from __future__ import annotations
import sys as _sys
import warnings as _warnings
import io as _io
import os as _os
import ssl as _ssl

from typing import Any, Callable, Dict, ItemsView, Iterable, Iterator, KeysView, List, Mapping, MutableMapping, MutableSequence, MutableSet, Optional, Set, Tuple, Type, TypeVar, Union, ValuesView
_T = TypeVar('_T')
_ElemType = TypeVar('_ElemType')
_KeyType = TypeVar('_KeyType')
_ValueType = TypeVar('_ValueType')
_ValueType = TypeVar('_ValueType')
_EngineSubsystemTypeVar = TypeVar('_EngineSubsystemTypeVar', bound='EngineSubsystem')
_EditorSubsystemTypeVar  = TypeVar('_EditorSubsystemTypeVar', bound='EditorSubsystem')

##### Glue Code #####

def log(arg: Any) -> None:
    r"""
    log(arg: Any) -> None -- log the given argument as information in the LogPython category
    """
    ...

def log_warning(arg: Any) -> None:
    r"""
    log_warning(arg: Any) -> None -- log the given argument as a warning in the LogPython category
    """
    ...

def log_error(arg: Any) -> None:
    r"""
    log_error(arg: Any) -> None -- log the given argument as an error in the LogPython category
    """
    ...

def log_flush() -> None:
    r"""
    log_flush() -> None -- flush the log to disk.
    """
    ...

def reload(module: str) -> None:
    r"""
    reload(module: str) -> None -- reload the given Unreal Python module.
    """
    ...

def load_module(module: str) -> None:
    r"""
    load_module(module: str) -> None -- load the given Unreal module and generate any Python code for its reflected types
    """
    ...

def new_object(type: Union[Class, type], outer: Optional[Object] = None, name: Union[Name, str] = "", base_type: Optional[Object] = None) -> Any:
    r"""
    new_object(type: Union[Class, type], outer: Optional[Object]=None, name: Union[Name, str]="", base_type: Optional[Object]=None) -> Any -- create an Unreal object of the given class (and optional outer and name), optionally validating its type
    """
    ...

def find_object(outer: Optional[Object], name: str, type: Union[Class, type] = Object.static_class(), follow_redirectors: bool = True) -> Any:
    r"""
    find_object(outer: Optional[Object], name: str, type: Union[Class, type]=Object.static_class(), follow_redirectors: bool=True) -> Any -- find an already loaded Unreal object with the given outer and name, optionally validating its type
    """
    ...

def load_object(outer: Optional[Object], name: str, type: Union[Class, type] = Object.static_class(), follow_redirectors: bool = True) -> Any:
    r"""
    load_object(outer: Optional[Object], name: str, type: Union[Class, type]=Object.static_class(), follow_redirectors: bool=True) -> Any -- load an Unreal object with the given outer and name, optionally validating its type
    """
    ...

def load_class(outer: Optional[Object], name: str, type: Union[Class, type] = Object.static_class()) -> Optional[Class]:
    r"""
    load_class(outer: Optional[Object], name: str, type: Union[Class, type]=Object.static_class()) -> Optional[Class] -- load an Unreal class with the given outer and name, optionally validating its base type
    """
    ...

def find_asset(name: str, type: Union[Class, type] = Object.static_class(), follow_redirectors: bool = True) -> Any:
    r"""
    find_asset(name: str, type: Union[Class, type]=Object.static_class(), follow_redirectors: bool = True) -> Any -- find an already loaded Unreal asset with the given name, optionally validating its type
    """
    ...

def load_asset(name: str, type: Union[Class, type] = Object.static_class(), follow_redirectors: bool = True) -> Any:
    r"""
    load_asset(name: str, type: Union[Class, type]=Object.static_class(), follow_redirectors: bool = True) -> Any -- load an Unreal asset with the given name, optionally validating its type
    """
    ...

def find_package(name: str) -> Optional[Package]:
    r"""
    find_package(name: str) -> Optional[Package] -- find an already loaded Unreal package with the given name
    """
    ...

def load_package(name: str) -> Optional[Package]:
    r"""
    load_package(name: str) -> Optional[Package] -- load an Unreal package with the given name
    """
    ...

def get_default_object(type: Union[Class, type]) -> Any:
    r"""
    get_default_object(type: Union[Class, type]) -> Any -- get the Unreal class default object (CDO) of the given type
    """
    ...

def purge_object_references(obj: Object, include_inners: bool = True) -> None:
    r"""
    purge_object_references(obj: Object, include_inners: bool = True) -> None -- purge all references to the given Unreal object from any living Python objects
    """
    ...

def generate_class(class_type: type) -> None:
    r"""
    generate_class(class_type: type) -> None -- generate an Unreal class for the given Python type
    """
    ...

def generate_struct(struct_type: type) -> None:
    r"""
    generate_struct(struct_type: type) -> None -- generate an Unreal struct for the given Python type
    """
    ...

def generate_enum(enum_type: type) -> None:
    r"""
    generate_enum(enum_type: type) -> None -- generate an Unreal enum for the given Python type
    """
    ...

def flush_generated_type_reinstancing() -> None:
    r"""
    flush_generated_type_reinstancing() -> None -- flush any pending reinstancing requests for Python generated types
    """
    ...

def get_type_from_class(class_: Class) -> type:
    r"""
    get_type_from_class(class_: Class) -> type -- get the best matching Python type for the given Unreal class
    """
    ...

def get_type_from_struct(struct: Struct) -> type:
    r"""
    get_type_from_struct(struct: Struct) -> type -- get the best matching Python type for the given Unreal struct
    """
    ...

def get_type_from_enum(enum: Enum) -> type:
    r"""
    get_type_from_enum(enum: Enum) -> type -- get the best matching Python type for the given Unreal enum
    """
    ...

def register_python_shutdown_callback(callable: Callable[[], None]) -> object:
    r"""
    register_python_shutdown_callback(callable: Callable[[], None]) -> object -- register the given callable (with no input arguments) as a callback to execute immediately before Python shutdown
    """
    ...

def unregister_python_shutdown_callback(handle: object) -> None:
    r"""
    unregister_python_shutdown_callback(handle: object) -> None -- unregister the given handle from a previous call to register_python_shutdown_callback
    """
    ...

def NSLOCTEXT(ns: str, key: str, source: str) -> Text:
    r"""
    NSLOCTEXT(ns: str, key: str, source: str) -> Text -- create a localized Text from the given namespace, key, and source string
    """
    ...

def LOCTABLE(id: Union[Name, str], key: str) -> Text:
    r"""
    LOCTABLE(id: Union[Name, str], key: str) -> Text -- get a localized Text from the given string table id and key
    """
    ...

def is_editor() -> bool:
    r"""
    is_editor() -> bool -- tells if the editor is running or not
    """
    ...

def get_interpreter_executable_path() -> str:
    r"""
    get_interpreter_executable_path() -> str -- get the path to the Python interpreter executable of the Python SDK this plugin was compiled against
    """
    ...

def create_python_object_handle(obj: Optional[Any]) -> Optional[PythonObjectHandle]:
    r"""
    create_python_object_handle(obj: Optional[Any]) -> Optional[PythonObjectHandle] -- create a PythonObjectHandle from the given PyObject
    """
    ...

def resolve_python_object_handle(handle: Optional[PythonObjectHandle]) -> Optional[Any]:
    r"""
    resolve_python_object_handle(handle: Optional[PythonObjectHandle]) -> Optional[Any] -- resolve a PythonObjectHandle to its PyObject, or None
    """
    ...

def destroy_python_object_handle(*args):
    r"""
    destroy_python_object_handle(handle: Optional[PythonObjectHandle]) -- destroy a PythonObjectHandle (clearing its PyObject reference)
    """
    ...

class ScopedSlowTask(object):
    r"""
    Type used to create and managed a scoped slow task in Python
    """
    def __init__(self, work: float, desc: Union[Text, str] = "", enabled: bool = True) -> None:
        ...
    def __enter__(self) -> ScopedSlowTask:
        r"""
        __enter__(self) -> ScopedSlowTask -- begin this slow task
        """
        ...
    def __exit__(self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]) -> bool:
        r"""
        __exit__(self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]) -> bool -- end this slow task
        """
        ...
    def make_dialog_delayed(self, delay: float, can_cancel: bool = False, allow_in_pie: bool = False) -> None:
        r"""
        make_dialog_delayed(self, delay: float, can_cancel: bool = False, allow_in_pie: bool = False) -> None -- creates a new dialog for this slow task after the given time delay (in seconds). If the task completes before this time, no dialog will be shown
        """
        ...
    def make_dialog(self, can_cancel: bool = False, allow_in_pie: bool = False) -> None:
        r"""
        make_dialog(self, can_cancel: bool = False, allow_in_pie: bool = False) -> None -- creates a new dialog for this slow task, if there is currently not one open
        """
        ...
    def enter_progress_frame(self, work: float = 1.0, desc: Union[Text, str] = "") -> None:
        r"""
        enter_progress_frame(self, work: float = 1.0, desc: Union[Text, str] = "") -> None -- indicate that we are to enter a frame that will take up the specified amount of work (completes any previous frames)
        """
        ...
    def should_cancel(self) -> bool:
        r"""
        x.should_cancel() -> bool -- True if the user has requested that the slow task be canceled
        """
        ...

class ObjectIterator(object):
    r"""
    Type for iterating Unreal Object instances
    """
    def __init__(self, type: Union[Class, type] = ...) -> None:
        ...
    def __iter__(self) -> Iterator[Any]:
        ...

class ClassIterator(object):
    r"""
    Type for iterating Unreal class types
    """
    def __init__(self, type: type) -> None:
        ...
    def __iter__(self) -> Iterator[Class]:
        ...

class StructIterator(object):
    r"""
    Type for iterating Unreal struct types
    """
    def __init__(self, type: type) -> None:
        ...
    def __iter__(self) -> Iterator[ScriptStruct]:
        ...

class TypeIterator(object):
    r"""
    Type for iterating Python types
    """
    def __init__(self, type: type) -> None:
        ...
    def __iter__(self) -> Iterator[type]:
        ...

class ValueDef(object):
    r"""
    Type used to define constant values from Python
    """
    def __init__(self, val: object, meta: Optional[Dict[str, str]]) -> None:
        ...

class PropertyDef(object):
    r"""
    Type used to define FProperty fields from Python
    """
    def __init__(self, type: type, meta: Optional[Dict[str, str]], getter: Optional[str], setter: Optional[str]) -> None:
        ...

class FunctionDef(object):
    r"""
    Type used to define UFunction fields from Python
    """
    def __init__(self, func: Any, meta: Optional[Dict[str, str]], ret: Optional[Any], params: Optional[Sequence[Any]], override: Optional[bool], static: Optional[bool], pure: Optional[bool], getter: Optional[bool], setter: Optional[bool]) -> None:
        ...

class _WrapperBase(object):
    r"""
    Base type for all Unreal exposed types
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class _ObjectBase(_WrapperBase):
    r"""
    Type for all Unreal exposed object instances
    """
    def __init__(self, outer: Optional[Object] = None, name: Union[Name, str]="None") -> None:
        ...
    def _post_init(self) -> None:
        r"""
        _post_init(self) -> None -- called during Unreal object initialization (equivalent to PostInitProperties in C++)
        """
        ...
    @classmethod
    def cast(cls: Type[_T], object: object) -> _T:
        r"""
        cast(cls: Type[_T], object: object) -> _T -- cast the given object to this Unreal object type or raise an exception if the cast is not possible
        """
        ...
    @classmethod
    def get_default_object(cls: Type[_T]) -> _T:
        r"""
        get_default_object(cls: Type[_T]) -> _T -- get the Unreal class default object (CDO) of this type
        """
        ...
    @classmethod
    def static_class(cls) -> Class:
        r"""
        static_class(cls) -> Class -- get the Unreal class of this type
        """
        ...
    def get_class(self) -> Class:
        r"""
        get_class(self) -> Class -- get the Unreal class of this instance
        """
        ...
    def get_outer(self) -> Any:
        r"""
        get_outer(self) -> Any -- get the outer object from this instance (if any)
        """
        ...
    def get_typed_outer(self, type: Union[Class, type]) -> Any:
        r"""
        get_typed_outer(self, type: Union[Class, type]) -> Any -- get the first outer object of the given type from this instance (if any)
        """
        ...
    def get_outermost(self) -> Package:
        r"""
        get_outermost(self) -> Package -- get the outermost object (the package) from this instance
        """
        ...
    def is_package_external(self) -> bool:
        r"""
        is_package_external(self) -> bool -- returns true if this instance has a different package than its outer's package
        """
        ...
    def get_package(self) -> Package:
        r"""
        get_package(self) -> Package -- get the package directly associated with this instance
        """
        ...
    def get_name(self) -> str:
        r"""
        get_name(self) -> str -- get the name of this instance
        """
        ...
    def get_fname(self) -> Name:
        r"""
        get_fname(self) -> Name -- get the name of this instance
        """
        ...
    def get_full_name(self) -> str:
        r"""
        get_full_name(self) -> str -- get the full name (class name + full path) of this instance
        """
        ...
    def get_path_name(self) -> str:
        r"""
        get_path_name(self) -> str -- get the path name of this instance
        """
        ...
    def get_world(self) -> Optional[World]:
        r"""
        get_world(self) -> Optional[World] -- get the world associated with this instance (if any)
        """
        ...
    def modify(self, always_mark_dirty: bool = True) -> bool:
        r"""
        modify(self, always_mark_dirty: bool = True) -> bool -- inform that this instance is about to be modified (tracks changes for undo/redo if transactional)
        """
        ...
    def rename(self, name: Union[Name, str] = "None", outer: Optional[Object] = None) -> bool:
        r"""
        rename(self, name: Union[Name, str]="None", outer: Optional[Object]=None) -> bool -- rename this instance and/or change its outer
        """
        ...
    def get_editor_property(self, name: str) -> object:
        r"""
        get_editor_property(self, name: str) -> object -- get the value of any property visible to the editor
        """
        ...
    def set_editor_property(self, name: str, value: object, notify_mode: PropertyAccessChangeNotifyMode = PropertyAccessChangeNotifyMode.DEFAULT) -> None:
        r"""
        set_editor_property(self, name: str, value: object, notify_mode: PropertyAccessChangeNotifyMode=PropertyAccessChangeNotifyMode.DEFAULT) -> None -- set the value of any property visible to the editor, ensuring that the pre/post change notifications are called
        """
        ...
    def set_editor_properties(self, properties: Mapping[str, object]) -> None:
        r"""
        set_editor_properties(self, properties: Mapping[str, object]) -> None -- set the value of any properties visible to the editor (from a name->value dict), ensuring that the pre/post change notifications are called
        """
        ...
    def call_method(self, name: str, *args: Tuple[object, ...], **kwargs: Mapping[str, object]) -> Any:
        r"""
        call_method(self, name: str, *args: Tuple[object, ...], **kwargs: Mapping[str, object]) -> Any -- call a method on this object via Unreal reflection using the given ordered (a tuple passed as args) or named (a dict passed as kwargs) argument data - allows calling methods that don't have Python glue
        """
        ...

class StructBase(_WrapperBase):
    r"""
    Type for all Unreal exposed struct instances
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    def _post_init(self) -> None:
        r"""
        _post_init(self) -> None -- called during Unreal struct initialization (equivalent to PostInitProperties in C++)
        """
        ...
    @classmethod
    def cast(cls: Type[_T], object: Union[object, Mapping[str, object], Iterable[object]]) -> _T:
        r"""
        cast(cls: Type[_T], object: Union[object, Mapping[str, object], Iterable[object]]) -> _T -- cast the given object to this Unreal struct type. Can be partial Mapping[fieldName, fiedValue] or a sequence of field values
        """
        ...
    @classmethod
    def static_struct(cls) -> ScriptStruct:
        r"""
        static_struct(cls) -> ScriptStruct -- get the Unreal struct of this type
        """
        ...
    def __copy__(self) -> Any:
        r"""
        __copy__(self) -> Any -- copy this Unreal struct
        """
        ...
    def copy(self) -> Any:
        r"""
        copy(self) -> Any -- copy this Unreal struct
        """
        ...
    def assign(self, other: object) -> None:
        r"""
        assign(self, other: object) -> None -- assign the value of this Unreal struct to value of the given object
        """
        ...
    def to_tuple(self) -> Tuple[object, ...]:
        r"""
        to_tuple(self) -> Tuple[object, ...] -- break this Unreal struct into a tuple of its properties
        """
        ...
    def get_editor_property(self, name: Union[Name, str]) -> object:
        r"""
        get_editor_property(self, name: Union[Name, str]) -> object -- get the value of any property visible to the editor
        """
        ...
    def set_editor_property(self, name: Union[Name, str], value: object, notify_mode: PropertyAccessChangeNotifyMode = PropertyAccessChangeNotifyMode.DEFAULT) -> None:
        r"""
        set_editor_property(self, name: Union[Name, str], value: object, notify_mode: PropertyAccessChangeNotifyMode=PropertyAccessChangeNotifyMode.DEFAULT) -> None -- set the value of any property visible to the editor, ensuring that the pre/post change notifications are called
        """
        ...
    def set_editor_properties(self, properties: Mapping[str, object]) -> None:
        r"""
        set_editor_properties(self, properties: Mapping[str, object]) -> None -- set the value of any properties visible to the editor (from a name->value dict), ensuring that the pre/post change notifications are called
        """
        ...
    def export_text(self) -> str:
        r"""
        export_text(self) -> str -- exports the content of the Unreal struct of this type
        """
        ...
    def import_text(self, content: str) -> bool:
        r"""
        import_text(self, content: str) -> bool -- imports the provided string into the Unreal struct
        """
        ...

class EnumBase(_WrapperBase):
    r"""
    Type for all Unreal exposed enum instances
    """
    def __init__(self) -> None:
        ...
    @classmethod
    def cast(cls: Type[_T], object: object) -> _T:
        r"""
        cast(cls: Type[_T], object: object) -> _T -- cast the given object to this Unreal enum type
        """
        ...
    @classmethod
    def static_enum(cls) -> Enum:
        r"""
        static_enum(cls) -> Enum -- get the Unreal enum of this type
        """
        ...
    def get_display_name(self) -> Text:
        r"""
        get_display_name(self) -> Text -- get the UMETA display name of this type in the current culture
        """
        ...

class _EnumEntry(object):
    def __init__(self, enum: Any, name: str, value: int) -> None:
        self.enum = enum
        self.name = name
        self.value = value
    def __get__(self, obj, type=None):
        return self
    def __repr__(self):
        return "{0}.{1}".format(self.enum, self.name)
    @property
    def __name__(self):
        ...
    @__name__.setter
    def __name__(self, value) -> None:
        ...
    @property
    def __doc__(self):
        ...
    @__doc__.setter
    def __doc__(self, value) -> None:
        ...

class DelegateBase(_WrapperBase):
    r"""
    Type for all Unreal exposed delegate instances
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @classmethod
    def cast(cls: Type[_T], object: object) -> _T:
        r"""
        cast(cls: Type[_T], object: object) -> _T -- cast the given object to this Unreal delegate type
        """
        ...
    def __copy__(self) -> Any:
        r"""
        __copy__(self) -> Any -- copy this Unreal delegate
        """
        ...
    def copy(self) -> Any:
        r"""
        copy(self) -> Any -- copy this Unreal delegate
        """
        ...
    def is_bound(self) -> bool:
        r"""
        is_bound(self) -> bool -- is this Unreal delegate bound to something?
        """
        ...
    def bind_delegate(self, delegate: DelegateBase) -> None:
        r"""
        bind_delegate(self, delegate: DelegateBase) -> None -- bind this Unreal delegate to the same object and function as another delegate
        """
        ...
    def bind_function(self, obj: Object, name: Union[Name, str]) -> None:
        r"""
        bind_function(self, obj: Object, name: Union[Name, str]) -> None -- bind this Unreal delegate to a named Unreal function on the given object instance
        """
        ...
    def bind_callable(self, callable: Callable[..., Any]) -> None:
        r"""
        bind_callable(self, callable: Callable[..., Any]) -> None -- bind this Unreal delegate to a Python callable
        """
        ...
    def unbind(self) -> None:
        r"""
        unbind(self) -> None -- unbind this Unreal delegate
        """
        ...
    def execute(self, *args: Any) -> Any:
        r"""
        execute(self, *args: Any) -> Any -- call this Unreal delegate, but error if it's unbound
        """
        ...
    def execute_if_bound(self, *args: Any) -> Any:
        r"""
        x.execute_if_bound(self, *args: Any) -> Any -- call this Unreal delegate, but only if it's bound to something
        """
        ...

class MulticastDelegateBase(_WrapperBase):
    r"""
    Type for all Unreal exposed multicast delegate instances
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @classmethod
    def cast(cls: Type[_T], object: object) -> _T:
        r"""
        cast(cls: Type[_T], object: object) -> _T -- cast the given object to this Unreal delegate type
        """
        ...
    def __copy__(self) -> Any:
        r"""
        __copy__(self) -> Any -- copy this Unreal delegate
        """
        ...
    def copy(self) -> Any:
        r"""
        copy(self) -> Any -- copy this Unreal delegate
        """
        ...
    def is_bound(self) -> bool:
        r"""
        is_bound(self) -> bool -- is this Unreal delegate bound to something?
        """
        ...
    def add_function(self, obj: Object, name: Union[Name, str]) -> None:
        r"""
        add_function(self, obj: Object, name: Union[Name, str]) -> None -- add a binding to a named Unreal function on the given object instance to the invocation list of this Unreal delegate
        """
        ...
    def add_callable(self, callable: Callable[..., Any]) -> None:
        r"""
        add_callable(self, callable: Callable[..., Any]) -> None -- add a binding to a Python callable to the invocation list of this Unreal delegate
        """
        ...
    def add_function_unique(self, obj: Object, name: Union[Name, str]) -> None:
        r"""
        add_function_unique(self, obj: Object, name: Union[Name, str]) -> None -- add a unique binding to a named Unreal function on the given object instance to the invocation list of this Unreal delegate
        """
        ...
    def add_callable_unique(self, callable: Callable[..., Any]) -> None:
        r"""
        add_callable_unique(self, callable: Callable[..., Any]) -> None -- add a unique binding to a Python callable to the invocation list of this Unreal delegate
        """
        ...
    def remove_function(self, obj: Object, name: Union[Name, str]) -> None:
        r"""
        remove_function(self, obj: Object, name: Union[Name, str]) -> None -- remove a binding to a named Unreal function on the given object instance from the invocation list of this Unreal delegate
        """
        ...
    def remove_callable(self, callable: Callable[..., Any]) -> None:
        r"""
        remove_callable(self, callable: Callable[..., Any]) -> None -- remove a binding to a Python callable from the invocation list of this Unreal delegate
        """
        ...
    def remove_object(self, obj: Object) -> None:
        r"""
        remove_object(self, obj: Object) -> None -- remove all bindings for the given object instance from the invocation list of this Unreal delegate
        """
        ...
    def contains_function(self, obj: Object, name: Union[Name, str]) -> bool:
        r"""
        contains_function(self, obj: Object, name: Union[Name, str]) -> bool -- does the invocation list of this Unreal delegate contain a binding to a named Unreal function on the given object instance
        """
        ...
    def contains_callable(self, callable: Callable[..., Any]) -> bool:
        r"""
        contains_callable(self, callable: Callable[..., Any]) -> bool -- does the invocation list of this Unreal delegate contain a binding to a Python callable
        """
        ...
    def clear(self) -> None:
        r"""
        x.clear() -> None -- clear the invocation list of this Unreal delegate
        """
        ...
    def broadcast(self, *args: Any) -> None:
        r"""
        x.broadcast(*args: Any) -> None -- invoke this Unreal multicast delegate
        """
        ...

class Name(_WrapperBase):
    r"""
    Type for all Unreal exposed name instances
    """
    def __init__(self, value: Union[Name, str] = "None") -> None:
        ...
    @classmethod
    def cast(cls, object: object) -> Name:
        r"""
        cast(cls, object: object) -> Name -- cast the given object to this Unreal name type
        """
        ...
    def is_valid(self) -> bool:
        r"""
        is_valid(self) -> bool -- is this Unreal name valid?
        """
        ...
    def is_none(self) -> bool:
        r"""
        is_none(self) -> bool -- is this Unreal name set to NAME_None?
        """
        ...

class Text(_WrapperBase):
    r"""
    Type for all Unreal exposed text instances
    """
    def __init__(self, value: Union[Text, str] = "") -> None:
        ...
    @classmethod
    def cast(cls, object: object) -> Text:
        r"""
        cast(cls, object: object) -> Text -- cast the given object to this Unreal text type
        """
        ...
    @classmethod
    def as_number(cls, num: float) -> Text:
        r"""
        as_number(cls, num: float) -> Text -- convert the given number to a culture correct Unreal text representation
        """
        ...
    @classmethod
    def as_percent(cls, num: float) -> Text:
        r"""
        as_percent(cls, num: float) -> Text -- convert the given number to a culture correct Unreal text percentgage representation
        """
        ...
    @classmethod
    def as_currency(cls, val: int, code: str) -> Text:
        r"""
        as_currency(cls, val: int, code: str) -> Text -- convert the given number (specified in the smallest unit for the given currency i.e. 650 for $6.50) to a culture correct Unreal text currency representation
        """
        ...
    def is_empty(self) -> bool:
        r"""
        is_empty(self) -> bool -- is this Unreal text empty?
        """
        ...
    def is_empty_or_whitespace(self) -> bool:
        r"""
        is_empty_or_whitespace(self) -> bool -- is this Unreal text empty or only whitespace?
        """
        ...
    def is_transient(self) -> bool:
        r"""
        is_transient(self) -> bool -- is this Unreal text transient?
        """
        ...
    def is_culture_invariant(self) -> bool:
        r"""
        is_culture_invariant(self) -> bool -- is this Unreal text culture invariant?
        """
        ...
    def is_from_string_table(self) -> bool:
        r"""
        is_from_string_table(self) -> bool -- is this Unreal text referencing a string table entry?
        """
        ...
    def to_lower(self) -> Text:
        r"""
        to_lower(self) -> Text -- convert this Unreal text to lowercase in a culture correct way
        """
        ...
    def to_upper(self) -> Text:
        r"""
        to_upper(self) -> Text -- convert this Unreal text to uppercase in a culture correct way
        """
        ...
    def format(self, *args: Union[Mapping[str, object], object], **named_args: object) -> Text:
        r"""
        format(self, *args: Union[Mapping[str, object], object], **named_args: object) -> Text -- use this Unreal text as a format pattern and generate a new text using the format arguments (may be a mapping[arg_name, arg] or comma separed (optionally named) arguments)
        """
        ...

class Array(_WrapperBase, MutableSequence[_ElemType]):
    r"""
    Type for all Unreal exposed array instances
    """
    def __init__(self, type: type) -> None:
        ...
    def __setitem__(self, index: int, value: _ElemType) -> None:
        ...
    def __getitem__(self, index: int) -> _ElemType:
        ...
    @classmethod
    def __class_getitem__(cls, *args):
        r"""
        __class_getitem__(cls, item: _ElemType) -- implemented for type hinting purpose only
        """
        ...
    @classmethod
    def cast(cls, type: Type[_ElemType], obj: object) -> Array[_ElemType]:
        r"""
        cast(cls, type: Type[_ElemType], obj: object) -> Array[_ElemType] -- cast the given object to this Unreal array type
        """
        ...
    def __copy__(self) -> Array[_ElemType]:
        r"""
        __copy__(self) -> Array[_ElemType] -- copy this Unreal array
        """
        ...
    def copy(self) -> Array[_ElemType]:
        r"""
        copy(self) -> Array[_ElemType] -- copy this Unreal array
        """
        ...
    def append(self, value: _ElemType) -> None:
        r"""
        append(self, value: _ElemType) -> None -- append the given value to the end of this Unreal array (equivalent to TArray::Add in C++)
        """
        ...
    def count(self, value: _ElemType) -> int:
        r"""
        count(self, value: _ElemType) -> int -- return the number of times that value appears in this this Unreal array
        """
        ...
    def extend(self, values: Iterable[_ElemType]) -> None:
        r"""
        extend(self, values: Iterable[_ElemType]) -> None -- extend this Unreal array by appending elements from the given iterable (equivalent to TArray::Append in C++)
        """
        ...
    def index(self, value: _ElemType, start: int = 0, stop: int = -1) -> int:
        r"""
        index(self, value: _ElemType, start: int = 0, stop: int = -1) -> int -- get the index of the first matching value in this Unreal array, or raise ValueError if missing (equivalent to TArray::IndexOfByKey in C++)
        """
        ...
    def insert(self, index: int, value: _ElemType) -> None:
        r"""
        insert(self, index: int, value: _ElemType) -> None -- insert the given value at the given index in this Unreal array
        """
        ...
    def pop(self, index: int = -1) -> _ElemType:
        r"""
        pop(self, index: int = -1) -> _ElemType -- remove and return the value at the given index in this Unreal array, or raise IndexError if the index is out-of-bounds
        """
        ...
    def remove(self, value: _ElemType) -> None:
        r"""
        remove(self, value: _ElemType) -> None -- remove the first matching value in this Unreal array, or raise ValueError if missing
        """
        ...
    def reverse(self) -> None:
        r"""
        reverse(self) -> None -- reverse this Unreal array in-place
        """
        ...
    def sort(self, key: Optional[Callable[[_ElemType], object]] = None, reverse: bool = False) -> None:
        r"""
        sort(self, key: Optional[Callable[[_ElemType], object]]=None, reverse: bool=False) -> None -- stable sort this Unreal array in-place
        """
        ...
    def resize(self, len: int) -> None:
        r"""
        resize(self, len: int) -> None -- resize this Unreal array to hold the given number of elements
        """
        ...

class FixedArray(_WrapperBase, MutableSequence[_ElemType]):
    r"""
    Type for all Unreal exposed fixed-array instances
    """
    def __init__(self, type: type, len: int) -> None:
        ...
    def __setitem__(self, index: int, value: _ElemType) -> None:
        ...
    def __getitem__(self, index: int) -> _ElemType:
        ...
    @classmethod
    def __class_getitem__(cls, *args):
        r"""
        __class_getitem__(cls, item: _ElemType) -- implemented for type hinting purpose only
        """
        ...
    @classmethod
    def cast(cls, type: Type[_ElemType], obj: object) -> FixedArray[_ElemType]:
        r"""
        cast(cls, type: Type[_ElemType], obj: object) -> FixedArray[_ElemType] -- cast the given object to this Unreal fixed-array type
        """
        ...
    def __copy__(self) -> FixedArray[_ElemType]:
        r"""
        __copy__(self) -> FixedArray[_ElemType] -- copy this Unreal fixed-array
        """
        ...
    def copy(self) -> FixedArray[_ElemType]:
        r"""
        copy(self) -> FixedArray[_ElemType] -- copy this Unreal fixed-array
        """
        ...

class Set(_WrapperBase, MutableSet[_ElemType]):
    r"""
    Type for all Unreal exposed set instances
    """
    def __init__(self, type: type) -> None:
        ...
    @classmethod
    def __class_getitem__(cls, *args):
        r"""
        __class_getitem__(cls, item: _ElemType) -- implemented for type hinting purpose only
        """
        ...
    @classmethod
    def cast(cls, type: Type[_ElemType], obj: object) -> Set[_ElemType]:
        r"""
        cast(cls, type: Type[_ElemType], obj: object) -> Set[_ElemType] -- cast the given object to this Unreal set type
        """
        ...
    def __copy__(self) -> Set[_ElemType]:
        r"""
        __copy__(self) -> Set[_ElemType] -- copy this Unreal set
        """
        ...
    def copy(self) -> Set[_ElemType]:
        r"""
        copy(self) -> Set[_ElemType] -- copy this Unreal set
        """
        ...
    def add(self, value: _ElemType) -> None:
        r"""
        add(self, value: _ElemType) -> None -- add the given value to this Unreal set if not already present
        """
        ...
    def discard(self, value: _ElemType) -> None:
        r"""
        discard(self, value: _ElemType) -> None -- remove the given value from this Unreal set, or do nothing if not present
        """
        ...
    def remove(self, value: _ElemType) -> None:
        r"""
        remove(self, value: _ElemType) -> None -- remove the given value from this Unreal set, or raise KeyError if not present
        """
        ...
    def pop(self) -> _ElemType:
        r"""
        pop(self) -> _ElemType -- remove and return an arbitrary value from this Unreal set, or raise KeyError if the set is empty
        """
        ...
    def clear(self) -> None:
        r"""
        clear(self) -> None -- remove all values from this Unreal set
        """
        ...
    def difference(self, *iterable: Iterable[_ElemType]) -> Set[_ElemType]:
        r"""
        difference(self, *iterable: Iterable[_ElemType]) -> Set[_ElemType] -- return the difference between this Unreal set and the other iterables passed for comparison (ie, all values that are in this set but not the others)
        """
        ...
    def difference_update(self, *iterables: Iterable[_ElemType]) -> None:
        r"""
        difference_update(self, *iterables: Iterable[_ElemType]) -> None -- make this set the difference between this Unreal set and the other iterables passed for comparison (ie, all values that are in this set but not the others)
        """
        ...
    def intersection(self, *iterables: Iterable[_ElemType]) -> Set[_ElemType]:
        r"""
        intersection(self, *iterables: Iterable[_ElemType]) -> Set[_ElemType] -- return the intersection between this Unreal set and the other iterables passed for comparison (ie, values that are common to all of the sets)
        """
        ...
    def intersection_update(self, *iterables: Iterable[_ElemType]) -> None:
        r"""
        intersection_update(self, *iterables: Iterable[_ElemType]) -> None -- make this set the intersection between this Unreal set and the other iterables passed for comparison (ie, values that are common to all of the sets)
        """
        ...
    def symmetric_difference(self, other: Iterable[_ElemType]) -> Set[_ElemType]:
        r"""
        symmetric_difference(self, other: Iterable[_ElemType]) -> Set[_ElemType] -- return the symmetric difference between this Unreal set and another (ie, values that are in exactly one of the sets)
        """
        ...
    def symmetric_difference_update(self, other: Iterable[_ElemType]) -> None:
        r"""
        symmetric_difference_update(self, other: Iterable[_ElemType]) -> None -- make this set the symmetric difference between this Unreal set and another (ie, values that are in exactly one of the sets)
        """
        ...
    def union(self, *iterables: Iterable[_ElemType]) -> Set[_ElemType]:
        r"""
        union(self, *iterables: Iterable[_ElemType]) -> Set[_ElemType] -- return the union between this Unreal set and the other iterables passed for comparison (ie, values that are in any set)
        """
        ...
    def update(self, *iterables: Iterable[_ElemType]) -> None:
        r"""
        update(self, *iterables: Iterable[_ElemType]) -> None -- make this set the union between this Unreal set and the other iterables passed for comparison (ie, values that are in any set)
        """
        ...
    def isdisjoint(self, other: Iterable[_ElemType]) -> bool:
        r"""
        isdisjoint(self, other: Iterable[_ElemType]) -> bool -- return True if there is a null intersection between this Unreal set and another
        """
        ...
    def issubset(self, other: Iterable[_ElemType]) -> bool:
        r"""
        issubset(self, other: Iterable[_ElemType]) -> bool -- return True if another set contains this Unreal set
        """
        ...
    def issuperset(self, other: Iterable[_ElemType]) -> bool:
        r"""
        issuperset(self, other: Iterable[_ElemType]) -> bool -- return True if this Unreal set contains another
        """
        ...

class Map(_WrapperBase, MutableMapping[_KeyType, _ValueType]):
    r"""
    Type for all Unreal exposed map instances
    """
    def __init__(self, key: type, value: type) -> None:
        ...
    def __setitem__(self, key: _KeyType, value: _ValueType) -> None:
        ...
    def __getitem__(self, key: _KeyType) -> _ValueType:
        ...
    @classmethod
    def __class_getitem__(cls, *args):
        r"""
        __class_getitem__(cls, item) -- implemented for type hinting purpose only
        """
        ...
    @classmethod
    def cast(cls, key: Type[_KeyType], value: Type[_ValueType], obj: object) -> Map[_KeyType, _ValueType]:
        r"""
        cast(cls, key: Type[_KeyType], value: Type[_ValueType], obj: object) -> Map[_KeyType, _ValueType] -- cast the given object to this Unreal map type
        """
        ...
    def __copy__(self) -> Map[_KeyType, _ValueType]:
        r"""
        __copy__(self) -> Map[_KeyType, _ValueType] -- copy this Unreal map
        """
        ...
    def copy(self) -> Map[_KeyType, _ValueType]:
        r"""
        copy(self) -> Map[_KeyType, _ValueType] -- copy this Unreal map
        """
        ...
    def clear(self) -> None:
        r"""
        clear(self) -> None -- remove all items from this Unreal map
        """
        ...
    @classmethod
    def fromkeys(cls, sequence: Iterable[_KeyType], value: _ValueType) -> Map[_KeyType, _ValueType]:
        r"""
        fromkeys(cls, sequence: Iterable[_KeyType], value: _ValueType) -> Map[_KeyType, _ValueType] -- returns a new Unreal map of keys from the sequence using the given value (types are inferred)
        """
        ...
    def get(self, key: _KeyType, default: _ValueType = ...) -> _ValueType:
        r"""
        get(self, key: _KeyType, default: _ValueType=...) -> _ValueType -- x[key] if key in x, otherwise default
        """
        ...
    def setdefault(self, key: _KeyType, default: _ValueType = ...) -> _ValueType:
        r"""
        setdefault(self, key: _KeyType, default: _ValueType=...) -> _ValueType -- set key to default if key not in x and return the value of key
        """
        ...
    def pop(self, key: _KeyType, default: _ValueType = ...) -> _ValueType:
        r"""
        pop(self, key: _KeyType, default: _ValueType=...) -> _ValueType -- remove key and return its value, or default if key not present, or raise KeyError if no default
        """
        ...
    def popitem(self) -> Tuple[_KeyType, _ValueType]:
        r"""
        popitem(self) -> Tuple[_KeyType, _ValueType] -- remove and return an arbitrary pair from this Unreal map, or raise KeyError if the map is empty
        """
        ...
    def update(self, pairs: Union[Mapping[_KeyType, _ValueType], Iterable[Tuple[_KeyType, _ValueType]], Iterable[List[Union[_KeyType, _ValueType]]]]) -> None:
        r"""
        update(self, pairs: Union[Mapping[_KeyType, _ValueType], Iterable[Tuple[_KeyType, _ValueType]], Iterable[List[Union[_KeyType, _ValueType]]]]) -> None -- update this Unreal map from the given mapping or sequence pairs type or key->value arguments
        """
        ...
    def items(self) -> ItemsView[_KeyType, _ValueType]:
        r"""
        items(self) -> ItemsView[_KeyType, _ValueType] -- a set-like view of the key->value pairs of this Unreal map
        """
        ...
    def keys(self) -> KeysView[_KeyType]:
        r"""
        keys(self) -> KeysView[_KeyType] -- a set-like view of the keys of this Unreal map
        """
        ...
    def values(self) -> ValuesView[_ValueType]:
        r"""
        values(self) -> ValuesView[_ValueType] -- a view of the values of this Unreal map
        """
        ...

class FieldPath(_WrapperBase):
    r"""
    Type for all Unreal exposed FieldPath instances
    """
    def __init__(self, value: Union[FieldPath, str] = "") -> None:
        ...
    @classmethod
    def cast(cls, obj: object) -> FieldPath:
        r"""
        cast(cls, obj: object) -> FieldPath -- cast the given object to this Unreal field path type
        """
        ...
    def __copy__(self) -> FieldPath:
        r"""
        __copy__(self) -> FieldPath -- copy this Unreal field path
        """
        ...
    def copy(self) -> FieldPath:
        r"""
        copy(self) -> FieldPath -- copy this Unreal field path
        """
        ...
    def is_valid(self) -> bool:
        r"""
        is_valid(self) -> bool -- whether this Unreal field path refers to an existing Unreal field
        """
        ...

def register_slate_pre_tick_callback(callable: Union[Callable[[float], None], DelegateBase]) -> object:
    r"""
    x.register_slate_pre_tick_callback(callable: Union[Callable[[float], None], DelegateBase]) -> object -- register the given callable (taking a single float) as a pre-tick callback in Slate
    """
    ...

def unregister_slate_pre_tick_callback(handle: object) -> None:
    r"""
    x.unregister_slate_pre_tick_callback(handle: object) -> None -- unregister the given handle from a previous call to register_slate_pre_tick_callback
    """
    ...

def register_slate_post_tick_callback(callable: Union[Callable[[float], None], DelegateBase]) -> object:
    r"""
    x.register_slate_post_tick_callback(callable: Union[Callable[[float], None], DelegateBase]) -> object -- register the given callable (taking a single float) as a pre-tick callback in Slate
    """
    ...

def unregister_slate_post_tick_callback(handle: object) -> None:
    r"""
    x.unregister_slate_post_tick_callback(handle: object) -> None -- unregister the given handle from a previous call to register_slate_post_tick_callback
    """
    ...

def parent_external_window_to_slate(external_window_handle: object, parent_search_method: SlateParentWindowSearchMethod = SlateParentWindowSearchMethod.ACTIVE_WINDOW) -> None:
    r"""
    x.parent_external_window_to_slate(external_window_handle: object, parent_search_method: SlateParentWindowSearchMethod = SlateParentWindowSearchMethod.ACTIVE_WINDOW) -> None -- parent the given OS specific external window handle to a suitable Slate window
    """
    ...

def get_blueprint_generated_types(paths: Iterable[str]) -> Optional[Union[type, Tuple[type, ...]]]:
    r"""
    get_blueprint_generated_types(paths: Iterable[str]) -> Optional[Union[type, Tuple[type, ...]]] -- get the Python types (will return a tuple for multiple types) for the given set of Blueprint asset paths (may be a sequence type or set of arguments)
    """
    ...

class ActorIterator(object):
    r"""
    Type for iterating Unreal actor instances
    """
    def __init__(self, world: World, type: Union[Class, type] = ...) -> None:
        ...
    def __iter__(self) -> Iterator[Any]:
        ...

class SelectedActorIterator(object):
    r"""
    Type for iterating selected Unreal actor instances
    """
    def __init__(self, world: World, type: Union[Class, type] = ...) -> None:
        ...
    def __iter__(self) -> Iterator[Any]:
        ...

def get_engine_subsystem(subsystem: Union[Class, type[_EngineSubsystemTypeVar]]) -> Optional[_EngineSubsystemTypeVar]:
    r"""
    get_engine_subsystem(subsystem : Union[Class, type[_EngineSubsystemTypeVar]]) -> Optional[_EngineSubsystemTypeVar] -- returns the requested Engine subsystem or None
    """
    ...

def get_editor_subsystem(subsystem: Union[Class, type[_EditorSubsystemTypeVar]]) -> Optional[_EditorSubsystemTypeVar]:
    r"""
    get_editor_subsystem(subsystem : Union[Class, type[_EditorSubsystemTypeVar]]) -> Optional[_EditorSubsystemTypeVar] -- returns the requested Editor subsystem or None
    """
    ...

class ScopedEditorTransaction(object):
    r"""
    Type used to create and managed a scoped editor transaction in Python
    """
    def __init__(self, desc: Union[Text, str]) -> None:
        ...
    def __enter__(self) -> ScopedEditorTransaction:
        r"""
        __enter__(self) -> ScopedEditorTransaction -- begin this transaction
        """
        ...
    def __exit__(self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]) -> bool:
        r"""
        __exit__(self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]) -> bool -- end this transaction
        """
        ...
    def cancel(self) -> None:
        r"""
        cancel(self) -> None -- cancel this transaction
        """
        ...

class RangeBoundTypes(EnumBase):
    r"""
    Enumerates the valid types of range bounds (mirrored from RangeBound.h)
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    EXCLUSIVE: RangeBoundTypes #: 0: The range excludes the bound.
    INCLUSIVE: RangeBoundTypes #: 1: The range includes the bound.
    OPEN: RangeBoundTypes #: 2: The bound is open.
    ...

class InputDeviceConnectionState(EnumBase):
    r"""
    Represents the connection status of a given FInputDeviceId
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    INVALID: InputDeviceConnectionState #: 0: This is not a valid input device
    UNKNOWN: InputDeviceConnectionState #: 1: It is not known if this device is connected or not
    DISCONNECTED: InputDeviceConnectionState #: 2: Device is definitely connected
    CONNECTED: InputDeviceConnectionState #: 3: Definitely connected and powered on
    ...

class LocalizedTextSourceCategory(EnumBase):
    r"""
    Categories of localized text (mirrored in LocalizedTextSourceTypes.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    GAME: LocalizedTextSourceCategory #: 0
    ENGINE: LocalizedTextSourceCategory #: 1
    EDITOR: LocalizedTextSourceCategory #: 2
    ...

class TextGender(EnumBase):
    r"""
    EText Gender
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetTextLibrary.h
    
    """

    MASCULINE: TextGender #: 0
    FEMININE: TextGender #: 1
    NEUTER: TextGender #: 2
    ...

class FormatArgumentType(EnumBase):
    r"""
    EFormat Argument Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetTextLibrary.h
    
    """

    INT: FormatArgumentType #: 0
    U_INT: FormatArgumentType #: 1
    FLOAT: FormatArgumentType #: 2
    DOUBLE: FormatArgumentType #: 3
    TEXT: FormatArgumentType #: 4
    GENDER: FormatArgumentType #: 5
    ...

class AnimDataModelNotifyType(EnumBase):
    r"""
    EAnim Data Model Notify Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    """

    BRACKET_OPENED: AnimDataModelNotifyType #: 0: Indicates a bracket has been opened. Type of payload: FBracketPayload
    BRACKET_CLOSED: AnimDataModelNotifyType #: 1: Indicates a bracket has been closed. Type of payload: FEmptyPayload
    TRACK_ADDED: AnimDataModelNotifyType #: 2: Indicates a new bone track has been added. Type of payload: FAnimationTrackAddedPayload
    TRACK_CHANGED: AnimDataModelNotifyType #: 3: Indicates the keys of a bone track have been changed. Type of payload: FAnimationTrackChangedPayload
    TRACK_REMOVED: AnimDataModelNotifyType #: 4: Indicates a bone track has been removed. Type of payload: FAnimationTrackRemovedPayload
    SEQUENCE_LENGTH_CHANGED: AnimDataModelNotifyType #: 5: Indicates the play length of the animated data has changed. Type of payload: FSequenceLengthChangedPayload
    FRAME_RATE_CHANGED: AnimDataModelNotifyType #: 6: Indicates the sampling rate of the animated data has changed. Type of payload: FFrameRateChangedPayload
    CURVE_ADDED: AnimDataModelNotifyType #: 7: Indicates a new curve has been added. Type of payload: FCurveAddedPayload
    CURVE_CHANGED: AnimDataModelNotifyType #: 8: Indicates a curve its data has been changed. Type of payload: FCurveChangedPayload
    CURVE_REMOVED: AnimDataModelNotifyType #: 9: Indicates a curve has been removed. Type of payload: FCurveRemovedPayload
    CURVE_FLAGS_CHANGED: AnimDataModelNotifyType #: 10: Indicates a curve its flags have changed. Type of payload: FCurveFlagsChangedPayload
    CURVE_RENAMED: AnimDataModelNotifyType #: 11: Indicates a curve has been renamed. Type of payload: FCurveRenamedPayload
    CURVE_SCALED: AnimDataModelNotifyType #: 12: Indicates a curve has been scaled. Type of payload: FCurveScaledPayload
    CURVE_COLOR_CHANGED: AnimDataModelNotifyType #: 13: Indicates a curve its color has changed. Type of payload: FCurveChangedPayload
    CURVE_COMMENT_CHANGED: AnimDataModelNotifyType #: 14: Indicates a curve has been removed. Type of payload: FCurveChangedPayload
    ATTRIBUTE_ADDED: AnimDataModelNotifyType #: 15: Indicates a new attribute has been added. Type of payload: FAttributeAddedPayload
    ATTRIBUTE_REMOVED: AnimDataModelNotifyType #: 16: Indicates a new attribute has been removed. Type of payload: FAttributeRemovedPayload
    ATTRIBUTE_CHANGED: AnimDataModelNotifyType #: 17: Indicates an attribute has been changed. Type of payload: FAttributeChangedPayload
    POPULATED: AnimDataModelNotifyType #: 18: Indicates the data model has been populated from the source UAnimSequence. Type of payload: FEmptyPayload
    RESET: AnimDataModelNotifyType #: 19: Indicates all data stored on the model has been reset. Type of payload: FEmptyPayload
    SKELETON_CHANGED: AnimDataModelNotifyType #: 20: Indicates that the skeleton changed. Type of payload: FEmptyPayload
    INVALID: AnimDataModelNotifyType #: 21
    ...

class TouchIndex(EnumBase):
    r"""
    The number of entries in ETouchIndex must match the number of touch keys defined in EKeys and NUM_TOUCH_KEYS above
    
    **C++ Source:**
    
    - **Module**: InputCore
    - **File**: InputCoreTypes.h
    
    """

    TOUCH1: TouchIndex #: 0
    TOUCH2: TouchIndex #: 1
    TOUCH3: TouchIndex #: 2
    TOUCH4: TouchIndex #: 3
    TOUCH5: TouchIndex #: 4
    TOUCH6: TouchIndex #: 5
    TOUCH7: TouchIndex #: 6
    TOUCH8: TouchIndex #: 7
    TOUCH9: TouchIndex #: 8
    TOUCH10: TouchIndex #: 9
    ...

class MovementMode(EnumBase):
    r"""
    Movement modes for Characters.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    MOVE_NONE: MovementMode #: 0: None (movement is disabled).
    MOVE_WALKING: MovementMode #: 1: Walking on a surface.
    MOVE_NAV_WALKING: MovementMode
    r"""
    2: Simplified walking on navigation data (e.g. navmesh).
    If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move.
    If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions.
    """

    MOVE_FALLING: MovementMode #: 3: Falling under the effects of gravity, such as after jumping or walking off the edge of a surface.
    MOVE_SWIMMING: MovementMode #: 4: Swimming through a fluid volume, under the effects of gravity and buoyancy.
    MOVE_FLYING: MovementMode #: 5: Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction.
    MOVE_CUSTOM: MovementMode #: 6: User-defined custom movement mode, including many possible sub-modes.
    ...

class AudioComponentPlayState(EnumBase):
    r"""
    Enum describing the audio component play state
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    """

    PLAYING: AudioComponentPlayState #: 0: If the sound is playing (i.e. not fading in, not fading out, not paused)
    STOPPED: AudioComponentPlayState #: 1: If the sound is not playing
    PAUSED: AudioComponentPlayState #: 2: If the sound is playing but paused
    FADING_IN: AudioComponentPlayState #: 3: If the sound is playing and fading in
    FADING_OUT: AudioComponentPlayState #: 4: If the sound is playing and fading out
    ...

class DataLayerRuntimeState(EnumBase):
    r"""
    EData Layer Runtime State
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayerInstance.h
    
    """

    UNLOADED: DataLayerRuntimeState #: 0: Unloaded
    LOADED: DataLayerRuntimeState #: 1: Loaded (meaning loaded but not visible)
    ACTIVATED: DataLayerRuntimeState #: 2: Activated (meaning loaded and visible)
    ...

class QuartzCommandDelegateSubType(EnumBase):
    r"""
    An enumeration for specifying different TYPES of delegates
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    """

    COMMAND_ON_FAILED_TO_QUEUE: QuartzCommandDelegateSubType #: 0: The command will not execute (i.e. Clock doesn't exist or PlayQuantized failed concurrency)
    COMMAND_ON_QUEUED: QuartzCommandDelegateSubType #: 1: The command has been passed to the Audio Render Thread
    COMMAND_ON_CANCELED: QuartzCommandDelegateSubType #: 2: The command was stopped before it could execute
    COMMAND_ON_ABOUT_TO_START: QuartzCommandDelegateSubType #: 3: execute off this to be in sync w/ sound starting
    COMMAND_ON_STARTED: QuartzCommandDelegateSubType #: 4: the command was just executed on the Audio Render Thrtead
    ...

class QuartzCommandQuantization(EnumBase):
    r"""
    An enumeration for specifying quantization for Quartz commands
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    """

    BAR: QuartzCommandQuantization #: 0: (dependent on time signature)
    BEAT: QuartzCommandQuantization #: 1: (dependent on time signature and Pulse Override)
    THIRTY_SECOND_NOTE: QuartzCommandQuantization #: 2
    SIXTEENTH_NOTE: QuartzCommandQuantization #: 3
    EIGHTH_NOTE: QuartzCommandQuantization #: 4
    QUARTER_NOTE: QuartzCommandQuantization #: 5
    HALF_NOTE: QuartzCommandQuantization #: 6
    WHOLE_NOTE: QuartzCommandQuantization #: 7
    DOTTED_SIXTEENTH_NOTE: QuartzCommandQuantization #: 8
    DOTTED_EIGHTH_NOTE: QuartzCommandQuantization #: 9
    DOTTED_QUARTER_NOTE: QuartzCommandQuantization #: 10
    DOTTED_HALF_NOTE: QuartzCommandQuantization #: 11
    DOTTED_WHOLE_NOTE: QuartzCommandQuantization #: 12
    SIXTEENTH_NOTE_TRIPLET: QuartzCommandQuantization #: 13
    EIGHTH_NOTE_TRIPLET: QuartzCommandQuantization #: 14
    QUARTER_NOTE_TRIPLET: QuartzCommandQuantization #: 15
    HALF_NOTE_TRIPLET: QuartzCommandQuantization #: 16
    TICK: QuartzCommandQuantization #: 17: (same as 1/32)
    NONE: QuartzCommandQuantization #: 19: (Execute as soon as possible)
    ...

class EndPlayReason(EnumBase):
    r"""
    Specifies why an actor is being deleted/removed from a level
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    DESTROYED: EndPlayReason #: 0: When the Actor or Component is explicitly destroyed.
    LEVEL_TRANSITION: EndPlayReason #: 1: When the world is being unloaded for a level transition.
    END_PLAY_IN_EDITOR: EndPlayReason #: 2: When the world is being unloaded because PIE is ending.
    REMOVED_FROM_WORLD: EndPlayReason #: 3: When the level it is a member of is streamed out.
    QUIT: EndPlayReason #: 4: When the application is being exited.
    ...

class TickingGroup(EnumBase):
    r"""
    Determines which ticking group a tick function belongs to.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineBaseTypes.h
    
    """

    TG_PRE_PHYSICS: TickingGroup #: 0: Any item that needs to be executed before physics simulation starts.
    TG_DURING_PHYSICS: TickingGroup #: 2: Any item that can be run in parallel with our physics simulation work.
    TG_POST_PHYSICS: TickingGroup #: 4: Any item that needs rigid body and cloth simulation to be complete before being executed.
    TG_POST_UPDATE_WORK: TickingGroup #: 5: Any item that needs the update work to be done before being ticked.
    ...

class TemperatureSeverityType(EnumBase):
    r"""
    A parallel enum to the temperature change severity enum in CoreDelegates
    Note if you change this, then you must change the one in CoreDelegates
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ApplicationLifecycleComponent.h
    
    """

    UNKNOWN: TemperatureSeverityType #: 0
    GOOD: TemperatureSeverityType #: 1
    BAD: TemperatureSeverityType #: 2
    SERIOUS: TemperatureSeverityType #: 3
    CRITICAL: TemperatureSeverityType #: 4
    NUM_SEVERITIES: TemperatureSeverityType #: 5
    ...

class PlaneConstraintAxisSetting(EnumBase):
    r"""
    Setting that controls behavior when movement is restricted to a 2D plane defined by a specific axis/normal,
    so that movement along the locked axis is not be possible.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MovementComponent.h
    
    """

    CUSTOM: PlaneConstraintAxisSetting #: 0: Lock movement to a user-defined axis.
    X: PlaneConstraintAxisSetting #: 1: Lock movement in the X axis.
    Y: PlaneConstraintAxisSetting #: 2: Lock movement in the Y axis.
    Z: PlaneConstraintAxisSetting #: 3: Lock movement in the Z axis.
    USE_GLOBAL_PHYSICS_SETTING: PlaneConstraintAxisSetting #: 4: Use the global physics project setting.
    ...

class InterpToBehaviourType(EnumBase):
    r"""
    Controls the movement behaviour
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InterpToMovementComponent.h
    
    """

    ONE_SHOT: InterpToBehaviourType #: 0: Move to destination and stop
    ONE_SHOT_REVERSE: InterpToBehaviourType #: 1: Move to destination, return and stop
    LOOP_RESET: InterpToBehaviourType #: 2: Reset back to start when reaching the end
    PING_PONG: InterpToBehaviourType #: 3: Repeatedly lerp from start to end and back
    ...

class ObjectTypeQuery(EnumBase):
    r"""
    Specifies custom collision object types, overridable per game
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    OBJECT_TYPE_QUERY1: ObjectTypeQuery #: 0
    OBJECT_TYPE_QUERY2: ObjectTypeQuery #: 1
    OBJECT_TYPE_QUERY3: ObjectTypeQuery #: 2
    OBJECT_TYPE_QUERY4: ObjectTypeQuery #: 3
    OBJECT_TYPE_QUERY5: ObjectTypeQuery #: 4
    OBJECT_TYPE_QUERY6: ObjectTypeQuery #: 5
    ...

class DrawDebugTrace(EnumBase):
    r"""
    EDraw Debug Trace
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetSystemLibrary.h
    
    """

    NONE: DrawDebugTrace #: 0
    FOR_ONE_FRAME: DrawDebugTrace #: 1
    FOR_DURATION: DrawDebugTrace #: 2
    PERSISTENT: DrawDebugTrace #: 3
    ...

class TraceTypeQuery(EnumBase):
    r"""
    Specifies custom collision trace types, overridable per game
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    TRACE_TYPE_QUERY1: TraceTypeQuery #: 0
    TRACE_TYPE_QUERY2: TraceTypeQuery #: 1
    ...

class PropertyAccessChangeNotifyMode(EnumBase):
    r"""
    Enum controlling when to emit property change notifications when setting a property value.
    note: Mirrored from PropertyAccessUtil.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    DEFAULT: PropertyAccessChangeNotifyMode #: 0: Notify only when a value change has actually occurred
    NEVER: PropertyAccessChangeNotifyMode #: 1: Never notify that a value change has occurred
    ALWAYS: PropertyAccessChangeNotifyMode #: 2: Always notify that a value change has occurred, even if the value is unchanged
    ...

class NetworkFailure(EnumBase):
    r"""
    Types of network failures broadcast from the engine
    
    **C++ Source:**
    
    - **Module**: NetCore
    - **File**: NetEnums.h
    
    """

    NET_DRIVER_ALREADY_EXISTS: NetworkFailure #: 0: A relevant net driver has already been created for this service
    NET_DRIVER_CREATE_FAILURE: NetworkFailure #: 1: The net driver creation failed
    NET_DRIVER_LISTEN_FAILURE: NetworkFailure #: 2: The net driver failed its Listen() call
    CONNECTION_LOST: NetworkFailure #: 3: A connection to the net driver has been lost
    CONNECTION_TIMEOUT: NetworkFailure #: 4: A connection to the net driver has timed out
    FAILURE_RECEIVED: NetworkFailure #: 5: The net driver received an NMT_Failure message
    OUTDATED_CLIENT: NetworkFailure #: 6: The client needs to upgrade their game
    OUTDATED_SERVER: NetworkFailure #: 7: The server needs to upgrade their game
    PENDING_CONNECTION_FAILURE: NetworkFailure #: 8: There was an error during connection to the game
    NET_GUID_MISMATCH: NetworkFailure #: 9: NetGuid mismatch
    NET_CHECKSUM_MISMATCH: NetworkFailure #: 10: Network checksum mismatch
    ...

class TravelFailure(EnumBase):
    r"""
    Types of server travel failures broadcast by the engine
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineBaseTypes.h
    
    """

    NO_LEVEL: TravelFailure #: 0: No level found in the loaded package
    LOAD_MAP_FAILURE: TravelFailure #: 1: LoadMap failed on travel (about to Browse to default map)
    INVALID_URL: TravelFailure #: 2: Invalid URL specified
    PACKAGE_MISSING: TravelFailure #: 3: A package is missing on the client
    PACKAGE_VERSION: TravelFailure #: 4: A package version mismatch has occurred between client and server
    NO_DOWNLOAD: TravelFailure #: 5: A package is missing and the client is unable to download the file
    TRAVEL_FAILURE: TravelFailure #: 6: General travel failure
    CHEAT_COMMANDS: TravelFailure #: 7: Cheat commands have been used disabling travel
    PENDING_NET_GAME_CREATE_FAILURE: TravelFailure #: 8: Failed to create the pending net game for travel
    CLOUD_SAVE_FAILURE: TravelFailure #: 9: Failed to save before travel
    SERVER_TRAVEL_FAILURE: TravelFailure #: 10: There was an error during a server travel to a new map
    CLIENT_TRAVEL_FAILURE: TravelFailure #: 11: There was an error during a client travel to a new map
    ...

class ApplicationState(EnumBase):
    r"""
    application state when the game receives a notification
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    """

    UNKNOWN: ApplicationState #: 0: The Application was in an unknown state when receiving the notification
    INACTIVE: ApplicationState #: 1: The Application was inactive when receiving the notification
    BACKGROUND: ApplicationState #: 2: The Application was in the background when receiving the notification
    ACTIVE: ApplicationState #: 3: The Application was active when receiving the notification
    ...

class ScreenOrientation(EnumBase):
    r"""
    The list of possible device/screen orientation for mobile devices
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    """

    UNKNOWN: ScreenOrientation #: 0: The orientation is not known
    PORTRAIT: ScreenOrientation #: 1: The orientation is portrait with the home button at the bottom
    PORTRAIT_UPSIDE_DOWN: ScreenOrientation #: 2: The orientation is portrait with the home button at the top
    LANDSCAPE_LEFT: ScreenOrientation #: 3: The orientation is landscape with the home button at the right side
    LANDSCAPE_RIGHT: ScreenOrientation #: 4: The orientation is landscape with the home button at the left side
    FACE_UP: ScreenOrientation #: 5: The orientation is as if place on a desk with the screen upward
    FACE_DOWN: ScreenOrientation #: 6: The orientation is as if place on a desk with the screen downward
    PORTRAIT_SENSOR: ScreenOrientation #: 7: The orientation is portrait, oriented upright with the sensor
    LANDSCAPE_SENSOR: ScreenOrientation #: 8: The orientation is landscape, oriented upright with the sensor
    FULL_SENSOR: ScreenOrientation #: 9: The orientation is no longer locked and adjusts according to the sensor
    ...

class ComponentPhysicsStateChange(EnumBase):
    r"""
    TODO: Add sleep and wake state change types to this enum, so that the
    OnComponentWake and OnComponentSleep delegates may be deprecated.
    Doing so would save a couple bytes per primitive component.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """

    CREATED: ComponentPhysicsStateChange #: 0
    DESTROYED: ComponentPhysicsStateChange #: 1
    ...

class LifetimeCondition(EnumBase):
    r"""
    Secondary condition to check before considering the replication of a lifetime property.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: CoreNetTypes.h
    
    """

    COND_NONE: LifetimeCondition #: 0
    COND_INITIAL_ONLY: LifetimeCondition #: 1: This property has no condition, and will send anytime it changes
    COND_OWNER_ONLY: LifetimeCondition #: 2: This property will only attempt to send on the initial bunch
    COND_SKIP_OWNER: LifetimeCondition #: 3: This property will only send to the actor's owner
    COND_SIMULATED_ONLY: LifetimeCondition #: 4: This property send to every connection EXCEPT the owner
    COND_AUTONOMOUS_ONLY: LifetimeCondition #: 5: This property will only send to simulated actors
    COND_SIMULATED_OR_PHYSICS: LifetimeCondition #: 6: This property will only send to autonomous actors
    COND_INITIAL_OR_OWNER: LifetimeCondition #: 7: This property will send to simulated OR bRepPhysics actors
    COND_CUSTOM: LifetimeCondition #: 8: This property will send on the initial packet, or to the actors owner
    COND_REPLAY_OR_OWNER: LifetimeCondition #: 9: This property has no particular condition, but wants the ability to toggle on/off via SetCustomIsActiveOverride
    COND_REPLAY_ONLY: LifetimeCondition #: 10: This property will only send to the replay connection, or to the actors owner
    COND_SIMULATED_ONLY_NO_REPLAY: LifetimeCondition #: 11: This property will only send to the replay connection
    COND_SIMULATED_OR_PHYSICS_NO_REPLAY: LifetimeCondition #: 12: This property will send to actors only, but not to replay connections
    COND_SKIP_REPLAY: LifetimeCondition #: 13: This property will send to simulated Or bRepPhysics actors, but not to replay connections
    ...

class DataValidationUsecase(EnumBase):
    r"""
    EData Validation Usecase
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: DataValidation.h
    
    """

    NONE: DataValidationUsecase #: 0: No usecase specified
    MANUAL: DataValidationUsecase #: 1: Triggered on user's demand
    COMMANDLET: DataValidationUsecase #: 2: A commandlet invoked the validation
    SAVE: DataValidationUsecase #: 3: Saving a package triggered the validation
    PRE_SUBMIT: DataValidationUsecase #: 4: Submit dialog triggered the validation
    SCRIPT: DataValidationUsecase #: 5: Triggered by blueprint or c++
    ...

class AxisType(EnumBase):
    r"""
    Generic axis enum (mirrored for native use in Axis.h).
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    NONE: AxisType #: 0
    X: AxisType #: 1
    Y: AxisType #: 2
    Z: AxisType #: 3
    ...

class Unit(EnumBase):
    r"""
    A set of numerical unit types supported by the engine. Mirrored from UnitConversion.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    MICROMETERS: Unit #: 0: Scalar distance/length unit.
    MILLIMETERS: Unit #: 1
    CENTIMETERS: Unit #: 2
    METERS: Unit #: 3
    KILOMETERS: Unit #: 4
    INCHES: Unit #: 5
    FEET: Unit #: 6
    YARDS: Unit #: 7
    MILES: Unit #: 8
    LIGHTYEARS: Unit #: 9
    DEGREES: Unit #: 10: Angular unit.
    RADIANS: Unit #: 11
    CENTIMETERS_PER_SECOND: Unit #: 12: Speed unit.
    METERS_PER_SECOND: Unit #: 13
    KILOMETERS_PER_HOUR: Unit #: 14
    MILES_PER_HOUR: Unit #: 15
    DEGREES_PER_SECOND: Unit #: 16: Angular speed unit.
    RADIANS_PER_SECOND: Unit #: 17
    CENTIMETERS_PER_SECOND_SQUARED: Unit #: 18: Acceleration unit.
    METERS_PER_SECOND_SQUARED: Unit #: 19
    CELSIUS: Unit #: 20: Temperature unit.
    FARENHEIT: Unit #: 21
    KELVIN: Unit #: 22
    MICROGRAMS: Unit #: 23: Mass unit.
    MILLIGRAMS: Unit #: 24
    GRAMS: Unit #: 25
    KILOGRAMS: Unit #: 26
    METRIC_TONS: Unit #: 27
    OUNCES: Unit #: 28
    POUNDS: Unit #: 29
    STONES: Unit #: 30
    GRAMS_PER_CUBIC_CENTIMETER: Unit #: 31: Density unit.
    GRAMS_PER_CUBIC_METER: Unit #: 32
    KILOGRAMS_PER_CUBIC_CENTIMETER: Unit #: 33
    KILOGRAMS_PER_CUBIC_METER: Unit #: 34
    NEWTONS: Unit #: 35: Force unit.
    POUNDS_FORCE: Unit #: 36
    KILOGRAMS_FORCE: Unit #: 37
    KILOGRAM_CENTIMETERS_PER_SECOND_SQUARED: Unit #: 38
    NEWTON_METERS: Unit #: 39: Torque unit.
    KILOGRAM_CENTIMETERS_SQUARED_PER_SECOND_SQUARED: Unit #: 40
    NEWTON_SECONDS: Unit #: 41: Impulse unit.
    KILOGRAM_CENTIMETERS: Unit #: 42
    KILOGRAM_METERS: Unit #: 43
    HERTZ: Unit #: 44: Frequency unit.
    KILOHERTZ: Unit #: 45
    MEGAHERTZ: Unit #: 46
    GIGAHERTZ: Unit #: 47
    REVOLUTIONS_PER_MINUTE: Unit #: 48
    BYTES: Unit #: 49: Data Size unit.
    KILOBYTES: Unit #: 50
    MEGABYTES: Unit #: 51
    GIGABYTES: Unit #: 52
    TERABYTES: Unit #: 53
    LUMENS: Unit #: 54: Luminous flux unit.
    CANDELA: Unit #: 55: Luminous intensity unit.
    LUX: Unit #: 56: Illuminance unit.
    CANDELA_PER_METER2: Unit #: 57: Luminance unit.
    EXPOSURE_VALUE: Unit #: 58: Exposure value unit.
    NANOSECONDS: Unit #: 59: Time unit.
    MICROSECONDS: Unit #: 60
    MILLISECONDS: Unit #: 61
    SECONDS: Unit #: 62
    MINUTES: Unit #: 63
    HOURS: Unit #: 64
    DAYS: Unit #: 65
    MONTHS: Unit #: 66
    YEARS: Unit #: 67
    PIXELS_PER_INCH: Unit #: 68: Pixel density unit.
    PERCENTAGE: Unit #: 69: Percentage.
    MULTIPLIER: Unit #: 70: Arbitrary multiplier.
    PASCALS: Unit #: 71: Stress unit.
    KILO_PASCALS: Unit #: 72
    MEGA_PASCALS: Unit #: 73
    GIGA_PASCALS: Unit #: 74
    UNSPECIFIED: Unit #: 75: Symbolic entry, not specifiable on meta data.
    ...

class AppMsgCategory(EnumBase):
    r"""
    Enumerates supported message dialog category types.
    note: Mirrored from GenericPlatformMisc.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    WARNING: AppMsgCategory #: 0
    ERROR: AppMsgCategory #: 1
    SUCCESS: AppMsgCategory #: 2
    INFO: AppMsgCategory #: 3
    ...

class AppReturnType(EnumBase):
    r"""
    Enum denoting message dialog return types.
    note: Mirrored from GenericPlatformMisc.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    NO: AppReturnType #: 0
    YES: AppReturnType #: 1
    YES_ALL: AppReturnType #: 2
    NO_ALL: AppReturnType #: 3
    CANCEL: AppReturnType #: 4
    OK: AppReturnType #: 5
    RETRY: AppReturnType #: 6
    CONTINUE: AppReturnType #: 7
    ...

class AppMsgType(EnumBase):
    r"""
    Enumerates supported message dialog button types.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    OK: AppMsgType #: 0
    YES_NO: AppMsgType #: 1
    OK_CANCEL: AppMsgType #: 2
    YES_NO_CANCEL: AppMsgType #: 3
    CANCEL_RETRY_CONTINUE: AppMsgType #: 4
    YES_NO_YES_ALL_NO_ALL: AppMsgType #: 5
    YES_NO_YES_ALL_NO_ALL_CANCEL: AppMsgType #: 6
    YES_NO_YES_ALL: AppMsgType #: 7
    ...

class InputDeviceTriggerMask(EnumBase):
    r"""
    Represents input device triggers that are available
    
    NOTE: Make sure to keep this type in sync with the reflected version in IInputInterface.h!
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    NONE: InputDeviceTriggerMask #: 0
    LEFT: InputDeviceTriggerMask #: 1
    RIGHT: InputDeviceTriggerMask #: 2
    ALL: InputDeviceTriggerMask #: 3
    ...

class DataValidationResult(EnumBase):
    r"""
    Enum used by DataValidation plugin to see if an asset has been validated for correctness (mirrored in UObjectGlobals.h)
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    INVALID: DataValidationResult #: 0: Asset has failed validation
    VALID: DataValidationResult #: 1: Asset has passed validation
    NOT_VALIDATED: DataValidationResult #: 2: Asset has not yet been validated
    ...

class ControllerHand(EnumBase):
    r"""
    Defines the controller hands for tracking.  Could be expanded, as needed, to facilitate non-handheld controllers
    
    **C++ Source:**
    
    - **Module**: InputCore
    - **File**: InputCoreTypes.h
    
    """

    LEFT: ControllerHand #: 0
    RIGHT: ControllerHand #: 1
    ANY_HAND: ControllerHand #: 2
    PAD: ControllerHand #: 3
    EXTERNAL_CAMERA: ControllerHand #: 4
    GUN: ControllerHand #: 5
    HMD: ControllerHand #: 6
    CHEST: ControllerHand #: 7
    LEFT_SHOULDER: ControllerHand #: 8
    RIGHT_SHOULDER: ControllerHand #: 9
    LEFT_ELBOW: ControllerHand #: 10
    RIGHT_ELBOW: ControllerHand #: 11
    WAIST: ControllerHand #: 12
    LEFT_KNEE: ControllerHand #: 13
    RIGHT_KNEE: ControllerHand #: 14
    LEFT_FOOT: ControllerHand #: 15
    RIGHT_FOOT: ControllerHand #: 16
    SPECIAL: ControllerHand #: 17
    ...

class UINavigationRule(EnumBase):
    r"""
    EUINavigation Rule
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: NavigationReply.h
    
    """

    ESCAPE: UINavigationRule #: 0: Allow the movement to continue in that direction, seeking the next navigable widget automatically.
    EXPLICIT: UINavigationRule #: 1: Move to a specific widget.
    WRAP: UINavigationRule
    r"""
    2: Wrap movement inside this container, causing the movement to cycle around from the opposite side,
    if the navigation attempt would have escaped.
    """

    STOP: UINavigationRule #: 3: Stops movement in this direction
    CUSTOM: UINavigationRule #: 4: Custom navigation handled by user code.
    CUSTOM_BOUNDARY: UINavigationRule #: 5: Custom navigation handled by user code if the boundary is hit.
    INVALID: UINavigationRule #: 6: Invalid Rule
    ...

class ButtonClickMethod(EnumBase):
    r"""
    Enumerates different methods that a button click can be triggered. Normally, DownAndUp is appropriate.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    DOWN_AND_UP: ButtonClickMethod
    r"""
    0: User must press the button, then release while over the button to trigger the click.
    This is the most common type of button.
    """

    MOUSE_DOWN: ButtonClickMethod #: 1: Click will be triggered immediately on mouse down, and mouse will not be captured.
    MOUSE_UP: ButtonClickMethod
    r"""
    2: Click will always be triggered when mouse button is released over the button,
    even if the button wasn't pressed down over it.
    """

    PRECISE_CLICK: ButtonClickMethod
    r"""
    3: Inside a list, buttons can only be clicked with precise tap.
    Moving the pointer will scroll the list, also allows drag-droppable buttons.
    """

    ...

class ButtonTouchMethod(EnumBase):
    r"""
    Ways in which touch interactions trigger a "Clicked" event.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    DOWN_AND_UP: ButtonTouchMethod #: 0: Most buttons behave this way.
    DOWN: ButtonTouchMethod #: 1: Click will be triggered immediately on touch down, and touch will not be captured.
    PRECISE_TAP: ButtonTouchMethod
    r"""
    2: Inside a list, buttons can only be clicked with precise tap.
    Moving the pointer will scroll the list.
    """

    ...

class ButtonPressMethod(EnumBase):
    r"""
    Enumerates different methods that a button can be triggered with keyboard/controller. Normally, DownAndUp is appropriate.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    DOWN_AND_UP: ButtonPressMethod
    r"""
    0: User must press the button, then release while the button has focus to trigger the click.
    This is the most common type of button.
    """

    BUTTON_PRESS: ButtonPressMethod #: 1: Click will be triggered immediately on button press.
    BUTTON_RELEASE: ButtonPressMethod
    r"""
    2: Click will always be triggered when a button release occurs on the focused button,
    even if the button wasn't pressed while focused.
    """

    ...

class UINavigation(EnumBase):
    r"""
    Navigation context for event
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    LEFT: UINavigation #: 0: Four cardinal directions
    RIGHT: UINavigation #: 1
    UP: UINavigation #: 2
    DOWN: UINavigation #: 3
    NEXT: UINavigation #: 4: Conceptual next and previous
    PREVIOUS: UINavigation #: 5
    INVALID: UINavigation #: 7: Denotes an invalid navigation, more important used to denote no specified navigation
    ...

class UINavigationAction(EnumBase):
    r"""
    Generic UI navigation action that are usually bound to a gamepad or other input device
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    ACCEPT: UINavigationAction #: 0: Accept, normally acts like a mouse click. Corresponds to Virtual_Accept key
    BACK: UINavigationAction #: 1: Back/Cancel, normally acts like escape. Corresponds to Virtual_Back key
    INVALID: UINavigationAction #: 3: Invalid action
    ...

class HorizontalAlignment(EnumBase):
    r"""
    Enumerates horizontal alignment options, i.e. for widget slots.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    H_ALIGN_FILL: HorizontalAlignment #: 0: Fill the entire width.
    H_ALIGN_LEFT: HorizontalAlignment #: 1: Left-align.
    H_ALIGN_CENTER: HorizontalAlignment #: 2: Center-align.
    H_ALIGN_RIGHT: HorizontalAlignment #: 3: Right-align.
    ...

class VerticalAlignment(EnumBase):
    r"""
    Enumerates vertical alignment options, i.e. for widget slots.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    V_ALIGN_FILL: VerticalAlignment #: 0: Fill the entire height.
    V_ALIGN_TOP: VerticalAlignment #: 1: Top-align.
    V_ALIGN_CENTER: VerticalAlignment #: 2: Center-align.
    V_ALIGN_BOTTOM: VerticalAlignment #: 3: Bottom-align.
    ...

class MenuPlacement(EnumBase):
    r"""
    Enumerates possible placements for pop-up menus.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    MENU_PLACEMENT_BELOW_ANCHOR: MenuPlacement #: 0: Place the menu immediately below the anchor
    MENU_PLACEMENT_CENTERED_BELOW_ANCHOR: MenuPlacement #: 1: Place the menu immediately centered below the anchor
    MENU_PLACEMENT_BELOW_RIGHT_ANCHOR: MenuPlacement #: 2: Place the menu immediately below the anchor aligned to the right of the content
    MENU_PLACEMENT_COMBO_BOX: MenuPlacement #: 3: Place the menu immediately below the anchor and match is width to the anchor's content
    MENU_PLACEMENT_COMBO_BOX_RIGHT: MenuPlacement #: 4: Place the menu immediately below the anchor and match is width to the anchor's content. If the width overflows, align with the right edge of the anchor.
    MENU_PLACEMENT_MENU_RIGHT: MenuPlacement #: 5: Place the menu to the right of the anchor
    MENU_PLACEMENT_ABOVE_ANCHOR: MenuPlacement #: 6: Place the menu immediately above the anchor, no transition effect
    MENU_PLACEMENT_CENTERED_ABOVE_ANCHOR: MenuPlacement #: 7: Place the menu immediately centered above the anchor, no transition effect
    MENU_PLACEMENT_ABOVE_RIGHT_ANCHOR: MenuPlacement #: 8: Place the menu immediately above the anchor aligned to the right of the content
    MENU_PLACEMENT_MENU_LEFT: MenuPlacement #: 9: Place the menu to the left of the anchor
    MENU_PLACEMENT_CENTER: MenuPlacement #: 10: Place the menu's center on top of the menu anchor's center point
    MENU_PLACEMENT_RIGHT_LEFT_CENTER: MenuPlacement #: 11: Place the menu's vertical center on the left side at the menu anchor's vertical center on the right side
    MENU_PLACEMENT_MATCH_BOTTOM_LEFT: MenuPlacement #: 12: Place the menu's bottom left corner directly on top of the menu anchor's bottom left corner
    ...

class Orientation(EnumBase):
    r"""
    Enumerates widget orientations.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    ORIENT_HORIZONTAL: Orientation #: 0: Orient horizontally, i.e. left to right.
    ORIENT_VERTICAL: Orientation #: 1: Orient vertically, i.e. top to bottom.
    ...

class ScrollDirection(EnumBase):
    r"""
    Enumerates scroll directions.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    SCROLL_DOWN: ScrollDirection #: 0: Scroll down.
    SCROLL_UP: ScrollDirection #: 1: Scroll up.
    ...

class TextCommit(EnumBase):
    r"""
    Additional information about a text committal
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    DEFAULT: TextCommit #: 0: Losing focus or similar event caused implicit commit
    ON_ENTER: TextCommit #: 1: User committed via the enter key
    ON_USER_MOVED_FOCUS: TextCommit #: 2: User committed via tabbing away or moving focus explicitly away
    ON_CLEARED: TextCommit #: 3: Keyboard focus was explicitly cleared via the escape key or other similar action
    ...

class SelectInfo(EnumBase):
    r"""
    Additional information about a selection event
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateEnums.h
    
    """

    ON_KEY_PRESS: SelectInfo #: 0: User selected via a key press
    ON_NAVIGATION: SelectInfo #: 1: User selected by navigating to the item
    ON_MOUSE_CLICK: SelectInfo #: 2: User selected by clicking on the item
    DIRECT: SelectInfo #: 3: Selection was directly set in code
    ...

class SlatePostRT(EnumBase):
    r"""
    Bitfield used to mark if a slate post RT is used or not
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateRendererTypes.h
    
    """

    NONE: SlatePostRT #: 0
    E_SLATE_POST_RT_0: SlatePostRT #: 1
    E_SLATE_POST_RT_1: SlatePostRT #: 2
    E_SLATE_POST_RT_2: SlatePostRT #: 4
    E_SLATE_POST_RT_3: SlatePostRT #: 8
    E_SLATE_POST_RT_4: SlatePostRT #: 16
    NUM: SlatePostRT #: 5
    ...

class TextShapingMethod(EnumBase):
    r"""
    Methods that can be used to shape text.
    note: If you change this enum, make sure and update CVarDefaultTextShapingMethod and GetDefaultTextShapingMethod.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: FontCache.h
    
    """

    AUTO: TextShapingMethod
    r"""
    0: Automatically picks the fastest possible shaping method (either KerningOnly or FullShaping) based on the reading direction of the text.
    Left-to-right text uses the KerningOnly method, and right-to-left text uses the FullShaping method.
    """

    KERNING_ONLY: TextShapingMethod
    r"""
    1: Provides fake shaping using only kerning data.
    This can be faster than full shaping, but won't render complex right-to-left or bi-directional glyphs (such as Arabic) correctly.
    This can be useful as an optimization when you know your text block will only show simple glyphs (such as numbers).
    """

    FULL_SHAPING: TextShapingMethod
    r"""
    2: Provides full text shaping, allowing accurate rendering of complex right-to-left or bi-directional glyphs (such as Arabic).
    This mode will perform ligature replacement for all languages (such as the combined "fi" glyph in English).
    """

    ...

class WidgetClipping(EnumBase):
    r"""
    This enum controls clipping of widgets in Slate.  By default all SWidgets do not need to clip their children.
    Most of the time, you don't need to clip, the only times it becomes important is when something might become hidden
    due to panning.  You should use this wisely, as Slate can not batch across clipping areas, so if widget A and widget B
    are set to EWidgetClipping::Yes, no drawing that happens inside their widget trees will ever be batch together, adding
    additional GPU overhead.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Clipping.h
    
    """

    INHERIT: WidgetClipping #: 0: This widget does not clip children, it and all children inherit the clipping area of the last widget that clipped.
    CLIP_TO_BOUNDS: WidgetClipping #: 1: This widget clips content the bounds of this widget.  It intersects those bounds with any previous clipping area.
    CLIP_TO_BOUNDS_WITHOUT_INTERSECTING: WidgetClipping
    r"""
    2: This widget clips to its bounds.  It does NOT intersect with any existing clipping geometry, it pushes a new clipping
    state.  Effectively allowing it to render outside the bounds of hierarchy that does clip.
    
    NOTE: This will NOT allow you ignore the clipping zone that is set to [Yes - Always].
    """

    CLIP_TO_BOUNDS_ALWAYS: WidgetClipping
    r"""
    3: This widget clips to its bounds.  It intersects those bounds with any previous clipping area.
    
    NOTE: This clipping area can NOT be ignored, it will always clip children.  Useful for hard barriers
    in the UI where you never want animations or other effects to break this region.
    """

    ON_DEMAND: WidgetClipping
    r"""
    4: This widget clips to its bounds when it's Desired Size is larger than the allocated geometry
    the widget is given.  If that occurs, it work like [Yes].
    
    NOTE: This mode was primarily added for Text, which is often placed into containers that eventually
    are resized to not be able to support the length of the text.  So rather than needing to tag every
    container that could contain text with [Yes], which would result in almost no batching, this mode
    was added to dynamically adjust the clipping if needed.  The reason not every panel is set to OnDemand,
    is because not every panel returns a Desired Size that matches what it plans to render at.
    """

    ...

class SlateBrushDrawType(EnumBase):
    r"""
    Enumerates ways in which an image can be drawn.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateBrush.h
    
    """

    NO_DRAW_TYPE: SlateBrushDrawType #: 0: Don't do anything
    BOX: SlateBrushDrawType #: 1: Draw a 3x3 box, where the sides and the middle stretch based on the Margin
    BORDER: SlateBrushDrawType #: 2: Draw a 3x3 border where the sides tile and the middle is empty
    IMAGE: SlateBrushDrawType #: 3: Draw an image; margin is ignored
    ROUNDED_BOX: SlateBrushDrawType #: 4: Draw a solid rectangle with an outline and corner radius
    ...

class SlateBrushTileType(EnumBase):
    r"""
    Enumerates tiling options for image drawing.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateBrush.h
    
    """

    NO_TILE: SlateBrushTileType #: 0: Just stretch
    HORIZONTAL: SlateBrushTileType #: 1: Tile the image horizontally
    VERTICAL: SlateBrushTileType #: 2: Tile the image vertically
    BOTH: SlateBrushTileType #: 3: Tile in both directions
    ...

class SlateColorStylingMode(EnumBase):
    r"""
    Enumerates types of color values that can be held by Slate color.
    
    Should we use the specified color? If not, then which color from the style should we use.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateColor.h
    
    """

    USE_COLOR_SPECIFIED: SlateColorStylingMode #: 0: Color value is stored in this Slate color.
    USE_COLOR_FOREGROUND: SlateColorStylingMode #: 2: Use the widget's foreground color.
    ...

class SlateParentWindowSearchMethod(EnumBase):
    r"""
    Used to determine which search method we should use when finding a suitable parent window
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    """

    ACTIVE_WINDOW: SlateParentWindowSearchMethod #: 0: Favor using the active window (will fallback to the main window if the active window is unsuitable)
    MAIN_WINDOW: SlateParentWindowSearchMethod #: 1: Favor using the main window
    ...

class CheckBoxState(EnumBase):
    r"""
    Current state of the check box
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    """

    UNCHECKED: CheckBoxState #: 0: Unchecked
    CHECKED: CheckBoxState #: 1: Checked
    UNDETERMINED: CheckBoxState #: 2: Neither checked nor unchecked
    ...

class SlateCheckBoxState(EnumBase):
    r"""
    deprecated: 'SlateCheckBoxState' was renamed to 'CheckBoxState'.
    """

    UNCHECKED: SlateCheckBoxState #: 0: Unchecked
    CHECKED: SlateCheckBoxState #: 1: Checked
    UNDETERMINED: SlateCheckBoxState #: 2: Neither checked nor unchecked
    ...

class TextOverflowPolicy(EnumBase):
    r"""
    The different methods that can be used to determine what happens to text when it is longer than its allowed length
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    """

    CLIP: TextOverflowPolicy #: 0: Overflowing text will be clipped
    ELLIPSIS: TextOverflowPolicy #: 1: Overflowing text will be replaced with an ellipsis
    MULTILINE_ELLIPSIS: TextOverflowPolicy #: 2: Overflowing text will be replaced with an ellipsis. A partially clipped line on the vertical axis will be totally clipped, and ellipsis displayed on previous line
    ...

class TextTransformPolicy(EnumBase):
    r"""
    Text transformation policy that can be applied to the text before displaying it.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    """

    NONE: TextTransformPolicy #: 0: No transform, just use the given text as-is
    TO_LOWER: TextTransformPolicy #: 1: Convert the text to lowercase for display
    TO_UPPER: TextTransformPolicy #: 2: Convert the text to uppercase for display
    ...

class VirtualKeyboardTrigger(EnumBase):
    r"""
    EVirtual Keyboard Trigger
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: ISlateEditableTextWidget.h
    
    """

    ON_FOCUS_BY_POINTER: VirtualKeyboardTrigger #: 0: Display the virtual keyboard when the widget gains keyboard focus by a pointer action.
    ON_ALL_FOCUS_EVENTS: VirtualKeyboardTrigger #: 1: Display the virtual keyboard when the widget gains keyboard focus by any means.
    ...

class VirtualKeyboardDismissAction(EnumBase):
    r"""
    EVirtual Keyboard Dismiss Action
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: ISlateEditableTextWidget.h
    
    """

    TEXT_CHANGE_ON_DISMISS: VirtualKeyboardDismissAction #: 0: Sends a text changed message when the virtual keyboard is dismissed by the user.
    TEXT_COMMIT_ON_ACCEPT: VirtualKeyboardDismissAction #: 1: Send a text commit message if the user dismisses the keyboard by accepting text. Send a text changed message if the user cancels the virtual keyboard.
    TEXT_COMMIT_ON_DISMISS: VirtualKeyboardDismissAction #: 2: Send a text commit message when the virtual keyboard is dismissed by the user.
    ...

class MultiBoxType(EnumBase):
    r"""
    Types of MultiBoxes
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: MultiBoxDefs.h
    
    """

    MENU_BAR: MultiBoxType #: 0: Horizontal menu bar
    TOOL_BAR: MultiBoxType #: 1: Horizontal tool bar
    VERTICAL_TOOL_BAR: MultiBoxType #: 2: Vertical tool bar
    SLIM_HORIZONTAL_TOOL_BAR: MultiBoxType #: 3: Toolbar which is a slim version of the toolbar that aligns an icon and a text element horizontally
    UNIFORM_TOOL_BAR: MultiBoxType #: 4: A toolbar that tries to arrange all toolbar items uniformly (supports only horizontal toolbars for now)
    MENU: MultiBoxType #: 5: Vertical menu (pull-down menu, or context menu)
    BUTTON_ROW: MultiBoxType #: 6: Buttons arranged in rows, with a maximum number of buttons per row, like a toolbar but can have multiple rows
    SLIM_HORIZONTAL_UNIFORM_TOOL_BAR: MultiBoxType #: 7: A toolbar with horizontally-oriented buttons that tries to arrange all toolbar items uniformly
    ...

class MultiBlockType(EnumBase):
    r"""
    Types of MultiBlocks
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: MultiBoxDefs.h
    
    """

    NONE: MultiBlockType #: 0
    BUTTON_ROW: MultiBlockType #: 1
    EDITABLE_TEXT: MultiBlockType #: 2
    HEADING: MultiBlockType #: 3
    MENU_ENTRY: MultiBlockType #: 4
    SEPARATOR: MultiBlockType #: 5
    TOOL_BAR_BUTTON: MultiBlockType #: 6
    TOOL_BAR_COMBO_BUTTON: MultiBlockType #: 7
    WIDGET: MultiBlockType #: 8
    ...

class DescendantScrollDestination(EnumBase):
    r"""
    Where to scroll the descendant to
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: SScrollBox.h
    
    """

    INTO_VIEW: DescendantScrollDestination
    r"""
    0: Scroll the widget into view using the least amount of energy possible.  So if the new item
    is above the visible set, it will stop as soon as it's in view at the top.  If it's below the
    visible set, it stop it comes into view at the bottom.
    """

    TOP_OR_LEFT: DescendantScrollDestination #: 1: Always scroll the widget so it appears at the top/Left of the scrollable area.
    CENTER: DescendantScrollDestination
    r"""
    2: Always scroll the widget so it appears at the center of the scrollable area, if possible.
    This won't be possible for the first few items and the last few items, as there's not enough
    slack.
    """

    BOTTOM_OR_RIGHT: DescendantScrollDestination #: 3: Always scroll the widget so it appears at the bottom/Right of the scrollable area.
    ...

class ScrollWhenFocusChanges(EnumBase):
    r"""
    Set behavior when user focus changes inside this scroll box
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: SScrollBox.h
    
    """

    NO_SCROLL: ScrollWhenFocusChanges #: 0: Don't automatically scroll, navigation or child widget will handle this
    INSTANT_SCROLL: ScrollWhenFocusChanges #: 1: Instantly scroll using NavigationDestination rule
    ANIMATED_SCROLL: ScrollWhenFocusChanges #: 2: Use animation to scroll using NavigationDestination rule
    ...

class UserInterfaceActionType(EnumBase):
    r"""
    Types of user interfaces that can be associated with a user interface action
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: UICommandInfo.h
    
    """

    NONE: UserInterfaceActionType #: 0: An action which should not be associated with a user interface action
    BUTTON: UserInterfaceActionType #: 1: Momentary buttons or menu items.  These support enable state, and execute a delegate when clicked.
    TOGGLE_BUTTON: UserInterfaceActionType #: 2: Toggleable buttons or menu items that store on/off state.  These support enable state, and execute a delegate when toggled.
    RADIO_BUTTON: UserInterfaceActionType #: 3: Radio buttons are similar to toggle buttons in that they are for menu items that store on/off state.  However they should be used to indicate that menu items in a group can only be in one state
    CHECK: UserInterfaceActionType #: 4: Similar to Button but will display a readonly checkbox next to the item.
    COLLAPSED_BUTTON: UserInterfaceActionType #: 5: Similar to Button but has the checkbox area collapsed
    ...

class TextJustify(EnumBase):
    r"""
    EText Justify
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: TextLayout.h
    
    """

    LEFT: TextJustify
    r"""
    0: Justify the text logically to the left.
    When text is flowing left-to-right, this will align text visually to the left.
    When text is flowing right-to-left, this will align text visually to the right.
    """

    CENTER: TextJustify
    r"""
    1: Justify the text in the center.
    Text flow direction has no impact on this justification mode.
    """

    RIGHT: TextJustify
    r"""
    2: Justify the text logically to the right.
    When text is flowing left-to-right, this will align text visually to the right.
    When text is flowing right-to-left, this will align text visually to the left.
    """

    INVARIANT_LEFT: TextJustify #: 3: Always justify the text to the left, regardless of the flow direction of the current culture.
    INVARIANT_RIGHT: TextJustify #: 4: Always justify the text to the right, regardless of the flow direction of the current culture.
    ...

class TextWrappingPolicy(EnumBase):
    r"""
    The different methods that can be used if a word is too long to be broken by the default line-break iterator.
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: TextLayout.h
    
    """

    DEFAULT_WRAPPING: TextWrappingPolicy #: 0: No fallback, just use the given line-break iterator
    ALLOW_PER_CHARACTER_WRAPPING: TextWrappingPolicy #: 1: Fallback to per-character wrapping if a word is too long
    ...

class TextFlowDirection(EnumBase):
    r"""
    The different directions that text can flow within a paragraph of text.
    note: If you change this enum, make sure and update CVarDefaultTextFlowDirection and GetDefaultTextFlowDirection.
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: TextLayout.h
    
    """

    AUTO: TextFlowDirection #: 0: Automatically detect the flow direction for each paragraph from its text
    LEFT_TO_RIGHT: TextFlowDirection #: 1: Force text to be flowed left-to-right
    RIGHT_TO_LEFT: TextFlowDirection #: 2: Force text to be flowed right-to-left
    CULTURE: TextFlowDirection #: 3: Uses the set culture to determine if text should flow left-to-right or right-to-left.  By comparison, Auto will use the text itself to determine it.
    ...

class StretchDirection(EnumBase):
    r"""
    EStretch Direction
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: SScaleBox.h
    
    """

    BOTH: StretchDirection #: 0: Will scale the content up or down.
    DOWN_ONLY: StretchDirection #: 1: Will only make the content smaller, will never scale it larger than the content's desired size.
    UP_ONLY: StretchDirection #: 2: Will only make the content larger, will never scale it smaller than the content's desired size.
    ...

class Stretch(EnumBase):
    r"""
    EStretch
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: SScaleBox.h
    
    """

    NONE: Stretch #: 0: Does not scale the content.
    FILL: Stretch #: 1: Scales the content non-uniformly filling the entire space of the area.
    SCALE_TO_FIT: Stretch
    r"""
    2: Scales the content uniformly (preserving aspect ratio)
    until it can no longer scale the content without clipping it.
    """

    SCALE_TO_FIT_X: Stretch
    r"""
    3: Scales the content uniformly (preserving aspect ratio)
    until it can no longer scale the content without clipping it along the x-axis,
    the y-axis can/will be clipped.
    """

    SCALE_TO_FIT_Y: Stretch
    r"""
    4: Scales the content uniformly (preserving aspect ratio)
    until it can no longer scale the content without clipping it along the y-axis,
    the x-axis can/will be clipped.
    """

    SCALE_TO_FILL: Stretch
    r"""
    5: Scales the content uniformly (preserving aspect ratio), until all sides meet
    or exceed the size of the area.  Will result in clipping the longer side.
    """

    SCALE_BY_SAFE_ZONE: Stretch #: 6: Scales the content according to the size of the safe zone currently applied to the viewport.
    USER_SPECIFIED: Stretch #: 7: Scales the content by the scale specified by the user.
    USER_SPECIFIED_WITH_CLIPPING: Stretch #: 8: Scales the content by the scale specified by the user and also clips.
    ...

class ProgressBarFillType(EnumBase):
    r"""
    SProgressBar Fill Type
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: SProgressBar.h
    
    """

    LEFT_TO_RIGHT: ProgressBarFillType #: 0: will fill up from the left side to the right
    RIGHT_TO_LEFT: ProgressBarFillType #: 1: will fill up from the right side to the left side
    FILL_FROM_CENTER: ProgressBarFillType #: 2: will scale up from the midpoint to the outer edges both vertically and horizontally
    FILL_FROM_CENTER_HORIZONTAL: ProgressBarFillType #: 3: will fill up from the centerline to the outer edges horizontally
    FILL_FROM_CENTER_VERTICAL: ProgressBarFillType #: 4: will fill up from the centerline to the outer edges vertically
    TOP_TO_BOTTOM: ProgressBarFillType #: 5: will fill up from the top to the the bottom
    BOTTOM_TO_TOP: ProgressBarFillType #: 6: will fill up from the bottom to the the top
    ...

class ProgressBarFillStyle(EnumBase):
    r"""
    SProgressBar Fill Style
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: SProgressBar.h
    
    """

    MASK: ProgressBarFillStyle #: 0: a mask is used to paint the fill image
    SCALE: ProgressBarFillStyle #: 1: the fill image is scaled to the fill percentage
    ...

class ListItemAlignment(EnumBase):
    r"""
    If the list panel is arranging items as tiles, this enum dictates how the items should be aligned (basically, where any extra space is placed)
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: STableViewBase.h
    
    """

    EVENLY_DISTRIBUTED: ListItemAlignment #: 0: Items are distributed evenly along the line (any extra space is added as padding between the items)
    EVENLY_SIZE: ListItemAlignment #: 1: Items are distributed evenly along the line (any extra space is used to scale up the size of the item proportionally.)
    EVENLY_WIDE: ListItemAlignment #: 2: Items are distributed evenly along the line, any extra space is used to scale up width of the items proportionally.)
    LEFT_ALIGNED: ListItemAlignment #: 3: Items are left aligned on the line (any extra space is added to the right of the items)
    RIGHT_ALIGNED: ListItemAlignment #: 4: Items are right aligned on the line (any extra space is added to the left of the items)
    CENTER_ALIGNED: ListItemAlignment #: 5: Items are center aligned on the line (any extra space is halved and added to the left of the items)
    FILL: ListItemAlignment #: 6: Items are evenly stretched to distribute any extra space on the line
    ...

class LocatorResolveFlags(EnumBase):
    r"""
    ELocator Resolve Flags
    
    **C++ Source:**
    
    - **Module**: UniversalObjectLocator
    - **File**: UniversalObjectLocatorResolveParams.h
    
    """

    NONE: LocatorResolveFlags #: 0
    LOAD: LocatorResolveFlags #: 1: Flag to indicate whether the object should be loaded if it is not currently findable
    UNLOAD: LocatorResolveFlags #: 2: Flag to indicate whether the object should be unloaded or destroyed. Mutually exclusive with bLoad.
    ASYNC: LocatorResolveFlags
    r"""
    4: Indicates that the operation should be performed asynchronously if possible.
      When not combined with WillWait, the caller will never block waiting for the result.
      When combined with WillWait, the caller will block on this thread until the result is available,
       so care needs to be taken avoid a deadlock if there are additional threading constraints on the load.
    """

    WILL_WAIT: LocatorResolveFlags #: 8: Indicates the calling code is going to block waiting for the result.
    ASYNC_WAIT: LocatorResolveFlags #: 12: Combination of Async and WillWait.
    ...

class CoreOnlineDummy(EnumBase):
    r"""
    This exists purely to guarantee a package is created, or the engine will not boot.
    
    **C++ Source:**
    
    - **Module**: CoreOnline
    - **File**: CoreOnlinePrivate.h
    
    """

    DUMMY: CoreOnlineDummy #: 0
    ...

class ReplicationSystem(EnumBase):
    r"""
    EReplication System
    
    **C++ Source:**
    
    - **Module**: NetCore
    - **File**: NetEnums.h
    
    """

    DEFAULT: ReplicationSystem #: 0
    GENERIC: ReplicationSystem #: 1
    IRIS: ReplicationSystem #: 2
    ...

class SetMaskConditionType(EnumBase):
    r"""
    ESet Mask Condition Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    FIELD_SET_ALWAYS: SetMaskConditionType #: 0: The particle output value will be equal to Interior-value if the particle position is inside a sphere / Exterior-value otherwise.
    FIELD_SET_IFF_NOT_INTERIOR: SetMaskConditionType #: 1: The particle output value will be equal to Interior-value if the particle position is inside the sphere or if the particle input value is already Interior-Value / Exterior-value otherwise.
    FIELD_SET_IFF_NOT_EXTERIOR: SetMaskConditionType #: 2: The particle output value will be equal to Exterior-value if the particle position is outside the sphere or if the particle input value is already Exterior-Value / Interior-value otherwise.
    ...

class WaveFunctionType(EnumBase):
    r"""
    EWave Function Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    FIELD_WAVE_COSINE: WaveFunctionType #: 0: Cosine wave that will move in time.
    FIELD_WAVE_GAUSSIAN: WaveFunctionType #: 1: Gaussian wave that will move in time.
    FIELD_WAVE_FALLOFF: WaveFunctionType #: 2: The radial falloff radius will move along temporal wave.
    FIELD_WAVE_DECAY: WaveFunctionType #: 3: The magnitude of the field will decay in time.
    ...

class FieldOperationType(EnumBase):
    r"""
    EField Operation Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    FIELD_MULTIPLY: FieldOperationType #: 0: Multiply the fields output values : Output = Left * Right
    FIELD_DIVIDE: FieldOperationType #: 1: Divide the fields output values : Output = Left / Right
    FIELD_ADD: FieldOperationType #: 2: Add the fields output values : Output = Left + Right
    FIELD_SUBSTRACT: FieldOperationType #: 3: Subtract the fields output : Output = Left - Right
    ...

class FieldCullingOperationType(EnumBase):
    r"""
    EField Culling Operation Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    FIELD_CULLING_INSIDE: FieldCullingOperationType #: 0: Evaluate the input field if the result of the culling field is equal to 0
    FIELD_CULLING_OUTSIDE: FieldCullingOperationType #: 1: Evaluate the input field if the result of the culling field is different from 0
    ...

class FieldResolutionType(EnumBase):
    r"""
    EField Resolution Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    FIELD_RESOLUTION_MINIMAL: FieldResolutionType #: 0: Apply the field to all the active particles
    FIELD_RESOLUTION_DISABLED_PARENTS: FieldResolutionType #: 1: Apply the field to all the parent particles
    FIELD_RESOLUTION_MAXIMUM: FieldResolutionType #: 2: Apply the field to all the solver particles
    ...

class FieldFilterType(EnumBase):
    r"""
    EField Filter Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    FIELD_FILTER_DYNAMIC: FieldFilterType #: 0: Apply the field to all the dynamic particles
    FIELD_FILTER_KINEMATIC: FieldFilterType #: 1: Apply the field to all the kinematic particles
    FIELD_FILTER_STATIC: FieldFilterType #: 2: Apply the field to all the static particles
    FIELD_FILTER_ALL: FieldFilterType #: 3: Apply the field to all the solver particles
    FIELD_FILTER_SLEEPING: FieldFilterType #: 4: Apply the field to all the sleeping particles
    FIELD_FILTER_DISABLED: FieldFilterType #: 5: Apply the field to all the disabled particles
    ...

class FieldObjectType(EnumBase):
    r"""
    EField Object Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    FIELD_OBJECT_RIGID: FieldObjectType #: 0: Apply the field to all the rigid particles
    FIELD_OBJECT_CLOTH: FieldObjectType #: 1: Apply the field to all the cloth particles
    FIELD_OBJECT_DESTRUCTION: FieldObjectType #: 2: Apply the field to all the destruction particles
    FIELD_OBJECT_CHARACTER: FieldObjectType #: 3: Apply the field to all the character particles
    FIELD_OBJECT_ALL: FieldObjectType #: 4: Apply the field to all the objects particles
    ...

class FieldPositionType(EnumBase):
    r"""
    EField Position Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    FIELD_POSITION_CENTER_OF_MASS: FieldPositionType #: 0: Apply the field to the particles center of mass position
    FIELD_POSITION_PIVOT_POINT: FieldPositionType #: 1: Apply the field to the particles pivot point position
    ...

class FieldFalloffType(EnumBase):
    r"""
    EField Falloff Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    FIELD_FALL_OFF_NONE: FieldFalloffType #: 0: No falloff function is used
    FIELD_FALLOFF_LINEAR: FieldFalloffType #: 1: The falloff function will be proportional to x
    FIELD_FALLOFF_INVERSE: FieldFalloffType #: 2: The falloff function will be proportional to 1.0/x
    FIELD_FALLOFF_SQUARED: FieldFalloffType #: 3: The falloff function will be proportional to x*x
    FIELD_FALLOFF_LOGARITHMIC: FieldFalloffType #: 4: The falloff function will be proportional to log(x)
    ...

class FieldPhysicsType(EnumBase):
    r"""
    EField Physics Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    FIELD_DYNAMIC_STATE: FieldPhysicsType #: 1: Set the dynamic state of a particle (static, dynamic, kinematic...)
    FIELD_LINEAR_FORCE: FieldPhysicsType #: 2: Add a vector field to the particles linear force.
    FIELD_EXTERNAL_CLUSTER_STRAIN: FieldPhysicsType #: 3: Apply an external strain over the particles. If this strain is over the internal one, the cluster will break.
    FIELD_KILL: FieldPhysicsType #: 4: Disable the particles for which the field will be higher than 0.
    FIELD_LINEAR_VELOCITY: FieldPhysicsType #: 5: Add a vector field to the particles linear velocity.
    FIELD_ANGULAR_VELOCIY: FieldPhysicsType #: 6: Add a vector field to the particles angular velocity.
    FIELD_ANGULAR_TORQUE: FieldPhysicsType #: 7: Add a vector field to the particles angular torque.
    FIELD_INTERNAL_CLUSTER_STRAIN: FieldPhysicsType #: 8: Add a strain field to the particles internal one.
    FIELD_DISABLE_THRESHOLD: FieldPhysicsType #: 9: Disable the particles if their linear and angular velocity are less than the threshold.
    FIELD_SLEEPING_THRESHOLD: FieldPhysicsType #: 10: Set particles in sleeping mode if their linear and angular velocity are less than the threshold.
    FIELD_COLLISION_GROUP: FieldPhysicsType #: 15: Set the particles collision group.
    FIELD_ACTIVATE_DISABLED: FieldPhysicsType #: 16: Activate all the disabled particles for which the field value will be 0
    ...

class FieldVectorType(EnumBase):
    r"""
    TODO : Refactor these 3 enums to be in sync with the GetFieldTargetTypes
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    VECTOR_LINEAR_FORCE: FieldVectorType #: 0: Add a vector field to the particles linear force.
    VECTOR_LINEAR_VELOCITY: FieldVectorType #: 1: Add a vector field to the particles linear velocity.
    VECTOR_ANGULAR_VELOCITY: FieldVectorType #: 2: Add a vector field to the particles angular velocity.
    VECTOR_ANGULAR_TORQUE: FieldVectorType #: 3: Add a vector field to the particles angular torque.
    ...

class FieldScalarType(EnumBase):
    r"""
    EField Scalar Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    SCALAR_EXTERNAL_CLUSTER_STRAIN: FieldScalarType #: 0: Apply an external strain over the particles. If this strain is over the internal one, the cluster will break.
    SCALAR_KILL: FieldScalarType #: 1: Disable the particles for which the field will be higher than 0.
    SCALAR_DISABLE_THRESHOLD: FieldScalarType #: 2: Disable the particles if their linear and angular velocity are less than the threshold.
    SCALAR_SLEEPING_THRESHOLD: FieldScalarType #: 3: Set particles in sleeping mode if their linear and angular velocity are less than the threshold.
    SCALAR_INTERNAL_CLUSTER_STRAIN: FieldScalarType #: 4: Add a strain field to the particles internal one.
    ...

class FieldIntegerType(EnumBase):
    r"""
    EField Integer Type
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    INTEGER_DYNAMIC_STATE: FieldIntegerType #: 0: Set the dynamic state of a particle (static, dynamic, kinematic...)
    INTEGER_ACTIVATE_DISABLED: FieldIntegerType #: 1: Activate all the disabled particles for which the field value will be 0
    INTEGER_COLLISION_GROUP: FieldIntegerType #: 2: Set the particles collision group.
    ...

class FieldPhysicsDefaultFields(EnumBase):
    r"""
    EField Physics Default Fields
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: FieldSystemTypes.h
    
    """

    FIELD_RADIAL_INT_MASK: FieldPhysicsDefaultFields #: 0
    FIELD_RADIAL_FALLOFF: FieldPhysicsDefaultFields #: 1
    FIELD_UNIFORM_VECTOR: FieldPhysicsDefaultFields #: 2
    FIELD_RADIAL_VECTOR: FieldPhysicsDefaultFields #: 3
    FIELD_RADIAL_VECTOR_FALLOFF: FieldPhysicsDefaultFields #: 4
    ...

class ImplicitTypeEnum(EnumBase):
    r"""
    EImplicit Type Enum
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: GeometryCollectionSimulationTypes.h
    
    """

    CHAOS_IMPLICIT_BOX: ImplicitTypeEnum #: 0
    CHAOS_IMPLICIT_SPHERE: ImplicitTypeEnum #: 1
    CHAOS_IMPLICIT_CAPSULE: ImplicitTypeEnum #: 2
    CHAOS_IMPLICIT_LEVEL_SET: ImplicitTypeEnum #: 3
    CHAOS_IMPLICIT_NONE: ImplicitTypeEnum #: 4
    CHAOS_IMPLICIT_CONVEX: ImplicitTypeEnum #: 5
    ...

class ObjectStateTypeEnum(EnumBase):
    r"""
    EObject State Type Enum
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: GeometryCollectionSimulationTypes.h
    
    """

    CHAOS_OBJECT_SLEEPING: ObjectStateTypeEnum #: 1
    CHAOS_OBJECT_KINEMATIC: ObjectStateTypeEnum #: 2
    CHAOS_OBJECT_STATIC: ObjectStateTypeEnum #: 3
    CHAOS_OBJECT_DYNAMIC: ObjectStateTypeEnum #: 4
    CHAOS_OBJECT_USER_DEFINED: ObjectStateTypeEnum #: 100
    ...

class GeometryCollectionPhysicsTypeEnum(EnumBase):
    r"""
    EGeometry Collection Physics Type Enum
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: GeometryCollectionSimulationTypes.h
    
    """

    CHAOS_ANGULAR_VELOCITY: GeometryCollectionPhysicsTypeEnum #: 0: Add a vector field to the particles angular velocity.
    CHAOS_DYNAMIC_STATE: GeometryCollectionPhysicsTypeEnum #: 1: Set the dynamic state of a particle (static, dynamic, kinematic...)
    CHAOS_LINEAR_VELOCITY: GeometryCollectionPhysicsTypeEnum #: 2: Add a vector field to the particles linear velocity.
    CHAOS_INITIAL_ANGULAR_VELOCITY: GeometryCollectionPhysicsTypeEnum #: 3: Initial particles angular velocity.
    CHAOS_INITIAL_LINEAR_VELOCITY: GeometryCollectionPhysicsTypeEnum #: 4: Initial particles linear velocity.
    CHAOS_COLLISION_GROUP: GeometryCollectionPhysicsTypeEnum #: 5: Set the particles collision group.
    CHAOS_LINEAR_FORCE: GeometryCollectionPhysicsTypeEnum #: 6: Add a vector field to the particles linear force.
    CHAOS_ANGULAR_TORQUE: GeometryCollectionPhysicsTypeEnum #: 7: Add a vector field to the particles angular torque.
    CHAOS_DISABLE_THRESHOLD: GeometryCollectionPhysicsTypeEnum #: 8: Disable the particles if their linear and angular velocity are less than the threshold.
    CHAOS_SLEEPING_THRESHOLD: GeometryCollectionPhysicsTypeEnum #: 9: Set particles in sleeping mode if their linear and angular velocity are less than the threshold.
    CHAOS_EXTERNAL_CLUSTER_STRAIN: GeometryCollectionPhysicsTypeEnum #: 10: Apply an external strain over the particles. If this strain is over the internal one, the cluster will break.
    CHAOS_INTERNAL_CLUSTER_STRAIN: GeometryCollectionPhysicsTypeEnum #: 11: Add a strain field to the particles internal one.
    CHAOS_LINEAR_IMPULSE: GeometryCollectionPhysicsTypeEnum #: 12: Add a vector field to apply an impulse to the particles.
    ...

class InitialVelocityTypeEnum(EnumBase):
    r"""
    EInitial Velocity Type Enum
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: GeometryCollectionSimulationTypes.h
    
    """

    CHAOS_INITIAL_VELOCITY_USER_DEFINED: InitialVelocityTypeEnum #: 0: Chaos_Initial_Velocity_Animation UMETA(DisplayName = "Animation"),
    CHAOS_INITIAL_VELOCITY_NONE: InitialVelocityTypeEnum #: 1: Chaos_Initial_Velocity_Field UMETA(DisplayName = "Field"),
    ...

class EmissionPatternTypeEnum(EnumBase):
    r"""
    EEmission Pattern Type Enum
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: GeometryCollectionSimulationTypes.h
    
    """

    CHAOS_EMISSION_PATTERN_FIRST_FRAME: EmissionPatternTypeEnum #: 0
    CHAOS_EMISSION_PATTERN_ON_DEMAND: EmissionPatternTypeEnum #: 1
    ...

class DamageModelTypeEnum(EnumBase):
    r"""
    EDamage Model Type Enum
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: GeometryCollectionSimulationTypes.h
    
    """

    CHAOS_DAMAGE_MODEL_USER_DEFINED_DAMAGE_THRESHOLD: DamageModelTypeEnum #: 0: Using damage threshold set based on level of the cluster
    CHAOS_DAMAGE_MODEL_MATERIAL_STRENGTH_AND_CONNECTIVITY_DAMAGE_THRESHOLD: DamageModelTypeEnum #: 1: Using damage threshold set using the physical material strength and how connected a cluster is
    ...

class CollisionTraceFlag(EnumBase):
    r"""
    ECollision Trace Flag
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: BodySetupEnums.h
    
    """

    CTF_USE_DEFAULT: CollisionTraceFlag #: 0: Use project physics settings (DefaultShapeComplexity)
    CTF_USE_SIMPLE_AND_COMPLEX: CollisionTraceFlag #: 1: Create both simple and complex shapes. Simple shapes are used for regular scene queries and collision tests. Complex shape (per poly) is used for complex scene queries.
    CTF_USE_SIMPLE_AS_COMPLEX: CollisionTraceFlag #: 2: Create only simple shapes. Use simple shapes for all scene queries and collision tests.
    CTF_USE_COMPLEX_AS_SIMPLE: CollisionTraceFlag #: 3: Create only complex shapes (per poly). Use complex shapes for all scene queries and collision tests. Can be used in simulation for static shapes only (i.e can be collided against but not moved through forces or velocity.)
    ...

class PhysicalSurface(EnumBase):
    r"""
    Types of surfaces in the game, used by Physical Materials
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: ChaosEngineInterface.h
    
    """

    SURFACE_TYPE_DEFAULT: PhysicalSurface #: 0
    ...

class ToolMenuStringCommandType(EnumBase):
    r"""
    ETool Menu String Command Type
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuMisc.h
    
    """

    COMMAND: ToolMenuStringCommandType #: 0
    PYTHON: ToolMenuStringCommandType #: 1
    CUSTOM: ToolMenuStringCommandType #: 2
    ...

class ToolMenuInsertType(EnumBase):
    r"""
    ETool Menu Insert Type
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuMisc.h
    
    """

    DEFAULT: ToolMenuInsertType #: 0
    BEFORE: ToolMenuInsertType #: 1
    AFTER: ToolMenuInsertType #: 2
    FIRST: ToolMenuInsertType #: 3
    ...

class InterchangeFactoryAssetType(EnumBase):
    r"""
    EInterchange Factory Asset Type
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeFactoryBase.h
    
    """

    NONE: InterchangeFactoryAssetType #: 0
    TEXTURES: InterchangeFactoryAssetType #: 1
    MATERIALS: InterchangeFactoryAssetType #: 2
    MESHES: InterchangeFactoryAssetType #: 3
    ANIMATIONS: InterchangeFactoryAssetType #: 4
    PHYSICS: InterchangeFactoryAssetType #: 5
    ...

class InterchangePipelineTask(EnumBase):
    r"""
    EInterchange Pipeline Task
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangePipelineBase.h
    
    """

    POST_TRANSLATOR: InterchangePipelineTask #: 0
    POST_FACTORY: InterchangePipelineTask #: 1
    POST_IMPORT: InterchangePipelineTask #: 2
    EXPORT: InterchangePipelineTask #: 3
    ...

class InterchangeTranslatorType(EnumBase):
    r"""
    EInterchange Translator Type
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeTranslatorBase.h
    
    """

    INVALID: InterchangeTranslatorType #: 0
    ASSETS: InterchangeTranslatorType #: 2
    ACTORS: InterchangeTranslatorType #: 4
    SCENES: InterchangeTranslatorType #: 6
    ...

class InterchangeTranslatorAssetType(EnumBase):
    r"""
    EInterchange Translator Asset Type
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeTranslatorBase.h
    
    """

    NONE: InterchangeTranslatorAssetType #: 0
    TEXTURES: InterchangeTranslatorAssetType #: 1
    MATERIALS: InterchangeTranslatorAssetType #: 2
    MESHES: InterchangeTranslatorAssetType #: 4
    ANIMATIONS: InterchangeTranslatorAssetType #: 8
    ...

class InterchangeNodeContainerType(EnumBase):
    r"""
    ns UE::Interchange
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeBaseNode.h
    
    """

    NONE: InterchangeNodeContainerType #: 0
    TRANSLATED_SCENE: InterchangeNodeContainerType #: 1
    TRANSLATED_ASSET: InterchangeNodeContainerType #: 2
    FACTORY_DATA: InterchangeNodeContainerType #: 3
    ...

class InterchangeNodeUserInterfaceContext(EnumBase):
    r"""
    EInterchange Node User Interface Context
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeBaseNode.h
    
    """

    NONE: InterchangeNodeUserInterfaceContext #: 0
    PREVIEW: InterchangeNodeUserInterfaceContext #: 1
    ...

class ConstraintType(EnumBase):
    r"""
    Constraint Types
    
    **C++ Source:**
    
    - **Module**: AnimationCore
    - **File**: Constraint.h
    
    """

    TRANSFORM: ConstraintType #: 0: Transform Constraint
    AIM: ConstraintType #: 1: Aim Constraint
    ...

class TransformConstraintType(EnumBase):
    r"""
    Transform Constraint Types
    
    **C++ Source:**
    
    - **Module**: AnimationCore
    - **File**: Constraint.h
    
    """

    TRANSLATION: TransformConstraintType #: 0
    ROTATION: TransformConstraintType #: 1
    SCALE: TransformConstraintType #: 2
    PARENT: TransformConstraintType #: 3
    LOOK_AT: TransformConstraintType #: 4
    ...

class HDRCaptureGamut(EnumBase):
    r"""
    Used by UCompositionGraphCaptureSettings. Matches gamut order in EDisplayColorGamut
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: CompositionGraphCaptureProtocol.h
    
    """

    HCGM_REC709: HDRCaptureGamut #: 0
    HCGM_P3DCI: HDRCaptureGamut #: 1
    HCGM_REC2020: HDRCaptureGamut #: 2
    HCGM_ACES: HDRCaptureGamut #: 3
    HCGM_ACE_SCG: HDRCaptureGamut #: 4
    HCGM_LINEAR: HDRCaptureGamut #: 5
    ...

class TimecodeBoneMode(EnumBase):
    r"""
    ETimecode Bone Mode
    
    **C++ Source:**
    
    - **Module**: SequenceRecorder
    - **File**: AnimationRecorder.h
    
    """

    ALL: TimecodeBoneMode #: 0
    ROOT: TimecodeBoneMode #: 1
    USER_DEFINED: TimecodeBoneMode #: 2
    ...

class BakingKeySettings(EnumBase):
    r"""
    EBaking Key Settings
    
    **C++ Source:**
    
    - **Module**: MovieSceneTools
    - **File**: BakingAnimationKeySettings.h
    
    """

    KEYS_ONLY: BakingKeySettings #: 0
    ALL_FRAMES: BakingKeySettings #: 1
    ...

class FControlRigChannelEnum(EnumBase):
    r"""
    Enumeration specifying the control type and channel
    
    **C++ Source:**
    
    - **Module**: MovieSceneTools
    - **File**: MovieSceneToolsUserSettings.h
    
    """

    BOOL: FControlRigChannelEnum #: 0: Bool
    ENUM: FControlRigChannelEnum #: 1: Enum
    INTEGER: FControlRigChannelEnum #: 2: Integer
    FLOAT: FControlRigChannelEnum #: 3: Float
    VECTOR2DX: FControlRigChannelEnum #: 4: Vector2D.X
    VECTOR2DY: FControlRigChannelEnum #: 5: Vector2D.Y
    POSITION_X: FControlRigChannelEnum #: 6: Position.X
    POSITION_Y: FControlRigChannelEnum #: 7: Position.Y
    POSITION_Z: FControlRigChannelEnum #: 8: Position.Z
    ROTATOR_X: FControlRigChannelEnum #: 9: Rotator.X
    ROTATOR_Y: FControlRigChannelEnum #: 10: Rotator.Y
    ROTATOR_Z: FControlRigChannelEnum #: 11: Rotator.Z
    SCALE_X: FControlRigChannelEnum #: 12: Scale.X
    SCALE_Y: FControlRigChannelEnum #: 13: Scale.Y
    SCALE_Z: FControlRigChannelEnum #: 14: Scale.Z
    ...

class FTransformChannelEnum(EnumBase):
    r"""
    Enumeration specifying the transfrom channel
    
    **C++ Source:**
    
    - **Module**: MovieSceneTools
    - **File**: MovieSceneToolsUserSettings.h
    
    """

    TRANSLATE_X: FTransformChannelEnum #: 0
    TRANSLATE_Y: FTransformChannelEnum #: 1
    TRANSLATE_Z: FTransformChannelEnum #: 2
    ROTATE_X: FTransformChannelEnum #: 3
    ROTATE_Y: FTransformChannelEnum #: 4
    ROTATE_Z: FTransformChannelEnum #: 5
    SCALE_X: FTransformChannelEnum #: 6
    SCALE_Y: FTransformChannelEnum #: 7
    SCALE_Z: FTransformChannelEnum #: 8
    ...

class SequencerLoopMode(EnumBase):
    r"""
    ESequencer Loop Mode
    
    **C++ Source:**
    
    - **Module**: Sequencer
    - **File**: SequencerSettings.h
    
    """

    SLM_NO_LOOP: SequencerLoopMode #: 0: No Looping.
    SLM_LOOP: SequencerLoopMode #: 1: Loop Playback Range.
    SLM_LOOP_SELECTION_RANGE: SequencerLoopMode #: 2: Loop Selection Range.
    ...

class ControllerType(EnumBase):
    r"""
    EController Type
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorInteractor.h
    
    """

    LASER: ControllerType #: 0
    ASSISTING_LASER: ControllerType #: 1
    UI: ControllerType #: 2
    NAVIGATION: ControllerType #: 3
    UNKNOWN: ControllerType #: 4
    ...

class TouchSwipeDirection(EnumBase):
    r"""
    Directions the trackpad can be swiped to
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorInteractor.h
    
    """

    NONE: TouchSwipeDirection #: 0
    LEFT: TouchSwipeDirection #: 1
    RIGHT: TouchSwipeDirection #: 2
    UP: TouchSwipeDirection #: 3
    DOWN: TouchSwipeDirection #: 4
    ...

class XRDeviceConnectionResult(EnumBase):
    r"""
    Enumeration of results from Connecting to Remote XR device
    
    **C++ Source:**
    
    - **Module**: HeadMountedDisplay
    - **File**: HeadMountedDisplayTypes.h
    
    """

    NO_TRACKING_SYSTEM: XRDeviceConnectionResult #: 0
    FEATURE_NOT_SUPPORTED: XRDeviceConnectionResult #: 1
    NO_VALID_VIEWPORT: XRDeviceConnectionResult #: 2
    MISC_FAILURE: XRDeviceConnectionResult #: 3
    SUCCESS: XRDeviceConnectionResult #: 4
    ...

class XRSystemFlags(EnumBase):
    r"""
    Flags to better inform the user about specifics of the underlying XR system
    
    **C++ Source:**
    
    - **Module**: HeadMountedDisplay
    - **File**: HeadMountedDisplayTypes.h
    
    """

    IS_AR: XRSystemFlags #: 1
    IS_TABLET: XRSystemFlags #: 2
    IS_HEAD_MOUNTED: XRSystemFlags #: 4
    SUPPORTS_HAND_TRACKING: XRSystemFlags #: 8
    ...

class XRTrackedDeviceType(EnumBase):
    r"""
    EXRTracked Device Type
    
    **C++ Source:**
    
    - **Module**: HeadMountedDisplay
    - **File**: HeadMountedDisplayTypes.h
    
    """

    HEAD_MOUNTED_DISPLAY: XRTrackedDeviceType #: 0: Represents a head mounted display
    CONTROLLER: XRTrackedDeviceType #: 1: Represents a controller
    TRACKING_REFERENCE: XRTrackedDeviceType #: 2: Represents a static tracking reference device, such as a Lighthouse or tracking camera
    TRACKER: XRTrackedDeviceType #: 3: Represents trackers, such as a Vive tracker
    OTHER: XRTrackedDeviceType #: 4: Misc. device types, for future expansion
    ANY: XRTrackedDeviceType #: 255: Pass to EnumerateTrackedDevices to get all devices regardless of type
    ...

class HandKeypoint(EnumBase):
    r"""
    Transforms that are tracked on the hand.
    Matches the enums from WMR to make it a direct mapping
    
    **C++ Source:**
    
    - **Module**: HeadMountedDisplay
    - **File**: HeadMountedDisplayTypes.h
    
    """

    PALM: HandKeypoint #: 0
    WRIST: HandKeypoint #: 1
    THUMB_METACARPAL: HandKeypoint #: 2
    THUMB_PROXIMAL: HandKeypoint #: 3
    THUMB_DISTAL: HandKeypoint #: 4
    THUMB_TIP: HandKeypoint #: 5
    INDEX_METACARPAL: HandKeypoint #: 6
    INDEX_PROXIMAL: HandKeypoint #: 7
    INDEX_INTERMEDIATE: HandKeypoint #: 8
    INDEX_DISTAL: HandKeypoint #: 9
    INDEX_TIP: HandKeypoint #: 10
    MIDDLE_METACARPAL: HandKeypoint #: 11
    MIDDLE_PROXIMAL: HandKeypoint #: 12
    MIDDLE_INTERMEDIATE: HandKeypoint #: 13
    MIDDLE_DISTAL: HandKeypoint #: 14
    MIDDLE_TIP: HandKeypoint #: 15
    RING_METACARPAL: HandKeypoint #: 16
    RING_PROXIMAL: HandKeypoint #: 17
    RING_INTERMEDIATE: HandKeypoint #: 18
    RING_DISTAL: HandKeypoint #: 19
    RING_TIP: HandKeypoint #: 20
    LITTLE_METACARPAL: HandKeypoint #: 21
    LITTLE_PROXIMAL: HandKeypoint #: 22
    LITTLE_INTERMEDIATE: HandKeypoint #: 23
    LITTLE_DISTAL: HandKeypoint #: 24
    LITTLE_TIP: HandKeypoint #: 25
    ...

class XRVisualType(EnumBase):
    r"""
    EXRVisual Type
    
    **C++ Source:**
    
    - **Module**: HeadMountedDisplay
    - **File**: HeadMountedDisplayTypes.h
    
    """

    CONTROLLER: XRVisualType #: 0
    HAND: XRVisualType #: 1
    ...

class TrackingStatus(EnumBase):
    r"""
    ETracking Status
    
    **C++ Source:**
    
    - **Module**: HeadMountedDisplay
    - **File**: IMotionController.h
    
    """

    NOT_TRACKED: TrackingStatus #: 0
    INERTIAL_ONLY: TrackingStatus #: 1
    TRACKED: TrackingStatus #: 2
    ...

class HitResultGizmoFilterMode(EnumBase):
    r"""
    Filter mode for GetHitResultFromLaserPointer
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: ViewportInteractor.h
    
    """

    ALL: HitResultGizmoFilterMode #: 0
    NO_GIZMOS: HitResultGizmoFilterMode #: 1
    GIZMOS_ONLY: HitResultGizmoFilterMode #: 2
    ...

class GameplayContainerMatchType(EnumBase):
    r"""
    EGameplay Container Match Type
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagContainer.h
    
    """

    ANY: GameplayContainerMatchType #: 0: Means the filter is populated by any tag matches in this container.
    ALL: GameplayContainerMatchType #: 1: Means the filter is only populated if all of the tags in this container match.
    ...

class PathFollowingResult(EnumBase):
    r"""
    EPath Following Result
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PathFollowingComponent.h
    
    """

    SUCCESS: PathFollowingResult #: 0: Reached destination
    BLOCKED: PathFollowingResult #: 1: Movement was blocked
    OFF_PATH: PathFollowingResult #: 2: Agent is not on path
    ABORTED: PathFollowingResult #: 3: Aborted and stopped (failure)
    INVALID: PathFollowingResult #: 5: Request was invalid
    ...

class EnvQueryStatus(EnumBase):
    r"""
    EEnv Query Status
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryTypes.h
    
    """

    PROCESSING: EnvQueryStatus #: 0
    SUCCESS: EnvQueryStatus #: 1
    FAILED: EnvQueryStatus #: 2
    ABORTED: EnvQueryStatus #: 3
    OWNER_LOST: EnvQueryStatus #: 4
    MISSING_PARAM: EnvQueryStatus #: 5
    ...

class TeamAttitude(EnumBase):
    r"""
    ETeam Attitude
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: GenericTeamAgentInterface.h
    
    """

    FRIENDLY: TeamAttitude #: 0
    NEUTRAL: TeamAttitude #: 1
    HOSTILE: TeamAttitude #: 2
    ...

class BTNodeResult(EnumBase):
    r"""
    keep in sync with DescribeNodeResult()
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BehaviorTreeTypes.h
    
    """

    SUCCEEDED: BTNodeResult #: 0: finished as success
    FAILED: BTNodeResult #: 1: finished as failure
    ABORTED: BTNodeResult #: 2: finished aborting = failure
    IN_PROGRESS: BTNodeResult #: 3: not finished yet
    ...

class EnvTestDot(EnumBase):
    r"""
    EEnv Test Dot
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryTest_Dot.h
    
    """

    DOT3D: EnvTestDot #: 0: Fully 3D dot-product
    DOT2D: EnvTestDot #: 1: Dot Product in the XY-plane, which is equivalent to the cosine of the heading or yaw angle.
    ...

class PathFollowingStatus(EnumBase):
    r"""
    EPath Following Status
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PathFollowingComponent.h
    
    """

    IDLE: PathFollowingStatus #: 0: No requests
    WAITING: PathFollowingStatus #: 1: Request with incomplete path, will start after UpdateMove()
    PAUSED: PathFollowingStatus #: 2: Request paused, will continue after ResumeMove()
    MOVING: PathFollowingStatus #: 3: Following path
    ...

class PathFollowingAction(EnumBase):
    r"""
    DEPRECATED, will be removed with GetPathActionType function
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PathFollowingComponent.h
    
    """

    ERROR: PathFollowingAction #: 0
    NO_MOVE: PathFollowingAction #: 1
    DIRECT_MOVE: PathFollowingAction #: 2
    PARTIAL_PATH: PathFollowingAction #: 3
    PATH_TO_GOAL: PathFollowingAction #: 4
    ...

class PathFollowingRequestResult(EnumBase):
    r"""
    EPath Following Request Result
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PathFollowingComponent.h
    
    """

    FAILED: PathFollowingRequestResult #: 0
    ALREADY_AT_GOAL: PathFollowingRequestResult #: 1
    REQUEST_SUCCESSFUL: PathFollowingRequestResult #: 2
    ...

class ComponentMobility(EnumBase):
    r"""
    Describes how often this component is allowed to move.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    STATIC: ComponentMobility
    r"""
    0: Static objects cannot be moved or changed in game.
    - Allows baked lighting
    - Fastest rendering
    """

    STATIONARY: ComponentMobility
    r"""
    1: A stationary light will only have its shadowing and bounced lighting from static geometry baked by Lightmass, all other lighting will be dynamic.
    - It can change color and intensity in game.
    - Can't move
    - Allows partial baked lighting
    - Dynamic shadows
    """

    MOVABLE: ComponentMobility
    r"""
    2: Movable objects can be moved and changed in game.
    - Totally dynamic
    - Can cast dynamic shadows
    - Slowest rendering
    """

    ...

class ModifyFrequency(EnumBase):
    r"""
    deprecated: 'ModifyFrequency' was renamed to 'ComponentMobility'.
    """

    STATIC: ModifyFrequency
    r"""
    0: Static objects cannot be moved or changed in game.
    - Allows baked lighting
    - Fastest rendering
    """

    STATIONARY: ModifyFrequency
    r"""
    1: A stationary light will only have its shadowing and bounced lighting from static geometry baked by Lightmass, all other lighting will be dynamic.
    - It can change color and intensity in game.
    - Can't move
    - Allows partial baked lighting
    - Dynamic shadows
    """

    MOVABLE: ModifyFrequency
    r"""
    2: Movable objects can be moved and changed in game.
    - Totally dynamic
    - Can cast dynamic shadows
    - Slowest rendering
    """

    ...

class CollisionEnabled(EnumBase):
    r"""
    Enum used to describe what type of collision is enabled on a body.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    NO_COLLISION: CollisionEnabled #: 0: Will not create any representation in the physics engine. Cannot be used for spatial queries (raycasts, sweeps, overlaps) or simulation (rigid body, constraints). Best performance possible (especially for moving objects)
    QUERY_ONLY: CollisionEnabled #: 1: Only used for spatial queries (raycasts, sweeps, and overlaps). Cannot be used for simulation (rigid body, constraints). Useful for character movement and things that do not need physical simulation. Performance gains by keeping data out of simulation tree.
    PHYSICS_ONLY: CollisionEnabled #: 2: Only used only for physics simulation (rigid body, constraints). Cannot be used for spatial queries (raycasts, sweeps, overlaps). Useful for jiggly bits on characters that do not need per bone detection. Performance gains by keeping data out of query tree
    QUERY_AND_PHYSICS: CollisionEnabled #: 3: Can be used for both spatial queries (raycasts, sweeps, overlaps) and simulation (rigid body, constraints).
    PROBE_ONLY: CollisionEnabled
    r"""
    4: Only used for probing the physics simulation (rigid body, constraints). Cannot be used for spatial queries (raycasts,
                  sweeps, overlaps). Useful for when you want to detect potential physics interactions and pass contact data to hit callbacks
                  or contact modification, but don't want to physically react to these contacts.
    """

    QUERY_AND_PROBE: CollisionEnabled
    r"""
    5: Can be used for both spatial queries (raycasts, sweeps, overlaps) and probing the physics simulation (rigid body,
                  constraints). Will not allow for actual physics interaction, but will generate contact data, trigger hit callbacks, and
                  contacts will appear in contact modification.
    """

    ...

class CollisionChannel(EnumBase):
    r"""
    Enum indicating different type of objects for rigid-body collision purposes.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    ECC_WORLD_STATIC: CollisionChannel #: 0
    ECC_WORLD_DYNAMIC: CollisionChannel #: 1
    ECC_PAWN: CollisionChannel #: 2
    ECC_VISIBILITY: CollisionChannel #: 3
    ECC_CAMERA: CollisionChannel #: 4
    ECC_PHYSICS_BODY: CollisionChannel #: 5
    ECC_VEHICLE: CollisionChannel #: 6
    ECC_DESTRUCTIBLE: CollisionChannel #: 7
    ...

class CollisionResponseType(EnumBase):
    r"""
    Enum indicating how each type should respond
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    ECR_IGNORE: CollisionResponseType #: 0
    ECR_OVERLAP: CollisionResponseType #: 1
    ECR_BLOCK: CollisionResponseType #: 2
    ...

class WalkableSlopeBehavior(EnumBase):
    r"""
    Controls behavior of WalkableSlopeOverride, determining how to affect walkability of surfaces for Characters.
    see: FWalkableSlopeOverride
    see: UCharacterMovementComponent::GetWalkableFloorAngle(), UCharacterMovementComponent::SetWalkableFloorAngle()
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    WALKABLE_SLOPE_DEFAULT: WalkableSlopeBehavior #: 0: Don't affect the walkable slope. Walkable slope angle will be ignored.
    WALKABLE_SLOPE_INCREASE: WalkableSlopeBehavior
    r"""
    1: Increase walkable slope.
    Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles.
    see: FWalkableSlopeOverride::WalkableSlopeAngle
    """

    WALKABLE_SLOPE_DECREASE: WalkableSlopeBehavior
    r"""
    2: Decrease walkable slope.
    Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles.
    see: FWalkableSlopeOverride::WalkableSlopeAngle
    """

    WALKABLE_SLOPE_UNWALKABLE: WalkableSlopeBehavior
    r"""
    3: Make surface unwalkable.
    Note: WalkableSlopeAngle will be ignored.
    """

    ...

class DOFMode(EnumBase):
    r"""
    EDOFMode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BodyInstance.h
    
    """

    DEFAULT: DOFMode #: 0: Inherits the degrees of freedom from the project settings.
    SIX_DOF: DOFMode #: 1: Specifies which axis to freeze rotation and movement along.
    YZ_PLANE: DOFMode #: 2: Allows 2D movement along the Y-Z plane.
    XZ_PLANE: DOFMode #: 3: Allows 2D movement along the X-Z plane.
    XY_PLANE: DOFMode #: 4: Allows 2D movement along the X-Y plane.
    CUSTOM_PLANE: DOFMode #: 5: Allows 2D movement along the plane of a given normal
    NONE: DOFMode #: 6: No constraints.
    ...

class LockedAxis(EnumBase):
    r"""
    deprecated: 'LockedAxis' was renamed to 'DOFMode'.
    """

    DEFAULT: LockedAxis #: 0: Inherits the degrees of freedom from the project settings.
    SIX_DOF: LockedAxis #: 1: Specifies which axis to freeze rotation and movement along.
    YZ_PLANE: LockedAxis #: 2: Allows 2D movement along the Y-Z plane.
    XZ_PLANE: LockedAxis #: 3: Allows 2D movement along the X-Z plane.
    XY_PLANE: LockedAxis #: 4: Allows 2D movement along the X-Y plane.
    CUSTOM_PLANE: LockedAxis #: 5: Allows 2D movement along the plane of a given normal
    NONE: LockedAxis #: 6: No constraints.
    ...

class ChaosBreakingSortMethod(EnumBase):
    r"""
    Enumeration defining how to sort breaking results
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosBreakingEventFilter.h
    
    """

    SORT_NONE: ChaosBreakingSortMethod #: 0
    SORT_BY_HIGHEST_MASS: ChaosBreakingSortMethod #: 1
    SORT_BY_HIGHEST_SPEED: ChaosBreakingSortMethod #: 2
    SORT_BY_NEAREST_FIRST: ChaosBreakingSortMethod #: 3
    ...

class ChaosCollisionSortMethod(EnumBase):
    r"""
    Enumeration defining how to sort collision results
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosCollisionEventFilter.h
    
    """

    SORT_NONE: ChaosCollisionSortMethod #: 0
    SORT_BY_HIGHEST_MASS: ChaosCollisionSortMethod #: 1
    SORT_BY_HIGHEST_SPEED: ChaosCollisionSortMethod #: 2
    SORT_BY_HIGHEST_IMPULSE: ChaosCollisionSortMethod #: 3
    SORT_BY_NEAREST_FIRST: ChaosCollisionSortMethod #: 4
    ...

class ChaosRemovalSortMethod(EnumBase):
    r"""
    Enumeration defining how to sort removal results
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosRemovalEventFilter.h
    
    """

    SORT_NONE: ChaosRemovalSortMethod #: 0
    SORT_BY_HIGHEST_MASS: ChaosRemovalSortMethod #: 1
    SORT_BY_NEAREST_FIRST: ChaosRemovalSortMethod #: 2
    ...

class ChaosTrailingSortMethod(EnumBase):
    r"""
    Enumeration defining how to sort trailing results
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosTrailingEventFilter.h
    
    """

    SORT_NONE: ChaosTrailingSortMethod #: 0
    SORT_BY_HIGHEST_MASS: ChaosTrailingSortMethod #: 1
    SORT_BY_HIGHEST_SPEED: ChaosTrailingSortMethod #: 2
    SORT_BY_NEAREST_FIRST: ChaosTrailingSortMethod #: 3
    ...

class ToolShutdownType(EnumBase):
    r"""
    Passed to UInteractiveTool::Shutdown to indicate how Tool should shut itself down
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: InteractiveTool.h
    
    """

    COMPLETED: ToolShutdownType #: 0: Tool cleans up and exits. Pass this to tools that do not have Accept/Cancel options.
    ACCEPT: ToolShutdownType #: 1: Tool commits current preview to scene
    CANCEL: ToolShutdownType #: 2: Tool discards current preview without modifying scene
    ...

class SlateVisibility(EnumBase):
    r"""
    Is an entity visible?
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SlateWrapperTypes.h
    
    """

    VISIBLE: SlateVisibility #: 0: Visible and hit-testable (can interact with cursor). Default value.
    COLLAPSED: SlateVisibility #: 1: Not visible and takes up no space in the layout (obviously not hit-testable).
    HIDDEN: SlateVisibility #: 2: Not visible but occupies layout space (obviously not hit-testable).
    HIT_TEST_INVISIBLE: SlateVisibility #: 3: Visible but not hit-testable (cannot interact with cursor) and children in the hierarchy (if any) are also not hit-testable.
    SELF_HIT_TEST_INVISIBLE: SlateVisibility #: 4: Visible but not hit-testable (cannot interact with cursor) and doesn't affect hit-testing on children (if any).
    ...

class SlateAccessibleBehavior(EnumBase):
    r"""
    Whether a widget should be included in accessibility, and if so, how its text should be retrieved.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SlateWrapperTypes.h
    
    """

    NOT_ACCESSIBLE: SlateAccessibleBehavior #: 0: Not accessible.
    AUTO: SlateAccessibleBehavior
    r"""
    1: Accessible, first checking to see if there's any custom default text assigned for widgets of this type.
    If not, then it will attempt to use the alternate behavior (ie AccessibleSummaryBehavior instead of AccessibleBehavior)
    and return that value instead. This acts as a reference so that you only need to set one value for both of them
    to return the same thing.
    """

    SUMMARY: SlateAccessibleBehavior #: 2: Accessible, and traverse all child widgets and concat their AccessibleSummaryText together.
    CUSTOM: SlateAccessibleBehavior #: 3: Accessible, and retrieve manually-assigned text from a TAttribute.
    TOOL_TIP: SlateAccessibleBehavior #: 4: Accessible, and use the tooltip's accessible text.
    ...

class VirtualKeyboardType(EnumBase):
    r"""
    EVirtual Keyboard Type
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SlateWrapperTypes.h
    
    """

    DEFAULT: VirtualKeyboardType #: 0
    NUMBER: VirtualKeyboardType #: 1
    WEB: VirtualKeyboardType #: 2
    EMAIL: VirtualKeyboardType #: 3
    PASSWORD: VirtualKeyboardType #: 4
    ALPHA_NUMERIC: VirtualKeyboardType #: 5
    ...

class SlateSizeRule(EnumBase):
    r"""
    The sizing options of UWidgets
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SlateWrapperTypes.h
    
    """

    AUTOMATIC: SlateSizeRule #: 0: Only requests as much room as it needs based on the widgets desired size.
    FILL: SlateSizeRule #: 1: Greedily attempts to fill all available room based on the percentage value 0..1
    ...

class DynamicBoxType(EnumBase):
    r"""
    EDynamic Box Type
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: DynamicEntryBoxBase.h
    
    """

    HORIZONTAL: DynamicBoxType #: 0
    VERTICAL: DynamicBoxType #: 1
    WRAP: DynamicBoxType #: 2
    VERTICAL_WRAP: DynamicBoxType #: 3
    RADIAL: DynamicBoxType #: 4
    OVERLAY: DynamicBoxType #: 5
    ...

class WidgetSpace(EnumBase):
    r"""
    EWidget Space
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetComponent.h
    
    """

    WORLD: WidgetSpace #: 0: The widget is rendered in the world as mesh, it can be occluded like any other mesh in the world.
    SCREEN: WidgetSpace #: 1: The widget is rendered in the screen, completely outside of the world, never occluded.
    ...

class WidgetTimingPolicy(EnumBase):
    r"""
    EWidget Timing Policy
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetComponent.h
    
    """

    REAL_TIME: WidgetTimingPolicy #: 0: The widget will tick using real time. When not ticking, real time will accumulate and be simulated on the next tick.
    GAME_TIME: WidgetTimingPolicy #: 1: The widget will tick using game time, respecting pausing and time dilation.
    ...

class WidgetBlendMode(EnumBase):
    r"""
    EWidget Blend Mode
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetComponent.h
    
    """

    OPAQUE: WidgetBlendMode #: 0
    MASKED: WidgetBlendMode #: 1
    TRANSPARENT: WidgetBlendMode #: 2
    ...

class WidgetGeometryMode(EnumBase):
    r"""
    EWidget Geometry Mode
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetComponent.h
    
    """

    PLANE: WidgetGeometryMode #: 0: The widget is mapped onto a plane
    CYLINDER: WidgetGeometryMode #: 1: The widget is mapped onto a cylinder
    ...

class WindowVisibility(EnumBase):
    r"""
    EWindow Visibility
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetComponent.h
    
    """

    VISIBLE: WindowVisibility #: 0: The window visibility is Visible
    SELF_HIT_TEST_INVISIBLE: WindowVisibility #: 1: The window visibility is SelfHitTestInvisible
    ...

class TickMode(EnumBase):
    r"""
    ETick Mode
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetComponent.h
    
    """

    DISABLED: TickMode #: 0: The component tick is disabled until re-enabled.
    ENABLED: TickMode #: 1: The component is always ticked
    AUTOMATIC: TickMode #: 2: The component is ticked only when needed. i.e. when visible.
    ...

class WidgetInteractionSource(EnumBase):
    r"""
    The interaction source for the widget interaction component, e.g. where do we try and
    trace from to try to find a widget under a virtual pointer device.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetInteractionComponent.h
    
    """

    WORLD: WidgetInteractionSource #: 0: Sends traces from the world location and orientation of the interaction component.
    MOUSE: WidgetInteractionSource #: 1: Sends traces from the mouse location of the first local player controller.
    CENTER_SCREEN: WidgetInteractionSource #: 2: Sends trace from the center of the first local player's screen.
    CUSTOM: WidgetInteractionSource
    r"""
    3: Sends traces from a custom location determined by the user.  Will use whatever
    FHitResult is set by the call to SetCustomHitResult.
    """

    ...

class DragPivot(EnumBase):
    r"""
    Controls where the drag widget visual will appear when dragged relative to the pointer performing
    the drag operation.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: DragDropOperation.h
    
    """

    MOUSE_DOWN: DragPivot #: 0
    TOP_LEFT: DragPivot #: 1
    TOP_CENTER: DragPivot #: 2
    TOP_RIGHT: DragPivot #: 3
    CENTER_LEFT: DragPivot #: 4
    CENTER_CENTER: DragPivot #: 5
    CENTER_RIGHT: DragPivot #: 6
    BOTTOM_LEFT: DragPivot #: 7
    BOTTOM_CENTER: DragPivot #: 8
    BOTTOM_RIGHT: DragPivot #: 9
    ...

class WidgetAnimationEvent(EnumBase):
    r"""
    Different animation events.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UserWidget.h
    
    """

    STARTED: WidgetAnimationEvent #: 0
    FINISHED: WidgetAnimationEvent #: 1
    ...

class UMGSequencePlayMode(EnumBase):
    r"""
    Describes playback modes for UMG sequences.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UserWidget.h
    
    """

    FORWARD: UMGSequencePlayMode #: 0: Animation plays and loops from the beginning to the end.
    REVERSE: UMGSequencePlayMode #: 1: Animation plays and loops from the end to the beginning.
    PING_PONG: UMGSequencePlayMode #: 2: Animation plays from the beginning to the end and then from the end to the beginning.
    ...

class ContentBrowserPathType(EnumBase):
    r"""
    EContent Browser Path Type
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataSubsystem.h
    
    """

    NONE: ContentBrowserPathType #: 0: No path type set
    INTERNAL: ContentBrowserPathType #: 1: Internal path compatible with asset registry and engine calls (eg,. "/PluginA/MyFile")
    VIRTUAL: ContentBrowserPathType #: 2: Virtual path for enumerating Content Browser data (eg, "/All/Plugins/PluginA/MyFile")
    ...

class InterchangePipelineConfigurationDialogResult(EnumBase):
    r"""
    EInterchange Pipeline Configuration Dialog Result
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangePipelineConfigurationBase.h
    
    """

    CANCEL: InterchangePipelineConfigurationDialogResult #: 0
    IMPORT: InterchangePipelineConfigurationDialogResult #: 1
    IMPORT_ALL: InterchangePipelineConfigurationDialogResult #: 2
    ...

class AnimPoseSpaces(EnumBase):
    r"""
    EAnim Pose Spaces
    
    **C++ Source:**
    
    - **Module**: AnimationBlueprintLibrary
    - **File**: AnimPose.h
    
    """

    LOCAL: AnimPoseSpaces #: 0: Local (bone) space
    WORLD: AnimPoseSpaces #: 1: World (component) space
    ...

class AnimDataEvalType(EnumBase):
    r"""
    EAnim Data Eval Type
    
    **C++ Source:**
    
    - **Module**: AnimationBlueprintLibrary
    - **File**: AnimPose.h
    
    """

    SOURCE: AnimDataEvalType #: 0: Evaluates the original Animation Source data
    RAW: AnimDataEvalType #: 1: Evaluates the original Animation Source data with additive animation layers
    COMPRESSED: AnimDataEvalType #: 2: Evaluates the compressed Animation data - matching runtime (cooked)
    ...

class BoneModificationMode(EnumBase):
    r"""
    EBone Modification Mode
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_ModifyBone.h
    
    """

    BMM_IGNORE: BoneModificationMode #: 0: The modifier ignores this channel (keeps the existing bone translation, rotation, or scale).
    BMM_REPLACE: BoneModificationMode #: 1: The modifier replaces the existing translation, rotation, or scale.
    BMM_ADDITIVE: BoneModificationMode #: 2: The modifier adds to the existing translation, rotation, or scale.
    ...

class PoseDriverSource(EnumBase):
    r"""
    Transform aspect used to drive interpolation
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_PoseDriver.h
    
    """

    ROTATION: PoseDriverSource #: 0: Drive using rotation
    TRANSLATION: PoseDriverSource #: 1: Driver using translation
    ...

class PoseDriverOutput(EnumBase):
    r"""
    Options for what PoseDriver should be driving
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_PoseDriver.h
    
    """

    DRIVE_POSES: PoseDriverOutput #: 0: Use target's DrivenName to drive poses from the assigned PoseAsset
    DRIVE_CURVES: PoseDriverOutput #: 1: Use the target's DrivenName to drive curves
    ...

class SequenceEvalReinit(EnumBase):
    r"""
    ESequence Eval Reinit
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_SequenceEvaluator.h
    
    """

    NO_RESET: SequenceEvalReinit #: 0: Do not reset InternalTimeAccumulator
    START_POSITION: SequenceEvalReinit #: 1: Reset InternalTimeAccumulator to StartPosition
    EXPLICIT_TIME: SequenceEvalReinit #: 2: Reset InternalTimeAccumulator to ExplicitTime
    ...

class SwapRootBone(EnumBase):
    r"""
    ESwap Root Bone
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimSequencerInstanceProxy.h
    
    """

    SWAP_ROOT_BONE_COMPONENT: SwapRootBone #: 0: Swap the root bone to the component
    SWAP_ROOT_BONE_ACTOR: SwapRootBone #: 1: Swap root bone to the actor root component
    SWAP_ROOT_BONE_NONE: SwapRootBone #: 2: Do not swap the root bone
    ...

class AnimPhysSimSpaceType(EnumBase):
    r"""
    Anim Phys Sim Space Type
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_AnimDynamics.h
    
    """

    COMPONENT: AnimPhysSimSpaceType #: 0: Sim origin is the location/orientation of the skeletal mesh component.
    ACTOR: AnimPhysSimSpaceType #: 1: Sim origin is the location/orientation of the actor containing the skeletal mesh component.
    WORLD: AnimPhysSimSpaceType #: 2: Sim origin is the world origin. Teleporting characters is not recommended in this mode.
    ROOT_RELATIVE: AnimPhysSimSpaceType #: 3: Sim origin is the location/orientation of the root bone.
    BONE_RELATIVE: AnimPhysSimSpaceType #: 4: Sim origin is the location/orientation of the bone specified in RelativeSpaceBone
    ...

class ScaleChainInitialLength(EnumBase):
    r"""
    EScale Chain Initial Length
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_ScaleChainLength.h
    
    """

    FIXED_DEFAULT_LENGTH_VALUE: ScaleChainInitialLength #: 0: Use the 'DefaultChainLength' input value.
    DISTANCE: ScaleChainInitialLength #: 1: Use distance between 'ChainStartBone' and 'ChainEndBone' (in Component Space)
    CHAIN_LENGTH: ScaleChainInitialLength #: 2: Use animated chain length (length in local space of every bone from 'ChainStartBone' to 'ChainEndBone'
    ...

class WarpingEvaluationMode(EnumBase):
    r"""
    Specifies the evaluation mode of an animation warping node
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: BoneControllerTypes.h
    
    """

    MANUAL: WarpingEvaluationMode #: 0: Animation warping evaluation parameters are driven by user settings.
    GRAPH: WarpingEvaluationMode
    r"""
    1: Animation warping evaluation parameters are graph-driven. This means some
    properties of the node are automatically computed using the accumulated
    root motion delta contribution of the animation graph leading into it.
    """

    ...

class WarpingVectorMode(EnumBase):
    r"""
    The supported spaces of a corresponding input vector value
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: BoneControllerTypes.h
    
    """

    COMPONENT_SPACE_VECTOR: WarpingVectorMode #: 0: Component-space input vector
    ACTOR_SPACE_VECTOR: WarpingVectorMode #: 1: Actor-space input vector
    WORLD_SPACE_VECTOR: WarpingVectorMode #: 2: World-space input vector
    IK_FOOT_ROOT_LOCAL_SPACE_VECTOR: WarpingVectorMode #: 3: IK Foot Root relative local-space input vector
    ...

class MovieScene3DPathSection_Axis(EnumBase):
    r"""
    Movie Scene 3DPath Section Axis
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScene3DPathSection.h
    
    """

    X: MovieScene3DPathSection_Axis #: 0
    Y: MovieScene3DPathSection_Axis #: 1
    Z: MovieScene3DPathSection_Axis #: 2
    NEG_X: MovieScene3DPathSection_Axis #: 3
    NEG_Y: MovieScene3DPathSection_Axis #: 4
    NEG_Z: MovieScene3DPathSection_Axis #: 5
    ...

class MovieSceneCompletionMode(EnumBase):
    r"""
    Enumeration specifying how to handle state when this section is no longer evaluated
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneCompletionMode.h
    
    """

    KEEP_STATE: MovieSceneCompletionMode #: 0
    RESTORE_STATE: MovieSceneCompletionMode #: 1
    PROJECT_DEFAULT: MovieSceneCompletionMode #: 2
    ...

class MovieSceneEvaluationType(EnumBase):
    r"""
    EMovie Scene Evaluation Type
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneFwd.h
    
    """

    FRAME_LOCKED: MovieSceneEvaluationType #: 0: Play the sequence frame-locked to its playback rate (snapped to the tick resolution - no sub-frames)
    WITH_SUB_FRAMES: MovieSceneEvaluationType #: 1: Play the sequence in real-time, with sub-frame interpolation if necessary
    ...

class UpdateClockSource(EnumBase):
    r"""
    Enum used to define how to update to a particular time
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneFwd.h
    
    """

    TICK: UpdateClockSource #: 0: Use the default world tick delta for timing. Honors world and actor pause state, but is susceptible to accumulation errors
    PLATFORM: UpdateClockSource #: 1: Use the platform clock for timing. Does not honor world or actor pause state.
    AUDIO: UpdateClockSource #: 2: Use the audio clock for timing. Does not honor world or actor pause state.
    RELATIVE_TIMECODE: UpdateClockSource #: 3: Time relative to the timecode provider for timing. Does not honor world or actor pause state.
    TIMECODE: UpdateClockSource #: 4: Use current timecode provider for timing. Does not honor world or actor pause state.
    PLAY_EVERY_FRAME: UpdateClockSource #: 5: Debugging Tool: Hold on each whole frame for a Sequencer.SecondsPerFrame many wall-clock seconds before advancing to the next one. Does not honor world or actor pause state or time dilation and audio will be out of sync.
    CUSTOM: UpdateClockSource #: 6: Custom clock source created and defined externally.
    ...

class MovieSceneSubSectionFlags(EnumBase):
    r"""
    Flag structure that can be applied to any sub-section allowing control over various
    behaviors for the nested sub-sequence.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSectionParameters.h
    
    """

    NONE: MovieSceneSubSectionFlags #: 0
    OVERRIDE_KEEP_STATE: MovieSceneSubSectionFlags #: 1: When set, everything within the sub-section (including further sub-sections) should be keep-state. Mutually exclusive with OverrideRestoreState.
    OVERRIDE_RESTORE_STATE: MovieSceneSubSectionFlags #: 2: When set, everything within the sub-section (including further sub-sections) should be restore-state. Mutually exclusive with OverrideKeepState.
    IGNORE_HIERARCHICAL_BIAS: MovieSceneSubSectionFlags #: 4: Everything inside this sub-sequence should ignore hierarchical bias and always be relevant
    BLEND_HIERARCHICAL_BIAS: MovieSceneSubSectionFlags #: 8: Blend this sub sequence's hierarchical bias level using a higher -> lower override. Values from higher biases will override those in lower biases until a combined weight of 1 is reached.
    ANY_RESTORE_STATE_OVERRIDE: MovieSceneSubSectionFlags #: 3
    ...

class MovieSceneCompletionModeOverride(EnumBase):
    r"""
    Whether to override track sections' default completion mode when a sequence finishes.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSequencePlaybackSettings.h
    
    """

    NONE: MovieSceneCompletionModeOverride #: 0
    FORCE_KEEP_STATE: MovieSceneCompletionModeOverride #: 1
    FORCE_RESTORE_STATE: MovieSceneCompletionModeOverride #: 2
    ...

class MovieSceneTimeUnit(EnumBase):
    r"""
    Specifies which frame of reference you want to set/get time values in. This allows users to work
    in reference space without having to manually convert back and forth all of the time.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneTimeUnit.h
    
    """

    DISPLAY_RATE: MovieSceneTimeUnit #: 0: Display Rate matches the values shown in the UI such as 30fps giving you 30 frames per second. Supports sub-frame values (precision limited to Tick Resolution)
    TICK_RESOLUTION: MovieSceneTimeUnit #: 1: Tick Resolution is the internal resolution that data is actually stored in, such as 24000 giving you 24,000 frames per second. This is the smallest interval that data can be stored on.
    ...

class SequenceTimeUnit(EnumBase):
    r"""
    deprecated: 'SequenceTimeUnit' was renamed to 'MovieSceneTimeUnit'.
    """

    DISPLAY_RATE: SequenceTimeUnit #: 0: Display Rate matches the values shown in the UI such as 30fps giving you 30 frames per second. Supports sub-frame values (precision limited to Tick Resolution)
    TICK_RESOLUTION: SequenceTimeUnit #: 1: Tick Resolution is the internal resolution that data is actually stored in, such as 24000 giving you 24,000 frames per second. This is the smallest interval that data can be stored on.
    ...

class MovieSceneBlendType(EnumBase):
    r"""
    Movie scene blend type enumeration
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneBlendType.h
    
    """

    ABSOLUTE: MovieSceneBlendType #: 1: Blends all other weighted values together as an average of the total weight
    ADDITIVE: MovieSceneBlendType #: 2: Applies this value as a sum total of all other additives
    RELATIVE: MovieSceneBlendType #: 4: Applies this value as a sum total of all other additives and the initial value before the animation
    ADDITIVE_FROM_BASE: MovieSceneBlendType #: 8: Applies this value as an additive equal to the difference between the current value and the first value
    ...

class UpdatePositionMethod(EnumBase):
    r"""
    Enum used to define how to update to a particular time
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSequencePlayer.h
    
    """

    PLAY: UpdatePositionMethod #: 0: Update from the current position to a specified position (including triggering events), using the current player status
    JUMP: UpdatePositionMethod #: 1: Jump to a specified position (without triggering events in between), using the current player status
    SCRUB: UpdatePositionMethod #: 2: Jump to a specified position, temporarily using EMovieScenePlayerStatus::Scrubbing
    ...

class MovieScenePositionType(EnumBase):
    r"""
    EMovie Scene Position Type
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSequencePlayer.h
    
    """

    FRAME: MovieScenePositionType #: 0
    TIME: MovieScenePositionType #: 1
    MARKED_FRAME: MovieScenePositionType #: 2
    TIMECODE: MovieScenePositionType #: 3
    ...

class MediaPlayerOptionBooleanOverride(EnumBase):
    r"""
    EMedia Player Option Boolean Override
    
    **C++ Source:**
    
    - **Module**: MediaUtils
    - **File**: MediaPlayerOptions.h
    
    """

    USE_MEDIA_PLAYER_SETTING: MediaPlayerOptionBooleanOverride #: 0
    ENABLED: MediaPlayerOptionBooleanOverride #: 1
    DISABLED: MediaPlayerOptionBooleanOverride #: 2
    ...

class MediaPlayerOptionSeekTimeType(EnumBase):
    r"""
    EMedia Player Option Seek Time Type
    
    **C++ Source:**
    
    - **Module**: MediaUtils
    - **File**: MediaPlayerOptions.h
    
    """

    IGNORED: MediaPlayerOptionSeekTimeType #: 0: Ignore the given value and lets the media player choose.
    RELATIVE_TO_START_TIME: MediaPlayerOptionSeekTimeType #: 1: Given seek time is relative to the start of the media.
    ...

class MediaPlayerOptionTrackSelectMode(EnumBase):
    r"""
    EMedia Player Option Track Select Mode
    
    **C++ Source:**
    
    - **Module**: MediaUtils
    - **File**: MediaPlayerOptions.h
    
    """

    USE_MEDIA_PLAYER_DEFAULTS: MediaPlayerOptionTrackSelectMode #: 0: Let the media player choose defaults.
    USE_TRACK_OPTION_INDICES: MediaPlayerOptionTrackSelectMode #: 1: Use fixed track indices as specified with MediaPlayerTrackOptions
    ...

class AudioDeviceChangedRole(EnumBase):
    r"""
    EAudioDeviceChangedRole
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioDeviceNotificationSubsystem.h
    
    """

    INVALID: AudioDeviceChangedRole #: 0
    CONSOLE: AudioDeviceChangedRole #: 1
    MULTIMEDIA: AudioDeviceChangedRole #: 2
    COMMUNICATIONS: AudioDeviceChangedRole #: 3
    ...

class AudioDeviceChangedState(EnumBase):
    r"""
    EAudioDeviceChangedState
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioDeviceNotificationSubsystem.h
    
    """

    INVALID: AudioDeviceChangedState #: 0
    ACTIVE: AudioDeviceChangedState #: 1
    DISABLED: AudioDeviceChangedState #: 2
    NOT_PRESENT: AudioDeviceChangedState #: 3
    UNPLUGGED: AudioDeviceChangedState #: 4
    ...

class SwapAudioOutputDeviceResultState(EnumBase):
    r"""
    Resulting State of SwapAudioOutputDevice call
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerBlueprintLibrary.h
    
    """

    FAILURE: SwapAudioOutputDeviceResultState #: 0
    SUCCESS: SwapAudioOutputDeviceResultState #: 1
    NONE: SwapAudioOutputDeviceResultState #: 2
    ...

class MusicalNoteName(EnumBase):
    r"""
    EMusical Note Name
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerBlueprintLibrary.h
    
    """

    C: MusicalNoteName #: 0
    DB: MusicalNoteName #: 1
    D: MusicalNoteName #: 2
    EB: MusicalNoteName #: 3
    E: MusicalNoteName #: 4
    F: MusicalNoteName #: 5
    GB: MusicalNoteName #: 6
    G: MusicalNoteName #: 7
    AB: MusicalNoteName #: 8
    A: MusicalNoteName #: 9
    BB: MusicalNoteName #: 10
    B: MusicalNoteName #: 11
    ...

class SubmixEffectDynamicsProcessorType(EnumBase):
    r"""
    ESubmix Effect Dynamics Processor Type
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectDynamicsProcessor.h
    
    """

    COMPRESSOR: SubmixEffectDynamicsProcessorType #: 0
    LIMITER: SubmixEffectDynamicsProcessorType #: 1
    EXPANDER: SubmixEffectDynamicsProcessorType #: 2
    GATE: SubmixEffectDynamicsProcessorType #: 3
    UPWARDS_COMPRESSOR: SubmixEffectDynamicsProcessorType #: 4
    ...

class SubmixEffectDynamicsPeakMode(EnumBase):
    r"""
    ESubmix Effect Dynamics Peak Mode
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectDynamicsProcessor.h
    
    """

    MEAN_SQUARED: SubmixEffectDynamicsPeakMode #: 0
    ROOT_MEAN_SQUARED: SubmixEffectDynamicsPeakMode #: 1
    PEAK: SubmixEffectDynamicsPeakMode #: 2
    ...

class SubmixEffectDynamicsChannelLinkMode(EnumBase):
    r"""
    ESubmix Effect Dynamics Channel Link Mode
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectDynamicsProcessor.h
    
    """

    DISABLED: SubmixEffectDynamicsChannelLinkMode #: 0
    AVERAGE: SubmixEffectDynamicsChannelLinkMode #: 1
    PEAK: SubmixEffectDynamicsChannelLinkMode #: 2
    ...

class SubmixEffectDynamicsKeySource(EnumBase):
    r"""
    ESubmix Effect Dynamics Key Source
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectDynamicsProcessor.h
    
    """

    DEFAULT: SubmixEffectDynamicsKeySource #: 0: Defaults to use local submix (input) as key
    AUDIO_BUS: SubmixEffectDynamicsKeySource #: 1: Uses audio bus as key
    SUBMIX: SubmixEffectDynamicsKeySource #: 2: Uses external submix as key
    ...

class MediaPlayerTrack(EnumBase):
    r"""
    Media track types.
    
    Note: Keep this in sync with EMediaTrackType
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaPlayer.h
    
    """

    AUDIO: MediaPlayerTrack #: 0: Audio track.
    CAPTION: MediaPlayerTrack #: 1: Caption track.
    METADATA: MediaPlayerTrack #: 2: Metadata track.
    SCRIPT: MediaPlayerTrack #: 3: Script track.
    SUBTITLE: MediaPlayerTrack #: 4: Subtitle track.
    TEXT: MediaPlayerTrack #: 5: Text track.
    VIDEO: MediaPlayerTrack #: 6: Video track.
    ...

class MediaTimeRangeBPType(EnumBase):
    r"""
    Blueprint usable enum of EMediaTimeRangeType
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaPlayer.h
    
    """

    ABSOLUTE: MediaTimeRangeBPType #: 0: Total absolute time range as defined by the media.
    CURRENT: MediaTimeRangeBPType #: 1: Current time range of the media, set by media internal means or through API calls.
    ...

class MediaSoundComponentFFTSize(EnumBase):
    r"""
    EMedia Sound Component FFTSize
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaSoundComponent.h
    
    """

    MIN_64: MediaSoundComponentFFTSize #: 0
    SMALL_256: MediaSoundComponentFFTSize #: 1
    MEDIUM_512: MediaSoundComponentFFTSize #: 2
    LARGE_1024: MediaSoundComponentFFTSize #: 3
    ...

class MediaAudioCaptureDeviceFilter(EnumBase):
    r"""
    Filter flags for the EnumerateAudioCaptureDevices BP function.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaBlueprintFunctionLibrary.h
    
    """

    CARD: MediaAudioCaptureDeviceFilter #: 1: Audio capture cards.
    MICROPHONE: MediaAudioCaptureDeviceFilter #: 2: Microphone.
    SOFTWARE: MediaAudioCaptureDeviceFilter #: 4: Software device.
    UNKNOWN: MediaAudioCaptureDeviceFilter #: 8: Unknown audio capture device types.
    ...

class MediaVideoCaptureDeviceFilter(EnumBase):
    r"""
    Filter flags for the EnumerateVideoCaptureDevices BP function.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaBlueprintFunctionLibrary.h
    
    """

    CARD: MediaVideoCaptureDeviceFilter #: 1: Video capture card.
    SOFTWARE: MediaVideoCaptureDeviceFilter #: 2: Software video capture device.
    UNKNOWN: MediaVideoCaptureDeviceFilter #: 4: Unknown video capture device types.
    WEBCAM: MediaVideoCaptureDeviceFilter #: 8: Web cam.
    ...

class MediaWebcamCaptureDeviceFilter(EnumBase):
    r"""
    Filter flags for the EnumerateWebcamCaptureDevices BP function.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaBlueprintFunctionLibrary.h
    
    """

    DEPTH_SENSOR: MediaWebcamCaptureDeviceFilter #: 1: Depth sensor.
    FRONT: MediaWebcamCaptureDeviceFilter #: 2: Front facing web cam.
    REAR: MediaWebcamCaptureDeviceFilter #: 4: Rear facing web cam.
    UNKNOWN: MediaWebcamCaptureDeviceFilter #: 8: Unknown web cam types.
    ...

class CSVImportType(EnumBase):
    r"""
    Enum to indicate what to import CSV as
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CSVImportFactory.h
    
    """

    ECSV_DATA_TABLE: CSVImportType #: 0: Import as UDataTable
    ECSV_CURVE_TABLE: CSVImportType #: 1: Import as UCurveTable
    ECSV_CURVE_FLOAT: CSVImportType #: 2: Import as a UCurveFloat
    ECSV_CURVE_VECTOR: CSVImportType #: 3: Import as a UCurveVector
    ECSV_CURVE_LINEAR_COLOR: CSVImportType #: 4: Import as a UCurveLinearColor
    ...

class LevelVisibilityDirtyMode(EnumBase):
    r"""
    ELevel Visibility Dirty Mode
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorLevelUtils.h
    
    """

    MODIFY_ON_CHANGE: LevelVisibilityDirtyMode #: 0: Use when the user is causing the visibility change.  Will update transaction state and mark the package dirty.
    DONT_MODIFY: LevelVisibilityDirtyMode #: 1: Use when code is causing the visibility change.
    ...

class AssetEditorOpenLocation(EnumBase):
    r"""
    EAsset Editor Open Location
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorStyleSettings.h
    
    """

    DEFAULT: AssetEditorOpenLocation #: 0: Attempts to dock asset editors into either a new window, or the main window if they were docked there.
    NEW_WINDOW: AssetEditorOpenLocation #: 1: Docks tabs into new windows.
    MAIN_WINDOW: AssetEditorOpenLocation #: 2: Docks tabs into the main window.
    CONTENT_BROWSER: AssetEditorOpenLocation #: 3: Docks tabs into the content browser's window.
    LAST_DOCKED_WINDOW_OR_NEW_WINDOW: AssetEditorOpenLocation #: 4: Docks tabs into the last window that was docked into, or a new window if there is no last docked window.
    LAST_DOCKED_WINDOW_OR_MAIN_WINDOW: AssetEditorOpenLocation #: 5: Docks tabs into the last window that was docked into, or the main window if there is no last docked window.
    LAST_DOCKED_WINDOW_OR_CONTENT_BROWSER: AssetEditorOpenLocation #: 6: Docks tabs into the last window that was docked into, or the content browser window if there is no last docked window.
    ...

class FBXAnimationLengthImportType(EnumBase):
    r"""
    Animation length type when importing
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxAnimSequenceImportData.h
    
    """

    FBXALIT_EXPORTED_TIME: FBXAnimationLengthImportType #: 0: This option imports animation frames based on what is defined at the time of export
    FBXALIT_ANIMATED_KEY: FBXAnimationLengthImportType #: 1: Will import the range of frames that have animation. Can be useful if the exported range is longer than the actual animation in the FBX file
    FBXALIT_SET_RANGE: FBXAnimationLengthImportType #: 2: This will enable the Start Frame and End Frame properties for you to define the frames of animation to import
    ...

class FbxExportCompatibility(EnumBase):
    r"""
    Fbx export compatibility
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxExportOption.h
    
    """

    FBX_2011: FbxExportCompatibility #: 0
    FBX_2012: FbxExportCompatibility #: 1
    FBX_2013: FbxExportCompatibility #: 2
    FBX_2014: FbxExportCompatibility #: 3
    FBX_2016: FbxExportCompatibility #: 4
    FBX_2018: FbxExportCompatibility #: 5
    FBX_2019: FbxExportCompatibility #: 6
    FBX_2020: FbxExportCompatibility #: 7
    ...

class MovieSceneBakeType(EnumBase):
    r"""
    Bake options for animated properties of exported objects
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxExportOption.h
    
    """

    NONE: MovieSceneBakeType #: 0
    BAKE_CHANNELS: MovieSceneBakeType #: 1
    BAKE_TRANSFORMS: MovieSceneBakeType #: 2
    BAKE_ALL: MovieSceneBakeType #: 3
    ...

class FBXImportType(EnumBase):
    r"""
    Import mesh type
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxImportUI.h
    
    """

    FBXIT_STATIC_MESH: FBXImportType #: 0: Select Static Mesh if you'd like to import static mesh.
    FBXIT_SKELETAL_MESH: FBXImportType #: 1: Select Skeletal Mesh if you'd like to import skeletal mesh.
    FBXIT_ANIMATION: FBXImportType #: 2: Select Animation if you'd like to import only animation.
    ...

class FBXNormalImportMethod(EnumBase):
    r"""
    EFBXNormal Import Method
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxMeshImportData.h
    
    """

    FBXNIM_COMPUTE_NORMALS: FBXNormalImportMethod #: 0
    FBXNIM_IMPORT_NORMALS: FBXNormalImportMethod #: 1
    FBXNIM_IMPORT_NORMALS_AND_TANGENTS: FBXNormalImportMethod #: 2
    ...

class FBXNormalGenerationMethod(EnumBase):
    r"""
    EFBXNormal Generation Method
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxMeshImportData.h
    
    """

    BUILT_IN: FBXNormalGenerationMethod #: 0: Use the legacy built in method to generate normals (faster in some cases)
    MIKK_T_SPACE: FBXNormalGenerationMethod #: 1: Use MikkTSpace to generate normals and tangents
    ...

class VertexColorImportOption(EnumBase):
    r"""
    EVertex Color Import Option
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxMeshImportData.h
    
    """

    REPLACE: VertexColorImportOption #: 0: Import the static mesh using the vertex colors from the FBX file.
    IGNORE: VertexColorImportOption #: 1: Ignore vertex colors from the FBX file, and keep the existing mesh vertex colors.
    OVERRIDE: VertexColorImportOption #: 2: Override all vertex colors with the specified color.
    ...

class FBXSceneOptionsCreateHierarchyType(EnumBase):
    r"""
    EFBXScene Options Create Hierarchy Type
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxSceneImportOptions.h
    
    """

    FBXSOCHT_CREATE_LEVEL_ACTORS: FBXSceneOptionsCreateHierarchyType #: 0: Create an actor for every node in the fbx hierarchy. No reimport of the hierarchy.
    FBXSOCHT_CREATE_ACTOR_COMPONENTS: FBXSceneOptionsCreateHierarchyType #: 1: Create one actor and a component for every node in the fbx hierarchy. No reimport of the hierarchy.
    FBXSOCHT_CREATE_BLUEPRINT: FBXSceneOptionsCreateHierarchyType #: 2: Create one blueprint and a component for every node in the fbx hierarchy. Hierarchy can be reimport.
    ...

class FbxSceneVertexColorImportOption(EnumBase):
    r"""
    EFbx Scene Vertex Color Import Option
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxSceneImportOptionsStaticMesh.h
    
    """

    REPLACE: FbxSceneVertexColorImportOption #: 0: Import the static mesh using the vertex colors from the FBX file.
    IGNORE: FbxSceneVertexColorImportOption #: 1: Ignore vertex colors from the FBX file, and keep the existing mesh vertex colors.
    OVERRIDE: FbxSceneVertexColorImportOption #: 2: Override all vertex colors with the specified color.
    ...

class FBXSceneNormalImportMethod(EnumBase):
    r"""
    EFBXScene Normal Import Method
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxSceneImportOptionsStaticMesh.h
    
    """

    FBX_SCENE_NIM_COMPUTE_NORMALS: FBXSceneNormalImportMethod #: 0
    FBX_SCENE_NIM_IMPORT_NORMALS: FBXSceneNormalImportMethod #: 1
    FBX_SCENE_NIM_IMPORT_NORMALS_AND_TANGENTS: FBXSceneNormalImportMethod #: 2
    ...

class FBXSceneNormalGenerationMethod(EnumBase):
    r"""
    EFBXScene Normal Generation Method
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxSceneImportOptionsStaticMesh.h
    
    """

    BUILT_IN: FBXSceneNormalGenerationMethod #: 0: Use the legacy built in method to generate normals (faster in some cases)
    MIKK_T_SPACE: FBXSceneNormalGenerationMethod #: 1: Use MikkTSpace to generate normals and tangents
    ...

class FBXImportContentType(EnumBase):
    r"""
    EFBXImport Content Type
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxSkeletalMeshImportData.h
    
    """

    FBXICT_ALL: FBXImportContentType #: 0: Import all fbx content: geometry, skinning and weights.
    FBXICT_GEOMETRY: FBXImportContentType #: 1: Import the skeletal mesh geometry only (will create a default skeleton, or map the geometry to the existing one). Morph and LOD can be imported with it.
    FBXICT_SKINNING_WEIGHTS: FBXImportContentType #: 2: Import the skeletal mesh skinning and weights only (no geometry will be imported). Morph and LOD will not be imported with this settings.
    ...

class MaterialSearchLocation(EnumBase):
    r"""
    EMaterial Search Location
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialImportHelpers.h
    
    """

    LOCAL: MaterialSearchLocation #: 0: Search for matching material in local import folder only.
    UNDER_PARENT: MaterialSearchLocation #: 1: Search for matching material recursively from parent folder.
    UNDER_ROOT: MaterialSearchLocation #: 2: Search for matching material recursively from root folder.
    ALL_ASSETS: MaterialSearchLocation #: 3: Search for matching material in all assets folders.
    DO_NOT_SEARCH: MaterialSearchLocation #: 4: Do not search for existing matching materials
    ...

class SimulationOverlap(EnumBase):
    r"""
    ESimulation Overlap
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: ProceduralFoliageInstance.h
    
    """

    COLLISION_OVERLAP: SimulationOverlap #: 0: Instances overlap with collision
    SHADE_OVERLAP: SimulationOverlap #: 1: Instances overlap with shade
    NONE: SimulationOverlap #: 2: No overlap
    ...

class SimulationQuery(EnumBase):
    r"""
    ESimulation Query
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: ProceduralFoliageInstance.h
    
    """

    COLLISION_OVERLAP: SimulationQuery #: 1: Instances overlap with collision
    SHADE_OVERLAP: SimulationQuery #: 2: Instances overlap with shade
    ANY_OVERLAP: SimulationQuery #: 3: any overlap
    ...

class SparseVolumeTexturePreviewAttribute(EnumBase):
    r"""
    ESparse Volume Texture Preview Attribute
    
    **C++ Source:**
    
    - **Module**: Renderer
    - **File**: SparseVolumeTextureViewerComponent.h
    
    """

    ESVTPA_ATTRIBUTES_A_R: SparseVolumeTexturePreviewAttribute #: 0
    ESVTPA_ATTRIBUTES_A_G: SparseVolumeTexturePreviewAttribute #: 1
    ESVTPA_ATTRIBUTES_A_B: SparseVolumeTexturePreviewAttribute #: 2
    ESVTPA_ATTRIBUTES_A_A: SparseVolumeTexturePreviewAttribute #: 3
    ESVTPA_ATTRIBUTES_B_R: SparseVolumeTexturePreviewAttribute #: 4
    ESVTPA_ATTRIBUTES_B_G: SparseVolumeTexturePreviewAttribute #: 5
    ESVTPA_ATTRIBUTES_B_B: SparseVolumeTexturePreviewAttribute #: 6
    ESVTPA_ATTRIBUTES_B_A: SparseVolumeTexturePreviewAttribute #: 7
    ...

class AnimAssetCurveFlags(EnumBase):
    r"""
    This is curve flags that are saved in asset and *
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCurveTypes.h
    
    """

    AACF_EDITABLE: AnimAssetCurveFlags
    r"""
    4: Set per skeleton. DO NOT REMOVE UNTIL FrameworkObjectVersion.MoveCurveTypesToSkeleton expires.
    Is editable in Sequence Editor
    """

    AACF_METADATA: AnimAssetCurveFlags
    r"""
    16: This has moved to FAnimCurveType:bMaterial. Set per skeleton. DO NOT REMOVE UNTIL FrameworkObjectVersion.MoveCurveTypesToSkeleton expires.
    Is a metadata 'curve'
    """

    ...

class RawCurveTrackTypes(EnumBase):
    r"""
    ERaw Curve Track Types
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCurveTypes.h
    
    """

    RCT_FLOAT: RawCurveTrackTypes #: 0
    RCT_TRANSFORM: RawCurveTrackTypes #: 2
    ...

class BoneControlSpace(EnumBase):
    r"""
    Enum for controlling which reference frame a controller is applied in.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """

    BCS_WORLD_SPACE: BoneControlSpace #: 0: Set absolute position of bone in world space.
    BCS_COMPONENT_SPACE: BoneControlSpace #: 1: Set position of bone in SkeletalMeshComponent's reference frame.
    BCS_PARENT_BONE_SPACE: BoneControlSpace #: 2: Set position of bone relative to parent bone.
    BCS_BONE_SPACE: BoneControlSpace #: 3: Set position of bone in its own reference frame.
    ...

class AnimInterpolationType(EnumBase):
    r"""
    Indicates how animation should be evaluated between keys.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """

    LINEAR: AnimInterpolationType #: 0: Linear interpolation when looking up values between keys.
    STEP: AnimInterpolationType #: 1: Step interpolation when looking up values between keys.
    ...

class DataLayerType(EnumBase):
    r"""
    EData Layer Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayerType.h
    
    """

    RUNTIME: DataLayerType #: 0
    EDITOR: DataLayerType #: 1
    ...

class InputEventType(EnumBase):
    r"""
    EInputEvent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineBaseTypes.h
    
    """

    IE_PRESSED: InputEventType #: 0
    IE_RELEASED: InputEventType #: 1
    IE_REPEAT: InputEventType #: 2
    IE_DOUBLE_CLICK: InputEventType #: 3
    IE_AXIS: InputEventType #: 4
    ...

class DemoPlayFailure(EnumBase):
    r"""
    Types of demo play failures broadcast from the engine
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineBaseTypes.h
    
    """

    GENERIC: DemoPlayFailure #: 0: A Generic failure.
    DEMO_NOT_FOUND: DemoPlayFailure #: 1: Demo was not found.
    CORRUPT: DemoPlayFailure #: 2: Demo is corrupt.
    INVALID_VERSION: DemoPlayFailure #: 3: Invalid version.
    INIT_BASE: DemoPlayFailure #: 4: InitBase failed.
    GAME_SPECIFIC_HEADER: DemoPlayFailure #: 5: Failed to process game specific header.
    REPLAY_STREAMER_INTERNAL: DemoPlayFailure #: 6: Replay streamer had an internal error.
    LOAD_MAP: DemoPlayFailure #: 7: LoadMap failed.
    SERIALIZATION: DemoPlayFailure #: 8: Error serializing data stream.
    ...

class BlendMode(EnumBase):
    r"""
    The blending mode for materials
    warning: This is mirrored in Lightmass, be sure to update the blend mode structure and logic there if this changes.
    warning: Check UMaterialInstance::Serialize if changed!!
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    BLEND_OPAQUE: BlendMode #: 0
    BLEND_MASKED: BlendMode #: 1
    BLEND_TRANSLUCENT: BlendMode #: 2
    BLEND_ADDITIVE: BlendMode #: 3
    BLEND_MODULATE: BlendMode #: 4
    BLEND_ALPHA_COMPOSITE: BlendMode #: 5
    BLEND_ALPHA_HOLDOUT: BlendMode #: 6
    BLEND_TRANSLUCENT_COLORED_TRANSMITTANCE: BlendMode #: 7
    ...

class MaterialSamplerType(EnumBase):
    r"""
    Describes how textures are sampled for materials
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    SAMPLERTYPE_COLOR: MaterialSamplerType #: 0
    SAMPLERTYPE_GRAYSCALE: MaterialSamplerType #: 1
    SAMPLERTYPE_ALPHA: MaterialSamplerType #: 2
    SAMPLERTYPE_NORMAL: MaterialSamplerType #: 3
    SAMPLERTYPE_MASKS: MaterialSamplerType #: 4
    SAMPLERTYPE_DISTANCE_FIELD_FONT: MaterialSamplerType #: 5
    SAMPLERTYPE_LINEAR_COLOR: MaterialSamplerType #: 6
    SAMPLERTYPE_LINEAR_GRAYSCALE: MaterialSamplerType #: 7
    SAMPLERTYPE_DATA: MaterialSamplerType #: 8
    SAMPLERTYPE_EXTERNAL: MaterialSamplerType #: 9
    SAMPLERTYPE_VIRTUAL_COLOR: MaterialSamplerType #: 10
    SAMPLERTYPE_VIRTUAL_GRAYSCALE: MaterialSamplerType #: 11
    SAMPLERTYPE_VIRTUAL_ALPHA: MaterialSamplerType #: 12
    SAMPLERTYPE_VIRTUAL_NORMAL: MaterialSamplerType #: 13
    SAMPLERTYPE_VIRTUAL_MASKS: MaterialSamplerType #: 14
    SAMPLERTYPE_VIRTUAL_LINEAR_COLOR: MaterialSamplerType #: 15: No DistanceFiledFont Virtual
    SAMPLERTYPE_VIRTUAL_LINEAR_GRAYSCALE: MaterialSamplerType #: 16
    ...

class LightingBuildQuality(EnumBase):
    r"""
    Lighting build quality enumeration
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    QUALITY_PREVIEW: LightingBuildQuality #: 0
    QUALITY_MEDIUM: LightingBuildQuality #: 1
    QUALITY_HIGH: LightingBuildQuality #: 2
    QUALITY_PRODUCTION: LightingBuildQuality #: 3
    ...

class NetworkSmoothingMode(EnumBase):
    r"""
    Smoothing approach used by network interpolation for Characters.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    DISABLED: NetworkSmoothingMode #: 0: No smoothing, only change position as network position updates are received.
    LINEAR: NetworkSmoothingMode #: 1: Linear interpolation from source to target.
    EXPONENTIAL: NetworkSmoothingMode #: 2: Exponential. Faster as you are further from target.
    ...

class OverlapFilterOption(EnumBase):
    r"""
    Specifies what types of objects to return from an overlap physics query
    warning: If you change this, change GetCollisionChannelFromOverlapFilter() to match
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    OVERLAP_FILTER_ALL: OverlapFilterOption #: 0: Returns both overlaps with both dynamic and static components
    OVERLAP_FILTER_DYNAMIC_ONLY: OverlapFilterOption #: 1: returns only overlaps with dynamic actors (far fewer results in practice, much more efficient)
    OVERLAP_FILTER_STATIC_ONLY: OverlapFilterOption #: 2: returns only overlaps with static actors (fewer results, more efficient)
    ...

class NetRole(EnumBase):
    r"""
    The network role of an actor on a local/remote network context
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    ROLE_NONE: NetRole #: 0: No role at all.
    ROLE_SIMULATED_PROXY: NetRole #: 1: Locally simulated proxy of this actor.
    ROLE_AUTONOMOUS_PROXY: NetRole #: 2: Locally autonomous proxy of this actor.
    ROLE_AUTHORITY: NetRole #: 3: Authoritative control over the actor.
    ...

class NetDormancy(EnumBase):
    r"""
    Describes if an actor can enter a low network bandwidth dormant mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    DORM_NEVER: NetDormancy #: 0: This actor can never go network dormant.
    DORM_AWAKE: NetDormancy #: 1: This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant.
    DORM_DORMANT_ALL: NetDormancy #: 2: This actor wants to go fully dormant for all connections.
    DORM_DORMANT_PARTIAL: NetDormancy #: 3: This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which.
    DORM_INITIAL: NetDormancy #: 4: This actor is initially dormant for all connection if it was placed in map.
    ...

class PhysicsReplicationMode(EnumBase):
    r"""
    EPhysics Replication Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    DEFAULT: PhysicsReplicationMode #: 0: Default physics replication.
    PREDICTIVE_INTERPOLATION: PhysicsReplicationMode
    r"""
    1: Work In Progress. Physics replication performing velocity interpolation.
    Recommendation: Set on actors with a local role of ENetRole::ROLE_SimulatedProxy.
    Designed to handle local predictive interactions with other actors, especially actors of the local role ENetRole::ROLE_AutonomousProxy.
    """

    RESIMULATION: PhysicsReplicationMode
    r"""
    2: Work In Progress. Forward predicted replication by simulating physics and correcting errors through resimulating physics from a correct state in the past.
    Recommendation: Set on actors with a local role of ENetRole::ROLE_AutonomousProxy.
    Can be used for both ROLE_AutonomousProxy and ROLE_SimulatedProxy, though not recommended for ROLE_SimulatedProxy due to CPU performance.
    Available when Project Settings > Physics Prediction is enabled.
    """

    ...

class PhysicalMaterialMaskColor(EnumBase):
    r"""
    Types of valid physical material mask colors which may be associated with a physical material
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    RED: PhysicalMaterialMaskColor #: 0
    GREEN: PhysicalMaterialMaskColor #: 1
    BLUE: PhysicalMaterialMaskColor #: 2
    CYAN: PhysicalMaterialMaskColor #: 3
    MAGENTA: PhysicalMaterialMaskColor #: 4
    YELLOW: PhysicalMaterialMaskColor #: 5
    WHITE: PhysicalMaterialMaskColor #: 6
    BLACK: PhysicalMaterialMaskColor #: 7
    ...

class SpawnActorCollisionHandlingMethod(EnumBase):
    r"""
    Defines available strategies for handling the case where an actor is spawned in such a way that it penetrates blocking collision.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    UNDEFINED: SpawnActorCollisionHandlingMethod #: 0: Fall back to default settings.
    ALWAYS_SPAWN: SpawnActorCollisionHandlingMethod #: 1: Actor will spawn in desired location, regardless of collisions.
    ADJUST_IF_POSSIBLE_BUT_ALWAYS_SPAWN: SpawnActorCollisionHandlingMethod #: 2: Actor will try to find a nearby non-colliding location (based on shape components), but will always spawn even if one cannot be found.
    ADJUST_IF_POSSIBLE_BUT_DONT_SPAWN_IF_COLLIDING: SpawnActorCollisionHandlingMethod #: 3: Actor will try to find a nearby non-colliding location (based on shape components), but will NOT spawn unless one is found.
    DONT_SPAWN_IF_COLLIDING: SpawnActorCollisionHandlingMethod #: 4: Actor will fail to spawn.
    ...

class RoundingMode(EnumBase):
    r"""
    Provides rounding modes for converting numbers into localized text
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetTextLibrary.h
    
    """

    HALF_TO_EVEN: RoundingMode #: 0: Rounds to the nearest place, equidistant ties go to the value which is closest to an even value: 1.5 becomes 2, 0.5 becomes 0
    HALF_FROM_ZERO: RoundingMode #: 1: Rounds to nearest place, equidistant ties go to the value which is further from zero: -0.5 becomes -1.0, 0.5 becomes 1.0
    HALF_TO_ZERO: RoundingMode #: 2: Rounds to nearest place, equidistant ties go to the value which is closer to zero: -0.5 becomes 0, 0.5 becomes 0.
    FROM_ZERO: RoundingMode #: 3: Rounds to the value which is further from zero, "larger" in absolute value: 0.1 becomes 1, -0.1 becomes -1
    TO_ZERO: RoundingMode #: 4: Rounds to the value which is closer to zero, "smaller" in absolute value: 0.1 becomes 0, -0.1 becomes 0
    TO_NEGATIVE_INFINITY: RoundingMode #: 5: Rounds to the value which is more negative: 0.1 becomes 0, -0.1 becomes -1
    TO_POSITIVE_INFINITY: RoundingMode #: 6: Rounds to the value which is more positive: 0.1 becomes 1, -0.1 becomes 0
    ...

class FunctionInputType(EnumBase):
    r"""
    Supported input types
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionFunctionInput.h
    
    """

    FUNCTION_INPUT_SCALAR: FunctionInputType #: 0
    FUNCTION_INPUT_VECTOR2: FunctionInputType #: 1
    FUNCTION_INPUT_VECTOR3: FunctionInputType #: 2
    FUNCTION_INPUT_VECTOR4: FunctionInputType #: 3
    FUNCTION_INPUT_TEXTURE2D: FunctionInputType #: 4
    FUNCTION_INPUT_TEXTURE_CUBE: FunctionInputType #: 5
    FUNCTION_INPUT_TEXTURE2D_ARRAY: FunctionInputType #: 6
    FUNCTION_INPUT_VOLUME_TEXTURE: FunctionInputType #: 7
    FUNCTION_INPUT_STATIC_BOOL: FunctionInputType #: 8
    FUNCTION_INPUT_MATERIAL_ATTRIBUTES: FunctionInputType #: 9
    FUNCTION_INPUT_TEXTURE_EXTERNAL: FunctionInputType #: 10
    FUNCTION_INPUT_BOOL: FunctionInputType #: 11
    FUNCTION_INPUT_SUBSTRATE: FunctionInputType #: 12
    ...

class MaterialUsage(EnumBase):
    r"""
    EMaterial Usage
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInterface.h
    
    """

    MATUSAGE_SKELETAL_MESH: MaterialUsage #: 0
    MATUSAGE_PARTICLE_SPRITES: MaterialUsage #: 1
    MATUSAGE_BEAM_TRAILS: MaterialUsage #: 2
    MATUSAGE_MESH_PARTICLES: MaterialUsage #: 3
    MATUSAGE_STATIC_LIGHTING: MaterialUsage #: 4
    MATUSAGE_MORPH_TARGETS: MaterialUsage #: 5
    MATUSAGE_SPLINE_MESH: MaterialUsage #: 6
    MATUSAGE_INSTANCED_STATIC_MESHES: MaterialUsage #: 7
    MATUSAGE_GEOMETRY_COLLECTIONS: MaterialUsage #: 8
    MATUSAGE_CLOTHING: MaterialUsage #: 9
    MATUSAGE_NIAGARA_SPRITES: MaterialUsage #: 10
    MATUSAGE_NIAGARA_RIBBONS: MaterialUsage #: 11
    MATUSAGE_NIAGARA_MESH_PARTICLES: MaterialUsage #: 12
    MATUSAGE_GEOMETRY_CACHE: MaterialUsage #: 13
    MATUSAGE_WATER: MaterialUsage #: 14
    MATUSAGE_HAIR_STRANDS: MaterialUsage #: 15
    MATUSAGE_LIDAR_POINT_CLOUD: MaterialUsage #: 16
    MATUSAGE_VIRTUAL_HEIGHTFIELD_MESH: MaterialUsage #: 17
    MATUSAGE_NANITE: MaterialUsage #: 18
    MATUSAGE_VOLUMETRIC_CLOUD: MaterialUsage #: 19
    MATUSAGE_HETEROGENEOUS_VOLUMES: MaterialUsage #: 20
    ...

class ParticleSysParamType(EnumBase):
    r"""
    Enum for specifying type of a name instance parameter.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystemComponent.h
    
    """

    PSPT_NONE: ParticleSysParamType #: 0
    PSPT_SCALAR: ParticleSysParamType #: 1
    PSPT_SCALAR_RAND: ParticleSysParamType #: 2
    PSPT_VECTOR: ParticleSysParamType #: 3
    PSPT_VECTOR_RAND: ParticleSysParamType #: 4
    PSPT_COLOR: ParticleSysParamType #: 5
    PSPT_ACTOR: ParticleSysParamType #: 6
    PSPT_MATERIAL: ParticleSysParamType #: 7
    PSPT_VECTOR_UNIT_RAND: ParticleSysParamType #: 8
    ...

class RichCurveInterpMode(EnumBase):
    r"""
    Method of interpolation between this key and the next.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RealCurve.h
    
    """

    RCIM_LINEAR: RichCurveInterpMode #: 0: Use linear interpolation between values.
    RCIM_CONSTANT: RichCurveInterpMode #: 1: Use a constant value. Represents stepped values.
    RCIM_CUBIC: RichCurveInterpMode #: 2: Cubic interpolation. See TangentMode for different cubic interpolation options.
    ...

class RichCurveExtrapolation(EnumBase):
    r"""
    Enumerates extrapolation options.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RealCurve.h
    
    """

    RCCE_CYCLE: RichCurveExtrapolation #: 0: Repeat the curve without an offset.
    RCCE_CYCLE_WITH_OFFSET: RichCurveExtrapolation #: 1: Repeat the curve with an offset relative to the first or last key's value.
    RCCE_OSCILLATE: RichCurveExtrapolation #: 2: Sinusoidally extrapolate.
    RCCE_LINEAR: RichCurveExtrapolation #: 3: Use a linearly increasing value for extrapolation.
    RCCE_CONSTANT: RichCurveExtrapolation #: 4: Use a constant value for extrapolation
    RCCE_NONE: RichCurveExtrapolation #: 5: No Extrapolation
    ...

class RichCurveTangentMode(EnumBase):
    r"""
    If using RCIM_Cubic, this enum describes how the tangents should be controlled in editor.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RichCurve.h
    
    """

    RCTM_AUTO: RichCurveTangentMode #: 0: Automatically calculates tangents to create smooth curves between values.
    RCTM_USER: RichCurveTangentMode #: 1: User specifies the tangent as a unified tangent where the two tangents are locked to each other, presenting a consistent curve before and after.
    RCTM_BREAK: RichCurveTangentMode #: 2: User specifies the tangent as two separate broken tangents on each side of the key which can allow a sharp change in evaluation before or after.
    RCTM_SMART_AUTO: RichCurveTangentMode #: 4: New Auto tangent that creates smoother curves than Auto.
    ...

class RichCurveTangentWeightMode(EnumBase):
    r"""
    Enumerates tangent weight modes.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RichCurve.h
    
    """

    RCTWM_WEIGHTED_NONE: RichCurveTangentWeightMode #: 0: Don't take tangent weights into account.
    RCTWM_WEIGHTED_ARRIVE: RichCurveTangentWeightMode #: 1: Only take the arrival tangent weight into account for evaluation.
    RCTWM_WEIGHTED_LEAVE: RichCurveTangentWeightMode #: 2: Only take the leaving tangent weight into account for evaluation.
    RCTWM_WEIGHTED_BOTH: RichCurveTangentWeightMode #: 3: Take both the arrival and leaving tangent weights into account for evaluation.
    ...

class MaterialProperty(EnumBase):
    r"""
    EMaterialProperty
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneTypes.h
    
    """

    MP_EMISSIVE_COLOR: MaterialProperty #: 0
    MP_OPACITY: MaterialProperty #: 1
    MP_OPACITY_MASK: MaterialProperty #: 2
    MP_BASE_COLOR: MaterialProperty #: 5: used in Lightmass, not exposed to user, derived from: SpecularColor, Metallic, Specular        Also used in Substrate which uses Albedo/F0 parameterization
    MP_METALLIC: MaterialProperty #: 6
    MP_SPECULAR: MaterialProperty #: 7
    MP_ROUGHNESS: MaterialProperty #: 8
    MP_ANISOTROPY: MaterialProperty #: 9
    MP_NORMAL: MaterialProperty #: 10
    MP_TANGENT: MaterialProperty #: 11
    MP_SUBSURFACE_COLOR: MaterialProperty #: 15
    MP_AMBIENT_OCCLUSION: MaterialProperty #: 18
    MP_REFRACTION: MaterialProperty #: 19
    MP_FRONT_MATERIAL: MaterialProperty #: 30
    ...

class VisibilityBasedAnimTickOption(EnumBase):
    r"""
    Skinned Mesh Animation Tick option based on rendered or not. This dictates "TickPose and RefreshBoneTransforms"
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedMeshComponent.h
    
    """

    ALWAYS_TICK_POSE_AND_REFRESH_BONES: VisibilityBasedAnimTickOption #: 0: Always Tick and Refresh BoneTransforms whether rendered or not.
    ALWAYS_TICK_POSE: VisibilityBasedAnimTickOption #: 1: Always Tick, but Refresh BoneTransforms only when rendered.
    ONLY_TICK_MONTAGES_AND_REFRESH_BONES_WHEN_PLAYING_MONTAGES: VisibilityBasedAnimTickOption
    r"""
    2: When rendered Tick Pose and Refresh Bone Transforms,
    otherwise, just update montages alongside BoneTransforms.
    (AnimBP graph will not be updated).
    """

    ONLY_TICK_MONTAGES_WHEN_NOT_RENDERED: VisibilityBasedAnimTickOption
    r"""
    3: When rendered Tick Pose and Refresh Bone Transforms,
    otherwise, just update montages and skip everything else.
    (AnimBP graph will not be updated).
    """

    ONLY_TICK_POSE_WHEN_RENDERED: VisibilityBasedAnimTickOption #: 4: Tick only when rendered, and it will only RefreshBoneTransforms when rendered.
    ...

class MeshComponentUpdateFlag(EnumBase):
    r"""
    deprecated: 'MeshComponentUpdateFlag' was renamed to 'VisibilityBasedAnimTickOption'.
    """

    ALWAYS_TICK_POSE_AND_REFRESH_BONES: MeshComponentUpdateFlag #: 0: Always Tick and Refresh BoneTransforms whether rendered or not.
    ALWAYS_TICK_POSE: MeshComponentUpdateFlag #: 1: Always Tick, but Refresh BoneTransforms only when rendered.
    ONLY_TICK_MONTAGES_AND_REFRESH_BONES_WHEN_PLAYING_MONTAGES: MeshComponentUpdateFlag
    r"""
    2: When rendered Tick Pose and Refresh Bone Transforms,
    otherwise, just update montages alongside BoneTransforms.
    (AnimBP graph will not be updated).
    """

    ONLY_TICK_MONTAGES_WHEN_NOT_RENDERED: MeshComponentUpdateFlag
    r"""
    3: When rendered Tick Pose and Refresh Bone Transforms,
    otherwise, just update montages and skip everything else.
    (AnimBP graph will not be updated).
    """

    ONLY_TICK_POSE_WHEN_RENDERED: MeshComponentUpdateFlag #: 4: Tick only when rendered, and it will only RefreshBoneTransforms when rendered.
    ...

class AirAbsorptionMethod(EnumBase):
    r"""
    EAir Absorption Method
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundAttenuation.h
    
    """

    LINEAR: AirAbsorptionMethod #: 0: The air absorption conform to a linear distance function
    CUSTOM_CURVE: AirAbsorptionMethod #: 1: The air absorption conforms to a custom distance curve.
    ...

class ReverbSendMethod(EnumBase):
    r"""
    EReverb Send Method
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundAttenuation.h
    
    """

    LINEAR: ReverbSendMethod #: 0: A reverb send based on linear interpolation between a distance range and send-level range
    CUSTOM_CURVE: ReverbSendMethod #: 1: A reverb send based on a supplied curve
    MANUAL: ReverbSendMethod #: 2: A manual reverb send level (Uses the specified constant send level value. Useful for 2D sounds.)
    ...

class PriorityAttenuationMethod(EnumBase):
    r"""
    EPriority Attenuation Method
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundAttenuation.h
    
    """

    LINEAR: PriorityAttenuationMethod #: 0: A priority attenuation based on linear interpolation between a distance range and priority attenuation range
    CUSTOM_CURVE: PriorityAttenuationMethod #: 1: A priority attenuation based on a supplied curve
    MANUAL: PriorityAttenuationMethod #: 2: A manual priority attenuation (Uses the specified constant value. Useful for 2D sounds.)
    ...

class NonSpatializedRadiusSpeakerMapMode(EnumBase):
    r"""
    Defines how to speaker map the sound when using the non-spatialized radius feature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundAttenuation.h
    
    """

    OMNI_DIRECTIONAL: NonSpatializedRadiusSpeakerMapMode #: 0: Will blend the 3D sound to an omni-directional sound (equal output mapping in all directions)
    DIRECT2D: NonSpatializedRadiusSpeakerMapMode #: 1: Will blend the 3D source to the same representation speaker map used when playing the asset 2D
    SURROUND2D: NonSpatializedRadiusSpeakerMapMode #: 2: Will blend the 3D source to a multichannel 2D version (i.e. upmix stereo to quad) if rendering in surround
    ...

class SourceBusSendLevelControlMethod(EnumBase):
    r"""
    ESource Bus Send Level Control Method
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSourceBusSend.h
    
    """

    LINEAR: SourceBusSendLevelControlMethod #: 0: A send based on linear interpolation between a distance range and send-level range
    CUSTOM_CURVE: SourceBusSendLevelControlMethod #: 1: A send based on a supplied curve
    MANUAL: SourceBusSendLevelControlMethod #: 2: A manual send level (Uses the specified constant send level value. Useful for 2D sounds.)
    ...

class SoundWaveFFTSize(EnumBase):
    r"""
    The FFT size (in audio frames) to use for baked FFT analysis
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundWave.h
    
    """

    VERY_SMALL_64: SoundWaveFFTSize #: 0
    SMALL_256: SoundWaveFFTSize #: 1
    MEDIUM_512: SoundWaveFFTSize #: 2
    LARGE_1024: SoundWaveFFTSize #: 3
    VERY_LARGE_2048: SoundWaveFFTSize #: 4
    ...

class SoundAssetCompressionType(EnumBase):
    r"""
    Sound Asset Compression Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundWave.h
    
    """

    BINK_AUDIO: SoundAssetCompressionType #: 0: Perceptual-based codec which supports all features across all platforms.
    ADPCM: SoundAssetCompressionType #: 1: Will encode the asset using ADPCM, a time-domain codec that has fixed-sized quality and about ~4x compression ratio, but is relatively cheap to decode.
    PCM: SoundAssetCompressionType #: 2: Uncompressed audio. Large memory usage (streamed chunks contain less audio per chunk) but extremely cheap to decode and supports all features.
    OPUS: SoundAssetCompressionType #: 3: Opus is a highly versatile audio codec. It is primarily designed for interactive speech and music transmission over the Internet, but is also applicable to storage and streaming applications.
    PLATFORM_SPECIFIC: SoundAssetCompressionType #: 4: Encodes the asset to a platform specific format and will be different depending on the platform. It does not currently support seeking.
    PROJECT_DEFINED: SoundAssetCompressionType #: 5: The project defines the codec used for this asset.
    RAD_AUDIO: SoundAssetCompressionType #: 6: As BinkAudio, except better quality. Comparable CPU usage. Only valid sample rates are: 48000, 44100, 32000, and 24000.
    ...

class TimelineDirection(EnumBase):
    r"""
    Does timeline play or reverse ?
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimelineComponent.h
    
    """

    FORWARD: TimelineDirection #: 0
    BACKWARD: TimelineDirection #: 1
    ...

class SplitScreenType(EnumBase):
    r"""
    Enum of the different splitscreen types
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ViewportSplitScreen.h
    
    """

    NONE: SplitScreenType #: 0: No split
    TWO_PLAYER_HORIZONTAL: SplitScreenType #: 1: 2 player horizontal split
    TWO_PLAYER_VERTICAL: SplitScreenType #: 2: 2 player vertical split
    THREE_PLAYER_FAVOR_TOP: SplitScreenType #: 3: 3 Player split with 1 player on top and 2 on bottom
    THREE_PLAYER_FAVOR_BOTTOM: SplitScreenType #: 4: 3 Player split with 1 player on bottom and 2 on top
    THREE_PLAYER_VERTICAL: SplitScreenType #: 5: 3 Player vertical split
    THREE_PLAYER_HORIZONTAL: SplitScreenType #: 6: 3 Player horizontal split
    FOUR_PLAYER_GRID: SplitScreenType #: 7: 4 Player grid split
    FOUR_PLAYER_VERTICAL: SplitScreenType #: 8: 4 Player vertical split
    FOUR_PLAYER_HORIZONTAL: SplitScreenType #: 9: 4 Player horizontal split
    SPLIT_TYPE_COUNT: SplitScreenType #: 10
    ...

class QuartzTimeSignatureQuantization(EnumBase):
    r"""
    An enumeration for specifying the denominator of time signatures
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    """

    HALF_NOTE: QuartzTimeSignatureQuantization #: 0
    QUARTER_NOTE: QuartzTimeSignatureQuantization #: 1
    EIGHTH_NOTE: QuartzTimeSignatureQuantization #: 2
    SIXTEENTH_NOTE: QuartzTimeSignatureQuantization #: 3
    THIRTY_SECOND_NOTE: QuartzTimeSignatureQuantization #: 4
    ...

class QuartzDelegateType(EnumBase):
    r"""
    An enumeration for specifying different TYPES of delegates
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    """

    METRONOME_TICK: QuartzDelegateType #: 0
    COMMAND_EVENT: QuartzDelegateType #: 1: uses EAudioMixerCommandQuantization to select subdivision
    ...

class QuarztQuantizationReference(EnumBase):
    r"""
    An enumeration for specifying quantization boundary reference frame
    display name to hide c++ typo for now
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    """

    BAR_RELATIVE: QuarztQuantizationReference #: 0: Will occur on the next occurence of this duration from the start of a bar (i.e. On beat 3)
    TRANSPORT_RELATIVE: QuarztQuantizationReference #: 1: Will occur on the next multiple of this duration since the clock started ticking (i.e. on the next 4 bar boundary)
    CURRENT_TIME_RELATIVE: QuarztQuantizationReference #: 2: Will occur on the next multiple of this duration from the current time (i.e. In three beats)
    ...

class QuartzCommandType(EnumBase):
    r"""
    An enumeration for specifying Quartz command types
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    """

    PLAY_SOUND: QuartzCommandType #: 0: Play a sound on a spample-accurate boundary (taking a voice slot immediately)
    QUEUE_SOUND_TO_PLAY: QuartzCommandType #: 1: Queue a sound to play when it gets closer to its quantization boundary (avoids stealing a voice slot right away)
    RETRIGGER_SOUND: QuartzCommandType #: 2: Quantized looping of the target sound (event tells the AudioComponent to play the sound again)
    TICK_RATE_CHANGE: QuartzCommandType #: 3: Quantized change of the tick-rate (i.e. BPM change)
    TRANSPORT_RESET: QuartzCommandType #: 4: Quantized reset of the clocks transport (back to time = 0 on the boundary)
    START_OTHER_CLOCK: QuartzCommandType #: 5: Quantized start of another clock. Useful for sample accurate synchronization of clocks (i.e. to handle time signature changes)
    NOTIFY: QuartzCommandType #: 6: Command used only to get delegates for timing information (basically an empty command)
    CUSTOM: QuartzCommandType #: 7: Quantized custom command
    ...

class ActorUpdateOverlapsMethod(EnumBase):
    r"""
    Chooses a method for actors to update overlap state (objects it is touching) on initialization, currently only used during level streaming.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """

    USE_CONFIG_DEFAULT: ActorUpdateOverlapsMethod #: 0: Use the default value specified by the native class or config value.
    ALWAYS_UPDATE: ActorUpdateOverlapsMethod #: 1: Always update overlap state on initialization.
    ONLY_UPDATE_MOVABLE: ActorUpdateOverlapsMethod #: 2: Only update if root component has Movable mobility.
    NEVER_UPDATE: ActorUpdateOverlapsMethod #: 3: Never update overlap state on initialization.
    ...

class SpawnActorScaleMethod(EnumBase):
    r"""
    Determines how the transform being passed into actor spawning methods interact with the actor's default root component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """

    OVERRIDE_ROOT_SCALE: SpawnActorScaleMethod #: 0: Ignore the default scale in the actor's root component and hard-set it to the value of SpawnTransform Parameter
    MULTIPLY_WITH_ROOT: SpawnActorScaleMethod #: 1: Multiply value of the SpawnTransform Parameter with the default scale in the actor's root component
    ...

class AnimExecutionContextConversionResult(EnumBase):
    r"""
    The result of an anim node context conversion
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimExecutionContext.h
    
    """

    SUCCEEDED: AnimExecutionContextConversionResult #: 1
    FAILED: AnimExecutionContextConversionResult #: 0
    ...

class AnimNodeReferenceConversionResult(EnumBase):
    r"""
    The result of an anim node reference conversion
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNodeReference.h
    
    """

    SUCCEEDED: AnimNodeReferenceConversionResult #: 1
    FAILED: AnimNodeReferenceConversionResult #: 0
    ...

class TransitionRequestQueueMode(EnumBase):
    r"""
    ETransition Request Queue Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimStateMachineTypes.h
    
    """

    SHARED: TransitionRequestQueueMode #: 0: Only one transition can handle this request
    UNIQUE: TransitionRequestQueueMode #: 1: Allows multiple transitions to handle the same request
    ...

class TransitionRequestOverwriteMode(EnumBase):
    r"""
    ETransition Request Overwrite Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimStateMachineTypes.h
    
    """

    APPEND: TransitionRequestOverwriteMode #: 0: This request is added whether or not another with the same name is already queued
    IGNORE: TransitionRequestOverwriteMode #: 1: This request is ignored if another request with the same name is already queued
    OVERWRITE: TransitionRequestOverwriteMode #: 2: This request overwrites another request with the same name if one exists
    ...

class TransformCurveChannel(EnumBase):
    r"""
    Enum used to determine a component channel of a transform curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveIdentifier.h
    
    """

    POSITION: TransformCurveChannel #: 0
    ROTATION: TransformCurveChannel #: 1
    SCALE: TransformCurveChannel #: 2
    INVALID: TransformCurveChannel #: 3
    ...

class VectorCurveChannel(EnumBase):
    r"""
    Enum used to determine an axis channel of a vector curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveIdentifier.h
    
    """

    X: VectorCurveChannel #: 0
    Y: VectorCurveChannel #: 1
    Z: VectorCurveChannel #: 2
    INVALID: VectorCurveChannel #: 3
    ...

class AttenuationDistanceModel(EnumBase):
    r"""
    EAttenuation Distance Model
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Attenuation.h
    
    """

    LINEAR: AttenuationDistanceModel #: 0
    LOGARITHMIC: AttenuationDistanceModel #: 1
    INVERSE: AttenuationDistanceModel #: 2
    LOG_REVERSE: AttenuationDistanceModel #: 3
    NATURAL_SOUND: AttenuationDistanceModel #: 4
    CUSTOM: AttenuationDistanceModel #: 5
    ...

class SoundDistanceModel(EnumBase):
    r"""
    deprecated: 'SoundDistanceModel' was renamed to 'AttenuationDistanceModel'.
    """

    LINEAR: SoundDistanceModel #: 0
    LOGARITHMIC: SoundDistanceModel #: 1
    INVERSE: SoundDistanceModel #: 2
    LOG_REVERSE: SoundDistanceModel #: 3
    NATURAL_SOUND: SoundDistanceModel #: 4
    CUSTOM: SoundDistanceModel #: 5
    ...

class AttenuationShape(EnumBase):
    r"""
    EAttenuation Shape
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Attenuation.h
    
    """

    SPHERE: AttenuationShape #: 0
    CAPSULE: AttenuationShape #: 1
    BOX: AttenuationShape #: 2
    CONE: AttenuationShape #: 3
    ...

class NaturalSoundFalloffMode(EnumBase):
    r"""
    ENatural Sound Falloff Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Attenuation.h
    
    """

    CONTINUES: NaturalSoundFalloffMode
    r"""
    0: (Default) Continues attenuating pass falloff max using volume value
    specified at the max falloff distance's bounds
    """

    SILENT: NaturalSoundFalloffMode #: 1: Sound goes silent upon leaving the shape
    HOLD: NaturalSoundFalloffMode #: 2: Holds the volume value specified at the shapes falloff bounds
    ...

class AudioBusChannels(EnumBase):
    r"""
    The number of channels to mix audio into the source bus
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioBus.h
    
    """

    MONO: AudioBusChannels #: 0
    STEREO: AudioBusChannels #: 1
    QUAD: AudioBusChannels #: 3
    FIVE_POINT_ONE: AudioBusChannels #: 5
    SEVEN_POINT_ONE: AudioBusChannels #: 7
    MAX_CHANNEL_COUNT: AudioBusChannels #: 8
    ...

class AudioVolumeLocationState(EnumBase):
    r"""
    Enum describing the state of checking audio volume location
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioVolume.h
    
    """

    INSIDE_THE_VOLUME: AudioVolumeLocationState #: 0: Used for when the listener is located inside the Audio Volume
    OUTSIDE_THE_VOLUME: AudioVolumeLocationState #: 1: Used for when the listener is located outside the Audio Volume
    ...

class CameraShakeAttenuation(EnumBase):
    r"""
    ECamera Shake Attenuation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeSourceComponent.h
    
    """

    LINEAR: CameraShakeAttenuation #: 0
    QUADRATIC: CameraShakeAttenuation #: 1
    ...

class AudioFaderCurve(EnumBase):
    r"""
    Type of fade to use when adjusting the audio component's volume.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    """

    LINEAR: AudioFaderCurve #: 0: Linear Fade
    LOGARITHMIC: AudioFaderCurve #: 1: Logarithmic Fade
    S_CURVE: AudioFaderCurve #: 2: S-Curve, Sinusoidal Fade
    SIN: AudioFaderCurve #: 3: Equal Power, Sinusoidal Fade
    ...

class ModulationDestination(EnumBase):
    r"""
    EModulation Destination
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    """

    VOLUME: ModulationDestination #: 0: Volume modulation
    PITCH: ModulationDestination #: 1: Pitch modulation
    LOWPASS: ModulationDestination #: 2: Cutoff Frequency of a lowpass filter
    HIGHPASS: ModulationDestination #: 3: Cutoff Frequency of a highpass filter
    ...

class SyncOption(EnumBase):
    r"""
    ESync Option
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LODSyncComponent.h
    
    """

    DRIVE: SyncOption #: 0: Drive LOD from this component. It will contribute to the change of LOD
    PASSIVE: SyncOption #: 1: It follows what's currently driven by other components. It doesn't contribute to the change of LOD
    DISABLED: SyncOption #: 2: It is disabled, it doesn't do anything
    ...

class SplinePointType(EnumBase):
    r"""
    Permitted spline point types for SplineComponent.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SplineComponent.h
    
    """

    LINEAR: SplinePointType #: 0
    CURVE: SplinePointType #: 1
    CONSTANT: SplinePointType #: 2
    CURVE_CLAMPED: SplinePointType #: 3
    CURVE_CUSTOM_TANGENT: SplinePointType #: 4
    ...

class SplineMeshAxis(EnumBase):
    r"""
    ESpline Mesh Axis
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SplineMeshComponent.h
    
    """

    X: SplineMeshAxis #: 0
    Y: SplineMeshAxis #: 1
    Z: SplineMeshAxis #: 2
    ...

class FDataDrivenCVarType(EnumBase):
    r"""
    FData Driven CVar Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataDrivenCVars.h
    
    """

    C_VAR_FLOAT: FDataDrivenCVarType #: 0
    C_VAR_INT: FDataDrivenCVarType #: 1
    C_VAR_BOOL: FDataDrivenCVarType #: 2
    ...

class WindowMode(EnumBase):
    r"""
    Supported windowing modes (mirrored from GenericWindow.h)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameUserSettings.h
    
    """

    FULLSCREEN: WindowMode #: 0: The window is in true fullscreen mode
    WINDOWED_FULLSCREEN: WindowMode #: 1: The window has no border and takes up the entire area of the screen
    WINDOWED: WindowMode #: 2: The window has a border and may not take up the entire screen area
    ...

class ArraySortOrder(EnumBase):
    r"""
    EArray Sort Order
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetArrayLibrary.h
    
    """

    ASCENDING: ArraySortOrder #: 0
    DESCENDING: ArraySortOrder #: 1
    ...

class SlateGesture(EnumBase):
    r"""
    ESlate Gesture
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetInputLibrary.h
    
    """

    NONE: SlateGesture #: 0
    SCROLL: SlateGesture #: 1
    MAGNIFY: SlateGesture #: 2
    SWIPE: SlateGesture #: 3
    ROTATE: SlateGesture #: 4
    LONG_PRESS: SlateGesture #: 5
    ...

class MIDCreationFlags(EnumBase):
    r"""
    EMIDCreation Flags
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetMaterialLibrary.h
    
    """

    NONE: MIDCreationFlags #: 0
    TRANSIENT: MIDCreationFlags #: 1
    ...

class EasingFunc(EnumBase):
    r"""
    Provides different easing functions that can be used in blueprints
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetMathLibrary.h
    
    """

    LINEAR: EasingFunc #: 0: Simple linear interpolation.
    STEP: EasingFunc #: 1: Simple step interpolation.
    SINUSOIDAL_IN: EasingFunc #: 2: Sinusoidal in interpolation.
    SINUSOIDAL_OUT: EasingFunc #: 3: Sinusoidal out interpolation.
    SINUSOIDAL_IN_OUT: EasingFunc #: 4: Sinusoidal in/out interpolation.
    EASE_IN: EasingFunc #: 5: Smoothly accelerates, but does not decelerate into the target.  Ease amount controlled by BlendExp.
    EASE_OUT: EasingFunc #: 6: Immediately accelerates, but smoothly decelerates into the target.  Ease amount controlled by BlendExp.
    EASE_IN_OUT: EasingFunc #: 7: Smoothly accelerates and decelerates.  Ease amount controlled by BlendExp.
    EXPO_IN: EasingFunc #: 8: Easing in using an exponential
    EXPO_OUT: EasingFunc #: 9: Easing out using an exponential
    EXPO_IN_OUT: EasingFunc #: 10: Easing in/out using an exponential method
    CIRCULAR_IN: EasingFunc #: 11: Easing is based on a half circle.
    CIRCULAR_OUT: EasingFunc #: 12: Easing is based on an inverted half circle.
    CIRCULAR_IN_OUT: EasingFunc #: 13: Easing is based on two half circles.
    ...

class LerpInterpolationMode(EnumBase):
    r"""
    Different methods for interpolating rotation between transforms
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetMathLibrary.h
    
    """

    QUAT_INTERP: LerpInterpolationMode #: 0: Shortest Path or Quaternion interpolation for the rotation.
    EULER_INTERP: LerpInterpolationMode #: 1: Rotor or Euler Angle interpolation.
    DUAL_QUAT_INTERP: LerpInterpolationMode #: 2: Dual quaternion interpolation, follows helix or screw-motion path between keyframes.
    ...

class MatrixColumns(EnumBase):
    r"""
    Possible columns for an FMatrix
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetMathLibrary.h
    
    """

    FIRST: MatrixColumns #: 0: First Column.
    SECOND: MatrixColumns #: 1: Second Column.
    THIRD: MatrixColumns #: 2: Third Column.
    FOURTH: MatrixColumns #: 3: Fourth Column.
    ...

class ImportanceWeight(EnumBase):
    r"""
    Provides different weighting functions for texture importance sampling
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ImportanceSamplingLibrary.h
    
    """

    LUMINANCE: ImportanceWeight #: 0: Importance from color luminance.
    RED: ImportanceWeight #: 1: Importance from red channel of texture.
    GREEN: ImportanceWeight #: 2: Importance from green channel of texture.
    BLUE: ImportanceWeight #: 3: Importance from blue channel of texture.
    ALPHA: ImportanceWeight #: 4: Importance from alpha channel of texture.
    ...

class PerQualityLevels(EnumBase):
    r"""
    EPer Quality Levels
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PerQualityLevelProperties.h
    
    """

    LOW: PerQualityLevels #: 0
    MEDIUM: PerQualityLevels #: 1
    HIGH: PerQualityLevels #: 2
    EPIC: PerQualityLevels #: 3
    CINEMATIC: PerQualityLevels #: 4
    NUM: PerQualityLevels #: 5
    ...

class NeuralProfileFormat(EnumBase):
    r"""
    ENeural Profile Format
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NeuralProfile.h
    
    """

    TYPE32: NeuralProfileFormat #: 0
    TYPE16: NeuralProfileFormat #: 1
    ...

class NeuralModelTileType(EnumBase):
    r"""
    ENeural Model Tile Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NeuralProfile.h
    
    """

    ONE_BY_ONE: NeuralModelTileType
    r"""
    0: The NNE model is loaded and used as it is. No dimension augmentation. E.g.,
    if the input texture has different dimensions, it will be scaled down before application
    """

    TWO_BY_TWO: NeuralModelTileType #: 1
    FOUR_BY_FOUR: NeuralModelTileType #: 2
    EIGHT_BY_EIGHT: NeuralModelTileType #: 3
    AUTO: NeuralModelTileType
    r"""
    4: Create tiled buffers in batch dimension automatically, where each tile runs the neural model
          e.g., if the model input dimension is (1x3x200x200) and the used buffer size of the post processing
          is 1000x1000, then 5x5 tiles ((5x5)x3x200x200) will be run and recombined.
    """

    ...

class TileOverlapResolveType(EnumBase):
    r"""
    ETile Overlap Resolve Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NeuralProfile.h
    
    """

    IGNORE: TileOverlapResolveType #: 0: Overlapped tile regions have no contribution to adjecent tiles
    FEATHERING: TileOverlapResolveType #: 1: Overlapped regions are blended linearly to adjecent tiles
    ...

class NeuralProfileRuntimeType(EnumBase):
    r"""
    ENeural Profile Runtime Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NeuralProfile.h
    
    """

    NNE_RUNTIME_RDG_DML: NeuralProfileRuntimeType #: 0
    NNE_RUNTIME_RDG_HLSL: NeuralProfileRuntimeType #: 1: Does not have full operator support
    ...

class SpecularProfileFormat(EnumBase):
    r"""
    List of niagara solvers
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SpecularProfile.h
    
    """

    VIEW_LIGHT_VECTOR: SpecularProfileFormat #: 0
    HALF_VECTOR: SpecularProfileFormat #: 1
    ...

class VirtualizationMode(EnumBase):
    r"""
    Method of virtualization when a sound is stopped due to playback constraints
    (i.e. by concurrency, priority, and/or MaxChannelCount)
    for a given sound.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundBase.h
    
    """

    DISABLED: VirtualizationMode #: 0: Virtualization is disabled
    PLAY_WHEN_SILENT: VirtualizationMode
    r"""
    1: Sound continues to play when silent and not virtualize, continuing to use a voice. If
    sound is looping and stopped due to concurrency or channel limit/priority, sound will
    restart on realization. If any SoundWave referenced in a SoundCue's waveplayer is set
    to 'PlayWhenSilent', entire SoundCue will be overridden to 'PlayWhenSilent' (to maintain
    timing over all wave players).
    """

    RESTART: VirtualizationMode #: 2: If sound is looping, sound restarts from beginning upon realization from being virtual
    ...

class ModulationRouting(EnumBase):
    r"""
    EModulation Routing
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundModulationDestination.h
    
    """

    DISABLE: ModulationRouting #: 0: Disables modulation routing
    INHERIT: ModulationRouting #: 1: Inherits modulation routing (AudioComponent inherits from Sound, Sound inherits from SoundClass)
    OVERRIDE: ModulationRouting #: 2: Ignores inherited settings and uses modulation settings on this object
    UNION: ModulationRouting #: 3: Performs set union on local modulation sources with those inherited (AudioComponent inherits from Sound, Sound inherits from SoundClass)
    ...

class SourceBusChannels(EnumBase):
    r"""
    The number of channels to mix audio into the source bus
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSourceBus.h
    
    """

    MONO: SourceBusChannels #: 0
    STEREO: SourceBusChannels #: 1
    ...

class FFTSize(EnumBase):
    r"""
    EFFTSize
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    """

    DEFAULT_SIZE: FFTSize #: 0: 512
    MIN: FFTSize #: 1: 64
    SMALL: FFTSize #: 2: 256
    MEDIUM: FFTSize #: 3: 512
    LARGE: FFTSize #: 4: 1024
    VERY_LARGE: FFTSize #: 5: 2048
    MAX: FFTSize #: 6: 4096
    ...

class AudioSpectrumType(EnumBase):
    r"""
    EAudio Spectrum Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    """

    MAGNITUDE_SPECTRUM: AudioSpectrumType #: 0: Spectrum frequency values are equal to magnitude of frequency.
    POWER_SPECTRUM: AudioSpectrumType #: 1: Spectrum frequency values are equal to magnitude squared.
    DECIBEL: AudioSpectrumType #: 2: Returns decibels (0.0 dB is 1.0)
    ...

class GainParamMode(EnumBase):
    r"""
    Whether to use linear or decibel values for audio gains
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    """

    LINEAR: GainParamMode #: 0
    DECIBELS: GainParamMode #: 1
    ...

class AudioSpectrumBandPresetType(EnumBase):
    r"""
    EAudio Spectrum Band Preset Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmixSend.h
    
    """

    KICK_DRUM: AudioSpectrumBandPresetType #: 0: Band which contains frequencies generally related to kick drums.
    SNARE_DRUM: AudioSpectrumBandPresetType #: 1: Band which contains frequencies generally related to snare drums.
    VOICE: AudioSpectrumBandPresetType #: 2: Band which contains frequencies generally related to vocals.
    CYMBALS: AudioSpectrumBandPresetType #: 3: Band which contains frequencies generally related to cymbals.
    ...

class AudioRecordingExportType(EnumBase):
    r"""
    EAudio Recording Export Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmixSend.h
    
    """

    SOUND_WAVE: AudioRecordingExportType #: 0: Exports a USoundWave.
    WAV_FILE: AudioRecordingExportType #: 1: Exports a WAV file.
    ...

class SendLevelControlMethod(EnumBase):
    r"""
    ESend Level Control Method
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmixSend.h
    
    """

    LINEAR: SendLevelControlMethod #: 0: A send based on linear interpolation between a distance range and send-level range
    CUSTOM_CURVE: SendLevelControlMethod #: 1: A send based on a supplied curve
    MANUAL: SendLevelControlMethod #: 2: A manual send level (Uses the specified constant send level value. Useful for 2D sounds.)
    ...

class SubmixSendMethod(EnumBase):
    r"""
    deprecated: 'SubmixSendMethod' was renamed to 'SendLevelControlMethod'.
    """

    LINEAR: SubmixSendMethod #: 0: A send based on linear interpolation between a distance range and send-level range
    CUSTOM_CURVE: SubmixSendMethod #: 1: A send based on a supplied curve
    MANUAL: SubmixSendMethod #: 2: A manual send level (Uses the specified constant send level value. Useful for 2D sounds.)
    ...

class SubmixSendStage(EnumBase):
    r"""
    ESubmix Send Stage
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmixSend.h
    
    """

    POST_DISTANCE_ATTENUATION: SubmixSendStage #: 0: Whether to do the send pre distance attenuation
    PRE_DISTANCE_ATTENUATION: SubmixSendStage #: 1: Whether to do the send post distance attenuation
    ...

class TextureRenderTargetFormat(EnumBase):
    r"""
    Subset of EPixelFormat exposed to UTextureRenderTarget2D
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureRenderTarget2D.h
    
    """

    RTF_R8: TextureRenderTargetFormat #: 0: R channel, 8 bit per channel fixed point, range [0, 1].
    RTF_RG8: TextureRenderTargetFormat #: 1: RG channels, 8 bit per channel fixed point, range [0, 1].
    RTF_RGBA8: TextureRenderTargetFormat #: 2: RGBA channels, 8 bit per channel fixed point, range [0, 1].
    RTF_RGBA8_SRGB: TextureRenderTargetFormat #: 3: RGBA channels, 8 bit per channel fixed point, range [0, 1]. RGB is encoded with sRGB gamma curve. A is always stored as linear.
    RTF_R16F: TextureRenderTargetFormat #: 4: R channel, 16 bit per channel floating point, range [-65504, 65504]
    RTF_RG16F: TextureRenderTargetFormat #: 5: RG channels, 16 bit per channel floating point, range [-65504, 65504]
    RTF_RGBA16F: TextureRenderTargetFormat #: 6: RGBA channels, 16 bit per channel floating point, range [-65504, 65504]
    RTF_R32F: TextureRenderTargetFormat #: 7: R channel, 32 bit per channel floating point, range [-3.402823 x 10^38, 3.402823 x 10^38]
    RTF_RG32F: TextureRenderTargetFormat #: 8: RG channels, 32 bit per channel floating point, range [-3.402823 x 10^38, 3.402823 x 10^38]
    RTF_RGBA32F: TextureRenderTargetFormat #: 9: RGBA channels, 32 bit per channel floating point, range [-3.402823 x 10^38, 3.402823 x 10^38]
    RTF_RGB10A2: TextureRenderTargetFormat #: 10: RGBA channels, 10 bit per channel fixed point and 2 bit of alpha
    ...

class TextureRenderTargetSampleCount(EnumBase):
    r"""
    ETexture Render Target Sample Count
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureRenderTarget2D.h
    
    """

    RTSC_1: TextureRenderTargetSampleCount #: 0
    RTSC_2: TextureRenderTargetSampleCount #: 1
    RTSC_4: TextureRenderTargetSampleCount #: 2
    RTSC_8: TextureRenderTargetSampleCount #: 3
    ...

class HardwareDeviceSupportedFeatures(EnumBase):
    r"""
    A bitmask of supported features that a hardware device has.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputSettings.h
    
    """

    UNSPECIFIED: HardwareDeviceSupportedFeatures #: 0: A device that has not specified the type
    KEYPRESS: HardwareDeviceSupportedFeatures #: 1: This device can support basic key presses
    POINTER: HardwareDeviceSupportedFeatures #: 2: This device can handle basic pointer behavior, such as a mouse
    GAMEPAD: HardwareDeviceSupportedFeatures #: 4: This device has basic gamepad support
    TOUCH: HardwareDeviceSupportedFeatures #: 8: This device supports touch in some capactiy (tablet, controller with a touch pad, etc)
    CAMERA: HardwareDeviceSupportedFeatures #: 16: Does this device have a camera on it that we can access?
    MOTION_TRACKING: HardwareDeviceSupportedFeatures #: 32: Can this device track motion in a 3D space? (VR controllers, headset, etc)
    LIGHTS: HardwareDeviceSupportedFeatures #: 64: This hardware supports setting a light color (such as an LED light bar)
    TRIGGER_HAPTICS: HardwareDeviceSupportedFeatures #: 128: Does this device have trigger haptics available?
    FORCE_FEEDBACK: HardwareDeviceSupportedFeatures #: 256: Flagged true if this device supports force feedback
    AUDIO_BASED_VIBRATIONS: HardwareDeviceSupportedFeatures #: 512: Does this device support vibrations sourced from an audio file?
    ACCELERATION: HardwareDeviceSupportedFeatures #: 1024: This device can track acceleration in the users physical space
    VIRTUAL: HardwareDeviceSupportedFeatures #: 2048: This is a virtual device simulating input, not a physical device
    MICROPHONE: HardwareDeviceSupportedFeatures #: 4096: This device has a microphone on it that you can get audio from
    ORIENTATION: HardwareDeviceSupportedFeatures #: 8192: This device can track the orientation in world space, such as a gyroscope
    GUITAR: HardwareDeviceSupportedFeatures #: 16384: This device has the capabilities of a guitar (whammy bar, tilt, etc)
    DRUMS: HardwareDeviceSupportedFeatures #: 32768: This device has the capabilities of drums (symbols, foot pedal, etc)
    CUSTOM_A: HardwareDeviceSupportedFeatures #: 16777216: Some custom flags that can be used in your game if you have custom hardware!
    CUSTOM_B: HardwareDeviceSupportedFeatures #: 33554432
    CUSTOM_C: HardwareDeviceSupportedFeatures #: 67108864
    CUSTOM_D: HardwareDeviceSupportedFeatures #: 134217728
    ...

class HardwareDevicePrimaryType(EnumBase):
    r"""
    What is the primary use of an input device type?
    Each hardware device can only be one primary type.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputSettings.h
    
    """

    UNSPECIFIED: HardwareDevicePrimaryType #: 0
    KEYBOARD_AND_MOUSE: HardwareDevicePrimaryType #: 1
    GAMEPAD: HardwareDevicePrimaryType #: 2
    TOUCH: HardwareDevicePrimaryType #: 3
    MOTION_TRACKING: HardwareDevicePrimaryType #: 4
    RACING_WHEEL: HardwareDevicePrimaryType #: 5
    FLIGHT_STICK: HardwareDevicePrimaryType #: 6
    CAMERA: HardwareDevicePrimaryType #: 7
    INSTRUMENT: HardwareDevicePrimaryType #: 8
    CUSTOM_TYPE_A: HardwareDevicePrimaryType #: 9: Some custom devices that can be used for your game specific hardware if desired
    CUSTOM_TYPE_B: HardwareDevicePrimaryType #: 10
    CUSTOM_TYPE_C: HardwareDevicePrimaryType #: 11
    CUSTOM_TYPE_D: HardwareDevicePrimaryType #: 12
    ...

class DataLayerStateType(EnumBase):
    r"""
    EData Layer State
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayer.h
    
    """

    UNLOADED: DataLayerStateType #: 0
    LOADED: DataLayerStateType #: 1
    ACTIVATED: DataLayerStateType #: 2
    ...

class DataLayerLoadFilter(EnumBase):
    r"""
    EData Layer Load Filter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayerAsset.h
    
    """

    NONE: DataLayerLoadFilter #: 0
    CLIENT_ONLY: DataLayerLoadFilter #: 1
    SERVER_ONLY: DataLayerLoadFilter #: 2
    ...

class WorldPartitionRuntimeCellState(EnumBase):
    r"""
    Cell State
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionRuntimeCell.h
    
    """

    UNLOADED: WorldPartitionRuntimeCellState #: 0
    LOADED: WorldPartitionRuntimeCellState #: 1
    ACTIVATED: WorldPartitionRuntimeCellState #: 2
    ...

class StreamingSourceTargetBehavior(EnumBase):
    r"""
    EStreaming Source Target Behavior
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionStreamingSource.h
    
    """

    INCLUDE: StreamingSourceTargetBehavior #: 0
    EXCLUDE: StreamingSourceTargetBehavior #: 1
    ...

class StreamingSourcePriority(EnumBase):
    r"""
    Streaming Source Priority
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionStreamingSource.h
    
    """

    HIGHEST: StreamingSourcePriority #: 0
    HIGH: StreamingSourcePriority #: 64
    NORMAL: StreamingSourcePriority #: 128
    LOW: StreamingSourcePriority #: 192
    LOWEST: StreamingSourcePriority #: 255
    DEFAULT: StreamingSourcePriority #: 128
    ...

class InAppPurchaseState(EnumBase):
    r"""
    Possible result states of an in-app purchase transaction
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystem
    - **Module**: OnlineSubsystem
    - **File**: OnlineStoreInterfaceV2.h
    
    """

    UNKNOWN: InAppPurchaseState #: 0
    SUCCESS: InAppPurchaseState #: 1
    FAILED: InAppPurchaseState #: 2
    CANCELLED: InAppPurchaseState #: 3
    INVALID: InAppPurchaseState #: 4
    NOT_ALLOWED: InAppPurchaseState #: 5
    RESTORED: InAppPurchaseState #: 6
    ALREADY_OWNED: InAppPurchaseState #: 7
    ...

class MPMatchOutcome(EnumBase):
    r"""
    EMPMatchOutcome represents all the possible outcomes for this player in a match
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystem
    - **Module**: OnlineSubsystem
    - **File**: OnlineTurnBasedInterface.h
    
    """

    NONE: MPMatchOutcome #: 0
    QUIT: MPMatchOutcome #: 1
    WON: MPMatchOutcome #: 2
    LOST: MPMatchOutcome #: 3
    TIED: MPMatchOutcome #: 4
    TIME_EXPIRED: MPMatchOutcome #: 5
    FIRST: MPMatchOutcome #: 6
    SECOND: MPMatchOutcome #: 7
    THIRD: MPMatchOutcome #: 8
    FOURTH: MPMatchOutcome #: 9
    ...

class OnlineProxyStoreOfferDiscountType(EnumBase):
    r"""
    EOnline Proxy Store Offer Discount Type
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseQueryCallbackProxy2.h
    
    """

    NOT_ON_SALE: OnlineProxyStoreOfferDiscountType #: 0: Offer isn't on sale
    PERCENTAGE: OnlineProxyStoreOfferDiscountType #: 1: Offer price should be displayed as a percentage of regular price
    DISCOUNT_AMOUNT: OnlineProxyStoreOfferDiscountType #: 2: Offer price should be displayed as an amount off regular price
    PAY_AMOUNT: OnlineProxyStoreOfferDiscountType #: 3: Offer price should be displayed as a new price
    ...

class InAppPurchaseStatus(EnumBase):
    r"""
    State of a purchase transaction
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseDataTypes.h
    
    """

    INVALID: InAppPurchaseStatus #: 0
    FAILED: InAppPurchaseStatus #: 1: purchase completed but failed
    DEFERRED: InAppPurchaseStatus #: 2: purchase has been deferred (neither failed nor completed)
    CANCELED: InAppPurchaseStatus #: 3: purchase canceled by user
    PURCHASED: InAppPurchaseStatus #: 4: purchase succeeded
    RESTORED: InAppPurchaseStatus #: 5: restore succeeded
    ...

class GLTFTextureImageFormat(EnumBase):
    r"""
    EGLTFTexture Image Format
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFExportOptions.h
    
    """

    NONE: GLTFTextureImageFormat #: 0: Don't export any textures.
    PNG: GLTFTextureImageFormat #: 1: Always use PNG (lossless compression).
    JPEG: GLTFTextureImageFormat #: 2: If texture does not have an alpha channel, use JPEG (lossy compression); otherwise fallback to PNG.
    ...

class GLTFMaterialVariantMode(EnumBase):
    r"""
    EGLTFMaterial Variant Mode
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFExportOptions.h
    
    """

    NONE: GLTFMaterialVariantMode #: 0: Never export material variants.
    SIMPLE: GLTFMaterialVariantMode #: 1: Export material variants but only use a simple quad if a material input needs to be baked out.
    USE_MESH_DATA: GLTFMaterialVariantMode #: 2: Export material variants and allow usage of the mesh data if a material input needs to be baked out with vertex data.
    ...

class GLTFMaterialBakeMode(EnumBase):
    r"""
    EGLTFMaterial Bake Mode
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFMaterialUserData.h
    
    """

    DISABLED: GLTFMaterialBakeMode #: 0: Never bake material inputs.
    SIMPLE: GLTFMaterialBakeMode #: 1: Only use a simple quad if a material input needs to be baked out.
    USE_MESH_DATA: GLTFMaterialBakeMode #: 2: Allow usage of the mesh data if a material input needs to be baked out with vertex data.
    ...

class GLTFMaterialPropertyGroup(EnumBase):
    r"""
    EGLTFMaterial Property Group
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFMaterialUserData.h
    
    """

    NONE: GLTFMaterialPropertyGroup #: 0
    BASE_COLOR_OPACITY: GLTFMaterialPropertyGroup #: 1
    METALLIC_ROUGHNESS: GLTFMaterialPropertyGroup #: 2
    EMISSIVE_COLOR: GLTFMaterialPropertyGroup #: 3
    NORMAL: GLTFMaterialPropertyGroup #: 4
    AMBIENT_OCCLUSION: GLTFMaterialPropertyGroup #: 5
    CLEAR_COAT_ROUGHNESS: GLTFMaterialPropertyGroup #: 6
    CLEAR_COAT_BOTTOM_NORMAL: GLTFMaterialPropertyGroup #: 7
    ...

class DatasmithAreaLightActorShape(EnumBase):
    r"""
    Keep in sync with EDatasmithLightShape from DatasmithDefinitions
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAreaLightActor.h
    
    """

    RECTANGLE: DatasmithAreaLightActorShape #: 0
    DISC: DatasmithAreaLightActorShape #: 1
    SPHERE: DatasmithAreaLightActorShape #: 2
    CYLINDER: DatasmithAreaLightActorShape #: 3
    NONE: DatasmithAreaLightActorShape #: 4
    ...

class DatasmithAreaLightActorType(EnumBase):
    r"""
    EDatasmith Area Light Actor Type
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAreaLightActor.h
    
    """

    POINT: DatasmithAreaLightActorType #: 0
    SPOT: DatasmithAreaLightActorType #: 1
    IES_DEPRECATED: DatasmithAreaLightActorType #: 2
    RECT: DatasmithAreaLightActorType
    r"""
    3: Added for consistency with type EDatasmithAreaLightType.
    Removing this will result in 'EDatasmithAreaLightActorType MAX' enum value in the editor.
    """

    ...

class ACLVisualFidelityChangeResult(EnumBase):
    r"""
    An enum to represent the result of latent visual fidelity change requests.
    
    **C++ Source:**
    
    - **Plugin**: ACLPlugin
    - **Module**: ACLPlugin
    - **File**: AnimationCompressionLibraryDatabase.h
    
    """

    DISPATCHED: ACLVisualFidelityChangeResult #: 0
    COMPLETED: ACLVisualFidelityChangeResult #: 1
    FAILED: ACLVisualFidelityChangeResult #: 2
    ...

class MeshTrackerVertexColorMode(EnumBase):
    r"""
    Vertex color mode.
    
    **C++ Source:**
    
    - **Module**: MRMesh
    - **File**: MockDataMeshTrackerComponent.h
    
    """

    NONE: MeshTrackerVertexColorMode #: 0: Vertex Color is not set.
    CONFIDENCE: MeshTrackerVertexColorMode #: 1: ! Vertex confidence is interpolated between two specified colors.
    BLOCK: MeshTrackerVertexColorMode #: 2: ! Each block is given a color from a list.
    ...

class ThumbnailLabelType_BlueprintType(EnumBase):
    r"""
    EThumbnail Label Type Blueprint Type
    
    **C++ Source:**
    
    - **Module**: UMGEditor
    - **File**: AssetThumbnailWidget.h
    
    """

    CLASS_NAME: ThumbnailLabelType_BlueprintType #: 0
    ASSET_NAME: ThumbnailLabelType_BlueprintType #: 1
    NO_LABEL: ThumbnailLabelType_BlueprintType #: 2
    ...

class ThumbnailColorStripOrientation_BlueprintType(EnumBase):
    r"""
    EThumbnail Color Strip Orientation Blueprint Type
    
    **C++ Source:**
    
    - **Module**: UMGEditor
    - **File**: AssetThumbnailWidget.h
    
    """

    HORIZONTAL_BOTTOM_EDGE: ThumbnailColorStripOrientation_BlueprintType #: 0: Display the color strip as a horizontal line along the bottom edge
    VERTICAL_RIGHT_EDGE: ThumbnailColorStripOrientation_BlueprintType #: 1: Display the color strip as a vertical line along the right edge
    ...

class ComparisonTolerance(EnumBase):
    r"""
    EComparison Tolerance
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: AutomationScreenshotOptions.h
    
    """

    ZERO: ComparisonTolerance #: 0
    LOW: ComparisonTolerance #: 1
    MEDIUM: ComparisonTolerance #: 2
    HIGH: ComparisonTolerance #: 3
    CUSTOM: ComparisonTolerance #: 4
    ...

class ComparisonMethod(EnumBase):
    r"""
    EComparison Method
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalTest.h
    
    """

    EQUAL_TO: ComparisonMethod #: 0
    NOT_EQUAL_TO: ComparisonMethod #: 1
    GREATER_THAN_OR_EQUAL_TO: ComparisonMethod #: 2
    LESS_THAN_OR_EQUAL_TO: ComparisonMethod #: 3
    GREATER_THAN: ComparisonMethod #: 4
    LESS_THAN: ComparisonMethod #: 5
    ...

class FunctionalTestResult(EnumBase):
    r"""
    EFunctional Test Result
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalTest.h
    
    """

    DEFAULT: FunctionalTestResult
    r"""
    0: When finishing a test if you use Default, you're not explicitly stating if the test passed or failed.
    Instead you're instead allowing any tested assertions to have decided that for you.  Even if you do
    explicitly log success, it can be overturned by errors that occurred during the test.
    """

    INVALID: FunctionalTestResult #: 1
    ERROR: FunctionalTestResult #: 2
    RUNNING: FunctionalTestResult #: 3
    FAILED: FunctionalTestResult #: 4
    SUCCEEDED: FunctionalTestResult #: 5
    ...

class FunctionalTestLogHandling(EnumBase):
    r"""
    EFunctional Test Log Handling
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalTest.h
    
    """

    PROJECT_DEFAULT: FunctionalTestLogHandling
    r"""
    0: How do log categories affect rest results. ProjectDefault can be set in DefaultEngine.ini
    but individual tests can override that
    """

    OUTPUT_IS_ERROR: FunctionalTestLogHandling #: 1
    OUTPUT_IGNORED: FunctionalTestLogHandling #: 2
    ...

class PlayerMappableKeySlot(EnumBase):
    r"""
    The "Slot" that a player mappable key is in.
    Used by UI to allow for multiple keys to be bound by the player for a single player mapping
    
    | <Mapping Name>  | Slot 1 | Slot 2 | Slot 3 | Slot.... N |
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    """

    FIRST: PlayerMappableKeySlot #: 0: The first key slot
    SECOND: PlayerMappableKeySlot #: 1: The second mappable key slot. This is the default max in the project settings
    THIRD: PlayerMappableKeySlot #: 2
    FOURTH: PlayerMappableKeySlot #: 3
    FIFTH: PlayerMappableKeySlot #: 4
    SIXTH: PlayerMappableKeySlot #: 5
    SEVENTH: PlayerMappableKeySlot #: 6
    UNSPECIFIED: PlayerMappableKeySlot #: 7: A key that isn't in any slot
    MAX: PlayerMappableKeySlot #: 8
    ...

class InputActionValueType(EnumBase):
    r"""
    EInput Action Value Type
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputActionValue.h
    
    """

    BOOLEAN: InputActionValueType
    r"""
    0: Value types in increasing size order (used for type promotion)
    Name these Digital/Analog?
    """

    AXIS1D: InputActionValueType #: 1
    AXIS2D: InputActionValueType #: 2
    AXIS3D: InputActionValueType #: 3
    ...

class MappingQueryResult(EnumBase):
    r"""
    Result summary from a QueryMapKeyIn... call
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputMappingQuery.h
    
    """

    ERROR_ENHANCED_INPUT_NOT_ENABLED: MappingQueryResult #: 0: Query failed because the player controller being queried is not configured to support enhanced input (PlayerInput is not Enhanced).
    ERROR_INPUT_CONTEXT_NOT_IN_ACTIVE_CONTEXTS: MappingQueryResult #: 1: Query failed because the input context being queried against is not part of the active context list.
    ERROR_INVALID_ACTION: MappingQueryResult #: 2: Query failed because the action being queried against is None/null
    NOT_MAPPABLE: MappingQueryResult #: 3: Mapping cannot be applied due to blocking issues. Check OutIssues for details.
    MAPPING_AVAILABLE: MappingQueryResult #: 4: Mapping will not affect any existing mappings and is safe to apply.
    ...

class MappingQueryIssueFlag(EnumBase):
    r"""
    Mapping issues arising from a QueryMapKeyIn... call
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputMappingQuery.h
    
    """

    NO_ISSUE: MappingQueryIssueFlag #: 0: Mapping will not affect any existing mappings and is safe to apply.
    RESERVED_BY_ACTION: MappingQueryIssueFlag #: 1: Mapping has been reserved for the exclusive use of another action. The new mapping should be refused.
    HIDES_EXISTING_MAPPING: MappingQueryIssueFlag #: 2: Mapping will cause an existing mapping to be hidden and/or need remapping.
    HIDDEN_BY_EXISTING_MAPPING: MappingQueryIssueFlag #: 4: Mapping will not be functional, due to an existing mapping blocking it.
    COLLISION_WITH_MAPPING_IN_SAME_CONTEXT: MappingQueryIssueFlag #: 8: Mapping will be functional, but a collision with another mapping within this context may cause issues.
    FORCES_TYPE_PROMOTION: MappingQueryIssueFlag #: 16: Trying to bind an FKey with a less complex type than the bound action expects (e.g. Keyboard key bound to a 2D Gamepad axis. May not be desirable). Note: bool -> Axis1D promotions are never considered forced.
    FORCES_TYPE_DEMOTION: MappingQueryIssueFlag #: 32: Trying to bind an FKey with a more complex type than the bound action supports (this could behave oddly e.g. 2D Gamepad axis bound to a 1D axis will ignore Y axis)
    ...

class PlayerMappableKeySettingBehaviors(EnumBase):
    r"""
    Defines which Player Mappable Key Setting to use for a Action Key Mapping.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedActionKeyMapping.h
    
    """

    INHERIT_SETTINGS_FROM_ACTION: PlayerMappableKeySettingBehaviors #: 0: Use the Settings specified in the Input Action.
    OVERRIDE_SETTINGS: PlayerMappableKeySettingBehaviors #: 1: Use the Settings specified in the Action Key Mapping overriding the ones specified in the Input action.
    IGNORE_SETTINGS: PlayerMappableKeySettingBehaviors #: 2: Don't use any Settings even if one is specified in the Input Action.
    ...

class TriggerEvent(EnumBase):
    r"""
    Trigger events are the Action's interpretation of all Trigger State transitions that occurred for the action in the last tick
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    """

    TRIGGERED: TriggerEvent #: 1: Triggering occurred after one or more processing ticks
    STARTED: TriggerEvent #: 2: An event has occurred that has begun Trigger evaluation. Note: Triggered may also occur this frame, but this event will always be fired first.
    ONGOING: TriggerEvent
    r"""
    4: Triggering is still being processed. For example, an action with a "Press and Hold" trigger
    will be "Ongoing" while the user is holding down the key but the time threshold has not been met yet.
    """

    CANCELED: TriggerEvent
    r"""
    8: Triggering has been canceled. For example,  the user has let go of a key before the "Press and Hold" time threshold.
    The action has started to be evaluated, but never completed.
    """

    COMPLETED: TriggerEvent
    r"""
    16: The trigger state has transitioned from Triggered to None this frame, i.e. Triggering has finished.
    Note: Using this event restricts you to one set of triggers for Started/Completed events. You may prefer two actions, each with its own trigger rules.
    Completed will not fire if any trigger reports Ongoing on the same frame, but both should fire. e.g. Tick 2 of Hold (= Ongoing) + Pressed (= None) combo will raise Ongoing event only.
    """

    ...

class TakeRecorderState(EnumBase):
    r"""
    ETake Recorder State
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorder.h
    
    """

    COUNTING_DOWN: TakeRecorderState #: 0
    PRE_RECORD: TakeRecorderState #: 1
    TICKING_AFTER_PRE: TakeRecorderState #: 2
    STARTED: TakeRecorderState #: 3
    STOPPED: TakeRecorderState #: 4
    CANCELLED: TakeRecorderState #: 5
    ...

class TakeRecorderMode(EnumBase):
    r"""
    ETake Recorder Mode
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderParameters.h
    
    """

    RECORD_NEW_SEQUENCE: TakeRecorderMode #: 0: Record into a new sequence
    RECORD_INTO_SEQUENCE: TakeRecorderMode #: 1: Record into an existing sequence
    ...

class PropertyBagPropertyType(EnumBase):
    r"""
    Property bag property type, loosely based on BluePrint pin types.
    
    **C++ Source:**
    
    - **Plugin**: StructUtils
    - **Module**: StructUtils
    - **File**: PropertyBag.h
    
    """

    BOOL: PropertyBagPropertyType #: 1
    BYTE: PropertyBagPropertyType #: 2
    INT32: PropertyBagPropertyType #: 3
    INT64: PropertyBagPropertyType #: 4
    FLOAT: PropertyBagPropertyType #: 5
    DOUBLE: PropertyBagPropertyType #: 6
    NAME: PropertyBagPropertyType #: 7
    STRING: PropertyBagPropertyType #: 8
    TEXT: PropertyBagPropertyType #: 9
    U_INT32: PropertyBagPropertyType #: 16
    U_INT64: PropertyBagPropertyType #: 17: Type not fully supported at UI, will work with restrictions to type editing
    ...

class PropertyBagContainerType(EnumBase):
    r"""
    Property bag property container type.
    
    **C++ Source:**
    
    - **Plugin**: StructUtils
    - **Module**: StructUtils
    - **File**: PropertyBag.h
    
    """

    NONE: PropertyBagContainerType #: 0
    ARRAY: PropertyBagContainerType #: 1
    ...

class RigVMPinDirection(EnumBase):
    r"""
    The Pin Direction is used to differentiate different kinds of
    pins in the data flow graph - inputs, outputs etc.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction.h
    
    """

    INPUT: RigVMPinDirection #: 0
    OUTPUT: RigVMPinDirection #: 1: A const input value
    IO: RigVMPinDirection #: 2: A mutable output value
    VISIBLE: RigVMPinDirection #: 3: A mutable input and output value
    HIDDEN: RigVMPinDirection #: 4: A const value that cannot be connected to
    INVALID: RigVMPinDirection #: 5: A mutable hidden value (used for interal state)
    ...

class RigVMFunctionArgumentDirection(EnumBase):
    r"""
    The Function Argument is used to differentiate different kinds of
    pins in the data flow graph - inputs or outputs
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction.h
    
    """

    INPUT: RigVMFunctionArgumentDirection #: 0
    OUTPUT: RigVMFunctionArgumentDirection #: 1: A const input value
    INVALID: RigVMFunctionArgumentDirection #: 2: A mutable output value
    ...

class RigVMParameterType(EnumBase):
    r"""
    The type of parameter for a VM
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVM.h
    
    """

    INPUT: RigVMParameterType #: 0
    OUTPUT: RigVMParameterType #: 1
    INVALID: RigVMParameterType #: 2
    ...

class RigVMUserWorkflowType(EnumBase):
    r"""
    Types of workflows offered by a rigvm struct node
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMUserWorkflow.h
    
    """

    NODE_CONTEXT: RigVMUserWorkflowType #: 1
    PIN_CONTEXT: RigVMUserWorkflowType #: 2
    ON_PIN_DEFAULT_CHANGED: RigVMUserWorkflowType #: 4
    ALL: RigVMUserWorkflowType #: 7
    ...

class RigVMGraphNotifType(EnumBase):
    r"""
    The Graph Notification Type is used to differentiate
    between all of the changes that can happen within a graph.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMNotifications.h
    
    """

    GRAPH_CHANGED: RigVMGraphNotifType #: 0
    NODE_ADDED: RigVMGraphNotifType #: 1: The graph has changed / a new graph has been picked (Subject == nullptr)
    NODE_REMOVED: RigVMGraphNotifType #: 2: A node has been added to the graph (Subject == URigVMNode)
    NODE_SELECTED: RigVMGraphNotifType #: 3: A node has been removed from the graph (Subject == URigVMNode)
    NODE_DESELECTED: RigVMGraphNotifType #: 4: A node has been selected (Subject == URigVMNode)
    NODE_SELECTION_CHANGED: RigVMGraphNotifType #: 5: A node has been deselected (Subject == URigVMNode)
    NODE_POSITION_CHANGED: RigVMGraphNotifType #: 6: The set of selected nodes has changed (Subject == nullptr)
    NODE_SIZE_CHANGED: RigVMGraphNotifType #: 7: A node's position has changed (Subject == URigVMNode)
    NODE_COLOR_CHANGED: RigVMGraphNotifType #: 8: A node's size has changed (Subject == URigVMNode)
    PIN_ADDED: RigVMGraphNotifType #: 9: A node's color has changed (Subject == URigVMNode)
    PIN_REMOVED: RigVMGraphNotifType #: 10: A pin has been added to a given node (Subject == URigVMPin)
    PIN_RENAMED: RigVMGraphNotifType #: 11: A pin has been removed from a given node (Subject == URigVMPin)
    PIN_EXPANSION_CHANGED: RigVMGraphNotifType #: 12: A pin has been renamed (Subject == URigVMPin)
    PIN_WATCHED_CHANGED: RigVMGraphNotifType #: 13: A pin's expansion state has changed(Subject == URigVMPin)
    PIN_ARRAY_SIZE_CHANGED: RigVMGraphNotifType #: 14: A pin's watch state has changed (Subject == URigVMPin)
    PIN_DEFAULT_VALUE_CHANGED: RigVMGraphNotifType #: 15: An array pin's size has changed (Subject == URigVMPin)
    PIN_DIRECTION_CHANGED: RigVMGraphNotifType #: 16: A pin's default value has changed (Subject == URigVMPin)
    PIN_TYPE_CHANGED: RigVMGraphNotifType #: 17: A pin's direction has changed (Subject == URigVMPin)
    PIN_INDEX_CHANGED: RigVMGraphNotifType #: 18: A pin's data type has changed (Subject == URigVMPin)
    LINK_ADDED: RigVMGraphNotifType #: 19: A pin's index has changed (Subject == URigVMPin)
    LINK_REMOVED: RigVMGraphNotifType #: 20: A link has been added (Subject == URigVMLink)
    COMMENT_TEXT_CHANGED: RigVMGraphNotifType #: 21: A link has been removed (Subject == URigVMLink)
    VARIABLE_ADDED: RigVMGraphNotifType #: 22: A comment node's text has changed (Subject == URigVMCommentNode)
    VARIABLE_REMOVED: RigVMGraphNotifType #: 23: A variable has been added (Subject == URigVMVariableNode)
    VARIABLE_RENAMED: RigVMGraphNotifType #: 24: A variable has been removed (Subject == URigVMVariableNode)
    INTERACTION_BRACKET_OPENED: RigVMGraphNotifType #: 25: A variable has been renamed (Subject == URigVMVariableNode)
    INTERACTION_BRACKET_CLOSED: RigVMGraphNotifType #: 26: A bracket has been opened (Subject == nullptr)
    INTERACTION_BRACKET_CANCELED: RigVMGraphNotifType #: 27: A bracket has been opened (Subject == nullptr)
    PIN_BOUND_VARIABLE_CHANGED: RigVMGraphNotifType #: 28: A bracket has been canceled (Subject == nullptr)
    NODE_RENAMED: RigVMGraphNotifType #: 29: A pin has been bound or unbound to / from a variable (Subject == URigVMPin)
    NODE_REFERENCE_CHANGED: RigVMGraphNotifType #: 30: A node has been renamed in the graph (Subject == URigVMNode)
    NODE_CATEGORY_CHANGED: RigVMGraphNotifType #: 31: A node has changed it's referenced function
    NODE_KEYWORDS_CHANGED: RigVMGraphNotifType #: 32: A node's category has changed (Subject == URigVMNode)
    NODE_DESCRIPTION_CHANGED: RigVMGraphNotifType #: 33: A node's keywords have changed (Subject == URigVMNode)
    VARIABLE_REMAPPING_CHANGED: RigVMGraphNotifType #: 34: A node's description has changed (Subject == URigVMNode)
    LIBRARY_TEMPLATE_CHANGED: RigVMGraphNotifType #: 35: A function reference node's remapping has changed (Subject == URigVMFunctionReferenceNode)
    FUNCTION_ACCESS_CHANGED: RigVMGraphNotifType #: 36: The definition of a library node's template has changed (Subject == URigVMLibraryNode)
    INVALID: RigVMGraphNotifType #: 37: The function has been made public/private (Subject == URigVMLibraryNode)
    ...

class RigElementType(EnumBase):
    r"""
    * This is rig element types that we support
    * This can be used as a mask so supported as a bitfield
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """

    NONE: RigElementType #: 0
    BONE: RigElementType #: 1
    NULL: RigElementType #: 2
    CONTROL: RigElementType #: 4
    CURVE: RigElementType #: 8
    REFERENCE: RigElementType #: 32
    CONNECTOR: RigElementType #: 64
    SOCKET: RigElementType #: 128
    ALL: RigElementType #: 255
    ...

class RigControlTransformChannel(EnumBase):
    r"""
    ERig Control Transform Channel
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    """

    TRANSLATION_X: RigControlTransformChannel #: 0
    TRANSLATION_Y: RigControlTransformChannel #: 1
    TRANSLATION_Z: RigControlTransformChannel #: 2
    PITCH: RigControlTransformChannel #: 3
    YAW: RigControlTransformChannel #: 4
    ROLL: RigControlTransformChannel #: 5
    SCALE_X: RigControlTransformChannel #: 6
    SCALE_Y: RigControlTransformChannel #: 7
    SCALE_Z: RigControlTransformChannel #: 8
    ...

class RigControlVisibility(EnumBase):
    r"""
    ERig Control Visibility
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """

    USER_DEFINED: RigControlVisibility #: 0: Visibility controlled by the graph
    BASED_ON_SELECTION: RigControlVisibility #: 1: Visibility Controlled by the selection of driven controls
    ...

class RigControlAxis(EnumBase):
    r"""
    ERig Control Axis
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """

    X: RigControlAxis #: 0
    Y: RigControlAxis #: 1
    Z: RigControlAxis #: 2
    ...

class RigControlType(EnumBase):
    r"""
    ERig Control Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """

    BOOL: RigControlType #: 0
    FLOAT: RigControlType #: 1
    INTEGER: RigControlType #: 2
    VECTOR2D: RigControlType #: 3
    POSITION: RigControlType #: 4
    SCALE: RigControlType #: 5
    ROTATOR: RigControlType #: 6
    EULER_TRANSFORM: RigControlType #: 9
    SCALE_FLOAT: RigControlType #: 10
    ...

class RigControlAnimationType(EnumBase):
    r"""
    ERig Control Animation Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """

    ANIMATION_CONTROL: RigControlAnimationType #: 0: A visible, animatable control.
    ANIMATION_CHANNEL: RigControlAnimationType #: 1: An animation channel without a 3d shape
    PROXY_CONTROL: RigControlAnimationType
    r"""
    2: A control to drive other controls,
    not animatable in sequencer.
    """

    VISUAL_CUE: RigControlAnimationType
    r"""
    3: Visual feedback only - the control is
    neither animatable nor selectable.
    """

    ...

class ConnectorType(EnumBase):
    r"""
    EConnector Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    """

    PRIMARY: ConnectorType #: 0
    SECONDARY: ConnectorType #: 1: Single primary connector, non-optional and always visible. When dropped on another element, this connector will resolve to that element.
    ...

class ControlRigFKRigExecuteMode(EnumBase):
    r"""
    EControl Rig FKRig Execute Mode
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: FKControlRig.h
    
    """

    REPLACE: ControlRigFKRigExecuteMode #: 0: Replaces the current pose
    ADDITIVE: ControlRigFKRigExecuteMode #: 1: Applies the authored pose as an additive layer
    DIRECT: ControlRigFKRigExecuteMode #: 2: Sets the current pose without the use of offset transforms
    ...

class RigBoneType(EnumBase):
    r"""
    ERig Bone Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """

    IMPORTED: RigBoneType #: 0
    USER: RigBoneType #: 1
    ...

class RigMetadataType(EnumBase):
    r"""
    * The type of meta data stored on an element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """

    BOOL: RigMetadataType #: 0
    BOOL_ARRAY: RigMetadataType #: 1
    FLOAT: RigMetadataType #: 2
    FLOAT_ARRAY: RigMetadataType #: 3
    INT32: RigMetadataType #: 4
    INT32_ARRAY: RigMetadataType #: 5
    NAME: RigMetadataType #: 6
    NAME_ARRAY: RigMetadataType #: 7
    VECTOR: RigMetadataType #: 8
    VECTOR_ARRAY: RigMetadataType #: 9
    ROTATOR: RigMetadataType #: 10
    ROTATOR_ARRAY: RigMetadataType #: 11
    QUAT: RigMetadataType #: 12
    QUAT_ARRAY: RigMetadataType #: 13
    TRANSFORM: RigMetadataType #: 14
    TRANSFORM_ARRAY: RigMetadataType #: 15
    LINEAR_COLOR: RigMetadataType #: 16
    LINEAR_COLOR_ARRAY: RigMetadataType #: 17
    RIG_ELEMENT_KEY: RigMetadataType #: 18
    RIG_ELEMENT_KEY_ARRAY: RigMetadataType #: 19
    ...

class RigControlValueType(EnumBase):
    r"""
    ERig Control Value Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """

    INITIAL: RigControlValueType #: 0
    CURRENT: RigControlValueType #: 1
    MINIMUM: RigControlValueType #: 2
    MAXIMUM: RigControlValueType #: 3
    ...

class RigSpaceType(EnumBase):
    r"""
    ERig Space Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigSpaceHierarchy.h
    
    """

    GLOBAL: RigSpaceType #: 0: Not attached to anything
    BONE: RigSpaceType #: 1: Attached to a bone
    CONTROL: RigSpaceType #: 2: Attached to a control
    SPACE: RigSpaceType #: 3: Attached to a space
    ...

class MovieSceneControlRigSpaceType(EnumBase):
    r"""
    EMovie Scene Control Rig Space Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: MovieSceneControlRigSpaceChannel.h
    
    """

    PARENT: MovieSceneControlRigSpaceType #: 0
    WORLD: MovieSceneControlRigSpaceType #: 1
    CONTROL_RIG: MovieSceneControlRigSpaceType #: 2
    ...

class ConstraintInterpType(EnumBase):
    r"""
    Options for interpolating rotations
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    """

    AVERAGE: ConstraintInterpType #: 0: Weighted Average of Quaternions by their X,Y,Z,W values, The Shortest Route is Respected. The Order of Parents Doesn't Matter
    SHORTEST: ConstraintInterpType #: 1: Perform Quaternion Slerp in Sequence, Different Orders of Parents can Produce Different Results
    ...

class RigMetaDataNameSpace(EnumBase):
    r"""
    ERig Meta Data Name Space
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnitContext.h
    
    """

    NONE: RigMetaDataNameSpace #: 0: Use no namespace - store the metadata directly on the item
    SELF: RigMetaDataNameSpace #: 1: Store the metadata for item relative to its module
    PARENT: RigMetaDataNameSpace #: 2: Store the metadata relative to its parent model
    ROOT: RigMetaDataNameSpace #: 3: Store the metadata under the root module
    ...

class PBIKLimitType(EnumBase):
    r"""
    EPBIKLimit Type
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: PBIK
    - **File**: PBIK_Shared.h
    
    """

    FREE: PBIKLimitType #: 0
    LIMITED: PBIKLimitType #: 1
    LOCKED: PBIKLimitType #: 2
    ...

class PBIKRootBehavior(EnumBase):
    r"""
    namespace
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: PBIK
    - **File**: PBIKSolver.h
    
    """

    PRE_PULL: PBIKRootBehavior #: 0
    PIN_TO_INPUT: PBIKRootBehavior #: 1
    FREE: PBIKRootBehavior #: 2
    ...

class PyTestEnum(EnumBase):
    r"""
    Enum to allow testing of the various UEnum features that are exposed to Python wrapped types.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    """

    ONE: PyTestEnum #: 0
    TWO: PyTestEnum #: 1
    ...

class InterpCurveMode(EnumBase):
    r"""
    Describes shape of an interpolation curve (mirrored from InterpCurvePoint.h).
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    CIM_LINEAR: InterpCurveMode #: 0: A straight line between two keypoint values.
    CIM_CURVE_AUTO: InterpCurveMode
    r"""
    1: A cubic-hermite curve between two keypoints, using Arrive/Leave tangents. These tangents will be automatically
                  updated when points are moved, etc.  Tangents are unclamped and will plateau at curve start and end points.
    """

    CIM_CONSTANT: InterpCurveMode #: 2: The out value is held constant until the next key, then will jump to that value.
    CIM_CURVE_USER: InterpCurveMode #: 3: A smooth curve just like CIM_Curve, but tangents are not automatically updated so you can have manual control over them (eg. in Curve Editor).
    CIM_CURVE_BREAK: InterpCurveMode #: 4: A curve like CIM_Curve, but the arrive and leave tangents are not forced to be the same, so you can create a 'corner' at this key.
    CIM_CURVE_AUTO_CLAMPED: InterpCurveMode
    r"""
    5: A cubic-hermite curve between two keypoints, using Arrive/Leave tangents. These tangents will be automatically
              updated when points are moved, etc.  Tangents are clamped and will plateau at curve start and end points.
    """

    ...

class TypedElementChildInclusionMethod(EnumBase):
    r"""
    ETyped Element Child Inclusion Method
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementSelectionInterface.h
    
    """

    NONE: TypedElementChildInclusionMethod #: 0: Do not include child elements
    IMMEDIATE: TypedElementChildInclusionMethod #: 1: Include the immediate child elements, but do not recurse
    RECURSIVE: TypedElementChildInclusionMethod #: 2: Include the immediate child elements, and recurse into their children too
    ...

class SleepFamily(EnumBase):
    r"""
    Presets of values used in considering when put this body to sleep.
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: ChaosEngineInterface.h
    
    """

    NORMAL: SleepFamily #: 0: Engine defaults.
    SENSITIVE: SleepFamily #: 1: A family of values with a lower sleep threshold; good for slower pendulum-like physics.
    CUSTOM: SleepFamily #: 2: Specify your own sleep threshold multiplier
    ...

class SlateBrushMirrorType(EnumBase):
    r"""
    Possible options for mirroring the brush image
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateBrush.h
    
    """

    NO_MIRROR: SlateBrushMirrorType #: 0: Don't mirror anything, just draw the texture as it is.
    HORIZONTAL: SlateBrushMirrorType #: 1: Mirror the image horizontally.
    VERTICAL: SlateBrushMirrorType #: 2: Mirror the image vertically.
    BOTH: SlateBrushMirrorType #: 3: Mirror in both directions.
    ...

class SlateBrushImageType(EnumBase):
    r"""
    Enumerates brush image types.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateBrush.h
    
    """

    NO_IMAGE: SlateBrushImageType #: 0: No image is loaded.  Color only brushes, transparent brushes etc.
    FULL_COLOR: SlateBrushImageType #: 1: The image to be loaded is in full color.
    LINEAR: SlateBrushImageType #: 2: The image is a special texture in linear space (usually a rendering resource such as a lookup table).
    VECTOR: SlateBrushImageType #: 3: The image is vector graphics and will be rendered and cached in full color using size/scale requested by slate
    ...

class SlateBrushRoundingType(EnumBase):
    r"""
    Enumerates rounding options
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateBrush.h
    
    """

    FIXED_RADIUS: SlateBrushRoundingType #: 0: Use the specified Radius *
    HALF_HEIGHT_RADIUS: SlateBrushRoundingType #: 1: The rounding radius should be half the height such that it always looks perfectly round *
    ...

class AudioMixerStreamDataFormatType(EnumBase):
    r"""
    Duplicate of Audio::EAudioMixerStreamDataFormat::Type, to get around UHT's lack of namespace support
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerBlueprintLibrary.h
    
    """

    UNKNOWN: AudioMixerStreamDataFormatType #: 0
    FLOAT: AudioMixerStreamDataFormatType #: 1
    INT16: AudioMixerStreamDataFormatType #: 2
    UNSUPPORTED: AudioMixerStreamDataFormatType #: 3
    ...

class AudioMixerChannelType(EnumBase):
    r"""
    A copy of Audio::EAudioMixerChannel::Type to get around UHT's refusal of namespaces
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerBlueprintLibrary.h
    
    """

    FRONT_LEFT: AudioMixerChannelType #: 0
    FRONT_RIGHT: AudioMixerChannelType #: 1
    FRONT_CENTER: AudioMixerChannelType #: 2
    LOW_FREQUENCY: AudioMixerChannelType #: 3
    BACK_LEFT: AudioMixerChannelType #: 4
    BACK_RIGHT: AudioMixerChannelType #: 5
    FRONT_LEFT_OF_CENTER: AudioMixerChannelType #: 6
    FRONT_RIGHT_OF_CENTER: AudioMixerChannelType #: 7
    BACK_CENTER: AudioMixerChannelType #: 8
    SIDE_LEFT: AudioMixerChannelType #: 9
    SIDE_RIGHT: AudioMixerChannelType #: 10
    TOP_CENTER: AudioMixerChannelType #: 11
    TOP_FRONT_LEFT: AudioMixerChannelType #: 12
    TOP_FRONT_CENTER: AudioMixerChannelType #: 13
    TOP_FRONT_RIGHT: AudioMixerChannelType #: 14
    TOP_BACK_LEFT: AudioMixerChannelType #: 15
    TOP_BACK_CENTER: AudioMixerChannelType #: 16
    TOP_BACK_RIGHT: AudioMixerChannelType #: 17
    UNKNOWN: AudioMixerChannelType #: 18
    CHANNEL_TYPE_COUNT: AudioMixerChannelType #: 19
    DEFAULT_CHANNEL: AudioMixerChannelType #: 0
    ...

class SlateCheckBoxType(EnumBase):
    r"""
    Type of check box
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    """

    CHECK_BOX: SlateCheckBoxType #: 0: Traditional check box with check button and label (or other content)
    TOGGLE_BUTTON: SlateCheckBoxType #: 1: Toggle button.  You provide button content (such as an image), and the user can press to toggle it.
    ...

class AudioParameterType(EnumBase):
    r"""
    EAudio Parameter Type
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: AudioParameter.h
    
    """

    NONE: AudioParameterType
    r"""
    0: 'Default' results in behavior that is resolved
    based on the system interpreting it.  To support
    legacy implementation, SoundCues cache all typed values
    associated with a given parameter name.
    For MetaSounds, use a specific Type instead of this one.
    """

    BOOLEAN: AudioParameterType #: 1: Boolean value
    INTEGER: AudioParameterType #: 2: Integer value
    FLOAT: AudioParameterType #: 3: Float value
    STRING: AudioParameterType #: 4: String value (not supported by legacy SoundCue system)
    OBJECT: AudioParameterType #: 5: Object value (types other than SoundWave not supported by legacy SoundCue system)
    BOOLEAN_ARRAY: AudioParameterType #: 7: Array of boolean values (not supported by legacy SoundCue system)
    INTEGER_ARRAY: AudioParameterType #: 8: Array of integer values (not supported by legacy SoundCue system)
    FLOAT_ARRAY: AudioParameterType #: 9: Array of float values (not supported by legacy SoundCue system)
    STRING_ARRAY: AudioParameterType #: 10: Array of string values (not supported by legacy SoundCue system)
    OBJECT_ARRAY: AudioParameterType #: 11: Array of object values (not supported by legacy SoundCue system)
    TRIGGER: AudioParameterType #: 12: Trigger value
    ...

class LiveLinkCameraProjectionMode(EnumBase):
    r"""
    ELive Link Camera Projection Mode
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkCameraTypes.h
    
    """

    PERSPECTIVE: LiveLinkCameraProjectionMode #: 0
    ORTHOGRAPHIC: LiveLinkCameraProjectionMode #: 1
    ...

class AIParamType(EnumBase):
    r"""
    EAIParam Type
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryTypes.h
    
    """

    FLOAT: AIParamType #: 0
    INT: AIParamType #: 1
    BOOL: AIParamType #: 2
    ...

class EnvQueryParam(EnumBase):
    r"""
    deprecated: 'EnvQueryParam' was renamed to 'AIParamType'.
    """

    FLOAT: EnvQueryParam #: 0
    INT: EnvQueryParam #: 1
    BOOL: EnvQueryParam #: 2
    ...

class BloomMethod(EnumBase):
    r"""
    EBloom Method
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    """

    BM_SOG: BloomMethod #: 0: Sum of Gaussian formulation
    BM_FFT: BloomMethod #: 1: Fast Fourier Transform Image based convolution, intended for cinematics (too expensive for games)
    ...

class AutoExposureMethod(EnumBase):
    r"""
    Used by FPostProcessSettings Auto Exposure
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    """

    AEM_HISTOGRAM: AutoExposureMethod #: 0: requires compute shader to construct 64 bin histogram
    AEM_BASIC: AutoExposureMethod #: 1: faster method that computes single value by downsampling
    AEM_MANUAL: AutoExposureMethod #: 2: Uses camera settings.
    ...

class TemperatureMethod(EnumBase):
    r"""
    Used by FPostProcessSettings to determine Temperature calculation method.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    """

    TEMP_WHITE_BALANCE: TemperatureMethod #: 0
    TEMP_COLOR_TEMPERATURE: TemperatureMethod #: 1
    ...

class DynamicGlobalIlluminationMethod(EnumBase):
    r"""
    Note: Must match r.DynamicGlobalIlluminationMethod, this is used in URendererSettings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    NONE: DynamicGlobalIlluminationMethod #: 0: No dynamic Global Illumination method will be used. Global Illumination can still be baked into lightmaps.
    LUMEN: DynamicGlobalIlluminationMethod #: 1: Use Lumen Global Illumination for all lights, emissive materials casting light and SkyLight Occlusion.  Requires 'Generate Mesh Distance Fields' enabled for Software Ray Tracing and 'Support Hardware Ray Tracing' enabled for Hardware Ray Tracing.
    SCREEN_SPACE: DynamicGlobalIlluminationMethod #: 2: Standalone Screen Space Global Illumination.  Low cost, but limited by screen space information.
    PLUGIN: DynamicGlobalIlluminationMethod #: 3: Use a plugin for Global Illumination
    ...

class ReflectionMethod(EnumBase):
    r"""
    Note: Must match r.ReflectionMethod, this is used in URendererSettings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    NONE: ReflectionMethod #: 0: No global reflection method will be used. Reflections can still come from Reflection Captures, Planar Reflections or a Skylight placed in the level.
    LUMEN: ReflectionMethod #: 1: Use Lumen Reflections, which supports Screen / Software / Hardware Ray Tracing together and integrates with Lumen Global Illumination for rough reflections and Global Illumination seen in reflections.
    SCREEN_SPACE: ReflectionMethod #: 2: Standalone Screen Space Reflections.  Low cost, but limited by screen space information.
    ...

class LumenRayLightingModeOverride(EnumBase):
    r"""
    ELumen Ray Lighting Mode Override
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    """

    DEFAULT: LumenRayLightingModeOverride #: 0: Use the project default method
    SURFACE_CACHE: LumenRayLightingModeOverride #: 1: Use the Lumen Surface Cache to light reflection rays.  This method gives the best reflection performance.
    HIT_LIGHTING: LumenRayLightingModeOverride #: 2: Calculate lighting at the ray hit point.  This method gives the highest reflection quality, but greatly increases GPU cost, as the material needs to be evaluated and shadow rays traced.  The Surface Cache will still be used for Diffuse Indirect lighting (GI seen in Reflections).
    ...

class TranslucencyType(EnumBase):
    r"""
    ETranslucency Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    """

    RASTER: TranslucencyType #: 0
    RAY_TRACING: TranslucencyType #: 1
    ...

class ReflectedAndRefractedRayTracedShadows(EnumBase):
    r"""
    EReflected and Refracted Ray Traced Shadows
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    """

    DISABLED: ReflectedAndRefractedRayTracedShadows #: 0
    HARD_SHADOWS: ReflectedAndRefractedRayTracedShadows #: 1
    AREA_SHADOWS: ReflectedAndRefractedRayTracedShadows #: 2
    ...

class CameraFocusMethod(EnumBase):
    r"""
    Supported methods for focusing the camera.
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraSettings.h
    
    """

    DO_NOT_OVERRIDE: CameraFocusMethod #: 0: Don't override, ie. allow post process volume settings to persist.
    MANUAL: CameraFocusMethod #: 1: Allows for specifying or animating exact focus distances.
    TRACKING: CameraFocusMethod #: 2: Locks focus to specific object.
    DISABLE: CameraFocusMethod #: 3: Disable depth of field entirely.
    ...

class InputDevices(EnumBase):
    r"""
    Input event data can be applicable to many possible input devices.
    These flags are used to indicate specific or sets of device types.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: InputState.h
    
    """

    NONE: InputDevices #: 0
    KEYBOARD: InputDevices #: 1
    MOUSE: InputDevices #: 2
    GAMEPAD: InputDevices #: 4
    OCULUS_TOUCH: InputDevices #: 8
    HTC_VIVE_WANDS: InputDevices #: 16
    ANY_SPATIAL_DEVICE: InputDevices #: 24
    TABLET_FINGERS: InputDevices #: 1024
    ...

class ContentBrowserItemTypeFilter(EnumBase):
    r"""
    Flags controlling which item types should be included
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataFilter.h
    
    """

    INCLUDE_NONE: ContentBrowserItemTypeFilter #: 0
    INCLUDE_FOLDERS: ContentBrowserItemTypeFilter #: 1
    INCLUDE_FILES: ContentBrowserItemTypeFilter #: 2
    INCLUDE_ALL: ContentBrowserItemTypeFilter #: 3
    ...

class ContentBrowserItemCategoryFilter(EnumBase):
    r"""
    Flags controlling which item categories should be included
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataFilter.h
    
    """

    INCLUDE_NONE: ContentBrowserItemCategoryFilter #: 0
    INCLUDE_ASSETS: ContentBrowserItemCategoryFilter #: 1
    INCLUDE_CLASSES: ContentBrowserItemCategoryFilter #: 2
    INCLUDE_COLLECTIONS: ContentBrowserItemCategoryFilter #: 4
    INCLUDE_MISC: ContentBrowserItemCategoryFilter #: 8
    INCLUDE_ALL: ContentBrowserItemCategoryFilter #: 15
    ...

class ContentBrowserItemAttributeFilter(EnumBase):
    r"""
    Flags controlling which item attributes should be included
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataFilter.h
    
    """

    INCLUDE_NONE: ContentBrowserItemAttributeFilter #: 0
    INCLUDE_PROJECT: ContentBrowserItemAttributeFilter #: 1
    INCLUDE_ENGINE: ContentBrowserItemAttributeFilter #: 2
    INCLUDE_PLUGINS: ContentBrowserItemAttributeFilter #: 4
    INCLUDE_DEVELOPER: ContentBrowserItemAttributeFilter #: 8
    INCLUDE_LOCALIZED: ContentBrowserItemAttributeFilter #: 16
    INCLUDE_ALL: ContentBrowserItemAttributeFilter #: 31
    ...

class AssetMigrationConflict(EnumBase):
    r"""
    EAsset Migration Conflict
    
    **C++ Source:**
    
    - **Module**: AssetTools
    - **File**: IAssetTools.h
    
    """

    SKIP: AssetMigrationConflict #: 0: Skip Assets
    OVERWRITE: AssetMigrationConflict #: 1: Overwrite Assets
    CANCEL: AssetMigrationConflict #: 2: Cancel the whole Migration
    ...

class AnimGroupRole(EnumBase):
    r"""
    EAnim Group Role
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationAsset.h
    
    """

    CAN_BE_LEADER: AnimGroupRole #: 0: This node can be the leader, as long as it has a higher blend weight than the previous best leader.
    ALWAYS_FOLLOWER: AnimGroupRole #: 1: This node will always be a follower (unless there are only followers, in which case the first one ticked wins).
    ALWAYS_LEADER: AnimGroupRole #: 2: This node will always be a leader (if more than one node is AlwaysLeader, the last one ticked wins).
    TRANSITION_LEADER: AnimGroupRole #: 3: This node will be excluded from the sync group while blending in. Once blended in it will be the sync group leader until blended out
    TRANSITION_FOLLOWER: AnimGroupRole #: 4: This node will be excluded from the sync group while blending in. Once blended in it will be a follower until blended out
    ...

class AnimAlphaInputType(EnumBase):
    r"""
    AnimNodes using an Alpha can choose how it is driven.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputScaleBias.h
    
    """

    FLOAT: AnimAlphaInputType #: 0
    BOOL: AnimAlphaInputType #: 1
    CURVE: AnimAlphaInputType #: 2
    ...

class AlphaBlendOption(EnumBase):
    r"""
    EAlpha Blend Option
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AlphaBlend.h
    
    """

    LINEAR: AlphaBlendOption #: 0: Linear interpolation
    CUBIC: AlphaBlendOption #: 1: Cubic-in interpolation
    HERMITE_CUBIC: AlphaBlendOption #: 2: Hermite-Cubic
    SINUSOIDAL: AlphaBlendOption #: 3: Sinusoidal interpolation
    QUADRATIC_IN_OUT: AlphaBlendOption #: 4: Quadratic in-out interpolation
    CUBIC_IN_OUT: AlphaBlendOption #: 5: Cubic in-out interpolation
    QUARTIC_IN_OUT: AlphaBlendOption #: 6: Quartic in-out interpolation
    QUINTIC_IN_OUT: AlphaBlendOption #: 7: Quintic in-out interpolation
    CIRCULAR_IN: AlphaBlendOption #: 8: Circular-in interpolation
    CIRCULAR_OUT: AlphaBlendOption #: 9: Circular-out interpolation
    CIRCULAR_IN_OUT: AlphaBlendOption #: 10: Circular in-out interpolation
    EXP_IN: AlphaBlendOption #: 11: Exponential-in interpolation
    EXP_OUT: AlphaBlendOption #: 12: Exponential-Out interpolation
    EXP_IN_OUT: AlphaBlendOption #: 13: Exponential in-out interpolation
    CUSTOM: AlphaBlendOption #: 14: Custom interpolation, will use custom curve inside an FAlphaBlend or linear if none has been set
    ...

class BoneAxis(EnumBase):
    r"""
    Enum for specifying a specific axis of a bone
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """

    BA_X: BoneAxis #: 0
    BA_Y: BoneAxis #: 1
    BA_Z: BoneAxis #: 2
    ...

class RotationComponent(EnumBase):
    r"""
    A rotational component. This is used for retargeting, for example.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: CommonAnimationTypes.h
    
    """

    EULER_X: RotationComponent #: 0: Using the X component of the Euler rotation
    EULER_Y: RotationComponent #: 1: Using the Y component of the Euler rotation
    EULER_Z: RotationComponent #: 2: Using the Z component of the Euler rotation
    QUATERNION_ANGLE: RotationComponent #: 3: Using the angle of the quaternion
    SWING_ANGLE: RotationComponent #: 4: Using the angle of the swing quaternion
    TWIST_ANGLE: RotationComponent #: 5: Using the angle of the twist quaternion
    ...

class EasingFuncType(EnumBase):
    r"""
    An easing type defining how to ease float values.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: CommonAnimationTypes.h
    
    """

    LINEAR: EasingFuncType #: 0: Linear easing (no change to the value)
    SINUSOIDAL: EasingFuncType #: 1: Easing using a sinus function
    CUBIC: EasingFuncType #: 2: Cubic version of the value (only in)
    QUADRATIC_IN_OUT: EasingFuncType #: 3: Quadratic version of the value (in and out)
    CUBIC_IN_OUT: EasingFuncType #: 4: Cubic version of the value (in and out)
    HERMITE_CUBIC: EasingFuncType #: 5: Easing using a cubic hermite function
    QUARTIC_IN_OUT: EasingFuncType #: 6: Quartic version of the value (in and out)
    QUINTIC_IN_OUT: EasingFuncType #: 7: Quintic version of the value (in and out)
    CIRCULAR_IN: EasingFuncType #: 8: Circular easing (only in)
    CIRCULAR_OUT: EasingFuncType #: 9: Circular easing (only out)
    CIRCULAR_IN_OUT: EasingFuncType #: 10: Circular easing (in and out)
    EXP_IN: EasingFuncType #: 11: Exponential easing (only in)
    EXP_OUT: EasingFuncType #: 12: Exponential easing (only out)
    EXP_IN_OUT: EasingFuncType #: 13: Exponential easing (in and out)
    CUSTOM_CURVE: EasingFuncType #: 14: Custom - based on an optional Curve
    ...

class AnimSyncMethod(EnumBase):
    r"""
    How an asset will synchronize with other assets
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationAsset.h
    
    """

    DO_NOT_SYNC: AnimSyncMethod #: 0: Don't sync ever
    SYNC_GROUP: AnimSyncMethod #: 1: Use a named sync group
    GRAPH: AnimSyncMethod #: 2: Use the graph structure to provide a sync group to apply
    ...

class BlendListTransitionType(EnumBase):
    r"""
    EBlend List Transition Type
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendListBase.h
    
    """

    STANDARD_BLEND: BlendListTransitionType #: 0
    INERTIALIZATION: BlendListTransitionType #: 1
    ...

class AnimFunctionCallSite(EnumBase):
    r"""
    When to call the function during the execution of the animation graph
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_CallFunction.h
    
    """

    ON_INITIALIZE: AnimFunctionCallSite #: 0: Called when the node is initialized - i.e. it becomes weighted/relevant in the graph (before child nodes are initialized)
    ON_UPDATE: AnimFunctionCallSite #: 1: Called when the node is updated (before child nodes are updated)
    ON_BECOME_RELEVANT: AnimFunctionCallSite #: 2: Called when the node is updated for the first time with a valid weight
    ON_EVALUATE: AnimFunctionCallSite #: 3: Called when the node is evaluated (before child nodes are evaluated)
    ON_INITIALIZE_POST_RECURSION: AnimFunctionCallSite #: 4: Called when the node is initialized - i.e. it becomes weighted/relevant in the graph (after child nodes are initialized)
    ON_UPDATE_POST_RECURSION: AnimFunctionCallSite #: 5: Called when the node is updated (after child nodes are updated)
    ON_BECOME_RELEVANT_POST_RECURSION: AnimFunctionCallSite #: 6: Called when the node is updated for the first time with a valid weight (after child nodes are updated)
    ON_EVALUATE_POST_RECURSION: AnimFunctionCallSite #: 7: Called when the node is evaluated (after child nodes are evaluated)
    ON_STARTED_BLENDING_OUT: AnimFunctionCallSite
    r"""
    8: Called when the node is updated, was at full weight and beings to blend out. Called before child nodes are
    updated
    """

    ON_STARTED_BLENDING_IN: AnimFunctionCallSite #: 9: Called when the node is updated, was at zero weight and beings to blend in. Called before child nodes are updated
    ON_FINISHED_BLENDING_IN: AnimFunctionCallSite
    r"""
    11: Called when the node is updated, was at non-zero weight and becomes full weight. Called before child nodes are
    updated
    """

    ...

class LayeredBoneBlendMode(EnumBase):
    r"""
    ELayered Bone Blend Mode
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_LayeredBoneBlend.h
    
    """

    BRANCH_FILTER: LayeredBoneBlendMode #: 0
    BLEND_MASK: LayeredBoneBlendMode #: 1
    ...

class CurveBlendOption(EnumBase):
    r"""
    ECurve Blend Option
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """

    OVERRIDE: CurveBlendOption #: 0: Last pose that contains valid curve value override it.
    DO_NOT_OVERRIDE: CurveBlendOption #: 1: Only set the value if the previous pose doesn't have the curve value.
    NORMALIZE_BY_WEIGHT: CurveBlendOption #: 2: Normalize By Sum of Weight and use it to blend.
    BLEND_BY_WEIGHT: CurveBlendOption #: 3: Blend By Weight without normalizing
    USE_BASE_POSE: CurveBlendOption #: 4: Use Base Pose for all curve values. Do not blend
    USE_MAX_VALUE: CurveBlendOption #: 5: Find the highest curve value from multiple poses and use that.
    USE_MIN_VALUE: CurveBlendOption #: 6: Find the lowest curve value from multiple poses and use that.
    ...

class ModifyCurveApplyMode(EnumBase):
    r"""
    EModify Curve Apply Mode
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_ModifyCurve.h
    
    """

    ADD: ModifyCurveApplyMode #: 0: Add new value to input curve value
    SCALE: ModifyCurveApplyMode #: 1: Scale input value by new value
    BLEND: ModifyCurveApplyMode #: 2: Blend input with new curve value, using Alpha setting on the node
    WEIGHTED_MOVING_AVERAGE: ModifyCurveApplyMode #: 3: Blend the new curve value with the last curve value using Alpha to determine the weighting (.5 is a moving average, higher values react to new values faster, lower slower)
    REMAP_CURVE: ModifyCurveApplyMode #: 4: Remaps the new curve value between the CurveValues entry and 1.0 (.5 in CurveValues makes 0.51 map to 0.02)
    ...

class RBFSolverType(EnumBase):
    r"""
    The solver type to use. The two solvers have different requirements.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: RBFSolver.h
    
    """

    ADDITIVE: RBFSolverType
    r"""
    0: The additive solver sums up contributions from each target. It's faster
              but may require more targets for a good coverage, and requires the
                  normalization step to be performed for smooth results.
    """

    INTERPOLATIVE: RBFSolverType
    r"""
    1: The interpolative solver interpolates the values from each target based
                  on distance. As long as the input values are within the area bounded by
                  the targets, the interpolation is well-behaved and return weight values
                  within the 0% - 100% limit with no normalization required.
                  Interpolation also gives smoother results, with fewer targets, than additive
                  but at a higher computational cost.
    """

    ...

class RBFFunctionType(EnumBase):
    r"""
    Function to use for each target falloff
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: RBFSolver.h
    
    """

    GAUSSIAN: RBFFunctionType #: 0
    EXPONENTIAL: RBFFunctionType #: 1
    LINEAR: RBFFunctionType #: 2
    CUBIC: RBFFunctionType #: 3
    QUINTIC: RBFFunctionType #: 4
    DEFAULT_FUNCTION: RBFFunctionType #: 5: Uses the setting of the parent container
    ...

class RBFDistanceMethod(EnumBase):
    r"""
    Method for determining distance from input to targets
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: RBFSolver.h
    
    """

    EUCLIDEAN: RBFDistanceMethod #: 0: Standard n-dimensional distance measure
    QUATERNION: RBFDistanceMethod #: 1: Treat inputs as quaternion
    SWING_ANGLE: RBFDistanceMethod #: 2: Treat inputs as quaternion, and find distance between rotated TwistAxis direction
    TWIST_ANGLE: RBFDistanceMethod #: 3: Treat inputs as quaternion, and find distance between rotations around the TwistAxis direction
    DEFAULT_METHOD: RBFDistanceMethod #: 4: Uses the setting of the parent container
    ...

class RBFNormalizeMethod(EnumBase):
    r"""
    Method to normalize weights
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: RBFSolver.h
    
    """

    ONLY_NORMALIZE_ABOVE_ONE: RBFNormalizeMethod #: 0: Only normalize above one
    ALWAYS_NORMALIZE: RBFNormalizeMethod
    r"""
    1: Always normalize.
    Zero distribution weights stay zero.
    """

    NORMALIZE_WITHIN_MEDIAN: RBFNormalizeMethod
    r"""
    2: Normalize only within reference median. The median
    is a cone with a minimum and maximum angle within
    which the value will be interpolated between
    non-normalized and normalized. This helps to define
    the volume in which normalization is always required.
    """

    NO_NORMALIZATION: RBFNormalizeMethod
    r"""
    3: Don't normalize at all. This should only be used with
    the interpolative method, if it is known that all input
    values will be within the area bounded by the targets.
    """

    ...

class SnapshotSourceMode(EnumBase):
    r"""
    How to access the snapshot
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_PoseSnapshot.h
    
    """

    NAMED_SNAPSHOT: SnapshotSourceMode
    r"""
    0: Refer to an internal snapshot by name (previously stored with SavePoseSnapshot).
    This can be more efficient than access via pin.
    """

    SNAPSHOT_PIN: SnapshotSourceMode
    r"""
    1: Use a snapshot variable (previously populated using SnapshotPose).
    This is more flexible and allows poses to be modified and managed externally to the animation blueprint.
    """

    ...

class DrivenDestinationMode(EnumBase):
    r"""
    Type of destination value to drive
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BoneDrivenController.h
    
    """

    BONE: DrivenDestinationMode #: 0
    MORPH_TARGET: DrivenDestinationMode #: 1
    MATERIAL_PARAMETER: DrivenDestinationMode #: 2
    ...

class DrivenBoneModificationMode(EnumBase):
    r"""
    The type of modification to make to the destination component(s)
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BoneDrivenController.h
    
    """

    ADD_TO_INPUT: DrivenBoneModificationMode #: 0: Add the driven value to the input component value(s)
    REPLACE_COMPONENT: DrivenBoneModificationMode #: 1: Replace the input component value(s) with the driven value
    ADD_TO_REF_POSE: DrivenBoneModificationMode #: 2: Add the driven value to the reference pose value
    ...

class ComponentType(EnumBase):
    r"""
    The transform component (attribute) to read from
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """

    NONE: ComponentType #: 0
    TRANSLATION_X: ComponentType #: 1
    TRANSLATION_Y: ComponentType #: 2
    TRANSLATION_Z: ComponentType #: 3
    ROTATION_X: ComponentType #: 4
    ROTATION_Y: ComponentType #: 5
    ROTATION_Z: ComponentType #: 6
    SCALE: ComponentType #: 7
    SCALE_X: ComponentType #: 8
    SCALE_Y: ComponentType #: 9
    SCALE_Z: ComponentType #: 10
    ...

class CopyBoneDeltaMode(EnumBase):
    r"""
    Copy Bone Delta Mode
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_CopyBoneDelta.h
    
    """

    ACCUMULATE: CopyBoneDeltaMode #: 0
    COPY: CopyBoneDeltaMode #: 1
    ...

class BoneRotationSource(EnumBase):
    r"""
    Enum for specifying the source of a bone's rotation.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """

    BRS_KEEP_COMPONENT_SPACE_ROTATION: BoneRotationSource #: 0: Don't change rotation at all.
    BRS_KEEP_LOCAL_SPACE_ROTATION: BoneRotationSource #: 1: Keep forward direction vector relative to the parent bone.
    BRS_COPY_FROM_TARGET: BoneRotationSource #: 2: Copy rotation of target to bone.
    ...

class InterpolationBlend(EnumBase):
    r"""
    Various ways to interpolate TAlphaBlend.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_LookAt.h
    
    """

    LINEAR: InterpolationBlend #: 0
    CUBIC: InterpolationBlend #: 1
    SINUSOIDAL: InterpolationBlend #: 2
    EASE_IN_OUT_EXPONENT2: InterpolationBlend #: 3
    EASE_IN_OUT_EXPONENT3: InterpolationBlend #: 4
    EASE_IN_OUT_EXPONENT4: InterpolationBlend #: 5
    EASE_IN_OUT_EXPONENT5: InterpolationBlend #: 6
    ...

class SimulationSpace(EnumBase):
    r"""
    Determines in what space the simulation should run
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RigidBody.h
    
    """

    COMPONENT_SPACE: SimulationSpace #: 0: Simulate in component space. Moving the entire skeletal mesh will have no affect on velocities
    WORLD_SPACE: SimulationSpace #: 1: Simulate in world space. Moving the skeletal mesh will generate velocity changes
    BASE_BONE_SPACE: SimulationSpace #: 2: Simulate in another bone space. Moving the entire skeletal mesh and individually modifying the base bone will have no affect on velocities
    ...

class SimulationTiming(EnumBase):
    r"""
    Determines behaviour regarding deferral of simulation tasks.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RigidBody.h
    
    """

    DEFAULT: SimulationTiming #: 0: Use the default project setting as defined by p.RigidBodyNode.DeferredSimulationDefault.
    SYNCHRONOUS: SimulationTiming #: 1: Always run the simulation to completion during animation evaluation.
    DEFERRED: SimulationTiming #: 2: Always run the simulation in the background and retrieve the result on the next animation evaluation.
    ...

class SplineBoneAxis(EnumBase):
    r"""
    The different axes we can align our bones to.
    Note that the values are set to match up with EAxis (but without 'None')
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_SplineIK.h
    
    """

    X: SplineBoneAxis #: 1
    Y: SplineBoneAxis #: 2
    Z: SplineBoneAxis #: 3
    ...

class CameraShakePlaySpace(EnumBase):
    r"""
    ECamera Shake Play Space
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraTypes.h
    
    """

    CAMERA_LOCAL: CameraShakePlaySpace #: 0: This anim is applied in camera space.
    WORLD: CameraShakePlaySpace #: 1: This anim is applied in world space.
    USER_DEFINED: CameraShakePlaySpace #: 2: This anim is applied in a user-specified space (defined by UserPlaySpaceMatrix).
    ...

class CameraAnimPlaySpace(EnumBase):
    r"""
    deprecated: 'CameraAnimPlaySpace' was renamed to 'CameraShakePlaySpace'.
    """

    CAMERA_LOCAL: CameraAnimPlaySpace #: 0: This anim is applied in camera space.
    WORLD: CameraAnimPlaySpace #: 1: This anim is applied in world space.
    USER_DEFINED: CameraAnimPlaySpace #: 2: This anim is applied in a user-specified space (defined by UserPlaySpaceMatrix).
    ...

class MaterialParameterAssociation(EnumBase):
    r"""
    EMaterial Parameter Association
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialTypes.h
    
    """

    LAYER_PARAMETER: MaterialParameterAssociation #: 0
    BLEND_PARAMETER: MaterialParameterAssociation #: 1
    GLOBAL_PARAMETER: MaterialParameterAssociation #: 2
    ...

class AspectRatioAxisConstraint(EnumBase):
    r"""
    Enum describing how to constrain perspective view port FOV
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    ASPECT_RATIO_MAINTAIN_YFOV: AspectRatioAxisConstraint #: 0
    ASPECT_RATIO_MAINTAIN_XFOV: AspectRatioAxisConstraint #: 1
    ASPECT_RATIO_MAJOR_AXIS_FOV: AspectRatioAxisConstraint #: 2
    ...

class DesiredImageFormat(EnumBase):
    r"""
    EDesired Image Format
    
    **C++ Source:**
    
    - **Module**: ImageWriteQueue
    - **File**: ImageWriteTypes.h
    
    """

    PNG: DesiredImageFormat #: 0
    JPG: DesiredImageFormat #: 1
    BMP: DesiredImageFormat #: 2
    EXR: DesiredImageFormat #: 3
    ...

class GrassScaling(EnumBase):
    r"""
    EGrass Scaling
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeGrassType.h
    
    """

    UNIFORM: GrassScaling #: 0: Grass instances will have uniform X, Y and Z scales.
    FREE: GrassScaling #: 1: Grass instances will have random X, Y and Z scales.
    LOCK_XY: GrassScaling #: 2: X and Y will be the same random scale, Z will be another
    ...

class ShadowCacheInvalidationBehavior(EnumBase):
    r"""
    Setting to control shadow invalidation behavior (in particular with respect to Virtual Shadow Maps and future methods).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneTypes.h
    
    """

    AUTO: ShadowCacheInvalidationBehavior #: 0: Default. Invalidates based on World Position Offset material, and transform changes, attempting to do the right thing given the information available to the renderer.
    ALWAYS: ShadowCacheInvalidationBehavior #: 1: Always invalidate shadows, can be used to flag a primitive that is using some method of animating that is not known to the system.
    RIGID: ShadowCacheInvalidationBehavior #: 2: Suppresses invalidations that would otherwise be generated by e.g., World Position Offset (WPO). Can be used for example when they use WPO statically used, or the artifacts are subtle enough to not warrant the performace overhead (use with care).
    STATIC: ShadowCacheInvalidationBehavior
    r"""
    3: In addition to "Rigid" behavior, also suppress invalidations due to transform changes. Add/Remove will still trigger invalidations.
    If the primitive is actually moved or animated somehow the visual result is undefined.
    """

    ...

class LandscapeToolTargetType(EnumBase):
    r"""
    ELandscape Tool Target Type
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeEditTypes.h
    
    """

    HEIGHTMAP: LandscapeToolTargetType #: 0
    WEIGHTMAP: LandscapeToolTargetType #: 1
    VISIBILITY: LandscapeToolTargetType #: 2
    ...

class AnimLinkMethod(EnumBase):
    r"""
    Supported types of time for a linked element
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimLinkableElement.h
    
    """

    ABSOLUTE: AnimLinkMethod #: 0: Element stays at a specific time without moving.
    RELATIVE: AnimLinkMethod #: 1: Element moves with its segment, but not when the segment changes size.
    PROPORTIONAL: AnimLinkMethod #: 2: Element moves with its segment and will stay at a certain proportion through the segment.
    ...

class MontageNotifyTickType(EnumBase):
    r"""
    Ticking method for AnimNotifies in AnimMontages.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """

    QUEUED: MontageNotifyTickType #: 0: Queue notifies, and trigger them at the end of the evaluation phase (faster). Not suitable for changing sections or montage position.
    BRANCHING_POINT: MontageNotifyTickType #: 1: Trigger notifies as they are encountered (Slower). Suitable for changing sections or montage position.
    ...

class NotifyFilterType(EnumBase):
    r"""
    Filtering method for deciding whether to trigger a notify.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """

    NO_FILTERING: NotifyFilterType #: 0: No filtering.
    LOD: NotifyFilterType #: 1: Filter By Skeletal Mesh LOD.
    ...

class CameraProjectionMode(EnumBase):
    r"""
    
    TODO:: Document
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraTypes.h
    
    """

    PERSPECTIVE: CameraProjectionMode #: 0
    ORTHOGRAPHIC: CameraProjectionMode #: 1
    ...

class NaniteFallbackTarget(EnumBase):
    r"""
    ENanite Fallback Target
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    AUTO: NaniteFallbackTarget #: 0: Automatic heuristic based on project settings.
    PERCENT_TRIANGLES: NaniteFallbackTarget #: 1: Percentage of triangles to keep from source mesh for fallback.
    RELATIVE_ERROR: NaniteFallbackTarget #: 2: Reduce until the specified error is reached relative to size of the mesh
    ...

class TextureSizingType(EnumBase):
    r"""
    ETexture Sizing Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialMerging.h
    
    """

    TEXTURE_SIZING_TYPE_USE_SINGLE_TEXTURE_SIZE: TextureSizingType #: 0
    TEXTURE_SIZING_TYPE_USE_AUTOMATIC_BIASED_SIZES: TextureSizingType #: 1
    TEXTURE_SIZING_TYPE_USE_MANUAL_OVERRIDE_TEXTURE_SIZE: TextureSizingType #: 2
    TEXTURE_SIZING_TYPE_USE_SIMPLYGON_AUTOMATIC_SIZING: TextureSizingType #: 3
    TEXTURE_SIZING_TYPE_AUTOMATIC_FROM_TEXEL_DENSITY: TextureSizingType #: 4
    TEXTURE_SIZING_TYPE_AUTOMATIC_FROM_MESH_SCREEN_SIZE: TextureSizingType #: 5
    TEXTURE_SIZING_TYPE_AUTOMATIC_FROM_MESH_DRAW_DISTANCE: TextureSizingType #: 6: When working with World Partition HLODs, the draw distance is automatically deduced from the runtime grid loading range.
    ...

class NavLinkDirection(EnumBase):
    r"""
    ENav Link Direction
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavLinkDefinition.h
    
    """

    BOTH_WAYS: NavLinkDirection #: 0
    LEFT_TO_RIGHT: NavLinkDirection #: 1
    RIGHT_TO_LEFT: NavLinkDirection #: 2
    ...

class SmartNavLinkDir(EnumBase):
    r"""
    deprecated: 'SmartNavLinkDir' was renamed to 'NavLinkDirection'.
    """

    BOTH_WAYS: SmartNavLinkDir #: 0
    LEFT_TO_RIGHT: SmartNavLinkDir #: 1
    RIGHT_TO_LEFT: SmartNavLinkDir #: 2
    ...

class AttachLocation(EnumBase):
    r"""
    Deprecated rules for setting transform on attachment, new functions should use FAttachmentTransformRules isntead
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    KEEP_RELATIVE_OFFSET: AttachLocation #: 0: Keeps current relative transform as the relative transform to the new parent.
    KEEP_WORLD_POSITION: AttachLocation #: 1: Automatically calculates the relative transform such that the attached component maintains the same world transform.
    SNAP_TO_TARGET: AttachLocation #: 2: Snaps location and rotation to the attach point. Calculates the relative scale so that the final world scale of the component remains the same.
    SNAP_TO_TARGET_INCLUDING_SCALE: AttachLocation #: 3: Snaps entire transform to target, including scale.
    ...

class AttachLocationType(EnumBase):
    r"""
    deprecated: 'AttachLocationType' was renamed to 'AttachLocation'.
    """

    KEEP_RELATIVE_OFFSET: AttachLocationType #: 0: Keeps current relative transform as the relative transform to the new parent.
    KEEP_WORLD_POSITION: AttachLocationType #: 1: Automatically calculates the relative transform such that the attached component maintains the same world transform.
    SNAP_TO_TARGET: AttachLocationType #: 2: Snaps location and rotation to the attach point. Calculates the relative scale so that the final world scale of the component remains the same.
    SNAP_TO_TARGET_INCLUDING_SCALE: AttachLocationType #: 3: Snaps entire transform to target, including scale.
    ...

class PSCPoolMethod(EnumBase):
    r"""
    EPSCPool Method
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPSCPool.h
    
    """

    NONE: PSCPoolMethod #: 0: PSC is will be created fresh and not allocated from the pool.
    AUTO_RELEASE: PSCPoolMethod
    r"""
    1: PSC is allocated from the pool and will be automatically released back to it.
    User need not handle this any more that other PSCs but interaction with the PSC after the tick it's spawned in are unsafe.
    This method is useful for one-shot fx that you don't need to keep a reference to and can fire and forget.
    """

    MANUAL_RELEASE: PSCPoolMethod
    r"""
    2: PSC is allocated from the pool but will NOT be automatically released back to it. User has ownership of the PSC and must call ReleaseToPool when finished with it otherwise the PSC will leak.
    Interaction with the PSC after it has been released are unsafe.
    This method is useful for persistent FX that you need to modify parameters upon etc over it's lifetime.
    """

    ...

class ViewTargetBlendFunction(EnumBase):
    r"""
    Options that define how to blend when changing view targets.
    see: FViewTargetTransitionParams, SetViewTarget
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerCameraManager.h
    
    """

    VT_BLEND_LINEAR: ViewTargetBlendFunction #: 0: Camera does a simple linear interpolation.
    VT_BLEND_CUBIC: ViewTargetBlendFunction #: 1: Camera has a slight ease in and ease out, but amount of ease cannot be tweaked.
    VT_BLEND_EASE_IN: ViewTargetBlendFunction #: 2: Camera immediately accelerates, but smoothly decelerates into the target.  Ease amount controlled by BlendExp.
    VT_BLEND_EASE_OUT: ViewTargetBlendFunction #: 3: Camera smoothly accelerates, but does not decelerate into the target.  Ease amount controlled by BlendExp.
    VT_BLEND_EASE_IN_OUT: ViewTargetBlendFunction #: 4: Camera smoothly accelerates and decelerates.  Ease amount controlled by BlendExp.
    VT_BLEND_PRE_BLENDED: ViewTargetBlendFunction #: 5: The game's camera system has already performed the blending. Engine should not blend at all
    ...

class SoundSpatializationAlgorithm(EnumBase):
    r"""
    ESound Spatialization Algorithm
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundAttenuation.h
    
    """

    SPATIALIZATION_DEFAULT: SoundSpatializationAlgorithm #: 0: Standard panning method for spatialization (linear or equal power method defined in project settings)
    SPATIALIZATION_HRTF: SoundSpatializationAlgorithm #: 1: Binaural spatialization method if available (requires headphones, enabled by plugins)
    ...

class ModulationParamMode(EnumBase):
    r"""
    Modulation Param Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeModulatorContinuous.h
    
    """

    MPM_NORMAL: ModulationParamMode #: 0: Clamps input value to the range (MinInput, MaxInput) then maps to the range (MinOutput, MaxOutput)
    MPM_ABS: ModulationParamMode #: 1: Same as Normal except that the input value is treated as an absolute value
    MPM_DIRECT: ModulationParamMode #: 2: Use the input value directly without scaling or reference to Min or Max input or output values
    ...

class VolumeLightingMethod(EnumBase):
    r"""
    EVolume Lighting Method
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldSettings.h
    
    """

    VLM_VOLUMETRIC_LIGHTMAP: VolumeLightingMethod
    r"""
    0: Lighting samples are computed in an adaptive grid which covers the entire Lightmass Importance Volume.  Higher density grids are used near geometry.
    The Volumetric Lightmap is interpolated efficiently on the GPU per-pixel, allowing accurate indirect lighting for dynamic objects and volumetric fog.
    Positions outside of the Importance Volume reuse the border texels of the Volumetric Lightmap (clamp addressing).
    On mobile, interpolation is done on the CPU at the center of each object's bounds.
    """

    VLM_SPARSE_VOLUME_LIGHTING_SAMPLES: VolumeLightingMethod
    r"""
    1: Volume lighting samples are placed on top of static surfaces at medium density, and everywhere else in the Lightmass Importance Volume at low density.  Positions outside of the Importance Volume will have no indirect lighting.
    This method requires CPU interpolation so the Indirect Lighting Cache is used to interpolate results for each dynamic object, adding Rendering Thread overhead.
    Volumetric Fog cannot be affected by precomputed lighting with this method.
    """

    ...

class MeshApproximationType(EnumBase):
    r"""
    EMesh Approximation Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    MESH_AND_MATERIALS: MeshApproximationType #: 0
    MESH_SHAPE_ONLY: MeshApproximationType #: 1
    ...

class MeshApproximationBaseCappingType(EnumBase):
    r"""
    EMesh Approximation Base Capping Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    NO_BASE_CAPPING: MeshApproximationBaseCappingType #: 0
    CONVEX_POLYGON: MeshApproximationBaseCappingType #: 1
    CONVEX_SOLID: MeshApproximationBaseCappingType #: 2
    ...

class OccludedGeometryFilteringPolicy(EnumBase):
    r"""
    EOccluded Geometry Filtering Policy
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    NO_OCCLUSION_FILTERING: OccludedGeometryFilteringPolicy #: 0
    VISIBILITY_BASED_FILTERING: OccludedGeometryFilteringPolicy #: 1
    ...

class MeshApproximationSimplificationPolicy(EnumBase):
    r"""
    EMesh Approximation Simplification Policy
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    FIXED_TRIANGLE_COUNT: MeshApproximationSimplificationPolicy #: 0
    TRIANGLES_PER_AREA: MeshApproximationSimplificationPolicy #: 1
    GEOMETRIC_TOLERANCE: MeshApproximationSimplificationPolicy #: 2
    ...

class MeshApproximationGroundPlaneClippingPolicy(EnumBase):
    r"""
    EMesh Approximation Ground Plane Clipping Policy
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    NO_GROUND_CLIPPING: MeshApproximationGroundPlaneClippingPolicy #: 0
    DISCARD_WITH_Z_PLANE: MeshApproximationGroundPlaneClippingPolicy #: 1
    CUT_WITH_Z_PLANE: MeshApproximationGroundPlaneClippingPolicy #: 2
    CUT_AND_FILL_WITH_Z_PLANE: MeshApproximationGroundPlaneClippingPolicy #: 3
    ...

class MeshApproximationUVGenerationPolicy(EnumBase):
    r"""
    EMesh Approximation UVGeneration Policy
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    PREFER_UV_ATLAS: MeshApproximationUVGenerationPolicy #: 0
    PREFER_X_ATLAS: MeshApproximationUVGenerationPolicy #: 1
    PREFER_PATCH_BUILDER: MeshApproximationUVGenerationPolicy #: 2
    ...

class UVOutput(EnumBase):
    r"""
    As UHT doesnt allow arrays of bools, we need this binary enum :(
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    DO_NOT_OUTPUT_CHANNEL: UVOutput #: 0
    OUTPUT_CHANNEL: UVOutput #: 1
    ...

class MeshLODSelectionType(EnumBase):
    r"""
    EMesh LODSelection Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    ALL_LO_DS: MeshLODSelectionType #: 0: Whether or not to export all of the LODs found in the source meshes
    SPECIFIC_LOD: MeshLODSelectionType #: 1: Whether or not to export all of the LODs found in the source meshes
    CALCULATE_LOD: MeshLODSelectionType #: 2: Whether or not to calculate the appropriate LOD model for the given screen size
    LOWEST_DETAIL_LOD: MeshLODSelectionType #: 3: Whether or not to use the lowest-detail LOD
    ...

class ProxyNormalComputationMethod(EnumBase):
    r"""
    EProxy Normal Computation Method
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    ANGLE_WEIGHTED: ProxyNormalComputationMethod #: 0
    AREA_WEIGHTED: ProxyNormalComputationMethod #: 1
    EQUAL_WEIGHTED: ProxyNormalComputationMethod #: 2
    ...

class LandscapeCullingPrecision(EnumBase):
    r"""
    ELandscape Culling Precision
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    HIGH: LandscapeCullingPrecision #: 0
    MEDIUM: LandscapeCullingPrecision #: 1
    LOW: LandscapeCullingPrecision #: 2
    ...

class MontageBlendMode(EnumBase):
    r"""
    EMontage Blend Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimMontage.h
    
    """

    STANDARD: MontageBlendMode #: 0: Uses standard weight based blend
    INERTIALIZATION: MontageBlendMode #: 1: Uses inertialization. Requires an inertialization node somewhere in the graph after any slot node used by this montage.
    ...

class EvaluatorDataSource(EnumBase):
    r"""
    Indicates which state is being evaluated by this node (source or destination).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_TransitionPoseEvaluator.h
    
    """

    EDS_SOURCE_POSE: EvaluatorDataSource #: 0
    EDS_DESTINATION_POSE: EvaluatorDataSource #: 1
    ...

class EvaluatorMode(EnumBase):
    r"""
    Determines the behavior this node will use when updating and evaluating.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_TransitionPoseEvaluator.h
    
    """

    EM_STANDARD: EvaluatorMode #: 0: DataSource is ticked and evaluated every frame.
    EM_FREEZE: EvaluatorMode #: 1: DataSource is never ticked and only evaluated on the first frame. Every frame after uses the cached pose from the first frame.
    EM_DELAYED_FREEZE: EvaluatorMode #: 2: DataSource is ticked and evaluated for a given number of frames, then freezes after and uses the cached pose for future frames.
    ...

class MirrorRowType(EnumBase):
    r"""
    Type referenced by a row in the mirror data table
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MirrorDataTable.h
    
    """

    BONE: MirrorRowType #: 0
    ANIMATION_NOTIFY: MirrorRowType #: 1
    CURVE: MirrorRowType #: 2
    SYNC_MARKER: MirrorRowType #: 3
    CUSTOM: MirrorRowType #: 4
    ...

class MeshFeatureImportance(EnumBase):
    r"""
    The importance of a mesh feature when automatically generating mesh LODs.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    OFF: MeshFeatureImportance #: 0
    LOWEST: MeshFeatureImportance #: 1
    LOW: MeshFeatureImportance #: 2
    NORMAL: MeshFeatureImportance #: 3
    HIGH: MeshFeatureImportance #: 4
    HIGHEST: MeshFeatureImportance #: 5
    ...

class StaticMeshReductionTerimationCriterion(EnumBase):
    r"""
    Enum specifying the reduction type to use when simplifying static meshes with the engines internal tool
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    """

    TRIANGLES: StaticMeshReductionTerimationCriterion #: 0: Triangle percent criterion will be used for simplification.
    VERTICES: StaticMeshReductionTerimationCriterion #: 1: Vertice percent criterion will be used for simplification.
    ANY: StaticMeshReductionTerimationCriterion #: 2: Simplification will continue until either Triangle or Vertex count criteria is met.
    ...

class AudioOutputTarget(EnumBase):
    r"""
    EAudio Output Target
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioOutputTarget.h
    
    """

    SPEAKER: AudioOutputTarget #: 0: Sound plays only from speakers.
    CONTROLLER: AudioOutputTarget #: 1: Sound plays only from controller if present.
    CONTROLLER_FALLBACK_TO_SPEAKER: AudioOutputTarget #: 2: Sound plays on the controller if present. If not present, it plays from speakers.
    ...

class SoundWaveLoadingBehavior(EnumBase):
    r"""
    Only used when stream caching is enabled. Determines how we are going to load or retain a given audio asset.
    A USoundWave's loading behavior can be overridden in the USoundWave itself, the sound wave's USoundClass, or by cvars.
    The order of priority is defined as:
    1) The loading behavior set on the USoundWave
    2) The loading behavior set on the USoundWave's USoundClass.
    3) The loading behavior set on the nearest parent of a USoundWave's USoundClass.
    4) The loading behavior set via the au.streamcache cvars.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundWaveLoadingBehavior.h
    
    """

    INHERITED: SoundWaveLoadingBehavior #: 0: If set on a USoundWave, use the setting defined by the USoundClass. If set on the next parent USoundClass, or the default behavior defined via the au.streamcache cvars.
    RETAIN_ON_LOAD: SoundWaveLoadingBehavior #: 1: the first chunk of audio for this asset will be retained in the audio cache until a given USoundWave is either destroyed or USoundWave::ReleaseCompressedAudioData is called.
    PRIME_ON_LOAD: SoundWaveLoadingBehavior #: 2: the first chunk of audio for this asset will be loaded into the cache from disk when this asset is loaded, but may be evicted to make room for other audio if it isn't played for a while.
    LOAD_ON_DEMAND: SoundWaveLoadingBehavior #: 3: the first chunk of audio for this asset will not be loaded until this asset is played or primed.
    FORCE_INLINE: SoundWaveLoadingBehavior #: 4: Force all audio data for this audio asset to live outside of the cache and use the non-streaming decode pathways. Only usable if set on the USoundWave.
    ...

class MaxConcurrentResolutionRule(EnumBase):
    r"""
    EMax Concurrent Resolution Rule
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundConcurrency.h
    
    """

    PREVENT_NEW: MaxConcurrentResolutionRule #: 0: When Max Concurrent sounds are active do not start a new sound.
    STOP_OLDEST: MaxConcurrentResolutionRule #: 1: When Max Concurrent sounds are active stop the oldest and start a new one.
    STOP_FARTHEST_THEN_PREVENT_NEW: MaxConcurrentResolutionRule #: 2: When Max Concurrent sounds are active stop the furthest sound.  If all sounds are the same distance then do not start a new sound.
    STOP_FARTHEST_THEN_OLDEST: MaxConcurrentResolutionRule #: 3: When Max Concurrent sounds are active stop the furthest sound.  If all sounds are the same distance then stop the oldest.
    STOP_LOWEST_PRIORITY: MaxConcurrentResolutionRule #: 4: Stop the lowest priority sound in the group. If all sounds are the same priority, then it will stop the oldest sound in the group.
    STOP_QUIETEST: MaxConcurrentResolutionRule #: 5: Stop the sound that is quietest in the group.
    STOP_LOWEST_PRIORITY_THEN_PREVENT_NEW: MaxConcurrentResolutionRule #: 6: Stop the lowest priority sound in the group. If all sounds are the same priority, then it won't play a new sound.
    ...

class ConcurrencyVolumeScaleMode(EnumBase):
    r"""
    EConcurrency Volume Scale Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundConcurrency.h
    
    """

    DEFAULT: ConcurrencyVolumeScaleMode #: 0: Scales volume of older sounds more than newer sounds (default)
    DISTANCE: ConcurrencyVolumeScaleMode #: 1: Scales distant sounds by volume scalar more than closer sounds
    PRIORITY: ConcurrencyVolumeScaleMode #: 2: Scales lower priority sounds by volume scalar more than closer sounds
    ...

class TextureSourceEncoding(EnumBase):
    r"""
    List of (advanced) texture source encodings, matching the list in ColorManagementDefines.h.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    TSE_NONE: TextureSourceEncoding #: 0: The source encoding is not overridden.
    TSE_LINEAR: TextureSourceEncoding #: 1: The source encoding is considered linear (before optional sRGB encoding is applied).
    TSE_S_RGB: TextureSourceEncoding #: 2: sRGB source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_ST2084: TextureSourceEncoding #: 3: SMPTE ST 2084/PQ source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_GAMMA22: TextureSourceEncoding #: 4: Gamma 2.2 source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_BT1886: TextureSourceEncoding #: 5: BT1886/Gamma 2.4 source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_GAMMA26: TextureSourceEncoding #: 6: Gamma 2.6 source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_CINEON: TextureSourceEncoding #: 7: Cineon source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_RED_LOG: TextureSourceEncoding #: 8: RED Log source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_RED_LOG3G10: TextureSourceEncoding #: 9: RED Log3G10 source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_S_LOG1: TextureSourceEncoding #: 10: Sony SLog1 source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_S_LOG2: TextureSourceEncoding #: 11: Sony SLog2 source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_S_LOG3: TextureSourceEncoding #: 12: Sony SLog3 source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_ALEXA_V3_LOG_C: TextureSourceEncoding #: 13: ARRI Alexa V3 LogC source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_CANON_LOG: TextureSourceEncoding #: 14: Canon Log source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_PRO_TUNE: TextureSourceEncoding #: 15: GoPro ProTune source encoding to be linearized (before optional sRGB encoding is applied).
    TSE_V_LOG: TextureSourceEncoding #: 16: Panasonic V-Log source encoding to be linearized (before optional sRGB encoding is applied).
    ...

class TextureColorSpace(EnumBase):
    r"""
    List of (source) texture color spaces, matching the list in ColorManagementDefines.h.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    TCS_NONE: TextureColorSpace #: 0: No explicit color space definition.
    TCS_S_RGB: TextureColorSpace #: 1: sRGB / Rec709 (BT.709) color primaries, with D65 white point.
    TCS_REC2020: TextureColorSpace #: 2: Rec2020 (BT.2020) primaries with D65 white point.
    TCS_ACESAP0: TextureColorSpace #: 3: ACES AP0 wide gamut primaries, with D60 white point.
    TCS_ACESAP1: TextureColorSpace #: 4: ACES AP1 / ACEScg wide gamut primaries, with D60 white point.
    TCS_P3DCI: TextureColorSpace #: 5: P3 (Theater) primaries, with DCI Calibration white point.
    TCS_P3D65: TextureColorSpace #: 6: P3 (Display) primaries, with D65 white point.
    TCS_RED_WIDE_GAMUT: TextureColorSpace #: 7: RED Wide Gamut primaries, with D65 white point.
    TCS_SONY_S_GAMUT3: TextureColorSpace #: 8: Sony S-Gamut/S-Gamut3 primaries, with D65 white point.
    TCS_SONY_S_GAMUT3_CINE: TextureColorSpace #: 9: Sony S-Gamut3 Cine primaries, with D65 white point.
    TCS_ALEXA_WIDE_GAMUT: TextureColorSpace #: 10: Alexa Wide Gamut primaries, with D65 white point.
    TCS_CANON_CINEMA_GAMUT: TextureColorSpace #: 11: Canon Cinema Gamut primaries, with D65 white point.
    TCS_GO_PRO_PROTUNE_NATIVE: TextureColorSpace #: 12: GoPro Protune Native primaries, with D65 white point.
    TCS_PANASONIC_V_GAMUT: TextureColorSpace #: 13: Panasonic V-Gamut primaries, with D65 white point.
    TCS_CUSTOM: TextureColorSpace #: 99: User defined color space and white point.
    ...

class TextureChromaticAdaptationMethod(EnumBase):
    r"""
    List of chromatic adaptation methods, matching the list in ColorManagementDefines.h.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    TCAM_NONE: TextureChromaticAdaptationMethod #: 0: No chromatic adaptation is applied.
    TCAM_BRADFORD: TextureChromaticAdaptationMethod #: 1: Chromatic adaptation is applied using the Bradford method.
    TCAM_CAT02: TextureChromaticAdaptationMethod #: 2: Chromatic adaptation is applied using the CAT02 method.
    ...

class TextureFilter(EnumBase):
    r"""
    Texture Filter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    TF_NEAREST: TextureFilter #: 0
    TF_BILINEAR: TextureFilter #: 1
    TF_TRILINEAR: TextureFilter #: 2
    TF_DEFAULT: TextureFilter #: 3: Use setting from the Texture Group.
    ...

class TextureAddress(EnumBase):
    r"""
    Texture Address
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    TA_WRAP: TextureAddress #: 0
    TA_CLAMP: TextureAddress #: 1
    TA_MIRROR: TextureAddress #: 2
    ...

class DatasmithImportLightmapMin(EnumBase):
    r"""
    EDatasmith Import Lightmap Min
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    """

    LIGHTMAP_16: DatasmithImportLightmapMin #: 0
    LIGHTMAP_32: DatasmithImportLightmapMin #: 1
    LIGHTMAP_64: DatasmithImportLightmapMin #: 2
    LIGHTMAP_128: DatasmithImportLightmapMin #: 3
    LIGHTMAP_256: DatasmithImportLightmapMin #: 4
    LIGHTMAP_512: DatasmithImportLightmapMin #: 5
    ...

class DatasmithImportLightmapMax(EnumBase):
    r"""
    EDatasmith Import Lightmap Max
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    """

    LIGHTMAP_64: DatasmithImportLightmapMax #: 0
    LIGHTMAP_128: DatasmithImportLightmapMax #: 1
    LIGHTMAP_256: DatasmithImportLightmapMax #: 2
    LIGHTMAP_512: DatasmithImportLightmapMax #: 3
    LIGHTMAP_1024: DatasmithImportLightmapMax #: 4
    LIGHTMAP_2048: DatasmithImportLightmapMax #: 5
    LIGHTMAP_4096: DatasmithImportLightmapMax #: 6
    ...

class DatasmithImportScene(EnumBase):
    r"""
    EDatasmith Import Scene
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    """

    NEW_LEVEL: DatasmithImportScene #: 0: Create a new Level and spawn the actors after the import.
    CURRENT_LEVEL: DatasmithImportScene #: 1: Use the current Level to spawn the actors after the import.
    ASSETS_ONLY: DatasmithImportScene #: 2: Do not modify the Level after import. No actor will be created (including the Blueprint if requested by the ImportHierarchy
    ...

class DatasmithCADStitchingTechnique(EnumBase):
    r"""
    EDatasmith CADStitching Technique
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    """

    STITCHING_NONE: DatasmithCADStitchingTechnique #: 0
    STITCHING_HEAL: DatasmithCADStitchingTechnique #: 1
    STITCHING_SEW: DatasmithCADStitchingTechnique #: 2
    ...

class DatasmithCADRetessellationRule(EnumBase):
    r"""
    EDatasmith CADRetessellation Rule
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    """

    ALL: DatasmithCADRetessellationRule #: 0
    SKIP_DELETED_SURFACES: DatasmithCADRetessellationRule #: 1
    ...

class EulerRotationOrder(EnumBase):
    r"""
    EEuler Rotation Order
    
    **C++ Source:**
    
    - **Module**: AnimationCore
    - **File**: EulerTransform.h
    
    """

    XYZ: EulerRotationOrder #: 0
    XZY: EulerRotationOrder #: 1
    YXZ: EulerRotationOrder #: 2
    YZX: EulerRotationOrder #: 3
    ZXY: EulerRotationOrder #: 4
    ZYX: EulerRotationOrder #: 5
    ...

class ControlRigRotationOrder(EnumBase):
    r"""
    deprecated: 'ControlRigRotationOrder' was renamed to 'EulerRotationOrder'.
    """

    XYZ: ControlRigRotationOrder #: 0
    XZY: ControlRigRotationOrder #: 1
    YXZ: ControlRigRotationOrder #: 2
    YZX: ControlRigRotationOrder #: 3
    ZXY: ControlRigRotationOrder #: 4
    ZYX: ControlRigRotationOrder #: 5
    ...

class RigVMAnimEasingType(EnumBase):
    r"""
    ERig VMAnim Easing Type
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMMathLibrary.h
    
    """

    LINEAR: RigVMAnimEasingType #: 0
    QUADRATIC_EASE_IN: RigVMAnimEasingType #: 1
    QUADRATIC_EASE_OUT: RigVMAnimEasingType #: 2
    QUADRATIC_EASE_IN_OUT: RigVMAnimEasingType #: 3
    CUBIC_EASE_IN: RigVMAnimEasingType #: 4
    CUBIC_EASE_OUT: RigVMAnimEasingType #: 5
    CUBIC_EASE_IN_OUT: RigVMAnimEasingType #: 6
    QUARTIC_EASE_IN: RigVMAnimEasingType #: 7
    QUARTIC_EASE_OUT: RigVMAnimEasingType #: 8
    QUARTIC_EASE_IN_OUT: RigVMAnimEasingType #: 9
    QUINTIC_EASE_IN: RigVMAnimEasingType #: 10
    QUINTIC_EASE_OUT: RigVMAnimEasingType #: 11
    QUINTIC_EASE_IN_OUT: RigVMAnimEasingType #: 12
    SINE_EASE_IN: RigVMAnimEasingType #: 13
    SINE_EASE_OUT: RigVMAnimEasingType #: 14
    SINE_EASE_IN_OUT: RigVMAnimEasingType #: 15
    CIRCULAR_EASE_IN: RigVMAnimEasingType #: 16
    CIRCULAR_EASE_OUT: RigVMAnimEasingType #: 17
    CIRCULAR_EASE_IN_OUT: RigVMAnimEasingType #: 18
    EXPONENTIAL_EASE_IN: RigVMAnimEasingType #: 19
    EXPONENTIAL_EASE_OUT: RigVMAnimEasingType #: 20
    EXPONENTIAL_EASE_IN_OUT: RigVMAnimEasingType #: 21
    ELASTIC_EASE_IN: RigVMAnimEasingType #: 22
    ELASTIC_EASE_OUT: RigVMAnimEasingType #: 23
    ELASTIC_EASE_IN_OUT: RigVMAnimEasingType #: 24
    BACK_EASE_IN: RigVMAnimEasingType #: 25
    BACK_EASE_OUT: RigVMAnimEasingType #: 26
    BACK_EASE_IN_OUT: RigVMAnimEasingType #: 27
    BOUNCE_EASE_IN: RigVMAnimEasingType #: 28
    BOUNCE_EASE_OUT: RigVMAnimEasingType #: 29
    BOUNCE_EASE_IN_OUT: RigVMAnimEasingType #: 30
    ...

class ControlRigAnimEasingType(EnumBase):
    r"""
    deprecated: 'ControlRigAnimEasingType' was renamed to 'RigVMAnimEasingType'.
    """

    LINEAR: ControlRigAnimEasingType #: 0
    QUADRATIC_EASE_IN: ControlRigAnimEasingType #: 1
    QUADRATIC_EASE_OUT: ControlRigAnimEasingType #: 2
    QUADRATIC_EASE_IN_OUT: ControlRigAnimEasingType #: 3
    CUBIC_EASE_IN: ControlRigAnimEasingType #: 4
    CUBIC_EASE_OUT: ControlRigAnimEasingType #: 5
    CUBIC_EASE_IN_OUT: ControlRigAnimEasingType #: 6
    QUARTIC_EASE_IN: ControlRigAnimEasingType #: 7
    QUARTIC_EASE_OUT: ControlRigAnimEasingType #: 8
    QUARTIC_EASE_IN_OUT: ControlRigAnimEasingType #: 9
    QUINTIC_EASE_IN: ControlRigAnimEasingType #: 10
    QUINTIC_EASE_OUT: ControlRigAnimEasingType #: 11
    QUINTIC_EASE_IN_OUT: ControlRigAnimEasingType #: 12
    SINE_EASE_IN: ControlRigAnimEasingType #: 13
    SINE_EASE_OUT: ControlRigAnimEasingType #: 14
    SINE_EASE_IN_OUT: ControlRigAnimEasingType #: 15
    CIRCULAR_EASE_IN: ControlRigAnimEasingType #: 16
    CIRCULAR_EASE_OUT: ControlRigAnimEasingType #: 17
    CIRCULAR_EASE_IN_OUT: ControlRigAnimEasingType #: 18
    EXPONENTIAL_EASE_IN: ControlRigAnimEasingType #: 19
    EXPONENTIAL_EASE_OUT: ControlRigAnimEasingType #: 20
    EXPONENTIAL_EASE_IN_OUT: ControlRigAnimEasingType #: 21
    ELASTIC_EASE_IN: ControlRigAnimEasingType #: 22
    ELASTIC_EASE_OUT: ControlRigAnimEasingType #: 23
    ELASTIC_EASE_IN_OUT: ControlRigAnimEasingType #: 24
    BACK_EASE_IN: ControlRigAnimEasingType #: 25
    BACK_EASE_OUT: ControlRigAnimEasingType #: 26
    BACK_EASE_IN_OUT: ControlRigAnimEasingType #: 27
    BOUNCE_EASE_IN: ControlRigAnimEasingType #: 28
    BOUNCE_EASE_OUT: ControlRigAnimEasingType #: 29
    BOUNCE_EASE_IN_OUT: ControlRigAnimEasingType #: 30
    ...

class RigUnitDebugPointMode(EnumBase):
    r"""
    ERig Unit Debug Point Mode
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugPoint.h
    
    """

    POINT: RigUnitDebugPointMode #: 0: Draw as point
    VECTOR: RigUnitDebugPointMode #: 1: Draw as vector
    ...

class RigUnitDebugTransformMode(EnumBase):
    r"""
    ERig Unit Debug Transform Mode
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugTransform.h
    
    """

    POINT: RigUnitDebugTransformMode #: 0: Draw as point
    AXES: RigUnitDebugTransformMode #: 1: Draw as axes
    BOX: RigUnitDebugTransformMode #: 2: Draw as box
    ...

class RigUnitVisualDebugPointMode(EnumBase):
    r"""
    ERig Unit Visual Debug Point Mode
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_VisualDebug.h
    
    """

    POINT: RigUnitVisualDebugPointMode #: 0: Draw as point
    VECTOR: RigUnitVisualDebugPointMode #: 1: Draw as vector
    ...

class RBFQuatDistanceType(EnumBase):
    r"""
    Function to use for computing distance between the input and target
          quaternions.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    """

    EUCLIDEAN: RBFQuatDistanceType #: 0
    ARC_LENGTH: RBFQuatDistanceType #: 1
    SWING_ANGLE: RBFQuatDistanceType #: 2
    TWIST_ANGLE: RBFQuatDistanceType #: 3
    ...

class RBFKernelType(EnumBase):
    r"""
    Function to use for each target falloff
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    """

    GAUSSIAN: RBFKernelType #: 0
    EXPONENTIAL: RBFKernelType #: 1
    LINEAR: RBFKernelType #: 2
    CUBIC: RBFKernelType #: 3
    QUINTIC: RBFKernelType #: 4
    ...

class RBFVectorDistanceType(EnumBase):
    r"""
    Function to use for computing distance between the input and target
          quaternions.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    """

    EUCLIDEAN: RBFVectorDistanceType #: 0
    MANHATTAN: RBFVectorDistanceType #: 1
    ARC_LENGTH: RBFVectorDistanceType #: 2
    ...

class RigVMTransformSpace(EnumBase):
    r"""
    ERig VMTransform Space
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunctionDefines.h
    
    """

    LOCAL_SPACE: RigVMTransformSpace #: 0: Apply in parent space
    GLOBAL_SPACE: RigVMTransformSpace #: 1: Apply in rig space
    ...

class BoneGetterSetterMode(EnumBase):
    r"""
    deprecated: 'BoneGetterSetterMode' was renamed to 'RigVMTransformSpace'.
    """

    LOCAL_SPACE: BoneGetterSetterMode #: 0: Apply in parent space
    GLOBAL_SPACE: BoneGetterSetterMode #: 1: Apply in rig space
    ...

class RigVMClampSpatialMode(EnumBase):
    r"""
    ERig VMClamp Spatial Mode
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunctionDefines.h
    
    """

    PLANE: RigVMClampSpatialMode #: 0
    CYLINDER: RigVMClampSpatialMode #: 1
    SPHERE: RigVMClampSpatialMode #: 2
    CAPSULE: RigVMClampSpatialMode #: 3
    ...

class ControlRigClampSpatialMode(EnumBase):
    r"""
    deprecated: 'ControlRigClampSpatialMode' was renamed to 'RigVMClampSpatialMode'.
    """

    PLANE: ControlRigClampSpatialMode #: 0
    CYLINDER: ControlRigClampSpatialMode #: 1
    SPHERE: ControlRigClampSpatialMode #: 2
    CAPSULE: ControlRigClampSpatialMode #: 3
    ...

class ControlRigComponentMapDirection(EnumBase):
    r"""
    Enum for controlling how an element should be mapped.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigComponent.h
    
    """

    INPUT: ControlRigComponentMapDirection #: 0
    OUTPUT: ControlRigComponentMapDirection #: 1: An input driving a rig element
    ...

class ControlRigComponentSpace(EnumBase):
    r"""
    Enum for controlling which space a transform is applied in.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigComponent.h
    
    """

    WORLD_SPACE: ControlRigComponentSpace #: 0: World space transform
    ACTOR_SPACE: ControlRigComponentSpace #: 1: The space below the actor's root transform
    COMPONENT_SPACE: ControlRigComponentSpace #: 2: The space defined by the Control Rig Component
    RIG_SPACE: ControlRigComponentSpace
    r"""
    3: The space within the rig. Currently the same as Component Space.
    Inside of control rig this is called 'Global Space'.
    """

    LOCAL_SPACE: ControlRigComponentSpace #: 4: The space defined by each element's parent (bone, control etc)
    ...

class CRSimSoftCollisionType(EnumBase):
    r"""
    ECRSim Soft Collision Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: CRSimSoftCollision.h
    
    """

    PLANE: CRSimSoftCollisionType #: 0
    SPHERE: CRSimSoftCollisionType #: 1
    CONE: CRSimSoftCollisionType #: 2
    ...

class CRSimPointForceType(EnumBase):
    r"""
    ECRSim Point Force Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: CRSimPointForce.h
    
    """

    DIRECTION: CRSimPointForceType #: 0
    ...

class AimMode(EnumBase):
    r"""
    ENUM: Aim Mode (Default: Aim At Target Transform )  # How to perform an aim
    Aim At Target Transforms
    Orient To Target Transforms
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimConstraint.h
    
    """

    AIM_AT_TARGET: AimMode #: 0: Aim at Target Transform
    ORIENT_TO_TARGET: AimMode #: 1: Orient to Target Transform
    ...

class ApplyTransformMode(EnumBase):
    r"""
    EApply Transform Mode
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ApplyFK.h
    
    """

    OVERRIDE: ApplyTransformMode #: 0: Override existing motion
    ADDITIVE: ApplyTransformMode #: 1: Additive to existing motion
    ...

class TransformSpaceMode(EnumBase):
    r"""
    #define DECLARE_SCOPE_HIERARCHICAL_COUNTER_RIGUNIT() \
           DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigDefines.h
    
    """

    LOCAL_SPACE: TransformSpaceMode #: 0: Apply in parent space
    GLOBAL_SPACE: TransformSpaceMode #: 1: Apply in rig space
    BASE_SPACE: TransformSpaceMode #: 2: Apply in Base space
    BASE_JOINT: TransformSpaceMode #: 3: Apply in base bone
    ...

class TransformGetterType(EnumBase):
    r"""
    ETransform Getter Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigDefines.h
    
    """

    INITIAL: TransformGetterType #: 0
    CURRENT: TransformGetterType #: 1
    ...

class RigSwitchParentMode(EnumBase):
    r"""
    ERig Switch Parent Mode
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    """

    WORLD: RigSwitchParentMode #: 0: Switches the element to be parented to the world
    DEFAULT_PARENT: RigSwitchParentMode #: 1: Switches back to the original / default parent
    PARENT_ITEM: RigSwitchParentMode #: 2: Switches the child to the provided parent item
    ...

class RigEvent(EnumBase):
    r"""
    ERig Event
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """

    NONE: RigEvent #: 0: Invalid event
    REQUEST_AUTO_KEY: RigEvent #: 1: Request to Auto-Key the Control in Sequencer
    OPEN_UNDO_BRACKET: RigEvent #: 2: Request to open an Undo bracket in the client
    CLOSE_UNDO_BRACKET: RigEvent #: 3: Request to close an Undo bracket in the client
    ...

class ControlRigVectorKind(EnumBase):
    r"""
    EControl Rig Vector Kind
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_HighlevelBase.h
    
    """

    DIRECTION: ControlRigVectorKind #: 0
    LOCATION: ControlRigVectorKind #: 1
    ...

class ControlRigCurveAlignment(EnumBase):
    r"""
    EControl Rig Curve Alignment
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_FitChainToCurve.h
    
    """

    FRONT: ControlRigCurveAlignment #: 0
    STRETCHED: ControlRigCurveAlignment #: 1
    ...

class ControlRigModifyBoneMode(EnumBase):
    r"""
    EControl Rig Modify Bone Mode
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ModifyTransforms.h
    
    """

    OVERRIDE_LOCAL: ControlRigModifyBoneMode #: 0: Override existing local transform
    OVERRIDE_GLOBAL: ControlRigModifyBoneMode #: 1: Override existing global transform
    ADDITIVE_LOCAL: ControlRigModifyBoneMode
    r"""
    2: Additive to existing local transform.
    Input transform is added within the bone's space.
    """

    ADDITIVE_GLOBAL: ControlRigModifyBoneMode
    r"""
    3: Additive to existing global transform.
    Input transform is added as a global offset in the root of the hierarchy.
    """

    ...

class RigVMSimPointIntegrateType(EnumBase):
    r"""
    ERig VMSim Point Integrate Type
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMMathLibrary.h
    
    """

    VERLET: RigVMSimPointIntegrateType #: 0
    SEMI_EXPLICIT_EULER: RigVMSimPointIntegrateType #: 1
    ...

class CRSimPointIntegrateType(EnumBase):
    r"""
    deprecated: 'CRSimPointIntegrateType' was renamed to 'RigVMSimPointIntegrateType'.
    """

    VERLET: CRSimPointIntegrateType #: 0
    SEMI_EXPLICIT_EULER: CRSimPointIntegrateType #: 1
    ...

class PoleVectorOption(EnumBase):
    r"""
    EPole Vector Option
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: FullBodyIK
    - **File**: FBIKConstraintOption.h
    
    """

    DIRECTION: PoleVectorOption #: 0
    LOCATION: PoleVectorOption #: 1: The polevector will indicate a direction vector in their local bone space
    ...

class PythonLogOutputType(EnumBase):
    r"""
    Types of log output that Python can give.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PythonScriptTypes.h
    
    """

    INFO: PythonLogOutputType #: 0: This log was informative.
    WARNING: PythonLogOutputType #: 1: This log was a warning.
    ERROR: PythonLogOutputType #: 2: This log was an error.
    ...

class TypedElementSelectionMethod(EnumBase):
    r"""
    ETyped Element Selection Method
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementSelectionInterface.h
    
    """

    PRIMARY: TypedElementSelectionMethod #: 0: Select the "primary" element (eg, a component would favor selecting its owner actor)
    SECONDARY: TypedElementSelectionMethod #: 1: Select the "secondary" element (eg, a component would favor selecting itself)
    ...

class TwoPlayerSplitScreenType(EnumBase):
    r"""
    Ways the screen can be split with two players.
    
    **C++ Source:**
    
    - **Module**: EngineSettings
    - **File**: GameMapsSettings.h
    
    """

    HORIZONTAL: TwoPlayerSplitScreenType #: 0
    VERTICAL: TwoPlayerSplitScreenType #: 1
    ...

class ThreePlayerSplitScreenType(EnumBase):
    r"""
    Ways the screen can be split with three players.
    
    **C++ Source:**
    
    - **Module**: EngineSettings
    - **File**: GameMapsSettings.h
    
    """

    FAVOR_TOP: ThreePlayerSplitScreenType #: 0
    FAVOR_BOTTOM: ThreePlayerSplitScreenType #: 1
    VERTICAL: ThreePlayerSplitScreenType #: 2
    HORIZONTAL: ThreePlayerSplitScreenType #: 3
    ...

class FourPlayerSplitScreenType(EnumBase):
    r"""
    EFour Player Split Screen Type
    
    **C++ Source:**
    
    - **Module**: EngineSettings
    - **File**: GameMapsSettings.h
    
    """

    GRID: FourPlayerSplitScreenType #: 0
    VERTICAL: FourPlayerSplitScreenType #: 1
    HORIZONTAL: FourPlayerSplitScreenType #: 2
    ...

class FrictionCombineMode(EnumBase):
    r"""
    EFriction Combine Mode
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: PhysicsSettingsEnums.h
    
    """

    AVERAGE: FrictionCombineMode #: 0: Uses the average value of the materials touching: (a+b)/2
    MIN: FrictionCombineMode #: 1: Uses the minimum value of the materials touching: min(a,b)
    MULTIPLY: FrictionCombineMode #: 2: Uses the product of the values of the materials touching: a*b
    MAX: FrictionCombineMode #: 3: Uses the maximum value of materials touching: max(a,b)
    ...

class PhysicalMaterialSoftCollisionMode(EnumBase):
    r"""
    Soft collision mode for a physical material.
    
    NOTE: Must match EChaosPhysicsMaterialSoftCollisionMode
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: PhysicalMaterial.h
    
    """

    NONE: PhysicalMaterialSoftCollisionMode #: 0: No soft collisionss
    RELATIVE_THICKNESS: PhysicalMaterialSoftCollisionMode #: 1: SoftCollisionThickess is a fraction of the bounds (minimum axis). Should be less than 0.5
    ABSOLUTE_THICKESS: PhysicalMaterialSoftCollisionMode #: 2: SoftCollisionThickess is an absolute value in cm
    ...

class ReimportStrategyFlags(EnumBase):
    r"""
    namespace UE::Interchange
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeFactoryBaseNode.h
    
    """

    APPLY_NO_PROPERTIES: ReimportStrategyFlags #: 0: Do not apply any properties when reimporting. Simply change the source data
    APPLY_PIPELINE_PROPERTIES: ReimportStrategyFlags #: 1: Always apply all properties specified by the pipeline.
    APPLY_EDITOR_CHANGED_PROPERTIES: ReimportStrategyFlags #: 2: Always apply all properties specified by the pipeline, but leave the properties that were modified in the editor since the last import.
    ...

class PropertyPathTestEnum(EnumBase):
    r"""
    EProperty Path Test Enum
    
    **C++ Source:**
    
    - **Module**: PropertyPath
    - **File**: PropertyPathHelpersTest.h
    
    """

    ONE: PropertyPathTestEnum #: 0
    TWO: PropertyPathTestEnum #: 1
    THREE: PropertyPathTestEnum #: 2
    FOUR: PropertyPathTestEnum #: 3
    ...

class MovieSceneCaptureProtocolState(EnumBase):
    r"""
    EMovie Scene Capture Protocol State
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: MovieSceneCaptureProtocolBase.h
    
    """

    IDLE: MovieSceneCaptureProtocolState #: 0: The protocol is idle, and has not even been initialized
    INITIALIZED: MovieSceneCaptureProtocolState #: 1: The protocol has been initialized (and bound to a viewport) but is not capturing frames yet
    CAPTURING: MovieSceneCaptureProtocolState #: 2: The protocol has been initialized, bound to a viewport and is capturing data
    FINALIZING: MovieSceneCaptureProtocolState #: 3: The protocol has finished capturing data, and is pending finalization
    ...

class AutoReceiveInput(EnumBase):
    r"""
    Specifies which player index will pass input to this actor/component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    DISABLED: AutoReceiveInput #: 0
    PLAYER0: AutoReceiveInput #: 1
    PLAYER1: AutoReceiveInput #: 2
    PLAYER2: AutoReceiveInput #: 3
    PLAYER3: AutoReceiveInput #: 4
    PLAYER4: AutoReceiveInput #: 5
    PLAYER5: AutoReceiveInput #: 6
    PLAYER6: AutoReceiveInput #: 7
    PLAYER7: AutoReceiveInput #: 8
    ...

class DetachmentRule(EnumBase):
    r"""
    Rules for detaching components - needs to be kept synced to EAttachmentRule
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    KEEP_RELATIVE: DetachmentRule #: 0: Keeps current relative transform.
    KEEP_WORLD: DetachmentRule #: 1: Automatically calculates the relative transform such that the detached component maintains the same world transform.
    ...

class AttachmentRule(EnumBase):
    r"""
    Rules for attaching components - needs to be kept synced to EDetachmentRule
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    KEEP_RELATIVE: AttachmentRule #: 0: Keeps current relative transform as the relative transform to the new parent.
    KEEP_WORLD: AttachmentRule #: 1: Automatically calculates the relative transform such that the attached component maintains the same world transform.
    SNAP_TO_TARGET: AttachmentRule #: 2: Snaps transform to the attach point
    ...

class FlowDirectionPreference(EnumBase):
    r"""
    EFlow Direction Preference
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: FlowDirection.h
    
    """

    INHERIT: FlowDirectionPreference #: 0: Inherits the flow direction set by the parent widget.
    CULTURE: FlowDirectionPreference #: 1: Begins laying out widgets using the current cultures layout direction preference, flipping the directionality of flows.
    LEFT_TO_RIGHT: FlowDirectionPreference #: 2: Forces a Left to Right layout flow.
    RIGHT_TO_LEFT: FlowDirectionPreference #: 3: Forces a Right to Left layout flow.
    ...

class MouseCursor(EnumBase):
    r"""
    Mouse cursor types (mirrored from ICursor.h)
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    NONE: MouseCursor #: 0: Causes no mouse cursor to be visible.
    DEFAULT: MouseCursor #: 1: Default cursor (arrow).
    TEXT_EDIT_BEAM: MouseCursor #: 2: Text edit beam.
    RESIZE_LEFT_RIGHT: MouseCursor #: 3: Resize horizontal.
    RESIZE_UP_DOWN: MouseCursor #: 4: Resize vertical.
    RESIZE_SOUTH_EAST: MouseCursor #: 5: Resize diagonal.
    RESIZE_SOUTH_WEST: MouseCursor #: 6: Resize other diagonal.
    CARDINAL_CROSS: MouseCursor #: 7: MoveItem.
    CROSSHAIRS: MouseCursor #: 8: Target Cross.
    HAND: MouseCursor #: 9: Hand cursor.
    GRAB_HAND: MouseCursor #: 10: Grab Hand cursor.
    GRAB_HAND_CLOSED: MouseCursor #: 11: Grab Hand cursor closed.
    SLASHED_CIRCLE: MouseCursor #: 12: a circle with a diagonal line through it.
    EYE_DROPPER: MouseCursor #: 13: Eye-dropper cursor for picking colors.
    ...

class WidgetPixelSnapping(EnumBase):
    r"""
    The different states of pixel snapping a widget can be in.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: WidgetPixelSnapping.h
    
    """

    INHERIT: WidgetPixelSnapping #: 0: Inherits the snapping method set by the parent widget.
    DISABLED: WidgetPixelSnapping #: 1: Draws the widget without snapping. Useful during animations or moving indicators.
    SNAP_TO_PIXEL: WidgetPixelSnapping #: 2: Draws the widget at the nearest pixel. Improves sharpness of widgets.
    ...

class WidgetTickFrequency(EnumBase):
    r"""
    Determines what strategy we use to determine when and if the widget ticks.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UserWidget.h
    
    """

    NEVER: WidgetTickFrequency #: 0: This widget never ticks
    AUTO: WidgetTickFrequency
    r"""
    1: This widget will tick if a blueprint tick function is implemented, any latent actions are found or animations need to play
    If the widget inherits from something other than UserWidget it will also tick so that native C++ or inherited ticks function
    To disable native ticking use add the class metadata flag "DisableNativeTick".  I.E: meta=(DisableNativeTick)
    """

    ...

class DetailMode(EnumBase):
    r"""
    Detail mode for scene component rendering, corresponds with the integer value of UWorld::GetDetailMode()
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneComponent.h
    
    """

    DM_LOW: DetailMode #: 0
    DM_MEDIUM: DetailMode #: 1
    DM_HIGH: DetailMode #: 2
    DM_EPIC: DetailMode #: 3
    ...

class RelativeTransformSpace(EnumBase):
    r"""
    The space for the transform
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneComponent.h
    
    """

    RTS_WORLD: RelativeTransformSpace #: 0: World space transform.
    RTS_ACTOR: RelativeTransformSpace #: 1: Actor space transform.
    RTS_COMPONENT: RelativeTransformSpace #: 2: Component space transform.
    RTS_PARENT_BONE_SPACE: RelativeTransformSpace #: 3: Parent bone space transform
    ...

class IndirectLightingCacheQuality(EnumBase):
    r"""
    Quality of indirect lighting for Movable primitives. This has a large effect on Indirect Lighting Cache update time.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    ILCQ_OFF: IndirectLightingCacheQuality #: 0: The indirect lighting cache will be disabled for this object, so no GI from stationary lights on movable objects.
    ILCQ_POINT: IndirectLightingCacheQuality #: 1: A single indirect lighting sample computed at the bounds origin will be interpolated which fades over time to newer results.
    ILCQ_VOLUME: IndirectLightingCacheQuality #: 2: The object will get a 5x5x5 stable volume of interpolated indirect lighting, which allows gradients of lighting intensity across the receiving object.
    ...

class LightmapType(EnumBase):
    r"""
    Type of lightmap that is used for primitive components
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    DEFAULT: LightmapType #: 0: Use the default based on Mobility: Surface Lightmap for Static components, Volumetric Lightmap for Movable components.
    FORCE_SURFACE: LightmapType #: 1: Force Surface Lightmap, even if the component moves, which should otherwise change the lighting.  This is only supported on components which support surface lightmaps, like static meshes.
    FORCE_VOLUMETRIC: LightmapType
    r"""
    2: Force Volumetric Lightmaps, even if the component is static and could have supported surface lightmaps.
    Volumetric Lightmaps have better directionality and no Lightmap UV seams, but are much lower resolution than Surface Lightmaps and frequently have self-occlusion and leaking problems.
    Note: Lightmass currently requires valid lightmap UVs and sufficient lightmap resolution to compute bounce lighting, even though the Volumetric Lightmap will be used at runtime.
    """

    ...

class HLODBatchingPolicy(EnumBase):
    r"""
    Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODBatchingPolicy.h
    
    """

    NONE: HLODBatchingPolicy #: 0: No batching to be performed, geometry is to be simplified.
    MESH_SECTION: HLODBatchingPolicy #: 1: Batch this component geometry (using the lowest LOD) as a separate mesh section, grouping by material.
    INSTANCING: HLODBatchingPolicy #: 2: Batch this component geometry (using the lowest LOD) as a separate instanced static mesh component in the generated actor.
    ...

class CanBeCharacterBase(EnumBase):
    r"""
    Determines whether a Character can attempt to step up onto a component when they walk in to it.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """

    ECB_NO: CanBeCharacterBase #: 0: Character cannot step up onto this Component.
    ECB_YES: CanBeCharacterBase #: 1: Character can step up onto this Component.
    ECB_OWNER: CanBeCharacterBase
    r"""
    2: Owning actor determines whether character can step up onto this Component (default true unless overridden in code).
    see: AActor::CanBeBaseForCharacter()
    """

    ...

class RuntimeVirtualTextureMainPassType(EnumBase):
    r"""
    Enumeration of main pass behaviors when rendering to a runtime virtual texture.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RuntimeVirtualTextureEnum.h
    
    """

    NEVER: RuntimeVirtualTextureMainPassType
    r"""
    0: Never render to the main pass.
    Use this for primitives that only render to Runtime Virtual Texture and can be missing if there is no virtual texture support.
    """

    EXCLUSIVE: RuntimeVirtualTextureMainPassType
    r"""
    1: Render to the main pass if no associated Runtime Virtual Texture Volumes are set to 'Hide Primitives'.
    This will render to the main pass if there is no matching Runtime Virtual Texture Volume placed in the scene.
    """

    ALWAYS: RuntimeVirtualTextureMainPassType
    r"""
    2: Always render to the main pass.
    Use this for items that both read from and write to a Runtime Virtual Texture.
    """

    ...

class RayTracingGroupCullingPriority(EnumBase):
    r"""
    How quickly component should be culled.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """

    CP_0_NEVER_CULL: RayTracingGroupCullingPriority #: 0
    CP_1: RayTracingGroupCullingPriority #: 1
    CP_2: RayTracingGroupCullingPriority #: 2
    CP_3: RayTracingGroupCullingPriority #: 3
    CP_4_DEFAULT: RayTracingGroupCullingPriority #: 4
    CP_5: RayTracingGroupCullingPriority #: 5
    CP_6: RayTracingGroupCullingPriority #: 6
    CP_7: RayTracingGroupCullingPriority #: 7
    CP_8_QUICKLY_CULL: RayTracingGroupCullingPriority #: 8
    ...

class RendererStencilMask(EnumBase):
    r"""
    Exposed enum to parallel RHI's EStencilMask and show up in the editor. Has a paired struct to convert between the two.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """

    ERSM_DEFAULT: RendererStencilMask #: 0
    ERSM_255: RendererStencilMask #: 1
    ERSM_1: RendererStencilMask #: 2
    ERSM_2: RendererStencilMask #: 3
    ERSM_4: RendererStencilMask #: 4
    ERSM_8: RendererStencilMask #: 5
    ERSM_16: RendererStencilMask #: 6
    ERSM_32: RendererStencilMask #: 7
    ERSM_64: RendererStencilMask #: 8
    ERSM_128: RendererStencilMask #: 9
    ...

class HLODLevelExclusion(EnumBase):
    r"""
    Bitflag enum to allow editing of UPrimitiveComponent::ExcludeFromHLODLevels as a bitmask in the properties
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODLevelExclusion.h
    
    """

    HLOD0: HLODLevelExclusion #: 1
    HLOD1: HLODLevelExclusion #: 2
    HLOD2: HLODLevelExclusion #: 4
    HLOD3: HLODLevelExclusion #: 8
    HLOD4: HLODLevelExclusion #: 16
    HLOD5: HLODLevelExclusion #: 32
    HLOD6: HLODLevelExclusion #: 64
    HLOD7: HLODLevelExclusion #: 128
    ...

class RadialImpulseFalloff(EnumBase):
    r"""
    Enum for controlling the falloff of strength of a radial impulse as a function of distance from Origin.
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: ChaosEngineInterface.h
    
    """

    RIF_CONSTANT: RadialImpulseFalloff #: 0: Impulse is a constant strength, up to the limit of its range.
    RIF_LINEAR: RadialImpulseFalloff #: 1: Impulse should get linearly weaker the further from origin.
    ...

class ViewportInteractionDraggingMode(EnumBase):
    r"""
    Methods of dragging objects around in VR
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: ViewportInteractionTypes.h
    
    """

    NOTHING: ViewportInteractionDraggingMode #: 0: Not dragging right now with this hand
    TRANSFORMABLES_WITH_GIZMO: ViewportInteractionDraggingMode #: 1: Dragging transformables (e.g. actors, components, geometry elements) around using the transform gizmo
    TRANSFORMABLES_AT_LASER_IMPACT: ViewportInteractionDraggingMode #: 2: Transformables locked to the impact point under the laser
    ASSISTING_DRAG: ViewportInteractionDraggingMode #: 3: We're grabbing an object (or the world) that was already grabbed by the other hand
    TRANSFORMABLES_FREELY: ViewportInteractionDraggingMode #: 4: Freely moving, rotating and scaling transformables with one or two hands
    WORLD: ViewportInteractionDraggingMode #: 5: Moving the world itself around (actually, moving the camera in such a way that it feels like you're moving the world)
    INTERACTABLE: ViewportInteractionDraggingMode #: 6: Moving a custom interactable
    MATERIAL: ViewportInteractionDraggingMode #: 7: Dragging a material
    ...

class GizmoHandleTypes(EnumBase):
    r"""
    EGizmo Handle Types
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIBaseTransformGizmo.h
    
    """

    ALL: GizmoHandleTypes #: 0
    TRANSLATE: GizmoHandleTypes #: 1
    ROTATE: GizmoHandleTypes #: 2
    SCALE: GizmoHandleTypes #: 3
    ...

class LevelEditorMenuContext(EnumBase):
    r"""
    Enum to describe what a level editor context menu should be built for
    
    **C++ Source:**
    
    - **Module**: LevelEditor
    - **File**: LevelEditorMenuContext.h
    
    """

    VIEWPORT: LevelEditorMenuContext #: 0: This context menu is applicable to a viewport (limited subset of entries)
    SCENE_OUTLINER: LevelEditorMenuContext #: 1: This context menu is applicable to the Scene Outliner (disables click-position-based menu items)
    MAIN_MENU: LevelEditorMenuContext #: 2: This is the replica of the context menu that appears in the main menu bar (lists all entries)
    ...

class GameplayTaskRunResult(EnumBase):
    r"""
    EGameplay Task Run Result
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTasksComponent.h
    
    """

    ERROR: GameplayTaskRunResult #: 0: When tried running a null-task
    FAILED: GameplayTaskRunResult #: 1
    SUCCESS_PAUSED: GameplayTaskRunResult #: 2: Successfully registered for running, but currently paused due to higher priority tasks running
    SUCCESS_ACTIVE: GameplayTaskRunResult #: 3: Successfully activated
    SUCCESS_FINISHED: GameplayTaskRunResult #: 4: Successfully activated, but finished instantly
    ...

class AIRequestPriority(EnumBase):
    r"""
    EAIRequest Priority
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AITypes.h
    
    """

    SOFT_SCRIPT: AIRequestPriority #: 0: Actions requested by Level Designers by placing AI-hinting elements on the map.
    LOGIC: AIRequestPriority #: 1: Actions AI wants to do due to its internal logic.
    HARD_SCRIPT: AIRequestPriority #: 2: Actions LDs really want AI to perform.
    REACTION: AIRequestPriority #: 3: Actions being result of game-world mechanics, like hit reactions, death, falling, etc. In general things not depending on what AI's thinking.
    ULTIMATE: AIRequestPriority #: 4: Ultimate priority, to be used with caution, makes AI perform given action regardless of anything else (for example disabled reactions).
    ...

class PawnActionResult(EnumBase):
    r"""
    EPawn Action Result
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AITypes.h
    
    """

    NOT_STARTED: PawnActionResult #: 0
    IN_PROGRESS: PawnActionResult #: 1
    SUCCESS: PawnActionResult #: 2
    FAILED: PawnActionResult #: 3
    ABORTED: PawnActionResult #: 4
    ...

class PawnActionAbortState(EnumBase):
    r"""
    EPawn Action Abort State
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AITypes.h
    
    """

    NEVER_STARTED: PawnActionAbortState #: 0
    NOT_BEING_ABORTED: PawnActionAbortState #: 1
    MARK_PENDING_ABORT: PawnActionAbortState #: 2: This means waiting for child to abort before aborting self.
    LATENT_ABORT_IN_PROGRESS: PawnActionAbortState #: 3
    ABORT_DONE: PawnActionAbortState #: 4
    ...

class PawnActionFailHandling(EnumBase):
    r"""
    EPawn Action Fail Handling
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PawnAction.h
    
    """

    REQUIRE_SUCCESS: PawnActionFailHandling #: 0
    IGNORE_FAILURE: PawnActionFailHandling #: 1
    ...

class BTFlowAbortMode(EnumBase):
    r"""
    keep in sync with DescribeFlowAbortMode()
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BehaviorTreeTypes.h
    
    """

    NONE: BTFlowAbortMode #: 0
    LOWER_PRIORITY: BTFlowAbortMode #: 1
    SELF: BTFlowAbortMode #: 2
    BOTH: BTFlowAbortMode #: 3
    ...

class EnvQueryRunMode(EnumBase):
    r"""
    EEnv Query Run Mode
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryTypes.h
    
    """

    SINGLE_RESULT: EnvQueryRunMode #: 0: Pick first item with the best score
    RANDOM_BEST5_PCT: EnvQueryRunMode #: 1: Pick random item with score 95% .. 100% of max
    RANDOM_BEST25_PCT: EnvQueryRunMode #: 2: Pick random item with score 75% .. 100% of max
    ALL_MATCHING: EnvQueryRunMode #: 3: Get all items that match conditions
    ...

class AutoPossessAI(EnumBase):
    r"""
    Specifies if an AI pawn will automatically be possessed by an AI controller
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    DISABLED: AutoPossessAI #: 0: Feature is disabled (do not automatically possess AI).
    PLACED_IN_WORLD: AutoPossessAI #: 1: Only possess by an AI Controller if Pawn is placed in the world.
    SPAWNED: AutoPossessAI #: 2: Only possess by an AI Controller if Pawn is spawned after the world has loaded.
    PLACED_IN_WORLD_OR_SPAWNED: AutoPossessAI #: 3: Pawn is automatically possessed by an AI Controller whenever it is created.
    ...

class EnvQueryHightlightMode(EnumBase):
    r"""
    EEnv Query Hightlight Mode
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EQSTestingPawn.h
    
    """

    ALL: EnvQueryHightlightMode #: 0
    BEST5_PCT: EnvQueryHightlightMode #: 1
    BEST25_PCT: EnvQueryHightlightMode #: 2
    ...

class AISenseNotifyType(EnumBase):
    r"""
    EAISense Notify Type
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionTypes.h
    
    """

    ON_EVERY_PERCEPTION: AISenseNotifyType #: 0: Continuous update whenever target is perceived.
    ON_PERCEPTION_CHANGE: AISenseNotifyType #: 1: From "visible" to "not visible" or vice versa.
    ...

class ClusterConnectionTypeEnum(EnumBase):
    r"""
    Legacy enum for old deprecated configuration properties. To be removed when those properties are
    
    **C++ Source:**
    
    - **Module**: ChaosSolverEngine
    - **File**: ChaosSolverActor.h
    
    """

    CHAOS_POINT_IMPLICIT: ClusterConnectionTypeEnum #: 0
    CHAOS_MINIMAL_SPANNING_SUBSET_DELAUNAY_TRIANGULATION: ClusterConnectionTypeEnum #: 2
    CHAOS_POINT_IMPLICIT_AUGMENTED_WITH_MINIMAL_DELAUNAY: ClusterConnectionTypeEnum #: 3
    CHAOS_BOUNDS_OVERLAP_FILTERED_DELAUNAY_TRIANGULATION: ClusterConnectionTypeEnum #: 4
    ...

class GeometryCollectionDebugDrawActorHideGeometry(EnumBase):
    r"""
    EGeometryCollectionDebugDrawActorHideGeometry
      Visibility enum.
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionDebugDrawActor.h
    
    """

    HIDE_NONE: GeometryCollectionDebugDrawActorHideGeometry #: 0: Do not hide any geometry.
    HIDE_WITH_COLLISION: GeometryCollectionDebugDrawActorHideGeometry #: 1: Hide the geometry associated with rigid bodies that are selected for collision volume visualization.
    HIDE_SELECTED: GeometryCollectionDebugDrawActorHideGeometry #: 2: Hide the geometry associated with the selected rigid bodies.
    HIDE_WHOLE_COLLECTION: GeometryCollectionDebugDrawActorHideGeometry #: 3: Hide the entire geometry collection associated with the selected rigid bodies.
    HIDE_ALL: GeometryCollectionDebugDrawActorHideGeometry #: 4: Hide all geometry collections.
    ...

class CollisionTypeEnum(EnumBase):
    r"""
    ECollision Type Enum
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: GeometryCollectionSimulationTypes.h
    
    """

    CHAOS_VOLUMETRIC: CollisionTypeEnum #: 0
    CHAOS_SURFACE_VOLUMETRIC: CollisionTypeEnum #: 1
    ...

class RuntimeGenerationType(EnumBase):
    r"""
    Supported options for runtime navigation data generation
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationData.h
    
    """

    STATIC: RuntimeGenerationType #: 0: No runtime generation, fully static navigation data
    DYNAMIC_MODIFIERS_ONLY: RuntimeGenerationType #: 1: Supports only navigation modifiers updates
    DYNAMIC: RuntimeGenerationType #: 2: Fully dynamic, supports geometry changes along with navigation modifiers
    ...

class NavigationInvokerPriority(EnumBase):
    r"""
    ENavigation Invoker Priority
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationInvokerPriority.h
    
    """

    VERY_LOW: NavigationInvokerPriority #: 1: Enum values are used (keep in ascending order)
    LOW: NavigationInvokerPriority #: 2
    DEFAULT: NavigationInvokerPriority #: 3
    HIGH: NavigationInvokerPriority #: 4
    VERY_HIGH: NavigationInvokerPriority #: 5
    ...

class NavigationOptionFlag(EnumBase):
    r"""
    ENavigation Option Flag
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationTypes.h
    
    """

    DEFAULT: NavigationOptionFlag #: 0
    ENABLE: NavigationOptionFlag #: 1
    DISABLE: NavigationOptionFlag #: 2: UHT was complaining when tried to use True as value instead of Enable
    ...

class NavDataGatheringModeConfig(EnumBase):
    r"""
    ENav Data Gathering Mode Config
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationTypes.h
    
    """

    INSTANT: NavDataGatheringModeConfig #: 1
    LAZY: NavDataGatheringModeConfig #: 2
    ...

class NavigationQueryResult(EnumBase):
    r"""
    ENavigation Query Result
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationTypes.h
    
    """

    INVALID: NavigationQueryResult #: 0
    ERROR: NavigationQueryResult #: 1
    FAIL: NavigationQueryResult #: 2
    SUCCESS: NavigationQueryResult #: 3
    ...

class NavCostDisplay(EnumBase):
    r"""
    ENav Cost Display
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationTestingActor.h
    
    """

    TOTAL_COST: NavCostDisplay #: 0
    HEURISTIC_ONLY: NavCostDisplay #: 1
    REAL_COST_ONLY: NavCostDisplay #: 2
    ...

class BrushType(EnumBase):
    r"""
    EBrush Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Brush.h
    
    """

    BRUSH_ADD: BrushType #: 1: Add to world.
    BRUSH_SUBTRACT: BrushType #: 2: Subtract from world.
    ...

class NavigationLedgeSlopeFilterMode(EnumBase):
    r"""
    ENavigation Ledge Slope Filter Mode
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: RecastNavMesh.h
    
    """

    RECAST: NavigationLedgeSlopeFilterMode #: 0
    NONE: NavigationLedgeSlopeFilterMode #: 1: Use walkableClimb value to filter
    USE_STEP_HEIGHT_FROM_AGENT_MAX_SLOPE: NavigationLedgeSlopeFilterMode #: 2: Skip slope filtering
    ...

class RecastPartitioning(EnumBase):
    r"""
    keep in sync with rcRegionPartitioning enum!
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: RecastNavMesh.h
    
    """

    MONOTONE: RecastPartitioning #: 0
    WATERSHED: RecastPartitioning #: 1
    CHUNKY_MONOTONE: RecastPartitioning #: 2
    ...

class NavigationDataResolution(EnumBase):
    r"""
    ENavigation Data Resolution
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationDataResolution.h
    
    """

    LOW: NavigationDataResolution #: 0
    DEFAULT: NavigationDataResolution #: 1
    HIGH: NavigationDataResolution #: 2
    INVALID: NavigationDataResolution #: 3
    ...

class NavSystemOverridePolicy(EnumBase):
    r"""
    ENav System Override Policy
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavSystemConfigOverride.h
    
    """

    OVERRIDE: NavSystemOverridePolicy #: 0
    APPEND: NavSystemOverridePolicy #: 1: the pre-existing nav system instance will be destroyed.
    SKIP: NavSystemOverridePolicy #: 2: config information will be added to pre-existing nav system instance
    ...

class SelectionMode(EnumBase):
    r"""
    ESelection Mode
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: ITypedTableView.h
    
    """

    NONE: SelectionMode #: 0: Nothing can be selected and there is no hover cue for selection.  You can still handle mouse button events though.
    SINGLE: SelectionMode #: 1: A single item can be selected at once, or no item may be selected.
    SINGLE_TOGGLE: SelectionMode #: 2: A single item can be selected at once, or no item may be selected.  You can click the item to toggle selection on and off.
    MULTI: SelectionMode #: 3: Multiple items can be selected at the same time.
    ...

class ConsumeMouseWheel(EnumBase):
    r"""
    Used to determine how we should handle mouse wheel input events when someone scrolls.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    """

    WHEN_SCROLLING_POSSIBLE: ConsumeMouseWheel #: 0: Only consume the mouse wheel event when we actually scroll some amount.
    ALWAYS: ConsumeMouseWheel #: 1: Always consume mouse wheel event even if we don't scroll at all.
    NEVER: ConsumeMouseWheel #: 2: Never consume the mouse wheel
    ...

class WindowTitleBarMode(EnumBase):
    r"""
    EWindow Title Bar Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SGameLayerManager.h
    
    """

    OVERLAY: WindowTitleBarMode #: 0
    VERTICAL_BOX: WindowTitleBarMode #: 1
    ...

class MouseLockMode(EnumBase):
    r"""
    EMouse Lock Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineBaseTypes.h
    
    """

    DO_NOT_LOCK: MouseLockMode #: 0: Do not lock the mouse cursor to the viewport
    LOCK_ON_CAPTURE: MouseLockMode #: 1: Only lock the mouse cursor to the viewport when the mouse is captured
    LOCK_ALWAYS: MouseLockMode #: 2: Always lock the mouse cursor to the viewport
    LOCK_IN_FULLSCREEN: MouseLockMode #: 3: Lock the cursor if we're in fullscreen
    ...

class ColorVisionDeficiency(EnumBase):
    r"""
    Enumerates color vision deficiency types.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: RenderingCommon.h
    
    """

    NORMAL_VISION: ColorVisionDeficiency #: 0
    DEUTERANOPE: ColorVisionDeficiency #: 1
    PROTANOPE: ColorVisionDeficiency #: 2
    TRITANOPE: ColorVisionDeficiency #: 3
    ...

class ShouldCookBlueprintPropertyGuids(EnumBase):
    r"""
    EShould Cook Blueprint Property Guids
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Blueprint.h
    
    """

    NO: ShouldCookBlueprintPropertyGuids #: 0: Don't cook the property GUIDs for this Blueprint
    YES: ShouldCookBlueprintPropertyGuids #: 1: Cook the property GUIDs for this Blueprint (see UCookerSettings::BlueprintPropertyGuidsCookingMethod)
    INHERIT: ShouldCookBlueprintPropertyGuids #: 2: Inherit whether to cook the property GUIDs for this Blueprint from the parent Blueprint (behaves like 'No' if there is no parent Blueprint)
    ...

class BlueprintCompileMode(EnumBase):
    r"""
    Compile modes.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Blueprint.h
    
    """

    DEFAULT: BlueprintCompileMode #: 0: Use the default setting.
    DEVELOPMENT: BlueprintCompileMode #: 1: Always compile in development mode (even when cooking).
    FINAL_RELEASE: BlueprintCompileMode #: 2: Always compile in final release mode.
    ...

class ContentBrowserDataMenuContext_AddNewMenuDomain(EnumBase):
    r"""
    EContent Browser Data Menu Context Add New Menu Domain
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataMenuContexts.h
    
    """

    TOOLBAR: ContentBrowserDataMenuContext_AddNewMenuDomain #: 0
    ASSET_VIEW: ContentBrowserDataMenuContext_AddNewMenuDomain #: 1
    PATH_VIEW: ContentBrowserDataMenuContext_AddNewMenuDomain #: 2
    ...

class AssetRenameResult(EnumBase):
    r"""
    EAsset Rename Result
    
    **C++ Source:**
    
    - **Module**: AssetTools
    - **File**: IAssetTools.h
    
    """

    FAILURE: AssetRenameResult #: 0: The asset rename failed
    SUCCESS: AssetRenameResult #: 1: The asset rename succeeded
    PENDING: AssetRenameResult #: 2: The asset rename is still pending, likely due to outstanding asset discovery
    ...

class SkinCacheUsage(EnumBase):
    r"""
    ESkin Cache Usage
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedAssetCommon.h
    
    """

    AUTO: SkinCacheUsage #: 0: Auto will defer to child or global behavior based on context
    DISABLED: SkinCacheUsage #: 255: Mesh will not use the skin cache. However, if Support Ray Tracing is enabled on the mesh, the skin cache will still be used for Ray Tracing updates
    ENABLED: SkinCacheUsage #: 1: Mesh will use the skin cache
    ...

class PhysBodyOp(EnumBase):
    r"""
    PhysicsBody options when bone is hidden
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedMeshComponent.h
    
    """

    PBO_NONE: PhysBodyOp #: 0: Don't do anything.
    PBO_TERM: PhysBodyOp #: 1: Terminate - if you terminate, you won't be able to re-init when unhidden.
    ...

class KinematicBonesUpdateToPhysics(EnumBase):
    r"""
    This enum defines how you'd like to update bones to physics world.
          If bone is simulating, you don't have to waste time on updating bone transform from kinematic.
          But also sometimes you don't like fixed bones to be updated by animation data.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshComponent.h
    
    """

    SKIP_SIMULATING_BONES: KinematicBonesUpdateToPhysics #: 0: Update any bones that are not simulating.
    SKIP_ALL_BONES: KinematicBonesUpdateToPhysics #: 1: Skip physics update from kinematic changes.
    ...

class PhysicsTransformUpdateMode(EnumBase):
    r"""
    EPhysics Transform Update Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshComponent.h
    
    """

    SIMULATION_UPATES_COMPONENT_TRANSFORM: PhysicsTransformUpdateMode #: 0
    COMPONENT_TRANSFORM_IS_KINEMATIC: PhysicsTransformUpdateMode #: 1
    ...

class AnimationMode(EnumBase):
    r"""
    EAnimation Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshComponent.h
    
    """

    ANIMATION_BLUEPRINT: AnimationMode #: 0
    ANIMATION_SINGLE_NODE: AnimationMode #: 1
    ANIMATION_CUSTOM_MODE: AnimationMode #: 2: This is custom type, engine leaves AnimInstance as it is
    ...

class TeleportType(EnumBase):
    r"""
    Whether to teleport physics body or not
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    NONE: TeleportType #: 0: Do not teleport physics body. This means velocity will reflect the movement between initial and final position, and collisions along the way will occur
    TELEPORT_PHYSICS: TeleportType #: 1: Teleport physics body so that velocity remains the same and no collision occurs
    RESET_PHYSICS: TeleportType #: 2: Teleport physics body and reset physics state completely
    ...

class CustomBoneAttributeLookup(EnumBase):
    r"""
    Method used when retrieving a attribute value
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshComponent.h
    
    """

    BONE_ONLY: CustomBoneAttributeLookup #: 0: Only look for the attribute using the provided bone (name)
    IMMEDIATE_PARENT: CustomBoneAttributeLookup #: 1: Look for the attribute using the provided bone (name) and its direct parent bone
    PARENT_HIERARCHY: CustomBoneAttributeLookup #: 2: Look for the attribute using the provided bone (name) and its direct bone parent hierarchy up and until the root bone
    ...

class RootMotionMode(EnumBase):
    r"""
    ERoot Motion Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimEnums.h
    
    """

    NO_ROOT_MOTION_EXTRACTION: RootMotionMode #: 0: Leave root motion in animation.
    IGNORE_ROOT_MOTION: RootMotionMode #: 1: Extract root motion but do not apply it.
    ROOT_MOTION_FROM_EVERYTHING: RootMotionMode #: 2: Root motion is taken from all animations contributing to the final pose, not suitable for network multiplayer setups.
    ROOT_MOTION_FROM_MONTAGES_ONLY: RootMotionMode #: 3: Root motion is only taken from montages, suitable for network multiplayer setups.
    ...

class MontagePlayReturnType(EnumBase):
    r"""
    EMontage Play Return Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimInstance.h
    
    """

    MONTAGE_LENGTH: MontagePlayReturnType #: 0: Return value is the length of the montage (in seconds)
    DURATION: MontagePlayReturnType #: 1: Return value is the play duration of the montage (length / play rate, in seconds)
    ...

class AnimCurveType(EnumBase):
    r"""
    EAnim Curve Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCurveTypes.h
    
    """

    ATTRIBUTE_CURVE: AnimCurveType #: 0
    MATERIAL_CURVE: AnimCurveType #: 1
    MORPH_TARGET_CURVE: AnimCurveType #: 2
    ...

class TransitionLogicType(EnumBase):
    r"""
    
    TODO:: Document
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimStateMachineTypes.h
    
    """

    TLT_STANDARD_BLEND: TransitionLogicType #: 0
    TLT_INERTIALIZATION: TransitionLogicType #: 1
    TLT_CUSTOM: TransitionLogicType #: 2
    ...

class RootMotionRootLock(EnumBase):
    r"""
    Root Bone Lock options when extracting Root Motion.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimEnums.h
    
    """

    REF_POSE: RootMotionRootLock #: 0: Use reference pose root bone position.
    ANIM_FIRST_FRAME: RootMotionRootLock #: 1: Use root bone position on first frame of animation.
    ZERO: RootMotionRootLock #: 2: FTransform::Identity.
    ...

class AdditiveBasePoseType(EnumBase):
    r"""
    For an additive animation, indicates what the animation is relative to.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimEnums.h
    
    """

    ABPT_NONE: AdditiveBasePoseType #: 0: Will be deprecated.
    ABPT_REF_POSE: AdditiveBasePoseType #: 1: Use the Skeleton's ref pose as base.
    ABPT_ANIM_SCALED: AdditiveBasePoseType #: 2: Use a whole animation as a base pose. BasePoseSeq must be set.
    ABPT_ANIM_FRAME: AdditiveBasePoseType #: 3: Use one frame of an animation as a base pose. BasePoseSeq and RefFrameIndex must be set (RefFrameIndex will be clamped).
    ABPT_LOCAL_ANIM_FRAME: AdditiveBasePoseType #: 4: Use one frame of this animation. RefFrameIndex must be set (RefFrameIndex will be clamped).
    ...

class AdditiveAnimationType(EnumBase):
    r"""
    Indicates whether an animation is additive, and what kind.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """

    AAT_NONE: AdditiveAnimationType #: 0: No additive.
    AAT_LOCAL_SPACE_BASE: AdditiveAnimationType #: 1: Create Additive from LocalSpace Base.
    AAT_ROTATION_OFFSET_MESH_SPACE: AdditiveAnimationType #: 2: Create Additive from MeshSpace Rotation Only, Translation still will be LocalSpace.
    ...

class Show3DTrajectory(EnumBase):
    r"""
    Visibility options for 3d trajectory.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScene3DTransformSection.h
    
    """

    EST_ONLY_WHEN_SELECTED: Show3DTrajectory #: 0
    EST_ALWAYS: Show3DTrajectory #: 1
    EST_NEVER: Show3DTrajectory #: 2
    ...

class LevelVisibility(EnumBase):
    r"""
    Visibility options for the level visibility section.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneLevelVisibilitySection.h
    
    """

    VISIBLE: LevelVisibility #: 0: The streamed levels should be visible.
    HIDDEN: LevelVisibility #: 1: The streamed levels should be hidden.
    ...

class FireEventsAtPosition(EnumBase):
    r"""
    Indicates at what point in the sequence evaluation events should fire
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEventTrack.h
    
    """

    AT_START_OF_EVALUATION: FireEventsAtPosition #: 0: Fire events before anything else is evaluated in the sequence
    AT_END_OF_EVALUATION: FireEventsAtPosition #: 1: Fire events after everything else has been evaluated in the sequence
    AFTER_SPAWN: FireEventsAtPosition #: 2: Fire events right after any spawn tracks have been evaluated
    ...

class TimecodeProviderSynchronizationState(EnumBase):
    r"""
    Possible states of TimecodeProvider.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimecodeProvider.h
    
    """

    CLOSED: TimecodeProviderSynchronizationState #: 0: TimecodeProvider has not been initialized or has been shutdown.
    ERROR: TimecodeProviderSynchronizationState #: 1: Unrecoverable error occurred during Synchronization.
    SYNCHRONIZED: TimecodeProviderSynchronizationState #: 2: TimecodeProvider is currently synchronized with the source.
    SYNCHRONIZING: TimecodeProviderSynchronizationState #: 3: TimecodeProvider is initialized and being prepared for synchronization.
    ...

class MovieSceneBuiltInEasing(EnumBase):
    r"""
    EMovie Scene Built in Easing
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneEasingCurves.h
    
    """

    LINEAR: MovieSceneBuiltInEasing #: 0: Linear easing
    SIN_IN: MovieSceneBuiltInEasing #: 1: Sinusoidal easing
    SIN_OUT: MovieSceneBuiltInEasing #: 2
    SIN_IN_OUT: MovieSceneBuiltInEasing #: 3
    QUAD_IN: MovieSceneBuiltInEasing #: 4: Quadratic easing
    QUAD_OUT: MovieSceneBuiltInEasing #: 5
    QUAD_IN_OUT: MovieSceneBuiltInEasing #: 6
    CUBIC: MovieSceneBuiltInEasing #: 7: Cubic easing
    CUBIC_IN: MovieSceneBuiltInEasing #: 8
    CUBIC_OUT: MovieSceneBuiltInEasing #: 9
    CUBIC_IN_OUT: MovieSceneBuiltInEasing #: 10
    HERMITE_CUBIC_IN_OUT: MovieSceneBuiltInEasing #: 11
    QUART_IN: MovieSceneBuiltInEasing #: 12: Quartic easing
    QUART_OUT: MovieSceneBuiltInEasing #: 13
    QUART_IN_OUT: MovieSceneBuiltInEasing #: 14
    QUINT_IN: MovieSceneBuiltInEasing #: 15: Quintic easing
    QUINT_OUT: MovieSceneBuiltInEasing #: 16
    QUINT_IN_OUT: MovieSceneBuiltInEasing #: 17
    EXPO_IN: MovieSceneBuiltInEasing #: 18: Exponential easing
    EXPO_OUT: MovieSceneBuiltInEasing #: 19
    EXPO_IN_OUT: MovieSceneBuiltInEasing #: 20
    CIRC_IN: MovieSceneBuiltInEasing #: 21: Circular easing
    CIRC_OUT: MovieSceneBuiltInEasing #: 22
    CIRC_IN_OUT: MovieSceneBuiltInEasing #: 23
    CUSTOM: MovieSceneBuiltInEasing #: 24: Custom
    ...

class FFTPeakInterpolationMethod(EnumBase):
    r"""
    EFFTPeak Interpolation Method
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    """

    NEAREST_NEIGHBOR: FFTPeakInterpolationMethod #: 0
    LINEAR: FFTPeakInterpolationMethod #: 1
    QUADRATIC: FFTPeakInterpolationMethod #: 2
    CONSTANT_Q: FFTPeakInterpolationMethod #: 3
    ...

class FFTWindowType(EnumBase):
    r"""
    EFFTWindow Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    """

    NONE: FFTWindowType #: 0: No window is applied. Technically a boxcar window.
    HAMMING: FFTWindowType #: 1: Mainlobe width of -3 dB and sidelobe attenuation of ~-40 dB. Good for COLA.
    HANN: FFTWindowType #: 2: Mainlobe width of -3 dB and sidelobe attenuation of ~-30dB. Good for COLA.
    BLACKMAN: FFTWindowType #: 3: Mainlobe width of -3 dB and sidelobe attenuation of ~-60db. Tricky for COLA.
    ...

class SoundwaveSampleRateSettings(EnumBase):
    r"""
    ESoundwave Sample Rate Settings
    
    **C++ Source:**
    
    - **Module**: AudioPlatformConfiguration
    - **File**: AudioCompressionSettings.h
    
    """

    MAX: SoundwaveSampleRateSettings #: 0
    HIGH: SoundwaveSampleRateSettings #: 1
    MEDIUM: SoundwaveSampleRateSettings #: 2
    LOW: SoundwaveSampleRateSettings #: 3
    MIN: SoundwaveSampleRateSettings #: 4
    MATCH_DEVICE_DEPRECATED: SoundwaveSampleRateSettings #: 5
    ...

class SoundGroup(EnumBase):
    r"""
    ESound Group
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundGroups.h
    
    """

    SOUNDGROUP_DEFAULT: SoundGroup #: 0
    SOUNDGROUP_EFFECTS: SoundGroup #: 1
    SOUNDGROUP_UI: SoundGroup #: 2
    SOUNDGROUP_MUSIC: SoundGroup #: 3
    SOUNDGROUP_VOICE: SoundGroup #: 4
    ...

class TextureLossyCompressionAmount(EnumBase):
    r"""
    ETexture Lossy Compression Amount
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    TLCA_DEFAULT: TextureLossyCompressionAmount #: 0
    TLCA_NONE: TextureLossyCompressionAmount #: 1
    TLCA_LOWEST: TextureLossyCompressionAmount #: 2
    TLCA_LOW: TextureLossyCompressionAmount #: 3
    TLCA_MEDIUM: TextureLossyCompressionAmount #: 4
    TLCA_HIGH: TextureLossyCompressionAmount #: 5
    TLCA_HIGHEST: TextureLossyCompressionAmount #: 6
    ...

class TextureCompressionQuality(EnumBase):
    r"""
    TextureCompressionQuality is used for ASTC
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    TCQ_DEFAULT: TextureCompressionQuality #: 0
    TCQ_LOWEST: TextureCompressionQuality #: 1
    TCQ_LOW: TextureCompressionQuality #: 2
    TCQ_MEDIUM: TextureCompressionQuality #: 3
    TCQ_HIGH: TextureCompressionQuality #: 4
    TCQ_HIGHEST: TextureCompressionQuality #: 5
    ...

class TexturePowerOfTwoSetting(EnumBase):
    r"""
    Options for texture padding mode.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    NONE: TexturePowerOfTwoSetting #: 0: Do not modify the texture dimensions.
    PAD_TO_POWER_OF_TWO: TexturePowerOfTwoSetting #: 1: Pad the texture to the nearest power of two size.
    PAD_TO_SQUARE_POWER_OF_TWO: TexturePowerOfTwoSetting #: 2: Pad the texture to the nearest square power of two size.
    STRETCH_TO_POWER_OF_TWO: TexturePowerOfTwoSetting #: 3: Stretch the texture to the nearest power of two size.
    STRETCH_TO_SQUARE_POWER_OF_TWO: TexturePowerOfTwoSetting #: 4: Stretch the texture to the nearest square power of two size.
    RESIZE_TO_SPECIFIC_RESOLUTION: TexturePowerOfTwoSetting #: 5: Resize the texture to specific user defined resolution.
    ...

class TextureMipGenSettings(EnumBase):
    r"""
    Texture Mip Gen Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    TMGS_FROM_TEXTURE_GROUP: TextureMipGenSettings #: 0: Default for the "texture".
    TMGS_SIMPLE_AVERAGE: TextureMipGenSettings #: 1: 2x2 average, default for the "texture group".
    TMGS_SHARPEN0: TextureMipGenSettings #: 2: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    TMGS_SHARPEN1: TextureMipGenSettings #: 3: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    TMGS_SHARPEN2: TextureMipGenSettings #: 4: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    TMGS_SHARPEN3: TextureMipGenSettings #: 5: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    TMGS_SHARPEN4: TextureMipGenSettings #: 6: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    TMGS_SHARPEN5: TextureMipGenSettings #: 7: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    TMGS_SHARPEN6: TextureMipGenSettings #: 8: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    TMGS_SHARPEN7: TextureMipGenSettings #: 9: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    TMGS_SHARPEN8: TextureMipGenSettings #: 10: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    TMGS_SHARPEN9: TextureMipGenSettings #: 11: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    TMGS_SHARPEN10: TextureMipGenSettings #: 12: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    TMGS_NO_MIPMAPS: TextureMipGenSettings #: 13
    TMGS_LEAVE_EXISTING_MIPS: TextureMipGenSettings #: 14: Do not touch existing mip chain as it contains generated data.
    TMGS_BLUR1: TextureMipGenSettings #: 15: Blur further (useful for image based reflections).
    TMGS_BLUR2: TextureMipGenSettings #: 16
    TMGS_BLUR3: TextureMipGenSettings #: 17
    TMGS_BLUR4: TextureMipGenSettings #: 18
    TMGS_BLUR5: TextureMipGenSettings #: 19
    TMGS_UNFILTERED: TextureMipGenSettings #: 20: Use the first texel of each 2x2 (or 2x2x2) group.
    TMGS_ANGULAR: TextureMipGenSettings #: 21: Introduce significant amount of blur using angular filtering (only applies to cubemaps, useful for ambient lighting).
    ...

class CompositeTextureMode(EnumBase):
    r"""
    EComposite Texture Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    CTM_DISABLED: CompositeTextureMode #: 0
    CTM_NORMAL_ROUGHNESS_TO_RED: CompositeTextureMode #: 1: CompositingTexture needs to be a normal map with the same or larger size.
    CTM_NORMAL_ROUGHNESS_TO_GREEN: CompositeTextureMode #: 2: CompositingTexture needs to be a normal map with the same or larger size.
    CTM_NORMAL_ROUGHNESS_TO_BLUE: CompositeTextureMode #: 3: CompositingTexture needs to be a normal map with the same or larger size.
    CTM_NORMAL_ROUGHNESS_TO_ALPHA: CompositeTextureMode #: 4: CompositingTexture needs to be a normal map with the same or larger size.
    ...

class TextureCompressionSettings(EnumBase):
    r"""
    This needs to be mirrored in EditorFactories.cpp.
    TC_EncodedReflectionCapture is no longer used and could be deleted
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    TC_DEFAULT: TextureCompressionSettings #: 0
    TC_NORMALMAP: TextureCompressionSettings #: 1
    TC_MASKS: TextureCompressionSettings #: 2
    TC_GRAYSCALE: TextureCompressionSettings #: 3
    TC_DISPLACEMENTMAP: TextureCompressionSettings #: 4
    TC_VECTOR_DISPLACEMENTMAP: TextureCompressionSettings #: 5
    TC_HDR: TextureCompressionSettings #: 6
    TC_EDITOR_ICON: TextureCompressionSettings #: 7
    TC_ALPHA: TextureCompressionSettings #: 8
    TC_DISTANCE_FIELD_FONT: TextureCompressionSettings #: 9
    TC_HDR_COMPRESSED: TextureCompressionSettings #: 10
    TC_BC7: TextureCompressionSettings #: 11
    TC_HALF_FLOAT: TextureCompressionSettings #: 12
    TC_SINGLE_FLOAT: TextureCompressionSettings #: 15
    TC_HDR_F32: TextureCompressionSettings #: 16
    ...

class TextureMipLoadOptions(EnumBase):
    r"""
    ETexture Mip Load Options
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    DEFAULT: TextureMipLoadOptions #: 0: Fallback to the LODGroup settings
    ALL_MIPS: TextureMipLoadOptions #: 1: Load all mips.
    ONLY_FIRST_MIP: TextureMipLoadOptions #: 2: Load only the first mip.
    ...

class TextureCookPlatformTilingSettings(EnumBase):
    r"""
    Texture Cook Platform Tiling Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    TCPTS_FROM_TEXTURE_GROUP: TextureCookPlatformTilingSettings #: 0: Get the tiling setting from the texture's group CookPlatformTilingDisabled setting. By default it's to tile during cook, unless it has been changed in the texture group
    TCPTS_TILE: TextureCookPlatformTilingSettings #: 1: The texture will be tiled during the cook process if the platform supports it.
    TCPTS_DO_NOT_TILE: TextureCookPlatformTilingSettings #: 2: The texture will not be tiled during the cook process, and will be tiled when uploaded to the GPU if the platform supports it.
    ...

class TextureGroup(EnumBase):
    r"""
    
    warning:: if this is changed: update BaseEngine.ini [SystemSettings] you might have to update the update Game's DefaultEngine.ini [SystemSettings] order and actual name can never change (order is important!) TEXTUREGROUP_Cinematic: should be used for Cinematics which will be baked out and want to have the highest settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    TEXTUREGROUP_WORLD: TextureGroup #: 0
    TEXTUREGROUP_WORLD_NORMAL_MAP: TextureGroup #: 1
    TEXTUREGROUP_WORLD_SPECULAR: TextureGroup #: 2
    TEXTUREGROUP_CHARACTER: TextureGroup #: 3
    TEXTUREGROUP_CHARACTER_NORMAL_MAP: TextureGroup #: 4
    TEXTUREGROUP_CHARACTER_SPECULAR: TextureGroup #: 5
    TEXTUREGROUP_WEAPON: TextureGroup #: 6
    TEXTUREGROUP_WEAPON_NORMAL_MAP: TextureGroup #: 7
    TEXTUREGROUP_WEAPON_SPECULAR: TextureGroup #: 8
    TEXTUREGROUP_VEHICLE: TextureGroup #: 9
    TEXTUREGROUP_VEHICLE_NORMAL_MAP: TextureGroup #: 10
    TEXTUREGROUP_VEHICLE_SPECULAR: TextureGroup #: 11
    TEXTUREGROUP_CINEMATIC: TextureGroup #: 12
    TEXTUREGROUP_EFFECTS: TextureGroup #: 13
    TEXTUREGROUP_EFFECTS_NOT_FILTERED: TextureGroup #: 14
    TEXTUREGROUP_SKYBOX: TextureGroup #: 15
    TEXTUREGROUP_UI: TextureGroup #: 16
    TEXTUREGROUP_LIGHTMAP: TextureGroup #: 17
    TEXTUREGROUP_RENDER_TARGET: TextureGroup #: 18
    TEXTUREGROUP_MOBILE_FLATTENED: TextureGroup #: 19
    TEXTUREGROUP_PROC_BUILDING_FACE: TextureGroup #: 20: Obsolete - kept for backwards compatibility.
    TEXTUREGROUP_PROC_BUILDING_LIGHT_MAP: TextureGroup #: 21: Obsolete - kept for backwards compatibility.
    TEXTUREGROUP_SHADOWMAP: TextureGroup #: 22
    TEXTUREGROUP_COLOR_LOOKUP_TABLE: TextureGroup #: 23: No compression, no mips.
    TEXTUREGROUP_TERRAIN_HEIGHTMAP: TextureGroup #: 24
    TEXTUREGROUP_TERRAIN_WEIGHTMAP: TextureGroup #: 25
    TEXTUREGROUP_BOKEH: TextureGroup #: 26: Using this TextureGroup triggers special mip map generation code only useful for the BokehDOF post process.
    TEXTUREGROUP_IES_LIGHT_PROFILE: TextureGroup #: 27: No compression, created on import of a .IES file.
    TEXTUREGROUP_PIXELS2D: TextureGroup #: 28: Non-filtered, useful for 2D rendering.
    TEXTUREGROUP_HIERARCHICAL_LOD: TextureGroup #: 29: Hierarchical LOD generated textures
    TEXTUREGROUP_IMPOSTOR: TextureGroup #: 30: Impostor Color Textures
    TEXTUREGROUP_IMPOSTOR_NORMAL_DEPTH: TextureGroup #: 31: Impostor Normal and Depth, use default compression
    TEXTUREGROUP_8_BIT_DATA: TextureGroup #: 32: 8 bit data stored in textures
    TEXTUREGROUP_16_BIT_DATA: TextureGroup #: 33: 16 bit data stored in textures
    TEXTUREGROUP_PROJECT01: TextureGroup #: 34: Project specific group, rename in Engine.ini, [EnumRemap] TEXTUREGROUP_Project**.DisplayName=My Fun Group
    TEXTUREGROUP_PROJECT02: TextureGroup #: 35
    TEXTUREGROUP_PROJECT03: TextureGroup #: 36
    TEXTUREGROUP_PROJECT04: TextureGroup #: 37
    TEXTUREGROUP_PROJECT05: TextureGroup #: 38
    TEXTUREGROUP_PROJECT06: TextureGroup #: 39
    TEXTUREGROUP_PROJECT07: TextureGroup #: 40
    TEXTUREGROUP_PROJECT08: TextureGroup #: 41
    TEXTUREGROUP_PROJECT09: TextureGroup #: 42
    TEXTUREGROUP_PROJECT10: TextureGroup #: 43
    TEXTUREGROUP_PROJECT11: TextureGroup #: 44
    TEXTUREGROUP_PROJECT12: TextureGroup #: 45
    TEXTUREGROUP_PROJECT13: TextureGroup #: 46
    TEXTUREGROUP_PROJECT14: TextureGroup #: 47
    TEXTUREGROUP_PROJECT15: TextureGroup #: 48
    TEXTUREGROUP_PROJECT16: TextureGroup #: 49
    TEXTUREGROUP_PROJECT17: TextureGroup #: 50
    TEXTUREGROUP_PROJECT18: TextureGroup #: 51
    TEXTUREGROUP_PROJECT19: TextureGroup #: 52
    TEXTUREGROUP_PROJECT20: TextureGroup #: 53
    TEXTUREGROUP_PROJECT21: TextureGroup #: 54
    TEXTUREGROUP_PROJECT22: TextureGroup #: 55
    TEXTUREGROUP_PROJECT23: TextureGroup #: 56
    TEXTUREGROUP_PROJECT24: TextureGroup #: 57
    TEXTUREGROUP_PROJECT25: TextureGroup #: 58
    TEXTUREGROUP_PROJECT26: TextureGroup #: 59
    TEXTUREGROUP_PROJECT27: TextureGroup #: 60
    TEXTUREGROUP_PROJECT28: TextureGroup #: 61
    TEXTUREGROUP_PROJECT29: TextureGroup #: 62
    TEXTUREGROUP_PROJECT30: TextureGroup #: 63
    TEXTUREGROUP_PROJECT31: TextureGroup #: 64
    TEXTUREGROUP_PROJECT32: TextureGroup #: 65
    ...

class TextureDownscaleOptions(EnumBase):
    r"""
    ETexture Downscale Options
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    DEFAULT: TextureDownscaleOptions #: 0: Fallback to the "texture group" settings
    UNFILTERED: TextureDownscaleOptions #: 1: Unfiltered
    SIMPLE_AVERAGE: TextureDownscaleOptions #: 2: Average, default for the "texture group"
    SHARPEN0: TextureDownscaleOptions #: 3: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    SHARPEN1: TextureDownscaleOptions #: 4: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    SHARPEN2: TextureDownscaleOptions #: 5: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    SHARPEN3: TextureDownscaleOptions #: 6: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    SHARPEN4: TextureDownscaleOptions #: 7: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    SHARPEN5: TextureDownscaleOptions #: 8: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    SHARPEN6: TextureDownscaleOptions #: 9: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    SHARPEN7: TextureDownscaleOptions #: 10: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    SHARPEN8: TextureDownscaleOptions #: 11: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    SHARPEN9: TextureDownscaleOptions #: 12: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    SHARPEN10: TextureDownscaleOptions #: 13: 8x8 with sharpening: 0=no sharpening but better quality which is softer, 1=little, 5=medium, 10=extreme.
    ...

class TextureAvailability(EnumBase):
    r"""
    ETexture Availability
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureDefines.h
    
    """

    GPU: TextureAvailability #: 0
    CPU: TextureAvailability #: 1
    ...

class MediaTextureOutputFormat(EnumBase):
    r"""
    Media Texture Output Format
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaTexture.h
    
    """

    MTOF_DEFAULT: MediaTextureOutputFormat #: 0
    MTOF_SRGB_LINOUT: MediaTextureOutputFormat #: 1
    ...

class MediaTextureOrientation(EnumBase):
    r"""
    Media Texture Orientation
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaTexture.h
    
    """

    MTORI_ORIGINAL: MediaTextureOrientation #: 0
    MTORI_CW90: MediaTextureOrientation #: 1
    MTORI_CW180: MediaTextureOrientation #: 2
    MTORI_CW270: MediaTextureOrientation #: 3
    ...

class MediaSoundChannels(EnumBase):
    r"""
    Available media sound channel types.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaSoundComponent.h
    
    """

    MONO: MediaSoundChannels #: 0: Mono (1 channel).
    STEREO: MediaSoundChannels #: 1: Stereo (2 channels).
    SURROUND: MediaSoundChannels #: 2: Surround sound (7.1 channels; for UI).
    ...

class BlueprintType(EnumBase):
    r"""
    Enumerates types of blueprints.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Blueprint.h
    
    """

    BPTYPE_NORMAL: BlueprintType #: 0: Normal blueprint.
    BPTYPE_CONST: BlueprintType #: 1: Blueprint that is const during execution (no state graph and methods cannot modify member variables).
    BPTYPE_MACRO_LIBRARY: BlueprintType #: 2: Blueprint that serves as a container for macros to be used in other blueprints.
    BPTYPE_INTERFACE: BlueprintType #: 3: Blueprint that serves as an interface to be implemented by other blueprints.
    BPTYPE_LEVEL_SCRIPT: BlueprintType #: 4: Blueprint that handles level scripting.
    BPTYPE_FUNCTION_LIBRARY: BlueprintType #: 5: Blueprint that serves as a container for functions to be used in other blueprints.
    ...

class AssetTypeActivationOpenedMethod(EnumBase):
    r"""
    (jcotton) This enum has been extracted into a separate header as it would ideally live in IAssetTypeActions.h or AssetTypeActions_Base.h,
    however these files are included without module linking (IncludePathModuleNames) in several other modules which makes adding a UENUM() not
    possible without refactoring.
    // Types of permissions allowed when attempting to open an asset in editor via activation (EAssetTypeActivationMethod)
    
    **C++ Source:**
    
    - **Module**: AssetTools
    - **File**: AssetTypeActivationOpenedMethod.h
    
    """

    EDIT: AssetTypeActivationOpenedMethod #: 0
    VIEW: AssetTypeActivationOpenedMethod #: 1
    ...

class ReloadPackagesInteractionMode(EnumBase):
    r"""
    EReload Packages Interaction Mode
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PackageTools.h
    
    """

    INTERACTIVE: ReloadPackagesInteractionMode #: 0: Interactive, ask the user what to do
    ASSUME_POSITIVE: ReloadPackagesInteractionMode #: 1: Non-interactive, assume a positive response
    ASSUME_NEGATIVE: ReloadPackagesInteractionMode #: 2: Non-interactive, assume a negative response
    ...

class MaterialDomain(EnumBase):
    r"""
    Defines the domain of a material.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialDomain.h
    
    """

    MD_SURFACE: MaterialDomain #: 0: The material's attributes describe a 3d surface.
    MD_DEFERRED_DECAL: MaterialDomain #: 1: The material's attributes describe a deferred decal, and will be mapped onto the decal's frustum.
    MD_LIGHT_FUNCTION: MaterialDomain #: 2: The material's attributes describe a light's distribution.
    MD_VOLUME: MaterialDomain #: 3: The material's attributes describe a 3d volume.
    MD_POST_PROCESS: MaterialDomain #: 4: The material will be used in a custom post process pass.
    MD_UI: MaterialDomain #: 5: The material will be used for UMG or Slate UI
    ...

class DecalBlendMode(EnumBase):
    r"""
    Defines how the GBuffer channels are getting manipulated by a decal material pass. Actual index is used to control shader parameters so don't change order.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Material.h
    
    """

    DBM_TRANSLUCENT: DecalBlendMode #: 0: Blend full material, updating the GBuffer, does not work for baked lighting.
    DBM_STAIN: DecalBlendMode #: 1: Modulate BaseColor, blend rest, updating the GBuffer, does not work for baked lighting. Does not work in DBuffer mode (approximated as Translucent).
    DBM_NORMAL: DecalBlendMode #: 2: Only blend normal, updating the GBuffer, does not work for baked lighting.
    DBM_EMISSIVE: DecalBlendMode #: 3: Additive emissive only.
    DBM_D_BUFFER_COLOR_NORMAL_ROUGHNESS: DecalBlendMode #: 4: Put into DBuffer to work for baked lighting as well (becomes DBM_TranslucentNormal if normal is not hooked up).
    DBM_D_BUFFER_COLOR: DecalBlendMode #: 5: Put into DBuffer to work for baked lighting as well.
    DBM_D_BUFFER_COLOR_NORMAL: DecalBlendMode #: 6: Put into DBuffer to work for baked lighting as well (becomes DBM_DBuffer_Color if normal is not hooked up).
    DBM_D_BUFFER_COLOR_ROUGHNESS: DecalBlendMode #: 7: Put into DBuffer to work for baked lighting as well.
    DBM_D_BUFFER_NORMAL: DecalBlendMode #: 8: Put into DBuffer to work for baked lighting as well.
    DBM_D_BUFFER_NORMAL_ROUGHNESS: DecalBlendMode #: 9: Put into DBuffer to work for baked lighting as well (becomes DBM_DBuffer_Roughness if normal is not hooked up).
    DBM_D_BUFFER_ROUGHNESS: DecalBlendMode #: 10: Put into DBuffer to work for baked lighting as well.
    DBM_VOLUMETRIC_DISTANCE_FUNCTION: DecalBlendMode #: 14: Output signed distance in Opacity depending on LightVector. Note: Can be costly, no shadow casting but receiving, no per pixel normal yet, no quality settings yet
    DBM_ALPHA_COMPOSITE: DecalBlendMode #: 15: Blend with existing scene color. Decal color is already pre-multiplied by alpha.
    DBM_AMBIENT_OCCLUSION: DecalBlendMode #: 16: Ambient occlusion.
    ...

class MaterialDecalResponse(EnumBase):
    r"""
    Defines how the material reacts on DBuffer decals, later we can expose more variants between None and Default.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Material.h
    
    """

    MDR_NONE: MaterialDecalResponse #: 0: Do not receive decals (Later we still can read the DBuffer channels to customize the effect, this frees up some interpolators).
    MDR_COLOR_NORMAL_ROUGHNESS: MaterialDecalResponse #: 1: Receive Decals, applies all DBuffer channels.
    MDR_COLOR: MaterialDecalResponse #: 2: Receive Decals, applies color DBuffer channels.
    MDR_COLOR_NORMAL: MaterialDecalResponse #: 3: Receive Decals, applies color and normal DBuffer channels.
    MDR_COLOR_ROUGHNESS: MaterialDecalResponse #: 4: Receive Decals, applies color, roughness, specular and metallic DBuffer channels.
    MDR_NORMAL: MaterialDecalResponse #: 5: Receive Decals, applies normal DBuffer channels.
    MDR_NORMAL_ROUGHNESS: MaterialDecalResponse #: 6: Receive Decals, applies normal, roughness, specular and metallic DBuffer channels.
    MDR_ROUGHNESS: MaterialDecalResponse #: 7: Receive Decals, applies roughness, specular and metallic DBuffer channels.
    ...

class MaterialShadingModel(EnumBase):
    r"""
    Specifies the overal rendering/shading model for a material
    warning: Check UMaterialInstance::Serialize if changed!
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    MSM_UNLIT: MaterialShadingModel #: 0
    MSM_DEFAULT_LIT: MaterialShadingModel #: 1
    MSM_SUBSURFACE: MaterialShadingModel #: 2
    MSM_PREINTEGRATED_SKIN: MaterialShadingModel #: 3
    MSM_CLEAR_COAT: MaterialShadingModel #: 4
    MSM_SUBSURFACE_PROFILE: MaterialShadingModel #: 5
    MSM_TWO_SIDED_FOLIAGE: MaterialShadingModel #: 6
    MSM_HAIR: MaterialShadingModel #: 7
    MSM_CLOTH: MaterialShadingModel #: 8
    MSM_EYE: MaterialShadingModel #: 9
    MSM_SINGLE_LAYER_WATER: MaterialShadingModel #: 10
    MSM_THIN_TRANSLUCENT: MaterialShadingModel #: 11
    MSM_FROM_MATERIAL_EXPRESSION: MaterialShadingModel
    r"""
    14: Shading model will be determined by the Material Expression Graph,
                  by utilizing the 'Shading Model' MaterialAttribute output pin.
    """

    ...

class MaterialLightingModel(EnumBase):
    r"""
    deprecated: 'MaterialLightingModel' was renamed to 'MaterialShadingModel'.
    """

    MSM_UNLIT: MaterialLightingModel #: 0
    MSM_DEFAULT_LIT: MaterialLightingModel #: 1
    MSM_SUBSURFACE: MaterialLightingModel #: 2
    MSM_PREINTEGRATED_SKIN: MaterialLightingModel #: 3
    MSM_CLEAR_COAT: MaterialLightingModel #: 4
    MSM_SUBSURFACE_PROFILE: MaterialLightingModel #: 5
    MSM_TWO_SIDED_FOLIAGE: MaterialLightingModel #: 6
    MSM_HAIR: MaterialLightingModel #: 7
    MSM_CLOTH: MaterialLightingModel #: 8
    MSM_EYE: MaterialLightingModel #: 9
    MSM_SINGLE_LAYER_WATER: MaterialLightingModel #: 10
    MSM_THIN_TRANSLUCENT: MaterialLightingModel #: 11
    MSM_FROM_MATERIAL_EXPRESSION: MaterialLightingModel
    r"""
    14: Shading model will be determined by the Material Expression Graph,
                  by utilizing the 'Shading Model' MaterialAttribute output pin.
    """

    ...

class MaterialTranslucencyPass(EnumBase):
    r"""
    Specifies which separate translucency pass to render in.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Material.h
    
    """

    MTP_BEFORE_DOF: MaterialTranslucencyPass #: 0: Render before depth of field.
    MTP_AFTER_DOF: MaterialTranslucencyPass #: 1: Render after depth of field.
    MTP_AFTER_MOTION_BLUR: MaterialTranslucencyPass #: 2: Render after motion blur. Disables depth test (the reconstruction post MB and TSR would otherwise flicker due to the TSR camera jittering making the depth buffer unstable). Because of that Lumen high quality reflections is also disabled to avoid visual discrepancy at depth intersection.
    ...

class TranslucencyLightingMode(EnumBase):
    r"""
    Describes how to handle lighting of translucent objets
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    TLM_VOLUMETRIC_NON_DIRECTIONAL: TranslucencyLightingMode
    r"""
    0: Lighting will be calculated for a volume, without directionality.  Use this on particle effects like smoke and dust.
    This is the cheapest per-pixel lighting method, however the material normal is not taken into account.
    """

    TLM_VOLUMETRIC_DIRECTIONAL: TranslucencyLightingMode
    r"""
    1: Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account.
    Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space.
    """

    TLM_VOLUMETRIC_PER_VERTEX_NON_DIRECTIONAL: TranslucencyLightingMode
    r"""
    2: Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less.
    Note that lighting still comes from a volume texture, so it is limited in range.  Directional lights become unshadowed in the distance.
    """

    TLM_VOLUMETRIC_PER_VERTEX_DIRECTIONAL: TranslucencyLightingMode
    r"""
    3: Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less.
    Note that lighting still comes from a volume texture, so it is limited in range.  Directional lights become unshadowed in the distance.
    """

    TLM_SURFACE: TranslucencyLightingMode
    r"""
    4: Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry,
    limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water.
    Only diffuse lighting is supported.
    """

    TLM_SURFACE_PER_PIXEL_LIGHTING: TranslucencyLightingMode
    r"""
    5: Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water.
    This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not.
    This is the most expensive translucency lighting method as each light's contribution is computed per-pixel.
    """

    ...

class MaterialFloatPrecisionMode(EnumBase):
    r"""
    The default float precision for material's pixel shaders on mobile devices
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    MFPM_DEFAULT: MaterialFloatPrecisionMode #: 0: Uses project based precision mode setting
    MFPM_FULL_MATERIAL_EXPRESSION_ONLY: MaterialFloatPrecisionMode #: 1: Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf
    MFPM_FULL: MaterialFloatPrecisionMode #: 2: All the floats are full-precision
    MFPM_HALF: MaterialFloatPrecisionMode #: 3: Half precision, except explict 'float' in .ush/.usf
    ...

class MaterialShadingRate(EnumBase):
    r"""
    EMaterial Shading Rate
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    MSR_1X1: MaterialShadingRate #: 0
    MSR_2X1: MaterialShadingRate #: 1
    MSR_1X2: MaterialShadingRate #: 2
    MSR_2X2: MaterialShadingRate #: 3
    MSR_4X2: MaterialShadingRate #: 4
    MSR_2X4: MaterialShadingRate #: 5
    MSR_4X4: MaterialShadingRate #: 6
    ...

class BlendableLocation(EnumBase):
    r"""
    Where to place a post process material in the post processing chain.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendableInterface.h
    
    """

    BL_SCENE_COLOR_BEFORE_DOF: BlendableLocation
    r"""
    2: Post process material location to modify the scene color, between translucency distortion and DOF.
    Always run at rendering resolution.
    Inputs and output always in linear color space.
    
    Input0:former pass scene color, excluding AfterDOF translucency
    Input1:AfterDOF translucency.
    """

    BL_SCENE_COLOR_AFTER_DOF: BlendableLocation
    r"""
    1: Post process material location to modify the scene color, between DOF and AfterDOF translucency.
    Always run at rendering resolution.
    Inputs and output always in linear color space.
    
    Input0:former pass scene color, excluding AfterDOF translucency
    Input1:AfterDOF translucency.
    """

    BL_TRANSLUCENCY_AFTER_DOF: BlendableLocation
    r"""
    5: Post process material location to modify the AfterDOF translucency, before composition into the scene color.
    Always run at rendering resolution.
    Inputs and output always in linear color space.
    
    Input0:scene color without translucency, after DOF,
    Input1:AfterDOF translucency.
    """

    BL_SSR_INPUT: BlendableLocation
    r"""
    4: Post process material location to compose a backplate into SSR, between TSR/TAA and next frame's SSR.
    Runs at display resolution with TSR or TAAU, rendering resolution otherwise.
    Inputs and output always in linear color space.
    
    Input0:TAA/TSR output,
    """

    BL_SCENE_COLOR_BEFORE_BLOOM: BlendableLocation
    r"""
    6: Post process material location to modify the scene color, before bloom.
    Runs at display resolution with TSR or TAAU, rendering resolution otherwise.
    Inputs and output always in linear color space.
    
    Input0:former pass scene color,
    """

    BL_REPLACING_TONEMAPPER: BlendableLocation
    r"""
    3: Post process material replacing the tone mapper, to modify the scene color.
    Runs at display resolution with TSR or TAAU, rendering resolution otherwise.
    Inputs are always linear color space.
    
    Input0:former pass scene color,
    Input1:AfterDOF translucency.
    """

    BL_SCENE_COLOR_AFTER_TONEMAPPING: BlendableLocation
    r"""
    0: Post process material location to modify the scene color, after tone mapper.
    Runs at display resolution with TSR or TAAU, rendering resolution otherwise.
    Inputs and output in different color spaces, based rendering settings for instance (sRGB/Rec709, HDR or even Linear Color).
    
    Input0:former pass scene color,
    Input1:AfterDOF translucency.
    """

    ...

class MaterialStencilCompare(EnumBase):
    r"""
    EMaterial Stencil Compare
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    MSC_LESS: MaterialStencilCompare #: 0
    MSC_LESS_EQUAL: MaterialStencilCompare #: 1
    MSC_GREATER: MaterialStencilCompare #: 2
    MSC_GREATER_EQUAL: MaterialStencilCompare #: 3
    MSC_EQUAL: MaterialStencilCompare #: 4
    MSC_NOT_EQUAL: MaterialStencilCompare #: 5
    MSC_NEVER: MaterialStencilCompare #: 6
    MSC_ALWAYS: MaterialStencilCompare #: 7
    ...

class RefractionMode(EnumBase):
    r"""
    Determines how the refraction offset should be computed for the material.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    RM_INDEX_OF_REFRACTION: RefractionMode
    r"""
    0: By default, when the root node refraction pin is unplugged, relies on the material IOR evaluated from F0.
    Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input.
    The new medium's surface is defined by the material's normal.  With this mode, a flat plane seen from the side will have a constant refraction offset.
    This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water.
    """

    RM_PIXEL_NORMAL_OFFSET: RefractionMode
    r"""
    1: By default, when the root node refraction pin is unplugged, no refraction will appear.
    The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal.
    With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction.  This mode is only valid with tangent space normals.
    The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset.
    This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color.
    """

    RM_2D_OFFSET: RefractionMode
    r"""
    2: By default, when the root node refraction pin is unplugged, no refraction will appear.
    Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading.
    """

    RM_NONE: RefractionMode #: 3: Refraction is disabled.
    ...

class RefractionCoverageMode(EnumBase):
    r"""
    Determines how the refraction account for the coverage with Substrate. It can only be used when Substrate is enabled.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    RCM_COVERAGE_IGNORED: RefractionCoverageMode
    r"""
    0: This is the pre-Substrate behavior: coverage is ignored and always 1.
    When rough refraction is disabled, this is behavior is forced ON.
    """

    RCM_COVERAGE_ACCOUNTED_FOR: RefractionCoverageMode
    r"""
    1: This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth.
    This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage),
    while the blurred version will be visible according to coverage.
    """

    ...

class PropertyEditorTestEnum(EnumBase):
    r"""
    EProperty Editor Test Enum
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    """

    PROPERTY_EDITOR_TEST_ENUM2: PropertyEditorTestEnum #: 1: This comment should appear above enum 2
    PROPERTY_EDITOR_TEST_ENUM4: PropertyEditorTestEnum #: 3: This comment should appear above enum 4
    PROPERTY_EDITOR_TEST_ENUM6: PropertyEditorTestEnum #: 5: This comment should appear above enum 6
    ...

class PropertyEditorTestEditColor(EnumBase):
    r"""
    EProperty Editor Test Edit Color
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    """

    RED: PropertyEditorTestEditColor #: 0
    ORANGE: PropertyEditorTestEditColor #: 1
    YELLOW: PropertyEditorTestEditColor #: 2
    GREEN: PropertyEditorTestEditColor #: 3
    BLUE: PropertyEditorTestEditColor #: 4
    VIOLET: PropertyEditorTestEditColor #: 6
    PINK: PropertyEditorTestEditColor #: 7
    MAGENTA: PropertyEditorTestEditColor #: 8
    CYAN: PropertyEditorTestEditColor #: 9
    ...

class PropertyEditorTestUnderscores(EnumBase):
    r"""
    EProperty Editor Test Underscores
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    """

    ONE: PropertyEditorTestUnderscores #: 0
    TWO: PropertyEditorTestUnderscores #: 1
    THREE: PropertyEditorTestUnderscores #: 2
    NOT_UNDERSCORE: PropertyEditorTestUnderscores #: 3
    ...

class FoliageScaling(EnumBase):
    r"""
    EFoliage Scaling
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: FoliageType.h
    
    """

    UNIFORM: FoliageScaling #: 0: Foliage instances will have uniform X,Y and Z scales.
    FREE: FoliageScaling #: 1: Foliage instances will have random X,Y and Z scales.
    LOCK_XY: FoliageScaling #: 2: Locks the X and Y axis scale.
    LOCK_XZ: FoliageScaling #: 3: Locks the X and Z axis scale.
    LOCK_YZ: FoliageScaling #: 4: Locks the Y and Z axis scale.
    ...

class HasCustomNavigableGeometry(EnumBase):
    r"""
    Determines if a NavRelevant object contains custom collision for navigation/AI
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavRelevantInterface.h
    
    """

    NO: HasCustomNavigableGeometry #: 0: Primitive doesn't have custom navigation geometry, if collision is enabled then its convex/trimesh collision will be used for generating the navmesh
    YES: HasCustomNavigableGeometry #: 1: If primitive would normally affect navmesh, DoCustomNavigableGeometryExport() should be called to export this primitive's navigable geometry
    EVEN_IF_NOT_COLLIDABLE: HasCustomNavigableGeometry #: 2: DoCustomNavigableGeometryExport() should be called even if the mesh is non-collidable and wouldn't normally affect the navmesh
    DONT_EXPORT: HasCustomNavigableGeometry #: 3: Don't export navigable geometry even if primitive is relevant for navigation (can still add modifiers)
    ...

class NavDataGatheringMode(EnumBase):
    r"""
    ENav Data Gathering Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavDataGatheringMode.h
    
    """

    DEFAULT: NavDataGatheringMode #: 0
    INSTANT: NavDataGatheringMode #: 1
    LAZY: NavDataGatheringMode #: 2
    ...

class LandscapeHLODTextureSizePolicy(EnumBase):
    r"""
    ELandscape HLODTexture Size Policy
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeProxy.h
    
    """

    AUTOMATIC_SIZE: LandscapeHLODTextureSizePolicy #: 0: Automatic texture size, based on the expected HLOD draw distance and the landscape size.
    SPECIFIC_SIZE: LandscapeHLODTextureSizePolicy #: 1: User specified texture size.
    ...

class LandscapeHLODMeshSourceLODPolicy(EnumBase):
    r"""
    ELandscape HLODMesh Source LODPolicy
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeProxy.h
    
    """

    AUTOMATIC_LOD: LandscapeHLODMeshSourceLODPolicy #: 0: Automatic LOD selection, based on the expected HLOD draw distance and the landscape LOD Distribution settings.
    SPECIFIC_LOD: LandscapeHLODMeshSourceLODPolicy #: 1: User specified landscape LOD.
    LOWEST_DETAIL_LOD: LandscapeHLODMeshSourceLODPolicy #: 2: Use the lowest detailed LOD of this landscape.
    ...

class SplineModulationColorMask(EnumBase):
    r"""
    ESpline Modulation Color Mask
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeLayerInfoObject.h
    
    """

    RED: SplineModulationColorMask #: 0
    GREEN: SplineModulationColorMask #: 1
    BLUE: SplineModulationColorMask #: 2
    ALPHA: SplineModulationColorMask #: 3
    ...

class TerrainCoordMappingType(EnumBase):
    r"""
    ETerrain Coord Mapping Type
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeLayerCoords.h
    
    """

    TCMT_AUTO: TerrainCoordMappingType #: 0
    TCMT_XY: TerrainCoordMappingType #: 1
    TCMT_XZ: TerrainCoordMappingType #: 2
    TCMT_YZ: TerrainCoordMappingType #: 3
    ...

class LandscapeCustomizedCoordType(EnumBase):
    r"""
    ELandscape Customized Coord Type
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeLayerCoords.h
    
    """

    LCCT_NONE: LandscapeCustomizedCoordType #: 0: Don't use customized UV, just use original UV.
    LCCT_CUSTOM_UV0: LandscapeCustomizedCoordType #: 1
    LCCT_CUSTOM_UV1: LandscapeCustomizedCoordType #: 2
    LCCT_CUSTOM_UV2: LandscapeCustomizedCoordType #: 3
    LCCT_WEIGHT_MAP_UV: LandscapeCustomizedCoordType #: 4: Use original WeightMapUV, which could not be customized.
    ...

class NotifyTriggerMode(EnumBase):
    r"""
    ENotify Trigger Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace.h
    
    """

    ALL_ANIMATIONS: NotifyTriggerMode #: 0
    HIGHEST_WEIGHTED_ANIMATION: NotifyTriggerMode #: 1
    NONE: NotifyTriggerMode #: 2
    ...

class PreferredTriangulationDirection(EnumBase):
    r"""
    EPreferred Triangulation Direction
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace.h
    
    """

    NONE: PreferredTriangulationDirection #: 0: None
    TANGENTIAL: PreferredTriangulationDirection #: 1: When there is ambiguity, rectangles will be split so that the inserted edge tends to not point towards the origin
    RADIAL: PreferredTriangulationDirection #: 2: When there is ambiguity, rectangles will be split so that the inserted edge tends to point towards the origin
    ...

class BlendSpacePerBoneBlendMode(EnumBase):
    r"""
    EBlend Space Per Bone Blend Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace.h
    
    """

    MANUAL_PER_BONE_OVERRIDE: BlendSpacePerBoneBlendMode #: 0: Manually specify the bones and their smoothing interpolation times.
    BLEND_PROFILE: BlendSpacePerBoneBlendMode #: 1: Use a blend profile to specify the bone smoothing interpolation times.
    ...

class BlendSpaceAxis(EnumBase):
    r"""
    Interpolation data types.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace.h
    
    """

    BSA_NONE: BlendSpaceAxis #: 0
    BSA_X: BlendSpaceAxis #: 1
    BSA_Y: BlendSpaceAxis #: 2
    ...

class ReflectionSourceType(EnumBase):
    r"""
    EReflection Source Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ReflectionCaptureComponent.h
    
    """

    CAPTURED_SCENE: ReflectionSourceType #: 0: Construct the reflection source from the captured scene
    SPECIFIED_CUBEMAP: ReflectionSourceType #: 1: Construct the reflection source from the specified cubemap.
    ...

class StreamingVolumeUsage(EnumBase):
    r"""
    Enum for different usage cases of level streaming volumes.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelStreamingVolume.h
    
    """

    SVB_LOADING: StreamingVolumeUsage #: 0
    SVB_LOADING_AND_VISIBILITY: StreamingVolumeUsage #: 1
    SVB_VISIBILITY_BLOCKING_ON_LOAD: StreamingVolumeUsage #: 2
    SVB_BLOCKING_ON_LOAD: StreamingVolumeUsage #: 3
    SVB_LOADING_NOT_VISIBLE: StreamingVolumeUsage #: 4
    ...

class CastRayTracedShadow(EnumBase):
    r"""
    Ray Tracing Shadows type.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    DISABLED: CastRayTracedShadow #: 0: Ray traced shadows disabled for this light
    USE_PROJECT_SETTING: CastRayTracedShadow #: 1: Ray traced shadows follow Cast Ray Traced Shadows project setting
    ENABLED: CastRayTracedShadow #: 2: Ray traced shadows enabled for this light
    ...

class PositionOrigin(EnumBase):
    r"""
    Specifies what reference point should be used
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpression.h
    
    """

    ABSOLUTE: PositionOrigin #: 0: Absolute world position, i.e. relative to (0,0,0)
    CAMERA_RELATIVE: PositionOrigin #: 1: Camera relative world position, i.e. translated world space
    ...

class TextureMipValueMode(EnumBase):
    r"""
    defines how MipValue is used
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    TMVM_NONE: TextureMipValueMode #: 0: Use hardware computed sample's mip level with automatic anisotropic filtering support.
    TMVM_MIP_LEVEL: TextureMipValueMode #: 1: Explicitly compute the sample's mip level. Disables anisotropic filtering.
    TMVM_MIP_BIAS: TextureMipValueMode #: 2: Bias the hardware computed sample's mip level. Disables anisotropic filtering.
    TMVM_DERIVATIVE: TextureMipValueMode #: 3: Explicitly compute the sample's DDX and DDY for anisotropic filtering.
    ...

class SamplerSourceMode(EnumBase):
    r"""
    Controls where the sampler for different texture lookups comes from
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    SSM_FROM_TEXTURE_ASSET: SamplerSourceMode #: 0: Get the sampler from the texture.  Every unique texture will consume a sampler slot, which are limited in number.
    SSM_WRAP_WORLD_GROUP_SETTINGS: SamplerSourceMode #: 1: Shared sampler source that does not consume a sampler slot.  Uses wrap addressing and gets filter mode from the world texture group.
    SSM_CLAMP_WORLD_GROUP_SETTINGS: SamplerSourceMode #: 2: Shared sampler source that does not consume a sampler slot.  Uses clamp addressing and gets filter mode from the world texture group.
    ...

class TextureColorChannel(EnumBase):
    r"""
    ETexture Color Channel
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionAntialiasedTextureMask.h
    
    """

    TCC_RED: TextureColorChannel #: 0
    TCC_GREEN: TextureColorChannel #: 1
    TCC_BLUE: TextureColorChannel #: 2
    TCC_ALPHA: TextureColorChannel #: 3
    ...

class MaterialAttributeBlend(EnumBase):
    r"""
    EMaterial Attribute Blend
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionBlendMaterialAttributes.h
    
    """

    BLEND: MaterialAttributeBlend #: 0
    USE_A: MaterialAttributeBlend #: 1
    USE_B: MaterialAttributeBlend #: 2
    ...

class MaterialExpressionBoundsType(EnumBase):
    r"""
    EMaterial Expression Bounds Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionBounds.h
    
    """

    MEILB_INSTANCE_LOCAL: MaterialExpressionBoundsType #: 0: Instance local
    MEILB_OBJECT_LOCAL: MaterialExpressionBoundsType #: 1: Object local
    MEILB_PRE_SKINNED_LOCAL: MaterialExpressionBoundsType #: 2: Skinned local
    ...

class ChannelMaskParameterColor(EnumBase):
    r"""
    EChannel Mask Parameter Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionChannelMaskParameterColor.h
    
    """

    RED: ChannelMaskParameterColor #: 0
    GREEN: ChannelMaskParameterColor #: 1
    BLUE: ChannelMaskParameterColor #: 2
    ALPHA: ChannelMaskParameterColor #: 3
    ...

class ClampMode(EnumBase):
    r"""
    EClamp Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionClamp.h
    
    """

    CMODE_CLAMP: ClampMode #: 0
    CMODE_CLAMP_MIN: ClampMode #: 1
    CMODE_CLAMP_MAX: ClampMode #: 2
    ...

class CustomMaterialOutputType(EnumBase):
    r"""
    ECustom Material Output Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCustom.h
    
    """

    CMOT_FLOAT1: CustomMaterialOutputType #: 0
    CMOT_FLOAT2: CustomMaterialOutputType #: 1
    CMOT_FLOAT3: CustomMaterialOutputType #: 2
    CMOT_FLOAT4: CustomMaterialOutputType #: 3
    CMOT_MATERIAL_ATTRIBUTES: CustomMaterialOutputType #: 4
    ...

class DBufferTextureId(EnumBase):
    r"""
    EDBuffer Texture Id
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDBufferTexture.h
    
    """

    DBT_A: DBufferTextureId #: 0: DBuffer A (Base Color). RGB is pre-multiplied by alpha. A is one minus alpha.
    DBT_B: DBufferTextureId #: 1: DBuffer B (World Normal). RGB is pre-multiplied by alpha. A is one minus alpha.
    DBT_C: DBufferTextureId #: 2: DBuffer C (Roughness). R is Roughness, G is Metallic, B is Specular,  all pre-multiplied by alpha. A is one minus alpha.
    ...

class DepthOfFieldFunctionValue(EnumBase):
    r"""
    Note: The index is used to map the enum to different code in the shader
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDepthOfFieldFunction.h
    
    """

    TDOF_NEAR_AND_FAR_MASK: DepthOfFieldFunctionValue #: 0: 0:in Focus .. 1:Near or Far.
    TDOF_NEAR_MASK: DepthOfFieldFunctionValue #: 1: 0:in Focus or Far .. 1:Near.
    TDOF_FAR_MASK: DepthOfFieldFunctionValue #: 2: 0:in Focus or Near .. 1:Far.
    TDOF_CIRCLE_OF_CONFUSION_RADIUS: DepthOfFieldFunctionValue #: 3: in pixels, only works for CircleDOF, use Abs for the actual radius as the sign of the value indicates near out of focus, positive indicates far out of focus
    ...

class NeuralIndexType(EnumBase):
    r"""
    ENeural Index Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionNeuralPostProcessNode.h
    
    """

    NIT_TEXTURE_INDEX: NeuralIndexType #: 0: Texture index UV in 0...1 range
    NIT_BUFFER_INDEX: NeuralIndexType #: 1: Buffer index UV in LayerId (batch) x Channels x Height x Wdith
    ...

class NoiseFunction(EnumBase):
    r"""
    ENoise Function
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionNoise.h
    
    """

    NOISEFUNCTION_SIMPLEX_TEX: NoiseFunction
    r"""
    0: High quality for direct use and bumps
    ~77 instructions per level, 4 texture lookups
    Cannot tile
    """

    NOISEFUNCTION_GRADIENT_TEX: NoiseFunction
    r"""
    1: High quality for direct use and bumps
    Non-tiled: ~61 instructions per level, 8 texture lookups
    Tiling: ~74 instructions per level, 8 texture lookups
    Even "non-tiled" mode has a repeat of 128. Useful Repeat Size range <= 128
    Formerly labeled as Perlin noise
    """

    NOISEFUNCTION_GRADIENT_TEX3D: NoiseFunction
    r"""
    2: High quality for direct use, BAD for bumps; doesn't work on Mobile
    ~16 instructions per level, 1 texture lookup
    Always tiles with a repeat of 16, "Tiling" mode is not an option for Fast Gradient noise
    """

    NOISEFUNCTION_GRADIENT_ALU: NoiseFunction
    r"""
    3: High quality for direct use and bumps
    Non-tiled: ~80 instructions per level, no textures
    Tiling: ~143 instructions per level, no textures
    """

    NOISEFUNCTION_VALUE_ALU: NoiseFunction
    r"""
    4: Low quality, but pure computation
    Non-tiled: ~53 instructions per level, no textures
    Tiling: ~118 instructions per level, no textures
    Formerly mis-labeled as Gradient noise
    """

    NOISEFUNCTION_VORONOI_ALU: NoiseFunction
    r"""
    5: Also known as Worley or Cellular noise
    Quality=1 searches 8 cells, Quality=2 searches 16 cells
    Quality=3 searches 27 cells, Quality=4 searches 32 cells
    All are about 20 instructions per cell searched
    """

    ...

class PathTracingBufferTextureId(EnumBase):
    r"""
    EPath Tracing Buffer Texture Id
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPathTracingBufferTexture.h
    
    """

    PTBT_RADIANCE: PathTracingBufferTextureId #: 0: Radiance (Path Tracing). The raw radiance.
    PTBT_DENOISED_RADIANCE: PathTracingBufferTextureId #: 1: Normal (Path Tracing). Stores the denoised radiance if denoising is turned on and complete for the current frame, otherwise, black.
    PTBT_ALBEDO: PathTracingBufferTextureId #: 2: Albedo (Path Tracing). Average albedo at the current sample count.
    PTBT_NORMAL: PathTracingBufferTextureId #: 3: Normal (Path Tracing). Average normal at the current sample count.
    PTBT_VARIANCE: PathTracingBufferTextureId
    r"""
    4: Variance (Path Tracing). Path tracing variance stored as standard derivation. Variance can be per channel variance or
                  variance of luminance, albedo, and normal based on the path tracing configuration. Hooking up this buffer can increase additional
                  cost.
    """

    ...

class RuntimeVirtualTextureMaterialType(EnumBase):
    r"""
    Enumeration of virtual texture stack layouts to support.
    Extend this enumeration with other layouts as required. For example we will probably want to add a displacement texture option.
    This "fixed function" approach will probably break down if we end up needing to support some complex set of attribute combinations but it is OK to begin with.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RuntimeVirtualTextureEnum.h
    
    """

    BASE_COLOR: RuntimeVirtualTextureMaterialType #: 0
    BASE_COLOR_NORMAL_ROUGHNESS: RuntimeVirtualTextureMaterialType #: 2: Local space Normal. Requires less memory than 'Base Color, Normal, Roughness, Specular'. Supports LQ compression.
    BASE_COLOR_NORMAL_SPECULAR: RuntimeVirtualTextureMaterialType #: 3
    BASE_COLOR_NORMAL_SPECULAR_Y_CO_CG: RuntimeVirtualTextureMaterialType #: 4: Base Color is stored in YCoCg space. This requires more memory but may provide better quality.
    BASE_COLOR_NORMAL_SPECULAR_MASK_Y_CO_CG: RuntimeVirtualTextureMaterialType #: 5: Base Color is stored in YCoCg space. This requires more memory but may provide better quality.
    WORLD_HEIGHT: RuntimeVirtualTextureMaterialType #: 6
    DISPLACEMENT: RuntimeVirtualTextureMaterialType #: 7
    ...

class RuntimeVirtualTextureMipValueMode(EnumBase):
    r"""
    Set how Mip levels are calculated.
    Internally we will convert to ETextureMipValueMode which is used by internal APIs.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRuntimeVirtualTextureSample.h
    
    """

    RVTMVM_NONE: RuntimeVirtualTextureMipValueMode #: 0: * Use default computed mip level. Takes into account UV scaling from using the WorldPosition pin.
    RVTMVM_MIP_LEVEL: RuntimeVirtualTextureMipValueMode
    r"""
    1: * Use an absolute mip level from the MipValue pin.
    * 0 is full resolution.
    """

    RVTMVM_MIP_BIAS: RuntimeVirtualTextureMipValueMode
    r"""
    2: * Bias the default computed mip level using the MipValue pin.
    * Negative values increase resolution.
    """

    RVTMVM_RECALCULATE_DERIVATIVES: RuntimeVirtualTextureMipValueMode
    r"""
    3: * This is like 'Default' but it ignores the WorldPosition pin when computing the mip level.
    * It uses the actual pixel WorldPosition instead.
    * This can prevent sampling mip 0 if the WorldPosition pin gives a constant value.
    """

    ...

class RuntimeVirtualTextureTextureAddressMode(EnumBase):
    r"""
    Defines texture addressing behavior.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRuntimeVirtualTextureSample.h
    
    """

    RVTTA_CLAMP: RuntimeVirtualTextureTextureAddressMode #: 0: Clamp mode.
    RVTTA_WRAP: RuntimeVirtualTextureTextureAddressMode #: 1: Wrap mode.
    ...

class MaterialSceneAttributeInputMode(EnumBase):
    r"""
    EMaterial Scene Attribute Input Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSceneColor.h
    
    """

    COORDINATES: MaterialSceneAttributeInputMode #: 0
    OFFSET_FRACTION: MaterialSceneAttributeInputMode #: 1
    ...

class SceneTextureId(EnumBase):
    r"""
    like EPassInputId but can expose more e.g. GBuffer
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialSceneTextureId.h
    
    """

    PPI_SCENE_COLOR: SceneTextureId #: 0: Scene color, normal post process passes should use PostProcessInput0
    PPI_SCENE_DEPTH: SceneTextureId #: 1: Scene depth, single channel, contains the linear depth of the opaque objects
    PPI_DIFFUSE_COLOR: SceneTextureId #: 2: Material diffuse, RGB color (computed from GBuffer)
    PPI_SPECULAR_COLOR: SceneTextureId #: 3: Material specular, RGB color (computed from GBuffer)
    PPI_SUBSURFACE_COLOR: SceneTextureId #: 4: Material subsurface, RGB color (GBuffer, only for some ShadingModels)
    PPI_BASE_COLOR: SceneTextureId #: 5: Material base, RGB color (GBuffer), can be modified on read by the ShadingModel, consider StoredBasedColor
    PPI_SPECULAR: SceneTextureId #: 6: Material specular, single channel (GBuffer), can be modified on read by the ShadingModel, consider StoredSpecular
    PPI_METALLIC: SceneTextureId #: 7: Material metallic, single channel (GBuffer)
    PPI_WORLD_NORMAL: SceneTextureId #: 8: Normal, RGB in -1..1 range, not normalized (GBuffer)
    PPI_SEPARATE_TRANSLUCENCY: SceneTextureId #: 9: Not yet supported
    PPI_OPACITY: SceneTextureId #: 10: Material opacity, single channel (GBuffer)
    PPI_ROUGHNESS: SceneTextureId #: 11: Material roughness, single channel (GBuffer)
    PPI_MATERIAL_AO: SceneTextureId #: 12: Material ambient occlusion, single channel (GBuffer)
    PPI_CUSTOM_DEPTH: SceneTextureId #: 13: Scene depth, single channel, contains the linear depth of the opaque objects rendered with CustomDepth (mesh property)
    PPI_POST_PROCESS_INPUT0: SceneTextureId #: 14: Input #0 of this postprocess pass, usually the only one hooked up
    PPI_POST_PROCESS_INPUT1: SceneTextureId #: 15: Input #1 of this postprocess pass, usually not used
    PPI_POST_PROCESS_INPUT2: SceneTextureId #: 16: Input #2 of this postprocess pass, usually not used
    PPI_POST_PROCESS_INPUT3: SceneTextureId #: 17: Input #3 of this postprocess pass, usually not used
    PPI_POST_PROCESS_INPUT4: SceneTextureId #: 18: Input #4 of this postprocess pass, usually not used
    PPI_POST_PROCESS_INPUT5: SceneTextureId #: 19: Input #5 of this postprocess pass, usually not used
    PPI_POST_PROCESS_INPUT6: SceneTextureId #: 20: Input #6 of this postprocess pass, usually not used
    PPI_DECAL_MASK: SceneTextureId #: 21: Decal Mask, single bit (was moved to stencil for better performance, not accessible at the moment)
    PPI_SHADING_MODEL_COLOR: SceneTextureId #: 22: Shading model
    PPI_SHADING_MODEL_ID: SceneTextureId #: 23: Shading model ID
    PPI_AMBIENT_OCCLUSION: SceneTextureId #: 24: Ambient Occlusion, single channel
    PPI_CUSTOM_STENCIL: SceneTextureId #: 25: Scene stencil, contains CustomStencil mesh property of the opaque objects rendered with CustomDepth
    PPI_STORED_BASE_COLOR: SceneTextureId #: 26: Material base, RGB color (GBuffer)
    PPI_STORED_SPECULAR: SceneTextureId #: 27: Material specular, single channel (GBuffer)
    PPI_VELOCITY: SceneTextureId #: 28: Scene Velocity
    PPI_WORLD_TANGENT: SceneTextureId #: 29: Tangent, RGB in -1..1 range, not normalized (GBuffer)
    PPI_ANISOTROPY: SceneTextureId #: 30: Material anisotropy, single channel (GBuffer)
    ...

class SpeedTreeGeometryType(EnumBase):
    r"""
    ESpeed Tree Geometry Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSpeedTree.h
    
    """

    STG_BRANCH: SpeedTreeGeometryType #: 0
    STG_FROND: SpeedTreeGeometryType #: 1
    STG_LEAF: SpeedTreeGeometryType #: 2
    STG_FACING_LEAF: SpeedTreeGeometryType #: 3
    STG_BILLBOARD: SpeedTreeGeometryType #: 4
    ...

class SpeedTreeWindType(EnumBase):
    r"""
    ESpeed Tree Wind Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSpeedTree.h
    
    """

    STW_NONE: SpeedTreeWindType #: 0
    STW_FASTEST: SpeedTreeWindType #: 1
    STW_FAST: SpeedTreeWindType #: 2
    STW_BETTER: SpeedTreeWindType #: 3
    STW_BEST: SpeedTreeWindType #: 4
    STW_PALM: SpeedTreeWindType #: 5
    STW_BEST_PLUS: SpeedTreeWindType #: 6
    ...

class SpeedTreeLODType(EnumBase):
    r"""
    ESpeed Tree LODType
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSpeedTree.h
    
    """

    STLOD_POP: SpeedTreeLODType #: 0
    STLOD_SMOOTH: SpeedTreeLODType #: 1
    ...

class MaterialExposedTextureProperty(EnumBase):
    r"""
    Selects the texture property to output
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureProperty.h
    
    """

    TMTM_TEXTURE_SIZE: MaterialExposedTextureProperty #: 0: The texture's size.
    TMTM_TEXEL_SIZE: MaterialExposedTextureProperty #: 1: The texture's texel size in the UV space (1 / Texture Size)
    ...

class MaterialVectorCoordTransformSource(EnumBase):
    r"""
    EMaterial Vector Coord Transform Source
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTransform.h
    
    """

    TRANSFORMSOURCE_TANGENT: MaterialVectorCoordTransformSource #: 0: Tangent space (relative to the surface)
    TRANSFORMSOURCE_LOCAL: MaterialVectorCoordTransformSource #: 1: Local space (relative to the rendered object, = object space)
    TRANSFORMSOURCE_WORLD: MaterialVectorCoordTransformSource #: 2: World space, a unit is 1cm
    TRANSFORMSOURCE_VIEW: MaterialVectorCoordTransformSource #: 3: View space (relative to the camera/eye, = camera space, differs from camera space in the shadow passes)
    TRANSFORMSOURCE_CAMERA: MaterialVectorCoordTransformSource #: 4: Camera space
    TRANSFORMSOURCE_INSTANCE: MaterialVectorCoordTransformSource #: 6: Instance space (used to provide per instance transform, i.e. for Instanced Static Mesh / Particles).
    ...

class MaterialVectorCoordTransform(EnumBase):
    r"""
    EMaterial Vector Coord Transform
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTransform.h
    
    """

    TRANSFORM_TANGENT: MaterialVectorCoordTransform #: 0: Tangent space (relative to the surface)
    TRANSFORM_LOCAL: MaterialVectorCoordTransform #: 1: Local space (relative to the rendered object, = object space)
    TRANSFORM_WORLD: MaterialVectorCoordTransform #: 2: World space, a unit is 1cm
    TRANSFORM_VIEW: MaterialVectorCoordTransform #: 3: View space (relative to the camera/eye, = camera space, differs from camera space in the shadow passes)
    TRANSFORM_CAMERA: MaterialVectorCoordTransform #: 4: Camera space
    TRANSFORM_INSTANCE: MaterialVectorCoordTransform #: 6: Instance space (used to provide per instance transform, i.e. for Instanced Static Mesh / Particles).
    ...

class MaterialPositionTransformSource(EnumBase):
    r"""
    EMaterial Position Transform Source
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTransformPosition.h
    
    """

    TRANSFORMPOSSOURCE_LOCAL: MaterialPositionTransformSource #: 0: Local space
    TRANSFORMPOSSOURCE_WORLD: MaterialPositionTransformSource #: 1: Absolute world space
    TRANSFORMPOSSOURCE_TRANSLATED_WORLD: MaterialPositionTransformSource #: 2: Camera relative world space
    TRANSFORMPOSSOURCE_VIEW: MaterialPositionTransformSource #: 3: View space (differs from camera space in the shadow passes)
    TRANSFORMPOSSOURCE_CAMERA: MaterialPositionTransformSource #: 4: Camera space
    TRANSFORMPOSSOURCE_INSTANCE: MaterialPositionTransformSource #: 6: Instance space (used to provide per instance transform, i.e. for Instanced Static Mesh / Particles).
    ...

class VectorNoiseFunction(EnumBase):
    r"""
    EVector Noise Function
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVectorNoise.h
    
    """

    VNF_CELLNOISE_ALU: VectorNoiseFunction
    r"""
    0: Random color for each unit cell in 3D space.
    RGB output range 0 to 1
    R only = 9 instructions, RGB = 11 instructions
    """

    VNF_VECTOR_ALU: VectorNoiseFunction
    r"""
    1: Perlin-style noise with 3D vector/color output.
    RGB output range -1 to 1
    R only = ~83 instructions, RGB = ~125 instructions
    """

    VNF_GRADIENT_ALU: VectorNoiseFunction
    r"""
    2: Gradient of Perlin noise, useful for bumps.
    RGB = Gradient of scalar noise (signed 3D vector)
    A = Base scalar noise with range -1 to 1
    A only = ~83 instructions, RGBA = ~106 instructions
    """

    VNF_CURL_ALU: VectorNoiseFunction
    r"""
    3: Curl of Perlin noise, useful for 3D flow directions.
    RGB = signed curl vector
    ~162 instructions
    """

    VNF_VORONOI_ALU: VectorNoiseFunction
    r"""
    4: Also known as Worley or Cellular noise.
    RGB = *position* of closest point at center of Voronoi cell
    A = distance to closest point with range 0 to about 4
    Quality levels 1-4 search 8, 16, 27 & 32 cells
    All ~20 instructions per cell searched
    """

    ...

class MaterialExposedViewProperty(EnumBase):
    r"""
    EMaterial Exposed View Property
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionViewProperty.h
    
    """

    MEVP_BUFFER_SIZE: MaterialExposedViewProperty #: 0: Horizontal and vertical size of the view's buffer in pixels
    MEVP_FIELD_OF_VIEW: MaterialExposedViewProperty #: 1: Horizontal and vertical field of view angles in radian
    MEVP_TAN_HALF_FIELD_OF_VIEW: MaterialExposedViewProperty #: 2: Tan(FieldOfView * 0.5)
    MEVP_VIEW_SIZE: MaterialExposedViewProperty #: 3: Horizontal and vertical size of the view in pixels
    MEVP_WORLD_SPACE_VIEW_POSITION: MaterialExposedViewProperty #: 4: Absolute world space view position (differs from the camera position in the shadow passes)
    MEVP_WORLD_SPACE_CAMERA_POSITION: MaterialExposedViewProperty #: 5: Absolute world space camera position
    MEVP_VIEWPORT_OFFSET: MaterialExposedViewProperty #: 6: Horizontal and vertical position of the viewport in pixels within the buffer.
    MEVP_TEMPORAL_SAMPLE_COUNT: MaterialExposedViewProperty #: 7: Number of temporal AA sample used across multiple to converge to anti aliased output.
    MEVP_TEMPORAL_SAMPLE_INDEX: MaterialExposedViewProperty #: 8: Index of the Temporal AA jitter for this frame.
    MEVP_TEMPORAL_SAMPLE_OFFSET: MaterialExposedViewProperty #: 9: Offset of the temporal sample for this frame in pixel size.
    MEVP_RUNTIME_VIRTUAL_TEXTURE_OUTPUT_LEVEL: MaterialExposedViewProperty #: 10: Mip Level that Runtime Virtual Texture Output is rendering to.
    MEVP_RUNTIME_VIRTUAL_TEXTURE_OUTPUT_DERIVATIVE: MaterialExposedViewProperty #: 11: World space derivatives for Runtime Virtual Texture Output.
    MEVP_PRE_EXPOSURE: MaterialExposedViewProperty #: 12: Pre Exposure
    MEVP_RUNTIME_VIRTUAL_TEXTURE_MAX_LEVEL: MaterialExposedViewProperty #: 13: Maximum mip level of Runtime Virtual Texture that Runtime Virtual Texture Output is rendering to.
    MEVP_RESOLUTION_FRACTION: MaterialExposedViewProperty #: 14: Screen percentage at which the rendering resolution happens, to allow tech-art to remain consistent with dynamic resolution.
    ...

class WorldPositionIncludedOffsets(EnumBase):
    r"""
    Specifies which shader generated offsets should included in the world position (displacement/WPO etc.)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionWorldPosition.h
    
    """

    WPT_DEFAULT: WorldPositionIncludedOffsets #: 0: Absolute world position with all material shader offsets applied
    WPT_EXCLUDE_ALL_SHADER_OFFSETS: WorldPositionIncludedOffsets #: 1: Absolute world position with no material shader offsets applied
    WPT_CAMERA_RELATIVE: WorldPositionIncludedOffsets #: 2: Camera relative world position with all material shader offsets applied
    WPT_CAMERA_RELATIVE_NO_OFFSETS: WorldPositionIncludedOffsets #: 3: Camera relative world position with no material shader offsets applied
    ...

class ParticleSystemUpdateMode(EnumBase):
    r"""
    ParticleSystemUpdateMode
    Enumeration indicating the method by which the system should be updated
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystem.h
    
    """

    EPSUM_REAL_TIME: ParticleSystemUpdateMode #: 0: RealTime       - update via the delta time passed in
    EPSUM_FIXED_TIME: ParticleSystemUpdateMode #: 1: FixedTime      - update via a fixed time step
    ...

class ParticleSystemLODMethod(EnumBase):
    r"""
    ParticleSystemLODMethod
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystem.h
    
    """

    PARTICLESYSTEMLODMETHOD_AUTOMATIC: ParticleSystemLODMethod #: 0: Automatically set the LOD level, checking every LODDistanceCheckTime seconds.
    PARTICLESYSTEMLODMETHOD_DIRECT_SET: ParticleSystemLODMethod #: 1: LOD level is directly set by the game code.
    PARTICLESYSTEMLODMETHOD_ACTIVATE_AUTOMATIC: ParticleSystemLODMethod #: 2: LOD level is determined at Activation time, then left alone unless directly set by game code.
    ...

class ParticleSystemInsignificanceReaction(EnumBase):
    r"""
    Determines what a particle system will do when all of it's emitters become insignificant.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleHelper.h
    
    """

    AUTO: ParticleSystemInsignificanceReaction #: 0: Looping systems will DisableTick. Non-looping systems will Complete.
    COMPLETE: ParticleSystemInsignificanceReaction #: 1: The system will be considered complete and will auto destroy if desired etc.
    DISABLE_TICK: ParticleSystemInsignificanceReaction #: 2: The system will simply stop ticking. Tick will be re-enabled when any emitters become significant again. This is useful for persistent fx such as environmental fx.
    ...

class ParticleSystemOcclusionBoundsMethod(EnumBase):
    r"""
    Occlusion method enumeration
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystem.h
    
    """

    EPSOBM_NONE: ParticleSystemOcclusionBoundsMethod #: 0: Don't determine occlusion on this particle system
    EPSOBM_PARTICLE_BOUNDS: ParticleSystemOcclusionBoundsMethod #: 1: Use the bounds of the particle system component when determining occlusion
    EPSOBM_CUSTOM_BOUNDS: ParticleSystemOcclusionBoundsMethod #: 2: Use the custom occlusion bounds when determining occlusion
    ...

class ParticleSignificanceLevel(EnumBase):
    r"""
    A level of significance for a particle system. Used by game code to enable/disable emitters progressively as they move away from the camera or are occluded/off screen.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleHelper.h
    
    """

    LOW: ParticleSignificanceLevel #: 0: Low significance emitter. Culled first.
    MEDIUM: ParticleSignificanceLevel #: 1: Medium significance emitter.
    HIGH: ParticleSignificanceLevel #: 2: High significance emitter. Culled last.
    CRITICAL: ParticleSignificanceLevel #: 3: Critical emitter. Never culled.
    ...

class TrailWidthMode(EnumBase):
    r"""
    Controls the way that the width scale property affects animation trails.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    E_TRAIL_WIDTH_MODE_FROM_CENTRE: TrailWidthMode #: 0
    E_TRAIL_WIDTH_MODE_FROM_FIRST: TrailWidthMode #: 1
    E_TRAIL_WIDTH_MODE_FROM_SECOND: TrailWidthMode #: 2
    ...

class SceneCapturePrimitiveRenderMode(EnumBase):
    r"""
    EScene Capture Primitive Render Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneCaptureComponent.h
    
    """

    PRM_LEGACY_SCENE_CAPTURE: SceneCapturePrimitiveRenderMode #: 0: Legacy
    PRM_RENDER_SCENE_PRIMITIVES: SceneCapturePrimitiveRenderMode #: 1: Render primitives in the scene, minus HiddenActors.
    PRM_USE_SHOW_ONLY_LIST: SceneCapturePrimitiveRenderMode #: 2: Render only primitives in the ShowOnlyActors list, or components specified with ShowOnlyComponent().
    ...

class SceneCaptureSource(EnumBase):
    r"""
    Specifies which component of the scene rendering should be output to the final render target.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    SCS_SCENE_COLOR_HDR: SceneCaptureSource #: 0
    SCS_SCENE_COLOR_HDR_NO_ALPHA: SceneCaptureSource #: 1
    SCS_FINAL_COLOR_LDR: SceneCaptureSource #: 2
    SCS_SCENE_COLOR_SCENE_DEPTH: SceneCaptureSource #: 3
    SCS_SCENE_DEPTH: SceneCaptureSource #: 4
    SCS_DEVICE_DEPTH: SceneCaptureSource #: 5
    SCS_NORMAL: SceneCaptureSource #: 6
    SCS_BASE_COLOR: SceneCaptureSource #: 7
    SCS_FINAL_COLOR_HDR: SceneCaptureSource #: 8
    SCS_FINAL_TONE_CURVE_HDR: SceneCaptureSource #: 9
    ...

class SceneCaptureCompositeMode(EnumBase):
    r"""
    Specifies how scene captures are composited into render buffers
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    SCCM_OVERWRITE: SceneCaptureCompositeMode #: 0
    SCCM_ADDITIVE: SceneCaptureCompositeMode #: 1
    SCCM_COMPOSITE: SceneCaptureCompositeMode #: 2
    ...

class SkyLightSourceType(EnumBase):
    r"""
    ESky Light Source Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkyLightComponent.h
    
    """

    SLS_CAPTURED_SCENE: SkyLightSourceType #: 0: Construct the sky light from the captured scene, anything further than SkyDistanceThreshold from the sky light position will be included.
    SLS_SPECIFIED_CUBEMAP: SkyLightSourceType #: 1: Construct the sky light from the specified cubemap.
    ...

class OcclusionCombineMode(EnumBase):
    r"""
    Controls how occlusion from Distance Field Ambient Occlusion is combined with Screen Space Ambient Occlusion.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    OCM_MINIMUM: OcclusionCombineMode #: 0: Take the minimum occlusion value.  This is effective for avoiding over-occlusion from multiple methods, but can result in indoors looking too flat.
    OCM_MULTIPLY: OcclusionCombineMode
    r"""
    1: Multiply together occlusion values from Distance Field Ambient Occlusion and Screen Space Ambient Occlusion.
    This gives a good sense of depth everywhere, but can cause over-occlusion.
    SSAO should be tweaked to be less strong compared to Minimum.
    """

    ...

class PixelFormat(EnumBase):
    r"""
    Describes the format of a each pixel in a graphics buffer.
    warning:: When you update this, you must add an entry to GPixelFormats(see RenderUtils.cpp)
    warning:: When you update this, you must add an entries to PixelFormat.h, usually just copy the generated section on the header into EPixelFormat
    warning:: The *Tools DLLs will also need to be recompiled if the ordering is changed, but should not need code changes.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    PF_UNKNOWN: PixelFormat #: 0
    PF_A32B32G32R32F: PixelFormat #: 1
    PF_B8G8R8A8: PixelFormat #: 2: UNORM (0..1), corresponds to FColor.  Unpacks as rgba in the shader.
    PF_G8: PixelFormat #: 3: UNORM red (0..1)
    PF_G16: PixelFormat #: 4
    PF_DXT1: PixelFormat #: 5
    PF_DXT3: PixelFormat #: 6
    PF_DXT5: PixelFormat #: 7
    PF_UYVY: PixelFormat #: 8
    PF_FLOAT_RGB: PixelFormat #: 9: Same as PF_FloatR11G11B10
    PF_FLOAT_RGBA: PixelFormat #: 10: RGBA 16 bit signed FP format.  Use FFloat16Color on the CPU.
    PF_DEPTH_STENCIL: PixelFormat #: 11: A depth+stencil format with platform-specific implementation, for use with render targets.
    PF_SHADOW_DEPTH: PixelFormat #: 12: A depth format with platform-specific implementation, for use with render targets.
    PF_R32_FLOAT: PixelFormat #: 13
    PF_G16R16: PixelFormat #: 14
    PF_G16R16F: PixelFormat #: 15
    PF_G16R16F_FILTER: PixelFormat #: 16
    PF_G32R32F: PixelFormat #: 17
    PF_A2B10G10R10: PixelFormat #: 18
    PF_A16B16G16R16: PixelFormat #: 19
    PF_D24: PixelFormat #: 20
    PF_R16F: PixelFormat #: 21
    PF_R16F_FILTER: PixelFormat #: 22
    PF_BC5: PixelFormat #: 23
    PF_V8U8: PixelFormat #: 24: SNORM red, green (-1..1). Not supported on all RHI e.g. Metal
    PF_A1: PixelFormat #: 25
    PF_FLOAT_R11G11B10: PixelFormat #: 26: A low precision floating point format, unsigned.  Use FFloat3Packed on the CPU.
    PF_A8: PixelFormat #: 27
    PF_R32_UINT: PixelFormat #: 28
    PF_R32_SINT: PixelFormat #: 29
    PF_PVRTC2: PixelFormat #: 30
    PF_PVRTC4: PixelFormat #: 31
    PF_R16_UINT: PixelFormat #: 32
    PF_R16_SINT: PixelFormat #: 33
    PF_R16G16B16A16_UINT: PixelFormat #: 34
    PF_R16G16B16A16_SINT: PixelFormat #: 35
    PF_R5G6B5_UNORM: PixelFormat #: 36
    PF_R8G8B8A8: PixelFormat #: 37
    PF_A8R8G8B8: PixelFormat #: 38: Only used for legacy loading; do NOT use!
    PF_BC4: PixelFormat #: 39: High precision single channel block compressed, equivalent to a single channel BC5, 8 bytes per 4x4 block.
    PF_R8G8: PixelFormat #: 40: UNORM red, green (0..1).
    PF_ATC_RGB: PixelFormat #: 41: ATITC format.
    PF_ATC_RGBA_E: PixelFormat #: 42: ATITC format.
    PF_ATC_RGBA_I: PixelFormat #: 43: ATITC format.
    PF_X24_G8: PixelFormat #: 44: Used for creating SRVs to alias a DepthStencil buffer to read Stencil.  Don't use for creating textures.
    PF_ETC1: PixelFormat #: 45
    PF_ETC2_RGB: PixelFormat #: 46
    PF_ETC2_RGBA: PixelFormat #: 47
    PF_R32G32B32A32_UINT: PixelFormat #: 48
    PF_R16G16_UINT: PixelFormat #: 49
    PF_ASTC_4X4: PixelFormat #: 50: 8.00 bpp
    PF_ASTC_6X6: PixelFormat #: 51: 3.56 bpp
    PF_ASTC_8X8: PixelFormat #: 52: 2.00 bpp
    PF_ASTC_10X10: PixelFormat #: 53: 1.28 bpp
    PF_ASTC_12X12: PixelFormat #: 54: 0.89 bpp
    PF_BC6H: PixelFormat #: 55
    PF_BC7: PixelFormat #: 56
    PF_R8_UINT: PixelFormat #: 57
    PF_L8: PixelFormat #: 58
    PF_XGXR8: PixelFormat #: 59
    PF_R8G8B8A8_UINT: PixelFormat #: 60
    PF_R8G8B8A8_SNORM: PixelFormat #: 61: SNORM (-1..1), corresponds to FFixedRGBASigned8.
    PF_R16G16B16A16_UNORM: PixelFormat #: 62
    PF_R16G16B16A16_SNORM: PixelFormat #: 63
    PF_PLATFORM_HDR_0: PixelFormat #: 64
    PF_PLATFORM_HDR_1: PixelFormat #: 65
    PF_PLATFORM_HDR_2: PixelFormat #: 66
    PF_NV12: PixelFormat #: 67
    PF_R32G32_UINT: PixelFormat #: 68
    PF_ETC2_R11_EAC: PixelFormat #: 69
    PF_ETC2_RG11_EAC: PixelFormat #: 70
    PF_R8: PixelFormat #: 71
    PF_B5G5R5A1_UNORM: PixelFormat #: 72
    PF_ASTC_4X4_HDR: PixelFormat #: 73
    PF_ASTC_6X6_HDR: PixelFormat #: 74
    PF_ASTC_8X8_HDR: PixelFormat #: 75
    PF_ASTC_10X10_HDR: PixelFormat #: 76
    PF_ASTC_12X12_HDR: PixelFormat #: 77
    PF_G16R16_SNORM: PixelFormat #: 78
    PF_R8G8_UINT: PixelFormat #: 79
    PF_R32G32B32_UINT: PixelFormat #: 80
    PF_R32G32B32_SINT: PixelFormat #: 81
    PF_R32G32B32F: PixelFormat #: 82
    PF_R8_SINT: PixelFormat #: 83
    PF_R64_UINT: PixelFormat #: 84
    PF_R9G9B9EXP5: PixelFormat #: 85
    PF_P010: PixelFormat #: 86
    PF_ASTC_4X4_NORM_RG: PixelFormat #: 87
    PF_ASTC_6X6_NORM_RG: PixelFormat #: 88
    PF_ASTC_8X8_NORM_RG: PixelFormat #: 89
    PF_ASTC_10X10_NORM_RG: PixelFormat #: 90
    PF_ASTC_12X12_NORM_RG: PixelFormat #: 91
    ...

class StereoLayerType(EnumBase):
    r"""
    Used by IStereoLayer
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StereoLayerComponent.h
    
    """

    SLT_WORLD_LOCKED: StereoLayerType #: 0: Location within the world
    SLT_TRACKER_LOCKED: StereoLayerType #: 1: Location within the HMD tracking space
    SLT_FACE_LOCKED: StereoLayerType #: 2: Location within the view space
    ...

class HorizTextAligment(EnumBase):
    r"""
    EHoriz Text Aligment
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextRenderComponent.h
    
    """

    EHTA_LEFT: HorizTextAligment #: 0
    EHTA_CENTER: HorizTextAligment #: 1
    EHTA_RIGHT: HorizTextAligment #: 2
    ...

class VerticalTextAligment(EnumBase):
    r"""
    EVertical Text Aligment
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextRenderComponent.h
    
    """

    EVRTA_TEXT_TOP: VerticalTextAligment #: 0
    EVRTA_TEXT_CENTER: VerticalTextAligment #: 1
    EVRTA_TEXT_BOTTOM: VerticalTextAligment #: 2
    EVRTA_QUAD_TOP: VerticalTextAligment #: 3
    ...

class TimelineLengthMode(EnumBase):
    r"""
    Whether or not the timeline should be finished after the specified length, or the last keyframe in the tracks
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimelineComponent.h
    
    """

    TL_TIMELINE_LENGTH: TimelineLengthMode #: 0
    TL_LAST_KEY_FRAME: TimelineLengthMode #: 1
    ...

class WindSourceType(EnumBase):
    r"""
    EWind Source Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WindDirectionalSourceComponent.h
    
    """

    DIRECTIONAL: WindSourceType #: 0
    POINT: WindSourceType #: 1
    ...

class VisibilityAggressiveness(EnumBase):
    r"""
    EVisibility Aggressiveness
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldSettings.h
    
    """

    VIS_LEAST_AGGRESSIVE: VisibilityAggressiveness #: 0
    VIS_MODERATELY_AGGRESSIVE: VisibilityAggressiveness #: 1
    VIS_MOST_AGGRESSIVE: VisibilityAggressiveness #: 2
    ...

class CustomAttributeBlendType(EnumBase):
    r"""
    ECustom Attribute Blend Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CustomAttributes.h
    
    """

    OVERRIDE: CustomAttributeBlendType #: 0: Overrides Custom attributes according to highest weighted pose
    BLEND: CustomAttributeBlendType #: 1: Blends Custom attributes according to weights per pose
    ...

class StripAnimDataOnDedicatedServerSettings(EnumBase):
    r"""
    Enum used to decide whether we should strip animation data on dedicated server
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimSequence.h
    
    """

    USE_PROJECT_SETTING: StripAnimDataOnDedicatedServerSettings #: 0: Strip track data on dedicated server if 'Strip Animation Data on Dedicated Server' option in Project Settings is true and EnableRootMotion is false
    STRIP_ANIM_DATA_ON_DEDICATED_SERVER: StripAnimDataOnDedicatedServerSettings #: 1: Strip track data on dedicated server regardless of the value of 'Strip Animation Data on Dedicated Server' option in Project Settings as long as EnableRootMotion is false
    DO_NOT_STRIP_ANIM_DATA_ON_DEDICATED_SERVER: StripAnimDataOnDedicatedServerSettings #: 2: Do not strip track data on dedicated server regardless of the value of 'Strip Animation Data on Dedicated Server' option in Project Settings
    ...

class SkyAtmosphereTransformMode(EnumBase):
    r"""
    ESky Atmosphere Transform Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkyAtmosphereComponent.h
    
    """

    PLANET_TOP_AT_ABSOLUTE_WORLD_ORIGIN: SkyAtmosphereTransformMode #: 0
    PLANET_TOP_AT_COMPONENT_TRANSFORM: SkyAtmosphereTransformMode #: 1
    PLANET_CENTER_AT_COMPONENT_TRANSFORM: SkyAtmosphereTransformMode #: 2
    ...

class InterfaceValidResult(EnumBase):
    r"""
    EInterface Valid Result
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraLensEffectInterface.h
    
    """

    VALID: InterfaceValidResult #: 0
    INVALID: InterfaceValidResult #: 1
    ...

class DynamicForceFeedbackAction(EnumBase):
    r"""
    EDynamic Force Feedback Action
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerController.h
    
    """

    START: DynamicForceFeedbackAction #: 0
    UPDATE: DynamicForceFeedbackAction #: 1
    STOP: DynamicForceFeedbackAction #: 2
    ...

class ControllerAnalogStick(EnumBase):
    r"""
    EController Analog Stick
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputComponent.h
    
    """

    CAS_LEFT_STICK: ControllerAnalogStick #: 0
    CAS_RIGHT_STICK: ControllerAnalogStick #: 1
    ...

class LightUnits(EnumBase):
    r"""
    ELight Units
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    """

    UNITLESS: LightUnits #: 0
    CANDELAS: LightUnits #: 1
    LUMENS: LightUnits #: 2
    EV: LightUnits #: 3
    ...

class BoneSpaces(EnumBase):
    r"""
    Values for specifying bone space.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedMeshComponent.h
    
    """

    WORLD_SPACE: BoneSpaces #: 0: Set absolute position of bone in world space.
    COMPONENT_SPACE: BoneSpaces #: 1: Set position of bone in components reference frame.
    ...

class SplineCoordinateSpace(EnumBase):
    r"""
    Types of coordinate space accepted by the functions.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SplineComponent.h
    
    """

    LOCAL: SplineCoordinateSpace #: 0
    WORLD: SplineCoordinateSpace #: 1
    ...

class VolumetricCloudTracingMaxDistanceMode(EnumBase):
    r"""
    EVolumetric Cloud Tracing Max Distance Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VolumetricCloudComponent.h
    
    """

    DISTANCE_FROM_CLOUD_LAYER_ENTRY_POINT: VolumetricCloudTracingMaxDistanceMode #: 0
    DISTANCE_FROM_POINT_OF_VIEW: VolumetricCloudTracingMaxDistanceMode #: 1
    ...

class StreamingSourceTargetState(EnumBase):
    r"""
    Streaming Source Target State
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionStreamingSource.h
    
    """

    LOADED: StreamingSourceTargetState #: 0
    ACTIVATED: StreamingSourceTargetState #: 1
    ...

class EvaluateCurveTableResult(EnumBase):
    r"""
    Enum used to indicate success or failure of EvaluateCurveTableRow.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataTableFunctionLibrary.h
    
    """

    ROW_FOUND: EvaluateCurveTableResult #: 0: Found the row successfully.
    ROW_NOT_FOUND: EvaluateCurveTableResult #: 1: Failed to find the row.
    ...

class GrammaticalGender(EnumBase):
    r"""
    EGrammatical Gender
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DialogueTypes.h
    
    """

    NEUTER: GrammaticalGender #: 0
    MASCULINE: GrammaticalGender #: 1
    FEMININE: GrammaticalGender #: 2
    MIXED: GrammaticalGender #: 3
    ...

class GrammaticalNumber(EnumBase):
    r"""
    EGrammatical Number
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DialogueTypes.h
    
    """

    SINGULAR: GrammaticalNumber #: 0
    PLURAL: GrammaticalNumber #: 1
    ...

class TypedElementWorldType(EnumBase):
    r"""
    ETyped Element World Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TypedElementWorldInterface.h
    
    """

    GAME: TypedElementWorldType #: 0
    EDITOR: TypedElementWorldType #: 1
    ...

class FontCacheType(EnumBase):
    r"""
    Enumerates supported font caching types.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Font.h
    
    """

    OFFLINE: FontCacheType #: 0: The font is using offline caching (this is how UFont traditionally worked).
    RUNTIME: FontCacheType #: 1: The font is using runtime caching (this is how Slate fonts work).
    ...

class FontRasterizationMode(EnumBase):
    r"""
    Enumerates supported font rasterization modes.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: FontSdfSettings.h
    
    """

    BITMAP: FontRasterizationMode #: 0: Glyphs are rasterized directly into alpha mask bitmaps per size and skew.
    MSDF: FontRasterizationMode #: 1: Glyphs are first rasterized into multi-channel signed distance fields, which are size and skew agnostic.
    ...

class FontHinting(EnumBase):
    r"""
    EFont Hinting
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: CompositeFont.h
    
    """

    DEFAULT: FontHinting #: 0: Use the default hinting specified in the font.
    AUTO: FontHinting #: 1: Force the use of an automatic hinting algorithm.
    AUTO_LIGHT: FontHinting #: 2: Force the use of an automatic light hinting algorithm, optimized for non-monochrome displays.
    MONOCHROME: FontHinting #: 3: Force the use of an automatic hinting algorithm optimized for monochrome displays.
    NONE: FontHinting #: 4: Do not use hinting.
    ...

class FontLoadingPolicy(EnumBase):
    r"""
    EFont Loading Policy
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: CompositeFont.h
    
    """

    LAZY_LOAD: FontLoadingPolicy #: 0: Lazy load the entire font into memory. This will consume more memory than Streaming, however there will be zero file-IO when rendering glyphs within the font, although the initial load may cause a hitch.
    STREAM: FontLoadingPolicy #: 1: Stream the font from disk. This will consume less memory than LazyLoad or Inline, however there will be file-IO when rendering glyphs, which may cause hitches under certain circumstances or on certain platforms.
    INLINE: FontLoadingPolicy #: 2: Embed the font data within the asset. This will consume more memory than Streaming, however it is guaranteed to be hitch free (only valid for font data within a Font Face asset).
    ...

class FontLayoutMethod(EnumBase):
    r"""
    EFont Layout Method
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: CompositeFont.h
    
    """

    METRICS: FontLayoutMethod #: 0: Layout the font using the metrics data available in the font. This is typically the desired option, however some fonts have broken or incorrect metrics so may yield better results when using the bounding box values to layout the font.
    BOUNDING_BOX: FontLayoutMethod #: 1: Layout the font using the values from its bounding box. This typically yields a larger line height for fonts that have valid metrics, however it can also produce much better results for fonts that have broken or incorrect metrics.
    ...

class MouseCaptureMode(EnumBase):
    r"""
    EMouse Capture Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineBaseTypes.h
    
    """

    NO_CAPTURE: MouseCaptureMode #: 0: Do not capture the mouse at all
    CAPTURE_PERMANENTLY: MouseCaptureMode #: 1: Capture the mouse permanently when the viewport is clicked, and consume the initial mouse down that caused the capture so it isn't processed by player input
    CAPTURE_PERMANENTLY_INCLUDING_INITIAL_MOUSE_DOWN: MouseCaptureMode #: 2: Capture the mouse permanently when the viewport is clicked, and allow player input to process the mouse down that caused the capture
    CAPTURE_DURING_MOUSE_DOWN: MouseCaptureMode #: 3: Capture the mouse during a mouse down, releases on mouse up
    CAPTURE_DURING_RIGHT_MOUSE_DOWN: MouseCaptureMode #: 4: Capture only when the right mouse button is down, not any of the other mouse buttons
    ...

class SuggestProjVelocityTraceOption(EnumBase):
    r"""
    Trace option to SuggestProjectileVelocity functions.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameplayStaticsTypes.h
    
    """

    DO_NOT_TRACE: SuggestProjVelocityTraceOption #: 0
    TRACE_FULL_PATH: SuggestProjVelocityTraceOption #: 1
    ONLY_TRACE_WHILE_ASCENDING: SuggestProjVelocityTraceOption #: 2
    ...

class SearchCase(EnumBase):
    r"""
    Determines case sensitivity options for string comparisons.
    note: Mirrored from Engine\Source\Runtime\Core\Public\Containers\UnrealString.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    CASE_SENSITIVE: SearchCase #: 0
    IGNORE_CASE: SearchCase #: 1
    ...

class SearchDir(EnumBase):
    r"""
    Determines search direction for string operations.
    note: Mirrored from Engine\Source\Runtime\Core\Public\Containers\UnrealString.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """

    FROM_START: SearchDir #: 0
    FROM_END: SearchDir #: 1
    ...

class QuitPreference(EnumBase):
    r"""
    EQuit Preference
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetSystemLibrary.h
    
    """

    QUIT: QuitPreference #: 0: Exit the game completely.
    BACKGROUND: QuitPreference #: 1: Move the application to the background.
    ...

class MoveComponentAction(EnumBase):
    r"""
    Enum used to indicate desired behavior for MoveComponentTo latent function.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetSystemLibrary.h
    
    """

    MOVE: MoveComponentAction #: 0: Move to target over specified time.
    STOP: MoveComponentAction #: 1: If currently moving, stop.
    RETURN: MoveComponentAction #: 2: If currently moving, return to where you started, over the time elapsed so far.
    ...

class LevelInstanceRuntimeBehavior(EnumBase):
    r"""
    ELevel Instance Runtime Behavior
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelInstanceTypes.h
    
    """

    PARTITIONED: LevelInstanceRuntimeBehavior #: 2: Move level instance actors to the main world partition
    LEVEL_STREAMING: LevelInstanceRuntimeBehavior #: 3: Use level streaming to load level instance actors
    ...

class VertexPaintAxis(EnumBase):
    r"""
    EVertex Paint Axis
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshVertexPainter.h
    
    """

    X: VertexPaintAxis #: 0
    Y: VertexPaintAxis #: 1
    Z: VertexPaintAxis #: 2
    ...

class ConstraintPlasticityType(EnumBase):
    r"""
    LINEAR CCPT
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: ChaosEngineInterface.h
    
    """

    CCPT_FREE: ConstraintPlasticityType #: 0
    CCPT_SHRINK: ConstraintPlasticityType #: 1
    CCPT_GROW: ConstraintPlasticityType #: 2
    ...

class LinearConstraintMotion(EnumBase):
    r"""
    LINEAR DOF
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: ChaosEngineInterface.h
    
    """

    LCM_FREE: LinearConstraintMotion #: 0: No constraint against this axis.
    LCM_LIMITED: LinearConstraintMotion #: 1: Limited freedom along this axis.
    LCM_LOCKED: LinearConstraintMotion #: 2: Fully constraint against this axis.
    ...

class AngularConstraintMotion(EnumBase):
    r"""
    Specifies angular degrees of freedom
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: ChaosEngineInterface.h
    
    """

    ACM_FREE: AngularConstraintMotion #: 0: No constraint against this axis.
    ACM_LIMITED: AngularConstraintMotion #: 1: Limited freedom along this axis.
    ACM_LOCKED: AngularConstraintMotion #: 2: Fully constraint against this axis.
    ...

class AngularDriveMode(EnumBase):
    r"""
    EAngular Drive Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintDrives.h
    
    """

    SLERP: AngularDriveMode #: 0: Spherical lerp between the current orientation/velocity and the target orientation/velocity. NOTE: This will NOT work if any angular constraints are set to Locked.
    TWIST_AND_SWING: AngularDriveMode #: 1: Path is decomposed into twist (roll constraint) and swing (cone constraint). Doesn't follow shortest arc and may experience gimbal lock. Does work with locked angular constraints.
    ...

class PhysicsAssetSolverType(EnumBase):
    r"""
    EPhysics Asset Solver Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsAsset.h
    
    """

    RBAN: PhysicsAssetSolverType #: 0
    WORLD: PhysicsAssetSolverType #: 1
    ...

class ConstraintFrame(EnumBase):
    r"""
    Enum to indicate which context frame we use for physical constraints
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: ChaosEngineInterface.h
    
    """

    FRAME1: ConstraintFrame #: 0
    FRAME2: ConstraintFrame #: 1
    ...

class SettingsDOF(EnumBase):
    r"""
    ESettings DOF
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsSettings.h
    
    """

    FULL3D: SettingsDOF #: 0: Allows for full 3D movement and rotation.
    YZ_PLANE: SettingsDOF #: 1: Allows 2D movement along the Y-Z plane.
    XZ_PLANE: SettingsDOF #: 2: Allows 2D movement along the X-Z plane.
    XY_PLANE: SettingsDOF #: 3: Allows 2D movement along the X-Y plane.
    ...

class ClothLODBiasMode(EnumBase):
    r"""
    Strategy used for storing additional cloth deformer mappings depending on the
    desired use of the RaytracingMinLOD value and of the LODBias console variable.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMesh.h
    
    """

    MAPPINGS_TO_SAME_LOD: ClothLODBiasMode
    r"""
    0: Only store the strict minimum amount of cloth deformer mappings to save on memory usage.
    Raytracing of cloth elements must never be of a different LOD to the one being rendered when using this mode.
    """

    MAPPINGS_TO_MIN_LOD: ClothLODBiasMode
    r"""
    1: Store additional cloth deformer mappings to allow raytracing of the cloth elements at RayTracingMinLOD.
    Raytracing of cloth elements must never be of a different LOD to the one being rendered, or to the one set in RayTracingMinLOD when using this mode.
    """

    MAPPINGS_TO_ANY_LOD: ClothLODBiasMode
    r"""
    2: Store all cloth deformer mappings at the expense of memory usage, to allow raytracing of the cloth elements at any higher LOD.
    Use this mode when the RayTracing LODBias console variable is in use.
    """

    ...

class HLODLayerType(EnumBase):
    r"""
    EHLODLayer Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODLayer.h
    
    """

    INSTANCING: HLODLayerType #: 0
    MESH_MERGE: HLODLayerType #: 1
    MESH_SIMPLIFY: HLODLayerType #: 2
    MESH_APPROXIMATE: HLODLayerType #: 3
    CUSTOM: HLODLayerType #: 4
    ...

class CacheMode(EnumBase):
    r"""
    ECache Mode
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCaching
    - **File**: CacheManagerActor.h
    
    """

    NONE: CacheMode #: 0
    PLAY: CacheMode #: 1
    RECORD: CacheMode #: 2
    ...

class StartMode(EnumBase):
    r"""
    EStart Mode
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCaching
    - **File**: CacheManagerActor.h
    
    """

    TIMED: StartMode #: 0
    TRIGGERED: StartMode #: 1
    ...

class ACLVisualFidelity(EnumBase):
    r"""
    An enum to represent the ACL visual fidelity level.
    
    **C++ Source:**
    
    - **Plugin**: ACLPlugin
    - **Module**: ACLPlugin
    - **File**: AnimationCompressionLibraryDatabase.h
    
    """

    HIGHEST: ACLVisualFidelity #: 0
    MEDIUM: ACLVisualFidelity #: 1
    LOWEST: ACLVisualFidelity #: 2
    ...

class PreviewAnimationBlueprintApplicationMethod(EnumBase):
    r"""
    The method by which a preview animation blueprint is applied
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimBlueprint.h
    
    """

    LINKED_LAYERS: PreviewAnimationBlueprintApplicationMethod #: 0: Apply the preview animation blueprint using LinkAnimClassLayers
    LINKED_ANIM_GRAPH: PreviewAnimationBlueprintApplicationMethod #: 1: Apply the preview animation blueprint using SetLinkedAnimGraphByTag
    ...

class ThumbnailPreviewSizeMode(EnumBase):
    r"""
    EThumbnail Preview Size Mode
    
    **C++ Source:**
    
    - **Module**: UMGEditor
    - **File**: WidgetBlueprint.h
    
    """

    MATCH_DESIGNER_MODE: ThumbnailPreviewSizeMode #: 0
    FILL_SCREEN: ThumbnailPreviewSizeMode #: 1
    CUSTOM: ThumbnailPreviewSizeMode #: 2
    DESIRED: ThumbnailPreviewSizeMode #: 3
    ...

class ViewModeIndex(EnumBase):
    r"""
    Define view modes to get specific show flag settings (some on, some off and some are not altered)
    Don't change the order, the ID is serialized with the editor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineBaseTypes.h
    
    """

    VMI_BRUSH_WIREFRAME: ViewModeIndex #: 0: Wireframe w/ brushes.
    VMI_WIREFRAME: ViewModeIndex #: 1: Wireframe w/ BSP.
    VMI_UNLIT: ViewModeIndex #: 2: Unlit.
    VMI_LIT: ViewModeIndex #: 3: Lit.
    VMI_LIT_DETAIL_LIGHTING: ViewModeIndex #: 4
    VMI_LIGHTING_ONLY: ViewModeIndex #: 5: Lit wo/ materials.
    VMI_LIGHT_COMPLEXITY: ViewModeIndex #: 6: Colored according to light count.
    VMI_SHADER_COMPLEXITY: ViewModeIndex #: 8: Colored according to shader complexity.
    VMI_LIGHTMAP_DENSITY: ViewModeIndex #: 9: Colored according to world-space LightMap texture density.
    VMI_LIT_LIGHTMAP_DENSITY: ViewModeIndex #: 10: Colored according to light count - showing lightmap texel density on texture mapped objects.
    VMI_REFLECTION_OVERRIDE: ViewModeIndex #: 11
    VMI_VISUALIZE_BUFFER: ViewModeIndex #: 12
    VMI_STATIONARY_LIGHT_OVERLAP: ViewModeIndex #: 14: Colored according to stationary light overlap.
    VMI_COLLISION_PAWN: ViewModeIndex #: 15
    VMI_COLLISION_VISIBILITY: ViewModeIndex #: 16
    VMI_LOD_COLORATION: ViewModeIndex #: 18: Colored according to the current LOD index.
    VMI_QUAD_OVERDRAW: ViewModeIndex #: 19: Colored according to the quad coverage.
    VMI_PRIMITIVE_DISTANCE_ACCURACY: ViewModeIndex #: 20: Visualize the accuracy of the primitive distance computed for texture streaming.
    VMI_MESH_UV_DENSITY_ACCURACY: ViewModeIndex #: 21: Visualize the accuracy of the mesh UV densities computed for texture streaming.
    VMI_SHADER_COMPLEXITY_WITH_QUAD_OVERDRAW: ViewModeIndex #: 22: Colored according to shader complexity, including quad overdraw.
    VMI_HLOD_COLORATION: ViewModeIndex #: 23: Colored according to the current HLOD index.
    VMI_GROUP_LOD_COLORATION: ViewModeIndex #: 24: Group item for LOD and HLOD coloration
    VMI_MATERIAL_TEXTURE_SCALE_ACCURACY: ViewModeIndex #: 25: Visualize the accuracy of the material texture scales used for texture streaming.
    VMI_REQUIRED_TEXTURE_RESOLUTION: ViewModeIndex #: 26: Compare the required texture resolution to the actual resolution.
    VMI_PATH_TRACING: ViewModeIndex #: 27: Run path tracing pipeline
    VMI_RAY_TRACING_DEBUG: ViewModeIndex #: 28: Run ray tracing debug pipeline
    VMI_VISUALIZE_NANITE: ViewModeIndex #: 29: Visualize various aspects of Nanite
    VMI_VIRTUAL_TEXTURE_PENDING_MIPS: ViewModeIndex #: 30: Compare the required texture resolution to the actual resolution.
    VMI_VISUALIZE_LUMEN: ViewModeIndex #: 31: Visualize Lumen debug views
    VMI_VISUALIZE_VIRTUAL_SHADOW_MAP: ViewModeIndex #: 32: Visualize virtual shadow map
    VMI_VISUALIZE_GPU_SKIN_CACHE: ViewModeIndex #: 33: Visualize Skin Cache.
    VMI_VISUALIZE_SUBSTRATE: ViewModeIndex #: 34: Visualize Substrate debug views
    VMI_VISUALIZE_GROOM: ViewModeIndex #: 35: Visualize Groom debug views
    VMI_UNKNOWN: ViewModeIndex #: 255: VMI_Unknown - The value assigned to VMI_Unknown must be the highest possible of any member of EViewModeIndex, or GetViewModeName might seg-fault
    ...

class WidgetTestAppearLocation(EnumBase):
    r"""
    EWidget Test Appear Location
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalUIScreenshotTest.h
    
    """

    VIEWPORT: WidgetTestAppearLocation #: 0
    PLAYER_SCREEN: WidgetTestAppearLocation #: 1
    ...

class AFSActiveType(EnumBase):
    r"""
    EAFSActive Type
    
    **C++ Source:**
    
    - **Plugin**: AndroidFileServer
    - **Module**: AndroidFileServer
    - **File**: AndroidFileServerBPLibrary.h
    
    """

    NONE: AFSActiveType #: 0
    USB_ONLY: AFSActiveType #: 1
    NETWORK_ONLY: AFSActiveType #: 2
    COMBINED: AFSActiveType #: 3
    ...

class InputMappingRebuildType(EnumBase):
    r"""
    EInput Mapping Rebuild Type
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputSubsystemInterface.h
    
    """

    NONE: InputMappingRebuildType #: 0: No rebuild required.
    REBUILD: InputMappingRebuildType #: 1: Standard mapping rebuild. Retains existing triggers and modifiers for actions that were previously mapped.
    REBUILD_WITH_FLUSH: InputMappingRebuildType #: 2: If you have made changes to the triggers/modifiers associated with a UInputAction that was previously mapped a flush is required to reset the tracked data for that action.
    ...

class InputActionAccumulationBehavior(EnumBase):
    r"""
    This is an advanced setting that allows you to change how the value of an Input Action is calculated when there are
    multiple mappings to the same Input Action. The default behavior is to accept highest absolute value.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputAction.h
    
    """

    TAKE_HIGHEST_ABSOLUTE_VALUE: InputActionAccumulationBehavior
    r"""
    0: Take the value from the mapping with the highest Absolute Value.
    
    For example, given a value of -0.3 and 0.5, the input action's value would be 0.5.
    """

    CUMULATIVE: InputActionAccumulationBehavior
    r"""
    1: Cumulatively adds the key values for each mapping.
    
    For example, a value of -0.7 and +0.75 on the same input action would result in a value of 0.05.
    
    A practical example of when to use this would be for something like WASD movement, if you want pressing W and S to cancel each other out.
    """

    ...

class NormalizeInputSmoothingType(EnumBase):
    r"""
    Behavior options for how the value is calculated in UInputModifierSmoothDelta.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    """

    LERP: NormalizeInputSmoothingType #: 1
    INTERP_TO: NormalizeInputSmoothingType #: 2
    INTERP_CONSTANT_TO: NormalizeInputSmoothingType #: 3
    INTERP_CIRCULAR_IN: NormalizeInputSmoothingType #: 4
    INTERP_CIRCULAR_OUT: NormalizeInputSmoothingType #: 5
    INTERP_CIRCULAR_IN_OUT: NormalizeInputSmoothingType #: 6
    INTERP_EASE_IN: NormalizeInputSmoothingType #: 7
    INTERP_EASE_OUT: NormalizeInputSmoothingType #: 8
    INTERP_EASE_IN_OUT: NormalizeInputSmoothingType #: 9
    INTERP_EXPO_IN: NormalizeInputSmoothingType #: 10
    INTERP_EXPO_OUT: NormalizeInputSmoothingType #: 11
    INTERP_EXPO_IN_OUT: NormalizeInputSmoothingType #: 12
    INTERP_SIN_IN: NormalizeInputSmoothingType #: 13
    INTERP_SIN_OUT: NormalizeInputSmoothingType #: 14
    INTERP_SIN_IN_OUT: NormalizeInputSmoothingType #: 15
    ...

class DeadZoneType(EnumBase):
    r"""
    EDead Zone Type
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    """

    AXIAL: DeadZoneType #: 0: Apply dead zone to axes individually. This will result in input being chamfered at the corners for 2d/3d axis inputs, and matches the original UE4 deadzone logic.
    RADIAL: DeadZoneType #: 1: Apply dead zone logic to all axes simultaneously. This gives smooth input (circular/spherical coverage). On a 1d axis input this works identically to Axial.
    ...

class FOVScalingType(EnumBase):
    r"""
    EFOVScaling Type
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    """

    STANDARD: FOVScalingType #: 0: FOV scaling to apply scaled movement deltas to inputs dependent upon the player's selected FOV
    UE4_BACK_COMPAT: FOVScalingType #: 1: FOV scaling was incorrectly calculated in UE4's UPlayerInput::MassageAxisInput. This implementation is intended to aid backwards compatibility, but should not be used by new projects.
    ...

class InputAxisSwizzle(EnumBase):
    r"""
    EInput Axis Swizzle
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    """

    YXZ: InputAxisSwizzle #: 0: Swap X and Y axis. Useful for binding 1D inputs to the Y axis for 2D actions.
    ZYX: InputAxisSwizzle #: 1: Swap X and Z axis
    XZY: InputAxisSwizzle #: 2: Swap Y and Z axis
    YZX: InputAxisSwizzle #: 3: Reorder all axes, Y first
    ZXY: InputAxisSwizzle #: 4: Reorder all axes, Z first
    ...

class TriggerState(EnumBase):
    r"""
    Trigger states are a light weight interpretation of the provided input values used in trigger UpdateState responses.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    """

    NONE: TriggerState #: 0: No inputs
    ONGOING: TriggerState #: 1: Triggering is being monitored, but not yet been confirmed (e.g. a time based trigger that requires the trigger state to be maintained over several frames)
    TRIGGERED: TriggerState #: 2: The trigger state has been met
    ...

class TriggerType(EnumBase):
    r"""
    Trigger type determine how the trigger contributes to an action's overall trigger event the behavior of the trigger
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    """

    EXPLICIT: TriggerType #: 0: Input may trigger if any explicit trigger is triggered.
    IMPLICIT: TriggerType #: 1: Input may trigger only if all implicit triggers are triggered.
    BLOCKER: TriggerType #: 2: Inverted trigger that will block all other triggers when IsBlocking returns true
    ...

class TakeRecorderPanelMode(EnumBase):
    r"""
    ETake Recorder Panel Mode
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderPanel.h
    
    """

    NEW_RECORDING: TakeRecorderPanelMode #: 0: The panel is setting up a new recording
    RECORDING_INTO: TakeRecorderPanelMode #: 1: The panel is setting up recording into an existing level sequence
    EDITING_PRESET: TakeRecorderPanelMode #: 2: The panel is editing a Take Preset asset
    REVIEWING_RECORDING: TakeRecorderPanelMode #: 3: The panel is reviewing a previously recorded take
    ...

class StructUtilsResult(EnumBase):
    r"""
    EStruct Utils Result
    
    **C++ Source:**
    
    - **Plugin**: StructUtils
    - **Module**: StructUtilsEngine
    - **File**: StructUtilsFunctionLibrary.h
    
    """

    VALID: StructUtilsResult #: 0
    NOT_VALID: StructUtilsResult #: 1
    ...

class RigVMOpCode(EnumBase):
    r"""
    The code for a single operation within the RigVM
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMByteCode.h
    
    """

    EXECUTE_0_OPERANDS: RigVMOpCode #: 0
    EXECUTE_1_OPERANDS: RigVMOpCode #: 1: (DEPRECATED) execute a rig function with 0 operands
    EXECUTE_2_OPERANDS: RigVMOpCode #: 2: (DEPRECATED) execute a rig function with 1 operands
    EXECUTE_3_OPERANDS: RigVMOpCode #: 3: (DEPRECATED) execute a rig function with 2 operands
    EXECUTE_4_OPERANDS: RigVMOpCode #: 4: (DEPRECATED) execute a rig function with 3 operands
    EXECUTE_5_OPERANDS: RigVMOpCode #: 5: (DEPRECATED) execute a rig function with 4 operands
    EXECUTE_6_OPERANDS: RigVMOpCode #: 6: (DEPRECATED) execute a rig function with 5 operands
    EXECUTE_7_OPERANDS: RigVMOpCode #: 7: (DEPRECATED) execute a rig function with 6 operands
    EXECUTE_8_OPERANDS: RigVMOpCode #: 8: (DEPRECATED) execute a rig function with 7 operands
    EXECUTE_9_OPERANDS: RigVMOpCode #: 9: (DEPRECATED) execute a rig function with 8 operands
    EXECUTE_10_OPERANDS: RigVMOpCode #: 10: (DEPRECATED) execute a rig function with 9 operands
    EXECUTE_11_OPERANDS: RigVMOpCode #: 11: (DEPRECATED) execute a rig function with 10 operands
    EXECUTE_12_OPERANDS: RigVMOpCode #: 12: (DEPRECATED) execute a rig function with 11 operands
    EXECUTE_13_OPERANDS: RigVMOpCode #: 13: (DEPRECATED) execute a rig function with 12 operands
    EXECUTE_14_OPERANDS: RigVMOpCode #: 14: (DEPRECATED) execute a rig function with 13 operands
    EXECUTE_15_OPERANDS: RigVMOpCode #: 15: (DEPRECATED) execute a rig function with 14 operands
    EXECUTE_16_OPERANDS: RigVMOpCode #: 16: (DEPRECATED) execute a rig function with 15 operands
    EXECUTE_17_OPERANDS: RigVMOpCode #: 17: (DEPRECATED) execute a rig function with 16 operands
    EXECUTE_18_OPERANDS: RigVMOpCode #: 18: (DEPRECATED) execute a rig function with 17 operands
    EXECUTE_19_OPERANDS: RigVMOpCode #: 19: (DEPRECATED) execute a rig function with 18 operands
    EXECUTE_20_OPERANDS: RigVMOpCode #: 20: (DEPRECATED) execute a rig function with 19 operands
    EXECUTE_21_OPERANDS: RigVMOpCode #: 21: (DEPRECATED) execute a rig function with 20 operands
    EXECUTE_22_OPERANDS: RigVMOpCode #: 22: (DEPRECATED) execute a rig function with 21 operands
    EXECUTE_23_OPERANDS: RigVMOpCode #: 23: (DEPRECATED) execute a rig function with 22 operands
    EXECUTE_24_OPERANDS: RigVMOpCode #: 24: (DEPRECATED) execute a rig function with 23 operands
    EXECUTE_25_OPERANDS: RigVMOpCode #: 25: (DEPRECATED) execute a rig function with 24 operands
    EXECUTE_26_OPERANDS: RigVMOpCode #: 26: (DEPRECATED) execute a rig function with 25 operands
    EXECUTE_27_OPERANDS: RigVMOpCode #: 27: (DEPRECATED) execute a rig function with 26 operands
    EXECUTE_28_OPERANDS: RigVMOpCode #: 28: (DEPRECATED) execute a rig function with 27 operands
    EXECUTE_29_OPERANDS: RigVMOpCode #: 29: (DEPRECATED) execute a rig function with 28 operands
    EXECUTE_30_OPERANDS: RigVMOpCode #: 30: (DEPRECATED) execute a rig function with 29 operands
    EXECUTE_31_OPERANDS: RigVMOpCode #: 31: (DEPRECATED) execute a rig function with 30 operands
    EXECUTE_32_OPERANDS: RigVMOpCode #: 32: (DEPRECATED) execute a rig function with 31 operands
    EXECUTE_33_OPERANDS: RigVMOpCode #: 33: (DEPRECATED) execute a rig function with 32 operands
    EXECUTE_34_OPERANDS: RigVMOpCode #: 34: (DEPRECATED) execute a rig function with 33 operands
    EXECUTE_35_OPERANDS: RigVMOpCode #: 35: (DEPRECATED) execute a rig function with 34 operands
    EXECUTE_36_OPERANDS: RigVMOpCode #: 36: (DEPRECATED) execute a rig function with 35 operands
    EXECUTE_37_OPERANDS: RigVMOpCode #: 37: (DEPRECATED) execute a rig function with 36 operands
    EXECUTE_38_OPERANDS: RigVMOpCode #: 38: (DEPRECATED) execute a rig function with 37 operands
    EXECUTE_39_OPERANDS: RigVMOpCode #: 39: (DEPRECATED) execute a rig function with 38 operands
    EXECUTE_40_OPERANDS: RigVMOpCode #: 40: (DEPRECATED) execute a rig function with 39 operands
    EXECUTE_41_OPERANDS: RigVMOpCode #: 41: (DEPRECATED) execute a rig function with 40 operands
    EXECUTE_42_OPERANDS: RigVMOpCode #: 42: (DEPRECATED) execute a rig function with 41 operands
    EXECUTE_43_OPERANDS: RigVMOpCode #: 43: (DEPRECATED) execute a rig function with 42 operands
    EXECUTE_44_OPERANDS: RigVMOpCode #: 44: (DEPRECATED) execute a rig function with 43 operands
    EXECUTE_45_OPERANDS: RigVMOpCode #: 45: (DEPRECATED) execute a rig function with 44 operands
    EXECUTE_46_OPERANDS: RigVMOpCode #: 46: (DEPRECATED) execute a rig function with 45 operands
    EXECUTE_47_OPERANDS: RigVMOpCode #: 47: (DEPRECATED) execute a rig function with 46 operands
    EXECUTE_48_OPERANDS: RigVMOpCode #: 48: (DEPRECATED) execute a rig function with 47 operands
    EXECUTE_49_OPERANDS: RigVMOpCode #: 49: (DEPRECATED) execute a rig function with 48 operands
    EXECUTE_50_OPERANDS: RigVMOpCode #: 50: (DEPRECATED) execute a rig function with 49 operands
    EXECUTE_51_OPERANDS: RigVMOpCode #: 51: (DEPRECATED) execute a rig function with 50 operands
    EXECUTE_52_OPERANDS: RigVMOpCode #: 52: (DEPRECATED) execute a rig function with 51 operands
    EXECUTE_53_OPERANDS: RigVMOpCode #: 53: (DEPRECATED) execute a rig function with 52 operands
    EXECUTE_54_OPERANDS: RigVMOpCode #: 54: (DEPRECATED) execute a rig function with 53 operands
    EXECUTE_55_OPERANDS: RigVMOpCode #: 55: (DEPRECATED) execute a rig function with 54 operands
    EXECUTE_56_OPERANDS: RigVMOpCode #: 56: (DEPRECATED) execute a rig function with 55 operands
    EXECUTE_57_OPERANDS: RigVMOpCode #: 57: (DEPRECATED) execute a rig function with 56 operands
    EXECUTE_58_OPERANDS: RigVMOpCode #: 58: (DEPRECATED) execute a rig function with 57 operands
    EXECUTE_59_OPERANDS: RigVMOpCode #: 59: (DEPRECATED) execute a rig function with 58 operands
    EXECUTE_60_OPERANDS: RigVMOpCode #: 60: (DEPRECATED) execute a rig function with 59 operands
    EXECUTE_61_OPERANDS: RigVMOpCode #: 61: (DEPRECATED) execute a rig function with 60 operands
    EXECUTE_62_OPERANDS: RigVMOpCode #: 62: (DEPRECATED) execute a rig function with 61 operands
    EXECUTE_63_OPERANDS: RigVMOpCode #: 63: (DEPRECATED) execute a rig function with 62 operands
    EXECUTE_64_OPERANDS: RigVMOpCode #: 64: (DEPRECATED) execute a rig function with 63 operands
    ZERO: RigVMOpCode #: 65: (DEPRECATED) execute a rig function with 64 operands
    BOOL_FALSE: RigVMOpCode #: 66: zero the memory of a given register
    BOOL_TRUE: RigVMOpCode #: 67: set a given register to false
    COPY: RigVMOpCode #: 68: set a given register to true
    INCREMENT: RigVMOpCode #: 69: copy the content of one register to another
    DECREMENT: RigVMOpCode #: 70: increment a int32 register
    EQUALS: RigVMOpCode #: 71: decrement a int32 register
    NOT_EQUALS: RigVMOpCode #: 72: fill a bool register with the result of (A == B)
    JUMP_ABSOLUTE: RigVMOpCode #: 73: fill a bool register with the result of (A != B)
    JUMP_FORWARD: RigVMOpCode #: 74: jump to an absolute instruction index
    JUMP_BACKWARD: RigVMOpCode #: 75: jump forwards given a relative instruction index offset
    JUMP_ABSOLUTE_IF: RigVMOpCode #: 76: jump backwards given a relative instruction index offset
    JUMP_FORWARD_IF: RigVMOpCode #: 77: jump to an absolute instruction index based on a condition register
    JUMP_BACKWARD_IF: RigVMOpCode #: 78: jump forwards given a relative instruction index offset based on a condition register
    CHANGE_TYPE: RigVMOpCode #: 79: jump backwards given a relative instruction index offset based on a condition register
    EXIT: RigVMOpCode #: 80: change the type of a register (deprecated)
    BEGIN_BLOCK: RigVMOpCode #: 81: exit the execution loop
    END_BLOCK: RigVMOpCode #: 82: begins a new memory slice / block
    ARRAY_RESET: RigVMOpCode #: 83: ends the last memory slice / block
    ARRAY_GET_NUM: RigVMOpCode #: 84: (DEPRECATED) clears an array and resets its content
    ARRAY_SET_NUM: RigVMOpCode #: 85: (DEPRECATED) reads and returns the size of an array (binary op, in array, out int32)
    ARRAY_GET_AT_INDEX: RigVMOpCode #: 86: (DEPRECATED) resizes an array (binary op, in out array, in int32)
    ARRAY_SET_AT_INDEX: RigVMOpCode #: 87: (DEPRECATED) returns an array element by index (ternary op, in array, in int32, out element)
    ARRAY_ADD: RigVMOpCode #: 88: (DEPRECATED) sets an array element by index (ternary op, in out array, in int32, in element)
    ARRAY_INSERT: RigVMOpCode #: 89: (DEPRECATED) adds an element to an array (ternary op, in out array, in element, out int32 index)
    ARRAY_REMOVE: RigVMOpCode #: 90: (DEPRECATED) inserts an element to an array (ternary op, in out array, in int32, in element)
    ARRAY_FIND: RigVMOpCode #: 91: (DEPRECATED) removes an element from an array (binary op, in out array, in inindex)
    ARRAY_APPEND: RigVMOpCode #: 92: (DEPRECATED) finds and returns the index of an element (quaternery op, in array, in element, out int32 index, out bool success)
    ARRAY_CLONE: RigVMOpCode #: 93: (DEPRECATED) appends an array to another (binary op, in out array, in array)
    ARRAY_ITERATOR: RigVMOpCode #: 94: (DEPRECATED) clones an array (binary op, in array, out array)
    ARRAY_UNION: RigVMOpCode #: 95: (DEPRECATED) iterates over an array (senary op, in array, out element, out index, out count, out ratio, out continue)
    ARRAY_DIFFERENCE: RigVMOpCode #: 96: (DEPRECATED) merges two arrays while avoiding duplicates (binary op, in out array, in other array)
    ARRAY_INTERSECTION: RigVMOpCode #: 97: (DEPRECATED) returns a new array containing elements only found in one array (ternary op, in array, in array, out result)
    ARRAY_REVERSE: RigVMOpCode #: 98: (DEPRECATED) returns a new array containing elements found in both of the input arrays (ternary op, in array, in array, out result)
    INVOKE_ENTRY: RigVMOpCode #: 99: (DEPRECATED) returns the reverse of the input array (unary op, in out array)
    JUMP_TO_BRANCH: RigVMOpCode #: 100: invokes an entry from the entry list
    EXECUTE: RigVMOpCode #: 101: jumps to a branch based on a name operand
    RUN_INSTRUCTIONS: RigVMOpCode #: 102: single execute op (formerly Execute_0_Operands to Execute_64_Operands)
    INVALID: RigVMOpCode #: 103: runs a set of instructions lazily
    FIRST_ARRAY_OP_CODE: RigVMOpCode #: 83
    LAST_ARRAY_OP_CODE: RigVMOpCode #: 98
    ...

class ControlRigTestDataPlaybackMode(EnumBase):
    r"""
    EControl Rig Test Data Playback Mode
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigTestData.h
    
    """

    LIVE: ControlRigTestDataPlaybackMode #: 0
    REPLAY_INPUTS: ControlRigTestDataPlaybackMode #: 1
    GROUND_TRUTH: ControlRigTestDataPlaybackMode #: 2
    ...

class RigTransformType(EnumBase):
    r"""
    ERig Transform Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    """

    INITIAL_LOCAL: RigTransformType #: 0
    CURRENT_LOCAL: RigTransformType #: 1
    INITIAL_GLOBAL: RigTransformType #: 2
    CURRENT_GLOBAL: RigTransformType #: 3
    NUM_TRANSFORM_TYPES: RigTransformType #: 4
    ...

class PythonCommandExecutionMode(EnumBase):
    r"""
    Controls the execution mode used for the Python command.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PythonScriptTypes.h
    
    """

    EXECUTE_FILE: PythonCommandExecutionMode #: 0: Execute the Python command as a file. This allows you to execute either a literal Python script containing multiple statements, or a file with optional arguments.
    EXECUTE_STATEMENT: PythonCommandExecutionMode #: 1: Execute the Python command as a single statement. This will execute a single statement and print the result. This mode cannot run files.
    EVALUATE_STATEMENT: PythonCommandExecutionMode #: 2: Evaluate the Python command as a single statement. This will evaluate a single statement and return the result. This mode cannot run files.
    ...

class PythonFileExecutionScope(EnumBase):
    r"""
    Controls the scope used when executing Python files.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PythonScriptTypes.h
    
    """

    PRIVATE: PythonFileExecutionScope #: 0: Execute the Python file with its own unique locals and globals dict to isolate any changes it makes to the environment (like imports).
    PUBLIC: PythonFileExecutionScope #: 1: Execute the Python file with the shared locals and globals dict as used by the console, so that executing it behaves as if you'd ran the file contents directly in the console.
    ...

class LevelViewportType(EnumBase):
    r"""
    ELevelViewportType
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: UnrealEdTypes.h
    
    """

    LVT_ORTHO_XY: LevelViewportType #: 0: Top
    LVT_ORTHO_XZ: LevelViewportType #: 1: Front
    LVT_ORTHO_YZ: LevelViewportType #: 2: Left
    LVT_PERSPECTIVE: LevelViewportType #: 3
    LVT_ORTHO_FREELOOK: LevelViewportType #: 4
    LVT_ORTHO_NEGATIVE_XY: LevelViewportType #: 5: Bottom
    LVT_ORTHO_NEGATIVE_XZ: LevelViewportType #: 6: Back
    LVT_ORTHO_NEGATIVE_YZ: LevelViewportType #: 7: Right
    LVT_MAX: LevelViewportType #: 8
    ...

class NavPathEvent(EnumBase):
    r"""
    ENav Path Event
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationTypes.h
    
    """

    CLEARED: NavPathEvent #: 0
    NEW_PATH: NavPathEvent #: 1
    UPDATED_DUE_TO_GOAL_MOVED: NavPathEvent #: 2
    UPDATED_DUE_TO_NAVIGATION_CHANGED: NavPathEvent #: 3
    INVALIDATED: NavPathEvent #: 4
    RE_PATH_FAILED: NavPathEvent #: 5
    META_PATH_UPDATE: NavPathEvent #: 6
    CUSTOM: NavPathEvent #: 7
    ...

class RigHierarchyNotification(EnumBase):
    r"""
    ERig Hierarchy Notification
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """

    ELEMENT_ADDED: RigHierarchyNotification #: 0
    ELEMENT_REMOVED: RigHierarchyNotification #: 1
    ELEMENT_RENAMED: RigHierarchyNotification #: 2
    ELEMENT_SELECTED: RigHierarchyNotification #: 3
    ELEMENT_DESELECTED: RigHierarchyNotification #: 4
    PARENT_CHANGED: RigHierarchyNotification #: 5
    HIERARCHY_RESET: RigHierarchyNotification #: 6
    CONTROL_SETTING_CHANGED: RigHierarchyNotification #: 7
    CONTROL_VISIBILITY_CHANGED: RigHierarchyNotification #: 8
    CONTROL_DRIVEN_LIST_CHANGED: RigHierarchyNotification #: 9
    CONTROL_SHAPE_TRANSFORM_CHANGED: RigHierarchyNotification #: 10
    PARENT_WEIGHTS_CHANGED: RigHierarchyNotification #: 11
    INTERACTION_BRACKET_OPENED: RigHierarchyNotification #: 12
    INTERACTION_BRACKET_CLOSED: RigHierarchyNotification #: 13
    ELEMENT_REORDERED: RigHierarchyNotification #: 14
    CONNECTOR_SETTING_CHANGED: RigHierarchyNotification #: 15
    SOCKET_COLOR_CHANGED: RigHierarchyNotification #: 16
    SOCKET_DESCRIPTION_CHANGED: RigHierarchyNotification #: 17
    SOCKET_DESIRED_PARENT_CHANGED: RigHierarchyNotification #: 18
    HIERARCHY_COPIED: RigHierarchyNotification #: 19
    ...

class WorldPartitionServerStreamingMode(EnumBase):
    r"""
    EWorld Partition Server Streaming Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartition.h
    
    """

    PROJECT_DEFAULT: WorldPartitionServerStreamingMode #: 0: Use project default (wp.Runtime.EnableServerStreaming)
    DISABLED: WorldPartitionServerStreamingMode #: 1: Server streaming is disabled
    ENABLED: WorldPartitionServerStreamingMode #: 2: Server streaming is enabled
    ENABLED_IN_PIE: WorldPartitionServerStreamingMode #: 3: Server streaming is only enabled in PIE
    ...

class WorldPartitionServerStreamingOutMode(EnumBase):
    r"""
    EWorld Partition Server Streaming Out Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartition.h
    
    """

    PROJECT_DEFAULT: WorldPartitionServerStreamingOutMode #: 0: Use project default (wp.Runtime.EnableServerStreamingOut)
    DISABLED: WorldPartitionServerStreamingOutMode #: 1: Server streaming out is disabled
    ENABLED: WorldPartitionServerStreamingOutMode #: 2: Server streaming out is enabled
    ...

class WorldPartitionDataLayersLogicOperator(EnumBase):
    r"""
    EWorld Partition Data Layers Logic Operator
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartition.h
    
    """

    OR: WorldPartitionDataLayersLogicOperator #: 0
    AND: WorldPartitionDataLayersLogicOperator #: 1
    ...

class PhysicsType(EnumBase):
    r"""
    EPhysics Type
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: BodySetupEnums.h
    
    """

    PHYS_TYPE_DEFAULT: PhysicsType #: 0: Follow owner.
    PHYS_TYPE_KINEMATIC: PhysicsType #: 1: Do not follow owner, but make kinematic.
    PHYS_TYPE_SIMULATED: PhysicsType #: 2: Do not follow owner, but simulate.
    ...

class BodyCollisionResponse(EnumBase):
    r"""
    EBody Collision Response
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: BodySetupEnums.h
    
    """

    BODY_COLLISION_ENABLED: BodyCollisionResponse #: 0
    BODY_COLLISION_DISABLED: BodyCollisionResponse #: 1
    ...

class AnimPhysCollisionType(EnumBase):
    r"""
    Anim Phys Collision Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimPhysicsSolver.h
    
    """

    CO_M: AnimPhysCollisionType #: 0: Only limit the center of mass from crossing planes.
    CUSTOM_SPHERE: AnimPhysCollisionType #: 1: Use the specified sphere radius to collide with planes.
    INNER_SPHERE: AnimPhysCollisionType #: 2: Use the largest sphere that fits entirely within the body extents to collide with planes.
    OUTER_SPHERE: AnimPhysCollisionType #: 3: Use the smallest sphere that wholely contains the body extents to collide with planes.
    ...

class SphericalLimitType(EnumBase):
    r"""
    Whether spheres keep bodies inside, or outside of their shape
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_AnimDynamics.h
    
    """

    INNER: SphericalLimitType #: 0
    OUTER: SphericalLimitType #: 1
    ...

class ConstraintOffsetOption(EnumBase):
    r"""
    Enum value to describe how you'd like to maintain offset
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_Constraint.h
    
    """

    NONE: ConstraintOffsetOption #: 0
    OFFSET_REF_POSE: ConstraintOffsetOption #: 1: no offset
    ...

class FBIKBoneLimitType(EnumBase):
    r"""
    EFBIKBone Limit Type
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: FullBodyIK
    - **File**: FBIKConstraintOption.h
    
    """

    FREE: FBIKBoneLimitType #: 0
    LIMIT: FBIKBoneLimitType #: 1
    LOCKED: FBIKBoneLimitType #: 2: currently hard limit
    ...

class VectorQuantization(EnumBase):
    r"""
    Describes rules for network replicating a vector efficiently
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ReplicatedState.h
    
    """

    ROUND_WHOLE_NUMBER: VectorQuantization #: 0: Each vector component will be rounded to the nearest whole number.
    ROUND_ONE_DECIMAL: VectorQuantization #: 1: Each vector component will be rounded, preserving one decimal place.
    ROUND_TWO_DECIMALS: VectorQuantization #: 2: Each vector component will be rounded, preserving two decimal places.
    ...

class RotatorQuantization(EnumBase):
    r"""
    Describes rules for network replicating a vector efficiently
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ReplicatedState.h
    
    """

    BYTE_COMPONENTS: RotatorQuantization #: 0: The rotator will be compressed to 8 bits per component.
    SHORT_COMPONENTS: RotatorQuantization #: 1: The rotator will be compressed to 16 bits per component.
    ...

class ClusterUnionMethod(EnumBase):
    r"""
    ECluster Union Method
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: ChaosSolverConfiguration.h
    
    """

    POINT_IMPLICIT: ClusterUnionMethod #: 0
    DELAUNAY_TRIANGULATION: ClusterUnionMethod #: 1
    MINIMAL_SPANNING_SUBSET_DELAUNAY_TRIANGULATION: ClusterUnionMethod #: 2
    POINT_IMPLICIT_AUGMENTED_WITH_MINIMAL_DELAUNAY: ClusterUnionMethod #: 3
    BOUNDS_OVERLAP_FILTERED_DELAUNAY_TRIANGULATION: ClusterUnionMethod #: 4
    NONE: ClusterUnionMethod #: 5
    ...

class HeightFieldRenderMode(EnumBase):
    r"""
    EHeight Field Render Mode
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: RecastNavMesh.h
    
    """

    SOLID: HeightFieldRenderMode #: 0
    WALKABLE: HeightFieldRenderMode #: 1
    ...

class BoneTranslationRetargetingMode(EnumBase):
    r"""
    Bone translation retargeting mode.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Skeleton.h
    
    """

    ANIMATION: BoneTranslationRetargetingMode #: 0: Use translation from animation data.
    SKELETON: BoneTranslationRetargetingMode #: 1: Use fixed translation from Skeleton.
    ANIMATION_SCALED: BoneTranslationRetargetingMode #: 2: Use Translation from animation, but scale length by Skeleton's proportions.
    ANIMATION_RELATIVE: BoneTranslationRetargetingMode #: 3: Use Translation from animation, but also play the difference from retargeting pose as an additive.
    ORIENT_AND_SCALE: BoneTranslationRetargetingMode #: 4: Apply delta orientation and scale from ref pose
    ...

class SoundWaveCloudStreamingPlatformEnableType(EnumBase):
    r"""
    Platform specific enabling of Sound Wave cloud streaming.
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: ISoundWaveCloudStreaming.h
    
    """

    INHERITED: SoundWaveCloudStreamingPlatformEnableType #: 0: Use Sound Wave setting.
    DISABLED: SoundWaveCloudStreamingPlatformEnableType #: 1: Disables Sound Wave cloud streaming for this platform.
    ...

class TestEnumFlags(EnumBase):
    r"""
    ETest Enum Flags
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    """

    NONE: TestEnumFlags #: 0
    ONE: TestEnumFlags #: 1
    TWO: TestEnumFlags #: 2
    FOUR: TestEnumFlags #: 4
    ...

class LandscapeLayerBlendType(EnumBase):
    r"""
    ELandscape Layer Blend Type
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeLayerBlend.h
    
    """

    LB_WEIGHT_BLEND: LandscapeLayerBlendType #: 0
    LB_ALPHA_BLEND: LandscapeLayerBlendType #: 1
    LB_HEIGHT_BLEND: LandscapeLayerBlendType #: 2
    ...

class FilterInterpolationType(EnumBase):
    r"""
    Interpolation method used by animation blending
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """

    BSIT_AVERAGE: FilterInterpolationType #: 0
    BSIT_LINEAR: FilterInterpolationType #: 1
    BSIT_CUBIC: FilterInterpolationType #: 2
    BSIT_EASE_IN_OUT: FilterInterpolationType #: 3
    BSIT_EXPONENTIAL_DECAY: FilterInterpolationType #: 4
    BSIT_SPRING_DAMPER: FilterInterpolationType #: 5
    ...

class DataDrivenShaderPlatformInfoCondition(EnumBase):
    r"""
    EData Driven Shader Platform Info Condition
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDataDrivenShaderPlatformInfoSwitch.h
    
    """

    COND_TRUE: DataDrivenShaderPlatformInfoCondition #: 0
    COND_FALSE: DataDrivenShaderPlatformInfoCondition #: 1
    ...

class HierarchicalSimplificationMethod(EnumBase):
    r"""
    EHierarchical Simplification Method
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldSettings.h
    
    """

    MERGE: HierarchicalSimplificationMethod #: 1
    SIMPLIFY: HierarchicalSimplificationMethod #: 2
    APPROXIMATE: HierarchicalSimplificationMethod #: 3
    ...

class MirrorFindReplaceMethod(EnumBase):
    r"""
    Find and Replace Method for FMirrorFindReplaceExpression.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MirrorDataTable.h
    
    """

    PREFIX: MirrorFindReplaceMethod #: 0: Only find and replace matching strings at the start of the name
    SUFFIX: MirrorFindReplaceMethod #: 1: Only find and replace matching strings at the end of the name
    REGULAR_EXPRESSION: MirrorFindReplaceMethod #: 2: Use regular expressions for find and replace, including support for captures $1 - $10
    ...

class FontImportCharacterSet(EnumBase):
    r"""
    Font character set type for importing TrueType fonts.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: FontImportOptions.h
    
    """

    FONT_ICS_DEFAULT: FontImportCharacterSet #: 0
    FONT_ICS_ANSI: FontImportCharacterSet #: 1
    FONT_ICS_SYMBOL: FontImportCharacterSet #: 2
    ...

class ChaosThreadingMode(EnumBase):
    r"""
    EChaos Threading Mode
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: PhysicsCoreTypes.h
    
    """

    TASK_GRAPH: ChaosThreadingMode #: 1
    SINGLE_THREAD: ChaosThreadingMode #: 2
    ...

class ChaosSolverTickMode(EnumBase):
    r"""
    EChaos Solver Tick Mode
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: PhysicsCoreTypes.h
    
    """

    FIXED: ChaosSolverTickMode #: 0
    VARIABLE: ChaosSolverTickMode #: 1
    VARIABLE_CAPPED: ChaosSolverTickMode #: 2
    VARIABLE_CAPPED_WITH_TARGET: ChaosSolverTickMode #: 3
    ...

class ChaosBufferMode(EnumBase):
    r"""
    EChaos Buffer Mode
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: PhysicsCoreTypes.h
    
    """

    DOUBLE: ChaosBufferMode #: 0
    TRIPLE: ChaosBufferMode #: 1
    ...

class PrimaryAssetCookRule(EnumBase):
    r"""
    Rule about when to cook/ship a primary asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AssetManagerTypes.h
    
    """

    UNKNOWN: PrimaryAssetCookRule #: 0: Nothing is known about this asset specifically. It will cook in both Development and Production if something else depends on it.
    NEVER_COOK: PrimaryAssetCookRule #: 1: Asset should never be cooked/shipped in any situation. An error will be generated if something depends on it.
    PRODUCTION_NEVER_COOK: PrimaryAssetCookRule #: 2: Asset will be cooked in development if something else depends on it, but will never be cooked in a production build.
    DEVELOPMENT_COOK: PrimaryAssetCookRule #: 2: Legacy name equivalent to Production Never Cook
    DEVELOPMENT_ALWAYS_PRODUCTION_NEVER_COOK: PrimaryAssetCookRule #: 3: Asset will always be cooked in development, but should never be cooked in a production build.
    DEVELOPMENT_ALWAYS_COOK: PrimaryAssetCookRule #: 3: Legacy name equivalent to DevelopmentAlwaysProductionNeverCook
    DEVELOPMENT_ALWAYS_PRODUCTION_UNKNOWN_COOK: PrimaryAssetCookRule
    r"""
    4: Asset will always be cooked in development; nothing is known about whether it should cook in Production. It will cook
    in production if something else depends on it.
    """

    ALWAYS_COOK: PrimaryAssetCookRule #: 5: Asset will always be cooked, in both production and development.
    ...

class BoneFilterActionOption(EnumBase):
    r"""
    EBone Filter Action Option
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshLODSettings.h
    
    """

    REMOVE: BoneFilterActionOption #: 0: Remove list of joints specified and children. All the other joints will be kept.
    KEEP: BoneFilterActionOption #: 1: Only keep the joints specified and parents. All the other joints will be removed.
    ...

class AnimPhysLinearConstraintType(EnumBase):
    r"""
    Supported linear axis constraints
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_AnimDynamics.h
    
    """

    FREE: AnimPhysLinearConstraintType #: 0
    LIMITED: AnimPhysLinearConstraintType #: 1
    ...

class AnimPhysAxisType(EnumBase):
    r"""
    deprecated: 'AnimPhysAxisType' was renamed to 'AnimPhysLinearConstraintType'.
    """

    FREE: AnimPhysAxisType #: 0
    LIMITED: AnimPhysAxisType #: 1
    ...

class AnimPhysAngularConstraintType(EnumBase):
    r"""
    Supported angular constraint types
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_AnimDynamics.h
    
    """

    ANGULAR: AnimPhysAngularConstraintType #: 0
    CONE: AnimPhysAngularConstraintType #: 1
    ...

class AnimPhysConstraintType(EnumBase):
    r"""
    deprecated: 'AnimPhysConstraintType' was renamed to 'AnimPhysAngularConstraintType'.
    """

    ANGULAR: AnimPhysConstraintType #: 0
    CONE: AnimPhysConstraintType #: 1
    ...

class AnimPhysTwistAxis(EnumBase):
    r"""
    Enum for picking current angular twist axis
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimPhysicsSolver.h
    
    """

    AXIS_X: AnimPhysTwistAxis #: 0
    AXIS_Y: AnimPhysTwistAxis #: 1
    AXIS_Z: AnimPhysTwistAxis #: 2
    ...

class MaterialLayerLinkState(EnumBase):
    r"""
    EMaterial Layer Link State
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialLayersFunctions.h
    
    """

    UNINITIALIZED: MaterialLayerLinkState #: 0
    LINKED_TO_PARENT: MaterialLayerLinkState #: 1: Saved with previous engine version
    UNLINKED_FROM_PARENT: MaterialLayerLinkState #: 2: Layer should mirror changes from parent material
    NOT_FROM_PARENT: MaterialLayerLinkState #: 3: Layer is based on parent material, but should not mirror changes
    ...

class SkeletalMeshTerminationCriterion(EnumBase):
    r"""
    Enum specifying the reduction type to use when simplifying skeletal meshes with internal tool
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshReductionSettings.h
    
    """

    SMTC_NUM_OF_TRIANGLES: SkeletalMeshTerminationCriterion #: 0: Triangle count criterion will be used for simplification.
    SMTC_NUM_OF_VERTS: SkeletalMeshTerminationCriterion #: 1: Vertex cont criterion will be used for simplification.
    SMTC_TRIANGLE_OR_VERT: SkeletalMeshTerminationCriterion #: 2: Simplification will continue until either Triangle or Vertex count criteria is met.
    SMTC_ABS_NUM_OF_TRIANGLES: SkeletalMeshTerminationCriterion #: 3: Triangle count criterion will be used for simplification.
    SMTC_ABS_NUM_OF_VERTS: SkeletalMeshTerminationCriterion #: 4: Vertex cont criterion will be used for simplification.
    SMTC_ABS_TRIANGLE_OR_VERT: SkeletalMeshTerminationCriterion #: 5: Simplification will continue until either Triangle or Vertex count criteria is met.
    ...

class SkeletalMeshOptimizationType(EnumBase):
    r"""
    Enum specifying the reduction type to use when simplifying skeletal meshes with Simmplygon
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshReductionSettings.h
    
    """

    SMOT_NUM_OF_TRIANGLES: SkeletalMeshOptimizationType #: 0: Triangle requirement will be used for simplification.
    SMOT_MAX_DEVIATION: SkeletalMeshOptimizationType #: 1: Accuracy requirement will be used for simplification.
    SMOT_TRIANGLE_OR_DEVIATION: SkeletalMeshOptimizationType #: 2: Simplification will continue until either Triangle or Accuracy requirement is met.
    ...

class SkeletalMeshOptimizationImportance(EnumBase):
    r"""
    Enum specifying the importance of properties when simplifying skeletal meshes.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshReductionSettings.h
    
    """

    SMOI_OFF: SkeletalMeshOptimizationImportance #: 0
    SMOI_LOWEST: SkeletalMeshOptimizationImportance #: 1
    SMOI_LOW: SkeletalMeshOptimizationImportance #: 2
    SMOI_NORMAL: SkeletalMeshOptimizationImportance #: 3
    SMOI_HIGH: SkeletalMeshOptimizationImportance #: 4
    SMOI_HIGHEST: SkeletalMeshOptimizationImportance #: 5
    ...

class SkeletalMeshVertexAttributeDataType(EnumBase):
    r"""
    ESkeletal Mesh Vertex Attribute Data Type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshVertexAttribute.h
    
    """

    FLOAT: SkeletalMeshVertexAttributeDataType #: 0: Store the vertex attribute values as a 32-bit floating point (float)
    HALF_FLOAT: SkeletalMeshVertexAttributeDataType #: 1: Store the vertex attribute values as a 16-bit floating point (half)
    NU_INT8: SkeletalMeshVertexAttributeDataType #: 2: Quantize and store the vertex attribute values as an unsigned normalized 8-bit integer. Values outside the [0.0 - 1.0] range are clamped.
    ...

class ConstantQNormalizationEnum(EnumBase):
    r"""
    EConstantQNormalizationEnum
    
    Enumeration of available normalization schemes for ConstantQ frequency domain windows.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: ConstantQNRT.h
    
    """

    EQUAL_EUCLIDEAN_NORM: ConstantQNormalizationEnum #: 0: Normalize bands by euclidean norm. Good when using magnitude spectrum.
    EQUAL_ENERGY: ConstantQNormalizationEnum #: 1: Normalize bands by energy. Good when using power spectrum.
    EQUAL_AMPLITUDE: ConstantQNormalizationEnum #: 2: Normalize bands by their maximum values. Will result in relatively strong high frequences because the upper constant Q bands have larger bandwidths.
    ...

class ConstantQFFTSizeEnum(EnumBase):
    r"""
    EContantQFFTSizeEnum
    
    Enumeration of available FFT sizes in audio frames.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: ConstantQNRT.h
    
    """

    MIN: ConstantQFFTSizeEnum #: 0: 64
    XX_SMALL: ConstantQFFTSizeEnum #: 1: 128
    X_SMALL: ConstantQFFTSizeEnum #: 2: 256
    SMALL: ConstantQFFTSizeEnum #: 3: 512
    MEDIUM: ConstantQFFTSizeEnum #: 4: 1024
    LARGE: ConstantQFFTSizeEnum #: 5: 2048
    X_LARGE: ConstantQFFTSizeEnum #: 6: 4096
    XX_LARGE: ConstantQFFTSizeEnum #: 7: 8192
    MAX: ConstantQFFTSizeEnum #: 8: 16384
    ...

class LoudnessCurveTypeEnum(EnumBase):
    r"""
    ELoudnessCurveTypeEnum
    
    Enumeration of available equal loudness curves. Loudness curves based on IEC 61672-1:2013 Electroacoustics - Sound level meters - Part 1: Specifications.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Loudness.h
    
    """

    A: LoudnessCurveTypeEnum #: 0: Loudness Curve A Weighting. Commonly used in environmental sound measurements. Best for low level sounds.
    B: LoudnessCurveTypeEnum #: 1: Loudness Curve B Weighting. Relative to "A", gives more precedence to frequencies below 1kHz.
    C: LoudnessCurveTypeEnum #: 2: Loudness Curve C Weighting. Relative to "A" and "B", gives more precedence to frequencies below 1kHz.
    D: LoudnessCurveTypeEnum #: 3: Loudness Curve D Weighting. Similar to "B" but with an emphasis on presence in the 2kHz-6KHz frequency range.
    NONE: LoudnessCurveTypeEnum #: 4: No loudness curve weighting.
    ...

class LoudnessNRTCurveTypeEnum(EnumBase):
    r"""
    ELoudnessNRTCurveTypeEnum
    
    Enumeration of available equal loudness curves. Loudness curves based on IEC 61672-1:2013 Electroacoustics - Sound level meters - Part 1: Specifications.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: LoudnessNRT.h
    
    """

    A: LoudnessNRTCurveTypeEnum #: 0: Loudness Curve A Weighting. Commonly used in environmental sound measurements. Best for low level sounds.
    B: LoudnessNRTCurveTypeEnum #: 1: Loudness Curve B Weighting. Relative to "A", gives more precedence to frequencies below 1kHz.
    C: LoudnessNRTCurveTypeEnum #: 2: Loudness Curve C Weighting. Relative to "A" and "B", gives more precedence to frequencies below 1kHz.
    D: LoudnessNRTCurveTypeEnum #: 3: Loudness Curve D Weighting. Similar to "B" but with an emphasis on presence in the 2kHz-6KHz frequency range.
    NONE: LoudnessNRTCurveTypeEnum #: 4: No loudness curve weighting.
    ...

class MeterPeakType(EnumBase):
    r"""
    EMeter Peak Type
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Meter.h
    
    """

    MEAN_SQUARED: MeterPeakType #: 0
    ROOT_MEAN_SQUARED: MeterPeakType #: 1
    PEAK: MeterPeakType #: 2
    ...

class SetParamResult(EnumBase):
    r"""
    ESet Param Result
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundParameterPack.h
    
    """

    SUCCEEDED: SetParamResult #: 0
    FAILED: SetParamResult #: 1
    ...

class WaveTableBitDepth(EnumBase):
    r"""
    namespace WaveTable
    
    **C++ Source:**
    
    - **Plugin**: WaveTable
    - **Module**: WaveTable
    - **File**: WaveTable.h
    
    """

    PCM_16: WaveTableBitDepth
    r"""
    0: Lower resolution and marginal performance cost with
    conversion overhead (engine operates on 32-bit)
    with the advantage of half the size in memory.
    """

    IEEE_FLOAT: WaveTableBitDepth
    r"""
    1: Higher precision and faster operative performance
    (engine operates at 32-bit) at the cost of twice the
    memory of 16-bit.
    """

    ...

class WaveTableResolution(EnumBase):
    r"""
    namespace WaveTable
    
    **C++ Source:**
    
    - **Plugin**: WaveTable
    - **Module**: WaveTable
    - **File**: WaveTableSettings.h
    
    """

    RES_8: WaveTableResolution #: 3
    RES_16: WaveTableResolution #: 4
    RES_32: WaveTableResolution #: 5
    RES_64: WaveTableResolution #: 6
    RES_128: WaveTableResolution #: 7
    RES_256: WaveTableResolution #: 8
    RES_512: WaveTableResolution #: 9
    RES_1024: WaveTableResolution #: 10
    RES_2048: WaveTableResolution #: 11
    RES_4096: WaveTableResolution #: 12
    MAXIMUM: WaveTableResolution
    r"""
    13: Takes largest source file length (if WaveTable was produced
    by a file, PCM stream, SoundWave, etc.) of superset of waves,
    or Res_Max if all superset of waves were produced by curves. This
    can be very memory intensive if source file is large!
    """

    ...

class WaveTableCurve(EnumBase):
    r"""
    EWave Table Curve
    
    **C++ Source:**
    
    - **Plugin**: WaveTable
    - **Module**: WaveTable
    - **File**: WaveTableSettings.h
    
    """

    LINEAR: WaveTableCurve #: 0
    LINEAR_INV: WaveTableCurve #: 1
    EXP: WaveTableCurve #: 2
    EXP_INVERSE: WaveTableCurve #: 3
    LOG: WaveTableCurve #: 4
    SIN: WaveTableCurve #: 5
    SIN_FULL: WaveTableCurve #: 6
    S_CURVE: WaveTableCurve #: 7
    SHARED: WaveTableCurve #: 8: Reference a shared curve asset
    CUSTOM: WaveTableCurve #: 9: Design a custom curve unique to the owning transform
    FILE: WaveTableCurve #: 10: Generate WaveTable from audio file
    ...

class WaveTableSamplingMode(EnumBase):
    r"""
    SamplingMode of a given bank or collection of WaveTables
    
    **C++ Source:**
    
    - **Plugin**: WaveTable
    - **Module**: WaveTable
    - **File**: WaveTableSettings.h
    
    """

    FIXED_SAMPLE_RATE: WaveTableSamplingMode
    r"""
    0: Enforces fixed sample rate for all members in the bank/collection,
    enabling them to be of unique duration/number of samples. Good for
    use cases when entries are being treated as separate, discrete but
    related audio to be played back at a shared speed (ex. traditional
    "samplers" or granulation).
    """

    FIXED_RESOLUTION: WaveTableSamplingMode
    r"""
    1: Enforces resolution (i.e. size of all tables), uniformly resampling
    all tables in the collection to be the same length/number of samples
    (if not already).  Supports use cases where systems are mixing/
    interpolating or spatializing entries in lockstep (ex. oscillating
    or enveloping).
    """

    ...

class MetaSoundBuilderResult(EnumBase):
    r"""
    EMeta Sound Builder Result
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundBuilderSubsystem.h
    
    """

    SUCCEEDED: MetaSoundBuilderResult #: 0
    FAILED: MetaSoundBuilderResult #: 1
    ...

class MetaSoundOutputAudioFormat(EnumBase):
    r"""
    Declares supported MetaSound output audio formats
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundOutputFormatInterfaces.h
    
    """

    MONO: MetaSoundOutputAudioFormat #: 0
    STEREO: MetaSoundOutputAudioFormat #: 1
    QUAD: MetaSoundOutputAudioFormat #: 2
    FIVE_DOT_ONE: MetaSoundOutputAudioFormat #: 3
    SEVEN_DOT_ONE: MetaSoundOutputAudioFormat #: 4
    ...

class MetasoundFrontendClassType(EnumBase):
    r"""
    EMetasound Frontend Class Type
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    """

    EXTERNAL: MetasoundFrontendClassType #: 0: The MetaSound class is defined externally, in compiled code or in another document.
    GRAPH: MetasoundFrontendClassType #: 1: The MetaSound class is a graph within the containing document.
    INPUT: MetasoundFrontendClassType #: 2: The MetaSound class is an input into a graph in the containing document.
    OUTPUT: MetasoundFrontendClassType #: 3: The MetaSound class is an output from a graph in the containing document.
    LITERAL: MetasoundFrontendClassType #: 4: The MetaSound class is an literal requiring an literal value to construct.
    VARIABLE: MetasoundFrontendClassType #: 5: The MetaSound class is an variable requiring an literal value to construct.
    VARIABLE_DEFERRED_ACCESSOR: MetasoundFrontendClassType #: 6: The MetaSound class accesses variables.
    VARIABLE_ACCESSOR: MetasoundFrontendClassType #: 7: The MetaSound class accesses variables.
    VARIABLE_MUTATOR: MetasoundFrontendClassType #: 8: The MetaSound class mutates variables.
    TEMPLATE: MetasoundFrontendClassType
    r"""
    9: The MetaSound class is defined only by the Frontend, and associatively
    performs a functional operation within the given document in a registration/cook step.
    """

    ...

class AudioPanelLayoutType(EnumBase):
    r"""
    EAudio Panel Layout Type
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioWidgetsEnums.h
    
    """

    BASIC: AudioPanelLayoutType #: 0
    ADVANCED: AudioPanelLayoutType #: 1
    ...

class YAxisLabelsUnit(EnumBase):
    r"""
    EYAxis Labels Unit
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: SAudioOscilloscopePanelWidget.h
    
    """

    LINEAR: YAxisLabelsUnit #: 0
    DB: YAxisLabelsUnit #: 1
    ...

class XAxisLabelsUnit(EnumBase):
    r"""
    EXAxis Labels Unit
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: SAudioOscilloscopePanelWidget.h
    
    """

    SAMPLES: XAxisLabelsUnit #: 0
    SECONDS: XAxisLabelsUnit #: 1
    ...

class AudioColorGradient(EnumBase):
    r"""
    EAudio Color Gradient
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioColorMapper.h
    
    """

    BLACK_TO_WHITE: AudioColorGradient #: 0
    WHITE_TO_BLACK: AudioColorGradient #: 1
    ...

class AudioOscilloscopeTriggerMode(EnumBase):
    r"""
    EAudio Oscilloscope Trigger Mode
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioOscilloscopeEnums.h
    
    """

    NONE: AudioOscilloscopeTriggerMode #: 0
    RISING: AudioOscilloscopeTriggerMode #: 1
    FALLING: AudioOscilloscopeTriggerMode #: 2
    ...

class AudioSpectrogramFrequencyAxisScale(EnumBase):
    r"""
    EAudio Spectrogram Frequency Axis Scale
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioSpectrogramViewport.h
    
    """

    LINEAR: AudioSpectrogramFrequencyAxisScale #: 0
    LOGARITHMIC: AudioSpectrogramFrequencyAxisScale #: 1
    ...

class AudioSpectrogramFrequencyAxisPixelBucketMode(EnumBase):
    r"""
    EAudio Spectrogram Frequency Axis Pixel Bucket Mode
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioSpectrogramViewport.h
    
    """

    SAMPLE: AudioSpectrogramFrequencyAxisPixelBucketMode #: 0: Plot one data point per frequency axis pixel bucket only, choosing the data point nearest the pixel center.
    PEAK: AudioSpectrogramFrequencyAxisPixelBucketMode #: 1: Plot one data point per frequency axis pixel bucket only, choosing the data point with the highest sound level.
    AVERAGE: AudioSpectrogramFrequencyAxisPixelBucketMode #: 2: Plot the average of the data points in each frequency axis pixel bucket.
    ...

class AudioSpectrumPlotFrequencyAxisScale(EnumBase):
    r"""
    EAudio Spectrum Plot Frequency Axis Scale
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: SAudioSpectrumPlot.h
    
    """

    LINEAR: AudioSpectrumPlotFrequencyAxisScale #: 0
    LOGARITHMIC: AudioSpectrumPlotFrequencyAxisScale #: 1
    ...

class AudioSpectrumPlotFrequencyAxisPixelBucketMode(EnumBase):
    r"""
    EAudio Spectrum Plot Frequency Axis Pixel Bucket Mode
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: SAudioSpectrumPlot.h
    
    """

    SAMPLE: AudioSpectrumPlotFrequencyAxisPixelBucketMode #: 0: Plot one data point per frequency axis pixel bucket only, choosing the data point nearest the pixel center.
    PEAK: AudioSpectrumPlotFrequencyAxisPixelBucketMode #: 1: Plot one data point per frequency axis pixel bucket only, choosing the data point with the highest sound level.
    AVERAGE: AudioSpectrumPlotFrequencyAxisPixelBucketMode #: 2: Plot the average of the data points in each frequency axis pixel bucket.
    ...

class AudioRadialSliderLayout(EnumBase):
    r"""
    EAudio Radial Slider Layout
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: SAudioRadialSlider.h
    
    """

    LAYOUT_LABEL_TOP: AudioRadialSliderLayout #: 0: Label above radial slider.
    LAYOUT_LABEL_CENTER: AudioRadialSliderLayout #: 1: Label in the center of the radial slider.
    LAYOUT_LABEL_BOTTOM: AudioRadialSliderLayout #: 2: Label below radial slider.
    ...

class ProcMeshSliceCapOption(EnumBase):
    r"""
    Options for creating cap geometry when slicing
    
    **C++ Source:**
    
    - **Plugin**: ProceduralMeshComponent
    - **Module**: ProceduralMeshComponent
    - **File**: KismetProceduralMeshLibrary.h
    
    """

    NO_CAP: ProcMeshSliceCapOption #: 0: Do not create cap geometry
    CREATE_NEW_SECTION_FOR_CAP: ProcMeshSliceCapOption #: 1: Add a new section to ProceduralMesh for cap
    USE_LAST_SECTION_FOR_CAP: ProcMeshSliceCapOption #: 2: Add cap geometry to existing last section
    ...

class LocationAccuracy(EnumBase):
    r"""
    Enum used to determine what accuracy the Location Services should be run with. Based off the iOS kCLLocationAccuracy
    enums since those were the most restrictive (but convienently also had descriptive names)
    
    **C++ Source:**
    
    - **Plugin**: LocationServicesBPLibrary
    - **Module**: LocationServicesBPLibrary
    - **File**: LocationServicesBPLibrary.h
    
    """

    LA_THREE_KILOMETERS: LocationAccuracy #: 0
    LA_ONE_KILOMETER: LocationAccuracy #: 1
    LA_HUNDRED_METERS: LocationAccuracy #: 2
    LA_TEN_METERS: LocationAccuracy #: 3
    LA_BEST: LocationAccuracy #: 4
    LA_NAVIGATION: LocationAccuracy #: 5
    ...

class RaQualityMode(EnumBase):
    r"""
    ERa Quality Mode
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudio
    - **File**: ResonanceAudioEnums.h
    
    """

    STEREO_PANNING: RaQualityMode #: 0: Stereo panning.
    BINAURAL_LOW: RaQualityMode #: 1: Binaural Low (First Order Ambisonics).
    BINAURAL_MEDIUM: RaQualityMode #: 2: Binaural Medium (Second Order Ambisonics).
    BINAURAL_HIGH: RaQualityMode #: 3: Binaural High (Third Order Ambisonics = Default).
    ...

class RaSpatializationMethod(EnumBase):
    r"""
    ERa Spatialization Method
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudio
    - **File**: ResonanceAudioEnums.h
    
    """

    STEREO_PANNING: RaSpatializationMethod #: 0: Stereo panning.
    HRTF: RaSpatializationMethod #: 1: Binaural rendering via HRTF.
    ...

class RaDistanceRolloffModel(EnumBase):
    r"""
    ERa Distance Rolloff Model
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudio
    - **File**: ResonanceAudioEnums.h
    
    """

    LOGARITHMIC: RaDistanceRolloffModel #: 0: Logarithmic distance attenuation model (default).
    LINEAR: RaDistanceRolloffModel #: 1: Linear distance attenuation model.
    NONE: RaDistanceRolloffModel #: 2: Use Unreal Engine attenuation settings.
    ...

class RaMaterialName(EnumBase):
    r"""
    ERa Material Name
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudio
    - **File**: ResonanceAudioEnums.h
    
    """

    TRANSPARENT: RaMaterialName #: 0: Full acoustic energy absorption.
    ACOUSTIC_CEILING_TILES: RaMaterialName #: 1
    BRICK_BARE: RaMaterialName #: 2
    BRICK_PAINTED: RaMaterialName #: 3
    CONCRETE_BLOCK_COARSE: RaMaterialName #: 4
    CONCRETE_BLOCK_PAINTED: RaMaterialName #: 5
    CURTAIN_HEAVY: RaMaterialName #: 6
    FIBER_GLASS_INSULATION: RaMaterialName #: 7
    GLASS_THIN: RaMaterialName #: 8
    GLASS_THICK: RaMaterialName #: 9
    GRASS: RaMaterialName #: 10
    LINOLEUM_ON_CONCRETE: RaMaterialName #: 11
    MARBLE: RaMaterialName #: 12
    METAL: RaMaterialName #: 13
    PARQUET_ONCONCRETE: RaMaterialName #: 14
    PLASTER_ROUGH: RaMaterialName #: 15
    PLASTER_SMOOTH: RaMaterialName #: 16
    PLYWOOD_PANEL: RaMaterialName #: 17
    POLISHED_CONCRETE_OR_TILE: RaMaterialName #: 18
    SHEETROCK: RaMaterialName #: 19
    WATER_OR_ICE_SURFACE: RaMaterialName #: 20
    WOOD_CEILING: RaMaterialName #: 21
    WOOD_PANEL: RaMaterialName #: 22
    UNIFORM: RaMaterialName #: 23: Uniform acoustic energy absorption across all frequency bands.
    ...

class ResonanceRenderMode(EnumBase):
    r"""
    EResonance Render Mode
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudio
    - **File**: ResonanceAudioAmbisonicsSettings.h
    
    """

    STEREO_PANNING: ResonanceRenderMode #: 0: Stereo panning, i.e., this disables HRTF-based rendering.
    BINAURAL_LOW_QUALITY: ResonanceRenderMode
    r"""
    1: HRTF-based rendering using First Order Ambisonics, over a virtual array of
    8 loudspeakers arranged in a cube configuration around the listener's head.
    """

    BINAURAL_MEDIUM_QUALITY: ResonanceRenderMode
    r"""
    2: HRTF-based rendering using Second Order Ambisonics, over a virtual array of
    12 loudspeakers arranged in a dodecahedral configuration (using faces of
    the dodecahedron).
    """

    BINAURAL_HIGH_QUALITY: ResonanceRenderMode
    r"""
    3: HRTF-based rendering using Third Order Ambisonics, over a virtual array of
    26 loudspeakers arranged in a Lebedev grid: https:goo.gl/DX1wh3.
    """

    ROOM_EFFECTS_ONLY: ResonanceRenderMode
    r"""
    4: Room effects only rendering. This disables HRTF-based rendering and direct
    (dry) output of a sound object. Note that this rendering mode should *not*
    be used for general-purpose sound object spatialization, as it will only
    render the corresponding room effects of given sound objects without the
    direct spatialization.
    """

    ...

class Synth1OscType(EnumBase):
    r"""
    ESynth 1Osc Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """

    SINE: Synth1OscType #: 0
    SAW: Synth1OscType #: 1
    TRIANGLE: Synth1OscType #: 2
    SQUARE: Synth1OscType #: 3
    NOISE: Synth1OscType #: 4
    ...

class SynthLFOType(EnumBase):
    r"""
    ESynth LFOType
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """

    SINE: SynthLFOType #: 0
    UP_SAW: SynthLFOType #: 1
    DOWN_SAW: SynthLFOType #: 2
    SQUARE: SynthLFOType #: 3
    TRIANGLE: SynthLFOType #: 4
    EXPONENTIAL: SynthLFOType #: 5
    RANDOM_SAMPLE_HOLD: SynthLFOType #: 6
    ...

class SynthLFOMode(EnumBase):
    r"""
    ESynth LFOMode
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """

    SYNC: SynthLFOMode #: 0
    ONE_SHOT: SynthLFOMode #: 1
    FREE: SynthLFOMode #: 2
    ...

class SynthLFOPatchType(EnumBase):
    r"""
    ESynth LFOPatch Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """

    PATCH_TO_NONE: SynthLFOPatchType #: 0
    PATCH_TO_GAIN: SynthLFOPatchType #: 1
    PATCH_TO_OSC_FREQ: SynthLFOPatchType #: 2
    PATCH_TO_FILTER_FREQ: SynthLFOPatchType #: 3
    PATCH_TO_FILTER_Q: SynthLFOPatchType #: 4
    PATCH_TO_OSC_PULSE_WIDTH: SynthLFOPatchType #: 5
    PATCH_TO_OSC_PAN: SynthLFOPatchType #: 6
    PATCH_LFO1_TO_LFO2_FREQUENCY: SynthLFOPatchType #: 7
    PATCH_LFO1_TO_LFO2_GAIN: SynthLFOPatchType #: 8
    ...

class SynthModEnvPatch(EnumBase):
    r"""
    ESynth Mod Env Patch
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """

    PATCH_TO_NONE: SynthModEnvPatch #: 0
    PATCH_TO_OSC_FREQ: SynthModEnvPatch #: 1
    PATCH_TO_FILTER_FREQ: SynthModEnvPatch #: 2
    PATCH_TO_FILTER_Q: SynthModEnvPatch #: 3
    PATCH_TO_LFO1_GAIN: SynthModEnvPatch #: 4
    PATCH_TO_LFO2_GAIN: SynthModEnvPatch #: 5
    PATCH_TO_LFO1_FREQ: SynthModEnvPatch #: 6
    PATCH_TO_LFO2_FREQ: SynthModEnvPatch #: 7
    ...

class SynthModEnvBiasPatch(EnumBase):
    r"""
    ESynth Mod Env Bias Patch
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """

    PATCH_TO_NONE: SynthModEnvBiasPatch #: 0
    PATCH_TO_OSC_FREQ: SynthModEnvBiasPatch #: 1
    PATCH_TO_FILTER_FREQ: SynthModEnvBiasPatch #: 2
    PATCH_TO_FILTER_Q: SynthModEnvBiasPatch #: 3
    PATCH_TO_LFO1_GAIN: SynthModEnvBiasPatch #: 4
    PATCH_TO_LFO2_GAIN: SynthModEnvBiasPatch #: 5
    PATCH_TO_LFO1_FREQ: SynthModEnvBiasPatch #: 6
    PATCH_TO_LFO2_FREQ: SynthModEnvBiasPatch #: 7
    ...

class SynthFilterType(EnumBase):
    r"""
    ESynth Filter Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """

    LOW_PASS: SynthFilterType #: 0
    HIGH_PASS: SynthFilterType #: 1
    BAND_PASS: SynthFilterType #: 2
    BAND_STOP: SynthFilterType #: 3
    ...

class SynthFilterAlgorithm(EnumBase):
    r"""
    ESynth Filter Algorithm
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """

    ONE_POLE: SynthFilterAlgorithm #: 0
    STATE_VARIABLE: SynthFilterAlgorithm #: 1
    LADDER: SynthFilterAlgorithm #: 2
    ...

class SynthStereoDelayMode(EnumBase):
    r"""
    ESynth Stereo Delay Mode
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """

    NORMAL: SynthStereoDelayMode #: 0
    CROSS: SynthStereoDelayMode #: 1
    PING_PONG: SynthStereoDelayMode #: 2
    ...

class Synth1PatchSource(EnumBase):
    r"""
    ESynth 1Patch Source
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """

    LFO1: Synth1PatchSource #: 0
    LFO2: Synth1PatchSource #: 1
    ENVELOPE: Synth1PatchSource #: 2
    BIAS_ENVELOPE: Synth1PatchSource #: 3
    ...

class Synth1PatchDestination(EnumBase):
    r"""
    ESynth 1Patch Destination
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """

    OSC1_GAIN: Synth1PatchDestination #: 0
    OSC1_FREQUENCY: Synth1PatchDestination #: 1
    OSC1_PULSEWIDTH: Synth1PatchDestination #: 2
    OSC2_GAIN: Synth1PatchDestination #: 3
    OSC2_FREQUENCY: Synth1PatchDestination #: 4
    OSC2_PULSEWIDTH: Synth1PatchDestination #: 5
    FILTER_FREQUENCY: Synth1PatchDestination #: 6
    FILTER_Q: Synth1PatchDestination #: 7
    GAIN: Synth1PatchDestination #: 8
    PAN: Synth1PatchDestination #: 9
    LFO1_FREQUENCY: Synth1PatchDestination #: 10
    LFO1_GAIN: Synth1PatchDestination #: 11
    LFO2_FREQUENCY: Synth1PatchDestination #: 12
    LFO2_GAIN: Synth1PatchDestination #: 13
    ...

class SourceEffectDynamicsProcessorType(EnumBase):
    r"""
    ESource Effect Dynamics Processor Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectDynamicsProcessor.h
    
    """

    COMPRESSOR: SourceEffectDynamicsProcessorType #: 0
    LIMITER: SourceEffectDynamicsProcessorType #: 1
    EXPANDER: SourceEffectDynamicsProcessorType #: 2
    GATE: SourceEffectDynamicsProcessorType #: 3
    UPWARDS_COMPRESSOR: SourceEffectDynamicsProcessorType #: 4
    ...

class SourceEffectDynamicsPeakMode(EnumBase):
    r"""
    ESource Effect Dynamics Peak Mode
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectDynamicsProcessor.h
    
    """

    MEAN_SQUARED: SourceEffectDynamicsPeakMode #: 0
    ROOT_MEAN_SQUARED: SourceEffectDynamicsPeakMode #: 1
    PEAK: SourceEffectDynamicsPeakMode #: 2
    ...

class EnvelopeFollowerPeakMode(EnumBase):
    r"""
    EEnvelope Follower Peak Mode
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectEnvelopeFollower.h
    
    """

    MEAN_SQUARED: EnvelopeFollowerPeakMode #: 0
    ROOT_MEAN_SQUARED: EnvelopeFollowerPeakMode #: 1
    PEAK: EnvelopeFollowerPeakMode #: 2
    ...

class SourceEffectFilterCircuit(EnumBase):
    r"""
    ESource Effect Filter Circuit
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectFilter.h
    
    """

    ONE_POLE: SourceEffectFilterCircuit #: 0
    STATE_VARIABLE: SourceEffectFilterCircuit #: 1
    LADDER: SourceEffectFilterCircuit #: 2
    ...

class SourceEffectFilterType(EnumBase):
    r"""
    ESource Effect Filter Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectFilter.h
    
    """

    LOW_PASS: SourceEffectFilterType #: 0
    HIGH_PASS: SourceEffectFilterType #: 1
    BAND_PASS: SourceEffectFilterType #: 2
    BAND_STOP: SourceEffectFilterType #: 3
    ...

class SourceEffectFilterParam(EnumBase):
    r"""
    ESource Effect Filter Param
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectFilter.h
    
    """

    FILTER_FREQUENCY: SourceEffectFilterParam #: 0
    FILTER_RESONANCE: SourceEffectFilterParam #: 1
    ...

class StereoChannelMode(EnumBase):
    r"""
    Stereo channel mode
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMidSideSpreader.h
    
    """

    MID_SIDE: StereoChannelMode #: 0
    LEFT_RIGHT: StereoChannelMode #: 1
    ...

class SourceEffectMotionFilterModSource(EnumBase):
    r"""
    ESource Effect Motion Filter Mod Source
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMotionFilter.h
    
    """

    DISTANCE_FROM_LISTENER: SourceEffectMotionFilterModSource #: 0: Uunits between Listener and Sound Source.
    SPEED_RELATIVE_TO_LISTENER: SourceEffectMotionFilterModSource #: 1: Uunits per second change in distance between Listener and Sound Source.
    SPEED_OF_SOURCE_EMITTER: SourceEffectMotionFilterModSource #: 2: Uunits per second change in world location of Sound Source.
    SPEED_OF_LISTENER: SourceEffectMotionFilterModSource #: 3: Uunits per second change in world location of Listener.
    SPEED_OF_ANGLE_DELTA: SourceEffectMotionFilterModSource #: 4: Degrees per second change in Angle of Source from Listener.
    ...

class SourceEffectMotionFilterModDestination(EnumBase):
    r"""
    ESource Effect Motion Filter Mod Destination
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMotionFilter.h
    
    """

    FILTER_A_CUTOFF_FREQUENCY: SourceEffectMotionFilterModDestination #: 0: Filter input frequencies range between 20.0f and 15000.0f.
    FILTER_A_RESONANCE: SourceEffectMotionFilterModDestination #: 1: Filter input resonances range between 0.5f and 10.0f.
    FILTER_A_OUTPUT_VOLUME_DB: SourceEffectMotionFilterModDestination #: 2: Filter output dB range between 10.0f and -96.0f. Final Filter output is clamped to +6 dB, use positive values with caution.
    FILTER_B_CUTOFF_FREQUENCY: SourceEffectMotionFilterModDestination #: 3: Filter input frequencies range between 20.0f and 15000.0f.
    FILTER_B_RESONANCE: SourceEffectMotionFilterModDestination #: 4: Filter input resonances range between 0.5f and 10.0f.
    FILTER_B_OUTPUT_VOLUME_DB: SourceEffectMotionFilterModDestination #: 5: Filter output dB range between 10.0f and -96.0f. Final Filter output is clamped to +6 dB, use positive values with caution.
    FILTER_MIX: SourceEffectMotionFilterModDestination #: 6: Filter Mix values range from -1.0f (Filter A) and 1.0f (Filter B).
    ...

class SourceEffectMotionFilterTopology(EnumBase):
    r"""
    ESource Effect Motion Filter Topology
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMotionFilter.h
    
    """

    SERIAL_MODE: SourceEffectMotionFilterTopology #: 0
    PARALLEL_MODE: SourceEffectMotionFilterTopology #: 1
    ...

class SourceEffectMotionFilterCircuit(EnumBase):
    r"""
    ESource Effect Motion Filter Circuit
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMotionFilter.h
    
    """

    ONE_POLE: SourceEffectMotionFilterCircuit #: 0
    STATE_VARIABLE: SourceEffectMotionFilterCircuit #: 1
    LADDER: SourceEffectMotionFilterCircuit #: 2
    ...

class SourceEffectMotionFilterType(EnumBase):
    r"""
    ESource Effect Motion Filter Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMotionFilter.h
    
    """

    LOW_PASS: SourceEffectMotionFilterType #: 0
    HIGH_PASS: SourceEffectMotionFilterType #: 1
    BAND_PASS: SourceEffectMotionFilterType #: 2
    BAND_STOP: SourceEffectMotionFilterType #: 3
    ...

class PhaserLFOType(EnumBase):
    r"""
    EPhaser LFOType
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectPhaser.h
    
    """

    SINE: PhaserLFOType #: 0
    UP_SAW: PhaserLFOType #: 1
    DOWN_SAW: PhaserLFOType #: 2
    SQUARE: PhaserLFOType #: 3
    TRIANGLE: PhaserLFOType #: 4
    EXPONENTIAL: PhaserLFOType #: 5
    RANDOM_SAMPLE_HOLD: PhaserLFOType #: 6
    ...

class RingModulatorTypeSourceEffect(EnumBase):
    r"""
    ERing Modulator Type Source Effect
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectRingModulation.h
    
    """

    SINE: RingModulatorTypeSourceEffect #: 0
    SAW: RingModulatorTypeSourceEffect #: 1
    TRIANGLE: RingModulatorTypeSourceEffect #: 2
    SQUARE: RingModulatorTypeSourceEffect #: 3
    ...

class StereoDelaySourceEffect(EnumBase):
    r"""
    EStereo Delay Source Effect
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectStereoDelay.h
    
    """

    NORMAL: StereoDelaySourceEffect
    r"""
    0: Left input mixes with left delay line output and feeds to left output.
    Right input mixes with right delay line output and feeds to right output.
    """

    CROSS: StereoDelaySourceEffect
    r"""
    1: Left input mixes right delay line output and feeds to right output.
    Right input mixes with left delay line output and feeds to left output.
    """

    PING_PONG: StereoDelaySourceEffect
    r"""
    2: Left input mixes with left delay line output and feeds to right output.
    Right input mixes with right delay line output and feeds to left output.
    """

    ...

class StereoDelayFiltertype(EnumBase):
    r"""
    Stereo delay filter types
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectStereoDelay.h
    
    """

    LOWPASS: StereoDelayFiltertype #: 0
    HIGHPASS: StereoDelayFiltertype #: 1
    BANDPASS: StereoDelayFiltertype #: 2
    NOTCH: StereoDelayFiltertype #: 3
    ...

class SubmixFilterType(EnumBase):
    r"""
    ESubmix Filter Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectFilter.h
    
    """

    LOW_PASS: SubmixFilterType #: 0
    HIGH_PASS: SubmixFilterType #: 1
    BAND_PASS: SubmixFilterType #: 2
    BAND_STOP: SubmixFilterType #: 3
    ...

class SubmixFilterAlgorithm(EnumBase):
    r"""
    ESubmix Filter Algorithm
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectFilter.h
    
    """

    ONE_POLE: SubmixFilterAlgorithm #: 0
    STATE_VARIABLE: SubmixFilterAlgorithm #: 1
    LADDER: SubmixFilterAlgorithm #: 2
    ...

class GranularSynthEnvelopeType(EnumBase):
    r"""
    EGranular Synth Envelope Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentGranulator.h
    
    """

    RECTANGULAR: GranularSynthEnvelopeType #: 0
    TRIANGLE: GranularSynthEnvelopeType #: 1
    DOWNWARD_TRIANGLE: GranularSynthEnvelopeType #: 2
    UPWARD_TRIANGLE: GranularSynthEnvelopeType #: 3
    EXPONENTIAL_DECAY: GranularSynthEnvelopeType #: 4
    EXPONENTIAL_INCREASE: GranularSynthEnvelopeType #: 5
    GAUSSIAN: GranularSynthEnvelopeType #: 6
    HANNING: GranularSynthEnvelopeType #: 7
    LANCZOS: GranularSynthEnvelopeType #: 8
    COSINE: GranularSynthEnvelopeType #: 9
    COSINE_SQUARED: GranularSynthEnvelopeType #: 10
    WELCH: GranularSynthEnvelopeType #: 11
    BLACKMAN: GranularSynthEnvelopeType #: 12
    BLACKMAN_HARRIS: GranularSynthEnvelopeType #: 13
    ...

class GranularSynthSeekType(EnumBase):
    r"""
    EGranular Synth Seek Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentGranulator.h
    
    """

    FROM_BEGINNING: GranularSynthSeekType #: 0
    FROM_CURRENT_POSITION: GranularSynthSeekType #: 1
    ...

class CurveInterpolationType(EnumBase):
    r"""
    Curve Interpolation Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentMonoWaveTable.h
    
    """

    AUTOINTERP: CurveInterpolationType #: 0
    LINEAR: CurveInterpolationType #: 1
    CONSTANT: CurveInterpolationType #: 2
    ...

class SamplePlayerSeekType(EnumBase):
    r"""
    ESample Player Seek Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentWaveTable.h
    
    """

    FROM_BEGINNING: SamplePlayerSeekType #: 0
    FROM_CURRENT_POSITION: SamplePlayerSeekType #: 1
    FROM_END: SamplePlayerSeekType #: 2
    ...

class SynthKnobSize(EnumBase):
    r"""
    ESynth Knob Size
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthKnobStyle.h
    
    """

    MEDIUM: SynthKnobSize #: 0
    LARGE: SynthKnobSize #: 1
    ...

class SynthSlateSizeType(EnumBase):
    r"""
    ESynth Slate Size Type
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthSlateStyle.h
    
    """

    SMALL: SynthSlateSizeType #: 0
    MEDIUM: SynthSlateSizeType #: 1
    LARGE: SynthSlateSizeType #: 2
    ...

class SynthSlateColorStyle(EnumBase):
    r"""
    ESynth Slate Color Style
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthSlateStyle.h
    
    """

    LIGHT: SynthSlateColorStyle #: 0
    DARK: SynthSlateColorStyle #: 1
    ...

class SubmixEffectConvolutionReverbBlockSize(EnumBase):
    r"""
    Block size of convolution reverb algorithm.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EffectConvolutionReverb.h
    
    """

    BLOCK_SIZE256: SubmixEffectConvolutionReverbBlockSize #: 0: 256 audio frames per a block.
    BLOCK_SIZE512: SubmixEffectConvolutionReverbBlockSize #: 1: 512 audio frames per a block.
    BLOCK_SIZE1024: SubmixEffectConvolutionReverbBlockSize #: 2: 1024 audio frames per a block.
    ...

class TapLineMode(EnumBase):
    r"""
    ETap Line Mode
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectTapDelay.h
    
    """

    SEND_TO_CHANNEL: TapLineMode #: 0: Send tap audio output to a channel directly
    PANNING: TapLineMode #: 1: Allow tap to pan between channels based on azimuth angle
    DISABLED: TapLineMode #: 2: Disables the tap audio and performs a fadeout
    ...

class NiagaraScriptLibraryVisibility(EnumBase):
    r"""
    ENiagara Script Library Visibility
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraScript.h
    
    """

    UNEXPOSED: NiagaraScriptLibraryVisibility #: 1: The script is not visible by default to the user, but can be made visible by disabling the "Library only" filter option.
    LIBRARY: NiagaraScriptLibraryVisibility #: 2: The script is exposed to the asset library and always visible to the user.
    HIDDEN: NiagaraScriptLibraryVisibility #: 3: The script is never visible to the user. This is useful to "soft deprecate" assets that should not be shown to a user, but should also not generate errors for existing usages.
    ...

class NiagaraNumericOutputTypeSelectionMode(EnumBase):
    r"""
    Defines different modes for selecting the output numeric type of a function or operation based on the types of the inputs.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraTypes.h
    
    """

    LARGEST: NiagaraNumericOutputTypeSelectionMode #: 1: Select the largest of the numeric inputs.
    SMALLEST: NiagaraNumericOutputTypeSelectionMode #: 2: Select the smallest of the numeric inputs.
    SCALAR: NiagaraNumericOutputTypeSelectionMode #: 3: Selects the base scalar type for this numeric inputs.
    CUSTOM: NiagaraNumericOutputTypeSelectionMode #: 4: Selects the type based on custom logic from the node.
    ...

class ParticleAllocationMode(EnumBase):
    r"""
    EParticle Allocation Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEmitter.h
    
    """

    AUTOMATIC_ESTIMATE: ParticleAllocationMode #: 0: This mode tries to estimate the max particle count at runtime by using previous simulations as reference.
    MANUAL_ESTIMATE: ParticleAllocationMode #: 1: This mode is useful if the particle count can vary wildly at runtime (e.g. due to user parameters) and a lot of reallocations happen.
    FIXED_COUNT: ParticleAllocationMode #: 2: This mode defines an upper limit on the number of particles that will be simulated.  Useful for rejection sampling where we expect many spawned particles to get killed.
    ...

class NiagaraScriptTemplateSpecification(EnumBase):
    r"""
    ENiagara Script Template Specification
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraScript.h
    
    """

    NONE: NiagaraScriptTemplateSpecification #: 0
    TEMPLATE: NiagaraScriptTemplateSpecification #: 1
    BEHAVIOR: NiagaraScriptTemplateSpecification #: 2
    ...

class NiagaraSimTarget(EnumBase):
    r"""
    ENiagara Sim Target
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCommon.h
    
    """

    CPU_SIM: NiagaraSimTarget #: 0
    GPU_COMPUTE_SIM: NiagaraSimTarget #: 1
    ...

class NiagaraEmitterCalculateBoundMode(EnumBase):
    r"""
    ENiagara Emitter Calculate Bound Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEmitter.h
    
    """

    DYNAMIC: NiagaraEmitterCalculateBoundMode #: 0: Bounds are calculated per frame (Only available for CPU emitters).
    FIXED: NiagaraEmitterCalculateBoundMode #: 1: Bounds are set from the emitter's fixed bounds.
    PROGRAMMABLE: NiagaraEmitterCalculateBoundMode #: 2: Bounds will be set from the script using the Emitter Properties Data Interface, or blueprint.  If not set from either source the emitter has no bounds.
    ...

class NiagaraEmitterDefaultSummaryState(EnumBase):
    r"""
    ENiagara Emitter Default Summary State
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraScript.h
    
    """

    DEFAULT: NiagaraEmitterDefaultSummaryState #: 0: The emitter will be added in default, full view by default.
    SUMMARY: NiagaraEmitterDefaultSummaryState #: 1: The emitter will be added in summary state by default.
    ...

class NiagaraRendererMotionVectorSetting(EnumBase):
    r"""
    How a given Niagara renderer should handle motion vector generation.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCommon.h
    
    """

    AUTO_DETECT: NiagaraRendererMotionVectorSetting #: 0: Determines the best method to employ when generating motion vectors (accurate vs. approximate) based on project and renderer settings
    PRECISE: NiagaraRendererMotionVectorSetting #: 1: Force motion vectors to be precise for this renderer.
    APPROXIMATE: NiagaraRendererMotionVectorSetting #: 2: Force motion vectors to be approximate for this renderer (higher performance, lower particle memory usage).
    DISABLE: NiagaraRendererMotionVectorSetting #: 3: Do not generate motion vectors (i.e. render the object as though it is stationary).
    ...

class NiagaraModuleDependencyType(EnumBase):
    r"""
    ENiagara Module Dependency Type
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraScript.h
    
    """

    PRE_DEPENDENCY: NiagaraModuleDependencyType #: 0: The dependency belongs before the module.
    POST_DEPENDENCY: NiagaraModuleDependencyType #: 1: The dependency belongs after the module.
    ...

class NiagaraModuleDependencyScriptConstraint(EnumBase):
    r"""
    ENiagara Module Dependency Script Constraint
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraScript.h
    
    """

    SAME_SCRIPT: NiagaraModuleDependencyScriptConstraint #: 0: The module providing the dependency must be in the same script e.g. if the module requiring the dependency is in "Particle Spawn" the module providing the dependency must also be in "Particle Spawn".
    ALL_SCRIPTS: NiagaraModuleDependencyScriptConstraint #: 1: The module providing the dependency can be in any script as long as it satisfies the dependency type, e.g. if the module requiring the dependency is in "Particle Spawn" the module providing the dependency could be in "Emitter Spawn".
    ...

class ScriptExecutionMode(EnumBase):
    r"""
    EScript Execution Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEmitter.h
    
    """

    EVERY_PARTICLE: ScriptExecutionMode #: 0: The event script is run on every existing particle in the emitter.
    SPAWNED_PARTICLES: ScriptExecutionMode #: 1: The event script is run only on the particles that were spawned in response to the current event in the emitter.
    ...

class NiagaraCVarConditionResponse(EnumBase):
    r"""
    ENiagara CVar Condition Response
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPlatformSet.h
    
    """

    NONE: NiagaraCVarConditionResponse #: 0
    ENABLE: NiagaraCVarConditionResponse #: 1
    DISABLE: NiagaraCVarConditionResponse #: 2
    ...

class NiagaraSimCacheAttributeCaptureMode(EnumBase):
    r"""
    ENiagara Sim Cache Attribute Capture Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSimCache.h
    
    """

    ALL: NiagaraSimCacheAttributeCaptureMode
    r"""
    0: Captures all attributes available.
    This kind of cache will be useful for restarting a simulation from or debugging.
    """

    RENDERING_ONLY: NiagaraSimCacheAttributeCaptureMode
    r"""
    1: Captures attributes that are required to render the system only.
    This kind of cache is useful for rendering only and should have a much smaller
    size than capturing all attributes.
    """

    EXPLICIT_ATTRIBUTES: NiagaraSimCacheAttributeCaptureMode
    r"""
    2: Captures only attributes that match the 'ExplicitCaptureAttributes' list provided by the user.
    This kind of cache is useful to keep the size down if you need to debug a very
    specific attribute, or you want to do some additional process on the attributes
    i.e. capture MyEmitter.Particles.Position and place static meshes in those locations.
    """

    ...

class NiagartaDataChannelReadResult(EnumBase):
    r"""
    ENiagarta Data Channel Read Result
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataChannel.h
    
    """

    SUCCESS: NiagartaDataChannelReadResult #: 0
    FAILURE: NiagartaDataChannelReadResult #: 1
    ...

class NiagaraCompileErrorSeverity(EnumBase):
    r"""
    ENiagara Compile Error Severity
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSettings.h
    
    """

    IGNORE: NiagaraCompileErrorSeverity #: 0
    LOG_ONLY: NiagaraCompileErrorSeverity #: 1
    WARNING: NiagaraCompileErrorSeverity #: 2
    ERROR: NiagaraCompileErrorSeverity #: 3
    ...

class NiagaraStripScriptByteCodeOption(EnumBase):
    r"""
    ENiagara Strip Script Byte Code Option
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSettings.h
    
    """

    DEFAULT: NiagaraStripScriptByteCodeOption #: 0
    STRIP_ORIGINAL: NiagaraStripScriptByteCodeOption #: 1
    STRIP_EXPERIMENTAL: NiagaraStripScriptByteCodeOption #: 2
    ...

class NiagaraCompilationMode(EnumBase):
    r"""
    ENiagara Compilation Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSettings.h
    
    """

    ORIGINAL: NiagaraCompilationMode #: 0
    ASYNC_TASKS: NiagaraCompilationMode #: 1
    ...

class NiagaraGpuBufferFormat(EnumBase):
    r"""
    Niagara supported buffer formats on the GPU.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCommon.h
    
    """

    FLOAT: NiagaraGpuBufferFormat #: 0: 32-bit per channel floating point, range [-3.402823 x 10^38, 3.402823 x 10^38]
    HALF_FLOAT: NiagaraGpuBufferFormat #: 1: 16-bit per channel floating point, range [-65504, 65504]
    UNSIGNED_NORMALIZED_BYTE: NiagaraGpuBufferFormat #: 2: 8-bit per channel fixed point, range [0, 1].
    ...

class NiagaraDefaultRendererMotionVectorSetting(EnumBase):
    r"""
    How to handle how Niagara rendered effects should generate motion vectors by default (can still be overridden on a case-by-case basis)
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCommon.h
    
    """

    PRECISE: NiagaraDefaultRendererMotionVectorSetting
    r"""
    0: Motion vectors generated are precise (ideal for motion blur and temporal anti-aliasing).
    Requires relevant emitters to store more data per particle, and may affect vertex processing performance.
    """

    APPROXIMATE: NiagaraDefaultRendererMotionVectorSetting
    r"""
    1: Approximates the motion vectors from current velocity.
    Saves memory and performance, but can result in lower quality motion blur and/or anti-aliasing.
    """

    ...

class NiagaraDefaultRendererPixelCoverageMode(EnumBase):
    r"""
    ENiagara Default Renderer Pixel Coverage Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSettings.h
    
    """

    ENABLED: NiagaraDefaultRendererPixelCoverageMode #: 0: When renderer is set to automatic mode pixel coverage is enabled.
    DISABLED: NiagaraDefaultRendererPixelCoverageMode #: 1: When renderer is set to automatic mode pixel coverage is disabled.
    ...

class NiagaraDefaultSortPrecision(EnumBase):
    r"""
    ENiagara Default Sort Precision
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSettings.h
    
    """

    LOW: NiagaraDefaultSortPrecision #: 0: Low precision sorting, half float (fp16) precision, faster and adequate for most cases.
    HIGH: NiagaraDefaultSortPrecision #: 1: High precision sorting, float (fp32) precision, slower but may fix sorting artifacts.
    ...

class NiagaraDefaultGpuTranslucentLatency(EnumBase):
    r"""
    ENiagara Default Gpu Translucent Latency
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSettings.h
    
    """

    IMMEDIATE: NiagaraDefaultGpuTranslucentLatency #: 0: Gpu simulations will always read this frames data for translucent materials.
    LATENT: NiagaraDefaultGpuTranslucentLatency #: 1: Gpu simulations will read the previous frames data if the simulation has to run in PostRenderOpaque.
    ...

class NDISkelMesh_GpuMaxInfluences(EnumBase):
    r"""
    This enum must match the order in NiagaraDataInterfaceSkeletalMesh.ush
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSettings.h
    
    """

    ALLOW_MAX4: NDISkelMesh_GpuMaxInfluences #: 0: Allow up to 4 bones to be sampled.
    ALLOW_MAX8: NDISkelMesh_GpuMaxInfluences #: 1: Allow up to 8 bones to be sampled.
    UNLIMITED: NDISkelMesh_GpuMaxInfluences #: 2: Allow an unlimited amount of bones to be sampled.
    ...

class NDISkelMesh_GpuUniformSamplingFormat(EnumBase):
    r"""
    This enum must match the order in NiagaraDataInterfaceSkeletalMesh.ush
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSettings.h
    
    """

    FULL: NDISkelMesh_GpuUniformSamplingFormat #: 0: 64 bits per entry. Allow for the full int32 range of triangles (2 billion).
    LIMITED_24_8: NDISkelMesh_GpuUniformSamplingFormat #: 1: 32 bits per entry. Allow for ~16.7 million triangles and 8 bits of probability precision.
    LIMITED_23_9: NDISkelMesh_GpuUniformSamplingFormat #: 2: 32 bits per entry. Allow for ~8.4 millions triangles and 9 bits of probability precision.
    ...

class NDISkelMesh_AdjacencyTriangleIndexFormat(EnumBase):
    r"""
    This enum must match the order in NiagaraDataInterfaceSkeletalMesh.ush
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSettings.h
    
    """

    FULL: NDISkelMesh_AdjacencyTriangleIndexFormat #: 0: 32 bits per entry. Allow for the full int32 range of triangles (2 billion).
    HALF: NDISkelMesh_AdjacencyTriangleIndexFormat #: 1: 16 bits per entry. Allow for half (int16) range of triangles (64k).
    ...

class NDICollisionQuery_AsyncGpuTraceProvider(EnumBase):
    r"""
    ENDICollision Query Async Gpu Trace Provider
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSettings.h
    
    """

    DEFAULT: NDICollisionQuery_AsyncGpuTraceProvider #: 0
    HWRT: NDICollisionQuery_AsyncGpuTraceProvider #: 1
    GSDF: NDICollisionQuery_AsyncGpuTraceProvider #: 2
    NONE: NDICollisionQuery_AsyncGpuTraceProvider #: 3
    ...

class NDISceneCapture2DSourceMode(EnumBase):
    r"""
    ENDIScene Capture 2DSource Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceSceneCapture2D.h
    
    """

    USER_PARAMETER_THEN_ATTACH_PARENT: NDISceneCapture2DSourceMode #: 0: Check the user parameter then the attach parent to find the scene capture component.
    USER_PARAMETER_ONLY: NDISceneCapture2DSourceMode #: 1: Only check the user parameter to find the scene capture component.
    ATTACH_PARENT_ONLY: NDISceneCapture2DSourceMode #: 2: Only look at the attach parent to find the scene capture component.
    MANAGED: NDISceneCapture2DSourceMode #: 3: Managed mode, we will not search for any and instead create one internally.
    ...

class NDISceneCapture2DOffsetMode(EnumBase):
    r"""
    ENDIScene Capture 2DOffset Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceSceneCapture2D.h
    
    """

    DISABLED: NDISceneCapture2DOffsetMode #: 0: The offset is disabled and will not be applied.
    RELATIVE_LOCAL: NDISceneCapture2DOffsetMode #: 1: The offset is in the component local space.
    RELATIVE_WORLD: NDISceneCapture2DOffsetMode #: 2: The offset is in world space, i.e. added to the exising value directly.
    ABSOLUTE_WORLD: NDISceneCapture2DOffsetMode #: 3: The offset is applied directly, i.e. not added to the existing valud
    ...

class NDIStaticMesh_SourceMode(EnumBase):
    r"""
    ENDIStatic Mesh Source Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceStaticMesh.h
    
    """

    DEFAULT: NDIStaticMesh_SourceMode
    r"""
    0: Default behavior follows the order of.
    - Use "Source" when specified (either set explicitly or via blueprint with Set Niagara Static Mesh Component).
    - Use Mesh Parameter Binding if valid
    - Find Static Mesh Component, Attached Actor, Attached Component
    - Falls back to 'Default Mesh' specified on the data interface
    """

    SOURCE: NDIStaticMesh_SourceMode #: 1: Only use "Source" (either set explicitly or via blueprint with Set Niagara Static Mesh Component).
    ATTACH_PARENT: NDIStaticMesh_SourceMode #: 2: Only use the parent actor or component the system is attached to.
    DEFAULT_MESH_ONLY: NDIStaticMesh_SourceMode #: 3: Only use the "Default Mesh" specified.
    MESH_PARAMETER_BINDING: NDIStaticMesh_SourceMode #: 4: Only use the mesh parameter binding.
    ...

class NDIObjectPropertyReaderSourceMode(EnumBase):
    r"""
    ENDIObject Property Reader Source Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceUObjectPropertyReader.h
    
    """

    BINDING: NDIObjectPropertyReaderSourceMode #: 0: Source object is found in the order of object binding, source actor.
    ATTACH_PARENT_ACTOR: NDIObjectPropertyReaderSourceMode #: 1: Source object is found use the attached parent actor.
    BINDING_THEN_ATTACH_PARENT_ACTOR: NDIObjectPropertyReaderSourceMode #: 2: Source object is found in the order of object binding, source actor, then attached parent actor.
    ...

class NiagaraSystemSpawnSectionStartBehavior(EnumBase):
    r"""
    Defines options for system life cycle for before the section is evaluating up to the first frame the section evaluates.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraSystemSpawnSection.h
    
    """

    ACTIVATE: NiagaraSystemSpawnSectionStartBehavior
    r"""
    0: When the time before the section evaluates the particle system's component will be deactivated and on the first frame of the section the
           system's component will be activated.
    """

    ...

class NiagaraSystemSpawnSectionEvaluateBehavior(EnumBase):
    r"""
    Defines options for system life cycle for when the section is evaluating from the 2nd frame until the last frame of the section.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraSystemSpawnSection.h
    
    """

    ACTIVATE_IF_INACTIVE: NiagaraSystemSpawnSectionEvaluateBehavior #: 0: The system's component will be activated on any frame where it is inactive.  This is useful for continuous emitters, especially if the sequencer will start in the middle of the section.
    NONE: NiagaraSystemSpawnSectionEvaluateBehavior #: 1: There sill be no changes to the system life cycle while the section is evaluating.
    ...

class NiagaraSystemSpawnSectionEndBehavior(EnumBase):
    r"""
    Defines options for system life cycle for the time after the section.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraSystemSpawnSection.h
    
    """

    SET_SYSTEM_INACTIVE: NiagaraSystemSpawnSectionEndBehavior #: 0: / When the section ends the system is set to inactive which stops spawning but lets existing particles simulate until death.
    DEACTIVATE: NiagaraSystemSpawnSectionEndBehavior #: 1: / When the section ends the system's component is deactivated which will kill all existing particles.
    NONE: NiagaraSystemSpawnSectionEndBehavior #: 2: / Does nothing when the section ends and allows the system to continue to run as normal.
    ...

class NiagaraAgeUpdateMode(EnumBase):
    r"""
    Defines modes for updating the component's age.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCommon.h
    
    """

    TICK_DELTA_TIME: NiagaraAgeUpdateMode #: 0: Update the age using the delta time supplied to the component tick function.
    DESIRED_AGE: NiagaraAgeUpdateMode #: 1: Update the age by seeking to the DesiredAge. To prevent major perf loss, we clamp to MaxClampTime
    DESIRED_AGE_NO_SEEK: NiagaraAgeUpdateMode
    r"""
    2: Update the age by tracking changes to the desired age, but when the desired age goes backwards in time,
          or jumps forwards in time by more than a few steps, the system is reset and simulated forward by a single step.
          This mode is useful for continuous effects controlled by sequencer.
    """

    ...

class NiagaraTickBehavior(EnumBase):
    r"""
    Niagara ticking behaviour
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraTickBehaviorEnum.h
    
    """

    USE_PREREQS: NiagaraTickBehavior #: 0: Niagara will tick after all prereqs have ticked for attachements / data interfaces, this is the safest option.
    USE_COMPONENT_TICK_GROUP: NiagaraTickBehavior #: 1: Niagara will ignore prereqs (attachments / data interface dependencies) and use the tick group set on the component.
    FORCE_TICK_FIRST: NiagaraTickBehavior #: 2: Niagara will tick in the first tick group (default is TG_PrePhysics).
    FORCE_TICK_LAST: NiagaraTickBehavior #: 3: Niagara will tick in the last tick group (default is TG_LastDemotable).
    ...

class NiagaraOcclusionQueryMode(EnumBase):
    r"""
    ENiagara Occlusion Query Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraComponent.h
    
    """

    DEFAULT: NiagaraOcclusionQueryMode #: 0: Allow Niagara to determine if we allow occlusion queries to be enabled or not.
    ALWAYS_ENABLED: NiagaraOcclusionQueryMode #: 1: Occlusion queries will always be enabled for Niagara.
    ALWAYS_DISABLED: NiagaraOcclusionQueryMode #: 2: Occlusion queries will always be disabled for Niagara.
    ...

class NiagaraGpuSyncMode(EnumBase):
    r"""
    ENiagara Gpu Sync Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCommon.h
    
    """

    NONE: NiagaraGpuSyncMode #: 0: Data will not be automatically pushed and could diverge between Cpu & Gpu.
    SYNC_CPU_TO_GPU: NiagaraGpuSyncMode #: 1: Cpu modifications will be pushed to the Gpu.
    SYNC_GPU_TO_CPU: NiagaraGpuSyncMode #: 2: Gpu will continuously push back to the Cpu, this will incur a performance penalty.
    SYNC_BOTH: NiagaraGpuSyncMode #: 3: Gpu will continuously push back to the Cpu and Cpu modifications will be pushed to the Gpu.
    ...

class SetResolutionMethod(EnumBase):
    r"""
    ESet Resolution Method
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceRW.h
    
    """

    INDEPENDENT: SetResolutionMethod #: 0
    MAX_AXIS: SetResolutionMethod #: 1
    CELL_SIZE: SetResolutionMethod #: 2
    ...

class NiagaraMipMapGeneration(EnumBase):
    r"""
    ENiagara Mip Map Generation
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCommon.h
    
    """

    DISABLED: NiagaraMipMapGeneration #: 0: Mips will not be created or automatically generated.
    POST_STAGE: NiagaraMipMapGeneration #: 1: Mips will be generated after each stage where the interfaces is written to.
    POST_SIMULATE: NiagaraMipMapGeneration #: 2: Mips will be generated after all stages have been run if the interface was written to.
    ...

class NiagaraMipMapGenerationType(EnumBase):
    r"""
    ENiagara Mip Map Generation Type
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraShader
    - **File**: NiagaraGenerateMips.h
    
    """

    UNFILTERED: NiagaraMipMapGenerationType #: 0: Result is taken from whatever texel the sample lies on, aka Point Sampling.
    LINEAR: NiagaraMipMapGenerationType #: 1: Linear blending is performed between a 2x2 (or 2x2x2) region of texels, aka Bilinear / Trilinear.
    BLUR1: NiagaraMipMapGenerationType #: 2: A blur filter across a 3x3 (or 3x3x3) region of texels.
    BLUR2: NiagaraMipMapGenerationType #: 3: A blur filter across a 5x5 (or 5x5x5) region of texels.
    BLUR3: NiagaraMipMapGenerationType #: 4: A blur filter across a 7x7 (or 7x7x7) region of texels.
    BLUR4: NiagaraMipMapGenerationType #: 5: A blur filter across a 9x9 (or 9x9x9) region of texels.
    ...

class NCPoolMethod(EnumBase):
    r"""
    ENCPool Method
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraComponentPoolMethodEnum.h
    
    """

    NONE: NCPoolMethod #: 0: The component will be created fresh and not allocated from the pool.
    AUTO_RELEASE: NCPoolMethod
    r"""
    1: The component is allocated from the pool and will be automatically released back to it.
    User need not handle this any more that other NCs but interaction with the NC after the tick it's spawned in are unsafe.
    This method is useful for one-shot fx that you don't need to keep a reference to and can fire and forget.
    """

    MANUAL_RELEASE: NCPoolMethod
    r"""
    2: NC is allocated from the pool but will NOT be automatically released back to it. User has ownership of the NC and must call ReleaseToPool when finished with it otherwise the NC will leak.
    Interaction with the NC after it has been released are unsafe.
    This method is useful for persistent FX that you need to modify parameters upon etc over it's lifetime.
    """

    ...

class NiagaraRendererSourceDataMode(EnumBase):
    r"""
    This enum decides how a renderer will attempt to process the incoming data from the stack.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCommon.h
    
    """

    PARTICLES: NiagaraRendererSourceDataMode #: 0: The renderer will draw particle data, but can potentially pull in data from the Emitter/User/or System namespaces when drawing each Particle.
    EMITTER: NiagaraRendererSourceDataMode #: 1: The renderer will draw only one element per Emitter. It can only pull in data from Emitter/User/or System namespaces when drawing the single element.
    ...

class NiagaraPreviewGridResetMode(EnumBase):
    r"""
    ENiagara Preview Grid Reset Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPreviewGrid.h
    
    """

    NEVER: NiagaraPreviewGridResetMode #: 0
    INDIVIDUAL: NiagaraPreviewGridResetMode #: 1: Never resets the previews.
    ALL: NiagaraPreviewGridResetMode #: 2: Resets each preview as it completes.
    ...

class NiagaraSpriteAlignment(EnumBase):
    r"""
    This enum decides how a sprite particle will orient its "up" axis. Must keep these in sync with NiagaraSpriteVertexFactory.ush
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSpriteRendererProperties.h
    
    """

    UNALIGNED: NiagaraSpriteAlignment #: 0: Only Particles.SpriteRotation and FacingMode impact the alignment of the particle.
    VELOCITY_ALIGNED: NiagaraSpriteAlignment #: 1: Imagine the particle texture having an arrow pointing up, this mode makes the arrow point in the direction of the Particles.Velocity attribute. FacingMode is ignored unless CustomFacingVector is set.
    CUSTOM_ALIGNMENT: NiagaraSpriteAlignment #: 2: Imagine the particle texture having an arrow pointing up, this mode makes the arrow point towards the axis defined by the "Particles.SpriteAlignment" attribute. FacingMode is ignored unless CustomFacingVector is set. If the "Particles.SpriteAlignment" attribute is missing, this falls back to Unaligned mode.
    AUTOMATIC: NiagaraSpriteAlignment #: 3: Automatically select between Unaligned & CustomAlignment depending on if SpriteAlignment Binding is valid.
    ...

class NiagaraSpriteFacingMode(EnumBase):
    r"""
    This enum decides how a sprite particle will orient its "facing" axis. Must keep these in sync with NiagaraSpriteVertexFactory.ush
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSpriteRendererProperties.h
    
    """

    FACE_CAMERA: NiagaraSpriteFacingMode #: 0: The sprite billboard origin is always "looking at" the camera origin, trying to keep its up axis aligned to the camera's up axis.
    FACE_CAMERA_PLANE: NiagaraSpriteFacingMode #: 1: The sprite billboard plane is completely parallel to the camera plane. Particle always looks "flat"
    CUSTOM_FACING_VECTOR: NiagaraSpriteFacingMode #: 2: The sprite billboard faces toward the "Particles.SpriteFacing" vector attribute. If the "Particles.SpriteFacing" attribute is missing, this falls back to FaceCamera mode.
    FACE_CAMERA_POSITION: NiagaraSpriteFacingMode #: 3: Faces the camera position, but is not dependent on the camera rotation.  This method produces more stable particles under camera rotation. Uses the up axis of (0,0,1).
    FACE_CAMERA_DISTANCE_BLEND: NiagaraSpriteFacingMode #: 4: Blends between FaceCamera and FaceCameraPosition.
    AUTOMATIC: NiagaraSpriteFacingMode #: 5: Automatically select between FaceCamera & CustomFacingVector depending on if SpriteFacing binding is valid.
    ...

class NiagaraSortMode(EnumBase):
    r"""
    ENiagara Sort Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraGPUSortInfo.h
    
    """

    NONE: NiagaraSortMode #: 0: Perform no additional sorting prior to rendering.
    VIEW_DEPTH: NiagaraSortMode #: 1: Sort by depth to the camera's near plane.
    VIEW_DISTANCE: NiagaraSortMode #: 2: Sort by distance to the camera's origin.
    CUSTOM_ASCENDING: NiagaraSortMode
    r"""
    3: Sort according to particles CustomSortingBinding (defaults to Particles.NormalizedAge).
    Lower values will be sorted before higher values, i.e. 1 would draw on top of 0.
    """

    CUSTOM_DECENDING: NiagaraSortMode
    r"""
    4: Sort according to particles CustomSortingBinding (defaults to Particles.NormalizedAge).
    Higher values will be sorted before lower values, i.e. 0 would draw on top of 1.
    """

    ...

class NiagaraRendererSortPrecision(EnumBase):
    r"""
    ENiagara Renderer Sort Precision
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraRendererProperties.h
    
    """

    DEFAULT: NiagaraRendererSortPrecision #: 0: Uses the project settings value.
    LOW: NiagaraRendererSortPrecision #: 1: Low precision sorting, half float (fp16) precision, faster and adequate for most cases.
    HIGH: NiagaraRendererSortPrecision #: 2: High precision sorting, float (fp32) precision, slower but may fix sorting artifacts.
    ...

class NiagaraRendererGpuTranslucentLatency(EnumBase):
    r"""
    ENiagara Renderer Gpu Translucent Latency
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraRendererProperties.h
    
    """

    PROJECT_DEFAULT: NiagaraRendererGpuTranslucentLatency #: 0: Uses the project default value.
    IMMEDIATE: NiagaraRendererGpuTranslucentLatency #: 1: Gpu simulations will always read this frames data for translucent materials.
    LATENT: NiagaraRendererGpuTranslucentLatency #: 2: Gpu simulations will read the previous frames data if the simulation has to run in PostRenderOpaque.
    ...

class NiagaraRendererPixelCoverageMode(EnumBase):
    r"""
    ENiagara Renderer Pixel Coverage Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSpriteRendererProperties.h
    
    """

    AUTOMATIC: NiagaraRendererPixelCoverageMode #: 0: Automatically determine if we want pixel coverage enabled or disabled, based on project setting and the material used on the renderer.
    DISABLED: NiagaraRendererPixelCoverageMode #: 1: Disable pixel coverage.
    ENABLED: NiagaraRendererPixelCoverageMode #: 2: Enable pixel coverage with no color adjustment based on coverage.
    ENABLED_RGBA: NiagaraRendererPixelCoverageMode #: 3: Enable pixel coverage and adjust the RGBA channels according to coverage.
    ENABLED_RGB: NiagaraRendererPixelCoverageMode #: 4: Enable pixel coverage and adjust the RGB channels according to coverage.
    ENABLED_A: NiagaraRendererPixelCoverageMode #: 5: Enable pixel coverage and adjust the Alpha channel only according to coverage.
    ...

class SubUVBoundingVertexCount(EnumBase):
    r"""
    More bounding vertices results in reduced overdraw, but adds more triangle overhead.
    The eight vertex mode is best used when the SubUV texture has a lot of space to cut out that is not captured by the four vertex version,
    and when the particles using the texture will be few and large.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SubUVAnimation.h
    
    """

    BVC_FOUR_VERTICES: SubUVBoundingVertexCount #: 0
    BVC_EIGHT_VERTICES: SubUVBoundingVertexCount #: 1
    ...

class OpacitySourceMode(EnumBase):
    r"""
    EOpacity Source Mode
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SubUVAnimation.h
    
    """

    OSM_ALPHA: OpacitySourceMode #: 0
    OSM_COLOR_BRIGHTNESS: OpacitySourceMode #: 1
    OSM_RED_CHANNEL: OpacitySourceMode #: 2
    OSM_GREEN_CHANNEL: OpacitySourceMode #: 3
    OSM_BLUE_CHANNEL: OpacitySourceMode #: 4
    ...

class NiagaraScalabilityUpdateFrequency(EnumBase):
    r"""
    Controls how often should we update scalability states for these effects.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    """

    SPAWN_ONLY: NiagaraScalabilityUpdateFrequency #: 0: Scalability will be checked only on spawn.
    LOW: NiagaraScalabilityUpdateFrequency #: 1: Scalability will be checked every 1.0s (default for fx.NiagaraScalabilityUpdateTime_Low).
    MEDIUM: NiagaraScalabilityUpdateFrequency #: 2: Scalability will be checked every 0.5s (default for fx.NiagaraScalabilityUpdateTime_Medium).
    HIGH: NiagaraScalabilityUpdateFrequency #: 3: Scalability will be checked every 0.25s (default for fx.NiagaraScalabilityUpdateTime_High).
    CONTINUOUS: NiagaraScalabilityUpdateFrequency #: 4: Scalability will be checked every frame.
    ...

class NiagaraCullReaction(EnumBase):
    r"""
    Controls what action is taken by a Niagara system that fails it's cull checks.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    """

    DEACTIVATE: NiagaraCullReaction #: 0: The system instance will be deactivated. Particles will be allowed to die naturally. It will not be reactivated automatically by the scalability system.
    DEACTIVATE_IMMEDIATE: NiagaraCullReaction #: 1: The system instance will be deactivated and particles killed immediately. It will not be reactivated automatically by the scalability system.
    DEACTIVATE_RESUME: NiagaraCullReaction #: 2: The system instance will be deactivated. Particles will be allowed to die naturally. Will reactivate when it passes cull tests again.
    DEACTIVATE_IMMEDIATE_RESUME: NiagaraCullReaction #: 3: The system instance will be deactivated and particles killed immediately. Will reactivate when it passes cull tests again.
    PAUSE_RESUME: NiagaraCullReaction #: 4: The system instance will be paused, maintaining it's current state, but will resume ticking when it passes cull tests again.
    ...

class NiagaraDeviceProfileRedirectMode(EnumBase):
    r"""
    ENiagara Device Profile Redirect Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPlatformSet.h
    
    """

    C_VAR: NiagaraDeviceProfileRedirectMode #: 0: Replace Device Profile Reference with a CVar Condition.
    DEVICE_PROFILE: NiagaraDeviceProfileRedirectMode #: 1: Replace Device Profile Reference with a different Device Profile.
    ...

class NiagaraVariantMode(EnumBase):
    r"""
    ENiagara Variant Mode
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraVariant.h
    
    """

    NONE: NiagaraVariantMode #: 0
    OBJECT: NiagaraVariantMode #: 1
    DATA_INTERFACE: NiagaraVariantMode #: 2
    BYTES: NiagaraVariantMode #: 3
    ...

class NiagaraCullProxyMode(EnumBase):
    r"""
    Controls how cull proxies should be handled for a system.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    """

    NONE: NiagaraCullProxyMode #: 0: No cull proxy replaces culled systems.
    INSTANCED_RENDERED: NiagaraCullProxyMode #: 1: A single simulation is used but rendered in place of all culled systems. This saves on simulation cost but can still incur significant render thread cost.
    ...

class NiagaraSimCacheSectionPlayMode(EnumBase):
    r"""
    ENiagara Sim Cache Section Play Mode
    
    **C++ Source:**
    
    - **Plugin**: NiagaraSimCaching
    - **Module**: NiagaraSimCaching
    - **File**: MovieSceneNiagaraCacheSection.h
    
    """

    SIM_WITHOUT_CACHE: NiagaraSimCacheSectionPlayMode #: 0: When the sequence has no cached data to display, the Niagara component runs the simulation normally
    DISPLAY_CACHE_ONLY: NiagaraSimCacheSectionPlayMode #: 1: When the sequence has no cached data to display, the Niagara component is disabled
    ...

class NiagaraSimCacheSectionStretchMode(EnumBase):
    r"""
    ENiagara Sim Cache Section Stretch Mode
    
    **C++ Source:**
    
    - **Plugin**: NiagaraSimCaching
    - **Module**: NiagaraSimCaching
    - **File**: MovieSceneNiagaraCacheSection.h
    
    """

    REPEAT: NiagaraSimCacheSectionStretchMode #: 0: When the cache section is stretched in the track it will repeat the cached data
    TIME_DILATE: NiagaraSimCacheSectionStretchMode #: 1: When the cache section is stretched in the track it will dilate the input time so the cached data is stretched once over the full section
    ...

class InterchangeAnimationPayLoadType(EnumBase):
    r"""
    EInterchange Animation Pay Load Type
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeAnimationTrackSetNode.h
    
    """

    NONE: InterchangeAnimationPayLoadType #: 0
    CURVE: InterchangeAnimationPayLoadType #: 1
    MORPHTARGETCURVE: InterchangeAnimationPayLoadType #: 2
    STEPCURVE: InterchangeAnimationPayLoadType #: 3: Handles/generates the same properties as the CURVE variation, but the way it is acquired might be different (depending on the Translator).
    BAKED: InterchangeAnimationPayLoadType #: 4
    MORPHTARGETCURVEWEIGHTINSTANCE: InterchangeAnimationPayLoadType #: 5
    ...

class InterchangeAnimatedProperty(EnumBase):
    r"""
    Enumeration specifying which properties of a camera, light or scene node can be animated besides transform.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeAnimationTrackSetNode.h
    
    """

    NONE: InterchangeAnimatedProperty #: 0: The associated animation track will be ignored.
    VISIBILITY: InterchangeAnimatedProperty #: 1: The associated animation track is applied to the visibility property of the actor.
    ...

class InterchangeCameraProjectionType(EnumBase):
    r"""
    EInterchange Camera Projection Type
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeCameraNode.h
    
    """

    PERSPECTIVE: InterchangeCameraProjectionType #: 0
    ORTHOGRAPHIC: InterchangeCameraProjectionType #: 1
    ...

class InterchangeTextureWrapMode(EnumBase):
    r"""
    ns UE
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeTextureNode.h
    
    """

    WRAP: InterchangeTextureWrapMode #: 0
    CLAMP: InterchangeTextureWrapMode #: 1
    MIRROR: InterchangeTextureWrapMode #: 2
    ...

class InterchangeTextureFilterMode(EnumBase):
    r"""
    EInterchange Texture Filter Mode
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeTextureNode.h
    
    """

    NEAREST: InterchangeTextureFilterMode #: 0
    BILINEAR: InterchangeTextureFilterMode #: 1
    TRILINEAR: InterchangeTextureFilterMode #: 2
    DEFAULT: InterchangeTextureFilterMode #: 3: Use setting from the Texture Group.
    ...

class InterchangeMeshPayLoadType(EnumBase):
    r"""
    ns UE
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeMeshNode.h
    
    """

    NONE: InterchangeMeshPayLoadType #: 0
    STATIC: InterchangeMeshPayLoadType #: 1
    SKELETAL: InterchangeMeshPayLoadType #: 2
    MORPHTARGET: InterchangeMeshPayLoadType #: 3
    ...

class InterchangeLightUnits(EnumBase):
    r"""
    This enum is used as a placeholder for ELightUnits. Because InterchangeWorker is not compiled against Engine, the LightFactoryNode is not affected.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeLightNode.h
    
    """

    UNITLESS: InterchangeLightUnits #: 0
    CANDELAS: InterchangeLightUnits #: 1
    LUMENS: InterchangeLightUnits #: 2
    EV: InterchangeLightUnits #: 3
    ...

class InterchangeSkeletalMeshContentType(EnumBase):
    r"""
    EInterchange Skeletal Mesh Content Type
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeSkeletalMeshFactoryNode.h
    
    """

    ALL: InterchangeSkeletalMeshContentType #: 0: Imports all skeletal mesh content: geometry and skin weights.
    GEOMETRY: InterchangeSkeletalMeshContentType #: 1: Imports the skeletal mesh geometry only. This creates a default skeleton, or maps the geometry to the existing one. You can import morph targets and LODs with the mesh.
    SKINNING_WEIGHTS: InterchangeSkeletalMeshContentType #: 2: Imports the skeletal mesh skin weights only. No geometry, morph targets, or LODs are imported.
    ...

class MaterialXLuminanceMode(EnumBase):
    r"""
    A material expression that outputs a grayscale image containing the luminance of the incoming RGB color in all color channels;
        the alpha channel is left unchanged if present.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionLuminance.h
    
    """

    ACE_SCG: MaterialXLuminanceMode #: 0
    REC709: MaterialXLuminanceMode #: 1
    REC2020: MaterialXLuminanceMode #: 2
    REC2100: MaterialXLuminanceMode #: 2
    CUSTOM: MaterialXLuminanceMode #: 3
    ...

class LuminanceMode(EnumBase):
    r"""
    deprecated: 'LuminanceMode' was renamed to 'MaterialXLuminanceMode'.
    """

    ACE_SCG: LuminanceMode #: 0
    REC709: LuminanceMode #: 1
    REC2020: LuminanceMode #: 2
    REC2100: LuminanceMode #: 2
    CUSTOM: LuminanceMode #: 3
    ...

class MAterialXTextureSampleBlurKernel(EnumBase):
    r"""
    EMAterial XTexture Sample Blur Kernel
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionTextureSampleParameterBlur.h
    
    """

    KERNEL1: MAterialXTextureSampleBlurKernel #: 0: No Blur
    KERNEL3: MAterialXTextureSampleBlurKernel #: 1
    KERNEL5: MAterialXTextureSampleBlurKernel #: 2
    KERNEL7: MAterialXTextureSampleBlurKernel #: 3
    ...

class MaterialXTextureSampleBlurFilter(EnumBase):
    r"""
    EMaterial XTexture Sample Blur Filter
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionTextureSampleParameterBlur.h
    
    """

    BOX: MaterialXTextureSampleBlurFilter #: 0
    GAUSSIAN: MaterialXTextureSampleBlurFilter #: 1
    ...

class TextureSampleBlurFilter(EnumBase):
    r"""
    deprecated: 'TextureSampleBlurFilter' was renamed to 'MaterialXTextureSampleBlurFilter'.
    """

    BOX: TextureSampleBlurFilter #: 0
    GAUSSIAN: TextureSampleBlurFilter #: 1
    ...

class InterchangeForceMeshType(EnumBase):
    r"""
    Enumerates the options for importing all meshes as one type.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericAssetsPipelineSharedSettings.h
    
    """

    IFMT_NONE: InterchangeForceMeshType #: 0: Import both static meshes and skeletal meshes from the source without converting them.
    IFMT_STATIC_MESH: InterchangeForceMeshType #: 1: Import all meshes from the source as static meshes.
    IFMT_SKELETAL_MESH: InterchangeForceMeshType #: 2: Import all meshes from the source as skeletal meshes.
    ...

class InterchangeVertexColorImportOption(EnumBase):
    r"""
    EInterchange Vertex Color Import Option
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericAssetsPipelineSharedSettings.h
    
    """

    IVCIO_REPLACE: InterchangeVertexColorImportOption #: 0: Import the mesh using the vertex colors from the translated source.
    IVCIO_IGNORE: InterchangeVertexColorImportOption #: 1: Ignore vertex colors from the translated source. In case of a reimport, keep the existing mesh vertex colors.
    IVCIO_OVERRIDE: InterchangeVertexColorImportOption #: 2: Override all vertex colors with the specified color.
    ...

class InterchangeAnimationRange(EnumBase):
    r"""
    Animation length type when importing.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericAnimationPipeline.h
    
    """

    TIMELINE: InterchangeAnimationRange #: 0: This option imports the range of frames based on timeline definition in the source.
    ANIMATED: InterchangeAnimationRange #: 1: This option imports the range of frames that have animation.
    SET_RANGE: InterchangeAnimationRange #: 2: This option imports the range of frames specified by "FrameImportRange".
    ...

class InterchangeMaterialImportOption(EnumBase):
    r"""
    EInterchange Material Import Option
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericMaterialPipeline.h
    
    """

    IMPORT_AS_MATERIALS: InterchangeMaterialImportOption #: 0: Import all materials from the source as material assets.
    IMPORT_AS_MATERIAL_INSTANCES: InterchangeMaterialImportOption #: 1: Import all materials from the source as material instance assets.
    ...

class InterchangeMaterialSearchLocation(EnumBase):
    r"""
    EInterchange Material Search Location
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericMaterialPipeline.h
    
    """

    LOCAL: InterchangeMaterialSearchLocation #: 0: Search for existing material in local import folder only.
    UNDER_PARENT: InterchangeMaterialSearchLocation #: 1: Search for existing material recursively from parent folder.
    UNDER_ROOT: InterchangeMaterialSearchLocation #: 2: Search for existing material recursively from root folder.
    ALL_ASSETS: InterchangeMaterialSearchLocation #: 3: Search for existing material in all assets folders.
    DO_NOT_SEARCH: InterchangeMaterialSearchLocation #: 4: Do not search for existing existing materials
    ...

class ControlRigType(EnumBase):
    r"""
    EControl Rig Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigDeveloper
    - **File**: ControlRigBlueprint.h
    
    """

    INDEPENDENT_RIG: ControlRigType #: 0
    RIG_MODULE: ControlRigType #: 1
    MODULAR_RIG: ControlRigType #: 2
    ...

class RigVMDrawSettings(EnumBase):
    r"""
    ERig VMDraw Settings
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMDrawInstruction.h
    
    """

    POINTS: RigVMDrawSettings #: 0
    LINES: RigVMDrawSettings #: 1
    LINE_STRIP: RigVMDrawSettings #: 2
    DYNAMIC_MESH: RigVMDrawSettings #: 3
    ...

class OscillatorWaveform(EnumBase):
    r"""
    Types of waveforms that can be used for camera shake oscillators
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: LegacyCameraShake.h
    
    """

    SINE_WAVE: OscillatorWaveform #: 0: A sinusoidal wave
    PERLIN_NOISE: OscillatorWaveform #: 1: Perlin noise
    ...

class CameraAnimationPlaySpace(EnumBase):
    r"""
    ECamera Animation Play Space
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraAnimationCameraModifier.h
    
    """

    CAMERA_LOCAL: CameraAnimationPlaySpace #: 0: This anim is applied in camera space.
    WORLD: CameraAnimationPlaySpace #: 1: This anim is applied in world space.
    USER_DEFINED: CameraAnimationPlaySpace #: 2: This anim is applied in a user-specified space (defined by UserPlaySpaceMatrix).
    ...

class InitialOscillatorOffset(EnumBase):
    r"""
    Shake start offset parameter
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: LegacyCameraShake.h
    
    """

    EOO_OFFSET_RANDOM: InitialOscillatorOffset #: 0: Start with random offset (default).
    EOO_OFFSET_ZERO: InitialOscillatorOffset #: 1: Start with zero offset.
    ...

class CameraAnimationEasingType(EnumBase):
    r"""
    ECamera Animation Easing Type
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraAnimationCameraModifier.h
    
    """

    LINEAR: CameraAnimationEasingType #: 0
    SINUSOIDAL: CameraAnimationEasingType #: 1
    QUADRATIC: CameraAnimationEasingType #: 2
    CUBIC: CameraAnimationEasingType #: 3
    QUARTIC: CameraAnimationEasingType #: 4
    QUINTIC: CameraAnimationEasingType #: 5
    EXPONENTIAL: CameraAnimationEasingType #: 6
    CIRCULAR: CameraAnimationEasingType #: 7
    ...

class InitialWaveOscillatorOffsetType(EnumBase):
    r"""
    Shake start offset parameter.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: WaveOscillatorCameraShakePattern.h
    
    """

    RANDOM: InitialWaveOscillatorOffsetType #: 0: Start with random offset (default).
    ZERO: InitialWaveOscillatorOffsetType #: 1: Start with zero offset.
    ...

class FlipbookCollisionMode(EnumBase):
    r"""
    EFlipbook Collision Mode
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperFlipbook.h
    
    """

    NO_COLLISION: FlipbookCollisionMode #: 0: The flipbook has no collision
    FIRST_FRAME_COLLISION: FlipbookCollisionMode #: 1: The flipbook has non-animated collision based on the first frame of the animation
    EACH_FRAME_COLLISION: FlipbookCollisionMode #: 2: The flipbook changes collision each frame based on the animation (Note: This setting is not recommended and is very expensive, recreating the physics state every frame)
    ...

class SpriteCollisionMode(EnumBase):
    r"""
    The kind of collision that a Paper2D asset or component might participate in
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: SpriteEditorOnlyTypes.h
    
    """

    NONE: SpriteCollisionMode #: 0: Should this have no collison and not participate in physics?
    USE3D_PHYSICS: SpriteCollisionMode #: 2: Should this have 3D collision geometry and participate in the 3D physics world?
    ...

class SpritePivotMode(EnumBase):
    r"""
    ESprite Pivot Mode
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: SpriteEditorOnlyTypes.h
    
    """

    TOP_LEFT: SpritePivotMode #: 0
    TOP_CENTER: SpritePivotMode #: 1
    TOP_RIGHT: SpritePivotMode #: 2
    CENTER_LEFT: SpritePivotMode #: 3
    CENTER_CENTER: SpritePivotMode #: 4
    CENTER_RIGHT: SpritePivotMode #: 5
    BOTTOM_LEFT: SpritePivotMode #: 6
    BOTTOM_CENTER: SpritePivotMode #: 7
    BOTTOM_RIGHT: SpritePivotMode #: 8
    CUSTOM: SpritePivotMode #: 9
    ...

class PaperSpriteAtlasPadding(EnumBase):
    r"""
    EPaper Sprite Atlas Padding
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperSpriteAtlas.h
    
    """

    DILATE_BORDER: PaperSpriteAtlasPadding #: 0: Dilate the texture to pad the atlas.
    PAD_WITH_ZERO: PaperSpriteAtlasPadding #: 1: Padding border filled with zeros.
    ...

class TileMapProjectionMode(EnumBase):
    r"""
    The different kinds of projection modes supported
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTileMap.h
    
    """

    ORTHOGONAL: TileMapProjectionMode #: 0: Square tile layout
    ISOMETRIC_DIAMOND: TileMapProjectionMode #: 1: Isometric tile layout (shaped like a diamond) */
    ISOMETRIC_STAGGERED: TileMapProjectionMode #: 2: Isometric tile layout (roughly in a square with alternating rows staggered).  Warning: Not fully supported yet.
    HEXAGONAL_STAGGERED: TileMapProjectionMode #: 3: Hexagonal tile layout (roughly in a square with alternating rows staggered).  Warning: Not fully supported yet.
    ...

class SpritePolygonMode(EnumBase):
    r"""
    Method of specifying polygons for a sprite's render or collision data
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: SpriteEditorOnlyTypes.h
    
    """

    SOURCE_BOUNDING_BOX: SpritePolygonMode #: 0: Use the bounding box of the source sprite (no optimization)
    TIGHT_BOUNDING_BOX: SpritePolygonMode #: 1: Tighten the bounding box around the sprite to exclude fully transparent areas (the default)
    SHRINK_WRAPPED: SpritePolygonMode #: 2: Shrink-wrapped geometry
    FULLY_CUSTOM: SpritePolygonMode #: 3: Fully custom geometry; edited by hand
    DICED: SpritePolygonMode #: 4: Diced (split up into smaller squares, including only non-empty ones in the final geometry).  This option is only supported for Render geometry and will be ignored for Collision geometry.
    ...

class SpriteShapeType(EnumBase):
    r"""
    The type of a shape in a sprite geometry structure
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: SpriteEditorOnlyTypes.h
    
    """

    BOX: SpriteShapeType #: 0: Box/Rectangular prism (size defined by BoxSize)
    CIRCLE: SpriteShapeType #: 1: Circle/Sphere (major axis is defined by BoxSize.X, minor axis by BoxSize.Y)
    POLYGON: SpriteShapeType #: 2: Custom closed polygon
    ...

class RetargetTranslationMode(EnumBase):
    r"""
    ERetarget Translation Mode
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetSettings.h
    
    """

    NONE: RetargetTranslationMode #: 0
    GLOBALLY_SCALED: RetargetTranslationMode #: 1
    ABSOLUTE: RetargetTranslationMode #: 2
    ...

class RetargetRotationMode(EnumBase):
    r"""
    ERetarget Rotation Mode
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetSettings.h
    
    """

    INTERPOLATED: RetargetRotationMode #: 0
    ONE_TO_ONE: RetargetRotationMode #: 1
    ONE_TO_ONE_REVERSED: RetargetRotationMode #: 2
    NONE: RetargetRotationMode #: 3
    ...

class IKRigGoalSpace(EnumBase):
    r"""
    EIKRig Goal Space
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRigDataTypes.h
    
    """

    COMPONENT: IKRigGoalSpace #: 0
    ADDITIVE: IKRigGoalSpace #: 1
    WORLD: IKRigGoalSpace #: 2
    ...

class IKRigGoalTransformSource(EnumBase):
    r"""
    EIKRig Goal Transform Source
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRigDataTypes.h
    
    """

    MANUAL: IKRigGoalTransformSource #: 0
    BONE: IKRigGoalTransformSource #: 1
    ACTOR_COMPONENT: IKRigGoalTransformSource #: 2
    ...

class IKRigGoalPreviewMode(EnumBase):
    r"""
    EIKRig Goal Preview Mode
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRigDefinition.h
    
    """

    ADDITIVE: IKRigGoalPreviewMode #: 0
    ABSOLUTE: IKRigGoalPreviewMode #: 1
    ...

class RetargetSourceOrTarget(EnumBase):
    r"""
    which skeleton are we referring to?
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargeter.h
    
    """

    SOURCE: RetargetSourceOrTarget #: 0: the SOURCE skeleton (to copy FROM)
    TARGET: RetargetSourceOrTarget #: 1: the TARGET skeleton (to copy TO)
    ...

class PinBoneType(EnumBase):
    r"""
    which skeleton are we referring to?
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: PinBoneOp.h
    
    """

    FULL_TRANSFORM: PinBoneType #: 0
    TRANSLATE_ONLY: PinBoneType #: 1
    ROTATE_ONLY: PinBoneType #: 2
    SCALE_ONLY: PinBoneType #: 3
    ...

class RootMotionSource(EnumBase):
    r"""
    where to copy the motion of the root from
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: RootMotionGeneratorOp.h
    
    """

    COPY_FROM_SOURCE_ROOT: RootMotionSource #: 0
    GENERATE_FROM_TARGET_PELVIS: RootMotionSource #: 1
    ...

class RootMotionHeightSource(EnumBase):
    r"""
    where to copy the height of the root from
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: RootMotionGeneratorOp.h
    
    """

    COPY_HEIGHT_FROM_SOURCE: RootMotionHeightSource #: 0
    SNAP_TO_GROUND: RootMotionHeightSource #: 1
    ...

class WarpingDirectionSource(EnumBase):
    r"""
    EWarping Direction Source
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetSettings.h
    
    """

    GOALS: WarpingDirectionSource #: 0
    CHAIN: WarpingDirectionSource #: 1
    ROOT_BONE: WarpingDirectionSource #: 2
    ...

class BasicAxis(EnumBase):
    r"""
    EBasic Axis
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetSettings.h
    
    """

    X: BasicAxis #: 0
    Y: BasicAxis #: 1
    Z: BasicAxis #: 2
    NEG_X: BasicAxis #: 3
    NEG_Y: BasicAxis #: 4
    NEG_Z: BasicAxis #: 5
    ...

class DataSortTypeEnum(EnumBase):
    r"""
    EData Sort Type Enum
    
    **C++ Source:**
    
    - **Plugin**: ChaosNiagara
    - **Module**: ChaosNiagara
    - **File**: NiagaraDataInterfaceChaosDestruction.h
    
    """

    CHAOS_NIAGARA_DATA_SORT_TYPE_NO_SORTING: DataSortTypeEnum #: 0
    CHAOS_NIAGARA_DATA_SORT_TYPE_RANDOM_SHUFFLE: DataSortTypeEnum #: 1
    CHAOS_NIAGARA_DATA_SORT_TYPE_SORT_BY_MASS_MAX_TO_MIN: DataSortTypeEnum #: 2
    CHAOS_NIAGARA_DATA_SORT_TYPE_SORT_BY_MASS_MIN_TO_MAX: DataSortTypeEnum #: 3
    ...

class RandomVelocityGenerationTypeEnum(EnumBase):
    r"""
    ERandom Velocity Generation Type Enum
    
    **C++ Source:**
    
    - **Plugin**: ChaosNiagara
    - **Module**: ChaosNiagara
    - **File**: NiagaraDataInterfaceChaosDestruction.h
    
    """

    CHAOS_NIAGARA_RANDOM_VELOCITY_GENERATION_TYPE_RANDOM_DISTRIBUTION: RandomVelocityGenerationTypeEnum #: 0
    CHAOS_NIAGARA_RANDOM_VELOCITY_GENERATION_TYPE_RANDOM_DISTRIBUTION_WITH_STREAMERS: RandomVelocityGenerationTypeEnum #: 1
    CHAOS_NIAGARA_RANDOM_VELOCITY_GENERATION_TYPE_COLLISION_NORMAL_BASED: RandomVelocityGenerationTypeEnum #: 2
    ...

class DebugTypeEnum(EnumBase):
    r"""
    EDebug Type Enum
    
    **C++ Source:**
    
    - **Plugin**: ChaosNiagara
    - **Module**: ChaosNiagara
    - **File**: NiagaraDataInterfaceChaosDestruction.h
    
    """

    CHAOS_NIAGARA_DEBUG_TYPE_NO_DEBUG: DebugTypeEnum #: 0
    CHAOS_NIAGARA_DEBUG_TYPE_COLOR_BY_SOLVER: DebugTypeEnum #: 1
    CHAOS_NIAGARA_DEBUG_TYPE_COLOR_BY_PARTICLE_INDEX: DebugTypeEnum #: 2
    ...

class DataSourceTypeEnum(EnumBase):
    r"""
    EData Source Type Enum
    
    **C++ Source:**
    
    - **Plugin**: ChaosNiagara
    - **Module**: ChaosNiagara
    - **File**: NiagaraDataInterfaceChaosDestruction.h
    
    """

    CHAOS_NIAGARA_DATA_SOURCE_TYPE_COLLISION: DataSourceTypeEnum #: 0
    CHAOS_NIAGARA_DATA_SOURCE_TYPE_BREAKING: DataSourceTypeEnum #: 1
    CHAOS_NIAGARA_DATA_SOURCE_TYPE_TRAILING: DataSourceTypeEnum #: 2
    ...

class LocationFilteringModeEnum(EnumBase):
    r"""
    ELocation Filtering Mode Enum
    
    **C++ Source:**
    
    - **Plugin**: ChaosNiagara
    - **Module**: ChaosNiagara
    - **File**: NiagaraDataInterfaceChaosDestruction.h
    
    """

    CHAOS_NIAGARA_LOCATION_FILTERING_MODE_INCLUSIVE: LocationFilteringModeEnum #: 0
    CHAOS_NIAGARA_LOCATION_FILTERING_MODE_EXCLUSIVE: LocationFilteringModeEnum #: 1
    ...

class LocationXToSpawnEnum(EnumBase):
    r"""
    ELocation XTo Spawn Enum
    
    **C++ Source:**
    
    - **Plugin**: ChaosNiagara
    - **Module**: ChaosNiagara
    - **File**: NiagaraDataInterfaceChaosDestruction.h
    
    """

    CHAOS_NIAGARA_LOCATION_X_TO_SPAWN_NONE: LocationXToSpawnEnum #: 0
    CHAOS_NIAGARA_LOCATION_X_TO_SPAWN_MIN: LocationXToSpawnEnum #: 1
    CHAOS_NIAGARA_LOCATION_X_TO_SPAWN_MAX: LocationXToSpawnEnum #: 2
    CHAOS_NIAGARA_LOCATION_X_TO_SPAWN_MIN_MAX: LocationXToSpawnEnum #: 3
    ...

class LocationYToSpawnEnum(EnumBase):
    r"""
    ELocation YTo Spawn Enum
    
    **C++ Source:**
    
    - **Plugin**: ChaosNiagara
    - **Module**: ChaosNiagara
    - **File**: NiagaraDataInterfaceChaosDestruction.h
    
    """

    CHAOS_NIAGARA_LOCATION_Y_TO_SPAWN_NONE: LocationYToSpawnEnum #: 0
    CHAOS_NIAGARA_LOCATION_Y_TO_SPAWN_MIN: LocationYToSpawnEnum #: 1
    CHAOS_NIAGARA_LOCATION_Y_TO_SPAWN_MAX: LocationYToSpawnEnum #: 2
    CHAOS_NIAGARA_LOCATION_Y_TO_SPAWN_MIN_MAX: LocationYToSpawnEnum #: 3
    ...

class LocationZToSpawnEnum(EnumBase):
    r"""
    ELocation ZTo Spawn Enum
    
    **C++ Source:**
    
    - **Plugin**: ChaosNiagara
    - **Module**: ChaosNiagara
    - **File**: NiagaraDataInterfaceChaosDestruction.h
    
    """

    CHAOS_NIAGARA_LOCATION_Z_TO_SPAWN_NONE: LocationZToSpawnEnum #: 0
    CHAOS_NIAGARA_LOCATION_Z_TO_SPAWN_MIN: LocationZToSpawnEnum #: 1
    CHAOS_NIAGARA_LOCATION_Z_TO_SPAWN_MAX: LocationZToSpawnEnum #: 2
    CHAOS_NIAGARA_LOCATION_Z_TO_SPAWN_MIN_MAX: LocationZToSpawnEnum #: 3
    ...

class OutlinerColumnMode(EnumBase):
    r"""
    EOutliner Column Mode
    
    **C++ Source:**
    
    - **Plugin**: ChaosEditor
    - **Module**: FractureEditor
    - **File**: FractureEditorModeToolkit.h
    
    """

    STATE: OutlinerColumnMode #: 0
    DAMAGE: OutlinerColumnMode #: 1
    REMOVAL: OutlinerColumnMode #: 2
    COLLISION: OutlinerColumnMode #: 3
    SIZE: OutlinerColumnMode #: 4
    GEOMETRY: OutlinerColumnMode #: 5
    ...

class DynamicStateOverrideEnum(EnumBase):
    r"""
    EDynamic State Override Enum
    
    **C++ Source:**
    
    - **Plugin**: ChaosEditor
    - **Module**: FractureEditor
    - **File**: FractureToolProperties.h
    
    """

    NO_OVERRIDE: DynamicStateOverrideEnum #: 0
    KINEMATIC: DynamicStateOverrideEnum #: 2
    STATIC: DynamicStateOverrideEnum #: 3
    ...

class InspectedAttributeEnum(EnumBase):
    r"""
    EInspected Attribute Enum
    
    **C++ Source:**
    
    - **Plugin**: ChaosEditor
    - **Module**: FractureEditor
    - **File**: SGeometryCollectionHistogram.h
    
    """

    VOLUME: InspectedAttributeEnum #: 0
    LEVEL: InspectedAttributeEnum #: 1
    INITIAL_DYNAMIC_STATE: InspectedAttributeEnum #: 3
    SIZE: InspectedAttributeEnum #: 4
    ...

class OutlinerItemNameEnum(EnumBase):
    r"""
    EOutliner Item Name Enum
    
    **C++ Source:**
    
    - **Plugin**: ChaosEditor
    - **Module**: FractureEditor
    - **File**: SGeometryCollectionOutliner.h
    
    """

    BONE_NAME: OutlinerItemNameEnum #: 0
    BONE_INDEX: OutlinerItemNameEnum #: 1
    ...

class FloatArrayToIntArrayFunctionEnum(EnumBase):
    r"""
    EFloat Array to Int Array Function Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionArrayNodes.h
    
    """

    DATAFLOW_FLOAT_TO_INT_FUNCTION_FLOOR: FloatArrayToIntArrayFunctionEnum #: 0
    DATAFLOW_FLOAT_TO_INT_FUNCTION_CEIL: FloatArrayToIntArrayFunctionEnum #: 1
    DATAFLOW_FLOAT_TO_INT_FUNCTION_ROUND: FloatArrayToIntArrayFunctionEnum #: 2
    DATAFLOW_FLOAT_TO_INT_FUNCTION_TRUNCATE: FloatArrayToIntArrayFunctionEnum #: 3
    DATAFLOW_FLOAT_TO_INT_NON_ZERO_TO_INDEX: FloatArrayToIntArrayFunctionEnum #: 4
    DATAFLOW_FLOAT_TO_INT_ZERO_TO_INDEX: FloatArrayToIntArrayFunctionEnum #: 5
    ...

class CompareOperation1Enum(EnumBase):
    r"""
    ECompare Operation 1Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionArrayNodes.h
    
    """

    DATAFLOW_COMPARE_EQUAL: CompareOperation1Enum #: 0
    DATAFLOW_COMPARE_SMALLER: CompareOperation1Enum #: 1
    DATAFLOW_COMPARE_SMALLER_OR_EQUAL: CompareOperation1Enum #: 2
    DATAFLOW_COMPARE_GREATER: CompareOperation1Enum #: 3
    DATAFLOW_COMPARE_GREATER_OR_EQUAL: CompareOperation1Enum #: 4
    ...

class StatisticsOperationEnum(EnumBase):
    r"""
    EStatistics Operation Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionArrayNodes.h
    
    """

    DATAFLOW_E_STATISTICS_OPERATION_ENUM_MIN: StatisticsOperationEnum #: 0
    DATAFLOW_E_STATISTICS_OPERATION_ENUM_MAX: StatisticsOperationEnum #: 1
    DATAFLOW_E_STATISTICS_OPERATION_ENUM_MEAN: StatisticsOperationEnum #: 2
    DATAFLOW_E_STATISTICS_OPERATION_ENUM_MEDIAN: StatisticsOperationEnum #: 3
    DATAFLOW_E_STATISTICS_OPERATION_ENUM_MODE: StatisticsOperationEnum #: 4
    DATAFLOW_E_STATISTICS_OPERATION_ENUM_SUM: StatisticsOperationEnum #: 5
    ...

class DataflowFieldFalloffType(EnumBase):
    r"""
    EDataflow Field Falloff Type
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionFieldNodes.h
    
    """

    DATAFLOW_FIELD_FALLOFF_TYPE_NONE: DataflowFieldFalloffType #: 0: No falloff function is used
    DATAFLOW_FIELD_FALLOFF_TYPE_LINEAR: DataflowFieldFalloffType #: 1: The falloff function will be proportional to x
    DATAFLOW_FIELD_FALLOFF_TYPE_INVERSE: DataflowFieldFalloffType #: 2: The falloff function will be proportional to 1.0/x
    DATAFLOW_FIELD_FALLOFF_TYPE_SQUARED: DataflowFieldFalloffType #: 3: The falloff function will be proportional to x*x
    DATAFLOW_FIELD_FALLOFF_TYPE_LOGARITHMIC: DataflowFieldFalloffType #: 4: The falloff function will be proportional to log(x)
    ...

class DataflowSetMaskConditionType(EnumBase):
    r"""
    EDataflow Set Mask Condition Type
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionFieldNodes.h
    
    """

    DATAFLOW_SET_MASK_CONDITION_TYPE_ALWAYS: DataflowSetMaskConditionType #: 0: The particle output value will be equal to Interior-value if the particle position is inside a sphere / Exterior-value otherwise.
    DATAFLOW_SET_MASK_CONDITION_TYPE_IFF_NOT_INTERIOR: DataflowSetMaskConditionType #: 1: The particle output value will be equal to Interior-value if the particle position is inside the sphere or if the particle input value is already Interior-Value / Exterior-value otherwise.
    DATAFLOW_SET_MASK_CONDITION_TYPE_IFF_NOT_EXTERIOR: DataflowSetMaskConditionType #: 2: The particle output value will be equal to Exterior-value if the particle position is outside the sphere or if the particle input value is already Exterior-Value / Interior-value otherwise.
    ...

class DataflowWaveFunctionType(EnumBase):
    r"""
    EDataflow Wave Function Type
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionFieldNodes.h
    
    """

    DATAFLOW_WAVE_FUNCTION_TYPE_COSINE: DataflowWaveFunctionType #: 0: Cosine wave that will move in time.
    DATAFLOW_WAVE_FUNCTION_TYPE_GAUSSIAN: DataflowWaveFunctionType #: 1: Gaussian wave that will move in time.
    DATAFLOW_WAVE_FUNCTION_TYPE_FALLOFF: DataflowWaveFunctionType #: 2: The radial falloff radius will move along temporal wave.
    DATAFLOW_WAVE_FUNCTION_TYPE_DECAY: DataflowWaveFunctionType #: 3: The magnitude of the field will decay in time.
    ...

class DataflowFloatFieldOperationType(EnumBase):
    r"""
    EDataflow Float Field Operation Type
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionFieldNodes.h
    
    """

    DATAFLOW_FLOAT_FIELD_OPERATION_TYPE_MULTIPLY: DataflowFloatFieldOperationType #: 0: Multiply the fields output values : Output = Left * Right
    DATAFLOW_FLOAT_FIELD_FALLOFF_TYPE_DIVIDE: DataflowFloatFieldOperationType #: 1: Divide the fields output values : Output = Left / Right
    DATAFLOW_FLOAT_FIELD_FALLOFF_TYPE_ADD: DataflowFloatFieldOperationType #: 2: Add the fields output values : Output = Left + Right
    DATAFLOW_FLOAT_FIELD_FALLOFF_TYPE_SUBSTRACT: DataflowFloatFieldOperationType #: 3: Subtract the fields output : Output = Left - Right
    DATAFLOW_FLOAT_FIELD_FALLOFF_TYPE_MIN: DataflowFloatFieldOperationType #: 4: Min of the fields output values: Output = Min(Left, Right)
    DATAFLOW_FLOAT_FIELD_FALLOFF_TYPE_MAX: DataflowFloatFieldOperationType #: 5: Max of the fields output values: Output = Max(Left, Right)
    ...

class DataflowVectorFieldOperationType(EnumBase):
    r"""
    EDataflow Vector Field Operation Type
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionFieldNodes.h
    
    """

    DATAFLOW_VECTOR_FIELD_OPERATION_TYPE_MULTIPLY: DataflowVectorFieldOperationType #: 0: Multiply the fields output values : Output = Left * Right
    DATAFLOW_VECTOR_FIELD_FALLOFF_TYPE_DIVIDE: DataflowVectorFieldOperationType #: 1: Divide the fields output values : Output = Left / Right
    DATAFLOW_VECTOR_FIELD_FALLOFF_TYPE_ADD: DataflowVectorFieldOperationType #: 2: Add the fields output values : Output = Left + Right
    DATAFLOW_VECTOR_FIELD_FALLOFF_TYPE_SUBSTRACT: DataflowVectorFieldOperationType #: 3: Subtract the fields output : Output = Left - Right
    DATAFLOW_VECTOR_FIELD_FALLOFF_TYPE_CROSS_PRODUCT: DataflowVectorFieldOperationType #: 4: Cross product of the fields output values: Output = Left x Right
    ...

class SetMaterialOperationTypeEnum(EnumBase):
    r"""
    ESet Material Operation Type Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionMaterialNodes.h
    
    """

    DATAFLOW_SET_MATERIAL_OPERATION_TYPE_ADD: SetMaterialOperationTypeEnum #: 0
    DATAFLOW_SET_MATERIAL_OPERATION_TYPE_INSERT: SetMaterialOperationTypeEnum #: 1
    ...

class ConvexOverlapRemovalMethodEnum(EnumBase):
    r"""
    EConvex Overlap Removal Method Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionUtilityNodes.h
    
    """

    DATAFLOW_E_CONVEX_OVERLAP_REMOVAL_METHOD_NONE: ConvexOverlapRemovalMethodEnum #: 0
    DATAFLOW_E_CONVEX_OVERLAP_REMOVAL_METHOD_ALL: ConvexOverlapRemovalMethodEnum #: 1
    DATAFLOW_E_CONVEX_OVERLAP_REMOVAL_METHOD_ONLY_CLUSTERS: ConvexOverlapRemovalMethodEnum #: 2
    DATAFLOW_E_CONVEX_OVERLAP_REMOVAL_METHOD_ONLY_CLUSTERS_VS_CLUSTERS: ConvexOverlapRemovalMethodEnum #: 3
    ...

class ClusterSizeMethodEnum(EnumBase):
    r"""
    ECluster Size Method Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionClusteringNodes.h
    
    """

    DATAFLOW_CLUSTER_SIZE_METHOD_BY_NUMBER: ClusterSizeMethodEnum #: 0
    DATAFLOW_CLUSTER_SIZE_METHOD_BY_FRACTION_OF_INPUT: ClusterSizeMethodEnum #: 1
    DATAFLOW_CLUSTER_SIZE_METHOD_BY_SIZE: ClusterSizeMethodEnum #: 2
    DATAFLOW_CLUSTER_SIZE_METHOD_BY_GRID: ClusterSizeMethodEnum #: 3
    ...

class ClusterNeighborSelectionMethodEnum(EnumBase):
    r"""
    ECluster Neighbor Selection Method Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionClusteringNodes.h
    
    """

    DATAFLOW_CLUSTER_NEIGHBOR_SELECTION_METHOD_LARGEST_NEIGHBOR: ClusterNeighborSelectionMethodEnum #: 0
    DATAFLOW_CLUSTER_NEIGHBOR_SELECTION_METHOD_NEAREST_CENTER: ClusterNeighborSelectionMethodEnum #: 1
    ...

class FloatToIntFunctionEnum(EnumBase):
    r"""
    EFloat to Int Function Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionConversionNodes.h
    
    """

    DATAFLOW_FLOAT_TO_INT_FUNCTION_FLOOR: FloatToIntFunctionEnum #: 0
    DATAFLOW_FLOAT_TO_INT_FUNCTION_CEIL: FloatToIntFunctionEnum #: 1
    DATAFLOW_FLOAT_TO_INT_FUNCTION_ROUND: FloatToIntFunctionEnum #: 2
    DATAFLOW_FLOAT_TO_INT_FUNCTION_TRUNCATE: FloatToIntFunctionEnum #: 3
    ...

class VisibiltyOptionsEnum(EnumBase):
    r"""
    EVisibilty Options Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionEditNodes.h
    
    """

    DATAFLOW_VISIBILITY_OPTIONS_VISIBLE: VisibiltyOptionsEnum #: 0
    DATAFLOW_VISIBILITY_OPTIONS_INVISIBLE: VisibiltyOptionsEnum #: 1
    ...

class MakeBoxDataTypeEnum(EnumBase):
    r"""
    EMake Box Data Type Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionMakeNodes.h
    
    """

    DATAFLOW_MAKE_BOX_DATA_TYPE_MIN_MAX: MakeBoxDataTypeEnum #: 0
    DATAFLOW_MAKE_BOX_DATA_TYPE_CENTER_SIZE: MakeBoxDataTypeEnum #: 1
    ...

class MathConstantsEnum(EnumBase):
    r"""
    EMath Constants Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionMathNodes.h
    
    """

    DATAFLOW_MATH_CONSTANTS_PI: MathConstantsEnum #: 0
    DATAFLOW_MATH_CONSTANTS_HALF_PI: MathConstantsEnum #: 1
    DATAFLOW_MATH_CONSTANTS_TWO_PI: MathConstantsEnum #: 2
    DATAFLOW_MATH_CONSTANTS_FOUR_PI: MathConstantsEnum #: 3
    DATAFLOW_MATH_CONSTANTS_INV_PI: MathConstantsEnum #: 4
    DATAFLOW_MATH_CONSTANTS_INV_TWO_PI: MathConstantsEnum #: 5
    DATAFLOW_MATH_CONSTANTS_SQRT2: MathConstantsEnum #: 6
    DATAFLOW_MATH_CONSTANTS_INV_SQRT2: MathConstantsEnum #: 7
    DATAFLOW_MATH_CONSTANTS_SQRT3: MathConstantsEnum #: 8
    DATAFLOW_MATH_CONSTANTS_INV_SQRT3: MathConstantsEnum #: 9
    DATAFLOW_FLOAT_TO_INT_FUNCTION_E: MathConstantsEnum #: 10
    DATAFLOW_FLOAT_TO_INT_FUNCTION_GAMMA: MathConstantsEnum #: 11
    DATAFLOW_FLOAT_TO_INT_FUNCTION_GOLDEN_RATIO: MathConstantsEnum #: 12
    DATAFLOW_FLOAT_TO_INT_FUNCTION_ZERO_TOLERANCE: MathConstantsEnum #: 13
    ...

class MeshBooleanOperationEnum(EnumBase):
    r"""
    EMesh Boolean Operation Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionMeshNodes.h
    
    """

    DATAFLOW_MESH_BOOLEAN_UNION: MeshBooleanOperationEnum #: 0
    DATAFLOW_MESH_BOOLEAN_INTERSECT: MeshBooleanOperationEnum #: 1
    DATAFLOW_MESH_BOOLEAN_DIFFERENCE: MeshBooleanOperationEnum #: 2
    ...

class RotationOrderEnum(EnumBase):
    r"""
    ERotation Order Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionNodes.h
    
    """

    DATAFLOW_ROTATION_ORDER_XYZ: RotationOrderEnum #: 0
    DATAFLOW_ROTATION_ORDER_YZX: RotationOrderEnum #: 1
    DATAFLOW_ROTATION_ORDER_ZXY: RotationOrderEnum #: 2
    DATAFLOW_ROTATION_ORDER_XZY: RotationOrderEnum #: 3
    DATAFLOW_ROTATION_ORDER_YXZ: RotationOrderEnum #: 4
    DATAFLOW_ROTATION_ORDER_ZYX: RotationOrderEnum #: 5
    ...

class CompareOperationEnum(EnumBase):
    r"""
    ECompare Operation Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionNodes.h
    
    """

    DATAFLOW_COMPARE_EQUAL: CompareOperationEnum #: 0
    DATAFLOW_COMPARE_SMALLER: CompareOperationEnum #: 1
    DATAFLOW_COMPARE_SMALLER_OR_EQUAL: CompareOperationEnum #: 2
    DATAFLOW_COMPARE_GREATER: CompareOperationEnum #: 3
    DATAFLOW_COMPARE_GREATER_OR_EQUAL: CompareOperationEnum #: 4
    ...

class AnchorStateEnum(EnumBase):
    r"""
    EAnchor State Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionNodes.h
    
    """

    DATAFLOW_ANCHOR_STATE_ANCHORED: AnchorStateEnum #: 0
    DATAFLOW_ANCHOR_STATE_NOT_ANCHORED: AnchorStateEnum #: 1
    ...

class ProximityMethodEnum(EnumBase):
    r"""
    EProximity Method Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionNodes.h
    
    """

    DATAFLOW_PROXIMITY_METHOD_PRECISE: ProximityMethodEnum #: 0: Precise proximity mode looks for geometry with touching vertices or touching, coplanar, opposite - facing triangles.This works well with geometry fractured using our fracture tools.
    DATAFLOW_PROXIMITY_METHOD_CONVEX_HULL: ProximityMethodEnum #: 1: Convex Hull proximity mode looks for geometry with overlapping convex hulls(with an optional offset)
    ...

class ProximityContactFilteringMethodEnum(EnumBase):
    r"""
    EProximity Contact Filtering Method Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionNodes.h
    
    """

    DATAFLOW_PROXIMITY_CONTACT_FILTERING_METHOD_PROJECTED_BOUNDS_OVERLAP: ProximityContactFilteringMethodEnum #: 0: Rejects proximity if the bounding boxes do not overlap by more than Contact Threshold centimeters in any major axis direction (or at least half the max possible). This can filter out corner connections of box-like shapes.
    DATAFLOW_PROXIMITY_CONTACT_FILTERING_METHOD_CONVEX_HULL_SHARP: ProximityContactFilteringMethodEnum #: 1: Rejects proximity if the intersection of convex hulls (allowing for optional offset) follows a sharp, thin region which is not wider than Contact Threshold centimeters (or at least half the max possible).
    DATAFLOW_PROXIMITY_CONTACT_FILTERING_METHOD_CONVEX_HULL_AREA: ProximityContactFilteringMethodEnum #: 2: Rejects proximity if the surface area of the intersection of convex hulls (allowing for optional offset) is smaller than Contact Threshold squared (or at least half the max possible).
    ...

class ConnectionContactAreaMethodEnum(EnumBase):
    r"""
    EConnection Contact Area Method Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionNodes.h
    
    """

    DATAFLOW_CONNECTION_CONTACT_AREA_METHOD_NONE: ConnectionContactAreaMethodEnum #: 0: Do not compute contact areas
    DATAFLOW_PROXIMITY_CONTACT_FILTERING_METHOD_CONVEX_HULL_AREA: ConnectionContactAreaMethodEnum #: 1: Compute approximate contact surface area via the intersection of convex hulls (allowing for optional offset)
    ...

class StandardGroupNameEnum(EnumBase):
    r"""
    EStandard Group Name Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionNodes.h
    
    """

    DATAFLOW_E_STANDARD_GROUP_NAME_ENUM_TRANSFORM: StandardGroupNameEnum #: 0
    DATAFLOW_E_STANDARD_GROUP_NAME_ENUM_GEOMETRY: StandardGroupNameEnum #: 1
    DATAFLOW_E_STANDARD_GROUP_NAME_ENUM_FACES: StandardGroupNameEnum #: 2
    DATAFLOW_E_STANDARD_GROUP_NAME_ENUM_VERTICES: StandardGroupNameEnum #: 3
    DATAFLOW_E_STANDARD_GROUP_NAME_ENUM_MATERIAL: StandardGroupNameEnum #: 4
    DATAFLOW_E_STANDARD_GROUP_NAME_ENUM_BREAKING: StandardGroupNameEnum #: 5
    DATAFLOW_E_STANDARD_GROUP_NAME_ENUM_CUSTOM: StandardGroupNameEnum #: 6
    ...

class CustomAttributeTypeEnum(EnumBase):
    r"""
    ECustom Attribute Type Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionNodes.h
    
    """

    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_U_INT8: CustomAttributeTypeEnum #: 0: Data type: UInt8
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_INT32: CustomAttributeTypeEnum #: 1: Data type: Int32
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_FLOAT: CustomAttributeTypeEnum #: 2: Data type: Float
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_DOUBLE: CustomAttributeTypeEnum #: 3: Data type: Double
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_BOOL: CustomAttributeTypeEnum #: 4: Data type: Bool
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_STRING: CustomAttributeTypeEnum #: 5: Data type: FString
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_VECTOR2F: CustomAttributeTypeEnum #: 6: Data type: FVector2f
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_VECTOR3F: CustomAttributeTypeEnum #: 7: Data type: FVector3f
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_VECTOR3D: CustomAttributeTypeEnum #: 8: Data type: FVector3d
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_VECTOR4F: CustomAttributeTypeEnum #: 9: Data type: FVector4f
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_LINEAR_COLOR: CustomAttributeTypeEnum #: 10: Data type: FLinearColor
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_TRANSFORM: CustomAttributeTypeEnum #: 11: Data type: FTransform
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_QUAT4F: CustomAttributeTypeEnum #: 12: Data type: FQuat4f
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_BOX: CustomAttributeTypeEnum #: 13: Data type: FBox
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_GUID: CustomAttributeTypeEnum #: 14: Data type: FGuid
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_INT32_SET: CustomAttributeTypeEnum #: 15: Data type: TSet<int32>
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_INT32_ARRAY: CustomAttributeTypeEnum #: 16: Data type: TArray<int32>
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_INT_VECTOR: CustomAttributeTypeEnum #: 17: Data type: FIntVector
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_INT_VECTOR2: CustomAttributeTypeEnum #: 18: Data type: FIntVector2
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_INT_VECTOR4: CustomAttributeTypeEnum #: 19: Data type: FIntVector4
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_INT_VECTOR2_ARRAY: CustomAttributeTypeEnum #: 20: Data type: TArray<FIntVector2>
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_FLOAT_ARRAY: CustomAttributeTypeEnum #: 21: Data type: TArray<float>
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_VECTOR2F_ARRAY: CustomAttributeTypeEnum #: 22: Data type: TArray<FVector2f>
    DATAFLOW_CUSTOM_ATTRIBUTE_TYPE_F_VECTOR3F_ARRAY: CustomAttributeTypeEnum #: 23: Data type: TArray<FVector3f>
    ...

class SetOperationEnum(EnumBase):
    r"""
    ESet Operation Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionSelectionNodes.h
    
    """

    DATAFLOW_SET_OPERATION_AND: SetOperationEnum #: 0: Select elements that are selected in both incoming selections (Bitwise AND)
    DATAFLOW_SET_OPERATION_OR: SetOperationEnum #: 1: Select elements that are selected in either incoming selections (Bitwise OR)
    DATAFLOW_SET_OPERATION_XOR: SetOperationEnum #: 2: Select elements that are selected in exactly one incoming selection (Bitwise XOR)
    DATAFLOW_SET_OPERATION_SUBTRACT: SetOperationEnum #: 3: Select elements that are selected in only the first of the incoming selections (Bitwise A AND (NOT B))
    ...

class RangeSettingEnum(EnumBase):
    r"""
    ERange Setting Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionSelectionNodes.h
    
    """

    DATAFLOW_RANGE_SETTING_INSIDE_RANGE: RangeSettingEnum #: 0: Values for selection must be inside of the specified range
    DATAFLOW_RANGE_SETTING_OUTSIDE_RANGE: RangeSettingEnum #: 1: Values for selection must be outside of the specified range
    ...

class SelectSubjectTypeEnum(EnumBase):
    r"""
    ESelect Subject Type Enum
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionNodes
    - **File**: GeometryCollectionSelectionNodes.h
    
    """

    DATAFLOW_SELECT_SUBJECT_TYPE_VERTICES: SelectSubjectTypeEnum #: 0: InBox must contain the vertices of the bone
    DATAFLOW_SELECT_SUBJECT_TYPE_BOUNDING_BOX: SelectSubjectTypeEnum #: 1: InBox must contain the BoundingBox of the bone
    DATAFLOW_SELECT_SUBJECT_TYPE_CENTROID: SelectSubjectTypeEnum #: 2: InBox must contain the centroid of the bone
    ...

class OrientAxis(EnumBase):
    r"""
    FOrientOptions
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolsetExp
    - **Module**: SkeletalMeshModifiers
    - **File**: SkeletonModifier.h
    
    """

    NONE: OrientAxis #: 0
    POSITIVE_X: OrientAxis #: 1: Orients axis in the positive X direction
    POSITIVE_Y: OrientAxis #: 2: Orients axis in the positive Y direction
    POSITIVE_Z: OrientAxis #: 3: Orients axis in the positive Z direction
    NEGATIVE_X: OrientAxis #: 4: Orients axis in the negative X direction
    NEGATIVE_Y: OrientAxis #: 5: Orients axis in the negative Y direction
    NEGATIVE_Z: OrientAxis #: 6: Orients axis in the negative Z direction
    ...

class AlembicImportType(EnumBase):
    r"""
    Enum that describes type of asset to import
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    """

    STATIC_MESH: AlembicImportType #: 0: Imports only the first frame as one or multiple static meshes
    GEOMETRY_CACHE: AlembicImportType #: 1: Imports the Alembic file as flipbook and matrix animated objects
    SKELETAL: AlembicImportType #: 2: Imports the Alembic file as a skeletal mesh containing base poses as morph targets and blending between them to achieve the correct animation frame
    ...

class BaseCalculationType(EnumBase):
    r"""
    EBase Calculation Type
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    """

    PERCENTAGE_BASED: BaseCalculationType #: 1: Determines the number of bases that should be used with the given percentage
    FIXED_NUMBER: BaseCalculationType #: 2: Set a fixed number of bases to import
    NO_COMPRESSION: BaseCalculationType #: 3: One base per frame, uncompressed
    ...

class AlembicSamplingType(EnumBase):
    r"""
    EAlembic Sampling Type
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    """

    PER_FRAME: AlembicSamplingType #: 0: Samples the animation according to the imported data (default)
    PER_X_FRAMES: AlembicSamplingType #: 1: Samples the animation at given intervals determined by Frame Steps
    PER_TIME_STEP: AlembicSamplingType #: 2: Samples the animation at given intervals determined by Time Steps
    ...

class AbcConversionPreset(EnumBase):
    r"""
    Enum that describes type of asset to import
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    """

    MAYA: AbcConversionPreset #: 0: Imports only the first frame as one or multiple static meshes
    MAX: AbcConversionPreset #: 1: Imports the Alembic file as flipbook and matrix animated objects
    CUSTOM: AbcConversionPreset #: 2
    ...

class AbcGeometryCacheMotionVectorsImport(EnumBase):
    r"""
    EAbc Geometry Cache Motion Vectors Import
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    """

    NO_MOTION_VECTORS: AbcGeometryCacheMotionVectorsImport #: 0: No motion vectors will be present in the geometry cache.
    IMPORT_ABC_VELOCITIES_AS_MOTION_VECTORS: AbcGeometryCacheMotionVectorsImport #: 1: Imports the Velocities from the Alembic file and converts them to motion vectors. This will increase file size as the motion vectors will be stored on disc.
    CALCULATE_MOTION_VECTORS_DURING_IMPORT: AbcGeometryCacheMotionVectorsImport #: 2: Force calculation of motion vectors during import. This will increase file size as the motion vectors will be stored on disc.
    ...

class CollectionShareType(EnumBase):
    r"""
    ECollection Scripting Share Type
    
    **C++ Source:**
    
    - **Plugin**: AssetTags
    - **Module**: AssetTags
    - **File**: AssetTagsSubsystem.h
    
    """

    LOCAL: CollectionShareType #: 0: This collection is only visible to you and is not in source control.
    PRIVATE: CollectionShareType #: 1: This collection is only visible to you.
    SHARED: CollectionShareType #: 2: This collection is visible to everyone.
    ...

class TextureRotationDirection(EnumBase):
    r"""
    ETexture Rotation Direction
    
    **C++ Source:**
    
    - **Plugin**: AppleImageUtils
    - **Module**: AppleImageUtils
    - **File**: AppleImageUtilsTypes.h
    
    """

    NONE: TextureRotationDirection #: 0
    LEFT: TextureRotationDirection #: 1
    RIGHT: TextureRotationDirection #: 2
    DOWN: TextureRotationDirection #: 3
    LEFT_MIRRORED: TextureRotationDirection #: 4
    RIGHT_MIRRORED: TextureRotationDirection #: 5
    DOWN_MIRRORED: TextureRotationDirection #: 6
    UP_MIRRORED: TextureRotationDirection #: 7
    ...

class AppleTextureType(EnumBase):
    r"""
    EApple Texture Type
    
    **C++ Source:**
    
    - **Plugin**: AppleImageUtils
    - **Module**: AppleImageUtils
    - **File**: AppleImageUtilsTypes.h
    
    """

    UNKNOWN: AppleTextureType #: 0
    IMAGE: AppleTextureType #: 1
    PIXEL_BUFFER: AppleTextureType #: 2
    SURFACE: AppleTextureType #: 3
    METAL_TEXTURE: AppleTextureType #: 4
    ...

class DynamicMeshChangeType(EnumBase):
    r"""
    EDynamicMeshChangeType is used by FDynamicMeshChangeInfo to indicate a "type" of mesh change
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: UDynamicMesh.h
    
    """

    GENERAL_EDIT: DynamicMeshChangeType #: 0
    MESH_CHANGE: DynamicMeshChangeType #: 1
    MESH_REPLACEMENT_CHANGE: DynamicMeshChangeType #: 2
    MESH_VERTEX_CHANGE: DynamicMeshChangeType #: 3
    DEFORMATION_EDIT: DynamicMeshChangeType #: 4
    ATTRIBUTE_EDIT: DynamicMeshChangeType #: 5
    ...

class DynamicMeshAttributeChangeFlags(EnumBase):
    r"""
    EDynamic Mesh Attribute Change Flags
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: UDynamicMesh.h
    
    """

    UNKNOWN: DynamicMeshAttributeChangeFlags #: 0
    MESH_TOPOLOGY: DynamicMeshAttributeChangeFlags #: 1
    VERTEX_POSITIONS: DynamicMeshAttributeChangeFlags #: 2
    NORMALS_TANGENTS: DynamicMeshAttributeChangeFlags #: 4
    VERTEX_COLORS: DynamicMeshAttributeChangeFlags #: 8
    U_VS: DynamicMeshAttributeChangeFlags #: 16
    TRIANGLE_GROUPS: DynamicMeshAttributeChangeFlags #: 32
    ...

class DynamicMeshComponentColorOverrideMode(EnumBase):
    r"""
    Color Override Modes
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: BaseDynamicMeshComponent.h
    
    """

    NONE: DynamicMeshComponentColorOverrideMode #: 0: No Color Override enabled
    VERTEX_COLORS: DynamicMeshComponentColorOverrideMode #: 1: Vertex Colors are displayed
    POLYGROUPS: DynamicMeshComponentColorOverrideMode #: 2: Polygroup Colors are displayed
    CONSTANT: DynamicMeshComponentColorOverrideMode #: 3: Constant Color is displayed
    ...

class DynamicMeshVertexColorTransformMode(EnumBase):
    r"""
    Color Transform to apply to Vertex Colors when converting from internal DynamicMesh
    Color attributes (eg Color Overlay stored in FVector4f) to RHI Render Buffers (FColor).
    
    Note that UStaticMesh assumes the Source Mesh colors are Linear and always converts to SRGB.
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: BaseDynamicMeshComponent.h
    
    """

    NO_TRANSFORM: DynamicMeshVertexColorTransformMode #: 0: Do not apply any color-space transform to Vertex Colors
    LINEAR_TO_SRGB: DynamicMeshVertexColorTransformMode #: 1: Assume Vertex Colors are in Linear space and transform to SRGB
    SRGB_TO_LINEAR: DynamicMeshVertexColorTransformMode #: 2: Assume Vertex Colors are in SRGB space and convert to Linear
    ...

class DynamicMeshComponentTangentsMode(EnumBase):
    r"""
    Tangent calculation modes
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: BaseDynamicMeshComponent.h
    
    """

    NO_TANGENTS: DynamicMeshComponentTangentsMode #: 0: Tangents are not used/available, proceed accordingly (eg generate arbitrary orthogonal basis)
    AUTO_CALCULATED: DynamicMeshComponentTangentsMode #: 1: Tangents will be automatically calculated on demand. Note that mesh changes due to tangents calculation will *not* be broadcast via MeshChange events!
    EXTERNALLY_PROVIDED: DynamicMeshComponentTangentsMode #: 2: Tangents are externally provided via the FDynamicMesh3 AttributeSet
    DEFAULT: DynamicMeshComponentTangentsMode #: 255: Tangents mode will be set to the most commonly-useful default -- currently "From Dynamic Mesh"
    ...

class CreateModelingObjectResult(EnumBase):
    r"""
    Result code returned by UModelingObjectsCreationAPI functions
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    """

    OK: CreateModelingObjectResult #: 0
    CANCELLED: CreateModelingObjectResult #: 1
    FAILED_UNKNOWN: CreateModelingObjectResult #: 2
    FAILED_NO_API_FOUND: CreateModelingObjectResult #: 3
    FAILED_INVALID_WORLD: CreateModelingObjectResult #: 4
    FAILED_INVALID_MESH: CreateModelingObjectResult #: 5
    FAILED_INVALID_TEXTURE: CreateModelingObjectResult #: 6
    FAILED_ASSET_CREATION_FAILED: CreateModelingObjectResult #: 7
    FAILED_ACTOR_CREATION_FAILED: CreateModelingObjectResult #: 8
    FAILED_INVALID_MATERIAL: CreateModelingObjectResult #: 9
    ...

class CreateMeshObjectSourceMeshType(EnumBase):
    r"""
    Types of possible source meshes stored in FCreateMeshObjectParams
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    """

    MESH_DESCRIPTION: CreateMeshObjectSourceMeshType #: 0
    DYNAMIC_MESH: CreateMeshObjectSourceMeshType #: 1
    ...

class CreateObjectTypeHint(EnumBase):
    r"""
    Hint for the type of mesh object a UModelingObjectsCreationAPI might create based
    on FCreateMeshObjectParams data. This can be used by clients to try to specify
    the type of object to emit, however there is no guarantee that an API implementation
    supports creating all types.
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    """

    UNDEFINED: CreateObjectTypeHint #: 0
    STATIC_MESH: CreateObjectTypeHint #: 1
    VOLUME: CreateObjectTypeHint #: 2
    DYNAMIC_MESH_ACTOR: CreateObjectTypeHint #: 3
    ...

class GooglePADErrorCode(EnumBase):
    r"""
    An error code associated with Asset Pack operations.
    
    **C++ Source:**
    
    - **Plugin**: GooglePAD
    - **Module**: GooglePAD
    - **File**: GooglePADFunctionLibrary.h
    
    """

    ASSET_PACK_NO_ERROR: GooglePADErrorCode #: 0: There was no error with the request.
    ASSET_PACK_APP_UNAVAILABLE: GooglePADErrorCode #: 1: The requesting app is unavailable.
    ASSET_PACK_UNAVAILABLE: GooglePADErrorCode #: 2: The requested Asset Pack isn't available for this app version.
    ASSET_PACK_INVALID_REQUEST: GooglePADErrorCode #: 3: The request is invalid.
    ASSET_PACK_DOWNLOAD_NOT_FOUND: GooglePADErrorCode #: 4: The requested download isn't found.
    ASSET_PACK_API_NOT_AVAILABLE: GooglePADErrorCode #: 5: The Asset Pack API is unavailable.
    ASSET_PACK_NETWORK_ERROR: GooglePADErrorCode #: 6: Network error. Unable to obtain Asset Pack details.
    ASSET_PACK_ACCESS_DENIED: GooglePADErrorCode
    r"""
    7: Download not permitted under current device circumstances, e.g. app in
    background or device not signed into a Google account.
    """

    ASSET_PACK_INSUFFICIENT_STORAGE: GooglePADErrorCode #: 8: Asset Packs download failed due to insufficient storage.
    ASSET_PACK_PLAY_STORE_NOT_FOUND: GooglePADErrorCode #: 9: The Play Store app is either not installed or not the official version.
    ASSET_PACK_NETWORK_UNRESTRICTED: GooglePADErrorCode #: 10: Returned if showCellularDataConfirmation is called but no Asset Packs are waiting for Wi-Fi.
    ASSET_PACK_INTERNAL_ERROR: GooglePADErrorCode #: 11: Unknown error downloading Asset Pack.
    ASSET_PACK_INITIALIZATION_NEEDED: GooglePADErrorCode #: 12: The requested operation failed: need to call AssetPackManager_init() first.
    ASSET_PACK_INITIALIZATION_FAILED: GooglePADErrorCode #: 13: There was an error initializing the Asset Pack API.
    ...

class GooglePADDownloadStatus(EnumBase):
    r"""
    The status associated with Asset Pack download operations.
    
    **C++ Source:**
    
    - **Plugin**: GooglePAD
    - **Module**: GooglePAD
    - **File**: GooglePADFunctionLibrary.h
    
    """

    ASSET_PACK_UNKNOWN: GooglePADDownloadStatus #: 0: Nothing is known about the Asset Pack.
    ASSET_PACK_DOWNLOAD_PENDING: GooglePADDownloadStatus #: 1: An AssetPackManager_requestDownload() async request is pending.
    ASSET_PACK_DOWNLOADING: GooglePADDownloadStatus #: 2: The Asset Pack download is in progress.
    ASSET_PACK_TRANSFERRING: GooglePADDownloadStatus #: 3: The Asset Pack is being transferred to the app.
    ASSET_PACK_DOWNLOAD_COMPLETED: GooglePADDownloadStatus #: 4: Download and transfer are complete; the assets are available to the app.
    ASSET_PACK_DOWNLOAD_FAILED: GooglePADDownloadStatus #: 5: An AssetPackManager_requestDownload() has failed.
    ASSET_PACK_DOWNLOAD_CANCELED: GooglePADDownloadStatus #: 6: Asset Pack download has been canceled.
    ASSET_PACK_WAITING_FOR_WIFI: GooglePADDownloadStatus #: 7: The Asset Pack download is waiting for Wi-Fi to proceed.
    ASSET_PACK_NOT_INSTALLED: GooglePADDownloadStatus #: 8: The Asset Pack isn't installed.
    ASSET_PACK_INFO_PENDING: GooglePADDownloadStatus #: 9: An AssetPackManager_requestInfo() async request started, but the result isn't known yet.
    ASSET_PACK_INFO_FAILED: GooglePADDownloadStatus #: 10: An AssetPackManager_requestInfo() async request has failed.
    ASSET_PACK_REMOVAL_PENDING: GooglePADDownloadStatus #: 11: An AssetPackManager_requestRemoval() async request started.
    ASSET_PACK_REMOVAL_FAILED: GooglePADDownloadStatus #: 12: An AssetPackManager_requestRemoval() async request has failed.
    ...

class GooglePADStorageMethod(EnumBase):
    r"""
    The method used to store an Asset Pack on the device.
    
    **C++ Source:**
    
    - **Plugin**: GooglePAD
    - **Module**: GooglePAD
    - **File**: GooglePADFunctionLibrary.h
    
    """

    ASSET_PACK_STORAGE_FILES: GooglePADStorageMethod #: 0: The Asset Pack is unpacked into a folder containing individual asset files. Assets can be accessed via standard File APIs.
    ASSET_PACK_STORAGE_APK: GooglePADStorageMethod #: 1: The Asset Pack is installed as an APK containing packed asset files. Assets can be accessed via AAssetManager.
    ASSET_PACK_STORAGE_UNKNOWN: GooglePADStorageMethod #: 2: Nothing is known, perhaps due to an error.
    ASSET_PACK_STORAGE_NOT_INSTALLED: GooglePADStorageMethod #: 3: The Asset Pack is not installed.
    ...

class GooglePADCellularDataConfirmStatus(EnumBase):
    r"""
    The status associated with a request to display a cellular data confirmation dialog.
    
    **C++ Source:**
    
    - **Plugin**: GooglePAD
    - **Module**: GooglePAD
    - **File**: GooglePADFunctionLibrary.h
    
    """

    ASSET_PACK_CONFIRM_UNKNOWN: GooglePADCellularDataConfirmStatus #: 0: AssetPackManager_showCellularDataConfirmation() has not been called.
    ASSET_PACK_CONFIRM_PENDING: GooglePADCellularDataConfirmStatus #: 1: AssetPackManager_showCellularDataConfirmation() has been called, but the user hasn't made a choice.
    ASSET_PACK_CONFIRM_USER_APPROVED: GooglePADCellularDataConfirmStatus #: 2: The user approved of downloading Asset Packs over cellular data.
    ASSET_PACK_CONFIRM_USER_CANCELED: GooglePADCellularDataConfirmStatus #: 3: The user declined to download Asset Packs over cellular data.
    ...

class VariantManagerTestEnum(EnumBase):
    r"""
    EVariant Manager Test Enum
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContentEditor
    - **File**: VariantManagerTestActor.h
    
    """

    FIRST_OPTION: VariantManagerTestEnum #: 1
    SECOND_OPTION: VariantManagerTestEnum #: 3
    THIRD_OPTION: VariantManagerTestEnum #: 45
    ...

class InterchangeMaterialXShaders(EnumBase):
    r"""
    EInterchange Material XShaders
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeCommon
    - **File**: InterchangeMaterialXDefinitions.h
    
    """

    OPEN_PBR_SURFACE: InterchangeMaterialXShaders #: 0: Default settings for Open PBR Surface shader.
    OPEN_PBR_SURFACE_TRANSMISSION: InterchangeMaterialXShaders #: 1: Open PBR Surface shader        used for translucency.
    STANDARD_SURFACE: InterchangeMaterialXShaders #: 2: Default settings for Autodesk's Standard Surface shader.
    STANDARD_SURFACE_TRANSMISSION: InterchangeMaterialXShaders #: 3: Standard Surface shader used for translucency.
    SURFACE_UNLIT: InterchangeMaterialXShaders #: 4: Shader used for unlit surfaces.
    USD_PREVIEW_SURFACE: InterchangeMaterialXShaders #: 5: Default settings for USD's Surface shader.
    SURFACE: InterchangeMaterialXShaders #: 6: A surface shader constructed from scattering and emission distribution functions.
    ...

class InterchangeMaterialXBSDF(EnumBase):
    r"""
    Data type representing a Bidirectional Scattering Distribution Function.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeCommon
    - **File**: InterchangeMaterialXDefinitions.h
    
    """

    OREN_NAYAR_DIFFUSE: InterchangeMaterialXBSDF #: 0: A BSDF node for diffuse reflections.
    BURLEY_DIFFUSE: InterchangeMaterialXBSDF #: 1: A BSDF node for Burley diffuse reflections.
    TRANSLUCENT: InterchangeMaterialXBSDF #: 2: A BSDF node for pure diffuse transmission.
    DIELECTRIC: InterchangeMaterialXBSDF #: 3: A reflection/transmission BSDF node based on a microfacet model and a Fresnel curve for dielectrics.
    CONDUCTOR: InterchangeMaterialXBSDF #: 4: A reflection BSDF node based on a microfacet model and a Fresnel curve for conductors/metals.
    GENERALIZED_SCHLICK: InterchangeMaterialXBSDF #: 5: A reflection/transmission BSDF node based on a microfacet model and a generalized Schlick Fresnel curve.
    SUBSURFACE: InterchangeMaterialXBSDF #: 6: A subsurface scattering BSDF for true subsurface scattering.
    SHEEN: InterchangeMaterialXBSDF #: 7: A microfacet BSDF for the back-scattering properties of cloth-like materials.
    THIN_FILM: InterchangeMaterialXBSDF #: 8: Adds an iridescent thin film layer over a microfacet base BSDF.
    ...

class InterchangeMaterialXEDF(EnumBase):
    r"""
    Data type representing an Emission Distribution Function.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeCommon
    - **File**: InterchangeMaterialXDefinitions.h
    
    """

    UNIFORM: InterchangeMaterialXEDF #: 0: An EDF node for uniform emission.
    CONICAL: InterchangeMaterialXEDF #: 1: Constructs an EDF emitting light inside a cone around the normal direction.
    MEASURED: InterchangeMaterialXEDF #: 2: Constructs an EDF emitting light according to a measured IES light profile.
    ...

class InterchangeMaterialXVDF(EnumBase):
    r"""
    Data type representing a Volume Distribution Function.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeCommon
    - **File**: InterchangeMaterialXDefinitions.h
    
    """

    ABSORPTION: InterchangeMaterialXVDF #: 0: Constructs a VDF for pure light absorption.
    ANISOTROPIC: InterchangeMaterialXVDF #: 1: Constructs a VDF scattering light for a participating medium, based on the Henyey-Greenstein phase function.
    ...

class MediaTextureVisibleMipsTiles(EnumBase):
    r"""
    EMedia Texture Visible Mips Tiles
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaTextureTracker.h
    
    """

    NONE: MediaTextureVisibleMipsTiles #: 0
    PLANE: MediaTextureVisibleMipsTiles #: 1
    SPHERE: MediaTextureVisibleMipsTiles #: 2
    ...

class MovieSceneKeyInterpolation(EnumBase):
    r"""
    EMovie Scene Key Interpolation
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: KeyParams.h
    
    """

    AUTO: MovieSceneKeyInterpolation #: 0: Auto.
    USER: MovieSceneKeyInterpolation #: 1: User.
    BREAK: MovieSceneKeyInterpolation #: 2: Break.
    LINEAR: MovieSceneKeyInterpolation #: 3: Linear.
    CONSTANT: MovieSceneKeyInterpolation #: 4: Constant.
    SMART_AUTO: MovieSceneKeyInterpolation #: 5: Smart Auto.
    ...

class MotionExtractor_MotionType(EnumBase):
    r"""
    Type of motion to extract
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: MotionExtractorTypes.h
    
    """

    TRANSLATION: MotionExtractor_MotionType #: 1
    ROTATION: MotionExtractor_MotionType #: 2
    SCALE: MotionExtractor_MotionType #: 4
    TRANSLATION_SPEED: MotionExtractor_MotionType #: 8
    ROTATION_SPEED: MotionExtractor_MotionType #: 16
    ...

class MotionExtractor_Axis(EnumBase):
    r"""
    Axis to get the final value from
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: MotionExtractorTypes.h
    
    """

    X: MotionExtractor_Axis #: 0
    Y: MotionExtractor_Axis #: 1
    Z: MotionExtractor_Axis #: 2
    XY: MotionExtractor_Axis #: 3
    XZ: MotionExtractor_Axis #: 4
    YZ: MotionExtractor_Axis #: 5
    XYZ: MotionExtractor_Axis #: 6
    ...

class MotionExtractor_Space(EnumBase):
    r"""
    Reference frame/space to use when calculating motion
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: MotionExtractorTypes.h
    
    """

    COMPONENT_SPACE: MotionExtractor_Space #: 0
    LOCAL_SPACE: MotionExtractor_Space #: 1
    RELATIVE_TO_BONE: MotionExtractor_Space #: 2
    ...

class MotionExtractor_MathOperation(EnumBase):
    r"""
    Math operations that can be applied to the extracted value before add it to the curve
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: MotionExtractorTypes.h
    
    """

    NONE: MotionExtractor_MathOperation #: 0
    ADDITION: MotionExtractor_MathOperation #: 1
    SUBTRACTION: MotionExtractor_MathOperation #: 2
    DIVISION: MotionExtractor_MathOperation #: 3
    MULTIPLICATION: MotionExtractor_MathOperation #: 4
    ...

class DetectionTechnique(EnumBase):
    r"""
    Detection method used for placing a notify / marker in the track
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: FootstepAnimEventsModifier.h
    
    """

    PASS_THROUGH_REFERENCE_BONE: DetectionTechnique
    r"""
    0: Create anim event when foot bone passes through a given reference bone.
    
    Note that the translation vector of the reference bone will be used as the normal vector for the detection plane
    used to determine if the foot bone has crossed the reference bone.
    """

    FOOT_BONE_REACHES_GROUND: DetectionTechnique
    r"""
    1: Create anim event when foot bone reaches the ground level within a given threshold.
    
    Note that this will only be true if the foot bone position goes from NOT being within the threshold to being
    WITHIN the ground threshold.
    """

    FOOT_BONE_SPEED: DetectionTechnique
    r"""
    2: Create anim event when foot bone translation speed is below a given threshold and nearly zero.
    
    Note that the foot bone translation speed is normalize therefore when a footstep occurs
    the speed will be very close to zero.
    """

    ...

class EncodeRootBoneAxis(EnumBase):
    r"""
    EEncode Root Bone Axis
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: EncodeRootBoneModifier.h
    
    """

    X: EncodeRootBoneAxis #: 0
    Y: EncodeRootBoneAxis #: 1
    Z: EncodeRootBoneAxis #: 2
    ...

class SplineType(EnumBase):
    r"""
    ESpline Type
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineTypes.h
    
    """

    B_SPLINE: SplineType #: 0: The smooth curve will pass through the first and last control points
    HERMITE: SplineType #: 1: The curve will pass through the control points
    ...

class EditorScriptingStringMatchType(EnumBase):
    r"""
    EEditor Scripting String Match Type
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorFilterLibrary.h
    
    """

    CONTAINS: EditorScriptingStringMatchType #: 0
    MATCHES_WILDCARD: EditorScriptingStringMatchType #: 1
    EXACT_MATCH: EditorScriptingStringMatchType #: 2
    ...

class ScriptingCollisionShapeType_Deprecated(EnumBase):
    r"""
    Types of Collision Construct that are generated *
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorStaticMeshLibrary.h
    
    """

    BOX: ScriptingCollisionShapeType_Deprecated #: 0
    SPHERE: ScriptingCollisionShapeType_Deprecated #: 1
    CAPSULE: ScriptingCollisionShapeType_Deprecated #: 2
    NDOP10_X: ScriptingCollisionShapeType_Deprecated #: 3
    NDOP10_Y: ScriptingCollisionShapeType_Deprecated #: 4
    NDOP10_Z: ScriptingCollisionShapeType_Deprecated #: 5
    NDOP18: ScriptingCollisionShapeType_Deprecated #: 6
    NDOP26: ScriptingCollisionShapeType_Deprecated #: 7
    ...

class EditorScriptingFilterType(EnumBase):
    r"""
    EEditor Scripting Filter Type
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorFilterLibrary.h
    
    """

    INCLUDE: EditorScriptingFilterType #: 0
    EXCLUDE: EditorScriptingFilterType #: 1
    ...

class ScriptCollisionShapeType(EnumBase):
    r"""
    Types of Collision Construct that are generated *
    
    **C++ Source:**
    
    - **Module**: StaticMeshEditor
    - **File**: StaticMeshEditorSubsystemHelpers.h
    
    """

    BOX: ScriptCollisionShapeType #: 0
    SPHERE: ScriptCollisionShapeType #: 1
    CAPSULE: ScriptCollisionShapeType #: 2
    NDOP10_X: ScriptCollisionShapeType #: 3
    NDOP10_Y: ScriptCollisionShapeType #: 4
    NDOP10_Z: ScriptCollisionShapeType #: 5
    NDOP18: ScriptCollisionShapeType #: 6
    NDOP26: ScriptCollisionShapeType #: 7
    ...

class ScriptingCollisionShapeType(EnumBase):
    r"""
    deprecated: 'ScriptingCollisionShapeType' was renamed to 'ScriptCollisionShapeType'.
    """

    BOX: ScriptingCollisionShapeType #: 0
    SPHERE: ScriptingCollisionShapeType #: 1
    CAPSULE: ScriptingCollisionShapeType #: 2
    NDOP10_X: ScriptingCollisionShapeType #: 3
    NDOP10_Y: ScriptingCollisionShapeType #: 4
    NDOP10_Z: ScriptingCollisionShapeType #: 5
    NDOP18: ScriptingCollisionShapeType #: 6
    NDOP26: ScriptingCollisionShapeType #: 7
    ...

class CurveEditorFFTFilterClass(EnumBase):
    r"""
    ECurve Editor FFTFilter Class
    
    **C++ Source:**
    
    - **Plugin**: CurveEditorTools
    - **Module**: CurveEditorTools
    - **File**: CurveEditorFFTFilter.h
    
    """

    BUTTERWORTH: CurveEditorFFTFilterClass #: 0
    CHEBYSHEV: CurveEditorFFTFilterClass #: 1
    ...

class CurveEditorFFTFilterType(EnumBase):
    r"""
    ECurve Editor FFTFilter Type
    
    **C++ Source:**
    
    - **Plugin**: CurveEditorTools
    - **Module**: CurveEditorTools
    - **File**: CurveEditorFFTFilter.h
    
    """

    LOWPASS: CurveEditorFFTFilterType #: 0
    HIGHPASS: CurveEditorFFTFilterType #: 1
    ...

class ImportGeometryType(EnumBase):
    r"""
    Geometry import type
    
    **C++ Source:**
    
    - **Plugin**: SpeedTreeImporter
    - **Module**: SpeedTreeImporter
    - **File**: SpeedTreeImportData.h
    
    """

    IGT_3D: ImportGeometryType #: 0
    IGT_BILLBOARDS: ImportGeometryType #: 1
    IGT_BOTH: ImportGeometryType #: 2
    ...

class ImportLODType(EnumBase):
    r"""
    LOD type *
    
    **C++ Source:**
    
    - **Plugin**: SpeedTreeImporter
    - **Module**: SpeedTreeImporter
    - **File**: SpeedTreeImportData.h
    
    """

    ILT_PAINTED_FOLIAGE: ImportLODType #: 0
    ILT_INDIVIDUAL_ACTORS: ImportLODType #: 1
    ...

class GenerateStaticMeshLODProcess_MeshGeneratorModes(EnumBase):
    r"""
    EGenerate Static Mesh LODProcess Mesh Generator Modes
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    """

    SOLIDIFY: GenerateStaticMeshLODProcess_MeshGeneratorModes
    r"""
    0: Generate a mesh using Marching Cubes to remesh the input shape.
    Use Winding Numbers to determine what is inside
    """

    SOLIDIFY_AND_CLOSE: GenerateStaticMeshLODProcess_MeshGeneratorModes
    r"""
    1: Like Solidify, but Dilate and Contract the shape to delete small
    negative features (sharp inner corners, small holes) before remeshing
    """

    CLEAN_AND_SIMPLIFY: GenerateStaticMeshLODProcess_MeshGeneratorModes #: 2: Generate a mesh by simplifying input Mesh attributes and filling small holes
    CONVEX_HULL: GenerateStaticMeshLODProcess_MeshGeneratorModes #: 3: Generate a mesh by calculating the Convex Hull of the input shape
    ...

class GenerateStaticMeshLODProcess_SimplifyMethod(EnumBase):
    r"""
    EGenerate Static Mesh LODProcess Simplify Method
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    """

    TRIANGLE_COUNT: GenerateStaticMeshLODProcess_SimplifyMethod #: 0
    VERTEX_COUNT: GenerateStaticMeshLODProcess_SimplifyMethod #: 1
    TRIANGLE_PERCENTAGE: GenerateStaticMeshLODProcess_SimplifyMethod #: 2
    GEOMETRIC_TOLERANCE: GenerateStaticMeshLODProcess_SimplifyMethod #: 3
    ...

class GenerateStaticMeshLODProcess_NormalsMethod(EnumBase):
    r"""
    EGenerate Static Mesh LODProcess Normals Method
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    """

    FROM_ANGLE_THRESHOLD: GenerateStaticMeshLODProcess_NormalsMethod #: 0
    PER_VERTEX: GenerateStaticMeshLODProcess_NormalsMethod #: 1
    PER_TRIANGLE: GenerateStaticMeshLODProcess_NormalsMethod #: 2
    ...

class GenerateStaticMeshLODBakeResolution(EnumBase):
    r"""
    EGenerate Static Mesh LODBake Resolution
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    """

    RESOLUTION16: GenerateStaticMeshLODBakeResolution #: 16
    RESOLUTION32: GenerateStaticMeshLODBakeResolution #: 32
    RESOLUTION64: GenerateStaticMeshLODBakeResolution #: 64
    RESOLUTION128: GenerateStaticMeshLODBakeResolution #: 128
    RESOLUTION256: GenerateStaticMeshLODBakeResolution #: 256
    RESOLUTION512: GenerateStaticMeshLODBakeResolution #: 512
    RESOLUTION1024: GenerateStaticMeshLODBakeResolution #: 1024
    RESOLUTION2048: GenerateStaticMeshLODBakeResolution #: 2048
    RESOLUTION4096: GenerateStaticMeshLODBakeResolution #: 4096
    RESOLUTION8192: GenerateStaticMeshLODBakeResolution #: 8192
    ...

class GenerateStaticMeshLODProcess_AutoUVMethod(EnumBase):
    r"""
    EGenerate Static Mesh LODProcess Auto UVMethod
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    """

    PATCH_BUILDER: GenerateStaticMeshLODProcess_AutoUVMethod #: 0
    UV_ATLAS: GenerateStaticMeshLODProcess_AutoUVMethod #: 1
    X_ATLAS: GenerateStaticMeshLODProcess_AutoUVMethod #: 2
    ...

class GenerateStaticMeshLODSimpleCollisionGeometryType(EnumBase):
    r"""
    EGenerate Static Mesh LODSimple Collision Geometry Type
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    """

    ALIGNED_BOXES: GenerateStaticMeshLODSimpleCollisionGeometryType #: 0
    ORIENTED_BOXES: GenerateStaticMeshLODSimpleCollisionGeometryType #: 1
    MINIMAL_SPHERES: GenerateStaticMeshLODSimpleCollisionGeometryType #: 2
    CAPSULES: GenerateStaticMeshLODSimpleCollisionGeometryType #: 3
    CONVEX_HULLS: GenerateStaticMeshLODSimpleCollisionGeometryType #: 4
    SWEPT_HULLS: GenerateStaticMeshLODSimpleCollisionGeometryType #: 5
    MIN_VOLUME: GenerateStaticMeshLODSimpleCollisionGeometryType #: 6
    NONE: GenerateStaticMeshLODSimpleCollisionGeometryType #: 7
    ...

class GenerateStaticMeshLODProjectedHullAxisMode(EnumBase):
    r"""
    EGenerate Static Mesh LODProjected Hull Axis Mode
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    """

    X: GenerateStaticMeshLODProjectedHullAxisMode #: 0
    Y: GenerateStaticMeshLODProjectedHullAxisMode #: 1
    Z: GenerateStaticMeshLODProjectedHullAxisMode #: 2
    SMALLEST_BOX_DIMENSION: GenerateStaticMeshLODProjectedHullAxisMode #: 3
    SMALLEST_VOLUME: GenerateStaticMeshLODProjectedHullAxisMode #: 4
    ...

class ObjectMixerInheritanceInclusionOptions(EnumBase):
    r"""
    EObject Mixer Inheritance Inclusion Options
    
    **C++ Source:**
    
    - **Plugin**: ObjectMixer
    - **Module**: ObjectMixerEditor
    - **File**: ObjectMixerEditorObjectFilter.h
    
    """

    NONE: ObjectMixerInheritanceInclusionOptions #: 0: Get only the properties in the specified classes without considering parent or child classes
    INCLUDE_ONLY_IMMEDIATE_PARENT: ObjectMixerInheritanceInclusionOptions #: 1: Get properties from the class that the specified classes immediately derive from, but not the parents' parents + Specified Classes
    INCLUDE_ONLY_IMMEDIATE_CHILDREN: ObjectMixerInheritanceInclusionOptions #: 2: Get properties from child classes but not child classes of child classes + Specified Classes
    INCLUDE_ONLY_IMMEDIATE_PARENT_AND_CHILDREN: ObjectMixerInheritanceInclusionOptions #: 3: IncludeOnlyImmediateParent + IncludeOnlyImmediateChildren + Specified Classes
    INCLUDE_ALL_PARENTS: ObjectMixerInheritanceInclusionOptions #: 4: Go up the chain of parent classes to get all properties in the specified classes' ancestries + Specified Classes
    INCLUDE_ALL_CHILDREN: ObjectMixerInheritanceInclusionOptions #: 5: Get properties from all derived classes recursively + Specified Classes
    INCLUDE_ALL_PARENTS_AND_CHILDREN: ObjectMixerInheritanceInclusionOptions #: 6: IncludeAllParents + IncludeAllChildren + Specified Classes
    INCLUDE_ALL_PARENTS_AND_ONLY_IMMEDIATE_CHILDREN: ObjectMixerInheritanceInclusionOptions #: 7: IncludeAllParents + IncludeOnlyImmediateChildren + Specified Classes
    INCLUDE_ONLY_IMMEDIATE_PARENT_AND_ALL_CHILDREN: ObjectMixerInheritanceInclusionOptions #: 8: IncludeOnlyImmediateParent + IncludeAllChildren + Specified Classes
    ...

class ObjectMixerTreeViewMode(EnumBase):
    r"""
    EObject Mixer Tree View Mode
    
    **C++ Source:**
    
    - **Plugin**: ObjectMixer
    - **Module**: ObjectMixerEditor
    - **File**: ObjectMixerEditorObjectFilter.h
    
    """

    NO_FOLDERS: ObjectMixerTreeViewMode #: 0: Show all matching objects without folders
    FOLDERS: ObjectMixerTreeViewMode #: 1: Display objects in a hierarchy with folders
    ...

class TakeRecorderActorRecordType(EnumBase):
    r"""
    ETake Recorder Actor Record Type
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderActorSource.h
    
    """

    POSSESSABLE: TakeRecorderActorRecordType #: 0
    SPAWNABLE: TakeRecorderActorRecordType #: 1
    PROJECT_DEFAULT: TakeRecorderActorRecordType #: 2
    ...

class CacheTrackRecorderState(EnumBase):
    r"""
    ECache Track Recorder State
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: CacheTrackRecorder
    - **File**: CacheTrackRecorder.h
    
    """

    STARTING: CacheTrackRecorderState #: 0
    PRE_RECORD: CacheTrackRecorderState #: 1
    TICKING_AFTER_PRE: CacheTrackRecorderState #: 2
    STARTED: CacheTrackRecorderState #: 3
    STOPPED: CacheTrackRecorderState #: 4
    CANCELLED: CacheTrackRecorderState #: 5
    ...

class RigVMBlueprintLoadLogSeverity(EnumBase):
    r"""
    ERig VMBlueprint Load Log Severity
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMEditor
    - **File**: RigVMEditorBlueprintLibrary.h
    
    """

    DISPLAY: RigVMBlueprintLoadLogSeverity #: 0
    WARNING: RigVMBlueprintLoadLogSeverity #: 1
    ERROR: RigVMBlueprintLoadLogSeverity #: 2
    ...

class CastToControlRigBlueprintCases(EnumBase):
    r"""
    ECast to Control Rig Blueprint Cases
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigBlueprintEditorLibrary.h
    
    """

    CAST_SUCCEEDED: CastToControlRigBlueprintCases #: 0
    CAST_FAILED: CastToControlRigBlueprintCases #: 1
    ...

class AnimToolBlendOperation(EnumBase):
    r"""
    EAnim Tool Blend Operation
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigSequencerEditorLibrary.h
    
    """

    TWEEN: AnimToolBlendOperation #: 0
    BLEND_TO_NEIGHBOR: AnimToolBlendOperation #: 1
    PUSH_PULL: AnimToolBlendOperation #: 2
    BLEND_RELATIVE: AnimToolBlendOperation #: 3
    BLEND_TO_EASE: AnimToolBlendOperation #: 4
    SMOOTH_ROUGH: AnimToolBlendOperation #: 5
    ...

class AutoMapChainType(EnumBase):
    r"""
    EAuto Map Chain Type
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: IKRetargeterController.h
    
    """

    EXACT: AutoMapChainType #: 0
    FUZZY: AutoMapChainType #: 1: map chains that have exactly the same name (case insensitive)
    CLEAR: AutoMapChainType #: 2: map chains to the chain with the closest name (levenshtein distance)
    ...

class RetargetAutoAlignMethod(EnumBase):
    r"""
    A Note on Determining the "Direction" of a Bone...
    
    What are we using to determine the "direction" of the source and target bones to align?
    If chain only has one bone OR this bone is located at the end of a chain, then we cannot compute a tangent!
    So we fallback to an analysis of the geometry... this is necessary because we cannot rely solely on the shape of the skeleton.
    Any assumptions we make could be invalidated in different circumstances. For example,
    1. we cannot assume the local axes are aligned in any meaningful way, and even if they are we cannot assume WHICH axis is the correct one
    2. we cannot assume that any child bones are located in a position that would create a meaningful vector (ie twist bones in arbitrary locations)
    3. we cannot assume that extrapolating the direction from the parent is meaningful. For example, feet are usually perpendicular to the knee.
    
    Since the skeleton cannot be relied upon to provide robust directional information for individual and/or leaf bones, we must instead fallback
    on looking at the mesh that is skinned to it and try to discern a direction vector from that. If there is no skinning data, then we simply
    do NOT auto-align that bone.
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: IKRetargeterPoseGenerator.h
    
    """

    CHAIN_TO_CHAIN: RetargetAutoAlignMethod #: 0: use the chain to determine the source and target directions to align
    MESH_TO_MESH: RetargetAutoAlignMethod #: 1: use mesh direction as source, and mesh direction as the target to align
    ...

class ControlOutputFormat(EnumBase):
    r"""
    Custom Enum for RigControlElement creation format
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class AnimDataModelModifiedDynamicEvent(MulticastDelegateBase):
    r"""
    Anim Data Model Modified Dynamic Event  Delegate Signature
    
    Args:
        notif_type (AnimDataModelNotifyType): 
        model (AnimationDataModel): 
        payload (AnimDataModelNotifPayload):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class BreakEventSignature(MulticastDelegateBase):
    r"""
    Break Event Signature  Delegate Signature
    
    Args:
        break_events (Array[ChaosBreakEvent]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChaosEventRelay.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class CharacterMovementUpdatedSignature(MulticastDelegateBase):
    r"""
    Character Movement Updated Signature  Delegate Signature
    
    Args:
        delta_seconds (float): 
        old_location (Vector): 
        old_velocity (Vector):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Character.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class CharacterReachedApexSignature(MulticastDelegateBase):
    r"""
    Character Reached Apex Signature  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Character.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class CollisionEventSignature(MulticastDelegateBase):
    r"""
    Collision Event Signature  Delegate Signature
    
    Args:
        collision_events (Array[CollisionChaosEvent]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChaosEventRelay.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ConstraintBrokenSignature(MulticastDelegateBase):
    r"""
    Dynamic delegate to use by components that want to route the broken-event into blueprints
    
    Args:
        constraint_index (int32):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class CrumblingEventSignature(MulticastDelegateBase):
    r"""
    Crumbling Event Signature  Delegate Signature
    
    Args:
        crumbling_events (Array[ChaosCrumblingEvent]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChaosEventRelay.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EmptyOnlineDelegate(MulticastDelegateBase):
    r"""
    Empty Online Delegate  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: OnlineBlueprintCallProxyBase.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class HardwareInputDeviceChanged(MulticastDelegateBase):
    r"""
    Delegate called when a user changed the hardware they are using for input.
    
    Args:
        user_id (PlatformUserId): The Platform user whose device has changed
        device_id (InputDeviceId):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InputActionHandlerDynamicSignature(DelegateBase):
    r"""
    Input Action Handler Dynamic Signature  Delegate Signature
    
    Args:
        key (Key):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InputAxisHandlerDynamicSignature(DelegateBase):
    r"""
    Input Axis Handler Dynamic Signature  Delegate Signature
    
    Args:
        axis_value (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InputGestureHandlerDynamicSignature(DelegateBase):
    r"""
    Input Gesture Handler Dynamic Signature  Delegate Signature
    
    Args:
        value (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InputTouchHandlerDynamicSignature(DelegateBase):
    r"""
    Input Touch Handler Dynamic Signature  Delegate Signature
    
    Args:
        finger_index (TouchIndex): 
        location (Vector):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InputVectorAxisHandlerDynamicSignature(DelegateBase):
    r"""
    Input Vector Axis Handler Dynamic Signature  Delegate Signature
    
    Args:
        axis_value (Vector):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InstigatedAnyDamageSignature(MulticastDelegateBase):
    r"""
    Instigated Any Damage Signature  Delegate Signature
    
    Args:
        damage (float): 
        damage_type (DamageType): 
        damaged_actor (Actor): 
        damage_causer (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Controller.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class LandedSignature(MulticastDelegateBase):
    r"""
    Landed Signature  Delegate Signature
    
    Args:
        hit (HitResult):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Character.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class LevelStreamingLoadedStatus(MulticastDelegateBase):
    r"""
    Delegate signatures
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelStreaming.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class LevelStreamingVisibilityStatus(MulticastDelegateBase):
    r"""
    Level Streaming Visibility Status  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelStreaming.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class MovementModeChangedSignature(MulticastDelegateBase):
    r"""
    Movement Mode Changed Signature  Delegate Signature
    
    Args:
        character (Character): 
        prev_movement_mode (MovementMode): 
        previous_custom_mode (uint8):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Character.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnActorReady(DelegateBase):
    r"""
    On Actor Ready  Delegate Signature
    
    Args:
        handle (ActorInstanceHandle): 
    
    Returns:
        ActorInstanceHandle:
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightWeightInstanceStaticMeshManager.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAllMontageInstancesEndedMCDelegate(MulticastDelegateBase):
    r"""
    Delegate for when all montage instances have ended.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimInstance.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAnimInitialized(MulticastDelegateBase):
    r"""
    On Anim Initialized  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAsyncHandleSaveGame(MulticastDelegateBase):
    r"""
    On Async Handle Save Game  Delegate Signature
    
    Args:
        save_game (SaveGame): 
        success (bool):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionHandleSaveGame.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioFadeChangeSignature(MulticastDelegateBase):
    r"""
    On Audio Fade Change Signature  Delegate Signature
    
    Args:
        fade_out (bool): 
        fade_time (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerCameraManager.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioFinished(MulticastDelegateBase):
    r"""
    called when we finish playing audio, either because it played to completion or because a Stop() call turned it off early
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioMultiEnvelopeValue(MulticastDelegateBase):
    r"""
    Called while a sound plays and returns the sound's average and max envelope value (using an envelope follower in the audio renderer per wave instance).
    This only works in the audio mixer.
    
    Args:
        average_envelope_value (float): 
        max_envelope (float): 
        num_wave_instances (int32):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioPlaybackPercent(MulticastDelegateBase):
    r"""
    Called as a sound plays on the audio component to allow BP to perform actions based on playback percentage.
    Computed as samples played divided by total samples, taking into account pitch.
    Not currently implemented on all platforms.
    
    Args:
        playing_sound_wave (SoundWave): 
        playback_percent (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioPlayStateChanged(MulticastDelegateBase):
    r"""
    Called when sound's PlayState changes.
    
    Args:
        play_state (AudioComponentPlayState):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioSingleEnvelopeValue(MulticastDelegateBase):
    r"""
    Called while a sound plays and returns the sound's envelope value (using an envelope follower in the audio renderer).
    This only works in the audio mixer.
    
    Args:
        playing_sound_wave (SoundWave): 
        envelope_value (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioVirtualizationChanged(MulticastDelegateBase):
    r"""
    Called when sound becomes virtualized or realized (resumes playback from virtualization).
    
    Args:
        is_virtualized (bool):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnBoneTransformsFinalized(MulticastDelegateBase):
    r"""
    On Bone Transforms Finalized  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnCanvasRenderTargetUpdate(MulticastDelegateBase):
    r"""
    This delegate is assignable through Blueprint and has similar functionality to the above.
    
    Args:
        canvas (Canvas): 
        width (int32): 
        height (int32):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CanvasRenderTarget2D.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnClusterUnionAddedComponent(MulticastDelegateBase):
    r"""
    On Cluster Union Added Component  Delegate Signature
    
    Args:
        component (PrimitiveComponent): 
        bone_ids (Set[int32]): 
        is_new (bool):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ClusterUnionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnClusterUnionBoundsChanged(MulticastDelegateBase):
    r"""
    On Cluster Union Bounds Changed  Delegate Signature
    
    Args:
        component (ClusterUnionComponent): 
        bounds (BoxSphereBounds):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ClusterUnionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnClusterUnionRemovedComponent(MulticastDelegateBase):
    r"""
    On Cluster Union Removed Component  Delegate Signature
    
    Args:
        component (PrimitiveComponent):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ClusterUnionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnDataLayerInstanceRuntimeStateChanged(MulticastDelegateBase):
    r"""
    On Data Layer Instance Runtime State Changed  Delegate Signature
    
    Args:
        data_layer (DataLayerInstance): 
        state (DataLayerRuntimeState):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayerManager.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnDataLayerRuntimeStateChanged(MulticastDelegateBase):
    r"""
    On Data Layer Runtime State Changed  Delegate Signature
    
    Args:
        data_layer (DataLayerInstance): 
        state (DataLayerRuntimeState):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayerSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnForceFeedbackFinished(MulticastDelegateBase):
    r"""
    called when we finish playing forcefeedback effect, either because it played to completion or because a Stop() call turned it off early
    
    Args:
        force_feedback_component (ForceFeedbackComponent):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ForceFeedbackComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnGameUserSettingsUINeedsUpdate(MulticastDelegateBase):
    r"""
    On Game User Settings UINeeds Update  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameUserSettings.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLocalPlayerSaveGameLoaded(DelegateBase):
    r"""
    On Local Player Save Game Loaded  Delegate Signature
    
    Args:
        save_game (LocalPlayerSaveGame):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SaveGame.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMontageBlendedInEndedMCDelegate(MulticastDelegateBase):
    r"""
    Delegate for when Montage finished blending in
    
    Args:
        montage (AnimMontage):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimInstance.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMontageBlendingOutStartedMCDelegate(MulticastDelegateBase):
    r"""
    Delegate for when Montage started to blend out, whether interrupted or finished
    DesiredWeight of this montage becomes 0.f, but this still contributes to the output pose
    
    bInterrupted = true if it was not property finished
    
    Args:
        montage (AnimMontage): 
        interrupted (bool):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimInstance.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMontageEndedMCDelegate(MulticastDelegateBase):
    r"""
    Delegate for when Montage is completed, whether interrupted or finished
    Weight of this montage is 0.f, so it stops contributing to output pose
    
    bInterrupted = true if it was not property finished
    
    Args:
        montage (AnimMontage): 
        interrupted (bool):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimInstance.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMontageStartedMCDelegate(MulticastDelegateBase):
    r"""
    Delegate for when Montage is started
    
    Args:
        montage (AnimMontage):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimInstance.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnPawnControllerChanged(MulticastDelegateBase):
    r"""
    On Pawn Controller Changed  Delegate Signature
    
    Args:
        pawn (Pawn): 
        controller (Controller):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameInstance.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnPlayerStatePawnSet(MulticastDelegateBase):
    r"""
    On Player State Pawn Set  Delegate Signature
    
    Args:
        player (PlayerState): 
        new_pawn (Pawn): 
        old_pawn (Pawn):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerState.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnPossessedPawnChanged(MulticastDelegateBase):
    r"""
    On Possessed Pawn Changed  Delegate Signature
    
    Args:
        old_pawn (Pawn): 
        new_pawn (Pawn):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Controller.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnPrimaryAssetBundlesChanged(MulticastDelegateBase):
    r"""
    On Primary Asset Bundles Changed  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionLoadPrimaryAsset.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnPrimaryAssetClassListLoaded(MulticastDelegateBase):
    r"""
    On Primary Asset Class List Loaded  Delegate Signature
    
    Args:
        loaded (Array[type(Class)]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionLoadPrimaryAsset.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnPrimaryAssetClassLoaded(MulticastDelegateBase):
    r"""
    On Primary Asset Class Loaded  Delegate Signature
    
    Args:
        loaded (type(Class)):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionLoadPrimaryAsset.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnPrimaryAssetListLoaded(MulticastDelegateBase):
    r"""
    On Primary Asset List Loaded  Delegate Signature
    
    Args:
        loaded (Array[Object]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionLoadPrimaryAsset.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnPrimaryAssetLoaded(MulticastDelegateBase):
    r"""
    On Primary Asset Loaded  Delegate Signature
    
    Args:
        loaded (Object):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionLoadPrimaryAsset.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnQuartzCommandEvent(MulticastDelegateBase):
    r"""
    On Quartz Command Event  Delegate Signature
    
    Args:
        event_type (QuartzCommandDelegateSubType): 
        name (Name):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnQuartzCommandEventBP(DelegateBase):
    r"""
    On Quartz Command Event BP  Delegate Signature
    
    Args:
        event_type (QuartzCommandDelegateSubType): 
        name (Name):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnQuartzMetronomeEvent(MulticastDelegateBase):
    r"""
    Delegate Declarations
    
    Args:
        clock_name (Name): 
        quantization_type (QuartzCommandQuantization): 
        num_bars (int32): 
        beat (int32): 
        beat_fraction (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnQuartzMetronomeEventBP(DelegateBase):
    r"""
    On Quartz Metronome Event BP  Delegate Signature
    
    Args:
        clock_name (Name): 
        quantization_type (QuartzCommandQuantization): 
        num_bars (int32): 
        beat (int32): 
        beat_fraction (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnQueueSubtitles(DelegateBase):
    r"""
    Called when subtitles are sent to the SubtitleManager.  Set this delegate if you want to hijack the subtitles for other purposes
    
    Args:
        subtitles (Array[SubtitleCue]): 
        cue_duration (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnSubmixEnvelope(MulticastDelegateBase):
    r"""
    Called when a new submix envelope value is generated on the given audio device id (different for multiple PIE). Array is an envelope value for each channel.
    
    Args:
        envelope (Array[float]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnSubmixEnvelopeBP(DelegateBase):
    r"""
    On Submix Envelope BP  Delegate Signature
    
    Args:
        envelope (Array[float]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmixSend.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnSubmixRecordedFileDone(MulticastDelegateBase):
    r"""
    Called when a recorded file has finished writing to disk.
    
    Args:
        resulting_sound_wave (SoundWave):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnSubmixSpectralAnalysis(MulticastDelegateBase):
    r"""
    On Submix Spectral Analysis  Delegate Signature
    
    Args:
        magnitudes (Array[float]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnSubmixSpectralAnalysisBP(DelegateBase):
    r"""
    On Submix Spectral Analysis BP  Delegate Signature
    
    Args:
        magnitude (Array[float]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmixSend.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnSystemFinished(MulticastDelegateBase):
    r"""
    Called when the particle system is done
    
    Args:
        p_system (ParticleSystemComponent):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystemComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTimelineEvent(DelegateBase):
    r"""
    Signature of function to handle a timeline 'event'
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimelineComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTimelineFloat(DelegateBase):
    r"""
    Signature of function to handle timeline float track
    
    Args:
        output (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimelineComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTimelineLinearColor(DelegateBase):
    r"""
    Signature of function to handle linear color track
    
    Args:
        output (LinearColor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimelineComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTimelineVector(DelegateBase):
    r"""
    Signature of function to handle timeline vector track
    
    Args:
        output (Vector):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimelineComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnUserClickedBanner(DelegateBase):
    r"""
    Delegate called when user clicks on an banner ad. Base class already handles pausing,
    so a delegate is only needed if you need extra handling. If you set it to a PC or other actor
    function, make sure to set it back when switching levels.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InGameAdManager.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnUserClosedAdvertisement(DelegateBase):
    r"""
    Delegate called when user closes an ad (after clicking on banner). Base class already handles
    pausing, so a delegate is only needed if you need extra handling.  If you set it to a PC or other actor
    function, make sure to set it back when switching levels.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InGameAdManager.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnUserInputDeviceConnectionChange(MulticastDelegateBase):
    r"""
    On User Input Device Connection Change  Delegate Signature
    
    Args:
        new_connection_state (InputDeviceConnectionState): 
        platform_user_id (PlatformUserId): 
        input_device_id (InputDeviceId):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameInstance.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnUserInputDevicePairingChange(MulticastDelegateBase):
    r"""
    On User Input Device Pairing Change  Delegate Signature
    
    Args:
        input_device_id (InputDeviceId): 
        new_user_platform_id (PlatformUserId): 
        old_user_platform_id (PlatformUserId):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameInstance.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ParticleBurstSignature(MulticastDelegateBase):
    r"""
    Fires when a particle system bursts
    
    Args:
        event_name (Name): Custom event name for the Burst Event
        emitter_time (float): The emitter time when the event occured.
        particle_count (int32): The number of particles spawned in the burst.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Emitter.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ParticleCollisionSignature(MulticastDelegateBase):
    r"""
    Fires when a particle dies
    
    Args:
        event_name (Name): Custom event name for the Collision Event.
        emitter_time (float): The emitter time when the event occured.
        particle_time (int32): How long the particle had been alive at the time of the event.
        location (Vector): Location of the collision.
        velocity (Vector): Velocity of the particle at the point of collision.
        direction (Vector): Direction of the particle at the point of collision.
        normal (Vector): Normal to the surface with which collision occurred.
        bone_name (Name): 
        phys_mat (PhysicalMaterial): Physical Material for this collision.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Emitter.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ParticleDeathSignature(MulticastDelegateBase):
    r"""
    Fires when a particle dies
    
    Args:
        event_name (Name): Custom event name for the Death Event.
        emitter_time (float): The emitter time when the event occured.
        particle_time (int32): How long the particle had been alive at the time of the event.
        location (Vector): Location the particle was at when it died.
        velocity (Vector): Velocity of the particle when it died.
        direction (Vector): Direction of the particle when it died.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Emitter.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ParticleSpawnSignature(MulticastDelegateBase):
    r"""
    Fires when a particle is spawned
    
    Args:
        event_name (Name): Custom event name for the Spawn Event.
        emitter_time (float): The emitter time when the event occured.
        location (Vector): Location at which the particle was spawned.
        velocity (Vector): Initial velocity of the spawned particle.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Emitter.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlasticDeformationEventSignature(MulticastDelegateBase):
    r"""
    Dynamic delegate to use by components that want to route the pasticity deformation event into blueprints
    
    Args:
        constraint_index (int32):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlatformInterfaceDelegate(DelegateBase):
    r"""
    Generic platform interface delegate signature
    
    Args:
        result (PlatformInterfaceDelegateResult):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlatformInterfaceBase.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlayMontageAnimNotifyDelegate(MulticastDelegateBase):
    r"""
    Delegate called by 'PlayMontageNotify' and 'PlayMontageNotifyWindow' *
    
    Args:
        notify_name (Name): 
        branching_point_payload (BranchingPointNotifyPayload):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimInstance.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PostEvaluateAnimEvent(DelegateBase):
    r"""
    Post Evaluate Anim Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimSingleNodeInstance.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class RemovalEventSignature(MulticastDelegateBase):
    r"""
    Removal Event Signature  Delegate Signature
    
    Args:
        removal_events (Array[ChaosRemovalEvent]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChaosEventRelay.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TimerDynamicDelegate(DelegateBase):
    r"""
    Timer Dynamic Delegate  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimerHandle.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ViewportDisplayCallback(DelegateBase):
    r"""
    Viewport Display Callback  Delegate Signature
    
    Returns:
        tuple or None: 
    
        out_text (Text): 
    
        out_color (LinearColor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ViewportStatsSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ApplicationLifecycleComponent_ApplicationLifetimeDelegate(MulticastDelegateBase):
    r"""
    Application Lifetime Delegate  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ApplicationLifecycleComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ApplicationLifecycleComponent_ApplicationStartupArgumentsDelegate(MulticastDelegateBase):
    r"""
    Application Startup Arguments Delegate  Delegate Signature
    
    Args:
        startup_arguments (Array[str]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ApplicationLifecycleComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ApplicationLifecycleComponent_OnLowPowerModeDelegate(MulticastDelegateBase):
    r"""
    On Low Power Mode Delegate  Delegate Signature
    
    Args:
        low_power_mode (bool):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ApplicationLifecycleComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ApplicationLifecycleComponent_OnTemperatureChangeDelegate(MulticastDelegateBase):
    r"""
    On Temperature Change Delegate  Delegate Signature
    
    Args:
        severity (TemperatureSeverityType):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ApplicationLifecycleComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class DataDrivenCVarEngineSubsystem_OnDataDrivenCVarChanged(MulticastDelegateBase):
    r"""
    On Data Driven CVar Changed  Delegate Signature
    
    Args:
        c_var_name (str):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataDrivenCVars.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InterpToMovementComponent_OnInterpToResetDelegate(MulticastDelegateBase):
    r"""
    On Interp to Reset Delegate  Delegate Signature
    
    Args:
        impact_result (HitResult): 
        time (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InterpToMovementComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InterpToMovementComponent_OnInterpToReverseDelegate(MulticastDelegateBase):
    r"""
    On Interp to Reverse Delegate  Delegate Signature
    
    Args:
        impact_result (HitResult): 
        time (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InterpToMovementComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InterpToMovementComponent_OnInterpToStopDelegate(MulticastDelegateBase):
    r"""
    On Interp to Stop Delegate  Delegate Signature
    
    Args:
        impact_result (HitResult): 
        time (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InterpToMovementComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InterpToMovementComponent_OnInterpToWaitBeginDelegate(MulticastDelegateBase):
    r"""
    On Interp to Wait Begin Delegate  Delegate Signature
    
    Args:
        impact_result (HitResult): 
        time (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InterpToMovementComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InterpToMovementComponent_OnInterpToWaitEndDelegate(MulticastDelegateBase):
    r"""
    On Interp to Wait End Delegate  Delegate Signature
    
    Args:
        impact_result (HitResult): 
        time (float):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InterpToMovementComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class SystemLibrary_OnAssetLoaded(DelegateBase):
    r"""
    On Asset Loaded  Delegate Signature
    
    Args:
        loaded (Object):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetSystemLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class SystemLibrary_OnAssetClassLoaded(DelegateBase):
    r"""
    On Asset Class Loaded  Delegate Signature
    
    Args:
        loaded (type(Class)):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetSystemLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlatformEventsComponent_PlatformEventDelegate(MulticastDelegateBase):
    r"""
    Platform Event Delegate  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlatformEventsComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlatformGameInstance_PlatformDelegate(MulticastDelegateBase):
    r"""
    Platform Delegate  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlatformGameInstance_PlatformFailedToRegisterForRemoteNotificationsDelegate(MulticastDelegateBase):
    r"""
    Platform Failed to Register for Remote Notifications Delegate  Delegate Signature
    
    Args:
        in_string (str):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlatformGameInstance_PlatformReceivedLocalNotificationDelegate(MulticastDelegateBase):
    r"""
    Platform Received Local Notification Delegate  Delegate Signature
    
    Args:
        in_string (str): 
        in_int (int32): 
        in_app_state (ApplicationState):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlatformGameInstance_PlatformReceivedRemoteNotificationDelegate(MulticastDelegateBase):
    r"""
    Platform Received Remote Notification Delegate  Delegate Signature
    
    Args:
        in_string (str): 
        in_app_state (ApplicationState):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlatformGameInstance_PlatformRegisteredForRemoteNotificationsDelegate(MulticastDelegateBase):
    r"""
    Platform Registered for Remote Notifications Delegate  Delegate Signature
    
    Args:
        in_array (Array[uint8]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlatformGameInstance_PlatformRegisteredForUserNotificationsDelegate(MulticastDelegateBase):
    r"""
    Platform Registered for User Notifications Delegate  Delegate Signature
    
    Args:
        in_int (int32):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlatformGameInstance_PlatformScreenOrientationChangedDelegate(MulticastDelegateBase):
    r"""
    Platform Screen Orientation Changed Delegate  Delegate Signature
    
    Args:
        in_screen_orientation (ScreenOrientation):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PlatformGameInstance_PlatformStartupArgumentsDelegate(MulticastDelegateBase):
    r"""
    Platform Startup Arguments Delegate  Delegate Signature
    
    Args:
        startup_arguments (Array[str]):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ProjectileMovementComponent_OnProjectileBounceDelegate(MulticastDelegateBase):
    r"""
    On Projectile Bounce Delegate  Delegate Signature
    
    Args:
        impact_result (HitResult): 
        impact_velocity (Vector):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ProjectileMovementComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ProjectileMovementComponent_OnProjectileStopDelegate(MulticastDelegateBase):
    r"""
    On Projectile Stop Delegate  Delegate Signature
    
    Args:
        impact_result (HitResult):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ProjectileMovementComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TypedElementSelectionSet_OnChangeDynamic(MulticastDelegateBase):
    r"""
    On Change Dynamic  Delegate Signature
    
    Args:
        selection_set (TypedElementSelectionSet):
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementSelectionSet.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TypedElementSelectionSet_OnPreChangeDynamic(MulticastDelegateBase):
    r"""
    On Pre Change Dynamic  Delegate Signature
    
    Args:
        selection_set (TypedElementSelectionSet):
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementSelectionSet.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ToolMenuDynamicCanExecuteAction(DelegateBase):
    r"""
    Tool Menu Dynamic Can Execute Action  Delegate Signature
    
    Args:
        context (ToolMenuContext): 
    
    Returns:
        bool:
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuDelegates.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ToolMenuDynamicExecuteAction(DelegateBase):
    r"""
    Tool Menu Dynamic Execute Action  Delegate Signature
    
    Args:
        context (ToolMenuContext):
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuDelegates.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ToolMenuDynamicGetActionCheckState(DelegateBase):
    r"""
    Tool Menu Dynamic Get Action Check State  Delegate Signature
    
    Args:
        context (ToolMenuContext): 
    
    Returns:
        CheckBoxState:
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuDelegates.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ToolMenuDynamicIsActionButtonVisible(DelegateBase):
    r"""
    Tool Menu Dynamic Is Action Button Visible  Delegate Signature
    
    Args:
        context (ToolMenuContext): 
    
    Returns:
        bool:
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuDelegates.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ToolMenuDynamicIsActionChecked(DelegateBase):
    r"""
    Tool Menu Dynamic Is Action Checked  Delegate Signature
    
    Args:
        context (ToolMenuContext): 
    
    Returns:
        bool:
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuDelegates.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLevelEditorEditorCameraMoved(MulticastDelegateBase):
    r"""
    Delegate type for editor camera movement
    
    Args:
        location (Vector): 
        rotation (Rotator): 
        viewport_type (LevelViewportType): 
        view_index (int32):
    
    **C++ Source:**
    
    - **Module**: LevelEditor
    - **File**: LevelEditorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EditorAssetSubsystem_OnExtractAssetFromFileDynamic(DelegateBase):
    r"""
    Dynamic version of FOnExtractAssetFromFile.
    
    Args:
        files (Array[str]): 
    
    Returns:
        Array[AssetData]: 
    
        asset_data_array (Array[AssetData]):
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorAssetSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ImportSubsystem_OnAssetPostImport_Dyn(MulticastDelegateBase):
    r"""
    delegate type fired when new assets have been (re-)imported. Note: InCreatedObject can be NULL if import failed. Params: UFactory* InFactory, UObject* InCreatedObject
    
    Args:
        factory (Factory): 
        created_object (Object):
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ImportSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ImportSubsystem_OnAssetPostLODImport_Dyn(MulticastDelegateBase):
    r"""
    delegate type fired when new LOD have been imported to an asset.
    
    Args:
        object (Object): 
        lod_index (int32):
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ImportSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ImportSubsystem_OnAssetPreImport_Dyn(MulticastDelegateBase):
    r"""
    delegate type fired when new assets are being (re-)imported. Params: UFactory* InFactory, UClass* InClass, UObject* InParent, const FName& Name, const TCHAR* Type
    
    Args:
        factory (Factory): 
        class_ (type(Class)): 
        parent (Object): 
        name (Name): 
        type (str):
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ImportSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ImportSubsystem_OnAssetReimport_Dyn(MulticastDelegateBase):
    r"""
    delegate type fired when new assets have been reimported. Note: InCreatedObject can be NULL if import failed. Params: UObject* InCreatedObject
    
    Args:
        created_object (Object):
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ImportSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnDeleteActorsBegin(MulticastDelegateBase):
    r"""
    delegate type for before delete actors is handled
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnDeleteActorsEnd(MulticastDelegateBase):
    r"""
    delegate type for after delete actors is handled
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnDuplicateActorsBegin(MulticastDelegateBase):
    r"""
    delegate type for before edit duplicate actors is handled
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnDuplicateActorsEnd(MulticastDelegateBase):
    r"""
    delegate type for after edit duplicate actors is handled
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnEditCopyActorsBegin(MulticastDelegateBase):
    r"""
    delegate type for before edit copy actors is handled
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnEditCopyActorsEnd(MulticastDelegateBase):
    r"""
    delegate type for after edit copy actors is handled
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnEditCutActorsBegin(MulticastDelegateBase):
    r"""
    delegate type for before edit cut actors is handled
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnEditCutActorsEnd(MulticastDelegateBase):
    r"""
    delegate type for after edit cut actors is handled
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnEditNewActorsDropped(MulticastDelegateBase):
    r"""
    delegate type for triggering when new actors are dropped on to the viewport via drag and drop
    
    Args:
        dropped_objects (Array[Object]): 
        dropped_actors (Array[Actor]):
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnEditNewActorsPlaced(MulticastDelegateBase):
    r"""
    delegate type for triggering when new actors are placed on to the viewport. Triggers before NewActorsDropped if placement is caused by a drop action
    
    Args:
        obj_to_use (Object): 
        placed_actors (Array[Actor]):
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnEditPasteActorsBegin(MulticastDelegateBase):
    r"""
    delegate type for before edit paste actors is handled
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnEditPasteActorsEnd(MulticastDelegateBase):
    r"""
    delegate type for after edit paste actors is handled
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLevelEditorMapChanged(MulticastDelegateBase):
    r"""
    Delegate type for map change events ( Params: uint32 MapChangeFlags (MapChangeEventFlags) )
    
    Args:
        map_change_event_flags (int32):
    
    **C++ Source:**
    
    - **Module**: LevelEditor
    - **File**: LevelEditorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLevelEditorMapOpened(MulticastDelegateBase):
    r"""
    Delegate type for triggering when a map is opened
    
    Args:
        filename (str): 
        as_template (bool):
    
    **C++ Source:**
    
    - **Module**: LevelEditor
    - **File**: LevelEditorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLevelEditorPostSaveWorld(MulticastDelegateBase):
    r"""
    Delegate type for post save world events ( uint32 SaveFlags, UWorld* World, bool bSuccess )
    
    Args:
        save_flags (int32): 
        world (World): 
        success (bool):
    
    **C++ Source:**
    
    - **Module**: LevelEditor
    - **File**: LevelEditorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLevelEditorPreSaveWorld(MulticastDelegateBase):
    r"""
    Delegate type for pre save world events ( uint32 SaveFlags, UWorld* World )
    
    Args:
        save_flags (int32): 
        world (World):
    
    **C++ Source:**
    
    - **Module**: LevelEditor
    - **File**: LevelEditorSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class GameplayTaskSpawnActorDelegate(MulticastDelegateBase):
    r"""
    Gameplay Task Spawn Actor Delegate  Delegate Signature
    
    Args:
        spawned_actor (Actor):
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTask_SpawnActor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnClaimedResourcesChangeSignature(MulticastDelegateBase):
    r"""
    On Claimed Resources Change Signature  Delegate Signature
    
    Args:
        newly_claimed (GameplayResourceSet): 
        freshly_released (GameplayResourceSet):
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTasksComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class GameplayTask_GenericGameplayTaskDelegate(MulticastDelegateBase):
    r"""
    Generic Gameplay Task Delegate  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTask.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class GameplayTask_TimeLimitedExecution_TaskFinishDelegate(MulticastDelegateBase):
    r"""
    Task Finish Delegate  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTask_TimeLimitedExecution.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class GameplayTask_WaitDelay_TaskDelayDelegate(MulticastDelegateBase):
    r"""
    Task Delay Delegate  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTask_WaitDelay.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorPerceptionForgetUpdatedDelegate(MulticastDelegateBase):
    r"""
    Actor Perception Forget Updated Delegate  Delegate Signature
    
    Args:
        actor (Actor):
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorPerceptionInfoUpdatedDelegate(MulticastDelegateBase):
    r"""
    Actor Perception Info Updated Delegate  Delegate Signature
    
    Args:
        update_info (ActorPerceptionUpdateInfo):
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorPerceptionUpdatedDelegate(MulticastDelegateBase):
    r"""
    Actor Perception Updated Delegate  Delegate Signature
    
    Args:
        actor (Actor): 
        stimulus (AIStimulus):
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class AIMoveCompletedSignature(MulticastDelegateBase):
    r"""
    AIMove Completed Signature  Delegate Signature
    
    Args:
        request_id (AIRequestID): 
        result (PathFollowingResult):
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIController.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class MoveTaskCompletedSignature(MulticastDelegateBase):
    r"""
    Move Task Completed Signature  Delegate Signature
    
    Args:
        result (PathFollowingResult): 
        ai_controller (AIController):
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AITask_MoveTo.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OAISimpleDelegate(MulticastDelegateBase):
    r"""
    OAISimple Delegate  Delegate Signature
    
    Args:
        movement_result (PathFollowingResult):
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIAsyncTaskBlueprintProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PerceptionUpdatedDelegate(MulticastDelegateBase):
    r"""
    Perception Updated Delegate  Delegate Signature
    
    Args:
        updated_actors (Array[Actor]):
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class SmartLinkReachedSignature(MulticastDelegateBase):
    r"""
    Smart Link Reached Signature  Delegate Signature
    
    Args:
        moving_actor (Actor): 
        destination_point (Vector):
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: NavLinkProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EnvQueryInstanceBlueprintWrapper_EQSQueryDoneSignature(MulticastDelegateBase):
    r"""
    EQSQuery Done Signature  Delegate Signature
    
    Args:
        query_instance (EnvQueryInstanceBlueprintWrapper): 
        query_status (EnvQueryStatus):
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryInstanceBlueprintWrapper.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PawnSensingComponent_HearNoiseDelegate(MulticastDelegateBase):
    r"""
    Hear Noise Delegate  Delegate Signature
    
    Args:
        instigator (Pawn): 
        location (Vector): 
        volume (float):
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PawnSensingComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PawnSensingComponent_SeePawnDelegate(MulticastDelegateBase):
    r"""
    See Pawn Delegate  Delegate Signature
    
    Args:
        pawn (Pawn):
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PawnSensingComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnChaosPhysicsCollision(MulticastDelegateBase):
    r"""
    On Chaos Physics Collision  Delegate Signature
    
    Args:
        collision_info (ChaosPhysicsCollisionInfo):
    
    **C++ Source:**
    
    - **Module**: ChaosSolverEngine
    - **File**: ChaosNotifyHandlerInterface.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnChaosBreakEvent(MulticastDelegateBase):
    r"""
    On Chaos Break Event  Delegate Signature
    
    Args:
        break_event (ChaosBreakEvent):
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnChaosBreakingEvents(MulticastDelegateBase):
    r"""
    Called when new destruction events are available for breaks. Breaking listening must be enabled to get callbacks on this delegate.
    
    Args:
        breaking_events (Array[ChaosBreakingEventData]):
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosBlueprint.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnChaosCollisionEvents(MulticastDelegateBase):
    r"""
    Called when new destruction events are available for collisions. Collision listening must be enabled to get callbacks on this delegate.
    
    Args:
        collision_events (Array[ChaosCollisionEventData]):
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosBlueprint.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnChaosCrumblingEvent(MulticastDelegateBase):
    r"""
    On Chaos Crumbling Event  Delegate Signature
    
    Args:
        crumble_event (ChaosCrumblingEvent):
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnChaosRemovalEvent(MulticastDelegateBase):
    r"""
    On Chaos Removal Event  Delegate Signature
    
    Args:
        removal_event (ChaosRemovalEvent):
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnChaosRemovalEvents(MulticastDelegateBase):
    r"""
    Called when new destruction events are available for removals. Removal listening must be enabled to get callbacks on this delegate.
    
    Args:
        removal_events (Array[ChaosRemovalEventData]):
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosBlueprint.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnChaosTrailingEvents(MulticastDelegateBase):
    r"""
    Called when new trailing events are available for breaks. Trailing listening must be enabled to get callbacks on this delegate.
    
    Args:
        trailing_events (Array[ChaosTrailingEventData]):
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosBlueprint.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnGeometryCollectionFullyDecayedEvent(MulticastDelegateBase):
    r"""
    On Geometry Collection Fully Decayed Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnGeometryCollectionRootMovedEvent(MulticastDelegateBase):
    r"""
    On Geometry Collection Root Moved Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class GeometryCollectionComponent_NotifyGeometryCollectionPhysicsLoadingStateChange(MulticastDelegateBase):
    r"""
    Notify Geometry Collection Physics Loading State Change  Delegate Signature
    
    Args:
        fractured_component (GeometryCollectionComponent):
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class GeometryCollectionComponent_NotifyGeometryCollectionPhysicsStateChange(MulticastDelegateBase):
    r"""
    Blueprint event
    
    Args:
        fractured_component (GeometryCollectionComponent):
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnNavDataGenericEvent(MulticastDelegateBase):
    r"""
    Delegate to let interested parties know that Nav Data has been registered
    
    Args:
        nav_data (NavigationData):
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationSystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnNavigationPathUpdated(MulticastDelegateBase):
    r"""
    On Navigation Path Updated  Delegate Signature
    
    Args:
        affected_path (NavigationPath): 
        path_event (NavPathEvent):
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationPath.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GenerateWidgetForObject(DelegateBase):
    r"""
    Generate Widget for Object  Delegate Signature
    
    Args:
        item (Object): 
    
    Returns:
        Widget:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GenerateWidgetForString(DelegateBase):
    r"""
    Events
    
    Args:
        item (str): 
    
    Returns:
        Widget:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GetBool(DelegateBase):
    r"""
    Common Bindings - If you add any new common binding, you must provide a UPropertyBinding for it.
                      all primitive binding in UMG goes through native binding evaluators to prevent
                      thunking through the VM.
    
    Returns:
        bool:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GetCheckBoxState(DelegateBase):
    r"""
    Get Check Box State  Delegate Signature
    
    Returns:
        CheckBoxState:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GetFloat(DelegateBase):
    r"""
    Get Float  Delegate Signature
    
    Returns:
        float:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GetInt32(DelegateBase):
    r"""
    Get Int 32  Delegate Signature
    
    Returns:
        int32:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GetLinearColor(DelegateBase):
    r"""
    Get Linear Color  Delegate Signature
    
    Returns:
        LinearColor:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GetMouseCursor(DelegateBase):
    r"""
    Get Mouse Cursor  Delegate Signature
    
    Returns:
        MouseCursor:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GetSlateBrush(DelegateBase):
    r"""
    Get Slate Brush  Delegate Signature
    
    Returns:
        SlateBrush:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GetSlateColor(DelegateBase):
    r"""
    Get Slate Color  Delegate Signature
    
    Returns:
        SlateColor:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GetSlateVisibility(DelegateBase):
    r"""
    Get Slate Visibility  Delegate Signature
    
    Returns:
        SlateVisibility:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GetText(DelegateBase):
    r"""
    Get Text  Delegate Signature
    
    Returns:
        Text:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_GetWidget(DelegateBase):
    r"""
    Get Widget  Delegate Signature
    
    Returns:
        Widget:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class FieldValueChangedDynamicDelegate(DelegateBase):
    r"""
    Field Value Changed Dynamic Delegate  Delegate Signature
    
    Args:
        object (Object): 
        field (FieldNotificationId):
    
    **C++ Source:**
    
    - **Module**: FieldNotification
    - **File**: INotifyFieldValueChanged.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_OnPointerEvent(DelegateBase):
    r"""
    On Pointer Event  Delegate Signature
    
    Args:
        my_geometry (Geometry): 
        mouse_event (PointerEvent): 
    
    Returns:
        EventReply:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class Widget_OnReply(DelegateBase):
    r"""
    Events
    
    Returns:
        EventReply:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class CustomWidgetNavigationDelegate(DelegateBase):
    r"""
    Custom Widget Navigation Delegate  Delegate Signature
    
    Args:
        navigation (UINavigation): 
    
    Returns:
        Widget:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetNavigation.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComboBoxKey_GenerateWidgetEvent(DelegateBase):
    r"""
    Generate Widget Event  Delegate Signature
    
    Args:
        item (Name): 
    
    Returns:
        Widget:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ComboBoxKey.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComboBoxKey_OnOpeningEvent(MulticastDelegateBase):
    r"""
    On Opening Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ComboBoxKey.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComboBoxKey_OnSelectionChangedEvent(MulticastDelegateBase):
    r"""
    On Selection Changed Event  Delegate Signature
    
    Args:
        selected_item (Name): 
        selection_type (SelectInfo):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ComboBoxKey.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComboBoxString_OnOpeningEvent(MulticastDelegateBase):
    r"""
    On Opening Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ComboBoxString.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComboBoxString_OnSelectionChangedEvent(MulticastDelegateBase):
    r"""
    On Selection Changed Event  Delegate Signature
    
    Args:
        selected_item (str): 
        selection_type (SelectInfo):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ComboBoxString.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EditableText_OnEditableTextChangedEvent(MulticastDelegateBase):
    r"""
    On Editable Text Changed Event  Delegate Signature
    
    Args:
        text (Text):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: EditableText.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EditableText_OnEditableTextCommittedEvent(MulticastDelegateBase):
    r"""
    On Editable Text Committed Event  Delegate Signature
    
    Args:
        text (Text): 
        commit_method (TextCommit):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: EditableText.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EditableTextBox_OnEditableTextBoxChangedEvent(MulticastDelegateBase):
    r"""
    On Editable Text Box Changed Event  Delegate Signature
    
    Args:
        text (Text):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: EditableTextBox.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EditableTextBox_OnEditableTextBoxCommittedEvent(MulticastDelegateBase):
    r"""
    On Editable Text Box Committed Event  Delegate Signature
    
    Args:
        text (Text): 
        commit_method (TextCommit):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: EditableTextBox.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InputKeySelector_OnIsSelectingKeyChanged(MulticastDelegateBase):
    r"""
    On Is Selecting Key Changed  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: InputKeySelector.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InputKeySelector_OnKeySelected(MulticastDelegateBase):
    r"""
    On Key Selected  Delegate Signature
    
    Args:
        selected_key (InputChord):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: InputKeySelector.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class MenuAnchor_GetUserWidget(DelegateBase):
    r"""
    Get User Widget  Delegate Signature
    
    Returns:
        UserWidget:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MenuAnchor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMenuOpenChangedEvent(MulticastDelegateBase):
    r"""
    On Menu Open Changed Event  Delegate Signature
    
    Args:
        is_open (bool):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MenuAnchor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class DownloadImageDelegate(MulticastDelegateBase):
    r"""
    Download Image Delegate  Delegate Signature
    
    Args:
        texture (Texture2DDynamic):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: AsyncTaskDownloadImage.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnButtonClickedEvent(MulticastDelegateBase):
    r"""
    On Button Clicked Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Button.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnButtonHoverEvent(MulticastDelegateBase):
    r"""
    On Button Hover Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Button.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnButtonPressedEvent(MulticastDelegateBase):
    r"""
    On Button Pressed Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Button.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnButtonReleasedEvent(MulticastDelegateBase):
    r"""
    On Button Released Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Button.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnCheckBoxComponentStateChanged(MulticastDelegateBase):
    r"""
    On Check Box Component State Changed  Delegate Signature
    
    Args:
        is_checked (bool):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: CheckBox.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnConstructEvent(MulticastDelegateBase):
    r"""
    On Construct Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UserWidget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnControllerCaptureBeginEvent(MulticastDelegateBase):
    r"""
    On Controller Capture Begin Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Slider.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnControllerCaptureEndEvent(MulticastDelegateBase):
    r"""
    On Controller Capture End Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Slider.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnDragDropMulticast(MulticastDelegateBase):
    r"""
    On Drag Drop Multicast  Delegate Signature
    
    Args:
        operation (DragDropOperation):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: DragDropOperation.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnExpandableAreaExpansionChanged(MulticastDelegateBase):
    r"""
    On Expandable Area Expansion Changed  Delegate Signature
    
    Args:
        area (ExpandableArea): 
        is_expanded (bool):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ExpandableArea.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnFloatValueChangedEvent(MulticastDelegateBase):
    r"""
    On Float Value Changed Event  Delegate Signature
    
    Args:
        value (float):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Slider.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnGetItemChildrenDynamic(DelegateBase):
    r"""
    On Get Item Children Dynamic  Delegate Signature
    
    Args:
        item (Object): 
    
    Returns:
        Array[Object]: 
    
        children (Array[Object]):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: TreeView.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnHoveredWidgetChanged(MulticastDelegateBase):
    r"""
    TODO Come up with a better way to let people forward a lot of keyboard input without a bunch of glue
    
    Args:
        widget_component (WidgetComponent): 
        previous_widget_component (WidgetComponent):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetInteractionComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnInputAction(DelegateBase):
    r"""
    On Input Action  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UserWidget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnItemExpansionChangedDynamic(MulticastDelegateBase):
    r"""
    On Item Expansion Changed Dynamic  Delegate Signature
    
    Args:
        item (Object): 
        is_expanded (bool):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: TreeView.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnItemIsHoveredChangedDynamic(MulticastDelegateBase):
    r"""
    On Item Is Hovered Changed Dynamic  Delegate Signature
    
    Args:
        item (Object): 
        is_hovered (bool):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ListView.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnListEntryGeneratedDynamic(MulticastDelegateBase):
    r"""
    On List Entry Generated Dynamic  Delegate Signature
    
    Args:
        widget (UserWidget):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ListViewBase.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnListEntryInitializedDynamic(MulticastDelegateBase):
    r"""
    On List Entry Initialized Dynamic  Delegate Signature
    
    Args:
        item (Object): 
        widget (UserWidget):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ListView.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnListEntryReleasedDynamic(MulticastDelegateBase):
    r"""
    On List Entry Released Dynamic  Delegate Signature
    
    Args:
        widget (UserWidget):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ListViewBase.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnListItemScrolledIntoViewDynamic(MulticastDelegateBase):
    r"""
    On List Item Scrolled Into View Dynamic  Delegate Signature
    
    Args:
        item (Object): 
        widget (UserWidget):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ListView.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnListItemSelectionChangedDynamic(MulticastDelegateBase):
    r"""
    On List Item Selection Changed Dynamic  Delegate Signature
    
    Args:
        item (Object): 
        is_selected (bool):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ListView.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnListViewScrolledDynamic(MulticastDelegateBase):
    r"""
    On List View Scrolled Dynamic  Delegate Signature
    
    Args:
        item_offset (float): 
        distance_remaining (float):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ListView.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMouseCaptureBeginEvent(MulticastDelegateBase):
    r"""
    On Mouse Capture Begin Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Slider.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMouseCaptureEndEvent(MulticastDelegateBase):
    r"""
    On Mouse Capture End Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Slider.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnScrollBarVisibilityChangedEvent(MulticastDelegateBase):
    r"""
    On Scroll Bar Visibility Changed Event  Delegate Signature
    
    Args:
        new_visibility (SlateVisibility):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ScrollBox.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnUserScrolledEvent(MulticastDelegateBase):
    r"""
    On User Scrolled Event  Delegate Signature
    
    Args:
        current_offset (float):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ScrollBox.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnVisibilityChangedEvent(MulticastDelegateBase):
    r"""
    On Visibility Changed Event  Delegate Signature
    
    Args:
        visibility (SlateVisibility):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UserWidget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnWidgetAnimationPlaybackStatusChanged(MulticastDelegateBase):
    r"""
    On Widget Animation Playback Status Changed  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetAnimationEvents.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class SimpleListItemEventDynamic(MulticastDelegateBase):
    r"""
    Simple List Item Event Dynamic  Delegate Signature
    
    Args:
        item (Object):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ListView.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class WidgetAnimationDynamicEvent(DelegateBase):
    r"""
    Widget Animation Dynamic Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetAnimationEvents.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class WidgetAnimationDynamicEvents(MulticastDelegateBase):
    r"""
    Widget Animation Dynamic Events  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetAnimationEvents.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class WidgetAnimationResult(MulticastDelegateBase):
    r"""
    Widget Animation Result  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetAnimationPlayCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class MultiLineEditableText_OnMultiLineEditableTextChangedEvent(MulticastDelegateBase):
    r"""
    On Multi Line Editable Text Changed Event  Delegate Signature
    
    Args:
        text (Text):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MultiLineEditableText.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class MultiLineEditableText_OnMultiLineEditableTextCommittedEvent(MulticastDelegateBase):
    r"""
    On Multi Line Editable Text Committed Event  Delegate Signature
    
    Args:
        text (Text): 
        commit_method (TextCommit):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MultiLineEditableText.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class MultiLineEditableTextBox_OnMultiLineEditableTextBoxChangedEvent(MulticastDelegateBase):
    r"""
    On Multi Line Editable Text Box Changed Event  Delegate Signature
    
    Args:
        text (Text):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MultiLineEditableTextBox.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class MultiLineEditableTextBox_OnMultiLineEditableTextBoxCommittedEvent(MulticastDelegateBase):
    r"""
    On Multi Line Editable Text Box Committed Event  Delegate Signature
    
    Args:
        text (Text): 
        commit_method (TextCommit):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MultiLineEditableTextBox.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class SlateAccessibleWidgetData_GetText(DelegateBase):
    r"""
    Get Text  Delegate Signature
    
    Returns:
        Text:
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SlateWrapperTypes.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class SpinBox_OnSpinBoxBeginSliderMovement(MulticastDelegateBase):
    r"""
    On Spin Box Begin Slider Movement  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SpinBox.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class SpinBox_OnSpinBoxValueChangedEvent(MulticastDelegateBase):
    r"""
    On Spin Box Value Changed Event  Delegate Signature
    
    Args:
        value (float):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SpinBox.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class SpinBox_OnSpinBoxValueCommittedEvent(MulticastDelegateBase):
    r"""
    On Spin Box Value Committed Event  Delegate Signature
    
    Args:
        value (float): 
        commit_method (TextCommit):
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SpinBox.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class WidgetLibrary_OnGameWindowCloseButtonClickedDelegate(DelegateBase):
    r"""
    On Game Window Close Button Clicked Delegate  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnImportDoneDynamic(DelegateBase):
    r"""
    On Import Done Dynamic  Delegate Signature
    
    Args:
        objects (Array[Object]):
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangeManager.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnObjectImportDoneDynamic(DelegateBase):
    r"""
    Some utility delegates for automating Interchange.
    
    Args:
        object (Object):
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangeManager.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class AdvancedCopyCompletedEvent(DelegateBase):
    r"""
    Advanced Copy Completed Event  Delegate Signature
    
    Args:
        success (bool): 
        all_copied_assets (Array[AssetRenameData]):
    
    **C++ Source:**
    
    - **Module**: AssetTools
    - **File**: IAssetTools.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnNotifyReplaced(DelegateBase):
    r"""
    Delegate called when a notify was replaced
    
    Args:
        old_notify (AnimNotify): 
        new_notify (AnimNotify):
    
    **C++ Source:**
    
    - **Module**: AnimationBlueprintLibrary
    - **File**: AnimationBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnNotifyStateReplaced(DelegateBase):
    r"""
    Delegate called when a notify state was replaced
    
    Args:
        old_notify_state (AnimNotifyState): 
        new_notify_state (AnimNotifyState):
    
    **C++ Source:**
    
    - **Module**: AnimationBlueprintLibrary
    - **File**: AnimationBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMontagePlayDelegate(MulticastDelegateBase):
    r"""
    On Montage Play Delegate  Delegate Signature
    
    Args:
        notify_name (Name):
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: PlayMontageCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class MovieSceneActorPredictionFailure(MulticastDelegateBase):
    r"""
    Movie Scene Actor Prediction Failure  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScenePredictionSystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class MovieSceneActorPredictionResult(MulticastDelegateBase):
    r"""
    namespace UE
    
    Args:
        predicted_transform (Transform):
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScenePredictionSystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMovieSceneSequencePlayerEvent(MulticastDelegateBase):
    r"""
    On Movie Scene Sequence Player Event  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSequencePlayer.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioDefaultDeviceChanged(MulticastDelegateBase):
    r"""
    On Audio Default Device Changed  Delegate Signature
    
    Args:
        audio_device_role (AudioDeviceChangedRole): 
        device_id (str):
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioDeviceNotificationSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioDeviceChange(MulticastDelegateBase):
    r"""
    On Audio Device Change  Delegate Signature
    
    Args:
        device_id (str):
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioDeviceNotificationSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioDeviceStateChanged(MulticastDelegateBase):
    r"""
    On Audio Device State Changed  Delegate Signature
    
    Args:
        device_id (str): 
        new_state (AudioDeviceChangedState):
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioDeviceNotificationSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioOutputDevicesObtained(DelegateBase):
    r"""
    Called when a list of all available audio devices is retrieved
    
    Args:
        available_devices (Array[AudioOutputDeviceInfo]):
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnCompletedDeviceSwap(DelegateBase):
    r"""
    Called when the system has swapped to another audio output device
    
    Args:
        swap_result (SwapAudioOutputResult):
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMainAudioOutputDeviceObtained(DelegateBase):
    r"""
    Called when a list of all available audio devices is retrieved
    
    Args:
        current_device (str):
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnSoundLoadComplete(DelegateBase):
    r"""
    Called when a load request for a sound has completed.
    
    Args:
        loaded_sound_wave (SoundWave): 
        was_cancelled (bool):
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnSynthEnvelopeValue(MulticastDelegateBase):
    r"""
    Called by a synth component and returns the sound's envelope value (using an envelope follower in the audio renderer).
    This only works in the audio mixer.
    
    Args:
        envelope_value (float):
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: SynthComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMediaPlayerMediaEvent(MulticastDelegateBase):
    r"""
    Multicast delegate that is invoked when a media event occurred in the player.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaPlayer.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMediaPlayerMediaOpened(MulticastDelegateBase):
    r"""
    Multicast delegate that is invoked when a media player's media has been opened.
    
    Args:
        opened_url (str):
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaPlayer.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMediaPlayerMediaOpenFailed(MulticastDelegateBase):
    r"""
    Multicast delegate that is invoked when a media player's media has failed to open.
    
    Args:
        failed_url (str):
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaPlayer.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InstancePointDamageSignature(MulticastDelegateBase):
    r"""
    Instance Point Damage Signature  Delegate Signature
    
    Args:
        instance_index (int32): 
        damage (float): 
        instigated_by (Controller): 
        hit_location (Vector): 
        shot_from_direction (Vector): 
        damage_type (DamageType): 
        damage_causer (Actor):
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: FoliageInstancedStaticMeshComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InstanceRadialDamageSignature(MulticastDelegateBase):
    r"""
    Instance Radial Damage Signature  Delegate Signature
    
    Args:
        instances (Array[int32]): 
        damages (Array[float]): 
        instigated_by (Controller): 
        origin (Vector): 
        max_radius (float): 
        damage_type (DamageType): 
        damage_causer (Actor):
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: FoliageInstancedStaticMeshComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnImageWriteComplete(DelegateBase):
    r"""
    On Image Write Complete  Delegate Signature
    
    Args:
        success (bool):
    
    **C++ Source:**
    
    - **Module**: ImageWriteQueue
    - **File**: ImageWriteBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class AchievementWriteDelegate(MulticastDelegateBase):
    r"""
    Achievement Write Delegate  Delegate Signature
    
    Args:
        written_achievement_name (Name): 
        written_progress (float): 
        written_user_tag (int32):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: AchievementWriteCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class BlueprintFindSessionsResultDelegate(MulticastDelegateBase):
    r"""
    Blueprint Find Sessions Result Delegate  Delegate Signature
    
    Args:
        results (Array[BlueprintSessionResult]):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: FindSessionsCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InAppPurchaseQuery2Result(MulticastDelegateBase):
    r"""
    In App Purchase Query 2Result  Delegate Signature
    
    Args:
        app_offer_information (Array[OnlineProxyStoreOffer]):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseQueryCallbackProxy2.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InAppPurchaseRestoreResult2(MulticastDelegateBase):
    r"""
    In App Purchase Restore Result 2  Delegate Signature
    
    Args:
        purchase_status (InAppPurchaseStatus): 
        app_purchase_restore_info (Array[InAppPurchaseRestoreInfo2]):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseRestoreCallbackProxy2.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InAppPurchaseResult2(MulticastDelegateBase):
    r"""
    In App Purchase Result 2  Delegate Signature
    
    Args:
        purchase_status (InAppPurchaseStatus): 
        app_purchase_receipts (Array[InAppPurchaseReceiptInfo2]):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseCallbackProxy2.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class LeaderboardQueryResult(MulticastDelegateBase):
    r"""
    Leaderboard Query Result  Delegate Signature
    
    Args:
        leaderboard_value (int32):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: LeaderboardQueryCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLeaderboardFlushed(MulticastDelegateBase):
    r"""
    On Leaderboard Flushed  Delegate Signature
    
    Args:
        session_name (Name):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: LeaderboardFlushCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnlineConnectionResult(MulticastDelegateBase):
    r"""
    Online Connection Result  Delegate Signature
    
    Args:
        error_code (int32):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: ConnectionCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnlineLogoutResult(MulticastDelegateBase):
    r"""
    Online Logout Result  Delegate Signature
    
    Args:
        player_controller (PlayerController):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: LogoutCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnlineProxyInAppCheckoutResult(MulticastDelegateBase):
    r"""
    Online Proxy in App Checkout Result  Delegate Signature
    
    Args:
        purchase_status (InAppPurchaseStatus): 
        app_purchase_receipt (InAppPurchaseReceiptInfo2):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseCheckoutCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnlineProxyInAppReceiptsResult(MulticastDelegateBase):
    r"""
    Online Proxy in App Receipts Result  Delegate Signature
    
    Args:
        purchase_status (InAppPurchaseStatus): 
        app_purchase_receipts (Array[InAppPurchaseReceiptInfo2]):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseReceiptsCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnlineShowLoginUIResult(MulticastDelegateBase):
    r"""
    Online Show Login UIResult  Delegate Signature
    
    Args:
        player_controller (PlayerController):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: ShowLoginUICallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnlineTurnBasedMatchResult(MulticastDelegateBase):
    r"""
    Online Turn Based Match Result  Delegate Signature
    
    Args:
        match_id (str):
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: FindTurnBasedMatchCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnNiagaraScriptCompilationComplete(MulticastDelegateBase):
    r"""
    On Niagara Script Compilation Complete  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraShader
    - **File**: NiagaraShared.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class SequencerOutlinerSelectionChanged(MulticastDelegateBase):
    r"""
    Sequencer Outliner Selection Changed  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: SequencerCore
    - **File**: OutlinerScriptingObject.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class SourceControl_QueryFileStateDelegate(DelegateBase):
    r"""
    Delegate to broadcast FileState upon AsyncQueryFileState completion
    
    Args:
        file_state_out (SourceControlState):
    
    **C++ Source:**
    
    - **Module**: SourceControl
    - **File**: SourceControlHelpers.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class LevelSequenceActor_OnLevelSequenceLoaded(DelegateBase):
    r"""
    On Level Sequence Loaded  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequenceActor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLevelSequencePlayerCameraCutEvent(MulticastDelegateBase):
    r"""
    On Level Sequence Player Camera Cut Event  Delegate Signature
    
    Args:
        camera_component (CameraComponent):
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequencePlayer.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class MockDataMeshTrackerComponent_OnMockDataMeshTrackerUpdated(MulticastDelegateBase):
    r"""
    Delegate used by OnMeshUpdated().
    
    Args:
        index (int32): The index of the mesh section in the ProceduralMeshComponent that was updated.
        vertices (Array[Vector]): List of all vertices in the updated mesh section.
        triangles (Array[int32]): List of all triangles in the updated mesh section.
        normals (Array[Vector]): List of the normals of all triangles in the updated mesh section.
        confidence (Array[float]): List of the confidence values per vertex in the updated mesh section. This can be used to determine if the user needs to scan more.
    
    **C++ Source:**
    
    - **Module**: MRMesh
    - **File**: MockDataMeshTrackerComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class GetHighlightTextDelegate(DelegateBase):
    r"""
    Get Highlight Text Delegate  Delegate Signature
    
    Returns:
        Text:
    
    **C++ Source:**
    
    - **Module**: UMGEditor
    - **File**: AssetThumbnailWidget.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnPropertyValueChanged(MulticastDelegateBase):
    r"""
    Sets a delegate called when the property value changes
    
    Args:
        property_name (Name):
    
    **C++ Source:**
    
    - **Module**: ScriptableEditorWidgets
    - **File**: PropertyViewBase.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class FunctionalTestAISpawned(MulticastDelegateBase):
    r"""
    Functional Test AISpawned  Delegate Signature
    
    Args:
        controller (AIController): 
        pawn (Pawn):
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalAITest.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class FunctionalTestEventSignature(MulticastDelegateBase):
    r"""
    Functional Test Event Signature  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalTest.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EnhancedInputActionHandlerDynamicSignature(DelegateBase):
    r"""
    Provides full access to value and timers
    
    Args:
        action_value (InputActionValue): 
        elapsed_time (float): 
        triggered_time (float): 
        source_action (InputAction):
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class InputDebugKeyHandlerDynamicSignature(DelegateBase):
    r"""
    Input Debug Key Handler Dynamic Signature  Delegate Signature
    
    Args:
        key (Key): 
        action_value (InputActionValue):
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EnhancedInputLocalPlayerSubsystem_OnControlMappingsRebuilt(MulticastDelegateBase):
    r"""
    A delegate that will be called when control mappings have been rebuilt this frame.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputSubsystems.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EnhancedInputUserSettings_EnhancedInputUserSettingsApplied(MulticastDelegateBase):
    r"""
    Called after the settings have been applied from the ApplySettings call.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EnhancedInputUserSettings_EnhancedInputUserSettingsChanged(MulticastDelegateBase):
    r"""
    Fired when the user settings have changed, such as their key mappings.
    
    Args:
        settings (EnhancedInputUserSettings):
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EnhancedInputUserSettings_MappableKeyProfileChanged(MulticastDelegateBase):
    r"""
    Fired when you equip a different key profile
    
    Args:
        new_profile (EnhancedPlayerMappableKeyProfile):
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class EnhancedInputUserSettings_MappingContextRegisteredWithSettings(MulticastDelegateBase):
    r"""
    Fired when a new input mapping context is registered. Useful if you need to update your UI
    
    Args:
        imc (InputMappingContext):
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTakeRecorderCancelled(DelegateBase):
    r"""
    On Take Recorder Cancelled  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTakeRecorderFinished(DelegateBase):
    r"""
    On Take Recorder Finished  Delegate Signature
    
    Args:
        sequence_asset (LevelSequence):
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTakeRecorderMarkedFrameAdded(DelegateBase):
    r"""
    On Take Recorder Marked Frame Added  Delegate Signature
    
    Args:
        marked_frame (MovieSceneMarkedFrame):
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTakeRecorderPanelChanged(DelegateBase):
    r"""
    On Take Recorder Panel Changed  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTakeRecorderPreInitialize(DelegateBase):
    r"""
    On Take Recorder Pre Initialize  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTakeRecorderStarted(DelegateBase):
    r"""
    On Take Recorder Started  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTakeRecorderStopped(DelegateBase):
    r"""
    On Take Recorder Stopped  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TakeRecorderCancelled(MulticastDelegateBase):
    r"""
    Take Recorder Cancelled  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TakeRecorderFinished(MulticastDelegateBase):
    r"""
    Take Recorder Finished  Delegate Signature
    
    Args:
        sequence_asset (LevelSequence):
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TakeRecorderMarkedFrameAdded(MulticastDelegateBase):
    r"""
    Take Recorder Marked Frame Added  Delegate Signature
    
    Args:
        marked_frame (MovieSceneMarkedFrame):
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TakeRecorderPreInitialize(MulticastDelegateBase):
    r"""
    Take Recorder Pre Initialize  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TakeRecorderStarted(MulticastDelegateBase):
    r"""
    Take Recorder Started  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TakeRecorderStopped(MulticastDelegateBase):
    r"""
    Take Recorder Stopped  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TakesCoreBlueprintLibrary_OnTakeRecorderSlateChanged(DelegateBase):
    r"""
    On Take Recorder Slate Changed  Delegate Signature
    
    Args:
        slate (str):
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakesCoreBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TakesCoreBlueprintLibrary_OnTakeRecorderTakeNumberChanged(DelegateBase):
    r"""
    On Take Recorder Take Number Changed  Delegate Signature
    
    Args:
        take_number (int32):
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakesCoreBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class RigVMPeformUserWorkflowDynamicDelegate(DelegateBase):
    r"""
    Rig VMPeform User Workflow Dynamic Delegate  Delegate Signature
    
    Args:
        options (RigVMUserWorkflowOptions): 
        controller (Object): 
    
    Returns:
        bool:
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMUserWorkflow.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class RigVMGraphModifiedDynamicEvent(MulticastDelegateBase):
    r"""
    A dynamic delegate for subscribing / reacting to graph modifications (used for Python integration).
    
    Args:
        notif_type (RigVMGraphNotifType): 
        graph (RigVMGraph): 
        subject (Object):
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMNotifications.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class RigVMUserWorkflowProvider(DelegateBase):
    r"""
    Rig VMUser Workflow Provider  Delegate Signature
    
    Args:
        subject (Object): 
    
    Returns:
        Array[RigVMUserWorkflow]:
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMUserWorkflowRegistry.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ControlRigComponentDelegate(MulticastDelegateBase):
    r"""
    Bindable event for external objects to hook into ControlRig-level execution
    
    Args:
        component (ControlRigComponent):
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class RigHierarchyModifiedDynamicEvent(MulticastDelegateBase):
    r"""
    Rig Hierarchy Modified Dynamic Event  Delegate Signature
    
    Args:
        notif_type (RigHierarchyNotification): 
        hierarchy (RigHierarchy): 
        subject (RigElementKey):
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PyTestDelegate(DelegateBase):
    r"""
    Delegate to allow testing of the various script delegate features that are exposed to Python wrapped types.
    
    Args:
        value (int32): 
    
    Returns:
        int32:
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PyTestMulticastDelegate(MulticastDelegateBase):
    r"""
    Multicast delegate to allow testing of the various script delegate features that are exposed to Python wrapped types.
    
    Args:
        str (str):
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PyTestSlateTickDelegate(DelegateBase):
    r"""
    Delegate for slate pre/post tick event.
    
    Args:
        delta_time (float):
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PyTestStructDelegate_OnNameCollisionDelegate(MulticastDelegateBase):
    r"""
    On Name Collision Delegate  Delegate Signature
    
    Args:
        py_struct (PyTestStruct):
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PyTestVectorDelegate_OnNameCollisionDelegate(MulticastDelegateBase):
    r"""
    On Name Collision Delegate  Delegate Signature
    
    Args:
        vec (Vector2D):
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorComponentDeactivateSignature(MulticastDelegateBase):
    r"""
    Actor Component Deactivate Signature  Delegate Signature
    
    Args:
        component (ActorComponent):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ActorComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorComponentActivatedSignature(MulticastDelegateBase):
    r"""
    Actor Component Activated Signature  Delegate Signature
    
    Args:
        component (ActorComponent): 
        reset (bool):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ActorComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorBeginCursorOverSignature(MulticastDelegateBase):
    r"""
    Actor Begin Cursor Over Signature  Delegate Signature
    
    Args:
        touched_actor (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorBeginOverlapSignature(MulticastDelegateBase):
    r"""
    Actor Begin Overlap Signature  Delegate Signature
    
    Args:
        overlapped_actor (Actor): 
        other_actor (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorBeginTouchOverSignature(MulticastDelegateBase):
    r"""
    Actor Begin Touch Over Signature  Delegate Signature
    
    Args:
        finger_index (TouchIndex): 
        touched_actor (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorDestroyedSignature(MulticastDelegateBase):
    r"""
    Actor Destroyed Signature  Delegate Signature
    
    Args:
        destroyed_actor (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorEndCursorOverSignature(MulticastDelegateBase):
    r"""
    Actor End Cursor Over Signature  Delegate Signature
    
    Args:
        touched_actor (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorEndOverlapSignature(MulticastDelegateBase):
    r"""
    Actor End Overlap Signature  Delegate Signature
    
    Args:
        overlapped_actor (Actor): 
        other_actor (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorEndPlaySignature(MulticastDelegateBase):
    r"""
    Actor End Play Signature  Delegate Signature
    
    Args:
        actor (Actor): 
        end_play_reason (EndPlayReason):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorEndTouchOverSignature(MulticastDelegateBase):
    r"""
    Actor End Touch Over Signature  Delegate Signature
    
    Args:
        finger_index (TouchIndex): 
        touched_actor (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorHitSignature(MulticastDelegateBase):
    r"""
    Actor Hit Signature  Delegate Signature
    
    Args:
        self_actor (Actor): 
        other_actor (Actor): 
        normal_impulse (Vector): 
        hit (HitResult):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorOnClickedSignature(MulticastDelegateBase):
    r"""
    Actor on Clicked Signature  Delegate Signature
    
    Args:
        touched_actor (Actor): 
        button_pressed (Key):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorOnInputTouchBeginSignature(MulticastDelegateBase):
    r"""
    Actor on Input Touch Begin Signature  Delegate Signature
    
    Args:
        finger_index (TouchIndex): 
        touched_actor (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorOnInputTouchEndSignature(MulticastDelegateBase):
    r"""
    Actor on Input Touch End Signature  Delegate Signature
    
    Args:
        finger_index (TouchIndex): 
        touched_actor (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ActorOnReleasedSignature(MulticastDelegateBase):
    r"""
    Actor on Released Signature  Delegate Signature
    
    Args:
        touched_actor (Actor): 
        button_released (Key):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentBeginCursorOverSignature(MulticastDelegateBase):
    r"""
    Component Begin Cursor Over Signature  Delegate Signature
    
    Args:
        touched_component (PrimitiveComponent):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentBeginOverlapSignature(MulticastDelegateBase):
    r"""
    Delegate for notification of start of overlap with a specific component
    
    Args:
        overlapped_component (PrimitiveComponent): 
        other_actor (Actor): 
        other_comp (PrimitiveComponent): 
        other_body_index (int32): 
        from_sweep (bool): 
        sweep_result (HitResult):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentBeginTouchOverSignature(MulticastDelegateBase):
    r"""
    Component Begin Touch Over Signature  Delegate Signature
    
    Args:
        finger_index (TouchIndex): 
        touched_component (PrimitiveComponent):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentCollisionSettingsChangedSignature(MulticastDelegateBase):
    r"""
    Delegate for notification when collision settings change.
    
    Args:
        changed_component (PrimitiveComponent):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentEndCursorOverSignature(MulticastDelegateBase):
    r"""
    Component End Cursor Over Signature  Delegate Signature
    
    Args:
        touched_component (PrimitiveComponent):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentEndOverlapSignature(MulticastDelegateBase):
    r"""
    Delegate for notification of end of overlap with a specific component
    
    Args:
        overlapped_component (PrimitiveComponent): 
        other_actor (Actor): 
        other_comp (PrimitiveComponent): 
        other_body_index (int32):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentEndTouchOverSignature(MulticastDelegateBase):
    r"""
    Component End Touch Over Signature  Delegate Signature
    
    Args:
        finger_index (TouchIndex): 
        touched_component (PrimitiveComponent):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentHitSignature(MulticastDelegateBase):
    r"""
    Delegate for notification of blocking collision against a specific component.
    NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    
    Args:
        hit_component (PrimitiveComponent): 
        other_actor (Actor): 
        other_comp (PrimitiveComponent): 
        normal_impulse (Vector): 
        hit (HitResult):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentOnClickedSignature(MulticastDelegateBase):
    r"""
    Component on Clicked Signature  Delegate Signature
    
    Args:
        touched_component (PrimitiveComponent): 
        button_pressed (Key):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentOnInputTouchBeginSignature(MulticastDelegateBase):
    r"""
    Component on Input Touch Begin Signature  Delegate Signature
    
    Args:
        finger_index (TouchIndex): 
        touched_component (PrimitiveComponent):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentOnInputTouchEndSignature(MulticastDelegateBase):
    r"""
    Component on Input Touch End Signature  Delegate Signature
    
    Args:
        finger_index (TouchIndex): 
        touched_component (PrimitiveComponent):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentOnReleasedSignature(MulticastDelegateBase):
    r"""
    Component on Released Signature  Delegate Signature
    
    Args:
        touched_component (PrimitiveComponent): 
        button_released (Key):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentPhysicsStateChanged(MulticastDelegateBase):
    r"""
    Delegate for physics state created
    
    Args:
        changed_component (PrimitiveComponent): 
        state_change (ComponentPhysicsStateChange):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentSleepSignature(MulticastDelegateBase):
    r"""
    Delegate for notification when a sleep event is fired by physics
    
    Args:
        sleeping_component (PrimitiveComponent): 
        bone_name (Name):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ComponentWakeSignature(MulticastDelegateBase):
    r"""
    Delegate for notification when a wake event is fired by physics
    
    Args:
        waking_component (PrimitiveComponent): 
        bone_name (Name):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class IsRootComponentChanged(MulticastDelegateBase):
    r"""
    Is Root Component Changed  Delegate Signature
    
    Args:
        updated_component (SceneComponent): 
        is_root_component (bool):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PawnControllerChangedSignature(MulticastDelegateBase):
    r"""
    Pawn Controller Changed Signature  Delegate Signature
    
    Args:
        pawn (Pawn): 
        old_controller (Controller): 
        new_controller (Controller):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Pawn.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PawnRestartedSignature(MulticastDelegateBase):
    r"""
    Pawn Restarted Signature  Delegate Signature
    
    Args:
        pawn (Pawn):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Pawn.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class PhysicsVolumeChanged(MulticastDelegateBase):
    r"""
    Physics Volume Changed  Delegate Signature
    
    Args:
        new_volume (PhysicsVolume):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TakeAnyDamageSignature(MulticastDelegateBase):
    r"""
    Delegate signatures
    
    Args:
        damaged_actor (Actor): 
        damage (float): 
        damage_type (DamageType): 
        instigated_by (Controller): 
        damage_causer (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TakePointDamageSignature(MulticastDelegateBase):
    r"""
    Take Point Damage Signature  Delegate Signature
    
    Args:
        damaged_actor (Actor): 
        damage (float): 
        instigated_by (Controller): 
        hit_location (Vector): 
        f_hit_component (PrimitiveComponent): 
        bone_name (Name): 
        shot_from_direction (Vector): 
        damage_type (DamageType): 
        damage_causer (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class TakeRadialDamageSignature(MulticastDelegateBase):
    r"""
    Take Radial Damage Signature  Delegate Signature
    
    Args:
        damaged_actor (Actor): 
        damage (float): 
        damage_type (DamageType): 
        origin (Vector): 
        hit_info (HitResult): 
        instigated_by (Controller): 
        damage_causer (Actor):
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ConstraintsManager_OnConstraintAdded(MulticastDelegateBase):
    r"""
    Dynamic blueprintable delegates for knowing when a constraints are added or deleted
    
    Args:
        mananger (ConstraintsManager): 
        constraint (TickableConstraint):
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: ConstraintsManager.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ConstraintsManager_OnConstraintRemoved(MulticastDelegateBase):
    r"""
    On Constraint Removed  Delegate Signature
    
    Args:
        mananger (ConstraintsManager): 
        constraint (TickableConstraint): 
        do_not_compensate (bool):
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: ConstraintsManager.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ConstraintSubsystem_OnConstraintAddedToSystem(MulticastDelegateBase):
    r"""
    Dynamic blueprintable delegates for knowing when a constraints are added or deleted
    
    Args:
        mananger (ConstraintSubsystem): 
        constraint (TickableConstraint):
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: ConstraintSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ConstraintSubsystem_OnConstraintRemovedFromSystem(MulticastDelegateBase):
    r"""
    On Constraint Removed from System  Delegate Signature
    
    Args:
        mananger (ConstraintSubsystem): 
        constraint (TickableConstraint): 
        do_not_compensate (bool):
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: ConstraintSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ControlRig_OnControlSelectedBP(MulticastDelegateBase):
    r"""
    To support Blueprints/scripting, we need a different delegate type (a 'Dynamic' delegate) which supports looser style UFunction binding (using names).
    
    Args:
        rig (ControlRig): 
        control (RigControlElement): 
        selected (bool):
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRig.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnConstantQResults(MulticastDelegateBase):
    r"""
    Delegate to receive all ConstantQ results per channel (time-stamped in an array) since last delegate call. If bDownmixToMono setting is true, results will be in channel index 0.
    
    Args:
        channel_index (int32): 
        constant_q_results (Array[ConstantQResults]):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: ConstantQ.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLatestConstantQResults(MulticastDelegateBase):
    r"""
    Delegate to receive only the most recent overall ConstantQ result per channel. If bDownmixToMono setting is true, results will be in channel index 0.
    
    Args:
        channel_index (int32): 
        latest_constant_q_results (ConstantQResults):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: ConstantQ.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLatestOverallLoudnessResults(MulticastDelegateBase):
    r"""
    Delegate to receive only the most recent overall loudness result.
    
    Args:
        latest_overall_loudness_results (LoudnessResults):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Loudness.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLatestOverallMeterResults(MulticastDelegateBase):
    r"""
    Delegate to receive only the most recent overall meter results.
    
    Args:
        latest_overall_meter_results (MeterResults):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Meter.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLatestPerChannelLoudnessResults(MulticastDelegateBase):
    r"""
    Delegate to receive only the most recent overall loudness result per channel.
    
    Args:
        channel_index (int32): 
        latest_loudness_results (LoudnessResults):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Loudness.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLatestPerChannelMeterResults(MulticastDelegateBase):
    r"""
    Delegate to receive only the most recent overall meter result per channel.
    
    Args:
        channel_index (int32): 
        latest_meter_results (MeterResults):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Meter.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnLatestSpectrumResults(MulticastDelegateBase):
    r"""
    Delegate to receive only the most recent overall spectrum result per channel. If bDownmixToMono setting is true, results will be in channel index 0.
    
    Args:
        channel_index (int32): 
        latest_spectrum_results (SynesthesiaSpectrumResults):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: SynesthesiaSpectrumAnalysis.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnOverallLoudnessResults(MulticastDelegateBase):
    r"""
    Delegate to receive all overall loudness results (time-stamped in an array) since last delegate call.
    
    Args:
        overall_loudness_results (Array[LoudnessResults]):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Loudness.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnOverallMeterResults(MulticastDelegateBase):
    r"""
    Delegate to receive all overall loudness results (time-stamped in an array) since last delegate call.
    
    Args:
        meter_results (Array[MeterResults]):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Meter.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnPerChannelLoudnessResults(MulticastDelegateBase):
    r"""
    Delegate to receive all loudness results per channel (time-stamped in an array) since last delegate call.
    
    Args:
        channel_index (int32): 
        loudness_results (Array[LoudnessResults]):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Loudness.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnPerChannelMeterResults(MulticastDelegateBase):
    r"""
    Delegate to receive all meter results per channel (time-stamped in an array) since last delegate call.
    
    Args:
        channel_index (int32): 
        meter_results (Array[MeterResults]):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Meter.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnSpectrumResults(MulticastDelegateBase):
    r"""
    Delegate to receive all spectrum results per channel (time-stamped in an array) since last delegate call. If bDownmixToMono setting is true, results will be in channel index 0.
    
    Args:
        channel_index (int32): 
        spectrum_results (Array[SynesthesiaSpectrumResults]):
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: SynesthesiaSpectrumAnalysis.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnCreateAuditionGeneratorHandleDelegate(DelegateBase):
    r"""
    namespace Metasound::Engine
    
    Args:
        generator_handle (MetasoundGeneratorHandle):
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundBuilderSubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMetasoundOutputValueChanged(DelegateBase):
    r"""
    On Metasound Output Value Changed  Delegate Signature
    
    Args:
        output_name (Name): 
        output (MetaSoundOutput):
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundGeneratorHandle.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMetasoundOutputValueChangedMulticast(MulticastDelegateBase):
    r"""
    On Metasound Output Value Changed Multicast  Delegate Signature
    
    Args:
        name (Name): 
        output (MetaSoundOutput):
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundGeneratorHandle.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioRadialSliderValueChangedEvent(MulticastDelegateBase):
    r"""
    On Audio Radial Slider Value Changed Event  Delegate Signature
    
    Args:
        value (float):
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioRadialSlider.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class AudioVectorscope_GetVectorscopeAudioSamples(DelegateBase):
    r"""
    Get Vectorscope Audio Samples  Delegate Signature
    
    Returns:
        Array[float]:
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioVectorscopeUMG.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class AudioOscilloscope_GetOscilloscopeAudioSamples(DelegateBase):
    r"""
    Get Oscilloscope Audio Samples  Delegate Signature
    
    Returns:
        Array[float]:
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioOscilloscopeUMG.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class AudioMeter_GetMeterChannelInfo(DelegateBase):
    r"""
    Get Meter Channel Info  Delegate Signature
    
    Returns:
        Array[MeterChannelInfo]:
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioMeter.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class LocationServicesData_OnLocationChanged(MulticastDelegateBase):
    r"""
    Location Services Data on Location Changed  Delegate Signature
    
    Args:
        location_data (LocationServicesData):
    
    **C++ Source:**
    
    - **Plugin**: LocationServicesBPLibrary
    - **Module**: LocationServicesBPLibrary
    - **File**: LocationServicesBPLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class NumTablesChanged(MulticastDelegateBase):
    r"""
    Num Tables Changed  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentMonoWaveTable.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnControllerCaptureBeginEventSynth2D(MulticastDelegateBase):
    r"""
    On Controller Capture Begin Event Synth 2D  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: Synth2DSlider.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnControllerCaptureEndEventSynth2D(MulticastDelegateBase):
    r"""
    On Controller Capture End Event Synth 2D  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: Synth2DSlider.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnEnvelopeFollowerUpdate(MulticastDelegateBase):
    r"""
    On Envelope Follower Update  Delegate Signature
    
    Args:
        envelope_value (float):
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectEnvelopeFollower.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnFloatValueChangedEventSynth2D(MulticastDelegateBase):
    r"""
    On Float Value Changed Event Synth 2D  Delegate Signature
    
    Args:
        value (float):
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: Synth2DSlider.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMouseCaptureBeginEventSynth2D(MulticastDelegateBase):
    r"""
    On Mouse Capture Begin Event Synth 2D  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: Synth2DSlider.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnMouseCaptureEndEventSynth2D(MulticastDelegateBase):
    r"""
    On Mouse Capture End Event Synth 2D  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: Synth2DSlider.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnSampleLoaded(MulticastDelegateBase):
    r"""
    Called when a sample has finished loading into the sample player
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentWaveTable.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnSamplePlaybackProgress(MulticastDelegateBase):
    r"""
    Called while a sample player is playing back. Indicates the playhead progress in percent and as absolute time value (within the file).
    
    Args:
        progress_percent (float): 
        progress_time_seconds (float):
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentWaveTable.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnTableAltered(MulticastDelegateBase):
    r"""
    On Table Altered  Delegate Signature
    
    Args:
        table_index (int32):
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentMonoWaveTable.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class NiagaraClipboardFunction_OnPastedFunctionCallNode(DelegateBase):
    r"""
    On Pasted Function Call Node  Delegate Signature
    
    Args:
        pasted_function_call (NiagaraNodeFunctionCall):
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraClipboard.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnNiagaraSystemFinished(MulticastDelegateBase):
    r"""
    Called when the particle system is done
    
    Args:
        p_system (NiagaraComponent):
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class AsyncNiagaraCaptureSimCache_OnCaptureComplete(MulticastDelegateBase):
    r"""
    On Capture Complete  Delegate Signature
    
    Args:
        success (bool):
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSimCacheFunctionLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class FlipbookFinishedPlaySignature(MulticastDelegateBase):
    r"""
    Event for a non-looping flipbook finishing play
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperFlipbookComponent.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAudioInputDevicesObtained(DelegateBase):
    r"""
    Called when a list of all available audio devices is retrieved
    
    Args:
        available_devices (Array[AudioInputDeviceInfo]):
    
    **C++ Source:**
    
    - **Plugin**: AudioCapture
    - **Module**: AudioCapture
    - **File**: AudioCaptureBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class AppleImageConversionDelegate(MulticastDelegateBase):
    r"""
    Apple Image Conversion Delegate  Delegate Signature
    
    Args:
        conversion_result (AppleImageUtilsImageConversionResult):
    
    **C++ Source:**
    
    - **Plugin**: AppleImageUtils
    - **Module**: AppleImageUtils
    - **File**: AppleImageUtilsBlueprintProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class AndroidPermissionDynamicDelegate(MulticastDelegateBase):
    r"""
    Android Permission Dynamic Delegate  Delegate Signature
    
    Args:
        permissions (Array[str]): 
        grant_results (Array[bool]):
    
    **C++ Source:**
    
    - **Plugin**: AndroidPermission
    - **Module**: AndroidPermission
    - **File**: AndroidPermissionCallbackProxy.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnDynamicMeshModifiedBP(MulticastDelegateBase):
    r"""
    On Dynamic Mesh Modified BP  Delegate Signature
    
    Args:
        mesh (DynamicMesh):
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: UDynamicMesh.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnContentInstallFailed(DelegateBase):
    r"""
    On Content Install Failed  Delegate Signature
    
    Args:
        error_text (Text): 
        error_code (int32):
    
    **C++ Source:**
    
    - **Plugin**: MobilePatchingUtils
    - **Module**: MobilePatchingUtils
    - **File**: MobilePatchingLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnContentInstallSucceeded(DelegateBase):
    r"""
    On Content Install Succeeded  Delegate Signature
    
    **C++ Source:**
    
    - **Plugin**: MobilePatchingUtils
    - **Module**: MobilePatchingUtils
    - **File**: MobilePatchingLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnRequestContentFailed(DelegateBase):
    r"""
    On Request Content Failed  Delegate Signature
    
    Args:
        error_text (Text): 
        error_code (int32):
    
    **C++ Source:**
    
    - **Plugin**: MobilePatchingUtils
    - **Module**: MobilePatchingUtils
    - **File**: MobilePatchingLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnRequestContentSucceeded(DelegateBase):
    r"""
    On Request Content Succeeded  Delegate Signature
    
    Args:
        mobile_pending_content (MobilePendingContent):
    
    **C++ Source:**
    
    - **Plugin**: MobilePatchingUtils
    - **Module**: MobilePatchingUtils
    - **File**: MobilePatchingLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnRenderMovieStopped(DelegateBase):
    r"""
    On Render Movie Stopped  Delegate Signature
    
    Args:
        success (bool):
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScriptingEditor
    - **File**: SequencerTools.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class AsyncDelayComplete(MulticastDelegateBase):
    r"""
    Async Delay Complete  Delegate Signature
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class AsyncEditorWaitForGameWorldEvent(MulticastDelegateBase):
    r"""
    Async Editor Wait for Game World Event  Delegate Signature
    
    Args:
        world (World):
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ForEachActorIteratorSignature(MulticastDelegateBase):
    r"""
    For Each Actor Iterator Signature  Delegate Signature
    
    Args:
        actor (Actor): 
        index (int32):
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: GlobalEditorUtilityBase.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ForEachAssetIteratorSignature(MulticastDelegateBase):
    r"""
    For Each Asset Iterator Signature  Delegate Signature
    
    Args:
        asset (Object): 
        index (int32):
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: GlobalEditorUtilityBase.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnAsyncCaptureSceneComplete(MulticastDelegateBase):
    r"""
    On Async Capture Scene Complete  Delegate Signature
    
    Args:
        texture (TextureRenderTarget2D):
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: AsyncCaptureScene.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnEditorUtilityPIEEvent(MulticastDelegateBase):
    r"""
    Delegate for a PIE event exposed via Editor Utility (begin, end, pause/resume, etc)
    
    Args:
        is_simulating (bool):
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilitySubsystem.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnEditorUtilityTaskDynamicDelegate(MulticastDelegateBase):
    r"""
    On Editor Utility Task Dynamic Delegate  Delegate Signature
    
    Args:
        task (EditorUtilityTask):
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityTask.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class OnExportImageAsyncComplete(MulticastDelegateBase):
    r"""
    On Export Image Async Complete  Delegate Signature
    
    Args:
        success (bool):
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: AsyncImageExport.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class RigVMAssetDataFilterDynamic(DelegateBase):
    r"""
    Rig VMAsset Data Filter Dynamic  Delegate Signature
    
    Args:
        asset_data (AssetData): 
    
    Returns:
        bool:
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMEditor
    - **File**: RigVMEditorBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class RigVMBlueprintFilterDynamic(DelegateBase):
    r"""
    Rig VMBlueprint Filter Dynamic  Delegate Signature
    
    Args:
        blueprint (RigVMBlueprint): 
        log_during_load (Array[RigVMBlueprintLoadLogEntry]): 
    
    Returns:
        bool:
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMEditor
    - **File**: RigVMEditorBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class RigVMNodeFilterDynamic(DelegateBase):
    r"""
    Rig VMNode Filter Dynamic  Delegate Signature
    
    Args:
        blueprint (RigVMBlueprint): 
        node (RigVMNode): 
    
    Returns:
        bool:
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMEditor
    - **File**: RigVMEditorBlueprintLibrary.h
    
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...

class ARFilter(StructBase):
    r"""
    A struct to serve as a filter for Asset Registry queries. (mirrored in ARFilter.h)
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``class_names`` (Array[Name]):  [Read-Write] [DEPRECATED] - Class names are now represented by path names. Please use ClassPaths instead.
      deprecated: Short asset class names must be converted to full asset pathnames. Use ClassPaths instead.
    - ``class_paths`` (Array[TopLevelAssetPath]):  [Read-Write] The filter component for class path names. Instances of the specified classes, but not subclasses (by default), will be included. Derived classes will be included only if bRecursiveClasses is true.
    - ``include_only_on_disk_assets`` (bool):  [Read-Write] If true, only on-disk assets will be returned. Be warned that this is rarely what you want and should only be used for performance reasons
    - ``package_names`` (Array[Name]):  [Read-Write] The filter component for package names
    - ``package_paths`` (Array[Name]):  [Read-Write] The filter component for package paths
    - ``recursive_class_paths_exclusion_set`` (Set[TopLevelAssetPath]):  [Read-Write] Only if bRecursiveClasses is true, the results will exclude classes (and subclasses) in this list
    - ``recursive_classes`` (bool):  [Read-Write] If true, subclasses of ClassNames will also be included and RecursiveClassesExclusionSet will be excluded.
    - ``recursive_classes_exclusion_set`` (Set[Name]):  [Read-Write] [DEPRECATED] - Class names are now represented by path names. Please use RecursiveClassPathsExclusionSet instead.
      deprecated: Short asset class names must be converted to full asset pathnames. Use RecursiveClassPathsExclusionSet instead.
    - ``recursive_paths`` (bool):  [Read-Write] If true, PackagePath components will be recursive
    - ``soft_object_paths`` (Array[SoftObjectPath]):  [Read-Write] The filter component containing specific object paths
    """
    def __init__(self, package_names: Array[Name] = [], package_paths: Array[Name] = [], soft_object_paths: Array[SoftObjectPath] = [], class_paths: Array[TopLevelAssetPath] = [], recursive_class_paths_exclusion_set: Set[TopLevelAssetPath] = [], class_names: Array[Name] = [], recursive_classes_exclusion_set: Set[Name] = [], recursive_paths: bool = False, recursive_classes: bool = False, include_only_on_disk_assets: bool = False) -> None:
        ...
    @property
    def package_names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] The filter component for package names
        """
        ...
    @package_names.setter
    def package_names(self, value: Array[Name]) -> None:
        ...
    @property
    def package_paths(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] The filter component for package paths
        """
        ...
    @package_paths.setter
    def package_paths(self, value: Array[Name]) -> None:
        ...
    @property
    def soft_object_paths(self) -> Array[SoftObjectPath]:
        r"""
        (Array[SoftObjectPath]):  [Read-Write] The filter component containing specific object paths
        """
        ...
    @soft_object_paths.setter
    def soft_object_paths(self, value: Array[SoftObjectPath]) -> None:
        ...
    @property
    def class_names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] [DEPRECATED] - Class names are now represented by path names. Please use ClassPaths instead.
        deprecated: Short asset class names must be converted to full asset pathnames. Use ClassPaths instead.
        """
        ...
    @class_names.setter
    def class_names(self, value: Array[Name]) -> None:
        ...
    @property
    def class_paths(self) -> Array[TopLevelAssetPath]:
        r"""
        (Array[TopLevelAssetPath]):  [Read-Write] The filter component for class path names. Instances of the specified classes, but not subclasses (by default), will be included. Derived classes will be included only if bRecursiveClasses is true.
        """
        ...
    @class_paths.setter
    def class_paths(self, value: Array[TopLevelAssetPath]) -> None:
        ...
    @property
    def recursive_classes_exclusion_set(self) -> Set[Name]:
        r"""
        (Set[Name]):  [Read-Write] [DEPRECATED] - Class names are now represented by path names. Please use RecursiveClassPathsExclusionSet instead.
        deprecated: Short asset class names must be converted to full asset pathnames. Use RecursiveClassPathsExclusionSet instead.
        """
        ...
    @recursive_classes_exclusion_set.setter
    def recursive_classes_exclusion_set(self, value: Set[Name]) -> None:
        ...
    @property
    def recursive_class_paths_exclusion_set(self) -> Set[TopLevelAssetPath]:
        r"""
        (Set[TopLevelAssetPath]):  [Read-Write] Only if bRecursiveClasses is true, the results will exclude classes (and subclasses) in this list
        """
        ...
    @recursive_class_paths_exclusion_set.setter
    def recursive_class_paths_exclusion_set(self, value: Set[TopLevelAssetPath]) -> None:
        ...
    @property
    def recursive_paths(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, PackagePath components will be recursive
        """
        ...
    @recursive_paths.setter
    def recursive_paths(self, value: bool) -> None:
        ...
    @property
    def recursive_classes(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, subclasses of ClassNames will also be included and RecursiveClassesExclusionSet will be excluded.
        """
        ...
    @recursive_classes.setter
    def recursive_classes(self, value: bool) -> None:
        ...
    @property
    def include_only_on_disk_assets(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, only on-disk assets will be returned. Be warned that this is rarely what you want and should only be used for performance reasons
        """
        ...
    @include_only_on_disk_assets.setter
    def include_only_on_disk_assets(self, value: bool) -> None:
        ...
    def get_blueprint_assets(self) -> Array[AssetData]:
        r"""
        x.get_blueprint_assets() -> Array[AssetData]
        Gets asset data for all blueprint assets that match the filter. ClassPaths in the filter specify the blueprint's parent class.
        
        Returns:
            Array[AssetData]: 
        
            out_asset_data (Array[AssetData]):
        """
        ...

class TopLevelAssetPath(StructBase):
    r"""
    A struct that can reference a top level asset such as '/Path/To/Package.AssetName'
    note: The full C++ class is located here: Engine\Source\Runtime\CoreUObject\Public\UObject\TopLevelAssetPath.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_name`` (Name):  [Read-Write] Name of the asset within the package e.g. 'AssetName'
    - ``package_name`` (Name):  [Read-Write] Name of the package containing the asset e.g. /Path/To/Package
    """
    def __init__(self, package_name: str = "", asset_name: str = "") -> None:
        ...
    @property
    def package_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of the package containing the asset e.g. /Path/To/Package
        """
        ...
    @package_name.setter
    def package_name(self, value: Name) -> None:
        ...
    @property
    def asset_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of the asset within the package e.g. 'AssetName'
        """
        ...
    @asset_name.setter
    def asset_name(self, value: Name) -> None:
        ...

class SoftObjectPath(StructBase):
    r"""
    A struct that contains a string reference to an object, either a top level asset or a subobject.
    note: The full C++ class is located here: Engine\Source\Runtime\CoreUObject\Public\UObject\SoftObjectPath.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """
    def __init__(self, path_string: str = "") -> None:
        ...

class StringAssetReference(SoftObjectPath):
    r"""
    deprecated: 'StringAssetReference' was renamed to 'SoftObjectPath'.
    """
    def __init__(self, path_string: str = "") -> None:
        ...

class AssetData(StructBase):
    r"""
    A struct to hold important information about an assets found by the Asset Registry
    This struct is transient and should never be serialized
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_class`` (Name):  [Read-Write] The name of the asset's class
      deprecated: Short asset class name must be converted to full asset pathname. Use AssetClassPath instead.
    - ``asset_class_path`` (TopLevelAssetPath):  [Read-Write] The path name of the asset's class
    - ``asset_name`` (Name):  [Read-Write] The name of the asset without the package
    - ``package_name`` (Name):  [Read-Write] The name of the package in which the asset is found, this is the full long package name such as /Game/Path/Package
    - ``package_path`` (Name):  [Read-Write] The path to the package in which the asset is found, this is /Game/Path with the Package stripped off
    """
    def __init__(self, package_name: Name = "None", package_path: Name = "None", asset_name: Name = "None", asset_class_path: TopLevelAssetPath = [""]) -> None:
        ...
    @property
    def package_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of the package in which the asset is found, this is the full long package name such as /Game/Path/Package
        """
        ...
    @property
    def package_path(self) -> Name:
        r"""
        (Name):  [Read-Only] The path to the package in which the asset is found, this is /Game/Path with the Package stripped off
        """
        ...
    @property
    def asset_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of the asset without the package
        """
        ...
    @property
    def asset_class(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of the asset's class
        deprecated: Short asset class name must be converted to full asset pathname. Use AssetClassPath instead.
        """
        ...
    @property
    def asset_class_path(self) -> TopLevelAssetPath:
        r"""
        (TopLevelAssetPath):  [Read-Only] The path name of the asset's class
        """
        ...
    def to_soft_object_path(self) -> SoftObjectPath:
        r"""
        x.to_soft_object_path() -> SoftObjectPath
        Convert to a SoftObjectPath for loading
        
        Returns:
            SoftObjectPath:
        """
        ...
    def is_valid(self) -> bool:
        r"""
        x.is_valid() -> bool
        Checks to see if this AssetData refers to an asset or is NULL
        
        Returns:
            bool:
        """
        ...
    def is_u_asset(self) -> bool:
        r"""
        x.is_u_asset() -> bool
        Returns true if this is the primary asset in a package, true for maps and assets but false for secondary objects like class redirectors
        
        Returns:
            bool:
        """
        ...
    def is_redirector(self) -> bool:
        r"""
        x.is_redirector() -> bool
        Returns true if the this asset is a redirector.
        
        Returns:
            bool:
        """
        ...
    def is_asset_loaded(self) -> bool:
        r"""
        x.is_asset_loaded() -> bool
        Returns true if the asset is loaded
        
        Returns:
            bool:
        """
        ...
    def get_tag_value(self, tag_name: Name) -> Optional[str]:
        r"""
        x.get_tag_value(tag_name) -> str or None
        Gets the value associated with the given tag as a string
        
        Args:
            tag_name (Name): 
        
        Returns:
            str or None: 
        
            out_tag_value (str):
        """
        ...
    def get_full_name(self) -> str:
        r"""
        x.get_full_name() -> str
        Returns the full name for the asset in the form: Class ObjectPath
        
        Returns:
            str:
        """
        ...
    def get_export_text_name(self) -> str:
        r"""
        x.get_export_text_name() -> str
        Returns the name for the asset in the form: Class'ObjectPath'
        
        Returns:
            str:
        """
        ...
    def get_class(self) -> Class:
        r"""
        x.get_class() -> type(Class)
        Get Class
        
        Returns:
            type(Class):
        """
        ...
    def get_asset(self) -> Object:
        r"""
        x.get_asset() -> Object
        Returns the asset UObject if it is loaded or loads the asset if it is unloaded then returns the result
        
        Returns:
            Object:
        """
        ...
    def find_asset_native_class(self) -> Class:
        r"""
        x.find_asset_native_class() -> type(Class)
        Returns the first native class of the asset type that can be found.  Normally this is just the FAssetData::GetClass(),
        however if the class is a blueprint generated class it may not be loaded.  In which case GetAncestorClassNames will
        be used to find the first native super class.  This can be slow if temporary caching mode is not on.
        
        Returns:
            type(Class):
        """
        ...

class Guid(StructBase):
    r"""
    A globally unique identifier (mirrored from Guid.h)
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``c`` (int32):  [Read-Write]
    - ``d`` (int32):  [Read-Write]
    """
    def __init__(self) -> None:
        ...
    def to_string(self) -> str:
        r"""
        x.to_string() -> str
        Converts a GUID value to a string, in the form 'A-B-C-D'
        
        Returns:
            str:
        """
        ...

class DateTime(StructBase):
    r"""
    A value representing a specific point date and time over a wide range of years.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Misc\DateTime.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """
    def __init__(self, year: int = 0, month: int = 0, day: int = 0, hour: int = 0, minute: int = 0, second: int = 0, millisecond: int = 0) -> None:
        ...

class Box(StructBase):
    r"""
    A bounding box.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Box.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_valid`` (bool):  [Read-Write]
    - ``max`` (Vector):  [Read-Write]
    - ``min`` (Vector):  [Read-Write]
    """
    def __init__(self, min: Vector = [0.000000, 0.000000, 0.000000], max: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def min(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @min.setter
    def min(self, value: Vector) -> None:
        ...
    @property
    def max(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @max.setter
    def max(self, value: Vector) -> None:
        ...
    @property
    def is_valid(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_valid.setter
    def is_valid(self, value: bool) -> None:
        ...
    def random_point_in_box_extents(self) -> Vector:
        r"""
        x.random_point_in_box_extents() -> Vector
        Returns a random point within the specified bounding box.
        
        Returns:
            Vector:
        """
        ...

class Vector(StructBase):
    r"""
    A point or direction FVector in 3d space.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Vector.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    - ``z`` (double):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000) -> None:
        ...
    @property
    def x(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: float) -> None:
        ...
    @property
    def y(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: float) -> None:
        ...
    @property
    def z(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: float) -> None:
        ...
    def length2d_squared(self) -> float:
        r"""
        x.length2d_squared() -> double
        Returns the squared length of the vector's XY components.
        
        Returns:
            double:
        """
        ...
    def length2d(self) -> float:
        r"""
        x.length2d() -> double
        Returns the length of the vector's XY components.
        
        Returns:
            double:
        """
        ...
    def length_squared(self) -> float:
        r"""
        x.length_squared() -> double
        Returns the squared length of the vector
        
        Returns:
            double:
        """
        ...
    def length(self) -> float:
        r"""
        x.length() -> double
        Returns the length of the vector
        
        Returns:
            double:
        """
        ...
    def lerp_to(self, b: Vector, alpha: float) -> Vector:
        r"""
        x.lerp_to(b, alpha) -> Vector
        Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)
        
        Args:
            b (Vector): 
            alpha (float): 
        
        Returns:
            Vector:
        """
        ...
    def interp_to_constant(self, target: Vector, delta_time: float, interp_speed: float) -> Vector:
        r"""
        x.interp_to_constant(target, delta_time, interp_speed) -> Vector
        Tries to reach Target at a constant rate.
        
        Args:
            target (Vector): Target position
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed
        
        Returns:
            Vector: New interpolated position
        """
        ...
    def interp_to(self, target: Vector, delta_time: float, interp_speed: float) -> Vector:
        r"""
        x.interp_to(target, delta_time, interp_speed) -> Vector
        Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position.
        
        Args:
            target (Vector): Target position
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed, if the speed given is 0, then jump to the target.
        
        Returns:
            Vector: New interpolated position
        """
        ...
    def interp_spring_to(self, target: Vector, spring_state: VectorSpringState, stiffness: float, critical_damping_factor: float, delta_time: float, mass: float = 1.000000, target_velocity_amount: float = 1.000000, clamp: bool = False, min_value: Vector = [-1.000000, -1.000000, -1.000000], max_value: Vector = [1.000000, 1.000000, 1.000000], initialize_from_target: bool = False) -> Tuple[Vector, VectorSpringState]:
        r"""
        x.interp_spring_to(target, spring_state, stiffness, critical_damping_factor, delta_time, mass=1.000000, target_velocity_amount=1.000000, clamp=False, min_value=[-1.000000, -1.000000, -1.000000], max_value=[1.000000, 1.000000, 1.000000], initialize_from_target=False) -> (Vector, spring_state=VectorSpringState)
        Uses a simple spring model to interpolate a vector from Current to Target.
        
        Args:
            target (Vector): Target value
            spring_state (VectorSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
            stiffness (float): How stiff the spring model is (more stiffness means more oscillation around the target value)
            critical_damping_factor (float): How much damping to apply to the spring (0 means no damping, 1 means critically damped which means no oscillation)
            delta_time (float): Time difference since the last update
            mass (float): Multiplier that acts like mass on a spring
            target_velocity_amount (float): If 1 then the target velocity will be calculated and used, which results following the target more closely/without lag. Values down to zero (recommended when using this to smooth data) will progressively disable this effect.
            clamp (bool): Whether to use the Min/Max values to clamp the motion
            min_value (Vector): Clamps the minimum output value and cancels the velocity if it reaches this limit
            max_value (Vector): Clamps the maximum output value and cancels the velocity if it reaches this limit
            initialize_from_target (bool): If set then the current value will be set from the target on the first update
        
        Returns:
            VectorSpringState: 
        
            spring_state (VectorSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
        """
        ...
    def unwind_euler(self) -> None:
        r"""
        x.unwind_euler() -> None
        When this vector contains Euler angles (degrees), ensure that angles are between +/-180
        """
        ...
    def unit_cartesian_to_spherical(self) -> Vector2D:
        r"""
        x.unit_cartesian_to_spherical() -> Vector2D
        Converts a Cartesian unit vector into spherical coordinates on the unit sphere.
        
        Returns:
            Vector2D: Output Theta will be in the range [0, PI], and output Phi will be in the range [-PI, PI].
        """
        ...
    def to_radians(self) -> Vector:
        r"""
        x.to_radians() -> Vector
        Converts a vector containing degree values to a vector containing radian values.
        
        Returns:
            Vector: Vector containing radian values
        """
        ...
    def to_degrees(self) -> Vector:
        r"""
        x.to_degrees() -> Vector
        Converts a vector containing radian values to a vector containing degree values.
        
        Returns:
            Vector: Vector  containing degree values
        """
        ...
    def snapped_to_grid(self, grid_size: float) -> Vector:
        r"""
        x.snapped_to_grid(grid_size) -> Vector
        Gets a copy of this vector snapped to a grid.
        
        Args:
            grid_size (float): Grid dimension / step.
        
        Returns:
            Vector: A copy of this vector snapped to a grid.
        """
        ...
    def slerp_vectors(self, direction: Vector, alpha: float) -> Vector:
        r"""
        x.slerp_vectors(direction, alpha) -> Vector
        Interpolate from a vector to the direction of another vector along a spherical path.
        
        Args:
            direction (Vector): Target direction we interpolate to
            alpha (double): interpolation amount, usually between 0-1
        
        Returns:
            Vector: Vector after interpolating between Vector and Direction along a spherical path. The magnitude will remain the length of the starting vector.
        """
        ...
    def slerp_normals(self, normal_b: Vector, alpha: float) -> Vector:
        r"""
        x.slerp_normals(normal_b, alpha) -> Vector
        Interpolate from normalized vector A to normalized vector B along a spherical path.
        
        Args:
            normal_b (Vector): End target direction of interpolation, must be normalized.
            alpha (double): interpolation amount, usually between 0-1
        
        Returns:
            Vector: Vector after interpolating between A and B along a spherical path.
        """
        ...
    def set(self, x: float, y: float, z: float) -> None:
        r"""
        x.set(x, y, z) -> None
        Set the values of the vector directly.
        
        Args:
            x (double): 
            y (double): 
            z (double):
        """
        ...
    def reciprocal(self) -> Vector:
        r"""
        x.reciprocal() -> Vector
        Gets the reciprocal of this vector, avoiding division by zero.
        Zero components are set to BIG_NUMBER.
        
        Returns:
            Vector: Reciprocal of this vector.
        """
        ...
    def project_on_to_normal(self, normal: Vector) -> Vector:
        r"""
        x.project_on_to_normal(normal) -> Vector
        Gets a copy of this vector projected onto the input vector, which is assumed to be unit length.
        
        Args:
            normal (Vector): Vector to project onto (assumed to be unit length).
        
        Returns:
            Vector: Projected vector.
        """
        ...
    def normal_unsafe(self) -> Vector:
        r"""
        x.normal_unsafe() -> Vector
        Calculates normalized unit version of vector without checking for zero length.
        
        Returns:
            Vector: Normalized version of vector.
        """
        ...
    def normalize(self, tolerance: float = 0.000000) -> None:
        r"""
        x.normalize(tolerance=0.000000) -> None
        Normalize this vector in-place if it is large enough or set it to (0,0,0) otherwise.
        
        Args:
            tolerance (float): Minimum squared length of vector for normalization.
        """
        ...
    def normal2d(self, tolerance: float = 0.000100) -> Vector:
        r"""
        x.normal2d(tolerance=0.000100) -> Vector
        Gets a normalized unit copy of the 2D components of the vector, ensuring it is safe to do so. Z is set to zero.
        Returns zero vector if vector length is too small to normalize.
        
        Args:
            tolerance (float): Minimum squared vector length.
        
        Returns:
            Vector: Normalized copy if safe, (0,0,0) otherwise.
        """
        ...
    def mirror_by_plane(self, plane: Plane) -> Vector:
        r"""
        x.mirror_by_plane(plane) -> Vector
        Mirrors a vector about a plane.
        
        Args:
            plane (Plane): 
        
        Returns:
            Vector: Mirrored vector.
        """
        ...
    def is_zero(self) -> bool:
        r"""
        x.is_zero() -> bool
        Checks whether all components of the vector are exactly zero.
        
        Returns:
            bool: true if vector is exactly zero, otherwise false.
        """
        ...
    def is_unit(self, squared_lenth_tolerance: float = 0.000100) -> bool:
        r"""
        x.is_unit(squared_lenth_tolerance=0.000100) -> bool
        Determines if vector is normalized / unit (length 1) within specified squared tolerance.
        
        Args:
            squared_lenth_tolerance (float): 
        
        Returns:
            bool: true if unit, false otherwise.
        """
        ...
    def is_uniform(self, tolerance: float = 0.000100) -> bool:
        r"""
        x.is_uniform(tolerance=0.000100) -> bool
        Checks whether all components of this vector are the same, within a tolerance.
        
        Args:
            tolerance (float): Error tolerance.
        
        Returns:
            bool: true if the vectors are equal within tolerance limits, false otherwise.
        """
        ...
    def is_normal(self) -> bool:
        r"""
        x.is_normal() -> bool
        Determines if vector is normalized / unit (length 1).
        
        Returns:
            bool: true if normalized, false otherwise.
        """
        ...
    def is_nearly_zero(self, tolerance: float = 0.000100) -> bool:
        r"""
        x.is_nearly_zero(tolerance=0.000100) -> bool
        Checks whether vector is near to zero within a specified tolerance.
        
        Args:
            tolerance (float): Error tolerance.
        
        Returns:
            bool: true if vector is in tolerance to zero, otherwise false.
        """
        ...
    def is_nan(self) -> bool:
        r"""
        x.is_nan() -> bool
        Determines if any component is not a number (NAN)
        
        Returns:
            bool: true if one or more components is NAN, otherwise false.
        """
        ...
    def heading_angle(self) -> float:
        r"""
        x.heading_angle() -> double
        Convert a direction vector into a 'heading' angle.
        
        Returns:
            double: 'Heading' angle between +/-PI radians. 0 is pointing down +X.
        """
        ...
    def get_sign_vector(self) -> Vector:
        r"""
        x.get_sign_vector() -> Vector
        Get a copy of the vector as sign only.
        Each component is set to +1 or -1, with the sign of zero treated as +1.
        
        Returns:
            Vector:
        """
        ...
    def get_projection(self) -> Vector:
        r"""
        x.get_projection() -> Vector
        Projects 2D components of vector based on Z.
        
        Returns:
            Vector: Projected version of vector based on Z.
        """
        ...
    def get_abs_min(self) -> float:
        r"""
        x.get_abs_min() -> double
        Find the minimum absolute element (abs(X), abs(Y) or abs(Z)) of a vector
        
        Returns:
            double:
        """
        ...
    def get_abs_max(self) -> float:
        r"""
        x.get_abs_max() -> double
        Find the maximum absolute element (abs(X), abs(Y) or abs(Z)) of a vector
        
        Returns:
            double:
        """
        ...
    def get_abs(self) -> Vector:
        r"""
        x.get_abs() -> Vector
        Get a copy of this vector with absolute value of each component.
        
        Returns:
            Vector: A copy of this vector with absolute value of each component.
        """
        ...
    def distance_squared(self, v2: Vector) -> float:
        r"""
        x.distance_squared(v2) -> double
        Squared distance between two points.
        
        Args:
            v2 (Vector): The second point.
        
        Returns:
            double: The squared distance between two points.
        """
        ...
    def distance2d_squared(self, v2: Vector) -> float:
        r"""
        x.distance2d_squared(v2) -> double
        Squared euclidean distance between two points in the XY plane (ignoring Z).
        
        Args:
            v2 (Vector): The second point.
        
        Returns:
            double: The distance between two points in the XY plane.
        """
        ...
    def distance2d(self, v2: Vector) -> float:
        r"""
        x.distance2d(v2) -> double
        Euclidean distance between two points in the XY plane (ignoring Z).
        
        Args:
            v2 (Vector): The second point.
        
        Returns:
            double: The distance between two points in the XY plane.
        """
        ...
    def distance(self, v2: Vector) -> float:
        r"""
        x.distance(v2) -> double
        Distance between two points.
        
        Args:
            v2 (Vector): The second point.
        
        Returns:
            double: The distance between two points.
        """
        ...
    def cosine_angle2d(self, b: Vector) -> float:
        r"""
        x.cosine_angle2d(b) -> double
        Returns the cosine of the angle between this vector and another projected onto the XY plane (no Z).
        
        Args:
            b (Vector): the other vector to find the 2D cosine of the angle with.
        
        Returns:
            double: The cosine.
        """
        ...
    def get_min(self, b: Vector) -> Vector:
        r"""
        x.get_min(b) -> Vector
        Find the minimum elements (X, Y and Z) between the two vector's components
        
        Args:
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def get_max(self, b: Vector) -> Vector:
        r"""
        x.get_max(b) -> Vector
        Find the maximum elements (X, Y and Z) between the two vector's components
        
        Args:
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def clamped_size_max2d(self, max: float) -> Vector:
        r"""
        x.clamped_size_max2d(max) -> Vector
        Create a copy of this vector, with the maximum 2D magnitude/size/length clamped to MaxSize. Z is unchanged.
        
        Args:
            max (double): 
        
        Returns:
            Vector:
        """
        ...
    def clamped_size_max(self, max: float) -> Vector:
        r"""
        x.clamped_size_max(max) -> Vector
        Create a copy of this vector, with its maximum magnitude/size/length clamped to MaxSize.
        
        Args:
            max (double): 
        
        Returns:
            Vector:
        """
        ...
    def clamped_size2d(self, min: float, max: float) -> Vector:
        r"""
        x.clamped_size2d(min, max) -> Vector
        Create a copy of this vector, with the 2D magnitude/size/length clamped between Min and Max. Z is unchanged.
        
        Args:
            min (double): 
            max (double): 
        
        Returns:
            Vector:
        """
        ...
    def bounded_to_cube(self, radius: float) -> Vector:
        r"""
        x.bounded_to_cube(radius) -> Vector
        Get a copy of this vector, clamped inside of an axis aligned cube centered at the origin.
        
        Args:
            radius (float): Half size of the cube (or radius of sphere circumscribed in the cube).
        
        Returns:
            Vector: A copy of this vector, bound by cube.
        """
        ...
    def bounded_to_box(self, box_min: Vector, box_max: Vector) -> Vector:
        r"""
        x.bounded_to_box(box_min, box_max) -> Vector
        Get a copy of this vector, clamped inside of the specified axis aligned cube.
        
        Args:
            box_min (Vector): 
            box_max (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def assign(self, vector: Vector) -> None:
        r"""
        x.assign(vector) -> None
        Assign the values of the supplied vector.
        
        Args:
            vector (Vector): Vector to copy values from.
        """
        ...
    def add_bounded(self, add_vect: Vector, radius: float) -> None:
        r"""
        x.add_bounded(add_vect, radius) -> None
        Add a vector to this and clamp the result to an axis aligned cube centered at the origin.
        
        Args:
            add_vect (Vector): Vector to add.
            radius (float): Half size of the cube.
        """
        ...
    def subtract(self, b: Vector) -> Vector:
        r"""
        x.subtract(b) -> Vector
        Vector subtraction
        
        Args:
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def subtract_int(self, b: int) -> Vector:
        r"""
        x.subtract_int(b) -> Vector
        Subtracts an integer from each component of a vector
        
        Args:
            b (int32): 
        
        Returns:
            Vector:
        """
        ...
    def subtract_float(self, b: float) -> Vector:
        r"""
        x.subtract_float(b) -> Vector
        Subtracts a float from each component of a vector
        
        Args:
            b (double): 
        
        Returns:
            Vector:
        """
        ...
    def rotator_from_axis_and_angle(self, angle: float) -> Rotator:
        r"""
        x.rotator_from_axis_and_angle(angle) -> Rotator
        Create a rotation from an axis and supplied angle (in degrees)
        
        Args:
            angle (float): 
        
        Returns:
            Rotator:
        """
        ...
    def rotate_angle_axis(self, angle_deg: float, axis: Vector) -> Vector:
        r"""
        x.rotate_angle_axis(angle_deg, axis) -> Vector
        Returns result of vector A rotated by AngleDeg around Axis
        
        Args:
            angle_deg (float): 
            axis (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def random_point_in_box_extents(self, half_size: Vector) -> Vector:
        r"""
        x.random_point_in_box_extents(half_size) -> Vector
        Returns a random point within the specified bounding box using the first vector as an origin and the second as the box extents.
        
        Args:
            half_size (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def find_quat_between_vectors(self, end: Vector) -> Quat:
        r"""
        x.find_quat_between_vectors(end) -> Quat
        Generates the 'smallest' (geodesic) rotation around a sphere between two vectors of arbitrary length.
        
        Args:
            end (Vector): Vector the rotation ends at
        
        Returns:
            Quat: Quat that will rotate from Start to End
        """
        ...
    def find_quat_between_normals(self, end_normal: Vector) -> Quat:
        r"""
        x.find_quat_between_normals(end_normal) -> Quat
        Generates the 'smallest' (geodesic) rotation around a sphere between two normals (assumed to be unit length).
        
        Args:
            end_normal (Vector): 
        
        Returns:
            Quat: Quat that will rotate from Start to End
        """
        ...
    def project_on_to(self, target: Vector) -> Vector:
        r"""
        x.project_on_to(target) -> Vector
        Projects one vector (V) onto another (Target) and returns the projected vector.
        If Target is nearly zero in length, returns the zero vector.
        
        Args:
            target (Vector): Vector on which we are projecting.
        
        Returns:
            Vector: V projected on to Target.
        """
        ...
    def project_on_to_plane(self, plane_normal: Vector) -> Vector:
        r"""
        x.project_on_to_plane(plane_normal) -> Vector
        Projects a vector onto a plane defined by a normalized vector (PlaneNormal).
        
        Args:
            plane_normal (Vector): Normal of the plane.
        
        Returns:
            Vector: Vector projected onto the plane.
        """
        ...
    def project_point_on_to_plane(self, plane_base: Vector, plane_normal: Vector) -> Vector:
        r"""
        x.project_point_on_to_plane(plane_base, plane_normal) -> Vector
        Projects/snaps a point onto a plane defined by a point on the plane and a plane normal.
        
        Args:
            plane_base (Vector): A point on the plane.
            plane_normal (Vector): Normal of the plane.
        
        Returns:
            Vector: Point projected onto the plane.
        """
        ...
    def not_equal(self, b: Vector) -> bool:
        r"""
        x.not_equal(b) -> bool
        Returns true if vector A is not equal to vector B (A != B)
        
        Args:
            b (Vector): 
        
        Returns:
            bool:
        """
        ...
    def is_not_near_equal(self, b: Vector, error_tolerance: float = 0.000100) -> bool:
        r"""
        x.is_not_near_equal(b, error_tolerance=0.000100) -> bool
        Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance
        
        Args:
            b (Vector): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    def normal(self, tolerance: float = 0.000100) -> Vector:
        r"""
        x.normal(tolerance=0.000100) -> Vector
        Gets a normalized unit copy of the vector, ensuring it is safe to do so based on the length.
        Returns zero vector if vector length is too small to safely normalize.
        
        Args:
            tolerance (float): Minimum squared vector length.
        
        Returns:
            Vector: A normalized copy if safe, (0,0,0) otherwise.
        """
        ...
    def negated(self) -> Vector:
        r"""
        x.negated() -> Vector
        Negate a vector.
        
        Returns:
            Vector:
        """
        ...
    def multiply(self, b: Vector) -> Vector:
        r"""
        x.multiply(b) -> Vector
        Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z})
        
        Args:
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def multiply_int(self, b: int) -> Vector:
        r"""
        x.multiply_int(b) -> Vector
        Scales Vector A by B
        
        Args:
            b (int32): 
        
        Returns:
            Vector:
        """
        ...
    def multiply_float(self, b: float) -> Vector:
        r"""
        x.multiply_float(b) -> Vector
        Scales Vector A by B
        
        Args:
            b (double): 
        
        Returns:
            Vector:
        """
        ...
    def unrotate(self, b: Rotator) -> Vector:
        r"""
        x.unrotate(b) -> Vector
        Returns result of vector A rotated by the inverse of Rotator B
        
        Args:
            b (Rotator): 
        
        Returns:
            Vector:
        """
        ...
    def rotate(self, b: Rotator) -> Vector:
        r"""
        x.rotate(b) -> Vector
        Returns result of vector A rotated by Rotator B
        
        Args:
            b (Rotator): 
        
        Returns:
            Vector:
        """
        ...
    def mirror_by_vector(self, surface_normal: Vector) -> Vector:
        r"""
        x.mirror_by_vector(surface_normal) -> Vector
        Given a direction vector and a surface normal, returns the vector reflected across the surface normal.
        Produces a result like shining a laser at a mirror!
        
        Args:
            surface_normal (Vector): A normal of the surface the ray should be reflected on.
        
        Returns:
            Vector: Reflected vector.
        """
        ...
    def get_min_element(self) -> float:
        r"""
        x.get_min_element() -> double
        Find the minimum element (X, Y or Z) of a vector
        
        Returns:
            double:
        """
        ...
    def get_max_element(self) -> float:
        r"""
        x.get_max_element() -> double
        Find the maximum element (X, Y or Z) of a vector
        
        Returns:
            double:
        """
        ...
    def direction_unit_to(self, to: Vector) -> Vector:
        r"""
        x.direction_unit_to(to) -> Vector
        Find the unit direction vector from one position to another or (0,0,0) if positions are the same.
        
        Args:
            to (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def truncated(self) -> IntVector:
        r"""
        x.truncated() -> IntVector
        Rounds A to an integer with truncation towards zero for each element in a vector.  (e.g. -1.7 truncated to -1, 2.8 truncated to 2)
        
        Returns:
            IntVector:
        """
        ...
    def equals(self, b: Vector) -> bool:
        r"""
        x.equals(b) -> bool
        Returns true if vector A is equal to vector B (A == B)
        
        Args:
            b (Vector): 
        
        Returns:
            bool:
        """
        ...
    def is_near_equal(self, b: Vector, error_tolerance: float = 0.000100) -> bool:
        r"""
        x.is_near_equal(b, error_tolerance=0.000100) -> bool
        Returns true if vector A is equal to vector B (A == B) within a specified error tolerance
        
        Args:
            b (Vector): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    def dot(self, b: Vector) -> float:
        r"""
        x.dot(b) -> double
        Returns the dot product of two 3d vectors - see http://mathworld.wolfram.com/DotProduct.html
        
        Args:
            b (Vector): 
        
        Returns:
            double:
        """
        ...
    def divide(self, b: Vector = [1.000000, 1.000000, 1.000000]) -> Vector:
        r"""
        x.divide(b=[1.000000, 1.000000, 1.000000]) -> Vector
        Element-wise Vector division (Result = {A.x/B.x, A.y/B.y, A.z/B.z})
        
        Args:
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def divide_int(self, b: int = 1) -> Vector:
        r"""
        x.divide_int(b=1) -> Vector
        Vector divide by an integer
        
        Args:
            b (int32): 
        
        Returns:
            Vector:
        """
        ...
    def divide_float(self, b: float = 1.000000) -> Vector:
        r"""
        x.divide_float(b=1.000000) -> Vector
        Vector divide by a float
        
        Args:
            b (double): 
        
        Returns:
            Vector:
        """
        ...
    def cross(self, b: Vector) -> Vector:
        r"""
        x.cross(b) -> Vector
        Returns the cross product of two 3d vectors - see http://mathworld.wolfram.com/CrossProduct.html
        
        Args:
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def vector2d(self) -> Vector2D:
        r"""
        x.vector2d() -> Vector2D
        Converts a Vector to a Vector2D using the Vector's (X, Y) coordinates
        
        Returns:
            Vector2D:
        """
        ...
    def transform(self) -> Transform:
        r"""
        x.transform() -> Transform
        Converts a vector to a transform. Uses vector as location
        
        Returns:
            Transform:
        """
        ...
    def rotator(self) -> Rotator:
        r"""
        x.rotator() -> Rotator
        Return the FRotator orientation corresponding to the direction in which the vector points.
        Sets Yaw and Pitch to the proper numbers, and sets Roll to zero because the roll can't be determined from a vector.
        
        Returns:
            Rotator: FRotator from the Vector's direction, without any roll.
        """
        ...
    def quaternion(self) -> Quat:
        r"""
        x.quaternion() -> Quat
        Return the Quaternion orientation corresponding to the direction in which the vector points.
        Similar to the FRotator version, returns a result without roll such that it preserves the up vector.
        note: If you don't care about preserving the up vector and just want the most direct rotation, you can use the faster 'FindBetweenVectors(ForwardVector, YourVector)' or 'FindBetweenNormals(...)' if you know the vector is of unit length.
        
        Returns:
            Quat: Quaternion from the Vector's direction, without any roll.
        """
        ...
    def linear_color(self) -> LinearColor:
        r"""
        x.linear_color() -> LinearColor
        Converts a vector to LinearColor
        
        Returns:
            LinearColor:
        """
        ...
    def clamped_size(self, min: float, max: float) -> Vector:
        r"""
        x.clamped_size(min, max) -> Vector
        Create a copy of this vector, with its magnitude/size/length clamped between Min and Max.
        
        Args:
            min (double): 
            max (double): 
        
        Returns:
            Vector:
        """
        ...
    def add(self, b: Vector) -> Vector:
        r"""
        x.add(b) -> Vector
        Vector addition
        
        Args:
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def add_int(self, b: int) -> Vector:
        r"""
        x.add_int(b) -> Vector
        Adds an integer to each component of a vector
        
        Args:
            b (int32): 
        
        Returns:
            Vector:
        """
        ...
    def add_float(self, b: float) -> Vector:
        r"""
        x.add_float(b) -> Vector
        Adds a float to each component of a vector
        
        Args:
            b (double): 
        
        Returns:
            Vector:
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Vector`` Returns true if vector A is equal to vector B (A == B)
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Vector`` Returns true if vector A is not equal to vector B (A != B)
        """
        ...
    def __add__(self, other: Vector) -> None:
        r"""
        **Overloads:**
        
        - ``Vector`` Vector addition
        """
        ...
    def __iadd__(self, other: Vector) -> None:
        r"""
        **Overloads:**
        
        - ``Vector`` Vector addition
        """
        ...
    def __sub__(self, other: Vector) -> None:
        r"""
        **Overloads:**
        
        - ``Vector`` Vector subtraction
        """
        ...
    def __isub__(self, other: Vector) -> None:
        r"""
        **Overloads:**
        
        - ``Vector`` Vector subtraction
        """
        ...
    def __mul__(self, other: Vector) -> None:
        r"""
        **Overloads:**
        
        - ``Vector`` Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z})
        - ``double`` Scales Vector A by B
        """
        ...
    def __imul__(self, other: Vector) -> None:
        r"""
        **Overloads:**
        
        - ``Vector`` Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z})
        - ``double`` Scales Vector A by B
        """
        ...
    def __truediv__(self, other: Vector) -> None:
        r"""
        **Overloads:**
        
        - ``Vector`` Element-wise Vector division (Result = {A.x/B.x, A.y/B.y, A.z/B.z})
        - ``double`` Vector divide by a float
        """
        ...
    def __or__(self, other: Vector) -> None:
        r"""
        **Overloads:**
        
        - ``Vector`` Returns the dot product of two 3d vectors - see http://mathworld.wolfram.com/DotProduct.html
        """
        ...
    def __xor__(self, other: Vector) -> None:
        r"""
        **Overloads:**
        
        - ``Vector`` Returns the cross product of two 3d vectors - see http://mathworld.wolfram.com/CrossProduct.html
        """
        ...
    def __neg__(self) -> None:
        r"""
        Negate a vector.
        """
        ...
    ZERO: Vector #: (Vector): 3D vector zero constant (0,0,0)
    UP: Vector #: (Vector): 3D vector Unreal up direction constant (0,0,1)
    RIGHT: Vector #: (Vector): 3D vector Unreal right direction constant (0,1,0)
    ONE: Vector #: (Vector): 3D vector one constant (1,1,1)
    LEFT: Vector #: (Vector): 3D vector Unreal left direction constant (0,-1,0)
    FORWARD: Vector #: (Vector): 3D vector Unreal forward direction constant (1,0,0)
    DOWN: Vector #: (Vector): 3D vector Unreal down direction constant (0,0,-1)
    BACKWARD: Vector #: (Vector): 3D vector Unreal backward direction constant (-1,0,0)

class Box2D(StructBase):
    r"""
    A rectangular 2D Box.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Box2D.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_valid`` (bool):  [Read-Write]
    - ``max`` (Vector2D):  [Read-Write]
    - ``min`` (Vector2D):  [Read-Write]
    """
    def __init__(self, min: Vector2D = [0.000000, 0.000000], max: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def min(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write]
        """
        ...
    @min.setter
    def min(self, value: Vector2D) -> None:
        ...
    @property
    def max(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write]
        """
        ...
    @max.setter
    def max(self, value: Vector2D) -> None:
        ...
    @property
    def is_valid(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_valid.setter
    def is_valid(self, value: bool) -> None:
        ...

class Vector2D(StructBase):
    r"""
    A vector in 2-D space composed of components (X, Y) with floating point precision.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Vector2D.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000) -> None:
        ...
    @property
    def x(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: float) -> None:
        ...
    @property
    def y(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: float) -> None:
        ...
    def length_squared(self) -> float:
        r"""
        x.length_squared() -> double
        Returns the squared length of a 2D Vector.
        
        Returns:
            double:
        """
        ...
    def length(self) -> float:
        r"""
        x.length() -> double
        Returns the length of a 2D Vector.
        
        Returns:
            double:
        """
        ...
    def interp_to_constant(self, target: Vector2D, delta_time: float, interp_speed: float) -> Vector2D:
        r"""
        x.interp_to_constant(target, delta_time, interp_speed) -> Vector2D
        Tries to reach Target at a constant rate.
        
        Args:
            target (Vector2D): Target position
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed
        
        Returns:
            Vector2D: New interpolated position
        """
        ...
    def interp_to(self, target: Vector2D, delta_time: float, interp_speed: float) -> Vector2D:
        r"""
        x.interp_to(target, delta_time, interp_speed) -> Vector2D
        Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position.
        
        Args:
            target (Vector2D): Target position
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed, if the speed given is 0, then jump to the target.
        
        Returns:
            Vector2D: New interpolated position
        """
        ...
    def to_sign(self) -> Vector2D:
        r"""
        x.to_sign() -> Vector2D
        Get a copy of the vector as sign only.
        Each component is set to +1 or -1, with the sign of zero treated as +1.
        
        Returns:
            Vector2D: A copy of the vector with each component set to +1 or -1
        """
        ...
    def to_rounded(self) -> Vector2D:
        r"""
        x.to_rounded() -> Vector2D
        Get this vector as a vector where each component has been rounded to the nearest int.
        
        Returns:
            Vector2D: New FVector2D from this vector that is rounded.
        """
        ...
    def to_direction_and_length(self) -> Tuple[Vector2D, float]:
        r"""
        x.to_direction_and_length() -> (out_dir=Vector2D, out_length=double)
        Util to convert this vector into a unit direction vector and its original length.
        
        Returns:
            tuple: 
        
            out_dir (Vector2D): Reference passed in to store unit direction vector.
        
            out_length (double): Reference passed in to store length of the vector.
        """
        ...
    def subtract(self, b: Vector2D) -> Vector2D:
        r"""
        x.subtract(b) -> Vector2D
        Returns subtraction of Vector B from Vector A (A - B)
        
        Args:
            b (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    def subtract_float(self, b: float) -> Vector2D:
        r"""
        x.subtract_float(b) -> Vector2D
        Returns Vector A subtracted by B
        
        Args:
            b (double): 
        
        Returns:
            Vector2D:
        """
        ...
    def spherical_to_unit_cartesian(self) -> Vector:
        r"""
        x.spherical_to_unit_cartesian() -> Vector
        Converts spherical coordinates on the unit sphere into a Cartesian unit length vector.
        
        Returns:
            Vector:
        """
        ...
    def set(self, x: float, y: float) -> None:
        r"""
        x.set(x, y) -> None
        Set the values of the vector directly.
        
        Args:
            x (double): 
            y (double):
        """
        ...
    def not_equal(self, b: Vector2D) -> bool:
        r"""
        x.not_equal(b) -> bool
        Returns true if vector2D A is not equal to vector2D B (A != B) within a specified error tolerance
        
        Args:
            b (Vector2D): 
        
        Returns:
            bool:
        """
        ...
    def is_not_near_equal(self, b: Vector2D, error_tolerance: float = 0.000100) -> bool:
        r"""
        x.is_not_near_equal(b, error_tolerance=0.000100) -> bool
        Returns true if vector2D A is not equal to vector2D B (A != B) within a specified error tolerance
        
        Args:
            b (Vector2D): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    def normal(self, tolerance: float = 0.000000) -> Vector2D:
        r"""
        x.normal(tolerance=0.000000) -> Vector2D
        Gets a normalized copy of the vector, checking it is safe to do so based on the length.
        Returns zero vector if vector length is too small to safely normalize.
        
        Args:
            tolerance (float): Minimum squared length of vector for normalization.
        
        Returns:
            Vector2D: A normalized copy of the vector if safe, (0,0) otherwise.
        """
        ...
    def normalize(self, tolerance: float = 0.000000) -> None:
        r"""
        x.normalize(tolerance=0.000000) -> None
        Normalize this vector in-place if it is large enough, set it to (0,0) otherwise.
        see: NormalSafe2D()
        
        Args:
            tolerance (float): Minimum squared length of vector for normalization.
        """
        ...
    def normal_unsafe(self) -> Vector2D:
        r"""
        x.normal_unsafe() -> Vector2D
        Returns a unit normal version of the 2D vector
        
        Returns:
            Vector2D:
        """
        ...
    def negated(self) -> Vector2D:
        r"""
        x.negated() -> Vector2D
        Gets a negated copy of the vector.
        
        Returns:
            Vector2D:
        """
        ...
    def multiply(self, b: Vector2D) -> Vector2D:
        r"""
        x.multiply(b) -> Vector2D
        Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y})
        
        Args:
            b (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    def multiply_float(self, b: float) -> Vector2D:
        r"""
        x.multiply_float(b) -> Vector2D
        Returns Vector A scaled by B
        
        Args:
            b (double): 
        
        Returns:
            Vector2D:
        """
        ...
    def is_zero(self) -> bool:
        r"""
        x.is_zero() -> bool
        Checks whether all components of the vector are exactly zero.
        
        Returns:
            bool: true if vector is exactly zero, otherwise false.
        """
        ...
    def is_nearly_zero(self, tolerance: float = 0.000100) -> bool:
        r"""
        x.is_nearly_zero(tolerance=0.000100) -> bool
        Checks whether vector is near to zero within a specified tolerance.
        
        Args:
            tolerance (float): Error tolerance.
        
        Returns:
            bool: true if vector is in tolerance to zero, otherwise false.
        """
        ...
    def get_rotated(self, angle_deg: float) -> Vector2D:
        r"""
        x.get_rotated(angle_deg) -> Vector2D
        Rotates around axis (0,0,1)
        
        Args:
            angle_deg (float): Angle to rotate (in degrees)
        
        Returns:
            Vector2D: Rotated Vector
        """
        ...
    def get_min(self) -> float:
        r"""
        x.get_min() -> double
        Get the minimum value of the vector's components.
        
        Returns:
            double: The minimum value of the vector's components.
        """
        ...
    def get_max(self) -> float:
        r"""
        x.get_max() -> double
        Get the maximum value of the vector's components.
        
        Returns:
            double: The maximum value of the vector's components.
        """
        ...
    def get_abs_max(self) -> float:
        r"""
        x.get_abs_max() -> double
        Get the maximum absolute value of the vector's components.
        
        Returns:
            double: The maximum absolute value of the vector's components.
        """
        ...
    def get_abs(self) -> Vector2D:
        r"""
        x.get_abs() -> Vector2D
        Get a copy of this vector with absolute value of each component.
        
        Returns:
            Vector2D: A copy of this vector with absolute value of each component.
        """
        ...
    def equals(self, b: Vector2D) -> bool:
        r"""
        x.equals(b) -> bool
        Returns true if vector A is equal to vector B (A == B)
        
        Args:
            b (Vector2D): 
        
        Returns:
            bool:
        """
        ...
    def is_near_equal(self, b: Vector2D, error_tolerance: float = 0.000100) -> bool:
        r"""
        x.is_near_equal(b, error_tolerance=0.000100) -> bool
        Returns true if vector2D A is equal to vector2D B (A == B) within a specified error tolerance
        
        Args:
            b (Vector2D): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    def dot(self, b: Vector2D) -> float:
        r"""
        x.dot(b) -> double
        Returns the dot product of two 2d vectors - see http://mathworld.wolfram.com/DotProduct.html
        
        Args:
            b (Vector2D): 
        
        Returns:
            double:
        """
        ...
    def divide(self, b: Vector2D) -> Vector2D:
        r"""
        x.divide(b) -> Vector2D
        Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y})
        
        Args:
            b (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    def divide_float(self, b: float = 1.000000) -> Vector2D:
        r"""
        x.divide_float(b=1.000000) -> Vector2D
        Returns Vector A divided by B
        
        Args:
            b (double): 
        
        Returns:
            Vector2D:
        """
        ...
    def distance_squared(self, v2: Vector2D) -> float:
        r"""
        x.distance_squared(v2) -> double
        Squared distance between two 2D points.
        
        Args:
            v2 (Vector2D): The second point.
        
        Returns:
            double: The squared distance between two 2D points.
        """
        ...
    def distance(self, v2: Vector2D) -> float:
        r"""
        x.distance(v2) -> double
        Distance between two 2D points.
        
        Args:
            v2 (Vector2D): The second point.
        
        Returns:
            double: The distance between two 2D points.
        """
        ...
    def cross(self, b: Vector2D) -> float:
        r"""
        x.cross(b) -> double
        Returns the cross product of two 2d vectors - see  http://mathworld.wolfram.com/CrossProduct.html
        
        Args:
            b (Vector2D): 
        
        Returns:
            double:
        """
        ...
    def vector(self, z: float = 0.000000) -> Vector:
        r"""
        x.vector(z=0.000000) -> Vector
        Converts a Vector2D to a Vector
        
        Args:
            z (float): 
        
        Returns:
            Vector:
        """
        ...
    def int_point(self) -> IntPoint:
        r"""
        x.int_point() -> IntPoint
        Converts a Vector2D to an IntPoint
        
        Returns:
            IntPoint:
        """
        ...
    def clamped_axes(self, min_axis_val: float, max_axis_val: float) -> Vector2D:
        r"""
        x.clamped_axes(min_axis_val, max_axis_val) -> Vector2D
        Creates a copy of this vector with both axes clamped to the given range.
        
        Args:
            min_axis_val (double): 
            max_axis_val (double): 
        
        Returns:
            Vector2D: New vector with clamped axes.
        """
        ...
    def add(self, b: Vector2D) -> Vector2D:
        r"""
        x.add(b) -> Vector2D
        Returns addition of Vector A and Vector B (A + B)
        
        Args:
            b (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    def add_float(self, b: float) -> Vector2D:
        r"""
        x.add_float(b) -> Vector2D
        Returns Vector A added by B
        
        Args:
            b (double): 
        
        Returns:
            Vector2D:
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Vector2D`` Returns true if vector A is equal to vector B (A == B)
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Vector2D`` Returns true if vector2D A is not equal to vector2D B (A != B) within a specified error tolerance
        """
        ...
    def __add__(self, other: Vector2D) -> None:
        r"""
        **Overloads:**
        
        - ``Vector2D`` Returns addition of Vector A and Vector B (A + B)
        - ``double`` Returns Vector A added by B
        """
        ...
    def __iadd__(self, other: Vector2D) -> None:
        r"""
        **Overloads:**
        
        - ``Vector2D`` Returns addition of Vector A and Vector B (A + B)
        - ``double`` Returns Vector A added by B
        """
        ...
    def __sub__(self, other: Vector2D) -> None:
        r"""
        **Overloads:**
        
        - ``Vector2D`` Returns subtraction of Vector B from Vector A (A - B)
        - ``double`` Returns Vector A subtracted by B
        """
        ...
    def __isub__(self, other: Vector2D) -> None:
        r"""
        **Overloads:**
        
        - ``Vector2D`` Returns subtraction of Vector B from Vector A (A - B)
        - ``double`` Returns Vector A subtracted by B
        """
        ...
    def __mul__(self, other: Vector2D) -> None:
        r"""
        **Overloads:**
        
        - ``Vector2D`` Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y})
        - ``double`` Returns Vector A scaled by B
        """
        ...
    def __imul__(self, other: Vector2D) -> None:
        r"""
        **Overloads:**
        
        - ``Vector2D`` Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y})
        - ``double`` Returns Vector A scaled by B
        """
        ...
    def __truediv__(self, other: Vector2D) -> None:
        r"""
        **Overloads:**
        
        - ``Vector2D`` Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y})
        - ``double`` Returns Vector A divided by B
        """
        ...
    def __or__(self, other: Vector2D) -> None:
        r"""
        **Overloads:**
        
        - ``Vector2D`` Returns the dot product of two 2d vectors - see http://mathworld.wolfram.com/DotProduct.html
        """
        ...
    def __xor__(self, other: Vector2D) -> None:
        r"""
        **Overloads:**
        
        - ``Vector2D`` Returns the cross product of two 2d vectors - see  http://mathworld.wolfram.com/CrossProduct.html
        """
        ...
    def __neg__(self) -> None:
        r"""
        Gets a negated copy of the vector.
        """
        ...
    ZERO: Vector2D #: (Vector2D): 2D zero vector constant (0,0)
    UNIT45_DEG: Vector2D #: (Vector2D): 2D unit vector constant along the 45 degree angle or symmetrical positive axes (sqrt(.5),sqrt(.5)) or (.707,.707). https://en.wikipedia.org/wiki/Unit_vector
    ONE: Vector2D #: (Vector2D): 2D one vector constant (1,1)

class Box2f(StructBase):
    r"""
    A rectangular 2D Box.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Box2D.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_valid`` (bool):  [Read-Write]
    - ``max`` (Vector2f):  [Read-Write]
    - ``min`` (Vector2f):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class Vector2f(StructBase):
    r"""
    A vector in 2-D space composed of components (X, Y) with floating point precision.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Vector2D.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (float):  [Read-Write]
    - ``y`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class Box3f(StructBase):
    r"""
    A point or direction FVector in 3d space.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Box.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_valid`` (bool):  [Read-Write]
    - ``max`` (Vector3f):  [Read-Write]
    - ``min`` (Vector3f):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class Vector3f(StructBase):
    r"""
    A point or direction FVector in 3d space.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Vector.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (float):  [Read-Write]
    - ``y`` (float):  [Read-Write]
    - ``z`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class BoxSphereBounds(StructBase):
    r"""
    A bounding box and bounding sphere with the same origin.
    note: The full C++ class is located here : Engine\Source\Runtime\Core\Public\Math\BoxSphereBounds.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``box_extent`` (Vector):  [Read-Write] Holds the extent of the bounding box, which is half the size of the box in 3D space
    - ``origin`` (Vector):  [Read-Write] Holds the origin of the bounding box and sphere.
    - ``sphere_radius`` (double):  [Read-Write] Holds the radius of the bounding sphere.
    """
    def __init__(self, origin: Vector = [0.000000, 0.000000, 0.000000], box_extent: Vector = [0.000000, 0.000000, 0.000000], sphere_radius: float = 0.000000) -> None:
        ...
    @property
    def origin(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Holds the origin of the bounding box and sphere.
        """
        ...
    @origin.setter
    def origin(self, value: Vector) -> None:
        ...
    @property
    def box_extent(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Holds the extent of the bounding box, which is half the size of the box in 3D space
        """
        ...
    @box_extent.setter
    def box_extent(self, value: Vector) -> None:
        ...
    @property
    def sphere_radius(self) -> float:
        r"""
        (double):  [Read-Write] Holds the radius of the bounding sphere.
        """
        ...
    @sphere_radius.setter
    def sphere_radius(self, value: float) -> None:
        ...

class Color(StructBase):
    r"""
    Stores a color with 8 bits of precision per channel. (BGRA).
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Color.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (uint8):  [Read-Write]
    - ``b`` (uint8):  [Read-Write]
    - ``g`` (uint8):  [Read-Write]
    - ``r`` (uint8):  [Read-Write]
    """
    def __init__(self, b: int = 0, g: int = 0, r: int = 0, a: int = 0) -> None:
        ...
    @property
    def b(self) -> int:
        r"""
        (uint8):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: int) -> None:
        ...
    @property
    def g(self) -> int:
        r"""
        (uint8):  [Read-Write]
        """
        ...
    @g.setter
    def g(self, value: int) -> None:
        ...
    @property
    def r(self) -> int:
        r"""
        (uint8):  [Read-Write]
        """
        ...
    @r.setter
    def r(self, value: int) -> None:
        ...
    @property
    def a(self) -> int:
        r"""
        (uint8):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: int) -> None:
        ...

class DirectoryPath(StructBase):
    r"""
    Structure for directory paths that are displayed in the editor with a picker UI.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``path`` (str):  [Read-Write] The path to the directory.
    """
    def __init__(self, path: str = "") -> None:
        ...
    @property
    def path(self) -> str:
        r"""
        (str):  [Read-Write] The path to the directory.
        """
        ...
    @path.setter
    def path(self, value: str) -> None:
        ...

class DoubleRange(StructBase):
    r"""
    A contiguous set of doubles described by lower and upper bound values.
    note: This is a mirror of TRange<double>, defined in Range.h
    note: Fields are private to match the C++ declaration in the header above.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``lower_bound`` (DoubleRangeBound):  [Read-Write] Holds the range's lower bound.
    - ``upper_bound`` (DoubleRangeBound):  [Read-Write] Holds the range's upper bound.
    """
    def __init__(self, lower_bound: DoubleRangeBound = [RangeBoundTypes.EXCLUSIVE, 0.000000], upper_bound: DoubleRangeBound = [RangeBoundTypes.EXCLUSIVE, 0.000000]) -> None:
        ...
    @property
    def lower_bound(self) -> DoubleRangeBound:
        r"""
        (DoubleRangeBound):  [Read-Write] Holds the range's lower bound.
        """
        ...
    @lower_bound.setter
    def lower_bound(self, value: DoubleRangeBound) -> None:
        ...
    @property
    def upper_bound(self) -> DoubleRangeBound:
        r"""
        (DoubleRangeBound):  [Read-Write] Holds the range's upper bound.
        """
        ...
    @upper_bound.setter
    def upper_bound(self, value: DoubleRangeBound) -> None:
        ...

class DoubleRangeBound(StructBase):
    r"""
    Defines a single bound for a range of values.
    note: This is a mirror of TRangeBound<double>, defined in RangeBound.h
    note: Fields are private to match the C++ declaration in the header above.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``type`` (RangeBoundTypes):  [Read-Write] Holds the type of the bound.
    - ``value`` (double):  [Read-Write] Holds the bound's value.
    """
    def __init__(self, type: RangeBoundTypes = RangeBoundTypes.EXCLUSIVE, value: float = 0.000000) -> None:
        ...
    @property
    def type(self) -> RangeBoundTypes:
        r"""
        (RangeBoundTypes):  [Read-Write] Holds the type of the bound.
        """
        ...
    @type.setter
    def type(self, value: RangeBoundTypes) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write] Holds the bound's value.
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class FilePath(StructBase):
    r"""
    Structure for file paths that are displayed in the editor with a picker UI.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``file_path`` (str):  [Read-Write] The path to the file.
    """
    def __init__(self, file_path: str = "") -> None:
        ...
    @property
    def file_path(self) -> str:
        r"""
        (str):  [Read-Write] The path to the file.
        """
        ...
    @file_path.setter
    def file_path(self, value: str) -> None:
        ...

class FloatInterval(StructBase):
    r"""
    An interval of floats, defined by inclusive min and max values
    note: This is a mirror of TInterval<float>, defined in Interval.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max`` (float):  [Read-Write] Values must be <= Max
    - ``min`` (float):  [Read-Write] Values must be >= Min
    """
    def __init__(self, min: float = 0.000000, max: float = 0.000000) -> None:
        ...
    @property
    def min(self) -> float:
        r"""
        (float):  [Read-Write] Values must be >= Min
        """
        ...
    @min.setter
    def min(self, value: float) -> None:
        ...
    @property
    def max(self) -> float:
        r"""
        (float):  [Read-Write] Values must be <= Max
        """
        ...
    @max.setter
    def max(self, value: float) -> None:
        ...

class FloatRange(StructBase):
    r"""
    A contiguous set of floats described by lower and upper bound values.
    note: This is a mirror of TRange<float>, defined in Range.h
    note: Fields are private to match the C++ declaration in the header above.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``lower_bound`` (FloatRangeBound):  [Read-Write] Holds the range's lower bound.
    - ``upper_bound`` (FloatRangeBound):  [Read-Write] Holds the range's upper bound.
    """
    def __init__(self, lower_bound: FloatRangeBound = [RangeBoundTypes.EXCLUSIVE, 0.000000], upper_bound: FloatRangeBound = [RangeBoundTypes.EXCLUSIVE, 0.000000]) -> None:
        ...
    @property
    def lower_bound(self) -> FloatRangeBound:
        r"""
        (FloatRangeBound):  [Read-Write] Holds the range's lower bound.
        """
        ...
    @lower_bound.setter
    def lower_bound(self, value: FloatRangeBound) -> None:
        ...
    @property
    def upper_bound(self) -> FloatRangeBound:
        r"""
        (FloatRangeBound):  [Read-Write] Holds the range's upper bound.
        """
        ...
    @upper_bound.setter
    def upper_bound(self, value: FloatRangeBound) -> None:
        ...

class FloatRangeBound(StructBase):
    r"""
    Defines a single bound for a range of values.
    note: This is a mirror of TRangeBound<float>, defined in RangeBound.h
    note: Fields are private to match the C++ declaration in the header above.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``type`` (RangeBoundTypes):  [Read-Write] Holds the type of the bound.
    - ``value`` (float):  [Read-Write] Holds the bound's value.
    """
    def __init__(self, type: RangeBoundTypes = RangeBoundTypes.EXCLUSIVE, value: float = 0.000000) -> None:
        ...
    @property
    def type(self) -> RangeBoundTypes:
        r"""
        (RangeBoundTypes):  [Read-Write] Holds the type of the bound.
        """
        ...
    @type.setter
    def type(self, value: RangeBoundTypes) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write] Holds the bound's value.
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class FrameNumber(StructBase):
    r"""
    A frame number value, representing discrete frames since the start of timing.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Misc\FrameNumber.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0) -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: int) -> None:
        ...
    def subtract_frame_number_integer(self, b: int) -> None:
        r"""
        x.subtract_frame_number_integer(b) -> None
        Subtraction (FrameNumber A - int B)
        
        Args:
            b (int32): 
        
        Returns:
            FrameNumber:
        """
        ...
    def subtract_frame_number_frame_number(self, b: FrameNumber) -> None:
        r"""
        x.subtract_frame_number_frame_number(b) -> None
        Subtraction (FrameNumber A - FrameNumber B)
        
        Args:
            b (FrameNumber): 
        
        Returns:
            FrameNumber:
        """
        ...
    def multiply_frame_number_integer(self, b: int) -> None:
        r"""
        x.multiply_frame_number_integer(b) -> None
        Multiply (FrameNumber A * B)
        
        Args:
            b (int32): 
        
        Returns:
            FrameNumber:
        """
        ...
    def divide_frame_number_integer(self, b: int) -> None:
        r"""
        x.divide_frame_number_integer(b) -> None
        Divide (FrameNumber A / B)
        
        Args:
            b (int32): 
        
        Returns:
            FrameNumber:
        """
        ...
    def add_frame_number_integer(self, b: int) -> None:
        r"""
        x.add_frame_number_integer(b) -> None
        Addition (FrameNumber A + int B)
        
        Args:
            b (int32): 
        
        Returns:
            FrameNumber:
        """
        ...
    def add_frame_number_frame_number(self, b: FrameNumber) -> None:
        r"""
        x.add_frame_number_frame_number(b) -> None
        Addition (FrameNumber A + FrameNumber B)
        
        Args:
            b (FrameNumber): 
        
        Returns:
            FrameNumber:
        """
        ...
    def __add__(self, other: FrameNumber) -> None:
        r"""
        **Overloads:**
        
        - ``int32`` Addition (FrameNumber A + int B)
        - ``FrameNumber`` Addition (FrameNumber A + FrameNumber B)
        """
        ...
    def __iadd__(self, other: FrameNumber) -> None:
        r"""
        **Overloads:**
        
        - ``int32`` Addition (FrameNumber A + int B)
        - ``FrameNumber`` Addition (FrameNumber A + FrameNumber B)
        """
        ...
    def __sub__(self, other: FrameNumber) -> None:
        r"""
        **Overloads:**
        
        - ``int32`` Subtraction (FrameNumber A - int B)
        - ``FrameNumber`` Subtraction (FrameNumber A - FrameNumber B)
        """
        ...
    def __isub__(self, other: FrameNumber) -> None:
        r"""
        **Overloads:**
        
        - ``int32`` Subtraction (FrameNumber A - int B)
        - ``FrameNumber`` Subtraction (FrameNumber A - FrameNumber B)
        """
        ...
    def __mul__(self, other: FrameNumber) -> None:
        r"""
        **Overloads:**
        
        - ``int32`` Multiply (FrameNumber A * B)
        """
        ...
    def __imul__(self, other: FrameNumber) -> None:
        r"""
        **Overloads:**
        
        - ``int32`` Multiply (FrameNumber A * B)
        """
        ...
    def __truediv__(self, other: FrameNumber) -> None:
        r"""
        **Overloads:**
        
        - ``int32`` Divide (FrameNumber A / B)
        """
        ...

class FrameNumberRange(StructBase):
    r"""
    A contiguous set of frame numbers described by lower and upper bound values.
    note: This is a mirror of TRange<FFrameNumber>, defined in Range.h
    note: Fields are private to match the C++ declaration in the header above.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``lower_bound`` (FrameNumberRangeBound):  [Read-Write]
    - ``upper_bound`` (FrameNumberRangeBound):  [Read-Write]
    """
    def __init__(self, lower_bound: FrameNumberRangeBound = [RangeBoundTypes.EXCLUSIVE, [0]], upper_bound: FrameNumberRangeBound = [RangeBoundTypes.EXCLUSIVE, [0]]) -> None:
        ...
    @property
    def lower_bound(self) -> FrameNumberRangeBound:
        r"""
        (FrameNumberRangeBound):  [Read-Write]
        """
        ...
    @lower_bound.setter
    def lower_bound(self, value: FrameNumberRangeBound) -> None:
        ...
    @property
    def upper_bound(self) -> FrameNumberRangeBound:
        r"""
        (FrameNumberRangeBound):  [Read-Write]
        """
        ...
    @upper_bound.setter
    def upper_bound(self, value: FrameNumberRangeBound) -> None:
        ...

class FrameNumberRangeBound(StructBase):
    r"""
    Defines a single bound for a range of frame numbers.
    note: This is a mirror of TRangeBound<FFrameNumber>, defined in RangeBound.h
    note: Fields are private to match the C++ declaration in the header above.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``type`` (RangeBoundTypes):  [Read-Write]
    - ``value`` (FrameNumber):  [Read-Write]
    """
    def __init__(self, type: RangeBoundTypes = RangeBoundTypes.EXCLUSIVE, value: FrameNumber = [0]) -> None:
        ...
    @property
    def type(self) -> RangeBoundTypes:
        r"""
        (RangeBoundTypes):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: RangeBoundTypes) -> None:
        ...
    @property
    def value(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: FrameNumber) -> None:
        ...

class FrameRate(StructBase):
    r"""
    A frame rate represented as a fraction comprising 2 integers: a numerator (number of frames), and a denominator (per second).
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Misc\FrameRate.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``denominator`` (int32):  [Read-Write] The denominator of the framerate represented as a number of frames per second (e.g. 1 for 60 fps)
    - ``numerator`` (int32):  [Read-Write] The numerator of the framerate represented as a number of frames per second (e.g. 60 for 60 fps)
    """
    def __init__(self, numerator: int = 0, denominator: int = 1) -> None:
        ...
    @property
    def numerator(self) -> int:
        r"""
        (int32):  [Read-Write] The numerator of the framerate represented as a number of frames per second (e.g. 60 for 60 fps)
        """
        ...
    @numerator.setter
    def numerator(self, value: int) -> None:
        ...
    @property
    def denominator(self) -> int:
        r"""
        (int32):  [Read-Write] The denominator of the framerate represented as a number of frames per second (e.g. 1 for 60 fps)
        """
        ...
    @denominator.setter
    def denominator(self, value: int) -> None:
        ...

class FrameTime(StructBase):
    r"""
    Represents a time by a context-free frame number, plus a sub frame value in the range [0:1).
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Misc\FrameTime.h
    note: The 'SubFrame' field is private to match its C++ class declaration in the header above.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_number`` (FrameNumber):  [Read-Write] Count of frames from start of timing
    - ``sub_frame`` (float):  [Read-Write] Time within a frame, always between >= 0 and < 1
    """
    def __init__(self, frame_number: FrameNumber = [0], sub_frame: float = 0.000000) -> None:
        ...
    @property
    def frame_number(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] Count of frames from start of timing
        """
        ...
    @frame_number.setter
    def frame_number(self, value: FrameNumber) -> None:
        ...
    @property
    def sub_frame(self) -> float:
        r"""
        (float):  [Read-Write] Time within a frame, always between >= 0 and < 1
        """
        ...
    @sub_frame.setter
    def sub_frame(self, value: float) -> None:
        ...

class InputDeviceId(StructBase):
    r"""
    Represents a single input device such as a gamepad, keyboard, or mouse.
    
    Has a globally unique identifier.
    
    Opaque struct for the FInputDeviceId struct defined in CoreMiscDefines.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``internal_id`` (int32):  [Read-Only]
    """
    def __init__(self) -> None:
        ...
    def not_equal(self, b: InputDeviceId) -> bool:
        r"""
        x.not_equal(b) -> bool
        Returns true if InputDeviceId A is not equal to InputDeviceId B (A != B)
        
        Args:
            b (InputDeviceId): 
        
        Returns:
            bool:
        """
        ...
    def equals(self, b: InputDeviceId) -> bool:
        r"""
        x.equals(b) -> bool
        Returns true if InputDeviceId A is equal to InputDeviceId B (A == B)
        
        Args:
            b (InputDeviceId): 
        
        Returns:
            bool:
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``InputDeviceId`` Returns true if InputDeviceId A is equal to InputDeviceId B (A == B)
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``InputDeviceId`` Returns true if InputDeviceId A is not equal to InputDeviceId B (A != B)
        """
        ...
    NONE: InputDeviceId #: (InputDeviceId): Static invalid input device

class Int32Interval(StructBase):
    r"""
    An interval of integers, defined by inclusive min and max values
    note: This is a mirror of TInterval<int32>, defined in Interval.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max`` (int32):  [Read-Write] Values must be <= Max
    - ``min`` (int32):  [Read-Write] Values must be >= Min
    """
    def __init__(self, min: int = 0, max: int = 0) -> None:
        ...
    @property
    def min(self) -> int:
        r"""
        (int32):  [Read-Write] Values must be >= Min
        """
        ...
    @min.setter
    def min(self, value: int) -> None:
        ...
    @property
    def max(self) -> int:
        r"""
        (int32):  [Read-Write] Values must be <= Max
        """
        ...
    @max.setter
    def max(self, value: int) -> None:
        ...

class Int32Range(StructBase):
    r"""
    A contiguous set of floats described by lower and upper bound values.
    note: This is a mirror of TRange<int32>, defined in Range.h
    note: Fields are private to match the C++ declaration in the header above.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``lower_bound`` (Int32RangeBound):  [Read-Write] Holds the range's lower bound.
    - ``upper_bound`` (Int32RangeBound):  [Read-Write] Holds the range's upper bound.
    """
    def __init__(self, lower_bound: Int32RangeBound = [RangeBoundTypes.EXCLUSIVE, 0], upper_bound: Int32RangeBound = [RangeBoundTypes.EXCLUSIVE, 0]) -> None:
        ...
    @property
    def lower_bound(self) -> Int32RangeBound:
        r"""
        (Int32RangeBound):  [Read-Write] Holds the range's lower bound.
        """
        ...
    @lower_bound.setter
    def lower_bound(self, value: Int32RangeBound) -> None:
        ...
    @property
    def upper_bound(self) -> Int32RangeBound:
        r"""
        (Int32RangeBound):  [Read-Write] Holds the range's upper bound.
        """
        ...
    @upper_bound.setter
    def upper_bound(self, value: Int32RangeBound) -> None:
        ...

class Int32RangeBound(StructBase):
    r"""
    Defines a single bound for a range of values.
    note: This is a mirror of TRangeBound<int32>, defined in RangeBound.h
    note: Fields are private to match the C++ declaration in the header above.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``type`` (RangeBoundTypes):  [Read-Write] Holds the type of the bound.
    - ``value`` (int32):  [Read-Write] Holds the bound's value.
    """
    def __init__(self, type: RangeBoundTypes = RangeBoundTypes.EXCLUSIVE, value: int = 0) -> None:
        ...
    @property
    def type(self) -> RangeBoundTypes:
        r"""
        (RangeBoundTypes):  [Read-Write] Holds the type of the bound.
        """
        ...
    @type.setter
    def type(self, value: RangeBoundTypes) -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Write] Holds the bound's value.
        """
        ...
    @value.setter
    def value(self, value: int) -> None:
        ...

class InterpCurveFloat(StructBase):
    r"""
    Describes an entire curve that is used to compute a float output value from a float input.
    note: This is a mirror of TInterpCurve<float>, defined in InterpCurve.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_looped`` (bool):  [Read-Write] Specify whether the curve is looped or not
    - ``loop_key_offset`` (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
    - ``points`` (Array[InterpCurvePointFloat]):  [Read-Write] Holds the collection of interpolation points.
    """
    def __init__(self, points: Array[InterpCurvePointFloat] = [], is_looped: bool = False, loop_key_offset: float = 0.000000) -> None:
        ...
    @property
    def points(self) -> Array[InterpCurvePointFloat]:
        r"""
        (Array[InterpCurvePointFloat]):  [Read-Write] Holds the collection of interpolation points.
        """
        ...
    @points.setter
    def points(self, value: Array[InterpCurvePointFloat]) -> None:
        ...
    @property
    def is_looped(self) -> bool:
        r"""
        (bool):  [Read-Write] Specify whether the curve is looped or not
        """
        ...
    @is_looped.setter
    def is_looped(self, value: bool) -> None:
        ...
    @property
    def loop_key_offset(self) -> float:
        r"""
        (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
        """
        ...
    @loop_key_offset.setter
    def loop_key_offset(self, value: float) -> None:
        ...

class InterpCurvePointFloat(StructBase):
    r"""
    Describes one specific point on an interpolation curve.
    note: This is a mirror of TInterpCurvePoint<float>, defined in InterpCurvePoint.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``arrive_tangent`` (float):  [Read-Write] Tangent of curve arriving at this point.
    - ``interp_mode`` (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
    - ``leave_tangent`` (float):  [Read-Write] Tangent of curve leaving this point.
    - ``out_val`` (float):  [Read-Write] Float output value type when input is equal to InVal.
    - ``val`` (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
    """
    def __init__(self, val: float = 0.000000, out_val: float = 0.000000, arrive_tangent: float = 0.000000, leave_tangent: float = 0.000000, interp_mode: InterpCurveMode = InterpCurveMode.CIM_LINEAR) -> None:
        ...
    @property
    def val(self) -> float:
        r"""
        (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
        """
        ...
    @val.setter
    def val(self, value: float) -> None:
        ...
    @property
    def out_val(self) -> float:
        r"""
        (float):  [Read-Write] Float output value type when input is equal to InVal.
        """
        ...
    @out_val.setter
    def out_val(self, value: float) -> None:
        ...
    @property
    def arrive_tangent(self) -> float:
        r"""
        (float):  [Read-Write] Tangent of curve arriving at this point.
        """
        ...
    @arrive_tangent.setter
    def arrive_tangent(self, value: float) -> None:
        ...
    @property
    def leave_tangent(self) -> float:
        r"""
        (float):  [Read-Write] Tangent of curve leaving this point.
        """
        ...
    @leave_tangent.setter
    def leave_tangent(self, value: float) -> None:
        ...
    @property
    def interp_mode(self) -> InterpCurveMode:
        r"""
        (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
        """
        ...
    @interp_mode.setter
    def interp_mode(self, value: InterpCurveMode) -> None:
        ...

class InterpCurveLinearColor(StructBase):
    r"""
    Describes an entire curve that is used to compute a color output value from a float input.
    note: This is a mirror of TInterpCurve<FLinearColor>, defined in InterpCurve.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_looped`` (bool):  [Read-Write] Specify whether the curve is looped or not
    - ``loop_key_offset`` (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
    - ``points`` (Array[InterpCurvePointLinearColor]):  [Read-Write] Holds the collection of interpolation points.
    """
    def __init__(self, points: Array[InterpCurvePointLinearColor] = [], is_looped: bool = False, loop_key_offset: float = 0.000000) -> None:
        ...
    @property
    def points(self) -> Array[InterpCurvePointLinearColor]:
        r"""
        (Array[InterpCurvePointLinearColor]):  [Read-Write] Holds the collection of interpolation points.
        """
        ...
    @points.setter
    def points(self, value: Array[InterpCurvePointLinearColor]) -> None:
        ...
    @property
    def is_looped(self) -> bool:
        r"""
        (bool):  [Read-Write] Specify whether the curve is looped or not
        """
        ...
    @is_looped.setter
    def is_looped(self, value: bool) -> None:
        ...
    @property
    def loop_key_offset(self) -> float:
        r"""
        (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
        """
        ...
    @loop_key_offset.setter
    def loop_key_offset(self, value: float) -> None:
        ...

class InterpCurvePointLinearColor(StructBase):
    r"""
    Describes one specific point on an interpolation curve.
    note: This is a mirror of TInterpCurvePoint<FLinearColor>, defined in InterpCurvePoint.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``arrive_tangent`` (LinearColor):  [Read-Write] Tangent of curve arriving at this point.
    - ``interp_mode`` (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
    - ``leave_tangent`` (LinearColor):  [Read-Write] Tangent of curve leaving this point.
    - ``out_val`` (LinearColor):  [Read-Write] Color output value of when input is equal to InVal.
    - ``val`` (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
    """
    def __init__(self, val: float = 0.000000, out_val: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], arrive_tangent: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], leave_tangent: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], interp_mode: InterpCurveMode = InterpCurveMode.CIM_LINEAR) -> None:
        ...
    @property
    def val(self) -> float:
        r"""
        (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
        """
        ...
    @val.setter
    def val(self, value: float) -> None:
        ...
    @property
    def out_val(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Color output value of when input is equal to InVal.
        """
        ...
    @out_val.setter
    def out_val(self, value: LinearColor) -> None:
        ...
    @property
    def arrive_tangent(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Tangent of curve arriving at this point.
        """
        ...
    @arrive_tangent.setter
    def arrive_tangent(self, value: LinearColor) -> None:
        ...
    @property
    def leave_tangent(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Tangent of curve leaving this point.
        """
        ...
    @leave_tangent.setter
    def leave_tangent(self, value: LinearColor) -> None:
        ...
    @property
    def interp_mode(self) -> InterpCurveMode:
        r"""
        (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
        """
        ...
    @interp_mode.setter
    def interp_mode(self, value: InterpCurveMode) -> None:
        ...

class LinearColor(StructBase):
    r"""
    A linear, 32-bit/component floating point RGBA color.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Color.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``g`` (float):  [Read-Write]
    - ``r`` (float):  [Read-Write]
    """
    def __init__(self, r: float = 0.000000, g: float = 0.000000, b: float = 0.000000, a: float = 0.000000) -> None:
        ...
    @property
    def r(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @r.setter
    def r(self, value: float) -> None:
        ...
    @property
    def g(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @g.setter
    def g(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    def subtract(self, b: LinearColor) -> LinearColor:
        r"""
        x.subtract(b) -> LinearColor
        Element-wise subtraction of two linear colors (R-R, G-G, B-B, A-A)
        
        Args:
            b (LinearColor): 
        
        Returns:
            LinearColor:
        """
        ...
    def rgb_into_hsv(self) -> LinearColor:
        r"""
        x.rgb_into_hsv() -> LinearColor
        Converts a RGB linear color to HSV (where H is in R (0..360), S is in G (0..1), and V is in B (0..1))
        
        Returns:
            LinearColor: 
        
            hsv (LinearColor):
        """
        ...
    def rgb_into_hsv_components(self) -> Tuple[float, float, float, float]:
        r"""
        x.rgb_into_hsv_components() -> (h=float, s=float, v=float, a=float)
        Breaks apart a color into individual HSV components (as well as alpha) (Hue is [0..360) while Saturation and Value are 0..1)
        
        Returns:
            tuple: 
        
            h (float): 
        
            s (float): 
        
            v (float): 
        
            a (float):
        """
        ...
    def rgb_to_hsv(self) -> LinearColor:
        r"""
        x.rgb_to_hsv() -> LinearColor
        Converts a RGB linear color to HSV (where H is in R, S is in G, and V is in B)
        
        Returns:
            LinearColor:
        """
        ...
    def not_equal(self, b: LinearColor) -> bool:
        r"""
        x.not_equal(b) -> bool
        Returns true if linear color A is not equal to linear color B (A != B) within a specified error tolerance
        
        Args:
            b (LinearColor): 
        
        Returns:
            bool:
        """
        ...
    def multiply(self, b: LinearColor) -> LinearColor:
        r"""
        x.multiply(b) -> LinearColor
        Element-wise multiplication of two linear colors (R*R, G*G, B*B, A*A)
        
        Args:
            b (LinearColor): 
        
        Returns:
            LinearColor:
        """
        ...
    def multiply_float(self, b: float) -> LinearColor:
        r"""
        x.multiply_float(b) -> LinearColor
        Element-wise multiplication of a linear color by a float (F*R, F*G, F*B, F*A)
        
        Args:
            b (float): 
        
        Returns:
            LinearColor:
        """
        ...
    def lerp_using_hsv_to(self, b: LinearColor, alpha: float) -> LinearColor:
        r"""
        x.lerp_using_hsv_to(b, alpha) -> LinearColor
        Linearly interpolates between two colors by the specified Alpha amount (100% of A when Alpha=0 and 100% of B when Alpha=1).  The interpolation is performed in HSV color space taking the shortest path to the new color's hue.  This can give better results than a normal lerp, but is much more expensive.  The incoming colors are in RGB space, and the output color will be RGB.  The alpha value will also be interpolated.
        
        Args:
            b (LinearColor): The color and alpha to interpolate to as linear RGBA
            alpha (float): Scalar interpolation amount (usually between 0.0 and 1.0 inclusive)
        
        Returns:
            LinearColor: The interpolated color in linear RGB space along with the interpolated alpha value
        """
        ...
    def lerp_to(self, b: LinearColor, alpha: float) -> LinearColor:
        r"""
        x.lerp_to(b, alpha) -> LinearColor
        Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)
        
        Args:
            b (LinearColor): 
            alpha (float): 
        
        Returns:
            LinearColor:
        """
        ...
    def to_rgbe(self) -> Color:
        r"""
        x.to_rgbe() -> Color
        Converts from linear to 8-bit RGBE as outlined in Gregory Ward's Real Pixels article, Graphics Gems II, page 80.
        
        Returns:
            Color:
        """
        ...
    def to_new_opacity(self, opacity: float) -> LinearColor:
        r"""
        x.to_new_opacity(opacity) -> LinearColor
        Returns a copy of this color using the specified opacity/alpha.
        
        Args:
            opacity (float): 
        
        Returns:
            LinearColor:
        """
        ...
    def set_temperature(self, temperature: float) -> None:
        r"""
        x.set_temperature(temperature) -> None
        Converts temperature in Kelvins of a black body radiator to RGB chromaticity.
        
        Args:
            temperature (float):
        """
        ...
    def set_rgba(self, r: float, g: float, b: float, a: float = 1.000000) -> None:
        r"""
        x.set_rgba(r, g, b, a=1.000000) -> None
        Assign individual linear RGBA components.
        
        Args:
            r (float): 
            g (float): 
            b (float): 
            a (float):
        """
        ...
    def set_random_hue(self) -> None:
        r"""
        x.set_random_hue() -> None
        Sets to a random color. Choses a quite nice color based on a random hue.
        """
        ...
    def set_from_srgb(self, srgb: Color) -> None:
        r"""
        x.set_from_srgb(srgb) -> None
        Assigns an FColor coming from an observed sRGB output, into a linear color.
        
        Args:
            srgb (Color): The sRGB color that needs to be converted into linear space.
        """
        ...
    def set_from_pow22(self, color: Color) -> None:
        r"""
        x.set_from_pow22(color) -> None
        Assigns an FColor coming from an observed Pow(1/2.2) output, into a linear color.
        
        Args:
            color (Color): The Pow(1/2.2) color that needs to be converted into linear space.
        """
        ...
    def set_from_hsv(self, h: float, s: float, v: float, a: float = 1.000000) -> None:
        r"""
        x.set_from_hsv(h, s, v, a=1.000000) -> None
        Assigns an HSV color to a linear space RGB color
        
        Args:
            h (float): 
            s (float): 
            v (float): 
            a (float):
        """
        ...
    def set(self, color: LinearColor) -> None:
        r"""
        x.set(color) -> None
        Assign contents of InColor
        
        Args:
            color (LinearColor):
        """
        ...
    def quantize_round(self) -> Color:
        r"""
        x.quantize_round() -> Color
        Quantizes the linear color with rounding and returns the result as an 8-bit color.  This bypasses the SRGB conversion.
        
        Returns:
            Color:
        """
        ...
    def quantize(self) -> Color:
        r"""
        x.quantize() -> Color
        Quantizes the linear color and returns the result as an 8-bit color.  This bypasses the SRGB conversion.
        deprecated: Use LinearColor_QuantizeRound instead for correct color conversion.
        
        Returns:
            Color:
        """
        ...
    def is_near_equal(self, b: LinearColor, tolerance: float = 0.000100) -> bool:
        r"""
        x.is_near_equal(b, tolerance=0.000100) -> bool
        Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance
        
        Args:
            b (LinearColor): 
            tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    def get_min(self) -> float:
        r"""
        x.get_min() -> float
        Returns the minimum color channel value in this color structure
        
        Returns:
            float: The minimum color channel value
        """
        ...
    def get_max(self) -> float:
        r"""
        x.get_max() -> float
        Returns the maximum color channel value in this color structure
        
        Returns:
            float: The maximum color channel value
        """
        ...
    def get_luminance(self) -> float:
        r"""
        x.get_luminance() -> float
        Returns the perceived brightness of a color on a display taking into account the impact on the human eye per color channel: green > red > blue.
        
        Returns:
            float:
        """
        ...
    def distance(self, c2: LinearColor) -> float:
        r"""
        x.distance(c2) -> float
        Euclidean distance between two color points.
        
        Args:
            c2 (LinearColor): 
        
        Returns:
            float:
        """
        ...
    def desaturated(self, desaturation: float) -> LinearColor:
        r"""
        x.desaturated(desaturation) -> LinearColor
        Returns a desaturated color, with 0 meaning no desaturation and 1 == full desaturation
        
        Args:
            desaturation (float): 
        
        Returns:
            LinearColor: Desaturated color
        """
        ...
    def hsv_to_rgb(self) -> LinearColor:
        r"""
        x.hsv_to_rgb() -> LinearColor
        Converts a HSV linear color (where H is in R, S is in G, and V is in B) to linear RGB
        
        Returns:
            LinearColor:
        """
        ...
    def hsv_into_rgb(self) -> LinearColor:
        r"""
        x.hsv_into_rgb() -> LinearColor
        Converts a HSV linear color (where H is in R (0..360), S is in G (0..1), and V is in B (0..1)) to RGB
        
        Returns:
            LinearColor: 
        
            rgb (LinearColor):
        """
        ...
    def equals(self, b: LinearColor) -> bool:
        r"""
        x.equals(b) -> bool
        Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance
        
        Args:
            b (LinearColor): 
        
        Returns:
            bool:
        """
        ...
    def divide(self, b: LinearColor) -> LinearColor:
        r"""
        x.divide(b) -> LinearColor
        Element-wise multiplication of two linear colors (R/R, G/G, B/B, A/A)
        
        Args:
            b (LinearColor): 
        
        Returns:
            LinearColor:
        """
        ...
    def to_rgb_vector(self) -> Vector:
        r"""
        x.to_rgb_vector() -> Vector
        Converts a LinearColor to a vector
        
        Returns:
            Vector:
        """
        ...
    def to_color(self, use_srgb: bool = True) -> Color:
        r"""
        x.to_color(use_srgb=True) -> Color
        Quantizes the linear color and returns the result as a FColor with optional sRGB conversion and quality as goal.
        
        Args:
            use_srgb (bool): 
        
        Returns:
            Color:
        """
        ...
    def interpolate_to(self, target: LinearColor, delta_time: float, interp_speed: float) -> LinearColor:
        r"""
        x.interpolate_to(target, delta_time, interp_speed) -> LinearColor
        Interpolate Linear Color from Current to Target. Scaled by distance to Target, so it has a strong start speed and ease out.
        
        Args:
            target (LinearColor): Target Color
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed, if the speed given is 0, then jump to the target.
        
        Returns:
            LinearColor: New interpolated Color
        """
        ...
    def add(self, b: LinearColor) -> LinearColor:
        r"""
        x.add(b) -> LinearColor
        Element-wise addition of two linear colors (R+R, G+G, B+B, A+A)
        
        Args:
            b (LinearColor): 
        
        Returns:
            LinearColor:
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``LinearColor`` Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance
        - ``LinearColor`` Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``LinearColor`` Returns true if linear color A is not equal to linear color B (A != B) within a specified error tolerance
        """
        ...
    def __add__(self, other: LinearColor) -> None:
        r"""
        **Overloads:**
        
        - ``LinearColor`` Element-wise addition of two linear colors (R+R, G+G, B+B, A+A)
        """
        ...
    def __iadd__(self, other: LinearColor) -> None:
        r"""
        **Overloads:**
        
        - ``LinearColor`` Element-wise addition of two linear colors (R+R, G+G, B+B, A+A)
        """
        ...
    def __sub__(self, other: LinearColor) -> None:
        r"""
        **Overloads:**
        
        - ``LinearColor`` Element-wise subtraction of two linear colors (R-R, G-G, B-B, A-A)
        """
        ...
    def __isub__(self, other: LinearColor) -> None:
        r"""
        **Overloads:**
        
        - ``LinearColor`` Element-wise subtraction of two linear colors (R-R, G-G, B-B, A-A)
        """
        ...
    def __mul__(self, other: LinearColor) -> None:
        r"""
        **Overloads:**
        
        - ``LinearColor`` Element-wise multiplication of two linear colors (R*R, G*G, B*B, A*A)
        """
        ...
    def __imul__(self, other: LinearColor) -> None:
        r"""
        **Overloads:**
        
        - ``LinearColor`` Element-wise multiplication of two linear colors (R*R, G*G, B*B, A*A)
        """
        ...
    def __truediv__(self, other: LinearColor) -> None:
        r"""
        **Overloads:**
        
        - ``LinearColor`` Element-wise multiplication of two linear colors (R/R, G/G, B/B, A/A)
        """
        ...
    YELLOW: LinearColor #: (LinearColor): Yellow linear color
    WHITE: LinearColor #: (LinearColor): White linear color
    TRANSPARENT: LinearColor #: (LinearColor): Transparent linear color - black with 0 opacity/alpha
    RED: LinearColor #: (LinearColor): Red linear color
    GREEN: LinearColor #: (LinearColor): Green linear color
    GRAY: LinearColor #: (LinearColor): Grey linear color
    BLUE: LinearColor #: (LinearColor): Blue linear color
    BLACK: LinearColor #: (LinearColor): Black linear color

class InterpCurvePointQuat(StructBase):
    r"""
    Describes one specific point on an interpolation curve.
    note: This is a mirror of TInterpCurvePoint<FQuat>, defined in InterpCurvePoint.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``arrive_tangent`` (Quat):  [Read-Write] Tangent of curve arriving at this point.
    - ``interp_mode`` (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
    - ``leave_tangent`` (Quat):  [Read-Write] Tangent of curve leaving this point.
    - ``out_val`` (Quat):  [Read-Write] Quaternion output value of when input is equal to InVal.
    - ``val`` (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
    """
    def __init__(self, val: float = 0.000000, out_val: Quat = [0.000000, 0.000000, 0.000000, 1.000000], arrive_tangent: Quat = [0.000000, 0.000000, 0.000000, 1.000000], leave_tangent: Quat = [0.000000, 0.000000, 0.000000, 1.000000], interp_mode: InterpCurveMode = InterpCurveMode.CIM_LINEAR) -> None:
        ...
    @property
    def val(self) -> float:
        r"""
        (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
        """
        ...
    @val.setter
    def val(self, value: float) -> None:
        ...
    @property
    def out_val(self) -> Quat:
        r"""
        (Quat):  [Read-Write] Quaternion output value of when input is equal to InVal.
        """
        ...
    @out_val.setter
    def out_val(self, value: Quat) -> None:
        ...
    @property
    def arrive_tangent(self) -> Quat:
        r"""
        (Quat):  [Read-Write] Tangent of curve arriving at this point.
        """
        ...
    @arrive_tangent.setter
    def arrive_tangent(self, value: Quat) -> None:
        ...
    @property
    def leave_tangent(self) -> Quat:
        r"""
        (Quat):  [Read-Write] Tangent of curve leaving this point.
        """
        ...
    @leave_tangent.setter
    def leave_tangent(self, value: Quat) -> None:
        ...
    @property
    def interp_mode(self) -> InterpCurveMode:
        r"""
        (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
        """
        ...
    @interp_mode.setter
    def interp_mode(self, value: InterpCurveMode) -> None:
        ...

class Quat(StructBase):
    r"""
    Quaternion.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Quat.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``w`` (double):  [Read-Write]
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    - ``z`` (double):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000, w: float = 0.000000) -> None:
        ...
    @property
    def x(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: float) -> None:
        ...
    @property
    def y(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: float) -> None:
        ...
    @property
    def z(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: float) -> None:
        ...
    @property
    def w(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @w.setter
    def w(self, value: float) -> None:
        ...
    def subtract(self, b: Quat) -> Quat:
        r"""
        x.subtract(b) -> Quat
        Returns subtraction of Vector B from Vector A (A - B)
        
        Args:
            b (Quat): 
        
        Returns:
            Quat:
        """
        ...
    def interp_spring_to(self, target: Quat, spring_state: QuaternionSpringState, stiffness: float, critical_damping_factor: float, delta_time: float, mass: float = 1.000000, target_velocity_amount: float = 1.000000, initialize_from_target: bool = False) -> Tuple[Quat, QuaternionSpringState]:
        r"""
        x.interp_spring_to(target, spring_state, stiffness, critical_damping_factor, delta_time, mass=1.000000, target_velocity_amount=1.000000, initialize_from_target=False) -> (Quat, spring_state=QuaternionSpringState)
        Uses a simple spring model to interpolate a quaternion from Current to Target.
        
        Args:
            target (Quat): Target value
            spring_state (QuaternionSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
            stiffness (float): How stiff the spring model is (more stiffness means more oscillation around the target value)
            critical_damping_factor (float): How much damping to apply to the spring (0 means no damping, 1 means critically damped which means no oscillation)
            delta_time (float): Time difference since the last update
            mass (float): Multiplier that acts like mass on a spring
            target_velocity_amount (float): If 1 then the target velocity will be calculated and used, which results following the target more closely/without lag. Values down to zero (recommended when using this to smooth data) will progressively disable this effect.
            initialize_from_target (bool): If set then the current value will be set from the target on the first update
        
        Returns:
            QuaternionSpringState: 
        
            spring_state (QuaternionSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
        """
        ...
    def vector_up(self) -> Vector:
        r"""
        x.vector_up() -> Vector
        Get the up direction (Z axis) after it has been rotated by this Quaternion.
        
        Returns:
            Vector:
        """
        ...
    def vector_right(self) -> Vector:
        r"""
        x.vector_right() -> Vector
        Get the right direction (Y axis) after it has been rotated by this Quaternion.
        
        Returns:
            Vector:
        """
        ...
    def vector_forward(self) -> Vector:
        r"""
        x.vector_forward() -> Vector
        Get the forward direction (X axis) after it has been rotated by this Quaternion.
        
        Returns:
            Vector:
        """
        ...
    def unrotate_vector(self, v: Vector) -> Vector:
        r"""
        x.unrotate_vector(v) -> Vector
        Rotate a vector by the inverse of this quaternion.
        
        Args:
            v (Vector): the vector to be rotated
        
        Returns:
            Vector: vector after rotation by the inverse of this quaternion.
        """
        ...
    def slerp_quat(self, b: Quat, alpha: float) -> Quat:
        r"""
        x.slerp_quat(b, alpha) -> Quat
        Spherical interpolation between Quaternions. Result is normalized.
        
        Args:
            b (Quat): The target quat we interp to
            alpha (double): The interpolation amount, usually 0 to 1.
        
        Returns:
            Quat: Quat after spherical interpolation
        """
        ...
    def size_squared(self) -> float:
        r"""
        x.size_squared() -> float
        Get the squared length of the quaternion.
        
        Returns:
            float: The squared length of the quaternion.
        """
        ...
    def size(self) -> float:
        r"""
        x.size() -> float
        Get the length of the quaternion.
        
        Returns:
            float: The length of the quaternion.
        """
        ...
    def set_from_euler(self, euler: Vector) -> None:
        r"""
        x.set_from_euler(euler) -> None
        Convert a vector of floating-point Euler angles (in degrees) into a Quaternion.
        
        Args:
            euler (Vector): the Euler angles
        """
        ...
    def set_components(self, x: float, y: float, z: float, w: float) -> None:
        r"""
        x.set_components(x, y, z, w) -> None
        Set X, Y, Z, W components of Quaternion.
        
        Args:
            x (float): 
            y (float): 
            z (float): 
            w (float):
        """
        ...
    def rotator(self) -> Rotator:
        r"""
        x.rotator() -> Rotator
        Converts to Rotator representation of this Quaternion.
        
        Returns:
            Rotator:
        """
        ...
    def rotate_vector(self, v: Vector) -> Vector:
        r"""
        x.rotate_vector(v) -> Vector
        Rotate a vector by this quaternion.
        
        Args:
            v (Vector): the vector to be rotated
        
        Returns:
            Vector: vector after rotation
        """
        ...
    def normalized(self, tolerance: float = 0.000100) -> Quat:
        r"""
        x.normalized(tolerance=0.000100) -> Quat
        Get a normalized copy of this quaternion.
        If it is too small, returns an identity quaternion.
        
        Args:
            tolerance (float): Minimum squared length of quaternion for normalization.
        
        Returns:
            Quat:
        """
        ...
    def normalize(self, tolerance: float = 0.000100) -> None:
        r"""
        x.normalize(tolerance=0.000100) -> None
        Normalize this quaternion if it is large enough as compared to the supplied tolerance.
        If it is too small then set it to the identity quaternion.
        
        Args:
            tolerance (float): Minimum squared length of quaternion for normalization.
        """
        ...
    def log(self) -> Quat:
        r"""
        x.log() -> Quat
        Quaternion with W=0 and V=theta*v. Used in combination with Exp().
        
        Returns:
            Quat:
        """
        ...
    def is_normalized(self) -> bool:
        r"""
        x.is_normalized() -> bool
        Return true if this quaternion is normalized
        
        Returns:
            bool:
        """
        ...
    def is_non_finite(self) -> bool:
        r"""
        x.is_non_finite() -> bool
        Determine if there are any non-finite values (NaN or Inf) in this Quat.
        
        Returns:
            bool:
        """
        ...
    def is_identity(self, tolerance: float = 0.000100) -> bool:
        r"""
        x.is_identity(tolerance=0.000100) -> bool
        Checks whether this Quaternion is an Identity Quaternion.
        Assumes Quaternion tested is normalized.
        
        Args:
            tolerance (float): Error tolerance for comparison with Identity Quaternion.
        
        Returns:
            bool: true if Quaternion is a normalized Identity Quaternion.
        """
        ...
    def is_finite(self) -> bool:
        r"""
        x.is_finite() -> bool
        Determine if all the values  are finite (not NaN nor Inf) in this Quat.
        
        Returns:
            bool:
        """
        ...
    def inversed(self) -> Quat:
        r"""
        x.inversed() -> Quat
        Return an inversed copy of this quaternion.
        
        Returns:
            Quat:
        """
        ...
    def get_rotation_axis(self) -> Vector:
        r"""
        x.get_rotation_axis() -> Vector
        Get the axis of rotation of the Quaternion.
        This is the axis around which rotation occurs to transform the canonical coordinate system to the target orientation.
        For the identity Quaternion which has no such rotation, FVector(1,0,0) is returned.
        
        Returns:
            Vector:
        """
        ...
    def get_axis_z(self) -> Vector:
        r"""
        x.get_axis_z() -> Vector
        Get the up direction (Z axis) after it has been rotated by this Quaternion.
        
        Returns:
            Vector:
        """
        ...
    def get_axis_y(self) -> Vector:
        r"""
        x.get_axis_y() -> Vector
        Get the right direction (Y axis) after it has been rotated by this Quaternion.
        
        Returns:
            Vector:
        """
        ...
    def get_axis_x(self) -> Vector:
        r"""
        x.get_axis_x() -> Vector
        Get the forward direction (X axis) after it has been rotated by this Quaternion.
        
        Returns:
            Vector:
        """
        ...
    def get_angle(self) -> float:
        r"""
        x.get_angle() -> float
        Get the angle of this quaternion
        
        Returns:
            float:
        """
        ...
    def exp(self) -> Quat:
        r"""
        x.exp() -> Quat
        Used in combination with Log().
        Assumes a quaternion with W=0 and V=theta*v (where |v| = 1).
        Exp(q) = (sin(theta)*v, cos(theta))
        
        Returns:
            Quat:
        """
        ...
    def euler(self) -> Vector:
        r"""
        x.euler() -> Vector
        Convert a Quaternion into floating-point Euler angles (in degrees).
        
        Returns:
            Vector:
        """
        ...
    def ensure_shortest_arc_to(self, b: Quat) -> None:
        r"""
        x.ensure_shortest_arc_to(b) -> None
        Modify the quaternion to ensure that the delta between it and B represents the shortest possible rotation angle.
        
        Args:
            b (Quat):
        """
        ...
    def angular_distance(self, b: Quat) -> float:
        r"""
        x.angular_distance(b) -> float
        Find the angular distance/difference between two rotation quaternions.
        
        Args:
            b (Quat): Quaternion to find angle distance to
        
        Returns:
            float: angular distance in radians
        """
        ...
    def not_equal(self, b: Quat, error_tolerance: float = 0.000100) -> bool:
        r"""
        x.not_equal(b, error_tolerance=0.000100) -> bool
        Returns true if Quat A is not equal to Quat B (A != B) within a specified error tolerance
        
        Args:
            b (Quat): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    def multiply(self, b: Quat) -> Quat:
        r"""
        x.multiply(b) -> Quat
        Gets the result of multiplying two quaternions (A * B).
        
        Order matters when composing quaternions: C = A * B will yield a quaternion C that logically
        first applies B then A to any subsequent transformation (right first, then left).
        
        Args:
            b (Quat): The Quaternion to multiply by.
        
        Returns:
            Quat: The result of multiplication (A * B).
        """
        ...
    def equals(self, b: Quat, tolerance: float = 0.000100) -> bool:
        r"""
        x.equals(b, tolerance=0.000100) -> bool
        Returns true if Quaternion A is equal to Quaternion B (A == B) within a specified error tolerance
        
        Args:
            b (Quat): 
            tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    def add(self, b: Quat) -> Quat:
        r"""
        x.add(b) -> Quat
        Returns addition of Vector A and Vector B (A + B)
        
        Args:
            b (Quat): 
        
        Returns:
            Quat:
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Quat`` Returns true if Quaternion A is equal to Quaternion B (A == B) within a specified error tolerance
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Quat`` Returns true if Quat A is not equal to Quat B (A != B) within a specified error tolerance
        """
        ...
    def __add__(self, other: Quat) -> None:
        r"""
        **Overloads:**
        
        - ``Quat`` Returns addition of Vector A and Vector B (A + B)
        """
        ...
    def __iadd__(self, other: Quat) -> None:
        r"""
        **Overloads:**
        
        - ``Quat`` Returns addition of Vector A and Vector B (A + B)
        """
        ...
    def __sub__(self, other: Quat) -> None:
        r"""
        **Overloads:**
        
        - ``Quat`` Returns subtraction of Vector B from Vector A (A - B)
        """
        ...
    def __isub__(self, other: Quat) -> None:
        r"""
        **Overloads:**
        
        - ``Quat`` Returns subtraction of Vector B from Vector A (A - B)
        """
        ...
    def __mul__(self, other: Quat) -> None:
        r"""
        **Overloads:**
        
        - ``Quat`` Gets the result of multiplying two quaternions (A * B).
          
          Order matters when composing quaternions: C = A * B will yield a quaternion C that logically
          first applies B then A to any subsequent transformation (right first, then left).
          
          @param B The Quaternion to multiply by.
          @return The result of multiplication (A * B).
        """
        ...
    def __imul__(self, other: Quat) -> None:
        r"""
        **Overloads:**
        
        - ``Quat`` Gets the result of multiplying two quaternions (A * B).
          
          Order matters when composing quaternions: C = A * B will yield a quaternion C that logically
          first applies B then A to any subsequent transformation (right first, then left).
          
          @param B The Quaternion to multiply by.
          @return The result of multiplication (A * B).
        """
        ...
    IDENTITY: Quat #: (Quat): Identity quaternion constant

class InterpCurvePointTwoVectors(StructBase):
    r"""
    Describes one specific point on an interpolation curve.
    note: This is a mirror of TInterpCurvePoint<FTwoVectors>, defined in InterpCurvePoint.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``arrive_tangent`` (TwoVectors):  [Read-Write] Tangent of curve arriving at this point.
    - ``interp_mode`` (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
    - ``leave_tangent`` (TwoVectors):  [Read-Write] Tangent of curve leaving this point.
    - ``out_val`` (TwoVectors):  [Read-Write] Two 3D vectors output value of when input is equal to InVal.
    - ``val`` (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
    """
    def __init__(self, val: float = 0.000000, out_val: TwoVectors = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], arrive_tangent: TwoVectors = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], leave_tangent: TwoVectors = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], interp_mode: InterpCurveMode = InterpCurveMode.CIM_LINEAR) -> None:
        ...
    @property
    def val(self) -> float:
        r"""
        (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
        """
        ...
    @val.setter
    def val(self, value: float) -> None:
        ...
    @property
    def out_val(self) -> TwoVectors:
        r"""
        (TwoVectors):  [Read-Write] Two 3D vectors output value of when input is equal to InVal.
        """
        ...
    @out_val.setter
    def out_val(self, value: TwoVectors) -> None:
        ...
    @property
    def arrive_tangent(self) -> TwoVectors:
        r"""
        (TwoVectors):  [Read-Write] Tangent of curve arriving at this point.
        """
        ...
    @arrive_tangent.setter
    def arrive_tangent(self, value: TwoVectors) -> None:
        ...
    @property
    def leave_tangent(self) -> TwoVectors:
        r"""
        (TwoVectors):  [Read-Write] Tangent of curve leaving this point.
        """
        ...
    @leave_tangent.setter
    def leave_tangent(self, value: TwoVectors) -> None:
        ...
    @property
    def interp_mode(self) -> InterpCurveMode:
        r"""
        (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
        """
        ...
    @interp_mode.setter
    def interp_mode(self, value: InterpCurveMode) -> None:
        ...

class TwoVectors(StructBase):
    r"""
    A pair of 3D vectors (mirrored from TwoVectors.h).
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``v1`` (Vector):  [Read-Write]
    - ``v2`` (Vector):  [Read-Write]
    """
    def __init__(self, v1: Vector = [0.000000, 0.000000, 0.000000], v2: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def v1(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @v1.setter
    def v1(self, value: Vector) -> None:
        ...
    @property
    def v2(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @v2.setter
    def v2(self, value: Vector) -> None:
        ...

class InterpCurvePointVector(StructBase):
    r"""
    Describes one specific point on an interpolation curve.
    note: This is a mirror of TInterpCurvePoint<FVector>, defined in InterpCurvePoint.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``arrive_tangent`` (Vector):  [Read-Write] Tangent of curve arriving at this point.
    - ``interp_mode`` (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
    - ``leave_tangent`` (Vector):  [Read-Write] Tangent of curve leaving this point.
    - ``out_val`` (Vector):  [Read-Write] 3D vector output value of when input is equal to InVal.
    - ``val`` (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
    """
    def __init__(self, val: float = 0.000000, out_val: Vector = [0.000000, 0.000000, 0.000000], arrive_tangent: Vector = [0.000000, 0.000000, 0.000000], leave_tangent: Vector = [0.000000, 0.000000, 0.000000], interp_mode: InterpCurveMode = InterpCurveMode.CIM_LINEAR) -> None:
        ...
    @property
    def val(self) -> float:
        r"""
        (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
        """
        ...
    @val.setter
    def val(self, value: float) -> None:
        ...
    @property
    def out_val(self) -> Vector:
        r"""
        (Vector):  [Read-Write] 3D vector output value of when input is equal to InVal.
        """
        ...
    @out_val.setter
    def out_val(self, value: Vector) -> None:
        ...
    @property
    def arrive_tangent(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Tangent of curve arriving at this point.
        """
        ...
    @arrive_tangent.setter
    def arrive_tangent(self, value: Vector) -> None:
        ...
    @property
    def leave_tangent(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Tangent of curve leaving this point.
        """
        ...
    @leave_tangent.setter
    def leave_tangent(self, value: Vector) -> None:
        ...
    @property
    def interp_mode(self) -> InterpCurveMode:
        r"""
        (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
        """
        ...
    @interp_mode.setter
    def interp_mode(self, value: InterpCurveMode) -> None:
        ...

class InterpCurvePointVector2D(StructBase):
    r"""
    Describes one specific point on an interpolation curve.
    note: This is a mirror of TInterpCurvePoint<FVector2D>, defined in InterpCurvePoint.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``arrive_tangent`` (Vector2D):  [Read-Write] Tangent of curve arriving at this point.
    - ``interp_mode`` (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
    - ``leave_tangent`` (Vector2D):  [Read-Write] Tangent of curve leaving this point.
    - ``out_val`` (Vector2D):  [Read-Write] 2D vector output value of when input is equal to InVal.
    - ``val`` (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
    """
    def __init__(self, val: float = 0.000000, out_val: Vector2D = [0.000000, 0.000000], arrive_tangent: Vector2D = [0.000000, 0.000000], leave_tangent: Vector2D = [0.000000, 0.000000], interp_mode: InterpCurveMode = InterpCurveMode.CIM_LINEAR) -> None:
        ...
    @property
    def val(self) -> float:
        r"""
        (float):  [Read-Write] Float input value that corresponds to this key (eg. time).
        """
        ...
    @val.setter
    def val(self, value: float) -> None:
        ...
    @property
    def out_val(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] 2D vector output value of when input is equal to InVal.
        """
        ...
    @out_val.setter
    def out_val(self, value: Vector2D) -> None:
        ...
    @property
    def arrive_tangent(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Tangent of curve arriving at this point.
        """
        ...
    @arrive_tangent.setter
    def arrive_tangent(self, value: Vector2D) -> None:
        ...
    @property
    def leave_tangent(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Tangent of curve leaving this point.
        """
        ...
    @leave_tangent.setter
    def leave_tangent(self, value: Vector2D) -> None:
        ...
    @property
    def interp_mode(self) -> InterpCurveMode:
        r"""
        (InterpCurveMode):  [Read-Write] Interpolation mode between this point and the next one.
        """
        ...
    @interp_mode.setter
    def interp_mode(self, value: InterpCurveMode) -> None:
        ...

class InterpCurveQuat(StructBase):
    r"""
    Describes an entire curve that is used to compute a quaternion output value from a float input.
    note: This is a mirror of TInterpCurve<FQuat>, defined in InterpCurve.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_looped`` (bool):  [Read-Write] Specify whether the curve is looped or not
    - ``loop_key_offset`` (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
    - ``points`` (Array[InterpCurvePointQuat]):  [Read-Write] Holds the collection of interpolation points.
    """
    def __init__(self, points: Array[InterpCurvePointQuat] = [], is_looped: bool = False, loop_key_offset: float = 0.000000) -> None:
        ...
    @property
    def points(self) -> Array[InterpCurvePointQuat]:
        r"""
        (Array[InterpCurvePointQuat]):  [Read-Write] Holds the collection of interpolation points.
        """
        ...
    @points.setter
    def points(self, value: Array[InterpCurvePointQuat]) -> None:
        ...
    @property
    def is_looped(self) -> bool:
        r"""
        (bool):  [Read-Write] Specify whether the curve is looped or not
        """
        ...
    @is_looped.setter
    def is_looped(self, value: bool) -> None:
        ...
    @property
    def loop_key_offset(self) -> float:
        r"""
        (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
        """
        ...
    @loop_key_offset.setter
    def loop_key_offset(self, value: float) -> None:
        ...

class InterpCurveTwoVectors(StructBase):
    r"""
    Describes an entire curve that is used to compute two 3D vector values from a float input.
    note: This is a mirror of TInterpCurve<FTwoVectors>, defined in InterpCurve.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_looped`` (bool):  [Read-Write] Specify whether the curve is looped or not
    - ``loop_key_offset`` (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
    - ``points`` (Array[InterpCurvePointTwoVectors]):  [Read-Write] Holds the collection of interpolation points.
    """
    def __init__(self, points: Array[InterpCurvePointTwoVectors] = [], is_looped: bool = False, loop_key_offset: float = 0.000000) -> None:
        ...
    @property
    def points(self) -> Array[InterpCurvePointTwoVectors]:
        r"""
        (Array[InterpCurvePointTwoVectors]):  [Read-Write] Holds the collection of interpolation points.
        """
        ...
    @points.setter
    def points(self, value: Array[InterpCurvePointTwoVectors]) -> None:
        ...
    @property
    def is_looped(self) -> bool:
        r"""
        (bool):  [Read-Write] Specify whether the curve is looped or not
        """
        ...
    @is_looped.setter
    def is_looped(self, value: bool) -> None:
        ...
    @property
    def loop_key_offset(self) -> float:
        r"""
        (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
        """
        ...
    @loop_key_offset.setter
    def loop_key_offset(self, value: float) -> None:
        ...

class InterpCurveVector(StructBase):
    r"""
    Describes an entire curve that is used to compute a 3D vector output value from a float input.
    note: This is a mirror of TInterpCurve<FVector>, defined in InterpCurve.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_looped`` (bool):  [Read-Write] Specify whether the curve is looped or not
    - ``loop_key_offset`` (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
    - ``points`` (Array[InterpCurvePointVector]):  [Read-Write] Holds the collection of interpolation points.
    """
    def __init__(self, points: Array[InterpCurvePointVector] = [], is_looped: bool = False, loop_key_offset: float = 0.000000) -> None:
        ...
    @property
    def points(self) -> Array[InterpCurvePointVector]:
        r"""
        (Array[InterpCurvePointVector]):  [Read-Write] Holds the collection of interpolation points.
        """
        ...
    @points.setter
    def points(self, value: Array[InterpCurvePointVector]) -> None:
        ...
    @property
    def is_looped(self) -> bool:
        r"""
        (bool):  [Read-Write] Specify whether the curve is looped or not
        """
        ...
    @is_looped.setter
    def is_looped(self, value: bool) -> None:
        ...
    @property
    def loop_key_offset(self) -> float:
        r"""
        (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
        """
        ...
    @loop_key_offset.setter
    def loop_key_offset(self, value: float) -> None:
        ...

class InterpCurveVector2D(StructBase):
    r"""
    Describes an entire curve that is used to compute a 2D vector output value from a float input.
    note: This is a mirror of TInterpCurve<FVector2D>, defined in InterpCurve.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_looped`` (bool):  [Read-Write] Specify whether the curve is looped or not
    - ``loop_key_offset`` (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
    - ``points`` (Array[InterpCurvePointVector2D]):  [Read-Write] Holds the collection of interpolation points.
    """
    def __init__(self, points: Array[InterpCurvePointVector2D] = [], is_looped: bool = False, loop_key_offset: float = 0.000000) -> None:
        ...
    @property
    def points(self) -> Array[InterpCurvePointVector2D]:
        r"""
        (Array[InterpCurvePointVector2D]):  [Read-Write] Holds the collection of interpolation points.
        """
        ...
    @points.setter
    def points(self, value: Array[InterpCurvePointVector2D]) -> None:
        ...
    @property
    def is_looped(self) -> bool:
        r"""
        (bool):  [Read-Write] Specify whether the curve is looped or not
        """
        ...
    @is_looped.setter
    def is_looped(self, value: bool) -> None:
        ...
    @property
    def loop_key_offset(self) -> float:
        r"""
        (float):  [Read-Write] Specify the offset from the last point's input key corresponding to the loop point
        """
        ...
    @loop_key_offset.setter
    def loop_key_offset(self, value: float) -> None:
        ...

class IntPoint(StructBase):
    r"""
    Screen coordinates.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\IntPoint.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (int32):  [Read-Write]
    - ``y`` (int32):  [Read-Write]
    """
    def __init__(self, x: int = 0, y: int = 0) -> None:
        ...
    @property
    def x(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: int) -> None:
        ...
    @property
    def y(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: int) -> None:
        ...
    def subtract(self, b: IntPoint) -> IntPoint:
        r"""
        x.subtract(b) -> IntPoint
        Returns IntPoint A subtracted by B
        
        Args:
            b (IntPoint): 
        
        Returns:
            IntPoint:
        """
        ...
    def subtract_int(self, b: int) -> IntPoint:
        r"""
        x.subtract_int(b) -> IntPoint
        Subtraction (A - B)
        
        Args:
            b (int32): 
        
        Returns:
            IntPoint:
        """
        ...
    def not_equal(self, b: IntPoint) -> bool:
        r"""
        x.not_equal(b) -> bool
        Returns true if IntPoint A is NOT equal to IntPoint B (A != B)
        
        Args:
            b (IntPoint): 
        
        Returns:
            bool:
        """
        ...
    def multiply(self, b: IntPoint) -> IntPoint:
        r"""
        x.multiply(b) -> IntPoint
        Returns IntPoint A multiplied by B
        
        Args:
            b (IntPoint): 
        
        Returns:
            IntPoint:
        """
        ...
    def multiply_int(self, b: int) -> IntPoint:
        r"""
        x.multiply_int(b) -> IntPoint
        Multiplication (A * B)
        
        Args:
            b (int32): 
        
        Returns:
            IntPoint:
        """
        ...
    def equals(self, b: IntPoint) -> bool:
        r"""
        x.equals(b) -> bool
        Returns true if IntPoint A is equal to IntPoint B (A == B)
        
        Args:
            b (IntPoint): 
        
        Returns:
            bool:
        """
        ...
    def divide(self, b: IntPoint) -> IntPoint:
        r"""
        x.divide(b) -> IntPoint
        Returns IntPoint A divided by B
        
        Args:
            b (IntPoint): 
        
        Returns:
            IntPoint:
        """
        ...
    def divide_int(self, b: int) -> IntPoint:
        r"""
        x.divide_int(b) -> IntPoint
        Division (A * B)
        
        Args:
            b (int32): 
        
        Returns:
            IntPoint:
        """
        ...
    def vector2d(self) -> Vector2D:
        r"""
        x.vector2d() -> Vector2D
        Converts an IntPoint to a Vector2D
        
        Returns:
            Vector2D:
        """
        ...
    def add(self, b: IntPoint) -> IntPoint:
        r"""
        x.add(b) -> IntPoint
        Returns IntPoint A added by B
        
        Args:
            b (IntPoint): 
        
        Returns:
            IntPoint:
        """
        ...
    def add_int(self, b: int) -> IntPoint:
        r"""
        x.add_int(b) -> IntPoint
        Addition (A - B)
        
        Args:
            b (int32): 
        
        Returns:
            IntPoint:
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``IntPoint`` Returns true if IntPoint A is NOT equal to IntPoint B (A != B)
        - ``IntPoint`` Returns true if IntPoint A is equal to IntPoint B (A == B)
        """
        ...
    def __add__(self, other: IntPoint) -> None:
        r"""
        **Overloads:**
        
        - ``IntPoint`` Returns IntPoint A added by B
        - ``int32`` Addition (A - B)
        """
        ...
    def __iadd__(self, other: IntPoint) -> None:
        r"""
        **Overloads:**
        
        - ``IntPoint`` Returns IntPoint A added by B
        - ``int32`` Addition (A - B)
        """
        ...
    def __sub__(self, other: IntPoint) -> None:
        r"""
        **Overloads:**
        
        - ``IntPoint`` Returns IntPoint A subtracted by B
        - ``int32`` Subtraction (A - B)
        """
        ...
    def __isub__(self, other: IntPoint) -> None:
        r"""
        **Overloads:**
        
        - ``IntPoint`` Returns IntPoint A subtracted by B
        - ``int32`` Subtraction (A - B)
        """
        ...
    def __mul__(self, other: IntPoint) -> None:
        r"""
        **Overloads:**
        
        - ``IntPoint`` Returns IntPoint A multiplied by B
        - ``int32`` Multiplication (A * B)
        """
        ...
    def __imul__(self, other: IntPoint) -> None:
        r"""
        **Overloads:**
        
        - ``IntPoint`` Returns IntPoint A multiplied by B
        - ``int32`` Multiplication (A * B)
        """
        ...
    def __truediv__(self, other: IntPoint) -> None:
        r"""
        **Overloads:**
        
        - ``IntPoint`` Returns IntPoint A divided by B
        - ``int32`` Division (A * B)
        """
        ...
    ZERO: IntPoint #: (IntPoint): Zero Int Point (0, 0)
    UP: IntPoint #: (IntPoint): Up Int Point (0, -1)
    RIGHT: IntPoint #: (IntPoint): Right Int Point (1, 0)
    ONE: IntPoint #: (IntPoint): One Int Point (1, 1)
    LEFT: IntPoint #: (IntPoint): Left Int Point (-1, 0)
    DOWN: IntPoint #: (IntPoint): Down Int Point (0, 1)

class IntVector(StructBase):
    r"""
    An integer vector in 3D space.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\IntVector.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (int32):  [Read-Write]
    - ``y`` (int32):  [Read-Write]
    - ``z`` (int32):  [Read-Write]
    """
    def __init__(self, x: int = 0, y: int = 0, z: int = 0) -> None:
        ...
    @property
    def x(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: int) -> None:
        ...
    @property
    def y(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: int) -> None:
        ...
    @property
    def z(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: int) -> None:
        ...

class IntVector4(StructBase):
    r"""
    An integer vector in 4D space.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\IntVector.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``w`` (int32):  [Read-Write]
    - ``x`` (int32):  [Read-Write]
    - ``y`` (int32):  [Read-Write]
    - ``z`` (int32):  [Read-Write]
    """
    def __init__(self, x: int = 0, y: int = 0, z: int = 0, w: int = 0) -> None:
        ...
    @property
    def x(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: int) -> None:
        ...
    @property
    def y(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: int) -> None:
        ...
    @property
    def z(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: int) -> None:
        ...
    @property
    def w(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @w.setter
    def w(self, value: int) -> None:
        ...

class Matrix(StructBase):
    r"""
    A 4x4 matrix.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Matrix.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``w_plane`` (Plane):  [Read-Write]
    - ``x_plane`` (Plane):  [Read-Write]
    - ``y_plane`` (Plane):  [Read-Write]
    - ``z_plane`` (Plane):  [Read-Write]
    """
    def __init__(self, x_plane: Plane = [0.000000, 0.000000, 0.000000, 0.000000], y_plane: Plane = [0.000000, 0.000000, 0.000000, 0.000000], z_plane: Plane = [0.000000, 0.000000, 0.000000, 0.000000], w_plane: Plane = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def x_plane(self) -> Plane:
        r"""
        (Plane):  [Read-Write]
        """
        ...
    @x_plane.setter
    def x_plane(self, value: Plane) -> None:
        ...
    @property
    def y_plane(self) -> Plane:
        r"""
        (Plane):  [Read-Write]
        """
        ...
    @y_plane.setter
    def y_plane(self, value: Plane) -> None:
        ...
    @property
    def z_plane(self) -> Plane:
        r"""
        (Plane):  [Read-Write]
        """
        ...
    @z_plane.setter
    def z_plane(self, value: Plane) -> None:
        ...
    @property
    def w_plane(self) -> Plane:
        r"""
        (Plane):  [Read-Write]
        """
        ...
    @w_plane.setter
    def w_plane(self, value: Plane) -> None:
        ...
    def not_equal(self, b: Matrix, tolerance: float = 0.000100) -> bool:
        r"""
        x.not_equal(b, tolerance=0.000100) -> bool
        Checks whether another Matrix is not equal to this, within specified tolerance.
        
        Args:
            b (Matrix): 
            tolerance (float): 
        
        Returns:
            bool: true if two Matrix are not equal, within specified tolerance, otherwise false.
        """
        ...
    def multiply(self, b: Matrix) -> Matrix:
        r"""
        x.multiply(b) -> Matrix
        Gets the result of multiplying a Matrix to this.
        
        Args:
            b (Matrix): 
        
        Returns:
            Matrix: The result of multiplication.
        """
        ...
    def multiply_float(self, b: float) -> Matrix:
        r"""
        x.multiply_float(b) -> Matrix
        Multiplies all values of the matrix by a float.
        If your Matrix represents a Transform that you wish to scale you should use Apply Scale instead
        
        Args:
            b (double): 
        
        Returns:
            Matrix:
        """
        ...
    def transform_vector4(self, v: Vector4) -> Vector4:
        r"""
        x.transform_vector4(v) -> Vector4
        Transform a vector by the matrix.
        (Assumes Matrix represents a transform)
        
        Args:
            v (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    def transform_vector(self, v: Vector) -> Vector4:
        r"""
        x.transform_vector(v) -> Vector4
        Transform a direction vector - will not take into account translation part of the FMatrix.
        If you want to transform a surface normal (or plane) and correctly account for non-uniform scaling you should use TransformByUsingAdjointT.
        (Assumes Matrix represents a transform)
        
        Args:
            v (Vector): 
        
        Returns:
            Vector4:
        """
        ...
    def transform_position(self, v: Vector) -> Vector4:
        r"""
        x.transform_position(v) -> Vector4
        Transform a location - will take into account translation part of the FMatrix.
        (Assumes Matrix represents a transform)
        
        Args:
            v (Vector): 
        
        Returns:
            Vector4:
        """
        ...
    def to_quat(self) -> Quat:
        r"""
        x.to_quat() -> Quat
        Transform a rotation matrix into a quaternion.
        (Assumes Matrix represents a transform)
        warning: rotation part will need to be unit length for this to be right!
        
        Returns:
            Quat:
        """
        ...
    def set_origin(self, new_origin: Vector) -> None:
        r"""
        x.set_origin(new_origin) -> None
        Set the origin of the coordinate system to the given vector
        (Assumes Matrix represents a transform)
        
        Args:
            new_origin (Vector):
        """
        ...
    def set_column(self, column: MatrixColumns, value: Vector) -> None:
        r"""
        x.set_column(column, value) -> None
        Matrix Set Column
        
        Args:
            column (MatrixColumns): 
            value (Vector):
        """
        ...
    def set_axis(self, axis: AxisType, axis_vector: Vector) -> None:
        r"""
        x.set_axis(axis, axis_vector) -> None
        set an axis of this matrix
        (Assumes Matrix represents a transform)
        
        Args:
            axis (AxisType): vector of the axis
            axis_vector (Vector):
        """
        ...
    def scale_translation(self, scale3d: Vector) -> Matrix:
        r"""
        x.scale_translation(scale3d) -> Matrix
        Scale the translation part of the matrix by the supplied vector.
        (Assumes Matrix represents a transform)
        
        Args:
            scale3d (Vector): 
        
        Returns:
            Matrix:
        """
        ...
    def remove_translation(self) -> Matrix:
        r"""
        x.remove_translation() -> Matrix
        Remove any translation from this matrix
        (Assumes Matrix represents a transform)
        
        Returns:
            Matrix:
        """
        ...
    def remove_scaling(self, tolerance: float = 0.000000) -> None:
        r"""
        x.remove_scaling(tolerance=0.000000) -> None
        Remove any scaling from this matrix (ie magnitude of each row is 1) with error Tolerance
        (Assumes Matrix represents a transform)
        
        Args:
            tolerance (float):
        """
        ...
    def mirror(self, mirror_axis: AxisType, flip_axis: AxisType) -> Matrix:
        r"""
        x.mirror(mirror_axis, flip_axis) -> Matrix
        Utility for mirroring this transform across a certain plane, and flipping one of the axis as well.
        (Assumes Matrix represents a transform)
        
        Args:
            mirror_axis (AxisType): 
            flip_axis (AxisType): 
        
        Returns:
            Matrix:
        """
        ...
    def inverse_transform_vector(self, v: Vector) -> Vector:
        r"""
        x.inverse_transform_vector(v) -> Vector
        Transform a direction vector by the inverse of this matrix - will not take into account translation part.
        If you want to transform a surface normal (or plane) and correctly account for non-uniform scaling you should use TransformByUsingAdjointT with adjoint of matrix inverse.
        (Assumes Matrix represents a transform)
        
        Args:
            v (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def inverse_transform_position(self, v: Vector) -> Vector:
        r"""
        x.inverse_transform_position(v) -> Vector
        Inverts the matrix and then transforms V - correctly handles scaling in this matrix.
        (Assumes Matrix represents a transform)
        
        Args:
            v (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def get_unit_axis(self, axis: AxisType) -> Vector:
        r"""
        x.get_unit_axis(axis) -> Vector
        get unit length axis of this matrix
        (Assumes Matrix represents a transform)
        
        Args:
            axis (AxisType): 
        
        Returns:
            Vector: vector of the axis
        """
        ...
    def get_unit_axes(self) -> Tuple[Vector, Vector, Vector]:
        r"""
        x.get_unit_axes() -> (x=Vector, y=Vector, z=Vector)
        get unit length axes of this matrix
        (Assumes Matrix represents a transform)
        
        Returns:
            tuple: 
        
            x (Vector): axes returned to this param
        
            y (Vector): axes returned to this param
        
            z (Vector): axes returned to this param
        """
        ...
    def get_transposed(self) -> Matrix:
        r"""
        x.get_transposed() -> Matrix
        Transpose.
        
        Returns:
            Matrix:
        """
        ...
    def get_transpose_adjoint(self) -> Matrix:
        r"""
        x.get_transpose_adjoint() -> Matrix
        Get the Transose Adjoint of the Matrix.
        
        Returns:
            Matrix:
        """
        ...
    def get_scale_vector(self, tolerance: float = 0.000000) -> Vector:
        r"""
        x.get_scale_vector(tolerance=0.000000) -> Vector
        return a 3D scale vector calculated from this matrix (where each component is the magnitude of a row vector) with error Tolerance.
        (Assumes Matrix represents a transform)
        
        Args:
            tolerance (float): 
        
        Returns:
            Vector:
        """
        ...
    def get_scaled_axis(self, axis: AxisType) -> Vector:
        r"""
        x.get_scaled_axis(axis) -> Vector
        get axis of this matrix scaled by the scale of the matrix
        (Assumes Matrix represents a transform)
        
        Args:
            axis (AxisType): 
        
        Returns:
            Vector: vector of the axis
        """
        ...
    def get_scaled_axes(self) -> Tuple[Vector, Vector, Vector]:
        r"""
        x.get_scaled_axes() -> (x=Vector, y=Vector, z=Vector)
        get axes of this matrix scaled by the scale of the matrix
        (Assumes Matrix represents a transform)
        
        Returns:
            tuple: 
        
            x (Vector): axes returned to this param
        
            y (Vector): axes returned to this param
        
            z (Vector): axes returned to this param
        """
        ...
    def get_rot_determinant(self) -> float:
        r"""
        x.get_rot_determinant() -> float
        
        
        Returns:
            float: the determinant of rotation 3x3 matrix (Assumes Top Left 3x3 Submatrix represents a Rotation)
        """
        ...
    def get_rotator(self) -> Rotator:
        r"""
        x.get_rotator() -> Rotator
        Get the rotator representation of this matrix
        (Assumes Matrix represents a transform)
        
        Returns:
            Rotator: rotator representation of this matrix
        """
        ...
    def get_origin(self) -> Vector:
        r"""
        x.get_origin() -> Vector
        Get the origin of the co-ordinate system
        (Assumes Matrix represents a transform)
        
        Returns:
            Vector: co-ordinate system origin
        """
        ...
    def get_maximum_axis_scale(self) -> float:
        r"""
        x.get_maximum_axis_scale() -> float
        
        
        Returns:
            float: the maximum magnitude of any row of the matrix. (Assumes Matrix represents a transform)
        """
        ...
    def get_matrix_without_scale(self, tolerance: float = 0.000000) -> Matrix:
        r"""
        x.get_matrix_without_scale(tolerance=0.000000) -> Matrix
        Returns matrix after RemoveScaling with error Tolerance
        (Assumes Matrix represents a transform)
        
        Args:
            tolerance (float): 
        
        Returns:
            Matrix:
        """
        ...
    def get_inverse(self) -> Matrix:
        r"""
        x.get_inverse() -> Matrix
        Get the inverse of the Matrix. Handles nil matrices.
        
        Returns:
            Matrix:
        """
        ...
    def get_frustum_top_plane(self) -> Optional[Plane]:
        r"""
        x.get_frustum_top_plane() -> Plane or None
        Get the top plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the top plane of the Frustum of this matrix
        """
        ...
    def get_frustum_right_plane(self) -> Optional[Plane]:
        r"""
        x.get_frustum_right_plane() -> Plane or None
        Get the right plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the right plane of the Frustum of this matrix
        """
        ...
    def get_frustum_near_plane(self) -> Optional[Plane]:
        r"""
        x.get_frustum_near_plane() -> Plane or None
        Get the near plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the near plane of the Frustum of this matrix
        """
        ...
    def get_frustum_left_plane(self) -> Optional[Plane]:
        r"""
        x.get_frustum_left_plane() -> Plane or None
        Get the left plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the left plane of the Frustum of this matrix
        """
        ...
    def get_frustum_far_plane(self) -> Optional[Plane]:
        r"""
        x.get_frustum_far_plane() -> Plane or None
        Get the far plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the far plane of the Frustum of this matrix
        """
        ...
    def get_frustum_bottom_plane(self) -> Optional[Plane]:
        r"""
        x.get_frustum_bottom_plane() -> Plane or None
        Get the bottom plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the bottom plane of the Frustum of this matrix
        """
        ...
    def get_determinant(self) -> float:
        r"""
        x.get_determinant() -> float
        
        
        Returns:
            float: determinant of this matrix.
        """
        ...
    def get_column(self, column: MatrixColumns) -> Vector:
        r"""
        x.get_column(column) -> Vector
        get a column of this matrix
        
        Args:
            column (MatrixColumns): 
        
        Returns:
            Vector: vector of the column
        """
        ...
    def contains_na_n(self) -> bool:
        r"""
        x.contains_na_n() -> bool
        Returns true if any element of this matrix is NaN
        
        Returns:
            bool:
        """
        ...
    def concatenate_translation(self, translation: Vector) -> Matrix:
        r"""
        x.concatenate_translation(translation) -> Matrix
        Returns a matrix with an additional translation concatenated.
        (Assumes Matrix represents a transform)
        
        Args:
            translation (Vector): 
        
        Returns:
            Matrix:
        """
        ...
    def apply_scale(self, scale: float) -> Matrix:
        r"""
        x.apply_scale(scale) -> Matrix
        Apply Scale to this matrix
        (Assumes Matrix represents a transform)
        
        Args:
            scale (float): 
        
        Returns:
            Matrix:
        """
        ...
    def equals(self, b: Matrix, tolerance: float = 0.000100) -> bool:
        r"""
        x.equals(b, tolerance=0.000100) -> bool
        Checks whether another Matrix is equal to this, within specified tolerance.
        
        Args:
            b (Matrix): 
            tolerance (float): Error Tolerance.
        
        Returns:
            bool: true if two Matrix are equal, within specified tolerance, otherwise false.
        """
        ...
    def transform(self) -> Transform:
        r"""
        x.transform() -> Transform
        Converts a Matrix to a Transform
        (Assumes Matrix represents a transform)
        
        Returns:
            Transform:
        """
        ...
    def rotator(self) -> Rotator:
        r"""
        x.rotator() -> Rotator
        Converts a Matrix to a Rotator
        (Assumes Matrix represents a transform)
        
        Returns:
            Rotator:
        """
        ...
    def add(self, b: Matrix) -> Matrix:
        r"""
        x.add(b) -> Matrix
        Gets the result of adding a matrix to this.
        
        Args:
            b (Matrix): 
        
        Returns:
            Matrix: The result of addition.
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Matrix`` Checks whether another Matrix is equal to this, within specified tolerance.
          
          @param Other The other Matrix.
          @param Tolerance Error Tolerance.
          @return true if two Matrix are equal, within specified tolerance, otherwise false.
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Matrix`` Checks whether another Matrix is not equal to this, within specified tolerance.
          
          @param Other The other Matrix.
          @return true if two Matrix are not equal, within specified tolerance, otherwise false.
        """
        ...
    def __add__(self, other: Matrix) -> None:
        r"""
        **Overloads:**
        
        - ``Matrix`` Gets the result of adding a matrix to this.
          
          @param Other The Matrix to add.
          @return The result of addition.
        """
        ...
    def __iadd__(self, other: Matrix) -> None:
        r"""
        **Overloads:**
        
        - ``Matrix`` Gets the result of adding a matrix to this.
          
          @param Other The Matrix to add.
          @return The result of addition.
        """
        ...
    def __mul__(self, other: Matrix) -> None:
        r"""
        **Overloads:**
        
        - ``Matrix`` Gets the result of multiplying a Matrix to this.
          
          @param Other The matrix to multiply this by.
          @return The result of multiplication.
        - ``double`` Multiplies all values of the matrix by a float.
          If your Matrix represents a Transform that you wish to scale you should use Apply Scale instead
        """
        ...
    def __imul__(self, other: Matrix) -> None:
        r"""
        **Overloads:**
        
        - ``Matrix`` Gets the result of multiplying a Matrix to this.
          
          @param Other The matrix to multiply this by.
          @return The result of multiplication.
        - ``double`` Multiplies all values of the matrix by a float.
          If your Matrix represents a Transform that you wish to scale you should use Apply Scale instead
        """
        ...
    IDENTITY: Matrix #: (Matrix): Identity matrix

class Plane(Vector):
    r"""
    A plane definition in 3D space.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Plane.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``w`` (double):  [Read-Write]
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    - ``z`` (double):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000, w: float = 0.000000) -> None:
        ...
    @property
    def w(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @w.setter
    def w(self, value: float) -> None:
        ...

class Matrix44f(StructBase):
    r"""
    A 4x4 matrix.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Matrix.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``w_plane`` (Plane4f):  [Read-Write]
    - ``x_plane`` (Plane4f):  [Read-Write]
    - ``y_plane`` (Plane4f):  [Read-Write]
    - ``z_plane`` (Plane4f):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class Plane4f(Vector3f):
    r"""
    A plane definition in 3D space.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Plane.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``w`` (float):  [Read-Write]
    - ``x`` (float):  [Read-Write]
    - ``y`` (float):  [Read-Write]
    - ``z`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class PlatformInputDeviceState(StructBase):
    r"""
    Data about an input device's current state
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``connection_state`` (InputDeviceConnectionState):  [Read-Only] The connection state of this input device
    - ``owning_platform_user`` (PlatformUserId):  [Read-Only] The platform user that this input device belongs to
    """
    def __init__(self, owning_platform_user: PlatformUserId = [], connection_state: InputDeviceConnectionState = InputDeviceConnectionState.INVALID) -> None:
        ...
    @property
    def owning_platform_user(self) -> PlatformUserId:
        r"""
        (PlatformUserId):  [Read-Only] The platform user that this input device belongs to
        """
        ...
    @property
    def connection_state(self) -> InputDeviceConnectionState:
        r"""
        (InputDeviceConnectionState):  [Read-Only] The connection state of this input device
        """
        ...

class PlatformUserId(StructBase):
    r"""
    Handle that defines a local user on this platform.
    This used to be just a typedef int32 that was used interchangeably as ControllerId and LocalUserIndex.
    Moving forward these will be allocated by the platform application layer.
    
    Opaque struct for the FPlatformUserId struct defined in CoreMiscDefines.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``internal_id`` (int32):  [Read-Only]
    """
    def __init__(self) -> None:
        ...
    def not_equal(self, b: PlatformUserId) -> bool:
        r"""
        x.not_equal(b) -> bool
        Returns true if PlatformUserId A is not equal to PlatformUserId B (A != B)
        
        Args:
            b (PlatformUserId): 
        
        Returns:
            bool:
        """
        ...
    def equals(self, b: PlatformUserId) -> bool:
        r"""
        x.equals(b) -> bool
        Returns true if PlatformUserId A is equal to PlatformUserId B (A == B)
        
        Args:
            b (PlatformUserId): 
        
        Returns:
            bool:
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``PlatformUserId`` Returns true if PlatformUserId A is equal to PlatformUserId B (A == B)
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``PlatformUserId`` Returns true if PlatformUserId A is not equal to PlatformUserId B (A != B)
        """
        ...
    NONE: PlatformUserId #: (PlatformUserId): Static invalid platform user

class PolyglotTextData(StructBase):
    r"""
    Polyglot data that may be registered to the text localization manager at runtime.
    note: This struct is mirrored in PolyglotTextData.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``category`` (LocalizedTextSourceCategory):  [Read-Write] The category of this polyglot data.
      note: This affects when and how the data is loaded into the text localization manager.
    - ``is_minimal_patch`` (bool):  [Read-Write] True if this polyglot data is a minimal patch, and that missing translations should be
      ignored (falling back to any LocRes data) rather than falling back to the native string.
    - ``key`` (str):  [Read-Write] The key of the text created from this polyglot data.
      note: This must not be empty.
    - ``localized_strings`` (Map[str, str]):  [Read-Write] Mapping between a culture code and its localized string.
      note: The native culture may also have a translation in this map.
    - ``namespace`` (str):  [Read-Write] The namespace of the text created from this polyglot data.
      note: This may be empty.
    - ``native_culture`` (str):  [Read-Write] The native culture of this polyglot data.
      note: This may be empty, and if empty, will be inferred from the native culture of the text category.
    - ``native_string`` (str):  [Read-Write] The native string for this polyglot data.
      note: This must not be empty (it should be the same as the originally authored text you are trying to replace).
    """
    def __init__(self, category: LocalizedTextSourceCategory = LocalizedTextSourceCategory.GAME, native_culture: str = "", namespace: str = "", key: str = "", native_string: str = "", localized_strings: Map[str, str] = {}, is_minimal_patch: bool = False) -> None:
        ...
    @property
    def category(self) -> LocalizedTextSourceCategory:
        r"""
        (LocalizedTextSourceCategory):  [Read-Write] The category of this polyglot data.
        note: This affects when and how the data is loaded into the text localization manager.
        """
        ...
    @category.setter
    def category(self, value: LocalizedTextSourceCategory) -> None:
        ...
    @property
    def native_culture(self) -> str:
        r"""
        (str):  [Read-Write] The native culture of this polyglot data.
        note: This may be empty, and if empty, will be inferred from the native culture of the text category.
        """
        ...
    @native_culture.setter
    def native_culture(self, value: str) -> None:
        ...
    @property
    def namespace(self) -> str:
        r"""
        (str):  [Read-Write] The namespace of the text created from this polyglot data.
        note: This may be empty.
        """
        ...
    @namespace.setter
    def namespace(self, value: str) -> None:
        ...
    @property
    def key(self) -> str:
        r"""
        (str):  [Read-Write] The key of the text created from this polyglot data.
        note: This must not be empty.
        """
        ...
    @key.setter
    def key(self, value: str) -> None:
        ...
    @property
    def native_string(self) -> str:
        r"""
        (str):  [Read-Write] The native string for this polyglot data.
        note: This must not be empty (it should be the same as the originally authored text you are trying to replace).
        """
        ...
    @native_string.setter
    def native_string(self, value: str) -> None:
        ...
    @property
    def localized_strings(self) -> Map[str, str]:
        r"""
        (Map[str, str]):  [Read-Write] Mapping between a culture code and its localized string.
        note: The native culture may also have a translation in this map.
        """
        ...
    @localized_strings.setter
    def localized_strings(self, value: Map[str, str]) -> None:
        ...
    @property
    def is_minimal_patch(self) -> bool:
        r"""
        (bool):  [Read-Write] True if this polyglot data is a minimal patch, and that missing translations should be
        ignored (falling back to any LocRes data) rather than falling back to the native string.
        """
        ...
    @is_minimal_patch.setter
    def is_minimal_patch(self, value: bool) -> None:
        ...

class PrimaryAssetId(StructBase):
    r"""
    This identifies an object as a "primary" asset that can be searched for by the AssetManager and used in various tools
    note: The full C++ class is located here: Engine\Source\Runtime\CoreUObject\Public\UObject\PrimaryAssetId.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``primary_asset_name`` (Name):  [Read-Write] The Name of this object, by default its short name
    - ``primary_asset_type`` (PrimaryAssetType):  [Read-Write] The Type of this object, by default its base class's name
    """
    def __init__(self, primary_asset_type: PrimaryAssetType = ["None"], primary_asset_name: Name = "None") -> None:
        ...
    @property
    def primary_asset_type(self) -> PrimaryAssetType:
        r"""
        (PrimaryAssetType):  [Read-Write] The Type of this object, by default its base class's name
        """
        ...
    @primary_asset_type.setter
    def primary_asset_type(self, value: PrimaryAssetType) -> None:
        ...
    @property
    def primary_asset_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The Name of this object, by default its short name
        """
        ...
    @primary_asset_name.setter
    def primary_asset_name(self, value: Name) -> None:
        ...
    def unload(self) -> None:
        r"""
        x.unload() -> None
        Unloads a primary asset, which allows it to be garbage collected if nothing else is referencing it
        """
        ...
    def is_valid(self) -> bool:
        r"""
        x.is_valid() -> bool
        Returns true if the Primary Asset Id is valid
        
        Returns:
            bool:
        """
        ...
    def get_soft_object_reference(self) -> Object:
        r"""
        x.get_soft_object_reference() -> Object
        Returns the Object Id associated with a Primary Asset Id, this works even if the asset is not loaded
        
        Returns:
            Object:
        """
        ...
    def get_soft_class_reference(self) -> Class:
        r"""
        x.get_soft_class_reference() -> Class
        Returns the Blueprint Class Id associated with a Primary Asset Id, this works even if the asset is not loaded
        
        Returns:
            Class:
        """
        ...
    def get_object(self) -> Object:
        r"""
        x.get_object() -> Object
        Returns the Object associated with a Primary Asset Id, this will only return a valid object if it is in memory, it will not load it
        
        Returns:
            Object:
        """
        ...
    def get_current_bundle_state(self, force_current_state: bool) -> Optional[Array[Name]]:
        r"""
        x.get_current_bundle_state(force_current_state) -> Array[Name] or None
        Returns the list of loaded bundles for a given Primary Asset. This will return false if the asset is not loaded at all.
        If ForceCurrentState is true it will return the current state even if a load is in process
        
        Args:
            force_current_state (bool): 
        
        Returns:
            Array[Name] or None: 
        
            out_bundles (Array[Name]):
        """
        ...
    def get_class(self) -> Class:
        r"""
        x.get_class() -> type(Class)
        Returns the Blueprint Class associated with a Primary Asset Id, this will only return a valid object if it is in memory, it will not load it
        
        Returns:
            type(Class):
        """
        ...
    def to_string(self) -> str:
        r"""
        x.to_string() -> str
        Converts a Primary Asset Id to a string. The other direction is not provided because it cannot be validated
        
        Returns:
            str:
        """
        ...
    def __bool__(self) -> bool:
        r"""
        Returns true if the Primary Asset Id is valid
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``PrimaryAssetId`` Returns true if the values are equal (A == B)
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``PrimaryAssetId`` Returns true if the values are not equal (A != B)
        """
        ...

class PrimaryAssetType(StructBase):
    r"""
    A type of primary asset, used by the Asset Manager system.
    note: The full C++ class is located here: Engine\Source\Runtime\CoreUObject\Public\UObject\PrimaryAssetId.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] The Type of this object, by default its base class's name
    """
    def __init__(self, name: Name = "None") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] The Type of this object, by default its base class's name
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    def is_valid(self) -> bool:
        r"""
        x.is_valid() -> bool
        Returns list of Primary Asset Ids for a PrimaryAssetType
        
        Returns:
            bool:
        """
        ...
    def get_primary_asset_id_list(self) -> Array[PrimaryAssetId]:
        r"""
        x.get_primary_asset_id_list() -> Array[PrimaryAssetId]
        Returns list of PrimaryAssetIds for a PrimaryAssetType
        
        Returns:
            Array[PrimaryAssetId]: 
        
            out_primary_asset_id_list (Array[PrimaryAssetId]):
        """
        ...
    def to_string(self) -> str:
        r"""
        x.to_string() -> str
        Converts a Primary Asset Type to a string. The other direction is not provided because it cannot be validated
        
        Returns:
            str:
        """
        ...
    def __bool__(self) -> bool:
        r"""
        Returns list of Primary Asset Ids for a PrimaryAssetType
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``PrimaryAssetType`` Returns true if the values are equal (A == B)
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``PrimaryAssetType`` Returns true if the values are not equal (A != B)
        """
        ...

class QualifiedTime(StructBase):
    r"""
    A frame time qualified by a frame rate context.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Misc\QualifiedFrameTime.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``rate`` (FrameRate):  [Read-Write] The rate that this frame time is in
    - ``time`` (FrameTime):  [Read-Write] The frame time
    """
    def __init__(self, frame: FrameNumber = [0], frame_rate: FrameRate = [0, 0], sub_frame: float = 0.000000) -> None:
        ...
    @property
    def time(self) -> FrameTime:
        r"""
        (FrameTime):  [Read-Write] The frame time
        """
        ...
    @time.setter
    def time(self, value: FrameTime) -> None:
        ...
    @property
    def rate(self) -> FrameRate:
        r"""
        (FrameRate):  [Read-Write] The rate that this frame time is in
        """
        ...
    @rate.setter
    def rate(self, value: FrameRate) -> None:
        ...

class Quat4f(StructBase):
    r"""
    Quaternion.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Quat.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``w`` (float):  [Read-Write]
    - ``x`` (float):  [Read-Write]
    - ``y`` (float):  [Read-Write]
    - ``z`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class RandomStream(StructBase):
    r"""
    Thread-safe random number generator that can be manually seeded.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\RandomStream.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``initial_seed`` (int32):  [Read-Write] Holds the initial seed.
    """
    def __init__(self, initial_seed: int = 0) -> None:
        ...
    @property
    def initial_seed(self) -> int:
        r"""
        (int32):  [Read-Write] Holds the initial seed.
        """
        ...
    @initial_seed.setter
    def initial_seed(self, value: int) -> None:
        ...
    def set_seed(self, new_seed: int) -> None:
        r"""
        x.set_seed(new_seed) -> None
        Set the seed of a random stream to a specific number
        
        Args:
            new_seed (int32):
        """
        ...
    def generate_new_seed(self) -> None:
        r"""
        x.generate_new_seed() -> None
        Create a new random seed for a random stream
        """
        ...
    def reset(self) -> None:
        r"""
        x.reset() -> None
        Reset a random stream
        """
        ...
    def random_unit_vector_in_elliptical_cone_in_radians(self, cone_dir: Vector, max_yaw_in_radians: float, max_pitch_in_radians: float) -> Vector:
        r"""
        x.random_unit_vector_in_elliptical_cone_in_radians(cone_dir, max_yaw_in_radians, max_pitch_in_radians) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        The shape of the cone can be modified according to the yaw and pitch angles.
        
        Args:
            cone_dir (Vector): 
            max_yaw_in_radians (float): The yaw angle of the cone (from ConeDir to horizontal edge), in radians.
            max_pitch_in_radians (float): The pitch angle of the cone (from ConeDir to vertical edge), in radians.
        
        Returns:
            Vector:
        """
        ...
    def random_unit_vector_in_elliptical_cone_in_degrees(self, cone_dir: Vector, max_yaw_in_degrees: float, max_pitch_in_degrees: float) -> Vector:
        r"""
        x.random_unit_vector_in_elliptical_cone_in_degrees(cone_dir, max_yaw_in_degrees, max_pitch_in_degrees) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        The shape of the cone can be modified according to the yaw and pitch angles.
        
        Args:
            cone_dir (Vector): 
            max_yaw_in_degrees (float): The yaw angle of the cone (from ConeDir to horizontal edge), in degrees.
            max_pitch_in_degrees (float): The pitch angle of the cone (from ConeDir to vertical edge), in degrees.
        
        Returns:
            Vector:
        """
        ...
    def random_unit_vector_in_cone_in_radians(self, cone_dir: Vector, cone_half_angle_in_radians: float) -> Vector:
        r"""
        x.random_unit_vector_in_cone_in_radians(cone_dir, cone_half_angle_in_radians) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        
        Args:
            cone_dir (Vector): The base "center" direction of the cone.
            cone_half_angle_in_radians (float): The half-angle of the cone (from ConeDir to edge), in radians.
        
        Returns:
            Vector:
        """
        ...
    def random_unit_vector_in_cone_in_degrees(self, cone_dir: Vector, cone_half_angle_in_degrees: float) -> Vector:
        r"""
        x.random_unit_vector_in_cone_in_degrees(cone_dir, cone_half_angle_in_degrees) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        
        Args:
            cone_dir (Vector): The base "center" direction of the cone.
            cone_half_angle_in_degrees (float): The half-angle of the cone (from ConeDir to edge), in degrees.
        
        Returns:
            Vector:
        """
        ...
    def random_unit_vector(self) -> Vector:
        r"""
        x.random_unit_vector() -> Vector
        Returns a random vector with length of 1.0
        
        Returns:
            Vector:
        """
        ...
    def random_rotator(self, roll: bool) -> Rotator:
        r"""
        x.random_rotator(roll) -> Rotator
        Create a random rotation
        
        Args:
            roll (bool): 
        
        Returns:
            Rotator:
        """
        ...
    def random_point_in_box(self, box: Box) -> Vector:
        r"""
        x.random_point_in_box(box) -> Vector
        Returns a random point within the specified bounding box.
        
        Args:
            box (Box): 
        
        Returns:
            Vector:
        """
        ...
    def random_point_in_bounded_box(self, center: Vector, half_size: Vector) -> Vector:
        r"""
        x.random_point_in_bounded_box(center, half_size) -> Vector
        Returns a random point within the specified bounding box using the first vector as an origin and the second as the half size of the AABB.
        
        Args:
            center (Vector): 
            half_size (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def random_int_in_range(self, min: int, max: int) -> int:
        r"""
        x.random_int_in_range(min, max) -> int32
        Return a random integer between Min and Max (>= Min and <= Max)
        
        Args:
            min (int32): 
            max (int32): 
        
        Returns:
            int32:
        """
        ...
    def random_int(self, max: int) -> int:
        r"""
        x.random_int(max) -> int32
        Returns a uniformly distributed random number between 0 and Max - 1
        
        Args:
            max (int32): 
        
        Returns:
            int32:
        """
        ...
    def random_float_in_range(self, min: float, max: float) -> float:
        r"""
        x.random_float_in_range(min, max) -> float
        Generate a random number between Min and Max
        
        Args:
            min (float): 
            max (float): 
        
        Returns:
            float:
        """
        ...
    def random_float(self) -> float:
        r"""
        x.random_float() -> float
        Returns a random float between 0 and 1
        
        Returns:
            float:
        """
        ...
    def random_bool_with_weight(self, weight: float = 0.500000) -> bool:
        r"""
        x.random_bool_with_weight(weight=0.500000) -> bool
        Get a random chance with the specified weight. Range of weight is 0.0 - 1.0 E.g.,
                      Weight = .6 return value = True 60% of the time
        
        Args:
            weight (float): 
        
        Returns:
            bool:
        """
        ...
    def random_bool(self) -> bool:
        r"""
        x.random_bool() -> bool
        Returns a random bool
        
        Returns:
            bool:
        """
        ...

class Ray(StructBase):
    r"""
    3D Ray represented by Origin and (normalized) Direction.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Ray.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``direction`` (Vector):  [Read-Write]
    - ``origin`` (Vector):  [Read-Write]
    """
    def __init__(self, origin: Vector = [0.000000, 0.000000, 0.000000], direction: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def origin(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @origin.setter
    def origin(self, value: Vector) -> None:
        ...
    @property
    def direction(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @direction.setter
    def direction(self, value: Vector) -> None:
        ...

class Rotator(StructBase):
    r"""
    An orthogonal rotation in 3d space.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Rotator.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``pitch`` (double):  [Read-Write] Pitch (degrees) around Y axis
    - ``roll`` (double):  [Read-Write] Roll (degrees) around X axis
    - ``yaw`` (double):  [Read-Write] Yaw (degrees) around Z axis
    """
    def __init__(self, roll: float = 0.000000, pitch: float = 0.000000, yaw: float = 0.000000) -> None:
        ...
    @property
    def pitch(self) -> float:
        r"""
        (double):  [Read-Write] Pitch (degrees) around Y axis
        """
        ...
    @pitch.setter
    def pitch(self, value: float) -> None:
        ...
    @property
    def yaw(self) -> float:
        r"""
        (double):  [Read-Write] Yaw (degrees) around Z axis
        """
        ...
    @yaw.setter
    def yaw(self, value: float) -> None:
        ...
    @property
    def roll(self) -> float:
        r"""
        (double):  [Read-Write] Roll (degrees) around X axis
        """
        ...
    @roll.setter
    def roll(self, value: float) -> None:
        ...
    def lerp(self, b: Rotator, alpha: float, shortest_path: bool) -> Rotator:
        r"""
        x.lerp(b, alpha, shortest_path) -> Rotator
        Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)
        
        Args:
            b (Rotator): 
            alpha (float): 
            shortest_path (bool): 
        
        Returns:
            Rotator:
        """
        ...
    def is_not_near_equal(self, b: Rotator, error_tolerance: float = 0.000100) -> bool:
        r"""
        x.is_not_near_equal(b, error_tolerance=0.000100) -> bool
        Returns true if rotator A is not equal to rotator B (A != B) within a specified error tolerance
        
        Args:
            b (Rotator): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    def delta(self, b: Rotator) -> Rotator:
        r"""
        x.delta(b) -> Rotator
        Normalized A-B
        
        Args:
            b (Rotator): 
        
        Returns:
            Rotator:
        """
        ...
    def inversed(self) -> Rotator:
        r"""
        x.inversed() -> Rotator
        Negate a rotator
        
        Returns:
            Rotator:
        """
        ...
    def scale_integer(self, b: int) -> Rotator:
        r"""
        x.scale_integer(b) -> Rotator
        Returns rotator representing rotator A scaled by B
        
        Args:
            b (int32): 
        
        Returns:
            Rotator:
        """
        ...
    def scale(self, b: float) -> Rotator:
        r"""
        x.scale(b) -> Rotator
        Returns rotator representing rotator A scaled by B
        
        Args:
            b (float): 
        
        Returns:
            Rotator:
        """
        ...
    def get_up_vector(self) -> Vector:
        r"""
        x.get_up_vector() -> Vector
        Rotate the world up vector by the given rotation
        
        Returns:
            Vector:
        """
        ...
    def get_right_vector(self) -> Vector:
        r"""
        x.get_right_vector() -> Vector
        Rotate the world right vector by the given rotation
        
        Returns:
            Vector:
        """
        ...
    def get_forward_vector(self) -> Vector:
        r"""
        x.get_forward_vector() -> Vector
        Rotate the world forward vector by the given rotation
        
        Returns:
            Vector:
        """
        ...
    def get_axes(self) -> Tuple[Vector, Vector, Vector]:
        r"""
        x.get_axes() -> (x=Vector, y=Vector, z=Vector)
        Get the reference frame direction vectors (axes) described by this rotation
        
        Returns:
            tuple: 
        
            x (Vector): 
        
            y (Vector): 
        
            z (Vector):
        """
        ...
    def is_near_equal(self, b: Rotator, error_tolerance: float = 0.000100) -> bool:
        r"""
        x.is_near_equal(b, error_tolerance=0.000100) -> bool
        Returns true if rotator A is equal to rotator B (A == B) within a specified error tolerance
        
        Args:
            b (Rotator): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    def to_vector(self) -> Vector:
        r"""
        x.to_vector() -> Vector
        Get the X direction vector after this rotation
        
        Returns:
            Vector:
        """
        ...
    def transform(self) -> Transform:
        r"""
        x.transform() -> Transform
        Converts Rotator to Transform
        
        Returns:
            Transform:
        """
        ...
    def quaternion(self) -> Quat:
        r"""
        x.quaternion() -> Quat
        Converts to Quaternion representation of this Rotator.
        
        Returns:
            Quat:
        """
        ...
    def combine(self, b: Rotator) -> Rotator:
        r"""
        x.combine(b) -> Rotator
        Combine 2 rotations to give you the resulting rotation of first applying A, then B.
        
        Args:
            b (Rotator): 
        
        Returns:
            Rotator:
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Rotator`` Returns true if rotator A is equal to rotator B (A == B) within a specified error tolerance
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Rotator`` Returns true if rotator A is not equal to rotator B (A != B) within a specified error tolerance
        """
        ...
    def __neg__(self) -> None:
        r"""
        Negate a rotator
        """
        ...

class Rotator3f(StructBase):
    r"""
    An orthogonal rotation in 3d space.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Rotator.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``pitch`` (float):  [Read-Write] Pitch (degrees) around Y axis
    - ``roll`` (float):  [Read-Write] Roll (degrees) around X axis
    - ``yaw`` (float):  [Read-Write] Yaw (degrees) around Z axis
    """
    def __init__(self) -> None:
        ...

class SoftClassPath(SoftObjectPath):
    r"""
    A struct that contains a string reference to a class, can be used to make soft references to classes.
    note: The full C++ class is located here: Engine\Source\Runtime\CoreUObject\Public\UObject\SoftObjectPath.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """
    def __init__(self, path_string: str = "") -> None:
        ...

class StringClassReference(SoftClassPath):
    r"""
    deprecated: 'StringClassReference' was renamed to 'SoftClassPath'.
    """
    def __init__(self, path_string: str = "") -> None:
        ...

class Sphere(StructBase):
    r"""
    3D Sphere represented by Center and Radius.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Sphere.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``center`` (Vector):  [Read-Write]
    - ``w`` (double):  [Read-Write]
    """
    def __init__(self, center: Vector = [0.000000, 0.000000, 0.000000], w: float = 0.000000) -> None:
        ...
    @property
    def center(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @center.setter
    def center(self, value: Vector) -> None:
        ...
    @property
    def w(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @w.setter
    def w(self, value: float) -> None:
        ...

class TemplateString(StructBase):
    r"""
    Structure for templated strings that are displayed in the editor with a allowed args.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``template`` (str):  [Read-Write] The format string.
    """
    def __init__(self, template: str = "") -> None:
        ...
    @property
    def template(self) -> str:
        r"""
        (str):  [Read-Write] The format string.
        """
        ...
    @template.setter
    def template(self, value: str) -> None:
        ...

class Timecode(StructBase):
    r"""
    A timecode that stores time in HH:MM:SS format with the remainder of time represented by an integer frame count.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Misc\TimeCode.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``drop_frame_format`` (bool):  [Read-Write] If true, this Timecode represents a Drop Frame timecode used to account for fractional frame rates in NTSC play rates.
    - ``frames`` (int32):  [Read-Write]
    - ``hours`` (int32):  [Read-Write]
    - ``minutes`` (int32):  [Read-Write]
    - ``seconds`` (int32):  [Read-Write]
    """
    def __init__(self, hours: int = 0, minutes: int = 0, seconds: int = 0, frames: int = 0, drop_frame_format: bool = False) -> None:
        ...
    @property
    def hours(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @hours.setter
    def hours(self, value: int) -> None:
        ...
    @property
    def minutes(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @minutes.setter
    def minutes(self, value: int) -> None:
        ...
    @property
    def seconds(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @seconds.setter
    def seconds(self, value: int) -> None:
        ...
    @property
    def frames(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @frames.setter
    def frames(self, value: int) -> None:
        ...
    @property
    def drop_frame_format(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this Timecode represents a Drop Frame timecode used to account for fractional frame rates in NTSC play rates.
        """
        ...
    @drop_frame_format.setter
    def drop_frame_format(self, value: bool) -> None:
        ...

class Timespan(StructBase):
    r"""
    A time span value, which is the difference between two dates and times.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Misc\Timespan.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """
    def __init__(self, days: int = 0, hours: int = 0, minutes: int = 0, seconds: int = 0, milliseconds: int = 0) -> None:
        ...
    ZERO: Timespan #: (Timespan): Returns a zero time span value
    MIN_VALUE: Timespan #: (Timespan): Returns the minimum time span value
    MAX_VALUE: Timespan #: (Timespan): Returns the maximum time span value

class Transform(StructBase):
    r"""
    Transform composed of Quat/Translation/Scale.
    note: This is implemented in either TransformVectorized.h or TransformNonVectorized.h depending on the platform.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``rotation`` (Quat):  [Read-Write] Rotation of this transformation, as a quaternion.
    - ``scale3d`` (Vector):  [Read-Write] 3D scale (always applied in local space) as a vector.
    - ``translation`` (Vector):  [Read-Write] Translation of this transformation, as a vector.
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], scale: Vector = [1.000000, 1.000000, 1.000000]) -> None:
        ...
    @property
    def rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Write] Rotation of this transformation, as a quaternion.
        """
        ...
    @rotation.setter
    def rotation(self, value: Quat) -> None:
        ...
    @property
    def translation(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Translation of this transformation, as a vector.
        """
        ...
    @translation.setter
    def translation(self, value: Vector) -> None:
        ...
    @property
    def scale3d(self) -> Vector:
        r"""
        (Vector):  [Read-Write] 3D scale (always applied in local space) as a vector.
        """
        ...
    @scale3d.setter
    def scale3d(self, value: Vector) -> None:
        ...
    def transform_rotation(self, rotation: Rotator) -> Rotator:
        r"""
        x.transform_rotation(rotation) -> Rotator
        Transform a rotator by the supplied transform.
        For example, if T was an object's transform, this would transform a rotation from local space to world space.
        
        Args:
            rotation (Rotator): 
        
        Returns:
            Rotator:
        """
        ...
    def transform_location(self, location: Vector) -> Vector:
        r"""
        x.transform_location(location) -> Vector
        Transform a position by the supplied transform.
        For example, if T was an object's transform, this would transform a position from local space to world space.
        
        Args:
            location (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def transform_direction(self, direction: Vector) -> Vector:
        r"""
        x.transform_direction(direction) -> Vector
        Transform a direction vector by the supplied transform - will not change its length.
        For example, if T was an object's transform, this would transform a direction from local space to world space.
        
        Args:
            direction (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def determinant(self) -> float:
        r"""
        x.determinant() -> float
        Calculates the determinant of the transform (converts to FMatrix internally)
        
        Returns:
            float:
        """
        ...
    def lerp(self, b: Transform, alpha: float, interp_mode: LerpInterpolationMode = LerpInterpolationMode.QUAT_INTERP) -> Transform:
        r"""
        x.lerp(b, alpha, interp_mode=LerpInterpolationMode.QUAT_INTERP) -> Transform
        Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1).
        
        Args:
            b (Transform): 
            alpha (float): 
            interp_mode (LerpInterpolationMode): 
        
        Returns:
            Transform:
        """
        ...
    def interp_to(self, target: Transform, delta_time: float, interp_speed: float) -> Transform:
        r"""
        x.interp_to(target, delta_time, interp_speed) -> Transform
        Tries to reach Target transform based on distance from Current position, giving a nice smooth feeling when tracking a position.
        
        Args:
            target (Transform): Target transform
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed, if the speed given is 0, then jump to the target.
        
        Returns:
            Transform: New interpolated transform
        """
        ...
    def is_near_equal(self, b: Transform, location_tolerance: float = 0.000100, rotation_tolerance: float = 0.000100, scale3d_tolerance: float = 0.000100) -> bool:
        r"""
        x.is_near_equal(b, location_tolerance=0.000100, rotation_tolerance=0.000100, scale3d_tolerance=0.000100) -> bool
        Returns true if transform A is nearly equal to B
        
        Args:
            b (Transform): 
            location_tolerance (float): How close position of transforms need to be to be considered equal
            rotation_tolerance (float): How close rotations of transforms need to be to be considered equal
            scale3d_tolerance (float): How close scale of transforms need to be to be considered equal
        
        Returns:
            bool:
        """
        ...
    def make_relative(self, relative_to: Transform) -> Transform:
        r"""
        x.make_relative(relative_to) -> Transform
        Computes a relative transform of one transform compared to another.
        
        Example: ChildOffset = MakeRelativeTransform(Child.GetActorTransform(), Parent.GetActorTransform())
        This computes the relative transform of the Child from the Parent.
        
        Args:
            relative_to (Transform): The transform the result is relative to (in the same space as A)
        
        Returns:
            Transform: The new relative transform
        """
        ...
    def inverse(self) -> Transform:
        r"""
        x.inverse() -> Transform
        Returns the inverse of the given transform T.
        
        Example: Given a LocalToWorld transform, WorldToLocal will be returned.
        
        Returns:
            Transform: The inverse of T.
        """
        ...
    def inverse_transform_rotation(self, rotation: Rotator) -> Rotator:
        r"""
        x.inverse_transform_rotation(rotation) -> Rotator
        Transform a rotator by the inverse of the supplied transform.
        For example, if T was an object's transform, this would transform a rotation from world space to local space.
        
        Args:
            rotation (Rotator): 
        
        Returns:
            Rotator:
        """
        ...
    def inverse_transform_location(self, location: Vector) -> Vector:
        r"""
        x.inverse_transform_location(location) -> Vector
        Transform a position by the inverse of the supplied transform.
        For example, if T was an object's transform, this would transform a position from world space to local space.
        
        Args:
            location (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def inverse_transform_direction(self, direction: Vector) -> Vector:
        r"""
        x.inverse_transform_direction(direction) -> Vector
        Transform a direction vector by the inverse of the supplied transform - will not change its length.
        For example, if T was an object's transform, this would transform a direction from world space to local space.
        
        Args:
            direction (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def equals(self, b: Transform) -> bool:
        r"""
        x.equals(b) -> bool
        Returns true if transform A is equal to transform B
        
        Args:
            b (Transform): 
        
        Returns:
            bool:
        """
        ...
    def to_matrix(self) -> Matrix:
        r"""
        x.to_matrix() -> Matrix
        Converts a Transform to a Matrix with scale
        
        Returns:
            Matrix:
        """
        ...
    def multiply(self, b: Transform) -> Transform:
        r"""
        x.multiply(b) -> Transform
        Compose two transforms in order: A * B.
        
        Order matters when composing transforms:
        A * B will yield a transform that logically first applies A then B to any subsequent transformation.
        
        Example: LocalToWorld = ComposeTransforms(DeltaRotation, LocalToWorld) will change rotation in local space by DeltaRotation.
        Example: LocalToWorld = ComposeTransforms(LocalToWorld, DeltaRotation) will change rotation in world space by DeltaRotation.
        
        Args:
            b (Transform): 
        
        Returns:
            Transform: New transform: A * B
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Transform`` Returns true if transform A is equal to transform B
        """
        ...
    def __mul__(self, other: Transform) -> None:
        r"""
        **Overloads:**
        
        - ``Transform`` Compose two transforms in order: A * B.
          
          Order matters when composing transforms:
          A * B will yield a transform that logically first applies A then B to any subsequent transformation.
          
          Example: LocalToWorld = ComposeTransforms(DeltaRotation, LocalToWorld) will change rotation in local space by DeltaRotation.
          Example: LocalToWorld = ComposeTransforms(LocalToWorld, DeltaRotation) will change rotation in world space by DeltaRotation.
          
          @return New transform: A * B
        """
        ...
    def __imul__(self, other: Transform) -> None:
        r"""
        **Overloads:**
        
        - ``Transform`` Compose two transforms in order: A * B.
          
          Order matters when composing transforms:
          A * B will yield a transform that logically first applies A then B to any subsequent transformation.
          
          Example: LocalToWorld = ComposeTransforms(DeltaRotation, LocalToWorld) will change rotation in local space by DeltaRotation.
          Example: LocalToWorld = ComposeTransforms(LocalToWorld, DeltaRotation) will change rotation in world space by DeltaRotation.
          
          @return New transform: A * B
        """
        ...

class Transform3f(StructBase):
    r"""
    Transform composed of Quat/Translation/Scale.
    note: This is implemented in either TransformVectorized.h or TransformNonVectorized.h depending on the platform.
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``rotation`` (Quat4f):  [Read-Write] Rotation of this transformation, as a quaternion.
    - ``scale3d`` (Vector3f):  [Read-Write] 3D scale (always applied in local space) as a vector.
    - ``translation`` (Vector3f):  [Read-Write] Translation of this transformation, as a vector.
    """
    def __init__(self) -> None:
        ...

class Vector4(StructBase):
    r"""
    A 4-D homogeneous vector.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Vector4.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``w`` (double):  [Read-Write]
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    - ``z`` (double):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000, w: float = 0.000000) -> None:
        ...
    @property
    def x(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: float) -> None:
        ...
    @property
    def y(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: float) -> None:
        ...
    @property
    def z(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: float) -> None:
        ...
    @property
    def w(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @w.setter
    def w(self, value: float) -> None:
        ...
    def length_squared3(self) -> float:
        r"""
        x.length_squared3() -> double
        Returns the squared length of the vector. The W element is ignored.
        
        Returns:
            double:
        """
        ...
    def length_squared(self) -> float:
        r"""
        x.length_squared() -> double
        Returns the squared length of the vector.
        
        Returns:
            double:
        """
        ...
    def length3(self) -> float:
        r"""
        x.length3() -> double
        Returns the length of the vector. The W element is ignored.
        
        Returns:
            double:
        """
        ...
    def length(self) -> float:
        r"""
        x.length() -> double
        Returns the length of the vector.
        
        Returns:
            double:
        """
        ...
    def set(self, x: float, y: float, z: float, w: float) -> None:
        r"""
        x.set(x, y, z, w) -> None
        Set the values of the vector directly.
        
        Args:
            x (double): 
            y (double): 
            z (double): 
            w (double):
        """
        ...
    def normal_unsafe3(self) -> Vector4:
        r"""
        x.normal_unsafe3() -> Vector4
        Calculates normalized unit version of vector without checking for zero length. The W element is ignored and the returned vector has W=0.
        
        Returns:
            Vector4: Normalized version of vector.
        """
        ...
    def normalize3(self, tolerance: float = 0.000000) -> None:
        r"""
        x.normalize3(tolerance=0.000000) -> None
        Normalize this vector in-place if it is large enough or set it to (0,0,0,0) otherwise. The W element is ignored and the returned vector has W=0.
        
        Args:
            tolerance (float): Minimum squared length of vector for normalization.
        """
        ...
    def normal3(self, tolerance: float = 0.000100) -> Vector4:
        r"""
        x.normal3(tolerance=0.000100) -> Vector4
        Gets a normalized unit copy of the vector, ensuring it is safe to do so based on the length. The W element is ignored and the returned vector has W=0.
        Returns zero vector if vector length is too small to safely normalize.
        
        Args:
            tolerance (float): Minimum squared vector length.
        
        Returns:
            Vector4: A normalized copy if safe, (0,0,0) otherwise.
        """
        ...
    def negated(self) -> Vector4:
        r"""
        x.negated() -> Vector4
        Gets a negated copy of the vector. Equivalent to -Vector for scripts.
        
        Returns:
            Vector4:
        """
        ...
    def mirror_by_vector3(self, surface_normal: Vector4) -> Vector4:
        r"""
        x.mirror_by_vector3(surface_normal) -> Vector4
        Given a direction vector and a surface normal, returns the vector reflected across the surface normal.
        Produces a result like shining a laser at a mirror!
        The W element is ignored.
        
        Args:
            surface_normal (Vector4): A normal of the surface the ray should be reflected on.
        
        Returns:
            Vector4: Reflected vector.
        """
        ...
    def is_zero(self) -> bool:
        r"""
        x.is_zero() -> bool
        Checks whether all components of the vector are exactly zero.
        
        Returns:
            bool: true if vector is exactly zero, otherwise false.
        """
        ...
    def is_unit3(self, squared_lenth_tolerance: float = 0.000100) -> bool:
        r"""
        x.is_unit3(squared_lenth_tolerance=0.000100) -> bool
        Determines if vector is normalized / unit (length 1) within specified squared tolerance. The W element is ignored.
        
        Args:
            squared_lenth_tolerance (float): 
        
        Returns:
            bool: true if unit, false otherwise.
        """
        ...
    def is_normal3(self) -> bool:
        r"""
        x.is_normal3() -> bool
        Determines if vector is normalized / unit (length 1). The W element is ignored.
        
        Returns:
            bool: true if normalized, false otherwise.
        """
        ...
    def is_nearly_zero3(self, tolerance: float = 0.000100) -> bool:
        r"""
        x.is_nearly_zero3(tolerance=0.000100) -> bool
        Checks whether vector is near to zero within a specified tolerance. The W element is ignored.
        
        Args:
            tolerance (float): Error tolerance.
        
        Returns:
            bool: true if vector is in tolerance to zero, otherwise false.
        """
        ...
    def is_nan(self) -> bool:
        r"""
        x.is_nan() -> bool
        Determines if any component is not a number (NAN)
        
        Returns:
            bool: true if one or more components is NAN, otherwise false.
        """
        ...
    def dot3(self, b: Vector4) -> float:
        r"""
        x.dot3(b) -> double
        Returns the dot product of two vectors - see http://mathworld.wolfram.com/DotProduct.html The W element is ignored.
        
        Args:
            b (Vector4): 
        
        Returns:
            double:
        """
        ...
    def dot(self, b: Vector4) -> float:
        r"""
        x.dot(b) -> double
        Returns the dot product of two vectors - see http://mathworld.wolfram.com/DotProduct.html
        
        Args:
            b (Vector4): 
        
        Returns:
            double:
        """
        ...
    def cross3(self, b: Vector4) -> Vector4:
        r"""
        x.cross3(b) -> Vector4
        Returns the cross product of two vectors - see  http://mathworld.wolfram.com/CrossProduct.html
        
        Args:
            b (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    def assign(self, vector: Vector4) -> None:
        r"""
        x.assign(vector) -> None
        Assign the values of the supplied vector.
        
        Args:
            vector (Vector4): Vector to copy values from.
        """
        ...
    def subtract(self, b: Vector4) -> Vector4:
        r"""
        x.subtract(b) -> Vector4
        Returns subtraction of Vector B from Vector A (A - B)
        
        Args:
            b (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    def not_equal(self, b: Vector4) -> bool:
        r"""
        x.not_equal(b) -> bool
        Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance
        
        Args:
            b (Vector4): 
        
        Returns:
            bool:
        """
        ...
    def is_not_near_equal(self, b: Vector4, error_tolerance: float = 0.000100) -> bool:
        r"""
        x.is_not_near_equal(b, error_tolerance=0.000100) -> bool
        Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance
        
        Args:
            b (Vector4): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    def multiply(self, b: Vector4) -> Vector4:
        r"""
        x.multiply(b) -> Vector4
        Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z, A.w*B.w})
        
        Args:
            b (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    def equals(self, b: Vector4) -> bool:
        r"""
        x.equals(b) -> bool
        Returns true if vector A is equal to vector B (A == B)
        
        Args:
            b (Vector4): 
        
        Returns:
            bool:
        """
        ...
    def is_near_equal(self, b: Vector4, error_tolerance: float = 0.000100) -> bool:
        r"""
        x.is_near_equal(b, error_tolerance=0.000100) -> bool
        Returns true if vector A is equal to vector B (A == B) within a specified error tolerance
        
        Args:
            b (Vector4): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    def divide(self, b: Vector4) -> Vector4:
        r"""
        x.divide(b) -> Vector4
        Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y, A.z/B.z, A.w/B.w})
        
        Args:
            b (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    def vector(self) -> Vector:
        r"""
        x.vector() -> Vector
        Converts a Vector4 to a Vector (dropping the W element)
        
        Returns:
            Vector:
        """
        ...
    def rotator(self) -> Rotator:
        r"""
        x.rotator() -> Rotator
        Return the FRotator orientation corresponding to the direction in which the vector points.
        Sets Yaw and Pitch to the proper numbers, and sets Roll to zero because the roll can't be determined from a vector.
        
        Returns:
            Rotator: FRotator from the Vector's direction, without any roll.
        """
        ...
    def quaternion(self) -> Quat:
        r"""
        x.quaternion() -> Quat
        Return the Quaternion orientation corresponding to the direction in which the vector points.
        Similar to the FRotator version, returns a result without roll such that it preserves the up vector.
        note: If you don't care about preserving the up vector and just want the most direct rotation, you can use the faster 'FindBetweenVectors(ForwardVector, YourVector)' or 'FindBetweenNormals(...)' if you know the vector is of unit length.
        
        Returns:
            Quat: Quaternion from the Vector's direction, without any roll.
        """
        ...
    def add(self, b: Vector4) -> Vector4:
        r"""
        x.add(b) -> Vector4
        Returns addition of Vector A and Vector B (A + B)
        
        Args:
            b (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Vector4`` Returns true if vector A is equal to vector B (A == B)
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``Vector4`` Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance
        """
        ...
    def __add__(self, other: Vector4) -> None:
        r"""
        **Overloads:**
        
        - ``Vector4`` Returns addition of Vector A and Vector B (A + B)
        """
        ...
    def __iadd__(self, other: Vector4) -> None:
        r"""
        **Overloads:**
        
        - ``Vector4`` Returns addition of Vector A and Vector B (A + B)
        """
        ...
    def __sub__(self, other: Vector4) -> None:
        r"""
        **Overloads:**
        
        - ``Vector4`` Returns subtraction of Vector B from Vector A (A - B)
        """
        ...
    def __isub__(self, other: Vector4) -> None:
        r"""
        **Overloads:**
        
        - ``Vector4`` Returns subtraction of Vector B from Vector A (A - B)
        """
        ...
    def __mul__(self, other: Vector4) -> None:
        r"""
        **Overloads:**
        
        - ``Vector4`` Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z, A.w*B.w})
        """
        ...
    def __imul__(self, other: Vector4) -> None:
        r"""
        **Overloads:**
        
        - ``Vector4`` Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z, A.w*B.w})
        """
        ...
    def __truediv__(self, other: Vector4) -> None:
        r"""
        **Overloads:**
        
        - ``Vector4`` Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y, A.z/B.z, A.w/B.w})
        """
        ...
    def __or__(self, other: Vector4) -> None:
        r"""
        **Overloads:**
        
        - ``Vector4`` Returns the dot product of two vectors - see http://mathworld.wolfram.com/DotProduct.html
        """
        ...
    def __neg__(self) -> None:
        r"""
        Gets a negated copy of the vector. Equivalent to -Vector for scripts.
        """
        ...
    ZERO: Vector4 #: (Vector4): 4D vector zero constant (0,0,0)

class Vector4f(StructBase):
    r"""
    A 4-D homogeneous vector.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Vector4.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``w`` (float):  [Read-Write]
    - ``x`` (float):  [Read-Write]
    - ``y`` (float):  [Read-Write]
    - ``z`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class FloatRK4SpringInterpolator(StructBase):
    r"""
    Float RK4Spring Interpolator
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SpringInterpolator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``dampening_ratio`` (float):  [Read-Write] 0 = Undamped, <1 = Underdamped, 1 = Critically damped, >1 = Over damped
    - ``stiffness_constant`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class FormatArgumentData(StructBase):
    r"""
    Used to pass argument/value pairs into FText::Format.
    The full C++ struct is located here: Engine\Source\Runtime\Core\Public\Internationalization\Text.h
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetTextLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument_name`` (str):  [Read-Write]
    - ``argument_value`` (Text):  [Read-Write]
    - ``argument_value_double`` (double):  [Read-Write]
    - ``argument_value_float`` (float):  [Read-Write]
    - ``argument_value_gender`` (TextGender):  [Read-Write]
    - ``argument_value_int`` (int64):  [Read-Write]
    - ``argument_value_type`` (FormatArgumentType):  [Read-Write]
    """
    def __init__(self, argument_name: str = "", argument_value_type: FormatArgumentType = FormatArgumentType.INT, argument_value: Text = "", argument_value_int: int = 0, argument_value_float: float = 0.000000, argument_value_double: float = 0.000000, argument_value_gender: TextGender = TextGender.MASCULINE) -> None:
        ...
    @property
    def argument_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @argument_name.setter
    def argument_name(self, value: str) -> None:
        ...
    @property
    def argument_value_type(self) -> FormatArgumentType:
        r"""
        (FormatArgumentType):  [Read-Write]
        """
        ...
    @argument_value_type.setter
    def argument_value_type(self, value: FormatArgumentType) -> None:
        ...
    @property
    def argument_value(self) -> Text:
        r"""
        (Text):  [Read-Write]
        """
        ...
    @argument_value.setter
    def argument_value(self, value: Text) -> None:
        ...
    @property
    def text_value(self) -> Text:
        r"""
        deprecated: 'text_value' was renamed to 'argument_value'.
        """
        ...
    @text_value.setter
    def text_value(self, value: Text) -> None:
        ...
    @property
    def argument_value_int(self) -> int:
        r"""
        (int64):  [Read-Write]
        """
        ...
    @argument_value_int.setter
    def argument_value_int(self, value: int) -> None:
        ...
    @property
    def argument_value_float(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @argument_value_float.setter
    def argument_value_float(self, value: float) -> None:
        ...
    @property
    def argument_value_double(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @argument_value_double.setter
    def argument_value_double(self, value: float) -> None:
        ...
    @property
    def argument_value_gender(self) -> TextGender:
        r"""
        (TextGender):  [Read-Write]
        """
        ...
    @argument_value_gender.setter
    def argument_value_gender(self, value: TextGender) -> None:
        ...

class FormatTextArgument(FormatArgumentData):
    r"""
    deprecated: 'FormatTextArgument' was renamed to 'FormatArgumentData'.
    """
    def __init__(self, argument_name: str = "", argument_value_type: FormatArgumentType = FormatArgumentType.INT, argument_value: Text = "", argument_value_int: int = 0, argument_value_float: float = 0.000000, argument_value_double: float = 0.000000, argument_value_gender: TextGender = TextGender.MASCULINE) -> None:
        ...

class VectorRK4SpringInterpolator(StructBase):
    r"""
    Vector RK4Spring Interpolator
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SpringInterpolator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``dampening_ratio`` (float):  [Read-Write] 0 = Undamped, <1 = Underdamped, 1 = Critically damped, >1 = Over damped
    - ``stiffness_constant`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AnimDataModelNotifPayload(StructBase):
    r"""
    Anim Data Model Notif Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    """
    def __init__(self) -> None:
        ...
    def get_payload(self) -> EmptyPayload:
        r"""
        x.get_payload() -> EmptyPayload
        Get Payload
        
        Returns:
            EmptyPayload:
        """
        ...
    def copy_payload(self, expected_struct: ScriptStruct, out_payload: EmptyPayload) -> EmptyPayload:
        r"""
        x.copy_payload(expected_struct, out_payload) -> EmptyPayload
        Copy Payload
        
        Args:
            expected_struct (ScriptStruct): 
            out_payload (EmptyPayload): 
        
        Returns:
            EmptyPayload: 
        
            out_payload (EmptyPayload):
        """
        ...

class ChaosBreakEvent(StructBase):
    r"""
    Chaos Break Event
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChaosEventType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_velocity`` (Vector):  [Read-Write] Angular Velocity of the breaking particle
    - ``component`` (PrimitiveComponent):  [Read-Write] primitive component involved in the break event
    - ``extents`` (Vector):  [Read-Write] Extents of the bounding box
    - ``from_crumble`` (bool):  [Read-Write] Whether the break event originated from a crumble event
    - ``index`` (int32):  [Read-Write] Index of the geometry collection bone if positive
    - ``location`` (Vector):  [Read-Write] World location of the break
    - ``mass`` (float):  [Read-Write] Mass of the breaking particle
    - ``velocity`` (Vector):  [Read-Write] Linear Velocity of the breaking particle
    """
    def __init__(self, component: PrimitiveComponent = None, location: Vector = [0.000000, 0.000000, 0.000000], velocity: Vector = [0.000000, 0.000000, 0.000000], angular_velocity: Vector = [0.000000, 0.000000, 0.000000], extents: Vector = [0.000000, 0.000000, 0.000000], mass: float = 0.000000, index: int = 0, from_crumble: bool = False) -> None:
        ...
    @property
    def component(self) -> PrimitiveComponent:
        r"""
        (PrimitiveComponent):  [Read-Only] primitive component involved in the break event
        """
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Only] World location of the break
        """
        ...
    @property
    def velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Linear Velocity of the breaking particle
        """
        ...
    @property
    def angular_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Angular Velocity of the breaking particle
        """
        ...
    @property
    def extents(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Extents of the bounding box
        """
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Only] Mass of the breaking particle
        """
        ...
    @property
    def index(self) -> int:
        r"""
        (int32):  [Read-Only] Index of the geometry collection bone if positive
        """
        ...
    @property
    def from_crumble(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the break event originated from a crumble event
        """
        ...

class CollisionChaosEvent(StructBase):
    r"""
    Collision Chaos Event
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChaosEventType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accumulated_impulse`` (Vector):  [Read-Write]
    - ``body1`` (CollisionChaosEventBodyInfo):  [Read-Write]
    - ``body2`` (CollisionChaosEventBodyInfo):  [Read-Write]
    - ``location`` (Vector):  [Read-Write]
    - ``normal`` (Vector):  [Read-Write]
    - ``penetration_depth`` (float):  [Read-Write]
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], accumulated_impulse: Vector = [0.000000, 0.000000, 0.000000], normal: Vector = [0.000000, 0.000000, 0.000000], penetration_depth: float = 0.000000, body1: CollisionChaosEventBodyInfo = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], 0.000000, None, None, 0, "None"], body2: CollisionChaosEventBodyInfo = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], 0.000000, None, None, 0, "None"]) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def accumulated_impulse(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def normal(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def penetration_depth(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def body1(self) -> CollisionChaosEventBodyInfo:
        r"""
        (CollisionChaosEventBodyInfo):  [Read-Only]
        """
        ...
    @property
    def body2(self) -> CollisionChaosEventBodyInfo:
        r"""
        (CollisionChaosEventBodyInfo):  [Read-Only]
        """
        ...

class CollisionChaosEventBodyInfo(StructBase):
    r"""
    Collision Chaos Event Body Info
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChaosEventType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_velocity`` (Vector):  [Read-Write]
    - ``body_index`` (int32):  [Read-Write]
    - ``bone_name`` (Name):  [Read-Write]
    - ``component`` (PrimitiveComponent):  [Read-Write]
    - ``delta_velocity`` (Vector):  [Read-Write]
    - ``mass`` (float):  [Read-Write]
    - ``phys_material`` (PhysicalMaterial):  [Read-Write]
    - ``velocity`` (Vector):  [Read-Write]
    """
    def __init__(self, velocity: Vector = [0.000000, 0.000000, 0.000000], delta_velocity: Vector = [0.000000, 0.000000, 0.000000], angular_velocity: Vector = [0.000000, 0.000000, 0.000000], mass: float = 0.000000, phys_material: PhysicalMaterial = None, component: PrimitiveComponent = None, body_index: int = 0, bone_name: Name = "None") -> None:
        ...
    @property
    def velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def delta_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def angular_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def phys_material(self) -> PhysicalMaterial:
        r"""
        (PhysicalMaterial):  [Read-Only]
        """
        ...
    @property
    def component(self) -> PrimitiveComponent:
        r"""
        (PrimitiveComponent):  [Read-Only]
        """
        ...
    @property
    def body_index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def bone_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...

class ChaosCrumblingEvent(StructBase):
    r"""
    Chaos Crumbling Event
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChaosEventType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_velocity`` (Vector):  [Read-Write] Angular Velocity of the crumbling cluster
    - ``children`` (Array[int32]):  [Read-Write] List of children indices released (optional : see geometry collection component bCrumblingEventIncludesChildren)
    - ``component`` (PrimitiveComponent):  [Read-Write] primitive component involved in the crumble event
    - ``linear_velocity`` (Vector):  [Read-Write] Linear Velocity of the crumbling cluster
    - ``local_bounds`` (Box):  [Read-Write] Local bounding box of the crumbling cluster
    - ``location`` (Vector):  [Read-Write] World location of the crumbling cluster
    - ``mass`` (float):  [Read-Write] Mass of the crumbling cluster
    - ``orientation`` (Quat):  [Read-Write] World orientation of the crumbling cluster
    """
    def __init__(self, component: PrimitiveComponent = None, location: Vector = [0.000000, 0.000000, 0.000000], orientation: Quat = [0.000000, 0.000000, 0.000000, 1.000000], linear_velocity: Vector = [0.000000, 0.000000, 0.000000], angular_velocity: Vector = [0.000000, 0.000000, 0.000000], mass: float = 0.000000, local_bounds: Box = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], False], children: Array[int] = []) -> None:
        ...
    @property
    def component(self) -> PrimitiveComponent:
        r"""
        (PrimitiveComponent):  [Read-Only] primitive component involved in the crumble event
        """
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Only] World location of the crumbling cluster
        """
        ...
    @property
    def orientation(self) -> Quat:
        r"""
        (Quat):  [Read-Only] World orientation of the crumbling cluster
        """
        ...
    @property
    def linear_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Linear Velocity of the crumbling cluster
        """
        ...
    @property
    def angular_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Angular Velocity of the crumbling cluster
        """
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Only] Mass of the crumbling cluster
        """
        ...
    @property
    def local_bounds(self) -> Box:
        r"""
        (Box):  [Read-Only] Local bounding box of the crumbling cluster
        """
        ...
    @property
    def children(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Only] List of children indices released (optional : see geometry collection component bCrumblingEventIncludesChildren)
        """
        ...

class Key(StructBase):
    r"""
    Key
    
    **C++ Source:**
    
    - **Module**: InputCore
    - **File**: InputCoreTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``key_name`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class HitResult(StructBase):
    r"""
    Structure containing information about one hit of a trace, such as point of impact and surface normal at that point.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HitResult.h
    
    """
    def __init__(self, blocking_hit: bool = False, initial_overlap: bool = False, time: float = 0.000000, distance: float = 0.000000, location: Vector = [0.000000, 0.000000, 0.000000], impact_point: Vector = [0.000000, 0.000000, 0.000000], normal: Vector = [0.000000, 0.000000, 1.000000], impact_normal: Vector = [0.000000, 0.000000, 1.000000], phys_mat: PhysicalMaterial = None, hit_actor: Actor = None, hit_component: PrimitiveComponent = None, hit_bone_name: Name = "None", bone_name: Name = "None", hit_item: int = 0, element_index: int = 0, face_index: int = 0, trace_start: Vector = [0.000000, 0.000000, 0.000000], trace_end: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class ActorInstanceHandle(StructBase):
    r"""
    Handle to a unique object. This may specify a full weigh actor or it may only specify the actor instance that represents the same object.
    note: The handle has game thread constraints related to UObjects and should be used carefully from other threads. Can only be used on the game thread -       all constructors -       all getters (GetXYZ, FetchActor, IsActorValid, DoesRepresent) * -       comparison operators against live AActor pointer Can be used on any thread -       MakeActorHandleToResolve to create a handle that will be lazily resolved on the game thread since it only stores a weak object ptr without any access to the live object -       handle validity and comparison operators against another handle (i.e. IsValid(), operator==|!=(const FActorInstanceHandle& Other))
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ActorInstanceHandle.h
    
    """
    def __init__(self) -> None:
        ...

class Vector_NetQuantize(Vector):
    r"""
    FVector_NetQuantize
    
    0 decimal place of precision.
    Up to 20 bits per component.
    Valid range: 2^20 = +/- 1,048,576
    
    Note: this is the historical UE format for vector net serialization
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NetSerialization.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    - ``z`` (double):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000) -> None:
        ...

class Vector_NetQuantizeNormal(Vector):
    r"""
    FVector_NetQuantizeNormal
    
    16 bits per component
    Valid range: -1..+1 inclusive
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NetSerialization.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    - ``z`` (double):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000) -> None:
        ...

class SubtitleCue(StructBase):
    r"""
    A line of subtitle text and the time at which it should be displayed.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``text`` (Text):  [Read-Write] The text to appear in the subtitle.
    - ``time`` (float):  [Read-Write] The time at which the subtitle is to be displayed, in seconds relative to the beginning of the line.
    """
    def __init__(self, text: Text = "", time: float = 0.000000) -> None:
        ...
    @property
    def text(self) -> Text:
        r"""
        (Text):  [Read-Only] The text to appear in the subtitle.
        """
        ...
    @property
    def time(self) -> float:
        r"""
        (float):  [Read-Only] The time at which the subtitle is to be displayed, in seconds relative to the beginning of the line.
        """
        ...

class ChaosRemovalEvent(StructBase):
    r"""
    Chaos Removal Event
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChaosEventType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``component`` (PrimitiveComponent):  [Read-Write]
    - ``location`` (Vector):  [Read-Write]
    - ``mass`` (float):  [Read-Write]
    """
    def __init__(self, component: PrimitiveComponent = None, location: Vector = [0.000000, 0.000000, 0.000000], mass: float = 0.000000) -> None:
        ...
    @property
    def component(self) -> PrimitiveComponent:
        r"""
        (PrimitiveComponent):  [Read-Only]
        """
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class InterpControlPoint(StructBase):
    r"""
    Interp Control Point
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InterpToMovementComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``position_control_point`` (Vector):  [Read-Write] The position of the point
    - ``position_is_relative`` (bool):  [Read-Write] Is the location relative to the root components initial location
    """
    def __init__(self, position_control_point: Vector = [0.000000, 0.000000, 0.000000], position_is_relative: bool = False) -> None:
        ...
    @property
    def position_control_point(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The position of the point
        """
        ...
    @position_control_point.setter
    def position_control_point(self, value: Vector) -> None:
        ...
    @property
    def position_is_relative(self) -> bool:
        r"""
        (bool):  [Read-Write] Is the location relative to the root components initial location
        """
        ...
    @position_is_relative.setter
    def position_is_relative(self, value: bool) -> None:
        ...

class DebugFloatHistory(StructBase):
    r"""
    Structure for recording float values and displaying them as an Histogram through DrawDebugFloatHistory.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_adjust_min_max`` (bool):  [Read-Write] Auto adjust Min/Max as new values are recorded?
    - ``max_samples`` (int32):  [Read-Write] Max Samples to record.
    - ``max_value`` (float):  [Read-Write] Max value to record.
    - ``min_value`` (float):  [Read-Write] Min value to record.
    """
    def __init__(self, max_samples: int = 0, min_value: float = 0.000000, max_value: float = 0.000000, auto_adjust_min_max: bool = False) -> None:
        ...
    @property
    def max_samples(self) -> int:
        r"""
        (int32):  [Read-Write] Max Samples to record.
        """
        ...
    @max_samples.setter
    def max_samples(self, value: int) -> None:
        ...
    @property
    def min_value(self) -> float:
        r"""
        (float):  [Read-Write] Min value to record.
        """
        ...
    @min_value.setter
    def min_value(self, value: float) -> None:
        ...
    @property
    def max_value(self) -> float:
        r"""
        (float):  [Read-Write] Max value to record.
        """
        ...
    @max_value.setter
    def max_value(self, value: float) -> None:
        ...
    @property
    def auto_adjust_min_max(self) -> bool:
        r"""
        (bool):  [Read-Write] Auto adjust Min/Max as new values are recorded?
        """
        ...
    @auto_adjust_min_max.setter
    def auto_adjust_min_max(self, value: bool) -> None:
        ...

class BaseComponentReference(StructBase):
    r"""
    Base class for the hard/soft component reference structs
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``component_property`` (Name):  [Read-Write] Name of component to use. If this is not specified the reference refers to the root component.
    - ``path_to_component`` (str):  [Read-Write] Path to the component from its owner actor
    """
    def __init__(self, component_property: Name = "None") -> None:
        ...
    @property
    def component_property(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of component to use. If this is not specified the reference refers to the root component.
        """
        ...
    @component_property.setter
    def component_property(self, value: Name) -> None:
        ...

class SoftComponentReference(BaseComponentReference):
    r"""
    Struct that allows for different ways to reference a component using TSoftObjectPtr.
    If just an Actor is specified, will return RootComponent of that Actor.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``component_property`` (Name):  [Read-Write] Name of component to use. If this is not specified the reference refers to the root component.
    - ``other_actor`` (Actor):  [Read-Write] Soft Pointer to a different Actor that owns the Component.
      If this is not provided the reference refers to a component on this / the same actor.
    - ``path_to_component`` (str):  [Read-Write] Path to the component from its owner actor
    """
    def __init__(self, component_property: Name = "None", other_actor: Actor = None) -> None:
        ...
    @property
    def other_actor(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Soft Pointer to a different Actor that owns the Component.
        If this is not provided the reference refers to a component on this / the same actor.
        """
        ...
    @other_actor.setter
    def other_actor(self, value: Actor) -> None:
        ...

class ComponentReference(BaseComponentReference):
    r"""
    Struct that allows for different ways to reference a component using TObjectPtr.
    If just an Actor is specified, will return RootComponent of that Actor.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``component_property`` (Name):  [Read-Write] Name of component to use. If this is not specified the reference refers to the root component.
    - ``other_actor`` (Actor):  [Read-Write] Weak Pointer to a different Actor that owns the Component.
      If this is not provided the reference refers to a component on this / the same actor.
    - ``path_to_component`` (str):  [Read-Write] Path to the component from its owner actor
    """
    def __init__(self, component_property: Name = "None", other_actor: Actor = None) -> None:
        ...
    @property
    def other_actor(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Weak Pointer to a different Actor that owns the Component.
        If this is not provided the reference refers to a component on this / the same actor.
        """
        ...
    @other_actor.setter
    def other_actor(self, value: Actor) -> None:
        ...

class LatentActionInfo(StructBase):
    r"""
    Latent action info
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LatentActionManager.h
    
    """
    def __init__(self) -> None:
        ...

class TimerHandle(StructBase):
    r"""
    Unique handle that can be used to distinguish timers that have identical delegates.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimerHandle.h
    
    """
    def __init__(self) -> None:
        ...

class CollisionProfileName(StructBase):
    r"""
    Structure representing a collision profile name, this gets a special UI in the editor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CollisionProfile.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    """
    def __init__(self, name: Name = "None") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...

class GenericStruct(StructBase):
    r"""
    Generic Struct
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetSystemLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class UserActivity(StructBase):
    r"""
    The description of a user activity
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``action_name`` (str):  [Read-Write] Describes the user's activity
    """
    def __init__(self, action_name: str = "") -> None:
        ...
    @property
    def action_name(self) -> str:
        r"""
        (str):  [Read-Write] Describes the user's activity
        """
        ...
    @action_name.setter
    def action_name(self, value: str) -> None:
        ...

class FloatAnimationAttribute(StructBase):
    r"""
    Attribute type supporting the legacy TVariant<float> atttributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class IntegerAnimationAttribute(StructBase):
    r"""
    Attribute type supporting the legacy TVariant<int32> atttributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0) -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: int) -> None:
        ...

class StringAnimationAttribute(StructBase):
    r"""
    Attribute type supporting the legacy TVariant<FString> attributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, value: str = "") -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...

class TransformAnimationAttribute(StructBase):
    r"""
    Attribute type supporting the legacy TVariant<FTransform> attributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...

class VectorAnimationAttribute(StructBase):
    r"""
    Vector Animation Attribute
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...

class QuaternionAnimationAttribute(StructBase):
    r"""
    Quaternion Animation Attribute
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...

class ScriptTypedElementHandle(StructBase):
    r"""
    Script exposure for the typed element handle struct type
    Act as a weak handle to simplify the scripting use of the typed element framework and making it safer to use by avoiding crash in case of a bad usage.
    This type is the standard way that an element is passed through to interfaces for a script (Blueprint or Python), and also the type that is stored in the script element lists.
    C++ code may choose to use TTypedElement instead, which is a combination of an element handle and its associated element interface.
    
    Note: This type shouldn't be used in the engine code as it come with a performance and memory overhead that we want to avoid when compare to the native handles (FTypedElementHandle).
    
    **C++ Source:**
    
    - **Module**: TypedElementFramework
    - **File**: TypedElementHandle.h
    
    """
    def __init__(self) -> None:
        ...
    def release(self) -> None:
        r"""
        x.release() -> None
        Release this handle and set it back to an empty state.
        """
        ...
    def not_equal(self, rhs: ScriptTypedElementHandle) -> bool:
        r"""
        x.not_equal(rhs) -> bool
        Are these two handles not equal?
        
        Args:
            rhs (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    def is_set(self) -> bool:
        r"""
        x.is_set() -> bool
        Has this handle been initialized to a valid element?
        
        Returns:
            bool:
        """
        ...
    def equal(self, rhs: ScriptTypedElementHandle) -> bool:
        r"""
        x.equal(rhs) -> bool
        Are these two handles equal?
        
        Args:
            rhs (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    def __bool__(self) -> bool:
        r"""
        Has this handle been initialized to a valid element?
        """
        ...
    def __eq__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``ScriptTypedElementHandle`` Are these two handles equal?
        """
        ...
    def __ne__(self, other: object) -> bool:
        r"""
        **Overloads:**
        
        - ``ScriptTypedElementHandle`` Are these two handles not equal?
        """
        ...

class TypedElementSelectionOptions(StructBase):
    r"""
    Typed Element Selection Options
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementSelectionInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_groups`` (bool):  [Read-Write]
    - ``allow_hidden`` (bool):  [Read-Write]
    - ``allow_legacy_notifications`` (bool):  [Read-Write]
    - ``allow_sub_root_selection`` (bool):  [Read-Write]
    - ``child_element_inclusion_method`` (TypedElementChildInclusionMethod):  [Read-Write]
    - ``warn_if_locked`` (bool):  [Read-Write]
    """
    def __init__(self, allow_hidden: bool = False, allow_groups: bool = False, allow_legacy_notifications: bool = False, warn_if_locked: bool = False, allow_sub_root_selection: bool = False, child_element_inclusion_method: TypedElementChildInclusionMethod = TypedElementChildInclusionMethod.NONE) -> None:
        ...
    @property
    def allow_hidden(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_hidden.setter
    def allow_hidden(self, value: bool) -> None:
        ...
    @property
    def allow_groups(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_groups.setter
    def allow_groups(self, value: bool) -> None:
        ...
    @property
    def allow_legacy_notifications(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_legacy_notifications.setter
    def allow_legacy_notifications(self, value: bool) -> None:
        ...
    @property
    def warn_if_locked(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @warn_if_locked.setter
    def warn_if_locked(self, value: bool) -> None:
        ...
    @property
    def allow_sub_root_selection(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_sub_root_selection.setter
    def allow_sub_root_selection(self, value: bool) -> None:
        ...
    @property
    def child_element_inclusion_method(self) -> TypedElementChildInclusionMethod:
        r"""
        (TypedElementChildInclusionMethod):  [Read-Write]
        """
        ...
    @child_element_inclusion_method.setter
    def child_element_inclusion_method(self, value: TypedElementChildInclusionMethod) -> None:
        ...

class TypedElementSelectionSetState(StructBase):
    r"""
    Typed Element Selection Set State
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementSelectionSet.h
    
    """
    def __init__(self) -> None:
        ...

class TypedElementIsSelectedOptions(StructBase):
    r"""
    Typed Element Is Selected Options
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementSelectionInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_indirect`` (bool):  [Read-Write]
    """
    def __init__(self, allow_indirect: bool = False) -> None:
        ...
    @property
    def allow_indirect(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_indirect.setter
    def allow_indirect(self, value: bool) -> None:
        ...

class ToolMenuContext(StructBase):
    r"""
    Tool Menu Context
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuContext.h
    
    """
    def __init__(self) -> None:
        ...
    def find_by_class(self, class_: Class) -> Object:
        r"""
        x.find_by_class(class_) -> Object
        Find by Class
        
        Args:
            class_ (type(Class)): 
        
        Returns:
            Object:
        """
        ...

class GameplayResourceSet(StructBase):
    r"""
    Gameplay Resource Set
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTask.h
    
    """
    def __init__(self) -> None:
        ...

class ActorPerceptionUpdateInfo(StructBase):
    r"""
    Actor Perception Update Info
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``stimulus`` (AIStimulus):  [Read-Write] Updated stimulus
    - ``target`` (Actor):  [Read-Write] Actor associated to the stimulus (can be null)
    - ``target_id`` (int32):  [Read-Write] Id of to the stimulus source
    """
    def __init__(self, target_id: int = 0, target: Actor = None, stimulus: AIStimulus = [340282346638528859811704183484516925440.000000, 340282346638528859811704183484516925440.000000, -1.000000, [340282346638528859811704183484516925440.000000, 340282346638528859811704183484516925440.000000, 340282346638528859811704183484516925440.000000], [340282346638528859811704183484516925440.000000, 340282346638528859811704183484516925440.000000, 340282346638528859811704183484516925440.000000], "None", False]) -> None:
        ...
    @property
    def target_id(self) -> int:
        r"""
        (int32):  [Read-Write] Id of to the stimulus source
        """
        ...
    @target_id.setter
    def target_id(self, value: int) -> None:
        ...
    @property
    def target(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Actor associated to the stimulus (can be null)
        """
        ...
    @target.setter
    def target(self, value: Actor) -> None:
        ...
    @property
    def stimulus(self) -> AIStimulus:
        r"""
        (AIStimulus):  [Read-Write] Updated stimulus
        """
        ...
    @stimulus.setter
    def stimulus(self, value: AIStimulus) -> None:
        ...

class AIStimulus(StructBase):
    r"""
    AIStimulus
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``age`` (float):  [Read-Write]
    - ``expiration_age`` (float):  [Read-Write]
    - ``receiver_location`` (Vector):  [Read-Write]
    - ``stimulus_location`` (Vector):  [Read-Write]
    - ``strength`` (float):  [Read-Write]
    - ``successfully_sensed`` (bool):  [Read-Write]
    - ``tag`` (Name):  [Read-Write]
    """
    def __init__(self, age: float = 0.000000, expiration_age: float = 0.000000, strength: float = 0.000000, stimulus_location: Vector = [0.000000, 0.000000, 0.000000], receiver_location: Vector = [0.000000, 0.000000, 0.000000], tag: Name = "None", successfully_sensed: bool = False) -> None:
        ...
    @property
    def age(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @age.setter
    def age(self, value: float) -> None:
        ...
    @property
    def expiration_age(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @expiration_age.setter
    def expiration_age(self, value: float) -> None:
        ...
    @property
    def strength(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @strength.setter
    def strength(self, value: float) -> None:
        ...
    @property
    def stimulus_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @stimulus_location.setter
    def stimulus_location(self, value: Vector) -> None:
        ...
    @property
    def receiver_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @receiver_location.setter
    def receiver_location(self, value: Vector) -> None:
        ...
    @property
    def tag(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @tag.setter
    def tag(self, value: Name) -> None:
        ...
    @property
    def successfully_sensed(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @successfully_sensed.setter
    def successfully_sensed(self, value: bool) -> None:
        ...

class AIRequestID(StructBase):
    r"""
    AIRequest ID
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AITypes.h
    
    """
    def __init__(self) -> None:
        ...

class ChaosPhysicsCollisionInfo(StructBase):
    r"""
    Chaos Physics Collision Info
    
    **C++ Source:**
    
    - **Module**: ChaosSolverEngine
    - **File**: ChaosNotifyHandlerInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accumulated_impulse`` (Vector):  [Read-Write]
    - ``angular_velocity`` (Vector):  [Read-Write]
    - ``component`` (PrimitiveComponent):  [Read-Write]
    - ``location`` (Vector):  [Read-Write] Location of the impact
    - ``mass`` (float):  [Read-Write]
    - ``normal`` (Vector):  [Read-Write] Normal at the impact
    - ``other_angular_velocity`` (Vector):  [Read-Write]
    - ``other_component`` (PrimitiveComponent):  [Read-Write]
    - ``other_mass`` (float):  [Read-Write]
    - ``other_velocity`` (Vector):  [Read-Write]
    - ``velocity`` (Vector):  [Read-Write]
    """
    def __init__(self, component: PrimitiveComponent = None, other_component: PrimitiveComponent = None, location: Vector = [0.000000, 0.000000, 0.000000], normal: Vector = [0.000000, 0.000000, 0.000000], accumulated_impulse: Vector = [0.000000, 0.000000, 0.000000], velocity: Vector = [0.000000, 0.000000, 0.000000], other_velocity: Vector = [0.000000, 0.000000, 0.000000], angular_velocity: Vector = [0.000000, 0.000000, 0.000000], other_angular_velocity: Vector = [0.000000, 0.000000, 0.000000], mass: float = 0.000000, other_mass: float = 0.000000) -> None:
        ...
    @property
    def component(self) -> PrimitiveComponent:
        r"""
        (PrimitiveComponent):  [Read-Write]
        """
        ...
    @component.setter
    def component(self, value: PrimitiveComponent) -> None:
        ...
    @property
    def other_component(self) -> PrimitiveComponent:
        r"""
        (PrimitiveComponent):  [Read-Write]
        """
        ...
    @other_component.setter
    def other_component(self, value: PrimitiveComponent) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Location of the impact
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def normal(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Normal at the impact
        """
        ...
    @normal.setter
    def normal(self, value: Vector) -> None:
        ...
    @property
    def accumulated_impulse(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @accumulated_impulse.setter
    def accumulated_impulse(self, value: Vector) -> None:
        ...
    @property
    def velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @velocity.setter
    def velocity(self, value: Vector) -> None:
        ...
    @property
    def other_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @other_velocity.setter
    def other_velocity(self, value: Vector) -> None:
        ...
    @property
    def angular_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @angular_velocity.setter
    def angular_velocity(self, value: Vector) -> None:
        ...
    @property
    def other_angular_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @other_angular_velocity.setter
    def other_angular_velocity(self, value: Vector) -> None:
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @mass.setter
    def mass(self, value: float) -> None:
        ...
    @property
    def other_mass(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @other_mass.setter
    def other_mass(self, value: float) -> None:
        ...

class ChaosBreakingEventData(StructBase):
    r"""
    A breaking event data structure.
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosBreakingEventFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``location`` (Vector):  [Read-Write] Location of the breaking event (centroid)
    - ``mass`` (float):  [Read-Write] The mass of the breaking event
    - ``velocity`` (Vector):  [Read-Write] The velocity of the breaking event
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], velocity: Vector = [0.000000, 0.000000, 0.000000], mass: float = 0.000000) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Location of the breaking event (centroid)
        """
        ...
    @property
    def velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The velocity of the breaking event
        """
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Only] The mass of the breaking event
        """
        ...

class ChaosCollisionEventData(StructBase):
    r"""
    A collision event data structure
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosCollisionEventFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``impulse`` (Vector):  [Read-Write] The accumulated impulse vector of the collision event
    - ``location`` (Vector):  [Read-Write] Location of the collision event
    - ``mass1`` (float):  [Read-Write] The mass of object 1 of the collision event
    - ``mass2`` (float):  [Read-Write] The mass of object 2 of the collision event
    - ``normal`` (Vector):  [Read-Write] Normal of the collision event
    - ``velocity1`` (Vector):  [Read-Write] The velocity of object 1 of the collision event
    - ``velocity2`` (Vector):  [Read-Write] The velocity of object 2 of the collision event
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], normal: Vector = [0.000000, 0.000000, 0.000000], velocity1: Vector = [0.000000, 0.000000, 0.000000], velocity2: Vector = [0.000000, 0.000000, 0.000000], mass1: float = 0.000000, mass2: float = 0.000000, impulse: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Location of the collision event
        """
        ...
    @property
    def normal(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Normal of the collision event
        """
        ...
    @property
    def velocity1(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The velocity of object 1 of the collision event
        """
        ...
    @property
    def velocity2(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The velocity of object 2 of the collision event
        """
        ...
    @property
    def mass1(self) -> float:
        r"""
        (float):  [Read-Only] The mass of object 1 of the collision event
        """
        ...
    @property
    def mass2(self) -> float:
        r"""
        (float):  [Read-Only] The mass of object 2 of the collision event
        """
        ...
    @property
    def impulse(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The accumulated impulse vector of the collision event
        """
        ...

class ChaosRemovalEventData(StructBase):
    r"""
    A Removal event data structure.
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosRemovalEventFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``location`` (Vector):  [Read-Write] Current removal location.
    - ``mass`` (float):  [Read-Write] The mass of the removal.
    - ``particle_index`` (int32):  [Read-Write] The particle index of the removal.
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], mass: float = 0.000000, particle_index: int = 0) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Current removal location.
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Write] The mass of the removal.
        """
        ...
    @mass.setter
    def mass(self, value: float) -> None:
        ...
    @property
    def particle_index(self) -> int:
        r"""
        (int32):  [Read-Write] The particle index of the removal.
        """
        ...
    @particle_index.setter
    def particle_index(self, value: int) -> None:
        ...

class ChaosTrailingEventData(StructBase):
    r"""
    A trailing event data structure.
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosTrailingEventFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_velocity`` (Vector):  [Read-Write] The angular velocity of the trail.
    - ``location`` (Vector):  [Read-Write] Current trail location.
    - ``mass`` (float):  [Read-Write] The mass of the trail.
    - ``particle_index`` (int32):  [Read-Write] The particle index of the trail.
    - ``velocity`` (Vector):  [Read-Write] The velocity of the trail.
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], velocity: Vector = [0.000000, 0.000000, 0.000000], angular_velocity: Vector = [0.000000, 0.000000, 0.000000], mass: float = 0.000000, particle_index: int = 0) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Current trail location.
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The velocity of the trail.
        """
        ...
    @velocity.setter
    def velocity(self, value: Vector) -> None:
        ...
    @property
    def angular_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The angular velocity of the trail.
        """
        ...
    @angular_velocity.setter
    def angular_velocity(self, value: Vector) -> None:
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Write] The mass of the trail.
        """
        ...
    @mass.setter
    def mass(self, value: float) -> None:
        ...
    @property
    def particle_index(self) -> int:
        r"""
        (int32):  [Read-Write] The particle index of the trail.
        """
        ...
    @particle_index.setter
    def particle_index(self, value: int) -> None:
        ...

class BodyInstanceAsyncPhysicsTickHandle(StructBase):
    r"""
    Body Instance Async Physics Tick Handle
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BodyInstance.h
    
    """
    def __init__(self) -> None:
        ...

class WalkableSlopeOverride(StructBase):
    r"""
    Struct allowing control over "walkable" normals, by allowing a restriction or relaxation of what steepness is normally walkable.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``walkable_slope_angle`` (float):  [Read-Write] Override walkable slope angle (in degrees), applying the rules of the Walkable Slope Behavior.
      see: GetWalkableSlopeAngle(), SetWalkableSlopeAngle()
    - ``walkable_slope_behavior`` (WalkableSlopeBehavior):  [Read-Write] Behavior of this surface (whether we affect the walkable slope).
      see: GetWalkableSlopeBehavior(), SetWalkableSlopeBehavior()
    """
    def __init__(self, walkable_slope_behavior: WalkableSlopeBehavior = WalkableSlopeBehavior.WALKABLE_SLOPE_DEFAULT, walkable_slope_angle: float = 0.000000) -> None:
        ...
    @property
    def walkable_slope_behavior(self) -> WalkableSlopeBehavior:
        r"""
        (WalkableSlopeBehavior):  [Read-Write] Behavior of this surface (whether we affect the walkable slope).
        see: GetWalkableSlopeBehavior(), SetWalkableSlopeBehavior()
        """
        ...
    @walkable_slope_behavior.setter
    def walkable_slope_behavior(self, value: WalkableSlopeBehavior) -> None:
        ...
    @property
    def walkable_slope_angle(self) -> float:
        r"""
        (float):  [Read-Write] Override walkable slope angle (in degrees), applying the rules of the Walkable Slope Behavior.
        see: GetWalkableSlopeAngle(), SetWalkableSlopeAngle()
        """
        ...
    @walkable_slope_angle.setter
    def walkable_slope_angle(self, value: float) -> None:
        ...

class BodyInstanceCore(StructBase):
    r"""
    Body Instance Core
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: BodyInstanceCore.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_weld`` (bool):  [Read-Write] If true and is attached to a parent, the two bodies will be joined into a single rigid body. Physical settings like collision profile and body settings are determined by the root
    - ``enable_gravity`` (bool):  [Read-Write] If object should have the force of gravity applied
    - ``generate_wake_events`` (bool):  [Read-Write] Should 'wake/sleep' events fire when this object is woken up or put to sleep by the physics simulation.
    - ``override_mass`` (bool):  [Read-Write] If true, mass will not be automatically computed and you must set it directly
    - ``simulate_physics`` (bool):  [Read-Write] If true, this body will use simulation. If false, will be 'fixed' (ie kinematic) and move where it is told.
      For a Skeletal Mesh Component, simulating requires a physics asset setup and assigned on the SkeletalMesh asset.
      For a Static Mesh Component, simulating requires simple collision to be setup on the StaticMesh asset.
    - ``start_awake`` (bool):  [Read-Write] If object should start awake, or if it should initially be sleeping
    - ``update_kinematic_from_simulation`` (bool):  [Read-Write] When kinematic, whether the actor transform should be updated as a result of movement in the simulation, rather than immediately whenever a target transform is set.
    - ``update_mass_when_scale_changes`` (bool):  [Read-Write] If true, it will update mass when scale change *
    """
    def __init__(self, simulate_physics: bool = False, enable_gravity: bool = False, update_kinematic_from_simulation: bool = False, auto_weld: bool = False, start_awake: bool = False, generate_wake_events: bool = False, update_mass_when_scale_changes: bool = False) -> None:
        ...
    @property
    def simulate_physics(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this body will use simulation. If false, will be 'fixed' (ie kinematic) and move where it is told.
        For a Skeletal Mesh Component, simulating requires a physics asset setup and assigned on the SkeletalMesh asset.
        For a Static Mesh Component, simulating requires simple collision to be setup on the StaticMesh asset.
        """
        ...
    @simulate_physics.setter
    def simulate_physics(self, value: bool) -> None:
        ...
    @property
    def enable_gravity(self) -> bool:
        r"""
        (bool):  [Read-Only] If object should have the force of gravity applied
        """
        ...
    @property
    def update_kinematic_from_simulation(self) -> bool:
        r"""
        (bool):  [Read-Only] When kinematic, whether the actor transform should be updated as a result of movement in the simulation, rather than immediately whenever a target transform is set.
        """
        ...
    @property
    def auto_weld(self) -> bool:
        r"""
        (bool):  [Read-Write] If true and is attached to a parent, the two bodies will be joined into a single rigid body. Physical settings like collision profile and body settings are determined by the root
        """
        ...
    @auto_weld.setter
    def auto_weld(self, value: bool) -> None:
        ...
    @property
    def start_awake(self) -> bool:
        r"""
        (bool):  [Read-Only] If object should start awake, or if it should initially be sleeping
        """
        ...
    @property
    def generate_wake_events(self) -> bool:
        r"""
        (bool):  [Read-Only] Should 'wake/sleep' events fire when this object is woken up or put to sleep by the physics simulation.
        """
        ...
    @property
    def update_mass_when_scale_changes(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, it will update mass when scale change *
        """
        ...
    @update_mass_when_scale_changes.setter
    def update_mass_when_scale_changes(self, value: bool) -> None:
        ...

class BodyInstance(BodyInstanceCore):
    r"""
    Container for a physics representation of an object
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BodyInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_damping`` (float):  [Read-Write] 'Drag' force added to reduce angular movement
    - ``auto_weld`` (bool):  [Read-Write] If true and is attached to a parent, the two bodies will be joined into a single rigid body. Physical settings like collision profile and body settings are determined by the root
    - ``collision_enabled`` (CollisionEnabled):  [Read-Write] Type of collision enabled.
      
            No Collision      : Will not create any representation in the physics engine. Cannot be used for spatial queries (raycasts, sweeps, overlaps) or simulation (rigid body, constraints). Best performance possible (especially for moving objects)
            Query Only        : Only used for spatial queries (raycasts, sweeps, and overlaps). Cannot be used for simulation (rigid body, constraints). Useful for character movement and things that do not need physical simulation. Performance gains by keeping data out of simulation tree.
            Physics Only      : Only used only for physics simulation (rigid body, constraints). Cannot be used for spatial queries (raycasts, sweeps, overlaps). Useful for jiggly bits on characters that do not need per bone detection. Performance gains by keeping data out of query tree
            Collision Enabled : Can be used for both spatial queries (raycasts, sweeps, overlaps) and simulation (rigid body, constraints).
    - ``collision_profile_name`` (Name):  [Read-Write] Collision Profile Name *
    - ``collision_responses`` (CollisionResponse):  [Read-Write] Custom Channels for Responses
    - ``com_nudge`` (Vector):  [Read-Write] User specified offset for the center of mass of this object, from the calculated location
    - ``custom_dof_plane_normal`` (Vector):  [Read-Write] Locks physical movement along a custom plane for a given normal.
    - ``custom_sleep_threshold_multiplier`` (float):  [Read-Write] If the SleepFamily is set to custom, multiply the natural sleep threshold by this amount. A higher number will cause the body to sleep sooner.
    - ``dof_mode`` (DOFMode):  [Read-Write] [Physx Only] Locks physical movement along specified axis.
    - ``enable_gravity`` (bool):  [Read-Write] If object should have the force of gravity applied
    - ``generate_wake_events`` (bool):  [Read-Write] Should 'wake/sleep' events fire when this object is woken up or put to sleep by the physics simulation.
    - ``ignore_analytic_collisions`` (bool):  [Read-Write] If true ignore analytic collisions and treat objects as a general implicit surface
    - ``inertia_conditioning`` (bool):  [Read-Write]
      brief: Enable automatic inertia conditioning to stabilize constraints. Inertia conitioning increases inertia when an object is long and thin and also when it has joints that are outside the collision shapes of the body. Increasing the inertia reduces the amount of rotation applied at joints which helps stabilize joint chains, especially when bodies are small. In principle you can get the same behaviour by setting the InertiaTensorScale appropriately, but this takes some of the guesswork out of it.
      note: This only changes the inertia used in the low-level solver. That inertia is not visible to the BodyInstance which will still report the inertia calculated from the mass, shapes, and InertiaTensorScale.
      note: When enabled, the effective inertia depends on the joints attached to the body so the inertia will change when joints are added or removed (automatically - no user action required).
    - ``inertia_tensor_scale`` (Vector):  [Read-Write] Per-instance scaling of inertia (bigger number means  it'll be harder to rotate)
    - ``linear_damping`` (float):  [Read-Write] 'Drag' force added to reduce linear movement
    - ``lock_rotation`` (bool):  [Read-Write] [Physx Only] When a Locked Axis Mode is selected, will lock rotation to the specified axis
    - ``lock_translation`` (bool):  [Read-Write] [Physx Only] When a Locked Axis Mode is selected, will lock translation on the specified axis
    - ``lock_x_rotation`` (bool):  [Read-Write] [Physx Only] Lock rotation about the X-axis
    - ``lock_x_translation`` (bool):  [Read-Write] [Physx Only] Lock translation along the X-axis
    - ``lock_y_rotation`` (bool):  [Read-Write] [Physx Only] Lock rotation about the Y-axis
    - ``lock_y_translation`` (bool):  [Read-Write] [Physx Only] Lock translation along the Y-axis
    - ``lock_z_rotation`` (bool):  [Read-Write] [Physx Only] Lock rotation about the Z-axis
    - ``lock_z_translation`` (bool):  [Read-Write] [Physx Only] Lock translation along the Z-axis
    - ``mass_in_kg_override`` (float):  [Read-Write] Mass of the body in KG. By default we compute this based on physical material and mass scale.
      see: bOverrideMass to set this directly
    - ``mass_scale`` (float):  [Read-Write] Per-instance scaling of mass
    - ``max_angular_velocity`` (float):  [Read-Write] The maximum angular velocity for this instance [degrees/s]
    - ``max_depenetration_velocity`` (float):  [Read-Write] The maximum velocity used to depenetrate this object from others when spawned or teleported with initial overlaps (does not affect overlaps as a result of normal movement).
      A value of zero will allow objects that are spawned overlapping to go to sleep without moving rather than pop out of each other. E.g., use zero if you spawn dynamic rocks
      partially embedded in the ground and want them to be interactive but not pop out of the ground when touched.
      A negative value is equivalent to bOverrideMaxDepenetrationVelocity = false, meaning use the project setting.
      This overrides the CollisionInitialOverlapDepenetrationVelocity project setting on a per-body basis (and not the MaxDepenetrationVelocity solver setting that will be deprecated).
    - ``notify_rigid_body_collision`` (bool):  [Read-Write] Should 'Hit' events fire when this object collides during physics simulation.
    - ``object_type`` (CollisionChannel):  [Read-Write] Enum indicating what type of object this should be considered as when it moves
    - ``one_way_interaction`` (bool):  [Read-Write] If set to true, this body will treat bodies that do not have the flag set as having infinite mass
    - ``override_mass`` (bool):  [Read-Write] If true, mass will not be automatically computed and you must set it directly
    - ``override_max_angular_velocity`` (bool):  [Read-Write] Override the default max angular velocity
    - ``override_max_depenetration_velocity`` (bool):  [Read-Write] Whether this body instance has its own custom MaxDepenetrationVelocity
    - ``override_solver_async_delta_time`` (bool):  [Read-Write] Set the desired delta time for the body. *
    - ``override_walkable_slope_on_instance`` (bool):  [Read-Write] Whether this instance of the object has its own custom walkable slope override setting.
    - ``phys_material_override`` (PhysicalMaterial):  [Read-Write] Allows you to override the PhysicalMaterial to use for simple collision on this body.
    - ``position_solver_iteration_count`` (uint8):  [Read-Write] [PhysX Only] This physics body's solver iteration count for position. Increasing this will be more CPU intensive, but better stabilized.
    - ``simulate_physics`` (bool):  [Read-Write] If true, this body will use simulation. If false, will be 'fixed' (ie kinematic) and move where it is told.
      For a Skeletal Mesh Component, simulating requires a physics asset setup and assigned on the SkeletalMesh asset.
      For a Static Mesh Component, simulating requires simple collision to be setup on the StaticMesh asset.
    - ``sleep_family`` (SleepFamily):  [Read-Write] The set of values used in considering when put this body to sleep.
    - ``smooth_edge_collisions`` (bool):  [Read-Write] Remove unnecessary edge collisions to allow smooth sliding over surfaces composed of multiple actors/components.
      This is fairly expensive and should only be enabled on hero objects.
    - ``solver_async_delta_time`` (float):  [Read-Write] Override value for physics solver async delta time.  With multiple actors specifying this, the solver will use the smallest delta time *
    - ``stabilization_threshold_multiplier`` (float):  [Read-Write] Stabilization factor for this body if Physics stabilization is enabled. A higher number will cause more aggressive stabilization at the risk of loss of momentum at low speeds. A value of 0 will disable stabilization for this body.
    - ``start_awake`` (bool):  [Read-Write] If object should start awake, or if it should initially be sleeping
    - ``update_kinematic_from_simulation`` (bool):  [Read-Write] When kinematic, whether the actor transform should be updated as a result of movement in the simulation, rather than immediately whenever a target transform is set.
    - ``update_mass_when_scale_changes`` (bool):  [Read-Write] If true, it will update mass when scale change *
    - ``use_ccd`` (bool):  [Read-Write] If true Continuous Collision Detection (CCD) will be used for this component
    - ``use_macd`` (bool):  [Read-Write] [EXPERIMENTAL] If true Motion-Aware Collision Detection (MACD) will be used for this component
    - ``velocity_solver_iteration_count`` (uint8):  [Read-Write] [PhysX Only] This physics body's solver iteration count for velocity. Increasing this will be more CPU intensive, but better stabilized.
    - ``walkable_slope_override`` (WalkableSlopeOverride):  [Read-Write] Custom walkable slope override setting for this instance.
      see: GetWalkableSlopeOverride(), SetWalkableSlopeOverride()
    """
    def __init__(self, simulate_physics: bool = False, enable_gravity: bool = False, update_kinematic_from_simulation: bool = False, auto_weld: bool = False, start_awake: bool = False, generate_wake_events: bool = False, update_mass_when_scale_changes: bool = False, sleep_family: SleepFamily = SleepFamily.NORMAL, use_ccd: bool = False, ignore_analytic_collisions: bool = False, notify_rigid_body_collision: bool = False, smooth_edge_collisions: bool = False, inertia_conditioning: bool = False, one_way_interaction: bool = False, override_solver_async_delta_time: bool = False, solver_async_delta_time: float = 0.000000, position_solver_iteration_count: int = 0, velocity_solver_iteration_count: int = 0, max_depenetration_velocity: float = 0.000000, mass_in_kg_override: float = 0.000000, linear_damping: float = 0.000000, angular_damping: float = 0.000000, com_nudge: Vector = [0.000000, 0.000000, 0.000000], mass_scale: float = 0.000000, inertia_tensor_scale: Vector = [0.000000, 0.000000, 0.000000], walkable_slope_override: WalkableSlopeOverride = [WalkableSlopeBehavior.WALKABLE_SLOPE_DEFAULT, 0.000000], phys_material_override: PhysicalMaterial = None, max_angular_velocity: float = 0.000000, custom_sleep_threshold_multiplier: float = 0.000000, stabilization_threshold_multiplier: float = 0.000000) -> None:
        ...
    @property
    def sleep_family(self) -> SleepFamily:
        r"""
        (SleepFamily):  [Read-Write] The set of values used in considering when put this body to sleep.
        """
        ...
    @sleep_family.setter
    def sleep_family(self, value: SleepFamily) -> None:
        ...
    @property
    def use_ccd(self) -> bool:
        r"""
        (bool):  [Read-Only] If true Continuous Collision Detection (CCD) will be used for this component
        """
        ...
    @property
    def ignore_analytic_collisions(self) -> bool:
        r"""
        (bool):  [Read-Only] If true ignore analytic collisions and treat objects as a general implicit surface
        """
        ...
    @property
    def notify_rigid_body_collision(self) -> bool:
        r"""
        (bool):  [Read-Only] Should 'Hit' events fire when this object collides during physics simulation.
        """
        ...
    @property
    def smooth_edge_collisions(self) -> bool:
        r"""
        (bool):  [Read-Only] Remove unnecessary edge collisions to allow smooth sliding over surfaces composed of multiple actors/components.
        This is fairly expensive and should only be enabled on hero objects.
        """
        ...
    @property
    def inertia_conditioning(self) -> bool:
        r"""
        (bool):  [Read-Write]
        brief: Enable automatic inertia conditioning to stabilize constraints. Inertia conitioning increases inertia when an object is long and thin and also when it has joints that are outside the collision shapes of the body. Increasing the inertia reduces the amount of rotation applied at joints which helps stabilize joint chains, especially when bodies are small. In principle you can get the same behaviour by setting the InertiaTensorScale appropriately, but this takes some of the guesswork out of it.
        note: This only changes the inertia used in the low-level solver. That inertia is not visible to the BodyInstance which will still report the inertia calculated from the mass, shapes, and InertiaTensorScale.
        note: When enabled, the effective inertia depends on the joints attached to the body so the inertia will change when joints are added or removed (automatically - no user action required).
        """
        ...
    @inertia_conditioning.setter
    def inertia_conditioning(self, value: bool) -> None:
        ...
    @property
    def one_way_interaction(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true, this body will treat bodies that do not have the flag set as having infinite mass
        """
        ...
    @one_way_interaction.setter
    def one_way_interaction(self, value: bool) -> None:
        ...
    @property
    def override_solver_async_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Only] Set the desired delta time for the body. *
        """
        ...
    @property
    def solver_async_delta_time(self) -> float:
        r"""
        (float):  [Read-Only] Override value for physics solver async delta time.  With multiple actors specifying this, the solver will use the smallest delta time *
        """
        ...
    @property
    def position_solver_iteration_count(self) -> int:
        r"""
        (uint8):  [Read-Only] [PhysX Only] This physics body's solver iteration count for position. Increasing this will be more CPU intensive, but better stabilized.
        """
        ...
    @property
    def velocity_solver_iteration_count(self) -> int:
        r"""
        (uint8):  [Read-Only] [PhysX Only] This physics body's solver iteration count for velocity. Increasing this will be more CPU intensive, but better stabilized.
        """
        ...
    @property
    def max_depenetration_velocity(self) -> float:
        r"""
        (float):  [Read-Only] The maximum velocity used to depenetrate this object from others when spawned or teleported with initial overlaps (does not affect overlaps as a result of normal movement).
        A value of zero will allow objects that are spawned overlapping to go to sleep without moving rather than pop out of each other. E.g., use zero if you spawn dynamic rocks
        partially embedded in the ground and want them to be interactive but not pop out of the ground when touched.
        A negative value is equivalent to bOverrideMaxDepenetrationVelocity = false, meaning use the project setting.
        This overrides the CollisionInitialOverlapDepenetrationVelocity project setting on a per-body basis (and not the MaxDepenetrationVelocity solver setting that will be deprecated).
        """
        ...
    @property
    def mass_in_kg_override(self) -> float:
        r"""
        (float):  [Read-Only] Mass of the body in KG. By default we compute this based on physical material and mass scale.
        see: bOverrideMass to set this directly
        """
        ...
    @property
    def mass_in_kg(self) -> float:
        r"""
        deprecated: 'mass_in_kg' was renamed to 'mass_in_kg_override'.
        """
        ...
    @property
    def linear_damping(self) -> float:
        r"""
        (float):  [Read-Write] 'Drag' force added to reduce linear movement
        """
        ...
    @linear_damping.setter
    def linear_damping(self, value: float) -> None:
        ...
    @property
    def angular_damping(self) -> float:
        r"""
        (float):  [Read-Write] 'Drag' force added to reduce angular movement
        """
        ...
    @angular_damping.setter
    def angular_damping(self, value: float) -> None:
        ...
    @property
    def com_nudge(self) -> Vector:
        r"""
        (Vector):  [Read-Write] User specified offset for the center of mass of this object, from the calculated location
        """
        ...
    @com_nudge.setter
    def com_nudge(self, value: Vector) -> None:
        ...
    @property
    def mass_scale(self) -> float:
        r"""
        (float):  [Read-Write] Per-instance scaling of mass
        """
        ...
    @mass_scale.setter
    def mass_scale(self, value: float) -> None:
        ...
    @property
    def inertia_tensor_scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Per-instance scaling of inertia (bigger number means  it'll be harder to rotate)
        """
        ...
    @inertia_tensor_scale.setter
    def inertia_tensor_scale(self, value: Vector) -> None:
        ...
    @property
    def walkable_slope_override(self) -> WalkableSlopeOverride:
        r"""
        (WalkableSlopeOverride):  [Read-Only] Custom walkable slope override setting for this instance.
        see: GetWalkableSlopeOverride(), SetWalkableSlopeOverride()
        """
        ...
    @property
    def phys_material_override(self) -> PhysicalMaterial:
        r"""
        (PhysicalMaterial):  [Read-Only] Allows you to override the PhysicalMaterial to use for simple collision on this body.
        """
        ...
    @property
    def max_angular_velocity(self) -> float:
        r"""
        (float):  [Read-Only] The maximum angular velocity for this instance [degrees/s]
        """
        ...
    @property
    def custom_sleep_threshold_multiplier(self) -> float:
        r"""
        (float):  [Read-Only] If the SleepFamily is set to custom, multiply the natural sleep threshold by this amount. A higher number will cause the body to sleep sooner.
        """
        ...
    @property
    def stabilization_threshold_multiplier(self) -> float:
        r"""
        (float):  [Read-Only] Stabilization factor for this body if Physics stabilization is enabled. A higher number will cause more aggressive stabilization at the risk of loss of momentum at low speeds. A value of 0 will disable stabilization for this body.
        """
        ...

class CollisionResponseContainer(StructBase):
    r"""
    Container for indicating a set of collision channels that this object will collide with.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``camera`` (CollisionResponseType):  [Read-Write] 3
    - ``destructible`` (CollisionResponseType):  [Read-Write] 6
    - ``engine_trace_channel1`` (CollisionResponseType):  [Read-Write] Unspecified Engine Trace Channels
    - ``engine_trace_channel2`` (CollisionResponseType):  [Read-Write] 8
    - ``engine_trace_channel3`` (CollisionResponseType):  [Read-Write] 9
    - ``engine_trace_channel4`` (CollisionResponseType):  [Read-Write] 10
    - ``engine_trace_channel5`` (CollisionResponseType):  [Read-Write] 11
    - ``engine_trace_channel6`` (CollisionResponseType):  [Read-Write] 12
    - ``game_trace_channel1`` (CollisionResponseType):  [Read-Write] in order to use this custom channels
      we recommend to define in your local file
      - i.e. #define COLLISION_WEAPON               ECC_GameTraceChannel1
      and make sure you customize these it in INI file by
      
      in DefaultEngine.ini
      
      [/Script/Engine.CollisionProfile]
      GameTraceChannel1="Weapon"
      
      also in the INI file, you can override collision profiles that are defined by simply redefining
      note that Weapon isn't defined in the BaseEngine.ini file, but "Trigger" is defined in Engine
      +Profiles=(Name="Trigger",CollisionEnabled=QueryOnly,ObjectTypeName=WorldDynamic, DefaultResponse=ECR_Overlap, CustomResponses=((Channel=Visibility, Response=ECR_Ignore), (Channel=Weapon, Response=ECR_Ignore)))
    - ``game_trace_channel10`` (CollisionResponseType):  [Read-Write] 22
    - ``game_trace_channel11`` (CollisionResponseType):  [Read-Write] 23
    - ``game_trace_channel12`` (CollisionResponseType):  [Read-Write] 24
    - ``game_trace_channel13`` (CollisionResponseType):  [Read-Write] 25
    - ``game_trace_channel14`` (CollisionResponseType):  [Read-Write] 26
    - ``game_trace_channel15`` (CollisionResponseType):  [Read-Write] 27
    - ``game_trace_channel16`` (CollisionResponseType):  [Read-Write] 28
    - ``game_trace_channel17`` (CollisionResponseType):  [Read-Write] 28
    - ``game_trace_channel18`` (CollisionResponseType):  [Read-Write] 30
    - ``game_trace_channel2`` (CollisionResponseType):  [Read-Write] 14
    - ``game_trace_channel3`` (CollisionResponseType):  [Read-Write] 15
    - ``game_trace_channel4`` (CollisionResponseType):  [Read-Write] 16
    - ``game_trace_channel5`` (CollisionResponseType):  [Read-Write] 17
    - ``game_trace_channel6`` (CollisionResponseType):  [Read-Write] 18
    - ``game_trace_channel7`` (CollisionResponseType):  [Read-Write] 19
    - ``game_trace_channel8`` (CollisionResponseType):  [Read-Write] 20
    - ``game_trace_channel9`` (CollisionResponseType):  [Read-Write] 21
    - ``pawn`` (CollisionResponseType):  [Read-Write] 1.
    - ``physics_body`` (CollisionResponseType):  [Read-Write] 4
    - ``vehicle`` (CollisionResponseType):  [Read-Write] 5
    - ``visibility`` (CollisionResponseType):  [Read-Write] 2
    - ``world_dynamic`` (CollisionResponseType):  [Read-Write] 0
    - ``world_static`` (CollisionResponseType):  [Read-Write] Reserved Engine Trace Channels
      
      Note -        If you change this (add/remove/modify)
                            you should make sure it matches with ECollisionChannel (including DisplayName)
                            They has to be mirrored if serialized
    """
    def __init__(self, world_static: CollisionResponseType = CollisionResponseType.ECR_IGNORE, world_dynamic: CollisionResponseType = CollisionResponseType.ECR_IGNORE, pawn: CollisionResponseType = CollisionResponseType.ECR_IGNORE, visibility: CollisionResponseType = CollisionResponseType.ECR_IGNORE, camera: CollisionResponseType = CollisionResponseType.ECR_IGNORE, physics_body: CollisionResponseType = CollisionResponseType.ECR_IGNORE, vehicle: CollisionResponseType = CollisionResponseType.ECR_IGNORE, destructible: CollisionResponseType = CollisionResponseType.ECR_IGNORE, engine_trace_channel1: CollisionResponseType = CollisionResponseType.ECR_IGNORE, engine_trace_channel2: CollisionResponseType = CollisionResponseType.ECR_IGNORE, engine_trace_channel3: CollisionResponseType = CollisionResponseType.ECR_IGNORE, engine_trace_channel4: CollisionResponseType = CollisionResponseType.ECR_IGNORE, engine_trace_channel5: CollisionResponseType = CollisionResponseType.ECR_IGNORE, engine_trace_channel6: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel1: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel2: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel3: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel4: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel5: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel6: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel7: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel8: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel9: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel10: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel11: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel12: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel13: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel14: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel15: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel16: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel17: CollisionResponseType = CollisionResponseType.ECR_IGNORE, game_trace_channel18: CollisionResponseType = CollisionResponseType.ECR_IGNORE) -> None:
        ...
    @property
    def world_static(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] Reserved Engine Trace Channels
        
        Note -        If you change this (add/remove/modify)
                              you should make sure it matches with ECollisionChannel (including DisplayName)
                              They has to be mirrored if serialized
        """
        ...
    @property
    def static(self) -> CollisionResponseType:
        r"""
        deprecated: 'static' was renamed to 'world_static'.
        """
        ...
    @property
    def world_dynamic(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 0
        """
        ...
    @property
    def dynamic(self) -> CollisionResponseType:
        r"""
        deprecated: 'dynamic' was renamed to 'world_dynamic'.
        """
        ...
    @property
    def pawn(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 1.
        """
        ...
    @property
    def visibility(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 2
        """
        ...
    @property
    def camera(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 3
        """
        ...
    @property
    def physics_body(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 4
        """
        ...
    @property
    def rigid_body(self) -> CollisionResponseType:
        r"""
        deprecated: 'rigid_body' was renamed to 'physics_body'.
        """
        ...
    @property
    def vehicle(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 5
        """
        ...
    @property
    def destructible(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 6
        """
        ...
    @property
    def engine_trace_channel1(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] Unspecified Engine Trace Channels
        """
        ...
    @property
    def engine_trace_channel2(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 8
        """
        ...
    @property
    def engine_trace_channel3(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 9
        """
        ...
    @property
    def engine_trace_channel4(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 10
        """
        ...
    @property
    def engine_trace_channel5(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 11
        """
        ...
    @property
    def engine_trace_channel6(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 12
        """
        ...
    @property
    def game_trace_channel1(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] in order to use this custom channels
        we recommend to define in your local file
        - i.e. #define COLLISION_WEAPON               ECC_GameTraceChannel1
        and make sure you customize these it in INI file by
        
        in DefaultEngine.ini
        
        [/Script/Engine.CollisionProfile]
        GameTraceChannel1="Weapon"
        
        also in the INI file, you can override collision profiles that are defined by simply redefining
        note that Weapon isn't defined in the BaseEngine.ini file, but "Trigger" is defined in Engine
        +Profiles=(Name="Trigger",CollisionEnabled=QueryOnly,ObjectTypeName=WorldDynamic, DefaultResponse=ECR_Overlap, CustomResponses=((Channel=Visibility, Response=ECR_Ignore), (Channel=Weapon, Response=ECR_Ignore)))
        """
        ...
    @property
    def game_trace_channel2(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 14
        """
        ...
    @property
    def game_trace_channel3(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 15
        """
        ...
    @property
    def game_trace_channel4(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 16
        """
        ...
    @property
    def game_trace_channel5(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 17
        """
        ...
    @property
    def game_trace_channel6(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 18
        """
        ...
    @property
    def game_trace_channel7(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 19
        """
        ...
    @property
    def game_trace_channel8(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 20
        """
        ...
    @property
    def game_trace_channel9(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 21
        """
        ...
    @property
    def game_trace_channel10(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 22
        """
        ...
    @property
    def game_trace_channel11(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 23
        """
        ...
    @property
    def game_trace_channel12(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 24
        """
        ...
    @property
    def game_trace_channel13(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 25
        """
        ...
    @property
    def game_trace_channel14(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 26
        """
        ...
    @property
    def game_trace_channel15(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 27
        """
        ...
    @property
    def game_trace_channel16(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 28
        """
        ...
    @property
    def game_trace_channel17(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 28
        """
        ...
    @property
    def game_trace_channel18(self) -> CollisionResponseType:
        r"""
        (CollisionResponseType):  [Read-Only] 30
        """
        ...

class LightingChannels(StructBase):
    r"""
    Specifies which lighting channels are relevant
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel0`` (bool):  [Read-Write] Default channel for all primitives and lights.
    - ``channel1`` (bool):  [Read-Write] First custom channel
    - ``channel2`` (bool):  [Read-Write] Second custom channel
    """
    def __init__(self, channel0: bool = False, channel1: bool = False, channel2: bool = False) -> None:
        ...
    @property
    def channel0(self) -> bool:
        r"""
        (bool):  [Read-Only] Default channel for all primitives and lights.
        """
        ...
    @property
    def channel1(self) -> bool:
        r"""
        (bool):  [Read-Only] First custom channel
        """
        ...
    @property
    def channel2(self) -> bool:
        r"""
        (bool):  [Read-Only] Second custom channel
        """
        ...

class GeometryCollectionDamagePropagationData(StructBase):
    r"""
    Geometry Collection Damage Propagation Data
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionDamagePropagationData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``break_damage_propagation_factor`` (float):  [Read-Write] factor of the remaining strain propagated through the connection graph after a piece breaks.
    - ``enabled`` (bool):  [Read-Write] Whether or not damage propagation is enabled.
    - ``shock_damage_propagation_factor`` (float):  [Read-Write] factor of the received strain propagated throug the connection graph if the piece did not break.
    """
    def __init__(self, enabled: bool = False, break_damage_propagation_factor: float = 0.000000, shock_damage_propagation_factor: float = 0.000000) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not damage propagation is enabled.
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def break_damage_propagation_factor(self) -> float:
        r"""
        (float):  [Read-Write] factor of the remaining strain propagated through the connection graph after a piece breaks.
        """
        ...
    @break_damage_propagation_factor.setter
    def break_damage_propagation_factor(self, value: float) -> None:
        ...
    @property
    def shock_damage_propagation_factor(self) -> float:
        r"""
        (float):  [Read-Write] factor of the received strain propagated throug the connection graph if the piece did not break.
        """
        ...
    @shock_damage_propagation_factor.setter
    def shock_damage_propagation_factor(self, value: float) -> None:
        ...

class Geometry(StructBase):
    r"""
    Represents the position, size, and absolute position of a Widget in Slate.
    The absolute location of a geometry is usually screen space or
    window space depending on where the geometry originated.
    Geometries are usually paired with a SWidget pointer in order
    to provide information about a specific widget (see FArrangedWidget).
    A Geometry's parent is generally thought to be the Geometry of the
    the corresponding parent widget.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Geometry.h
    
    """
    def __init__(self) -> None:
        ...

class SlateBrush(StructBase):
    r"""
    A brush which contains information about how to draw a Slate element
     //, meta = (HasNativeMake = ""))
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateBrush.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``draw_as`` (SlateBrushDrawType):  [Read-Write] How to draw the image
    - ``image_size`` (DeprecateSlateVector2D):  [Read-Write] Size of the resource in Slate Units
    - ``image_type`` (SlateBrushImageType):  [Read-Write] The type of image
    - ``margin`` (Margin):  [Read-Write] The margin to use in Box and Border modes
    - ``mirroring`` (SlateBrushMirrorType):  [Read-Write] How to mirror the image in Image mode.  This is normally only used for dynamic image brushes where the source texture
                comes from a hardware device such as a web camera.
    - ``outline_settings`` (SlateBrushOutlineSettings):  [Read-Write] How to draw the outline.  Currently only used for RoundedBox type brushes.
    - ``resource_name`` (Name):  [Read-Write] The name of the rendering resource to use
    - ``resource_object`` (Object):  [Read-Write] The image to render for this brush, can be a UTexture or UMaterialInterface or an object implementing
      the AtlasedTextureInterface.
    - ``tiling`` (SlateBrushTileType):  [Read-Write] How to tile the image in Image mode
    - ``tint_color`` (SlateColor):  [Read-Write] Tinting applied to the image.
    """
    def __init__(self, draw_as: SlateBrushDrawType = SlateBrushDrawType.NO_DRAW_TYPE, tiling: SlateBrushTileType = SlateBrushTileType.NO_TILE, mirroring: SlateBrushMirrorType = SlateBrushMirrorType.NO_MIRROR, image_size: DeprecateSlateVector2D = [0.000000, 0.000000], margin: Margin = [0.000000, 0.000000, 0.000000, 0.000000], tint_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], outline_settings: SlateBrushOutlineSettings = [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], resource_object: Object = None) -> None:
        ...
    @property
    def draw_as(self) -> SlateBrushDrawType:
        r"""
        (SlateBrushDrawType):  [Read-Write] How to draw the image
        """
        ...
    @draw_as.setter
    def draw_as(self, value: SlateBrushDrawType) -> None:
        ...
    @property
    def tiling(self) -> SlateBrushTileType:
        r"""
        (SlateBrushTileType):  [Read-Write] How to tile the image in Image mode
        """
        ...
    @tiling.setter
    def tiling(self, value: SlateBrushTileType) -> None:
        ...
    @property
    def mirroring(self) -> SlateBrushMirrorType:
        r"""
        (SlateBrushMirrorType):  [Read-Write] How to mirror the image in Image mode.  This is normally only used for dynamic image brushes where the source texture
                  comes from a hardware device such as a web camera.
        """
        ...
    @mirroring.setter
    def mirroring(self, value: SlateBrushMirrorType) -> None:
        ...
    @property
    def image_size(self) -> DeprecateSlateVector2D:
        r"""
        (DeprecateSlateVector2D):  [Read-Write] Size of the resource in Slate Units
        """
        ...
    @image_size.setter
    def image_size(self, value: DeprecateSlateVector2D) -> None:
        ...
    @property
    def margin(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The margin to use in Box and Border modes
        """
        ...
    @margin.setter
    def margin(self, value: Margin) -> None:
        ...
    @property
    def tint_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Tinting applied to the image.
        """
        ...
    @tint_color.setter
    def tint_color(self, value: SlateColor) -> None:
        ...
    @property
    def outline_settings(self) -> SlateBrushOutlineSettings:
        r"""
        (SlateBrushOutlineSettings):  [Read-Write] How to draw the outline.  Currently only used for RoundedBox type brushes.
        """
        ...
    @outline_settings.setter
    def outline_settings(self, value: SlateBrushOutlineSettings) -> None:
        ...
    @property
    def resource_object(self) -> Object:
        r"""
        (Object):  [Read-Write] The image to render for this brush, can be a UTexture or UMaterialInterface or an object implementing
        the AtlasedTextureInterface.
        """
        ...
    @resource_object.setter
    def resource_object(self, value: Object) -> None:
        ...
    @property
    def texture_object(self) -> Object:
        r"""
        deprecated: 'texture_object' was renamed to 'resource_object'.
        """
        ...
    @texture_object.setter
    def texture_object(self, value: Object) -> None:
        ...

class SlateBrushOutlineSettings(StructBase):
    r"""
    Possible options for rounded box brush image
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateBrush.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (SlateColor):  [Read-Write] Tinting applied to the border outline.
    - ``corner_radii`` (Vector4):  [Read-Write] Radius in Slate Units applied to the outline at each corner. X = Top Left, Y = Top Right, Z = Bottom Right, W = Bottom Left
    - ``rounding_type`` (SlateBrushRoundingType):  [Read-Write] The Rounding Type *
    - ``use_brush_transparency`` (bool):  [Read-Write] True if we should use the owning brush's transparency as our own *
    - ``width`` (float):  [Read-Write] Line width in Slate Units applied to the border outline.
    """
    def __init__(self, corner_radii: Vector4 = [0.000000, 0.000000, 0.000000, 0.000000], color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], width: float = 0.000000, rounding_type: SlateBrushRoundingType = SlateBrushRoundingType.FIXED_RADIUS, use_brush_transparency: bool = False) -> None:
        ...
    @property
    def corner_radii(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Radius in Slate Units applied to the outline at each corner. X = Top Left, Y = Top Right, Z = Bottom Right, W = Bottom Left
        """
        ...
    @corner_radii.setter
    def corner_radii(self, value: Vector4) -> None:
        ...
    @property
    def color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Tinting applied to the border outline.
        """
        ...
    @color.setter
    def color(self, value: SlateColor) -> None:
        ...
    @property
    def width(self) -> float:
        r"""
        (float):  [Read-Write] Line width in Slate Units applied to the border outline.
        """
        ...
    @width.setter
    def width(self, value: float) -> None:
        ...
    @property
    def rounding_type(self) -> SlateBrushRoundingType:
        r"""
        (SlateBrushRoundingType):  [Read-Write] The Rounding Type *
        """
        ...
    @rounding_type.setter
    def rounding_type(self, value: SlateBrushRoundingType) -> None:
        ...
    @property
    def use_brush_transparency(self) -> bool:
        r"""
        (bool):  [Read-Write] True if we should use the owning brush's transparency as our own *
        """
        ...
    @use_brush_transparency.setter
    def use_brush_transparency(self, value: bool) -> None:
        ...

class SlateColor(StructBase):
    r"""
    A Slate color can be a directly specified value, or the color can be pulled from a WidgetStyle.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_use_rule`` (SlateColorStylingMode):  [Read-Write] The rule for which color to pick.
    - ``specified_color`` (LinearColor):  [Read-Write] The current specified color; only meaningful when ColorToUse == UseColor_Specified.
    """
    def __init__(self, specified_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], color_use_rule: SlateColorStylingMode = SlateColorStylingMode.USE_COLOR_SPECIFIED) -> None:
        ...
    @property
    def specified_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The current specified color; only meaningful when ColorToUse == UseColor_Specified.
        """
        ...
    @specified_color.setter
    def specified_color(self, value: LinearColor) -> None:
        ...
    @property
    def color_use_rule(self) -> SlateColorStylingMode:
        r"""
        (SlateColorStylingMode):  [Read-Write] The rule for which color to pick.
        """
        ...
    @color_use_rule.setter
    def color_use_rule(self, value: SlateColorStylingMode) -> None:
        ...

class Margin(StructBase):
    r"""
    Describes the space around a Widget.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Margin.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bottom`` (float):  [Read-Write] Holds the margin to the bottom.
    - ``left`` (float):  [Read-Write] Holds the margin to the left.
    - ``right`` (float):  [Read-Write] Holds the margin to the right.
    - ``top`` (float):  [Read-Write] Holds the margin to the top.
    """
    def __init__(self, left: float = 0.000000, top: float = 0.000000, right: float = 0.000000, bottom: float = 0.000000) -> None:
        ...
    @property
    def left(self) -> float:
        r"""
        (float):  [Read-Write] Holds the margin to the left.
        """
        ...
    @left.setter
    def left(self, value: float) -> None:
        ...
    @property
    def top(self) -> float:
        r"""
        (float):  [Read-Write] Holds the margin to the top.
        """
        ...
    @top.setter
    def top(self, value: float) -> None:
        ...
    @property
    def right(self) -> float:
        r"""
        (float):  [Read-Write] Holds the margin to the right.
        """
        ...
    @right.setter
    def right(self, value: float) -> None:
        ...
    @property
    def bottom(self) -> float:
        r"""
        (float):  [Read-Write] Holds the margin to the bottom.
        """
        ...
    @bottom.setter
    def bottom(self, value: float) -> None:
        ...

class DeprecateSlateVector2D(Vector2f):
    r"""
    Vector2D (single-precision)
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateVector2.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (float):  [Read-Write]
    - ``y`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class FieldNotificationId(StructBase):
    r"""
    namespace
    
    **C++ Source:**
    
    - **Module**: FieldNotification
    - **File**: FieldNotificationId.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``field_name`` (Name):  [Read-Write]
    """
    def __init__(self, field_name: Name = "None") -> None:
        ...
    @property
    def field_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @field_name.setter
    def field_name(self, value: Name) -> None:
        ...

class EventReply(StructBase):
    r"""
    Allows users to handle events and return information to the underlying UI layer.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SlateWrapperTypes.h
    
    """
    def __init__(self) -> None:
        ...

class SReply(EventReply):
    r"""
    deprecated: 'SReply' was renamed to 'EventReply'.
    """
    def __init__(self) -> None:
        ...

class InputEvent(StructBase):
    r"""
    Base class for all mouse and keyevents.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Events.h
    
    """
    def __init__(self) -> None:
        ...

class PointerEvent(InputEvent):
    r"""
    FPointerEvent describes a mouse or touch action (e.g. Press, Release, Move, etc).
    It is passed to event handlers dealing with pointer-based input.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Events.h
    
    """
    def __init__(self) -> None:
        ...

class WidgetTransform(StructBase):
    r"""
    Describes the standard transformation of a widget
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angle`` (float):  [Read-Write] The angle in degrees to rotate
    - ``scale`` (Vector2D):  [Read-Write] The scale to apply to the widget
    - ``shear`` (Vector2D):  [Read-Write] The amount to shear the widget in slate units
    - ``translation`` (Vector2D):  [Read-Write] The amount to translate the widget in slate units
    """
    def __init__(self, translation: Vector2D = [0.000000, 0.000000], scale: Vector2D = [0.000000, 0.000000], shear: Vector2D = [0.000000, 0.000000], angle: float = 0.000000) -> None:
        ...
    @property
    def translation(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The amount to translate the widget in slate units
        """
        ...
    @translation.setter
    def translation(self, value: Vector2D) -> None:
        ...
    @property
    def scale(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The scale to apply to the widget
        """
        ...
    @scale.setter
    def scale(self, value: Vector2D) -> None:
        ...
    @property
    def shear(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The amount to shear the widget in slate units
        """
        ...
    @shear.setter
    def shear(self, value: Vector2D) -> None:
        ...
    @property
    def angle(self) -> float:
        r"""
        (float):  [Read-Write] The angle in degrees to rotate
        """
        ...
    @angle.setter
    def angle(self, value: float) -> None:
        ...

class SlateWidgetStyle(StructBase):
    r"""
    Base structure for widget styles.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateWidgetStyle.h
    
    """
    def __init__(self) -> None:
        ...

class ScrollBarStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SScrollBar
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``dragged_thumb_image`` (SlateBrush):  [Read-Write] Image to use when the scrollbar thumb is in its dragged state
    - ``horizontal_background_image`` (SlateBrush):  [Read-Write] Background image to use when the scrollbar is oriented horizontally
    - ``horizontal_bottom_slot_image`` (SlateBrush):  [Read-Write] The image to use to represent the track below the thumb when the scrollbar is oriented horizontally
    - ``horizontal_top_slot_image`` (SlateBrush):  [Read-Write] The image to use to represent the track above the thumb when the scrollbar is oriented horizontally
    - ``hovered_thumb_image`` (SlateBrush):  [Read-Write] Image to use when the scrollbar thumb is in its hovered state
    - ``normal_thumb_image`` (SlateBrush):  [Read-Write] Image to use when the scrollbar thumb is in its normal state
    - ``thickness`` (float):  [Read-Write]
    - ``vertical_background_image`` (SlateBrush):  [Read-Write] Background image to use when the scrollbar is oriented vertically
    - ``vertical_bottom_slot_image`` (SlateBrush):  [Read-Write] The image to use to represent the track below the thumb when the scrollbar is oriented vertically
    - ``vertical_top_slot_image`` (SlateBrush):  [Read-Write] The image to use to represent the track above the thumb when the scrollbar is oriented vertically
    """
    def __init__(self, horizontal_background_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], vertical_background_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], vertical_top_slot_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], horizontal_top_slot_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], vertical_bottom_slot_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], horizontal_bottom_slot_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], normal_thumb_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], hovered_thumb_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], dragged_thumb_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], thickness: float = 0.000000) -> None:
        ...
    @property
    def horizontal_background_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Background image to use when the scrollbar is oriented horizontally
        """
        ...
    @horizontal_background_image.setter
    def horizontal_background_image(self, value: SlateBrush) -> None:
        ...
    @property
    def vertical_background_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Background image to use when the scrollbar is oriented vertically
        """
        ...
    @vertical_background_image.setter
    def vertical_background_image(self, value: SlateBrush) -> None:
        ...
    @property
    def vertical_top_slot_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The image to use to represent the track above the thumb when the scrollbar is oriented vertically
        """
        ...
    @vertical_top_slot_image.setter
    def vertical_top_slot_image(self, value: SlateBrush) -> None:
        ...
    @property
    def horizontal_top_slot_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The image to use to represent the track above the thumb when the scrollbar is oriented horizontally
        """
        ...
    @horizontal_top_slot_image.setter
    def horizontal_top_slot_image(self, value: SlateBrush) -> None:
        ...
    @property
    def vertical_bottom_slot_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The image to use to represent the track below the thumb when the scrollbar is oriented vertically
        """
        ...
    @vertical_bottom_slot_image.setter
    def vertical_bottom_slot_image(self, value: SlateBrush) -> None:
        ...
    @property
    def horizontal_bottom_slot_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The image to use to represent the track below the thumb when the scrollbar is oriented horizontally
        """
        ...
    @horizontal_bottom_slot_image.setter
    def horizontal_bottom_slot_image(self, value: SlateBrush) -> None:
        ...
    @property
    def normal_thumb_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use when the scrollbar thumb is in its normal state
        """
        ...
    @normal_thumb_image.setter
    def normal_thumb_image(self, value: SlateBrush) -> None:
        ...
    @property
    def hovered_thumb_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use when the scrollbar thumb is in its hovered state
        """
        ...
    @hovered_thumb_image.setter
    def hovered_thumb_image(self, value: SlateBrush) -> None:
        ...
    @property
    def dragged_thumb_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use when the scrollbar thumb is in its dragged state
        """
        ...
    @dragged_thumb_image.setter
    def dragged_thumb_image(self, value: SlateBrush) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...

class TableRowStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an STableRow
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active_brush`` (SlateBrush):  [Read-Write] Brush used when a selected row is active
    - ``active_highlighted_brush`` (SlateBrush):  [Read-Write] Brush used when a highlighted row is active
    - ``active_hovered_brush`` (SlateBrush):  [Read-Write] Brush used when a selected row is active and hovered
    - ``drop_indicator_above`` (SlateBrush):  [Read-Write] Brush used to provide feedback that a user can drop above the hovered row.
    - ``drop_indicator_below`` (SlateBrush):  [Read-Write] Brush used to provide feedback that a user can drop below the hovered row.
    - ``drop_indicator_onto`` (SlateBrush):  [Read-Write] Brush used to provide feedback that a user can drop onto the hovered row.
    - ``even_row_background_brush`` (SlateBrush):  [Read-Write] Brush used when an even row is in its normal state
    - ``even_row_background_hovered_brush`` (SlateBrush):  [Read-Write] Brush used when an even row is hovered
    - ``inactive_brush`` (SlateBrush):  [Read-Write] Brush used when a selected row is inactive
    - ``inactive_highlighted_brush`` (SlateBrush):  [Read-Write] Brush used when a highlighted row is inactive and hovered
    - ``inactive_hovered_brush`` (SlateBrush):  [Read-Write] Brush used when a selected row is inactive and hovered
    - ``odd_row_background_brush`` (SlateBrush):  [Read-Write] Brush to used when an odd row is in its normal state
    - ``odd_row_background_hovered_brush`` (SlateBrush):  [Read-Write] Brush used when an odd row is hovered
    - ``parent_row_background_brush`` (SlateBrush):  [Read-Write] Brush used for the top parent row
    - ``parent_row_background_hovered_brush`` (SlateBrush):  [Read-Write] Brush used for the top parent row and row is hovered
    - ``selected_text_color`` (SlateColor):  [Read-Write] Text color used for the selected row
    - ``selector_focused_brush`` (SlateBrush):  [Read-Write] Brush used as a selector when a row is focused
    - ``text_color`` (SlateColor):  [Read-Write] Text color used for all rows
    - ``use_parent_row_brush`` (bool):  [Read-Write] If using parent row brushes
    """
    def __init__(self, selector_focused_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], active_hovered_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], active_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], inactive_hovered_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], inactive_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], use_parent_row_brush: bool = False, parent_row_background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], parent_row_background_hovered_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], even_row_background_hovered_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], even_row_background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], odd_row_background_hovered_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], odd_row_background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], text_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], selected_text_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], drop_indicator_above: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], drop_indicator_onto: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], drop_indicator_below: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], active_highlighted_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], inactive_highlighted_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None]) -> None:
        ...
    @property
    def selector_focused_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used as a selector when a row is focused
        """
        ...
    @selector_focused_brush.setter
    def selector_focused_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def active_hovered_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used when a selected row is active and hovered
        """
        ...
    @active_hovered_brush.setter
    def active_hovered_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def active_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used when a selected row is active
        """
        ...
    @active_brush.setter
    def active_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def inactive_hovered_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used when a selected row is inactive and hovered
        """
        ...
    @inactive_hovered_brush.setter
    def inactive_hovered_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def inactive_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used when a selected row is inactive
        """
        ...
    @inactive_brush.setter
    def inactive_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def use_parent_row_brush(self) -> bool:
        r"""
        (bool):  [Read-Write] If using parent row brushes
        """
        ...
    @use_parent_row_brush.setter
    def use_parent_row_brush(self, value: bool) -> None:
        ...
    @property
    def parent_row_background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used for the top parent row
        """
        ...
    @parent_row_background_brush.setter
    def parent_row_background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def parent_row_background_hovered_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used for the top parent row and row is hovered
        """
        ...
    @parent_row_background_hovered_brush.setter
    def parent_row_background_hovered_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def even_row_background_hovered_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used when an even row is hovered
        """
        ...
    @even_row_background_hovered_brush.setter
    def even_row_background_hovered_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def even_row_background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used when an even row is in its normal state
        """
        ...
    @even_row_background_brush.setter
    def even_row_background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def odd_row_background_hovered_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used when an odd row is hovered
        """
        ...
    @odd_row_background_hovered_brush.setter
    def odd_row_background_hovered_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def odd_row_background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush to used when an odd row is in its normal state
        """
        ...
    @odd_row_background_brush.setter
    def odd_row_background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def text_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Text color used for all rows
        """
        ...
    @text_color.setter
    def text_color(self, value: SlateColor) -> None:
        ...
    @property
    def selected_text_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Text color used for the selected row
        """
        ...
    @selected_text_color.setter
    def selected_text_color(self, value: SlateColor) -> None:
        ...
    @property
    def drop_indicator_above(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to provide feedback that a user can drop above the hovered row.
        """
        ...
    @drop_indicator_above.setter
    def drop_indicator_above(self, value: SlateBrush) -> None:
        ...
    @property
    def drop_indicator_onto(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to provide feedback that a user can drop onto the hovered row.
        """
        ...
    @drop_indicator_onto.setter
    def drop_indicator_onto(self, value: SlateBrush) -> None:
        ...
    @property
    def drop_indicator_below(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to provide feedback that a user can drop below the hovered row.
        """
        ...
    @drop_indicator_below.setter
    def drop_indicator_below(self, value: SlateBrush) -> None:
        ...
    @property
    def active_highlighted_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used when a highlighted row is active
        """
        ...
    @active_highlighted_brush.setter
    def active_highlighted_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def inactive_highlighted_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used when a highlighted row is inactive and hovered
        """
        ...
    @inactive_highlighted_brush.setter
    def inactive_highlighted_brush(self, value: SlateBrush) -> None:
        ...

class ComboBoxStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SComboBox
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``combo_button_style`` (ComboButtonStyle):  [Read-Write] The style to use for our SComboButton
    - ``content_padding`` (Margin):  [Read-Write] * Button Content Padding
    - ``menu_row_padding`` (Margin):  [Read-Write] * Menu Row Padding
    - ``pressed_slate_sound`` (SlateSound):  [Read-Write] The sound the button should play when pressed
    - ``selection_change_slate_sound`` (SlateSound):  [Read-Write] The Sound to play when the selection is changed
    """
    def __init__(self, combo_button_style: ComboButtonStyle = [[[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 1.000000], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [0.000000, 0.000000, 0.000000, 0.000000], [5.000000, 5.000000, 5.000000, 5.000000], [2.000000, 2.000000, 2.000000, 2.000000], VerticalAlignment.V_ALIGN_CENTER], pressed_slate_sound: SlateSound = [None], selection_change_slate_sound: SlateSound = [None], content_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], menu_row_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def combo_button_style(self) -> ComboButtonStyle:
        r"""
        (ComboButtonStyle):  [Read-Write] The style to use for our SComboButton
        """
        ...
    @combo_button_style.setter
    def combo_button_style(self, value: ComboButtonStyle) -> None:
        ...
    @property
    def pressed_slate_sound(self) -> SlateSound:
        r"""
        (SlateSound):  [Read-Write] The sound the button should play when pressed
        """
        ...
    @pressed_slate_sound.setter
    def pressed_slate_sound(self, value: SlateSound) -> None:
        ...
    @property
    def selection_change_slate_sound(self) -> SlateSound:
        r"""
        (SlateSound):  [Read-Write] The Sound to play when the selection is changed
        """
        ...
    @selection_change_slate_sound.setter
    def selection_change_slate_sound(self, value: SlateSound) -> None:
        ...
    @property
    def content_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] * Button Content Padding
        """
        ...
    @content_padding.setter
    def content_padding(self, value: Margin) -> None:
        ...
    @property
    def menu_row_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] * Menu Row Padding
        """
        ...
    @menu_row_padding.setter
    def menu_row_padding(self, value: Margin) -> None:
        ...

class SlateSound(StructBase):
    r"""
    An intermediary to make UBaseSound available for Slate to play sounds
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateSound.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``resource_object`` (Object):  [Read-Write] Pointer to the USoundBase. Holding onto it as a UObject because USoundBase is not available in Slate core.
      Edited via FSlateSoundStructCustomization to ensure you can only set USoundBase assets on it.
    """
    def __init__(self, resource_object: Object = None) -> None:
        ...
    @property
    def resource_object(self) -> Object:
        r"""
        (Object):  [Read-Write] Pointer to the USoundBase. Holding onto it as a UObject because USoundBase is not available in Slate core.
        Edited via FSlateSoundStructCustomization to ensure you can only set USoundBase assets on it.
        """
        ...
    @resource_object.setter
    def resource_object(self, value: Object) -> None:
        ...

class ComboButtonStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SComboButton
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``button_style`` (ButtonStyle):  [Read-Write] The style to use for our SButton.
    - ``content_padding`` (Margin):  [Read-Write] * Button Content Padding
    - ``down_arrow_align`` (VerticalAlignment):  [Read-Write] * Dropdown arrow vertical alignment
    - ``down_arrow_image`` (SlateBrush):  [Read-Write] Image to use for the down arrow.
    - ``down_arrow_padding`` (Margin):  [Read-Write] * Dropdown arrow padding (if a dropdown arrow exists)
    - ``menu_border_brush`` (SlateBrush):  [Read-Write] Brush to use to add a "menu border" around the drop-down content.
    - ``menu_border_padding`` (Margin):  [Read-Write] Padding to use to add a "menu border" around the drop-down content.
    - ``shadow_color_and_opacity`` (LinearColor):  [Read-Write] The color and opacity of the shadow for the down arrow.
      Only active if ShadowOffset is not (0,0).
    - ``shadow_offset`` (DeprecateSlateVector2D):  [Read-Write] How much should the shadow be offset for the down arrow?
      An offset of 0 implies no shadow.
    """
    def __init__(self, button_style: ButtonStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], down_arrow_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], shadow_offset: DeprecateSlateVector2D = [0.000000, 0.000000], shadow_color_and_opacity: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], menu_border_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], menu_border_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], content_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], down_arrow_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], down_arrow_align: VerticalAlignment = VerticalAlignment.V_ALIGN_FILL) -> None:
        ...
    @property
    def button_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write] The style to use for our SButton.
        """
        ...
    @button_style.setter
    def button_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def down_arrow_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use for the down arrow.
        """
        ...
    @down_arrow_image.setter
    def down_arrow_image(self, value: SlateBrush) -> None:
        ...
    @property
    def shadow_offset(self) -> DeprecateSlateVector2D:
        r"""
        (DeprecateSlateVector2D):  [Read-Write] How much should the shadow be offset for the down arrow?
        An offset of 0 implies no shadow.
        """
        ...
    @shadow_offset.setter
    def shadow_offset(self, value: DeprecateSlateVector2D) -> None:
        ...
    @property
    def shadow_color_and_opacity(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color and opacity of the shadow for the down arrow.
        Only active if ShadowOffset is not (0,0).
        """
        ...
    @shadow_color_and_opacity.setter
    def shadow_color_and_opacity(self, value: LinearColor) -> None:
        ...
    @property
    def menu_border_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush to use to add a "menu border" around the drop-down content.
        """
        ...
    @menu_border_brush.setter
    def menu_border_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def menu_border_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding to use to add a "menu border" around the drop-down content.
        """
        ...
    @menu_border_padding.setter
    def menu_border_padding(self, value: Margin) -> None:
        ...
    @property
    def content_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] * Button Content Padding
        """
        ...
    @content_padding.setter
    def content_padding(self, value: Margin) -> None:
        ...
    @property
    def down_arrow_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] * Dropdown arrow padding (if a dropdown arrow exists)
        """
        ...
    @down_arrow_padding.setter
    def down_arrow_padding(self, value: Margin) -> None:
        ...
    @property
    def down_arrow_align(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] * Dropdown arrow vertical alignment
        """
        ...
    @down_arrow_align.setter
    def down_arrow_align(self, value: VerticalAlignment) -> None:
        ...

class ButtonStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SButton
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disabled`` (SlateBrush):  [Read-Write] Button appearance when disabled, by default this is set to an invalid resource when that is the case default disabled drawing is used.
    - ``disabled_foreground`` (SlateColor):  [Read-Write] Foreground Color when disabled
    - ``hovered`` (SlateBrush):  [Read-Write] Button appearance when hovered
    - ``hovered_foreground`` (SlateColor):  [Read-Write] Foreground Color when hovered
    - ``hovered_slate_sound`` (SlateSound):  [Read-Write] The sound the button should play when initially hovered over
    - ``normal`` (SlateBrush):  [Read-Write] Button appearance when the button is not hovered or pressed
    - ``normal_foreground`` (SlateColor):  [Read-Write] Foreground Color when the button is not hovered or pressed
    - ``normal_padding`` (Margin):  [Read-Write] Padding that accounts for the border in the button's background image.
      When this is applied, the content of the button should appear flush
      with the button's border. Use this padding when the button is not pressed.
    - ``pressed`` (SlateBrush):  [Read-Write] Button appearance when pressed
    - ``pressed_foreground`` (SlateColor):  [Read-Write] Foreground Color when pressed
    - ``pressed_padding`` (Margin):  [Read-Write] Same as NormalPadding but used when the button is pressed. Allows for moving the content to match
      any "movement" in the button's border image.
    - ``pressed_slate_sound`` (SlateSound):  [Read-Write] The sound the button should play when pressed
    """
    def __init__(self, normal: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], hovered: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], pressed: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], disabled: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], normal_foreground: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], hovered_foreground: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], pressed_foreground: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], disabled_foreground: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], normal_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], pressed_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], pressed_slate_sound: SlateSound = [None], hovered_slate_sound: SlateSound = [None]) -> None:
        ...
    @property
    def normal(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Button appearance when the button is not hovered or pressed
        """
        ...
    @normal.setter
    def normal(self, value: SlateBrush) -> None:
        ...
    @property
    def hovered(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Button appearance when hovered
        """
        ...
    @hovered.setter
    def hovered(self, value: SlateBrush) -> None:
        ...
    @property
    def pressed(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Button appearance when pressed
        """
        ...
    @pressed.setter
    def pressed(self, value: SlateBrush) -> None:
        ...
    @property
    def disabled(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Button appearance when disabled, by default this is set to an invalid resource when that is the case default disabled drawing is used.
        """
        ...
    @disabled.setter
    def disabled(self, value: SlateBrush) -> None:
        ...
    @property
    def normal_foreground(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Foreground Color when the button is not hovered or pressed
        """
        ...
    @normal_foreground.setter
    def normal_foreground(self, value: SlateColor) -> None:
        ...
    @property
    def hovered_foreground(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Foreground Color when hovered
        """
        ...
    @hovered_foreground.setter
    def hovered_foreground(self, value: SlateColor) -> None:
        ...
    @property
    def pressed_foreground(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Foreground Color when pressed
        """
        ...
    @pressed_foreground.setter
    def pressed_foreground(self, value: SlateColor) -> None:
        ...
    @property
    def disabled_foreground(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Foreground Color when disabled
        """
        ...
    @disabled_foreground.setter
    def disabled_foreground(self, value: SlateColor) -> None:
        ...
    @property
    def normal_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding that accounts for the border in the button's background image.
        When this is applied, the content of the button should appear flush
        with the button's border. Use this padding when the button is not pressed.
        """
        ...
    @normal_padding.setter
    def normal_padding(self, value: Margin) -> None:
        ...
    @property
    def pressed_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Same as NormalPadding but used when the button is pressed. Allows for moving the content to match
        any "movement" in the button's border image.
        """
        ...
    @pressed_padding.setter
    def pressed_padding(self, value: Margin) -> None:
        ...
    @property
    def pressed_slate_sound(self) -> SlateSound:
        r"""
        (SlateSound):  [Read-Write] The sound the button should play when pressed
        """
        ...
    @pressed_slate_sound.setter
    def pressed_slate_sound(self, value: SlateSound) -> None:
        ...
    @property
    def hovered_slate_sound(self) -> SlateSound:
        r"""
        (SlateSound):  [Read-Write] The sound the button should play when initially hovered over
        """
        ...
    @hovered_slate_sound.setter
    def hovered_slate_sound(self, value: SlateSound) -> None:
        ...

class SlateFontInfo(StructBase):
    r"""
    A representation of a font in Slate.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateFontInfo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``font_material`` (Object):  [Read-Write] The material to use when rendering
    - ``font_object`` (Object):  [Read-Write] The font object (valid when used from UMG or a Slate widget style asset)
    - ``force_monospaced`` (bool):  [Read-Write] Enable pseudo-monospaced font.
    - ``letter_spacing`` (int32):  [Read-Write] The uniform spacing (or tracking) between all characters in the text.
    - ``monospaced_width`` (float):  [Read-Write] The uniform width to apply to all characters when bForceMonospaced is enabled, proportional of the font Size.
    - ``outline_settings`` (FontOutlineSettings):  [Read-Write] Settings for applying an outline to a font
    - ``size`` (float):  [Read-Write] The font size is a measure in point values. The conversion of points to Slate Units is done at 96 DPI.
      So if you're using a tool like Photoshop to prototype layouts and UI mock ups, you can change the UMG Font settings
      to ensure that UMG font size is displayed in its 72 DPI equivalent, even if Slate will still use 96 DPI internally.
    - ``skew_amount`` (float):  [Read-Write] A skew amount to apply to the text.
    - ``typeface_font_name`` (Name):  [Read-Write] The name of the font to use from the default typeface (None will use the first entry)
    """
    def __init__(self, font_object: Object = None, font_material: Object = None, outline_settings: FontOutlineSettings = [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], typeface_font_name: Name = "None", size: float = 0.000000, letter_spacing: int = 0, skew_amount: float = 0.000000, force_monospaced: bool = False, monospaced_width: float = 0.000000) -> None:
        ...
    @property
    def font_object(self) -> Object:
        r"""
        (Object):  [Read-Write] The font object (valid when used from UMG or a Slate widget style asset)
        """
        ...
    @font_object.setter
    def font_object(self, value: Object) -> None:
        ...
    @property
    def font_material(self) -> Object:
        r"""
        (Object):  [Read-Write] The material to use when rendering
        """
        ...
    @font_material.setter
    def font_material(self, value: Object) -> None:
        ...
    @property
    def outline_settings(self) -> FontOutlineSettings:
        r"""
        (FontOutlineSettings):  [Read-Write] Settings for applying an outline to a font
        """
        ...
    @outline_settings.setter
    def outline_settings(self, value: FontOutlineSettings) -> None:
        ...
    @property
    def typeface_font_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the font to use from the default typeface (None will use the first entry)
        """
        ...
    @typeface_font_name.setter
    def typeface_font_name(self, value: Name) -> None:
        ...
    @property
    def size(self) -> float:
        r"""
        (float):  [Read-Write] The font size is a measure in point values. The conversion of points to Slate Units is done at 96 DPI.
        So if you're using a tool like Photoshop to prototype layouts and UI mock ups, you can change the UMG Font settings
        to ensure that UMG font size is displayed in its 72 DPI equivalent, even if Slate will still use 96 DPI internally.
        """
        ...
    @size.setter
    def size(self, value: float) -> None:
        ...
    @property
    def letter_spacing(self) -> int:
        r"""
        (int32):  [Read-Write] The uniform spacing (or tracking) between all characters in the text.
        """
        ...
    @letter_spacing.setter
    def letter_spacing(self, value: int) -> None:
        ...
    @property
    def skew_amount(self) -> float:
        r"""
        (float):  [Read-Write] A skew amount to apply to the text.
        """
        ...
    @skew_amount.setter
    def skew_amount(self, value: float) -> None:
        ...
    @property
    def force_monospaced(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable pseudo-monospaced font.
        """
        ...
    @force_monospaced.setter
    def force_monospaced(self, value: bool) -> None:
        ...
    @property
    def monospaced_width(self) -> float:
        r"""
        (float):  [Read-Write] The uniform width to apply to all characters when bForceMonospaced is enabled, proportional of the font Size.
        """
        ...
    @monospaced_width.setter
    def monospaced_width(self, value: float) -> None:
        ...

class FontOutlineSettings(StructBase):
    r"""
    Settings for applying an outline to a font
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateFontInfo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_outline_to_drop_shadows`` (bool):  [Read-Write] When enabled the outline will be applied to any drop shadow that uses this font
    - ``mitered_corners`` (bool):  [Read-Write] When enabled, outlines have sharp mitered corners, otherwise they are rounded.
    - ``outline_color`` (LinearColor):  [Read-Write] The color of the outline for any character in this font
    - ``outline_material`` (Object):  [Read-Write] Optional material to apply to the outline
    - ``outline_size`` (int32):  [Read-Write] Size of the outline in slate units (at 1.0 font scale this unit is a pixel)
    - ``separate_fill_alpha`` (bool):  [Read-Write] When enabled the outline will be completely translucent where the filled area will be.  This allows for a separate fill alpha value
      The trade off when enabling this is slightly worse quality for completely opaque fills where the inner outline border meets the fill area
    """
    def __init__(self, outline_size: int = 0, mitered_corners: bool = False, separate_fill_alpha: bool = False, apply_outline_to_drop_shadows: bool = False, outline_material: Object = None, outline_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def outline_size(self) -> int:
        r"""
        (int32):  [Read-Write] Size of the outline in slate units (at 1.0 font scale this unit is a pixel)
        """
        ...
    @outline_size.setter
    def outline_size(self, value: int) -> None:
        ...
    @property
    def mitered_corners(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled, outlines have sharp mitered corners, otherwise they are rounded.
        """
        ...
    @mitered_corners.setter
    def mitered_corners(self, value: bool) -> None:
        ...
    @property
    def separate_fill_alpha(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled the outline will be completely translucent where the filled area will be.  This allows for a separate fill alpha value
        The trade off when enabling this is slightly worse quality for completely opaque fills where the inner outline border meets the fill area
        """
        ...
    @separate_fill_alpha.setter
    def separate_fill_alpha(self, value: bool) -> None:
        ...
    @property
    def apply_outline_to_drop_shadows(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled the outline will be applied to any drop shadow that uses this font
        """
        ...
    @apply_outline_to_drop_shadows.setter
    def apply_outline_to_drop_shadows(self, value: bool) -> None:
        ...
    @property
    def outline_material(self) -> Object:
        r"""
        (Object):  [Read-Write] Optional material to apply to the outline
        """
        ...
    @outline_material.setter
    def outline_material(self, value: Object) -> None:
        ...
    @property
    def outline_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color of the outline for any character in this font
        """
        ...
    @outline_color.setter
    def outline_color(self, value: LinearColor) -> None:
        ...

class ShapedTextOptions(StructBase):
    r"""
    Common data for all widgets that use shaped text.
    Contains the common options that should be exposed for the underlying Slate widget.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: TextWidgetTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``override_text_flow_direction`` (bool):  [Read-Write]
    - ``override_text_shaping_method`` (bool):  [Read-Write]
    - ``text_flow_direction`` (TextFlowDirection):  [Read-Write] Which text flow direction should the text within this widget use? (unset to use the default returned by GetDefaultTextFlowDirection)
    - ``text_shaping_method`` (TextShapingMethod):  [Read-Write] Which text shaping method should the text within this widget use? (unset to use the default returned by GetDefaultTextShapingMethod)
    """
    def __init__(self, text_shaping_method: TextShapingMethod = TextShapingMethod.AUTO, text_flow_direction: TextFlowDirection = TextFlowDirection.AUTO) -> None:
        ...
    @property
    def text_shaping_method(self) -> TextShapingMethod:
        r"""
        (TextShapingMethod):  [Read-Only] Which text shaping method should the text within this widget use? (unset to use the default returned by GetDefaultTextShapingMethod)
        """
        ...
    @property
    def text_flow_direction(self) -> TextFlowDirection:
        r"""
        (TextFlowDirection):  [Read-Only] Which text flow direction should the text within this widget use? (unset to use the default returned by GetDefaultTextFlowDirection)
        """
        ...

class EditableTextStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SEditableText
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_image_composing`` (SlateBrush):  [Read-Write] Background image for the selected text
    - ``background_image_selected`` (SlateBrush):  [Read-Write] Background image for the selected text
    - ``caret_image`` (SlateBrush):  [Read-Write] Image brush used for the caret
    - ``color_and_opacity`` (SlateColor):  [Read-Write] The color and opacity of this text
    - ``font`` (SlateFontInfo):  [Read-Write] Font family and size to be used when displaying this text.
    """
    def __init__(self, font: SlateFontInfo = [None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000], color_and_opacity: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], background_image_selected: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], background_image_composing: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], caret_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None]) -> None:
        ...
    @property
    def font(self) -> SlateFontInfo:
        r"""
        (SlateFontInfo):  [Read-Write] Font family and size to be used when displaying this text.
        """
        ...
    @font.setter
    def font(self, value: SlateFontInfo) -> None:
        ...
    @property
    def color_and_opacity(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] The color and opacity of this text
        """
        ...
    @color_and_opacity.setter
    def color_and_opacity(self, value: SlateColor) -> None:
        ...
    @property
    def background_image_selected(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Background image for the selected text
        """
        ...
    @background_image_selected.setter
    def background_image_selected(self, value: SlateBrush) -> None:
        ...
    @property
    def background_image_composing(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Background image for the selected text
        """
        ...
    @background_image_composing.setter
    def background_image_composing(self, value: SlateBrush) -> None:
        ...
    @property
    def caret_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image brush used for the caret
        """
        ...
    @caret_image.setter
    def caret_image(self, value: SlateBrush) -> None:
        ...

class EditableTextBoxStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SEditableTextBox
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_color`` (SlateColor):  [Read-Write] The background color applied to the active background image
    - ``background_image_focused`` (SlateBrush):  [Read-Write] Border background image when the box is focused
    - ``background_image_hovered`` (SlateBrush):  [Read-Write] Border background image when the box is hovered
    - ``background_image_normal`` (SlateBrush):  [Read-Write] Border background image when the box is not hovered or focused
    - ``background_image_read_only`` (SlateBrush):  [Read-Write] Border background image when the box is read-only
    - ``focused_foreground_color`` (SlateColor):  [Read-Write] The foreground color of text when the edit box has keyboard focus.
    - ``foreground_color`` (SlateColor):  [Read-Write] The foreground color of text.
    - ``h_scroll_bar_padding`` (Margin):  [Read-Write] Padding around the horizontal scrollbar
    - ``padding`` (Margin):  [Read-Write] Padding
    - ``read_only_foreground_color`` (SlateColor):  [Read-Write] The read-only foreground color of text in read-only mode.
    - ``scroll_bar_style`` (ScrollBarStyle):  [Read-Write] Style used for the scrollbars
    - ``text_style`` (TextBlockStyle):  [Read-Write] The style of the text block, which dictates the font, color, and shadow options. Style overrides all other properties!
    - ``v_scroll_bar_padding`` (Margin):  [Read-Write] Padding around the vertical scrollbar
    """
    def __init__(self, background_image_normal: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], background_image_hovered: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], background_image_focused: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], background_image_read_only: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], text_style: TextBlockStyle = [[None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], TextTransformPolicy.NONE, TextOverflowPolicy.CLIP], foreground_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], background_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], read_only_foreground_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], focused_foreground_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], h_scroll_bar_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], v_scroll_bar_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], scroll_bar_style: ScrollBarStyle = [[SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], 16.000000]) -> None:
        ...
    @property
    def background_image_normal(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Border background image when the box is not hovered or focused
        """
        ...
    @background_image_normal.setter
    def background_image_normal(self, value: SlateBrush) -> None:
        ...
    @property
    def background_image_hovered(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Border background image when the box is hovered
        """
        ...
    @background_image_hovered.setter
    def background_image_hovered(self, value: SlateBrush) -> None:
        ...
    @property
    def background_image_focused(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Border background image when the box is focused
        """
        ...
    @background_image_focused.setter
    def background_image_focused(self, value: SlateBrush) -> None:
        ...
    @property
    def background_image_read_only(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Border background image when the box is read-only
        """
        ...
    @background_image_read_only.setter
    def background_image_read_only(self, value: SlateBrush) -> None:
        ...
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def text_style(self) -> TextBlockStyle:
        r"""
        (TextBlockStyle):  [Read-Write] The style of the text block, which dictates the font, color, and shadow options. Style overrides all other properties!
        """
        ...
    @text_style.setter
    def text_style(self, value: TextBlockStyle) -> None:
        ...
    @property
    def foreground_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] The foreground color of text.
        """
        ...
    @foreground_color.setter
    def foreground_color(self, value: SlateColor) -> None:
        ...
    @property
    def background_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] The background color applied to the active background image
        """
        ...
    @background_color.setter
    def background_color(self, value: SlateColor) -> None:
        ...
    @property
    def read_only_foreground_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] The read-only foreground color of text in read-only mode.
        """
        ...
    @read_only_foreground_color.setter
    def read_only_foreground_color(self, value: SlateColor) -> None:
        ...
    @property
    def focused_foreground_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] The foreground color of text when the edit box has keyboard focus.
        """
        ...
    @focused_foreground_color.setter
    def focused_foreground_color(self, value: SlateColor) -> None:
        ...
    @property
    def h_scroll_bar_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding around the horizontal scrollbar
        """
        ...
    @h_scroll_bar_padding.setter
    def h_scroll_bar_padding(self, value: Margin) -> None:
        ...
    @property
    def v_scroll_bar_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding around the vertical scrollbar
        """
        ...
    @v_scroll_bar_padding.setter
    def v_scroll_bar_padding(self, value: Margin) -> None:
        ...
    @property
    def scroll_bar_style(self) -> ScrollBarStyle:
        r"""
        (ScrollBarStyle):  [Read-Write] Style used for the scrollbars
        """
        ...
    @scroll_bar_style.setter
    def scroll_bar_style(self, value: ScrollBarStyle) -> None:
        ...

class TextBlockStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an STextBlock
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_and_opacity`` (SlateColor):  [Read-Write] The color and opacity of this text
    - ``font`` (SlateFontInfo):  [Read-Write] Font family and size to be used when displaying this text.
    - ``highlight_color`` (SlateColor):  [Read-Write] The color of highlighted text
    - ``highlight_shape`` (SlateBrush):  [Read-Write] The shape of highlighted text
    - ``overflow_policy`` (TextOverflowPolicy):  [Read-Write] Determines what happens to text that is clipped and doesn't fit within the clip rect of a text widget
    - ``selected_background_color`` (SlateColor):  [Read-Write] The background color of selected text
    - ``shadow_color_and_opacity`` (LinearColor):  [Read-Write] The color and opacity of the shadow
    - ``shadow_offset`` (DeprecateSlateVector2D):  [Read-Write] How much should the shadow be offset? An offset of 0 implies no shadow.
    - ``strike_brush`` (SlateBrush):  [Read-Write] The brush used to draw an strike through the text (if any)
    - ``transform_policy`` (TextTransformPolicy):  [Read-Write] The Text Transform Policy (defaults to None)
    - ``underline_brush`` (SlateBrush):  [Read-Write] The brush used to draw an underline under the text (if any)
    """
    def __init__(self, font: SlateFontInfo = [None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000], color_and_opacity: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], shadow_offset: DeprecateSlateVector2D = [0.000000, 0.000000], shadow_color_and_opacity: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], highlight_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], highlight_shape: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], strike_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], underline_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], transform_policy: TextTransformPolicy = TextTransformPolicy.NONE, overflow_policy: TextOverflowPolicy = TextOverflowPolicy.CLIP) -> None:
        ...
    @property
    def font(self) -> SlateFontInfo:
        r"""
        (SlateFontInfo):  [Read-Write] Font family and size to be used when displaying this text.
        """
        ...
    @font.setter
    def font(self, value: SlateFontInfo) -> None:
        ...
    @property
    def color_and_opacity(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] The color and opacity of this text
        """
        ...
    @color_and_opacity.setter
    def color_and_opacity(self, value: SlateColor) -> None:
        ...
    @property
    def shadow_offset(self) -> DeprecateSlateVector2D:
        r"""
        (DeprecateSlateVector2D):  [Read-Write] How much should the shadow be offset? An offset of 0 implies no shadow.
        """
        ...
    @shadow_offset.setter
    def shadow_offset(self, value: DeprecateSlateVector2D) -> None:
        ...
    @property
    def shadow_color_and_opacity(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color and opacity of the shadow
        """
        ...
    @shadow_color_and_opacity.setter
    def shadow_color_and_opacity(self, value: LinearColor) -> None:
        ...
    @property
    def highlight_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] The color of highlighted text
        """
        ...
    @highlight_color.setter
    def highlight_color(self, value: SlateColor) -> None:
        ...
    @property
    def highlight_shape(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The shape of highlighted text
        """
        ...
    @highlight_shape.setter
    def highlight_shape(self, value: SlateBrush) -> None:
        ...
    @property
    def strike_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The brush used to draw an strike through the text (if any)
        """
        ...
    @strike_brush.setter
    def strike_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def underline_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The brush used to draw an underline under the text (if any)
        """
        ...
    @underline_brush.setter
    def underline_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def transform_policy(self) -> TextTransformPolicy:
        r"""
        (TextTransformPolicy):  [Read-Write] The Text Transform Policy (defaults to None)
        """
        ...
    @transform_policy.setter
    def transform_policy(self, value: TextTransformPolicy) -> None:
        ...
    @property
    def overflow_policy(self) -> TextOverflowPolicy:
        r"""
        (TextOverflowPolicy):  [Read-Write] Determines what happens to text that is clipped and doesn't fit within the clip rect of a text widget
        """
        ...
    @overflow_policy.setter
    def overflow_policy(self, value: TextOverflowPolicy) -> None:
        ...

class InputChord(StructBase):
    r"""
    An Input Chord is a key and the modifier keys that are to be held with it.
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: InputChord.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alt`` (bool):  [Read-Write] Whether the alt key is part of the chord.
    - ``cmd`` (bool):  [Read-Write] Whether the command key is part of the chord.
    - ``ctrl`` (bool):  [Read-Write] Whether the control key is part of the chord.
    - ``key`` (Key):  [Read-Write] The Key is the core of the chord.
    - ``shift`` (bool):  [Read-Write] Whether the shift key is part of the chord.
    """
    def __init__(self, key: Key = [], shift: bool = False, ctrl: bool = False, alt: bool = False, cmd: bool = False) -> None:
        ...
    @property
    def key(self) -> Key:
        r"""
        (Key):  [Read-Write] The Key is the core of the chord.
        """
        ...
    @key.setter
    def key(self, value: Key) -> None:
        ...
    @property
    def shift(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the shift key is part of the chord.
        """
        ...
    @shift.setter
    def shift(self, value: bool) -> None:
        ...
    @property
    def ctrl(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the control key is part of the chord.
        """
        ...
    @ctrl.setter
    def ctrl(self, value: bool) -> None:
        ...
    @property
    def alt(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the alt key is part of the chord.
        """
        ...
    @alt.setter
    def alt(self, value: bool) -> None:
        ...
    @property
    def cmd(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the command key is part of the chord.
        """
        ...
    @cmd.setter
    def cmd(self, value: bool) -> None:
        ...

class SpinBoxStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SSpinBox
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active_background_brush`` (SlateBrush):  [Read-Write]
    - ``active_fill_brush`` (SlateBrush):  [Read-Write] Brush used to fill the spinbox when it's active
    - ``arrows_image`` (SlateBrush):  [Read-Write] Image used to draw the spinbox arrows
    - ``background_brush`` (SlateBrush):  [Read-Write] Brush used to draw the background of the spinbox
    - ``hovered_background_brush`` (SlateBrush):  [Read-Write] Brush used to draw the background of the spinbox when it's hovered over
    - ``hovered_fill_brush`` (SlateBrush):  [Read-Write] Brush used to fill the spinbox when it's hovered and not active
    - ``inactive_fill_brush`` (SlateBrush):  [Read-Write] Brush used to fill the spinbox when it's inactive
    - ``inset_padding`` (Margin):  [Read-Write] Padding between the background brush and the fill brush
    - ``text_padding`` (Margin):  [Read-Write] Padding to add around the spinbox and its text
    """
    def __init__(self, background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], active_background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], hovered_background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], active_fill_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], hovered_fill_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], inactive_fill_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], arrows_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], text_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], inset_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the background of the spinbox
        """
        ...
    @background_brush.setter
    def background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def active_background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @active_background_brush.setter
    def active_background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def hovered_background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the background of the spinbox when it's hovered over
        """
        ...
    @hovered_background_brush.setter
    def hovered_background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def active_fill_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to fill the spinbox when it's active
        """
        ...
    @active_fill_brush.setter
    def active_fill_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def hovered_fill_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to fill the spinbox when it's hovered and not active
        """
        ...
    @hovered_fill_brush.setter
    def hovered_fill_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def inactive_fill_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to fill the spinbox when it's inactive
        """
        ...
    @inactive_fill_brush.setter
    def inactive_fill_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def arrows_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image used to draw the spinbox arrows
        """
        ...
    @arrows_image.setter
    def arrows_image(self, value: SlateBrush) -> None:
        ...
    @property
    def text_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding to add around the spinbox and its text
        """
        ...
    @text_padding.setter
    def text_padding(self, value: Margin) -> None:
        ...
    @property
    def inset_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding between the background brush and the fill brush
        """
        ...
    @inset_padding.setter
    def inset_padding(self, value: Margin) -> None:
        ...

class PaintContext(StructBase):
    r"""
    The state passed into OnPaint that we can expose as a single painting structure to blueprints to
    allow script code to override OnPaint behavior.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UserWidget.h
    
    """
    def __init__(self) -> None:
        ...

class CharacterEvent(InputEvent):
    r"""
    FCharacterEvent describes a keyboard action where the utf-16 code is given.  Used for OnKeyChar messages
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Events.h
    
    """
    def __init__(self) -> None:
        ...

class KeyEvent(InputEvent):
    r"""
    FKeyEvent describes a key action (keyboard/controller key/button pressed or released.)
    It is passed to event handlers dealing with key input.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Events.h
    
    """
    def __init__(self) -> None:
        ...

class KeyboardEvent(KeyEvent):
    r"""
    deprecated: 'KeyboardEvent' was renamed to 'KeyEvent'.
    """
    def __init__(self) -> None:
        ...

class NavigationEvent(InputEvent):
    r"""
    FNavigationEvent describes a navigation action (Left, Right, Up, Down)
    It is passed to event handlers dealing with navigation.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Events.h
    
    """
    def __init__(self) -> None:
        ...

class AnalogInputEvent(KeyEvent):
    r"""
    FAnalogEvent describes a analog key value.
    It is passed to event handlers dealing with analog keys.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Events.h
    
    """
    def __init__(self) -> None:
        ...

class AssetRenameData(StructBase):
    r"""
    Asset Rename Data
    
    **C++ Source:**
    
    - **Module**: AssetTools
    - **File**: IAssetTools.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset`` (Object):  [Read-Write] Object being renamed
    - ``new_name`` (str):  [Read-Write] New package and asset name, new object path will be PackagePath/NewName.NewName
    - ``new_package_path`` (str):  [Read-Write] New path to package without package name, ie /Game/SubDirectory
    """
    def __init__(self, asset: Object = None, new_package_path: str = "", new_name: str = "") -> None:
        ...
    @property
    def asset(self) -> Object:
        r"""
        (Object):  [Read-Write] Object being renamed
        """
        ...
    @asset.setter
    def asset(self, value: Object) -> None:
        ...
    @property
    def new_package_path(self) -> str:
        r"""
        (str):  [Read-Write] New path to package without package name, ie /Game/SubDirectory
        """
        ...
    @new_package_path.setter
    def new_package_path(self, value: str) -> None:
        ...
    @property
    def new_name(self) -> str:
        r"""
        (str):  [Read-Write] New package and asset name, new object path will be PackagePath/NewName.NewName
        """
        ...
    @new_name.setter
    def new_name(self, value: str) -> None:
        ...

class AudioOutputDeviceInfo(StructBase):
    r"""
    Platform audio output device info, in a Blueprint-readable format
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerBlueprintLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``device_id`` (str):  [Read-Write] ID of the device.
    - ``format`` (AudioMixerStreamDataFormatType):  [Read-Write] The data format of the audio stream
    - ``is_current_device`` (bool):  [Read-Write] Whether or not this device is the device currently in use
    - ``is_system_default`` (bool):  [Read-Write] Whether or not this device is the system default
    - ``name`` (str):  [Read-Write] The name of the audio device
    - ``num_channels`` (int32):  [Read-Write] The number of channels supported by the audio device
    - ``output_channel_array`` (Array[AudioMixerChannelType]):  [Read-Write] The output channel array of the audio device
    - ``sample_rate`` (int32):  [Read-Write] The sample rate of the audio device
    """
    def __init__(self, name: str = "", device_id: str = "", num_channels: int = 0, sample_rate: int = 0, format: AudioMixerStreamDataFormatType = AudioMixerStreamDataFormatType.UNKNOWN, output_channel_array: Array[AudioMixerChannelType] = [], is_system_default: bool = False, is_current_device: bool = False) -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Only] The name of the audio device
        """
        ...
    @property
    def device_id(self) -> str:
        r"""
        (str):  [Read-Only] ID of the device.
        """
        ...
    @property
    def num_channels(self) -> int:
        r"""
        (int32):  [Read-Only] The number of channels supported by the audio device
        """
        ...
    @property
    def sample_rate(self) -> int:
        r"""
        (int32):  [Read-Only] The sample rate of the audio device
        """
        ...
    @property
    def format(self) -> AudioMixerStreamDataFormatType:
        r"""
        (AudioMixerStreamDataFormatType):  [Read-Only] The data format of the audio stream
        """
        ...
    @property
    def output_channel_array(self) -> Array[AudioMixerChannelType]:
        r"""
        (Array[AudioMixerChannelType]):  [Read-Only] The output channel array of the audio device
        """
        ...
    @property
    def is_system_default(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether or not this device is the system default
        """
        ...
    @property
    def is_current_device(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether or not this device is the device currently in use
        """
        ...

class SwapAudioOutputResult(StructBase):
    r"""
    Out structure for use with AudioMixerBlueprintLibrary::SwapAudioOutputDevice
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerBlueprintLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``current_device_id`` (str):  [Read-Write] ID of the currently set device.  This is the device at the time of the call, NOT the resulting deviceId
    - ``requested_device_id`` (str):  [Read-Write] ID of the requested device.
    - ``result`` (SwapAudioOutputDeviceResultState):  [Read-Write] Result of the call
    """
    def __init__(self, current_device_id: str = "", requested_device_id: str = "", result: SwapAudioOutputDeviceResultState = SwapAudioOutputDeviceResultState.FAILURE) -> None:
        ...
    @property
    def current_device_id(self) -> str:
        r"""
        (str):  [Read-Only] ID of the currently set device.  This is the device at the time of the call, NOT the resulting deviceId
        """
        ...
    @property
    def requested_device_id(self) -> str:
        r"""
        (str):  [Read-Only] ID of the requested device.
        """
        ...
    @property
    def result(self) -> SwapAudioOutputDeviceResultState:
        r"""
        (SwapAudioOutputDeviceResultState):  [Read-Only] Result of the call
        """
        ...

class BlueprintSessionResult(StructBase):
    r"""
    Blueprint Session Result
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: FindSessionsCallbackProxy.h
    
    """
    def __init__(self) -> None:
        ...

class OnlineProxyStoreOffer(StructBase):
    r"""
    Offer entry for display from online store
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseQueryCallbackProxy2.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``currency_code`` (str):  [Read-Write] Price currency code
    - ``description`` (Text):  [Read-Write] Short description for display
    - ``discount_type`` (OnlineProxyStoreOfferDiscountType):  [Read-Write] Type of discount currently running on this offer (if any)
    - ``dynamic_fields`` (Map[str, str]):  [Read-Write]
    - ``expiration_date`` (DateTime):  [Read-Write] Date this information is no longer valid (maybe due to sale ending, etc)
    - ``long_description`` (Text):  [Read-Write] Full description for display
    - ``numeric_price`` (int32):  [Read-Write] Final-Price (Post-Sales/Discounts) in numeric form for comparison/sorting
    - ``offer_id`` (str):  [Read-Write] Unique offer identifier
    - ``price_text`` (Text):  [Read-Write] Final-Pricing (Post-Sales/Discounts) as text for display
    - ``regular_price`` (int32):  [Read-Write] Regular non-sale price in numeric form for comparison/sorting
    - ``regular_price_text`` (Text):  [Read-Write] Regular non-sale price as text for display
    - ``release_date`` (DateTime):  [Read-Write] Date the offer was released
    - ``title`` (Text):  [Read-Write] Title for display
    """
    def __init__(self, offer_id: str = "", title: Text = "", description: Text = "", long_description: Text = "", regular_price_text: Text = "", regular_price: int = 0, price_text: Text = "", numeric_price: int = 0, currency_code: str = "", release_date: DateTime = [], expiration_date: DateTime = [], discount_type: OnlineProxyStoreOfferDiscountType = OnlineProxyStoreOfferDiscountType.NOT_ON_SALE, dynamic_fields: Map[str, str] = {}) -> None:
        ...
    @property
    def offer_id(self) -> str:
        r"""
        (str):  [Read-Only] Unique offer identifier
        """
        ...
    @property
    def title(self) -> Text:
        r"""
        (Text):  [Read-Only] Title for display
        """
        ...
    @property
    def description(self) -> Text:
        r"""
        (Text):  [Read-Only] Short description for display
        """
        ...
    @property
    def long_description(self) -> Text:
        r"""
        (Text):  [Read-Only] Full description for display
        """
        ...
    @property
    def regular_price_text(self) -> Text:
        r"""
        (Text):  [Read-Only] Regular non-sale price as text for display
        """
        ...
    @property
    def regular_price(self) -> int:
        r"""
        (int32):  [Read-Only] Regular non-sale price in numeric form for comparison/sorting
        """
        ...
    @property
    def price_text(self) -> Text:
        r"""
        (Text):  [Read-Only] Final-Pricing (Post-Sales/Discounts) as text for display
        """
        ...
    @property
    def numeric_price(self) -> int:
        r"""
        (int32):  [Read-Only] Final-Price (Post-Sales/Discounts) in numeric form for comparison/sorting
        """
        ...
    @property
    def currency_code(self) -> str:
        r"""
        (str):  [Read-Only] Price currency code
        """
        ...
    @property
    def release_date(self) -> DateTime:
        r"""
        (DateTime):  [Read-Only] Date the offer was released
        """
        ...
    @property
    def expiration_date(self) -> DateTime:
        r"""
        (DateTime):  [Read-Only] Date this information is no longer valid (maybe due to sale ending, etc)
        """
        ...
    @property
    def discount_type(self) -> OnlineProxyStoreOfferDiscountType:
        r"""
        (OnlineProxyStoreOfferDiscountType):  [Read-Only] Type of discount currently running on this offer (if any)
        """
        ...
    @property
    def dynamic_fields(self) -> Map[str, str]:
        r"""
        (Map[str, str]):  [Read-Only]
        """
        ...

class InAppPurchaseRestoreInfo2(StructBase):
    r"""
    Micro-transaction purchase information
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseRestoreCallbackProxy2.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item_id`` (str):  [Read-Write] The unique product identifier
    - ``item_name`` (str):  [Read-Write] The item name
    - ``validation_info`` (str):  [Read-Write] the unique transaction identifier
    """
    def __init__(self, item_name: str = "", item_id: str = "", validation_info: str = "") -> None:
        ...
    @property
    def item_name(self) -> str:
        r"""
        (str):  [Read-Only] The item name
        """
        ...
    @property
    def item_id(self) -> str:
        r"""
        (str):  [Read-Only] The unique product identifier
        """
        ...
    @property
    def validation_info(self) -> str:
        r"""
        (str):  [Read-Only] the unique transaction identifier
        """
        ...

class InAppPurchaseReceiptInfo2(StructBase):
    r"""
    Micro-transaction purchase information
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseDataTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item_id`` (str):  [Read-Write] The unique product identifier
    - ``item_name`` (str):  [Read-Write] The item name
    - ``transaction_identifier`` (str):  [Read-Write] the unique transaction identifier
    - ``validation_info`` (str):  [Read-Write] the purchase validation information
    """
    def __init__(self, item_name: str = "", item_id: str = "", validation_info: str = "", transaction_identifier: str = "") -> None:
        ...
    @property
    def item_name(self) -> str:
        r"""
        (str):  [Read-Only] The item name
        """
        ...
    @property
    def item_id(self) -> str:
        r"""
        (str):  [Read-Only] The unique product identifier
        """
        ...
    @property
    def validation_info(self) -> str:
        r"""
        (str):  [Read-Only] the purchase validation information
        """
        ...
    @property
    def transaction_identifier(self) -> str:
        r"""
        (str):  [Read-Only] the unique transaction identifier
        """
        ...

class FontSdfSettings(StructBase):
    r"""
    Settings for signed distance field fonts.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: FontSdfSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_ppem`` (int32):  [Read-Write] The base pixels per em for generated distance fields
    """
    def __init__(self) -> None:
        ...

class FocusEvent(StructBase):
    r"""
    FFocusEvent is used when notifying widgets about keyboard focus changes
    It is passed to event handlers dealing with keyboard focus
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Events.h
    
    """
    def __init__(self) -> None:
        ...

class KeyboardFocusEvent(FocusEvent):
    r"""
    deprecated: 'KeyboardFocusEvent' was renamed to 'FocusEvent'.
    """
    def __init__(self) -> None:
        ...

class CaptureLostEvent(StructBase):
    r"""
    Capture Lost Event
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Events.h
    
    """
    def __init__(self) -> None:
        ...

class MotionEvent(InputEvent):
    r"""
    FMotionEvent describes a touch pad action (press, move, lift)
    It is passed to event handlers dealing with touch input.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: Events.h
    
    """
    def __init__(self) -> None:
        ...

class SegmentedControlStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SSegmentedControl
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SegmentedControlStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_brush`` (SlateBrush):  [Read-Write] Background of the segmented control
    - ``control_style`` (CheckBoxStyle):  [Read-Write] The style to use for our Center Control
    - ``first_control_style`` (CheckBoxStyle):  [Read-Write] The style to use for our Left Control
    - ``last_control_style`` (CheckBoxStyle):  [Read-Write] The style to use for our Left Control
    - ``uniform_padding`` (Margin):  [Read-Write] Padding between each control
    """
    def __init__(self, control_style: CheckBoxStyle = [SlateCheckBoxType.CHECK_BOX, [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [2.000000, 0.000000, 0.000000, 0.000000], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [None], [None], [None]], first_control_style: CheckBoxStyle = [SlateCheckBoxType.CHECK_BOX, [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [2.000000, 0.000000, 0.000000, 0.000000], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [None], [None], [None]], last_control_style: CheckBoxStyle = [SlateCheckBoxType.CHECK_BOX, [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [2.000000, 0.000000, 0.000000, 0.000000], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [None], [None], [None]], background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], uniform_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def control_style(self) -> CheckBoxStyle:
        r"""
        (CheckBoxStyle):  [Read-Write] The style to use for our Center Control
        """
        ...
    @control_style.setter
    def control_style(self, value: CheckBoxStyle) -> None:
        ...
    @property
    def first_control_style(self) -> CheckBoxStyle:
        r"""
        (CheckBoxStyle):  [Read-Write] The style to use for our Left Control
        """
        ...
    @first_control_style.setter
    def first_control_style(self, value: CheckBoxStyle) -> None:
        ...
    @property
    def last_control_style(self) -> CheckBoxStyle:
        r"""
        (CheckBoxStyle):  [Read-Write] The style to use for our Left Control
        """
        ...
    @last_control_style.setter
    def last_control_style(self, value: CheckBoxStyle) -> None:
        ...
    @property
    def background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Background of the segmented control
        """
        ...
    @background_brush.setter
    def background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def uniform_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding between each control
        """
        ...
    @uniform_padding.setter
    def uniform_padding(self, value: Margin) -> None:
        ...

class CheckBoxStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SCheckBox
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_hovered_image`` (SlateBrush):  [Read-Write] Background appearance when hovered
    - ``background_image`` (SlateBrush):  [Read-Write] Background appearance
    - ``background_pressed_image`` (SlateBrush):  [Read-Write] Background appearance when pressed
    - ``border_background_color`` (SlateColor):  [Read-Write] BorderBackgroundColor refers to the actual color and opacity of the supplied border image on toggle buttons
    - ``check_box_type`` (SlateCheckBoxType):  [Read-Write] The visual type of the checkbox
    - ``checked_foreground`` (SlateColor):  [Read-Write] Foreground Color when checked
    - ``checked_hovered_foreground`` (SlateColor):  [Read-Write] Foreground Color when checked and pressed
    - ``checked_hovered_image`` (SlateBrush):  [Read-Write] CheckBox appearance when checked and hovered
    - ``checked_image`` (SlateBrush):  [Read-Write] CheckBox appearance when the CheckBox is checked
    - ``checked_pressed_foreground`` (SlateColor):  [Read-Write] Foreground Color when checked and pressed
    - ``checked_pressed_image`` (SlateBrush):  [Read-Write] CheckBox appearance when checked and pressed
    - ``checked_slate_sound`` (SlateSound):  [Read-Write] The sound the check box should play when checked
    - ``foreground_color`` (SlateColor):  [Read-Write] The normal unchecked foreground color
    - ``hovered_foreground`` (SlateColor):  [Read-Write] Foreground Color when hovered
    - ``hovered_slate_sound`` (SlateSound):  [Read-Write] The sound the check box should play when initially hovered over
    - ``padding`` (Margin):  [Read-Write] Padding
    - ``pressed_foreground`` (SlateColor):  [Read-Write] Foreground Color when pressed
    - ``unchecked_hovered_image`` (SlateBrush):  [Read-Write] CheckBox appearance when the CheckBox is unchecked and hovered
    - ``unchecked_image`` (SlateBrush):  [Read-Write] CheckBox appearance when the CheckBox is unchecked (normal)
    - ``unchecked_pressed_image`` (SlateBrush):  [Read-Write] CheckBox appearance when the CheckBox is unchecked and hovered
    - ``unchecked_slate_sound`` (SlateSound):  [Read-Write] The sound the check box should play when unchecked
    - ``undetermined_foreground`` (SlateColor):  [Read-Write] Foreground Color when the check state is indeterminate
    - ``undetermined_hovered_image`` (SlateBrush):  [Read-Write] CheckBox appearance when CheckBox is undetermined and hovered
    - ``undetermined_image`` (SlateBrush):  [Read-Write] CheckBox appearance when the CheckBox is undetermined
    - ``undetermined_pressed_image`` (SlateBrush):  [Read-Write] CheckBox appearance when CheckBox is undetermined and pressed
    """
    def __init__(self, check_box_type: SlateCheckBoxType = SlateCheckBoxType.CHECK_BOX, unchecked_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], unchecked_hovered_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], unchecked_pressed_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], checked_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], checked_hovered_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], checked_pressed_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], undetermined_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], undetermined_hovered_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], undetermined_pressed_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], background_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], background_hovered_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], background_pressed_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], foreground_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], hovered_foreground: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], pressed_foreground: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], checked_foreground: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], checked_hovered_foreground: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], checked_pressed_foreground: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], undetermined_foreground: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], border_background_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], checked_slate_sound: SlateSound = [None], unchecked_slate_sound: SlateSound = [None], hovered_slate_sound: SlateSound = [None]) -> None:
        ...
    @property
    def check_box_type(self) -> SlateCheckBoxType:
        r"""
        (SlateCheckBoxType):  [Read-Write] The visual type of the checkbox
        """
        ...
    @check_box_type.setter
    def check_box_type(self, value: SlateCheckBoxType) -> None:
        ...
    @property
    def unchecked_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] CheckBox appearance when the CheckBox is unchecked (normal)
        """
        ...
    @unchecked_image.setter
    def unchecked_image(self, value: SlateBrush) -> None:
        ...
    @property
    def unchecked_hovered_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] CheckBox appearance when the CheckBox is unchecked and hovered
        """
        ...
    @unchecked_hovered_image.setter
    def unchecked_hovered_image(self, value: SlateBrush) -> None:
        ...
    @property
    def unchecked_pressed_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] CheckBox appearance when the CheckBox is unchecked and hovered
        """
        ...
    @unchecked_pressed_image.setter
    def unchecked_pressed_image(self, value: SlateBrush) -> None:
        ...
    @property
    def checked_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] CheckBox appearance when the CheckBox is checked
        """
        ...
    @checked_image.setter
    def checked_image(self, value: SlateBrush) -> None:
        ...
    @property
    def checked_hovered_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] CheckBox appearance when checked and hovered
        """
        ...
    @checked_hovered_image.setter
    def checked_hovered_image(self, value: SlateBrush) -> None:
        ...
    @property
    def checked_pressed_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] CheckBox appearance when checked and pressed
        """
        ...
    @checked_pressed_image.setter
    def checked_pressed_image(self, value: SlateBrush) -> None:
        ...
    @property
    def undetermined_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] CheckBox appearance when the CheckBox is undetermined
        """
        ...
    @undetermined_image.setter
    def undetermined_image(self, value: SlateBrush) -> None:
        ...
    @property
    def undetermined_hovered_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] CheckBox appearance when CheckBox is undetermined and hovered
        """
        ...
    @undetermined_hovered_image.setter
    def undetermined_hovered_image(self, value: SlateBrush) -> None:
        ...
    @property
    def undetermined_pressed_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] CheckBox appearance when CheckBox is undetermined and pressed
        """
        ...
    @undetermined_pressed_image.setter
    def undetermined_pressed_image(self, value: SlateBrush) -> None:
        ...
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def background_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Background appearance
        """
        ...
    @background_image.setter
    def background_image(self, value: SlateBrush) -> None:
        ...
    @property
    def background_hovered_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Background appearance when hovered
        """
        ...
    @background_hovered_image.setter
    def background_hovered_image(self, value: SlateBrush) -> None:
        ...
    @property
    def background_pressed_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Background appearance when pressed
        """
        ...
    @background_pressed_image.setter
    def background_pressed_image(self, value: SlateBrush) -> None:
        ...
    @property
    def foreground_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] The normal unchecked foreground color
        """
        ...
    @foreground_color.setter
    def foreground_color(self, value: SlateColor) -> None:
        ...
    @property
    def hovered_foreground(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Foreground Color when hovered
        """
        ...
    @hovered_foreground.setter
    def hovered_foreground(self, value: SlateColor) -> None:
        ...
    @property
    def pressed_foreground(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Foreground Color when pressed
        """
        ...
    @pressed_foreground.setter
    def pressed_foreground(self, value: SlateColor) -> None:
        ...
    @property
    def checked_foreground(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Foreground Color when checked
        """
        ...
    @checked_foreground.setter
    def checked_foreground(self, value: SlateColor) -> None:
        ...
    @property
    def checked_hovered_foreground(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Foreground Color when checked and pressed
        """
        ...
    @checked_hovered_foreground.setter
    def checked_hovered_foreground(self, value: SlateColor) -> None:
        ...
    @property
    def checked_pressed_foreground(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Foreground Color when checked and pressed
        """
        ...
    @checked_pressed_foreground.setter
    def checked_pressed_foreground(self, value: SlateColor) -> None:
        ...
    @property
    def undetermined_foreground(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Foreground Color when the check state is indeterminate
        """
        ...
    @undetermined_foreground.setter
    def undetermined_foreground(self, value: SlateColor) -> None:
        ...
    @property
    def border_background_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] BorderBackgroundColor refers to the actual color and opacity of the supplied border image on toggle buttons
        """
        ...
    @border_background_color.setter
    def border_background_color(self, value: SlateColor) -> None:
        ...
    @property
    def checked_slate_sound(self) -> SlateSound:
        r"""
        (SlateSound):  [Read-Write] The sound the check box should play when checked
        """
        ...
    @checked_slate_sound.setter
    def checked_slate_sound(self, value: SlateSound) -> None:
        ...
    @property
    def unchecked_slate_sound(self) -> SlateSound:
        r"""
        (SlateSound):  [Read-Write] The sound the check box should play when unchecked
        """
        ...
    @unchecked_slate_sound.setter
    def unchecked_slate_sound(self, value: SlateSound) -> None:
        ...
    @property
    def hovered_slate_sound(self) -> SlateSound:
        r"""
        (SlateSound):  [Read-Write] The sound the check box should play when initially hovered over
        """
        ...
    @hovered_slate_sound.setter
    def hovered_slate_sound(self, value: SlateSound) -> None:
        ...

class HyperlinkStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SHyperlink
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``padding`` (Margin):  [Read-Write] Padding
    - ``text_style`` (TextBlockStyle):  [Read-Write] Text style
    - ``underline_style`` (ButtonStyle):  [Read-Write] Underline style
    """
    def __init__(self, underline_style: ButtonStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], text_style: TextBlockStyle = [[None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], TextTransformPolicy.NONE, TextOverflowPolicy.CLIP], padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def underline_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write] Underline style
        """
        ...
    @underline_style.setter
    def underline_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def text_style(self) -> TextBlockStyle:
        r"""
        (TextBlockStyle):  [Read-Write] Text style
        """
        ...
    @text_style.setter
    def text_style(self, value: TextBlockStyle) -> None:
        ...
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...

class InlineEditableTextBlockStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SInlineEditableTextBlock
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``editable_text_box_style`` (EditableTextBoxStyle):  [Read-Write] The style of the editable text box, which dictates the font, color, and shadow options.
    - ``text_style`` (TextBlockStyle):  [Read-Write] The style of the text block, which dictates the font, color, and shadow options. Style overrides all other properties!
    """
    def __init__(self, editable_text_box_style: EditableTextBoxStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [4.000000, 2.000000, 4.000000, 2.000000], [[None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "Regular", 9.000000, 0, 0.000000, False, 1.000000], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000, 0.000000], 0], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], 0], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], TextTransformPolicy.NONE, TextOverflowPolicy.CLIP], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], 16.000000]], text_style: TextBlockStyle = [[None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], TextTransformPolicy.NONE, TextOverflowPolicy.CLIP]) -> None:
        ...
    @property
    def editable_text_box_style(self) -> EditableTextBoxStyle:
        r"""
        (EditableTextBoxStyle):  [Read-Write] The style of the editable text box, which dictates the font, color, and shadow options.
        """
        ...
    @editable_text_box_style.setter
    def editable_text_box_style(self, value: EditableTextBoxStyle) -> None:
        ...
    @property
    def text_style(self) -> TextBlockStyle:
        r"""
        (TextBlockStyle):  [Read-Write] The style of the text block, which dictates the font, color, and shadow options. Style overrides all other properties!
        """
        ...
    @text_style.setter
    def text_style(self, value: TextBlockStyle) -> None:
        ...

class ProgressBarStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SProgressBar
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_image`` (SlateBrush):  [Read-Write] Background image to use for the progress bar
    - ``enable_fill_animation`` (bool):  [Read-Write] Enables a simple animation on the fill image to give the appearance that progress has not stalled. Disable this if you have a custom material which animates itself.
      This requires a pattern in your material or texture to give the appearance of movement.  A solid color will show no movement.
    - ``fill_image`` (SlateBrush):  [Read-Write] Foreground image to use for the progress bar
    - ``marquee_image`` (SlateBrush):  [Read-Write] Image to use for marquee mode
    """
    def __init__(self, background_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], fill_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], marquee_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], enable_fill_animation: bool = False) -> None:
        ...
    @property
    def background_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Background image to use for the progress bar
        """
        ...
    @background_image.setter
    def background_image(self, value: SlateBrush) -> None:
        ...
    @property
    def fill_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Foreground image to use for the progress bar
        """
        ...
    @fill_image.setter
    def fill_image(self, value: SlateBrush) -> None:
        ...
    @property
    def marquee_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use for marquee mode
        """
        ...
    @marquee_image.setter
    def marquee_image(self, value: SlateBrush) -> None:
        ...
    @property
    def enable_fill_animation(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables a simple animation on the fill image to give the appearance that progress has not stalled. Disable this if you have a custom material which animates itself.
        This requires a pattern in your material or texture to give the appearance of movement.  A solid color will show no movement.
        """
        ...
    @enable_fill_animation.setter
    def enable_fill_animation(self, value: bool) -> None:
        ...

class SliderStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SSlider
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bar_thickness`` (float):  [Read-Write]
    - ``disabled_bar_image`` (SlateBrush):  [Read-Write] Image to use when the slider bar is in its disabled state
    - ``disabled_thumb_image`` (SlateBrush):  [Read-Write] Image to use when the slider thumb is in its disabled state
    - ``hovered_bar_image`` (SlateBrush):  [Read-Write] Image to use when the slider bar is in its hovered state
    - ``hovered_thumb_image`` (SlateBrush):  [Read-Write] Image to use when the slider thumb is in its hovered state
    - ``normal_bar_image`` (SlateBrush):  [Read-Write] Image to use when the slider bar is in its normal state
    - ``normal_thumb_image`` (SlateBrush):  [Read-Write] Image to use when the slider thumb is in its normal state
    """
    def __init__(self, normal_bar_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], hovered_bar_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], disabled_bar_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], normal_thumb_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], hovered_thumb_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], disabled_thumb_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], bar_thickness: float = 0.000000) -> None:
        ...
    @property
    def normal_bar_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use when the slider bar is in its normal state
        """
        ...
    @normal_bar_image.setter
    def normal_bar_image(self, value: SlateBrush) -> None:
        ...
    @property
    def hovered_bar_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use when the slider bar is in its hovered state
        """
        ...
    @hovered_bar_image.setter
    def hovered_bar_image(self, value: SlateBrush) -> None:
        ...
    @property
    def disabled_bar_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use when the slider bar is in its disabled state
        """
        ...
    @disabled_bar_image.setter
    def disabled_bar_image(self, value: SlateBrush) -> None:
        ...
    @property
    def normal_thumb_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use when the slider thumb is in its normal state
        """
        ...
    @normal_thumb_image.setter
    def normal_thumb_image(self, value: SlateBrush) -> None:
        ...
    @property
    def hovered_thumb_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use when the slider thumb is in its hovered state
        """
        ...
    @hovered_thumb_image.setter
    def hovered_thumb_image(self, value: SlateBrush) -> None:
        ...
    @property
    def disabled_thumb_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use when the slider thumb is in its disabled state
        """
        ...
    @disabled_thumb_image.setter
    def disabled_thumb_image(self, value: SlateBrush) -> None:
        ...
    @property
    def bar_thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @bar_thickness.setter
    def bar_thickness(self, value: float) -> None:
        ...

class SplitterStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SSplitter
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``handle_highlight_brush`` (SlateBrush):  [Read-Write] Brush used to draw the handle in its highlight state
    - ``handle_normal_brush`` (SlateBrush):  [Read-Write] Brush used to draw the handle in its normal state
    """
    def __init__(self, handle_normal_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], handle_highlight_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None]) -> None:
        ...
    @property
    def handle_normal_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the handle in its normal state
        """
        ...
    @handle_normal_brush.setter
    def handle_normal_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def handle_highlight_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the handle in its highlight state
        """
        ...
    @handle_highlight_brush.setter
    def handle_highlight_brush(self, value: SlateBrush) -> None:
        ...

class TableViewStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an STableView
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_brush`` (SlateBrush):  [Read-Write] Brush used when a selected row is active
    """
    def __init__(self, background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None]) -> None:
        ...
    @property
    def background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used when a selected row is active
        """
        ...
    @background_brush.setter
    def background_brush(self, value: SlateBrush) -> None:
        ...

class ScrollBoxStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SScrollBox
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bar_thickness`` (float):  [Read-Write]
    - ``bottom_shadow_brush`` (SlateBrush):  [Read-Write] Brush used to draw the bottom shadow of a scrollbox
    - ``horizontal_scrolled_content_padding`` (Margin):  [Read-Write] Padding scroll panel that presents the scrolled content
    - ``left_shadow_brush`` (SlateBrush):  [Read-Write] Brush used to draw the left shadow of a scrollbox
    - ``right_shadow_brush`` (SlateBrush):  [Read-Write] Brush used to draw the right shadow of a scrollbox
    - ``top_shadow_brush`` (SlateBrush):  [Read-Write] Brush used to draw the top shadow of a scrollbox
    - ``vertical_scrolled_content_padding`` (Margin):  [Read-Write] Padding scroll panel that presents the scrolled content
    """
    def __init__(self, bar_thickness: float = 0.000000, top_shadow_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], bottom_shadow_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], left_shadow_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], right_shadow_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], horizontal_scrolled_content_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], vertical_scrolled_content_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def bar_thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @bar_thickness.setter
    def bar_thickness(self, value: float) -> None:
        ...
    @property
    def top_shadow_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the top shadow of a scrollbox
        """
        ...
    @top_shadow_brush.setter
    def top_shadow_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def bottom_shadow_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the bottom shadow of a scrollbox
        """
        ...
    @bottom_shadow_brush.setter
    def bottom_shadow_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def left_shadow_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the left shadow of a scrollbox
        """
        ...
    @left_shadow_brush.setter
    def left_shadow_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def right_shadow_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the right shadow of a scrollbox
        """
        ...
    @right_shadow_brush.setter
    def right_shadow_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def horizontal_scrolled_content_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding scroll panel that presents the scrolled content
        """
        ...
    @horizontal_scrolled_content_padding.setter
    def horizontal_scrolled_content_padding(self, value: Margin) -> None:
        ...
    @property
    def vertical_scrolled_content_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding scroll panel that presents the scrolled content
        """
        ...
    @vertical_scrolled_content_padding.setter
    def vertical_scrolled_content_padding(self, value: Margin) -> None:
        ...

class ScrollBorderStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an FScrollBorderStyle
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bottom_shadow_brush`` (SlateBrush):  [Read-Write] Brush used to draw the bottom shadow of a scrollborder
    - ``top_shadow_brush`` (SlateBrush):  [Read-Write] Brush used to draw the top shadow of a scrollborder
    """
    def __init__(self, top_shadow_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], bottom_shadow_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None]) -> None:
        ...
    @property
    def top_shadow_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the top shadow of a scrollborder
        """
        ...
    @top_shadow_brush.setter
    def top_shadow_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def bottom_shadow_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the bottom shadow of a scrollborder
        """
        ...
    @bottom_shadow_brush.setter
    def bottom_shadow_brush(self, value: SlateBrush) -> None:
        ...

class WindowStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SWindow
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active_title_brush`` (SlateBrush):  [Read-Write] Brush used to draw the window title area when the window is active
    - ``background_brush`` (SlateBrush):  [Read-Write] Brush used to draw the window background
    - ``background_color`` (SlateColor):  [Read-Write] Color used to draw the window background
    - ``border_brush`` (SlateBrush):  [Read-Write] Brush used to draw the window border
    - ``border_color`` (SlateColor):  [Read-Write] Color used to draw the window border
    - ``border_padding`` (Margin):  [Read-Write] Window corner rounding.  If this value is <= 0 no rounding will occur.   Used for regular, non-maximized windows only (not tool-tips or decorators.)
    - ``child_background_brush`` (SlateBrush):  [Read-Write] Brush used to draw the background of child windows
    - ``close_button_style`` (ButtonStyle):  [Read-Write] Style used to draw the window close button
    - ``flash_title_brush`` (SlateBrush):  [Read-Write] Brush used to draw the window title area when the window is flashing
    - ``inactive_title_brush`` (SlateBrush):  [Read-Write] Brush used to draw the window title area when the window is inactive
    - ``maximize_button_style`` (ButtonStyle):  [Read-Write] Style used to draw the window maximize button
    - ``minimize_button_style`` (ButtonStyle):  [Read-Write] Style used to draw the window minimize button
    - ``outline_brush`` (SlateBrush):  [Read-Write] Brush used to draw the window outline
    - ``outline_color`` (SlateColor):  [Read-Write] Color used to draw the window outline
    - ``restore_button_style`` (ButtonStyle):  [Read-Write] Style used to draw the window restore button
    - ``title_text_style`` (TextBlockStyle):  [Read-Write] Style used to draw the window title text
    - ``window_corner_radius`` (int32):  [Read-Write] Window corner rounding.  If this value is <= 0 no rounding will occur.   Used for regular, non-maximized windows only (not tool-tips or decorators.)
    """
    def __init__(self, minimize_button_style: ButtonStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], maximize_button_style: ButtonStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], restore_button_style: ButtonStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], close_button_style: ButtonStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], title_text_style: TextBlockStyle = [[None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], TextTransformPolicy.NONE, TextOverflowPolicy.CLIP], active_title_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], inactive_title_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], flash_title_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], background_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], outline_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], outline_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], border_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], border_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], child_background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], window_corner_radius: int = 0, border_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def minimize_button_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write] Style used to draw the window minimize button
        """
        ...
    @minimize_button_style.setter
    def minimize_button_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def maximize_button_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write] Style used to draw the window maximize button
        """
        ...
    @maximize_button_style.setter
    def maximize_button_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def restore_button_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write] Style used to draw the window restore button
        """
        ...
    @restore_button_style.setter
    def restore_button_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def close_button_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write] Style used to draw the window close button
        """
        ...
    @close_button_style.setter
    def close_button_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def title_text_style(self) -> TextBlockStyle:
        r"""
        (TextBlockStyle):  [Read-Write] Style used to draw the window title text
        """
        ...
    @title_text_style.setter
    def title_text_style(self, value: TextBlockStyle) -> None:
        ...
    @property
    def active_title_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the window title area when the window is active
        """
        ...
    @active_title_brush.setter
    def active_title_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def inactive_title_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the window title area when the window is inactive
        """
        ...
    @inactive_title_brush.setter
    def inactive_title_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def flash_title_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the window title area when the window is flashing
        """
        ...
    @flash_title_brush.setter
    def flash_title_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def background_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Color used to draw the window background
        """
        ...
    @background_color.setter
    def background_color(self, value: SlateColor) -> None:
        ...
    @property
    def outline_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the window outline
        """
        ...
    @outline_brush.setter
    def outline_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def outline_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Color used to draw the window outline
        """
        ...
    @outline_color.setter
    def outline_color(self, value: SlateColor) -> None:
        ...
    @property
    def border_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the window border
        """
        ...
    @border_brush.setter
    def border_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def border_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Color used to draw the window border
        """
        ...
    @border_color.setter
    def border_color(self, value: SlateColor) -> None:
        ...
    @property
    def background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the window background
        """
        ...
    @background_brush.setter
    def background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def child_background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Brush used to draw the background of child windows
        """
        ...
    @child_background_brush.setter
    def child_background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def window_corner_radius(self) -> int:
        r"""
        (int32):  [Read-Write] Window corner rounding.  If this value is <= 0 no rounding will occur.   Used for regular, non-maximized windows only (not tool-tips or decorators.)
        """
        ...
    @window_corner_radius.setter
    def window_corner_radius(self, value: int) -> None:
        ...
    @property
    def border_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Window corner rounding.  If this value is <= 0 no rounding will occur.   Used for regular, non-maximized windows only (not tool-tips or decorators.)
        """
        ...
    @border_padding.setter
    def border_padding(self, value: Margin) -> None:
        ...

class ToolBarStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of a toolbar
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: ToolBarStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_brush`` (SlateBrush):  [Read-Write] The brush used for the background of the toolbar
    - ``background_padding`` (Margin):  [Read-Write]
    - ``block_padding`` (Margin):  [Read-Write]
    - ``button_content_fill_width`` (float):  [Read-Write]
    - ``button_content_max_width`` (float):  [Read-Write]
    - ``button_padding`` (Margin):  [Read-Write]
    - ``button_style`` (ButtonStyle):  [Read-Write]
    - ``check_box_padding`` (Margin):  [Read-Write]
    - ``combo_button_padding`` (Margin):  [Read-Write]
    - ``combo_button_style`` (ComboButtonStyle):  [Read-Write]
    - ``editable_text_style`` (EditableTextBoxStyle):  [Read-Write]
    - ``expand_brush`` (SlateBrush):  [Read-Write] The brush used for the expand arrow when the toolbar runs out of room and needs to display toolbar items in a menu
    - ``icon_padding`` (Margin):  [Read-Write]
    - ``icon_padding_with_collapsed_label`` (Margin):  [Read-Write]
    - ``icon_padding_with_visible_label`` (Margin):  [Read-Write]
    - ``icon_size`` (DeprecateSlateVector2D):  [Read-Write]
    - ``indented_block_padding`` (Margin):  [Read-Write]
    - ``label_padding`` (Margin):  [Read-Write]
    - ``label_style`` (TextBlockStyle):  [Read-Write]
    - ``num_columns`` (int32):  [Read-Write]
    - ``separator_brush`` (SlateBrush):  [Read-Write]
    - ``separator_padding`` (Margin):  [Read-Write]
    - ``settings_button_style`` (ButtonStyle):  [Read-Write]
    - ``settings_combo_button`` (ComboButtonStyle):  [Read-Write]
    - ``settings_toggle_button`` (CheckBoxStyle):  [Read-Write]
    - ``show_labels`` (bool):  [Read-Write]
    - ``toggle_button`` (CheckBoxStyle):  [Read-Write]
    - ``uniform_block_height`` (float):  [Read-Write]
    - ``uniform_block_width`` (float):  [Read-Write]
    """
    def __init__(self, background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], expand_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], separator_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], label_style: TextBlockStyle = [[None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], TextTransformPolicy.NONE, TextOverflowPolicy.CLIP], editable_text_style: EditableTextBoxStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [4.000000, 2.000000, 4.000000, 2.000000], [[None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "Regular", 9.000000, 0, 0.000000, False, 1.000000], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000, 0.000000], 0], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], 0], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], TextTransformPolicy.NONE, TextOverflowPolicy.CLIP], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], 16.000000]], toggle_button: CheckBoxStyle = [SlateCheckBoxType.CHECK_BOX, [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [2.000000, 0.000000, 0.000000, 0.000000], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [None], [None], [None]], combo_button_style: ComboButtonStyle = [[[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 1.000000], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [0.000000, 0.000000, 0.000000, 0.000000], [5.000000, 5.000000, 5.000000, 5.000000], [2.000000, 2.000000, 2.000000, 2.000000], VerticalAlignment.V_ALIGN_CENTER], settings_button_style: ButtonStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], settings_combo_button: ComboButtonStyle = [[[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 1.000000], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [0.000000, 0.000000, 0.000000, 0.000000], [5.000000, 5.000000, 5.000000, 5.000000], [2.000000, 2.000000, 2.000000, 2.000000], VerticalAlignment.V_ALIGN_CENTER], settings_toggle_button: CheckBoxStyle = [SlateCheckBoxType.CHECK_BOX, [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [2.000000, 0.000000, 0.000000, 0.000000], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [None], [None], [None]], button_style: ButtonStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], label_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], uniform_block_width: float = 0.000000, uniform_block_height: float = 0.000000, num_columns: int = 0, icon_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], separator_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], combo_button_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], button_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], check_box_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], block_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], indented_block_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], background_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], icon_size: DeprecateSlateVector2D = [0.000000, 0.000000], show_labels: bool = False, button_content_max_width: float = 0.000000, button_content_fill_width: float = 0.000000, icon_padding_with_visible_label: Margin = [0.000000, 0.000000, 0.000000, 0.000000], icon_padding_with_collapsed_label: Margin = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The brush used for the background of the toolbar
        """
        ...
    @background_brush.setter
    def background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def expand_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The brush used for the expand arrow when the toolbar runs out of room and needs to display toolbar items in a menu
        """
        ...
    @expand_brush.setter
    def expand_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def separator_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @separator_brush.setter
    def separator_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def label_style(self) -> TextBlockStyle:
        r"""
        (TextBlockStyle):  [Read-Write]
        """
        ...
    @label_style.setter
    def label_style(self, value: TextBlockStyle) -> None:
        ...
    @property
    def editable_text_style(self) -> EditableTextBoxStyle:
        r"""
        (EditableTextBoxStyle):  [Read-Write]
        """
        ...
    @editable_text_style.setter
    def editable_text_style(self, value: EditableTextBoxStyle) -> None:
        ...
    @property
    def toggle_button(self) -> CheckBoxStyle:
        r"""
        (CheckBoxStyle):  [Read-Write]
        """
        ...
    @toggle_button.setter
    def toggle_button(self, value: CheckBoxStyle) -> None:
        ...
    @property
    def combo_button_style(self) -> ComboButtonStyle:
        r"""
        (ComboButtonStyle):  [Read-Write]
        """
        ...
    @combo_button_style.setter
    def combo_button_style(self, value: ComboButtonStyle) -> None:
        ...
    @property
    def settings_button_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write]
        """
        ...
    @settings_button_style.setter
    def settings_button_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def settings_combo_button(self) -> ComboButtonStyle:
        r"""
        (ComboButtonStyle):  [Read-Write]
        """
        ...
    @settings_combo_button.setter
    def settings_combo_button(self, value: ComboButtonStyle) -> None:
        ...
    @property
    def settings_toggle_button(self) -> CheckBoxStyle:
        r"""
        (CheckBoxStyle):  [Read-Write]
        """
        ...
    @settings_toggle_button.setter
    def settings_toggle_button(self, value: CheckBoxStyle) -> None:
        ...
    @property
    def button_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write]
        """
        ...
    @button_style.setter
    def button_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def label_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @label_padding.setter
    def label_padding(self, value: Margin) -> None:
        ...
    @property
    def uniform_block_width(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @uniform_block_width.setter
    def uniform_block_width(self, value: float) -> None:
        ...
    @property
    def uniform_block_height(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @uniform_block_height.setter
    def uniform_block_height(self, value: float) -> None:
        ...
    @property
    def num_columns(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @num_columns.setter
    def num_columns(self, value: int) -> None:
        ...
    @property
    def icon_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @icon_padding.setter
    def icon_padding(self, value: Margin) -> None:
        ...
    @property
    def separator_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @separator_padding.setter
    def separator_padding(self, value: Margin) -> None:
        ...
    @property
    def combo_button_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @combo_button_padding.setter
    def combo_button_padding(self, value: Margin) -> None:
        ...
    @property
    def button_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @button_padding.setter
    def button_padding(self, value: Margin) -> None:
        ...
    @property
    def check_box_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @check_box_padding.setter
    def check_box_padding(self, value: Margin) -> None:
        ...
    @property
    def block_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @block_padding.setter
    def block_padding(self, value: Margin) -> None:
        ...
    @property
    def indented_block_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @indented_block_padding.setter
    def indented_block_padding(self, value: Margin) -> None:
        ...
    @property
    def background_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @background_padding.setter
    def background_padding(self, value: Margin) -> None:
        ...
    @property
    def icon_size(self) -> DeprecateSlateVector2D:
        r"""
        (DeprecateSlateVector2D):  [Read-Write]
        """
        ...
    @icon_size.setter
    def icon_size(self, value: DeprecateSlateVector2D) -> None:
        ...
    @property
    def show_labels(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @show_labels.setter
    def show_labels(self, value: bool) -> None:
        ...
    @property
    def button_content_max_width(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @button_content_max_width.setter
    def button_content_max_width(self, value: float) -> None:
        ...
    @property
    def button_content_fill_width(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @button_content_fill_width.setter
    def button_content_fill_width(self, value: float) -> None:
        ...
    @property
    def icon_padding_with_visible_label(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @icon_padding_with_visible_label.setter
    def icon_padding_with_visible_label(self, value: Margin) -> None:
        ...
    @property
    def icon_padding_with_collapsed_label(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @icon_padding_with_collapsed_label.setter
    def icon_padding_with_collapsed_label(self, value: Margin) -> None:
        ...

class Anchors(StructBase):
    r"""
    Describes how a widget is anchored.
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: Anchors.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``maximum`` (Vector2D):  [Read-Write] Holds the maximum anchors, right + bottom.
    - ``minimum`` (Vector2D):  [Read-Write] Holds the minimum anchors, left + top.
    """
    def __init__(self, minimum: Vector2D = [0.000000, 0.000000], maximum: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def minimum(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Holds the minimum anchors, left + top.
        """
        ...
    @minimum.setter
    def minimum(self, value: Vector2D) -> None:
        ...
    @property
    def maximum(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Holds the maximum anchors, right + bottom.
        """
        ...
    @maximum.setter
    def maximum(self, value: Vector2D) -> None:
        ...

class TypedElementList(StructBase):
    r"""
    A list of script element handles (proxy to a FScriptTypedElementList instance).
    Provides high-level access to groups of elements, including accessing elements that implement specific interfaces.
    
    Note: the script list proxy use should be avoided when not using it for the script exposure apis.
    The weak model for the handles come with an additional cost to the runtime performance and the memory usage.
    
    **C++ Source:**
    
    - **Module**: TypedElementFramework
    - **File**: TypedElementListProxy.h
    
    """
    def __init__(self) -> None:
        ...
    def shrink(self) -> None:
        r"""
        x.shrink() -> None
        Shrink this element list storage to avoid slack.
        """
        ...
    def reset(self) -> None:
        r"""
        x.reset() -> None
        Remove all entries from this element list, preserving existing allocations.
        """
        ...
    def reserve(self, size: int) -> None:
        r"""
        x.reserve(size) -> None
        Pre-allocate enough memory in this element list to store the given number of entries.
        
        Args:
            size (int32):
        """
        ...
    def remove(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.remove(element_handle) -> bool
        Remove the given element handle from this element list, if it is in the list.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool: True if the element handle was removed, false if it isn't in the list.
        """
        ...
    def num(self) -> int:
        r"""
        x.num() -> int32
        Get the number of entries within this element list.
        
        Returns:
            int32:
        """
        ...
    def is_valid_index(self, index: int) -> bool:
        r"""
        x.is_valid_index(index) -> bool
        Is the given index a valid entry within this element list?
        
        Args:
            index (int32): 
        
        Returns:
            bool:
        """
        ...
    def has_elements_of_type(self, element_type_name: Name) -> bool:
        r"""
        x.has_elements_of_type(element_type_name) -> bool
        Test whether there are elements in this list of the given type.
        
        Args:
            element_type_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def has_elements(self, base_interface_type: Class = None) -> bool:
        r"""
        x.has_elements(base_interface_type=None) -> bool
        Test whether there are elements in this list, optionally filtering to elements that implement the given interface.
        
        Args:
            base_interface_type (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    def get_element_interface(self, element_handle: ScriptTypedElementHandle, base_interface_type: Class) -> Object:
        r"""
        x.get_element_interface(element_handle, base_interface_type) -> Object
        Get the element interface from the given handle.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            base_interface_type (type(Class)): 
        
        Returns:
            Object:
        """
        ...
    def get_element_handles(self, base_interface_type: Class) -> Array[ScriptTypedElementHandle]:
        r"""
        x.get_element_handles(base_interface_type) -> Array[ScriptTypedElementHandle]
        Get the handle of every element in this list, optionally filtering to elements that implement the given interface.
        
        Args:
            base_interface_type (type(Class)): 
        
        Returns:
            Array[ScriptTypedElementHandle]:
        """
        ...
    def get_element_handle_at(self, index: int) -> ScriptTypedElementHandle:
        r"""
        x.get_element_handle_at(index) -> ScriptTypedElementHandle
        Get the element handle at the given index.
        note: Use IsValidIndex to test for validity.
        
        Args:
            index (int32): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...
    def empty(self, slack: int = 0) -> None:
        r"""
        x.empty(slack=0) -> None
        Remove all entries from this element list, potentially leaving space allocated for the given number of entries.
        
        Args:
            slack (int32):
        """
        ...
    def count_elements_of_type(self, element_type_name: Name) -> int:
        r"""
        x.count_elements_of_type(element_type_name) -> int32
        Count the number of elements in this list of the given type.
        
        Args:
            element_type_name (Name): 
        
        Returns:
            int32:
        """
        ...
    def count_elements(self, base_interface_type: Class = None) -> int:
        r"""
        x.count_elements(base_interface_type=None) -> int32
        Count the number of elements in this list, optionally filtering to elements that implement the given interface.
        
        Args:
            base_interface_type (type(Class)): 
        
        Returns:
            int32:
        """
        ...
    def contains(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.contains(element_handle) -> bool
        Does this element list contain an entry for the given element handle?
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    def clone(self) -> TypedElementList:
        r"""
        x.clone() -> TypedElementList
        Clone this list instance.
        note: Only copies elements; does not copy any bindings!
        
        Returns:
            TypedElementList:
        """
        ...
    def append_list(self, other_element_list: TypedElementList) -> None:
        r"""
        x.append_list(other_element_list) -> None
        Append the another element list to this element list.
        
        Args:
            other_element_list (TypedElementList):
        """
        ...
    def append(self, element_handles: Array[ScriptTypedElementHandle]) -> None:
        r"""
        x.append(element_handles) -> None
        Append the given element handles to this element list.
        
        Args:
            element_handles (Array[ScriptTypedElementHandle]):
        """
        ...
    def add(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.add(element_handle) -> bool
        Add the given element handle to this element list, if it isn't already in the list.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool: True if the element handle was added, false if it is already in the list.
        """
        ...

class TypedElementSelectionNormalizationOptions(StructBase):
    r"""
    Typed Element Selection Normalization Options
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementSelectionSet.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``expand_groups`` (bool):  [Read-Write]
    - ``follow_attachment`` (bool):  [Read-Write]
    """
    def __init__(self, expand_groups: bool = False, follow_attachment: bool = False) -> None:
        ...
    @property
    def expand_groups(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @expand_groups.setter
    def expand_groups(self, value: bool) -> None:
        ...
    @property
    def follow_attachment(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @follow_attachment.setter
    def follow_attachment(self, value: bool) -> None:
        ...

class UniversalObjectLocator(StructBase):
    r"""
    Universal Object Locators (UOLs) define an address to an object.
    
    The address is implemented as a chain of FUniversalObjectLocatorFragments, allowing addressing of objects
      that may be nested deeply within levels of externally defined spawn or ownership logic.
    
    For example, a Universal Object Locator may reference an Anim Instance within a Skeletal Mesh Actor
      is spawned by a Child Actor Component that is spawned by Sequencer. This is impossible with a
      regular soft object path, but is perfectly feasible for a UOL.
    
    This type is 16 bytes.
    
    **C++ Source:**
    
    - **Module**: UniversalObjectLocator
    - **File**: UniversalObjectLocator.h
    
    """
    def __init__(self, object: Object = None, context: Object = None) -> None:
        ...
    def to_string(self) -> str:
        r"""
        x.to_string() -> str
        Convert the specified locator to its string representation
        
        Returns:
            str:
        """
        ...
    def sync_unload(self, context: Object = None) -> None:
        r"""
        x.sync_unload(context=None) -> None
        Attempt to resolve the object locator by unloading the object if possible.
        
        Args:
            context (Object): (Optional) Context object to use for resolving the object. This should usually be the object that owns or created the locator.
        """
        ...
    def sync_load(self, context: Object = None) -> Object:
        r"""
        x.sync_load(context=None) -> Object
        Attempt to resolve the object locator by finding or loading the object.
        
        Args:
            context (Object): (Optional) Context object to use for resolving the object. This should usually be the object that owns or created the locator.
        
        Returns:
            Object: The resolve object pointer, or null if it was not found.
        """
        ...
    def sync_find(self, context: Object = None) -> Object:
        r"""
        x.sync_find(context=None) -> Object
        Attempt to resolve the object locator by finding the object. If it is not currently loaded or created,
        
        Args:
            context (Object): (Optional) Context object to use for resolving the object. This should usually be the object that owns or created the locator.
        
        Returns:
            Object: The resolve object pointer, or null if it was not found.
        """
        ...
    def is_empty(self) -> bool:
        r"""
        x.is_empty() -> bool
        Check whether the specified locator is empty; not equivalent to Resolve() != None.
        An empty locator will never resolve to a valid object.
        
        Returns:
            bool:
        """
        ...

class UniversalObjectLocatorFragment(StructBase):
    r"""
    Universal Object Locator (UOL) Fragments provide an extensible mechanism for referencing permanent, transient
      or dynamically created objects relative to an external context. UOLs comprise zero or more nested fragments.
    
    Creation and resolution of a fragment requires a context to be provided;
      normally this will be the object on which the UOL exists as a property.
    
    The way in which the object is referenced is defined by globally registered 'FragmentTypes'
      (See IUniversalObjectLocatorModule::RegisterFragmentType). Each FragmentType can be thought of as somewhat
      equivalent to a www URI fragment type, though the 'path' is not necessarily just a string, but includes
      support for the full set of Engine Property types.
    
    The type is implemented as a type-erased payload block, a fragment type handle and some internal flags.
    Payloads will be allocated using the inline memory if alignment and size constraints allow, but
      will fall back to a heap allocation if necessary. Allocation should be avoided by keeping payload
      types small.
    
    Aligned to 8 bytes, 32 (runtime) or 64 (editor) bytes big.
    
    **C++ Source:**
    
    - **Module**: UniversalObjectLocator
    - **File**: UniversalObjectLocatorFragment.h
    
    """
    def __init__(self) -> None:
        ...

class SharedImageConstRefBlueprint(StructBase):
    r"""
    Exposes a FSharedImage to blueprint in an unalterable way.
    
    **C++ Source:**
    
    - **Module**: ImageCore
    - **File**: ImageCoreBP.h
    
    """
    def __init__(self) -> None:
        ...

class JsonObjectWrapper(StructBase):
    r"""
    UStruct that holds a JsonObject, can be used by structs passed to JsonObjectConverter to pass through JsonObjects directly
    
    **C++ Source:**
    
    - **Module**: JsonUtilities
    - **File**: JsonObjectWrapper.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``json_string`` (str):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class TagAndValue(StructBase):
    r"""
    Tag and Value
    
    **C++ Source:**
    
    - **Module**: AssetRegistry
    - **File**: AssetRegistryHelpers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``tag`` (Name):  [Read-Write]
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, tag: Name = "None", value: str = "") -> None:
        ...
    @property
    def tag(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @tag.setter
    def tag(self, value: Name) -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...

class AssetRegistryDependencyOptions(StructBase):
    r"""
    namespace UE::AssetRegistry
    
    **C++ Source:**
    
    - **Module**: AssetRegistry
    - **File**: IAssetRegistry.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``include_hard_management_references`` (bool):  [Read-Write] Reference that says one object directly manages another object, set when Primary Assets manage things explicitly
    - ``include_hard_package_references`` (bool):  [Read-Write] Dependencies which are required for correct usage of the source asset, and must be loaded at the same time
    - ``include_searchable_names`` (bool):  [Read-Write] References to specific SearchableNames inside a package
    - ``include_soft_management_references`` (bool):  [Read-Write] Indirect management references, these are set through recursion for Primary Assets that manage packages or other primary assets
    - ``include_soft_package_references`` (bool):  [Read-Write] Dependencies which don't need to be loaded for the object to be used (i.e. soft object paths)
    """
    def __init__(self, include_soft_package_references: bool = False, include_hard_package_references: bool = False, include_searchable_names: bool = False, include_soft_management_references: bool = False, include_hard_management_references: bool = False) -> None:
        ...
    @property
    def include_soft_package_references(self) -> bool:
        r"""
        (bool):  [Read-Write] Dependencies which don't need to be loaded for the object to be used (i.e. soft object paths)
        """
        ...
    @include_soft_package_references.setter
    def include_soft_package_references(self, value: bool) -> None:
        ...
    @property
    def include_hard_package_references(self) -> bool:
        r"""
        (bool):  [Read-Write] Dependencies which are required for correct usage of the source asset, and must be loaded at the same time
        """
        ...
    @include_hard_package_references.setter
    def include_hard_package_references(self, value: bool) -> None:
        ...
    @property
    def include_searchable_names(self) -> bool:
        r"""
        (bool):  [Read-Write] References to specific SearchableNames inside a package
        """
        ...
    @include_searchable_names.setter
    def include_searchable_names(self, value: bool) -> None:
        ...
    @property
    def include_soft_management_references(self) -> bool:
        r"""
        (bool):  [Read-Write] Indirect management references, these are set through recursion for Primary Assets that manage packages or other primary assets
        """
        ...
    @include_soft_management_references.setter
    def include_soft_management_references(self, value: bool) -> None:
        ...
    @property
    def include_hard_management_references(self) -> bool:
        r"""
        (bool):  [Read-Write] Reference that says one object directly manages another object, set when Primary Assets manage things explicitly
        """
        ...
    @include_hard_management_references.setter
    def include_hard_management_references(self, value: bool) -> None:
        ...

class ElementID(StructBase):
    r"""
    
    todo: mesheditor: Need comments
    todo: mesheditor script: BP doesn't have name spaces, so we might need a more specific display name, or just rename our various types
    
    **C++ Source:**
    
    - **Module**: MeshDescription
    - **File**: MeshTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``id_value`` (int32):  [Read-Write] The actual mesh element index this ID represents.  Read-only.
    """
    def __init__(self, id_value: int = 0) -> None:
        ...
    @property
    def id_value(self) -> int:
        r"""
        (int32):  [Read-Only] The actual mesh element index this ID represents.  Read-only.
        """
        ...

class VertexID(ElementID):
    r"""
    Vertex ID
    
    **C++ Source:**
    
    - **Module**: MeshDescription
    - **File**: MeshTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``id_value`` (int32):  [Read-Write] The actual mesh element index this ID represents.  Read-only.
    """
    def __init__(self, id_value: int = 0) -> None:
        ...

class VertexInstanceID(ElementID):
    r"""
    Vertex Instance ID
    
    **C++ Source:**
    
    - **Module**: MeshDescription
    - **File**: MeshTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``id_value`` (int32):  [Read-Write] The actual mesh element index this ID represents.  Read-only.
    """
    def __init__(self, id_value: int = 0) -> None:
        ...

class EdgeID(ElementID):
    r"""
    Edge ID
    
    **C++ Source:**
    
    - **Module**: MeshDescription
    - **File**: MeshTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``id_value`` (int32):  [Read-Write] The actual mesh element index this ID represents.  Read-only.
    """
    def __init__(self, id_value: int = 0) -> None:
        ...

class UVID(ElementID):
    r"""
    UVID
    
    **C++ Source:**
    
    - **Module**: MeshDescription
    - **File**: MeshTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``id_value`` (int32):  [Read-Write] The actual mesh element index this ID represents.  Read-only.
    """
    def __init__(self, id_value: int = 0) -> None:
        ...

class TriangleID(ElementID):
    r"""
    Triangle ID
    
    **C++ Source:**
    
    - **Module**: MeshDescription
    - **File**: MeshTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``id_value`` (int32):  [Read-Write] The actual mesh element index this ID represents.  Read-only.
    """
    def __init__(self, id_value: int = 0) -> None:
        ...

class PolygonGroupID(ElementID):
    r"""
    Polygon Group ID
    
    **C++ Source:**
    
    - **Module**: MeshDescription
    - **File**: MeshTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``id_value`` (int32):  [Read-Write] The actual mesh element index this ID represents.  Read-only.
    """
    def __init__(self, id_value: int = 0) -> None:
        ...

class PolygonID(ElementID):
    r"""
    Polygon ID
    
    **C++ Source:**
    
    - **Module**: MeshDescription
    - **File**: MeshTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``id_value`` (int32):  [Read-Write] The actual mesh element index this ID represents.  Read-only.
    """
    def __init__(self, id_value: int = 0) -> None:
        ...

class UVMapSettings(StructBase):
    r"""
    UV map generation settings that are exposed to the user for scripting and through the editor
    
    **C++ Source:**
    
    - **Module**: StaticMeshDescription
    - **File**: UVMapSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``position`` (Vector):  [Read-Write] Position of the UV mapping gizmo
    - ``rotation`` (Rotator):  [Read-Write] Rotation of the UV mapping gizmo (angles in degrees)
    - ``scale`` (Vector):  [Read-Write] Scale of the UV mapping gizmo
    - ``size`` (Vector):  [Read-Write] Length, width, height of the UV mapping gizmo
    - ``uv_tile`` (Vector2D):  [Read-Write] Tiling of the UV mapping
    """
    def __init__(self, size: Vector = [0.000000, 0.000000, 0.000000], uv_tile: Vector2D = [0.000000, 0.000000], position: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], scale: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def size(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Length, width, height of the UV mapping gizmo
        """
        ...
    @size.setter
    def size(self, value: Vector) -> None:
        ...
    @property
    def uv_tile(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Tiling of the UV mapping
        """
        ...
    @uv_tile.setter
    def uv_tile(self, value: Vector2D) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Position of the UV mapping gizmo
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] Rotation of the UV mapping gizmo (angles in degrees)
        """
        ...
    @rotation.setter
    def rotation(self, value: Rotator) -> None:
        ...
    @property
    def scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Scale of the UV mapping gizmo
        """
        ...
    @scale.setter
    def scale(self, value: Vector) -> None:
        ...

class BoneID(ElementID):
    r"""
    Bone ID
    
    **C++ Source:**
    
    - **Module**: SkeletalMeshDescription
    - **File**: SkeletalMeshElementTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``id_value`` (int32):  [Read-Write] The actual mesh element index this ID represents.  Read-only.
    """
    def __init__(self, id_value: int = 0) -> None:
        ...

class SourceGeometryPartID(ElementID):
    r"""
    Source Geometry Part ID
    
    **C++ Source:**
    
    - **Module**: SkeletalMeshDescription
    - **File**: SkeletalMeshElementTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``id_value`` (int32):  [Read-Write] The actual mesh element index this ID represents.  Read-only.
    """
    def __init__(self, id_value: int = 0) -> None:
        ...

class ClosestPhysicsObjectResult(StructBase):
    r"""
    Closest Physics Object Result
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: PhysicsObjectInterface.h
    
    """
    def __init__(self) -> None:
        ...

class SolverTrailingFilterSettings(StructBase):
    r"""
    Solver Trailing Filter Settings
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: SolverEventFilters.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``filter_enabled`` (bool):  [Read-Write] Filter is enabled.
    - ``min_mass`` (float):  [Read-Write] The minimum mass threshold for the results (compared with min of particle 1 mass and particle 2 mass).
    - ``min_speed`` (float):  [Read-Write]
    - ``min_volume`` (float):  [Read-Write]
    """
    def __init__(self, filter_enabled: bool = False, min_mass: float = 0.000000, min_speed: float = 0.000000, min_volume: float = 0.000000) -> None:
        ...
    @property
    def filter_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Filter is enabled.
        """
        ...
    @filter_enabled.setter
    def filter_enabled(self, value: bool) -> None:
        ...
    @property
    def min_mass(self) -> float:
        r"""
        (float):  [Read-Write] The minimum mass threshold for the results (compared with min of particle 1 mass and particle 2 mass).
        """
        ...
    @min_mass.setter
    def min_mass(self, value: float) -> None:
        ...
    @property
    def min_speed(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @min_speed.setter
    def min_speed(self, value: float) -> None:
        ...
    @property
    def min_volume(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @min_volume.setter
    def min_volume(self, value: float) -> None:
        ...

class SolverBreakingFilterSettings(StructBase):
    r"""
    Solver Breaking Filter Settings
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: SolverEventFilters.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``filter_enabled`` (bool):  [Read-Write] Filter is enabled.
    - ``min_mass`` (float):  [Read-Write] The minimum mass threshold for the results (compared with min of particle 1 mass and particle 2 mass).
    - ``min_speed`` (float):  [Read-Write] The min velocity threshold for the results (compared with min of particle 1 speed and particle 2 speed).
    - ``min_volume`` (float):  [Read-Write]
    """
    def __init__(self, filter_enabled: bool = False, min_mass: float = 0.000000, min_speed: float = 0.000000, min_volume: float = 0.000000) -> None:
        ...
    @property
    def filter_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Filter is enabled.
        """
        ...
    @filter_enabled.setter
    def filter_enabled(self, value: bool) -> None:
        ...
    @property
    def min_mass(self) -> float:
        r"""
        (float):  [Read-Write] The minimum mass threshold for the results (compared with min of particle 1 mass and particle 2 mass).
        """
        ...
    @min_mass.setter
    def min_mass(self, value: float) -> None:
        ...
    @property
    def min_speed(self) -> float:
        r"""
        (float):  [Read-Write] The min velocity threshold for the results (compared with min of particle 1 speed and particle 2 speed).
        """
        ...
    @min_speed.setter
    def min_speed(self, value: float) -> None:
        ...
    @property
    def min_volume(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @min_volume.setter
    def min_volume(self, value: float) -> None:
        ...

class SolverCollisionFilterSettings(StructBase):
    r"""
    Solver Collision Filter Settings
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: SolverEventFilters.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``filter_enabled`` (bool):  [Read-Write] Filter is enabled.
    - ``min_impulse`` (float):  [Read-Write] The minimum impulse threshold for the results.
    - ``min_mass`` (float):  [Read-Write] The minimum mass threshold for the results (compared with min of particle 1 mass and particle 2 mass).
    - ``min_speed`` (float):  [Read-Write] The min velocity threshold for the results (compared with min of particle 1 speed and particle 2 speed).
    """
    def __init__(self, filter_enabled: bool = False, min_mass: float = 0.000000, min_speed: float = 0.000000, min_impulse: float = 0.000000) -> None:
        ...
    @property
    def filter_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Filter is enabled.
        """
        ...
    @filter_enabled.setter
    def filter_enabled(self, value: bool) -> None:
        ...
    @property
    def min_mass(self) -> float:
        r"""
        (float):  [Read-Write] The minimum mass threshold for the results (compared with min of particle 1 mass and particle 2 mass).
        """
        ...
    @min_mass.setter
    def min_mass(self, value: float) -> None:
        ...
    @property
    def min_speed(self) -> float:
        r"""
        (float):  [Read-Write] The min velocity threshold for the results (compared with min of particle 1 speed and particle 2 speed).
        """
        ...
    @min_speed.setter
    def min_speed(self, value: float) -> None:
        ...
    @property
    def min_impulse(self) -> float:
        r"""
        (float):  [Read-Write] The minimum impulse threshold for the results.
        """
        ...
    @min_impulse.setter
    def min_impulse(self, value: float) -> None:
        ...

class SolverRemovalFilterSettings(StructBase):
    r"""
    Solver Removal Filter Settings
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: SolverEventFilters.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``filter_enabled`` (bool):  [Read-Write] Filter is enabled.
    - ``min_mass`` (float):  [Read-Write] The minimum mass threshold for the results (compared with min of particle 1 mass and particle 2 mass).
    - ``min_volume`` (float):  [Read-Write]
    """
    def __init__(self, filter_enabled: bool = False, min_mass: float = 0.000000, min_volume: float = 0.000000) -> None:
        ...
    @property
    def filter_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Filter is enabled.
        """
        ...
    @filter_enabled.setter
    def filter_enabled(self, value: bool) -> None:
        ...
    @property
    def min_mass(self) -> float:
        r"""
        (float):  [Read-Write] The minimum mass threshold for the results (compared with min of particle 1 mass and particle 2 mass).
        """
        ...
    @min_mass.setter
    def min_mass(self, value: float) -> None:
        ...
    @property
    def min_volume(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @min_volume.setter
    def min_volume(self, value: float) -> None:
        ...

class PhysicalMaterialStrength(StructBase):
    r"""
    Defines the directional strengths of a physical material in term of force per surface area
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: PhysicalMaterial.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``compression_strength`` (float):  [Read-Write] Compression strength of the material in MegaPascal ( 10^6 N/m2 )
      This amount of compression force per area the material can withstand before it fractures, crumbles or buckles
    - ``shear_strength`` (float):  [Read-Write] Shear strength of the material in MegaPascal ( 10^6 N/m2 )
      This amount of shear force per area the material can withstand before it fractures
    - ``tensile_strength`` (float):  [Read-Write] Tensile strength of the material in MegaPascal ( 10^6 N/m2 )
      This amount of tension force per area the material can withstand before it fractures
    """
    def __init__(self, tensile_strength: float = 0.000000, compression_strength: float = 0.000000, shear_strength: float = 0.000000) -> None:
        ...
    @property
    def tensile_strength(self) -> float:
        r"""
        (float):  [Read-Only] Tensile strength of the material in MegaPascal ( 10^6 N/m2 )
        This amount of tension force per area the material can withstand before it fractures
        """
        ...
    @property
    def compression_strength(self) -> float:
        r"""
        (float):  [Read-Only] Compression strength of the material in MegaPascal ( 10^6 N/m2 )
        This amount of compression force per area the material can withstand before it fractures, crumbles or buckles
        """
        ...
    @property
    def shear_strength(self) -> float:
        r"""
        (float):  [Read-Only] Shear strength of the material in MegaPascal ( 10^6 N/m2 )
        This amount of shear force per area the material can withstand before it fractures
        """
        ...

class PhysicalMaterialDamageModifier(StructBase):
    r"""
    Damage threshold modifiers, used by the Chaos destruction system
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: PhysicalMaterial.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``damage_threshold_multiplier`` (float):  [Read-Write] Multiplier for the geometry collection damage thresholds/ internal strain
      this allows for setting up unit damage threshold and use the material to scale them to the desired range of values
      Note that the geometry collection asset needs to opt-in for the material modifer to be able to use it
    """
    def __init__(self, damage_threshold_multiplier: float = 0.000000) -> None:
        ...
    @property
    def damage_threshold_multiplier(self) -> float:
        r"""
        (float):  [Read-Only] Multiplier for the geometry collection damage thresholds/ internal strain
        this allows for setting up unit damage threshold and use the material to scale them to the desired range of values
        Note that the geometry collection asset needs to opt-in for the material modifer to be able to use it
        """
        ...

class SoundGeneratorOutput(StructBase):
    r"""
    Base class for generators that have outputs that can be exposed to other game code.
    
    NOTE: This is not widely supported and should be considered experimental.
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: SoundGeneratorOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] The output's name
    """
    def __init__(self, name: Name = "None") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only] The output's name
        """
        ...

class AudioParameter(StructBase):
    r"""
    Audio Parameter
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: AudioParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``array_bool_param`` (Array[bool]):  [Read-Write] Boolean value of parameter
    - ``array_float_param`` (Array[float]):  [Read-Write] Array Float value of parameter
    - ``array_int_param`` (Array[int32]):  [Read-Write] Integer value of parameter
    - ``array_object_param`` (Array[Object]):  [Read-Write] Object value of parameter
    - ``array_string_param`` (Array[str]):  [Read-Write] String value of parameter
    - ``bool_param`` (bool):  [Read-Write] Boolean value of parameter
    - ``float_param`` (float):  [Read-Write] Float value of parameter
    - ``int_param`` (int32):  [Read-Write] Integer value of parameter. If set to 'Default Construct', value is number of array items to construct.
    - ``object_param`` (Object):  [Read-Write] Object value of parameter
    - ``param_name`` (Name):  [Read-Write] Name of the parameter
    - ``param_type`` (AudioParameterType):  [Read-Write]
    - ``string_param`` (str):  [Read-Write] String value of parameter
    """
    def __init__(self, param_name: Name = "None", float_param: float = 0.000000, bool_param: bool = False, int_param: int = 0, object_param: Object = None, string_param: str = "", array_float_param: Array[float] = [], array_bool_param: Array[bool] = [], array_int_param: Array[int] = [], array_object_param: Array[Object] = [], array_string_param: Array[str] = [], param_type: AudioParameterType = AudioParameterType.NONE) -> None:
        ...
    @property
    def param_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of the parameter
        """
        ...
    @param_name.setter
    def param_name(self, value: Name) -> None:
        ...
    @property
    def float_param(self) -> float:
        r"""
        (float):  [Read-Write] Float value of parameter
        """
        ...
    @float_param.setter
    def float_param(self, value: float) -> None:
        ...
    @property
    def bool_param(self) -> bool:
        r"""
        (bool):  [Read-Write] Boolean value of parameter
        """
        ...
    @bool_param.setter
    def bool_param(self, value: bool) -> None:
        ...
    @property
    def int_param(self) -> int:
        r"""
        (int32):  [Read-Write] Integer value of parameter. If set to 'Default Construct', value is number of array items to construct.
        """
        ...
    @int_param.setter
    def int_param(self, value: int) -> None:
        ...
    @property
    def object_param(self) -> Object:
        r"""
        (Object):  [Read-Write] Object value of parameter
        """
        ...
    @object_param.setter
    def object_param(self, value: Object) -> None:
        ...
    @property
    def sound_wave_param(self) -> Object:
        r"""
        deprecated: 'sound_wave_param' was renamed to 'object_param'.
        """
        ...
    @sound_wave_param.setter
    def sound_wave_param(self, value: Object) -> None:
        ...
    @property
    def string_param(self) -> str:
        r"""
        (str):  [Read-Write] String value of parameter
        """
        ...
    @string_param.setter
    def string_param(self, value: str) -> None:
        ...
    @property
    def array_float_param(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Write] Array Float value of parameter
        """
        ...
    @array_float_param.setter
    def array_float_param(self, value: Array[float]) -> None:
        ...
    @property
    def array_bool_param(self) -> Array[bool]:
        r"""
        (Array[bool]):  [Read-Write] Boolean value of parameter
        """
        ...
    @array_bool_param.setter
    def array_bool_param(self, value: Array[bool]) -> None:
        ...
    @property
    def array_int_param(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write] Integer value of parameter
        """
        ...
    @array_int_param.setter
    def array_int_param(self, value: Array[int]) -> None:
        ...
    @property
    def array_object_param(self) -> Array[Object]:
        r"""
        (Array[Object]):  [Read-Write] Object value of parameter
        """
        ...
    @array_object_param.setter
    def array_object_param(self, value: Array[Object]) -> None:
        ...
    @property
    def array_string_param(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] String value of parameter
        """
        ...
    @array_string_param.setter
    def array_string_param(self, value: Array[str]) -> None:
        ...
    @property
    def param_type(self) -> AudioParameterType:
        r"""
        (AudioParameterType):  [Read-Write]
        """
        ...
    @param_type.setter
    def param_type(self, value: AudioParameterType) -> None:
        ...

class AudioComponentParam(AudioParameter):
    r"""
    deprecated: 'AudioComponentParam' was renamed to 'AudioParameter'.
    """
    def __init__(self, param_name: Name = "None", float_param: float = 0.000000, bool_param: bool = False, int_param: int = 0, object_param: Object = None, string_param: str = "", array_float_param: Array[float] = [], array_bool_param: Array[bool] = [], array_int_param: Array[int] = [], array_object_param: Array[Object] = [], array_string_param: Array[str] = [], param_type: AudioParameterType = AudioParameterType.NONE) -> None:
        ...

class ToolDynamicUIAction(StructBase):
    r"""
    Tool Dynamic UIAction
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuDelegates.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_execute_action`` (ToolMenuDynamicCanExecuteAction):  [Read-Write]
    - ``execute_action`` (ToolMenuDynamicExecuteAction):  [Read-Write]
    - ``get_action_check_state`` (ToolMenuDynamicGetActionCheckState):  [Read-Write]
    - ``is_action_visible_delegate`` (ToolMenuDynamicIsActionButtonVisible):  [Read-Write]
    """
    def __init__(self, execute_action: ToolMenuDynamicExecuteAction = ToolMenuDynamicExecuteAction(), can_execute_action: ToolMenuDynamicCanExecuteAction = ToolMenuDynamicCanExecuteAction(), get_action_check_state: ToolMenuDynamicGetActionCheckState = ToolMenuDynamicGetActionCheckState(), is_action_visible_delegate: ToolMenuDynamicIsActionButtonVisible = ToolMenuDynamicIsActionButtonVisible()) -> None:
        ...
    @property
    def execute_action(self) -> ToolMenuDynamicExecuteAction:
        r"""
        (ToolMenuDynamicExecuteAction):  [Read-Write]
        """
        ...
    @execute_action.setter
    def execute_action(self, value: ToolMenuDynamicExecuteAction) -> None:
        ...
    @property
    def can_execute_action(self) -> ToolMenuDynamicCanExecuteAction:
        r"""
        (ToolMenuDynamicCanExecuteAction):  [Read-Write]
        """
        ...
    @can_execute_action.setter
    def can_execute_action(self, value: ToolMenuDynamicCanExecuteAction) -> None:
        ...
    @property
    def get_action_check_state(self) -> ToolMenuDynamicGetActionCheckState:
        r"""
        (ToolMenuDynamicGetActionCheckState):  [Read-Write]
        """
        ...
    @get_action_check_state.setter
    def get_action_check_state(self, value: ToolMenuDynamicGetActionCheckState) -> None:
        ...
    @property
    def is_action_visible_delegate(self) -> ToolMenuDynamicIsActionButtonVisible:
        r"""
        (ToolMenuDynamicIsActionButtonVisible):  [Read-Write]
        """
        ...
    @is_action_visible_delegate.setter
    def is_action_visible_delegate(self, value: ToolMenuDynamicIsActionButtonVisible) -> None:
        ...

class ToolMenuStringCommand(StructBase):
    r"""
    Tool Menu String Command
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuMisc.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``custom_type`` (Name):  [Read-Write] Which command handler to use when type is custom
    - ``string`` (str):  [Read-Write] String to pass to command handler
    - ``type`` (ToolMenuStringCommandType):  [Read-Write] Which command handler to use
    """
    def __init__(self, type: ToolMenuStringCommandType = ToolMenuStringCommandType.COMMAND, custom_type: Name = "None", string: str = "") -> None:
        ...
    @property
    def type(self) -> ToolMenuStringCommandType:
        r"""
        (ToolMenuStringCommandType):  [Read-Write] Which command handler to use
        """
        ...
    @type.setter
    def type(self, value: ToolMenuStringCommandType) -> None:
        ...
    @property
    def custom_type(self) -> Name:
        r"""
        (Name):  [Read-Write] Which command handler to use when type is custom
        """
        ...
    @custom_type.setter
    def custom_type(self, value: Name) -> None:
        ...
    @property
    def string(self) -> str:
        r"""
        (str):  [Read-Write] String to pass to command handler
        """
        ...
    @string.setter
    def string(self, value: str) -> None:
        ...

class ToolMenuInsert(StructBase):
    r"""
    Tool Menu Insert
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuMisc.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] Where to insert
    - ``position`` (ToolMenuInsertType):  [Read-Write] How to insert
    """
    def __init__(self, name: Name = "None", position: ToolMenuInsertType = ToolMenuInsertType.DEFAULT) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] Where to insert
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def position(self) -> ToolMenuInsertType:
        r"""
        (ToolMenuInsertType):  [Read-Write] How to insert
        """
        ...
    @position.setter
    def position(self, value: ToolMenuInsertType) -> None:
        ...

class ToolMenuOwner(StructBase):
    r"""
    Represents the owner of a menu. Can be used when registering menus
    to later unregistering all menus created by a specified owner.
    
    See UToolMenus::UnregisterOwnerByName and FToolMenuOwnerScoped which relate to this.
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuOwner.h
    
    """
    def __init__(self, name: Name = "None") -> None:
        ...

class ToolMenuEntry(StructBase):
    r"""
    Represents entries in menus such as buttons, checkboxes, and sub-menus.
    
    Many entries are created for you via the methods of FToolMenuSection, such as FToolMenuSection::AddMenuEntry.
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuEntry.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``insert_position`` (ToolMenuInsert):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``owner`` (ToolMenuOwner):  [Read-Write]
    - ``script_object`` (ToolMenuEntryScript):  [Read-Write]
    - ``should_close_window_after_menu_selection`` (bool):  [Read-Write]
    - ``style_name_override`` (Name):  [Read-Write]
    - ``tutorial_highlight_name`` (Name):  [Read-Write]
    - ``type`` (MultiBlockType):  [Read-Write]
    - ``user_interface_action_type`` (UserInterfaceActionType):  [Read-Write]
    """
    def __init__(self, name: Name = "None", owner: ToolMenuOwner = ["None"], type: MultiBlockType = MultiBlockType.NONE, user_interface_action_type: UserInterfaceActionType = UserInterfaceActionType.NONE, tutorial_highlight_name: Name = "None", insert_position: ToolMenuInsert = ["None", ToolMenuInsertType.DEFAULT], should_close_window_after_menu_selection: bool = False, script_object: ToolMenuEntryScript = None, style_name_override: Name = "None") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def owner(self) -> ToolMenuOwner:
        r"""
        (ToolMenuOwner):  [Read-Write]
        """
        ...
    @owner.setter
    def owner(self, value: ToolMenuOwner) -> None:
        ...
    @property
    def type(self) -> MultiBlockType:
        r"""
        (MultiBlockType):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: MultiBlockType) -> None:
        ...
    @property
    def user_interface_action_type(self) -> UserInterfaceActionType:
        r"""
        (UserInterfaceActionType):  [Read-Write]
        """
        ...
    @user_interface_action_type.setter
    def user_interface_action_type(self, value: UserInterfaceActionType) -> None:
        ...
    @property
    def tutorial_highlight_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @tutorial_highlight_name.setter
    def tutorial_highlight_name(self, value: Name) -> None:
        ...
    @property
    def insert_position(self) -> ToolMenuInsert:
        r"""
        (ToolMenuInsert):  [Read-Write]
        """
        ...
    @insert_position.setter
    def insert_position(self, value: ToolMenuInsert) -> None:
        ...
    @property
    def should_close_window_after_menu_selection(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @should_close_window_after_menu_selection.setter
    def should_close_window_after_menu_selection(self, value: bool) -> None:
        ...
    @property
    def script_object(self) -> ToolMenuEntryScript:
        r"""
        (ToolMenuEntryScript):  [Read-Write]
        """
        ...
    @script_object.setter
    def script_object(self, value: ToolMenuEntryScript) -> None:
        ...
    @property
    def style_name_override(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @style_name_override.setter
    def style_name_override(self, value: Name) -> None:
        ...
    def set_tool_tip(self, tool_tip: Text) -> None:
        r"""
        x.set_tool_tip(tool_tip) -> None
        Set Tool Tip
        
        Args:
            tool_tip (Text):
        """
        ...
    def set_string_command(self, type: ToolMenuStringCommandType, custom_type: Name, string: str) -> None:
        r"""
        x.set_string_command(type, custom_type, string) -> None
        Set String Command
        
        Args:
            type (ToolMenuStringCommandType): 
            custom_type (Name): 
            string (str):
        """
        ...
    def set_label(self, label: Text) -> None:
        r"""
        x.set_label(label) -> None
        Set Label
        
        Args:
            label (Text):
        """
        ...
    def set_icon(self, style_set_name: Name, style_name: Name = "None", small_style_name: Name = "None") -> None:
        r"""
        x.set_icon(style_set_name, style_name="None", small_style_name="None") -> None
        Set Icon
        
        Args:
            style_set_name (Name): 
            style_name (Name): 
            small_style_name (Name):
        """
        ...
    def get_tool_tip(self) -> Text:
        r"""
        x.get_tool_tip() -> Text
        Get Tool Tip
        
        Returns:
            Text:
        """
        ...
    def get_label(self) -> Text:
        r"""
        x.get_label() -> Text
        Get Label
        
        Returns:
            Text:
        """
        ...

class ScriptSlateIcon(StructBase):
    r"""
    Script Slate Icon
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuEntryScript.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``small_style_name`` (Name):  [Read-Write]
    - ``style_name`` (Name):  [Read-Write]
    - ``style_set_name`` (Name):  [Read-Write]
    """
    def __init__(self, style_set_name: Name = "None", style_name: Name = "None", small_style_name: Name = "None") -> None:
        ...
    @property
    def style_set_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @style_set_name.setter
    def style_set_name(self, value: Name) -> None:
        ...
    @property
    def style_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @style_name.setter
    def style_name(self, value: Name) -> None:
        ...
    @property
    def small_style_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @small_style_name.setter
    def small_style_name(self, value: Name) -> None:
        ...

class ToolMenuEntryScriptDataAdvanced(StructBase):
    r"""
    Tool Menu Entry Script Data Advanced
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuEntryScript.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``entry_type`` (MultiBlockType):  [Read-Write]
    - ``is_sub_menu`` (bool):  [Read-Write]
    - ``open_sub_menu_on_click`` (bool):  [Read-Write]
    - ``should_close_window_after_menu_selection`` (bool):  [Read-Write]
    - ``simple_combo_box`` (bool):  [Read-Write]
    - ``style_name_override`` (Name):  [Read-Write]
    - ``tutorial_highlight`` (Name):  [Read-Write]
    - ``user_interface_action_type`` (UserInterfaceActionType):  [Read-Write]
    """
    def __init__(self, tutorial_highlight: Name = "None", entry_type: MultiBlockType = MultiBlockType.NONE, user_interface_action_type: UserInterfaceActionType = UserInterfaceActionType.NONE, style_name_override: Name = "None", is_sub_menu: bool = False, open_sub_menu_on_click: bool = False, should_close_window_after_menu_selection: bool = False, simple_combo_box: bool = False) -> None:
        ...
    @property
    def tutorial_highlight(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @tutorial_highlight.setter
    def tutorial_highlight(self, value: Name) -> None:
        ...
    @property
    def entry_type(self) -> MultiBlockType:
        r"""
        (MultiBlockType):  [Read-Write]
        """
        ...
    @entry_type.setter
    def entry_type(self, value: MultiBlockType) -> None:
        ...
    @property
    def user_interface_action_type(self) -> UserInterfaceActionType:
        r"""
        (UserInterfaceActionType):  [Read-Write]
        """
        ...
    @user_interface_action_type.setter
    def user_interface_action_type(self, value: UserInterfaceActionType) -> None:
        ...
    @property
    def style_name_override(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @style_name_override.setter
    def style_name_override(self, value: Name) -> None:
        ...
    @property
    def is_sub_menu(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_sub_menu.setter
    def is_sub_menu(self, value: bool) -> None:
        ...
    @property
    def open_sub_menu_on_click(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @open_sub_menu_on_click.setter
    def open_sub_menu_on_click(self, value: bool) -> None:
        ...
    @property
    def should_close_window_after_menu_selection(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @should_close_window_after_menu_selection.setter
    def should_close_window_after_menu_selection(self, value: bool) -> None:
        ...
    @property
    def simple_combo_box(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @simple_combo_box.setter
    def simple_combo_box(self, value: bool) -> None:
        ...

class ToolMenuEntryScriptData(StructBase):
    r"""
    Tool Menu Entry Script Data
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuEntryScript.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``advanced`` (ToolMenuEntryScriptDataAdvanced):  [Read-Write]
    - ``icon`` (ScriptSlateIcon):  [Read-Write]
    - ``insert_position`` (ToolMenuInsert):  [Read-Write]
    - ``label`` (Text):  [Read-Write]
    - ``menu`` (Name):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``owner_name`` (Name):  [Read-Write] Optional identifier used for unregistering a group of menu items
    - ``section`` (Name):  [Read-Write]
    - ``tool_tip`` (Text):  [Read-Write]
    """
    def __init__(self, menu: Name = "None", section: Name = "None", name: Name = "None", label: Text = "", tool_tip: Text = "", icon: ScriptSlateIcon = ["None", "None", "None"], owner_name: Name = "None", insert_position: ToolMenuInsert = ["None", ToolMenuInsertType.DEFAULT], advanced: ToolMenuEntryScriptDataAdvanced = ["None", MultiBlockType.MENU_ENTRY, UserInterfaceActionType.BUTTON, "None", False, False, True, False]) -> None:
        ...
    @property
    def menu(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @menu.setter
    def menu(self, value: Name) -> None:
        ...
    @property
    def section(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @section.setter
    def section(self, value: Name) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def label(self) -> Text:
        r"""
        (Text):  [Read-Write]
        """
        ...
    @label.setter
    def label(self, value: Text) -> None:
        ...
    @property
    def tool_tip(self) -> Text:
        r"""
        (Text):  [Read-Write]
        """
        ...
    @tool_tip.setter
    def tool_tip(self, value: Text) -> None:
        ...
    @property
    def icon(self) -> ScriptSlateIcon:
        r"""
        (ScriptSlateIcon):  [Read-Write]
        """
        ...
    @icon.setter
    def icon(self, value: ScriptSlateIcon) -> None:
        ...
    @property
    def owner_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Optional identifier used for unregistering a group of menu items
        """
        ...
    @owner_name.setter
    def owner_name(self, value: Name) -> None:
        ...
    @property
    def insert_position(self) -> ToolMenuInsert:
        r"""
        (ToolMenuInsert):  [Read-Write]
        """
        ...
    @insert_position.setter
    def insert_position(self, value: ToolMenuInsert) -> None:
        ...
    @property
    def advanced(self) -> ToolMenuEntryScriptDataAdvanced:
        r"""
        (ToolMenuEntryScriptDataAdvanced):  [Read-Write]
        """
        ...
    @advanced.setter
    def advanced(self, value: ToolMenuEntryScriptDataAdvanced) -> None:
        ...

class ToolMenuSection(StructBase):
    r"""
    Tool Menu Section
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blocks`` (Array[ToolMenuEntry]):  [Read-Write]
    - ``context`` (ToolMenuContext):  [Read-Write]
    - ``insert_position`` (ToolMenuInsert):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``owner`` (ToolMenuOwner):  [Read-Write]
    - ``tool_menu_section_dynamic`` (ToolMenuSectionDynamic):  [Read-Write]
    """
    def __init__(self, name: Name = "None", owner: ToolMenuOwner = ["None"], blocks: Array[ToolMenuEntry] = [], insert_position: ToolMenuInsert = ["None", ToolMenuInsertType.DEFAULT], context: ToolMenuContext = [], tool_menu_section_dynamic: ToolMenuSectionDynamic = None) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def owner(self) -> ToolMenuOwner:
        r"""
        (ToolMenuOwner):  [Read-Write]
        """
        ...
    @owner.setter
    def owner(self, value: ToolMenuOwner) -> None:
        ...
    @property
    def blocks(self) -> Array[ToolMenuEntry]:
        r"""
        (Array[ToolMenuEntry]):  [Read-Write]
        """
        ...
    @blocks.setter
    def blocks(self, value: Array[ToolMenuEntry]) -> None:
        ...
    @property
    def insert_position(self) -> ToolMenuInsert:
        r"""
        (ToolMenuInsert):  [Read-Write]
        """
        ...
    @insert_position.setter
    def insert_position(self, value: ToolMenuInsert) -> None:
        ...
    @property
    def context(self) -> ToolMenuContext:
        r"""
        (ToolMenuContext):  [Read-Write]
        """
        ...
    @context.setter
    def context(self, value: ToolMenuContext) -> None:
        ...
    @property
    def tool_menu_section_dynamic(self) -> ToolMenuSectionDynamic:
        r"""
        (ToolMenuSectionDynamic):  [Read-Write]
        """
        ...
    @tool_menu_section_dynamic.setter
    def tool_menu_section_dynamic(self, value: ToolMenuSectionDynamic) -> None:
        ...
    def set_label(self, label: Text) -> None:
        r"""
        x.set_label(label) -> None
        Set Label
        
        Args:
            label (Text):
        """
        ...
    def get_label(self) -> Text:
        r"""
        x.get_label() -> Text
        Get Label
        
        Returns:
            Text:
        """
        ...
    def add_entry_object(self, object: ToolMenuEntryScript) -> None:
        r"""
        x.add_entry_object(object) -> None
        Add Entry Object
        
        Args:
            object (ToolMenuEntryScript):
        """
        ...
    def add_entry(self, args: ToolMenuEntry) -> None:
        r"""
        x.add_entry(args) -> None
        Add Entry
        
        Args:
            args (ToolMenuEntry):
        """
        ...

class InterchangePipelinePropertyStatePerContext(StructBase):
    r"""
    Interchange Pipeline Property State Per Context
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangePipelineBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``visible`` (bool):  [Read-Write] If true, the property is visible.
    """
    def __init__(self, visible: bool = False) -> None:
        ...
    @property
    def visible(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the property is visible.
        """
        ...
    @visible.setter
    def visible(self, value: bool) -> None:
        ...

class InterchangePipelinePropertyStates(StructBase):
    r"""
    Interchange Pipeline Property States
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangePipelineBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``basic_layout_states`` (InterchangePipelinePropertyStatePerContext):  [Read-Write] The property states for the import context.
    - ``import_states`` (InterchangePipelinePropertyStatePerContext):  [Read-Write] The property states for the import context
    - ``locked`` (bool):  [Read-Write] If true, the property is locked.
    - ``reimport_states`` (InterchangePipelinePropertyStatePerContext):  [Read-Write] The property states for the reimport context.
    """
    def __init__(self, locked: bool = False, basic_layout_states: InterchangePipelinePropertyStatePerContext = [True], import_states: InterchangePipelinePropertyStatePerContext = [True], reimport_states: InterchangePipelinePropertyStatePerContext = [True]) -> None:
        ...
    @property
    def locked(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the property is locked.
        """
        ...
    @locked.setter
    def locked(self, value: bool) -> None:
        ...
    @property
    def basic_layout_states(self) -> InterchangePipelinePropertyStatePerContext:
        r"""
        (InterchangePipelinePropertyStatePerContext):  [Read-Write] The property states for the import context.
        """
        ...
    @basic_layout_states.setter
    def basic_layout_states(self, value: InterchangePipelinePropertyStatePerContext) -> None:
        ...
    @property
    def import_states(self) -> InterchangePipelinePropertyStatePerContext:
        r"""
        (InterchangePipelinePropertyStatePerContext):  [Read-Write] The property states for the import context
        """
        ...
    @import_states.setter
    def import_states(self, value: InterchangePipelinePropertyStatePerContext) -> None:
        ...
    @property
    def reimport_states(self) -> InterchangePipelinePropertyStatePerContext:
        r"""
        (InterchangePipelinePropertyStatePerContext):  [Read-Write] The property states for the reimport context.
        """
        ...
    @reimport_states.setter
    def reimport_states(self, value: InterchangePipelinePropertyStatePerContext) -> None:
        ...

class InterchangeUserDefinedAttributeInfo(StructBase):
    r"""
    Interchange User Defined Attribute Info
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeUserDefinedAttribute.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (str):  [Read-Write]
    """
    def __init__(self, name: str = "") -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: str) -> None:
        ...

class ToolkitWidgetStyle(SlateWidgetStyle):
    r"""
    FToolkitWidgetStyle is the FSlateWidgetStyle that defines the styling of a ToolkitWidget
    
    **C++ Source:**
    
    - **Module**: WidgetRegistration
    - **File**: FToolkitWidgetStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active_tool_title_border_padding`` (Margin):  [Read-Write]
    - ``title_background_brush`` (SlateBrush):  [Read-Write]
    - ``title_font`` (SlateFontInfo):  [Read-Write]
    - ``title_foreground_color`` (SlateColor):  [Read-Write]
    - ``title_padding`` (Margin):  [Read-Write]
    - ``tool_context_text_block_padding`` (Margin):  [Read-Write]
    - ``tool_details_background_brush`` (SlateBrush):  [Read-Write]
    """
    def __init__(self, title_background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], tool_details_background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], title_foreground_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], title_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], active_tool_title_border_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], tool_context_text_block_padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], title_font: SlateFontInfo = [None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000]) -> None:
        ...
    @property
    def title_background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @title_background_brush.setter
    def title_background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def tool_details_background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @tool_details_background_brush.setter
    def tool_details_background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def title_foreground_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @title_foreground_color.setter
    def title_foreground_color(self, value: SlateColor) -> None:
        ...
    @property
    def title_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @title_padding.setter
    def title_padding(self, value: Margin) -> None:
        ...
    @property
    def active_tool_title_border_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @active_tool_title_border_padding.setter
    def active_tool_title_border_padding(self, value: Margin) -> None:
        ...
    @property
    def tool_context_text_block_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @tool_context_text_block_padding.setter
    def tool_context_text_block_padding(self, value: Margin) -> None:
        ...
    @property
    def title_font(self) -> SlateFontInfo:
        r"""
        (SlateFontInfo):  [Read-Write]
        """
        ...
    @title_font.setter
    def title_font(self, value: SlateFontInfo) -> None:
        ...

class PropertyPathTestBaseStruct(StructBase):
    r"""
    Property Path Test Base Struct
    
    **C++ Source:**
    
    - **Module**: PropertyPath
    - **File**: PropertyPathHelpersTest.h
    
    """
    def __init__(self) -> None:
        ...

class PropertyPathTestInnerStruct(PropertyPathTestBaseStruct):
    r"""
    Property Path Test Inner Struct
    
    **C++ Source:**
    
    - **Module**: PropertyPath
    - **File**: PropertyPathHelpersTest.h
    
    """
    def __init__(self) -> None:
        ...

class PropertyPathTestStruct(PropertyPathTestBaseStruct):
    r"""
    Property Path Test Struct
    
    **C++ Source:**
    
    - **Module**: PropertyPath
    - **File**: PropertyPathHelpersTest.h
    
    """
    def __init__(self) -> None:
        ...

class FilterOptionPerAxis(StructBase):
    r"""
    Filter Option Per Axis
    
    This is used to filter per axis for constraint options
    
    **C++ Source:**
    
    - **Module**: AnimationCore
    - **File**: Constraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (bool):  [Read-Write]
    - ``y`` (bool):  [Read-Write]
    - ``z`` (bool):  [Read-Write]
    """
    def __init__(self, x: bool = False, y: bool = False, z: bool = False) -> None:
        ...
    @property
    def x(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: bool) -> None:
        ...
    @property
    def y(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: bool) -> None:
        ...
    @property
    def z(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: bool) -> None:
        ...

class TransformFilter(StructBase):
    r"""
    A filter for a whole transform
    
    **C++ Source:**
    
    - **Module**: AnimationCore
    - **File**: Constraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``rotation_filter`` (FilterOptionPerAxis):  [Read-Write]
    - ``scale_filter`` (FilterOptionPerAxis):  [Read-Write]
    - ``translation_filter`` (FilterOptionPerAxis):  [Read-Write]
    """
    def __init__(self, translation_filter: FilterOptionPerAxis = [True, True, True], rotation_filter: FilterOptionPerAxis = [True, True, True], scale_filter: FilterOptionPerAxis = [True, True, True]) -> None:
        ...
    @property
    def translation_filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @translation_filter.setter
    def translation_filter(self, value: FilterOptionPerAxis) -> None:
        ...
    @property
    def rotation_filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @rotation_filter.setter
    def rotation_filter(self, value: FilterOptionPerAxis) -> None:
        ...
    @property
    def scale_filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @scale_filter.setter
    def scale_filter(self, value: FilterOptionPerAxis) -> None:
        ...

class ConstraintDescription(StructBase):
    r"""
    A description of how to apply a simple transform constraint
    
    **C++ Source:**
    
    - **Module**: AnimationCore
    - **File**: Constraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parent`` (bool):  [Read-Write] this does composed transform - where as individual will accumulate per component
    - ``rotation`` (bool):  [Read-Write]
    - ``rotation_axes`` (FilterOptionPerAxis):  [Read-Write]
    - ``scale`` (bool):  [Read-Write]
    - ``scale_axes`` (FilterOptionPerAxis):  [Read-Write]
    - ``translation`` (bool):  [Read-Write]
    - ``translation_axes`` (FilterOptionPerAxis):  [Read-Write]
    """
    def __init__(self, translation: bool = False, rotation: bool = False, scale: bool = False, parent: bool = False, translation_axes: FilterOptionPerAxis = [True, True, True], rotation_axes: FilterOptionPerAxis = [True, True, True], scale_axes: FilterOptionPerAxis = [True, True, True]) -> None:
        ...
    @property
    def translation(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @translation.setter
    def translation(self, value: bool) -> None:
        ...
    @property
    def rotation(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @rotation.setter
    def rotation(self, value: bool) -> None:
        ...
    @property
    def scale(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: bool) -> None:
        ...
    @property
    def parent(self) -> bool:
        r"""
        (bool):  [Read-Write] this does composed transform - where as individual will accumulate per component
        """
        ...
    @parent.setter
    def parent(self, value: bool) -> None:
        ...
    @property
    def translation_axes(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @translation_axes.setter
    def translation_axes(self, value: FilterOptionPerAxis) -> None:
        ...
    @property
    def rotation_axes(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @rotation_axes.setter
    def rotation_axes(self, value: FilterOptionPerAxis) -> None:
        ...
    @property
    def scale_axes(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @scale_axes.setter
    def scale_axes(self, value: FilterOptionPerAxis) -> None:
        ...

class TransformConstraint(StructBase):
    r"""
    Transform Constraint
    
    **C++ Source:**
    
    - **Module**: AnimationCore
    - **File**: Constraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``maintain_offset`` (bool):  [Read-Write] When the constraint is first applied, maintain the offset from the target node
    - ``operator`` (ConstraintDescription):  [Read-Write]
      note: thought of separating this out per each but we'll have an issue with applying transform in what order but something to think about if that seems better
    - ``source_node`` (Name):  [Read-Write]
    - ``target_node`` (Name):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, operator: ConstraintDescription = [True, True, False, False, [True, True, True], [True, True, True], [True, True, True]], source_node: Name = "None", target_node: Name = "None", weight: float = 0.000000, maintain_offset: bool = False) -> None:
        ...
    @property
    def operator(self) -> ConstraintDescription:
        r"""
        (ConstraintDescription):  [Read-Write]
        note: thought of separating this out per each but we'll have an issue with applying transform in what order but something to think about if that seems better
        """
        ...
    @operator.setter
    def operator(self, value: ConstraintDescription) -> None:
        ...
    @property
    def source_node(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @source_node.setter
    def source_node(self, value: Name) -> None:
        ...
    @property
    def target_node(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @target_node.setter
    def target_node(self, value: Name) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def maintain_offset(self) -> bool:
        r"""
        (bool):  [Read-Write] When the constraint is first applied, maintain the offset from the target node
        """
        ...
    @maintain_offset.setter
    def maintain_offset(self, value: bool) -> None:
        ...

class EulerTransform(StructBase):
    r"""
    Euler Transform
    
    **C++ Source:**
    
    - **Module**: AnimationCore
    - **File**: EulerTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``location`` (Vector):  [Read-Write] The translation of this transform
    - ``rotation`` (Rotator):  [Read-Write] The rotation of this transform
    - ``scale`` (Vector):  [Read-Write] The scale of this transform
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], scale: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The translation of this transform
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] The rotation of this transform
        """
        ...
    @rotation.setter
    def rotation(self, value: Rotator) -> None:
        ...
    @property
    def scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The scale of this transform
        """
        ...
    @scale.setter
    def scale(self, value: Vector) -> None:
        ...

class TransformNoScale(StructBase):
    r"""
    Transform No Scale
    
    **C++ Source:**
    
    - **Module**: AnimationCore
    - **File**: TransformNoScale.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``location`` (Vector):  [Read-Write] The translation of this transform
    - ``rotation`` (Quat):  [Read-Write] The rotation of this transform
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], rotation: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The translation of this transform
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Write] The rotation of this transform
        """
        ...
    @rotation.setter
    def rotation(self, value: Quat) -> None:
        ...

class WidgetCarouselNavigationBarStyle(SlateWidgetStyle):
    r"""
    Widget Carousel Navigation Bar Style
    
    **C++ Source:**
    
    - **Module**: WidgetCarousel
    - **File**: WidgetCarouselStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``center_button_style`` (ButtonStyle):  [Read-Write]
    - ``highlight_brush`` (SlateBrush):  [Read-Write]
    - ``left_button_style`` (ButtonStyle):  [Read-Write]
    - ``right_button_style`` (ButtonStyle):  [Read-Write]
    """
    def __init__(self, highlight_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], left_button_style: ButtonStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], center_button_style: ButtonStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]], right_button_style: ButtonStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.NO_DRAW_TYPE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_FOREGROUND], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [None], [None]]) -> None:
        ...
    @property
    def highlight_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @highlight_brush.setter
    def highlight_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def left_button_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write]
        """
        ...
    @left_button_style.setter
    def left_button_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def center_button_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write]
        """
        ...
    @center_button_style.setter
    def center_button_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def right_button_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write]
        """
        ...
    @right_button_style.setter
    def right_button_style(self, value: ButtonStyle) -> None:
        ...

class LiveLinkSourceHandle(StructBase):
    r"""
    A Blueprint handle to a specific LiveLink Source
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: ILiveLinkSource.h
    
    """
    def __init__(self) -> None:
        ...

class LiveLinkBaseStaticData(StructBase):
    r"""
    Base static data structure for a subject
    Use to store information that is common to every frame
    note: subclass can't contains reference to UObject
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``property_names`` (Array[Name]):  [Read-Write] Names for each curve values that will be sent for each frame
    """
    def __init__(self, property_names: Array[Name] = []) -> None:
        ...
    @property
    def property_names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Names for each curve values that will be sent for each frame
        """
        ...
    @property_names.setter
    def property_names(self, value: Array[Name]) -> None:
        ...

class LiveLinkSkeletonStaticData(LiveLinkBaseStaticData):
    r"""
    Static data for Animation purposes. Contains data about bones that shouldn't change every frame.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkAnimationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_names`` (Array[Name]):  [Read-Write] Names of each bone in the skeleton
    - ``bone_parents`` (Array[int32]):  [Read-Write] Parent Indices: For each bone it specifies the index of its parent
    - ``property_names`` (Array[Name]):  [Read-Write] Names for each curve values that will be sent for each frame
    """
    def __init__(self, property_names: Array[Name] = [], bone_names: Array[Name] = [], bone_parents: Array[int] = []) -> None:
        ...
    @property
    def bone_names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Names of each bone in the skeleton
        """
        ...
    @bone_names.setter
    def bone_names(self, value: Array[Name]) -> None:
        ...
    @property
    def bone_parents(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write] Parent Indices: For each bone it specifies the index of its parent
        """
        ...
    @bone_parents.setter
    def bone_parents(self, value: Array[int]) -> None:
        ...

class LiveLinkBaseFrameData(StructBase):
    r"""
    Base data structure for each frame coming in for a subject
    note: subclass can't contains reference to UObject
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``meta_data`` (LiveLinkMetaData):  [Read-Write] Frame's metadata.
    - ``property_values`` (Array[float]):  [Read-Write] Values of the properties defined in the static structure. Use FLiveLinkBaseStaticData.FindPropertyValue to evaluate.
    - ``world_time`` (LiveLinkWorldTime):  [Read-Only] Time in seconds the frame was created.
    """
    def __init__(self, meta_data: LiveLinkMetaData = [{}, [[0], [24, 1], 0.000000]], property_values: Array[float] = []) -> None:
        ...
    @property
    def meta_data(self) -> LiveLinkMetaData:
        r"""
        (LiveLinkMetaData):  [Read-Write] Frame's metadata.
        """
        ...
    @meta_data.setter
    def meta_data(self, value: LiveLinkMetaData) -> None:
        ...
    @property
    def property_values(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Write] Values of the properties defined in the static structure. Use FLiveLinkBaseStaticData.FindPropertyValue to evaluate.
        """
        ...
    @property_values.setter
    def property_values(self, value: Array[float]) -> None:
        ...

class LiveLinkMetaData(StructBase):
    r"""
    Live Link Meta Data
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``scene_time`` (QualifiedTime):  [Read-Write]
    - ``string_meta_data`` (Map[Name, str]):  [Read-Write]
    """
    def __init__(self, string_meta_data: Map[Name, str] = {}, scene_time: QualifiedTime = [[0], [0, 0], 0.000000]) -> None:
        ...
    @property
    def string_meta_data(self) -> Map[Name, str]:
        r"""
        (Map[Name, str]):  [Read-Write]
        """
        ...
    @string_meta_data.setter
    def string_meta_data(self, value: Map[Name, str]) -> None:
        ...
    @property
    def scene_time(self) -> QualifiedTime:
        r"""
        (QualifiedTime):  [Read-Write]
        """
        ...
    @scene_time.setter
    def scene_time(self, value: QualifiedTime) -> None:
        ...

class LiveLinkAnimationFrameData(LiveLinkBaseFrameData):
    r"""
    Dynamic data for Animation purposes.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkAnimationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``meta_data`` (LiveLinkMetaData):  [Read-Write] Frame's metadata.
    - ``property_values`` (Array[float]):  [Read-Write] Values of the properties defined in the static structure. Use FLiveLinkBaseStaticData.FindPropertyValue to evaluate.
    - ``transforms`` (Array[Transform]):  [Read-Write] Array of transforms for each bone of the skeleton
    - ``world_time`` (LiveLinkWorldTime):  [Read-Only] Time in seconds the frame was created.
    """
    def __init__(self, meta_data: LiveLinkMetaData = [{}, [[0], [24, 1], 0.000000]], property_values: Array[float] = [], transforms: Array[Transform] = []) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write] Array of transforms for each bone of the skeleton
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...

class LiveLinkBaseBlueprintData(StructBase):
    r"""
    Base blueprint data structure for a subject frame
    Can be used to do blueprint facilitator per role
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTypes.h
    
    """
    def __init__(self) -> None:
        ...

class LiveLinkBasicBlueprintData(LiveLinkBaseBlueprintData):
    r"""
    Facility structure to handle base data in blueprint
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkBasicTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_data`` (LiveLinkBaseFrameData):  [Read-Write] Dynamic data that can change every frame
    - ``static_data`` (LiveLinkBaseStaticData):  [Read-Write] Static data that should not change every frame
    """
    def __init__(self, static_data: LiveLinkBaseStaticData = [[]], frame_data: LiveLinkBaseFrameData = [[{}, [[0], [24, 1], 0.000000]], []]) -> None:
        ...
    @property
    def static_data(self) -> LiveLinkBaseStaticData:
        r"""
        (LiveLinkBaseStaticData):  [Read-Write] Static data that should not change every frame
        """
        ...
    @static_data.setter
    def static_data(self, value: LiveLinkBaseStaticData) -> None:
        ...
    @property
    def frame_data(self) -> LiveLinkBaseFrameData:
        r"""
        (LiveLinkBaseFrameData):  [Read-Write] Dynamic data that can change every frame
        """
        ...
    @frame_data.setter
    def frame_data(self, value: LiveLinkBaseFrameData) -> None:
        ...

class LiveLinkTransformStaticData(LiveLinkBaseStaticData):
    r"""
    Static data for Transform data.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTransformTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_location_supported`` (bool):  [Read-Write] Whether location in frame data should be used
    - ``is_rotation_supported`` (bool):  [Read-Write] Whether rotation in frame data should be used
    - ``is_scale_supported`` (bool):  [Read-Write] Whether scale in frame data should be used
    - ``property_names`` (Array[Name]):  [Read-Write] Names for each curve values that will be sent for each frame
    """
    def __init__(self, property_names: Array[Name] = [], is_location_supported: bool = False, is_rotation_supported: bool = False, is_scale_supported: bool = False) -> None:
        ...
    @property
    def is_location_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether location in frame data should be used
        """
        ...
    @is_location_supported.setter
    def is_location_supported(self, value: bool) -> None:
        ...
    @property
    def is_rotation_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether rotation in frame data should be used
        """
        ...
    @is_rotation_supported.setter
    def is_rotation_supported(self, value: bool) -> None:
        ...
    @property
    def is_scale_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether scale in frame data should be used
        """
        ...
    @is_scale_supported.setter
    def is_scale_supported(self, value: bool) -> None:
        ...

class LiveLinkCameraStaticData(LiveLinkTransformStaticData):
    r"""
    Static data for Camera data.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkCameraTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``film_back_height`` (float):  [Read-Write] Used with CinematicCamera. Values greater than 0 will be applied
    - ``film_back_width`` (float):  [Read-Write] Used with CinematicCamera. Values greater than 0 will be applied
    - ``is_aperture_supported`` (bool):  [Read-Write] Whether Aperture in frame data can be used
    - ``is_aspect_ratio_supported`` (bool):  [Read-Write] Whether AspectRatio in frame data can be used
    - ``is_depth_of_field_supported`` (bool):  [Read-Write] Set to false to force the camera to disable depth of field
    - ``is_field_of_view_supported`` (bool):  [Read-Write] Whether FieldOfView in frame data can be used
    - ``is_focal_length_supported`` (bool):  [Read-Write] Whether FocalLength in frame data can be used
    - ``is_focus_distance_supported`` (bool):  [Read-Write] Whether FocusDistance in frame data can be used
    - ``is_location_supported`` (bool):  [Read-Write] Whether location in frame data should be used
    - ``is_projection_mode_supported`` (bool):  [Read-Write] Whether ProjectionMode in frame data can be used
    - ``is_rotation_supported`` (bool):  [Read-Write] Whether rotation in frame data should be used
    - ``is_scale_supported`` (bool):  [Read-Write] Whether scale in frame data should be used
    - ``property_names`` (Array[Name]):  [Read-Write] Names for each curve values that will be sent for each frame
    """
    def __init__(self, property_names: Array[Name] = [], is_location_supported: bool = False, is_rotation_supported: bool = False, is_scale_supported: bool = False, is_field_of_view_supported: bool = False, is_aspect_ratio_supported: bool = False, is_focal_length_supported: bool = False, is_projection_mode_supported: bool = False, film_back_width: float = 0.000000, film_back_height: float = 0.000000, is_aperture_supported: bool = False, is_focus_distance_supported: bool = False, is_depth_of_field_supported: bool = False) -> None:
        ...
    @property
    def is_field_of_view_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether FieldOfView in frame data can be used
        """
        ...
    @is_field_of_view_supported.setter
    def is_field_of_view_supported(self, value: bool) -> None:
        ...
    @property
    def is_aspect_ratio_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether AspectRatio in frame data can be used
        """
        ...
    @is_aspect_ratio_supported.setter
    def is_aspect_ratio_supported(self, value: bool) -> None:
        ...
    @property
    def is_focal_length_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether FocalLength in frame data can be used
        """
        ...
    @is_focal_length_supported.setter
    def is_focal_length_supported(self, value: bool) -> None:
        ...
    @property
    def is_projection_mode_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether ProjectionMode in frame data can be used
        """
        ...
    @is_projection_mode_supported.setter
    def is_projection_mode_supported(self, value: bool) -> None:
        ...
    @property
    def film_back_width(self) -> float:
        r"""
        (float):  [Read-Write] Used with CinematicCamera. Values greater than 0 will be applied
        """
        ...
    @film_back_width.setter
    def film_back_width(self, value: float) -> None:
        ...
    @property
    def film_back_height(self) -> float:
        r"""
        (float):  [Read-Write] Used with CinematicCamera. Values greater than 0 will be applied
        """
        ...
    @film_back_height.setter
    def film_back_height(self, value: float) -> None:
        ...
    @property
    def is_aperture_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether Aperture in frame data can be used
        """
        ...
    @is_aperture_supported.setter
    def is_aperture_supported(self, value: bool) -> None:
        ...
    @property
    def is_focus_distance_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether FocusDistance in frame data can be used
        """
        ...
    @is_focus_distance_supported.setter
    def is_focus_distance_supported(self, value: bool) -> None:
        ...
    @property
    def is_depth_of_field_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Set to false to force the camera to disable depth of field
        """
        ...
    @is_depth_of_field_supported.setter
    def is_depth_of_field_supported(self, value: bool) -> None:
        ...

class LiveLinkTransformFrameData(LiveLinkBaseFrameData):
    r"""
    Dynamic data for Transform
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTransformTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``meta_data`` (LiveLinkMetaData):  [Read-Write] Frame's metadata.
    - ``property_values`` (Array[float]):  [Read-Write] Values of the properties defined in the static structure. Use FLiveLinkBaseStaticData.FindPropertyValue to evaluate.
    - ``transform`` (Transform):  [Read-Write] Transform of the frame
    - ``world_time`` (LiveLinkWorldTime):  [Read-Only] Time in seconds the frame was created.
    """
    def __init__(self, meta_data: LiveLinkMetaData = [{}, [[0], [24, 1], 0.000000]], property_values: Array[float] = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Transform of the frame
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...

class LiveLinkCameraFrameData(LiveLinkTransformFrameData):
    r"""
    Dynamic data for camera
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkCameraTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``aperture`` (float):  [Read-Write] Aperture of the camera in terms of f-stop
    - ``aspect_ratio`` (float):  [Read-Write] Aspect Ratio of the camera (Width / Heigth)
    - ``field_of_view`` (float):  [Read-Write] Field of View of the camera in degrees
    - ``focal_length`` (float):  [Read-Write] Focal length of the camera
    - ``focus_distance`` (float):  [Read-Write] Focus distance of the camera in cm. Works only in manual focus method
    - ``meta_data`` (LiveLinkMetaData):  [Read-Write] Frame's metadata.
    - ``projection_mode`` (LiveLinkCameraProjectionMode):  [Read-Write] ProjectionMode of the camera (Perspective, Orthographic, etc...)
    - ``property_values`` (Array[float]):  [Read-Write] Values of the properties defined in the static structure. Use FLiveLinkBaseStaticData.FindPropertyValue to evaluate.
    - ``transform`` (Transform):  [Read-Write] Transform of the frame
    - ``world_time`` (LiveLinkWorldTime):  [Read-Only] Time in seconds the frame was created.
    """
    def __init__(self, meta_data: LiveLinkMetaData = [{}, [[0], [24, 1], 0.000000]], property_values: Array[float] = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], field_of_view: float = 0.000000, aspect_ratio: float = 0.000000, focal_length: float = 0.000000, aperture: float = 0.000000, focus_distance: float = 0.000000, projection_mode: LiveLinkCameraProjectionMode = LiveLinkCameraProjectionMode.PERSPECTIVE) -> None:
        ...
    @property
    def field_of_view(self) -> float:
        r"""
        (float):  [Read-Write] Field of View of the camera in degrees
        """
        ...
    @field_of_view.setter
    def field_of_view(self, value: float) -> None:
        ...
    @property
    def aspect_ratio(self) -> float:
        r"""
        (float):  [Read-Write] Aspect Ratio of the camera (Width / Heigth)
        """
        ...
    @aspect_ratio.setter
    def aspect_ratio(self, value: float) -> None:
        ...
    @property
    def focal_length(self) -> float:
        r"""
        (float):  [Read-Write] Focal length of the camera
        """
        ...
    @focal_length.setter
    def focal_length(self, value: float) -> None:
        ...
    @property
    def aperture(self) -> float:
        r"""
        (float):  [Read-Write] Aperture of the camera in terms of f-stop
        """
        ...
    @aperture.setter
    def aperture(self, value: float) -> None:
        ...
    @property
    def focus_distance(self) -> float:
        r"""
        (float):  [Read-Write] Focus distance of the camera in cm. Works only in manual focus method
        """
        ...
    @focus_distance.setter
    def focus_distance(self, value: float) -> None:
        ...
    @property
    def projection_mode(self) -> LiveLinkCameraProjectionMode:
        r"""
        (LiveLinkCameraProjectionMode):  [Read-Write] ProjectionMode of the camera (Perspective, Orthographic, etc...)
        """
        ...
    @projection_mode.setter
    def projection_mode(self, value: LiveLinkCameraProjectionMode) -> None:
        ...

class LiveLinkCameraBlueprintData(LiveLinkBaseBlueprintData):
    r"""
    Facility structure to handle camera data in blueprint
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkCameraTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_data`` (LiveLinkCameraFrameData):  [Read-Write] Dynamic data that can change every frame
    - ``static_data`` (LiveLinkCameraStaticData):  [Read-Write] Static data that should not change every frame
    """
    def __init__(self, static_data: LiveLinkCameraStaticData = [False, False, False, False, -1.000000, -1.000000, False, False, True, True, True, False, []], frame_data: LiveLinkCameraFrameData = [90.000000, 1.777778, 50.000000, 2.800000, 100000.000000, LiveLinkCameraProjectionMode.PERSPECTIVE, [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], [{}, [[0], [24, 1], 0.000000]], []]) -> None:
        ...
    @property
    def static_data(self) -> LiveLinkCameraStaticData:
        r"""
        (LiveLinkCameraStaticData):  [Read-Write] Static data that should not change every frame
        """
        ...
    @static_data.setter
    def static_data(self, value: LiveLinkCameraStaticData) -> None:
        ...
    @property
    def frame_data(self) -> LiveLinkCameraFrameData:
        r"""
        (LiveLinkCameraFrameData):  [Read-Write] Dynamic data that can change every frame
        """
        ...
    @frame_data.setter
    def frame_data(self, value: LiveLinkCameraFrameData) -> None:
        ...

class LiveLinkGamepadInputDeviceStaticData(LiveLinkBaseStaticData):
    r"""
    Struct for static Gamepad Input Device data
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkInputDeviceTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``property_names`` (Array[Name]):  [Read-Write] Names for each curve values that will be sent for each frame
    """
    def __init__(self, property_names: Array[Name] = []) -> None:
        ...

class LiveLinkGamepadInputDeviceFrameData(LiveLinkBaseFrameData):
    r"""
    Struct for dynamic (per-frame) Gampead Input Device data
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkInputDeviceTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``d_pad_down`` (float):  [Read-Write]
    - ``d_pad_left`` (float):  [Read-Write]
    - ``d_pad_right`` (float):  [Read-Write]
    - ``d_pad_up`` (float):  [Read-Write]
    - ``face_button_bottom`` (float):  [Read-Write]
    - ``face_button_left`` (float):  [Read-Write]
    - ``face_button_right`` (float):  [Read-Write]
    - ``face_button_top`` (float):  [Read-Write]
    - ``left_analog_x`` (float):  [Read-Write]
    - ``left_analog_y`` (float):  [Read-Write]
    - ``left_shoulder`` (float):  [Read-Write]
    - ``left_stick_down`` (float):  [Read-Write]
    - ``left_stick_left`` (float):  [Read-Write]
    - ``left_stick_right`` (float):  [Read-Write]
    - ``left_stick_up`` (float):  [Read-Write]
    - ``left_thumb`` (float):  [Read-Write]
    - ``left_trigger_analog`` (float):  [Read-Write]
    - ``left_trigger_threshold`` (float):  [Read-Write]
    - ``meta_data`` (LiveLinkMetaData):  [Read-Write] Frame's metadata.
    - ``property_values`` (Array[float]):  [Read-Write] Values of the properties defined in the static structure. Use FLiveLinkBaseStaticData.FindPropertyValue to evaluate.
    - ``right_analog_x`` (float):  [Read-Write]
    - ``right_analog_y`` (float):  [Read-Write]
    - ``right_shoulder`` (float):  [Read-Write]
    - ``right_stick_down`` (float):  [Read-Write]
    - ``right_stick_left`` (float):  [Read-Write]
    - ``right_stick_right`` (float):  [Read-Write]
    - ``right_stick_up`` (float):  [Read-Write]
    - ``right_thumb`` (float):  [Read-Write]
    - ``right_trigger_analog`` (float):  [Read-Write]
    - ``right_trigger_threshold`` (float):  [Read-Write]
    - ``special_left`` (float):  [Read-Write]
    - ``special_left_x`` (float):  [Read-Write]
    - ``special_left_y`` (float):  [Read-Write]
    - ``special_right`` (float):  [Read-Write]
    - ``world_time`` (LiveLinkWorldTime):  [Read-Only] Time in seconds the frame was created.
    """
    def __init__(self, meta_data: LiveLinkMetaData = [{}, [[0], [24, 1], 0.000000]], property_values: Array[float] = [], left_analog_x: float = 0.000000, left_analog_y: float = 0.000000, right_analog_x: float = 0.000000, right_analog_y: float = 0.000000, left_trigger_analog: float = 0.000000, right_trigger_analog: float = 0.000000, left_thumb: float = 0.000000, right_thumb: float = 0.000000, special_left: float = 0.000000, special_left_x: float = 0.000000, special_left_y: float = 0.000000, special_right: float = 0.000000, face_button_bottom: float = 0.000000, face_button_right: float = 0.000000, face_button_left: float = 0.000000, face_button_top: float = 0.000000, left_shoulder: float = 0.000000, right_shoulder: float = 0.000000, left_trigger_threshold: float = 0.000000, right_trigger_threshold: float = 0.000000, d_pad_up: float = 0.000000, d_pad_down: float = 0.000000, d_pad_right: float = 0.000000, d_pad_left: float = 0.000000, left_stick_up: float = 0.000000, left_stick_down: float = 0.000000, left_stick_right: float = 0.000000, left_stick_left: float = 0.000000, right_stick_up: float = 0.000000, right_stick_down: float = 0.000000, right_stick_right: float = 0.000000, right_stick_left: float = 0.000000) -> None:
        ...
    @property
    def left_analog_x(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @left_analog_x.setter
    def left_analog_x(self, value: float) -> None:
        ...
    @property
    def left_analog_y(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @left_analog_y.setter
    def left_analog_y(self, value: float) -> None:
        ...
    @property
    def right_analog_x(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @right_analog_x.setter
    def right_analog_x(self, value: float) -> None:
        ...
    @property
    def right_analog_y(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @right_analog_y.setter
    def right_analog_y(self, value: float) -> None:
        ...
    @property
    def left_trigger_analog(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @left_trigger_analog.setter
    def left_trigger_analog(self, value: float) -> None:
        ...
    @property
    def right_trigger_analog(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @right_trigger_analog.setter
    def right_trigger_analog(self, value: float) -> None:
        ...
    @property
    def left_thumb(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @left_thumb.setter
    def left_thumb(self, value: float) -> None:
        ...
    @property
    def right_thumb(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @right_thumb.setter
    def right_thumb(self, value: float) -> None:
        ...
    @property
    def special_left(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @special_left.setter
    def special_left(self, value: float) -> None:
        ...
    @property
    def special_left_x(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @special_left_x.setter
    def special_left_x(self, value: float) -> None:
        ...
    @property
    def special_left_y(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @special_left_y.setter
    def special_left_y(self, value: float) -> None:
        ...
    @property
    def special_right(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @special_right.setter
    def special_right(self, value: float) -> None:
        ...
    @property
    def face_button_bottom(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @face_button_bottom.setter
    def face_button_bottom(self, value: float) -> None:
        ...
    @property
    def face_button_right(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @face_button_right.setter
    def face_button_right(self, value: float) -> None:
        ...
    @property
    def face_button_left(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @face_button_left.setter
    def face_button_left(self, value: float) -> None:
        ...
    @property
    def face_button_top(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @face_button_top.setter
    def face_button_top(self, value: float) -> None:
        ...
    @property
    def left_shoulder(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @left_shoulder.setter
    def left_shoulder(self, value: float) -> None:
        ...
    @property
    def right_shoulder(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @right_shoulder.setter
    def right_shoulder(self, value: float) -> None:
        ...
    @property
    def left_trigger_threshold(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @left_trigger_threshold.setter
    def left_trigger_threshold(self, value: float) -> None:
        ...
    @property
    def right_trigger_threshold(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @right_trigger_threshold.setter
    def right_trigger_threshold(self, value: float) -> None:
        ...
    @property
    def d_pad_up(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @d_pad_up.setter
    def d_pad_up(self, value: float) -> None:
        ...
    @property
    def d_pad_down(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @d_pad_down.setter
    def d_pad_down(self, value: float) -> None:
        ...
    @property
    def d_pad_right(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @d_pad_right.setter
    def d_pad_right(self, value: float) -> None:
        ...
    @property
    def d_pad_left(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @d_pad_left.setter
    def d_pad_left(self, value: float) -> None:
        ...
    @property
    def left_stick_up(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @left_stick_up.setter
    def left_stick_up(self, value: float) -> None:
        ...
    @property
    def left_stick_down(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @left_stick_down.setter
    def left_stick_down(self, value: float) -> None:
        ...
    @property
    def left_stick_right(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @left_stick_right.setter
    def left_stick_right(self, value: float) -> None:
        ...
    @property
    def left_stick_left(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @left_stick_left.setter
    def left_stick_left(self, value: float) -> None:
        ...
    @property
    def right_stick_up(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @right_stick_up.setter
    def right_stick_up(self, value: float) -> None:
        ...
    @property
    def right_stick_down(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @right_stick_down.setter
    def right_stick_down(self, value: float) -> None:
        ...
    @property
    def right_stick_right(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @right_stick_right.setter
    def right_stick_right(self, value: float) -> None:
        ...
    @property
    def right_stick_left(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @right_stick_left.setter
    def right_stick_left(self, value: float) -> None:
        ...

class LiveLinkGamepadInputDeviceBlueprintData(LiveLinkBaseBlueprintData):
    r"""
    Facility structure to handle Preston MDR data in blueprint
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkInputDeviceTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_data`` (LiveLinkGamepadInputDeviceFrameData):  [Read-Write] Dynamic data that can change every frame
    - ``static_data`` (LiveLinkGamepadInputDeviceStaticData):  [Read-Write] Static data that should not change every frame
    """
    def __init__(self, static_data: LiveLinkGamepadInputDeviceStaticData = [[]], frame_data: LiveLinkGamepadInputDeviceFrameData = [0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, [{}, [[0], [24, 1], 0.000000]], []]) -> None:
        ...
    @property
    def static_data(self) -> LiveLinkGamepadInputDeviceStaticData:
        r"""
        (LiveLinkGamepadInputDeviceStaticData):  [Read-Write] Static data that should not change every frame
        """
        ...
    @static_data.setter
    def static_data(self, value: LiveLinkGamepadInputDeviceStaticData) -> None:
        ...
    @property
    def frame_data(self) -> LiveLinkGamepadInputDeviceFrameData:
        r"""
        (LiveLinkGamepadInputDeviceFrameData):  [Read-Write] Dynamic data that can change every frame
        """
        ...
    @frame_data.setter
    def frame_data(self, value: LiveLinkGamepadInputDeviceFrameData) -> None:
        ...

class LiveLinkLightStaticData(LiveLinkTransformStaticData):
    r"""
    Static data for Light data.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkLightTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_attenuation_radius_supported`` (bool):  [Read-Write] Whether AttenuationRadius can be used in the frame data. Only used for spot lights
    - ``is_inner_cone_angle_supported`` (bool):  [Read-Write] Whether InnerConeAngle can be used in the frame data. Only used for spot lights
    - ``is_intensity_supported`` (bool):  [Read-Write] Whether Intensity can be used in the frame data
    - ``is_light_color_supported`` (bool):  [Read-Write] Whether LightColor can be used in the frame data
    - ``is_location_supported`` (bool):  [Read-Write] Whether location in frame data should be used
    - ``is_outer_cone_angle_supported`` (bool):  [Read-Write] Whether OuterConeAngle can be used in the frame data. Only used for spot lights
    - ``is_rotation_supported`` (bool):  [Read-Write] Whether rotation in frame data should be used
    - ``is_scale_supported`` (bool):  [Read-Write] Whether scale in frame data should be used
    - ``is_soft_source_radius_supported`` (bool):  [Read-Write] Whether SoftSourceRadius can be used in the frame data. Only used for spot lights
    - ``is_source_lenght_supported`` (bool):  [Read-Write] Whether SourceLength can be used in the frame data. Only used for spot lights
    - ``is_source_radius_supported`` (bool):  [Read-Write] Whether SourceRadius can be used in the frame data. Only used for spot lights
    - ``is_temperature_supported`` (bool):  [Read-Write] Whether Temperature can be used in the frame data
    - ``property_names`` (Array[Name]):  [Read-Write] Names for each curve values that will be sent for each frame
    """
    def __init__(self, property_names: Array[Name] = [], is_location_supported: bool = False, is_rotation_supported: bool = False, is_scale_supported: bool = False, is_temperature_supported: bool = False, is_intensity_supported: bool = False, is_light_color_supported: bool = False, is_inner_cone_angle_supported: bool = False, is_outer_cone_angle_supported: bool = False, is_attenuation_radius_supported: bool = False, is_source_lenght_supported: bool = False, is_source_radius_supported: bool = False, is_soft_source_radius_supported: bool = False) -> None:
        ...
    @property
    def is_temperature_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether Temperature can be used in the frame data
        """
        ...
    @is_temperature_supported.setter
    def is_temperature_supported(self, value: bool) -> None:
        ...
    @property
    def is_intensity_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether Intensity can be used in the frame data
        """
        ...
    @is_intensity_supported.setter
    def is_intensity_supported(self, value: bool) -> None:
        ...
    @property
    def is_light_color_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether LightColor can be used in the frame data
        """
        ...
    @is_light_color_supported.setter
    def is_light_color_supported(self, value: bool) -> None:
        ...
    @property
    def is_inner_cone_angle_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether InnerConeAngle can be used in the frame data. Only used for spot lights
        """
        ...
    @is_inner_cone_angle_supported.setter
    def is_inner_cone_angle_supported(self, value: bool) -> None:
        ...
    @property
    def is_outer_cone_angle_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether OuterConeAngle can be used in the frame data. Only used for spot lights
        """
        ...
    @is_outer_cone_angle_supported.setter
    def is_outer_cone_angle_supported(self, value: bool) -> None:
        ...
    @property
    def is_attenuation_radius_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether AttenuationRadius can be used in the frame data. Only used for spot lights
        """
        ...
    @is_attenuation_radius_supported.setter
    def is_attenuation_radius_supported(self, value: bool) -> None:
        ...
    @property
    def is_source_lenght_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether SourceLength can be used in the frame data. Only used for spot lights
        """
        ...
    @is_source_lenght_supported.setter
    def is_source_lenght_supported(self, value: bool) -> None:
        ...
    @property
    def is_source_radius_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether SourceRadius can be used in the frame data. Only used for spot lights
        """
        ...
    @is_source_radius_supported.setter
    def is_source_radius_supported(self, value: bool) -> None:
        ...
    @property
    def is_soft_source_radius_supported(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether SoftSourceRadius can be used in the frame data. Only used for spot lights
        """
        ...
    @is_soft_source_radius_supported.setter
    def is_soft_source_radius_supported(self, value: bool) -> None:
        ...

class LiveLinkLightFrameData(LiveLinkTransformFrameData):
    r"""
    Dynamic data for light.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkLightTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attenuation_radius`` (float):  [Read-Write] Light visible influence. Works for Pointlight and Spotlight.
    - ``inner_cone_angle`` (float):  [Read-Write] Inner cone angle in degrees for a Spotlight.
    - ``intensity`` (float):  [Read-Write] Total energy that the light emits in lux.
    - ``light_color`` (Color):  [Read-Write] Filter color of the light.
    - ``meta_data`` (LiveLinkMetaData):  [Read-Write] Frame's metadata.
    - ``outer_cone_angle`` (float):  [Read-Write] Outer cone angle in degrees for a Spotlight.
    - ``property_values`` (Array[float]):  [Read-Write] Values of the properties defined in the static structure. Use FLiveLinkBaseStaticData.FindPropertyValue to evaluate.
    - ``soft_source_radius`` (float):  [Read-Write] Soft radius of light source shape. Works for Pointlight and Spotlight.
    - ``source_length`` (float):  [Read-Write] Length of light source shape. Works for Pointlight and Spotlight.
    - ``source_radius`` (float):  [Read-Write] Radius of light source shape. Works for Pointlight and Spotlight.
    - ``temperature`` (float):  [Read-Write] Color temperature in Kelvin of the blackbody illuminant
    - ``transform`` (Transform):  [Read-Write] Transform of the frame
    - ``world_time`` (LiveLinkWorldTime):  [Read-Only] Time in seconds the frame was created.
    """
    def __init__(self, meta_data: LiveLinkMetaData = [{}, [[0], [24, 1], 0.000000]], property_values: Array[float] = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], temperature: float = 0.000000, intensity: float = 0.000000, light_color: Color = [0, 0, 0, 0], inner_cone_angle: float = 0.000000, outer_cone_angle: float = 0.000000, attenuation_radius: float = 0.000000, source_radius: float = 0.000000, soft_source_radius: float = 0.000000, source_length: float = 0.000000) -> None:
        ...
    @property
    def temperature(self) -> float:
        r"""
        (float):  [Read-Write] Color temperature in Kelvin of the blackbody illuminant
        """
        ...
    @temperature.setter
    def temperature(self, value: float) -> None:
        ...
    @property
    def intensity(self) -> float:
        r"""
        (float):  [Read-Write] Total energy that the light emits in lux.
        """
        ...
    @intensity.setter
    def intensity(self, value: float) -> None:
        ...
    @property
    def light_color(self) -> Color:
        r"""
        (Color):  [Read-Write] Filter color of the light.
        """
        ...
    @light_color.setter
    def light_color(self, value: Color) -> None:
        ...
    @property
    def inner_cone_angle(self) -> float:
        r"""
        (float):  [Read-Write] Inner cone angle in degrees for a Spotlight.
        """
        ...
    @inner_cone_angle.setter
    def inner_cone_angle(self, value: float) -> None:
        ...
    @property
    def outer_cone_angle(self) -> float:
        r"""
        (float):  [Read-Write] Outer cone angle in degrees for a Spotlight.
        """
        ...
    @outer_cone_angle.setter
    def outer_cone_angle(self, value: float) -> None:
        ...
    @property
    def attenuation_radius(self) -> float:
        r"""
        (float):  [Read-Write] Light visible influence. Works for Pointlight and Spotlight.
        """
        ...
    @attenuation_radius.setter
    def attenuation_radius(self, value: float) -> None:
        ...
    @property
    def source_radius(self) -> float:
        r"""
        (float):  [Read-Write] Radius of light source shape. Works for Pointlight and Spotlight.
        """
        ...
    @source_radius.setter
    def source_radius(self, value: float) -> None:
        ...
    @property
    def soft_source_radius(self) -> float:
        r"""
        (float):  [Read-Write] Soft radius of light source shape. Works for Pointlight and Spotlight.
        """
        ...
    @soft_source_radius.setter
    def soft_source_radius(self, value: float) -> None:
        ...
    @property
    def source_length(self) -> float:
        r"""
        (float):  [Read-Write] Length of light source shape. Works for Pointlight and Spotlight.
        """
        ...
    @source_length.setter
    def source_length(self, value: float) -> None:
        ...

class LiveLinkLightBlueprintData(LiveLinkBaseBlueprintData):
    r"""
    Facility structure to handle light data in blueprint
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkLightTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_data`` (LiveLinkLightFrameData):  [Read-Write] Dynamic data that can change every frame
    - ``static_data`` (LiveLinkLightStaticData):  [Read-Write] Static data that should not change every frame
    """
    def __init__(self, static_data: LiveLinkLightStaticData = [False, False, False, False, False, False, False, False, False, True, True, False, []], frame_data: LiveLinkLightFrameData = [6500.000000, 3.141593, [255, 255, 255, 255], 0.000000, 44.000000, 1000.000000, 0.000000, 0.000000, 0.000000, [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], [{}, [[0], [24, 1], 0.000000]], []]) -> None:
        ...
    @property
    def static_data(self) -> LiveLinkLightStaticData:
        r"""
        (LiveLinkLightStaticData):  [Read-Write] Static data that should not change every frame
        """
        ...
    @static_data.setter
    def static_data(self, value: LiveLinkLightStaticData) -> None:
        ...
    @property
    def frame_data(self) -> LiveLinkLightFrameData:
        r"""
        (LiveLinkLightFrameData):  [Read-Write] Dynamic data that can change every frame
        """
        ...
    @frame_data.setter
    def frame_data(self, value: LiveLinkLightFrameData) -> None:
        ...

class LiveLinkSubjectKey(StructBase):
    r"""
    Structure that identifies an individual subject
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source`` (Guid):  [Read-Write] The guid for this subjects source
    - ``subject_name`` (LiveLinkSubjectName):  [Read-Write] The Name of this subject
    """
    def __init__(self, source: Guid = [], subject_name: LiveLinkSubjectName = ["None"]) -> None:
        ...
    @property
    def source(self) -> Guid:
        r"""
        (Guid):  [Read-Only] The guid for this subjects source
        """
        ...
    @property
    def subject_name(self) -> LiveLinkSubjectName:
        r"""
        (LiveLinkSubjectName):  [Read-Only] The Name of this subject
        """
        ...

class LiveLinkSubjectName(StructBase):
    r"""
    Live Link Subject Name
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] Name of the subject
    """
    def __init__(self, name: Name = "None") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of the subject
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...

class LiveLinkSubjectRepresentation(StructBase):
    r"""
    Live Link Subject Representation
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkRole.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``role`` (type(Class)):  [Read-Write]
    - ``subject`` (LiveLinkSubjectName):  [Read-Write]
    """
    def __init__(self, subject: LiveLinkSubjectName = ["None"], role: Class = None) -> None:
        ...
    @property
    def subject(self) -> LiveLinkSubjectName:
        r"""
        (LiveLinkSubjectName):  [Read-Write]
        """
        ...
    @subject.setter
    def subject(self, value: LiveLinkSubjectName) -> None:
        ...
    @property
    def role(self) -> Class:
        r"""
        (type(Class)):  [Read-Write]
        """
        ...
    @role.setter
    def role(self, value: Class) -> None:
        ...

class LiveLinkTransformBlueprintData(LiveLinkBaseBlueprintData):
    r"""
    Facility structure to handle transform data in blueprint
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTransformTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_data`` (LiveLinkTransformFrameData):  [Read-Write] Dynamic data that can change every frame
    - ``static_data`` (LiveLinkTransformStaticData):  [Read-Write] Static data that should not change every frame
    """
    def __init__(self, static_data: LiveLinkTransformStaticData = [True, True, False, []], frame_data: LiveLinkTransformFrameData = [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], [{}, [[0], [24, 1], 0.000000]], []]) -> None:
        ...
    @property
    def static_data(self) -> LiveLinkTransformStaticData:
        r"""
        (LiveLinkTransformStaticData):  [Read-Write] Static data that should not change every frame
        """
        ...
    @static_data.setter
    def static_data(self, value: LiveLinkTransformStaticData) -> None:
        ...
    @property
    def frame_data(self) -> LiveLinkTransformFrameData:
        r"""
        (LiveLinkTransformFrameData):  [Read-Write] Dynamic data that can change every frame
        """
        ...
    @frame_data.setter
    def frame_data(self, value: LiveLinkTransformFrameData) -> None:
        ...

class LiveLinkCurveConversionSettings(StructBase):
    r"""
    Live Link Curve Conversion Settings
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkCurveRemapSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve_conversion_asset_map`` (Map[str, SoftObjectPath]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class LiveLinkTime(StructBase):
    r"""
    Live Link Time
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``scene_time`` (QualifiedTime):  [Read-Write]
    - ``world_time`` (double):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class LiveLinkFrameRate(FrameRate):
    r"""
    Live Link Frame Rate
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``denominator`` (int32):  [Read-Write] The denominator of the framerate represented as a number of frames per second (e.g. 1 for 60 fps)
    - ``numerator`` (int32):  [Read-Write] The numerator of the framerate represented as a number of frames per second (e.g. 60 for 60 fps)
    """
    def __init__(self, numerator: int = 0, denominator: int = 0) -> None:
        ...

class SubjectMetadata(StructBase):
    r"""
    Subject Metadata
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkAnimationBlueprintStructs.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``scene_framerate`` (FrameRate):  [Read-Write]
    - ``scene_timecode`` (Timecode):  [Read-Write]
    - ``string_metadata`` (Map[Name, str]):  [Read-Write]
    """
    def __init__(self, string_metadata: Map[Name, str] = {}, scene_timecode: Timecode = [0, 0, 0, 0, False], scene_framerate: FrameRate = [0, 0]) -> None:
        ...
    @property
    def string_metadata(self) -> Map[Name, str]:
        r"""
        (Map[Name, str]):  [Read-Write]
        """
        ...
    @string_metadata.setter
    def string_metadata(self, value: Map[Name, str]) -> None:
        ...
    @property
    def scene_timecode(self) -> Timecode:
        r"""
        (Timecode):  [Read-Write]
        """
        ...
    @scene_timecode.setter
    def scene_timecode(self, value: Timecode) -> None:
        ...
    @property
    def scene_framerate(self) -> FrameRate:
        r"""
        (FrameRate):  [Read-Write]
        """
        ...
    @scene_framerate.setter
    def scene_framerate(self, value: FrameRate) -> None:
        ...

class LiveLinkTransform(StructBase):
    r"""
    Live Link Transform
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkAnimationBlueprintStructs.h
    
    """
    def __init__(self) -> None:
        ...

class SubjectFrameHandle(LiveLinkBaseBlueprintData):
    r"""
    Subject Frame Handle
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkAnimationBlueprintStructs.h
    
    """
    def __init__(self) -> None:
        ...

class CompositionGraphCapturePasses(StructBase):
    r"""
    Composition Graph Capture Passes
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: CompositionGraphCaptureProtocol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (Array[str]):  [Read-Write] List of passes to record by name.
    """
    def __init__(self, value: Array[str] = []) -> None:
        ...
    @property
    def value(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] List of passes to record by name.
        """
        ...
    @value.setter
    def value(self, value: Array[str]) -> None:
        ...

class CaptureResolution(StructBase):
    r"""
    Structure representing a capture resolution
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: MovieSceneCaptureSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``res_x`` (int32):  [Read-Write]
    - ``res_y`` (int32):  [Read-Write]
    """
    def __init__(self, res_x: int = 0, res_y: int = 0) -> None:
        ...
    @property
    def res_x(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @res_x.setter
    def res_x(self, value: int) -> None:
        ...
    @property
    def res_y(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @res_y.setter
    def res_y(self, value: int) -> None:
        ...

class MovieSceneCaptureSettings(StructBase):
    r"""
    Common movie-scene capture settings
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: MovieSceneCaptureSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_movement`` (bool):  [Read-Write] Whether to allow player movement whilst capturing
    - ``allow_turning`` (bool):  [Read-Write] Whether to allow player rotation whilst capturing
    - ``cinematic_engine_scalability`` (bool):  [Read-Write] Whether to enable cinematic engine scalability settings
    - ``cinematic_mode`` (bool):  [Read-Write] Whether to enable cinematic mode whilst capturing
    - ``custom_frame_rate`` (FrameRate):  [Read-Write] The custom frame rate at which to capture if "Use Custom Frame Rate" is enabled
    - ``enable_texture_streaming`` (bool):  [Read-Write] Whether to texture streaming should be enabled while capturing.  Turning off texture streaming may cause much more memory to be used, but also reduces the chance of blurry textures in your captured video.
    - ``frame_rate`` (FrameRate):  [Read-Only] The sequence's frame rate at which to capture if "Use Custom Frame Rate" is not enabled
    - ``game_mode_override`` (type(Class)):  [Read-Write] Optional game mode to override the map's default game mode with.  This can be useful if the game's normal mode displays UI elements or loading screens that you don't want captured.
    - ``handle_frames`` (int32):  [Read-Write] Number of frame handles to include for each shot
    - ``movie_extension`` (str):  [Read-Write] Filename extension for movies referenced in the XMLs/EDLs
    - ``output_directory`` (DirectoryPath):  [Read-Write] The directory to output the captured file(s) in
    - ``output_format`` (str):  [Read-Write] The format to use for the resulting filename. Extension will be added automatically. Any tokens of the form {token} will be replaced with the corresponding value:
      {fps}                - The captured framerate
      {frame}              - The current frame number (only relevant for image sequences)
      {width}              - The width of the captured frames
      {height}             - The height of the captured frames
      {world}              - The name of the current world
      {quality}    - The image compression quality setting
      {material}   - The material/render pass
      {shot}       - The name of the level sequence asset shot being played
      {sequence}   - The name of the level sequence asset being played
      {camera}     - The name of the current camera
      {date}       - The date in the format of {year}.{month}.{day}
      {year}       - The current year
      {month}      - The current month
      {day}        - The current day
      {time}       - The current time in the format of hours.minutes.seconds
    - ``overwrite_existing`` (bool):  [Read-Write] Whether to overwrite existing files or not
    - ``path_tracer_sample_per_pixel`` (int32):  [Read-Write] Number of sampler per pixel to be used when rendering the scene with the path tracer (if supported)
    - ``resolution`` (CaptureResolution):  [Read-Write] The resolution at which to capture
    - ``show_hud`` (bool):  [Read-Write] Whether to show the in-game HUD whilst capturing
    - ``show_player`` (bool):  [Read-Write] Whether to show the local player whilst capturing
    - ``use_custom_frame_rate`` (bool):  [Read-Write] Specify using the custom frame rate as opposed to the sequence's display rate
    - ``use_path_tracer`` (bool):  [Read-Write] Whether to use the path tracer (if supported) to render the scene
    - ``use_relative_frame_numbers`` (bool):  [Read-Write] True if frame numbers in the output files should be relative to zero, rather than the actual frame numbers in the originating animation content.
    - ``zero_pad_frame_numbers`` (uint8):  [Read-Write] How much to zero-pad frame numbers on filenames
    """
    def __init__(self, output_directory: DirectoryPath = [""], game_mode_override: Class = None, output_format: str = "", overwrite_existing: bool = False, use_relative_frame_numbers: bool = False, handle_frames: int = 0, movie_extension: str = "", zero_pad_frame_numbers: int = 0, frame_rate: FrameRate = [0, 0], use_custom_frame_rate: bool = False, custom_frame_rate: FrameRate = [0, 0], resolution: CaptureResolution = [0, 0], enable_texture_streaming: bool = False, cinematic_engine_scalability: bool = False, cinematic_mode: bool = False, allow_movement: bool = False, allow_turning: bool = False, show_player: bool = False, show_hud: bool = False, use_path_tracer: bool = False, path_tracer_sample_per_pixel: int = 0) -> None:
        ...
    @property
    def output_directory(self) -> DirectoryPath:
        r"""
        (DirectoryPath):  [Read-Write] The directory to output the captured file(s) in
        """
        ...
    @output_directory.setter
    def output_directory(self, value: DirectoryPath) -> None:
        ...
    @property
    def game_mode_override(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Optional game mode to override the map's default game mode with.  This can be useful if the game's normal mode displays UI elements or loading screens that you don't want captured.
        """
        ...
    @game_mode_override.setter
    def game_mode_override(self, value: Class) -> None:
        ...
    @property
    def output_format(self) -> str:
        r"""
        (str):  [Read-Write] The format to use for the resulting filename. Extension will be added automatically. Any tokens of the form {token} will be replaced with the corresponding value:
        {fps}                - The captured framerate
        {frame}              - The current frame number (only relevant for image sequences)
        {width}              - The width of the captured frames
        {height}             - The height of the captured frames
        {world}              - The name of the current world
        {quality}    - The image compression quality setting
        {material}   - The material/render pass
        {shot}       - The name of the level sequence asset shot being played
        {sequence}   - The name of the level sequence asset being played
        {camera}     - The name of the current camera
        {date}       - The date in the format of {year}.{month}.{day}
        {year}       - The current year
        {month}      - The current month
        {day}        - The current day
        {time}       - The current time in the format of hours.minutes.seconds
        """
        ...
    @output_format.setter
    def output_format(self, value: str) -> None:
        ...
    @property
    def overwrite_existing(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to overwrite existing files or not
        """
        ...
    @overwrite_existing.setter
    def overwrite_existing(self, value: bool) -> None:
        ...
    @property
    def use_relative_frame_numbers(self) -> bool:
        r"""
        (bool):  [Read-Write] True if frame numbers in the output files should be relative to zero, rather than the actual frame numbers in the originating animation content.
        """
        ...
    @use_relative_frame_numbers.setter
    def use_relative_frame_numbers(self, value: bool) -> None:
        ...
    @property
    def handle_frames(self) -> int:
        r"""
        (int32):  [Read-Write] Number of frame handles to include for each shot
        """
        ...
    @handle_frames.setter
    def handle_frames(self, value: int) -> None:
        ...
    @property
    def movie_extension(self) -> str:
        r"""
        (str):  [Read-Write] Filename extension for movies referenced in the XMLs/EDLs
        """
        ...
    @movie_extension.setter
    def movie_extension(self, value: str) -> None:
        ...
    @property
    def zero_pad_frame_numbers(self) -> int:
        r"""
        (uint8):  [Read-Write] How much to zero-pad frame numbers on filenames
        """
        ...
    @zero_pad_frame_numbers.setter
    def zero_pad_frame_numbers(self, value: int) -> None:
        ...
    @property
    def frame_rate(self) -> FrameRate:
        r"""
        (FrameRate):  [Read-Only] The sequence's frame rate at which to capture if "Use Custom Frame Rate" is not enabled
        """
        ...
    @property
    def use_custom_frame_rate(self) -> bool:
        r"""
        (bool):  [Read-Write] Specify using the custom frame rate as opposed to the sequence's display rate
        """
        ...
    @use_custom_frame_rate.setter
    def use_custom_frame_rate(self, value: bool) -> None:
        ...
    @property
    def custom_frame_rate(self) -> FrameRate:
        r"""
        (FrameRate):  [Read-Write] The custom frame rate at which to capture if "Use Custom Frame Rate" is enabled
        """
        ...
    @custom_frame_rate.setter
    def custom_frame_rate(self, value: FrameRate) -> None:
        ...
    @property
    def resolution(self) -> CaptureResolution:
        r"""
        (CaptureResolution):  [Read-Write] The resolution at which to capture
        """
        ...
    @resolution.setter
    def resolution(self, value: CaptureResolution) -> None:
        ...
    @property
    def enable_texture_streaming(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to texture streaming should be enabled while capturing.  Turning off texture streaming may cause much more memory to be used, but also reduces the chance of blurry textures in your captured video.
        """
        ...
    @enable_texture_streaming.setter
    def enable_texture_streaming(self, value: bool) -> None:
        ...
    @property
    def cinematic_engine_scalability(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to enable cinematic engine scalability settings
        """
        ...
    @cinematic_engine_scalability.setter
    def cinematic_engine_scalability(self, value: bool) -> None:
        ...
    @property
    def cinematic_mode(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to enable cinematic mode whilst capturing
        """
        ...
    @cinematic_mode.setter
    def cinematic_mode(self, value: bool) -> None:
        ...
    @property
    def allow_movement(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to allow player movement whilst capturing
        """
        ...
    @allow_movement.setter
    def allow_movement(self, value: bool) -> None:
        ...
    @property
    def allow_turning(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to allow player rotation whilst capturing
        """
        ...
    @allow_turning.setter
    def allow_turning(self, value: bool) -> None:
        ...
    @property
    def show_player(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to show the local player whilst capturing
        """
        ...
    @show_player.setter
    def show_player(self, value: bool) -> None:
        ...
    @property
    def show_hud(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to show the in-game HUD whilst capturing
        """
        ...
    @show_hud.setter
    def show_hud(self, value: bool) -> None:
        ...
    @property
    def use_path_tracer(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to use the path tracer (if supported) to render the scene
        """
        ...
    @use_path_tracer.setter
    def use_path_tracer(self, value: bool) -> None:
        ...
    @property
    def path_tracer_sample_per_pixel(self) -> int:
        r"""
        (int32):  [Read-Write] Number of sampler per pixel to be used when rendering the scene with the path tracer (if supported)
        """
        ...
    @path_tracer_sample_per_pixel.setter
    def path_tracer_sample_per_pixel(self, value: int) -> None:
        ...

class FrameMetrics(StructBase):
    r"""
    Metrics that correspond to a particular frame
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: MovieSceneCaptureProtocolBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_delta`` (float):  [Read-Write] The total amount of time, in seconds, that this specific frame took to render (not accounting for dropped frames)
    - ``frame_number`` (int32):  [Read-Write] The index of this frame from the start of the capture, including dropped frames
    - ``num_dropped_frames`` (int32):  [Read-Write] The number of frames we dropped in-between this frame, and the last one we captured
    - ``total_elapsed_time`` (float):  [Read-Write] The total amount of time, in seconds, since the capture started
    """
    def __init__(self, total_elapsed_time: float = 0.000000, frame_delta: float = 0.000000, frame_number: int = 0, num_dropped_frames: int = 0) -> None:
        ...
    @property
    def total_elapsed_time(self) -> float:
        r"""
        (float):  [Read-Only] The total amount of time, in seconds, since the capture started
        """
        ...
    @property
    def frame_delta(self) -> float:
        r"""
        (float):  [Read-Only] The total amount of time, in seconds, that this specific frame took to render (not accounting for dropped frames)
        """
        ...
    @property
    def frame_number(self) -> int:
        r"""
        (int32):  [Read-Only] The index of this frame from the start of the capture, including dropped frames
        """
        ...
    @property
    def num_dropped_frames(self) -> int:
        r"""
        (int32):  [Read-Only] The number of frames we dropped in-between this frame, and the last one we captured
        """
        ...

class CapturedPixelsID(StructBase):
    r"""
    Structure used as an identifier for a particular buffer within a capture.
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: UserDefinedCaptureProtocol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``identifiers`` (Map[Name, Name]):  [Read-Write] Map of identifiers to their values for this ID.
    """
    def __init__(self, identifiers: Map[Name, Name] = {}) -> None:
        ...
    @property
    def identifiers(self) -> Map[Name, Name]:
        r"""
        (Map[Name, Name]):  [Read-Write] Map of identifiers to their values for this ID.
        """
        ...
    @identifiers.setter
    def identifiers(self, value: Map[Name, Name]) -> None:
        ...

class CapturedPixels(StructBase):
    r"""
    Captured Pixels
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: UserDefinedCaptureProtocol.h
    
    """
    def __init__(self) -> None:
        ...

class TimecodeBoneMethod(StructBase):
    r"""
    Timecode Bone Method
    
    **C++ Source:**
    
    - **Module**: SequenceRecorder
    - **File**: AnimationRecorder.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_mode`` (TimecodeBoneMode):  [Read-Write] The timecode bone mode
    - ``bone_name`` (Name):  [Read-Write] Name of the bone to assign timecode values to
    """
    def __init__(self, bone_mode: TimecodeBoneMode = TimecodeBoneMode.ALL, bone_name: Name = "None") -> None:
        ...
    @property
    def bone_mode(self) -> TimecodeBoneMode:
        r"""
        (TimecodeBoneMode):  [Read-Write] The timecode bone mode
        """
        ...
    @bone_mode.setter
    def bone_mode(self, value: TimecodeBoneMode) -> None:
        ...
    @property
    def bone_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of the bone to assign timecode values to
        """
        ...
    @bone_name.setter
    def bone_name(self, value: Name) -> None:
        ...

class BakingAnimationKeySettings(StructBase):
    r"""
    Baking Animation Key Settings
    
    **C++ Source:**
    
    - **Module**: MovieSceneTools
    - **File**: BakingAnimationKeySettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``baking_key_settings`` (BakingKeySettings):  [Read-Write]
    - ``end_frame`` (FrameNumber):  [Read-Write]
    - ``frame_increment`` (int32):  [Read-Write]
    - ``reduce_keys`` (bool):  [Read-Write]
    - ``start_frame`` (FrameNumber):  [Read-Write]
    - ``tolerance`` (float):  [Read-Write]
    """
    def __init__(self, start_frame: FrameNumber = [0], end_frame: FrameNumber = [0], baking_key_settings: BakingKeySettings = BakingKeySettings.KEYS_ONLY, frame_increment: int = 0, reduce_keys: bool = False, tolerance: float = 0.000000) -> None:
        ...
    @property
    def start_frame(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write]
        """
        ...
    @start_frame.setter
    def start_frame(self, value: FrameNumber) -> None:
        ...
    @property
    def end_frame(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write]
        """
        ...
    @end_frame.setter
    def end_frame(self, value: FrameNumber) -> None:
        ...
    @property
    def baking_key_settings(self) -> BakingKeySettings:
        r"""
        (BakingKeySettings):  [Read-Write]
        """
        ...
    @baking_key_settings.setter
    def baking_key_settings(self, value: BakingKeySettings) -> None:
        ...
    @property
    def frame_increment(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @frame_increment.setter
    def frame_increment(self, value: int) -> None:
        ...
    @property
    def reduce_keys(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @reduce_keys.setter
    def reduce_keys(self, value: bool) -> None:
        ...
    @property
    def tolerance(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @tolerance.setter
    def tolerance(self, value: float) -> None:
        ...

class ControlToTransformMappings(StructBase):
    r"""
    Control to Transform Mappings
    
    **C++ Source:**
    
    - **Module**: MovieSceneTools
    - **File**: MovieSceneToolsUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control_channel`` (FControlRigChannelEnum):  [Read-Write] The channel of the control to map
    - ``fbx_channel`` (FTransformChannelEnum):  [Read-Write] The channel of the fbx transofrm node to map
    - ``negate`` (bool):  [Read-Write] Whether to negate the value
    """
    def __init__(self) -> None:
        ...

class ControlFindReplaceString(StructBase):
    r"""
    Control Find Replace String
    
    **C++ Source:**
    
    - **Module**: MovieSceneTools
    - **File**: MovieSceneToolsUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``find`` (str):  [Read-Write] The string to find in the imported data
    - ``replace`` (str):  [Read-Write] The string to replace in the imported data
    """
    def __init__(self) -> None:
        ...

class SequencerViewModelScriptingStruct(StructBase):
    r"""
    Sequencer View Model Scripting Struct
    
    **C++ Source:**
    
    - **Module**: SequencerCore
    - **File**: ViewModelScriptingStruct.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``type`` (Name):  [Read-Only]
    """
    def __init__(self, type: Name = "None") -> None:
        ...
    @property
    def type(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    def get_label(self) -> str:
        r"""
        x.get_label() -> str
        Get Label
        
        Returns:
            str:
        """
        ...

class ColumnVisibilitySetting(StructBase):
    r"""
    Struct for storing reorderable and hidden/visible outliner columns
    
    **C++ Source:**
    
    - **Module**: Sequencer
    - **File**: SequencerSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``column_name`` (Name):  [Read-Only]
    - ``is_visible`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MovieScenePasteFoldersParams(StructBase):
    r"""
    Paste folders params
    
    **C++ Source:**
    
    - **Module**: Sequencer
    - **File**: SequencerUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parent_folder`` (MovieSceneFolder):  [Read-Write]
    - ``sequence`` (MovieSceneSequence):  [Read-Write]
    """
    def __init__(self, sequence: MovieSceneSequence = None, parent_folder: MovieSceneFolder = None) -> None:
        ...
    @property
    def sequence(self) -> MovieSceneSequence:
        r"""
        (MovieSceneSequence):  [Read-Write]
        """
        ...
    @sequence.setter
    def sequence(self, value: MovieSceneSequence) -> None:
        ...
    @property
    def parent_folder(self) -> MovieSceneFolder:
        r"""
        (MovieSceneFolder):  [Read-Write]
        """
        ...
    @parent_folder.setter
    def parent_folder(self, value: MovieSceneFolder) -> None:
        ...

class MovieScenePasteSectionsParams(StructBase):
    r"""
    Paste sections params
    
    **C++ Source:**
    
    - **Module**: Sequencer
    - **File**: SequencerUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``time`` (FrameTime):  [Read-Write]
    - ``track_row_indices`` (Array[int32]):  [Read-Write]
    - ``tracks`` (Array[MovieSceneTrack]):  [Read-Write]
    """
    def __init__(self, tracks: Array[MovieSceneTrack] = [], track_row_indices: Array[int] = [], time: FrameTime = [[0], 0.000000]) -> None:
        ...
    @property
    def tracks(self) -> Array[MovieSceneTrack]:
        r"""
        (Array[MovieSceneTrack]):  [Read-Write]
        """
        ...
    @tracks.setter
    def tracks(self, value: Array[MovieSceneTrack]) -> None:
        ...
    @property
    def track_row_indices(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write]
        """
        ...
    @track_row_indices.setter
    def track_row_indices(self, value: Array[int]) -> None:
        ...
    @property
    def time(self) -> FrameTime:
        r"""
        (FrameTime):  [Read-Write]
        """
        ...
    @time.setter
    def time(self, value: FrameTime) -> None:
        ...

class MovieScenePasteTracksParams(StructBase):
    r"""
    Paste tracks params
    
    **C++ Source:**
    
    - **Module**: Sequencer
    - **File**: SequencerUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bindings`` (Array[MovieSceneBindingProxy]):  [Read-Write]
    - ``folders`` (Array[MovieSceneFolder]):  [Read-Write]
    - ``parent_folder`` (MovieSceneFolder):  [Read-Write]
    - ``sequence`` (MovieSceneSequence):  [Read-Write]
    """
    def __init__(self, sequence: MovieSceneSequence = None, bindings: Array[MovieSceneBindingProxy] = [], parent_folder: MovieSceneFolder = None, folders: Array[MovieSceneFolder] = []) -> None:
        ...
    @property
    def sequence(self) -> MovieSceneSequence:
        r"""
        (MovieSceneSequence):  [Read-Write]
        """
        ...
    @sequence.setter
    def sequence(self, value: MovieSceneSequence) -> None:
        ...
    @property
    def bindings(self) -> Array[MovieSceneBindingProxy]:
        r"""
        (Array[MovieSceneBindingProxy]):  [Read-Write]
        """
        ...
    @bindings.setter
    def bindings(self, value: Array[MovieSceneBindingProxy]) -> None:
        ...
    @property
    def parent_folder(self) -> MovieSceneFolder:
        r"""
        (MovieSceneFolder):  [Read-Write]
        """
        ...
    @parent_folder.setter
    def parent_folder(self, value: MovieSceneFolder) -> None:
        ...
    @property
    def folders(self) -> Array[MovieSceneFolder]:
        r"""
        (Array[MovieSceneFolder]):  [Read-Write]
        """
        ...
    @folders.setter
    def folders(self, value: Array[MovieSceneFolder]) -> None:
        ...

class MovieSceneBindingProxy(StructBase):
    r"""
    Movie Scene Binding Proxy represents the binding ID (an FGuid) and the corresponding sequence that it relates to.
    This is primarily used for scripting where there is no support for FMovieSceneSequenceID and use cases where
    managing multiple bindings with their corresponding sequences is necessary.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneBindingProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``binding_id`` (Guid):  [Read-Write]
    - ``sequence`` (MovieSceneSequence):  [Read-Write]
    """
    def __init__(self, binding_id: Guid = [], sequence: MovieSceneSequence = None) -> None:
        ...
    @property
    def binding_id(self) -> Guid:
        r"""
        (Guid):  [Read-Only]
        """
        ...
    @property
    def sequence(self) -> MovieSceneSequence:
        r"""
        (MovieSceneSequence):  [Read-Only]
        """
        ...
    def set_spawnable_binding_id(self, spawnable_binding_id: MovieSceneObjectBindingID) -> None:
        r"""
        x.set_spawnable_binding_id(spawnable_binding_id) -> None
        Set the spawnable id that the possessable binding should possess
        
        Args:
            spawnable_binding_id (MovieSceneObjectBindingID): The spawnable's binding id
        """
        ...
    def set_sorting_order(self, sorting_order: int) -> None:
        r"""
        x.set_sorting_order(sorting_order) -> None
        Set the sorting order for this binding
        
        Args:
            sorting_order (int32): The sorting order to set
        """
        ...
    def set_parent(self, parent_binding: MovieSceneBindingProxy) -> None:
        r"""
        x.set_parent(parent_binding) -> None
        Set the parent to this binding
        
        Args:
            parent_binding (MovieSceneBindingProxy): The parent to set the InBinding to
        """
        ...
    def set_name(self, name: str) -> None:
        r"""
        x.set_name(name) -> None
        Set this binding's object non-display name
        
        Args:
            name (str): The name of the binding
        """
        ...
    def set_display_name(self, display_name: Text) -> None:
        r"""
        x.set_display_name(display_name) -> None
        Set this binding's name
        
        Args:
            display_name (Text):
        """
        ...
    def remove_track(self, track_to_remove: MovieSceneTrack) -> None:
        r"""
        x.remove_track(track_to_remove) -> None
        Remove the specified track from this binding
        
        Args:
            track_to_remove (MovieSceneTrack): The track to remove
        """
        ...
    def remove(self) -> None:
        r"""
        x.remove() -> None
        Remove the specified binding
        """
        ...
    def move_binding_contents(self, destination_binding_id: MovieSceneBindingProxy) -> None:
        r"""
        x.move_binding_contents(destination_binding_id) -> None
        Move all the contents (tracks, child bindings) of the specified binding ID onto another
        
        Args:
            destination_binding_id (MovieSceneBindingProxy): The identifier of the binding ID to move the contents to
        """
        ...
    def is_valid(self) -> bool:
        r"""
        x.is_valid() -> bool
        Check whether the specified binding is valid
        
        Returns:
            bool:
        """
        ...
    def get_tracks(self) -> Array[MovieSceneTrack]:
        r"""
        x.get_tracks() -> Array[MovieSceneTrack]
        Get all the tracks stored within this binding
        
        Returns:
            Array[MovieSceneTrack]: An array containing all the binding's tracks
        """
        ...
    def get_sorting_order(self) -> int:
        r"""
        x.get_sorting_order() -> int32
        Get the sorting order for this binding
        
        Returns:
            int32: The sorting order of the requested binding
        """
        ...
    def get_possessed_object_class(self) -> Class:
        r"""
        x.get_possessed_object_class() -> type(Class)
        Get this binding's possessed object class
        
        Returns:
            type(Class): The possessed object class of the binding
        """
        ...
    def get_parent(self) -> MovieSceneBindingProxy:
        r"""
        x.get_parent() -> MovieSceneBindingProxy
        Get the parent of this binding
        
        Returns:
            MovieSceneBindingProxy: The binding's parent
        """
        ...
    def get_object_template(self) -> Object:
        r"""
        x.get_object_template() -> Object
        Get this binding's object template
        
        Returns:
            Object: The object template of the binding
        """
        ...
    def get_name(self) -> str:
        r"""
        x.get_name() -> str
        Get this binding's object non-display name
        
        Returns:
            str: The name of the binding
        """
        ...
    def get_id(self) -> Guid:
        r"""
        x.get_id() -> Guid
        Get this binding's ID
        
        Returns:
            Guid: The guid that uniquely represents this binding
        """
        ...
    def get_display_name(self) -> Text:
        r"""
        x.get_display_name() -> Text
        Get this binding's name
        
        Returns:
            Text: The display name of the binding
        """
        ...
    def get_child_possessables(self) -> Array[MovieSceneBindingProxy]:
        r"""
        x.get_child_possessables() -> Array[MovieSceneBindingProxy]
        Get all the children of this binding
        
        Returns:
            Array[MovieSceneBindingProxy]: An array containing all the binding's children
        """
        ...
    def find_tracks_by_type(self, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        x.find_tracks_by_type(track_type) -> Array[MovieSceneTrack]
        Find all tracks within a given binding of the specified type
        
        Args:
            track_type (type(Class)): A UMovieSceneTrack class type specifying which types of track to return
        
        Returns:
            Array[MovieSceneTrack]: An array containing any tracks that match the type specified
        """
        ...
    def find_tracks_by_exact_type(self, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        x.find_tracks_by_exact_type(track_type) -> Array[MovieSceneTrack]
        Find all tracks within a given binding of the specified type, not allowing sub-classed types
        
        Args:
            track_type (type(Class)): A UMovieSceneTrack class type specifying the exact types of track to return
        
        Returns:
            Array[MovieSceneTrack]: An array containing any tracks that are exactly the same as the type specified
        """
        ...
    def add_track(self, track_type: Class) -> MovieSceneTrack:
        r"""
        x.add_track(track_type) -> MovieSceneTrack
        Add a new track to the specified binding
        
        Args:
            track_type (type(Class)): A UMovieSceneTrack class type specifying the type of track to create
        
        Returns:
            MovieSceneTrack: The newly created track, if successful
        """
        ...

class SequencerBindingProxy(MovieSceneBindingProxy):
    r"""
    deprecated: 'SequencerBindingProxy' was renamed to 'MovieSceneBindingProxy'.
    """
    def __init__(self, binding_id: Guid = [], sequence: MovieSceneSequence = None) -> None:
        ...

class MovieScenePasteBindingsParams(StructBase):
    r"""
    Paste bindings params
    
    **C++ Source:**
    
    - **Module**: Sequencer
    - **File**: SequencerUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bindings`` (Array[MovieSceneBindingProxy]):  [Read-Write]
    - ``duplicate_existing_actors`` (bool):  [Read-Write]
    - ``folders`` (Array[MovieSceneFolder]):  [Read-Write]
    - ``parent_folder`` (MovieSceneFolder):  [Read-Write]
    """
    def __init__(self, bindings: Array[MovieSceneBindingProxy] = [], parent_folder: MovieSceneFolder = None, folders: Array[MovieSceneFolder] = [], duplicate_existing_actors: bool = False) -> None:
        ...
    @property
    def bindings(self) -> Array[MovieSceneBindingProxy]:
        r"""
        (Array[MovieSceneBindingProxy]):  [Read-Write]
        """
        ...
    @bindings.setter
    def bindings(self, value: Array[MovieSceneBindingProxy]) -> None:
        ...
    @property
    def parent_folder(self) -> MovieSceneFolder:
        r"""
        (MovieSceneFolder):  [Read-Write]
        """
        ...
    @parent_folder.setter
    def parent_folder(self, value: MovieSceneFolder) -> None:
        ...
    @property
    def folders(self) -> Array[MovieSceneFolder]:
        r"""
        (Array[MovieSceneFolder]):  [Read-Write]
        """
        ...
    @folders.setter
    def folders(self, value: Array[MovieSceneFolder]) -> None:
        ...
    @property
    def duplicate_existing_actors(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @duplicate_existing_actors.setter
    def duplicate_existing_actors(self, value: bool) -> None:
        ...

class VREditorFloatingUICreationContext(StructBase):
    r"""
    Creation parameters for AVREditorFloatingUI
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorFloatingUI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``editor_ui_size`` (float):  [Read-Write] Optional override for "VREd.EditorUISize". Leave at 0 for default.
    - ``hide_window_handles`` (bool):  [Read-Write] Turn off handles under window? (X-To-Close, movement bar...)
    - ``mask_out_widget_background`` (bool):  [Read-Write] Turn off the widget's background to create a see-through look.
    - ``no_close_button`` (bool):  [Read-Write] If bHideWindowHandles is false, this window doesn't have a close button. (
    - ``panel_id`` (Name):  [Read-Write] ID that the UI system will use to identify the panel. MUST BE UNIQUE!
    - ``panel_mesh`` (StaticMesh):  [Read-Write] Optional custom mesh to use for the VR window.
    - ``panel_size`` (Vector2D):  [Read-Write] Panel size. Should match the size of the UMG passed in.
    - ``panel_spawn_offset`` (Transform):  [Read-Write] Optional offset from HMD where the window opens. Pass FTransform::Identity for default logic - window will open at controller location.
    - ``parent_actor`` (Actor):  [Read-Write]
    - ``widget_class`` (type(Class)):  [Read-Write] Widget to open in the VR window. null to close an open window (if if matches the PanelID)
    """
    def __init__(self, widget_class: Class = None, panel_id: Name = "None", parent_actor: Actor = None, panel_spawn_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], panel_size: Vector2D = [0.000000, 0.000000], panel_mesh: StaticMesh = None, editor_ui_size: float = 0.000000, hide_window_handles: bool = False, mask_out_widget_background: bool = False, no_close_button: bool = False) -> None:
        ...
    @property
    def widget_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Widget to open in the VR window. null to close an open window (if if matches the PanelID)
        """
        ...
    @widget_class.setter
    def widget_class(self, value: Class) -> None:
        ...
    @property
    def panel_id(self) -> Name:
        r"""
        (Name):  [Read-Write] ID that the UI system will use to identify the panel. MUST BE UNIQUE!
        """
        ...
    @panel_id.setter
    def panel_id(self, value: Name) -> None:
        ...
    @property
    def parent_actor(self) -> Actor:
        r"""
        (Actor):  [Read-Write]
        """
        ...
    @parent_actor.setter
    def parent_actor(self, value: Actor) -> None:
        ...
    @property
    def panel_spawn_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Optional offset from HMD where the window opens. Pass FTransform::Identity for default logic - window will open at controller location.
        """
        ...
    @panel_spawn_offset.setter
    def panel_spawn_offset(self, value: Transform) -> None:
        ...
    @property
    def panel_size(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Panel size. Should match the size of the UMG passed in.
        """
        ...
    @panel_size.setter
    def panel_size(self, value: Vector2D) -> None:
        ...
    @property
    def panel_mesh(self) -> StaticMesh:
        r"""
        (StaticMesh):  [Read-Write] Optional custom mesh to use for the VR window.
        """
        ...
    @panel_mesh.setter
    def panel_mesh(self, value: StaticMesh) -> None:
        ...
    @property
    def editor_ui_size(self) -> float:
        r"""
        (float):  [Read-Write] Optional override for "VREd.EditorUISize". Leave at 0 for default.
        """
        ...
    @editor_ui_size.setter
    def editor_ui_size(self, value: float) -> None:
        ...
    @property
    def hide_window_handles(self) -> bool:
        r"""
        (bool):  [Read-Write] Turn off handles under window? (X-To-Close, movement bar...)
        """
        ...
    @hide_window_handles.setter
    def hide_window_handles(self, value: bool) -> None:
        ...
    @property
    def mask_out_widget_background(self) -> bool:
        r"""
        (bool):  [Read-Write] Turn off the widget's background to create a see-through look.
        """
        ...
    @mask_out_widget_background.setter
    def mask_out_widget_background(self, value: bool) -> None:
        ...
    @property
    def no_close_button(self) -> bool:
        r"""
        (bool):  [Read-Write] If bHideWindowHandles is false, this window doesn't have a close button. (
        """
        ...
    @no_close_button.setter
    def no_close_button(self, value: bool) -> None:
        ...

class XRHMDData(StructBase):
    r"""
    XRHMDData
    
    **C++ Source:**
    
    - **Module**: HeadMountedDisplay
    - **File**: HeadMountedDisplayTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``application_instance_id`` (Guid):  [Read-Write]
    - ``device_name`` (Name):  [Read-Write]
    - ``position`` (Vector):  [Read-Write]
    - ``rotation`` (Quat):  [Read-Write]
    - ``tracking_status`` (TrackingStatus):  [Read-Write]
    - ``valid`` (bool):  [Read-Write]
    """
    def __init__(self, valid: bool = False, device_name: Name = "None", application_instance_id: Guid = [], tracking_status: TrackingStatus = TrackingStatus.NOT_TRACKED, position: Vector = [0.000000, 0.000000, 0.000000], rotation: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def valid(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def device_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def application_instance_id(self) -> Guid:
        r"""
        (Guid):  [Read-Only]
        """
        ...
    @property
    def tracking_status(self) -> TrackingStatus:
        r"""
        (TrackingStatus):  [Read-Only]
        """
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class XRMotionControllerData(StructBase):
    r"""
    XRMotion Controller Data
    
    **C++ Source:**
    
    - **Module**: HeadMountedDisplay
    - **File**: HeadMountedDisplayTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``aim_position`` (Vector):  [Read-Write] For handheld controllers, gives a vector for pointing at objects
    - ``aim_rotation`` (Quat):  [Read-Write] For handheld controllers, gives a quaternion for pointing at objects
    - ``application_instance_id`` (Guid):  [Read-Write]
    - ``device_name`` (Name):  [Read-Write]
    - ``device_visual_type`` (XRVisualType):  [Read-Write]
    - ``grip_position`` (Vector):  [Read-Write] Vector representing an object being held in the player's hand
    - ``grip_rotation`` (Quat):  [Read-Write] Quaternion representing an object being held in the player's hand
    - ``hand_index`` (ControllerHand):  [Read-Write]
    - ``hand_key_positions`` (Array[Vector]):  [Read-Write] The indices of this array are the values of EHandKeypoint (Palm, Wrist, ThumbMetacarpal, etc).
    - ``hand_key_radii`` (Array[float]):  [Read-Write] The indices of this array are the values of EHandKeypoint (Palm, Wrist, ThumbMetacarpal, etc).
    - ``hand_key_rotations`` (Array[Quat]):  [Read-Write] The indices of this array are the values of EHandKeypoint (Palm, Wrist, ThumbMetacarpal, etc).
    - ``is_grasped`` (bool):  [Read-Write]
    - ``palm_position`` (Vector):  [Read-Write] For handheld controllers, gives a vector for representing the hand
    - ``palm_rotation`` (Quat):  [Read-Write] For handheld controllers, gives a quaternion for representing the hand
    - ``tracking_status`` (TrackingStatus):  [Read-Write]
    - ``valid`` (bool):  [Read-Write]
    """
    def __init__(self, valid: bool = False, device_name: Name = "None", application_instance_id: Guid = [], device_visual_type: XRVisualType = XRVisualType.CONTROLLER, hand_index: ControllerHand = ControllerHand.LEFT, tracking_status: TrackingStatus = TrackingStatus.NOT_TRACKED, grip_position: Vector = [0.000000, 0.000000, 0.000000], grip_rotation: Quat = [0.000000, 0.000000, 0.000000, 1.000000], aim_position: Vector = [0.000000, 0.000000, 0.000000], aim_rotation: Quat = [0.000000, 0.000000, 0.000000, 1.000000], palm_position: Vector = [0.000000, 0.000000, 0.000000], palm_rotation: Quat = [0.000000, 0.000000, 0.000000, 1.000000], hand_key_positions: Array[Vector] = [], hand_key_rotations: Array[Quat] = [], hand_key_radii: Array[float] = [], is_grasped: bool = False) -> None:
        ...
    @property
    def valid(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def device_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def application_instance_id(self) -> Guid:
        r"""
        (Guid):  [Read-Only]
        """
        ...
    @property
    def device_visual_type(self) -> XRVisualType:
        r"""
        (XRVisualType):  [Read-Only]
        """
        ...
    @property
    def hand_index(self) -> ControllerHand:
        r"""
        (ControllerHand):  [Read-Only]
        """
        ...
    @property
    def tracking_status(self) -> TrackingStatus:
        r"""
        (TrackingStatus):  [Read-Only]
        """
        ...
    @property
    def grip_position(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Vector representing an object being held in the player's hand
        """
        ...
    @property
    def grip_rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Only] Quaternion representing an object being held in the player's hand
        """
        ...
    @property
    def aim_position(self) -> Vector:
        r"""
        (Vector):  [Read-Only] For handheld controllers, gives a vector for pointing at objects
        """
        ...
    @property
    def aim_rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Only] For handheld controllers, gives a quaternion for pointing at objects
        """
        ...
    @property
    def palm_position(self) -> Vector:
        r"""
        (Vector):  [Read-Only] For handheld controllers, gives a vector for representing the hand
        """
        ...
    @property
    def palm_rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Only] For handheld controllers, gives a quaternion for representing the hand
        """
        ...
    @property
    def hand_key_positions(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Only] The indices of this array are the values of EHandKeypoint (Palm, Wrist, ThumbMetacarpal, etc).
        """
        ...
    @property
    def hand_key_rotations(self) -> Array[Quat]:
        r"""
        (Array[Quat]):  [Read-Only] The indices of this array are the values of EHandKeypoint (Palm, Wrist, ThumbMetacarpal, etc).
        """
        ...
    @property
    def hand_key_radii(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Only] The indices of this array are the values of EHandKeypoint (Palm, Wrist, ThumbMetacarpal, etc).
        """
        ...
    @property
    def is_grasped(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class XRDeviceId(StructBase):
    r"""
    XRDevice Id
    
    **C++ Source:**
    
    - **Module**: HeadMountedDisplay
    - **File**: IIdentifiableXRDevice.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``device_id`` (int32):  [Read-Write]
    - ``system_name`` (Name):  [Read-Write]
    """
    def __init__(self, system_name: Name = "None", device_id: int = 0) -> None:
        ...
    @property
    def system_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def device_id(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class ViewportActionKeyInput(StructBase):
    r"""
    Represents a generic action
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: ViewportInteractionTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``action_type`` (Name):  [Read-Write] The name of this action
    - ``event`` (InputEventType):  [Read-Write] Input event
    """
    def __init__(self, action_type: Name = "None", event: InputEventType = InputEventType.IE_PRESSED) -> None:
        ...
    @property
    def action_type(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of this action
        """
        ...
    @property
    def event(self) -> InputEventType:
        r"""
        (InputEventType):  [Read-Only] Input event
        """
        ...

class GameplayTag(StructBase):
    r"""
    A single gameplay tag, which represents a hierarchical name of the form x.y that is registered in the GameplayTagsManager
    You can filter the gameplay tags displayed in the editor using, meta = (Categories = "Tag1.Tag2.Tag3"))
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``tag_name`` (Name):  [Read-Only] This Tags Name
    """
    def __init__(self, value: GameplayTag = ["None"]) -> None:
        ...

class GameplayTagContainer(StructBase):
    r"""
    A Tag Container holds a collection of FGameplayTags, tags are included explicitly by adding them, and implicitly from adding child tags
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``gameplay_tags`` (Array[GameplayTag]):  [Read-Only] Array of gameplay tags
    """
    def __init__(self, gameplay_tags: Array[GameplayTag] = []) -> None:
        ...
    @property
    def gameplay_tags(self) -> Array[GameplayTag]:
        r"""
        (Array[GameplayTag]):  [Read-Only] Array of gameplay tags
        """
        ...

class GameplayTagQuery(StructBase):
    r"""
    An FGameplayTagQuery is a logical query that can be run against an FGameplayTagContainer.  A query that succeeds is said to "match".
    Queries are logical expressions that can test the intersection properties of another tag container (all, any, or none), or the matching state of a set of sub-expressions
    (all, any, or none). This allows queries to be arbitrarily recursive and very expressive.  For instance, if you wanted to test if a given tag container contained tags
    ((A && B) || (C)) && (!D), you would construct your query in the form ALL( ANY( ALL(A,B), ALL(C) ), NONE(D) )
    
    You can expose the query structs to Blueprints and edit them with a custom editor, or you can construct them natively in code.
    
    Example of how to build a query via code:
        FGameplayTagQuery Q;
        Q.BuildQuery(
                FGameplayTagQueryExpression()
                .AllTagsMatch()
                .AddTag(FGameplayTag::RequestGameplayTag(FName(TEXT("Animal.Mammal.Dog.Corgi"))))
                .AddTag(FGameplayTag::RequestGameplayTag(FName(TEXT("Plant.Tree.Spruce"))))
                );
    
    Queries are internally represented as a byte stream that is memory-efficient and can be evaluated quickly at runtime.
    Note: these have an extensive details and graph pin customization for editing, so there is no need to expose the internals to Blueprints.
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_description`` (str):  [Read-Write] Auto-generated string describing the query
    - ``query_token_stream`` (Array[uint8]):  [Read-Write] Stream representation of the actual hierarchical query
    - ``tag_dictionary`` (Array[GameplayTag]):  [Read-Write] List of tags referenced by this entire query. Token stream stored indices into this list.
    - ``token_stream_version`` (int32):  [Read-Write] Versioning for future token stream protocol changes. See EGameplayTagQueryStreamVersion.
    - ``user_description`` (str):  [Read-Write] User-provided string describing the query
    """
    def __init__(self, tag_query: GameplayTagQuery = []) -> None:
        ...

class TableRowBase(StructBase):
    r"""
    Base class for all table row structs to inherit from.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataTable.h
    
    """
    def __init__(self) -> None:
        ...

class GameplayTagTableRow(TableRowBase):
    r"""
    Simple struct for a table row in the gameplay tag table and element in the ini list
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagsManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``dev_comment`` (str):  [Read-Write] Developer comment clarifying the usage of a particular tag, not user facing
    - ``tag`` (Name):  [Read-Write] Tag specified in the table
    """
    def __init__(self, tag: Name = "None", dev_comment: str = "") -> None:
        ...
    @property
    def tag(self) -> Name:
        r"""
        (Name):  [Read-Only] Tag specified in the table
        """
        ...
    @property
    def dev_comment(self) -> str:
        r"""
        (str):  [Read-Only] Developer comment clarifying the usage of a particular tag, not user facing
        """
        ...

class RestrictedGameplayTagTableRow(GameplayTagTableRow):
    r"""
    Simple struct for a table row in the restricted gameplay tag table and element in the ini list
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagsManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_non_restricted_children`` (bool):  [Read-Write] Tag specified in the table
    - ``dev_comment`` (str):  [Read-Write] Developer comment clarifying the usage of a particular tag, not user facing
    - ``tag`` (Name):  [Read-Write] Tag specified in the table
    """
    def __init__(self, tag: Name = "None", dev_comment: str = "", allow_non_restricted_children: bool = False) -> None:
        ...
    @property
    def allow_non_restricted_children(self) -> bool:
        r"""
        (bool):  [Read-Only] Tag specified in the table
        """
        ...

class EnvNamedValue(StructBase):
    r"""
    Env Named Value
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``param_name`` (Name):  [Read-Write]
    - ``param_type`` (AIParamType):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, param_name: Name = "None", param_type: AIParamType = AIParamType.FLOAT, value: float = 0.000000) -> None:
        ...
    @property
    def param_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @param_name.setter
    def param_name(self, value: Name) -> None:
        ...
    @property
    def param_type(self) -> AIParamType:
        r"""
        (AIParamType):  [Read-Write]
        """
        ...
    @param_type.setter
    def param_type(self, value: AIParamType) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class EnvQueryResult(StructBase):
    r"""
    Env Query Result
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item_type`` (type(Class)):  [Read-Write] type of generated items
    - ``option_index`` (int32):  [Read-Write] index of query option, that generated items
    - ``query_id`` (int32):  [Read-Write] instance ID
    """
    def __init__(self, item_type: Class = None, option_index: int = 0, query_id: int = 0) -> None:
        ...
    @property
    def item_type(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] type of generated items
        """
        ...
    @property
    def option_index(self) -> int:
        r"""
        (int32):  [Read-Only] index of query option, that generated items
        """
        ...
    @property
    def query_id(self) -> int:
        r"""
        (int32):  [Read-Only] instance ID
        """
        ...

class AIDynamicParam(StructBase):
    r"""
    AIDynamic Param
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bb_key`` (BlackboardKeySelector):  [Read-Write]
    - ``param_name`` (Name):  [Read-Only]
    - ``param_type`` (AIParamType):  [Read-Only]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, param_name: Name = "None", param_type: AIParamType = AIParamType.FLOAT, value: float = 0.000000, bb_key: BlackboardKeySelector = [[], "None", None, 65535, False]) -> None:
        ...
    @property
    def param_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def param_type(self) -> AIParamType:
        r"""
        (AIParamType):  [Read-Only]
        """
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def bb_key(self) -> BlackboardKeySelector:
        r"""
        (BlackboardKeySelector):  [Read-Write]
        """
        ...
    @bb_key.setter
    def bb_key(self, value: BlackboardKeySelector) -> None:
        ...

class BlackboardKeySelector(StructBase):
    r"""
    helper struct for defining types of allowed blackboard entries
    (e.g. only entries holding points and objects derived form actor class)
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BehaviorTreeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allowed_types`` (Array[BlackboardKeyType]):  [Read-Write] array of allowed types with additional properties (e.g. uobject's base class)
      EditAnywhere is required for FBlackboardSelectorDetails::CacheBlackboardData()
    - ``none_is_allowed_value`` (bool):  [Read-Write]
    - ``selected_key_id`` (int32):  [Read-Write] ID of selected key
    - ``selected_key_name`` (Name):  [Read-Write] name of selected key
    - ``selected_key_type`` (type(Class)):  [Read-Write] class of selected key
    """
    def __init__(self, allowed_types: Array[BlackboardKeyType] = [], selected_key_name: Name = "None", selected_key_type: Class = None, selected_key_id: int = 0, none_is_allowed_value: bool = False) -> None:
        ...
    @property
    def allowed_types(self) -> Array[BlackboardKeyType]:
        r"""
        (Array[BlackboardKeyType]):  [Read-Write] array of allowed types with additional properties (e.g. uobject's base class)
        EditAnywhere is required for FBlackboardSelectorDetails::CacheBlackboardData()
        """
        ...
    @allowed_types.setter
    def allowed_types(self, value: Array[BlackboardKeyType]) -> None:
        ...
    @property
    def selected_key_name(self) -> Name:
        r"""
        (Name):  [Read-Write] name of selected key
        """
        ...
    @selected_key_name.setter
    def selected_key_name(self, value: Name) -> None:
        ...
    @property
    def selected_key_type(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] class of selected key
        """
        ...
    @selected_key_type.setter
    def selected_key_type(self, value: Class) -> None:
        ...
    @property
    def selected_key_id(self) -> int:
        r"""
        (int32):  [Read-Write] ID of selected key
        """
        ...
    @selected_key_id.setter
    def selected_key_id(self, value: int) -> None:
        ...
    @property
    def none_is_allowed_value(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @none_is_allowed_value.setter
    def none_is_allowed_value(self, value: bool) -> None:
        ...

class GenericTeamId(StructBase):
    r"""
    Generic Team Id
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: GenericTeamAgentInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``team_id`` (uint8):  [Read-Write]
    """
    def __init__(self, team_id: int = 0) -> None:
        ...
    @property
    def team_id(self) -> int:
        r"""
        (uint8):  [Read-Write]
        """
        ...
    @team_id.setter
    def team_id(self, value: int) -> None:
        ...

class ActorPerceptionBlueprintInfo(StructBase):
    r"""
    Actor Perception Blueprint Info
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_friendly`` (bool):  [Read-Write]
    - ``is_hostile`` (bool):  [Read-Write]
    - ``last_sensed_stimuli`` (Array[AIStimulus]):  [Read-Write]
    - ``target`` (Actor):  [Read-Write]
    """
    def __init__(self, target: Actor = None, last_sensed_stimuli: Array[AIStimulus] = [], is_hostile: bool = False, is_friendly: bool = False) -> None:
        ...
    @property
    def target(self) -> Actor:
        r"""
        (Actor):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Actor) -> None:
        ...
    @property
    def last_sensed_stimuli(self) -> Array[AIStimulus]:
        r"""
        (Array[AIStimulus]):  [Read-Write]
        """
        ...
    @last_sensed_stimuli.setter
    def last_sensed_stimuli(self, value: Array[AIStimulus]) -> None:
        ...
    @property
    def is_hostile(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_hostile.setter
    def is_hostile(self, value: bool) -> None:
        ...
    @property
    def is_friendly(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_friendly.setter
    def is_friendly(self, value: bool) -> None:
        ...

class AISenseAffiliationFilter(StructBase):
    r"""
    AISense Affiliation Filter
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``detect_enemies`` (bool):  [Read-Write]
    - ``detect_friendlies`` (bool):  [Read-Write]
    - ``detect_neutrals`` (bool):  [Read-Write]
    """
    def __init__(self, detect_enemies: bool = False, detect_neutrals: bool = False, detect_friendlies: bool = False) -> None:
        ...
    @property
    def detect_enemies(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def detect_neutrals(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def detect_friendlies(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class AIDamageEvent(StructBase):
    r"""
    AIDamage Event
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISense_Damage.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``amount`` (float):  [Read-Write] Damage taken by DamagedActor.
      Note: 0-damage events do not get ignored
    - ``damaged_actor`` (Actor):  [Read-Write] Damaged actor
    - ``hit_location`` (Vector):  [Read-Write] Event's additional spatial information
      TODO: document
    - ``instigator`` (Actor):  [Read-Write] Actor that instigated damage. Can be None
    - ``location`` (Vector):  [Read-Write] Event's "Location", or what will be later treated as the perceived location for this sense.
          If not set, HitLocation will be used, if that is unset too DamagedActor's location
    - ``tag`` (Name):  [Read-Write] Optional named identifier for the damage.
    """
    def __init__(self, amount: float = 0.000000, location: Vector = [0.000000, 0.000000, 0.000000], hit_location: Vector = [0.000000, 0.000000, 0.000000], damaged_actor: Actor = None, instigator: Actor = None, tag: Name = "None") -> None:
        ...
    @property
    def amount(self) -> float:
        r"""
        (float):  [Read-Write] Damage taken by DamagedActor.
        Note: 0-damage events do not get ignored
        """
        ...
    @amount.setter
    def amount(self, value: float) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Event's "Location", or what will be later treated as the perceived location for this sense.
            If not set, HitLocation will be used, if that is unset too DamagedActor's location
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def hit_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Event's additional spatial information
        TODO: document
        """
        ...
    @hit_location.setter
    def hit_location(self, value: Vector) -> None:
        ...
    @property
    def damaged_actor(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Damaged actor
        """
        ...
    @damaged_actor.setter
    def damaged_actor(self, value: Actor) -> None:
        ...
    @property
    def instigator(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Actor that instigated damage. Can be None
        """
        ...
    @instigator.setter
    def instigator(self, value: Actor) -> None:
        ...
    @property
    def tag(self) -> Name:
        r"""
        (Name):  [Read-Write] Optional named identifier for the damage.
        """
        ...
    @tag.setter
    def tag(self, value: Name) -> None:
        ...

class AINoiseEvent(StructBase):
    r"""
    AINoise Event
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISense_Hearing.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``instigator`` (Actor):  [Read-Write] Actor triggering the sound.
    - ``loudness`` (float):  [Read-Write] Loudness modifier of the sound.
      If MaxRange is non-zero, this modifies the range (by multiplication).
      If there is no MaxRange, then if Square(DistanceToSound) <= Square(HearingRange * Loudness), the sound is heard, false otherwise.
    - ``max_range`` (float):  [Read-Write] Max range at which the sound can be heard. Multiplied by Loudness.
      A value of 0 indicates that there is no range limit, though listeners are still limited by their own hearing range.
    - ``noise_location`` (Vector):  [Read-Write] if not set Instigator's location will be used
    - ``tag`` (Name):  [Read-Write] Named identifier for the noise.
    """
    def __init__(self, noise_location: Vector = [0.000000, 0.000000, 0.000000], loudness: float = 0.000000, max_range: float = 0.000000, instigator: Actor = None, tag: Name = "None") -> None:
        ...
    @property
    def noise_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] if not set Instigator's location will be used
        """
        ...
    @noise_location.setter
    def noise_location(self, value: Vector) -> None:
        ...
    @property
    def loudness(self) -> float:
        r"""
        (float):  [Read-Write] Loudness modifier of the sound.
        If MaxRange is non-zero, this modifies the range (by multiplication).
        If there is no MaxRange, then if Square(DistanceToSound) <= Square(HearingRange * Loudness), the sound is heard, false otherwise.
        """
        ...
    @loudness.setter
    def loudness(self, value: float) -> None:
        ...
    @property
    def max_range(self) -> float:
        r"""
        (float):  [Read-Write] Max range at which the sound can be heard. Multiplied by Loudness.
        A value of 0 indicates that there is no range limit, though listeners are still limited by their own hearing range.
        """
        ...
    @max_range.setter
    def max_range(self, value: float) -> None:
        ...
    @property
    def instigator(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Actor triggering the sound.
        """
        ...
    @instigator.setter
    def instigator(self, value: Actor) -> None:
        ...
    @property
    def tag(self) -> Name:
        r"""
        (Name):  [Read-Write] Named identifier for the noise.
        """
        ...
    @tag.setter
    def tag(self, value: Name) -> None:
        ...

class StringValuePair(StructBase):
    r"""
    String Value Pair
    
    **C++ Source:**
    
    - **Module**: DataflowEngine
    - **File**: DataflowEngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``key`` (str):  [Read-Write]
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, key: str = "", value: str = "") -> None:
        ...
    @property
    def key(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @key.setter
    def key(self, value: str) -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...

class FieldObjectCommands(StructBase):
    r"""
    Field Commands container that will be stored in the construction script
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``meta_datas`` (Array[FieldSystemMetaData]):  [Read-Write] Commands Meta Data
    - ``root_nodes`` (Array[FieldNodeBase]):  [Read-Write] Commands Root Node
    - ``target_names`` (Array[Name]):  [Read-Write] Commands Target Name
    """
    def __init__(self, target_names: Array[Name] = [], root_nodes: Array[FieldNodeBase] = [], meta_datas: Array[FieldSystemMetaData] = []) -> None:
        ...
    @property
    def target_names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Commands Target Name
        """
        ...
    @target_names.setter
    def target_names(self, value: Array[Name]) -> None:
        ...
    @property
    def root_nodes(self) -> Array[FieldNodeBase]:
        r"""
        (Array[FieldNodeBase]):  [Read-Write] Commands Root Node
        """
        ...
    @root_nodes.setter
    def root_nodes(self, value: Array[FieldNodeBase]) -> None:
        ...
    @property
    def meta_datas(self) -> Array[FieldSystemMetaData]:
        r"""
        (Array[FieldSystemMetaData]):  [Read-Write] Commands Meta Data
        """
        ...
    @meta_datas.setter
    def meta_datas(self, value: Array[FieldSystemMetaData]) -> None:
        ...

class ChaosBreakingEventRequestSettings(StructBase):
    r"""
    Settings used to refine breaking event requests
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosBreakingEventFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max_distance`` (float):  [Read-Write] The maximum distance threshold for the results.
    - ``max_number_of_results`` (int32):  [Read-Write] The maximum number of results to return.
    - ``min_mass`` (float):  [Read-Write] The minimum mass threshold for the results.
    - ``min_radius`` (float):  [Read-Write] The minimum breaking radius threshold for the results.
    - ``min_speed`` (float):  [Read-Write] The minimum speed threshold for the results.
    - ``sort_method`` (ChaosBreakingSortMethod):  [Read-Write] The method used to sort the breaking events.
    """
    def __init__(self, max_number_of_results: int = 0, min_radius: float = 0.000000, min_speed: float = 0.000000, min_mass: float = 0.000000, max_distance: float = 0.000000, sort_method: ChaosBreakingSortMethod = ChaosBreakingSortMethod.SORT_NONE) -> None:
        ...
    @property
    def max_number_of_results(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of results to return.
        """
        ...
    @max_number_of_results.setter
    def max_number_of_results(self, value: int) -> None:
        ...
    @property
    def min_radius(self) -> float:
        r"""
        (float):  [Read-Write] The minimum breaking radius threshold for the results.
        """
        ...
    @min_radius.setter
    def min_radius(self, value: float) -> None:
        ...
    @property
    def min_speed(self) -> float:
        r"""
        (float):  [Read-Write] The minimum speed threshold for the results.
        """
        ...
    @min_speed.setter
    def min_speed(self, value: float) -> None:
        ...
    @property
    def min_mass(self) -> float:
        r"""
        (float):  [Read-Write] The minimum mass threshold for the results.
        """
        ...
    @min_mass.setter
    def min_mass(self, value: float) -> None:
        ...
    @property
    def max_distance(self) -> float:
        r"""
        (float):  [Read-Write] The maximum distance threshold for the results.
        """
        ...
    @max_distance.setter
    def max_distance(self, value: float) -> None:
        ...
    @property
    def sort_method(self) -> ChaosBreakingSortMethod:
        r"""
        (ChaosBreakingSortMethod):  [Read-Write] The method used to sort the breaking events.
        """
        ...
    @sort_method.setter
    def sort_method(self, value: ChaosBreakingSortMethod) -> None:
        ...

class ChaosCollisionEventRequestSettings(StructBase):
    r"""
    Settings used to define collision event requests
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosCollisionEventFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max_distance`` (float):  [Read-Write] The maximum distance threshold for the results.
    - ``max_number_results`` (int32):  [Read-Write] The maximum number of results to return.
    - ``min_impulse`` (float):  [Read-Write] The minimum impulse threshold for the results.
    - ``min_mass`` (float):  [Read-Write] The minimum mass threshold for the results (compared with min of particle 1 mass and particle 2 mass).
    - ``min_speed`` (float):  [Read-Write] The min speed threshold for the results (compared with min of particle 1 speed and particle 2 speed).
    - ``sort_method`` (ChaosCollisionSortMethod):  [Read-Write] The method used to sort the collision events.
    """
    def __init__(self, max_number_results: int = 0, min_mass: float = 0.000000, min_speed: float = 0.000000, min_impulse: float = 0.000000, max_distance: float = 0.000000, sort_method: ChaosCollisionSortMethod = ChaosCollisionSortMethod.SORT_NONE) -> None:
        ...
    @property
    def max_number_results(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of results to return.
        """
        ...
    @max_number_results.setter
    def max_number_results(self, value: int) -> None:
        ...
    @property
    def min_mass(self) -> float:
        r"""
        (float):  [Read-Write] The minimum mass threshold for the results (compared with min of particle 1 mass and particle 2 mass).
        """
        ...
    @min_mass.setter
    def min_mass(self, value: float) -> None:
        ...
    @property
    def min_speed(self) -> float:
        r"""
        (float):  [Read-Write] The min speed threshold for the results (compared with min of particle 1 speed and particle 2 speed).
        """
        ...
    @min_speed.setter
    def min_speed(self, value: float) -> None:
        ...
    @property
    def min_impulse(self) -> float:
        r"""
        (float):  [Read-Write] The minimum impulse threshold for the results.
        """
        ...
    @min_impulse.setter
    def min_impulse(self, value: float) -> None:
        ...
    @property
    def max_distance(self) -> float:
        r"""
        (float):  [Read-Write] The maximum distance threshold for the results.
        """
        ...
    @max_distance.setter
    def max_distance(self, value: float) -> None:
        ...
    @property
    def sort_method(self) -> ChaosCollisionSortMethod:
        r"""
        (ChaosCollisionSortMethod):  [Read-Write] The method used to sort the collision events.
        """
        ...
    @sort_method.setter
    def sort_method(self, value: ChaosCollisionSortMethod) -> None:
        ...

class ChaosRemovalEventRequestSettings(StructBase):
    r"""
    Chaos Removal Event Request Settings
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosRemovalEventFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max_distance`` (float):  [Read-Write] The maximum distance threshold for the results (if location is set on destruction event listener).
    - ``max_number_of_results`` (int32):  [Read-Write] The maximum number of results to return.
    - ``min_mass`` (float):  [Read-Write] The minimum mass treshold for the results.
    - ``sort_method`` (ChaosRemovalSortMethod):  [Read-Write] The method used to sort the removal events.
    """
    def __init__(self, max_number_of_results: int = 0, min_mass: float = 0.000000, max_distance: float = 0.000000, sort_method: ChaosRemovalSortMethod = ChaosRemovalSortMethod.SORT_NONE) -> None:
        ...
    @property
    def max_number_of_results(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of results to return.
        """
        ...
    @max_number_of_results.setter
    def max_number_of_results(self, value: int) -> None:
        ...
    @property
    def min_mass(self) -> float:
        r"""
        (float):  [Read-Write] The minimum mass treshold for the results.
        """
        ...
    @min_mass.setter
    def min_mass(self, value: float) -> None:
        ...
    @property
    def max_distance(self) -> float:
        r"""
        (float):  [Read-Write] The maximum distance threshold for the results (if location is set on destruction event listener).
        """
        ...
    @max_distance.setter
    def max_distance(self, value: float) -> None:
        ...
    @property
    def sort_method(self) -> ChaosRemovalSortMethod:
        r"""
        (ChaosRemovalSortMethod):  [Read-Write] The method used to sort the removal events.
        """
        ...
    @sort_method.setter
    def sort_method(self, value: ChaosRemovalSortMethod) -> None:
        ...

class ChaosTrailingEventRequestSettings(StructBase):
    r"""
    Chaos Trailing Event Request Settings
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosTrailingEventFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max_distance`` (float):  [Read-Write] The maximum distance threshold for the results (if location is set on destruction event listener).
    - ``max_number_of_results`` (int32):  [Read-Write] The maximum number of results to return.
    - ``min_angular_speed`` (float):  [Read-Write] The minimum angular speed threshold for the results.
    - ``min_mass`` (float):  [Read-Write] The minimum mass treshold for the results.
    - ``min_speed`` (float):  [Read-Write] The minimum speed threshold for the results.
    - ``sort_method`` (ChaosTrailingSortMethod):  [Read-Write] The method used to sort the breaking events.
    """
    def __init__(self, max_number_of_results: int = 0, min_mass: float = 0.000000, min_speed: float = 0.000000, min_angular_speed: float = 0.000000, max_distance: float = 0.000000, sort_method: ChaosTrailingSortMethod = ChaosTrailingSortMethod.SORT_NONE) -> None:
        ...
    @property
    def max_number_of_results(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of results to return.
        """
        ...
    @max_number_of_results.setter
    def max_number_of_results(self, value: int) -> None:
        ...
    @property
    def min_mass(self) -> float:
        r"""
        (float):  [Read-Write] The minimum mass treshold for the results.
        """
        ...
    @min_mass.setter
    def min_mass(self, value: float) -> None:
        ...
    @property
    def min_speed(self) -> float:
        r"""
        (float):  [Read-Write] The minimum speed threshold for the results.
        """
        ...
    @min_speed.setter
    def min_speed(self, value: float) -> None:
        ...
    @property
    def min_angular_speed(self) -> float:
        r"""
        (float):  [Read-Write] The minimum angular speed threshold for the results.
        """
        ...
    @min_angular_speed.setter
    def min_angular_speed(self, value: float) -> None:
        ...
    @property
    def max_distance(self) -> float:
        r"""
        (float):  [Read-Write] The maximum distance threshold for the results (if location is set on destruction event listener).
        """
        ...
    @max_distance.setter
    def max_distance(self, value: float) -> None:
        ...
    @property
    def sort_method(self) -> ChaosTrailingSortMethod:
        r"""
        (ChaosTrailingSortMethod):  [Read-Write] The method used to sort the breaking events.
        """
        ...
    @sort_method.setter
    def sort_method(self, value: ChaosTrailingSortMethod) -> None:
        ...

class GeometryCollectionSource(StructBase):
    r"""
    Geometry Collection Source
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``add_internal_materials`` (bool):  [Read-Write] (Legacy) Whether source materials will be duplicated to create new slots for internal materials, or existing odd materials will be considered internal. (For non-Geometry Collection inputs only.)
    - ``instance_custom_data`` (Array[float]):  [Read-Write]
    - ``local_transform`` (Transform):  [Read-Write]
    - ``set_internal_from_material_index`` (bool):  [Read-Write] Whether to set the 'internal' flag for faces with odd-numbered materials slots.
    - ``source_geometry_object`` (SoftObjectPath):  [Read-Write]
    - ``source_material`` (Array[MaterialInterface]):  [Read-Write]
    - ``split_components`` (bool):  [Read-Write] Whether individual source mesh components should be split into separate pieces of geometry based on mesh connectivity. If checked, triangles that are not topologically connected will be assigned separate bones. (For non-Geometry Collection inputs only.)
    """
    def __init__(self, source_geometry_object: SoftObjectPath = [""], local_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], source_material: Array[MaterialInterface] = [], instance_custom_data: Array[float] = [], add_internal_materials: bool = False, split_components: bool = False, set_internal_from_material_index: bool = False) -> None:
        ...
    @property
    def source_geometry_object(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Write]
        """
        ...
    @source_geometry_object.setter
    def source_geometry_object(self, value: SoftObjectPath) -> None:
        ...
    @property
    def local_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @local_transform.setter
    def local_transform(self, value: Transform) -> None:
        ...
    @property
    def source_material(self) -> Array[MaterialInterface]:
        r"""
        (Array[MaterialInterface]):  [Read-Write]
        """
        ...
    @source_material.setter
    def source_material(self, value: Array[MaterialInterface]) -> None:
        ...
    @property
    def instance_custom_data(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Write]
        """
        ...
    @instance_custom_data.setter
    def instance_custom_data(self, value: Array[float]) -> None:
        ...
    @property
    def add_internal_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] (Legacy) Whether source materials will be duplicated to create new slots for internal materials, or existing odd materials will be considered internal. (For non-Geometry Collection inputs only.)
        """
        ...
    @add_internal_materials.setter
    def add_internal_materials(self, value: bool) -> None:
        ...
    @property
    def split_components(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether individual source mesh components should be split into separate pieces of geometry based on mesh connectivity. If checked, triangles that are not topologically connected will be assigned separate bones. (For non-Geometry Collection inputs only.)
        """
        ...
    @split_components.setter
    def split_components(self, value: bool) -> None:
        ...
    @property
    def set_internal_from_material_index(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to set the 'internal' flag for faces with odd-numbered materials slots.
        """
        ...
    @set_internal_from_material_index.setter
    def set_internal_from_material_index(self, value: bool) -> None:
        ...

class GeometryCollectionAutoInstanceMesh(StructBase):
    r"""
    Geometry Collection Auto Instance Mesh
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``custom_data`` (Array[float]):  [Read-Only]
    - ``materials`` (Array[MaterialInterface]):  [Read-Write]
    - ``mesh`` (StaticMesh):  [Read-Write]
    - ``num_instances`` (int32):  [Read-Only]
    - ``static_mesh`` (SoftObjectPath):  [Read-Write]
      deprecated: Use Mesh instead.
    """
    def __init__(self, mesh: StaticMesh = None, materials: Array[MaterialInterface] = []) -> None:
        ...
    @property
    def static_mesh(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Write]
        deprecated: Use Mesh instead.
        """
        ...
    @static_mesh.setter
    def static_mesh(self, value: SoftObjectPath) -> None:
        ...
    @property
    def mesh(self) -> StaticMesh:
        r"""
        (StaticMesh):  [Read-Write]
        """
        ...
    @mesh.setter
    def mesh(self, value: StaticMesh) -> None:
        ...
    @property
    def materials(self) -> Array[MaterialInterface]:
        r"""
        (Array[MaterialInterface]):  [Read-Write]
        """
        ...
    @materials.setter
    def materials(self, value: Array[MaterialInterface]) -> None:
        ...

class GeometryCollectionEmbeddedExemplar(StructBase):
    r"""
    Geometry Collection Embedded Exemplar
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_cull_distance`` (float):  [Read-Write]
    - ``instance_count`` (int32):  [Read-Only]
    - ``start_cull_distance`` (float):  [Read-Write]
    - ``static_mesh_exemplar`` (SoftObjectPath):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class GeometryCollectionProxyMeshData(StructBase):
    r"""
    Geometry Collection Proxy Mesh Data
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``proxy_meshes`` (Array[StaticMesh]):  [Read-Write]
    """
    def __init__(self, proxy_meshes: Array[StaticMesh] = []) -> None:
        ...
    @property
    def proxy_meshes(self) -> Array[StaticMesh]:
        r"""
        (Array[StaticMesh]):  [Read-Write]
        """
        ...
    @proxy_meshes.setter
    def proxy_meshes(self, value: Array[StaticMesh]) -> None:
        ...

class PostProcessSettings(StructBase):
    r"""
    To be able to use struct PostProcessSettings. // Each property consists of a bool to enable it (by default off),
    // the variable declaration and further down the default value for it.
    // The comment should include the meaning and usable range.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ambient_cubemap`` (TextureCube):  [Read-Write] The Ambient cubemap (Affects diffuse and specular shading), blends additively which if different from all other settings here
    - ``ambient_cubemap_intensity`` (float):  [Read-Write] To scale the Ambient cubemap brightness
      >=0: off, 1(default), >1 brighter
    - ``ambient_cubemap_tint`` (LinearColor):  [Read-Write] AmbientCubemap tint color
    - ``ambient_occlusion_bias`` (float):  [Read-Write] >0, in unreal units, default (3.0) works well for flat surfaces but can reduce details
    - ``ambient_occlusion_fade_distance`` (float):  [Read-Write] >0, in unreal units, at what distance the AO effect disppears in the distance (avoding artifacts and AO effects on huge object)
    - ``ambient_occlusion_fade_radius`` (float):  [Read-Write] >0, in unreal units, how many units before AmbientOcclusionFadeOutDistance it starts fading out
    - ``ambient_occlusion_intensity`` (float):  [Read-Write] 0..1 0=off/no ambient occlusion .. 1=strong ambient occlusion, defines how much it affects the non direct lighting after base pass
    - ``ambient_occlusion_mip_blend`` (float):  [Read-Write] Affects the blend over the multiple mips (lower resolution versions) , 0:fully use full resolution, 1::fully use low resolution, around 0.6 seems to be a good value
    - ``ambient_occlusion_mip_scale`` (float):  [Read-Write] Affects the radius AO radius scale over the multiple mips (lower resolution versions)
    - ``ambient_occlusion_mip_threshold`` (float):  [Read-Write] to tweak the bilateral upsampling when using multiple mips (lower resolution versions)
    - ``ambient_occlusion_power`` (float):  [Read-Write] >0, in unreal units, bigger values means even distant surfaces affect the ambient occlusion
    - ``ambient_occlusion_quality`` (float):  [Read-Write] 0=lowest quality..100=maximum quality, only a few quality levels are implemented, no soft transition
    - ``ambient_occlusion_radius`` (float):  [Read-Write] >0, in unreal units, bigger values means even distant surfaces affect the ambient occlusion
    - ``ambient_occlusion_radius_in_ws`` (bool):  [Read-Write] true: AO radius is in world space units, false: AO radius is locked the view space in 400 units
    - ``ambient_occlusion_static_fraction`` (float):  [Read-Write] 0..1 0=no effect on static lighting .. 1=AO affects the stat lighting, 0 is free meaning no extra rendering pass
    - ``ambient_occlusion_temporal_blend_weight`` (float):  [Read-Write] How much to blend the current frame with previous frames when using GTAO with temporal accumulation
    - ``auto_exposure_apply_physical_camera_exposure`` (bool):  [Read-Write] Only affects Manual exposure mode.
    - ``auto_exposure_bias`` (float):  [Read-Write] Logarithmic adjustment for the exposure. Only used if a tonemapper is specified.
      0: no adjustment, -1:2x darker, -2:4x darker, 1:2x brighter, 2:4x brighter, ...
    - ``auto_exposure_bias_curve`` (CurveFloat):  [Read-Write] Exposure compensation based on the scene EV100.
      Used to calibrate the final exposure differently depending on the average scene luminance.
      0: no adjustment, -1:2x darker, -2:4x darker, 1:2x brighter, 2:4x brighter, ...
    - ``auto_exposure_high_percent`` (float):  [Read-Write] The eye adaptation will adapt to a value extracted from the luminance histogram of the scene color.
      The value is defined as having x percent below this brightness. Higher values give bright spots on the screen more priority
      but can lead to less stable results. Lower values give the medium and darker values more priority but might cause burn out of
      bright spots.
      >0, <100, good values are in the range 80 .. 95
    - ``auto_exposure_low_percent`` (float):  [Read-Write] The eye adaptation will adapt to a value extracted from the luminance histogram of the scene color.
      The value is defined as having x percent below this brightness. Higher values give bright spots on the screen more priority
      but can lead to less stable results. Lower values give the medium and darker values more priority but might cause burn out of
      bright spots.
      >0, <100, good values are in the range 70 .. 80
    - ``auto_exposure_max_brightness`` (float):  [Read-Write] Auto-Exposure maximum adaptation. Eye Adaptation is disabled if Min = Max.
      Auto-exposure is implemented by choosing an exposure value for which the average luminance generates a pixel brightness equal to the Constant Calibration value.
      The Min/Max are expressed in pixel luminance (cd/m2) or in EV100 when using ExtendDefaultLuminanceRange (see project settings).
    - ``auto_exposure_meter_mask`` (Texture):  [Read-Write] Exposure metering mask. Bright spots on the mask will have high influence on auto-exposure metering
      and dark spots will have low influence.
    - ``auto_exposure_method`` (AutoExposureMethod):  [Read-Write] Luminance computation method
    - ``auto_exposure_min_brightness`` (float):  [Read-Write] Auto-Exposure minimum adaptation. Eye Adaptation is disabled if Min = Max.
      Auto-exposure is implemented by choosing an exposure value for which the average luminance generates a pixel brightness equal to the Constant Calibration value.
      The Min/Max are expressed in pixel luminance (cd/m2) or in EV100 when using ExtendDefaultLuminanceRange (see project settings).
    - ``auto_exposure_speed_down`` (float):  [Read-Write] In F-stops per second, should be >0
    - ``auto_exposure_speed_up`` (float):  [Read-Write] In F-stops per second, should be >0
    - ``bloom1_size`` (float):  [Read-Write] Diameter size for the Bloom1 in percent of the screen width
      (is done in 1/2 resolution, larger values cost more performance, good for high frequency details)
      >=0: can be clamped because of shader limitations
    - ``bloom1_tint`` (LinearColor):  [Read-Write] Bloom1 tint color
    - ``bloom2_size`` (float):  [Read-Write] Diameter size for Bloom2 in percent of the screen width
      (is done in 1/4 resolution, larger values cost more performance)
      >=0: can be clamped because of shader limitations
    - ``bloom2_tint`` (LinearColor):  [Read-Write] Bloom2 tint color
    - ``bloom3_size`` (float):  [Read-Write] Diameter size for Bloom3 in percent of the screen width
      (is done in 1/8 resolution, larger values cost more performance)
      >=0: can be clamped because of shader limitations
    - ``bloom3_tint`` (LinearColor):  [Read-Write] Bloom3 tint color
    - ``bloom4_size`` (float):  [Read-Write] Diameter size for Bloom4 in percent of the screen width
      (is done in 1/16 resolution, larger values cost more performance, best for wide contributions)
      >=0: can be clamped because of shader limitations
    - ``bloom4_tint`` (LinearColor):  [Read-Write] Bloom4 tint color
    - ``bloom5_size`` (float):  [Read-Write] Diameter size for Bloom5 in percent of the screen width
      (is done in 1/32 resolution, larger values cost more performance, best for wide contributions)
      >=0: can be clamped because of shader limitations
    - ``bloom5_tint`` (LinearColor):  [Read-Write] Bloom5 tint color
    - ``bloom6_size`` (float):  [Read-Write] Diameter size for Bloom6 in percent of the screen width
      (is done in 1/64 resolution, larger values cost more performance, best for wide contributions)
      >=0: can be clamped because of shader limitations
    - ``bloom6_tint`` (LinearColor):  [Read-Write] Bloom6 tint color
    - ``bloom_convolution_buffer_scale`` (float):  [Read-Write] Implicit buffer region as a fraction of the screen size to insure the bloom does not wrap across the screen.  Larger sizes have perf impact.
    - ``bloom_convolution_center_uv`` (Vector2D):  [Read-Write] The UV location of the center of the kernel.  Should be very close to (.5,.5)
    - ``bloom_convolution_pre_filter_max`` (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables
    - ``bloom_convolution_pre_filter_min`` (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables
    - ``bloom_convolution_pre_filter_mult`` (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables
    - ``bloom_convolution_scatter_dispersion`` (float):  [Read-Write] Intensity multiplier on the scatter dispersion energy of the kernel. 1.0 means exactly use the same energy as the kernel scatter dispersion.
    - ``bloom_convolution_size`` (float):  [Read-Write] Relative size of the convolution kernel image compared to the minor axis of the viewport
    - ``bloom_convolution_texture`` (Texture2D):  [Read-Write] Texture to replace default convolution bloom kernel
    - ``bloom_dirt_mask`` (Texture):  [Read-Write] Texture that defines the dirt on the camera lens where the light of very bright objects is scattered.
    - ``bloom_dirt_mask_intensity`` (float):  [Read-Write] BloomDirtMask intensity
    - ``bloom_dirt_mask_tint`` (LinearColor):  [Read-Write] BloomDirtMask tint color
    - ``bloom_intensity`` (float):  [Read-Write] Multiplier for all bloom contributions >=0: off, 1(default), >1 brighter
    - ``bloom_method`` (BloomMethod):  [Read-Write] Bloom algorithm
    - ``bloom_size_scale`` (float):  [Read-Write] Scale for all bloom sizes
    - ``bloom_threshold`` (float):  [Read-Write] minimum brightness the bloom starts having effect
      -1:all pixels affect bloom equally (physically correct, faster as a threshold pass is omitted), 0:all pixels affect bloom brights more, 1(default), >1 brighter
    - ``blue_correction`` (float):  [Read-Write] Correct for artifacts with "electric" blues due to the ACEScg color space. Bright blue desaturates instead of going to violet.
    - ``camera_iso`` (float):  [Read-Write] The camera sensor sensitivity
    - ``camera_shutter_speed`` (float):  [Read-Write] The camera shutter in seconds.
    - ``chromatic_aberration_start_offset`` (float):  [Read-Write] A normalized distance to the center of the framebuffer where the effect takes place.
    - ``color_contrast`` (Vector4):  [Read-Write] Control the range of light and dark values in your scene. Lower values will reduce the difference between bright and dark areas while higher values will increase the difference between the bright and dark areas.
    - ``color_contrast_highlights`` (Vector4):  [Read-Write] Control the range of light and dark values in the highlights region. Lower values will reduce the difference between bright and dark areas while higher values will increase the difference between the bright and dark areas.
    - ``color_contrast_midtones`` (Vector4):  [Read-Write] Control the range of light and dark values in the mid-tone region. Lower values will reduce the difference between bright and dark areas while higher values will increase the difference between the bright and dark areas.
    - ``color_contrast_shadows`` (Vector4):  [Read-Write] Control the range of light and dark values in your scene. Lower values will reduce the difference between bright and dark areas while higher values will increase the difference between the bright and dark areas.
    - ``color_correction_highlights_max`` (float):  [Read-Write] This value sets the upper threshold for what is considered to be the highlight region of the image.  This value should be larger than HighlightsMin. Default is 1.0, for backwards compatibility
    - ``color_correction_highlights_min`` (float):  [Read-Write] This value sets the lower threshold for what is considered to be the highlight region of the image.
    - ``color_correction_shadows_max`` (float):  [Read-Write] This value sets the threshold for what is considered to be the shadow region of the image.
    - ``color_gain`` (Vector4):  [Read-Write] This value multiplies the colors of the image.  Raising or lowering this value will result in brightening or darkening the entire scene.
    - ``color_gain_highlights`` (Vector4):  [Read-Write] This value multiplies the colors in the highlight region.  Raising or lowering this value will result in brightening or darkening the affected region.
    - ``color_gain_midtones`` (Vector4):  [Read-Write] This value multiplies the colors in the mid-tone region of the image.  Raising or lowering this value will result in brightening or darkening the affected region.
    - ``color_gain_shadows`` (Vector4):  [Read-Write] This value multiplies the colors in the shadow region.  Raising or lowering this value will result in brightening or darkening the affected region.
    - ``color_gamma`` (Vector4):  [Read-Write] Control the luminance curve of the scene. Raising or lowering this value will result brightening or darkening the mid-tones of the entire image.
    - ``color_gamma_highlights`` (Vector4):  [Read-Write] Control the luminance curve of the highlight region. Raising or lowering this value will result brightening or darkening the mid-tones of the highlight region.
    - ``color_gamma_midtones`` (Vector4):  [Read-Write] Control the luminance curve of the mid-tone region of the image. Raising or lowering this value will result brightening or darkening the mid-tones of the image.
    - ``color_gamma_shadows`` (Vector4):  [Read-Write] Control the luminance curve of the shadow region. Raising or lowering this value will result brightening or darkening the mid-tones of the shadow region.
    - ``color_grading_intensity`` (float):  [Read-Write] Color grading lookup table intensity. 0 = no intensity, 1=full intensity
    - ``color_grading_lut`` (Texture):  [Read-Write] Look up table texture to use or none of not used
    - ``color_offset`` (Vector4):  [Read-Write] This value is added to the colors of the scene.  Raising or lowering this value will result in the image being more or less washed-out.
    - ``color_offset_highlights`` (Vector4):  [Read-Write] This value is added to the colors in the highlight region.  Raising or lowering this value will result in the highlights being more or less washed-out.
    - ``color_offset_midtones`` (Vector4):  [Read-Write] This value is added to the colors in the mid-tone region of the image.  Raising or lowering this value will result in the mid-tones being more or less washed-out.
    - ``color_offset_shadows`` (Vector4):  [Read-Write] This value is added to the colors in the shadow region.  Raising or lowering this value will result in the shadows being more or less washed-out.
    - ``color_saturation`` (Vector4):  [Read-Write] Control the intensity of the color(hue) for the entire image.Higher values will result in more vibrant colors.
    - ``color_saturation_highlights`` (Vector4):  [Read-Write] Control the intensity of the color (hue) for the highlights region of the image.  Higher values will result in more vibrant colors.
    - ``color_saturation_midtones`` (Vector4):  [Read-Write] Control the intensity of the colors (hue) in the mid-tone region of the image.  Higher values will result in more vibrant colors.
    - ``color_saturation_shadows`` (Vector4):  [Read-Write] Control the intensity of the colors (hue) in the shadow region of the image.  Higher values will result in more vibrant colors.
    - ``depth_of_field_blade_count`` (int32):  [Read-Write] Defines the number of blades of the diaphragm within the lens (between 4 and 16).
    - ``depth_of_field_depth_blur_amount`` (float):  [Read-Write] CircleDOF only: Depth blur km for 50%
    - ``depth_of_field_depth_blur_radius`` (float):  [Read-Write] CircleDOF only: Depth blur radius in pixels at 1920x
    - ``depth_of_field_far_blur_size`` (float):  [Read-Write] Gaussian only: Maximum size of the Depth of Field blur (in percent of the view width) (note: performance cost scales with size)
    - ``depth_of_field_far_transition_region`` (float):  [Read-Write] To define the width of the transition region next to the focal region on the near side (cm)
    - ``depth_of_field_focal_distance`` (float):  [Read-Write] Distance in which the Depth of Field effect should be sharp, in unreal units (cm)
    - ``depth_of_field_focal_region`` (float):  [Read-Write] Artificial region where all content is in focus, starting after DepthOfFieldFocalDistance, in unreal units  (cm)
    - ``depth_of_field_fstop`` (float):  [Read-Write] Defines the opening of the camera lens, Aperture is 1/fstop, typical lens go down to f/1.2 (large opening), larger numbers reduce the DOF effect
    - ``depth_of_field_min_fstop`` (float):  [Read-Write] Defines the maximum opening of the camera lens to control the curvature of blades of the diaphragm. Set it to 0 to get straight blades.
    - ``depth_of_field_near_blur_size`` (float):  [Read-Write] Gaussian only: Maximum size of the Depth of Field blur (in percent of the view width) (note: performance cost scales with size)
    - ``depth_of_field_near_transition_region`` (float):  [Read-Write] To define the width of the transition region next to the focal region on the near side (cm)
    - ``depth_of_field_occlusion`` (float):  [Read-Write] Occlusion tweak factor 1 (0.18 to get natural occlusion, 0.4 to solve layer color leaking issues)
    - ``depth_of_field_scale`` (float):  [Read-Write] SM5: BokehDOF only: To amplify the depth of field effect (like aperture)  0=off
                ES3_1: Used to blend DoF. 0=off
    - ``depth_of_field_sensor_width`` (float):  [Read-Write] Width of the camera sensor to assume, in mm.
    - ``depth_of_field_sky_focus_distance`` (float):  [Read-Write] Artificial distance to allow the skybox to be in focus (e.g. 200000), <=0 to switch the feature off, only for GaussianDOF, can cost performance
    - ``depth_of_field_squeeze_factor`` (float):  [Read-Write] This is the squeeze factor for the DOF, which emulates the properties of anamorphic lenses.
    - ``depth_of_field_use_hair_depth`` (bool):  [Read-Write] For depth of field to use the hair depth for computing circle of confusion size. Otherwise use an interpolated distance between the hair depth and the scene depth based on the hair coverage (default).
    - ``depth_of_field_vignette_size`` (float):  [Read-Write] Artificial circular mask to (near) blur content outside the radius, only for GaussianDOF, diameter in percent of screen width, costs performance if the mask is used, keep Feather can Radius on default to keep it off
    - ``dynamic_global_illumination_method`` (DynamicGlobalIlluminationMethod):  [Read-Write] Chooses the Dynamic Global Illumination method.  Not compatible with Forward Shading.
    - ``expand_gamut`` (float):  [Read-Write] Expand bright saturated colors outside the sRGB gamut to fake wide gamut rendering.
    - ``film_black_clip`` (float):  [Read-Write] Lowers the toe of the tonemapper curve by this amount. Increasing this value causes more of the scene to clip to black.  For most purposes, this property should remain 0
    - ``film_grain_highlights_max`` (float):  [Read-Write] Sets the upper bound used for Film Grain Highlight Intensity. This value should be larger than HighlightsMin.. Default is 1.0, for backwards compatibility
    - ``film_grain_highlights_min`` (float):  [Read-Write] Sets the lower bound used for Film Grain Highlight Intensity.
    - ``film_grain_intensity`` (float):  [Read-Write] 0..1 Film grain intensity to apply. LinearSceneColor *= lerp(1.0, DecodedFilmGrainTexture, FilmGrainIntensity)
    - ``film_grain_intensity_highlights`` (float):  [Read-Write] Control over the grain intensity in the regions of the image considered highlight areas.
    - ``film_grain_intensity_midtones`` (float):  [Read-Write] Control over the grain intensity in the mid-tone region of the image.
    - ``film_grain_intensity_shadows`` (float):  [Read-Write] Control over the grain intensity in the regions of the image considered shadow areas.
    - ``film_grain_shadows_max`` (float):  [Read-Write] Sets the upper bound used for Film Grain Shadow Intensity.
    - ``film_grain_texel_size`` (float):  [Read-Write] Controls the size of the film grain. Size of texel of FilmGrainTexture on screen.
    - ``film_grain_texture`` (Texture2D):  [Read-Write] Defines film grain texture to use.
    - ``film_shoulder`` (float):  [Read-Write] Sometimes referred to as highlight rolloff.  Controls the contrast of the bright end of the tonemapper curve. Larger values increase contrast and smaller values decrease contrast.
    - ``film_slope`` (float):  [Read-Write] Controls the overall steepness of the tonemapper curve.  Larger values increase scene contrast and smaller values reduce contrast.
    - ``film_toe`` (float):  [Read-Write] Controls the contrast of the dark end of the tonemapper curve. Larger values increase contrast and smaller values decrease contrast.
    - ``film_white_clip`` (float):  [Read-Write] Controls the height of the tonemapper curve.  Raising this value can cause bright values to more quickly approach fully-saturated white.
    - ``histogram_log_max`` (float):  [Read-Write] Histogram Max value. Expressed in Log2(Luminance) or in EV100 when using ExtendDefaultLuminanceRange (see project settings)
    - ``histogram_log_min`` (float):  [Read-Write] Histogram Min value. Expressed in Log2(Luminance) or in EV100 when using ExtendDefaultLuminanceRange (see project settings)
    - ``indirect_lighting_color`` (LinearColor):  [Read-Write] Adjusts indirect lighting color. (1,1,1) is default. (0,0,0) to disable GI. The show flag 'Global Illumination' must be enabled to use this property.
    - ``indirect_lighting_intensity`` (float):  [Read-Write] Scales the indirect lighting contribution. A value of 0 disables GI. Default is 1. The show flag 'Global Illumination' must be enabled to use this property.
    - ``lens_flare_bokeh_shape`` (Texture):  [Read-Write] Defines the shape of the Bokeh when the image base lens flares are blurred, cannot be blended
    - ``lens_flare_bokeh_size`` (float):  [Read-Write] Size of the Lens Blur (in percent of the view width) that is done with the Bokeh texture (note: performance cost is radius*radius)
    - ``lens_flare_intensity`` (float):  [Read-Write] Brightness scale of the image cased lens flares (linear)
    - ``lens_flare_threshold`` (float):  [Read-Write] Minimum brightness the lens flare starts having effect (this should be as high as possible to avoid the performance cost of blurring content that is too dark too see)
    - ``lens_flare_tint`` (LinearColor):  [Read-Write] Tint color for the image based lens flares.
    - ``lens_flare_tints`` (LinearColor):  [Read-Write] RGB defines the lens flare color, A it's position. This is a temporary solution.
    - ``local_exposure_blurred_luminance_blend`` (float):  [Read-Write] Local Exposure decomposes luminance of the frame into a base layer and a detail layer.
      Blend between bilateral filtered and blurred luminance as the base layer.
      Blurred luminance helps preserve image appearance and specular highlights, and reduce ringing.
      Good values are usually in the range 0.4 .. 0.6
    - ``local_exposure_blurred_luminance_kernel_size_percent`` (float):  [Read-Write] Kernel size (percentage of screen) used to blur frame luminance.
    - ``local_exposure_detail_strength`` (float):  [Read-Write] Local Exposure decomposes luminance of the frame into a base layer and a detail layer.
      Value different than 1 will enable local exposure.
      This value should be set to 1 in most cases.
    - ``local_exposure_highlight_contrast_curve`` (CurveFloat):  [Read-Write] Local Exposure Highlight Contrast based on the scene EV100.
      Used to calibrate Local Exposure differently depending on the average scene luminance.
    - ``local_exposure_highlight_contrast_scale`` (float):  [Read-Write] Local Exposure decomposes luminance of the frame into a base layer and a detail layer.
      Contrast of the base layer is reduced based on this value.
      Value less than 1 will enable local exposure.
      Good values are usually in the range 0.6 .. 1.0.
    - ``local_exposure_highlight_threshold`` (float):  [Read-Write] Threshold used to determine which regions of the screen are considered highlights.
    - ``local_exposure_middle_grey_bias`` (float):  [Read-Write] Logarithmic adjustment for the local exposure middle grey.
      0: no adjustment, -1:2x darker, -2:4x darker, 1:2x brighter, 2:4x brighter, ...
    - ``local_exposure_shadow_contrast_curve`` (CurveFloat):  [Read-Write] Local Exposure Shadow Contrast based on the scene EV100.
      Used to calibrate Local Exposure differently depending on the average scene luminance.
    - ``local_exposure_shadow_contrast_scale`` (float):  [Read-Write] Local Exposure decomposes luminance of the frame into a base layer and a detail layer.
      Contrast of the base layer is reduced based on this value.
      Value less than 1 will enable local exposure.
      Good values are usually in the range 0.6 .. 1.0.
    - ``local_exposure_shadow_threshold`` (float):  [Read-Write] Threshold used to determine which regions of the screen are considered shadows.
    - ``lumen_diffuse_color_boost`` (float):  [Read-Write] Allows brightening indirect lighting by calculating material diffuse color for indirect lighting as pow(DiffuseColor, 1 / DiffuseColorBoost). Values above 1 (original diffuse color) aren't physically correct, but they can be useful as an art direction knob to increase the amount of bounced light in the scene. Best to keep below 2 as it also causes reflections to be brighter than the scene.
    - ``lumen_final_gather_lighting_update_speed`` (float):  [Read-Write] Controls how much Lumen Final Gather is allowed to cache lighting results to improve performance.  Larger scales cause lighting changes to propagate faster, but increase GPU cost and noise.
    - ``lumen_final_gather_quality`` (float):  [Read-Write] Scales Lumen's Final Gather quality.  Larger scales reduce noise, but greatly increase GPU cost.
    - ``lumen_final_gather_screen_traces`` (bool):  [Read-Write] Whether to use screen space traces for Lumen Global Illumination. Screen space traces bypass Lumen Scene and instead sample Scene Depth and Color. This improves quality, but at the same time prevents from Lumen Scene only changes like adding emissive objects, which are visible only in Global Illumination.
    - ``lumen_front_layer_translucency_reflections`` (bool):  [Read-Write] Whether to use high quality mirror reflections on the front layer of translucent surfaces.  Other layers will use the lower quality Radiance Cache method that can only produce glossy reflections.  Increases GPU cost when enabled.
    - ``lumen_full_skylight_leaking_distance`` (float):  [Read-Write] Controls the distance from a receiving surface where skylight leaking reaches its full intensity.  Smaller values make the skylight leaking flatter, while larger values create an Ambient Occlusion effect.
    - ``lumen_max_reflection_bounces`` (int32):  [Read-Write] Sets the maximum number of recursive reflection bounces. 1 means a single reflection ray (no secondary reflections in mirrors). Currently only supported by Hardware Ray Tracing with Hit Lighting.
    - ``lumen_max_refraction_bounces`` (int32):  [Read-Write] The maximum count of refraction event to trace. When hit lighting is used, Translucent meshes will be traced when LumenMaxRefractionBounces > 0, making the reflection tracing more expenssive.
    - ``lumen_max_roughness_to_trace_reflections`` (float):  [Read-Write] Sets the maximum roughness value for which Lumen still traces dedicated reflection rays. Higher values improve reflection quality, but greatly increase GPU cost.
    - ``lumen_max_trace_distance`` (float):  [Read-Write] Controls the maximum distance that Lumen should trace while solving lighting.  Values that are too small will cause lighting to leak into large caves, while values that are large will increase GPU cost.
    - ``lumen_ray_lighting_mode`` (LumenRayLightingModeOverride):  [Read-Write] Controls how Lumen rays are lit when Lumen is using Hardware Ray Tracing.  By default, Lumen uses the Surface Cache for best performance, but can be set to 'Hit Lighting' for higher quality.
    - ``lumen_reflection_quality`` (float):  [Read-Write] Scales the Reflection quality.  Larger scales reduce noise in reflections, but increase GPU cost.
    - ``lumen_reflections_screen_traces`` (bool):  [Read-Write] Whether to use screen space traces for Lumen Reflections. Screen space traces bypass Lumen Scene and instead sample Scene Depth and Color. This improves quality, but at the same time prevents from Lumen Scene only changes like adding emissive objects, which are visible only in Reflections.
    - ``lumen_scene_detail`` (float):  [Read-Write] Controls the size of instances that can be represented in Lumen Scene.  Larger values will ensure small objects are represented, but increase GPU cost.
    - ``lumen_scene_lighting_quality`` (float):  [Read-Write] Scales Lumen Scene's quality.  Larger scales cause Lumen Scene to be calculated with a higher fidelity, which can be visible in reflections, but increase GPU cost.
    - ``lumen_scene_lighting_update_speed`` (float):  [Read-Write] Controls how much Lumen Scene is allowed to cache lighting results to improve performance.  Larger scales cause lighting changes to propagate faster, but increase GPU cost.
    - ``lumen_scene_view_distance`` (float):  [Read-Write] Sets the maximum view distance of the scene that Lumen maintains for ray tracing against.  Larger values will increase the effective range of sky shadowing and Global Illumination, but increase GPU cost.
    - ``lumen_skylight_leaking`` (float):  [Read-Write] Controls what fraction of the skylight intensity should be allowed to leak.  This can be useful as an art direction knob (non-physically based) to keep indoor areas from going fully black.
    - ``lumen_surface_cache_resolution`` (float):  [Read-Write] Scale factor for Lumen Surface Cache resolution, for Scene Capture.  Smaller values save GPU memory, at a cost in quality.  Defaults to 0.5 if not overridden.
    - ``mobile_hq_gaussian`` (bool):  [Read-Write] Enable HQ Gaussian on high end mobile platforms. (ES3_1)
    - ``motion_blur_amount`` (float):  [Read-Write] Strength of motion blur, 0:off
    - ``motion_blur_max`` (float):  [Read-Write] max distortion caused by motion blur, in percent of the screen width, 0:off
    - ``motion_blur_per_object_size`` (float):  [Read-Write] The minimum projected screen radius for a primitive to be drawn in the velocity pass, percentage of screen width. smaller numbers cause more draw calls, default: 4%
    - ``motion_blur_target_fps`` (int32):  [Read-Write] Defines the target FPS for motion blur. Makes motion blur independent of actual frame rate and relative
      to the specified target FPS instead. Higher target FPS results in shorter frames, which means shorter
      shutter times and less motion blur. Lower FPS means more motion blur. A value of zero makes the motion
      blur dependent on the actual frame rate.
    - ``override_ambient_cubemap_intensity`` (bool):  [Read-Write]
    - ``override_ambient_cubemap_tint`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_bias`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_fade_distance`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_fade_radius`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_intensity`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_mip_blend`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_mip_scale`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_mip_threshold`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_power`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_quality`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_radius`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_radius_in_ws`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_static_fraction`` (bool):  [Read-Write]
    - ``override_ambient_occlusion_temporal_blend_weight`` (bool):  [Read-Write]
    - ``override_auto_exposure_apply_physical_camera_exposure`` (bool):  [Read-Write]
    - ``override_auto_exposure_bias`` (bool):  [Read-Write]
    - ``override_auto_exposure_bias_curve`` (bool):  [Read-Write]
    - ``override_auto_exposure_high_percent`` (bool):  [Read-Write]
    - ``override_auto_exposure_low_percent`` (bool):  [Read-Write]
    - ``override_auto_exposure_max_brightness`` (bool):  [Read-Write]
    - ``override_auto_exposure_meter_mask`` (bool):  [Read-Write]
    - ``override_auto_exposure_method`` (bool):  [Read-Write]
    - ``override_auto_exposure_min_brightness`` (bool):  [Read-Write]
    - ``override_auto_exposure_speed_down`` (bool):  [Read-Write]
    - ``override_auto_exposure_speed_up`` (bool):  [Read-Write]
    - ``override_bloom1_size`` (bool):  [Read-Write]
    - ``override_bloom1_tint`` (bool):  [Read-Write]
    - ``override_bloom2_size`` (bool):  [Read-Write]
    - ``override_bloom2_tint`` (bool):  [Read-Write]
    - ``override_bloom3_size`` (bool):  [Read-Write]
    - ``override_bloom3_tint`` (bool):  [Read-Write]
    - ``override_bloom4_size`` (bool):  [Read-Write]
    - ``override_bloom4_tint`` (bool):  [Read-Write]
    - ``override_bloom5_size`` (bool):  [Read-Write]
    - ``override_bloom5_tint`` (bool):  [Read-Write]
    - ``override_bloom6_size`` (bool):  [Read-Write]
    - ``override_bloom6_tint`` (bool):  [Read-Write]
    - ``override_bloom_convolution_buffer_scale`` (bool):  [Read-Write]
    - ``override_bloom_convolution_center_uv`` (bool):  [Read-Write]
    - ``override_bloom_convolution_pre_filter_max`` (bool):  [Read-Write]
    - ``override_bloom_convolution_pre_filter_min`` (bool):  [Read-Write]
    - ``override_bloom_convolution_pre_filter_mult`` (bool):  [Read-Write]
    - ``override_bloom_convolution_scatter_dispersion`` (bool):  [Read-Write]
    - ``override_bloom_convolution_size`` (bool):  [Read-Write]
    - ``override_bloom_convolution_texture`` (bool):  [Read-Write]
    - ``override_bloom_dirt_mask`` (bool):  [Read-Write]
    - ``override_bloom_dirt_mask_intensity`` (bool):  [Read-Write]
    - ``override_bloom_dirt_mask_tint`` (bool):  [Read-Write]
    - ``override_bloom_intensity`` (bool):  [Read-Write]
    - ``override_bloom_method`` (bool):  [Read-Write]
    - ``override_bloom_size_scale`` (bool):  [Read-Write]
    - ``override_bloom_threshold`` (bool):  [Read-Write]
    - ``override_blue_correction`` (bool):  [Read-Write]
    - ``override_camera_iso`` (bool):  [Read-Write]
    - ``override_camera_shutter_speed`` (bool):  [Read-Write]
    - ``override_chromatic_aberration_start_offset`` (bool):  [Read-Write]
    - ``override_color_contrast`` (bool):  [Read-Write]
    - ``override_color_contrast_highlights`` (bool):  [Read-Write]
    - ``override_color_contrast_midtones`` (bool):  [Read-Write]
    - ``override_color_contrast_shadows`` (bool):  [Read-Write]
    - ``override_color_correction_highlights_max`` (bool):  [Read-Write]
    - ``override_color_correction_highlights_min`` (bool):  [Read-Write]
    - ``override_color_correction_shadows_max`` (bool):  [Read-Write]
    - ``override_color_gain`` (bool):  [Read-Write]
    - ``override_color_gain_highlights`` (bool):  [Read-Write]
    - ``override_color_gain_midtones`` (bool):  [Read-Write]
    - ``override_color_gain_shadows`` (bool):  [Read-Write]
    - ``override_color_gamma`` (bool):  [Read-Write]
    - ``override_color_gamma_highlights`` (bool):  [Read-Write]
    - ``override_color_gamma_midtones`` (bool):  [Read-Write]
    - ``override_color_gamma_shadows`` (bool):  [Read-Write]
    - ``override_color_grading_intensity`` (bool):  [Read-Write]
    - ``override_color_grading_lut`` (bool):  [Read-Write]
    - ``override_color_offset`` (bool):  [Read-Write]
    - ``override_color_offset_highlights`` (bool):  [Read-Write]
    - ``override_color_offset_midtones`` (bool):  [Read-Write]
    - ``override_color_offset_shadows`` (bool):  [Read-Write]
    - ``override_color_saturation`` (bool):  [Read-Write] Color Correction controls
    - ``override_color_saturation_highlights`` (bool):  [Read-Write]
    - ``override_color_saturation_midtones`` (bool):  [Read-Write]
    - ``override_color_saturation_shadows`` (bool):  [Read-Write]
    - ``override_depth_of_field_blade_count`` (bool):  [Read-Write]
    - ``override_depth_of_field_depth_blur_amount`` (bool):  [Read-Write]
    - ``override_depth_of_field_depth_blur_radius`` (bool):  [Read-Write]
    - ``override_depth_of_field_far_blur_size`` (bool):  [Read-Write]
    - ``override_depth_of_field_far_transition_region`` (bool):  [Read-Write]
    - ``override_depth_of_field_focal_distance`` (bool):  [Read-Write]
    - ``override_depth_of_field_focal_region`` (bool):  [Read-Write]
    - ``override_depth_of_field_fstop`` (bool):  [Read-Write]
    - ``override_depth_of_field_min_fstop`` (bool):  [Read-Write]
    - ``override_depth_of_field_near_blur_size`` (bool):  [Read-Write]
    - ``override_depth_of_field_near_transition_region`` (bool):  [Read-Write]
    - ``override_depth_of_field_occlusion`` (bool):  [Read-Write]
    - ``override_depth_of_field_scale`` (bool):  [Read-Write]
    - ``override_depth_of_field_sensor_width`` (bool):  [Read-Write]
    - ``override_depth_of_field_sky_focus_distance`` (bool):  [Read-Write]
    - ``override_depth_of_field_squeeze_factor`` (bool):  [Read-Write]
    - ``override_depth_of_field_use_hair_depth`` (bool):  [Read-Write]
    - ``override_depth_of_field_vignette_size`` (bool):  [Read-Write]
    - ``override_dynamic_global_illumination_method`` (bool):  [Read-Write]
    - ``override_expand_gamut`` (bool):  [Read-Write]
    - ``override_film_black_clip`` (bool):  [Read-Write]
    - ``override_film_grain_highlights_max`` (bool):  [Read-Write]
    - ``override_film_grain_highlights_min`` (bool):  [Read-Write]
    - ``override_film_grain_intensity`` (bool):  [Read-Write]
    - ``override_film_grain_intensity_highlights`` (bool):  [Read-Write]
    - ``override_film_grain_intensity_midtones`` (bool):  [Read-Write]
    - ``override_film_grain_intensity_shadows`` (bool):  [Read-Write]
    - ``override_film_grain_shadows_max`` (bool):  [Read-Write]
    - ``override_film_grain_texel_size`` (bool):  [Read-Write]
    - ``override_film_grain_texture`` (bool):  [Read-Write]
    - ``override_film_shoulder`` (bool):  [Read-Write]
    - ``override_film_slope`` (bool):  [Read-Write]
    - ``override_film_toe`` (bool):  [Read-Write]
    - ``override_film_white_clip`` (bool):  [Read-Write]
    - ``override_histogram_log_max`` (bool):  [Read-Write]
    - ``override_histogram_log_min`` (bool):  [Read-Write]
    - ``override_indirect_lighting_color`` (bool):  [Read-Write]
    - ``override_indirect_lighting_intensity`` (bool):  [Read-Write]
    - ``override_lens_flare_bokeh_shape`` (bool):  [Read-Write]
    - ``override_lens_flare_bokeh_size`` (bool):  [Read-Write]
    - ``override_lens_flare_intensity`` (bool):  [Read-Write]
    - ``override_lens_flare_threshold`` (bool):  [Read-Write]
    - ``override_lens_flare_tint`` (bool):  [Read-Write]
    - ``override_lens_flare_tints`` (bool):  [Read-Write]
    - ``override_local_exposure_blurred_luminance_blend`` (bool):  [Read-Write]
    - ``override_local_exposure_blurred_luminance_kernel_size_percent`` (bool):  [Read-Write]
    - ``override_local_exposure_detail_strength`` (bool):  [Read-Write]
    - ``override_local_exposure_highlight_contrast_curve`` (bool):  [Read-Write]
    - ``override_local_exposure_highlight_contrast_scale`` (bool):  [Read-Write]
    - ``override_local_exposure_highlight_threshold`` (bool):  [Read-Write]
    - ``override_local_exposure_middle_grey_bias`` (bool):  [Read-Write]
    - ``override_local_exposure_shadow_contrast_curve`` (bool):  [Read-Write]
    - ``override_local_exposure_shadow_contrast_scale`` (bool):  [Read-Write]
    - ``override_local_exposure_shadow_threshold`` (bool):  [Read-Write]
    - ``override_lumen_diffuse_color_boost`` (bool):  [Read-Write]
    - ``override_lumen_final_gather_lighting_update_speed`` (bool):  [Read-Write]
    - ``override_lumen_final_gather_quality`` (bool):  [Read-Write]
    - ``override_lumen_final_gather_screen_traces`` (bool):  [Read-Write]
    - ``override_lumen_front_layer_translucency_reflections`` (bool):  [Read-Write]
    - ``override_lumen_full_skylight_leaking_distance`` (bool):  [Read-Write]
    - ``override_lumen_max_reflection_bounces`` (bool):  [Read-Write]
    - ``override_lumen_max_refraction_bounces`` (bool):  [Read-Write]
    - ``override_lumen_max_roughness_to_trace_reflections`` (bool):  [Read-Write]
    - ``override_lumen_max_trace_distance`` (bool):  [Read-Write]
    - ``override_lumen_ray_lighting_mode`` (bool):  [Read-Write]
    - ``override_lumen_reflection_quality`` (bool):  [Read-Write]
    - ``override_lumen_reflections_screen_traces`` (bool):  [Read-Write]
    - ``override_lumen_scene_detail`` (bool):  [Read-Write]
    - ``override_lumen_scene_lighting_quality`` (bool):  [Read-Write]
    - ``override_lumen_scene_lighting_update_speed`` (bool):  [Read-Write]
    - ``override_lumen_scene_view_distance`` (bool):  [Read-Write]
    - ``override_lumen_skylight_leaking`` (bool):  [Read-Write]
    - ``override_lumen_surface_cache_resolution`` (bool):  [Read-Write]
    - ``override_mobile_hq_gaussian`` (bool):  [Read-Write]
    - ``override_motion_blur_amount`` (bool):  [Read-Write]
    - ``override_motion_blur_max`` (bool):  [Read-Write]
    - ``override_motion_blur_per_object_size`` (bool):  [Read-Write]
    - ``override_motion_blur_target_fps`` (bool):  [Read-Write]
    - ``override_path_tracing_enable_denoiser`` (bool):  [Read-Write]
    - ``override_path_tracing_enable_emissive_materials`` (bool):  [Read-Write]
    - ``override_path_tracing_enable_reference_atmosphere`` (bool):  [Read-Write]
    - ``override_path_tracing_enable_reference_dof`` (bool):  [Read-Write]
    - ``override_path_tracing_include_diffuse`` (bool):  [Read-Write]
    - ``override_path_tracing_include_emissive`` (bool):  [Read-Write]
    - ``override_path_tracing_include_indirect_diffuse`` (bool):  [Read-Write]
    - ``override_path_tracing_include_indirect_specular`` (bool):  [Read-Write]
    - ``override_path_tracing_include_indirect_volume`` (bool):  [Read-Write]
    - ``override_path_tracing_include_specular`` (bool):  [Read-Write]
    - ``override_path_tracing_include_volume`` (bool):  [Read-Write]
    - ``override_path_tracing_max_bounces`` (bool):  [Read-Write]
    - ``override_path_tracing_max_path_exposure`` (bool):  [Read-Write]
    - ``override_path_tracing_samples_per_pixel`` (bool):  [Read-Write]
    - ``override_ray_tracing_ao`` (bool):  [Read-Write]
    - ``override_ray_tracing_ao_intensity`` (bool):  [Read-Write]
    - ``override_ray_tracing_ao_radius`` (bool):  [Read-Write]
    - ``override_ray_tracing_ao_samples_per_pixel`` (bool):  [Read-Write]
    - ``override_ray_tracing_gi`` (bool):  [Read-Write]
    - ``override_ray_tracing_gi_max_bounces`` (bool):  [Read-Write]
    - ``override_ray_tracing_gi_samples_per_pixel`` (bool):  [Read-Write]
    - ``override_ray_tracing_reflections_max_bounces`` (bool):  [Read-Write]
    - ``override_ray_tracing_reflections_max_roughness`` (bool):  [Read-Write]
    - ``override_ray_tracing_reflections_samples_per_pixel`` (bool):  [Read-Write]
    - ``override_ray_tracing_reflections_shadows`` (bool):  [Read-Write]
    - ``override_ray_tracing_reflections_translucency`` (bool):  [Read-Write]
    - ``override_ray_tracing_translucency_max_roughness`` (bool):  [Read-Write]
    - ``override_ray_tracing_translucency_refraction`` (bool):  [Read-Write]
    - ``override_ray_tracing_translucency_refraction_rays`` (bool):  [Read-Write]
    - ``override_ray_tracing_translucency_samples_per_pixel`` (bool):  [Read-Write]
    - ``override_ray_tracing_translucency_shadows`` (bool):  [Read-Write]
    - ``override_reflection_method`` (bool):  [Read-Write]
    - ``override_scene_color_tint`` (bool):  [Read-Write]
    - ``override_scene_fringe_intensity`` (bool):  [Read-Write]
    - ``override_screen_space_reflection_intensity`` (bool):  [Read-Write]
    - ``override_screen_space_reflection_max_roughness`` (bool):  [Read-Write]
    - ``override_screen_space_reflection_quality`` (bool):  [Read-Write]
    - ``override_screen_space_reflection_roughness_scale`` (bool):  [Read-Write]
    - ``override_sharpen`` (bool):  [Read-Write]
    - ``override_temperature_type`` (bool):  [Read-Write] first all bOverride_... as they get grouped together into bitfields
    - ``override_tone_curve_amount`` (bool):  [Read-Write]
    - ``override_translucency_type`` (bool):  [Read-Write]
    - ``override_vignette_intensity`` (bool):  [Read-Write]
    - ``override_white_temp`` (bool):  [Read-Write]
    - ``override_white_tint`` (bool):  [Read-Write]
    - ``path_tracing_enable_denoiser`` (bool):  [Read-Write] Run the currently loaded denoiser plugin on the last sample to remove noise from the output. Has no effect if a plug-in is not loaded.
    - ``path_tracing_enable_emissive_materials`` (bool):  [Read-Write] Should emissive materials contribute to scene lighting?
    - ``path_tracing_enable_reference_atmosphere`` (bool):  [Read-Write] Enables path tracing in the atmosphere instead of baking the sky atmosphere contribution into a skylight. Any skylight present in the scene will be automatically ignored when this is enabled.
    - ``path_tracing_enable_reference_dof`` (bool):  [Read-Write] Enables a reference quality depth-of-field which replaces the post-process effect.
    - ``path_tracing_include_diffuse`` (bool):  [Read-Write] Should the render include diffuse lighting contributions?
    - ``path_tracing_include_emissive`` (bool):  [Read-Write] Should the render include directly visible emissive elements?
    - ``path_tracing_include_indirect_diffuse`` (bool):  [Read-Write] Should the render include indirect diffuse lighting contributions?
    - ``path_tracing_include_indirect_specular`` (bool):  [Read-Write] Should the render include indirect specular lighting contributions?
    - ``path_tracing_include_indirect_volume`` (bool):  [Read-Write] Should the render include volume lighting contributions?
    - ``path_tracing_include_specular`` (bool):  [Read-Write] Should the render include specular lighting contributions?
    - ``path_tracing_include_volume`` (bool):  [Read-Write] Should the render include volume lighting contributions?
    - ``path_tracing_max_bounces`` (int32):  [Read-Write] Sets the path tracing maximum bounces
    - ``path_tracing_max_path_exposure`` (float):  [Read-Write] Sets the maximum exposure allowed in the path tracer to reduce fireflies. This should be set a few stops higher than the scene exposure.
    - ``path_tracing_samples_per_pixel`` (int32):  [Read-Write] Sets the samples per pixel for the path tracer.
    - ``ray_tracing_ao`` (bool):  [Read-Write] Enables ray tracing ambient occlusion.
    - ``ray_tracing_ao_intensity`` (float):  [Read-Write] Scalar factor on the ray-tracing ambient occlusion score.
    - ``ray_tracing_ao_radius`` (float):  [Read-Write] Defines the world-space search radius for occlusion rays.
    - ``ray_tracing_ao_samples_per_pixel`` (int32):  [Read-Write] Sets the samples per pixel for ray tracing ambient occlusion.
    - ``ray_tracing_translucency_max_roughness`` (float):  [Read-Write] Sets the maximum roughness until which ray tracing translucency will be visible (lower value is faster). Translucency contribution is smoothly faded when close to roughness threshold. This parameter behaves similarly to ScreenSpaceReflectionMaxRoughness.
    - ``ray_tracing_translucency_refraction`` (bool):  [Read-Write] Sets whether refraction should be enabled or not (if not rays will not scatter and only travel in the same direction as before the intersection event).
    - ``ray_tracing_translucency_refraction_rays`` (int32):  [Read-Write] Sets the maximum number of ray tracing refraction rays.
    - ``ray_tracing_translucency_samples_per_pixel`` (int32):  [Read-Write] Sets the samples per pixel for ray traced translucency.
    - ``ray_tracing_translucency_shadows`` (ReflectedAndRefractedRayTracedShadows):  [Read-Write] Sets the translucency shadows type.
    - ``reflection_method`` (ReflectionMethod):  [Read-Write] Chooses the Reflection method. Not compatible with Forward Shading.
    - ``scene_color_tint`` (LinearColor):  [Read-Write] Scene tint color
    - ``scene_fringe_intensity`` (float):  [Read-Write] in percent, Scene chromatic aberration / color fringe (camera imperfection) to simulate an artifact that happens in real-world lens, mostly visible in the image corners.
    - ``screen_space_reflection_intensity`` (float):  [Read-Write] Enable/Fade/disable the Screen Space Reflection feature, in percent, avoid numbers between 0 and 1 fo consistency
    - ``screen_space_reflection_max_roughness`` (float):  [Read-Write] Until what roughness we fade the screen space reflections, 0.8 works well, smaller can run faster
    - ``screen_space_reflection_quality`` (float):  [Read-Write] 0=lowest quality..100=maximum quality, only a few quality levels are implemented, no soft transition, 50 is the default for better performance.
    - ``sharpen`` (float):  [Read-Write] Controls the strength of image sharpening applied during tonemapping.
    - ``temperature_type`` (TemperatureMethod):  [Read-Write] Selects the type of temperature calculation.
      White Balance uses the Temperature value to control the virtual camera's White Balance. This is the default selection.
      Color Temperature uses the Temperature value to adjust the color temperature of the scene, which is the inverse of the White Balance operation.
    - ``tone_curve_amount`` (float):  [Read-Write] Allow effect of Tone Curve to be reduced (Set ToneCurveAmount and ExpandGamut to 0.0 to fully disable tone curve)
    - ``translucency_type`` (TranslucencyType):  [Read-Write] Sets the translucency type
    - ``vignette_intensity`` (float):  [Read-Write] 0..1 0=off/no vignette .. 1=strong vignette
    - ``weighted_blendables`` (WeightedBlendables):  [Read-Write] Allows custom post process materials to be defined, using a MaterialInstance with the same Material as its parent to allow blending.
      For materials this needs to be the "PostProcess" domain type. This can be used for any UObject object implementing the IBlendableInterface (e.g. could be used to fade weather settings).
    - ``white_temp`` (float):  [Read-Write] Controls the color temperature or white balance in degrees Kelvin which the scene considers as white light.
    - ``white_tint`` (float):  [Read-Write] Controls the color of the scene along the magenta - green axis (orthogonal to the color temperature).  This feature is equivalent to color tint in digital cameras.
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def override_temperature_type(self) -> bool:
        r"""
        (bool):  [Read-Write] first all bOverride_... as they get grouped together into bitfields
        """
        ...
    @override_temperature_type.setter
    def override_temperature_type(self, value: bool) -> None:
        ...
    @property
    def override_white_temp(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_white_temp.setter
    def override_white_temp(self, value: bool) -> None:
        ...
    @property
    def override_white_tint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_white_tint.setter
    def override_white_tint(self, value: bool) -> None:
        ...
    @property
    def override_color_saturation(self) -> bool:
        r"""
        (bool):  [Read-Write] Color Correction controls
        """
        ...
    @override_color_saturation.setter
    def override_color_saturation(self, value: bool) -> None:
        ...
    @property
    def override_color_contrast(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_contrast.setter
    def override_color_contrast(self, value: bool) -> None:
        ...
    @property
    def override_color_gamma(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_gamma.setter
    def override_color_gamma(self, value: bool) -> None:
        ...
    @property
    def override_color_gain(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_gain.setter
    def override_color_gain(self, value: bool) -> None:
        ...
    @property
    def override_color_offset(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_offset.setter
    def override_color_offset(self, value: bool) -> None:
        ...
    @property
    def override_color_saturation_shadows(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_saturation_shadows.setter
    def override_color_saturation_shadows(self, value: bool) -> None:
        ...
    @property
    def override_color_contrast_shadows(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_contrast_shadows.setter
    def override_color_contrast_shadows(self, value: bool) -> None:
        ...
    @property
    def override_color_gamma_shadows(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_gamma_shadows.setter
    def override_color_gamma_shadows(self, value: bool) -> None:
        ...
    @property
    def override_color_gain_shadows(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_gain_shadows.setter
    def override_color_gain_shadows(self, value: bool) -> None:
        ...
    @property
    def override_color_offset_shadows(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_offset_shadows.setter
    def override_color_offset_shadows(self, value: bool) -> None:
        ...
    @property
    def override_color_saturation_midtones(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_saturation_midtones.setter
    def override_color_saturation_midtones(self, value: bool) -> None:
        ...
    @property
    def override_color_contrast_midtones(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_contrast_midtones.setter
    def override_color_contrast_midtones(self, value: bool) -> None:
        ...
    @property
    def override_color_gamma_midtones(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_gamma_midtones.setter
    def override_color_gamma_midtones(self, value: bool) -> None:
        ...
    @property
    def override_color_gain_midtones(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_gain_midtones.setter
    def override_color_gain_midtones(self, value: bool) -> None:
        ...
    @property
    def override_color_offset_midtones(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_offset_midtones.setter
    def override_color_offset_midtones(self, value: bool) -> None:
        ...
    @property
    def override_color_saturation_highlights(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_saturation_highlights.setter
    def override_color_saturation_highlights(self, value: bool) -> None:
        ...
    @property
    def override_color_contrast_highlights(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_contrast_highlights.setter
    def override_color_contrast_highlights(self, value: bool) -> None:
        ...
    @property
    def override_color_gamma_highlights(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_gamma_highlights.setter
    def override_color_gamma_highlights(self, value: bool) -> None:
        ...
    @property
    def override_color_gain_highlights(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_gain_highlights.setter
    def override_color_gain_highlights(self, value: bool) -> None:
        ...
    @property
    def override_color_offset_highlights(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_offset_highlights.setter
    def override_color_offset_highlights(self, value: bool) -> None:
        ...
    @property
    def override_color_correction_shadows_max(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_correction_shadows_max.setter
    def override_color_correction_shadows_max(self, value: bool) -> None:
        ...
    @property
    def override_color_correction_highlights_min(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_correction_highlights_min.setter
    def override_color_correction_highlights_min(self, value: bool) -> None:
        ...
    @property
    def override_color_correction_highlights_max(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_correction_highlights_max.setter
    def override_color_correction_highlights_max(self, value: bool) -> None:
        ...
    @property
    def override_blue_correction(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_blue_correction.setter
    def override_blue_correction(self, value: bool) -> None:
        ...
    @property
    def override_expand_gamut(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_expand_gamut.setter
    def override_expand_gamut(self, value: bool) -> None:
        ...
    @property
    def override_tone_curve_amount(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_tone_curve_amount.setter
    def override_tone_curve_amount(self, value: bool) -> None:
        ...
    @property
    def override_film_slope(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_slope.setter
    def override_film_slope(self, value: bool) -> None:
        ...
    @property
    def override_film_toe(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_toe.setter
    def override_film_toe(self, value: bool) -> None:
        ...
    @property
    def override_film_shoulder(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_shoulder.setter
    def override_film_shoulder(self, value: bool) -> None:
        ...
    @property
    def override_film_black_clip(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_black_clip.setter
    def override_film_black_clip(self, value: bool) -> None:
        ...
    @property
    def override_film_white_clip(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_white_clip.setter
    def override_film_white_clip(self, value: bool) -> None:
        ...
    @property
    def override_scene_color_tint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_scene_color_tint.setter
    def override_scene_color_tint(self, value: bool) -> None:
        ...
    @property
    def override_scene_fringe_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_scene_fringe_intensity.setter
    def override_scene_fringe_intensity(self, value: bool) -> None:
        ...
    @property
    def override_chromatic_aberration_start_offset(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_chromatic_aberration_start_offset.setter
    def override_chromatic_aberration_start_offset(self, value: bool) -> None:
        ...
    @property
    def override_ambient_cubemap_tint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_cubemap_tint.setter
    def override_ambient_cubemap_tint(self, value: bool) -> None:
        ...
    @property
    def override_ambient_cubemap_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_cubemap_intensity.setter
    def override_ambient_cubemap_intensity(self, value: bool) -> None:
        ...
    @property
    def override_bloom_method(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_method.setter
    def override_bloom_method(self, value: bool) -> None:
        ...
    @property
    def override_bloom_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_intensity.setter
    def override_bloom_intensity(self, value: bool) -> None:
        ...
    @property
    def override_bloom_threshold(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_threshold.setter
    def override_bloom_threshold(self, value: bool) -> None:
        ...
    @property
    def override_bloom1_tint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom1_tint.setter
    def override_bloom1_tint(self, value: bool) -> None:
        ...
    @property
    def override_bloom1_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom1_size.setter
    def override_bloom1_size(self, value: bool) -> None:
        ...
    @property
    def override_bloom2_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom2_size.setter
    def override_bloom2_size(self, value: bool) -> None:
        ...
    @property
    def override_bloom2_tint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom2_tint.setter
    def override_bloom2_tint(self, value: bool) -> None:
        ...
    @property
    def override_bloom3_tint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom3_tint.setter
    def override_bloom3_tint(self, value: bool) -> None:
        ...
    @property
    def override_bloom3_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom3_size.setter
    def override_bloom3_size(self, value: bool) -> None:
        ...
    @property
    def override_bloom4_tint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom4_tint.setter
    def override_bloom4_tint(self, value: bool) -> None:
        ...
    @property
    def override_bloom4_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom4_size.setter
    def override_bloom4_size(self, value: bool) -> None:
        ...
    @property
    def override_bloom5_tint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom5_tint.setter
    def override_bloom5_tint(self, value: bool) -> None:
        ...
    @property
    def override_bloom5_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom5_size.setter
    def override_bloom5_size(self, value: bool) -> None:
        ...
    @property
    def override_bloom6_tint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom6_tint.setter
    def override_bloom6_tint(self, value: bool) -> None:
        ...
    @property
    def override_bloom6_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom6_size.setter
    def override_bloom6_size(self, value: bool) -> None:
        ...
    @property
    def override_bloom_size_scale(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_size_scale.setter
    def override_bloom_size_scale(self, value: bool) -> None:
        ...
    @property
    def override_bloom_convolution_texture(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_convolution_texture.setter
    def override_bloom_convolution_texture(self, value: bool) -> None:
        ...
    @property
    def override_bloom_convolution_scatter_dispersion(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_convolution_scatter_dispersion.setter
    def override_bloom_convolution_scatter_dispersion(self, value: bool) -> None:
        ...
    @property
    def override_bloom_convolution_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_convolution_size.setter
    def override_bloom_convolution_size(self, value: bool) -> None:
        ...
    @property
    def override_bloom_convolution_center_uv(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_convolution_center_uv.setter
    def override_bloom_convolution_center_uv(self, value: bool) -> None:
        ...
    @property
    def override_bloom_convolution_pre_filter_min(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_convolution_pre_filter_min.setter
    def override_bloom_convolution_pre_filter_min(self, value: bool) -> None:
        ...
    @property
    def override_bloom_convolution_pre_filter_max(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_convolution_pre_filter_max.setter
    def override_bloom_convolution_pre_filter_max(self, value: bool) -> None:
        ...
    @property
    def override_bloom_convolution_pre_filter_mult(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_convolution_pre_filter_mult.setter
    def override_bloom_convolution_pre_filter_mult(self, value: bool) -> None:
        ...
    @property
    def override_bloom_convolution_buffer_scale(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_convolution_buffer_scale.setter
    def override_bloom_convolution_buffer_scale(self, value: bool) -> None:
        ...
    @property
    def override_bloom_dirt_mask_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_dirt_mask_intensity.setter
    def override_bloom_dirt_mask_intensity(self, value: bool) -> None:
        ...
    @property
    def override_bloom_dirt_mask_tint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_dirt_mask_tint.setter
    def override_bloom_dirt_mask_tint(self, value: bool) -> None:
        ...
    @property
    def override_bloom_dirt_mask(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_bloom_dirt_mask.setter
    def override_bloom_dirt_mask(self, value: bool) -> None:
        ...
    @property
    def override_camera_shutter_speed(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_camera_shutter_speed.setter
    def override_camera_shutter_speed(self, value: bool) -> None:
        ...
    @property
    def override_camera_iso(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_camera_iso.setter
    def override_camera_iso(self, value: bool) -> None:
        ...
    @property
    def override_auto_exposure_method(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_auto_exposure_method.setter
    def override_auto_exposure_method(self, value: bool) -> None:
        ...
    @property
    def override_auto_exposure_low_percent(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_auto_exposure_low_percent.setter
    def override_auto_exposure_low_percent(self, value: bool) -> None:
        ...
    @property
    def b_override_eye_adaptation_low_percent(self) -> bool:
        r"""
        deprecated: 'b_override_eye_adaptation_low_percent' was renamed to 'override_auto_exposure_low_percent'.
        """
        ...
    @b_override_eye_adaptation_low_percent.setter
    def b_override_eye_adaptation_low_percent(self, value: bool) -> None:
        ...
    @property
    def override_auto_exposure_high_percent(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_auto_exposure_high_percent.setter
    def override_auto_exposure_high_percent(self, value: bool) -> None:
        ...
    @property
    def b_override_eye_adaptation_high_percent(self) -> bool:
        r"""
        deprecated: 'b_override_eye_adaptation_high_percent' was renamed to 'override_auto_exposure_high_percent'.
        """
        ...
    @b_override_eye_adaptation_high_percent.setter
    def b_override_eye_adaptation_high_percent(self, value: bool) -> None:
        ...
    @property
    def override_auto_exposure_min_brightness(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_auto_exposure_min_brightness.setter
    def override_auto_exposure_min_brightness(self, value: bool) -> None:
        ...
    @property
    def b_override_eye_adaptation_min_brightness(self) -> bool:
        r"""
        deprecated: 'b_override_eye_adaptation_min_brightness' was renamed to 'override_auto_exposure_min_brightness'.
        """
        ...
    @b_override_eye_adaptation_min_brightness.setter
    def b_override_eye_adaptation_min_brightness(self, value: bool) -> None:
        ...
    @property
    def override_auto_exposure_max_brightness(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_auto_exposure_max_brightness.setter
    def override_auto_exposure_max_brightness(self, value: bool) -> None:
        ...
    @property
    def b_override_eye_adaptation_max_brightness(self) -> bool:
        r"""
        deprecated: 'b_override_eye_adaptation_max_brightness' was renamed to 'override_auto_exposure_max_brightness'.
        """
        ...
    @b_override_eye_adaptation_max_brightness.setter
    def b_override_eye_adaptation_max_brightness(self, value: bool) -> None:
        ...
    @property
    def override_auto_exposure_speed_up(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_auto_exposure_speed_up.setter
    def override_auto_exposure_speed_up(self, value: bool) -> None:
        ...
    @property
    def b_override_eye_adaption_speed_up(self) -> bool:
        r"""
        deprecated: 'b_override_eye_adaption_speed_up' was renamed to 'override_auto_exposure_speed_up'.
        """
        ...
    @b_override_eye_adaption_speed_up.setter
    def b_override_eye_adaption_speed_up(self, value: bool) -> None:
        ...
    @property
    def override_auto_exposure_speed_down(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_auto_exposure_speed_down.setter
    def override_auto_exposure_speed_down(self, value: bool) -> None:
        ...
    @property
    def b_override_eye_adaption_speed_down(self) -> bool:
        r"""
        deprecated: 'b_override_eye_adaption_speed_down' was renamed to 'override_auto_exposure_speed_down'.
        """
        ...
    @b_override_eye_adaption_speed_down.setter
    def b_override_eye_adaption_speed_down(self, value: bool) -> None:
        ...
    @property
    def override_auto_exposure_bias(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_auto_exposure_bias.setter
    def override_auto_exposure_bias(self, value: bool) -> None:
        ...
    @property
    def b_override_exposure_offset(self) -> bool:
        r"""
        deprecated: 'b_override_exposure_offset' was renamed to 'override_auto_exposure_bias'.
        """
        ...
    @b_override_exposure_offset.setter
    def b_override_exposure_offset(self, value: bool) -> None:
        ...
    @property
    def override_auto_exposure_bias_curve(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_auto_exposure_bias_curve.setter
    def override_auto_exposure_bias_curve(self, value: bool) -> None:
        ...
    @property
    def override_auto_exposure_meter_mask(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_auto_exposure_meter_mask.setter
    def override_auto_exposure_meter_mask(self, value: bool) -> None:
        ...
    @property
    def override_auto_exposure_apply_physical_camera_exposure(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_auto_exposure_apply_physical_camera_exposure.setter
    def override_auto_exposure_apply_physical_camera_exposure(self, value: bool) -> None:
        ...
    @property
    def override_histogram_log_min(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_histogram_log_min.setter
    def override_histogram_log_min(self, value: bool) -> None:
        ...
    @property
    def override_histogram_log_max(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_histogram_log_max.setter
    def override_histogram_log_max(self, value: bool) -> None:
        ...
    @property
    def override_local_exposure_highlight_contrast_scale(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_local_exposure_highlight_contrast_scale.setter
    def override_local_exposure_highlight_contrast_scale(self, value: bool) -> None:
        ...
    @property
    def override_local_exposure_shadow_contrast_scale(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_local_exposure_shadow_contrast_scale.setter
    def override_local_exposure_shadow_contrast_scale(self, value: bool) -> None:
        ...
    @property
    def override_local_exposure_highlight_contrast_curve(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_local_exposure_highlight_contrast_curve.setter
    def override_local_exposure_highlight_contrast_curve(self, value: bool) -> None:
        ...
    @property
    def override_local_exposure_shadow_contrast_curve(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_local_exposure_shadow_contrast_curve.setter
    def override_local_exposure_shadow_contrast_curve(self, value: bool) -> None:
        ...
    @property
    def override_local_exposure_highlight_threshold(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_local_exposure_highlight_threshold.setter
    def override_local_exposure_highlight_threshold(self, value: bool) -> None:
        ...
    @property
    def override_local_exposure_shadow_threshold(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_local_exposure_shadow_threshold.setter
    def override_local_exposure_shadow_threshold(self, value: bool) -> None:
        ...
    @property
    def override_local_exposure_detail_strength(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_local_exposure_detail_strength.setter
    def override_local_exposure_detail_strength(self, value: bool) -> None:
        ...
    @property
    def override_local_exposure_blurred_luminance_blend(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_local_exposure_blurred_luminance_blend.setter
    def override_local_exposure_blurred_luminance_blend(self, value: bool) -> None:
        ...
    @property
    def override_local_exposure_blurred_luminance_kernel_size_percent(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_local_exposure_blurred_luminance_kernel_size_percent.setter
    def override_local_exposure_blurred_luminance_kernel_size_percent(self, value: bool) -> None:
        ...
    @property
    def override_local_exposure_middle_grey_bias(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_local_exposure_middle_grey_bias.setter
    def override_local_exposure_middle_grey_bias(self, value: bool) -> None:
        ...
    @property
    def override_lens_flare_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lens_flare_intensity.setter
    def override_lens_flare_intensity(self, value: bool) -> None:
        ...
    @property
    def override_lens_flare_tint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lens_flare_tint.setter
    def override_lens_flare_tint(self, value: bool) -> None:
        ...
    @property
    def override_lens_flare_tints(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lens_flare_tints.setter
    def override_lens_flare_tints(self, value: bool) -> None:
        ...
    @property
    def override_lens_flare_bokeh_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lens_flare_bokeh_size.setter
    def override_lens_flare_bokeh_size(self, value: bool) -> None:
        ...
    @property
    def override_lens_flare_bokeh_shape(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lens_flare_bokeh_shape.setter
    def override_lens_flare_bokeh_shape(self, value: bool) -> None:
        ...
    @property
    def override_lens_flare_threshold(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lens_flare_threshold.setter
    def override_lens_flare_threshold(self, value: bool) -> None:
        ...
    @property
    def override_vignette_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_vignette_intensity.setter
    def override_vignette_intensity(self, value: bool) -> None:
        ...
    @property
    def override_sharpen(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_sharpen.setter
    def override_sharpen(self, value: bool) -> None:
        ...
    @property
    def override_film_grain_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_grain_intensity.setter
    def override_film_grain_intensity(self, value: bool) -> None:
        ...
    @property
    def override_film_grain_intensity_shadows(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_grain_intensity_shadows.setter
    def override_film_grain_intensity_shadows(self, value: bool) -> None:
        ...
    @property
    def override_film_grain_intensity_midtones(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_grain_intensity_midtones.setter
    def override_film_grain_intensity_midtones(self, value: bool) -> None:
        ...
    @property
    def override_film_grain_intensity_highlights(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_grain_intensity_highlights.setter
    def override_film_grain_intensity_highlights(self, value: bool) -> None:
        ...
    @property
    def override_film_grain_shadows_max(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_grain_shadows_max.setter
    def override_film_grain_shadows_max(self, value: bool) -> None:
        ...
    @property
    def override_film_grain_highlights_min(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_grain_highlights_min.setter
    def override_film_grain_highlights_min(self, value: bool) -> None:
        ...
    @property
    def override_film_grain_highlights_max(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_grain_highlights_max.setter
    def override_film_grain_highlights_max(self, value: bool) -> None:
        ...
    @property
    def override_film_grain_texel_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_grain_texel_size.setter
    def override_film_grain_texel_size(self, value: bool) -> None:
        ...
    @property
    def override_film_grain_texture(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_film_grain_texture.setter
    def override_film_grain_texture(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_intensity.setter
    def override_ambient_occlusion_intensity(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_static_fraction(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_static_fraction.setter
    def override_ambient_occlusion_static_fraction(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_radius(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_radius.setter
    def override_ambient_occlusion_radius(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_fade_distance(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_fade_distance.setter
    def override_ambient_occlusion_fade_distance(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_fade_radius(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_fade_radius.setter
    def override_ambient_occlusion_fade_radius(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_radius_in_ws(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_radius_in_ws.setter
    def override_ambient_occlusion_radius_in_ws(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_power(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_power.setter
    def override_ambient_occlusion_power(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_bias(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_bias.setter
    def override_ambient_occlusion_bias(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_quality(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_quality.setter
    def override_ambient_occlusion_quality(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_mip_blend(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_mip_blend.setter
    def override_ambient_occlusion_mip_blend(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_mip_scale(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_mip_scale.setter
    def override_ambient_occlusion_mip_scale(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_mip_threshold(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_mip_threshold.setter
    def override_ambient_occlusion_mip_threshold(self, value: bool) -> None:
        ...
    @property
    def override_ambient_occlusion_temporal_blend_weight(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ambient_occlusion_temporal_blend_weight.setter
    def override_ambient_occlusion_temporal_blend_weight(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_ao(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_ao.setter
    def override_ray_tracing_ao(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_ao_samples_per_pixel(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_ao_samples_per_pixel.setter
    def override_ray_tracing_ao_samples_per_pixel(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_ao_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_ao_intensity.setter
    def override_ray_tracing_ao_intensity(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_ao_radius(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_ao_radius.setter
    def override_ray_tracing_ao_radius(self, value: bool) -> None:
        ...
    @property
    def override_indirect_lighting_color(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_indirect_lighting_color.setter
    def override_indirect_lighting_color(self, value: bool) -> None:
        ...
    @property
    def override_indirect_lighting_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_indirect_lighting_intensity.setter
    def override_indirect_lighting_intensity(self, value: bool) -> None:
        ...
    @property
    def override_color_grading_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_grading_intensity.setter
    def override_color_grading_intensity(self, value: bool) -> None:
        ...
    @property
    def override_color_grading_lut(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_color_grading_lut.setter
    def override_color_grading_lut(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_focal_distance(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_focal_distance.setter
    def override_depth_of_field_focal_distance(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_fstop(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_fstop.setter
    def override_depth_of_field_fstop(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_min_fstop(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_min_fstop.setter
    def override_depth_of_field_min_fstop(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_blade_count(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_blade_count.setter
    def override_depth_of_field_blade_count(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_sensor_width(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_sensor_width.setter
    def override_depth_of_field_sensor_width(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_squeeze_factor(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_squeeze_factor.setter
    def override_depth_of_field_squeeze_factor(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_depth_blur_radius(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_depth_blur_radius.setter
    def override_depth_of_field_depth_blur_radius(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_use_hair_depth(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_use_hair_depth.setter
    def override_depth_of_field_use_hair_depth(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_depth_blur_amount(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_depth_blur_amount.setter
    def override_depth_of_field_depth_blur_amount(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_focal_region(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_focal_region.setter
    def override_depth_of_field_focal_region(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_near_transition_region(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_near_transition_region.setter
    def override_depth_of_field_near_transition_region(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_far_transition_region(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_far_transition_region.setter
    def override_depth_of_field_far_transition_region(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_scale(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_scale.setter
    def override_depth_of_field_scale(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_near_blur_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_near_blur_size.setter
    def override_depth_of_field_near_blur_size(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_far_blur_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_far_blur_size.setter
    def override_depth_of_field_far_blur_size(self, value: bool) -> None:
        ...
    @property
    def override_mobile_hq_gaussian(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_mobile_hq_gaussian.setter
    def override_mobile_hq_gaussian(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_occlusion(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_occlusion.setter
    def override_depth_of_field_occlusion(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_sky_focus_distance(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_sky_focus_distance.setter
    def override_depth_of_field_sky_focus_distance(self, value: bool) -> None:
        ...
    @property
    def override_depth_of_field_vignette_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_depth_of_field_vignette_size.setter
    def override_depth_of_field_vignette_size(self, value: bool) -> None:
        ...
    @property
    def override_motion_blur_amount(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_motion_blur_amount.setter
    def override_motion_blur_amount(self, value: bool) -> None:
        ...
    @property
    def override_motion_blur_max(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_motion_blur_max.setter
    def override_motion_blur_max(self, value: bool) -> None:
        ...
    @property
    def override_motion_blur_target_fps(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_motion_blur_target_fps.setter
    def override_motion_blur_target_fps(self, value: bool) -> None:
        ...
    @property
    def override_motion_blur_per_object_size(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_motion_blur_per_object_size.setter
    def override_motion_blur_per_object_size(self, value: bool) -> None:
        ...
    @property
    def override_reflection_method(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_reflection_method.setter
    def override_reflection_method(self, value: bool) -> None:
        ...
    @property
    def override_lumen_reflection_quality(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_reflection_quality.setter
    def override_lumen_reflection_quality(self, value: bool) -> None:
        ...
    @property
    def override_screen_space_reflection_intensity(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_screen_space_reflection_intensity.setter
    def override_screen_space_reflection_intensity(self, value: bool) -> None:
        ...
    @property
    def override_screen_space_reflection_quality(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_screen_space_reflection_quality.setter
    def override_screen_space_reflection_quality(self, value: bool) -> None:
        ...
    @property
    def override_screen_space_reflection_max_roughness(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_screen_space_reflection_max_roughness.setter
    def override_screen_space_reflection_max_roughness(self, value: bool) -> None:
        ...
    @property
    def override_screen_space_reflection_roughness_scale(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_screen_space_reflection_roughness_scale.setter
    def override_screen_space_reflection_roughness_scale(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_reflections_max_roughness(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_reflections_max_roughness.setter
    def override_ray_tracing_reflections_max_roughness(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_reflections_max_bounces(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_reflections_max_bounces.setter
    def override_ray_tracing_reflections_max_bounces(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_reflections_samples_per_pixel(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_reflections_samples_per_pixel.setter
    def override_ray_tracing_reflections_samples_per_pixel(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_reflections_shadows(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_reflections_shadows.setter
    def override_ray_tracing_reflections_shadows(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_reflections_translucency(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_reflections_translucency.setter
    def override_ray_tracing_reflections_translucency(self, value: bool) -> None:
        ...
    @property
    def override_translucency_type(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_translucency_type.setter
    def override_translucency_type(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_translucency_max_roughness(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_translucency_max_roughness.setter
    def override_ray_tracing_translucency_max_roughness(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_translucency_refraction_rays(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_translucency_refraction_rays.setter
    def override_ray_tracing_translucency_refraction_rays(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_translucency_samples_per_pixel(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_translucency_samples_per_pixel.setter
    def override_ray_tracing_translucency_samples_per_pixel(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_translucency_shadows(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_translucency_shadows.setter
    def override_ray_tracing_translucency_shadows(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_translucency_refraction(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_translucency_refraction.setter
    def override_ray_tracing_translucency_refraction(self, value: bool) -> None:
        ...
    @property
    def override_dynamic_global_illumination_method(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_dynamic_global_illumination_method.setter
    def override_dynamic_global_illumination_method(self, value: bool) -> None:
        ...
    @property
    def override_lumen_scene_lighting_quality(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_scene_lighting_quality.setter
    def override_lumen_scene_lighting_quality(self, value: bool) -> None:
        ...
    @property
    def override_lumen_scene_detail(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_scene_detail.setter
    def override_lumen_scene_detail(self, value: bool) -> None:
        ...
    @property
    def override_lumen_scene_view_distance(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_scene_view_distance.setter
    def override_lumen_scene_view_distance(self, value: bool) -> None:
        ...
    @property
    def override_lumen_scene_lighting_update_speed(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_scene_lighting_update_speed.setter
    def override_lumen_scene_lighting_update_speed(self, value: bool) -> None:
        ...
    @property
    def override_lumen_final_gather_quality(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_final_gather_quality.setter
    def override_lumen_final_gather_quality(self, value: bool) -> None:
        ...
    @property
    def override_lumen_final_gather_lighting_update_speed(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_final_gather_lighting_update_speed.setter
    def override_lumen_final_gather_lighting_update_speed(self, value: bool) -> None:
        ...
    @property
    def override_lumen_final_gather_screen_traces(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_final_gather_screen_traces.setter
    def override_lumen_final_gather_screen_traces(self, value: bool) -> None:
        ...
    @property
    def override_lumen_max_trace_distance(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_max_trace_distance.setter
    def override_lumen_max_trace_distance(self, value: bool) -> None:
        ...
    @property
    def override_lumen_diffuse_color_boost(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_diffuse_color_boost.setter
    def override_lumen_diffuse_color_boost(self, value: bool) -> None:
        ...
    @property
    def override_lumen_skylight_leaking(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_skylight_leaking.setter
    def override_lumen_skylight_leaking(self, value: bool) -> None:
        ...
    @property
    def override_lumen_full_skylight_leaking_distance(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_full_skylight_leaking_distance.setter
    def override_lumen_full_skylight_leaking_distance(self, value: bool) -> None:
        ...
    @property
    def override_lumen_ray_lighting_mode(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_ray_lighting_mode.setter
    def override_lumen_ray_lighting_mode(self, value: bool) -> None:
        ...
    @property
    def override_lumen_reflections_screen_traces(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_reflections_screen_traces.setter
    def override_lumen_reflections_screen_traces(self, value: bool) -> None:
        ...
    @property
    def override_lumen_front_layer_translucency_reflections(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_front_layer_translucency_reflections.setter
    def override_lumen_front_layer_translucency_reflections(self, value: bool) -> None:
        ...
    @property
    def override_lumen_max_roughness_to_trace_reflections(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_max_roughness_to_trace_reflections.setter
    def override_lumen_max_roughness_to_trace_reflections(self, value: bool) -> None:
        ...
    @property
    def override_lumen_max_reflection_bounces(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_max_reflection_bounces.setter
    def override_lumen_max_reflection_bounces(self, value: bool) -> None:
        ...
    @property
    def override_lumen_max_refraction_bounces(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_max_refraction_bounces.setter
    def override_lumen_max_refraction_bounces(self, value: bool) -> None:
        ...
    @property
    def override_lumen_surface_cache_resolution(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_lumen_surface_cache_resolution.setter
    def override_lumen_surface_cache_resolution(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_gi(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_gi.setter
    def override_ray_tracing_gi(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_gi_max_bounces(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_gi_max_bounces.setter
    def override_ray_tracing_gi_max_bounces(self, value: bool) -> None:
        ...
    @property
    def override_ray_tracing_gi_samples_per_pixel(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_ray_tracing_gi_samples_per_pixel.setter
    def override_ray_tracing_gi_samples_per_pixel(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_max_bounces(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_max_bounces.setter
    def override_path_tracing_max_bounces(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_samples_per_pixel(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_samples_per_pixel.setter
    def override_path_tracing_samples_per_pixel(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_max_path_exposure(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_max_path_exposure.setter
    def override_path_tracing_max_path_exposure(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_enable_emissive_materials(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_enable_emissive_materials.setter
    def override_path_tracing_enable_emissive_materials(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_enable_reference_dof(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_enable_reference_dof.setter
    def override_path_tracing_enable_reference_dof(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_enable_reference_atmosphere(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_enable_reference_atmosphere.setter
    def override_path_tracing_enable_reference_atmosphere(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_enable_denoiser(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_enable_denoiser.setter
    def override_path_tracing_enable_denoiser(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_include_emissive(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_include_emissive.setter
    def override_path_tracing_include_emissive(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_include_diffuse(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_include_diffuse.setter
    def override_path_tracing_include_diffuse(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_include_indirect_diffuse(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_include_indirect_diffuse.setter
    def override_path_tracing_include_indirect_diffuse(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_include_specular(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_include_specular.setter
    def override_path_tracing_include_specular(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_include_indirect_specular(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_include_indirect_specular.setter
    def override_path_tracing_include_indirect_specular(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_include_volume(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_include_volume.setter
    def override_path_tracing_include_volume(self, value: bool) -> None:
        ...
    @property
    def override_path_tracing_include_indirect_volume(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_path_tracing_include_indirect_volume.setter
    def override_path_tracing_include_indirect_volume(self, value: bool) -> None:
        ...
    @property
    def mobile_hq_gaussian(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable HQ Gaussian on high end mobile platforms. (ES3_1)
        """
        ...
    @mobile_hq_gaussian.setter
    def mobile_hq_gaussian(self, value: bool) -> None:
        ...
    @property
    def bloom_method(self) -> BloomMethod:
        r"""
        (BloomMethod):  [Read-Write] Bloom algorithm
        """
        ...
    @bloom_method.setter
    def bloom_method(self, value: BloomMethod) -> None:
        ...
    @property
    def auto_exposure_method(self) -> AutoExposureMethod:
        r"""
        (AutoExposureMethod):  [Read-Write] Luminance computation method
        """
        ...
    @auto_exposure_method.setter
    def auto_exposure_method(self, value: AutoExposureMethod) -> None:
        ...
    @property
    def temperature_type(self) -> TemperatureMethod:
        r"""
        (TemperatureMethod):  [Read-Write] Selects the type of temperature calculation.
        White Balance uses the Temperature value to control the virtual camera's White Balance. This is the default selection.
        Color Temperature uses the Temperature value to adjust the color temperature of the scene, which is the inverse of the White Balance operation.
        """
        ...
    @temperature_type.setter
    def temperature_type(self, value: TemperatureMethod) -> None:
        ...
    @property
    def white_temp(self) -> float:
        r"""
        (float):  [Read-Write] Controls the color temperature or white balance in degrees Kelvin which the scene considers as white light.
        """
        ...
    @white_temp.setter
    def white_temp(self, value: float) -> None:
        ...
    @property
    def white_tint(self) -> float:
        r"""
        (float):  [Read-Write] Controls the color of the scene along the magenta - green axis (orthogonal to the color temperature).  This feature is equivalent to color tint in digital cameras.
        """
        ...
    @white_tint.setter
    def white_tint(self, value: float) -> None:
        ...
    @property
    def color_saturation(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the intensity of the color(hue) for the entire image.Higher values will result in more vibrant colors.
        """
        ...
    @color_saturation.setter
    def color_saturation(self, value: Vector4) -> None:
        ...
    @property
    def color_contrast(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the range of light and dark values in your scene. Lower values will reduce the difference between bright and dark areas while higher values will increase the difference between the bright and dark areas.
        """
        ...
    @color_contrast.setter
    def color_contrast(self, value: Vector4) -> None:
        ...
    @property
    def color_gamma(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the luminance curve of the scene. Raising or lowering this value will result brightening or darkening the mid-tones of the entire image.
        """
        ...
    @color_gamma.setter
    def color_gamma(self, value: Vector4) -> None:
        ...
    @property
    def color_gain(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] This value multiplies the colors of the image.  Raising or lowering this value will result in brightening or darkening the entire scene.
        """
        ...
    @color_gain.setter
    def color_gain(self, value: Vector4) -> None:
        ...
    @property
    def color_offset(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] This value is added to the colors of the scene.  Raising or lowering this value will result in the image being more or less washed-out.
        """
        ...
    @color_offset.setter
    def color_offset(self, value: Vector4) -> None:
        ...
    @property
    def color_saturation_shadows(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the intensity of the colors (hue) in the shadow region of the image.  Higher values will result in more vibrant colors.
        """
        ...
    @color_saturation_shadows.setter
    def color_saturation_shadows(self, value: Vector4) -> None:
        ...
    @property
    def color_contrast_shadows(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the range of light and dark values in your scene. Lower values will reduce the difference between bright and dark areas while higher values will increase the difference between the bright and dark areas.
        """
        ...
    @color_contrast_shadows.setter
    def color_contrast_shadows(self, value: Vector4) -> None:
        ...
    @property
    def color_gamma_shadows(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the luminance curve of the shadow region. Raising or lowering this value will result brightening or darkening the mid-tones of the shadow region.
        """
        ...
    @color_gamma_shadows.setter
    def color_gamma_shadows(self, value: Vector4) -> None:
        ...
    @property
    def color_gain_shadows(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] This value multiplies the colors in the shadow region.  Raising or lowering this value will result in brightening or darkening the affected region.
        """
        ...
    @color_gain_shadows.setter
    def color_gain_shadows(self, value: Vector4) -> None:
        ...
    @property
    def color_offset_shadows(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] This value is added to the colors in the shadow region.  Raising or lowering this value will result in the shadows being more or less washed-out.
        """
        ...
    @color_offset_shadows.setter
    def color_offset_shadows(self, value: Vector4) -> None:
        ...
    @property
    def color_saturation_midtones(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the intensity of the colors (hue) in the mid-tone region of the image.  Higher values will result in more vibrant colors.
        """
        ...
    @color_saturation_midtones.setter
    def color_saturation_midtones(self, value: Vector4) -> None:
        ...
    @property
    def color_contrast_midtones(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the range of light and dark values in the mid-tone region. Lower values will reduce the difference between bright and dark areas while higher values will increase the difference between the bright and dark areas.
        """
        ...
    @color_contrast_midtones.setter
    def color_contrast_midtones(self, value: Vector4) -> None:
        ...
    @property
    def color_gamma_midtones(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the luminance curve of the mid-tone region of the image. Raising or lowering this value will result brightening or darkening the mid-tones of the image.
        """
        ...
    @color_gamma_midtones.setter
    def color_gamma_midtones(self, value: Vector4) -> None:
        ...
    @property
    def color_gain_midtones(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] This value multiplies the colors in the mid-tone region of the image.  Raising or lowering this value will result in brightening or darkening the affected region.
        """
        ...
    @color_gain_midtones.setter
    def color_gain_midtones(self, value: Vector4) -> None:
        ...
    @property
    def color_offset_midtones(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] This value is added to the colors in the mid-tone region of the image.  Raising or lowering this value will result in the mid-tones being more or less washed-out.
        """
        ...
    @color_offset_midtones.setter
    def color_offset_midtones(self, value: Vector4) -> None:
        ...
    @property
    def color_saturation_highlights(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the intensity of the color (hue) for the highlights region of the image.  Higher values will result in more vibrant colors.
        """
        ...
    @color_saturation_highlights.setter
    def color_saturation_highlights(self, value: Vector4) -> None:
        ...
    @property
    def color_contrast_highlights(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the range of light and dark values in the highlights region. Lower values will reduce the difference between bright and dark areas while higher values will increase the difference between the bright and dark areas.
        """
        ...
    @color_contrast_highlights.setter
    def color_contrast_highlights(self, value: Vector4) -> None:
        ...
    @property
    def color_gamma_highlights(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Control the luminance curve of the highlight region. Raising or lowering this value will result brightening or darkening the mid-tones of the highlight region.
        """
        ...
    @color_gamma_highlights.setter
    def color_gamma_highlights(self, value: Vector4) -> None:
        ...
    @property
    def color_gain_highlights(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] This value multiplies the colors in the highlight region.  Raising or lowering this value will result in brightening or darkening the affected region.
        """
        ...
    @color_gain_highlights.setter
    def color_gain_highlights(self, value: Vector4) -> None:
        ...
    @property
    def color_offset_highlights(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] This value is added to the colors in the highlight region.  Raising or lowering this value will result in the highlights being more or less washed-out.
        """
        ...
    @color_offset_highlights.setter
    def color_offset_highlights(self, value: Vector4) -> None:
        ...
    @property
    def color_correction_highlights_min(self) -> float:
        r"""
        (float):  [Read-Write] This value sets the lower threshold for what is considered to be the highlight region of the image.
        """
        ...
    @color_correction_highlights_min.setter
    def color_correction_highlights_min(self, value: float) -> None:
        ...
    @property
    def color_correction_highlights_max(self) -> float:
        r"""
        (float):  [Read-Write] This value sets the upper threshold for what is considered to be the highlight region of the image.  This value should be larger than HighlightsMin. Default is 1.0, for backwards compatibility
        """
        ...
    @color_correction_highlights_max.setter
    def color_correction_highlights_max(self, value: float) -> None:
        ...
    @property
    def color_correction_shadows_max(self) -> float:
        r"""
        (float):  [Read-Write] This value sets the threshold for what is considered to be the shadow region of the image.
        """
        ...
    @color_correction_shadows_max.setter
    def color_correction_shadows_max(self, value: float) -> None:
        ...
    @property
    def blue_correction(self) -> float:
        r"""
        (float):  [Read-Write] Correct for artifacts with "electric" blues due to the ACEScg color space. Bright blue desaturates instead of going to violet.
        """
        ...
    @blue_correction.setter
    def blue_correction(self, value: float) -> None:
        ...
    @property
    def expand_gamut(self) -> float:
        r"""
        (float):  [Read-Write] Expand bright saturated colors outside the sRGB gamut to fake wide gamut rendering.
        """
        ...
    @expand_gamut.setter
    def expand_gamut(self, value: float) -> None:
        ...
    @property
    def tone_curve_amount(self) -> float:
        r"""
        (float):  [Read-Write] Allow effect of Tone Curve to be reduced (Set ToneCurveAmount and ExpandGamut to 0.0 to fully disable tone curve)
        """
        ...
    @tone_curve_amount.setter
    def tone_curve_amount(self, value: float) -> None:
        ...
    @property
    def film_slope(self) -> float:
        r"""
        (float):  [Read-Write] Controls the overall steepness of the tonemapper curve.  Larger values increase scene contrast and smaller values reduce contrast.
        """
        ...
    @film_slope.setter
    def film_slope(self, value: float) -> None:
        ...
    @property
    def film_toe(self) -> float:
        r"""
        (float):  [Read-Write] Controls the contrast of the dark end of the tonemapper curve. Larger values increase contrast and smaller values decrease contrast.
        """
        ...
    @film_toe.setter
    def film_toe(self, value: float) -> None:
        ...
    @property
    def film_shoulder(self) -> float:
        r"""
        (float):  [Read-Write] Sometimes referred to as highlight rolloff.  Controls the contrast of the bright end of the tonemapper curve. Larger values increase contrast and smaller values decrease contrast.
        """
        ...
    @film_shoulder.setter
    def film_shoulder(self, value: float) -> None:
        ...
    @property
    def film_black_clip(self) -> float:
        r"""
        (float):  [Read-Write] Lowers the toe of the tonemapper curve by this amount. Increasing this value causes more of the scene to clip to black.  For most purposes, this property should remain 0
        """
        ...
    @film_black_clip.setter
    def film_black_clip(self, value: float) -> None:
        ...
    @property
    def film_white_clip(self) -> float:
        r"""
        (float):  [Read-Write] Controls the height of the tonemapper curve.  Raising this value can cause bright values to more quickly approach fully-saturated white.
        """
        ...
    @film_white_clip.setter
    def film_white_clip(self, value: float) -> None:
        ...
    @property
    def scene_color_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Scene tint color
        """
        ...
    @scene_color_tint.setter
    def scene_color_tint(self, value: LinearColor) -> None:
        ...
    @property
    def scene_fringe_intensity(self) -> float:
        r"""
        (float):  [Read-Write] in percent, Scene chromatic aberration / color fringe (camera imperfection) to simulate an artifact that happens in real-world lens, mostly visible in the image corners.
        """
        ...
    @scene_fringe_intensity.setter
    def scene_fringe_intensity(self, value: float) -> None:
        ...
    @property
    def chromatic_aberration_start_offset(self) -> float:
        r"""
        (float):  [Read-Write] A normalized distance to the center of the framebuffer where the effect takes place.
        """
        ...
    @chromatic_aberration_start_offset.setter
    def chromatic_aberration_start_offset(self, value: float) -> None:
        ...
    @property
    def bloom_intensity(self) -> float:
        r"""
        (float):  [Read-Write] Multiplier for all bloom contributions >=0: off, 1(default), >1 brighter
        """
        ...
    @bloom_intensity.setter
    def bloom_intensity(self, value: float) -> None:
        ...
    @property
    def bloom_threshold(self) -> float:
        r"""
        (float):  [Read-Write] minimum brightness the bloom starts having effect
        -1:all pixels affect bloom equally (physically correct, faster as a threshold pass is omitted), 0:all pixels affect bloom brights more, 1(default), >1 brighter
        """
        ...
    @bloom_threshold.setter
    def bloom_threshold(self, value: float) -> None:
        ...
    @property
    def bloom_size_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scale for all bloom sizes
        """
        ...
    @bloom_size_scale.setter
    def bloom_size_scale(self, value: float) -> None:
        ...
    @property
    def bloom1_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for the Bloom1 in percent of the screen width
        (is done in 1/2 resolution, larger values cost more performance, good for high frequency details)
        >=0: can be clamped because of shader limitations
        """
        ...
    @bloom1_size.setter
    def bloom1_size(self, value: float) -> None:
        ...
    @property
    def bloom2_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for Bloom2 in percent of the screen width
        (is done in 1/4 resolution, larger values cost more performance)
        >=0: can be clamped because of shader limitations
        """
        ...
    @bloom2_size.setter
    def bloom2_size(self, value: float) -> None:
        ...
    @property
    def bloom3_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for Bloom3 in percent of the screen width
        (is done in 1/8 resolution, larger values cost more performance)
        >=0: can be clamped because of shader limitations
        """
        ...
    @bloom3_size.setter
    def bloom3_size(self, value: float) -> None:
        ...
    @property
    def bloom4_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for Bloom4 in percent of the screen width
        (is done in 1/16 resolution, larger values cost more performance, best for wide contributions)
        >=0: can be clamped because of shader limitations
        """
        ...
    @bloom4_size.setter
    def bloom4_size(self, value: float) -> None:
        ...
    @property
    def bloom5_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for Bloom5 in percent of the screen width
        (is done in 1/32 resolution, larger values cost more performance, best for wide contributions)
        >=0: can be clamped because of shader limitations
        """
        ...
    @bloom5_size.setter
    def bloom5_size(self, value: float) -> None:
        ...
    @property
    def bloom6_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for Bloom6 in percent of the screen width
        (is done in 1/64 resolution, larger values cost more performance, best for wide contributions)
        >=0: can be clamped because of shader limitations
        """
        ...
    @bloom6_size.setter
    def bloom6_size(self, value: float) -> None:
        ...
    @property
    def bloom1_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom1 tint color
        """
        ...
    @bloom1_tint.setter
    def bloom1_tint(self, value: LinearColor) -> None:
        ...
    @property
    def bloom2_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom2 tint color
        """
        ...
    @bloom2_tint.setter
    def bloom2_tint(self, value: LinearColor) -> None:
        ...
    @property
    def bloom3_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom3 tint color
        """
        ...
    @bloom3_tint.setter
    def bloom3_tint(self, value: LinearColor) -> None:
        ...
    @property
    def bloom4_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom4 tint color
        """
        ...
    @bloom4_tint.setter
    def bloom4_tint(self, value: LinearColor) -> None:
        ...
    @property
    def bloom5_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom5 tint color
        """
        ...
    @bloom5_tint.setter
    def bloom5_tint(self, value: LinearColor) -> None:
        ...
    @property
    def bloom6_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom6 tint color
        """
        ...
    @bloom6_tint.setter
    def bloom6_tint(self, value: LinearColor) -> None:
        ...
    @property
    def bloom_convolution_scatter_dispersion(self) -> float:
        r"""
        (float):  [Read-Write] Intensity multiplier on the scatter dispersion energy of the kernel. 1.0 means exactly use the same energy as the kernel scatter dispersion.
        """
        ...
    @bloom_convolution_scatter_dispersion.setter
    def bloom_convolution_scatter_dispersion(self, value: float) -> None:
        ...
    @property
    def bloom_convolution_size(self) -> float:
        r"""
        (float):  [Read-Write] Relative size of the convolution kernel image compared to the minor axis of the viewport
        """
        ...
    @bloom_convolution_size.setter
    def bloom_convolution_size(self, value: float) -> None:
        ...
    @property
    def bloom_convolution_texture(self) -> Texture2D:
        r"""
        (Texture2D):  [Read-Write] Texture to replace default convolution bloom kernel
        """
        ...
    @bloom_convolution_texture.setter
    def bloom_convolution_texture(self, value: Texture2D) -> None:
        ...
    @property
    def bloom_convolution_center_uv(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The UV location of the center of the kernel.  Should be very close to (.5,.5)
        """
        ...
    @bloom_convolution_center_uv.setter
    def bloom_convolution_center_uv(self, value: Vector2D) -> None:
        ...
    @property
    def bloom_convolution_pre_filter_min(self) -> float:
        r"""
        (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables
        """
        ...
    @bloom_convolution_pre_filter_min.setter
    def bloom_convolution_pre_filter_min(self, value: float) -> None:
        ...
    @property
    def bloom_convolution_pre_filter_max(self) -> float:
        r"""
        (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables
        """
        ...
    @bloom_convolution_pre_filter_max.setter
    def bloom_convolution_pre_filter_max(self, value: float) -> None:
        ...
    @property
    def bloom_convolution_pre_filter_mult(self) -> float:
        r"""
        (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables
        """
        ...
    @bloom_convolution_pre_filter_mult.setter
    def bloom_convolution_pre_filter_mult(self, value: float) -> None:
        ...
    @property
    def bloom_convolution_buffer_scale(self) -> float:
        r"""
        (float):  [Read-Write] Implicit buffer region as a fraction of the screen size to insure the bloom does not wrap across the screen.  Larger sizes have perf impact.
        """
        ...
    @bloom_convolution_buffer_scale.setter
    def bloom_convolution_buffer_scale(self, value: float) -> None:
        ...
    @property
    def bloom_dirt_mask(self) -> Texture:
        r"""
        (Texture):  [Read-Write] Texture that defines the dirt on the camera lens where the light of very bright objects is scattered.
        """
        ...
    @bloom_dirt_mask.setter
    def bloom_dirt_mask(self, value: Texture) -> None:
        ...
    @property
    def bloom_dirt_mask_intensity(self) -> float:
        r"""
        (float):  [Read-Write] BloomDirtMask intensity
        """
        ...
    @bloom_dirt_mask_intensity.setter
    def bloom_dirt_mask_intensity(self, value: float) -> None:
        ...
    @property
    def bloom_dirt_mask_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] BloomDirtMask tint color
        """
        ...
    @bloom_dirt_mask_tint.setter
    def bloom_dirt_mask_tint(self, value: LinearColor) -> None:
        ...
    @property
    def dynamic_global_illumination_method(self) -> DynamicGlobalIlluminationMethod:
        r"""
        (DynamicGlobalIlluminationMethod):  [Read-Write] Chooses the Dynamic Global Illumination method.  Not compatible with Forward Shading.
        """
        ...
    @dynamic_global_illumination_method.setter
    def dynamic_global_illumination_method(self, value: DynamicGlobalIlluminationMethod) -> None:
        ...
    @property
    def indirect_lighting_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Adjusts indirect lighting color. (1,1,1) is default. (0,0,0) to disable GI. The show flag 'Global Illumination' must be enabled to use this property.
        """
        ...
    @indirect_lighting_color.setter
    def indirect_lighting_color(self, value: LinearColor) -> None:
        ...
    @property
    def indirect_lighting_intensity(self) -> float:
        r"""
        (float):  [Read-Write] Scales the indirect lighting contribution. A value of 0 disables GI. Default is 1. The show flag 'Global Illumination' must be enabled to use this property.
        """
        ...
    @indirect_lighting_intensity.setter
    def indirect_lighting_intensity(self, value: float) -> None:
        ...
    @property
    def lumen_scene_lighting_quality(self) -> float:
        r"""
        (float):  [Read-Write] Scales Lumen Scene's quality.  Larger scales cause Lumen Scene to be calculated with a higher fidelity, which can be visible in reflections, but increase GPU cost.
        """
        ...
    @lumen_scene_lighting_quality.setter
    def lumen_scene_lighting_quality(self, value: float) -> None:
        ...
    @property
    def lumen_scene_detail(self) -> float:
        r"""
        (float):  [Read-Write] Controls the size of instances that can be represented in Lumen Scene.  Larger values will ensure small objects are represented, but increase GPU cost.
        """
        ...
    @lumen_scene_detail.setter
    def lumen_scene_detail(self, value: float) -> None:
        ...
    @property
    def lumen_scene_view_distance(self) -> float:
        r"""
        (float):  [Read-Write] Sets the maximum view distance of the scene that Lumen maintains for ray tracing against.  Larger values will increase the effective range of sky shadowing and Global Illumination, but increase GPU cost.
        """
        ...
    @lumen_scene_view_distance.setter
    def lumen_scene_view_distance(self, value: float) -> None:
        ...
    @property
    def lumen_scene_lighting_update_speed(self) -> float:
        r"""
        (float):  [Read-Write] Controls how much Lumen Scene is allowed to cache lighting results to improve performance.  Larger scales cause lighting changes to propagate faster, but increase GPU cost.
        """
        ...
    @lumen_scene_lighting_update_speed.setter
    def lumen_scene_lighting_update_speed(self, value: float) -> None:
        ...
    @property
    def lumen_final_gather_quality(self) -> float:
        r"""
        (float):  [Read-Write] Scales Lumen's Final Gather quality.  Larger scales reduce noise, but greatly increase GPU cost.
        """
        ...
    @lumen_final_gather_quality.setter
    def lumen_final_gather_quality(self, value: float) -> None:
        ...
    @property
    def lumen_final_gather_lighting_update_speed(self) -> float:
        r"""
        (float):  [Read-Write] Controls how much Lumen Final Gather is allowed to cache lighting results to improve performance.  Larger scales cause lighting changes to propagate faster, but increase GPU cost and noise.
        """
        ...
    @lumen_final_gather_lighting_update_speed.setter
    def lumen_final_gather_lighting_update_speed(self, value: float) -> None:
        ...
    @property
    def lumen_final_gather_screen_traces(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to use screen space traces for Lumen Global Illumination. Screen space traces bypass Lumen Scene and instead sample Scene Depth and Color. This improves quality, but at the same time prevents from Lumen Scene only changes like adding emissive objects, which are visible only in Global Illumination.
        """
        ...
    @lumen_final_gather_screen_traces.setter
    def lumen_final_gather_screen_traces(self, value: bool) -> None:
        ...
    @property
    def lumen_max_trace_distance(self) -> float:
        r"""
        (float):  [Read-Write] Controls the maximum distance that Lumen should trace while solving lighting.  Values that are too small will cause lighting to leak into large caves, while values that are large will increase GPU cost.
        """
        ...
    @lumen_max_trace_distance.setter
    def lumen_max_trace_distance(self, value: float) -> None:
        ...
    @property
    def lumen_diffuse_color_boost(self) -> float:
        r"""
        (float):  [Read-Write] Allows brightening indirect lighting by calculating material diffuse color for indirect lighting as pow(DiffuseColor, 1 / DiffuseColorBoost). Values above 1 (original diffuse color) aren't physically correct, but they can be useful as an art direction knob to increase the amount of bounced light in the scene. Best to keep below 2 as it also causes reflections to be brighter than the scene.
        """
        ...
    @lumen_diffuse_color_boost.setter
    def lumen_diffuse_color_boost(self, value: float) -> None:
        ...
    @property
    def lumen_skylight_leaking(self) -> float:
        r"""
        (float):  [Read-Write] Controls what fraction of the skylight intensity should be allowed to leak.  This can be useful as an art direction knob (non-physically based) to keep indoor areas from going fully black.
        """
        ...
    @lumen_skylight_leaking.setter
    def lumen_skylight_leaking(self, value: float) -> None:
        ...
    @property
    def lumen_full_skylight_leaking_distance(self) -> float:
        r"""
        (float):  [Read-Write] Controls the distance from a receiving surface where skylight leaking reaches its full intensity.  Smaller values make the skylight leaking flatter, while larger values create an Ambient Occlusion effect.
        """
        ...
    @lumen_full_skylight_leaking_distance.setter
    def lumen_full_skylight_leaking_distance(self, value: float) -> None:
        ...
    @property
    def lumen_surface_cache_resolution(self) -> float:
        r"""
        (float):  [Read-Write] Scale factor for Lumen Surface Cache resolution, for Scene Capture.  Smaller values save GPU memory, at a cost in quality.  Defaults to 0.5 if not overridden.
        """
        ...
    @lumen_surface_cache_resolution.setter
    def lumen_surface_cache_resolution(self, value: float) -> None:
        ...
    @property
    def reflection_method(self) -> ReflectionMethod:
        r"""
        (ReflectionMethod):  [Read-Write] Chooses the Reflection method. Not compatible with Forward Shading.
        """
        ...
    @reflection_method.setter
    def reflection_method(self, value: ReflectionMethod) -> None:
        ...
    @property
    def lumen_reflection_quality(self) -> float:
        r"""
        (float):  [Read-Write] Scales the Reflection quality.  Larger scales reduce noise in reflections, but increase GPU cost.
        """
        ...
    @lumen_reflection_quality.setter
    def lumen_reflection_quality(self, value: float) -> None:
        ...
    @property
    def lumen_ray_lighting_mode(self) -> LumenRayLightingModeOverride:
        r"""
        (LumenRayLightingModeOverride):  [Read-Write] Controls how Lumen rays are lit when Lumen is using Hardware Ray Tracing.  By default, Lumen uses the Surface Cache for best performance, but can be set to 'Hit Lighting' for higher quality.
        """
        ...
    @lumen_ray_lighting_mode.setter
    def lumen_ray_lighting_mode(self, value: LumenRayLightingModeOverride) -> None:
        ...
    @property
    def lumen_reflections_screen_traces(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to use screen space traces for Lumen Reflections. Screen space traces bypass Lumen Scene and instead sample Scene Depth and Color. This improves quality, but at the same time prevents from Lumen Scene only changes like adding emissive objects, which are visible only in Reflections.
        """
        ...
    @lumen_reflections_screen_traces.setter
    def lumen_reflections_screen_traces(self, value: bool) -> None:
        ...
    @property
    def lumen_front_layer_translucency_reflections(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to use high quality mirror reflections on the front layer of translucent surfaces.  Other layers will use the lower quality Radiance Cache method that can only produce glossy reflections.  Increases GPU cost when enabled.
        """
        ...
    @lumen_front_layer_translucency_reflections.setter
    def lumen_front_layer_translucency_reflections(self, value: bool) -> None:
        ...
    @property
    def lumen_max_roughness_to_trace_reflections(self) -> float:
        r"""
        (float):  [Read-Write] Sets the maximum roughness value for which Lumen still traces dedicated reflection rays. Higher values improve reflection quality, but greatly increase GPU cost.
        """
        ...
    @lumen_max_roughness_to_trace_reflections.setter
    def lumen_max_roughness_to_trace_reflections(self, value: float) -> None:
        ...
    @property
    def lumen_max_reflection_bounces(self) -> int:
        r"""
        (int32):  [Read-Write] Sets the maximum number of recursive reflection bounces. 1 means a single reflection ray (no secondary reflections in mirrors). Currently only supported by Hardware Ray Tracing with Hit Lighting.
        """
        ...
    @lumen_max_reflection_bounces.setter
    def lumen_max_reflection_bounces(self, value: int) -> None:
        ...
    @property
    def lumen_max_refraction_bounces(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum count of refraction event to trace. When hit lighting is used, Translucent meshes will be traced when LumenMaxRefractionBounces > 0, making the reflection tracing more expenssive.
        """
        ...
    @lumen_max_refraction_bounces.setter
    def lumen_max_refraction_bounces(self, value: int) -> None:
        ...
    @property
    def screen_space_reflection_intensity(self) -> float:
        r"""
        (float):  [Read-Write] Enable/Fade/disable the Screen Space Reflection feature, in percent, avoid numbers between 0 and 1 fo consistency
        """
        ...
    @screen_space_reflection_intensity.setter
    def screen_space_reflection_intensity(self, value: float) -> None:
        ...
    @property
    def screen_space_reflection_quality(self) -> float:
        r"""
        (float):  [Read-Write] 0=lowest quality..100=maximum quality, only a few quality levels are implemented, no soft transition, 50 is the default for better performance.
        """
        ...
    @screen_space_reflection_quality.setter
    def screen_space_reflection_quality(self, value: float) -> None:
        ...
    @property
    def screen_space_reflection_max_roughness(self) -> float:
        r"""
        (float):  [Read-Write] Until what roughness we fade the screen space reflections, 0.8 works well, smaller can run faster
        """
        ...
    @screen_space_reflection_max_roughness.setter
    def screen_space_reflection_max_roughness(self, value: float) -> None:
        ...
    @property
    def ambient_cubemap_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] AmbientCubemap tint color
        """
        ...
    @ambient_cubemap_tint.setter
    def ambient_cubemap_tint(self, value: LinearColor) -> None:
        ...
    @property
    def ambient_cubemap_intensity(self) -> float:
        r"""
        (float):  [Read-Write] To scale the Ambient cubemap brightness
        >=0: off, 1(default), >1 brighter
        """
        ...
    @ambient_cubemap_intensity.setter
    def ambient_cubemap_intensity(self, value: float) -> None:
        ...
    @property
    def ambient_cubemap(self) -> TextureCube:
        r"""
        (TextureCube):  [Read-Write] The Ambient cubemap (Affects diffuse and specular shading), blends additively which if different from all other settings here
        """
        ...
    @ambient_cubemap.setter
    def ambient_cubemap(self, value: TextureCube) -> None:
        ...
    @property
    def camera_shutter_speed(self) -> float:
        r"""
        (float):  [Read-Write] The camera shutter in seconds.
        """
        ...
    @camera_shutter_speed.setter
    def camera_shutter_speed(self, value: float) -> None:
        ...
    @property
    def camera_iso(self) -> float:
        r"""
        (float):  [Read-Write] The camera sensor sensitivity
        """
        ...
    @camera_iso.setter
    def camera_iso(self, value: float) -> None:
        ...
    @property
    def depth_of_field_fstop(self) -> float:
        r"""
        (float):  [Read-Write] Defines the opening of the camera lens, Aperture is 1/fstop, typical lens go down to f/1.2 (large opening), larger numbers reduce the DOF effect
        """
        ...
    @depth_of_field_fstop.setter
    def depth_of_field_fstop(self, value: float) -> None:
        ...
    @property
    def depth_of_field_min_fstop(self) -> float:
        r"""
        (float):  [Read-Write] Defines the maximum opening of the camera lens to control the curvature of blades of the diaphragm. Set it to 0 to get straight blades.
        """
        ...
    @depth_of_field_min_fstop.setter
    def depth_of_field_min_fstop(self, value: float) -> None:
        ...
    @property
    def depth_of_field_blade_count(self) -> int:
        r"""
        (int32):  [Read-Write] Defines the number of blades of the diaphragm within the lens (between 4 and 16).
        """
        ...
    @depth_of_field_blade_count.setter
    def depth_of_field_blade_count(self, value: int) -> None:
        ...
    @property
    def auto_exposure_bias(self) -> float:
        r"""
        (float):  [Read-Write] Logarithmic adjustment for the exposure. Only used if a tonemapper is specified.
        0: no adjustment, -1:2x darker, -2:4x darker, 1:2x brighter, 2:4x brighter, ...
        """
        ...
    @auto_exposure_bias.setter
    def auto_exposure_bias(self, value: float) -> None:
        ...
    @property
    def exposure_offset(self) -> float:
        r"""
        deprecated: 'exposure_offset' was renamed to 'auto_exposure_bias'.
        """
        ...
    @exposure_offset.setter
    def exposure_offset(self, value: float) -> None:
        ...
    @property
    def auto_exposure_apply_physical_camera_exposure(self) -> bool:
        r"""
        (bool):  [Read-Write] Only affects Manual exposure mode.
        """
        ...
    @auto_exposure_apply_physical_camera_exposure.setter
    def auto_exposure_apply_physical_camera_exposure(self, value: bool) -> None:
        ...
    @property
    def auto_exposure_bias_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] Exposure compensation based on the scene EV100.
        Used to calibrate the final exposure differently depending on the average scene luminance.
        0: no adjustment, -1:2x darker, -2:4x darker, 1:2x brighter, 2:4x brighter, ...
        """
        ...
    @auto_exposure_bias_curve.setter
    def auto_exposure_bias_curve(self, value: CurveFloat) -> None:
        ...
    @property
    def auto_exposure_meter_mask(self) -> Texture:
        r"""
        (Texture):  [Read-Write] Exposure metering mask. Bright spots on the mask will have high influence on auto-exposure metering
        and dark spots will have low influence.
        """
        ...
    @auto_exposure_meter_mask.setter
    def auto_exposure_meter_mask(self, value: Texture) -> None:
        ...
    @property
    def auto_exposure_low_percent(self) -> float:
        r"""
        (float):  [Read-Write] The eye adaptation will adapt to a value extracted from the luminance histogram of the scene color.
        The value is defined as having x percent below this brightness. Higher values give bright spots on the screen more priority
        but can lead to less stable results. Lower values give the medium and darker values more priority but might cause burn out of
        bright spots.
        >0, <100, good values are in the range 70 .. 80
        """
        ...
    @auto_exposure_low_percent.setter
    def auto_exposure_low_percent(self, value: float) -> None:
        ...
    @property
    def eye_adaptation_low_percent(self) -> float:
        r"""
        deprecated: 'eye_adaptation_low_percent' was renamed to 'auto_exposure_low_percent'.
        """
        ...
    @eye_adaptation_low_percent.setter
    def eye_adaptation_low_percent(self, value: float) -> None:
        ...
    @property
    def auto_exposure_high_percent(self) -> float:
        r"""
        (float):  [Read-Write] The eye adaptation will adapt to a value extracted from the luminance histogram of the scene color.
        The value is defined as having x percent below this brightness. Higher values give bright spots on the screen more priority
        but can lead to less stable results. Lower values give the medium and darker values more priority but might cause burn out of
        bright spots.
        >0, <100, good values are in the range 80 .. 95
        """
        ...
    @auto_exposure_high_percent.setter
    def auto_exposure_high_percent(self, value: float) -> None:
        ...
    @property
    def eye_adaptation_high_percent(self) -> float:
        r"""
        deprecated: 'eye_adaptation_high_percent' was renamed to 'auto_exposure_high_percent'.
        """
        ...
    @eye_adaptation_high_percent.setter
    def eye_adaptation_high_percent(self, value: float) -> None:
        ...
    @property
    def auto_exposure_min_brightness(self) -> float:
        r"""
        (float):  [Read-Write] Auto-Exposure minimum adaptation. Eye Adaptation is disabled if Min = Max.
        Auto-exposure is implemented by choosing an exposure value for which the average luminance generates a pixel brightness equal to the Constant Calibration value.
        The Min/Max are expressed in pixel luminance (cd/m2) or in EV100 when using ExtendDefaultLuminanceRange (see project settings).
        """
        ...
    @auto_exposure_min_brightness.setter
    def auto_exposure_min_brightness(self, value: float) -> None:
        ...
    @property
    def eye_adaptation_min_brightness(self) -> float:
        r"""
        deprecated: 'eye_adaptation_min_brightness' was renamed to 'auto_exposure_min_brightness'.
        """
        ...
    @eye_adaptation_min_brightness.setter
    def eye_adaptation_min_brightness(self, value: float) -> None:
        ...
    @property
    def auto_exposure_max_brightness(self) -> float:
        r"""
        (float):  [Read-Write] Auto-Exposure maximum adaptation. Eye Adaptation is disabled if Min = Max.
        Auto-exposure is implemented by choosing an exposure value for which the average luminance generates a pixel brightness equal to the Constant Calibration value.
        The Min/Max are expressed in pixel luminance (cd/m2) or in EV100 when using ExtendDefaultLuminanceRange (see project settings).
        """
        ...
    @auto_exposure_max_brightness.setter
    def auto_exposure_max_brightness(self, value: float) -> None:
        ...
    @property
    def eye_adaptation_max_brightness(self) -> float:
        r"""
        deprecated: 'eye_adaptation_max_brightness' was renamed to 'auto_exposure_max_brightness'.
        """
        ...
    @eye_adaptation_max_brightness.setter
    def eye_adaptation_max_brightness(self, value: float) -> None:
        ...
    @property
    def auto_exposure_speed_up(self) -> float:
        r"""
        (float):  [Read-Write] In F-stops per second, should be >0
        """
        ...
    @auto_exposure_speed_up.setter
    def auto_exposure_speed_up(self, value: float) -> None:
        ...
    @property
    def eye_adaption_speed_up(self) -> float:
        r"""
        deprecated: 'eye_adaption_speed_up' was renamed to 'auto_exposure_speed_up'.
        """
        ...
    @eye_adaption_speed_up.setter
    def eye_adaption_speed_up(self, value: float) -> None:
        ...
    @property
    def auto_exposure_speed_down(self) -> float:
        r"""
        (float):  [Read-Write] In F-stops per second, should be >0
        """
        ...
    @auto_exposure_speed_down.setter
    def auto_exposure_speed_down(self, value: float) -> None:
        ...
    @property
    def eye_adaption_speed_down(self) -> float:
        r"""
        deprecated: 'eye_adaption_speed_down' was renamed to 'auto_exposure_speed_down'.
        """
        ...
    @eye_adaption_speed_down.setter
    def eye_adaption_speed_down(self, value: float) -> None:
        ...
    @property
    def histogram_log_min(self) -> float:
        r"""
        (float):  [Read-Write] Histogram Min value. Expressed in Log2(Luminance) or in EV100 when using ExtendDefaultLuminanceRange (see project settings)
        """
        ...
    @histogram_log_min.setter
    def histogram_log_min(self, value: float) -> None:
        ...
    @property
    def histogram_log_max(self) -> float:
        r"""
        (float):  [Read-Write] Histogram Max value. Expressed in Log2(Luminance) or in EV100 when using ExtendDefaultLuminanceRange (see project settings)
        """
        ...
    @histogram_log_max.setter
    def histogram_log_max(self, value: float) -> None:
        ...
    @property
    def local_exposure_highlight_contrast_scale(self) -> float:
        r"""
        (float):  [Read-Write] Local Exposure decomposes luminance of the frame into a base layer and a detail layer.
        Contrast of the base layer is reduced based on this value.
        Value less than 1 will enable local exposure.
        Good values are usually in the range 0.6 .. 1.0.
        """
        ...
    @local_exposure_highlight_contrast_scale.setter
    def local_exposure_highlight_contrast_scale(self, value: float) -> None:
        ...
    @property
    def local_exposure_shadow_contrast_scale(self) -> float:
        r"""
        (float):  [Read-Write] Local Exposure decomposes luminance of the frame into a base layer and a detail layer.
        Contrast of the base layer is reduced based on this value.
        Value less than 1 will enable local exposure.
        Good values are usually in the range 0.6 .. 1.0.
        """
        ...
    @local_exposure_shadow_contrast_scale.setter
    def local_exposure_shadow_contrast_scale(self, value: float) -> None:
        ...
    @property
    def local_exposure_highlight_contrast_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] Local Exposure Highlight Contrast based on the scene EV100.
        Used to calibrate Local Exposure differently depending on the average scene luminance.
        """
        ...
    @local_exposure_highlight_contrast_curve.setter
    def local_exposure_highlight_contrast_curve(self, value: CurveFloat) -> None:
        ...
    @property
    def local_exposure_shadow_contrast_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] Local Exposure Shadow Contrast based on the scene EV100.
        Used to calibrate Local Exposure differently depending on the average scene luminance.
        """
        ...
    @local_exposure_shadow_contrast_curve.setter
    def local_exposure_shadow_contrast_curve(self, value: CurveFloat) -> None:
        ...
    @property
    def local_exposure_highlight_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Threshold used to determine which regions of the screen are considered highlights.
        """
        ...
    @local_exposure_highlight_threshold.setter
    def local_exposure_highlight_threshold(self, value: float) -> None:
        ...
    @property
    def local_exposure_shadow_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Threshold used to determine which regions of the screen are considered shadows.
        """
        ...
    @local_exposure_shadow_threshold.setter
    def local_exposure_shadow_threshold(self, value: float) -> None:
        ...
    @property
    def local_exposure_detail_strength(self) -> float:
        r"""
        (float):  [Read-Write] Local Exposure decomposes luminance of the frame into a base layer and a detail layer.
        Value different than 1 will enable local exposure.
        This value should be set to 1 in most cases.
        """
        ...
    @local_exposure_detail_strength.setter
    def local_exposure_detail_strength(self, value: float) -> None:
        ...
    @property
    def local_exposure_blurred_luminance_blend(self) -> float:
        r"""
        (float):  [Read-Write] Local Exposure decomposes luminance of the frame into a base layer and a detail layer.
        Blend between bilateral filtered and blurred luminance as the base layer.
        Blurred luminance helps preserve image appearance and specular highlights, and reduce ringing.
        Good values are usually in the range 0.4 .. 0.6
        """
        ...
    @local_exposure_blurred_luminance_blend.setter
    def local_exposure_blurred_luminance_blend(self, value: float) -> None:
        ...
    @property
    def local_exposure_blurred_luminance_kernel_size_percent(self) -> float:
        r"""
        (float):  [Read-Write] Kernel size (percentage of screen) used to blur frame luminance.
        """
        ...
    @local_exposure_blurred_luminance_kernel_size_percent.setter
    def local_exposure_blurred_luminance_kernel_size_percent(self, value: float) -> None:
        ...
    @property
    def local_exposure_middle_grey_bias(self) -> float:
        r"""
        (float):  [Read-Write] Logarithmic adjustment for the local exposure middle grey.
        0: no adjustment, -1:2x darker, -2:4x darker, 1:2x brighter, 2:4x brighter, ...
        """
        ...
    @local_exposure_middle_grey_bias.setter
    def local_exposure_middle_grey_bias(self, value: float) -> None:
        ...
    @property
    def lens_flare_intensity(self) -> float:
        r"""
        (float):  [Read-Write] Brightness scale of the image cased lens flares (linear)
        """
        ...
    @lens_flare_intensity.setter
    def lens_flare_intensity(self, value: float) -> None:
        ...
    @property
    def lens_flare_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Tint color for the image based lens flares.
        """
        ...
    @lens_flare_tint.setter
    def lens_flare_tint(self, value: LinearColor) -> None:
        ...
    @property
    def lens_flare_bokeh_size(self) -> float:
        r"""
        (float):  [Read-Write] Size of the Lens Blur (in percent of the view width) that is done with the Bokeh texture (note: performance cost is radius*radius)
        """
        ...
    @lens_flare_bokeh_size.setter
    def lens_flare_bokeh_size(self, value: float) -> None:
        ...
    @property
    def lens_flare_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Minimum brightness the lens flare starts having effect (this should be as high as possible to avoid the performance cost of blurring content that is too dark too see)
        """
        ...
    @lens_flare_threshold.setter
    def lens_flare_threshold(self, value: float) -> None:
        ...
    @property
    def lens_flare_bokeh_shape(self) -> Texture:
        r"""
        (Texture):  [Read-Write] Defines the shape of the Bokeh when the image base lens flares are blurred, cannot be blended
        """
        ...
    @lens_flare_bokeh_shape.setter
    def lens_flare_bokeh_shape(self, value: Texture) -> None:
        ...
    @property
    def vignette_intensity(self) -> float:
        r"""
        (float):  [Read-Write] 0..1 0=off/no vignette .. 1=strong vignette
        """
        ...
    @vignette_intensity.setter
    def vignette_intensity(self, value: float) -> None:
        ...
    @property
    def sharpen(self) -> float:
        r"""
        (float):  [Read-Write] Controls the strength of image sharpening applied during tonemapping.
        """
        ...
    @sharpen.setter
    def sharpen(self, value: float) -> None:
        ...
    @property
    def film_grain_intensity(self) -> float:
        r"""
        (float):  [Read-Write] 0..1 Film grain intensity to apply. LinearSceneColor *= lerp(1.0, DecodedFilmGrainTexture, FilmGrainIntensity)
        """
        ...
    @film_grain_intensity.setter
    def film_grain_intensity(self, value: float) -> None:
        ...
    @property
    def film_grain_intensity_shadows(self) -> float:
        r"""
        (float):  [Read-Write] Control over the grain intensity in the regions of the image considered shadow areas.
        """
        ...
    @film_grain_intensity_shadows.setter
    def film_grain_intensity_shadows(self, value: float) -> None:
        ...
    @property
    def film_grain_intensity_midtones(self) -> float:
        r"""
        (float):  [Read-Write] Control over the grain intensity in the mid-tone region of the image.
        """
        ...
    @film_grain_intensity_midtones.setter
    def film_grain_intensity_midtones(self, value: float) -> None:
        ...
    @property
    def film_grain_intensity_highlights(self) -> float:
        r"""
        (float):  [Read-Write] Control over the grain intensity in the regions of the image considered highlight areas.
        """
        ...
    @film_grain_intensity_highlights.setter
    def film_grain_intensity_highlights(self, value: float) -> None:
        ...
    @property
    def film_grain_shadows_max(self) -> float:
        r"""
        (float):  [Read-Write] Sets the upper bound used for Film Grain Shadow Intensity.
        """
        ...
    @film_grain_shadows_max.setter
    def film_grain_shadows_max(self, value: float) -> None:
        ...
    @property
    def film_grain_highlights_min(self) -> float:
        r"""
        (float):  [Read-Write] Sets the lower bound used for Film Grain Highlight Intensity.
        """
        ...
    @film_grain_highlights_min.setter
    def film_grain_highlights_min(self, value: float) -> None:
        ...
    @property
    def film_grain_highlights_max(self) -> float:
        r"""
        (float):  [Read-Write] Sets the upper bound used for Film Grain Highlight Intensity. This value should be larger than HighlightsMin.. Default is 1.0, for backwards compatibility
        """
        ...
    @film_grain_highlights_max.setter
    def film_grain_highlights_max(self, value: float) -> None:
        ...
    @property
    def film_grain_texel_size(self) -> float:
        r"""
        (float):  [Read-Write] Controls the size of the film grain. Size of texel of FilmGrainTexture on screen.
        """
        ...
    @film_grain_texel_size.setter
    def film_grain_texel_size(self, value: float) -> None:
        ...
    @property
    def film_grain_texture(self) -> Texture2D:
        r"""
        (Texture2D):  [Read-Write] Defines film grain texture to use.
        """
        ...
    @film_grain_texture.setter
    def film_grain_texture(self, value: Texture2D) -> None:
        ...
    @property
    def ambient_occlusion_intensity(self) -> float:
        r"""
        (float):  [Read-Write] 0..1 0=off/no ambient occlusion .. 1=strong ambient occlusion, defines how much it affects the non direct lighting after base pass
        """
        ...
    @ambient_occlusion_intensity.setter
    def ambient_occlusion_intensity(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_static_fraction(self) -> float:
        r"""
        (float):  [Read-Write] 0..1 0=no effect on static lighting .. 1=AO affects the stat lighting, 0 is free meaning no extra rendering pass
        """
        ...
    @ambient_occlusion_static_fraction.setter
    def ambient_occlusion_static_fraction(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_radius(self) -> float:
        r"""
        (float):  [Read-Write] >0, in unreal units, bigger values means even distant surfaces affect the ambient occlusion
        """
        ...
    @ambient_occlusion_radius.setter
    def ambient_occlusion_radius(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_radius_in_ws(self) -> bool:
        r"""
        (bool):  [Read-Write] true: AO radius is in world space units, false: AO radius is locked the view space in 400 units
        """
        ...
    @ambient_occlusion_radius_in_ws.setter
    def ambient_occlusion_radius_in_ws(self, value: bool) -> None:
        ...
    @property
    def ambient_occlusion_fade_distance(self) -> float:
        r"""
        (float):  [Read-Write] >0, in unreal units, at what distance the AO effect disppears in the distance (avoding artifacts and AO effects on huge object)
        """
        ...
    @ambient_occlusion_fade_distance.setter
    def ambient_occlusion_fade_distance(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_fade_radius(self) -> float:
        r"""
        (float):  [Read-Write] >0, in unreal units, how many units before AmbientOcclusionFadeOutDistance it starts fading out
        """
        ...
    @ambient_occlusion_fade_radius.setter
    def ambient_occlusion_fade_radius(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_power(self) -> float:
        r"""
        (float):  [Read-Write] >0, in unreal units, bigger values means even distant surfaces affect the ambient occlusion
        """
        ...
    @ambient_occlusion_power.setter
    def ambient_occlusion_power(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_bias(self) -> float:
        r"""
        (float):  [Read-Write] >0, in unreal units, default (3.0) works well for flat surfaces but can reduce details
        """
        ...
    @ambient_occlusion_bias.setter
    def ambient_occlusion_bias(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_quality(self) -> float:
        r"""
        (float):  [Read-Write] 0=lowest quality..100=maximum quality, only a few quality levels are implemented, no soft transition
        """
        ...
    @ambient_occlusion_quality.setter
    def ambient_occlusion_quality(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_mip_blend(self) -> float:
        r"""
        (float):  [Read-Write] Affects the blend over the multiple mips (lower resolution versions) , 0:fully use full resolution, 1::fully use low resolution, around 0.6 seems to be a good value
        """
        ...
    @ambient_occlusion_mip_blend.setter
    def ambient_occlusion_mip_blend(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_mip_scale(self) -> float:
        r"""
        (float):  [Read-Write] Affects the radius AO radius scale over the multiple mips (lower resolution versions)
        """
        ...
    @ambient_occlusion_mip_scale.setter
    def ambient_occlusion_mip_scale(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_mip_threshold(self) -> float:
        r"""
        (float):  [Read-Write] to tweak the bilateral upsampling when using multiple mips (lower resolution versions)
        """
        ...
    @ambient_occlusion_mip_threshold.setter
    def ambient_occlusion_mip_threshold(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_temporal_blend_weight(self) -> float:
        r"""
        (float):  [Read-Write] How much to blend the current frame with previous frames when using GTAO with temporal accumulation
        """
        ...
    @ambient_occlusion_temporal_blend_weight.setter
    def ambient_occlusion_temporal_blend_weight(self, value: float) -> None:
        ...
    @property
    def ray_tracing_ao(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables ray tracing ambient occlusion.
        """
        ...
    @ray_tracing_ao.setter
    def ray_tracing_ao(self, value: bool) -> None:
        ...
    @property
    def ray_tracing_ao_samples_per_pixel(self) -> int:
        r"""
        (int32):  [Read-Write] Sets the samples per pixel for ray tracing ambient occlusion.
        """
        ...
    @ray_tracing_ao_samples_per_pixel.setter
    def ray_tracing_ao_samples_per_pixel(self, value: int) -> None:
        ...
    @property
    def ray_tracing_ao_intensity(self) -> float:
        r"""
        (float):  [Read-Write] Scalar factor on the ray-tracing ambient occlusion score.
        """
        ...
    @ray_tracing_ao_intensity.setter
    def ray_tracing_ao_intensity(self, value: float) -> None:
        ...
    @property
    def ray_tracing_ao_radius(self) -> float:
        r"""
        (float):  [Read-Write] Defines the world-space search radius for occlusion rays.
        """
        ...
    @ray_tracing_ao_radius.setter
    def ray_tracing_ao_radius(self, value: float) -> None:
        ...
    @property
    def color_grading_intensity(self) -> float:
        r"""
        (float):  [Read-Write] Color grading lookup table intensity. 0 = no intensity, 1=full intensity
        """
        ...
    @color_grading_intensity.setter
    def color_grading_intensity(self, value: float) -> None:
        ...
    @property
    def color_grading_lut(self) -> Texture:
        r"""
        (Texture):  [Read-Write] Look up table texture to use or none of not used
        """
        ...
    @color_grading_lut.setter
    def color_grading_lut(self, value: Texture) -> None:
        ...
    @property
    def depth_of_field_sensor_width(self) -> float:
        r"""
        (float):  [Read-Write] Width of the camera sensor to assume, in mm.
        """
        ...
    @depth_of_field_sensor_width.setter
    def depth_of_field_sensor_width(self, value: float) -> None:
        ...
    @property
    def depth_of_field_squeeze_factor(self) -> float:
        r"""
        (float):  [Read-Write] This is the squeeze factor for the DOF, which emulates the properties of anamorphic lenses.
        """
        ...
    @depth_of_field_squeeze_factor.setter
    def depth_of_field_squeeze_factor(self, value: float) -> None:
        ...
    @property
    def depth_of_field_focal_distance(self) -> float:
        r"""
        (float):  [Read-Write] Distance in which the Depth of Field effect should be sharp, in unreal units (cm)
        """
        ...
    @depth_of_field_focal_distance.setter
    def depth_of_field_focal_distance(self, value: float) -> None:
        ...
    @property
    def depth_of_field_depth_blur_amount(self) -> float:
        r"""
        (float):  [Read-Write] CircleDOF only: Depth blur km for 50%
        """
        ...
    @depth_of_field_depth_blur_amount.setter
    def depth_of_field_depth_blur_amount(self, value: float) -> None:
        ...
    @property
    def depth_of_field_depth_blur_radius(self) -> float:
        r"""
        (float):  [Read-Write] CircleDOF only: Depth blur radius in pixels at 1920x
        """
        ...
    @depth_of_field_depth_blur_radius.setter
    def depth_of_field_depth_blur_radius(self, value: float) -> None:
        ...
    @property
    def depth_of_field_use_hair_depth(self) -> bool:
        r"""
        (bool):  [Read-Write] For depth of field to use the hair depth for computing circle of confusion size. Otherwise use an interpolated distance between the hair depth and the scene depth based on the hair coverage (default).
        """
        ...
    @depth_of_field_use_hair_depth.setter
    def depth_of_field_use_hair_depth(self, value: bool) -> None:
        ...
    @property
    def depth_of_field_focal_region(self) -> float:
        r"""
        (float):  [Read-Write] Artificial region where all content is in focus, starting after DepthOfFieldFocalDistance, in unreal units  (cm)
        """
        ...
    @depth_of_field_focal_region.setter
    def depth_of_field_focal_region(self, value: float) -> None:
        ...
    @property
    def depth_of_field_near_transition_region(self) -> float:
        r"""
        (float):  [Read-Write] To define the width of the transition region next to the focal region on the near side (cm)
        """
        ...
    @depth_of_field_near_transition_region.setter
    def depth_of_field_near_transition_region(self, value: float) -> None:
        ...
    @property
    def depth_of_field_far_transition_region(self) -> float:
        r"""
        (float):  [Read-Write] To define the width of the transition region next to the focal region on the near side (cm)
        """
        ...
    @depth_of_field_far_transition_region.setter
    def depth_of_field_far_transition_region(self, value: float) -> None:
        ...
    @property
    def depth_of_field_scale(self) -> float:
        r"""
        (float):  [Read-Write] SM5: BokehDOF only: To amplify the depth of field effect (like aperture)  0=off
                  ES3_1: Used to blend DoF. 0=off
        """
        ...
    @depth_of_field_scale.setter
    def depth_of_field_scale(self, value: float) -> None:
        ...
    @property
    def depth_of_field_near_blur_size(self) -> float:
        r"""
        (float):  [Read-Write] Gaussian only: Maximum size of the Depth of Field blur (in percent of the view width) (note: performance cost scales with size)
        """
        ...
    @depth_of_field_near_blur_size.setter
    def depth_of_field_near_blur_size(self, value: float) -> None:
        ...
    @property
    def depth_of_field_far_blur_size(self) -> float:
        r"""
        (float):  [Read-Write] Gaussian only: Maximum size of the Depth of Field blur (in percent of the view width) (note: performance cost scales with size)
        """
        ...
    @depth_of_field_far_blur_size.setter
    def depth_of_field_far_blur_size(self, value: float) -> None:
        ...
    @property
    def depth_of_field_occlusion(self) -> float:
        r"""
        (float):  [Read-Write] Occlusion tweak factor 1 (0.18 to get natural occlusion, 0.4 to solve layer color leaking issues)
        """
        ...
    @depth_of_field_occlusion.setter
    def depth_of_field_occlusion(self, value: float) -> None:
        ...
    @property
    def depth_of_field_sky_focus_distance(self) -> float:
        r"""
        (float):  [Read-Write] Artificial distance to allow the skybox to be in focus (e.g. 200000), <=0 to switch the feature off, only for GaussianDOF, can cost performance
        """
        ...
    @depth_of_field_sky_focus_distance.setter
    def depth_of_field_sky_focus_distance(self, value: float) -> None:
        ...
    @property
    def depth_of_field_vignette_size(self) -> float:
        r"""
        (float):  [Read-Write] Artificial circular mask to (near) blur content outside the radius, only for GaussianDOF, diameter in percent of screen width, costs performance if the mask is used, keep Feather can Radius on default to keep it off
        """
        ...
    @depth_of_field_vignette_size.setter
    def depth_of_field_vignette_size(self, value: float) -> None:
        ...
    @property
    def motion_blur_amount(self) -> float:
        r"""
        (float):  [Read-Write] Strength of motion blur, 0:off
        """
        ...
    @motion_blur_amount.setter
    def motion_blur_amount(self, value: float) -> None:
        ...
    @property
    def motion_blur_max(self) -> float:
        r"""
        (float):  [Read-Write] max distortion caused by motion blur, in percent of the screen width, 0:off
        """
        ...
    @motion_blur_max.setter
    def motion_blur_max(self, value: float) -> None:
        ...
    @property
    def motion_blur_target_fps(self) -> int:
        r"""
        (int32):  [Read-Write] Defines the target FPS for motion blur. Makes motion blur independent of actual frame rate and relative
        to the specified target FPS instead. Higher target FPS results in shorter frames, which means shorter
        shutter times and less motion blur. Lower FPS means more motion blur. A value of zero makes the motion
        blur dependent on the actual frame rate.
        """
        ...
    @motion_blur_target_fps.setter
    def motion_blur_target_fps(self, value: int) -> None:
        ...
    @property
    def motion_blur_per_object_size(self) -> float:
        r"""
        (float):  [Read-Write] The minimum projected screen radius for a primitive to be drawn in the velocity pass, percentage of screen width. smaller numbers cause more draw calls, default: 4%
        """
        ...
    @motion_blur_per_object_size.setter
    def motion_blur_per_object_size(self, value: float) -> None:
        ...
    @property
    def translucency_type(self) -> TranslucencyType:
        r"""
        (TranslucencyType):  [Read-Write] Sets the translucency type
        """
        ...
    @translucency_type.setter
    def translucency_type(self, value: TranslucencyType) -> None:
        ...
    @property
    def ray_tracing_translucency_max_roughness(self) -> float:
        r"""
        (float):  [Read-Write] Sets the maximum roughness until which ray tracing translucency will be visible (lower value is faster). Translucency contribution is smoothly faded when close to roughness threshold. This parameter behaves similarly to ScreenSpaceReflectionMaxRoughness.
        """
        ...
    @ray_tracing_translucency_max_roughness.setter
    def ray_tracing_translucency_max_roughness(self, value: float) -> None:
        ...
    @property
    def ray_tracing_translucency_refraction_rays(self) -> int:
        r"""
        (int32):  [Read-Write] Sets the maximum number of ray tracing refraction rays.
        """
        ...
    @ray_tracing_translucency_refraction_rays.setter
    def ray_tracing_translucency_refraction_rays(self, value: int) -> None:
        ...
    @property
    def ray_tracing_translucency_samples_per_pixel(self) -> int:
        r"""
        (int32):  [Read-Write] Sets the samples per pixel for ray traced translucency.
        """
        ...
    @ray_tracing_translucency_samples_per_pixel.setter
    def ray_tracing_translucency_samples_per_pixel(self, value: int) -> None:
        ...
    @property
    def ray_tracing_translucency_shadows(self) -> ReflectedAndRefractedRayTracedShadows:
        r"""
        (ReflectedAndRefractedRayTracedShadows):  [Read-Write] Sets the translucency shadows type.
        """
        ...
    @ray_tracing_translucency_shadows.setter
    def ray_tracing_translucency_shadows(self, value: ReflectedAndRefractedRayTracedShadows) -> None:
        ...
    @property
    def ray_tracing_translucency_refraction(self) -> bool:
        r"""
        (bool):  [Read-Write] Sets whether refraction should be enabled or not (if not rays will not scatter and only travel in the same direction as before the intersection event).
        """
        ...
    @ray_tracing_translucency_refraction.setter
    def ray_tracing_translucency_refraction(self, value: bool) -> None:
        ...
    @property
    def path_tracing_max_bounces(self) -> int:
        r"""
        (int32):  [Read-Write] Sets the path tracing maximum bounces
        """
        ...
    @path_tracing_max_bounces.setter
    def path_tracing_max_bounces(self, value: int) -> None:
        ...
    @property
    def path_tracing_samples_per_pixel(self) -> int:
        r"""
        (int32):  [Read-Write] Sets the samples per pixel for the path tracer.
        """
        ...
    @path_tracing_samples_per_pixel.setter
    def path_tracing_samples_per_pixel(self, value: int) -> None:
        ...
    @property
    def path_tracing_max_path_exposure(self) -> float:
        r"""
        (float):  [Read-Write] Sets the maximum exposure allowed in the path tracer to reduce fireflies. This should be set a few stops higher than the scene exposure.
        """
        ...
    @path_tracing_max_path_exposure.setter
    def path_tracing_max_path_exposure(self, value: float) -> None:
        ...
    @property
    def path_tracing_enable_emissive_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] Should emissive materials contribute to scene lighting?
        """
        ...
    @path_tracing_enable_emissive_materials.setter
    def path_tracing_enable_emissive_materials(self, value: bool) -> None:
        ...
    @property
    def path_tracing_enable_reference_dof(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables a reference quality depth-of-field which replaces the post-process effect.
        """
        ...
    @path_tracing_enable_reference_dof.setter
    def path_tracing_enable_reference_dof(self, value: bool) -> None:
        ...
    @property
    def path_tracing_enable_reference_atmosphere(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables path tracing in the atmosphere instead of baking the sky atmosphere contribution into a skylight. Any skylight present in the scene will be automatically ignored when this is enabled.
        """
        ...
    @path_tracing_enable_reference_atmosphere.setter
    def path_tracing_enable_reference_atmosphere(self, value: bool) -> None:
        ...
    @property
    def path_tracing_enable_denoiser(self) -> bool:
        r"""
        (bool):  [Read-Write] Run the currently loaded denoiser plugin on the last sample to remove noise from the output. Has no effect if a plug-in is not loaded.
        """
        ...
    @path_tracing_enable_denoiser.setter
    def path_tracing_enable_denoiser(self, value: bool) -> None:
        ...
    @property
    def path_tracing_include_emissive(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the render include directly visible emissive elements?
        """
        ...
    @path_tracing_include_emissive.setter
    def path_tracing_include_emissive(self, value: bool) -> None:
        ...
    @property
    def path_tracing_include_diffuse(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the render include diffuse lighting contributions?
        """
        ...
    @path_tracing_include_diffuse.setter
    def path_tracing_include_diffuse(self, value: bool) -> None:
        ...
    @property
    def path_tracing_include_indirect_diffuse(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the render include indirect diffuse lighting contributions?
        """
        ...
    @path_tracing_include_indirect_diffuse.setter
    def path_tracing_include_indirect_diffuse(self, value: bool) -> None:
        ...
    @property
    def path_tracing_include_specular(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the render include specular lighting contributions?
        """
        ...
    @path_tracing_include_specular.setter
    def path_tracing_include_specular(self, value: bool) -> None:
        ...
    @property
    def path_tracing_include_indirect_specular(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the render include indirect specular lighting contributions?
        """
        ...
    @path_tracing_include_indirect_specular.setter
    def path_tracing_include_indirect_specular(self, value: bool) -> None:
        ...
    @property
    def path_tracing_include_volume(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the render include volume lighting contributions?
        """
        ...
    @path_tracing_include_volume.setter
    def path_tracing_include_volume(self, value: bool) -> None:
        ...
    @property
    def path_tracing_include_indirect_volume(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the render include volume lighting contributions?
        """
        ...
    @path_tracing_include_indirect_volume.setter
    def path_tracing_include_indirect_volume(self, value: bool) -> None:
        ...
    @property
    def weighted_blendables(self) -> WeightedBlendables:
        r"""
        (WeightedBlendables):  [Read-Write] Allows custom post process materials to be defined, using a MaterialInstance with the same Material as its parent to allow blending.
        For materials this needs to be the "PostProcess" domain type. This can be used for any UObject object implementing the IBlendableInterface (e.g. could be used to fade weather settings).
        """
        ...
    @weighted_blendables.setter
    def weighted_blendables(self, value: WeightedBlendables) -> None:
        ...

class WeightedBlendables(StructBase):
    r"""
    for easier detail customization, needed?
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``array`` (Array[WeightedBlendable]):  [Read-Write]
    """
    def __init__(self, array: Array[WeightedBlendable] = []) -> None:
        ...
    @property
    def array(self) -> Array[WeightedBlendable]:
        r"""
        (Array[WeightedBlendable]):  [Read-Write]
        """
        ...
    @array.setter
    def array(self, value: Array[WeightedBlendable]) -> None:
        ...

class WeightedBlendable(StructBase):
    r"""
    Weighted Blendable
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``object`` (Object):  [Read-Write] should be of the IBlendableInterface* type but UProperties cannot express that
    - ``weight`` (float):  [Read-Write] 0:no effect .. 1:full effect
    """
    def __init__(self, weight: float = 0.000000, object: Object = None) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] 0:no effect .. 1:full effect
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def object(self) -> Object:
        r"""
        (Object):  [Read-Write] should be of the IBlendableInterface* type but UProperties cannot express that
        """
        ...
    @object.setter
    def object(self, value: Object) -> None:
        ...

class PropertyEntry(StructBase):
    r"""
    Structure to represent a single property the user wants to bake out for a given set of materials
    
    **C++ Source:**
    
    - **Module**: MaterialBaking
    - **File**: MaterialOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``constant_value`` (float):  [Read-Write] Defines the value representing this property in the final proxy material
    - ``custom_size`` (IntPoint):  [Read-Write] Defines the size of the output textures for the baked out material properties
    - ``property_`` (MaterialProperty):  [Read-Write] Property which should be baked out
    - ``use_constant_value`` (bool):  [Read-Write] Wheter or not to use Constant Value as the final 'baked out' value for the this property
    - ``use_custom_size`` (bool):  [Read-Write] Whether or not to use the value of custom size for the output texture
    """
    def __init__(self, property_: MaterialProperty = MaterialProperty.MP_EMISSIVE_COLOR, use_custom_size: bool = False, custom_size: IntPoint = [0, 0], use_constant_value: bool = False, constant_value: float = 0.000000) -> None:
        ...
    @property
    def property_(self) -> MaterialProperty:
        r"""
        (MaterialProperty):  [Read-Write] Property which should be baked out
        """
        ...
    @property_.setter
    def property_(self, value: MaterialProperty) -> None:
        ...
    @property
    def use_custom_size(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to use the value of custom size for the output texture
        """
        ...
    @use_custom_size.setter
    def use_custom_size(self, value: bool) -> None:
        ...
    @property
    def custom_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Defines the size of the output textures for the baked out material properties
        """
        ...
    @custom_size.setter
    def custom_size(self, value: IntPoint) -> None:
        ...
    @property
    def use_constant_value(self) -> bool:
        r"""
        (bool):  [Read-Write] Wheter or not to use Constant Value as the final 'baked out' value for the this property
        """
        ...
    @use_constant_value.setter
    def use_constant_value(self, value: bool) -> None:
        ...
    @property
    def constant_value(self) -> float:
        r"""
        (float):  [Read-Write] Defines the value representing this property in the final proxy material
        """
        ...
    @constant_value.setter
    def constant_value(self, value: float) -> None:
        ...

class MaterialStatistics(StructBase):
    r"""
    Material Statistics
    
    **C++ Source:**
    
    - **Module**: MaterialEditor
    - **File**: MaterialEditingLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``num_interpolator_scalars`` (int32):  [Read-Write] Number of interpolator scalars required for user-defined interpolators
    - ``num_pixel_shader_instructions`` (int32):  [Read-Write] Number of instructions used by most expensive pixel shader in the material
    - ``num_pixel_texture_samples`` (int32):  [Read-Write] Number of textures sampled by the pixel shader
    - ``num_samplers`` (int32):  [Read-Write] Number of samplers required by the material
    - ``num_uv_scalars`` (int32):  [Read-Write] Number of interpolator scalars required for UVs
    - ``num_vertex_shader_instructions`` (int32):  [Read-Write] Number of instructions used by most expensive vertex shader in the material
    - ``num_vertex_texture_samples`` (int32):  [Read-Write] Number of textures sampled by the vertex shader
    - ``num_virtual_texture_samples`` (int32):  [Read-Write] Number of virtual textures sampled
    """
    def __init__(self, num_vertex_shader_instructions: int = 0, num_pixel_shader_instructions: int = 0, num_samplers: int = 0, num_vertex_texture_samples: int = 0, num_pixel_texture_samples: int = 0, num_virtual_texture_samples: int = 0, num_uv_scalars: int = 0, num_interpolator_scalars: int = 0) -> None:
        ...
    @property
    def num_vertex_shader_instructions(self) -> int:
        r"""
        (int32):  [Read-Write] Number of instructions used by most expensive vertex shader in the material
        """
        ...
    @num_vertex_shader_instructions.setter
    def num_vertex_shader_instructions(self, value: int) -> None:
        ...
    @property
    def num_pixel_shader_instructions(self) -> int:
        r"""
        (int32):  [Read-Write] Number of instructions used by most expensive pixel shader in the material
        """
        ...
    @num_pixel_shader_instructions.setter
    def num_pixel_shader_instructions(self, value: int) -> None:
        ...
    @property
    def num_samplers(self) -> int:
        r"""
        (int32):  [Read-Write] Number of samplers required by the material
        """
        ...
    @num_samplers.setter
    def num_samplers(self, value: int) -> None:
        ...
    @property
    def num_vertex_texture_samples(self) -> int:
        r"""
        (int32):  [Read-Write] Number of textures sampled by the vertex shader
        """
        ...
    @num_vertex_texture_samples.setter
    def num_vertex_texture_samples(self, value: int) -> None:
        ...
    @property
    def num_pixel_texture_samples(self) -> int:
        r"""
        (int32):  [Read-Write] Number of textures sampled by the pixel shader
        """
        ...
    @num_pixel_texture_samples.setter
    def num_pixel_texture_samples(self, value: int) -> None:
        ...
    @property
    def num_virtual_texture_samples(self) -> int:
        r"""
        (int32):  [Read-Write] Number of virtual textures sampled
        """
        ...
    @num_virtual_texture_samples.setter
    def num_virtual_texture_samples(self, value: int) -> None:
        ...
    @property
    def num_uv_scalars(self) -> int:
        r"""
        (int32):  [Read-Write] Number of interpolator scalars required for UVs
        """
        ...
    @num_uv_scalars.setter
    def num_uv_scalars(self, value: int) -> None:
        ...
    @property
    def num_interpolator_scalars(self) -> int:
        r"""
        (int32):  [Read-Write] Number of interpolator scalars required for user-defined interpolators
        """
        ...
    @num_interpolator_scalars.setter
    def num_interpolator_scalars(self, value: int) -> None:
        ...

class CurveEditorBakeFilterRange(StructBase):
    r"""
    Curve Editor Bake Filter Range
    
    **C++ Source:**
    
    - **Module**: CurveEditor
    - **File**: CurveEditorBakeFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max`` (FrameNumber):  [Read-Write]
    - ``min`` (FrameNumber):  [Read-Write]
    """
    def __init__(self, min: FrameNumber = [0], max: FrameNumber = [0]) -> None:
        ...
    @property
    def min(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write]
        """
        ...
    @min.setter
    def min(self, value: FrameNumber) -> None:
        ...
    @property
    def max(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write]
        """
        ...
    @max.setter
    def max(self, value: FrameNumber) -> None:
        ...

class CameraLookatTrackingSettings(StructBase):
    r"""
    Settings to control the camera's lookat feature
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_to_track`` (Actor):  [Read-Write] If set, camera will track this actor's location
    - ``allow_roll`` (bool):  [Read-Write] True to allow user-defined roll, false otherwise.
    - ``draw_debug_look_at_tracking_position`` (bool):  [Read-Write] True to draw a debug representation of the lookat location
    - ``enable_look_at_tracking`` (bool):  [Read-Write] True to enable lookat tracking, false otherwise.
    - ``look_at_tracking_interp_speed`` (float):  [Read-Write] Controls degree of smoothing. 0.f for no smoothing, higher numbers for faster/tighter tracking.
    - ``relative_offset`` (Vector):  [Read-Write] Offset from actor position to look at. Relative to actor if tracking an actor, relative to world otherwise.
    """
    def __init__(self, enable_look_at_tracking: bool = False, draw_debug_look_at_tracking_position: bool = False, look_at_tracking_interp_speed: float = 0.000000, actor_to_track: Actor = None, relative_offset: Vector = [0.000000, 0.000000, 0.000000], allow_roll: bool = False) -> None:
        ...
    @property
    def enable_look_at_tracking(self) -> bool:
        r"""
        (bool):  [Read-Write] True to enable lookat tracking, false otherwise.
        """
        ...
    @enable_look_at_tracking.setter
    def enable_look_at_tracking(self, value: bool) -> None:
        ...
    @property
    def draw_debug_look_at_tracking_position(self) -> bool:
        r"""
        (bool):  [Read-Write] True to draw a debug representation of the lookat location
        """
        ...
    @draw_debug_look_at_tracking_position.setter
    def draw_debug_look_at_tracking_position(self, value: bool) -> None:
        ...
    @property
    def look_at_tracking_interp_speed(self) -> float:
        r"""
        (float):  [Read-Write] Controls degree of smoothing. 0.f for no smoothing, higher numbers for faster/tighter tracking.
        """
        ...
    @look_at_tracking_interp_speed.setter
    def look_at_tracking_interp_speed(self, value: float) -> None:
        ...
    @property
    def actor_to_track(self) -> Actor:
        r"""
        (Actor):  [Read-Write] If set, camera will track this actor's location
        """
        ...
    @actor_to_track.setter
    def actor_to_track(self, value: Actor) -> None:
        ...
    @property
    def relative_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Offset from actor position to look at. Relative to actor if tracking an actor, relative to world otherwise.
        """
        ...
    @relative_offset.setter
    def relative_offset(self, value: Vector) -> None:
        ...
    @property
    def allow_roll(self) -> bool:
        r"""
        (bool):  [Read-Write] True to allow user-defined roll, false otherwise.
        """
        ...
    @allow_roll.setter
    def allow_roll(self, value: bool) -> None:
        ...

class CameraFilmbackSettings(StructBase):
    r"""
    #note, this struct has a details customization in CameraFilmbackSettingsCustomization.cpp/h
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``sensor_aspect_ratio`` (float):  [Read-Only] Read-only. Computed from Sensor dimensions.
    - ``sensor_height`` (float):  [Read-Write] Vertical size of filmback or digital sensor, in mm.
    - ``sensor_width`` (float):  [Read-Write] Horizontal size of filmback or digital sensor, in mm.
    """
    def __init__(self, sensor_width: float = 0.000000, sensor_height: float = 0.000000, sensor_aspect_ratio: float = 0.000000) -> None:
        ...
    @property
    def sensor_width(self) -> float:
        r"""
        (float):  [Read-Write] Horizontal size of filmback or digital sensor, in mm.
        """
        ...
    @sensor_width.setter
    def sensor_width(self, value: float) -> None:
        ...
    @property
    def sensor_height(self) -> float:
        r"""
        (float):  [Read-Write] Vertical size of filmback or digital sensor, in mm.
        """
        ...
    @sensor_height.setter
    def sensor_height(self, value: float) -> None:
        ...
    @property
    def sensor_aspect_ratio(self) -> float:
        r"""
        (float):  [Read-Only] Read-only. Computed from Sensor dimensions.
        """
        ...

class NamedFilmbackPreset(StructBase):
    r"""
    A named bundle of filmback settings used to implement filmback presets
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``filmback_settings`` (CameraFilmbackSettings):  [Read-Write]
    - ``name`` (str):  [Read-Write] Name for the preset.
    """
    def __init__(self, name: str = "", filmback_settings: CameraFilmbackSettings = [24.889999, 18.670000, 1.330000]) -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Write] Name for the preset.
        """
        ...
    @name.setter
    def name(self, value: str) -> None:
        ...
    @property
    def filmback_settings(self) -> CameraFilmbackSettings:
        r"""
        (CameraFilmbackSettings):  [Read-Write]
        """
        ...
    @filmback_settings.setter
    def filmback_settings(self, value: CameraFilmbackSettings) -> None:
        ...

class CameraLensSettings(StructBase):
    r"""
    #note, this struct has a details customization in CameraLensSettingsCustomization.cpp/h
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``diaphragm_blade_count`` (int32):  [Read-Write] Number of blades of diaphragm.
    - ``max_f_stop`` (float):  [Read-Write] Maximum aperture for this lens (e.g. 2.8 for an f/2.8 lens)
    - ``max_focal_length`` (float):  [Read-Write] Maximum focal length for this lens
    - ``min_f_stop`` (float):  [Read-Write] Minimum aperture for this lens (e.g. 2.8 for an f/2.8 lens)
    - ``min_focal_length`` (float):  [Read-Write] Minimum focal length for this lens
    - ``minimum_focus_distance`` (float):  [Read-Write] Shortest distance this lens can focus on.
    - ``squeeze_factor`` (float):  [Read-Write] Squeeze factor for anamorphic lenses.
    """
    def __init__(self, min_focal_length: float = 0.000000, max_focal_length: float = 0.000000, min_f_stop: float = 0.000000, max_f_stop: float = 0.000000, minimum_focus_distance: float = 0.000000, squeeze_factor: float = 0.000000, diaphragm_blade_count: int = 0) -> None:
        ...
    @property
    def min_focal_length(self) -> float:
        r"""
        (float):  [Read-Write] Minimum focal length for this lens
        """
        ...
    @min_focal_length.setter
    def min_focal_length(self, value: float) -> None:
        ...
    @property
    def max_focal_length(self) -> float:
        r"""
        (float):  [Read-Write] Maximum focal length for this lens
        """
        ...
    @max_focal_length.setter
    def max_focal_length(self, value: float) -> None:
        ...
    @property
    def min_f_stop(self) -> float:
        r"""
        (float):  [Read-Write] Minimum aperture for this lens (e.g. 2.8 for an f/2.8 lens)
        """
        ...
    @min_f_stop.setter
    def min_f_stop(self, value: float) -> None:
        ...
    @property
    def max_f_stop(self) -> float:
        r"""
        (float):  [Read-Write] Maximum aperture for this lens (e.g. 2.8 for an f/2.8 lens)
        """
        ...
    @max_f_stop.setter
    def max_f_stop(self, value: float) -> None:
        ...
    @property
    def minimum_focus_distance(self) -> float:
        r"""
        (float):  [Read-Write] Shortest distance this lens can focus on.
        """
        ...
    @minimum_focus_distance.setter
    def minimum_focus_distance(self, value: float) -> None:
        ...
    @property
    def squeeze_factor(self) -> float:
        r"""
        (float):  [Read-Write] Squeeze factor for anamorphic lenses.
        """
        ...
    @squeeze_factor.setter
    def squeeze_factor(self, value: float) -> None:
        ...
    @property
    def diaphragm_blade_count(self) -> int:
        r"""
        (int32):  [Read-Write] Number of blades of diaphragm.
        """
        ...
    @diaphragm_blade_count.setter
    def diaphragm_blade_count(self, value: int) -> None:
        ...

class NamedLensPreset(StructBase):
    r"""
    A named bundle of lens settings used to implement lens presets.
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``lens_settings`` (CameraLensSettings):  [Read-Write]
    - ``name`` (str):  [Read-Write] Name for the preset.
    """
    def __init__(self, name: str = "", lens_settings: CameraLensSettings = [50.000000, 50.000000, 2.000000, 2.000000, 15.000000, 1.000000, 5]) -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Write] Name for the preset.
        """
        ...
    @name.setter
    def name(self, value: str) -> None:
        ...
    @property
    def lens_settings(self) -> CameraLensSettings:
        r"""
        (CameraLensSettings):  [Read-Write]
        """
        ...
    @lens_settings.setter
    def lens_settings(self, value: CameraLensSettings) -> None:
        ...

class PlateCropSettings(StructBase):
    r"""
    #note, this struct has a details customization in CameraCropSettingsCustomization.cpp/h
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``aspect_ratio`` (float):  [Read-Write]
    """
    def __init__(self, aspect_ratio: float = 0.000000) -> None:
        ...
    @property
    def aspect_ratio(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @aspect_ratio.setter
    def aspect_ratio(self, value: float) -> None:
        ...

class NamedPlateCropPreset(StructBase):
    r"""
    A named bundle of crop settings used to implement crop presets.
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``crop_settings`` (PlateCropSettings):  [Read-Write]
    - ``name`` (str):  [Read-Write] Name for the preset.
    """
    def __init__(self, name: str = "", crop_settings: PlateCropSettings = [0.000000]) -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Write] Name for the preset.
        """
        ...
    @name.setter
    def name(self, value: str) -> None:
        ...
    @property
    def crop_settings(self) -> PlateCropSettings:
        r"""
        (PlateCropSettings):  [Read-Write]
        """
        ...
    @crop_settings.setter
    def crop_settings(self, value: PlateCropSettings) -> None:
        ...

class CameraTrackingFocusSettings(StructBase):
    r"""
    Settings to control tracking-focus mode.
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_to_track`` (Actor):  [Read-Write] Focus distance will be tied to this actor's location.
    - ``draw_debug_tracking_focus_point`` (bool):  [Read-Write] True to draw a debug representation of the tracked position.
    - ``relative_offset`` (Vector):  [Read-Write] Offset from actor position to track. Relative to actor if tracking an actor, relative to world otherwise.
    """
    def __init__(self, actor_to_track: Actor = None, relative_offset: Vector = [0.000000, 0.000000, 0.000000], draw_debug_tracking_focus_point: bool = False) -> None:
        ...
    @property
    def actor_to_track(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Focus distance will be tied to this actor's location.
        """
        ...
    @actor_to_track.setter
    def actor_to_track(self, value: Actor) -> None:
        ...
    @property
    def relative_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Offset from actor position to track. Relative to actor if tracking an actor, relative to world otherwise.
        """
        ...
    @relative_offset.setter
    def relative_offset(self, value: Vector) -> None:
        ...
    @property
    def draw_debug_tracking_focus_point(self) -> bool:
        r"""
        (bool):  [Read-Write] True to draw a debug representation of the tracked position.
        """
        ...
    @draw_debug_tracking_focus_point.setter
    def draw_debug_tracking_focus_point(self, value: bool) -> None:
        ...

class CameraFocusSettings(StructBase):
    r"""
    Settings to control camera focus
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_focus_plane_color`` (Color):  [Read-Write] For customizing the focus plane color, in case the default doesn't show up well in your scene.
    - ``draw_debug_focus_plane`` (bool):  [Read-Write] True to draw a translucent plane at the current focus depth, for easy tweaking.
    - ``focus_method`` (CameraFocusMethod):  [Read-Write] Which method to use to handle camera focus
    - ``focus_offset`` (float):  [Read-Write] Additional focus depth offset, used for manually tweaking if your chosen focus method needs adjustment
    - ``focus_smoothing_interp_speed`` (float):  [Read-Write] Controls interpolation speed when smoothing focus distance changes. Ignored if bSmoothFocusChanges is false.
    - ``manual_focus_distance`` (float):  [Read-Write] Manually-controlled focus distance (manual focus mode only)
    - ``smooth_focus_changes`` (bool):  [Read-Write] True to use interpolation to smooth out changes in focus distance, false for focus distance changes to be instantaneous.
    - ``tracking_focus_settings`` (CameraTrackingFocusSettings):  [Read-Write] Settings to control tracking focus (tracking focus mode only)
    """
    def __init__(self, focus_method: CameraFocusMethod = CameraFocusMethod.DO_NOT_OVERRIDE, manual_focus_distance: float = 0.000000, tracking_focus_settings: CameraTrackingFocusSettings = [None, [0.000000, 0.000000, 0.000000], False], smooth_focus_changes: bool = False, focus_smoothing_interp_speed: float = 0.000000, focus_offset: float = 0.000000) -> None:
        ...
    @property
    def focus_method(self) -> CameraFocusMethod:
        r"""
        (CameraFocusMethod):  [Read-Write] Which method to use to handle camera focus
        """
        ...
    @focus_method.setter
    def focus_method(self, value: CameraFocusMethod) -> None:
        ...
    @property
    def manual_focus_distance(self) -> float:
        r"""
        (float):  [Read-Write] Manually-controlled focus distance (manual focus mode only)
        """
        ...
    @manual_focus_distance.setter
    def manual_focus_distance(self, value: float) -> None:
        ...
    @property
    def tracking_focus_settings(self) -> CameraTrackingFocusSettings:
        r"""
        (CameraTrackingFocusSettings):  [Read-Write] Settings to control tracking focus (tracking focus mode only)
        """
        ...
    @tracking_focus_settings.setter
    def tracking_focus_settings(self, value: CameraTrackingFocusSettings) -> None:
        ...
    @property
    def smooth_focus_changes(self) -> bool:
        r"""
        (bool):  [Read-Write] True to use interpolation to smooth out changes in focus distance, false for focus distance changes to be instantaneous.
        """
        ...
    @smooth_focus_changes.setter
    def smooth_focus_changes(self, value: bool) -> None:
        ...
    @property
    def focus_smoothing_interp_speed(self) -> float:
        r"""
        (float):  [Read-Write] Controls interpolation speed when smoothing focus distance changes. Ignored if bSmoothFocusChanges is false.
        """
        ...
    @focus_smoothing_interp_speed.setter
    def focus_smoothing_interp_speed(self, value: float) -> None:
        ...
    @property
    def focus_offset(self) -> float:
        r"""
        (float):  [Read-Write] Additional focus depth offset, used for manually tweaking if your chosen focus method needs adjustment
        """
        ...
    @focus_offset.setter
    def focus_offset(self, value: float) -> None:
        ...

class DataLayerCreationParameters(StructBase):
    r"""
    Data Layer Creation Parameters
    
    **C++ Source:**
    
    - **Module**: DataLayerEditor
    - **File**: DataLayerEditorSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_layer_asset`` (DataLayerAsset):  [Read-Write] Required. Will assign the asset to the created instance.
    - ``is_private`` (bool):  [Read-Write]
    - ``world_data_layers`` (WorldDataLayers):  [Read-Write] Optional. Will default at the level WorldDataLayers if unset.
    """
    def __init__(self, data_layer_asset: DataLayerAsset = None, world_data_layers: WorldDataLayers = None, is_private: bool = False) -> None:
        ...
    @property
    def data_layer_asset(self) -> DataLayerAsset:
        r"""
        (DataLayerAsset):  [Read-Write] Required. Will assign the asset to the created instance.
        """
        ...
    @data_layer_asset.setter
    def data_layer_asset(self, value: DataLayerAsset) -> None:
        ...
    @property
    def world_data_layers(self) -> WorldDataLayers:
        r"""
        (WorldDataLayers):  [Read-Write] Optional. Will default at the level WorldDataLayers if unset.
        """
        ...
    @world_data_layers.setter
    def world_data_layers(self, value: WorldDataLayers) -> None:
        ...
    @property
    def is_private(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_private.setter
    def is_private(self, value: bool) -> None:
        ...

class InputRayHit(StructBase):
    r"""
    * FInputRayHit is returned by various hit-test interface functions.
    * Generally this is intended to be returned as the result of a hit-test with a FInputDeviceRay
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: InputState.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``has_hit_normal`` (bool):  [Read-Write] True if HitNormal was set
    - ``hit`` (bool):  [Read-Write] true if ray hit something, false otherwise
    - ``hit_depth`` (double):  [Read-Write] distance along ray at which intersection occurred
    - ``hit_identifier`` (int32):  [Read-Write] Client-defined integer identifier for hit object/element/target/etc
    - ``hit_normal`` (Vector):  [Read-Write] Normal at hit point, if available
    - ``hit_object`` (Object):  [Read-Write] Client-defined pointer for UObject-derived hit owners.
      HitOwner and HitObject should be set to the same pointer if the HitOwner derives from UObject.
    """
    def __init__(self, hit: bool = False, hit_depth: float = 0.000000, hit_normal: Vector = [0.000000, 0.000000, 0.000000], has_hit_normal: bool = False, hit_identifier: int = 0, hit_object: Object = None) -> None:
        ...
    @property
    def hit(self) -> bool:
        r"""
        (bool):  [Read-Write] true if ray hit something, false otherwise
        """
        ...
    @hit.setter
    def hit(self, value: bool) -> None:
        ...
    @property
    def hit_depth(self) -> float:
        r"""
        (double):  [Read-Write] distance along ray at which intersection occurred
        """
        ...
    @hit_depth.setter
    def hit_depth(self, value: float) -> None:
        ...
    @property
    def hit_normal(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Normal at hit point, if available
        """
        ...
    @hit_normal.setter
    def hit_normal(self, value: Vector) -> None:
        ...
    @property
    def has_hit_normal(self) -> bool:
        r"""
        (bool):  [Read-Write] True if HitNormal was set
        """
        ...
    @has_hit_normal.setter
    def has_hit_normal(self, value: bool) -> None:
        ...
    @property
    def hit_identifier(self) -> int:
        r"""
        (int32):  [Read-Write] Client-defined integer identifier for hit object/element/target/etc
        """
        ...
    @hit_identifier.setter
    def hit_identifier(self, value: int) -> None:
        ...
    @property
    def hit_object(self) -> Object:
        r"""
        (Object):  [Read-Write] Client-defined pointer for UObject-derived hit owners.
        HitOwner and HitObject should be set to the same pointer if the HitOwner derives from UObject.
        """
        ...
    @hit_object.setter
    def hit_object(self, value: Object) -> None:
        ...

class DeviceButtonState(StructBase):
    r"""
    Current State of a physical device button (mouse, key, etc) at a point in time.
    Each "click" of a button should involve at minimum two separate state
    events, one where bPressed=true and one where bReleased=true.
    Each of these states should occur only once.
    In addition there may be additional frames where the button is
    held down and bDown=true and bPressed=false.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: InputState.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``button`` (Key):  [Read-Write] Button identifier
    - ``down`` (bool):  [Read-Write] Is the button currently pressed down. This should be true every frame the button is pressed.
    - ``pressed`` (bool):  [Read-Write] Was the button pressed down this frame. This should happen once per "click"
    - ``released`` (bool):  [Read-Write] Was the button released this frame. This should happen once per "click"
    """
    def __init__(self, button: Key = [], pressed: bool = False, down: bool = False, released: bool = False) -> None:
        ...
    @property
    def button(self) -> Key:
        r"""
        (Key):  [Read-Write] Button identifier
        """
        ...
    @button.setter
    def button(self, value: Key) -> None:
        ...
    @property
    def pressed(self) -> bool:
        r"""
        (bool):  [Read-Write] Was the button pressed down this frame. This should happen once per "click"
        """
        ...
    @pressed.setter
    def pressed(self, value: bool) -> None:
        ...
    @property
    def down(self) -> bool:
        r"""
        (bool):  [Read-Write] Is the button currently pressed down. This should be true every frame the button is pressed.
        """
        ...
    @down.setter
    def down(self, value: bool) -> None:
        ...
    @property
    def released(self) -> bool:
        r"""
        (bool):  [Read-Write] Was the button released this frame. This should happen once per "click"
        """
        ...
    @released.setter
    def released(self, value: bool) -> None:
        ...

class KeyboardInputDeviceState(StructBase):
    r"""
    Current state of active keyboard key at a point in time
    todo: would be useful to track set of active keys
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: InputState.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active_key`` (DeviceButtonState):  [Read-Write] state of active key that was modified (ie press or release)
    """
    def __init__(self, active_key: DeviceButtonState = [[], False, False, False]) -> None:
        ...
    @property
    def active_key(self) -> DeviceButtonState:
        r"""
        (DeviceButtonState):  [Read-Write] state of active key that was modified (ie press or release)
        """
        ...
    @active_key.setter
    def active_key(self, value: DeviceButtonState) -> None:
        ...

class MouseInputDeviceState(StructBase):
    r"""
    Current State of a physical Mouse device at a point in time.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: InputState.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delta2d`` (Vector2D):  [Read-Write] Change in 2D mouse position from last state event
    - ``left`` (DeviceButtonState):  [Read-Write] State of the left mouse button
    - ``middle`` (DeviceButtonState):  [Read-Write] State of the middle mouse button
    - ``position2d`` (Vector2D):  [Read-Write] Current 2D position of the mouse, in application-defined coordinate system
    - ``right`` (DeviceButtonState):  [Read-Write] State of the right mouse button
    - ``wheel_delta`` (float):  [Read-Write] Change in 'ticks' of the mouse wheel since last state event
    - ``world_ray`` (Ray):  [Read-Write] Ray into current 3D scene at current 2D mouse position
    """
    def __init__(self, left: DeviceButtonState = [[], False, False, False], middle: DeviceButtonState = [[], False, False, False], right: DeviceButtonState = [[], False, False, False], wheel_delta: float = 0.000000, position2d: Vector2D = [0.000000, 0.000000], delta2d: Vector2D = [0.000000, 0.000000], world_ray: Ray = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]]) -> None:
        ...
    @property
    def left(self) -> DeviceButtonState:
        r"""
        (DeviceButtonState):  [Read-Write] State of the left mouse button
        """
        ...
    @left.setter
    def left(self, value: DeviceButtonState) -> None:
        ...
    @property
    def middle(self) -> DeviceButtonState:
        r"""
        (DeviceButtonState):  [Read-Write] State of the middle mouse button
        """
        ...
    @middle.setter
    def middle(self, value: DeviceButtonState) -> None:
        ...
    @property
    def right(self) -> DeviceButtonState:
        r"""
        (DeviceButtonState):  [Read-Write] State of the right mouse button
        """
        ...
    @right.setter
    def right(self, value: DeviceButtonState) -> None:
        ...
    @property
    def wheel_delta(self) -> float:
        r"""
        (float):  [Read-Write] Change in 'ticks' of the mouse wheel since last state event
        """
        ...
    @wheel_delta.setter
    def wheel_delta(self, value: float) -> None:
        ...
    @property
    def position2d(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Current 2D position of the mouse, in application-defined coordinate system
        """
        ...
    @position2d.setter
    def position2d(self, value: Vector2D) -> None:
        ...
    @property
    def delta2d(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Change in 2D mouse position from last state event
        """
        ...
    @delta2d.setter
    def delta2d(self, value: Vector2D) -> None:
        ...
    @property
    def world_ray(self) -> Ray:
        r"""
        (Ray):  [Read-Write] Ray into current 3D scene at current 2D mouse position
        """
        ...
    @world_ray.setter
    def world_ray(self, value: Ray) -> None:
        ...

class InputDeviceState(StructBase):
    r"""
    Current state of physical input devices at a point in time.
    Assumption is that the state refers to a single physical input device,
    ie InputDevice field is a single value of EInputDevices and not a combination.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: InputState.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alt_key_down`` (bool):  [Read-Write] Is they keyboard ALT modifier key currently pressed down
    - ``cmd_key_down`` (bool):  [Read-Write] Is they keyboard CMD modifier key currently pressed down (only on Apple devices)
    - ``ctrl_key_down`` (bool):  [Read-Write] Is they keyboard CTRL modifier key currently pressed down
    - ``input_device`` (InputDevices):  [Read-Write] Which InputDevice member is valid in this state
    - ``keyboard`` (KeyboardInputDeviceState):  [Read-Write] Current state of Keyboard device, if InputDevice == EInputDevices::Keyboard
    - ``mouse`` (MouseInputDeviceState):  [Read-Write] Current state of Mouse device, if InputDevice == EInputDevices::Mouse
    - ``shift_key_down`` (bool):  [Read-Write] Is they keyboard SHIFT modifier key currently pressed down
    """
    def __init__(self, input_device: InputDevices = InputDevices.NONE, shift_key_down: bool = False, alt_key_down: bool = False, ctrl_key_down: bool = False, cmd_key_down: bool = False, keyboard: KeyboardInputDeviceState = [[[], False, False, False]], mouse: MouseInputDeviceState = [[[], False, False, False], [[], False, False, False], [[], False, False, False], 0.000000, [0.000000, 0.000000], [0.000000, 0.000000], [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 1.000000]]]) -> None:
        ...
    @property
    def input_device(self) -> InputDevices:
        r"""
        (InputDevices):  [Read-Write] Which InputDevice member is valid in this state
        """
        ...
    @input_device.setter
    def input_device(self, value: InputDevices) -> None:
        ...
    @property
    def shift_key_down(self) -> bool:
        r"""
        (bool):  [Read-Write] Is they keyboard SHIFT modifier key currently pressed down
        """
        ...
    @shift_key_down.setter
    def shift_key_down(self, value: bool) -> None:
        ...
    @property
    def alt_key_down(self) -> bool:
        r"""
        (bool):  [Read-Write] Is they keyboard ALT modifier key currently pressed down
        """
        ...
    @alt_key_down.setter
    def alt_key_down(self, value: bool) -> None:
        ...
    @property
    def ctrl_key_down(self) -> bool:
        r"""
        (bool):  [Read-Write] Is they keyboard CTRL modifier key currently pressed down
        """
        ...
    @ctrl_key_down.setter
    def ctrl_key_down(self, value: bool) -> None:
        ...
    @property
    def cmd_key_down(self) -> bool:
        r"""
        (bool):  [Read-Write] Is they keyboard CMD modifier key currently pressed down (only on Apple devices)
        """
        ...
    @cmd_key_down.setter
    def cmd_key_down(self, value: bool) -> None:
        ...
    @property
    def keyboard(self) -> KeyboardInputDeviceState:
        r"""
        (KeyboardInputDeviceState):  [Read-Write] Current state of Keyboard device, if InputDevice == EInputDevices::Keyboard
        """
        ...
    @keyboard.setter
    def keyboard(self, value: KeyboardInputDeviceState) -> None:
        ...
    @property
    def mouse(self) -> MouseInputDeviceState:
        r"""
        (MouseInputDeviceState):  [Read-Write] Current state of Mouse device, if InputDevice == EInputDevices::Mouse
        """
        ...
    @mouse.setter
    def mouse(self, value: MouseInputDeviceState) -> None:
        ...

class InputDeviceRay(StructBase):
    r"""
    FInputDeviceRay represents a 3D ray created based on an input device.
    If the device is a 2D input device like a mouse, then the ray may
    have an associated 2D screen position.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: InputState.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``has2d`` (bool):  [Read-Write] If true, WorldRay has 2D device position coordinates
    - ``screen_position`` (Vector2D):  [Read-Write] 2D device position coordinates associated with the ray
    - ``world_ray`` (Ray):  [Read-Write] 3D ray in 3D scene, in world coordinates
    """
    def __init__(self, world_ray: Ray = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], has2d: bool = False, screen_position: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def world_ray(self) -> Ray:
        r"""
        (Ray):  [Read-Write] 3D ray in 3D scene, in world coordinates
        """
        ...
    @world_ray.setter
    def world_ray(self, value: Ray) -> None:
        ...
    @property
    def has2d(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, WorldRay has 2D device position coordinates
        """
        ...
    @has2d.setter
    def has2d(self, value: bool) -> None:
        ...
    @property
    def screen_position(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] 2D device position coordinates associated with the ray
        """
        ...
    @screen_position.setter
    def screen_position(self, value: Vector2D) -> None:
        ...

class SubobjectData(StructBase):
    r"""
    A struct that represents a single subobject. This can be anything, but are
    most commonly components attached to an actor instance or blueprint. Keeps track
    of the handles to its parent object and any child that it has.
    
    If you wish to modify a subobject, use the SubobjectDataSubsystem.
    
    **C++ Source:**
    
    - **Module**: SubobjectDataInterface
    - **File**: SubobjectData.h
    
    """
    def __init__(self) -> None:
        ...

class SubobjectDataHandle(StructBase):
    r"""
    A subobject handle is a globally unique identifier for subobjects
    Upon construction, the handle will be invalid. It is the responsibility
    of the owning FSubobjectData to set the DataPtr once the subobject
    data has validated that it has a good context.
    
    **C++ Source:**
    
    - **Module**: SubobjectDataInterface
    - **File**: SubobjectDataHandle.h
    
    """
    def __init__(self) -> None:
        ...

class AddNewSubobjectParams(StructBase):
    r"""
    Options when adding a new subobject
    
    **C++ Source:**
    
    - **Module**: SubobjectDataInterface
    - **File**: SubobjectDataSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blueprint_context`` (Blueprint):  [Read-Write] Pointer to the blueprint context that this subobject is in. If this is null, it is assumed that
      this subobject is being added to an instance.
    - ``conform_transform_to_parent`` (bool):  [Read-Write] Whether the newly created component should keep its transform, or conform it to its parent
    - ``new_class`` (type(Class)):  [Read-Write] The class of the new subobject that will be added
    - ``parent_handle`` (SubobjectDataHandle):  [Read-Write]
    - ``skip_mark_blueprint_modified`` (bool):  [Read-Write] Optionally skip marking this blueprint as modified (e.g. if we're handling that externally
    """
    def __init__(self, parent_handle: SubobjectDataHandle = [], new_class: Class = None, blueprint_context: Blueprint = None, skip_mark_blueprint_modified: bool = False, conform_transform_to_parent: bool = False) -> None:
        ...
    @property
    def parent_handle(self) -> SubobjectDataHandle:
        r"""
        (SubobjectDataHandle):  [Read-Write]
        """
        ...
    @parent_handle.setter
    def parent_handle(self, value: SubobjectDataHandle) -> None:
        ...
    @property
    def new_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] The class of the new subobject that will be added
        """
        ...
    @new_class.setter
    def new_class(self, value: Class) -> None:
        ...
    @property
    def blueprint_context(self) -> Blueprint:
        r"""
        (Blueprint):  [Read-Write] Pointer to the blueprint context that this subobject is in. If this is null, it is assumed that
        this subobject is being added to an instance.
        """
        ...
    @blueprint_context.setter
    def blueprint_context(self, value: Blueprint) -> None:
        ...
    @property
    def skip_mark_blueprint_modified(self) -> bool:
        r"""
        (bool):  [Read-Write] Optionally skip marking this blueprint as modified (e.g. if we're handling that externally
        """
        ...
    @skip_mark_blueprint_modified.setter
    def skip_mark_blueprint_modified(self, value: bool) -> None:
        ...
    @property
    def conform_transform_to_parent(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the newly created component should keep its transform, or conform it to its parent
        """
        ...
    @conform_transform_to_parent.setter
    def conform_transform_to_parent(self, value: bool) -> None:
        ...

class ReparentSubobjectParams(StructBase):
    r"""
    Options for reparenting subobjects
    
    **C++ Source:**
    
    - **Module**: SubobjectDataInterface
    - **File**: SubobjectDataSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_preview_context`` (Actor):  [Read-Write] The preview actor context to be used if in a blueprint context.
      This must have a value if BlueprintContext is needed.
    - ``blueprint_context`` (Blueprint):  [Read-Write] Pointer to the blueprint context that this subobject is in. If this is null, it is assumed that
      this subobject is being added to an instance.
    - ``new_parent_handle`` (SubobjectDataHandle):  [Read-Write] The handle of the subobject to reparent to.
    """
    def __init__(self, new_parent_handle: SubobjectDataHandle = [], blueprint_context: Blueprint = None, actor_preview_context: Actor = None) -> None:
        ...
    @property
    def new_parent_handle(self) -> SubobjectDataHandle:
        r"""
        (SubobjectDataHandle):  [Read-Write] The handle of the subobject to reparent to.
        """
        ...
    @new_parent_handle.setter
    def new_parent_handle(self, value: SubobjectDataHandle) -> None:
        ...
    @property
    def blueprint_context(self) -> Blueprint:
        r"""
        (Blueprint):  [Read-Write] Pointer to the blueprint context that this subobject is in. If this is null, it is assumed that
        this subobject is being added to an instance.
        """
        ...
    @blueprint_context.setter
    def blueprint_context(self, value: Blueprint) -> None:
        ...
    @property
    def actor_preview_context(self) -> Actor:
        r"""
        (Actor):  [Read-Write] The preview actor context to be used if in a blueprint context.
        This must have a value if BlueprintContext is needed.
        """
        ...
    @actor_preview_context.setter
    def actor_preview_context(self, value: Actor) -> None:
        ...

class SlatePostSettings(StructBase):
    r"""
    Settings for a particular Slate Post RT.
    Notably if enabled & blur by default. To be updated with additional effects & to be expandable in game code / settings.
    
    **C++ Source:**
    
    - **Module**: SlateRHIRenderer
    - **File**: SlateRHIRendererSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write] Should this post buffer be enabled for updating
    - ``post_processor_class`` (type(Class)):  [Read-Write] Copy of actually loaded post processor class
    """
    def __init__(self, enabled: bool = False, post_processor_class: Class = None) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Should this post buffer be enabled for updating
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def post_processor_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Copy of actually loaded post processor class
        """
        ...
    @post_processor_class.setter
    def post_processor_class(self, value: Class) -> None:
        ...

class RadialBoxSettings(StructBase):
    r"""
    Radial Box Settings
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: RadialBoxSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angle_between_items`` (float):  [Read-Write] Amount of Euler degrees that separate each item. Only used when bDistributeItemsEvenly is false
    - ``distribute_items_evenly`` (bool):  [Read-Write] Distribute Items evenly in the whole circle. Checking this option ignores AngleBetweenItems
    - ``sector_central_angle`` (float):  [Read-Write] If we need a section of a radial (for example half-a-radial) we can define a central angle < 360 (180 in case of half-a-radial). Used when bDistributeItemsEvenly is enabled.
    - ``starting_angle`` (float):  [Read-Write] At what angle will we place the first element of the wheel?
    """
    def __init__(self) -> None:
        ...

class SlateChildSize(StructBase):
    r"""
    A struct exposing size param related properties to UMG.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SlateWrapperTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``size_rule`` (SlateSizeRule):  [Read-Write] The sizing rule of the content.
    - ``value`` (float):  [Read-Write] The parameter of the size rule.
    """
    def __init__(self, value: float = 0.000000, size_rule: SlateSizeRule = SlateSizeRule.AUTOMATIC) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write] The parameter of the size rule.
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def size_rule(self) -> SlateSizeRule:
        r"""
        (SlateSizeRule):  [Read-Write] The sizing rule of the content.
        """
        ...
    @size_rule.setter
    def size_rule(self, value: SlateSizeRule) -> None:
        ...

class WidgetEventField(StructBase):
    r"""
    Generic structure to notify when an event occurs.
    
    class UMyWidget : public UWidget
    {
      UPROPERTY(FieldNotify)
      FWidgetEventField SomeEvent;
    
      void OnSomeEvent()
      {
        BroadcastFieldValueChanged(FFieldNotificationClassDescriptor::Text);
      }
    };
    };
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetEventField.h
    
    """
    def __init__(self) -> None:
        ...

class WidgetNavigationData(StructBase):
    r"""
    Widget Navigation Data
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetNavigation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``rule`` (UINavigationRule):  [Read-Write]
    - ``widget_to_focus`` (Name):  [Read-Write] This either the widget to focus, OR the name of the function to call.
    """
    def __init__(self, rule: UINavigationRule = UINavigationRule.ESCAPE, widget_to_focus: Name = "None") -> None:
        ...
    @property
    def rule(self) -> UINavigationRule:
        r"""
        (UINavigationRule):  [Read-Only]
        """
        ...
    @property
    def widget_to_focus(self) -> Name:
        r"""
        (Name):  [Read-Only] This either the widget to focus, OR the name of the function to call.
        """
        ...

class GameViewportWidgetSlot(StructBase):
    r"""
    The default value fills the entire screen / player region.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: GameViewportSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alignment`` (Vector2D):  [Read-Write]
    - ``anchors`` (Anchors):  [Read-Write]
    - ``auto_remove_on_world_removed`` (bool):  [Read-Write] Remove the widget when the Widget's World is removed.
      note: The Widget is added to the GameViewportClient of the Widget's World. The GameViewportClient can migrate from World to World. The widget can stay visible if the owner of the widget also migrate.
    - ``offsets`` (Margin):  [Read-Write]
    - ``z_order`` (int32):  [Read-Write] The higher the number, the more on top this widget will be.
    """
    def __init__(self, anchors: Anchors = [[0.000000, 0.000000], [0.000000, 0.000000]], offsets: Margin = [0.000000, 0.000000, 0.000000, 0.000000], alignment: Vector2D = [0.000000, 0.000000], z_order: int = 0, auto_remove_on_world_removed: bool = False) -> None:
        ...
    @property
    def anchors(self) -> Anchors:
        r"""
        (Anchors):  [Read-Write]
        """
        ...
    @anchors.setter
    def anchors(self, value: Anchors) -> None:
        ...
    @property
    def offsets(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @offsets.setter
    def offsets(self, value: Margin) -> None:
        ...
    @property
    def alignment(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write]
        """
        ...
    @alignment.setter
    def alignment(self, value: Vector2D) -> None:
        ...
    @property
    def z_order(self) -> int:
        r"""
        (int32):  [Read-Write] The higher the number, the more on top this widget will be.
        """
        ...
    @z_order.setter
    def z_order(self, value: int) -> None:
        ...
    @property
    def auto_remove_on_world_removed(self) -> bool:
        r"""
        (bool):  [Read-Write] Remove the widget when the Widget's World is removed.
        note: The Widget is added to the GameViewportClient of the Widget's World. The GameViewportClient can migrate from World to World. The widget can stay visible if the owner of the widget also migrate.
        """
        ...
    @auto_remove_on_world_removed.setter
    def auto_remove_on_world_removed(self, value: bool) -> None:
        ...

class AnchorData(StructBase):
    r"""
    Anchor Data
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: CanvasPanelSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alignment`` (Vector2D):  [Read-Write] Alignment is the pivot point of the widget.  Starting in the upper left at (0,0),
      ending in the lower right at (1,1).  Moving the alignment point allows you to move
      the origin of the widget.
    - ``anchors`` (Anchors):  [Read-Write] Anchors.
    - ``offsets`` (Margin):  [Read-Write] Offset.
    """
    def __init__(self, offsets: Margin = [0.000000, 0.000000, 0.000000, 0.000000], anchors: Anchors = [[0.000000, 0.000000], [0.000000, 0.000000]], alignment: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def offsets(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Offset.
        """
        ...
    @offsets.setter
    def offsets(self, value: Margin) -> None:
        ...
    @property
    def anchors(self) -> Anchors:
        r"""
        (Anchors):  [Read-Write] Anchors.
        """
        ...
    @anchors.setter
    def anchors(self, value: Anchors) -> None:
        ...
    @property
    def alignment(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Alignment is the pivot point of the widget.  Starting in the upper left at (0,0),
        ending in the lower right at (1,1).  Moving the alignment point allows you to move
        the origin of the widget.
        """
        ...
    @alignment.setter
    def alignment(self, value: Vector2D) -> None:
        ...

class RichTextStyleRow(TableRowBase):
    r"""
    Simple struct for rich text styles
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: RichTextBlock.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``text_style`` (TextBlockStyle):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class RichImageRow(TableRowBase):
    r"""
    Simple struct for rich text styles
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: RichTextBlockImageDecorator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``brush`` (SlateBrush):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class ContentBrowserDataFilter(StructBase):
    r"""
    A filter used to control what is returned from Content Browser data queries.
    note: The compiled version of this, FContentBrowserDataCompiledFilter, is produced via UContentBrowserDataSubsystem::CompileFilter.
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item_attribute_filter`` (ContentBrowserItemAttributeFilter):  [Read-Write] Flags controlling which item attributes should be included in this query
    - ``item_category_filter`` (ContentBrowserItemCategoryFilter):  [Read-Write] Flags controlling which item categories should be included in this query
    - ``item_type_filter`` (ContentBrowserItemTypeFilter):  [Read-Write] Flags controlling which item types should be included in this query
    - ``recursive_paths`` (bool):  [Read-Write] Whether we should include sub-paths in this query
    """
    def __init__(self, recursive_paths: bool = False, item_type_filter: ContentBrowserItemTypeFilter = ContentBrowserItemTypeFilter.INCLUDE_NONE, item_category_filter: ContentBrowserItemCategoryFilter = ContentBrowserItemCategoryFilter.INCLUDE_NONE, item_attribute_filter: ContentBrowserItemAttributeFilter = ContentBrowserItemAttributeFilter.INCLUDE_NONE) -> None:
        ...
    @property
    def recursive_paths(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we should include sub-paths in this query
        """
        ...
    @recursive_paths.setter
    def recursive_paths(self, value: bool) -> None:
        ...
    @property
    def item_type_filter(self) -> ContentBrowserItemTypeFilter:
        r"""
        (ContentBrowserItemTypeFilter):  [Read-Write] Flags controlling which item types should be included in this query
        """
        ...
    @item_type_filter.setter
    def item_type_filter(self, value: ContentBrowserItemTypeFilter) -> None:
        ...
    @property
    def item_category_filter(self) -> ContentBrowserItemCategoryFilter:
        r"""
        (ContentBrowserItemCategoryFilter):  [Read-Write] Flags controlling which item categories should be included in this query
        """
        ...
    @item_category_filter.setter
    def item_category_filter(self, value: ContentBrowserItemCategoryFilter) -> None:
        ...
    @property
    def item_attribute_filter(self) -> ContentBrowserItemAttributeFilter:
        r"""
        (ContentBrowserItemAttributeFilter):  [Read-Write] Flags controlling which item attributes should be included in this query
        """
        ...
    @item_attribute_filter.setter
    def item_attribute_filter(self, value: ContentBrowserItemAttributeFilter) -> None:
        ...

class ContentBrowserDataObjectFilter(StructBase):
    r"""
    Data used to filter object instances by their name and tags.
    note: This will typically limit your query to returning assets.
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``object_names_to_exclude`` (Array[Name]):  [Read-Write] Array of object names that should be excluded from this query
    - ``object_names_to_include`` (Array[Name]):  [Read-Write] Array of object names that should be included in this query
    - ``on_disk_objects_only`` (bool):  [Read-Write] Whether we should only include on-disk objects (ignoring those that exist only in memory)
    """
    def __init__(self, object_names_to_include: Array[Name] = [], object_names_to_exclude: Array[Name] = [], on_disk_objects_only: bool = False) -> None:
        ...
    @property
    def object_names_to_include(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Array of object names that should be included in this query
        """
        ...
    @object_names_to_include.setter
    def object_names_to_include(self, value: Array[Name]) -> None:
        ...
    @property
    def object_names_to_exclude(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Array of object names that should be excluded from this query
        """
        ...
    @object_names_to_exclude.setter
    def object_names_to_exclude(self, value: Array[Name]) -> None:
        ...
    @property
    def on_disk_objects_only(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we should only include on-disk objects (ignoring those that exist only in memory)
        """
        ...
    @on_disk_objects_only.setter
    def on_disk_objects_only(self, value: bool) -> None:
        ...

class ContentBrowserDataPackageFilter(StructBase):
    r"""
    Data used to filter object instances by their package.
    note: This will typically limit your query to returning assets.
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``package_names_to_exclude`` (Array[Name]):  [Read-Write] Array of package names that should be excluded from this query
    - ``package_names_to_include`` (Array[Name]):  [Read-Write] Array of package names that should be included in this query
    - ``package_paths_to_exclude`` (Array[Name]):  [Read-Write] Array of package paths that should be excluded from this query
    - ``package_paths_to_include`` (Array[Name]):  [Read-Write] Array of package paths that should be included in this query
    - ``recursive_package_paths_to_exclude`` (bool):  [Read-Write] Whether we should include exclusive package sub-paths in this query
    - ``recursive_package_paths_to_include`` (bool):  [Read-Write] Whether we should include inclusive package sub-paths in this query
    """
    def __init__(self, package_names_to_include: Array[Name] = [], package_names_to_exclude: Array[Name] = [], package_paths_to_include: Array[Name] = [], package_paths_to_exclude: Array[Name] = [], recursive_package_paths_to_include: bool = False, recursive_package_paths_to_exclude: bool = False) -> None:
        ...
    @property
    def package_names_to_include(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Array of package names that should be included in this query
        """
        ...
    @package_names_to_include.setter
    def package_names_to_include(self, value: Array[Name]) -> None:
        ...
    @property
    def package_names_to_exclude(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Array of package names that should be excluded from this query
        """
        ...
    @package_names_to_exclude.setter
    def package_names_to_exclude(self, value: Array[Name]) -> None:
        ...
    @property
    def package_paths_to_include(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Array of package paths that should be included in this query
        """
        ...
    @package_paths_to_include.setter
    def package_paths_to_include(self, value: Array[Name]) -> None:
        ...
    @property
    def package_paths_to_exclude(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Array of package paths that should be excluded from this query
        """
        ...
    @package_paths_to_exclude.setter
    def package_paths_to_exclude(self, value: Array[Name]) -> None:
        ...
    @property
    def recursive_package_paths_to_include(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we should include inclusive package sub-paths in this query
        """
        ...
    @recursive_package_paths_to_include.setter
    def recursive_package_paths_to_include(self, value: bool) -> None:
        ...
    @property
    def recursive_package_paths_to_exclude(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we should include exclusive package sub-paths in this query
        """
        ...
    @recursive_package_paths_to_exclude.setter
    def recursive_package_paths_to_exclude(self, value: bool) -> None:
        ...

class ContentBrowserDataClassFilter(StructBase):
    r"""
    Data used to filter object instances by their class.
    note: This will typically limit your query to returning assets.
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``class_names_to_exclude`` (Array[str]):  [Read-Write] Array of class names that should be excluded from this query
    - ``class_names_to_include`` (Array[str]):  [Read-Write] Array of class names that should be included in this query
    - ``recursive_class_names_to_exclude`` (bool):  [Read-Write] Whether we should include exclusive sub-classes in this query
    - ``recursive_class_names_to_include`` (bool):  [Read-Write] Whether we should include inclusive sub-classes in this query
    """
    def __init__(self, class_names_to_include: Array[str] = [], class_names_to_exclude: Array[str] = [], recursive_class_names_to_include: bool = False, recursive_class_names_to_exclude: bool = False) -> None:
        ...
    @property
    def class_names_to_include(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Array of class names that should be included in this query
        """
        ...
    @class_names_to_include.setter
    def class_names_to_include(self, value: Array[str]) -> None:
        ...
    @property
    def class_names_to_exclude(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Array of class names that should be excluded from this query
        """
        ...
    @class_names_to_exclude.setter
    def class_names_to_exclude(self, value: Array[str]) -> None:
        ...
    @property
    def recursive_class_names_to_include(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we should include inclusive sub-classes in this query
        """
        ...
    @recursive_class_names_to_include.setter
    def recursive_class_names_to_include(self, value: bool) -> None:
        ...
    @property
    def recursive_class_names_to_exclude(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we should include exclusive sub-classes in this query
        """
        ...
    @recursive_class_names_to_exclude.setter
    def recursive_class_names_to_exclude(self, value: bool) -> None:
        ...

class ContentBrowserDataCollectionFilter(StructBase):
    r"""
    Data used to filter items by their collection.
    note: This will typically limit your query to items that support being inside a collection.
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``include_child_collections`` (bool):  [Read-Write] Whether we should include child collections in this query
    """
    def __init__(self, include_child_collections: bool = False) -> None:
        ...
    @property
    def include_child_collections(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we should include child collections in this query
        """
        ...
    @include_child_collections.setter
    def include_child_collections(self, value: bool) -> None:
        ...

class ContentBrowserItem(StructBase):
    r"""
    Representation of a Content Browser item.
    
    FContentBrowserItem is potentially a composite of multiple internal items (eg, combining equivalent folder items from different data sources),
    and defers back to these internal items to provide its functionality (via the data source that owns each internal item).
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserItem.h
    
    """
    def __init__(self) -> None:
        ...
    def is_folder(self) -> bool:
        r"""
        x.is_folder() -> bool
        Is Folder
        
        Returns:
            bool:
        """
        ...
    def is_file(self) -> bool:
        r"""
        x.is_file() -> bool
        Is File
        
        Returns:
            bool:
        """
        ...
    def get_virtual_path(self) -> Name:
        r"""
        x.get_virtual_path() -> Name
        Get Virtual Path
        
        Returns:
            Name:
        """
        ...
    def get_display_name(self) -> Text:
        r"""
        x.get_display_name() -> Text
        Get Display Name
        
        Returns:
            Text:
        """
        ...

class ContentBrowserItemPath(StructBase):
    r"""
    Hold multiple versions of a path as FNames
    
    Path conversion each time Set is called
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserItemPath.h
    
    """
    def __init__(self, path: Name = "None", path_type: ContentBrowserPathType = ContentBrowserPathType.NONE) -> None:
        ...
    def set_path(self, path: Name, path_type: ContentBrowserPathType) -> None:
        r"""
        x.set_path(path, path_type) -> None
        Set the path being stored
        
        Args:
            path (Name): 
            path_type (ContentBrowserPathType):
        """
        ...
    def get_virtual_path(self) -> Name:
        r"""
        x.get_virtual_path() -> Name
        Returns virtual path as FName (eg, "/All/Plugins/PluginA/MyFile").
        
        Returns:
            Name:
        """
        ...
    def get_internal_path(self) -> Name:
        r"""
        x.get_internal_path() -> Name
        Returns internal path if there is one (eg,. "/PluginA/MyFile").
        
        Returns:
            Name:
        """
        ...

class InterchangeFilePickerParameters(StructBase):
    r"""
    Interchange File Picker Parameters
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangeFilePickerBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_multiple_files`` (bool):  [Read-Write] If true, the user will be able to select multiple files.
    - ``default_path`` (str):  [Read-Write] Set the default open path that the dialog will show to the user.
    - ``title`` (Text):  [Read-Write] If not empty, this will override the default title.
    """
    def __init__(self) -> None:
        ...

class InterchangeStackInfo(StructBase):
    r"""
    Interchange Stack Info
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangePipelineConfigurationBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``pipelines`` (Array[InterchangePipelineBase]):  [Read-Write]
    - ``stack_name`` (Name):  [Read-Write]
    """
    def __init__(self, stack_name: Name = "None", pipelines: Array[InterchangePipelineBase] = []) -> None:
        ...
    @property
    def stack_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @stack_name.setter
    def stack_name(self, value: Name) -> None:
        ...
    @property
    def pipelines(self) -> Array[InterchangePipelineBase]:
        r"""
        (Array[InterchangePipelineBase]):  [Read-Write]
        """
        ...
    @pipelines.setter
    def pipelines(self, value: Array[InterchangePipelineBase]) -> None:
        ...

class ImportAssetParameters(StructBase):
    r"""
    Import Asset Parameters
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangeManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``destination_name`` (str):  [Read-Write] Optional custom name for the import.
    - ``follow_redirectors`` (bool):  [Read-Write] Tell Interchange to follow redirectors when determining the location an asset will be imported.
    - ``import_level`` (Level):  [Read-Write] Level to import into when doing a scene import.
    - ``is_automated`` (bool):  [Read-Write] Tell Interchange that import is automated and it shouldn't present a modal window.
    - ``on_asset_done`` (OnObjectImportDoneDynamic):  [Read-Write] Delegates used to track the imported objects. // This is called each time an asset is imported or reimported from the import call.
    - ``on_assets_import_done`` (OnImportDoneDynamic):  [Read-Write] This is called when all the assets were imported from the source data.
    - ``on_scene_import_done`` (OnImportDoneDynamic):  [Read-Write] This is called when all the scene objects were imported from the source data.
    - ``on_scene_object_done`` (OnObjectImportDoneDynamic):  [Read-Write] This is called each time an object in the scene is imported or reimported from the import call.
    - ``override_pipelines`` (Array[SoftObjectPath]):  [Read-Write] Adding overrides tells Interchange to use the specific custom set of pipelines instead of letting the user or the system choose.
    - ``reimport_asset`` (Object):  [Read-Write] If the import is a reimport for a specific asset, set the asset to reimport here.
    - ``reimport_source_index`` (int32):  [Read-Write] If we are doing a reimport, set the source index here. Some assets have more then one source file that each contains part of the asset content.
    - ``replace_existing`` (bool):  [Read-Write] Determies whether to overwrite existing assets.
    """
    def __init__(self, reimport_asset: Object = None, reimport_source_index: int = 0, is_automated: bool = False, follow_redirectors: bool = False, override_pipelines: Array[SoftObjectPath] = [], import_level: Level = None, destination_name: str = "", replace_existing: bool = False, on_asset_done: OnObjectImportDoneDynamic = OnObjectImportDoneDynamic(), on_assets_import_done: OnImportDoneDynamic = OnImportDoneDynamic(), on_scene_object_done: OnObjectImportDoneDynamic = OnObjectImportDoneDynamic(), on_scene_import_done: OnImportDoneDynamic = OnImportDoneDynamic()) -> None:
        ...
    @property
    def reimport_asset(self) -> Object:
        r"""
        (Object):  [Read-Write] If the import is a reimport for a specific asset, set the asset to reimport here.
        """
        ...
    @reimport_asset.setter
    def reimport_asset(self, value: Object) -> None:
        ...
    @property
    def reimport_source_index(self) -> int:
        r"""
        (int32):  [Read-Write] If we are doing a reimport, set the source index here. Some assets have more then one source file that each contains part of the asset content.
        """
        ...
    @reimport_source_index.setter
    def reimport_source_index(self, value: int) -> None:
        ...
    @property
    def is_automated(self) -> bool:
        r"""
        (bool):  [Read-Write] Tell Interchange that import is automated and it shouldn't present a modal window.
        """
        ...
    @is_automated.setter
    def is_automated(self, value: bool) -> None:
        ...
    @property
    def follow_redirectors(self) -> bool:
        r"""
        (bool):  [Read-Write] Tell Interchange to follow redirectors when determining the location an asset will be imported.
        """
        ...
    @follow_redirectors.setter
    def follow_redirectors(self, value: bool) -> None:
        ...
    @property
    def override_pipelines(self) -> Array[SoftObjectPath]:
        r"""
        (Array[SoftObjectPath]):  [Read-Write] Adding overrides tells Interchange to use the specific custom set of pipelines instead of letting the user or the system choose.
        """
        ...
    @override_pipelines.setter
    def override_pipelines(self, value: Array[SoftObjectPath]) -> None:
        ...
    @property
    def import_level(self) -> Level:
        r"""
        (Level):  [Read-Write] Level to import into when doing a scene import.
        """
        ...
    @import_level.setter
    def import_level(self, value: Level) -> None:
        ...
    @property
    def destination_name(self) -> str:
        r"""
        (str):  [Read-Write] Optional custom name for the import.
        """
        ...
    @destination_name.setter
    def destination_name(self, value: str) -> None:
        ...
    @property
    def replace_existing(self) -> bool:
        r"""
        (bool):  [Read-Write] Determies whether to overwrite existing assets.
        """
        ...
    @replace_existing.setter
    def replace_existing(self, value: bool) -> None:
        ...
    @property
    def on_asset_done(self) -> OnObjectImportDoneDynamic:
        r"""
        (OnObjectImportDoneDynamic):  [Read-Write] Delegates used to track the imported objects. // This is called each time an asset is imported or reimported from the import call.
        """
        ...
    @on_asset_done.setter
    def on_asset_done(self, value: OnObjectImportDoneDynamic) -> None:
        ...
    @property
    def on_assets_import_done(self) -> OnImportDoneDynamic:
        r"""
        (OnImportDoneDynamic):  [Read-Write] This is called when all the assets were imported from the source data.
        """
        ...
    @on_assets_import_done.setter
    def on_assets_import_done(self, value: OnImportDoneDynamic) -> None:
        ...
    @property
    def on_scene_object_done(self) -> OnObjectImportDoneDynamic:
        r"""
        (OnObjectImportDoneDynamic):  [Read-Write] This is called each time an object in the scene is imported or reimported from the import call.
        """
        ...
    @on_scene_object_done.setter
    def on_scene_object_done(self, value: OnObjectImportDoneDynamic) -> None:
        ...
    @property
    def on_scene_import_done(self) -> OnImportDoneDynamic:
        r"""
        (OnImportDoneDynamic):  [Read-Write] This is called when all the scene objects were imported from the source data.
        """
        ...
    @on_scene_import_done.setter
    def on_scene_import_done(self, value: OnImportDoneDynamic) -> None:
        ...

class RevisionInfo(StructBase):
    r"""
    Revision information for a single revision of a file in source control
    
    **C++ Source:**
    
    - **Module**: AssetDefinition
    - **File**: AssetDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``changelist`` (int32):  [Read-Write]
    - ``date`` (DateTime):  [Read-Write]
    - ``revision`` (str):  [Read-Write]
    """
    def __init__(self, revision: str = "", changelist: int = 0, date: DateTime = []) -> None:
        ...
    @property
    def revision(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @revision.setter
    def revision(self, value: str) -> None:
        ...
    @property
    def changelist(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @changelist.setter
    def changelist(self, value: int) -> None:
        ...
    @property
    def date(self) -> DateTime:
        r"""
        (DateTime):  [Read-Write]
        """
        ...
    @date.setter
    def date(self, value: DateTime) -> None:
        ...

class MigrationOptions(StructBase):
    r"""
    Migration Options
    
    **C++ Source:**
    
    - **Module**: AssetTools
    - **File**: IAssetTools.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_conflict`` (AssetMigrationConflict):  [Read-Write] What to do when Assets are conflicting on the destination
    - ``ignore_dependencies`` (bool):  [Read-Write] Ignore dependencies of assets, only migrate the given assets. usefull for automation. This will not migrate the actors of a OFPA (one file per actor) level
    - ``orphan_folder`` (str):  [Read-Write] Destination for assets that don't have a corresponding content folder. If left empty those assets are not migrated. (Not used by the new migration)
    - ``prompt`` (bool):  [Read-Write] Prompt user for confirmation (always false through scripting)
    """
    def __init__(self, prompt: bool = False, ignore_dependencies: bool = False, asset_conflict: AssetMigrationConflict = AssetMigrationConflict.SKIP, orphan_folder: str = "") -> None:
        ...
    @property
    def prompt(self) -> bool:
        r"""
        (bool):  [Read-Write] Prompt user for confirmation (always false through scripting)
        """
        ...
    @prompt.setter
    def prompt(self, value: bool) -> None:
        ...
    @property
    def ignore_dependencies(self) -> bool:
        r"""
        (bool):  [Read-Write] Ignore dependencies of assets, only migrate the given assets. usefull for automation. This will not migrate the actors of a OFPA (one file per actor) level
        """
        ...
    @ignore_dependencies.setter
    def ignore_dependencies(self, value: bool) -> None:
        ...
    @property
    def asset_conflict(self) -> AssetMigrationConflict:
        r"""
        (AssetMigrationConflict):  [Read-Write] What to do when Assets are conflicting on the destination
        """
        ...
    @asset_conflict.setter
    def asset_conflict(self, value: AssetMigrationConflict) -> None:
        ...
    @property
    def orphan_folder(self) -> str:
        r"""
        (str):  [Read-Write] Destination for assets that don't have a corresponding content folder. If left empty those assets are not migrated. (Not used by the new migration)
        """
        ...
    @orphan_folder.setter
    def orphan_folder(self, value: str) -> None:
        ...

class SourceControlState(StructBase):
    r"""
    Snapshot of source control state of a file
    see: USourceControlHelpers::QueryFileState()
    
    **C++ Source:**
    
    - **Module**: SourceControl
    - **File**: SourceControlHelpers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_add`` (bool):  [Read-Only] Determine if this file can be added to source control (i.e. is part of the directory
      structure currently under source control)
    - ``can_check_in`` (bool):  [Read-Only] Determine if this file can be checked in.
    - ``can_check_out`` (bool):  [Read-Only] Determine if this file can be checked out
    - ``can_delete`` (bool):  [Read-Only] Determine if source control allows this file to be deleted.
    - ``can_edit`` (bool):  [Read-Only] Determine if source control allows this file to be edited
    - ``can_revert`` (bool):  [Read-Only] Determine if this file can be reverted, i.e. discard changes and the file will no longer be checked-out.
    - ``checked_out_other`` (str):  [Read-Only] Get name of other user who this file already checked out or "" if no other user has it checked out
    - ``filename`` (str):  [Read-Only] Get the local filename that this state represents
    - ``is_added`` (bool):  [Read-Only] Determine if this file is marked for add
      note: if already checked in then not considered mid add
    - ``is_checked_out`` (bool):  [Read-Only] Determine if this file is checked out
    - ``is_checked_out_other`` (bool):  [Read-Only] Determine if this file is checked out by someone else
    - ``is_conflicted`` (bool):  [Read-Only] Determine if this file is in a conflicted state
    - ``is_current`` (bool):  [Read-Only] Determine if this file is up-to-date with the version in source control
    - ``is_deleted`` (bool):  [Read-Only] Determine if this file is marked for delete
    - ``is_ignored`` (bool):  [Read-Only] Determine if this file is ignored by source control
    - ``is_modified`` (bool):  [Read-Only] Determine if this file is modified compared to the version in source control.
    - ``is_source_controlled`` (bool):  [Read-Only] Determine if this file is under source control
    - ``is_unknown`` (bool):  [Read-Only] Determine if we know anything about the source control state of this file
    - ``is_valid`` (bool):  [Read-Only] Indicates whether this source control state has valid information (true) or not (false)
    """
    def __init__(self, filename: str = "", is_valid: bool = False, is_unknown: bool = False, can_check_in: bool = False, can_check_out: bool = False, is_checked_out: bool = False, is_current: bool = False, is_source_controlled: bool = False, is_added: bool = False, is_deleted: bool = False, is_ignored: bool = False, can_edit: bool = False, can_delete: bool = False, is_modified: bool = False, can_add: bool = False, is_conflicted: bool = False, can_revert: bool = False, is_checked_out_other: bool = False, checked_out_other: str = "") -> None:
        ...
    @property
    def filename(self) -> str:
        r"""
        (str):  [Read-Only] Get the local filename that this state represents
        """
        ...
    @property
    def is_valid(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates whether this source control state has valid information (true) or not (false)
        """
        ...
    @property
    def is_unknown(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if we know anything about the source control state of this file
        """
        ...
    @property
    def can_check_in(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file can be checked in.
        """
        ...
    @property
    def can_check_out(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file can be checked out
        """
        ...
    @property
    def is_checked_out(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file is checked out
        """
        ...
    @property
    def is_current(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file is up-to-date with the version in source control
        """
        ...
    @property
    def is_source_controlled(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file is under source control
        """
        ...
    @property
    def is_added(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file is marked for add
        note: if already checked in then not considered mid add
        """
        ...
    @property
    def is_deleted(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file is marked for delete
        """
        ...
    @property
    def is_ignored(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file is ignored by source control
        """
        ...
    @property
    def can_edit(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if source control allows this file to be edited
        """
        ...
    @property
    def can_delete(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if source control allows this file to be deleted.
        """
        ...
    @property
    def is_modified(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file is modified compared to the version in source control.
        """
        ...
    @property
    def can_add(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file can be added to source control (i.e. is part of the directory
        structure currently under source control)
        """
        ...
    @property
    def is_conflicted(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file is in a conflicted state
        """
        ...
    @property
    def can_revert(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file can be reverted, i.e. discard changes and the file will no longer be checked-out.
        """
        ...
    @property
    def is_checked_out_other(self) -> bool:
        r"""
        (bool):  [Read-Only] Determine if this file is checked out by someone else
        """
        ...
    @property
    def checked_out_other(self) -> str:
        r"""
        (str):  [Read-Only] Get name of other user who this file already checked out or "" if no other user has it checked out
        """
        ...

class EdGraphPinType(StructBase):
    r"""
    Struct used to define the type of information carried on this pin
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EdGraphPin.h
    
    """
    def __init__(self) -> None:
        ...

class AnimPoseEvaluationOptions(StructBase):
    r"""
    Anim Pose Evaluation Options
    
    **C++ Source:**
    
    - **Module**: AnimationBlueprintLibrary
    - **File**: AnimPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``evaluate_curves`` (bool):  [Read-Write] Whether or not to evaluate Animation Curves
    - ``evaluation_type`` (AnimDataEvalType):  [Read-Write] Type of evaluation which should be used
    - ``extract_root_motion`` (bool):  [Read-Write] Whether or not to extract root motion values
    - ``incorporate_root_motion_into_pose`` (bool):  [Read-Write] Whether or not to force root motion being incorporated into retrieved pose
    - ``optional_skeletal_mesh`` (SkeletalMesh):  [Read-Write] Optional skeletal mesh with proportions to use when evaluating a pose
    - ``retrieve_additive_as_full_pose`` (bool):  [Read-Write] Whether or additive animations should be applied to their base-pose
    - ``should_retarget`` (bool):  [Read-Write] Whether or not to retarget animation during evaluation
    """
    def __init__(self, evaluation_type: AnimDataEvalType = AnimDataEvalType.SOURCE, should_retarget: bool = False, extract_root_motion: bool = False, incorporate_root_motion_into_pose: bool = False, optional_skeletal_mesh: SkeletalMesh = None, retrieve_additive_as_full_pose: bool = False, evaluate_curves: bool = False) -> None:
        ...
    @property
    def evaluation_type(self) -> AnimDataEvalType:
        r"""
        (AnimDataEvalType):  [Read-Write] Type of evaluation which should be used
        """
        ...
    @evaluation_type.setter
    def evaluation_type(self, value: AnimDataEvalType) -> None:
        ...
    @property
    def should_retarget(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to retarget animation during evaluation
        """
        ...
    @should_retarget.setter
    def should_retarget(self, value: bool) -> None:
        ...
    @property
    def extract_root_motion(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to extract root motion values
        """
        ...
    @extract_root_motion.setter
    def extract_root_motion(self, value: bool) -> None:
        ...
    @property
    def incorporate_root_motion_into_pose(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to force root motion being incorporated into retrieved pose
        """
        ...
    @incorporate_root_motion_into_pose.setter
    def incorporate_root_motion_into_pose(self, value: bool) -> None:
        ...
    @property
    def optional_skeletal_mesh(self) -> SkeletalMesh:
        r"""
        (SkeletalMesh):  [Read-Write] Optional skeletal mesh with proportions to use when evaluating a pose
        """
        ...
    @optional_skeletal_mesh.setter
    def optional_skeletal_mesh(self, value: SkeletalMesh) -> None:
        ...
    @property
    def retrieve_additive_as_full_pose(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or additive animations should be applied to their base-pose
        """
        ...
    @retrieve_additive_as_full_pose.setter
    def retrieve_additive_as_full_pose(self, value: bool) -> None:
        ...
    @property
    def evaluate_curves(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to evaluate Animation Curves
        """
        ...
    @evaluate_curves.setter
    def evaluate_curves(self, value: bool) -> None:
        ...

class AnimPose(StructBase):
    r"""
    Script friendly representation of an evaluated animation bone pose
    
    **C++ Source:**
    
    - **Module**: AnimationBlueprintLibrary
    - **File**: AnimPose.h
    
    """
    def __init__(self) -> None:
        ...
    def set_bone_pose(self, transform: Transform, bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> None:
        r"""
        x.set_bone_pose(transform, bone_name, space=AnimPoseSpaces.LOCAL) -> None
        Sets the transform for the provided bone name for a pose
        
        Args:
            transform (Transform): Transform to set the bone to
            bone_name (Name): Name of the bone to set
            space (AnimPoseSpaces): Space in which the transform should be set
        """
        ...
    def is_valid(self) -> bool:
        r"""
        x.is_valid() -> bool
        Returns whether the Anim Pose contains valid data
        
        Returns:
            bool: Result of the validation
        """
        ...
    def get_socket_pose(self, socket_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        x.get_socket_pose(socket_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the transform for the provided socket name from a pose
        
        Args:
            socket_name (Name): Name of the socket to retrieve
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    def get_socket_names(self) -> Array[Name]:
        r"""
        x.get_socket_names() -> Array[Name]
        Returns an array of socket names contained by the pose
        
        Returns:
            Array[Name]: 
        
            sockets (Array[Name]): Array to be populated with the socket names
        """
        ...
    def get_relative_transform(self, from_bone_name: Name, to_bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        x.get_relative_transform(from_bone_name, to_bone_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the relative transform between the two provided bone names
        
        Args:
            from_bone_name (Name): Name of the bone to retrieve the transform relative from
            to_bone_name (Name): Name of the bone to retrieve the transform relative to
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Relative transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    def get_relative_to_ref_pose_transform(self, bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        x.get_relative_to_ref_pose_transform(bone_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the relative transform between reference and animated bone transform
        
        Args:
            bone_name (Name): Name of the bone to retrieve the relative transform for
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Relative transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    def get_ref_pose_relative_transform(self, from_bone_name: Name, to_bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        x.get_ref_pose_relative_transform(from_bone_name, to_bone_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the relative transform for the reference pose between the two provided bone names
        
        Args:
            from_bone_name (Name): Name of the bone to retrieve the transform relative from
            to_bone_name (Name): Name of the bone to retrieve the transform relative to
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Relative transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    def get_ref_bone_pose(self, bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        x.get_ref_bone_pose(bone_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the reference pose transform for the provided bone name
        
        Args:
            bone_name (Name): Name of the bone to retrieve
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    def get_curve_weight(self, curve_name: Name) -> float:
        r"""
        x.get_curve_weight(curve_name) -> float
        Returns the weight of an evaluated curve - if found
        
        Args:
            curve_name (Name): Curve to retrieve the weight value for
        
        Returns:
            float: Curve weight value, if found - 0.f otherwise
        """
        ...
    def get_curve_names(self) -> Array[Name]:
        r"""
        x.get_curve_names() -> Array[Name]
        Returns an array of curve names contained by the pose
        
        Returns:
            Array[Name]: 
        
            curves (Array[Name]): Array to be populated with the curve names
        """
        ...
    def get_bone_pose(self, bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        x.get_bone_pose(bone_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the transform for the provided bone name from a pose
        
        Args:
            bone_name (Name): Name of the bone to retrieve
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    def get_bone_names(self) -> Array[Name]:
        r"""
        x.get_bone_names() -> Array[Name]
        Returns an array of bone names contained by the pose
        
        Returns:
            Array[Name]: 
        
            bones (Array[Name]): Array to be populated with the bone names
        """
        ...
    def evaluate_animation_blueprint_with_input_pose(self, target_skeletal_mesh: SkeletalMesh, animation_blueprint: AnimBlueprint) -> AnimPose:
        r"""
        x.evaluate_animation_blueprint_with_input_pose(target_skeletal_mesh, animation_blueprint) -> AnimPose
        Evaluates an Animation Blueprint instance, using the provided Anim Pose and its Input Pose value, generating a valid Anim Pose using the result. Warning this function may cause performance issues.
        
        Args:
            target_skeletal_mesh (SkeletalMesh): USkeletalMesh object used as the target skeletal mesh, should have same USkeleton as InputPose and Animation Blueprint
            animation_blueprint (AnimBlueprint): Animation Blueprint to generate an AnimInstance with, used to evaluate the output Anim Pose
        
        Returns:
            AnimPose: 
        
            out_pose (AnimPose): Anim pose to hold the data from evaluating the Animation Blueprint instance
        """
        ...

class AnimNode_Base(StructBase):
    r"""
    This is the base of all runtime animation nodes
    
    To create a new animation node:
      Create a struct derived from FAnimNode_Base - this is your runtime node
      Create a class derived from UAnimGraphNode_Base, containing an instance of your runtime node as a member - this is your visual/editor-only node
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNodeBase.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_BlendSpaceGraphBase(AnimNode_Base):
    r"""
    Allows multiple animations to be blended between based on input parameters
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendSpaceGraphBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group). Note that
      this is the name of the group used to sync the output of this node - it will not force
      syncing of animations contained by it. Animations inside this Blend Space have their own
      options for syncing.
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this Blend Space can assume within the group (ignored if GroupName is not set). Note
      that this is the role of the output of this node, not of animations contained by it.
    - ``x`` (float):  [Read-Write] The X coordinate to sample in the blendspace
    - ``y`` (float):  [Read-Write] The Y coordinate to sample in the blendspace
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, group_name: Name = "None", group_role: AnimGroupRole = AnimGroupRole.CAN_BE_LEADER) -> None:
        ...
    @property
    def x(self) -> float:
        r"""
        (float):  [Read-Write] The X coordinate to sample in the blendspace
        """
        ...
    @x.setter
    def x(self, value: float) -> None:
        ...
    @property
    def y(self) -> float:
        r"""
        (float):  [Read-Write] The Y coordinate to sample in the blendspace
        """
        ...
    @y.setter
    def y(self, value: float) -> None:
        ...
    @property
    def group_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group). Note that
        this is the name of the group used to sync the output of this node - it will not force
        syncing of animations contained by it. Animations inside this Blend Space have their own
        options for syncing.
        """
        ...
    @group_name.setter
    def group_name(self, value: Name) -> None:
        ...
    @property
    def group_role(self) -> AnimGroupRole:
        r"""
        (AnimGroupRole):  [Read-Write] The role this Blend Space can assume within the group (ignored if GroupName is not set). Note
        that this is the role of the output of this node, not of animations contained by it.
        """
        ...
    @group_role.setter
    def group_role(self, value: AnimGroupRole) -> None:
        ...

class PoseLinkBase(StructBase):
    r"""
    A pose link to another node
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNodeBase.h
    
    """
    def __init__(self) -> None:
        ...

class PoseLink(PoseLinkBase):
    r"""
    A local-space pose link to another node
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNodeBase.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_BlendSpaceGraph(AnimNode_BlendSpaceGraphBase):
    r"""
    Allows multiple animations to be blended between based on input parameters
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendSpaceGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group). Note that
      this is the name of the group used to sync the output of this node - it will not force
      syncing of animations contained by it. Animations inside this Blend Space have their own
      options for syncing.
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this Blend Space can assume within the group (ignored if GroupName is not set). Note
      that this is the role of the output of this node, not of animations contained by it.
    - ``x`` (float):  [Read-Write] The X coordinate to sample in the blendspace
    - ``y`` (float):  [Read-Write] The Y coordinate to sample in the blendspace
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, group_name: Name = "None", group_role: AnimGroupRole = AnimGroupRole.CAN_BE_LEADER) -> None:
        ...

class AnimNode_Root(AnimNode_Base):
    r"""
    Root node of an animation tree (sink)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_Root.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``group`` (Name):  [Read-Write]
      deprecated: Please, use LayerGroup
    - ``result`` (PoseLink):  [Read-Write]
    """
    def __init__(self, result: PoseLink = []) -> None:
        ...
    @property
    def result(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @result.setter
    def result(self, value: PoseLink) -> None:
        ...
    @property
    def group(self) -> Name:
        r"""
        (Name):  [Read-Write]
        deprecated: Please, use LayerGroup
        """
        ...
    @group.setter
    def group(self, value: Name) -> None:
        ...

class AnimNode_BlendSpaceSampleResult(AnimNode_Root):
    r"""
    Root node of a blend space sample (sink node).
    We dont use AnimNode_Root to let us distinguish these nodes in the property list at link time.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendSpaceSampleResult.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``group`` (Name):  [Read-Write]
      deprecated: Please, use LayerGroup
    - ``result`` (PoseLink):  [Read-Write]
    """
    def __init__(self, result: PoseLink = []) -> None:
        ...

class AnimNode_SkeletalControlBase(AnimNode_Base):
    r"""
    Anim Node Skeletal Control Base
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_SkeletalControlBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000]) -> None:
        ...
    @property
    def component_pose(self) -> ComponentSpacePoseLink:
        r"""
        (ComponentSpacePoseLink):  [Read-Write] Input link
        """
        ...
    @component_pose.setter
    def component_pose(self, value: ComponentSpacePoseLink) -> None:
        ...
    @property
    def lod_threshold(self) -> int:
        r"""
        (int32):  [Read-Write] * Max LOD that this node is allowed to run
        * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
        * when the component LOD becomes 3, it will stop update/evaluate
        * currently transition would be issue and that has to be re-visited
        """
        ...
    @lod_threshold.setter
    def lod_threshold(self, value: int) -> None:
        ...
    @property
    def alpha_input_type(self) -> AnimAlphaInputType:
        r"""
        (AnimAlphaInputType):  [Read-Write]
        """
        ...
    @alpha_input_type.setter
    def alpha_input_type(self, value: AnimAlphaInputType) -> None:
        ...
    @property
    def alpha_bool_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @alpha_bool_enabled.setter
    def alpha_bool_enabled(self, value: bool) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write] Current strength of the skeletal control
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...
    @property
    def alpha_scale_bias(self) -> InputScaleBias:
        r"""
        (InputScaleBias):  [Read-Write]
        """
        ...
    @alpha_scale_bias.setter
    def alpha_scale_bias(self, value: InputScaleBias) -> None:
        ...
    @property
    def alpha_bool_blend(self) -> InputAlphaBoolBlend:
        r"""
        (InputAlphaBoolBlend):  [Read-Write]
        """
        ...
    @alpha_bool_blend.setter
    def alpha_bool_blend(self, value: InputAlphaBoolBlend) -> None:
        ...
    @property
    def alpha_curve_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @alpha_curve_name.setter
    def alpha_curve_name(self, value: Name) -> None:
        ...
    @property
    def alpha_scale_bias_clamp(self) -> InputScaleBiasClamp:
        r"""
        (InputScaleBiasClamp):  [Read-Write]
        """
        ...
    @alpha_scale_bias_clamp.setter
    def alpha_scale_bias_clamp(self, value: InputScaleBiasClamp) -> None:
        ...

class InputScaleBiasClamp(StructBase):
    r"""
    Input modifier with remapping, scaling, biasing, clamping, and interpolation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputScaleBias.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bias`` (float):  [Read-Write]
    - ``clamp_max`` (float):  [Read-Write]
    - ``clamp_min`` (float):  [Read-Write]
    - ``clamp_result`` (bool):  [Read-Write]
    - ``interp_result`` (bool):  [Read-Write]
    - ``interp_speed_decreasing`` (float):  [Read-Write]
    - ``interp_speed_increasing`` (float):  [Read-Write]
    - ``map_range`` (bool):  [Read-Write]
    - ``out_range`` (InputRange):  [Read-Write]
    - ``range`` (InputRange):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    """
    def __init__(self, map_range: bool = False, clamp_result: bool = False, interp_result: bool = False, range: InputRange = [0.000000, 1.000000], out_range: InputRange = [0.000000, 1.000000], scale: float = 0.000000, bias: float = 0.000000, clamp_min: float = 0.000000, clamp_max: float = 0.000000, interp_speed_increasing: float = 0.000000, interp_speed_decreasing: float = 0.000000) -> None:
        ...
    @property
    def map_range(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @map_range.setter
    def map_range(self, value: bool) -> None:
        ...
    @property
    def clamp_result(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @clamp_result.setter
    def clamp_result(self, value: bool) -> None:
        ...
    @property
    def interp_result(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @interp_result.setter
    def interp_result(self, value: bool) -> None:
        ...
    @property
    def range(self) -> InputRange:
        r"""
        (InputRange):  [Read-Write]
        """
        ...
    @range.setter
    def range(self, value: InputRange) -> None:
        ...
    @property
    def out_range(self) -> InputRange:
        r"""
        (InputRange):  [Read-Write]
        """
        ...
    @out_range.setter
    def out_range(self, value: InputRange) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bias(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @bias.setter
    def bias(self, value: float) -> None:
        ...
    @property
    def clamp_min(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_min.setter
    def clamp_min(self, value: float) -> None:
        ...
    @property
    def clamp_max(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_max.setter
    def clamp_max(self, value: float) -> None:
        ...
    @property
    def interp_speed_increasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_increasing.setter
    def interp_speed_increasing(self, value: float) -> None:
        ...
    @property
    def interp_speed_decreasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_decreasing.setter
    def interp_speed_decreasing(self, value: float) -> None:
        ...

class InputRange(StructBase):
    r"""
    Input Range
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputScaleBias.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max`` (float):  [Read-Write]
    - ``min`` (float):  [Read-Write]
    """
    def __init__(self, min: float = 0.000000, max: float = 0.000000) -> None:
        ...
    @property
    def min(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @min.setter
    def min(self, value: float) -> None:
        ...
    @property
    def max(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @max.setter
    def max(self, value: float) -> None:
        ...

class InputAlphaBoolBlend(StructBase):
    r"""
    Input Alpha Bool Blend
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputScaleBias.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_in_time`` (float):  [Read-Write]
    - ``blend_option`` (AlphaBlendOption):  [Read-Write]
    - ``blend_out_time`` (float):  [Read-Write]
    - ``custom_curve`` (CurveFloat):  [Read-Write]
    """
    def __init__(self, blend_in_time: float = 0.000000, blend_out_time: float = 0.000000, blend_option: AlphaBlendOption = AlphaBlendOption.LINEAR, custom_curve: CurveFloat = None) -> None:
        ...
    @property
    def blend_in_time(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @blend_in_time.setter
    def blend_in_time(self, value: float) -> None:
        ...
    @property
    def blend_out_time(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @blend_out_time.setter
    def blend_out_time(self, value: float) -> None:
        ...
    @property
    def blend_option(self) -> AlphaBlendOption:
        r"""
        (AlphaBlendOption):  [Read-Write]
        """
        ...
    @blend_option.setter
    def blend_option(self, value: AlphaBlendOption) -> None:
        ...
    @property
    def custom_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write]
        """
        ...
    @custom_curve.setter
    def custom_curve(self, value: CurveFloat) -> None:
        ...

class AlphaBlend(StructBase):
    r"""
    Alpha Blend class that supports different blend options as well as custom curves
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AlphaBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_option`` (AlphaBlendOption):  [Read-Write] Type of blending used (Linear, Cubic, etc.)
    - ``blend_time`` (float):  [Read-Write] Blend Time
    - ``custom_curve`` (CurveFloat):  [Read-Write] If you're using Custom BlendOption, you can specify curve
    """
    def __init__(self) -> None:
        ...

class InputScaleBias(StructBase):
    r"""
    Input modifier with scaling and biasing
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputScaleBias.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bias`` (float):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    """
    def __init__(self, scale: float = 0.000000, bias: float = 0.000000) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bias(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @bias.setter
    def bias(self, value: float) -> None:
        ...

class ComponentSpacePoseLink(PoseLinkBase):
    r"""
    A component-space pose link to another node
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNodeBase.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_ModifyBone(AnimNode_SkeletalControlBase):
    r"""
    Simple controller that replaces or adds to the translation/rotation of a single bone.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_ModifyBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``bone_to_modify`` (BoneReference):  [Read-Write] Name of bone to control. This is the main bone chain to modify from. *
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``rotation`` (Rotator):  [Read-Write] New rotation of bone to apply.
    - ``rotation_mode`` (BoneModificationMode):  [Read-Write] Whether and how to modify the translation of this bone.
    - ``rotation_space`` (BoneControlSpace):  [Read-Write] Reference frame to apply Rotation in.
    - ``scale`` (Vector):  [Read-Write] New Scale of bone to apply. This is only worldspace.
    - ``scale_mode`` (BoneModificationMode):  [Read-Write] Whether and how to modify the translation of this bone.
    - ``scale_space`` (BoneControlSpace):  [Read-Write] Reference frame to apply Scale in.
    - ``translation`` (Vector):  [Read-Write] New translation of bone to apply.
    - ``translation_mode`` (BoneModificationMode):  [Read-Write] Whether and how to modify the translation of this bone.
    - ``translation_space`` (BoneControlSpace):  [Read-Write] Reference frame to apply Translation in.
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], translation: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], scale: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def translation(self) -> Vector:
        r"""
        (Vector):  [Read-Write] New translation of bone to apply.
        """
        ...
    @translation.setter
    def translation(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] New rotation of bone to apply.
        """
        ...
    @rotation.setter
    def rotation(self, value: Rotator) -> None:
        ...
    @property
    def scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write] New Scale of bone to apply. This is only worldspace.
        """
        ...
    @scale.setter
    def scale(self, value: Vector) -> None:
        ...

class AnimNodeReference(StructBase):
    r"""
    A reference to an anim node. Does not persist, only valid for the call in which it was retrieved.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNodeReference.h
    
    """
    def __init__(self) -> None:
        ...

class RigidBodyAnimNodeReference(AnimNodeReference):
    r"""
    Rigid Body Anim Node Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RigidBody_Library.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_RotationMultiplier(AnimNode_SkeletalControlBase):
    r"""
    Simple controller that multiplies scalar value to the translation/rotation/scale of a single bone.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RotationMultiplier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``is_additive`` (bool):  [Read-Write]
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``multiplier`` (float):  [Read-Write] To make these to be easily pin-hookable, I'm not making it struct, but each variable
      0.f is invalid, and default
    - ``rotation_axis_to_refer`` (BoneAxis):  [Read-Write]
    - ``source_bone`` (BoneReference):  [Read-Write] Source to get transform from
    - ``target_bone`` (BoneReference):  [Read-Write] Name of bone to control. This is the main bone chain to modify from.
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], multiplier: float = 0.000000) -> None:
        ...
    @property
    def multiplier(self) -> float:
        r"""
        (float):  [Read-Write] To make these to be easily pin-hookable, I'm not making it struct, but each variable
        0.f is invalid, and default
        """
        ...
    @multiplier.setter
    def multiplier(self, value: float) -> None:
        ...

class BlendSpaceReference(AnimNodeReference):
    r"""
    Blend Space Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: BlendSpaceLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class RotationRetargetingInfo(StructBase):
    r"""
    The FRotationRetargetingInfo is used to provide all of the
    settings required to perform rotational retargeting on a single
    transform.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: CommonAnimationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clamp`` (bool):  [Read-Write] If set to true the value for the easing will be clamped between 0.0 and 1.0
    - ``custom_curve`` (RuntimeFloatCurve):  [Read-Write] Custom curve mapping to apply if bApplyCustomCurve is true
    - ``easing_type`` (EasingFuncType):  [Read-Write] The easing to use - pick linear if you don't want to apply any easing
    - ``easing_weight`` (float):  [Read-Write] The amount of easing to apply (value should be 0.0 to 1.0)
    - ``enabled`` (bool):  [Read-Write] Set to true this enables retargeting
    - ``flip_easing`` (bool):  [Read-Write] If set to true the interpolation value for the easing will be flipped (1.0 - Value)
    - ``rotation_component`` (RotationComponent):  [Read-Write] The rotation component to perform retargeting with
    - ``source`` (Transform):  [Read-Write] The source transform of the frame of reference. The rotation is made relative to this space
    - ``source_maximum`` (float):  [Read-Write] The maximum value of the source angle in degrees
    - ``source_minimum`` (float):  [Read-Write] The minimum value of the source angle in degrees
    - ``target`` (Transform):  [Read-Write] The target transform to project the rotation. In most cases this is the same as Source
    - ``target_maximum`` (float):  [Read-Write] The target value of the target angle in degrees (can be the same as SourceMaximum)
    - ``target_minimum`` (float):  [Read-Write] The minimum value of the target angle in degrees (can be the same as SourceMinimum)
    - ``twist_axis`` (Vector):  [Read-Write] In case the rotation component is SwingAngle or TwistAngle this vector is used as the twist axis
    - ``use_absolute_angle`` (bool):  [Read-Write] If set to true the angle will be always positive, thus resulting in mirrored rotation both ways
    """
    def __init__(self) -> None:
        ...

class RuntimeFloatCurve(StructBase):
    r"""
    Runtime Float Curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``external_curve`` (CurveFloat):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class RichCurveKey(StructBase):
    r"""
    One key in a rich, editable float curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RichCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``time`` (float):  [Read-Write] Time at this key
    - ``value`` (float):  [Read-Write] Value at this key
    """
    def __init__(self, time: float = 0.000000, value: float = 0.000000) -> None:
        ...
    @property
    def time(self) -> float:
        r"""
        (float):  [Read-Write] Time at this key
        """
        ...
    @time.setter
    def time(self, value: float) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write] Value at this key
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class PositionHistory(StructBase):
    r"""
    An easing type defining how to ease float values.
    The FPositionHistory is a container to record position changes
    over time. This is used to calculate velocity of a bone, for example.
    The FPositionArray also tracks the last index used to allow for
    reuse of entries (instead of appending to the array all the time).
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: KismetAnimationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``positions`` (Array[Vector]):  [Read-Write] The recorded positions
    - ``range`` (float):  [Read-Write] The range for this particular history
    """
    def __init__(self) -> None:
        ...

class AnimationStateResultReference(AnimNodeReference):
    r"""
    Animation State Result Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimationStateMachineLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class AnimationStateMachineReference(AnimNodeReference):
    r"""
    Animation State Machine Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimationStateMachineLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_AssetPlayerRelevancyBase(AnimNode_Base):
    r"""
    Base class for any asset playing anim node
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_RelevantAssetPlayerBase.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_AssetPlayerBase(AnimNode_AssetPlayerRelevancyBase):
    r"""
    Base class for any asset playing anim node
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_AssetPlayerBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000) -> None:
        ...
    @property
    def blend_weight(self) -> float:
        r"""
        (float):  [Read-Write] Last encountered blendweight for this node
        """
        ...
    @blend_weight.setter
    def blend_weight(self, value: float) -> None:
        ...
    @property
    def internal_time_accumulator(self) -> float:
        r"""
        (float):  [Read-Write] Accumulated time used to reference the asset in this node
        """
        ...
    @internal_time_accumulator.setter
    def internal_time_accumulator(self, value: float) -> None:
        ...

class AnimNode_BlendSpacePlayerBase(AnimNode_AssetPlayerBase):
    r"""
    
    TODO:: Comment
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendSpacePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000) -> None:
        ...

class AnimNode_BlendSpacePlayer(AnimNode_BlendSpacePlayerBase):
    r"""
    
    TODO:: Comment
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendSpacePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_space`` (BlendSpace):  [Read-Write] The blendspace asset to play
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group). Note that
      this is the name of the group used to sync the output of this node - it will not force
      syncing of animations contained by it.
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this node can assume within the group (ignored if GroupName is not set). Note
      that this is the role of the output of this node, not of animations contained by it.
    - ``ignore_for_relevancy_test`` (bool):  [Read-Write] If true, "Relevant anim" nodes that look for the highest weighted animation in a state will ignore this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``loop`` (bool):  [Read-Write] Should the animation loop back to the start when it reaches the end?
    - ``method`` (AnimSyncMethod):  [Read-Write] How this node will synchronize with other animations. Note that this determines how the output
      of this node is used for synchronization, not of animations contained by it.
    - ``play_rate`` (float):  [Read-Write] The play rate multiplier. Can be negative, which will cause the animation to play in reverse.
    - ``reset_play_time_when_blend_space_changes`` (bool):  [Read-Write] Whether we should reset the current play time when the blend space changes
    - ``start_position`` (float):  [Read-Write] The start position in [0, 1] to use when initializing. When looping, play will still jump back to the beginning when reaching the end.
    - ``x`` (float):  [Read-Write] The X coordinate to sample in the blendspace
    - ``y`` (float):  [Read-Write] The Y coordinate to sample in the blendspace
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000) -> None:
        ...

class AnimNode_BlendSpace(AnimNode_BlendSpacePlayer):
    r"""
    deprecated: 'AnimNode_BlendSpace' was renamed to 'AnimNode_BlendSpacePlayer'.
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000) -> None:
        ...

class AnimNode_AimOffsetLookAt(AnimNode_BlendSpacePlayer):
    r"""
    This node uses a source transform of a socket on the skeletal mesh to automatically calculate
    Yaw and Pitch directions for a referenced aim offset given a point in the world to look at.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_AimOffsetLookAt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Amount of this node to blend into the output pose
    - ``base_pose`` (PoseLink):  [Read-Write]
    - ``blend_space`` (BlendSpace):  [Read-Write] The blendspace asset to play
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group). Note that
      this is the name of the group used to sync the output of this node - it will not force
      syncing of animations contained by it.
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this node can assume within the group (ignored if GroupName is not set). Note
      that this is the role of the output of this node, not of animations contained by it.
    - ``ignore_for_relevancy_test`` (bool):  [Read-Write] If true, "Relevant anim" nodes that look for the highest weighted animation in a state will ignore this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``look_at_location`` (Vector):  [Read-Write] Location, in world space to look at
    - ``loop`` (bool):  [Read-Write] Should the animation loop back to the start when it reaches the end?
    - ``method`` (AnimSyncMethod):  [Read-Write] How this node will synchronize with other animations. Note that this determines how the output
      of this node is used for synchronization, not of animations contained by it.
    - ``pivot_socket_name`` (Name):  [Read-Write] Socket or bone to treat as the look at pivot (optional). This will overwrite the translation of the
      source socket transform improve the lookat direction, especially when the target is close
      to the character
    - ``play_rate`` (float):  [Read-Write] The play rate multiplier. Can be negative, which will cause the animation to play in reverse.
    - ``reset_play_time_when_blend_space_changes`` (bool):  [Read-Write] Whether we should reset the current play time when the blend space changes
    - ``socket_axis`` (Vector):  [Read-Write] Direction in the socket transform to consider the 'forward' or look at axis
    - ``source_socket_name`` (Name):  [Read-Write] Socket or bone to treat as the look at source. This will then be pointed at LookAtLocation
    - ``start_position`` (float):  [Read-Write] The start position in [0, 1] to use when initializing. When looping, play will still jump back to the beginning when reaching the end.
    - ``x`` (float):  [Read-Write] The X coordinate to sample in the blendspace
    - ``y`` (float):  [Read-Write] The Y coordinate to sample in the blendspace
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000, base_pose: PoseLink = [], lod_threshold: int = 0, source_socket_name: Name = "None", pivot_socket_name: Name = "None", look_at_location: Vector = [0.000000, 0.000000, 0.000000], socket_axis: Vector = [0.000000, 0.000000, 0.000000], alpha: float = 0.000000) -> None:
        ...
    @property
    def base_pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @base_pose.setter
    def base_pose(self, value: PoseLink) -> None:
        ...
    @property
    def lod_threshold(self) -> int:
        r"""
        (int32):  [Read-Write] * Max LOD that this node is allowed to run
        * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
        * when the component LOD becomes 3, it will stop update/evaluate
        * currently transition would be issue and that has to be re-visited
        """
        ...
    @lod_threshold.setter
    def lod_threshold(self, value: int) -> None:
        ...
    @property
    def source_socket_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Socket or bone to treat as the look at source. This will then be pointed at LookAtLocation
        """
        ...
    @source_socket_name.setter
    def source_socket_name(self, value: Name) -> None:
        ...
    @property
    def pivot_socket_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Socket or bone to treat as the look at pivot (optional). This will overwrite the translation of the
        source socket transform improve the lookat direction, especially when the target is close
        to the character
        """
        ...
    @pivot_socket_name.setter
    def pivot_socket_name(self, value: Name) -> None:
        ...
    @property
    def look_at_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Location, in world space to look at
        """
        ...
    @look_at_location.setter
    def look_at_location(self, value: Vector) -> None:
        ...
    @property
    def socket_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Direction in the socket transform to consider the 'forward' or look at axis
        """
        ...
    @socket_axis.setter
    def socket_axis(self, value: Vector) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write] Amount of this node to blend into the output pose
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...

class AnimNode_ApplyAdditive(AnimNode_Base):
    r"""
    Anim Node Apply Additive
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_ApplyAdditive.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additive`` (PoseLink):  [Read-Write]
    - ``alpha`` (float):  [Read-Write]
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``base`` (PoseLink):  [Read-Write]
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    """
    def __init__(self, base: PoseLink = [], additive: PoseLink = [], alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], lod_threshold: int = 0, alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False) -> None:
        ...
    @property
    def base(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @base.setter
    def base(self, value: PoseLink) -> None:
        ...
    @property
    def additive(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @additive.setter
    def additive(self, value: PoseLink) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...
    @property
    def alpha_scale_bias(self) -> InputScaleBias:
        r"""
        (InputScaleBias):  [Read-Write]
        """
        ...
    @alpha_scale_bias.setter
    def alpha_scale_bias(self, value: InputScaleBias) -> None:
        ...
    @property
    def lod_threshold(self) -> int:
        r"""
        (int32):  [Read-Write] * Max LOD that this node is allowed to run
        * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
        * when the component LOD becomes 3, it will stop update/evaluate
        * currently transition would be issue and that has to be re-visited
        """
        ...
    @lod_threshold.setter
    def lod_threshold(self, value: int) -> None:
        ...
    @property
    def alpha_bool_blend(self) -> InputAlphaBoolBlend:
        r"""
        (InputAlphaBoolBlend):  [Read-Write]
        """
        ...
    @alpha_bool_blend.setter
    def alpha_bool_blend(self, value: InputAlphaBoolBlend) -> None:
        ...
    @property
    def alpha_curve_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @alpha_curve_name.setter
    def alpha_curve_name(self, value: Name) -> None:
        ...
    @property
    def alpha_scale_bias_clamp(self) -> InputScaleBiasClamp:
        r"""
        (InputScaleBiasClamp):  [Read-Write]
        """
        ...
    @alpha_scale_bias_clamp.setter
    def alpha_scale_bias_clamp(self, value: InputScaleBiasClamp) -> None:
        ...
    @property
    def alpha_input_type(self) -> AnimAlphaInputType:
        r"""
        (AnimAlphaInputType):  [Read-Write]
        """
        ...
    @alpha_input_type.setter
    def alpha_input_type(self, value: AnimAlphaInputType) -> None:
        ...
    @property
    def alpha_bool_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @alpha_bool_enabled.setter
    def alpha_bool_enabled(self, value: bool) -> None:
        ...

class BlendBoneByChannelEntry(StructBase):
    r"""
    Blend Bone by Channel Entry
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendBoneByChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_rotation`` (bool):  [Read-Write] Copy Rotation from Source to Target
    - ``blend_scale`` (bool):  [Read-Write] Copy Scale from Source to Target
    - ``blend_translation`` (bool):  [Read-Write] Copy Translation from Source to Target
    - ``source_bone`` (BoneReference):  [Read-Write] Bone to take Transform from
    - ``target_bone`` (BoneReference):  [Read-Write] Bone to apply Transform to
    """
    def __init__(self) -> None:
        ...

class AnimNode_BlendBoneByChannel(AnimNode_Base):
    r"""
    Anim Node Blend Bone by Channel
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendBoneByChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (PoseLink):  [Read-Write]
    - ``alpha`` (float):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``b`` (PoseLink):  [Read-Write]
    - ``bone_definitions`` (Array[BlendBoneByChannelEntry]):  [Read-Write]
    - ``transforms_space`` (BoneControlSpace):  [Read-Write] Space to convert transforms into prior to copying channels
    """
    def __init__(self, a: PoseLink = [], b: PoseLink = [], alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000]) -> None:
        ...
    @property
    def a(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: PoseLink) -> None:
        ...
    @property
    def b(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: PoseLink) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...
    @property
    def alpha_scale_bias(self) -> InputScaleBias:
        r"""
        (InputScaleBias):  [Read-Write]
        """
        ...
    @alpha_scale_bias.setter
    def alpha_scale_bias(self, value: InputScaleBias) -> None:
        ...

class AnimNode_BlendListBase(AnimNode_Base):
    r"""
    Blend list node; has many children
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendListBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_pose`` (Array[PoseLink]):  [Read-Write]
    - ``blend_profile`` (BlendProfile):  [Read-Write]
    - ``blend_time`` (Array[float]):  [Read-Write]
    - ``blend_type`` (AlphaBlendOption):  [Read-Write]
    - ``custom_blend_curve`` (CurveFloat):  [Read-Write]
    - ``reset_child_on_activation`` (bool):  [Read-Write] This reinitializes the re-activated child if the child's weight was zero.
    - ``transition_type`` (BlendListTransitionType):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AnimNode_BlendListByBool(AnimNode_BlendListBase):
    r"""
    This node is effectively a 'branch', picking one of two input poses based on an input Boolean value
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendListByBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active_value`` (bool):  [Read-Write] Which input should be connected to the output?
    - ``blend_pose`` (Array[PoseLink]):  [Read-Write]
    - ``blend_profile`` (BlendProfile):  [Read-Write]
    - ``blend_time`` (Array[float]):  [Read-Write]
    - ``blend_type`` (AlphaBlendOption):  [Read-Write]
    - ``custom_blend_curve`` (CurveFloat):  [Read-Write]
    - ``reset_child_on_activation`` (bool):  [Read-Write] This reinitializes the re-activated child if the child's weight was zero.
    - ``transition_type`` (BlendListTransitionType):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AnimNode_BlendListByEnum(AnimNode_BlendListBase):
    r"""
    Blend List by Enum, it changes based on enum input that enters
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendListByEnum.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active_enum_value`` (uint8):  [Read-Write] The currently selected pose (as an enum value)
    - ``blend_pose`` (Array[PoseLink]):  [Read-Write]
    - ``blend_profile`` (BlendProfile):  [Read-Write]
    - ``blend_time`` (Array[float]):  [Read-Write]
    - ``blend_type`` (AlphaBlendOption):  [Read-Write]
    - ``custom_blend_curve`` (CurveFloat):  [Read-Write]
    - ``reset_child_on_activation`` (bool):  [Read-Write] This reinitializes the re-activated child if the child's weight was zero.
    - ``transition_type`` (BlendListTransitionType):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AnimNode_BlendListByInt(AnimNode_BlendListBase):
    r"""
    Blend list node; has many children
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendListByInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active_child_index`` (int32):  [Read-Write]
    - ``blend_pose`` (Array[PoseLink]):  [Read-Write]
    - ``blend_profile`` (BlendProfile):  [Read-Write]
    - ``blend_time`` (Array[float]):  [Read-Write]
    - ``blend_type`` (AlphaBlendOption):  [Read-Write]
    - ``custom_blend_curve`` (CurveFloat):  [Read-Write]
    - ``reset_child_on_activation`` (bool):  [Read-Write] This reinitializes the re-activated child if the child's weight was zero.
    - ``transition_type`` (BlendListTransitionType):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AnimNode_BlendSpaceEvaluator(AnimNode_BlendSpacePlayer):
    r"""
    Evaluates a BlendSpace at a specific using a specific time input rather than advancing time
    internally. Typically the playback position of the animation for this node will represent
    something other than time, like jump height. Note that events output from the sequences playing
    and being blended together should not be used. In addition, synchronization of animations
    will potentially be discontinuous if the blend weights are updated, as the leader/follower changes.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendSpaceEvaluator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_space`` (BlendSpace):  [Read-Write] The blendspace asset to play
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group). Note that
      this is the name of the group used to sync the output of this node - it will not force
      syncing of animations contained by it.
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this node can assume within the group (ignored if GroupName is not set). Note
      that this is the role of the output of this node, not of animations contained by it.
    - ``ignore_for_relevancy_test`` (bool):  [Read-Write] If true, "Relevant anim" nodes that look for the highest weighted animation in a state will ignore this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``loop`` (bool):  [Read-Write] Should the animation loop back to the start when it reaches the end?
    - ``method`` (AnimSyncMethod):  [Read-Write] How this node will synchronize with other animations. Note that this determines how the output
      of this node is used for synchronization, not of animations contained by it.
    - ``normalized_time`` (float):  [Read-Write] Normalized time between [0,1]. The actual length of a blendspace is dynamic based on the coordinate,
      so it is exposed as a normalized value. Note that treating this as a "time" value that increases (and wraps)
      will not result in the same output as you would get from using a BlendSpace player. The output events
      may not be as expected, and synchronization will sometimes be discontinuous if the leader/follower
      animations change as a result of changing the blend weights (even if that is done smoothly).
    - ``play_rate`` (float):  [Read-Write] The play rate multiplier. Can be negative, which will cause the animation to play in reverse.
    - ``reset_play_time_when_blend_space_changes`` (bool):  [Read-Write] Whether we should reset the current play time when the blend space changes
    - ``start_position`` (float):  [Read-Write] The start position in [0, 1] to use when initializing. When looping, play will still jump back to the beginning when reaching the end.
    - ``teleport_to_normalized_time`` (bool):  [Read-Write] If true, teleport to normalized time, does NOT advance time (does not trigger notifies, does not
      extract Root Motion, etc.). If false, will advance time (will trigger notifies, extract root motion
      if applicable, etc).
    - ``x`` (float):  [Read-Write] The X coordinate to sample in the blendspace
    - ``y`` (float):  [Read-Write] The Y coordinate to sample in the blendspace
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000, normalized_time: float = 0.000000) -> None:
        ...
    @property
    def normalized_time(self) -> float:
        r"""
        (float):  [Read-Write] Normalized time between [0,1]. The actual length of a blendspace is dynamic based on the coordinate,
        so it is exposed as a normalized value. Note that treating this as a "time" value that increases (and wraps)
        will not result in the same output as you would get from using a BlendSpace player. The output events
        may not be as expected, and synchronization will sometimes be discontinuous if the leader/follower
        animations change as a result of changing the blend weights (even if that is done smoothly).
        """
        ...
    @normalized_time.setter
    def normalized_time(self, value: float) -> None:
        ...

class AnimNode_BlendSpacePlayer_Standalone(AnimNode_BlendSpacePlayerBase):
    r"""
    
    TODO:: Comment
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BlendSpacePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_space`` (BlendSpace):  [Read-Write] The blendspace asset to play
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group). Note that
      this is the name of the group used to sync the output of this node - it will not force
      syncing of animations contained by it. Animations inside this Blend Space have their own
      options for syncing.
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this Blend Space can assume within the group (ignored if GroupName is not set). Note
      that this is the role of the output of this node, not of animations contained by it.
    - ``ignore_for_relevancy_test`` (bool):  [Read-Write] If true, "Relevant anim" nodes that look for the highest weighted animation in a state will ignore this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``loop`` (bool):  [Read-Write] Should the animation loop back to the start when it reaches the end?
    - ``method`` (AnimSyncMethod):  [Read-Write] How this asset will synchronize with other assets. Note that this determines how the output
      of this node is used for synchronization, not of animations contained by it.
    - ``play_rate`` (float):  [Read-Write] The play rate multiplier. Can be negative, which will cause the animation to play in reverse.
    - ``reset_play_time_when_blend_space_changes`` (bool):  [Read-Write] Whether we should reset the current play time when the blend space changes
    - ``start_position`` (float):  [Read-Write] The start position in [0, 1] to use when initializing. When looping, play will still jump back to the beginning when reaching the end.
    - ``x`` (float):  [Read-Write] The X coordinate to sample in the blendspace
    - ``y`` (float):  [Read-Write] The Y coordinate to sample in the blendspace
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000) -> None:
        ...

class AnimNode_CallFunction(AnimNode_Base):
    r"""
    Calls specified user-defined events/functions during anim graph execution
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_CallFunction.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``call_site`` (AnimFunctionCallSite):  [Read-Write] When to call the function during the execution of the animation graph
    - ``source`` (PoseLink):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AnimNode_CopyPoseFromMesh(AnimNode_Base):
    r"""
    Simple controller to copy a bone's transform to another one.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_CopyPoseFromMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``copy_curves`` (bool):  [Read-Write] Copy curves also from SouceMeshComponent. This will copy the curves if this instance also contains curve attributes
    - ``copy_custom_attributes`` (bool):  [Read-Write] Copy custom attributes from SouceMeshComponent
    - ``root_bone_to_copy`` (Name):  [Read-Write] If you want to specify copy root, use this - this will ensure copy only below of this joint (inclusively)
    - ``source_mesh_component`` (SkeletalMeshComponent):  [Read-Write] This is used by default if it's valid
    - ``use_attached_parent`` (bool):  [Read-Write] If SourceMeshComponent is not valid, and if this is true, it will look for attahced parent as a source
    - ``use_mesh_pose`` (bool):  [Read-Write] Use root space transform to copy to the target pose. By default, it copies their relative transform (bone space)
    """
    def __init__(self, source_mesh_component: SkeletalMeshComponent = None, use_attached_parent: bool = False, copy_curves: bool = False, copy_custom_attributes: bool = False, use_mesh_pose: bool = False, root_bone_to_copy: Name = "None") -> None:
        ...
    @property
    def source_mesh_component(self) -> SkeletalMeshComponent:
        r"""
        (SkeletalMeshComponent):  [Read-Write] This is used by default if it's valid
        """
        ...
    @source_mesh_component.setter
    def source_mesh_component(self, value: SkeletalMeshComponent) -> None:
        ...
    @property
    def use_attached_parent(self) -> bool:
        r"""
        (bool):  [Read-Write] If SourceMeshComponent is not valid, and if this is true, it will look for attahced parent as a source
        """
        ...
    @use_attached_parent.setter
    def use_attached_parent(self, value: bool) -> None:
        ...
    @property
    def copy_curves(self) -> bool:
        r"""
        (bool):  [Read-Write] Copy curves also from SouceMeshComponent. This will copy the curves if this instance also contains curve attributes
        """
        ...
    @copy_curves.setter
    def copy_curves(self, value: bool) -> None:
        ...
    @property
    def copy_custom_attributes(self) -> bool:
        r"""
        (bool):  [Read-Write] Copy custom attributes from SouceMeshComponent
        """
        ...
    @copy_custom_attributes.setter
    def copy_custom_attributes(self, value: bool) -> None:
        ...
    @property
    def use_mesh_pose(self) -> bool:
        r"""
        (bool):  [Read-Write] Use root space transform to copy to the target pose. By default, it copies their relative transform (bone space)
        """
        ...
    @use_mesh_pose.setter
    def use_mesh_pose(self, value: bool) -> None:
        ...
    @property
    def root_bone_to_copy(self) -> Name:
        r"""
        (Name):  [Read-Write] If you want to specify copy root, use this - this will ensure copy only below of this joint (inclusively)
        """
        ...
    @root_bone_to_copy.setter
    def root_bone_to_copy(self, value: Name) -> None:
        ...

class AnimNode_CurveSource(AnimNode_Base):
    r"""
    Supply curves from some external source (e.g. audio)
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_CurveSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] How much we wan to blend the curve in by
    - ``source_binding`` (Name):  [Read-Write] The binding of the curve source we want to bind to.
      We will bind to an object that implements ICurveSourceInterface. First we check
      the actor that owns this (if any), then we check each of its components to see if we should
      bind to the source that matches this name.
    - ``source_pose`` (PoseLink):  [Read-Write]
    """
    def __init__(self, source_pose: PoseLink = [], source_binding: Name = "None", alpha: float = 0.000000) -> None:
        ...
    @property
    def source_pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @source_pose.setter
    def source_pose(self, value: PoseLink) -> None:
        ...
    @property
    def source_binding(self) -> Name:
        r"""
        (Name):  [Read-Write] The binding of the curve source we want to bind to.
        We will bind to an object that implements ICurveSourceInterface. First we check
        the actor that owns this (if any), then we check each of its components to see if we should
        bind to the source that matches this name.
        """
        ...
    @source_binding.setter
    def source_binding(self, value: Name) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write] How much we wan to blend the curve in by
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...

class AnimNode_LayeredBoneBlend(AnimNode_Base):
    r"""
    Layered blend (per bone); has dynamic number of blendposes that can blend per different bone sets
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_LayeredBoneBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_pose`` (PoseLink):  [Read-Write] The source pose
    - ``blend_masks`` (Array[BlendProfile]):  [Read-Write] The blend masks to use for our layer inputs. Allows the use of per-bone alphas.
      Blend masks are used when BlendMode is BlendMask.
    - ``blend_mode`` (LayeredBoneBlendMode):  [Read-Write] Whether to use branch filters or a blend mask to specify an input pose per-bone influence
    - ``blend_poses`` (Array[PoseLink]):  [Read-Write] Each layer's blended pose
    - ``blend_root_motion_based_on_root_bone`` (bool):  [Read-Write] Whether to incorporate the per-bone blend weight of the root bone when lending root motion
    - ``blend_weights`` (Array[float]):  [Read-Write] The weights of each layer
    - ``curve_blend_option`` (CurveBlendOption):  [Read-Write] How to blend the layers together
    - ``layer_setup`` (Array[InputBlendPose]):  [Read-Write] Configuration for the parts of the skeleton to blend for each layer. Allows
      certain parts of the tree to be blended out or omitted from the pose.
      LayerSetup is used when BlendMode is BranchFilter.
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``mesh_space_rotation_blend`` (bool):  [Read-Write] Whether to blend bone rotations in mesh space or in local space
    - ``mesh_space_scale_blend`` (bool):  [Read-Write] Whether to blend bone scales in mesh space or in local space
    """
    def __init__(self, base_pose: PoseLink = [], blend_poses: Array[PoseLink] = [], blend_weights: Array[float] = [], mesh_space_rotation_blend: bool = False, mesh_space_scale_blend: bool = False, curve_blend_option: CurveBlendOption = CurveBlendOption.OVERRIDE, lod_threshold: int = 0) -> None:
        ...
    @property
    def base_pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write] The source pose
        """
        ...
    @base_pose.setter
    def base_pose(self, value: PoseLink) -> None:
        ...
    @property
    def blend_poses(self) -> Array[PoseLink]:
        r"""
        (Array[PoseLink]):  [Read-Write] Each layer's blended pose
        """
        ...
    @blend_poses.setter
    def blend_poses(self, value: Array[PoseLink]) -> None:
        ...
    @property
    def blend_weights(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Write] The weights of each layer
        """
        ...
    @blend_weights.setter
    def blend_weights(self, value: Array[float]) -> None:
        ...
    @property
    def mesh_space_rotation_blend(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to blend bone rotations in mesh space or in local space
        """
        ...
    @mesh_space_rotation_blend.setter
    def mesh_space_rotation_blend(self, value: bool) -> None:
        ...
    @property
    def mesh_space_scale_blend(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to blend bone scales in mesh space or in local space
        """
        ...
    @mesh_space_scale_blend.setter
    def mesh_space_scale_blend(self, value: bool) -> None:
        ...
    @property
    def curve_blend_option(self) -> CurveBlendOption:
        r"""
        (CurveBlendOption):  [Read-Write] How to blend the layers together
        """
        ...
    @curve_blend_option.setter
    def curve_blend_option(self, value: CurveBlendOption) -> None:
        ...
    @property
    def lod_threshold(self) -> int:
        r"""
        (int32):  [Read-Write] * Max LOD that this node is allowed to run
        * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
        * when the component LOD becomes 3, it will stop update/evaluate
        * currently transition would be issue and that has to be re-visited
        """
        ...
    @lod_threshold.setter
    def lod_threshold(self, value: int) -> None:
        ...

class PerBoneBlendWeight(StructBase):
    r"""
    Per Bone Blend Weight
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_MakeDynamicAdditive(AnimNode_Base):
    r"""
    Anim Node Make Dynamic Additive
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_MakeDynamicAdditive.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additive`` (PoseLink):  [Read-Write] Pose to make additive
    - ``base`` (PoseLink):  [Read-Write] Reference pose for additive delta calculation
    - ``mesh_space_additive`` (bool):  [Read-Write] Do additive delta calculation in mesh space
    """
    def __init__(self, base: PoseLink = [], additive: PoseLink = [], mesh_space_additive: bool = False) -> None:
        ...
    @property
    def base(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write] Reference pose for additive delta calculation
        """
        ...
    @base.setter
    def base(self, value: PoseLink) -> None:
        ...
    @property
    def additive(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write] Pose to make additive
        """
        ...
    @additive.setter
    def additive(self, value: PoseLink) -> None:
        ...
    @property
    def mesh_space_additive(self) -> bool:
        r"""
        (bool):  [Read-Write] Do additive delta calculation in mesh space
        """
        ...
    @mesh_space_additive.setter
    def mesh_space_additive(self, value: bool) -> None:
        ...

class AnimNode_MirrorBase(AnimNode_Base):
    r"""
    Anim Node Mirror Base
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_Mirror.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source`` (PoseLink):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AnimNode_Mirror(AnimNode_MirrorBase):
    r"""
    Anim Node Mirror
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_Mirror.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attribute_mirroring`` (bool):  [Read-Write]
    - ``blend_time`` (float):  [Read-Write] Inertialization blend time to use when transitioning between mirrored and unmirrored states
    - ``bone_mirroring`` (bool):  [Read-Write]
    - ``curve_mirroring`` (bool):  [Read-Write]
    - ``mirror`` (bool):  [Read-Write]
    - ``mirror_data_table`` (MirrorDataTable):  [Read-Write]
    - ``reset_child`` (bool):  [Read-Write] Whether to reset (reinitialize) the child (source) pose when the mirror state changes
    - ``source`` (PoseLink):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AnimNode_Mirror_Standalone(AnimNode_MirrorBase):
    r"""
    Anim Node Mirror Standalone
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_Mirror.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attribute_mirroring`` (bool):  [Read-Write]
    - ``blend_time`` (float):  [Read-Write] Inertialization blend time to use when transitioning between mirrored and unmirrored states
    - ``bone_mirroring`` (bool):  [Read-Write]
    - ``curve_mirroring`` (bool):  [Read-Write]
    - ``mirror`` (bool):  [Read-Write]
    - ``mirror_data_table`` (MirrorDataTable):  [Read-Write]
    - ``reset_child`` (bool):  [Read-Write] Whether to reset (reinitialize) the child (source) pose when the mirror state changes
    - ``source`` (PoseLink):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AnimNode_ModifyCurve(AnimNode_Base):
    r"""
    Easy way to modify curve values on a pose
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_ModifyCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write]
    - ``apply_mode`` (ModifyCurveApplyMode):  [Read-Write]
    - ``curve_map`` (Map[Name, float]):  [Read-Write]
    - ``curve_values`` (Array[float]):  [Read-Write]
    - ``source_pose`` (PoseLink):  [Read-Write]
    """
    def __init__(self, source_pose: PoseLink = [], curve_map: Map[Name, float] = {}, curve_values: Array[float] = [], alpha: float = 0.000000, apply_mode: ModifyCurveApplyMode = ModifyCurveApplyMode.ADD) -> None:
        ...
    @property
    def source_pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @source_pose.setter
    def source_pose(self, value: PoseLink) -> None:
        ...
    @property
    def curve_map(self) -> Map[Name, float]:
        r"""
        (Map[Name, float]):  [Read-Write]
        """
        ...
    @curve_map.setter
    def curve_map(self, value: Map[Name, float]) -> None:
        ...
    @property
    def curve_values(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Write]
        """
        ...
    @curve_values.setter
    def curve_values(self, value: Array[float]) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...
    @property
    def apply_mode(self) -> ModifyCurveApplyMode:
        r"""
        (ModifyCurveApplyMode):  [Read-Write]
        """
        ...
    @apply_mode.setter
    def apply_mode(self, value: ModifyCurveApplyMode) -> None:
        ...

class AnimNode_MultiWayBlend(AnimNode_Base):
    r"""
    This represents a baked transition
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_MultiWayBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additive_node`` (bool):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``desired_alphas`` (Array[float]):  [Read-Write]
    - ``normalize_alpha`` (bool):  [Read-Write]
    - ``poses`` (Array[PoseLink]):  [Read-Write]
    """
    def __init__(self, poses: Array[PoseLink] = [], desired_alphas: Array[float] = [], alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], additive_node: bool = False, normalize_alpha: bool = False) -> None:
        ...
    @property
    def poses(self) -> Array[PoseLink]:
        r"""
        (Array[PoseLink]):  [Read-Write]
        """
        ...
    @poses.setter
    def poses(self, value: Array[PoseLink]) -> None:
        ...
    @property
    def desired_alphas(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Write]
        """
        ...
    @desired_alphas.setter
    def desired_alphas(self, value: Array[float]) -> None:
        ...
    @property
    def alpha_scale_bias(self) -> InputScaleBias:
        r"""
        (InputScaleBias):  [Read-Write]
        """
        ...
    @alpha_scale_bias.setter
    def alpha_scale_bias(self, value: InputScaleBias) -> None:
        ...
    @property
    def additive_node(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @additive_node.setter
    def additive_node(self, value: bool) -> None:
        ...
    @property
    def normalize_alpha(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @normalize_alpha.setter
    def normalize_alpha(self, value: bool) -> None:
        ...

class AnimNode_PoseHandler(AnimNode_AssetPlayerBase):
    r"""
    Evaluates a point in an anim sequence, using a specific time input rather than advancing time internally.
    Typically the playback position of the animation for this node will represent something other than time, like jump height.
    This node will not trigger any notifies present in the associated sequence.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_PoseHandler.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``pose_asset`` (PoseAsset):  [Read-Write] The animation sequence asset to evaluate
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000, pose_asset: PoseAsset = None) -> None:
        ...
    @property
    def pose_asset(self) -> PoseAsset:
        r"""
        (PoseAsset):  [Read-Write] The animation sequence asset to evaluate
        """
        ...
    @pose_asset.setter
    def pose_asset(self, value: PoseAsset) -> None:
        ...

class AnimNode_PoseBlendNode(AnimNode_PoseHandler):
    r"""
    Evaluates a point in an anim sequence, using a specific time input rather than advancing time internally.
    Typically the playback position of the animation for this node will represent something other than time, like jump height.
    This node will not trigger any notifies present in the associated sequence.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_PoseBlendNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_option`` (AlphaBlendOption):  [Read-Write] Type of blending used (Linear, Cubic, etc.)
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``custom_curve`` (CurveFloat):  [Read-Write] If you're using Custom BlendOption, you can specify curve
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``pose_asset`` (PoseAsset):  [Read-Write] The animation sequence asset to evaluate
    - ``source_pose`` (PoseLink):  [Read-Write]
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000, pose_asset: PoseAsset = None, source_pose: PoseLink = []) -> None:
        ...
    @property
    def source_pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @source_pose.setter
    def source_pose(self, value: PoseLink) -> None:
        ...

class AnimNode_PoseByName(AnimNode_PoseHandler):
    r"""
    Evaluates a point in an anim sequence, using a specific time input rather than advancing time internally.
    Typically the playback position of the animation for this node will represent something other than time, like jump height.
    This node will not trigger any notifies present in the associated sequence.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_PoseByName.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``pose_asset`` (PoseAsset):  [Read-Write] The animation sequence asset to evaluate
    - ``pose_name`` (Name):  [Read-Write]
    - ``pose_weight`` (float):  [Read-Write]
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000, pose_asset: PoseAsset = None, pose_name: Name = "None", pose_weight: float = 0.000000) -> None:
        ...
    @property
    def pose_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @pose_name.setter
    def pose_name(self, value: Name) -> None:
        ...
    @property
    def pose_weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @pose_weight.setter
    def pose_weight(self, value: float) -> None:
        ...

class AnimNode_PoseDriver(AnimNode_PoseHandler):
    r"""
    RBF based orientation driver
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_PoseDriver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``drive_output`` (PoseDriverOutput):  [Read-Write] Whether we should drive poses or curves
    - ``drive_source`` (PoseDriverSource):  [Read-Write] Which part of the transform is read
    - ``eval_from_ref_pose`` (bool):  [Read-Write] Evaluate SourceBone transform relative from its Reference Pose.
      This is recommended when using Swing and Twist Angle as Distance Method, since the twist will be computed from RefPose.
      
      If not specified, the local space of SourceBone will be used. (ie relative to parent bone)
      This mode won't work in conjunction with EvalSpaceBone;
    - ``eval_space_bone`` (BoneReference):  [Read-Write] Optional other bone space to use when reading SourceBone transform.
      If not specified, the local space of SourceBone will be used. (ie relative to parent bone)
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``only_drive_bones`` (Array[BoneReference]):  [Read-Write] List of bones that will modified by this node. If no list is provided, all bones bones with a track in the PoseAsset will be modified
    - ``pose_asset`` (PoseAsset):  [Read-Write] The animation sequence asset to evaluate
    - ``pose_targets`` (Array[PoseDriverTarget]):  [Read-Write] Targets used to compare with current pose and drive morphs/poses
    - ``rbf_params`` (RBFParams):  [Read-Write] Parameters used by RBF solver
    - ``source_bones`` (Array[BoneReference]):  [Read-Write] Bone to use for driving parameters based on its orientation
    - ``source_pose`` (PoseLink):  [Read-Write] Bones to use for driving parameters based on their transform
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000, pose_asset: PoseAsset = None, source_pose: PoseLink = []) -> None:
        ...
    @property
    def source_pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write] Bones to use for driving parameters based on their transform
        """
        ...
    @source_pose.setter
    def source_pose(self, value: PoseLink) -> None:
        ...

class AnimNode_OrientationDriver(AnimNode_PoseDriver):
    r"""
    deprecated: 'AnimNode_OrientationDriver' was renamed to 'AnimNode_PoseDriver'.
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000, pose_asset: PoseAsset = None, source_pose: PoseLink = []) -> None:
        ...

class RBFParams(StructBase):
    r"""
    Parameters used by RBF solver
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: RBFSolver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_radius`` (bool):  [Read-Write] Automatically pick the radius based on the average distance between targets
    - ``distance_method`` (RBFDistanceMethod):  [Read-Write]
    - ``function`` (RBFFunctionType):  [Read-Write]
    - ``median_max`` (float):  [Read-Write] Maximum distance used for median
    - ``median_min`` (float):  [Read-Write] Minimum distance used for median
    - ``median_reference`` (Vector):  [Read-Write] Rotation or position of median (used for normalization)
    - ``normalize_method`` (RBFNormalizeMethod):  [Read-Write] Method to use for normalizing the weight
    - ``radius`` (float):  [Read-Write] Default radius for each target.
    - ``solver_type`` (RBFSolverType):  [Read-Write] Specifies the type of solver to use. The additive solver requires normalization, for the
                    most part, whereas the Interpolative solver is not as reliant on it. The interpolative
                    solver also has smoother blending, whereas the additive solver requires more targets but
                    has a more precise control over the influence of each target.
    - ``twist_axis`` (BoneAxis):  [Read-Write] Axis to use when DistanceMethod is SwingAngle
    - ``weight_threshold`` (float):  [Read-Write] Weight below which we shouldn't bother returning a contribution from a target
    """
    def __init__(self, solver_type: RBFSolverType = RBFSolverType.ADDITIVE, radius: float = 0.000000, automatic_radius: bool = False, function: RBFFunctionType = RBFFunctionType.GAUSSIAN, distance_method: RBFDistanceMethod = RBFDistanceMethod.EUCLIDEAN, twist_axis: BoneAxis = BoneAxis.BA_X, weight_threshold: float = 0.000000, normalize_method: RBFNormalizeMethod = RBFNormalizeMethod.ONLY_NORMALIZE_ABOVE_ONE, median_reference: Vector = [0.000000, 0.000000, 0.000000], median_min: float = 0.000000, median_max: float = 0.000000) -> None:
        ...
    @property
    def solver_type(self) -> RBFSolverType:
        r"""
        (RBFSolverType):  [Read-Write] Specifies the type of solver to use. The additive solver requires normalization, for the
                      most part, whereas the Interpolative solver is not as reliant on it. The interpolative
                      solver also has smoother blending, whereas the additive solver requires more targets but
                      has a more precise control over the influence of each target.
        """
        ...
    @solver_type.setter
    def solver_type(self, value: RBFSolverType) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write] Default radius for each target.
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def automatic_radius(self) -> bool:
        r"""
        (bool):  [Read-Write] Automatically pick the radius based on the average distance between targets
        """
        ...
    @automatic_radius.setter
    def automatic_radius(self, value: bool) -> None:
        ...
    @property
    def function(self) -> RBFFunctionType:
        r"""
        (RBFFunctionType):  [Read-Write]
        """
        ...
    @function.setter
    def function(self, value: RBFFunctionType) -> None:
        ...
    @property
    def distance_method(self) -> RBFDistanceMethod:
        r"""
        (RBFDistanceMethod):  [Read-Write]
        """
        ...
    @distance_method.setter
    def distance_method(self, value: RBFDistanceMethod) -> None:
        ...
    @property
    def twist_axis(self) -> BoneAxis:
        r"""
        (BoneAxis):  [Read-Write] Axis to use when DistanceMethod is SwingAngle
        """
        ...
    @twist_axis.setter
    def twist_axis(self, value: BoneAxis) -> None:
        ...
    @property
    def weight_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Weight below which we shouldn't bother returning a contribution from a target
        """
        ...
    @weight_threshold.setter
    def weight_threshold(self, value: float) -> None:
        ...
    @property
    def normalize_method(self) -> RBFNormalizeMethod:
        r"""
        (RBFNormalizeMethod):  [Read-Write] Method to use for normalizing the weight
        """
        ...
    @normalize_method.setter
    def normalize_method(self, value: RBFNormalizeMethod) -> None:
        ...
    @property
    def median_reference(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Rotation or position of median (used for normalization)
        """
        ...
    @median_reference.setter
    def median_reference(self, value: Vector) -> None:
        ...
    @property
    def median_min(self) -> float:
        r"""
        (float):  [Read-Write] Minimum distance used for median
        """
        ...
    @median_min.setter
    def median_min(self, value: float) -> None:
        ...
    @property
    def median_max(self) -> float:
        r"""
        (float):  [Read-Write] Maximum distance used for median
        """
        ...
    @median_max.setter
    def median_max(self, value: float) -> None:
        ...

class AnimNode_PoseSnapshot(AnimNode_Base):
    r"""
    Provide a snapshot pose, either from the internal named pose cache or via a supplied snapshot
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_PoseSnapshot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``mode`` (SnapshotSourceMode):  [Read-Write] How to access the snapshot
    - ``snapshot`` (PoseSnapshot):  [Read-Write] Snapshot to use. This should be populated at first by calling SnapshotPose
    - ``snapshot_name`` (Name):  [Read-Write] The name of the snapshot previously stored with SavePoseSnapshot
    """
    def __init__(self, snapshot_name: Name = "None", snapshot: PoseSnapshot = [[], [], "None", "None", False], mode: SnapshotSourceMode = SnapshotSourceMode.NAMED_SNAPSHOT) -> None:
        ...
    @property
    def snapshot_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the snapshot previously stored with SavePoseSnapshot
        """
        ...
    @snapshot_name.setter
    def snapshot_name(self, value: Name) -> None:
        ...
    @property
    def snapshot(self) -> PoseSnapshot:
        r"""
        (PoseSnapshot):  [Read-Write] Snapshot to use. This should be populated at first by calling SnapshotPose
        """
        ...
    @snapshot.setter
    def snapshot(self, value: PoseSnapshot) -> None:
        ...
    @property
    def mode(self) -> SnapshotSourceMode:
        r"""
        (SnapshotSourceMode):  [Read-Write] How to access the snapshot
        """
        ...
    @mode.setter
    def mode(self, value: SnapshotSourceMode) -> None:
        ...

class PoseSnapshot(StructBase):
    r"""
    A pose for a skeletal mesh
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PoseSnapshot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_names`` (Array[Name]):  [Read-Write] Array of bone names (corresponding to LocalTransforms)
    - ``is_valid`` (bool):  [Read-Write] Whether the pose is valid
    - ``local_transforms`` (Array[Transform]):  [Read-Write] Array of transforms per-bone
    - ``skeletal_mesh_name`` (Name):  [Read-Write] The name of the skeletal mesh that was used to take this snapshot
    - ``snapshot_name`` (Name):  [Read-Write] The name for this snapshot
    """
    def __init__(self, local_transforms: Array[Transform] = [], bone_names: Array[Name] = [], skeletal_mesh_name: Name = "None", snapshot_name: Name = "None", is_valid: bool = False) -> None:
        ...
    @property
    def local_transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write] Array of transforms per-bone
        """
        ...
    @local_transforms.setter
    def local_transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def bone_names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Array of bone names (corresponding to LocalTransforms)
        """
        ...
    @bone_names.setter
    def bone_names(self, value: Array[Name]) -> None:
        ...
    @property
    def skeletal_mesh_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the skeletal mesh that was used to take this snapshot
        """
        ...
    @skeletal_mesh_name.setter
    def skeletal_mesh_name(self, value: Name) -> None:
        ...
    @property
    def snapshot_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name for this snapshot
        """
        ...
    @snapshot_name.setter
    def snapshot_name(self, value: Name) -> None:
        ...
    @property
    def is_valid(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the pose is valid
        """
        ...
    @is_valid.setter
    def is_valid(self, value: bool) -> None:
        ...

class RandomPlayerSequenceEntry(StructBase):
    r"""
    The random player node holds a list of sequences and parameter ranges which will be played continuously
    In a random order. If shuffle mode is enabled then each entry will be played once before repeating any
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RandomPlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_in`` (AlphaBlend):  [Read-Write] Blending properties used when this entry is blending in ontop of another entry
    - ``chance_to_play`` (float):  [Read-Write] When not in shuffle mode, this is the chance this entry will play (normalized against all other sample chances)
    - ``max_loop_count`` (int32):  [Read-Write] Maximum number of times this entry will loop before ending
    - ``max_play_rate`` (float):  [Read-Write] Maximum playrate for this entry
    - ``min_loop_count`` (int32):  [Read-Write] Minimum number of times this entry will loop before ending
    - ``min_play_rate`` (float):  [Read-Write] Minimum playrate for this entry
    - ``sequence`` (AnimSequenceBase):  [Read-Write] Sequence to play when this entry is picked
    """
    def __init__(self, sequence: AnimSequenceBase = None, chance_to_play: float = 0.000000, min_loop_count: int = 0, max_loop_count: int = 0, min_play_rate: float = 0.000000, max_play_rate: float = 0.000000) -> None:
        ...
    @property
    def sequence(self) -> AnimSequenceBase:
        r"""
        (AnimSequenceBase):  [Read-Write] Sequence to play when this entry is picked
        """
        ...
    @sequence.setter
    def sequence(self, value: AnimSequenceBase) -> None:
        ...
    @property
    def chance_to_play(self) -> float:
        r"""
        (float):  [Read-Write] When not in shuffle mode, this is the chance this entry will play (normalized against all other sample chances)
        """
        ...
    @chance_to_play.setter
    def chance_to_play(self, value: float) -> None:
        ...
    @property
    def min_loop_count(self) -> int:
        r"""
        (int32):  [Read-Write] Minimum number of times this entry will loop before ending
        """
        ...
    @min_loop_count.setter
    def min_loop_count(self, value: int) -> None:
        ...
    @property
    def max_loop_count(self) -> int:
        r"""
        (int32):  [Read-Write] Maximum number of times this entry will loop before ending
        """
        ...
    @max_loop_count.setter
    def max_loop_count(self, value: int) -> None:
        ...
    @property
    def min_play_rate(self) -> float:
        r"""
        (float):  [Read-Write] Minimum playrate for this entry
        """
        ...
    @min_play_rate.setter
    def min_play_rate(self, value: float) -> None:
        ...
    @property
    def max_play_rate(self) -> float:
        r"""
        (float):  [Read-Write] Maximum playrate for this entry
        """
        ...
    @max_play_rate.setter
    def max_play_rate(self, value: float) -> None:
        ...

class AnimNode_RandomPlayer(AnimNode_AssetPlayerRelevancyBase):
    r"""
    Anim Node Random Player
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RandomPlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blend weight for this node
    - ``entries`` (Array[RandomPlayerSequenceEntry]):  [Read-Write] List of sequences to randomly step through
    - ``ignore_for_relevancy_test`` (bool):  [Read-Write] If true, "Relevant anim" nodes that look for the highest weighted animation in a state will ignore this node
    - ``shuffle_mode`` (bool):  [Read-Write] When shuffle mode is active we will never loop a sequence beyond MaxLoopCount
      without visiting each sequence in turn (no repeats). Enabling this will ignore
      ChanceToPlay for each entry
    """
    def __init__(self, entries: Array[RandomPlayerSequenceEntry] = [], blend_weight: float = 0.000000, shuffle_mode: bool = False) -> None:
        ...
    @property
    def entries(self) -> Array[RandomPlayerSequenceEntry]:
        r"""
        (Array[RandomPlayerSequenceEntry]):  [Read-Write] List of sequences to randomly step through
        """
        ...
    @entries.setter
    def entries(self, value: Array[RandomPlayerSequenceEntry]) -> None:
        ...
    @property
    def blend_weight(self) -> float:
        r"""
        (float):  [Read-Write] Last encountered blend weight for this node
        """
        ...
    @blend_weight.setter
    def blend_weight(self, value: float) -> None:
        ...
    @property
    def shuffle_mode(self) -> bool:
        r"""
        (bool):  [Read-Write] When shuffle mode is active we will never loop a sequence beyond MaxLoopCount
        without visiting each sequence in turn (no repeats). Enabling this will ignore
        ChanceToPlay for each entry
        """
        ...
    @shuffle_mode.setter
    def shuffle_mode(self, value: bool) -> None:
        ...

class AnimNode_RotateRootBone(AnimNode_Base):
    r"""
    
    TODO:: Comment
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RotateRootBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_pose`` (PoseLink):  [Read-Write]
    - ``mesh_to_component`` (Rotator):  [Read-Write]
    - ``pitch`` (float):  [Read-Write]
    - ``pitch_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``rotate_root_motion_attribute`` (bool):  [Read-Write] If enabled, rotating the root bone using this node will also rotate the direction of the root motion custom attribute
    - ``yaw`` (float):  [Read-Write]
    - ``yaw_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    """
    def __init__(self, base_pose: PoseLink = [], pitch: float = 0.000000, yaw: float = 0.000000, pitch_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], yaw_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], mesh_to_component: Rotator = [0.000000, 0.000000, 0.000000], rotate_root_motion_attribute: bool = False) -> None:
        ...
    @property
    def base_pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @base_pose.setter
    def base_pose(self, value: PoseLink) -> None:
        ...
    @property
    def pitch(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @pitch.setter
    def pitch(self, value: float) -> None:
        ...
    @property
    def yaw(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @yaw.setter
    def yaw(self, value: float) -> None:
        ...
    @property
    def pitch_scale_bias_clamp(self) -> InputScaleBiasClamp:
        r"""
        (InputScaleBiasClamp):  [Read-Write]
        """
        ...
    @pitch_scale_bias_clamp.setter
    def pitch_scale_bias_clamp(self, value: InputScaleBiasClamp) -> None:
        ...
    @property
    def yaw_scale_bias_clamp(self) -> InputScaleBiasClamp:
        r"""
        (InputScaleBiasClamp):  [Read-Write]
        """
        ...
    @yaw_scale_bias_clamp.setter
    def yaw_scale_bias_clamp(self, value: InputScaleBiasClamp) -> None:
        ...
    @property
    def mesh_to_component(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @mesh_to_component.setter
    def mesh_to_component(self, value: Rotator) -> None:
        ...
    @property
    def rotate_root_motion_attribute(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, rotating the root bone using this node will also rotate the direction of the root motion custom attribute
        """
        ...
    @rotate_root_motion_attribute.setter
    def rotate_root_motion_attribute(self, value: bool) -> None:
        ...

class AnimNode_RotationOffsetBlendSpace(AnimNode_BlendSpacePlayer):
    r"""
    
    TODO:: Comment
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RotationOffsetBlendSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the AimOffset
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``base_pose`` (PoseLink):  [Read-Write]
    - ``blend_space`` (BlendSpace):  [Read-Write] The blendspace asset to play
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group). Note that
      this is the name of the group used to sync the output of this node - it will not force
      syncing of animations contained by it.
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this node can assume within the group (ignored if GroupName is not set). Note
      that this is the role of the output of this node, not of animations contained by it.
    - ``ignore_for_relevancy_test`` (bool):  [Read-Write] If true, "Relevant anim" nodes that look for the highest weighted animation in a state will ignore this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``loop`` (bool):  [Read-Write] Should the animation loop back to the start when it reaches the end?
    - ``method`` (AnimSyncMethod):  [Read-Write] How this node will synchronize with other animations. Note that this determines how the output
      of this node is used for synchronization, not of animations contained by it.
    - ``play_rate`` (float):  [Read-Write] The play rate multiplier. Can be negative, which will cause the animation to play in reverse.
    - ``reset_play_time_when_blend_space_changes`` (bool):  [Read-Write] Whether we should reset the current play time when the blend space changes
    - ``start_position`` (float):  [Read-Write] The start position in [0, 1] to use when initializing. When looping, play will still jump back to the beginning when reaching the end.
    - ``x`` (float):  [Read-Write] The X coordinate to sample in the blendspace
    - ``y`` (float):  [Read-Write] The Y coordinate to sample in the blendspace
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000, base_pose: PoseLink = [], lod_threshold: int = 0, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False) -> None:
        ...
    @property
    def base_pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @base_pose.setter
    def base_pose(self, value: PoseLink) -> None:
        ...
    @property
    def lod_threshold(self) -> int:
        r"""
        (int32):  [Read-Write] * Max LOD that this node is allowed to run
        * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
        * when the component LOD becomes 3, it will stop update/evaluate
        * currently transition would be issue and that has to be re-visited
        """
        ...
    @lod_threshold.setter
    def lod_threshold(self, value: int) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write] Current strength of the AimOffset
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...
    @property
    def alpha_scale_bias(self) -> InputScaleBias:
        r"""
        (InputScaleBias):  [Read-Write]
        """
        ...
    @alpha_scale_bias.setter
    def alpha_scale_bias(self, value: InputScaleBias) -> None:
        ...
    @property
    def alpha_bool_blend(self) -> InputAlphaBoolBlend:
        r"""
        (InputAlphaBoolBlend):  [Read-Write]
        """
        ...
    @alpha_bool_blend.setter
    def alpha_bool_blend(self, value: InputAlphaBoolBlend) -> None:
        ...
    @property
    def alpha_curve_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @alpha_curve_name.setter
    def alpha_curve_name(self, value: Name) -> None:
        ...
    @property
    def alpha_scale_bias_clamp(self) -> InputScaleBiasClamp:
        r"""
        (InputScaleBiasClamp):  [Read-Write]
        """
        ...
    @alpha_scale_bias_clamp.setter
    def alpha_scale_bias_clamp(self, value: InputScaleBiasClamp) -> None:
        ...
    @property
    def alpha_input_type(self) -> AnimAlphaInputType:
        r"""
        (AnimAlphaInputType):  [Read-Write]
        """
        ...
    @alpha_input_type.setter
    def alpha_input_type(self, value: AnimAlphaInputType) -> None:
        ...
    @property
    def alpha_bool_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @alpha_bool_enabled.setter
    def alpha_bool_enabled(self, value: bool) -> None:
        ...

class AnimNode_RotationOffsetBlendSpaceGraph(AnimNode_BlendSpaceGraphBase):
    r"""
    Allows multiple animations to be blended between based on input parameters
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RotationOffsetBlendSpaceGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the AimOffset
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``base_pose`` (PoseLink):  [Read-Write]
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group). Note that
      this is the name of the group used to sync the output of this node - it will not force
      syncing of animations contained by it. Animations inside this Blend Space have their own
      options for syncing.
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this Blend Space can assume within the group (ignored if GroupName is not set). Note
      that this is the role of the output of this node, not of animations contained by it.
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``x`` (float):  [Read-Write] The X coordinate to sample in the blendspace
    - ``y`` (float):  [Read-Write] The Y coordinate to sample in the blendspace
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, group_name: Name = "None", group_role: AnimGroupRole = AnimGroupRole.CAN_BE_LEADER, base_pose: PoseLink = [], lod_threshold: int = 0, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False) -> None:
        ...
    @property
    def base_pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @base_pose.setter
    def base_pose(self, value: PoseLink) -> None:
        ...
    @property
    def lod_threshold(self) -> int:
        r"""
        (int32):  [Read-Write] * Max LOD that this node is allowed to run
        * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
        * when the component LOD becomes 3, it will stop update/evaluate
        * currently transition would be issue and that has to be re-visited
        """
        ...
    @lod_threshold.setter
    def lod_threshold(self, value: int) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write] Current strength of the AimOffset
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...
    @property
    def alpha_scale_bias(self) -> InputScaleBias:
        r"""
        (InputScaleBias):  [Read-Write]
        """
        ...
    @alpha_scale_bias.setter
    def alpha_scale_bias(self, value: InputScaleBias) -> None:
        ...
    @property
    def alpha_bool_blend(self) -> InputAlphaBoolBlend:
        r"""
        (InputAlphaBoolBlend):  [Read-Write]
        """
        ...
    @alpha_bool_blend.setter
    def alpha_bool_blend(self, value: InputAlphaBoolBlend) -> None:
        ...
    @property
    def alpha_curve_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @alpha_curve_name.setter
    def alpha_curve_name(self, value: Name) -> None:
        ...
    @property
    def alpha_scale_bias_clamp(self) -> InputScaleBiasClamp:
        r"""
        (InputScaleBiasClamp):  [Read-Write]
        """
        ...
    @alpha_scale_bias_clamp.setter
    def alpha_scale_bias_clamp(self, value: InputScaleBiasClamp) -> None:
        ...
    @property
    def alpha_input_type(self) -> AnimAlphaInputType:
        r"""
        (AnimAlphaInputType):  [Read-Write]
        """
        ...
    @alpha_input_type.setter
    def alpha_input_type(self, value: AnimAlphaInputType) -> None:
        ...
    @property
    def alpha_bool_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @alpha_bool_enabled.setter
    def alpha_bool_enabled(self, value: bool) -> None:
        ...

class AnimNode_SequenceEvaluatorBase(AnimNode_AssetPlayerBase):
    r"""
    Abstract base class. Evaluates a point in an anim sequence, using a specific time input rather than advancing time internally.
    Typically the playback position of the animation for this node will represent something other than time, like jump height.
    This node will not trigger any notifies present in the associated sequence.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_SequenceEvaluator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000) -> None:
        ...

class AnimNode_SequenceEvaluator(AnimNode_SequenceEvaluatorBase):
    r"""
    Sequence evaluator node that can be used with constant folding
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_SequenceEvaluator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``explicit_frame`` (int32):  [Read-Write] The frame at which to evaluate the associated sequence
    - ``explicit_time`` (float):  [Read-Write] The time at which to evaluate the associated sequence
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group).
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this node can assume within the group (ignored if GroupName is not set)
    - ``ignore_for_relevancy_test`` (bool):  [Read-Write] If true, "Relevant anim" nodes that look for the highest weighted animation in a state will ignore this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``method`` (AnimSyncMethod):  [Read-Write] How this node will synchronize with other animations.
    - ``reinitialization_behavior`` (SequenceEvalReinit):  [Read-Write] What to do when SequenceEvaluator is reinitialized
    - ``sequence`` (AnimSequenceBase):  [Read-Write] The animation sequence asset to evaluate
    - ``should_loop`` (bool):  [Read-Write] This only works if bTeleportToExplicitTime is false OR this node is set to use SyncGroup
    - ``start_position`` (float):  [Read-Write] The start up position, it only applies when ReinitializationBehavior == StartPosition. Only used when bTeleportToExplicitTime is false.
    - ``teleport_to_explicit_time`` (bool):  [Read-Write] If true, teleport to explicit time, does NOT advance time (does not trigger notifies, does not extract Root Motion, etc.)
            If false, will advance time (will trigger notifies, extract root motion if applicable, etc.)
            Note: using a sync group forces advancing time regardless of what this option is set to.
    - ``use_explicit_frame`` (bool):  [Read-Write] Whether to use ExplicitFrame (true) or ExplicitTime (false) when evaluating the associated sequence
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000) -> None:
        ...

class AnimNode_SequenceEvaluator_Standalone(AnimNode_SequenceEvaluatorBase):
    r"""
    Sequence evaluator node that can be used standalone (without constant folding)
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_SequenceEvaluator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``explicit_frame`` (int32):  [Read-Write]
    - ``explicit_time`` (float):  [Read-Write] The time at which to evaluate the associated sequence
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group).
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this node can assume within the group (ignored if GroupName is not set)
    - ``ignore_for_relevancy_test`` (bool):  [Read-Write] If true, "Relevant anim" nodes that look for the highest weighted animation in a state will ignore this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``method`` (AnimSyncMethod):  [Read-Write] How this node will synchronize with other animations.
    - ``reinitialization_behavior`` (SequenceEvalReinit):  [Read-Write] What to do when SequenceEvaluator is reinitialized
    - ``sequence`` (AnimSequenceBase):  [Read-Write] The animation sequence asset to evaluate
    - ``should_loop`` (bool):  [Read-Write] This only works if bTeleportToExplicitTime is false OR this node is set to use SyncGroup
    - ``start_position`` (float):  [Read-Write] The start up position, it only applies when ReinitializationBehavior == StartPosition. Only used when bTeleportToExplicitTime is false.
    - ``teleport_to_explicit_time`` (bool):  [Read-Write] If true, teleport to explicit time, does NOT advance time (does not trigger notifies, does not extract Root Motion, etc.)
            If false, will advance time (will trigger notifies, extract root motion if applicable, etc.)
            Note: using a sync group forces advancing time regardless of what this option is set to.
    - ``use_explicit_frame`` (bool):  [Read-Write]
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000) -> None:
        ...

class AnimNode_Slot(AnimNode_Base):
    r"""
    An animation slot node normally acts as a passthru, but a montage or PlaySlotAnimation call from
    game code can cause an animation to blend in and be played on the slot temporarily, overriding the
    Source input.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_Slot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``always_update_source_pose`` (bool):  [Read-Write] Whether we should continue to update the source pose regardless of whether it would be used.
    - ``slot_name`` (Name):  [Read-Write] The name of this slot, exposed to gameplay code, etc...
    - ``source`` (PoseLink):  [Read-Write] The source input, passed thru to the output unless a montage or slot animation is currently playing
    """
    def __init__(self, source: PoseLink = [], slot_name: Name = "None", always_update_source_pose: bool = False) -> None:
        ...
    @property
    def source(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write] The source input, passed thru to the output unless a montage or slot animation is currently playing
        """
        ...
    @source.setter
    def source(self, value: PoseLink) -> None:
        ...
    @property
    def slot_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of this slot, exposed to gameplay code, etc...
        """
        ...
    @slot_name.setter
    def slot_name(self, value: Name) -> None:
        ...
    @property
    def always_update_source_pose(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we should continue to update the source pose regardless of whether it would be used.
        """
        ...
    @always_update_source_pose.setter
    def always_update_source_pose(self, value: bool) -> None:
        ...

class AnimNode_Sync(AnimNode_Base):
    r"""
    Anim Node Sync
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_Sync.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group).
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this animation can assume within the group (ignored if GroupName is not set)
    - ``source`` (PoseLink):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AnimNode_TwoWayBlend(AnimNode_Base):
    r"""
    This represents a baked transition
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_TwoWayBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (PoseLink):  [Read-Write]
    - ``alpha`` (float):  [Read-Write] The float value that controls the alpha blending when the alpha input type is set to 'Float'
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write] The boolean value that controls the alpha blending when the alpha input type is set to 'Bool'
    - ``alpha_curve_name`` (Name):  [Read-Write] The animation curve that controls the alpha blending when the alpha input type is set to 'Curve'
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write] The data type used to control the alpha blending between the A and B poses.
                    Note: Changing this value will disconnect alpha input pins.
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``always_update_children`` (bool):  [Read-Write] Always update children, regardless of whether or not that child has weight.
    - ``b`` (PoseLink):  [Read-Write]
    - ``reset_child_on_activation`` (bool):  [Read-Write] This reinitializes child pose when re-activated. For example, when active child changes
    """
    def __init__(self, a: PoseLink = [], b: PoseLink = [], alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000]) -> None:
        ...
    @property
    def a(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: PoseLink) -> None:
        ...
    @property
    def b(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: PoseLink) -> None:
        ...
    @property
    def alpha_input_type(self) -> AnimAlphaInputType:
        r"""
        (AnimAlphaInputType):  [Read-Write] The data type used to control the alpha blending between the A and B poses.
                      Note: Changing this value will disconnect alpha input pins.
        """
        ...
    @alpha_input_type.setter
    def alpha_input_type(self, value: AnimAlphaInputType) -> None:
        ...
    @property
    def alpha_bool_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] The boolean value that controls the alpha blending when the alpha input type is set to 'Bool'
        """
        ...
    @alpha_bool_enabled.setter
    def alpha_bool_enabled(self, value: bool) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write] The float value that controls the alpha blending when the alpha input type is set to 'Float'
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...
    @property
    def alpha_scale_bias(self) -> InputScaleBias:
        r"""
        (InputScaleBias):  [Read-Write]
        """
        ...
    @alpha_scale_bias.setter
    def alpha_scale_bias(self, value: InputScaleBias) -> None:
        ...
    @property
    def alpha_bool_blend(self) -> InputAlphaBoolBlend:
        r"""
        (InputAlphaBoolBlend):  [Read-Write]
        """
        ...
    @alpha_bool_blend.setter
    def alpha_bool_blend(self, value: InputAlphaBoolBlend) -> None:
        ...
    @property
    def alpha_curve_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The animation curve that controls the alpha blending when the alpha input type is set to 'Curve'
        """
        ...
    @alpha_curve_name.setter
    def alpha_curve_name(self, value: Name) -> None:
        ...
    @property
    def alpha_scale_bias_clamp(self) -> InputScaleBiasClamp:
        r"""
        (InputScaleBiasClamp):  [Read-Write]
        """
        ...
    @alpha_scale_bias_clamp.setter
    def alpha_scale_bias_clamp(self, value: InputScaleBiasClamp) -> None:
        ...

class AnimationNode_TwoWayBlend(AnimNode_TwoWayBlend):
    r"""
    deprecated: 'AnimationNode_TwoWayBlend' was renamed to 'AnimNode_TwoWayBlend'.
    """
    def __init__(self, a: PoseLink = [], b: PoseLink = [], alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000]) -> None:
        ...

class BlendListBaseReference(AnimNodeReference):
    r"""
    Blend List Base Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: BlendListBaseLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class BlendSpacePlayerReference(AnimNodeReference):
    r"""
    Blend Space Player Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: BlendSpacePlayerLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_AnimDynamics(AnimNode_SkeletalControlBase):
    r"""
    Anim Node Anim Dynamics
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_AnimDynamics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``angular_bias_override`` (float):  [Read-Write] Overridden angular bias value
      Angular bias is essentially a twist reduction for chain forces and defaults to a value to keep chains stability
      in check. When using single-body systems sometimes angular forces will look like they are "catching-up" with
      the mesh, if that's the case override this and push it towards 1.0f until it settles correctly
    - ``angular_damping_override`` (float):  [Read-Write] Overridden angular damping value. The default is 0.7. Values below 0.7 won't have an effect.
    - ``angular_spring`` (bool):  [Read-Write] If true the body will attempt to align itself with the specified angular target
    - ``angular_spring_constant`` (float):  [Read-Write] Spring constant to use when calculating angular springs, higher values mean a stronger spring.
      You need to enable the Angular Spring checkbox for this to have an effect.
      Note: Make sure to also set the Angular Target Axis and Angular Target in the Constraint Setup for this to have an effect.
    - ``bound_bone`` (BoneReference):  [Read-Write] The bone to attach the physics body to, if bChain is true this is the top of the chain
    - ``chain`` (bool):  [Read-Write] Set to true to use the solver to simulate a connected chain
    - ``chain_end`` (BoneReference):  [Read-Write] If bChain is true this is the bottom of the chain, otherwise ignored
    - ``component_applied_linear_acc_clamp`` (Vector):  [Read-Write] When using non-world-space sim, this is an overall clamp on acceleration derived from ComponentLinearAccScale and ComponentLinearVelScale, to ensure it is not too large.
    - ``component_linear_acc_scale`` (Vector):  [Read-Write] When using non-world-space sim, this controls how much of the components world-space acceleration is passed on to the local-space simulation.
    - ``component_linear_vel_scale`` (Vector):  [Read-Write] When using non-world-space sim, this applies a 'drag' to the bodies in the local space simulation, based on the components world-space velocity.
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``do_eval`` (bool):  [Read-Write] If true we will perform bone transform evaluation, otherwise skip - allows visualization of the initial anim state compared to the physics sim
    - ``do_update`` (bool):  [Read-Write] If true we will perform physics update, otherwise skip - allows visualization of the initial state of the bodies
    - ``enable_wind`` (bool):  [Read-Write] Whether or not wind is enabled for the bodies in this simulation
    - ``external_force`` (Vector):  [Read-Write] An external force to apply to all bodies in the simulation when ticked, specified in world space
    - ``gravity_override`` (Vector):  [Read-Write] Gravity Override Value
    - ``gravity_override_in_sim_space`` (bool):  [Read-Write] If true the gravity override value is defined in simulation space, by default it is in world space
    - ``gravity_scale`` (float):  [Read-Write] Scale for gravity, higher values increase forces due to gravity
    - ``linear_damping_override`` (float):  [Read-Write] Overridden linear damping value. The default is 0.7. Values below 0.7 won't have an effect.
    - ``linear_spring`` (bool):  [Read-Write] If true the body will attempt to spring back to its initial position
    - ``linear_spring_constant`` (float):  [Read-Write] Spring constant to use when calculating linear springs, higher values mean a stronger spring.
      You need to enable the Linear Spring checkbox for this to have an effect.
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``num_solver_iterations_post_update`` (int32):  [Read-Write] Number of update passes on the linear and angular limits after we solve the position of the bodies, recommended to be around a quarter of NumSolverIterationsPreUpdate
    - ``num_solver_iterations_pre_update`` (int32):  [Read-Write] Number of update passes on the linear and angular limits before we solve the position of the bodies recommended to be four times the value of NumSolverIterationsPostUpdate
    - ``override_angular_bias`` (bool):  [Read-Write] If true, the override value will be used for the angular bias for bodies in this node.
      Angular bias is essentially a twist reduction for chain forces and defaults to a value to keep chains stability
      in check. When using single-body systems sometimes angular forces will look like they are "catching-up" with
      the mesh, if that's the case override this and push it towards 1.0f until it settles correctly
    - ``override_angular_damping`` (bool):  [Read-Write] If true, the override value will be used for angular damping
    - ``override_linear_damping`` (bool):  [Read-Write] If true, the override value will be used for linear damping
    - ``physics_body_definitions`` (Array[AnimPhysBodyDefinition]):  [Read-Write]
    - ``planar_limits`` (Array[AnimPhysPlanarLimit]):  [Read-Write] List of available planar limits for this node
    - ``relative_space_bone`` (BoneReference):  [Read-Write] When in BoneRelative sim space, the simulation will use this bone as the origin
    - ``retargeting_settings`` (RotationRetargetingInfo):  [Read-Write] The settings for rotation retargeting
    - ``simulation_space`` (AnimPhysSimSpaceType):  [Read-Write] The space used to run the simulation
    - ``spherical_limits`` (Array[AnimPhysSphericalLimit]):  [Read-Write] List of available spherical limits for this node
    - ``use_gravity_override`` (bool):  [Read-Write] Use gravity override value vs gravity scale
    - ``use_planar_limit`` (bool):  [Read-Write] Whether to evaluate planar limits
    - ``use_spherical_limits`` (bool):  [Read-Write] Whether to evaluate spherical limits
    - ``wind_scale`` (float):  [Read-Write] Scale to apply to calculated wind velocities in the solver
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], linear_damping_override: float = 0.000000, angular_damping_override: float = 0.000000, gravity_scale: float = 0.000000, gravity_override: Vector = [0.000000, 0.000000, 0.000000], linear_spring_constant: float = 0.000000, angular_spring_constant: float = 0.000000, angular_bias_override: float = 0.000000, simulation_space: AnimPhysSimSpaceType = AnimPhysSimSpaceType.COMPONENT, use_gravity_override: bool = False) -> None:
        ...
    @property
    def linear_damping_override(self) -> float:
        r"""
        (float):  [Read-Write] Overridden linear damping value. The default is 0.7. Values below 0.7 won't have an effect.
        """
        ...
    @linear_damping_override.setter
    def linear_damping_override(self, value: float) -> None:
        ...
    @property
    def angular_damping_override(self) -> float:
        r"""
        (float):  [Read-Write] Overridden angular damping value. The default is 0.7. Values below 0.7 won't have an effect.
        """
        ...
    @angular_damping_override.setter
    def angular_damping_override(self, value: float) -> None:
        ...
    @property
    def gravity_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scale for gravity, higher values increase forces due to gravity
        """
        ...
    @gravity_scale.setter
    def gravity_scale(self, value: float) -> None:
        ...
    @property
    def gravity_override(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Gravity Override Value
        """
        ...
    @gravity_override.setter
    def gravity_override(self, value: Vector) -> None:
        ...
    @property
    def linear_spring_constant(self) -> float:
        r"""
        (float):  [Read-Write] Spring constant to use when calculating linear springs, higher values mean a stronger spring.
        You need to enable the Linear Spring checkbox for this to have an effect.
        """
        ...
    @linear_spring_constant.setter
    def linear_spring_constant(self, value: float) -> None:
        ...
    @property
    def angular_spring_constant(self) -> float:
        r"""
        (float):  [Read-Write] Spring constant to use when calculating angular springs, higher values mean a stronger spring.
        You need to enable the Angular Spring checkbox for this to have an effect.
        Note: Make sure to also set the Angular Target Axis and Angular Target in the Constraint Setup for this to have an effect.
        """
        ...
    @angular_spring_constant.setter
    def angular_spring_constant(self, value: float) -> None:
        ...
    @property
    def angular_bias_override(self) -> float:
        r"""
        (float):  [Read-Write] Overridden angular bias value
        Angular bias is essentially a twist reduction for chain forces and defaults to a value to keep chains stability
        in check. When using single-body systems sometimes angular forces will look like they are "catching-up" with
        the mesh, if that's the case override this and push it towards 1.0f until it settles correctly
        """
        ...
    @angular_bias_override.setter
    def angular_bias_override(self, value: float) -> None:
        ...
    @property
    def simulation_space(self) -> AnimPhysSimSpaceType:
        r"""
        (AnimPhysSimSpaceType):  [Read-Write] The space used to run the simulation
        """
        ...
    @simulation_space.setter
    def simulation_space(self, value: AnimPhysSimSpaceType) -> None:
        ...
    @property
    def use_gravity_override(self) -> bool:
        r"""
        (bool):  [Read-Write] Use gravity override value vs gravity scale
        """
        ...
    @use_gravity_override.setter
    def use_gravity_override(self, value: bool) -> None:
        ...

class AnimNode_ApplyLimits(AnimNode_SkeletalControlBase):
    r"""
    Anim Node Apply Limits
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_ApplyLimits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``angular_offsets`` (Array[Vector]):  [Read-Write]
    - ``angular_range_limits`` (Array[AngularRangeLimit]):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], angular_offsets: Array[Vector] = []) -> None:
        ...
    @property
    def angular_offsets(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Write]
        """
        ...
    @angular_offsets.setter
    def angular_offsets(self, value: Array[Vector]) -> None:
        ...

class AnimNode_BoneDrivenController(AnimNode_SkeletalControlBase):
    r"""
    This is the runtime version of a bone driven controller, which maps part of the state from one bone to another (e.g., 2 * source.x -> target.z)
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_BoneDrivenController.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affect_target_rotation_x`` (bool):  [Read-Write] Affect the X component of rotation on the target bone
    - ``affect_target_rotation_y`` (bool):  [Read-Write] Affect the Y component of rotation on the target bone
    - ``affect_target_rotation_z`` (bool):  [Read-Write] Affect the Z component of rotation on the target bone
    - ``affect_target_scale_x`` (bool):  [Read-Write] Affect the X component of scale on the target bone
    - ``affect_target_scale_y`` (bool):  [Read-Write] Affect the Y component of scale on the target bone
    - ``affect_target_scale_z`` (bool):  [Read-Write] Affect the Z component of scale on the target bone
    - ``affect_target_translation_x`` (bool):  [Read-Write] Affect the X component of translation on the target bone
    - ``affect_target_translation_y`` (bool):  [Read-Write] Affect the Y component of translation on the target bone
    - ``affect_target_translation_z`` (bool):  [Read-Write] Affect the Z component of translation on the target bone
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``destination_mode`` (DrivenDestinationMode):  [Read-Write] Type of destination to drive, currently either bone or morph target
    - ``driving_curve`` (CurveFloat):  [Read-Write] Curve used to map from the source attribute to the driven attributes if present (otherwise the Multiplier will be used)
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``modification_mode`` (DrivenBoneModificationMode):  [Read-Write] The type of modification to make to the destination component(s)
    - ``multiplier`` (float):  [Read-Write] Multiplier to apply to the input value (Note: Ignored when a curve is used)
    - ``parameter_name`` (Name):  [Read-Write] Name of Morph Target to drive using the source attribute
    - ``range_max`` (double):  [Read-Write] Maximum limit of the input value (mapped to RemappedMax, only used when limiting the source range)
      If this is rotation, the unit is radian
    - ``range_min`` (double):  [Read-Write] Minimum limit of the input value (mapped to RemappedMin, only used when limiting the source range)
      If this is rotation, the unit is radian
    - ``remapped_max`` (double):  [Read-Write] Maximum value to apply to the destination (remapped from the input range)
      If this is rotation, the unit is radian
    - ``remapped_min`` (double):  [Read-Write] Minimum value to apply to the destination (remapped from the input range)
      If this is rotation, the unit is radian
    - ``source_bone`` (BoneReference):  [Read-Write] Bone to use as controller input
    - ``source_component`` (ComponentType):  [Read-Write] Transform component to use as input
    - ``target_bone`` (BoneReference):  [Read-Write] Bone to drive using controller input
    - ``use_range`` (bool):  [Read-Write] Whether or not to clamp the driver value and remap it before scaling it
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000]) -> None:
        ...

class AnimNode_CCDIK(AnimNode_SkeletalControlBase):
    r"""
    Controller which implements the CCDIK IK approximation algorithm
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_CCDIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``effector_location`` (Vector):  [Read-Write] Coordinates for target location of tip bone - if EffectorLocationSpace is bone, this is the offset from Target Bone to use as target location
    - ``effector_location_space`` (BoneControlSpace):  [Read-Write] Reference frame of Effector Transform.
    - ``effector_target`` (BoneSocketTarget):  [Read-Write] If EffectorTransformSpace is a bone, this is the bone to use. *
    - ``enable_rotation_limit`` (bool):  [Read-Write] Tolerance for final tip location delta from EffectorLocation
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``max_iterations`` (int32):  [Read-Write] Maximum number of iterations allowed, to control performance.
    - ``precision`` (float):  [Read-Write] Tolerance for final tip location delta from EffectorLocation
    - ``root_bone`` (BoneReference):  [Read-Write] Name of the root bone
    - ``rotation_limit_per_joints`` (Array[float]):  [Read-Write] symmetry rotation limit per joint. Index 0 matches with root bone and last index matches with tip bone.
    - ``start_from_tail`` (bool):  [Read-Write] Toggle drawing of axes to debug joint rotation
    - ``tip_bone`` (BoneReference):  [Read-Write] Name of tip bone
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000]) -> None:
        ...

class AnimNode_Constraint(AnimNode_SkeletalControlBase):
    r"""
    Constraint node to parent or world transform for rotation/translation
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_Constraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``bone_to_modify`` (BoneReference):  [Read-Write] Name of bone to control. This is the main bone chain to modify from. *
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``constraint_setup`` (Array[Constraint]):  [Read-Write] List of constraints
    - ``constraint_weights`` (Array[float]):  [Read-Write] Weight data - post edit syncs up to ConstraintSetups
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000]) -> None:
        ...

class AnimNode_CopyBone(AnimNode_SkeletalControlBase):
    r"""
    Simple controller to copy a bone's transform to another one.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_CopyBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``control_space`` (BoneControlSpace):  [Read-Write] Space to convert transforms into prior to copying components
    - ``copy_rotation`` (bool):  [Read-Write] If Rotation should be copied
    - ``copy_scale`` (bool):  [Read-Write] If Scale should be copied
    - ``copy_translation`` (bool):  [Read-Write] If Translation should be copied
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``source_bone`` (BoneReference):  [Read-Write] Source Bone Name to get transform from
    - ``target_bone`` (BoneReference):  [Read-Write] Name of bone to control. This is the main bone chain to modify from. *
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], copy_translation: bool = False, copy_rotation: bool = False, copy_scale: bool = False) -> None:
        ...
    @property
    def copy_translation(self) -> bool:
        r"""
        (bool):  [Read-Write] If Translation should be copied
        """
        ...
    @copy_translation.setter
    def copy_translation(self, value: bool) -> None:
        ...
    @property
    def copy_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] If Rotation should be copied
        """
        ...
    @copy_rotation.setter
    def copy_rotation(self, value: bool) -> None:
        ...
    @property
    def copy_scale(self) -> bool:
        r"""
        (bool):  [Read-Write] If Scale should be copied
        """
        ...
    @copy_scale.setter
    def copy_scale(self, value: bool) -> None:
        ...

class AnimNode_CopyBoneDelta(AnimNode_SkeletalControlBase):
    r"""
    Simple controller to copy a transform relative to the ref pose to the target bone,
    instead of the copy bone node which copies the absolute transform
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_CopyBoneDelta.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``copy_mode`` (CopyBoneDeltaMode):  [Read-Write]
    - ``copy_rotation`` (bool):  [Read-Write]
    - ``copy_scale`` (bool):  [Read-Write]
    - ``copy_translation`` (bool):  [Read-Write]
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``rotation_multiplier`` (float):  [Read-Write]
    - ``scale_multiplier`` (float):  [Read-Write]
    - ``source_bone`` (BoneReference):  [Read-Write]
    - ``target_bone`` (BoneReference):  [Read-Write]
    - ``translation_multiplier`` (float):  [Read-Write]
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], copy_translation: bool = False, copy_rotation: bool = False, copy_scale: bool = False, translation_multiplier: float = 0.000000, rotation_multiplier: float = 0.000000, scale_multiplier: float = 0.000000) -> None:
        ...
    @property
    def copy_translation(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @copy_translation.setter
    def copy_translation(self, value: bool) -> None:
        ...
    @property
    def copy_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @copy_rotation.setter
    def copy_rotation(self, value: bool) -> None:
        ...
    @property
    def copy_scale(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @copy_scale.setter
    def copy_scale(self, value: bool) -> None:
        ...
    @property
    def translation_multiplier(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @translation_multiplier.setter
    def translation_multiplier(self, value: float) -> None:
        ...
    @property
    def rotation_multiplier(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @rotation_multiplier.setter
    def rotation_multiplier(self, value: float) -> None:
        ...
    @property
    def scale_multiplier(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale_multiplier.setter
    def scale_multiplier(self, value: float) -> None:
        ...

class AnimNode_Fabrik(AnimNode_SkeletalControlBase):
    r"""
    Controller which implements the FABRIK IK approximation algorithm -  see http://www.academia.edu/9165835/FABRIK_A_fast_iterative_solver_for_the_Inverse_Kinematics_problem for details
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_Fabrik.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``effector_rotation_source`` (BoneRotationSource):  [Read-Write]
    - ``effector_target`` (BoneSocketTarget):  [Read-Write] If EffectorTransformSpace is a bone, this is the bone to use. *
    - ``effector_transform`` (Transform):  [Read-Write] Coordinates for target location of tip bone - if EffectorLocationSpace is bone, this is the offset from Target Bone to use as target location
    - ``effector_transform_space`` (BoneControlSpace):  [Read-Write] Reference frame of Effector Transform.
    - ``enable_debug_draw`` (bool):  [Read-Write] Toggle drawing of axes to debug joint rotation
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``max_iterations`` (int32):  [Read-Write] Maximum number of iterations allowed, to control performance.
    - ``precision`` (float):  [Read-Write] Tolerance for final tip location delta from EffectorLocation
    - ``root_bone`` (BoneReference):  [Read-Write] Name of the root bone
    - ``tip_bone`` (BoneReference):  [Read-Write] Name of tip bone
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], effector_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def effector_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Coordinates for target location of tip bone - if EffectorLocationSpace is bone, this is the offset from Target Bone to use as target location
        """
        ...
    @effector_transform.setter
    def effector_transform(self, value: Transform) -> None:
        ...

class AnimNode_HandIKRetargeting(AnimNode_SkeletalControlBase):
    r"""
    Node to handle re-targeting of Hand IK bone chain.
    It looks at position in Mesh Space of Left and Right FK bones, and moves Left and Right IK bones to those.
    based on HandFKWeight. (0 = favor left hand, 1 = favor right hand, 0.5 = equal weight).
    This is used so characters of different proportions can handle the same props.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_HandIKRetargeting.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``hand_fk_weight`` (float):  [Read-Write] Which hand to favor. 0.5 is equal weight for both, 1 = right hand, 0 = left hand.
    - ``ik_bones_to_move`` (Array[BoneReference]):  [Read-Write] IK Bones to move.
    - ``left_hand_fk`` (BoneReference):  [Read-Write] Bone for Left Hand FK
    - ``left_hand_ik`` (BoneReference):  [Read-Write] Bone for Left Hand IK
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``per_axis_alpha`` (Vector):  [Read-Write] Alpha values per axis to apply on the resulting retargeting translation
    - ``right_hand_fk`` (BoneReference):  [Read-Write] Bone for Right Hand FK
    - ``right_hand_ik`` (BoneReference):  [Read-Write] Bone for Right Hand IK
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], per_axis_alpha: Vector = [0.000000, 0.000000, 0.000000], hand_fk_weight: float = 0.000000) -> None:
        ...
    @property
    def per_axis_alpha(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Alpha values per axis to apply on the resulting retargeting translation
        """
        ...
    @per_axis_alpha.setter
    def per_axis_alpha(self, value: Vector) -> None:
        ...
    @property
    def hand_fk_weight(self) -> float:
        r"""
        (float):  [Read-Write] Which hand to favor. 0.5 is equal weight for both, 1 = right hand, 0 = left hand.
        """
        ...
    @hand_fk_weight.setter
    def hand_fk_weight(self, value: float) -> None:
        ...

class AnimNode_LegIK(AnimNode_SkeletalControlBase):
    r"""
    Anim Node Leg IK
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_LegIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``legs_definition`` (Array[AnimLegIKDefinition]):  [Read-Write]
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``max_iterations`` (int32):  [Read-Write] Max Number of Iterations.
    - ``reach_precision`` (float):  [Read-Write] Tolerance for reaching IK Target, in unreal units.
    - ``soft_alpha`` (float):  [Read-Write] Default is 1.0 (full). Range is 0 to 1. Blends the effect of the "softness" on/off.
    - ``soft_percent_length`` (float):  [Read-Write] Default is 1.0 (off). Range is 0.1 to 1.0. When set to a value less than 1, will "softly" approach full extension starting when the effector
      distance from the root of the chain is greater than this percent length of the bone chain. Typical values are around 0.97.
      This is useful for preventing the knee from "popping" when approaching full extension.
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000]) -> None:
        ...

class AnimNode_LookAt(AnimNode_SkeletalControlBase):
    r"""
    Simple controller that make a bone to look at the point or another bone
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_LookAt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``bone_to_modify`` (BoneReference):  [Read-Write] Name of bone to control. This is the main bone chain to modify from. *
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``interpolation_time`` (float):  [Read-Write]
    - ``interpolation_trigger_threashold`` (float):  [Read-Write]
    - ``interpolation_type`` (InterpolationBlend):  [Read-Write]
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``look_at_axis`` (Axis):  [Read-Write]
    - ``look_at_clamp`` (float):  [Read-Write] Look at Clamp value in degrees - if your look at axis is Z, only X, Y degree of clamp will be used
    - ``look_at_location`` (Vector):  [Read-Write] Target Offset. It's in world space if LookAtBone is empty or it is based on LookAtBone or LookAtSocket in their local space
    - ``look_at_target`` (BoneSocketTarget):  [Read-Write] Target socket to look at. Used if LookAtBone is empty. - You can use  LookAtLocation if you need offset from this point. That location will be used in their local space. *
    - ``look_up_axis`` (Axis):  [Read-Write]
    - ``use_look_up_axis`` (bool):  [Read-Write] Whether or not to use Look up axis
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], look_at_location: Vector = [0.000000, 0.000000, 0.000000], interpolation_type: InterpolationBlend = InterpolationBlend.LINEAR, look_at_clamp: float = 0.000000, interpolation_time: float = 0.000000, interpolation_trigger_threashold: float = 0.000000) -> None:
        ...
    @property
    def look_at_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Target Offset. It's in world space if LookAtBone is empty or it is based on LookAtBone or LookAtSocket in their local space
        """
        ...
    @look_at_location.setter
    def look_at_location(self, value: Vector) -> None:
        ...
    @property
    def interpolation_type(self) -> InterpolationBlend:
        r"""
        (InterpolationBlend):  [Read-Write]
        """
        ...
    @interpolation_type.setter
    def interpolation_type(self, value: InterpolationBlend) -> None:
        ...
    @property
    def look_at_clamp(self) -> float:
        r"""
        (float):  [Read-Write] Look at Clamp value in degrees - if your look at axis is Z, only X, Y degree of clamp will be used
        """
        ...
    @look_at_clamp.setter
    def look_at_clamp(self, value: float) -> None:
        ...
    @property
    def interpolation_time(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interpolation_time.setter
    def interpolation_time(self, value: float) -> None:
        ...
    @property
    def interpolation_trigger_threashold(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interpolation_trigger_threashold.setter
    def interpolation_trigger_threashold(self, value: float) -> None:
        ...

class AnimNode_ObserveBone(AnimNode_SkeletalControlBase):
    r"""
    Debugging node that displays the current value of a bone in a specific space.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_ObserveBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``bone_to_observe`` (BoneReference):  [Read-Write] Name of bone to observe.
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``display_space`` (BoneControlSpace):  [Read-Write] Reference frame to display the bone transform in.
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``relative_to_ref_pose`` (bool):  [Read-Write] Show the difference from the reference pose?
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000]) -> None:
        ...

class AnimNode_ResetRoot(AnimNode_SkeletalControlBase):
    r"""
    Anim Node Reset Root
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_ResetRoot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000]) -> None:
        ...

class SimSpaceSettings(StructBase):
    r"""
    Sim Space Settings
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RigidBody.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``external_angular_velocity`` (Vector):  [Read-Write] Additional angular velocity that is added to the component angular velocity. This can be used to make the simulation act as if the actor is rotating
      even when it is not. E.g., to apply physics to a character on a podium as the camera rotates around it, to emulate the podium itself rotating.
      Vector is in world space. Units are rad/s.
    - ``external_linear_drag`` (float):  [Read-Write]
      deprecated: ExternalLinearDrag is deprecated. Please use ExternalLinearDragV instead.
    - ``external_linear_drag_v`` (Vector):  [Read-Write] Additional linear drag applied to every body in addition to linear drag specified on them in the physics asset.
      When combined with ExternalLinearVelocity, this can be used to add a temporary wind-blown effect without having to tune linear drag on
      all the bodies in the physics asset. The result is that each body has a force equal to -ExternalLinearDragV * ExternalLinearVelocity applied to it, in
      additional to all other forces. The vector is in simulation local space.
    - ``external_linear_velocity`` (Vector):  [Read-Write] Additional velocity that is added to the component velocity so the simulation acts as if the actor is moving at speed, even when stationary.
      Vector is in world space. Units are cm/s. Could be used for a wind effects etc. Typical values are similar to the velocity of the object or effect,
      and usually around or less than 1000 for characters/wind.
    - ``max_angular_acceleration`` (float):  [Read-Write] A clamp on the effective world-space angular accleration that is passed to the simulation. Units are radian/s/s. The default value effectively means "unlimited".
      This has a similar effect to MaxAngularVelocity, except that it is related to the flying out of bodies when the rotation speed suddenly changes. Typical limist for
      a character might be around 100.
    - ``max_angular_velocity`` (float):  [Read-Write] A clamp on the effective world-space angular velocity that is passed to the simulation. Units are radian/s, so a value of about 6.0 is one rotation per second.
      The default value effectively means "unlimited". You would reduce this (and MaxAngularAcceleration) to limit how much bodies "fly out" when the actor spins on the spot.
      This is especially useful if you have characters than can rotate very quickly and you would probably want values around or less than 10 in this case.
    - ``max_linear_acceleration`` (float):  [Read-Write] A clamp on the effective world-space acceleration that is passed to the simulation. Units are cm/s/s. The default value effectively means "unlimited".
      This property is used to stop the bodies of the simulation flying out when suddenly changing linear speed. It is useful when you have characters than can
      changes from stationary to running very quickly such as in an FPS. A common value for a character might be in the few hundreds.
    - ``max_linear_velocity`` (float):  [Read-Write] A clamp on the effective world-space velocity that is passed to the simulation. Units are cm/s. The default value effectively means "unlimited". It is not usually required to
      change this but you would reduce this to limit the effects of drag on the bodies in the simulation (if you have bodies that have LinearDrag set to non-zero in the physics asset).
      Expected values in this case would be somewhat less than the usual velocities of your object which is commonly a few hundred for a character.
    - ``velocity_scale_z`` (float):  [Read-Write] Multiplier on the Z-component of velocity and acceleration that is passed to the simulation. Usually from 0.0 to 1.0 to
      reduce the effects of jumping and crouching on the simulation, but it can be higher than 1.0 if you need to exaggerate this motion for some reason.
    - ``world_alpha`` (float):  [Read-Write] Global multipler on the effects of simulation space movement. Must be in range [0, 1]. If WorldAlpha = 0.0, the system is disabled and the simulation will
      be fully local (i.e., world-space actor movement and rotation does not affect the simulation). When WorldAlpha = 1.0 the simulation effectively acts as a
      world-space sim, but with the ability to apply limits using the other parameters.
    """
    def __init__(self, world_alpha: float = 0.000000, velocity_scale_z: float = 0.000000, max_linear_velocity: float = 0.000000, max_angular_velocity: float = 0.000000, max_linear_acceleration: float = 0.000000, max_angular_acceleration: float = 0.000000, external_linear_drag_v: Vector = [0.000000, 0.000000, 0.000000], external_linear_velocity: Vector = [0.000000, 0.000000, 0.000000], external_angular_velocity: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def world_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Global multipler on the effects of simulation space movement. Must be in range [0, 1]. If WorldAlpha = 0.0, the system is disabled and the simulation will
        be fully local (i.e., world-space actor movement and rotation does not affect the simulation). When WorldAlpha = 1.0 the simulation effectively acts as a
        world-space sim, but with the ability to apply limits using the other parameters.
        """
        ...
    @world_alpha.setter
    def world_alpha(self, value: float) -> None:
        ...
    @property
    def master_alpha(self) -> float:
        r"""
        deprecated: 'master_alpha' was renamed to 'world_alpha'.
        """
        ...
    @master_alpha.setter
    def master_alpha(self, value: float) -> None:
        ...
    @property
    def velocity_scale_z(self) -> float:
        r"""
        (float):  [Read-Write] Multiplier on the Z-component of velocity and acceleration that is passed to the simulation. Usually from 0.0 to 1.0 to
        reduce the effects of jumping and crouching on the simulation, but it can be higher than 1.0 if you need to exaggerate this motion for some reason.
        """
        ...
    @velocity_scale_z.setter
    def velocity_scale_z(self, value: float) -> None:
        ...
    @property
    def max_linear_velocity(self) -> float:
        r"""
        (float):  [Read-Write] A clamp on the effective world-space velocity that is passed to the simulation. Units are cm/s. The default value effectively means "unlimited". It is not usually required to
        change this but you would reduce this to limit the effects of drag on the bodies in the simulation (if you have bodies that have LinearDrag set to non-zero in the physics asset).
        Expected values in this case would be somewhat less than the usual velocities of your object which is commonly a few hundred for a character.
        """
        ...
    @max_linear_velocity.setter
    def max_linear_velocity(self, value: float) -> None:
        ...
    @property
    def max_angular_velocity(self) -> float:
        r"""
        (float):  [Read-Write] A clamp on the effective world-space angular velocity that is passed to the simulation. Units are radian/s, so a value of about 6.0 is one rotation per second.
        The default value effectively means "unlimited". You would reduce this (and MaxAngularAcceleration) to limit how much bodies "fly out" when the actor spins on the spot.
        This is especially useful if you have characters than can rotate very quickly and you would probably want values around or less than 10 in this case.
        """
        ...
    @max_angular_velocity.setter
    def max_angular_velocity(self, value: float) -> None:
        ...
    @property
    def max_linear_acceleration(self) -> float:
        r"""
        (float):  [Read-Write] A clamp on the effective world-space acceleration that is passed to the simulation. Units are cm/s/s. The default value effectively means "unlimited".
        This property is used to stop the bodies of the simulation flying out when suddenly changing linear speed. It is useful when you have characters than can
        changes from stationary to running very quickly such as in an FPS. A common value for a character might be in the few hundreds.
        """
        ...
    @max_linear_acceleration.setter
    def max_linear_acceleration(self, value: float) -> None:
        ...
    @property
    def max_angular_acceleration(self) -> float:
        r"""
        (float):  [Read-Write] A clamp on the effective world-space angular accleration that is passed to the simulation. Units are radian/s/s. The default value effectively means "unlimited".
        This has a similar effect to MaxAngularVelocity, except that it is related to the flying out of bodies when the rotation speed suddenly changes. Typical limist for
        a character might be around 100.
        """
        ...
    @max_angular_acceleration.setter
    def max_angular_acceleration(self, value: float) -> None:
        ...
    @property
    def external_linear_drag(self) -> float:
        r"""
        (float):  [Read-Write]
        deprecated: ExternalLinearDrag is deprecated. Please use ExternalLinearDragV instead.
        """
        ...
    @external_linear_drag.setter
    def external_linear_drag(self, value: float) -> None:
        ...
    @property
    def external_linear_drag_v(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Additional linear drag applied to every body in addition to linear drag specified on them in the physics asset.
        When combined with ExternalLinearVelocity, this can be used to add a temporary wind-blown effect without having to tune linear drag on
        all the bodies in the physics asset. The result is that each body has a force equal to -ExternalLinearDragV * ExternalLinearVelocity applied to it, in
        additional to all other forces. The vector is in simulation local space.
        """
        ...
    @external_linear_drag_v.setter
    def external_linear_drag_v(self, value: Vector) -> None:
        ...
    @property
    def external_linear_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Additional velocity that is added to the component velocity so the simulation acts as if the actor is moving at speed, even when stationary.
        Vector is in world space. Units are cm/s. Could be used for a wind effects etc. Typical values are similar to the velocity of the object or effect,
        and usually around or less than 1000 for characters/wind.
        """
        ...
    @external_linear_velocity.setter
    def external_linear_velocity(self, value: Vector) -> None:
        ...
    @property
    def external_angular_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Additional angular velocity that is added to the component angular velocity. This can be used to make the simulation act as if the actor is rotating
        even when it is not. E.g., to apply physics to a character on a podium as the camera rotates around it, to emulate the podium itself rotating.
        Vector is in world space. Units are rad/s.
        """
        ...
    @external_angular_velocity.setter
    def external_angular_velocity(self, value: Vector) -> None:
        ...

class AnimNode_RigidBody(AnimNode_SkeletalControlBase):
    r"""
    Controller that simulates physics based on the physics asset of the skeletal mesh component
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RigidBody.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``base_bone_ref`` (BoneReference):  [Read-Write] Matters if SimulationSpace is BaseBone
    - ``cached_bounds_scale`` (float):  [Read-Write] Scale of cached bounds (vs. actual bounds).
      Increasing this may improve performance, but overlaps may not work as well.
      (A value of 1.0 effectively disables cached bounds).
    - ``clamp_linear_translation_limit_to_ref_pose`` (bool):  [Read-Write] Correct for linear tearing on bodies with all axes Locked.
      This only works if all axes linear translation are locked
    - ``component_applied_linear_acc_clamp`` (Vector):  [Read-Write] When using non-world-space sim, this is an overall clamp on acceleration derived from ComponentLinearAccScale and ComponentLinearVelScale, to ensure it is not too large.
    - ``component_linear_acc_scale`` (Vector):  [Read-Write] When using non-world-space sim, this controls how much of the components world-space acceleration is passed on to the local-space simulation.
    - ``component_linear_vel_scale`` (Vector):  [Read-Write] When using non-world-space sim, this applies a 'drag' to the bodies in the local space simulation, based on the components world-space velocity.
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``default_to_skeletal_mesh_physics_asset`` (bool):  [Read-Write] Use the skeletal mesh physics asset as default in case set to True. The Override Physics Asset will always have priority over this.
    - ``enable_world_geometry`` (bool):  [Read-Write]
    - ``evaluation_reset_time`` (float):  [Read-Write] If the node is not evaluated for this amount of time (seconds), either because a lower LOD was in use for a while or the component was
      not visible, reset the simulation to the default pose on the next evaluation. Set to 0 to disable time-based reset.
    - ``external_force`` (Vector):  [Read-Write] Applies a uniform external force in world space. This allows for easily faking inertia of movement while still simulating in component space for example
    - ``force_disable_collision_between_constraint_bodies`` (bool):  [Read-Write] Whether to allow collisions between two bodies joined by a constraint
    - ``freeze_incoming_pose_on_start`` (bool):  [Read-Write] When simulation starts, freeze incoming pose.
      This is useful for ragdolls, when we want the simulation to take over.
      It prevents non simulated bones from animating.
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``overlap_channel`` (CollisionChannel):  [Read-Write] The channel we use to find static geometry to collide with
    - ``override_physics_asset`` (PhysicsAsset):  [Read-Write] Physics asset to use. If empty use the skeletal mesh's default physics asset in case Default To Skeletal Mesh Physics Asset is set to True.
    - ``override_world_gravity`` (Vector):  [Read-Write] Override gravity
    - ``override_world_gravity`` (bool):  [Read-Write]
    - ``sim_space_settings`` (SimSpaceSettings):  [Read-Write] Settings for the system which passes motion of the simulation's space
      into the simulation. This allows the simulation to pass a
      fraction of the world space motion onto the bodies which allows Bone-Space
      and Component-Space simulations to react to world-space movement in a
      controllable way.
      This system is a superset of the functionality provided by ComponentLinearAccScale,
      ComponentLinearVelScale, and ComponentAppliedLinearAccClamp. In general
      you should not have both systems enabled.
    - ``simulation_space`` (SimulationSpace):  [Read-Write] What space to simulate the bodies in. This affects how velocities are generated
    - ``simulation_timing`` (SimulationTiming):  [Read-Write] Whether the physics simulation runs synchronously with the node's evaluation or is run in the background until the next frame.
    - ``transfer_bone_velocities`` (bool):  [Read-Write] When simulation starts, transfer previous bone velocities (from animation)
      to make transition into simulation seamless.
    - ``use_external_cloth_collision`` (bool):  [Read-Write] If true, kinematic objects will be added to the simulation at runtime to represent any cloth colliders defined for the parent object.
    - ``use_local_lod_threshold_only`` (bool):  [Read-Write] Enable if you want to ignore the p.RigidBodyLODThreshold CVAR and force the node to solely use the LOD threshold.
    - ``world_space_minimum_scale`` (float):  [Read-Write] For world-space simulations, if the magnitude of the component's 3D scale is less than WorldSpaceMinimumScale, do not update the node.
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], use_local_lod_threshold_only: bool = False) -> None:
        ...
    @property
    def use_local_lod_threshold_only(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable if you want to ignore the p.RigidBodyLODThreshold CVAR and force the node to solely use the LOD threshold.
        """
        ...
    @use_local_lod_threshold_only.setter
    def use_local_lod_threshold_only(self, value: bool) -> None:
        ...

class AnimNode_Ragdoll(AnimNode_RigidBody):
    r"""
    deprecated: 'AnimNode_Ragdoll' was renamed to 'AnimNode_RigidBody'.
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], use_local_lod_threshold_only: bool = False) -> None:
        ...

class AnimNode_ScaleChainLength(AnimNode_Base):
    r"""
    Scale the length of a chain of bones.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_ScaleChainLength.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``chain_end_bone`` (BoneReference):  [Read-Write]
    - ``chain_initial_length`` (ScaleChainInitialLength):  [Read-Write]
    - ``chain_start_bone`` (BoneReference):  [Read-Write]
    - ``default_chain_length`` (float):  [Read-Write] Default chain length, as animated.
    - ``input_pose`` (PoseLink):  [Read-Write]
    - ``target_location`` (Vector):  [Read-Write]
    """
    def __init__(self, default_chain_length: float = 0.000000, target_location: Vector = [0.000000, 0.000000, 0.000000], alpha: float = 0.000000) -> None:
        ...
    @property
    def default_chain_length(self) -> float:
        r"""
        (float):  [Read-Write] Default chain length, as animated.
        """
        ...
    @default_chain_length.setter
    def default_chain_length(self, value: float) -> None:
        ...
    @property
    def target_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @target_location.setter
    def target_location(self, value: Vector) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...

class AnimNode_SplineIK(AnimNode_SkeletalControlBase):
    r"""
    Anim Node Spline IK
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_SplineIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``auto_calculate_spline`` (bool):  [Read-Write] The number of points in the spline if we are specifying it directly
    - ``bone_axis`` (SplineBoneAxis):  [Read-Write] Axis of the controlled bone (ie the direction of the spline) to use as the direction for the curve.
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``control_points`` (Array[Transform]):  [Read-Write] Transforms applied to spline points *
    - ``end_bone`` (BoneReference):  [Read-Write] Name of bone at the end of the spline chain. Bones after this will not be altered by the controller.
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``offset`` (float):  [Read-Write] The distance along the spline from the start from which bones are constrained
    - ``point_count`` (int32):  [Read-Write] The number of points in the spline if we are not auto-calculating
    - ``roll`` (float):  [Read-Write] Overall roll of the spline, applied on top of other rotations along the direction of the spline
    - ``start_bone`` (BoneReference):  [Read-Write] Name of root bone from which the spline extends *
    - ``stretch`` (float):  [Read-Write] The maximum stretch allowed when fitting bones to the spline. 0.0 means bones do not stretch their length,
      1.0 means bones stretch to the length of the spline
    - ``twist_blend`` (AlphaBlend):  [Read-Write] How to interpolate twist along the length of the spline
    - ``twist_end`` (float):  [Read-Write] The twist of the end bone. Twist is interpolated along the spline according to Twist Blend.
    - ``twist_start`` (float):  [Read-Write] The twist of the start bone. Twist is interpolated along the spline according to Twist Blend.
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], control_points: Array[Transform] = [], roll: float = 0.000000, twist_start: float = 0.000000, twist_end: float = 0.000000, stretch: float = 0.000000, offset: float = 0.000000) -> None:
        ...
    @property
    def control_points(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write] Transforms applied to spline points *
        """
        ...
    @control_points.setter
    def control_points(self, value: Array[Transform]) -> None:
        ...
    @property
    def roll(self) -> float:
        r"""
        (float):  [Read-Write] Overall roll of the spline, applied on top of other rotations along the direction of the spline
        """
        ...
    @roll.setter
    def roll(self, value: float) -> None:
        ...
    @property
    def twist_start(self) -> float:
        r"""
        (float):  [Read-Write] The twist of the start bone. Twist is interpolated along the spline according to Twist Blend.
        """
        ...
    @twist_start.setter
    def twist_start(self, value: float) -> None:
        ...
    @property
    def twist_end(self) -> float:
        r"""
        (float):  [Read-Write] The twist of the end bone. Twist is interpolated along the spline according to Twist Blend.
        """
        ...
    @twist_end.setter
    def twist_end(self, value: float) -> None:
        ...
    @property
    def stretch(self) -> float:
        r"""
        (float):  [Read-Write] The maximum stretch allowed when fitting bones to the spline. 0.0 means bones do not stretch their length,
        1.0 means bones stretch to the length of the spline
        """
        ...
    @stretch.setter
    def stretch(self, value: float) -> None:
        ...
    @property
    def offset(self) -> float:
        r"""
        (float):  [Read-Write] The distance along the spline from the start from which bones are constrained
        """
        ...
    @offset.setter
    def offset(self, value: float) -> None:
        ...

class AnimNode_SpringBone(AnimNode_SkeletalControlBase):
    r"""
    Simple controller that replaces or adds to the translation/rotation of a single bone.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_SpringBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``error_reset_thresh`` (double):  [Read-Write] If spring stretches more than this, reset it. Useful for catching teleports etc
    - ``limit_displacement`` (bool):  [Read-Write] Limit the amount that a bone can stretch from its ref-pose length.
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``max_displacement`` (double):  [Read-Write] If bLimitDisplacement is true, this indicates how long a bone can stretch beyond its length in the ref-pose.
    - ``rotate_x`` (bool):  [Read-Write] If true take the spring calculation for rotation in X
    - ``rotate_y`` (bool):  [Read-Write] If true take the spring calculation for rotation in Y
    - ``rotate_z`` (bool):  [Read-Write] If true take the spring calculation for rotation in Z
    - ``spring_bone`` (BoneReference):  [Read-Write] Name of bone to control. This is the main bone chain to modify from. *
    - ``spring_damping`` (double):  [Read-Write] Damping of spring
    - ``spring_stiffness`` (double):  [Read-Write] Stiffness of spring
    - ``translate_x`` (bool):  [Read-Write] If true take the spring calculation for translation in X
    - ``translate_y`` (bool):  [Read-Write] If true take the spring calculation for translation in Y
    - ``translate_z`` (bool):  [Read-Write] If true take the spring calculation for translation in Z
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], max_displacement: float = 0.000000) -> None:
        ...
    @property
    def max_displacement(self) -> float:
        r"""
        (double):  [Read-Write] If bLimitDisplacement is true, this indicates how long a bone can stretch beyond its length in the ref-pose.
        """
        ...
    @max_displacement.setter
    def max_displacement(self, value: float) -> None:
        ...

class AnimNode_Trail(AnimNode_SkeletalControlBase):
    r"""
    Trail Controller
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_Trail.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_space_fake_vel`` (bool):  [Read-Write] Whether 'fake' velocity should be applied in actor or world space.
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``base_joint`` (BoneReference):  [Read-Write] Base Joint to calculate velocity from. If none, it will use Component's World Transform. .
    - ``chain_bone_axis`` (AxisType):  [Read-Write] Axis of the bones to point along trail.
    - ``chain_length`` (int32):  [Read-Write] Number of bones above the active one in the hierarchy to modify. ChainLength should be at least 2.
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``debug_life_time`` (float):  [Read-Write] Debug Life Time
    - ``enable_debug`` (bool):  [Read-Write] Enable Debug in the PIE. This doesn't work in game
    - ``fake_velocity`` (Vector):  [Read-Write] 'Fake' velocity applied to bones.
    - ``invert_chain_bone_axis`` (bool):  [Read-Write] Invert the direction specified in ChainBoneAxis.
    - ``last_bone_rotation_anim_alpha_blend`` (float):  [Read-Write] How to set last bone rotation. It copies from previous joint if alpha is 0.f, or 1.f will use animated pose
             * This alpha dictates the blend between parent joint and animated pose, and how much you'd like to use animated pose for
    - ``limit_rotation`` (bool):  [Read-Write] Limit the amount that a bone can stretch from its ref-pose length.
    - ``limit_stretch`` (bool):  [Read-Write] Limit the amount that a bone can stretch from its ref-pose length.
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``max_delta_time`` (float):  [Read-Write] To avoid hitches causing stretch of trail, you can use MaxDeltaTime to clamp the long delta time. If you want 30 fps to set it to 0.03333f ( = 1/30 ).
    - ``planar_limits`` (Array[AnimPhysPlanarLimit]):  [Read-Write] List of available planar limits for this node
    - ``relaxation_speed_scale`` (float):  [Read-Write]
    - ``relaxation_speed_scale_input_processor`` (InputScaleBiasClamp):  [Read-Write]
    - ``reorient_parent_to_child`` (bool):  [Read-Write] Fix up rotation to face child for the parent
    - ``rotation_limits`` (Array[RotationLimit]):  [Read-Write]
    - ``rotation_offsets`` (Array[Vector]):  [Read-Write]
    - ``show_base_motion`` (bool):  [Read-Write] Show Base Motion
    - ``show_limit`` (bool):  [Read-Write] Show Planar Limits *
    - ``show_trail_location`` (bool):  [Read-Write] Show Trail Location *
    - ``stretch_limit`` (float):  [Read-Write] If bLimitStretch is true, this indicates how long a bone can stretch beyond its length in the ref-pose.
    - ``trail_bone`` (BoneReference):  [Read-Write] Reference to the active bone in the hierarchy to modify.
    - ``trail_relaxation_speed`` (RuntimeFloatCurve):  [Read-Write] How quickly we 'relax' the bones to their animated positions. Time 0 will map to top root joint, time 1 will map to the bottom joint.
    - ``use_planar_limit`` (bool):  [Read-Write] Whether to evaluate planar limits
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], relaxation_speed_scale: float = 0.000000, relaxation_speed_scale_input_processor: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], rotation_offsets: Array[Vector] = []) -> None:
        ...
    @property
    def relaxation_speed_scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @relaxation_speed_scale.setter
    def relaxation_speed_scale(self, value: float) -> None:
        ...
    @property
    def relaxation_speed_scale_input_processor(self) -> InputScaleBiasClamp:
        r"""
        (InputScaleBiasClamp):  [Read-Write]
        """
        ...
    @relaxation_speed_scale_input_processor.setter
    def relaxation_speed_scale_input_processor(self, value: InputScaleBiasClamp) -> None:
        ...
    @property
    def rotation_offsets(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Write]
        """
        ...
    @rotation_offsets.setter
    def rotation_offsets(self, value: Array[Vector]) -> None:
        ...

class AnimNode_TwistCorrectiveNode(AnimNode_SkeletalControlBase):
    r"""
    This is the node that apply corrective morphtarget for twist
    Good example is that if you twist your neck too far right or left, you're going to see odd stretch shape of neck,
    This node can detect the angle and apply morphtarget curve
    This isn't the twist control node for bone twist
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_TwistCorrectiveNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``base_frame`` (ReferenceBoneFrame):  [Read-Write] Base Frame of the reference for the twist node
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``curve_name`` (Name):  [Read-Write]
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``range_max`` (float):  [Read-Write] Maximum limit of the input value (mapped to RemappedMax, only used when limiting the source range)
      We can't go more than 180 right now because this is dot product driver
    - ``remapped_max`` (float):  [Read-Write] Maximum value to apply to the destination (remapped from the input range)
    - ``remapped_min`` (float):  [Read-Write] Minimum value to apply to the destination (remapped from the input range)
    - ``twist_frame`` (ReferenceBoneFrame):  [Read-Write] Transform component to use as input
    - ``twist_plane_normal_axis`` (Axis):  [Read-Write] Normal of the Plane that we'd like to calculate angle calculation from in BaseFrame. Please note we're looking for Normal Axis
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000]) -> None:
        ...

class AnimNode_TwoBoneIK(AnimNode_SkeletalControlBase):
    r"""
    Simple 2 Bone IK Controller.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_TwoBoneIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_stretching`` (bool):  [Read-Write] Should stretching be allowed, to be prevent over extension
    - ``allow_twist`` (bool):  [Read-Write] Whether or not to apply twist on the chain of joints. This clears the twist value along the TwistAxis
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write] Input link
    - ``effector_location`` (Vector):  [Read-Write] Effector Location. Target Location to reach.
    - ``effector_location_space`` (BoneControlSpace):  [Read-Write] Reference frame of Effector Location.
    - ``effector_target`` (BoneSocketTarget):  [Read-Write]
    - ``ik_bone`` (BoneReference):  [Read-Write] Name of bone to control. This is the main bone chain to modify from. *
    - ``joint_target`` (BoneSocketTarget):  [Read-Write]
    - ``joint_target_location`` (Vector):  [Read-Write] Joint Target Location. Location used to orient Joint bone. *
    - ``joint_target_location_space`` (BoneControlSpace):  [Read-Write] Reference frame of Joint Target Location.
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``maintain_effector_rel_rot`` (bool):  [Read-Write] Keep local rotation of end bone
    - ``max_stretch_scale`` (double):  [Read-Write] Limits to use if stretching is allowed. This value determins what is the max stretch scale. For example, 1.5 means it will stretch until 150 % of the whole length of the limb.
    - ``start_stretch_ratio`` (double):  [Read-Write] Limits to use if stretching is allowed. This value determines when to start stretch. For example, 0.9 means once it reaches 90% of the whole length of the limb, it will start apply.
    - ``take_rotation_from_effector_space`` (bool):  [Read-Write] Set end bone to use End Effector rotation
    - ``twist_axis`` (Axis):  [Read-Write] Specify which axis it's aligned. Used when removing twist
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = [], lod_threshold: int = 0, alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], effector_location: Vector = [0.000000, 0.000000, 0.000000], joint_target_location: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def effector_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Effector Location. Target Location to reach.
        """
        ...
    @effector_location.setter
    def effector_location(self, value: Vector) -> None:
        ...
    @property
    def joint_target_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Joint Target Location. Location used to orient Joint bone. *
        """
        ...
    @joint_target_location.setter
    def joint_target_location(self, value: Vector) -> None:
        ...

class IKFootPelvisPullDownSolver(StructBase):
    r"""
    IKFoot Pelvis Pull Down Solver
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: BoneControllerSolvers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``pelvis_adjustment_error_tolerance`` (double):  [Read-Write] Specifies the pelvis adjustment distance error that is tolerated for each iteration of the solver
      
      When it is detected that the pelvis adjustment distance is incrementing at a value lower or equal
      to this value for each iteration, the solve will halt. Lower values will marginally increase visual
      quality at the cost of performance, but may require a higher PelvisAdjustmentMaxIter to be specified
      
      The default value of 0.01 specifies 1 centimeter of error
    - ``pelvis_adjustment_interp`` (VectorRK4SpringInterpolator):  [Read-Write] Specifies the spring interpolation parameters applied during pelvis adjustment
    - ``pelvis_adjustment_interp_alpha`` (double):  [Read-Write] Specifies an alpha between the original and final adjusted pelvis locations
      This is used to retain some degree of the original pelvis motion
    - ``pelvis_adjustment_max_distance`` (double):  [Read-Write] Specifies the maximum displacement the pelvis can be adjusted relative to its original location
    - ``pelvis_adjustment_max_iter`` (int32):  [Read-Write] Specifies the maximum number of iterations to run for the pelvis adjustment solver
      Higher iterations will guarantee closer PelvisAdjustmentErrorTolerance convergence at the cost of performance
    """
    def __init__(self) -> None:
        ...

class WarpingVectorValue(StructBase):
    r"""
    Vector values which may be specified in a configured space
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: BoneControllerTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``mode`` (WarpingVectorMode):  [Read-Write] Space of the corresponding Vector value
    - ``value`` (Vector):  [Read-Write] Specifies a vector relative to the space defined by Mode
    """
    def __init__(self, mode: WarpingVectorMode = WarpingVectorMode.COMPONENT_SPACE_VECTOR, value: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def mode(self) -> WarpingVectorMode:
        r"""
        (WarpingVectorMode):  [Read-Write] Space of the corresponding Vector value
        """
        ...
    @mode.setter
    def mode(self, value: WarpingVectorMode) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Specifies a vector relative to the space defined by Mode
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...

class LayeredBoneBlendReference(AnimNodeReference):
    r"""
    Layered Bone Blend Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: LayeredBoneBlendLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class LinkedAnimGraphReference(AnimNodeReference):
    r"""
    Linked Anim Graph Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: LinkedAnimGraphLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class MirrorAnimNodeReference(AnimNodeReference):
    r"""
    Mirror Anim Node Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: MirrorAnimLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class ModifyCurveAnimNodeReference(AnimNodeReference):
    r"""
    Modify Curve Anim Node Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: ModifyCurveLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class SequenceEvaluatorReference(AnimNodeReference):
    r"""
    Sequence Evaluator Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: SequenceEvaluatorLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class SequencePlayerReference(AnimNodeReference):
    r"""
    Sequence Player Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: SequencePlayerLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class SkeletalControlReference(AnimNodeReference):
    r"""
    Skeletal Control Reference
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: SkeletalControlLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class MovieSceneCameraShakeSourceTrigger(StructBase):
    r"""
    Movie Scene Camera Shake Source Trigger
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCameraShakeSourceTriggerChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``play_scale`` (float):  [Read-Write] Scalar that affects shake intensity
    - ``play_space`` (CameraShakePlaySpace):  [Read-Write]
    - ``shake_class`` (type(Class)):  [Read-Write] Class of the camera shake to play
    - ``user_defined_play_space`` (Rotator):  [Read-Write]
    """
    def __init__(self, shake_class: Class = None, play_scale: float = 0.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_defined_play_space: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def shake_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Class of the camera shake to play
        """
        ...
    @shake_class.setter
    def shake_class(self, value: Class) -> None:
        ...
    @property
    def play_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scalar that affects shake intensity
        """
        ...
    @play_scale.setter
    def play_scale(self, value: float) -> None:
        ...
    @property
    def play_space(self) -> CameraShakePlaySpace:
        r"""
        (CameraShakePlaySpace):  [Read-Write]
        """
        ...
    @play_space.setter
    def play_space(self, value: CameraShakePlaySpace) -> None:
        ...
    @property
    def user_defined_play_space(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @user_defined_play_space.setter
    def user_defined_play_space(self, value: Rotator) -> None:
        ...

class MovieSceneEventPayloadVariable(StructBase):
    r"""
    Value definition for any type-agnostic variable (exported as text)
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEvent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MovieSceneEventPtrs(StructBase):
    r"""
    Compiled reflection pointers for the event function and parameters
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEvent.h
    
    """
    def __init__(self) -> None:
        ...

class MovieSceneEvent(StructBase):
    r"""
    Movie Scene Event
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEvent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bound_object_pin_name`` (Name):  [Read-Write]
    - ``payload_variables`` (Map[Name, MovieSceneEventPayloadVariable]):  [Read-Write] Array of payload variables to be added to the generated function
    - ``weak_endpoint`` (Object):  [Read-Write] Serialized weak pointer to the function entry (UK2Node_FunctionEntry) or custom event node (UK2Node_CustomEvent) within the blueprint graph for this event. Stored as an editor-only UObject so UHT can parse it when building for non-editor.
    """
    def __init__(self) -> None:
        ...
    def get_bound_object_property_class(self) -> Class:
        r"""
        x.get_bound_object_property_class() -> type(Class)
        * Return the class of the bound object property
        *
        *
        
        Returns:
            type(Class): The class of the bound object property
        """
        ...

class MovieSceneObjectBindingID(StructBase):
    r"""
    Persistent identifier to a specific object binding within a sequence hierarchy.
    
    Binding IDs come in 3 flavors with Local and External being preferred as they are reslilient towards sequences being authored in isolation or included in other root sequences:
        Local: (ResolveParentIndex == 0) SequenceID relates to _this sequence's_ local hierarchy; represents an object binding within the same sequence as the ID is resolved, or inside one of its sub-sequences. Sequence ID must be remapped at runtime.
        External: (ResolveParentIndex > 0) SequenceID is local to the parent sequence of this one denoted by the parent index (ie, 1 = parent, 2 = grandparent etc). Sequence ID must be remapped at runtime.
        Fixed: Represents a binding anywhere in the sequence; always resolved from the root sequence.
    
    Fixed bindings will break if the sequence is evaluated inside a different root sequence.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneObjectBindingID.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``guid`` (Guid):  [Read-Write] Identifier for the object binding within the sequence
    """
    def __init__(self) -> None:
        ...

class MovieSceneObjectBindingPtr(MovieSceneObjectBindingID):
    r"""
    deprecated: 'MovieSceneObjectBindingPtr' was renamed to 'MovieSceneObjectBindingID'.
    """
    def __init__(self) -> None:
        ...

class EventPayload(StructBase):
    r"""
    Event Payload
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEventSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``event_name`` (Name):  [Read-Write] The name of the event to trigger
    - ``parameters`` (MovieSceneEventParameters):  [Read-Write] The event parameters
    """
    def __init__(self, event_name: Name = "None", parameters: MovieSceneEventParameters = []) -> None:
        ...
    @property
    def event_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the event to trigger
        """
        ...
    @event_name.setter
    def event_name(self, value: Name) -> None:
        ...
    @property
    def parameters(self) -> MovieSceneEventParameters:
        r"""
        (MovieSceneEventParameters):  [Read-Only] The event parameters
        """
        ...

class MovieSceneEventParameters(StructBase):
    r"""
    Movie Scene Event Parameters
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEventSection.h
    
    """
    def __init__(self) -> None:
        ...

class MaterialParameterInfo(StructBase):
    r"""
    Material Parameter Info
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``association`` (MaterialParameterAssociation):  [Read-Write] Whether this is a global parameter, or part of a layer or blend
    - ``index`` (int32):  [Read-Write] Layer or blend index this parameter is part of. INDEX_NONE for global parameters.
    - ``name`` (Name):  [Read-Write]
    """
    def __init__(self, name: Name = "None", association: MaterialParameterAssociation = MaterialParameterAssociation.LAYER_PARAMETER, index: int = 0) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def association(self) -> MaterialParameterAssociation:
        r"""
        (MaterialParameterAssociation):  [Read-Write] Whether this is a global parameter, or part of a layer or blend
        """
        ...
    @association.setter
    def association(self, value: MaterialParameterAssociation) -> None:
        ...
    @property
    def index(self) -> int:
        r"""
        (int32):  [Read-Write] Layer or blend index this parameter is part of. INDEX_NONE for global parameters.
        """
        ...
    @index.setter
    def index(self, value: int) -> None:
        ...

class MovieSceneSkeletalAnimationParams(StructBase):
    r"""
    Movie Scene Skeletal Animation Params
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneSkeletalAnimationSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animation`` (AnimSequenceBase):  [Read-Write] The animation this section plays
    - ``end_frame_offset`` (FrameNumber):  [Read-Write] The offset into the end of the animation clip
    - ``first_loop_start_frame_offset`` (FrameNumber):  [Read-Write] The offset into the beginning of the animation clip for the first loop of play.
    - ``force_custom_mode`` (bool):  [Read-Write] If on animation sequence will always play when active even if the animation is controlled by a Blueprint or Anim Instance Class
    - ``mirror_data_table`` (MirrorDataTable):  [Read-Write]
    - ``play_rate`` (float):  [Read-Write] The playback rate of the animation clip
    - ``reverse`` (bool):  [Read-Write] Reverse the playback of the animation clip
    - ``skip_anim_notifiers`` (bool):  [Read-Write] If on will skip sending animation notifies
    - ``slot_name`` (Name):  [Read-Write] The slot name to use for the animation
    - ``start_frame_offset`` (FrameNumber):  [Read-Write] The offset into the beginning of the animation clip
    - ``swap_root_bone`` (SwapRootBone):  [Read-Write] If on the root bone transform will be swapped to the specified root
    """
    def __init__(self, animation: AnimSequenceBase = None, first_loop_start_frame_offset: FrameNumber = [0], start_frame_offset: FrameNumber = [0], end_frame_offset: FrameNumber = [0], play_rate: float = 0.000000, reverse: bool = False, slot_name: Name = "None", mirror_data_table: MirrorDataTable = None, skip_anim_notifiers: bool = False, force_custom_mode: bool = False, swap_root_bone: SwapRootBone = SwapRootBone.SWAP_ROOT_BONE_COMPONENT) -> None:
        ...
    @property
    def animation(self) -> AnimSequenceBase:
        r"""
        (AnimSequenceBase):  [Read-Write] The animation this section plays
        """
        ...
    @animation.setter
    def animation(self, value: AnimSequenceBase) -> None:
        ...
    @property
    def first_loop_start_frame_offset(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] The offset into the beginning of the animation clip for the first loop of play.
        """
        ...
    @first_loop_start_frame_offset.setter
    def first_loop_start_frame_offset(self, value: FrameNumber) -> None:
        ...
    @property
    def start_frame_offset(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] The offset into the beginning of the animation clip
        """
        ...
    @start_frame_offset.setter
    def start_frame_offset(self, value: FrameNumber) -> None:
        ...
    @property
    def end_frame_offset(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] The offset into the end of the animation clip
        """
        ...
    @end_frame_offset.setter
    def end_frame_offset(self, value: FrameNumber) -> None:
        ...
    @property
    def play_rate(self) -> float:
        r"""
        (float):  [Read-Write] The playback rate of the animation clip
        """
        ...
    @play_rate.setter
    def play_rate(self, value: float) -> None:
        ...
    @property
    def reverse(self) -> bool:
        r"""
        (bool):  [Read-Write] Reverse the playback of the animation clip
        """
        ...
    @reverse.setter
    def reverse(self, value: bool) -> None:
        ...
    @property
    def slot_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The slot name to use for the animation
        """
        ...
    @slot_name.setter
    def slot_name(self, value: Name) -> None:
        ...
    @property
    def mirror_data_table(self) -> MirrorDataTable:
        r"""
        (MirrorDataTable):  [Read-Write]
        """
        ...
    @mirror_data_table.setter
    def mirror_data_table(self, value: MirrorDataTable) -> None:
        ...
    @property
    def skip_anim_notifiers(self) -> bool:
        r"""
        (bool):  [Read-Write] If on will skip sending animation notifies
        """
        ...
    @skip_anim_notifiers.setter
    def skip_anim_notifiers(self, value: bool) -> None:
        ...
    @property
    def force_custom_mode(self) -> bool:
        r"""
        (bool):  [Read-Write] If on animation sequence will always play when active even if the animation is controlled by a Blueprint or Anim Instance Class
        """
        ...
    @force_custom_mode.setter
    def force_custom_mode(self, value: bool) -> None:
        ...
    @property
    def swap_root_bone(self) -> SwapRootBone:
        r"""
        (SwapRootBone):  [Read-Write] If on the root bone transform will be swapped to the specified root
        """
        ...
    @swap_root_bone.setter
    def swap_root_bone(self, value: SwapRootBone) -> None:
        ...

class ComponentMaterialInfo(StructBase):
    r"""
    Contains what is necessary to uniquely identify a material on a component, whether that be an indexed material, one with a slot name, or an overlay material.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneMaterialTrack.h
    
    """
    def __init__(self) -> None:
        ...

class TimedDataChannelSampleTime(StructBase):
    r"""
    Timed Data Channel Sample Time
    
    **C++ Source:**
    
    - **Module**: TimeManagement
    - **File**: ITimedDataInput.h
    
    """
    def __init__(self) -> None:
        ...

class TimedDataInputEvaluationData(StructBase):
    r"""
    Timed Data Input Evaluation Data
    
    **C++ Source:**
    
    - **Module**: TimeManagement
    - **File**: ITimedDataInput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_to_newest_sample_seconds`` (float):  [Read-Write] Distance between evaluation time and newest sample in seconds
    - ``distance_to_oldest_sample_seconds`` (float):  [Read-Write] Distance between evaluation time and newest sample in seconds
    """
    def __init__(self, distance_to_newest_sample_seconds: float = 0.000000, distance_to_oldest_sample_seconds: float = 0.000000) -> None:
        ...
    @property
    def distance_to_newest_sample_seconds(self) -> float:
        r"""
        (float):  [Read-Write] Distance between evaluation time and newest sample in seconds
        """
        ...
    @distance_to_newest_sample_seconds.setter
    def distance_to_newest_sample_seconds(self, value: float) -> None:
        ...
    @property
    def distance_to_oldest_sample_seconds(self) -> float:
        r"""
        (float):  [Read-Write] Distance between evaluation time and newest sample in seconds
        """
        ...
    @distance_to_oldest_sample_seconds.setter
    def distance_to_oldest_sample_seconds(self, value: float) -> None:
        ...

class ActorForWorldTransforms(StructBase):
    r"""
    Description of an actor selected parts we can find world transforms on
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: ActorForWorldTransforms.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor`` (Actor):  [Read-Write]
    - ``component`` (SceneComponent):  [Read-Write]
    - ``socket_name`` (Name):  [Read-Write]
    """
    def __init__(self, actor: Actor = None, component: SceneComponent = None, socket_name: Name = "None") -> None:
        ...
    @property
    def actor(self) -> Actor:
        r"""
        (Actor):  [Read-Write]
        """
        ...
    @actor.setter
    def actor(self, value: Actor) -> None:
        ...
    @property
    def component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Write]
        """
        ...
    @component.setter
    def component(self, value: SceneComponent) -> None:
        ...
    @property
    def socket_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @socket_name.setter
    def socket_name(self, value: Name) -> None:
        ...

class MovieSceneSectionParameters(StructBase):
    r"""
    namespace UE::MovieScene
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSectionParameters.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_loop`` (bool):  [Read-Write] Whether this section supports looping the sub-sequence.
    - ``end_frame_offset`` (FrameNumber):  [Read-Write] Number of frames (in display rate) to skip at the beginning of the sub-sequence.
    - ``first_loop_start_frame_offset`` (FrameNumber):  [Read-Write] Number of frames (in display rate) to offset the first loop of the sub-sequence.
    - ``flags`` (MovieSceneSubSectionFlags):  [Read-Write] Sub-section flags defining how to deal with this sub-sequence
    - ``hierarchical_bias`` (int32):  [Read-Write] Hierachical bias. Higher bias will take precedence.
    - ``start_frame_offset`` (FrameNumber):  [Read-Write] Number of frames (in display rate) to skip at the beginning of the sub-sequence.
    - ``time_scale`` (float):  [Read-Write] Playback time scaling factor.
    """
    def __init__(self, start_frame_offset: FrameNumber = [0], can_loop: bool = False, end_frame_offset: FrameNumber = [0], first_loop_start_frame_offset: FrameNumber = [0], time_scale: float = 0.000000, hierarchical_bias: int = 0, flags: MovieSceneSubSectionFlags = MovieSceneSubSectionFlags.NONE) -> None:
        ...
    @property
    def start_frame_offset(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] Number of frames (in display rate) to skip at the beginning of the sub-sequence.
        """
        ...
    @start_frame_offset.setter
    def start_frame_offset(self, value: FrameNumber) -> None:
        ...
    @property
    def can_loop(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this section supports looping the sub-sequence.
        """
        ...
    @can_loop.setter
    def can_loop(self, value: bool) -> None:
        ...
    @property
    def end_frame_offset(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] Number of frames (in display rate) to skip at the beginning of the sub-sequence.
        """
        ...
    @end_frame_offset.setter
    def end_frame_offset(self, value: FrameNumber) -> None:
        ...
    @property
    def first_loop_start_frame_offset(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] Number of frames (in display rate) to offset the first loop of the sub-sequence.
        """
        ...
    @first_loop_start_frame_offset.setter
    def first_loop_start_frame_offset(self, value: FrameNumber) -> None:
        ...
    @property
    def time_scale(self) -> float:
        r"""
        (float):  [Read-Write] Playback time scaling factor.
        """
        ...
    @time_scale.setter
    def time_scale(self, value: float) -> None:
        ...
    @property
    def hierarchical_bias(self) -> int:
        r"""
        (int32):  [Read-Write] Hierachical bias. Higher bias will take precedence.
        """
        ...
    @hierarchical_bias.setter
    def hierarchical_bias(self, value: int) -> None:
        ...
    @property
    def flags(self) -> MovieSceneSubSectionFlags:
        r"""
        (MovieSceneSubSectionFlags):  [Read-Write] Sub-section flags defining how to deal with this sub-sequence
        """
        ...
    @flags.setter
    def flags(self, value: MovieSceneSubSectionFlags) -> None:
        ...

class MovieSceneSequenceLoopCount(StructBase):
    r"""
    POD struct that represents a number of loops where -1 signifies infinite looping, 0 means no loops, etc
    Defined as a struct rather than an int so a property type customization can be bound to it
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSequencePlaybackSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (int32):  [Read-Write] Whether or not to loop playback. If Loop Exactly is chosen, you can specify the number of times to loop
    """
    def __init__(self, value: int = 0) -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Write] Whether or not to loop playback. If Loop Exactly is chosen, you can specify the number of times to loop
        """
        ...
    @value.setter
    def value(self, value: int) -> None:
        ...

class MovieSceneSequencePlaybackSettings(StructBase):
    r"""
    Settings for the level sequence player actor.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSequencePlaybackSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_play`` (bool):  [Read-Write] Auto-play the sequence when created
    - ``disable_camera_cuts`` (bool):  [Read-Write] Disable camera cuts
    - ``disable_look_at_input`` (bool):  [Read-Write] Disable LookAt Input from player during play
    - ``disable_movement_input`` (bool):  [Read-Write] Disable Input from player during play
    - ``dynamic_weighting`` (bool):  [Read-Write] Whether to enable dynamic weighting on this player or not
    - ``finish_completion_state_override`` (MovieSceneCompletionModeOverride):  [Read-Write] If set to something other than none, when a sequence ends, the completion mode of any track sections still active will be overridden
            * by the chosen value, either keep state or restore state. Otherwise, completion mode will be determined by each track section.
            * Note that any track sections that finish before the end of a sequence will have their completion mode determined by the section settings rather than this override.
    - ``hide_hud`` (bool):  [Read-Write] Hide HUD during play
    - ``hide_player`` (bool):  [Read-Write] Hide Player Pawn during play
    - ``inherit_tick_interval_from_owner`` (bool):  [Read-Write] When checked, a custom tick interval can be provided to define how often to update this sequence
    - ``loop_count`` (MovieSceneSequenceLoopCount):  [Read-Write] Number of times to loop playback. -1 for infinite, else the number of times to loop before stopping
    - ``pause_at_end`` (bool):  [Read-Write] Pause the sequence when playback reaches the end rather than stopping it
    - ``play_rate`` (float):  [Read-Write] The rate at which to playback the animation
    - ``random_start_time`` (bool):  [Read-Write] Start playback at a random time
    - ``restore_state`` (bool):  [Read-Write] Flag used to specify whether actor states should be restored on stop.
      This has been deprecated in favor of FinishCompletionStateOverride.
      deprecated: Use Settings.FinishCompletionStateOverride instead
    - ``start_time`` (float):  [Read-Write] Start playback at the specified offset from the start of the sequence's playback range
    - ``tick_interval`` (MovieSceneSequenceTickInterval):  [Read-Write] Overridable tick interval for this sequence to update at. When not overridden, the owning actor or component's tick interval will be used
    """
    def __init__(self, auto_play: bool = False, loop_count: MovieSceneSequenceLoopCount = [0], play_rate: float = 0.000000, start_time: float = 0.000000, random_start_time: bool = False, disable_movement_input: bool = False, disable_look_at_input: bool = False, hide_player: bool = False, hide_hud: bool = False, disable_camera_cuts: bool = False, finish_completion_state_override: MovieSceneCompletionModeOverride = MovieSceneCompletionModeOverride.NONE, pause_at_end: bool = False) -> None:
        ...
    @property
    def auto_play(self) -> bool:
        r"""
        (bool):  [Read-Write] Auto-play the sequence when created
        """
        ...
    @auto_play.setter
    def auto_play(self, value: bool) -> None:
        ...
    @property
    def loop_count(self) -> MovieSceneSequenceLoopCount:
        r"""
        (MovieSceneSequenceLoopCount):  [Read-Write] Number of times to loop playback. -1 for infinite, else the number of times to loop before stopping
        """
        ...
    @loop_count.setter
    def loop_count(self, value: MovieSceneSequenceLoopCount) -> None:
        ...
    @property
    def play_rate(self) -> float:
        r"""
        (float):  [Read-Write] The rate at which to playback the animation
        """
        ...
    @play_rate.setter
    def play_rate(self, value: float) -> None:
        ...
    @property
    def start_time(self) -> float:
        r"""
        (float):  [Read-Write] Start playback at the specified offset from the start of the sequence's playback range
        """
        ...
    @start_time.setter
    def start_time(self, value: float) -> None:
        ...
    @property
    def random_start_time(self) -> bool:
        r"""
        (bool):  [Read-Write] Start playback at a random time
        """
        ...
    @random_start_time.setter
    def random_start_time(self, value: bool) -> None:
        ...
    @property
    def restore_state(self) -> bool:
        r"""
        (bool):  [Read-Write] Flag used to specify whether actor states should be restored on stop.
        This has been deprecated in favor of FinishCompletionStateOverride.
        deprecated: Use Settings.FinishCompletionStateOverride instead
        """
        ...
    @restore_state.setter
    def restore_state(self, value: bool) -> None:
        ...
    @property
    def disable_movement_input(self) -> bool:
        r"""
        (bool):  [Read-Write] Disable Input from player during play
        """
        ...
    @disable_movement_input.setter
    def disable_movement_input(self, value: bool) -> None:
        ...
    @property
    def disable_look_at_input(self) -> bool:
        r"""
        (bool):  [Read-Write] Disable LookAt Input from player during play
        """
        ...
    @disable_look_at_input.setter
    def disable_look_at_input(self, value: bool) -> None:
        ...
    @property
    def hide_player(self) -> bool:
        r"""
        (bool):  [Read-Write] Hide Player Pawn during play
        """
        ...
    @hide_player.setter
    def hide_player(self, value: bool) -> None:
        ...
    @property
    def hide_hud(self) -> bool:
        r"""
        (bool):  [Read-Write] Hide HUD during play
        """
        ...
    @hide_hud.setter
    def hide_hud(self, value: bool) -> None:
        ...
    @property
    def disable_camera_cuts(self) -> bool:
        r"""
        (bool):  [Read-Write] Disable camera cuts
        """
        ...
    @disable_camera_cuts.setter
    def disable_camera_cuts(self, value: bool) -> None:
        ...
    @property
    def finish_completion_state_override(self) -> MovieSceneCompletionModeOverride:
        r"""
        (MovieSceneCompletionModeOverride):  [Read-Write] If set to something other than none, when a sequence ends, the completion mode of any track sections still active will be overridden
              * by the chosen value, either keep state or restore state. Otherwise, completion mode will be determined by each track section.
              * Note that any track sections that finish before the end of a sequence will have their completion mode determined by the section settings rather than this override.
        """
        ...
    @finish_completion_state_override.setter
    def finish_completion_state_override(self, value: MovieSceneCompletionModeOverride) -> None:
        ...
    @property
    def pause_at_end(self) -> bool:
        r"""
        (bool):  [Read-Write] Pause the sequence when playback reaches the end rather than stopping it
        """
        ...
    @pause_at_end.setter
    def pause_at_end(self, value: bool) -> None:
        ...

class LevelSequencePlaybackSettings(MovieSceneSequencePlaybackSettings):
    r"""
    deprecated: 'LevelSequencePlaybackSettings' was renamed to 'MovieSceneSequencePlaybackSettings'.
    """
    def __init__(self, auto_play: bool = False, loop_count: MovieSceneSequenceLoopCount = [0], play_rate: float = 0.000000, start_time: float = 0.000000, random_start_time: bool = False, disable_movement_input: bool = False, disable_look_at_input: bool = False, hide_player: bool = False, hide_hud: bool = False, disable_camera_cuts: bool = False, finish_completion_state_override: MovieSceneCompletionModeOverride = MovieSceneCompletionModeOverride.NONE, pause_at_end: bool = False) -> None:
        ...

class MovieSceneSequenceTickInterval(StructBase):
    r"""
    Structure defining a concrete tick interval for a Sequencer based evaluation
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSequenceTickInterval.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_rounding`` (bool):  [Read-Write] When true, allow the sequence to be grouped with other sequences based on Sequencer.TickIntervalGroupingResolutionMs. Otherwise the interval will be used precisely.
    - ``evaluation_budget_microseconds`` (float):  [Read-Write] Defines an approximate budget for evaluation of this sequence (and any other sequences with the same tick interval)
    - ``tick_interval_seconds`` (float):  [Read-Write] Defines the rate at which the sequence should update, in seconds
    - ``tick_when_paused`` (bool):  [Read-Write] When true, the sequence will continue to tick and progress even when the world is paused
    """
    def __init__(self) -> None:
        ...

class OptionalMovieSceneBlendType(StructBase):
    r"""
    Optional blend type structure
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneBlendType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_type`` (MovieSceneBlendType):  [Read-Write] The actual blend type
    - ``is_valid`` (bool):  [Read-Write] Boolean indicating whether BlendType is valid
    """
    def __init__(self, blend_type: MovieSceneBlendType = 0, is_valid: bool = False) -> None:
        ...
    @property
    def blend_type(self) -> MovieSceneBlendType:
        r"""
        (MovieSceneBlendType):  [Read-Only] The actual blend type
        """
        ...
    @property
    def is_valid(self) -> bool:
        r"""
        (bool):  [Read-Only] Boolean indicating whether BlendType is valid
        """
        ...

class MovieSceneMarkedFrame(StructBase):
    r"""
    Movie Scene Marked Frame
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneMarkedFrame.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``comment`` (str):  [Read-Write]
    - ``frame_number`` (FrameNumber):  [Read-Write]
    - ``is_determinism_fence`` (bool):  [Read-Write] When checked, treat this mark as a fence for evaluation purposes. Fences cannot be crossed in a single evaluation, and force the evaluation to be split into 2 separate parts.
    - ``label`` (str):  [Read-Write]
    """
    def __init__(self, frame_number: FrameNumber = [0], label: str = "", is_determinism_fence: bool = False) -> None:
        ...
    @property
    def frame_number(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write]
        """
        ...
    @frame_number.setter
    def frame_number(self, value: FrameNumber) -> None:
        ...
    @property
    def label(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @label.setter
    def label(self, value: str) -> None:
        ...
    @property
    def is_determinism_fence(self) -> bool:
        r"""
        (bool):  [Read-Write] When checked, treat this mark as a fence for evaluation purposes. Fences cannot be crossed in a single evaluation, and force the evaluation to be split into 2 separate parts.
        """
        ...
    @is_determinism_fence.setter
    def is_determinism_fence(self, value: bool) -> None:
        ...

class MovieSceneDynamicBindingPayloadVariable(StructBase):
    r"""
    Value definition for any type-agnostic variable (exported as text)
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneDynamicBinding.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MovieSceneDynamicBindingResolveParams(StructBase):
    r"""
    Optional parameter struct for dynamic binding resolver functions.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneDynamicBinding.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``object_binding_id`` (Guid):  [Read-Write] The ID of the object binding being resolved
    - ``root_sequence`` (MovieSceneSequence):  [Read-Write] The root sequence
    - ``sequence`` (MovieSceneSequence):  [Read-Write] The sequence that contains the object binding being resolved
    """
    def __init__(self, sequence: MovieSceneSequence = None, object_binding_id: Guid = [], root_sequence: MovieSceneSequence = None) -> None:
        ...
    @property
    def sequence(self) -> MovieSceneSequence:
        r"""
        (MovieSceneSequence):  [Read-Write] The sequence that contains the object binding being resolved
        """
        ...
    @sequence.setter
    def sequence(self, value: MovieSceneSequence) -> None:
        ...
    @property
    def object_binding_id(self) -> Guid:
        r"""
        (Guid):  [Read-Write] The ID of the object binding being resolved
        """
        ...
    @object_binding_id.setter
    def object_binding_id(self, value: Guid) -> None:
        ...
    @property
    def root_sequence(self) -> MovieSceneSequence:
        r"""
        (MovieSceneSequence):  [Read-Write] The root sequence
        """
        ...
    @root_sequence.setter
    def root_sequence(self, value: MovieSceneSequence) -> None:
        ...

class MovieSceneDynamicBindingResolveResult(StructBase):
    r"""
    Movie Scene Dynamic Binding Resolve Result
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneDynamicBinding.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_possessed_object`` (bool):  [Read-Write] Whether the resolved object is external to the sequence
      
      This property is ignored for possessables, who are always treated as external.
      When resolving a spawnable, setting this to true will not destroy the object
      when the spawnable track ends, or the sequence finishes.
    - ``object`` (Object):  [Read-Write] The resolved object
    """
    def __init__(self, object: Object = None, is_possessed_object: bool = False) -> None:
        ...
    @property
    def object(self) -> Object:
        r"""
        (Object):  [Read-Write] The resolved object
        """
        ...
    @object.setter
    def object(self, value: Object) -> None:
        ...
    @property
    def is_possessed_object(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the resolved object is external to the sequence
        
        This property is ignored for possessables, who are always treated as external.
        When resolving a spawnable, setting this to true will not destroy the object
        when the spawnable track ends, or the sequence finishes.
        """
        ...
    @is_possessed_object.setter
    def is_possessed_object(self, value: bool) -> None:
        ...

class MovieSceneTimecodeSource(StructBase):
    r"""
    Movie Scene Timecode Source
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``timecode`` (Timecode):  [Read-Write] The global timecode at which this target is based (ie. the timecode at the beginning of the movie scene section when it was recorded)
    """
    def __init__(self, timecode: Timecode = [0, 0, 0, 0, False]) -> None:
        ...
    @property
    def timecode(self) -> Timecode:
        r"""
        (Timecode):  [Read-Only] The global timecode at which this target is based (ie. the timecode at the beginning of the movie scene section when it was recorded)
        """
        ...

class MovieSceneSequencePlaybackParams(StructBase):
    r"""
    Movie Scene Sequence Playback Params
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSequencePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame`` (FrameTime):  [Read-Write]
    - ``has_jumped`` (bool):  [Read-Write]
    - ``marked_frame`` (str):  [Read-Write]
    - ``position_type`` (MovieScenePositionType):  [Read-Write]
    - ``time`` (float):  [Read-Write]
    - ``timecode`` (Timecode):  [Read-Write]
    - ``update_method`` (UpdatePositionMethod):  [Read-Write]
    """
    def __init__(self, frame: FrameTime = [[0], 0.000000], time: float = 0.000000, marked_frame: str = "", timecode: Timecode = [0, 0, 0, 0, False], position_type: MovieScenePositionType = MovieScenePositionType.FRAME, update_method: UpdatePositionMethod = UpdatePositionMethod.PLAY, has_jumped: bool = False) -> None:
        ...
    @property
    def frame(self) -> FrameTime:
        r"""
        (FrameTime):  [Read-Write]
        """
        ...
    @frame.setter
    def frame(self, value: FrameTime) -> None:
        ...
    @property
    def time(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @time.setter
    def time(self, value: float) -> None:
        ...
    @property
    def marked_frame(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @marked_frame.setter
    def marked_frame(self, value: str) -> None:
        ...
    @property
    def timecode(self) -> Timecode:
        r"""
        (Timecode):  [Read-Write]
        """
        ...
    @timecode.setter
    def timecode(self, value: Timecode) -> None:
        ...
    @property
    def position_type(self) -> MovieScenePositionType:
        r"""
        (MovieScenePositionType):  [Read-Write]
        """
        ...
    @position_type.setter
    def position_type(self, value: MovieScenePositionType) -> None:
        ...
    @property
    def update_method(self) -> UpdatePositionMethod:
        r"""
        (UpdatePositionMethod):  [Read-Write]
        """
        ...
    @update_method.setter
    def update_method(self, value: UpdatePositionMethod) -> None:
        ...
    @property
    def has_jumped(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @has_jumped.setter
    def has_jumped(self, value: bool) -> None:
        ...

class MovieSceneSequencePlayToParams(StructBase):
    r"""
    Movie Scene Sequence Play to Params
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSequencePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``exclusive`` (bool):  [Read-Write] Should the PlayTo time be considered exclusive? Defaults to true as end frames in Sequencer are exclusive by default.
    """
    def __init__(self, exclusive: bool = False) -> None:
        ...
    @property
    def exclusive(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the PlayTo time be considered exclusive? Defaults to true as end frames in Sequencer are exclusive by default.
        """
        ...
    @exclusive.setter
    def exclusive(self, value: bool) -> None:
        ...

class MediaPlayerTrackOptions(StructBase):
    r"""
    Media Player Track Options
    
    **C++ Source:**
    
    - **Module**: MediaUtils
    - **File**: MediaPlayerOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio`` (int32):  [Read-Write]
    - ``caption`` (int32):  [Read-Write]
    - ``metadata`` (int32):  [Read-Write]
    - ``script`` (int32):  [Read-Write]
    - ``subtitle`` (int32):  [Read-Write]
    - ``text`` (int32):  [Read-Write]
    - ``video`` (int32):  [Read-Write]
    """
    def __init__(self, audio: int = 0, caption: int = 0, metadata: int = 0, script: int = 0, subtitle: int = 0, text: int = 0, video: int = 0) -> None:
        ...
    @property
    def audio(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @audio.setter
    def audio(self, value: int) -> None:
        ...
    @property
    def caption(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @caption.setter
    def caption(self, value: int) -> None:
        ...
    @property
    def metadata(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @metadata.setter
    def metadata(self, value: int) -> None:
        ...
    @property
    def script(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @script.setter
    def script(self, value: int) -> None:
        ...
    @property
    def subtitle(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @subtitle.setter
    def subtitle(self, value: int) -> None:
        ...
    @property
    def text(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @text.setter
    def text(self, value: int) -> None:
        ...
    @property
    def video(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @video.setter
    def video(self, value: int) -> None:
        ...

class MediaPlayerOptions(StructBase):
    r"""
    Media Player Options
    
    **C++ Source:**
    
    - **Module**: MediaUtils
    - **File**: MediaPlayerOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``loop`` (MediaPlayerOptionBooleanOverride):  [Read-Write] How to initially select looping of the media.
    - ``play_on_open`` (MediaPlayerOptionBooleanOverride):  [Read-Write] How to handle automatic playback when media opens.
    - ``seek_time`` (Timespan):  [Read-Write] Initial media time to start playback at.
    - ``seek_time_type`` (MediaPlayerOptionSeekTimeType):  [Read-Write] How to interpret the initial seek time.
    - ``track_selection`` (MediaPlayerOptionTrackSelectMode):  [Read-Write] How the initial media tracks for playback are selected
    - ``tracks`` (MediaPlayerTrackOptions):  [Read-Write] Indices of the media tracks to select for playback
    """
    def __init__(self, tracks: MediaPlayerTrackOptions = [0, -1, -1, -1, -1, -1, 0], track_selection: MediaPlayerOptionTrackSelectMode = MediaPlayerOptionTrackSelectMode.USE_MEDIA_PLAYER_DEFAULTS, seek_time: Timespan = [0, 0, 0, 0, 0], seek_time_type: MediaPlayerOptionSeekTimeType = MediaPlayerOptionSeekTimeType.IGNORED, play_on_open: MediaPlayerOptionBooleanOverride = MediaPlayerOptionBooleanOverride.USE_MEDIA_PLAYER_SETTING, loop: MediaPlayerOptionBooleanOverride = MediaPlayerOptionBooleanOverride.USE_MEDIA_PLAYER_SETTING) -> None:
        ...
    @property
    def tracks(self) -> MediaPlayerTrackOptions:
        r"""
        (MediaPlayerTrackOptions):  [Read-Write] Indices of the media tracks to select for playback
        """
        ...
    @tracks.setter
    def tracks(self, value: MediaPlayerTrackOptions) -> None:
        ...
    @property
    def track_selection(self) -> MediaPlayerOptionTrackSelectMode:
        r"""
        (MediaPlayerOptionTrackSelectMode):  [Read-Write] How the initial media tracks for playback are selected
        """
        ...
    @track_selection.setter
    def track_selection(self, value: MediaPlayerOptionTrackSelectMode) -> None:
        ...
    @property
    def seek_time(self) -> Timespan:
        r"""
        (Timespan):  [Read-Write] Initial media time to start playback at.
        """
        ...
    @seek_time.setter
    def seek_time(self, value: Timespan) -> None:
        ...
    @property
    def seek_time_type(self) -> MediaPlayerOptionSeekTimeType:
        r"""
        (MediaPlayerOptionSeekTimeType):  [Read-Write] How to interpret the initial seek time.
        """
        ...
    @seek_time_type.setter
    def seek_time_type(self, value: MediaPlayerOptionSeekTimeType) -> None:
        ...
    @property
    def play_on_open(self) -> MediaPlayerOptionBooleanOverride:
        r"""
        (MediaPlayerOptionBooleanOverride):  [Read-Write] How to handle automatic playback when media opens.
        """
        ...
    @play_on_open.setter
    def play_on_open(self, value: MediaPlayerOptionBooleanOverride) -> None:
        ...
    @property
    def loop(self) -> MediaPlayerOptionBooleanOverride:
        r"""
        (MediaPlayerOptionBooleanOverride):  [Read-Write] How to initially select looping of the media.
        """
        ...
    @loop.setter
    def loop(self, value: MediaPlayerOptionBooleanOverride) -> None:
        ...

class SubmixEffectDynamicProcessorFilterSettings(StructBase):
    r"""
    Submix Effect Dynamic Processor Filter Settings
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectDynamicsProcessor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cutoff`` (float):  [Read-Write] The cutoff frequency of the HPF applied to key signal
    - ``enabled`` (bool):  [Read-Write] Whether or not filter is enabled
    - ``gain_db`` (float):  [Read-Write] The gain of the filter shelf applied to the key signal
    """
    def __init__(self, enabled: bool = False, cutoff: float = 0.000000, gain_db: float = 0.000000) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not filter is enabled
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def cutoff(self) -> float:
        r"""
        (float):  [Read-Write] The cutoff frequency of the HPF applied to key signal
        """
        ...
    @cutoff.setter
    def cutoff(self, value: float) -> None:
        ...
    @property
    def gain_db(self) -> float:
        r"""
        (float):  [Read-Write] The gain of the filter shelf applied to the key signal
        """
        ...
    @gain_db.setter
    def gain_db(self, value: float) -> None:
        ...

class SubmixEffectDynamicsProcessorSettings(StructBase):
    r"""
    Submix dynamics processor settings
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectDynamicsProcessor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``analog_mode`` (bool):  [Read-Write] Toggles treating the attack and release envelopes as analog-style vs digital-style (Analog will respond a bit more naturally/slower)
    - ``attack_time_msec`` (float):  [Read-Write] The amount of time to ramp into any dynamics processing effect
    - ``bypass`` (bool):  [Read-Write] Whether or not to bypass effect
    - ``dynamics_processor_type`` (SubmixEffectDynamicsProcessorType):  [Read-Write] Type of processor to apply
    - ``external_audio_bus`` (AudioBus):  [Read-Write] If set, uses output of provided audio bus as modulator of input signal for dynamics processor (Uses input signal as default modulator)
    - ``external_submix`` (SoundSubmix):  [Read-Write] If set, uses output of provided submix as modulator of input signal for dynamics processor (Uses input signal as default modulator)
    - ``input_gain_db`` (float):  [Read-Write] The input gain of the dynamics processor
    - ``key_audition`` (bool):  [Read-Write] Audition the key modulation signal, bypassing enveloping and processing the input signal.
    - ``key_gain_db`` (float):  [Read-Write] Gain to apply to key signal if key source not set to default (input).
    - ``key_highshelf`` (SubmixEffectDynamicProcessorFilterSettings):  [Read-Write] High Shelf filter settings for key signal (external signal if supplied or input signal if not)
    - ``key_lowshelf`` (SubmixEffectDynamicProcessorFilterSettings):  [Read-Write] Low Shelf filter settings for key signal (external signal if supplied or input signal if not)
    - ``key_source`` (SubmixEffectDynamicsKeySource):  [Read-Write]
    - ``knee_bandwidth_db`` (float):  [Read-Write] The knee bandwidth of the processor to use
    - ``link_mode`` (SubmixEffectDynamicsChannelLinkMode):  [Read-Write] Mode of peak detection if key signal is multi-channel
    - ``look_ahead_msec`` (float):  [Read-Write] The amount of time to look ahead of the current audio (Allows for transients to be included in dynamics processing)
    - ``output_gain_db`` (float):  [Read-Write] The output gain of the dynamics processor
    - ``peak_mode`` (SubmixEffectDynamicsPeakMode):  [Read-Write] Mode of peak detection used on input key signal
    - ``ratio`` (float):  [Read-Write] The dynamics processor ratio used for compression/expansion
    - ``release_time_msec`` (float):  [Read-Write] The amount of time to release the dynamics processing effect
    - ``threshold_db`` (float):  [Read-Write] The threshold at which to perform a dynamics processing operation
    """
    def __init__(self, dynamics_processor_type: SubmixEffectDynamicsProcessorType = SubmixEffectDynamicsProcessorType.COMPRESSOR, peak_mode: SubmixEffectDynamicsPeakMode = SubmixEffectDynamicsPeakMode.MEAN_SQUARED, link_mode: SubmixEffectDynamicsChannelLinkMode = SubmixEffectDynamicsChannelLinkMode.DISABLED, input_gain_db: float = 0.000000, threshold_db: float = 0.000000, ratio: float = 0.000000, knee_bandwidth_db: float = 0.000000, look_ahead_msec: float = 0.000000, attack_time_msec: float = 0.000000, release_time_msec: float = 0.000000, key_source: SubmixEffectDynamicsKeySource = SubmixEffectDynamicsKeySource.DEFAULT, external_audio_bus: AudioBus = None, external_submix: SoundSubmix = None, analog_mode: bool = False, bypass: bool = False, key_audition: bool = False, key_gain_db: float = 0.000000, output_gain_db: float = 0.000000, key_highshelf: SubmixEffectDynamicProcessorFilterSettings = [False, 20.000000, 0.000000], key_lowshelf: SubmixEffectDynamicProcessorFilterSettings = [False, 20.000000, 0.000000]) -> None:
        ...
    @property
    def dynamics_processor_type(self) -> SubmixEffectDynamicsProcessorType:
        r"""
        (SubmixEffectDynamicsProcessorType):  [Read-Write] Type of processor to apply
        """
        ...
    @dynamics_processor_type.setter
    def dynamics_processor_type(self, value: SubmixEffectDynamicsProcessorType) -> None:
        ...
    @property
    def peak_mode(self) -> SubmixEffectDynamicsPeakMode:
        r"""
        (SubmixEffectDynamicsPeakMode):  [Read-Write] Mode of peak detection used on input key signal
        """
        ...
    @peak_mode.setter
    def peak_mode(self, value: SubmixEffectDynamicsPeakMode) -> None:
        ...
    @property
    def link_mode(self) -> SubmixEffectDynamicsChannelLinkMode:
        r"""
        (SubmixEffectDynamicsChannelLinkMode):  [Read-Write] Mode of peak detection if key signal is multi-channel
        """
        ...
    @link_mode.setter
    def link_mode(self, value: SubmixEffectDynamicsChannelLinkMode) -> None:
        ...
    @property
    def input_gain_db(self) -> float:
        r"""
        (float):  [Read-Write] The input gain of the dynamics processor
        """
        ...
    @input_gain_db.setter
    def input_gain_db(self, value: float) -> None:
        ...
    @property
    def threshold_db(self) -> float:
        r"""
        (float):  [Read-Write] The threshold at which to perform a dynamics processing operation
        """
        ...
    @threshold_db.setter
    def threshold_db(self, value: float) -> None:
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Write] The dynamics processor ratio used for compression/expansion
        """
        ...
    @ratio.setter
    def ratio(self, value: float) -> None:
        ...
    @property
    def knee_bandwidth_db(self) -> float:
        r"""
        (float):  [Read-Write] The knee bandwidth of the processor to use
        """
        ...
    @knee_bandwidth_db.setter
    def knee_bandwidth_db(self, value: float) -> None:
        ...
    @property
    def look_ahead_msec(self) -> float:
        r"""
        (float):  [Read-Write] The amount of time to look ahead of the current audio (Allows for transients to be included in dynamics processing)
        """
        ...
    @look_ahead_msec.setter
    def look_ahead_msec(self, value: float) -> None:
        ...
    @property
    def attack_time_msec(self) -> float:
        r"""
        (float):  [Read-Write] The amount of time to ramp into any dynamics processing effect
        """
        ...
    @attack_time_msec.setter
    def attack_time_msec(self, value: float) -> None:
        ...
    @property
    def release_time_msec(self) -> float:
        r"""
        (float):  [Read-Write] The amount of time to release the dynamics processing effect
        """
        ...
    @release_time_msec.setter
    def release_time_msec(self, value: float) -> None:
        ...
    @property
    def key_source(self) -> SubmixEffectDynamicsKeySource:
        r"""
        (SubmixEffectDynamicsKeySource):  [Read-Write]
        """
        ...
    @key_source.setter
    def key_source(self, value: SubmixEffectDynamicsKeySource) -> None:
        ...
    @property
    def external_audio_bus(self) -> AudioBus:
        r"""
        (AudioBus):  [Read-Write] If set, uses output of provided audio bus as modulator of input signal for dynamics processor (Uses input signal as default modulator)
        """
        ...
    @external_audio_bus.setter
    def external_audio_bus(self, value: AudioBus) -> None:
        ...
    @property
    def external_submix(self) -> SoundSubmix:
        r"""
        (SoundSubmix):  [Read-Write] If set, uses output of provided submix as modulator of input signal for dynamics processor (Uses input signal as default modulator)
        """
        ...
    @external_submix.setter
    def external_submix(self, value: SoundSubmix) -> None:
        ...
    @property
    def analog_mode(self) -> bool:
        r"""
        (bool):  [Read-Write] Toggles treating the attack and release envelopes as analog-style vs digital-style (Analog will respond a bit more naturally/slower)
        """
        ...
    @analog_mode.setter
    def analog_mode(self, value: bool) -> None:
        ...
    @property
    def bypass(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to bypass effect
        """
        ...
    @bypass.setter
    def bypass(self, value: bool) -> None:
        ...
    @property
    def key_audition(self) -> bool:
        r"""
        (bool):  [Read-Write] Audition the key modulation signal, bypassing enveloping and processing the input signal.
        """
        ...
    @key_audition.setter
    def key_audition(self, value: bool) -> None:
        ...
    @property
    def key_gain_db(self) -> float:
        r"""
        (float):  [Read-Write] Gain to apply to key signal if key source not set to default (input).
        """
        ...
    @key_gain_db.setter
    def key_gain_db(self, value: float) -> None:
        ...
    @property
    def output_gain_db(self) -> float:
        r"""
        (float):  [Read-Write] The output gain of the dynamics processor
        """
        ...
    @output_gain_db.setter
    def output_gain_db(self, value: float) -> None:
        ...
    @property
    def key_highshelf(self) -> SubmixEffectDynamicProcessorFilterSettings:
        r"""
        (SubmixEffectDynamicProcessorFilterSettings):  [Read-Write] High Shelf filter settings for key signal (external signal if supplied or input signal if not)
        """
        ...
    @key_highshelf.setter
    def key_highshelf(self, value: SubmixEffectDynamicProcessorFilterSettings) -> None:
        ...
    @property
    def key_lowshelf(self) -> SubmixEffectDynamicProcessorFilterSettings:
        r"""
        (SubmixEffectDynamicProcessorFilterSettings):  [Read-Write] Low Shelf filter settings for key signal (external signal if supplied or input signal if not)
        """
        ...
    @key_lowshelf.setter
    def key_lowshelf(self, value: SubmixEffectDynamicProcessorFilterSettings) -> None:
        ...

class SubmixEffectEQBand(StructBase):
    r"""
    A multiband EQ submix effect.
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectEQ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bandwidth`` (float):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``frequency`` (float):  [Read-Write]
    - ``gain_db`` (float):  [Read-Write]
    """
    def __init__(self, frequency: float = 0.000000, bandwidth: float = 0.000000, gain_db: float = 0.000000, enabled: bool = False) -> None:
        ...
    @property
    def frequency(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @frequency.setter
    def frequency(self, value: float) -> None:
        ...
    @property
    def bandwidth(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @bandwidth.setter
    def bandwidth(self, value: float) -> None:
        ...
    @property
    def gain_db(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @gain_db.setter
    def gain_db(self, value: float) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class SubmixEffectSubmixEQSettings(StructBase):
    r"""
    EQ submix effect
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectEQ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``eq_bands`` (Array[SubmixEffectEQBand]):  [Read-Write] The EQ bands to use.
    """
    def __init__(self, eq_bands: Array[SubmixEffectEQBand] = []) -> None:
        ...
    @property
    def eq_bands(self) -> Array[SubmixEffectEQBand]:
        r"""
        (Array[SubmixEffectEQBand]):  [Read-Write] The EQ bands to use.
        """
        ...
    @eq_bands.setter
    def eq_bands(self, value: Array[SubmixEffectEQBand]) -> None:
        ...

class SubmixEffectReverbSettings(StructBase):
    r"""
    Submix Effect Reverb Settings
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectReverb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``air_absorption_gain_hf`` (float):  [Read-Write] Air Absorption - 0.0 < 0.994 < 1.0 - lower value means more absorption
    - ``bypass`` (bool):  [Read-Write] Bypasses reverb
    - ``bypass_early_reflections`` (bool):  [Read-Write] Bypasses early reflections
    - ``bypass_late_reflections`` (bool):  [Read-Write] Bypasses late reflections.
    - ``decay_hf_ratio`` (float):  [Read-Write] Decay High Frequency Ratio - 0.1 < 0.83 < 2.0 - how much quicker or slower the high frequencies decay relative to the lower frequencies.
    - ``decay_time`` (float):  [Read-Write] Decay Time - 0.1 < 1.49 < 20.0 Seconds - larger is more reverb
    - ``density`` (float):  [Read-Write] Density - 0.0 < 0.85 < 1.0 - Coloration of the late reverb - lower value is more grainy
    - ``diffusion`` (float):  [Read-Write] Diffusion - 0.0 < 0.85 < 1.0 - Echo density in the reverberation decay - lower is more grainy
    - ``dry_level`` (float):  [Read-Write] Overall dry level of the reverb effect
    - ``gain`` (float):  [Read-Write] Reverb Gain - 0.0 < 0.32 < 1.0 - overall reverb gain - master volume control
    - ``gain_hf`` (float):  [Read-Write] Reverb Gain High Frequency - 0.0 < 0.89 < 1.0 - attenuates the high frequency reflected sound
    - ``late_delay`` (float):  [Read-Write] Late Reverb Delay - 0.0 < 0.011 < 0.1 Seconds - time difference between late reverb and first reflections
    - ``late_gain`` (float):  [Read-Write] Late Reverb Gain - 0.0 < 1.26 < 10.0 - gain of the late reverb
    - ``reflections_delay`` (float):  [Read-Write] Reflections Delay - 0.0 < 0.007 < 0.3 Seconds - the time between the listener receiving the direct path sound and the first reflection
    - ``reflections_gain`` (float):  [Read-Write] Reflections Gain - 0.0 < 0.05 < 3.16 - controls the amount of initial reflections
    - ``wet_level`` (float):  [Read-Write] Overall wet level of the reverb effect
    """
    def __init__(self, bypass_early_reflections: bool = False, reflections_delay: float = 0.000000, gain_hf: float = 0.000000, reflections_gain: float = 0.000000, bypass_late_reflections: bool = False, late_delay: float = 0.000000, decay_time: float = 0.000000, density: float = 0.000000, diffusion: float = 0.000000, air_absorption_gain_hf: float = 0.000000, decay_hf_ratio: float = 0.000000, late_gain: float = 0.000000, gain: float = 0.000000, wet_level: float = 0.000000, dry_level: float = 0.000000, bypass: bool = False) -> None:
        ...
    @property
    def bypass_early_reflections(self) -> bool:
        r"""
        (bool):  [Read-Write] Bypasses early reflections
        """
        ...
    @bypass_early_reflections.setter
    def bypass_early_reflections(self, value: bool) -> None:
        ...
    @property
    def reflections_delay(self) -> float:
        r"""
        (float):  [Read-Write] Reflections Delay - 0.0 < 0.007 < 0.3 Seconds - the time between the listener receiving the direct path sound and the first reflection
        """
        ...
    @reflections_delay.setter
    def reflections_delay(self, value: float) -> None:
        ...
    @property
    def gain_hf(self) -> float:
        r"""
        (float):  [Read-Write] Reverb Gain High Frequency - 0.0 < 0.89 < 1.0 - attenuates the high frequency reflected sound
        """
        ...
    @gain_hf.setter
    def gain_hf(self, value: float) -> None:
        ...
    @property
    def reflections_gain(self) -> float:
        r"""
        (float):  [Read-Write] Reflections Gain - 0.0 < 0.05 < 3.16 - controls the amount of initial reflections
        """
        ...
    @reflections_gain.setter
    def reflections_gain(self, value: float) -> None:
        ...
    @property
    def bypass_late_reflections(self) -> bool:
        r"""
        (bool):  [Read-Write] Bypasses late reflections.
        """
        ...
    @bypass_late_reflections.setter
    def bypass_late_reflections(self, value: bool) -> None:
        ...
    @property
    def late_delay(self) -> float:
        r"""
        (float):  [Read-Write] Late Reverb Delay - 0.0 < 0.011 < 0.1 Seconds - time difference between late reverb and first reflections
        """
        ...
    @late_delay.setter
    def late_delay(self, value: float) -> None:
        ...
    @property
    def decay_time(self) -> float:
        r"""
        (float):  [Read-Write] Decay Time - 0.1 < 1.49 < 20.0 Seconds - larger is more reverb
        """
        ...
    @decay_time.setter
    def decay_time(self, value: float) -> None:
        ...
    @property
    def density(self) -> float:
        r"""
        (float):  [Read-Write] Density - 0.0 < 0.85 < 1.0 - Coloration of the late reverb - lower value is more grainy
        """
        ...
    @density.setter
    def density(self, value: float) -> None:
        ...
    @property
    def diffusion(self) -> float:
        r"""
        (float):  [Read-Write] Diffusion - 0.0 < 0.85 < 1.0 - Echo density in the reverberation decay - lower is more grainy
        """
        ...
    @diffusion.setter
    def diffusion(self, value: float) -> None:
        ...
    @property
    def air_absorption_gain_hf(self) -> float:
        r"""
        (float):  [Read-Write] Air Absorption - 0.0 < 0.994 < 1.0 - lower value means more absorption
        """
        ...
    @air_absorption_gain_hf.setter
    def air_absorption_gain_hf(self, value: float) -> None:
        ...
    @property
    def decay_hf_ratio(self) -> float:
        r"""
        (float):  [Read-Write] Decay High Frequency Ratio - 0.1 < 0.83 < 2.0 - how much quicker or slower the high frequencies decay relative to the lower frequencies.
        """
        ...
    @decay_hf_ratio.setter
    def decay_hf_ratio(self, value: float) -> None:
        ...
    @property
    def late_gain(self) -> float:
        r"""
        (float):  [Read-Write] Late Reverb Gain - 0.0 < 1.26 < 10.0 - gain of the late reverb
        """
        ...
    @late_gain.setter
    def late_gain(self, value: float) -> None:
        ...
    @property
    def gain(self) -> float:
        r"""
        (float):  [Read-Write] Reverb Gain - 0.0 < 0.32 < 1.0 - overall reverb gain - master volume control
        """
        ...
    @gain.setter
    def gain(self, value: float) -> None:
        ...
    @property
    def wet_level(self) -> float:
        r"""
        (float):  [Read-Write] Overall wet level of the reverb effect
        """
        ...
    @wet_level.setter
    def wet_level(self, value: float) -> None:
        ...
    @property
    def dry_level(self) -> float:
        r"""
        (float):  [Read-Write] Overall dry level of the reverb effect
        """
        ...
    @dry_level.setter
    def dry_level(self, value: float) -> None:
        ...
    @property
    def bypass(self) -> bool:
        r"""
        (bool):  [Read-Write] Bypasses reverb
        """
        ...
    @bypass.setter
    def bypass(self, value: bool) -> None:
        ...

class SubmixEffectReverbFastSettings(SubmixEffectReverbSettings):
    r"""
    deprecated: 'SubmixEffectReverbFastSettings' was renamed to 'SubmixEffectReverbSettings'.
    """
    def __init__(self, bypass_early_reflections: bool = False, reflections_delay: float = 0.000000, gain_hf: float = 0.000000, reflections_gain: float = 0.000000, bypass_late_reflections: bool = False, late_delay: float = 0.000000, decay_time: float = 0.000000, density: float = 0.000000, diffusion: float = 0.000000, air_absorption_gain_hf: float = 0.000000, decay_hf_ratio: float = 0.000000, late_gain: float = 0.000000, gain: float = 0.000000, wet_level: float = 0.000000, dry_level: float = 0.000000, bypass: bool = False) -> None:
        ...

class MediaMetadataItemBPT(StructBase):
    r"""
    Media Metadata Item BPT
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaPlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``binary_data`` (Array[uint8]):  [Read-Write]
    - ``language_code`` (str):  [Read-Write]
    - ``mime_type`` (str):  [Read-Write]
    - ``string_data`` (str):  [Read-Write]
    """
    def __init__(self, language_code: str = "", mime_type: str = "", string_data: str = "", binary_data: Array[int] = []) -> None:
        ...
    @property
    def language_code(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def mime_type(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def string_data(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def binary_data(self) -> Array[int]:
        r"""
        (Array[uint8]):  [Read-Only]
        """
        ...

class MediaMetadataItemsBPT(StructBase):
    r"""
    Media Metadata Items BPT
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaPlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``items`` (Array[MediaMetadataItemBPT]):  [Read-Write]
    """
    def __init__(self, items: Array[MediaMetadataItemBPT] = []) -> None:
        ...
    @property
    def items(self) -> Array[MediaMetadataItemBPT]:
        r"""
        (Array[MediaMetadataItemBPT]):  [Read-Only]
        """
        ...

class MediaSoundComponentSpectralData(StructBase):
    r"""
    Media Sound Component Spectral Data
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaSoundComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frequency_hz`` (float):  [Read-Write] The frequency hz of the spectrum value
    - ``magnitude`` (float):  [Read-Write] The magnitude of the spectrum at this frequency
    """
    def __init__(self, frequency_hz: float = 0.000000, magnitude: float = 0.000000) -> None:
        ...
    @property
    def frequency_hz(self) -> float:
        r"""
        (float):  [Read-Write] The frequency hz of the spectrum value
        """
        ...
    @frequency_hz.setter
    def frequency_hz(self, value: float) -> None:
        ...
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write] The magnitude of the spectrum at this frequency
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...

class MediaSourceCacheSettings(StructBase):
    r"""
    Cache settings to pass to the player.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``override`` (bool):  [Read-Write] Override the default cache settings.
      Currently only the ImgMedia player supports these settings.
    - ``time_to_look_ahead`` (float):  [Read-Write] The cache will fill up with frames that are up to this time from the current time.
      E.g. if this is 0.2, and we are at time index 5 seconds,
      then we will fill the cache with frames between 5 seconds and 5.2 seconds.
    """
    def __init__(self) -> None:
        ...

class MediaCaptureDevice(StructBase):
    r"""
    Information about a capture device.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaBlueprintFunctionLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] Human readable display name.
    - ``url`` (str):  [Read-Write] Media URL string for use with media players.
    """
    def __init__(self, display_name: Text = "", url: str = "") -> None:
        ...
    @property
    def display_name(self) -> Text:
        r"""
        (Text):  [Read-Only] Human readable display name.
        """
        ...
    @property
    def url(self) -> str:
        r"""
        (str):  [Read-Only] Media URL string for use with media players.
        """
        ...

class ActorDataLayer(StructBase):
    r"""
    This class is deprecated and only present for backward compatibility purposes.
    Instead of using FActorDatalayer, directly save the DataLayerInstance FName if the DataLayer not exposed in data.
    If the DataLayer is exposed in Data, then use DataLayerAssets.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ActorDataLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Only] The name of this layer
    """
    def __init__(self, name: Name = "None") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of this layer
        """
        ...

class Vector_NetQuantize100(Vector):
    r"""
    FVector_NetQuantize100
    
    2 decimal place of precision.
    Up to 30 bits per component.
    Valid range: 2^30 / 100 = +/- 10,737,418.24
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NetSerialization.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    - ``z`` (double):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000) -> None:
        ...

class LevelSequenceCameraSettings(StructBase):
    r"""
    Level Sequence Camera Settings
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequenceCameraSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``aspect_ratio_axis_constraint`` (AspectRatioAxisConstraint):  [Read-Write]
    - ``override_aspect_ratio_axis_constraint`` (bool):  [Read-Write]
    """
    def __init__(self, override_aspect_ratio_axis_constraint: bool = False, aspect_ratio_axis_constraint: AspectRatioAxisConstraint = AspectRatioAxisConstraint.ASPECT_RATIO_MAINTAIN_YFOV) -> None:
        ...
    @property
    def override_aspect_ratio_axis_constraint(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_aspect_ratio_axis_constraint.setter
    def override_aspect_ratio_axis_constraint(self, value: bool) -> None:
        ...
    @property
    def aspect_ratio_axis_constraint(self) -> AspectRatioAxisConstraint:
        r"""
        (AspectRatioAxisConstraint):  [Read-Write]
        """
        ...
    @aspect_ratio_axis_constraint.setter
    def aspect_ratio_axis_constraint(self, value: AspectRatioAxisConstraint) -> None:
        ...

class LevelSequenceAnimSequenceLinkItem(StructBase):
    r"""
    Link To Anim Sequence that we are linked too.
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequenceAnimSequenceLink.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve_interpolation`` (RichCurveInterpMode):  [Read-Write]
    - ``evaluate_all_skeletal_mesh_components`` (bool):  [Read-Write]
    - ``export_attribute_curves`` (bool):  [Read-Write]
    - ``export_material_curves`` (bool):  [Read-Write]
    - ``export_morph_targets`` (bool):  [Read-Write]
    - ``export_transforms`` (bool):  [Read-Write] From Editor Only UAnimSeqExportOption we cache this since we can re-import dynamically
    - ``interpolation`` (AnimInterpolationType):  [Read-Write]
    - ``path_to_anim_sequence`` (SoftObjectPath):  [Read-Write]
    - ``record_in_world_space`` (bool):  [Read-Write]
    - ``skel_track_guid`` (Guid):  [Read-Write]
    """
    def __init__(self, skel_track_guid: Guid = [], path_to_anim_sequence: SoftObjectPath = [""], export_transforms: bool = False, export_morph_targets: bool = False, export_attribute_curves: bool = False, export_material_curves: bool = False, interpolation: AnimInterpolationType = AnimInterpolationType.LINEAR, curve_interpolation: RichCurveInterpMode = RichCurveInterpMode.RCIM_LINEAR, record_in_world_space: bool = False, evaluate_all_skeletal_mesh_components: bool = False) -> None:
        ...
    @property
    def skel_track_guid(self) -> Guid:
        r"""
        (Guid):  [Read-Write]
        """
        ...
    @skel_track_guid.setter
    def skel_track_guid(self, value: Guid) -> None:
        ...
    @property
    def path_to_anim_sequence(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Write]
        """
        ...
    @path_to_anim_sequence.setter
    def path_to_anim_sequence(self, value: SoftObjectPath) -> None:
        ...
    @property
    def export_transforms(self) -> bool:
        r"""
        (bool):  [Read-Write] From Editor Only UAnimSeqExportOption we cache this since we can re-import dynamically
        """
        ...
    @export_transforms.setter
    def export_transforms(self, value: bool) -> None:
        ...
    @property
    def export_morph_targets(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @export_morph_targets.setter
    def export_morph_targets(self, value: bool) -> None:
        ...
    @property
    def export_attribute_curves(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @export_attribute_curves.setter
    def export_attribute_curves(self, value: bool) -> None:
        ...
    @property
    def export_material_curves(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @export_material_curves.setter
    def export_material_curves(self, value: bool) -> None:
        ...
    @property
    def interpolation(self) -> AnimInterpolationType:
        r"""
        (AnimInterpolationType):  [Read-Write]
        """
        ...
    @interpolation.setter
    def interpolation(self, value: AnimInterpolationType) -> None:
        ...
    @property
    def curve_interpolation(self) -> RichCurveInterpMode:
        r"""
        (RichCurveInterpMode):  [Read-Write]
        """
        ...
    @curve_interpolation.setter
    def curve_interpolation(self, value: RichCurveInterpMode) -> None:
        ...
    @property
    def record_in_world_space(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @record_in_world_space.setter
    def record_in_world_space(self, value: bool) -> None:
        ...
    @property
    def evaluate_all_skeletal_mesh_components(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @evaluate_all_skeletal_mesh_components.setter
    def evaluate_all_skeletal_mesh_components(self, value: bool) -> None:
        ...

class LevelSequencePlayerSnapshot(StructBase):
    r"""
    Frame snapshot information for a level sequence
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequencePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active_shot`` (LevelSequence):  [Read-Only]
    - ``camera_component`` (CameraComponent):  [Read-Only]
    - ``current_shot_local_time`` (QualifiedTime):  [Read-Only]
    - ``current_shot_name`` (str):  [Read-Only]
    - ``current_shot_source_time`` (QualifiedTime):  [Read-Only]
    - ``root_name`` (str):  [Read-Only]
    - ``root_time`` (QualifiedTime):  [Read-Only]
    - ``source_time`` (QualifiedTime):  [Read-Only]
    - ``source_timecode`` (str):  [Read-Only]
    """
    def __init__(self, root_name: str = "", root_time: QualifiedTime = [[0], [0, 0], 0.000000], source_time: QualifiedTime = [[0], [0, 0], 0.000000], current_shot_name: str = "", current_shot_local_time: QualifiedTime = [[0], [0, 0], 0.000000], current_shot_source_time: QualifiedTime = [[0], [0, 0], 0.000000], source_timecode: str = "", camera_component: CameraComponent = None, active_shot: LevelSequence = None) -> None:
        ...
    @property
    def root_name(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def root_time(self) -> QualifiedTime:
        r"""
        (QualifiedTime):  [Read-Only]
        """
        ...
    @property
    def source_time(self) -> QualifiedTime:
        r"""
        (QualifiedTime):  [Read-Only]
        """
        ...
    @property
    def current_shot_name(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def current_shot_local_time(self) -> QualifiedTime:
        r"""
        (QualifiedTime):  [Read-Only]
        """
        ...
    @property
    def current_shot_source_time(self) -> QualifiedTime:
        r"""
        (QualifiedTime):  [Read-Only]
        """
        ...
    @property
    def source_timecode(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def camera_component(self) -> CameraComponent:
        r"""
        (CameraComponent):  [Read-Only]
        """
        ...
    @property
    def active_shot(self) -> LevelSequence:
        r"""
        (LevelSequence):  [Read-Only]
        """
        ...

class CSVImportSettings(StructBase):
    r"""
    CSVImport Settings
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CSVImportFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``import_curve_interp_mode`` (RichCurveInterpMode):  [Read-Write]
    - ``import_row_struct`` (ScriptStruct):  [Read-Write]
    - ``import_type`` (CSVImportType):  [Read-Write]
    """
    def __init__(self, import_row_struct: ScriptStruct = None, import_type: CSVImportType = CSVImportType.ECSV_DATA_TABLE, import_curve_interp_mode: RichCurveInterpMode = RichCurveInterpMode.RCIM_LINEAR) -> None:
        ...
    @property
    def import_row_struct(self) -> ScriptStruct:
        r"""
        (ScriptStruct):  [Read-Write]
        """
        ...
    @import_row_struct.setter
    def import_row_struct(self, value: ScriptStruct) -> None:
        ...
    @property
    def import_type(self) -> CSVImportType:
        r"""
        (CSVImportType):  [Read-Write]
        """
        ...
    @import_type.setter
    def import_type(self, value: CSVImportType) -> None:
        ...
    @property
    def import_curve_interp_mode(self) -> RichCurveInterpMode:
        r"""
        (RichCurveInterpMode):  [Read-Write]
        """
        ...
    @import_curve_interp_mode.setter
    def import_curve_interp_mode(self, value: RichCurveInterpMode) -> None:
        ...

class ImportMeshLodSectionsData(StructBase):
    r"""
    Action to add nodes to the graph based on selected objects
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxMeshImportData.h
    
    """
    def __init__(self) -> None:
        ...

class ProceduralFoliageInstance(StructBase):
    r"""
    Procedural Foliage Instance
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: ProceduralFoliageInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``age`` (float):  [Read-Write]
    - ``location`` (Vector):  [Read-Write]
    - ``normal`` (Vector):  [Read-Write]
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], age: float = 0.000000, normal: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def age(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @age.setter
    def age(self, value: float) -> None:
        ...
    @property
    def normal(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @normal.setter
    def normal(self, value: Vector) -> None:
        ...

class ImageWriteOptions(StructBase):
    r"""
    Options specific to writing image files to disk
    
    **C++ Source:**
    
    - **Module**: ImageWriteQueue
    - **File**: ImageWriteBlueprintLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``async_`` (bool):  [Read-Write] Whether to perform the writing asynchronously, or to block the game thread until it is complete
    - ``compression_quality`` (int32):  [Read-Write] An image format specific compression setting. Either 0 (Default) or 1 (Uncompressed) for EXRs, or a value between 0 and 100.
    - ``format`` (DesiredImageFormat):  [Read-Write] The desired output image format to write to disk
    - ``on_complete`` (OnImageWriteComplete):  [Read-Write] A callback to invoke when the image has been written, or there was an error
    - ``overwrite_file`` (bool):  [Read-Write] Whether to overwrite the image if it already exists
    """
    def __init__(self, format: DesiredImageFormat = DesiredImageFormat.PNG, on_complete: OnImageWriteComplete = OnImageWriteComplete(), compression_quality: int = 0, overwrite_file: bool = False, async_: bool = False) -> None:
        ...
    @property
    def format(self) -> DesiredImageFormat:
        r"""
        (DesiredImageFormat):  [Read-Write] The desired output image format to write to disk
        """
        ...
    @format.setter
    def format(self, value: DesiredImageFormat) -> None:
        ...
    @property
    def on_complete(self) -> OnImageWriteComplete:
        r"""
        (OnImageWriteComplete):  [Read-Write] A callback to invoke when the image has been written, or there was an error
        """
        ...
    @on_complete.setter
    def on_complete(self, value: OnImageWriteComplete) -> None:
        ...
    @property
    def compression_quality(self) -> int:
        r"""
        (int32):  [Read-Write] An image format specific compression setting. Either 0 (Default) or 1 (Uncompressed) for EXRs, or a value between 0 and 100.
        """
        ...
    @compression_quality.setter
    def compression_quality(self, value: int) -> None:
        ...
    @property
    def overwrite_file(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to overwrite the image if it already exists
        """
        ...
    @overwrite_file.setter
    def overwrite_file(self, value: bool) -> None:
        ...
    @property
    def async_(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to perform the writing asynchronously, or to block the game thread until it is complete
        """
        ...
    @async_.setter
    def async_(self, value: bool) -> None:
        ...

class PerPlatformInt(StructBase):
    r"""
    FPerPlatformInt - int32 property with per-platform overrides
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PerPlatformProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default`` (int32):  [Read-Write]
    - ``per_platform`` (Map[Name, int32]):  [Read-Write]
    """
    def __init__(self, default: int = 0) -> None:
        ...
    @property
    def default(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class GrassVariety(StructBase):
    r"""
    Grass Variety
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeGrassType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.
    - ``align_to_surface`` (bool):  [Read-Write] Whether the grass instances should be tilted to the normal of the landscape (true), or always vertical (false)
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the grass should cast contact shadows. *
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Whether the grass should cast shadows when using non-precomputed shadowing. *
    - ``end_cull_distance`` (PerPlatformInt):  [Read-Write] The distance where instances will have completely faded out when using a PerInstanceFadeAmount material node. 0 disables.
      When the entire cluster is beyond this distance, the cluster is completely culled and not rendered at all.
    - ``end_cull_distance_quality`` (PerQualityLevelInt):  [Read-Write]
    - ``grass_density`` (PerPlatformFloat):  [Read-Write] Instances per 10 square meters.
    - ``grass_density_quality`` (PerQualityLevelFloat):  [Read-Write]
    - ``grass_mesh`` (StaticMesh):  [Read-Write]
    - ``instance_world_position_offset_disable_distance`` (uint32):  [Read-Write] Distance at which to grass instances should disable WPO for performance reasons
    - ``keep_instance_buffer_cpu_copy`` (bool):  [Read-Write] Whether we should keep a cpu copy of the instance buffer. This should be set to true if you plan on using GetOverlappingXXXXCount functions of the component otherwise it won't return any data.*
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Lighting channels that the grass will be assigned. Lights with matching channels will affect the grass.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``max_scale_weight_attenuation`` (float):  [Read-Write] Modulate the scale of the instances based on weight (normalized density). The weight range (ScaleWeightAttenuation, 1.0) maps to (scaleMin, scaleMax), weight values less than ScaleWeightAttenuation are set to minScale
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      If -1 (default), the MinLOD of the static mesh asset will be used instead.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material Overrides.
    - ``placement_jitter`` (float):  [Read-Write]
    - ``random_rotation`` (bool):  [Read-Write] Whether the grass instances should be placed at random rotation (true) or all at the same rotation (false)
    - ``receives_decals`` (bool):  [Read-Write] Whether the grass instances should receive decals.
    - ``scale_x`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a grass instance's X Scale property
    - ``scale_y`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a grass instance's Y Scale property
    - ``scale_z`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a grass instance's Z Scale property
    - ``scaling`` (GrassScaling):  [Read-Write] Specifies grass instance scaling type
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``start_cull_distance`` (PerPlatformInt):  [Read-Write] The distance where instances will begin to fade out if using a PerInstanceFadeAmount material node. 0 disables.
    - ``start_cull_distance_quality`` (PerQualityLevelInt):  [Read-Write]
    - ``use_grid`` (bool):  [Read-Write] If true, use a jittered grid sequence for placement, otherwise use a halton sequence.
    - ``use_landscape_lightmap`` (bool):  [Read-Write] Whether to use the landscape's lightmap when rendering the grass.
    - ``weight_attenuates_max_scale`` (bool):  [Read-Write] If enabled the the scale of instances is reduced as the weight (density) decreases
    """
    def __init__(self, grass_mesh: StaticMesh = None, override_materials: Array[MaterialInterface] = [], grass_density: PerPlatformFloat = [0.000000], grass_density_quality: PerQualityLevelFloat = [0.000000], use_grid: bool = False, placement_jitter: float = 0.000000, start_cull_distance: PerPlatformInt = [0], start_cull_distance_quality: PerQualityLevelInt = [0], end_cull_distance: PerPlatformInt = [0], end_cull_distance_quality: PerQualityLevelInt = [0], min_lod: int = 0, scaling: GrassScaling = GrassScaling.UNIFORM, scale_x: FloatInterval = [0.000000, 0.000000], scale_y: FloatInterval = [0.000000, 0.000000], scale_z: FloatInterval = [0.000000, 0.000000], weight_attenuates_max_scale: bool = False, max_scale_weight_attenuation: float = 0.000000, random_rotation: bool = False, align_to_surface: bool = False, use_landscape_lightmap: bool = False, lighting_channels: LightingChannels = [True, False, False], receives_decals: bool = False, affect_distance_field_lighting: bool = False, cast_dynamic_shadow: bool = False, cast_contact_shadow: bool = False, keep_instance_buffer_cpu_copy: bool = False, shadow_cache_invalidation_behavior: ShadowCacheInvalidationBehavior = ShadowCacheInvalidationBehavior.AUTO) -> None:
        ...
    @property
    def grass_mesh(self) -> StaticMesh:
        r"""
        (StaticMesh):  [Read-Only]
        """
        ...
    @property
    def override_materials(self) -> Array[MaterialInterface]:
        r"""
        (Array[MaterialInterface]):  [Read-Only] Material Overrides.
        """
        ...
    @property
    def grass_density(self) -> PerPlatformFloat:
        r"""
        (PerPlatformFloat):  [Read-Only] Instances per 10 square meters.
        """
        ...
    @property
    def grass_density_quality(self) -> PerQualityLevelFloat:
        r"""
        (PerQualityLevelFloat):  [Read-Only]
        """
        ...
    @property
    def use_grid(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, use a jittered grid sequence for placement, otherwise use a halton sequence.
        """
        ...
    @property
    def placement_jitter(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def start_cull_distance(self) -> PerPlatformInt:
        r"""
        (PerPlatformInt):  [Read-Only] The distance where instances will begin to fade out if using a PerInstanceFadeAmount material node. 0 disables.
        """
        ...
    @property
    def start_cull_distance_quality(self) -> PerQualityLevelInt:
        r"""
        (PerQualityLevelInt):  [Read-Only]
        """
        ...
    @property
    def end_cull_distance(self) -> PerPlatformInt:
        r"""
        (PerPlatformInt):  [Read-Only] The distance where instances will have completely faded out when using a PerInstanceFadeAmount material node. 0 disables.
        When the entire cluster is beyond this distance, the cluster is completely culled and not rendered at all.
        """
        ...
    @property
    def end_cull_distance_quality(self) -> PerQualityLevelInt:
        r"""
        (PerQualityLevelInt):  [Read-Only]
        """
        ...
    @property
    def min_lod(self) -> int:
        r"""
        (int32):  [Read-Only] Specifies the smallest LOD that will be used for this component.
        If -1 (default), the MinLOD of the static mesh asset will be used instead.
        """
        ...
    @property
    def scaling(self) -> GrassScaling:
        r"""
        (GrassScaling):  [Read-Only] Specifies grass instance scaling type
        """
        ...
    @property
    def scale_x(self) -> FloatInterval:
        r"""
        (FloatInterval):  [Read-Only] Specifies the range of scale, from minimum to maximum, to apply to a grass instance's X Scale property
        """
        ...
    @property
    def scale_y(self) -> FloatInterval:
        r"""
        (FloatInterval):  [Read-Only] Specifies the range of scale, from minimum to maximum, to apply to a grass instance's Y Scale property
        """
        ...
    @property
    def scale_z(self) -> FloatInterval:
        r"""
        (FloatInterval):  [Read-Only] Specifies the range of scale, from minimum to maximum, to apply to a grass instance's Z Scale property
        """
        ...
    @property
    def weight_attenuates_max_scale(self) -> bool:
        r"""
        (bool):  [Read-Only] If enabled the the scale of instances is reduced as the weight (density) decreases
        """
        ...
    @property
    def max_scale_weight_attenuation(self) -> float:
        r"""
        (float):  [Read-Only] Modulate the scale of the instances based on weight (normalized density). The weight range (ScaleWeightAttenuation, 1.0) maps to (scaleMin, scaleMax), weight values less than ScaleWeightAttenuation are set to minScale
        """
        ...
    @property
    def random_rotation(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the grass instances should be placed at random rotation (true) or all at the same rotation (false)
        """
        ...
    @property
    def align_to_surface(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the grass instances should be tilted to the normal of the landscape (true), or always vertical (false)
        """
        ...
    @property
    def use_landscape_lightmap(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to use the landscape's lightmap when rendering the grass.
        """
        ...
    @property
    def lighting_channels(self) -> LightingChannels:
        r"""
        (LightingChannels):  [Read-Only] Lighting channels that the grass will be assigned. Lights with matching channels will affect the grass.
        These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
        """
        ...
    @property
    def receives_decals(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the grass instances should receive decals.
        """
        ...
    @property
    def affect_distance_field_lighting(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the primitive should affect dynamic distance field lighting methods.
        """
        ...
    @property
    def cast_dynamic_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the grass should cast shadows when using non-precomputed shadowing. *
        """
        ...
    @property
    def cast_contact_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the grass should cast contact shadows. *
        """
        ...
    @property
    def keep_instance_buffer_cpu_copy(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether we should keep a cpu copy of the instance buffer. This should be set to true if you plan on using GetOverlappingXXXXCount functions of the component otherwise it won't return any data.*
        """
        ...
    @property
    def shadow_cache_invalidation_behavior(self) -> ShadowCacheInvalidationBehavior:
        r"""
        (ShadowCacheInvalidationBehavior):  [Read-Only] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
        """
        ...

class PerQualityLevelInt(StructBase):
    r"""
    Per Quality Level Int
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PerQualityLevelProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default`` (int32):  [Read-Write]
    - ``per_quality`` (Map[int32, int32]):  [Read-Write]
    """
    def __init__(self, default: int = 0) -> None:
        ...
    @property
    def default(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class PerQualityLevelFloat(StructBase):
    r"""
    Per Quality Level Float
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PerQualityLevelProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default`` (float):  [Read-Write]
    - ``per_quality`` (Map[int32, float]):  [Read-Write]
    """
    def __init__(self, default: float = 0.000000) -> None:
        ...
    @property
    def default(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class PerPlatformFloat(StructBase):
    r"""
    FPerPlatformFloat - float property with per-platform overrides
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PerPlatformProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default`` (float):  [Read-Write]
    - ``per_platform`` (Map[Name, float]):  [Read-Write]
    """
    def __init__(self, default: float = 0.000000) -> None:
        ...
    @property
    def default(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class LandscapeBrushParameters(StructBase):
    r"""
    Landscape Brush Parameters
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeBlueprintBrushBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``combined_result`` (TextureRenderTarget2D):  [Read-Write]
    - ``layer_type`` (LandscapeToolTargetType):  [Read-Write]
    - ``weightmap_layer_name`` (Name):  [Read-Write]
    """
    def __init__(self, layer_type: LandscapeToolTargetType = LandscapeToolTargetType.HEIGHTMAP, combined_result: TextureRenderTarget2D = None, weightmap_layer_name: Name = "None") -> None:
        ...
    @property
    def layer_type(self) -> LandscapeToolTargetType:
        r"""
        (LandscapeToolTargetType):  [Read-Write]
        """
        ...
    @layer_type.setter
    def layer_type(self, value: LandscapeToolTargetType) -> None:
        ...
    @property
    def combined_result(self) -> TextureRenderTarget2D:
        r"""
        (TextureRenderTarget2D):  [Read-Write]
        """
        ...
    @combined_result.setter
    def combined_result(self, value: TextureRenderTarget2D) -> None:
        ...
    @property
    def weightmap_layer_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @weightmap_layer_name.setter
    def weightmap_layer_name(self, value: Name) -> None:
        ...

class NamedFloat(StructBase):
    r"""
    A named float
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, name: Name = "None") -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...

class NamedVector(StructBase):
    r"""
    A named float
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], name: Name = "None") -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...

class NamedColor(StructBase):
    r"""
    A named color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``value`` (Color):  [Read-Write]
    """
    def __init__(self, value: Color = [0, 0, 0, 0], name: Name = "None") -> None:
        ...
    @property
    def value(self) -> Color:
        r"""
        (Color):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Color) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...

class NamedTransform(StructBase):
    r"""
    A named transform
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], name: Name = "None") -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...

class LocalSpacePose(StructBase):
    r"""
    A pose in local space (i.e. each transform is relative to its parent)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``names`` (Array[Name]):  [Read-Write]
    - ``transforms`` (Array[Transform]):  [Read-Write]
    """
    def __init__(self, transforms: Array[Transform] = [], names: Array[Name] = []) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write]
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write]
        """
        ...
    @names.setter
    def names(self, value: Array[Name]) -> None:
        ...

class ComponentSpacePose(StructBase):
    r"""
    A pose in component space (i.e. each transform is relative to the component's transform)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``names`` (Array[Name]):  [Read-Write]
    - ``transforms`` (Array[Transform]):  [Read-Write]
    """
    def __init__(self, transforms: Array[Transform] = [], names: Array[Name] = []) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write]
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write]
        """
        ...
    @names.setter
    def names(self, value: Array[Name]) -> None:
        ...

class AnimCurveBase(StructBase):
    r"""
    Float curve data for one track
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCurveTypes.h
    
    """
    def __init__(self) -> None:
        ...

class FloatCurve(AnimCurveBase):
    r"""
    Float Curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCurveTypes.h
    
    """
    def __init__(self) -> None:
        ...

class VectorCurve(AnimCurveBase):
    r"""
    Vector Curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCurveTypes.h
    
    """
    def __init__(self) -> None:
        ...

class TransformCurve(AnimCurveBase):
    r"""
    Transform Curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCurveTypes.h
    
    """
    def __init__(self) -> None:
        ...

class CachedFloatCurve(StructBase):
    r"""
    Cached Float Curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCurveTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve_name`` (Name):  [Read-Write]
    """
    def __init__(self, curve_name: Name = "None") -> None:
        ...
    @property
    def curve_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @curve_name.setter
    def curve_name(self, value: Name) -> None:
        ...

class EmptyPayload(StructBase):
    r"""
    Empty Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    """
    def __init__(self) -> None:
        ...

class BracketPayload(EmptyPayload):
    r"""
    Bracket Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``description`` (str):  [Read-Write] Description of bracket-ed operation applied to the model
    """
    def __init__(self, description: str = "") -> None:
        ...
    @property
    def description(self) -> str:
        r"""
        (str):  [Read-Only] Description of bracket-ed operation applied to the model
        """
        ...

class AnimationTrackPayload(EmptyPayload):
    r"""
    Animation Track Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] Name of the track (bone)
    """
    def __init__(self, name: Name = "None") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of the track (bone)
        """
        ...

class AnimationTrackAddedPayload(AnimationTrackPayload):
    r"""
    Animation Track Added Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] Name of the track (bone)
    - ``track_index`` (int32):  [Read-Write]
    """
    def __init__(self, name: Name = "None", track_index: int = 0) -> None:
        ...
    @property
    def track_index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class SequenceLengthChangedPayload(EmptyPayload):
    r"""
    Sequence Length Changed Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame0`` (FrameNumber):  [Read-Write] Frame number at which the change in frames has been made
    - ``frame1`` (FrameNumber):  [Read-Write] Amount of frames which is inserted or removed starting at Frame0
    - ``previous_length`` (float):  [Read-Write]
    - ``previous_number_of_frames`` (FrameNumber):  [Read-Write] Previous playable number of frames for the Model
    - ``t0`` (float):  [Read-Write]
    - ``t1`` (float):  [Read-Write]
    """
    def __init__(self, previous_length: float = 0.000000, t0: float = 0.000000, t1: float = 0.000000, previous_number_of_frames: FrameNumber = [0], frame0: FrameNumber = [0], frame1: FrameNumber = [0]) -> None:
        ...
    @property
    def previous_length(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def t0(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def t1(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def previous_number_of_frames(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Only] Previous playable number of frames for the Model
        """
        ...
    @property
    def frame0(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Only] Frame number at which the change in frames has been made
        """
        ...
    @property
    def frame1(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Only] Amount of frames which is inserted or removed starting at Frame0
        """
        ...

class FrameRateChangedPayload(EmptyPayload):
    r"""
    Frame Rate Changed Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``previous_frame_rate`` (FrameRate):  [Read-Write] Previous sampling rate for the Model
    """
    def __init__(self, previous_frame_rate: FrameRate = [0, 0]) -> None:
        ...
    @property
    def previous_frame_rate(self) -> FrameRate:
        r"""
        (FrameRate):  [Read-Only] Previous sampling rate for the Model
        """
        ...

class CurvePayload(EmptyPayload):
    r"""
    Curve Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``identifier`` (AnimationCurveIdentifier):  [Read-Write] Identifier of the curve
    """
    def __init__(self, identifier: AnimationCurveIdentifier = []) -> None:
        ...
    @property
    def identifier(self) -> AnimationCurveIdentifier:
        r"""
        (AnimationCurveIdentifier):  [Read-Only] Identifier of the curve
        """
        ...

class AnimationCurveIdentifier(StructBase):
    r"""
    Script-friendly structure for identifying an animation curve.
    Wrapping the unique type and smart-name for use within the AnimDataController API.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveIdentifier.h
    
    """
    def __init__(self) -> None:
        ...
    def set_curve_identifier(self, name: Name, curve_type: RawCurveTrackTypes) -> None:
        r"""
        x.set_curve_identifier(name, curve_type) -> None
        Constructs a valid FAnimationCurveIdentifier instance.
        
        Args:
            name (Name): Name of the curve to find or add
            curve_type (RawCurveTrackTypes): Type of the curve to find or add
        """
        ...
    def is_valid(self) -> bool:
        r"""
        x.is_valid() -> bool
        
        
        Returns:
            bool: Whether or not the Curve Identifier is valid
        """
        ...
    def get_type(self) -> RawCurveTrackTypes:
        r"""
        x.get_type() -> RawCurveTrackTypes
        
        
        Returns:
            RawCurveTrackTypes: The animation curve type for the curve represented by the Curve Identifier
        """
        ...
    def get_transform_child_curve_identifier(self, channel: TransformCurveChannel, axis: VectorCurveChannel) -> bool:
        r"""
        x.get_transform_child_curve_identifier(channel, axis) -> bool
        Converts a valid FAnimationCurveIdentifier instance with RCT_Transform curve type to target a child curve.
        
        Args:
            channel (TransformCurveChannel): Channel to target
            axis (VectorCurveChannel): Axis within channel to target
        
        Returns:
            bool: Valid FAnimationCurveIdentifier if the operation was successful
        """
        ...
    def get_name(self) -> Name:
        r"""
        x.get_name() -> Name
        
        
        Returns:
            Name: The name used for displaying the Curve Identifier
        """
        ...

class CurveScaledPayload(CurvePayload):
    r"""
    Curve Scaled Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``factor`` (float):  [Read-Write] Factor with which the curve was scaled
    - ``identifier`` (AnimationCurveIdentifier):  [Read-Write] Identifier of the curve
    - ``origin`` (float):  [Read-Write] Time used as the origin when scaling the curve
    """
    def __init__(self, identifier: AnimationCurveIdentifier = [], factor: float = 0.000000, origin: float = 0.000000) -> None:
        ...
    @property
    def factor(self) -> float:
        r"""
        (float):  [Read-Only] Factor with which the curve was scaled
        """
        ...
    @property
    def origin(self) -> float:
        r"""
        (float):  [Read-Only] Time used as the origin when scaling the curve
        """
        ...

class CurveRenamedPayload(CurvePayload):
    r"""
    Curve Renamed Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``identifier`` (AnimationCurveIdentifier):  [Read-Write] Identifier of the curve
    - ``new_identifier`` (AnimationCurveIdentifier):  [Read-Write] Identifier of the curve after it was renamed
    """
    def __init__(self, identifier: AnimationCurveIdentifier = [], new_identifier: AnimationCurveIdentifier = []) -> None:
        ...
    @property
    def new_identifier(self) -> AnimationCurveIdentifier:
        r"""
        (AnimationCurveIdentifier):  [Read-Only] Identifier of the curve after it was renamed
        """
        ...

class CurveFlagsChangedPayload(CurvePayload):
    r"""
    Curve Flags Changed Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``identifier`` (AnimationCurveIdentifier):  [Read-Write] Identifier of the curve
    - ``old_flags`` (int32):  [Read-Write] Old flags mask for the curve
    """
    def __init__(self, identifier: AnimationCurveIdentifier = [], old_flags: int = 0) -> None:
        ...
    @property
    def old_flags(self) -> int:
        r"""
        (int32):  [Read-Only] Old flags mask for the curve
        """
        ...

class AttributePayload(EmptyPayload):
    r"""
    Attribute Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``identifier`` (AnimationAttributeIdentifier):  [Read-Write] Identifier of the attribute
    """
    def __init__(self, identifier: AnimationAttributeIdentifier = ["None", "None", -1, None, [""]]) -> None:
        ...
    @property
    def identifier(self) -> AnimationAttributeIdentifier:
        r"""
        (AnimationAttributeIdentifier):  [Read-Only] Identifier of the attribute
        """
        ...

class AnimationAttributeIdentifier(StructBase):
    r"""
    Script-friendly structure for identifying an attribute (curve).
    Wrapping the attribute name, bone name and index, and underlying data type for use within the AnimDataController API.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AttributeIdentifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_index`` (int32):  [Read-Write]
    - ``bone_name`` (Name):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``script_struct`` (ScriptStruct):  [Read-Write]
    - ``script_struct_path`` (SoftObjectPath):  [Read-Write]
    """
    def __init__(self, name: Name = "None", bone_name: Name = "None", bone_index: int = 0, script_struct: ScriptStruct = None, script_struct_path: SoftObjectPath = [""]) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def bone_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def bone_index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def script_struct(self) -> ScriptStruct:
        r"""
        (ScriptStruct):  [Read-Only]
        """
        ...
    @property
    def script_struct_path(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Only]
        """
        ...
    def is_valid(self) -> bool:
        r"""
        x.is_valid() -> bool
        
        
        Returns:
            bool: Whether or not the Attribute Identifier is valid
        """
        ...

class AnimNodeConstantData(StructBase):
    r"""
    Any constant class data an anim node uses should be derived from this type.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNodeConstantData.h
    
    """
    def __init__(self) -> None:
        ...

class PerBoneBlendWeights(StructBase):
    r"""
    Per Bone Blend Weights
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """
    def __init__(self) -> None:
        ...

class AnimLinkableElement(StructBase):
    r"""
    Used to describe an element that can be linked to a segment in a montage or sequence.
       Usage:
               Inherit from FAnimLinkableElement and make sure to call LinkMontage or LinkSequence
               both on creation and on loading the element. From there SetTime and GetTime should be
               used to control where this element is in the montage or sequence.
    
               For more advanced usage, see this implementation used in FAnimNotifyEvent where
               we have a secondary link to handle a duration
    see: FAnimNotifyEvent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimLinkableElement.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``link_method`` (AnimLinkMethod):  [Read-Write] The method we are using to calculate our times
    - ``linked_sequence`` (AnimSequenceBase):  [Read-Only] The Animation Sequence that this montage element will link to, when the sequence changes
      in either length or rate; the element will correctly place itself in relation to the sequence
    - ``slot_index`` (int32):  [Read-Write] The slot index we are currently using within LinkedMontage
    """
    def __init__(self) -> None:
        ...

class AnimNotifyEvent(AnimLinkableElement):
    r"""
    Triggers an animation notify.  Each AnimNotifyEvent contains an AnimNotify object
    which has its Notify method called and passed to the animation.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_be_filtered_via_request`` (bool):  [Read-Write] Allow notify event to be filtered if requested at runtime (e. g. via an Anim Graph Message)
    - ``link_method`` (AnimLinkMethod):  [Read-Write] The method we are using to calculate our times
    - ``linked_sequence`` (AnimSequenceBase):  [Read-Only] The Animation Sequence that this montage element will link to, when the sequence changes
      in either length or rate; the element will correctly place itself in relation to the sequence
    - ``montage_tick_type`` (MontageNotifyTickType):  [Read-Write]
    - ``notify`` (AnimNotify):  [Read-Write]
    - ``notify_filter_lod`` (int32):  [Read-Write] LOD to start filtering this notify from.
    - ``notify_filter_type`` (NotifyFilterType):  [Read-Write] Defines a method for filtering notifies (stopping them triggering) e.g. by looking at the meshes current LOD
    - ``notify_name`` (Name):  [Read-Write]
    - ``notify_state_class`` (AnimNotifyState):  [Read-Write]
    - ``notify_trigger_chance`` (float):  [Read-Write] Defines the chance of of this notify triggering, 0 = No Chance, 1 = Always triggers
    - ``slot_index`` (int32):  [Read-Write] The slot index we are currently using within LinkedMontage
    - ``trigger_on_dedicated_server`` (bool):  [Read-Write] If disabled this notify will be skipped on dedicated servers
    - ``trigger_on_follower`` (bool):  [Read-Write] If enabled this notify will trigger when the animation is a follower in a sync group (by default only the sync group leaders notifies trigger
    - ``trigger_weight_threshold`` (float):  [Read-Write]
    """
    def __init__(self, trigger_weight_threshold: float = 0.000000, notify_name: Name = "None", notify: AnimNotify = None, notify_state_class: AnimNotifyState = None, montage_tick_type: MontageNotifyTickType = MontageNotifyTickType.QUEUED, notify_trigger_chance: float = 0.000000, notify_filter_type: NotifyFilterType = NotifyFilterType.NO_FILTERING, notify_filter_lod: int = 0, can_be_filtered_via_request: bool = False, trigger_on_dedicated_server: bool = False, trigger_on_follower: bool = False) -> None:
        ...
    @property
    def trigger_weight_threshold(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @trigger_weight_threshold.setter
    def trigger_weight_threshold(self, value: float) -> None:
        ...
    @property
    def notify_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def notify(self) -> AnimNotify:
        r"""
        (AnimNotify):  [Read-Write]
        """
        ...
    @notify.setter
    def notify(self, value: AnimNotify) -> None:
        ...
    @property
    def notify_state_class(self) -> AnimNotifyState:
        r"""
        (AnimNotifyState):  [Read-Write]
        """
        ...
    @notify_state_class.setter
    def notify_state_class(self, value: AnimNotifyState) -> None:
        ...
    @property
    def montage_tick_type(self) -> MontageNotifyTickType:
        r"""
        (MontageNotifyTickType):  [Read-Write]
        """
        ...
    @montage_tick_type.setter
    def montage_tick_type(self, value: MontageNotifyTickType) -> None:
        ...
    @property
    def notify_trigger_chance(self) -> float:
        r"""
        (float):  [Read-Write] Defines the chance of of this notify triggering, 0 = No Chance, 1 = Always triggers
        """
        ...
    @notify_trigger_chance.setter
    def notify_trigger_chance(self, value: float) -> None:
        ...
    @property
    def notify_filter_type(self) -> NotifyFilterType:
        r"""
        (NotifyFilterType):  [Read-Write] Defines a method for filtering notifies (stopping them triggering) e.g. by looking at the meshes current LOD
        """
        ...
    @notify_filter_type.setter
    def notify_filter_type(self, value: NotifyFilterType) -> None:
        ...
    @property
    def notify_filter_lod(self) -> int:
        r"""
        (int32):  [Read-Write] LOD to start filtering this notify from.
        """
        ...
    @notify_filter_lod.setter
    def notify_filter_lod(self, value: int) -> None:
        ...
    @property
    def can_be_filtered_via_request(self) -> bool:
        r"""
        (bool):  [Read-Write] Allow notify event to be filtered if requested at runtime (e. g. via an Anim Graph Message)
        """
        ...
    @can_be_filtered_via_request.setter
    def can_be_filtered_via_request(self, value: bool) -> None:
        ...
    @property
    def trigger_on_dedicated_server(self) -> bool:
        r"""
        (bool):  [Read-Write] If disabled this notify will be skipped on dedicated servers
        """
        ...
    @trigger_on_dedicated_server.setter
    def trigger_on_dedicated_server(self, value: bool) -> None:
        ...
    @property
    def trigger_on_follower(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled this notify will trigger when the animation is a follower in a sync group (by default only the sync group leaders notifies trigger
        """
        ...
    @trigger_on_follower.setter
    def trigger_on_follower(self, value: bool) -> None:
        ...

class AnimSyncMarker(StructBase):
    r"""
    Anim Sync Marker
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``marker_name`` (Name):  [Read-Write] The name of this marker
    - ``time`` (float):  [Read-Write] Time in seconds of this marker
    """
    def __init__(self, marker_name: Name = "None", time: float = 0.000000) -> None:
        ...
    @property
    def marker_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of this marker
        """
        ...
    @property
    def time(self) -> float:
        r"""
        (float):  [Read-Only] Time in seconds of this marker
        """
        ...

class RawAnimSequenceTrack(StructBase):
    r"""
    Raw keyframe data for one track.Each array will contain either NumFrames elements or 1 element.
    One element is used as a simple compression scheme where if all keys are the same, they'll be
    reduced to 1 key that is constant over the entire sequence.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """
    def __init__(self) -> None:
        ...
    def get_scale_keys(self) -> Array[Vector]:
        r"""
        x.get_scale_keys() -> Array[Vector]
        Returns the scale keys contained by the FRawAnimSequenceTrack
        
        Returns:
            Array[Vector]:
        """
        ...
    def get_rotational_keys(self) -> Array[Quat]:
        r"""
        x.get_rotational_keys() -> Array[Quat]
        Returns the rotational keys contained by the FRawAnimSequenceTrack
        
        Returns:
            Array[Quat]:
        """
        ...
    def get_positional_keys(self) -> Array[Vector]:
        r"""
        x.get_positional_keys() -> Array[Vector]
        Returns the positional keys contained by the FRawAnimSequenceTrack
        
        Returns:
            Array[Vector]:
        """
        ...

class NonBlendableQuaternionAnimationAttribute(QuaternionAnimationAttribute):
    r"""
    Non Blendable Quaternion Animation Attribute
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class NonBlendableVectorAnimationAttribute(VectorAnimationAttribute):
    r"""
    Non Blendable Vector Animation Attribute
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class NonBlendableTransformAnimationAttribute(TransformAnimationAttribute):
    r"""
    Non Blendable Transform Animation Attribute
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class NonBlendableFloatAnimationAttribute(FloatAnimationAttribute):
    r"""
    Non Blendable Float Animation Attribute
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class NonBlendableIntegerAnimationAttribute(IntegerAnimationAttribute):
    r"""
    Non Blendable Integer Animation Attribute
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0) -> None:
        ...

class MinimalViewInfo(StructBase):
    r"""
    Minimal View Info
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``aspect_ratio`` (float):  [Read-Write] Aspect Ratio (Width/Height)
    - ``auto_calculate_ortho_planes`` (bool):  [Read-Write] Option for the Ortho camera to automatically calculated the near/far plane
    - ``auto_plane_shift`` (float):  [Read-Write] Manually adjusts the planes of this camera, maintaining the distance between them. Positive moves out to the farplane, negative towards the near plane
    - ``constrain_aspect_ratio`` (bool):  [Read-Write] If bConstrainAspectRatio is true, black bars will be added if the destination view has a different aspect ratio than this camera requested.
    - ``fov`` (float):  [Read-Write] The horizontal field of view (in degrees) in perspective mode (ignored in orthographic mode).
    - ``location`` (Vector):  [Read-Write] Location
    - ``off_center_projection_offset`` (Vector2D):  [Read-Only] Off-axis / off-center projection offset as proportion of screen dimensions
    - ``ortho_far_clip_plane`` (float):  [Read-Write] The far plane distance of the orthographic view (in world units)
    - ``ortho_near_clip_plane`` (float):  [Read-Write] The near plane distance of the orthographic view (in world units)
    - ``ortho_width`` (float):  [Read-Write] The desired width (in world units) of the orthographic view (ignored in Perspective mode)
    - ``perspective_near_clip_plane`` (float):  [Read-Write] The near plane distance of the perspective view (in world units). Set to a negative value to use the default global value of GNearClippingPlane
    - ``post_process_blend_weight`` (float):  [Read-Write] Indicates if PostProcessSettings should be applied.
    - ``post_process_settings`` (PostProcessSettings):  [Read-Write] Post-process settings to use if PostProcessBlendWeight is non-zero.
    - ``projection_mode`` (CameraProjectionMode):  [Read-Write] The type of camera
    - ``rotation`` (Rotator):  [Read-Write] Rotation
    - ``update_ortho_planes`` (bool):  [Read-Write] Adjusts the near/far planes and the view origin of the current camera automatically to avoid clipping and light artefacting
    - ``use_camera_height_as_view_target`` (bool):  [Read-Write] If UpdateOrthoPlanes is enabled, this setting will use the cameras current height to compensate the distance to the general view (as a pseudo distance to view target when one isn't present)
    - ``use_field_of_view_for_lod`` (bool):  [Read-Write] If true, account for the field of view angle when computing which level of detail to use for meshes.
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], fov: float = 0.000000, ortho_width: float = 0.000000, auto_calculate_ortho_planes: bool = False, auto_plane_shift: float = 0.000000, update_ortho_planes: bool = False, use_camera_height_as_view_target: bool = False, ortho_near_clip_plane: float = 0.000000, ortho_far_clip_plane: float = 0.000000, perspective_near_clip_plane: float = 0.000000, aspect_ratio: float = 0.000000, constrain_aspect_ratio: bool = False, use_field_of_view_for_lod: bool = False, projection_mode: CameraProjectionMode = CameraProjectionMode.PERSPECTIVE, post_process_blend_weight: float = 0.000000, post_process_settings: PostProcessSettings = [], off_center_projection_offset: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Location
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] Rotation
        """
        ...
    @rotation.setter
    def rotation(self, value: Rotator) -> None:
        ...
    @property
    def fov(self) -> float:
        r"""
        (float):  [Read-Write] The horizontal field of view (in degrees) in perspective mode (ignored in orthographic mode).
        """
        ...
    @fov.setter
    def fov(self, value: float) -> None:
        ...
    @property
    def ortho_width(self) -> float:
        r"""
        (float):  [Read-Write] The desired width (in world units) of the orthographic view (ignored in Perspective mode)
        """
        ...
    @ortho_width.setter
    def ortho_width(self, value: float) -> None:
        ...
    @property
    def auto_calculate_ortho_planes(self) -> bool:
        r"""
        (bool):  [Read-Write] Option for the Ortho camera to automatically calculated the near/far plane
        """
        ...
    @auto_calculate_ortho_planes.setter
    def auto_calculate_ortho_planes(self, value: bool) -> None:
        ...
    @property
    def auto_plane_shift(self) -> float:
        r"""
        (float):  [Read-Write] Manually adjusts the planes of this camera, maintaining the distance between them. Positive moves out to the farplane, negative towards the near plane
        """
        ...
    @auto_plane_shift.setter
    def auto_plane_shift(self, value: float) -> None:
        ...
    @property
    def update_ortho_planes(self) -> bool:
        r"""
        (bool):  [Read-Write] Adjusts the near/far planes and the view origin of the current camera automatically to avoid clipping and light artefacting
        """
        ...
    @update_ortho_planes.setter
    def update_ortho_planes(self, value: bool) -> None:
        ...
    @property
    def use_camera_height_as_view_target(self) -> bool:
        r"""
        (bool):  [Read-Write] If UpdateOrthoPlanes is enabled, this setting will use the cameras current height to compensate the distance to the general view (as a pseudo distance to view target when one isn't present)
        """
        ...
    @use_camera_height_as_view_target.setter
    def use_camera_height_as_view_target(self, value: bool) -> None:
        ...
    @property
    def ortho_near_clip_plane(self) -> float:
        r"""
        (float):  [Read-Write] The near plane distance of the orthographic view (in world units)
        """
        ...
    @ortho_near_clip_plane.setter
    def ortho_near_clip_plane(self, value: float) -> None:
        ...
    @property
    def ortho_far_clip_plane(self) -> float:
        r"""
        (float):  [Read-Write] The far plane distance of the orthographic view (in world units)
        """
        ...
    @ortho_far_clip_plane.setter
    def ortho_far_clip_plane(self, value: float) -> None:
        ...
    @property
    def perspective_near_clip_plane(self) -> float:
        r"""
        (float):  [Read-Write] The near plane distance of the perspective view (in world units). Set to a negative value to use the default global value of GNearClippingPlane
        """
        ...
    @perspective_near_clip_plane.setter
    def perspective_near_clip_plane(self, value: float) -> None:
        ...
    @property
    def aspect_ratio(self) -> float:
        r"""
        (float):  [Read-Write] Aspect Ratio (Width/Height)
        """
        ...
    @aspect_ratio.setter
    def aspect_ratio(self, value: float) -> None:
        ...
    @property
    def constrain_aspect_ratio(self) -> bool:
        r"""
        (bool):  [Read-Write] If bConstrainAspectRatio is true, black bars will be added if the destination view has a different aspect ratio than this camera requested.
        """
        ...
    @constrain_aspect_ratio.setter
    def constrain_aspect_ratio(self, value: bool) -> None:
        ...
    @property
    def use_field_of_view_for_lod(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, account for the field of view angle when computing which level of detail to use for meshes.
        """
        ...
    @use_field_of_view_for_lod.setter
    def use_field_of_view_for_lod(self, value: bool) -> None:
        ...
    @property
    def projection_mode(self) -> CameraProjectionMode:
        r"""
        (CameraProjectionMode):  [Read-Write] The type of camera
        """
        ...
    @projection_mode.setter
    def projection_mode(self, value: CameraProjectionMode) -> None:
        ...
    @property
    def post_process_blend_weight(self) -> float:
        r"""
        (float):  [Read-Write] Indicates if PostProcessSettings should be applied.
        """
        ...
    @post_process_blend_weight.setter
    def post_process_blend_weight(self, value: float) -> None:
        ...
    @property
    def post_process_settings(self) -> PostProcessSettings:
        r"""
        (PostProcessSettings):  [Read-Write] Post-process settings to use if PostProcessBlendWeight is non-zero.
        """
        ...
    @post_process_settings.setter
    def post_process_settings(self, value: PostProcessSettings) -> None:
        ...
    @property
    def off_center_projection_offset(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] Off-axis / off-center projection offset as proportion of screen dimensions
        """
        ...
    def calculate_projection_matrix(self) -> Matrix:
        r"""
        x.calculate_projection_matrix() -> Matrix
        Calculates the projection matrix using this view info's aspect ratio (regardless of bConstrainAspectRatio)
        
        Returns:
            Matrix:
        """
        ...

class FractureEffect(StructBase):
    r"""
    Struct used to hold effects for destructible damage events
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``particle_system`` (ParticleSystem):  [Read-Write] Particle system effect to play at fracture location.
    - ``sound`` (SoundBase):  [Read-Write] Sound cue to play at fracture location.
    """
    def __init__(self, particle_system: ParticleSystem = None, sound: SoundBase = None) -> None:
        ...
    @property
    def particle_system(self) -> ParticleSystem:
        r"""
        (ParticleSystem):  [Read-Write] Particle system effect to play at fracture location.
        """
        ...
    @particle_system.setter
    def particle_system(self, value: ParticleSystem) -> None:
        ...
    @property
    def sound(self) -> SoundBase:
        r"""
        (SoundBase):  [Read-Write] Sound cue to play at fracture location.
        """
        ...
    @sound.setter
    def sound(self, value: SoundBase) -> None:
        ...

class BasedPosition(StructBase):
    r"""
    Struct for handling positions relative to a base actor, which is potentially moving
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base`` (Actor):  [Read-Write] Actor that is the base
    - ``position`` (Vector):  [Read-Write] Position relative to the base actor
    """
    def __init__(self, base: Actor = None, position: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def base(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Actor that is the base
        """
        ...
    @base.setter
    def base(self, value: Actor) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Position relative to the base actor
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...

class POV(StructBase):
    r"""
    Point Of View structure used in Camera calculations
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``fov`` (float):  [Read-Write] FOV angle
    - ``location`` (Vector):  [Read-Write] Location
    - ``rotation`` (Rotator):  [Read-Write] Rotation
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], fov: float = 0.000000) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Location
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] Rotation
        """
        ...
    @rotation.setter
    def rotation(self, value: Rotator) -> None:
        ...
    @property
    def fov(self) -> float:
        r"""
        (float):  [Read-Write] FOV angle
        """
        ...
    @fov.setter
    def fov(self, value: float) -> None:
        ...

class MeshBuildSettings(StructBase):
    r"""
    Settings applied when building a mesh.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``build_reversed_index_buffer`` (bool):  [Read-Write] Required to optimize mesh in mirrored transform. Double index buffer size.
    - ``build_scale3d`` (Vector):  [Read-Write] The local scale applied when building the mesh
    - ``compute_weighted_normals`` (bool):  [Read-Write] If true, we will use the surface area and the corner angle of the triangle as a ratio when computing the normals.
    - ``distance_field_replacement_mesh`` (StaticMesh):  [Read-Write]
    - ``distance_field_resolution_scale`` (float):  [Read-Write] Scale to apply to the mesh when allocating the distance field volume texture.
      The default scale is 1, which is assuming that the mesh will be placed unscaled in the world.
    - ``dst_lightmap_index`` (int32):  [Read-Write]
    - ``generate_distance_field_as_if_two_sided`` (bool):  [Read-Write] Whether to generate the distance field treating every triangle hit as a front face.
      When enabled prevents the distance field from being discarded due to the mesh being open, but also lowers Distance Field AO quality.
    - ``generate_lightmap_u_vs`` (bool):  [Read-Write]
    - ``max_lumen_mesh_cards`` (int32):  [Read-Write] Max Lumen mesh cards to generate for this mesh.
      More cards means that surface will have better coverage, but will result in increased runtime overhead.
      Set to 0 in order to disable mesh card generation for this mesh.
      Default is 12.
    - ``min_lightmap_resolution`` (int32):  [Read-Write]
    - ``recompute_normals`` (bool):  [Read-Write] If true, normals in the raw mesh are ignored and recomputed.
    - ``recompute_tangents`` (bool):  [Read-Write] If true, tangents in the raw mesh are ignored and recomputed.
    - ``remove_degenerates`` (bool):  [Read-Write] If true, degenerate triangles will be removed.
    - ``src_lightmap_index`` (int32):  [Read-Write]
    - ``support_face_remap`` (bool):  [Read-Write]
    - ``use_backwards_compatible_f16_trunc_u_vs`` (bool):  [Read-Write] If true, UVs will use backwards-compatible F16 conversion with truncation for legacy meshes.
    - ``use_full_precision_u_vs`` (bool):  [Read-Write] If true, UVs will be stored at full floating point precision.
    - ``use_high_precision_tangent_basis`` (bool):  [Read-Write] If true, Tangents will be stored at 16 bit vs 8 bit precision.
    - ``use_mikk_t_space`` (bool):  [Read-Write] If true, degenerate triangles will be removed.
    """
    def __init__(self, use_mikk_t_space: bool = False, recompute_normals: bool = False, recompute_tangents: bool = False, compute_weighted_normals: bool = False, remove_degenerates: bool = False, build_reversed_index_buffer: bool = False, use_high_precision_tangent_basis: bool = False, use_full_precision_u_vs: bool = False, use_backwards_compatible_f16_trunc_u_vs: bool = False, generate_lightmap_u_vs: bool = False, generate_distance_field_as_if_two_sided: bool = False, support_face_remap: bool = False, min_lightmap_resolution: int = 0, src_lightmap_index: int = 0, dst_lightmap_index: int = 0, build_scale3d: Vector = [0.000000, 0.000000, 0.000000], distance_field_resolution_scale: float = 0.000000, distance_field_replacement_mesh: StaticMesh = None, max_lumen_mesh_cards: int = 0) -> None:
        ...
    @property
    def use_mikk_t_space(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, degenerate triangles will be removed.
        """
        ...
    @use_mikk_t_space.setter
    def use_mikk_t_space(self, value: bool) -> None:
        ...
    @property
    def recompute_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, normals in the raw mesh are ignored and recomputed.
        """
        ...
    @recompute_normals.setter
    def recompute_normals(self, value: bool) -> None:
        ...
    @property
    def recompute_tangents(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, tangents in the raw mesh are ignored and recomputed.
        """
        ...
    @recompute_tangents.setter
    def recompute_tangents(self, value: bool) -> None:
        ...
    @property
    def compute_weighted_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, we will use the surface area and the corner angle of the triangle as a ratio when computing the normals.
        """
        ...
    @compute_weighted_normals.setter
    def compute_weighted_normals(self, value: bool) -> None:
        ...
    @property
    def remove_degenerates(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, degenerate triangles will be removed.
        """
        ...
    @remove_degenerates.setter
    def remove_degenerates(self, value: bool) -> None:
        ...
    @property
    def build_reversed_index_buffer(self) -> bool:
        r"""
        (bool):  [Read-Write] Required to optimize mesh in mirrored transform. Double index buffer size.
        """
        ...
    @build_reversed_index_buffer.setter
    def build_reversed_index_buffer(self, value: bool) -> None:
        ...
    @property
    def use_high_precision_tangent_basis(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, Tangents will be stored at 16 bit vs 8 bit precision.
        """
        ...
    @use_high_precision_tangent_basis.setter
    def use_high_precision_tangent_basis(self, value: bool) -> None:
        ...
    @property
    def use_full_precision_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, UVs will be stored at full floating point precision.
        """
        ...
    @use_full_precision_u_vs.setter
    def use_full_precision_u_vs(self, value: bool) -> None:
        ...
    @property
    def use_backwards_compatible_f16_trunc_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, UVs will use backwards-compatible F16 conversion with truncation for legacy meshes.
        """
        ...
    @use_backwards_compatible_f16_trunc_u_vs.setter
    def use_backwards_compatible_f16_trunc_u_vs(self, value: bool) -> None:
        ...
    @property
    def generate_lightmap_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @generate_lightmap_u_vs.setter
    def generate_lightmap_u_vs(self, value: bool) -> None:
        ...
    @property
    def generate_distance_field_as_if_two_sided(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate the distance field treating every triangle hit as a front face.
        When enabled prevents the distance field from being discarded due to the mesh being open, but also lowers Distance Field AO quality.
        """
        ...
    @generate_distance_field_as_if_two_sided.setter
    def generate_distance_field_as_if_two_sided(self, value: bool) -> None:
        ...
    @property
    def support_face_remap(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @support_face_remap.setter
    def support_face_remap(self, value: bool) -> None:
        ...
    @property
    def min_lightmap_resolution(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @min_lightmap_resolution.setter
    def min_lightmap_resolution(self, value: int) -> None:
        ...
    @property
    def src_lightmap_index(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @src_lightmap_index.setter
    def src_lightmap_index(self, value: int) -> None:
        ...
    @property
    def dst_lightmap_index(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @dst_lightmap_index.setter
    def dst_lightmap_index(self, value: int) -> None:
        ...
    @property
    def build_scale3d(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The local scale applied when building the mesh
        """
        ...
    @build_scale3d.setter
    def build_scale3d(self, value: Vector) -> None:
        ...
    @property
    def distance_field_resolution_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scale to apply to the mesh when allocating the distance field volume texture.
        The default scale is 1, which is assuming that the mesh will be placed unscaled in the world.
        """
        ...
    @distance_field_resolution_scale.setter
    def distance_field_resolution_scale(self, value: float) -> None:
        ...
    @property
    def distance_field_replacement_mesh(self) -> StaticMesh:
        r"""
        (StaticMesh):  [Read-Write]
        """
        ...
    @distance_field_replacement_mesh.setter
    def distance_field_replacement_mesh(self, value: StaticMesh) -> None:
        ...
    @property
    def max_lumen_mesh_cards(self) -> int:
        r"""
        (int32):  [Read-Write] Max Lumen mesh cards to generate for this mesh.
        More cards means that surface will have better coverage, but will result in increased runtime overhead.
        Set to 0 in order to disable mesh card generation for this mesh.
        Default is 12.
        """
        ...
    @max_lumen_mesh_cards.setter
    def max_lumen_mesh_cards(self, value: int) -> None:
        ...

class SkeletalMeshBuildSettings(StructBase):
    r"""
    Settings applied when building a mesh.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_influence_limit`` (int32):  [Read-Write] The maximum number of bone influences to allow each vertex in this mesh to use.
      
      If set higher than the limit determined by the project settings, it has no effect.
      
      If set to 0, the value is taken from the DefaultBoneInfluenceLimit project setting.
    - ``compute_weighted_normals`` (bool):  [Read-Write] If true, we will use the surface area and the corner angle of the triangle as a ratio when computing the normals.
    - ``morph_threshold_position`` (float):  [Read-Write] Threshold to compare vertex position equality when computing morph target deltas.
    - ``recompute_normals`` (bool):  [Read-Write] If true, normals in the raw mesh are ignored and recomputed.
    - ``recompute_tangents`` (bool):  [Read-Write] If true, tangents in the raw mesh are ignored and recomputed.
    - ``remove_degenerates`` (bool):  [Read-Write] If true, degenerate triangles will be removed.
    - ``threshold_position`` (float):  [Read-Write] Threshold use to decide if two vertex position are equal.
    - ``threshold_tangent_normal`` (float):  [Read-Write] Threshold use to decide if two normal, tangents or bi-normals are equal.
    - ``threshold_uv`` (float):  [Read-Write] Threshold use to decide if two UVs are equal.
    - ``use_backwards_compatible_f16_trunc_u_vs`` (bool):  [Read-Write] If true, UVs will use backwards-compatible F16 conversion with truncation for legacy meshes.
    - ``use_full_precision_u_vs`` (bool):  [Read-Write] If true, UVs will be stored at full floating point precision.
    - ``use_high_precision_skin_weights`` (bool):  [Read-Write] Use 16-bit precision for rendering skin weights, instead of 8-bit precision.
    - ``use_high_precision_tangent_basis`` (bool):  [Read-Write] If true, Tangents will be stored at 16 bit vs 8 bit precision.
    - ``use_mikk_t_space`` (bool):  [Read-Write] If true, degenerate triangles will be removed.
    """
    def __init__(self, recompute_normals: bool = False, recompute_tangents: bool = False, use_mikk_t_space: bool = False, compute_weighted_normals: bool = False, remove_degenerates: bool = False, use_high_precision_tangent_basis: bool = False, use_high_precision_skin_weights: bool = False, use_full_precision_u_vs: bool = False, use_backwards_compatible_f16_trunc_u_vs: bool = False, threshold_position: float = 0.000000, threshold_tangent_normal: float = 0.000000, threshold_uv: float = 0.000000, morph_threshold_position: float = 0.000000, bone_influence_limit: int = 0) -> None:
        ...
    @property
    def recompute_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, normals in the raw mesh are ignored and recomputed.
        """
        ...
    @recompute_normals.setter
    def recompute_normals(self, value: bool) -> None:
        ...
    @property
    def recompute_tangents(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, tangents in the raw mesh are ignored and recomputed.
        """
        ...
    @recompute_tangents.setter
    def recompute_tangents(self, value: bool) -> None:
        ...
    @property
    def use_mikk_t_space(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, degenerate triangles will be removed.
        """
        ...
    @use_mikk_t_space.setter
    def use_mikk_t_space(self, value: bool) -> None:
        ...
    @property
    def compute_weighted_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, we will use the surface area and the corner angle of the triangle as a ratio when computing the normals.
        """
        ...
    @compute_weighted_normals.setter
    def compute_weighted_normals(self, value: bool) -> None:
        ...
    @property
    def remove_degenerates(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, degenerate triangles will be removed.
        """
        ...
    @remove_degenerates.setter
    def remove_degenerates(self, value: bool) -> None:
        ...
    @property
    def use_high_precision_tangent_basis(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, Tangents will be stored at 16 bit vs 8 bit precision.
        """
        ...
    @use_high_precision_tangent_basis.setter
    def use_high_precision_tangent_basis(self, value: bool) -> None:
        ...
    @property
    def use_high_precision_skin_weights(self) -> bool:
        r"""
        (bool):  [Read-Write] Use 16-bit precision for rendering skin weights, instead of 8-bit precision.
        """
        ...
    @use_high_precision_skin_weights.setter
    def use_high_precision_skin_weights(self, value: bool) -> None:
        ...
    @property
    def use_full_precision_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, UVs will be stored at full floating point precision.
        """
        ...
    @use_full_precision_u_vs.setter
    def use_full_precision_u_vs(self, value: bool) -> None:
        ...
    @property
    def use_backwards_compatible_f16_trunc_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, UVs will use backwards-compatible F16 conversion with truncation for legacy meshes.
        """
        ...
    @use_backwards_compatible_f16_trunc_u_vs.setter
    def use_backwards_compatible_f16_trunc_u_vs(self, value: bool) -> None:
        ...
    @property
    def threshold_position(self) -> float:
        r"""
        (float):  [Read-Write] Threshold use to decide if two vertex position are equal.
        """
        ...
    @threshold_position.setter
    def threshold_position(self, value: float) -> None:
        ...
    @property
    def threshold_tangent_normal(self) -> float:
        r"""
        (float):  [Read-Write] Threshold use to decide if two normal, tangents or bi-normals are equal.
        """
        ...
    @threshold_tangent_normal.setter
    def threshold_tangent_normal(self, value: float) -> None:
        ...
    @property
    def threshold_uv(self) -> float:
        r"""
        (float):  [Read-Write] Threshold use to decide if two UVs are equal.
        """
        ...
    @threshold_uv.setter
    def threshold_uv(self, value: float) -> None:
        ...
    @property
    def morph_threshold_position(self) -> float:
        r"""
        (float):  [Read-Write] Threshold to compare vertex position equality when computing morph target deltas.
        """
        ...
    @morph_threshold_position.setter
    def morph_threshold_position(self, value: float) -> None:
        ...
    @property
    def bone_influence_limit(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of bone influences to allow each vertex in this mesh to use.
        
        If set higher than the limit determined by the project settings, it has no effect.
        
        If set to 0, the value is taken from the DefaultBoneInfluenceLimit project setting.
        """
        ...
    @bone_influence_limit.setter
    def bone_influence_limit(self, value: int) -> None:
        ...

class MeshDisplacementMap(StructBase):
    r"""
    Mesh Displacement Map
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``center`` (float):  [Read-Write]
    - ``magnitude`` (float):  [Read-Write]
    - ``texture`` (Texture2D):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MeshNaniteSettings(StructBase):
    r"""
    Settings applied when building Nanite data.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``displacement_maps`` (Array[MeshDisplacementMap]):  [Read-Write]
    - ``displacement_uv_channel`` (int32):  [Read-Write] UV channel used to sample displacement maps
    - ``enabled`` (bool):  [Read-Write] If true, Nanite data will be generated.
    - ``explicit_tangents`` (bool):  [Read-Write] Whether to store explicit tangents instead of using the implicitly derived ones.
    - ``fallback_percent_triangles`` (float):  [Read-Write] Percentage of triangles to keep from source mesh for fallback. 1.0 = no reduction, 0.0 = no triangles.
    - ``fallback_relative_error`` (float):  [Read-Write] Reduce until at least this amount of error is reached relative to size of the mesh
    - ``fallback_target`` (NaniteFallbackTarget):  [Read-Write] Which heuristic to use when generating the fallback mesh.
    - ``keep_percent_triangles`` (float):  [Read-Write] Percentage of triangles to keep from source mesh. 1.0 = no reduction, 0.0 = no triangles.
    - ``lerp_u_vs`` (bool):  [Read-Write] Whether to interpolate UVs when simplifying.
      Should be enabled whenever possible.
      For real UV coordinates this allows calculating the lowest error optimal UVs for new vertices when simplifying,
      assuming the UVs are used as normal texture coordinates and will interpolate across the face of the triangles.
      
      Disable if data stored in UVs isn't valid to interpolate, for example if indexes are stored in UVs.
      Lerping an index doesn't make sense and would break the shader trying to use it.
      Note: If disabled, error from UVs is no longer accounted for when Nanite selects the LOD to render because
      error due to arbitary vertex attributes that aren't interpolatable can't be generally reasoned about.
    - ``max_edge_length_factor`` (float):  [Read-Write] Controls the maximum distance allowed between each vertex of the mesh on screen. Can be used to prevent oversimplification
      of meshes that are intended to be deformed (e.g. animation using World Position Offset, Spline Mesh Component, etc.).
      Should be left at default of 0 unless explicitly needed to fix oversimplification issues.
    - ``normal_precision`` (int32):  [Read-Write] Normal Precision in bits. -1 is auto.
    - ``position_precision`` (int32):  [Read-Write] Position Precision. Step size is 2^(-PositionPrecision) cm. MIN_int32 is auto.
    - ``preserve_area`` (bool):  [Read-Write] Whether to try and maintain the same surface area at all distances. Useful for foliage that thins out otherwise.
    - ``tangent_precision`` (int32):  [Read-Write] Tangent Precision in bits. -1 is auto.
    - ``target_minimum_residency_in_kb`` (uint32):  [Read-Write] How much of the resource should always be resident (In KB). Approximate due to paging. 0: Minimum size (single page). MAX_uint32: Entire mesh.
    - ``trim_relative_error`` (float):  [Read-Write] Reduce until at least this amount of error is reached relative to size of the mesh
    """
    def __init__(self, enabled: bool = False, preserve_area: bool = False, explicit_tangents: bool = False, lerp_u_vs: bool = False, position_precision: int = 0, normal_precision: int = 0, tangent_precision: int = 0, keep_percent_triangles: float = 0.000000, trim_relative_error: float = 0.000000, fallback_target: NaniteFallbackTarget = NaniteFallbackTarget.AUTO, fallback_percent_triangles: float = 0.000000, fallback_relative_error: float = 0.000000, max_edge_length_factor: float = 0.000000, displacement_uv_channel: int = 0) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, Nanite data will be generated.
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def preserve_area(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to try and maintain the same surface area at all distances. Useful for foliage that thins out otherwise.
        """
        ...
    @preserve_area.setter
    def preserve_area(self, value: bool) -> None:
        ...
    @property
    def explicit_tangents(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to store explicit tangents instead of using the implicitly derived ones.
        """
        ...
    @explicit_tangents.setter
    def explicit_tangents(self, value: bool) -> None:
        ...
    @property
    def lerp_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to interpolate UVs when simplifying.
        Should be enabled whenever possible.
        For real UV coordinates this allows calculating the lowest error optimal UVs for new vertices when simplifying,
        assuming the UVs are used as normal texture coordinates and will interpolate across the face of the triangles.
        
        Disable if data stored in UVs isn't valid to interpolate, for example if indexes are stored in UVs.
        Lerping an index doesn't make sense and would break the shader trying to use it.
        Note: If disabled, error from UVs is no longer accounted for when Nanite selects the LOD to render because
        error due to arbitary vertex attributes that aren't interpolatable can't be generally reasoned about.
        """
        ...
    @lerp_u_vs.setter
    def lerp_u_vs(self, value: bool) -> None:
        ...
    @property
    def position_precision(self) -> int:
        r"""
        (int32):  [Read-Write] Position Precision. Step size is 2^(-PositionPrecision) cm. MIN_int32 is auto.
        """
        ...
    @position_precision.setter
    def position_precision(self, value: int) -> None:
        ...
    @property
    def normal_precision(self) -> int:
        r"""
        (int32):  [Read-Write] Normal Precision in bits. -1 is auto.
        """
        ...
    @normal_precision.setter
    def normal_precision(self, value: int) -> None:
        ...
    @property
    def tangent_precision(self) -> int:
        r"""
        (int32):  [Read-Write] Tangent Precision in bits. -1 is auto.
        """
        ...
    @tangent_precision.setter
    def tangent_precision(self, value: int) -> None:
        ...
    @property
    def keep_percent_triangles(self) -> float:
        r"""
        (float):  [Read-Write] Percentage of triangles to keep from source mesh. 1.0 = no reduction, 0.0 = no triangles.
        """
        ...
    @keep_percent_triangles.setter
    def keep_percent_triangles(self, value: float) -> None:
        ...
    @property
    def trim_relative_error(self) -> float:
        r"""
        (float):  [Read-Write] Reduce until at least this amount of error is reached relative to size of the mesh
        """
        ...
    @trim_relative_error.setter
    def trim_relative_error(self, value: float) -> None:
        ...
    @property
    def fallback_target(self) -> NaniteFallbackTarget:
        r"""
        (NaniteFallbackTarget):  [Read-Write] Which heuristic to use when generating the fallback mesh.
        """
        ...
    @fallback_target.setter
    def fallback_target(self, value: NaniteFallbackTarget) -> None:
        ...
    @property
    def fallback_percent_triangles(self) -> float:
        r"""
        (float):  [Read-Write] Percentage of triangles to keep from source mesh for fallback. 1.0 = no reduction, 0.0 = no triangles.
        """
        ...
    @fallback_percent_triangles.setter
    def fallback_percent_triangles(self, value: float) -> None:
        ...
    @property
    def fallback_relative_error(self) -> float:
        r"""
        (float):  [Read-Write] Reduce until at least this amount of error is reached relative to size of the mesh
        """
        ...
    @fallback_relative_error.setter
    def fallback_relative_error(self, value: float) -> None:
        ...
    @property
    def max_edge_length_factor(self) -> float:
        r"""
        (float):  [Read-Write] Controls the maximum distance allowed between each vertex of the mesh on screen. Can be used to prevent oversimplification
        of meshes that are intended to be deformed (e.g. animation using World Position Offset, Spline Mesh Component, etc.).
        Should be left at default of 0 unless explicitly needed to fix oversimplification issues.
        """
        ...
    @max_edge_length_factor.setter
    def max_edge_length_factor(self, value: float) -> None:
        ...
    @property
    def displacement_uv_channel(self) -> int:
        r"""
        (int32):  [Read-Write] UV channel used to sample displacement maps
        """
        ...
    @displacement_uv_channel.setter
    def displacement_uv_channel(self, value: int) -> None:
        ...

class DisplacementScaling(StructBase):
    r"""
    Displacement Scaling
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``center`` (float):  [Read-Write]
    - ``magnitude`` (float):  [Read-Write]
    """
    def __init__(self, magnitude: float = 0.000000, center: float = 0.000000) -> None:
        ...
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...
    @property
    def center(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @center.setter
    def center(self, value: float) -> None:
        ...

class CollectionReference(StructBase):
    r"""
    Reference to an editor collection of assets. This allows an editor-only picker UI
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection_name`` (Name):  [Read-Write] Name of the collection
    """
    def __init__(self, collection_name: Name = "None") -> None:
        ...
    @property
    def collection_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of the collection
        """
        ...
    @collection_name.setter
    def collection_name(self, value: Name) -> None:
        ...

class DepthFieldGlowInfo(StructBase):
    r"""
    Info for glow when using depth field rendering
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_glow`` (bool):  [Read-Write] Whether to turn on the outline glow (depth field fonts only)
    - ``glow_color`` (LinearColor):  [Read-Write] Base color to use for the glow
    - ``glow_inner_radius`` (Vector2D):  [Read-Write] If bEnableGlow, outline glow inner radius (0 to 1, 0.5 is edge of character silhouette)
      glow influence will be 1 at GlowInnerRadius.X and 0 at GlowInnerRadius.Y
    - ``glow_outer_radius`` (Vector2D):  [Read-Write] If bEnableGlow, outline glow outer radius (0 to 1, 0.5 is edge of character silhouette)
      glow influence will be 0 at GlowOuterRadius.X and 1 at GlowOuterRadius.Y
    """
    def __init__(self, enable_glow: bool = False, glow_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], glow_outer_radius: Vector2D = [0.000000, 0.000000], glow_inner_radius: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def enable_glow(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to turn on the outline glow (depth field fonts only)
        """
        ...
    @enable_glow.setter
    def enable_glow(self, value: bool) -> None:
        ...
    @property
    def glow_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Base color to use for the glow
        """
        ...
    @glow_color.setter
    def glow_color(self, value: LinearColor) -> None:
        ...
    @property
    def glow_outer_radius(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] If bEnableGlow, outline glow outer radius (0 to 1, 0.5 is edge of character silhouette)
        glow influence will be 0 at GlowOuterRadius.X and 1 at GlowOuterRadius.Y
        """
        ...
    @glow_outer_radius.setter
    def glow_outer_radius(self, value: Vector2D) -> None:
        ...
    @property
    def glow_inner_radius(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] If bEnableGlow, outline glow inner radius (0 to 1, 0.5 is edge of character silhouette)
        glow influence will be 1 at GlowInnerRadius.X and 0 at GlowInnerRadius.Y
        """
        ...
    @glow_inner_radius.setter
    def glow_inner_radius(self, value: Vector2D) -> None:
        ...

class FontRenderInfo(StructBase):
    r"""
    Information used in font rendering
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clip_text`` (bool):  [Read-Write] Whether to clip text
    - ``enable_shadow`` (bool):  [Read-Write] Whether to turn on shadowing
    - ``glow_info`` (DepthFieldGlowInfo):  [Read-Write] Depth field glow parameters (only usable if font was imported with a depth field)
    """
    def __init__(self, clip_text: bool = False, enable_shadow: bool = False, glow_info: DepthFieldGlowInfo = [False, [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000], [0.000000, 0.000000]]) -> None:
        ...
    @property
    def clip_text(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to clip text
        """
        ...
    @clip_text.setter
    def clip_text(self, value: bool) -> None:
        ...
    @property
    def enable_shadow(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to turn on shadowing
        """
        ...
    @enable_shadow.setter
    def enable_shadow(self, value: bool) -> None:
        ...
    @property
    def glow_info(self) -> DepthFieldGlowInfo:
        r"""
        (DepthFieldGlowInfo):  [Read-Write] Depth field glow parameters (only usable if font was imported with a depth field)
        """
        ...
    @glow_info.setter
    def glow_info(self, value: DepthFieldGlowInfo) -> None:
        ...

class CanvasUVTri(StructBase):
    r"""
    Simple 2d triangle with UVs
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``v0_color`` (LinearColor):  [Read-Write] Color of first vertex
    - ``v0_pos`` (Vector2D):  [Read-Write] Position of first vertex
    - ``v0_uv`` (Vector2D):  [Read-Write] UV of first vertex
    - ``v1_color`` (LinearColor):  [Read-Write] Color of second vertex
    - ``v1_pos`` (Vector2D):  [Read-Write] Position of second vertex
    - ``v1_uv`` (Vector2D):  [Read-Write] UV of second vertex
    - ``v2_color`` (LinearColor):  [Read-Write] Color of third vertex
    - ``v2_pos`` (Vector2D):  [Read-Write] Position of third vertex
    - ``v2_uv`` (Vector2D):  [Read-Write] UV of third vertex
    """
    def __init__(self, v0_pos: Vector2D = [0.000000, 0.000000], v0_uv: Vector2D = [0.000000, 0.000000], v0_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], v1_pos: Vector2D = [0.000000, 0.000000], v1_uv: Vector2D = [0.000000, 0.000000], v1_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], v2_pos: Vector2D = [0.000000, 0.000000], v2_uv: Vector2D = [0.000000, 0.000000], v2_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def v0_pos(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Position of first vertex
        """
        ...
    @v0_pos.setter
    def v0_pos(self, value: Vector2D) -> None:
        ...
    @property
    def v0_uv(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] UV of first vertex
        """
        ...
    @v0_uv.setter
    def v0_uv(self, value: Vector2D) -> None:
        ...
    @property
    def v0_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Color of first vertex
        """
        ...
    @v0_color.setter
    def v0_color(self, value: LinearColor) -> None:
        ...
    @property
    def v1_pos(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Position of second vertex
        """
        ...
    @v1_pos.setter
    def v1_pos(self, value: Vector2D) -> None:
        ...
    @property
    def v1_uv(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] UV of second vertex
        """
        ...
    @v1_uv.setter
    def v1_uv(self, value: Vector2D) -> None:
        ...
    @property
    def v1_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Color of second vertex
        """
        ...
    @v1_color.setter
    def v1_color(self, value: LinearColor) -> None:
        ...
    @property
    def v2_pos(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Position of third vertex
        """
        ...
    @v2_pos.setter
    def v2_pos(self, value: Vector2D) -> None:
        ...
    @property
    def v2_uv(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] UV of third vertex
        """
        ...
    @v2_uv.setter
    def v2_uv(self, value: Vector2D) -> None:
        ...
    @property
    def v2_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Color of third vertex
        """
        ...
    @v2_color.setter
    def v2_color(self, value: LinearColor) -> None:
        ...

class ExponentialHeightFogData(StructBase):
    r"""
    Data for an individual fog line integral.
    This is the data which is not shared between fogs when multiple fogs are set up on a single UExponentialHeightFogComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ExponentialHeightFogComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``fog_density`` (float):  [Read-Write] Global density factor for this fog.
    - ``fog_height_falloff`` (float):  [Read-Write] Height density factor, controls how the density increases as height decreases.
      Smaller values make the visible transition larger.
    - ``fog_height_offset`` (float):  [Read-Write] Height offset, relative to the actor position Z.
    """
    def __init__(self, fog_density: float = 0.000000, fog_height_falloff: float = 0.000000, fog_height_offset: float = 0.000000) -> None:
        ...
    @property
    def fog_density(self) -> float:
        r"""
        (float):  [Read-Only] Global density factor for this fog.
        """
        ...
    @property
    def fog_height_falloff(self) -> float:
        r"""
        (float):  [Read-Only] Height density factor, controls how the density increases as height decreases.
        Smaller values make the visible transition larger.
        """
        ...
    @property
    def fog_height_offset(self) -> float:
        r"""
        (float):  [Read-Only] Height offset, relative to the actor position Z.
        """
        ...

class BaseAttenuationSettings(StructBase):
    r"""
    * Base class for attenuation settings.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Attenuation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attenuation_shape`` (AttenuationShape):  [Read-Write] The shape of the non-custom attenuation method.
    - ``attenuation_shape_extents`` (Vector):  [Read-Write] The dimensions to use for the attenuation shape. Interpretation of the values differ per shape.
               Sphere  - X is Sphere Radius. Y and Z are unused
               Capsule - X is Capsule Half Height, Y is Capsule Radius, Z is unused
               Box     - X, Y, and Z are the Box's dimensions
               Cone    - X is Cone Radius, Y is Cone Angle, Z is Cone Falloff Angle
    - ``cone_offset`` (float):  [Read-Write] The distance back from the sound's origin to begin the cone when using the cone attenuation shape.
    - ``cone_sphere_falloff_distance`` (float):  [Read-Write] The distance over which volume attenuation occurs for the optional sphere shape.
    - ``cone_sphere_radius`` (float):  [Read-Write] An optional attenuation radius (sphere) that extends from the cone origin.
    - ``custom_attenuation_curve`` (RuntimeFloatCurve):  [Read-Write] The custom volume attenuation curve to use.
    - ``d_b_attenuation_at_max`` (float):  [Read-Write] The attenuation volume at the falloff distance in decibels (Only for 'Natural Sound' Distance Algorithm).
    - ``distance_algorithm`` (AttenuationDistanceModel):  [Read-Write] The type of attenuation as a function of distance to use.
    - ``falloff_distance`` (float):  [Read-Write] The distance over which volume attenuation occurs.
    - ``falloff_mode`` (NaturalSoundFalloffMode):  [Read-Write] Whether to continue attenuating, go silent, or hold last volume value when beyond falloff bounds and
      'Attenuation At Max (dB)' is set to a value greater than -60dB.
      (Only for 'Natural Sound' Distance Algorithm). */
    """
    def __init__(self, distance_algorithm: AttenuationDistanceModel = AttenuationDistanceModel.LINEAR, attenuation_shape: AttenuationShape = AttenuationShape.SPHERE, falloff_mode: NaturalSoundFalloffMode = NaturalSoundFalloffMode.CONTINUES, d_b_attenuation_at_max: float = 0.000000, attenuation_shape_extents: Vector = [0.000000, 0.000000, 0.000000], cone_offset: float = 0.000000, falloff_distance: float = 0.000000, cone_sphere_radius: float = 0.000000, cone_sphere_falloff_distance: float = 0.000000, custom_attenuation_curve: RuntimeFloatCurve = []) -> None:
        ...
    @property
    def distance_algorithm(self) -> AttenuationDistanceModel:
        r"""
        (AttenuationDistanceModel):  [Read-Write] The type of attenuation as a function of distance to use.
        """
        ...
    @distance_algorithm.setter
    def distance_algorithm(self, value: AttenuationDistanceModel) -> None:
        ...
    @property
    def attenuation_shape(self) -> AttenuationShape:
        r"""
        (AttenuationShape):  [Read-Write] The shape of the non-custom attenuation method.
        """
        ...
    @attenuation_shape.setter
    def attenuation_shape(self, value: AttenuationShape) -> None:
        ...
    @property
    def falloff_mode(self) -> NaturalSoundFalloffMode:
        r"""
        (NaturalSoundFalloffMode):  [Read-Write] Whether to continue attenuating, go silent, or hold last volume value when beyond falloff bounds and
        'Attenuation At Max (dB)' is set to a value greater than -60dB.
        (Only for 'Natural Sound' Distance Algorithm). */
        """
        ...
    @falloff_mode.setter
    def falloff_mode(self, value: NaturalSoundFalloffMode) -> None:
        ...
    @property
    def d_b_attenuation_at_max(self) -> float:
        r"""
        (float):  [Read-Write] The attenuation volume at the falloff distance in decibels (Only for 'Natural Sound' Distance Algorithm).
        """
        ...
    @d_b_attenuation_at_max.setter
    def d_b_attenuation_at_max(self, value: float) -> None:
        ...
    @property
    def attenuation_shape_extents(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The dimensions to use for the attenuation shape. Interpretation of the values differ per shape.
                 Sphere  - X is Sphere Radius. Y and Z are unused
                 Capsule - X is Capsule Half Height, Y is Capsule Radius, Z is unused
                 Box     - X, Y, and Z are the Box's dimensions
                 Cone    - X is Cone Radius, Y is Cone Angle, Z is Cone Falloff Angle
        """
        ...
    @attenuation_shape_extents.setter
    def attenuation_shape_extents(self, value: Vector) -> None:
        ...
    @property
    def cone_offset(self) -> float:
        r"""
        (float):  [Read-Write] The distance back from the sound's origin to begin the cone when using the cone attenuation shape.
        """
        ...
    @cone_offset.setter
    def cone_offset(self, value: float) -> None:
        ...
    @property
    def falloff_distance(self) -> float:
        r"""
        (float):  [Read-Write] The distance over which volume attenuation occurs.
        """
        ...
    @falloff_distance.setter
    def falloff_distance(self, value: float) -> None:
        ...
    @property
    def cone_sphere_radius(self) -> float:
        r"""
        (float):  [Read-Write] An optional attenuation radius (sphere) that extends from the cone origin.
        """
        ...
    @cone_sphere_radius.setter
    def cone_sphere_radius(self, value: float) -> None:
        ...
    @property
    def cone_sphere_falloff_distance(self) -> float:
        r"""
        (float):  [Read-Write] The distance over which volume attenuation occurs for the optional sphere shape.
        """
        ...
    @cone_sphere_falloff_distance.setter
    def cone_sphere_falloff_distance(self, value: float) -> None:
        ...
    @property
    def custom_attenuation_curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Write] The custom volume attenuation curve to use.
        """
        ...
    @custom_attenuation_curve.setter
    def custom_attenuation_curve(self, value: RuntimeFloatCurve) -> None:
        ...

class ForceFeedbackAttenuationSettings(BaseAttenuationSettings):
    r"""
    The struct for defining the properties used when determining attenuation for a force feedback effect
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ForceFeedbackAttenuation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attenuation_shape`` (AttenuationShape):  [Read-Write] The shape of the non-custom attenuation method.
    - ``attenuation_shape_extents`` (Vector):  [Read-Write] The dimensions to use for the attenuation shape. Interpretation of the values differ per shape.
               Sphere  - X is Sphere Radius. Y and Z are unused
               Capsule - X is Capsule Half Height, Y is Capsule Radius, Z is unused
               Box     - X, Y, and Z are the Box's dimensions
               Cone    - X is Cone Radius, Y is Cone Angle, Z is Cone Falloff Angle
    - ``cone_offset`` (float):  [Read-Write] The distance back from the sound's origin to begin the cone when using the cone attenuation shape.
    - ``cone_sphere_falloff_distance`` (float):  [Read-Write] The distance over which volume attenuation occurs for the optional sphere shape.
    - ``cone_sphere_radius`` (float):  [Read-Write] An optional attenuation radius (sphere) that extends from the cone origin.
    - ``custom_attenuation_curve`` (RuntimeFloatCurve):  [Read-Write] The custom volume attenuation curve to use.
    - ``d_b_attenuation_at_max`` (float):  [Read-Write] The attenuation volume at the falloff distance in decibels (Only for 'Natural Sound' Distance Algorithm).
    - ``distance_algorithm`` (AttenuationDistanceModel):  [Read-Write] The type of attenuation as a function of distance to use.
    - ``falloff_distance`` (float):  [Read-Write] The distance over which volume attenuation occurs.
    - ``falloff_mode`` (NaturalSoundFalloffMode):  [Read-Write] Whether to continue attenuating, go silent, or hold last volume value when beyond falloff bounds and
      'Attenuation At Max (dB)' is set to a value greater than -60dB.
      (Only for 'Natural Sound' Distance Algorithm). */
    """
    def __init__(self, distance_algorithm: AttenuationDistanceModel = AttenuationDistanceModel.LINEAR, attenuation_shape: AttenuationShape = AttenuationShape.SPHERE, falloff_mode: NaturalSoundFalloffMode = NaturalSoundFalloffMode.CONTINUES, d_b_attenuation_at_max: float = 0.000000, attenuation_shape_extents: Vector = [0.000000, 0.000000, 0.000000], cone_offset: float = 0.000000, falloff_distance: float = 0.000000, cone_sphere_radius: float = 0.000000, cone_sphere_falloff_distance: float = 0.000000, custom_attenuation_curve: RuntimeFloatCurve = []) -> None:
        ...

class PredictProjectilePathParams(StructBase):
    r"""
    Input parameters to PredictProjectilePath functions.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameplayStaticsTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actors_to_ignore`` (Array[Actor]):  [Read-Write] Actors to ignore when tracing with collision.
    - ``draw_debug_time`` (float):  [Read-Write] Duration of debug lines (only relevant for DrawDebugType::Duration)
    - ``draw_debug_type`` (DrawDebugTrace):  [Read-Write] Debug drawing duration option.
    - ``launch_velocity`` (Vector):  [Read-Write] Initial launch velocity at the start of the trace.
    - ``max_sim_time`` (float):  [Read-Write] Maximum simulation time for the virtual projectile.
    - ``object_types`` (Array[ObjectTypeQuery]):  [Read-Write] Object type to use, if tracing with collision.
    - ``override_gravity_z`` (float):  [Read-Write] Optional override of Gravity (if 0, uses WorldGravityZ).
    - ``projectile_radius`` (float):  [Read-Write] Projectile radius, used when tracing for collision. If <= 0, a line trace is used instead.
    - ``sim_frequency`` (float):  [Read-Write] Determines size of each sub-step in the simulation (chopping up MaxSimTime). Recommended between 10 to 30 depending on desired quality versus performance.
    - ``start_location`` (Vector):  [Read-Write] Location of the start of the trace.
    - ``trace_channel`` (CollisionChannel):  [Read-Write] Trace channel to use, if tracing with collision.
    - ``trace_complex`` (bool):  [Read-Write] Trace against complex collision (triangles rather than simple primitives) if tracing with collision.
    - ``trace_with_channel`` (bool):  [Read-Write] Whether or not to use TraceChannel, if tracing with collision.
    - ``trace_with_collision`` (bool):  [Read-Write] Whether to trace along the path looking for blocking collision and stopping at the first hit.
    """
    def __init__(self, start_location: Vector = [0.000000, 0.000000, 0.000000], launch_velocity: Vector = [0.000000, 0.000000, 0.000000], trace_with_collision: bool = False, projectile_radius: float = 0.000000, max_sim_time: float = 0.000000, trace_with_channel: bool = False, trace_channel: CollisionChannel = CollisionChannel.ECC_WORLD_STATIC, object_types: Array[ObjectTypeQuery] = [], actors_to_ignore: Array[Actor] = [], sim_frequency: float = 0.000000, override_gravity_z: float = 0.000000, draw_debug_type: DrawDebugTrace = DrawDebugTrace.NONE, draw_debug_time: float = 0.000000, trace_complex: bool = False) -> None:
        ...
    @property
    def start_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Location of the start of the trace.
        """
        ...
    @start_location.setter
    def start_location(self, value: Vector) -> None:
        ...
    @property
    def launch_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Initial launch velocity at the start of the trace.
        """
        ...
    @launch_velocity.setter
    def launch_velocity(self, value: Vector) -> None:
        ...
    @property
    def trace_with_collision(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to trace along the path looking for blocking collision and stopping at the first hit.
        """
        ...
    @trace_with_collision.setter
    def trace_with_collision(self, value: bool) -> None:
        ...
    @property
    def projectile_radius(self) -> float:
        r"""
        (float):  [Read-Write] Projectile radius, used when tracing for collision. If <= 0, a line trace is used instead.
        """
        ...
    @projectile_radius.setter
    def projectile_radius(self, value: float) -> None:
        ...
    @property
    def max_sim_time(self) -> float:
        r"""
        (float):  [Read-Write] Maximum simulation time for the virtual projectile.
        """
        ...
    @max_sim_time.setter
    def max_sim_time(self, value: float) -> None:
        ...
    @property
    def trace_with_channel(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to use TraceChannel, if tracing with collision.
        """
        ...
    @trace_with_channel.setter
    def trace_with_channel(self, value: bool) -> None:
        ...
    @property
    def trace_channel(self) -> CollisionChannel:
        r"""
        (CollisionChannel):  [Read-Write] Trace channel to use, if tracing with collision.
        """
        ...
    @trace_channel.setter
    def trace_channel(self, value: CollisionChannel) -> None:
        ...
    @property
    def object_types(self) -> Array[ObjectTypeQuery]:
        r"""
        (Array[ObjectTypeQuery]):  [Read-Write] Object type to use, if tracing with collision.
        """
        ...
    @object_types.setter
    def object_types(self, value: Array[ObjectTypeQuery]) -> None:
        ...
    @property
    def actors_to_ignore(self) -> Array[Actor]:
        r"""
        (Array[Actor]):  [Read-Write] Actors to ignore when tracing with collision.
        """
        ...
    @actors_to_ignore.setter
    def actors_to_ignore(self, value: Array[Actor]) -> None:
        ...
    @property
    def sim_frequency(self) -> float:
        r"""
        (float):  [Read-Write] Determines size of each sub-step in the simulation (chopping up MaxSimTime). Recommended between 10 to 30 depending on desired quality versus performance.
        """
        ...
    @sim_frequency.setter
    def sim_frequency(self, value: float) -> None:
        ...
    @property
    def override_gravity_z(self) -> float:
        r"""
        (float):  [Read-Write] Optional override of Gravity (if 0, uses WorldGravityZ).
        """
        ...
    @override_gravity_z.setter
    def override_gravity_z(self, value: float) -> None:
        ...
    @property
    def draw_debug_type(self) -> DrawDebugTrace:
        r"""
        (DrawDebugTrace):  [Read-Write] Debug drawing duration option.
        """
        ...
    @draw_debug_type.setter
    def draw_debug_type(self, value: DrawDebugTrace) -> None:
        ...
    @property
    def draw_debug_time(self) -> float:
        r"""
        (float):  [Read-Write] Duration of debug lines (only relevant for DrawDebugType::Duration)
        """
        ...
    @draw_debug_time.setter
    def draw_debug_time(self, value: float) -> None:
        ...
    @property
    def trace_complex(self) -> bool:
        r"""
        (bool):  [Read-Write] Trace against complex collision (triangles rather than simple primitives) if tracing with collision.
        """
        ...
    @trace_complex.setter
    def trace_complex(self, value: bool) -> None:
        ...

class PredictProjectilePathPointData(StructBase):
    r"""
    Data about a single point in a projectile path trace.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameplayStaticsTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``location`` (Vector):  [Read-Only] Location of this point
    - ``time`` (float):  [Read-Only] Elapsed time at this point from the start of the trace.
    - ``velocity`` (Vector):  [Read-Only] Velocity at this point
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], velocity: Vector = [0.000000, 0.000000, 0.000000], time: float = 0.000000) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Location of this point
        """
        ...
    @property
    def velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Velocity at this point
        """
        ...
    @property
    def time(self) -> float:
        r"""
        (float):  [Read-Only] Elapsed time at this point from the start of the trace.
        """
        ...

class PredictProjectilePathResult(StructBase):
    r"""
    Container for the result of a projectile path trace (using PredictProjectilePath).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameplayStaticsTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``hit_result`` (HitResult):  [Read-Only] Hit along the trace, if tracing with collision was enabled.
    - ``last_trace_destination`` (PredictProjectilePathPointData):  [Read-Only] Info on the last point we tried to trace to, which may have been beyond the final hit.
    - ``path_data`` (Array[PredictProjectilePathPointData]):  [Read-Only] Info for each point on the path.
    """
    def __init__(self, path_data: Array[PredictProjectilePathPointData] = [], last_trace_destination: PredictProjectilePathPointData = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], 0.000000], hit_result: HitResult = [False, False, 1.000000, 0.000000, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], None, None, None, "None", "None", 0, 0, 0, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]]) -> None:
        ...
    @property
    def path_data(self) -> Array[PredictProjectilePathPointData]:
        r"""
        (Array[PredictProjectilePathPointData]):  [Read-Only] Info for each point on the path.
        """
        ...
    @property
    def last_trace_destination(self) -> PredictProjectilePathPointData:
        r"""
        (PredictProjectilePathPointData):  [Read-Only] Info on the last point we tried to trace to, which may have been beyond the final hit.
        """
        ...
    @property
    def hit_result(self) -> HitResult:
        r"""
        (HitResult):  [Read-Only] Hit along the trace, if tracing with collision was enabled.
        """
        ...

class BoneAnimationTrack(StructBase):
    r"""
    Structure encapsulating a single bone animation track.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: IAnimationDataModel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_tree_index`` (int32):  [Read-Only] Index corresponding to the bone this track corresponds to within the target USkeleton
    - ``internal_track_data`` (RawAnimSequenceTrack):  [Read-Only] Internally stored data representing the animation bone data
    - ``name`` (Name):  [Read-Only] Name of the bone this track corresponds to
    """
    def __init__(self, internal_track_data: RawAnimSequenceTrack = [], bone_tree_index: int = 0, name: Name = "None") -> None:
        ...
    @property
    def internal_track_data(self) -> RawAnimSequenceTrack:
        r"""
        (RawAnimSequenceTrack):  [Read-Only] Internally stored data representing the animation bone data
        """
        ...
    @property
    def bone_tree_index(self) -> int:
        r"""
        (int32):  [Read-Only] Index corresponding to the bone this track corresponds to within the target USkeleton
        """
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of the bone this track corresponds to
        """
        ...

class AnimationCurveData(StructBase):
    r"""
    Structure encapsulating animated curve data. Currently only contains Float and Transform curves.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: IAnimationDataModel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``float_curves`` (Array[FloatCurve]):  [Read-Only] Float-based animation curves
    - ``transform_curves`` (Array[TransformCurve]):  [Read-Only] FTransform-based animation curves, used for animation layer editing
    """
    def __init__(self, float_curves: Array[FloatCurve] = [], transform_curves: Array[TransformCurve] = []) -> None:
        ...
    @property
    def float_curves(self) -> Array[FloatCurve]:
        r"""
        (Array[FloatCurve]):  [Read-Only] Float-based animation curves
        """
        ...
    @property
    def transform_curves(self) -> Array[TransformCurve]:
        r"""
        (Array[TransformCurve]):  [Read-Only] FTransform-based animation curves, used for animation layer editing
        """
        ...

class AnimatedBoneAttribute(StructBase):
    r"""
    Structure encapsulating animated (bone) attribute data.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: IAnimationDataModel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve`` (AttributeCurve):  [Read-Only] Curve containing the (animated) attribute data
    - ``identifier`` (AnimationAttributeIdentifier):  [Read-Only] Identifier to reference this attribute by
    """
    def __init__(self, identifier: AnimationAttributeIdentifier = ["None", "None", -1, None, [""]], curve: AttributeCurve = []) -> None:
        ...
    @property
    def identifier(self) -> AnimationAttributeIdentifier:
        r"""
        (AnimationAttributeIdentifier):  [Read-Only] Identifier to reference this attribute by
        """
        ...
    @property
    def curve(self) -> AttributeCurve:
        r"""
        (AttributeCurve):  [Read-Only] Curve containing the (animated) attribute data
        """
        ...

class IndexedCurve(StructBase):
    r"""
    A curve base class which enables key handles to index lookups.
    todo: sequencer: Some heavy refactoring can be done here. Much more stuff can go in this base class.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: IndexedCurve.h
    
    """
    def __init__(self) -> None:
        ...

class AttributeCurve(IndexedCurve):
    r"""
    Attribute Curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AttributeCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``keys`` (Array[AttributeKey]):  [Read-Write] The keys, ordered by time
    - ``script_struct`` (ScriptStruct):  [Read-Write] Transient UScriptStruct instance representing the underlying value type for the curve
    - ``script_struct_path`` (SoftObjectPath):  [Read-Only] Path to UScriptStruct to be loaded
    - ``should_interpolate`` (bool):  [Read-Write] Whether or not to interpolate between keys of ScripStruct type
    """
    def __init__(self) -> None:
        ...

class InputDevicePropertyHandle(StructBase):
    r"""
    A handle to an active input device property that is being used by the InputDeviceSubsytem.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDevicePropertyHandle.h
    
    """
    def __init__(self) -> None:
        ...

class MaterialProxySettings(StructBase):
    r"""
    Material Proxy Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialMerging.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_two_sided_material`` (bool):  [Read-Write] Whether or not to allow the generated material can be two-sided
    - ``ambient_occlusion_constant`` (float):  [Read-Write] Constant value to use for the Ambient Occlusion property
    - ``ambient_occlusion_map`` (bool):  [Read-Write] Whether to generate a texture for the Ambient Occlusion property
    - ``ambient_occlusion_texture_size`` (IntPoint):  [Read-Write] Override Ambient Occlusion texture size
    - ``anisotropy_constant`` (float):  [Read-Write] Constant value to use for the Anisotropy property
    - ``anisotropy_map`` (bool):  [Read-Write] Whether to generate a texture for the Anisotropy property
    - ``anisotropy_texture_size`` (IntPoint):  [Read-Write] Override Anisotropy texture size
    - ``blend_mode`` (BlendMode):  [Read-Write] Target blend mode for the generated material
    - ``diffuse_texture_size`` (IntPoint):  [Read-Write] Override Diffuse texture size
    - ``emissive_map`` (bool):  [Read-Write] Whether to generate a texture for the Emissive property
    - ``emissive_texture_size`` (IntPoint):  [Read-Write] Override Emissive texture size
    - ``gutter_space`` (float):  [Read-Write] Gutter space to take into account
    - ``mesh_max_screen_size_percent`` (float):  [Read-Write] Expected maximum screen size for the mesh
    - ``mesh_min_draw_distance`` (double):  [Read-Write] Expected minimum distance at which the mesh will be rendered
    - ``metallic_constant`` (float):  [Read-Write] Constant value to use for the Metallic property
    - ``metallic_map`` (bool):  [Read-Write] Whether to generate a texture for the Metallic property
    - ``metallic_texture_size`` (IntPoint):  [Read-Write] Override Metallic texture size
    - ``normal_map`` (bool):  [Read-Write] Whether to generate a texture for the Normal property
    - ``normal_texture_size`` (IntPoint):  [Read-Write] Override Normal texture size
    - ``opacity_constant`` (float):  [Read-Write] Constant value to use for the Opacity property
    - ``opacity_map`` (bool):  [Read-Write] Whether to generate a texture for the Opacity property
    - ``opacity_mask_constant`` (float):  [Read-Write] Constant value to use for the Opacity mask property
    - ``opacity_mask_map`` (bool):  [Read-Write] Whether to generate a texture for the Opacity Mask property
    - ``opacity_mask_texture_size`` (IntPoint):  [Read-Write] Override Opacity Mask texture size
    - ``opacity_texture_size`` (IntPoint):  [Read-Write] Override Opacity texture size
    - ``roughness_constant`` (float):  [Read-Write] Constant value to use for the Roughness property
    - ``roughness_map`` (bool):  [Read-Write] Whether to generate a texture for the Roughness property
    - ``roughness_texture_size`` (IntPoint):  [Read-Write] Override Roughness texture size
    - ``specular_constant`` (float):  [Read-Write] Constant value to use for the Specular property
    - ``specular_map`` (bool):  [Read-Write] Whether to generate a texture for the Specular property
    - ``specular_texture_size`` (IntPoint):  [Read-Write] Override Specular texture size
    - ``tangent_map`` (bool):  [Read-Write] Whether to generate a texture for the Tangent property
    - ``tangent_texture_size`` (IntPoint):  [Read-Write] Override Tangent texture size
    - ``target_texel_density_per_meter`` (float):  [Read-Write] Target texel density
    - ``texture_size`` (IntPoint):  [Read-Write] Size of generated BaseColor map
    - ``texture_sizing_type`` (TextureSizingType):  [Read-Write] Method that should be used to generate the sizes of the output textures
    """
    def __init__(self, texture_sizing_type: TextureSizingType = TextureSizingType.TEXTURE_SIZING_TYPE_USE_SINGLE_TEXTURE_SIZE, target_texel_density_per_meter: float = 0.000000, mesh_max_screen_size_percent: float = 0.000000, mesh_min_draw_distance: float = 0.000000, gutter_space: float = 0.000000, metallic_constant: float = 0.000000, roughness_constant: float = 0.000000, anisotropy_constant: float = 0.000000, specular_constant: float = 0.000000, opacity_constant: float = 0.000000, opacity_mask_constant: float = 0.000000, ambient_occlusion_constant: float = 0.000000, blend_mode: BlendMode = BlendMode.BLEND_OPAQUE, allow_two_sided_material: bool = False, normal_map: bool = False, tangent_map: bool = False, metallic_map: bool = False, roughness_map: bool = False, anisotropy_map: bool = False, specular_map: bool = False, emissive_map: bool = False, opacity_map: bool = False, opacity_mask_map: bool = False, ambient_occlusion_map: bool = False, diffuse_texture_size: IntPoint = [0, 0], normal_texture_size: IntPoint = [0, 0], tangent_texture_size: IntPoint = [0, 0], metallic_texture_size: IntPoint = [0, 0], roughness_texture_size: IntPoint = [0, 0], anisotropy_texture_size: IntPoint = [0, 0], specular_texture_size: IntPoint = [0, 0], emissive_texture_size: IntPoint = [0, 0], opacity_texture_size: IntPoint = [0, 0], opacity_mask_texture_size: IntPoint = [0, 0], ambient_occlusion_texture_size: IntPoint = [0, 0]) -> None:
        ...
    @property
    def texture_sizing_type(self) -> TextureSizingType:
        r"""
        (TextureSizingType):  [Read-Write] Method that should be used to generate the sizes of the output textures
        """
        ...
    @texture_sizing_type.setter
    def texture_sizing_type(self, value: TextureSizingType) -> None:
        ...
    @property
    def target_texel_density_per_meter(self) -> float:
        r"""
        (float):  [Read-Write] Target texel density
        """
        ...
    @target_texel_density_per_meter.setter
    def target_texel_density_per_meter(self, value: float) -> None:
        ...
    @property
    def mesh_max_screen_size_percent(self) -> float:
        r"""
        (float):  [Read-Write] Expected maximum screen size for the mesh
        """
        ...
    @mesh_max_screen_size_percent.setter
    def mesh_max_screen_size_percent(self, value: float) -> None:
        ...
    @property
    def mesh_min_draw_distance(self) -> float:
        r"""
        (double):  [Read-Write] Expected minimum distance at which the mesh will be rendered
        """
        ...
    @mesh_min_draw_distance.setter
    def mesh_min_draw_distance(self, value: float) -> None:
        ...
    @property
    def gutter_space(self) -> float:
        r"""
        (float):  [Read-Write] Gutter space to take into account
        """
        ...
    @gutter_space.setter
    def gutter_space(self, value: float) -> None:
        ...
    @property
    def metallic_constant(self) -> float:
        r"""
        (float):  [Read-Write] Constant value to use for the Metallic property
        """
        ...
    @metallic_constant.setter
    def metallic_constant(self, value: float) -> None:
        ...
    @property
    def roughness_constant(self) -> float:
        r"""
        (float):  [Read-Write] Constant value to use for the Roughness property
        """
        ...
    @roughness_constant.setter
    def roughness_constant(self, value: float) -> None:
        ...
    @property
    def anisotropy_constant(self) -> float:
        r"""
        (float):  [Read-Write] Constant value to use for the Anisotropy property
        """
        ...
    @anisotropy_constant.setter
    def anisotropy_constant(self, value: float) -> None:
        ...
    @property
    def specular_constant(self) -> float:
        r"""
        (float):  [Read-Write] Constant value to use for the Specular property
        """
        ...
    @specular_constant.setter
    def specular_constant(self, value: float) -> None:
        ...
    @property
    def opacity_constant(self) -> float:
        r"""
        (float):  [Read-Write] Constant value to use for the Opacity property
        """
        ...
    @opacity_constant.setter
    def opacity_constant(self, value: float) -> None:
        ...
    @property
    def opacity_mask_constant(self) -> float:
        r"""
        (float):  [Read-Write] Constant value to use for the Opacity mask property
        """
        ...
    @opacity_mask_constant.setter
    def opacity_mask_constant(self, value: float) -> None:
        ...
    @property
    def ambient_occlusion_constant(self) -> float:
        r"""
        (float):  [Read-Write] Constant value to use for the Ambient Occlusion property
        """
        ...
    @ambient_occlusion_constant.setter
    def ambient_occlusion_constant(self, value: float) -> None:
        ...
    @property
    def blend_mode(self) -> BlendMode:
        r"""
        (BlendMode):  [Read-Write] Target blend mode for the generated material
        """
        ...
    @blend_mode.setter
    def blend_mode(self, value: BlendMode) -> None:
        ...
    @property
    def allow_two_sided_material(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to allow the generated material can be two-sided
        """
        ...
    @allow_two_sided_material.setter
    def allow_two_sided_material(self, value: bool) -> None:
        ...
    @property
    def normal_map(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate a texture for the Normal property
        """
        ...
    @normal_map.setter
    def normal_map(self, value: bool) -> None:
        ...
    @property
    def tangent_map(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate a texture for the Tangent property
        """
        ...
    @tangent_map.setter
    def tangent_map(self, value: bool) -> None:
        ...
    @property
    def metallic_map(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate a texture for the Metallic property
        """
        ...
    @metallic_map.setter
    def metallic_map(self, value: bool) -> None:
        ...
    @property
    def roughness_map(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate a texture for the Roughness property
        """
        ...
    @roughness_map.setter
    def roughness_map(self, value: bool) -> None:
        ...
    @property
    def anisotropy_map(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate a texture for the Anisotropy property
        """
        ...
    @anisotropy_map.setter
    def anisotropy_map(self, value: bool) -> None:
        ...
    @property
    def specular_map(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate a texture for the Specular property
        """
        ...
    @specular_map.setter
    def specular_map(self, value: bool) -> None:
        ...
    @property
    def emissive_map(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate a texture for the Emissive property
        """
        ...
    @emissive_map.setter
    def emissive_map(self, value: bool) -> None:
        ...
    @property
    def opacity_map(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate a texture for the Opacity property
        """
        ...
    @opacity_map.setter
    def opacity_map(self, value: bool) -> None:
        ...
    @property
    def opacity_mask_map(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate a texture for the Opacity Mask property
        """
        ...
    @opacity_mask_map.setter
    def opacity_mask_map(self, value: bool) -> None:
        ...
    @property
    def ambient_occlusion_map(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate a texture for the Ambient Occlusion property
        """
        ...
    @ambient_occlusion_map.setter
    def ambient_occlusion_map(self, value: bool) -> None:
        ...
    @property
    def diffuse_texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Override Diffuse texture size
        """
        ...
    @diffuse_texture_size.setter
    def diffuse_texture_size(self, value: IntPoint) -> None:
        ...
    @property
    def normal_texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Override Normal texture size
        """
        ...
    @normal_texture_size.setter
    def normal_texture_size(self, value: IntPoint) -> None:
        ...
    @property
    def tangent_texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Override Tangent texture size
        """
        ...
    @tangent_texture_size.setter
    def tangent_texture_size(self, value: IntPoint) -> None:
        ...
    @property
    def metallic_texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Override Metallic texture size
        """
        ...
    @metallic_texture_size.setter
    def metallic_texture_size(self, value: IntPoint) -> None:
        ...
    @property
    def roughness_texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Override Roughness texture size
        """
        ...
    @roughness_texture_size.setter
    def roughness_texture_size(self, value: IntPoint) -> None:
        ...
    @property
    def anisotropy_texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Override Anisotropy texture size
        """
        ...
    @anisotropy_texture_size.setter
    def anisotropy_texture_size(self, value: IntPoint) -> None:
        ...
    @property
    def specular_texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Override Specular texture size
        """
        ...
    @specular_texture_size.setter
    def specular_texture_size(self, value: IntPoint) -> None:
        ...
    @property
    def emissive_texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Override Emissive texture size
        """
        ...
    @emissive_texture_size.setter
    def emissive_texture_size(self, value: IntPoint) -> None:
        ...
    @property
    def opacity_texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Override Opacity texture size
        """
        ...
    @opacity_texture_size.setter
    def opacity_texture_size(self, value: IntPoint) -> None:
        ...
    @property
    def opacity_mask_texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Override Opacity Mask texture size
        """
        ...
    @opacity_mask_texture_size.setter
    def opacity_mask_texture_size(self, value: IntPoint) -> None:
        ...
    @property
    def ambient_occlusion_texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Override Ambient Occlusion texture size
        """
        ...
    @ambient_occlusion_texture_size.setter
    def ambient_occlusion_texture_size(self, value: IntPoint) -> None:
        ...

class MeshUVChannelInfo(StructBase):
    r"""
    The world size for each texcoord mapping. Used by the texture streaming.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshUVChannelInfo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``local_uv_densities`` (float):  [Read-Write] The UV density in the mesh, before any transform scaling, in world unit per UV.
      This value represents the length taken to cover a full UV unit.
    - ``override_densities`` (bool):  [Read-Write] Whether this values was set manually or is auto generated.
    """
    def __init__(self) -> None:
        ...

class NavAvoidanceMask(StructBase):
    r"""
    Nav Avoidance Mask
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationAvoidanceTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``group0`` (bool):  [Read-Write]
    - ``group1`` (bool):  [Read-Write]
    - ``group10`` (bool):  [Read-Write]
    - ``group11`` (bool):  [Read-Write]
    - ``group12`` (bool):  [Read-Write]
    - ``group13`` (bool):  [Read-Write]
    - ``group14`` (bool):  [Read-Write]
    - ``group15`` (bool):  [Read-Write]
    - ``group16`` (bool):  [Read-Write]
    - ``group17`` (bool):  [Read-Write]
    - ``group18`` (bool):  [Read-Write]
    - ``group19`` (bool):  [Read-Write]
    - ``group2`` (bool):  [Read-Write]
    - ``group20`` (bool):  [Read-Write]
    - ``group21`` (bool):  [Read-Write]
    - ``group22`` (bool):  [Read-Write]
    - ``group23`` (bool):  [Read-Write]
    - ``group24`` (bool):  [Read-Write]
    - ``group25`` (bool):  [Read-Write]
    - ``group26`` (bool):  [Read-Write]
    - ``group27`` (bool):  [Read-Write]
    - ``group28`` (bool):  [Read-Write]
    - ``group29`` (bool):  [Read-Write]
    - ``group3`` (bool):  [Read-Write]
    - ``group30`` (bool):  [Read-Write]
    - ``group31`` (bool):  [Read-Write]
    - ``group4`` (bool):  [Read-Write]
    - ``group5`` (bool):  [Read-Write]
    - ``group6`` (bool):  [Read-Write]
    - ``group7`` (bool):  [Read-Write]
    - ``group8`` (bool):  [Read-Write]
    - ``group9`` (bool):  [Read-Write]
    """
    def __init__(self, group0: bool = False, group1: bool = False, group2: bool = False, group3: bool = False, group4: bool = False, group5: bool = False, group6: bool = False, group7: bool = False, group8: bool = False, group9: bool = False, group10: bool = False, group11: bool = False, group12: bool = False, group13: bool = False, group14: bool = False, group15: bool = False, group16: bool = False, group17: bool = False, group18: bool = False, group19: bool = False, group20: bool = False, group21: bool = False, group22: bool = False, group23: bool = False, group24: bool = False, group25: bool = False, group26: bool = False, group27: bool = False, group28: bool = False, group29: bool = False, group30: bool = False, group31: bool = False) -> None:
        ...
    @property
    def group0(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group0.setter
    def group0(self, value: bool) -> None:
        ...
    @property
    def group1(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group1.setter
    def group1(self, value: bool) -> None:
        ...
    @property
    def group2(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group2.setter
    def group2(self, value: bool) -> None:
        ...
    @property
    def group3(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group3.setter
    def group3(self, value: bool) -> None:
        ...
    @property
    def group4(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group4.setter
    def group4(self, value: bool) -> None:
        ...
    @property
    def group5(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group5.setter
    def group5(self, value: bool) -> None:
        ...
    @property
    def group6(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group6.setter
    def group6(self, value: bool) -> None:
        ...
    @property
    def group7(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group7.setter
    def group7(self, value: bool) -> None:
        ...
    @property
    def group8(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group8.setter
    def group8(self, value: bool) -> None:
        ...
    @property
    def group9(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group9.setter
    def group9(self, value: bool) -> None:
        ...
    @property
    def group10(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group10.setter
    def group10(self, value: bool) -> None:
        ...
    @property
    def group11(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group11.setter
    def group11(self, value: bool) -> None:
        ...
    @property
    def group12(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group12.setter
    def group12(self, value: bool) -> None:
        ...
    @property
    def group13(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group13.setter
    def group13(self, value: bool) -> None:
        ...
    @property
    def group14(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group14.setter
    def group14(self, value: bool) -> None:
        ...
    @property
    def group15(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group15.setter
    def group15(self, value: bool) -> None:
        ...
    @property
    def group16(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group16.setter
    def group16(self, value: bool) -> None:
        ...
    @property
    def group17(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group17.setter
    def group17(self, value: bool) -> None:
        ...
    @property
    def group18(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group18.setter
    def group18(self, value: bool) -> None:
        ...
    @property
    def group19(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group19.setter
    def group19(self, value: bool) -> None:
        ...
    @property
    def group20(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group20.setter
    def group20(self, value: bool) -> None:
        ...
    @property
    def group21(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group21.setter
    def group21(self, value: bool) -> None:
        ...
    @property
    def group22(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group22.setter
    def group22(self, value: bool) -> None:
        ...
    @property
    def group23(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group23.setter
    def group23(self, value: bool) -> None:
        ...
    @property
    def group24(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group24.setter
    def group24(self, value: bool) -> None:
        ...
    @property
    def group25(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group25.setter
    def group25(self, value: bool) -> None:
        ...
    @property
    def group26(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group26.setter
    def group26(self, value: bool) -> None:
        ...
    @property
    def group27(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group27.setter
    def group27(self, value: bool) -> None:
        ...
    @property
    def group28(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group28.setter
    def group28(self, value: bool) -> None:
        ...
    @property
    def group29(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group29.setter
    def group29(self, value: bool) -> None:
        ...
    @property
    def group30(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group30.setter
    def group30(self, value: bool) -> None:
        ...
    @property
    def group31(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @group31.setter
    def group31(self, value: bool) -> None:
        ...

class NavigationLinkBase(StructBase):
    r"""
    Navigation Link Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavLinkDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``area_class`` (type(Class)):  [Read-Write] Area type of this link (empty = default)
    - ``description`` (str):  [Read-Write] this is an editor-only property to put descriptions in navlinks setup, to be able to identify it easier
    - ``direction`` (NavLinkDirection):  [Read-Write]
    - ``left_project_height`` (float):  [Read-Write] if greater than 0 nav system will attempt to project navlink's start point on geometry below
    - ``max_fall_down_length`` (float):  [Read-Write] if greater than 0 nav system will attempt to project navlink's end point on geometry below
    - ``snap_height`` (float):  [Read-Write]
    - ``snap_radius`` (float):  [Read-Write]
    - ``snap_to_cheapest_area`` (bool):  [Read-Write] If set, link will try to snap to cheapest area in given radius
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict area only to specified agents
    - ``use_snap_height`` (bool):  [Read-Write]
    """
    def __init__(self, direction: NavLinkDirection = NavLinkDirection.BOTH_WAYS) -> None:
        ...
    @property
    def direction(self) -> NavLinkDirection:
        r"""
        (NavLinkDirection):  [Read-Write]
        """
        ...
    @direction.setter
    def direction(self, value: NavLinkDirection) -> None:
        ...

class NavigationLink(NavigationLinkBase):
    r"""
    Navigation Link
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavLinkDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``area_class`` (type(Class)):  [Read-Write] Area type of this link (empty = default)
    - ``description`` (str):  [Read-Write] this is an editor-only property to put descriptions in navlinks setup, to be able to identify it easier
    - ``direction`` (NavLinkDirection):  [Read-Write]
    - ``left`` (Vector):  [Read-Write]
    - ``left_project_height`` (float):  [Read-Write] if greater than 0 nav system will attempt to project navlink's start point on geometry below
    - ``max_fall_down_length`` (float):  [Read-Write] if greater than 0 nav system will attempt to project navlink's end point on geometry below
    - ``right`` (Vector):  [Read-Write]
    - ``snap_height`` (float):  [Read-Write]
    - ``snap_radius`` (float):  [Read-Write]
    - ``snap_to_cheapest_area`` (bool):  [Read-Write] If set, link will try to snap to cheapest area in given radius
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict area only to specified agents
    - ``use_snap_height`` (bool):  [Read-Write]
    """
    def __init__(self, direction: NavLinkDirection = NavLinkDirection.BOTH_WAYS, left: Vector = [0.000000, 0.000000, 0.000000], right: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def left(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @left.setter
    def left(self, value: Vector) -> None:
        ...
    @property
    def right(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @right.setter
    def right(self, value: Vector) -> None:
        ...

class NavigationSegmentLink(NavigationLinkBase):
    r"""
    Navigation Segment Link
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavLinkDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``area_class`` (type(Class)):  [Read-Write] Area type of this link (empty = default)
    - ``description`` (str):  [Read-Write] this is an editor-only property to put descriptions in navlinks setup, to be able to identify it easier
    - ``direction`` (NavLinkDirection):  [Read-Write]
    - ``left_end`` (Vector):  [Read-Write]
    - ``left_project_height`` (float):  [Read-Write] if greater than 0 nav system will attempt to project navlink's start point on geometry below
    - ``left_start`` (Vector):  [Read-Write]
    - ``max_fall_down_length`` (float):  [Read-Write] if greater than 0 nav system will attempt to project navlink's end point on geometry below
    - ``right_end`` (Vector):  [Read-Write]
    - ``right_start`` (Vector):  [Read-Write]
    - ``snap_height`` (float):  [Read-Write]
    - ``snap_radius`` (float):  [Read-Write]
    - ``snap_to_cheapest_area`` (bool):  [Read-Write] If set, link will try to snap to cheapest area in given radius
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict area only to specified agents
    - ``use_snap_height`` (bool):  [Read-Write]
    """
    def __init__(self, direction: NavLinkDirection = NavLinkDirection.BOTH_WAYS) -> None:
        ...

class Vector_NetQuantize10(Vector):
    r"""
    FVector_NetQuantize10
    
    1 decimal place of precision.
    Up to 24 bits per component.
    Valid range: 2^24 / 10 = +/- 1,677,721.6
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NetSerialization.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    - ``z`` (double):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000) -> None:
        ...

class ParticleSysParam(StructBase):
    r"""
    Struct used for a particular named instance parameter for this ParticleSystemComponent.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystemComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor`` (Actor):  [Read-Write]
    - ``color`` (Color):  [Read-Write]
    - ``material`` (MaterialInterface):  [Read-Write]
    - ``name`` (Name):  [Read-Write] The name of the parameter
    - ``param_type`` (ParticleSysParamType):  [Read-Write] The type of parameters
      PSPT_None       - There is no data type
      PSPT_Scalar     - Use the scalar value
      PSPT_ScalarRand - Select a scalar value in the range [Scalar_Low..Scalar)
      PSPT_Vector     - Use the vector value
      PSPT_VectorRand - Select a vector value in the range [Vector_Low..Vector)
      PSPT_Color      - Use the color value
      PSPT_Actor      - Use the actor value
      PSPT_Material   - Use the material value
      PSPT_VectorUnitRand - Select a random unit vector and scale along the range [Vector_Low..Vector)
    - ``scalar`` (float):  [Read-Write]
    - ``scalar_low`` (float):  [Read-Write]
    - ``vector`` (Vector):  [Read-Write]
    - ``vector_low`` (Vector):  [Read-Write]
    """
    def __init__(self, name: Name = "None", param_type: ParticleSysParamType = ParticleSysParamType.PSPT_NONE, scalar: float = 0.000000, scalar_low: float = 0.000000, vector: Vector = [0.000000, 0.000000, 0.000000], vector_low: Vector = [0.000000, 0.000000, 0.000000], color: Color = [0, 0, 0, 0], actor: Actor = None, material: MaterialInterface = None) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the parameter
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def param_type(self) -> ParticleSysParamType:
        r"""
        (ParticleSysParamType):  [Read-Write] The type of parameters
        PSPT_None       - There is no data type
        PSPT_Scalar     - Use the scalar value
        PSPT_ScalarRand - Select a scalar value in the range [Scalar_Low..Scalar)
        PSPT_Vector     - Use the vector value
        PSPT_VectorRand - Select a vector value in the range [Vector_Low..Vector)
        PSPT_Color      - Use the color value
        PSPT_Actor      - Use the actor value
        PSPT_Material   - Use the material value
        PSPT_VectorUnitRand - Select a random unit vector and scale along the range [Vector_Low..Vector)
        """
        ...
    @param_type.setter
    def param_type(self, value: ParticleSysParamType) -> None:
        ...
    @property
    def scalar(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scalar.setter
    def scalar(self, value: float) -> None:
        ...
    @property
    def scalar_low(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scalar_low.setter
    def scalar_low(self, value: float) -> None:
        ...
    @property
    def vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @vector.setter
    def vector(self, value: Vector) -> None:
        ...
    @property
    def vector_low(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @vector_low.setter
    def vector_low(self, value: Vector) -> None:
        ...
    @property
    def color(self) -> Color:
        r"""
        (Color):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: Color) -> None:
        ...
    @property
    def actor(self) -> Actor:
        r"""
        (Actor):  [Read-Write]
        """
        ...
    @actor.setter
    def actor(self, value: Actor) -> None:
        ...
    @property
    def material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Write]
        """
        ...
    @material.setter
    def material(self, value: MaterialInterface) -> None:
        ...

class FXSystemSpawnParameters(StructBase):
    r"""
    Parameters controlling the spawning behavior of FX systems via the SpawnSystemAtLocation and SpawnSystemAttached.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystemComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attach_point_name`` (Name):  [Read-Write]
    - ``attach_to_component`` (SceneComponent):  [Read-Write]
    - ``auto_activate`` (bool):  [Read-Write]
    - ``auto_destroy`` (bool):  [Read-Write]
    - ``is_player_effect`` (bool):  [Read-Write]
    - ``location`` (Vector):  [Read-Write]
    - ``location_type`` (AttachLocation):  [Read-Write]
    - ``pooling_method`` (PSCPoolMethod):  [Read-Write]
    - ``pre_cull_check`` (bool):  [Read-Write]
    - ``rotation`` (Rotator):  [Read-Write]
    - ``scale`` (Vector):  [Read-Write]
    - ``system_template`` (FXSystemAsset):  [Read-Write]
    - ``world_context_object`` (Object):  [Read-Write]
    """
    def __init__(self, world_context_object: Object = None, system_template: FXSystemAsset = None, location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], scale: Vector = [0.000000, 0.000000, 0.000000], attach_to_component: SceneComponent = None, attach_point_name: Name = "None", location_type: AttachLocation = AttachLocation.KEEP_RELATIVE_OFFSET, auto_destroy: bool = False, auto_activate: bool = False, pooling_method: PSCPoolMethod = PSCPoolMethod.NONE, pre_cull_check: bool = False, is_player_effect: bool = False) -> None:
        ...
    @property
    def world_context_object(self) -> Object:
        r"""
        (Object):  [Read-Write]
        """
        ...
    @world_context_object.setter
    def world_context_object(self, value: Object) -> None:
        ...
    @property
    def system_template(self) -> FXSystemAsset:
        r"""
        (FXSystemAsset):  [Read-Write]
        """
        ...
    @system_template.setter
    def system_template(self, value: FXSystemAsset) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @rotation.setter
    def rotation(self, value: Rotator) -> None:
        ...
    @property
    def scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: Vector) -> None:
        ...
    @property
    def attach_to_component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Write]
        """
        ...
    @attach_to_component.setter
    def attach_to_component(self, value: SceneComponent) -> None:
        ...
    @property
    def attach_point_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @attach_point_name.setter
    def attach_point_name(self, value: Name) -> None:
        ...
    @property
    def location_type(self) -> AttachLocation:
        r"""
        (AttachLocation):  [Read-Write]
        """
        ...
    @location_type.setter
    def location_type(self, value: AttachLocation) -> None:
        ...
    @property
    def auto_destroy(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @auto_destroy.setter
    def auto_destroy(self, value: bool) -> None:
        ...
    @property
    def auto_activate(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @auto_activate.setter
    def auto_activate(self, value: bool) -> None:
        ...
    @property
    def pooling_method(self) -> PSCPoolMethod:
        r"""
        (PSCPoolMethod):  [Read-Write]
        """
        ...
    @pooling_method.setter
    def pooling_method(self, value: PSCPoolMethod) -> None:
        ...
    @property
    def pre_cull_check(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @pre_cull_check.setter
    def pre_cull_check(self, value: bool) -> None:
        ...
    @property
    def is_player_effect(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_player_effect.setter
    def is_player_effect(self, value: bool) -> None:
        ...

class TViewTarget(StructBase):
    r"""
    A ViewTarget is the primary actor the camera is associated with.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerCameraManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``player_state`` (PlayerState):  [Read-Write] PlayerState (used to follow same player through pawn transitions, etc., when spectating)
    - ``pov`` (MinimalViewInfo):  [Read-Write] Computed point of view
    - ``target`` (Actor):  [Read-Write] Target Actor used to compute POV
    """
    def __init__(self, target: Actor = None, pov: MinimalViewInfo = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], 90.000000, 512.000000, True, 0.000000, False, False, 0.000000, 2097152.000000, -1.000000, 1.333333, False, True, CameraProjectionMode.PERSPECTIVE, 0.000000, [], [0.000000, 0.000000]], player_state: PlayerState = None) -> None:
        ...
    @property
    def target(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Target Actor used to compute POV
        """
        ...
    @target.setter
    def target(self, value: Actor) -> None:
        ...
    @property
    def pov(self) -> MinimalViewInfo:
        r"""
        (MinimalViewInfo):  [Read-Write] Computed point of view
        """
        ...
    @pov.setter
    def pov(self, value: MinimalViewInfo) -> None:
        ...
    @property
    def player_state(self) -> PlayerState:
        r"""
        (PlayerState):  [Read-Write] PlayerState (used to follow same player through pawn transitions, etc., when spectating)
        """
        ...
    @player_state.setter
    def player_state(self, value: PlayerState) -> None:
        ...

class ViewTargetTransitionParams(StructBase):
    r"""
    A set of parameters to describe how to transition between view targets.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerCameraManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_exp`` (float):  [Read-Write] Exponent, used by certain blend functions to control the shape of the curve.
    - ``blend_function`` (ViewTargetBlendFunction):  [Read-Write] Function to apply to the blend parameter.
    - ``blend_time`` (float):  [Read-Write] Total duration of blend to pending view target. 0 means no blending.
    - ``lock_outgoing`` (bool):  [Read-Write] If true, lock outgoing viewtarget to last frame's camera POV for the remainder of the blend.
      This is useful if you plan to teleport the old viewtarget, but don't want to affect the blend.
    """
    def __init__(self, blend_time: float = 0.000000, blend_function: ViewTargetBlendFunction = ViewTargetBlendFunction.VT_BLEND_LINEAR, blend_exp: float = 0.000000, lock_outgoing: bool = False) -> None:
        ...
    @property
    def blend_time(self) -> float:
        r"""
        (float):  [Read-Write] Total duration of blend to pending view target. 0 means no blending.
        """
        ...
    @blend_time.setter
    def blend_time(self, value: float) -> None:
        ...
    @property
    def blend_function(self) -> ViewTargetBlendFunction:
        r"""
        (ViewTargetBlendFunction):  [Read-Write] Function to apply to the blend parameter.
        """
        ...
    @blend_function.setter
    def blend_function(self, value: ViewTargetBlendFunction) -> None:
        ...
    @property
    def blend_exp(self) -> float:
        r"""
        (float):  [Read-Write] Exponent, used by certain blend functions to control the shape of the curve.
        """
        ...
    @blend_exp.setter
    def blend_exp(self, value: float) -> None:
        ...
    @property
    def lock_outgoing(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, lock outgoing viewtarget to last frame's camera POV for the remainder of the blend.
        This is useful if you plan to teleport the old viewtarget, but don't want to affect the blend.
        """
        ...
    @lock_outgoing.setter
    def lock_outgoing(self, value: bool) -> None:
        ...

class ReverbSettings(StructBase):
    r"""
    Struct encapsulating settings for reverb effects.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ReverbSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_reverb`` (bool):  [Read-Write] Whether to apply the reverb settings below.
    - ``fade_time`` (float):  [Read-Write] Time to fade from the current reverb settings into this setting, in seconds.
    - ``reverb_effect`` (ReverbEffect):  [Read-Write] The reverb asset to employ.
    - ``reverb_plugin_effect`` (SoundEffectSubmixPreset):  [Read-Write] This is used to apply plugin-specific settings when a Reverb Plugin is being used.
    - ``volume`` (float):  [Read-Write] Volume level of the reverb effect.
    """
    def __init__(self, apply_reverb: bool = False, reverb_effect: ReverbEffect = None, reverb_plugin_effect: SoundEffectSubmixPreset = None, volume: float = 0.000000, fade_time: float = 0.000000) -> None:
        ...
    @property
    def apply_reverb(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to apply the reverb settings below.
        """
        ...
    @apply_reverb.setter
    def apply_reverb(self, value: bool) -> None:
        ...
    @property
    def reverb_effect(self) -> ReverbEffect:
        r"""
        (ReverbEffect):  [Read-Write] The reverb asset to employ.
        """
        ...
    @reverb_effect.setter
    def reverb_effect(self, value: ReverbEffect) -> None:
        ...
    @property
    def reverb_plugin_effect(self) -> SoundEffectSubmixPreset:
        r"""
        (SoundEffectSubmixPreset):  [Read-Write] This is used to apply plugin-specific settings when a Reverb Plugin is being used.
        """
        ...
    @reverb_plugin_effect.setter
    def reverb_plugin_effect(self, value: SoundEffectSubmixPreset) -> None:
        ...
    @property
    def volume(self) -> float:
        r"""
        (float):  [Read-Write] Volume level of the reverb effect.
        """
        ...
    @volume.setter
    def volume(self, value: float) -> None:
        ...
    @property
    def fade_time(self) -> float:
        r"""
        (float):  [Read-Write] Time to fade from the current reverb settings into this setting, in seconds.
        """
        ...
    @fade_time.setter
    def fade_time(self, value: float) -> None:
        ...

class ColorGradePerRangeSettings(StructBase):
    r"""
    Color Grade Per Range Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``contrast`` (Vector4):  [Read-Write]
    - ``gain`` (Vector4):  [Read-Write]
    - ``gamma`` (Vector4):  [Read-Write]
    - ``offset`` (Vector4):  [Read-Write]
    - ``saturation`` (Vector4):  [Read-Write]
    """
    def __init__(self, saturation: Vector4 = [0.000000, 0.000000, 0.000000, 0.000000], contrast: Vector4 = [0.000000, 0.000000, 0.000000, 0.000000], gamma: Vector4 = [0.000000, 0.000000, 0.000000, 0.000000], gain: Vector4 = [0.000000, 0.000000, 0.000000, 0.000000], offset: Vector4 = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def saturation(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write]
        """
        ...
    @saturation.setter
    def saturation(self, value: Vector4) -> None:
        ...
    @property
    def contrast(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write]
        """
        ...
    @contrast.setter
    def contrast(self, value: Vector4) -> None:
        ...
    @property
    def gamma(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write]
        """
        ...
    @gamma.setter
    def gamma(self, value: Vector4) -> None:
        ...
    @property
    def gain(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write]
        """
        ...
    @gain.setter
    def gain(self, value: Vector4) -> None:
        ...
    @property
    def offset(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write]
        """
        ...
    @offset.setter
    def offset(self, value: Vector4) -> None:
        ...

class ColorGradingSettings(StructBase):
    r"""
    Color Grading Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_`` (ColorGradePerRangeSettings):  [Read-Write]
    - ``highlights`` (ColorGradePerRangeSettings):  [Read-Write]
    - ``highlights_max`` (float):  [Read-Write]
    - ``highlights_min`` (float):  [Read-Write]
    - ``midtones`` (ColorGradePerRangeSettings):  [Read-Write]
    - ``shadows`` (ColorGradePerRangeSettings):  [Read-Write]
    - ``shadows_max`` (float):  [Read-Write]
    """
    def __init__(self, global_: ColorGradePerRangeSettings = [[1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [0.000000, 0.000000, 0.000000, 0.000000]], shadows: ColorGradePerRangeSettings = [[1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [0.000000, 0.000000, 0.000000, 0.000000]], midtones: ColorGradePerRangeSettings = [[1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [0.000000, 0.000000, 0.000000, 0.000000]], highlights: ColorGradePerRangeSettings = [[1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 1.000000, 1.000000, 1.000000], [0.000000, 0.000000, 0.000000, 0.000000]], shadows_max: float = 0.000000, highlights_min: float = 0.000000, highlights_max: float = 0.000000) -> None:
        ...
    @property
    def global_(self) -> ColorGradePerRangeSettings:
        r"""
        (ColorGradePerRangeSettings):  [Read-Write]
        """
        ...
    @global_.setter
    def global_(self, value: ColorGradePerRangeSettings) -> None:
        ...
    @property
    def shadows(self) -> ColorGradePerRangeSettings:
        r"""
        (ColorGradePerRangeSettings):  [Read-Write]
        """
        ...
    @shadows.setter
    def shadows(self, value: ColorGradePerRangeSettings) -> None:
        ...
    @property
    def midtones(self) -> ColorGradePerRangeSettings:
        r"""
        (ColorGradePerRangeSettings):  [Read-Write]
        """
        ...
    @midtones.setter
    def midtones(self, value: ColorGradePerRangeSettings) -> None:
        ...
    @property
    def highlights(self) -> ColorGradePerRangeSettings:
        r"""
        (ColorGradePerRangeSettings):  [Read-Write]
        """
        ...
    @highlights.setter
    def highlights(self, value: ColorGradePerRangeSettings) -> None:
        ...
    @property
    def shadows_max(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @shadows_max.setter
    def shadows_max(self, value: float) -> None:
        ...
    @property
    def highlights_min(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @highlights_min.setter
    def highlights_min(self, value: float) -> None:
        ...
    @property
    def highlights_max(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @highlights_max.setter
    def highlights_max(self, value: float) -> None:
        ...

class FilmStockSettings(StructBase):
    r"""
    Film Stock Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``black_clip`` (float):  [Read-Write]
    - ``shoulder`` (float):  [Read-Write]
    - ``slope`` (float):  [Read-Write]
    - ``toe`` (float):  [Read-Write]
    - ``white_clip`` (float):  [Read-Write]
    """
    def __init__(self, slope: float = 0.000000, toe: float = 0.000000, shoulder: float = 0.000000, black_clip: float = 0.000000, white_clip: float = 0.000000) -> None:
        ...
    @property
    def slope(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @slope.setter
    def slope(self, value: float) -> None:
        ...
    @property
    def toe(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @toe.setter
    def toe(self, value: float) -> None:
        ...
    @property
    def shoulder(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @shoulder.setter
    def shoulder(self, value: float) -> None:
        ...
    @property
    def black_clip(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @black_clip.setter
    def black_clip(self, value: float) -> None:
        ...
    @property
    def white_clip(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @white_clip.setter
    def white_clip(self, value: float) -> None:
        ...

class GaussianSumBloomSettings(StructBase):
    r"""
    Gaussian Sum Bloom Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``filter1_size`` (float):  [Read-Write] Diameter size for the Bloom1 in percent of the screen width
      (is done in 1/2 resolution, larger values cost more performance, good for high frequency details)
      >=0: can be clamped because of shader limitations
    - ``filter1_tint`` (LinearColor):  [Read-Write] Bloom1 tint color
    - ``filter2_size`` (float):  [Read-Write] Diameter size for Bloom2 in percent of the screen width
      (is done in 1/4 resolution, larger values cost more performance)
      >=0: can be clamped because of shader limitations
    - ``filter2_tint`` (LinearColor):  [Read-Write] Bloom2 tint color
    - ``filter3_size`` (float):  [Read-Write] Diameter size for Bloom3 in percent of the screen width
      (is done in 1/8 resolution, larger values cost more performance)
      >=0: can be clamped because of shader limitations
    - ``filter3_tint`` (LinearColor):  [Read-Write] Bloom3 tint color
    - ``filter4_size`` (float):  [Read-Write] Diameter size for Bloom4 in percent of the screen width
      (is done in 1/16 resolution, larger values cost more performance, best for wide contributions)
      >=0: can be clamped because of shader limitations
    - ``filter4_tint`` (LinearColor):  [Read-Write] Bloom4 tint color
    - ``filter5_size`` (float):  [Read-Write] Diameter size for Bloom5 in percent of the screen width
      (is done in 1/32 resolution, larger values cost more performance, best for wide contributions)
      >=0: can be clamped because of shader limitations
    - ``filter5_tint`` (LinearColor):  [Read-Write] Bloom5 tint color
    - ``filter6_size`` (float):  [Read-Write] Diameter size for Bloom6 in percent of the screen width
      (is done in 1/64 resolution, larger values cost more performance, best for wide contributions)
      >=0: can be clamped because of shader limitations
    - ``filter6_tint`` (LinearColor):  [Read-Write] Bloom6 tint color
    - ``intensity`` (float):  [Read-Write] Multiplier for all bloom contributions >=0: off, 1(default), >1 brighter
    - ``size_scale`` (float):  [Read-Write] Scale for all bloom sizes
    - ``threshold`` (float):  [Read-Write] minimum brightness the bloom starts having effect
      -1:all pixels affect bloom equally (physically correct, faster as a threshold pass is omitted), 0:all pixels affect bloom brights more, 1(default), >1 brighter
    """
    def __init__(self, intensity: float = 0.000000, threshold: float = 0.000000, size_scale: float = 0.000000, filter1_size: float = 0.000000, filter2_size: float = 0.000000, filter3_size: float = 0.000000, filter4_size: float = 0.000000, filter5_size: float = 0.000000, filter6_size: float = 0.000000, filter1_tint: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], filter2_tint: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], filter3_tint: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], filter4_tint: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], filter5_tint: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], filter6_tint: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def intensity(self) -> float:
        r"""
        (float):  [Read-Write] Multiplier for all bloom contributions >=0: off, 1(default), >1 brighter
        """
        ...
    @intensity.setter
    def intensity(self, value: float) -> None:
        ...
    @property
    def threshold(self) -> float:
        r"""
        (float):  [Read-Write] minimum brightness the bloom starts having effect
        -1:all pixels affect bloom equally (physically correct, faster as a threshold pass is omitted), 0:all pixels affect bloom brights more, 1(default), >1 brighter
        """
        ...
    @threshold.setter
    def threshold(self, value: float) -> None:
        ...
    @property
    def size_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scale for all bloom sizes
        """
        ...
    @size_scale.setter
    def size_scale(self, value: float) -> None:
        ...
    @property
    def filter1_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for the Bloom1 in percent of the screen width
        (is done in 1/2 resolution, larger values cost more performance, good for high frequency details)
        >=0: can be clamped because of shader limitations
        """
        ...
    @filter1_size.setter
    def filter1_size(self, value: float) -> None:
        ...
    @property
    def filter2_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for Bloom2 in percent of the screen width
        (is done in 1/4 resolution, larger values cost more performance)
        >=0: can be clamped because of shader limitations
        """
        ...
    @filter2_size.setter
    def filter2_size(self, value: float) -> None:
        ...
    @property
    def filter3_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for Bloom3 in percent of the screen width
        (is done in 1/8 resolution, larger values cost more performance)
        >=0: can be clamped because of shader limitations
        """
        ...
    @filter3_size.setter
    def filter3_size(self, value: float) -> None:
        ...
    @property
    def filter4_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for Bloom4 in percent of the screen width
        (is done in 1/16 resolution, larger values cost more performance, best for wide contributions)
        >=0: can be clamped because of shader limitations
        """
        ...
    @filter4_size.setter
    def filter4_size(self, value: float) -> None:
        ...
    @property
    def filter5_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for Bloom5 in percent of the screen width
        (is done in 1/32 resolution, larger values cost more performance, best for wide contributions)
        >=0: can be clamped because of shader limitations
        """
        ...
    @filter5_size.setter
    def filter5_size(self, value: float) -> None:
        ...
    @property
    def filter6_size(self) -> float:
        r"""
        (float):  [Read-Write] Diameter size for Bloom6 in percent of the screen width
        (is done in 1/64 resolution, larger values cost more performance, best for wide contributions)
        >=0: can be clamped because of shader limitations
        """
        ...
    @filter6_size.setter
    def filter6_size(self, value: float) -> None:
        ...
    @property
    def filter1_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom1 tint color
        """
        ...
    @filter1_tint.setter
    def filter1_tint(self, value: LinearColor) -> None:
        ...
    @property
    def filter2_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom2 tint color
        """
        ...
    @filter2_tint.setter
    def filter2_tint(self, value: LinearColor) -> None:
        ...
    @property
    def filter3_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom3 tint color
        """
        ...
    @filter3_tint.setter
    def filter3_tint(self, value: LinearColor) -> None:
        ...
    @property
    def filter4_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom4 tint color
        """
        ...
    @filter4_tint.setter
    def filter4_tint(self, value: LinearColor) -> None:
        ...
    @property
    def filter5_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom5 tint color
        """
        ...
    @filter5_tint.setter
    def filter5_tint(self, value: LinearColor) -> None:
        ...
    @property
    def filter6_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Bloom6 tint color
        """
        ...
    @filter6_tint.setter
    def filter6_tint(self, value: LinearColor) -> None:
        ...

class ConvolutionBloomSettings(StructBase):
    r"""
    Convolution Bloom Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``buffer_scale`` (float):  [Read-Write] Implicit buffer region as a fraction of the screen size to insure the bloom does not wrap across the screen.  Larger sizes have perf impact.
    - ``center_uv`` (Vector2D):  [Read-Write] The UV location of the center of the kernel.  Should be very close to (.5,.5)
    - ``pre_filter_max`` (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables convolution boost
    - ``pre_filter_min`` (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables convolution boost
    - ``pre_filter_mult`` (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables convolution boost
    - ``scatter_dispersion`` (float):  [Read-Write] Intensity multiplier on the scatter dispersion energy of the kernel. 1.0 means exactly use the same energy as the kernel scatter dispersion.
    - ``size`` (float):  [Read-Write] Relative size of the convolution kernel image compared to the minor axis of the viewport
    - ``texture`` (Texture2D):  [Read-Write] Texture to replace default convolution bloom kernel
    """
    def __init__(self, texture: Texture2D = None, scatter_dispersion: float = 0.000000, size: float = 0.000000, center_uv: Vector2D = [0.000000, 0.000000], pre_filter_min: float = 0.000000, pre_filter_max: float = 0.000000, pre_filter_mult: float = 0.000000, buffer_scale: float = 0.000000) -> None:
        ...
    @property
    def texture(self) -> Texture2D:
        r"""
        (Texture2D):  [Read-Write] Texture to replace default convolution bloom kernel
        """
        ...
    @texture.setter
    def texture(self, value: Texture2D) -> None:
        ...
    @property
    def scatter_dispersion(self) -> float:
        r"""
        (float):  [Read-Write] Intensity multiplier on the scatter dispersion energy of the kernel. 1.0 means exactly use the same energy as the kernel scatter dispersion.
        """
        ...
    @scatter_dispersion.setter
    def scatter_dispersion(self, value: float) -> None:
        ...
    @property
    def size(self) -> float:
        r"""
        (float):  [Read-Write] Relative size of the convolution kernel image compared to the minor axis of the viewport
        """
        ...
    @size.setter
    def size(self, value: float) -> None:
        ...
    @property
    def center_uv(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The UV location of the center of the kernel.  Should be very close to (.5,.5)
        """
        ...
    @center_uv.setter
    def center_uv(self, value: Vector2D) -> None:
        ...
    @property
    def pre_filter_min(self) -> float:
        r"""
        (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables convolution boost
        """
        ...
    @pre_filter_min.setter
    def pre_filter_min(self, value: float) -> None:
        ...
    @property
    def pre_filter_max(self) -> float:
        r"""
        (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables convolution boost
        """
        ...
    @pre_filter_max.setter
    def pre_filter_max(self, value: float) -> None:
        ...
    @property
    def pre_filter_mult(self) -> float:
        r"""
        (float):  [Read-Write] Boost intensity of select pixels  prior to computing bloom convolution (Min, Max, Multiplier).  Max < Min disables convolution boost
        """
        ...
    @pre_filter_mult.setter
    def pre_filter_mult(self, value: float) -> None:
        ...
    @property
    def buffer_scale(self) -> float:
        r"""
        (float):  [Read-Write] Implicit buffer region as a fraction of the screen size to insure the bloom does not wrap across the screen.  Larger sizes have perf impact.
        """
        ...
    @buffer_scale.setter
    def buffer_scale(self, value: float) -> None:
        ...

class LensBloomSettings(StructBase):
    r"""
    Lens Bloom Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``convolution`` (ConvolutionBloomSettings):  [Read-Write] Bloom convolution method specific settings.
    - ``gaussian_sum`` (GaussianSumBloomSettings):  [Read-Write] Bloom gaussian sum method specific settings.
    - ``method`` (BloomMethod):  [Read-Write] Bloom algorithm
    """
    def __init__(self, gaussian_sum: GaussianSumBloomSettings = [0.675000, -1.000000, 4.000000, 0.300000, 1.000000, 2.000000, 10.000000, 30.000000, 64.000000, [0.346500, 0.346500, 0.346500, 1.000000], [0.138000, 0.138000, 0.138000, 1.000000], [0.117600, 0.117600, 0.117600, 1.000000], [0.066000, 0.066000, 0.066000, 1.000000], [0.066000, 0.066000, 0.066000, 1.000000], [0.061000, 0.061000, 0.061000, 1.000000]], convolution: ConvolutionBloomSettings = [None, 1.000000, 1.000000, [0.500000, 0.500000], 7.000000, 15000.000000, 15.000000, 0.133000], method: BloomMethod = BloomMethod.BM_SOG) -> None:
        ...
    @property
    def gaussian_sum(self) -> GaussianSumBloomSettings:
        r"""
        (GaussianSumBloomSettings):  [Read-Write] Bloom gaussian sum method specific settings.
        """
        ...
    @gaussian_sum.setter
    def gaussian_sum(self, value: GaussianSumBloomSettings) -> None:
        ...
    @property
    def convolution(self) -> ConvolutionBloomSettings:
        r"""
        (ConvolutionBloomSettings):  [Read-Write] Bloom convolution method specific settings.
        """
        ...
    @convolution.setter
    def convolution(self, value: ConvolutionBloomSettings) -> None:
        ...
    @property
    def method(self) -> BloomMethod:
        r"""
        (BloomMethod):  [Read-Write] Bloom algorithm
        """
        ...
    @method.setter
    def method(self, value: BloomMethod) -> None:
        ...

class LensImperfectionSettings(StructBase):
    r"""
    Lens Imperfection Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``dirt_mask`` (Texture):  [Read-Write] Texture that defines the dirt on the camera lens where the light of very bright objects is scattered.
    - ``dirt_mask_intensity`` (float):  [Read-Write] BloomDirtMask intensity
    - ``dirt_mask_tint`` (LinearColor):  [Read-Write] BloomDirtMask tint color
    """
    def __init__(self, dirt_mask: Texture = None, dirt_mask_intensity: float = 0.000000, dirt_mask_tint: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def dirt_mask(self) -> Texture:
        r"""
        (Texture):  [Read-Write] Texture that defines the dirt on the camera lens where the light of very bright objects is scattered.
        """
        ...
    @dirt_mask.setter
    def dirt_mask(self, value: Texture) -> None:
        ...
    @property
    def dirt_mask_intensity(self) -> float:
        r"""
        (float):  [Read-Write] BloomDirtMask intensity
        """
        ...
    @dirt_mask_intensity.setter
    def dirt_mask_intensity(self, value: float) -> None:
        ...
    @property
    def dirt_mask_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] BloomDirtMask tint color
        """
        ...
    @dirt_mask_tint.setter
    def dirt_mask_tint(self, value: LinearColor) -> None:
        ...

class LensSettings(StructBase):
    r"""
    Lens Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bloom`` (LensBloomSettings):  [Read-Write]
    - ``chromatic_aberration`` (float):  [Read-Write] in percent, Scene chromatic aberration / color fringe (camera imperfection) to simulate an artifact that happens in real-world lens, mostly visible in the image corners.
    - ``imperfections`` (LensImperfectionSettings):  [Read-Write]
    """
    def __init__(self, bloom: LensBloomSettings = [[0.675000, -1.000000, 4.000000, 0.300000, 1.000000, 2.000000, 10.000000, 30.000000, 64.000000, [0.346500, 0.346500, 0.346500, 1.000000], [0.138000, 0.138000, 0.138000, 1.000000], [0.117600, 0.117600, 0.117600, 1.000000], [0.066000, 0.066000, 0.066000, 1.000000], [0.066000, 0.066000, 0.066000, 1.000000], [0.061000, 0.061000, 0.061000, 1.000000]], [None, 1.000000, 1.000000, [0.500000, 0.500000], 7.000000, 15000.000000, 15.000000, 0.133000], BloomMethod.BM_SOG], imperfections: LensImperfectionSettings = [None, 0.000000, [0.500000, 0.500000, 0.500000, 1.000000]], chromatic_aberration: float = 0.000000) -> None:
        ...
    @property
    def bloom(self) -> LensBloomSettings:
        r"""
        (LensBloomSettings):  [Read-Write]
        """
        ...
    @bloom.setter
    def bloom(self, value: LensBloomSettings) -> None:
        ...
    @property
    def imperfections(self) -> LensImperfectionSettings:
        r"""
        (LensImperfectionSettings):  [Read-Write]
        """
        ...
    @imperfections.setter
    def imperfections(self, value: LensImperfectionSettings) -> None:
        ...
    @property
    def chromatic_aberration(self) -> float:
        r"""
        (float):  [Read-Write] in percent, Scene chromatic aberration / color fringe (camera imperfection) to simulate an artifact that happens in real-world lens, mostly visible in the image corners.
        """
        ...
    @chromatic_aberration.setter
    def chromatic_aberration(self, value: float) -> None:
        ...

class CameraExposureSettings(StructBase):
    r"""
    Camera Exposure Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Scene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_physical_camera_exposure`` (bool):  [Read-Write] Enables physical camera exposure using ShutterSpeed/ISO/Aperture.
    - ``bias`` (float):  [Read-Write] Logarithmic adjustment for the exposure. Only used if a tonemapper is specified.
      0: no adjustment, -1:2x darker, -2:4x darker, 1:2x brighter, 2:4x brighter, ...
    - ``bias_curve`` (CurveFloat):  [Read-Write] Exposure compensation based on the scene EV100.
      Used to calibrate the final exposure differently depending on the average scene luminance.
      0: no adjustment, -1:2x darker, -2:4x darker, 1:2x brighter, 2:4x brighter, ...
    - ``calibration_constant`` (float):  [Read-Write] Calibration constant for 18% albedo.
    - ``high_percent`` (float):  [Read-Write] The eye adaptation will adapt to a value extracted from the luminance histogram of the scene color.
      The value is defined as having x percent below this brightness. Higher values give bright spots on the screen more priority
      but can lead to less stable results. Lower values give the medium and darker values more priority but might cause burn out of
      bright spots.
      >0, <100, good values are in the range 80 .. 95
    - ``histogram_log_max`` (float):  [Read-Write] temporary exposed until we found good values 4: 16, 8: 256
    - ``histogram_log_min`` (float):  [Read-Write] temporary exposed until we found good values, -8: 1/256, -10: 1/1024
    - ``low_percent`` (float):  [Read-Write] The eye adaptation will adapt to a value extracted from the luminance histogram of the scene color.
      The value is defined as having x percent below this brightness. Higher values give bright spots on the screen more priority
      but can lead to less stable results. Lower values give the medium and darker values more priority but might cause burn out of
      bright spots.
      >0, <100, good values are in the range 70 .. 80
    - ``max_brightness`` (float):  [Read-Write] A good value should be positive (2 is a good value). This is the maximum brightness the auto exposure can adapt to.
      It should be tweaked in a bright lighting situation (too small: image appears too bright, too large: image appears too dark).
      Note: Tweaking emissive materials and lights or tweaking auto exposure can look the same. Tweaking auto exposure has global
      effect and defined the HDR range - you don't want to change that late in the project development.
      Eye Adaptation is disabled if MinBrightness = MaxBrightness
    - ``meter_mask`` (Texture):  [Read-Write] Exposure metering mask. Bright spots on the mask will have high influence on auto-exposure metering
      and dark spots will have low influence.
    - ``method`` (AutoExposureMethod):  [Read-Write] Luminance computation method
    - ``min_brightness`` (float):  [Read-Write] A good value should be positive near 0. This is the minimum brightness the auto exposure can adapt to.
      It should be tweaked in a dark lighting situation (too small: image appears too bright, too large: image appears too dark).
      Note: Tweaking emissive materials and lights or tweaking auto exposure can look the same. Tweaking auto exposure has global
      effect and defined the HDR range - you don't want to change that late in the project development.
      Eye Adaptation is disabled if MinBrightness = MaxBrightness
    - ``speed_down`` (float):  [Read-Write] In F-stops per second, should be >0
    - ``speed_up`` (float):  [Read-Write] In F-stops per second, should be >0
    """
    def __init__(self, method: AutoExposureMethod = AutoExposureMethod.AEM_HISTOGRAM, low_percent: float = 0.000000, high_percent: float = 0.000000, min_brightness: float = 0.000000, max_brightness: float = 0.000000, speed_up: float = 0.000000, speed_down: float = 0.000000, bias: float = 0.000000, bias_curve: CurveFloat = None, meter_mask: Texture = None, histogram_log_min: float = 0.000000, histogram_log_max: float = 0.000000, calibration_constant: float = 0.000000, apply_physical_camera_exposure: bool = False) -> None:
        ...
    @property
    def method(self) -> AutoExposureMethod:
        r"""
        (AutoExposureMethod):  [Read-Write] Luminance computation method
        """
        ...
    @method.setter
    def method(self, value: AutoExposureMethod) -> None:
        ...
    @property
    def low_percent(self) -> float:
        r"""
        (float):  [Read-Write] The eye adaptation will adapt to a value extracted from the luminance histogram of the scene color.
        The value is defined as having x percent below this brightness. Higher values give bright spots on the screen more priority
        but can lead to less stable results. Lower values give the medium and darker values more priority but might cause burn out of
        bright spots.
        >0, <100, good values are in the range 70 .. 80
        """
        ...
    @low_percent.setter
    def low_percent(self, value: float) -> None:
        ...
    @property
    def high_percent(self) -> float:
        r"""
        (float):  [Read-Write] The eye adaptation will adapt to a value extracted from the luminance histogram of the scene color.
        The value is defined as having x percent below this brightness. Higher values give bright spots on the screen more priority
        but can lead to less stable results. Lower values give the medium and darker values more priority but might cause burn out of
        bright spots.
        >0, <100, good values are in the range 80 .. 95
        """
        ...
    @high_percent.setter
    def high_percent(self, value: float) -> None:
        ...
    @property
    def min_brightness(self) -> float:
        r"""
        (float):  [Read-Write] A good value should be positive near 0. This is the minimum brightness the auto exposure can adapt to.
        It should be tweaked in a dark lighting situation (too small: image appears too bright, too large: image appears too dark).
        Note: Tweaking emissive materials and lights or tweaking auto exposure can look the same. Tweaking auto exposure has global
        effect and defined the HDR range - you don't want to change that late in the project development.
        Eye Adaptation is disabled if MinBrightness = MaxBrightness
        """
        ...
    @min_brightness.setter
    def min_brightness(self, value: float) -> None:
        ...
    @property
    def max_brightness(self) -> float:
        r"""
        (float):  [Read-Write] A good value should be positive (2 is a good value). This is the maximum brightness the auto exposure can adapt to.
        It should be tweaked in a bright lighting situation (too small: image appears too bright, too large: image appears too dark).
        Note: Tweaking emissive materials and lights or tweaking auto exposure can look the same. Tweaking auto exposure has global
        effect and defined the HDR range - you don't want to change that late in the project development.
        Eye Adaptation is disabled if MinBrightness = MaxBrightness
        """
        ...
    @max_brightness.setter
    def max_brightness(self, value: float) -> None:
        ...
    @property
    def speed_up(self) -> float:
        r"""
        (float):  [Read-Write] In F-stops per second, should be >0
        """
        ...
    @speed_up.setter
    def speed_up(self, value: float) -> None:
        ...
    @property
    def speed_down(self) -> float:
        r"""
        (float):  [Read-Write] In F-stops per second, should be >0
        """
        ...
    @speed_down.setter
    def speed_down(self, value: float) -> None:
        ...
    @property
    def bias(self) -> float:
        r"""
        (float):  [Read-Write] Logarithmic adjustment for the exposure. Only used if a tonemapper is specified.
        0: no adjustment, -1:2x darker, -2:4x darker, 1:2x brighter, 2:4x brighter, ...
        """
        ...
    @bias.setter
    def bias(self, value: float) -> None:
        ...
    @property
    def bias_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] Exposure compensation based on the scene EV100.
        Used to calibrate the final exposure differently depending on the average scene luminance.
        0: no adjustment, -1:2x darker, -2:4x darker, 1:2x brighter, 2:4x brighter, ...
        """
        ...
    @bias_curve.setter
    def bias_curve(self, value: CurveFloat) -> None:
        ...
    @property
    def meter_mask(self) -> Texture:
        r"""
        (Texture):  [Read-Write] Exposure metering mask. Bright spots on the mask will have high influence on auto-exposure metering
        and dark spots will have low influence.
        """
        ...
    @meter_mask.setter
    def meter_mask(self, value: Texture) -> None:
        ...
    @property
    def histogram_log_min(self) -> float:
        r"""
        (float):  [Read-Write] temporary exposed until we found good values, -8: 1/256, -10: 1/1024
        """
        ...
    @histogram_log_min.setter
    def histogram_log_min(self, value: float) -> None:
        ...
    @property
    def histogram_log_max(self) -> float:
        r"""
        (float):  [Read-Write] temporary exposed until we found good values 4: 16, 8: 256
        """
        ...
    @histogram_log_max.setter
    def histogram_log_max(self, value: float) -> None:
        ...
    @property
    def calibration_constant(self) -> float:
        r"""
        (float):  [Read-Write] Calibration constant for 18% albedo.
        """
        ...
    @calibration_constant.setter
    def calibration_constant(self, value: float) -> None:
        ...
    @property
    def apply_physical_camera_exposure(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables physical camera exposure using ShutterSpeed/ISO/Aperture.
        """
        ...
    @apply_physical_camera_exposure.setter
    def apply_physical_camera_exposure(self, value: bool) -> None:
        ...

class SceneViewExtensionIsActiveFunctor(StructBase):
    r"""
    Contains the TFunction that determines if a scene view extension should be valid in the given context given for the current frame.
    It also contains Guid to help identify it, given that we can't directly compare TFunctions.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneViewExtensionContext.h
    
    """
    def __init__(self) -> None:
        ...

class SkelMeshSkinWeightInfo(StructBase):
    r"""
    Vertex skin weight info supplied for a component override.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedMeshComponent.h
    
    """
    def __init__(self, bone0: int = 0, weight0: int = 0, bone1: int = 0, weight1: int = 0, bone2: int = 0, weight2: int = 0, bone3: int = 0, weight3: int = 0) -> None:
        ...

class VertexOffsetUsage(StructBase):
    r"""
    Vertex Offset Usage
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``usage`` (int32):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class SoftWorldReference(StructBase):
    r"""
    A simple wrapper type to enable content-defined structs to hold soft references to UWorld assets *
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoftWorldReference.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``world_asset`` (World):  [Read-Write]
    """
    def __init__(self, world_asset: World = None) -> None:
        ...
    @property
    def world_asset(self) -> World:
        r"""
        (World):  [Read-Write]
        """
        ...
    @world_asset.setter
    def world_asset(self, value: World) -> None:
        ...

class SoundAttenuationPluginSettings(StructBase):
    r"""
    Sound Attenuation Plugin Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundAttenuation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``occlusion_plugin_settings_array`` (Array[OcclusionPluginSourceSettingsBase]):  [Read-Write] Settings to use with occlusion audio plugin. These are defined by the plugin creator. Not all audio plugins utilize this feature. This is an array so multiple plugins can have settings.
    - ``reverb_plugin_settings_array`` (Array[ReverbPluginSourceSettingsBase]):  [Read-Write] Settings to use with reverb audio plugin. These are defined by the plugin creator. Not all audio plugins utilize this feature. This is an array so multiple plugins can have settings.
    - ``source_data_override_plugin_settings_array`` (Array[SourceDataOverridePluginSourceSettingsBase]):  [Read-Write] Settings to use with source data override audio plugin. These are defined by the plugin creator. Not all audio plugins utilize this feature. This is an array so multiple plugins can have settings.
    - ``spatialization_plugin_settings_array`` (Array[SpatializationPluginSourceSettingsBase]):  [Read-Write] Settings to use with spatialization audio plugin. These are defined by the plugin creator. Not all audio plugins utilize this feature. This is an array so multiple plugins can have settings.
    """
    def __init__(self, spatialization_plugin_settings_array: Array[SpatializationPluginSourceSettingsBase] = [], occlusion_plugin_settings_array: Array[OcclusionPluginSourceSettingsBase] = [], reverb_plugin_settings_array: Array[ReverbPluginSourceSettingsBase] = [], source_data_override_plugin_settings_array: Array[SourceDataOverridePluginSourceSettingsBase] = []) -> None:
        ...
    @property
    def spatialization_plugin_settings_array(self) -> Array[SpatializationPluginSourceSettingsBase]:
        r"""
        (Array[SpatializationPluginSourceSettingsBase]):  [Read-Write] Settings to use with spatialization audio plugin. These are defined by the plugin creator. Not all audio plugins utilize this feature. This is an array so multiple plugins can have settings.
        """
        ...
    @spatialization_plugin_settings_array.setter
    def spatialization_plugin_settings_array(self, value: Array[SpatializationPluginSourceSettingsBase]) -> None:
        ...
    @property
    def occlusion_plugin_settings_array(self) -> Array[OcclusionPluginSourceSettingsBase]:
        r"""
        (Array[OcclusionPluginSourceSettingsBase]):  [Read-Write] Settings to use with occlusion audio plugin. These are defined by the plugin creator. Not all audio plugins utilize this feature. This is an array so multiple plugins can have settings.
        """
        ...
    @occlusion_plugin_settings_array.setter
    def occlusion_plugin_settings_array(self, value: Array[OcclusionPluginSourceSettingsBase]) -> None:
        ...
    @property
    def reverb_plugin_settings_array(self) -> Array[ReverbPluginSourceSettingsBase]:
        r"""
        (Array[ReverbPluginSourceSettingsBase]):  [Read-Write] Settings to use with reverb audio plugin. These are defined by the plugin creator. Not all audio plugins utilize this feature. This is an array so multiple plugins can have settings.
        """
        ...
    @reverb_plugin_settings_array.setter
    def reverb_plugin_settings_array(self, value: Array[ReverbPluginSourceSettingsBase]) -> None:
        ...
    @property
    def source_data_override_plugin_settings_array(self) -> Array[SourceDataOverridePluginSourceSettingsBase]:
        r"""
        (Array[SourceDataOverridePluginSourceSettingsBase]):  [Read-Write] Settings to use with source data override audio plugin. These are defined by the plugin creator. Not all audio plugins utilize this feature. This is an array so multiple plugins can have settings.
        """
        ...
    @source_data_override_plugin_settings_array.setter
    def source_data_override_plugin_settings_array(self, value: Array[SourceDataOverridePluginSourceSettingsBase]) -> None:
        ...

class SoundSubmixSendInfoBase(StructBase):
    r"""
    Common set of settings that are uses as submix sends.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmixSend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``custom_send_level_curve`` (RuntimeFloatCurve):  [Read-Write] The custom reverb send curve to use for distance-based send level.
    - ``disable_manual_send_clamp`` (bool):  [Read-Write] Whether to disable the 0-1 clamp for manual SendLevel control
    - ``max_send_distance`` (float):  [Read-Write] The max distance to send to the master
    - ``max_send_level`` (float):  [Read-Write] The amount to send to master when sound is located at a distance equal to value specified in the max send distance.
    - ``min_send_distance`` (float):  [Read-Write] The min distance to send to the master
    - ``min_send_level`` (float):  [Read-Write] The amount to send to master when sound is located at a distance equal to value specified in the min send distance.
    - ``send_level`` (float):  [Read-Write] The amount of audio to send
    - ``send_level_control_method`` (SendLevelControlMethod):  [Read-Write] Manual: Use Send Level only
      Linear: Interpolate between Min and Max Send Levels based on listener distance (between Distance Min and Distance Max)
      Custom Curve: Use the float curve to map Send Level to distance (0.0-1.0 on curve maps to Distance Min - Distance Max)
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] The submix to send the audio to
    """
    def __init__(self, send_level_control_method: SendLevelControlMethod = SendLevelControlMethod.LINEAR, sound_submix: SoundSubmixBase = None, send_level: float = 0.000000, disable_manual_send_clamp: bool = False, min_send_level: float = 0.000000, max_send_level: float = 0.000000, min_send_distance: float = 0.000000, max_send_distance: float = 0.000000, custom_send_level_curve: RuntimeFloatCurve = []) -> None:
        ...
    @property
    def send_level_control_method(self) -> SendLevelControlMethod:
        r"""
        (SendLevelControlMethod):  [Read-Write] Manual: Use Send Level only
        Linear: Interpolate between Min and Max Send Levels based on listener distance (between Distance Min and Distance Max)
        Custom Curve: Use the float curve to map Send Level to distance (0.0-1.0 on curve maps to Distance Min - Distance Max)
        """
        ...
    @send_level_control_method.setter
    def send_level_control_method(self, value: SendLevelControlMethod) -> None:
        ...
    @property
    def sound_submix(self) -> SoundSubmixBase:
        r"""
        (SoundSubmixBase):  [Read-Write] The submix to send the audio to
        """
        ...
    @sound_submix.setter
    def sound_submix(self, value: SoundSubmixBase) -> None:
        ...
    @property
    def send_level(self) -> float:
        r"""
        (float):  [Read-Write] The amount of audio to send
        """
        ...
    @send_level.setter
    def send_level(self, value: float) -> None:
        ...
    @property
    def disable_manual_send_clamp(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to disable the 0-1 clamp for manual SendLevel control
        """
        ...
    @disable_manual_send_clamp.setter
    def disable_manual_send_clamp(self, value: bool) -> None:
        ...
    @property
    def min_send_level(self) -> float:
        r"""
        (float):  [Read-Write] The amount to send to master when sound is located at a distance equal to value specified in the min send distance.
        """
        ...
    @min_send_level.setter
    def min_send_level(self, value: float) -> None:
        ...
    @property
    def max_send_level(self) -> float:
        r"""
        (float):  [Read-Write] The amount to send to master when sound is located at a distance equal to value specified in the max send distance.
        """
        ...
    @max_send_level.setter
    def max_send_level(self, value: float) -> None:
        ...
    @property
    def min_send_distance(self) -> float:
        r"""
        (float):  [Read-Write] The min distance to send to the master
        """
        ...
    @min_send_distance.setter
    def min_send_distance(self, value: float) -> None:
        ...
    @property
    def max_send_distance(self) -> float:
        r"""
        (float):  [Read-Write] The max distance to send to the master
        """
        ...
    @max_send_distance.setter
    def max_send_distance(self, value: float) -> None:
        ...
    @property
    def custom_send_level_curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Write] The custom reverb send curve to use for distance-based send level.
        """
        ...
    @custom_send_level_curve.setter
    def custom_send_level_curve(self, value: RuntimeFloatCurve) -> None:
        ...

class AttenuationSubmixSendSettings(SoundSubmixSendInfoBase):
    r"""
    Attenuation Submix Send Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundAttenuation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``custom_send_level_curve`` (RuntimeFloatCurve):  [Read-Write] The custom reverb send curve to use for distance-based send level.
    - ``disable_manual_send_clamp`` (bool):  [Read-Write] Whether to disable the 0-1 clamp for manual SendLevel control
    - ``max_send_distance`` (float):  [Read-Write] The max distance to send to the master
    - ``max_send_level`` (float):  [Read-Write] The amount to send to master when sound is located at a distance equal to value specified in the max send distance.
    - ``min_send_distance`` (float):  [Read-Write] The min distance to send to the master
    - ``min_send_level`` (float):  [Read-Write] The amount to send to master when sound is located at a distance equal to value specified in the min send distance.
    - ``send_level`` (float):  [Read-Write] The amount of audio to send
    - ``send_level_control_method`` (SendLevelControlMethod):  [Read-Write] Manual: Use Send Level only
      Linear: Interpolate between Min and Max Send Levels based on listener distance (between Distance Min and Distance Max)
      Custom Curve: Use the float curve to map Send Level to distance (0.0-1.0 on curve maps to Distance Min - Distance Max)
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] The submix to send the audio to
    """
    def __init__(self, send_level_control_method: SendLevelControlMethod = SendLevelControlMethod.LINEAR, sound_submix: SoundSubmixBase = None, send_level: float = 0.000000, disable_manual_send_clamp: bool = False, min_send_level: float = 0.000000, max_send_level: float = 0.000000, min_send_distance: float = 0.000000, max_send_distance: float = 0.000000, custom_send_level_curve: RuntimeFloatCurve = []) -> None:
        ...

class SoundAttenuationSettings(BaseAttenuationSettings):
    r"""
    The settings for attenuating.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundAttenuation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absorption_method`` (AirAbsorptionMethod):  [Read-Write] What method to use to map distance values to frequency absorption values.
    - ``apply_normalization_to_stereo_sounds`` (bool):  [Read-Write] Enables applying a -6 dB attenuation to stereo assets which are 3d spatialized. Avoids clipping when assets have spread of 0.0 due to channel summing.
    - ``attenuate`` (bool):  [Read-Write] Allows distance-based volume attenuation.
    - ``attenuate_with_lpf`` (bool):  [Read-Write] Allows simulation of air absorption by applying a filter with a cutoff frequency as a function of distance.
    - ``attenuation_shape`` (AttenuationShape):  [Read-Write] The shape of the non-custom attenuation method.
    - ``attenuation_shape_extents`` (Vector):  [Read-Write] The dimensions to use for the attenuation shape. Interpretation of the values differ per shape.
               Sphere  - X is Sphere Radius. Y and Z are unused
               Capsule - X is Capsule Half Height, Y is Capsule Radius, Z is unused
               Box     - X, Y, and Z are the Box's dimensions
               Cone    - X is Cone Radius, Y is Cone Angle, Z is Cone Falloff Angle
    - ``audio_link_settings_override`` (AudioLinkSettingsAbstract):  [Read-Write] AudioLink Setting Overrides
    - ``binaural_radius`` (float):  [Read-Write] What min radius to use to swap to non-binaural audio when a sound starts playing.
    - ``cone_offset`` (float):  [Read-Write] The distance back from the sound's origin to begin the cone when using the cone attenuation shape.
    - ``cone_sphere_falloff_distance`` (float):  [Read-Write] The distance over which volume attenuation occurs for the optional sphere shape.
    - ``cone_sphere_radius`` (float):  [Read-Write] An optional attenuation radius (sphere) that extends from the cone origin.
    - ``custom_attenuation_curve`` (RuntimeFloatCurve):  [Read-Write] The custom volume attenuation curve to use.
    - ``custom_highpass_air_absorption_curve`` (RuntimeFloatCurve):  [Read-Write] The normalized custom curve to use for the air absorption highpass frequency values. Does a mapping from defined distance values (x-axis) and defined frequency values (y-axis)
    - ``custom_lowpass_air_absorption_curve`` (RuntimeFloatCurve):  [Read-Write] The normalized custom curve to use for the air absorption lowpass frequency values. Does a mapping from defined distance values (x-axis) and defined frequency values (y-axis)
    - ``custom_priority_attenuation_curve`` (RuntimeFloatCurve):  [Read-Write] The custom curve to use for distance-based priority attenuation.
    - ``custom_reverb_send_curve`` (RuntimeFloatCurve):  [Read-Write] The custom reverb send curve to use for distance-based send level.
    - ``d_b_attenuation_at_max`` (float):  [Read-Write] The attenuation volume at the falloff distance in decibels (Only for 'Natural Sound' Distance Algorithm).
    - ``distance_algorithm`` (AttenuationDistanceModel):  [Read-Write] The type of attenuation as a function of distance to use.
    - ``enable_focus_interpolation`` (bool):  [Read-Write] Enables focus interpolation to smooth transition in and and of focus.
    - ``enable_listener_focus`` (bool):  [Read-Write] Enable listener focus-based adjustments.
    - ``enable_log_frequency_scaling`` (bool):  [Read-Write] Enables applying a log scale to frequency values (so frequency sweeping is perceptually linear).
    - ``enable_occlusion`` (bool):  [Read-Write] Enables realtime occlusion tracing.
    - ``enable_priority_attenuation`` (bool):  [Read-Write] Enables attenuation of sound priority based off distance.
    - ``enable_reverb_send`` (bool):  [Read-Write] Enables adjusting reverb sends based on distance.
    - ``enable_send_to_audio_link`` (bool):  [Read-Write] Enables/Disables AudioLink on all sources using this attenuation
    - ``enable_source_data_override`` (bool):  [Read-Write] Enables overriding WaveInstance data using source data override plugin
    - ``enable_submix_sends`` (bool):  [Read-Write] Enables submix sends based on distance.
    - ``falloff_distance`` (float):  [Read-Write] The distance over which volume attenuation occurs.
    - ``falloff_mode`` (NaturalSoundFalloffMode):  [Read-Write] Whether to continue attenuating, go silent, or hold last volume value when beyond falloff bounds and
      'Attenuation At Max (dB)' is set to a value greater than -60dB.
      (Only for 'Natural Sound' Distance Algorithm). */
    - ``focus_attack_interp_speed`` (float):  [Read-Write] Scalar used to increase interpolation speed upwards to the target Focus value
    - ``focus_azimuth`` (float):  [Read-Write] Azimuth angle (in degrees) relative to the listener forward vector which defines the focus region of sounds. Sounds playing at an angle less than this will be in focus.
    - ``focus_distance_scale`` (float):  [Read-Write] Amount to scale the distance calculation of sounds that are in-focus. Can be used to make in-focus sounds appear to be closer or further away than they actually are.
    - ``focus_priority_scale`` (float):  [Read-Write] Amount to scale the priority of sounds that are in focus. Can be used to boost the priority of sounds that are in focus.
    - ``focus_release_interp_speed`` (float):  [Read-Write] Scalar used to increase interpolation speed downwards to the target Focus value
    - ``focus_volume_attenuation`` (float):  [Read-Write] Amount to attenuate sounds that are in focus. Can be overridden at the sound-level.
    - ``hpf_frequency_at_max`` (float):  [Read-Write] The range of the cutoff frequency (in Hz) of the highpass absorption filter.
    - ``hpf_frequency_at_min`` (float):  [Read-Write] The range of the cutoff frequency (in Hz) of the highpass absorption filter.
    - ``lpf_frequency_at_max`` (float):  [Read-Write] The range of the cutoff frequency (in Hz) of the lowpass absorption filter.
    - ``lpf_frequency_at_min`` (float):  [Read-Write] The range of the cutoff frequency (in Hz) of the lowpass absorption filter.
    - ``lpf_radius_max`` (float):  [Read-Write] The max distance range at which to apply an absorption LPF filter. Absorption freq cutoff interpolates between filter frequency ranges between these distance values.
    - ``lpf_radius_min`` (float):  [Read-Write] The distance min range at which to apply an absorption LPF filter.
    - ``manual_priority_attenuation`` (float):  [Read-Write] Static priority scalar to use (doesn't change as a function of distance).
    - ``manual_reverb_send_level`` (float):  [Read-Write] The manual master reverb send level to use. Doesn't change as a function of distance.
    - ``non_focus_azimuth`` (float):  [Read-Write] Azimuth angle (in degrees) relative to the listener forward vector which defines the non-focus region of sounds. Sounds playing at an angle greater than this will be out of focus.
    - ``non_focus_distance_scale`` (float):  [Read-Write] Amount to scale the distance calculation of sounds that are not in-focus. Can be used to make in-focus sounds appear to be closer or further away than they actually are.
    - ``non_focus_priority_scale`` (float):  [Read-Write] Amount to scale the priority of sounds that are not in-focus. Can be used to reduce the priority of sounds that are not in focus.
    - ``non_focus_volume_attenuation`` (float):  [Read-Write] Amount to attenuate sounds that are not in focus. Can be overridden at the sound-level.
    - ``non_spatialized_radius_end`` (float):  [Read-Write] The distance below which a sound is fully non-spatialized (2D). See "Non Spatialized Radius Start" to define the start of the interpolation and the "Non Spatialized Radius Mode" for the mode of the interpolation.
    - ``non_spatialized_radius_mode`` (NonSpatializedRadiusSpeakerMapMode):  [Read-Write] Defines how to interpolate a 3D sound towards a 2D sound when using the non-spatialized radius start and end properties.
    - ``non_spatialized_radius_start`` (float):  [Read-Write] The distance below which a sound begins to linearly interpolate towards being non-spatialized (2D). See "Non Spatialized Radius End" to define the end of the interpolation and the "Non Spatialized Radius Mode" for the mode of the interpolation. Note: this does not apply when using a 3rd party binaural plugin (audio will remain spatialized).
    - ``occlusion_interpolation_time`` (float):  [Read-Write] The amount of time in seconds to interpolate to the target OcclusionLowPassFilterFrequency when a sound is occluded.
    - ``occlusion_low_pass_filter_frequency`` (float):  [Read-Write] The low pass filter frequency (in Hz) to apply if the sound playing in this audio component is occluded. This will override the frequency set in LowPassFilterFrequency. A frequency of 0.0 is the device sample rate and will bypass the filter.
    - ``occlusion_trace_channel`` (CollisionChannel):  [Read-Write] Which trace channel to use for audio occlusion checks.
    - ``occlusion_volume_attenuation`` (float):  [Read-Write] The amount of volume attenuation to apply to sounds which are occluded.
    - ``plugin_settings`` (SoundAttenuationPluginSettings):  [Read-Write] Sound attenuation plugin settings to use with sounds that play with this attenuation setting.
    - ``priority_attenuation_distance_max`` (float):  [Read-Write] The max distance to attenuate priority.
    - ``priority_attenuation_distance_min`` (float):  [Read-Write] The min distance to attenuate priority.
    - ``priority_attenuation_max`` (float):  [Read-Write] Interpolated value to scale priority against when the sound is at the maximum priority attenuation distance from the closest listener.
    - ``priority_attenuation_method`` (PriorityAttenuationMethod):  [Read-Write] What method to use to control priority attenuation
    - ``priority_attenuation_min`` (float):  [Read-Write] Interpolated value to scale priority against when the sound is at the minimum priority attenuation distance from the closest listener.
    - ``reverb_distance_max`` (float):  [Read-Write] The max distance to send to the master reverb.
    - ``reverb_distance_min`` (float):  [Read-Write] The min distance to send to the master reverb.
    - ``reverb_send_method`` (ReverbSendMethod):  [Read-Write] What method to use to control master reverb sends
    - ``reverb_wet_level_max`` (float):  [Read-Write] The amount to send to master reverb when sound is located at a distance equal to value specified in the reverb max send distance.
    - ``reverb_wet_level_min`` (float):  [Read-Write] The amount to send to master reverb when sound is located at a distance equal to value specified in the reverb min send distance.
    - ``spatialization_algorithm`` (SoundSpatializationAlgorithm):  [Read-Write] What method we use to spatialize the sound.
    - ``spatialize`` (bool):  [Read-Write] Allows the source to be 3D spatialized.
    - ``stereo_spread`` (float):  [Read-Write] The world-space distance between left and right stereo channels when stereo assets are 3D spatialized.
    - ``submix_send_settings`` (Array[AttenuationSubmixSendSettings]):  [Read-Write] Set of submix send settings to use to send audio to submixes as a function of distance.
    - ``use_complex_collision_for_occlusion`` (bool):  [Read-Write] Enables tracing against complex collision when doing occlusion traces.
    """
    def __init__(self, distance_algorithm: AttenuationDistanceModel = AttenuationDistanceModel.LINEAR, attenuation_shape: AttenuationShape = AttenuationShape.SPHERE, falloff_mode: NaturalSoundFalloffMode = NaturalSoundFalloffMode.CONTINUES, d_b_attenuation_at_max: float = 0.000000, attenuation_shape_extents: Vector = [0.000000, 0.000000, 0.000000], cone_offset: float = 0.000000, falloff_distance: float = 0.000000, cone_sphere_radius: float = 0.000000, cone_sphere_falloff_distance: float = 0.000000, custom_attenuation_curve: RuntimeFloatCurve = [], attenuate: bool = False, spatialize: bool = False, attenuate_with_lpf: bool = False, enable_listener_focus: bool = False, enable_focus_interpolation: bool = False, enable_occlusion: bool = False, use_complex_collision_for_occlusion: bool = False, enable_reverb_send: bool = False, enable_priority_attenuation: bool = False, apply_normalization_to_stereo_sounds: bool = False, enable_log_frequency_scaling: bool = False, enable_submix_sends: bool = False, enable_source_data_override: bool = False, enable_send_to_audio_link: bool = False, spatialization_algorithm: SoundSpatializationAlgorithm = SoundSpatializationAlgorithm.SPATIALIZATION_DEFAULT, audio_link_settings_override: AudioLinkSettingsAbstract = None, binaural_radius: float = 0.000000, custom_lowpass_air_absorption_curve: RuntimeFloatCurve = [], custom_highpass_air_absorption_curve: RuntimeFloatCurve = [], absorption_method: AirAbsorptionMethod = AirAbsorptionMethod.LINEAR, occlusion_trace_channel: CollisionChannel = CollisionChannel.ECC_WORLD_STATIC, reverb_send_method: ReverbSendMethod = ReverbSendMethod.LINEAR, priority_attenuation_method: PriorityAttenuationMethod = PriorityAttenuationMethod.LINEAR, non_spatialized_radius_start: float = 0.000000, non_spatialized_radius_end: float = 0.000000, non_spatialized_radius_mode: NonSpatializedRadiusSpeakerMapMode = NonSpatializedRadiusSpeakerMapMode.OMNI_DIRECTIONAL, stereo_spread: float = 0.000000, lpf_radius_min: float = 0.000000, lpf_radius_max: float = 0.000000, lpf_frequency_at_min: float = 0.000000, lpf_frequency_at_max: float = 0.000000, hpf_frequency_at_min: float = 0.000000, hpf_frequency_at_max: float = 0.000000, focus_azimuth: float = 0.000000, non_focus_azimuth: float = 0.000000, focus_distance_scale: float = 0.000000, non_focus_distance_scale: float = 0.000000, focus_priority_scale: float = 0.000000, non_focus_priority_scale: float = 0.000000, focus_volume_attenuation: float = 0.000000, non_focus_volume_attenuation: float = 0.000000, focus_attack_interp_speed: float = 0.000000, focus_release_interp_speed: float = 0.000000, occlusion_low_pass_filter_frequency: float = 0.000000, occlusion_volume_attenuation: float = 0.000000, occlusion_interpolation_time: float = 0.000000, reverb_wet_level_min: float = 0.000000, reverb_wet_level_max: float = 0.000000, reverb_distance_min: float = 0.000000, reverb_distance_max: float = 0.000000, manual_reverb_send_level: float = 0.000000, priority_attenuation_min: float = 0.000000, priority_attenuation_max: float = 0.000000, priority_attenuation_distance_min: float = 0.000000, priority_attenuation_distance_max: float = 0.000000, manual_priority_attenuation: float = 0.000000, custom_reverb_send_curve: RuntimeFloatCurve = [], submix_send_settings: Array[AttenuationSubmixSendSettings] = [], custom_priority_attenuation_curve: RuntimeFloatCurve = [], plugin_settings: SoundAttenuationPluginSettings = [[], [], [], []]) -> None:
        ...
    @property
    def attenuate(self) -> bool:
        r"""
        (bool):  [Read-Write] Allows distance-based volume attenuation.
        """
        ...
    @attenuate.setter
    def attenuate(self, value: bool) -> None:
        ...
    @property
    def spatialize(self) -> bool:
        r"""
        (bool):  [Read-Write] Allows the source to be 3D spatialized.
        """
        ...
    @spatialize.setter
    def spatialize(self, value: bool) -> None:
        ...
    @property
    def attenuate_with_lpf(self) -> bool:
        r"""
        (bool):  [Read-Write] Allows simulation of air absorption by applying a filter with a cutoff frequency as a function of distance.
        """
        ...
    @attenuate_with_lpf.setter
    def attenuate_with_lpf(self, value: bool) -> None:
        ...
    @property
    def enable_listener_focus(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable listener focus-based adjustments.
        """
        ...
    @enable_listener_focus.setter
    def enable_listener_focus(self, value: bool) -> None:
        ...
    @property
    def enable_focus_interpolation(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables focus interpolation to smooth transition in and and of focus.
        """
        ...
    @enable_focus_interpolation.setter
    def enable_focus_interpolation(self, value: bool) -> None:
        ...
    @property
    def enable_occlusion(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables realtime occlusion tracing.
        """
        ...
    @enable_occlusion.setter
    def enable_occlusion(self, value: bool) -> None:
        ...
    @property
    def use_complex_collision_for_occlusion(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables tracing against complex collision when doing occlusion traces.
        """
        ...
    @use_complex_collision_for_occlusion.setter
    def use_complex_collision_for_occlusion(self, value: bool) -> None:
        ...
    @property
    def enable_reverb_send(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables adjusting reverb sends based on distance.
        """
        ...
    @enable_reverb_send.setter
    def enable_reverb_send(self, value: bool) -> None:
        ...
    @property
    def enable_priority_attenuation(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables attenuation of sound priority based off distance.
        """
        ...
    @enable_priority_attenuation.setter
    def enable_priority_attenuation(self, value: bool) -> None:
        ...
    @property
    def apply_normalization_to_stereo_sounds(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables applying a -6 dB attenuation to stereo assets which are 3d spatialized. Avoids clipping when assets have spread of 0.0 due to channel summing.
        """
        ...
    @apply_normalization_to_stereo_sounds.setter
    def apply_normalization_to_stereo_sounds(self, value: bool) -> None:
        ...
    @property
    def enable_log_frequency_scaling(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables applying a log scale to frequency values (so frequency sweeping is perceptually linear).
        """
        ...
    @enable_log_frequency_scaling.setter
    def enable_log_frequency_scaling(self, value: bool) -> None:
        ...
    @property
    def enable_submix_sends(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables submix sends based on distance.
        """
        ...
    @enable_submix_sends.setter
    def enable_submix_sends(self, value: bool) -> None:
        ...
    @property
    def enable_source_data_override(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables overriding WaveInstance data using source data override plugin
        """
        ...
    @enable_source_data_override.setter
    def enable_source_data_override(self, value: bool) -> None:
        ...
    @property
    def enable_send_to_audio_link(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables/Disables AudioLink on all sources using this attenuation
        """
        ...
    @enable_send_to_audio_link.setter
    def enable_send_to_audio_link(self, value: bool) -> None:
        ...
    @property
    def spatialization_algorithm(self) -> SoundSpatializationAlgorithm:
        r"""
        (SoundSpatializationAlgorithm):  [Read-Write] What method we use to spatialize the sound.
        """
        ...
    @spatialization_algorithm.setter
    def spatialization_algorithm(self, value: SoundSpatializationAlgorithm) -> None:
        ...
    @property
    def audio_link_settings_override(self) -> AudioLinkSettingsAbstract:
        r"""
        (AudioLinkSettingsAbstract):  [Read-Write] AudioLink Setting Overrides
        """
        ...
    @audio_link_settings_override.setter
    def audio_link_settings_override(self, value: AudioLinkSettingsAbstract) -> None:
        ...
    @property
    def binaural_radius(self) -> float:
        r"""
        (float):  [Read-Write] What min radius to use to swap to non-binaural audio when a sound starts playing.
        """
        ...
    @binaural_radius.setter
    def binaural_radius(self, value: float) -> None:
        ...
    @property
    def custom_lowpass_air_absorption_curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Write] The normalized custom curve to use for the air absorption lowpass frequency values. Does a mapping from defined distance values (x-axis) and defined frequency values (y-axis)
        """
        ...
    @custom_lowpass_air_absorption_curve.setter
    def custom_lowpass_air_absorption_curve(self, value: RuntimeFloatCurve) -> None:
        ...
    @property
    def custom_highpass_air_absorption_curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Write] The normalized custom curve to use for the air absorption highpass frequency values. Does a mapping from defined distance values (x-axis) and defined frequency values (y-axis)
        """
        ...
    @custom_highpass_air_absorption_curve.setter
    def custom_highpass_air_absorption_curve(self, value: RuntimeFloatCurve) -> None:
        ...
    @property
    def absorption_method(self) -> AirAbsorptionMethod:
        r"""
        (AirAbsorptionMethod):  [Read-Write] What method to use to map distance values to frequency absorption values.
        """
        ...
    @absorption_method.setter
    def absorption_method(self, value: AirAbsorptionMethod) -> None:
        ...
    @property
    def occlusion_trace_channel(self) -> CollisionChannel:
        r"""
        (CollisionChannel):  [Read-Write] Which trace channel to use for audio occlusion checks.
        """
        ...
    @occlusion_trace_channel.setter
    def occlusion_trace_channel(self, value: CollisionChannel) -> None:
        ...
    @property
    def reverb_send_method(self) -> ReverbSendMethod:
        r"""
        (ReverbSendMethod):  [Read-Write] What method to use to control master reverb sends
        """
        ...
    @reverb_send_method.setter
    def reverb_send_method(self, value: ReverbSendMethod) -> None:
        ...
    @property
    def priority_attenuation_method(self) -> PriorityAttenuationMethod:
        r"""
        (PriorityAttenuationMethod):  [Read-Write] What method to use to control priority attenuation
        """
        ...
    @priority_attenuation_method.setter
    def priority_attenuation_method(self, value: PriorityAttenuationMethod) -> None:
        ...
    @property
    def non_spatialized_radius_start(self) -> float:
        r"""
        (float):  [Read-Write] The distance below which a sound begins to linearly interpolate towards being non-spatialized (2D). See "Non Spatialized Radius End" to define the end of the interpolation and the "Non Spatialized Radius Mode" for the mode of the interpolation. Note: this does not apply when using a 3rd party binaural plugin (audio will remain spatialized).
        """
        ...
    @non_spatialized_radius_start.setter
    def non_spatialized_radius_start(self, value: float) -> None:
        ...
    @property
    def omni_radius(self) -> float:
        r"""
        deprecated: 'omni_radius' was renamed to 'non_spatialized_radius_start'.
        """
        ...
    @omni_radius.setter
    def omni_radius(self, value: float) -> None:
        ...
    @property
    def non_spatialized_radius_end(self) -> float:
        r"""
        (float):  [Read-Write] The distance below which a sound is fully non-spatialized (2D). See "Non Spatialized Radius Start" to define the start of the interpolation and the "Non Spatialized Radius Mode" for the mode of the interpolation.
        """
        ...
    @non_spatialized_radius_end.setter
    def non_spatialized_radius_end(self, value: float) -> None:
        ...
    @property
    def non_spatialized_radius_mode(self) -> NonSpatializedRadiusSpeakerMapMode:
        r"""
        (NonSpatializedRadiusSpeakerMapMode):  [Read-Write] Defines how to interpolate a 3D sound towards a 2D sound when using the non-spatialized radius start and end properties.
        """
        ...
    @non_spatialized_radius_mode.setter
    def non_spatialized_radius_mode(self, value: NonSpatializedRadiusSpeakerMapMode) -> None:
        ...
    @property
    def stereo_spread(self) -> float:
        r"""
        (float):  [Read-Write] The world-space distance between left and right stereo channels when stereo assets are 3D spatialized.
        """
        ...
    @stereo_spread.setter
    def stereo_spread(self, value: float) -> None:
        ...
    @property
    def lpf_radius_min(self) -> float:
        r"""
        (float):  [Read-Write] The distance min range at which to apply an absorption LPF filter.
        """
        ...
    @lpf_radius_min.setter
    def lpf_radius_min(self, value: float) -> None:
        ...
    @property
    def lpf_radius_max(self) -> float:
        r"""
        (float):  [Read-Write] The max distance range at which to apply an absorption LPF filter. Absorption freq cutoff interpolates between filter frequency ranges between these distance values.
        """
        ...
    @lpf_radius_max.setter
    def lpf_radius_max(self, value: float) -> None:
        ...
    @property
    def lpf_frequency_at_min(self) -> float:
        r"""
        (float):  [Read-Write] The range of the cutoff frequency (in Hz) of the lowpass absorption filter.
        """
        ...
    @lpf_frequency_at_min.setter
    def lpf_frequency_at_min(self, value: float) -> None:
        ...
    @property
    def lpf_frequency_at_max(self) -> float:
        r"""
        (float):  [Read-Write] The range of the cutoff frequency (in Hz) of the lowpass absorption filter.
        """
        ...
    @lpf_frequency_at_max.setter
    def lpf_frequency_at_max(self, value: float) -> None:
        ...
    @property
    def hpf_frequency_at_min(self) -> float:
        r"""
        (float):  [Read-Write] The range of the cutoff frequency (in Hz) of the highpass absorption filter.
        """
        ...
    @hpf_frequency_at_min.setter
    def hpf_frequency_at_min(self, value: float) -> None:
        ...
    @property
    def hpf_frequency_at_max(self) -> float:
        r"""
        (float):  [Read-Write] The range of the cutoff frequency (in Hz) of the highpass absorption filter.
        """
        ...
    @hpf_frequency_at_max.setter
    def hpf_frequency_at_max(self, value: float) -> None:
        ...
    @property
    def focus_azimuth(self) -> float:
        r"""
        (float):  [Read-Write] Azimuth angle (in degrees) relative to the listener forward vector which defines the focus region of sounds. Sounds playing at an angle less than this will be in focus.
        """
        ...
    @focus_azimuth.setter
    def focus_azimuth(self, value: float) -> None:
        ...
    @property
    def non_focus_azimuth(self) -> float:
        r"""
        (float):  [Read-Write] Azimuth angle (in degrees) relative to the listener forward vector which defines the non-focus region of sounds. Sounds playing at an angle greater than this will be out of focus.
        """
        ...
    @non_focus_azimuth.setter
    def non_focus_azimuth(self, value: float) -> None:
        ...
    @property
    def focus_distance_scale(self) -> float:
        r"""
        (float):  [Read-Write] Amount to scale the distance calculation of sounds that are in-focus. Can be used to make in-focus sounds appear to be closer or further away than they actually are.
        """
        ...
    @focus_distance_scale.setter
    def focus_distance_scale(self, value: float) -> None:
        ...
    @property
    def non_focus_distance_scale(self) -> float:
        r"""
        (float):  [Read-Write] Amount to scale the distance calculation of sounds that are not in-focus. Can be used to make in-focus sounds appear to be closer or further away than they actually are.
        """
        ...
    @non_focus_distance_scale.setter
    def non_focus_distance_scale(self, value: float) -> None:
        ...
    @property
    def focus_priority_scale(self) -> float:
        r"""
        (float):  [Read-Write] Amount to scale the priority of sounds that are in focus. Can be used to boost the priority of sounds that are in focus.
        """
        ...
    @focus_priority_scale.setter
    def focus_priority_scale(self, value: float) -> None:
        ...
    @property
    def non_focus_priority_scale(self) -> float:
        r"""
        (float):  [Read-Write] Amount to scale the priority of sounds that are not in-focus. Can be used to reduce the priority of sounds that are not in focus.
        """
        ...
    @non_focus_priority_scale.setter
    def non_focus_priority_scale(self, value: float) -> None:
        ...
    @property
    def focus_volume_attenuation(self) -> float:
        r"""
        (float):  [Read-Write] Amount to attenuate sounds that are in focus. Can be overridden at the sound-level.
        """
        ...
    @focus_volume_attenuation.setter
    def focus_volume_attenuation(self, value: float) -> None:
        ...
    @property
    def non_focus_volume_attenuation(self) -> float:
        r"""
        (float):  [Read-Write] Amount to attenuate sounds that are not in focus. Can be overridden at the sound-level.
        """
        ...
    @non_focus_volume_attenuation.setter
    def non_focus_volume_attenuation(self, value: float) -> None:
        ...
    @property
    def focus_attack_interp_speed(self) -> float:
        r"""
        (float):  [Read-Write] Scalar used to increase interpolation speed upwards to the target Focus value
        """
        ...
    @focus_attack_interp_speed.setter
    def focus_attack_interp_speed(self, value: float) -> None:
        ...
    @property
    def focus_release_interp_speed(self) -> float:
        r"""
        (float):  [Read-Write] Scalar used to increase interpolation speed downwards to the target Focus value
        """
        ...
    @focus_release_interp_speed.setter
    def focus_release_interp_speed(self, value: float) -> None:
        ...
    @property
    def occlusion_low_pass_filter_frequency(self) -> float:
        r"""
        (float):  [Read-Write] The low pass filter frequency (in Hz) to apply if the sound playing in this audio component is occluded. This will override the frequency set in LowPassFilterFrequency. A frequency of 0.0 is the device sample rate and will bypass the filter.
        """
        ...
    @occlusion_low_pass_filter_frequency.setter
    def occlusion_low_pass_filter_frequency(self, value: float) -> None:
        ...
    @property
    def occlusion_volume_attenuation(self) -> float:
        r"""
        (float):  [Read-Write] The amount of volume attenuation to apply to sounds which are occluded.
        """
        ...
    @occlusion_volume_attenuation.setter
    def occlusion_volume_attenuation(self, value: float) -> None:
        ...
    @property
    def occlusion_interpolation_time(self) -> float:
        r"""
        (float):  [Read-Write] The amount of time in seconds to interpolate to the target OcclusionLowPassFilterFrequency when a sound is occluded.
        """
        ...
    @occlusion_interpolation_time.setter
    def occlusion_interpolation_time(self, value: float) -> None:
        ...
    @property
    def reverb_wet_level_min(self) -> float:
        r"""
        (float):  [Read-Write] The amount to send to master reverb when sound is located at a distance equal to value specified in the reverb min send distance.
        """
        ...
    @reverb_wet_level_min.setter
    def reverb_wet_level_min(self, value: float) -> None:
        ...
    @property
    def reverb_wet_level_max(self) -> float:
        r"""
        (float):  [Read-Write] The amount to send to master reverb when sound is located at a distance equal to value specified in the reverb max send distance.
        """
        ...
    @reverb_wet_level_max.setter
    def reverb_wet_level_max(self, value: float) -> None:
        ...
    @property
    def reverb_distance_min(self) -> float:
        r"""
        (float):  [Read-Write] The min distance to send to the master reverb.
        """
        ...
    @reverb_distance_min.setter
    def reverb_distance_min(self, value: float) -> None:
        ...
    @property
    def reverb_distance_max(self) -> float:
        r"""
        (float):  [Read-Write] The max distance to send to the master reverb.
        """
        ...
    @reverb_distance_max.setter
    def reverb_distance_max(self, value: float) -> None:
        ...
    @property
    def manual_reverb_send_level(self) -> float:
        r"""
        (float):  [Read-Write] The manual master reverb send level to use. Doesn't change as a function of distance.
        """
        ...
    @manual_reverb_send_level.setter
    def manual_reverb_send_level(self, value: float) -> None:
        ...
    @property
    def priority_attenuation_min(self) -> float:
        r"""
        (float):  [Read-Write] Interpolated value to scale priority against when the sound is at the minimum priority attenuation distance from the closest listener.
        """
        ...
    @priority_attenuation_min.setter
    def priority_attenuation_min(self, value: float) -> None:
        ...
    @property
    def priority_attenuation_max(self) -> float:
        r"""
        (float):  [Read-Write] Interpolated value to scale priority against when the sound is at the maximum priority attenuation distance from the closest listener.
        """
        ...
    @priority_attenuation_max.setter
    def priority_attenuation_max(self, value: float) -> None:
        ...
    @property
    def priority_attenuation_distance_min(self) -> float:
        r"""
        (float):  [Read-Write] The min distance to attenuate priority.
        """
        ...
    @priority_attenuation_distance_min.setter
    def priority_attenuation_distance_min(self, value: float) -> None:
        ...
    @property
    def priority_attenuation_distance_max(self) -> float:
        r"""
        (float):  [Read-Write] The max distance to attenuate priority.
        """
        ...
    @priority_attenuation_distance_max.setter
    def priority_attenuation_distance_max(self, value: float) -> None:
        ...
    @property
    def manual_priority_attenuation(self) -> float:
        r"""
        (float):  [Read-Write] Static priority scalar to use (doesn't change as a function of distance).
        """
        ...
    @manual_priority_attenuation.setter
    def manual_priority_attenuation(self, value: float) -> None:
        ...
    @property
    def custom_reverb_send_curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Write] The custom reverb send curve to use for distance-based send level.
        """
        ...
    @custom_reverb_send_curve.setter
    def custom_reverb_send_curve(self, value: RuntimeFloatCurve) -> None:
        ...
    @property
    def submix_send_settings(self) -> Array[AttenuationSubmixSendSettings]:
        r"""
        (Array[AttenuationSubmixSendSettings]):  [Read-Write] Set of submix send settings to use to send audio to submixes as a function of distance.
        """
        ...
    @submix_send_settings.setter
    def submix_send_settings(self, value: Array[AttenuationSubmixSendSettings]) -> None:
        ...
    @property
    def custom_priority_attenuation_curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Write] The custom curve to use for distance-based priority attenuation.
        """
        ...
    @custom_priority_attenuation_curve.setter
    def custom_priority_attenuation_curve(self, value: RuntimeFloatCurve) -> None:
        ...
    @property
    def plugin_settings(self) -> SoundAttenuationPluginSettings:
        r"""
        (SoundAttenuationPluginSettings):  [Read-Write] Sound attenuation plugin settings to use with sounds that play with this attenuation setting.
        """
        ...
    @plugin_settings.setter
    def plugin_settings(self, value: SoundAttenuationPluginSettings) -> None:
        ...

class AttenuationSettings(SoundAttenuationSettings):
    r"""
    deprecated: 'AttenuationSettings' was renamed to 'SoundAttenuationSettings'.
    """
    def __init__(self, distance_algorithm: AttenuationDistanceModel = AttenuationDistanceModel.LINEAR, attenuation_shape: AttenuationShape = AttenuationShape.SPHERE, falloff_mode: NaturalSoundFalloffMode = NaturalSoundFalloffMode.CONTINUES, d_b_attenuation_at_max: float = 0.000000, attenuation_shape_extents: Vector = [0.000000, 0.000000, 0.000000], cone_offset: float = 0.000000, falloff_distance: float = 0.000000, cone_sphere_radius: float = 0.000000, cone_sphere_falloff_distance: float = 0.000000, custom_attenuation_curve: RuntimeFloatCurve = [], attenuate: bool = False, spatialize: bool = False, attenuate_with_lpf: bool = False, enable_listener_focus: bool = False, enable_focus_interpolation: bool = False, enable_occlusion: bool = False, use_complex_collision_for_occlusion: bool = False, enable_reverb_send: bool = False, enable_priority_attenuation: bool = False, apply_normalization_to_stereo_sounds: bool = False, enable_log_frequency_scaling: bool = False, enable_submix_sends: bool = False, enable_source_data_override: bool = False, enable_send_to_audio_link: bool = False, spatialization_algorithm: SoundSpatializationAlgorithm = SoundSpatializationAlgorithm.SPATIALIZATION_DEFAULT, audio_link_settings_override: AudioLinkSettingsAbstract = None, binaural_radius: float = 0.000000, custom_lowpass_air_absorption_curve: RuntimeFloatCurve = [], custom_highpass_air_absorption_curve: RuntimeFloatCurve = [], absorption_method: AirAbsorptionMethod = AirAbsorptionMethod.LINEAR, occlusion_trace_channel: CollisionChannel = CollisionChannel.ECC_WORLD_STATIC, reverb_send_method: ReverbSendMethod = ReverbSendMethod.LINEAR, priority_attenuation_method: PriorityAttenuationMethod = PriorityAttenuationMethod.LINEAR, non_spatialized_radius_start: float = 0.000000, non_spatialized_radius_end: float = 0.000000, non_spatialized_radius_mode: NonSpatializedRadiusSpeakerMapMode = NonSpatializedRadiusSpeakerMapMode.OMNI_DIRECTIONAL, stereo_spread: float = 0.000000, lpf_radius_min: float = 0.000000, lpf_radius_max: float = 0.000000, lpf_frequency_at_min: float = 0.000000, lpf_frequency_at_max: float = 0.000000, hpf_frequency_at_min: float = 0.000000, hpf_frequency_at_max: float = 0.000000, focus_azimuth: float = 0.000000, non_focus_azimuth: float = 0.000000, focus_distance_scale: float = 0.000000, non_focus_distance_scale: float = 0.000000, focus_priority_scale: float = 0.000000, non_focus_priority_scale: float = 0.000000, focus_volume_attenuation: float = 0.000000, non_focus_volume_attenuation: float = 0.000000, focus_attack_interp_speed: float = 0.000000, focus_release_interp_speed: float = 0.000000, occlusion_low_pass_filter_frequency: float = 0.000000, occlusion_volume_attenuation: float = 0.000000, occlusion_interpolation_time: float = 0.000000, reverb_wet_level_min: float = 0.000000, reverb_wet_level_max: float = 0.000000, reverb_distance_min: float = 0.000000, reverb_distance_max: float = 0.000000, manual_reverb_send_level: float = 0.000000, priority_attenuation_min: float = 0.000000, priority_attenuation_max: float = 0.000000, priority_attenuation_distance_min: float = 0.000000, priority_attenuation_distance_max: float = 0.000000, manual_priority_attenuation: float = 0.000000, custom_reverb_send_curve: RuntimeFloatCurve = [], submix_send_settings: Array[AttenuationSubmixSendSettings] = [], custom_priority_attenuation_curve: RuntimeFloatCurve = [], plugin_settings: SoundAttenuationPluginSettings = [[], [], [], []]) -> None:
        ...

class SourceEffectChainEntry(StructBase):
    r"""
    Source Effect Chain Entry
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundEffectSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bypass`` (bool):  [Read-Write]
    - ``preset`` (SoundEffectSourcePreset):  [Read-Write]
    """
    def __init__(self, preset: SoundEffectSourcePreset = None, bypass: bool = False) -> None:
        ...
    @property
    def preset(self) -> SoundEffectSourcePreset:
        r"""
        (SoundEffectSourcePreset):  [Read-Write]
        """
        ...
    @preset.setter
    def preset(self, value: SoundEffectSourcePreset) -> None:
        ...
    @property
    def bypass(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @bypass.setter
    def bypass(self, value: bool) -> None:
        ...

class ModulatorContinuousParams(StructBase):
    r"""
    Modulator Continuous Params
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeModulatorContinuous.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default`` (float):  [Read-Write] The default value to be used if the parameter is not found.
    - ``max_input`` (float):  [Read-Write] The maximum input value. Values will be clamped to the [MinInput, MaxInput] range.
    - ``max_output`` (float):  [Read-Write] The maximum output value. The input value will be scaled from the range [MinInput, MaxInput] to [MinOut, MaxOutput]
    - ``min_input`` (float):  [Read-Write] The minimum input value. Values will be clamped to the [MinInput, MaxInput] range.
    - ``min_output`` (float):  [Read-Write] The minimum output value. The input value will be scaled from the range [MinInput, MaxInput] to [MinOut, MaxOutput]
    - ``param_mode`` (ModulationParamMode):  [Read-Write] The mode with which to treat the input value
    - ``parameter_name`` (Name):  [Read-Write] The name of the sound instance parameter that specifies the current value.
    """
    def __init__(self, parameter_name: Name = "None") -> None:
        ...
    @property
    def parameter_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of the sound instance parameter that specifies the current value.
        """
        ...

class SoundSourceBusSendInfo(StructBase):
    r"""
    Sound Source Bus Send Info
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSourceBusSend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio_bus`` (AudioBus):  [Read-Write] An audio bus to send the audio to. Audio buses can be used to route audio to DSP effects or other purposes. E.g. side-chaining, analysis, etc. Audio buses are not audible unless hooked up to a source bus.
    - ``custom_send_level_curve`` (RuntimeFloatCurve):  [Read-Write] The custom curve to use for distance-based bus send level.
    - ``max_send_distance`` (float):  [Read-Write] The distance at which the max send level is sent to the bus
    - ``max_send_level`` (float):  [Read-Write] The amount to send to the bus when sound is located at a distance equal to value specified in the max send distance.
    - ``min_send_distance`` (float):  [Read-Write] The distance at which the min send Level is sent to the bus
    - ``min_send_level`` (float):  [Read-Write] The amount to send to the bus when sound is located at a distance equal to value specified in the min send distance.
    - ``send_level`` (float):  [Read-Write] The amount of audio to send to the bus.
    - ``sound_source_bus`` (SoundSourceBus):  [Read-Write] A source Bus to send the audio to. Source buses sonify (make audible) the audio sent to it and are themselves sounds which take up a voice slot in the audio engine.
    - ``source_bus_send_level_control_method`` (SourceBusSendLevelControlMethod):  [Read-Write] Manual: Use Send Level only
      Linear: Interpolate between Min and Max Send Levels based on listener distance (between Distance Min and Distance Max)
      Custom Curve: Use the float curve to map Send Level to distance (0.0-1.0 on curve maps to Distance Min - Distance Max)
    """
    def __init__(self, min_send_level: float = 0.000000, max_send_level: float = 0.000000, min_send_distance: float = 0.000000, max_send_distance: float = 0.000000, custom_send_level_curve: RuntimeFloatCurve = []) -> None:
        ...
    @property
    def min_send_level(self) -> float:
        r"""
        (float):  [Read-Write] The amount to send to the bus when sound is located at a distance equal to value specified in the min send distance.
        """
        ...
    @min_send_level.setter
    def min_send_level(self, value: float) -> None:
        ...
    @property
    def max_send_level(self) -> float:
        r"""
        (float):  [Read-Write] The amount to send to the bus when sound is located at a distance equal to value specified in the max send distance.
        """
        ...
    @max_send_level.setter
    def max_send_level(self, value: float) -> None:
        ...
    @property
    def min_send_distance(self) -> float:
        r"""
        (float):  [Read-Write] The distance at which the min send Level is sent to the bus
        """
        ...
    @min_send_distance.setter
    def min_send_distance(self, value: float) -> None:
        ...
    @property
    def max_send_distance(self) -> float:
        r"""
        (float):  [Read-Write] The distance at which the max send level is sent to the bus
        """
        ...
    @max_send_distance.setter
    def max_send_distance(self, value: float) -> None:
        ...
    @property
    def custom_send_level_curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Write] The custom curve to use for distance-based bus send level.
        """
        ...
    @custom_send_level_curve.setter
    def custom_send_level_curve(self, value: RuntimeFloatCurve) -> None:
        ...

class SoundWaveSpectralData(StructBase):
    r"""
    Sound Wave Spectral Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundWave.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frequency_hz`` (float):  [Read-Write] The frequency (in Hz) of the spectrum value
    - ``magnitude`` (float):  [Read-Write] The magnitude of the spectrum at this frequency
    - ``normalized_magnitude`` (float):  [Read-Write] The normalized magnitude of the spectrum at this frequency
    """
    def __init__(self, frequency_hz: float = 0.000000, magnitude: float = 0.000000, normalized_magnitude: float = 0.000000) -> None:
        ...
    @property
    def frequency_hz(self) -> float:
        r"""
        (float):  [Read-Write] The frequency (in Hz) of the spectrum value
        """
        ...
    @frequency_hz.setter
    def frequency_hz(self, value: float) -> None:
        ...
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write] The magnitude of the spectrum at this frequency
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...
    @property
    def normalized_magnitude(self) -> float:
        r"""
        (float):  [Read-Write] The normalized magnitude of the spectrum at this frequency
        """
        ...
    @normalized_magnitude.setter
    def normalized_magnitude(self, value: float) -> None:
        ...

class SoundWaveSpectralDataPerSound(StructBase):
    r"""
    Sound Wave Spectral Data Per Sound
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundWave.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``playback_time`` (float):  [Read-Write] The current playback time of this sound wave
    - ``sound_wave`` (SoundWave):  [Read-Write] The sound wave this spectral data is associated with
    - ``spectral_data`` (Array[SoundWaveSpectralData]):  [Read-Write] The array of current spectral data for this sound wave
    """
    def __init__(self, spectral_data: Array[SoundWaveSpectralData] = [], playback_time: float = 0.000000, sound_wave: SoundWave = None) -> None:
        ...
    @property
    def spectral_data(self) -> Array[SoundWaveSpectralData]:
        r"""
        (Array[SoundWaveSpectralData]):  [Read-Write] The array of current spectral data for this sound wave
        """
        ...
    @spectral_data.setter
    def spectral_data(self, value: Array[SoundWaveSpectralData]) -> None:
        ...
    @property
    def playback_time(self) -> float:
        r"""
        (float):  [Read-Write] The current playback time of this sound wave
        """
        ...
    @playback_time.setter
    def playback_time(self, value: float) -> None:
        ...
    @property
    def sound_wave(self) -> SoundWave:
        r"""
        (SoundWave):  [Read-Write] The sound wave this spectral data is associated with
        """
        ...
    @sound_wave.setter
    def sound_wave(self, value: SoundWave) -> None:
        ...

class SoundWaveEnvelopeDataPerSound(StructBase):
    r"""
    Sound Wave Envelope Data Per Sound
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundWave.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``envelope`` (float):  [Read-Write] The current envelope of the playing sound
    - ``playback_time`` (float):  [Read-Write] The current playback time of this sound wave
    - ``sound_wave`` (SoundWave):  [Read-Write] The sound wave this envelope data is associated with
    """
    def __init__(self, envelope: float = 0.000000, playback_time: float = 0.000000, sound_wave: SoundWave = None) -> None:
        ...
    @property
    def envelope(self) -> float:
        r"""
        (float):  [Read-Write] The current envelope of the playing sound
        """
        ...
    @envelope.setter
    def envelope(self, value: float) -> None:
        ...
    @property
    def playback_time(self) -> float:
        r"""
        (float):  [Read-Write] The current playback time of this sound wave
        """
        ...
    @playback_time.setter
    def playback_time(self, value: float) -> None:
        ...
    @property
    def sound_wave(self) -> SoundWave:
        r"""
        (SoundWave):  [Read-Write] The sound wave this envelope data is associated with
        """
        ...
    @sound_wave.setter
    def sound_wave(self, value: SoundWave) -> None:
        ...

class SoundWaveCuePoint(StructBase):
    r"""
    Struct defining a cue point in a sound wave asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundWave.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cue_point_id`` (int32):  [Read-Only] Unique identifier for the wave cue point
    - ``frame_length`` (int32):  [Read-Only] The frame length of the cue point (non-zero if it's a region)
    - ``frame_position`` (int32):  [Read-Only] The frame position of the cue point
    - ``is_loop_region`` (bool):  [Read-Only] intentionally kept private.
      only USoundFactory should modify this value on import
    - ``label`` (str):  [Read-Only] The label for the cue point
    """
    def __init__(self, cue_point_id: int = 0, label: str = "", frame_position: int = 0, frame_length: int = 0) -> None:
        ...
    @property
    def cue_point_id(self) -> int:
        r"""
        (int32):  [Read-Only] Unique identifier for the wave cue point
        """
        ...
    @property
    def label(self) -> str:
        r"""
        (str):  [Read-Only] The label for the cue point
        """
        ...
    @property
    def frame_position(self) -> int:
        r"""
        (int32):  [Read-Only] The frame position of the cue point
        """
        ...
    @property
    def frame_length(self) -> int:
        r"""
        (int32):  [Read-Only] The frame length of the cue point (non-zero if it's a region)
        """
        ...

class EquirectProps(StructBase):
    r"""
    Properties for equirect layers
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StereoLayerComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``left_bias`` (Vector2D):  [Read-Write] Left eye's texture coordinate bias after mapping to 2D.
    - ``left_scale`` (Vector2D):  [Read-Write] Left eye's texture coordinate scale after mapping to 2D.
    - ``left_uv_rect`` (Box2D):  [Read-Write] Left source texture UVRect, specifying portion of input texture corresponding to left eye.
    - ``radius`` (float):  [Read-Write] Sphere radius. As of UE 5.3, equirect layers are supported only by the Oculus OpenXR runtime and only with a radius of 0 (infinite sphere).
    - ``right_bias`` (Vector2D):  [Read-Write] Right eye's texture coordinate bias after mapping to 2D.
    - ``right_scale`` (Vector2D):  [Read-Write] Right eye's texture coordinate scale after mapping to 2D.
    - ``right_uv_rect`` (Box2D):  [Read-Write] Right source texture UVRect, specifying portion of input texture corresponding to right eye.
    """
    def __init__(self, left_uv_rect: Box2D = [[0.000000, 0.000000], [0.000000, 0.000000], False], right_uv_rect: Box2D = [[0.000000, 0.000000], [0.000000, 0.000000], False], left_scale: Vector2D = [0.000000, 0.000000], right_scale: Vector2D = [0.000000, 0.000000], left_bias: Vector2D = [0.000000, 0.000000], right_bias: Vector2D = [0.000000, 0.000000], radius: float = 0.000000) -> None:
        ...
    @property
    def left_uv_rect(self) -> Box2D:
        r"""
        (Box2D):  [Read-Only] Left source texture UVRect, specifying portion of input texture corresponding to left eye.
        """
        ...
    @property
    def right_uv_rect(self) -> Box2D:
        r"""
        (Box2D):  [Read-Only] Right source texture UVRect, specifying portion of input texture corresponding to right eye.
        """
        ...
    @property
    def left_scale(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] Left eye's texture coordinate scale after mapping to 2D.
        """
        ...
    @property
    def right_scale(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] Right eye's texture coordinate scale after mapping to 2D.
        """
        ...
    @property
    def left_bias(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] Left eye's texture coordinate bias after mapping to 2D.
        """
        ...
    @property
    def right_bias(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] Right eye's texture coordinate bias after mapping to 2D.
        """
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Only] Sphere radius. As of UE 5.3, equirect layers are supported only by the Oculus OpenXR runtime and only with a radius of 0 (infinite sphere).
        """
        ...

class LightmassWorldInfoSettings(StructBase):
    r"""
    Lightmass World Info Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``compress_lightmaps`` (bool):  [Read-Write] Whether to compress lightmap textures.  Disabling lightmap texture compression will reduce artifacts but increase memory and disk size by 4x.
      Use caution when disabling this.
    - ``diffuse_boost`` (float):  [Read-Write] Scales the diffuse contribution of all materials in the scene.
    - ``direct_illumination_occlusion_fraction`` (float):  [Read-Write] How much of the AO to apply to direct lighting.
    - ``environment_color`` (Color):  [Read-Write] Represents a constant color light surrounding the upper hemisphere of the level, like a sky.
      This light source currently does not get bounced as indirect lighting and causes reflection capture brightness to be incorrect.  Prefer using a Static Skylight instead.
    - ``environment_intensity`` (float):  [Read-Write] Scales EnvironmentColor to allow independent color and brightness controls.
    - ``fully_occluded_samples_fraction`` (float):  [Read-Write] Fraction of samples taken that must be occluded in order to reach full occlusion.
    - ``generate_ambient_occlusion_material_mask`` (bool):  [Read-Write] Whether to generate textures storing the AO computed by Lightmass.
      These can be accessed through the PrecomputedAOMask material node,
      Which is useful for blending between material layers on environment assets.
      Be sure to set DirectIlluminationOcclusionFraction and IndirectIlluminationOcclusionFraction to 0 if you only want the PrecomputedAOMask!
    - ``indirect_illumination_occlusion_fraction`` (float):  [Read-Write] How much of the AO to apply to indirect lighting.
    - ``indirect_lighting_quality`` (float):  [Read-Write] Warning: Setting this higher than 1 will greatly increase build times!
      Can be used to increase the GI solver sample counts in order to get higher quality for levels that need it.
      It can be useful to reduce IndirectLightingSmoothness somewhat (~.75) when increasing quality to get defined indirect shadows.
      Note that this can't affect compression artifacts, UV seams or other texture based artifacts.
    - ``indirect_lighting_smoothness`` (float):  [Read-Write] Smoothness factor to apply to indirect lighting.  This is useful in some lighting conditions when Lightmass cannot resolve accurate indirect lighting.
      1 is default smoothness tweaked for a variety of lighting situations.
      Higher values like 3 smooth out the indirect lighting more, but at the cost of indirect shadows losing detail.
    - ``max_occlusion_distance`` (float):  [Read-Write] Maximum distance for an object to cause occlusion on another object.
    - ``num_indirect_lighting_bounces`` (int32):  [Read-Write] Number of light bounces to simulate for point / spot / directional lights, starting from the light source.
      0 is direct lighting only, 1 is one bounce, etc.
      Bounce 1 takes the most time to calculate and contributes the most to visual quality, followed by bounce 2.
      Successive bounces don't really affect build times, but have a much lower visual impact, unless the material diffuse colors are close to 1.
    - ``num_sky_lighting_bounces`` (int32):  [Read-Write] Number of skylight and emissive bounces to simulate.
      Lightmass uses a non-distributable radiosity method for skylight bounces whose cost is proportional to the number of bounces.
    - ``occlusion_exponent`` (float):  [Read-Write] Higher exponents increase contrast.
    - ``static_lighting_level_scale`` (float):  [Read-Write] Warning: Setting this to less than 1 will greatly increase build times!
      Scale of the level relative to real world scale (1 Unreal Unit = 1 cm).
      All scale-dependent Lightmass setting defaults have been tweaked to work well with real world scale,
      Any levels with a different scale should use this scale to compensate.
      For large levels it can drastically reduce build times to set this to 2 or 4.
    - ``use_ambient_occlusion`` (bool):  [Read-Write] If true, AmbientOcclusion will be enabled.
    - ``visualize_ambient_occlusion`` (bool):  [Read-Write] If true, override normal direct and indirect lighting with just the AO term.
    - ``visualize_material_diffuse`` (bool):  [Read-Write] If true, override normal direct and indirect lighting with just the exported diffuse term.
    - ``volume_light_sample_placement_scale`` (float):  [Read-Write] Scales the distances at which volume lighting samples are placed.  Volume lighting samples are computed by Lightmass and are used for GI on movable components.
      Using larger scales results in less sample memory usage and reduces Indirect Lighting Cache update times, but less accurate transitions between lighting areas.
    - ``volume_lighting_method`` (VolumeLightingMethod):  [Read-Write] Technique to use for providing precomputed lighting at all positions inside the Lightmass Importance Volume
    - ``volumetric_lightmap_detail_cell_size`` (float):  [Read-Write] Size of an Volumetric Lightmap voxel at the highest density (used around geometry), in world space units.
      This setting has a large impact on build times and memory, use with caution.
      Halving the DetailCellSize can increase memory by up to a factor of 8x.
    - ``volumetric_lightmap_maximum_brick_memory_mb`` (float):  [Read-Write] Maximum amount of memory to spend on Volumetric Lightmap Brick data.  High density bricks will be discarded until this limit is met, with bricks furthest from geometry discarded first.
    - ``volumetric_lightmap_spherical_harmonic_smoothing`` (float):  [Read-Write] Controls how much smoothing should be done to Volumetric Lightmap samples during Spherical Harmonic de-ringing.
      Whenever highly directional lighting is stored in a Spherical Harmonic, a ringing artifact occurs which manifests as unexpected black areas on the opposite side.
      Smoothing can reduce this artifact.  Smoothing is only applied when the ringing artifact is present.
      0 = no smoothing, 1 = strong smooth (little directionality in lighting).
    """
    def __init__(self, static_lighting_level_scale: float = 0.000000, num_indirect_lighting_bounces: int = 0, num_sky_lighting_bounces: int = 0, indirect_lighting_quality: float = 0.000000, indirect_lighting_smoothness: float = 0.000000, environment_color: Color = [0, 0, 0, 0], environment_intensity: float = 0.000000, diffuse_boost: float = 0.000000, volume_lighting_method: VolumeLightingMethod = VolumeLightingMethod.VLM_VOLUMETRIC_LIGHTMAP, use_ambient_occlusion: bool = False, generate_ambient_occlusion_material_mask: bool = False, visualize_material_diffuse: bool = False, visualize_ambient_occlusion: bool = False, compress_lightmaps: bool = False, volumetric_lightmap_detail_cell_size: float = 0.000000, volumetric_lightmap_maximum_brick_memory_mb: float = 0.000000, volumetric_lightmap_spherical_harmonic_smoothing: float = 0.000000, volume_light_sample_placement_scale: float = 0.000000, direct_illumination_occlusion_fraction: float = 0.000000, indirect_illumination_occlusion_fraction: float = 0.000000, occlusion_exponent: float = 0.000000, fully_occluded_samples_fraction: float = 0.000000, max_occlusion_distance: float = 0.000000) -> None:
        ...
    @property
    def static_lighting_level_scale(self) -> float:
        r"""
        (float):  [Read-Write] Warning: Setting this to less than 1 will greatly increase build times!
        Scale of the level relative to real world scale (1 Unreal Unit = 1 cm).
        All scale-dependent Lightmass setting defaults have been tweaked to work well with real world scale,
        Any levels with a different scale should use this scale to compensate.
        For large levels it can drastically reduce build times to set this to 2 or 4.
        """
        ...
    @static_lighting_level_scale.setter
    def static_lighting_level_scale(self, value: float) -> None:
        ...
    @property
    def num_indirect_lighting_bounces(self) -> int:
        r"""
        (int32):  [Read-Write] Number of light bounces to simulate for point / spot / directional lights, starting from the light source.
        0 is direct lighting only, 1 is one bounce, etc.
        Bounce 1 takes the most time to calculate and contributes the most to visual quality, followed by bounce 2.
        Successive bounces don't really affect build times, but have a much lower visual impact, unless the material diffuse colors are close to 1.
        """
        ...
    @num_indirect_lighting_bounces.setter
    def num_indirect_lighting_bounces(self, value: int) -> None:
        ...
    @property
    def num_sky_lighting_bounces(self) -> int:
        r"""
        (int32):  [Read-Write] Number of skylight and emissive bounces to simulate.
        Lightmass uses a non-distributable radiosity method for skylight bounces whose cost is proportional to the number of bounces.
        """
        ...
    @num_sky_lighting_bounces.setter
    def num_sky_lighting_bounces(self, value: int) -> None:
        ...
    @property
    def indirect_lighting_quality(self) -> float:
        r"""
        (float):  [Read-Write] Warning: Setting this higher than 1 will greatly increase build times!
        Can be used to increase the GI solver sample counts in order to get higher quality for levels that need it.
        It can be useful to reduce IndirectLightingSmoothness somewhat (~.75) when increasing quality to get defined indirect shadows.
        Note that this can't affect compression artifacts, UV seams or other texture based artifacts.
        """
        ...
    @indirect_lighting_quality.setter
    def indirect_lighting_quality(self, value: float) -> None:
        ...
    @property
    def indirect_lighting_smoothness(self) -> float:
        r"""
        (float):  [Read-Write] Smoothness factor to apply to indirect lighting.  This is useful in some lighting conditions when Lightmass cannot resolve accurate indirect lighting.
        1 is default smoothness tweaked for a variety of lighting situations.
        Higher values like 3 smooth out the indirect lighting more, but at the cost of indirect shadows losing detail.
        """
        ...
    @indirect_lighting_smoothness.setter
    def indirect_lighting_smoothness(self, value: float) -> None:
        ...
    @property
    def environment_color(self) -> Color:
        r"""
        (Color):  [Read-Write] Represents a constant color light surrounding the upper hemisphere of the level, like a sky.
        This light source currently does not get bounced as indirect lighting and causes reflection capture brightness to be incorrect.  Prefer using a Static Skylight instead.
        """
        ...
    @environment_color.setter
    def environment_color(self, value: Color) -> None:
        ...
    @property
    def environment_intensity(self) -> float:
        r"""
        (float):  [Read-Write] Scales EnvironmentColor to allow independent color and brightness controls.
        """
        ...
    @environment_intensity.setter
    def environment_intensity(self, value: float) -> None:
        ...
    @property
    def diffuse_boost(self) -> float:
        r"""
        (float):  [Read-Write] Scales the diffuse contribution of all materials in the scene.
        """
        ...
    @diffuse_boost.setter
    def diffuse_boost(self, value: float) -> None:
        ...
    @property
    def volume_lighting_method(self) -> VolumeLightingMethod:
        r"""
        (VolumeLightingMethod):  [Read-Write] Technique to use for providing precomputed lighting at all positions inside the Lightmass Importance Volume
        """
        ...
    @volume_lighting_method.setter
    def volume_lighting_method(self, value: VolumeLightingMethod) -> None:
        ...
    @property
    def use_ambient_occlusion(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, AmbientOcclusion will be enabled.
        """
        ...
    @use_ambient_occlusion.setter
    def use_ambient_occlusion(self, value: bool) -> None:
        ...
    @property
    def generate_ambient_occlusion_material_mask(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate textures storing the AO computed by Lightmass.
        These can be accessed through the PrecomputedAOMask material node,
        Which is useful for blending between material layers on environment assets.
        Be sure to set DirectIlluminationOcclusionFraction and IndirectIlluminationOcclusionFraction to 0 if you only want the PrecomputedAOMask!
        """
        ...
    @generate_ambient_occlusion_material_mask.setter
    def generate_ambient_occlusion_material_mask(self, value: bool) -> None:
        ...
    @property
    def visualize_material_diffuse(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, override normal direct and indirect lighting with just the exported diffuse term.
        """
        ...
    @visualize_material_diffuse.setter
    def visualize_material_diffuse(self, value: bool) -> None:
        ...
    @property
    def visualize_ambient_occlusion(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, override normal direct and indirect lighting with just the AO term.
        """
        ...
    @visualize_ambient_occlusion.setter
    def visualize_ambient_occlusion(self, value: bool) -> None:
        ...
    @property
    def compress_lightmaps(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to compress lightmap textures.  Disabling lightmap texture compression will reduce artifacts but increase memory and disk size by 4x.
        Use caution when disabling this.
        """
        ...
    @compress_lightmaps.setter
    def compress_lightmaps(self, value: bool) -> None:
        ...
    @property
    def volumetric_lightmap_detail_cell_size(self) -> float:
        r"""
        (float):  [Read-Write] Size of an Volumetric Lightmap voxel at the highest density (used around geometry), in world space units.
        This setting has a large impact on build times and memory, use with caution.
        Halving the DetailCellSize can increase memory by up to a factor of 8x.
        """
        ...
    @volumetric_lightmap_detail_cell_size.setter
    def volumetric_lightmap_detail_cell_size(self, value: float) -> None:
        ...
    @property
    def volumetric_lightmap_maximum_brick_memory_mb(self) -> float:
        r"""
        (float):  [Read-Write] Maximum amount of memory to spend on Volumetric Lightmap Brick data.  High density bricks will be discarded until this limit is met, with bricks furthest from geometry discarded first.
        """
        ...
    @volumetric_lightmap_maximum_brick_memory_mb.setter
    def volumetric_lightmap_maximum_brick_memory_mb(self, value: float) -> None:
        ...
    @property
    def volumetric_lightmap_spherical_harmonic_smoothing(self) -> float:
        r"""
        (float):  [Read-Write] Controls how much smoothing should be done to Volumetric Lightmap samples during Spherical Harmonic de-ringing.
        Whenever highly directional lighting is stored in a Spherical Harmonic, a ringing artifact occurs which manifests as unexpected black areas on the opposite side.
        Smoothing can reduce this artifact.  Smoothing is only applied when the ringing artifact is present.
        0 = no smoothing, 1 = strong smooth (little directionality in lighting).
        """
        ...
    @volumetric_lightmap_spherical_harmonic_smoothing.setter
    def volumetric_lightmap_spherical_harmonic_smoothing(self, value: float) -> None:
        ...
    @property
    def volume_light_sample_placement_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scales the distances at which volume lighting samples are placed.  Volume lighting samples are computed by Lightmass and are used for GI on movable components.
        Using larger scales results in less sample memory usage and reduces Indirect Lighting Cache update times, but less accurate transitions between lighting areas.
        """
        ...
    @volume_light_sample_placement_scale.setter
    def volume_light_sample_placement_scale(self, value: float) -> None:
        ...
    @property
    def direct_illumination_occlusion_fraction(self) -> float:
        r"""
        (float):  [Read-Write] How much of the AO to apply to direct lighting.
        """
        ...
    @direct_illumination_occlusion_fraction.setter
    def direct_illumination_occlusion_fraction(self, value: float) -> None:
        ...
    @property
    def indirect_illumination_occlusion_fraction(self) -> float:
        r"""
        (float):  [Read-Write] How much of the AO to apply to indirect lighting.
        """
        ...
    @indirect_illumination_occlusion_fraction.setter
    def indirect_illumination_occlusion_fraction(self, value: float) -> None:
        ...
    @property
    def occlusion_exponent(self) -> float:
        r"""
        (float):  [Read-Write] Higher exponents increase contrast.
        """
        ...
    @occlusion_exponent.setter
    def occlusion_exponent(self, value: float) -> None:
        ...
    @property
    def fully_occluded_samples_fraction(self) -> float:
        r"""
        (float):  [Read-Write] Fraction of samples taken that must be occluded in order to reach full occlusion.
        """
        ...
    @fully_occluded_samples_fraction.setter
    def fully_occluded_samples_fraction(self, value: float) -> None:
        ...
    @property
    def max_occlusion_distance(self) -> float:
        r"""
        (float):  [Read-Write] Maximum distance for an object to cause occlusion on another object.
        """
        ...
    @max_occlusion_distance.setter
    def max_occlusion_distance(self, value: float) -> None:
        ...

class MeshApproximationSettings(StructBase):
    r"""
    Mesh Approximation Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_distance_field`` (bool):  [Read-Write] Whether to allow distance field to be computed for this mesh. Disable this to save memory if the generated mesh will only be rendered in the distance.
    - ``approximation_accuracy`` (float):  [Read-Write] Approximation Accuracy in Meters, will determine (eg) voxel resolution
    - ``attempt_auto_thickening`` (bool):  [Read-Write] if enabled, we will attempt to auto-thicken thin parts or flat sheets
    - ``base_capping`` (MeshApproximationBaseCappingType):  [Read-Write] Optional methods to attempt to close off the bottom of open meshes
    - ``capture_field_of_view`` (float):  [Read-Write]
    - ``clamp_voxel_dimension`` (int32):  [Read-Write] Maximum allowable voxel count along main directions. This is a limit on ApproximationAccuracy. Max of 1290 (1290^3 is the last integer < 2^31, using a bigger number results in failures in TArray code & probably elsewhere)
    - ``curvature_alignment`` (float):  [Read-Write] This parameter controls alignment of the initial patches to creases in the mesh
    - ``emit_full_debug_mesh`` (bool):  [Read-Write] If true, write the full mesh triangle set (ie flattened, non-instanced) used for mesh generation. Warning: this asset may be extremely large!!
    - ``enable_parallel_baking`` (bool):  [Read-Write] If false, texture capture and baking will be done serially after mesh generation, rather than in parallel when possible. This will reduce the maximum memory requirements of the process.
    - ``enable_simplify_pre_pass`` (bool):  [Read-Write] If true, a faster mesh simplfication strategy will be used. This can significantly reduce computation time and memory usage, but potentially at the cost of lower quality output.
    - ``estimate_hard_normals`` (bool):  [Read-Write] If true, normal angle will be used to estimate hard normals
    - ``fill_gaps`` (bool):  [Read-Write] If true, topological expand/contract is used to try to fill small gaps between objects.
    - ``gap_distance`` (float):  [Read-Write] Distance in Meters to expand/contract to fill gaps
    - ``generate_nanite_enabled_mesh`` (bool):  [Read-Write] Whether to generate a nanite-enabled mesh
    - ``geometric_deviation`` (float):  [Read-Write] Allowable Geometric Deviation in Meters when SimplifyMethod incorporates a Geometric Tolerance
    - ``ground_clipping`` (MeshApproximationGroundPlaneClippingPolicy):  [Read-Write] Configure how the final mesh should be clipped with a ground plane, if desired
    - ``ground_clipping_z_height`` (float):  [Read-Write] Z-Height for the ground clipping plane, if enabled
    - ``hard_normal_angle`` (float):  [Read-Write]
    - ``ignore_tiny_parts`` (bool):  [Read-Write] If enabled, tiny parts will be excluded from the mesh merging, which can improve performance
    - ``initial_patch_count`` (int32):  [Read-Write] Number of initial patches mesh will be split into before computing island merging
    - ``material_settings`` (MaterialProxySettings):  [Read-Write] Material generation settings
    - ``max_angle_deviation`` (float):  [Read-Write] UV islands will not be merged if their average face normals deviate by larger than this amount
    - ``merging_threshold`` (float):  [Read-Write] Distortion/Stretching Threshold for island merging - larger values increase the allowable UV stretching
    - ``multi_sampling_aa`` (int32):  [Read-Write] If Value is > 1, Multisample output baked textures by this amount in each direction (eg 4 == 16x supersampling)
    - ``nanite_fallback_percent_triangles`` (float):  [Read-Write] Percentage of triangles to keep from source Nanite mesh for fallback. 1.0 = no reduction, 0.0 = no triangles.
    - ``nanite_fallback_relative_error`` (float):  [Read-Write] Reduce Nanite fallback mesh until at least this amount of error is reached relative to size of the mesh.
    - ``nanite_fallback_target`` (NaniteFallbackTarget):  [Read-Write] Which heuristic to use when generating the Nanite fallback mesh.
    - ``near_plane_dist`` (float):  [Read-Write]
    - ``occlude_from_bottom`` (bool):  [Read-Write] If true, then the OcclusionMethod computation is configured to try to consider downward-facing "bottom" geometry as occluded
    - ``occlusion_method`` (OccludedGeometryFilteringPolicy):  [Read-Write] Type of hidden geometry removal to apply
    - ``output_type`` (MeshApproximationType):  [Read-Write] Type of output from mesh approximation process
    - ``print_debug_messages`` (bool):  [Read-Write] If true, print out debugging messages
    - ``render_capture_resolution`` (int32):  [Read-Write] If Value is zero, use MaterialSettings resolution, otherwise override the render capture resolution
    - ``simplify_method`` (MeshApproximationSimplificationPolicy):  [Read-Write] Mesh Simplification criteria
    - ``support_ray_tracing`` (bool):  [Read-Write] Whether ray tracing will be supported on this mesh. Disable this to save memory if the generated mesh will only be rendered in the distance.
    - ``target_min_thickness_multiplier`` (float):  [Read-Write] Multiplier on Approximation Accuracy used for auto-thickening
    - ``target_tri_count`` (int32):  [Read-Write] Target triangle count for Mesh Simplification, for SimplifyMethods that use a Count
    - ``tiny_part_size_multiplier`` (float):  [Read-Write] Multiplier on Approximation Accuracy used to define tiny-part threshold, using maximum bounding-box dimension
    - ``triangles_per_m`` (float):  [Read-Write] Approximate Number of triangles per Square Meter, for SimplifyMethods that use such a constraint
    - ``use_render_lod_meshes`` (bool):  [Read-Write] If true, LOD0 Render Meshes (or Nanite Fallback meshes) are used instead of Source Mesh data. This can significantly reduce computation time and memory usage, but potentially at the cost of lower quality output.
    - ``uv_generation_method`` (MeshApproximationUVGenerationPolicy):  [Read-Write] Mesh UV Generation Settings
    - ``winding_threshold`` (float):  [Read-Write] Winding Threshold controls hole filling at open mesh borders. Smaller value means "more/rounder" filling
    """
    def __init__(self, output_type: MeshApproximationType = MeshApproximationType.MESH_AND_MATERIALS, approximation_accuracy: float = 0.000000, clamp_voxel_dimension: int = 0, attempt_auto_thickening: bool = False, target_min_thickness_multiplier: float = 0.000000, ignore_tiny_parts: bool = False, tiny_part_size_multiplier: float = 0.000000, base_capping: MeshApproximationBaseCappingType = MeshApproximationBaseCappingType.NO_BASE_CAPPING, winding_threshold: float = 0.000000, fill_gaps: bool = False, gap_distance: float = 0.000000, occlusion_method: OccludedGeometryFilteringPolicy = OccludedGeometryFilteringPolicy.NO_OCCLUSION_FILTERING, occlude_from_bottom: bool = False, simplify_method: MeshApproximationSimplificationPolicy = MeshApproximationSimplificationPolicy.FIXED_TRIANGLE_COUNT, target_tri_count: int = 0, triangles_per_m: float = 0.000000, geometric_deviation: float = 0.000000, ground_clipping: MeshApproximationGroundPlaneClippingPolicy = MeshApproximationGroundPlaneClippingPolicy.NO_GROUND_CLIPPING, ground_clipping_z_height: float = 0.000000, estimate_hard_normals: bool = False, hard_normal_angle: float = 0.000000, uv_generation_method: MeshApproximationUVGenerationPolicy = MeshApproximationUVGenerationPolicy.PREFER_UV_ATLAS, initial_patch_count: int = 0, curvature_alignment: float = 0.000000, merging_threshold: float = 0.000000, max_angle_deviation: float = 0.000000, generate_nanite_enabled_mesh: bool = False, nanite_fallback_target: NaniteFallbackTarget = NaniteFallbackTarget.AUTO, nanite_fallback_percent_triangles: float = 0.000000, nanite_fallback_relative_error: float = 0.000000, support_ray_tracing: bool = False, allow_distance_field: bool = False, multi_sampling_aa: int = 0, render_capture_resolution: int = 0, material_settings: MaterialProxySettings = [TextureSizingType.TEXTURE_SIZING_TYPE_USE_SINGLE_TEXTURE_SIZE, 5.000000, 0.500000, 10000.000000, 4.000000, 0.000000, 0.500000, 0.000000, 0.500000, 1.000000, 1.000000, 1.000000, BlendMode.BLEND_OPAQUE, True, True, False, False, False, False, False, False, False, False, False, [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024]], capture_field_of_view: float = 0.000000, near_plane_dist: float = 0.000000, use_render_lod_meshes: bool = False, enable_simplify_pre_pass: bool = False, enable_parallel_baking: bool = False, print_debug_messages: bool = False, emit_full_debug_mesh: bool = False) -> None:
        ...
    @property
    def output_type(self) -> MeshApproximationType:
        r"""
        (MeshApproximationType):  [Read-Write] Type of output from mesh approximation process
        """
        ...
    @output_type.setter
    def output_type(self, value: MeshApproximationType) -> None:
        ...
    @property
    def approximation_accuracy(self) -> float:
        r"""
        (float):  [Read-Write] Approximation Accuracy in Meters, will determine (eg) voxel resolution
        """
        ...
    @approximation_accuracy.setter
    def approximation_accuracy(self, value: float) -> None:
        ...
    @property
    def clamp_voxel_dimension(self) -> int:
        r"""
        (int32):  [Read-Write] Maximum allowable voxel count along main directions. This is a limit on ApproximationAccuracy. Max of 1290 (1290^3 is the last integer < 2^31, using a bigger number results in failures in TArray code & probably elsewhere)
        """
        ...
    @clamp_voxel_dimension.setter
    def clamp_voxel_dimension(self, value: int) -> None:
        ...
    @property
    def attempt_auto_thickening(self) -> bool:
        r"""
        (bool):  [Read-Write] if enabled, we will attempt to auto-thicken thin parts or flat sheets
        """
        ...
    @attempt_auto_thickening.setter
    def attempt_auto_thickening(self, value: bool) -> None:
        ...
    @property
    def target_min_thickness_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Multiplier on Approximation Accuracy used for auto-thickening
        """
        ...
    @target_min_thickness_multiplier.setter
    def target_min_thickness_multiplier(self, value: float) -> None:
        ...
    @property
    def ignore_tiny_parts(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, tiny parts will be excluded from the mesh merging, which can improve performance
        """
        ...
    @ignore_tiny_parts.setter
    def ignore_tiny_parts(self, value: bool) -> None:
        ...
    @property
    def tiny_part_size_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Multiplier on Approximation Accuracy used to define tiny-part threshold, using maximum bounding-box dimension
        """
        ...
    @tiny_part_size_multiplier.setter
    def tiny_part_size_multiplier(self, value: float) -> None:
        ...
    @property
    def base_capping(self) -> MeshApproximationBaseCappingType:
        r"""
        (MeshApproximationBaseCappingType):  [Read-Write] Optional methods to attempt to close off the bottom of open meshes
        """
        ...
    @base_capping.setter
    def base_capping(self, value: MeshApproximationBaseCappingType) -> None:
        ...
    @property
    def winding_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Winding Threshold controls hole filling at open mesh borders. Smaller value means "more/rounder" filling
        """
        ...
    @winding_threshold.setter
    def winding_threshold(self, value: float) -> None:
        ...
    @property
    def fill_gaps(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, topological expand/contract is used to try to fill small gaps between objects.
        """
        ...
    @fill_gaps.setter
    def fill_gaps(self, value: bool) -> None:
        ...
    @property
    def gap_distance(self) -> float:
        r"""
        (float):  [Read-Write] Distance in Meters to expand/contract to fill gaps
        """
        ...
    @gap_distance.setter
    def gap_distance(self, value: float) -> None:
        ...
    @property
    def occlusion_method(self) -> OccludedGeometryFilteringPolicy:
        r"""
        (OccludedGeometryFilteringPolicy):  [Read-Write] Type of hidden geometry removal to apply
        """
        ...
    @occlusion_method.setter
    def occlusion_method(self, value: OccludedGeometryFilteringPolicy) -> None:
        ...
    @property
    def occlude_from_bottom(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, then the OcclusionMethod computation is configured to try to consider downward-facing "bottom" geometry as occluded
        """
        ...
    @occlude_from_bottom.setter
    def occlude_from_bottom(self, value: bool) -> None:
        ...
    @property
    def simplify_method(self) -> MeshApproximationSimplificationPolicy:
        r"""
        (MeshApproximationSimplificationPolicy):  [Read-Write] Mesh Simplification criteria
        """
        ...
    @simplify_method.setter
    def simplify_method(self, value: MeshApproximationSimplificationPolicy) -> None:
        ...
    @property
    def target_tri_count(self) -> int:
        r"""
        (int32):  [Read-Write] Target triangle count for Mesh Simplification, for SimplifyMethods that use a Count
        """
        ...
    @target_tri_count.setter
    def target_tri_count(self, value: int) -> None:
        ...
    @property
    def triangles_per_m(self) -> float:
        r"""
        (float):  [Read-Write] Approximate Number of triangles per Square Meter, for SimplifyMethods that use such a constraint
        """
        ...
    @triangles_per_m.setter
    def triangles_per_m(self, value: float) -> None:
        ...
    @property
    def geometric_deviation(self) -> float:
        r"""
        (float):  [Read-Write] Allowable Geometric Deviation in Meters when SimplifyMethod incorporates a Geometric Tolerance
        """
        ...
    @geometric_deviation.setter
    def geometric_deviation(self, value: float) -> None:
        ...
    @property
    def ground_clipping(self) -> MeshApproximationGroundPlaneClippingPolicy:
        r"""
        (MeshApproximationGroundPlaneClippingPolicy):  [Read-Write] Configure how the final mesh should be clipped with a ground plane, if desired
        """
        ...
    @ground_clipping.setter
    def ground_clipping(self, value: MeshApproximationGroundPlaneClippingPolicy) -> None:
        ...
    @property
    def ground_clipping_z_height(self) -> float:
        r"""
        (float):  [Read-Write] Z-Height for the ground clipping plane, if enabled
        """
        ...
    @ground_clipping_z_height.setter
    def ground_clipping_z_height(self, value: float) -> None:
        ...
    @property
    def estimate_hard_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, normal angle will be used to estimate hard normals
        """
        ...
    @estimate_hard_normals.setter
    def estimate_hard_normals(self, value: bool) -> None:
        ...
    @property
    def hard_normal_angle(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @hard_normal_angle.setter
    def hard_normal_angle(self, value: float) -> None:
        ...
    @property
    def uv_generation_method(self) -> MeshApproximationUVGenerationPolicy:
        r"""
        (MeshApproximationUVGenerationPolicy):  [Read-Write] Mesh UV Generation Settings
        """
        ...
    @uv_generation_method.setter
    def uv_generation_method(self, value: MeshApproximationUVGenerationPolicy) -> None:
        ...
    @property
    def initial_patch_count(self) -> int:
        r"""
        (int32):  [Read-Write] Number of initial patches mesh will be split into before computing island merging
        """
        ...
    @initial_patch_count.setter
    def initial_patch_count(self, value: int) -> None:
        ...
    @property
    def curvature_alignment(self) -> float:
        r"""
        (float):  [Read-Write] This parameter controls alignment of the initial patches to creases in the mesh
        """
        ...
    @curvature_alignment.setter
    def curvature_alignment(self, value: float) -> None:
        ...
    @property
    def merging_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Distortion/Stretching Threshold for island merging - larger values increase the allowable UV stretching
        """
        ...
    @merging_threshold.setter
    def merging_threshold(self, value: float) -> None:
        ...
    @property
    def max_angle_deviation(self) -> float:
        r"""
        (float):  [Read-Write] UV islands will not be merged if their average face normals deviate by larger than this amount
        """
        ...
    @max_angle_deviation.setter
    def max_angle_deviation(self, value: float) -> None:
        ...
    @property
    def generate_nanite_enabled_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate a nanite-enabled mesh
        """
        ...
    @generate_nanite_enabled_mesh.setter
    def generate_nanite_enabled_mesh(self, value: bool) -> None:
        ...
    @property
    def nanite_fallback_target(self) -> NaniteFallbackTarget:
        r"""
        (NaniteFallbackTarget):  [Read-Write] Which heuristic to use when generating the Nanite fallback mesh.
        """
        ...
    @nanite_fallback_target.setter
    def nanite_fallback_target(self, value: NaniteFallbackTarget) -> None:
        ...
    @property
    def nanite_fallback_percent_triangles(self) -> float:
        r"""
        (float):  [Read-Write] Percentage of triangles to keep from source Nanite mesh for fallback. 1.0 = no reduction, 0.0 = no triangles.
        """
        ...
    @nanite_fallback_percent_triangles.setter
    def nanite_fallback_percent_triangles(self, value: float) -> None:
        ...
    @property
    def nanite_fallback_relative_error(self) -> float:
        r"""
        (float):  [Read-Write] Reduce Nanite fallback mesh until at least this amount of error is reached relative to size of the mesh.
        """
        ...
    @nanite_fallback_relative_error.setter
    def nanite_fallback_relative_error(self, value: float) -> None:
        ...
    @property
    def support_ray_tracing(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether ray tracing will be supported on this mesh. Disable this to save memory if the generated mesh will only be rendered in the distance.
        """
        ...
    @support_ray_tracing.setter
    def support_ray_tracing(self, value: bool) -> None:
        ...
    @property
    def allow_distance_field(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to allow distance field to be computed for this mesh. Disable this to save memory if the generated mesh will only be rendered in the distance.
        """
        ...
    @allow_distance_field.setter
    def allow_distance_field(self, value: bool) -> None:
        ...
    @property
    def multi_sampling_aa(self) -> int:
        r"""
        (int32):  [Read-Write] If Value is > 1, Multisample output baked textures by this amount in each direction (eg 4 == 16x supersampling)
        """
        ...
    @multi_sampling_aa.setter
    def multi_sampling_aa(self, value: int) -> None:
        ...
    @property
    def render_capture_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] If Value is zero, use MaterialSettings resolution, otherwise override the render capture resolution
        """
        ...
    @render_capture_resolution.setter
    def render_capture_resolution(self, value: int) -> None:
        ...
    @property
    def material_settings(self) -> MaterialProxySettings:
        r"""
        (MaterialProxySettings):  [Read-Write] Material generation settings
        """
        ...
    @material_settings.setter
    def material_settings(self, value: MaterialProxySettings) -> None:
        ...
    @property
    def capture_field_of_view(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @capture_field_of_view.setter
    def capture_field_of_view(self, value: float) -> None:
        ...
    @property
    def near_plane_dist(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @near_plane_dist.setter
    def near_plane_dist(self, value: float) -> None:
        ...
    @property
    def use_render_lod_meshes(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, LOD0 Render Meshes (or Nanite Fallback meshes) are used instead of Source Mesh data. This can significantly reduce computation time and memory usage, but potentially at the cost of lower quality output.
        """
        ...
    @use_render_lod_meshes.setter
    def use_render_lod_meshes(self, value: bool) -> None:
        ...
    @property
    def enable_simplify_pre_pass(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, a faster mesh simplfication strategy will be used. This can significantly reduce computation time and memory usage, but potentially at the cost of lower quality output.
        """
        ...
    @enable_simplify_pre_pass.setter
    def enable_simplify_pre_pass(self, value: bool) -> None:
        ...
    @property
    def enable_parallel_baking(self) -> bool:
        r"""
        (bool):  [Read-Write] If false, texture capture and baking will be done serially after mesh generation, rather than in parallel when possible. This will reduce the maximum memory requirements of the process.
        """
        ...
    @enable_parallel_baking.setter
    def enable_parallel_baking(self, value: bool) -> None:
        ...
    @property
    def print_debug_messages(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, print out debugging messages
        """
        ...
    @print_debug_messages.setter
    def print_debug_messages(self, value: bool) -> None:
        ...
    @property
    def emit_full_debug_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, write the full mesh triangle set (ie flattened, non-instanced) used for mesh generation. Warning: this asset may be extremely large!!
        """
        ...
    @emit_full_debug_mesh.setter
    def emit_full_debug_mesh(self, value: bool) -> None:
        ...

class MeshMergingSettings(StructBase):
    r"""
    Mesh merging settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_distance_field`` (bool):  [Read-Write] Whether to allow distance field to be computed for this mesh. Disable this to save memory if the merged mesh will only be rendered in the distance.
    - ``bake_vertex_data_to_mesh`` (bool):  [Read-Write] Whether or not vertex data such as vertex colours should be baked into the resulting mesh
    - ``computed_light_map_resolution`` (bool):  [Read-Write] Whether or not the lightmap resolution should be computed by summing the lightmap resolutions for the input Mesh Components
    - ``generate_light_map_uv`` (bool):  [Read-Write] Whether to generate lightmap UVs for a merged mesh
    - ``gutter_size`` (int32):  [Read-Write] The gutter (in texels) to add to each sub-chart for our baked-out material for the top mip level
    - ``include_imposters`` (bool):  [Read-Write] Whether or not to include any imposter LODs that are part of the source static meshes
    - ``lod_selection_type`` (MeshLODSelectionType):  [Read-Write] Which selection mode should be used when generating the merged static mesh
    - ``material_settings`` (MaterialProxySettings):  [Read-Write] Material simplification
    - ``merge_equivalent_materials`` (bool):  [Read-Write] Whether to attempt to merge materials that are deemed equivalent. This can cause artifacts in the merged mesh if world position/actor position etc. is used to determine output color.
    - ``merge_materials`` (bool):  [Read-Write] Whether to merge source materials into one flat material, ONLY available when LOD Selection Type is set to LowestDetailLOD
    - ``merge_mesh_sockets`` (bool):  [Read-Write] Whether to merge sockets
    - ``merge_physics_data`` (bool):  [Read-Write] Whether to merge physics data (collision primitives)
    - ``nanite_settings`` (MeshNaniteSettings):  [Read-Write] Settings related to building Nanite data.
    - ``output_u_vs`` (UVOutput):  [Read-Write] Whether to output the specified UV channels into the merged mesh (only if the source meshes contain valid UVs for the specified channel)
    - ``pivot_point_at_zero`` (bool):  [Read-Write] Whether merged mesh should have pivot at world origin, or at first merged component otherwise
    - ``reuse_mesh_lightmap_u_vs`` (bool):  [Read-Write] Whether to attempt to re-use the source mesh's lightmap UVs when baking the material or always generate a new set.
    - ``specific_lod`` (int32):  [Read-Write] A given LOD level to export from the source meshes, used if LOD Selection Type is set to SpecificLOD
    - ``support_ray_tracing`` (bool):  [Read-Write] Whether ray tracing will be supported on this mesh. Disable this to save memory if the generated mesh will only be rendered in the distance.
    - ``target_light_map_resolution`` (int32):  [Read-Write] The lightmap resolution used both for generating lightmap UV coordinates, and also set on the generated static mesh
    - ``use_landscape_culling`` (bool):  [Read-Write] Whether or not to use available landscape geometry to cull away invisible triangles
    - ``use_texture_binning`` (bool):  [Read-Write] Whether or not to calculate varying output texture sizes according to their importance in the final atlas texture
    - ``use_vertex_data_for_baking_material`` (bool):  [Read-Write] Whether or not vertex data such as vertex colours should be used when baking out materials
    """
    def __init__(self, target_light_map_resolution: int = 0, material_settings: MaterialProxySettings = [TextureSizingType.TEXTURE_SIZING_TYPE_USE_SINGLE_TEXTURE_SIZE, 5.000000, 0.500000, 10000.000000, 4.000000, 0.000000, 0.500000, 0.000000, 0.500000, 1.000000, 1.000000, 1.000000, BlendMode.BLEND_OPAQUE, True, True, False, False, False, False, False, False, False, False, False, [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024]], lod_selection_type: MeshLODSelectionType = MeshLODSelectionType.ALL_LO_DS, specific_lod: int = 0, generate_light_map_uv: bool = False, computed_light_map_resolution: bool = False, pivot_point_at_zero: bool = False, merge_physics_data: bool = False, merge_mesh_sockets: bool = False, merge_materials: bool = False, bake_vertex_data_to_mesh: bool = False, use_vertex_data_for_baking_material: bool = False, use_texture_binning: bool = False, use_landscape_culling: bool = False, include_imposters: bool = False, support_ray_tracing: bool = False, nanite_settings: MeshNaniteSettings = [False, False, False, True, -2147483648, -1, -1, 1.000000, 0.000000, NaniteFallbackTarget.AUTO, 1.000000, 1.000000, 0.000000, 0]) -> None:
        ...
    @property
    def target_light_map_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] The lightmap resolution used both for generating lightmap UV coordinates, and also set on the generated static mesh
        """
        ...
    @target_light_map_resolution.setter
    def target_light_map_resolution(self, value: int) -> None:
        ...
    @property
    def material_settings(self) -> MaterialProxySettings:
        r"""
        (MaterialProxySettings):  [Read-Write] Material simplification
        """
        ...
    @material_settings.setter
    def material_settings(self, value: MaterialProxySettings) -> None:
        ...
    @property
    def lod_selection_type(self) -> MeshLODSelectionType:
        r"""
        (MeshLODSelectionType):  [Read-Write] Which selection mode should be used when generating the merged static mesh
        """
        ...
    @lod_selection_type.setter
    def lod_selection_type(self, value: MeshLODSelectionType) -> None:
        ...
    @property
    def specific_lod(self) -> int:
        r"""
        (int32):  [Read-Write] A given LOD level to export from the source meshes, used if LOD Selection Type is set to SpecificLOD
        """
        ...
    @specific_lod.setter
    def specific_lod(self, value: int) -> None:
        ...
    @property
    def generate_light_map_uv(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate lightmap UVs for a merged mesh
        """
        ...
    @generate_light_map_uv.setter
    def generate_light_map_uv(self, value: bool) -> None:
        ...
    @property
    def computed_light_map_resolution(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not the lightmap resolution should be computed by summing the lightmap resolutions for the input Mesh Components
        """
        ...
    @computed_light_map_resolution.setter
    def computed_light_map_resolution(self, value: bool) -> None:
        ...
    @property
    def pivot_point_at_zero(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether merged mesh should have pivot at world origin, or at first merged component otherwise
        """
        ...
    @pivot_point_at_zero.setter
    def pivot_point_at_zero(self, value: bool) -> None:
        ...
    @property
    def merge_physics_data(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to merge physics data (collision primitives)
        """
        ...
    @merge_physics_data.setter
    def merge_physics_data(self, value: bool) -> None:
        ...
    @property
    def merge_mesh_sockets(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to merge sockets
        """
        ...
    @merge_mesh_sockets.setter
    def merge_mesh_sockets(self, value: bool) -> None:
        ...
    @property
    def merge_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to merge source materials into one flat material, ONLY available when LOD Selection Type is set to LowestDetailLOD
        """
        ...
    @merge_materials.setter
    def merge_materials(self, value: bool) -> None:
        ...
    @property
    def bake_vertex_data_to_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not vertex data such as vertex colours should be baked into the resulting mesh
        """
        ...
    @bake_vertex_data_to_mesh.setter
    def bake_vertex_data_to_mesh(self, value: bool) -> None:
        ...
    @property
    def use_vertex_data_for_baking_material(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not vertex data such as vertex colours should be used when baking out materials
        """
        ...
    @use_vertex_data_for_baking_material.setter
    def use_vertex_data_for_baking_material(self, value: bool) -> None:
        ...
    @property
    def use_texture_binning(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to calculate varying output texture sizes according to their importance in the final atlas texture
        """
        ...
    @use_texture_binning.setter
    def use_texture_binning(self, value: bool) -> None:
        ...
    @property
    def use_landscape_culling(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to use available landscape geometry to cull away invisible triangles
        """
        ...
    @use_landscape_culling.setter
    def use_landscape_culling(self, value: bool) -> None:
        ...
    @property
    def include_imposters(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to include any imposter LODs that are part of the source static meshes
        """
        ...
    @include_imposters.setter
    def include_imposters(self, value: bool) -> None:
        ...
    @property
    def support_ray_tracing(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether ray tracing will be supported on this mesh. Disable this to save memory if the generated mesh will only be rendered in the distance.
        """
        ...
    @support_ray_tracing.setter
    def support_ray_tracing(self, value: bool) -> None:
        ...
    @property
    def nanite_settings(self) -> MeshNaniteSettings:
        r"""
        (MeshNaniteSettings):  [Read-Write] Settings related to building Nanite data.
        """
        ...
    @nanite_settings.setter
    def nanite_settings(self, value: MeshNaniteSettings) -> None:
        ...

class MeshProxySettings(StructBase):
    r"""
    Mesh Proxy Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_distance_field`` (bool):  [Read-Write] Whether to allow distance field to be computed for this mesh. Disable this to save memory if the merged mesh will only be rendered in the distance.
    - ``allow_vertex_colors`` (bool):  [Read-Write] Whether to allow vertex colors saved in the merged mesh
    - ``calculate_correct_lod_model`` (bool):  [Read-Write] Determines whether or not the correct LOD models should be calculated given the source meshes and transition size
    - ``compute_light_map_resolution`` (bool):  [Read-Write] If ticked will compute the lightmap resolution by summing the dimensions for each mesh included for merging
    - ``create_collision`` (bool):  [Read-Write] Whether to generate collision for the merged mesh
    - ``generate_lightmap_u_vs`` (bool):  [Read-Write] Whether to generate lightmap uvs for the merged mesh
    - ``group_identical_meshes_for_baking`` (bool):  [Read-Write] Bake identical meshes (or mesh instances) only once. Can lead to discrepancies with the source mesh visual, especially for materials that are using world position or per instance data. However, this will result in better quality baked textures & greatly reduce baking time.
    - ``hard_angle_threshold`` (float):  [Read-Write] Angle at which a hard edge is introduced between faces
    - ``landscape_culling_precision`` (LandscapeCullingPrecision):  [Read-Write] Level of detail of the landscape that should be used for the culling
    - ``light_map_resolution`` (int32):  [Read-Write] Lightmap resolution
    - ``material_settings`` (MaterialProxySettings):  [Read-Write] Material simplification
    - ``max_ray_cast_dist`` (float):  [Read-Write] Override search distance used when discovering texture values for simplified geometry. Useful when non-zero Merge Distance setting generates new geometry in concave corners.
    - ``merge_distance`` (float):  [Read-Write] Distance at which meshes should be merged together, this can close gaps like doors and windows in distant geometry
    - ``nanite_settings`` (MeshNaniteSettings):  [Read-Write] Settings related to building Nanite data.
    - ``normal_calculation_method`` (ProxyNormalComputationMethod):  [Read-Write] Controls the method used to calculate the normal for the simplified geometry
    - ``override_transfer_distance`` (bool):  [Read-Write] Enable an override for material transfer distance
    - ``override_voxel_size`` (bool):  [Read-Write] If true, Spatial Sampling Distance will not be automatically computed based on geometry and you must set it directly
    - ``recalculate_normals`` (bool):  [Read-Write] Whether Simplygon should recalculate normals, otherwise the normals channel will be sampled from the original mesh
    - ``reuse_mesh_lightmap_u_vs`` (bool):  [Read-Write] Whether to attempt to re-use the source mesh's lightmap UVs when baking the material or always generate a new set.
    - ``screen_size`` (int32):  [Read-Write] Screen size of the resulting proxy mesh in pixels
    - ``support_ray_tracing`` (bool):  [Read-Write] Whether ray tracing will be supported on this mesh. Disable this to save memory if the generated mesh will only be rendered in the distance.
    - ``unresolved_geometry_color`` (Color):  [Read-Write] Base color assigned to LOD geometry that can't be associated with the source geometry: e.g. doors and windows that have been closed by the Merge Distance
    - ``use_hard_angle_threshold`` (bool):  [Read-Write] Enable the use of hard angle based vertex splitting
    - ``use_landscape_culling`` (bool):  [Read-Write] Whether or not to use available landscape geometry to cull away invisible triangles
    - ``voxel_size`` (float):  [Read-Write] Override when converting multiple meshes for proxy LOD merging. Warning, large geometry with small sampling has very high memory costs
    """
    def __init__(self, screen_size: int = 0, voxel_size: float = 0.000000, material_settings: MaterialProxySettings = [TextureSizingType.TEXTURE_SIZING_TYPE_USE_SINGLE_TEXTURE_SIZE, 5.000000, 0.500000, 10000.000000, 4.000000, 0.000000, 0.500000, 0.000000, 0.500000, 1.000000, 1.000000, 1.000000, BlendMode.BLEND_OPAQUE, True, True, False, False, False, False, False, False, False, False, False, [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024]], merge_distance: float = 0.000000, unresolved_geometry_color: Color = [0, 0, 0, 0], max_ray_cast_dist: float = 0.000000, hard_angle_threshold: float = 0.000000, light_map_resolution: int = 0, normal_calculation_method: ProxyNormalComputationMethod = ProxyNormalComputationMethod.ANGLE_WEIGHTED, landscape_culling_precision: LandscapeCullingPrecision = LandscapeCullingPrecision.HIGH, calculate_correct_lod_model: bool = False, override_voxel_size: bool = False, override_transfer_distance: bool = False, use_hard_angle_threshold: bool = False, compute_light_map_resolution: bool = False, recalculate_normals: bool = False, use_landscape_culling: bool = False, support_ray_tracing: bool = False, allow_distance_field: bool = False, reuse_mesh_lightmap_u_vs: bool = False, group_identical_meshes_for_baking: bool = False, create_collision: bool = False, allow_vertex_colors: bool = False, generate_lightmap_u_vs: bool = False, nanite_settings: MeshNaniteSettings = [False, False, False, True, -2147483648, -1, -1, 1.000000, 0.000000, NaniteFallbackTarget.AUTO, 1.000000, 1.000000, 0.000000, 0]) -> None:
        ...
    @property
    def screen_size(self) -> int:
        r"""
        (int32):  [Read-Write] Screen size of the resulting proxy mesh in pixels
        """
        ...
    @screen_size.setter
    def screen_size(self, value: int) -> None:
        ...
    @property
    def voxel_size(self) -> float:
        r"""
        (float):  [Read-Write] Override when converting multiple meshes for proxy LOD merging. Warning, large geometry with small sampling has very high memory costs
        """
        ...
    @voxel_size.setter
    def voxel_size(self, value: float) -> None:
        ...
    @property
    def material_settings(self) -> MaterialProxySettings:
        r"""
        (MaterialProxySettings):  [Read-Write] Material simplification
        """
        ...
    @material_settings.setter
    def material_settings(self, value: MaterialProxySettings) -> None:
        ...
    @property
    def merge_distance(self) -> float:
        r"""
        (float):  [Read-Write] Distance at which meshes should be merged together, this can close gaps like doors and windows in distant geometry
        """
        ...
    @merge_distance.setter
    def merge_distance(self, value: float) -> None:
        ...
    @property
    def unresolved_geometry_color(self) -> Color:
        r"""
        (Color):  [Read-Write] Base color assigned to LOD geometry that can't be associated with the source geometry: e.g. doors and windows that have been closed by the Merge Distance
        """
        ...
    @unresolved_geometry_color.setter
    def unresolved_geometry_color(self, value: Color) -> None:
        ...
    @property
    def max_ray_cast_dist(self) -> float:
        r"""
        (float):  [Read-Write] Override search distance used when discovering texture values for simplified geometry. Useful when non-zero Merge Distance setting generates new geometry in concave corners.
        """
        ...
    @max_ray_cast_dist.setter
    def max_ray_cast_dist(self, value: float) -> None:
        ...
    @property
    def hard_angle_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Angle at which a hard edge is introduced between faces
        """
        ...
    @hard_angle_threshold.setter
    def hard_angle_threshold(self, value: float) -> None:
        ...
    @property
    def light_map_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] Lightmap resolution
        """
        ...
    @light_map_resolution.setter
    def light_map_resolution(self, value: int) -> None:
        ...
    @property
    def normal_calculation_method(self) -> ProxyNormalComputationMethod:
        r"""
        (ProxyNormalComputationMethod):  [Read-Write] Controls the method used to calculate the normal for the simplified geometry
        """
        ...
    @normal_calculation_method.setter
    def normal_calculation_method(self, value: ProxyNormalComputationMethod) -> None:
        ...
    @property
    def landscape_culling_precision(self) -> LandscapeCullingPrecision:
        r"""
        (LandscapeCullingPrecision):  [Read-Write] Level of detail of the landscape that should be used for the culling
        """
        ...
    @landscape_culling_precision.setter
    def landscape_culling_precision(self, value: LandscapeCullingPrecision) -> None:
        ...
    @property
    def calculate_correct_lod_model(self) -> bool:
        r"""
        (bool):  [Read-Write] Determines whether or not the correct LOD models should be calculated given the source meshes and transition size
        """
        ...
    @calculate_correct_lod_model.setter
    def calculate_correct_lod_model(self, value: bool) -> None:
        ...
    @property
    def override_voxel_size(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, Spatial Sampling Distance will not be automatically computed based on geometry and you must set it directly
        """
        ...
    @override_voxel_size.setter
    def override_voxel_size(self, value: bool) -> None:
        ...
    @property
    def override_transfer_distance(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable an override for material transfer distance
        """
        ...
    @override_transfer_distance.setter
    def override_transfer_distance(self, value: bool) -> None:
        ...
    @property
    def use_hard_angle_threshold(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable the use of hard angle based vertex splitting
        """
        ...
    @use_hard_angle_threshold.setter
    def use_hard_angle_threshold(self, value: bool) -> None:
        ...
    @property
    def compute_light_map_resolution(self) -> bool:
        r"""
        (bool):  [Read-Write] If ticked will compute the lightmap resolution by summing the dimensions for each mesh included for merging
        """
        ...
    @compute_light_map_resolution.setter
    def compute_light_map_resolution(self, value: bool) -> None:
        ...
    @property
    def recalculate_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether Simplygon should recalculate normals, otherwise the normals channel will be sampled from the original mesh
        """
        ...
    @recalculate_normals.setter
    def recalculate_normals(self, value: bool) -> None:
        ...
    @property
    def use_landscape_culling(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to use available landscape geometry to cull away invisible triangles
        """
        ...
    @use_landscape_culling.setter
    def use_landscape_culling(self, value: bool) -> None:
        ...
    @property
    def support_ray_tracing(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether ray tracing will be supported on this mesh. Disable this to save memory if the generated mesh will only be rendered in the distance.
        """
        ...
    @support_ray_tracing.setter
    def support_ray_tracing(self, value: bool) -> None:
        ...
    @property
    def allow_distance_field(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to allow distance field to be computed for this mesh. Disable this to save memory if the merged mesh will only be rendered in the distance.
        """
        ...
    @allow_distance_field.setter
    def allow_distance_field(self, value: bool) -> None:
        ...
    @property
    def reuse_mesh_lightmap_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to attempt to re-use the source mesh's lightmap UVs when baking the material or always generate a new set.
        """
        ...
    @reuse_mesh_lightmap_u_vs.setter
    def reuse_mesh_lightmap_u_vs(self, value: bool) -> None:
        ...
    @property
    def group_identical_meshes_for_baking(self) -> bool:
        r"""
        (bool):  [Read-Write] Bake identical meshes (or mesh instances) only once. Can lead to discrepancies with the source mesh visual, especially for materials that are using world position or per instance data. However, this will result in better quality baked textures & greatly reduce baking time.
        """
        ...
    @group_identical_meshes_for_baking.setter
    def group_identical_meshes_for_baking(self, value: bool) -> None:
        ...
    @property
    def create_collision(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate collision for the merged mesh
        """
        ...
    @create_collision.setter
    def create_collision(self, value: bool) -> None:
        ...
    @property
    def allow_vertex_colors(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to allow vertex colors saved in the merged mesh
        """
        ...
    @allow_vertex_colors.setter
    def allow_vertex_colors(self, value: bool) -> None:
        ...
    @property
    def generate_lightmap_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to generate lightmap uvs for the merged mesh
        """
        ...
    @generate_lightmap_u_vs.setter
    def generate_lightmap_u_vs(self, value: bool) -> None:
        ...
    @property
    def nanite_settings(self) -> MeshNaniteSettings:
        r"""
        (MeshNaniteSettings):  [Read-Write] Settings related to building Nanite data.
        """
        ...
    @nanite_settings.setter
    def nanite_settings(self, value: MeshNaniteSettings) -> None:
        ...

class QuartzPulseOverrideStep(StructBase):
    r"""
    Allows the user to specify non-uniform beat durations in odd meters
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``number_of_pulses`` (int32):  [Read-Write] The number of pulses for this beat duration
    - ``pulse_duration`` (QuartzCommandQuantization):  [Read-Write] This Beat duration
    """
    def __init__(self, number_of_pulses: int = 0, pulse_duration: QuartzCommandQuantization = QuartzCommandQuantization.BAR) -> None:
        ...
    @property
    def number_of_pulses(self) -> int:
        r"""
        (int32):  [Read-Write] The number of pulses for this beat duration
        """
        ...
    @number_of_pulses.setter
    def number_of_pulses(self, value: int) -> None:
        ...
    @property
    def pulse_duration(self) -> QuartzCommandQuantization:
        r"""
        (QuartzCommandQuantization):  [Read-Write] This Beat duration
        """
        ...
    @pulse_duration.setter
    def pulse_duration(self, value: QuartzCommandQuantization) -> None:
        ...

class QuartzTimeSignature(StructBase):
    r"""
    Quartz Time Signature
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``beat_type`` (QuartzTimeSignatureQuantization):  [Read-Write] denominator
    - ``num_beats`` (int32):  [Read-Write] numerator
    - ``optional_pulse_override`` (Array[QuartzPulseOverrideStep]):  [Read-Write] beat override
    """
    def __init__(self, num_beats: int = 0, beat_type: QuartzTimeSignatureQuantization = QuartzTimeSignatureQuantization.HALF_NOTE, optional_pulse_override: Array[QuartzPulseOverrideStep] = []) -> None:
        ...
    @property
    def num_beats(self) -> int:
        r"""
        (int32):  [Read-Write] numerator
        """
        ...
    @num_beats.setter
    def num_beats(self, value: int) -> None:
        ...
    @property
    def beat_type(self) -> QuartzTimeSignatureQuantization:
        r"""
        (QuartzTimeSignatureQuantization):  [Read-Write] denominator
        """
        ...
    @beat_type.setter
    def beat_type(self, value: QuartzTimeSignatureQuantization) -> None:
        ...
    @property
    def optional_pulse_override(self) -> Array[QuartzPulseOverrideStep]:
        r"""
        (Array[QuartzPulseOverrideStep]):  [Read-Write] beat override
        """
        ...
    @optional_pulse_override.setter
    def optional_pulse_override(self, value: Array[QuartzPulseOverrideStep]) -> None:
        ...

class QuartzTransportTimeStamp(StructBase):
    r"""
    Transport Time stamp, used for tracking the musical time stamp on a clock
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bars`` (int32):  [Read-Write] The current bar this clock is on
    - ``beat`` (int32):  [Read-Write] The current beat this clock is on
    - ``beat_fraction`` (float):  [Read-Write] A fractional representation of the time that's played since the last bear
    - ``seconds`` (float):  [Read-Write] The time in seconds that this TimeStamp occured at
    """
    def __init__(self, bars: int = 0, beat: int = 0, beat_fraction: float = 0.000000, seconds: float = 0.000000) -> None:
        ...
    @property
    def bars(self) -> int:
        r"""
        (int32):  [Read-Only] The current bar this clock is on
        """
        ...
    @property
    def beat(self) -> int:
        r"""
        (int32):  [Read-Only] The current beat this clock is on
        """
        ...
    @property
    def beat_fraction(self) -> float:
        r"""
        (float):  [Read-Only] A fractional representation of the time that's played since the last bear
        """
        ...
    @property
    def seconds(self) -> float:
        r"""
        (float):  [Read-Only] The time in seconds that this TimeStamp occured at
        """
        ...

class QuartzClockSettings(StructBase):
    r"""
    UStruct version of settings struct used to initialized a clock
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ignore_level_change`` (bool):  [Read-Write] should the clock start Ticking
    - ``time_signature`` (QuartzTimeSignature):  [Read-Write] Time Signature (defaults to 4/4)
    """
    def __init__(self, time_signature: QuartzTimeSignature = [4, QuartzTimeSignatureQuantization.QUARTER_NOTE, []], ignore_level_change: bool = False) -> None:
        ...
    @property
    def time_signature(self) -> QuartzTimeSignature:
        r"""
        (QuartzTimeSignature):  [Read-Write] Time Signature (defaults to 4/4)
        """
        ...
    @time_signature.setter
    def time_signature(self, value: QuartzTimeSignature) -> None:
        ...
    @property
    def ignore_level_change(self) -> bool:
        r"""
        (bool):  [Read-Write] should the clock start Ticking
        """
        ...
    @ignore_level_change.setter
    def ignore_level_change(self, value: bool) -> None:
        ...

class QuartzQuantizationBoundary(StructBase):
    r"""
    struct used to specify the quantization boundary of an event
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: QuartzQuantizationUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cancel_command_if_clock_is_not_running`` (bool):  [Read-Write] If this is true, this command will be canceled if the Clock is stopped or otherwise not running
    - ``counting_reference_point`` (QuarztQuantizationReference):  [Read-Write]
    - ``fire_on_clock_start`` (bool):  [Read-Write] If this is true and the Clock hasn't started yet, the event will fire immediately when the Clock starts
    - ``multiplier`` (float):  [Read-Write] how many "Resolutions" to wait before the onset we care about
    - ``quantization`` (QuartzCommandQuantization):  [Read-Write] resolution we are interested in
    - ``reset_clock_on_queued`` (bool):  [Read-Write] If this is true, queueing the sound will also call a Reset Clock command
    - ``resume_clock_on_queued`` (bool):  [Read-Write] If this is true, queueing the sound will also call a Resume Clock command
    """
    def __init__(self, quantization: QuartzCommandQuantization = QuartzCommandQuantization.BAR, multiplier: float = 0.000000, counting_reference_point: QuarztQuantizationReference = QuarztQuantizationReference.BAR_RELATIVE, fire_on_clock_start: bool = False, cancel_command_if_clock_is_not_running: bool = False, reset_clock_on_queued: bool = False, resume_clock_on_queued: bool = False) -> None:
        ...
    @property
    def quantization(self) -> QuartzCommandQuantization:
        r"""
        (QuartzCommandQuantization):  [Read-Write] resolution we are interested in
        """
        ...
    @quantization.setter
    def quantization(self, value: QuartzCommandQuantization) -> None:
        ...
    @property
    def multiplier(self) -> float:
        r"""
        (float):  [Read-Write] how many "Resolutions" to wait before the onset we care about
        """
        ...
    @multiplier.setter
    def multiplier(self, value: float) -> None:
        ...
    @property
    def counting_reference_point(self) -> QuarztQuantizationReference:
        r"""
        (QuarztQuantizationReference):  [Read-Write]
        """
        ...
    @counting_reference_point.setter
    def counting_reference_point(self, value: QuarztQuantizationReference) -> None:
        ...
    @property
    def fire_on_clock_start(self) -> bool:
        r"""
        (bool):  [Read-Write] If this is true and the Clock hasn't started yet, the event will fire immediately when the Clock starts
        """
        ...
    @fire_on_clock_start.setter
    def fire_on_clock_start(self, value: bool) -> None:
        ...
    @property
    def cancel_command_if_clock_is_not_running(self) -> bool:
        r"""
        (bool):  [Read-Write] If this is true, this command will be canceled if the Clock is stopped or otherwise not running
        """
        ...
    @cancel_command_if_clock_is_not_running.setter
    def cancel_command_if_clock_is_not_running(self, value: bool) -> None:
        ...
    @property
    def reset_clock_on_queued(self) -> bool:
        r"""
        (bool):  [Read-Write] If this is true, queueing the sound will also call a Reset Clock command
        """
        ...
    @reset_clock_on_queued.setter
    def reset_clock_on_queued(self, value: bool) -> None:
        ...
    @property
    def resume_clock_on_queued(self) -> bool:
        r"""
        (bool):  [Read-Write] If this is true, queueing the sound will also call a Resume Clock command
        """
        ...
    @resume_clock_on_queued.setter
    def resume_clock_on_queued(self, value: bool) -> None:
        ...

class MovementProperties(StructBase):
    r"""
    Movement capabilities, determining available movement options for Pawns and used by AI for reachability tests.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_crouch`` (bool):  [Read-Write] If true, this Pawn is capable of crouching.
    - ``can_fly`` (bool):  [Read-Write] If true, this Pawn is capable of flying.
    - ``can_jump`` (bool):  [Read-Write] If true, this Pawn is capable of jumping.
    - ``can_swim`` (bool):  [Read-Write] If true, this Pawn is capable of swimming or moving through fluid volumes.
    - ``can_walk`` (bool):  [Read-Write] If true, this Pawn is capable of walking or moving on the ground.
    """
    def __init__(self, can_crouch: bool = False, can_jump: bool = False, can_walk: bool = False, can_swim: bool = False, can_fly: bool = False) -> None:
        ...
    @property
    def can_crouch(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this Pawn is capable of crouching.
        """
        ...
    @can_crouch.setter
    def can_crouch(self, value: bool) -> None:
        ...
    @property
    def can_jump(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this Pawn is capable of jumping.
        """
        ...
    @can_jump.setter
    def can_jump(self, value: bool) -> None:
        ...
    @property
    def can_walk(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this Pawn is capable of walking or moving on the ground.
        """
        ...
    @can_walk.setter
    def can_walk(self, value: bool) -> None:
        ...
    @property
    def can_swim(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this Pawn is capable of swimming or moving through fluid volumes.
        """
        ...
    @can_swim.setter
    def can_swim(self, value: bool) -> None:
        ...
    @property
    def can_fly(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this Pawn is capable of flying.
        """
        ...
    @can_fly.setter
    def can_fly(self, value: bool) -> None:
        ...

class NavAgentProperties(MovementProperties):
    r"""
    Properties of representation of an 'agent' (or Pawn) used by AI navigation/pathfinding.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``agent_height`` (float):  [Read-Write] Total height of the capsule used for navigation/pathfinding.
    - ``agent_radius`` (float):  [Read-Write] Radius of the capsule used for navigation/pathfinding.
    - ``agent_step_height`` (float):  [Read-Write] Step height to use, or -1 for default value from navdata's config.
    - ``can_crouch`` (bool):  [Read-Write] If true, this Pawn is capable of crouching.
    - ``can_fly`` (bool):  [Read-Write] If true, this Pawn is capable of flying.
    - ``can_jump`` (bool):  [Read-Write] If true, this Pawn is capable of jumping.
    - ``can_swim`` (bool):  [Read-Write] If true, this Pawn is capable of swimming or moving through fluid volumes.
    - ``can_walk`` (bool):  [Read-Write] If true, this Pawn is capable of walking or moving on the ground.
    - ``nav_walking_search_height_scale`` (float):  [Read-Write] Scale factor to apply to height of bounds when searching for navmesh to project to when nav walking
    - ``preferred_nav_data`` (SoftClassPath):  [Read-Write] Type of navigation data used by agent, null means "any"
    """
    def __init__(self, can_crouch: bool = False, can_jump: bool = False, can_walk: bool = False, can_swim: bool = False, can_fly: bool = False, agent_radius: float = 0.000000, agent_height: float = 0.000000, agent_step_height: float = 0.000000, nav_walking_search_height_scale: float = 0.000000, preferred_nav_data: SoftClassPath = [""]) -> None:
        ...
    @property
    def agent_radius(self) -> float:
        r"""
        (float):  [Read-Write] Radius of the capsule used for navigation/pathfinding.
        """
        ...
    @agent_radius.setter
    def agent_radius(self, value: float) -> None:
        ...
    @property
    def agent_height(self) -> float:
        r"""
        (float):  [Read-Write] Total height of the capsule used for navigation/pathfinding.
        """
        ...
    @agent_height.setter
    def agent_height(self, value: float) -> None:
        ...
    @property
    def agent_step_height(self) -> float:
        r"""
        (float):  [Read-Write] Step height to use, or -1 for default value from navdata's config.
        """
        ...
    @agent_step_height.setter
    def agent_step_height(self, value: float) -> None:
        ...
    @property
    def nav_walking_search_height_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scale factor to apply to height of bounds when searching for navmesh to project to when nav walking
        """
        ...
    @nav_walking_search_height_scale.setter
    def nav_walking_search_height_scale(self, value: float) -> None:
        ...
    @property
    def preferred_nav_data(self) -> SoftClassPath:
        r"""
        (SoftClassPath):  [Read-Write] Type of navigation data used by agent, null means "any"
        """
        ...
    @preferred_nav_data.setter
    def preferred_nav_data(self, value: SoftClassPath) -> None:
        ...

class NavDataConfig(NavAgentProperties):
    r"""
    Nav Data Config
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``agent_height`` (float):  [Read-Write] Total height of the capsule used for navigation/pathfinding.
    - ``agent_radius`` (float):  [Read-Write] Radius of the capsule used for navigation/pathfinding.
    - ``agent_step_height`` (float):  [Read-Write] Step height to use, or -1 for default value from navdata's config.
    - ``can_crouch`` (bool):  [Read-Write] If true, this Pawn is capable of crouching.
    - ``can_fly`` (bool):  [Read-Write] If true, this Pawn is capable of flying.
    - ``can_jump`` (bool):  [Read-Write] If true, this Pawn is capable of jumping.
    - ``can_swim`` (bool):  [Read-Write] If true, this Pawn is capable of swimming or moving through fluid volumes.
    - ``can_walk`` (bool):  [Read-Write] If true, this Pawn is capable of walking or moving on the ground.
    - ``color`` (Color):  [Read-Write] Color used to represent this agent in the editor and for debugging
    - ``default_query_extent`` (Vector):  [Read-Write] Rough size of this agent, used when projecting unto navigation mesh
    - ``name`` (Name):  [Read-Write] Internal/debug name of this agent
    - ``nav_data_class`` (Class):  [Read-Write] Class to use when spawning navigation data instance
    - ``nav_walking_search_height_scale`` (float):  [Read-Write] Scale factor to apply to height of bounds when searching for navmesh to project to when nav walking
    - ``preferred_nav_data`` (SoftClassPath):  [Read-Write] Type of navigation data used by agent, null means "any"
    """
    def __init__(self, can_crouch: bool = False, can_jump: bool = False, can_walk: bool = False, can_swim: bool = False, can_fly: bool = False, agent_radius: float = 0.000000, agent_height: float = 0.000000, agent_step_height: float = 0.000000, nav_walking_search_height_scale: float = 0.000000, preferred_nav_data: SoftClassPath = [""], name: Name = "None", color: Color = [0, 0, 0, 0], default_query_extent: Vector = [0.000000, 0.000000, 0.000000], nav_data_class: Class = None) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] Internal/debug name of this agent
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def color(self) -> Color:
        r"""
        (Color):  [Read-Write] Color used to represent this agent in the editor and for debugging
        """
        ...
    @color.setter
    def color(self, value: Color) -> None:
        ...
    @property
    def default_query_extent(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Rough size of this agent, used when projecting unto navigation mesh
        """
        ...
    @property
    def nav_data_class(self) -> Class:
        r"""
        (Class):  [Read-Write] Class to use when spawning navigation data instance
        """
        ...
    @nav_data_class.setter
    def nav_data_class(self, value: Class) -> None:
        ...
    @property
    def navigation_data_class_name(self) -> Class:
        r"""
        deprecated: 'navigation_data_class_name' was renamed to 'nav_data_class'.
        """
        ...
    @navigation_data_class_name.setter
    def navigation_data_class_name(self, value: Class) -> None:
        ...

class AlphaBlendArgs(StructBase):
    r"""
    Alpha Blend construction arguments. Used for creation of an AlphaBlend.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AlphaBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_option`` (AlphaBlendOption):  [Read-Write] Type of blending used (Linear, Cubic, etc.)
    - ``blend_time`` (float):  [Read-Write] Blend Time
    - ``custom_curve`` (CurveFloat):  [Read-Write] If you're using Custom BlendOption, you can specify curve
    """
    def __init__(self, custom_curve: CurveFloat = None, blend_time: float = 0.000000, blend_option: AlphaBlendOption = AlphaBlendOption.LINEAR) -> None:
        ...
    @property
    def custom_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] If you're using Custom BlendOption, you can specify curve
        """
        ...
    @custom_curve.setter
    def custom_curve(self, value: CurveFloat) -> None:
        ...
    @property
    def blend_time(self) -> float:
        r"""
        (float):  [Read-Write] Blend Time
        """
        ...
    @blend_time.setter
    def blend_time(self, value: float) -> None:
        ...
    @property
    def blend_option(self) -> AlphaBlendOption:
        r"""
        (AlphaBlendOption):  [Read-Write] Type of blending used (Linear, Cubic, etc.)
        """
        ...
    @blend_option.setter
    def blend_option(self, value: AlphaBlendOption) -> None:
        ...

class BlendSampleData(StructBase):
    r"""
    Transform definition
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationAsset.h
    
    """
    def __init__(self) -> None:
        ...

class MarkerSyncAnimPosition(StructBase):
    r"""
    Represent a current play position in an animation
    based on sync markers
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``next_marker_name`` (Name):  [Read-Write] The marker we are heading towards
    - ``position_between_markers`` (float):  [Read-Write] Value between 0 and 1 representing where we are:
            0   we are at PreviousMarker
            1   we are at NextMarker
            0.5 we are half way between the two
    - ``previous_marker_name`` (Name):  [Read-Write] The marker we have passed
    """
    def __init__(self, previous_marker_name: Name = "None", next_marker_name: Name = "None", position_between_markers: float = 0.000000) -> None:
        ...
    @property
    def previous_marker_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The marker we have passed
        """
        ...
    @previous_marker_name.setter
    def previous_marker_name(self, value: Name) -> None:
        ...
    @property
    def next_marker_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The marker we are heading towards
        """
        ...
    @next_marker_name.setter
    def next_marker_name(self, value: Name) -> None:
        ...
    @property
    def position_between_markers(self) -> float:
        r"""
        (float):  [Read-Write] Value between 0 and 1 representing where we are:
              0   we are at PreviousMarker
              1   we are at NextMarker
              0.5 we are half way between the two
        """
        ...
    @position_between_markers.setter
    def position_between_markers(self, value: float) -> None:
        ...

class AnimExecutionContext(StructBase):
    r"""
    Context used to expose anim graph execution to BP function libraries
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimExecutionContext.h
    
    """
    def __init__(self) -> None:
        ...

class AnimInitializationContext(AnimExecutionContext):
    r"""
    Anim Initialization Context
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimExecutionContext.h
    
    """
    def __init__(self) -> None:
        ...

class AnimUpdateContext(AnimExecutionContext):
    r"""
    Anim Update Context
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimExecutionContext.h
    
    """
    def __init__(self) -> None:
        ...

class AnimPoseContext(AnimExecutionContext):
    r"""
    Anim Pose Context
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimExecutionContext.h
    
    """
    def __init__(self) -> None:
        ...

class AnimComponentSpacePoseContext(AnimExecutionContext):
    r"""
    Anim Component Space Pose Context
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimExecutionContext.h
    
    """
    def __init__(self) -> None:
        ...

class MontageBlendSettings(StructBase):
    r"""
    Montage blend settings. Can be used to overwrite default Montage settings on Play/Stop
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimMontage.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend`` (AlphaBlendArgs):  [Read-Write] AlphaBlend options (time, curve, etc.)
    - ``blend_mode`` (MontageBlendMode):  [Read-Write] Type of blend mode (Standard vs Inertial)
    - ``blend_profile`` (BlendProfile):  [Read-Write] Blend Profile to use for this blend
    """
    def __init__(self, blend_profile: BlendProfile = None, blend: AlphaBlendArgs = [None, 0.200000, AlphaBlendOption.LINEAR], blend_mode: MontageBlendMode = MontageBlendMode.STANDARD) -> None:
        ...
    @property
    def blend_profile(self) -> BlendProfile:
        r"""
        (BlendProfile):  [Read-Write] Blend Profile to use for this blend
        """
        ...
    @blend_profile.setter
    def blend_profile(self, value: BlendProfile) -> None:
        ...
    @property
    def blend(self) -> AlphaBlendArgs:
        r"""
        (AlphaBlendArgs):  [Read-Write] AlphaBlend options (time, curve, etc.)
        """
        ...
    @blend.setter
    def blend(self, value: AlphaBlendArgs) -> None:
        ...
    @property
    def blend_mode(self) -> MontageBlendMode:
        r"""
        (MontageBlendMode):  [Read-Write] Type of blend mode (Standard vs Inertial)
        """
        ...
    @blend_mode.setter
    def blend_mode(self, value: MontageBlendMode) -> None:
        ...

class AnimNodeData(StructBase):
    r"""
    Any constant/folded class data an anim node can be accessed via this struct
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNodeData.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_ConvertComponentToLocalSpace(AnimNode_Base):
    r"""
    Anim Node Convert Component to Local Space
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNodeSpaceConversions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``component_pose`` (ComponentSpacePoseLink):  [Read-Write]
    """
    def __init__(self, component_pose: ComponentSpacePoseLink = []) -> None:
        ...
    @property
    def component_pose(self) -> ComponentSpacePoseLink:
        r"""
        (ComponentSpacePoseLink):  [Read-Write]
        """
        ...
    @component_pose.setter
    def component_pose(self, value: ComponentSpacePoseLink) -> None:
        ...

class AnimNode_ConvertLocalToComponentSpace(AnimNode_Base):
    r"""
    Anim Node Convert Local to Component Space
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNodeSpaceConversions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``local_pose`` (PoseLink):  [Read-Write]
    """
    def __init__(self, local_pose: PoseLink = []) -> None:
        ...
    @property
    def local_pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @local_pose.setter
    def local_pose(self, value: PoseLink) -> None:
        ...

class AnimNode_ApplyMeshSpaceAdditive(AnimNode_Base):
    r"""
    Anim Node Apply Mesh Space Additive
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_ApplyMeshSpaceAdditive.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additive`` (PoseLink):  [Read-Write]
    - ``alpha`` (float):  [Read-Write] The float value that controls the alpha blending when the alpha input type is set to 'Float'
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write] The boolean value that controls the alpha blending when the alpha input type is set to 'Bool'
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write] The data type used to control the alpha blending of the additive pose.
                    Note: Changing this value will disconnect alpha input pins.
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``base`` (PoseLink):  [Read-Write]
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    """
    def __init__(self, base: PoseLink = [], additive: PoseLink = [], alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha: float = 0.000000, alpha_bool_enabled: bool = False, alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000], lod_threshold: int = 0) -> None:
        ...
    @property
    def base(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @base.setter
    def base(self, value: PoseLink) -> None:
        ...
    @property
    def additive(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @additive.setter
    def additive(self, value: PoseLink) -> None:
        ...
    @property
    def alpha_input_type(self) -> AnimAlphaInputType:
        r"""
        (AnimAlphaInputType):  [Read-Write] The data type used to control the alpha blending of the additive pose.
                      Note: Changing this value will disconnect alpha input pins.
        """
        ...
    @alpha_input_type.setter
    def alpha_input_type(self, value: AnimAlphaInputType) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write] The float value that controls the alpha blending when the alpha input type is set to 'Float'
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...
    @property
    def alpha_bool_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] The boolean value that controls the alpha blending when the alpha input type is set to 'Bool'
        """
        ...
    @alpha_bool_enabled.setter
    def alpha_bool_enabled(self, value: bool) -> None:
        ...
    @property
    def alpha_bool_blend(self) -> InputAlphaBoolBlend:
        r"""
        (InputAlphaBoolBlend):  [Read-Write]
        """
        ...
    @alpha_bool_blend.setter
    def alpha_bool_blend(self, value: InputAlphaBoolBlend) -> None:
        ...
    @property
    def alpha_curve_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @alpha_curve_name.setter
    def alpha_curve_name(self, value: Name) -> None:
        ...
    @property
    def alpha_scale_bias(self) -> InputScaleBias:
        r"""
        (InputScaleBias):  [Read-Write]
        """
        ...
    @alpha_scale_bias.setter
    def alpha_scale_bias(self, value: InputScaleBias) -> None:
        ...
    @property
    def alpha_scale_bias_clamp(self) -> InputScaleBiasClamp:
        r"""
        (InputScaleBiasClamp):  [Read-Write]
        """
        ...
    @alpha_scale_bias_clamp.setter
    def alpha_scale_bias_clamp(self, value: InputScaleBiasClamp) -> None:
        ...
    @property
    def lod_threshold(self) -> int:
        r"""
        (int32):  [Read-Write] * Max LOD that this node is allowed to run
        * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
        * when the component LOD becomes 3, it will stop update/evaluate
        * currently transition would be issue and that has to be re-visited
        """
        ...
    @lod_threshold.setter
    def lod_threshold(self, value: int) -> None:
        ...

class AnimNode_DeadBlending(AnimNode_Base):
    r"""
    Dead Blending Node
    
    Dead blending is an alternative method of inertialization that extrapolates the animation being transitioned from
    forward in time and then performs a normal cross-fade blend between this extrapolated animation and the new animation
    being transitioned to.
    
    For more background see: https://theorangeduck.com/page/dead-blending
    
    This node works by extrapolating forward the animation being transition from using the animation's velocities at
    the point of transition, with an exponential decay which reduces those velocities over time to avoid the pose
    becoming invalid.
    
    The rate of this decay is set automatically based on how much the velocities of the animation being transitioned
    from are moving toward the pose of the animation being transitioned to. If they are moving in the wrong direction or
    too quickly they will have a larger decay rate, while if they are in the correct direction and moving slowly relative
    to the difference they will have a smaller decay rate.
    
    These decay rates can be controlled by the `ExtrapolationHalfLife`, `ExtrapolationHalfLifeMin` and
    `ExtrapolationHalfLifeMax` parameters, which specify the approximate average, min, and max decay periods.
    More specifically they specify the "half-life" - or how it takes for the velocities to be decayed by half.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_DeadBlending.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``always_use_default_blend_settings`` (bool):  [Read-Write] When enabled, the default blend settings will always be used rather than those coming from the inertialization request.
    - ``blend_time_multiplier`` (float):  [Read-Write] Multiplier that can be used to scale the overall blend durations coming from inertialization requests.
    - ``default_blend_duration`` (float):  [Read-Write] The default blend duration to use when "Always Use Default Blend Settings" is set to true.
    - ``default_blend_mode`` (AlphaBlendOption):  [Read-Write] Default blend mode to use when no blend mode is supplied with the inertialization request.
    - ``default_blend_profile`` (BlendProfile):  [Read-Write] Default blend profile to use when no blend profile is supplied with the inertialization request.
    - ``default_custom_blend_curve`` (CurveFloat):  [Read-Write] Default custom blend curve to use along with the default blend mode.
    - ``extrapolation_filtered_curves`` (Array[Name]):  [Read-Write] List of curves that will not be included in the extrapolation. Curves in this list will effectively act like they have had their value reset
      to zero at the point of the transition, and will be blended in with the curve values in the animation that is being transitioned to.
    - ``extrapolation_half_life`` (float):  [Read-Write] The average half-life of decay in seconds to use when extrapolating the animation. To get the final half-life of
      decay, this value will be scaled by the amount to which the velocities of the animation being transitioned from
      are moving toward the animation being transitioned to.
    - ``extrapolation_half_life_max`` (float):  [Read-Write] The maximum half-life of decay in seconds to use when extrapolating the animation. This will dictate the longest
      decay duration possible when velocities of the animation being transitioned from are small and moving towards the
      animation being transitioned to.
    - ``extrapolation_half_life_min`` (float):  [Read-Write] The minimum half-life of decay in seconds to use when extrapolating the animation. This will be used when the
      velocities of the animation being transitioned from are very small or moving away from the animation being
      transitioned to.
    - ``filtered_bones`` (Array[BoneReference]):  [Read-Write] List of bones that should not use inertial blending. These bones will change instantly when the animation switches.
    - ``filtered_curves`` (Array[Name]):  [Read-Write] List of curves that should not use inertial blending. These curves will change instantly when the animation switches.
    - ``linearly_interpolate_scales`` (bool):  [Read-Write] When enabled, bone scales will be linearly interpolated and extrapolated. This is slightly more performant and
      consistent with the rest of Unreal but visually gives the appearance of the rate of change of scale being affected
      by the overall size of the bone. Note: this option must be enabled if you want this node to support negative scales.
    - ``maximum_curve_velocity`` (float):  [Read-Write] The maximum velocity to allow for extrapolation of curves. Smaller values may help prevent extreme curve values
      during blending but too small values can make the blending of curves less smooth.
    - ``maximum_rotation_velocity`` (float):  [Read-Write] The maximum velocity to allow for extrapolation of bone rotations in degrees per second. Smaller values
      may help prevent the pose breaking during blending but too small values can make the blend less smooth.
    - ``maximum_scale_velocity`` (float):  [Read-Write] The maximum velocity to allow for extrapolation of bone scales. Smaller values may help prevent the pose
      breaking during blending but too small values can make the blend less smooth.
    - ``maximum_translation_velocity`` (float):  [Read-Write] The maximum velocity to allow for extrapolation of bone translations in centimeters per second. Smaller values
      may help prevent the pose breaking during blending but too small values can make the blend less smooth.
    - ``reset_on_becoming_relevant`` (bool):  [Read-Write] Clear any active blends if we just became relevant, to avoid carrying over undesired blends.
    - ``show_extrapolations`` (bool):  [Read-Write] This setting can be used to show what the extrapolation of the animation looks like.
    - ``source`` (PoseLink):  [Read-Write] Input Pose
    """
    def __init__(self) -> None:
        ...

class AnimNode_Inertialization(AnimNode_Base):
    r"""
    Anim Node Inertialization
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_Inertialization.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_blend_profile`` (BlendProfile):  [Read-Write] Optional default blend profile to use when no blend profile is supplied with the inertialization request
    - ``filtered_bones`` (Array[BoneReference]):  [Read-Write] List of bones that should not use inertial blending. These bones will change instantly when the animation switches.
    - ``filtered_curves`` (Array[Name]):  [Read-Write] List of curves that should not use inertial blending. These curves will instantly change when inertialization begins.
    - ``forward_requests_through_skipped_cached_pose_nodes`` (bool):  [Read-Write] When enabled this option will forward inertialization requests through any downstream UseCachedPose nodes which
      have had their update skipped (e.g. because they have already been updated in another location). This can be
      useful in the case where the same cached pose is used in multiple places, and having an inertialization request
      that goes with it caught in only one of those places would create popping.
    - ``preallocate_memory`` (bool):  [Read-Write]
      deprecated: Preallocate Memory has been deprecated.
    - ``reset_on_becoming_relevant`` (bool):  [Read-Write] Clear any active blends if we just became relevant, to avoid carrying over undesired blends.
    - ``source`` (PoseLink):  [Read-Write]
    """
    def __init__(self) -> None:
        ...
    @property
    def preallocate_memory(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: Preallocate Memory has been deprecated.
        """
        ...
    @preallocate_memory.setter
    def preallocate_memory(self, value: bool) -> None:
        ...

class AnimNode_CustomProperty(AnimNode_Base):
    r"""
    Custom property node that you'd like to expand pin by reflecting internal instance (we call TargetInstance here)
    
     Used by sub anim instance or control rig node
        where you have internal instance and would like to reflect to AnimNode as a pin
    
     To make pin working, you need storage inside of AnimInstance (SourceProperties/SourcePropertyNames)
     So this creates storage inside of AnimInstance with the unique custom property name
        and it copies to the actually TargetInstance here to allow the information be transferred in runtime (DestProperties/DestPropertyNames)
    
     TargetInstance - UObject derived instance that has certain dest properties
     Source - AnimInstance's copy properties that is used to store the data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_CustomProperty.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_LinkedAnimGraph(AnimNode_CustomProperty):
    r"""
    Anim Node Linked Anim Graph
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_LinkedAnimGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``instance_class`` (type(Class)):  [Read-Write] The class spawned for this linked instance
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether named notifies will be propagated from this linked instance to other instances (outer or other linked instances)
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether named notifies will be received by this linked instance from other instances (outer or other linked instances)
    """
    def __init__(self) -> None:
        ...

class AnimNode_SubInstance(AnimNode_LinkedAnimGraph):
    r"""
    deprecated: 'AnimNode_SubInstance' was renamed to 'AnimNode_LinkedAnimGraph'.
    """
    def __init__(self) -> None:
        ...

class AnimNode_LinkedAnimLayer(AnimNode_LinkedAnimGraph):
    r"""
    Anim Node Linked Anim Layer
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_LinkedAnimLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``instance_class`` (type(Class)):  [Read-Write] The class spawned for this linked instance
    - ``layer`` (Name):  [Read-Write] The layer in the interface to use
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether named notifies will be propagated from this linked instance to other instances (outer or other linked instances)
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether named notifies will be received by this linked instance from other instances (outer or other linked instances)
    """
    def __init__(self) -> None:
        ...

class AnimNode_Layer(AnimNode_LinkedAnimLayer):
    r"""
    deprecated: 'AnimNode_Layer' was renamed to 'AnimNode_LinkedAnimLayer'.
    """
    def __init__(self) -> None:
        ...

class AnimNode_SaveCachedPose(AnimNode_Base):
    r"""
    namespace UE::Anim
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_SaveCachedPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``pose`` (PoseLink):  [Read-Write]
    """
    def __init__(self, pose: PoseLink = []) -> None:
        ...
    @property
    def pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: PoseLink) -> None:
        ...

class AnimNode_SequencePlayerBase(AnimNode_AssetPlayerBase):
    r"""
    Sequence player node. Not instantiated directly, use FAnimNode_SequencePlayer or FAnimNode_SequencePlayer_Standalone
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_SequencePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000) -> None:
        ...

class InputScaleBiasClampState(StructBase):
    r"""
    Mutable state struct to be used with FInputScaleBiasClampConstants
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputScaleBias.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_SequencePlayer(AnimNode_SequencePlayerBase):
    r"""
    Sequence player node that can be used with constant folding
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_SequencePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group).
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this node can assume within the group (ignored if GroupName is not set)
    - ``ignore_for_relevancy_test`` (bool):  [Read-Write] If true, "Relevant anim" nodes that look for the highest weighted animation in a state will ignore this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``loop_animation`` (bool):  [Read-Write] Should the animation loop back to the start when it reaches the end?
    - ``method`` (AnimSyncMethod):  [Read-Write] How this node will synchronize with other animations.
    - ``play_rate`` (float):  [Read-Write] The play rate multiplier. Can be negative, which will cause the animation to play in reverse.
    - ``play_rate_basis`` (float):  [Read-Write] The Basis in which the PlayRate is expressed in. This is used to rescale PlayRate inputs.
      For example a Basis of 100 means that the PlayRate input will be divided by 100.
    - ``play_rate_scale_bias_clamp_constants`` (InputScaleBiasClampConstants):  [Read-Write] Additional scaling, offsetting and clamping of PlayRate input.
      Performed after PlayRateBasis.
    - ``sequence`` (AnimSequenceBase):  [Read-Write] The animation sequence asset to play
    - ``start_from_matching_pose`` (bool):  [Read-Write] Use pose matching to choose the start position. Requires experimental PoseSearch plugin.
    - ``start_position`` (float):  [Read-Write] The start position between 0 and the length of the sequence to use when initializing. When looping, play will still jump back to the beginning when reaching the end.
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000) -> None:
        ...

class InputScaleBiasClampConstants(StructBase):
    r"""
    Input Scale Bias Clamp Constants
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputScaleBias.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bias`` (float):  [Read-Write]
    - ``clamp_max`` (float):  [Read-Write]
    - ``clamp_min`` (float):  [Read-Write]
    - ``clamp_result`` (bool):  [Read-Write]
    - ``interp_result`` (bool):  [Read-Write]
    - ``interp_speed_decreasing`` (float):  [Read-Write]
    - ``interp_speed_increasing`` (float):  [Read-Write]
    - ``map_range`` (bool):  [Read-Write]
    - ``out_range`` (InputRange):  [Read-Write]
    - ``range`` (InputRange):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    """
    def __init__(self, map_range: bool = False, clamp_result: bool = False, interp_result: bool = False, range: InputRange = [0.000000, 1.000000], out_range: InputRange = [0.000000, 1.000000], scale: float = 0.000000, bias: float = 0.000000, clamp_min: float = 0.000000, clamp_max: float = 0.000000, interp_speed_increasing: float = 0.000000, interp_speed_decreasing: float = 0.000000) -> None:
        ...
    @property
    def map_range(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @map_range.setter
    def map_range(self, value: bool) -> None:
        ...
    @property
    def clamp_result(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @clamp_result.setter
    def clamp_result(self, value: bool) -> None:
        ...
    @property
    def interp_result(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @interp_result.setter
    def interp_result(self, value: bool) -> None:
        ...
    @property
    def range(self) -> InputRange:
        r"""
        (InputRange):  [Read-Write]
        """
        ...
    @range.setter
    def range(self, value: InputRange) -> None:
        ...
    @property
    def out_range(self) -> InputRange:
        r"""
        (InputRange):  [Read-Write]
        """
        ...
    @out_range.setter
    def out_range(self, value: InputRange) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bias(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @bias.setter
    def bias(self, value: float) -> None:
        ...
    @property
    def clamp_min(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_min.setter
    def clamp_min(self, value: float) -> None:
        ...
    @property
    def clamp_max(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_max.setter
    def clamp_max(self, value: float) -> None:
        ...
    @property
    def interp_speed_increasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_increasing.setter
    def interp_speed_increasing(self, value: float) -> None:
        ...
    @property
    def interp_speed_decreasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_decreasing.setter
    def interp_speed_decreasing(self, value: float) -> None:
        ...

class AnimNode_SequencePlayer_Standalone(AnimNode_SequencePlayerBase):
    r"""
    Sequence player node that can be used standalone (without constant folding)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_SequencePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_weight`` (float):  [Read-Write] Last encountered blendweight for this node
    - ``group_name`` (Name):  [Read-Write] The group name that we synchronize with (NAME_None if it is not part of any group).
    - ``group_role`` (AnimGroupRole):  [Read-Write] The role this node can assume within the group (ignored if GroupName is not set)
    - ``ignore_for_relevancy_test`` (bool):  [Read-Write] If true, "Relevant anim" nodes that look for the highest weighted animation in a state will ignore this node
    - ``internal_time_accumulator`` (float):  [Read-Write] Accumulated time used to reference the asset in this node
    - ``loop_animation`` (bool):  [Read-Write] Should the animation loop back to the start when it reaches the end?
    - ``method`` (AnimSyncMethod):  [Read-Write] How this node will synchronize with other animations.
    - ``play_rate`` (float):  [Read-Write] The play rate multiplier. Can be negative, which will cause the animation to play in reverse.
    - ``play_rate_basis`` (float):  [Read-Write] The Basis in which the PlayRate is expressed in. This is used to rescale PlayRate inputs.
      For example a Basis of 100 means that the PlayRate input will be divided by 100.
    - ``play_rate_scale_bias_clamp_constants`` (InputScaleBiasClampConstants):  [Read-Write] Additional scaling, offsetting and clamping of PlayRate input.
      Performed after PlayRateBasis.
    - ``sequence`` (AnimSequenceBase):  [Read-Write] The animation sequence asset to play
    - ``start_from_matching_pose`` (bool):  [Read-Write] Use pose matching to choose the start position. Requires experimental PoseSearch plugin.
    - ``start_position`` (float):  [Read-Write] The start position between 0 and the length of the sequence to use when initializing. When looping, play will still jump back to the beginning when reaching the end.
    """
    def __init__(self, blend_weight: float = 0.000000, internal_time_accumulator: float = 0.000000) -> None:
        ...

class AnimNode_StateResult(AnimNode_Root):
    r"""
    Root node of an state machine state (sink node).
    We dont use AnimNode_Root to let us distinguish these nodes in the property list at link time.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_StateResult.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``group`` (Name):  [Read-Write]
      deprecated: Please, use LayerGroup
    - ``result`` (PoseLink):  [Read-Write]
    """
    def __init__(self, result: PoseLink = []) -> None:
        ...

class AnimNode_TransitionPoseEvaluator(AnimNode_Base):
    r"""
    Animation data node for state machine transitions.
    Can be set to supply either the animation data from the transition source (From State) or the transition destination (To State).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_TransitionPoseEvaluator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_source`` (EvaluatorDataSource):  [Read-Write]
    - ``evaluator_mode`` (EvaluatorMode):  [Read-Write]
    - ``frames_to_cache_pose`` (int32):  [Read-Write]
    """
    def __init__(self, frames_to_cache_pose: int = 0, data_source: EvaluatorDataSource = EvaluatorDataSource.EDS_SOURCE_POSE, evaluator_mode: EvaluatorMode = EvaluatorMode.EM_STANDARD) -> None:
        ...
    @property
    def frames_to_cache_pose(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @frames_to_cache_pose.setter
    def frames_to_cache_pose(self, value: int) -> None:
        ...
    @property
    def data_source(self) -> EvaluatorDataSource:
        r"""
        (EvaluatorDataSource):  [Read-Write]
        """
        ...
    @data_source.setter
    def data_source(self, value: EvaluatorDataSource) -> None:
        ...
    @property
    def evaluator_mode(self) -> EvaluatorMode:
        r"""
        (EvaluatorMode):  [Read-Write]
        """
        ...
    @evaluator_mode.setter
    def evaluator_mode(self, value: EvaluatorMode) -> None:
        ...

class AnimNode_TransitionResult(AnimNode_Base):
    r"""
    Root node of a state machine transition graph
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_TransitionResult.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_enter_transition`` (bool):  [Read-Write]
    """
    def __init__(self, can_enter_transition: bool = False) -> None:
        ...
    @property
    def can_enter_transition(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @can_enter_transition.setter
    def can_enter_transition(self, value: bool) -> None:
        ...

class AnimNotifyEventReference(StructBase):
    r"""
    Anim Notify Event Reference
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotifyQueue.h
    
    """
    def __init__(self) -> None:
        ...
    def notify_state_reached_end(self) -> bool:
        r"""
        x.notify_state_reached_end() -> bool
        Get whether the notify state reached the end (was not cancelled)
        
        Returns:
            bool:
        """
        ...
    def get_current_animation_time_ratio(self) -> float:
        r"""
        x.get_current_animation_time_ratio() -> float
        Get the current anim notify time as a ratio (0 -> 1) through the animation for when this notify was fired
        
        Returns:
            float: the time as a ratio (0 -> 1) through the animation for when this notify was fired
        """
        ...
    def get_current_animation_time(self) -> float:
        r"""
        x.get_current_animation_time() -> float
        Get the current anim notify time in seconds for when this notify was fired
        
        Returns:
            float: the time in seconds through the current animation for when this notify was fired
        """
        ...
    def get_current_animation_notify_state_time_ratio(self) -> float:
        r"""
        x.get_current_animation_notify_state_time_ratio() -> float
        Gets the current time as a ratio (0 -> 1) relative to the start of the notify state
        
        Returns:
            float: the current time as a ratio (0 -> 1) relative to the start of the notify state
        """
        ...
    def get_current_animation_notify_state_time(self) -> float:
        r"""
        x.get_current_animation_notify_state_time() -> float
        Gets the current time in seconds relative to the start of the notify state, clamped to the range of the notify
        state
        
        Returns:
            float: the current time in seconds relative to the start of the notify state, clamped to the range of the notify state
        """
        ...

class AnimNode_SingleNode(AnimNode_Base):
    r"""
    Local anim node for extensible processing.
    Cant be used outside of this context as it has no graph node counterpart
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimSingleNodeInstanceProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source_pose`` (PoseLink):  [Read-Write]
    """
    def __init__(self, source_pose: PoseLink = []) -> None:
        ...
    @property
    def source_pose(self) -> PoseLink:
        r"""
        (PoseLink):  [Read-Write]
        """
        ...
    @source_pose.setter
    def source_pose(self, value: PoseLink) -> None:
        ...

class CachedAnimStateData(StructBase):
    r"""
    This file contains a number of helper structures that can be used to process state-machine-
    related data in C++. This includes relevancy, state weights, animation time etc.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CachedAnimData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``state_machine_name`` (Name):  [Read-Write] Name of StateMachine State is in
    - ``state_name`` (Name):  [Read-Write] Name of State to Cache
    """
    def __init__(self, state_machine_name: Name = "None", state_name: Name = "None") -> None:
        ...
    @property
    def state_machine_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of StateMachine State is in
        """
        ...
    @property
    def state_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of State to Cache
        """
        ...

class CachedAnimStateArray(StructBase):
    r"""
    Cached Anim State Array
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CachedAnimData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``states`` (Array[CachedAnimStateData]):  [Read-Write] Array of states
    """
    def __init__(self, states: Array[CachedAnimStateData] = []) -> None:
        ...
    @property
    def states(self) -> Array[CachedAnimStateData]:
        r"""
        (Array[CachedAnimStateData]):  [Read-Only] Array of states
        """
        ...

class CachedAnimAssetPlayerData(StructBase):
    r"""
    Cached Anim Asset Player Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CachedAnimData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``state_machine_name`` (Name):  [Read-Write] Name of StateMachine State is in
    - ``state_name`` (Name):  [Read-Write] Name of State to Cache
    """
    def __init__(self, state_machine_name: Name = "None", state_name: Name = "None") -> None:
        ...
    @property
    def state_machine_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of StateMachine State is in
        """
        ...
    @property
    def state_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of State to Cache
        """
        ...

class CachedAnimRelevancyData(StructBase):
    r"""
    Cached Anim Relevancy Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CachedAnimData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``state_machine_name`` (Name):  [Read-Write] Name of StateMachine State is in
    - ``state_name`` (Name):  [Read-Write] Name of State to Cache
    """
    def __init__(self, state_machine_name: Name = "None", state_name: Name = "None") -> None:
        ...
    @property
    def state_machine_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of StateMachine State is in
        """
        ...
    @property
    def state_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of State to Cache
        """
        ...

class CachedAnimTransitionData(StructBase):
    r"""
    Cached Anim Transition Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CachedAnimData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``from_state_name`` (Name):  [Read-Write] Name of From State to Cache
    - ``state_machine_name`` (Name):  [Read-Write] Name of StateMachine State is in
    - ``to_state_name`` (Name):  [Read-Write] Name of To State to Cache
    """
    def __init__(self, state_machine_name: Name = "None", from_state_name: Name = "None", to_state_name: Name = "None") -> None:
        ...
    @property
    def state_machine_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of StateMachine State is in
        """
        ...
    @property
    def from_state_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of From State to Cache
        """
        ...
    @property
    def to_state_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of To State to Cache
        """
        ...

class NamedCurveValue(StructBase):
    r"""
    Name/value pair for retrieving curve values
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveSourceInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] The name of the curve
    - ``value`` (float):  [Read-Write] The value of the curve
    """
    def __init__(self, name: Name = "None", value: float = 0.000000) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the curve
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write] The value of the curve
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class InputClampConstants(StructBase):
    r"""
    Input modifier with clamping and interpolation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputScaleBias.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clamp_max`` (float):  [Read-Write]
    - ``clamp_min`` (float):  [Read-Write]
    - ``clamp_result`` (bool):  [Read-Write]
    - ``interp_result`` (bool):  [Read-Write]
    - ``interp_speed_decreasing`` (float):  [Read-Write]
    - ``interp_speed_increasing`` (float):  [Read-Write]
    """
    def __init__(self, clamp_result: bool = False, interp_result: bool = False, clamp_min: float = 0.000000, clamp_max: float = 0.000000, interp_speed_increasing: float = 0.000000, interp_speed_decreasing: float = 0.000000) -> None:
        ...
    @property
    def clamp_result(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @clamp_result.setter
    def clamp_result(self, value: bool) -> None:
        ...
    @property
    def interp_result(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @interp_result.setter
    def interp_result(self, value: bool) -> None:
        ...
    @property
    def clamp_min(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_min.setter
    def clamp_min(self, value: float) -> None:
        ...
    @property
    def clamp_max(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_max.setter
    def clamp_max(self, value: float) -> None:
        ...
    @property
    def interp_speed_increasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_increasing.setter
    def interp_speed_increasing(self, value: float) -> None:
        ...
    @property
    def interp_speed_decreasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_decreasing.setter
    def interp_speed_decreasing(self, value: float) -> None:
        ...

class InputClampState(StructBase):
    r"""
    Mutable state struct to be used with FInputClampConstants
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputScaleBias.h
    
    """
    def __init__(self) -> None:
        ...

class MirrorTableRow(TableRowBase):
    r"""
    Base Mirror Table containing all data required by the animation mirroring system.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MirrorDataTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``mirror_entry_type`` (MirrorRowType):  [Read-Write]
    - ``mirrored_name`` (Name):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    """
    def __init__(self, name: Name = "None", mirrored_name: Name = "None", mirror_entry_type: MirrorRowType = MirrorRowType.BONE) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def mirrored_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def mirror_entry_type(self) -> MirrorRowType:
        r"""
        (MirrorRowType):  [Read-Only]
        """
        ...

class TrajectorySample(StructBase):
    r"""
    Trajectory Sample
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MotionTrajectoryTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accumulated_seconds`` (float):  [Read-Write] The relative accumulated time that this sample is associated with
      Zero value for instantaneous, negative values for the past, and positive values for the future
    - ``linear_velocity`` (Vector):  [Read-Write] Linear velocity relative to the sampled in-motion object
    - ``transform`` (Transform):  [Read-Write] Position relative to the sampled in-motion object
    """
    def __init__(self, accumulated_seconds: float = 0.000000, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], linear_velocity: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def accumulated_seconds(self) -> float:
        r"""
        (float):  [Read-Write] The relative accumulated time that this sample is associated with
        Zero value for instantaneous, negative values for the past, and positive values for the future
        """
        ...
    @accumulated_seconds.setter
    def accumulated_seconds(self, value: float) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Position relative to the sampled in-motion object
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def linear_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Linear velocity relative to the sampled in-motion object
        """
        ...
    @linear_velocity.setter
    def linear_velocity(self, value: Vector) -> None:
        ...

class TrajectorySampleRange(StructBase):
    r"""
    A container of ordered trajectory samples and associated sampling rate
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MotionTrajectoryTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``samples`` (Array[TrajectorySample]):  [Read-Write] Linearly ordered container for past, present, and future trajectory samples
    """
    def __init__(self, samples: Array[TrajectorySample] = []) -> None:
        ...
    @property
    def samples(self) -> Array[TrajectorySample]:
        r"""
        (Array[TrajectorySample]):  [Read-Write] Linearly ordered container for past, present, and future trajectory samples
        """
        ...
    @samples.setter
    def samples(self, value: Array[TrajectorySample]) -> None:
        ...

class AssetCompileData(StructBase):
    r"""
    Asset Compile Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AssetCompilingManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset`` (Object):  [Read-Write] Object being compiled
    """
    def __init__(self, asset: Object = None) -> None:
        ...
    @property
    def asset(self) -> Object:
        r"""
        (Object):  [Read-Write] Object being compiled
        """
        ...
    @asset.setter
    def asset(self, value: Object) -> None:
        ...

class AssetManagerSearchRules(StructBase):
    r"""
    Rules for how to scan the asset registry for assets matching path and type descriptions
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AssetManagerTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_base_class`` (type(Class)):  [Read-Write] Assets must inherit from this class, for blueprints this should be the instance base class
    - ``asset_scan_paths`` (Array[str]):  [Read-Write] List of top-level directories and specific assets to search, must be paths starting with /, directories should not have a trailing /
    - ``exclude_patterns`` (Array[str]):  [Read-Write] Optional list of exclude wildcard patterns that can use *, if any of these match it will be excluded
    - ``force_synchronous_scan`` (bool):  [Read-Write] True if this should force a synchronous scan of the disk even if an async scan is in progress
    - ``has_blueprint_classes`` (bool):  [Read-Write] True if scanning for blueprints, false for all other assets
    - ``include_patterns`` (Array[str]):  [Read-Write] Optional list of include wildcard patterns using * that will get matched against full package path. If there are any at least one of these must match
    - ``skip_manager_include_check`` (bool):  [Read-Write] True if this test should skip the ShouldIncludeInAssetSearch function on AssetManager
    - ``skip_virtual_path_expansion`` (bool):  [Read-Write] True if AssetScanPaths are real paths that do not need expansion
    """
    def __init__(self, asset_scan_paths: Array[str] = [], include_patterns: Array[str] = [], exclude_patterns: Array[str] = [], asset_base_class: Class = None, has_blueprint_classes: bool = False, force_synchronous_scan: bool = False, skip_virtual_path_expansion: bool = False, skip_manager_include_check: bool = False) -> None:
        ...
    @property
    def asset_scan_paths(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] List of top-level directories and specific assets to search, must be paths starting with /, directories should not have a trailing /
        """
        ...
    @asset_scan_paths.setter
    def asset_scan_paths(self, value: Array[str]) -> None:
        ...
    @property
    def include_patterns(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Optional list of include wildcard patterns using * that will get matched against full package path. If there are any at least one of these must match
        """
        ...
    @include_patterns.setter
    def include_patterns(self, value: Array[str]) -> None:
        ...
    @property
    def exclude_patterns(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Optional list of exclude wildcard patterns that can use *, if any of these match it will be excluded
        """
        ...
    @exclude_patterns.setter
    def exclude_patterns(self, value: Array[str]) -> None:
        ...
    @property
    def asset_base_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Assets must inherit from this class, for blueprints this should be the instance base class
        """
        ...
    @asset_base_class.setter
    def asset_base_class(self, value: Class) -> None:
        ...
    @property
    def has_blueprint_classes(self) -> bool:
        r"""
        (bool):  [Read-Write] True if scanning for blueprints, false for all other assets
        """
        ...
    @has_blueprint_classes.setter
    def has_blueprint_classes(self, value: bool) -> None:
        ...
    @property
    def force_synchronous_scan(self) -> bool:
        r"""
        (bool):  [Read-Write] True if this should force a synchronous scan of the disk even if an async scan is in progress
        """
        ...
    @force_synchronous_scan.setter
    def force_synchronous_scan(self, value: bool) -> None:
        ...
    @property
    def skip_virtual_path_expansion(self) -> bool:
        r"""
        (bool):  [Read-Write] True if AssetScanPaths are real paths that do not need expansion
        """
        ...
    @skip_virtual_path_expansion.setter
    def skip_virtual_path_expansion(self, value: bool) -> None:
        ...
    @property
    def skip_manager_include_check(self) -> bool:
        r"""
        (bool):  [Read-Write] True if this test should skip the ShouldIncludeInAssetSearch function on AssetManager
        """
        ...
    @skip_manager_include_check.setter
    def skip_manager_include_check(self, value: bool) -> None:
        ...

class AudioVolumeSubmixSendSettings(StructBase):
    r"""
    Struct to determine dynamic submix send data for use with audio volumes.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``listener_location_state`` (AudioVolumeLocationState):  [Read-Write] The state the listener needs to be in, relative to the audio volume, for this submix send list to be used for a given sound
    - ``submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] Submix send array for sounds that are in the ListenerLocationState at the same time as the listener
    """
    def __init__(self, listener_location_state: AudioVolumeLocationState = AudioVolumeLocationState.INSIDE_THE_VOLUME, submix_sends: Array[SoundSubmixSendInfo] = []) -> None:
        ...
    @property
    def listener_location_state(self) -> AudioVolumeLocationState:
        r"""
        (AudioVolumeLocationState):  [Read-Write] The state the listener needs to be in, relative to the audio volume, for this submix send list to be used for a given sound
        """
        ...
    @listener_location_state.setter
    def listener_location_state(self, value: AudioVolumeLocationState) -> None:
        ...
    @property
    def submix_sends(self) -> Array[SoundSubmixSendInfo]:
        r"""
        (Array[SoundSubmixSendInfo]):  [Read-Write] Submix send array for sounds that are in the ListenerLocationState at the same time as the listener
        """
        ...
    @submix_sends.setter
    def submix_sends(self, value: Array[SoundSubmixSendInfo]) -> None:
        ...

class SoundSubmixSendInfo(SoundSubmixSendInfoBase):
    r"""
    Sound Submix Send Info
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmixSend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``custom_send_level_curve`` (RuntimeFloatCurve):  [Read-Write] The custom reverb send curve to use for distance-based send level.
    - ``disable_manual_send_clamp`` (bool):  [Read-Write] Whether to disable the 0-1 clamp for manual SendLevel control
    - ``max_send_distance`` (float):  [Read-Write] The max distance to send to the master
    - ``max_send_level`` (float):  [Read-Write] The amount to send to master when sound is located at a distance equal to value specified in the max send distance.
    - ``min_send_distance`` (float):  [Read-Write] The min distance to send to the master
    - ``min_send_level`` (float):  [Read-Write] The amount to send to master when sound is located at a distance equal to value specified in the min send distance.
    - ``send_level`` (float):  [Read-Write] The amount of audio to send
    - ``send_level_control_method`` (SendLevelControlMethod):  [Read-Write] Manual: Use Send Level only
      Linear: Interpolate between Min and Max Send Levels based on listener distance (between Distance Min and Distance Max)
      Custom Curve: Use the float curve to map Send Level to distance (0.0-1.0 on curve maps to Distance Min - Distance Max)
    - ``send_stage`` (SubmixSendStage):  [Read-Write] Defines at what mix stage the send should happen.
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] The submix to send the audio to
    """
    def __init__(self, send_level_control_method: SendLevelControlMethod = SendLevelControlMethod.LINEAR, sound_submix: SoundSubmixBase = None, send_level: float = 0.000000, disable_manual_send_clamp: bool = False, min_send_level: float = 0.000000, max_send_level: float = 0.000000, min_send_distance: float = 0.000000, max_send_distance: float = 0.000000, custom_send_level_curve: RuntimeFloatCurve = [], send_stage: SubmixSendStage = SubmixSendStage.POST_DISTANCE_ATTENUATION) -> None:
        ...
    @property
    def send_stage(self) -> SubmixSendStage:
        r"""
        (SubmixSendStage):  [Read-Write] Defines at what mix stage the send should happen.
        """
        ...
    @send_stage.setter
    def send_stage(self, value: SubmixSendStage) -> None:
        ...

class AudioVolumeSubmixOverrideSettings(StructBase):
    r"""
    Audio Volume Submix Override Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``crossfade_time`` (float):  [Read-Write] The amount of time to crossfade to the override for the submix chain
    - ``submix`` (SoundSubmix):  [Read-Write] The submix to override the effect chain of
    - ``submix_effect_chain`` (Array[SoundEffectSubmixPreset]):  [Read-Write] The submix effect chain to override
    """
    def __init__(self, submix: SoundSubmix = None, submix_effect_chain: Array[SoundEffectSubmixPreset] = [], crossfade_time: float = 0.000000) -> None:
        ...
    @property
    def submix(self) -> SoundSubmix:
        r"""
        (SoundSubmix):  [Read-Write] The submix to override the effect chain of
        """
        ...
    @submix.setter
    def submix(self, value: SoundSubmix) -> None:
        ...
    @property
    def submix_effect_chain(self) -> Array[SoundEffectSubmixPreset]:
        r"""
        (Array[SoundEffectSubmixPreset]):  [Read-Only] The submix effect chain to override
        """
        ...
    @property
    def crossfade_time(self) -> float:
        r"""
        (float):  [Read-Only] The amount of time to crossfade to the override for the submix chain
        """
        ...

class InteriorSettings(StructBase):
    r"""
    Struct encapsulating settings for interior areas.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``exterior_lpf`` (float):  [Read-Write] The desired LPF frequency cutoff in hertz of sounds outside the volume when the player is inside the volume
    - ``exterior_lpf_time`` (float):  [Read-Write] The time over which to interpolate from the current LPF to the desired LPF of sounds outside the volume when the player enters the volume
    - ``exterior_time`` (float):  [Read-Write] The time over which to interpolate from the current volume to the desired volume of sounds outside the volume when the player enters the volume
    - ``exterior_volume`` (float):  [Read-Write] The desired volume of sounds outside the volume when the player is inside the volume
    - ``interior_lpf`` (float):  [Read-Write] The desired LPF frequency cutoff in hertz of sounds inside the volume when the player is outside the volume
    - ``interior_lpf_time`` (float):  [Read-Write] The time over which to interpolate from the current LPF to the desired LPF of sounds inside the volume when the player exits the volume
    - ``interior_time`` (float):  [Read-Write] The time over which to interpolate from the current volume to the desired volume of sounds inside the volume when the player exits the volume
    - ``interior_volume`` (float):  [Read-Write] The desired volume of sounds inside the volume when the player is outside the volume
    """
    def __init__(self, exterior_volume: float = 0.000000, exterior_time: float = 0.000000, exterior_lpf: float = 0.000000, exterior_lpf_time: float = 0.000000, interior_volume: float = 0.000000, interior_time: float = 0.000000, interior_lpf: float = 0.000000, interior_lpf_time: float = 0.000000) -> None:
        ...
    @property
    def exterior_volume(self) -> float:
        r"""
        (float):  [Read-Write] The desired volume of sounds outside the volume when the player is inside the volume
        """
        ...
    @exterior_volume.setter
    def exterior_volume(self, value: float) -> None:
        ...
    @property
    def exterior_time(self) -> float:
        r"""
        (float):  [Read-Write] The time over which to interpolate from the current volume to the desired volume of sounds outside the volume when the player enters the volume
        """
        ...
    @exterior_time.setter
    def exterior_time(self, value: float) -> None:
        ...
    @property
    def exterior_lpf(self) -> float:
        r"""
        (float):  [Read-Write] The desired LPF frequency cutoff in hertz of sounds outside the volume when the player is inside the volume
        """
        ...
    @exterior_lpf.setter
    def exterior_lpf(self, value: float) -> None:
        ...
    @property
    def exterior_lpf_time(self) -> float:
        r"""
        (float):  [Read-Write] The time over which to interpolate from the current LPF to the desired LPF of sounds outside the volume when the player enters the volume
        """
        ...
    @exterior_lpf_time.setter
    def exterior_lpf_time(self, value: float) -> None:
        ...
    @property
    def interior_volume(self) -> float:
        r"""
        (float):  [Read-Write] The desired volume of sounds inside the volume when the player is outside the volume
        """
        ...
    @interior_volume.setter
    def interior_volume(self, value: float) -> None:
        ...
    @property
    def interior_time(self) -> float:
        r"""
        (float):  [Read-Write] The time over which to interpolate from the current volume to the desired volume of sounds inside the volume when the player exits the volume
        """
        ...
    @interior_time.setter
    def interior_time(self, value: float) -> None:
        ...
    @property
    def interior_lpf(self) -> float:
        r"""
        (float):  [Read-Write] The desired LPF frequency cutoff in hertz of sounds inside the volume when the player is outside the volume
        """
        ...
    @interior_lpf.setter
    def interior_lpf(self, value: float) -> None:
        ...
    @property
    def interior_lpf_time(self) -> float:
        r"""
        (float):  [Read-Write] The time over which to interpolate from the current LPF to the desired LPF of sounds inside the volume when the player exits the volume
        """
        ...
    @interior_lpf_time.setter
    def interior_lpf_time(self, value: float) -> None:
        ...

class CameraLensInterfaceClassSupport(StructBase):
    r"""
    Wrapper type for validation that the specfied subclass in fact does implement the desired interface!
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraLensEffectInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``class_`` (type(Class)):  [Read-Write] The class to spawn/reference. Must implement CameraLensEffectInterface!
    """
    def __init__(self) -> None:
        ...

class CameraShakePatternStartParams(StructBase):
    r"""
    Parameters for starting a camera shake pattern.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration_override`` (float):  [Read-Write] An optional override for the camera shake's duration
    - ``is_restarting`` (bool):  [Read-Write] Whether the camera shake is restarting while playing
    - ``override_duration`` (bool):  [Read-Write] Whether the camera shake's duration is overriden (see DurationOverride)
    """
    def __init__(self, is_restarting: bool = False, override_duration: bool = False, duration_override: float = 0.000000) -> None:
        ...
    @property
    def is_restarting(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the camera shake is restarting while playing
        """
        ...
    @is_restarting.setter
    def is_restarting(self, value: bool) -> None:
        ...
    @property
    def override_duration(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the camera shake's duration is overriden (see DurationOverride)
        """
        ...
    @override_duration.setter
    def override_duration(self, value: bool) -> None:
        ...
    @property
    def duration_override(self) -> float:
        r"""
        (float):  [Read-Write] An optional override for the camera shake's duration
        """
        ...
    @duration_override.setter
    def duration_override(self, value: float) -> None:
        ...

class CameraShakeStartParams(CameraShakePatternStartParams):
    r"""
    deprecated: 'CameraShakeStartParams' was renamed to 'CameraShakePatternStartParams'.
    """
    def __init__(self, is_restarting: bool = False, override_duration: bool = False, duration_override: float = 0.000000) -> None:
        ...

class CameraShakePatternUpdateParams(StructBase):
    r"""
    Parameters for updating a camera shake pattern.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delta_time`` (float):  [Read-Write] The time elapsed since last update
    - ``dynamic_scale`` (float):  [Read-Write] The dynamic scale being passed down from the camera manger for the next update
    - ``pov`` (MinimalViewInfo):  [Read-Write] The current view that this camera shake should modify
    - ``shake_scale`` (float):  [Read-Write] The base scale for this shake
    """
    def __init__(self, delta_time: float = 0.000000, shake_scale: float = 0.000000, dynamic_scale: float = 0.000000, pov: MinimalViewInfo = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], 90.000000, 512.000000, True, 0.000000, False, False, 0.000000, 2097152.000000, -1.000000, 1.333333, False, True, CameraProjectionMode.PERSPECTIVE, 0.000000, [], [0.000000, 0.000000]]) -> None:
        ...
    @property
    def delta_time(self) -> float:
        r"""
        (float):  [Read-Write] The time elapsed since last update
        """
        ...
    @delta_time.setter
    def delta_time(self, value: float) -> None:
        ...
    @property
    def shake_scale(self) -> float:
        r"""
        (float):  [Read-Write] The base scale for this shake
        """
        ...
    @shake_scale.setter
    def shake_scale(self, value: float) -> None:
        ...
    @property
    def dynamic_scale(self) -> float:
        r"""
        (float):  [Read-Write] The dynamic scale being passed down from the camera manger for the next update
        """
        ...
    @dynamic_scale.setter
    def dynamic_scale(self, value: float) -> None:
        ...
    @property
    def pov(self) -> MinimalViewInfo:
        r"""
        (MinimalViewInfo):  [Read-Write] The current view that this camera shake should modify
        """
        ...
    @pov.setter
    def pov(self, value: MinimalViewInfo) -> None:
        ...

class CameraShakeUpdateParams(CameraShakePatternUpdateParams):
    r"""
    deprecated: 'CameraShakeUpdateParams' was renamed to 'CameraShakePatternUpdateParams'.
    """
    def __init__(self, delta_time: float = 0.000000, shake_scale: float = 0.000000, dynamic_scale: float = 0.000000, pov: MinimalViewInfo = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], 90.000000, 512.000000, True, 0.000000, False, False, 0.000000, 2097152.000000, -1.000000, 1.333333, False, True, CameraProjectionMode.PERSPECTIVE, 0.000000, [], [0.000000, 0.000000]]) -> None:
        ...

class CameraShakePatternScrubParams(StructBase):
    r"""
    Parameters for scrubbing a camera shake.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_time`` (float):  [Read-Write] The time to scrub to
    - ``dynamic_scale`` (float):  [Read-Write] The dynamic scale being passed down from the camera manger for the next update
    - ``pov`` (MinimalViewInfo):  [Read-Write] The current view that this camera shake should modify
    - ``shake_scale`` (float):  [Read-Write] The base scale for this shake
    """
    def __init__(self, absolute_time: float = 0.000000, shake_scale: float = 0.000000, dynamic_scale: float = 0.000000, pov: MinimalViewInfo = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], 90.000000, 512.000000, True, 0.000000, False, False, 0.000000, 2097152.000000, -1.000000, 1.333333, False, True, CameraProjectionMode.PERSPECTIVE, 0.000000, [], [0.000000, 0.000000]]) -> None:
        ...
    @property
    def absolute_time(self) -> float:
        r"""
        (float):  [Read-Write] The time to scrub to
        """
        ...
    @absolute_time.setter
    def absolute_time(self, value: float) -> None:
        ...
    @property
    def shake_scale(self) -> float:
        r"""
        (float):  [Read-Write] The base scale for this shake
        """
        ...
    @shake_scale.setter
    def shake_scale(self, value: float) -> None:
        ...
    @property
    def dynamic_scale(self) -> float:
        r"""
        (float):  [Read-Write] The dynamic scale being passed down from the camera manger for the next update
        """
        ...
    @dynamic_scale.setter
    def dynamic_scale(self, value: float) -> None:
        ...
    @property
    def pov(self) -> MinimalViewInfo:
        r"""
        (MinimalViewInfo):  [Read-Write] The current view that this camera shake should modify
        """
        ...
    @pov.setter
    def pov(self, value: MinimalViewInfo) -> None:
        ...

class CameraShakeScrubParams(CameraShakePatternScrubParams):
    r"""
    deprecated: 'CameraShakeScrubParams' was renamed to 'CameraShakePatternScrubParams'.
    """
    def __init__(self, absolute_time: float = 0.000000, shake_scale: float = 0.000000, dynamic_scale: float = 0.000000, pov: MinimalViewInfo = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], 90.000000, 512.000000, True, 0.000000, False, False, 0.000000, 2097152.000000, -1.000000, 1.333333, False, True, CameraProjectionMode.PERSPECTIVE, 0.000000, [], [0.000000, 0.000000]]) -> None:
        ...

class CameraShakePatternUpdateResult(StructBase):
    r"""
    The result of a camera shake pattern update.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeBase.h
    
    """
    def __init__(self) -> None:
        ...

class CameraShakeUpdateResult(CameraShakePatternUpdateResult):
    r"""
    deprecated: 'CameraShakeUpdateResult' was renamed to 'CameraShakePatternUpdateResult'.
    """
    def __init__(self) -> None:
        ...

class CameraShakePatternStopParams(StructBase):
    r"""
    Parameters for stopping a camera shake.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``immediately`` (bool):  [Read-Write]
    """
    def __init__(self, immediately: bool = False) -> None:
        ...
    @property
    def immediately(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @immediately.setter
    def immediately(self, value: bool) -> None:
        ...

class CameraShakeStopParams(CameraShakePatternStopParams):
    r"""
    deprecated: 'CameraShakeStopParams' was renamed to 'CameraShakePatternStopParams'.
    """
    def __init__(self, immediately: bool = False) -> None:
        ...

class CameraShakeDuration(StructBase):
    r"""
    Camera shake duration.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeBase.h
    
    """
    def __init__(self) -> None:
        ...

class CameraShakeInfo(StructBase):
    r"""
    Information about a camera shake class.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeBase.h
    
    """
    def __init__(self) -> None:
        ...

class FindFloorResult(StructBase):
    r"""
    Data about the floor for walking movement, used by CharacterMovementComponent.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CharacterMovementComponentAsync.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blocking_hit`` (bool):  [Read-Only] True if there was a blocking hit in the floor test that was NOT in initial penetration.
      The HitResult can give more info about other circumstances.
    - ``floor_dist`` (float):  [Read-Only] The distance to the floor, computed from the swept capsule trace.
    - ``hit_result`` (HitResult):  [Read-Only] Hit result of the test that found a floor. Includes more specific data about the point of impact and surface normal at that point.
    - ``line_dist`` (float):  [Read-Only] The distance to the floor, computed from the trace. Only valid if bLineTrace is true.
    - ``line_trace`` (bool):  [Read-Only] True if the hit found a valid walkable floor using a line trace (rather than a sweep test, which happens when the sweep test fails to yield a walkable surface).
    - ``walkable_floor`` (bool):  [Read-Only] True if the hit found a valid walkable floor.
    """
    def __init__(self, blocking_hit: bool = False, walkable_floor: bool = False, line_trace: bool = False, floor_dist: float = 0.000000, line_dist: float = 0.000000, hit_result: HitResult = [False, False, 1.000000, 0.000000, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], None, None, None, "None", "None", 0, 0, 0, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]]) -> None:
        ...
    @property
    def blocking_hit(self) -> bool:
        r"""
        (bool):  [Read-Only] True if there was a blocking hit in the floor test that was NOT in initial penetration.
        The HitResult can give more info about other circumstances.
        """
        ...
    @property
    def walkable_floor(self) -> bool:
        r"""
        (bool):  [Read-Only] True if the hit found a valid walkable floor.
        """
        ...
    @property
    def line_trace(self) -> bool:
        r"""
        (bool):  [Read-Only] True if the hit found a valid walkable floor using a line trace (rather than a sweep test, which happens when the sweep test fails to yield a walkable surface).
        """
        ...
    @property
    def floor_dist(self) -> float:
        r"""
        (float):  [Read-Only] The distance to the floor, computed from the swept capsule trace.
        """
        ...
    @property
    def line_dist(self) -> float:
        r"""
        (float):  [Read-Only] The distance to the floor, computed from the trace. Only valid if bLineTrace is true.
        """
        ...
    @property
    def hit_result(self) -> HitResult:
        r"""
        (HitResult):  [Read-Only] Hit result of the test that found a floor. Includes more specific data about the point of impact and surface normal at that point.
        """
        ...

class LODMappingData(StructBase):
    r"""
    LODMapping Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LODSyncComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``mapping`` (Array[int32]):  [Read-Write]
    """
    def __init__(self, mapping: Array[int] = []) -> None:
        ...
    @property
    def mapping(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write]
        """
        ...
    @mapping.setter
    def mapping(self, value: Array[int]) -> None:
        ...

class ComponentSync(StructBase):
    r"""
    Component Sync
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LODSyncComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``sync_option`` (SyncOption):  [Read-Write]
    """
    def __init__(self, name: Name = "None", sync_option: SyncOption = SyncOption.DRIVE) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def sync_option(self) -> SyncOption:
        r"""
        (SyncOption):  [Read-Write]
        """
        ...
    @sync_option.setter
    def sync_option(self, value: SyncOption) -> None:
        ...

class MaterialSpriteElement(StructBase):
    r"""
    Material Sprite Element
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialBillboardComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_size_x`` (float):  [Read-Write] The base width of the sprite, multiplied with the DistanceToSizeCurve.
    - ``base_size_y`` (float):  [Read-Write] The base height of the sprite, multiplied with the DistanceToSizeCurve.
    - ``distance_to_opacity_curve`` (CurveFloat):  [Read-Write] A curve that maps distance on the X axis to the sprite opacity on the Y axis.
    - ``distance_to_size_curve`` (CurveFloat):  [Read-Write] A curve that maps distance on the X axis to the sprite size on the Y axis.
    - ``material`` (MaterialInterface):  [Read-Write] The material that the sprite is rendered with.
    - ``size_is_in_screen_space`` (bool):  [Read-Write] Whether the size is defined in screen-space or world-space.
    """
    def __init__(self, material: MaterialInterface = None, distance_to_opacity_curve: CurveFloat = None, size_is_in_screen_space: bool = False, base_size_x: float = 0.000000, base_size_y: float = 0.000000, distance_to_size_curve: CurveFloat = None) -> None:
        ...
    @property
    def material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Write] The material that the sprite is rendered with.
        """
        ...
    @material.setter
    def material(self, value: MaterialInterface) -> None:
        ...
    @property
    def distance_to_opacity_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] A curve that maps distance on the X axis to the sprite opacity on the Y axis.
        """
        ...
    @distance_to_opacity_curve.setter
    def distance_to_opacity_curve(self, value: CurveFloat) -> None:
        ...
    @property
    def size_is_in_screen_space(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the size is defined in screen-space or world-space.
        """
        ...
    @size_is_in_screen_space.setter
    def size_is_in_screen_space(self, value: bool) -> None:
        ...
    @property
    def base_size_x(self) -> float:
        r"""
        (float):  [Read-Write] The base width of the sprite, multiplied with the DistanceToSizeCurve.
        """
        ...
    @base_size_x.setter
    def base_size_x(self, value: float) -> None:
        ...
    @property
    def base_size_y(self) -> float:
        r"""
        (float):  [Read-Write] The base height of the sprite, multiplied with the DistanceToSizeCurve.
        """
        ...
    @base_size_y.setter
    def base_size_y(self, value: float) -> None:
        ...
    @property
    def distance_to_size_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] A curve that maps distance on the X axis to the sprite size on the Y axis.
        """
        ...
    @distance_to_size_curve.setter
    def distance_to_size_curve(self, value: CurveFloat) -> None:
        ...

class EngineShowFlagsSetting(StructBase):
    r"""
    Engine Show Flags Setting
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneCaptureComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``show_flag_name`` (str):  [Read-Write]
    """
    def __init__(self, show_flag_name: str = "", enabled: bool = False) -> None:
        ...
    @property
    def show_flag_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @show_flag_name.setter
    def show_flag_name(self, value: str) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class TentDistribution(StructBase):
    r"""
    Tent Distribution
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkyAtmosphereComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``tip_altitude`` (float):  [Read-Write]
    - ``tip_value`` (float):  [Read-Write]
    - ``width`` (float):  [Read-Write]
    """
    def __init__(self, tip_altitude: float = 0.000000, tip_value: float = 0.000000, width: float = 0.000000) -> None:
        ...
    @property
    def tip_altitude(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def tip_value(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def width(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class SplinePoint(StructBase):
    r"""
    Spline Point
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SplineComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``arrive_tangent`` (Vector):  [Read-Write]
    - ``input_key`` (float):  [Read-Write]
    - ``leave_tangent`` (Vector):  [Read-Write]
    - ``position`` (Vector):  [Read-Write]
    - ``rotation`` (Rotator):  [Read-Write]
    - ``scale`` (Vector):  [Read-Write]
    - ``type`` (SplinePointType):  [Read-Write]
    """
    def __init__(self, input_key: float = 0.000000, position: Vector = [0.000000, 0.000000, 0.000000], arrive_tangent: Vector = [0.000000, 0.000000, 0.000000], leave_tangent: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], scale: Vector = [0.000000, 0.000000, 0.000000], type: SplinePointType = SplinePointType.LINEAR) -> None:
        ...
    @property
    def input_key(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @input_key.setter
    def input_key(self, value: float) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...
    @property
    def arrive_tangent(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @arrive_tangent.setter
    def arrive_tangent(self, value: Vector) -> None:
        ...
    @property
    def leave_tangent(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @leave_tangent.setter
    def leave_tangent(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @rotation.setter
    def rotation(self, value: Rotator) -> None:
        ...
    @property
    def scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: Vector) -> None:
        ...
    @property
    def type(self) -> SplinePointType:
        r"""
        (SplinePointType):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: SplinePointType) -> None:
        ...

class CullDistanceSizePair(StructBase):
    r"""
    Helper structure containing size and cull distance pair.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CullDistanceVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cull_distance`` (float):  [Read-Write] Cull distance associated with size.
    - ``size`` (float):  [Read-Write] Size to associate with cull distance.
    """
    def __init__(self, size: float = 0.000000, cull_distance: float = 0.000000) -> None:
        ...
    @property
    def size(self) -> float:
        r"""
        (float):  [Read-Only] Size to associate with cull distance.
        """
        ...
    @property
    def cull_distance(self) -> float:
        r"""
        (float):  [Read-Only] Cull distance associated with size.
        """
        ...

class RuntimeVectorCurve(StructBase):
    r"""
    Runtime Vector Curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``external_curve`` (CurveVector):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class CurveTableRowHandle(StructBase):
    r"""
    Handle to a particular row in a table.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve_table`` (CurveTable):  [Read-Write] Pointer to table we want a row from
    - ``row_name`` (Name):  [Read-Write] Name of row in the table that we want
    """
    def __init__(self, curve_table: CurveTable = None, row_name: Name = "None") -> None:
        ...
    @property
    def curve_table(self) -> CurveTable:
        r"""
        (CurveTable):  [Read-Write] Pointer to table we want a row from
        """
        ...
    @curve_table.setter
    def curve_table(self, value: CurveTable) -> None:
        ...
    @property
    def row_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of row in the table that we want
        """
        ...
    @row_name.setter
    def row_name(self, value: Name) -> None:
        ...

class DataDrivenConsoleVariable(StructBase):
    r"""
    Data Driven Console Variable
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataDrivenCVars.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_value_bool`` (bool):  [Read-Write]
    - ``default_value_float`` (float):  [Read-Write]
    - ``default_value_int`` (int32):  [Read-Write]
    - ``name`` (str):  [Read-Write]
    - ``tool_tip`` (str):  [Read-Write]
    - ``type`` (FDataDrivenCVarType):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class DataTableRowHandle(StructBase):
    r"""
    Handle to a particular row in a table
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_table`` (DataTable):  [Read-Write] Pointer to table we want a row from
    - ``row_name`` (Name):  [Read-Write] Name of row in the table that we want
    """
    def __init__(self, data_table: DataTable = None, row_name: Name = "None") -> None:
        ...
    @property
    def data_table(self) -> DataTable:
        r"""
        (DataTable):  [Read-Write] Pointer to table we want a row from
        """
        ...
    @data_table.setter
    def data_table(self, value: DataTable) -> None:
        ...
    @property
    def row_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of row in the table that we want
        """
        ...
    @row_name.setter
    def row_name(self, value: Name) -> None:
        ...

class DataTableCategoryHandle(StructBase):
    r"""
    Handle to a particular set of rows in a table
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``column_name`` (Name):  [Read-Write] Name of column in the table that we want
    - ``data_table`` (DataTable):  [Read-Write] Pointer to table we want a row from
    - ``row_contents`` (Name):  [Read-Write] Contents of rows in the table that we want
    """
    def __init__(self, data_table: DataTable = None, column_name: Name = "None", row_contents: Name = "None") -> None:
        ...
    @property
    def data_table(self) -> DataTable:
        r"""
        (DataTable):  [Read-Write] Pointer to table we want a row from
        """
        ...
    @data_table.setter
    def data_table(self, value: DataTable) -> None:
        ...
    @property
    def column_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of column in the table that we want
        """
        ...
    @column_name.setter
    def column_name(self, value: Name) -> None:
        ...
    @property
    def row_contents(self) -> Name:
        r"""
        (Name):  [Read-Write] Contents of rows in the table that we want
        """
        ...
    @row_contents.setter
    def row_contents(self, value: Name) -> None:
        ...

class DialogueContext(StructBase):
    r"""
    Dialogue Context
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DialogueTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``speaker`` (DialogueVoice):  [Read-Write] The person speaking the dialogue.
    - ``targets`` (Array[DialogueVoice]):  [Read-Write] The people being spoken to.
    """
    def __init__(self, speaker: DialogueVoice = None, targets: Array[DialogueVoice] = []) -> None:
        ...
    @property
    def speaker(self) -> DialogueVoice:
        r"""
        (DialogueVoice):  [Read-Write] The person speaking the dialogue.
        """
        ...
    @speaker.setter
    def speaker(self, value: DialogueVoice) -> None:
        ...
    @property
    def targets(self) -> Array[DialogueVoice]:
        r"""
        (Array[DialogueVoice]):  [Read-Write] The people being spoken to.
        """
        ...
    @targets.setter
    def targets(self, value: Array[DialogueVoice]) -> None:
        ...

class TypedElementPasteOptions(StructBase):
    r"""
    Typed Element Paste Options
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TypedElementCommonActions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``paste_at_location`` (bool):  [Read-Write]
    - ``paste_location`` (Vector):  [Read-Write]
    - ``selection_set_to_modify`` (TypedElementSelectionSet):  [Read-Write] If provided the SelectionSet selection will only contains the newly added elements
    """
    def __init__(self, selection_set_to_modify: TypedElementSelectionSet = None, paste_at_location: bool = False, paste_location: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def selection_set_to_modify(self) -> TypedElementSelectionSet:
        r"""
        (TypedElementSelectionSet):  [Read-Write] If provided the SelectionSet selection will only contains the newly added elements
        """
        ...
    @selection_set_to_modify.setter
    def selection_set_to_modify(self, value: TypedElementSelectionSet) -> None:
        ...
    @property
    def paste_at_location(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @paste_at_location.setter
    def paste_at_location(self, value: bool) -> None:
        ...
    @property
    def paste_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @paste_location.setter
    def paste_location(self, value: Vector) -> None:
        ...

class TypedElementDeletionOptions(StructBase):
    r"""
    Typed Element Deletion Options
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TypedElementWorldInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``verify_deletion_can_happen`` (bool):  [Read-Write]
    - ``warn_about_references`` (bool):  [Read-Write]
    - ``warn_about_soft_references`` (bool):  [Read-Write]
    """
    def __init__(self, verify_deletion_can_happen: bool = False, warn_about_references: bool = False, warn_about_soft_references: bool = False) -> None:
        ...
    @property
    def verify_deletion_can_happen(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @verify_deletion_can_happen.setter
    def verify_deletion_can_happen(self, value: bool) -> None:
        ...
    @property
    def warn_about_references(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @warn_about_references.setter
    def warn_about_references(self, value: bool) -> None:
        ...
    @property
    def warn_about_soft_references(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @warn_about_soft_references.setter
    def warn_about_soft_references(self, value: bool) -> None:
        ...

class DamageEvent(StructBase):
    r"""
    Event used by AActor::TakeDamage and related functions
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DamageEvents.h
    
    """
    def __init__(self) -> None:
        ...

class PointDamageEvent(DamageEvent):
    r"""
    Damage subclass that handles damage with a single impact location and source direction
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DamageEvents.h
    
    """
    def __init__(self) -> None:
        ...

class RadialDamageParams(StructBase):
    r"""
    Parameters used to compute radial damage
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DamageEvents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_damage`` (float):  [Read-Write] Max damage done
    - ``damage_falloff`` (float):  [Read-Write] Describes amount of exponential damage falloff
    - ``inner_radius`` (float):  [Read-Write] Within InnerRadius, do max damage
    - ``minimum_damage`` (float):  [Read-Write] Damage will not fall below this if within range
    - ``outer_radius`` (float):  [Read-Write] Outside OuterRadius, do no damage
    """
    def __init__(self, base_damage: float = 0.000000, minimum_damage: float = 0.000000, inner_radius: float = 0.000000, outer_radius: float = 0.000000, damage_falloff: float = 0.000000) -> None:
        ...
    @property
    def base_damage(self) -> float:
        r"""
        (float):  [Read-Write] Max damage done
        """
        ...
    @base_damage.setter
    def base_damage(self, value: float) -> None:
        ...
    @property
    def minimum_damage(self) -> float:
        r"""
        (float):  [Read-Write] Damage will not fall below this if within range
        """
        ...
    @minimum_damage.setter
    def minimum_damage(self, value: float) -> None:
        ...
    @property
    def inner_radius(self) -> float:
        r"""
        (float):  [Read-Write] Within InnerRadius, do max damage
        """
        ...
    @inner_radius.setter
    def inner_radius(self, value: float) -> None:
        ...
    @property
    def outer_radius(self) -> float:
        r"""
        (float):  [Read-Write] Outside OuterRadius, do no damage
        """
        ...
    @outer_radius.setter
    def outer_radius(self, value: float) -> None:
        ...
    @property
    def damage_falloff(self) -> float:
        r"""
        (float):  [Read-Write] Describes amount of exponential damage falloff
        """
        ...
    @damage_falloff.setter
    def damage_falloff(self, value: float) -> None:
        ...

class RadialDamageEvent(DamageEvent):
    r"""
    Damage subclass that handles damage with a source location and falloff radius
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DamageEvents.h
    
    """
    def __init__(self) -> None:
        ...

class DeviceColorData(StructBase):
    r"""
    Data required for setting the Input Device Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable`` (bool):  [Read-Write] True if the light should be enabled at all
    - ``light_color`` (Color):  [Read-Write] The color to set the light on
    - ``reset_after_completion`` (bool):  [Read-Write] If true, the light color will be reset to "off" after this property has been evaluated.
    """
    def __init__(self, enable: bool = False, reset_after_completion: bool = False, light_color: Color = [0, 0, 0, 0]) -> None:
        ...
    @property
    def enable(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the light should be enabled at all
        """
        ...
    @enable.setter
    def enable(self, value: bool) -> None:
        ...
    @property
    def reset_after_completion(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the light color will be reset to "off" after this property has been evaluated.
        """
        ...
    @reset_after_completion.setter
    def reset_after_completion(self, value: bool) -> None:
        ...
    @property
    def light_color(self) -> Color:
        r"""
        (Color):  [Read-Write] The color to set the light on
        """
        ...
    @light_color.setter
    def light_color(self, value: Color) -> None:
        ...

class DeviceColorCurveData(StructBase):
    r"""
    Data required for setting the Input Device Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``device_color_curve`` (CurveLinearColor):  [Read-Write] The color the device light should be
    - ``enable`` (bool):  [Read-Write] True if the light should be enabled at all
    - ``reset_after_completion`` (bool):  [Read-Write] If true, the light color will be reset to "off" after the curve values are finished evaluating.
    """
    def __init__(self, enable: bool = False, reset_after_completion: bool = False, device_color_curve: CurveLinearColor = None) -> None:
        ...
    @property
    def enable(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the light should be enabled at all
        """
        ...
    @enable.setter
    def enable(self, value: bool) -> None:
        ...
    @property
    def reset_after_completion(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the light color will be reset to "off" after the curve values are finished evaluating.
        """
        ...
    @reset_after_completion.setter
    def reset_after_completion(self, value: bool) -> None:
        ...
    @property
    def device_color_curve(self) -> CurveLinearColor:
        r"""
        (CurveLinearColor):  [Read-Write] The color the device light should be
        """
        ...
    @device_color_curve.setter
    def device_color_curve(self, value: CurveLinearColor) -> None:
        ...

class DeviceTriggerBaseData(StructBase):
    r"""
    UInputDeviceTriggerEffect
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affected_triggers`` (InputDeviceTriggerMask):  [Read-Write] Which trigger this property should effect
    - ``reset_upon_completion`` (bool):  [Read-Write] True if the triggers should be reset after the duration of this device property
    """
    def __init__(self, affected_triggers: InputDeviceTriggerMask = InputDeviceTriggerMask.NONE, reset_upon_completion: bool = False) -> None:
        ...
    @property
    def affected_triggers(self) -> InputDeviceTriggerMask:
        r"""
        (InputDeviceTriggerMask):  [Read-Write] Which trigger this property should effect
        """
        ...
    @affected_triggers.setter
    def affected_triggers(self, value: InputDeviceTriggerMask) -> None:
        ...
    @property
    def reset_upon_completion(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the triggers should be reset after the duration of this device property
        """
        ...
    @reset_upon_completion.setter
    def reset_upon_completion(self, value: bool) -> None:
        ...

class DeviceTriggerFeedbackData(StructBase):
    r"""
    UInputDeviceTriggerFeedbackProperty
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``feedback_position_curve`` (CurveFloat):  [Read-Write] What position on the trigger that the feedback should be applied to over time (1-9)
    - ``feedback_strengh_curve`` (CurveFloat):  [Read-Write] How strong the feedback is over time (1-8)
    """
    def __init__(self, feedback_position_curve: CurveFloat = None, feedback_strengh_curve: CurveFloat = None) -> None:
        ...
    @property
    def feedback_position_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] What position on the trigger that the feedback should be applied to over time (1-9)
        """
        ...
    @feedback_position_curve.setter
    def feedback_position_curve(self, value: CurveFloat) -> None:
        ...
    @property
    def feedback_strengh_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] How strong the feedback is over time (1-8)
        """
        ...
    @feedback_strengh_curve.setter
    def feedback_strengh_curve(self, value: CurveFloat) -> None:
        ...

class DeviceTriggerTriggerResistanceData(StructBase):
    r"""
    UInputDeviceTriggerResistanceProperty
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_position`` (int32):  [Read-Write]
    - ``end_strengh`` (int32):  [Read-Write]
    - ``start_position`` (int32):  [Read-Write] The position that the trigger should start providing resistance
    - ``start_strengh`` (int32):  [Read-Write] How strong the resistance is
    """
    def __init__(self, start_position: int = 0, start_strengh: int = 0, end_position: int = 0, end_strengh: int = 0) -> None:
        ...
    @property
    def start_position(self) -> int:
        r"""
        (int32):  [Read-Write] The position that the trigger should start providing resistance
        """
        ...
    @start_position.setter
    def start_position(self, value: int) -> None:
        ...
    @property
    def start_strengh(self) -> int:
        r"""
        (int32):  [Read-Write] How strong the resistance is
        """
        ...
    @start_strengh.setter
    def start_strengh(self, value: int) -> None:
        ...
    @property
    def end_position(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @end_position.setter
    def end_position(self, value: int) -> None:
        ...
    @property
    def end_strengh(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @end_strengh.setter
    def end_strengh(self, value: int) -> None:
        ...

class DeviceTriggerTriggerVibrationData(StructBase):
    r"""
    UInputDeviceTriggerVibrationProperty
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``trigger_position_curve`` (CurveFloat):  [Read-Write] What position on the trigger that the feedback should be applied to over time (1-9)
    - ``vibration_amplitude_curve`` (CurveFloat):  [Read-Write] The amplitude of the vibration
    - ``vibration_frequency_curve`` (CurveFloat):  [Read-Write] The frequency of the vibration
    """
    def __init__(self, trigger_position_curve: CurveFloat = None, vibration_frequency_curve: CurveFloat = None, vibration_amplitude_curve: CurveFloat = None) -> None:
        ...
    @property
    def trigger_position_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] What position on the trigger that the feedback should be applied to over time (1-9)
        """
        ...
    @trigger_position_curve.setter
    def trigger_position_curve(self, value: CurveFloat) -> None:
        ...
    @property
    def vibration_frequency_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] The frequency of the vibration
        """
        ...
    @vibration_frequency_curve.setter
    def vibration_frequency_curve(self, value: CurveFloat) -> None:
        ...
    @property
    def vibration_amplitude_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] The amplitude of the vibration
        """
        ...
    @vibration_amplitude_curve.setter
    def vibration_amplitude_curve(self, value: CurveFloat) -> None:
        ...

class AudioBasedVibrationData(StructBase):
    r"""
    Audio Based Vibration Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``sound`` (SoundBase):  [Read-Write] The sound to play on the gamepad. Make sure the set the sound's submix sends to the gamepad audio and vibration endpoints!
    """
    def __init__(self, sound: SoundBase = None) -> None:
        ...
    @property
    def sound(self) -> SoundBase:
        r"""
        (SoundBase):  [Read-Write] The sound to play on the gamepad. Make sure the set the sound's submix sends to the gamepad audio and vibration endpoints!
        """
        ...
    @sound.setter
    def sound(self, value: SoundBase) -> None:
        ...

class ActivateDevicePropertyParams(StructBase):
    r"""
    Parameters for the UInputDeviceSubsystem::ActivateDeviceProperty function
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``device_id`` (InputDeviceId):  [Read-Write] The Input Device that should receive the device property. If nothing is specified here,
      then the Platform User's default input device will be used.
      
      The default input device is obtained from IPlatformInputDeviceMapper::GetPrimaryInputDeviceForUser
    - ``ignore_time_dilation`` (bool):  [Read-Write] If true, then this device property will ignore dilated delta time and use the Applications delta time instead
    - ``looping`` (bool):  [Read-Write] If true, then the input device property will not be removed after it's evaluation time has completed.
      Instead, it will remain active until manually removed with a RemoveDeviceProperty call.
    - ``play_while_paused`` (bool):  [Read-Write] If true, then this device property will be played even if the game world is paused.
    - ``user_id`` (PlatformUserId):  [Read-Write] The Platform User whose device's should receive the device property
    """
    def __init__(self, user_id: PlatformUserId = [], device_id: InputDeviceId = [], looping: bool = False, ignore_time_dilation: bool = False, play_while_paused: bool = False) -> None:
        ...
    @property
    def user_id(self) -> PlatformUserId:
        r"""
        (PlatformUserId):  [Read-Write] The Platform User whose device's should receive the device property
        """
        ...
    @user_id.setter
    def user_id(self, value: PlatformUserId) -> None:
        ...
    @property
    def device_id(self) -> InputDeviceId:
        r"""
        (InputDeviceId):  [Read-Write] The Input Device that should receive the device property. If nothing is specified here,
        then the Platform User's default input device will be used.
        
        The default input device is obtained from IPlatformInputDeviceMapper::GetPrimaryInputDeviceForUser
        """
        ...
    @device_id.setter
    def device_id(self, value: InputDeviceId) -> None:
        ...
    @property
    def looping(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, then the input device property will not be removed after it's evaluation time has completed.
        Instead, it will remain active until manually removed with a RemoveDeviceProperty call.
        """
        ...
    @looping.setter
    def looping(self, value: bool) -> None:
        ...
    @property
    def ignore_time_dilation(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, then this device property will ignore dilated delta time and use the Applications delta time instead
        """
        ...
    @ignore_time_dilation.setter
    def ignore_time_dilation(self, value: bool) -> None:
        ...
    @property
    def play_while_paused(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, then this device property will be played even if the game world is paused.
        """
        ...
    @play_while_paused.setter
    def play_while_paused(self, value: bool) -> None:
        ...

class SetDevicePropertyParams(ActivateDevicePropertyParams):
    r"""
    deprecated: 'SetDevicePropertyParams' was renamed to 'ActivateDevicePropertyParams'.
    """
    def __init__(self, user_id: PlatformUserId = [], device_id: InputDeviceId = [], looping: bool = False, ignore_time_dilation: bool = False, play_while_paused: bool = False) -> None:
        ...

class SlateModifierKeysState(StructBase):
    r"""
    A structure which captures the application's modifier key states (shift, alt, ctrl, etc.)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetInputLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class FloatSpringState(StructBase):
    r"""
    Float Spring State
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetMathLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class VectorSpringState(StructBase):
    r"""
    Vector Spring State
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetMathLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class QuaternionSpringState(StructBase):
    r"""
    Quaternion Spring State
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetMathLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class DrawToRenderTargetContext(StructBase):
    r"""
    Draw to Render Target Context
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetRenderingLibrary.h
    
    """
    def __init__(self) -> None:
        ...

class ImportanceTexture(StructBase):
    r"""
    Texture processed for importance sampling
    Holds marginal PDF of the rows, as well as the PDF of each row
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ImportanceSamplingLibrary.h
    
    """
    def __init__(self, texture: Texture2D = None, weighting_func: ImportanceWeight = ImportanceWeight.LUMINANCE) -> None:
        ...

class ScalarParameterValue(StructBase):
    r"""
    Scalar Parameter Value
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parameter_info`` (MaterialParameterInfo):  [Read-Write]
    - ``parameter_value`` (float):  [Read-Write]
    """
    def __init__(self, parameter_info: MaterialParameterInfo = ["None", MaterialParameterAssociation.GLOBAL_PARAMETER, -1], parameter_value: float = 0.000000) -> None:
        ...
    @property
    def parameter_info(self) -> MaterialParameterInfo:
        r"""
        (MaterialParameterInfo):  [Read-Write]
        """
        ...
    @parameter_info.setter
    def parameter_info(self, value: MaterialParameterInfo) -> None:
        ...
    @property
    def parameter_value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @parameter_value.setter
    def parameter_value(self, value: float) -> None:
        ...

class VectorParameterValue(StructBase):
    r"""
    Editable vector parameter.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parameter_info`` (MaterialParameterInfo):  [Read-Write]
    - ``parameter_value`` (LinearColor):  [Read-Write]
    """
    def __init__(self, parameter_info: MaterialParameterInfo = ["None", MaterialParameterAssociation.GLOBAL_PARAMETER, -1], parameter_value: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def parameter_info(self) -> MaterialParameterInfo:
        r"""
        (MaterialParameterInfo):  [Read-Write]
        """
        ...
    @parameter_info.setter
    def parameter_info(self, value: MaterialParameterInfo) -> None:
        ...
    @property
    def parameter_value(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @parameter_value.setter
    def parameter_value(self, value: LinearColor) -> None:
        ...

class DoubleVectorParameterValue(StructBase):
    r"""
    Editable vector parameter.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parameter_info`` (MaterialParameterInfo):  [Read-Write]
    - ``parameter_value`` (Vector4d):  [Read-Write] LWC_TODO: Blueprint?
    """
    def __init__(self, parameter_info: MaterialParameterInfo = ["None", MaterialParameterAssociation.GLOBAL_PARAMETER, -1]) -> None:
        ...
    @property
    def parameter_info(self) -> MaterialParameterInfo:
        r"""
        (MaterialParameterInfo):  [Read-Write]
        """
        ...
    @parameter_info.setter
    def parameter_info(self, value: MaterialParameterInfo) -> None:
        ...

class TextureParameterValue(StructBase):
    r"""
    Editable texture parameter.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parameter_info`` (MaterialParameterInfo):  [Read-Write]
    - ``parameter_value`` (Texture):  [Read-Write]
    """
    def __init__(self, parameter_info: MaterialParameterInfo = ["None", MaterialParameterAssociation.GLOBAL_PARAMETER, -1], parameter_value: Texture = None) -> None:
        ...
    @property
    def parameter_info(self) -> MaterialParameterInfo:
        r"""
        (MaterialParameterInfo):  [Read-Write]
        """
        ...
    @parameter_info.setter
    def parameter_info(self, value: MaterialParameterInfo) -> None:
        ...
    @property
    def parameter_value(self) -> Texture:
        r"""
        (Texture):  [Read-Write]
        """
        ...
    @parameter_value.setter
    def parameter_value(self, value: Texture) -> None:
        ...

class RuntimeVirtualTextureParameterValue(StructBase):
    r"""
    Editable runtime virtual texture parameter.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parameter_info`` (MaterialParameterInfo):  [Read-Write]
    - ``parameter_value`` (RuntimeVirtualTexture):  [Read-Write]
    """
    def __init__(self, parameter_info: MaterialParameterInfo = ["None", MaterialParameterAssociation.GLOBAL_PARAMETER, -1], parameter_value: RuntimeVirtualTexture = None) -> None:
        ...
    @property
    def parameter_info(self) -> MaterialParameterInfo:
        r"""
        (MaterialParameterInfo):  [Read-Write]
        """
        ...
    @parameter_info.setter
    def parameter_info(self, value: MaterialParameterInfo) -> None:
        ...
    @property
    def parameter_value(self) -> RuntimeVirtualTexture:
        r"""
        (RuntimeVirtualTexture):  [Read-Write]
        """
        ...
    @parameter_value.setter
    def parameter_value(self, value: RuntimeVirtualTexture) -> None:
        ...

class SparseVolumeTextureParameterValue(StructBase):
    r"""
    Editable sparse volume texture parameter.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parameter_info`` (MaterialParameterInfo):  [Read-Write]
    - ``parameter_value`` (SparseVolumeTexture):  [Read-Write]
    """
    def __init__(self, parameter_info: MaterialParameterInfo = ["None", MaterialParameterAssociation.GLOBAL_PARAMETER, -1], parameter_value: SparseVolumeTexture = None) -> None:
        ...
    @property
    def parameter_info(self) -> MaterialParameterInfo:
        r"""
        (MaterialParameterInfo):  [Read-Write]
        """
        ...
    @parameter_info.setter
    def parameter_info(self, value: MaterialParameterInfo) -> None:
        ...
    @property
    def parameter_value(self) -> SparseVolumeTexture:
        r"""
        (SparseVolumeTexture):  [Read-Write]
        """
        ...
    @parameter_value.setter
    def parameter_value(self, value: SparseVolumeTexture) -> None:
        ...

class FontParameterValue(StructBase):
    r"""
    Editable font parameter.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``font_page`` (int32):  [Read-Write]
    - ``font_value`` (Font):  [Read-Write]
    - ``parameter_info`` (MaterialParameterInfo):  [Read-Write]
    """
    def __init__(self, parameter_info: MaterialParameterInfo = ["None", MaterialParameterAssociation.GLOBAL_PARAMETER, -1], font_value: Font = None, font_page: int = 0) -> None:
        ...
    @property
    def parameter_info(self) -> MaterialParameterInfo:
        r"""
        (MaterialParameterInfo):  [Read-Write]
        """
        ...
    @parameter_info.setter
    def parameter_info(self, value: MaterialParameterInfo) -> None:
        ...
    @property
    def font_value(self) -> Font:
        r"""
        (Font):  [Read-Write]
        """
        ...
    @font_value.setter
    def font_value(self, value: Font) -> None:
        ...
    @property
    def font_page(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @font_page.setter
    def font_page(self, value: int) -> None:
        ...

class MeshReductionSettings(StructBase):
    r"""
    Settings used to reduce a mesh.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_lod_model`` (int32):  [Read-Write]
    - ``cull_occluded`` (bool):  [Read-Write]
    - ``generate_unique_lightmap_u_vs`` (bool):  [Read-Write]
    - ``hard_angle_threshold`` (float):  [Read-Write] Angle at which a hard edge is introduced between faces.
    - ``keep_symmetry`` (bool):  [Read-Write]
    - ``max_deviation`` (float):  [Read-Write] The maximum distance in object space by which the reduced mesh may deviate from the original mesh.
    - ``max_num_of_triangles`` (uint32):  [Read-Write] The maximum number of triangles to retain when using percentage termination criterion. (Triangles criterion properties)
    - ``max_num_of_verts`` (uint32):  [Read-Write] The maximum number of vertices to retain when using percentage termination criterion. (Vertices criterion properties)
    - ``percent_triangles`` (float):  [Read-Write] Percentage of triangles to keep. 1.0 = no reduction, 0.0 = no triangles. (Triangles criterion properties)
    - ``percent_vertices`` (float):  [Read-Write] Percentage of vertices to keep. 1.0 = no reduction, 0.0 = no vertices. (Vertices criterion properties)
    - ``pixel_error`` (float):  [Read-Write] The amount of error in pixels allowed for this LOD.
    - ``recalculate_normals`` (bool):  [Read-Write]
    - ``shading_importance`` (MeshFeatureImportance):  [Read-Write] Higher values try to preserve normals better.
    - ``silhouette_importance`` (MeshFeatureImportance):  [Read-Write] Higher values minimize change to border edges.
    - ``termination_criterion`` (StaticMeshReductionTerimationCriterion):  [Read-Write] The method to use when optimizing static mesh LODs
    - ``texture_importance`` (MeshFeatureImportance):  [Read-Write] Higher values reduce texture stretching.
    - ``vertex_color_importance`` (MeshFeatureImportance):  [Read-Write] Higher values minimize change to vertex color data.
    - ``visibility_aggressiveness`` (MeshFeatureImportance):  [Read-Write] Higher values generates fewer samples
    - ``visibility_aided`` (bool):  [Read-Write]
    - ``welding_threshold`` (float):  [Read-Write] Threshold in object space at which vertices are welded together.
    """
    def __init__(self, percent_triangles: float = 0.000000, percent_vertices: float = 0.000000, max_deviation: float = 0.000000, pixel_error: float = 0.000000, welding_threshold: float = 0.000000, hard_angle_threshold: float = 0.000000, base_lod_model: int = 0, silhouette_importance: MeshFeatureImportance = MeshFeatureImportance.OFF, texture_importance: MeshFeatureImportance = MeshFeatureImportance.OFF, shading_importance: MeshFeatureImportance = MeshFeatureImportance.OFF, recalculate_normals: bool = False, generate_unique_lightmap_u_vs: bool = False, keep_symmetry: bool = False, visibility_aided: bool = False, cull_occluded: bool = False, termination_criterion: StaticMeshReductionTerimationCriterion = StaticMeshReductionTerimationCriterion.TRIANGLES, visibility_aggressiveness: MeshFeatureImportance = MeshFeatureImportance.OFF, vertex_color_importance: MeshFeatureImportance = MeshFeatureImportance.OFF) -> None:
        ...
    @property
    def percent_triangles(self) -> float:
        r"""
        (float):  [Read-Write] Percentage of triangles to keep. 1.0 = no reduction, 0.0 = no triangles. (Triangles criterion properties)
        """
        ...
    @percent_triangles.setter
    def percent_triangles(self, value: float) -> None:
        ...
    @property
    def percent_vertices(self) -> float:
        r"""
        (float):  [Read-Write] Percentage of vertices to keep. 1.0 = no reduction, 0.0 = no vertices. (Vertices criterion properties)
        """
        ...
    @percent_vertices.setter
    def percent_vertices(self, value: float) -> None:
        ...
    @property
    def max_deviation(self) -> float:
        r"""
        (float):  [Read-Write] The maximum distance in object space by which the reduced mesh may deviate from the original mesh.
        """
        ...
    @max_deviation.setter
    def max_deviation(self, value: float) -> None:
        ...
    @property
    def pixel_error(self) -> float:
        r"""
        (float):  [Read-Write] The amount of error in pixels allowed for this LOD.
        """
        ...
    @pixel_error.setter
    def pixel_error(self, value: float) -> None:
        ...
    @property
    def welding_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Threshold in object space at which vertices are welded together.
        """
        ...
    @welding_threshold.setter
    def welding_threshold(self, value: float) -> None:
        ...
    @property
    def hard_angle_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Angle at which a hard edge is introduced between faces.
        """
        ...
    @hard_angle_threshold.setter
    def hard_angle_threshold(self, value: float) -> None:
        ...
    @property
    def base_lod_model(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @base_lod_model.setter
    def base_lod_model(self, value: int) -> None:
        ...
    @property
    def silhouette_importance(self) -> MeshFeatureImportance:
        r"""
        (MeshFeatureImportance):  [Read-Write] Higher values minimize change to border edges.
        """
        ...
    @silhouette_importance.setter
    def silhouette_importance(self, value: MeshFeatureImportance) -> None:
        ...
    @property
    def texture_importance(self) -> MeshFeatureImportance:
        r"""
        (MeshFeatureImportance):  [Read-Write] Higher values reduce texture stretching.
        """
        ...
    @texture_importance.setter
    def texture_importance(self, value: MeshFeatureImportance) -> None:
        ...
    @property
    def shading_importance(self) -> MeshFeatureImportance:
        r"""
        (MeshFeatureImportance):  [Read-Write] Higher values try to preserve normals better.
        """
        ...
    @shading_importance.setter
    def shading_importance(self, value: MeshFeatureImportance) -> None:
        ...
    @property
    def recalculate_normals(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @recalculate_normals.setter
    def recalculate_normals(self, value: bool) -> None:
        ...
    @property
    def generate_unique_lightmap_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @generate_unique_lightmap_u_vs.setter
    def generate_unique_lightmap_u_vs(self, value: bool) -> None:
        ...
    @property
    def keep_symmetry(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @keep_symmetry.setter
    def keep_symmetry(self, value: bool) -> None:
        ...
    @property
    def visibility_aided(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @visibility_aided.setter
    def visibility_aided(self, value: bool) -> None:
        ...
    @property
    def cull_occluded(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @cull_occluded.setter
    def cull_occluded(self, value: bool) -> None:
        ...
    @property
    def termination_criterion(self) -> StaticMeshReductionTerimationCriterion:
        r"""
        (StaticMeshReductionTerimationCriterion):  [Read-Write] The method to use when optimizing static mesh LODs
        """
        ...
    @termination_criterion.setter
    def termination_criterion(self, value: StaticMeshReductionTerimationCriterion) -> None:
        ...
    @property
    def visibility_aggressiveness(self) -> MeshFeatureImportance:
        r"""
        (MeshFeatureImportance):  [Read-Write] Higher values generates fewer samples
        """
        ...
    @visibility_aggressiveness.setter
    def visibility_aggressiveness(self, value: MeshFeatureImportance) -> None:
        ...
    @property
    def vertex_color_importance(self) -> MeshFeatureImportance:
        r"""
        (MeshFeatureImportance):  [Read-Write] Higher values minimize change to vertex color data.
        """
        ...
    @vertex_color_importance.setter
    def vertex_color_importance(self, value: MeshFeatureImportance) -> None:
        ...

class MeshInstancingSettings(StructBase):
    r"""
    Mesh instance-replacement settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMerging.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_class_to_use`` (type(Class)):  [Read-Write] The actor class to attach new instance static mesh components to
    - ``instance_replacement_threshold`` (int32):  [Read-Write] The number of static mesh instances needed before a mesh is replaced with an instanced version
    - ``ism_component_to_use`` (type(Class)):  [Read-Write] Whether to use the Instanced Static Mesh Compoment or the Hierarchical Instanced Static Mesh Compoment
    - ``skip_meshes_with_vertex_colors`` (bool):  [Read-Write] Whether to skip the conversion to an instanced static mesh for meshes with vertex colors.
      Instanced static meshes do not support vertex colors per-instance, so conversion will lose
      this data.
    - ``use_hlod_volumes`` (bool):  [Read-Write] Whether split up instanced static mesh components based on their intersection with HLOD volumes
    """
    def __init__(self, actor_class_to_use: Class = None, instance_replacement_threshold: int = 0, skip_meshes_with_vertex_colors: bool = False, use_hlod_volumes: bool = False, ism_component_to_use: Class = None) -> None:
        ...
    @property
    def actor_class_to_use(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] The actor class to attach new instance static mesh components to
        """
        ...
    @actor_class_to_use.setter
    def actor_class_to_use(self, value: Class) -> None:
        ...
    @property
    def instance_replacement_threshold(self) -> int:
        r"""
        (int32):  [Read-Write] The number of static mesh instances needed before a mesh is replaced with an instanced version
        """
        ...
    @instance_replacement_threshold.setter
    def instance_replacement_threshold(self, value: int) -> None:
        ...
    @property
    def skip_meshes_with_vertex_colors(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to skip the conversion to an instanced static mesh for meshes with vertex colors.
        Instanced static meshes do not support vertex colors per-instance, so conversion will lose
        this data.
        """
        ...
    @skip_meshes_with_vertex_colors.setter
    def skip_meshes_with_vertex_colors(self, value: bool) -> None:
        ...
    @property
    def use_hlod_volumes(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether split up instanced static mesh components based on their intersection with HLOD volumes
        """
        ...
    @use_hlod_volumes.setter
    def use_hlod_volumes(self, value: bool) -> None:
        ...
    @property
    def ism_component_to_use(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Whether to use the Instanced Static Mesh Compoment or the Hierarchical Instanced Static Mesh Compoment
        """
        ...
    @ism_component_to_use.setter
    def ism_component_to_use(self, value: Class) -> None:
        ...

class UniqueNetIdWrapper(StructBase):
    r"""
    UE::Online
    
    **C++ Source:**
    
    - **Module**: CoreOnline
    - **File**: CoreOnline.h
    
    """
    def __init__(self) -> None:
        ...

class UniqueNetIdRepl(UniqueNetIdWrapper):
    r"""
    Wrapper for opaque type FUniqueNetId
    
    Makes sure that the opaque aspects of FUniqueNetId are properly handled/serialized
    over network RPC and actor replication
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: OnlineReplStructs.h
    
    """
    def __init__(self) -> None:
        ...

class PerPlatformFrameRate(StructBase):
    r"""
    FPerPlatformFrameRate - FFrameRate property with per-platform overrides
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PerPlatformProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default`` (FrameRate):  [Read-Write]
    - ``per_platform`` (Map[Name, FrameRate]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class ConstraintInstanceAccessor(StructBase):
    r"""
    Wrapping type around instance pointer to be returned per value in Blueprints
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintInstance.h
    
    """
    def __init__(self) -> None:
        ...

class PhysicalAnimationData(StructBase):
    r"""
    Stores info on the type of motor that will be used for a given bone
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicalAnimationComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_velocity_strength`` (float):  [Read-Write] The strength used to correct angular velocity error
    - ``is_local_simulation`` (bool):  [Read-Write] Whether the drive targets are in world space or local
    - ``max_angular_force`` (float):  [Read-Write] The max force used to correct angular errors
    - ``max_linear_force`` (float):  [Read-Write] The max force used to correct linear errors
    - ``orientation_strength`` (float):  [Read-Write] The strength used to correct orientation error
    - ``position_strength`` (float):  [Read-Write] The strength used to correct linear position error. Only used for non-local simulation
    - ``velocity_strength`` (float):  [Read-Write] The strength used to correct linear velocity error. Only used for non-local simulation
    """
    def __init__(self, is_local_simulation: bool = False, orientation_strength: float = 0.000000, angular_velocity_strength: float = 0.000000, position_strength: float = 0.000000, velocity_strength: float = 0.000000, max_linear_force: float = 0.000000, max_angular_force: float = 0.000000) -> None:
        ...
    @property
    def is_local_simulation(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the drive targets are in world space or local
        """
        ...
    @is_local_simulation.setter
    def is_local_simulation(self, value: bool) -> None:
        ...
    @property
    def orientation_strength(self) -> float:
        r"""
        (float):  [Read-Write] The strength used to correct orientation error
        """
        ...
    @orientation_strength.setter
    def orientation_strength(self, value: float) -> None:
        ...
    @property
    def angular_velocity_strength(self) -> float:
        r"""
        (float):  [Read-Write] The strength used to correct angular velocity error
        """
        ...
    @angular_velocity_strength.setter
    def angular_velocity_strength(self, value: float) -> None:
        ...
    @property
    def position_strength(self) -> float:
        r"""
        (float):  [Read-Write] The strength used to correct linear position error. Only used for non-local simulation
        """
        ...
    @position_strength.setter
    def position_strength(self, value: float) -> None:
        ...
    @property
    def velocity_strength(self) -> float:
        r"""
        (float):  [Read-Write] The strength used to correct linear velocity error. Only used for non-local simulation
        """
        ...
    @velocity_strength.setter
    def velocity_strength(self, value: float) -> None:
        ...
    @property
    def max_linear_force(self) -> float:
        r"""
        (float):  [Read-Write] The max force used to correct linear errors
        """
        ...
    @max_linear_force.setter
    def max_linear_force(self, value: float) -> None:
        ...
    @property
    def max_angular_force(self) -> float:
        r"""
        (float):  [Read-Write] The max force used to correct angular errors
        """
        ...
    @max_angular_force.setter
    def max_angular_force(self, value: float) -> None:
        ...

class PhysicsAssetSolverSettings(StructBase):
    r"""
    Solver iterations settings for use by RigidBody AnimNode (RBAN) in the Anim Graph. Each RBAN node runs its own solver with these settings.
    note: These settings have no effect when the Physics Asset is used in a world simulation (i.e., as a ragdoll on a SkeletalMeshComponent).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cull_distance`` (float):  [Read-Write] RBAN: The distance at which collisions are ignored. In general you need this to be a bit larger than the typical relative body
      movement in your simulation, but small enough so that we don't have to speculatively create too many unused collisions.
    - ``fixed_time_step`` (float):  [Read-Write] RBAN: The recommended fixed timestep for the RBAN solver. Set to 0 to run with variable timestep (default).
      NOTE: If this value is non-zero and less than the current frame time, the simulation will step multiple times
      which increases the cost.
    - ``max_depenetration_velocity`` (float):  [Read-Write] RBAN: When bodies are penetrating, this is the maximum velocity delta that can be applied in one frame.
    - ``position_iterations`` (int32):  [Read-Write] RBAN: The number of position iterations to run. The position solve is responsible for depenetration.
      Increasing this will improve simulation stability, but increase the cost.
    - ``projection_iterations`` (int32):  [Read-Write] RBAN: The number of projection iterations to run. The projection phase is a final pass over the constraints, applying
      a semi-physical correction to any joint errors remaining after the position and velocity solves. It can be
      very helpful to stabilize joint chains, but can cause issues with collision response. The projection magnitude
      can be controlled per-constraint in the constraint settings (assuming ProjectionIteration is not zero).
      This should be left as 1 in almost all cases.
    - ``use_linear_joint_solver`` (bool):  [Read-Write] RBAN: Whether to use the linear or non-linear solver for RBAN Joints. The linear solver is significantly cheaper than
      the non-linear solver when you are running multiple iterations, but is more likely to suffer from jitter.
      In general you should try to use the linear solver and increase the PositionIterations to improve stability if
      possible, only using the non-linear solver as a last resort.
    - ``velocity_iterations`` (int32):  [Read-Write] RBAN: The number of velocity iterations to run. The velocity solve is responsible for restitution (bounce) and friction.
      This should usually be 1, but could be 0 if you don't care about friction and restitution.
    """
    def __init__(self, position_iterations: int = 0, velocity_iterations: int = 0, projection_iterations: int = 0, cull_distance: float = 0.000000, max_depenetration_velocity: float = 0.000000, fixed_time_step: float = 0.000000, use_linear_joint_solver: bool = False) -> None:
        ...
    @property
    def position_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] RBAN: The number of position iterations to run. The position solve is responsible for depenetration.
        Increasing this will improve simulation stability, but increase the cost.
        """
        ...
    @position_iterations.setter
    def position_iterations(self, value: int) -> None:
        ...
    @property
    def velocity_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] RBAN: The number of velocity iterations to run. The velocity solve is responsible for restitution (bounce) and friction.
        This should usually be 1, but could be 0 if you don't care about friction and restitution.
        """
        ...
    @velocity_iterations.setter
    def velocity_iterations(self, value: int) -> None:
        ...
    @property
    def projection_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] RBAN: The number of projection iterations to run. The projection phase is a final pass over the constraints, applying
        a semi-physical correction to any joint errors remaining after the position and velocity solves. It can be
        very helpful to stabilize joint chains, but can cause issues with collision response. The projection magnitude
        can be controlled per-constraint in the constraint settings (assuming ProjectionIteration is not zero).
        This should be left as 1 in almost all cases.
        """
        ...
    @projection_iterations.setter
    def projection_iterations(self, value: int) -> None:
        ...
    @property
    def cull_distance(self) -> float:
        r"""
        (float):  [Read-Write] RBAN: The distance at which collisions are ignored. In general you need this to be a bit larger than the typical relative body
        movement in your simulation, but small enough so that we don't have to speculatively create too many unused collisions.
        """
        ...
    @cull_distance.setter
    def cull_distance(self, value: float) -> None:
        ...
    @property
    def max_depenetration_velocity(self) -> float:
        r"""
        (float):  [Read-Write] RBAN: When bodies are penetrating, this is the maximum velocity delta that can be applied in one frame.
        """
        ...
    @max_depenetration_velocity.setter
    def max_depenetration_velocity(self, value: float) -> None:
        ...
    @property
    def fixed_time_step(self) -> float:
        r"""
        (float):  [Read-Write] RBAN: The recommended fixed timestep for the RBAN solver. Set to 0 to run with variable timestep (default).
        NOTE: If this value is non-zero and less than the current frame time, the simulation will step multiple times
        which increases the cost.
        """
        ...
    @fixed_time_step.setter
    def fixed_time_step(self, value: float) -> None:
        ...
    @property
    def use_linear_joint_solver(self) -> bool:
        r"""
        (bool):  [Read-Write] RBAN: Whether to use the linear or non-linear solver for RBAN Joints. The linear solver is significantly cheaper than
        the non-linear solver when you are running multiple iterations, but is more likely to suffer from jitter.
        In general you should try to use the linear solver and increase the PositionIterations to improve stability if
        possible, only using the non-linear solver as a last resort.
        """
        ...
    @use_linear_joint_solver.setter
    def use_linear_joint_solver(self, value: bool) -> None:
        ...

class SolverIterations(StructBase):
    r"""
    Solver settings for use by the Legacy RigidBody AnimNode (RBAN) solver.
    Thse settings are no longer used by default and will eventually be deprecated and then removed.
    note: These settings have no effect when the Physics Asset is used in a world simulation (ragdoll).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_iterations`` (int32):  [Read-Write] The recommended number of collision sub-iterations. Increasing this can help with collision jitter.
    - ``collision_push_out_iterations`` (int32):  [Read-Write] The recommended number of joint sub-push-out iterations. Increasing this can help with collision penetration problems.
    - ``joint_iterations`` (int32):  [Read-Write] The recommended number of joint sub-iterations. Increasing this can help with chains of long-thin bodies.
    - ``joint_push_out_iterations`` (int32):  [Read-Write] The recommended number of joint sub-push-out iterations.
    - ``solver_iterations`` (int32):  [Read-Write] The recommended number of solver iterations. Increase this if collision and joints are fighting, or joint chains are stretching.
    - ``solver_push_out_iterations`` (int32):  [Read-Write] Increase this if bodies remain penetrating
    """
    def __init__(self, solver_iterations: int = 0, joint_iterations: int = 0, collision_iterations: int = 0, solver_push_out_iterations: int = 0, joint_push_out_iterations: int = 0, collision_push_out_iterations: int = 0) -> None:
        ...
    @property
    def solver_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The recommended number of solver iterations. Increase this if collision and joints are fighting, or joint chains are stretching.
        """
        ...
    @solver_iterations.setter
    def solver_iterations(self, value: int) -> None:
        ...
    @property
    def joint_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The recommended number of joint sub-iterations. Increasing this can help with chains of long-thin bodies.
        """
        ...
    @joint_iterations.setter
    def joint_iterations(self, value: int) -> None:
        ...
    @property
    def collision_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The recommended number of collision sub-iterations. Increasing this can help with collision jitter.
        """
        ...
    @collision_iterations.setter
    def collision_iterations(self, value: int) -> None:
        ...
    @property
    def solver_push_out_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] Increase this if bodies remain penetrating
        """
        ...
    @solver_push_out_iterations.setter
    def solver_push_out_iterations(self, value: int) -> None:
        ...
    @property
    def joint_push_out_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The recommended number of joint sub-push-out iterations.
        """
        ...
    @joint_push_out_iterations.setter
    def joint_push_out_iterations(self, value: int) -> None:
        ...
    @property
    def collision_push_out_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The recommended number of joint sub-push-out iterations. Increasing this can help with collision penetration problems.
        """
        ...
    @collision_push_out_iterations.setter
    def collision_push_out_iterations(self, value: int) -> None:
        ...

class NeuralProfileStruct(StructBase):
    r"""
    struct with all the settings we want in UNeuralProfile, separate to make it easer to pass this data around in the engine.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NeuralProfile.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``batch_size_override`` (int32):  [Read-Write] Used to override the batch size if the batch dimension is dynamic (-1)
    - ``input_dimension`` (IntVector4):  [Read-Write] Input dimension of the NNEModelData model
    - ``input_format`` (NeuralProfileFormat):  [Read-Write] Define the expected input format, if any output from material is not this format, a custom conversion
      will be applied for this conversion.
    - ``nne_model_data`` (Object):  [Read-Write] Stores the NNEModelData imported from e.g., onnx model
    - ``output_dimension`` (IntVector4):  [Read-Write] Output dimension of the NNEModelData model
    - ``output_format`` (NeuralProfileFormat):  [Read-Write] Define the expected output format. A conversion between the output format and the actual format will
      be applied automatically.
    - ``runtime_type`` (NeuralProfileRuntimeType):  [Read-Write] runtime type (support "NNERuntimeRDGDml" only at this moment)
    - ``tile_overlap`` (IntPoint):  [Read-Write] Tile border overlaps (Left|Right, Top|Bottom). The larger this value, the more tiles are required to cover the whole screen when TileSize is Auto.
    - ``tile_overlap_resolve_type`` (TileOverlapResolveType):  [Read-Write]
    - ``tile_size`` (NeuralModelTileType):  [Read-Write] Total tiles used. Each tile will be executed by 1 batch
    """
    def __init__(self, input_format: NeuralProfileFormat = NeuralProfileFormat.TYPE32, output_format: NeuralProfileFormat = NeuralProfileFormat.TYPE32, runtime_type: NeuralProfileRuntimeType = NeuralProfileRuntimeType.NNE_RUNTIME_RDG_DML, nne_model_data: Object = None, input_dimension: IntVector4 = [0, 0, 0, 0], output_dimension: IntVector4 = [0, 0, 0, 0], batch_size_override: int = 0) -> None:
        ...
    @property
    def input_format(self) -> NeuralProfileFormat:
        r"""
        (NeuralProfileFormat):  [Read-Only] Define the expected input format, if any output from material is not this format, a custom conversion
        will be applied for this conversion.
        """
        ...
    @property
    def output_format(self) -> NeuralProfileFormat:
        r"""
        (NeuralProfileFormat):  [Read-Only] Define the expected output format. A conversion between the output format and the actual format will
        be applied automatically.
        """
        ...
    @property
    def runtime_type(self) -> NeuralProfileRuntimeType:
        r"""
        (NeuralProfileRuntimeType):  [Read-Only] runtime type (support "NNERuntimeRDGDml" only at this moment)
        """
        ...
    @property
    def nne_model_data(self) -> Object:
        r"""
        (Object):  [Read-Only] Stores the NNEModelData imported from e.g., onnx model
        """
        ...
    @property
    def input_dimension(self) -> IntVector4:
        r"""
        (IntVector4):  [Read-Only] Input dimension of the NNEModelData model
        """
        ...
    @property
    def output_dimension(self) -> IntVector4:
        r"""
        (IntVector4):  [Read-Only] Output dimension of the NNEModelData model
        """
        ...
    @property
    def batch_size_override(self) -> int:
        r"""
        (int32):  [Read-Only] Used to override the batch size if the batch dimension is dynamic (-1)
        """
        ...

class SpecularProfileStruct(StructBase):
    r"""
    struct with all the settings we want in USpecularProfile, separate to make it easer to pass this data around in the engine.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SpecularProfile.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``format`` (SpecularProfileFormat):  [Read-Write] Define the texture used as a specular profile
    - ``light_color`` (RuntimeCurveLinearColor):  [Read-Write] Define the light facing color
    - ``texture`` (Texture2D):  [Read-Write] Define the texture used as a specular profile
    - ``view_color`` (RuntimeCurveLinearColor):  [Read-Write] Define the view facing color
    """
    def __init__(self, format: SpecularProfileFormat = SpecularProfileFormat.VIEW_LIGHT_VECTOR, texture: Texture2D = None) -> None:
        ...
    @property
    def format(self) -> SpecularProfileFormat:
        r"""
        (SpecularProfileFormat):  [Read-Only] Define the texture used as a specular profile
        """
        ...
    @property
    def texture(self) -> Texture2D:
        r"""
        (Texture2D):  [Read-Only] Define the texture used as a specular profile
        """
        ...

class SubsurfaceProfileStruct(StructBase):
    r"""
    struct with all the settings we want in USubsurfaceProfile, separate to make it easer to pass this data around in the engine.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SubsurfaceProfile.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``boundary_color_bleed`` (LinearColor):  [Read-Write]
    - ``enable_burley`` (bool):  [Read-Write] Effective only when Burley subsurface scattering is enabled in cmd.
    - ``enable_mean_free_path`` (bool):  [Read-Write] Switch to use Mean Free Path, otherwise use diffuse mean free path.
    - ``extinction_scale`` (float):  [Read-Write]
    - ``falloff_color`` (LinearColor):  [Read-Write] defines the per-channel falloff of the gradients
      produced by the subsurface scattering events, can be used to fine tune the color of the gradients
      (called "falloff" in SeparableSSS, default there: 1, 0.37, 0.3)
      deprecated: Property 'FalloffColor' is deprecated.
    - ``ior`` (float):  [Read-Write]
    - ``lobe_mix`` (float):  [Read-Write]
    - ``mean_free_path_color`` (LinearColor):  [Read-Write] Controls how far light goes into the subsurface in the Red, Green and Blue channel. It is scaled by Mean Free path distance.
    - ``mean_free_path_distance`` (float):  [Read-Write] Subsurface mean free path distance in world/unreal units (cm)
    - ``normal_scale`` (float):  [Read-Write]
    - ``roughness0`` (float):  [Read-Write]
    - ``roughness1`` (float):  [Read-Write]
    - ``scatter_radius`` (float):  [Read-Write] in world/unreal units (cm)
      deprecated: Property 'ScatterRadius' is deprecated.
    - ``scattering_distribution`` (float):  [Read-Write]
    - ``subsurface_color`` (LinearColor):  [Read-Write] Specifies the how much of the diffuse light gets into the material,
      can be seen as a per-channel mix factor between the original image,
      and the SSS-filtered image (called "strength" in SeparableSSS, default there: 0.48, 0.41, 0.28)
      deprecated: Property 'SubsurfaceColor' is deprecated.
    - ``surface_albedo`` (LinearColor):  [Read-Write] It should match The base color of the corresponding material as much as possible.
    - ``tint`` (LinearColor):  [Read-Write] Specifies the how much of the diffuse light gets into the material,
      can be seen as a per-channel mix factor between the original image,
      and the SSS-filtered image. It introduces Non-PBR looks.
    - ``transmission_tint_color`` (LinearColor):  [Read-Write] Transmission tint control. It is multiplied on the transmission results. Works only when Burley is enabled.
    - ``world_unit_scale`` (float):  [Read-Write] Control the scale of world/unreal units (cm)
    """
    def __init__(self, surface_albedo: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], mean_free_path_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], mean_free_path_distance: float = 0.000000, world_unit_scale: float = 0.000000, enable_burley: bool = False, enable_mean_free_path: bool = False, tint: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], boundary_color_bleed: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], extinction_scale: float = 0.000000, normal_scale: float = 0.000000, scattering_distribution: float = 0.000000, ior: float = 0.000000, roughness0: float = 0.000000, roughness1: float = 0.000000, lobe_mix: float = 0.000000, transmission_tint_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def surface_albedo(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] It should match The base color of the corresponding material as much as possible.
        """
        ...
    @property
    def mean_free_path_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Controls how far light goes into the subsurface in the Red, Green and Blue channel. It is scaled by Mean Free path distance.
        """
        ...
    @property
    def mean_free_path_distance(self) -> float:
        r"""
        (float):  [Read-Only] Subsurface mean free path distance in world/unreal units (cm)
        """
        ...
    @property
    def world_unit_scale(self) -> float:
        r"""
        (float):  [Read-Only] Control the scale of world/unreal units (cm)
        """
        ...
    @property
    def enable_burley(self) -> bool:
        r"""
        (bool):  [Read-Only] Effective only when Burley subsurface scattering is enabled in cmd.
        """
        ...
    @property
    def enable_mean_free_path(self) -> bool:
        r"""
        (bool):  [Read-Only] Switch to use Mean Free Path, otherwise use diffuse mean free path.
        """
        ...
    @property
    def tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Specifies the how much of the diffuse light gets into the material,
        can be seen as a per-channel mix factor between the original image,
        and the SSS-filtered image. It introduces Non-PBR looks.
        """
        ...
    @property
    def scatter_radius(self) -> float:
        r"""
        (float):  [Read-Only] in world/unreal units (cm)
        deprecated: Property 'ScatterRadius' is deprecated.
        """
        ...
    @property
    def subsurface_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Specifies the how much of the diffuse light gets into the material,
        can be seen as a per-channel mix factor between the original image,
        and the SSS-filtered image (called "strength" in SeparableSSS, default there: 0.48, 0.41, 0.28)
        deprecated: Property 'SubsurfaceColor' is deprecated.
        """
        ...
    @property
    def falloff_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] defines the per-channel falloff of the gradients
        produced by the subsurface scattering events, can be used to fine tune the color of the gradients
        (called "falloff" in SeparableSSS, default there: 1, 0.37, 0.3)
        deprecated: Property 'FalloffColor' is deprecated.
        """
        ...
    @property
    def boundary_color_bleed(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...
    @property
    def extinction_scale(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def normal_scale(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def scattering_distribution(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def ior(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def roughness0(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def roughness1(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def lobe_mix(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def transmission_tint_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Transmission tint control. It is multiplied on the transmission results. Works only when Burley is enabled.
        """
        ...

class SingleAnimationPlayData(StructBase):
    r"""
    Single Animation Play Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SingleAnimationPlayData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_to_play`` (AnimationAsset):  [Read-Write]
      todo: in the future, we should make this one UObject and have detail customization to display different things The default sequence to play on this skeletal mesh
    - ``saved_looping`` (bool):  [Read-Write] Default setting for looping for SequenceToPlay. This is not current state of looping.
    - ``saved_play_rate`` (float):  [Read-Write] Default setting for play rate of SequenceToPlay to play.
    - ``saved_playing`` (bool):  [Read-Write] Default setting for playing for SequenceToPlay. This is not current state of playing.
    - ``saved_position`` (float):  [Read-Write] Default setting for position of SequenceToPlay to play.
    """
    def __init__(self, anim_to_play: AnimationAsset = None, saved_looping: bool = False, saved_playing: bool = False, saved_position: float = 0.000000, saved_play_rate: float = 0.000000) -> None:
        ...
    @property
    def anim_to_play(self) -> AnimationAsset:
        r"""
        (AnimationAsset):  [Read-Write]
        todo: in the future, we should make this one UObject and have detail customization to display different things The default sequence to play on this skeletal mesh
        """
        ...
    @anim_to_play.setter
    def anim_to_play(self, value: AnimationAsset) -> None:
        ...
    @property
    def saved_looping(self) -> bool:
        r"""
        (bool):  [Read-Write] Default setting for looping for SequenceToPlay. This is not current state of looping.
        """
        ...
    @saved_looping.setter
    def saved_looping(self, value: bool) -> None:
        ...
    @property
    def saved_playing(self) -> bool:
        r"""
        (bool):  [Read-Write] Default setting for playing for SequenceToPlay. This is not current state of playing.
        """
        ...
    @saved_playing.setter
    def saved_playing(self, value: bool) -> None:
        ...
    @property
    def saved_position(self) -> float:
        r"""
        (float):  [Read-Write] Default setting for position of SequenceToPlay to play.
        """
        ...
    @saved_position.setter
    def saved_position(self, value: float) -> None:
        ...
    @property
    def saved_play_rate(self) -> float:
        r"""
        (float):  [Read-Write] Default setting for play rate of SequenceToPlay to play.
        """
        ...
    @saved_play_rate.setter
    def saved_play_rate(self, value: float) -> None:
        ...

class SkelMeshMergeSectionMapping(StructBase):
    r"""
    Info to map all the sections from a single source skeletal mesh to
    a final section entry in the merged skeletal mesh
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshMerge.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``section_i_ds`` (Array[int32]):  [Read-Write] indices to final section entries of the merged skel mesh
    """
    def __init__(self, section_i_ds: Array[int] = []) -> None:
        ...
    @property
    def section_i_ds(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write] indices to final section entries of the merged skel mesh
        """
        ...
    @section_i_ds.setter
    def section_i_ds(self, value: Array[int]) -> None:
        ...

class SkelMeshMergeMeshUVTransforms(StructBase):
    r"""
    Skel Mesh Merge Mesh UVTransforms
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshMerge.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``uv_transforms`` (Array[Transform]):  [Read-Write] A list of how UVs should be transformed on a given mesh, where index represents a specific UV channel.
    """
    def __init__(self, uv_transforms: Array[Transform] = []) -> None:
        ...
    @property
    def uv_transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write] A list of how UVs should be transformed on a given mesh, where index represents a specific UV channel.
        """
        ...
    @uv_transforms.setter
    def uv_transforms(self, value: Array[Transform]) -> None:
        ...

class SkelMeshMergeUVTransformMapping(StructBase):
    r"""
    Info to map all the sections about how to transform their UVs
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshMerge.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``uv_transforms_per_mesh`` (Array[SkelMeshMergeMeshUVTransforms]):  [Read-Write] UV coordinates transform datam one entry for each Skeletal Mesh.
    """
    def __init__(self, uv_transforms_per_mesh: Array[SkelMeshMergeMeshUVTransforms] = []) -> None:
        ...
    @property
    def uv_transforms_per_mesh(self) -> Array[SkelMeshMergeMeshUVTransforms]:
        r"""
        (Array[SkelMeshMergeMeshUVTransforms]):  [Read-Write] UV coordinates transform datam one entry for each Skeletal Mesh.
        """
        ...
    @uv_transforms_per_mesh.setter
    def uv_transforms_per_mesh(self, value: Array[SkelMeshMergeMeshUVTransforms]) -> None:
        ...

class SkeletalMaterial(StructBase):
    r"""
    Skeletal Material
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedAssetCommon.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``imported_material_slot_name`` (Name):  [Read-Only] This name should be use when we re-import a skeletal mesh so we can order the Materials array like it should be
    - ``material_interface`` (MaterialInterface):  [Read-Write]
    - ``material_slot_name`` (Name):  [Read-Write] This name should be use by the gameplay to avoid error if the skeletal mesh Materials array topology change
    - ``uv_channel_data`` (MeshUVChannelInfo):  [Read-Only] Data used for texture streaming relative to each UV channels.
    """
    def __init__(self, material_interface: MaterialInterface = None, material_slot_name: Name = "None", uv_channel_data: MeshUVChannelInfo = []) -> None:
        ...
    @property
    def material_interface(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Write]
        """
        ...
    @material_interface.setter
    def material_interface(self, value: MaterialInterface) -> None:
        ...
    @property
    def material_slot_name(self) -> Name:
        r"""
        (Name):  [Read-Write] This name should be use by the gameplay to avoid error if the skeletal mesh Materials array topology change
        """
        ...
    @material_slot_name.setter
    def material_slot_name(self, value: Name) -> None:
        ...
    @property
    def uv_channel_data(self) -> MeshUVChannelInfo:
        r"""
        (MeshUVChannelInfo):  [Read-Only] Data used for texture streaming relative to each UV channels.
        """
        ...

class SoundClassProperties(StructBase):
    r"""
    Sound Class Properties
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundClass.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``always_play`` (bool):  [Read-Write] Whether to inflate referencing sound's priority to always play.
    - ``apply_ambient_volumes`` (bool):  [Read-Write] Whether the Interior/Exterior volume and LPF modifiers should be applied
    - ``apply_effects`` (bool):  [Read-Write] Whether to use 'Master EQ Submix' as set in the 'Audio' category of Project Settings as the default submix for referencing sounds.
    - ``attenuation_distance_scale`` (float):  [Read-Write] Scales the distance measurement used by the audio engine when determining distance-based attenuation.
      E.g., a sound 1000 units away with an AttenuationDistanceScale of .5 will be attenuated
      as if it is 500 units away from the listener.
      Allows adjusting attenuation settings dynamically.
    - ``center_channel_only`` (bool):  [Read-Write] Whether or not this sound class forces sounds to the center channel
    - ``default2d_reverb_send_amount`` (float):  [Read-Write] Send amount to master reverb effect for referencing unattenuated (2D) sounds.
    - ``default_submix`` (SoundSubmix):  [Read-Write] Default output submix of referencing sounds. If unset, falls back to the 'Master Submix' as set in the 'Audio' category of Project Settings.
      (Unavailable if legacy 'Output to Master EQ Submix' is set)
    - ``is_music`` (bool):  [Read-Write] Whether or not this is music (propagates to child classes only if parent is true)
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``lfe_bleed`` (float):  [Read-Write] The amount of a sound to bleed to the LFE channel
    - ``loading_behavior`` (SoundWaveLoadingBehavior):  [Read-Write] Specifies how and when compressed audio data is loaded for asset if stream caching is enabled.
    - ``low_pass_filter_frequency`` (float):  [Read-Write] Lowpass filter cutoff frequency
    - ``modulation_settings`` (SoundModulationDefaultSettings):  [Read-Write] Default modulation settings for sounds directly referencing this class
    - ``output_target`` (AudioOutputTarget):  [Read-Write] Which output target the sound should be played through
    - ``pitch`` (float):  [Read-Write] Pitch multiplier.
    - ``radio_filter_volume`` (float):  [Read-Write] Volume of the radio filter effect.
    - ``radio_filter_volume_threshold`` (float):  [Read-Write] Volume at which the radio filter kicks in
    - ``reverb`` (bool):  [Read-Write] Whether or not sounds referencing this class send to the reverb submix
    - ``size_of_first_audio_chunk_in_seconds`` (PerPlatformFloat):  [Read-Write] How much audio to add to First Audio Chunk (in seconds)
    - ``voice_center_channel_volume`` (float):  [Read-Write] The amount to send to center channel (does not propagate to child classes)
    - ``volume`` (float):  [Read-Write] Volume multiplier.
    """
    def __init__(self, volume: float = 0.000000, pitch: float = 0.000000, low_pass_filter_frequency: float = 0.000000, attenuation_distance_scale: float = 0.000000, lfe_bleed: float = 0.000000, voice_center_channel_volume: float = 0.000000, radio_filter_volume: float = 0.000000, radio_filter_volume_threshold: float = 0.000000, apply_effects: bool = False, always_play: bool = False, is_ui_sound: bool = False, is_music: bool = False, center_channel_only: bool = False, apply_ambient_volumes: bool = False, reverb: bool = False, default2d_reverb_send_amount: float = 0.000000, modulation_settings: SoundModulationDefaultSettings = [[0.000000, []], [0.000000, []], [20.000000, []], [20000.000000, []]], output_target: AudioOutputTarget = AudioOutputTarget.SPEAKER, loading_behavior: SoundWaveLoadingBehavior = SoundWaveLoadingBehavior.INHERITED, default_submix: SoundSubmix = None) -> None:
        ...
    @property
    def volume(self) -> float:
        r"""
        (float):  [Read-Only] Volume multiplier.
        """
        ...
    @property
    def pitch(self) -> float:
        r"""
        (float):  [Read-Only] Pitch multiplier.
        """
        ...
    @property
    def low_pass_filter_frequency(self) -> float:
        r"""
        (float):  [Read-Only] Lowpass filter cutoff frequency
        """
        ...
    @property
    def attenuation_distance_scale(self) -> float:
        r"""
        (float):  [Read-Only] Scales the distance measurement used by the audio engine when determining distance-based attenuation.
        E.g., a sound 1000 units away with an AttenuationDistanceScale of .5 will be attenuated
        as if it is 500 units away from the listener.
        Allows adjusting attenuation settings dynamically.
        """
        ...
    @property
    def lfe_bleed(self) -> float:
        r"""
        (float):  [Read-Only] The amount of a sound to bleed to the LFE channel
        """
        ...
    @property
    def voice_center_channel_volume(self) -> float:
        r"""
        (float):  [Read-Only] The amount to send to center channel (does not propagate to child classes)
        """
        ...
    @property
    def radio_filter_volume(self) -> float:
        r"""
        (float):  [Read-Only] Volume of the radio filter effect.
        """
        ...
    @property
    def radio_filter_volume_threshold(self) -> float:
        r"""
        (float):  [Read-Only] Volume at which the radio filter kicks in
        """
        ...
    @property
    def apply_effects(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to use 'Master EQ Submix' as set in the 'Audio' category of Project Settings as the default submix for referencing sounds.
        """
        ...
    @property
    def always_play(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to inflate referencing sound's priority to always play.
        """
        ...
    @property
    def is_ui_sound(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether or not this sound plays when the game is paused in the UI
        """
        ...
    @property
    def is_music(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether or not this is music (propagates to child classes only if parent is true)
        """
        ...
    @property
    def center_channel_only(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether or not this sound class forces sounds to the center channel
        """
        ...
    @property
    def apply_ambient_volumes(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the Interior/Exterior volume and LPF modifiers should be applied
        """
        ...
    @property
    def reverb(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether or not sounds referencing this class send to the reverb submix
        """
        ...
    @property
    def default2d_reverb_send_amount(self) -> float:
        r"""
        (float):  [Read-Only] Send amount to master reverb effect for referencing unattenuated (2D) sounds.
        """
        ...
    @property
    def modulation_settings(self) -> SoundModulationDefaultSettings:
        r"""
        (SoundModulationDefaultSettings):  [Read-Only] Default modulation settings for sounds directly referencing this class
        """
        ...
    @property
    def output_target(self) -> AudioOutputTarget:
        r"""
        (AudioOutputTarget):  [Read-Only] Which output target the sound should be played through
        """
        ...
    @property
    def loading_behavior(self) -> SoundWaveLoadingBehavior:
        r"""
        (SoundWaveLoadingBehavior):  [Read-Only] Specifies how and when compressed audio data is loaded for asset if stream caching is enabled.
        """
        ...
    @property
    def default_submix(self) -> SoundSubmix:
        r"""
        (SoundSubmix):  [Read-Only] Default output submix of referencing sounds. If unset, falls back to the 'Master Submix' as set in the 'Audio' category of Project Settings.
        (Unavailable if legacy 'Output to Master EQ Submix' is set)
        """
        ...

class SoundModulationDefaultSettings(StructBase):
    r"""
    Default parameter destination settings for source audio object.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundModulationDestination.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``highpass_modulation_destination`` (SoundModulationDestinationSettings):  [Read-Write] Highpass modulation
    - ``lowpass_modulation_destination`` (SoundModulationDestinationSettings):  [Read-Write] Lowpass modulation
    - ``pitch_modulation_destination`` (SoundModulationDestinationSettings):  [Read-Write] Pitch modulation
    - ``volume_modulation_destination`` (SoundModulationDestinationSettings):  [Read-Write] Volume modulation
    """
    def __init__(self, volume_modulation_destination: SoundModulationDestinationSettings = [1.000000, []], pitch_modulation_destination: SoundModulationDestinationSettings = [1.000000, []], highpass_modulation_destination: SoundModulationDestinationSettings = [1.000000, []], lowpass_modulation_destination: SoundModulationDestinationSettings = [1.000000, []]) -> None:
        ...
    @property
    def volume_modulation_destination(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] Volume modulation
        """
        ...
    @volume_modulation_destination.setter
    def volume_modulation_destination(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def pitch_modulation_destination(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] Pitch modulation
        """
        ...
    @pitch_modulation_destination.setter
    def pitch_modulation_destination(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def highpass_modulation_destination(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] Highpass modulation
        """
        ...
    @highpass_modulation_destination.setter
    def highpass_modulation_destination(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def lowpass_modulation_destination(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] Lowpass modulation
        """
        ...
    @lowpass_modulation_destination.setter
    def lowpass_modulation_destination(self, value: SoundModulationDestinationSettings) -> None:
        ...

class SoundModulationDestinationSettings(StructBase):
    r"""
    Parameter destination settings allowing modulation control override for parameter destinations opting in to the Modulation System.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundModulationDestination.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_modulation`` (bool):  [Read-Write] Whether or not to enable modulation
    - ``modulator`` (SoundModulatorBase):  [Read-Write]
      deprecated: Property 'Modulator' is deprecated.
    - ``modulators`` (Set[SoundModulatorBase]):  [Read-Write] Set of modulation sources, which provides values to mix with base value.
    - ``value`` (float):  [Read-Write] Base value of parameter
    """
    def __init__(self, value: float = 0.000000, modulators: Set[SoundModulatorBase] = []) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write] Base value of parameter
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def modulator(self) -> SoundModulatorBase:
        r"""
        (SoundModulatorBase):  [Read-Write]
        deprecated: Property 'Modulator' is deprecated.
        """
        ...
    @modulator.setter
    def modulator(self, value: SoundModulatorBase) -> None:
        ...
    @property
    def modulators(self) -> Set[SoundModulatorBase]:
        r"""
        (Set[SoundModulatorBase]):  [Read-Write] Set of modulation sources, which provides values to mix with base value.
        """
        ...
    @modulators.setter
    def modulators(self, value: Set[SoundModulatorBase]) -> None:
        ...

class PassiveSoundMixModifier(StructBase):
    r"""
    Structure containing information on a SoundMix to activate passively.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundClass.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max_volume_threshold`` (float):  [Read-Write] Maximum volume level required to activate SoundMix. Above this value the SoundMix will not be active.
    - ``min_volume_threshold`` (float):  [Read-Write] Minimum volume level required to activate SoundMix. Below this value the SoundMix will not be active.
    - ``sound_mix`` (SoundMix):  [Read-Write] The SoundMix to activate
    """
    def __init__(self, sound_mix: SoundMix = None, min_volume_threshold: float = 0.000000, max_volume_threshold: float = 0.000000) -> None:
        ...
    @property
    def sound_mix(self) -> SoundMix:
        r"""
        (SoundMix):  [Read-Only] The SoundMix to activate
        """
        ...
    @property
    def min_volume_threshold(self) -> float:
        r"""
        (float):  [Read-Only] Minimum volume level required to activate SoundMix. Below this value the SoundMix will not be active.
        """
        ...
    @property
    def volume_threshold(self) -> float:
        r"""
        deprecated: 'volume_threshold' was renamed to 'min_volume_threshold'.
        """
        ...
    @property
    def max_volume_threshold(self) -> float:
        r"""
        (float):  [Read-Only] Maximum volume level required to activate SoundMix. Above this value the SoundMix will not be active.
        """
        ...

class SoundConcurrencySettings(StructBase):
    r"""
    Sound Concurrency Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundConcurrency.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``limit_to_owner`` (bool):  [Read-Write] Whether or not to limit the concurrency to per sound owner (i.e. the actor that plays the sound). If the sound doesn't have an owner, it falls back to global concurrency.
    - ``max_count`` (int32):  [Read-Write] The max number of allowable concurrent active voices for voices playing in this concurrency group.
    - ``resolution_rule`` (MaxConcurrentResolutionRule):  [Read-Write] Which concurrency resolution policy to use if max voice count is reached.
    - ``retrigger_time`` (float):  [Read-Write] Amount of time to wait (in seconds) between different sounds which play with this concurrency. Sounds rejected from this will ignore virtualization settings.
    - ``voice_steal_release_time`` (float):  [Read-Write] Time taken to fade out if voice is evicted or culled due to another voice in the group starting.
    - ``volume_scale`` (float):  [Read-Write] Ducking factor to apply per older voice instance (generation), which compounds based on scaling mode
      and (optionally) revives them as they stop according to the provided attack/release times.
      
      Note: This is not applied until after StopQuietest rules are evaluated, in order to avoid thrashing sounds.
      
      AppliedVolumeScale = Math.Pow(DuckingScale, VoiceGeneration)
    - ``volume_scale_attack_time`` (float):  [Read-Write] Time taken to apply duck using volume scalar.
    - ``volume_scale_can_release`` (bool):  [Read-Write] Whether or not volume scaling can recover volume ducking behavior when concurrency group sounds stop (default scale mode only).
    - ``volume_scale_mode`` (ConcurrencyVolumeScaleMode):  [Read-Write] Volume Scale mode designating how to scale voice volume based on number of member sounds active in group.
    - ``volume_scale_release_time`` (float):  [Read-Write] Time taken to recover volume scalar duck.
    """
    def __init__(self, max_count: int = 0, limit_to_owner: bool = False, volume_scale_can_release: bool = False, resolution_rule: MaxConcurrentResolutionRule = MaxConcurrentResolutionRule.PREVENT_NEW, retrigger_time: float = 0.000000, volume_scale_mode: ConcurrencyVolumeScaleMode = ConcurrencyVolumeScaleMode.DEFAULT, volume_scale_attack_time: float = 0.000000, volume_scale_release_time: float = 0.000000, voice_steal_release_time: float = 0.000000) -> None:
        ...
    @property
    def max_count(self) -> int:
        r"""
        (int32):  [Read-Write] The max number of allowable concurrent active voices for voices playing in this concurrency group.
        """
        ...
    @max_count.setter
    def max_count(self, value: int) -> None:
        ...
    @property
    def limit_to_owner(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to limit the concurrency to per sound owner (i.e. the actor that plays the sound). If the sound doesn't have an owner, it falls back to global concurrency.
        """
        ...
    @limit_to_owner.setter
    def limit_to_owner(self, value: bool) -> None:
        ...
    @property
    def volume_scale_can_release(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not volume scaling can recover volume ducking behavior when concurrency group sounds stop (default scale mode only).
        """
        ...
    @volume_scale_can_release.setter
    def volume_scale_can_release(self, value: bool) -> None:
        ...
    @property
    def resolution_rule(self) -> MaxConcurrentResolutionRule:
        r"""
        (MaxConcurrentResolutionRule):  [Read-Write] Which concurrency resolution policy to use if max voice count is reached.
        """
        ...
    @resolution_rule.setter
    def resolution_rule(self, value: MaxConcurrentResolutionRule) -> None:
        ...
    @property
    def retrigger_time(self) -> float:
        r"""
        (float):  [Read-Write] Amount of time to wait (in seconds) between different sounds which play with this concurrency. Sounds rejected from this will ignore virtualization settings.
        """
        ...
    @retrigger_time.setter
    def retrigger_time(self, value: float) -> None:
        ...
    @property
    def volume_scale_mode(self) -> ConcurrencyVolumeScaleMode:
        r"""
        (ConcurrencyVolumeScaleMode):  [Read-Write] Volume Scale mode designating how to scale voice volume based on number of member sounds active in group.
        """
        ...
    @volume_scale_mode.setter
    def volume_scale_mode(self, value: ConcurrencyVolumeScaleMode) -> None:
        ...
    @property
    def volume_scale_attack_time(self) -> float:
        r"""
        (float):  [Read-Write] Time taken to apply duck using volume scalar.
        """
        ...
    @volume_scale_attack_time.setter
    def volume_scale_attack_time(self, value: float) -> None:
        ...
    @property
    def volume_scale_release_time(self) -> float:
        r"""
        (float):  [Read-Write] Time taken to recover volume scalar duck.
        """
        ...
    @volume_scale_release_time.setter
    def volume_scale_release_time(self, value: float) -> None:
        ...
    @property
    def voice_steal_release_time(self) -> float:
        r"""
        (float):  [Read-Write] Time taken to fade out if voice is evicted or culled due to another voice in the group starting.
        """
        ...
    @voice_steal_release_time.setter
    def voice_steal_release_time(self, value: float) -> None:
        ...

class SoundClassAdjuster(StructBase):
    r"""
    Elements of data for sound group volume control
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundMix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_to_children`` (bool):  [Read-Write] Set to true to apply this adjuster to all children of the sound class.
    - ``low_pass_filter_frequency`` (float):  [Read-Write] Lowpass filter cutoff frequency to apply to sound sources.
    - ``pitch_adjuster`` (float):  [Read-Write] A multiplier applied to the pitch.
    - ``sound_class_object`` (SoundClass):  [Read-Write] The sound class this adjuster affects.
    - ``voice_center_channel_volume_adjuster`` (float):  [Read-Write] A multiplier applied to VoiceCenterChannelVolume.
    - ``volume_adjuster`` (float):  [Read-Write] A multiplier applied to the volume.
    """
    def __init__(self, sound_class_object: SoundClass = None, volume_adjuster: float = 0.000000, pitch_adjuster: float = 0.000000, low_pass_filter_frequency: float = 0.000000, apply_to_children: bool = False, voice_center_channel_volume_adjuster: float = 0.000000) -> None:
        ...
    @property
    def sound_class_object(self) -> SoundClass:
        r"""
        (SoundClass):  [Read-Only] The sound class this adjuster affects.
        """
        ...
    @property
    def volume_adjuster(self) -> float:
        r"""
        (float):  [Read-Only] A multiplier applied to the volume.
        """
        ...
    @property
    def pitch_adjuster(self) -> float:
        r"""
        (float):  [Read-Only] A multiplier applied to the pitch.
        """
        ...
    @property
    def low_pass_filter_frequency(self) -> float:
        r"""
        (float):  [Read-Only] Lowpass filter cutoff frequency to apply to sound sources.
        """
        ...
    @property
    def apply_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] Set to true to apply this adjuster to all children of the sound class.
        """
        ...
    @property
    def voice_center_channel_volume_adjuster(self) -> float:
        r"""
        (float):  [Read-Only] A multiplier applied to VoiceCenterChannelVolume.
        """
        ...

class SoundModulationDefaultRoutingSettings(SoundModulationDefaultSettings):
    r"""
    Default parameter destination settings for source audio object.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundModulationDestination.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``highpass_modulation_destination`` (SoundModulationDestinationSettings):  [Read-Write] Highpass modulation
    - ``highpass_routing`` (ModulationRouting):  [Read-Write] What high-pass modulation settings to use
    - ``lowpass_modulation_destination`` (SoundModulationDestinationSettings):  [Read-Write] Lowpass modulation
    - ``lowpass_routing`` (ModulationRouting):  [Read-Write] What low-pass modulation settings to use
    - ``pitch_modulation_destination`` (SoundModulationDestinationSettings):  [Read-Write] Pitch modulation
    - ``pitch_routing`` (ModulationRouting):  [Read-Write] What pitch modulation settings to use
    - ``volume_modulation_destination`` (SoundModulationDestinationSettings):  [Read-Write] Volume modulation
    - ``volume_routing`` (ModulationRouting):  [Read-Write] What volume modulation settings to use
    """
    def __init__(self, volume_modulation_destination: SoundModulationDestinationSettings = [1.000000, []], pitch_modulation_destination: SoundModulationDestinationSettings = [1.000000, []], highpass_modulation_destination: SoundModulationDestinationSettings = [1.000000, []], lowpass_modulation_destination: SoundModulationDestinationSettings = [1.000000, []], volume_routing: ModulationRouting = ModulationRouting.DISABLE, pitch_routing: ModulationRouting = ModulationRouting.DISABLE, highpass_routing: ModulationRouting = ModulationRouting.DISABLE, lowpass_routing: ModulationRouting = ModulationRouting.DISABLE) -> None:
        ...
    @property
    def volume_routing(self) -> ModulationRouting:
        r"""
        (ModulationRouting):  [Read-Write] What volume modulation settings to use
        """
        ...
    @volume_routing.setter
    def volume_routing(self, value: ModulationRouting) -> None:
        ...
    @property
    def pitch_routing(self) -> ModulationRouting:
        r"""
        (ModulationRouting):  [Read-Write] What pitch modulation settings to use
        """
        ...
    @pitch_routing.setter
    def pitch_routing(self, value: ModulationRouting) -> None:
        ...
    @property
    def highpass_routing(self) -> ModulationRouting:
        r"""
        (ModulationRouting):  [Read-Write] What high-pass modulation settings to use
        """
        ...
    @highpass_routing.setter
    def highpass_routing(self, value: ModulationRouting) -> None:
        ...
    @property
    def lowpass_routing(self) -> ModulationRouting:
        r"""
        (ModulationRouting):  [Read-Write] What low-pass modulation settings to use
        """
        ...
    @lowpass_routing.setter
    def lowpass_routing(self, value: ModulationRouting) -> None:
        ...

class SoundSubmixSpectralAnalysisBandSettings(StructBase):
    r"""
    Sound Submix Spectral Analysis Band Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmixSend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attack_time_msec`` (int32):  [Read-Write] The attack time for the FFT band interpolation for delegate callback
    - ``band_frequency`` (float):  [Read-Write] The frequency band for the magnitude to analyze
    - ``q_factor`` (float):  [Read-Write] The ratio of the bandwidth divided by the center frequency. Only used when the spectral analysis type is set to Constant Q.
    - ``release_time_msec`` (int32):  [Read-Write] The release time for the FFT band interpolation for delegate callback
    """
    def __init__(self, band_frequency: float = 0.000000, attack_time_msec: int = 0, release_time_msec: int = 0, q_factor: float = 0.000000) -> None:
        ...
    @property
    def band_frequency(self) -> float:
        r"""
        (float):  [Read-Write] The frequency band for the magnitude to analyze
        """
        ...
    @band_frequency.setter
    def band_frequency(self, value: float) -> None:
        ...
    @property
    def attack_time_msec(self) -> int:
        r"""
        (int32):  [Read-Write] The attack time for the FFT band interpolation for delegate callback
        """
        ...
    @attack_time_msec.setter
    def attack_time_msec(self, value: int) -> None:
        ...
    @property
    def release_time_msec(self) -> int:
        r"""
        (int32):  [Read-Write] The release time for the FFT band interpolation for delegate callback
        """
        ...
    @release_time_msec.setter
    def release_time_msec(self, value: int) -> None:
        ...
    @property
    def q_factor(self) -> float:
        r"""
        (float):  [Read-Write] The ratio of the bandwidth divided by the center frequency. Only used when the spectral analysis type is set to Constant Q.
        """
        ...
    @q_factor.setter
    def q_factor(self, value: float) -> None:
        ...

class StaticMaterial(StructBase):
    r"""
    Static Material
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StaticMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``imported_material_slot_name`` (Name):  [Read-Only] This name should be use when we re-import a skeletal mesh so we can order the Materials array like it should be
    - ``material_interface`` (MaterialInterface):  [Read-Write]
    - ``material_slot_name`` (Name):  [Read-Write] This name should be use by the gameplay to avoid error if the skeletal mesh Materials array topology change
    - ``uv_channel_data`` (MeshUVChannelInfo):  [Read-Only] Data used for texture streaming relative to each UV channels.
    """
    def __init__(self, material_interface: MaterialInterface = None, material_slot_name: Name = "None", uv_channel_data: MeshUVChannelInfo = []) -> None:
        ...
    @property
    def material_interface(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Write]
        """
        ...
    @material_interface.setter
    def material_interface(self, value: MaterialInterface) -> None:
        ...
    @property
    def material_slot_name(self) -> Name:
        r"""
        (Name):  [Read-Write] This name should be use by the gameplay to avoid error if the skeletal mesh Materials array topology change
        """
        ...
    @material_slot_name.setter
    def material_slot_name(self, value: Name) -> None:
        ...
    @property
    def uv_channel_data(self) -> MeshUVChannelInfo:
        r"""
        (MeshUVChannelInfo):  [Read-Only] Data used for texture streaming relative to each UV channels.
        """
        ...

class TextureSourceColorSettings(StructBase):
    r"""
    Texture Source Color Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Texture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blue_chromaticity_coordinate`` (Vector2D):  [Read-Write] Blue chromaticity coordinate of the source color space.
    - ``chromatic_adaptation_method`` (TextureChromaticAdaptationMethod):  [Read-Write] Chromatic adaption method applied if the source white point differs from the working color space white point.
    - ``color_space`` (TextureColorSpace):  [Read-Write] Source color space of the texture.
    - ``encoding_override`` (TextureSourceEncoding):  [Read-Write] Source encoding of the texture, exposing more options than just sRGB.
    - ``green_chromaticity_coordinate`` (Vector2D):  [Read-Write] Green chromaticity coordinate of the source color space.
    - ``red_chromaticity_coordinate`` (Vector2D):  [Read-Write] Red chromaticity coordinate of the source color space.
    - ``white_chromaticity_coordinate`` (Vector2D):  [Read-Write] White chromaticity coordinate of the source color space.
    """
    def __init__(self, encoding_override: TextureSourceEncoding = TextureSourceEncoding.TSE_NONE, color_space: TextureColorSpace = TextureColorSpace.TCS_NONE, red_chromaticity_coordinate: Vector2D = [0.000000, 0.000000], green_chromaticity_coordinate: Vector2D = [0.000000, 0.000000], blue_chromaticity_coordinate: Vector2D = [0.000000, 0.000000], white_chromaticity_coordinate: Vector2D = [0.000000, 0.000000], chromatic_adaptation_method: TextureChromaticAdaptationMethod = TextureChromaticAdaptationMethod.TCAM_NONE) -> None:
        ...
    @property
    def encoding_override(self) -> TextureSourceEncoding:
        r"""
        (TextureSourceEncoding):  [Read-Write] Source encoding of the texture, exposing more options than just sRGB.
        """
        ...
    @encoding_override.setter
    def encoding_override(self, value: TextureSourceEncoding) -> None:
        ...
    @property
    def color_space(self) -> TextureColorSpace:
        r"""
        (TextureColorSpace):  [Read-Write] Source color space of the texture.
        """
        ...
    @color_space.setter
    def color_space(self, value: TextureColorSpace) -> None:
        ...
    @property
    def red_chromaticity_coordinate(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Red chromaticity coordinate of the source color space.
        """
        ...
    @red_chromaticity_coordinate.setter
    def red_chromaticity_coordinate(self, value: Vector2D) -> None:
        ...
    @property
    def green_chromaticity_coordinate(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Green chromaticity coordinate of the source color space.
        """
        ...
    @green_chromaticity_coordinate.setter
    def green_chromaticity_coordinate(self, value: Vector2D) -> None:
        ...
    @property
    def blue_chromaticity_coordinate(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Blue chromaticity coordinate of the source color space.
        """
        ...
    @blue_chromaticity_coordinate.setter
    def blue_chromaticity_coordinate(self, value: Vector2D) -> None:
        ...
    @property
    def white_chromaticity_coordinate(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] White chromaticity coordinate of the source color space.
        """
        ...
    @white_chromaticity_coordinate.setter
    def white_chromaticity_coordinate(self, value: Vector2D) -> None:
        ...
    @property
    def chromatic_adaptation_method(self) -> TextureChromaticAdaptationMethod:
        r"""
        (TextureChromaticAdaptationMethod):  [Read-Write] Chromatic adaption method applied if the source white point differs from the working color space white point.
        """
        ...
    @chromatic_adaptation_method.setter
    def chromatic_adaptation_method(self, value: TextureChromaticAdaptationMethod) -> None:
        ...

class CanvasIcon(StructBase):
    r"""
    Holds texture information with UV coordinates as well.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Canvas.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``texture`` (Texture):  [Read-Write] Source texture
    - ``u`` (float):  [Read-Write] UV coords
    - ``ul`` (float):  [Read-Write]
    - ``v`` (float):  [Read-Write]
    - ``vl`` (float):  [Read-Write]
    """
    def __init__(self, texture: Texture = None, u: float = 0.000000, v: float = 0.000000, ul: float = 0.000000, vl: float = 0.000000) -> None:
        ...
    @property
    def texture(self) -> Texture:
        r"""
        (Texture):  [Read-Write] Source texture
        """
        ...
    @texture.setter
    def texture(self, value: Texture) -> None:
        ...
    @property
    def u(self) -> float:
        r"""
        (float):  [Read-Write] UV coords
        """
        ...
    @u.setter
    def u(self, value: float) -> None:
        ...
    @property
    def v(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @v.setter
    def v(self, value: float) -> None:
        ...
    @property
    def ul(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @ul.setter
    def ul(self, value: float) -> None:
        ...
    @property
    def vl(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @vl.setter
    def vl(self, value: float) -> None:
        ...

class HardwareDeviceIdentifier(StructBase):
    r"""
    An identifier that can be used to determine what input devices are available based on the FInputDeviceScope.
    These mappings should match a FInputDeviceScope that is used by an IInputDevice
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``hardware_device_identifier`` (Name):  [Read-Write] The name of this hardware device.
      This should correspond with a FInputDeviceScope that is used by an IInputDevice
    - ``input_class_name`` (Name):  [Read-Write] The name of the Input Class that uses this hardware device.
      This should correspond with a FInputDeviceScope that is used by an IInputDevice
    - ``primary_device_type`` (HardwareDevicePrimaryType):  [Read-Write] The generic type that this hardware identifies as. This can be used to easily determine behaviors
    - ``supported_features_mask`` (int32):  [Read-Write] Flags that represent this hardware device's traits
    """
    def __init__(self, input_class_name: Name = "None", hardware_device_identifier: Name = "None", primary_device_type: HardwareDevicePrimaryType = HardwareDevicePrimaryType.UNSPECIFIED, supported_features_mask: int = 0) -> None:
        ...
    @property
    def input_class_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of the Input Class that uses this hardware device.
        This should correspond with a FInputDeviceScope that is used by an IInputDevice
        """
        ...
    @property
    def hardware_device_identifier(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of this hardware device.
        This should correspond with a FInputDeviceScope that is used by an IInputDevice
        """
        ...
    @property
    def primary_device_type(self) -> HardwareDevicePrimaryType:
        r"""
        (HardwareDevicePrimaryType):  [Read-Only] The generic type that this hardware identifies as. This can be used to easily determine behaviors
        """
        ...
    @property
    def supported_features_mask(self) -> int:
        r"""
        (int32):  [Read-Only] Flags that represent this hardware device's traits
        """
        ...

class InputActionKeyMapping(StructBase):
    r"""
    Defines a mapping between an action and key
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Input/index.html
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerInput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``action_name`` (Name):  [Read-Write] Friendly name of action, e.g "jump"
    - ``alt`` (bool):  [Read-Write] true if one of the Alt keys must be down when the KeyEvent is received to be acknowledged
    - ``cmd`` (bool):  [Read-Write] true if one of the Cmd keys must be down when the KeyEvent is received to be acknowledged
    - ``ctrl`` (bool):  [Read-Write] true if one of the Ctrl keys must be down when the KeyEvent is received to be acknowledged
    - ``key`` (Key):  [Read-Write] Key to bind it to.
    - ``shift`` (bool):  [Read-Write] true if one of the Shift keys must be down when the KeyEvent is received to be acknowledged
    """
    def __init__(self, action_name: Name = "None", shift: bool = False, ctrl: bool = False, alt: bool = False, cmd: bool = False, key: Key = []) -> None:
        ...
    @property
    def action_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Friendly name of action, e.g "jump"
        """
        ...
    @action_name.setter
    def action_name(self, value: Name) -> None:
        ...
    @property
    def shift(self) -> bool:
        r"""
        (bool):  [Read-Write] true if one of the Shift keys must be down when the KeyEvent is received to be acknowledged
        """
        ...
    @shift.setter
    def shift(self, value: bool) -> None:
        ...
    @property
    def ctrl(self) -> bool:
        r"""
        (bool):  [Read-Write] true if one of the Ctrl keys must be down when the KeyEvent is received to be acknowledged
        """
        ...
    @ctrl.setter
    def ctrl(self, value: bool) -> None:
        ...
    @property
    def alt(self) -> bool:
        r"""
        (bool):  [Read-Write] true if one of the Alt keys must be down when the KeyEvent is received to be acknowledged
        """
        ...
    @alt.setter
    def alt(self, value: bool) -> None:
        ...
    @property
    def cmd(self) -> bool:
        r"""
        (bool):  [Read-Write] true if one of the Cmd keys must be down when the KeyEvent is received to be acknowledged
        """
        ...
    @cmd.setter
    def cmd(self, value: bool) -> None:
        ...
    @property
    def key(self) -> Key:
        r"""
        (Key):  [Read-Write] Key to bind it to.
        """
        ...
    @key.setter
    def key(self, value: Key) -> None:
        ...

class InputAxisKeyMapping(StructBase):
    r"""
    Defines a mapping between an axis and key
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Input/index.html
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerInput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis_name`` (Name):  [Read-Write] Friendly name of axis, e.g "MoveForward"
    - ``key`` (Key):  [Read-Write] Key to bind it to.
    - ``scale`` (float):  [Read-Write] Multiplier to use for the mapping when accumulating the axis value
    """
    def __init__(self, axis_name: Name = "None", scale: float = 0.000000, key: Key = []) -> None:
        ...
    @property
    def axis_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Friendly name of axis, e.g "MoveForward"
        """
        ...
    @axis_name.setter
    def axis_name(self, value: Name) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write] Multiplier to use for the mapping when accumulating the axis value
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def key(self) -> Key:
        r"""
        (Key):  [Read-Write] Key to bind it to.
        """
        ...
    @key.setter
    def key(self, value: Key) -> None:
        ...

class InputActionSpeechMapping(StructBase):
    r"""
    Defines a mapping between an action and speech recognition
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Input/index.html
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerInput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``action_name`` (Name):  [Read-Write] Friendly name of action, e.g "jump"
    - ``speech_keyword`` (Name):  [Read-Write] Key to bind it to.
    """
    def __init__(self) -> None:
        ...

class VoiceSettings(StructBase):
    r"""
    Voice Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VoiceConfig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] Optional attenuation settings to attach to this player's voice.
      This should only be used when ComponentToAttachTo is set.
    - ``component_to_attach_to`` (SceneComponent):  [Read-Write] Optionally attach the voice source to a Scene Component to give the appearance
      that the voice is coming from that scene component.
      If this is not set, the voice will not be spatialized.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] Optional audio effects to apply to this player's voice.
    """
    def __init__(self, component_to_attach_to: SceneComponent = None, attenuation_settings: SoundAttenuation = None, source_effect_chain: SoundEffectSourcePresetChain = None) -> None:
        ...
    @property
    def component_to_attach_to(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Write] Optionally attach the voice source to a Scene Component to give the appearance
        that the voice is coming from that scene component.
        If this is not set, the voice will not be spatialized.
        """
        ...
    @component_to_attach_to.setter
    def component_to_attach_to(self, value: SceneComponent) -> None:
        ...
    @property
    def attenuation_settings(self) -> SoundAttenuation:
        r"""
        (SoundAttenuation):  [Read-Write] Optional attenuation settings to attach to this player's voice.
        This should only be used when ComponentToAttachTo is set.
        """
        ...
    @attenuation_settings.setter
    def attenuation_settings(self, value: SoundAttenuation) -> None:
        ...
    @property
    def source_effect_chain(self) -> SoundEffectSourcePresetChain:
        r"""
        (SoundEffectSourcePresetChain):  [Read-Write] Optional audio effects to apply to this player's voice.
        """
        ...
    @source_effect_chain.setter
    def source_effect_chain(self, value: SoundEffectSourcePresetChain) -> None:
        ...

class ActorDesc(StructBase):
    r"""
    Snapshot of an actor descriptor, which represents the state of an actor on disk.
    The actor may or may not be loaded.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionBlueprintLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_is_editor_only`` (bool):  [Read-Only] Actor's editor-only property.
    - ``actor_package`` (Name):  [Read-Only] Actor's package name.
    - ``actor_path`` (Name):  [Read-Only] Actor's path name.
    - ``bounds`` (Box):  [Read-Only] Streaming bounds of this actor.
    - ``class_`` (SoftObjectPath):  [Read-Only] Actor class, can point to a native or Blueprint class and may be redirected.
    - ``data_layer_assets`` (Array[SoftObjectPath]):  [Read-Only] Actor's data layer assets.
    - ``guid`` (Guid):  [Read-Only] The actor GUID of this descriptor.
    - ``is_spatially_loaded`` (bool):  [Read-Only] Actor's streaming state.
    - ``label`` (Name):  [Read-Only] Actor's label.
    - ``name`` (Name):  [Read-Only] Internal name of the acgor.
    - ``native_class`` (type(Class)):  [Read-Only] Actor first native class.
    - ``runtime_grid`` (Name):  [Read-Only] Actor's target runtime grid.
    """
    def __init__(self, guid: Guid = [], native_class: Class = None, class_: SoftObjectPath = [""], name: Name = "None", label: Name = "None", bounds: Box = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], False], runtime_grid: Name = "None", is_spatially_loaded: bool = False, actor_is_editor_only: bool = False, actor_package: Name = "None", actor_path: Name = "None", data_layer_assets: Array[SoftObjectPath] = []) -> None:
        ...
    @property
    def guid(self) -> Guid:
        r"""
        (Guid):  [Read-Only] The actor GUID of this descriptor.
        """
        ...
    @property
    def native_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] Actor first native class.
        """
        ...
    @property
    def class_(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Only] Actor class, can point to a native or Blueprint class and may be redirected.
        """
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only] Internal name of the acgor.
        """
        ...
    @property
    def label(self) -> Name:
        r"""
        (Name):  [Read-Only] Actor's label.
        """
        ...
    @property
    def bounds(self) -> Box:
        r"""
        (Box):  [Read-Only] Streaming bounds of this actor.
        """
        ...
    @property
    def runtime_grid(self) -> Name:
        r"""
        (Name):  [Read-Only] Actor's target runtime grid.
        """
        ...
    @property
    def is_spatially_loaded(self) -> bool:
        r"""
        (bool):  [Read-Only] Actor's streaming state.
        """
        ...
    @property
    def actor_is_editor_only(self) -> bool:
        r"""
        (bool):  [Read-Only] Actor's editor-only property.
        """
        ...
    @property
    def actor_package(self) -> Name:
        r"""
        (Name):  [Read-Only] Actor's package name.
        """
        ...
    @property
    def actor_path(self) -> Name:
        r"""
        (Name):  [Read-Only] Actor's path name.
        """
        ...
    @property
    def data_layer_assets(self) -> Array[SoftObjectPath]:
        r"""
        (Array[SoftObjectPath]):  [Read-Only] Actor's data layer assets.
        """
        ...

class WorldPartitionHLODDestructionTag(StructBase):
    r"""
    World Partition HLODDestruction Tag
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODDestruction.h
    
    """
    def __init__(self) -> None:
        ...

class StreamingSourceShape(StructBase):
    r"""
    Streaming Source Shape
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionStreamingSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_sector`` (bool):  [Read-Write] Whether the source shape is a spherical sector instead of a regular sphere source.
    - ``loading_range_scale`` (float):  [Read-Write] Applies a scale to the grid's loading range (used if bUseGridLoadingRange is True).
    - ``location`` (Vector):  [Read-Write] Streaming source shape location (local to streaming source).
    - ``radius`` (float):  [Read-Write] Custom streaming source shape radius (not used if bUseGridLoadingRange is True).
    - ``rotation`` (Rotator):  [Read-Write] Streaming source shape rotation (local to streaming source).
    - ``sector_angle`` (float):  [Read-Write] Shape's spherical sector angle in degree (not used if bIsSector is False).
    - ``use_grid_loading_range`` (bool):  [Read-Write] If True, streaming source shape radius is bound to loading range radius.
    """
    def __init__(self, use_grid_loading_range: bool = False, loading_range_scale: float = 0.000000, radius: float = 0.000000, is_sector: bool = False, sector_angle: float = 0.000000, location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def use_grid_loading_range(self) -> bool:
        r"""
        (bool):  [Read-Write] If True, streaming source shape radius is bound to loading range radius.
        """
        ...
    @use_grid_loading_range.setter
    def use_grid_loading_range(self, value: bool) -> None:
        ...
    @property
    def loading_range_scale(self) -> float:
        r"""
        (float):  [Read-Write] Applies a scale to the grid's loading range (used if bUseGridLoadingRange is True).
        """
        ...
    @loading_range_scale.setter
    def loading_range_scale(self, value: float) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write] Custom streaming source shape radius (not used if bUseGridLoadingRange is True).
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def is_sector(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the source shape is a spherical sector instead of a regular sphere source.
        """
        ...
    @is_sector.setter
    def is_sector(self, value: bool) -> None:
        ...
    @property
    def sector_angle(self) -> float:
        r"""
        (float):  [Read-Write] Shape's spherical sector angle in degree (not used if bIsSector is False).
        """
        ...
    @sector_angle.setter
    def sector_angle(self, value: float) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Streaming source shape location (local to streaming source).
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] Streaming source shape rotation (local to streaming source).
        """
        ...
    @rotation.setter
    def rotation(self, value: Rotator) -> None:
        ...

class WorldPartitionStreamingQuerySource(StructBase):
    r"""
    Structure containing all properties required to query a streaming state
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionStreamingSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_layers`` (Array[Name]):  [Read-Write] Optional list of data layers to specialize the query. If empty only non data layer cells will be returned by the query.
    - ``data_layers_only`` (bool):  [Read-Write] If True, Only cells that are in a data layer found in DataLayers property will be returned by the query.
    - ``location`` (Vector):  [Read-Write] Location to query. (not used if bSpatialQuery is false)
    - ``radius`` (float):  [Read-Write] Radius to query. (not used if bSpatialQuery is false)
    - ``spatial_query`` (bool):  [Read-Write] If False, Location/Radius will not be used to find the cells. Only AlwaysLoaded cells will be returned by the query.
    - ``use_grid_loading_range`` (bool):  [Read-Write] If True, Instead of providing a query radius, query can be bound to loading range radius.
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], radius: float = 0.000000, use_grid_loading_range: bool = False, data_layers: Array[Name] = [], data_layers_only: bool = False, spatial_query: bool = False) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Location to query. (not used if bSpatialQuery is false)
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write] Radius to query. (not used if bSpatialQuery is false)
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def use_grid_loading_range(self) -> bool:
        r"""
        (bool):  [Read-Write] If True, Instead of providing a query radius, query can be bound to loading range radius.
        """
        ...
    @use_grid_loading_range.setter
    def use_grid_loading_range(self, value: bool) -> None:
        ...
    @property
    def data_layers(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Optional list of data layers to specialize the query. If empty only non data layer cells will be returned by the query.
        """
        ...
    @data_layers.setter
    def data_layers(self, value: Array[Name]) -> None:
        ...
    @property
    def data_layers_only(self) -> bool:
        r"""
        (bool):  [Read-Write] If True, Only cells that are in a data layer found in DataLayers property will be returned by the query.
        """
        ...
    @data_layers_only.setter
    def data_layers_only(self, value: bool) -> None:
        ...
    @property
    def spatial_query(self) -> bool:
        r"""
        (bool):  [Read-Write] If False, Location/Radius will not be used to find the cells. Only AlwaysLoaded cells will be returned by the query.
        """
        ...
    @spatial_query.setter
    def spatial_query(self, value: bool) -> None:
        ...

class ObservedComponent(StructBase):
    r"""
    Observed Component
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCaching
    - **File**: CacheManagerActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cache_name`` (Name):  [Read-Write] Unique name for the cache, used as a key into the cache collection
    - ``is_simulating`` (bool):  [Read-Write] Capture of the initial state of the component before cache manager takes control.
    - ``playback_enabled`` (bool):  [Read-Write] Whether this component is enabled for playback, this allow a cache to hold many component but only replay some of them.
    - ``soft_component_ref`` (SoftComponentReference):  [Read-Write] The component observed by this object for either playback or recording
    - ``usd_cache_directory`` (DirectoryPath):  [Read-Write] USD cache directory, if supported for this simulated structure type.
    """
    def __init__(self, cache_name: Name = "None", soft_component_ref: SoftComponentReference = [None, "None"], is_simulating: bool = False, playback_enabled: bool = False, usd_cache_directory: DirectoryPath = [""]) -> None:
        ...
    @property
    def cache_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Unique name for the cache, used as a key into the cache collection
        """
        ...
    @cache_name.setter
    def cache_name(self, value: Name) -> None:
        ...
    @property
    def soft_component_ref(self) -> SoftComponentReference:
        r"""
        (SoftComponentReference):  [Read-Write] The component observed by this object for either playback or recording
        """
        ...
    @soft_component_ref.setter
    def soft_component_ref(self, value: SoftComponentReference) -> None:
        ...
    @property
    def is_simulating(self) -> bool:
        r"""
        (bool):  [Read-Only] Capture of the initial state of the component before cache manager takes control.
        """
        ...
    @property
    def playback_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this component is enabled for playback, this allow a cache to hold many component but only replay some of them.
        """
        ...
    @playback_enabled.setter
    def playback_enabled(self, value: bool) -> None:
        ...
    @property
    def usd_cache_directory(self) -> DirectoryPath:
        r"""
        (DirectoryPath):  [Read-Write] USD cache directory, if supported for this simulated structure type.
        """
        ...
    @usd_cache_directory.setter
    def usd_cache_directory(self, value: DirectoryPath) -> None:
        ...

class InAppPurchaseProductRequest2(StructBase):
    r"""
    Micro-transaction request information
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseDataTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_consumable`` (bool):  [Read-Write] Flag to determine whether this is a consumable purchase, or not.
    - ``product_identifier`` (str):  [Read-Write] The unique product identifier that matches the one from your targeted store.
    """
    def __init__(self, product_identifier: str = "", is_consumable: bool = False) -> None:
        ...
    @property
    def product_identifier(self) -> str:
        r"""
        (str):  [Read-Write] The unique product identifier that matches the one from your targeted store.
        """
        ...
    @product_identifier.setter
    def product_identifier(self, value: str) -> None:
        ...
    @property
    def is_consumable(self) -> bool:
        r"""
        (bool):  [Read-Write] Flag to determine whether this is a consumable purchase, or not.
        """
        ...
    @is_consumable.setter
    def is_consumable(self, value: bool) -> None:
        ...

class InAppPurchaseProductInfo2(StructBase):
    r"""
    Micro-transaction purchase information
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseCallbackProxy2.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``currency_code`` (str):  [Read-Write] The localized currency code of the price
    - ``currency_symbol`` (str):  [Read-Write] The localized currency symbol of the price
    - ``decimal_separator`` (str):  [Read-Write] The localized decimal separator used in the price
    - ``display_description`` (str):  [Read-Write] The localized display description name
    - ``display_name`` (str):  [Read-Write] The localized display name
    - ``display_price`` (str):  [Read-Write] The localized display price name
    - ``dynamic_fields`` (Map[str, str]):  [Read-Write] Dynamic fields from raw Json data.
    - ``grouping_separator`` (str):  [Read-Write] The localized grouping separator of the price
    - ``identifier`` (str):  [Read-Write] The unique product identifier
    - ``raw_price`` (float):  [Read-Write] Raw price without currency code and symbol
    - ``receipt_data`` (str):  [Read-Write] Opaque receipt data for the transaction
    - ``transaction_identifier`` (str):  [Read-Write] the unique transaction identifier
    """
    def __init__(self, identifier: str = "", transaction_identifier: str = "", display_name: str = "", display_description: str = "", display_price: str = "", raw_price: float = 0.000000, currency_code: str = "", currency_symbol: str = "", decimal_separator: str = "", grouping_separator: str = "", receipt_data: str = "", dynamic_fields: Map[str, str] = {}) -> None:
        ...
    @property
    def identifier(self) -> str:
        r"""
        (str):  [Read-Only] The unique product identifier
        """
        ...
    @property
    def transaction_identifier(self) -> str:
        r"""
        (str):  [Read-Only] the unique transaction identifier
        """
        ...
    @property
    def display_name(self) -> str:
        r"""
        (str):  [Read-Only] The localized display name
        """
        ...
    @property
    def display_description(self) -> str:
        r"""
        (str):  [Read-Only] The localized display description name
        """
        ...
    @property
    def display_price(self) -> str:
        r"""
        (str):  [Read-Only] The localized display price name
        """
        ...
    @property
    def raw_price(self) -> float:
        r"""
        (float):  [Read-Only] Raw price without currency code and symbol
        """
        ...
    @property
    def currency_code(self) -> str:
        r"""
        (str):  [Read-Only] The localized currency code of the price
        """
        ...
    @property
    def currency_symbol(self) -> str:
        r"""
        (str):  [Read-Only] The localized currency symbol of the price
        """
        ...
    @property
    def decimal_separator(self) -> str:
        r"""
        (str):  [Read-Only] The localized decimal separator used in the price
        """
        ...
    @property
    def grouping_separator(self) -> str:
        r"""
        (str):  [Read-Only] The localized grouping separator of the price
        """
        ...
    @property
    def receipt_data(self) -> str:
        r"""
        (str):  [Read-Only] Opaque receipt data for the transaction
        """
        ...
    @property
    def dynamic_fields(self) -> Map[str, str]:
        r"""
        (Map[str, str]):  [Read-Only] Dynamic fields from raw Json data.
        """
        ...

class VariantDependency(StructBase):
    r"""
    Variant Dependency
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: Variant.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``variant`` (Variant):  [Read-Write]
    - ``variant_set`` (VariantSet):  [Read-Write]
    """
    def __init__(self, variant_set: VariantSet = None, variant: Variant = None, enabled: bool = False) -> None:
        ...
    @property
    def variant_set(self) -> VariantSet:
        r"""
        (VariantSet):  [Read-Only]
        """
        ...
    @property
    def variant(self) -> Variant:
        r"""
        (Variant):  [Read-Only]
        """
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class GLTFExportMessages(StructBase):
    r"""
    GLTFExport Messages
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFExporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``errors`` (Array[str]):  [Read-Write]
    - ``suggestions`` (Array[str]):  [Read-Write]
    - ``warnings`` (Array[str]):  [Read-Write]
    """
    def __init__(self, suggestions: Array[str] = [], warnings: Array[str] = [], errors: Array[str] = []) -> None:
        ...
    @property
    def suggestions(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write]
        """
        ...
    @suggestions.setter
    def suggestions(self, value: Array[str]) -> None:
        ...
    @property
    def warnings(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write]
        """
        ...
    @warnings.setter
    def warnings(self, value: Array[str]) -> None:
        ...
    @property
    def errors(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write]
        """
        ...
    @errors.setter
    def errors(self, value: Array[str]) -> None:
        ...

class GLTFMaterialBakeSize(StructBase):
    r"""
    GLTFMaterial Bake Size
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFMaterialUserData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_detect`` (bool):  [Read-Write] If enabled, bake size is based on the largest texture used in the material input's expression graph. If none found, bake size will fall back to the explicit dimensions.
    - ``x`` (int32):  [Read-Write]
    - ``y`` (int32):  [Read-Write]
    """
    def __init__(self, x: int = 0, y: int = 0, auto_detect: bool = False) -> None:
        ...
    @property
    def x(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: int) -> None:
        ...
    @property
    def y(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: int) -> None:
        ...
    @property
    def auto_detect(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, bake size is based on the largest texture used in the material input's expression graph. If none found, bake size will fall back to the explicit dimensions.
        """
        ...
    @auto_detect.setter
    def auto_detect(self, value: bool) -> None:
        ...

class GLTFOverrideMaterialBakeSettings(StructBase):
    r"""
    GLTFOverride Material Bake Settings
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFMaterialUserData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``filter`` (TextureFilter):  [Read-Write] Overrides the default filtering mode used when sampling the baked out texture.
    - ``override_filter`` (bool):  [Read-Write] If enabled, default filtering mode will be overridden by the corresponding property.
    - ``override_size`` (bool):  [Read-Write] If enabled, default size will be overridden by the corresponding property.
    - ``override_tiling`` (bool):  [Read-Write] If enabled, default addressing mode will be overridden by the corresponding property.
    - ``size`` (GLTFMaterialBakeSize):  [Read-Write] Overrides default size of the baked out texture.
    - ``tiling`` (TextureAddress):  [Read-Write] Overrides the default addressing mode used when sampling the baked out texture.
    """
    def __init__(self, override_size: bool = False, size: GLTFMaterialBakeSize = [1, 1, False], override_filter: bool = False, filter: TextureFilter = TextureFilter.TF_NEAREST, override_tiling: bool = False, tiling: TextureAddress = TextureAddress.TA_WRAP) -> None:
        ...
    @property
    def override_size(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, default size will be overridden by the corresponding property.
        """
        ...
    @override_size.setter
    def override_size(self, value: bool) -> None:
        ...
    @property
    def size(self) -> GLTFMaterialBakeSize:
        r"""
        (GLTFMaterialBakeSize):  [Read-Write] Overrides default size of the baked out texture.
        """
        ...
    @size.setter
    def size(self, value: GLTFMaterialBakeSize) -> None:
        ...
    @property
    def override_filter(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, default filtering mode will be overridden by the corresponding property.
        """
        ...
    @override_filter.setter
    def override_filter(self, value: bool) -> None:
        ...
    @property
    def filter(self) -> TextureFilter:
        r"""
        (TextureFilter):  [Read-Write] Overrides the default filtering mode used when sampling the baked out texture.
        """
        ...
    @filter.setter
    def filter(self, value: TextureFilter) -> None:
        ...
    @property
    def override_tiling(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, default addressing mode will be overridden by the corresponding property.
        """
        ...
    @override_tiling.setter
    def override_tiling(self, value: bool) -> None:
        ...
    @property
    def tiling(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] Overrides the default addressing mode used when sampling the baked out texture.
        """
        ...
    @tiling.setter
    def tiling(self, value: TextureAddress) -> None:
        ...

class DatasmithAssetImportOptions(StructBase):
    r"""
    Datasmith Asset Import Options
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    """
    def __init__(self) -> None:
        ...

class DatasmithStaticMeshImportOptions(StructBase):
    r"""
    Datasmith Static Mesh Import Options
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``generate_lightmap_u_vs`` (bool):  [Read-Write]
    - ``max_lightmap_resolution`` (DatasmithImportLightmapMax):  [Read-Write] Maximum resolution for auto-generated lightmap UVs
    - ``min_lightmap_resolution`` (DatasmithImportLightmapMin):  [Read-Write] Minimum resolution for auto-generated lightmap UVs
    - ``remove_degenerates`` (bool):  [Read-Write]
    """
    def __init__(self, min_lightmap_resolution: DatasmithImportLightmapMin = DatasmithImportLightmapMin.LIGHTMAP_16, max_lightmap_resolution: DatasmithImportLightmapMax = DatasmithImportLightmapMax.LIGHTMAP_64, generate_lightmap_u_vs: bool = False, remove_degenerates: bool = False) -> None:
        ...
    @property
    def min_lightmap_resolution(self) -> DatasmithImportLightmapMin:
        r"""
        (DatasmithImportLightmapMin):  [Read-Write] Minimum resolution for auto-generated lightmap UVs
        """
        ...
    @min_lightmap_resolution.setter
    def min_lightmap_resolution(self, value: DatasmithImportLightmapMin) -> None:
        ...
    @property
    def max_lightmap_resolution(self) -> DatasmithImportLightmapMax:
        r"""
        (DatasmithImportLightmapMax):  [Read-Write] Maximum resolution for auto-generated lightmap UVs
        """
        ...
    @max_lightmap_resolution.setter
    def max_lightmap_resolution(self, value: DatasmithImportLightmapMax) -> None:
        ...
    @property
    def generate_lightmap_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @generate_lightmap_u_vs.setter
    def generate_lightmap_u_vs(self, value: bool) -> None:
        ...
    @property
    def remove_degenerates(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @remove_degenerates.setter
    def remove_degenerates(self, value: bool) -> None:
        ...

class DatasmithReimportOptions(StructBase):
    r"""
    Datasmith Reimport Options
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``respawn_deleted_actors`` (bool):  [Read-Write] Specifies whether or not to add back Actors you've deleted from the current Level
    - ``update_actors`` (bool):  [Read-Write] Specifies whether or not to update Datasmith Scene Actors in the current Level
    """
    def __init__(self, update_actors: bool = False, respawn_deleted_actors: bool = False) -> None:
        ...
    @property
    def update_actors(self) -> bool:
        r"""
        (bool):  [Read-Write] Specifies whether or not to update Datasmith Scene Actors in the current Level
        """
        ...
    @update_actors.setter
    def update_actors(self, value: bool) -> None:
        ...
    @property
    def respawn_deleted_actors(self) -> bool:
        r"""
        (bool):  [Read-Write] Specifies whether or not to add back Actors you've deleted from the current Level
        """
        ...
    @respawn_deleted_actors.setter
    def respawn_deleted_actors(self, value: bool) -> None:
        ...

class DatasmithImportBaseOptions(StructBase):
    r"""
    Datasmith Import Base Options
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_options`` (DatasmithAssetImportOptions):  [Read-Write]
    - ``include_animation`` (bool):  [Read-Write] Specifies whether or not to import animations
    - ``include_camera`` (bool):  [Read-Write] Specifies whether or not to import cameras
    - ``include_geometry`` (bool):  [Read-Write] Specifies whether or not to import geometry
    - ``include_light`` (bool):  [Read-Write] Specifies whether or not to import lights
    - ``include_material`` (bool):  [Read-Write] Specifies whether or not to import materials and textures
    - ``scene_handling`` (DatasmithImportScene):  [Read-Write] Specifies where to put the content
    - ``static_mesh_options`` (DatasmithStaticMeshImportOptions):  [Read-Write]
    """
    def __init__(self, scene_handling: DatasmithImportScene = DatasmithImportScene.NEW_LEVEL, include_geometry: bool = False, include_material: bool = False, include_light: bool = False, include_camera: bool = False, include_animation: bool = False, asset_options: DatasmithAssetImportOptions = [], static_mesh_options: DatasmithStaticMeshImportOptions = [DatasmithImportLightmapMin.LIGHTMAP_64, DatasmithImportLightmapMax.LIGHTMAP_512, True, True]) -> None:
        ...
    @property
    def scene_handling(self) -> DatasmithImportScene:
        r"""
        (DatasmithImportScene):  [Read-Write] Specifies where to put the content
        """
        ...
    @scene_handling.setter
    def scene_handling(self, value: DatasmithImportScene) -> None:
        ...
    @property
    def include_geometry(self) -> bool:
        r"""
        (bool):  [Read-Write] Specifies whether or not to import geometry
        """
        ...
    @include_geometry.setter
    def include_geometry(self, value: bool) -> None:
        ...
    @property
    def include_material(self) -> bool:
        r"""
        (bool):  [Read-Write] Specifies whether or not to import materials and textures
        """
        ...
    @include_material.setter
    def include_material(self, value: bool) -> None:
        ...
    @property
    def include_light(self) -> bool:
        r"""
        (bool):  [Read-Write] Specifies whether or not to import lights
        """
        ...
    @include_light.setter
    def include_light(self, value: bool) -> None:
        ...
    @property
    def include_camera(self) -> bool:
        r"""
        (bool):  [Read-Write] Specifies whether or not to import cameras
        """
        ...
    @include_camera.setter
    def include_camera(self, value: bool) -> None:
        ...
    @property
    def include_animation(self) -> bool:
        r"""
        (bool):  [Read-Write] Specifies whether or not to import animations
        """
        ...
    @include_animation.setter
    def include_animation(self, value: bool) -> None:
        ...
    @property
    def asset_options(self) -> DatasmithAssetImportOptions:
        r"""
        (DatasmithAssetImportOptions):  [Read-Write]
        """
        ...
    @asset_options.setter
    def asset_options(self, value: DatasmithAssetImportOptions) -> None:
        ...
    @property
    def static_mesh_options(self) -> DatasmithStaticMeshImportOptions:
        r"""
        (DatasmithStaticMeshImportOptions):  [Read-Write]
        """
        ...
    @static_mesh_options.setter
    def static_mesh_options(self, value: DatasmithStaticMeshImportOptions) -> None:
        ...

class DatasmithTessellationOptions(StructBase):
    r"""
    Datasmith Tessellation Options
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``chord_tolerance`` (float):  [Read-Write] Maximum distance between any generated triangle and the original surface. Smaller values make more triangles.
    - ``max_edge_length`` (float):  [Read-Write] Maximum length of any edge in the generated triangles. Smaller values make more triangles.
    - ``normal_tolerance`` (float):  [Read-Write] Maximum angle between adjacent triangles. Smaller values make more triangles.
    - ``stitching_technique`` (DatasmithCADStitchingTechnique):  [Read-Write] Stitching technique applied on model before tessellation. Sewing could impact number of objects.
    """
    def __init__(self, chord_tolerance: float = 0.000000, max_edge_length: float = 0.000000, normal_tolerance: float = 0.000000, stitching_technique: DatasmithCADStitchingTechnique = DatasmithCADStitchingTechnique.STITCHING_NONE) -> None:
        ...
    @property
    def chord_tolerance(self) -> float:
        r"""
        (float):  [Read-Write] Maximum distance between any generated triangle and the original surface. Smaller values make more triangles.
        """
        ...
    @chord_tolerance.setter
    def chord_tolerance(self, value: float) -> None:
        ...
    @property
    def max_edge_length(self) -> float:
        r"""
        (float):  [Read-Write] Maximum length of any edge in the generated triangles. Smaller values make more triangles.
        """
        ...
    @max_edge_length.setter
    def max_edge_length(self, value: float) -> None:
        ...
    @property
    def normal_tolerance(self) -> float:
        r"""
        (float):  [Read-Write] Maximum angle between adjacent triangles. Smaller values make more triangles.
        """
        ...
    @normal_tolerance.setter
    def normal_tolerance(self, value: float) -> None:
        ...
    @property
    def stitching_technique(self) -> DatasmithCADStitchingTechnique:
        r"""
        (DatasmithCADStitchingTechnique):  [Read-Write] Stitching technique applied on model before tessellation. Sewing could impact number of objects.
        """
        ...
    @stitching_technique.setter
    def stitching_technique(self, value: DatasmithCADStitchingTechnique) -> None:
        ...

class DatasmithRetessellationOptions(DatasmithTessellationOptions):
    r"""
    Datasmith Retessellation Options
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``chord_tolerance`` (float):  [Read-Write] Maximum distance between any generated triangle and the original surface. Smaller values make more triangles.
    - ``max_edge_length`` (float):  [Read-Write] Maximum length of any edge in the generated triangles. Smaller values make more triangles.
    - ``normal_tolerance`` (float):  [Read-Write] Maximum angle between adjacent triangles. Smaller values make more triangles.
    - ``retessellation_rule`` (DatasmithCADRetessellationRule):  [Read-Write] Regenerate deleted surfaces during retesselate or ignore them
    - ``stitching_technique`` (DatasmithCADStitchingTechnique):  [Read-Write] Stitching technique applied on model before tessellation. Sewing could impact number of objects.
    """
    def __init__(self, chord_tolerance: float = 0.000000, max_edge_length: float = 0.000000, normal_tolerance: float = 0.000000, stitching_technique: DatasmithCADStitchingTechnique = DatasmithCADStitchingTechnique.STITCHING_NONE, retessellation_rule: DatasmithCADRetessellationRule = DatasmithCADRetessellationRule.ALL) -> None:
        ...
    @property
    def retessellation_rule(self) -> DatasmithCADRetessellationRule:
        r"""
        (DatasmithCADRetessellationRule):  [Read-Write] Regenerate deleted surfaces during retesselate or ignore them
        """
        ...
    @retessellation_rule.setter
    def retessellation_rule(self, value: DatasmithCADRetessellationRule) -> None:
        ...

class MRMeshConfiguration(StructBase):
    r"""
    MRMesh Configuration
    
    **C++ Source:**
    
    - **Module**: MRMesh
    - **File**: MeshReconstructorBase.h
    
    """
    def __init__(self) -> None:
        ...

class AssetThumbnailWidgetSettings(StructBase):
    r"""
    Copied mostly from FAssetThumbnailConfig
    
    **C++ Source:**
    
    - **Module**: UMGEditor
    - **File**: AssetThumbnailWidget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_asset_specific_thumbnail_overlay`` (bool):  [Read-Write]
    - ``allow_hint_text`` (bool):  [Read-Write]
    - ``allow_real_time_on_hovered`` (bool):  [Read-Write]
    - ``asset_type_color_override`` (LinearColor):  [Read-Write]
    - ``color_strip_orientation`` (ThumbnailColorStripOrientation_BlueprintType):  [Read-Write]
    - ``force_generic_thumbnail`` (bool):  [Read-Write]
    - ``generic_thumbnail_size`` (int32):  [Read-Write]
    - ``highlighted_text_delegate`` (GetHighlightTextDelegate):  [Read-Write]
    - ``hint_color_and_opacity`` (LinearColor):  [Read-Write]
    - ``override_asset_type_color`` (bool):  [Read-Write] Whether to override the asset type's colour
    - ``padding`` (Margin):  [Read-Write]
    - ``thumbnail_label`` (ThumbnailLabelType_BlueprintType):  [Read-Write]
    """
    def __init__(self, force_generic_thumbnail: bool = False, allow_hint_text: bool = False, allow_real_time_on_hovered: bool = False, allow_asset_specific_thumbnail_overlay: bool = False, thumbnail_label: ThumbnailLabelType_BlueprintType = ThumbnailLabelType_BlueprintType.CLASS_NAME, highlighted_text_delegate: GetHighlightTextDelegate = GetHighlightTextDelegate(), hint_color_and_opacity: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], override_asset_type_color: bool = False, asset_type_color_override: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], padding: Margin = [0.000000, 0.000000, 0.000000, 0.000000], generic_thumbnail_size: int = 0, color_strip_orientation: ThumbnailColorStripOrientation_BlueprintType = ThumbnailColorStripOrientation_BlueprintType.HORIZONTAL_BOTTOM_EDGE) -> None:
        ...
    @property
    def force_generic_thumbnail(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @force_generic_thumbnail.setter
    def force_generic_thumbnail(self, value: bool) -> None:
        ...
    @property
    def allow_hint_text(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_hint_text.setter
    def allow_hint_text(self, value: bool) -> None:
        ...
    @property
    def allow_real_time_on_hovered(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_real_time_on_hovered.setter
    def allow_real_time_on_hovered(self, value: bool) -> None:
        ...
    @property
    def allow_asset_specific_thumbnail_overlay(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_asset_specific_thumbnail_overlay.setter
    def allow_asset_specific_thumbnail_overlay(self, value: bool) -> None:
        ...
    @property
    def thumbnail_label(self) -> ThumbnailLabelType_BlueprintType:
        r"""
        (ThumbnailLabelType_BlueprintType):  [Read-Write]
        """
        ...
    @thumbnail_label.setter
    def thumbnail_label(self, value: ThumbnailLabelType_BlueprintType) -> None:
        ...
    @property
    def highlighted_text_delegate(self) -> GetHighlightTextDelegate:
        r"""
        (GetHighlightTextDelegate):  [Read-Write]
        """
        ...
    @highlighted_text_delegate.setter
    def highlighted_text_delegate(self, value: GetHighlightTextDelegate) -> None:
        ...
    @property
    def hint_color_and_opacity(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @hint_color_and_opacity.setter
    def hint_color_and_opacity(self, value: LinearColor) -> None:
        ...
    @property
    def override_asset_type_color(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to override the asset type's colour
        """
        ...
    @override_asset_type_color.setter
    def override_asset_type_color(self, value: bool) -> None:
        ...
    @property
    def asset_type_color_override(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @asset_type_color_override.setter
    def asset_type_color_override(self, value: LinearColor) -> None:
        ...
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def generic_thumbnail_size(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @generic_thumbnail_size.setter
    def generic_thumbnail_size(self, value: int) -> None:
        ...
    @property
    def color_strip_orientation(self) -> ThumbnailColorStripOrientation_BlueprintType:
        r"""
        (ThumbnailColorStripOrientation_BlueprintType):  [Read-Write]
        """
        ...
    @color_strip_orientation.setter
    def color_strip_orientation(self, value: ThumbnailColorStripOrientation_BlueprintType) -> None:
        ...

class ComparisonToleranceAmount(StructBase):
    r"""
    Comparison Tolerance Amount
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: AutomationScreenshotOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (uint8):  [Read-Write]
    - ``blue`` (uint8):  [Read-Write]
    - ``green`` (uint8):  [Read-Write]
    - ``max_brightness`` (uint8):  [Read-Write]
    - ``min_brightness`` (uint8):  [Read-Write]
    - ``red`` (uint8):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AutomationScreenshotOptions(StructBase):
    r"""
    Automation Screenshot Options
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: AutomationScreenshotOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delay`` (float):  [Read-Write] The delay before we take the screenshot (measured in seconds). Both this delay and the frame delay must be met before the screenshot is taken.
    - ``disable_noisy_rendering_features`` (bool):  [Read-Write] Disables Anti-Aliasing, Motion Blur, Screen Space Reflections, Eye Adaptation, Tonemapper and Contact
      Shadows, because those features contribute a lot to the noise in the final rendered image.  If you're
      explicitly looking for changes. Unchecking the option will make accessible the Disable Eye Adaptation
      checkbox.
    - ``disable_tonemapping`` (bool):  [Read-Write] Disables Eye Adaptation and sets Tonemapper to fixed gamma curve. Should generally be on unless
      testing tone mapping or other post-processing results.
    - ``frame_delay`` (int32):  [Read-Write] The delay before we take the screenshot (measured in number of frames). Both this frame delay and the time delay must be met before the screenshot is taken.
    - ``ignore_anti_aliasing`` (bool):  [Read-Write] If this is true, we search neighboring pixels looking for the expected pixel as what may have happened, is
      that the pixel shifted a little.
    - ``ignore_colors`` (bool):  [Read-Write] If this is true, all we compare is luminance of the scene.
    - ``maximum_global_error`` (float):  [Read-Write] After you've accounted for color tolerance changes, you now need to control for total acceptable error.
      Which depending on how pixels were colored on triangle edges may be a few percent of the image being
      outside the tolerance levels.
    - ``maximum_local_error`` (float):  [Read-Write] After you've accounted for color tolerance changes, you now need to control for local acceptable error.
      Which depending on how pixels were colored on triangle edges may be a few percent of the image being
      outside the tolerance levels.  Unlike the MaximumGlobalError, the MaximumLocalError works by focusing
      on a smaller subset of the image.  These chunks will have be compared to the local error, in an attempt
      to locate hot spots of change that are important, that would be ignored by the global error.
    - ``override_override_time_to`` (bool):  [Read-Write]
    - ``override_time_to`` (double):  [Read-Write] Overrides World Time, Real Time to the value provided.  Sets Delta Time to 0.  Only
      affects the time being sent to the render thread and materials.  The time accumulating
      on the game thread is unaffected.
    - ``resolution`` (Vector2D):  [Read-Write] The desired resolution of the screenshot, if none is provided, it will use the default for the
      platform setup in the automation settings.
    - ``tolerance`` (ComparisonTolerance):  [Read-Write] These are quick defaults for tolerance levels, we default to low, because generally there's some
      constant variability in every pixel's color introduced by TxAA.
    - ``tolerance_amount`` (ComparisonToleranceAmount):  [Read-Write] For each channel and brightness levels you can control a region where the colors are found to be
      essentially the same.  Generally this is necessary as modern rendering techniques tend to introduce
      noise constantly to hide aliasing.
    - ``view_settings`` (AutomationViewSettings):  [Read-Write] Assign custom view settings to control which rendering options we allow on while taking the
      screenshot.
    - ``visualize_buffer`` (Name):  [Read-Write] Allows you to screenshot a buffer other than the default final lit scene image.  Useful if you're
      trying to build a test for a specific GBuffer, that may be harder to tell if errors are introduced
      in it.
    """
    def __init__(self, resolution: Vector2D = [0.000000, 0.000000], delay: float = 0.000000, frame_delay: int = 0, override_override_time_to: bool = False, override_time_to: float = 0.000000, disable_noisy_rendering_features: bool = False, disable_tonemapping: bool = False, view_settings: AutomationViewSettings = None, visualize_buffer: Name = "None", tolerance: ComparisonTolerance = ComparisonTolerance.ZERO, tolerance_amount: ComparisonToleranceAmount = [], maximum_local_error: float = 0.000000, maximum_global_error: float = 0.000000, ignore_anti_aliasing: bool = False, ignore_colors: bool = False) -> None:
        ...
    @property
    def resolution(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The desired resolution of the screenshot, if none is provided, it will use the default for the
        platform setup in the automation settings.
        """
        ...
    @resolution.setter
    def resolution(self, value: Vector2D) -> None:
        ...
    @property
    def delay(self) -> float:
        r"""
        (float):  [Read-Write] The delay before we take the screenshot (measured in seconds). Both this delay and the frame delay must be met before the screenshot is taken.
        """
        ...
    @delay.setter
    def delay(self, value: float) -> None:
        ...
    @property
    def frame_delay(self) -> int:
        r"""
        (int32):  [Read-Write] The delay before we take the screenshot (measured in number of frames). Both this frame delay and the time delay must be met before the screenshot is taken.
        """
        ...
    @frame_delay.setter
    def frame_delay(self, value: int) -> None:
        ...
    @property
    def override_override_time_to(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_override_time_to.setter
    def override_override_time_to(self, value: bool) -> None:
        ...
    @property
    def override_time_to(self) -> float:
        r"""
        (double):  [Read-Write] Overrides World Time, Real Time to the value provided.  Sets Delta Time to 0.  Only
        affects the time being sent to the render thread and materials.  The time accumulating
        on the game thread is unaffected.
        """
        ...
    @override_time_to.setter
    def override_time_to(self, value: float) -> None:
        ...
    @property
    def disable_noisy_rendering_features(self) -> bool:
        r"""
        (bool):  [Read-Write] Disables Anti-Aliasing, Motion Blur, Screen Space Reflections, Eye Adaptation, Tonemapper and Contact
        Shadows, because those features contribute a lot to the noise in the final rendered image.  If you're
        explicitly looking for changes. Unchecking the option will make accessible the Disable Eye Adaptation
        checkbox.
        """
        ...
    @disable_noisy_rendering_features.setter
    def disable_noisy_rendering_features(self, value: bool) -> None:
        ...
    @property
    def disable_tonemapping(self) -> bool:
        r"""
        (bool):  [Read-Write] Disables Eye Adaptation and sets Tonemapper to fixed gamma curve. Should generally be on unless
        testing tone mapping or other post-processing results.
        """
        ...
    @disable_tonemapping.setter
    def disable_tonemapping(self, value: bool) -> None:
        ...
    @property
    def view_settings(self) -> AutomationViewSettings:
        r"""
        (AutomationViewSettings):  [Read-Write] Assign custom view settings to control which rendering options we allow on while taking the
        screenshot.
        """
        ...
    @view_settings.setter
    def view_settings(self, value: AutomationViewSettings) -> None:
        ...
    @property
    def visualize_buffer(self) -> Name:
        r"""
        (Name):  [Read-Write] Allows you to screenshot a buffer other than the default final lit scene image.  Useful if you're
        trying to build a test for a specific GBuffer, that may be harder to tell if errors are introduced
        in it.
        """
        ...
    @visualize_buffer.setter
    def visualize_buffer(self, value: Name) -> None:
        ...
    @property
    def tolerance(self) -> ComparisonTolerance:
        r"""
        (ComparisonTolerance):  [Read-Write] These are quick defaults for tolerance levels, we default to low, because generally there's some
        constant variability in every pixel's color introduced by TxAA.
        """
        ...
    @tolerance.setter
    def tolerance(self, value: ComparisonTolerance) -> None:
        ...
    @property
    def tolerance_amount(self) -> ComparisonToleranceAmount:
        r"""
        (ComparisonToleranceAmount):  [Read-Write] For each channel and brightness levels you can control a region where the colors are found to be
        essentially the same.  Generally this is necessary as modern rendering techniques tend to introduce
        noise constantly to hide aliasing.
        """
        ...
    @tolerance_amount.setter
    def tolerance_amount(self, value: ComparisonToleranceAmount) -> None:
        ...
    @property
    def maximum_local_error(self) -> float:
        r"""
        (float):  [Read-Write] After you've accounted for color tolerance changes, you now need to control for local acceptable error.
        Which depending on how pixels were colored on triangle edges may be a few percent of the image being
        outside the tolerance levels.  Unlike the MaximumGlobalError, the MaximumLocalError works by focusing
        on a smaller subset of the image.  These chunks will have be compared to the local error, in an attempt
        to locate hot spots of change that are important, that would be ignored by the global error.
        """
        ...
    @maximum_local_error.setter
    def maximum_local_error(self, value: float) -> None:
        ...
    @property
    def maximum_global_error(self) -> float:
        r"""
        (float):  [Read-Write] After you've accounted for color tolerance changes, you now need to control for total acceptable error.
        Which depending on how pixels were colored on triangle edges may be a few percent of the image being
        outside the tolerance levels.
        """
        ...
    @maximum_global_error.setter
    def maximum_global_error(self, value: float) -> None:
        ...
    @property
    def ignore_anti_aliasing(self) -> bool:
        r"""
        (bool):  [Read-Write] If this is true, we search neighboring pixels looking for the expected pixel as what may have happened, is
        that the pixel shifted a little.
        """
        ...
    @ignore_anti_aliasing.setter
    def ignore_anti_aliasing(self, value: bool) -> None:
        ...
    @property
    def ignore_colors(self) -> bool:
        r"""
        (bool):  [Read-Write] If this is true, all we compare is luminance of the scene.
        """
        ...
    @ignore_colors.setter
    def ignore_colors(self, value: bool) -> None:
        ...

class AutomationWaitForLoadingOptions(StructBase):
    r"""
    Automation Wait for Loading Options
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: AutomationBlueprintFunctionLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``wait_for_replication_to_settle`` (bool):  [Read-Write]
    """
    def __init__(self, wait_for_replication_to_settle: bool = False) -> None:
        ...
    @property
    def wait_for_replication_to_settle(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @wait_for_replication_to_settle.setter
    def wait_for_replication_to_settle(self, value: bool) -> None:
        ...

class AITestSpawnInfoBase(StructBase):
    r"""
    FAITestSpawnInfoBase
    
    Base struct defining where & when to spawn. Used within a FAITestSpawnSetBase class.
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalAITest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``number_to_spawn`` (int32):  [Read-Write]
    - ``pre_spawn_delay`` (float):  [Read-Write] delay before attempting first spawn
    - ``spawn_delay`` (float):  [Read-Write] delay between consecutive spawn attempts
    - ``spawn_location`` (Actor):  [Read-Write] Where should AI be spawned
    """
    def __init__(self, spawn_location: Actor = None, number_to_spawn: int = 0, spawn_delay: float = 0.000000, pre_spawn_delay: float = 0.000000) -> None:
        ...
    @property
    def spawn_location(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Where should AI be spawned
        """
        ...
    @spawn_location.setter
    def spawn_location(self, value: Actor) -> None:
        ...
    @property
    def number_to_spawn(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @number_to_spawn.setter
    def number_to_spawn(self, value: int) -> None:
        ...
    @property
    def spawn_delay(self) -> float:
        r"""
        (float):  [Read-Write] delay between consecutive spawn attempts
        """
        ...
    @spawn_delay.setter
    def spawn_delay(self, value: float) -> None:
        ...
    @property
    def pre_spawn_delay(self) -> float:
        r"""
        (float):  [Read-Write] delay before attempting first spawn
        """
        ...
    @pre_spawn_delay.setter
    def pre_spawn_delay(self, value: float) -> None:
        ...

class AITestSpawnInfo(AITestSpawnInfoBase):
    r"""
    FAITestSpawnInfo
    
    Generic AI Test Spawn Info used in FAITestSpawnSet within a generic AFunctionalAITest test.
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalAITest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``behavior_tree`` (BehaviorTree):  [Read-Write] if set will be applied to spawned AI
    - ``controller_class`` (type(Class)):  [Read-Write] class to override default pawn's controller class. If None the default will be used
    - ``number_to_spawn`` (int32):  [Read-Write]
    - ``pawn_class`` (type(Class)):  [Read-Write] Determines AI to be spawned
    - ``pre_spawn_delay`` (float):  [Read-Write] delay before attempting first spawn
    - ``spawn_delay`` (float):  [Read-Write] delay between consecutive spawn attempts
    - ``spawn_location`` (Actor):  [Read-Write] Where should AI be spawned
    - ``team_id`` (GenericTeamId):  [Read-Write]
    """
    def __init__(self, spawn_location: Actor = None, number_to_spawn: int = 0, spawn_delay: float = 0.000000, pre_spawn_delay: float = 0.000000, pawn_class: Class = None, controller_class: Class = None, team_id: GenericTeamId = [255], behavior_tree: BehaviorTree = None) -> None:
        ...
    @property
    def pawn_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Determines AI to be spawned
        """
        ...
    @pawn_class.setter
    def pawn_class(self, value: Class) -> None:
        ...
    @property
    def controller_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] class to override default pawn's controller class. If None the default will be used
        """
        ...
    @controller_class.setter
    def controller_class(self, value: Class) -> None:
        ...
    @property
    def team_id(self) -> GenericTeamId:
        r"""
        (GenericTeamId):  [Read-Write]
        """
        ...
    @team_id.setter
    def team_id(self, value: GenericTeamId) -> None:
        ...
    @property
    def behavior_tree(self) -> BehaviorTree:
        r"""
        (BehaviorTree):  [Read-Write] if set will be applied to spawned AI
        """
        ...
    @behavior_tree.setter
    def behavior_tree(self, value: BehaviorTree) -> None:
        ...

class PendingDelayedSpawn(StructBase):
    r"""
    FPendingDelayedSpawn
    
    Struct defining a pending spawn request within a AFunctionalAITestBase.
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalAITest.h
    
    """
    def __init__(self) -> None:
        ...

class AITestSpawnSetBase(StructBase):
    r"""
    FAITestSpawnSetBase
    
    Base struct defining an AI Test Spawn Set that are used in AFunctionalAITestBase tests.
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalAITest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``fallback_spawn_location`` (Actor):  [Read-Write] location used for spawning if spawn info doesn't define one
    - ``name`` (Name):  [Read-Write] give the set a name to help identify it if need be
    """
    def __init__(self, name: Name = "None", enabled: bool = False, fallback_spawn_location: Actor = None) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] give the set a name to help identify it if need be
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def fallback_spawn_location(self) -> Actor:
        r"""
        (Actor):  [Read-Write] location used for spawning if spawn info doesn't define one
        """
        ...
    @fallback_spawn_location.setter
    def fallback_spawn_location(self, value: Actor) -> None:
        ...

class AITestSpawnSet(AITestSpawnSetBase):
    r"""
    FAITestSpawnSet
    
    Generic AI Test Spawn Set that is used in regular AFunctionalAITest tests.
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalAITest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``fallback_spawn_location`` (Actor):  [Read-Write] location used for spawning if spawn info doesn't define one
    - ``name`` (Name):  [Read-Write] give the set a name to help identify it if need be
    - ``spawn_info_container`` (Array[AITestSpawnInfo]):  [Read-Write] what to spawn
    """
    def __init__(self, name: Name = "None", enabled: bool = False, fallback_spawn_location: Actor = None, spawn_info_container: Array[AITestSpawnInfo] = []) -> None:
        ...
    @property
    def spawn_info_container(self) -> Array[AITestSpawnInfo]:
        r"""
        (Array[AITestSpawnInfo]):  [Read-Write] what to spawn
        """
        ...
    @spawn_info_container.setter
    def spawn_info_container(self, value: Array[AITestSpawnInfo]) -> None:
        ...

class TraceChannelTestBatchOptions(StructBase):
    r"""
    Trace Channel Test Batch Options
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: TraceQueryTestResults.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``box_trace`` (bool):  [Read-Write] Whether to do box traces
    - ``capsule_trace`` (bool):  [Read-Write] Whether to do capsule traces
    - ``channel_trace`` (bool):  [Read-Write] Whether to do channel traces
    - ``line_trace`` (bool):  [Read-Write] Whether to do line traces
    - ``objects_trace`` (bool):  [Read-Write] Whether to do object traces
    - ``profile_trace`` (bool):  [Read-Write] Whether to do profile traces
    - ``sphere_trace`` (bool):  [Read-Write] Whether to do sphere traces
    """
    def __init__(self, line_trace: bool = False, sphere_trace: bool = False, capsule_trace: bool = False, box_trace: bool = False, channel_trace: bool = False, objects_trace: bool = False, profile_trace: bool = False) -> None:
        ...
    @property
    def line_trace(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to do line traces
        """
        ...
    @line_trace.setter
    def line_trace(self, value: bool) -> None:
        ...
    @property
    def sphere_trace(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to do sphere traces
        """
        ...
    @sphere_trace.setter
    def sphere_trace(self, value: bool) -> None:
        ...
    @property
    def capsule_trace(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to do capsule traces
        """
        ...
    @capsule_trace.setter
    def capsule_trace(self, value: bool) -> None:
        ...
    @property
    def box_trace(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to do box traces
        """
        ...
    @box_trace.setter
    def box_trace(self, value: bool) -> None:
        ...
    @property
    def channel_trace(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to do channel traces
        """
        ...
    @channel_trace.setter
    def channel_trace(self, value: bool) -> None:
        ...
    @property
    def objects_trace(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to do object traces
        """
        ...
    @objects_trace.setter
    def objects_trace(self, value: bool) -> None:
        ...
    @property
    def profile_trace(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to do profile traces
        """
        ...
    @profile_trace.setter
    def profile_trace(self, value: bool) -> None:
        ...

class TraceQueryTestNames(StructBase):
    r"""
    Trace Query Test Names
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: TraceQueryTestResults.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_name`` (Name):  [Read-Write]
    - ``component_name`` (Name):  [Read-Write]
    - ``physical_material_name`` (Name):  [Read-Write]
    """
    def __init__(self, component_name: Name = "None", physical_material_name: Name = "None", actor_name: Name = "None") -> None:
        ...
    @property
    def component_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @component_name.setter
    def component_name(self, value: Name) -> None:
        ...
    @property
    def physical_material_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @physical_material_name.setter
    def physical_material_name(self, value: Name) -> None:
        ...
    @property
    def actor_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @actor_name.setter
    def actor_name(self, value: Name) -> None:
        ...

class TraceQueryTestResultsInnerMost(StructBase):
    r"""
    Trace Query Test Results Inner Most
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: TraceQueryTestResults.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``multi_hits`` (Array[HitResult]):  [Read-Write] Result from doing a multi sweep
    - ``multi_names`` (Array[TraceQueryTestNames]):  [Read-Write] Names found from doing a multi sweep
    - ``multi_result`` (bool):  [Read-Write] The true/false value returned from the multi sweep
    - ``single_hit`` (HitResult):  [Read-Write] Result from doing a single sweep
    - ``single_names`` (TraceQueryTestNames):  [Read-Write] Names found from doing a single sweep
    - ``single_result`` (bool):  [Read-Write] The true/false value returned from the single sweep
    """
    def __init__(self, single_hit: HitResult = [False, False, 1.000000, 0.000000, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], None, None, None, "None", "None", 0, 0, 0, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], single_names: TraceQueryTestNames = ["None", "None", "None"], single_result: bool = False, multi_hits: Array[HitResult] = [], multi_names: Array[TraceQueryTestNames] = [], multi_result: bool = False) -> None:
        ...
    @property
    def single_hit(self) -> HitResult:
        r"""
        (HitResult):  [Read-Write] Result from doing a single sweep
        """
        ...
    @single_hit.setter
    def single_hit(self, value: HitResult) -> None:
        ...
    @property
    def single_names(self) -> TraceQueryTestNames:
        r"""
        (TraceQueryTestNames):  [Read-Write] Names found from doing a single sweep
        """
        ...
    @single_names.setter
    def single_names(self, value: TraceQueryTestNames) -> None:
        ...
    @property
    def single_result(self) -> bool:
        r"""
        (bool):  [Read-Write] The true/false value returned from the single sweep
        """
        ...
    @single_result.setter
    def single_result(self, value: bool) -> None:
        ...
    @property
    def multi_hits(self) -> Array[HitResult]:
        r"""
        (Array[HitResult]):  [Read-Write] Result from doing a multi sweep
        """
        ...
    @multi_hits.setter
    def multi_hits(self, value: Array[HitResult]) -> None:
        ...
    @property
    def multi_names(self) -> Array[TraceQueryTestNames]:
        r"""
        (Array[TraceQueryTestNames]):  [Read-Write] Names found from doing a multi sweep
        """
        ...
    @multi_names.setter
    def multi_names(self, value: Array[TraceQueryTestNames]) -> None:
        ...
    @property
    def multi_result(self) -> bool:
        r"""
        (bool):  [Read-Write] The true/false value returned from the multi sweep
        """
        ...
    @multi_result.setter
    def multi_result(self, value: bool) -> None:
        ...

class TraceQueryTestResultsInner(StructBase):
    r"""
    Trace Query Test Results Inner
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: TraceQueryTestResults.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``box_results`` (TraceQueryTestResultsInnerMost):  [Read-Write] The results associated with the box
    - ``capsule_results`` (TraceQueryTestResultsInnerMost):  [Read-Write] The results associated with the capsule
    - ``line_results`` (TraceQueryTestResultsInnerMost):  [Read-Write] The results associated with the line trace
    - ``sphere_results`` (TraceQueryTestResultsInnerMost):  [Read-Write] The results associated with the sphere
    """
    def __init__(self, line_results: TraceQueryTestResultsInnerMost = [[False, False, 1.000000, 0.000000, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], None, None, None, "None", "None", 0, 0, 0, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], ["None", "None", "None"], False, [], [], False], sphere_results: TraceQueryTestResultsInnerMost = [[False, False, 1.000000, 0.000000, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], None, None, None, "None", "None", 0, 0, 0, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], ["None", "None", "None"], False, [], [], False], capsule_results: TraceQueryTestResultsInnerMost = [[False, False, 1.000000, 0.000000, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], None, None, None, "None", "None", 0, 0, 0, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], ["None", "None", "None"], False, [], [], False], box_results: TraceQueryTestResultsInnerMost = [[False, False, 1.000000, 0.000000, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], None, None, None, "None", "None", 0, 0, 0, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], ["None", "None", "None"], False, [], [], False]) -> None:
        ...
    @property
    def line_results(self) -> TraceQueryTestResultsInnerMost:
        r"""
        (TraceQueryTestResultsInnerMost):  [Read-Write] The results associated with the line trace
        """
        ...
    @line_results.setter
    def line_results(self, value: TraceQueryTestResultsInnerMost) -> None:
        ...
    @property
    def sphere_results(self) -> TraceQueryTestResultsInnerMost:
        r"""
        (TraceQueryTestResultsInnerMost):  [Read-Write] The results associated with the sphere
        """
        ...
    @sphere_results.setter
    def sphere_results(self, value: TraceQueryTestResultsInnerMost) -> None:
        ...
    @property
    def capsule_results(self) -> TraceQueryTestResultsInnerMost:
        r"""
        (TraceQueryTestResultsInnerMost):  [Read-Write] The results associated with the capsule
        """
        ...
    @capsule_results.setter
    def capsule_results(self, value: TraceQueryTestResultsInnerMost) -> None:
        ...
    @property
    def box_results(self) -> TraceQueryTestResultsInnerMost:
        r"""
        (TraceQueryTestResultsInnerMost):  [Read-Write] The results associated with the box
        """
        ...
    @box_results.setter
    def box_results(self, value: TraceQueryTestResultsInnerMost) -> None:
        ...

class OverlayItem(StructBase):
    r"""
    Overlay Item
    
    **C++ Source:**
    
    - **Module**: Overlay
    - **File**: Overlays.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_time`` (Timespan):  [Read-Write] When the overlay should be cleared
    - ``position`` (Vector2D):  [Read-Write] The position of the text on screen (Between 0.0 and 1.0)
    - ``start_time`` (Timespan):  [Read-Write] When the overlay should be displayed
    - ``text`` (str):  [Read-Write] Text that appears onscreen when the overlay is shown
    """
    def __init__(self, start_time: Timespan = [0, 0, 0, 0, 0], end_time: Timespan = [0, 0, 0, 0, 0], text: str = "", position: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def start_time(self) -> Timespan:
        r"""
        (Timespan):  [Read-Write] When the overlay should be displayed
        """
        ...
    @start_time.setter
    def start_time(self, value: Timespan) -> None:
        ...
    @property
    def end_time(self) -> Timespan:
        r"""
        (Timespan):  [Read-Write] When the overlay should be cleared
        """
        ...
    @end_time.setter
    def end_time(self, value: Timespan) -> None:
        ...
    @property
    def text(self) -> str:
        r"""
        (str):  [Read-Write] Text that appears onscreen when the overlay is shown
        """
        ...
    @text.setter
    def text(self, value: str) -> None:
        ...
    @property
    def position(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The position of the text on screen (Between 0.0 and 1.0)
        """
        ...
    @position.setter
    def position(self, value: Vector2D) -> None:
        ...

class InputActionValue(StructBase):
    r"""
    Input Action Value
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputActionValue.h
    
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000, value_type: InputActionValueType = InputActionValueType.BOOLEAN) -> None:
        ...

class PlayerMappableKeyProfileCreationArgs(StructBase):
    r"""
    Arguments that can be used when creating a new mapping profile
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The display name of this profile
    - ``profile_identifier`` (GameplayTag):  [Read-Write] The uniqiue identifier that this profile should have
    - ``profile_type`` (type(Class)):  [Read-Write]
    - ``set_as_current_profile`` (bool):  [Read-Write]
    - ``user_id`` (PlatformUserId):  [Read-Write] The user ID of the ULocalPlayer that this profile is associated with
    """
    def __init__(self, profile_type: Class = None, profile_identifier: GameplayTag = ["None"], user_id: PlatformUserId = [], display_name: Text = "", set_as_current_profile: bool = False) -> None:
        ...
    @property
    def profile_type(self) -> Class:
        r"""
        (type(Class)):  [Read-Write]
        """
        ...
    @profile_type.setter
    def profile_type(self, value: Class) -> None:
        ...
    @property
    def profile_identifier(self) -> GameplayTag:
        r"""
        (GameplayTag):  [Read-Write] The uniqiue identifier that this profile should have
        """
        ...
    @profile_identifier.setter
    def profile_identifier(self, value: GameplayTag) -> None:
        ...
    @property
    def user_id(self) -> PlatformUserId:
        r"""
        (PlatformUserId):  [Read-Write] The user ID of the ULocalPlayer that this profile is associated with
        """
        ...
    @user_id.setter
    def user_id(self, value: PlatformUserId) -> None:
        ...
    @property
    def display_name(self) -> Text:
        r"""
        (Text):  [Read-Write] The display name of this profile
        """
        ...
    @display_name.setter
    def display_name(self, value: Text) -> None:
        ...
    @property
    def set_as_current_profile(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @set_as_current_profile.setter
    def set_as_current_profile(self, value: bool) -> None:
        ...

class PlayerKeyMapping(StructBase):
    r"""
    Represents a single key mapping that is set by the player
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``associated_input_action`` (InputAction):  [Read-Only] The input action associated with this player key mapping
    - ``current_key`` (Key):  [Read-Only] The key that the player has mapped to
    - ``default_key`` (Key):  [Read-Only] The default key that this mapping was set to in its input mapping context
    - ``display_category`` (Text):  [Read-Only] Localized display category of this mapping
    - ``display_name`` (Text):  [Read-Only] Localized display name of this mapping
    - ``hardware_device_id`` (HardwareDeviceIdentifier):  [Read-Only] An optional Hardware Device specifier for this mapping
    - ``is_dirty`` (bool):  [Read-Only] True if this key mapping is dirty (i.e. has been changed by the player)
    - ``mapping_name`` (Name):  [Read-Only] The name of the mapping for this key
    - ``slot`` (PlayerMappableKeySlot):  [Read-Only] What slot this key is mapped to
    """
    def __init__(self, mapping_name: Name = "None", display_name: Text = "", display_category: Text = "", slot: PlayerMappableKeySlot = PlayerMappableKeySlot.FIRST, is_dirty: bool = False, default_key: Key = [], current_key: Key = [], hardware_device_id: HardwareDeviceIdentifier = ["None", "None", HardwareDevicePrimaryType.UNSPECIFIED, 0], associated_input_action: InputAction = None) -> None:
        ...
    @property
    def mapping_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of the mapping for this key
        """
        ...
    @property
    def display_name(self) -> Text:
        r"""
        (Text):  [Read-Only] Localized display name of this mapping
        """
        ...
    @property
    def display_category(self) -> Text:
        r"""
        (Text):  [Read-Only] Localized display category of this mapping
        """
        ...
    @property
    def slot(self) -> PlayerMappableKeySlot:
        r"""
        (PlayerMappableKeySlot):  [Read-Only] What slot this key is mapped to
        """
        ...
    @property
    def is_dirty(self) -> bool:
        r"""
        (bool):  [Read-Only] True if this key mapping is dirty (i.e. has been changed by the player)
        """
        ...
    @property
    def default_key(self) -> Key:
        r"""
        (Key):  [Read-Only] The default key that this mapping was set to in its input mapping context
        """
        ...
    @property
    def current_key(self) -> Key:
        r"""
        (Key):  [Read-Only] The key that the player has mapped to
        """
        ...
    @property
    def hardware_device_id(self) -> HardwareDeviceIdentifier:
        r"""
        (HardwareDeviceIdentifier):  [Read-Only] An optional Hardware Device specifier for this mapping
        """
        ...
    @property
    def associated_input_action(self) -> InputAction:
        r"""
        (InputAction):  [Read-Only] The input action associated with this player key mapping
        """
        ...

class MapPlayerKeyArgs(StructBase):
    r"""
    Arguments that can be used when mapping a player key
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``create_matching_slot_if_needed`` (bool):  [Read-Write] If there is not a player mapping already with the same Slot and Hardware Device ID, then create a new mapping for this slot.
    - ``defer_on_settings_changed_broadcast`` (bool):  [Read-Write] Defers setting changed delegates until the next frame if set to true.
    - ``hardware_device_id`` (Name):  [Read-Write] An OPTIONAL specifier about what kind of hardware this mapping is for.
    - ``mapping_name`` (Name):  [Read-Write] The name of the mapping for this key. This is either the default mapping name from an Input Action asset, or one
      that is overridden in the Input Mapping Context.
    - ``new_key`` (Key):  [Read-Write] The new Key that this should be mapped to
    - ``profile_id`` (GameplayTag):  [Read-Write] The Key Mapping Profile identifier that this mapping should be set on. If this is empty, then the currently equipped profile will be used.
    - ``slot`` (PlayerMappableKeySlot):  [Read-Write] What slot this key mapping is for
    """
    def __init__(self, mapping_name: Name = "None", slot: PlayerMappableKeySlot = PlayerMappableKeySlot.FIRST, new_key: Key = [], hardware_device_id: Name = "None", profile_id: GameplayTag = ["None"], create_matching_slot_if_needed: bool = False, defer_on_settings_changed_broadcast: bool = False) -> None:
        ...
    @property
    def mapping_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the mapping for this key. This is either the default mapping name from an Input Action asset, or one
        that is overridden in the Input Mapping Context.
        """
        ...
    @mapping_name.setter
    def mapping_name(self, value: Name) -> None:
        ...
    @property
    def slot(self) -> PlayerMappableKeySlot:
        r"""
        (PlayerMappableKeySlot):  [Read-Write] What slot this key mapping is for
        """
        ...
    @slot.setter
    def slot(self, value: PlayerMappableKeySlot) -> None:
        ...
    @property
    def new_key(self) -> Key:
        r"""
        (Key):  [Read-Write] The new Key that this should be mapped to
        """
        ...
    @new_key.setter
    def new_key(self, value: Key) -> None:
        ...
    @property
    def hardware_device_id(self) -> Name:
        r"""
        (Name):  [Read-Write] An OPTIONAL specifier about what kind of hardware this mapping is for.
        """
        ...
    @hardware_device_id.setter
    def hardware_device_id(self, value: Name) -> None:
        ...
    @property
    def profile_id(self) -> GameplayTag:
        r"""
        (GameplayTag):  [Read-Write] The Key Mapping Profile identifier that this mapping should be set on. If this is empty, then the currently equipped profile will be used.
        """
        ...
    @profile_id.setter
    def profile_id(self, value: GameplayTag) -> None:
        ...
    @property
    def create_matching_slot_if_needed(self) -> bool:
        r"""
        (bool):  [Read-Write] If there is not a player mapping already with the same Slot and Hardware Device ID, then create a new mapping for this slot.
        """
        ...
    @create_matching_slot_if_needed.setter
    def create_matching_slot_if_needed(self, value: bool) -> None:
        ...
    @property
    def defer_on_settings_changed_broadcast(self) -> bool:
        r"""
        (bool):  [Read-Write] Defers setting changed delegates until the next frame if set to true.
        """
        ...
    @defer_on_settings_changed_broadcast.setter
    def defer_on_settings_changed_broadcast(self, value: bool) -> None:
        ...

class KeyMappingRow(StructBase):
    r"""
    Stores all mappings bound to a single mapping name.
    
    Since a single mapping can have multiple bindings to it and this system should be Blueprint friendly,
    this needs to be a struct (blueprint don't support nested containers).
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``mappings`` (Set[PlayerKeyMapping]):  [Read-Only]
    """
    def __init__(self, mappings: Set[PlayerKeyMapping] = []) -> None:
        ...
    @property
    def mappings(self) -> Set[PlayerKeyMapping]:
        r"""
        (Set[PlayerKeyMapping]):  [Read-Only]
        """
        ...

class PlayerMappableKeyQueryOptions(StructBase):
    r"""
    Options when querying what keys are mapped to a specific action on the player mappable
    key profile.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``key_to_match`` (Key):  [Read-Write] If specified, then this key will be used to match against when checking if the key types and axis are the same.
    - ``mapping_name`` (Name):  [Read-Write] The mapping name to search for
    - ``match_basic_key_types`` (bool):  [Read-Write] If true, then only keys that have the same value for IsGamepadKey, IsTouch, and IsGesture will be included in the results of this query
    - ``match_key_axis_type`` (bool):  [Read-Write] If true, then only keys that have the same value of IsAxis1D, IsAxis2D, and IsAxis3D will be included in the results of this query
    - ``required_device_flags`` (int32):  [Read-Write] If set, then only player mappings whose Hardware Device Identifier that has the same flags as this will be included in the results
    - ``required_device_type`` (HardwareDevicePrimaryType):  [Read-Write] If set, then only player mappings whose hardware device identifier that has the same primary input device type will be included in the results of this query
    - ``slot_to_match`` (PlayerMappableKeySlot):  [Read-Write] The key slot that will be required to match if set. By default this is EPlayerMappableKeySlot::Unspecified, which will not filter by the slot at all.
    """
    def __init__(self, mapping_name: Name = "None", key_to_match: Key = [], slot_to_match: PlayerMappableKeySlot = PlayerMappableKeySlot.FIRST, match_basic_key_types: bool = False, match_key_axis_type: bool = False, required_device_type: HardwareDevicePrimaryType = HardwareDevicePrimaryType.UNSPECIFIED, required_device_flags: int = 0) -> None:
        ...
    @property
    def mapping_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The mapping name to search for
        """
        ...
    @mapping_name.setter
    def mapping_name(self, value: Name) -> None:
        ...
    @property
    def key_to_match(self) -> Key:
        r"""
        (Key):  [Read-Write] If specified, then this key will be used to match against when checking if the key types and axis are the same.
        """
        ...
    @key_to_match.setter
    def key_to_match(self, value: Key) -> None:
        ...
    @property
    def slot_to_match(self) -> PlayerMappableKeySlot:
        r"""
        (PlayerMappableKeySlot):  [Read-Write] The key slot that will be required to match if set. By default this is EPlayerMappableKeySlot::Unspecified, which will not filter by the slot at all.
        """
        ...
    @slot_to_match.setter
    def slot_to_match(self, value: PlayerMappableKeySlot) -> None:
        ...
    @property
    def match_basic_key_types(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, then only keys that have the same value for IsGamepadKey, IsTouch, and IsGesture will be included in the results of this query
        """
        ...
    @match_basic_key_types.setter
    def match_basic_key_types(self, value: bool) -> None:
        ...
    @property
    def match_key_axis_type(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, then only keys that have the same value of IsAxis1D, IsAxis2D, and IsAxis3D will be included in the results of this query
        """
        ...
    @match_key_axis_type.setter
    def match_key_axis_type(self, value: bool) -> None:
        ...
    @property
    def required_device_type(self) -> HardwareDevicePrimaryType:
        r"""
        (HardwareDevicePrimaryType):  [Read-Write] If set, then only player mappings whose hardware device identifier that has the same primary input device type will be included in the results of this query
        """
        ...
    @required_device_type.setter
    def required_device_type(self, value: HardwareDevicePrimaryType) -> None:
        ...
    @property
    def required_device_flags(self) -> int:
        r"""
        (int32):  [Read-Write] If set, then only player mappings whose Hardware Device Identifier that has the same flags as this will be included in the results
        """
        ...
    @required_device_flags.setter
    def required_device_flags(self, value: int) -> None:
        ...

class MappingQueryIssue(StructBase):
    r"""
    Potential issue raised with a mapping request
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputMappingQuery.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blocking_action`` (InputAction):  [Read-Write] Action within the input context that caused the blockage
    - ``blocking_context`` (InputMappingContext):  [Read-Write] Input context that contains a blocking action bound to the queried key
    - ``issue`` (MappingQueryIssueFlag):  [Read-Write]
    """
    def __init__(self, issue: MappingQueryIssueFlag = MappingQueryIssueFlag.NO_ISSUE, blocking_context: InputMappingContext = None, blocking_action: InputAction = None) -> None:
        ...
    @property
    def issue(self) -> MappingQueryIssueFlag:
        r"""
        (MappingQueryIssueFlag):  [Read-Only]
        """
        ...
    @property
    def blocking_context(self) -> InputMappingContext:
        r"""
        (InputMappingContext):  [Read-Only] Input context that contains a blocking action bound to the queried key
        """
        ...
    @property
    def blocking_action(self) -> InputAction:
        r"""
        (InputAction):  [Read-Only] Action within the input context that caused the blockage
        """
        ...

class PlayerMappableKeySlotData(StructBase):
    r"""
    Player Mappable Key Slot
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: PlayerMappableKeySlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``slot_number`` (int32):  [Read-Write]
    """
    def __init__(self, slot_number: int = 0) -> None:
        ...
    @property
    def slot_number(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @slot_number.setter
    def slot_number(self, value: int) -> None:
        ...

class PlayerMappableKeyOptions(StructBase):
    r"""
    A struct that represents player facing mapping options for an action key mapping.
    Use this to set a unique FName for the mapping option to save it, as well as some FText options
    for use in UI.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedActionKeyMapping.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_category`` (Text):  [Read-Write] The category that this player mapping is in
    - ``display_name`` (Text):  [Read-Write] The localized display name of this key mapping. Use this when displaying the mappings to a user.
    - ``metadata`` (Object):  [Read-Write] Metadata that can used to store any other related items to this key mapping such as icons, ability assets, etc.
    - ``name`` (Name):  [Read-Write] A unique name for this player mapping to be saved with.
    """
    def __init__(self, metadata: Object = None, name: Name = "None", display_name: Text = "", display_category: Text = "") -> None:
        ...
    @property
    def metadata(self) -> Object:
        r"""
        (Object):  [Read-Write] Metadata that can used to store any other related items to this key mapping such as icons, ability assets, etc.
        """
        ...
    @metadata.setter
    def metadata(self, value: Object) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] A unique name for this player mapping to be saved with.
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def display_name(self) -> Text:
        r"""
        (Text):  [Read-Write] The localized display name of this key mapping. Use this when displaying the mappings to a user.
        """
        ...
    @display_name.setter
    def display_name(self, value: Text) -> None:
        ...
    @property
    def display_category(self) -> Text:
        r"""
        (Text):  [Read-Write] The category that this player mapping is in
        """
        ...
    @display_category.setter
    def display_category(self, value: Text) -> None:
        ...

class EnhancedActionKeyMapping(StructBase):
    r"""
    Defines a mapping between a key activation and the resulting enhanced action
    An key could be a button press, joystick axis movement, etc.
    An enhanced action could be MoveForward, Jump, Fire, etc.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedActionKeyMapping.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``action`` (InputAction):  [Read-Write] Action to be affected by the key
    - ``is_player_mappable`` (bool):  [Read-Write]
      deprecated: bIsPlayerMappable has been deprecated, please use the SettingBehavior instead
    - ``key`` (Key):  [Read-Write] Key that affect the action.
    - ``modifiers`` (Array[InputModifier]):  [Read-Write] Modifiers applied to the raw key value.
      These are applied sequentially in array order.
      
      Note: Modifiers defined in individual key mappings will be applied before those defined in the Input Action asset.
      Modifiers will not override any that are defined on the Input Action asset, they will be combined together during evaluation.
    - ``player_mappable_key_settings`` (PlayerMappableKeySettings):  [Read-Write] Used to expose this mapping or to opt-out of settings completely.
    - ``player_mappable_options`` (PlayerMappableKeyOptions):  [Read-Write]
      deprecated: PlayerMappableOptions has been deprecated, please use the PlayerMappableKeySettings instead
    - ``setting_behavior`` (PlayerMappableKeySettingBehaviors):  [Read-Write] Defines which Player Mappable Key Setting to use for a Action Key Mapping.
    - ``triggers`` (Array[InputTrigger]):  [Read-Write] Trigger qualifiers. If any trigger qualifiers exist the mapping will not trigger unless:
      If there are any Explicit triggers in this list at least one of them must be met.
      All Implicit triggers in this list must be met.
    """
    def __init__(self, triggers: Array[InputTrigger] = [], modifiers: Array[InputModifier] = [], action: InputAction = None, key: Key = []) -> None:
        ...
    @property
    def player_mappable_options(self) -> PlayerMappableKeyOptions:
        r"""
        (PlayerMappableKeyOptions):  [Read-Write]
        deprecated: PlayerMappableOptions has been deprecated, please use the PlayerMappableKeySettings instead
        """
        ...
    @player_mappable_options.setter
    def player_mappable_options(self, value: PlayerMappableKeyOptions) -> None:
        ...
    @property
    def triggers(self) -> Array[InputTrigger]:
        r"""
        (Array[InputTrigger]):  [Read-Write] Trigger qualifiers. If any trigger qualifiers exist the mapping will not trigger unless:
        If there are any Explicit triggers in this list at least one of them must be met.
        All Implicit triggers in this list must be met.
        """
        ...
    @triggers.setter
    def triggers(self, value: Array[InputTrigger]) -> None:
        ...
    @property
    def modifiers(self) -> Array[InputModifier]:
        r"""
        (Array[InputModifier]):  [Read-Write] Modifiers applied to the raw key value.
        These are applied sequentially in array order.
        
        Note: Modifiers defined in individual key mappings will be applied before those defined in the Input Action asset.
        Modifiers will not override any that are defined on the Input Action asset, they will be combined together during evaluation.
        """
        ...
    @modifiers.setter
    def modifiers(self, value: Array[InputModifier]) -> None:
        ...
    @property
    def action(self) -> InputAction:
        r"""
        (InputAction):  [Read-Write] Action to be affected by the key
        """
        ...
    @action.setter
    def action(self, value: InputAction) -> None:
        ...
    @property
    def key(self) -> Key:
        r"""
        (Key):  [Read-Write] Key that affect the action.
        """
        ...
    @key.setter
    def key(self, value: Key) -> None:
        ...
    @property
    def is_player_mappable(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: bIsPlayerMappable has been deprecated, please use the SettingBehavior instead
        """
        ...
    @is_player_mappable.setter
    def is_player_mappable(self, value: bool) -> None:
        ...

class ModifyContextOptions(StructBase):
    r"""
    Passed in as params for Adding/Remove input contexts
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputSubsystemInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``force_immediately`` (bool):  [Read-Write] The mapping changes will be applied synchronously, rather than at the end of the frame,
      making them available to the input system on the same frame.
      
      This is not recommended to be set to true if you are adding multiple mapping contexts
      as it will have poor performance.
      
      Default: False
    - ``ignore_all_pressed_keys_until_release`` (bool):  [Read-Write] If true, then any keys that are "down" or "pressed" during the rebuild of control mappings will
      not be processed by Enhanced Input until after they are "released".
      
      For example, if you are adding a mapping context with a key mapping to "X",
      and the player is holding down "X" while that IMC is added,
      there will not be a "Triggered" event until the player releases "X" and presses it again.
      
      If this is set to false for the above example, then the "Triggered" would fire immediately
      as soon as the IMC is finished being added.
      
      Default: True
      
      Note: This will only do something for keys bound to boolean Input Action types.
      Note: This includes all keys that the player has pressed, not just the keys that are previously mapped in Enhanced Input before
      the call to RebuildControlMappings.
    - ``notify_user_settings`` (bool):  [Read-Write] If true, then this Mapping Context will be registered or unregistered with the
      Enhanced Input User Settings on this subsystem, if they exist.
      
      Default: False
      
      Note: You need to enable and configure your UEnhancedInputUserSettings class in the project
      settings for this to do anything.
    """
    def __init__(self, ignore_all_pressed_keys_until_release: bool = False, force_immediately: bool = False, notify_user_settings: bool = False) -> None:
        ...
    @property
    def ignore_all_pressed_keys_until_release(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, then any keys that are "down" or "pressed" during the rebuild of control mappings will
        not be processed by Enhanced Input until after they are "released".
        
        For example, if you are adding a mapping context with a key mapping to "X",
        and the player is holding down "X" while that IMC is added,
        there will not be a "Triggered" event until the player releases "X" and presses it again.
        
        If this is set to false for the above example, then the "Triggered" would fire immediately
        as soon as the IMC is finished being added.
        
        Default: True
        
        Note: This will only do something for keys bound to boolean Input Action types.
        Note: This includes all keys that the player has pressed, not just the keys that are previously mapped in Enhanced Input before
        the call to RebuildControlMappings.
        """
        ...
    @ignore_all_pressed_keys_until_release.setter
    def ignore_all_pressed_keys_until_release(self, value: bool) -> None:
        ...
    @property
    def force_immediately(self) -> bool:
        r"""
        (bool):  [Read-Write] The mapping changes will be applied synchronously, rather than at the end of the frame,
        making them available to the input system on the same frame.
        
        This is not recommended to be set to true if you are adding multiple mapping contexts
        as it will have poor performance.
        
        Default: False
        """
        ...
    @force_immediately.setter
    def force_immediately(self, value: bool) -> None:
        ...
    @property
    def notify_user_settings(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, then this Mapping Context will be registered or unregistered with the
        Enhanced Input User Settings on this subsystem, if they exist.
        
        Default: False
        
        Note: You need to enable and configure your UEnhancedInputUserSettings class in the project
        settings for this to do anything.
        """
        ...
    @notify_user_settings.setter
    def notify_user_settings(self, value: bool) -> None:
        ...

class InputActionInstance(StructBase):
    r"""
    Run time queryable action instance
    Generated from UInputAction templates above
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputAction.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``elapsed_processed_time`` (float):  [Read-Write] Total trigger processing/evaluation time (How long this action has been in event Started, Ongoing, or Triggered
    - ``elapsed_triggered_time`` (float):  [Read-Write] Triggered time (How long this action has been in event Triggered only)
    - ``last_triggered_world_time`` (float):  [Read-Write] The last time that this evaluated to a Triggered State
    - ``modifiers`` (Array[InputModifier]):  [Read-Write]
    - ``source_action`` (InputAction):  [Read-Write] The source action that this instance is created from
    - ``trigger_event`` (TriggerEvent):  [Read-Write] Trigger state
    - ``triggers`` (Array[InputTrigger]):  [Read-Write]
    """
    def __init__(self, source_action: InputAction = None, trigger_event: TriggerEvent = 0, last_triggered_world_time: float = 0.000000, triggers: Array[InputTrigger] = [], modifiers: Array[InputModifier] = [], elapsed_processed_time: float = 0.000000, elapsed_triggered_time: float = 0.000000) -> None:
        ...
    @property
    def source_action(self) -> InputAction:
        r"""
        (InputAction):  [Read-Only] The source action that this instance is created from
        """
        ...
    @property
    def trigger_event(self) -> TriggerEvent:
        r"""
        (TriggerEvent):  [Read-Only] Trigger state
        """
        ...
    @property
    def last_triggered_world_time(self) -> float:
        r"""
        (float):  [Read-Only] The last time that this evaluated to a Triggered State
        """
        ...
    @property
    def triggers(self) -> Array[InputTrigger]:
        r"""
        (Array[InputTrigger]):  [Read-Only]
        """
        ...
    @property
    def modifiers(self) -> Array[InputModifier]:
        r"""
        (Array[InputModifier]):  [Read-Only]
        """
        ...
    @property
    def elapsed_processed_time(self) -> float:
        r"""
        (float):  [Read-Only] Total trigger processing/evaluation time (How long this action has been in event Started, Ongoing, or Triggered
        """
        ...
    @property
    def elapsed_triggered_time(self) -> float:
        r"""
        (float):  [Read-Only] Triggered time (How long this action has been in event Triggered only)
        """
        ...

class InputComboStepData(StructBase):
    r"""
    Input Combo Step Data
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``combo_step_action`` (InputAction):  [Read-Write] The action that must be completed (according to Combo Step Completion States) to progress the combo
    - ``combo_step_completion_states`` (uint8):  [Read-Write] Trigger events that will complete this step - what events from this action should progress the combo
    - ``time_to_press_key`` (float):  [Read-Write] Time to press the key before combo is cancelled - starts once the previous step in the combo is completed
      Note: This can be safely ignored for the first action in the combo
    """
    def __init__(self, combo_step_action: InputAction = None, combo_step_completion_states: int = 0, time_to_press_key: float = 0.000000) -> None:
        ...
    @property
    def combo_step_action(self) -> InputAction:
        r"""
        (InputAction):  [Read-Write] The action that must be completed (according to Combo Step Completion States) to progress the combo
        """
        ...
    @combo_step_action.setter
    def combo_step_action(self, value: InputAction) -> None:
        ...
    @property
    def combo_step_completion_states(self) -> int:
        r"""
        (uint8):  [Read-Write] Trigger events that will complete this step - what events from this action should progress the combo
        """
        ...
    @combo_step_completion_states.setter
    def combo_step_completion_states(self, value: int) -> None:
        ...
    @property
    def time_to_press_key(self) -> float:
        r"""
        (float):  [Read-Write] Time to press the key before combo is cancelled - starts once the previous step in the combo is completed
        Note: This can be safely ignored for the first action in the combo
        """
        ...
    @time_to_press_key.setter
    def time_to_press_key(self, value: float) -> None:
        ...

class InputCancelAction(StructBase):
    r"""
    Input Cancel Action
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cancel_action`` (InputAction):  [Read-Write] The action that must be completed (according to Cancellation States) to cancel the combo
    - ``cancellation_states`` (uint8):  [Read-Write] Trigger events for this action that will cancel the combo - what events from this action should cancel the combo
    """
    def __init__(self, cancel_action: InputAction = None, cancellation_states: int = 0) -> None:
        ...
    @property
    def cancel_action(self) -> InputAction:
        r"""
        (InputAction):  [Read-Write] The action that must be completed (according to Cancellation States) to cancel the combo
        """
        ...
    @cancel_action.setter
    def cancel_action(self, value: InputAction) -> None:
        ...
    @property
    def cancellation_states(self) -> int:
        r"""
        (uint8):  [Read-Write] Trigger events for this action that will cancel the combo - what events from this action should cancel the combo
        """
        ...
    @cancellation_states.setter
    def cancellation_states(self, value: int) -> None:
        ...

class ActorRecordedProperty(StructBase):
    r"""
    Actor Recorded Property
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakeRecorderSourceProperty.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``property_name`` (Name):  [Read-Write]
    - ``recorder_name`` (Text):  [Read-Only]
    """
    def __init__(self, property_name: Name = "None", enabled: bool = False) -> None:
        ...
    @property
    def property_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @property_name.setter
    def property_name(self, value: Name) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class AudioInputDeviceInfoProperty(StructBase):
    r"""
    Encapsulates audio device properties which are utilized by UI facing classes such as FAudioInputDeviceProperty.
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakeRecorderSourceProperty.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``device_id`` (str):  [Read-Only] The unique id used to identify the device
    - ``device_name`` (str):  [Read-Only] User friendly name of the audio device
    - ``input_channels`` (int32):  [Read-Only] The number input channels this device supports
    - ``is_default_device`` (bool):  [Read-Only] Boolean indicating if this device is the currently the system selected input device
    - ``preferred_sample_rate`` (int32):  [Read-Only] The preferred sample rate for this audio device
    """
    def __init__(self, device_name: str = "", device_id: str = "", input_channels: int = 0, preferred_sample_rate: int = 0, is_default_device: bool = False) -> None:
        ...
    @property
    def device_name(self) -> str:
        r"""
        (str):  [Read-Only] User friendly name of the audio device
        """
        ...
    @property
    def device_id(self) -> str:
        r"""
        (str):  [Read-Only] The unique id used to identify the device
        """
        ...
    @property
    def input_channels(self) -> int:
        r"""
        (int32):  [Read-Only] The number input channels this device supports
        """
        ...
    @property
    def preferred_sample_rate(self) -> int:
        r"""
        (int32):  [Read-Only] The preferred sample rate for this audio device
        """
        ...
    @property
    def is_default_device(self) -> bool:
        r"""
        (bool):  [Read-Only] Boolean indicating if this device is the currently the system selected input device
        """
        ...

class AudioInputDeviceProperty(StructBase):
    r"""
    Encapsulates the array of audio input devices which is populated by UTakeRecorderMicrophoneAudioManager and
    utilized by the audio input device list in FAudioInputDevicePropertyCustomization.
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakeRecorderSourceProperty.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio_input_buffer_size`` (int32):  [Read-Write] The desired buffer size used for audio callbacks during record
    - ``device_id`` (str):  [Read-Write] The unique id of the currently selected audio device
    - ``device_info_array`` (Array[AudioInputDeviceInfoProperty]):  [Read-Only] Holds device information for each of the audio devices available on this system.
    - ``use_system_default_audio_device`` (bool):  [Read-Write] Boolean indicating if the system selects audio device should be used or to use the selected device from the details panel
    """
    def __init__(self, use_system_default_audio_device: bool = False, device_info_array: Array[AudioInputDeviceInfoProperty] = [], device_id: str = "", audio_input_buffer_size: int = 0) -> None:
        ...
    @property
    def use_system_default_audio_device(self) -> bool:
        r"""
        (bool):  [Read-Write] Boolean indicating if the system selects audio device should be used or to use the selected device from the details panel
        """
        ...
    @use_system_default_audio_device.setter
    def use_system_default_audio_device(self, value: bool) -> None:
        ...
    @property
    def device_info_array(self) -> Array[AudioInputDeviceInfoProperty]:
        r"""
        (Array[AudioInputDeviceInfoProperty]):  [Read-Only] Holds device information for each of the audio devices available on this system.
        """
        ...
    @property
    def device_id(self) -> str:
        r"""
        (str):  [Read-Write] The unique id of the currently selected audio device
        """
        ...
    @device_id.setter
    def device_id(self, value: str) -> None:
        ...
    @property
    def audio_input_buffer_size(self) -> int:
        r"""
        (int32):  [Read-Write] The desired buffer size used for audio callbacks during record
        """
        ...
    @audio_input_buffer_size.setter
    def audio_input_buffer_size(self, value: int) -> None:
        ...

class AudioInputDeviceChannelProperty(StructBase):
    r"""
    This class is used by Microphone sources to track the currently selected channel. It aslo
    contains a local cache of the max channel count for the currently selected audio device.
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakeRecorderSourceProperty.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio_input_device_channel`` (int32):  [Read-Write] The currently selected channel from the details panel for this source
    """
    def __init__(self, audio_input_device_channel: int = 0) -> None:
        ...
    @property
    def audio_input_device_channel(self) -> int:
        r"""
        (int32):  [Read-Write] The currently selected channel from the details panel for this source
        """
        ...
    @audio_input_device_channel.setter
    def audio_input_device_channel(self, value: int) -> None:
        ...

class TakeRecorderUserParameters(StructBase):
    r"""
    Take Recorder User Parameters
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderParameters.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_lock`` (bool):  [Read-Write] Whether to lock the level sequence when done recording
    - ``auto_serialize`` (bool):  [Read-Write] Whether to incrementally serialize and store some data while recording
    - ``countdown_seconds`` (float):  [Read-Write] Delay that we will use before starting recording
    - ``engine_time_dilation`` (float):  [Read-Write] The engine time dilation to apply during the recording
    - ``maximize_viewport`` (bool):  [Read-Write] Whether to maximize the viewport (enter Immersive Mode) when recording
    - ``reduce_keys_tolerance`` (float):  [Read-Write] Tolerance to use when reducing keys
    - ``remove_redundant_tracks`` (bool):  [Read-Write] Recommended for use with recorded spawnables. Beware that changes to actor instances in the map after recording may alter the recording when played back
    - ``reset_playhead`` (bool):  [Read-Write] Reset playhead to beginning of the playback range when starting recording
    - ``save_recorded_assets`` (bool):  [Read-Write] Whether to save recorded level sequences and assets when done recording
    - ``stop_at_playback_end`` (bool):  [Read-Write] Automatically stop recording when reaching the end of the playback range
    """
    def __init__(self, maximize_viewport: bool = False, countdown_seconds: float = 0.000000, engine_time_dilation: float = 0.000000, reset_playhead: bool = False, stop_at_playback_end: bool = False, remove_redundant_tracks: bool = False, reduce_keys_tolerance: float = 0.000000, save_recorded_assets: bool = False, auto_lock: bool = False, auto_serialize: bool = False) -> None:
        ...
    @property
    def maximize_viewport(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to maximize the viewport (enter Immersive Mode) when recording
        """
        ...
    @maximize_viewport.setter
    def maximize_viewport(self, value: bool) -> None:
        ...
    @property
    def countdown_seconds(self) -> float:
        r"""
        (float):  [Read-Write] Delay that we will use before starting recording
        """
        ...
    @countdown_seconds.setter
    def countdown_seconds(self, value: float) -> None:
        ...
    @property
    def engine_time_dilation(self) -> float:
        r"""
        (float):  [Read-Write] The engine time dilation to apply during the recording
        """
        ...
    @engine_time_dilation.setter
    def engine_time_dilation(self, value: float) -> None:
        ...
    @property
    def reset_playhead(self) -> bool:
        r"""
        (bool):  [Read-Write] Reset playhead to beginning of the playback range when starting recording
        """
        ...
    @reset_playhead.setter
    def reset_playhead(self, value: bool) -> None:
        ...
    @property
    def stop_at_playback_end(self) -> bool:
        r"""
        (bool):  [Read-Write] Automatically stop recording when reaching the end of the playback range
        """
        ...
    @stop_at_playback_end.setter
    def stop_at_playback_end(self, value: bool) -> None:
        ...
    @property
    def remove_redundant_tracks(self) -> bool:
        r"""
        (bool):  [Read-Write] Recommended for use with recorded spawnables. Beware that changes to actor instances in the map after recording may alter the recording when played back
        """
        ...
    @remove_redundant_tracks.setter
    def remove_redundant_tracks(self, value: bool) -> None:
        ...
    @property
    def reduce_keys_tolerance(self) -> float:
        r"""
        (float):  [Read-Write] Tolerance to use when reducing keys
        """
        ...
    @reduce_keys_tolerance.setter
    def reduce_keys_tolerance(self, value: float) -> None:
        ...
    @property
    def save_recorded_assets(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to save recorded level sequences and assets when done recording
        """
        ...
    @save_recorded_assets.setter
    def save_recorded_assets(self, value: bool) -> None:
        ...
    @property
    def auto_lock(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to lock the level sequence when done recording
        """
        ...
    @auto_lock.setter
    def auto_lock(self, value: bool) -> None:
        ...
    @property
    def auto_serialize(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to incrementally serialize and store some data while recording
        """
        ...
    @auto_serialize.setter
    def auto_serialize(self, value: bool) -> None:
        ...

class TakeRecorderProjectParameters(StructBase):
    r"""
    Take Recorder Project Parameters
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderParameters.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_slate`` (str):  [Read-Write] The default name to use for the Slate information
    - ``default_tracks`` (Array[TakeRecorderTrackSettings]):  [Read-Write] List of property names for which movie scene tracks will always record.
    - ``record_sources_into_sub_sequences`` (bool):  [Read-Write] If enabled, each Source will be recorded into a separate Sequence and embedded in the Root Sequence will link to them via Subscenes track.
      If disabled, all Sources will be recorded into the Root Sequence, and you will not be able to swap between various takes of specific source
      using the Sequencer Take ui. This can still be done via copying and pasting between sequences if needed.
    - ``record_timecode`` (bool):  [Read-Write] If enabled, timecode will be recorded into each actor track
    - ``record_to_possessable`` (bool):  [Read-Write] * If enabled, all recorded actors will be recorded to possessable object bindings in Sequencer. If disabled, all recorded actors will be
      * recorded to spawnable object bindings in Sequencer. This can be overridden per actor source.
    - ``recording_clock_source`` (UpdateClockSource):  [Read-Write] The clock source to use when recording
    - ``root_take_save_dir`` (DirectoryPath):  [Read-Write] The root of the directory in which to save recorded takes.
    - ``show_notifications`` (bool):  [Read-Write] Whether to show notification windows or not when recording
    - ``start_at_current_timecode`` (bool):  [Read-Write] If enabled, track sections will start at the current timecode. Otherwise, 0.
    - ``take_save_dir`` (str):  [Read-Write] The name of the directory in which to save recorded takes. Supports any of the following format specifiers that will be substituted when a take is recorded:
      {day}       - The day of the timestamp for the start of the recording.
      {month}     - The month of the timestamp for the start of the recording.
      {year}      - The year of the timestamp for the start of the recording.
      {hour}      - The hour of the timestamp for the start of the recording.
      {minute}    - The minute of the timestamp for the start of the recording.
      {second}    - The second of the timestamp for the start of the recording.
      {take}      - The take number.
      {slate}     - The slate string.
    """
    def __init__(self, root_take_save_dir: DirectoryPath = [""], take_save_dir: str = "", default_slate: str = "", recording_clock_source: UpdateClockSource = UpdateClockSource.TICK, start_at_current_timecode: bool = False, record_timecode: bool = False, record_sources_into_sub_sequences: bool = False, record_to_possessable: bool = False, show_notifications: bool = False) -> None:
        ...
    @property
    def root_take_save_dir(self) -> DirectoryPath:
        r"""
        (DirectoryPath):  [Read-Write] The root of the directory in which to save recorded takes.
        """
        ...
    @root_take_save_dir.setter
    def root_take_save_dir(self, value: DirectoryPath) -> None:
        ...
    @property
    def take_save_dir(self) -> str:
        r"""
        (str):  [Read-Write] The name of the directory in which to save recorded takes. Supports any of the following format specifiers that will be substituted when a take is recorded:
        {day}       - The day of the timestamp for the start of the recording.
        {month}     - The month of the timestamp for the start of the recording.
        {year}      - The year of the timestamp for the start of the recording.
        {hour}      - The hour of the timestamp for the start of the recording.
        {minute}    - The minute of the timestamp for the start of the recording.
        {second}    - The second of the timestamp for the start of the recording.
        {take}      - The take number.
        {slate}     - The slate string.
        """
        ...
    @take_save_dir.setter
    def take_save_dir(self, value: str) -> None:
        ...
    @property
    def default_slate(self) -> str:
        r"""
        (str):  [Read-Write] The default name to use for the Slate information
        """
        ...
    @default_slate.setter
    def default_slate(self, value: str) -> None:
        ...
    @property
    def recording_clock_source(self) -> UpdateClockSource:
        r"""
        (UpdateClockSource):  [Read-Write] The clock source to use when recording
        """
        ...
    @recording_clock_source.setter
    def recording_clock_source(self, value: UpdateClockSource) -> None:
        ...
    @property
    def start_at_current_timecode(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, track sections will start at the current timecode. Otherwise, 0.
        """
        ...
    @start_at_current_timecode.setter
    def start_at_current_timecode(self, value: bool) -> None:
        ...
    @property
    def record_timecode(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, timecode will be recorded into each actor track
        """
        ...
    @record_timecode.setter
    def record_timecode(self, value: bool) -> None:
        ...
    @property
    def record_sources_into_sub_sequences(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, each Source will be recorded into a separate Sequence and embedded in the Root Sequence will link to them via Subscenes track.
        If disabled, all Sources will be recorded into the Root Sequence, and you will not be able to swap between various takes of specific source
        using the Sequencer Take ui. This can still be done via copying and pasting between sequences if needed.
        """
        ...
    @record_sources_into_sub_sequences.setter
    def record_sources_into_sub_sequences(self, value: bool) -> None:
        ...
    @property
    def record_to_possessable(self) -> bool:
        r"""
        (bool):  [Read-Write] * If enabled, all recorded actors will be recorded to possessable object bindings in Sequencer. If disabled, all recorded actors will be
        * recorded to spawnable object bindings in Sequencer. This can be overridden per actor source.
        """
        ...
    @record_to_possessable.setter
    def record_to_possessable(self, value: bool) -> None:
        ...
    @property
    def show_notifications(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to show notification windows or not when recording
        """
        ...
    @show_notifications.setter
    def show_notifications(self, value: bool) -> None:
        ...

class TakeRecorderParameters(StructBase):
    r"""
    Structure housing all configurable parameters for a take recorder instance
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderParameters.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``project`` (TakeRecorderProjectParameters):  [Read-Write]
    - ``start_frame`` (FrameNumber):  [Read-Write]
    - ``take_recorder_mode`` (TakeRecorderMode):  [Read-Write]
    - ``user`` (TakeRecorderUserParameters):  [Read-Write]
    """
    def __init__(self, user: TakeRecorderUserParameters = [False, 0.000000, 1.000000, True, False, True, 0.000100, False, True, False], project: TakeRecorderProjectParameters = [[""], "", "", UpdateClockSource.RELATIVE_TIMECODE, True, False, False, False, True], take_recorder_mode: TakeRecorderMode = TakeRecorderMode.RECORD_NEW_SEQUENCE, start_frame: FrameNumber = [0]) -> None:
        ...
    @property
    def user(self) -> TakeRecorderUserParameters:
        r"""
        (TakeRecorderUserParameters):  [Read-Write]
        """
        ...
    @user.setter
    def user(self, value: TakeRecorderUserParameters) -> None:
        ...
    @property
    def project(self) -> TakeRecorderProjectParameters:
        r"""
        (TakeRecorderProjectParameters):  [Read-Write]
        """
        ...
    @project.setter
    def project(self, value: TakeRecorderProjectParameters) -> None:
        ...
    @property
    def take_recorder_mode(self) -> TakeRecorderMode:
        r"""
        (TakeRecorderMode):  [Read-Write]
        """
        ...
    @take_recorder_mode.setter
    def take_recorder_mode(self, value: TakeRecorderMode) -> None:
        ...
    @property
    def start_frame(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write]
        """
        ...
    @start_frame.setter
    def start_frame(self, value: FrameNumber) -> None:
        ...

class RigVMUserWorkflow(StructBase):
    r"""
    Rig VMUser Workflow
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMUserWorkflow.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_perform_workflow`` (RigVMPeformUserWorkflowDynamicDelegate):  [Read-Write]
    - ``options_class`` (type(Class)):  [Read-Write]
    - ``title`` (str):  [Read-Write]
    - ``tooltip`` (str):  [Read-Write]
    - ``type`` (RigVMUserWorkflowType):  [Read-Write]
    """
    def __init__(self, title: str = "", tooltip: str = "", type: RigVMUserWorkflowType = 0, on_perform_workflow: RigVMPeformUserWorkflowDynamicDelegate = RigVMPeformUserWorkflowDynamicDelegate(), options_class: Class = None) -> None:
        ...
    @property
    def title(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @title.setter
    def title(self, value: str) -> None:
        ...
    @property
    def tooltip(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @tooltip.setter
    def tooltip(self, value: str) -> None:
        ...
    @property
    def type(self) -> RigVMUserWorkflowType:
        r"""
        (RigVMUserWorkflowType):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: RigVMUserWorkflowType) -> None:
        ...
    @property
    def on_perform_workflow(self) -> RigVMPeformUserWorkflowDynamicDelegate:
        r"""
        (RigVMPeformUserWorkflowDynamicDelegate):  [Read-Write]
        """
        ...
    @on_perform_workflow.setter
    def on_perform_workflow(self, value: RigVMPeformUserWorkflowDynamicDelegate) -> None:
        ...
    @property
    def options_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write]
        """
        ...
    @options_class.setter
    def options_class(self, value: Class) -> None:
        ...

class RigElementKey(StructBase):
    r"""
    Rig Element Key
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``type`` (RigElementType):  [Read-Write]
    """
    def __init__(self, type: RigElementType = RigElementType.NONE, name: Name = "None") -> None:
        ...
    @property
    def type(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: RigElementType) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...

class RigVMExtendedExecuteContext(StructBase):
    r"""
    The execute context is used for mutable nodes to
    indicate execution order.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMExecuteContext.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_memory_storage_object`` (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4
      deprecated: Please, use DebugMemoryStorage
    - ``work_memory_storage_object`` (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4
      deprecated: Please, use WorkMemoryStorage
    """
    def __init__(self) -> None:
        ...
    @property
    def work_memory_storage_object(self) -> RigVMMemoryStorage:
        r"""
        (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4
        deprecated: Please, use WorkMemoryStorage
        """
        ...
    @work_memory_storage_object.setter
    def work_memory_storage_object(self, value: RigVMMemoryStorage) -> None:
        ...
    @property
    def debug_memory_storage_object(self) -> RigVMMemoryStorage:
        r"""
        (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4
        deprecated: Please, use DebugMemoryStorage
        """
        ...
    @debug_memory_storage_object.setter
    def debug_memory_storage_object(self, value: RigVMMemoryStorage) -> None:
        ...

class RigBaseElement(StructBase):
    r"""
    Rig Base Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``selected`` (bool):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False) -> None:
        ...
    @property
    def key(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only]
        """
        ...
    @property
    def index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def sub_index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def created_at_instruction_index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def selected(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigTransformElement(RigBaseElement):
    r"""
    Rig Transform Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``pose`` (RigCurrentAndInitialTransform):  [Read-Write]
    - ``selected`` (bool):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False, pose: RigCurrentAndInitialTransform = [[[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]]) -> None:
        ...
    @property
    def pose(self) -> RigCurrentAndInitialTransform:
        r"""
        (RigCurrentAndInitialTransform):  [Read-Only]
        """
        ...

class RigCurrentAndInitialTransform(StructBase):
    r"""
    Rig Current and Initial Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``current`` (RigLocalAndGlobalTransform):  [Read-Write]
    - ``initial`` (RigLocalAndGlobalTransform):  [Read-Write]
    """
    def __init__(self, current: RigLocalAndGlobalTransform = [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], initial: RigLocalAndGlobalTransform = [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]) -> None:
        ...
    @property
    def current(self) -> RigLocalAndGlobalTransform:
        r"""
        (RigLocalAndGlobalTransform):  [Read-Only]
        """
        ...
    @property
    def initial(self) -> RigLocalAndGlobalTransform:
        r"""
        (RigLocalAndGlobalTransform):  [Read-Only]
        """
        ...

class RigLocalAndGlobalTransform(StructBase):
    r"""
    Rig Local and Global Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_`` (RigComputedTransform):  [Read-Write]
    - ``local`` (RigComputedTransform):  [Read-Write]
    """
    def __init__(self, local: RigComputedTransform = [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], global_: RigComputedTransform = [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def local(self) -> RigComputedTransform:
        r"""
        (RigComputedTransform):  [Read-Only]
        """
        ...
    @property
    def global_(self) -> RigComputedTransform:
        r"""
        (RigComputedTransform):  [Read-Only]
        """
        ...

class RigComputedTransform(StructBase):
    r"""
    Rig Computed Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``transform`` (Transform):  [Read-Write]
    """
    def __init__(self, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigMultiParentElement(RigTransformElement):
    r"""
    Rig Multi Parent Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``pose`` (RigCurrentAndInitialTransform):  [Read-Write]
    - ``selected`` (bool):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False, pose: RigCurrentAndInitialTransform = [[[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]]) -> None:
        ...

class RigControlElement(RigMultiParentElement):
    r"""
    Rig Control Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``offset`` (RigCurrentAndInitialTransform):  [Read-Write]
    - ``pose`` (RigCurrentAndInitialTransform):  [Read-Write]
    - ``preferred_euler_angles`` (RigPreferredEulerAngles):  [Read-Write]
    - ``selected`` (bool):  [Read-Write]
    - ``settings`` (RigControlSettings):  [Read-Write]
    - ``shape`` (RigCurrentAndInitialTransform):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False, pose: RigCurrentAndInitialTransform = [[[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]], settings: RigControlSettings = [RigControlAnimationType.ANIMATION_CONTROL, RigControlType.EULER_TRANSFORM, "None", RigControlAxis.X, [], True, [], [], True, RigControlVisibility.USER_DEFINED, "Default", [1.000000, 0.000000, 0.000000, 1.000000], False, None, [[], []], [], False, False, [], EulerRotationOrder.YZX, False], offset: RigCurrentAndInitialTransform = [[[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]], shape: RigCurrentAndInitialTransform = [[[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]], preferred_euler_angles: RigPreferredEulerAngles = [EulerRotationOrder.YZX, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]]) -> None:
        ...
    @property
    def settings(self) -> RigControlSettings:
        r"""
        (RigControlSettings):  [Read-Only]
        """
        ...
    @property
    def offset(self) -> RigCurrentAndInitialTransform:
        r"""
        (RigCurrentAndInitialTransform):  [Read-Only]
        """
        ...
    @property
    def shape(self) -> RigCurrentAndInitialTransform:
        r"""
        (RigCurrentAndInitialTransform):  [Read-Only]
        """
        ...
    @property
    def gizmo(self) -> RigCurrentAndInitialTransform:
        r"""
        deprecated: 'gizmo' was renamed to 'shape'.
        """
        ...
    @property
    def preferred_euler_angles(self) -> RigPreferredEulerAngles:
        r"""
        (RigPreferredEulerAngles):  [Read-Only]
        """
        ...

class RigPreferredEulerAngles(StructBase):
    r"""
    Rig Preferred Euler Angles
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``current`` (Vector):  [Read-Write]
    - ``initial`` (Vector):  [Read-Write]
    - ``rotation_order`` (EulerRotationOrder):  [Read-Write]
    """
    def __init__(self, rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ, current: Vector = [0.000000, 0.000000, 0.000000], initial: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def rotation_order(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Only]
        """
        ...
    @property
    def current(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def initial(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigControlSettings(StructBase):
    r"""
    Rig Control Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animatable`` (bool):  [Read-Write] Deprecated properties.
      deprecated: Use animation_type instead.
    - ``animation_type`` (RigControlAnimationType):  [Read-Write]
    - ``control_enum`` (Enum):  [Read-Write] If the control is integer it can use this enum to choose values
    - ``control_type`` (RigControlType):  [Read-Write]
    - ``customization`` (RigControlElementCustomization):  [Read-Write] The User interface customization used for a control
      This will be used as the default content for the space picker and other widgets
    - ``display_name`` (Name):  [Read-Write]
    - ``draw_limits`` (bool):  [Read-Write] True if the limits should be drawn in debug.
      For this to be enabled you need to have at least one min and max limit turned on.
    - ``driven_controls`` (Array[RigElementKey]):  [Read-Write] The list of driven controls for this proxy control.
    - ``filtered_channels`` (Array[RigControlTransformChannel]):  [Read-Write] Filtered Visible Transform channels. If this is empty everything is visible
    - ``group_with_parent_control`` (bool):  [Read-Write] If set to true the animation channel will be grouped with the parent control in sequencer
    - ``is_transient_control`` (bool):  [Read-Write] If the control is transient and only visible in the control rig editor
    - ``limit_enabled`` (Array[RigControlLimitEnabled]):  [Read-Write] True if the control has limits.
    - ``maximum_value`` (RigControlValue):  [Read-Write] The maximum limit of the control's value
    - ``minimum_value`` (RigControlValue):  [Read-Write] The minimum limit of the control's value
    - ``preferred_rotation_order`` (EulerRotationOrder):  [Read-Write] The euler rotation order this control prefers for animation, if we aren't using default UE rotator
    - ``primary_axis`` (RigControlAxis):  [Read-Write] the primary axis to use for float controls
    - ``restrict_space_switching`` (bool):  [Read-Write] Allow to space switch only to the available spaces
    - ``shape_color`` (LinearColor):  [Read-Write]
    - ``shape_enabled`` (bool):  [Read-Write]
      deprecated: Use animation_type or shape_visible instead.
    - ``shape_name`` (Name):  [Read-Write] This is optional UI setting - this doesn't mean this is always used, but it is optional for manipulation layer to use this
    - ``shape_visibility`` (RigControlVisibility):  [Read-Write] Defines how the shape visibility should be changed
    - ``shape_visible`` (bool):  [Read-Write] Set to true if the shape is currently visible in 3d
    - ``use_preferred_rotation_order`` (bool):  [Read-Write] Whether to use a specified rotation order or just use the default FRotator order and conversion functions
    """
    def __init__(self, animation_type: RigControlAnimationType = RigControlAnimationType.ANIMATION_CONTROL, control_type: RigControlType = RigControlType.BOOL, display_name: Name = "None", primary_axis: RigControlAxis = RigControlAxis.X, limit_enabled: Array[RigControlLimitEnabled] = [], draw_limits: bool = False, minimum_value: RigControlValue = [], maximum_value: RigControlValue = [], shape_visible: bool = False, shape_visibility: RigControlVisibility = RigControlVisibility.USER_DEFINED, shape_name: Name = "None", shape_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], is_transient_control: bool = False, control_enum: Enum = None, customization: RigControlElementCustomization = [[], []], driven_controls: Array[RigElementKey] = [], group_with_parent_control: bool = False, restrict_space_switching: bool = False, filtered_channels: Array[RigControlTransformChannel] = [], preferred_rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ, use_preferred_rotation_order: bool = False) -> None:
        ...
    @property
    def animation_type(self) -> RigControlAnimationType:
        r"""
        (RigControlAnimationType):  [Read-Write]
        """
        ...
    @animation_type.setter
    def animation_type(self, value: RigControlAnimationType) -> None:
        ...
    @property
    def control_type(self) -> RigControlType:
        r"""
        (RigControlType):  [Read-Write]
        """
        ...
    @control_type.setter
    def control_type(self, value: RigControlType) -> None:
        ...
    @property
    def display_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @display_name.setter
    def display_name(self, value: Name) -> None:
        ...
    @property
    def primary_axis(self) -> RigControlAxis:
        r"""
        (RigControlAxis):  [Read-Write] the primary axis to use for float controls
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: RigControlAxis) -> None:
        ...
    @property
    def limit_enabled(self) -> Array[RigControlLimitEnabled]:
        r"""
        (Array[RigControlLimitEnabled]):  [Read-Write] True if the control has limits.
        """
        ...
    @limit_enabled.setter
    def limit_enabled(self, value: Array[RigControlLimitEnabled]) -> None:
        ...
    @property
    def draw_limits(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the limits should be drawn in debug.
        For this to be enabled you need to have at least one min and max limit turned on.
        """
        ...
    @draw_limits.setter
    def draw_limits(self, value: bool) -> None:
        ...
    @property
    def minimum_value(self) -> RigControlValue:
        r"""
        (RigControlValue):  [Read-Write] The minimum limit of the control's value
        """
        ...
    @minimum_value.setter
    def minimum_value(self, value: RigControlValue) -> None:
        ...
    @property
    def maximum_value(self) -> RigControlValue:
        r"""
        (RigControlValue):  [Read-Write] The maximum limit of the control's value
        """
        ...
    @maximum_value.setter
    def maximum_value(self, value: RigControlValue) -> None:
        ...
    @property
    def shape_visible(self) -> bool:
        r"""
        (bool):  [Read-Write] Set to true if the shape is currently visible in 3d
        """
        ...
    @shape_visible.setter
    def shape_visible(self, value: bool) -> None:
        ...
    @property
    def b_gizmo_visible(self) -> bool:
        r"""
        deprecated: 'b_gizmo_visible' was renamed to 'shape_visible'.
        """
        ...
    @b_gizmo_visible.setter
    def b_gizmo_visible(self, value: bool) -> None:
        ...
    @property
    def shape_visibility(self) -> RigControlVisibility:
        r"""
        (RigControlVisibility):  [Read-Write] Defines how the shape visibility should be changed
        """
        ...
    @shape_visibility.setter
    def shape_visibility(self, value: RigControlVisibility) -> None:
        ...
    @property
    def shape_name(self) -> Name:
        r"""
        (Name):  [Read-Write] This is optional UI setting - this doesn't mean this is always used, but it is optional for manipulation layer to use this
        """
        ...
    @shape_name.setter
    def shape_name(self, value: Name) -> None:
        ...
    @property
    def gizmo_name(self) -> Name:
        r"""
        deprecated: 'gizmo_name' was renamed to 'shape_name'.
        """
        ...
    @gizmo_name.setter
    def gizmo_name(self, value: Name) -> None:
        ...
    @property
    def shape_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @shape_color.setter
    def shape_color(self, value: LinearColor) -> None:
        ...
    @property
    def gizmo_color(self) -> LinearColor:
        r"""
        deprecated: 'gizmo_color' was renamed to 'shape_color'.
        """
        ...
    @gizmo_color.setter
    def gizmo_color(self, value: LinearColor) -> None:
        ...
    @property
    def is_transient_control(self) -> bool:
        r"""
        (bool):  [Read-Write] If the control is transient and only visible in the control rig editor
        """
        ...
    @is_transient_control.setter
    def is_transient_control(self, value: bool) -> None:
        ...
    @property
    def control_enum(self) -> Enum:
        r"""
        (Enum):  [Read-Only] If the control is integer it can use this enum to choose values
        """
        ...
    @property
    def customization(self) -> RigControlElementCustomization:
        r"""
        (RigControlElementCustomization):  [Read-Only] The User interface customization used for a control
        This will be used as the default content for the space picker and other widgets
        """
        ...
    @property
    def driven_controls(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only] The list of driven controls for this proxy control.
        """
        ...
    @property
    def group_with_parent_control(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true the animation channel will be grouped with the parent control in sequencer
        """
        ...
    @property
    def restrict_space_switching(self) -> bool:
        r"""
        (bool):  [Read-Only] Allow to space switch only to the available spaces
        """
        ...
    @property
    def filtered_channels(self) -> Array[RigControlTransformChannel]:
        r"""
        (Array[RigControlTransformChannel]):  [Read-Only] Filtered Visible Transform channels. If this is empty everything is visible
        """
        ...
    @property
    def preferred_rotation_order(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Only] The euler rotation order this control prefers for animation, if we aren't using default UE rotator
        """
        ...
    @property
    def use_preferred_rotation_order(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to use a specified rotation order or just use the default FRotator order and conversion functions
        """
        ...
    @property
    def animatable(self) -> bool:
        r"""
        (bool):  [Read-Write] Deprecated properties.
        deprecated: Use animation_type instead.
        """
        ...
    @animatable.setter
    def animatable(self, value: bool) -> None:
        ...
    @property
    def shape_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: Use animation_type or shape_visible instead.
        """
        ...
    @shape_enabled.setter
    def shape_enabled(self, value: bool) -> None:
        ...
    @property
    def b_gizmo_enabled(self) -> bool:
        r"""
        deprecated: 'b_gizmo_enabled' was renamed to 'shape_enabled'.
        """
        ...
    @b_gizmo_enabled.setter
    def b_gizmo_enabled(self, value: bool) -> None:
        ...

class RigControlElementCustomization(StructBase):
    r"""
    Rig Control Element Customization
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``available_spaces`` (Array[RigElementKey]):  [Read-Write]
    - ``removed_spaces`` (Array[RigElementKey]):  [Read-Write]
    """
    def __init__(self, available_spaces: Array[RigElementKey] = [], removed_spaces: Array[RigElementKey] = []) -> None:
        ...
    @property
    def available_spaces(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...
    @property
    def removed_spaces(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigControlValue(StructBase):
    r"""
    Rig Control Value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """
    def __init__(self) -> None:
        ...

class RigControlValueStorage(StructBase):
    r"""
    Rig Control Value Storage
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """
    def __init__(self) -> None:
        ...

class RigControlLimitEnabled(StructBase):
    r"""
    Rig Control Limit Enabled
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``maximum`` (bool):  [Read-Write]
    - ``minimum`` (bool):  [Read-Write]
    """
    def __init__(self, minimum: bool = False, maximum: bool = False) -> None:
        ...
    @property
    def minimum(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @minimum.setter
    def minimum(self, value: bool) -> None:
        ...
    @property
    def maximum(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @maximum.setter
    def maximum(self, value: bool) -> None:
        ...

class RigModuleSettings(StructBase):
    r"""
    Rig Module Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigModuleDefines.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``category`` (str):  [Read-Write] The category of the module
    - ``description`` (str):  [Read-Write] The description of the module
    - ``exposed_connectors`` (Array[RigModuleConnector]):  [Read-Write]
    - ``icon`` (SoftObjectPath):  [Read-Write] The icon used for the module in the module library
    - ``identifier`` (RigModuleIdentifier):  [Read-Write] The identifier used to retrieve the module in the module library
    - ``keywords`` (str):  [Read-Write] The keywords of the module
    """
    def __init__(self, identifier: RigModuleIdentifier = ["", "Module"], icon: SoftObjectPath = [""], category: str = "", keywords: str = "", description: str = "", exposed_connectors: Array[RigModuleConnector] = []) -> None:
        ...
    @property
    def identifier(self) -> RigModuleIdentifier:
        r"""
        (RigModuleIdentifier):  [Read-Write] The identifier used to retrieve the module in the module library
        """
        ...
    @identifier.setter
    def identifier(self, value: RigModuleIdentifier) -> None:
        ...
    @property
    def icon(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Write] The icon used for the module in the module library
        """
        ...
    @icon.setter
    def icon(self, value: SoftObjectPath) -> None:
        ...
    @property
    def category(self) -> str:
        r"""
        (str):  [Read-Write] The category of the module
        """
        ...
    @category.setter
    def category(self, value: str) -> None:
        ...
    @property
    def keywords(self) -> str:
        r"""
        (str):  [Read-Write] The keywords of the module
        """
        ...
    @keywords.setter
    def keywords(self, value: str) -> None:
        ...
    @property
    def description(self) -> str:
        r"""
        (str):  [Read-Write] The description of the module
        """
        ...
    @description.setter
    def description(self, value: str) -> None:
        ...
    @property
    def exposed_connectors(self) -> Array[RigModuleConnector]:
        r"""
        (Array[RigModuleConnector]):  [Read-Only]
        """
        ...

class RigModuleConnector(StructBase):
    r"""
    Rig Module Connector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigModuleDefines.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (str):  [Read-Write]
    - ``settings`` (RigConnectorSettings):  [Read-Write]
    """
    def __init__(self, name: str = "", settings: RigConnectorSettings = ["", ConnectorType.PRIMARY, False, []]) -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: str) -> None:
        ...
    @property
    def settings(self) -> RigConnectorSettings:
        r"""
        (RigConnectorSettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: RigConnectorSettings) -> None:
        ...

class RigConnectorSettings(StructBase):
    r"""
    Rig Connector Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``description`` (str):  [Read-Write]
    - ``optional`` (bool):  [Read-Write]
    - ``rules`` (Array[RigConnectionRuleStash]):  [Read-Write]
    - ``type`` (ConnectorType):  [Read-Write]
    """
    def __init__(self, description: str = "", type: ConnectorType = ConnectorType.PRIMARY, optional: bool = False, rules: Array[RigConnectionRuleStash] = []) -> None:
        ...
    @property
    def description(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @description.setter
    def description(self, value: str) -> None:
        ...
    @property
    def type(self) -> ConnectorType:
        r"""
        (ConnectorType):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: ConnectorType) -> None:
        ...
    @property
    def optional(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @optional.setter
    def optional(self, value: bool) -> None:
        ...
    @property
    def rules(self) -> Array[RigConnectionRuleStash]:
        r"""
        (Array[RigConnectionRuleStash]):  [Read-Write]
        """
        ...
    @rules.setter
    def rules(self, value: Array[RigConnectionRuleStash]) -> None:
        ...

class RigConnectionRuleStash(StructBase):
    r"""
    Rig Connection Rule Stash
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigConnectionRules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``exported_text`` (str):  [Read-Write]
    - ``script_struct_path`` (str):  [Read-Write]
    """
    def __init__(self, script_struct_path: str = "", exported_text: str = "") -> None:
        ...
    @property
    def script_struct_path(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @script_struct_path.setter
    def script_struct_path(self, value: str) -> None:
        ...
    @property
    def exported_text(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @exported_text.setter
    def exported_text(self, value: str) -> None:
        ...

class RigModuleIdentifier(StructBase):
    r"""
    Rig Module Identifier
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigModuleDefines.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (str):  [Read-Write] The name of the module used to find it in the module library
    - ``type`` (str):  [Read-Write] The kind of module this is (for example "Arm")
    """
    def __init__(self, name: str = "", type: str = "") -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Write] The name of the module used to find it in the module library
        """
        ...
    @name.setter
    def name(self, value: str) -> None:
        ...
    @property
    def type(self) -> str:
        r"""
        (str):  [Read-Write] The kind of module this is (for example "Arm")
        """
        ...
    @type.setter
    def type(self, value: str) -> None:
        ...

class RigInfluenceMapPerEvent(StructBase):
    r"""
    Rig Influence Map Per Event
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigInfluenceMap.h
    
    """
    def __init__(self) -> None:
        ...

class RigInfluenceMap(StructBase):
    r"""
    Rig Influence Map
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigInfluenceMap.h
    
    """
    def __init__(self) -> None:
        ...

class RigInfluenceEntry(StructBase):
    r"""
    Rig Influence Entry
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigInfluenceMap.h
    
    """
    def __init__(self) -> None:
        ...

class InstancedStruct(StructBase):
    r"""
    FInstancedStruct works similarly as instanced UObject* property but is USTRUCTs.
    
    Example:
    
        UPROPERTY(EditAnywhere, Category = Foo, meta = (BaseStruct = "/Script/ModuleName.TestStructBase"))
        FInstancedStruct Test;
    
        UPROPERTY(EditAnywhere, Category = Foo, meta = (BaseStruct = "/Script/ModuleName.TestStructBase"))
        TArray<FInstancedStruct> TestArray;
    
    **C++ Source:**
    
    - **Plugin**: StructUtils
    - **Module**: StructUtils
    - **File**: InstancedStruct.h
    
    """
    def __init__(self, value: int = 0) -> None:
        ...

class UniqueScriptStructPtr(InstancedStruct):
    r"""
    deprecated: 'UniqueScriptStructPtr' was renamed to 'InstancedStruct'.
    """
    def __init__(self, value: int = 0) -> None:
        ...

class RigVMExternalVariableDef(StructBase):
    r"""
    The external variable can be used to map external / unowned
    memory into the VM and back out
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMExternalVariable.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMExternalVariable(RigVMExternalVariableDef):
    r"""
    Rig VMExternal Variable
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMExternalVariable.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMStruct(StructBase):
    r"""
    The base class for all RigVM enabled structs.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMStruct.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMStructMutable(RigVMStruct):
    r"""
    The base mutable class for all RigVM enabled structs.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMStruct.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    """
    def __init__(self, execute_context: RigVMExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> RigVMExecuteContext:
        r"""
        (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
        """
        ...
    @execute_context.setter
    def execute_context(self, value: RigVMExecuteContext) -> None:
        ...

class RigVMExecuteContext(StructBase):
    r"""
    The execute context is used for mutable nodes to
    indicate execution order.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMExecuteContext.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_DebugBaseMutable(RigVMStructMutable):
    r"""
    Rig VMFunction Debug Base Mutable
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    """
    def __init__(self, execute_context: RigVMExecuteContext = []) -> None:
        ...

class RigVMFunction_MathMutableBase(RigVMStructMutable):
    r"""
    Rig VMFunction Math Mutable Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    """
    def __init__(self, execute_context: RigVMExecuteContext = []) -> None:
        ...

class RigUnit_MathMutableBase(RigVMFunction_MathMutableBase):
    r"""
    deprecated: 'RigUnit_MathMutableBase' was renamed to 'RigVMFunction_MathMutableBase'.
    """
    def __init__(self, execute_context: RigVMExecuteContext = []) -> None:
        ...

class RigVMFunction_Sequence(RigVMStruct):
    r"""
    Allows for a single execution pulse to trigger a series of events in order.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Sequence.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (RigVMExecuteContext):  [Read-Write] The execution result A
    - ``b`` (RigVMExecuteContext):  [Read-Write] The execution result B
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] The execution input
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], a: RigVMExecuteContext = [], b: RigVMExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> RigVMExecuteContext:
        r"""
        (RigVMExecuteContext):  [Read-Write] The execution input
        """
        ...
    @execute_context.setter
    def execute_context(self, value: RigVMExecuteContext) -> None:
        ...
    @property
    def a(self) -> RigVMExecuteContext:
        r"""
        (RigVMExecuteContext):  [Read-Only] The execution result A
        """
        ...
    @property
    def b(self) -> RigVMExecuteContext:
        r"""
        (RigVMExecuteContext):  [Read-Only] The execution result B
        """
        ...

class RigUnit_SequenceAggregate(RigVMFunction_Sequence):
    r"""
    deprecated: 'RigUnit_SequenceAggregate' was renamed to 'RigVMFunction_Sequence'.
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], a: RigVMExecuteContext = [], b: RigVMExecuteContext = []) -> None:
        ...

class RigVMFunction_SimBaseMutable(RigVMStructMutable):
    r"""
    Rig VMFunction Sim Base Mutable
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_SimBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    """
    def __init__(self, execute_context: RigVMExecuteContext = []) -> None:
        ...

class RigUnit_SimBaseMutable(RigVMFunction_SimBaseMutable):
    r"""
    deprecated: 'RigUnit_SimBaseMutable' was renamed to 'RigVMFunction_SimBaseMutable'.
    """
    def __init__(self, execute_context: RigVMExecuteContext = []) -> None:
        ...

class RigVMGraphFunctionData(StructBase):
    r"""
    Rig VMGraph Function Data
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMGraphFunctionDefinition.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMFunctionCompilationData(StructBase):
    r"""
    Rig VMFunction Compilation Data
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMGraphFunctionDefinition.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMGraphFunctionHeader(StructBase):
    r"""
    Rig VMGraph Function Header
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMGraphFunctionDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``arguments`` (Array[RigVMGraphFunctionArgument]):  [Read-Only]
    - ``category`` (str):  [Read-Only]
    - ``description`` (str):  [Read-Only]
    - ``keywords`` (str):  [Read-Only]
    - ``library_pointer`` (RigVMGraphFunctionIdentifier):  [Read-Only]
    - ``name`` (Name):  [Read-Only]
    - ``node_color`` (LinearColor):  [Read-Only]
    - ``node_title`` (str):  [Read-Only]
    - ``tooltip`` (Text):  [Read-Write]
      deprecated: Property 'Tooltip' is deprecated.
    """
    def __init__(self, library_pointer: RigVMGraphFunctionIdentifier = [[""], [""]], name: Name = "None", node_title: str = "", node_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], description: str = "", category: str = "", keywords: str = "", arguments: Array[RigVMGraphFunctionArgument] = []) -> None:
        ...
    @property
    def library_pointer(self) -> RigVMGraphFunctionIdentifier:
        r"""
        (RigVMGraphFunctionIdentifier):  [Read-Only]
        """
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def node_title(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def node_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...
    @property
    def tooltip(self) -> Text:
        r"""
        (Text):  [Read-Write]
        deprecated: Property 'Tooltip' is deprecated.
        """
        ...
    @tooltip.setter
    def tooltip(self, value: Text) -> None:
        ...
    @property
    def description(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def category(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def keywords(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def arguments(self) -> Array[RigVMGraphFunctionArgument]:
        r"""
        (Array[RigVMGraphFunctionArgument]):  [Read-Only]
        """
        ...

class RigVMGraphFunctionIdentifier(StructBase):
    r"""
    Rig VMGraph Function Identifier
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMGraphFunctionDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``host_object`` (SoftObjectPath):  [Read-Only] A path to the IRigVMGraphFunctionHost that stores the function information, and compilation data (e.g. RigVMBlueprintGeneratedClass)
    - ``library_node`` (SoftObjectPath):  [Read-Only]
    """
    def __init__(self, library_node: SoftObjectPath = [""], host_object: SoftObjectPath = [""]) -> None:
        ...
    @property
    def library_node(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Only]
        """
        ...
    @property
    def host_object(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Only] A path to the IRigVMGraphFunctionHost that stores the function information, and compilation data (e.g. RigVMBlueprintGeneratedClass)
        """
        ...

class RigVMGraphFunctionArgument(StructBase):
    r"""
    Rig VMGraph Function Argument
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMGraphFunctionDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cpp_type`` (Name):  [Read-Only]
    - ``cpp_type_object`` (Object):  [Read-Only]
    - ``default_value`` (str):  [Read-Only]
    - ``direction`` (RigVMPinDirection):  [Read-Only]
    - ``display_name`` (Name):  [Read-Only]
    - ``is_array`` (bool):  [Read-Only]
    - ``is_const`` (bool):  [Read-Only]
    - ``name`` (Name):  [Read-Only]
    """
    def __init__(self, name: Name = "None", display_name: Name = "None", cpp_type: Name = "None", cpp_type_object: Object = None, is_array: bool = False, direction: RigVMPinDirection = RigVMPinDirection.INPUT, default_value: str = "", is_const: bool = False) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def display_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def cpp_type(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def cpp_type_object(self) -> Object:
        r"""
        (Object):  [Read-Only]
        """
        ...
    @property
    def is_array(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def direction(self) -> RigVMPinDirection:
        r"""
        (RigVMPinDirection):  [Read-Only]
        """
        ...
    @property
    def default_value(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def is_const(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigVMMemoryStatistics(StructBase):
    r"""
    Rig VMMemory Statistics
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMStatistics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_bytes`` (int32):  [Read-Only]
    - ``register_count`` (int32):  [Read-Only]
    - ``total_bytes`` (int32):  [Read-Only]
    """
    def __init__(self, register_count: int = 0, data_bytes: int = 0, total_bytes: int = 0) -> None:
        ...
    @property
    def register_count(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def data_bytes(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def total_bytes(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigVMByteCodeStatistics(StructBase):
    r"""
    Rig VMByte Code Statistics
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMStatistics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_bytes`` (int32):  [Read-Only]
    - ``instruction_count`` (int32):  [Read-Only]
    """
    def __init__(self, instruction_count: int = 0, data_bytes: int = 0) -> None:
        ...
    @property
    def instruction_count(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def data_bytes(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigVMStatistics(StructBase):
    r"""
    Rig VMStatistics
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMStatistics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``byte_code`` (RigVMByteCodeStatistics):  [Read-Only]
    - ``bytes_for_caching`` (int32):  [Read-Only]
    - ``bytes_for_cdo`` (int32):  [Read-Only]
    - ``bytes_per_instance`` (int32):  [Read-Only]
    - ``debug_memory`` (RigVMMemoryStatistics):  [Read-Only]
    - ``literal_memory`` (RigVMMemoryStatistics):  [Read-Only]
    - ``work_memory`` (RigVMMemoryStatistics):  [Read-Only]
    """
    def __init__(self, bytes_for_cdo: int = 0, bytes_per_instance: int = 0, literal_memory: RigVMMemoryStatistics = [0, 0, 0], work_memory: RigVMMemoryStatistics = [0, 0, 0], debug_memory: RigVMMemoryStatistics = [0, 0, 0], bytes_for_caching: int = 0, byte_code: RigVMByteCodeStatistics = [0, 0]) -> None:
        ...
    @property
    def bytes_for_cdo(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def bytes_per_instance(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def literal_memory(self) -> RigVMMemoryStatistics:
        r"""
        (RigVMMemoryStatistics):  [Read-Only]
        """
        ...
    @property
    def work_memory(self) -> RigVMMemoryStatistics:
        r"""
        (RigVMMemoryStatistics):  [Read-Only]
        """
        ...
    @property
    def debug_memory(self) -> RigVMMemoryStatistics:
        r"""
        (RigVMMemoryStatistics):  [Read-Only]
        """
        ...
    @property
    def bytes_for_caching(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def byte_code(self) -> RigVMByteCodeStatistics:
        r"""
        (RigVMByteCodeStatistics):  [Read-Only]
        """
        ...

class RigVMParameter(StructBase):
    r"""
    The RigVMParameter define an input or output of the RigVM.
    Parameters are mapped to work state memory registers and can be
    used to set input parameters as well as retrieve output parameters.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVM.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMInstructionSetExecuteState(StructBase):
    r"""
    A runtime cache for determining if a set of instruction has to
    run for this execution of the VM
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMMemoryCommon.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_AnimBase(RigVMStruct):
    r"""
    Rig VMFunction Anim Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_AnimBase.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_AnimBase(RigVMFunction_AnimBase):
    r"""
    deprecated: 'RigUnit_AnimBase' was renamed to 'RigVMFunction_AnimBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_AnimEasingType(RigVMFunction_AnimBase):
    r"""
    A constant value of an easing type
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_AnimEasing.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``type`` (RigVMAnimEasingType):  [Read-Write]
    """
    def __init__(self, type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR) -> None:
        ...
    @property
    def type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: RigVMAnimEasingType) -> None:
        ...

class RigUnit_AnimEasingType(RigVMFunction_AnimEasingType):
    r"""
    deprecated: 'RigUnit_AnimEasingType' was renamed to 'RigVMFunction_AnimEasingType'.
    """
    def __init__(self, type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR) -> None:
        ...

class RigVMFunction_AnimEasing(RigVMFunction_AnimBase):
    r"""
    Returns the eased version of the input value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_AnimEasing.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``source_maximum`` (float):  [Read-Write]
    - ``source_minimum`` (float):  [Read-Write]
    - ``target_maximum`` (float):  [Read-Write]
    - ``target_minimum`` (float):  [Read-Write]
    - ``type`` (RigVMAnimEasingType):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, source_minimum: float = 0.000000, source_maximum: float = 0.000000, target_minimum: float = 0.000000, target_maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: RigVMAnimEasingType) -> None:
        ...
    @property
    def source_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @source_minimum.setter
    def source_minimum(self, value: float) -> None:
        ...
    @property
    def source_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @source_maximum.setter
    def source_maximum(self, value: float) -> None:
        ...
    @property
    def target_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @target_minimum.setter
    def target_minimum(self, value: float) -> None:
        ...
    @property
    def target_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @target_maximum.setter
    def target_maximum(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_AnimEasing(RigVMFunction_AnimEasing):
    r"""
    deprecated: 'RigUnit_AnimEasing' was renamed to 'RigVMFunction_AnimEasing'.
    """
    def __init__(self, value: float = 0.000000, type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, source_minimum: float = 0.000000, source_maximum: float = 0.000000, target_minimum: float = 0.000000, target_maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_AnimEvalRichCurve(RigVMFunction_AnimBase):
    r"""
    Evaluates the provided curve. Values are normalized between 0 and 1
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_AnimEvalRichCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve`` (RuntimeFloatCurve):  [Read-Only]
    - ``result`` (float):  [Read-Write]
    - ``source_maximum`` (float):  [Read-Write]
    - ``source_minimum`` (float):  [Read-Write]
    - ``target_maximum`` (float):  [Read-Write]
    - ``target_minimum`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, curve: RuntimeFloatCurve = [], source_minimum: float = 0.000000, source_maximum: float = 0.000000, target_minimum: float = 0.000000, target_maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Only]
        """
        ...
    @property
    def source_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @source_minimum.setter
    def source_minimum(self, value: float) -> None:
        ...
    @property
    def source_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @source_maximum.setter
    def source_maximum(self, value: float) -> None:
        ...
    @property
    def target_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @target_minimum.setter
    def target_minimum(self, value: float) -> None:
        ...
    @property
    def target_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @target_maximum.setter
    def target_maximum(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_AnimEvalRichCurve(RigVMFunction_AnimEvalRichCurve):
    r"""
    deprecated: 'RigUnit_AnimEvalRichCurve' was renamed to 'RigVMFunction_AnimEvalRichCurve'.
    """
    def __init__(self, value: float = 0.000000, curve: RuntimeFloatCurve = [], source_minimum: float = 0.000000, source_maximum: float = 0.000000, target_minimum: float = 0.000000, target_maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_AnimRichCurve(RigVMFunction_AnimBase):
    r"""
    Provides a constant curve to be used for multiple curve evaluations
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_AnimRichCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve`` (RuntimeFloatCurve):  [Read-Only]
    """
    def __init__(self, curve: RuntimeFloatCurve = []) -> None:
        ...
    @property
    def curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Only]
        """
        ...

class RigUnit_AnimRichCurve(RigVMFunction_AnimRichCurve):
    r"""
    deprecated: 'RigUnit_AnimRichCurve' was renamed to 'RigVMFunction_AnimRichCurve'.
    """
    def __init__(self, curve: RuntimeFloatCurve = []) -> None:
        ...

class RigVMFunction_GetDeltaTime(RigVMFunction_AnimBase):
    r"""
    Returns the time gone by from the previous evaluation
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_GetDeltaTime.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, result: float = 0.000000) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_GetDeltaTime(RigVMFunction_GetDeltaTime):
    r"""
    deprecated: 'RigUnit_GetDeltaTime' was renamed to 'RigVMFunction_GetDeltaTime'.
    """
    def __init__(self, result: float = 0.000000) -> None:
        ...

class RigVMFunction_GetWorldTime(RigVMFunction_AnimBase):
    r"""
    Returns the current time (year, month, day, hour, minute)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_GetWorldTime.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``day`` (float):  [Read-Write]
    - ``hours`` (float):  [Read-Write]
    - ``minutes`` (float):  [Read-Write]
    - ``month`` (float):  [Read-Write]
    - ``overall_seconds`` (float):  [Read-Write]
    - ``seconds`` (float):  [Read-Write]
    - ``week_day`` (float):  [Read-Write]
    - ``year`` (float):  [Read-Write]
    """
    def __init__(self, year: float = 0.000000, month: float = 0.000000, day: float = 0.000000, week_day: float = 0.000000, hours: float = 0.000000, minutes: float = 0.000000, seconds: float = 0.000000, overall_seconds: float = 0.000000) -> None:
        ...
    @property
    def year(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def month(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def day(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def week_day(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def hours(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def minutes(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def seconds(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def overall_seconds(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_GetWorldTime(RigVMFunction_GetWorldTime):
    r"""
    deprecated: 'RigUnit_GetWorldTime' was renamed to 'RigVMFunction_GetWorldTime'.
    """
    def __init__(self, year: float = 0.000000, month: float = 0.000000, day: float = 0.000000, week_day: float = 0.000000, hours: float = 0.000000, minutes: float = 0.000000, seconds: float = 0.000000, overall_seconds: float = 0.000000) -> None:
        ...

class RigVMFunction_FramesToSeconds(RigVMFunction_AnimBase):
    r"""
    Converts frames to seconds based on the current frame rate
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_TimeConversion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frames`` (float):  [Read-Write]
    - ``seconds`` (float):  [Read-Write]
    """
    def __init__(self, frames: float = 0.000000, seconds: float = 0.000000) -> None:
        ...
    @property
    def frames(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @frames.setter
    def frames(self, value: float) -> None:
        ...
    @property
    def seconds(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_FramesToSeconds(RigVMFunction_FramesToSeconds):
    r"""
    deprecated: 'RigUnit_FramesToSeconds' was renamed to 'RigVMFunction_FramesToSeconds'.
    """
    def __init__(self, frames: float = 0.000000, seconds: float = 0.000000) -> None:
        ...

class RigVMFunction_SecondsToFrames(RigVMFunction_AnimBase):
    r"""
    Converts seconds to frames based on the current frame rate
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_TimeConversion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frames`` (float):  [Read-Write]
    - ``seconds`` (float):  [Read-Write]
    """
    def __init__(self, seconds: float = 0.000000, frames: float = 0.000000) -> None:
        ...
    @property
    def seconds(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @seconds.setter
    def seconds(self, value: float) -> None:
        ...
    @property
    def frames(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_SecondsToFrames(RigVMFunction_SecondsToFrames):
    r"""
    deprecated: 'RigUnit_SecondsToFrames' was renamed to 'RigVMFunction_SecondsToFrames'.
    """
    def __init__(self, seconds: float = 0.000000, frames: float = 0.000000) -> None:
        ...

class RigVMFunction_DebugLineNoSpace(RigVMFunction_DebugBaseMutable):
    r"""
    Draws a line in the viewport given a start and end vector
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugLine.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``thickness`` (float):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigVMFunction_DebugLineStripNoSpace(RigVMFunction_DebugBaseMutable):
    r"""
    Draws a line strip in the viewport given any number of points
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugLineStrip.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``points`` (Array[Vector]):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], points: Array[Vector] = [], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def points(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Write]
        """
        ...
    @points.setter
    def points(self, value: Array[Vector]) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigVMFunction_DebugBase(RigVMStruct):
    r"""
    Rig VMFunction Debug Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugBase.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_DebugPoint(RigVMFunction_DebugBase):
    r"""
    Rig VMFunction Debug Point
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugPoint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``mode`` (RigUnitDebugPointMode):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``vector`` (Vector):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, vector: Vector = [0.000000, 0.000000, 0.000000], mode: RigUnitDebugPointMode = RigUnitDebugPointMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], scale: float = 0.000000, thickness: float = 0.000000, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @vector.setter
    def vector(self, value: Vector) -> None:
        ...
    @property
    def mode(self) -> RigUnitDebugPointMode:
        r"""
        (RigUnitDebugPointMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitDebugPointMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_DebugPoint(RigVMFunction_DebugPoint):
    r"""
    deprecated: 'RigUnit_DebugPoint' was renamed to 'RigVMFunction_DebugPoint'.
    """
    def __init__(self, vector: Vector = [0.000000, 0.000000, 0.000000], mode: RigUnitDebugPointMode = RigUnitDebugPointMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], scale: float = 0.000000, thickness: float = 0.000000, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...

class RigVMFunction_DebugPointMutable(RigVMFunction_DebugBaseMutable):
    r"""
    Rig VMFunction Debug Point Mutable
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugPoint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``mode`` (RigUnitDebugPointMode):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``vector`` (Vector):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], vector: Vector = [0.000000, 0.000000, 0.000000], mode: RigUnitDebugPointMode = RigUnitDebugPointMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], scale: float = 0.000000, thickness: float = 0.000000, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @vector.setter
    def vector(self, value: Vector) -> None:
        ...
    @property
    def mode(self) -> RigUnitDebugPointMode:
        r"""
        (RigUnitDebugPointMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitDebugPointMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_DebugPointMutable(RigVMFunction_DebugPointMutable):
    r"""
    deprecated: 'RigUnit_DebugPointMutable' was renamed to 'RigVMFunction_DebugPointMutable'.
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], vector: Vector = [0.000000, 0.000000, 0.000000], mode: RigUnitDebugPointMode = RigUnitDebugPointMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], scale: float = 0.000000, thickness: float = 0.000000, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...

class RigVMFunction_DebugRectangle(RigVMFunction_DebugBaseMutable):
    r"""
    Rig VMFunction Debug Rectangle
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugPrimitives.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``scale`` (float):  [Read-Write]
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], scale: float = 0.000000, thickness: float = 0.000000, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigVMFunction_DebugRectangleNoSpace(RigVMFunction_DebugBaseMutable):
    r"""
    Draws a rectangle in the viewport given a transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugPrimitives.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], scale: float = 0.000000, thickness: float = 0.000000, world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigVMFunction_DebugArc(RigVMFunction_DebugBaseMutable):
    r"""
    Rig VMFunction Debug Arc
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugPrimitives.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``detail`` (int32):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``maximum_degrees`` (float):  [Read-Write]
    - ``minimum_degrees`` (float):  [Read-Write]
    - ``radius`` (float):  [Read-Write]
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], radius: float = 0.000000, minimum_degrees: float = 0.000000, maximum_degrees: float = 0.000000, thickness: float = 0.000000, detail: int = 0, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def minimum_degrees(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum_degrees.setter
    def minimum_degrees(self, value: float) -> None:
        ...
    @property
    def maximum_degrees(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum_degrees.setter
    def maximum_degrees(self, value: float) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def detail(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @detail.setter
    def detail(self, value: int) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigVMFunction_DebugArcNoSpace(RigVMFunction_DebugBaseMutable):
    r"""
    Draws an arc in the viewport, can take in different min and max degrees
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugPrimitives.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``detail`` (int32):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``maximum_degrees`` (float):  [Read-Write]
    - ``minimum_degrees`` (float):  [Read-Write]
    - ``radius`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], radius: float = 0.000000, minimum_degrees: float = 0.000000, maximum_degrees: float = 0.000000, thickness: float = 0.000000, detail: int = 0, world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def minimum_degrees(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum_degrees.setter
    def minimum_degrees(self, value: float) -> None:
        ...
    @property
    def maximum_degrees(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum_degrees.setter
    def maximum_degrees(self, value: float) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def detail(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @detail.setter
    def detail(self, value: int) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigVMFunction_DebugTransformMutableNoSpace(RigVMFunction_DebugBaseMutable):
    r"""
    Given a transform, will draw a point, axis, or a box in the viewport
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``mode`` (RigUnitDebugTransformMode):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], mode: RigUnitDebugTransformMode = RigUnitDebugTransformMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, scale: float = 0.000000, world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def mode(self) -> RigUnitDebugTransformMode:
        r"""
        (RigUnitDebugTransformMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitDebugTransformMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigVMFunction_DebugTransformArrayMutableNoSpace(RigVMFunction_DebugBaseMutable):
    r"""
    Given a transform array, will draw a point, axis, or a box in the viewport
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DebugTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``mode`` (RigUnitDebugTransformMode):  [Read-Write]
    - ``parent_indices`` (Array[int32]):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transforms`` (Array[Transform]):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], transforms: Array[Transform] = [], parent_indices: Array[int] = [], mode: RigUnitDebugTransformMode = RigUnitDebugTransformMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, scale: float = 0.000000, world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write]
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def parent_indices(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write]
        """
        ...
    @parent_indices.setter
    def parent_indices(self, value: Array[int]) -> None:
        ...
    @property
    def mode(self) -> RigUnitDebugTransformMode:
        r"""
        (RigUnitDebugTransformMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitDebugTransformMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigVMFunction_VisualDebugVector(RigVMFunction_DebugBase):
    r"""
    Rig VMFunction Visual Debug Vector
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_space`` (Name):  [Read-Write]
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``mode`` (RigUnitVisualDebugPointMode):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], enabled: bool = False, mode: RigUnitVisualDebugPointMode = RigUnitVisualDebugPointMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, scale: float = 0.000000, bone_space: Name = "None") -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def mode(self) -> RigUnitVisualDebugPointMode:
        r"""
        (RigUnitVisualDebugPointMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitVisualDebugPointMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bone_space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @bone_space.setter
    def bone_space(self, value: Name) -> None:
        ...

class RigVMFunction_VisualDebugVectorNoSpace(RigVMFunction_DebugBase):
    r"""
    Debug draw parameters for a Point or Vector given a vector
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``mode`` (RigUnitVisualDebugPointMode):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], enabled: bool = False, mode: RigUnitVisualDebugPointMode = RigUnitVisualDebugPointMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, scale: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def mode(self) -> RigUnitVisualDebugPointMode:
        r"""
        (RigUnitVisualDebugPointMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitVisualDebugPointMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...

class RigVMFunction_VisualDebugQuat(RigVMFunction_DebugBase):
    r"""
    Rig VMFunction Visual Debug Quat
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_space`` (Name):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], enabled: bool = False, thickness: float = 0.000000, scale: float = 0.000000, bone_space: Name = "None") -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bone_space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @bone_space.setter
    def bone_space(self, value: Name) -> None:
        ...

class RigVMFunction_VisualDebugQuatNoSpace(RigVMFunction_DebugBase):
    r"""
    Debug draw parameters for an Axis given a quaternion
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], enabled: bool = False, thickness: float = 0.000000, scale: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...

class RigVMFunction_VisualDebugTransform(RigVMFunction_DebugBase):
    r"""
    Rig VMFunction Visual Debug Transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_space`` (Name):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False, thickness: float = 0.000000, scale: float = 0.000000, bone_space: Name = "None") -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bone_space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @bone_space.setter
    def bone_space(self, value: Name) -> None:
        ...

class RigVMFunction_VisualDebugTransformNoSpace(RigVMFunction_DebugBase):
    r"""
    Debug draw parameters for an Axis given a transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False, thickness: float = 0.000000, scale: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...

class RigVMFunction_ForLoopCount(RigVMStructMutable):
    r"""
    Given a count, execute iteratively until the count is up
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_ForLoop.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``completed`` (RigVMExecuteContext):  [Read-Write]
    - ``count`` (int32):  [Read-Write]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``index`` (int32):  [Read-Write]
    - ``ratio`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], count: int = 0, index: int = 0, ratio: float = 0.000000, completed: RigVMExecuteContext = []) -> None:
        ...
    @property
    def count(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @count.setter
    def count(self, value: int) -> None:
        ...
    @property
    def index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def completed(self) -> RigVMExecuteContext:
        r"""
        (RigVMExecuteContext):  [Read-Only]
        """
        ...

class RigUnit_ForLoopCount(RigVMFunction_ForLoopCount):
    r"""
    deprecated: 'RigUnit_ForLoopCount' was renamed to 'RigVMFunction_ForLoopCount'.
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], count: int = 0, index: int = 0, ratio: float = 0.000000, completed: RigVMExecuteContext = []) -> None:
        ...

class RigVMFunction_UserDefinedEvent(RigVMStruct):
    r"""
    User Defined Event for running custom logic
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_UserDefinedEvent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``event_name`` (Name):  [Read-Only] True if the current interaction is a rotation
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] The execution result
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], event_name: Name = "None") -> None:
        ...
    @property
    def execute_context(self) -> RigVMExecuteContext:
        r"""
        (RigVMExecuteContext):  [Read-Only] The execution result
        """
        ...
    @property
    def event_name(self) -> Name:
        r"""
        (Name):  [Read-Only] True if the current interaction is a rotation
        """
        ...

class RigUnit_UserDefinedEvent(RigVMFunction_UserDefinedEvent):
    r"""
    deprecated: 'RigUnit_UserDefinedEvent' was renamed to 'RigVMFunction_UserDefinedEvent'.
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], event_name: Name = "None") -> None:
        ...

class RigVMFunction_MathBase(RigVMStruct):
    r"""
    Rig VMFunction Math Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBase.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_MathBase(RigVMFunction_MathBase):
    r"""
    deprecated: 'RigUnit_MathBase' was renamed to 'RigVMFunction_MathBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathBoolBase(RigVMFunction_MathBase):
    r"""
    Rig VMFunction Math Bool Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_MathBoolBase(RigVMFunction_MathBoolBase):
    r"""
    deprecated: 'RigUnit_MathBoolBase' was renamed to 'RigVMFunction_MathBoolBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathBoolConstant(RigVMFunction_MathBoolBase):
    r"""
    Rig VMFunction Math Bool Constant
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (bool):  [Read-Write]
    """
    def __init__(self, value: bool = False) -> None:
        ...
    @property
    def value(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathBoolConstant(RigVMFunction_MathBoolConstant):
    r"""
    deprecated: 'RigUnit_MathBoolConstant' was renamed to 'RigVMFunction_MathBoolConstant'.
    """
    def __init__(self, value: bool = False) -> None:
        ...

class RigVMFunction_MathBoolUnaryOp(RigVMFunction_MathBoolBase):
    r"""
    Rig VMFunction Math Bool Unary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (bool):  [Read-Write]
    - ``value`` (bool):  [Read-Write]
    """
    def __init__(self, value: bool = False, result: bool = False) -> None:
        ...
    @property
    def value(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: bool) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathBoolUnaryOp(RigVMFunction_MathBoolUnaryOp):
    r"""
    deprecated: 'RigUnit_MathBoolUnaryOp' was renamed to 'RigVMFunction_MathBoolUnaryOp'.
    """
    def __init__(self, value: bool = False, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolBinaryOp(RigVMFunction_MathBoolBase):
    r"""
    Rig VMFunction Math Bool Binary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (bool):  [Read-Write]
    - ``b`` (bool):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...
    @property
    def a(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: bool) -> None:
        ...
    @property
    def b(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: bool) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathBoolBinaryOp(RigVMFunction_MathBoolBinaryOp):
    r"""
    deprecated: 'RigUnit_MathBoolBinaryOp' was renamed to 'RigVMFunction_MathBoolBinaryOp'.
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolBinaryAggregateOp(RigVMFunction_MathBoolBase):
    r"""
    Rig VMFunction Math Bool Binary Aggregate Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (bool):  [Read-Write]
    - ``b`` (bool):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...
    @property
    def a(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: bool) -> None:
        ...
    @property
    def b(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: bool) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathBoolBinaryAggregateOp(RigVMFunction_MathBoolBinaryAggregateOp):
    r"""
    deprecated: 'RigUnit_MathBoolBinaryAggregateOp' was renamed to 'RigVMFunction_MathBoolBinaryAggregateOp'.
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolMake(RigVMFunction_MathBoolBase):
    r"""
    A boolean constant
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (bool):  [Read-Write]
    """
    def __init__(self, value: bool = False) -> None:
        ...
    @property
    def value(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: bool) -> None:
        ...

class RigUnit_MathBoolMake(RigVMFunction_MathBoolMake):
    r"""
    deprecated: 'RigUnit_MathBoolMake' was renamed to 'RigVMFunction_MathBoolMake'.
    """
    def __init__(self, value: bool = False) -> None:
        ...

class RigVMFunction_MathBoolConstTrue(RigVMFunction_MathBoolConstant):
    r"""
    Returns true
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (bool):  [Read-Write]
    """
    def __init__(self, value: bool = False) -> None:
        ...

class RigUnit_MathBoolConstTrue(RigVMFunction_MathBoolConstTrue):
    r"""
    deprecated: 'RigUnit_MathBoolConstTrue' was renamed to 'RigVMFunction_MathBoolConstTrue'.
    """
    def __init__(self, value: bool = False) -> None:
        ...

class RigVMFunction_MathBoolConstFalse(RigVMFunction_MathBoolConstant):
    r"""
    Returns false
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (bool):  [Read-Write]
    """
    def __init__(self, value: bool = False) -> None:
        ...

class RigUnit_MathBoolConstFalse(RigVMFunction_MathBoolConstFalse):
    r"""
    deprecated: 'RigUnit_MathBoolConstFalse' was renamed to 'RigVMFunction_MathBoolConstFalse'.
    """
    def __init__(self, value: bool = False) -> None:
        ...

class RigVMFunction_MathBoolNot(RigVMFunction_MathBoolUnaryOp):
    r"""
    Returns true if the condition is false
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (bool):  [Read-Write]
    - ``value`` (bool):  [Read-Write]
    """
    def __init__(self, value: bool = False, result: bool = False) -> None:
        ...

class RigUnit_MathBoolNot(RigVMFunction_MathBoolNot):
    r"""
    deprecated: 'RigUnit_MathBoolNot' was renamed to 'RigVMFunction_MathBoolNot'.
    """
    def __init__(self, value: bool = False, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolAnd(RigVMFunction_MathBoolBinaryAggregateOp):
    r"""
    Returns true if both conditions are true
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (bool):  [Read-Write]
    - ``b`` (bool):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigUnit_MathBoolAnd(RigVMFunction_MathBoolAnd):
    r"""
    deprecated: 'RigUnit_MathBoolAnd' was renamed to 'RigVMFunction_MathBoolAnd'.
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolNand(RigVMFunction_MathBoolBinaryOp):
    r"""
    Returns true if both conditions are false
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (bool):  [Read-Write]
    - ``b`` (bool):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigUnit_MathBoolNand(RigVMFunction_MathBoolNand):
    r"""
    deprecated: 'RigUnit_MathBoolNand' was renamed to 'RigVMFunction_MathBoolNand'.
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolNand2(RigVMFunction_MathBoolBinaryOp):
    r"""
    Returns false if both conditions are true
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (bool):  [Read-Write]
    - ``b`` (bool):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigUnit_MathBoolNand2(RigVMFunction_MathBoolNand2):
    r"""
    deprecated: 'RigUnit_MathBoolNand2' was renamed to 'RigVMFunction_MathBoolNand2'.
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolOr(RigVMFunction_MathBoolBinaryAggregateOp):
    r"""
    Returns true if one of the conditions is true
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (bool):  [Read-Write]
    - ``b`` (bool):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigUnit_MathBoolOr(RigVMFunction_MathBoolOr):
    r"""
    deprecated: 'RigUnit_MathBoolOr' was renamed to 'RigVMFunction_MathBoolOr'.
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolEquals(RigVMFunction_MathBoolBase):
    r"""
    Returns true if the value A equals B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (bool):  [Read-Write]
    - ``b`` (bool):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...
    @property
    def a(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: bool) -> None:
        ...
    @property
    def b(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: bool) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathBoolEquals(RigVMFunction_MathBoolEquals):
    r"""
    deprecated: 'RigUnit_MathBoolEquals' was renamed to 'RigVMFunction_MathBoolEquals'.
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolNotEquals(RigVMFunction_MathBoolBase):
    r"""
    Returns true if the value A does not equal B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (bool):  [Read-Write]
    - ``b`` (bool):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...
    @property
    def a(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: bool) -> None:
        ...
    @property
    def b(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: bool) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathBoolNotEquals(RigVMFunction_MathBoolNotEquals):
    r"""
    deprecated: 'RigUnit_MathBoolNotEquals' was renamed to 'RigVMFunction_MathBoolNotEquals'.
    """
    def __init__(self, a: bool = False, b: bool = False, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolToggled(RigVMFunction_MathBoolBase):
    r"""
    Returns true if the value has changed from the last run
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``toggled`` (bool):  [Read-Write]
    - ``value`` (bool):  [Read-Write]
    """
    def __init__(self, value: bool = False, toggled: bool = False) -> None:
        ...
    @property
    def value(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: bool) -> None:
        ...
    @property
    def toggled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathBoolToggled(RigVMFunction_MathBoolToggled):
    r"""
    deprecated: 'RigUnit_MathBoolToggled' was renamed to 'RigVMFunction_MathBoolToggled'.
    """
    def __init__(self, value: bool = False, toggled: bool = False) -> None:
        ...

class RigVMFunction_MathBoolFlipFlop(RigVMFunction_MathBoolBase):
    r"""
    Returns true and false as a sequence.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration`` (float):  [Read-Write] The duration in seconds at which the result won't change.
      Use 0 for a different result every time.
    - ``result`` (bool):  [Read-Write]
    - ``start_value`` (bool):  [Read-Write] The initial value to use for the flag
    """
    def __init__(self, start_value: bool = False, duration: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def start_value(self) -> bool:
        r"""
        (bool):  [Read-Write] The initial value to use for the flag
        """
        ...
    @start_value.setter
    def start_value(self, value: bool) -> None:
        ...
    @property
    def duration(self) -> float:
        r"""
        (float):  [Read-Write] The duration in seconds at which the result won't change.
        Use 0 for a different result every time.
        """
        ...
    @duration.setter
    def duration(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathBoolFlipFlop(RigVMFunction_MathBoolFlipFlop):
    r"""
    deprecated: 'RigUnit_MathBoolFlipFlop' was renamed to 'RigVMFunction_MathBoolFlipFlop'.
    """
    def __init__(self, start_value: bool = False, duration: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolOnce(RigVMFunction_MathBoolBase):
    r"""
    Returns true once the first time this node is hit
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration`` (float):  [Read-Write] The duration in seconds at which the result is true
      Use 0 for a different result every time.
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, duration: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def duration(self) -> float:
        r"""
        (float):  [Read-Write] The duration in seconds at which the result is true
        Use 0 for a different result every time.
        """
        ...
    @duration.setter
    def duration(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathBoolOnce(RigVMFunction_MathBoolOnce):
    r"""
    deprecated: 'RigUnit_MathBoolOnce' was renamed to 'RigVMFunction_MathBoolOnce'.
    """
    def __init__(self, duration: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathBoolToFloat(RigVMFunction_MathBoolBase):
    r"""
    Turns the given bool into a float value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (bool):  [Read-Write]
    """
    def __init__(self, value: bool = False, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: bool) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathBoolToFloat(RigVMFunction_MathBoolToFloat):
    r"""
    deprecated: 'RigUnit_MathBoolToFloat' was renamed to 'RigVMFunction_MathBoolToFloat'.
    """
    def __init__(self, value: bool = False, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathBoolToInteger(RigVMFunction_MathBoolBase):
    r"""
    Turns the given bool into an integer value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (int32):  [Read-Write]
    - ``value`` (bool):  [Read-Write]
    """
    def __init__(self, value: bool = False, result: int = 0) -> None:
        ...
    @property
    def value(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: bool) -> None:
        ...
    @property
    def result(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathBoolToInteger(RigVMFunction_MathBoolToInteger):
    r"""
    deprecated: 'RigUnit_MathBoolToInteger' was renamed to 'RigVMFunction_MathBoolToInteger'.
    """
    def __init__(self, value: bool = False, result: int = 0) -> None:
        ...

class RigVMFunction_MathColorBase(RigVMFunction_MathBase):
    r"""
    Rig VMFunction Math Color Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathColor.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_MathColorBase(RigVMFunction_MathColorBase):
    r"""
    deprecated: 'RigUnit_MathColorBase' was renamed to 'RigVMFunction_MathColorBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathColorBinaryOp(RigVMFunction_MathColorBase):
    r"""
    Rig VMFunction Math Color Binary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (LinearColor):  [Read-Write]
    - ``b`` (LinearColor):  [Read-Write]
    - ``result`` (LinearColor):  [Read-Write]
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def a(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: LinearColor) -> None:
        ...
    @property
    def b(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: LinearColor) -> None:
        ...
    @property
    def result(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...

class RigUnit_MathColorBinaryOp(RigVMFunction_MathColorBinaryOp):
    r"""
    deprecated: 'RigUnit_MathColorBinaryOp' was renamed to 'RigVMFunction_MathColorBinaryOp'.
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathColorBinaryAggregateOp(RigVMFunction_MathColorBase):
    r"""
    Rig VMFunction Math Color Binary Aggregate Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (LinearColor):  [Read-Write]
    - ``b`` (LinearColor):  [Read-Write]
    - ``result`` (LinearColor):  [Read-Write]
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def a(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: LinearColor) -> None:
        ...
    @property
    def b(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: LinearColor) -> None:
        ...
    @property
    def result(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...

class RigUnit_MathColorBinaryAggregateOp(RigVMFunction_MathColorBinaryAggregateOp):
    r"""
    deprecated: 'RigUnit_MathColorBinaryAggregateOp' was renamed to 'RigVMFunction_MathColorBinaryAggregateOp'.
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathColorMake(RigVMFunction_MathColorBase):
    r"""
    Makes a color from its components
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``g`` (float):  [Read-Write]
    - ``r`` (float):  [Read-Write]
    - ``result`` (LinearColor):  [Read-Write]
    """
    def __init__(self, r: float = 0.000000, g: float = 0.000000, b: float = 0.000000, a: float = 0.000000, result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def r(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @r.setter
    def r(self, value: float) -> None:
        ...
    @property
    def g(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @g.setter
    def g(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def result(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...

class RigUnit_MathColorMake(RigVMFunction_MathColorMake):
    r"""
    deprecated: 'RigUnit_MathColorMake' was renamed to 'RigVMFunction_MathColorMake'.
    """
    def __init__(self, r: float = 0.000000, g: float = 0.000000, b: float = 0.000000, a: float = 0.000000, result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathColorFromFloat(RigVMFunction_MathColorBase):
    r"""
    Makes a vector from a single float
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (LinearColor):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...

class RigUnit_MathColorFromFloat(RigVMFunction_MathColorFromFloat):
    r"""
    deprecated: 'RigUnit_MathColorFromFloat' was renamed to 'RigVMFunction_MathColorFromFloat'.
    """
    def __init__(self, value: float = 0.000000, result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathColorFromDouble(RigVMFunction_MathColorBase):
    r"""
    Makes a vector from a single double
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (LinearColor):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...

class RigUnit_MathColorFromDouble(RigVMFunction_MathColorFromDouble):
    r"""
    deprecated: 'RigUnit_MathColorFromDouble' was renamed to 'RigVMFunction_MathColorFromDouble'.
    """
    def __init__(self, value: float = 0.000000, result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathColorAdd(RigVMFunction_MathColorBinaryAggregateOp):
    r"""
    Returns the sum of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (LinearColor):  [Read-Write]
    - ``b`` (LinearColor):  [Read-Write]
    - ``result`` (LinearColor):  [Read-Write]
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathColorAdd(RigVMFunction_MathColorAdd):
    r"""
    deprecated: 'RigUnit_MathColorAdd' was renamed to 'RigVMFunction_MathColorAdd'.
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathColorSub(RigVMFunction_MathColorBinaryOp):
    r"""
    Returns the difference of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (LinearColor):  [Read-Write]
    - ``b`` (LinearColor):  [Read-Write]
    - ``result`` (LinearColor):  [Read-Write]
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathColorSub(RigVMFunction_MathColorSub):
    r"""
    deprecated: 'RigUnit_MathColorSub' was renamed to 'RigVMFunction_MathColorSub'.
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathColorMul(RigVMFunction_MathColorBinaryAggregateOp):
    r"""
    Returns the product of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (LinearColor):  [Read-Write]
    - ``b`` (LinearColor):  [Read-Write]
    - ``result`` (LinearColor):  [Read-Write]
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathColorMul(RigVMFunction_MathColorMul):
    r"""
    deprecated: 'RigUnit_MathColorMul' was renamed to 'RigVMFunction_MathColorMul'.
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathColorLerp(RigVMFunction_MathColorBase):
    r"""
    Linearly interpolates between A and B using the ratio T
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (LinearColor):  [Read-Write]
    - ``b`` (LinearColor):  [Read-Write]
    - ``result`` (LinearColor):  [Read-Write]
    - ``t`` (float):  [Read-Write]
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], t: float = 0.000000, result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def a(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: LinearColor) -> None:
        ...
    @property
    def b(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: LinearColor) -> None:
        ...
    @property
    def t(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @t.setter
    def t(self, value: float) -> None:
        ...
    @property
    def result(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...

class RigUnit_MathColorLerp(RigVMFunction_MathColorLerp):
    r"""
    deprecated: 'RigUnit_MathColorLerp' was renamed to 'RigVMFunction_MathColorLerp'.
    """
    def __init__(self, a: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], b: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], t: float = 0.000000, result: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathDoubleBase(RigVMFunction_MathBase):
    r"""
    Rig VMFunction Math Double Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_MathDoubleBase(RigVMFunction_MathDoubleBase):
    r"""
    deprecated: 'RigUnit_MathDoubleBase' was renamed to 'RigVMFunction_MathDoubleBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathDoubleConstant(RigVMFunction_MathDoubleBase):
    r"""
    Rig VMFunction Math Double Constant
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleConstant(RigVMFunction_MathDoubleConstant):
    r"""
    deprecated: 'RigUnit_MathDoubleConstant' was renamed to 'RigVMFunction_MathDoubleConstant'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleUnaryOp(RigVMFunction_MathDoubleBase):
    r"""
    Rig VMFunction Math Double Unary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleUnaryOp(RigVMFunction_MathDoubleUnaryOp):
    r"""
    deprecated: 'RigUnit_MathDoubleUnaryOp' was renamed to 'RigVMFunction_MathDoubleUnaryOp'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleBinaryOp(RigVMFunction_MathDoubleBase):
    r"""
    Rig VMFunction Math Double Binary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleBinaryOp(RigVMFunction_MathDoubleBinaryOp):
    r"""
    deprecated: 'RigUnit_MathDoubleBinaryOp' was renamed to 'RigVMFunction_MathDoubleBinaryOp'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleBinaryAggregateOp(RigVMFunction_MathDoubleBase):
    r"""
    Rig VMFunction Math Double Binary Aggregate Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleBinaryAggregateOp(RigVMFunction_MathDoubleBinaryAggregateOp):
    r"""
    deprecated: 'RigUnit_MathDoubleBinaryAggregateOp' was renamed to 'RigVMFunction_MathDoubleBinaryAggregateOp'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleMake(RigVMFunction_MathDoubleBase):
    r"""
    A double constant
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class RigUnit_MathDoubleMake(RigVMFunction_MathDoubleMake):
    r"""
    deprecated: 'RigUnit_MathDoubleMake' was renamed to 'RigVMFunction_MathDoubleMake'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleConstPi(RigVMFunction_MathDoubleConstant):
    r"""
    Returns PI
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleConstPi(RigVMFunction_MathDoubleConstPi):
    r"""
    deprecated: 'RigUnit_MathDoubleConstPi' was renamed to 'RigVMFunction_MathDoubleConstPi'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleConstHalfPi(RigVMFunction_MathDoubleConstant):
    r"""
    Returns PI * 0.5
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleConstHalfPi(RigVMFunction_MathDoubleConstHalfPi):
    r"""
    deprecated: 'RigUnit_MathDoubleConstHalfPi' was renamed to 'RigVMFunction_MathDoubleConstHalfPi'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleConstTwoPi(RigVMFunction_MathDoubleConstant):
    r"""
    Returns PI * 2.0
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleConstTwoPi(RigVMFunction_MathDoubleConstTwoPi):
    r"""
    deprecated: 'RigUnit_MathDoubleConstTwoPi' was renamed to 'RigVMFunction_MathDoubleConstTwoPi'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleConstE(RigVMFunction_MathDoubleConstant):
    r"""
    Returns E
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleConstE(RigVMFunction_MathDoubleConstE):
    r"""
    deprecated: 'RigUnit_MathDoubleConstE' was renamed to 'RigVMFunction_MathDoubleConstE'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleAdd(RigVMFunction_MathDoubleBinaryAggregateOp):
    r"""
    Returns the sum of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleAdd(RigVMFunction_MathDoubleAdd):
    r"""
    deprecated: 'RigUnit_MathDoubleAdd' was renamed to 'RigVMFunction_MathDoubleAdd'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleSub(RigVMFunction_MathDoubleBinaryOp):
    r"""
    Returns the difference of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleSub(RigVMFunction_MathDoubleSub):
    r"""
    deprecated: 'RigUnit_MathDoubleSub' was renamed to 'RigVMFunction_MathDoubleSub'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleMul(RigVMFunction_MathDoubleBinaryAggregateOp):
    r"""
    Returns the product of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleMul(RigVMFunction_MathDoubleMul):
    r"""
    deprecated: 'RigUnit_MathDoubleMul' was renamed to 'RigVMFunction_MathDoubleMul'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleDiv(RigVMFunction_MathDoubleBinaryOp):
    r"""
    Returns the division of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleDiv(RigVMFunction_MathDoubleDiv):
    r"""
    deprecated: 'RigUnit_MathDoubleDiv' was renamed to 'RigVMFunction_MathDoubleDiv'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleMod(RigVMFunction_MathDoubleBinaryOp):
    r"""
    Returns the modulo of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleMod(RigVMFunction_MathDoubleMod):
    r"""
    deprecated: 'RigUnit_MathDoubleMod' was renamed to 'RigVMFunction_MathDoubleMod'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleMin(RigVMFunction_MathDoubleBinaryAggregateOp):
    r"""
    Returns the smaller of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleMin(RigVMFunction_MathDoubleMin):
    r"""
    deprecated: 'RigUnit_MathDoubleMin' was renamed to 'RigVMFunction_MathDoubleMin'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleMax(RigVMFunction_MathDoubleBinaryAggregateOp):
    r"""
    Returns the larger of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleMax(RigVMFunction_MathDoubleMax):
    r"""
    deprecated: 'RigUnit_MathDoubleMax' was renamed to 'RigVMFunction_MathDoubleMax'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoublePow(RigVMFunction_MathDoubleBinaryOp):
    r"""
    Returns the value of A raised to the power of B.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoublePow(RigVMFunction_MathDoublePow):
    r"""
    deprecated: 'RigUnit_MathDoublePow' was renamed to 'RigVMFunction_MathDoublePow'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleSqrt(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the square root of the given value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleSqrt(RigVMFunction_MathDoubleSqrt):
    r"""
    deprecated: 'RigUnit_MathDoubleSqrt' was renamed to 'RigVMFunction_MathDoubleSqrt'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleNegate(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the negative value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleNegate(RigVMFunction_MathDoubleNegate):
    r"""
    deprecated: 'RigUnit_MathDoubleNegate' was renamed to 'RigVMFunction_MathDoubleNegate'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleAbs(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the absolute (positive) value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleAbs(RigVMFunction_MathDoubleAbs):
    r"""
    deprecated: 'RigUnit_MathDoubleAbs' was renamed to 'RigVMFunction_MathDoubleAbs'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleFloor(RigVMFunction_MathDoubleBase):
    r"""
    Returns the closest lower full number (integer) of the value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``int`` (int32):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...
    @property
    def int(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleFloor(RigVMFunction_MathDoubleFloor):
    r"""
    deprecated: 'RigUnit_MathDoubleFloor' was renamed to 'RigVMFunction_MathDoubleFloor'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...

class RigVMFunction_MathDoubleCeil(RigVMFunction_MathDoubleBase):
    r"""
    Returns the closest higher full number (integer) of the value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``int`` (int32):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...
    @property
    def int(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleCeil(RigVMFunction_MathDoubleCeil):
    r"""
    deprecated: 'RigUnit_MathDoubleCeil' was renamed to 'RigVMFunction_MathDoubleCeil'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...

class RigVMFunction_MathDoubleRound(RigVMFunction_MathDoubleBase):
    r"""
    Returns the closest higher full number (integer) of the value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``int`` (int32):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...
    @property
    def int(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleRound(RigVMFunction_MathDoubleRound):
    r"""
    deprecated: 'RigUnit_MathDoubleRound' was renamed to 'RigVMFunction_MathDoubleRound'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...

class RigVMFunction_MathDoubleToInt(RigVMFunction_MathDoubleBase):
    r"""
    Returns the double cast to an int (this uses floor)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (int32):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: int = 0) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleToInt(RigVMFunction_MathDoubleToInt):
    r"""
    deprecated: 'RigUnit_MathDoubleToInt' was renamed to 'RigVMFunction_MathDoubleToInt'.
    """
    def __init__(self, value: float = 0.000000, result: int = 0) -> None:
        ...

class RigVMFunction_MathDoubleSign(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the sign of the value (+1 for >= 0.0, -1 for < 0.0)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleSign(RigVMFunction_MathDoubleSign):
    r"""
    deprecated: 'RigUnit_MathDoubleSign' was renamed to 'RigVMFunction_MathDoubleSign'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleClamp(RigVMFunction_MathDoubleBase):
    r"""
    Clamps the given value within the range provided by minimum and maximum
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``maximum`` (double):  [Read-Write]
    - ``minimum`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, minimum: float = 0.000000, maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def minimum(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @minimum.setter
    def minimum(self, value: float) -> None:
        ...
    @property
    def maximum(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @maximum.setter
    def maximum(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleClamp(RigVMFunction_MathDoubleClamp):
    r"""
    deprecated: 'RigUnit_MathDoubleClamp' was renamed to 'RigVMFunction_MathDoubleClamp'.
    """
    def __init__(self, value: float = 0.000000, minimum: float = 0.000000, maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleLerp(RigVMFunction_MathDoubleBase):
    r"""
    Linearly interpolates between A and B using the ratio T
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    - ``t`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, t: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def t(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @t.setter
    def t(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleLerp(RigVMFunction_MathDoubleLerp):
    r"""
    deprecated: 'RigUnit_MathDoubleLerp' was renamed to 'RigVMFunction_MathDoubleLerp'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, t: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleRemap(RigVMFunction_MathDoubleBase):
    r"""
    Remaps the given value from a source range to a target range.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clamp`` (bool):  [Read-Write] If set to true the result is clamped to the target range
    - ``result`` (double):  [Read-Write]
    - ``source_maximum`` (double):  [Read-Write]
    - ``source_minimum`` (double):  [Read-Write]
    - ``target_maximum`` (double):  [Read-Write]
    - ``target_minimum`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, source_minimum: float = 0.000000, source_maximum: float = 0.000000, target_minimum: float = 0.000000, target_maximum: float = 0.000000, clamp: bool = False, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def source_minimum(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @source_minimum.setter
    def source_minimum(self, value: float) -> None:
        ...
    @property
    def source_maximum(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @source_maximum.setter
    def source_maximum(self, value: float) -> None:
        ...
    @property
    def target_minimum(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @target_minimum.setter
    def target_minimum(self, value: float) -> None:
        ...
    @property
    def target_maximum(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @target_maximum.setter
    def target_maximum(self, value: float) -> None:
        ...
    @property
    def clamp(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the result is clamped to the target range
        """
        ...
    @clamp.setter
    def clamp(self, value: bool) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleRemap(RigVMFunction_MathDoubleRemap):
    r"""
    deprecated: 'RigUnit_MathDoubleRemap' was renamed to 'RigVMFunction_MathDoubleRemap'.
    """
    def __init__(self, value: float = 0.000000, source_minimum: float = 0.000000, source_maximum: float = 0.000000, target_minimum: float = 0.000000, target_maximum: float = 0.000000, clamp: bool = False, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleEquals(RigVMFunction_MathDoubleBase):
    r"""
    Returns true if the value A equals B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleEquals(RigVMFunction_MathDoubleEquals):
    r"""
    deprecated: 'RigUnit_MathDoubleEquals' was renamed to 'RigVMFunction_MathDoubleEquals'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathDoubleNotEquals(RigVMFunction_MathDoubleBase):
    r"""
    Returns true if the value A does not equal B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleNotEquals(RigVMFunction_MathDoubleNotEquals):
    r"""
    deprecated: 'RigUnit_MathDoubleNotEquals' was renamed to 'RigVMFunction_MathDoubleNotEquals'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathDoubleGreater(RigVMFunction_MathDoubleBase):
    r"""
    Returns true if the value A is greater than B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleGreater(RigVMFunction_MathDoubleGreater):
    r"""
    deprecated: 'RigUnit_MathDoubleGreater' was renamed to 'RigVMFunction_MathDoubleGreater'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathDoubleLess(RigVMFunction_MathDoubleBase):
    r"""
    Returns true if the value A is less than B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleLess(RigVMFunction_MathDoubleLess):
    r"""
    deprecated: 'RigUnit_MathDoubleLess' was renamed to 'RigVMFunction_MathDoubleLess'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathDoubleGreaterEqual(RigVMFunction_MathDoubleBase):
    r"""
    Returns true if the value A is greater than or equal to B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleGreaterEqual(RigVMFunction_MathDoubleGreaterEqual):
    r"""
    deprecated: 'RigUnit_MathDoubleGreaterEqual' was renamed to 'RigVMFunction_MathDoubleGreaterEqual'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathDoubleLessEqual(RigVMFunction_MathDoubleBase):
    r"""
    Returns true if the value A is less than or equal to B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleLessEqual(RigVMFunction_MathDoubleLessEqual):
    r"""
    deprecated: 'RigUnit_MathDoubleLessEqual' was renamed to 'RigVMFunction_MathDoubleLessEqual'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathDoubleIsNearlyZero(RigVMFunction_MathDoubleBase):
    r"""
    Returns true if the value is nearly zero
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (bool):  [Read-Write]
    - ``tolerance`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, tolerance: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def tolerance(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @tolerance.setter
    def tolerance(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleIsNearlyZero(RigVMFunction_MathDoubleIsNearlyZero):
    r"""
    deprecated: 'RigUnit_MathDoubleIsNearlyZero' was renamed to 'RigVMFunction_MathDoubleIsNearlyZero'.
    """
    def __init__(self, value: float = 0.000000, tolerance: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathDoubleIsNearlyEqual(RigVMFunction_MathDoubleBase):
    r"""
    Returns true if the value A is almost equal to B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    - ``tolerance`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, tolerance: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def tolerance(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @tolerance.setter
    def tolerance(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleIsNearlyEqual(RigVMFunction_MathDoubleIsNearlyEqual):
    r"""
    deprecated: 'RigUnit_MathDoubleIsNearlyEqual' was renamed to 'RigVMFunction_MathDoubleIsNearlyEqual'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, tolerance: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathDoubleDeg(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the degrees of a given value in radians
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleDeg(RigVMFunction_MathDoubleDeg):
    r"""
    deprecated: 'RigUnit_MathDoubleDeg' was renamed to 'RigVMFunction_MathDoubleDeg'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleRad(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the radians of a given value in degrees
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleRad(RigVMFunction_MathDoubleRad):
    r"""
    deprecated: 'RigUnit_MathDoubleRad' was renamed to 'RigVMFunction_MathDoubleRad'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleSin(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the sinus value of the given value (in radians)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleSin(RigVMFunction_MathDoubleSin):
    r"""
    deprecated: 'RigUnit_MathDoubleSin' was renamed to 'RigVMFunction_MathDoubleSin'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleCos(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the cosinus value of the given value (in radians)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleCos(RigVMFunction_MathDoubleCos):
    r"""
    deprecated: 'RigUnit_MathDoubleCos' was renamed to 'RigVMFunction_MathDoubleCos'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleTan(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the tangens value of the given value (in radians)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleTan(RigVMFunction_MathDoubleTan):
    r"""
    deprecated: 'RigUnit_MathDoubleTan' was renamed to 'RigVMFunction_MathDoubleTan'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleAsin(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the inverse sinus value (in radians) of the given value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleAsin(RigVMFunction_MathDoubleAsin):
    r"""
    deprecated: 'RigUnit_MathDoubleAsin' was renamed to 'RigVMFunction_MathDoubleAsin'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleAcos(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the inverse cosinus value (in radians) of the given value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleAcos(RigVMFunction_MathDoubleAcos):
    r"""
    deprecated: 'RigUnit_MathDoubleAcos' was renamed to 'RigVMFunction_MathDoubleAcos'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleAtan(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Returns the inverse tangens value (in radians) of the given value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleAtan(RigVMFunction_MathDoubleAtan):
    r"""
    deprecated: 'RigUnit_MathDoubleAtan' was renamed to 'RigVMFunction_MathDoubleAtan'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleAtan2(RigVMFunction_MathDoubleBinaryOp):
    r"""
    Returns the arctangent of the specified A and B coordinates.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleLawOfCosine(RigVMFunction_MathDoubleBase):
    r"""
    Computes the angles alpha, beta and gamma (in radians) between the three sides A, B and C
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (double):  [Read-Write]
    - ``alpha_angle`` (double):  [Read-Write]
    - ``b`` (double):  [Read-Write]
    - ``beta_angle`` (double):  [Read-Write]
    - ``c`` (double):  [Read-Write]
    - ``gamma_angle`` (double):  [Read-Write]
    - ``valid`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, c: float = 0.000000, alpha_angle: float = 0.000000, beta_angle: float = 0.000000, gamma_angle: float = 0.000000, valid: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def c(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @c.setter
    def c(self, value: float) -> None:
        ...
    @property
    def alpha_angle(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...
    @property
    def beta_angle(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...
    @property
    def gamma_angle(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...
    @property
    def valid(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathDoubleLawOfCosine(RigVMFunction_MathDoubleLawOfCosine):
    r"""
    deprecated: 'RigUnit_MathDoubleLawOfCosine' was renamed to 'RigVMFunction_MathDoubleLawOfCosine'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, c: float = 0.000000, alpha_angle: float = 0.000000, beta_angle: float = 0.000000, gamma_angle: float = 0.000000, valid: bool = False) -> None:
        ...

class RigVMFunction_MathDoubleExponential(RigVMFunction_MathDoubleUnaryOp):
    r"""
    Computes the base-e exponential of the given value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathDoubleExponential(RigVMFunction_MathDoubleExponential):
    r"""
    deprecated: 'RigUnit_MathDoubleExponential' was renamed to 'RigVMFunction_MathDoubleExponential'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDoubleArraySum(RigVMFunction_MathDoubleBase):
    r"""
    Returns the sum of the given array
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``array`` (Array[double]):  [Read-Write]
    - ``sum`` (double):  [Read-Write]
    """
    def __init__(self, array: Array[float] = [], sum: float = 0.000000) -> None:
        ...
    @property
    def array(self) -> Array[float]:
        r"""
        (Array[double]):  [Read-Write]
        """
        ...
    @array.setter
    def array(self, value: Array[float]) -> None:
        ...
    @property
    def sum(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...

class RigVMFunction_MathDoubleArrayAverage(RigVMFunction_MathDoubleBase):
    r"""
    Returns the average of the given array
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``array`` (Array[double]):  [Read-Write]
    - ``average`` (double):  [Read-Write]
    """
    def __init__(self, array: Array[float] = [], average: float = 0.000000) -> None:
        ...
    @property
    def array(self) -> Array[float]:
        r"""
        (Array[double]):  [Read-Write]
        """
        ...
    @array.setter
    def array(self, value: Array[float]) -> None:
        ...
    @property
    def average(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...

class RigVMFunction_MathFloatBase(RigVMFunction_MathBase):
    r"""
    Rig VMFunction Math Float Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_MathFloatBase(RigVMFunction_MathFloatBase):
    r"""
    deprecated: 'RigUnit_MathFloatBase' was renamed to 'RigVMFunction_MathFloatBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathFloatConstant(RigVMFunction_MathFloatBase):
    r"""
    Rig VMFunction Math Float Constant
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathFloatConstant(RigVMFunction_MathFloatConstant):
    r"""
    deprecated: 'RigUnit_MathFloatConstant' was renamed to 'RigVMFunction_MathFloatConstant'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatUnaryOp(RigVMFunction_MathFloatBase):
    r"""
    Rig VMFunction Math Float Unary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathFloatUnaryOp(RigVMFunction_MathFloatUnaryOp):
    r"""
    deprecated: 'RigUnit_MathFloatUnaryOp' was renamed to 'RigVMFunction_MathFloatUnaryOp'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatBinaryOp(RigVMFunction_MathFloatBase):
    r"""
    Rig VMFunction Math Float Binary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathFloatBinaryOp(RigVMFunction_MathFloatBinaryOp):
    r"""
    deprecated: 'RigUnit_MathFloatBinaryOp' was renamed to 'RigVMFunction_MathFloatBinaryOp'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatBinaryAggregateOp(RigVMFunction_MathFloatBase):
    r"""
    Rig VMFunction Math Float Binary Aggregate Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathFloatBinaryAggregateOp(RigVMFunction_MathFloatBinaryAggregateOp):
    r"""
    deprecated: 'RigUnit_MathFloatBinaryAggregateOp' was renamed to 'RigVMFunction_MathFloatBinaryAggregateOp'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatMake(RigVMFunction_MathFloatBase):
    r"""
    A float constant
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class RigUnit_MathFloatMake(RigVMFunction_MathFloatMake):
    r"""
    deprecated: 'RigUnit_MathFloatMake' was renamed to 'RigVMFunction_MathFloatMake'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatConstPi(RigVMFunction_MathFloatConstant):
    r"""
    Returns PI
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatConstPi(RigVMFunction_MathFloatConstPi):
    r"""
    deprecated: 'RigUnit_MathFloatConstPi' was renamed to 'RigVMFunction_MathFloatConstPi'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatConstHalfPi(RigVMFunction_MathFloatConstant):
    r"""
    Returns PI * 0.5
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatConstHalfPi(RigVMFunction_MathFloatConstHalfPi):
    r"""
    deprecated: 'RigUnit_MathFloatConstHalfPi' was renamed to 'RigVMFunction_MathFloatConstHalfPi'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatConstTwoPi(RigVMFunction_MathFloatConstant):
    r"""
    Returns PI * 2.0
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatConstTwoPi(RigVMFunction_MathFloatConstTwoPi):
    r"""
    deprecated: 'RigUnit_MathFloatConstTwoPi' was renamed to 'RigVMFunction_MathFloatConstTwoPi'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatConstE(RigVMFunction_MathFloatConstant):
    r"""
    Returns E
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatConstE(RigVMFunction_MathFloatConstE):
    r"""
    deprecated: 'RigUnit_MathFloatConstE' was renamed to 'RigVMFunction_MathFloatConstE'.
    """
    def __init__(self, value: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatAdd(RigVMFunction_MathFloatBinaryAggregateOp):
    r"""
    Returns the sum of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatAdd(RigVMFunction_MathFloatAdd):
    r"""
    deprecated: 'RigUnit_MathFloatAdd' was renamed to 'RigVMFunction_MathFloatAdd'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatSub(RigVMFunction_MathFloatBinaryOp):
    r"""
    Returns the difference of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatSub(RigVMFunction_MathFloatSub):
    r"""
    deprecated: 'RigUnit_MathFloatSub' was renamed to 'RigVMFunction_MathFloatSub'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatMul(RigVMFunction_MathFloatBinaryAggregateOp):
    r"""
    Returns the product of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatMul(RigVMFunction_MathFloatMul):
    r"""
    deprecated: 'RigUnit_MathFloatMul' was renamed to 'RigVMFunction_MathFloatMul'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatDiv(RigVMFunction_MathFloatBinaryOp):
    r"""
    Returns the division of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatDiv(RigVMFunction_MathFloatDiv):
    r"""
    deprecated: 'RigUnit_MathFloatDiv' was renamed to 'RigVMFunction_MathFloatDiv'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatMod(RigVMFunction_MathFloatBinaryOp):
    r"""
    Returns the modulo of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatMod(RigVMFunction_MathFloatMod):
    r"""
    deprecated: 'RigUnit_MathFloatMod' was renamed to 'RigVMFunction_MathFloatMod'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatMin(RigVMFunction_MathFloatBinaryAggregateOp):
    r"""
    Returns the smaller of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatMin(RigVMFunction_MathFloatMin):
    r"""
    deprecated: 'RigUnit_MathFloatMin' was renamed to 'RigVMFunction_MathFloatMin'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatMax(RigVMFunction_MathFloatBinaryAggregateOp):
    r"""
    Returns the larger of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatMax(RigVMFunction_MathFloatMax):
    r"""
    deprecated: 'RigUnit_MathFloatMax' was renamed to 'RigVMFunction_MathFloatMax'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatPow(RigVMFunction_MathFloatBinaryOp):
    r"""
    Returns the value of A raised to the power of B.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatPow(RigVMFunction_MathFloatPow):
    r"""
    deprecated: 'RigUnit_MathFloatPow' was renamed to 'RigVMFunction_MathFloatPow'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatSqrt(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the square root of the given value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatSqrt(RigVMFunction_MathFloatSqrt):
    r"""
    deprecated: 'RigUnit_MathFloatSqrt' was renamed to 'RigVMFunction_MathFloatSqrt'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatNegate(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the negative value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatNegate(RigVMFunction_MathFloatNegate):
    r"""
    deprecated: 'RigUnit_MathFloatNegate' was renamed to 'RigVMFunction_MathFloatNegate'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatAbs(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the absolute (positive) value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatAbs(RigVMFunction_MathFloatAbs):
    r"""
    deprecated: 'RigUnit_MathFloatAbs' was renamed to 'RigVMFunction_MathFloatAbs'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatFloor(RigVMFunction_MathFloatBase):
    r"""
    Returns the closest lower full number (integer) of the value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``int`` (int32):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def int(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathFloatFloor(RigVMFunction_MathFloatFloor):
    r"""
    deprecated: 'RigUnit_MathFloatFloor' was renamed to 'RigVMFunction_MathFloatFloor'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...

class RigVMFunction_MathFloatCeil(RigVMFunction_MathFloatBase):
    r"""
    Returns the closest higher full number (integer) of the value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``int`` (int32):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def int(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathFloatCeil(RigVMFunction_MathFloatCeil):
    r"""
    deprecated: 'RigUnit_MathFloatCeil' was renamed to 'RigVMFunction_MathFloatCeil'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...

class RigVMFunction_MathFloatRound(RigVMFunction_MathFloatBase):
    r"""
    Returns the closest higher full number (integer) of the value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``int`` (int32):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def int(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathFloatRound(RigVMFunction_MathFloatRound):
    r"""
    deprecated: 'RigUnit_MathFloatRound' was renamed to 'RigVMFunction_MathFloatRound'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000, int: int = 0) -> None:
        ...

class RigVMFunction_MathFloatToInt(RigVMFunction_MathFloatBase):
    r"""
    Returns the float cast to an int (this uses floor)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (int32):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: int = 0) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathFloatToInt(RigVMFunction_MathFloatToInt):
    r"""
    deprecated: 'RigUnit_MathFloatToInt' was renamed to 'RigVMFunction_MathFloatToInt'.
    """
    def __init__(self, value: float = 0.000000, result: int = 0) -> None:
        ...

class RigVMFunction_MathFloatSign(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the sign of the value (+1 for >= 0.f, -1 for < 0.f)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatSign(RigVMFunction_MathFloatSign):
    r"""
    deprecated: 'RigUnit_MathFloatSign' was renamed to 'RigVMFunction_MathFloatSign'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatClamp(RigVMFunction_MathFloatBase):
    r"""
    Clamps the given value within the range provided by minimum and maximum
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``maximum`` (float):  [Read-Write]
    - ``minimum`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, minimum: float = 0.000000, maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum.setter
    def minimum(self, value: float) -> None:
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum.setter
    def maximum(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathFloatClamp(RigVMFunction_MathFloatClamp):
    r"""
    deprecated: 'RigUnit_MathFloatClamp' was renamed to 'RigVMFunction_MathFloatClamp'.
    """
    def __init__(self, value: float = 0.000000, minimum: float = 0.000000, maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatLerp(RigVMFunction_MathFloatBase):
    r"""
    Linearly interpolates between A and B using the ratio T
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``t`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, t: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def t(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @t.setter
    def t(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathFloatLerp(RigVMFunction_MathFloatLerp):
    r"""
    deprecated: 'RigUnit_MathFloatLerp' was renamed to 'RigVMFunction_MathFloatLerp'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, t: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatRemap(RigVMFunction_MathFloatBase):
    r"""
    Remaps the given value from a source range to a target range.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clamp`` (bool):  [Read-Write] If set to true the result is clamped to the target range
    - ``result`` (float):  [Read-Write]
    - ``source_maximum`` (float):  [Read-Write]
    - ``source_minimum`` (float):  [Read-Write]
    - ``target_maximum`` (float):  [Read-Write]
    - ``target_minimum`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, source_minimum: float = 0.000000, source_maximum: float = 0.000000, target_minimum: float = 0.000000, target_maximum: float = 0.000000, clamp: bool = False, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def source_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @source_minimum.setter
    def source_minimum(self, value: float) -> None:
        ...
    @property
    def source_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @source_maximum.setter
    def source_maximum(self, value: float) -> None:
        ...
    @property
    def target_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @target_minimum.setter
    def target_minimum(self, value: float) -> None:
        ...
    @property
    def target_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @target_maximum.setter
    def target_maximum(self, value: float) -> None:
        ...
    @property
    def clamp(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the result is clamped to the target range
        """
        ...
    @clamp.setter
    def clamp(self, value: bool) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathFloatRemap(RigVMFunction_MathFloatRemap):
    r"""
    deprecated: 'RigUnit_MathFloatRemap' was renamed to 'RigVMFunction_MathFloatRemap'.
    """
    def __init__(self, value: float = 0.000000, source_minimum: float = 0.000000, source_maximum: float = 0.000000, target_minimum: float = 0.000000, target_maximum: float = 0.000000, clamp: bool = False, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatEquals(RigVMFunction_MathFloatBase):
    r"""
    Returns true if the value A equals B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathFloatEquals(RigVMFunction_MathFloatEquals):
    r"""
    deprecated: 'RigUnit_MathFloatEquals' was renamed to 'RigVMFunction_MathFloatEquals'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathFloatNotEquals(RigVMFunction_MathFloatBase):
    r"""
    Returns true if the value A does not equal B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathFloatNotEquals(RigVMFunction_MathFloatNotEquals):
    r"""
    deprecated: 'RigUnit_MathFloatNotEquals' was renamed to 'RigVMFunction_MathFloatNotEquals'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathFloatGreater(RigVMFunction_MathFloatBase):
    r"""
    Returns true if the value A is greater than B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathFloatGreater(RigVMFunction_MathFloatGreater):
    r"""
    deprecated: 'RigUnit_MathFloatGreater' was renamed to 'RigVMFunction_MathFloatGreater'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathFloatLess(RigVMFunction_MathFloatBase):
    r"""
    Returns true if the value A is less than B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathFloatLess(RigVMFunction_MathFloatLess):
    r"""
    deprecated: 'RigUnit_MathFloatLess' was renamed to 'RigVMFunction_MathFloatLess'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathFloatGreaterEqual(RigVMFunction_MathFloatBase):
    r"""
    Returns true if the value A is greater than or equal to B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathFloatGreaterEqual(RigVMFunction_MathFloatGreaterEqual):
    r"""
    deprecated: 'RigUnit_MathFloatGreaterEqual' was renamed to 'RigVMFunction_MathFloatGreaterEqual'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathFloatLessEqual(RigVMFunction_MathFloatBase):
    r"""
    Returns true if the value A is less than or equal to B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathFloatLessEqual(RigVMFunction_MathFloatLessEqual):
    r"""
    deprecated: 'RigUnit_MathFloatLessEqual' was renamed to 'RigVMFunction_MathFloatLessEqual'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathFloatIsNearlyZero(RigVMFunction_MathFloatBase):
    r"""
    Returns true if the value is nearly zero
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (bool):  [Read-Write]
    - ``tolerance`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, tolerance: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def tolerance(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @tolerance.setter
    def tolerance(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathFloatIsNearlyZero(RigVMFunction_MathFloatIsNearlyZero):
    r"""
    deprecated: 'RigUnit_MathFloatIsNearlyZero' was renamed to 'RigVMFunction_MathFloatIsNearlyZero'.
    """
    def __init__(self, value: float = 0.000000, tolerance: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathFloatIsNearlyEqual(RigVMFunction_MathFloatBase):
    r"""
    Returns true if the value A is almost equal to B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    - ``tolerance`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, tolerance: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def tolerance(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @tolerance.setter
    def tolerance(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathFloatIsNearlyEqual(RigVMFunction_MathFloatIsNearlyEqual):
    r"""
    deprecated: 'RigUnit_MathFloatIsNearlyEqual' was renamed to 'RigVMFunction_MathFloatIsNearlyEqual'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, tolerance: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathFloatSelectBool(RigVMFunction_MathFloatBase):
    r"""
    Return one of the two values based on the condition
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``condition`` (bool):  [Read-Write]
    - ``if_false`` (float):  [Read-Write]
    - ``if_true`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, condition: bool = False, if_true: float = 0.000000, if_false: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def condition(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @condition.setter
    def condition(self, value: bool) -> None:
        ...
    @property
    def if_true(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @if_true.setter
    def if_true(self, value: float) -> None:
        ...
    @property
    def if_false(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @if_false.setter
    def if_false(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathFloatSelectBool(RigVMFunction_MathFloatSelectBool):
    r"""
    deprecated: 'RigUnit_MathFloatSelectBool' was renamed to 'RigVMFunction_MathFloatSelectBool'.
    """
    def __init__(self, condition: bool = False, if_true: float = 0.000000, if_false: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatDeg(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the degrees of a given value in radians
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatDeg(RigVMFunction_MathFloatDeg):
    r"""
    deprecated: 'RigUnit_MathFloatDeg' was renamed to 'RigVMFunction_MathFloatDeg'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatRad(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the radians of a given value in degrees
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatRad(RigVMFunction_MathFloatRad):
    r"""
    deprecated: 'RigUnit_MathFloatRad' was renamed to 'RigVMFunction_MathFloatRad'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatSin(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the sinus value of the given value (in radians)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatSin(RigVMFunction_MathFloatSin):
    r"""
    deprecated: 'RigUnit_MathFloatSin' was renamed to 'RigVMFunction_MathFloatSin'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatCos(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the cosinus value of the given value (in radians)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatCos(RigVMFunction_MathFloatCos):
    r"""
    deprecated: 'RigUnit_MathFloatCos' was renamed to 'RigVMFunction_MathFloatCos'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatTan(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the tangens value of the given value (in radians)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatTan(RigVMFunction_MathFloatTan):
    r"""
    deprecated: 'RigUnit_MathFloatTan' was renamed to 'RigVMFunction_MathFloatTan'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatAsin(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the inverse sinus value (in radians) of the given value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatAsin(RigVMFunction_MathFloatAsin):
    r"""
    deprecated: 'RigUnit_MathFloatAsin' was renamed to 'RigVMFunction_MathFloatAsin'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatAcos(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the inverse cosinus value (in radians) of the given value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatAcos(RigVMFunction_MathFloatAcos):
    r"""
    deprecated: 'RigUnit_MathFloatAcos' was renamed to 'RigVMFunction_MathFloatAcos'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatAtan(RigVMFunction_MathFloatUnaryOp):
    r"""
    Returns the inverse tangens value (in radians) of the given value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatAtan(RigVMFunction_MathFloatAtan):
    r"""
    deprecated: 'RigUnit_MathFloatAtan' was renamed to 'RigVMFunction_MathFloatAtan'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatAtan2(RigVMFunction_MathFloatBinaryOp):
    r"""
    Returns the arctangent of the specified A and B coordinates.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatLawOfCosine(RigVMFunction_MathFloatBase):
    r"""
    Computes the angles alpha, beta and gamma (in radians) between the three sides A, B and C
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (float):  [Read-Write]
    - ``alpha_angle`` (float):  [Read-Write]
    - ``b`` (float):  [Read-Write]
    - ``beta_angle`` (float):  [Read-Write]
    - ``c`` (float):  [Read-Write]
    - ``gamma_angle`` (float):  [Read-Write]
    - ``valid`` (bool):  [Read-Write]
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, c: float = 0.000000, alpha_angle: float = 0.000000, beta_angle: float = 0.000000, gamma_angle: float = 0.000000, valid: bool = False) -> None:
        ...
    @property
    def a(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: float) -> None:
        ...
    @property
    def b(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: float) -> None:
        ...
    @property
    def c(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @c.setter
    def c(self, value: float) -> None:
        ...
    @property
    def alpha_angle(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def beta_angle(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def gamma_angle(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def valid(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathFloatLawOfCosine(RigVMFunction_MathFloatLawOfCosine):
    r"""
    deprecated: 'RigUnit_MathFloatLawOfCosine' was renamed to 'RigVMFunction_MathFloatLawOfCosine'.
    """
    def __init__(self, a: float = 0.000000, b: float = 0.000000, c: float = 0.000000, alpha_angle: float = 0.000000, beta_angle: float = 0.000000, gamma_angle: float = 0.000000, valid: bool = False) -> None:
        ...

class RigVMFunction_MathFloatExponential(RigVMFunction_MathFloatUnaryOp):
    r"""
    Computes the base-e exponential of the given value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_MathFloatExponential(RigVMFunction_MathFloatExponential):
    r"""
    deprecated: 'RigUnit_MathFloatExponential' was renamed to 'RigVMFunction_MathFloatExponential'.
    """
    def __init__(self, value: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathFloatArraySum(RigVMFunction_MathFloatBase):
    r"""
    Returns the sum of the given array
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``array`` (Array[float]):  [Read-Write]
    - ``sum`` (float):  [Read-Write]
    """
    def __init__(self, array: Array[float] = [], sum: float = 0.000000) -> None:
        ...
    @property
    def array(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Write]
        """
        ...
    @array.setter
    def array(self, value: Array[float]) -> None:
        ...
    @property
    def sum(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigVMFunction_MathFloatArrayAverage(RigVMFunction_MathFloatBase):
    r"""
    Returns the average of the given array
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``array`` (Array[float]):  [Read-Write]
    - ``average`` (float):  [Read-Write]
    """
    def __init__(self, array: Array[float] = [], average: float = 0.000000) -> None:
        ...
    @property
    def array(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Write]
        """
        ...
    @array.setter
    def array(self, value: Array[float]) -> None:
        ...
    @property
    def average(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigVMFunction_MathIntBase(RigVMFunction_MathBase):
    r"""
    Rig VMFunction Math Int Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_MathIntBase(RigVMFunction_MathIntBase):
    r"""
    deprecated: 'RigUnit_MathIntBase' was renamed to 'RigVMFunction_MathIntBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathIntUnaryOp(RigVMFunction_MathIntBase):
    r"""
    Rig VMFunction Math Int Unary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (int32):  [Read-Write]
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0, result: int = 0) -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: int) -> None:
        ...
    @property
    def result(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathIntUnaryOp(RigVMFunction_MathIntUnaryOp):
    r"""
    deprecated: 'RigUnit_MathIntUnaryOp' was renamed to 'RigVMFunction_MathIntUnaryOp'.
    """
    def __init__(self, value: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntBinaryOp(RigVMFunction_MathIntBase):
    r"""
    Rig VMFunction Math Int Binary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (int32):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...
    @property
    def a(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: int) -> None:
        ...
    @property
    def b(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: int) -> None:
        ...
    @property
    def result(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathIntBinaryOp(RigVMFunction_MathIntBinaryOp):
    r"""
    deprecated: 'RigUnit_MathIntBinaryOp' was renamed to 'RigVMFunction_MathIntBinaryOp'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntBinaryAggregateOp(RigVMFunction_MathIntBase):
    r"""
    Rig VMFunction Math Int Binary Aggregate Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (int32):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...
    @property
    def a(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: int) -> None:
        ...
    @property
    def b(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: int) -> None:
        ...
    @property
    def result(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathIntBinaryAggregateOp(RigVMFunction_MathIntBinaryAggregateOp):
    r"""
    deprecated: 'RigUnit_MathIntBinaryAggregateOp' was renamed to 'RigVMFunction_MathIntBinaryAggregateOp'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntMake(RigVMFunction_MathIntBase):
    r"""
    A integer constant
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0) -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: int) -> None:
        ...

class RigUnit_MathIntMake(RigVMFunction_MathIntMake):
    r"""
    deprecated: 'RigUnit_MathIntMake' was renamed to 'RigVMFunction_MathIntMake'.
    """
    def __init__(self, value: int = 0) -> None:
        ...

class RigVMFunction_MathIntAdd(RigVMFunction_MathIntBinaryAggregateOp):
    r"""
    Returns the sum of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (int32):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigUnit_MathIntAdd(RigVMFunction_MathIntAdd):
    r"""
    deprecated: 'RigUnit_MathIntAdd' was renamed to 'RigVMFunction_MathIntAdd'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntSub(RigVMFunction_MathIntBinaryOp):
    r"""
    Returns the difference of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (int32):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigUnit_MathIntSub(RigVMFunction_MathIntSub):
    r"""
    deprecated: 'RigUnit_MathIntSub' was renamed to 'RigVMFunction_MathIntSub'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntMul(RigVMFunction_MathIntBinaryAggregateOp):
    r"""
    Returns the product of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (int32):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigUnit_MathIntMul(RigVMFunction_MathIntMul):
    r"""
    deprecated: 'RigUnit_MathIntMul' was renamed to 'RigVMFunction_MathIntMul'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntDiv(RigVMFunction_MathIntBinaryOp):
    r"""
    Returns the division of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (int32):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigUnit_MathIntDiv(RigVMFunction_MathIntDiv):
    r"""
    deprecated: 'RigUnit_MathIntDiv' was renamed to 'RigVMFunction_MathIntDiv'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntMod(RigVMFunction_MathIntBinaryOp):
    r"""
    Returns the modulo of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (int32):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigUnit_MathIntMod(RigVMFunction_MathIntMod):
    r"""
    deprecated: 'RigUnit_MathIntMod' was renamed to 'RigVMFunction_MathIntMod'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntMin(RigVMFunction_MathIntBinaryAggregateOp):
    r"""
    Returns the smaller of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (int32):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigUnit_MathIntMin(RigVMFunction_MathIntMin):
    r"""
    deprecated: 'RigUnit_MathIntMin' was renamed to 'RigVMFunction_MathIntMin'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntMax(RigVMFunction_MathIntBinaryAggregateOp):
    r"""
    Returns the larger of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (int32):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigUnit_MathIntMax(RigVMFunction_MathIntMax):
    r"""
    deprecated: 'RigUnit_MathIntMax' was renamed to 'RigVMFunction_MathIntMax'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntPow(RigVMFunction_MathIntBinaryOp):
    r"""
    Returns the value of A raised to the power of B.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (int32):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigUnit_MathIntPow(RigVMFunction_MathIntPow):
    r"""
    deprecated: 'RigUnit_MathIntPow' was renamed to 'RigVMFunction_MathIntPow'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntNegate(RigVMFunction_MathIntUnaryOp):
    r"""
    Returns the negative value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (int32):  [Read-Write]
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0, result: int = 0) -> None:
        ...

class RigUnit_MathIntNegate(RigVMFunction_MathIntNegate):
    r"""
    deprecated: 'RigUnit_MathIntNegate' was renamed to 'RigVMFunction_MathIntNegate'.
    """
    def __init__(self, value: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntAbs(RigVMFunction_MathIntUnaryOp):
    r"""
    Returns the absolute (positive) value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (int32):  [Read-Write]
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0, result: int = 0) -> None:
        ...

class RigUnit_MathIntAbs(RigVMFunction_MathIntAbs):
    r"""
    deprecated: 'RigUnit_MathIntAbs' was renamed to 'RigVMFunction_MathIntAbs'.
    """
    def __init__(self, value: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntToFloat(RigVMFunction_MathIntBase):
    r"""
    Returns the int cast to a float
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: int) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathIntToFloat(RigVMFunction_MathIntToFloat):
    r"""
    deprecated: 'RigUnit_MathIntToFloat' was renamed to 'RigVMFunction_MathIntToFloat'.
    """
    def __init__(self, value: int = 0, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathIntToDouble(RigVMFunction_MathIntBase):
    r"""
    Returns the int cast to a float
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (double):  [Read-Write]
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: int) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...

class RigUnit_MathIntToDouble(RigVMFunction_MathIntToDouble):
    r"""
    deprecated: 'RigUnit_MathIntToDouble' was renamed to 'RigVMFunction_MathIntToDouble'.
    """
    def __init__(self, value: int = 0, result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathIntSign(RigVMFunction_MathIntUnaryOp):
    r"""
    Returns the sign of the value (+1 for >= 0, -1 for < 0)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (int32):  [Read-Write]
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0, result: int = 0) -> None:
        ...

class RigUnit_MathIntSign(RigVMFunction_MathIntSign):
    r"""
    deprecated: 'RigUnit_MathIntSign' was renamed to 'RigVMFunction_MathIntSign'.
    """
    def __init__(self, value: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntClamp(RigVMFunction_MathIntBase):
    r"""
    Clamps the given value within the range provided by minimum and maximum
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``maximum`` (int32):  [Read-Write]
    - ``minimum`` (int32):  [Read-Write]
    - ``result`` (int32):  [Read-Write]
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0, minimum: int = 0, maximum: int = 0, result: int = 0) -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: int) -> None:
        ...
    @property
    def minimum(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @minimum.setter
    def minimum(self, value: int) -> None:
        ...
    @property
    def maximum(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @maximum.setter
    def maximum(self, value: int) -> None:
        ...
    @property
    def result(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_MathIntClamp(RigVMFunction_MathIntClamp):
    r"""
    deprecated: 'RigUnit_MathIntClamp' was renamed to 'RigVMFunction_MathIntClamp'.
    """
    def __init__(self, value: int = 0, minimum: int = 0, maximum: int = 0, result: int = 0) -> None:
        ...

class RigVMFunction_MathIntEquals(RigVMFunction_MathIntBase):
    r"""
    Returns true if the value A equals B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...
    @property
    def a(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: int) -> None:
        ...
    @property
    def b(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: int) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathIntEquals(RigVMFunction_MathIntEquals):
    r"""
    deprecated: 'RigUnit_MathIntEquals' was renamed to 'RigVMFunction_MathIntEquals'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...

class RigVMFunction_MathIntNotEquals(RigVMFunction_MathIntBase):
    r"""
    Returns true if the value A does not equal B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...
    @property
    def a(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: int) -> None:
        ...
    @property
    def b(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: int) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathIntNotEquals(RigVMFunction_MathIntNotEquals):
    r"""
    deprecated: 'RigUnit_MathIntNotEquals' was renamed to 'RigVMFunction_MathIntNotEquals'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...

class RigVMFunction_MathIntGreater(RigVMFunction_MathIntBase):
    r"""
    Returns true if the value A is greater than B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...
    @property
    def a(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: int) -> None:
        ...
    @property
    def b(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: int) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathIntGreater(RigVMFunction_MathIntGreater):
    r"""
    deprecated: 'RigUnit_MathIntGreater' was renamed to 'RigVMFunction_MathIntGreater'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...

class RigVMFunction_MathIntLess(RigVMFunction_MathIntBase):
    r"""
    Returns true if the value A is less than B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...
    @property
    def a(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: int) -> None:
        ...
    @property
    def b(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: int) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathIntLess(RigVMFunction_MathIntLess):
    r"""
    deprecated: 'RigUnit_MathIntLess' was renamed to 'RigVMFunction_MathIntLess'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...

class RigVMFunction_MathIntGreaterEqual(RigVMFunction_MathIntBase):
    r"""
    Returns true if the value A is greater than or equal to B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...
    @property
    def a(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: int) -> None:
        ...
    @property
    def b(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: int) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathIntGreaterEqual(RigVMFunction_MathIntGreaterEqual):
    r"""
    deprecated: 'RigUnit_MathIntGreaterEqual' was renamed to 'RigVMFunction_MathIntGreaterEqual'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...

class RigVMFunction_MathIntLessEqual(RigVMFunction_MathIntBase):
    r"""
    Returns true if the value A is less than or equal to B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (int32):  [Read-Write]
    - ``b`` (int32):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...
    @property
    def a(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: int) -> None:
        ...
    @property
    def b(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: int) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathIntLessEqual(RigVMFunction_MathIntLessEqual):
    r"""
    deprecated: 'RigUnit_MathIntLessEqual' was renamed to 'RigVMFunction_MathIntLessEqual'.
    """
    def __init__(self, a: int = 0, b: int = 0, result: bool = False) -> None:
        ...

class RigVMFunction_MathIntArraySum(RigVMFunction_MathIntBase):
    r"""
    Returns the sum of the given array
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``array`` (Array[int32]):  [Read-Write]
    - ``sum`` (int32):  [Read-Write]
    """
    def __init__(self, array: Array[int] = [], sum: int = 0) -> None:
        ...
    @property
    def array(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write]
        """
        ...
    @array.setter
    def array(self, value: Array[int]) -> None:
        ...
    @property
    def sum(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigVMFunction_MathIntArrayAverage(RigVMFunction_MathIntBase):
    r"""
    Returns the average of the given array
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``array`` (Array[int32]):  [Read-Write]
    - ``average`` (int32):  [Read-Write]
    """
    def __init__(self, array: Array[int] = [], average: int = 0) -> None:
        ...
    @property
    def array(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write]
        """
        ...
    @array.setter
    def array(self, value: Array[int]) -> None:
        ...
    @property
    def average(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigVMFunction_MathIntToString(RigVMFunction_MathIntBase):
    r"""
    Converts an integer to a string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``number`` (int32):  [Read-Write]
    - ``padded_size`` (int32):  [Read-Write] * For positive numbers you can pad the result to a required with
      * so rather than '13' return '00013' for a padded size of 5.
    - ``result`` (str):  [Read-Write]
    """
    def __init__(self, number: int = 0, padded_size: int = 0, result: str = "") -> None:
        ...
    @property
    def number(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @number.setter
    def number(self, value: int) -> None:
        ...
    @property
    def padded_size(self) -> int:
        r"""
        (int32):  [Read-Write] * For positive numbers you can pad the result to a required with
        * so rather than '13' return '00013' for a padded size of 5.
        """
        ...
    @padded_size.setter
    def padded_size(self, value: int) -> None:
        ...
    @property
    def result(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigVMFunction_MathIntToName(RigVMFunction_MathIntBase):
    r"""
    Converts an integer to a name
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``number`` (int32):  [Read-Write]
    - ``padded_size`` (int32):  [Read-Write] * For positive numbers you can pad the result to a required with
      * so rather than '13' return '00013' for a padded size of 5.
    - ``result`` (Name):  [Read-Write]
    """
    def __init__(self, number: int = 0, padded_size: int = 0, result: Name = "None") -> None:
        ...
    @property
    def number(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @number.setter
    def number(self, value: int) -> None:
        ...
    @property
    def padded_size(self) -> int:
        r"""
        (int32):  [Read-Write] * For positive numbers you can pad the result to a required with
        * so rather than '13' return '00013' for a padded size of 5.
        """
        ...
    @padded_size.setter
    def padded_size(self, value: int) -> None:
        ...
    @property
    def result(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...

class RigVMFunction_MathMatrixBase(RigVMFunction_MathBase):
    r"""
    Rig VMFunction Math Matrix Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathMatrix.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_MathMatrixBase(RigVMFunction_MathMatrixBase):
    r"""
    deprecated: 'RigUnit_MathMatrixBase' was renamed to 'RigVMFunction_MathMatrixBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathMatrixUnaryOp(RigVMFunction_MathMatrixBase):
    r"""
    Rig VMFunction Math Matrix Unary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathMatrix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Matrix):  [Read-Write]
    - ``value`` (Matrix):  [Read-Write]
    """
    def __init__(self, value: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...
    @property
    def value(self) -> Matrix:
        r"""
        (Matrix):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Matrix) -> None:
        ...
    @property
    def result(self) -> Matrix:
        r"""
        (Matrix):  [Read-Only]
        """
        ...

class RigUnit_MathMatrixUnaryOp(RigVMFunction_MathMatrixUnaryOp):
    r"""
    deprecated: 'RigUnit_MathMatrixUnaryOp' was renamed to 'RigVMFunction_MathMatrixUnaryOp'.
    """
    def __init__(self, value: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...

class RigVMFunction_MathMatrixBinaryOp(RigVMFunction_MathMatrixBase):
    r"""
    Rig VMFunction Math Matrix Binary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathMatrix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Matrix):  [Read-Write]
    - ``b`` (Matrix):  [Read-Write]
    - ``result`` (Matrix):  [Read-Write]
    """
    def __init__(self, a: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], b: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...
    @property
    def a(self) -> Matrix:
        r"""
        (Matrix):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Matrix) -> None:
        ...
    @property
    def b(self) -> Matrix:
        r"""
        (Matrix):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Matrix) -> None:
        ...
    @property
    def result(self) -> Matrix:
        r"""
        (Matrix):  [Read-Only]
        """
        ...

class RigUnit_MathMatrixBinaryOp(RigVMFunction_MathMatrixBinaryOp):
    r"""
    deprecated: 'RigUnit_MathMatrixBinaryOp' was renamed to 'RigVMFunction_MathMatrixBinaryOp'.
    """
    def __init__(self, a: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], b: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...

class RigVMFunction_MathMatrixBinaryAggregateOp(RigVMFunction_MathMatrixBase):
    r"""
    Rig VMFunction Math Matrix Binary Aggregate Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathMatrix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Matrix):  [Read-Write]
    - ``b`` (Matrix):  [Read-Write]
    - ``result`` (Matrix):  [Read-Write]
    """
    def __init__(self, a: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], b: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...
    @property
    def a(self) -> Matrix:
        r"""
        (Matrix):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Matrix) -> None:
        ...
    @property
    def b(self) -> Matrix:
        r"""
        (Matrix):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Matrix) -> None:
        ...
    @property
    def result(self) -> Matrix:
        r"""
        (Matrix):  [Read-Only]
        """
        ...

class RigUnit_MathMatrixBinaryAggregateOp(RigVMFunction_MathMatrixBinaryAggregateOp):
    r"""
    deprecated: 'RigUnit_MathMatrixBinaryAggregateOp' was renamed to 'RigVMFunction_MathMatrixBinaryAggregateOp'.
    """
    def __init__(self, a: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], b: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...

class RigVMFunction_MathMatrixToTransform(RigVMFunction_MathMatrixBase):
    r"""
    Makes a transform from a matrix
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathMatrix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Transform):  [Read-Write]
    - ``value`` (Matrix):  [Read-Write]
    """
    def __init__(self, value: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Matrix:
        r"""
        (Matrix):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Matrix) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathMatrixToTransform(RigVMFunction_MathMatrixToTransform):
    r"""
    deprecated: 'RigUnit_MathMatrixToTransform' was renamed to 'RigVMFunction_MathMatrixToTransform'.
    """
    def __init__(self, value: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathMatrixFromTransform(RigVMFunction_MathMatrixBase):
    r"""
    Makes a matrix from a transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathMatrix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Matrix):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    """
    def __init__(self, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Matrix:
        r"""
        (Matrix):  [Read-Only]
        """
        ...

class RigUnit_MathMatrixFromTransform(RigVMFunction_MathMatrixFromTransform):
    r"""
    deprecated: 'RigUnit_MathMatrixFromTransform' was renamed to 'RigVMFunction_MathMatrixFromTransform'.
    """
    def __init__(self, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...

class RigVMFunction_MathMatrixFromTransformV2(RigVMFunction_MathMatrixBase):
    r"""
    Makes a matrix from a transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathMatrix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Matrix):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Matrix:
        r"""
        (Matrix):  [Read-Only]
        """
        ...

class RigUnit_MathMatrixFromTransformV2(RigVMFunction_MathMatrixFromTransformV2):
    r"""
    deprecated: 'RigUnit_MathMatrixFromTransformV2' was renamed to 'RigVMFunction_MathMatrixFromTransformV2'.
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...

class RigVMFunction_MathMatrixToVectors(RigVMFunction_MathMatrixBase):
    r"""
    Converts the matrix to its vectors
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathMatrix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``origin`` (Vector):  [Read-Write]
    - ``value`` (Matrix):  [Read-Write]
    - ``x`` (Vector):  [Read-Write]
    - ``y`` (Vector):  [Read-Write]
    - ``z`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], origin: Vector = [0.000000, 0.000000, 0.000000], x: Vector = [0.000000, 0.000000, 0.000000], y: Vector = [0.000000, 0.000000, 0.000000], z: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Matrix:
        r"""
        (Matrix):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Matrix) -> None:
        ...
    @property
    def origin(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def x(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def y(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def z(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathMatrixToVectors(RigVMFunction_MathMatrixToVectors):
    r"""
    deprecated: 'RigUnit_MathMatrixToVectors' was renamed to 'RigVMFunction_MathMatrixToVectors'.
    """
    def __init__(self, value: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], origin: Vector = [0.000000, 0.000000, 0.000000], x: Vector = [0.000000, 0.000000, 0.000000], y: Vector = [0.000000, 0.000000, 0.000000], z: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathMatrixFromVectors(RigVMFunction_MathMatrixBase):
    r"""
    Makes a matrix from its vectors
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathMatrix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``origin`` (Vector):  [Read-Write]
    - ``result`` (Matrix):  [Read-Write]
    - ``x`` (Vector):  [Read-Write]
    - ``y`` (Vector):  [Read-Write]
    - ``z`` (Vector):  [Read-Write]
    """
    def __init__(self, origin: Vector = [0.000000, 0.000000, 0.000000], x: Vector = [0.000000, 0.000000, 0.000000], y: Vector = [0.000000, 0.000000, 0.000000], z: Vector = [0.000000, 0.000000, 0.000000], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...
    @property
    def origin(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @origin.setter
    def origin(self, value: Vector) -> None:
        ...
    @property
    def x(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: Vector) -> None:
        ...
    @property
    def y(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: Vector) -> None:
        ...
    @property
    def z(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Matrix:
        r"""
        (Matrix):  [Read-Only]
        """
        ...

class RigUnit_MathMatrixFromVectors(RigVMFunction_MathMatrixFromVectors):
    r"""
    deprecated: 'RigUnit_MathMatrixFromVectors' was renamed to 'RigVMFunction_MathMatrixFromVectors'.
    """
    def __init__(self, origin: Vector = [0.000000, 0.000000, 0.000000], x: Vector = [0.000000, 0.000000, 0.000000], y: Vector = [0.000000, 0.000000, 0.000000], z: Vector = [0.000000, 0.000000, 0.000000], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...

class RigVMFunction_MathMatrixMul(RigVMFunction_MathMatrixBinaryAggregateOp):
    r"""
    Returns the product of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathMatrix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Matrix):  [Read-Write]
    - ``b`` (Matrix):  [Read-Write]
    - ``result`` (Matrix):  [Read-Write]
    """
    def __init__(self, a: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], b: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...

class RigUnit_MathMatrixMul(RigVMFunction_MathMatrixMul):
    r"""
    deprecated: 'RigUnit_MathMatrixMul' was renamed to 'RigVMFunction_MathMatrixMul'.
    """
    def __init__(self, a: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], b: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...

class RigVMFunction_MathMatrixInverse(RigVMFunction_MathMatrixUnaryOp):
    r"""
    Returns the inverse value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathMatrix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Matrix):  [Read-Write]
    - ``value`` (Matrix):  [Read-Write]
    """
    def __init__(self, value: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...

class RigUnit_MathMatrixInverse(RigVMFunction_MathMatrixInverse):
    r"""
    deprecated: 'RigUnit_MathMatrixInverse' was renamed to 'RigVMFunction_MathMatrixInverse'.
    """
    def __init__(self, value: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]], result: Matrix = [[0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000]]) -> None:
        ...

class RigVMFunction_MathQuaternionBase(RigVMFunction_MathBase):
    r"""
    Rig VMFunction Math Quaternion Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_MathQuaternionBase(RigVMFunction_MathQuaternionBase):
    r"""
    deprecated: 'RigUnit_MathQuaternionBase' was renamed to 'RigVMFunction_MathQuaternionBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathQuaternionUnaryOp(RigVMFunction_MathQuaternionBase):
    r"""
    Rig VMFunction Math Quaternion Unary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Quat):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionUnaryOp(RigVMFunction_MathQuaternionUnaryOp):
    r"""
    deprecated: 'RigUnit_MathQuaternionUnaryOp' was renamed to 'RigVMFunction_MathQuaternionUnaryOp'.
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionBinaryOp(RigVMFunction_MathQuaternionBase):
    r"""
    Rig VMFunction Math Quaternion Binary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Quat):  [Read-Write]
    - ``b`` (Quat):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def a(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Quat) -> None:
        ...
    @property
    def b(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionBinaryOp(RigVMFunction_MathQuaternionBinaryOp):
    r"""
    deprecated: 'RigUnit_MathQuaternionBinaryOp' was renamed to 'RigVMFunction_MathQuaternionBinaryOp'.
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionBinaryAggregateOp(RigVMFunction_MathQuaternionBase):
    r"""
    Rig VMFunction Math Quaternion Binary Aggregate Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Quat):  [Read-Write]
    - ``b`` (Quat):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def a(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Quat) -> None:
        ...
    @property
    def b(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionBinaryAggregateOp(RigVMFunction_MathQuaternionBinaryAggregateOp):
    r"""
    deprecated: 'RigUnit_MathQuaternionBinaryAggregateOp' was renamed to 'RigVMFunction_MathQuaternionBinaryAggregateOp'.
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionMake(RigVMFunction_MathQuaternionBase):
    r"""
    Makes a quaternion from its components
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Quat):  [Read-Write]
    - ``w`` (float):  [Read-Write]
    - ``x`` (float):  [Read-Write]
    - ``y`` (float):  [Read-Write]
    - ``z`` (float):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000, w: float = 0.000000, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def x(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: float) -> None:
        ...
    @property
    def y(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: float) -> None:
        ...
    @property
    def z(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: float) -> None:
        ...
    @property
    def w(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @w.setter
    def w(self, value: float) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionMake(RigVMFunction_MathQuaternionMake):
    r"""
    deprecated: 'RigUnit_MathQuaternionMake' was renamed to 'RigVMFunction_MathQuaternionMake'.
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000, w: float = 0.000000, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionFromAxisAndAngle(RigVMFunction_MathQuaternionBase):
    r"""
    Makes a quaternion from an axis and an angle in radians
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angle`` (float):  [Read-Write]
    - ``axis`` (Vector):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, axis: Vector = [0.000000, 0.000000, 0.000000], angle: float = 0.000000, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @axis.setter
    def axis(self, value: Vector) -> None:
        ...
    @property
    def angle(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @angle.setter
    def angle(self, value: float) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionFromAxisAndAngle(RigVMFunction_MathQuaternionFromAxisAndAngle):
    r"""
    deprecated: 'RigUnit_MathQuaternionFromAxisAndAngle' was renamed to 'RigVMFunction_MathQuaternionFromAxisAndAngle'.
    """
    def __init__(self, axis: Vector = [0.000000, 0.000000, 0.000000], angle: float = 0.000000, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionFromEuler(RigVMFunction_MathQuaternionBase):
    r"""
    Makes a quaternion from euler values in degrees
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``euler`` (Vector):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    - ``rotation_order`` (EulerRotationOrder):  [Read-Write]
    """
    def __init__(self, euler: Vector = [0.000000, 0.000000, 0.000000], rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def euler(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @euler.setter
    def euler(self, value: Vector) -> None:
        ...
    @property
    def rotation_order(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Write]
        """
        ...
    @rotation_order.setter
    def rotation_order(self, value: EulerRotationOrder) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionFromEuler(RigVMFunction_MathQuaternionFromEuler):
    r"""
    deprecated: 'RigUnit_MathQuaternionFromEuler' was renamed to 'RigVMFunction_MathQuaternionFromEuler'.
    """
    def __init__(self, euler: Vector = [0.000000, 0.000000, 0.000000], rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionFromRotator(RigVMFunction_MathQuaternionBase):
    r"""
    Makes a quaternion from a rotator
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Quat):  [Read-Write]
    - ``rotator`` (Rotator):  [Read-Write]
    """
    def __init__(self, rotator: Rotator = [0.000000, 0.000000, 0.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def rotator(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @rotator.setter
    def rotator(self, value: Rotator) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionFromRotator(RigVMFunction_MathQuaternionFromRotator):
    r"""
    deprecated: 'RigUnit_MathQuaternionFromRotator' was renamed to 'RigVMFunction_MathQuaternionFromRotator'.
    """
    def __init__(self, rotator: Rotator = [0.000000, 0.000000, 0.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionFromRotatorV2(RigVMFunction_MathQuaternionBase):
    r"""
    Makes a quaternion from a rotator
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Quat):  [Read-Write]
    - ``value`` (Rotator):  [Read-Write]
    """
    def __init__(self, value: Rotator = [0.000000, 0.000000, 0.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def value(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Rotator) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionFromRotatorV2(RigVMFunction_MathQuaternionFromRotatorV2):
    r"""
    deprecated: 'RigUnit_MathQuaternionFromRotatorV2' was renamed to 'RigVMFunction_MathQuaternionFromRotatorV2'.
    """
    def __init__(self, value: Rotator = [0.000000, 0.000000, 0.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionFromTwoVectors(RigVMFunction_MathQuaternionBase):
    r"""
    Makes a quaternion from two vectors, representing the shortest rotation between the two vectors.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionFromTwoVectors(RigVMFunction_MathQuaternionFromTwoVectors):
    r"""
    deprecated: 'RigUnit_MathQuaternionFromTwoVectors' was renamed to 'RigVMFunction_MathQuaternionFromTwoVectors'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionToAxisAndAngle(RigVMFunction_MathQuaternionBase):
    r"""
    Retrieves the axis and angle of a quaternion in radians
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angle`` (float):  [Read-Write]
    - ``axis`` (Vector):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], axis: Vector = [0.000000, 0.000000, 0.000000], angle: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def axis(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def angle(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionToAxisAndAngle(RigVMFunction_MathQuaternionToAxisAndAngle):
    r"""
    deprecated: 'RigUnit_MathQuaternionToAxisAndAngle' was renamed to 'RigVMFunction_MathQuaternionToAxisAndAngle'.
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], axis: Vector = [0.000000, 0.000000, 0.000000], angle: float = 0.000000) -> None:
        ...

class RigVMFunction_MathQuaternionToVectors(RigVMFunction_MathQuaternionBase):
    r"""
    Retrieves the forward, right and up vectors of a quaternion
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``forward`` (Vector):  [Read-Write]
    - ``right`` (Vector):  [Read-Write]
    - ``up`` (Vector):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], forward: Vector = [0.000000, 0.000000, 0.000000], right: Vector = [0.000000, 0.000000, 0.000000], up: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def forward(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def right(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def up(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigVMFunction_MathQuaternionScale(RigVMFunction_MathQuaternionBase):
    r"""
    Scales a quaternion's angle
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``scale`` (float):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], scale: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...

class RigUnit_MathQuaternionScale(RigVMFunction_MathQuaternionScale):
    r"""
    deprecated: 'RigUnit_MathQuaternionScale' was renamed to 'RigVMFunction_MathQuaternionScale'.
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], scale: float = 0.000000) -> None:
        ...

class RigVMFunction_MathQuaternionScaleV2(RigVMFunction_MathQuaternionBase):
    r"""
    Scales a quaternion's angle
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``factor`` (float):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], factor: float = 0.000000, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def factor(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @factor.setter
    def factor(self, value: float) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionScaleV2(RigVMFunction_MathQuaternionScaleV2):
    r"""
    deprecated: 'RigUnit_MathQuaternionScaleV2' was renamed to 'RigVMFunction_MathQuaternionScaleV2'.
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], factor: float = 0.000000, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionToEuler(RigVMFunction_MathQuaternionBase):
    r"""
    Retrieves the euler angles in degrees
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``rotation_order`` (EulerRotationOrder):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def rotation_order(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Write]
        """
        ...
    @rotation_order.setter
    def rotation_order(self, value: EulerRotationOrder) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionToEuler(RigVMFunction_MathQuaternionToEuler):
    r"""
    deprecated: 'RigUnit_MathQuaternionToEuler' was renamed to 'RigVMFunction_MathQuaternionToEuler'.
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionToRotator(RigVMFunction_MathQuaternionBase):
    r"""
    Retrieves the rotator
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Rotator):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionToRotator(RigVMFunction_MathQuaternionToRotator):
    r"""
    deprecated: 'RigUnit_MathQuaternionToRotator' was renamed to 'RigVMFunction_MathQuaternionToRotator'.
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionMul(RigVMFunction_MathQuaternionBinaryAggregateOp):
    r"""
    Returns the product of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Quat):  [Read-Write]
    - ``b`` (Quat):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigUnit_MathQuaternionMul(RigVMFunction_MathQuaternionMul):
    r"""
    deprecated: 'RigUnit_MathQuaternionMul' was renamed to 'RigVMFunction_MathQuaternionMul'.
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionInverse(RigVMFunction_MathQuaternionUnaryOp):
    r"""
    Returns the negative value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Quat):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigUnit_MathQuaternionInverse(RigVMFunction_MathQuaternionInverse):
    r"""
    deprecated: 'RigUnit_MathQuaternionInverse' was renamed to 'RigVMFunction_MathQuaternionInverse'.
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionSlerp(RigVMFunction_MathQuaternionBase):
    r"""
    Linearly interpolates between A and B using the ratio T
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Quat):  [Read-Write]
    - ``b`` (Quat):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    - ``t`` (float):  [Read-Write]
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], t: float = 0.000000, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def a(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Quat) -> None:
        ...
    @property
    def b(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Quat) -> None:
        ...
    @property
    def t(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @t.setter
    def t(self, value: float) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionSlerp(RigVMFunction_MathQuaternionSlerp):
    r"""
    deprecated: 'RigUnit_MathQuaternionSlerp' was renamed to 'RigVMFunction_MathQuaternionSlerp'.
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], t: float = 0.000000, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionEquals(RigVMFunction_MathQuaternionBase):
    r"""
    Returns true if the value A equals B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Quat):  [Read-Write]
    - ``b`` (Quat):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: bool = False) -> None:
        ...
    @property
    def a(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Quat) -> None:
        ...
    @property
    def b(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionEquals(RigVMFunction_MathQuaternionEquals):
    r"""
    deprecated: 'RigUnit_MathQuaternionEquals' was renamed to 'RigVMFunction_MathQuaternionEquals'.
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: bool = False) -> None:
        ...

class RigVMFunction_MathQuaternionNotEquals(RigVMFunction_MathQuaternionBase):
    r"""
    Returns true if the value A does not equal B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Quat):  [Read-Write]
    - ``b`` (Quat):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: bool = False) -> None:
        ...
    @property
    def a(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Quat) -> None:
        ...
    @property
    def b(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionNotEquals(RigVMFunction_MathQuaternionNotEquals):
    r"""
    deprecated: 'RigUnit_MathQuaternionNotEquals' was renamed to 'RigVMFunction_MathQuaternionNotEquals'.
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: bool = False) -> None:
        ...

class RigVMFunction_MathQuaternionSelectBool(RigVMFunction_MathQuaternionBase):
    r"""
    Return one of the two values based on the condition
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``condition`` (bool):  [Read-Write]
    - ``if_false`` (Quat):  [Read-Write]
    - ``if_true`` (Quat):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, condition: bool = False, if_true: Quat = [0.000000, 0.000000, 0.000000, 1.000000], if_false: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def condition(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @condition.setter
    def condition(self, value: bool) -> None:
        ...
    @property
    def if_true(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @if_true.setter
    def if_true(self, value: Quat) -> None:
        ...
    @property
    def if_false(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @if_false.setter
    def if_false(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionSelectBool(RigVMFunction_MathQuaternionSelectBool):
    r"""
    deprecated: 'RigUnit_MathQuaternionSelectBool' was renamed to 'RigVMFunction_MathQuaternionSelectBool'.
    """
    def __init__(self, condition: bool = False, if_true: Quat = [0.000000, 0.000000, 0.000000, 1.000000], if_false: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionDot(RigVMFunction_MathQuaternionBase):
    r"""
    Returns the dot product between two quaternions
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Quat):  [Read-Write]
    - ``b`` (Quat):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: float = 0.000000) -> None:
        ...
    @property
    def a(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Quat) -> None:
        ...
    @property
    def b(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionDot(RigVMFunction_MathQuaternionDot):
    r"""
    deprecated: 'RigUnit_MathQuaternionDot' was renamed to 'RigVMFunction_MathQuaternionDot'.
    """
    def __init__(self, a: Quat = [0.000000, 0.000000, 0.000000, 1.000000], b: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathQuaternionUnit(RigVMFunction_MathQuaternionUnaryOp):
    r"""
    Returns the normalized quaternion
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Quat):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigUnit_MathQuaternionUnit(RigVMFunction_MathQuaternionUnit):
    r"""
    deprecated: 'RigUnit_MathQuaternionUnit' was renamed to 'RigVMFunction_MathQuaternionUnit'.
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionRotateVector(RigVMFunction_MathQuaternionBase):
    r"""
    Rotates a given vector by the quaternion
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``transform`` (Quat):  [Read-Write]
    - ``vector`` (Vector):  [Read-Write]
    """
    def __init__(self, transform: Quat = [0.000000, 0.000000, 0.000000, 1.000000], vector: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def transform(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Quat) -> None:
        ...
    @property
    def quaternion(self) -> Quat:
        r"""
        deprecated: 'quaternion' was renamed to 'transform'.
        """
        ...
    @quaternion.setter
    def quaternion(self, value: Quat) -> None:
        ...
    @property
    def vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @vector.setter
    def vector(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionRotateVector(RigVMFunction_MathQuaternionRotateVector):
    r"""
    deprecated: 'RigUnit_MathQuaternionRotateVector' was renamed to 'RigVMFunction_MathQuaternionRotateVector'.
    """
    def __init__(self, transform: Quat = [0.000000, 0.000000, 0.000000, 1.000000], vector: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionGetAxis(RigVMFunction_MathQuaternionBase):
    r"""
    Rotates a given vector by the quaternion
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis`` (AxisType):  [Read-Write]
    - ``quaternion`` (Quat):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, quaternion: Quat = [0.000000, 0.000000, 0.000000, 1.000000], axis: AxisType = AxisType.NONE, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def quaternion(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @quaternion.setter
    def quaternion(self, value: Quat) -> None:
        ...
    @property
    def axis(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write]
        """
        ...
    @axis.setter
    def axis(self, value: AxisType) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionGetAxis(RigVMFunction_MathQuaternionGetAxis):
    r"""
    deprecated: 'RigUnit_MathQuaternionGetAxis' was renamed to 'RigVMFunction_MathQuaternionGetAxis'.
    """
    def __init__(self, quaternion: Quat = [0.000000, 0.000000, 0.000000, 1.000000], axis: AxisType = AxisType.NONE, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionSwingTwist(RigVMFunction_MathQuaternionBase):
    r"""
    Computes the swing and twist components of a quaternion
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input`` (Quat):  [Read-Write]
    - ``swing`` (Quat):  [Read-Write]
    - ``twist`` (Quat):  [Read-Write]
    - ``twist_axis`` (Vector):  [Read-Write]
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], twist_axis: Vector = [0.000000, 0.000000, 0.000000], swing: Quat = [0.000000, 0.000000, 0.000000, 1.000000], twist: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def input(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: Quat) -> None:
        ...
    @property
    def twist_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @twist_axis.setter
    def twist_axis(self, value: Vector) -> None:
        ...
    @property
    def swing(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...
    @property
    def twist(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionSwingTwist(RigVMFunction_MathQuaternionSwingTwist):
    r"""
    deprecated: 'RigUnit_MathQuaternionSwingTwist' was renamed to 'RigVMFunction_MathQuaternionSwingTwist'.
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], twist_axis: Vector = [0.000000, 0.000000, 0.000000], swing: Quat = [0.000000, 0.000000, 0.000000, 1.000000], twist: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionRotationOrder(RigVMFunction_MathBase):
    r"""
    Enum of possible rotation orders
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``rotation_order`` (EulerRotationOrder):  [Read-Write]
    """
    def __init__(self, rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ) -> None:
        ...
    @property
    def rotation_order(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Write]
        """
        ...
    @rotation_order.setter
    def rotation_order(self, value: EulerRotationOrder) -> None:
        ...

class RigUnit_MathQuaternionRotationOrder(RigVMFunction_MathQuaternionRotationOrder):
    r"""
    deprecated: 'RigUnit_MathQuaternionRotationOrder' was renamed to 'RigVMFunction_MathQuaternionRotationOrder'.
    """
    def __init__(self, rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ) -> None:
        ...

class RigVMFunction_MathQuaternionMakeRelative(RigVMFunction_MathQuaternionBase):
    r"""
    Returns the relative local transform within a parent's transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_`` (Quat):  [Read-Write]
    - ``local`` (Quat):  [Read-Write]
    - ``parent`` (Quat):  [Read-Write]
    """
    def __init__(self, global_: Quat = [0.000000, 0.000000, 0.000000, 1.000000], parent: Quat = [0.000000, 0.000000, 0.000000, 1.000000], local: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def global_(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @global_.setter
    def global_(self, value: Quat) -> None:
        ...
    @property
    def parent(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @parent.setter
    def parent(self, value: Quat) -> None:
        ...
    @property
    def local(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionMakeRelative(RigVMFunction_MathQuaternionMakeRelative):
    r"""
    deprecated: 'RigUnit_MathQuaternionMakeRelative' was renamed to 'RigVMFunction_MathQuaternionMakeRelative'.
    """
    def __init__(self, global_: Quat = [0.000000, 0.000000, 0.000000, 1.000000], parent: Quat = [0.000000, 0.000000, 0.000000, 1.000000], local: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionMakeAbsolute(RigVMFunction_MathQuaternionBase):
    r"""
    Returns the absolute global transform within a parent's transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_`` (Quat):  [Read-Write]
    - ``local`` (Quat):  [Read-Write]
    - ``parent`` (Quat):  [Read-Write]
    """
    def __init__(self, local: Quat = [0.000000, 0.000000, 0.000000, 1.000000], parent: Quat = [0.000000, 0.000000, 0.000000, 1.000000], global_: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def local(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @local.setter
    def local(self, value: Quat) -> None:
        ...
    @property
    def parent(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @parent.setter
    def parent(self, value: Quat) -> None:
        ...
    @property
    def global_(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionMakeAbsolute(RigVMFunction_MathQuaternionMakeAbsolute):
    r"""
    deprecated: 'RigUnit_MathQuaternionMakeAbsolute' was renamed to 'RigVMFunction_MathQuaternionMakeAbsolute'.
    """
    def __init__(self, local: Quat = [0.000000, 0.000000, 0.000000, 1.000000], parent: Quat = [0.000000, 0.000000, 0.000000, 1.000000], global_: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathQuaternionMirrorTransform(RigVMFunction_MathQuaternionBase):
    r"""
    Mirror a rotation about a central transform.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathQuaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis_to_flip`` (AxisType):  [Read-Write] the axis to flip for rotations
    - ``central_transform`` (Transform):  [Read-Write] The transform about which to mirror
    - ``mirror_axis`` (AxisType):  [Read-Write] the axis to mirror against
    - ``result`` (Quat):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], mirror_axis: AxisType = AxisType.NONE, axis_to_flip: AxisType = AxisType.NONE, central_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def mirror_axis(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] the axis to mirror against
        """
        ...
    @mirror_axis.setter
    def mirror_axis(self, value: AxisType) -> None:
        ...
    @property
    def axis_to_flip(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] the axis to flip for rotations
        """
        ...
    @axis_to_flip.setter
    def axis_to_flip(self, value: AxisType) -> None:
        ...
    @property
    def central_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform about which to mirror
        """
        ...
    @central_transform.setter
    def central_transform(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathQuaternionMirrorTransform(RigVMFunction_MathQuaternionMirrorTransform):
    r"""
    deprecated: 'RigUnit_MathQuaternionMirrorTransform' was renamed to 'RigVMFunction_MathQuaternionMirrorTransform'.
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], mirror_axis: AxisType = AxisType.NONE, axis_to_flip: AxisType = AxisType.NONE, central_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_MathRayBase(RigVMFunction_MathBase):
    r"""
    Rig VMFunction Math Ray Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRay.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathRayIntersectRay(RigVMFunction_MathRayBase):
    r"""
    Returns the closest point intersection of a ray with another ray
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Ray):  [Read-Write]
    - ``b`` (Ray):  [Read-Write]
    - ``distance`` (float):  [Read-Write]
    - ``ratio_a`` (float):  [Read-Write]
    - ``ratio_b`` (float):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, a: Ray = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], b: Ray = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], result: Vector = [0.000000, 0.000000, 0.000000], distance: float = 0.000000, ratio_a: float = 0.000000, ratio_b: float = 0.000000) -> None:
        ...
    @property
    def a(self) -> Ray:
        r"""
        (Ray):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Ray) -> None:
        ...
    @property
    def b(self) -> Ray:
        r"""
        (Ray):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Ray) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def distance(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def ratio_a(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def ratio_b(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigVMFunction_MathRayIntersectPlane(RigVMFunction_MathRayBase):
    r"""
    Returns the closest point intersection of a ray with a plane
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance`` (float):  [Read-Write]
    - ``plane_normal`` (Vector):  [Read-Write]
    - ``plane_point`` (Vector):  [Read-Write]
    - ``ratio`` (float):  [Read-Write]
    - ``ray`` (Ray):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, ray: Ray = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], plane_point: Vector = [0.000000, 0.000000, 0.000000], plane_normal: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000], distance: float = 0.000000, ratio: float = 0.000000) -> None:
        ...
    @property
    def ray(self) -> Ray:
        r"""
        (Ray):  [Read-Write]
        """
        ...
    @ray.setter
    def ray(self, value: Ray) -> None:
        ...
    @property
    def plane_point(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @plane_point.setter
    def plane_point(self, value: Vector) -> None:
        ...
    @property
    def plane_normal(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @plane_normal.setter
    def plane_normal(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def distance(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigVMFunction_MathRayGetAt(RigVMFunction_MathRayBase):
    r"""
    Returns the position on a ray
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ratio`` (float):  [Read-Write]
    - ``ray`` (Ray):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, ray: Ray = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], ratio: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def ray(self) -> Ray:
        r"""
        (Ray):  [Read-Write]
        """
        ...
    @ray.setter
    def ray(self, value: Ray) -> None:
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @ratio.setter
    def ratio(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigVMFunction_MathRayTransform(RigVMFunction_MathRayBase):
    r"""
    Returns the division of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ray`` (Ray):  [Read-Write]
    - ``result`` (Ray):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    """
    def __init__(self, ray: Ray = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Ray = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000]]) -> None:
        ...
    @property
    def ray(self) -> Ray:
        r"""
        (Ray):  [Read-Write]
        """
        ...
    @ray.setter
    def ray(self, value: Ray) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Ray:
        r"""
        (Ray):  [Read-Only]
        """
        ...

class RigVMFunction_MathRBFInterpolateBase(RigVMFunction_MathBase):
    r"""
    Rig VMFunction Math RBFInterpolate Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_MathRBFInterpolateBase(RigVMFunction_MathRBFInterpolateBase):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateBase' was renamed to 'RigVMFunction_MathRBFInterpolateBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathRBFInterpolateQuatBase(RigVMFunction_MathRBFInterpolateBase):
    r"""
    Rig VMFunction Math RBFInterpolate Quat Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFQuatDistanceType):  [Read-Only]
    - ``input`` (Quat):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``smoothing_angle`` (float):  [Read-Only]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``twist_axis`` (Vector):  [Read-Write]
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def input(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: Quat) -> None:
        ...
    @property
    def distance_function(self) -> RBFQuatDistanceType:
        r"""
        (RBFQuatDistanceType):  [Read-Only]
        """
        ...
    @property
    def smoothing_function(self) -> RBFKernelType:
        r"""
        (RBFKernelType):  [Read-Only]
        """
        ...
    @property
    def smoothing_angle(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def normalize_output(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def twist_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @twist_axis.setter
    def twist_axis(self, value: Vector) -> None:
        ...

class RigUnit_MathRBFInterpolateQuatBase(RigVMFunction_MathRBFInterpolateQuatBase):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateQuatBase' was renamed to 'RigVMFunction_MathRBFInterpolateQuatBase'.
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathRBFInterpolateVectorBase(RigVMFunction_MathRBFInterpolateBase):
    r"""
    Rig VMFunction Math RBFInterpolate Vector Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFVectorDistanceType):  [Read-Only]
    - ``input`` (Vector):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``smoothing_radius`` (float):  [Read-Only]
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False) -> None:
        ...
    @property
    def input(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: Vector) -> None:
        ...
    @property
    def distance_function(self) -> RBFVectorDistanceType:
        r"""
        (RBFVectorDistanceType):  [Read-Only]
        """
        ...
    @property
    def smoothing_function(self) -> RBFKernelType:
        r"""
        (RBFKernelType):  [Read-Only]
        """
        ...
    @property
    def smoothing_radius(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def normalize_output(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathRBFInterpolateVectorBase(RigVMFunction_MathRBFInterpolateVectorBase):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateVectorBase' was renamed to 'RigVMFunction_MathRBFInterpolateVectorBase'.
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False) -> None:
        ...

class MathRBFInterpolateQuatFloat_Target(StructBase):
    r"""
    Quat -> T
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``target`` (Quat):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, target: Quat = [0.000000, 0.000000, 0.000000, 1.000000], value: float = 0.000000) -> None:
        ...
    @property
    def target(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Quat) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class RigVMFunction_MathRBFInterpolateQuatFloat(RigVMFunction_MathRBFInterpolateQuatBase):
    r"""
    Rig VMFunction Math RBFInterpolate Quat Float
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFQuatDistanceType):  [Read-Only]
    - ``input`` (Quat):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``output`` (float):  [Read-Write]
    - ``smoothing_angle`` (float):  [Read-Only]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``targets`` (Array[MathRBFInterpolateQuatFloat_Target]):  [Read-Write]
    - ``twist_axis`` (Vector):  [Read-Write]
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000], targets: Array[MathRBFInterpolateQuatFloat_Target] = [], output: float = 0.000000) -> None:
        ...
    @property
    def targets(self) -> Array[MathRBFInterpolateQuatFloat_Target]:
        r"""
        (Array[MathRBFInterpolateQuatFloat_Target]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[MathRBFInterpolateQuatFloat_Target]) -> None:
        ...
    @property
    def output(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathRBFInterpolateQuatFloat(RigVMFunction_MathRBFInterpolateQuatFloat):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateQuatFloat' was renamed to 'RigVMFunction_MathRBFInterpolateQuatFloat'.
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000], targets: Array[MathRBFInterpolateQuatFloat_Target] = [], output: float = 0.000000) -> None:
        ...

class MathRBFInterpolateQuatVector_Target(StructBase):
    r"""
    Math RBFInterpolate Quat Vector Target
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``target`` (Quat):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, target: Quat = [0.000000, 0.000000, 0.000000, 1.000000], value: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def target(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Quat) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...

class RigVMFunction_MathRBFInterpolateQuatVector(RigVMFunction_MathRBFInterpolateQuatBase):
    r"""
    Rig VMFunction Math RBFInterpolate Quat Vector
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFQuatDistanceType):  [Read-Only]
    - ``input`` (Quat):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``output`` (Vector):  [Read-Write]
    - ``smoothing_angle`` (float):  [Read-Only]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``targets`` (Array[MathRBFInterpolateQuatVector_Target]):  [Read-Write]
    - ``twist_axis`` (Vector):  [Read-Write]
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000], targets: Array[MathRBFInterpolateQuatVector_Target] = [], output: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def targets(self) -> Array[MathRBFInterpolateQuatVector_Target]:
        r"""
        (Array[MathRBFInterpolateQuatVector_Target]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[MathRBFInterpolateQuatVector_Target]) -> None:
        ...
    @property
    def output(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathRBFInterpolateQuatVector(RigVMFunction_MathRBFInterpolateQuatVector):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateQuatVector' was renamed to 'RigVMFunction_MathRBFInterpolateQuatVector'.
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000], targets: Array[MathRBFInterpolateQuatVector_Target] = [], output: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class MathRBFInterpolateQuatColor_Target(StructBase):
    r"""
    Math RBFInterpolate Quat Color Target
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``target`` (Quat):  [Read-Write]
    - ``value`` (LinearColor):  [Read-Write]
    """
    def __init__(self, target: Quat = [0.000000, 0.000000, 0.000000, 1.000000], value: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def target(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Quat) -> None:
        ...
    @property
    def value(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: LinearColor) -> None:
        ...

class RigVMFunction_MathRBFInterpolateQuatColor(RigVMFunction_MathRBFInterpolateQuatBase):
    r"""
    Rig VMFunction Math RBFInterpolate Quat Color
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFQuatDistanceType):  [Read-Only]
    - ``input`` (Quat):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``output`` (LinearColor):  [Read-Write]
    - ``smoothing_angle`` (float):  [Read-Only]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``targets`` (Array[MathRBFInterpolateQuatColor_Target]):  [Read-Write]
    - ``twist_axis`` (Vector):  [Read-Write]
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000], targets: Array[MathRBFInterpolateQuatColor_Target] = [], output: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def targets(self) -> Array[MathRBFInterpolateQuatColor_Target]:
        r"""
        (Array[MathRBFInterpolateQuatColor_Target]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[MathRBFInterpolateQuatColor_Target]) -> None:
        ...
    @property
    def output(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...

class RigUnit_MathRBFInterpolateQuatColor(RigVMFunction_MathRBFInterpolateQuatColor):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateQuatColor' was renamed to 'RigVMFunction_MathRBFInterpolateQuatColor'.
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000], targets: Array[MathRBFInterpolateQuatColor_Target] = [], output: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class MathRBFInterpolateQuatQuat_Target(StructBase):
    r"""
    Math RBFInterpolate Quat Quat Target
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``target`` (Quat):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, target: Quat = [0.000000, 0.000000, 0.000000, 1.000000], value: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def target(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Quat) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...

class RigVMFunction_MathRBFInterpolateQuatQuat(RigVMFunction_MathRBFInterpolateQuatBase):
    r"""
    Rig VMFunction Math RBFInterpolate Quat Quat
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFQuatDistanceType):  [Read-Only]
    - ``input`` (Quat):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``output`` (Quat):  [Read-Write]
    - ``smoothing_angle`` (float):  [Read-Only]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``targets`` (Array[MathRBFInterpolateQuatQuat_Target]):  [Read-Write]
    - ``twist_axis`` (Vector):  [Read-Write]
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000], targets: Array[MathRBFInterpolateQuatQuat_Target] = [], output: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def targets(self) -> Array[MathRBFInterpolateQuatQuat_Target]:
        r"""
        (Array[MathRBFInterpolateQuatQuat_Target]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[MathRBFInterpolateQuatQuat_Target]) -> None:
        ...
    @property
    def output(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathRBFInterpolateQuatQuat(RigVMFunction_MathRBFInterpolateQuatQuat):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateQuatQuat' was renamed to 'RigVMFunction_MathRBFInterpolateQuatQuat'.
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000], targets: Array[MathRBFInterpolateQuatQuat_Target] = [], output: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class MathRBFInterpolateQuatXform_Target(StructBase):
    r"""
    Math RBFInterpolate Quat Xform Target
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``target`` (Quat):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, target: Quat = [0.000000, 0.000000, 0.000000, 1.000000], value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def target(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Quat) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...

class RigVMFunction_MathRBFInterpolateQuatXform(RigVMFunction_MathRBFInterpolateQuatBase):
    r"""
    Rig VMFunction Math RBFInterpolate Quat Xform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFQuatDistanceType):  [Read-Only]
    - ``input`` (Quat):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``output`` (Transform):  [Read-Write]
    - ``smoothing_angle`` (float):  [Read-Only]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``targets`` (Array[MathRBFInterpolateQuatXform_Target]):  [Read-Write]
    - ``twist_axis`` (Vector):  [Read-Write]
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000], targets: Array[MathRBFInterpolateQuatXform_Target] = [], output: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def targets(self) -> Array[MathRBFInterpolateQuatXform_Target]:
        r"""
        (Array[MathRBFInterpolateQuatXform_Target]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[MathRBFInterpolateQuatXform_Target]) -> None:
        ...
    @property
    def output(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathRBFInterpolateQuatXform(RigVMFunction_MathRBFInterpolateQuatXform):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateQuatXform' was renamed to 'RigVMFunction_MathRBFInterpolateQuatXform'.
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], distance_function: RBFQuatDistanceType = RBFQuatDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_angle: float = 0.000000, normalize_output: bool = False, twist_axis: Vector = [0.000000, 0.000000, 0.000000], targets: Array[MathRBFInterpolateQuatXform_Target] = [], output: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class MathRBFInterpolateVectorFloat_Target(StructBase):
    r"""
    Vector->T
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``target`` (Vector):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, target: Vector = [0.000000, 0.000000, 0.000000], value: float = 0.000000) -> None:
        ...
    @property
    def target(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Vector) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class RigVMFunction_MathRBFInterpolateVectorFloat(RigVMFunction_MathRBFInterpolateVectorBase):
    r"""
    Rig VMFunction Math RBFInterpolate Vector Float
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFVectorDistanceType):  [Read-Only]
    - ``input`` (Vector):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``output`` (float):  [Read-Write]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``smoothing_radius`` (float):  [Read-Only]
    - ``targets`` (Array[MathRBFInterpolateVectorFloat_Target]):  [Read-Write]
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False, targets: Array[MathRBFInterpolateVectorFloat_Target] = [], output: float = 0.000000) -> None:
        ...
    @property
    def targets(self) -> Array[MathRBFInterpolateVectorFloat_Target]:
        r"""
        (Array[MathRBFInterpolateVectorFloat_Target]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[MathRBFInterpolateVectorFloat_Target]) -> None:
        ...
    @property
    def output(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathRBFInterpolateVectorFloat(RigVMFunction_MathRBFInterpolateVectorFloat):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateVectorFloat' was renamed to 'RigVMFunction_MathRBFInterpolateVectorFloat'.
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False, targets: Array[MathRBFInterpolateVectorFloat_Target] = [], output: float = 0.000000) -> None:
        ...

class MathRBFInterpolateVectorVector_Target(StructBase):
    r"""
    Math RBFInterpolate Vector Vector Target
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``target`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, target: Vector = [0.000000, 0.000000, 0.000000], value: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def target(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Vector) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...

class RigVMFunction_MathRBFInterpolateVectorVector(RigVMFunction_MathRBFInterpolateVectorBase):
    r"""
    Rig VMFunction Math RBFInterpolate Vector Vector
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFVectorDistanceType):  [Read-Only]
    - ``input`` (Vector):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``output`` (Vector):  [Read-Write]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``smoothing_radius`` (float):  [Read-Only]
    - ``targets`` (Array[MathRBFInterpolateVectorVector_Target]):  [Read-Write]
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False, targets: Array[MathRBFInterpolateVectorVector_Target] = [], output: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def targets(self) -> Array[MathRBFInterpolateVectorVector_Target]:
        r"""
        (Array[MathRBFInterpolateVectorVector_Target]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[MathRBFInterpolateVectorVector_Target]) -> None:
        ...
    @property
    def output(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathRBFInterpolateVectorVector(RigVMFunction_MathRBFInterpolateVectorVector):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateVectorVector' was renamed to 'RigVMFunction_MathRBFInterpolateVectorVector'.
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False, targets: Array[MathRBFInterpolateVectorVector_Target] = [], output: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class MathRBFInterpolateVectorColor_Target(StructBase):
    r"""
    Math RBFInterpolate Vector Color Target
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``target`` (Vector):  [Read-Write]
    - ``value`` (LinearColor):  [Read-Write]
    """
    def __init__(self, target: Vector = [0.000000, 0.000000, 0.000000], value: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def target(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Vector) -> None:
        ...
    @property
    def value(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: LinearColor) -> None:
        ...

class RigVMFunction_MathRBFInterpolateVectorColor(RigVMFunction_MathRBFInterpolateVectorBase):
    r"""
    Rig VMFunction Math RBFInterpolate Vector Color
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFVectorDistanceType):  [Read-Only]
    - ``input`` (Vector):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``output`` (LinearColor):  [Read-Write]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``smoothing_radius`` (float):  [Read-Only]
    - ``targets`` (Array[MathRBFInterpolateVectorColor_Target]):  [Read-Write]
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False, targets: Array[MathRBFInterpolateVectorColor_Target] = [], output: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def targets(self) -> Array[MathRBFInterpolateVectorColor_Target]:
        r"""
        (Array[MathRBFInterpolateVectorColor_Target]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[MathRBFInterpolateVectorColor_Target]) -> None:
        ...
    @property
    def output(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...

class RigUnit_MathRBFInterpolateVectorColor(RigVMFunction_MathRBFInterpolateVectorColor):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateVectorColor' was renamed to 'RigVMFunction_MathRBFInterpolateVectorColor'.
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False, targets: Array[MathRBFInterpolateVectorColor_Target] = [], output: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...

class MathRBFInterpolateVectorQuat_Target(StructBase):
    r"""
    Math RBFInterpolate Vector Quat Target
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``target`` (Vector):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, target: Vector = [0.000000, 0.000000, 0.000000], value: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def target(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Vector) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...

class RigVMFunction_MathRBFInterpolateVectorQuat(RigVMFunction_MathRBFInterpolateVectorBase):
    r"""
    Rig VMFunction Math RBFInterpolate Vector Quat
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFVectorDistanceType):  [Read-Only]
    - ``input`` (Vector):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``output`` (Quat):  [Read-Write]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``smoothing_radius`` (float):  [Read-Only]
    - ``targets`` (Array[MathRBFInterpolateVectorQuat_Target]):  [Read-Write]
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False, targets: Array[MathRBFInterpolateVectorQuat_Target] = [], output: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def targets(self) -> Array[MathRBFInterpolateVectorQuat_Target]:
        r"""
        (Array[MathRBFInterpolateVectorQuat_Target]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[MathRBFInterpolateVectorQuat_Target]) -> None:
        ...
    @property
    def output(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MathRBFInterpolateVectorQuat(RigVMFunction_MathRBFInterpolateVectorQuat):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateVectorQuat' was renamed to 'RigVMFunction_MathRBFInterpolateVectorQuat'.
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False, targets: Array[MathRBFInterpolateVectorQuat_Target] = [], output: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class MathRBFInterpolateVectorXform_Target(StructBase):
    r"""
    Math RBFInterpolate Vector Xform Target
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``target`` (Vector):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, target: Vector = [0.000000, 0.000000, 0.000000], value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def target(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Vector) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...

class RigVMFunction_MathRBFInterpolateVectorXform(RigVMFunction_MathRBFInterpolateVectorBase):
    r"""
    Rig VMFunction Math RBFInterpolate Vector Xform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathRBFInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distance_function`` (RBFVectorDistanceType):  [Read-Only]
    - ``input`` (Vector):  [Read-Write]
    - ``normalize_output`` (bool):  [Read-Only]
    - ``output`` (Transform):  [Read-Write]
    - ``smoothing_function`` (RBFKernelType):  [Read-Only]
    - ``smoothing_radius`` (float):  [Read-Only]
    - ``targets`` (Array[MathRBFInterpolateVectorXform_Target]):  [Read-Write]
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False, targets: Array[MathRBFInterpolateVectorXform_Target] = [], output: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def targets(self) -> Array[MathRBFInterpolateVectorXform_Target]:
        r"""
        (Array[MathRBFInterpolateVectorXform_Target]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[MathRBFInterpolateVectorXform_Target]) -> None:
        ...
    @property
    def output(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathRBFInterpolateVectorXform(RigVMFunction_MathRBFInterpolateVectorXform):
    r"""
    deprecated: 'RigUnit_MathRBFInterpolateVectorXform' was renamed to 'RigVMFunction_MathRBFInterpolateVectorXform'.
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], distance_function: RBFVectorDistanceType = RBFVectorDistanceType.EUCLIDEAN, smoothing_function: RBFKernelType = RBFKernelType.GAUSSIAN, smoothing_radius: float = 0.000000, normalize_output: bool = False, targets: Array[MathRBFInterpolateVectorXform_Target] = [], output: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformMutableBase(RigVMFunction_MathMutableBase):
    r"""
    Rig VMFunction Math Transform Mutable Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    """
    def __init__(self, execute_context: RigVMExecuteContext = []) -> None:
        ...

class RigUnit_MathTransformMutableBase(RigVMFunction_MathTransformMutableBase):
    r"""
    deprecated: 'RigUnit_MathTransformMutableBase' was renamed to 'RigVMFunction_MathTransformMutableBase'.
    """
    def __init__(self, execute_context: RigVMExecuteContext = []) -> None:
        ...

class RigVMFunction_MathTransformBase(RigVMFunction_MathBase):
    r"""
    Rig VMFunction Math Transform Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_MathTransformBase(RigVMFunction_MathTransformBase):
    r"""
    deprecated: 'RigUnit_MathTransformBase' was renamed to 'RigVMFunction_MathTransformBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathTransformUnaryOp(RigVMFunction_MathTransformBase):
    r"""
    Rig VMFunction Math Transform Unary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Transform):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformUnaryOp(RigVMFunction_MathTransformUnaryOp):
    r"""
    deprecated: 'RigUnit_MathTransformUnaryOp' was renamed to 'RigVMFunction_MathTransformUnaryOp'.
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformBinaryOp(RigVMFunction_MathTransformBase):
    r"""
    Rig VMFunction Math Transform Binary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Transform):  [Read-Write]
    - ``b`` (Transform):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    """
    def __init__(self, a: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], b: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def a(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Transform) -> None:
        ...
    @property
    def b(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformBinaryOp(RigVMFunction_MathTransformBinaryOp):
    r"""
    deprecated: 'RigUnit_MathTransformBinaryOp' was renamed to 'RigVMFunction_MathTransformBinaryOp'.
    """
    def __init__(self, a: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], b: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformBinaryAggregateOp(RigVMFunction_MathTransformBase):
    r"""
    Rig VMFunction Math Transform Binary Aggregate Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Transform):  [Read-Write]
    - ``b`` (Transform):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    """
    def __init__(self, a: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], b: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def a(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Transform) -> None:
        ...
    @property
    def b(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformBinaryAggregateOp(RigVMFunction_MathTransformBinaryAggregateOp):
    r"""
    deprecated: 'RigUnit_MathTransformBinaryAggregateOp' was renamed to 'RigVMFunction_MathTransformBinaryAggregateOp'.
    """
    def __init__(self, a: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], b: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformMake(RigVMFunction_MathTransformBase):
    r"""
    Makes a transform from its components
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Transform):  [Read-Write]
    - ``rotation`` (Quat):  [Read-Write]
    - ``scale`` (Vector):  [Read-Write]
    - ``translation`` (Vector):  [Read-Write]
    """
    def __init__(self, translation: Vector = [0.000000, 0.000000, 0.000000], rotation: Quat = [0.000000, 0.000000, 0.000000, 1.000000], scale: Vector = [0.000000, 0.000000, 0.000000], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def translation(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @translation.setter
    def translation(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @rotation.setter
    def rotation(self, value: Quat) -> None:
        ...
    @property
    def scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformMake(RigVMFunction_MathTransformMake):
    r"""
    deprecated: 'RigUnit_MathTransformMake' was renamed to 'RigVMFunction_MathTransformMake'.
    """
    def __init__(self, translation: Vector = [0.000000, 0.000000, 0.000000], rotation: Quat = [0.000000, 0.000000, 0.000000, 1.000000], scale: Vector = [0.000000, 0.000000, 0.000000], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformFromEulerTransform(RigVMFunction_MathTransformBase):
    r"""
    Makes a quaternion based transform from a euler based transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``euler_transform`` (EulerTransform):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    """
    def __init__(self, euler_transform: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def euler_transform(self) -> EulerTransform:
        r"""
        (EulerTransform):  [Read-Write]
        """
        ...
    @euler_transform.setter
    def euler_transform(self, value: EulerTransform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformFromEulerTransform(RigVMFunction_MathTransformFromEulerTransform):
    r"""
    deprecated: 'RigUnit_MathTransformFromEulerTransform' was renamed to 'RigVMFunction_MathTransformFromEulerTransform'.
    """
    def __init__(self, euler_transform: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformFromEulerTransformV2(RigVMFunction_MathTransformBase):
    r"""
    Makes a quaternion based transform from a euler based transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Transform):  [Read-Write]
    - ``value`` (EulerTransform):  [Read-Write]
    """
    def __init__(self, value: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> EulerTransform:
        r"""
        (EulerTransform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: EulerTransform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformFromEulerTransformV2(RigVMFunction_MathTransformFromEulerTransformV2):
    r"""
    deprecated: 'RigUnit_MathTransformFromEulerTransformV2' was renamed to 'RigVMFunction_MathTransformFromEulerTransformV2'.
    """
    def __init__(self, value: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformToEulerTransform(RigVMFunction_MathTransformBase):
    r"""
    Retrieves a euler based transform from a quaternion based transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (EulerTransform):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> EulerTransform:
        r"""
        (EulerTransform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformToEulerTransform(RigVMFunction_MathTransformToEulerTransform):
    r"""
    deprecated: 'RigUnit_MathTransformToEulerTransform' was renamed to 'RigVMFunction_MathTransformToEulerTransform'.
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformToVectors(RigVMFunction_MathTransformBase):
    r"""
    Retrieves the forward, right and up vectors of a transform's quaternion
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``forward`` (Vector):  [Read-Write]
    - ``right`` (Vector):  [Read-Write]
    - ``up`` (Vector):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], forward: Vector = [0.000000, 0.000000, 0.000000], right: Vector = [0.000000, 0.000000, 0.000000], up: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def forward(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def right(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def up(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigVMFunction_MathTransformMul(RigVMFunction_MathTransformBinaryAggregateOp):
    r"""
    Returns the product of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Transform):  [Read-Write]
    - ``b`` (Transform):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    """
    def __init__(self, a: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], b: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigUnit_MathTransformMul(RigVMFunction_MathTransformMul):
    r"""
    deprecated: 'RigUnit_MathTransformMul' was renamed to 'RigVMFunction_MathTransformMul'.
    """
    def __init__(self, a: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], b: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformMakeRelative(RigVMFunction_MathTransformBase):
    r"""
    Returns the relative local transform within a parent's transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_`` (Transform):  [Read-Write]
    - ``local`` (Transform):  [Read-Write]
    - ``parent`` (Transform):  [Read-Write]
    """
    def __init__(self, global_: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], parent: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], local: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def global_(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @global_.setter
    def global_(self, value: Transform) -> None:
        ...
    @property
    def parent(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @parent.setter
    def parent(self, value: Transform) -> None:
        ...
    @property
    def local(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformMakeRelative(RigVMFunction_MathTransformMakeRelative):
    r"""
    deprecated: 'RigUnit_MathTransformMakeRelative' was renamed to 'RigVMFunction_MathTransformMakeRelative'.
    """
    def __init__(self, global_: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], parent: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], local: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformMakeAbsolute(RigVMFunction_MathTransformBase):
    r"""
    Returns the absolute global transform within a parent's transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_`` (Transform):  [Read-Write]
    - ``local`` (Transform):  [Read-Write]
    - ``parent`` (Transform):  [Read-Write]
    """
    def __init__(self, local: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], parent: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], global_: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def local(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @local.setter
    def local(self, value: Transform) -> None:
        ...
    @property
    def parent(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @parent.setter
    def parent(self, value: Transform) -> None:
        ...
    @property
    def global_(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformMakeAbsolute(RigVMFunction_MathTransformMakeAbsolute):
    r"""
    deprecated: 'RigUnit_MathTransformMakeAbsolute' was renamed to 'RigVMFunction_MathTransformMakeAbsolute'.
    """
    def __init__(self, local: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], parent: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], global_: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformAccumulateArray(RigVMFunction_MathTransformMutableBase):
    r"""
    Treats the provided transforms as a chain with global / local transforms, and
    projects each transform into the target space. Optionally you can provide
    a custom parent indices array, with which you can represent more than just chains.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``parent_indices`` (Array[int32]):  [Read-Write] If this array is the same size as the transforms array the indices will be used
      to look up each transform's parent. They are expected to be in order.
    - ``root`` (Transform):  [Read-Write] Provides the parent transform for the root
    - ``target_space`` (RigVMTransformSpace):  [Read-Write] Defines the space to project to
    - ``transforms`` (Array[Transform]):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], transforms: Array[Transform] = [], target_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, root: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], parent_indices: Array[int] = []) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write]
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def target_space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines the space to project to
        """
        ...
    @target_space.setter
    def target_space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def root(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Provides the parent transform for the root
        """
        ...
    @root.setter
    def root(self, value: Transform) -> None:
        ...
    @property
    def parent_indices(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write] If this array is the same size as the transforms array the indices will be used
        to look up each transform's parent. They are expected to be in order.
        """
        ...
    @parent_indices.setter
    def parent_indices(self, value: Array[int]) -> None:
        ...

class RigUnit_MathTransformAccumulateArray(RigVMFunction_MathTransformAccumulateArray):
    r"""
    deprecated: 'RigUnit_MathTransformAccumulateArray' was renamed to 'RigVMFunction_MathTransformAccumulateArray'.
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], transforms: Array[Transform] = [], target_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, root: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], parent_indices: Array[int] = []) -> None:
        ...

class RigVMFunction_MathTransformInverse(RigVMFunction_MathTransformUnaryOp):
    r"""
    Returns the negative value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Transform):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigUnit_MathTransformInverse(RigVMFunction_MathTransformInverse):
    r"""
    deprecated: 'RigUnit_MathTransformInverse' was renamed to 'RigVMFunction_MathTransformInverse'.
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformLerp(RigVMFunction_MathTransformBase):
    r"""
    Linearly interpolates between A and B using the ratio T
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Transform):  [Read-Write]
    - ``b`` (Transform):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    - ``t`` (float):  [Read-Write]
    """
    def __init__(self, a: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], b: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], t: float = 0.000000, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def a(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Transform) -> None:
        ...
    @property
    def b(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Transform) -> None:
        ...
    @property
    def t(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @t.setter
    def t(self, value: float) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformLerp(RigVMFunction_MathTransformLerp):
    r"""
    deprecated: 'RigUnit_MathTransformLerp' was renamed to 'RigVMFunction_MathTransformLerp'.
    """
    def __init__(self, a: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], b: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], t: float = 0.000000, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformSelectBool(RigVMFunction_MathTransformBase):
    r"""
    Return one of the two values based on the condition
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``condition`` (bool):  [Read-Write]
    - ``if_false`` (Transform):  [Read-Write]
    - ``if_true`` (Transform):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    """
    def __init__(self, condition: bool = False, if_true: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], if_false: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def condition(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @condition.setter
    def condition(self, value: bool) -> None:
        ...
    @property
    def if_true(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @if_true.setter
    def if_true(self, value: Transform) -> None:
        ...
    @property
    def if_false(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @if_false.setter
    def if_false(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformSelectBool(RigVMFunction_MathTransformSelectBool):
    r"""
    deprecated: 'RigUnit_MathTransformSelectBool' was renamed to 'RigVMFunction_MathTransformSelectBool'.
    """
    def __init__(self, condition: bool = False, if_true: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], if_false: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformRotateVector(RigVMFunction_MathTransformBase):
    r"""
    Rotates a given vector (direction) by the transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``vector`` (Vector):  [Read-Write]
    """
    def __init__(self, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], vector: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @vector.setter
    def vector(self, value: Vector) -> None:
        ...
    @property
    def direction(self) -> Vector:
        r"""
        deprecated: 'direction' was renamed to 'vector'.
        """
        ...
    @direction.setter
    def direction(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathTransformRotateVector(RigVMFunction_MathTransformRotateVector):
    r"""
    deprecated: 'RigUnit_MathTransformRotateVector' was renamed to 'RigVMFunction_MathTransformRotateVector'.
    """
    def __init__(self, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], vector: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathTransformTransformVector(RigVMFunction_MathTransformBase):
    r"""
    Multiplies a given vector (location) by the transform
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``location`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    """
    def __init__(self, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], location: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathTransformTransformVector(RigVMFunction_MathTransformTransformVector):
    r"""
    deprecated: 'RigUnit_MathTransformTransformVector' was renamed to 'RigVMFunction_MathTransformTransformVector'.
    """
    def __init__(self, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], location: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathTransformFromSRT(RigVMFunction_MathTransformBase):
    r"""
    Composes a Transform (and Euler Transform) from its components.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``euler_transform`` (EulerTransform):  [Read-Write]
    - ``location`` (Vector):  [Read-Write]
    - ``rotation`` (Vector):  [Read-Write]
    - ``rotation_order`` (EulerRotationOrder):  [Read-Write]
    - ``scale`` (Vector):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], rotation: Vector = [0.000000, 0.000000, 0.000000], rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ, scale: Vector = [0.000000, 0.000000, 0.000000], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], euler_transform: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @rotation.setter
    def rotation(self, value: Vector) -> None:
        ...
    @property
    def rotation_order(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Write]
        """
        ...
    @rotation_order.setter
    def rotation_order(self, value: EulerRotationOrder) -> None:
        ...
    @property
    def scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: Vector) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...
    @property
    def euler_transform(self) -> EulerTransform:
        r"""
        (EulerTransform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformFromSRT(RigVMFunction_MathTransformFromSRT):
    r"""
    deprecated: 'RigUnit_MathTransformFromSRT' was renamed to 'RigVMFunction_MathTransformFromSRT'.
    """
    def __init__(self, location: Vector = [0.000000, 0.000000, 0.000000], rotation: Vector = [0.000000, 0.000000, 0.000000], rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ, scale: Vector = [0.000000, 0.000000, 0.000000], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], euler_transform: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformArrayToSRT(RigVMFunction_MathTransformBase):
    r"""
    Decomposes a Transform Array to its components.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``rotations`` (Array[Quat]):  [Read-Write]
    - ``scales`` (Array[Vector]):  [Read-Write]
    - ``transforms`` (Array[Transform]):  [Read-Write]
    - ``translations`` (Array[Vector]):  [Read-Write]
    """
    def __init__(self, transforms: Array[Transform] = [], translations: Array[Vector] = [], rotations: Array[Quat] = [], scales: Array[Vector] = []) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write]
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def translations(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Only]
        """
        ...
    @property
    def rotations(self) -> Array[Quat]:
        r"""
        (Array[Quat]):  [Read-Only]
        """
        ...
    @property
    def scales(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Only]
        """
        ...

class RigUnit_MathTransformArrayToSRT(RigVMFunction_MathTransformArrayToSRT):
    r"""
    deprecated: 'RigUnit_MathTransformArrayToSRT' was renamed to 'RigVMFunction_MathTransformArrayToSRT'.
    """
    def __init__(self, transforms: Array[Transform] = [], translations: Array[Vector] = [], rotations: Array[Quat] = [], scales: Array[Vector] = []) -> None:
        ...

class RigVMFunction_MathTransformClampSpatially(RigVMFunction_MathTransformBase):
    r"""
    Clamps a position using a plane collision, cylindric collision or spherical collision.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis`` (AxisType):  [Read-Write]
    - ``debug_color`` (LinearColor):  [Read-Write]
    - ``debug_thickness`` (float):  [Read-Write]
    - ``draw_debug`` (bool):  [Read-Write]
    - ``maximum`` (float):  [Read-Write] This maximum allowed distance.
      A collision will occur towards the center at this wall.
      Note: For capsule this represents the length.
      Disable by setting to 0.0.
    - ``minimum`` (float):  [Read-Write] The minimum allowed distance at which a collision occurs.
      Note: For capsule this represents the radius.
      Disable by setting to 0.0.
    - ``result`` (Transform):  [Read-Write]
    - ``space`` (Transform):  [Read-Write] The space this spatial clamp happens within.
      The input position will be projected into this space.
    - ``type`` (RigVMClampSpatialMode):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], axis: AxisType = AxisType.NONE, type: RigVMClampSpatialMode = RigVMClampSpatialMode.PLANE, minimum: float = 0.000000, maximum: float = 0.000000, space: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], draw_debug: bool = False, debug_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], debug_thickness: float = 0.000000, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def axis(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write]
        """
        ...
    @axis.setter
    def axis(self, value: AxisType) -> None:
        ...
    @property
    def type(self) -> RigVMClampSpatialMode:
        r"""
        (RigVMClampSpatialMode):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: RigVMClampSpatialMode) -> None:
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Write] The minimum allowed distance at which a collision occurs.
        Note: For capsule this represents the radius.
        Disable by setting to 0.0.
        """
        ...
    @minimum.setter
    def minimum(self, value: float) -> None:
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Write] This maximum allowed distance.
        A collision will occur towards the center at this wall.
        Note: For capsule this represents the length.
        Disable by setting to 0.0.
        """
        ...
    @maximum.setter
    def maximum(self, value: float) -> None:
        ...
    @property
    def space(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The space this spatial clamp happens within.
        The input position will be projected into this space.
        """
        ...
    @space.setter
    def space(self, value: Transform) -> None:
        ...
    @property
    def draw_debug(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_debug.setter
    def draw_debug(self, value: bool) -> None:
        ...
    @property
    def debug_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @debug_color.setter
    def debug_color(self, value: LinearColor) -> None:
        ...
    @property
    def debug_thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @debug_thickness.setter
    def debug_thickness(self, value: float) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformClampSpatially(RigVMFunction_MathTransformClampSpatially):
    r"""
    deprecated: 'RigUnit_MathTransformClampSpatially' was renamed to 'RigVMFunction_MathTransformClampSpatially'.
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], axis: AxisType = AxisType.NONE, type: RigVMClampSpatialMode = RigVMClampSpatialMode.PLANE, minimum: float = 0.000000, maximum: float = 0.000000, space: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], draw_debug: bool = False, debug_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], debug_thickness: float = 0.000000, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathTransformMirrorTransform(RigVMFunction_MathTransformBase):
    r"""
    Mirror a transform about a central transform.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis_to_flip`` (AxisType):  [Read-Write] the axis to flip for rotations
    - ``central_transform`` (Transform):  [Read-Write] The transform about which to mirror
    - ``mirror_axis`` (AxisType):  [Read-Write] the axis to mirror against
    - ``result`` (Transform):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], mirror_axis: AxisType = AxisType.NONE, axis_to_flip: AxisType = AxisType.NONE, central_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def mirror_axis(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] the axis to mirror against
        """
        ...
    @mirror_axis.setter
    def mirror_axis(self, value: AxisType) -> None:
        ...
    @property
    def axis_to_flip(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] the axis to flip for rotations
        """
        ...
    @axis_to_flip.setter
    def axis_to_flip(self, value: AxisType) -> None:
        ...
    @property
    def central_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform about which to mirror
        """
        ...
    @central_transform.setter
    def central_transform(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MathTransformMirrorTransform(RigVMFunction_MathTransformMirrorTransform):
    r"""
    deprecated: 'RigUnit_MathTransformMirrorTransform' was renamed to 'RigVMFunction_MathTransformMirrorTransform'.
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], mirror_axis: AxisType = AxisType.NONE, axis_to_flip: AxisType = AxisType.NONE, central_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_MathVectorBase(RigVMFunction_MathBase):
    r"""
    Rig VMFunction Math Vector Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_MathVectorBase(RigVMFunction_MathVectorBase):
    r"""
    deprecated: 'RigUnit_MathVectorBase' was renamed to 'RigVMFunction_MathVectorBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathVectorUnaryOp(RigVMFunction_MathVectorBase):
    r"""
    Rig VMFunction Math Vector Unary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorUnaryOp(RigVMFunction_MathVectorUnaryOp):
    r"""
    deprecated: 'RigUnit_MathVectorUnaryOp' was renamed to 'RigVMFunction_MathVectorUnaryOp'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorBinaryOp(RigVMFunction_MathVectorBase):
    r"""
    Rig VMFunction Math Vector Binary Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorBinaryOp(RigVMFunction_MathVectorBinaryOp):
    r"""
    deprecated: 'RigUnit_MathVectorBinaryOp' was renamed to 'RigVMFunction_MathVectorBinaryOp'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorBinaryAggregateOp(RigVMFunction_MathVectorBase):
    r"""
    Rig VMFunction Math Vector Binary Aggregate Op
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorBinaryAggregateOp(RigVMFunction_MathVectorBinaryAggregateOp):
    r"""
    deprecated: 'RigUnit_MathVectorBinaryAggregateOp' was renamed to 'RigVMFunction_MathVectorBinaryAggregateOp'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorMake(RigVMFunction_MathVectorBase):
    r"""
    Makes a vector from its components
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``x`` (float):  [Read-Write]
    - ``y`` (float):  [Read-Write]
    - ``z`` (float):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def x(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: float) -> None:
        ...
    @property
    def y(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: float) -> None:
        ...
    @property
    def z(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorMake(RigVMFunction_MathVectorMake):
    r"""
    deprecated: 'RigUnit_MathVectorMake' was renamed to 'RigVMFunction_MathVectorMake'.
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorFromFloat(RigVMFunction_MathVectorBase):
    r"""
    Makes a vector from a single float
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorFromFloat(RigVMFunction_MathVectorFromFloat):
    r"""
    deprecated: 'RigUnit_MathVectorFromFloat' was renamed to 'RigVMFunction_MathVectorFromFloat'.
    """
    def __init__(self, value: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorFromDouble(RigVMFunction_MathVectorBase):
    r"""
    Makes a vector from a single double
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorFromDouble(RigVMFunction_MathVectorFromDouble):
    r"""
    deprecated: 'RigUnit_MathVectorFromDouble' was renamed to 'RigVMFunction_MathVectorFromDouble'.
    """
    def __init__(self, value: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorAdd(RigVMFunction_MathVectorBinaryAggregateOp):
    r"""
    Returns the sum of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorAdd(RigVMFunction_MathVectorAdd):
    r"""
    deprecated: 'RigUnit_MathVectorAdd' was renamed to 'RigVMFunction_MathVectorAdd'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorSub(RigVMFunction_MathVectorBinaryOp):
    r"""
    Returns the difference of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorSub(RigVMFunction_MathVectorSub):
    r"""
    deprecated: 'RigUnit_MathVectorSub' was renamed to 'RigVMFunction_MathVectorSub'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorMul(RigVMFunction_MathVectorBinaryAggregateOp):
    r"""
    Returns the product of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorMul(RigVMFunction_MathVectorMul):
    r"""
    deprecated: 'RigUnit_MathVectorMul' was renamed to 'RigVMFunction_MathVectorMul'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorScale(RigVMFunction_MathVectorBase):
    r"""
    Returns the product of the the vector and the float value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``factor`` (float):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], factor: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def factor(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @factor.setter
    def factor(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorScale(RigVMFunction_MathVectorScale):
    r"""
    deprecated: 'RigUnit_MathVectorScale' was renamed to 'RigVMFunction_MathVectorScale'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], factor: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorDiv(RigVMFunction_MathVectorBinaryOp):
    r"""
    Returns the division of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorDiv(RigVMFunction_MathVectorDiv):
    r"""
    deprecated: 'RigUnit_MathVectorDiv' was renamed to 'RigVMFunction_MathVectorDiv'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorMod(RigVMFunction_MathVectorBinaryOp):
    r"""
    Returns the modulo of the two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorMod(RigVMFunction_MathVectorMod):
    r"""
    deprecated: 'RigUnit_MathVectorMod' was renamed to 'RigVMFunction_MathVectorMod'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorMin(RigVMFunction_MathVectorBinaryAggregateOp):
    r"""
    Returns the smaller of the two values for each component
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorMin(RigVMFunction_MathVectorMin):
    r"""
    deprecated: 'RigUnit_MathVectorMin' was renamed to 'RigVMFunction_MathVectorMin'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorMax(RigVMFunction_MathVectorBinaryAggregateOp):
    r"""
    Returns the larger of the two values each component
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorMax(RigVMFunction_MathVectorMax):
    r"""
    deprecated: 'RigUnit_MathVectorMax' was renamed to 'RigVMFunction_MathVectorMax'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorNegate(RigVMFunction_MathVectorUnaryOp):
    r"""
    Returns the negative value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorNegate(RigVMFunction_MathVectorNegate):
    r"""
    deprecated: 'RigUnit_MathVectorNegate' was renamed to 'RigVMFunction_MathVectorNegate'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorAbs(RigVMFunction_MathVectorUnaryOp):
    r"""
    Returns the absolute (positive) value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorAbs(RigVMFunction_MathVectorAbs):
    r"""
    deprecated: 'RigUnit_MathVectorAbs' was renamed to 'RigVMFunction_MathVectorAbs'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorFloor(RigVMFunction_MathVectorUnaryOp):
    r"""
    Returns the closest lower full number (integer) of the value for each component
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorFloor(RigVMFunction_MathVectorFloor):
    r"""
    deprecated: 'RigUnit_MathVectorFloor' was renamed to 'RigVMFunction_MathVectorFloor'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorCeil(RigVMFunction_MathVectorUnaryOp):
    r"""
    Returns the closest higher full number (integer) of the value for each component
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorCeil(RigVMFunction_MathVectorCeil):
    r"""
    deprecated: 'RigUnit_MathVectorCeil' was renamed to 'RigVMFunction_MathVectorCeil'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorRound(RigVMFunction_MathVectorUnaryOp):
    r"""
    Returns the closest higher full number (integer) of the value for each component
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorRound(RigVMFunction_MathVectorRound):
    r"""
    deprecated: 'RigUnit_MathVectorRound' was renamed to 'RigVMFunction_MathVectorRound'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorSign(RigVMFunction_MathVectorUnaryOp):
    r"""
    Returns the sign of the value (+1 for >= FVector(0.f, 0.f, 0.f), -1 for < 0.f) for each component
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorSign(RigVMFunction_MathVectorSign):
    r"""
    deprecated: 'RigUnit_MathVectorSign' was renamed to 'RigVMFunction_MathVectorSign'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorClamp(RigVMFunction_MathVectorBase):
    r"""
    Clamps the given value within the range provided by minimum and maximum for each component
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``maximum`` (Vector):  [Read-Write]
    - ``minimum`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], minimum: Vector = [0.000000, 0.000000, 0.000000], maximum: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def minimum(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @minimum.setter
    def minimum(self, value: Vector) -> None:
        ...
    @property
    def maximum(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @maximum.setter
    def maximum(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorClamp(RigVMFunction_MathVectorClamp):
    r"""
    deprecated: 'RigUnit_MathVectorClamp' was renamed to 'RigVMFunction_MathVectorClamp'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], minimum: Vector = [0.000000, 0.000000, 0.000000], maximum: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorLerp(RigVMFunction_MathVectorBase):
    r"""
    Linearly interpolates between A and B using the ratio T
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``t`` (float):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], t: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def t(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @t.setter
    def t(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorLerp(RigVMFunction_MathVectorLerp):
    r"""
    deprecated: 'RigUnit_MathVectorLerp' was renamed to 'RigVMFunction_MathVectorLerp'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], t: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorRemap(RigVMFunction_MathVectorBase):
    r"""
    Remaps the given value from a source range to a target range for each component
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clamp`` (bool):  [Read-Write] If set to true the result is clamped to the target range
    - ``result`` (Vector):  [Read-Write]
    - ``source_maximum`` (Vector):  [Read-Write]
    - ``source_minimum`` (Vector):  [Read-Write]
    - ``target_maximum`` (Vector):  [Read-Write]
    - ``target_minimum`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], source_minimum: Vector = [0.000000, 0.000000, 0.000000], source_maximum: Vector = [0.000000, 0.000000, 0.000000], target_minimum: Vector = [0.000000, 0.000000, 0.000000], target_maximum: Vector = [0.000000, 0.000000, 0.000000], clamp: bool = False, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def source_minimum(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @source_minimum.setter
    def source_minimum(self, value: Vector) -> None:
        ...
    @property
    def source_maximum(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @source_maximum.setter
    def source_maximum(self, value: Vector) -> None:
        ...
    @property
    def target_minimum(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @target_minimum.setter
    def target_minimum(self, value: Vector) -> None:
        ...
    @property
    def target_maximum(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @target_maximum.setter
    def target_maximum(self, value: Vector) -> None:
        ...
    @property
    def clamp(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the result is clamped to the target range
        """
        ...
    @clamp.setter
    def clamp(self, value: bool) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorRemap(RigVMFunction_MathVectorRemap):
    r"""
    deprecated: 'RigUnit_MathVectorRemap' was renamed to 'RigVMFunction_MathVectorRemap'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], source_minimum: Vector = [0.000000, 0.000000, 0.000000], source_maximum: Vector = [0.000000, 0.000000, 0.000000], target_minimum: Vector = [0.000000, 0.000000, 0.000000], target_maximum: Vector = [0.000000, 0.000000, 0.000000], clamp: bool = False, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorEquals(RigVMFunction_MathVectorBase):
    r"""
    Returns true if the value A equals B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: bool = False) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathVectorEquals(RigVMFunction_MathVectorEquals):
    r"""
    deprecated: 'RigUnit_MathVectorEquals' was renamed to 'RigVMFunction_MathVectorEquals'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: bool = False) -> None:
        ...

class RigVMFunction_MathVectorNotEquals(RigVMFunction_MathVectorBase):
    r"""
    Returns true if the value A does not equal B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: bool = False) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathVectorNotEquals(RigVMFunction_MathVectorNotEquals):
    r"""
    deprecated: 'RigUnit_MathVectorNotEquals' was renamed to 'RigVMFunction_MathVectorNotEquals'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: bool = False) -> None:
        ...

class RigVMFunction_MathVectorIsNearlyZero(RigVMFunction_MathVectorBase):
    r"""
    Returns true if the value is nearly zero
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (bool):  [Read-Write]
    - ``tolerance`` (float):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], tolerance: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def tolerance(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @tolerance.setter
    def tolerance(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathVectorIsNearlyZero(RigVMFunction_MathVectorIsNearlyZero):
    r"""
    deprecated: 'RigUnit_MathVectorIsNearlyZero' was renamed to 'RigVMFunction_MathVectorIsNearlyZero'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], tolerance: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathVectorIsNearlyEqual(RigVMFunction_MathVectorBase):
    r"""
    Returns true if the value A is almost equal to B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    - ``tolerance`` (float):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], tolerance: float = 0.000000, result: bool = False) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def tolerance(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @tolerance.setter
    def tolerance(self, value: float) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathVectorIsNearlyEqual(RigVMFunction_MathVectorIsNearlyEqual):
    r"""
    deprecated: 'RigUnit_MathVectorIsNearlyEqual' was renamed to 'RigVMFunction_MathVectorIsNearlyEqual'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], tolerance: float = 0.000000, result: bool = False) -> None:
        ...

class RigVMFunction_MathVectorSelectBool(RigVMFunction_MathVectorBase):
    r"""
    Return one of the two values based on the condition
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``condition`` (bool):  [Read-Write]
    - ``if_false`` (Vector):  [Read-Write]
    - ``if_true`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, condition: bool = False, if_true: Vector = [0.000000, 0.000000, 0.000000], if_false: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def condition(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @condition.setter
    def condition(self, value: bool) -> None:
        ...
    @property
    def if_true(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @if_true.setter
    def if_true(self, value: Vector) -> None:
        ...
    @property
    def if_false(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @if_false.setter
    def if_false(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorSelectBool(RigVMFunction_MathVectorSelectBool):
    r"""
    deprecated: 'RigUnit_MathVectorSelectBool' was renamed to 'RigVMFunction_MathVectorSelectBool'.
    """
    def __init__(self, condition: bool = False, if_true: Vector = [0.000000, 0.000000, 0.000000], if_false: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorDeg(RigVMFunction_MathVectorUnaryOp):
    r"""
    Returns the degrees of a given value in radians
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorDeg(RigVMFunction_MathVectorDeg):
    r"""
    deprecated: 'RigUnit_MathVectorDeg' was renamed to 'RigVMFunction_MathVectorDeg'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorRad(RigVMFunction_MathVectorUnaryOp):
    r"""
    Returns the radians of a given value in degrees
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorRad(RigVMFunction_MathVectorRad):
    r"""
    deprecated: 'RigUnit_MathVectorRad' was renamed to 'RigVMFunction_MathVectorRad'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorLengthSquared(RigVMFunction_MathVectorBase):
    r"""
    Returns the squared length of the vector
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathVectorLengthSquared(RigVMFunction_MathVectorLengthSquared):
    r"""
    deprecated: 'RigUnit_MathVectorLengthSquared' was renamed to 'RigVMFunction_MathVectorLengthSquared'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathVectorLength(RigVMFunction_MathVectorBase):
    r"""
    Returns the length of the vector
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (float):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathVectorLength(RigVMFunction_MathVectorLength):
    r"""
    deprecated: 'RigUnit_MathVectorLength' was renamed to 'RigVMFunction_MathVectorLength'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathVectorDistance(RigVMFunction_MathVectorBase):
    r"""
    Returns the distance from A to B
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: float = 0.000000) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathVectorDistance(RigVMFunction_MathVectorDistance):
    r"""
    deprecated: 'RigUnit_MathVectorDistance' was renamed to 'RigVMFunction_MathVectorDistance'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathVectorCross(RigVMFunction_MathVectorBinaryOp):
    r"""
    Returns the cross product between two vectors
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorCross(RigVMFunction_MathVectorCross):
    r"""
    deprecated: 'RigUnit_MathVectorCross' was renamed to 'RigVMFunction_MathVectorCross'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorDot(RigVMFunction_MathVectorBase):
    r"""
    Returns the dot product between two vectors
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: float = 0.000000) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathVectorDot(RigVMFunction_MathVectorDot):
    r"""
    deprecated: 'RigUnit_MathVectorDot' was renamed to 'RigVMFunction_MathVectorDot'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathVectorUnit(RigVMFunction_MathVectorUnaryOp):
    r"""
    Returns the normalized value
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_MathVectorUnit(RigVMFunction_MathVectorUnit):
    r"""
    deprecated: 'RigUnit_MathVectorUnit' was renamed to 'RigVMFunction_MathVectorUnit'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorSetLength(RigVMFunction_MathVectorBase):
    r"""
    Sets the length of a given vector
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``length`` (float):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], length: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def length(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @length.setter
    def length(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorSetLength(RigVMFunction_MathVectorSetLength):
    r"""
    deprecated: 'RigUnit_MathVectorSetLength' was renamed to 'RigVMFunction_MathVectorSetLength'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], length: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorClampLength(RigVMFunction_MathVectorBase):
    r"""
    Clamps the length of a given vector between a minimum and maximum
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``maximum_length`` (float):  [Read-Write]
    - ``minimum_length`` (float):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], minimum_length: float = 0.000000, maximum_length: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def minimum_length(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum_length.setter
    def minimum_length(self, value: float) -> None:
        ...
    @property
    def maximum_length(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum_length.setter
    def maximum_length(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorClampLength(RigVMFunction_MathVectorClampLength):
    r"""
    deprecated: 'RigUnit_MathVectorClampLength' was renamed to 'RigVMFunction_MathVectorClampLength'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], minimum_length: float = 0.000000, maximum_length: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorMirror(RigVMFunction_MathVectorBase):
    r"""
    Mirror a vector about a normal vector.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``normal`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], normal: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def normal(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @normal.setter
    def normal(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorMirror(RigVMFunction_MathVectorMirror):
    r"""
    deprecated: 'RigUnit_MathVectorMirror' was renamed to 'RigVMFunction_MathVectorMirror'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], normal: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorAngle(RigVMFunction_MathVectorBase):
    r"""
    Returns the angle between two vectors in radians
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: float = 0.000000) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathVectorAngle(RigVMFunction_MathVectorAngle):
    r"""
    deprecated: 'RigUnit_MathVectorAngle' was renamed to 'RigVMFunction_MathVectorAngle'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: float = 0.000000) -> None:
        ...

class RigVMFunction_MathVectorParallel(RigVMFunction_MathVectorBase):
    r"""
    Returns true if the two vectors are parallel
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: bool = False) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathVectorParallel(RigVMFunction_MathVectorParallel):
    r"""
    deprecated: 'RigUnit_MathVectorParallel' was renamed to 'RigVMFunction_MathVectorParallel'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: bool = False) -> None:
        ...

class RigVMFunction_MathVectorOrthogonal(RigVMFunction_MathVectorBase):
    r"""
    Returns true if the two vectors are orthogonal
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: bool = False) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_MathVectorOrthogonal(RigVMFunction_MathVectorOrthogonal):
    r"""
    deprecated: 'RigUnit_MathVectorOrthogonal' was renamed to 'RigVMFunction_MathVectorOrthogonal'.
    """
    def __init__(self, a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], result: bool = False) -> None:
        ...

class RigVMFunction_MathVectorBezierFourPoint(RigVMFunction_MathVectorBase):
    r"""
    Returns the 4 point bezier interpolation
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bezier`` (RigVMFourPointBezier):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``t`` (float):  [Read-Write]
    - ``tangent`` (Vector):  [Read-Write]
    """
    def __init__(self, bezier: RigVMFourPointBezier = [], t: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000], tangent: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def bezier(self) -> RigVMFourPointBezier:
        r"""
        (RigVMFourPointBezier):  [Read-Write]
        """
        ...
    @bezier.setter
    def bezier(self, value: RigVMFourPointBezier) -> None:
        ...
    @property
    def t(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @t.setter
    def t(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def tangent(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorBezierFourPoint(RigVMFunction_MathVectorBezierFourPoint):
    r"""
    deprecated: 'RigUnit_MathVectorBezierFourPoint' was renamed to 'RigVMFunction_MathVectorBezierFourPoint'.
    """
    def __init__(self, bezier: RigVMFourPointBezier = [], t: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000], tangent: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFourPointBezier(StructBase):
    r"""
    Rig VMFour Point Bezier
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMMathLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``c`` (Vector):  [Read-Write]
    - ``d`` (Vector):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class CRFourPointBezier(RigVMFourPointBezier):
    r"""
    deprecated: 'CRFourPointBezier' was renamed to 'RigVMFourPointBezier'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_MathVectorMakeBezierFourPoint(RigVMFunction_MathVectorBase):
    r"""
    Creates a bezier four point
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bezier`` (RigVMFourPointBezier):  [Read-Write]
    """
    def __init__(self, bezier: RigVMFourPointBezier = []) -> None:
        ...
    @property
    def bezier(self) -> RigVMFourPointBezier:
        r"""
        (RigVMFourPointBezier):  [Read-Write]
        """
        ...
    @bezier.setter
    def bezier(self, value: RigVMFourPointBezier) -> None:
        ...

class RigUnit_MathVectorMakeBezierFourPoint(RigVMFunction_MathVectorMakeBezierFourPoint):
    r"""
    deprecated: 'RigUnit_MathVectorMakeBezierFourPoint' was renamed to 'RigVMFunction_MathVectorMakeBezierFourPoint'.
    """
    def __init__(self, bezier: RigVMFourPointBezier = []) -> None:
        ...

class RigVMFunction_MathVectorClampSpatially(RigVMFunction_MathVectorBase):
    r"""
    Clamps a position using a plane collision, cylindric collision or spherical collision.
    The collision happens both towards an inner envelope (minimum) and towards an outer envelope (maximum).
    You can disable the inner / outer envelope / collision by setting the minimum / maximum to 0.0.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis`` (AxisType):  [Read-Write]
    - ``debug_color`` (LinearColor):  [Read-Write]
    - ``debug_thickness`` (float):  [Read-Write]
    - ``draw_debug`` (bool):  [Read-Write]
    - ``maximum`` (float):  [Read-Write] This maximum allowed distance.
      A collision will occur towards the center at this wall.
      Note: For capsule this represents the length.
      Disable by setting to 0.0.
    - ``minimum`` (float):  [Read-Write] The minimum allowed distance at which a collision occurs.
      Note: For capsule this represents the radius.
      Disable by setting to 0.0.
    - ``result`` (Vector):  [Read-Write]
    - ``space`` (Transform):  [Read-Write] The space this spatial clamp happens within.
      The input position will be projected into this space.
    - ``type`` (RigVMClampSpatialMode):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], axis: AxisType = AxisType.NONE, type: RigVMClampSpatialMode = RigVMClampSpatialMode.PLANE, minimum: float = 0.000000, maximum: float = 0.000000, space: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], draw_debug: bool = False, debug_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], debug_thickness: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def axis(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write]
        """
        ...
    @axis.setter
    def axis(self, value: AxisType) -> None:
        ...
    @property
    def type(self) -> RigVMClampSpatialMode:
        r"""
        (RigVMClampSpatialMode):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: RigVMClampSpatialMode) -> None:
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Write] The minimum allowed distance at which a collision occurs.
        Note: For capsule this represents the radius.
        Disable by setting to 0.0.
        """
        ...
    @minimum.setter
    def minimum(self, value: float) -> None:
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Write] This maximum allowed distance.
        A collision will occur towards the center at this wall.
        Note: For capsule this represents the length.
        Disable by setting to 0.0.
        """
        ...
    @maximum.setter
    def maximum(self, value: float) -> None:
        ...
    @property
    def space(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The space this spatial clamp happens within.
        The input position will be projected into this space.
        """
        ...
    @space.setter
    def space(self, value: Transform) -> None:
        ...
    @property
    def draw_debug(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_debug.setter
    def draw_debug(self, value: bool) -> None:
        ...
    @property
    def debug_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @debug_color.setter
    def debug_color(self, value: LinearColor) -> None:
        ...
    @property
    def debug_thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @debug_thickness.setter
    def debug_thickness(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorClampSpatially(RigVMFunction_MathVectorClampSpatially):
    r"""
    deprecated: 'RigUnit_MathVectorClampSpatially' was renamed to 'RigVMFunction_MathVectorClampSpatially'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], axis: AxisType = AxisType.NONE, type: RigVMClampSpatialMode = RigVMClampSpatialMode.PLANE, minimum: float = 0.000000, maximum: float = 0.000000, space: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], draw_debug: bool = False, debug_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], debug_thickness: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathIntersectPlane(RigVMFunction_MathVectorBase):
    r"""
    Intersects a plane with a vector given a start and direction
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``direction`` (Vector):  [Read-Write]
    - ``distance`` (float):  [Read-Write]
    - ``plane_normal`` (Vector):  [Read-Write]
    - ``plane_point`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``start`` (Vector):  [Read-Write]
    """
    def __init__(self, start: Vector = [0.000000, 0.000000, 0.000000], direction: Vector = [0.000000, 0.000000, 0.000000], plane_point: Vector = [0.000000, 0.000000, 0.000000], plane_normal: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000], distance: float = 0.000000) -> None:
        ...
    @property
    def start(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @start.setter
    def start(self, value: Vector) -> None:
        ...
    @property
    def direction(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @direction.setter
    def direction(self, value: Vector) -> None:
        ...
    @property
    def plane_point(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @plane_point.setter
    def plane_point(self, value: Vector) -> None:
        ...
    @property
    def plane_normal(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @plane_normal.setter
    def plane_normal(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def distance(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathIntersectPlane(RigVMFunction_MathIntersectPlane):
    r"""
    deprecated: 'RigUnit_MathIntersectPlane' was renamed to 'RigVMFunction_MathIntersectPlane'.
    """
    def __init__(self, start: Vector = [0.000000, 0.000000, 0.000000], direction: Vector = [0.000000, 0.000000, 0.000000], plane_point: Vector = [0.000000, 0.000000, 0.000000], plane_normal: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000], distance: float = 0.000000) -> None:
        ...

class RigVMFunction_MathDistanceToPlane(RigVMFunction_MathVectorBase):
    r"""
    Find the point on the plane that is closest to the given point and the distance between them.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``closest_point_on_plane`` (Vector):  [Read-Write]
    - ``plane_normal`` (Vector):  [Read-Write]
    - ``plane_point`` (Vector):  [Read-Write]
    - ``point`` (Vector):  [Read-Write]
    - ``signed_distance`` (float):  [Read-Write]
    """
    def __init__(self, point: Vector = [0.000000, 0.000000, 0.000000], plane_point: Vector = [0.000000, 0.000000, 0.000000], plane_normal: Vector = [0.000000, 0.000000, 0.000000], closest_point_on_plane: Vector = [0.000000, 0.000000, 0.000000], signed_distance: float = 0.000000) -> None:
        ...
    @property
    def point(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @point.setter
    def point(self, value: Vector) -> None:
        ...
    @property
    def plane_point(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @plane_point.setter
    def plane_point(self, value: Vector) -> None:
        ...
    @property
    def plane_normal(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @plane_normal.setter
    def plane_normal(self, value: Vector) -> None:
        ...
    @property
    def closest_point_on_plane(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def signed_distance(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MathDistanceToPlane(RigVMFunction_MathDistanceToPlane):
    r"""
    deprecated: 'RigUnit_MathDistanceToPlane' was renamed to 'RigVMFunction_MathDistanceToPlane'.
    """
    def __init__(self, point: Vector = [0.000000, 0.000000, 0.000000], plane_point: Vector = [0.000000, 0.000000, 0.000000], plane_normal: Vector = [0.000000, 0.000000, 0.000000], closest_point_on_plane: Vector = [0.000000, 0.000000, 0.000000], signed_distance: float = 0.000000) -> None:
        ...

class RigVMFunction_MathVectorMakeRelative(RigVMFunction_MathVectorBase):
    r"""
    Returns the relative local vector within a parent's vector
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_`` (Vector):  [Read-Write]
    - ``local`` (Vector):  [Read-Write]
    - ``parent`` (Vector):  [Read-Write]
    """
    def __init__(self, global_: Vector = [0.000000, 0.000000, 0.000000], parent: Vector = [0.000000, 0.000000, 0.000000], local: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def global_(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @global_.setter
    def global_(self, value: Vector) -> None:
        ...
    @property
    def parent(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @parent.setter
    def parent(self, value: Vector) -> None:
        ...
    @property
    def local(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorMakeRelative(RigVMFunction_MathVectorMakeRelative):
    r"""
    deprecated: 'RigUnit_MathVectorMakeRelative' was renamed to 'RigVMFunction_MathVectorMakeRelative'.
    """
    def __init__(self, global_: Vector = [0.000000, 0.000000, 0.000000], parent: Vector = [0.000000, 0.000000, 0.000000], local: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorMakeAbsolute(RigVMFunction_MathVectorBase):
    r"""
    Returns the absolute global vector within a parent's vector
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_`` (Vector):  [Read-Write]
    - ``local`` (Vector):  [Read-Write]
    - ``parent`` (Vector):  [Read-Write]
    """
    def __init__(self, local: Vector = [0.000000, 0.000000, 0.000000], parent: Vector = [0.000000, 0.000000, 0.000000], global_: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def local(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @local.setter
    def local(self, value: Vector) -> None:
        ...
    @property
    def parent(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @parent.setter
    def parent(self, value: Vector) -> None:
        ...
    @property
    def global_(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorMakeAbsolute(RigVMFunction_MathVectorMakeAbsolute):
    r"""
    deprecated: 'RigUnit_MathVectorMakeAbsolute' was renamed to 'RigVMFunction_MathVectorMakeAbsolute'.
    """
    def __init__(self, local: Vector = [0.000000, 0.000000, 0.000000], parent: Vector = [0.000000, 0.000000, 0.000000], global_: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorMirrorTransform(RigVMFunction_MathVectorBase):
    r"""
    Mirror a vector about a central transform.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis_to_flip`` (AxisType):  [Read-Write] the axis to flip for rotations
    - ``central_transform`` (Transform):  [Read-Write] The transform about which to mirror
    - ``mirror_axis`` (AxisType):  [Read-Write] the axis to mirror against
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], mirror_axis: AxisType = AxisType.NONE, axis_to_flip: AxisType = AxisType.NONE, central_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def mirror_axis(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] the axis to mirror against
        """
        ...
    @mirror_axis.setter
    def mirror_axis(self, value: AxisType) -> None:
        ...
    @property
    def axis_to_flip(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] the axis to flip for rotations
        """
        ...
    @axis_to_flip.setter
    def axis_to_flip(self, value: AxisType) -> None:
        ...
    @property
    def central_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform about which to mirror
        """
        ...
    @central_transform.setter
    def central_transform(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_MathVectorMirrorTransform(RigVMFunction_MathVectorMirrorTransform):
    r"""
    deprecated: 'RigUnit_MathVectorMirrorTransform' was renamed to 'RigVMFunction_MathVectorMirrorTransform'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], mirror_axis: AxisType = AxisType.NONE, axis_to_flip: AxisType = AxisType.NONE, central_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_MathVectorArraySum(RigVMFunction_MathVectorBase):
    r"""
    Returns the sum of the given array
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``array`` (Array[Vector]):  [Read-Write]
    - ``sum`` (Vector):  [Read-Write]
    """
    def __init__(self, array: Array[Vector] = [], sum: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def array(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Write]
        """
        ...
    @array.setter
    def array(self, value: Array[Vector]) -> None:
        ...
    @property
    def sum(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigVMFunction_MathVectorArrayAverage(RigVMFunction_MathVectorBase):
    r"""
    Returns the average of the given array
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_MathVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``array`` (Array[Vector]):  [Read-Write]
    - ``average`` (Vector):  [Read-Write]
    """
    def __init__(self, array: Array[Vector] = [], average: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def array(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Write]
        """
        ...
    @array.setter
    def array(self, value: Array[Vector]) -> None:
        ...
    @property
    def average(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigVMFunction_NoiseFloat(RigVMFunction_MathBase):
    r"""
    Generates a float through a noise fluctuation process between a min and a max through speed
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Noise.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frequency`` (float):  [Read-Write]
    - ``maximum`` (float):  [Read-Write]
    - ``minimum`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``speed`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, speed: float = 0.000000, frequency: float = 0.000000, minimum: float = 0.000000, maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def speed(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @speed.setter
    def speed(self, value: float) -> None:
        ...
    @property
    def frequency(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @frequency.setter
    def frequency(self, value: float) -> None:
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum.setter
    def minimum(self, value: float) -> None:
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum.setter
    def maximum(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_NoiseFloat(RigVMFunction_NoiseFloat):
    r"""
    deprecated: 'RigUnit_NoiseFloat' was renamed to 'RigVMFunction_NoiseFloat'.
    """
    def __init__(self, value: float = 0.000000, speed: float = 0.000000, frequency: float = 0.000000, minimum: float = 0.000000, maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_NoiseDouble(RigVMFunction_MathBase):
    r"""
    Generates a float through a noise fluctuation process between a min and a max through speed
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Noise.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frequency`` (double):  [Read-Write]
    - ``maximum`` (double):  [Read-Write]
    - ``minimum`` (double):  [Read-Write]
    - ``result`` (double):  [Read-Write]
    - ``speed`` (double):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, speed: float = 0.000000, frequency: float = 0.000000, minimum: float = 0.000000, maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def speed(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @speed.setter
    def speed(self, value: float) -> None:
        ...
    @property
    def frequency(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @frequency.setter
    def frequency(self, value: float) -> None:
        ...
    @property
    def minimum(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @minimum.setter
    def minimum(self, value: float) -> None:
        ...
    @property
    def maximum(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @maximum.setter
    def maximum(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...

class RigUnit_NoiseDouble(RigVMFunction_NoiseDouble):
    r"""
    deprecated: 'RigUnit_NoiseDouble' was renamed to 'RigVMFunction_NoiseDouble'.
    """
    def __init__(self, value: float = 0.000000, speed: float = 0.000000, frequency: float = 0.000000, minimum: float = 0.000000, maximum: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_NoiseVector(RigVMFunction_MathBase):
    r"""
    Generates a vector through a noise fluctuation process between a min and a max through speed
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Noise.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frequency`` (Vector):  [Read-Write]
    - ``maximum`` (float):  [Read-Write]
    - ``minimum`` (float):  [Read-Write]
    - ``position`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``speed`` (Vector):  [Read-Write]
    """
    def __init__(self, position: Vector = [0.000000, 0.000000, 0.000000], speed: Vector = [0.000000, 0.000000, 0.000000], frequency: Vector = [0.000000, 0.000000, 0.000000], minimum: float = 0.000000, maximum: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...
    @property
    def speed(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @speed.setter
    def speed(self, value: Vector) -> None:
        ...
    @property
    def frequency(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @frequency.setter
    def frequency(self, value: Vector) -> None:
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum.setter
    def minimum(self, value: float) -> None:
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum.setter
    def maximum(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_NoiseVector(RigVMFunction_NoiseVector):
    r"""
    deprecated: 'RigUnit_NoiseVector' was renamed to 'RigVMFunction_NoiseVector'.
    """
    def __init__(self, position: Vector = [0.000000, 0.000000, 0.000000], speed: Vector = [0.000000, 0.000000, 0.000000], frequency: Vector = [0.000000, 0.000000, 0.000000], minimum: float = 0.000000, maximum: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_NoiseVector2(RigVMFunction_MathBase):
    r"""
    Generates a vector through a noise fluctuation process between a min and a max through speed
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Noise.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frequency`` (Vector):  [Read-Write]
    - ``maximum`` (double):  [Read-Write]
    - ``minimum`` (double):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``speed`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], speed: Vector = [0.000000, 0.000000, 0.000000], frequency: Vector = [0.000000, 0.000000, 0.000000], minimum: float = 0.000000, maximum: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def speed(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @speed.setter
    def speed(self, value: Vector) -> None:
        ...
    @property
    def frequency(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @frequency.setter
    def frequency(self, value: Vector) -> None:
        ...
    @property
    def minimum(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @minimum.setter
    def minimum(self, value: float) -> None:
        ...
    @property
    def maximum(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @maximum.setter
    def maximum(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_NoiseVector2(RigVMFunction_NoiseVector2):
    r"""
    deprecated: 'RigUnit_NoiseVector2' was renamed to 'RigVMFunction_NoiseVector2'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], speed: Vector = [0.000000, 0.000000, 0.000000], frequency: Vector = [0.000000, 0.000000, 0.000000], minimum: float = 0.000000, maximum: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_RandomFloat(RigVMFunction_MathBase):
    r"""
    Generates a random float between a min and a max
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Random.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration`` (float):  [Read-Write] The duration at which the number won't change.
      Use 0 for a different number every time.
      A negative number (for ex: -1) results in an infinite duration.
    - ``maximum`` (float):  [Read-Write]
    - ``minimum`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``seed`` (int32):  [Read-Write]
    """
    def __init__(self, seed: int = 0, minimum: float = 0.000000, maximum: float = 0.000000, duration: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def seed(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @seed.setter
    def seed(self, value: int) -> None:
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum.setter
    def minimum(self, value: float) -> None:
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum.setter
    def maximum(self, value: float) -> None:
        ...
    @property
    def duration(self) -> float:
        r"""
        (float):  [Read-Write] The duration at which the number won't change.
        Use 0 for a different number every time.
        A negative number (for ex: -1) results in an infinite duration.
        """
        ...
    @duration.setter
    def duration(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_RandomFloat(RigVMFunction_RandomFloat):
    r"""
    deprecated: 'RigUnit_RandomFloat' was renamed to 'RigVMFunction_RandomFloat'.
    """
    def __init__(self, seed: int = 0, minimum: float = 0.000000, maximum: float = 0.000000, duration: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_RandomVector(RigVMFunction_MathBase):
    r"""
    Generates a random vector between a min and a max
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Random.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration`` (float):  [Read-Write] The duration at which the number won't change.
      Use 0 for a different number every time.
      A negative number (for ex: -1) results in an infinite duration.
    - ``maximum`` (float):  [Read-Write]
    - ``minimum`` (float):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``seed`` (int32):  [Read-Write]
    """
    def __init__(self, seed: int = 0, minimum: float = 0.000000, maximum: float = 0.000000, duration: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def seed(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @seed.setter
    def seed(self, value: int) -> None:
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum.setter
    def minimum(self, value: float) -> None:
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum.setter
    def maximum(self, value: float) -> None:
        ...
    @property
    def duration(self) -> float:
        r"""
        (float):  [Read-Write] The duration at which the number won't change.
        Use 0 for a different number every time.
        A negative number (for ex: -1) results in an infinite duration.
        """
        ...
    @duration.setter
    def duration(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_RandomVector(RigVMFunction_RandomVector):
    r"""
    deprecated: 'RigUnit_RandomVector' was renamed to 'RigVMFunction_RandomVector'.
    """
    def __init__(self, seed: int = 0, minimum: float = 0.000000, maximum: float = 0.000000, duration: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMMirrorSettings(StructBase):
    r"""
    Rig VMMirror Settings
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMMathLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis_to_flip`` (AxisType):  [Read-Write] the axis to flip for rotations
    - ``mirror_axis`` (AxisType):  [Read-Write] the axis to mirror against
    - ``replace_string`` (str):  [Read-Write] the string to replace the search occurrences with
    - ``search_string`` (str):  [Read-Write] the string to search for
    """
    def __init__(self, mirror_axis: AxisType = AxisType.NONE, axis_to_flip: AxisType = AxisType.NONE, search_string: str = "", replace_string: str = "") -> None:
        ...
    @property
    def mirror_axis(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] the axis to mirror against
        """
        ...
    @mirror_axis.setter
    def mirror_axis(self, value: AxisType) -> None:
        ...
    @property
    def axis_to_flip(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] the axis to flip for rotations
        """
        ...
    @axis_to_flip.setter
    def axis_to_flip(self, value: AxisType) -> None:
        ...
    @property
    def search_string(self) -> str:
        r"""
        (str):  [Read-Write] the string to search for
        """
        ...
    @search_string.setter
    def search_string(self, value: str) -> None:
        ...
    @property
    def replace_string(self) -> str:
        r"""
        (str):  [Read-Write] the string to replace the search occurrences with
        """
        ...
    @replace_string.setter
    def replace_string(self, value: str) -> None:
        ...

class RigMirrorSettings(RigVMMirrorSettings):
    r"""
    deprecated: 'RigMirrorSettings' was renamed to 'RigVMMirrorSettings'.
    """
    def __init__(self, mirror_axis: AxisType = AxisType.NONE, axis_to_flip: AxisType = AxisType.NONE, search_string: str = "", replace_string: str = "") -> None:
        ...

class RigVMSimPoint(StructBase):
    r"""
    Rig VMSim Point
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMMathLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``inherit_motion`` (float):  [Read-Write] Defines how much the point will inherit motion from its input.
      This does not have an effect on passive (mass == 0.0) points.
      Values can be higher than 1 due to timestep - but they are clamped internally.
    - ``linear_damping`` (float):  [Read-Write] The linear damping of the point
    - ``linear_velocity`` (Vector):  [Read-Write] The velocity of the point per second
    - ``mass`` (float):  [Read-Write] The mass of the point
    - ``position`` (Vector):  [Read-Write] The position of the point
    - ``size`` (float):  [Read-Write] Size of the point - only used for collision
    """
    def __init__(self) -> None:
        ...

class CRSimPoint(RigVMSimPoint):
    r"""
    deprecated: 'CRSimPoint' was renamed to 'RigVMSimPoint'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_ControlFlowBase(RigVMStruct):
    r"""
    Rig VMFunction Control Flow Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_ControlFlow.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_ControlFlowBranch(RigVMFunction_ControlFlowBase):
    r"""
    Executes either the True or False branch based on the condition
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_ControlFlow.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``completed`` (RigVMExecuteContext):  [Read-Write]
    - ``condition`` (bool):  [Read-Write]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write]
    - ``false`` (RigVMExecuteContext):  [Read-Write]
    - ``true`` (RigVMExecuteContext):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], condition: bool = False, true: RigVMExecuteContext = [], false: RigVMExecuteContext = [], completed: RigVMExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> RigVMExecuteContext:
        r"""
        (RigVMExecuteContext):  [Read-Write]
        """
        ...
    @execute_context.setter
    def execute_context(self, value: RigVMExecuteContext) -> None:
        ...
    @property
    def condition(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @condition.setter
    def condition(self, value: bool) -> None:
        ...
    @property
    def true(self) -> RigVMExecuteContext:
        r"""
        (RigVMExecuteContext):  [Read-Only]
        """
        ...
    @property
    def false(self) -> RigVMExecuteContext:
        r"""
        (RigVMExecuteContext):  [Read-Only]
        """
        ...
    @property
    def completed(self) -> RigVMExecuteContext:
        r"""
        (RigVMExecuteContext):  [Read-Only]
        """
        ...

class RigVMFunction_NameBase(RigVMStruct):
    r"""
    Rig VMFunction Name Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Name.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_NameBase(RigVMFunction_NameBase):
    r"""
    deprecated: 'RigUnit_NameBase' was renamed to 'RigVMFunction_NameBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_NameConcat(RigVMFunction_NameBase):
    r"""
    Concatenates two strings together to make a new string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Name.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Name):  [Read-Write]
    - ``b`` (Name):  [Read-Write]
    - ``result`` (Name):  [Read-Write]
    """
    def __init__(self, a: Name = "None", b: Name = "None", result: Name = "None") -> None:
        ...
    @property
    def a(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Name) -> None:
        ...
    @property
    def b(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Name) -> None:
        ...
    @property
    def result(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...

class RigUnit_NameConcat(RigVMFunction_NameConcat):
    r"""
    deprecated: 'RigUnit_NameConcat' was renamed to 'RigVMFunction_NameConcat'.
    """
    def __init__(self, a: Name = "None", b: Name = "None", result: Name = "None") -> None:
        ...

class RigVMFunction_NameTruncate(RigVMFunction_NameBase):
    r"""
    Returns the left or right most characters from the string chopping the given number of characters from the start or the end
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Name.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``chopped`` (Name):  [Read-Write] the part of the name that has been chopped off
    - ``count`` (int32):  [Read-Write] Number of characters to remove from left or right
    - ``from_end`` (bool):  [Read-Write] if set to true the characters will be removed from the end
    - ``name`` (Name):  [Read-Write]
    - ``remainder`` (Name):  [Read-Write] the part of the string without the chopped characters
    """
    def __init__(self, name: Name = "None", count: int = 0, from_end: bool = False, remainder: Name = "None", chopped: Name = "None") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def count(self) -> int:
        r"""
        (int32):  [Read-Write] Number of characters to remove from left or right
        """
        ...
    @count.setter
    def count(self, value: int) -> None:
        ...
    @property
    def from_end(self) -> bool:
        r"""
        (bool):  [Read-Write] if set to true the characters will be removed from the end
        """
        ...
    @from_end.setter
    def from_end(self, value: bool) -> None:
        ...
    @property
    def remainder(self) -> Name:
        r"""
        (Name):  [Read-Only] the part of the string without the chopped characters
        """
        ...
    @property
    def chopped(self) -> Name:
        r"""
        (Name):  [Read-Only] the part of the name that has been chopped off
        """
        ...

class RigUnit_NameTruncate(RigVMFunction_NameTruncate):
    r"""
    deprecated: 'RigUnit_NameTruncate' was renamed to 'RigVMFunction_NameTruncate'.
    """
    def __init__(self, name: Name = "None", count: int = 0, from_end: bool = False, remainder: Name = "None", chopped: Name = "None") -> None:
        ...

class RigVMFunction_NameReplace(RigVMFunction_NameBase):
    r"""
    Replace all occurrences of a substring in this string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Name.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``new`` (Name):  [Read-Write]
    - ``old`` (Name):  [Read-Write]
    - ``result`` (Name):  [Read-Write]
    """
    def __init__(self, name: Name = "None", old: Name = "None", new: Name = "None", result: Name = "None") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def old(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @old.setter
    def old(self, value: Name) -> None:
        ...
    @property
    def new(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @new.setter
    def new(self, value: Name) -> None:
        ...
    @property
    def result(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...

class RigUnit_NameReplace(RigVMFunction_NameReplace):
    r"""
    deprecated: 'RigUnit_NameReplace' was renamed to 'RigVMFunction_NameReplace'.
    """
    def __init__(self, name: Name = "None", old: Name = "None", new: Name = "None", result: Name = "None") -> None:
        ...

class RigVMFunction_EndsWith(RigVMFunction_NameBase):
    r"""
    Tests whether this string ends with given string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Name.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ending`` (Name):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, name: Name = "None", ending: Name = "None", result: bool = False) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def ending(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @ending.setter
    def ending(self, value: Name) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_EndsWith(RigVMFunction_EndsWith):
    r"""
    deprecated: 'RigUnit_EndsWith' was renamed to 'RigVMFunction_EndsWith'.
    """
    def __init__(self, name: Name = "None", ending: Name = "None", result: bool = False) -> None:
        ...

class RigVMFunction_StartsWith(RigVMFunction_NameBase):
    r"""
    Tests whether this string starts with given string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Name.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    - ``start`` (Name):  [Read-Write]
    """
    def __init__(self, name: Name = "None", start: Name = "None", result: bool = False) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def start(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @start.setter
    def start(self, value: Name) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_StartsWith(RigVMFunction_StartsWith):
    r"""
    deprecated: 'RigUnit_StartsWith' was renamed to 'RigVMFunction_StartsWith'.
    """
    def __init__(self, name: Name = "None", start: Name = "None", result: bool = False) -> None:
        ...

class RigVMFunction_Contains(RigVMFunction_NameBase):
    r"""
    Returns true or false if a given name exists in another given name
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Name.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    - ``search`` (Name):  [Read-Write]
    """
    def __init__(self, name: Name = "None", search: Name = "None", result: bool = False) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def search(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @search.setter
    def search(self, value: Name) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_Contains(RigVMFunction_Contains):
    r"""
    deprecated: 'RigUnit_Contains' was renamed to 'RigVMFunction_Contains'.
    """
    def __init__(self, name: Name = "None", search: Name = "None", result: bool = False) -> None:
        ...

class RigVMFunction_StringBase(RigVMStruct):
    r"""
    Rig VMFunction String Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_StringBase(RigVMFunction_StringBase):
    r"""
    deprecated: 'RigUnit_StringBase' was renamed to 'RigVMFunction_StringBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_StringConcat(RigVMFunction_StringBase):
    r"""
    Concatenates two strings together to make a new string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (str):  [Read-Write]
    - ``b`` (str):  [Read-Write]
    - ``result`` (str):  [Read-Write]
    """
    def __init__(self, a: str = "", b: str = "", result: str = "") -> None:
        ...
    @property
    def a(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: str) -> None:
        ...
    @property
    def b(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: str) -> None:
        ...
    @property
    def result(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_StringConcat(RigVMFunction_StringConcat):
    r"""
    deprecated: 'RigUnit_StringConcat' was renamed to 'RigVMFunction_StringConcat'.
    """
    def __init__(self, a: str = "", b: str = "", result: str = "") -> None:
        ...

class RigVMFunction_StringTruncate(RigVMFunction_StringBase):
    r"""
    Returns the left or right most characters from the string chopping the given number of characters from the start or the end
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``chopped`` (str):  [Read-Write] the part of the name that has been chopped off
    - ``count`` (int32):  [Read-Write] Number of characters to remove from left or right
    - ``from_end`` (bool):  [Read-Write] if set to true the characters will be removed from the end
    - ``name`` (str):  [Read-Write]
    - ``remainder`` (str):  [Read-Write] the part of the string without the chopped characters
    """
    def __init__(self, name: str = "", count: int = 0, from_end: bool = False, remainder: str = "", chopped: str = "") -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: str) -> None:
        ...
    @property
    def count(self) -> int:
        r"""
        (int32):  [Read-Write] Number of characters to remove from left or right
        """
        ...
    @count.setter
    def count(self, value: int) -> None:
        ...
    @property
    def from_end(self) -> bool:
        r"""
        (bool):  [Read-Write] if set to true the characters will be removed from the end
        """
        ...
    @from_end.setter
    def from_end(self, value: bool) -> None:
        ...
    @property
    def remainder(self) -> str:
        r"""
        (str):  [Read-Only] the part of the string without the chopped characters
        """
        ...
    @property
    def chopped(self) -> str:
        r"""
        (str):  [Read-Only] the part of the name that has been chopped off
        """
        ...

class RigUnit_StringTruncate(RigVMFunction_StringTruncate):
    r"""
    deprecated: 'RigUnit_StringTruncate' was renamed to 'RigVMFunction_StringTruncate'.
    """
    def __init__(self, name: str = "", count: int = 0, from_end: bool = False, remainder: str = "", chopped: str = "") -> None:
        ...

class RigVMFunction_StringReplace(RigVMFunction_StringBase):
    r"""
    Replace all occurrences of a substring in this string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (str):  [Read-Write]
    - ``new`` (str):  [Read-Write]
    - ``old`` (str):  [Read-Write]
    - ``result`` (str):  [Read-Write]
    """
    def __init__(self, name: str = "", old: str = "", new: str = "", result: str = "") -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: str) -> None:
        ...
    @property
    def old(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @old.setter
    def old(self, value: str) -> None:
        ...
    @property
    def new(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @new.setter
    def new(self, value: str) -> None:
        ...
    @property
    def result(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_StringReplace(RigVMFunction_StringReplace):
    r"""
    deprecated: 'RigUnit_StringReplace' was renamed to 'RigVMFunction_StringReplace'.
    """
    def __init__(self, name: str = "", old: str = "", new: str = "", result: str = "") -> None:
        ...

class RigVMFunction_StringEndsWith(RigVMFunction_StringBase):
    r"""
    Tests whether this string ends with given string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ending`` (str):  [Read-Write]
    - ``name`` (str):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, name: str = "", ending: str = "", result: bool = False) -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: str) -> None:
        ...
    @property
    def ending(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @ending.setter
    def ending(self, value: str) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_StringEndsWith(RigVMFunction_StringEndsWith):
    r"""
    deprecated: 'RigUnit_StringEndsWith' was renamed to 'RigVMFunction_StringEndsWith'.
    """
    def __init__(self, name: str = "", ending: str = "", result: bool = False) -> None:
        ...

class RigVMFunction_StringStartsWith(RigVMFunction_StringBase):
    r"""
    Tests whether this string starts with given string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (str):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    - ``start`` (str):  [Read-Write]
    """
    def __init__(self, name: str = "", start: str = "", result: bool = False) -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: str) -> None:
        ...
    @property
    def start(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @start.setter
    def start(self, value: str) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_StringStartsWith(RigVMFunction_StringStartsWith):
    r"""
    deprecated: 'RigUnit_StringStartsWith' was renamed to 'RigVMFunction_StringStartsWith'.
    """
    def __init__(self, name: str = "", start: str = "", result: bool = False) -> None:
        ...

class RigVMFunction_StringContains(RigVMFunction_StringBase):
    r"""
    Returns true or false if a given name exists in another given name
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (str):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    - ``search`` (str):  [Read-Write]
    """
    def __init__(self, name: str = "", search: str = "", result: bool = False) -> None:
        ...
    @property
    def name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: str) -> None:
        ...
    @property
    def search(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @search.setter
    def search(self, value: str) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_StringContains(RigVMFunction_StringContains):
    r"""
    deprecated: 'RigUnit_StringContains' was renamed to 'RigVMFunction_StringContains'.
    """
    def __init__(self, name: str = "", search: str = "", result: bool = False) -> None:
        ...

class RigVMFunction_StringLength(RigVMFunction_StringBase):
    r"""
    Returns the length of a string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``length`` (int32):  [Read-Write]
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, value: str = "", length: int = 0) -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...
    @property
    def length(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_StringLength(RigVMFunction_StringLength):
    r"""
    deprecated: 'RigUnit_StringLength' was renamed to 'RigVMFunction_StringLength'.
    """
    def __init__(self, value: str = "", length: int = 0) -> None:
        ...

class RigVMFunction_StringTrimWhitespace(RigVMFunction_StringBase):
    r"""
    Trims the whitespace from a string (start and end)
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (str):  [Read-Write]
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, value: str = "", result: str = "") -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...
    @property
    def result(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_StringTrimWhitespace(RigVMFunction_StringTrimWhitespace):
    r"""
    deprecated: 'RigUnit_StringTrimWhitespace' was renamed to 'RigVMFunction_StringTrimWhitespace'.
    """
    def __init__(self, value: str = "", result: str = "") -> None:
        ...

class RigVMFunction_StringToUppercase(RigVMFunction_StringBase):
    r"""
    Converts the string to upper case
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (str):  [Read-Write]
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, value: str = "", result: str = "") -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...
    @property
    def result(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_StringToUppercase(RigVMFunction_StringToUppercase):
    r"""
    deprecated: 'RigUnit_StringToUppercase' was renamed to 'RigVMFunction_StringToUppercase'.
    """
    def __init__(self, value: str = "", result: str = "") -> None:
        ...

class RigVMFunction_StringToLowercase(RigVMFunction_StringBase):
    r"""
    Converts the string to lower case
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (str):  [Read-Write]
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, value: str = "", result: str = "") -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...
    @property
    def result(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_StringToLowercase(RigVMFunction_StringToLowercase):
    r"""
    deprecated: 'RigUnit_StringToLowercase' was renamed to 'RigVMFunction_StringToLowercase'.
    """
    def __init__(self, value: str = "", result: str = "") -> None:
        ...

class RigVMFunction_StringReverse(RigVMFunction_StringBase):
    r"""
    Returns the reverse of the input string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``reverse`` (str):  [Read-Write]
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, value: str = "", reverse: str = "") -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...
    @property
    def reverse(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_StringReverse(RigVMFunction_StringReverse):
    r"""
    deprecated: 'RigUnit_StringReverse' was renamed to 'RigVMFunction_StringReverse'.
    """
    def __init__(self, value: str = "", reverse: str = "") -> None:
        ...

class RigVMFunction_StringLeft(RigVMFunction_StringBase):
    r"""
    Returns the left most characters of a string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``count`` (int32):  [Read-Write]
    - ``result`` (str):  [Read-Write]
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, value: str = "", count: int = 0, result: str = "") -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...
    @property
    def count(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @count.setter
    def count(self, value: int) -> None:
        ...
    @property
    def result(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_StringLeft(RigVMFunction_StringLeft):
    r"""
    deprecated: 'RigUnit_StringLeft' was renamed to 'RigVMFunction_StringLeft'.
    """
    def __init__(self, value: str = "", count: int = 0, result: str = "") -> None:
        ...

class RigVMFunction_StringRight(RigVMFunction_StringBase):
    r"""
    Returns the right most characters of a string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``count`` (int32):  [Read-Write]
    - ``result`` (str):  [Read-Write]
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, value: str = "", count: int = 0, result: str = "") -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...
    @property
    def count(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @count.setter
    def count(self, value: int) -> None:
        ...
    @property
    def result(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_StringRight(RigVMFunction_StringRight):
    r"""
    deprecated: 'RigUnit_StringRight' was renamed to 'RigVMFunction_StringRight'.
    """
    def __init__(self, value: str = "", count: int = 0, result: str = "") -> None:
        ...

class RigVMFunction_StringMiddle(RigVMFunction_StringBase):
    r"""
    Returns the middle section of a string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``count`` (int32):  [Read-Write] if count is set to -1 all character from Start will be returned
    - ``result`` (str):  [Read-Write]
    - ``start`` (int32):  [Read-Write] the index of the first character
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, value: str = "", start: int = 0, count: int = 0, result: str = "") -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...
    @property
    def start(self) -> int:
        r"""
        (int32):  [Read-Write] the index of the first character
        """
        ...
    @start.setter
    def start(self, value: int) -> None:
        ...
    @property
    def count(self) -> int:
        r"""
        (int32):  [Read-Write] if count is set to -1 all character from Start will be returned
        """
        ...
    @count.setter
    def count(self, value: int) -> None:
        ...
    @property
    def result(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_StringMiddle(RigVMFunction_StringMiddle):
    r"""
    deprecated: 'RigUnit_StringMiddle' was renamed to 'RigVMFunction_StringMiddle'.
    """
    def __init__(self, value: str = "", start: int = 0, count: int = 0, result: str = "") -> None:
        ...

class RigVMFunction_StringFind(RigVMFunction_StringBase):
    r"""
    Finds a string within another string
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``found`` (bool):  [Read-Write]
    - ``index`` (int32):  [Read-Write]
    - ``search`` (str):  [Read-Write]
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, value: str = "", search: str = "", found: bool = False, index: int = 0) -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...
    @property
    def search(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @search.setter
    def search(self, value: str) -> None:
        ...
    @property
    def found(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_StringFind(RigVMFunction_StringFind):
    r"""
    deprecated: 'RigUnit_StringFind' was renamed to 'RigVMFunction_StringFind'.
    """
    def __init__(self, value: str = "", search: str = "", found: bool = False, index: int = 0) -> None:
        ...

class RigVMFunction_StringSplit(RigVMFunction_StringBase):
    r"""
    Splits a string into multiple sections given a separator
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Array[str]):  [Read-Write]
    - ``separator`` (str):  [Read-Write]
    - ``value`` (str):  [Read-Write]
    """
    def __init__(self, value: str = "", separator: str = "", result: Array[str] = []) -> None:
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: str) -> None:
        ...
    @property
    def separator(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @separator.setter
    def separator(self, value: str) -> None:
        ...
    @property
    def result(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Only]
        """
        ...

class RigUnit_StringSplit(RigVMFunction_StringSplit):
    r"""
    deprecated: 'RigUnit_StringSplit' was renamed to 'RigVMFunction_StringSplit'.
    """
    def __init__(self, value: str = "", separator: str = "", result: Array[str] = []) -> None:
        ...

class RigVMFunction_StringJoin(RigVMFunction_StringBase):
    r"""
    Joins a string into multiple sections given a separator
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (str):  [Read-Write]
    - ``separator`` (str):  [Read-Write]
    - ``values`` (Array[str]):  [Read-Write]
    """
    def __init__(self, values: Array[str] = [], separator: str = "", result: str = "") -> None:
        ...
    @property
    def values(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write]
        """
        ...
    @values.setter
    def values(self, value: Array[str]) -> None:
        ...
    @property
    def separator(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @separator.setter
    def separator(self, value: str) -> None:
        ...
    @property
    def result(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_StringJoin(RigVMFunction_StringJoin):
    r"""
    deprecated: 'RigUnit_StringJoin' was renamed to 'RigVMFunction_StringJoin'.
    """
    def __init__(self, values: Array[str] = [], separator: str = "", result: str = "") -> None:
        ...

class RigVMFunction_StringPadInteger(RigVMFunction_StringBase):
    r"""
    Converts an integer number to a string with padding
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_String.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``digits`` (int32):  [Read-Write]
    - ``result`` (str):  [Read-Write]
    - ``value`` (int32):  [Read-Write]
    """
    def __init__(self, value: int = 0, digits: int = 0, result: str = "") -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: int) -> None:
        ...
    @property
    def digits(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @digits.setter
    def digits(self, value: int) -> None:
        ...
    @property
    def result(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_StringPadInteger(RigVMFunction_StringPadInteger):
    r"""
    deprecated: 'RigUnit_StringPadInteger' was renamed to 'RigVMFunction_StringPadInteger'.
    """
    def __init__(self, value: int = 0, digits: int = 0, result: str = "") -> None:
        ...

class RigVMFunction_SimBase(RigVMStruct):
    r"""
    Rig VMFunction Sim Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_SimBase.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_SimBase(RigVMFunction_SimBase):
    r"""
    deprecated: 'RigUnit_SimBase' was renamed to 'RigVMFunction_SimBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_AccumulateBase(RigVMFunction_SimBase):
    r"""
    Rig VMFunction Accumulate Base
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_AccumulateBase(RigVMFunction_AccumulateBase):
    r"""
    deprecated: 'RigUnit_AccumulateBase' was renamed to 'RigVMFunction_AccumulateBase'.
    """
    def __init__(self) -> None:
        ...

class RigVMFunction_AccumulateFloatAdd(RigVMFunction_AccumulateBase):
    r"""
    Adds a value over time over and over again
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``increment`` (float):  [Read-Write]
    - ``initial_value`` (float):  [Read-Write]
    - ``integrate_delta_time`` (bool):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, increment: float = 0.000000, initial_value: float = 0.000000, integrate_delta_time: bool = False, result: float = 0.000000) -> None:
        ...
    @property
    def increment(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @increment.setter
    def increment(self, value: float) -> None:
        ...
    @property
    def initial_value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @initial_value.setter
    def initial_value(self, value: float) -> None:
        ...
    @property
    def integrate_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @integrate_delta_time.setter
    def integrate_delta_time(self, value: bool) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_AccumulateFloatAdd(RigVMFunction_AccumulateFloatAdd):
    r"""
    deprecated: 'RigUnit_AccumulateFloatAdd' was renamed to 'RigVMFunction_AccumulateFloatAdd'.
    """
    def __init__(self, increment: float = 0.000000, initial_value: float = 0.000000, integrate_delta_time: bool = False, result: float = 0.000000) -> None:
        ...

class RigVMFunction_AccumulateVectorAdd(RigVMFunction_AccumulateBase):
    r"""
    Adds a vector over time over and over again
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``increment`` (Vector):  [Read-Write]
    - ``initial_value`` (Vector):  [Read-Write]
    - ``integrate_delta_time`` (bool):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, increment: Vector = [0.000000, 0.000000, 0.000000], initial_value: Vector = [0.000000, 0.000000, 0.000000], integrate_delta_time: bool = False, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def increment(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @increment.setter
    def increment(self, value: Vector) -> None:
        ...
    @property
    def initial_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Vector) -> None:
        ...
    @property
    def integrate_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @integrate_delta_time.setter
    def integrate_delta_time(self, value: bool) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_AccumulateVectorAdd(RigVMFunction_AccumulateVectorAdd):
    r"""
    deprecated: 'RigUnit_AccumulateVectorAdd' was renamed to 'RigVMFunction_AccumulateVectorAdd'.
    """
    def __init__(self, increment: Vector = [0.000000, 0.000000, 0.000000], initial_value: Vector = [0.000000, 0.000000, 0.000000], integrate_delta_time: bool = False, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_AccumulateFloatMul(RigVMFunction_AccumulateBase):
    r"""
    Multiplies a value over time over and over again
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``initial_value`` (float):  [Read-Write]
    - ``integrate_delta_time`` (bool):  [Read-Write]
    - ``multiplier`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, multiplier: float = 0.000000, initial_value: float = 0.000000, integrate_delta_time: bool = False, result: float = 0.000000) -> None:
        ...
    @property
    def multiplier(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @multiplier.setter
    def multiplier(self, value: float) -> None:
        ...
    @property
    def initial_value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @initial_value.setter
    def initial_value(self, value: float) -> None:
        ...
    @property
    def integrate_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @integrate_delta_time.setter
    def integrate_delta_time(self, value: bool) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_AccumulateFloatMul(RigVMFunction_AccumulateFloatMul):
    r"""
    deprecated: 'RigUnit_AccumulateFloatMul' was renamed to 'RigVMFunction_AccumulateFloatMul'.
    """
    def __init__(self, multiplier: float = 0.000000, initial_value: float = 0.000000, integrate_delta_time: bool = False, result: float = 0.000000) -> None:
        ...

class RigVMFunction_AccumulateVectorMul(RigVMFunction_AccumulateBase):
    r"""
    Multiplies a vector over time over and over again
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``initial_value`` (Vector):  [Read-Write]
    - ``integrate_delta_time`` (bool):  [Read-Write]
    - ``multiplier`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, multiplier: Vector = [0.000000, 0.000000, 0.000000], initial_value: Vector = [0.000000, 0.000000, 0.000000], integrate_delta_time: bool = False, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def multiplier(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @multiplier.setter
    def multiplier(self, value: Vector) -> None:
        ...
    @property
    def initial_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Vector) -> None:
        ...
    @property
    def integrate_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @integrate_delta_time.setter
    def integrate_delta_time(self, value: bool) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_AccumulateVectorMul(RigVMFunction_AccumulateVectorMul):
    r"""
    deprecated: 'RigUnit_AccumulateVectorMul' was renamed to 'RigVMFunction_AccumulateVectorMul'.
    """
    def __init__(self, multiplier: Vector = [0.000000, 0.000000, 0.000000], initial_value: Vector = [0.000000, 0.000000, 0.000000], integrate_delta_time: bool = False, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_AccumulateQuatMul(RigVMFunction_AccumulateBase):
    r"""
    Multiplies a quaternion over time over and over again
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``flip_order`` (bool):  [Read-Write]
    - ``initial_value`` (Quat):  [Read-Write]
    - ``integrate_delta_time`` (bool):  [Read-Write]
    - ``multiplier`` (Quat):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, multiplier: Quat = [0.000000, 0.000000, 0.000000, 1.000000], initial_value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], flip_order: bool = False, integrate_delta_time: bool = False, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def multiplier(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @multiplier.setter
    def multiplier(self, value: Quat) -> None:
        ...
    @property
    def initial_value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Quat) -> None:
        ...
    @property
    def flip_order(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @flip_order.setter
    def flip_order(self, value: bool) -> None:
        ...
    @property
    def integrate_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @integrate_delta_time.setter
    def integrate_delta_time(self, value: bool) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_AccumulateQuatMul(RigVMFunction_AccumulateQuatMul):
    r"""
    deprecated: 'RigUnit_AccumulateQuatMul' was renamed to 'RigVMFunction_AccumulateQuatMul'.
    """
    def __init__(self, multiplier: Quat = [0.000000, 0.000000, 0.000000, 1.000000], initial_value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], flip_order: bool = False, integrate_delta_time: bool = False, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_AccumulateTransformMul(RigVMFunction_AccumulateBase):
    r"""
    Multiplies a transform over time over and over again
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``flip_order`` (bool):  [Read-Write]
    - ``initial_value`` (Transform):  [Read-Write]
    - ``integrate_delta_time`` (bool):  [Read-Write]
    - ``multiplier`` (Transform):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    """
    def __init__(self, multiplier: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], initial_value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], flip_order: bool = False, integrate_delta_time: bool = False, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def multiplier(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @multiplier.setter
    def multiplier(self, value: Transform) -> None:
        ...
    @property
    def initial_value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Transform) -> None:
        ...
    @property
    def flip_order(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @flip_order.setter
    def flip_order(self, value: bool) -> None:
        ...
    @property
    def integrate_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @integrate_delta_time.setter
    def integrate_delta_time(self, value: bool) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_AccumulateTransformMul(RigVMFunction_AccumulateTransformMul):
    r"""
    deprecated: 'RigUnit_AccumulateTransformMul' was renamed to 'RigVMFunction_AccumulateTransformMul'.
    """
    def __init__(self, multiplier: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], initial_value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], flip_order: bool = False, integrate_delta_time: bool = False, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_AccumulateFloatLerp(RigVMFunction_AccumulateBase):
    r"""
    Interpolates two values over time over and over again
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend`` (float):  [Read-Write]
    - ``initial_value`` (float):  [Read-Write]
    - ``integrate_delta_time`` (bool):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``target_value`` (float):  [Read-Write]
    """
    def __init__(self, target_value: float = 0.000000, initial_value: float = 0.000000, blend: float = 0.000000, integrate_delta_time: bool = False, result: float = 0.000000) -> None:
        ...
    @property
    def target_value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @target_value.setter
    def target_value(self, value: float) -> None:
        ...
    @property
    def initial_value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @initial_value.setter
    def initial_value(self, value: float) -> None:
        ...
    @property
    def blend(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @blend.setter
    def blend(self, value: float) -> None:
        ...
    @property
    def integrate_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @integrate_delta_time.setter
    def integrate_delta_time(self, value: bool) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_AccumulateFloatLerp(RigVMFunction_AccumulateFloatLerp):
    r"""
    deprecated: 'RigUnit_AccumulateFloatLerp' was renamed to 'RigVMFunction_AccumulateFloatLerp'.
    """
    def __init__(self, target_value: float = 0.000000, initial_value: float = 0.000000, blend: float = 0.000000, integrate_delta_time: bool = False, result: float = 0.000000) -> None:
        ...

class RigVMFunction_AccumulateVectorLerp(RigVMFunction_AccumulateBase):
    r"""
    Interpolates two vectors over time over and over again
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend`` (float):  [Read-Write]
    - ``initial_value`` (Vector):  [Read-Write]
    - ``integrate_delta_time`` (bool):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``target_value`` (Vector):  [Read-Write]
    """
    def __init__(self, target_value: Vector = [0.000000, 0.000000, 0.000000], initial_value: Vector = [0.000000, 0.000000, 0.000000], blend: float = 0.000000, integrate_delta_time: bool = False, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def target_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @target_value.setter
    def target_value(self, value: Vector) -> None:
        ...
    @property
    def initial_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Vector) -> None:
        ...
    @property
    def blend(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @blend.setter
    def blend(self, value: float) -> None:
        ...
    @property
    def integrate_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @integrate_delta_time.setter
    def integrate_delta_time(self, value: bool) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_AccumulateVectorLerp(RigVMFunction_AccumulateVectorLerp):
    r"""
    deprecated: 'RigUnit_AccumulateVectorLerp' was renamed to 'RigVMFunction_AccumulateVectorLerp'.
    """
    def __init__(self, target_value: Vector = [0.000000, 0.000000, 0.000000], initial_value: Vector = [0.000000, 0.000000, 0.000000], blend: float = 0.000000, integrate_delta_time: bool = False, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_AccumulateQuatLerp(RigVMFunction_AccumulateBase):
    r"""
    Interpolates two quaternions over time over and over again
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend`` (float):  [Read-Write]
    - ``initial_value`` (Quat):  [Read-Write]
    - ``integrate_delta_time`` (bool):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    - ``target_value`` (Quat):  [Read-Write]
    """
    def __init__(self, target_value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], initial_value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], blend: float = 0.000000, integrate_delta_time: bool = False, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def target_value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @target_value.setter
    def target_value(self, value: Quat) -> None:
        ...
    @property
    def initial_value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Quat) -> None:
        ...
    @property
    def blend(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @blend.setter
    def blend(self, value: float) -> None:
        ...
    @property
    def integrate_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @integrate_delta_time.setter
    def integrate_delta_time(self, value: bool) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_AccumulateQuatLerp(RigVMFunction_AccumulateQuatLerp):
    r"""
    deprecated: 'RigUnit_AccumulateQuatLerp' was renamed to 'RigVMFunction_AccumulateQuatLerp'.
    """
    def __init__(self, target_value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], initial_value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], blend: float = 0.000000, integrate_delta_time: bool = False, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_AccumulateTransformLerp(RigVMFunction_AccumulateBase):
    r"""
    Interpolates two transforms over time over and over again
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend`` (float):  [Read-Write]
    - ``initial_value`` (Transform):  [Read-Write]
    - ``integrate_delta_time`` (bool):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    - ``target_value`` (Transform):  [Read-Write]
    """
    def __init__(self, target_value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], initial_value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], blend: float = 0.000000, integrate_delta_time: bool = False, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def target_value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @target_value.setter
    def target_value(self, value: Transform) -> None:
        ...
    @property
    def initial_value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Transform) -> None:
        ...
    @property
    def blend(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @blend.setter
    def blend(self, value: float) -> None:
        ...
    @property
    def integrate_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @integrate_delta_time.setter
    def integrate_delta_time(self, value: bool) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_AccumulateTransformLerp(RigVMFunction_AccumulateTransformLerp):
    r"""
    deprecated: 'RigUnit_AccumulateTransformLerp' was renamed to 'RigVMFunction_AccumulateTransformLerp'.
    """
    def __init__(self, target_value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], initial_value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], blend: float = 0.000000, integrate_delta_time: bool = False, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_AccumulateFloatRange(RigVMFunction_AccumulateBase):
    r"""
    Accumulates the min and max values over time
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``maximum`` (float):  [Read-Write]
    - ``minimum`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, minimum: float = 0.000000, maximum: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_AccumulateFloatRange(RigVMFunction_AccumulateFloatRange):
    r"""
    deprecated: 'RigUnit_AccumulateFloatRange' was renamed to 'RigVMFunction_AccumulateFloatRange'.
    """
    def __init__(self, value: float = 0.000000, minimum: float = 0.000000, maximum: float = 0.000000) -> None:
        ...

class RigVMFunction_AccumulateVectorRange(RigVMFunction_AccumulateBase):
    r"""
    Accumulates the min and max values over time
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Accumulate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``maximum`` (Vector):  [Read-Write]
    - ``minimum`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], minimum: Vector = [0.000000, 0.000000, 0.000000], maximum: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def minimum(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def maximum(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_AccumulateVectorRange(RigVMFunction_AccumulateVectorRange):
    r"""
    deprecated: 'RigUnit_AccumulateVectorRange' was renamed to 'RigVMFunction_AccumulateVectorRange'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], minimum: Vector = [0.000000, 0.000000, 0.000000], maximum: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_AlphaInterp(RigVMFunction_SimBase):
    r"""
    Takes in a float value and outputs an accumulated value with a customized scale and clamp
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_AlphaInterp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bias`` (float):  [Read-Write]
    - ``clamp_max`` (float):  [Read-Write]
    - ``clamp_min`` (float):  [Read-Write]
    - ``clamp_result`` (bool):  [Read-Only]
    - ``interp_result`` (bool):  [Read-Only]
    - ``interp_speed_decreasing`` (float):  [Read-Write]
    - ``interp_speed_increasing`` (float):  [Read-Write]
    - ``map_range`` (bool):  [Read-Only]
    - ``out_range`` (InputRange):  [Read-Write]
    - ``range`` (InputRange):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, scale: float = 0.000000, bias: float = 0.000000, map_range: bool = False, range: InputRange = [0.000000, 1.000000], out_range: InputRange = [0.000000, 1.000000], clamp_result: bool = False, clamp_min: float = 0.000000, clamp_max: float = 0.000000, interp_result: bool = False, interp_speed_increasing: float = 0.000000, interp_speed_decreasing: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bias(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @bias.setter
    def bias(self, value: float) -> None:
        ...
    @property
    def map_range(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def range(self) -> InputRange:
        r"""
        (InputRange):  [Read-Write]
        """
        ...
    @range.setter
    def range(self, value: InputRange) -> None:
        ...
    @property
    def out_range(self) -> InputRange:
        r"""
        (InputRange):  [Read-Write]
        """
        ...
    @out_range.setter
    def out_range(self, value: InputRange) -> None:
        ...
    @property
    def clamp_result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def clamp_min(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_min.setter
    def clamp_min(self, value: float) -> None:
        ...
    @property
    def clamp_max(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_max.setter
    def clamp_max(self, value: float) -> None:
        ...
    @property
    def interp_result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def interp_speed_increasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_increasing.setter
    def interp_speed_increasing(self, value: float) -> None:
        ...
    @property
    def interp_speed_decreasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_decreasing.setter
    def interp_speed_decreasing(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_AlphaInterp(RigVMFunction_AlphaInterp):
    r"""
    deprecated: 'RigUnit_AlphaInterp' was renamed to 'RigVMFunction_AlphaInterp'.
    """
    def __init__(self, value: float = 0.000000, scale: float = 0.000000, bias: float = 0.000000, map_range: bool = False, range: InputRange = [0.000000, 1.000000], out_range: InputRange = [0.000000, 1.000000], clamp_result: bool = False, clamp_min: float = 0.000000, clamp_max: float = 0.000000, interp_result: bool = False, interp_speed_increasing: float = 0.000000, interp_speed_decreasing: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_AlphaInterpVector(RigVMFunction_SimBase):
    r"""
    Takes in a vector value and outputs an accumulated value with a customized scale and clamp
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_AlphaInterp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bias`` (float):  [Read-Write]
    - ``clamp_max`` (float):  [Read-Write]
    - ``clamp_min`` (float):  [Read-Write]
    - ``clamp_result`` (bool):  [Read-Only]
    - ``interp_result`` (bool):  [Read-Only]
    - ``interp_speed_decreasing`` (float):  [Read-Write]
    - ``interp_speed_increasing`` (float):  [Read-Write]
    - ``map_range`` (bool):  [Read-Only]
    - ``out_range`` (InputRange):  [Read-Write]
    - ``range`` (InputRange):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], scale: float = 0.000000, bias: float = 0.000000, map_range: bool = False, range: InputRange = [0.000000, 1.000000], out_range: InputRange = [0.000000, 1.000000], clamp_result: bool = False, clamp_min: float = 0.000000, clamp_max: float = 0.000000, interp_result: bool = False, interp_speed_increasing: float = 0.000000, interp_speed_decreasing: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bias(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @bias.setter
    def bias(self, value: float) -> None:
        ...
    @property
    def map_range(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def range(self) -> InputRange:
        r"""
        (InputRange):  [Read-Write]
        """
        ...
    @range.setter
    def range(self, value: InputRange) -> None:
        ...
    @property
    def out_range(self) -> InputRange:
        r"""
        (InputRange):  [Read-Write]
        """
        ...
    @out_range.setter
    def out_range(self, value: InputRange) -> None:
        ...
    @property
    def clamp_result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def clamp_min(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_min.setter
    def clamp_min(self, value: float) -> None:
        ...
    @property
    def clamp_max(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_max.setter
    def clamp_max(self, value: float) -> None:
        ...
    @property
    def interp_result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def interp_speed_increasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_increasing.setter
    def interp_speed_increasing(self, value: float) -> None:
        ...
    @property
    def interp_speed_decreasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_decreasing.setter
    def interp_speed_decreasing(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_AlphaInterpVector(RigVMFunction_AlphaInterpVector):
    r"""
    deprecated: 'RigUnit_AlphaInterpVector' was renamed to 'RigVMFunction_AlphaInterpVector'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], scale: float = 0.000000, bias: float = 0.000000, map_range: bool = False, range: InputRange = [0.000000, 1.000000], out_range: InputRange = [0.000000, 1.000000], clamp_result: bool = False, clamp_min: float = 0.000000, clamp_max: float = 0.000000, interp_result: bool = False, interp_speed_increasing: float = 0.000000, interp_speed_decreasing: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_AlphaInterpQuat(RigVMFunction_SimBase):
    r"""
    Takes in a vector value and outputs an accumulated value with a customized scale and clamp
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_AlphaInterp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bias`` (float):  [Read-Write]
    - ``clamp_max`` (float):  [Read-Write]
    - ``clamp_min`` (float):  [Read-Write]
    - ``clamp_result`` (bool):  [Read-Only]
    - ``interp_result`` (bool):  [Read-Only]
    - ``interp_speed_decreasing`` (float):  [Read-Write]
    - ``interp_speed_increasing`` (float):  [Read-Write]
    - ``map_range`` (bool):  [Read-Only]
    - ``out_range`` (InputRange):  [Read-Write]
    - ``range`` (InputRange):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], scale: float = 0.000000, bias: float = 0.000000, map_range: bool = False, range: InputRange = [0.000000, 1.000000], out_range: InputRange = [0.000000, 1.000000], clamp_result: bool = False, clamp_min: float = 0.000000, clamp_max: float = 0.000000, interp_result: bool = False, interp_speed_increasing: float = 0.000000, interp_speed_decreasing: float = 0.000000, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bias(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @bias.setter
    def bias(self, value: float) -> None:
        ...
    @property
    def map_range(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def range(self) -> InputRange:
        r"""
        (InputRange):  [Read-Write]
        """
        ...
    @range.setter
    def range(self, value: InputRange) -> None:
        ...
    @property
    def out_range(self) -> InputRange:
        r"""
        (InputRange):  [Read-Write]
        """
        ...
    @out_range.setter
    def out_range(self, value: InputRange) -> None:
        ...
    @property
    def clamp_result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def clamp_min(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_min.setter
    def clamp_min(self, value: float) -> None:
        ...
    @property
    def clamp_max(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clamp_max.setter
    def clamp_max(self, value: float) -> None:
        ...
    @property
    def interp_result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def interp_speed_increasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_increasing.setter
    def interp_speed_increasing(self, value: float) -> None:
        ...
    @property
    def interp_speed_decreasing(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @interp_speed_decreasing.setter
    def interp_speed_decreasing(self, value: float) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_AlphaInterpQuat(RigVMFunction_AlphaInterpQuat):
    r"""
    deprecated: 'RigUnit_AlphaInterpQuat' was renamed to 'RigVMFunction_AlphaInterpQuat'.
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], scale: float = 0.000000, bias: float = 0.000000, map_range: bool = False, range: InputRange = [0.000000, 1.000000], out_range: InputRange = [0.000000, 1.000000], clamp_result: bool = False, clamp_min: float = 0.000000, clamp_max: float = 0.000000, interp_result: bool = False, interp_speed_increasing: float = 0.000000, interp_speed_decreasing: float = 0.000000, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_DeltaFromPreviousFloat(RigVMFunction_SimBase):
    r"""
    Computes the difference from the previous value going through the node
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DeltaFromPrevious.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delta`` (float):  [Read-Write]
    - ``previous_value`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, delta: float = 0.000000, previous_value: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def delta(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def previous_value(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_DeltaFromPreviousFloat(RigVMFunction_DeltaFromPreviousFloat):
    r"""
    deprecated: 'RigUnit_DeltaFromPreviousFloat' was renamed to 'RigVMFunction_DeltaFromPreviousFloat'.
    """
    def __init__(self, value: float = 0.000000, delta: float = 0.000000, previous_value: float = 0.000000) -> None:
        ...

class RigVMFunction_DeltaFromPreviousVector(RigVMFunction_SimBase):
    r"""
    Computes the difference from the previous value going through the node
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DeltaFromPrevious.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delta`` (Vector):  [Read-Write]
    - ``previous_value`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], delta: Vector = [0.000000, 0.000000, 0.000000], previous_value: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def delta(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def previous_value(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_DeltaFromPreviousVector(RigVMFunction_DeltaFromPreviousVector):
    r"""
    deprecated: 'RigUnit_DeltaFromPreviousVector' was renamed to 'RigVMFunction_DeltaFromPreviousVector'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], delta: Vector = [0.000000, 0.000000, 0.000000], previous_value: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_DeltaFromPreviousQuat(RigVMFunction_SimBase):
    r"""
    Computes the difference from the previous value going through the node
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DeltaFromPrevious.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delta`` (Quat):  [Read-Write]
    - ``previous_value`` (Quat):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], delta: Quat = [0.000000, 0.000000, 0.000000, 1.000000], previous_value: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def delta(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...
    @property
    def previous_value(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_DeltaFromPreviousQuat(RigVMFunction_DeltaFromPreviousQuat):
    r"""
    deprecated: 'RigUnit_DeltaFromPreviousQuat' was renamed to 'RigVMFunction_DeltaFromPreviousQuat'.
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], delta: Quat = [0.000000, 0.000000, 0.000000, 1.000000], previous_value: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigVMFunction_DeltaFromPreviousTransform(RigVMFunction_SimBase):
    r"""
    Computes the difference from the previous value going through the node
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_DeltaFromPrevious.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delta`` (Transform):  [Read-Write]
    - ``previous_value`` (Transform):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], delta: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], previous_value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def delta(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...
    @property
    def previous_value(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_DeltaFromPreviousTransform(RigVMFunction_DeltaFromPreviousTransform):
    r"""
    deprecated: 'RigUnit_DeltaFromPreviousTransform' was renamed to 'RigVMFunction_DeltaFromPreviousTransform'.
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], delta: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], previous_value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_KalmanFloat(RigVMFunction_SimBase):
    r"""
    Averages a value over time.
    This uses a Kalman Filter internally.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Kalman.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``buffer_size`` (int32):  [Read-Only]
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, buffer_size: int = 0, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def buffer_size(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_KalmanFloat(RigVMFunction_KalmanFloat):
    r"""
    deprecated: 'RigUnit_KalmanFloat' was renamed to 'RigVMFunction_KalmanFloat'.
    """
    def __init__(self, value: float = 0.000000, buffer_size: int = 0, result: float = 0.000000) -> None:
        ...

class RigVMFunction_KalmanVector(RigVMFunction_SimBase):
    r"""
    Averages a value over time.
    This uses a Kalman Filter internally.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Kalman.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``buffer_size`` (int32):  [Read-Only]
    - ``result`` (Vector):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], buffer_size: int = 0, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def buffer_size(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_KalmanVector(RigVMFunction_KalmanVector):
    r"""
    deprecated: 'RigUnit_KalmanVector' was renamed to 'RigVMFunction_KalmanVector'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], buffer_size: int = 0, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_KalmanTransform(RigVMFunction_SimBase):
    r"""
    Averages a transform over time.
    This uses a Kalman Filter internally.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Kalman.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``buffer_size`` (int32):  [Read-Only]
    - ``result`` (Transform):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], buffer_size: int = 0, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def buffer_size(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_KalmanTransform(RigVMFunction_KalmanTransform):
    r"""
    deprecated: 'RigUnit_KalmanTransform' was renamed to 'RigVMFunction_KalmanTransform'.
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], buffer_size: int = 0, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_Timeline(RigVMFunction_SimBase):
    r"""
    Simulates a time value - can act as a timeline playing back
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Timeline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``speed`` (float):  [Read-Write]
    - ``time`` (float):  [Read-Write]
    """
    def __init__(self, speed: float = 0.000000, time: float = 0.000000) -> None:
        ...
    @property
    def speed(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @speed.setter
    def speed(self, value: float) -> None:
        ...
    @property
    def time(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_Timeline(RigVMFunction_Timeline):
    r"""
    deprecated: 'RigUnit_Timeline' was renamed to 'RigVMFunction_Timeline'.
    """
    def __init__(self, speed: float = 0.000000, time: float = 0.000000) -> None:
        ...

class RigVMFunction_TimeLoop(RigVMFunction_SimBase):
    r"""
    Simulates a time value - and outputs loop information
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Timeline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute`` (float):  [Read-Write] the overall time in seconds
    - ``duration`` (float):  [Read-Write] the duration of a single loop in seconds
    - ``even`` (bool):  [Read-Write] true if the iteration of the loop is even
    - ``flip_flop`` (float):  [Read-Write] the relative time in seconds (within the loop),
      going from 0 to duration and then back from duration to 0,
      or 0 to 1 and 1 to 0 if Normalize is turned on
    - ``normalize`` (bool):  [Read-Write] if set to true the output relative and flipflop
      will be normalized over the duration.
    - ``relative`` (float):  [Read-Write] the relative time in seconds (within the loop)
    - ``speed`` (float):  [Read-Write]
    """
    def __init__(self, speed: float = 0.000000, duration: float = 0.000000, normalize: bool = False, absolute: float = 0.000000, relative: float = 0.000000, flip_flop: float = 0.000000, even: bool = False) -> None:
        ...
    @property
    def speed(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @speed.setter
    def speed(self, value: float) -> None:
        ...
    @property
    def duration(self) -> float:
        r"""
        (float):  [Read-Write] the duration of a single loop in seconds
        """
        ...
    @duration.setter
    def duration(self, value: float) -> None:
        ...
    @property
    def normalize(self) -> bool:
        r"""
        (bool):  [Read-Write] if set to true the output relative and flipflop
        will be normalized over the duration.
        """
        ...
    @normalize.setter
    def normalize(self, value: bool) -> None:
        ...
    @property
    def absolute(self) -> float:
        r"""
        (float):  [Read-Only] the overall time in seconds
        """
        ...
    @property
    def relative(self) -> float:
        r"""
        (float):  [Read-Only] the relative time in seconds (within the loop)
        """
        ...
    @property
    def flip_flop(self) -> float:
        r"""
        (float):  [Read-Only] the relative time in seconds (within the loop),
        going from 0 to duration and then back from duration to 0,
        or 0 to 1 and 1 to 0 if Normalize is turned on
        """
        ...
    @property
    def even(self) -> bool:
        r"""
        (bool):  [Read-Only] true if the iteration of the loop is even
        """
        ...

class RigUnit_TimeLoop(RigVMFunction_TimeLoop):
    r"""
    deprecated: 'RigUnit_TimeLoop' was renamed to 'RigVMFunction_TimeLoop'.
    """
    def __init__(self, speed: float = 0.000000, duration: float = 0.000000, normalize: bool = False, absolute: float = 0.000000, relative: float = 0.000000, flip_flop: float = 0.000000, even: bool = False) -> None:
        ...

class RigVMFunction_TimeOffsetFloat(RigVMFunction_SimBase):
    r"""
    Records a value over time and can access the value from the past
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_TimeOffset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``buffer_size`` (int32):  [Read-Only] The sampling precision of the buffer. The higher the more precise - the more memory usage.
    - ``result`` (float):  [Read-Write]
    - ``seconds_ago`` (float):  [Read-Write] Seconds of time in the past you want to query the value for
    - ``time_range`` (float):  [Read-Only] The maximum time required for offsetting in seconds.
    - ``value`` (float):  [Read-Write] The value to record
    """
    def __init__(self, value: float = 0.000000, seconds_ago: float = 0.000000, buffer_size: int = 0, time_range: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write] The value to record
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def seconds_ago(self) -> float:
        r"""
        (float):  [Read-Write] Seconds of time in the past you want to query the value for
        """
        ...
    @seconds_ago.setter
    def seconds_ago(self, value: float) -> None:
        ...
    @property
    def buffer_size(self) -> int:
        r"""
        (int32):  [Read-Only] The sampling precision of the buffer. The higher the more precise - the more memory usage.
        """
        ...
    @property
    def time_range(self) -> float:
        r"""
        (float):  [Read-Only] The maximum time required for offsetting in seconds.
        """
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_TimeOffsetFloat(RigVMFunction_TimeOffsetFloat):
    r"""
    deprecated: 'RigUnit_TimeOffsetFloat' was renamed to 'RigVMFunction_TimeOffsetFloat'.
    """
    def __init__(self, value: float = 0.000000, seconds_ago: float = 0.000000, buffer_size: int = 0, time_range: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigVMFunction_TimeOffsetVector(RigVMFunction_SimBase):
    r"""
    Records a value over time and can access the value from the past
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_TimeOffset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``buffer_size`` (int32):  [Read-Only] The sampling precision of the buffer. The higher the more precise - the more memory usage.
    - ``result`` (Vector):  [Read-Write]
    - ``seconds_ago`` (float):  [Read-Write] Seconds of time in the past you want to query the value for
    - ``time_range`` (float):  [Read-Only] The maximum time required for offsetting in seconds.
    - ``value`` (Vector):  [Read-Write] The value to record
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], seconds_ago: float = 0.000000, buffer_size: int = 0, time_range: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The value to record
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def seconds_ago(self) -> float:
        r"""
        (float):  [Read-Write] Seconds of time in the past you want to query the value for
        """
        ...
    @seconds_ago.setter
    def seconds_ago(self, value: float) -> None:
        ...
    @property
    def buffer_size(self) -> int:
        r"""
        (int32):  [Read-Only] The sampling precision of the buffer. The higher the more precise - the more memory usage.
        """
        ...
    @property
    def time_range(self) -> float:
        r"""
        (float):  [Read-Only] The maximum time required for offsetting in seconds.
        """
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_TimeOffsetVector(RigVMFunction_TimeOffsetVector):
    r"""
    deprecated: 'RigUnit_TimeOffsetVector' was renamed to 'RigVMFunction_TimeOffsetVector'.
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], seconds_ago: float = 0.000000, buffer_size: int = 0, time_range: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMFunction_TimeOffsetTransform(RigVMFunction_SimBase):
    r"""
    Records a value over time and can access the value from the past
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_TimeOffset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``buffer_size`` (int32):  [Read-Only] The sampling precision of the buffer. The higher the more precise - the more memory usage.
    - ``result`` (Transform):  [Read-Write]
    - ``seconds_ago`` (float):  [Read-Write] Seconds of time in the past you want to query the value for
    - ``time_range`` (float):  [Read-Only] The maximum time required for offsetting in seconds.
    - ``value`` (Transform):  [Read-Write] The value to record
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], seconds_ago: float = 0.000000, buffer_size: int = 0, time_range: float = 0.000000, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The value to record
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def seconds_ago(self) -> float:
        r"""
        (float):  [Read-Write] Seconds of time in the past you want to query the value for
        """
        ...
    @seconds_ago.setter
    def seconds_ago(self, value: float) -> None:
        ...
    @property
    def buffer_size(self) -> int:
        r"""
        (int32):  [Read-Only] The sampling precision of the buffer. The higher the more precise - the more memory usage.
        """
        ...
    @property
    def time_range(self) -> float:
        r"""
        (float):  [Read-Only] The maximum time required for offsetting in seconds.
        """
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_TimeOffsetTransform(RigVMFunction_TimeOffsetTransform):
    r"""
    deprecated: 'RigUnit_TimeOffsetTransform' was renamed to 'RigVMFunction_TimeOffsetTransform'.
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], seconds_ago: float = 0.000000, buffer_size: int = 0, time_range: float = 0.000000, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigVMFunction_VerletIntegrateVector(RigVMFunction_SimBase):
    r"""
    Simulates a single position over time using Verlet integration. It is recommended to use SpringInterp instead as it
    is more accurate and stable, and has more meaningful parameters.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMFunction_Verlet.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``acceleration`` (Vector):  [Read-Write]
    - ``blend`` (float):  [Read-Write] The amount of blending to apply per second
    - ``damp`` (float):  [Read-Write] The amount of damping to apply ( 0.0 to 1.0, but usually really low like 0.005 )
    - ``force`` (Vector):  [Read-Write] The force feeding into the solver. Can be used for gravity.
    - ``position`` (Vector):  [Read-Write]
    - ``strength`` (float):  [Read-Write] The strength of the verlet spring
    - ``target`` (Vector):  [Read-Write]
    - ``velocity`` (Vector):  [Read-Write]
    """
    def __init__(self, target: Vector = [0.000000, 0.000000, 0.000000], strength: float = 0.000000, damp: float = 0.000000, blend: float = 0.000000, force: Vector = [0.000000, 0.000000, 0.000000], position: Vector = [0.000000, 0.000000, 0.000000], velocity: Vector = [0.000000, 0.000000, 0.000000], acceleration: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def target(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Vector) -> None:
        ...
    @property
    def strength(self) -> float:
        r"""
        (float):  [Read-Write] The strength of the verlet spring
        """
        ...
    @strength.setter
    def strength(self, value: float) -> None:
        ...
    @property
    def damp(self) -> float:
        r"""
        (float):  [Read-Write] The amount of damping to apply ( 0.0 to 1.0, but usually really low like 0.005 )
        """
        ...
    @damp.setter
    def damp(self, value: float) -> None:
        ...
    @property
    def blend(self) -> float:
        r"""
        (float):  [Read-Write] The amount of blending to apply per second
        """
        ...
    @blend.setter
    def blend(self, value: float) -> None:
        ...
    @property
    def force(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The force feeding into the solver. Can be used for gravity.
        """
        ...
    @force.setter
    def force(self, value: Vector) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def acceleration(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_VerletIntegrateVector(RigVMFunction_VerletIntegrateVector):
    r"""
    deprecated: 'RigUnit_VerletIntegrateVector' was renamed to 'RigVMFunction_VerletIntegrateVector'.
    """
    def __init__(self, target: Vector = [0.000000, 0.000000, 0.000000], strength: float = 0.000000, damp: float = 0.000000, blend: float = 0.000000, force: Vector = [0.000000, 0.000000, 0.000000], position: Vector = [0.000000, 0.000000, 0.000000], velocity: Vector = [0.000000, 0.000000, 0.000000], acceleration: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigVMGraphVariableDescription(StructBase):
    r"""
    The variable description is used to convey information
    about unique variables within a Graph. Multiple Variable
    Nodes can share the same variable description.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMVariableDescription.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cpp_type`` (str):  [Read-Write] The C++ data type of the variable
    - ``cpp_type_object`` (Object):  [Read-Write] The Struct of the C++ data type of the variable (or nullptr)
    - ``default_value`` (str):  [Read-Write] The default value of the variable
    - ``name`` (Name):  [Read-Write] The name of the variable
    """
    def __init__(self, name: Name = "None", cpp_type: str = "", cpp_type_object: Object = None, default_value: str = "") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of the variable
        """
        ...
    @property
    def cpp_type(self) -> str:
        r"""
        (str):  [Read-Only] The C++ data type of the variable
        """
        ...
    @property
    def cpp_type_object(self) -> Object:
        r"""
        (Object):  [Read-Only] The Struct of the C++ data type of the variable (or nullptr)
        """
        ...
    @property
    def default_value(self) -> str:
        r"""
        (str):  [Read-Only] The default value of the variable
        """
        ...

class RigVMParserASTSettings(StructBase):
    r"""
    * The settings to apply during the parse of the abstract syntax tree.
    * The folding settings can affect the performance of the parse dramatically.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMAST.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context_struct`` (ScriptStruct):  [Read-Only]
    - ``fold_assignments`` (bool):  [Read-Write] fold assignments / copies
    - ``fold_literals`` (bool):  [Read-Write] fold literals and share memory
    """
    def __init__(self) -> None:
        ...

class RigVMCompileSettings(StructBase):
    r"""
    Rig VMCompile Settings
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMCompiler.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ast_settings`` (RigVMParserASTSettings):  [Read-Write]
    - ``enable_pin_watches`` (bool):  [Read-Write]
    - ``surpress_errors`` (bool):  [Read-Write]
    - ``surpress_info_messages`` (bool):  [Read-Write]
    - ``surpress_warnings`` (bool):  [Read-Write]
    """
    def __init__(self, surpress_info_messages: bool = False, surpress_warnings: bool = False, surpress_errors: bool = False, enable_pin_watches: bool = False, ast_settings: RigVMParserASTSettings = []) -> None:
        ...
    @property
    def surpress_info_messages(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @surpress_info_messages.setter
    def surpress_info_messages(self, value: bool) -> None:
        ...
    @property
    def surpress_warnings(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @surpress_warnings.setter
    def surpress_warnings(self, value: bool) -> None:
        ...
    @property
    def surpress_errors(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @surpress_errors.setter
    def surpress_errors(self, value: bool) -> None:
        ...
    @property
    def enable_pin_watches(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enable_pin_watches.setter
    def enable_pin_watches(self, value: bool) -> None:
        ...
    @property
    def ast_settings(self) -> RigVMParserASTSettings:
        r"""
        (RigVMParserASTSettings):  [Read-Write]
        """
        ...
    @ast_settings.setter
    def ast_settings(self, value: RigVMParserASTSettings) -> None:
        ...

class RigVMGraphParameterDescription(StructBase):
    r"""
    The parameter description is used to convey information
    about unique parameters within a Graph. Multiple Parameter
    Nodes can share the same parameter description.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMParameterNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cpp_type`` (str):  [Read-Write] The C++ data type of the parameter
    - ``cpp_type_object`` (Object):  [Read-Write] The Struct of the C++ data type of the parameter (or nullptr)
    - ``default_value`` (str):  [Read-Write] The default value of the parameter
    - ``is_input`` (bool):  [Read-Write] True if the parameter is an input
    - ``name`` (Name):  [Read-Write] The name of the parameter
    """
    def __init__(self, name: Name = "None", is_input: bool = False, cpp_type: str = "", cpp_type_object: Object = None, default_value: str = "") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of the parameter
        """
        ...
    @property
    def is_input(self) -> bool:
        r"""
        (bool):  [Read-Only] True if the parameter is an input
        """
        ...
    @property
    def cpp_type(self) -> str:
        r"""
        (str):  [Read-Only] The C++ data type of the parameter
        """
        ...
    @property
    def cpp_type_object(self) -> Object:
        r"""
        (Object):  [Read-Only] The Struct of the C++ data type of the parameter (or nullptr)
        """
        ...
    @property
    def default_value(self) -> str:
        r"""
        (str):  [Read-Only] The default value of the parameter
        """
        ...

class RigVMFunctionReferenceArray(StructBase):
    r"""
    Rig VMFunction Reference Array
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMBuildData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``function_references`` (Array[RigVMFunctionReferenceNode]):  [Read-Only]
    """
    def __init__(self) -> None:
        ...

class RigStructScope(StructBase):
    r"""
    Rig Struct Scope
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMController.h
    
    """
    def __init__(self) -> None:
        ...

class RigModuleInstance(StructBase):
    r"""
    Rig Module Instance
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ModularRig.h
    
    """
    def __init__(self) -> None:
        ...

class RigModuleExecutionElement(StructBase):
    r"""
    Rig Module Execution Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ModularRig.h
    
    """
    def __init__(self) -> None:
        ...

class RigSingleParentElement(RigTransformElement):
    r"""
    Rig Single Parent Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``pose`` (RigCurrentAndInitialTransform):  [Read-Write]
    - ``selected`` (bool):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False, pose: RigCurrentAndInitialTransform = [[[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]]) -> None:
        ...

class RigElementWeight(StructBase):
    r"""
    Rig Element Weight
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``location`` (float):  [Read-Write]
    - ``rotation`` (float):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    """
    def __init__(self, location: float = 0.000000, rotation: float = 0.000000, scale: float = 0.000000) -> None:
        ...
    @property
    def location(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @location.setter
    def location(self, value: float) -> None:
        ...
    @property
    def rotation(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @rotation.setter
    def rotation(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...

class RigBoneElement(RigSingleParentElement):
    r"""
    Rig Bone Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_type`` (RigBoneType):  [Read-Only]
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``pose`` (RigCurrentAndInitialTransform):  [Read-Write]
    - ``selected`` (bool):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False, pose: RigCurrentAndInitialTransform = [[[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]], bone_type: RigBoneType = RigBoneType.IMPORTED) -> None:
        ...
    @property
    def bone_type(self) -> RigBoneType:
        r"""
        (RigBoneType):  [Read-Only]
        """
        ...

class RigNullElement(RigMultiParentElement):
    r"""
    Rig Null Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``pose`` (RigCurrentAndInitialTransform):  [Read-Write]
    - ``selected`` (bool):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False, pose: RigCurrentAndInitialTransform = [[[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]]) -> None:
        ...

class RigCurveElement(RigBaseElement):
    r"""
    Rig Curve Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``selected`` (bool):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False) -> None:
        ...

class RigRigidBodySettings(StructBase):
    r"""
    Rig Rigid Body Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``mass`` (float):  [Read-Write]
    """
    def __init__(self, mass: float = 0.000000) -> None:
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @mass.setter
    def mass(self, value: float) -> None:
        ...

class RigRigidBodyElement(RigSingleParentElement):
    r"""
    Rig Rigid Body Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``pose`` (RigCurrentAndInitialTransform):  [Read-Write]
    - ``selected`` (bool):  [Read-Write]
    - ``settings`` (RigRigidBodySettings):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False, pose: RigCurrentAndInitialTransform = [[[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]], settings: RigRigidBodySettings = [1.000000]) -> None:
        ...
    @property
    def settings(self) -> RigRigidBodySettings:
        r"""
        (RigRigidBodySettings):  [Read-Only]
        """
        ...

class RigReferenceElement(RigSingleParentElement):
    r"""
    Rig Reference Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``pose`` (RigCurrentAndInitialTransform):  [Read-Write]
    - ``selected`` (bool):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False, pose: RigCurrentAndInitialTransform = [[[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]]) -> None:
        ...

class RigConnectorState(StructBase):
    r"""
    Rig Connector State
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``resolved_target`` (RigElementKey):  [Read-Write]
    - ``settings`` (RigConnectorSettings):  [Read-Write]
    """
    def __init__(self, name: Name = "None", resolved_target: RigElementKey = [RigElementType.NONE, "None"], settings: RigConnectorSettings = ["", ConnectorType.PRIMARY, False, []]) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def resolved_target(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @resolved_target.setter
    def resolved_target(self, value: RigElementKey) -> None:
        ...
    @property
    def settings(self) -> RigConnectorSettings:
        r"""
        (RigConnectorSettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: RigConnectorSettings) -> None:
        ...

class RigConnectorElement(RigBaseElement):
    r"""
    Rig Connector Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``selected`` (bool):  [Read-Write]
    - ``settings`` (RigConnectorSettings):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False, settings: RigConnectorSettings = ["", ConnectorType.PRIMARY, False, []]) -> None:
        ...
    @property
    def settings(self) -> RigConnectorSettings:
        r"""
        (RigConnectorSettings):  [Read-Only]
        """
        ...

class RigSocketState(StructBase):
    r"""
    Rig Socket State
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``description`` (str):  [Read-Write]
    - ``initial_local_transform`` (Transform):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``parent`` (RigElementKey):  [Read-Write]
    """
    def __init__(self, name: Name = "None", parent: RigElementKey = [RigElementType.NONE, "None"], initial_local_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], description: str = "") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...
    @property
    def initial_local_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @initial_local_transform.setter
    def initial_local_transform(self, value: Transform) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def description(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @description.setter
    def description(self, value: str) -> None:
        ...

class RigSocketElement(RigSingleParentElement):
    r"""
    Rig Socket Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyElements.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``created_at_instruction_index`` (int32):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``key`` (RigElementKey):  [Read-Only]
    - ``pose`` (RigCurrentAndInitialTransform):  [Read-Write]
    - ``selected`` (bool):  [Read-Write]
    - ``sub_index`` (int32):  [Read-Only]
    """
    def __init__(self, key: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, sub_index: int = 0, created_at_instruction_index: int = 0, selected: bool = False, pose: RigCurrentAndInitialTransform = [[[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]], [[[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [[[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]]]) -> None:
        ...

class RigUnit(RigVMStruct):
    r"""
    Base class for all rig units
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_DebugBase(RigUnit):
    r"""
    Rig Unit Debug Base
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugBase.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnitMutable(RigUnit):
    r"""
    Base class for all rig units that can change data
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
        """
        ...
    @execute_context.setter
    def execute_context(self, value: ControlRigExecuteContext) -> None:
        ...

class ControlRigExecuteContext(RigVMExecuteContext):
    r"""
    Control Rig Execute Context
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnitContext.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_DebugBaseMutable(RigUnitMutable):
    r"""
    Rig Unit Debug Base Mutable
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...

class RigUnit_HighlevelBase(RigUnit):
    r"""
    Rig Unit Highlevel Base
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_HighlevelBase.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_HighlevelBaseMutable(RigUnitMutable):
    r"""
    Rig Unit Highlevel Base Mutable
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_HighlevelBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...

class ControlRigReference(AnimNodeReference):
    r"""
    Control Rig Reference
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: AnimNode_ControlRig_Library.h
    
    """
    def __init__(self) -> None:
        ...

class ControlRigComponentMappedElement(StructBase):
    r"""
    Control Rig Component Mapped Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``component_reference`` (SoftComponentReference):  [Read-Write] The component to map to the Control Rig
    - ``direction`` (ControlRigComponentMapDirection):  [Read-Write] The direction (input / output) to be used for mapping an element
    - ``element_name`` (Name):  [Read-Write] The name of the element to map to
    - ``element_type`` (RigElementType):  [Read-Write] The type of element this is mapped to
    - ``offset`` (Transform):  [Read-Write] The offset transform to apply
    - ``space`` (ControlRigComponentSpace):  [Read-Write] space in which the mapping happens
    - ``transform_index`` (int32):  [Read-Write] An optional index that can be used with components
      with multiple transforms (for example the InstancedStaticMeshComponent)
    - ``transform_name`` (Name):  [Read-Write] An optional name that can be used with components
      that have sockets (for example the SkeletalMeshComponent)
    - ``weight`` (float):  [Read-Write] defines how much the mapped element should be driven
    """
    def __init__(self, component_reference: SoftComponentReference = [None, "None"], transform_index: int = 0, transform_name: Name = "None", element_type: RigElementType = RigElementType.NONE, element_name: Name = "None", direction: ControlRigComponentMapDirection = ControlRigComponentMapDirection.INPUT, offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], weight: float = 0.000000, space: ControlRigComponentSpace = ControlRigComponentSpace.WORLD_SPACE) -> None:
        ...
    @property
    def component_reference(self) -> SoftComponentReference:
        r"""
        (SoftComponentReference):  [Read-Write] The component to map to the Control Rig
        """
        ...
    @component_reference.setter
    def component_reference(self, value: SoftComponentReference) -> None:
        ...
    @property
    def transform_index(self) -> int:
        r"""
        (int32):  [Read-Write] An optional index that can be used with components
        with multiple transforms (for example the InstancedStaticMeshComponent)
        """
        ...
    @transform_index.setter
    def transform_index(self, value: int) -> None:
        ...
    @property
    def transform_name(self) -> Name:
        r"""
        (Name):  [Read-Write] An optional name that can be used with components
        that have sockets (for example the SkeletalMeshComponent)
        """
        ...
    @transform_name.setter
    def transform_name(self, value: Name) -> None:
        ...
    @property
    def element_type(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write] The type of element this is mapped to
        """
        ...
    @element_type.setter
    def element_type(self, value: RigElementType) -> None:
        ...
    @property
    def element_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the element to map to
        """
        ...
    @element_name.setter
    def element_name(self, value: Name) -> None:
        ...
    @property
    def direction(self) -> ControlRigComponentMapDirection:
        r"""
        (ControlRigComponentMapDirection):  [Read-Write] The direction (input / output) to be used for mapping an element
        """
        ...
    @direction.setter
    def direction(self, value: ControlRigComponentMapDirection) -> None:
        ...
    @property
    def offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The offset transform to apply
        """
        ...
    @offset.setter
    def offset(self, value: Transform) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] defines how much the mapped element should be driven
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def space(self) -> ControlRigComponentSpace:
        r"""
        (ControlRigComponentSpace):  [Read-Write] space in which the mapping happens
        """
        ...
    @space.setter
    def space(self, value: ControlRigComponentSpace) -> None:
        ...

class ControlRigComponentMappedComponent(StructBase):
    r"""
    Control Rig Component Mapped Component
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``component`` (SceneComponent):  [Read-Write]
    - ``direction`` (ControlRigComponentMapDirection):  [Read-Write]
    - ``element_name`` (Name):  [Read-Write]
    - ``element_type`` (RigElementType):  [Read-Write] The type of element this is mapped to
    """
    def __init__(self, component: SceneComponent = None, element_name: Name = "None", element_type: RigElementType = RigElementType.NONE, direction: ControlRigComponentMapDirection = ControlRigComponentMapDirection.INPUT) -> None:
        ...
    @property
    def component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Write]
        """
        ...
    @component.setter
    def component(self, value: SceneComponent) -> None:
        ...
    @property
    def element_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @element_name.setter
    def element_name(self, value: Name) -> None:
        ...
    @property
    def element_type(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write] The type of element this is mapped to
        """
        ...
    @element_type.setter
    def element_type(self, value: RigElementType) -> None:
        ...
    @property
    def direction(self) -> ControlRigComponentMapDirection:
        r"""
        (ControlRigComponentMapDirection):  [Read-Write]
        """
        ...
    @direction.setter
    def direction(self, value: ControlRigComponentMapDirection) -> None:
        ...

class ControlRigComponentMappedBone(StructBase):
    r"""
    Control Rig Component Mapped Bone
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source`` (Name):  [Read-Write]
    - ``target`` (Name):  [Read-Write]
    """
    def __init__(self, source: Name = "None", target: Name = "None") -> None:
        ...
    @property
    def source(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @source.setter
    def source(self, value: Name) -> None:
        ...
    @property
    def target(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Name) -> None:
        ...

class ControlRigComponentMappedCurve(StructBase):
    r"""
    Control Rig Component Mapped Curve
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source`` (Name):  [Read-Write]
    - ``target`` (Name):  [Read-Write]
    """
    def __init__(self, source: Name = "None", target: Name = "None") -> None:
        ...
    @property
    def source(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @source.setter
    def source(self, value: Name) -> None:
        ...
    @property
    def target(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Name) -> None:
        ...

class ControlRigShapeDefinition(StructBase):
    r"""
    Control Rig Shape Definition
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigGizmoLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``shape_name`` (Name):  [Read-Write]
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    """
    def __init__(self, shape_name: Name = "None", static_mesh: StaticMesh = None, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def shape_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def gizmo_name(self) -> Name:
        r"""
        deprecated: 'gizmo_name' was renamed to 'shape_name'.
        """
        ...
    @property
    def static_mesh(self) -> StaticMesh:
        r"""
        (StaticMesh):  [Read-Only]
        """
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class ControlRigGizmoDefinition(ControlRigShapeDefinition):
    r"""
    deprecated: 'ControlRigGizmoDefinition' was renamed to 'ControlRigShapeDefinition'.
    """
    def __init__(self, shape_name: Name = "None", static_mesh: StaticMesh = None, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class ControlRigTestDataVariable(StructBase):
    r"""
    Control Rig Test Data Variable
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigTestData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cpp_type`` (Name):  [Read-Only]
    - ``name`` (Name):  [Read-Only]
    - ``value`` (str):  [Read-Only]
    """
    def __init__(self, name: Name = "None", cpp_type: Name = "None", value: str = "") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def cpp_type(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def value(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class ControlRigTestDataFrame(StructBase):
    r"""
    Control Rig Test Data Frame
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigTestData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_time`` (double):  [Read-Only]
    - ``delta_time`` (double):  [Read-Only]
    - ``pose`` (RigPose):  [Read-Only]
    - ``variables`` (Array[ControlRigTestDataVariable]):  [Read-Only]
    """
    def __init__(self, absolute_time: float = 0.000000, delta_time: float = 0.000000, variables: Array[ControlRigTestDataVariable] = [], pose: RigPose = []) -> None:
        ...
    @property
    def absolute_time(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...
    @property
    def delta_time(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...
    @property
    def variables(self) -> Array[ControlRigTestDataVariable]:
        r"""
        (Array[ControlRigTestDataVariable]):  [Read-Only]
        """
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Only]
        """
        ...

class RigPose(StructBase):
    r"""
    Rig Pose
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyPose.h
    
    """
    def __init__(self) -> None:
        ...

class RigPoseElement(StructBase):
    r"""
    Rig Pose Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyPose.h
    
    """
    def __init__(self) -> None:
        ...

class CachedRigElement(StructBase):
    r"""
    Cached Rig Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyCache.h
    
    """
    def __init__(self) -> None:
        ...

class CRSimLinearSpring(StructBase):
    r"""
    CRSim Linear Spring
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: CRSimLinearSpring.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``coefficient`` (float):  [Read-Write] The power of this spring
    - ``equilibrium`` (float):  [Read-Write] The rest length of this spring.
      A value of lower than zero indicates that the equilibrium
      should be based on the current distance of the two subjects.
    - ``subject_a`` (int32):  [Read-Write] The first point affected by this spring
    - ``subject_b`` (int32):  [Read-Write] The second point affected by this spring
    """
    def __init__(self) -> None:
        ...

class CRSimSoftCollision(StructBase):
    r"""
    CRSim Soft Collision
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: CRSimSoftCollision.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``coefficient`` (float):  [Read-Write] The strength of the collision force
    - ``falloff_type`` (RigVMAnimEasingType):  [Read-Write] The type of falloff to use
    - ``inverted`` (bool):  [Read-Write] If set to true the collision volume will be inverted
    - ``maximum_distance`` (float):  [Read-Write] The maximum distance for the collision.
      If this is equal or lower than the minimum there's no falloff.
      For a cone shape this represents the maximum angle in degrees.
    - ``minimum_distance`` (float):  [Read-Write] The minimum distance for the collision.
      If this is equal or higher than the maximum there's no falloff.
      For a cone shape this represents the minimum angle in degrees.
    - ``shape_type`` (CRSimSoftCollisionType):  [Read-Write] The type of collision shape
    - ``transform`` (Transform):  [Read-Write] The world / global transform of the collisoin
    """
    def __init__(self) -> None:
        ...

class CRSimPointForce(StructBase):
    r"""
    CRSim Point Force
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: CRSimPointForce.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``coefficient`` (float):  [Read-Write] The strength of the force (a multiplier for direction based forces)
    - ``force_type`` (CRSimPointForceType):  [Read-Write] The type of force.
    - ``normalize`` (bool):  [Read-Write] If set to true the input vector will be normalized.
    - ``vector`` (Vector):  [Read-Write] The point / direction to use for the force.
      This is a direction for direction based forces,
      while this is a position for attractor / repel based forces.
    """
    def __init__(self) -> None:
        ...

class RigModuleReference(StructBase):
    r"""
    Rig Module Reference
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ModularRigModel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``connections`` (Map[RigElementKey, RigElementKey]):  [Read-Write]
      deprecated: Property 'Connections' is deprecated.
    """
    def __init__(self) -> None:
        ...
    @property
    def connections(self) -> Map[RigElementKey, RigElementKey]:
        r"""
        (Map[RigElementKey, RigElementKey]):  [Read-Write]
        deprecated: Property 'Connections' is deprecated.
        """
        ...
    @connections.setter
    def connections(self, value: Map[RigElementKey, RigElementKey]) -> None:
        ...

class ModularRigSingleConnection(StructBase):
    r"""
    Modular Rig Single Connection
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ModularRigModel.h
    
    """
    def __init__(self) -> None:
        ...

class ModularRigConnections(StructBase):
    r"""
    Modular Rig Connections
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ModularRigModel.h
    
    """
    def __init__(self) -> None:
        ...

class ModularRigModel(StructBase):
    r"""
    A management struct containing all modules in the rig
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ModularRigModel.h
    
    """
    def __init__(self) -> None:
        ...

class RigElement(StructBase):
    r"""
    Rig Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``index`` (int32):  [Read-Only]
    - ``name`` (Name):  [Read-Write]
    """
    def __init__(self, name: Name = "None", index: int = 0) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigBone(RigElement):
    r"""
    Rig Bone
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigBoneHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_transform`` (Transform):  [Read-Write]
    - ``index`` (int32):  [Read-Only]
    - ``initial_transform`` (Transform):  [Read-Write] Initial global transform that is saved in this rig
    - ``local_transform`` (Transform):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``parent_name`` (Name):  [Read-Only]
    - ``type`` (RigBoneType):  [Read-Only] the source of the bone to differentiate procedurally generated, imported etc
    """
    def __init__(self, name: Name = "None", index: int = 0, parent_name: Name = "None", initial_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], global_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], local_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], type: RigBoneType = RigBoneType.IMPORTED) -> None:
        ...
    @property
    def parent_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def initial_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] Initial global transform that is saved in this rig
        """
        ...
    @property
    def global_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...
    @property
    def local_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...
    @property
    def type(self) -> RigBoneType:
        r"""
        (RigBoneType):  [Read-Only] the source of the bone to differentiate procedurally generated, imported etc
        """
        ...

class RigJoint(RigBone):
    r"""
    deprecated: 'RigJoint' was renamed to 'RigBone'.
    """
    def __init__(self, name: Name = "None", index: int = 0, parent_name: Name = "None", initial_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], global_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], local_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], type: RigBoneType = RigBoneType.IMPORTED) -> None:
        ...

class RigConnectionRule(StructBase):
    r"""
    Rig Connection Rule
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigConnectionRules.h
    
    """
    def __init__(self) -> None:
        ...

class RigAndConnectionRule(RigConnectionRule):
    r"""
    Rig and Connection Rule
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigConnectionRules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_rules`` (Array[RigConnectionRuleStash]):  [Read-Write]
    """
    def __init__(self, child_rules: Array[RigConnectionRuleStash] = []) -> None:
        ...
    @property
    def child_rules(self) -> Array[RigConnectionRuleStash]:
        r"""
        (Array[RigConnectionRuleStash]):  [Read-Write]
        """
        ...
    @child_rules.setter
    def child_rules(self, value: Array[RigConnectionRuleStash]) -> None:
        ...

class RigOrConnectionRule(RigConnectionRule):
    r"""
    Rig or Connection Rule
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigConnectionRules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_rules`` (Array[RigConnectionRuleStash]):  [Read-Write]
    """
    def __init__(self, child_rules: Array[RigConnectionRuleStash] = []) -> None:
        ...
    @property
    def child_rules(self) -> Array[RigConnectionRuleStash]:
        r"""
        (Array[RigConnectionRuleStash]):  [Read-Write]
        """
        ...
    @child_rules.setter
    def child_rules(self, value: Array[RigConnectionRuleStash]) -> None:
        ...

class RigTypeConnectionRule(RigConnectionRule):
    r"""
    Rig Type Connection Rule
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigConnectionRules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``element_type`` (RigElementType):  [Read-Write]
    """
    def __init__(self, element_type: RigElementType = RigElementType.NONE) -> None:
        ...
    @property
    def element_type(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @element_type.setter
    def element_type(self, value: RigElementType) -> None:
        ...

class RigTagConnectionRule(RigConnectionRule):
    r"""
    Rig Tag Connection Rule
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigConnectionRules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``tag`` (Name):  [Read-Write]
    """
    def __init__(self, tag: Name = "None") -> None:
        ...
    @property
    def tag(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @tag.setter
    def tag(self, value: Name) -> None:
        ...

class RigChildOfPrimaryConnectionRule(RigConnectionRule):
    r"""
    Rig Child Of Primary Connection Rule
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigConnectionRules.h
    
    """
    def __init__(self) -> None:
        ...

class RigControl(RigElement):
    r"""
    Rig Control
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigControlHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animatable`` (bool):  [Read-Write] If the control is animatable in sequencer
    - ``control_enum`` (Enum):  [Read-Write] If the control is transient and only visible in the control rig editor
    - ``control_type`` (RigControlType):  [Read-Write]
    - ``display_name`` (Name):  [Read-Write]
    - ``draw_limits`` (bool):  [Read-Write] True if the limits should be drawn in debug.
    - ``gizmo_color`` (LinearColor):  [Read-Write]
    - ``gizmo_enabled`` (bool):  [Read-Write] Set to true if the gizmo is enabled in 3d
    - ``gizmo_name`` (Name):  [Read-Write] This is optional UI setting - this doesn't mean this is always used, but it is optional for manipulation layer to use this
    - ``gizmo_transform`` (Transform):  [Read-Write]
    - ``gizmo_visible`` (bool):  [Read-Write] Set to true if the gizmo is currently visible in 3d
    - ``index`` (int32):  [Read-Only]
    - ``initial_value`` (RigControlValue):  [Read-Only] The value that a control is reset to during begin play or when the
      control rig is instantiated.
    - ``is_transient_control`` (bool):  [Read-Write] If the control is transient and only visible in the control rig editor
    - ``limit_rotation`` (bool):  [Read-Write] True if the control has to obey rotation limits.
    - ``limit_scale`` (bool):  [Read-Write] True if the control has to obey scale limits.
    - ``limit_translation`` (bool):  [Read-Write] True if the control has to obey translation limits.
    - ``maximum_value`` (RigControlValue):  [Read-Write] The maximum limit of the control's value
    - ``minimum_value`` (RigControlValue):  [Read-Write] The minimum limit of the control's value
    - ``name`` (Name):  [Read-Write]
    - ``offset_transform`` (Transform):  [Read-Write] Used to offset a control in global space. This can be useful
      to offset a float control by rotating it or translating it.
    - ``parent_index`` (int32):  [Read-Write]
    - ``parent_name`` (Name):  [Read-Only]
    - ``primary_axis`` (RigControlAxis):  [Read-Write] the primary axis to use for float controls
    - ``space_index`` (int32):  [Read-Write]
    - ``space_name`` (Name):  [Read-Only]
    - ``value`` (RigControlValue):  [Read-Only] The current value of the control.
    """
    def __init__(self, name: Name = "None", index: int = 0, control_type: RigControlType = RigControlType.BOOL, display_name: Name = "None", parent_name: Name = "None", parent_index: int = 0, space_name: Name = "None", space_index: int = 0, offset_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], initial_value: RigControlValue = [], value: RigControlValue = [], primary_axis: RigControlAxis = RigControlAxis.X, animatable: bool = False, limit_translation: bool = False, limit_rotation: bool = False, limit_scale: bool = False, draw_limits: bool = False, minimum_value: RigControlValue = [], maximum_value: RigControlValue = [], gizmo_enabled: bool = False, gizmo_visible: bool = False, gizmo_name: Name = "None", gizmo_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], gizmo_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], is_transient_control: bool = False, control_enum: Enum = None) -> None:
        ...
    @property
    def control_type(self) -> RigControlType:
        r"""
        (RigControlType):  [Read-Write]
        """
        ...
    @control_type.setter
    def control_type(self, value: RigControlType) -> None:
        ...
    @property
    def display_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @display_name.setter
    def display_name(self, value: Name) -> None:
        ...
    @property
    def parent_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def parent_index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def space_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def space_index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def offset_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Used to offset a control in global space. This can be useful
        to offset a float control by rotating it or translating it.
        """
        ...
    @offset_transform.setter
    def offset_transform(self, value: Transform) -> None:
        ...
    @property
    def initial_value(self) -> RigControlValue:
        r"""
        (RigControlValue):  [Read-Only] The value that a control is reset to during begin play or when the
        control rig is instantiated.
        """
        ...
    @property
    def value(self) -> RigControlValue:
        r"""
        (RigControlValue):  [Read-Only] The current value of the control.
        """
        ...
    @property
    def primary_axis(self) -> RigControlAxis:
        r"""
        (RigControlAxis):  [Read-Write] the primary axis to use for float controls
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: RigControlAxis) -> None:
        ...
    @property
    def animatable(self) -> bool:
        r"""
        (bool):  [Read-Write] If the control is animatable in sequencer
        """
        ...
    @animatable.setter
    def animatable(self, value: bool) -> None:
        ...
    @property
    def limit_translation(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the control has to obey translation limits.
        """
        ...
    @limit_translation.setter
    def limit_translation(self, value: bool) -> None:
        ...
    @property
    def limit_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the control has to obey rotation limits.
        """
        ...
    @limit_rotation.setter
    def limit_rotation(self, value: bool) -> None:
        ...
    @property
    def limit_scale(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the control has to obey scale limits.
        """
        ...
    @limit_scale.setter
    def limit_scale(self, value: bool) -> None:
        ...
    @property
    def draw_limits(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the limits should be drawn in debug.
        """
        ...
    @draw_limits.setter
    def draw_limits(self, value: bool) -> None:
        ...
    @property
    def minimum_value(self) -> RigControlValue:
        r"""
        (RigControlValue):  [Read-Write] The minimum limit of the control's value
        """
        ...
    @minimum_value.setter
    def minimum_value(self, value: RigControlValue) -> None:
        ...
    @property
    def maximum_value(self) -> RigControlValue:
        r"""
        (RigControlValue):  [Read-Write] The maximum limit of the control's value
        """
        ...
    @maximum_value.setter
    def maximum_value(self, value: RigControlValue) -> None:
        ...
    @property
    def gizmo_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Set to true if the gizmo is enabled in 3d
        """
        ...
    @gizmo_enabled.setter
    def gizmo_enabled(self, value: bool) -> None:
        ...
    @property
    def gizmo_visible(self) -> bool:
        r"""
        (bool):  [Read-Write] Set to true if the gizmo is currently visible in 3d
        """
        ...
    @gizmo_visible.setter
    def gizmo_visible(self, value: bool) -> None:
        ...
    @property
    def gizmo_name(self) -> Name:
        r"""
        (Name):  [Read-Write] This is optional UI setting - this doesn't mean this is always used, but it is optional for manipulation layer to use this
        """
        ...
    @gizmo_name.setter
    def gizmo_name(self, value: Name) -> None:
        ...
    @property
    def gizmo_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @gizmo_transform.setter
    def gizmo_transform(self, value: Transform) -> None:
        ...
    @property
    def gizmo_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @gizmo_color.setter
    def gizmo_color(self, value: LinearColor) -> None:
        ...
    @property
    def is_transient_control(self) -> bool:
        r"""
        (bool):  [Read-Write] If the control is transient and only visible in the control rig editor
        """
        ...
    @is_transient_control.setter
    def is_transient_control(self, value: bool) -> None:
        ...
    @property
    def control_enum(self) -> Enum:
        r"""
        (Enum):  [Read-Only] If the control is transient and only visible in the control rig editor
        """
        ...

class RigCurve(RigElement):
    r"""
    Rig Curve
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigCurveContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``index`` (int32):  [Read-Only]
    - ``name`` (Name):  [Read-Write]
    - ``value`` (float):  [Read-Only]
    """
    def __init__(self, name: Name = "None", index: int = 0, value: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigSpace(RigElement):
    r"""
    Rig Space
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigSpaceHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``index`` (int32):  [Read-Only]
    - ``initial_transform`` (Transform):  [Read-Write]
    - ``local_transform`` (Transform):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``parent_index`` (int32):  [Read-Write]
    - ``parent_name`` (Name):  [Read-Only]
    - ``space_type`` (RigSpaceType):  [Read-Only]
    """
    def __init__(self, name: Name = "None", index: int = 0, space_type: RigSpaceType = RigSpaceType.GLOBAL, parent_name: Name = "None", parent_index: int = 0, initial_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], local_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def space_type(self) -> RigSpaceType:
        r"""
        (RigSpaceType):  [Read-Only]
        """
        ...
    @property
    def parent_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def parent_index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def initial_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...
    @property
    def local_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigControlModifiedContext(StructBase):
    r"""
    Rig Control Modified Context
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """
    def __init__(self) -> None:
        ...

class RigElementKeyCollection(StructBase):
    r"""
    Rig Element Key Collection
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``keys`` (Array[RigElementKey]):  [Read-Write]
    """
    def __init__(self, keys: Array[RigElementKey] = []) -> None:
        ...
    @property
    def keys(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write]
        """
        ...
    @keys.setter
    def keys(self, value: Array[RigElementKey]) -> None:
        ...

class RigEventContext(StructBase):
    r"""
    Rig Event Context
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """
    def __init__(self) -> None:
        ...

class RigElementResolveResult(StructBase):
    r"""
    Rig Element Resolve Result
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """
    def __init__(self) -> None:
        ...

class ModularRigResolveResult(StructBase):
    r"""
    Modular Rig Resolve Result
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyDefines.h
    
    """
    def __init__(self) -> None:
        ...

class ModularRigSettings(StructBase):
    r"""
    Modular Rig Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigModuleDefines.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_resolve`` (bool):  [Read-Write] Whether or not to autoresolve secondary connectors once the primary connector is resolved
    """
    def __init__(self, auto_resolve: bool = False) -> None:
        ...
    @property
    def auto_resolve(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to autoresolve secondary connectors once the primary connector is resolved
        """
        ...
    @auto_resolve.setter
    def auto_resolve(self, value: bool) -> None:
        ...

class RigModuleDescription(StructBase):
    r"""
    Rig Module Description
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigModuleDefines.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``path`` (SoftObjectPath):  [Read-Only]
    - ``settings`` (RigModuleSettings):  [Read-Only]
    """
    def __init__(self, path: SoftObjectPath = [""], settings: RigModuleSettings = [["", "Module"], [""], "", "", "", []]) -> None:
        ...
    @property
    def path(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Only]
        """
        ...
    @property
    def settings(self) -> RigModuleSettings:
        r"""
        (RigModuleSettings):  [Read-Only]
        """
        ...

class RigControlCopy(StructBase):
    r"""
    The Data Stored For Each Control in A Pose.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control_type`` (RigControlType):  [Read-Write]
    - ``global_transform`` (Transform):  [Read-Write]
    - ``local_transform`` (Transform):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``offset_transform`` (Transform):  [Read-Write]
    - ``parent_key`` (RigElementKey):  [Read-Write]
    - ``parent_transform`` (Transform):  [Read-Write]
    """
    def __init__(self, name: Name = "None", control_type: RigControlType = RigControlType.BOOL, parent_key: RigElementKey = [RigElementType.NONE, "None"], offset_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], parent_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], local_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], global_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def control_type(self) -> RigControlType:
        r"""
        (RigControlType):  [Read-Write]
        """
        ...
    @control_type.setter
    def control_type(self, value: RigControlType) -> None:
        ...
    @property
    def parent_key(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @parent_key.setter
    def parent_key(self, value: RigElementKey) -> None:
        ...
    @property
    def offset_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @offset_transform.setter
    def offset_transform(self, value: Transform) -> None:
        ...
    @property
    def parent_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @parent_transform.setter
    def parent_transform(self, value: Transform) -> None:
        ...
    @property
    def local_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @local_transform.setter
    def local_transform(self, value: Transform) -> None:
        ...
    @property
    def global_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @global_transform.setter
    def global_transform(self, value: Transform) -> None:
        ...

class ControlRigControlPose(StructBase):
    r"""
    The Data Stored For Each Pose and associated Functions to Store and Paste It
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``copy_of_controls`` (Array[RigControlCopy]):  [Read-Write]
    """
    def __init__(self, copy_of_controls: Array[RigControlCopy] = []) -> None:
        ...
    @property
    def copy_of_controls(self) -> Array[RigControlCopy]:
        r"""
        (Array[RigControlCopy]):  [Read-Write]
        """
        ...
    @copy_of_controls.setter
    def copy_of_controls(self, value: Array[RigControlCopy]) -> None:
        ...

class RigVMDispatchFactory(StructBase):
    r"""
    A factory to generate a template and its dispatch functions
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMDispatchFactory.h
    
    """
    def __init__(self) -> None:
        ...

class RigDispatchFactory(RigVMDispatchFactory):
    r"""
    Base class for all rig dispatch factories
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigDispatchFactory.h
    
    """
    def __init__(self) -> None:
        ...

class RigDispatch_AnimAttributeBase(RigDispatchFactory):
    r"""
    Animation Attributes allow dynamically added data to flow from
    one Anim Node to other Anim Nodes downstream in the Anim Graph
    and accessible from deformer graph
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AnimAttribute.h
    
    """
    def __init__(self) -> None:
        ...

class RigDispatch_GetAnimAttribute(RigDispatch_AnimAttributeBase):
    r"""
    * Get the value of an animation attribute from the skeletal mesh
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AnimAttribute.h
    
    """
    def __init__(self) -> None:
        ...

class RigDispatch_SetAnimAttribute(RigDispatch_AnimAttributeBase):
    r"""
    * Modify an animation attribute if one is found, otherwise add a new animation attribute
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AnimAttribute.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_SphereTraceWorld(RigUnit):
    r"""
    Sweeps a sphere against the world and return the first blocking hit using a specific channel
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_WorldCollision.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (CollisionChannel):  [Read-Write] The 'channel' that this trace is in, used to determine which components to hit
    - ``end`` (Vector):  [Read-Write] End of the trace in rig / global space
    - ``hit`` (bool):  [Read-Write] Returns true if there was a hit
    - ``hit_location`` (Vector):  [Read-Write] Hit location in rig / global Space
    - ``hit_normal`` (Vector):  [Read-Write] Hit normal in rig / global Space
    - ``radius`` (float):  [Read-Write] Radius of the sphere to use for sweeping / tracing
    - ``start`` (Vector):  [Read-Write] Start of the trace in rig / global space
    """
    def __init__(self, start: Vector = [0.000000, 0.000000, 0.000000], end: Vector = [0.000000, 0.000000, 0.000000], channel: CollisionChannel = CollisionChannel.ECC_WORLD_STATIC, radius: float = 0.000000, hit: bool = False, hit_location: Vector = [0.000000, 0.000000, 0.000000], hit_normal: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def start(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Start of the trace in rig / global space
        """
        ...
    @start.setter
    def start(self, value: Vector) -> None:
        ...
    @property
    def end(self) -> Vector:
        r"""
        (Vector):  [Read-Write] End of the trace in rig / global space
        """
        ...
    @end.setter
    def end(self, value: Vector) -> None:
        ...
    @property
    def channel(self) -> CollisionChannel:
        r"""
        (CollisionChannel):  [Read-Write] The 'channel' that this trace is in, used to determine which components to hit
        """
        ...
    @channel.setter
    def channel(self, value: CollisionChannel) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write] Radius of the sphere to use for sweeping / tracing
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def hit(self) -> bool:
        r"""
        (bool):  [Read-Only] Returns true if there was a hit
        """
        ...
    @property
    def hit_location(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Hit location in rig / global Space
        """
        ...
    @property
    def hit_normal(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Hit normal in rig / global Space
        """
        ...

class RigUnit_SphereTraceByTraceChannel(RigUnit):
    r"""
    Sweeps a sphere against the world and return the first blocking hit using a specific channel. Target objects can have different object types, but they need to have the same trace channel set to "block" in their collision response settings.
    You can create custom trace channels in Project Setting - Collision.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_WorldCollision.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end`` (Vector):  [Read-Write] End of the trace in rig / global space
    - ``hit`` (bool):  [Read-Write] Returns true if there was a hit
    - ``hit_location`` (Vector):  [Read-Write] Hit location in rig / global Space
    - ``hit_normal`` (Vector):  [Read-Write] Hit normal in rig / global Space
    - ``radius`` (float):  [Read-Write] Radius of the sphere to use for sweeping / tracing
    - ``start`` (Vector):  [Read-Write] Start of the trace in rig / global space
    - ``trace_channel`` (TraceTypeQuery):  [Read-Write] The 'channel' that this trace is in, used to determine which components to hit
    """
    def __init__(self, start: Vector = [0.000000, 0.000000, 0.000000], end: Vector = [0.000000, 0.000000, 0.000000], trace_channel: TraceTypeQuery = TraceTypeQuery.TRACE_TYPE_QUERY1, radius: float = 0.000000, hit: bool = False, hit_location: Vector = [0.000000, 0.000000, 0.000000], hit_normal: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def start(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Start of the trace in rig / global space
        """
        ...
    @start.setter
    def start(self, value: Vector) -> None:
        ...
    @property
    def end(self) -> Vector:
        r"""
        (Vector):  [Read-Write] End of the trace in rig / global space
        """
        ...
    @end.setter
    def end(self, value: Vector) -> None:
        ...
    @property
    def trace_channel(self) -> TraceTypeQuery:
        r"""
        (TraceTypeQuery):  [Read-Write] The 'channel' that this trace is in, used to determine which components to hit
        """
        ...
    @trace_channel.setter
    def trace_channel(self, value: TraceTypeQuery) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write] Radius of the sphere to use for sweeping / tracing
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def hit(self) -> bool:
        r"""
        (bool):  [Read-Only] Returns true if there was a hit
        """
        ...
    @property
    def hit_location(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Hit location in rig / global Space
        """
        ...
    @property
    def hit_normal(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Hit normal in rig / global Space
        """
        ...

class RigUnit_SphereTraceByObjectTypes(RigUnit):
    r"""
    Sweeps a sphere against the world and return the first blocking hit. The trace is filtered by object types only, the collision response settings are ignored.
    You can create custom object types in Project Setting - Collision
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_WorldCollision.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end`` (Vector):  [Read-Write] End of the trace in rig / global space
    - ``hit`` (bool):  [Read-Write] Returns true if there was a hit
    - ``hit_location`` (Vector):  [Read-Write] Hit location in rig / global Space
    - ``hit_normal`` (Vector):  [Read-Write] Hit normal in rig / global Space
    - ``object_types`` (Array[ObjectTypeQuery]):  [Read-Write] The types of objects that this trace can hit
    - ``radius`` (float):  [Read-Write] Radius of the sphere to use for sweeping / tracing
    - ``start`` (Vector):  [Read-Write] Start of the trace in rig / global space
    """
    def __init__(self, start: Vector = [0.000000, 0.000000, 0.000000], end: Vector = [0.000000, 0.000000, 0.000000], object_types: Array[ObjectTypeQuery] = [], radius: float = 0.000000, hit: bool = False, hit_location: Vector = [0.000000, 0.000000, 0.000000], hit_normal: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def start(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Start of the trace in rig / global space
        """
        ...
    @start.setter
    def start(self, value: Vector) -> None:
        ...
    @property
    def end(self) -> Vector:
        r"""
        (Vector):  [Read-Write] End of the trace in rig / global space
        """
        ...
    @end.setter
    def end(self, value: Vector) -> None:
        ...
    @property
    def object_types(self) -> Array[ObjectTypeQuery]:
        r"""
        (Array[ObjectTypeQuery]):  [Read-Write] The types of objects that this trace can hit
        """
        ...
    @object_types.setter
    def object_types(self, value: Array[ObjectTypeQuery]) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write] Radius of the sphere to use for sweeping / tracing
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def hit(self) -> bool:
        r"""
        (bool):  [Read-Only] Returns true if there was a hit
        """
        ...
    @property
    def hit_location(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Hit location in rig / global Space
        """
        ...
    @property
    def hit_normal(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Hit normal in rig / global Space
        """
        ...

class RigUnit_Control(RigUnit):
    r"""
    A control unit used to drive a transform from an external source
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Control.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base`` (Transform):  [Read-Write] The base that transform is relative to
    - ``filter`` (TransformFilter):  [Read-Write] The filter determines what axes can be manipulated by the in-viewport widgets
    - ``init_transform`` (Transform):  [Read-Write] The initial transform that The Transform is initialized to.
    - ``result`` (Transform):  [Read-Write] The resultant transform of this unit (Base * Filter(Transform))
    - ``transform`` (EulerTransform):  [Read-Write] The transform of this control
    """
    def __init__(self, transform: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], base: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], init_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], filter: TransformFilter = [[True, True, True], [True, True, True], [True, True, True]]) -> None:
        ...
    @property
    def transform(self) -> EulerTransform:
        r"""
        (EulerTransform):  [Read-Write] The transform of this control
        """
        ...
    @transform.setter
    def transform(self, value: EulerTransform) -> None:
        ...
    @property
    def base(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The base that transform is relative to
        """
        ...
    @base.setter
    def base(self, value: Transform) -> None:
        ...
    @property
    def init_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The initial transform that The Transform is initialized to.
        """
        ...
    @init_transform.setter
    def init_transform(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The resultant transform of this unit (Base * Filter(Transform))
        """
        ...
    @property
    def filter(self) -> TransformFilter:
        r"""
        (TransformFilter):  [Read-Write] The filter determines what axes can be manipulated by the in-viewport widgets
        """
        ...
    @filter.setter
    def filter(self, value: TransformFilter) -> None:
        ...

class RigUnit_Control_StaticMesh(RigUnit_Control):
    r"""
    A control unit used to drive a transform from an external source
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Control_StaticMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base`` (Transform):  [Read-Write] The base that transform is relative to
    - ``filter`` (TransformFilter):  [Read-Write] The filter determines what axes can be manipulated by the in-viewport widgets
    - ``init_transform`` (Transform):  [Read-Write] The initial transform that The Transform is initialized to.
    - ``mesh_transform`` (Transform):  [Read-Write] The the transform the mesh will be rendered with (applied on top of the control's transform in the viewport)
    - ``result`` (Transform):  [Read-Write] The resultant transform of this unit (Base * Filter(Transform))
    - ``transform`` (EulerTransform):  [Read-Write] The transform of this control
    """
    def __init__(self, transform: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], base: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], init_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], filter: TransformFilter = [[True, True, True], [True, True, True], [True, True, True]], mesh_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def mesh_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The the transform the mesh will be rendered with (applied on top of the control's transform in the viewport)
        """
        ...
    @mesh_transform.setter
    def mesh_transform(self, value: Transform) -> None:
        ...

class RigDispatch_GetUserData(RigDispatchFactory):
    r"""
    * Retrieves a value from a namespaces user data
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_UserData.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_SetupShapeLibraryFromUserData(RigUnitMutable):
    r"""
    Allows to set / add a shape library on the running control rig from user data
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_UserData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``library_name`` (str):  [Read-Write] * Optionally provide the namespace of the shape library to use.
      * This is only useful if you have multiple shape libraries and you
      * want to override a specific one.
    - ``log_shape_libraries`` (bool):  [Read-Write] * If this is checked we'll output the resulting shape libraries to the log for debugging.
    - ``name_space`` (str):  [Read-Write] * The name space of the user data to look the shape library up within
    - ``path`` (str):  [Read-Write] * The path within the user data for the shape library
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], name_space: str = "", path: str = "", library_name: str = "", log_shape_libraries: bool = False) -> None:
        ...
    @property
    def name_space(self) -> str:
        r"""
        (str):  [Read-Write] * The name space of the user data to look the shape library up within
        """
        ...
    @name_space.setter
    def name_space(self, value: str) -> None:
        ...
    @property
    def path(self) -> str:
        r"""
        (str):  [Read-Write] * The path within the user data for the shape library
        """
        ...
    @path.setter
    def path(self, value: str) -> None:
        ...
    @property
    def library_name(self) -> str:
        r"""
        (str):  [Read-Write] * Optionally provide the namespace of the shape library to use.
        * This is only useful if you have multiple shape libraries and you
        * want to override a specific one.
        """
        ...
    @library_name.setter
    def library_name(self, value: str) -> None:
        ...
    @property
    def log_shape_libraries(self) -> bool:
        r"""
        (bool):  [Read-Write] * If this is checked we'll output the resulting shape libraries to the log for debugging.
        """
        ...
    @log_shape_libraries.setter
    def log_shape_libraries(self, value: bool) -> None:
        ...

class RigUnit_ShapeExists(RigUnit):
    r"""
    Checks whether or not a shape is available in the rig's shape libraries
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_UserData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (bool):  [Read-Write] * True if the shape name exists in any of the shape libraries
    - ``shape_name`` (Name):  [Read-Write] * The name of the shape to search for
    """
    def __init__(self, shape_name: Name = "None", result: bool = False) -> None:
        ...
    @property
    def shape_name(self) -> Name:
        r"""
        (Name):  [Read-Write] * The name of the shape to search for
        """
        ...
    @shape_name.setter
    def shape_name(self, value: Name) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only] * True if the shape name exists in any of the shape libraries
        """
        ...

class RigUnit_DebugBezier(RigVMFunction_DebugBaseMutable):
    r"""
    Rig Unit Debug Bezier
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugBezier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bezier`` (RigVMFourPointBezier):  [Read-Write]
    - ``color`` (LinearColor):  [Read-Write]
    - ``detail`` (int32):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``maximum_u`` (float):  [Read-Write]
    - ``minimum_u`` (float):  [Read-Write]
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], bezier: RigVMFourPointBezier = [], minimum_u: float = 0.000000, maximum_u: float = 0.000000, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, detail: int = 0, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def bezier(self) -> RigVMFourPointBezier:
        r"""
        (RigVMFourPointBezier):  [Read-Write]
        """
        ...
    @bezier.setter
    def bezier(self, value: RigVMFourPointBezier) -> None:
        ...
    @property
    def minimum_u(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum_u.setter
    def minimum_u(self, value: float) -> None:
        ...
    @property
    def maximum_u(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum_u.setter
    def maximum_u(self, value: float) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def detail(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @detail.setter
    def detail(self, value: int) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_DebugBezierItemSpace(RigVMFunction_DebugBaseMutable):
    r"""
    Rig Unit Debug Bezier Item Space
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugBezier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bezier`` (RigVMFourPointBezier):  [Read-Write]
    - ``color`` (LinearColor):  [Read-Write]
    - ``detail`` (int32):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``maximum_u`` (float):  [Read-Write]
    - ``minimum_u`` (float):  [Read-Write]
    - ``space`` (RigElementKey):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], bezier: RigVMFourPointBezier = [], minimum_u: float = 0.000000, maximum_u: float = 0.000000, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, detail: int = 0, space: RigElementKey = [RigElementType.NONE, "None"], world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def bezier(self) -> RigVMFourPointBezier:
        r"""
        (RigVMFourPointBezier):  [Read-Write]
        """
        ...
    @bezier.setter
    def bezier(self, value: RigVMFourPointBezier) -> None:
        ...
    @property
    def minimum_u(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum_u.setter
    def minimum_u(self, value: float) -> None:
        ...
    @property
    def maximum_u(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum_u.setter
    def maximum_u(self, value: float) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def detail(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @detail.setter
    def detail(self, value: int) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_DebugHierarchy(RigVMFunction_DebugBase):
    r"""
    Draws vectors on each bone in the viewport across the entire hierarchy
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], scale: float = 0.000000, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Write]
        """
        ...
    @execute_context.setter
    def execute_context(self, value: ControlRigExecuteContext) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigUnit_DebugPose(RigVMFunction_DebugBase):
    r"""
    Draws vectors on each bone in the viewport across the entire pose
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write]
    - ``pose`` (RigPose):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], pose: RigPose = [], scale: float = 0.000000, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Write]
        """
        ...
    @execute_context.setter
    def execute_context(self, value: ControlRigExecuteContext) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: RigPose) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigUnit_DebugLine(RigUnit_DebugBaseMutable):
    r"""
    Rig Unit Debug Line
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugLine.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_DebugLineItemSpace(RigUnit_DebugBaseMutable):
    r"""
    Draws a line in the viewport given a start and end vector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugLine.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Vector):  [Read-Write]
    - ``b`` (Vector):  [Read-Write]
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``space`` (RigElementKey):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], a: Vector = [0.000000, 0.000000, 0.000000], b: Vector = [0.000000, 0.000000, 0.000000], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, space: RigElementKey = [RigElementType.NONE, "None"], world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def a(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: Vector) -> None:
        ...
    @property
    def b(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: Vector) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigUnit_DebugLineStrip(RigUnit_DebugBaseMutable):
    r"""
    Rig Unit Debug Line Strip
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugLineStrip.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``points`` (Array[Vector]):  [Read-Write]
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], points: Array[Vector] = [], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def points(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Write]
        """
        ...
    @points.setter
    def points(self, value: Array[Vector]) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_DebugLineStripItemSpace(RigUnit_DebugBaseMutable):
    r"""
    Draws a line strip in the viewport given any number of points
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugLineStrip.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``points`` (Array[Vector]):  [Read-Write]
    - ``space`` (RigElementKey):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], points: Array[Vector] = [], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, space: RigElementKey = [RigElementType.NONE, "None"], world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def points(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Write]
        """
        ...
    @points.setter
    def points(self, value: Array[Vector]) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigUnit_DebugRectangle(RigUnit_DebugBaseMutable):
    r"""
    Rig Unit Debug Rectangle
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugPrimitives.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``scale`` (float):  [Read-Write]
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], scale: float = 0.000000, thickness: float = 0.000000, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_DebugRectangleItemSpace(RigUnit_DebugBaseMutable):
    r"""
    Draws a rectangle in the viewport given a transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugPrimitives.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``scale`` (float):  [Read-Write]
    - ``space`` (RigElementKey):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], scale: float = 0.000000, thickness: float = 0.000000, space: RigElementKey = [RigElementType.NONE, "None"], world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigUnit_DebugArc(RigUnit_DebugBaseMutable):
    r"""
    Rig Unit Debug Arc
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugPrimitives.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``detail`` (int32):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``maximum_degrees`` (float):  [Read-Write]
    - ``minimum_degrees`` (float):  [Read-Write]
    - ``radius`` (float):  [Read-Write]
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], radius: float = 0.000000, minimum_degrees: float = 0.000000, maximum_degrees: float = 0.000000, thickness: float = 0.000000, detail: int = 0, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def minimum_degrees(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum_degrees.setter
    def minimum_degrees(self, value: float) -> None:
        ...
    @property
    def maximum_degrees(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum_degrees.setter
    def maximum_degrees(self, value: float) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def detail(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @detail.setter
    def detail(self, value: int) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_DebugArcItemSpace(RigUnit_DebugBaseMutable):
    r"""
    Draws an arc in the viewport, can take in different min and max degrees
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugPrimitives.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``detail`` (int32):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``maximum_degrees`` (float):  [Read-Write]
    - ``minimum_degrees`` (float):  [Read-Write]
    - ``radius`` (float):  [Read-Write]
    - ``space`` (RigElementKey):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], radius: float = 0.000000, minimum_degrees: float = 0.000000, maximum_degrees: float = 0.000000, thickness: float = 0.000000, detail: int = 0, space: RigElementKey = [RigElementType.NONE, "None"], world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def minimum_degrees(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @minimum_degrees.setter
    def minimum_degrees(self, value: float) -> None:
        ...
    @property
    def maximum_degrees(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @maximum_degrees.setter
    def maximum_degrees(self, value: float) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def detail(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @detail.setter
    def detail(self, value: int) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigUnit_DebugTransform(RigUnit_DebugBase):
    r"""
    Rig Unit Debug Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``mode`` (RigUnitDebugTransformMode):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], mode: RigUnitDebugTransformMode = RigUnitDebugTransformMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, scale: float = 0.000000, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def mode(self) -> RigUnitDebugTransformMode:
        r"""
        (RigUnitDebugTransformMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitDebugTransformMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_DebugTransformMutable(RigUnit_DebugBaseMutable):
    r"""
    Rig Unit Debug Transform Mutable
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``mode`` (RigUnitDebugTransformMode):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], mode: RigUnitDebugTransformMode = RigUnitDebugTransformMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, scale: float = 0.000000, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def mode(self) -> RigUnitDebugTransformMode:
        r"""
        (RigUnitDebugTransformMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitDebugTransformMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_DebugTransformMutableItemSpace(RigUnit_DebugBaseMutable):
    r"""
    Given a transform, will draw a point, axis, or a box in the viewport
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``mode`` (RigUnitDebugTransformMode):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``space`` (RigElementKey):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], mode: RigUnitDebugTransformMode = RigUnitDebugTransformMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, scale: float = 0.000000, space: RigElementKey = [RigElementType.NONE, "None"], world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def mode(self) -> RigUnitDebugTransformMode:
        r"""
        (RigUnitDebugTransformMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitDebugTransformMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigUnit_DebugTransformArrayMutable(RigUnit_DebugBaseMutable):
    r"""
    Rig Unit Debug Transform Array Mutable
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Only]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``mode`` (RigUnitDebugTransformMode):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``space`` (Name):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transforms`` (Array[Transform]):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], transforms: Array[Transform] = [], mode: RigUnitDebugTransformMode = RigUnitDebugTransformMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, scale: float = 0.000000, space: Name = "None", world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write]
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def mode(self) -> RigUnitDebugTransformMode:
        r"""
        (RigUnitDebugTransformMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitDebugTransformMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_DebugTransformArrayMutableItemSpace(RigUnit_DebugBaseMutable):
    r"""
    Given a transform array, will draw a point, axis, or a box in the viewport
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DebugTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``mode`` (RigUnitDebugTransformMode):  [Read-Write]
    - ``parent_indices`` (Array[int32]):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``space`` (RigElementKey):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transforms`` (Array[Transform]):  [Read-Write]
    - ``world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], transforms: Array[Transform] = [], parent_indices: Array[int] = [], mode: RigUnitDebugTransformMode = RigUnitDebugTransformMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, scale: float = 0.000000, space: RigElementKey = [RigElementType.NONE, "None"], world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write]
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def parent_indices(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write]
        """
        ...
    @parent_indices.setter
    def parent_indices(self, value: Array[int]) -> None:
        ...
    @property
    def mode(self) -> RigUnitDebugTransformMode:
        r"""
        (RigUnitDebugTransformMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitDebugTransformMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class RigUnit_StartProfilingTimer(RigVMFunction_DebugBaseMutable):
    r"""
    Starts a profiling timer for debugging, used in conjunction with End Profiling Timer
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ProfilingBracket.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    """
    def __init__(self, execute_context: RigVMExecuteContext = []) -> None:
        ...

class RigUnit_EndProfilingTimer(RigVMFunction_DebugBaseMutable):
    r"""
    Ends an existing profiling timer for debugging, used in conjunction with Start Profiling Timer
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ProfilingBracket.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``number_of_measurements`` (int32):  [Read-Only]
    - ``prefix`` (str):  [Read-Only]
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], number_of_measurements: int = 0, prefix: str = "") -> None:
        ...
    @property
    def number_of_measurements(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def prefix(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigUnit_VisualDebugVector(RigUnit_DebugBase):
    r"""
    Rig Unit Visual Debug Vector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_space`` (Name):  [Read-Write]
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``mode`` (RigUnitVisualDebugPointMode):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], enabled: bool = False, mode: RigUnitVisualDebugPointMode = RigUnitVisualDebugPointMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, scale: float = 0.000000, bone_space: Name = "None") -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def mode(self) -> RigUnitVisualDebugPointMode:
        r"""
        (RigUnitVisualDebugPointMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitVisualDebugPointMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bone_space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @bone_space.setter
    def bone_space(self, value: Name) -> None:
        ...

class RigUnit_VisualDebugVectorItemSpace(RigUnit_DebugBase):
    r"""
    Debug draw parameters for a Point or Vector given a vector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``mode`` (RigUnitVisualDebugPointMode):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``space`` (RigElementKey):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Vector):  [Read-Write]
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], enabled: bool = False, mode: RigUnitVisualDebugPointMode = RigUnitVisualDebugPointMode.POINT, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, scale: float = 0.000000, space: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def mode(self) -> RigUnitVisualDebugPointMode:
        r"""
        (RigUnitVisualDebugPointMode):  [Read-Write]
        """
        ...
    @mode.setter
    def mode(self, value: RigUnitVisualDebugPointMode) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...

class RigUnit_VisualDebugQuat(RigUnit_DebugBase):
    r"""
    Rig Unit Visual Debug Quat
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_space`` (Name):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], enabled: bool = False, thickness: float = 0.000000, scale: float = 0.000000, bone_space: Name = "None") -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bone_space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @bone_space.setter
    def bone_space(self, value: Name) -> None:
        ...

class RigUnit_VisualDebugQuatItemSpace(RigUnit_DebugBase):
    r"""
    Debug draw parameters for an Axis given a quaternion
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``space`` (RigElementKey):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Quat):  [Read-Write]
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], enabled: bool = False, thickness: float = 0.000000, scale: float = 0.000000, space: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...

class RigUnit_VisualDebugTransform(RigUnit_DebugBase):
    r"""
    Rig Unit Visual Debug Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_space`` (Name):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False, thickness: float = 0.000000, scale: float = 0.000000, bone_space: Name = "None") -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def bone_space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @bone_space.setter
    def bone_space(self, value: Name) -> None:
        ...

class RigUnit_VisualDebugTransformItemSpace(RigUnit_DebugBase):
    r"""
    Debug draw parameters for an Axis given a transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_VisualDebug.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    - ``space`` (RigElementKey):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``value`` (Transform):  [Read-Write]
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], enabled: bool = False, thickness: float = 0.000000, scale: float = 0.000000, space: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...

class RigUnit_ConvertTransform(RigUnit):
    r"""
    Rig Unit Convert Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Converter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input`` (Transform):  [Read-Write]
    - ``result`` (EulerTransform):  [Read-Write]
    """
    def __init__(self, input: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def input(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> EulerTransform:
        r"""
        (EulerTransform):  [Read-Only]
        """
        ...

class RigUnit_ConvertEulerTransform(RigUnit):
    r"""
    Rig Unit Convert Euler Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Converter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input`` (EulerTransform):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    """
    def __init__(self, input: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def input(self) -> EulerTransform:
        r"""
        (EulerTransform):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: EulerTransform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_ConvertRotation(RigUnit):
    r"""
    Rig Unit Convert Rotation
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Converter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input`` (Rotator):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, input: Rotator = [0.000000, 0.000000, 0.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def input(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: Rotator) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_ConvertVectorRotation(RigUnit_ConvertRotation):
    r"""
    Rig Unit Convert Vector Rotation
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Converter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input`` (Rotator):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, input: Rotator = [0.000000, 0.000000, 0.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigUnit_ConvertQuaternion(RigUnit):
    r"""
    Rig Unit Convert Quaternion
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Converter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input`` (Quat):  [Read-Write]
    - ``result`` (Rotator):  [Read-Write]
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def input(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only]
        """
        ...

class RigUnit_ConvertVectorToRotation(RigUnit):
    r"""
    Rig Unit Convert Vector to Rotation
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Converter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input`` (Vector):  [Read-Write]
    - ``result`` (Rotator):  [Read-Write]
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], result: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def input(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only]
        """
        ...

class RigUnit_ConvertVectorToQuaternion(RigUnit):
    r"""
    Rig Unit Convert Vector to Quaternion
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Converter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input`` (Vector):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, input: Vector = [0.000000, 0.000000, 0.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def input(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_ConvertRotationToVector(RigUnit):
    r"""
    Rig Unit Convert Rotation to Vector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Converter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input`` (Rotator):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, input: Rotator = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def input(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: Rotator) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_ConvertQuaternionToVector(RigUnit):
    r"""
    Rig Unit Convert Quaternion to Vector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Converter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input`` (Quat):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def input(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_ToSwingAndTwist(RigUnit):
    r"""
    Rig Unit to Swing and Twist
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Converter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input`` (Quat):  [Read-Write]
    - ``swing`` (Quat):  [Read-Write]
    - ``twist`` (Quat):  [Read-Write]
    - ``twist_axis`` (Vector):  [Read-Write]
    """
    def __init__(self, input: Quat = [0.000000, 0.000000, 0.000000, 1.000000], twist_axis: Vector = [0.000000, 0.000000, 0.000000], swing: Quat = [0.000000, 0.000000, 0.000000, 1.000000], twist: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def input(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @input.setter
    def input(self, value: Quat) -> None:
        ...
    @property
    def twist_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @twist_axis.setter
    def twist_axis(self, value: Vector) -> None:
        ...
    @property
    def swing(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...
    @property
    def twist(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_BinaryFloatOp(RigUnit):
    r"""
    Two args and a result of float type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Float.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (float):  [Read-Write]
    - ``argument1`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, argument0: float = 0.000000, argument1: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def argument0(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @argument0.setter
    def argument0(self, value: float) -> None:
        ...
    @property
    def argument1(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @argument1.setter
    def argument1(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_Multiply_FloatFloat(RigUnit_BinaryFloatOp):
    r"""
    Rig Unit Multiply Float Float
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Float.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (float):  [Read-Write]
    - ``argument1`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, argument0: float = 0.000000, argument1: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_Add_FloatFloat(RigUnit_BinaryFloatOp):
    r"""
    Rig Unit Add Float Float
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Float.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (float):  [Read-Write]
    - ``argument1`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, argument0: float = 0.000000, argument1: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_Subtract_FloatFloat(RigUnit_BinaryFloatOp):
    r"""
    Rig Unit Subtract Float Float
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Float.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (float):  [Read-Write]
    - ``argument1`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, argument0: float = 0.000000, argument1: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_Divide_FloatFloat(RigUnit_BinaryFloatOp):
    r"""
    Rig Unit Divide Float Float
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Float.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (float):  [Read-Write]
    - ``argument1`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, argument0: float = 0.000000, argument1: float = 0.000000, result: float = 0.000000) -> None:
        ...

class RigUnit_Clamp_Float(RigUnit):
    r"""
    Two args and a result of float type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Float.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max`` (float):  [Read-Write]
    - ``min`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, min: float = 0.000000, max: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def min(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @min.setter
    def min(self, value: float) -> None:
        ...
    @property
    def max(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @max.setter
    def max(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_MapRange_Float(RigUnit):
    r"""
    Two args and a result of float type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Float.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max_in`` (float):  [Read-Write]
    - ``max_out`` (float):  [Read-Write]
    - ``min_in`` (float):  [Read-Write]
    - ``min_out`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self, value: float = 0.000000, min_in: float = 0.000000, max_in: float = 0.000000, min_out: float = 0.000000, max_out: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def min_in(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @min_in.setter
    def min_in(self, value: float) -> None:
        ...
    @property
    def max_in(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @max_in.setter
    def max_in(self, value: float) -> None:
        ...
    @property
    def min_out(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @min_out.setter
    def min_out(self, value: float) -> None:
        ...
    @property
    def max_out(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @max_out.setter
    def max_out(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_BinaryQuaternionOp(RigUnit):
    r"""
    Two args and a result of Quaternion type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Quaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (Quat):  [Read-Write]
    - ``argument1`` (Quat):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, argument0: Quat = [0.000000, 0.000000, 0.000000, 1.000000], argument1: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def argument0(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @argument0.setter
    def argument0(self, value: Quat) -> None:
        ...
    @property
    def argument1(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @argument1.setter
    def argument1(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_MultiplyQuaternion(RigUnit_BinaryQuaternionOp):
    r"""
    Rig Unit Multiply Quaternion
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Quaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (Quat):  [Read-Write]
    - ``argument1`` (Quat):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, argument0: Quat = [0.000000, 0.000000, 0.000000, 1.000000], argument1: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigUnit_UnaryQuaternionOp(RigUnit):
    r"""
    Two args and a result of Quaternion type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Quaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument`` (Quat):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, argument: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def argument(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @argument.setter
    def argument(self, value: Quat) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_InverseQuaterion(RigUnit_UnaryQuaternionOp):
    r"""
    Rig Unit Inverse Quaterion
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Quaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument`` (Quat):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, argument: Quat = [0.000000, 0.000000, 0.000000, 1.000000], result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...

class RigUnit_QuaternionToAxisAndAngle(RigUnit):
    r"""
    Rig Unit Quaternion to Axis and Angle
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Quaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angle`` (float):  [Read-Write]
    - ``argument`` (Quat):  [Read-Write]
    - ``axis`` (Vector):  [Read-Write]
    """
    def __init__(self, argument: Quat = [0.000000, 0.000000, 0.000000, 1.000000], axis: Vector = [0.000000, 0.000000, 0.000000], angle: float = 0.000000) -> None:
        ...
    @property
    def argument(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @argument.setter
    def argument(self, value: Quat) -> None:
        ...
    @property
    def axis(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def angle(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_QuaternionFromAxisAndAngle(RigUnit):
    r"""
    Rig Unit Quaternion from Axis and Angle
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Quaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angle`` (float):  [Read-Write]
    - ``axis`` (Vector):  [Read-Write]
    - ``result`` (Quat):  [Read-Write]
    """
    def __init__(self, axis: Vector = [0.000000, 0.000000, 0.000000], angle: float = 0.000000, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @axis.setter
    def axis(self, value: Vector) -> None:
        ...
    @property
    def angle(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @angle.setter
    def angle(self, value: float) -> None:
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only]
        """
        ...

class RigUnit_QuaternionToAngle(RigUnit):
    r"""
    Rig Unit Quaternion to Angle
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Quaternion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angle`` (float):  [Read-Write]
    - ``argument`` (Quat):  [Read-Write]
    - ``axis`` (Vector):  [Read-Write]
    """
    def __init__(self, axis: Vector = [0.000000, 0.000000, 0.000000], argument: Quat = [0.000000, 0.000000, 0.000000, 1.000000], angle: float = 0.000000) -> None:
        ...
    @property
    def axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @axis.setter
    def axis(self, value: Vector) -> None:
        ...
    @property
    def argument(self) -> Quat:
        r"""
        (Quat):  [Read-Write]
        """
        ...
    @argument.setter
    def argument(self, value: Quat) -> None:
        ...
    @property
    def angle(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_BinaryTransformOp(RigUnit):
    r"""
    Two args and a result of Transform type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Transform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (Transform):  [Read-Write]
    - ``argument1`` (Transform):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    """
    def __init__(self, argument0: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], argument1: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def argument0(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @argument0.setter
    def argument0(self, value: Transform) -> None:
        ...
    @property
    def argument1(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @argument1.setter
    def argument1(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_MultiplyTransform(RigUnit_BinaryTransformOp):
    r"""
    Rig Unit Multiply Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Transform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (Transform):  [Read-Write]
    - ``argument1`` (Transform):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    """
    def __init__(self, argument0: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], argument1: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigUnit_GetRelativeTransform(RigUnit_BinaryTransformOp):
    r"""
    Rig Unit Get Relative Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Transform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (Transform):  [Read-Write]
    - ``argument1`` (Transform):  [Read-Write]
    - ``result`` (Transform):  [Read-Write]
    """
    def __init__(self, argument0: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], argument1: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...

class RigUnit_BinaryVectorOp(RigUnit):
    r"""
    Two args and a result of Vector type
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Vector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (Vector):  [Read-Write]
    - ``argument1`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, argument0: Vector = [0.000000, 0.000000, 0.000000], argument1: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def argument0(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @argument0.setter
    def argument0(self, value: Vector) -> None:
        ...
    @property
    def argument1(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @argument1.setter
    def argument1(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_Multiply_VectorVector(RigUnit_BinaryVectorOp):
    r"""
    Rig Unit Multiply Vector Vector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Vector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (Vector):  [Read-Write]
    - ``argument1`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, argument0: Vector = [0.000000, 0.000000, 0.000000], argument1: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_Add_VectorVector(RigUnit_BinaryVectorOp):
    r"""
    Rig Unit Add Vector Vector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Vector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (Vector):  [Read-Write]
    - ``argument1`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, argument0: Vector = [0.000000, 0.000000, 0.000000], argument1: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_Subtract_VectorVector(RigUnit_BinaryVectorOp):
    r"""
    Rig Unit Subtract Vector Vector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Vector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (Vector):  [Read-Write]
    - ``argument1`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, argument0: Vector = [0.000000, 0.000000, 0.000000], argument1: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_Divide_VectorVector(RigUnit_BinaryVectorOp):
    r"""
    Rig Unit Divide Vector Vector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Vector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (Vector):  [Read-Write]
    - ``argument1`` (Vector):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    """
    def __init__(self, argument0: Vector = [0.000000, 0.000000, 0.000000], argument1: Vector = [0.000000, 0.000000, 0.000000], result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class RigUnit_Distance_VectorVector(RigUnit):
    r"""
    Rig Unit Distance Vector Vector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Vector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``argument0`` (Vector):  [Read-Write]
    - ``argument1`` (Vector):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    """
    def __init__(self, argument0: Vector = [0.000000, 0.000000, 0.000000], argument1: Vector = [0.000000, 0.000000, 0.000000], result: float = 0.000000) -> None:
        ...
    @property
    def argument0(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @argument0.setter
    def argument0(self, value: Vector) -> None:
        ...
    @property
    def argument1(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @argument1.setter
    def argument1(self, value: Vector) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class AimTarget(StructBase):
    r"""
    Aim Target
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``align_vector`` (Vector):  [Read-Write] # Orient To Target Transforms mode only : Vector in the space of Target Transform to which the Aim Vector will be aligned
    - ``transform`` (Transform):  [Read-Write] # Aim at/Align to this Transform
    - ``weight`` (float):  [Read-Write] # Target Weight
    """
    def __init__(self) -> None:
        ...

class RigUnit_AimConstraint(RigUnitMutable):
    r"""
    Rig Unit Aim Constraint
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``aim_mode`` (AimMode):  [Read-Write] # How to perform an aim
    - ``aim_targets`` (Array[AimTarget]):  [Read-Write]
    - ``aim_vector`` (Vector):  [Read-Write] # Vector in the space of Named joint which will be aligned to the aim target
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``joint`` (Name):  [Read-Write]
    - ``up_mode`` (AimMode):  [Read-Write] # How to perform an upvector stabilization
    - ``up_targets`` (Array[AimTarget]):  [Read-Write]
    - ``up_vector`` (Vector):  [Read-Write] # Vector in the space of Named joint which will be aligned to the up target for stabilization
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], joint: Name = "None", aim_mode: AimMode = AimMode.AIM_AT_TARGET, up_mode: AimMode = AimMode.AIM_AT_TARGET, aim_vector: Vector = [0.000000, 0.000000, 0.000000], up_vector: Vector = [0.000000, 0.000000, 0.000000], aim_targets: Array[AimTarget] = [], up_targets: Array[AimTarget] = []) -> None:
        ...
    @property
    def joint(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @joint.setter
    def joint(self, value: Name) -> None:
        ...
    @property
    def aim_mode(self) -> AimMode:
        r"""
        (AimMode):  [Read-Write] # How to perform an aim
        """
        ...
    @aim_mode.setter
    def aim_mode(self, value: AimMode) -> None:
        ...
    @property
    def up_mode(self) -> AimMode:
        r"""
        (AimMode):  [Read-Write] # How to perform an upvector stabilization
        """
        ...
    @up_mode.setter
    def up_mode(self, value: AimMode) -> None:
        ...
    @property
    def aim_vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write] # Vector in the space of Named joint which will be aligned to the aim target
        """
        ...
    @aim_vector.setter
    def aim_vector(self, value: Vector) -> None:
        ...
    @property
    def up_vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write] # Vector in the space of Named joint which will be aligned to the up target for stabilization
        """
        ...
    @up_vector.setter
    def up_vector(self, value: Vector) -> None:
        ...
    @property
    def aim_targets(self) -> Array[AimTarget]:
        r"""
        (Array[AimTarget]):  [Read-Write]
        """
        ...
    @aim_targets.setter
    def aim_targets(self, value: Array[AimTarget]) -> None:
        ...
    @property
    def up_targets(self) -> Array[AimTarget]:
        r"""
        (Array[AimTarget]):  [Read-Write]
        """
        ...
    @up_targets.setter
    def up_targets(self, value: Array[AimTarget]) -> None:
        ...

class RigUnit_ApplyFK(RigUnitMutable):
    r"""
    Rig Unit Apply FK
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ApplyFK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_transform_mode`` (ApplyTransformMode):  [Read-Write]
    - ``apply_transform_space`` (TransformSpaceMode):  [Read-Write]
    - ``base_joint`` (Name):  [Read-Write] Transform op option. Use if ETransformSpace is BaseJoint
    - ``base_transform`` (Transform):  [Read-Write] Transform op option. Use if ETransformSpace is BaseTransform
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``filter`` (TransformFilter):  [Read-Write] The filter determines what axes can be manipulated by the in-viewport widgets
    - ``joint`` (Name):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], joint: Name = "None", transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], filter: TransformFilter = [[True, True, True], [True, True, True], [True, True, True]], apply_transform_mode: ApplyTransformMode = ApplyTransformMode.OVERRIDE, apply_transform_space: TransformSpaceMode = TransformSpaceMode.LOCAL_SPACE, base_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], base_joint: Name = "None") -> None:
        ...
    @property
    def joint(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @joint.setter
    def joint(self, value: Name) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def filter(self) -> TransformFilter:
        r"""
        (TransformFilter):  [Read-Write] The filter determines what axes can be manipulated by the in-viewport widgets
        """
        ...
    @filter.setter
    def filter(self, value: TransformFilter) -> None:
        ...
    @property
    def apply_transform_mode(self) -> ApplyTransformMode:
        r"""
        (ApplyTransformMode):  [Read-Write]
        """
        ...
    @apply_transform_mode.setter
    def apply_transform_mode(self, value: ApplyTransformMode) -> None:
        ...
    @property
    def apply_transform_space(self) -> TransformSpaceMode:
        r"""
        (TransformSpaceMode):  [Read-Write]
        """
        ...
    @apply_transform_space.setter
    def apply_transform_space(self, value: TransformSpaceMode) -> None:
        ...
    @property
    def base_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Transform op option. Use if ETransformSpace is BaseTransform
        """
        ...
    @base_transform.setter
    def base_transform(self, value: Transform) -> None:
        ...
    @property
    def base_joint(self) -> Name:
        r"""
        (Name):  [Read-Write] Transform op option. Use if ETransformSpace is BaseJoint
        """
        ...
    @base_joint.setter
    def base_joint(self, value: Name) -> None:
        ...

class BlendTarget(StructBase):
    r"""
    Blend Target
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BlendTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``transform`` (Transform):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class RigUnit_BlendTransform(RigUnit):
    r"""
    Rig Unit Blend Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BlendTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Transform):  [Read-Write]
    - ``source`` (Transform):  [Read-Write]
    - ``targets`` (Array[BlendTarget]):  [Read-Write]
    """
    def __init__(self, source: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], targets: Array[BlendTarget] = [], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def source(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @source.setter
    def source(self, value: Transform) -> None:
        ...
    @property
    def targets(self) -> Array[BlendTarget]:
        r"""
        (Array[BlendTarget]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[BlendTarget]) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_GetJointTransform(RigUnitMutable):
    r"""
    Rig Unit Get Joint Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetJointTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_joint`` (Name):  [Read-Write] Transform op option. Use if ETransformSpace is BaseJoint
    - ``base_transform`` (Transform):  [Read-Write] Transform op option. Use if ETransformSpace is BaseTransform
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``joint`` (Name):  [Read-Write]
    - ``output`` (Transform):  [Read-Write] possibly space, relative transform so on can be input
    - ``transform_space`` (TransformSpaceMode):  [Read-Write]
    - ``type`` (TransformGetterType):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], joint: Name = "None", type: TransformGetterType = TransformGetterType.INITIAL, transform_space: TransformSpaceMode = TransformSpaceMode.LOCAL_SPACE, base_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], base_joint: Name = "None", output: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def joint(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @joint.setter
    def joint(self, value: Name) -> None:
        ...
    @property
    def type(self) -> TransformGetterType:
        r"""
        (TransformGetterType):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: TransformGetterType) -> None:
        ...
    @property
    def transform_space(self) -> TransformSpaceMode:
        r"""
        (TransformSpaceMode):  [Read-Write]
        """
        ...
    @transform_space.setter
    def transform_space(self, value: TransformSpaceMode) -> None:
        ...
    @property
    def base_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Transform op option. Use if ETransformSpace is BaseTransform
        """
        ...
    @base_transform.setter
    def base_transform(self, value: Transform) -> None:
        ...
    @property
    def base_joint(self) -> Name:
        r"""
        (Name):  [Read-Write] Transform op option. Use if ETransformSpace is BaseJoint
        """
        ...
    @base_joint.setter
    def base_joint(self, value: Name) -> None:
        ...
    @property
    def output(self) -> Transform:
        r"""
        (Transform):  [Read-Only] possibly space, relative transform so on can be input
        """
        ...

class RigUnit_TwoBoneIKFK(RigUnitMutable):
    r"""
    Rig Unit Two Bone IKFK
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TwoBoneIKFK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_effector`` (Transform):  [Read-Write] # Transform to use as the end effector of the IK system
    - ``end_joint`` (Name):  [Read-Write]
    - ``end_joint_fk_transform`` (Transform):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``ik_blend`` (float):  [Read-Write] Float : IKBlend(Default : 0.0)             # Blend between 0.0 (FK) and 1.0 (IK)solutions
    - ``mid_joint_fk_transform`` (Transform):  [Read-Write]
    - ``pole_target`` (Vector):  [Read-Write] # Transform to use as the pole target(specifies the plane of solution)
    - ``spin`` (float):  [Read-Write] Float: Spin(Default : 0.0) # Amount of twist to apply to the solution plane(Additive after application of Pole Target motion)
    - ``start_joint`` (Name):  [Read-Write]
    - ``start_joint_fk_transform`` (Transform):  [Read-Write] Transform : Start Joint FK Transform         # Transform for the Start Joint when in FK mode
      Transform: Mid Joint FK Transform           # Transform for the Mid Joint when in FK mode
      Transform : End Joint FK Transform          # Transform for the End Joint when in FK mode
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], start_joint: Name = "None", end_joint: Name = "None", pole_target: Vector = [0.000000, 0.000000, 0.000000], spin: float = 0.000000, end_effector: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], ik_blend: float = 0.000000) -> None:
        ...
    @property
    def start_joint(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @start_joint.setter
    def start_joint(self, value: Name) -> None:
        ...
    @property
    def end_joint(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @end_joint.setter
    def end_joint(self, value: Name) -> None:
        ...
    @property
    def pole_target(self) -> Vector:
        r"""
        (Vector):  [Read-Write] # Transform to use as the pole target(specifies the plane of solution)
        """
        ...
    @pole_target.setter
    def pole_target(self, value: Vector) -> None:
        ...
    @property
    def spin(self) -> float:
        r"""
        (float):  [Read-Write] Float: Spin(Default : 0.0) # Amount of twist to apply to the solution plane(Additive after application of Pole Target motion)
        """
        ...
    @spin.setter
    def spin(self, value: float) -> None:
        ...
    @property
    def end_effector(self) -> Transform:
        r"""
        (Transform):  [Read-Write] # Transform to use as the end effector of the IK system
        """
        ...
    @end_effector.setter
    def end_effector(self, value: Transform) -> None:
        ...
    @property
    def ik_blend(self) -> float:
        r"""
        (float):  [Read-Write] Float : IKBlend(Default : 0.0)             # Blend between 0.0 (FK) and 1.0 (IK)solutions
        """
        ...
    @ik_blend.setter
    def ik_blend(self, value: float) -> None:
        ...

class RigUnit_DrawContainerGetInstruction(RigUnit):
    r"""
    Get Imported Draw Container curve transform and color
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DrawContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``instruction_name`` (Name):  [Read-Only]
    - ``transform`` (Transform):  [Read-Write]
    """
    def __init__(self, instruction_name: Name = "None", color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def instruction_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_DrawContainerSetColor(RigUnitMutable):
    r"""
    Set Imported Draw Container curve color
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DrawContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``instruction_name`` (Name):  [Read-Only]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], instruction_name: Name = "None", color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def instruction_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...

class RigUnit_DrawContainerSetThickness(RigUnitMutable):
    r"""
    Set Imported Draw Container curve thickness
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DrawContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``instruction_name`` (Name):  [Read-Only]
    - ``thickness`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], instruction_name: Name = "None", thickness: float = 0.000000) -> None:
        ...
    @property
    def instruction_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...

class RigUnit_DrawContainerSetTransform(RigUnitMutable):
    r"""
    Set Imported Draw Container curve transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DrawContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``instruction_name`` (Name):  [Read-Only]
    - ``transform`` (Transform):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], instruction_name: Name = "None", transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def instruction_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...

class RigUnit_BeginExecution(RigUnit):
    r"""
    Event for driving the skeleton hierarchy with variables and rig elements
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BeginExecution.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] The execution result
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only] The execution result
        """
        ...

class RigUnit_PreBeginExecution(RigUnit):
    r"""
    Event always executed before the forward solve
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BeginExecution.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] The execution result
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only] The execution result
        """
        ...

class RigUnit_PostBeginExecution(RigUnit):
    r"""
    Event always executed after the forward solve
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BeginExecution.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] The execution result
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only] The execution result
        """
        ...

class RigUnit_CollectionBase(RigUnit):
    r"""
    Rig Unit Collection Base
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_CollectionBaseMutable(RigUnitMutable):
    r"""
    Rig Unit Collection Base Mutable
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...

class RigUnit_CollectionChain(RigUnit_CollectionBase):
    r"""
    Creates a collection based on a first and last item within a chain.
    Chains can refer to bone chains or chains within a control hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``first_item`` (RigElementKey):  [Read-Write]
    - ``last_item`` (RigElementKey):  [Read-Write]
    - ``reverse`` (bool):  [Read-Write]
    """
    def __init__(self, first_item: RigElementKey = [RigElementType.NONE, "None"], last_item: RigElementKey = [RigElementType.NONE, "None"], reverse: bool = False, collection: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def first_item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @first_item.setter
    def first_item(self, value: RigElementKey) -> None:
        ...
    @property
    def last_item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @last_item.setter
    def last_item(self, value: RigElementKey) -> None:
        ...
    @property
    def reverse(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @reverse.setter
    def reverse(self, value: bool) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_CollectionChainArray(RigUnit_CollectionBase):
    r"""
    Creates an item array based on a first and last item within a chain.
    Chains can refer to bone chains or chains within a control hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``first_item`` (RigElementKey):  [Read-Write]
    - ``items`` (Array[RigElementKey]):  [Read-Write]
    - ``last_item`` (RigElementKey):  [Read-Write]
    - ``reverse`` (bool):  [Read-Write]
    """
    def __init__(self, first_item: RigElementKey = [RigElementType.NONE, "None"], last_item: RigElementKey = [RigElementType.NONE, "None"], reverse: bool = False, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def first_item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @first_item.setter
    def first_item(self, value: RigElementKey) -> None:
        ...
    @property
    def last_item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @last_item.setter
    def last_item(self, value: RigElementKey) -> None:
        ...
    @property
    def reverse(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @reverse.setter
    def reverse(self, value: bool) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigUnit_CollectionNameSearch(RigUnit_CollectionBase):
    r"""
    Creates a collection based on a name search.
    The name search is case sensitive.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``partial_name`` (Name):  [Read-Write]
    - ``type_to_search`` (RigElementType):  [Read-Write]
    """
    def __init__(self, partial_name: Name = "None", type_to_search: RigElementType = RigElementType.NONE, collection: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def partial_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @partial_name.setter
    def partial_name(self, value: Name) -> None:
        ...
    @property
    def type_to_search(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @type_to_search.setter
    def type_to_search(self, value: RigElementType) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_CollectionNameSearchArray(RigUnit_CollectionBase):
    r"""
    Creates an item array based on a name search.
    The name search is case sensitive.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``items`` (Array[RigElementKey]):  [Read-Write]
    - ``partial_name`` (Name):  [Read-Write]
    - ``type_to_search`` (RigElementType):  [Read-Write]
    """
    def __init__(self, partial_name: Name = "None", type_to_search: RigElementType = RigElementType.NONE, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def partial_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @partial_name.setter
    def partial_name(self, value: Name) -> None:
        ...
    @property
    def type_to_search(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @type_to_search.setter
    def type_to_search(self, value: RigElementType) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigUnit_CollectionChildren(RigUnit_CollectionBase):
    r"""
    Creates a collection based on the direct or recursive children
    of a provided parent item. Returns an empty collection for an invalid parent item.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``include_parent`` (bool):  [Read-Write]
    - ``parent`` (RigElementKey):  [Read-Write]
    - ``recursive`` (bool):  [Read-Write]
    - ``type_to_search`` (RigElementType):  [Read-Write]
    """
    def __init__(self, parent: RigElementKey = [RigElementType.NONE, "None"], include_parent: bool = False, recursive: bool = False, type_to_search: RigElementType = RigElementType.NONE, collection: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...
    @property
    def include_parent(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @include_parent.setter
    def include_parent(self, value: bool) -> None:
        ...
    @property
    def recursive(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @recursive.setter
    def recursive(self, value: bool) -> None:
        ...
    @property
    def type_to_search(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @type_to_search.setter
    def type_to_search(self, value: RigElementType) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_CollectionChildrenArray(RigUnit_CollectionBase):
    r"""
    Creates an item array based on the direct or recursive children
    of a provided parent item. Returns an empty array for an invalid parent item.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``include_parent`` (bool):  [Read-Write]
    - ``items`` (Array[RigElementKey]):  [Read-Write]
    - ``parent`` (RigElementKey):  [Read-Write]
    - ``recursive`` (bool):  [Read-Write]
    - ``type_to_search`` (RigElementType):  [Read-Write]
    """
    def __init__(self, parent: RigElementKey = [RigElementType.NONE, "None"], include_parent: bool = False, recursive: bool = False, type_to_search: RigElementType = RigElementType.NONE, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...
    @property
    def include_parent(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @include_parent.setter
    def include_parent(self, value: bool) -> None:
        ...
    @property
    def recursive(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @recursive.setter
    def recursive(self, value: bool) -> None:
        ...
    @property
    def type_to_search(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @type_to_search.setter
    def type_to_search(self, value: RigElementType) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigUnit_CollectionGetAll(RigUnit_CollectionBase):
    r"""
    Creates an item array for all elements given the filter.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``items`` (Array[RigElementKey]):  [Read-Write]
    - ``type_to_search`` (RigElementType):  [Read-Write]
    """
    def __init__(self, type_to_search: RigElementType = RigElementType.NONE, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def type_to_search(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @type_to_search.setter
    def type_to_search(self, value: RigElementType) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigUnit_CollectionReplaceItems(RigUnit_CollectionBase):
    r"""
    Replaces all names within the collection
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_duplicates`` (bool):  [Read-Write]
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``items`` (RigElementKeyCollection):  [Read-Write]
    - ``new`` (Name):  [Read-Write]
    - ``old`` (Name):  [Read-Write]
    - ``remove_invalid_items`` (bool):  [Read-Write]
    """
    def __init__(self, items: RigElementKeyCollection = [[]], old: Name = "None", new: Name = "None", remove_invalid_items: bool = False, allow_duplicates: bool = False, collection: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @items.setter
    def items(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def old(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @old.setter
    def old(self, value: Name) -> None:
        ...
    @property
    def new(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @new.setter
    def new(self, value: Name) -> None:
        ...
    @property
    def remove_invalid_items(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @remove_invalid_items.setter
    def remove_invalid_items(self, value: bool) -> None:
        ...
    @property
    def allow_duplicates(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_duplicates.setter
    def allow_duplicates(self, value: bool) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_CollectionReplaceItemsArray(RigUnit_CollectionBase):
    r"""
    Replaces all names within the item array
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_duplicates`` (bool):  [Read-Write]
    - ``items`` (Array[RigElementKey]):  [Read-Write]
    - ``new`` (Name):  [Read-Write]
    - ``old`` (Name):  [Read-Write]
    - ``remove_invalid_items`` (bool):  [Read-Write]
    - ``result`` (Array[RigElementKey]):  [Read-Write]
    """
    def __init__(self, items: Array[RigElementKey] = [], old: Name = "None", new: Name = "None", remove_invalid_items: bool = False, allow_duplicates: bool = False, result: Array[RigElementKey] = []) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write]
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def old(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @old.setter
    def old(self, value: Name) -> None:
        ...
    @property
    def new(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @new.setter
    def new(self, value: Name) -> None:
        ...
    @property
    def remove_invalid_items(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @remove_invalid_items.setter
    def remove_invalid_items(self, value: bool) -> None:
        ...
    @property
    def allow_duplicates(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_duplicates.setter
    def allow_duplicates(self, value: bool) -> None:
        ...
    @property
    def result(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigUnit_CollectionItems(RigUnit_CollectionBase):
    r"""
    Returns a collection provided a specific array of items.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_duplicates`` (bool):  [Read-Write]
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``items`` (Array[RigElementKey]):  [Read-Write]
    """
    def __init__(self, items: Array[RigElementKey] = [], allow_duplicates: bool = False, collection: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write]
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def allow_duplicates(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_duplicates.setter
    def allow_duplicates(self, value: bool) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_CollectionGetItems(RigUnit_CollectionBase):
    r"""
    Returns an array of items provided a collection
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``items`` (Array[RigElementKey]):  [Read-Write]
    """
    def __init__(self, collection: RigElementKeyCollection = [[]], items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @collection.setter
    def collection(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigUnit_CollectionGetParentIndices(RigUnit_CollectionBase):
    r"""
    Returns an array of relative parent indices for each item. Several options here
    a) If an item has multiple parents the major parent (based on the weights) will be returned.
    b) If an item has a parent that's not part of the collection INDEX_NONE will be returned.
    c) If an item has a parent that's not part of the collection, but a grand parent is we'll use that index instead.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``parent_indices`` (Array[int32]):  [Read-Write]
    """
    def __init__(self, collection: RigElementKeyCollection = [[]], parent_indices: Array[int] = []) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @collection.setter
    def collection(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def parent_indices(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Only]
        """
        ...

class RigUnit_CollectionGetParentIndicesItemArray(RigUnit_CollectionBase):
    r"""
    Returns an array of relative parent indices for each item. Several options here
    a) If an item has multiple parents the major parent (based on the weights) will be returned.
    b) If an item has a parent that's not part of the collection INDEX_NONE will be returned.
    c) If an item has a parent that's not part of the collection, but a grand parent is we'll use that index instead.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``items`` (Array[RigElementKey]):  [Read-Write]
    - ``parent_indices`` (Array[int32]):  [Read-Write]
    """
    def __init__(self, items: Array[RigElementKey] = [], parent_indices: Array[int] = []) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write]
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def parent_indices(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Only]
        """
        ...

class RigUnit_CollectionUnion(RigUnit_CollectionBase):
    r"""
    Returns the union of two provided collections
    (the combination of all items from both A and B).
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (RigElementKeyCollection):  [Read-Write]
    - ``allow_duplicates`` (bool):  [Read-Write]
    - ``b`` (RigElementKeyCollection):  [Read-Write]
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    """
    def __init__(self, a: RigElementKeyCollection = [[]], b: RigElementKeyCollection = [[]], allow_duplicates: bool = False, collection: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def a(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def b(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def allow_duplicates(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_duplicates.setter
    def allow_duplicates(self, value: bool) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_CollectionIntersection(RigUnit_CollectionBase):
    r"""
    Returns the intersection of two provided collections
    (the items present in both A and B).
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (RigElementKeyCollection):  [Read-Write]
    - ``b`` (RigElementKeyCollection):  [Read-Write]
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    """
    def __init__(self, a: RigElementKeyCollection = [[]], b: RigElementKeyCollection = [[]], collection: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def a(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def b(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_CollectionDifference(RigUnit_CollectionBase):
    r"""
    Returns the difference between two collections
    (the items present in A but not in B).
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (RigElementKeyCollection):  [Read-Write]
    - ``b`` (RigElementKeyCollection):  [Read-Write]
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    """
    def __init__(self, a: RigElementKeyCollection = [[]], b: RigElementKeyCollection = [[]], collection: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def a(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def b(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_CollectionReverse(RigUnit_CollectionBase):
    r"""
    Returns the collection in reverse order
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``reversed`` (RigElementKeyCollection):  [Read-Write]
    """
    def __init__(self, collection: RigElementKeyCollection = [[]], reversed: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @collection.setter
    def collection(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def reversed(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_CollectionCount(RigUnit_CollectionBase):
    r"""
    Returns the number of elements in a collection
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``count`` (int32):  [Read-Write]
    """
    def __init__(self, collection: RigElementKeyCollection = [[]], count: int = 0) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @collection.setter
    def collection(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def count(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class RigUnit_CollectionItemAtIndex(RigUnit_CollectionBase):
    r"""
    Returns a single item within a collection by index
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``index`` (int32):  [Read-Write]
    - ``item`` (RigElementKey):  [Read-Write]
    """
    def __init__(self, collection: RigElementKeyCollection = [[]], index: int = 0, item: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @collection.setter
    def collection(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def index(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @index.setter
    def index(self, value: int) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only]
        """
        ...

class RigUnit_CollectionLoop(RigUnit_CollectionBaseMutable):
    r"""
    Given a collection of items, execute iteratively across all items in a given collection
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``completed`` (ControlRigExecuteContext):  [Read-Write]
    - ``count`` (int32):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``index`` (int32):  [Read-Write]
    - ``item`` (RigElementKey):  [Read-Write]
    - ``ratio`` (float):  [Read-Write] Ranging from 0.0 (first item) and 1.0 (last item)
      This is useful to drive a consecutive node with a
      curve or an ease to distribute a value.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], collection: RigElementKeyCollection = [[]], item: RigElementKey = [RigElementType.NONE, "None"], index: int = 0, count: int = 0, ratio: float = 0.000000, completed: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @collection.setter
    def collection(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only]
        """
        ...
    @property
    def index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def count(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Only] Ranging from 0.0 (first item) and 1.0 (last item)
        This is useful to drive a consecutive node with a
        curve or an ease to distribute a value.
        """
        ...
    @property
    def completed(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only]
        """
        ...

class RigUnit_CollectionAddItem(RigUnit_CollectionBase):
    r"""
    Adds an element to an existing collection
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Collection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (RigElementKeyCollection):  [Read-Write]
    - ``item`` (RigElementKey):  [Read-Write]
    - ``result`` (RigElementKeyCollection):  [Read-Write]
    """
    def __init__(self, collection: RigElementKeyCollection = [[]], item: RigElementKey = [RigElementType.NONE, "None"], result: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def collection(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write]
        """
        ...
    @collection.setter
    def collection(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def result(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_DynamicHierarchyBase(RigUnit):
    r"""
    Rig Unit Dynamic Hierarchy Base
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_DynamicHierarchyBaseMutable(RigUnitMutable):
    r"""
    Rig Unit Dynamic Hierarchy Base Mutable
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...

class RigUnit_AddParent(RigUnit_DynamicHierarchyBaseMutable):
    r"""
    Adds a new parent to an element. The weight for the new parent will be 0.0.
    You can use the SetParentWeights node to change the parent weights later.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write] * The child to be parented under the new parent
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``parent`` (RigElementKey):  [Read-Write] * The new parent to be added to the child
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], parent: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The child to be parented under the new parent
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The new parent to be added to the child
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...

class RigUnit_SetDefaultParent(RigUnit_DynamicHierarchyBaseMutable):
    r"""
    Changes the default parent for an item - this removes all other current parents.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write] * The child to be parented under the new default parent
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``parent`` (RigElementKey):  [Read-Write] * The default parent to be used for the child
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], parent: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The child to be parented under the new default parent
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The default parent to be used for the child
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...

class RigUnit_SwitchParent(RigUnit_DynamicHierarchyBaseMutable):
    r"""
    Switches an element to a new parent.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write] The child to switch to a new parent
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``maintain_global`` (bool):  [Read-Write] If set to true the item will maintain its global transform,
             * otherwise it will maintain local
    - ``mode`` (RigSwitchParentMode):  [Read-Write] Depending on this the child will switch to the world,
             * back to its default or to the item provided by the Parent pin
    - ``parent`` (RigElementKey):  [Read-Write] The optional parent to switch to. This is only used if the mode is set to 'Parent Item'
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], mode: RigSwitchParentMode = RigSwitchParentMode.WORLD, child: RigElementKey = [RigElementType.NONE, "None"], parent: RigElementKey = [RigElementType.NONE, "None"], maintain_global: bool = False) -> None:
        ...
    @property
    def mode(self) -> RigSwitchParentMode:
        r"""
        (RigSwitchParentMode):  [Read-Write] Depending on this the child will switch to the world,
               * back to its default or to the item provided by the Parent pin
        """
        ...
    @mode.setter
    def mode(self, value: RigSwitchParentMode) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The child to switch to a new parent
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The optional parent to switch to. This is only used if the mode is set to 'Parent Item'
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...
    @property
    def maintain_global(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the item will maintain its global transform,
               * otherwise it will maintain local
        """
        ...
    @maintain_global.setter
    def maintain_global(self, value: bool) -> None:
        ...

class RigUnit_HierarchyGetParentWeights(RigUnit_DynamicHierarchyBase):
    r"""
    Returns the item's parents' weights
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write] * The child to retrieve the weights for
    - ``parents`` (RigElementKeyCollection):  [Read-Write] * The key for each parent
    - ``weights`` (Array[RigElementWeight]):  [Read-Write] * The weight of each parent
    """
    def __init__(self, child: RigElementKey = [RigElementType.NONE, "None"], weights: Array[RigElementWeight] = [], parents: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The child to retrieve the weights for
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def weights(self) -> Array[RigElementWeight]:
        r"""
        (Array[RigElementWeight]):  [Read-Only] * The weight of each parent
        """
        ...
    @property
    def parents(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only] * The key for each parent
        """
        ...

class RigUnit_HierarchyGetParentWeightsArray(RigUnit_DynamicHierarchyBase):
    r"""
    Returns the item's parents' weights
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write] * The child to retrieve the weights for
    - ``parents`` (Array[RigElementKey]):  [Read-Write] * The key for each parent
    - ``weights`` (Array[RigElementWeight]):  [Read-Write] * The weight of each parent
    """
    def __init__(self, child: RigElementKey = [RigElementType.NONE, "None"], weights: Array[RigElementWeight] = [], parents: Array[RigElementKey] = []) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The child to retrieve the weights for
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def weights(self) -> Array[RigElementWeight]:
        r"""
        (Array[RigElementWeight]):  [Read-Only] * The weight of each parent
        """
        ...
    @property
    def parents(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only] * The key for each parent
        """
        ...

class RigUnit_HierarchySetParentWeights(RigUnit_DynamicHierarchyBaseMutable):
    r"""
    Sets the item's parents' weights
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write] * The child to set the parents' weights for
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``weights`` (Array[RigElementWeight]):  [Read-Write] * The weights to set for the child's parents.
      * The number of weights needs to match the current number of parents.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], weights: Array[RigElementWeight] = []) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The child to set the parents' weights for
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def weights(self) -> Array[RigElementWeight]:
        r"""
        (Array[RigElementWeight]):  [Read-Write] * The weights to set for the child's parents.
        * The number of weights needs to match the current number of parents.
        """
        ...
    @weights.setter
    def weights(self, value: Array[RigElementWeight]) -> None:
        ...

class RigUnit_HierarchyReset(RigUnit_DynamicHierarchyBaseMutable):
    r"""
    Removes all elements from the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...

class RigUnit_HierarchyImportFromSkeleton(RigUnit_DynamicHierarchyBaseMutable):
    r"""
    Imports all bones (and curves) from the currently assigned skeleton.
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``include_curves`` (bool):  [Read-Write]
    - ``items`` (Array[RigElementKey]):  [Read-Write]
    - ``name_space`` (Name):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], name_space: Name = "None", include_curves: bool = False, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def name_space(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name_space.setter
    def name_space(self, value: Name) -> None:
        ...
    @property
    def include_curves(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @include_curves.setter
    def include_curves(self, value: bool) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigUnit_HierarchyRemoveElement(RigUnit_DynamicHierarchyBaseMutable):
    r"""
    Removes an element from the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] * The item to remove
    - ``success`` (bool):  [Read-Write] * True if the element has been removed successfuly
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], success: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The item to remove
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def success(self) -> bool:
        r"""
        (bool):  [Read-Only] * True if the element has been removed successfuly
        """
        ...

class RigUnit_HierarchyAddElement(RigUnit_DynamicHierarchyBaseMutable):
    r"""
    Rig Unit Hierarchy Add Element
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The parent of the new element to add
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] * The name of the new element to add
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only] * The resulting item
        """
        ...

class RigUnit_HierarchyAddBone(RigUnit_HierarchyAddElement):
    r"""
    Adds a new bone to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the transform should be interpreted in local or global space
    - ``transform`` (Transform):  [Read-Write] * The initial transform of the new element
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] * The initial transform of the new element
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the transform should be interpreted in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...

class RigUnit_HierarchyAddNull(RigUnit_HierarchyAddElement):
    r"""
    Adds a new null to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the transform should be interpreted in local or global space
    - ``transform`` (Transform):  [Read-Write] * The initial transform of the new element
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] * The initial transform of the new element
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the transform should be interpreted in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...

class RigUnit_HierarchyAddControl_Settings(StructBase):
    r"""
    Rig Unit Hierarchy Add Control Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Name):  [Read-Write]
    """
    def __init__(self, display_name: Name = "None") -> None:
        ...
    @property
    def display_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @display_name.setter
    def display_name(self, value: Name) -> None:
        ...

class RigUnit_HierarchyAddControl_ShapeSettings(StructBase):
    r"""
    Rig Unit Hierarchy Add Control Shape Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``visible`` (bool):  [Read-Write]
    """
    def __init__(self, visible: bool = False, name: Name = "None", color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def visible(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @visible.setter
    def visible(self, value: bool) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...

class RigUnit_HierarchyAddControl_ProxySettings(StructBase):
    r"""
    Rig Unit Hierarchy Add Control Proxy Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``driven_controls`` (Array[RigElementKey]):  [Read-Write]
    - ``is_proxy`` (bool):  [Read-Write]
    - ``shape_visibility`` (RigControlVisibility):  [Read-Write]
    """
    def __init__(self, is_proxy: bool = False, driven_controls: Array[RigElementKey] = [], shape_visibility: RigControlVisibility = RigControlVisibility.USER_DEFINED) -> None:
        ...
    @property
    def is_proxy(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_proxy.setter
    def is_proxy(self, value: bool) -> None:
        ...
    @property
    def driven_controls(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write]
        """
        ...
    @driven_controls.setter
    def driven_controls(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def shape_visibility(self) -> RigControlVisibility:
        r"""
        (RigControlVisibility):  [Read-Write]
        """
        ...
    @shape_visibility.setter
    def shape_visibility(self, value: RigControlVisibility) -> None:
        ...

class RigUnit_HierarchyAddControlFloat_LimitSettings(StructBase):
    r"""
    Rig Unit Hierarchy Add Control Float Limit Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``draw_limits`` (bool):  [Read-Write]
    - ``limit`` (RigControlLimitEnabled):  [Read-Write]
    - ``max_value`` (float):  [Read-Write]
    - ``min_value`` (float):  [Read-Write]
    """
    def __init__(self, limit: RigControlLimitEnabled = [False, False], min_value: float = 0.000000, max_value: float = 0.000000, draw_limits: bool = False) -> None:
        ...
    @property
    def limit(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit.setter
    def limit(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def min_value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @min_value.setter
    def min_value(self, value: float) -> None:
        ...
    @property
    def max_value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @max_value.setter
    def max_value(self, value: float) -> None:
        ...
    @property
    def draw_limits(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_limits.setter
    def draw_limits(self, value: bool) -> None:
        ...

class RigUnit_HierarchyAddControlFloat_Settings(RigUnit_HierarchyAddControl_Settings):
    r"""
    Rig Unit Hierarchy Add Control Float Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Name):  [Read-Write]
    - ``is_scale`` (bool):  [Read-Write]
    - ``limits`` (RigUnit_HierarchyAddControlFloat_LimitSettings):  [Read-Write]
    - ``primary_axis`` (RigControlAxis):  [Read-Write]
    - ``proxy`` (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
    - ``shape`` (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
    """
    def __init__(self, display_name: Name = "None", primary_axis: RigControlAxis = RigControlAxis.X, is_scale: bool = False, limits: RigUnit_HierarchyAddControlFloat_LimitSettings = [[True, True], 0.000000, 100.000000, True], shape: RigUnit_HierarchyAddControl_ShapeSettings = [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], proxy: RigUnit_HierarchyAddControl_ProxySettings = [False, [], RigControlVisibility.BASED_ON_SELECTION]) -> None:
        ...
    @property
    def primary_axis(self) -> RigControlAxis:
        r"""
        (RigControlAxis):  [Read-Write]
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: RigControlAxis) -> None:
        ...
    @property
    def is_scale(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_scale.setter
    def is_scale(self, value: bool) -> None:
        ...
    @property
    def limits(self) -> RigUnit_HierarchyAddControlFloat_LimitSettings:
        r"""
        (RigUnit_HierarchyAddControlFloat_LimitSettings):  [Read-Write]
        """
        ...
    @limits.setter
    def limits(self, value: RigUnit_HierarchyAddControlFloat_LimitSettings) -> None:
        ...
    @property
    def shape(self) -> RigUnit_HierarchyAddControl_ShapeSettings:
        r"""
        (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
        """
        ...
    @shape.setter
    def shape(self, value: RigUnit_HierarchyAddControl_ShapeSettings) -> None:
        ...
    @property
    def proxy(self) -> RigUnit_HierarchyAddControl_ProxySettings:
        r"""
        (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
        """
        ...
    @proxy.setter
    def proxy(self, value: RigUnit_HierarchyAddControl_ProxySettings) -> None:
        ...

class RigUnit_HierarchyAddControlElement(RigUnit_HierarchyAddElement):
    r"""
    Adds a new control to the hierarchy
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``offset_space`` (RigVMTransformSpace):  [Read-Write] * The space the offset is in
    - ``offset_transform`` (Transform):  [Read-Write] * The offset transform of the new control
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], offset_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], offset_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE) -> None:
        ...
    @property
    def offset_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] * The offset transform of the new control
        """
        ...
    @offset_transform.setter
    def offset_transform(self, value: Transform) -> None:
        ...
    @property
    def offset_space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] * The space the offset is in
        """
        ...
    @offset_space.setter
    def offset_space(self, value: RigVMTransformSpace) -> None:
        ...

class RigUnit_HierarchyAddControlFloat(RigUnit_HierarchyAddControlElement):
    r"""
    Adds a new control to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (float):  [Read-Write] * The initial value of the new control
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``offset_space`` (RigVMTransformSpace):  [Read-Write] * The space the offset is in
    - ``offset_transform`` (Transform):  [Read-Write] * The offset transform of the new control
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    - ``settings`` (RigUnit_HierarchyAddControlFloat_Settings):  [Read-Write] * The settings for the control
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], offset_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], offset_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial_value: float = 0.000000, settings: RigUnit_HierarchyAddControlFloat_Settings = [RigControlAxis.X, False, [[True, True], 0.000000, 100.000000, True], [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [False, [], RigControlVisibility.BASED_ON_SELECTION], "None"]) -> None:
        ...
    @property
    def initial_value(self) -> float:
        r"""
        (float):  [Read-Write] * The initial value of the new control
        """
        ...
    @initial_value.setter
    def initial_value(self, value: float) -> None:
        ...
    @property
    def settings(self) -> RigUnit_HierarchyAddControlFloat_Settings:
        r"""
        (RigUnit_HierarchyAddControlFloat_Settings):  [Read-Write] * The settings for the control
        """
        ...
    @settings.setter
    def settings(self, value: RigUnit_HierarchyAddControlFloat_Settings) -> None:
        ...

class RigUnit_HierarchyAddControlInteger_LimitSettings(StructBase):
    r"""
    Rig Unit Hierarchy Add Control Integer Limit Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``draw_limits`` (bool):  [Read-Write]
    - ``limit`` (RigControlLimitEnabled):  [Read-Write]
    - ``max_value`` (int32):  [Read-Write]
    - ``min_value`` (int32):  [Read-Write]
    """
    def __init__(self, limit: RigControlLimitEnabled = [False, False], min_value: int = 0, max_value: int = 0, draw_limits: bool = False) -> None:
        ...
    @property
    def limit(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit.setter
    def limit(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def min_value(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @min_value.setter
    def min_value(self, value: int) -> None:
        ...
    @property
    def max_value(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @max_value.setter
    def max_value(self, value: int) -> None:
        ...
    @property
    def draw_limits(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_limits.setter
    def draw_limits(self, value: bool) -> None:
        ...

class RigUnit_HierarchyAddControlInteger_Settings(RigUnit_HierarchyAddControl_Settings):
    r"""
    Rig Unit Hierarchy Add Control Integer Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control_enum`` (Enum):  [Read-Write]
    - ``display_name`` (Name):  [Read-Write]
    - ``limits`` (RigUnit_HierarchyAddControlInteger_LimitSettings):  [Read-Write]
    - ``primary_axis`` (RigControlAxis):  [Read-Write]
    - ``proxy`` (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
    - ``shape`` (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
    """
    def __init__(self, display_name: Name = "None", primary_axis: RigControlAxis = RigControlAxis.X, control_enum: Enum = None, limits: RigUnit_HierarchyAddControlInteger_LimitSettings = [[True, True], 0, 100, True], shape: RigUnit_HierarchyAddControl_ShapeSettings = [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], proxy: RigUnit_HierarchyAddControl_ProxySettings = [False, [], RigControlVisibility.BASED_ON_SELECTION]) -> None:
        ...
    @property
    def primary_axis(self) -> RigControlAxis:
        r"""
        (RigControlAxis):  [Read-Write]
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: RigControlAxis) -> None:
        ...
    @property
    def control_enum(self) -> Enum:
        r"""
        (Enum):  [Read-Write]
        """
        ...
    @control_enum.setter
    def control_enum(self, value: Enum) -> None:
        ...
    @property
    def limits(self) -> RigUnit_HierarchyAddControlInteger_LimitSettings:
        r"""
        (RigUnit_HierarchyAddControlInteger_LimitSettings):  [Read-Write]
        """
        ...
    @limits.setter
    def limits(self, value: RigUnit_HierarchyAddControlInteger_LimitSettings) -> None:
        ...
    @property
    def shape(self) -> RigUnit_HierarchyAddControl_ShapeSettings:
        r"""
        (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
        """
        ...
    @shape.setter
    def shape(self, value: RigUnit_HierarchyAddControl_ShapeSettings) -> None:
        ...
    @property
    def proxy(self) -> RigUnit_HierarchyAddControl_ProxySettings:
        r"""
        (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
        """
        ...
    @proxy.setter
    def proxy(self, value: RigUnit_HierarchyAddControl_ProxySettings) -> None:
        ...

class RigUnit_HierarchyAddControlInteger(RigUnit_HierarchyAddControlElement):
    r"""
    Adds a new control to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (int32):  [Read-Write] * The initial value of the new control
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``offset_space`` (RigVMTransformSpace):  [Read-Write] * The space the offset is in
    - ``offset_transform`` (Transform):  [Read-Write] * The offset transform of the new control
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    - ``settings`` (RigUnit_HierarchyAddControlInteger_Settings):  [Read-Write] * The settings for the control
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], offset_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], offset_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial_value: int = 0, settings: RigUnit_HierarchyAddControlInteger_Settings = [RigControlAxis.X, None, [[True, True], 0, 100, True], [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [False, [], RigControlVisibility.BASED_ON_SELECTION], "None"]) -> None:
        ...
    @property
    def initial_value(self) -> int:
        r"""
        (int32):  [Read-Write] * The initial value of the new control
        """
        ...
    @initial_value.setter
    def initial_value(self, value: int) -> None:
        ...
    @property
    def settings(self) -> RigUnit_HierarchyAddControlInteger_Settings:
        r"""
        (RigUnit_HierarchyAddControlInteger_Settings):  [Read-Write] * The settings for the control
        """
        ...
    @settings.setter
    def settings(self, value: RigUnit_HierarchyAddControlInteger_Settings) -> None:
        ...

class RigUnit_HierarchyAddControlVector2D_LimitSettings(StructBase):
    r"""
    Rig Unit Hierarchy Add Control Vector 2D Limit Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``draw_limits`` (bool):  [Read-Write]
    - ``limit_x`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_y`` (RigControlLimitEnabled):  [Read-Write]
    - ``max_value`` (Vector2D):  [Read-Write]
    - ``min_value`` (Vector2D):  [Read-Write]
    """
    def __init__(self, limit_x: RigControlLimitEnabled = [False, False], limit_y: RigControlLimitEnabled = [False, False], min_value: Vector2D = [0.000000, 0.000000], max_value: Vector2D = [0.000000, 0.000000], draw_limits: bool = False) -> None:
        ...
    @property
    def limit_x(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_x.setter
    def limit_x(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_y(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_y.setter
    def limit_y(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def min_value(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write]
        """
        ...
    @min_value.setter
    def min_value(self, value: Vector2D) -> None:
        ...
    @property
    def max_value(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write]
        """
        ...
    @max_value.setter
    def max_value(self, value: Vector2D) -> None:
        ...
    @property
    def draw_limits(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_limits.setter
    def draw_limits(self, value: bool) -> None:
        ...

class RigUnit_HierarchyAddControlVector2D_Settings(RigUnit_HierarchyAddControl_Settings):
    r"""
    Rig Unit Hierarchy Add Control Vector 2D Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Name):  [Read-Write]
    - ``filtered_channels`` (Array[RigControlTransformChannel]):  [Read-Write]
    - ``limits`` (RigUnit_HierarchyAddControlVector2D_LimitSettings):  [Read-Write]
    - ``primary_axis`` (RigControlAxis):  [Read-Write]
    - ``proxy`` (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
    - ``shape`` (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
    """
    def __init__(self, display_name: Name = "None", primary_axis: RigControlAxis = RigControlAxis.X, limits: RigUnit_HierarchyAddControlVector2D_LimitSettings = [[True, True], [True, True], [0.000000, 0.000000], [1.000000, 1.000000], True], shape: RigUnit_HierarchyAddControl_ShapeSettings = [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], proxy: RigUnit_HierarchyAddControl_ProxySettings = [False, [], RigControlVisibility.BASED_ON_SELECTION], filtered_channels: Array[RigControlTransformChannel] = []) -> None:
        ...
    @property
    def primary_axis(self) -> RigControlAxis:
        r"""
        (RigControlAxis):  [Read-Write]
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: RigControlAxis) -> None:
        ...
    @property
    def limits(self) -> RigUnit_HierarchyAddControlVector2D_LimitSettings:
        r"""
        (RigUnit_HierarchyAddControlVector2D_LimitSettings):  [Read-Write]
        """
        ...
    @limits.setter
    def limits(self, value: RigUnit_HierarchyAddControlVector2D_LimitSettings) -> None:
        ...
    @property
    def shape(self) -> RigUnit_HierarchyAddControl_ShapeSettings:
        r"""
        (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
        """
        ...
    @shape.setter
    def shape(self, value: RigUnit_HierarchyAddControl_ShapeSettings) -> None:
        ...
    @property
    def proxy(self) -> RigUnit_HierarchyAddControl_ProxySettings:
        r"""
        (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
        """
        ...
    @proxy.setter
    def proxy(self, value: RigUnit_HierarchyAddControl_ProxySettings) -> None:
        ...
    @property
    def filtered_channels(self) -> Array[RigControlTransformChannel]:
        r"""
        (Array[RigControlTransformChannel]):  [Read-Write]
        """
        ...
    @filtered_channels.setter
    def filtered_channels(self, value: Array[RigControlTransformChannel]) -> None:
        ...

class RigUnit_HierarchyAddControlVector2D(RigUnit_HierarchyAddControlElement):
    r"""
    Adds a new control to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (Vector2D):  [Read-Write] * The initial value of the new control
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``offset_space`` (RigVMTransformSpace):  [Read-Write] * The space the offset is in
    - ``offset_transform`` (Transform):  [Read-Write] * The offset transform of the new control
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    - ``settings`` (RigUnit_HierarchyAddControlVector2D_Settings):  [Read-Write] * The settings for the control
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], offset_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], offset_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial_value: Vector2D = [0.000000, 0.000000], settings: RigUnit_HierarchyAddControlVector2D_Settings = [RigControlAxis.X, [[True, True], [True, True], [0.000000, 0.000000], [1.000000, 1.000000], True], [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [False, [], RigControlVisibility.BASED_ON_SELECTION], [], "None"]) -> None:
        ...
    @property
    def initial_value(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] * The initial value of the new control
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Vector2D) -> None:
        ...
    @property
    def settings(self) -> RigUnit_HierarchyAddControlVector2D_Settings:
        r"""
        (RigUnit_HierarchyAddControlVector2D_Settings):  [Read-Write] * The settings for the control
        """
        ...
    @settings.setter
    def settings(self, value: RigUnit_HierarchyAddControlVector2D_Settings) -> None:
        ...

class RigUnit_HierarchyAddControlVector_LimitSettings(StructBase):
    r"""
    Rig Unit Hierarchy Add Control Vector Limit Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``draw_limits`` (bool):  [Read-Write]
    - ``limit_x`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_y`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_z`` (RigControlLimitEnabled):  [Read-Write]
    - ``max_value`` (Vector):  [Read-Write]
    - ``min_value`` (Vector):  [Read-Write]
    """
    def __init__(self, limit_x: RigControlLimitEnabled = [False, False], limit_y: RigControlLimitEnabled = [False, False], limit_z: RigControlLimitEnabled = [False, False], min_value: Vector = [0.000000, 0.000000, 0.000000], max_value: Vector = [0.000000, 0.000000, 0.000000], draw_limits: bool = False) -> None:
        ...
    @property
    def limit_x(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_x.setter
    def limit_x(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_y(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_y.setter
    def limit_y(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_z(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_z.setter
    def limit_z(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def min_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @min_value.setter
    def min_value(self, value: Vector) -> None:
        ...
    @property
    def max_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @max_value.setter
    def max_value(self, value: Vector) -> None:
        ...
    @property
    def draw_limits(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_limits.setter
    def draw_limits(self, value: bool) -> None:
        ...

class RigUnit_HierarchyAddControlVector_Settings(RigUnit_HierarchyAddControl_Settings):
    r"""
    Rig Unit Hierarchy Add Control Vector Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Name):  [Read-Write]
    - ``filtered_channels`` (Array[RigControlTransformChannel]):  [Read-Write]
    - ``initial_space`` (RigVMTransformSpace):  [Read-Write]
    - ``is_position`` (bool):  [Read-Write]
    - ``limits`` (RigUnit_HierarchyAddControlVector_LimitSettings):  [Read-Write]
    - ``proxy`` (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
    - ``shape`` (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
    """
    def __init__(self, display_name: Name = "None", initial_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, is_position: bool = False, limits: RigUnit_HierarchyAddControlVector_LimitSettings = [[False, False], [False, False], [False, False], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000], True], shape: RigUnit_HierarchyAddControl_ShapeSettings = [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], proxy: RigUnit_HierarchyAddControl_ProxySettings = [False, [], RigControlVisibility.BASED_ON_SELECTION], filtered_channels: Array[RigControlTransformChannel] = []) -> None:
        ...
    @property
    def initial_space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write]
        """
        ...
    @initial_space.setter
    def initial_space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def is_position(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_position.setter
    def is_position(self, value: bool) -> None:
        ...
    @property
    def limits(self) -> RigUnit_HierarchyAddControlVector_LimitSettings:
        r"""
        (RigUnit_HierarchyAddControlVector_LimitSettings):  [Read-Write]
        """
        ...
    @limits.setter
    def limits(self, value: RigUnit_HierarchyAddControlVector_LimitSettings) -> None:
        ...
    @property
    def shape(self) -> RigUnit_HierarchyAddControl_ShapeSettings:
        r"""
        (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
        """
        ...
    @shape.setter
    def shape(self, value: RigUnit_HierarchyAddControl_ShapeSettings) -> None:
        ...
    @property
    def proxy(self) -> RigUnit_HierarchyAddControl_ProxySettings:
        r"""
        (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
        """
        ...
    @proxy.setter
    def proxy(self, value: RigUnit_HierarchyAddControl_ProxySettings) -> None:
        ...
    @property
    def filtered_channels(self) -> Array[RigControlTransformChannel]:
        r"""
        (Array[RigControlTransformChannel]):  [Read-Write]
        """
        ...
    @filtered_channels.setter
    def filtered_channels(self, value: Array[RigControlTransformChannel]) -> None:
        ...

class RigUnit_HierarchyAddControlVector(RigUnit_HierarchyAddControlElement):
    r"""
    Adds a new control to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (Vector):  [Read-Write] * The initial value of the new control
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``offset_space`` (RigVMTransformSpace):  [Read-Write] * The space the offset is in
    - ``offset_transform`` (Transform):  [Read-Write] * The offset transform of the new control
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    - ``settings`` (RigUnit_HierarchyAddControlVector_Settings):  [Read-Write] * The settings for the control
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], offset_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], offset_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial_value: Vector = [0.000000, 0.000000, 0.000000], settings: RigUnit_HierarchyAddControlVector_Settings = [RigVMTransformSpace.LOCAL_SPACE, True, [[False, False], [False, False], [False, False], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000], True], [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [False, [], RigControlVisibility.BASED_ON_SELECTION], [], "None"]) -> None:
        ...
    @property
    def initial_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] * The initial value of the new control
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Vector) -> None:
        ...
    @property
    def settings(self) -> RigUnit_HierarchyAddControlVector_Settings:
        r"""
        (RigUnit_HierarchyAddControlVector_Settings):  [Read-Write] * The settings for the control
        """
        ...
    @settings.setter
    def settings(self, value: RigUnit_HierarchyAddControlVector_Settings) -> None:
        ...

class RigUnit_HierarchyAddControlRotator_LimitSettings(StructBase):
    r"""
    Rig Unit Hierarchy Add Control Rotator Limit Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``draw_limits`` (bool):  [Read-Write]
    - ``limit_pitch`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_roll`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_yaw`` (RigControlLimitEnabled):  [Read-Write]
    - ``max_value`` (Rotator):  [Read-Write]
    - ``min_value`` (Rotator):  [Read-Write]
    """
    def __init__(self, limit_pitch: RigControlLimitEnabled = [False, False], limit_yaw: RigControlLimitEnabled = [False, False], limit_roll: RigControlLimitEnabled = [False, False], min_value: Rotator = [0.000000, 0.000000, 0.000000], max_value: Rotator = [0.000000, 0.000000, 0.000000], draw_limits: bool = False) -> None:
        ...
    @property
    def limit_pitch(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_pitch.setter
    def limit_pitch(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_yaw(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_yaw.setter
    def limit_yaw(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_roll(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_roll.setter
    def limit_roll(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def min_value(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @min_value.setter
    def min_value(self, value: Rotator) -> None:
        ...
    @property
    def max_value(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @max_value.setter
    def max_value(self, value: Rotator) -> None:
        ...
    @property
    def draw_limits(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_limits.setter
    def draw_limits(self, value: bool) -> None:
        ...

class RigUnit_HierarchyAddControlRotator_Settings(RigUnit_HierarchyAddControl_Settings):
    r"""
    Rig Unit Hierarchy Add Control Rotator Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Name):  [Read-Write]
    - ``filtered_channels`` (Array[RigControlTransformChannel]):  [Read-Write]
    - ``initial_space`` (RigVMTransformSpace):  [Read-Write]
    - ``limits`` (RigUnit_HierarchyAddControlRotator_LimitSettings):  [Read-Write]
    - ``proxy`` (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
    - ``shape`` (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
    """
    def __init__(self, display_name: Name = "None", initial_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, limits: RigUnit_HierarchyAddControlRotator_LimitSettings = [[False, False], [False, False], [False, False], [-180.000000, -180.000000, -180.000000], [180.000000, 180.000000, 180.000000], True], shape: RigUnit_HierarchyAddControl_ShapeSettings = [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], proxy: RigUnit_HierarchyAddControl_ProxySettings = [False, [], RigControlVisibility.BASED_ON_SELECTION], filtered_channels: Array[RigControlTransformChannel] = []) -> None:
        ...
    @property
    def initial_space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write]
        """
        ...
    @initial_space.setter
    def initial_space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def limits(self) -> RigUnit_HierarchyAddControlRotator_LimitSettings:
        r"""
        (RigUnit_HierarchyAddControlRotator_LimitSettings):  [Read-Write]
        """
        ...
    @limits.setter
    def limits(self, value: RigUnit_HierarchyAddControlRotator_LimitSettings) -> None:
        ...
    @property
    def shape(self) -> RigUnit_HierarchyAddControl_ShapeSettings:
        r"""
        (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
        """
        ...
    @shape.setter
    def shape(self, value: RigUnit_HierarchyAddControl_ShapeSettings) -> None:
        ...
    @property
    def proxy(self) -> RigUnit_HierarchyAddControl_ProxySettings:
        r"""
        (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
        """
        ...
    @proxy.setter
    def proxy(self, value: RigUnit_HierarchyAddControl_ProxySettings) -> None:
        ...
    @property
    def filtered_channels(self) -> Array[RigControlTransformChannel]:
        r"""
        (Array[RigControlTransformChannel]):  [Read-Write]
        """
        ...
    @filtered_channels.setter
    def filtered_channels(self, value: Array[RigControlTransformChannel]) -> None:
        ...

class RigUnit_HierarchyAddControlRotator(RigUnit_HierarchyAddControlElement):
    r"""
    Adds a new control to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (Rotator):  [Read-Write] * The initial value of the new control
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``offset_space`` (RigVMTransformSpace):  [Read-Write] * The space the offset is in
    - ``offset_transform`` (Transform):  [Read-Write] * The offset transform of the new control
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    - ``settings`` (RigUnit_HierarchyAddControlRotator_Settings):  [Read-Write] * The settings for the control
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], offset_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], offset_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial_value: Rotator = [0.000000, 0.000000, 0.000000], settings: RigUnit_HierarchyAddControlRotator_Settings = [RigVMTransformSpace.LOCAL_SPACE, [[False, False], [False, False], [False, False], [-180.000000, -180.000000, -180.000000], [180.000000, 180.000000, 180.000000], True], [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [False, [], RigControlVisibility.BASED_ON_SELECTION], [], "None"]) -> None:
        ...
    @property
    def initial_value(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] * The initial value of the new control
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Rotator) -> None:
        ...
    @property
    def settings(self) -> RigUnit_HierarchyAddControlRotator_Settings:
        r"""
        (RigUnit_HierarchyAddControlRotator_Settings):  [Read-Write] * The settings for the control
        """
        ...
    @settings.setter
    def settings(self, value: RigUnit_HierarchyAddControlRotator_Settings) -> None:
        ...

class RigUnit_HierarchyAddControlTransform_LimitSettings(StructBase):
    r"""
    Rig Unit Hierarchy Add Control Transform Limit Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``draw_limits`` (bool):  [Read-Write]
    - ``limit_pitch`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_roll`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_scale_x`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_scale_y`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_scale_z`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_translation_x`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_translation_y`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_translation_z`` (RigControlLimitEnabled):  [Read-Write]
    - ``limit_yaw`` (RigControlLimitEnabled):  [Read-Write]
    - ``max_value`` (EulerTransform):  [Read-Write]
    - ``min_value`` (EulerTransform):  [Read-Write]
    """
    def __init__(self, limit_translation_x: RigControlLimitEnabled = [False, False], limit_translation_y: RigControlLimitEnabled = [False, False], limit_translation_z: RigControlLimitEnabled = [False, False], limit_pitch: RigControlLimitEnabled = [False, False], limit_yaw: RigControlLimitEnabled = [False, False], limit_roll: RigControlLimitEnabled = [False, False], limit_scale_x: RigControlLimitEnabled = [False, False], limit_scale_y: RigControlLimitEnabled = [False, False], limit_scale_z: RigControlLimitEnabled = [False, False], min_value: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], max_value: EulerTransform = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], draw_limits: bool = False) -> None:
        ...
    @property
    def limit_translation_x(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_translation_x.setter
    def limit_translation_x(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_translation_y(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_translation_y.setter
    def limit_translation_y(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_translation_z(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_translation_z.setter
    def limit_translation_z(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_pitch(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_pitch.setter
    def limit_pitch(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_yaw(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_yaw.setter
    def limit_yaw(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_roll(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_roll.setter
    def limit_roll(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_scale_x(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_scale_x.setter
    def limit_scale_x(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_scale_y(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_scale_y.setter
    def limit_scale_y(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def limit_scale_z(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @limit_scale_z.setter
    def limit_scale_z(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def min_value(self) -> EulerTransform:
        r"""
        (EulerTransform):  [Read-Write]
        """
        ...
    @min_value.setter
    def min_value(self, value: EulerTransform) -> None:
        ...
    @property
    def max_value(self) -> EulerTransform:
        r"""
        (EulerTransform):  [Read-Write]
        """
        ...
    @max_value.setter
    def max_value(self, value: EulerTransform) -> None:
        ...
    @property
    def draw_limits(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_limits.setter
    def draw_limits(self, value: bool) -> None:
        ...

class RigUnit_HierarchyAddControlTransform_Settings(RigUnit_HierarchyAddControl_Settings):
    r"""
    Rig Unit Hierarchy Add Control Transform Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Name):  [Read-Write]
    - ``filtered_channels`` (Array[RigControlTransformChannel]):  [Read-Write]
    - ``initial_space`` (RigVMTransformSpace):  [Read-Write]
    - ``limits`` (RigUnit_HierarchyAddControlTransform_LimitSettings):  [Read-Write]
    - ``preferred_rotation_order`` (EulerRotationOrder):  [Read-Write]
    - ``proxy`` (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
    - ``shape`` (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
    - ``use_preferred_rotation_order`` (bool):  [Read-Write] Enables overriding the preferred rotation order
    """
    def __init__(self, display_name: Name = "None", initial_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, use_preferred_rotation_order: bool = False, preferred_rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ, limits: RigUnit_HierarchyAddControlTransform_LimitSettings = [[False, False], [False, False], [False, False], [False, False], [False, False], [False, False], [False, False], [False, False], [False, False], [[-100.000000, -100.000000, -100.000000], [-180.000000, -180.000000, -180.000000], [0.000000, 0.000000, 0.000000]], [[100.000000, 100.000000, 100.000000], [180.000000, 180.000000, 180.000000], [10.000000, 10.000000, 10.000000]], True], shape: RigUnit_HierarchyAddControl_ShapeSettings = [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], proxy: RigUnit_HierarchyAddControl_ProxySettings = [False, [], RigControlVisibility.BASED_ON_SELECTION], filtered_channels: Array[RigControlTransformChannel] = []) -> None:
        ...
    @property
    def initial_space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write]
        """
        ...
    @initial_space.setter
    def initial_space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def use_preferred_rotation_order(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables overriding the preferred rotation order
        """
        ...
    @use_preferred_rotation_order.setter
    def use_preferred_rotation_order(self, value: bool) -> None:
        ...
    @property
    def preferred_rotation_order(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Write]
        """
        ...
    @preferred_rotation_order.setter
    def preferred_rotation_order(self, value: EulerRotationOrder) -> None:
        ...
    @property
    def limits(self) -> RigUnit_HierarchyAddControlTransform_LimitSettings:
        r"""
        (RigUnit_HierarchyAddControlTransform_LimitSettings):  [Read-Write]
        """
        ...
    @limits.setter
    def limits(self, value: RigUnit_HierarchyAddControlTransform_LimitSettings) -> None:
        ...
    @property
    def shape(self) -> RigUnit_HierarchyAddControl_ShapeSettings:
        r"""
        (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write]
        """
        ...
    @shape.setter
    def shape(self, value: RigUnit_HierarchyAddControl_ShapeSettings) -> None:
        ...
    @property
    def proxy(self) -> RigUnit_HierarchyAddControl_ProxySettings:
        r"""
        (RigUnit_HierarchyAddControl_ProxySettings):  [Read-Write]
        """
        ...
    @proxy.setter
    def proxy(self, value: RigUnit_HierarchyAddControl_ProxySettings) -> None:
        ...
    @property
    def filtered_channels(self) -> Array[RigControlTransformChannel]:
        r"""
        (Array[RigControlTransformChannel]):  [Read-Write]
        """
        ...
    @filtered_channels.setter
    def filtered_channels(self, value: Array[RigControlTransformChannel]) -> None:
        ...

class RigUnit_HierarchyAddControlTransform(RigUnit_HierarchyAddControlElement):
    r"""
    Adds a new control to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (Transform):  [Read-Write] * The initial value of the new control
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``offset_space`` (RigVMTransformSpace):  [Read-Write] * The space the offset is in
    - ``offset_transform`` (Transform):  [Read-Write] * The offset transform of the new control
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    - ``settings`` (RigUnit_HierarchyAddControlTransform_Settings):  [Read-Write] * The settings for the control
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], offset_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], offset_space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial_value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], settings: RigUnit_HierarchyAddControlTransform_Settings = [RigVMTransformSpace.LOCAL_SPACE, False, EulerRotationOrder.YZX, [[False, False], [False, False], [False, False], [False, False], [False, False], [False, False], [False, False], [False, False], [False, False], [[-100.000000, -100.000000, -100.000000], [-180.000000, -180.000000, -180.000000], [0.000000, 0.000000, 0.000000]], [[100.000000, 100.000000, 100.000000], [180.000000, 180.000000, 180.000000], [10.000000, 10.000000, 10.000000]], True], [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], [False, [], RigControlVisibility.BASED_ON_SELECTION], [], "None"]) -> None:
        ...
    @property
    def initial_value(self) -> Transform:
        r"""
        (Transform):  [Read-Write] * The initial value of the new control
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Transform) -> None:
        ...
    @property
    def settings(self) -> RigUnit_HierarchyAddControlTransform_Settings:
        r"""
        (RigUnit_HierarchyAddControlTransform_Settings):  [Read-Write] * The settings for the control
        """
        ...
    @settings.setter
    def settings(self, value: RigUnit_HierarchyAddControlTransform_Settings) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelEmptyLimitSettings(StructBase):
    r"""
    Rig Unit Hierarchy Add Animation Channel Empty Limit Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelBool(RigUnit_HierarchyAddElement):
    r"""
    Adds a new animation channel to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (bool):  [Read-Write] * The initial value of the new animation channel
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``limits_enabled`` (RigUnit_HierarchyAddAnimationChannelEmptyLimitSettings):  [Read-Write] * The enable settings for the limits
    - ``maximum_value`` (bool):  [Read-Write] * The maximum value for the animation channel
    - ``minimum_value`` (bool):  [Read-Write] * The initial value of the new animation channel
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], initial_value: bool = False, minimum_value: bool = False, maximum_value: bool = False, limits_enabled: RigUnit_HierarchyAddAnimationChannelEmptyLimitSettings = []) -> None:
        ...
    @property
    def initial_value(self) -> bool:
        r"""
        (bool):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @initial_value.setter
    def initial_value(self, value: bool) -> None:
        ...
    @property
    def minimum_value(self) -> bool:
        r"""
        (bool):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @minimum_value.setter
    def minimum_value(self, value: bool) -> None:
        ...
    @property
    def maximum_value(self) -> bool:
        r"""
        (bool):  [Read-Write] * The maximum value for the animation channel
        """
        ...
    @maximum_value.setter
    def maximum_value(self, value: bool) -> None:
        ...
    @property
    def limits_enabled(self) -> RigUnit_HierarchyAddAnimationChannelEmptyLimitSettings:
        r"""
        (RigUnit_HierarchyAddAnimationChannelEmptyLimitSettings):  [Read-Write] * The enable settings for the limits
        """
        ...
    @limits_enabled.setter
    def limits_enabled(self, value: RigUnit_HierarchyAddAnimationChannelEmptyLimitSettings) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelSingleLimitSettings(RigUnit_HierarchyAddAnimationChannelEmptyLimitSettings):
    r"""
    Rig Unit Hierarchy Add Animation Channel Single Limit Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (RigControlLimitEnabled):  [Read-Write]
    """
    def __init__(self, enabled: RigControlLimitEnabled = [False, False]) -> None:
        ...
    @property
    def enabled(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: RigControlLimitEnabled) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelFloat(RigUnit_HierarchyAddElement):
    r"""
    Adds a new animation channel to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (float):  [Read-Write] * The initial value of the new animation channel
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``limits_enabled`` (RigUnit_HierarchyAddAnimationChannelSingleLimitSettings):  [Read-Write] * The enable settings for the limits
    - ``maximum_value`` (float):  [Read-Write] * The maximum value for the animation channel
    - ``minimum_value`` (float):  [Read-Write] * The initial value of the new animation channel
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], initial_value: float = 0.000000, minimum_value: float = 0.000000, maximum_value: float = 0.000000, limits_enabled: RigUnit_HierarchyAddAnimationChannelSingleLimitSettings = [[True, True]]) -> None:
        ...
    @property
    def initial_value(self) -> float:
        r"""
        (float):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @initial_value.setter
    def initial_value(self, value: float) -> None:
        ...
    @property
    def minimum_value(self) -> float:
        r"""
        (float):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @minimum_value.setter
    def minimum_value(self, value: float) -> None:
        ...
    @property
    def maximum_value(self) -> float:
        r"""
        (float):  [Read-Write] * The maximum value for the animation channel
        """
        ...
    @maximum_value.setter
    def maximum_value(self, value: float) -> None:
        ...
    @property
    def limits_enabled(self) -> RigUnit_HierarchyAddAnimationChannelSingleLimitSettings:
        r"""
        (RigUnit_HierarchyAddAnimationChannelSingleLimitSettings):  [Read-Write] * The enable settings for the limits
        """
        ...
    @limits_enabled.setter
    def limits_enabled(self, value: RigUnit_HierarchyAddAnimationChannelSingleLimitSettings) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelScaleFloat(RigUnit_HierarchyAddElement):
    r"""
    Adds a new animation channel to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (float):  [Read-Write] * The initial value of the new animation channel
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``limits_enabled`` (RigUnit_HierarchyAddAnimationChannelSingleLimitSettings):  [Read-Write] * The enable settings for the limits
    - ``maximum_value`` (float):  [Read-Write] * The maximum value for the animation channel
    - ``minimum_value`` (float):  [Read-Write] * The initial value of the new animation channel
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], initial_value: float = 0.000000, minimum_value: float = 0.000000, maximum_value: float = 0.000000, limits_enabled: RigUnit_HierarchyAddAnimationChannelSingleLimitSettings = [[True, True]]) -> None:
        ...
    @property
    def initial_value(self) -> float:
        r"""
        (float):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @initial_value.setter
    def initial_value(self, value: float) -> None:
        ...
    @property
    def minimum_value(self) -> float:
        r"""
        (float):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @minimum_value.setter
    def minimum_value(self, value: float) -> None:
        ...
    @property
    def maximum_value(self) -> float:
        r"""
        (float):  [Read-Write] * The maximum value for the animation channel
        """
        ...
    @maximum_value.setter
    def maximum_value(self, value: float) -> None:
        ...
    @property
    def limits_enabled(self) -> RigUnit_HierarchyAddAnimationChannelSingleLimitSettings:
        r"""
        (RigUnit_HierarchyAddAnimationChannelSingleLimitSettings):  [Read-Write] * The enable settings for the limits
        """
        ...
    @limits_enabled.setter
    def limits_enabled(self, value: RigUnit_HierarchyAddAnimationChannelSingleLimitSettings) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelInteger(RigUnit_HierarchyAddElement):
    r"""
    Adds a new animation channel to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control_enum`` (Enum):  [Read-Write] * The enum to use to find valid values
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (int32):  [Read-Write] * The initial value of the new animation channel
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``limits_enabled`` (RigUnit_HierarchyAddAnimationChannelSingleLimitSettings):  [Read-Write] * The enable settings for the limits
    - ``maximum_value`` (int32):  [Read-Write] * The maximum value for the animation channel
    - ``minimum_value`` (int32):  [Read-Write] * The initial value of the new animation channel
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], initial_value: int = 0, minimum_value: int = 0, maximum_value: int = 0, limits_enabled: RigUnit_HierarchyAddAnimationChannelSingleLimitSettings = [[True, True]], control_enum: Enum = None) -> None:
        ...
    @property
    def initial_value(self) -> int:
        r"""
        (int32):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @initial_value.setter
    def initial_value(self, value: int) -> None:
        ...
    @property
    def minimum_value(self) -> int:
        r"""
        (int32):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @minimum_value.setter
    def minimum_value(self, value: int) -> None:
        ...
    @property
    def maximum_value(self) -> int:
        r"""
        (int32):  [Read-Write] * The maximum value for the animation channel
        """
        ...
    @maximum_value.setter
    def maximum_value(self, value: int) -> None:
        ...
    @property
    def limits_enabled(self) -> RigUnit_HierarchyAddAnimationChannelSingleLimitSettings:
        r"""
        (RigUnit_HierarchyAddAnimationChannelSingleLimitSettings):  [Read-Write] * The enable settings for the limits
        """
        ...
    @limits_enabled.setter
    def limits_enabled(self, value: RigUnit_HierarchyAddAnimationChannelSingleLimitSettings) -> None:
        ...
    @property
    def control_enum(self) -> Enum:
        r"""
        (Enum):  [Read-Write] * The enum to use to find valid values
        """
        ...
    @control_enum.setter
    def control_enum(self, value: Enum) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannel2DLimitSettings(RigUnit_HierarchyAddAnimationChannelEmptyLimitSettings):
    r"""
    Rig Unit Hierarchy Add Animation Channel 2DLimit Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (RigControlLimitEnabled):  [Read-Write]
    - ``y`` (RigControlLimitEnabled):  [Read-Write]
    """
    def __init__(self, x: RigControlLimitEnabled = [False, False], y: RigControlLimitEnabled = [False, False]) -> None:
        ...
    @property
    def x(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def y(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: RigControlLimitEnabled) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelVector2D(RigUnit_HierarchyAddElement):
    r"""
    Adds a new animation channel to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (Vector2D):  [Read-Write] * The initial value of the new animation channel
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``limits_enabled`` (RigUnit_HierarchyAddAnimationChannel2DLimitSettings):  [Read-Write] * The enable settings for the limits
    - ``maximum_value`` (Vector2D):  [Read-Write] * The maximum value for the animation channel
    - ``minimum_value`` (Vector2D):  [Read-Write] * The initial value of the new animation channel
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], initial_value: Vector2D = [0.000000, 0.000000], minimum_value: Vector2D = [0.000000, 0.000000], maximum_value: Vector2D = [0.000000, 0.000000], limits_enabled: RigUnit_HierarchyAddAnimationChannel2DLimitSettings = [[True, True], [True, True]]) -> None:
        ...
    @property
    def initial_value(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Vector2D) -> None:
        ...
    @property
    def minimum_value(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @minimum_value.setter
    def minimum_value(self, value: Vector2D) -> None:
        ...
    @property
    def maximum_value(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] * The maximum value for the animation channel
        """
        ...
    @maximum_value.setter
    def maximum_value(self, value: Vector2D) -> None:
        ...
    @property
    def limits_enabled(self) -> RigUnit_HierarchyAddAnimationChannel2DLimitSettings:
        r"""
        (RigUnit_HierarchyAddAnimationChannel2DLimitSettings):  [Read-Write] * The enable settings for the limits
        """
        ...
    @limits_enabled.setter
    def limits_enabled(self, value: RigUnit_HierarchyAddAnimationChannel2DLimitSettings) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelVectorLimitSettings(RigUnit_HierarchyAddAnimationChannelEmptyLimitSettings):
    r"""
    Rig Unit Hierarchy Add Animation Channel Vector Limit Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (RigControlLimitEnabled):  [Read-Write]
    - ``y`` (RigControlLimitEnabled):  [Read-Write]
    - ``z`` (RigControlLimitEnabled):  [Read-Write]
    """
    def __init__(self, x: RigControlLimitEnabled = [False, False], y: RigControlLimitEnabled = [False, False], z: RigControlLimitEnabled = [False, False]) -> None:
        ...
    @property
    def x(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def y(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def z(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: RigControlLimitEnabled) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelVector(RigUnit_HierarchyAddElement):
    r"""
    Adds a new animation channel to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (Vector):  [Read-Write] * The initial value of the new animation channel
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``limits_enabled`` (RigUnit_HierarchyAddAnimationChannelVectorLimitSettings):  [Read-Write] * The enable settings for the limits
    - ``maximum_value`` (Vector):  [Read-Write] * The maximum value for the animation channel
    - ``minimum_value`` (Vector):  [Read-Write] * The initial value of the new animation channel
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], initial_value: Vector = [0.000000, 0.000000, 0.000000], minimum_value: Vector = [0.000000, 0.000000, 0.000000], maximum_value: Vector = [0.000000, 0.000000, 0.000000], limits_enabled: RigUnit_HierarchyAddAnimationChannelVectorLimitSettings = [[True, True], [True, True], [True, True]]) -> None:
        ...
    @property
    def initial_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Vector) -> None:
        ...
    @property
    def minimum_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @minimum_value.setter
    def minimum_value(self, value: Vector) -> None:
        ...
    @property
    def maximum_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] * The maximum value for the animation channel
        """
        ...
    @maximum_value.setter
    def maximum_value(self, value: Vector) -> None:
        ...
    @property
    def limits_enabled(self) -> RigUnit_HierarchyAddAnimationChannelVectorLimitSettings:
        r"""
        (RigUnit_HierarchyAddAnimationChannelVectorLimitSettings):  [Read-Write] * The enable settings for the limits
        """
        ...
    @limits_enabled.setter
    def limits_enabled(self, value: RigUnit_HierarchyAddAnimationChannelVectorLimitSettings) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelScaleVector(RigUnit_HierarchyAddElement):
    r"""
    Adds a new animation channel to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (Vector):  [Read-Write] * The initial value of the new animation channel
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``limits_enabled`` (RigUnit_HierarchyAddAnimationChannelVectorLimitSettings):  [Read-Write] * The enable settings for the limits
    - ``maximum_value`` (Vector):  [Read-Write] * The maximum value for the animation channel
    - ``minimum_value`` (Vector):  [Read-Write] * The initial value of the new animation channel
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], initial_value: Vector = [0.000000, 0.000000, 0.000000], minimum_value: Vector = [0.000000, 0.000000, 0.000000], maximum_value: Vector = [0.000000, 0.000000, 0.000000], limits_enabled: RigUnit_HierarchyAddAnimationChannelVectorLimitSettings = [[True, True], [True, True], [True, True]]) -> None:
        ...
    @property
    def initial_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Vector) -> None:
        ...
    @property
    def minimum_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @minimum_value.setter
    def minimum_value(self, value: Vector) -> None:
        ...
    @property
    def maximum_value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] * The maximum value for the animation channel
        """
        ...
    @maximum_value.setter
    def maximum_value(self, value: Vector) -> None:
        ...
    @property
    def limits_enabled(self) -> RigUnit_HierarchyAddAnimationChannelVectorLimitSettings:
        r"""
        (RigUnit_HierarchyAddAnimationChannelVectorLimitSettings):  [Read-Write] * The enable settings for the limits
        """
        ...
    @limits_enabled.setter
    def limits_enabled(self, value: RigUnit_HierarchyAddAnimationChannelVectorLimitSettings) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelRotatorLimitSettings(RigUnit_HierarchyAddAnimationChannelEmptyLimitSettings):
    r"""
    Rig Unit Hierarchy Add Animation Channel Rotator Limit Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``pitch`` (RigControlLimitEnabled):  [Read-Write]
    - ``roll`` (RigControlLimitEnabled):  [Read-Write]
    - ``yaw`` (RigControlLimitEnabled):  [Read-Write]
    """
    def __init__(self, pitch: RigControlLimitEnabled = [False, False], yaw: RigControlLimitEnabled = [False, False], roll: RigControlLimitEnabled = [False, False]) -> None:
        ...
    @property
    def pitch(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @pitch.setter
    def pitch(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def yaw(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @yaw.setter
    def yaw(self, value: RigControlLimitEnabled) -> None:
        ...
    @property
    def roll(self) -> RigControlLimitEnabled:
        r"""
        (RigControlLimitEnabled):  [Read-Write]
        """
        ...
    @roll.setter
    def roll(self, value: RigControlLimitEnabled) -> None:
        ...

class RigUnit_HierarchyAddAnimationChannelRotator(RigUnit_HierarchyAddElement):
    r"""
    Adds a new animation channel to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_value`` (Rotator):  [Read-Write] * The initial value of the new animation channel
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``limits_enabled`` (RigUnit_HierarchyAddAnimationChannelRotatorLimitSettings):  [Read-Write] * The enable settings for the limits
    - ``maximum_value`` (Rotator):  [Read-Write] * The maximum value for the animation channel
    - ``minimum_value`` (Rotator):  [Read-Write] * The initial value of the new animation channel
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], initial_value: Rotator = [0.000000, 0.000000, 0.000000], minimum_value: Rotator = [0.000000, 0.000000, 0.000000], maximum_value: Rotator = [0.000000, 0.000000, 0.000000], limits_enabled: RigUnit_HierarchyAddAnimationChannelRotatorLimitSettings = [[True, True], [True, True], [True, True]]) -> None:
        ...
    @property
    def initial_value(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @initial_value.setter
    def initial_value(self, value: Rotator) -> None:
        ...
    @property
    def minimum_value(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] * The initial value of the new animation channel
        """
        ...
    @minimum_value.setter
    def minimum_value(self, value: Rotator) -> None:
        ...
    @property
    def maximum_value(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] * The maximum value for the animation channel
        """
        ...
    @maximum_value.setter
    def maximum_value(self, value: Rotator) -> None:
        ...
    @property
    def limits_enabled(self) -> RigUnit_HierarchyAddAnimationChannelRotatorLimitSettings:
        r"""
        (RigUnit_HierarchyAddAnimationChannelRotatorLimitSettings):  [Read-Write] * The enable settings for the limits
        """
        ...
    @limits_enabled.setter
    def limits_enabled(self, value: RigUnit_HierarchyAddAnimationChannelRotatorLimitSettings) -> None:
        ...

class RigUnit_HierarchyGetShapeSettings(RigUnit_DynamicHierarchyBase):
    r"""
    Retrieves the shape settings of a control
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Write] * The item to change
    - ``settings`` (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write] * The shape settings for the control
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], settings: RigUnit_HierarchyAddControl_ShapeSettings = [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The item to change
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def settings(self) -> RigUnit_HierarchyAddControl_ShapeSettings:
        r"""
        (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Only] * The shape settings for the control
        """
        ...

class RigUnit_HierarchySetShapeSettings(RigUnit_DynamicHierarchyBaseMutable):
    r"""
    Changes the shape settings of a control
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] * The item to change
    - ``settings`` (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write] * The shape settings for the control
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], settings: RigUnit_HierarchyAddControl_ShapeSettings = [True, "Default", [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The item to change
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def settings(self) -> RigUnit_HierarchyAddControl_ShapeSettings:
        r"""
        (RigUnit_HierarchyAddControl_ShapeSettings):  [Read-Write] * The shape settings for the control
        """
        ...
    @settings.setter
    def settings(self, value: RigUnit_HierarchyAddControl_ShapeSettings) -> None:
        ...

class RigUnit_HierarchyAddSocket(RigUnit_HierarchyAddElement):
    r"""
    Adds a new socket to the hierarchy
    Note: This node only runs as part of the construction event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DynamicHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write] * The color of the socket
    - ``description`` (str):  [Read-Write] * The (optional) description of the socket
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] * The resulting item
    - ``name`` (Name):  [Read-Write] * The name of the new element to add
    - ``parent`` (RigElementKey):  [Read-Write] * The parent of the new element to add
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the transform should be interpreted in local or global space
    - ``transform`` (Transform):  [Read-Write] * The initial transform of the new element
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], parent: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", item: RigElementKey = [RigElementType.NONE, "None"], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], description: str = "") -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] * The initial transform of the new element
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the transform should be interpreted in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] * The color of the socket
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def description(self) -> str:
        r"""
        (str):  [Read-Write] * The (optional) description of the socket
        """
        ...
    @description.setter
    def description(self, value: str) -> None:
        ...

class RigUnit_HierarchyBase(RigUnit):
    r"""
    Rig Unit Hierarchy Base
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_HierarchyBaseMutable(RigUnitMutable):
    r"""
    Rig Unit Hierarchy Base Mutable
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...

class RigUnit_HierarchyGetParent(RigUnit_HierarchyBase):
    r"""
    Returns the item's parent
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write]
    - ``parent`` (RigElementKey):  [Read-Write]
    """
    def __init__(self, child: RigElementKey = [RigElementType.NONE, "None"], parent: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only]
        """
        ...

class RigUnit_HierarchyGetParents(RigUnit_HierarchyBase):
    r"""
    Returns the item's parents
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write]
    - ``include_child`` (bool):  [Read-Write]
    - ``parents`` (RigElementKeyCollection):  [Read-Write]
    - ``reverse`` (bool):  [Read-Write]
    """
    def __init__(self, child: RigElementKey = [RigElementType.NONE, "None"], include_child: bool = False, reverse: bool = False, parents: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def include_child(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @include_child.setter
    def include_child(self, value: bool) -> None:
        ...
    @property
    def reverse(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @reverse.setter
    def reverse(self, value: bool) -> None:
        ...
    @property
    def parents(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_HierarchyGetParentsItemArray(RigUnit_HierarchyBase):
    r"""
    Returns the item's parents
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write]
    - ``include_child`` (bool):  [Read-Write]
    - ``parents`` (Array[RigElementKey]):  [Read-Write]
    - ``reverse`` (bool):  [Read-Write]
    """
    def __init__(self, child: RigElementKey = [RigElementType.NONE, "None"], include_child: bool = False, reverse: bool = False, parents: Array[RigElementKey] = []) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def include_child(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @include_child.setter
    def include_child(self, value: bool) -> None:
        ...
    @property
    def reverse(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @reverse.setter
    def reverse(self, value: bool) -> None:
        ...
    @property
    def parents(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigUnit_HierarchyGetChildren(RigUnit_HierarchyBase):
    r"""
    Returns the item's children
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``children`` (RigElementKeyCollection):  [Read-Write]
    - ``include_parent`` (bool):  [Read-Write]
    - ``parent`` (RigElementKey):  [Read-Write]
    - ``recursive`` (bool):  [Read-Write]
    """
    def __init__(self, parent: RigElementKey = [RigElementType.NONE, "None"], include_parent: bool = False, recursive: bool = False, children: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...
    @property
    def include_parent(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @include_parent.setter
    def include_parent(self, value: bool) -> None:
        ...
    @property
    def recursive(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @recursive.setter
    def recursive(self, value: bool) -> None:
        ...
    @property
    def children(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_HierarchyGetSiblings(RigUnit_HierarchyBase):
    r"""
    Returns the item's siblings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``include_item`` (bool):  [Read-Write]
    - ``item`` (RigElementKey):  [Read-Write]
    - ``siblings`` (RigElementKeyCollection):  [Read-Write]
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], include_item: bool = False, siblings: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def include_item(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @include_item.setter
    def include_item(self, value: bool) -> None:
        ...
    @property
    def siblings(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_HierarchyGetSiblingsItemArray(RigUnit_HierarchyBase):
    r"""
    Returns the item's siblings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``include_item`` (bool):  [Read-Write]
    - ``item`` (RigElementKey):  [Read-Write]
    - ``siblings`` (Array[RigElementKey]):  [Read-Write]
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], include_item: bool = False, siblings: Array[RigElementKey] = []) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def include_item(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @include_item.setter
    def include_item(self, value: bool) -> None:
        ...
    @property
    def siblings(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigUnit_HierarchyGetChainItemArray(RigUnit_HierarchyBase):
    r"""
    Returns a chain between two items
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``chain`` (Array[RigElementKey]):  [Read-Write]
    - ``end`` (RigElementKey):  [Read-Write]
    - ``include_end`` (bool):  [Read-Write]
    - ``include_start`` (bool):  [Read-Write]
    - ``reverse`` (bool):  [Read-Write]
    - ``start`` (RigElementKey):  [Read-Write]
    """
    def __init__(self, start: RigElementKey = [RigElementType.NONE, "None"], end: RigElementKey = [RigElementType.NONE, "None"], include_start: bool = False, include_end: bool = False, reverse: bool = False, chain: Array[RigElementKey] = []) -> None:
        ...
    @property
    def start(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @start.setter
    def start(self, value: RigElementKey) -> None:
        ...
    @property
    def end(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @end.setter
    def end(self, value: RigElementKey) -> None:
        ...
    @property
    def include_start(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @include_start.setter
    def include_start(self, value: bool) -> None:
        ...
    @property
    def include_end(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @include_end.setter
    def include_end(self, value: bool) -> None:
        ...
    @property
    def reverse(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @reverse.setter
    def reverse(self, value: bool) -> None:
        ...
    @property
    def chain(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigUnit_HierarchyGetPose(RigUnit_HierarchyBase):
    r"""
    Returns the hierarchy's pose
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``element_type`` (RigElementType):  [Read-Write]
    - ``initial`` (bool):  [Read-Write]
    - ``items_to_get`` (RigElementKeyCollection):  [Read-Write] An optional collection to filter against
    - ``pose`` (RigPose):  [Read-Write]
    """
    def __init__(self, initial: bool = False, element_type: RigElementType = RigElementType.NONE, items_to_get: RigElementKeyCollection = [[]], pose: RigPose = []) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...
    @property
    def element_type(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @element_type.setter
    def element_type(self, value: RigElementType) -> None:
        ...
    @property
    def items_to_get(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] An optional collection to filter against
        """
        ...
    @items_to_get.setter
    def items_to_get(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Only]
        """
        ...

class RigUnit_HierarchyGetPoseItemArray(RigUnit_HierarchyBase):
    r"""
    Returns the hierarchy's pose
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``element_type`` (RigElementType):  [Read-Write]
    - ``initial`` (bool):  [Read-Write]
    - ``items_to_get`` (Array[RigElementKey]):  [Read-Write] An optional collection to filter against
    - ``pose`` (RigPose):  [Read-Write]
    """
    def __init__(self, initial: bool = False, element_type: RigElementType = RigElementType.NONE, items_to_get: Array[RigElementKey] = [], pose: RigPose = []) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...
    @property
    def element_type(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @element_type.setter
    def element_type(self, value: RigElementType) -> None:
        ...
    @property
    def items_to_get(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] An optional collection to filter against
        """
        ...
    @items_to_get.setter
    def items_to_get(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Only]
        """
        ...

class RigUnit_HierarchySetPose(RigUnit_HierarchyBaseMutable):
    r"""
    Sets the hierarchy's pose
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``element_type`` (RigElementType):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items_to_set`` (RigElementKeyCollection):  [Read-Write] An optional collection to filter against
    - ``pose`` (RigPose):  [Read-Write]
    - ``space`` (RigVMTransformSpace):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], pose: RigPose = [], element_type: RigElementType = RigElementType.NONE, space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, items_to_set: RigElementKeyCollection = [[]], weight: float = 0.000000) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: RigPose) -> None:
        ...
    @property
    def element_type(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @element_type.setter
    def element_type(self, value: RigElementType) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def items_to_set(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] An optional collection to filter against
        """
        ...
    @items_to_set.setter
    def items_to_set(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_HierarchySetPoseItemArray(RigUnit_HierarchyBaseMutable):
    r"""
    Sets the hierarchy's pose
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``element_type`` (RigElementType):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items_to_set`` (Array[RigElementKey]):  [Read-Write] An optional collection to filter against
    - ``pose`` (RigPose):  [Read-Write]
    - ``space`` (RigVMTransformSpace):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], pose: RigPose = [], element_type: RigElementType = RigElementType.NONE, space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, items_to_set: Array[RigElementKey] = [], weight: float = 0.000000) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: RigPose) -> None:
        ...
    @property
    def element_type(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @element_type.setter
    def element_type(self, value: RigElementType) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write]
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def items_to_set(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] An optional collection to filter against
        """
        ...
    @items_to_set.setter
    def items_to_set(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_PoseIsEmpty(RigUnit_HierarchyBase):
    r"""
    Returns true if the hierarchy pose is empty (has no items)
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_empty`` (bool):  [Read-Write]
    - ``pose`` (RigPose):  [Read-Write]
    """
    def __init__(self, pose: RigPose = [], is_empty: bool = False) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: RigPose) -> None:
        ...
    @property
    def is_empty(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_PoseGetItems(RigUnit_HierarchyBase):
    r"""
    Returns the items in the hierarchy pose
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``element_type`` (RigElementType):  [Read-Write]
    - ``items`` (RigElementKeyCollection):  [Read-Write]
    - ``pose`` (RigPose):  [Read-Write]
    """
    def __init__(self, pose: RigPose = [], element_type: RigElementType = RigElementType.NONE, items: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: RigPose) -> None:
        ...
    @property
    def element_type(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @element_type.setter
    def element_type(self, value: RigElementType) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_PoseGetItemsItemArray(RigUnit_HierarchyBase):
    r"""
    Returns the items in the hierarchy pose
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``element_type`` (RigElementType):  [Read-Write]
    - ``items`` (Array[RigElementKey]):  [Read-Write]
    - ``pose`` (RigPose):  [Read-Write]
    """
    def __init__(self, pose: RigPose = [], element_type: RigElementType = RigElementType.NONE, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: RigPose) -> None:
        ...
    @property
    def element_type(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @element_type.setter
    def element_type(self, value: RigElementType) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class RigUnit_PoseGetDelta(RigUnit_HierarchyBase):
    r"""
    Compares two pose caches and compares their values.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve_threshold`` (float):  [Read-Write] The delta threshold for curve value difference. 0.0 disables curve differences.
    - ``element_type`` (RigElementType):  [Read-Write]
    - ``items_to_compare`` (RigElementKeyCollection):  [Read-Write] An optional list of items to compare
    - ``items_with_delta`` (RigElementKeyCollection):  [Read-Write]
    - ``pose_a`` (RigPose):  [Read-Write]
    - ``pose_b`` (RigPose):  [Read-Write]
    - ``poses_are_equal`` (bool):  [Read-Write]
    - ``position_threshold`` (float):  [Read-Write] The delta threshold for a translation / position difference. 0.0 disables position differences.
    - ``rotation_threshold`` (float):  [Read-Write] The delta threshold for a rotation difference (in degrees). 0.0 disables rotation differences.
    - ``scale_threshold`` (float):  [Read-Write] The delta threshold for a scale difference. 0.0 disables scale differences.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines in which space transform deltas should be computed
    """
    def __init__(self, pose_a: RigPose = [], pose_b: RigPose = [], position_threshold: float = 0.000000, rotation_threshold: float = 0.000000, scale_threshold: float = 0.000000, curve_threshold: float = 0.000000, element_type: RigElementType = RigElementType.NONE, space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, items_to_compare: RigElementKeyCollection = [[]], poses_are_equal: bool = False, items_with_delta: RigElementKeyCollection = [[]]) -> None:
        ...
    @property
    def pose_a(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose_a.setter
    def pose_a(self, value: RigPose) -> None:
        ...
    @property
    def pose_b(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose_b.setter
    def pose_b(self, value: RigPose) -> None:
        ...
    @property
    def position_threshold(self) -> float:
        r"""
        (float):  [Read-Write] The delta threshold for a translation / position difference. 0.0 disables position differences.
        """
        ...
    @position_threshold.setter
    def position_threshold(self, value: float) -> None:
        ...
    @property
    def rotation_threshold(self) -> float:
        r"""
        (float):  [Read-Write] The delta threshold for a rotation difference (in degrees). 0.0 disables rotation differences.
        """
        ...
    @rotation_threshold.setter
    def rotation_threshold(self, value: float) -> None:
        ...
    @property
    def scale_threshold(self) -> float:
        r"""
        (float):  [Read-Write] The delta threshold for a scale difference. 0.0 disables scale differences.
        """
        ...
    @scale_threshold.setter
    def scale_threshold(self, value: float) -> None:
        ...
    @property
    def curve_threshold(self) -> float:
        r"""
        (float):  [Read-Write] The delta threshold for curve value difference. 0.0 disables curve differences.
        """
        ...
    @curve_threshold.setter
    def curve_threshold(self, value: float) -> None:
        ...
    @property
    def element_type(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @element_type.setter
    def element_type(self, value: RigElementType) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines in which space transform deltas should be computed
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def items_to_compare(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] An optional list of items to compare
        """
        ...
    @items_to_compare.setter
    def items_to_compare(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def poses_are_equal(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def items_with_delta(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Only]
        """
        ...

class RigUnit_PoseGetTransform(RigUnit_HierarchyBase):
    r"""
    Returns the hierarchy's pose transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve_value`` (float):  [Read-Write]
    - ``item`` (RigElementKey):  [Read-Write]
    - ``pose`` (RigPose):  [Read-Write]
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the transform should be retrieved in local or global space
    - ``transform`` (Transform):  [Read-Write]
    - ``valid`` (bool):  [Read-Write]
    """
    def __init__(self, pose: RigPose = [], item: RigElementKey = [RigElementType.NONE, "None"], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, valid: bool = False, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], curve_value: float = 0.000000) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: RigPose) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the transform should be retrieved in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def valid(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...
    @property
    def curve_value(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_PoseGetTransformArray(RigUnit_HierarchyBase):
    r"""
    Returns an array of transforms from a given hierarchy pose
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``pose`` (RigPose):  [Read-Write]
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the transform should be retrieved in local or global space
    - ``transforms`` (Array[Transform]):  [Read-Write]
    - ``valid`` (bool):  [Read-Write]
    """
    def __init__(self, pose: RigPose = [], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, valid: bool = False, transforms: Array[Transform] = []) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: RigPose) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the transform should be retrieved in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def valid(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Only]
        """
        ...

class RigUnit_PoseGetCurve(RigUnit_HierarchyBase):
    r"""
    Returns the hierarchy's pose curve value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve`` (Name):  [Read-Write]
    - ``curve_value`` (float):  [Read-Write]
    - ``pose`` (RigPose):  [Read-Write]
    - ``valid`` (bool):  [Read-Write]
    """
    def __init__(self, pose: RigPose = [], curve: Name = "None", valid: bool = False, curve_value: float = 0.000000) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: RigPose) -> None:
        ...
    @property
    def curve(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @curve.setter
    def curve(self, value: Name) -> None:
        ...
    @property
    def valid(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def curve_value(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_PoseLoop(RigUnit_HierarchyBaseMutable):
    r"""
    Given a pose, execute iteratively across all items in the pose
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Hierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``completed`` (ControlRigExecuteContext):  [Read-Write]
    - ``count`` (int32):  [Read-Write]
    - ``curve_value`` (float):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``global_transform`` (Transform):  [Read-Write]
    - ``index`` (int32):  [Read-Write]
    - ``item`` (RigElementKey):  [Read-Write]
    - ``local_transform`` (Transform):  [Read-Write]
    - ``pose`` (RigPose):  [Read-Write]
    - ``ratio`` (float):  [Read-Write] Ranging from 0.0 (first item) and 1.0 (last item)
      This is useful to drive a consecutive node with a
      curve or an ease to distribute a value.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], pose: RigPose = [], item: RigElementKey = [RigElementType.NONE, "None"], global_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], local_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], curve_value: float = 0.000000, index: int = 0, count: int = 0, ratio: float = 0.000000, completed: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def pose(self) -> RigPose:
        r"""
        (RigPose):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: RigPose) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only]
        """
        ...
    @property
    def global_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...
    @property
    def local_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...
    @property
    def curve_value(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def count(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Only] Ranging from 0.0 (first item) and 1.0 (last item)
        This is useful to drive a consecutive node with a
        curve or an ease to distribute a value.
        """
        ...
    @property
    def completed(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only]
        """
        ...

class RigUnit_InteractionExecution(RigUnit):
    r"""
    Event for executing logic during an interaction
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_InteractionExecution.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] The execution result
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only] The execution result
        """
        ...

class RigUnit_InverseExecution(RigUnit):
    r"""
    Event for driving elements based off the skeleton hierarchy
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_InverseExecution.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] The execution result
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only] The execution result
        """
        ...

class RigUnit_IsInteracting(RigUnit):
    r"""
    Returns true if the Control Rig is being interacted
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_IsInteracting.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_interacting`` (bool):  [Read-Write] True if there is currently an interaction happening
    - ``is_rotating`` (bool):  [Read-Write] True if the current interaction is a rotation
    - ``is_scaling`` (bool):  [Read-Write] True if the current interaction is scaling
    - ``is_translating`` (bool):  [Read-Write] True if the current interaction is a translation
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items being interacted on
    """
    def __init__(self, is_interacting: bool = False, is_translating: bool = False, is_rotating: bool = False, is_scaling: bool = False, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def is_interacting(self) -> bool:
        r"""
        (bool):  [Read-Only] True if there is currently an interaction happening
        """
        ...
    @property
    def is_translating(self) -> bool:
        r"""
        (bool):  [Read-Only] True if the current interaction is a translation
        """
        ...
    @property
    def is_rotating(self) -> bool:
        r"""
        (bool):  [Read-Only] True if the current interaction is a rotation
        """
        ...
    @property
    def is_scaling(self) -> bool:
        r"""
        (bool):  [Read-Only] True if the current interaction is scaling
        """
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only] The items being interacted on
        """
        ...

class RigUnit_ItemBase(RigUnit):
    r"""
    Rig Unit Item Base
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Item.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_ItemBaseMutable(RigUnitMutable):
    r"""
    Rig Unit Item Base Mutable
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Item.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...

class RigUnit_ItemExists(RigUnit_ItemBase):
    r"""
    Returns true or false if a given item exists
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Item.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``exists`` (bool):  [Read-Write]
    - ``item`` (RigElementKey):  [Read-Write]
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], exists: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def exists(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_ItemReplace(RigUnit_ItemBase):
    r"""
    Replaces the text within the name of the item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Item.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Write]
    - ``new`` (Name):  [Read-Write]
    - ``old`` (Name):  [Read-Write]
    - ``result`` (RigElementKey):  [Read-Write]
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], old: Name = "None", new: Name = "None", result: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def old(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @old.setter
    def old(self, value: Name) -> None:
        ...
    @property
    def new(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @new.setter
    def new(self, value: Name) -> None:
        ...
    @property
    def result(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only]
        """
        ...

class RigUnit_ItemEquals(RigUnit_ItemBase):
    r"""
    Returns true if the two items are equal
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Item.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (RigElementKey):  [Read-Write]
    - ``b`` (RigElementKey):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: RigElementKey = [RigElementType.NONE, "None"], b: RigElementKey = [RigElementType.NONE, "None"], result: bool = False) -> None:
        ...
    @property
    def a(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: RigElementKey) -> None:
        ...
    @property
    def b(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: RigElementKey) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_ItemNotEquals(RigUnit_ItemBase):
    r"""
    Returns true if the two items are not equal
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Item.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (RigElementKey):  [Read-Write]
    - ``b`` (RigElementKey):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: RigElementKey = [RigElementType.NONE, "None"], b: RigElementKey = [RigElementType.NONE, "None"], result: bool = False) -> None:
        ...
    @property
    def a(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: RigElementKey) -> None:
        ...
    @property
    def b(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: RigElementKey) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_ItemTypeEquals(RigUnit_ItemBase):
    r"""
    Returns true if the two items' types are equal
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Item.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (RigElementKey):  [Read-Write]
    - ``b`` (RigElementKey):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: RigElementKey = [RigElementType.NONE, "None"], b: RigElementKey = [RigElementType.NONE, "None"], result: bool = False) -> None:
        ...
    @property
    def a(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: RigElementKey) -> None:
        ...
    @property
    def b(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: RigElementKey) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_ItemTypeNotEquals(RigUnit_ItemBase):
    r"""
    Returns true if the two items's types are not equal
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Item.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (RigElementKey):  [Read-Write]
    - ``b`` (RigElementKey):  [Read-Write]
    - ``result`` (bool):  [Read-Write]
    """
    def __init__(self, a: RigElementKey = [RigElementType.NONE, "None"], b: RigElementKey = [RigElementType.NONE, "None"], result: bool = False) -> None:
        ...
    @property
    def a(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @a.setter
    def a(self, value: RigElementKey) -> None:
        ...
    @property
    def b(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @b.setter
    def b(self, value: RigElementKey) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class RigUnit_ItemToName(RigUnit_ItemBase):
    r"""
    Casts the provided item key to its name
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Item.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``result`` (Name):  [Read-Write]
    - ``value`` (RigElementKey):  [Read-Write]
    """
    def __init__(self, value: RigElementKey = [RigElementType.NONE, "None"], result: Name = "None") -> None:
        ...
    @property
    def value(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: RigElementKey) -> None:
        ...
    @property
    def result(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...

class RigUnit_PrepareForExecution(RigUnit):
    r"""
    Event to create / configure elements before any other event
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_PrepareForExecution.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] The execution result
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only] The execution result
        """
        ...

class RigUnit_RigModulesBase(RigUnit):
    r"""
    Rig Unit Rig Modules Base
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_RigModules.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_RigModulesBaseMutable(RigUnitMutable):
    r"""
    Rig Unit Rig Modules Base Mutable
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_RigModules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...

class RigUnit_ResolveConnector(RigUnit_RigModulesBase):
    r"""
    Returns the resolved item of the connector.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_RigModules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``connector`` (RigElementKey):  [Read-Write] * The key of the connector to resolve
    - ``is_connected`` (bool):  [Read-Write] * Returns true if the connector is resolved to a target.
    - ``result`` (RigElementKey):  [Read-Write] * The resulting item the connector is resolved to
    - ``skip_socket`` (bool):  [Read-Write] * If the connector is resolved to a socket the node
      * will return the socket's direct parent (skipping it).
    """
    def __init__(self, connector: RigElementKey = [RigElementType.NONE, "None"], skip_socket: bool = False, result: RigElementKey = [RigElementType.NONE, "None"], is_connected: bool = False) -> None:
        ...
    @property
    def connector(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The key of the connector to resolve
        """
        ...
    @connector.setter
    def connector(self, value: RigElementKey) -> None:
        ...
    @property
    def skip_socket(self) -> bool:
        r"""
        (bool):  [Read-Write] * If the connector is resolved to a socket the node
        * will return the socket's direct parent (skipping it).
        """
        ...
    @skip_socket.setter
    def skip_socket(self, value: bool) -> None:
        ...
    @property
    def result(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only] * The resulting item the connector is resolved to
        """
        ...
    @property
    def is_connected(self) -> bool:
        r"""
        (bool):  [Read-Only] * Returns true if the connector is resolved to a target.
        """
        ...

class RigUnit_GetCurrentNameSpace(RigUnit_RigModulesBase):
    r"""
    Returns the currently used namespace of the module.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_RigModules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name_space`` (str):  [Read-Write] * The current namespace of the rig module
    """
    def __init__(self, name_space: str = "") -> None:
        ...
    @property
    def name_space(self) -> str:
        r"""
        (str):  [Read-Only] * The current namespace of the rig module
        """
        ...

class RigUnit_GetItemShortName(RigUnit_RigModulesBase):
    r"""
    Returns the short name of the given item (without the namespace)
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_RigModules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Write] * The key of the item to return the short name for
    - ``short_name`` (Name):  [Read-Write] * The short name of the item (without the namespace)
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], short_name: Name = "None") -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The key of the item to return the short name for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def short_name(self) -> Name:
        r"""
        (Name):  [Read-Only] * The short name of the item (without the namespace)
        """
        ...

class RigUnit_GetItemNameSpace(RigUnit_RigModulesBase):
    r"""
    Returns the namespace of a given item. This may be an empty string if the item doesn't have a namespace.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_RigModules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``has_name_space`` (bool):  [Read-Write] * True if the item has a valid namespace
    - ``item`` (RigElementKey):  [Read-Write] * The key of the item to return the namespace for
    - ``name_space`` (str):  [Read-Write] * The namespace of the item
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], has_name_space: bool = False, name_space: str = "") -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The key of the item to return the namespace for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def has_name_space(self) -> bool:
        r"""
        (bool):  [Read-Only] * True if the item has a valid namespace
        """
        ...
    @property
    def name_space(self) -> str:
        r"""
        (str):  [Read-Only] * The namespace of the item
        """
        ...

class RigUnit_IsItemInCurrentNameSpace(RigUnit_RigModulesBase):
    r"""
    Returns true if the given item has been created by this module,
    which means that the item's namespace is the module namespace.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_RigModules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Write] * The key of the item to return the namespace for
    - ``result`` (bool):  [Read-Write] * True if the item is in this namespace / owned by this module.
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], result: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] * The key of the item to return the namespace for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def result(self) -> bool:
        r"""
        (bool):  [Read-Only] * True if the item is in this namespace / owned by this module.
        """
        ...

class RigUnit_GetItemsInNameSpace(RigUnit_RigModulesBase):
    r"""
    Returns all items (based on a filter) in the current namespace.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_RigModules.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``items`` (Array[RigElementKey]):  [Read-Write] * The items within the namespace
    - ``type_to_search`` (RigElementType):  [Read-Write]
    """
    def __init__(self, type_to_search: RigElementType = RigElementType.NONE, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def type_to_search(self) -> RigElementType:
        r"""
        (RigElementType):  [Read-Write]
        """
        ...
    @type_to_search.setter
    def type_to_search(self, value: RigElementType) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only] * The items within the namespace
        """
        ...

class RigUnit_SequenceExecution(RigUnit):
    r"""
    Allows for a single execution pulse to trigger a series of events in order.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SequenceExecution.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (ControlRigExecuteContext):  [Read-Write] The execution result A
    - ``b`` (ControlRigExecuteContext):  [Read-Write] The execution result B
    - ``c`` (ControlRigExecuteContext):  [Read-Write] The execution result C
    - ``d`` (ControlRigExecuteContext):  [Read-Write] The execution result D
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] The execution input
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], a: ControlRigExecuteContext = [], b: ControlRigExecuteContext = [], c: ControlRigExecuteContext = [], d: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Write] The execution input
        """
        ...
    @execute_context.setter
    def execute_context(self, value: ControlRigExecuteContext) -> None:
        ...
    @property
    def a(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only] The execution result A
        """
        ...
    @property
    def b(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only] The execution result B
        """
        ...
    @property
    def c(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only] The execution result C
        """
        ...
    @property
    def d(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only] The execution result D
        """
        ...

class RigUnit_AddBoneTransform(RigUnitMutable):
    r"""
    Offset Transform is used to perform a change in the hierarchy by setting a single bone's transform.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AddBoneTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the Bone to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``post_multiply`` (bool):  [Read-Write] If set to true the transform will be post multiplied, otherwise pre multiplied.
      Post multiplying means that the transform is understood as a parent space change,
      while pre multiplying means that the transform is understood as a child space change.
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``transform`` (Transform):  [Read-Write] The transform value to set for the given Bone.
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], bone: Name = "None", transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], weight: float = 0.000000, post_multiply: bool = False, propagate_to_children: bool = False) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to set the transform for.
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform value to set for the given Bone.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def post_multiply(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the transform will be post multiplied, otherwise pre multiplied.
        Post multiplying means that the transform is understood as a parent space change,
        while pre multiplying means that the transform is understood as a child space change.
        """
        ...
    @post_multiply.setter
    def post_multiply(self, value: bool) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_Item(RigUnit):
    r"""
    The Item node is used to share a specific item across the graph
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BoneName.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Write] The item
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...

class RigUnit_ItemArray(RigUnit):
    r"""
    The Item Array node is used to share an array of items across the graph
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BoneName.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items
    """
    def __init__(self, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The items
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...

class RigUnit_BoneName(RigUnit):
    r"""
    BoneName is used to represent a bone name in the graph
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BoneName.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the Bone
    """
    def __init__(self, bone: Name = "None") -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...

class RigUnit_SpaceName(RigUnit):
    r"""
    SpaceName is used to represent a Space name in the graph
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BoneName.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``space`` (Name):  [Read-Write] The name of the Space
    """
    def __init__(self, space: Name = "None") -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Space
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...

class RigUnit_ControlName(RigUnit):
    r"""
    ControlName is used to represent a Control name in the graph
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BoneName.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control
    """
    def __init__(self, control: Name = "None") -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...

class RigUnit_GetAnimationChannelBase(RigUnit):
    r"""
    Get Animation Channel is used to retrieve a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to retrieve the value for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def channel(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
        """
        ...
    @channel.setter
    def channel(self, value: Name) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the initial value will be returned
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...

class RigUnit_GetBoolAnimationChannel(RigUnit_GetAnimationChannelBase):
    r"""
    Get Bool Channel is used to retrieve a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (bool):  [Read-Write] The current value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, value: bool = False) -> None:
        ...
    @property
    def value(self) -> bool:
        r"""
        (bool):  [Read-Only] The current value of the animation channel
        """
        ...

class RigUnit_GetFloatAnimationChannel(RigUnit_GetAnimationChannelBase):
    r"""
    Get Float Channel is used to retrieve a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (float):  [Read-Write] The current value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, value: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Only] The current value of the animation channel
        """
        ...

class RigUnit_GetIntAnimationChannel(RigUnit_GetAnimationChannelBase):
    r"""
    Get Int Channel is used to retrieve a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (int32):  [Read-Write] The current value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, value: int = 0) -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Only] The current value of the animation channel
        """
        ...

class RigUnit_GetVector2DAnimationChannel(RigUnit_GetAnimationChannelBase):
    r"""
    Get Vector2D Channel is used to retrieve a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (Vector2D):  [Read-Write] The current value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, value: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] The current value of the animation channel
        """
        ...

class RigUnit_GetVectorAnimationChannel(RigUnit_GetAnimationChannelBase):
    r"""
    Get Vector Channel is used to retrieve a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (Vector):  [Read-Write] The current value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, value: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The current value of the animation channel
        """
        ...

class RigUnit_GetRotatorAnimationChannel(RigUnit_GetAnimationChannelBase):
    r"""
    Get Rotator Channel is used to retrieve a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (Rotator):  [Read-Write] The current value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, value: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] The current value of the animation channel
        """
        ...

class RigUnit_GetTransformAnimationChannel(RigUnit_GetAnimationChannelBase):
    r"""
    Get Transform Channel is used to retrieve a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (Transform):  [Read-Write] The current value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The current value of the animation channel
        """
        ...

class RigUnit_SetAnimationChannelBase(RigUnit_GetAnimationChannelBase):
    r"""
    Set Animation Channel is used to change a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write]
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, execute_context: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Write]
        """
        ...
    @execute_context.setter
    def execute_context(self, value: ControlRigExecuteContext) -> None:
        ...

class RigUnit_SetBoolAnimationChannel(RigUnit_SetAnimationChannelBase):
    r"""
    Set Bool Channel is used to set a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write]
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (bool):  [Read-Write] The new value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, execute_context: ControlRigExecuteContext = [], value: bool = False) -> None:
        ...
    @property
    def value(self) -> bool:
        r"""
        (bool):  [Read-Write] The new value of the animation channel
        """
        ...
    @value.setter
    def value(self, value: bool) -> None:
        ...

class RigUnit_SetFloatAnimationChannel(RigUnit_SetAnimationChannelBase):
    r"""
    Set Float Channel is used to set a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write]
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (float):  [Read-Write] The new value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, execute_context: ControlRigExecuteContext = [], value: float = 0.000000) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write] The new value of the animation channel
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class RigUnit_SetIntAnimationChannel(RigUnit_SetAnimationChannelBase):
    r"""
    Set Int Channel is used to set a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write]
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (int32):  [Read-Write] The new value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, execute_context: ControlRigExecuteContext = [], value: int = 0) -> None:
        ...
    @property
    def value(self) -> int:
        r"""
        (int32):  [Read-Write] The new value of the animation channel
        """
        ...
    @value.setter
    def value(self, value: int) -> None:
        ...

class RigUnit_SetVector2DAnimationChannel(RigUnit_SetAnimationChannelBase):
    r"""
    Set Vector2D Channel is used to set a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write]
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (Vector2D):  [Read-Write] The new value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, execute_context: ControlRigExecuteContext = [], value: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The new value of the animation channel
        """
        ...
    @value.setter
    def value(self, value: Vector2D) -> None:
        ...

class RigUnit_SetVectorAnimationChannel(RigUnit_SetAnimationChannelBase):
    r"""
    Set Vector Channel is used to set a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write]
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (Vector):  [Read-Write] The new value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, execute_context: ControlRigExecuteContext = [], value: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The new value of the animation channel
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...

class RigUnit_SetRotatorAnimationChannel(RigUnit_SetAnimationChannelBase):
    r"""
    Set Rotator Channel is used to set a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write]
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (Rotator):  [Read-Write] The new value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, execute_context: ControlRigExecuteContext = [], value: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] The new value of the animation channel
        """
        ...
    @value.setter
    def value(self, value: Rotator) -> None:
        ...

class RigUnit_SetTransformAnimationChannel(RigUnit_SetAnimationChannelBase):
    r"""
    Set Transform Channel is used to set a control's animation channel value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ControlChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] The name of the animation channel to retrieve the value for.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the value for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write]
    - ``initial`` (bool):  [Read-Write] If set to true the initial value will be returned
    - ``value`` (Transform):  [Read-Write] The new value of the animation channel
    """
    def __init__(self, control: Name = "None", channel: Name = "None", initial: bool = False, execute_context: ControlRigExecuteContext = [], value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The new value of the animation channel
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...

class RigUnit_CurveExists(RigUnit):
    r"""
    CurveExists is used to check whether a curve exists or not.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_CurveExists.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve`` (Name):  [Read-Write] The name of the Curve to retrieve the transform for.
    - ``exists`` (bool):  [Read-Write] Boolean indicating whether the named curve exists or not.
      Does not indicate whether the curve's value is valid or not.
    """
    def __init__(self, curve: Name = "None", exists: bool = False) -> None:
        ...
    @property
    def curve(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Curve to retrieve the transform for.
        """
        ...
    @curve.setter
    def curve(self, value: Name) -> None:
        ...
    @property
    def exists(self) -> bool:
        r"""
        (bool):  [Read-Only] Boolean indicating whether the named curve exists or not.
        Does not indicate whether the curve's value is valid or not.
        """
        ...

class RigUnit_GetBoneTransform(RigUnit):
    r"""
    GetBoneTransform is used to retrieve a single transform from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetBoneTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the Bone to retrieve the transform for.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be retrieved
      in local or global space.
    - ``transform`` (Transform):  [Read-Write] The current transform of the given bone - or identity in case it wasn't found.
    """
    def __init__(self, bone: Name = "None", space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to retrieve the transform for.
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be retrieved
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The current transform of the given bone - or identity in case it wasn't found.
        """
        ...

class RigUnit_GetControlInitialTransform(RigUnit):
    r"""
    GetControlTransform is used to retrieve a single transform from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetControlInitialTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the transform for.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the Control's transform should be retrieved
      in local or global space.
    - ``transform`` (Transform):  [Read-Write] The current transform of the given bone - or identity in case it wasn't found.
    """
    def __init__(self, control: Name = "None", space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to retrieve the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the Control's transform should be retrieved
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The current transform of the given bone - or identity in case it wasn't found.
        """
        ...

class RigUnit_GetControlBool(RigUnit):
    r"""
    GetControlBool is used to retrieve a single Bool from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool_value`` (bool):  [Read-Write] The current bool of the given bone - or identity in case it wasn't found.
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the bool for.
    """
    def __init__(self, control: Name = "None", bool_value: bool = False) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to retrieve the bool for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def bool_value(self) -> bool:
        r"""
        (bool):  [Read-Only] The current bool of the given bone - or identity in case it wasn't found.
        """
        ...

class RigUnit_GetControlFloat(RigUnit):
    r"""
    GetControlFloat is used to retrieve a single Float from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the Float for.
    - ``float_value`` (float):  [Read-Write] The current value of the control.
    - ``maximum`` (float):  [Read-Write] The maximum value of the control.
    - ``minimum`` (float):  [Read-Write] The minimum value of the control.
    """
    def __init__(self, control: Name = "None", float_value: float = 0.000000, minimum: float = 0.000000, maximum: float = 0.000000) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to retrieve the Float for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def float_value(self) -> float:
        r"""
        (float):  [Read-Only] The current value of the control.
        """
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Only] The minimum value of the control.
        """
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Only] The maximum value of the control.
        """
        ...

class RigUnit_GetControlInteger(RigUnit):
    r"""
    GetControlFloat is used to retrieve a single Integer from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the Integer for.
    - ``integer_value`` (int32):  [Read-Write] The current value of the control.
    - ``maximum`` (int32):  [Read-Write] The maximum value of the control.
    - ``minimum`` (int32):  [Read-Write] The minimum value of the control.
    """
    def __init__(self, control: Name = "None", integer_value: int = 0, minimum: int = 0, maximum: int = 0) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to retrieve the Integer for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def integer_value(self) -> int:
        r"""
        (int32):  [Read-Only] The current value of the control.
        """
        ...
    @property
    def minimum(self) -> int:
        r"""
        (int32):  [Read-Only] The minimum value of the control.
        """
        ...
    @property
    def maximum(self) -> int:
        r"""
        (int32):  [Read-Only] The maximum value of the control.
        """
        ...

class RigUnit_GetControlVector2D(RigUnit):
    r"""
    GetControlVector2D is used to retrieve a single Vector2D from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the Vector2D for.
    - ``maximum`` (Vector2D):  [Read-Write] The maximum value of the control.
    - ``minimum`` (Vector2D):  [Read-Write] The minimum value of the control.
    - ``vector`` (Vector2D):  [Read-Write] The current value of the control.
    """
    def __init__(self, control: Name = "None", vector: Vector2D = [0.000000, 0.000000], minimum: Vector2D = [0.000000, 0.000000], maximum: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to retrieve the Vector2D for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def vector(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] The current value of the control.
        """
        ...
    @property
    def minimum(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] The minimum value of the control.
        """
        ...
    @property
    def maximum(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] The maximum value of the control.
        """
        ...

class RigUnit_GetControlVector(RigUnit):
    r"""
    GetControlVector is used to retrieve a single Vector from a hierarchy, can be used for Controls of type "Position" or "Scale".
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the Vector for.
    - ``maximum`` (Vector):  [Read-Write] The maximum value of the control.
    - ``minimum`` (Vector):  [Read-Write] The minimum value of the control.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the Control's Vector should be retrieved
      in local or global space.
    - ``vector`` (Vector):  [Read-Write] The current value of the control.
    """
    def __init__(self, control: Name = "None", space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, vector: Vector = [0.000000, 0.000000, 0.000000], minimum: Vector = [0.000000, 0.000000, 0.000000], maximum: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to retrieve the Vector for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the Control's Vector should be retrieved
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def vector(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The current value of the control.
        """
        ...
    @property
    def minimum(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The minimum value of the control.
        """
        ...
    @property
    def maximum(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The maximum value of the control.
        """
        ...

class RigUnit_GetControlRotator(RigUnit):
    r"""
    GetControlRotator is used to retrieve a single Rotator from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the Rotator for.
    - ``maximum`` (Rotator):  [Read-Write] The maximum value of the control.
    - ``minimum`` (Rotator):  [Read-Write] The minimum value of the control.
    - ``rotator`` (Rotator):  [Read-Write] The current value of the control.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the Control's Rotator should be retrieved
      in local or global space.
    """
    def __init__(self, control: Name = "None", space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, rotator: Rotator = [0.000000, 0.000000, 0.000000], minimum: Rotator = [0.000000, 0.000000, 0.000000], maximum: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to retrieve the Rotator for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the Control's Rotator should be retrieved
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def rotator(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] The current value of the control.
        """
        ...
    @property
    def minimum(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] The minimum value of the control.
        """
        ...
    @property
    def maximum(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] The maximum value of the control.
        """
        ...

class RigUnit_GetControlTransform(RigUnit):
    r"""
    GetControlTransform is used to retrieve a single transform from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to retrieve the transform for.
    - ``maximum`` (Transform):  [Read-Write] The maximum value of the control.
    - ``minimum`` (Transform):  [Read-Write] The minimum value of the control.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the Control's transform should be retrieved
      in local or global space.
    - ``transform`` (Transform):  [Read-Write] The current value of the control.
    """
    def __init__(self, control: Name = "None", space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], minimum: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], maximum: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to retrieve the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the Control's transform should be retrieved
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The current value of the control.
        """
        ...
    @property
    def minimum(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The minimum value of the control.
        """
        ...
    @property
    def maximum(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The maximum value of the control.
        """
        ...

class RigUnit_GetCurveValue(RigUnit):
    r"""
    GetCurveValue is used to retrieve a single float from a Curve
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetCurveValue.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve`` (Name):  [Read-Write] The name of the Curve to retrieve the transform for.
    - ``valid`` (bool):  [Read-Write]
    - ``value`` (float):  [Read-Write] The current transform of the given Curve - or identity in case it wasn't found.
    """
    def __init__(self, curve: Name = "None", valid: bool = False, value: float = 0.000000) -> None:
        ...
    @property
    def curve(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Curve to retrieve the transform for.
        """
        ...
    @curve.setter
    def curve(self, value: Name) -> None:
        ...
    @property
    def valid(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Only] The current transform of the given Curve - or identity in case it wasn't found.
        """
        ...

class RigUnit_GetInitialBoneTransform(RigUnit):
    r"""
    GetInitialBoneTransform is used to retrieve a single transform from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetInitialBoneTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the Bone to retrieve the transform for.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be retrieved
      in local or global space.
    - ``transform`` (Transform):  [Read-Write] The current transform of the given bone - or identity in case it wasn't found.
    """
    def __init__(self, bone: Name = "None", space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to retrieve the transform for.
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be retrieved
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The current transform of the given bone - or identity in case it wasn't found.
        """
        ...

class RigUnit_GetRelativeBoneTransform(RigUnit):
    r"""
    GetBoneTransform is used to retrieve a single transform from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetRelativeBoneTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the Bone to retrieve the transform for.
    - ``space`` (Name):  [Read-Write] The name of the Bone to retrieve the transform relative within.
    - ``transform`` (Transform):  [Read-Write] The current transform of the given bone - or identity in case it wasn't found.
    """
    def __init__(self, bone: Name = "None", space: Name = "None", transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to retrieve the transform for.
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to retrieve the transform relative within.
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The current transform of the given bone - or identity in case it wasn't found.
        """
        ...

class RigUnit_GetRelativeTransformForItem(RigUnit):
    r"""
    GetRelativeTransform is used to retrieve a single transform from a hierarchy in the space of another transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetRelativeTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write] The child item to retrieve the transform for
    - ``child_initial`` (bool):  [Read-Write] Defines if the child's transform should be retrieved as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``parent`` (RigElementKey):  [Read-Write] The parent item to use.
      The child transform will be retrieve in the space of the parent.
    - ``parent_initial`` (bool):  [Read-Write] Defines if the parent's transform should be retrieved as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``relative_transform`` (Transform):  [Read-Write] The transform of the given child item relative to the provided parent
    """
    def __init__(self, child: RigElementKey = [RigElementType.NONE, "None"], child_initial: bool = False, parent: RigElementKey = [RigElementType.NONE, "None"], parent_initial: bool = False, relative_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The child item to retrieve the transform for
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def child_initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the child's transform should be retrieved as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @child_initial.setter
    def child_initial(self, value: bool) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The parent item to use.
        The child transform will be retrieve in the space of the parent.
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...
    @property
    def parent_initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the parent's transform should be retrieved as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @parent_initial.setter
    def parent_initial(self, value: bool) -> None:
        ...
    @property
    def relative_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The transform of the given child item relative to the provided parent
        """
        ...

class RigUnit_GetSpaceTransform(RigUnit):
    r"""
    GetSpaceTransform is used to retrieve a single transform from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetSpaceTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``space`` (Name):  [Read-Write] The name of the Space to retrieve the transform for.
    - ``space_type`` (RigVMTransformSpace):  [Read-Write] Defines if the Space's transform should be retrieved
      in local or global space.
    - ``transform`` (Transform):  [Read-Write] The current transform of the given bone - or identity in case it wasn't found.
    """
    def __init__(self, space: Name = "None", space_type: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Space to retrieve the transform for.
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def space_type(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the Space's transform should be retrieved
        in local or global space.
        """
        ...
    @space_type.setter
    def space_type(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The current transform of the given bone - or identity in case it wasn't found.
        """
        ...

class RigUnit_GetTransform(RigUnit):
    r"""
    GetTransform is used to retrieve a single transform from a hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``initial`` (bool):  [Read-Write] Defines if the transform should be retrieved as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``item`` (RigElementKey):  [Read-Write] The item to retrieve the transform for
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the transform should be retrieved in local or global space
    - ``transform`` (Transform):  [Read-Write] The current transform of the given item - or identity in case it wasn't found.
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial: bool = False, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to retrieve the transform for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the transform should be retrieved in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the transform should be retrieved as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The current transform of the given item - or identity in case it wasn't found.
        """
        ...

class RigUnit_GetTransformArray(RigUnit):
    r"""
    GetTransformArray is used to retrieve an array of transforms from the hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``initial`` (bool):  [Read-Write] Defines if the transforms should be retrieved as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``items`` (RigElementKeyCollection):  [Read-Write] The items to retrieve the transforms for
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the transforms should be retrieved in local or global space
    - ``transforms`` (Array[Transform]):  [Read-Write] The current transform of the given item - or identity in case it wasn't found.
    """
    def __init__(self, items: RigElementKeyCollection = [[]], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial: bool = False, transforms: Array[Transform] = []) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] The items to retrieve the transforms for
        """
        ...
    @items.setter
    def items(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the transforms should be retrieved in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the transforms should be retrieved as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Only] The current transform of the given item - or identity in case it wasn't found.
        """
        ...

class RigUnit_GetTransformItemArray(RigUnit):
    r"""
    GetTransformArray is used to retrieve an array of transforms from the hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_GetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``initial`` (bool):  [Read-Write] Defines if the transforms should be retrieved as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items to retrieve the transforms for
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the transforms should be retrieved in local or global space
    - ``transforms`` (Array[Transform]):  [Read-Write] The current transform of the given item - or identity in case it wasn't found.
    """
    def __init__(self, items: Array[RigElementKey] = [], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial: bool = False, transforms: Array[Transform] = []) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The items to retrieve the transforms for
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the transforms should be retrieved in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the transforms should be retrieved as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Only] The current transform of the given item - or identity in case it wasn't found.
        """
        ...

class RigDispatch_MetadataBase(RigDispatchFactory):
    r"""
    Rig Dispatch Metadata Base
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    """
    def __init__(self) -> None:
        ...

class RigDispatch_GetMetadata(RigDispatch_MetadataBase):
    r"""
    * Sets some metadata for the provided item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    """
    def __init__(self) -> None:
        ...

class RigDispatch_SetMetadata(RigDispatch_MetadataBase):
    r"""
    * Sets some metadata for the provided item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_RemoveMetadata(RigUnitMutable):
    r"""
    Removes an existing metadata filed from an item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] The item to remove the metadata from
    - ``name`` (Name):  [Read-Write] The name of the metadata to remove
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``removed`` (bool):  [Read-Write] True if the metadata has been removed
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE, removed: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to remove the metadata from
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the metadata to remove
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...
    @property
    def removed(self) -> bool:
        r"""
        (bool):  [Read-Only] True if the metadata has been removed
        """
        ...

class RigUnit_RemoveAllMetadata(RigUnitMutable):
    r"""
    Removes an existing metadata filed from an item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] The item to remove the metadata from
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``removed`` (bool):  [Read-Write] True if any metadata has been removed
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE, removed: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to remove the metadata from
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...
    @property
    def removed(self) -> bool:
        r"""
        (bool):  [Read-Only] True if any metadata has been removed
        """
        ...

class RigUnit_HasMetadata(RigUnit):
    r"""
    Returns true if a given item in the hierarchy has a specific set of metadata
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``found`` (bool):  [Read-Write] True if the item has the metadata
    - ``item`` (RigElementKey):  [Read-Write] The item to check the metadata for
    - ``name`` (Name):  [Read-Write] The name of the metadata to check
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``type`` (RigMetadataType):  [Read-Write] The type of metadata to check for
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], name: Name = "None", type: RigMetadataType = RigMetadataType.BOOL, name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE, found: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to check the metadata for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the metadata to check
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def type(self) -> RigMetadataType:
        r"""
        (RigMetadataType):  [Read-Write] The type of metadata to check for
        """
        ...
    @type.setter
    def type(self, value: RigMetadataType) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...
    @property
    def found(self) -> bool:
        r"""
        (bool):  [Read-Only] True if the item has the metadata
        """
        ...

class RigUnit_FindItemsWithMetadata(RigUnit):
    r"""
    Returns all items containing a specific set of metadata
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items containing the metadata
    - ``name`` (Name):  [Read-Write] The name of the metadata to find
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``type`` (RigMetadataType):  [Read-Write] The type of metadata to find
    """
    def __init__(self, name: Name = "None", type: RigMetadataType = RigMetadataType.BOOL, name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the metadata to find
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def type(self) -> RigMetadataType:
        r"""
        (RigMetadataType):  [Read-Write] The type of metadata to find
        """
        ...
    @type.setter
    def type(self, value: RigMetadataType) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only] The items containing the metadata
        """
        ...

class RigUnit_GetMetadataTags(RigUnit):
    r"""
    Returns the metadata tags on an item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Write] The item to check the metadata for
    - ``tags`` (Array[Name]):  [Read-Write] The name of the tag to check
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], tags: Array[Name] = []) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to check the metadata for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def tags(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Only] The name of the tag to check
        """
        ...

class RigUnit_SetMetadataTag(RigUnitMutable):
    r"""
    Sets a single tag on an item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] The item to set the metadata for
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``tag`` (Name):  [Read-Write] The name of the tag to set
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], tag: Name = "None", name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to set the metadata for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def tag(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the tag to set
        """
        ...
    @tag.setter
    def tag(self, value: Name) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...

class RigUnit_SetMetadataTagArray(RigUnitMutable):
    r"""
    Sets multiple tags on an item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] The item to set the metadata for
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``tags`` (Array[Name]):  [Read-Write] The tags to set for the item
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], tags: Array[Name] = [], name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to set the metadata for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def tags(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] The tags to set for the item
        """
        ...
    @tags.setter
    def tags(self, value: Array[Name]) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...

class RigUnit_RemoveMetadataTag(RigUnitMutable):
    r"""
    Removes a tag from an item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] The item to set the metadata for
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``removed`` (bool):  [Read-Write] Returns true if the removal was successful
    - ``tag`` (Name):  [Read-Write] The name of the tag to set
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], tag: Name = "None", name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE, removed: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to set the metadata for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def tag(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the tag to set
        """
        ...
    @tag.setter
    def tag(self, value: Name) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...
    @property
    def removed(self) -> bool:
        r"""
        (bool):  [Read-Only] Returns true if the removal was successful
        """
        ...

class RigUnit_HasMetadataTag(RigUnit):
    r"""
    Returns true if a given item in the hierarchy has a specific tag stored in the metadata
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``found`` (bool):  [Read-Write] True if the item has the metadata
    - ``item`` (RigElementKey):  [Read-Write] The item to check the metadata for
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``tag`` (Name):  [Read-Write] The name of the tag to check
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], tag: Name = "None", name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE, found: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to check the metadata for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def tag(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the tag to check
        """
        ...
    @tag.setter
    def tag(self, value: Name) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...
    @property
    def found(self) -> bool:
        r"""
        (bool):  [Read-Only] True if the item has the metadata
        """
        ...

class RigUnit_HasMetadataTagArray(RigUnit):
    r"""
    Returns true if a given item in the hierarchy has all of the provided tags
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``found`` (bool):  [Read-Write] True if the item has the metadata
    - ``item`` (RigElementKey):  [Read-Write] The item to check the metadata for
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``tags`` (Array[Name]):  [Read-Write] The name of the tag to check
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], tags: Array[Name] = [], name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE, found: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to check the metadata for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def tags(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] The name of the tag to check
        """
        ...
    @tags.setter
    def tags(self, value: Array[Name]) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...
    @property
    def found(self) -> bool:
        r"""
        (bool):  [Read-Only] True if the item has the metadata
        """
        ...

class RigUnit_FindItemsWithMetadataTag(RigUnit):
    r"""
    Returns all items with a specific tag
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items containing the metadata
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``tag`` (Name):  [Read-Write] The name of the tag to find
    """
    def __init__(self, tag: Name = "None", name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def tag(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the tag to find
        """
        ...
    @tag.setter
    def tag(self, value: Name) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only] The items containing the metadata
        """
        ...

class RigUnit_FindItemsWithMetadataTagArray(RigUnit):
    r"""
    Returns all items with a specific tag
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items containing the metadata
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``tags`` (Array[Name]):  [Read-Write] The tags to find
    """
    def __init__(self, tags: Array[Name] = [], name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE, items: Array[RigElementKey] = []) -> None:
        ...
    @property
    def tags(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] The tags to find
        """
        ...
    @tags.setter
    def tags(self, value: Array[Name]) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only] The items containing the metadata
        """
        ...

class RigUnit_FilterItemsByMetadataTags(RigUnit):
    r"""
    Filters an item array by a list of tags
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``inclusive`` (bool):  [Read-Write] If set to true only items with ALL of tags will be returned,
      if set to false items with ANY of the tags will be removed
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items to filter
    - ``name_space`` (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
    - ``result`` (Array[RigElementKey]):  [Read-Write] The results of the filter
    - ``tags`` (Array[Name]):  [Read-Write] The tags to find
    """
    def __init__(self, items: Array[RigElementKey] = [], tags: Array[Name] = [], name_space: RigMetaDataNameSpace = RigMetaDataNameSpace.NONE, inclusive: bool = False, result: Array[RigElementKey] = []) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The items to filter
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def tags(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] The tags to find
        """
        ...
    @tags.setter
    def tags(self, value: Array[Name]) -> None:
        ...
    @property
    def name_space(self) -> RigMetaDataNameSpace:
        r"""
        (RigMetaDataNameSpace):  [Read-Write] Defines in which namespace the metadata will be looked up
        """
        ...
    @name_space.setter
    def name_space(self, value: RigMetaDataNameSpace) -> None:
        ...
    @property
    def inclusive(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true only items with ALL of tags will be returned,
        if set to false items with ANY of the tags will be removed
        """
        ...
    @inclusive.setter
    def inclusive(self, value: bool) -> None:
        ...
    @property
    def result(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only] The results of the filter
        """
        ...

class RigDispatch_GetModuleMetadata(RigDispatch_GetMetadata):
    r"""
    * Returns some metadata on a given module
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    """
    def __init__(self) -> None:
        ...

class RigDispatch_SetModuleMetadata(RigDispatch_SetMetadata):
    r"""
    * Sets metadata on the module
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_Metadata.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_OffsetTransformForItem(RigUnitMutable):
    r"""
    Offset Transform is used to add an offset to an existing transform in the hierarchy. The offset is post multiplied.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_OffsetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] The item to offset the transform for
    - ``offset_transform`` (Transform):  [Read-Write] The transform of the item relative to its previous transform
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true children of affected items in the hierarchy
      will follow the transform change - otherwise only the parent will move.
    - ``weight`` (float):  [Read-Write] Defines how much the change will be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], offset_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to offset the transform for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def offset_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the item relative to its previous transform
        """
        ...
    @offset_transform.setter
    def offset_transform(self, value: Transform) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] Defines how much the change will be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true children of affected items in the hierarchy
        will follow the transform change - otherwise only the parent will move.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...

class RigUnit_ParentSwitchConstraint(RigUnitMutable):
    r"""
    The Parent Switch Constraint is used to have an item follow one of multiple parents,
    and allowing to switch between the parent in question.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ParentSwitchConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_global_transform`` (Transform):  [Read-Write] The initial global transform for the subject
    - ``parent_index`` (int32):  [Read-Write] The parent index to use for constraining the subject
    - ``parents`` (RigElementKeyCollection):  [Read-Write] The list of parents to constrain to
    - ``subject`` (RigElementKey):  [Read-Write] The subject to constrain
    - ``switched`` (bool):  [Read-Write] Returns true if the parent has changed
    - ``transform`` (Transform):  [Read-Write] The transform result (full without weighting)
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], subject: RigElementKey = [RigElementType.NONE, "None"], parent_index: int = 0, parents: RigElementKeyCollection = [[]], initial_global_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], weight: float = 0.000000, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], switched: bool = False) -> None:
        ...
    @property
    def subject(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The subject to constrain
        """
        ...
    @subject.setter
    def subject(self, value: RigElementKey) -> None:
        ...
    @property
    def parent_index(self) -> int:
        r"""
        (int32):  [Read-Write] The parent index to use for constraining the subject
        """
        ...
    @parent_index.setter
    def parent_index(self, value: int) -> None:
        ...
    @property
    def parents(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] The list of parents to constrain to
        """
        ...
    @parents.setter
    def parents(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def initial_global_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The initial global transform for the subject
        """
        ...
    @initial_global_transform.setter
    def initial_global_transform(self, value: Transform) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The transform result (full without weighting)
        """
        ...
    @property
    def switched(self) -> bool:
        r"""
        (bool):  [Read-Only] Returns true if the parent has changed
        """
        ...

class RigUnit_ParentSwitchConstraintArray(RigUnitMutable):
    r"""
    The Parent Switch Constraint is used to have an item follow one of multiple parents,
    and allowing to switch between the parent in question.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ParentSwitchConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial_global_transform`` (Transform):  [Read-Write] The initial global transform for the subject
    - ``parent_index`` (int32):  [Read-Write] The parent index to use for constraining the subject
    - ``parents`` (Array[RigElementKey]):  [Read-Write] The list of parents to constrain to
    - ``subject`` (RigElementKey):  [Read-Write] The subject to constrain
    - ``switched`` (bool):  [Read-Write] Returns true if the parent has changed
    - ``transform`` (Transform):  [Read-Write] The transform result (full without weighting)
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], subject: RigElementKey = [RigElementType.NONE, "None"], parent_index: int = 0, parents: Array[RigElementKey] = [], initial_global_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], weight: float = 0.000000, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], switched: bool = False) -> None:
        ...
    @property
    def subject(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The subject to constrain
        """
        ...
    @subject.setter
    def subject(self, value: RigElementKey) -> None:
        ...
    @property
    def parent_index(self) -> int:
        r"""
        (int32):  [Read-Write] The parent index to use for constraining the subject
        """
        ...
    @parent_index.setter
    def parent_index(self, value: int) -> None:
        ...
    @property
    def parents(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The list of parents to constrain to
        """
        ...
    @parents.setter
    def parents(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def initial_global_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The initial global transform for the subject
        """
        ...
    @initial_global_transform.setter
    def initial_global_transform(self, value: Transform) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The transform result (full without weighting)
        """
        ...
    @property
    def switched(self) -> bool:
        r"""
        (bool):  [Read-Only] Returns true if the parent has changed
        """
        ...

class RigUnit_ProjectTransformToNewParent(RigUnit):
    r"""
    Gets the relative offset between the child and the old parent, then multiplies by new parent's transform.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ProjectTransformToNewParent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write] The element to project between parents
    - ``child_initial`` (bool):  [Read-Write] If set to true the child will be retrieved in its initial transform
    - ``new_parent`` (RigElementKey):  [Read-Write] The new parent of the child.
    - ``new_parent_initial`` (bool):  [Read-Write] If set to true the new parent will be retrieved in its initial transform
    - ``old_parent`` (RigElementKey):  [Read-Write] The original parent of the child.
      Can be an actual parent in the hierarchy or any other
      item you want to use to compute to offset against.
    - ``old_parent_initial`` (bool):  [Read-Write] If set to true the old parent will be retrieved in its initial transform
    - ``transform`` (Transform):  [Read-Write] The resulting transform
    """
    def __init__(self, child: RigElementKey = [RigElementType.NONE, "None"], child_initial: bool = False, old_parent: RigElementKey = [RigElementType.NONE, "None"], old_parent_initial: bool = False, new_parent: RigElementKey = [RigElementType.NONE, "None"], new_parent_initial: bool = False, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The element to project between parents
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def child_initial(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the child will be retrieved in its initial transform
        """
        ...
    @child_initial.setter
    def child_initial(self, value: bool) -> None:
        ...
    @property
    def old_parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The original parent of the child.
        Can be an actual parent in the hierarchy or any other
        item you want to use to compute to offset against.
        """
        ...
    @old_parent.setter
    def old_parent(self, value: RigElementKey) -> None:
        ...
    @property
    def old_parent_initial(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the old parent will be retrieved in its initial transform
        """
        ...
    @old_parent_initial.setter
    def old_parent_initial(self, value: bool) -> None:
        ...
    @property
    def new_parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The new parent of the child.
        """
        ...
    @new_parent.setter
    def new_parent(self, value: RigElementKey) -> None:
        ...
    @property
    def new_parent_initial(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the new parent will be retrieved in its initial transform
        """
        ...
    @new_parent_initial.setter
    def new_parent_initial(self, value: bool) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The resulting transform
        """
        ...

class RigUnit_PropagateTransform(RigUnitMutable):
    r"""
    Propagate Transform can be used to force a recalculation of a bone's global transform
    from its local - as well as propagating that change onto the children.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_PropagateTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_to_children`` (bool):  [Read-Write] If set to true the direct children of this item will be recomputed as well.
      Combined with bRecursive all children will be affected recursively.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] The item to offset the transform for
    - ``recompute_global`` (bool):  [Read-Write] If set to true the item's global transform will be recomputed from
      its parent's transform and its local.
    - ``recursive`` (bool):  [Read-Write] If set to true and with bApplyToChildren enabled
      all children will be affected recursively.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], recompute_global: bool = False, apply_to_children: bool = False, recursive: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to offset the transform for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def recompute_global(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the item's global transform will be recomputed from
        its parent's transform and its local.
        """
        ...
    @recompute_global.setter
    def recompute_global(self, value: bool) -> None:
        ...
    @property
    def apply_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the direct children of this item will be recomputed as well.
        Combined with bRecursive all children will be affected recursively.
        """
        ...
    @apply_to_children.setter
    def apply_to_children(self, value: bool) -> None:
        ...
    @property
    def recursive(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true and with bApplyToChildren enabled
        all children will be affected recursively.
        """
        ...
    @recursive.setter
    def recursive(self, value: bool) -> None:
        ...

class RigUnit_SendEvent(RigUnitMutable):
    r"""
    SendEvent is used to notify the engine / editor of a change that happend within the Control Rig.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SendEvent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable`` (bool):  [Read-Write] The event will be sent if this is checked
    - ``event`` (RigEvent):  [Read-Write] The event to send to the engine
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] The item to send the event for
    - ``offset_in_seconds`` (float):  [Read-Write] The time offset to use for the send event
    - ``only_during_interaction`` (bool):  [Read-Write] The event will be sent if this only during an interaction
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], event: RigEvent = RigEvent.NONE, item: RigElementKey = [RigElementType.NONE, "None"], offset_in_seconds: float = 0.000000, enable: bool = False, only_during_interaction: bool = False) -> None:
        ...
    @property
    def event(self) -> RigEvent:
        r"""
        (RigEvent):  [Read-Write] The event to send to the engine
        """
        ...
    @event.setter
    def event(self, value: RigEvent) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to send the event for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def offset_in_seconds(self) -> float:
        r"""
        (float):  [Read-Write] The time offset to use for the send event
        """
        ...
    @offset_in_seconds.setter
    def offset_in_seconds(self, value: float) -> None:
        ...
    @property
    def enable(self) -> bool:
        r"""
        (bool):  [Read-Write] The event will be sent if this is checked
        """
        ...
    @enable.setter
    def enable(self, value: bool) -> None:
        ...
    @property
    def only_during_interaction(self) -> bool:
        r"""
        (bool):  [Read-Write] The event will be sent if this only during an interaction
        """
        ...
    @only_during_interaction.setter
    def only_during_interaction(self, value: bool) -> None:
        ...

class RigUnit_SetBoneInitialTransform(RigUnitMutable):
    r"""
    SetBoneInitialTransform is used to perform a change in the hierarchy by setting a single bone's transform.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetBoneInitialTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the Bone to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``result`` (Transform):  [Read-Write] The transform value result (after weighting)
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
      in local or global space.
    - ``transform`` (Transform):  [Read-Write] The transform value to set for the given Bone.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], bone: Name = "None", transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, propagate_to_children: bool = False) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to set the transform for.
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform value to set for the given Bone.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The transform value result (after weighting)
        """
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_SetBoneRotation(RigUnitMutable):
    r"""
    SetBoneRotation is used to perform a change in the hierarchy by setting a single bone's rotation.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetBoneRotation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the Bone to set the rotation for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``rotation`` (Quat):  [Read-Write] The rotation value to set for the given Bone.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's rotation should be set
      in local or global space.
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], bone: Name = "None", rotation: Quat = [0.000000, 0.000000, 0.000000, 1.000000], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to set the rotation for.
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Write] The rotation value to set for the given Bone.
        """
        ...
    @rotation.setter
    def rotation(self, value: Quat) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's rotation should be set
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_SetBoneTransform(RigUnitMutable):
    r"""
    SetBoneTransform is used to perform a change in the hierarchy by setting a single bone's transform.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetBoneTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the Bone to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``result`` (Transform):  [Read-Write] The transform value result (after weighting)
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
      in local or global space.
    - ``transform`` (Transform):  [Read-Write] The transform value to set for the given Bone.
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], bone: Name = "None", transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to set the transform for.
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform value to set for the given Bone.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The transform value result (after weighting)
        """
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_SetBoneTranslation(RigUnitMutable):
    r"""
    SetBoneTranslation is used to perform a change in the hierarchy by setting a single bone's Translation.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetBoneTranslation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the Bone to set the Translation for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's Translation should be set
      in local or global space.
    - ``translation`` (Vector):  [Read-Write] The Translation value to set for the given Bone.
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], bone: Name = "None", translation: Vector = [0.000000, 0.000000, 0.000000], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to set the Translation for.
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def translation(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The Translation value to set for the given Bone.
        """
        ...
    @translation.setter
    def translation(self, value: Vector) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's Translation should be set
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_GetControlColor(RigUnit):
    r"""
    GetControlColor is used to retrieve the color of control
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write] The color of the control
    - ``control`` (Name):  [Read-Write] The name of the Control to get the color for.
    """
    def __init__(self, control: Name = "None", color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to get the color for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color of the control
        """
        ...

class RigUnit_SetControlColor(RigUnitMutable):
    r"""
    SetControlColor is used to change the control's color
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write] The color to set for the control
    - ``control`` (Name):  [Read-Write] The name of the Control to set the color for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], control: Name = "None", color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the color for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color to set for the control
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...

class RigUnit_GetControlDrivenList(RigUnit):
    r"""
    GetControlDrivenList is used to retrieve the list of affected controls of an indirect control
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlDrivenList.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to get the list for
    - ``driven`` (Array[RigElementKey]):  [Read-Write] The list of affected controls
    """
    def __init__(self, control: Name = "None", driven: Array[RigElementKey] = []) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to get the list for
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def driven(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only] The list of affected controls
        """
        ...

class RigUnit_SetControlDrivenList(RigUnitMutable):
    r"""
    SetControlDrivenList is used to change the list of affected controls of an indirect control
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlDrivenList.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the list for
    - ``driven`` (Array[RigElementKey]):  [Read-Write] The list of affected controls
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], control: Name = "None", driven: Array[RigElementKey] = []) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the list for
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def driven(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The list of affected controls
        """
        ...
    @driven.setter
    def driven(self, value: Array[RigElementKey]) -> None:
        ...

class RigUnit_SetControlOffset(RigUnitMutable):
    r"""
    SetControlOffset is used to perform a change in the hierarchy by setting a single control's transform.
    This is typically only used during the Construction Event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlOffset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``offset`` (Transform):  [Read-Write] The offset transform to set for the control
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
      in local or global space.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], control: Name = "None", offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The offset transform to set for the control
        """
        ...
    @offset.setter
    def offset(self, value: Transform) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...

class RigUnit_GetShapeTransform(RigUnit):
    r"""
    GetShapeTransform is used to retrieve single control's shape transform.
    This is typically only used during the Construction Event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlOffset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``transform`` (Transform):  [Read-Write] The shape transform to set for the control
    """
    def __init__(self, control: Name = "None", transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The shape transform to set for the control
        """
        ...

class RigUnit_SetShapeTransform(RigUnitMutable):
    r"""
    SetShapeTransform is used to perform a change in the hierarchy by setting a single control's shape transform.
    This is typically only used during the Construction Event.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlOffset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``transform`` (Transform):  [Read-Write] The shape transform to set for the control
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], control: Name = "None", transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The shape transform to set for the control
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...

class RigUnit_SetControlBool(RigUnitMutable):
    r"""
    SetControlBool is used to perform a change in the hierarchy by setting a single control's bool value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool_value`` (bool):  [Read-Write] The bool value to set for the given Control.
    - ``control`` (Name):  [Read-Write] The name of the Control to set the bool for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], control: Name = "None", bool_value: bool = False) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the bool for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def bool_value(self) -> bool:
        r"""
        (bool):  [Read-Write] The bool value to set for the given Control.
        """
        ...
    @bool_value.setter
    def bool_value(self, value: bool) -> None:
        ...

class RigUnit_SetMultiControlBool_Entry(StructBase):
    r"""
    Rig Unit Set Multi Control Bool Entry
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool_value`` (bool):  [Read-Write] The bool value to set for the given Control.
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    """
    def __init__(self, control: Name = "None", bool_value: bool = False) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def bool_value(self) -> bool:
        r"""
        (bool):  [Read-Write] The bool value to set for the given Control.
        """
        ...
    @bool_value.setter
    def bool_value(self, value: bool) -> None:
        ...

class RigUnit_SetMultiControlBool(RigUnitMutable):
    r"""
    SetMultiControlBool is used to perform a change in the hierarchy by setting multiple controls' bool value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``entries`` (Array[RigUnit_SetMultiControlBool_Entry]):  [Read-Write] The array of control-Bool pairs to be processed
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], entries: Array[RigUnit_SetMultiControlBool_Entry] = []) -> None:
        ...
    @property
    def entries(self) -> Array[RigUnit_SetMultiControlBool_Entry]:
        r"""
        (Array[RigUnit_SetMultiControlBool_Entry]):  [Read-Write] The array of control-Bool pairs to be processed
        """
        ...
    @entries.setter
    def entries(self, value: Array[RigUnit_SetMultiControlBool_Entry]) -> None:
        ...

class RigUnit_SetControlFloat(RigUnitMutable):
    r"""
    SetControlFloat is used to perform a change in the hierarchy by setting a single control's float value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``float_value`` (float):  [Read-Write] The transform value to set for the given Control.
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], control: Name = "None", weight: float = 0.000000, float_value: float = 0.000000) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def float_value(self) -> float:
        r"""
        (float):  [Read-Write] The transform value to set for the given Control.
        """
        ...
    @float_value.setter
    def float_value(self, value: float) -> None:
        ...

class RigUnit_SetMultiControlFloat_Entry(StructBase):
    r"""
    Rig Unit Set Multi Control Float Entry
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``float_value`` (float):  [Read-Write] The transform value to set for the given Control.
    """
    def __init__(self, control: Name = "None", float_value: float = 0.000000) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def float_value(self) -> float:
        r"""
        (float):  [Read-Write] The transform value to set for the given Control.
        """
        ...
    @float_value.setter
    def float_value(self, value: float) -> None:
        ...

class RigUnit_SetMultiControlFloat(RigUnitMutable):
    r"""
    SetMultiControlFloat is used to perform a change in the hierarchy by setting multiple controls' float value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``entries`` (Array[RigUnit_SetMultiControlFloat_Entry]):  [Read-Write] The array of control-float pairs to be processed
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], entries: Array[RigUnit_SetMultiControlFloat_Entry] = [], weight: float = 0.000000) -> None:
        ...
    @property
    def entries(self) -> Array[RigUnit_SetMultiControlFloat_Entry]:
        r"""
        (Array[RigUnit_SetMultiControlFloat_Entry]):  [Read-Write] The array of control-float pairs to be processed
        """
        ...
    @entries.setter
    def entries(self, value: Array[RigUnit_SetMultiControlFloat_Entry]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_SetControlInteger(RigUnitMutable):
    r"""
    SetControlInteger is used to perform a change in the hierarchy by setting a single control's int32 value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``integer_value`` (int32):  [Read-Write] The transform value to set for the given Control.
    - ``weight`` (int32):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], control: Name = "None", weight: int = 0, integer_value: int = 0) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def weight(self) -> int:
        r"""
        (int32):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: int) -> None:
        ...
    @property
    def integer_value(self) -> int:
        r"""
        (int32):  [Read-Write] The transform value to set for the given Control.
        """
        ...
    @integer_value.setter
    def integer_value(self, value: int) -> None:
        ...

class RigUnit_SetMultiControlInteger_Entry(StructBase):
    r"""
    Rig Unit Set Multi Control Integer Entry
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``integer_value`` (int32):  [Read-Write] The transform value to set for the given Control.
    """
    def __init__(self, control: Name = "None", integer_value: int = 0) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def integer_value(self) -> int:
        r"""
        (int32):  [Read-Write] The transform value to set for the given Control.
        """
        ...
    @integer_value.setter
    def integer_value(self, value: int) -> None:
        ...

class RigUnit_SetMultiControlInteger(RigUnitMutable):
    r"""
    SetMultiControlInteger is used to perform a change in the hierarchy by setting multiple controls' integer value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``entries`` (Array[RigUnit_SetMultiControlInteger_Entry]):  [Read-Write] The array of control-integer pairs to be processed
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], entries: Array[RigUnit_SetMultiControlInteger_Entry] = [], weight: float = 0.000000) -> None:
        ...
    @property
    def entries(self) -> Array[RigUnit_SetMultiControlInteger_Entry]:
        r"""
        (Array[RigUnit_SetMultiControlInteger_Entry]):  [Read-Write] The array of control-integer pairs to be processed
        """
        ...
    @entries.setter
    def entries(self, value: Array[RigUnit_SetMultiControlInteger_Entry]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_SetControlVector2D(RigUnitMutable):
    r"""
    SetControlVector2D is used to perform a change in the hierarchy by setting a single control's Vector2D value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``vector`` (Vector2D):  [Read-Write] The transform value to set for the given Control.
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], control: Name = "None", weight: float = 0.000000, vector: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def vector(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The transform value to set for the given Control.
        """
        ...
    @vector.setter
    def vector(self, value: Vector2D) -> None:
        ...

class RigUnit_SetMultiControlVector2D_Entry(StructBase):
    r"""
    Rig Unit Set Multi Control Vector 2D Entry
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``vector`` (Vector2D):  [Read-Write] The transform value to set for the given Control.
    """
    def __init__(self, control: Name = "None", vector: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def vector(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The transform value to set for the given Control.
        """
        ...
    @vector.setter
    def vector(self, value: Vector2D) -> None:
        ...

class RigUnit_SetMultiControlVector2D(RigUnitMutable):
    r"""
    SetMultiControlVector2D is used to perform a change in the hierarchy by setting multiple controls' vector2D value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``entries`` (Array[RigUnit_SetMultiControlVector2D_Entry]):  [Read-Write] The array of control-vector2D pairs to be processed
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], entries: Array[RigUnit_SetMultiControlVector2D_Entry] = [], weight: float = 0.000000) -> None:
        ...
    @property
    def entries(self) -> Array[RigUnit_SetMultiControlVector2D_Entry]:
        r"""
        (Array[RigUnit_SetMultiControlVector2D_Entry]):  [Read-Write] The array of control-vector2D pairs to be processed
        """
        ...
    @entries.setter
    def entries(self, value: Array[RigUnit_SetMultiControlVector2D_Entry]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_SetControlVector(RigUnitMutable):
    r"""
    SetControlVector is used to perform a change in the hierarchy by setting a single control's Vector value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
      in local or global space.
    - ``vector`` (Vector):  [Read-Write] The transform value to set for the given Control.
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], control: Name = "None", weight: float = 0.000000, vector: Vector = [0.000000, 0.000000, 0.000000], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The transform value to set for the given Control.
        """
        ...
    @vector.setter
    def vector(self, value: Vector) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...

class RigUnit_SetControlRotator(RigUnitMutable):
    r"""
    SetControlRotator is used to perform a change in the hierarchy by setting a single control's Rotator value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``rotator`` (Rotator):  [Read-Write] The transform value to set for the given Control.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
      in local or global space.
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], control: Name = "None", weight: float = 0.000000, rotator: Rotator = [0.000000, 0.000000, 0.000000], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def rotator(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] The transform value to set for the given Control.
        """
        ...
    @rotator.setter
    def rotator(self, value: Rotator) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...

class RigUnit_SetMultiControlRotator_Entry(StructBase):
    r"""
    Rig Unit Set Multi Control Rotator Entry
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``rotator`` (Rotator):  [Read-Write] The transform value to set for the given Control.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
      in local or global space.
    """
    def __init__(self, control: Name = "None", rotator: Rotator = [0.000000, 0.000000, 0.000000], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def rotator(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] The transform value to set for the given Control.
        """
        ...
    @rotator.setter
    def rotator(self, value: Rotator) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...

class RigUnit_SetMultiControlRotator(RigUnitMutable):
    r"""
    SetMultiControlRotator is used to perform a change in the hierarchy by setting multiple controls' rotator value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``entries`` (Array[RigUnit_SetMultiControlRotator_Entry]):  [Read-Write] The array of control-rotator pairs to be processed
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], entries: Array[RigUnit_SetMultiControlRotator_Entry] = [], weight: float = 0.000000) -> None:
        ...
    @property
    def entries(self) -> Array[RigUnit_SetMultiControlRotator_Entry]:
        r"""
        (Array[RigUnit_SetMultiControlRotator_Entry]):  [Read-Write] The array of control-rotator pairs to be processed
        """
        ...
    @entries.setter
    def entries(self, value: Array[RigUnit_SetMultiControlRotator_Entry]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_SetControlTransform(RigUnitMutable):
    r"""
    SetControlTransform is used to perform a change in the hierarchy by setting a single control's transform.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control`` (Name):  [Read-Write] The name of the Control to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
      in local or global space.
    - ``transform`` (Transform):  [Read-Write] The transform value to set for the given Control.
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], control: Name = "None", weight: float = 0.000000, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE) -> None:
        ...
    @property
    def control(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Control to set the transform for.
        """
        ...
    @control.setter
    def control(self, value: Name) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform value to set for the given Control.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...

class RigUnit_GetControlVisibility(RigUnit):
    r"""
    GetControlVisibility is used to retrieve the visibility of a control
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlVisibility.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Write] The name of the Control to set the visibility for.
    - ``visible`` (bool):  [Read-Write] The visibility of the control
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], visible: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The name of the Control to set the visibility for.
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def visible(self) -> bool:
        r"""
        (bool):  [Read-Only] The visibility of the control
        """
        ...

class RigUnit_SetControlVisibility(RigUnitMutable):
    r"""
    SetControlVisibility is used to change the visibility on a control at runtime
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetControlVisibility.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] The name of the Control to set the visibility for.
    - ``pattern`` (str):  [Read-Only] If the ControlName is set to None this can be used to look for a series of Controls
    - ``visible`` (bool):  [Read-Write] The visibility to set for the control
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], pattern: str = "", visible: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The name of the Control to set the visibility for.
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def pattern(self) -> str:
        r"""
        (str):  [Read-Only] If the ControlName is set to None this can be used to look for a series of Controls
        """
        ...
    @property
    def visible(self) -> bool:
        r"""
        (bool):  [Read-Write] The visibility to set for the control
        """
        ...
    @visible.setter
    def visible(self, value: bool) -> None:
        ...

class RigUnit_SetCurveValue(RigUnitMutable):
    r"""
    SetCurveValue is used to perform a change in the curve container by setting a single Curve value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetCurveValue.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve`` (Name):  [Read-Write] The name of the Curve to set the Value for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``value`` (float):  [Read-Write] The value to set for the given Curve.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], curve: Name = "None", value: float = 0.000000) -> None:
        ...
    @property
    def curve(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Curve to set the Value for.
        """
        ...
    @curve.setter
    def curve(self, value: Name) -> None:
        ...
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write] The value to set for the given Curve.
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class RigUnit_SetRelativeBoneTransform(RigUnitMutable):
    r"""
    SetRelativeBoneTransform is used to perform a change in the hierarchy by setting a single bone's transform.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetRelativeBoneTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the Bone to set the transform for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``space`` (Name):  [Read-Write] The name of the Bone to set the transform relative within.
    - ``transform`` (Transform):  [Read-Write] The transform value to set for the given Bone.
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], bone: Name = "None", space: Name = "None", transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to set the transform for.
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to set the transform relative within.
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform value to set for the given Bone.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_SetRelativeTransformForItem(RigUnitMutable):
    r"""
    SetRelativeTransform is used to set a single transform from a hierarchy in the space of another item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetRelativeTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write] The child item to set the transform for
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``parent`` (RigElementKey):  [Read-Write] The parent item to use.
      The child transform will be set in the space of the parent.
    - ``parent_initial`` (bool):  [Read-Write] Defines if the parent's transform should be determined as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true children of affected items in the hierarchy
      will follow the transform change - otherwise only the parent will move.
    - ``value`` (Transform):  [Read-Write] The transform of the child item relative to the provided parent
    - ``weight`` (float):  [Read-Write] Defines how much the change will be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], parent: RigElementKey = [RigElementType.NONE, "None"], parent_initial: bool = False, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The child item to set the transform for
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The parent item to use.
        The child transform will be set in the space of the parent.
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...
    @property
    def parent_initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the parent's transform should be determined as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @parent_initial.setter
    def parent_initial(self, value: bool) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the child item relative to the provided parent
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def relative_transform(self) -> Transform:
        r"""
        deprecated: 'relative_transform' was renamed to 'value'.
        """
        ...
    @relative_transform.setter
    def relative_transform(self, value: Transform) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] Defines how much the change will be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true children of affected items in the hierarchy
        will follow the transform change - otherwise only the parent will move.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...

class RigUnit_SetRelativeTranslationForItem(RigUnitMutable):
    r"""
    SetRelativeTranslation is used to set a single translation from a hierarchy in the space of another item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetRelativeTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write] The child item to set the transform for
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``parent`` (RigElementKey):  [Read-Write] The parent item to use.
      The child transform will be set in the space of the parent.
    - ``parent_initial`` (bool):  [Read-Write] Defines if the parent's transform should be determined as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true children of affected items in the hierarchy
      will follow the transform change - otherwise only the parent will move.
    - ``value`` (Vector):  [Read-Write] The transform of the child item relative to the provided parent
    - ``weight`` (float):  [Read-Write] Defines how much the change will be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], parent: RigElementKey = [RigElementType.NONE, "None"], parent_initial: bool = False, value: Vector = [0.000000, 0.000000, 0.000000], weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The child item to set the transform for
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The parent item to use.
        The child transform will be set in the space of the parent.
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...
    @property
    def parent_initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the parent's transform should be determined as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @parent_initial.setter
    def parent_initial(self, value: bool) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The transform of the child item relative to the provided parent
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] Defines how much the change will be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true children of affected items in the hierarchy
        will follow the transform change - otherwise only the parent will move.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...

class RigUnit_SetRelativeRotationForItem(RigUnitMutable):
    r"""
    SetRelativeRotation is used to set a single rotation from a hierarchy in the space of another item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetRelativeTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write] The child item to set the transform for
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``parent`` (RigElementKey):  [Read-Write] The parent item to use.
      The child transform will be set in the space of the parent.
    - ``parent_initial`` (bool):  [Read-Write] Defines if the parent's transform should be determined as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true children of affected items in the hierarchy
      will follow the transform change - otherwise only the parent will move.
    - ``value`` (Quat):  [Read-Write] The transform of the child item relative to the provided parent
    - ``weight`` (float):  [Read-Write] Defines how much the change will be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], parent: RigElementKey = [RigElementType.NONE, "None"], parent_initial: bool = False, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The child item to set the transform for
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def parent(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The parent item to use.
        The child transform will be set in the space of the parent.
        """
        ...
    @parent.setter
    def parent(self, value: RigElementKey) -> None:
        ...
    @property
    def parent_initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the parent's transform should be determined as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @parent_initial.setter
    def parent_initial(self, value: bool) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write] The transform of the child item relative to the provided parent
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] Defines how much the change will be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true children of affected items in the hierarchy
        will follow the transform change - otherwise only the parent will move.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...

class RigUnit_SetSpaceInitialTransform(RigUnitMutable):
    r"""
    SetSpaceInitialTransform is used to perform a change in the hierarchy by setting a single space's initial transform.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetSpaceInitialTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``result`` (Transform):  [Read-Write] The transform value result (after weighting)
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
      in local or global space.
    - ``space_name`` (Name):  [Read-Write] The name of the Space to set the transform for.
    - ``transform`` (Transform):  [Read-Write] The transform value to set for the given space.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], space_name: Name = "None", transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE) -> None:
        ...
    @property
    def space_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Space to set the transform for.
        """
        ...
    @space_name.setter
    def space_name(self, value: Name) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform value to set for the given space.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The transform value result (after weighting)
        """
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
        in local or global space.
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...

class RigUnit_SetSpaceTransform(RigUnitMutable):
    r"""
    SetSpaceTransform is used to perform a change in the hierarchy by setting a single space's transform.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetSpaceTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``space`` (Name):  [Read-Write] The name of the Space to set the transform for.
    - ``space_type`` (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
      in local or global space.
    - ``transform`` (Transform):  [Read-Write] The transform value to set for the given Space.
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], space: Name = "None", weight: float = 0.000000, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], space_type: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Space to set the transform for.
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform value to set for the given Space.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def space_type(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the bone's transform should be set
        in local or global space.
        """
        ...
    @space_type.setter
    def space_type(self, value: RigVMTransformSpace) -> None:
        ...

class RigUnit_SetTransform(RigUnitMutable):
    r"""
    SetTransform is used to set a single transform on hierarchy.
    
    Note: For Controls when setting the initial transform this node
    actually sets the Control's offset transform and resets the local
    values to (0, 0, 0).
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial`` (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``item`` (RigElementKey):  [Read-Write] The item to set the transform for
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true children of affected items in the hierarchy
      will follow the transform change - otherwise only the parent will move.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the transform should be set in local or global space
    - ``value`` (Transform):  [Read-Write] The new transform of the given item
    - ``weight`` (float):  [Read-Write] Defines how much the change will be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial: bool = False, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to set the transform for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the transform should be set in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The new transform of the given item
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        deprecated: 'transform' was renamed to 'value'.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] Defines how much the change will be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true children of affected items in the hierarchy
        will follow the transform change - otherwise only the parent will move.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...

class RigUnit_SetTranslation(RigUnitMutable):
    r"""
    SetTranslation is used to set a single translation on hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial`` (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``item`` (RigElementKey):  [Read-Write] The item to set the translation for
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true children of affected items in the hierarchy
      will follow the transform change - otherwise only the parent will move.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the translation should be set in local or global space
    - ``value`` (Vector):  [Read-Write] The new translation of the given item
    - ``weight`` (float):  [Read-Write] Defines how much the change will be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial: bool = False, value: Vector = [0.000000, 0.000000, 0.000000], weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to set the translation for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the translation should be set in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The new translation of the given item
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def translation(self) -> Vector:
        r"""
        deprecated: 'translation' was renamed to 'value'.
        """
        ...
    @translation.setter
    def translation(self, value: Vector) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] Defines how much the change will be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true children of affected items in the hierarchy
        will follow the transform change - otherwise only the parent will move.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...

class RigUnit_SetRotation(RigUnitMutable):
    r"""
    SetRotation is used to set a single rotation on hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial`` (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``item`` (RigElementKey):  [Read-Write] The item to set the rotation for
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true children of affected items in the hierarchy
      will follow the transform change - otherwise only the parent will move.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the rotation should be set in local or global space
    - ``value`` (Quat):  [Read-Write] The new rotation of the given item
    - ``weight`` (float):  [Read-Write] Defines how much the change will be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial: bool = False, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to set the rotation for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the rotation should be set in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write] The new rotation of the given item
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def rotation(self) -> Quat:
        r"""
        deprecated: 'rotation' was renamed to 'value'.
        """
        ...
    @rotation.setter
    def rotation(self, value: Quat) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] Defines how much the change will be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true children of affected items in the hierarchy
        will follow the transform change - otherwise only the parent will move.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...

class RigUnit_SetScale(RigUnitMutable):
    r"""
    SetScale is used to set a single scale on hierarchy.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial`` (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``item`` (RigElementKey):  [Read-Write] The item to set the scale for
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true children of affected items in the hierarchy
      will follow the transform change - otherwise only the parent will move.
    - ``scale`` (Vector):  [Read-Write] The new scale of the given item
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the scale should be set in local or global space
    - ``weight`` (float):  [Read-Write] Defines how much the change will be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial: bool = False, scale: Vector = [0.000000, 0.000000, 0.000000], weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to set the scale for
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the scale should be set in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...
    @property
    def scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The new scale of the given item
        """
        ...
    @scale.setter
    def scale(self, value: Vector) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] Defines how much the change will be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true children of affected items in the hierarchy
        will follow the transform change - otherwise only the parent will move.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...

class RigUnit_SetTransformArray(RigUnitMutable):
    r"""
    SetTransformArray is used to set an array of transforms on the hierarchy.
    
    Note: For Controls when setting the initial transform this node
    actually sets the Control's offset transform and resets the local
    values to (0, 0, 0).
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial`` (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``items`` (RigElementKeyCollection):  [Read-Write] The item to set the transform for
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true children of affected items in the hierarchy
      will follow the transform change - otherwise only the parent will move.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the transform should be set in local or global space
    - ``transforms`` (Array[Transform]):  [Read-Write] The new transform of the given item
    - ``weight`` (float):  [Read-Write] Defines how much the change will be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: RigElementKeyCollection = [[]], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial: bool = False, transforms: Array[Transform] = [], weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] The item to set the transform for
        """
        ...
    @items.setter
    def items(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the transform should be set in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write] The new transform of the given item
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] Defines how much the change will be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true children of affected items in the hierarchy
        will follow the transform change - otherwise only the parent will move.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...

class RigUnit_SetTransformItemArray(RigUnitMutable):
    r"""
    SetTransformArray is used to set an array of transforms on the hierarchy.
    
    Note: For Controls when setting the initial transform this node
    actually sets the Control's offset transform and resets the local
    values to (0, 0, 0).
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``initial`` (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
      Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
    - ``items`` (Array[RigElementKey]):  [Read-Write] The item to set the transform for
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true children of affected items in the hierarchy
      will follow the transform change - otherwise only the parent will move.
    - ``space`` (RigVMTransformSpace):  [Read-Write] Defines if the transform should be set in local or global space
    - ``transforms`` (Array[Transform]):  [Read-Write] The new transform of the given item
    - ``weight`` (float):  [Read-Write] Defines how much the change will be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: Array[RigElementKey] = [], space: RigVMTransformSpace = RigVMTransformSpace.LOCAL_SPACE, initial: bool = False, transforms: Array[Transform] = [], weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The item to set the transform for
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def space(self) -> RigVMTransformSpace:
        r"""
        (RigVMTransformSpace):  [Read-Write] Defines if the transform should be set in local or global space
        """
        ...
    @space.setter
    def space(self, value: RigVMTransformSpace) -> None:
        ...
    @property
    def initial(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines if the transform should be set as current (false) or initial (true).
        Initial transforms for bones and other elements in the hierarchy represent the reference pose's value.
        """
        ...
    @initial.setter
    def initial(self, value: bool) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write] The new transform of the given item
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] Defines how much the change will be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true children of affected items in the hierarchy
        will follow the transform change - otherwise only the parent will move.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...

class RigUnit_UnsetCurveValue(RigUnitMutable):
    r"""
    UnsetCurveValue is used to perform a change in the curve container by invalidating a single Curve value.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_UnsetCurveValue.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve`` (Name):  [Read-Write] The name of the Curve to set the Value for.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], curve: Name = "None") -> None:
        ...
    @property
    def curve(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Curve to set the Value for.
        """
        ...
    @curve.setter
    def curve(self, value: Name) -> None:
        ...

class RigUnit_ToWorldSpace_Transform(RigUnit):
    r"""
    Converts a transform from rig (global) space to world space
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_WorldSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (Transform):  [Read-Write] The input transform in global / rig space
    - ``world`` (Transform):  [Read-Write] The result transform in world space
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], world: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The input transform in global / rig space
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        deprecated: 'transform' was renamed to 'value'.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def world(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The result transform in world space
        """
        ...

class RigUnit_ToRigSpace_Transform(RigUnit):
    r"""
    Converts a transform from world space to rig (global) space
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_WorldSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_`` (Transform):  [Read-Write] The result transform in global / rig space
    - ``value`` (Transform):  [Read-Write] The input transform in world
    """
    def __init__(self, value: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], global_: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def value(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The input transform in world
        """
        ...
    @value.setter
    def value(self, value: Transform) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        deprecated: 'transform' was renamed to 'value'.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def global_(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The result transform in global / rig space
        """
        ...

class RigUnit_ToWorldSpace_Location(RigUnit):
    r"""
    Converts a position / location from rig (global) space to world space
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_WorldSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (Vector):  [Read-Write] The input position / location in global / rig space
    - ``world`` (Vector):  [Read-Write] The result position / location in world space
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], world: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The input position / location in global / rig space
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        deprecated: 'location' was renamed to 'value'.
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def world(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The result position / location in world space
        """
        ...

class RigUnit_ToRigSpace_Location(RigUnit):
    r"""
    Converts a position / location from world space to rig (global) space
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_WorldSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_`` (Vector):  [Read-Write] The result position / location in global / rig space
    - ``value`` (Vector):  [Read-Write] The input position / location in world
    """
    def __init__(self, value: Vector = [0.000000, 0.000000, 0.000000], global_: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def value(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The input position / location in world
        """
        ...
    @value.setter
    def value(self, value: Vector) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        deprecated: 'location' was renamed to 'value'.
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def global_(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The result position / location in global / rig space
        """
        ...

class RigUnit_ToWorldSpace_Rotation(RigUnit):
    r"""
    Converts a rotation from rig (global) space to world space
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_WorldSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (Quat):  [Read-Write] The input rotation in global / rig space
    - ``world`` (Quat):  [Read-Write] The result rotation in world space
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], world: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write] The input rotation in global / rig space
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def rotation(self) -> Quat:
        r"""
        deprecated: 'rotation' was renamed to 'value'.
        """
        ...
    @rotation.setter
    def rotation(self, value: Quat) -> None:
        ...
    @property
    def world(self) -> Quat:
        r"""
        (Quat):  [Read-Only] The result rotation in world space
        """
        ...

class RigUnit_ToRigSpace_Rotation(RigUnit):
    r"""
    Converts a rotation from world space to rig (global) space
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_WorldSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_`` (Quat):  [Read-Write] The result rotation in global / rig space
    - ``value`` (Quat):  [Read-Write] The input rotation in world
    """
    def __init__(self, value: Quat = [0.000000, 0.000000, 0.000000, 1.000000], global_: Quat = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def value(self) -> Quat:
        r"""
        (Quat):  [Read-Write] The input rotation in world
        """
        ...
    @value.setter
    def value(self, value: Quat) -> None:
        ...
    @property
    def rotation(self) -> Quat:
        r"""
        deprecated: 'rotation' was renamed to 'value'.
        """
        ...
    @rotation.setter
    def rotation(self, value: Quat) -> None:
        ...
    @property
    def global_(self) -> Quat:
        r"""
        (Quat):  [Read-Only] The result rotation in global / rig space
        """
        ...

class RigUnit_BoneHarmonics_BoneTarget(StructBase):
    r"""
    Rig Unit Bone Harmonics Bone Target
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BoneHarmonics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the bone to drive
    - ``ratio`` (float):  [Read-Only] The ratio of where the bone sits within the harmonics system.
      Valid values reach from 0.0 to 1.0
    """
    def __init__(self, bone: Name = "None", ratio: float = 0.000000) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the bone to drive
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Only] The ratio of where the bone sits within the harmonics system.
        Valid values reach from 0.0 to 1.0
        """
        ...

class RigUnit_Harmonics_TargetItem(StructBase):
    r"""
    Rig Unit Harmonics Target Item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BoneHarmonics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Write] The name of the item to drive
    - ``ratio`` (float):  [Read-Only] The ratio of where the item sits within the harmonics system.
      Valid values reach from 0.0 to 1.0
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], ratio: float = 0.000000) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The name of the item to drive
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Only] The ratio of where the item sits within the harmonics system.
        Valid values reach from 0.0 to 1.0
        """
        ...

class RigUnit_BoneHarmonics(RigUnit_HighlevelBaseMutable):
    r"""
    Performs point based simulation
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BoneHarmonics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bones`` (Array[RigUnit_BoneHarmonics_BoneTarget]):  [Read-Only] The bones to drive.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``rotation_order`` (EulerRotationOrder):  [Read-Write]
    - ``wave_amplitude`` (Vector):  [Read-Write] The amplitude in degrees per axis
    - ``wave_ease`` (RigVMAnimEasingType):  [Read-Write]
    - ``wave_frequency`` (Vector):  [Read-Write]
    - ``wave_maximum`` (float):  [Read-Write]
    - ``wave_minimum`` (float):  [Read-Write]
    - ``wave_noise`` (Vector):  [Read-Write]
    - ``wave_offset`` (Vector):  [Read-Write]
    - ``wave_speed`` (Vector):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], bones: Array[RigUnit_BoneHarmonics_BoneTarget] = [], wave_speed: Vector = [0.000000, 0.000000, 0.000000], wave_frequency: Vector = [0.000000, 0.000000, 0.000000], wave_amplitude: Vector = [0.000000, 0.000000, 0.000000], wave_offset: Vector = [0.000000, 0.000000, 0.000000], wave_noise: Vector = [0.000000, 0.000000, 0.000000], wave_ease: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, wave_minimum: float = 0.000000, wave_maximum: float = 0.000000, rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ, propagate_to_children: bool = False) -> None:
        ...
    @property
    def bones(self) -> Array[RigUnit_BoneHarmonics_BoneTarget]:
        r"""
        (Array[RigUnit_BoneHarmonics_BoneTarget]):  [Read-Only] The bones to drive.
        """
        ...
    @property
    def wave_speed(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_speed.setter
    def wave_speed(self, value: Vector) -> None:
        ...
    @property
    def wave_frequency(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_frequency.setter
    def wave_frequency(self, value: Vector) -> None:
        ...
    @property
    def wave_amplitude(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The amplitude in degrees per axis
        """
        ...
    @wave_amplitude.setter
    def wave_amplitude(self, value: Vector) -> None:
        ...
    @property
    def wave_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_offset.setter
    def wave_offset(self, value: Vector) -> None:
        ...
    @property
    def wave_noise(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_noise.setter
    def wave_noise(self, value: Vector) -> None:
        ...
    @property
    def wave_ease(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Write]
        """
        ...
    @wave_ease.setter
    def wave_ease(self, value: RigVMAnimEasingType) -> None:
        ...
    @property
    def wave_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @wave_minimum.setter
    def wave_minimum(self, value: float) -> None:
        ...
    @property
    def wave_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @wave_maximum.setter
    def wave_maximum(self, value: float) -> None:
        ...
    @property
    def rotation_order(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Write]
        """
        ...
    @rotation_order.setter
    def rotation_order(self, value: EulerRotationOrder) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_ItemHarmonics(RigUnit_HighlevelBaseMutable):
    r"""
    Drives an array of items through a harmonics spectrum
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_BoneHarmonics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``rotation_order`` (EulerRotationOrder):  [Read-Write]
    - ``targets`` (Array[RigUnit_Harmonics_TargetItem]):  [Read-Only] The items to drive.
    - ``wave_amplitude`` (Vector):  [Read-Write] The amplitude in degrees per axis
    - ``wave_ease`` (RigVMAnimEasingType):  [Read-Write]
    - ``wave_frequency`` (Vector):  [Read-Write]
    - ``wave_maximum`` (float):  [Read-Write]
    - ``wave_minimum`` (float):  [Read-Write]
    - ``wave_noise`` (Vector):  [Read-Write]
    - ``wave_offset`` (Vector):  [Read-Write]
    - ``wave_speed`` (Vector):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], targets: Array[RigUnit_Harmonics_TargetItem] = [], wave_speed: Vector = [0.000000, 0.000000, 0.000000], wave_frequency: Vector = [0.000000, 0.000000, 0.000000], wave_amplitude: Vector = [0.000000, 0.000000, 0.000000], wave_offset: Vector = [0.000000, 0.000000, 0.000000], wave_noise: Vector = [0.000000, 0.000000, 0.000000], wave_ease: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, wave_minimum: float = 0.000000, wave_maximum: float = 0.000000, rotation_order: EulerRotationOrder = EulerRotationOrder.XYZ) -> None:
        ...
    @property
    def targets(self) -> Array[RigUnit_Harmonics_TargetItem]:
        r"""
        (Array[RigUnit_Harmonics_TargetItem]):  [Read-Only] The items to drive.
        """
        ...
    @property
    def wave_speed(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_speed.setter
    def wave_speed(self, value: Vector) -> None:
        ...
    @property
    def wave_frequency(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_frequency.setter
    def wave_frequency(self, value: Vector) -> None:
        ...
    @property
    def wave_amplitude(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The amplitude in degrees per axis
        """
        ...
    @wave_amplitude.setter
    def wave_amplitude(self, value: Vector) -> None:
        ...
    @property
    def wave_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_offset.setter
    def wave_offset(self, value: Vector) -> None:
        ...
    @property
    def wave_noise(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_noise.setter
    def wave_noise(self, value: Vector) -> None:
        ...
    @property
    def wave_ease(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Write]
        """
        ...
    @wave_ease.setter
    def wave_ease(self, value: RigVMAnimEasingType) -> None:
        ...
    @property
    def wave_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @wave_minimum.setter
    def wave_minimum(self, value: float) -> None:
        ...
    @property
    def wave_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @wave_maximum.setter
    def wave_maximum(self, value: float) -> None:
        ...
    @property
    def rotation_order(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Write]
        """
        ...
    @rotation_order.setter
    def rotation_order(self, value: EulerRotationOrder) -> None:
        ...

class RigUnit_ChainHarmonics_Reach(StructBase):
    r"""
    Rig Unit Chain Harmonics Reach
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ChainHarmonics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``reach_axis`` (Vector):  [Read-Only]
    - ``reach_ease`` (RigVMAnimEasingType):  [Read-Write]
    - ``reach_maximum`` (float):  [Read-Write]
    - ``reach_minimum`` (float):  [Read-Write]
    - ``reach_target`` (Vector):  [Read-Write]
    """
    def __init__(self, enabled: bool = False, reach_target: Vector = [0.000000, 0.000000, 0.000000], reach_axis: Vector = [0.000000, 0.000000, 0.000000], reach_minimum: float = 0.000000, reach_maximum: float = 0.000000, reach_ease: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def reach_target(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @reach_target.setter
    def reach_target(self, value: Vector) -> None:
        ...
    @property
    def reach_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def reach_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @reach_minimum.setter
    def reach_minimum(self, value: float) -> None:
        ...
    @property
    def reach_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @reach_maximum.setter
    def reach_maximum(self, value: float) -> None:
        ...
    @property
    def reach_ease(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Write]
        """
        ...
    @reach_ease.setter
    def reach_ease(self, value: RigVMAnimEasingType) -> None:
        ...

class RigUnit_ChainHarmonics_Wave(StructBase):
    r"""
    Rig Unit Chain Harmonics Wave
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ChainHarmonics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``wave_amplitude`` (Vector):  [Read-Write]
    - ``wave_ease`` (RigVMAnimEasingType):  [Read-Write]
    - ``wave_frequency`` (Vector):  [Read-Write]
    - ``wave_maximum`` (float):  [Read-Write]
    - ``wave_minimum`` (float):  [Read-Write]
    - ``wave_noise`` (Vector):  [Read-Write]
    - ``wave_offset`` (Vector):  [Read-Write]
    """
    def __init__(self, enabled: bool = False, wave_frequency: Vector = [0.000000, 0.000000, 0.000000], wave_amplitude: Vector = [0.000000, 0.000000, 0.000000], wave_offset: Vector = [0.000000, 0.000000, 0.000000], wave_noise: Vector = [0.000000, 0.000000, 0.000000], wave_minimum: float = 0.000000, wave_maximum: float = 0.000000, wave_ease: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def wave_frequency(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_frequency.setter
    def wave_frequency(self, value: Vector) -> None:
        ...
    @property
    def wave_amplitude(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_amplitude.setter
    def wave_amplitude(self, value: Vector) -> None:
        ...
    @property
    def wave_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_offset.setter
    def wave_offset(self, value: Vector) -> None:
        ...
    @property
    def wave_noise(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @wave_noise.setter
    def wave_noise(self, value: Vector) -> None:
        ...
    @property
    def wave_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @wave_minimum.setter
    def wave_minimum(self, value: float) -> None:
        ...
    @property
    def wave_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @wave_maximum.setter
    def wave_maximum(self, value: float) -> None:
        ...
    @property
    def wave_ease(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Write]
        """
        ...
    @wave_ease.setter
    def wave_ease(self, value: RigVMAnimEasingType) -> None:
        ...

class RigUnit_ChainHarmonics_Pendulum(StructBase):
    r"""
    Rig Unit Chain Harmonics Pendulum
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ChainHarmonics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``pendulum_blend`` (float):  [Read-Write]
    - ``pendulum_drag`` (float):  [Read-Write]
    - ``pendulum_ease`` (RigVMAnimEasingType):  [Read-Write]
    - ``pendulum_gravity`` (Vector):  [Read-Write]
    - ``pendulum_maximum`` (float):  [Read-Write]
    - ``pendulum_minimum`` (float):  [Read-Write]
    - ``pendulum_stiffness`` (float):  [Read-Write]
    - ``unwind_axis`` (Vector):  [Read-Write]
    - ``unwind_maximum`` (float):  [Read-Write]
    - ``unwind_minimum`` (float):  [Read-Write]
    """
    def __init__(self, enabled: bool = False, pendulum_stiffness: float = 0.000000, pendulum_gravity: Vector = [0.000000, 0.000000, 0.000000], pendulum_blend: float = 0.000000, pendulum_drag: float = 0.000000, pendulum_minimum: float = 0.000000, pendulum_maximum: float = 0.000000, pendulum_ease: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, unwind_axis: Vector = [0.000000, 0.000000, 0.000000], unwind_minimum: float = 0.000000, unwind_maximum: float = 0.000000) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def pendulum_stiffness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @pendulum_stiffness.setter
    def pendulum_stiffness(self, value: float) -> None:
        ...
    @property
    def pendulum_gravity(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @pendulum_gravity.setter
    def pendulum_gravity(self, value: Vector) -> None:
        ...
    @property
    def pendulum_blend(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @pendulum_blend.setter
    def pendulum_blend(self, value: float) -> None:
        ...
    @property
    def pendulum_drag(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @pendulum_drag.setter
    def pendulum_drag(self, value: float) -> None:
        ...
    @property
    def pendulum_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @pendulum_minimum.setter
    def pendulum_minimum(self, value: float) -> None:
        ...
    @property
    def pendulum_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @pendulum_maximum.setter
    def pendulum_maximum(self, value: float) -> None:
        ...
    @property
    def pendulum_ease(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Write]
        """
        ...
    @pendulum_ease.setter
    def pendulum_ease(self, value: RigVMAnimEasingType) -> None:
        ...
    @property
    def unwind_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @unwind_axis.setter
    def unwind_axis(self, value: Vector) -> None:
        ...
    @property
    def unwind_minimum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @unwind_minimum.setter
    def unwind_minimum(self, value: float) -> None:
        ...
    @property
    def unwind_maximum(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @unwind_maximum.setter
    def unwind_maximum(self, value: float) -> None:
        ...

class RigUnit_ChainHarmonics(RigUnit_HighlevelBaseMutable):
    r"""
    Rig Unit Chain Harmonics
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ChainHarmonics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``chain_root`` (Name):  [Read-Write]
    - ``draw_debug`` (bool):  [Read-Write]
    - ``draw_world_offset`` (Transform):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``pendulum`` (RigUnit_ChainHarmonics_Pendulum):  [Read-Write]
    - ``reach`` (RigUnit_ChainHarmonics_Reach):  [Read-Write]
    - ``speed`` (Vector):  [Read-Write]
    - ``wave`` (RigUnit_ChainHarmonics_Wave):  [Read-Write]
    - ``wave_curve`` (RuntimeFloatCurve):  [Read-Only]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], chain_root: Name = "None", speed: Vector = [0.000000, 0.000000, 0.000000], reach: RigUnit_ChainHarmonics_Reach = [True, [0.000000, 0.000000, 0.000000], [1.000000, 0.000000, 0.000000], 0.000000, 0.000000, RigVMAnimEasingType.LINEAR], wave: RigUnit_ChainHarmonics_Wave = [True, [1.000000, 0.600000, 0.800000], [0.000000, 1.000000, 0.000000], [0.000000, 1.000000, 2.000000], [0.000000, 0.000000, 0.000000], 0.000000, 1.000000, RigVMAnimEasingType.LINEAR], wave_curve: RuntimeFloatCurve = [], pendulum: RigUnit_ChainHarmonics_Pendulum = [True, 2.000000, [0.000000, 0.000000, 0.000000], 0.750000, 0.980000, 0.000000, 0.100000, RigVMAnimEasingType.LINEAR, [0.000000, 1.000000, 0.000000], 0.200000, 0.050000], draw_debug: bool = False, draw_world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def chain_root(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @chain_root.setter
    def chain_root(self, value: Name) -> None:
        ...
    @property
    def speed(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @speed.setter
    def speed(self, value: Vector) -> None:
        ...
    @property
    def reach(self) -> RigUnit_ChainHarmonics_Reach:
        r"""
        (RigUnit_ChainHarmonics_Reach):  [Read-Write]
        """
        ...
    @reach.setter
    def reach(self, value: RigUnit_ChainHarmonics_Reach) -> None:
        ...
    @property
    def wave(self) -> RigUnit_ChainHarmonics_Wave:
        r"""
        (RigUnit_ChainHarmonics_Wave):  [Read-Write]
        """
        ...
    @wave.setter
    def wave(self, value: RigUnit_ChainHarmonics_Wave) -> None:
        ...
    @property
    def wave_curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Only]
        """
        ...
    @property
    def pendulum(self) -> RigUnit_ChainHarmonics_Pendulum:
        r"""
        (RigUnit_ChainHarmonics_Pendulum):  [Read-Write]
        """
        ...
    @pendulum.setter
    def pendulum(self, value: RigUnit_ChainHarmonics_Pendulum) -> None:
        ...
    @property
    def draw_debug(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_debug.setter
    def draw_debug(self, value: bool) -> None:
        ...
    @property
    def draw_world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @draw_world_offset.setter
    def draw_world_offset(self, value: Transform) -> None:
        ...

class RigUnit_ChainHarmonicsPerItem(RigUnit_HighlevelBaseMutable):
    r"""
    Given a root will drive all items underneath in a chain based harmonics spectrum
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ChainHarmonics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``chain_root`` (RigElementKey):  [Read-Write]
    - ``draw_debug`` (bool):  [Read-Write]
    - ``draw_world_offset`` (Transform):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``pendulum`` (RigUnit_ChainHarmonics_Pendulum):  [Read-Write]
    - ``reach`` (RigUnit_ChainHarmonics_Reach):  [Read-Write]
    - ``speed`` (Vector):  [Read-Write]
    - ``wave`` (RigUnit_ChainHarmonics_Wave):  [Read-Write]
    - ``wave_curve`` (RuntimeFloatCurve):  [Read-Only]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], chain_root: RigElementKey = [RigElementType.NONE, "None"], speed: Vector = [0.000000, 0.000000, 0.000000], reach: RigUnit_ChainHarmonics_Reach = [True, [0.000000, 0.000000, 0.000000], [1.000000, 0.000000, 0.000000], 0.000000, 0.000000, RigVMAnimEasingType.LINEAR], wave: RigUnit_ChainHarmonics_Wave = [True, [1.000000, 0.600000, 0.800000], [0.000000, 1.000000, 0.000000], [0.000000, 1.000000, 2.000000], [0.000000, 0.000000, 0.000000], 0.000000, 1.000000, RigVMAnimEasingType.LINEAR], wave_curve: RuntimeFloatCurve = [], pendulum: RigUnit_ChainHarmonics_Pendulum = [True, 2.000000, [0.000000, 0.000000, 0.000000], 0.750000, 0.980000, 0.000000, 0.100000, RigVMAnimEasingType.LINEAR, [0.000000, 1.000000, 0.000000], 0.200000, 0.050000], draw_debug: bool = False, draw_world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def chain_root(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @chain_root.setter
    def chain_root(self, value: RigElementKey) -> None:
        ...
    @property
    def speed(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @speed.setter
    def speed(self, value: Vector) -> None:
        ...
    @property
    def reach(self) -> RigUnit_ChainHarmonics_Reach:
        r"""
        (RigUnit_ChainHarmonics_Reach):  [Read-Write]
        """
        ...
    @reach.setter
    def reach(self, value: RigUnit_ChainHarmonics_Reach) -> None:
        ...
    @property
    def wave(self) -> RigUnit_ChainHarmonics_Wave:
        r"""
        (RigUnit_ChainHarmonics_Wave):  [Read-Write]
        """
        ...
    @wave.setter
    def wave(self, value: RigUnit_ChainHarmonics_Wave) -> None:
        ...
    @property
    def wave_curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Only]
        """
        ...
    @property
    def pendulum(self) -> RigUnit_ChainHarmonics_Pendulum:
        r"""
        (RigUnit_ChainHarmonics_Pendulum):  [Read-Write]
        """
        ...
    @pendulum.setter
    def pendulum(self, value: RigUnit_ChainHarmonics_Pendulum) -> None:
        ...
    @property
    def draw_debug(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_debug.setter
    def draw_debug(self, value: bool) -> None:
        ...
    @property
    def draw_world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write]
        """
        ...
    @draw_world_offset.setter
    def draw_world_offset(self, value: Transform) -> None:
        ...

class RigUnit_AimBone_Target(StructBase):
    r"""
    Rig Unit Aim Bone Target
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis`` (Vector):  [Read-Write] The axis to align with the aim on this target
    - ``kind`` (ControlRigVectorKind):  [Read-Write] The kind of target this is representing - can be a direction or a location
    - ``space`` (Name):  [Read-Write] The space in which the target is expressed
    - ``target`` (Vector):  [Read-Write] The target to aim at - can be a direction or location based on the Kind setting
    - ``weight`` (float):  [Read-Write] The amount of aim rotation to apply on this target.
    """
    def __init__(self, weight: float = 0.000000, axis: Vector = [0.000000, 0.000000, 0.000000], target: Vector = [0.000000, 0.000000, 0.000000], kind: ControlRigVectorKind = ControlRigVectorKind.DIRECTION, space: Name = "None") -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The amount of aim rotation to apply on this target.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The axis to align with the aim on this target
        """
        ...
    @axis.setter
    def axis(self, value: Vector) -> None:
        ...
    @property
    def target(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The target to aim at - can be a direction or location based on the Kind setting
        """
        ...
    @target.setter
    def target(self, value: Vector) -> None:
        ...
    @property
    def kind(self) -> ControlRigVectorKind:
        r"""
        (ControlRigVectorKind):  [Read-Write] The kind of target this is representing - can be a direction or a location
        """
        ...
    @kind.setter
    def kind(self, value: ControlRigVectorKind) -> None:
        ...
    @property
    def space(self) -> Name:
        r"""
        (Name):  [Read-Write] The space in which the target is expressed
        """
        ...
    @space.setter
    def space(self, value: Name) -> None:
        ...

class RigUnit_AimItem_Target(StructBase):
    r"""
    Rig Unit Aim Item Target
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis`` (Vector):  [Read-Write] The axis to align with the aim on this target
    - ``kind`` (ControlRigVectorKind):  [Read-Write] The kind of target this is representing - can be a direction or a location
    - ``space`` (RigElementKey):  [Read-Write] The space in which the target is expressed
    - ``target`` (Vector):  [Read-Write] The target to aim at - can be a direction or location based on the Kind setting
    - ``weight`` (float):  [Read-Write] The amount of aim rotation to apply on this target.
    """
    def __init__(self, weight: float = 0.000000, axis: Vector = [0.000000, 0.000000, 0.000000], target: Vector = [0.000000, 0.000000, 0.000000], kind: ControlRigVectorKind = ControlRigVectorKind.DIRECTION, space: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The amount of aim rotation to apply on this target.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The axis to align with the aim on this target
        """
        ...
    @axis.setter
    def axis(self, value: Vector) -> None:
        ...
    @property
    def target(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The target to aim at - can be a direction or location based on the Kind setting
        """
        ...
    @target.setter
    def target(self, value: Vector) -> None:
        ...
    @property
    def kind(self) -> ControlRigVectorKind:
        r"""
        (ControlRigVectorKind):  [Read-Write] The kind of target this is representing - can be a direction or a location
        """
        ...
    @kind.setter
    def kind(self, value: ControlRigVectorKind) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The space in which the target is expressed
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...

class RigUnit_AimBone_DebugSettings(StructBase):
    r"""
    Rig Unit Aim Bone Debug Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write] If enabled debug information will be drawn
    - ``scale`` (float):  [Read-Write] The size of the debug drawing information
    - ``world_offset`` (Transform):  [Read-Write] The offset at which to draw the debug information in the world
    """
    def __init__(self, enabled: bool = False, scale: float = 0.000000, world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled debug information will be drawn
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write] The size of the debug drawing information
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The offset at which to draw the debug information in the world
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...

class RigUnit_AimBoneMath(RigUnit_HighlevelBase):
    r"""
    Outputs an aligned transform of a primary and secondary axis of an input transform to a world target.
    Note: This node operates in world space!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_settings`` (RigUnit_AimBone_DebugSettings):  [Read-Write] The debug setting for the node
    - ``input_transform`` (Transform):  [Read-Write] The transform (in global space) before the aim was applied (optional)
    - ``primary`` (RigUnit_AimItem_Target):  [Read-Write] The primary target for the aim
    - ``result`` (Transform):  [Read-Write] The resulting transform
    - ``secondary`` (RigUnit_AimItem_Target):  [Read-Write] The secondary target for the aim - also referred to as PoleVector / UpVector
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, input_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], primary: RigUnit_AimItem_Target = [1.000000, [1.000000, 0.000000, 0.000000], [1.000000, 0.000000, 0.000000], ControlRigVectorKind.LOCATION, [RigElementType.BONE, "None"]], secondary: RigUnit_AimItem_Target = [1.000000, [1.000000, 0.000000, 0.000000], [1.000000, 0.000000, 0.000000], ControlRigVectorKind.LOCATION, [RigElementType.BONE, "None"]], weight: float = 0.000000, result: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], debug_settings: RigUnit_AimBone_DebugSettings = [False, 10.000000, [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def input_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform (in global space) before the aim was applied (optional)
        """
        ...
    @input_transform.setter
    def input_transform(self, value: Transform) -> None:
        ...
    @property
    def primary(self) -> RigUnit_AimItem_Target:
        r"""
        (RigUnit_AimItem_Target):  [Read-Write] The primary target for the aim
        """
        ...
    @primary.setter
    def primary(self, value: RigUnit_AimItem_Target) -> None:
        ...
    @property
    def secondary(self) -> RigUnit_AimItem_Target:
        r"""
        (RigUnit_AimItem_Target):  [Read-Write] The secondary target for the aim - also referred to as PoleVector / UpVector
        """
        ...
    @secondary.setter
    def secondary(self, value: RigUnit_AimItem_Target) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def result(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The resulting transform
        """
        ...
    @property
    def debug_settings(self) -> RigUnit_AimBone_DebugSettings:
        r"""
        (RigUnit_AimBone_DebugSettings):  [Read-Write] The debug setting for the node
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_AimBone_DebugSettings) -> None:
        ...

class RigUnit_AimBone(RigUnit_HighlevelBaseMutable):
    r"""
    Aligns the rotation of a primary and secondary axis of a bone to a global target.
    Note: This node operates in global space!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the bone to align
    - ``debug_settings`` (RigUnit_AimBone_DebugSettings):  [Read-Write] The debug setting for the node
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``primary`` (RigUnit_AimBone_Target):  [Read-Write] The primary target for the aim
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``secondary`` (RigUnit_AimBone_Target):  [Read-Write] The secondary target for the aim - also referred to as PoleVector / UpVector
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], bone: Name = "None", primary: RigUnit_AimBone_Target = [1.000000, [1.000000, 0.000000, 0.000000], [1.000000, 0.000000, 0.000000], ControlRigVectorKind.LOCATION, "None"], secondary: RigUnit_AimBone_Target = [1.000000, [1.000000, 0.000000, 0.000000], [1.000000, 0.000000, 0.000000], ControlRigVectorKind.LOCATION, "None"], weight: float = 0.000000, propagate_to_children: bool = False, debug_settings: RigUnit_AimBone_DebugSettings = [False, 10.000000, [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the bone to align
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def primary(self) -> RigUnit_AimBone_Target:
        r"""
        (RigUnit_AimBone_Target):  [Read-Write] The primary target for the aim
        """
        ...
    @primary.setter
    def primary(self, value: RigUnit_AimBone_Target) -> None:
        ...
    @property
    def secondary(self) -> RigUnit_AimBone_Target:
        r"""
        (RigUnit_AimBone_Target):  [Read-Write] The secondary target for the aim - also referred to as PoleVector / UpVector
        """
        ...
    @secondary.setter
    def secondary(self, value: RigUnit_AimBone_Target) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def debug_settings(self) -> RigUnit_AimBone_DebugSettings:
        r"""
        (RigUnit_AimBone_DebugSettings):  [Read-Write] The debug setting for the node
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_AimBone_DebugSettings) -> None:
        ...

class RigUnit_AimItem(RigUnit_HighlevelBaseMutable):
    r"""
    Aligns the rotation of a primary and secondary axis of a bone to a global target.
    Note: This node operates in global space!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_settings`` (RigUnit_AimBone_DebugSettings):  [Read-Write] The debug setting for the node
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write] The name of the item to align
    - ``primary`` (RigUnit_AimItem_Target):  [Read-Write] The primary target for the aim
    - ``secondary`` (RigUnit_AimItem_Target):  [Read-Write] The secondary target for the aim - also referred to as PoleVector / UpVector
    - ``weight`` (float):  [Read-Write] The weight of the change - how much the change should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], primary: RigUnit_AimItem_Target = [1.000000, [1.000000, 0.000000, 0.000000], [1.000000, 0.000000, 0.000000], ControlRigVectorKind.LOCATION, [RigElementType.BONE, "None"]], secondary: RigUnit_AimItem_Target = [1.000000, [1.000000, 0.000000, 0.000000], [1.000000, 0.000000, 0.000000], ControlRigVectorKind.LOCATION, [RigElementType.BONE, "None"]], weight: float = 0.000000, debug_settings: RigUnit_AimBone_DebugSettings = [False, 10.000000, [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The name of the item to align
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def primary(self) -> RigUnit_AimItem_Target:
        r"""
        (RigUnit_AimItem_Target):  [Read-Write] The primary target for the aim
        """
        ...
    @primary.setter
    def primary(self, value: RigUnit_AimItem_Target) -> None:
        ...
    @property
    def secondary(self) -> RigUnit_AimItem_Target:
        r"""
        (RigUnit_AimItem_Target):  [Read-Write] The secondary target for the aim - also referred to as PoleVector / UpVector
        """
        ...
    @secondary.setter
    def secondary(self, value: RigUnit_AimItem_Target) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the change - how much the change should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def debug_settings(self) -> RigUnit_AimBone_DebugSettings:
        r"""
        (RigUnit_AimBone_DebugSettings):  [Read-Write] The debug setting for the node
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_AimBone_DebugSettings) -> None:
        ...

class RigUnit_AimConstraint_WorldUp(StructBase):
    r"""
    Rig Unit Aim Constraint World Up
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``kind`` (ControlRigVectorKind):  [Read-Write] The kind of target this is representing - can be a direction or a location
    - ``space`` (RigElementKey):  [Read-Write] The space in which the target is expressed, use None to indicate world space
    - ``target`` (Vector):  [Read-Write] The target to aim at - can be a direction or location based on the Kind setting
    """
    def __init__(self, target: Vector = [0.000000, 0.000000, 0.000000], kind: ControlRigVectorKind = ControlRigVectorKind.DIRECTION, space: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def target(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The target to aim at - can be a direction or location based on the Kind setting
        """
        ...
    @target.setter
    def target(self, value: Vector) -> None:
        ...
    @property
    def kind(self) -> ControlRigVectorKind:
        r"""
        (ControlRigVectorKind):  [Read-Write] The kind of target this is representing - can be a direction or a location
        """
        ...
    @kind.setter
    def kind(self, value: ControlRigVectorKind) -> None:
        ...
    @property
    def space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The space in which the target is expressed, use None to indicate world space
        """
        ...
    @space.setter
    def space(self, value: RigElementKey) -> None:
        ...

class RigUnit_AimConstraint_AdvancedSettings(StructBase):
    r"""
    Rig Unit Aim Constraint Advanced Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_settings`` (RigUnit_AimBone_DebugSettings):  [Read-Write] Settings related to debug drawings
    - ``rotation_order_for_filter`` (EulerRotationOrder):  [Read-Write] Rotation is converted to euler angles using the specified order such that individual axes can be filtered.
    """
    def __init__(self, debug_settings: RigUnit_AimBone_DebugSettings = [False, 10.000000, [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], rotation_order_for_filter: EulerRotationOrder = EulerRotationOrder.XYZ) -> None:
        ...
    @property
    def debug_settings(self) -> RigUnit_AimBone_DebugSettings:
        r"""
        (RigUnit_AimBone_DebugSettings):  [Read-Write] Settings related to debug drawings
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_AimBone_DebugSettings) -> None:
        ...
    @property
    def rotation_order_for_filter(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Write] Rotation is converted to euler angles using the specified order such that individual axes can be filtered.
        """
        ...
    @rotation_order_for_filter.setter
    def rotation_order_for_filter(self, value: EulerRotationOrder) -> None:
        ...

class RigUnit_AimConstraintLocalSpaceOffset(RigUnit_HighlevelBaseMutable):
    r"""
    Orients an item such that its aim axis points towards a global target.
    Note: This node operates in global space!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_AimBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``advanced_settings`` (RigUnit_AimConstraint_AdvancedSettings):  [Read-Write]
    - ``aim_axis`` (Vector):  [Read-Write] Child is rotated so that its AimAxis points to the parents
    - ``child`` (RigElementKey):  [Read-Write] The name of the item to apply aim
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``filter`` (FilterOptionPerAxis):  [Read-Write] Filters the final rotation by axes based on the euler rotation order defined in the node's advanced settings
      If flipping is observed, try adjusting the rotation order
    - ``maintain_offset`` (bool):  [Read-Write] Maintains the offset between child and weighted average of parents based on initial transforms
    - ``parents`` (Array[ConstraintParent]):  [Read-Write]
    - ``up_axis`` (Vector):  [Read-Write] Child is rotated around the AimAxis so that its UpAxis points to/Aligns with the WorldUp target
    - ``weight`` (float):  [Read-Write]
    - ``world_up`` (RigUnit_AimConstraint_WorldUp):  [Read-Write] Defines how Child should rotate around the AimAxis. This is the aim target for the UpAxis
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], maintain_offset: bool = False, filter: FilterOptionPerAxis = [True, True, True], aim_axis: Vector = [0.000000, 0.000000, 0.000000], up_axis: Vector = [0.000000, 0.000000, 0.000000], world_up: RigUnit_AimConstraint_WorldUp = [[0.000000, 0.000000, 1.000000], ControlRigVectorKind.DIRECTION, [RigElementType.NONE, "None"]], parents: Array[ConstraintParent] = [], advanced_settings: RigUnit_AimConstraint_AdvancedSettings = [[False, 10.000000, [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], EulerRotationOrder.XZY], weight: float = 0.000000) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The name of the item to apply aim
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def maintain_offset(self) -> bool:
        r"""
        (bool):  [Read-Write] Maintains the offset between child and weighted average of parents based on initial transforms
        """
        ...
    @maintain_offset.setter
    def maintain_offset(self, value: bool) -> None:
        ...
    @property
    def filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write] Filters the final rotation by axes based on the euler rotation order defined in the node's advanced settings
        If flipping is observed, try adjusting the rotation order
        """
        ...
    @filter.setter
    def filter(self, value: FilterOptionPerAxis) -> None:
        ...
    @property
    def aim_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Child is rotated so that its AimAxis points to the parents
        """
        ...
    @aim_axis.setter
    def aim_axis(self, value: Vector) -> None:
        ...
    @property
    def up_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Child is rotated around the AimAxis so that its UpAxis points to/Aligns with the WorldUp target
        """
        ...
    @up_axis.setter
    def up_axis(self, value: Vector) -> None:
        ...
    @property
    def world_up(self) -> RigUnit_AimConstraint_WorldUp:
        r"""
        (RigUnit_AimConstraint_WorldUp):  [Read-Write] Defines how Child should rotate around the AimAxis. This is the aim target for the UpAxis
        """
        ...
    @world_up.setter
    def world_up(self, value: RigUnit_AimConstraint_WorldUp) -> None:
        ...
    @property
    def parents(self) -> Array[ConstraintParent]:
        r"""
        (Array[ConstraintParent]):  [Read-Write]
        """
        ...
    @parents.setter
    def parents(self, value: Array[ConstraintParent]) -> None:
        ...
    @property
    def advanced_settings(self) -> RigUnit_AimConstraint_AdvancedSettings:
        r"""
        (RigUnit_AimConstraint_AdvancedSettings):  [Read-Write]
        """
        ...
    @advanced_settings.setter
    def advanced_settings(self, value: RigUnit_AimConstraint_AdvancedSettings) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class ConstraintParent(StructBase):
    r"""
    Constraint Parent
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], weight: float = 0.000000) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_CCDIK_RotationLimit(StructBase):
    r"""
    Rig Unit CCDIK Rotation Limit
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_CCDIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the bone to apply the rotation limit to.
    - ``limit`` (float):  [Read-Only] The limit of the rotation in degrees.
    """
    def __init__(self, bone: Name = "None", limit: float = 0.000000) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the bone to apply the rotation limit to.
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def limit(self) -> float:
        r"""
        (float):  [Read-Only] The limit of the rotation in degrees.
        """
        ...

class RigUnit_CCDIK_RotationLimitPerItem(StructBase):
    r"""
    Rig Unit CCDIK Rotation Limit Per Item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_CCDIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Write] The name of the item to apply the rotation limit to.
    - ``limit`` (float):  [Read-Only] The limit of the rotation in degrees.
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], limit: float = 0.000000) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The name of the item to apply the rotation limit to.
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def limit(self) -> float:
        r"""
        (float):  [Read-Only] The limit of the rotation in degrees.
        """
        ...

class RigUnit_CCDIK(RigUnit_HighlevelBaseMutable):
    r"""
    The CCID solver can solve N-Bone chains using
    the Cyclic Coordinate Descent Inverse Kinematics algorithm.
    For now this node supports single effector chains only.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_CCDIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_rotation_limit`` (float):  [Read-Only] The general rotation limit to be applied to bones
    - ``effector_bone`` (Name):  [Read-Write] The last bone in the chain to solve - the effector
    - ``effector_transform`` (Transform):  [Read-Write] The transform of the effector in global space
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``max_iterations`` (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
    - ``precision`` (float):  [Read-Only] The precision to use for the fabrik solver
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``rotation_limits`` (Array[RigUnit_CCDIK_RotationLimit]):  [Read-Only] Defines the limits of rotation per bone.
    - ``start_bone`` (Name):  [Read-Write] The first bone in the chain to solve
    - ``start_from_tail`` (bool):  [Read-Only] If set to true the direction of the solvers is flipped.
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], start_bone: Name = "None", effector_bone: Name = "None", effector_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], precision: float = 0.000000, weight: float = 0.000000, max_iterations: int = 0, start_from_tail: bool = False, base_rotation_limit: float = 0.000000, rotation_limits: Array[RigUnit_CCDIK_RotationLimit] = [], propagate_to_children: bool = False) -> None:
        ...
    @property
    def start_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The first bone in the chain to solve
        """
        ...
    @start_bone.setter
    def start_bone(self, value: Name) -> None:
        ...
    @property
    def effector_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The last bone in the chain to solve - the effector
        """
        ...
    @effector_bone.setter
    def effector_bone(self, value: Name) -> None:
        ...
    @property
    def effector_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the effector in global space
        """
        ...
    @effector_transform.setter
    def effector_transform(self, value: Transform) -> None:
        ...
    @property
    def precision(self) -> float:
        r"""
        (float):  [Read-Only] The precision to use for the fabrik solver
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def max_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
        """
        ...
    @max_iterations.setter
    def max_iterations(self, value: int) -> None:
        ...
    @property
    def start_from_tail(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true the direction of the solvers is flipped.
        """
        ...
    @property
    def base_rotation_limit(self) -> float:
        r"""
        (float):  [Read-Only] The general rotation limit to be applied to bones
        """
        ...
    @property
    def rotation_limits(self) -> Array[RigUnit_CCDIK_RotationLimit]:
        r"""
        (Array[RigUnit_CCDIK_RotationLimit]):  [Read-Only] Defines the limits of rotation per bone.
        """
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_CCDIKPerItem(RigUnit_HighlevelBaseMutable):
    r"""
    The CCID solver can solve N-Bone chains using
    the Cyclic Coordinate Descent Inverse Kinematics algorithm.
    For now this node supports single effector chains only.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_CCDIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_rotation_limit`` (float):  [Read-Only] The general rotation limit to be applied to bones
    - ``effector_transform`` (Transform):  [Read-Write] The transform of the effector in global space
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (RigElementKeyCollection):  [Read-Write] The chain to use
    - ``max_iterations`` (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
    - ``precision`` (float):  [Read-Only] The precision to use for the fabrik solver
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``rotation_limits`` (Array[RigUnit_CCDIK_RotationLimitPerItem]):  [Read-Only] Defines the limits of rotation per bone.
    - ``start_from_tail`` (bool):  [Read-Only] If set to true the direction of the solvers is flipped.
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: RigElementKeyCollection = [[]], effector_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], precision: float = 0.000000, weight: float = 0.000000, max_iterations: int = 0, start_from_tail: bool = False, base_rotation_limit: float = 0.000000, rotation_limits: Array[RigUnit_CCDIK_RotationLimitPerItem] = [], propagate_to_children: bool = False) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] The chain to use
        """
        ...
    @items.setter
    def items(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def effector_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the effector in global space
        """
        ...
    @effector_transform.setter
    def effector_transform(self, value: Transform) -> None:
        ...
    @property
    def precision(self) -> float:
        r"""
        (float):  [Read-Only] The precision to use for the fabrik solver
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def max_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
        """
        ...
    @max_iterations.setter
    def max_iterations(self, value: int) -> None:
        ...
    @property
    def start_from_tail(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true the direction of the solvers is flipped.
        """
        ...
    @property
    def base_rotation_limit(self) -> float:
        r"""
        (float):  [Read-Only] The general rotation limit to be applied to bones
        """
        ...
    @property
    def rotation_limits(self) -> Array[RigUnit_CCDIK_RotationLimitPerItem]:
        r"""
        (Array[RigUnit_CCDIK_RotationLimitPerItem]):  [Read-Only] Defines the limits of rotation per bone.
        """
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_CCDIKItemArray(RigUnit_HighlevelBaseMutable):
    r"""
    The CCID solver can solve N-Bone chains using
    the Cyclic Coordinate Descent Inverse Kinematics algorithm.
    For now this node supports single effector chains only.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_CCDIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_rotation_limit`` (float):  [Read-Only] The general rotation limit to be applied to bones
    - ``effector_transform`` (Transform):  [Read-Write] The transform of the effector in global space
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (Array[RigElementKey]):  [Read-Write] The chain to use
    - ``max_iterations`` (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
    - ``precision`` (float):  [Read-Only] The precision to use for the fabrik solver
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``rotation_limits`` (Array[RigUnit_CCDIK_RotationLimitPerItem]):  [Read-Only] Defines the limits of rotation per bone.
    - ``start_from_tail`` (bool):  [Read-Only] If set to true the direction of the solvers is flipped.
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: Array[RigElementKey] = [], effector_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], precision: float = 0.000000, weight: float = 0.000000, max_iterations: int = 0, start_from_tail: bool = False, base_rotation_limit: float = 0.000000, rotation_limits: Array[RigUnit_CCDIK_RotationLimitPerItem] = [], propagate_to_children: bool = False) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The chain to use
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def effector_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the effector in global space
        """
        ...
    @effector_transform.setter
    def effector_transform(self, value: Transform) -> None:
        ...
    @property
    def precision(self) -> float:
        r"""
        (float):  [Read-Only] The precision to use for the fabrik solver
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def max_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
        """
        ...
    @max_iterations.setter
    def max_iterations(self, value: int) -> None:
        ...
    @property
    def start_from_tail(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true the direction of the solvers is flipped.
        """
        ...
    @property
    def base_rotation_limit(self) -> float:
        r"""
        (float):  [Read-Only] The general rotation limit to be applied to bones
        """
        ...
    @property
    def rotation_limits(self) -> Array[RigUnit_CCDIK_RotationLimitPerItem]:
        r"""
        (Array[RigUnit_CCDIK_RotationLimitPerItem]):  [Read-Only] Defines the limits of rotation per bone.
        """
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_DistributeRotation_Rotation(StructBase):
    r"""
    Rig Unit Distribute Rotation Rotation
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DistributeRotation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ratio`` (float):  [Read-Only] The ratio of where this rotation sits along the chain
    - ``rotation`` (Quat):  [Read-Write] The rotation to be applied
    """
    def __init__(self, rotation: Quat = [0.000000, 0.000000, 0.000000, 1.000000], ratio: float = 0.000000) -> None:
        ...
    @property
    def rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Write] The rotation to be applied
        """
        ...
    @rotation.setter
    def rotation(self, value: Quat) -> None:
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Only] The ratio of where this rotation sits along the chain
        """
        ...

class RigUnit_DistributeRotation(RigUnit_HighlevelBaseMutable):
    r"""
    Distributes rotations provided along a chain.
    Each rotation is expressed by a quaternion and a ratio, where the ratio is between 0.0 and 1.0
    Note: This node adds rotation in local space of each bone!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DistributeRotation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_bone`` (Name):  [Read-Write] The name of the last bone to align
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``rotation_ease_type`` (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
    - ``rotations`` (Array[RigUnit_DistributeRotation_Rotation]):  [Read-Write] The list of rotations to be applied
    - ``start_bone`` (Name):  [Read-Write] The name of the first bone to align
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], start_bone: Name = "None", end_bone: Name = "None", rotations: Array[RigUnit_DistributeRotation_Rotation] = [], rotation_ease_type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def start_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the first bone to align
        """
        ...
    @start_bone.setter
    def start_bone(self, value: Name) -> None:
        ...
    @property
    def end_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the last bone to align
        """
        ...
    @end_bone.setter
    def end_bone(self, value: Name) -> None:
        ...
    @property
    def rotations(self) -> Array[RigUnit_DistributeRotation_Rotation]:
        r"""
        (Array[RigUnit_DistributeRotation_Rotation]):  [Read-Write] The list of rotations to be applied
        """
        ...
    @rotations.setter
    def rotations(self, value: Array[RigUnit_DistributeRotation_Rotation]) -> None:
        ...
    @property
    def rotation_ease_type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_DistributeRotationForCollection(RigUnit_HighlevelBaseMutable):
    r"""
    Distributes rotations provided across a collection of items.
    Each rotation is expressed by a quaternion and a ratio, where the ratio is between 0.0 and 1.0
    Note: This node adds rotation in local space of each item!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DistributeRotation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (RigElementKeyCollection):  [Read-Write] The items to use to distribute the rotation
    - ``rotation_ease_type`` (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
    - ``rotations`` (Array[RigUnit_DistributeRotation_Rotation]):  [Read-Write] The list of rotations to be applied
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: RigElementKeyCollection = [[]], rotations: Array[RigUnit_DistributeRotation_Rotation] = [], rotation_ease_type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, weight: float = 0.000000) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] The items to use to distribute the rotation
        """
        ...
    @items.setter
    def items(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def rotations(self) -> Array[RigUnit_DistributeRotation_Rotation]:
        r"""
        (Array[RigUnit_DistributeRotation_Rotation]):  [Read-Write] The list of rotations to be applied
        """
        ...
    @rotations.setter
    def rotations(self, value: Array[RigUnit_DistributeRotation_Rotation]) -> None:
        ...
    @property
    def rotation_ease_type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_DistributeRotationForItemArray(RigUnit_HighlevelBaseMutable):
    r"""
    Distributes rotations provided across a array of items.
    Each rotation is expressed by a quaternion and a ratio, where the ratio is between 0.0 and 1.0
    Note: This node adds rotation in local space of each item!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_DistributeRotation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items to use to distribute the rotation
    - ``rotation_ease_type`` (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
    - ``rotations`` (Array[RigUnit_DistributeRotation_Rotation]):  [Read-Write] The list of rotations to be applied
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: Array[RigElementKey] = [], rotations: Array[RigUnit_DistributeRotation_Rotation] = [], rotation_ease_type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, weight: float = 0.000000) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The items to use to distribute the rotation
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def rotations(self) -> Array[RigUnit_DistributeRotation_Rotation]:
        r"""
        (Array[RigUnit_DistributeRotation_Rotation]):  [Read-Write] The list of rotations to be applied
        """
        ...
    @rotations.setter
    def rotations(self, value: Array[RigUnit_DistributeRotation_Rotation]) -> None:
        ...
    @property
    def rotation_ease_type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_FABRIK(RigUnit_HighlevelBaseMutable):
    r"""
    The FABRIK solver can solve N-Bone chains using
    the Forward and Backward Reaching Inverse Kinematics algorithm.
    For now this node supports single effector chains only.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_FABRIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``effector_bone`` (Name):  [Read-Write] The last bone in the chain to solve - the effector
    - ``effector_transform`` (Transform):  [Read-Write] The transform of the effector in global space
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``max_iterations`` (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
    - ``precision`` (float):  [Read-Only] The precision to use for the fabrik solver
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``set_effector_transform`` (bool):  [Read-Write] The option to set the effector transform
    - ``start_bone`` (Name):  [Read-Write] The first bone in the chain to solve
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], start_bone: Name = "None", effector_bone: Name = "None", effector_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], precision: float = 0.000000, weight: float = 0.000000, propagate_to_children: bool = False, max_iterations: int = 0, set_effector_transform: bool = False) -> None:
        ...
    @property
    def start_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The first bone in the chain to solve
        """
        ...
    @start_bone.setter
    def start_bone(self, value: Name) -> None:
        ...
    @property
    def effector_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The last bone in the chain to solve - the effector
        """
        ...
    @effector_bone.setter
    def effector_bone(self, value: Name) -> None:
        ...
    @property
    def effector_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the effector in global space
        """
        ...
    @effector_transform.setter
    def effector_transform(self, value: Transform) -> None:
        ...
    @property
    def precision(self) -> float:
        r"""
        (float):  [Read-Only] The precision to use for the fabrik solver
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def max_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
        """
        ...
    @max_iterations.setter
    def max_iterations(self, value: int) -> None:
        ...
    @property
    def set_effector_transform(self) -> bool:
        r"""
        (bool):  [Read-Write] The option to set the effector transform
        """
        ...
    @set_effector_transform.setter
    def set_effector_transform(self, value: bool) -> None:
        ...

class RigUnit_FABRIKPerItem(RigUnit_HighlevelBaseMutable):
    r"""
    The FABRIK solver can solve N-Bone chains using
    the Forward and Backward Reaching Inverse Kinematics algorithm.
    For now this node supports single effector chains only.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_FABRIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``effector_transform`` (Transform):  [Read-Write] The transform of the effector in global space
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (RigElementKeyCollection):  [Read-Write] The chain to use
    - ``max_iterations`` (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
    - ``precision`` (float):  [Read-Only] The precision to use for the fabrik solver
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``set_effector_transform`` (bool):  [Read-Write] The option to set the effector transform
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: RigElementKeyCollection = [[]], effector_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], precision: float = 0.000000, weight: float = 0.000000, propagate_to_children: bool = False, max_iterations: int = 0, set_effector_transform: bool = False) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] The chain to use
        """
        ...
    @items.setter
    def items(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def effector_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the effector in global space
        """
        ...
    @effector_transform.setter
    def effector_transform(self, value: Transform) -> None:
        ...
    @property
    def precision(self) -> float:
        r"""
        (float):  [Read-Only] The precision to use for the fabrik solver
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def max_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
        """
        ...
    @max_iterations.setter
    def max_iterations(self, value: int) -> None:
        ...
    @property
    def set_effector_transform(self) -> bool:
        r"""
        (bool):  [Read-Write] The option to set the effector transform
        """
        ...
    @set_effector_transform.setter
    def set_effector_transform(self, value: bool) -> None:
        ...

class RigUnit_FABRIKItemArray(RigUnit_HighlevelBaseMutable):
    r"""
    The FABRIK solver can solve N-Bone chains using
    the Forward and Backward Reaching Inverse Kinematics algorithm.
    For now this node supports single effector chains only.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_FABRIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``effector_transform`` (Transform):  [Read-Write] The transform of the effector in global space
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (Array[RigElementKey]):  [Read-Write] The chain to use
    - ``max_iterations`` (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
    - ``precision`` (float):  [Read-Only] The precision to use for the fabrik solver
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``set_effector_transform`` (bool):  [Read-Write] The option to set the effector transform
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: Array[RigElementKey] = [], effector_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], precision: float = 0.000000, weight: float = 0.000000, propagate_to_children: bool = False, max_iterations: int = 0, set_effector_transform: bool = False) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The chain to use
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def effector_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the effector in global space
        """
        ...
    @effector_transform.setter
    def effector_transform(self, value: Transform) -> None:
        ...
    @property
    def precision(self) -> float:
        r"""
        (float):  [Read-Only] The precision to use for the fabrik solver
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def max_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
        """
        ...
    @max_iterations.setter
    def max_iterations(self, value: int) -> None:
        ...
    @property
    def set_effector_transform(self) -> bool:
        r"""
        (bool):  [Read-Write] The option to set the effector transform
        """
        ...
    @set_effector_transform.setter
    def set_effector_transform(self, value: bool) -> None:
        ...

class RigUnit_FitChainToCurve_Rotation(StructBase):
    r"""
    Rig Unit Fit Chain to Curve Rotation
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_FitChainToCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ratio`` (float):  [Read-Only] The ratio of where this rotation sits along the chain
    - ``rotation`` (Quat):  [Read-Write] The rotation to be applied
    """
    def __init__(self, rotation: Quat = [0.000000, 0.000000, 0.000000, 1.000000], ratio: float = 0.000000) -> None:
        ...
    @property
    def rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Write] The rotation to be applied
        """
        ...
    @rotation.setter
    def rotation(self, value: Quat) -> None:
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Only] The ratio of where this rotation sits along the chain
        """
        ...

class RigUnit_FitChainToCurve_DebugSettings(StructBase):
    r"""
    Rig Unit Fit Chain to Curve Debug Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_FitChainToCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve_color`` (LinearColor):  [Read-Write] The color to use for debug drawing
    - ``enabled`` (bool):  [Read-Write] If enabled debug information will be drawn
    - ``scale`` (float):  [Read-Write] The size of the debug drawing information
    - ``segments_color`` (LinearColor):  [Read-Write] The color to use for debug drawing
    - ``world_offset`` (Transform):  [Read-Write] The offset at which to draw the debug information in the world
    """
    def __init__(self, enabled: bool = False, scale: float = 0.000000, curve_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], segments_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled debug information will be drawn
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write] The size of the debug drawing information
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def curve_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color to use for debug drawing
        """
        ...
    @curve_color.setter
    def curve_color(self, value: LinearColor) -> None:
        ...
    @property
    def segments_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color to use for debug drawing
        """
        ...
    @segments_color.setter
    def segments_color(self, value: LinearColor) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The offset at which to draw the debug information in the world
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...

class RigUnit_FitChainToCurve(RigUnit_HighlevelBaseMutable):
    r"""
    Fits a given chain to a four point bezier curve.
    Additionally provides rotational control matching the features of the Distribute Rotation node.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_FitChainToCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alignment`` (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
    - ``bezier`` (RigVMFourPointBezier):  [Read-Write] The curve to align to
    - ``debug_settings`` (RigUnit_FitChainToCurve_DebugSettings):  [Read-Write]
    - ``end_bone`` (Name):  [Read-Write] The name of the last bone to align
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``maximum`` (float):  [Read-Only] The maximum U value to use on the curve
    - ``minimum`` (float):  [Read-Only] The minimum U value to use on the curve
    - ``pole_vector_position`` (Vector):  [Read-Write] The the position of the pole vector used for aligning the secondary axis.
      Only has an effect if the secondary axis is set.
    - ``primary_axis`` (Vector):  [Read-Write] The major axis being aligned - along the bone
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``rotation_ease_type`` (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
    - ``rotations`` (Array[RigUnit_FitChainToCurve_Rotation]):  [Read-Write] The list of rotations to be applied along the curve
    - ``sampling_precision`` (int32):  [Read-Only] The number of samples to use on the curve. Clamped at 64.
    - ``secondary_axis`` (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector.
      You can use (0.0, 0.0, 0.0) to disable it.
    - ``start_bone`` (Name):  [Read-Write] The name of the first bone to align
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], start_bone: Name = "None", end_bone: Name = "None", bezier: RigVMFourPointBezier = [], alignment: ControlRigCurveAlignment = ControlRigCurveAlignment.FRONT, minimum: float = 0.000000, maximum: float = 0.000000, sampling_precision: int = 0, primary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis: Vector = [0.000000, 0.000000, 0.000000], pole_vector_position: Vector = [0.000000, 0.000000, 0.000000], rotations: Array[RigUnit_FitChainToCurve_Rotation] = [], rotation_ease_type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, weight: float = 0.000000, propagate_to_children: bool = False, debug_settings: RigUnit_FitChainToCurve_DebugSettings = [False, 1.000000, [1.000000, 1.000000, 0.000000, 1.000000], [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def start_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the first bone to align
        """
        ...
    @start_bone.setter
    def start_bone(self, value: Name) -> None:
        ...
    @property
    def end_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the last bone to align
        """
        ...
    @end_bone.setter
    def end_bone(self, value: Name) -> None:
        ...
    @property
    def bezier(self) -> RigVMFourPointBezier:
        r"""
        (RigVMFourPointBezier):  [Read-Write] The curve to align to
        """
        ...
    @bezier.setter
    def bezier(self, value: RigVMFourPointBezier) -> None:
        ...
    @property
    def alignment(self) -> ControlRigCurveAlignment:
        r"""
        (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
        """
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Only] The minimum U value to use on the curve
        """
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Only] The maximum U value to use on the curve
        """
        ...
    @property
    def sampling_precision(self) -> int:
        r"""
        (int32):  [Read-Only] The number of samples to use on the curve. Clamped at 64.
        """
        ...
    @property
    def primary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The major axis being aligned - along the bone
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector.
        You can use (0.0, 0.0, 0.0) to disable it.
        """
        ...
    @secondary_axis.setter
    def secondary_axis(self, value: Vector) -> None:
        ...
    @property
    def pole_vector_position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The the position of the pole vector used for aligning the secondary axis.
        Only has an effect if the secondary axis is set.
        """
        ...
    @pole_vector_position.setter
    def pole_vector_position(self, value: Vector) -> None:
        ...
    @property
    def rotations(self) -> Array[RigUnit_FitChainToCurve_Rotation]:
        r"""
        (Array[RigUnit_FitChainToCurve_Rotation]):  [Read-Write] The list of rotations to be applied along the curve
        """
        ...
    @rotations.setter
    def rotations(self, value: Array[RigUnit_FitChainToCurve_Rotation]) -> None:
        ...
    @property
    def rotation_ease_type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def debug_settings(self) -> RigUnit_FitChainToCurve_DebugSettings:
        r"""
        (RigUnit_FitChainToCurve_DebugSettings):  [Read-Write]
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_FitChainToCurve_DebugSettings) -> None:
        ...

class RigUnit_FitChainToCurvePerItem(RigUnit_HighlevelBaseMutable):
    r"""
    Fits a given chain to a four point bezier curve.
    Additionally provides rotational control matching the features of the Distribute Rotation node.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_FitChainToCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alignment`` (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
    - ``bezier`` (RigVMFourPointBezier):  [Read-Write] The curve to align to
    - ``debug_settings`` (RigUnit_FitChainToCurve_DebugSettings):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (RigElementKeyCollection):  [Read-Write] The items to align
    - ``maximum`` (float):  [Read-Only] The maximum U value to use on the curve
    - ``minimum`` (float):  [Read-Only] The minimum U value to use on the curve
    - ``pole_vector_position`` (Vector):  [Read-Write] The the position of the pole vector used for aligning the secondary axis.
      Only has an effect if the secondary axis is set.
    - ``primary_axis`` (Vector):  [Read-Write] The major axis being aligned - along the bone
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``rotation_ease_type`` (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
    - ``rotations`` (Array[RigUnit_FitChainToCurve_Rotation]):  [Read-Write] The list of rotations to be applied along the curve
    - ``sampling_precision`` (int32):  [Read-Only] The number of samples to use on the curve. Clamped at 64.
    - ``secondary_axis`` (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector.
      You can use (0.0, 0.0, 0.0) to disable it.
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: RigElementKeyCollection = [[]], bezier: RigVMFourPointBezier = [], alignment: ControlRigCurveAlignment = ControlRigCurveAlignment.FRONT, minimum: float = 0.000000, maximum: float = 0.000000, sampling_precision: int = 0, primary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis: Vector = [0.000000, 0.000000, 0.000000], pole_vector_position: Vector = [0.000000, 0.000000, 0.000000], rotations: Array[RigUnit_FitChainToCurve_Rotation] = [], rotation_ease_type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, weight: float = 0.000000, propagate_to_children: bool = False, debug_settings: RigUnit_FitChainToCurve_DebugSettings = [False, 1.000000, [1.000000, 1.000000, 0.000000, 1.000000], [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] The items to align
        """
        ...
    @items.setter
    def items(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def bezier(self) -> RigVMFourPointBezier:
        r"""
        (RigVMFourPointBezier):  [Read-Write] The curve to align to
        """
        ...
    @bezier.setter
    def bezier(self, value: RigVMFourPointBezier) -> None:
        ...
    @property
    def alignment(self) -> ControlRigCurveAlignment:
        r"""
        (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
        """
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Only] The minimum U value to use on the curve
        """
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Only] The maximum U value to use on the curve
        """
        ...
    @property
    def sampling_precision(self) -> int:
        r"""
        (int32):  [Read-Only] The number of samples to use on the curve. Clamped at 64.
        """
        ...
    @property
    def primary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The major axis being aligned - along the bone
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector.
        You can use (0.0, 0.0, 0.0) to disable it.
        """
        ...
    @secondary_axis.setter
    def secondary_axis(self, value: Vector) -> None:
        ...
    @property
    def pole_vector_position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The the position of the pole vector used for aligning the secondary axis.
        Only has an effect if the secondary axis is set.
        """
        ...
    @pole_vector_position.setter
    def pole_vector_position(self, value: Vector) -> None:
        ...
    @property
    def rotations(self) -> Array[RigUnit_FitChainToCurve_Rotation]:
        r"""
        (Array[RigUnit_FitChainToCurve_Rotation]):  [Read-Write] The list of rotations to be applied along the curve
        """
        ...
    @rotations.setter
    def rotations(self, value: Array[RigUnit_FitChainToCurve_Rotation]) -> None:
        ...
    @property
    def rotation_ease_type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def debug_settings(self) -> RigUnit_FitChainToCurve_DebugSettings:
        r"""
        (RigUnit_FitChainToCurve_DebugSettings):  [Read-Write]
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_FitChainToCurve_DebugSettings) -> None:
        ...

class RigUnit_FitChainToCurveItemArray(RigUnit_HighlevelBaseMutable):
    r"""
    Fits a given chain to a four point bezier curve.
    Additionally provides rotational control matching the features of the Distribute Rotation node.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_FitChainToCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alignment`` (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
    - ``bezier`` (RigVMFourPointBezier):  [Read-Write] The curve to align to
    - ``debug_settings`` (RigUnit_FitChainToCurve_DebugSettings):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items to align
    - ``maximum`` (float):  [Read-Only] The maximum U value to use on the curve
    - ``minimum`` (float):  [Read-Only] The minimum U value to use on the curve
    - ``pole_vector_position`` (Vector):  [Read-Write] The the position of the pole vector used for aligning the secondary axis.
      Only has an effect if the secondary axis is set.
    - ``primary_axis`` (Vector):  [Read-Write] The major axis being aligned - along the bone
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``rotation_ease_type`` (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
    - ``rotations`` (Array[RigUnit_FitChainToCurve_Rotation]):  [Read-Write] The list of rotations to be applied along the curve
    - ``sampling_precision`` (int32):  [Read-Only] The number of samples to use on the curve. Clamped at 64.
    - ``secondary_axis`` (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector.
      You can use (0.0, 0.0, 0.0) to disable it.
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: Array[RigElementKey] = [], bezier: RigVMFourPointBezier = [], alignment: ControlRigCurveAlignment = ControlRigCurveAlignment.FRONT, minimum: float = 0.000000, maximum: float = 0.000000, sampling_precision: int = 0, primary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis: Vector = [0.000000, 0.000000, 0.000000], pole_vector_position: Vector = [0.000000, 0.000000, 0.000000], rotations: Array[RigUnit_FitChainToCurve_Rotation] = [], rotation_ease_type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, weight: float = 0.000000, propagate_to_children: bool = False, debug_settings: RigUnit_FitChainToCurve_DebugSettings = [False, 1.000000, [1.000000, 1.000000, 0.000000, 1.000000], [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The items to align
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def bezier(self) -> RigVMFourPointBezier:
        r"""
        (RigVMFourPointBezier):  [Read-Write] The curve to align to
        """
        ...
    @bezier.setter
    def bezier(self, value: RigVMFourPointBezier) -> None:
        ...
    @property
    def alignment(self) -> ControlRigCurveAlignment:
        r"""
        (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
        """
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Only] The minimum U value to use on the curve
        """
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Only] The maximum U value to use on the curve
        """
        ...
    @property
    def sampling_precision(self) -> int:
        r"""
        (int32):  [Read-Only] The number of samples to use on the curve. Clamped at 64.
        """
        ...
    @property
    def primary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The major axis being aligned - along the bone
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector.
        You can use (0.0, 0.0, 0.0) to disable it.
        """
        ...
    @secondary_axis.setter
    def secondary_axis(self, value: Vector) -> None:
        ...
    @property
    def pole_vector_position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The the position of the pole vector used for aligning the secondary axis.
        Only has an effect if the secondary axis is set.
        """
        ...
    @pole_vector_position.setter
    def pole_vector_position(self, value: Vector) -> None:
        ...
    @property
    def rotations(self) -> Array[RigUnit_FitChainToCurve_Rotation]:
        r"""
        (Array[RigUnit_FitChainToCurve_Rotation]):  [Read-Write] The list of rotations to be applied along the curve
        """
        ...
    @rotations.setter
    def rotations(self, value: Array[RigUnit_FitChainToCurve_Rotation]) -> None:
        ...
    @property
    def rotation_ease_type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def debug_settings(self) -> RigUnit_FitChainToCurve_DebugSettings:
        r"""
        (RigUnit_FitChainToCurve_DebugSettings):  [Read-Write]
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_FitChainToCurve_DebugSettings) -> None:
        ...

class RigUnit_ModifyBoneTransforms_PerBone(StructBase):
    r"""
    Rig Unit Modify Bone Transforms Per Bone
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ModifyBoneTransforms.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the Bone to set the transform for.
    - ``transform`` (Transform):  [Read-Write] The transform value to set for the given Bone.
    """
    def __init__(self, bone: Name = "None", transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the Bone to set the transform for.
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform value to set for the given Bone.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...

class RigUnit_ModifyBoneTransforms(RigUnit_HighlevelBaseMutable):
    r"""
    ModifyBonetransforms is used to perform a change in the hierarchy by setting one or more bones' transforms.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ModifyBoneTransforms.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_to_modify`` (Array[RigUnit_ModifyBoneTransforms_PerBone]):  [Read-Write] The bones to modify.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``mode`` (ControlRigModifyBoneMode):  [Read-Only] Defines if the bone's transform should be set
      in local or global space, additive or override.
    - ``weight`` (float):  [Read-Write] At 1 this sets the transform, between 0 and 1 the transform is blended with previous results.
    - ``weight_maximum`` (float):  [Read-Only] The maximum of the weight - defaults to 1.0
    - ``weight_minimum`` (float):  [Read-Only] The minimum of the weight - defaults to 0.0
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], bone_to_modify: Array[RigUnit_ModifyBoneTransforms_PerBone] = [], weight: float = 0.000000, weight_minimum: float = 0.000000, weight_maximum: float = 0.000000, mode: ControlRigModifyBoneMode = ControlRigModifyBoneMode.OVERRIDE_LOCAL) -> None:
        ...
    @property
    def bone_to_modify(self) -> Array[RigUnit_ModifyBoneTransforms_PerBone]:
        r"""
        (Array[RigUnit_ModifyBoneTransforms_PerBone]):  [Read-Write] The bones to modify.
        """
        ...
    @bone_to_modify.setter
    def bone_to_modify(self, value: Array[RigUnit_ModifyBoneTransforms_PerBone]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] At 1 this sets the transform, between 0 and 1 the transform is blended with previous results.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def weight_minimum(self) -> float:
        r"""
        (float):  [Read-Only] The minimum of the weight - defaults to 0.0
        """
        ...
    @property
    def weight_maximum(self) -> float:
        r"""
        (float):  [Read-Only] The maximum of the weight - defaults to 1.0
        """
        ...
    @property
    def mode(self) -> ControlRigModifyBoneMode:
        r"""
        (ControlRigModifyBoneMode):  [Read-Only] Defines if the bone's transform should be set
        in local or global space, additive or override.
        """
        ...

class RigUnit_ModifyTransforms_PerItem(StructBase):
    r"""
    Rig Unit Modify Transforms Per Item
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ModifyTransforms.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Write] The item to set the transform for.
    - ``transform`` (Transform):  [Read-Write] The transform value to set for the given Bone.
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The item to set the transform for.
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform value to set for the given Bone.
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...

class RigUnit_ModifyTransforms(RigUnit_HighlevelBaseMutable):
    r"""
    Modify Transforms is used to perform a change in the hierarchy by setting one or more bones' transforms
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ModifyTransforms.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item_to_modify`` (Array[RigUnit_ModifyTransforms_PerItem]):  [Read-Write] The items to modify.
    - ``mode`` (ControlRigModifyBoneMode):  [Read-Only] Defines if the bone's transform should be set
      in local or global space, additive or override.
    - ``weight`` (float):  [Read-Write] At 1 this sets the transform, between 0 and 1 the transform is blended with previous results.
    - ``weight_maximum`` (float):  [Read-Only] The maximum of the weight - defaults to 1.0
    - ``weight_minimum`` (float):  [Read-Only] The minimum of the weight - defaults to 0.0
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item_to_modify: Array[RigUnit_ModifyTransforms_PerItem] = [], weight: float = 0.000000, weight_minimum: float = 0.000000, weight_maximum: float = 0.000000, mode: ControlRigModifyBoneMode = ControlRigModifyBoneMode.OVERRIDE_LOCAL) -> None:
        ...
    @property
    def item_to_modify(self) -> Array[RigUnit_ModifyTransforms_PerItem]:
        r"""
        (Array[RigUnit_ModifyTransforms_PerItem]):  [Read-Write] The items to modify.
        """
        ...
    @item_to_modify.setter
    def item_to_modify(self, value: Array[RigUnit_ModifyTransforms_PerItem]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] At 1 this sets the transform, between 0 and 1 the transform is blended with previous results.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def weight_minimum(self) -> float:
        r"""
        (float):  [Read-Only] The minimum of the weight - defaults to 0.0
        """
        ...
    @property
    def weight_maximum(self) -> float:
        r"""
        (float):  [Read-Only] The maximum of the weight - defaults to 1.0
        """
        ...
    @property
    def mode(self) -> ControlRigModifyBoneMode:
        r"""
        (ControlRigModifyBoneMode):  [Read-Only] Defines if the bone's transform should be set
        in local or global space, additive or override.
        """
        ...

class RigUnit_MultiFABRIK_EndEffector(StructBase):
    r"""
    Rig Unit Multi FABRIK End Effector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_MultiFABRIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The last bone in the chain to solve - the effector
    - ``location`` (Vector):  [Read-Write] The transform of the effector in global space
    """
    def __init__(self, bone: Name = "None", location: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The last bone in the chain to solve - the effector
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The transform of the effector in global space
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...

class RigUnit_MultiFABRIK(RigUnit_HighlevelBaseMutable):
    r"""
    The FABRIK solver can solve multi chains within a root using multi effectors
    the Forward and Backward Reaching Inverse Kinematics algorithm.
    For now this node supports single effector chains only.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_MultiFABRIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``effectors`` (Array[RigUnit_MultiFABRIK_EndEffector]):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``max_iterations`` (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
    - ``precision`` (float):  [Read-Only] The precision to use for the fabrik solver
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``root_bone`` (Name):  [Read-Write] The first bone in the chain to solve
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], root_bone: Name = "None", effectors: Array[RigUnit_MultiFABRIK_EndEffector] = [], precision: float = 0.000000, propagate_to_children: bool = False, max_iterations: int = 0) -> None:
        ...
    @property
    def root_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The first bone in the chain to solve
        """
        ...
    @root_bone.setter
    def root_bone(self, value: Name) -> None:
        ...
    @property
    def effectors(self) -> Array[RigUnit_MultiFABRIK_EndEffector]:
        r"""
        (Array[RigUnit_MultiFABRIK_EndEffector]):  [Read-Write]
        """
        ...
    @effectors.setter
    def effectors(self, value: Array[RigUnit_MultiFABRIK_EndEffector]) -> None:
        ...
    @property
    def precision(self) -> float:
        r"""
        (float):  [Read-Only] The precision to use for the fabrik solver
        """
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...
    @property
    def max_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
        """
        ...
    @max_iterations.setter
    def max_iterations(self, value: int) -> None:
        ...

class RigUnit_SlideChain(RigUnit_HighlevelBaseMutable):
    r"""
    Slides an existing chain along itself with control over extrapolation.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SlideChain.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_bone`` (Name):  [Read-Write] The name of the last bone to slide
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``slide_amount`` (float):  [Read-Write] The amount of sliding. This unit is multiple of the chain length.
    - ``start_bone`` (Name):  [Read-Write] The name of the first bone to slide
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], start_bone: Name = "None", end_bone: Name = "None", slide_amount: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def start_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the first bone to slide
        """
        ...
    @start_bone.setter
    def start_bone(self, value: Name) -> None:
        ...
    @property
    def end_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the last bone to slide
        """
        ...
    @end_bone.setter
    def end_bone(self, value: Name) -> None:
        ...
    @property
    def slide_amount(self) -> float:
        r"""
        (float):  [Read-Write] The amount of sliding. This unit is multiple of the chain length.
        """
        ...
    @slide_amount.setter
    def slide_amount(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_SlideChainPerItem(RigUnit_HighlevelBaseMutable):
    r"""
    Slides an existing chain along itself with control over extrapolation.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SlideChain.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (RigElementKeyCollection):  [Read-Write] The items to slide
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``slide_amount`` (float):  [Read-Write] The amount of sliding. This unit is multiple of the chain length.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: RigElementKeyCollection = [[]], slide_amount: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] The items to slide
        """
        ...
    @items.setter
    def items(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def slide_amount(self) -> float:
        r"""
        (float):  [Read-Write] The amount of sliding. This unit is multiple of the chain length.
        """
        ...
    @slide_amount.setter
    def slide_amount(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_SlideChainItemArray(RigUnit_HighlevelBaseMutable):
    r"""
    Slides an existing chain along itself with control over extrapolation.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SlideChain.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items to slide
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``slide_amount`` (float):  [Read-Write] The amount of sliding. This unit is multiple of the chain length.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: Array[RigElementKey] = [], slide_amount: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The items to slide
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def slide_amount(self) -> float:
        r"""
        (float):  [Read-Write] The amount of sliding. This unit is multiple of the chain length.
        """
        ...
    @slide_amount.setter
    def slide_amount(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RegionScaleFactors(StructBase):
    r"""
    Region Scale Factors
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SphericalPoseReader.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``negative_height`` (float):  [Read-Write] Scale the region in the NEGATIVE height direction. Range is 0-1. Default is 1.0.
    - ``negative_width`` (float):  [Read-Write] Scale the region in the NEGATIVE width direction. Range is 0-1. Default is 1.0.
    - ``positive_height`` (float):  [Read-Write] Scale the region in the POSITIVE height direction. Range is 0-1. Default is 1.0.
    - ``positive_width`` (float):  [Read-Write] Scale the region in the POSITIVE width direction. Range is 0-1. Default is 1.0.
    """
    def __init__(self, positive_width: float = 0.000000, negative_width: float = 0.000000, positive_height: float = 0.000000, negative_height: float = 0.000000) -> None:
        ...
    @property
    def positive_width(self) -> float:
        r"""
        (float):  [Read-Write] Scale the region in the POSITIVE width direction. Range is 0-1. Default is 1.0.
        """
        ...
    @positive_width.setter
    def positive_width(self, value: float) -> None:
        ...
    @property
    def negative_width(self) -> float:
        r"""
        (float):  [Read-Write] Scale the region in the NEGATIVE width direction. Range is 0-1. Default is 1.0.
        """
        ...
    @negative_width.setter
    def negative_width(self, value: float) -> None:
        ...
    @property
    def positive_height(self) -> float:
        r"""
        (float):  [Read-Write] Scale the region in the POSITIVE height direction. Range is 0-1. Default is 1.0.
        """
        ...
    @positive_height.setter
    def positive_height(self, value: float) -> None:
        ...
    @property
    def negative_height(self) -> float:
        r"""
        (float):  [Read-Write] Scale the region in the NEGATIVE height direction. Range is 0-1. Default is 1.0.
        """
        ...
    @negative_height.setter
    def negative_height(self, value: float) -> None:
        ...

class SphericalPoseReaderDebugSettings(StructBase):
    r"""
    Spherical Pose Reader Debug Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SphericalPoseReader.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_scale`` (float):  [Read-Write]
    - ``debug_segments`` (int32):  [Read-Write]
    - ``debug_thickness`` (float):  [Read-Write]
    - ``draw2d`` (bool):  [Read-Write]
    - ``draw_debug`` (bool):  [Read-Write]
    - ``draw_local_axes`` (bool):  [Read-Write]
    """
    def __init__(self, draw_debug: bool = False, draw2d: bool = False, draw_local_axes: bool = False, debug_scale: float = 0.000000, debug_segments: int = 0, debug_thickness: float = 0.000000) -> None:
        ...
    @property
    def draw_debug(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_debug.setter
    def draw_debug(self, value: bool) -> None:
        ...
    @property
    def draw2d(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw2d.setter
    def draw2d(self, value: bool) -> None:
        ...
    @property
    def draw_local_axes(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @draw_local_axes.setter
    def draw_local_axes(self, value: bool) -> None:
        ...
    @property
    def debug_scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @debug_scale.setter
    def debug_scale(self, value: float) -> None:
        ...
    @property
    def debug_segments(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @debug_segments.setter
    def debug_segments(self, value: int) -> None:
        ...
    @property
    def debug_thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @debug_thickness.setter
    def debug_thickness(self, value: float) -> None:
        ...

class RigUnit_SphericalPoseReader(RigUnit_HighlevelBaseMutable):
    r"""
    * Outputs a float value between 0-1 based off of the driver item's rotation in a specified region.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SphericalPoseReader.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active_region_scale_factors`` (RegionScaleFactors):  [Read-Write] The directional scaling parameters for the active region (green).
    - ``active_region_size`` (float):  [Read-Write] The size of the active region (green) that outputs the full value (1.0). Range is 0-1. Default is 0.1.
    - ``debug`` (SphericalPoseReaderDebugSettings):  [Read-Write]
    - ``driver_axis`` (Vector):  [Read-Write] The axis of the driver transform that is compared against the falloff regions. Typically the axis that is pointing at the child; usually X by convention. Default is X-axis (1,0,0).
    - ``driver_item`` (RigElementKey):  [Read-Write] The bone that will drive the output parameter when rotated into the active regions of this pose reader.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``falloff_region_scale_factors`` (RegionScaleFactors):  [Read-Write] The directional scaling parameters for the falloff region (yellow).
    - ``falloff_size`` (float):  [Read-Write] The size of the falloff region (yellow) that defines the start of the output range. A value of 1 wraps the entire sphere with falloff. Range is 0-1. Default is 0.2.
    - ``flip_height_scaling`` (bool):  [Read-Write] Flip the positive / negative directions of the height scale factors.
    - ``flip_width_scaling`` (bool):  [Read-Write] Flip the positive / negative directions of the width scale factors.
    - ``optional_parent_item`` (RigElementKey):  [Read-Write] An optional parent to use as a stable frame of reference for the active regions (defaults to DriverItem's parent if unset).
    - ``output_param`` (float):  [Read-Write] The normalized output parameter; ranges from 0 (when outside yellow region) to 1 (in the green region) and smoothly blends from 0-1 in the yellow region.
    - ``rotation_offset`` (Vector):  [Read-Write] Rotate the entire falloff region to align with the desired area of effect.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], output_param: float = 0.000000, driver_item: RigElementKey = [RigElementType.NONE, "None"], driver_axis: Vector = [0.000000, 0.000000, 0.000000], rotation_offset: Vector = [0.000000, 0.000000, 0.000000], active_region_size: float = 0.000000, active_region_scale_factors: RegionScaleFactors = [1.000000, 1.000000, 1.000000, 1.000000], falloff_size: float = 0.000000, falloff_region_scale_factors: RegionScaleFactors = [1.000000, 1.000000, 1.000000, 1.000000], flip_width_scaling: bool = False, flip_height_scaling: bool = False, optional_parent_item: RigElementKey = [RigElementType.NONE, "None"], debug: SphericalPoseReaderDebugSettings = [True, False, False, 25.000000, 20, 0.250000]) -> None:
        ...
    @property
    def output_param(self) -> float:
        r"""
        (float):  [Read-Only] The normalized output parameter; ranges from 0 (when outside yellow region) to 1 (in the green region) and smoothly blends from 0-1 in the yellow region.
        """
        ...
    @property
    def driver_item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The bone that will drive the output parameter when rotated into the active regions of this pose reader.
        """
        ...
    @driver_item.setter
    def driver_item(self, value: RigElementKey) -> None:
        ...
    @property
    def driver_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The axis of the driver transform that is compared against the falloff regions. Typically the axis that is pointing at the child; usually X by convention. Default is X-axis (1,0,0).
        """
        ...
    @driver_axis.setter
    def driver_axis(self, value: Vector) -> None:
        ...
    @property
    def rotation_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Rotate the entire falloff region to align with the desired area of effect.
        """
        ...
    @rotation_offset.setter
    def rotation_offset(self, value: Vector) -> None:
        ...
    @property
    def active_region_size(self) -> float:
        r"""
        (float):  [Read-Write] The size of the active region (green) that outputs the full value (1.0). Range is 0-1. Default is 0.1.
        """
        ...
    @active_region_size.setter
    def active_region_size(self, value: float) -> None:
        ...
    @property
    def active_region_scale_factors(self) -> RegionScaleFactors:
        r"""
        (RegionScaleFactors):  [Read-Write] The directional scaling parameters for the active region (green).
        """
        ...
    @active_region_scale_factors.setter
    def active_region_scale_factors(self, value: RegionScaleFactors) -> None:
        ...
    @property
    def falloff_size(self) -> float:
        r"""
        (float):  [Read-Write] The size of the falloff region (yellow) that defines the start of the output range. A value of 1 wraps the entire sphere with falloff. Range is 0-1. Default is 0.2.
        """
        ...
    @falloff_size.setter
    def falloff_size(self, value: float) -> None:
        ...
    @property
    def falloff_region_scale_factors(self) -> RegionScaleFactors:
        r"""
        (RegionScaleFactors):  [Read-Write] The directional scaling parameters for the falloff region (yellow).
        """
        ...
    @falloff_region_scale_factors.setter
    def falloff_region_scale_factors(self, value: RegionScaleFactors) -> None:
        ...
    @property
    def flip_width_scaling(self) -> bool:
        r"""
        (bool):  [Read-Write] Flip the positive / negative directions of the width scale factors.
        """
        ...
    @flip_width_scaling.setter
    def flip_width_scaling(self, value: bool) -> None:
        ...
    @property
    def flip_height_scaling(self) -> bool:
        r"""
        (bool):  [Read-Write] Flip the positive / negative directions of the height scale factors.
        """
        ...
    @flip_height_scaling.setter
    def flip_height_scaling(self, value: bool) -> None:
        ...
    @property
    def optional_parent_item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] An optional parent to use as a stable frame of reference for the active regions (defaults to DriverItem's parent if unset).
        """
        ...
    @optional_parent_item.setter
    def optional_parent_item(self, value: RigElementKey) -> None:
        ...
    @property
    def debug(self) -> SphericalPoseReaderDebugSettings:
        r"""
        (SphericalPoseReaderDebugSettings):  [Read-Write]
        """
        ...
    @debug.setter
    def debug(self, value: SphericalPoseReaderDebugSettings) -> None:
        ...

class RigUnit_SpringIK_DebugSettings(StructBase):
    r"""
    Rig Unit Spring IK Debug Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SpringIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write] The color to use for debug drawing
    - ``enabled`` (bool):  [Read-Write] If enabled debug information will be drawn
    - ``scale`` (float):  [Read-Write] The size of the debug drawing information
    - ``world_offset`` (Transform):  [Read-Write] The offset at which to draw the debug information in the world
    """
    def __init__(self, enabled: bool = False, scale: float = 0.000000, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled debug information will be drawn
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write] The size of the debug drawing information
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color to use for debug drawing
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The offset at which to draw the debug information in the world
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...

class RigUnit_SpringIK(RigUnit_HighlevelBaseMutable):
    r"""
    The Spring IK solver uses a verlet integrator to perform an IK solve.
    It support custom constraints including distance, length etc.
    Note: This node operates in world space!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SpringIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``damping`` (float):  [Read-Only] The higher the value to more quickly the simulation calms down. Values between 0.0001 and 0.75 are common.
    - ``debug_settings`` (RigUnit_SpringIK_DebugSettings):  [Read-Write] The debug setting for the node
    - ``effector_ratio`` (float):  [Read-Only] Defines the equilibrium of the effector springs.
      This value ranges from 0.0 (zero distance) to 1.0 (distance in initial pose)
    - ``effector_strength`` (float):  [Read-Only] Sets the coefficient of the springs towards the effector. Values between 1 and 2048 are common.
    - ``end_bone`` (Name):  [Read-Write] The name of the second bone to solve
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``flip_pole_plane`` (bool):  [Read-Write] If set to true the pole plane will be flipped
    - ``hierarchy_strength`` (float):  [Read-Only] Sets the coefficient of the springs along the hierarchy. Values between 1 and 2048 are common.
    - ``iterations`` (int32):  [Read-Only] Drives how precise the solver operates. Values between 4 and 24 are common.
      This is only used if the simulation is not live (bLiveSimulation setting).
    - ``limit_local_position`` (bool):  [Read-Write] If set to true bones are placed within the original distance of
      the previous local transform. This can be used to avoid stretch.
    - ``live_simulation`` (bool):  [Read-Write] If set to true simulation will continue for all intermediate bones over time.
    - ``pole_vector`` (Vector):  [Read-Write] The polevector to use for the IK solver
      This can be a location or direction.
    - ``pole_vector_kind`` (ControlRigVectorKind):  [Read-Write] The kind of pole vector this is representing - can be a direction or a location
    - ``pole_vector_space`` (Name):  [Read-Write] The space in which the pole vector is expressed
    - ``primary_axis`` (Vector):  [Read-Write] The major axis being aligned - along the bone
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``root_ratio`` (float):  [Read-Only] Defines the equilibrium of the root springs.
      This value ranges from 0.0 (zero distance) to 1.0 (distance in initial pose)
    - ``root_strength`` (float):  [Read-Only] Sets the coefficient of the springs towards the root. Values between 1 and 2048 are common.
    - ``secondary_axis`` (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector
    - ``start_bone`` (Name):  [Read-Write] The name of the first bone to solve
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], start_bone: Name = "None", end_bone: Name = "None", hierarchy_strength: float = 0.000000, effector_strength: float = 0.000000, effector_ratio: float = 0.000000, root_strength: float = 0.000000, root_ratio: float = 0.000000, damping: float = 0.000000, pole_vector: Vector = [0.000000, 0.000000, 0.000000], flip_pole_plane: bool = False, pole_vector_kind: ControlRigVectorKind = ControlRigVectorKind.DIRECTION, pole_vector_space: Name = "None", primary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis: Vector = [0.000000, 0.000000, 0.000000], live_simulation: bool = False, iterations: int = 0, limit_local_position: bool = False, propagate_to_children: bool = False, debug_settings: RigUnit_SpringIK_DebugSettings = [False, 1.000000, [0.000000, 0.000000, 1.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def start_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the first bone to solve
        """
        ...
    @start_bone.setter
    def start_bone(self, value: Name) -> None:
        ...
    @property
    def end_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the second bone to solve
        """
        ...
    @end_bone.setter
    def end_bone(self, value: Name) -> None:
        ...
    @property
    def hierarchy_strength(self) -> float:
        r"""
        (float):  [Read-Only] Sets the coefficient of the springs along the hierarchy. Values between 1 and 2048 are common.
        """
        ...
    @property
    def effector_strength(self) -> float:
        r"""
        (float):  [Read-Only] Sets the coefficient of the springs towards the effector. Values between 1 and 2048 are common.
        """
        ...
    @property
    def effector_ratio(self) -> float:
        r"""
        (float):  [Read-Only] Defines the equilibrium of the effector springs.
        This value ranges from 0.0 (zero distance) to 1.0 (distance in initial pose)
        """
        ...
    @property
    def root_strength(self) -> float:
        r"""
        (float):  [Read-Only] Sets the coefficient of the springs towards the root. Values between 1 and 2048 are common.
        """
        ...
    @property
    def root_ratio(self) -> float:
        r"""
        (float):  [Read-Only] Defines the equilibrium of the root springs.
        This value ranges from 0.0 (zero distance) to 1.0 (distance in initial pose)
        """
        ...
    @property
    def damping(self) -> float:
        r"""
        (float):  [Read-Only] The higher the value to more quickly the simulation calms down. Values between 0.0001 and 0.75 are common.
        """
        ...
    @property
    def pole_vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The polevector to use for the IK solver
        This can be a location or direction.
        """
        ...
    @pole_vector.setter
    def pole_vector(self, value: Vector) -> None:
        ...
    @property
    def flip_pole_plane(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the pole plane will be flipped
        """
        ...
    @flip_pole_plane.setter
    def flip_pole_plane(self, value: bool) -> None:
        ...
    @property
    def pole_vector_kind(self) -> ControlRigVectorKind:
        r"""
        (ControlRigVectorKind):  [Read-Write] The kind of pole vector this is representing - can be a direction or a location
        """
        ...
    @pole_vector_kind.setter
    def pole_vector_kind(self, value: ControlRigVectorKind) -> None:
        ...
    @property
    def pole_vector_space(self) -> Name:
        r"""
        (Name):  [Read-Write] The space in which the pole vector is expressed
        """
        ...
    @pole_vector_space.setter
    def pole_vector_space(self, value: Name) -> None:
        ...
    @property
    def primary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The major axis being aligned - along the bone
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector
        """
        ...
    @secondary_axis.setter
    def secondary_axis(self, value: Vector) -> None:
        ...
    @property
    def live_simulation(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true simulation will continue for all intermediate bones over time.
        """
        ...
    @live_simulation.setter
    def live_simulation(self, value: bool) -> None:
        ...
    @property
    def iterations(self) -> int:
        r"""
        (int32):  [Read-Only] Drives how precise the solver operates. Values between 4 and 24 are common.
        This is only used if the simulation is not live (bLiveSimulation setting).
        """
        ...
    @property
    def limit_local_position(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true bones are placed within the original distance of
        the previous local transform. This can be used to avoid stretch.
        """
        ...
    @limit_local_position.setter
    def limit_local_position(self, value: bool) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def debug_settings(self) -> RigUnit_SpringIK_DebugSettings:
        r"""
        (RigUnit_SpringIK_DebugSettings):  [Read-Write] The debug setting for the node
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_SpringIK_DebugSettings) -> None:
        ...

class ConstraintTarget(StructBase):
    r"""
    Constraint Target
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``filter`` (TransformFilter):  [Read-Only]
    - ``maintain_offset`` (bool):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, filter: TransformFilter = [[True, True, True], [True, True, True], [True, True, True]]) -> None:
        ...
    @property
    def filter(self) -> TransformFilter:
        r"""
        (TransformFilter):  [Read-Only]
        """
        ...

class RigUnit_TransformConstraint(RigUnit_HighlevelBaseMutable):
    r"""
    Rig Unit Transform Constraint
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_bone`` (Name):  [Read-Write] Transform op option. Use if ETransformSpace is BaseJoint
    - ``base_transform`` (Transform):  [Read-Write] Transform op option. Use if ETransformSpace is BaseTransform
    - ``base_transform_space`` (TransformSpaceMode):  [Read-Write]
    - ``bone`` (Name):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``targets`` (Array[ConstraintTarget]):  [Read-Write]
    - ``use_initial_transforms`` (bool):  [Read-Only] If checked the initial transform will be used for the constraint data
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], bone: Name = "None", base_transform_space: TransformSpaceMode = TransformSpaceMode.LOCAL_SPACE, base_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], base_bone: Name = "None", targets: Array[ConstraintTarget] = [], use_initial_transforms: bool = False) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def base_transform_space(self) -> TransformSpaceMode:
        r"""
        (TransformSpaceMode):  [Read-Write]
        """
        ...
    @base_transform_space.setter
    def base_transform_space(self, value: TransformSpaceMode) -> None:
        ...
    @property
    def base_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Transform op option. Use if ETransformSpace is BaseTransform
        """
        ...
    @base_transform.setter
    def base_transform(self, value: Transform) -> None:
        ...
    @property
    def base_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] Transform op option. Use if ETransformSpace is BaseJoint
        """
        ...
    @base_bone.setter
    def base_bone(self, value: Name) -> None:
        ...
    @property
    def targets(self) -> Array[ConstraintTarget]:
        r"""
        (Array[ConstraintTarget]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[ConstraintTarget]) -> None:
        ...
    @property
    def use_initial_transforms(self) -> bool:
        r"""
        (bool):  [Read-Only] If checked the initial transform will be used for the constraint data
        """
        ...

class RigUnit_TransformConstraintPerItem(RigUnit_HighlevelBaseMutable):
    r"""
    Constrains an item's transform to multiple items' transforms
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_item`` (RigElementKey):  [Read-Write] Transform op option. Use if ETransformSpace is BaseJoint
    - ``base_transform`` (Transform):  [Read-Write] Transform op option. Use if ETransformSpace is BaseTransform
    - ``base_transform_space`` (TransformSpaceMode):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item`` (RigElementKey):  [Read-Write]
    - ``targets`` (Array[ConstraintTarget]):  [Read-Write]
    - ``use_initial_transforms`` (bool):  [Read-Only] If checked the initial transform will be used for the constraint data
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item: RigElementKey = [RigElementType.NONE, "None"], base_transform_space: TransformSpaceMode = TransformSpaceMode.LOCAL_SPACE, base_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], base_item: RigElementKey = [RigElementType.NONE, "None"], targets: Array[ConstraintTarget] = [], use_initial_transforms: bool = False) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @item.setter
    def item(self, value: RigElementKey) -> None:
        ...
    @property
    def base_transform_space(self) -> TransformSpaceMode:
        r"""
        (TransformSpaceMode):  [Read-Write]
        """
        ...
    @base_transform_space.setter
    def base_transform_space(self, value: TransformSpaceMode) -> None:
        ...
    @property
    def base_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Transform op option. Use if ETransformSpace is BaseTransform
        """
        ...
    @base_transform.setter
    def base_transform(self, value: Transform) -> None:
        ...
    @property
    def base_item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] Transform op option. Use if ETransformSpace is BaseJoint
        """
        ...
    @base_item.setter
    def base_item(self, value: RigElementKey) -> None:
        ...
    @property
    def targets(self) -> Array[ConstraintTarget]:
        r"""
        (Array[ConstraintTarget]):  [Read-Write]
        """
        ...
    @targets.setter
    def targets(self, value: Array[ConstraintTarget]) -> None:
        ...
    @property
    def use_initial_transforms(self) -> bool:
        r"""
        (bool):  [Read-Only] If checked the initial transform will be used for the constraint data
        """
        ...

class RigUnit_ParentConstraint_AdvancedSettings(StructBase):
    r"""
    Rig Unit Parent Constraint Advanced Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``interpolation_type`` (ConstraintInterpType):  [Read-Write] Options for interpolating rotations
    - ``rotation_order_for_filter`` (EulerRotationOrder):  [Read-Write] Rotation is converted to euler angles using the specified order such that individual axes can be filtered.
    """
    def __init__(self, interpolation_type: ConstraintInterpType = ConstraintInterpType.AVERAGE, rotation_order_for_filter: EulerRotationOrder = EulerRotationOrder.XYZ) -> None:
        ...
    @property
    def interpolation_type(self) -> ConstraintInterpType:
        r"""
        (ConstraintInterpType):  [Read-Write] Options for interpolating rotations
        """
        ...
    @interpolation_type.setter
    def interpolation_type(self, value: ConstraintInterpType) -> None:
        ...
    @property
    def rotation_order_for_filter(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Write] Rotation is converted to euler angles using the specified order such that individual axes can be filtered.
        """
        ...
    @rotation_order_for_filter.setter
    def rotation_order_for_filter(self, value: EulerRotationOrder) -> None:
        ...

class RigUnit_ParentConstraint(RigUnit_HighlevelBaseMutable):
    r"""
    Constrains an item's transform to multiple items' transforms
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``advanced_settings`` (RigUnit_ParentConstraint_AdvancedSettings):  [Read-Write]
    - ``child`` (RigElementKey):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``filter`` (TransformFilter):  [Read-Write]
    - ``maintain_offset`` (bool):  [Read-Write]
    - ``parents`` (Array[ConstraintParent]):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], maintain_offset: bool = False, filter: TransformFilter = [[True, True, True], [True, True, True], [True, True, True]], parents: Array[ConstraintParent] = [], advanced_settings: RigUnit_ParentConstraint_AdvancedSettings = [ConstraintInterpType.AVERAGE, EulerRotationOrder.XZY], weight: float = 0.000000) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def maintain_offset(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @maintain_offset.setter
    def maintain_offset(self, value: bool) -> None:
        ...
    @property
    def filter(self) -> TransformFilter:
        r"""
        (TransformFilter):  [Read-Write]
        """
        ...
    @filter.setter
    def filter(self, value: TransformFilter) -> None:
        ...
    @property
    def parents(self) -> Array[ConstraintParent]:
        r"""
        (Array[ConstraintParent]):  [Read-Write]
        """
        ...
    @parents.setter
    def parents(self, value: Array[ConstraintParent]) -> None:
        ...
    @property
    def advanced_settings(self) -> RigUnit_ParentConstraint_AdvancedSettings:
        r"""
        (RigUnit_ParentConstraint_AdvancedSettings):  [Read-Write]
        """
        ...
    @advanced_settings.setter
    def advanced_settings(self, value: RigUnit_ParentConstraint_AdvancedSettings) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_ParentConstraintMath_AdvancedSettings(StructBase):
    r"""
    Rig Unit Parent Constraint Math Advanced Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``interpolation_type`` (ConstraintInterpType):  [Read-Write] Options for interpolating rotations
    """
    def __init__(self, interpolation_type: ConstraintInterpType = ConstraintInterpType.AVERAGE) -> None:
        ...
    @property
    def interpolation_type(self) -> ConstraintInterpType:
        r"""
        (ConstraintInterpType):  [Read-Write] Options for interpolating rotations
        """
        ...
    @interpolation_type.setter
    def interpolation_type(self, value: ConstraintInterpType) -> None:
        ...

class RigUnit_ParentConstraintMath(RigUnit_HighlevelBase):
    r"""
    Computes the output transform by constraining the input transform to multiple parents
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``advanced_settings`` (RigUnit_ParentConstraintMath_AdvancedSettings):  [Read-Write]
    - ``input`` (Transform):  [Read-Write] Input is used to calculate offsets from parents' initial transform
    - ``output`` (Transform):  [Read-Write]
    - ``parents`` (Array[ConstraintParent]):  [Read-Write]
    """
    def __init__(self, input: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], parents: Array[ConstraintParent] = [], advanced_settings: RigUnit_ParentConstraintMath_AdvancedSettings = [ConstraintInterpType.AVERAGE], output: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def input(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Input is used to calculate offsets from parents' initial transform
        """
        ...
    @input.setter
    def input(self, value: Transform) -> None:
        ...
    @property
    def parents(self) -> Array[ConstraintParent]:
        r"""
        (Array[ConstraintParent]):  [Read-Write]
        """
        ...
    @parents.setter
    def parents(self, value: Array[ConstraintParent]) -> None:
        ...
    @property
    def advanced_settings(self) -> RigUnit_ParentConstraintMath_AdvancedSettings:
        r"""
        (RigUnit_ParentConstraintMath_AdvancedSettings):  [Read-Write]
        """
        ...
    @advanced_settings.setter
    def advanced_settings(self, value: RigUnit_ParentConstraintMath_AdvancedSettings) -> None:
        ...
    @property
    def output(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_PositionConstraint(RigUnit_HighlevelBaseMutable):
    r"""
    Constrains an item's position to multiple items' positions
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``filter`` (FilterOptionPerAxis):  [Read-Write]
    - ``maintain_offset`` (bool):  [Read-Write]
    - ``parents`` (Array[ConstraintParent]):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], maintain_offset: bool = False, filter: FilterOptionPerAxis = [True, True, True], parents: Array[ConstraintParent] = [], weight: float = 0.000000) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def maintain_offset(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @maintain_offset.setter
    def maintain_offset(self, value: bool) -> None:
        ...
    @property
    def filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @filter.setter
    def filter(self, value: FilterOptionPerAxis) -> None:
        ...
    @property
    def parents(self) -> Array[ConstraintParent]:
        r"""
        (Array[ConstraintParent]):  [Read-Write]
        """
        ...
    @parents.setter
    def parents(self, value: Array[ConstraintParent]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_PositionConstraintLocalSpaceOffset(RigUnit_HighlevelBaseMutable):
    r"""
    Constrains an item's position to multiple items' positions
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``filter`` (FilterOptionPerAxis):  [Read-Write]
    - ``maintain_offset`` (bool):  [Read-Write]
    - ``parents`` (Array[ConstraintParent]):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], maintain_offset: bool = False, filter: FilterOptionPerAxis = [True, True, True], parents: Array[ConstraintParent] = [], weight: float = 0.000000) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def maintain_offset(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @maintain_offset.setter
    def maintain_offset(self, value: bool) -> None:
        ...
    @property
    def filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @filter.setter
    def filter(self, value: FilterOptionPerAxis) -> None:
        ...
    @property
    def parents(self) -> Array[ConstraintParent]:
        r"""
        (Array[ConstraintParent]):  [Read-Write]
        """
        ...
    @parents.setter
    def parents(self, value: Array[ConstraintParent]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_RotationConstraint_AdvancedSettings(StructBase):
    r"""
    Rig Unit Rotation Constraint Advanced Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``interpolation_type`` (ConstraintInterpType):  [Read-Write] Options for interpolating rotations
    - ``rotation_order_for_filter`` (EulerRotationOrder):  [Read-Write] Rotation is converted to euler angles using the specified order such that individual axes can be filtered.
    """
    def __init__(self, interpolation_type: ConstraintInterpType = ConstraintInterpType.AVERAGE, rotation_order_for_filter: EulerRotationOrder = EulerRotationOrder.XYZ) -> None:
        ...
    @property
    def interpolation_type(self) -> ConstraintInterpType:
        r"""
        (ConstraintInterpType):  [Read-Write] Options for interpolating rotations
        """
        ...
    @interpolation_type.setter
    def interpolation_type(self, value: ConstraintInterpType) -> None:
        ...
    @property
    def rotation_order_for_filter(self) -> EulerRotationOrder:
        r"""
        (EulerRotationOrder):  [Read-Write] Rotation is converted to euler angles using the specified order such that individual axes can be filtered.
        """
        ...
    @rotation_order_for_filter.setter
    def rotation_order_for_filter(self, value: EulerRotationOrder) -> None:
        ...

class RigUnit_RotationConstraint(RigUnit_HighlevelBaseMutable):
    r"""
    Constrains an item's rotation to multiple items' rotations
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``advanced_settings`` (RigUnit_RotationConstraint_AdvancedSettings):  [Read-Write]
    - ``child`` (RigElementKey):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``filter`` (FilterOptionPerAxis):  [Read-Write]
    - ``maintain_offset`` (bool):  [Read-Write]
    - ``parents`` (Array[ConstraintParent]):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], maintain_offset: bool = False, filter: FilterOptionPerAxis = [True, True, True], parents: Array[ConstraintParent] = [], advanced_settings: RigUnit_RotationConstraint_AdvancedSettings = [ConstraintInterpType.AVERAGE, EulerRotationOrder.XZY], weight: float = 0.000000) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def maintain_offset(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @maintain_offset.setter
    def maintain_offset(self, value: bool) -> None:
        ...
    @property
    def filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @filter.setter
    def filter(self, value: FilterOptionPerAxis) -> None:
        ...
    @property
    def parents(self) -> Array[ConstraintParent]:
        r"""
        (Array[ConstraintParent]):  [Read-Write]
        """
        ...
    @parents.setter
    def parents(self, value: Array[ConstraintParent]) -> None:
        ...
    @property
    def advanced_settings(self) -> RigUnit_RotationConstraint_AdvancedSettings:
        r"""
        (RigUnit_RotationConstraint_AdvancedSettings):  [Read-Write]
        """
        ...
    @advanced_settings.setter
    def advanced_settings(self, value: RigUnit_RotationConstraint_AdvancedSettings) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_RotationConstraintLocalSpaceOffset(RigUnit_HighlevelBaseMutable):
    r"""
    Constrains an item's rotation to multiple items' rotations
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``advanced_settings`` (RigUnit_RotationConstraint_AdvancedSettings):  [Read-Write]
    - ``child`` (RigElementKey):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``filter`` (FilterOptionPerAxis):  [Read-Write]
    - ``maintain_offset`` (bool):  [Read-Write]
    - ``parents`` (Array[ConstraintParent]):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], maintain_offset: bool = False, filter: FilterOptionPerAxis = [True, True, True], parents: Array[ConstraintParent] = [], advanced_settings: RigUnit_RotationConstraint_AdvancedSettings = [ConstraintInterpType.AVERAGE, EulerRotationOrder.XZY], weight: float = 0.000000) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def maintain_offset(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @maintain_offset.setter
    def maintain_offset(self, value: bool) -> None:
        ...
    @property
    def filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @filter.setter
    def filter(self, value: FilterOptionPerAxis) -> None:
        ...
    @property
    def parents(self) -> Array[ConstraintParent]:
        r"""
        (Array[ConstraintParent]):  [Read-Write]
        """
        ...
    @parents.setter
    def parents(self, value: Array[ConstraintParent]) -> None:
        ...
    @property
    def advanced_settings(self) -> RigUnit_RotationConstraint_AdvancedSettings:
        r"""
        (RigUnit_RotationConstraint_AdvancedSettings):  [Read-Write]
        """
        ...
    @advanced_settings.setter
    def advanced_settings(self, value: RigUnit_RotationConstraint_AdvancedSettings) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_ScaleConstraint(RigUnit_HighlevelBaseMutable):
    r"""
    Constrains an item's scale to multiple items' scales
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``filter`` (FilterOptionPerAxis):  [Read-Write]
    - ``maintain_offset`` (bool):  [Read-Write]
    - ``parents`` (Array[ConstraintParent]):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], maintain_offset: bool = False, filter: FilterOptionPerAxis = [True, True, True], parents: Array[ConstraintParent] = [], weight: float = 0.000000) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def maintain_offset(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @maintain_offset.setter
    def maintain_offset(self, value: bool) -> None:
        ...
    @property
    def filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @filter.setter
    def filter(self, value: FilterOptionPerAxis) -> None:
        ...
    @property
    def parents(self) -> Array[ConstraintParent]:
        r"""
        (Array[ConstraintParent]):  [Read-Write]
        """
        ...
    @parents.setter
    def parents(self, value: Array[ConstraintParent]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_ScaleConstraintLocalSpaceOffset(RigUnit_HighlevelBaseMutable):
    r"""
    Constrains an item's scale to multiple items' scales
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child`` (RigElementKey):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``filter`` (FilterOptionPerAxis):  [Read-Write]
    - ``maintain_offset`` (bool):  [Read-Write]
    - ``parents`` (Array[ConstraintParent]):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], child: RigElementKey = [RigElementType.NONE, "None"], maintain_offset: bool = False, filter: FilterOptionPerAxis = [True, True, True], parents: Array[ConstraintParent] = [], weight: float = 0.000000) -> None:
        ...
    @property
    def child(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @child.setter
    def child(self, value: RigElementKey) -> None:
        ...
    @property
    def maintain_offset(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @maintain_offset.setter
    def maintain_offset(self, value: bool) -> None:
        ...
    @property
    def filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write]
        """
        ...
    @filter.setter
    def filter(self, value: FilterOptionPerAxis) -> None:
        ...
    @property
    def parents(self) -> Array[ConstraintParent]:
        r"""
        (Array[ConstraintParent]):  [Read-Write]
        """
        ...
    @parents.setter
    def parents(self, value: Array[ConstraintParent]) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...

class RigUnit_TwistBones(RigUnit_HighlevelBaseMutable):
    r"""
    Creates a gradient of twist rotation along a chain.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TwistBones.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_bone`` (Name):  [Read-Write] The name of the last bone to twist
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``pole_axis`` (Vector):  [Read-Only] The axis to use for the pole vector for each bone
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``start_bone`` (Name):  [Read-Write] The name of the first bone to twist
    - ``twist_axis`` (Vector):  [Read-Only] The axis to twist the bones around
    - ``twist_ease_type`` (RigVMAnimEasingType):  [Read-Only] The easing to use between two twists.
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], start_bone: Name = "None", end_bone: Name = "None", twist_axis: Vector = [0.000000, 0.000000, 0.000000], pole_axis: Vector = [0.000000, 0.000000, 0.000000], twist_ease_type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def start_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the first bone to twist
        """
        ...
    @start_bone.setter
    def start_bone(self, value: Name) -> None:
        ...
    @property
    def end_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the last bone to twist
        """
        ...
    @end_bone.setter
    def end_bone(self, value: Name) -> None:
        ...
    @property
    def twist_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The axis to twist the bones around
        """
        ...
    @property
    def pole_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The axis to use for the pole vector for each bone
        """
        ...
    @property
    def twist_ease_type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Only] The easing to use between two twists.
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_TwistBonesPerItem(RigUnit_HighlevelBaseMutable):
    r"""
    Creates a gradient of twist rotation along a collection of items.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TwistBones.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (RigElementKeyCollection):  [Read-Write] The items to twist
    - ``pole_axis`` (Vector):  [Read-Only] The axis to use for the pole vector for each bone
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``twist_axis`` (Vector):  [Read-Only] The axis to twist the bones around
    - ``twist_ease_type`` (RigVMAnimEasingType):  [Read-Only] The easing to use between two twists.
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: RigElementKeyCollection = [[]], twist_axis: Vector = [0.000000, 0.000000, 0.000000], pole_axis: Vector = [0.000000, 0.000000, 0.000000], twist_ease_type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, weight: float = 0.000000, propagate_to_children: bool = False) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] The items to twist
        """
        ...
    @items.setter
    def items(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def twist_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The axis to twist the bones around
        """
        ...
    @property
    def pole_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The axis to use for the pole vector for each bone
        """
        ...
    @property
    def twist_ease_type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Only] The easing to use between two twists.
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_TwoBoneIKSimple_DebugSettings(StructBase):
    r"""
    Rig Unit Two Bone IKSimple Debug Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TwoBoneIKSimple.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write] If enabled debug information will be drawn
    - ``scale`` (float):  [Read-Write] The size of the debug drawing information
    - ``world_offset`` (Transform):  [Read-Write] The offset at which to draw the debug information in the world
    """
    def __init__(self, enabled: bool = False, scale: float = 0.000000, world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled debug information will be drawn
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write] The size of the debug drawing information
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The offset at which to draw the debug information in the world
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...

class RigUnit_TwoBoneIKSimple(RigUnit_HighlevelBaseMutable):
    r"""
    Solves the two bone IK given two bones.
    Note: This node operates in world space!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TwoBoneIKSimple.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_a`` (Name):  [Read-Write] The name of first bone
    - ``bone_a_length`` (float):  [Read-Write] The length of the first bone.
      If set to 0.0 it will be determined by the hierarchy
    - ``bone_b`` (Name):  [Read-Write] The name of second bone
    - ``bone_b_length`` (float):  [Read-Write] The length of the second  bone.
      If set to 0.0 it will be determined by the hierarchy
    - ``debug_settings`` (RigUnit_TwoBoneIKSimple_DebugSettings):  [Read-Write] The settings for debug drawing
    - ``effector`` (Transform):  [Read-Write] The transform of the effector
    - ``effector_bone`` (Name):  [Read-Write] The name of the effector bone (if exists)
    - ``enable_stretch`` (bool):  [Read-Write] If set to true the stretch feature of the solver will be enabled
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``pole_vector`` (Vector):  [Read-Write] The polevector to use for the IK solver
      This can be a location or direction.
    - ``pole_vector_kind`` (ControlRigVectorKind):  [Read-Write] The kind of pole vector this is representing - can be a direction or a location
    - ``pole_vector_space`` (Name):  [Read-Write] The space in which the pole vector is expressed
    - ``primary_axis`` (Vector):  [Read-Write] The major axis being aligned - along the bone
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``secondary_axis`` (Vector):  [Read-Write] The minor axis being aligned - towards the polevector
    - ``secondary_axis_weight`` (float):  [Read-Write] Determines how much the secondary axis roll is being applied
    - ``stretch_maximum_ratio`` (float):  [Read-Write] The maximum allowed stretch ratio
    - ``stretch_start_ratio`` (float):  [Read-Write] The ratio where the stretch starts
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], bone_a: Name = "None", bone_b: Name = "None", effector_bone: Name = "None", effector: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], primary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis_weight: float = 0.000000, pole_vector: Vector = [0.000000, 0.000000, 0.000000], pole_vector_kind: ControlRigVectorKind = ControlRigVectorKind.DIRECTION, pole_vector_space: Name = "None", enable_stretch: bool = False, stretch_start_ratio: float = 0.000000, stretch_maximum_ratio: float = 0.000000, weight: float = 0.000000, bone_a_length: float = 0.000000, bone_b_length: float = 0.000000, propagate_to_children: bool = False, debug_settings: RigUnit_TwoBoneIKSimple_DebugSettings = [False, 10.000000, [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def bone_a(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of first bone
        """
        ...
    @bone_a.setter
    def bone_a(self, value: Name) -> None:
        ...
    @property
    def bone_b(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of second bone
        """
        ...
    @bone_b.setter
    def bone_b(self, value: Name) -> None:
        ...
    @property
    def effector_bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the effector bone (if exists)
        """
        ...
    @effector_bone.setter
    def effector_bone(self, value: Name) -> None:
        ...
    @property
    def effector(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the effector
        """
        ...
    @effector.setter
    def effector(self, value: Transform) -> None:
        ...
    @property
    def primary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The major axis being aligned - along the bone
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The minor axis being aligned - towards the polevector
        """
        ...
    @secondary_axis.setter
    def secondary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis_weight(self) -> float:
        r"""
        (float):  [Read-Write] Determines how much the secondary axis roll is being applied
        """
        ...
    @secondary_axis_weight.setter
    def secondary_axis_weight(self, value: float) -> None:
        ...
    @property
    def pole_vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The polevector to use for the IK solver
        This can be a location or direction.
        """
        ...
    @pole_vector.setter
    def pole_vector(self, value: Vector) -> None:
        ...
    @property
    def pole_vector_kind(self) -> ControlRigVectorKind:
        r"""
        (ControlRigVectorKind):  [Read-Write] The kind of pole vector this is representing - can be a direction or a location
        """
        ...
    @pole_vector_kind.setter
    def pole_vector_kind(self, value: ControlRigVectorKind) -> None:
        ...
    @property
    def pole_vector_space(self) -> Name:
        r"""
        (Name):  [Read-Write] The space in which the pole vector is expressed
        """
        ...
    @pole_vector_space.setter
    def pole_vector_space(self, value: Name) -> None:
        ...
    @property
    def enable_stretch(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the stretch feature of the solver will be enabled
        """
        ...
    @enable_stretch.setter
    def enable_stretch(self, value: bool) -> None:
        ...
    @property
    def stretch_start_ratio(self) -> float:
        r"""
        (float):  [Read-Write] The ratio where the stretch starts
        """
        ...
    @stretch_start_ratio.setter
    def stretch_start_ratio(self, value: float) -> None:
        ...
    @property
    def stretch_maximum_ratio(self) -> float:
        r"""
        (float):  [Read-Write] The maximum allowed stretch ratio
        """
        ...
    @stretch_maximum_ratio.setter
    def stretch_maximum_ratio(self, value: float) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def bone_a_length(self) -> float:
        r"""
        (float):  [Read-Write] The length of the first bone.
        If set to 0.0 it will be determined by the hierarchy
        """
        ...
    @bone_a_length.setter
    def bone_a_length(self, value: float) -> None:
        ...
    @property
    def bone_b_length(self) -> float:
        r"""
        (float):  [Read-Write] The length of the second  bone.
        If set to 0.0 it will be determined by the hierarchy
        """
        ...
    @bone_b_length.setter
    def bone_b_length(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def debug_settings(self) -> RigUnit_TwoBoneIKSimple_DebugSettings:
        r"""
        (RigUnit_TwoBoneIKSimple_DebugSettings):  [Read-Write] The settings for debug drawing
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_TwoBoneIKSimple_DebugSettings) -> None:
        ...

class RigUnit_TwoBoneIKSimplePerItem(RigUnit_HighlevelBaseMutable):
    r"""
    Solves the two bone IK given two bones.
    Note: This node operates in world space!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TwoBoneIKSimple.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_settings`` (RigUnit_TwoBoneIKSimple_DebugSettings):  [Read-Write] The settings for debug drawing
    - ``effector`` (Transform):  [Read-Write] The transform of the effector
    - ``effector_item`` (RigElementKey):  [Read-Write] The name of the effector item (if exists)
    - ``enable_stretch`` (bool):  [Read-Write] If set to true the stretch feature of the solver will be enabled
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``item_a`` (RigElementKey):  [Read-Write] The name of first item
    - ``item_a_length`` (float):  [Read-Write] The length of the first item.
      If set to 0.0 it will be determined by the hierarchy
    - ``item_b`` (RigElementKey):  [Read-Write] The name of second item
    - ``item_b_length`` (float):  [Read-Write] The length of the second item.
      If set to 0.0 it will be determined by the hierarchy
    - ``pole_vector`` (Vector):  [Read-Write] The polevector to use for the IK solver
      This can be a location or direction.
    - ``pole_vector_kind`` (ControlRigVectorKind):  [Read-Write] The kind of pole vector this is representing - can be a direction or a location
    - ``pole_vector_space`` (RigElementKey):  [Read-Write] The space in which the pole vector is expressed
    - ``primary_axis`` (Vector):  [Read-Write] The major axis being aligned - along the item
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``secondary_axis`` (Vector):  [Read-Write] The minor axis being aligned - towards the polevector
    - ``secondary_axis_weight`` (float):  [Read-Write] Determines how much the secondary axis roll is being applied
    - ``stretch_maximum_ratio`` (float):  [Read-Write] The maximum allowed stretch ratio
    - ``stretch_start_ratio`` (float):  [Read-Write] The ratio where the stretch starts
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], item_a: RigElementKey = [RigElementType.NONE, "None"], item_b: RigElementKey = [RigElementType.NONE, "None"], effector_item: RigElementKey = [RigElementType.NONE, "None"], effector: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], primary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis_weight: float = 0.000000, pole_vector: Vector = [0.000000, 0.000000, 0.000000], pole_vector_kind: ControlRigVectorKind = ControlRigVectorKind.DIRECTION, pole_vector_space: RigElementKey = [RigElementType.NONE, "None"], enable_stretch: bool = False, stretch_start_ratio: float = 0.000000, stretch_maximum_ratio: float = 0.000000, weight: float = 0.000000, item_a_length: float = 0.000000, item_b_length: float = 0.000000, propagate_to_children: bool = False, debug_settings: RigUnit_TwoBoneIKSimple_DebugSettings = [False, 10.000000, [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def item_a(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The name of first item
        """
        ...
    @item_a.setter
    def item_a(self, value: RigElementKey) -> None:
        ...
    @property
    def item_b(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The name of second item
        """
        ...
    @item_b.setter
    def item_b(self, value: RigElementKey) -> None:
        ...
    @property
    def effector_item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The name of the effector item (if exists)
        """
        ...
    @effector_item.setter
    def effector_item(self, value: RigElementKey) -> None:
        ...
    @property
    def effector(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the effector
        """
        ...
    @effector.setter
    def effector(self, value: Transform) -> None:
        ...
    @property
    def primary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The major axis being aligned - along the item
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The minor axis being aligned - towards the polevector
        """
        ...
    @secondary_axis.setter
    def secondary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis_weight(self) -> float:
        r"""
        (float):  [Read-Write] Determines how much the secondary axis roll is being applied
        """
        ...
    @secondary_axis_weight.setter
    def secondary_axis_weight(self, value: float) -> None:
        ...
    @property
    def pole_vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The polevector to use for the IK solver
        This can be a location or direction.
        """
        ...
    @pole_vector.setter
    def pole_vector(self, value: Vector) -> None:
        ...
    @property
    def pole_vector_kind(self) -> ControlRigVectorKind:
        r"""
        (ControlRigVectorKind):  [Read-Write] The kind of pole vector this is representing - can be a direction or a location
        """
        ...
    @pole_vector_kind.setter
    def pole_vector_kind(self, value: ControlRigVectorKind) -> None:
        ...
    @property
    def pole_vector_space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The space in which the pole vector is expressed
        """
        ...
    @pole_vector_space.setter
    def pole_vector_space(self, value: RigElementKey) -> None:
        ...
    @property
    def enable_stretch(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the stretch feature of the solver will be enabled
        """
        ...
    @enable_stretch.setter
    def enable_stretch(self, value: bool) -> None:
        ...
    @property
    def stretch_start_ratio(self) -> float:
        r"""
        (float):  [Read-Write] The ratio where the stretch starts
        """
        ...
    @stretch_start_ratio.setter
    def stretch_start_ratio(self, value: float) -> None:
        ...
    @property
    def stretch_maximum_ratio(self) -> float:
        r"""
        (float):  [Read-Write] The maximum allowed stretch ratio
        """
        ...
    @stretch_maximum_ratio.setter
    def stretch_maximum_ratio(self, value: float) -> None:
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the IK should be applied.
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def item_a_length(self) -> float:
        r"""
        (float):  [Read-Write] The length of the first item.
        If set to 0.0 it will be determined by the hierarchy
        """
        ...
    @item_a_length.setter
    def item_a_length(self, value: float) -> None:
        ...
    @property
    def item_b_length(self) -> float:
        r"""
        (float):  [Read-Write] The length of the second item.
        If set to 0.0 it will be determined by the hierarchy
        """
        ...
    @item_b_length.setter
    def item_b_length(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def debug_settings(self) -> RigUnit_TwoBoneIKSimple_DebugSettings:
        r"""
        (RigUnit_TwoBoneIKSimple_DebugSettings):  [Read-Write] The settings for debug drawing
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_TwoBoneIKSimple_DebugSettings) -> None:
        ...

class RigUnit_TwoBoneIKSimpleVectors(RigUnit_HighlevelBase):
    r"""
    Solves the two bone IK given positions
    Note: This node operates in world space!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TwoBoneIKSimple.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_a_length`` (float):  [Read-Write] The length of the first bone.
      If set to 0.0 it will be determined by the hierarchy
    - ``bone_b_length`` (float):  [Read-Write] The length of the second  bone.
      If set to 0.0 it will be determined by the hierarchy
    - ``effector`` (Vector):  [Read-Write] The position of the effector
    - ``elbow`` (Vector):  [Read-Write] The resulting elbow position
    - ``enable_stretch`` (bool):  [Read-Write] If set to true the stretch feature of the solver will be enabled
    - ``pole_vector`` (Vector):  [Read-Write] The position of the pole of the triangle
    - ``root`` (Vector):  [Read-Write] The position of the root of the triangle
    - ``stretch_maximum_ratio`` (float):  [Read-Write] The maximum allowed stretch ratio
    - ``stretch_start_ratio`` (float):  [Read-Write] The ratio where the stretch starts
    """
    def __init__(self, root: Vector = [0.000000, 0.000000, 0.000000], pole_vector: Vector = [0.000000, 0.000000, 0.000000], effector: Vector = [0.000000, 0.000000, 0.000000], enable_stretch: bool = False, stretch_start_ratio: float = 0.000000, stretch_maximum_ratio: float = 0.000000, bone_a_length: float = 0.000000, bone_b_length: float = 0.000000, elbow: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def root(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The position of the root of the triangle
        """
        ...
    @root.setter
    def root(self, value: Vector) -> None:
        ...
    @property
    def pole_vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The position of the pole of the triangle
        """
        ...
    @pole_vector.setter
    def pole_vector(self, value: Vector) -> None:
        ...
    @property
    def effector(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The position of the effector
        """
        ...
    @effector.setter
    def effector(self, value: Vector) -> None:
        ...
    @property
    def enable_stretch(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the stretch feature of the solver will be enabled
        """
        ...
    @enable_stretch.setter
    def enable_stretch(self, value: bool) -> None:
        ...
    @property
    def stretch_start_ratio(self) -> float:
        r"""
        (float):  [Read-Write] The ratio where the stretch starts
        """
        ...
    @stretch_start_ratio.setter
    def stretch_start_ratio(self, value: float) -> None:
        ...
    @property
    def stretch_maximum_ratio(self) -> float:
        r"""
        (float):  [Read-Write] The maximum allowed stretch ratio
        """
        ...
    @stretch_maximum_ratio.setter
    def stretch_maximum_ratio(self, value: float) -> None:
        ...
    @property
    def bone_a_length(self) -> float:
        r"""
        (float):  [Read-Write] The length of the first bone.
        If set to 0.0 it will be determined by the hierarchy
        """
        ...
    @bone_a_length.setter
    def bone_a_length(self, value: float) -> None:
        ...
    @property
    def bone_b_length(self) -> float:
        r"""
        (float):  [Read-Write] The length of the second  bone.
        If set to 0.0 it will be determined by the hierarchy
        """
        ...
    @bone_b_length.setter
    def bone_b_length(self, value: float) -> None:
        ...
    @property
    def elbow(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The resulting elbow position
        """
        ...

class RigUnit_TwoBoneIKSimpleTransforms(RigUnit_HighlevelBase):
    r"""
    Solves the two bone IK given transforms
    Note: This node operates in world space!
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_TwoBoneIKSimple.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_a_length`` (float):  [Read-Write] The length of the first bone.
      If set to 0.0 it will be determined by the hierarchy
    - ``bone_b_length`` (float):  [Read-Write] The length of the second  bone.
      If set to 0.0 it will be determined by the hierarchy
    - ``effector`` (Transform):  [Read-Write] The transform of the effector
    - ``elbow`` (Transform):  [Read-Write] The resulting elbow transform
    - ``enable_stretch`` (bool):  [Read-Write] If set to true the stretch feature of the solver will be enabled
    - ``pole_vector`` (Vector):  [Read-Write] The position of the pole of the triangle
    - ``primary_axis`` (Vector):  [Read-Write] The major axis being aligned - along the bone
    - ``root`` (Transform):  [Read-Write] The transform of the root of the triangle
    - ``secondary_axis`` (Vector):  [Read-Write] The minor axis being aligned - towards the polevector
    - ``secondary_axis_weight`` (float):  [Read-Write] Determines how much the secondary axis roll is being applied
    - ``stretch_maximum_ratio`` (float):  [Read-Write] The maximum allowed stretch ratio
    - ``stretch_start_ratio`` (float):  [Read-Write] The ratio where the stretch starts
    """
    def __init__(self, root: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], pole_vector: Vector = [0.000000, 0.000000, 0.000000], effector: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], primary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis_weight: float = 0.000000, enable_stretch: bool = False, stretch_start_ratio: float = 0.000000, stretch_maximum_ratio: float = 0.000000, bone_a_length: float = 0.000000, bone_b_length: float = 0.000000, elbow: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def root(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the root of the triangle
        """
        ...
    @root.setter
    def root(self, value: Transform) -> None:
        ...
    @property
    def pole_vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The position of the pole of the triangle
        """
        ...
    @pole_vector.setter
    def pole_vector(self, value: Vector) -> None:
        ...
    @property
    def effector(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The transform of the effector
        """
        ...
    @effector.setter
    def effector(self, value: Transform) -> None:
        ...
    @property
    def primary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The major axis being aligned - along the bone
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The minor axis being aligned - towards the polevector
        """
        ...
    @secondary_axis.setter
    def secondary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis_weight(self) -> float:
        r"""
        (float):  [Read-Write] Determines how much the secondary axis roll is being applied
        """
        ...
    @secondary_axis_weight.setter
    def secondary_axis_weight(self, value: float) -> None:
        ...
    @property
    def enable_stretch(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true the stretch feature of the solver will be enabled
        """
        ...
    @enable_stretch.setter
    def enable_stretch(self, value: bool) -> None:
        ...
    @property
    def stretch_start_ratio(self) -> float:
        r"""
        (float):  [Read-Write] The ratio where the stretch starts
        """
        ...
    @stretch_start_ratio.setter
    def stretch_start_ratio(self, value: float) -> None:
        ...
    @property
    def stretch_maximum_ratio(self) -> float:
        r"""
        (float):  [Read-Write] The maximum allowed stretch ratio
        """
        ...
    @stretch_maximum_ratio.setter
    def stretch_maximum_ratio(self, value: float) -> None:
        ...
    @property
    def bone_a_length(self) -> float:
        r"""
        (float):  [Read-Write] The length of the first bone.
        If set to 0.0 it will be determined by the hierarchy
        """
        ...
    @bone_a_length.setter
    def bone_a_length(self, value: float) -> None:
        ...
    @property
    def bone_b_length(self) -> float:
        r"""
        (float):  [Read-Write] The length of the second  bone.
        If set to 0.0 it will be determined by the hierarchy
        """
        ...
    @bone_b_length.setter
    def bone_b_length(self, value: float) -> None:
        ...
    @property
    def elbow(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The resulting elbow transform
        """
        ...
    @elbow.setter
    def elbow(self, value: Transform) -> None:
        ...

class RigUnit_GetCandidates(RigUnit):
    r"""
    Returns the connection candidates for one connector
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ConnectionCandidates.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``candidates`` (Array[RigElementKey]):  [Read-Write] The items being interacted on
    - ``connector`` (RigElementKey):  [Read-Write] The connector being resolved
    """
    def __init__(self, connector: RigElementKey = [RigElementType.NONE, "None"], candidates: Array[RigElementKey] = []) -> None:
        ...
    @property
    def connector(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only] The connector being resolved
        """
        ...
    @property
    def candidates(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only] The items being interacted on
        """
        ...

class RigUnit_DiscardMatches(RigUnitMutable):
    r"""
    Discards matches during a connector event
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ConnectionCandidates.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``excluded`` (Array[RigElementKey]):  [Read-Write] The items being interacted on
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``message`` (str):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], excluded: Array[RigElementKey] = [], message: str = "") -> None:
        ...
    @property
    def excluded(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The items being interacted on
        """
        ...
    @excluded.setter
    def excluded(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def message(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @message.setter
    def message(self, value: str) -> None:
        ...

class RigUnit_SetDefaultMatch(RigUnitMutable):
    r"""
    Set default match during a connector event
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ConnectionCandidates.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default`` (RigElementKey):  [Read-Write] The items being interacted on
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], default: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def default(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write] The items being interacted on
        """
        ...
    @default.setter
    def default(self, value: RigElementKey) -> None:
        ...

class RigUnit_ConnectorExecution(RigUnit):
    r"""
    Event for filtering connection candidates
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_ConnectorExecution.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] The execution result
    """
    def __init__(self, execute_context: ControlRigExecuteContext = []) -> None:
        ...
    @property
    def execute_context(self) -> ControlRigExecuteContext:
        r"""
        (ControlRigExecuteContext):  [Read-Only] The execution result
        """
        ...

class RigUnit_PointSimulation_DebugSettings(StructBase):
    r"""
    Rig Unit Point Simulation Debug Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_PointSimulation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_scale`` (float):  [Read-Write] The size of the debug drawing information
    - ``color`` (LinearColor):  [Read-Write] The color to use for debug drawing
    - ``draw_points_as_spheres`` (bool):  [Read-Write] If set to true points will be drawn as spheres with their sizes reflected
    - ``enabled`` (bool):  [Read-Write] If enabled debug information will be drawn
    - ``scale`` (float):  [Read-Write] The size of the debug drawing information
    - ``world_offset`` (Transform):  [Read-Write] The offset at which to draw the debug information in the world
    """
    def __init__(self, enabled: bool = False, scale: float = 0.000000, collision_scale: float = 0.000000, draw_points_as_spheres: bool = False, color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], world_offset: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled debug information will be drawn
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write] The size of the debug drawing information
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def collision_scale(self) -> float:
        r"""
        (float):  [Read-Write] The size of the debug drawing information
        """
        ...
    @collision_scale.setter
    def collision_scale(self, value: float) -> None:
        ...
    @property
    def draw_points_as_spheres(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true points will be drawn as spheres with their sizes reflected
        """
        ...
    @draw_points_as_spheres.setter
    def draw_points_as_spheres(self, value: bool) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color to use for debug drawing
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def world_offset(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The offset at which to draw the debug information in the world
        """
        ...
    @world_offset.setter
    def world_offset(self, value: Transform) -> None:
        ...

class RigUnit_PointSimulation_BoneTarget(StructBase):
    r"""
    Rig Unit Point Simulation Bone Target
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_PointSimulation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The name of the bone to map
    - ``primary_aim_point`` (int32):  [Read-Only] The index of the point to use for aiming the primary axis.
      Use -1 to indicate that you don't want to aim the bone.
    - ``secondary_aim_point`` (int32):  [Read-Only] The index of the point to use for aiming the secondary axis.
      Use -1 to indicate that you don't want to aim the bone.
    - ``translation_point`` (int32):  [Read-Only] The index of the point to use for translation
    """
    def __init__(self, bone: Name = "None", translation_point: int = 0, primary_aim_point: int = 0, secondary_aim_point: int = 0) -> None:
        ...
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the bone to map
        """
        ...
    @bone.setter
    def bone(self, value: Name) -> None:
        ...
    @property
    def translation_point(self) -> int:
        r"""
        (int32):  [Read-Only] The index of the point to use for translation
        """
        ...
    @property
    def primary_aim_point(self) -> int:
        r"""
        (int32):  [Read-Only] The index of the point to use for aiming the primary axis.
        Use -1 to indicate that you don't want to aim the bone.
        """
        ...
    @property
    def secondary_aim_point(self) -> int:
        r"""
        (int32):  [Read-Only] The index of the point to use for aiming the secondary axis.
        Use -1 to indicate that you don't want to aim the bone.
        """
        ...

class RigUnit_PointSimulation(RigVMFunction_SimBaseMutable):
    r"""
    Performs point based simulation
    Note: Disabled for now.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_PointSimulation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bezier`` (RigVMFourPointBezier):  [Read-Write] If the simulation has at least four points they will be stored in here.
    - ``bone_targets`` (Array[RigUnit_PointSimulation_BoneTarget]):  [Read-Only] The bones to map to the simulated points.
    - ``collision_volumes`` (Array[CRSimSoftCollision]):  [Read-Write] The collision volumes to define
    - ``debug_settings`` (RigUnit_PointSimulation_DebugSettings):  [Read-Write] Debug draw settings for this simulation
    - ``execute_context`` (RigVMExecuteContext):  [Read-Write] * This property is used to chain multiple mutable nodes together
    - ``forces`` (Array[CRSimPointForce]):  [Read-Write] The forces to apply
    - ``integrator_type`` (RigVMSimPointIntegrateType):  [Read-Only] The type of integrator to use
    - ``limit_local_position`` (bool):  [Read-Write] If set to true bones are placed within the original distance of
      the previous local transform. This can be used to avoid stretch.
    - ``links`` (Array[CRSimLinearSpring]):  [Read-Write] The links to connect the points with
    - ``points`` (Array[RigVMSimPoint]):  [Read-Write] The points to simulate
    - ``primary_aim_axis`` (Vector):  [Read-Write] The primary axis to use for the aim
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``secondary_aim_axis`` (Vector):  [Read-Write] The secondary axis to use for the aim
    - ``simulated_steps_per_second`` (float):  [Read-Only] The frame rate of the simulation
    - ``verlet_blend`` (float):  [Read-Write] The amount of blending to apply per second ( only for verlet integrations )
    """
    def __init__(self, execute_context: RigVMExecuteContext = [], points: Array[RigVMSimPoint] = [], links: Array[CRSimLinearSpring] = [], forces: Array[CRSimPointForce] = [], collision_volumes: Array[CRSimSoftCollision] = [], simulated_steps_per_second: float = 0.000000, integrator_type: RigVMSimPointIntegrateType = RigVMSimPointIntegrateType.VERLET, verlet_blend: float = 0.000000, bone_targets: Array[RigUnit_PointSimulation_BoneTarget] = [], limit_local_position: bool = False, propagate_to_children: bool = False, primary_aim_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_aim_axis: Vector = [0.000000, 0.000000, 0.000000], debug_settings: RigUnit_PointSimulation_DebugSettings = [False, 1.000000, 50.000000, False, [0.000000, 0.000000, 1.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]], bezier: RigVMFourPointBezier = []) -> None:
        ...
    @property
    def points(self) -> Array[RigVMSimPoint]:
        r"""
        (Array[RigVMSimPoint]):  [Read-Write] The points to simulate
        """
        ...
    @points.setter
    def points(self, value: Array[RigVMSimPoint]) -> None:
        ...
    @property
    def links(self) -> Array[CRSimLinearSpring]:
        r"""
        (Array[CRSimLinearSpring]):  [Read-Write] The links to connect the points with
        """
        ...
    @links.setter
    def links(self, value: Array[CRSimLinearSpring]) -> None:
        ...
    @property
    def forces(self) -> Array[CRSimPointForce]:
        r"""
        (Array[CRSimPointForce]):  [Read-Write] The forces to apply
        """
        ...
    @forces.setter
    def forces(self, value: Array[CRSimPointForce]) -> None:
        ...
    @property
    def collision_volumes(self) -> Array[CRSimSoftCollision]:
        r"""
        (Array[CRSimSoftCollision]):  [Read-Write] The collision volumes to define
        """
        ...
    @collision_volumes.setter
    def collision_volumes(self, value: Array[CRSimSoftCollision]) -> None:
        ...
    @property
    def simulated_steps_per_second(self) -> float:
        r"""
        (float):  [Read-Only] The frame rate of the simulation
        """
        ...
    @property
    def integrator_type(self) -> RigVMSimPointIntegrateType:
        r"""
        (RigVMSimPointIntegrateType):  [Read-Only] The type of integrator to use
        """
        ...
    @property
    def verlet_blend(self) -> float:
        r"""
        (float):  [Read-Write] The amount of blending to apply per second ( only for verlet integrations )
        """
        ...
    @verlet_blend.setter
    def verlet_blend(self, value: float) -> None:
        ...
    @property
    def bone_targets(self) -> Array[RigUnit_PointSimulation_BoneTarget]:
        r"""
        (Array[RigUnit_PointSimulation_BoneTarget]):  [Read-Only] The bones to map to the simulated points.
        """
        ...
    @property
    def limit_local_position(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true bones are placed within the original distance of
        the previous local transform. This can be used to avoid stretch.
        """
        ...
    @limit_local_position.setter
    def limit_local_position(self, value: bool) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def primary_aim_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The primary axis to use for the aim
        """
        ...
    @primary_aim_axis.setter
    def primary_aim_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_aim_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The secondary axis to use for the aim
        """
        ...
    @secondary_aim_axis.setter
    def secondary_aim_axis(self, value: Vector) -> None:
        ...
    @property
    def debug_settings(self) -> RigUnit_PointSimulation_DebugSettings:
        r"""
        (RigUnit_PointSimulation_DebugSettings):  [Read-Write] Debug draw settings for this simulation
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_PointSimulation_DebugSettings) -> None:
        ...
    @property
    def bezier(self) -> RigVMFourPointBezier:
        r"""
        (RigVMFourPointBezier):  [Read-Only] If the simulation has at least four points they will be stored in here.
        """
        ...

class RigUnit_SpringInterp(RigVMFunction_SimBase):
    r"""
    Uses a simple spring model to interpolate a float from Current to Target.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SpringInterp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``critical_damping`` (float):  [Read-Write]
    - ``current`` (float):  [Read-Write]
    - ``mass`` (float):  [Read-Write]
    - ``result`` (float):  [Read-Write]
    - ``stiffness`` (float):  [Read-Write]
    - ``target`` (float):  [Read-Write]
    """
    def __init__(self, current: float = 0.000000, target: float = 0.000000, stiffness: float = 0.000000, critical_damping: float = 0.000000, mass: float = 0.000000, result: float = 0.000000) -> None:
        ...
    @property
    def current(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @current.setter
    def current(self, value: float) -> None:
        ...
    @property
    def target(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: float) -> None:
        ...
    @property
    def stiffness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @stiffness.setter
    def stiffness(self, value: float) -> None:
        ...
    @property
    def critical_damping(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @critical_damping.setter
    def critical_damping(self, value: float) -> None:
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @mass.setter
    def mass(self, value: float) -> None:
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_SpringInterpVector(RigVMFunction_SimBase):
    r"""
    Uses a simple spring model to interpolate a vector from Current to Target.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SpringInterp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``critical_damping`` (float):  [Read-Write]
    - ``current`` (Vector):  [Read-Write]
    - ``mass`` (float):  [Read-Write]
    - ``result`` (Vector):  [Read-Write]
    - ``stiffness`` (float):  [Read-Write]
    - ``target`` (Vector):  [Read-Write]
    """
    def __init__(self, current: Vector = [0.000000, 0.000000, 0.000000], target: Vector = [0.000000, 0.000000, 0.000000], stiffness: float = 0.000000, critical_damping: float = 0.000000, mass: float = 0.000000, result: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def current(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @current.setter
    def current(self, value: Vector) -> None:
        ...
    @property
    def target(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @target.setter
    def target(self, value: Vector) -> None:
        ...
    @property
    def stiffness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @stiffness.setter
    def stiffness(self, value: float) -> None:
        ...
    @property
    def critical_damping(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @critical_damping.setter
    def critical_damping(self, value: float) -> None:
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @mass.setter
    def mass(self, value: float) -> None:
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_SpringInterpV2(RigVMFunction_SimBase):
    r"""
    Uses a simple spring model to interpolate a float from Current to Target.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SpringInterp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``critical_damping`` (float):  [Read-Write] The amount of damping in the spring.
      Set it smaller than 1 to make the spring oscillate before stabilizing on the target.
      Set it equal to 1 to reach the target without overshooting.
      Set it higher than one to make the spring take longer to reach the target.
    - ``current`` (float):  [Read-Write] Current position of the spring.
    - ``force`` (float):  [Read-Write] Extra force to apply (since the mass is 1, this is also the acceleration).
    - ``initialize_from_target`` (bool):  [Read-Only] If true, then the initial value will be taken from the target value, and not from the current value.
    - ``result`` (float):  [Read-Write] New position of the spring after delta time.
    - ``strength`` (float):  [Read-Write] The spring strength determines how hard it will pull towards the target. The value is the frequency
      at which it will oscillate when there is no damping.
    - ``target`` (float):  [Read-Write] Rest/target position of the spring.
    - ``target_velocity_amount`` (float):  [Read-Write] The amount that the velocity should be passed through to the spring. A value of 1 will result in more
      responsive output, but if the input is noisy or has step changes, these discontinuities will be passed
      through to the output much more than if a smaller value such as 0 is used.
    - ``use_current_input`` (bool):  [Read-Only] If true, then the Current input will be used to initialize the state, and is required to be a variable that
      holds the current state. If false then the Target value will be used to initialize the state and the Current
      input will be ignored/unnecessary as a state will be maintained by this node.
    - ``velocity`` (float):  [Read-Write] Velocity
    """
    def __init__(self, target: float = 0.000000, strength: float = 0.000000, critical_damping: float = 0.000000, force: float = 0.000000, use_current_input: bool = False, current: float = 0.000000, target_velocity_amount: float = 0.000000, initialize_from_target: bool = False, result: float = 0.000000, velocity: float = 0.000000) -> None:
        ...
    @property
    def target(self) -> float:
        r"""
        (float):  [Read-Write] Rest/target position of the spring.
        """
        ...
    @target.setter
    def target(self, value: float) -> None:
        ...
    @property
    def strength(self) -> float:
        r"""
        (float):  [Read-Write] The spring strength determines how hard it will pull towards the target. The value is the frequency
        at which it will oscillate when there is no damping.
        """
        ...
    @strength.setter
    def strength(self, value: float) -> None:
        ...
    @property
    def critical_damping(self) -> float:
        r"""
        (float):  [Read-Write] The amount of damping in the spring.
        Set it smaller than 1 to make the spring oscillate before stabilizing on the target.
        Set it equal to 1 to reach the target without overshooting.
        Set it higher than one to make the spring take longer to reach the target.
        """
        ...
    @critical_damping.setter
    def critical_damping(self, value: float) -> None:
        ...
    @property
    def force(self) -> float:
        r"""
        (float):  [Read-Write] Extra force to apply (since the mass is 1, this is also the acceleration).
        """
        ...
    @force.setter
    def force(self, value: float) -> None:
        ...
    @property
    def use_current_input(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, then the Current input will be used to initialize the state, and is required to be a variable that
        holds the current state. If false then the Target value will be used to initialize the state and the Current
        input will be ignored/unnecessary as a state will be maintained by this node.
        """
        ...
    @property
    def current(self) -> float:
        r"""
        (float):  [Read-Write] Current position of the spring.
        """
        ...
    @current.setter
    def current(self, value: float) -> None:
        ...
    @property
    def target_velocity_amount(self) -> float:
        r"""
        (float):  [Read-Write] The amount that the velocity should be passed through to the spring. A value of 1 will result in more
        responsive output, but if the input is noisy or has step changes, these discontinuities will be passed
        through to the output much more than if a smaller value such as 0 is used.
        """
        ...
    @target_velocity_amount.setter
    def target_velocity_amount(self, value: float) -> None:
        ...
    @property
    def initialize_from_target(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, then the initial value will be taken from the target value, and not from the current value.
        """
        ...
    @property
    def result(self) -> float:
        r"""
        (float):  [Read-Only] New position of the spring after delta time.
        """
        ...
    @property
    def velocity(self) -> float:
        r"""
        (float):  [Read-Only] Velocity
        """
        ...

class RigUnit_SpringInterpVectorV2(RigVMFunction_SimBase):
    r"""
    Uses a simple spring model to interpolate a vector from Current to Target.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SpringInterp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``critical_damping`` (float):  [Read-Write] The amount of damping in the spring.
      Set it smaller than 1 to make the spring oscillate before stabilizing on the target.
      Set it equal to 1 to reach the target without overshooting.
      Set it higher than one to make the spring take longer to reach the target.
    - ``current`` (Vector):  [Read-Write] Current position of the spring.
    - ``force`` (Vector):  [Read-Write] Extra force to apply (since the mass is 1, this is also the acceleration).
    - ``initialize_from_target`` (bool):  [Read-Only] If true, then the initial value will be taken from the target value, and not from the current value.
    - ``result`` (Vector):  [Read-Write] New position of the spring after delta time.
    - ``strength`` (float):  [Read-Write] The spring strength determines how hard it will pull towards the target. The value is the frequency
      at which it will oscillate when there is no damping.
    - ``target`` (Vector):  [Read-Write] Rest/target position of the spring.
    - ``target_velocity_amount`` (float):  [Read-Write] The amount that the velocity should be passed through to the spring. A value of 1 will result in more
      responsive output, but if the input is noisy or has step changes, these discontinuities will be passed
      through to the output much more than if a smaller value such as 0 is used.
    - ``use_current_input`` (bool):  [Read-Only] If true, then the Current input will be used to initialize the state, and is required to be a variable that
      holds the current state. If false then the Target value will be used to initialize the state and the Current
      input will be ignored/unnecessary as a state will be maintained by this node.
    - ``velocity`` (Vector):  [Read-Write] Velocity
    """
    def __init__(self, target: Vector = [0.000000, 0.000000, 0.000000], strength: float = 0.000000, critical_damping: float = 0.000000, force: Vector = [0.000000, 0.000000, 0.000000], use_current_input: bool = False, current: Vector = [0.000000, 0.000000, 0.000000], target_velocity_amount: float = 0.000000, initialize_from_target: bool = False, result: Vector = [0.000000, 0.000000, 0.000000], velocity: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def target(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Rest/target position of the spring.
        """
        ...
    @target.setter
    def target(self, value: Vector) -> None:
        ...
    @property
    def strength(self) -> float:
        r"""
        (float):  [Read-Write] The spring strength determines how hard it will pull towards the target. The value is the frequency
        at which it will oscillate when there is no damping.
        """
        ...
    @strength.setter
    def strength(self, value: float) -> None:
        ...
    @property
    def critical_damping(self) -> float:
        r"""
        (float):  [Read-Write] The amount of damping in the spring.
        Set it smaller than 1 to make the spring oscillate before stabilizing on the target.
        Set it equal to 1 to reach the target without overshooting.
        Set it higher than one to make the spring take longer to reach the target.
        """
        ...
    @critical_damping.setter
    def critical_damping(self, value: float) -> None:
        ...
    @property
    def force(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Extra force to apply (since the mass is 1, this is also the acceleration).
        """
        ...
    @force.setter
    def force(self, value: Vector) -> None:
        ...
    @property
    def use_current_input(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, then the Current input will be used to initialize the state, and is required to be a variable that
        holds the current state. If false then the Target value will be used to initialize the state and the Current
        input will be ignored/unnecessary as a state will be maintained by this node.
        """
        ...
    @property
    def current(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Current position of the spring.
        """
        ...
    @current.setter
    def current(self, value: Vector) -> None:
        ...
    @property
    def target_velocity_amount(self) -> float:
        r"""
        (float):  [Read-Write] The amount that the velocity should be passed through to the spring. A value of 1 will result in more
        responsive output, but if the input is noisy or has step changes, these discontinuities will be passed
        through to the output much more than if a smaller value such as 0 is used.
        """
        ...
    @target_velocity_amount.setter
    def target_velocity_amount(self, value: float) -> None:
        ...
    @property
    def initialize_from_target(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, then the initial value will be taken from the target value, and not from the current value.
        """
        ...
    @property
    def result(self) -> Vector:
        r"""
        (Vector):  [Read-Only] New position of the spring after delta time.
        """
        ...
    @property
    def velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Velocity
        """
        ...

class RigUnit_SpringInterpQuaternionV2(RigVMFunction_SimBase):
    r"""
    Uses a simple spring model to interpolate a quaternion from Current to Target.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnit_SpringInterp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_velocity`` (Vector):  [Read-Write] Angular velocity
    - ``critical_damping`` (float):  [Read-Write] The amount of damping in the spring.
      Set it smaller than 1 to make the spring oscillate before stabilizing on the target.
      Set it equal to 1 to reach the target without overshooting.
      Set it higher than one to make the spring take longer to reach the target.
    - ``current`` (Quat):  [Read-Write] Current position of the spring.
    - ``initialize_from_target`` (bool):  [Read-Only] If true, then the initial value will be taken from the target value, and not from the current value.
    - ``result`` (Quat):  [Read-Write] New position of the spring after delta time.
    - ``strength`` (float):  [Read-Write] The spring strength determines how hard it will pull towards the target. The value is the frequency
      at which it will oscillate when there is no damping.
    - ``target`` (Quat):  [Read-Write] Rest/target position of the spring.
    - ``target_velocity_amount`` (float):  [Read-Write] The amount that the velocity should be passed through to the spring. A value of 1 will result in more
      responsive output, but if the input is noisy or has step changes, these discontinuities will be passed
      through to the output much more than if a smaller value such as 0 is used.
    - ``torque`` (Vector):  [Read-Write] Extra torque to apply (since the moment of inertia is 1, this is also the angular acceleration).
    - ``use_current_input`` (bool):  [Read-Only] If true, then the Current input will be used to initialize the state, and is required to be a variable that
      holds the current state. If false then the Target value will be used to initialize the state and the Current
      input will be ignored/unnecessary as a state will be maintained by this node.
    """
    def __init__(self, target: Quat = [0.000000, 0.000000, 0.000000, 1.000000], strength: float = 0.000000, critical_damping: float = 0.000000, torque: Vector = [0.000000, 0.000000, 0.000000], use_current_input: bool = False, current: Quat = [0.000000, 0.000000, 0.000000, 1.000000], target_velocity_amount: float = 0.000000, initialize_from_target: bool = False, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000], angular_velocity: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def target(self) -> Quat:
        r"""
        (Quat):  [Read-Write] Rest/target position of the spring.
        """
        ...
    @target.setter
    def target(self, value: Quat) -> None:
        ...
    @property
    def strength(self) -> float:
        r"""
        (float):  [Read-Write] The spring strength determines how hard it will pull towards the target. The value is the frequency
        at which it will oscillate when there is no damping.
        """
        ...
    @strength.setter
    def strength(self, value: float) -> None:
        ...
    @property
    def critical_damping(self) -> float:
        r"""
        (float):  [Read-Write] The amount of damping in the spring.
        Set it smaller than 1 to make the spring oscillate before stabilizing on the target.
        Set it equal to 1 to reach the target without overshooting.
        Set it higher than one to make the spring take longer to reach the target.
        """
        ...
    @critical_damping.setter
    def critical_damping(self, value: float) -> None:
        ...
    @property
    def torque(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Extra torque to apply (since the moment of inertia is 1, this is also the angular acceleration).
        """
        ...
    @torque.setter
    def torque(self, value: Vector) -> None:
        ...
    @property
    def use_current_input(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, then the Current input will be used to initialize the state, and is required to be a variable that
        holds the current state. If false then the Target value will be used to initialize the state and the Current
        input will be ignored/unnecessary as a state will be maintained by this node.
        """
        ...
    @property
    def current(self) -> Quat:
        r"""
        (Quat):  [Read-Write] Current position of the spring.
        """
        ...
    @current.setter
    def current(self, value: Quat) -> None:
        ...
    @property
    def target_velocity_amount(self) -> float:
        r"""
        (float):  [Read-Write] The amount that the velocity should be passed through to the spring. A value of 1 will result in more
        responsive output, but if the input is noisy or has step changes, these discontinuities will be passed
        through to the output much more than if a smaller value such as 0 is used.
        """
        ...
    @target_velocity_amount.setter
    def target_velocity_amount(self, value: float) -> None:
        ...
    @property
    def initialize_from_target(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, then the initial value will be taken from the target value, and not from the current value.
        """
        ...
    @property
    def result(self) -> Quat:
        r"""
        (Quat):  [Read-Only] New position of the spring after delta time.
        """
        ...
    @property
    def angular_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Angular velocity
        """
        ...

class RigUnit_SpringInterpQuaternion(RigUnit_SpringInterpQuaternionV2):
    r"""
    deprecated: 'RigUnit_SpringInterpQuaternion' was renamed to 'RigUnit_SpringInterpQuaternionV2'.
    """
    def __init__(self, target: Quat = [0.000000, 0.000000, 0.000000, 1.000000], strength: float = 0.000000, critical_damping: float = 0.000000, torque: Vector = [0.000000, 0.000000, 0.000000], use_current_input: bool = False, current: Quat = [0.000000, 0.000000, 0.000000, 1.000000], target_velocity_amount: float = 0.000000, initialize_from_target: bool = False, result: Quat = [0.000000, 0.000000, 0.000000, 1.000000], angular_velocity: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...

class FBIKConstraintOption(StructBase):
    r"""
    FBIKConstraint Option
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: FullBodyIK
    - **File**: FBIKConstraintOption.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_limit`` (FBIKBoneLimit):  [Read-Write] Angular delta limit of this joints local transform. [-Limit, Limit]
    - ``angular_stiffness`` (Vector):  [Read-Write] Scale of [0, 1] and applied to angular motion strength, xyz is applied to twist, swing1, swing2
    - ``enabled`` (bool):  [Read-Write]
    - ``item`` (RigElementKey):  [Read-Only] Bone Name
    - ``linear_stiffness`` (Vector):  [Read-Write] Scale of [0, 1] and applied to linear motion strength - linear stiffness works on their local frame
    - ``offset_rotation`` (Rotator):  [Read-Write] this is offset rotation applied when constructing the local frame
    - ``pole_vector`` (Vector):  [Read-Write] Pole Vector in their local space
    - ``pole_vector_option`` (PoleVectorOption):  [Read-Write]
    - ``use_angular_limit`` (bool):  [Read-Write]
    - ``use_pole_vector`` (bool):  [Read-Write]
    - ``use_stiffness`` (bool):  [Read-Write]
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only] Bone Name
        """
        ...

class MotionProcessInput(StructBase):
    r"""
    Motion Process Input
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: FullBodyIK
    - **File**: FBIKConstraintOption.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``force_effector_rotation_target`` (bool):  [Read-Write]
    - ``only_apply_when_reached_to_target`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class FBIKDebugOption(StructBase):
    r"""
    FBIKDebug Option
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: FullBodyIK
    - **File**: FBIKDebugOption.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_angular_motion_strength`` (bool):  [Read-Write] use red channel
    - ``color_linear_motion_strength`` (bool):  [Read-Write] use green channel
    - ``draw_debug_axes`` (bool):  [Read-Write]
    - ``draw_debug_constraints`` (bool):  [Read-Write]
    - ``draw_debug_effector`` (bool):  [Read-Write]
    - ``draw_debug_hierarchy`` (bool):  [Read-Write]
    - ``draw_size`` (float):  [Read-Write]
    - ``draw_world_offset`` (Transform):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class SolverInput(StructBase):
    r"""
    Solver Input
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: FullBodyIK
    - **File**: FBIKShared.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_motion_strength`` (float):  [Read-Write] * This value is applied to the target information for effectors, which influence back to
      * Joint's motion that are affected by the end effector
      * The reason min/max is used when we apply the depth through the chain that are affected
    - ``damping`` (float):  [Read-Write] The precision to use for the fabrik solver
    - ``default_target_clamp`` (float):  [Read-Write] This is a scale value (range from 0-0.7) that is used to stablize the target vector. If less, it's more stable, but it can reduce speed of converge.
    - ``linear_motion_strength`` (float):  [Read-Write] * This value is applied to the target information for effectors, which influence back to
      * Joint's motion that are affected by the end effector
      * The reason min/max is used when we apply the depth through the chain that are affected
    - ``max_iterations`` (int32):  [Read-Write] The maximum number of iterations. Values between 4 and 16 are common.
    - ``min_angular_motion_strength`` (float):  [Read-Write]
    - ``min_linear_motion_strength`` (float):  [Read-Write]
    - ``precision`` (float):  [Read-Write] The precision to use for the solver
    - ``use_jacobian_transpose`` (bool):  [Read-Write] Cheaper solution than default Jacobian Pseudo Inverse Damped Least Square
    """
    def __init__(self) -> None:
        ...

class FBIKEndEffector(StructBase):
    r"""
    FBIKEnd Effector
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: FullBodyIK
    - **File**: RigUnit_FullbodyIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item`` (RigElementKey):  [Read-Only] The last item in the chain to solve - the effector
    """
    def __init__(self, item: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def item(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only] The last item in the chain to solve - the effector
        """
        ...

class RigUnit_FullbodyIK(RigUnit_HighlevelBaseMutable):
    r"""
    Based on Jacobian solver at core, this can solve multi chains within a root using multi effectors
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: FullBodyIK
    - **File**: RigUnit_FullbodyIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``constraints`` (Array[FBIKConstraintOption]):  [Read-Write]
    - ``debug_option`` (FBIKDebugOption):  [Read-Write]
    - ``effectors`` (Array[FBIKEndEffector]):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``motion_property`` (MotionProcessInput):  [Read-Only]
    - ``propagate_to_children`` (bool):  [Read-Write] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``root`` (RigElementKey):  [Read-Only] The first bone in the chain to solve
    - ``solver_property`` (SolverInput):  [Read-Only]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], root: RigElementKey = [RigElementType.NONE, "None"], effectors: Array[FBIKEndEffector] = [], constraints: Array[FBIKConstraintOption] = [], solver_property: SolverInput = [], motion_property: MotionProcessInput = [], propagate_to_children: bool = False, debug_option: FBIKDebugOption = []) -> None:
        ...
    @property
    def root(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only] The first bone in the chain to solve
        """
        ...
    @property
    def effectors(self) -> Array[FBIKEndEffector]:
        r"""
        (Array[FBIKEndEffector]):  [Read-Write]
        """
        ...
    @effectors.setter
    def effectors(self, value: Array[FBIKEndEffector]) -> None:
        ...
    @property
    def end_effectors(self) -> Array[FBIKEndEffector]:
        r"""
        deprecated: 'end_effectors' was renamed to 'effectors'.
        """
        ...
    @end_effectors.setter
    def end_effectors(self, value: Array[FBIKEndEffector]) -> None:
        ...
    @property
    def constraints(self) -> Array[FBIKConstraintOption]:
        r"""
        (Array[FBIKConstraintOption]):  [Read-Write]
        """
        ...
    @constraints.setter
    def constraints(self, value: Array[FBIKConstraintOption]) -> None:
        ...
    @property
    def solver_property(self) -> SolverInput:
        r"""
        (SolverInput):  [Read-Only]
        """
        ...
    @property
    def motion_property(self) -> MotionProcessInput:
        r"""
        (MotionProcessInput):  [Read-Only]
        """
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @propagate_to_children.setter
    def propagate_to_children(self, value: bool) -> None:
        ...
    @property
    def debug_option(self) -> FBIKDebugOption:
        r"""
        (FBIKDebugOption):  [Read-Write]
        """
        ...
    @debug_option.setter
    def debug_option(self, value: FBIKDebugOption) -> None:
        ...

class PBIKBoneSetting(StructBase):
    r"""
    PBIKBone Setting
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: PBIK
    - **File**: PBIK_Shared.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The Bone that these settings will be applied to.
    - ``max_x`` (float):  [Read-Write] Range is 0 to 180 (Default is 0). Degrees of rotation in the positive X direction to allow when joint is in "Limited" mode.
    - ``max_y`` (float):  [Read-Write] Range is 0 to 180 (Default is 0). Degrees of rotation in the positive Y direction to allow when joint is in "Limited" mode.
    - ``max_z`` (float):  [Read-Write] Range is 0 to 180 (Default is 0). Degrees of rotation in the positive Z direction to allow when joint is in "Limited" mode.
    - ``min_x`` (float):  [Read-Write] Range is -180 to 0 (Default is 0). Degrees of rotation in the negative X direction to allow when joint is in "Limited" mode.
    - ``min_y`` (float):  [Read-Write] Range is -180 to 0 (Default is 0). Degrees of rotation in the negative Y direction to allow when joint is in "Limited" mode.
    - ``min_z`` (float):  [Read-Write] Range is -180 to 0 (Default is 0). Degrees of rotation in the negative Z direction to allow when joint is in "Limited" mode.
    - ``position_stiffness`` (float):  [Read-Write] Range is 0 to 1 (Default is 0). At higher values, the bone will resist translational motion (forcing other bones to compensate).
    - ``preferred_angles`` (Vector):  [Read-Write] The local Euler angles (in degrees) used to rotate this bone when the chain it belongs to is squashed.
      This happens by moving the effector at the tip of the chain towards the root of the chain.
      This can be used to coerce knees and elbows to bend in the anatomically "correct" direction without resorting to limits (which may require more iterations to converge).
    - ``rotation_stiffness`` (float):  [Read-Write] Range is 0 to 1 (Default is 0). At higher values, the bone will resist rotating (forcing other bones to compensate).
    - ``use_preferred_angles`` (bool):  [Read-Write] When true, this bone will "prefer" to rotate in the direction specified by the Preferred Angles when the chain it belongs to is compressed.
      Preferred Angles should be the first method used to fix bones that bend in the wrong direction (rather than limits).
      The resulting angles can be visualized on their own by temporarily setting the Solver iterations to 0 and moving the effectors.
    - ``x`` (PBIKLimitType):  [Read-Write] Limit the rotation angle of the bone on the X axis.
      Free: can rotate freely in this axis.
      Limited: rotation is clamped between the min/max angles relative to the Skeletal Mesh reference pose.
      Locked: no rotation is allowed in this axis (will remain at reference pose angle).
    - ``y`` (PBIKLimitType):  [Read-Write] Limit the rotation angle of the bone on the Y axis.
      Free: can rotate freely in this axis.
      Limited: rotation is clamped between the min/max angles relative to the Skeletal Mesh reference pose.
      Locked: no rotation is allowed in this axis (will remain at input pose angle).
    - ``z`` (PBIKLimitType):  [Read-Write] Limit the rotation angle of the bone on the Z axis.
      Free: can rotate freely in this axis.
      Limited: rotation is clamped between the min/max angles relative to the Skeletal Mesh reference pose.
      Locked: no rotation is allowed in this axis (will remain at input pose angle).
    """
    def __init__(self) -> None:
        ...

class RootPrePullSettings(StructBase):
    r"""
    Root Pre Pull Settings
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: PBIK
    - **File**: PBIKSolver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``position_alpha`` (float):  [Read-Write] Range 0-1, default is 1. Apply a large scale position offset to the entire body prior to constraint solving.
    - ``position_alpha_x`` (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to position offset in the X axis in component space.
    - ``position_alpha_y`` (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to position offset in the Y axis in component space.
    - ``position_alpha_z`` (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to position offset in the Z axis in component space.
    - ``rotation_alpha`` (float):  [Read-Write] Range 0-1, default is 0. Apply a large scale rotation offset to the entire body prior to constraint solving.
    - ``rotation_alpha_x`` (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to rotation offset in the X axis in component space.
    - ``rotation_alpha_y`` (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to rotation offset in the Y axis in component space.
    - ``rotation_alpha_z`` (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to rotation offset in the Z axis in component space.
    """
    def __init__(self, rotation_alpha: float = 0.000000, rotation_alpha_x: float = 0.000000, rotation_alpha_y: float = 0.000000, rotation_alpha_z: float = 0.000000, position_alpha: float = 0.000000, position_alpha_x: float = 0.000000, position_alpha_y: float = 0.000000, position_alpha_z: float = 0.000000) -> None:
        ...
    @property
    def rotation_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 0. Apply a large scale rotation offset to the entire body prior to constraint solving.
        """
        ...
    @rotation_alpha.setter
    def rotation_alpha(self, value: float) -> None:
        ...
    @property
    def rotation_alpha_x(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to rotation offset in the X axis in component space.
        """
        ...
    @rotation_alpha_x.setter
    def rotation_alpha_x(self, value: float) -> None:
        ...
    @property
    def rotation_alpha_y(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to rotation offset in the Y axis in component space.
        """
        ...
    @rotation_alpha_y.setter
    def rotation_alpha_y(self, value: float) -> None:
        ...
    @property
    def rotation_alpha_z(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to rotation offset in the Z axis in component space.
        """
        ...
    @rotation_alpha_z.setter
    def rotation_alpha_z(self, value: float) -> None:
        ...
    @property
    def position_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 1. Apply a large scale position offset to the entire body prior to constraint solving.
        """
        ...
    @position_alpha.setter
    def position_alpha(self, value: float) -> None:
        ...
    @property
    def position_alpha_x(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to position offset in the X axis in component space.
        """
        ...
    @position_alpha_x.setter
    def position_alpha_x(self, value: float) -> None:
        ...
    @property
    def position_alpha_y(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to position offset in the Y axis in component space.
        """
        ...
    @position_alpha_y.setter
    def position_alpha_y(self, value: float) -> None:
        ...
    @property
    def position_alpha_z(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 1. Blend contribution to position offset in the Z axis in component space.
        """
        ...
    @position_alpha_z.setter
    def position_alpha_z(self, value: float) -> None:
        ...

class PBIKSolverSettings(StructBase):
    r"""
    PBIKSolver Settings
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: PBIK
    - **File**: PBIKSolver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_stretch`` (bool):  [Read-Write] If true, joints will translate to reach the effectors; causing bones to lengthen if necessary. Good for cartoon effects. Default is false.
    - ``global_pull_chain_alpha`` (float):  [Read-Write] A global multiplier for all Pull Chain Alpha values on all effectors. Range is 0.0 to 1.0. Default is 1.0.
    - ``iterations`` (int32):  [Read-Write] High iteration counts can help solve complex joint configurations with competing constraints, but will increase runtime cost. Default is 20.
    - ``mass_multiplier`` (float):  [Read-Write] A global mass multiplier; higher values will make the joints more stiff, but require more iterations. Typical range is 0.0 to 10.0.
    - ``max_angle`` (float):  [Read-Write] Maximum angle that a joint can be rotated per constraint iteration. Lower this value if the solve is diverging. Range is 0.0 to 180.0. Default is 30.
    - ``over_relaxation`` (float):  [Read-Write] Pushes constraints beyond their normal amount to speed up convergence. Increasing this may speed up convergence, but at the cost of stability. Range is 1.0 - 2.0. Default is 1.3.
    - ``pre_pull_root_settings`` (RootPrePullSettings):  [Read-Write] Settings only applicable when Root Behavior is set to "PrePull". Use these values to adjust the gross movement and orientation of the entire skeleton.
    - ``root_behavior`` (PBIKRootBehavior):  [Read-Write] (Default is PrePull) Set the behavior of the solver root.
      Pre Pull: translates and rotates the root (and all children) by the average motion of the stretched effectors to help achieve faster convergence when reaching far.
      Pin to Input: locks the translation and rotation of the root bone to the input pose. Overrides any bone settings applied to the root. Good for partial-body solves.
      Free: treats the root bone like any other and allows it to move freely or according to any bone settings applied to it.
    - ``sub_iterations`` (int32):  [Read-Write] Iterations used for sub-chains defined by the Chain Depth of the effectors. These are solved BEFORE the main iteration pass. Default is 0.
    """
    def __init__(self, iterations: int = 0, sub_iterations: int = 0, mass_multiplier: float = 0.000000, allow_stretch: bool = False, root_behavior: PBIKRootBehavior = PBIKRootBehavior.PRE_PULL, pre_pull_root_settings: RootPrePullSettings = [0.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000], global_pull_chain_alpha: float = 0.000000, max_angle: float = 0.000000, over_relaxation: float = 0.000000) -> None:
        ...
    @property
    def iterations(self) -> int:
        r"""
        (int32):  [Read-Write] High iteration counts can help solve complex joint configurations with competing constraints, but will increase runtime cost. Default is 20.
        """
        ...
    @iterations.setter
    def iterations(self, value: int) -> None:
        ...
    @property
    def sub_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] Iterations used for sub-chains defined by the Chain Depth of the effectors. These are solved BEFORE the main iteration pass. Default is 0.
        """
        ...
    @sub_iterations.setter
    def sub_iterations(self, value: int) -> None:
        ...
    @property
    def mass_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] A global mass multiplier; higher values will make the joints more stiff, but require more iterations. Typical range is 0.0 to 10.0.
        """
        ...
    @mass_multiplier.setter
    def mass_multiplier(self, value: float) -> None:
        ...
    @property
    def allow_stretch(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, joints will translate to reach the effectors; causing bones to lengthen if necessary. Good for cartoon effects. Default is false.
        """
        ...
    @allow_stretch.setter
    def allow_stretch(self, value: bool) -> None:
        ...
    @property
    def root_behavior(self) -> PBIKRootBehavior:
        r"""
        (PBIKRootBehavior):  [Read-Write] (Default is PrePull) Set the behavior of the solver root.
        Pre Pull: translates and rotates the root (and all children) by the average motion of the stretched effectors to help achieve faster convergence when reaching far.
        Pin to Input: locks the translation and rotation of the root bone to the input pose. Overrides any bone settings applied to the root. Good for partial-body solves.
        Free: treats the root bone like any other and allows it to move freely or according to any bone settings applied to it.
        """
        ...
    @root_behavior.setter
    def root_behavior(self, value: PBIKRootBehavior) -> None:
        ...
    @property
    def pre_pull_root_settings(self) -> RootPrePullSettings:
        r"""
        (RootPrePullSettings):  [Read-Write] Settings only applicable when Root Behavior is set to "PrePull". Use these values to adjust the gross movement and orientation of the entire skeleton.
        """
        ...
    @pre_pull_root_settings.setter
    def pre_pull_root_settings(self, value: RootPrePullSettings) -> None:
        ...
    @property
    def global_pull_chain_alpha(self) -> float:
        r"""
        (float):  [Read-Write] A global multiplier for all Pull Chain Alpha values on all effectors. Range is 0.0 to 1.0. Default is 1.0.
        """
        ...
    @global_pull_chain_alpha.setter
    def global_pull_chain_alpha(self, value: float) -> None:
        ...
    @property
    def max_angle(self) -> float:
        r"""
        (float):  [Read-Write] Maximum angle that a joint can be rotated per constraint iteration. Lower this value if the solve is diverging. Range is 0.0 to 180.0. Default is 30.
        """
        ...
    @max_angle.setter
    def max_angle(self, value: float) -> None:
        ...
    @property
    def over_relaxation(self) -> float:
        r"""
        (float):  [Read-Write] Pushes constraints beyond their normal amount to speed up convergence. Increasing this may speed up convergence, but at the cost of stability. Range is 1.0 - 2.0. Default is 1.3.
        """
        ...
    @over_relaxation.setter
    def over_relaxation(self, value: float) -> None:
        ...

class PBIKDebug(StructBase):
    r"""
    PBIKDebug
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: PBIK
    - **File**: RigUnit_PBIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``draw_debug`` (bool):  [Read-Write] If true, turns on debug drawing for the node.
    - ``draw_scale`` (float):  [Read-Write] The scale of the debug drawing.
    """
    def __init__(self) -> None:
        ...

class PBIKEffector(StructBase):
    r"""
    PBIKEffector
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: PBIK
    - **File**: RigUnit_PBIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Write] The bone that this effector will pull on.
    - ``chain_depth`` (int32):  [Read-Write] Range 0-inf (default is 0). Explicitly set the number of bones up the hierarchy to consider part of this effector's 'chain'.
      The "chain" of bones is used to apply Preferred Angles, Pull Chain Alpha and "Sub Solve" iterations.
      If left at 0, the solver will attempt to determine the root of the chain by searching up the hierarchy until it finds a branch or another effector, whichever it finds first.
    - ``pin_rotation`` (float):  [Read-Write] Range 0-1 (default is 1.0).
      Blends the effector bone rotation between the rotation of the effector transform (1.0) and the rotation of the input bone (0.0).
    - ``position_alpha`` (float):  [Read-Write] Range 0-1, default is 1. Blend between the input bone position (0.0) and the current effector position (1.0).
    - ``pull_chain_alpha`` (float):  [Read-Write] Range 0-1 (default is 1.0). When enabled (greater than 0.0), the solver internally partitions the skeleton into 'chains' which extend from the effector to the nearest fork in the skeleton.
      These chains are pre-rotated and translated, as a whole, towards the effector targets.
      This can improve the results for sparse bone chains, and significantly improve convergence on dense bone chains.
      But it may cause undesirable results in highly constrained bone chains (like robot arms).
    - ``rotation_alpha`` (float):  [Read-Write] Range 0-1, default is 1. Blend between the input bone rotation (0.0) and the current effector rotation (1.0).
    - ``strength_alpha`` (float):  [Read-Write] Range 0-1 (default is 1.0). The strength of the effector when pulling the bone towards it's target location.
      At 0.0, the effector does not pull at all, but the bones between the effector and the root will still slightly resist motion from other effectors.
      This can thus act as a "stabilizer" of sorts for parts of the body that you do not want to behave in a pure FK fashion.
    - ``transform`` (Transform):  [Read-Write] The target location and rotation for this effector. The solver will try to get the specified bone to reach this location.
    """
    def __init__(self, chain_depth: int = 0) -> None:
        ...
    @property
    def chain_depth(self) -> int:
        r"""
        (int32):  [Read-Write] Range 0-inf (default is 0). Explicitly set the number of bones up the hierarchy to consider part of this effector's 'chain'.
        The "chain" of bones is used to apply Preferred Angles, Pull Chain Alpha and "Sub Solve" iterations.
        If left at 0, the solver will attempt to determine the root of the chain by searching up the hierarchy until it finds a branch or another effector, whichever it finds first.
        """
        ...
    @chain_depth.setter
    def chain_depth(self, value: int) -> None:
        ...

class RigUnit_PBIK(RigUnit_HighlevelBaseMutable):
    r"""
    * Based on a Position Based solver at core, this node can solve multi chains within a root using multi effectors
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: PBIK
    - **File**: RigUnit_PBIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_settings`` (Array[PBIKBoneSetting]):  [Read-Write] Per-bone settings to control the resulting pose. Includes limits and preferred angles.
    - ``debug`` (PBIKDebug):  [Read-Write] Debug drawing options.
    - ``effectors`` (Array[PBIKEffector]):  [Read-Write] An array of effectors. These specify target transforms for different parts of the skeleton.
    - ``excluded_bones`` (Array[Name]):  [Read-Write] These bones will be excluded from the solver. They will not bend and will not contribute to the constraint set.
      Use the ExcludedBones array instead of setting Rotation Stiffness to very high values or Rotation Limits with zero range.
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``root`` (Name):  [Read-Write] This is usually the top-most skinned bone; often the "Pelvis" or "Hips", but can be set to any bone.
      Bones above the root will be ignored by the solver.
      Bones that are located *between* the Root and the effectors will be included in the solve.
    - ``settings`` (PBIKSolverSettings):  [Read-Write] Global solver settings.
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], root: Name = "None", effectors: Array[PBIKEffector] = [], bone_settings: Array[PBIKBoneSetting] = [], excluded_bones: Array[Name] = [], settings: PBIKSolverSettings = [20, 0, 1.000000, False, PBIKRootBehavior.PRE_PULL, [0.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000], 1.000000, 30.000000, 1.300000], debug: PBIKDebug = []) -> None:
        ...
    @property
    def root(self) -> Name:
        r"""
        (Name):  [Read-Write] This is usually the top-most skinned bone; often the "Pelvis" or "Hips", but can be set to any bone.
        Bones above the root will be ignored by the solver.
        Bones that are located *between* the Root and the effectors will be included in the solve.
        """
        ...
    @root.setter
    def root(self, value: Name) -> None:
        ...
    @property
    def effectors(self) -> Array[PBIKEffector]:
        r"""
        (Array[PBIKEffector]):  [Read-Write] An array of effectors. These specify target transforms for different parts of the skeleton.
        """
        ...
    @effectors.setter
    def effectors(self, value: Array[PBIKEffector]) -> None:
        ...
    @property
    def bone_settings(self) -> Array[PBIKBoneSetting]:
        r"""
        (Array[PBIKBoneSetting]):  [Read-Write] Per-bone settings to control the resulting pose. Includes limits and preferred angles.
        """
        ...
    @bone_settings.setter
    def bone_settings(self, value: Array[PBIKBoneSetting]) -> None:
        ...
    @property
    def excluded_bones(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] These bones will be excluded from the solver. They will not bend and will not contribute to the constraint set.
        Use the ExcludedBones array instead of setting Rotation Stiffness to very high values or Rotation Limits with zero range.
        """
        ...
    @excluded_bones.setter
    def excluded_bones(self, value: Array[Name]) -> None:
        ...
    @property
    def settings(self) -> PBIKSolverSettings:
        r"""
        (PBIKSolverSettings):  [Read-Write] Global solver settings.
        """
        ...
    @settings.setter
    def settings(self, value: PBIKSolverSettings) -> None:
        ...
    @property
    def debug(self) -> PBIKDebug:
        r"""
        (PBIKDebug):  [Read-Write] Debug drawing options.
        """
        ...
    @debug.setter
    def debug(self, value: PBIKDebug) -> None:
        ...

class PyTestStruct(StructBase):
    r"""
    Struct to allow testing of the various UStruct features that are exposed to Python wrapped types.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool`` (bool):  [Read-Write]
    - ``bool_defaults_only`` (bool):  [Read-Write]
    - ``bool_instance_only`` (bool):  [Read-Write]
    - ``bool_mutable`` (bool):  [Read-Only]
    - ``enum`` (PyTestEnum):  [Read-Write]
    - ``field_path`` (FieldPath):  [Read-Write]
    - ``float`` (float):  [Read-Write]
    - ``int`` (int32):  [Read-Write]
    - ``legacy_int`` (int32):  [Read-Write]
      deprecated: LegacyInt is deprecated. Please use Int instead.
    - ``name`` (Name):  [Read-Write]
    - ``string`` (str):  [Read-Write]
    - ``string_array`` (Array[str]):  [Read-Write]
    - ``string_int_map`` (Map[str, int32]):  [Read-Write]
    - ``string_set`` (Set[str]):  [Read-Write]
    - ``struct_field_path`` (FieldPath):  [Read-Write]
    - ``text`` (Text):  [Read-Write]
    """
    def __init__(self, bool: bool = False, int: int = 0, float: float = 0.000000, enum: PyTestEnum = PyTestEnum.ONE, string: str = "", name: Name = "None", text: Text = "", field_path: FieldPath = FieldPath(), struct_field_path: FieldPath = FieldPath(), string_array: Array[str] = [], string_set: Set[str] = [], string_int_map: Map[str, int] = {}, bool_mutable: bool = False) -> None:
        ...
    @property
    def bool(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @bool.setter
    def bool(self, value: bool) -> None:
        ...
    @property
    def int(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @int.setter
    def int(self, value: int) -> None:
        ...
    @property
    def float(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @float.setter
    def float(self, value: float) -> None:
        ...
    @property
    def enum(self) -> PyTestEnum:
        r"""
        (PyTestEnum):  [Read-Write]
        """
        ...
    @enum.setter
    def enum(self, value: PyTestEnum) -> None:
        ...
    @property
    def string(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @string.setter
    def string(self, value: str) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def text(self) -> Text:
        r"""
        (Text):  [Read-Write]
        """
        ...
    @text.setter
    def text(self, value: Text) -> None:
        ...
    @property
    def field_path(self) -> FieldPath:
        r"""
        (FieldPath):  [Read-Write]
        """
        ...
    @field_path.setter
    def field_path(self, value: FieldPath) -> None:
        ...
    @property
    def struct_field_path(self) -> FieldPath:
        r"""
        (FieldPath):  [Read-Write]
        """
        ...
    @struct_field_path.setter
    def struct_field_path(self, value: FieldPath) -> None:
        ...
    @property
    def string_array(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write]
        """
        ...
    @string_array.setter
    def string_array(self, value: Array[str]) -> None:
        ...
    @property
    def string_set(self) -> Set[str]:
        r"""
        (Set[str]):  [Read-Write]
        """
        ...
    @string_set.setter
    def string_set(self, value: Set[str]) -> None:
        ...
    @property
    def string_int_map(self) -> Map[str, int]:
        r"""
        (Map[str, int32]):  [Read-Write]
        """
        ...
    @string_int_map.setter
    def string_int_map(self, value: Map[str, int]) -> None:
        ...
    @property
    def legacy_int(self) -> int:
        r"""
        (int32):  [Read-Write]
        deprecated: LegacyInt is deprecated. Please use Int instead.
        """
        ...
    @legacy_int.setter
    def legacy_int(self, value: int) -> None:
        ...
    @property
    def bool_mutable(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    def set_bool_mutable_via_ref(self) -> None:
        r"""
        x.set_bool_mutable_via_ref() -> None
        Set Bool Mutable Via Ref
        """
        ...
    def set_bool_mutable(self) -> None:
        r"""
        x.set_bool_mutable() -> None
        Set Bool Mutable
        """
        ...
    def legacy_is_bool_set(self) -> bool:
        r"""
        x.legacy_is_bool_set() -> bool
        Legacy Is Bool Set
        deprecated: LegacyIsBoolSet is deprecated. Please use IsBoolSet instead.
        
        Returns:
            bool:
        """
        ...
    def is_bool_set(self) -> bool:
        r"""
        x.is_bool_set() -> bool
        Is Bool Set
        
        Returns:
            bool:
        """
        ...
    def is_bool_set_old(self) -> bool:
        r"""
        deprecated: 'is_bool_set_old' was renamed to 'is_bool_set'.
        """
        ...
    def clear_bool_mutable_via_ref(self) -> None:
        r"""
        x.clear_bool_mutable_via_ref() -> None
        Clear Bool Mutable Via Ref
        """
        ...
    def clear_bool_mutable(self) -> None:
        r"""
        x.clear_bool_mutable() -> None
        Clear Bool Mutable
        """
        ...
    def add_str(self, value: str) -> None:
        r"""
        x.add_str(value) -> None
        Add Str
        
        Args:
            value (str): 
        
        Returns:
            PyTestStruct:
        """
        ...
    def add_int(self, value: int) -> None:
        r"""
        x.add_int(value) -> None
        Add Int
        
        Args:
            value (int32): 
        
        Returns:
            PyTestStruct:
        """
        ...
    def add_float(self, value: float) -> None:
        r"""
        x.add_float(value) -> None
        Add Float
        
        Args:
            value (float): 
        
        Returns:
            PyTestStruct:
        """
        ...
    def __add__(self, other: PyTestStruct) -> None:
        r"""
        **Overloads:**
        
        - ``str`` Add Str
        - ``int32`` Add Int
        - ``float`` Add Float
        """
        ...
    def __iadd__(self, other: PyTestStruct) -> None:
        r"""
        **Overloads:**
        
        - ``str`` Add Str
        - ``int32`` Add Int
        - ``float`` Add Float
        """
        ...
    CONSTANT_VALUE: int #: (int32): Get Constant Value

class PythonLogOutputEntry(StructBase):
    r"""
    Log output entry captured from Python.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PythonScriptTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``output`` (str):  [Read-Only] The log output string.
    - ``type`` (PythonLogOutputType):  [Read-Only] The type of the log output.
    """
    def __init__(self, type: PythonLogOutputType = PythonLogOutputType.INFO, output: str = "") -> None:
        ...
    @property
    def type(self) -> PythonLogOutputType:
        r"""
        (PythonLogOutputType):  [Read-Only] The type of the log output.
        """
        ...
    @property
    def output(self) -> str:
        r"""
        (str):  [Read-Only] The log output string.
        """
        ...

class PyTestChildStruct(PyTestStruct):
    r"""
    Struct to allow testing of inheritance on Python wrapped types.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool`` (bool):  [Read-Write]
    - ``bool_defaults_only`` (bool):  [Read-Write]
    - ``bool_instance_only`` (bool):  [Read-Write]
    - ``bool_mutable`` (bool):  [Read-Only]
    - ``enum`` (PyTestEnum):  [Read-Write]
    - ``field_path`` (FieldPath):  [Read-Write]
    - ``float`` (float):  [Read-Write]
    - ``int`` (int32):  [Read-Write]
    - ``legacy_int`` (int32):  [Read-Write]
      deprecated: LegacyInt is deprecated. Please use Int instead.
    - ``name`` (Name):  [Read-Write]
    - ``string`` (str):  [Read-Write]
    - ``string_array`` (Array[str]):  [Read-Write]
    - ``string_int_map`` (Map[str, int32]):  [Read-Write]
    - ``string_set`` (Set[str]):  [Read-Write]
    - ``struct_field_path`` (FieldPath):  [Read-Write]
    - ``text`` (Text):  [Read-Write]
    """
    def __init__(self, bool: bool = False, int: int = 0, float: float = 0.000000, enum: PyTestEnum = PyTestEnum.ONE, string: str = "", name: Name = "None", text: Text = "", field_path: FieldPath = FieldPath(), struct_field_path: FieldPath = FieldPath(), string_array: Array[str] = [], string_set: Set[str] = [], string_int_map: Map[str, int] = {}, bool_mutable: bool = False) -> None:
        ...

class PyTestClassSparseData(StructBase):
    r"""
    Struct to allow testing of class sparse data on a Python exposed type.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``int_from_sparse_data`` (int32):  [Read-Write]
    """
    def __init__(self, int_from_sparse_data: int = 0) -> None:
        ...
    @property
    def int_from_sparse_data(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class CollisionResponse(StructBase):
    r"""
    Collision Response
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BodyInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``response_array`` (Array[ResponseChannel]):  [Read-Write] Custom Channels for Responses
    """
    def __init__(self) -> None:
        ...

class LiveLinkWorldTime(StructBase):
    r"""
    Live Link World Time
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTypes.h
    
    """
    def __init__(self) -> None:
        ...

class BoneReference(StructBase):
    r"""
    Bone Reference
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BoneReference.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_name`` (Name):  [Read-Write] Name of bone to control. This is the main bone chain to modify from. *
    """
    def __init__(self) -> None:
        ...

class InputBlendPose(StructBase):
    r"""
    Input Blend Pose
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BoneMaskFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``branch_filters`` (Array[BranchFilter]):  [Read-Write] Bone Name to filter *
    """
    def __init__(self) -> None:
        ...

class PoseDriverTarget(StructBase):
    r"""
    Information about each target in the PoseDriver
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_PoseDriver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_custom_curve`` (bool):  [Read-Write] If we should apply a custom curve mapping to how this target activates
    - ``bone_transforms`` (Array[PoseDriverTransform]):  [Read-Write] Translation of this target
    - ``custom_curve`` (RichCurve):  [Read-Write] Custom curve mapping to apply if bApplyCustomCurve is true
    - ``distance_method`` (RBFDistanceMethod):  [Read-Write] Override for the distance method to use for each target
    - ``driven_name`` (Name):  [Read-Write] Name of item to drive - depends on DriveOutput setting.
      If DriveOutput is DrivePoses, this should be the name of a pose in the assigned PoseAsset
      If DriveOutput is DriveCurves, this is the name of the curve (morph target, material param etc) to drive
    - ``function_type`` (RBFFunctionType):  [Read-Write] Override for the function method to use for each target
    - ``is_hidden`` (bool):  [Read-Write] If we should hide this pose from the UI
    - ``target_rotation`` (Rotator):  [Read-Write] Rotation of this target
    - ``target_scale`` (float):  [Read-Write] Scale applied to this target's function - a larger value will activate this target sooner
    """
    def __init__(self) -> None:
        ...

class AnimPhysBodyDefinition(StructBase):
    r"""
    Anim Phys Body Definition
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_AnimDynamics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bound_bone`` (BoneReference):  [Read-Only]
    - ``box_extents`` (Vector):  [Read-Write] Extents of the box to use for simulation
    - ``collision_type`` (AnimPhysCollisionType):  [Read-Write] Resolution method for planar limits
    - ``constraint_setup`` (AnimPhysConstraintSetup):  [Read-Write] Data describing the constraints we will apply to the body
    - ``local_joint_offset`` (Vector):  [Read-Write] Vector relative to the body being simulated to attach the constraint to
    - ``sphere_collision_radius`` (float):  [Read-Write] Radius to use if CollisionType is set to CustomSphere
    """
    def __init__(self) -> None:
        ...

class AnimPhysSphericalLimit(StructBase):
    r"""
    Anim Phys Spherical Limit
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_AnimDynamics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``driving_bone`` (BoneReference):  [Read-Write] Bone to attach the sphere to
    - ``limit_radius`` (float):  [Read-Write] Radius of the sphere
    - ``limit_type`` (SphericalLimitType):  [Read-Write] Whether to lock bodies inside or outside of the sphere
    - ``sphere_local_offset`` (Vector):  [Read-Write] Local offset for the sphere, if no driving bone is set this is in node space, otherwise bone space
    """
    def __init__(self) -> None:
        ...

class AnimPhysPlanarLimit(StructBase):
    r"""
    Anim Phys Planar Limit
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_AnimDynamics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``driving_bone`` (BoneReference):  [Read-Write] When using a driving bone, the plane transform will be relative to the bone transform
    - ``plane_transform`` (Transform):  [Read-Write] Transform of the plane, this is either in component-space if no DrivinBone is specified
      or in bone-space if a driving bone is present.
    """
    def __init__(self) -> None:
        ...

class AngularRangeLimit(StructBase):
    r"""
    Angular Range Limit
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_ApplyLimits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (BoneReference):  [Read-Write]
    - ``limit_max`` (Vector):  [Read-Write]
    - ``limit_min`` (Vector):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class BoneSocketTarget(StructBase):
    r"""
    Bone Socket Target
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BoneSocketReference.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_reference`` (BoneReference):  [Read-Write]
    - ``socket_reference`` (SocketReference):  [Read-Write]
    - ``use_socket`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class TargetReference(BoneSocketTarget):
    r"""
    deprecated: 'TargetReference' was renamed to 'BoneSocketTarget'.
    """
    def __init__(self) -> None:
        ...

class Constraint(StructBase):
    r"""
    Constraint Set up
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_Constraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``offset_option`` (ConstraintOffsetOption):  [Read-Write] Maintain offset based on refpose or not.
      
      None - no offset
      Offset_RefPose - offset is created based on reference pose
      
      In the future, we'd like to support custom offset, not just based on ref pose
    - ``per_axis`` (FilterOptionPerAxis):  [Read-Write] Per axis filter options - applied in their local space not in world space
    - ``target_bone`` (BoneReference):  [Read-Write] Target Bone this is constraint to
    - ``transform_type`` (TransformConstraintType):  [Read-Write] What transform type is constraint to - Translation, Rotation, Scale OR Parent. Parent overrides all component
    """
    def __init__(self) -> None:
        ...

class AnimLegIKDefinition(StructBase):
    r"""
    Per foot definitions
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_LegIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_knee_twist_correction`` (bool):  [Read-Write] Enable Knee Twist correction, by comparing Foot FK with Foot IK orientation.
    - ``enable_rotation_limit`` (bool):  [Read-Write] If enabled, we prevent the leg from bending backwards and enforce a min compression angle
    - ``fk_foot_bone`` (BoneReference):  [Read-Write]
    - ``foot_bone_forward_axis`` (AxisType):  [Read-Write] Forward Axis for Foot bone.
    - ``hinge_rotation_axis`` (AxisType):  [Read-Write] Hinge Bones Rotation Axis. This is essentially the plane normal for (hip - knee - foot).
    - ``ik_foot_bone`` (BoneReference):  [Read-Write]
    - ``min_rotation_angle`` (float):  [Read-Write] Only used if bEnableRotationLimit is enabled. Prevents the leg from folding onto itself,
      and forces at least this angle between Parent and Child bone.
    - ``num_bones_in_limb`` (int32):  [Read-Write]
    - ``twist_offset_curve_name`` (Name):  [Read-Write] Name of the curve to use as the twist offset angle(in degrees).
      This is useful for injecting knee motion, while keeping the IK chain's goal/hand and root/hip locked in place.
      Reasonable values are usually between -+15 degrees, although this is depends on how far in/out the knee is in the original pose.
    """
    def __init__(self) -> None:
        ...

class Axis(StructBase):
    r"""
    Axis to represent direction
    
    **C++ Source:**
    
    - **Module**: AnimationCore
    - **File**: CommonAnimTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis`` (Vector):  [Read-Write]
    - ``local_space`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class RotationLimit(StructBase):
    r"""
    Rotation Limit
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_Trail.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``limit_max`` (Vector):  [Read-Write]
    - ``limit_min`` (Vector):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class ReferenceBoneFrame(StructBase):
    r"""
    Reference Bone Frame
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_TwistCorrectiveNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis`` (Axis):  [Read-Write]
    - ``bone`` (BoneReference):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AttributeKey(StructBase):
    r"""
    Attribute Key
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AttributeCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``time`` (float):  [Read-Write] The keyed time
    """
    def __init__(self) -> None:
        ...

class NavAgentSelector(StructBase):
    r"""
    Nav Agent Selector
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavAgentSelector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``supports_agent0`` (bool):  [Read-Write]
    - ``supports_agent1`` (bool):  [Read-Write]
    - ``supports_agent10`` (bool):  [Read-Write]
    - ``supports_agent11`` (bool):  [Read-Write]
    - ``supports_agent12`` (bool):  [Read-Write]
    - ``supports_agent13`` (bool):  [Read-Write]
    - ``supports_agent14`` (bool):  [Read-Write]
    - ``supports_agent15`` (bool):  [Read-Write]
    - ``supports_agent2`` (bool):  [Read-Write]
    - ``supports_agent3`` (bool):  [Read-Write]
    - ``supports_agent4`` (bool):  [Read-Write]
    - ``supports_agent5`` (bool):  [Read-Write]
    - ``supports_agent6`` (bool):  [Read-Write]
    - ``supports_agent7`` (bool):  [Read-Write]
    - ``supports_agent8`` (bool):  [Read-Write]
    - ``supports_agent9`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class Vector4d(StructBase):
    r"""
    A 4-D homogeneous vector.
    note: The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Vector4.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``w`` (double):  [Read-Write]
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    - ``z`` (double):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class RuntimeCurveLinearColor(StructBase):
    r"""
    Runtime Curve Linear Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveLinearColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``external_curve`` (CurveLinearColor):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class TakeRecorderTrackSettings(StructBase):
    r"""
    Take Recorder Track Settings
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: IMovieSceneTrackRecorderHost.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_property_tracks`` (Array[TakeRecorderPropertyTrackSettings]):  [Read-Write] List of property names for which movie scene tracks will be created automatically.
    - ``exclude_property_tracks`` (Array[TakeRecorderPropertyTrackSettings]):  [Read-Write] List of property names for which movie scene tracks will NOT be created automatically.
    - ``matching_actor_class`` (SoftClassPath):  [Read-Write] The Actor class to create movie scene tracks for.
    """
    def __init__(self) -> None:
        ...

class FBIKBoneLimit(StructBase):
    r"""
    FBIKBone Limit
    
    **C++ Source:**
    
    - **Plugin**: FullBodyIK
    - **Module**: FullBodyIK
    - **File**: FBIKConstraintOption.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``limit`` (Vector):  [Read-Write] currently no negative limit, for position we may need min/max
    - ``limit_type_x`` (FBIKBoneLimitType):  [Read-Write]
    - ``limit_type_y`` (FBIKBoneLimitType):  [Read-Write]
    - ``limit_type_z`` (FBIKBoneLimitType):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class TemplateMapInfoOverride(StructBase):
    r"""
    Used by new level dialog.
    
    **C++ Source:**
    
    - **Module**: EngineSettings
    - **File**: GameMapsSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The display name of the map template in the level dialog. If this is empty the thumbnail name will be used
    - ``map`` (SoftObjectPath):  [Read-Write] The path to the template map
    - ``thumbnail`` (SoftObjectPath):  [Read-Write] The thumbnail to display in the new level dialog
    """
    def __init__(self) -> None:
        ...

class GameModeName(StructBase):
    r"""
    Helper structure, used to associate GameModes with shortcut names.
    
    **C++ Source:**
    
    - **Module**: EngineSettings
    - **File**: GameMapsSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``game_mode`` (SoftClassPath):  [Read-Write] GameMode class to load
    - ``name`` (str):  [Read-Write] Abbreviation/prefix that can be used as an alias for the class name
    """
    def __init__(self) -> None:
        ...

class ToolMenuProfile(StructBase):
    r"""
    * A menu profile is a way for systems to modify instances of a menu by showing/hiding specific items. You can have multiple profiles active on
    * a single menu at the same time.
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: ToolMenuBase.h
    
    """
    def __init__(self) -> None:
        ...

class CustomizedToolMenu(ToolMenuProfile):
    r"""
    * A menu customization is a specialization of menu profiles - that allows for advanced behavior such as modifying the order of sections/entries
    * A menu can only have one customization active at a time
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: ToolMenuBase.h
    
    """
    def __init__(self) -> None:
        ...

class ToolMenuProfileMap(StructBase):
    r"""
    * Struct to store all the profiles for a menu for serialization
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenus.h
    
    """
    def __init__(self) -> None:
        ...

class TickFunction(StructBase):
    r"""
    Abstract Base class for all tick functions.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineBaseTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_tick_on_dedicated_server`` (bool):  [Read-Write] If we allow this tick to run on a dedicated server
    - ``end_tick_group`` (TickingGroup):  [Read-Write] Defines the tick group that this tick function must finish in. These groups determine the relative order of when objects tick during a frame update.
      see: ETickingGroup
    - ``start_with_tick_enabled`` (bool):  [Read-Write] If true, this tick function will start enabled, but can be disabled later on.
    - ``tick_even_when_paused`` (bool):  [Read-Write] Bool indicating that this function should execute even if the game is paused. Pause ticks are very limited in capabilities. *
    - ``tick_group`` (TickingGroup):  [Read-Write] Defines the minimum tick group for this tick function. These groups determine the relative order of when objects tick during a frame update.
      Given prerequisites, the tick may be delayed.
      see: ETickingGroup
      see: FTickFunction::AddPrerequisite()
    - ``tick_interval`` (float):  [Read-Write] The frequency in seconds at which this tick function will be executed.  If less than or equal to 0 then it will tick every frame
    """
    def __init__(self) -> None:
        ...

class ActorTickFunction(TickFunction):
    r"""
    Tick function that calls AActor::TickActor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineBaseTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_tick_on_dedicated_server`` (bool):  [Read-Write] If we allow this tick to run on a dedicated server
    - ``end_tick_group`` (TickingGroup):  [Read-Write] Defines the tick group that this tick function must finish in. These groups determine the relative order of when objects tick during a frame update.
      see: ETickingGroup
    - ``start_with_tick_enabled`` (bool):  [Read-Write] If true, this tick function will start enabled, but can be disabled later on.
    - ``tick_even_when_paused`` (bool):  [Read-Write] Bool indicating that this function should execute even if the game is paused. Pause ticks are very limited in capabilities. *
    - ``tick_group`` (TickingGroup):  [Read-Write] Defines the minimum tick group for this tick function. These groups determine the relative order of when objects tick during a frame update.
      Given prerequisites, the tick may be delayed.
      see: ETickingGroup
      see: FTickFunction::AddPrerequisite()
    - ``tick_interval`` (float):  [Read-Write] The frequency in seconds at which this tick function will be executed.  If less than or equal to 0 then it will tick every frame
    """
    def __init__(self) -> None:
        ...

class RepMovement(StructBase):
    r"""
    Replicated movement data of our RootComponent.
    Struct used for efficient replication as velocity and location are generally replicated together (this saves a repindex)
    and velocity.Z is commonly zero (most position replications are for walking pawns).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ReplicatedState.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``location_quantization_level`` (VectorQuantization):  [Read-Write] Allows tuning the compression level for the replicated location vector. You should only need to change this from the default if you see visual artifacts.
    - ``rotation_quantization_level`` (RotatorQuantization):  [Read-Write] Allows tuning the compression level for replicated rotation. You should only need to change this from the default if you see visual artifacts.
    - ``velocity_quantization_level`` (VectorQuantization):  [Read-Write] Allows tuning the compression level for the replicated velocity vectors. You should only need to change this from the default if you see visual artifacts.
    """
    def __init__(self) -> None:
        ...

class WidgetChild(StructBase):
    r"""
    Represent a Widget present in the Tree Widget of the UserWidget
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetChild.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``widget_name`` (Name):  [Read-Write] This either the widget to focus, OR the name of the function to call.
    """
    def __init__(self) -> None:
        ...

class ActorComponentTickFunction(TickFunction):
    r"""
    Tick function that calls UActorComponent::ConditionalTick
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineBaseTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_tick_on_dedicated_server`` (bool):  [Read-Write] If we allow this tick to run on a dedicated server
    - ``end_tick_group`` (TickingGroup):  [Read-Write] Defines the tick group that this tick function must finish in. These groups determine the relative order of when objects tick during a frame update.
      see: ETickingGroup
    - ``start_with_tick_enabled`` (bool):  [Read-Write] If true, this tick function will start enabled, but can be disabled later on.
    - ``tick_even_when_paused`` (bool):  [Read-Write] Bool indicating that this function should execute even if the game is paused. Pause ticks are very limited in capabilities. *
    - ``tick_group`` (TickingGroup):  [Read-Write] Defines the minimum tick group for this tick function. These groups determine the relative order of when objects tick during a frame update.
      Given prerequisites, the tick may be delayed.
      see: ETickingGroup
      see: FTickFunction::AddPrerequisite()
    - ``tick_interval`` (float):  [Read-Write] The frequency in seconds at which this tick function will be executed.  If less than or equal to 0 then it will tick every frame
    """
    def __init__(self) -> None:
        ...

class CustomPrimitiveData(StructBase):
    r"""
    Custom primitive data payload.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data`` (Array[float]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class LightmassPrimitiveSettings(StructBase):
    r"""
    Per-object settings for Lightmass
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``diffuse_boost`` (float):  [Read-Write] Scales the diffuse contribution of all materials applied to this object.
    - ``emissive_boost`` (float):  [Read-Write] Scales the emissive contribution of all materials applied to this object.
    - ``fully_occluded_samples_fraction`` (float):  [Read-Write] Fraction of samples taken that must be occluded in order to reach full occlusion.
    - ``shadow_indirect_only`` (bool):  [Read-Write] If true, this object will only shadow indirect lighting.
    - ``use_emissive_for_static_lighting`` (bool):  [Read-Write] If true, allow using the emissive for static lighting.
    - ``use_two_sided_lighting`` (bool):  [Read-Write] If true, this object will be lit as if it receives light from both sides of its polygons.
    - ``use_vertex_normal_for_hemisphere_gather`` (bool):  [Read-Write] Typically the triangle normal is used for hemisphere gathering which prevents incorrect self-shadowing from artist-tweaked vertex normals.
      However in the case of foliage whose vertex normal has been setup to match the underlying terrain, gathering in the direction of the vertex normal is desired.
    """
    def __init__(self) -> None:
        ...

class BlackboardEntry(StructBase):
    r"""
    blackboard entry definition
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BlackboardData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``entry_category`` (Name):  [Read-Write]
    - ``entry_description`` (str):  [Read-Write] Optional description to explain what this blackboard entry does.
    - ``entry_name`` (Name):  [Read-Write]
    - ``instance_synced`` (bool):  [Read-Write] if set to true then this field will be synchronized across all instances of this blackboard
    - ``key_type`` (BlackboardKeyType):  [Read-Write] key type and additional properties
    """
    def __init__(self) -> None:
        ...

class IntervalCountdown(StructBase):
    r"""
    Interval Countdown
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AITypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``interval`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NavigationFilterArea(StructBase):
    r"""
    Navigation Filter Area
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationQueryFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``area_class`` (type(Class)):  [Read-Write] navigation area class
    - ``entering_cost_override`` (float):  [Read-Write] override for entering cost
    - ``is_excluded`` (bool):  [Read-Write] mark as excluded
    - ``override_entering_cost`` (bool):  [Read-Write]
    - ``override_travel_cost`` (bool):  [Read-Write]
    - ``travel_cost_override`` (float):  [Read-Write] override for travel cost
    """
    def __init__(self) -> None:
        ...

class NavigationFilterFlags(StructBase):
    r"""
    Use UNavigationSystemV1.DescribeFilterFlags() to setup user friendly names of flags
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationQueryFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``nav_flag0`` (bool):  [Read-Write]
    - ``nav_flag1`` (bool):  [Read-Write]
    - ``nav_flag10`` (bool):  [Read-Write]
    - ``nav_flag11`` (bool):  [Read-Write]
    - ``nav_flag12`` (bool):  [Read-Write]
    - ``nav_flag13`` (bool):  [Read-Write]
    - ``nav_flag14`` (bool):  [Read-Write]
    - ``nav_flag15`` (bool):  [Read-Write]
    - ``nav_flag2`` (bool):  [Read-Write]
    - ``nav_flag3`` (bool):  [Read-Write]
    - ``nav_flag4`` (bool):  [Read-Write]
    - ``nav_flag5`` (bool):  [Read-Write]
    - ``nav_flag6`` (bool):  [Read-Write]
    - ``nav_flag7`` (bool):  [Read-Write]
    - ``nav_flag8`` (bool):  [Read-Write]
    - ``nav_flag9`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class ChaosSolverConfiguration(StructBase):
    r"""
    Chaos Solver Configuration
    
    **C++ Source:**
    
    - **Module**: Chaos
    - **File**: ChaosSolverConfiguration.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``breaking_filter_settings`` (SolverBreakingFilterSettings):  [Read-Write]
    - ``cluster_connection_factor`` (float):  [Read-Write]
    - ``cluster_union_connection_type`` (ClusterUnionMethod):  [Read-Write]
    - ``collision_cull_distance`` (float):  [Read-Write] During collision detection, if tweo shapes are at least this far apart we do not calculate their nearest features
      during the collision detection step.
    - ``collision_filter_settings`` (SolverCollisionFilterSettings):  [Read-Write]
    - ``collision_initial_overlap_depenetration_velocity`` (float):  [Read-Write] If two bodies start off in overlapping each other, they will depentrate at this speed when they wake.
      If set to a large value, initially-overlapping objects will tend to "explode" apart at a speed that depends on the
      overlap amount and the timestep (this is the original, previously untunable behaviour). If set to zero,
      initially-overlapping objects will remain stationary and go to sleep until acted on by some other object or force.
      A negative value (-1) disables the feature and is equivalent to infinity.
      This property can be overridden per Body (see FBodyInstance::MaxDepenetrationVelocity)
    - ``collision_margin_fraction`` (float):  [Read-Write] A collision margin as a fraction of size used by some boxes and convex shapes to improve collision detection results.
      The core geometry of shapes that support a margin are reduced in size by the margin, and the margin
      is added back on during collision detection. The net result is a shape of the same size but with rounded corners.
    - ``collision_margin_max`` (float):  [Read-Write] An upper limit on the collision margin that will be subtracted from boxes and convex shapes. See CollisionMarginFraction
    - ``collision_max_push_out_velocity`` (float):  [Read-Write] The maximum speed at which two bodies can be extracted from each other when they start a frame inter-penetrating. This can
      happen because they spawned on top of each other, or the solver failed to fully reolve collisions last frame. A value of
      zero means "no limit". A non-zero value can be used to prevent explosive behaviour when bodies start deeply penetrating.
      An alternative to using this approach is to increase the number of Velocity Iterations, which is more expensive but will
      ensure the bodies are depenetrated in a single frame without explosive behaviour.
    - ``generate_break_data`` (bool):  [Read-Write]
    - ``generate_collision_data`` (bool):  [Read-Write]
    - ``generate_trailing_data`` (bool):  [Read-Write]
    - ``position_iterations`` (int32):  [Read-Write] The number of position iterations to run during the constraint solver step
    - ``projection_iterations`` (int32):  [Read-Write] The number of projection iterations to run during the constraint solver step
    - ``trailing_filter_settings`` (SolverTrailingFilterSettings):  [Read-Write]
    - ``velocity_iterations`` (int32):  [Read-Write] The number of velocity iterations to run during the constraint solver step
    """
    def __init__(self) -> None:
        ...

class ChaosDebugSubstepControl(StructBase):
    r"""
    Chaos Debug Substep Control
    
    **C++ Source:**
    
    - **Module**: ChaosSolverEngine
    - **File**: ChaosSolverActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``pause`` (bool):  [Read-Write] * Pause the solver at the next synchronization point.
    - ``step`` (bool):  [Read-Write] * Step the solver to the next synchronization point.
    - ``substep`` (bool):  [Read-Write] * Substep the solver to the next synchronization point.
    """
    def __init__(self) -> None:
        ...

class GeometryCollectionSizeSpecificData(StructBase):
    r"""
    Geometry Collection Size Specific Data
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_object_reduction_percentage`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
      deprecated: Use Collision.CollisionObjectReductionPercentage instead.
    - ``collision_particles_fraction`` (float):  [Read-Write] Number of particles on the triangulated surface to use for collisions.
      deprecated: Use Collision.CollisionParticlesFraction instead.
    - ``collision_shapes`` (Array[GeometryCollectionCollisionTypeData]):  [Read-Write] * Collision Shapes allow kfor multiple collision types per rigid body.
    - ``collision_type`` (CollisionTypeEnum):  [Read-Write] *  CollisionType defines how to initialize the rigid collision structures.
      deprecated: Use Collision.CollisionType instead.
    - ``damage_threshold`` (int32):  [Read-Write] Max number of particles.
    - ``implicit_type`` (ImplicitTypeEnum):  [Read-Write] *  CollisionType defines how to initialize the rigid collision structures.
      deprecated: Use Collision.ImplicitType instead.
    - ``max_cluster_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
      deprecated: Use Collision.LevelSet.MaxClusterLevelSetResolution instead.
    - ``max_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
      deprecated: Use Collision.LevelSet.MaxLevelSetResolution instead.
    - ``max_size`` (float):  [Read-Write] The max size these settings apply to
    - ``maximum_collision_particles`` (int32):  [Read-Write] Max number of particles.
      deprecated: Use Collision.MaximumCollisionParticles instead.
    - ``min_cluster_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 5)
      deprecated: Use Collision.LevelSet.MinClusterLevelSetResolution instead.
    - ``min_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 5)
      deprecated: Use Collision.LevelSet.MinLevelSetResolution instead.
    """
    def __init__(self) -> None:
        ...
    @property
    def collision_type(self) -> CollisionTypeEnum:
        r"""
        (CollisionTypeEnum):  [Read-Write] *  CollisionType defines how to initialize the rigid collision structures.
        deprecated: Use Collision.CollisionType instead.
        """
        ...
    @collision_type.setter
    def collision_type(self, value: CollisionTypeEnum) -> None:
        ...
    @property
    def implicit_type(self) -> ImplicitTypeEnum:
        r"""
        (ImplicitTypeEnum):  [Read-Write] *  CollisionType defines how to initialize the rigid collision structures.
        deprecated: Use Collision.ImplicitType instead.
        """
        ...
    @implicit_type.setter
    def implicit_type(self, value: ImplicitTypeEnum) -> None:
        ...
    @property
    def min_level_set_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 5)
        deprecated: Use Collision.LevelSet.MinLevelSetResolution instead.
        """
        ...
    @min_level_set_resolution.setter
    def min_level_set_resolution(self, value: int) -> None:
        ...
    @property
    def max_level_set_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
        deprecated: Use Collision.LevelSet.MaxLevelSetResolution instead.
        """
        ...
    @max_level_set_resolution.setter
    def max_level_set_resolution(self, value: int) -> None:
        ...
    @property
    def min_cluster_level_set_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 5)
        deprecated: Use Collision.LevelSet.MinClusterLevelSetResolution instead.
        """
        ...
    @min_cluster_level_set_resolution.setter
    def min_cluster_level_set_resolution(self, value: int) -> None:
        ...
    @property
    def max_cluster_level_set_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
        deprecated: Use Collision.LevelSet.MaxClusterLevelSetResolution instead.
        """
        ...
    @max_cluster_level_set_resolution.setter
    def max_cluster_level_set_resolution(self, value: int) -> None:
        ...
    @property
    def collision_object_reduction_percentage(self) -> int:
        r"""
        (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
        deprecated: Use Collision.CollisionObjectReductionPercentage instead.
        """
        ...
    @collision_object_reduction_percentage.setter
    def collision_object_reduction_percentage(self, value: int) -> None:
        ...
    @property
    def collision_particles_fraction(self) -> float:
        r"""
        (float):  [Read-Write] Number of particles on the triangulated surface to use for collisions.
        deprecated: Use Collision.CollisionParticlesFraction instead.
        """
        ...
    @collision_particles_fraction.setter
    def collision_particles_fraction(self, value: float) -> None:
        ...
    @property
    def maximum_collision_particles(self) -> int:
        r"""
        (int32):  [Read-Write] Max number of particles.
        deprecated: Use Collision.MaximumCollisionParticles instead.
        """
        ...
    @maximum_collision_particles.setter
    def maximum_collision_particles(self, value: int) -> None:
        ...

class RecastNavMeshTileGenerationDebug(StructBase):
    r"""
    Recast Nav Mesh Tile Generation Debug
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: RecastNavMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_geometry`` (bool):  [Read-Write] Display the collision used for the navmesh rasterization.
      Note: The visualization is affected by the DrawOffset of the RecastNavmesh owner
    - ``compact_heightfield`` (bool):  [Read-Write]
    - ``compact_heightfield_distances`` (bool):  [Read-Write]
    - ``compact_heightfield_eroded`` (bool):  [Read-Write]
    - ``compact_heightfield_regions`` (bool):  [Read-Write]
    - ``enabled`` (bool):  [Read-Write] If set, the selected internal debug data will be kept during tile generation to be displayed with the navmesh.
    - ``generate_debug_tile_only`` (bool):  [Read-Write] If set, the generator will only generate the tile selected to debug (set in TileCoordinate).
    - ``height_field_render_mode`` (HeightFieldRenderMode):  [Read-Write]
    - ``heightfield_bounds`` (bool):  [Read-Write]
    - ``heightfield_from_rasterization`` (bool):  [Read-Write]
    - ``heightfield_post_height_filtering`` (bool):  [Read-Write]
    - ``heightfield_post_inclusion_bounds_filtering`` (bool):  [Read-Write]
    - ``skip_contour_simplification`` (bool):  [Read-Write] If set, the contour simplification step will be skipped. Beware that enabling this changes the way navmesh will generate when Tile Generation Debug is enabled.
    - ``tile_cache_contours`` (bool):  [Read-Write]
    - ``tile_cache_detail_mesh`` (bool):  [Read-Write]
    - ``tile_cache_layer_areas`` (bool):  [Read-Write]
    - ``tile_cache_layer_regions`` (bool):  [Read-Write]
    - ``tile_cache_poly_mesh`` (bool):  [Read-Write]
    - ``tile_coordinate`` (IntVector):  [Read-Write] Selected tile coordinate, only this tile will have it's internal data kept.
      Tip: displaying the navmesh using 'Draw Tile Labels' show tile coordinates.
    """
    def __init__(self) -> None:
        ...

class NavMeshResolutionParam(StructBase):
    r"""
    Nav Mesh Resolution Param
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: RecastNavMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``agent_max_step_height`` (float):  [Read-Write] Largest vertical step the agent can perform
    - ``cell_height`` (float):  [Read-Write] Vertical size of voxelization cell
    - ``cell_size`` (float):  [Read-Write] Horizontal size of voxelization cell
    """
    def __init__(self) -> None:
        ...

class MovieSceneSectionEvalOptions(StructBase):
    r"""
    Movie Scene Section Eval Options
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``completion_mode`` (MovieSceneCompletionMode):  [Read-Write] When set to "RestoreState", this section will restore any animation back to its previous state
    """
    def __init__(self) -> None:
        ...

class MovieSceneEasingSettings(StructBase):
    r"""
    Movie Scene Easing Settings
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSection.h
    
    """
    def __init__(self) -> None:
        ...

class MovieSceneFrameRange(StructBase):
    r"""
    Type used to convert from a FFloatRange to a TRange<FFrameNumber>
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneFrameMigration.h
    
    """
    def __init__(self) -> None:
        ...

class MovieSceneTrackEvalOptions(StructBase):
    r"""
    Generic evaluation options for any track
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``eval_nearest_section`` (bool):  [Read-Write] When evaluating empty space on a track, will evaluate the last position of the previous section (if possible), or the first position of the next section, in that order of preference.
    - ``evaluate_in_postroll`` (bool):  [Read-Write] Evaluate this track as part of its parent sub-section's post-roll, if applicable
    - ``evaluate_in_preroll`` (bool):  [Read-Write] Evaluate this track as part of its parent sub-section's pre-roll, if applicable
    """
    def __init__(self) -> None:
        ...

class MovieSceneTrackDisplayOptions(StructBase):
    r"""
    Generic display options for any track
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``show_vertical_frames`` (bool):  [Read-Write] Show bounds as vertical frames
    """
    def __init__(self) -> None:
        ...

class VirtualKeyboardOptions(StructBase):
    r"""
    Virtual Keyboard Options
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: IVirtualKeyboardEntry.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_autocorrect`` (bool):  [Read-Write] Enables autocorrect for this widget, if supported by the platform's virtual keyboard. Autocorrect must also be enabled in Input settings for this to take effect.
    """
    def __init__(self) -> None:
        ...

class ExpandableAreaStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SExpandableArea
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collapsed_image`` (SlateBrush):  [Read-Write] Image to use when the area is collapsed
    - ``expanded_image`` (SlateBrush):  [Read-Write] Image to use when the area is expanded
    - ``rollout_animation_seconds`` (float):  [Read-Write] How long the rollout animation lasts
    """
    def __init__(self) -> None:
        ...

class AssetImportInfo(StructBase):
    r"""
    Struct that is used to store an array of asset import data as an asset registry tag
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AssetImportData.h
    
    """
    def __init__(self) -> None:
        ...

class AnimGraphBlendOptions(StructBase):
    r"""
    Blending options for animation graphs in Linked Animation Blueprints.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimClassInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_in_profile`` (BlendProfile):  [Read-Write] Optional blend profile to use when blending this graph in (if BlendInTime > 0)
    - ``blend_in_time`` (float):  [Read-Write] Time to blend this graph in using Inertialization. Specify -1.0 to defer to the BlendOutTime of the previous graph.
      To blend this graph in you must place an Inertialization node after the Linked Anim Graph node or Linked Anim Layer node that uses this graph.
    - ``blend_out_profile`` (BlendProfile):  [Read-Write] Optional blend profile to use when blending this graph out (if BlendOutTime > 0)
    - ``blend_out_time`` (float):  [Read-Write] Time to blend this graph out using Inertialization. Specify -1.0 to defer to the BlendInTime of the next graph.
      To blend this graph out you must place an Inertialization node after the Linked Anim Graph node or Linked Anim Layer node that uses this graph.
    """
    def __init__(self) -> None:
        ...

class OptionalPinFromProperty(StructBase):
    r"""
    Optional Pin from Property
    
    **C++ Source:**
    
    - **Module**: BlueprintGraph
    - **File**: K2Node.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_toggle_visibility`` (bool):  [Read-Write]
    - ``category_name`` (Name):  [Read-Write]
    - ``has_override_pin`` (bool):  [Read-Write]
    - ``is_marked_for_advanced_display`` (bool):  [Read-Write]
    - ``is_override_enabled`` (bool):  [Read-Write] TRUE if the override value is enabled for use
    - ``is_override_pin_visible`` (bool):  [Read-Write] TRUE if the override pin is visible
    - ``is_set_value_pin_visible`` (bool):  [Read-Write] TRUE if the override value should be set through this pin
    - ``property_friendly_name`` (str):  [Read-Write]
    - ``property_is_customized`` (bool):  [Read-Write]
    - ``property_name`` (Name):  [Read-Write]
    - ``property_tooltip`` (Text):  [Read-Write]
    - ``show_pin`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MemberReference(StructBase):
    r"""
    
    TODO:: this can encapsulate globally defined fields as well (like with native delegate signatures); consider renaming to FFieldReference
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MemberReference.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_RefPose(AnimNode_Base):
    r"""
    RefPose pose nodes - ref pose or additive RefPose pose
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RefPose.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_LinkedInputPose(AnimNode_Base):
    r"""
    Anim Node Linked Input Pose
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_LinkedInputPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] The name of this linked input pose node's pose, used to identify the input of this graph.
    """
    def __init__(self) -> None:
        ...

class AnimNode_SubInput(AnimNode_LinkedInputPose):
    r"""
    deprecated: 'AnimNode_SubInput' was renamed to 'AnimNode_LinkedInputPose'.
    """
    def __init__(self) -> None:
        ...

class AnimBlueprintFunctionPinInfo(StructBase):
    r"""
    Required info for reconstructing a manually specified pin
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_LinkedInputPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] The name of this parameter
    - ``type`` (EdGraphPinType):  [Read-Write] The type of this parameter
    """
    def __init__(self) -> None:
        ...

class AnimNode_MeshSpaceRefPose(AnimNode_Base):
    r"""
    Anim Node Mesh Space Ref Pose
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RefPose.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_StateMachine(AnimNode_Base):
    r"""
    State machine node
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNode_StateMachine.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_conduit_entry_states`` (bool):  [Read-Write] Allows a conduit to be used as this state machine's entry state
      If a valid entry state cannot be found at runtime then this will generate a reference pose!
    - ``create_notify_meta_data`` (bool):  [Read-Write] Tag Notifies with meta data such as the active state and mirroring state.  Producing this
      data has a  slight performance cost.
    - ``max_transitions_per_frame`` (int32):  [Read-Write] The maximum number of transitions that can be taken by this machine 'simultaneously' in a single frame
    - ``max_transitions_requests`` (int32):  [Read-Write] The maximum number of transition requests that can be buffered at any time.
      The oldest transition requests are dropped to accommodate for newly created requests.
    - ``reinitialize_on_becoming_relevant`` (bool):  [Read-Write] Reinitialize the state machine if we have become relevant to the graph
      after not being ticked on the previous frame(s)
    - ``skip_first_update_transition`` (bool):  [Read-Write] When the state machine becomes relevant, it is initialized into the Entry state.
      It then tries to take any valid transitions to possibly end up in a different state on that same frame.
      - if true, that new state starts full weight.
      - if false, a blend is created between the entry state and that new state.
      In either case all visited State notifications (Begin/End) will be triggered.
    """
    def __init__(self) -> None:
        ...

class BoneNode(StructBase):
    r"""
    Each Bone node in BoneTree
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Skeleton.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``translation_retargeting_mode`` (BoneTranslationRetargetingMode):  [Read-Write] Retargeting Mode for Translation Component.
    """
    def __init__(self) -> None:
        ...

class MovieSceneCameraShakeSectionData(StructBase):
    r"""
    Movie Scene Camera Shake Section Data
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCameraShakeSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``play_scale`` (float):  [Read-Write] Scalar that affects shake intensity
    - ``play_space`` (CameraShakePlaySpace):  [Read-Write]
    - ``shake_class`` (type(Class)):  [Read-Write] Class of the camera shake to play
    - ``user_defined_play_space`` (Rotator):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MovieSceneConsoleVariableCollection(StructBase):
    r"""
    Movie Scene Console Variable Collection
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCVarSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``interface`` (MovieSceneConsoleVariableTrackInterface):  [Read-Write] Array of console variable preset assets that this track should operate on
    - ``only_include_checked`` (bool):  [Read-Write] Whether to include checked consolve variables or not
    """
    def __init__(self) -> None:
        ...

class MovieSceneCVarOverrides(StructBase):
    r"""
    Movie Scene CVar Overrides
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCVarSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``values_by_c_var`` (Map[str, str]):  [Read-Write] The name of the console variable and the value, separated by ' ' or '=', ie: "foo.bar=1" or "foo.bar 1".
    """
    def __init__(self) -> None:
        ...

class SoundWaveTimecodeInfo(StructBase):
    r"""
    Sound Wave Timecode Info
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundWaveTimecodeInfo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``description`` (str):  [Read-Only]
    - ``num_samples_per_second`` (uint32):  [Read-Only]
    - ``num_samples_since_midnight`` (uint64):  [Read-Only]
    - ``originator_date`` (str):  [Read-Only]
    - ``originator_description`` (str):  [Read-Only]
    - ``originator_reference`` (str):  [Read-Only]
    - ``originator_time`` (str):  [Read-Only]
    - ``timecode_is_drop_frame`` (bool):  [Read-Only]
    - ``timecode_rate`` (FrameRate):  [Read-Only]
    """
    def __init__(self) -> None:
        ...

class SoundWaveCloudStreamingPlatformSettings(StructBase):
    r"""
    Platform specific settings for Sound Wave cloud streaming.
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: ISoundWaveCloudStreaming.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enablement_setting`` (SoundWaveCloudStreamingPlatformEnableType):  [Read-Write] Overrides whether to use cloud streaming on this platform.
    """
    def __init__(self) -> None:
        ...

class IniStringValue(StructBase):
    r"""
    Helper struct for setting string console ini values.
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AssetGuideline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``filename`` (str):  [Read-Write] From .ini, relative to {PROJECT}. Ex: /Config/DefaultEngine.ini
    - ``key`` (str):  [Read-Write] From .ini. Ex: r.GPUSkin.Support16BitBoneIndex
    - ``section`` (str):  [Read-Write] From .ini. Ex: /Script/Engine.RendererSettings
    - ``value`` (str):  [Read-Write] From .ini. Ex: True
    """
    def __init__(self) -> None:
        ...

class AnimSegment(StructBase):
    r"""
    this is anim segment that defines what animation and how *
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCompositeBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_end_time`` (float):  [Read-Write] Time to end playing the AnimSequence at.
    - ``anim_play_rate`` (float):  [Read-Write] Playback speed of this animation. If you'd like to reverse, set -1
    - ``anim_reference`` (AnimSequenceBase):  [Read-Write] Anim Reference to play - only allow AnimSequence or AnimComposite *
    - ``anim_start_time`` (float):  [Read-Write] Time to start playing AnimSequence at.
    - ``cached_play_length`` (float):  [Read-Write]
    - ``looping_count`` (int32):  [Read-Write]
    - ``start_pos`` (float):  [Read-Only] Start Pos within this AnimCompositeBase
    """
    def __init__(self) -> None:
        ...

class CompositeSection(AnimLinkableElement):
    r"""
    Section data for each track. Reference of data will be stored in the child class for the way they want
    AnimComposite vs AnimMontage have different requirement for the actual data reference
    This only contains composite section information. (vertical sequences)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimMontage.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``link_method`` (AnimLinkMethod):  [Read-Write] The method we are using to calculate our times
    - ``linked_sequence`` (AnimSequenceBase):  [Read-Only] The Animation Sequence that this montage element will link to, when the sequence changes
      in either length or rate; the element will correctly place itself in relation to the sequence
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``next_section_name`` (Name):  [Read-Only] Should this animation loop.
    - ``section_name`` (Name):  [Read-Write] Section Name
    - ``slot_index`` (int32):  [Read-Write] The slot index we are currently using within LinkedMontage
    """
    def __init__(self) -> None:
        ...

class EditorParameterGroup(StructBase):
    r"""
    Editor Parameter Group
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialEditorInstanceConstant.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parameters`` (Array[DEditorParameterValue]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MaterialInstanceBasePropertyOverrides(StructBase):
    r"""
    Properties from the base material that can be overridden in material instances.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstanceBasePropertyOverrides.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_mode`` (BlendMode):  [Read-Write] The blend mode
    - ``cast_dynamic_shadow_as_masked`` (bool):  [Read-Write] Whether the material should cast shadows as masked even though it has a translucent blend mode.
    - ``displacement_scaling`` (DisplacementScaling):  [Read-Write]
    - ``dithered_lod_transition`` (bool):  [Read-Write] Whether the material should support a dithered LOD transition when used with the foliage system.
    - ``enable_tessellation`` (bool):  [Read-Write] Whether or not tessellation is enabled. Required for displacement to work.
    - ``has_pixel_animation`` (bool):  [Read-Write] Whether the opaque material has any pixel animations happening, that isn't included in the geometric velocities.
      This allows to disable renderer's heuristics that assumes animation is fully described with motion vector, such as TSR's anti-flickering heuristic.
    - ``is_thin_surface`` (bool):  [Read-Write] Indicates that the material should be rendered as.
    - ``max_world_position_offset_displacement`` (float):  [Read-Write] The maximum World Position Offset distance. Zero means no maximum.
    - ``opacity_mask_clip_value`` (float):  [Read-Write] If BlendMode is BLEND_Masked, the surface is not rendered where OpacityMask < OpacityMaskClipValue.
    - ``output_translucent_velocity`` (bool):  [Read-Write] Whether the material should output velocity even though it has a translucent blend mode.
    - ``override_b_enable_tessellation`` (bool):  [Read-Write] Enables override of the enable tessellation property.
    - ``override_b_has_pixel_animation`` (bool):  [Read-Write] Enables override of the has pixel animation property.
    - ``override_b_is_thin_surface`` (bool):  [Read-Write] Enables override of the IsThinSurface property.
    - ``override_blend_mode`` (bool):  [Read-Write] Enables override of the blend mode.
    - ``override_cast_dynamic_shadow_as_masked`` (bool):  [Read-Write] Enables override of whether to shadow using masked opacity on translucent materials.
    - ``override_displacement_scaling`` (bool):  [Read-Write] Enables override of the displacement magnitude and center property.
    - ``override_dithered_lod_transition`` (bool):  [Read-Write] Enables override of the dithered LOD transition property.
    - ``override_max_world_position_offset_displacement`` (bool):  [Read-Write] Enables override of the max world position offset property.
    - ``override_opacity_mask_clip_value`` (bool):  [Read-Write] Enables override of the opacity mask clip value.
    - ``override_output_translucent_velocity`` (bool):  [Read-Write] Enables override of the output velocity property.
    - ``override_shading_model`` (bool):  [Read-Write] Enables override of the shading model.
    - ``override_two_sided`` (bool):  [Read-Write] Enables override of the two sided property.
    - ``shading_model`` (MaterialShadingModel):  [Read-Write] The shading model
    - ``two_sided`` (bool):  [Read-Write] Indicates that the material should be rendered without backface culling and the normal should be flipped for backfaces.
    """
    def __init__(self) -> None:
        ...

class LightmassParameterizedMaterialSettings(StructBase):
    r"""
    Structure for 'parameterized' Lightmass settings
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: UnrealEdTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cast_shadow_as_masked`` (LightmassBooleanParameterValue):  [Read-Write] If true, forces translucency to cast static shadows as if the material were masked.
    - ``diffuse_boost`` (LightmassScalarParameterValue):  [Read-Write] Scales the diffuse contribution of this material to static lighting.
    - ``emissive_boost`` (LightmassScalarParameterValue):  [Read-Write] Scales the emissive contribution of this material to static lighting.
    - ``export_resolution_scale`` (LightmassScalarParameterValue):  [Read-Write] Scales the resolution that this material's attributes were exported at.
      This is useful for increasing material resolution when details are needed.
    """
    def __init__(self) -> None:
        ...

class LightmassMaterialInterfaceSettings(StructBase):
    r"""
    UMaterial interface settings for Lightmass
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cast_shadow_as_masked`` (bool):  [Read-Write] If true, forces translucency to cast static shadows as if the material were masked.
    - ``diffuse_boost`` (float):  [Read-Write] Scales the diffuse contribution of this material to static lighting.
    - ``export_resolution_scale`` (float):  [Read-Write] Scales the resolution that this material's attributes were exported at.
      This is useful for increasing material resolution when details are needed.
    """
    def __init__(self) -> None:
        ...

class MaterialOverrideNanite(StructBase):
    r"""
    Storage for nanite material override.
    An override material can be selected, and the override material can be used according to the current settings.
    We handle removing the override material and its dependencies from the cook on platforms where we can determine
    that the override material can never be used.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialOverrideNanite.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``override_material_editor`` (MaterialInterface):  [Read-Write] EditorOnly version of the OverrideMaterial reference.
      This is a hard reference, but is editoronly. We rely on -skiponlyeditoronly to avoid pulling this editoronly hard reference into the cook.
    """
    def __init__(self) -> None:
        ...

class ParameterGroupData(StructBase):
    r"""
    Parameter Group Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Material.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``group_name`` (str):  [Read-Only]
    - ``group_sort_priority`` (int32):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class PropertyEditorTestBasicStruct(StructBase):
    r"""
    This structs properties should be pushed out to categories inside its parent category unless it is in an array
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``float_property_inside_a_struct`` (float):  [Read-Write]
    - ``inner_struct`` (PropertyEditorTestSubStruct):  [Read-Write]
    - ``int_property_inside_a_struct`` (int32):  [Read-Write]
    - ``object_property_inside_a_struct`` (Object):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class PropertyEditorTestInstancedStruct(StructBase):
    r"""
    Property Editor Test Instanced Struct
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``object`` (PropertyEditorTestInstancedObject):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class RealCurve(IndexedCurve):
    r"""
    A rich, editable float curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RealCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_value`` (float):  [Read-Write] Default value
    """
    def __init__(self) -> None:
        ...

class RichCurve(RealCurve):
    r"""
    A rich, editable float curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RichCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_value`` (float):  [Read-Write] Default value
    - ``keys`` (Array[RichCurveKey]):  [Read-Write] Sorted array of keys
    """
    def __init__(self) -> None:
        ...

class PropertyEditTestTextStruct(StructBase):
    r"""
    Property Edit Test Text Struct
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``normal_property`` (Text):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class PropertyEditorTestSubStruct(StructBase):
    r"""
    Property Editor Test Sub Struct
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``customized_struct_inside_uncustomized_struct`` (LinearColor):  [Read-Write]
    - ``customized_struct_inside_uncustomized_struct2`` (SoftObjectPath):  [Read-Write]
    - ``first_property`` (int32):  [Read-Write]
    - ``second_property`` (int32):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class PropertyEditorTestEditCondition(StructBase):
    r"""
    Property Editor Test Edit Condition
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled_and_visible_when_one`` (int32):  [Read-Write]
    - ``flags`` (TestEnumFlags):  [Read-Write]
    - ``has_inline_edit_condition`` (int32):  [Read-Write]
    - ``inline_edit_condition`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class InstancedStaticMeshInstanceData(StructBase):
    r"""
    Instanced Static Mesh Instance Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InstancedStaticMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``transform`` (Matrix):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class FoliageVertexColorChannelMask(StructBase):
    r"""
    Foliage Vertex Color Channel Mask
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: FoliageType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``invert_mask`` (bool):  [Read-Write] When unchecked, foliage instances will be placed only when the vertex color in the specified channel(s) is above the threshold amount.
      When checked, the vertex color must be less than the threshold amount
    - ``mask_threshold`` (float):  [Read-Write] Specifies the threshold value above which the static mesh vertex color value must be, in order for foliage instances to be placed in a specific area
    - ``use_mask`` (bool):  [Read-Write] When checked, foliage will be masked from this mesh using this color channel
    """
    def __init__(self) -> None:
        ...

class FoliageDensityFalloff(StructBase):
    r"""
    Foliage Density Falloff
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: FoliageType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``falloff_curve`` (RuntimeFloatCurve):  [Read-Write] Density as a function of normalized distance (i.e. distance from Procedural Foliage Volume / Max Volume Extent).
      X = 0 corresponds to Normalized distance = 0, X = 1 corresponds to Normalized distance = Max distance.
      Y = 0 corresponds to 0% probability of keeping instance, Y = 1 corresponds to 100% probability of keeping instance.
    - ``use_falloff_curve`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class FoliageTypeObject(StructBase):
    r"""
    A wrapper struct used to allow the use of either FoliageType assets or FoliageType blueprint classes
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: FoliageTypeObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``foliage_type_object`` (Object):  [Read-Write] The foliage type that will be spawned by the procedural foliage simulation
    """
    def __init__(self) -> None:
        ...

class ProceduralFoliageTypeData(FoliageTypeObject):
    r"""
    deprecated: 'ProceduralFoliageTypeData' was renamed to 'FoliageTypeObject'.
    """
    def __init__(self) -> None:
        ...

class LandscapePerLODMaterialOverride(StructBase):
    r"""
    Landscape Per LODMaterial Override
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``lod_index`` (int32):  [Read-Write]
    - ``material`` (MaterialInterface):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class LandscapeSplineSegmentConnection(StructBase):
    r"""
    Landscape Spline Segment Connection
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeSplineSegment.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``socket_name`` (Name):  [Read-Write] Socket on the control point that we are connected to
    - ``tangent_len`` (float):  [Read-Write] Tangent length of the connection
    """
    def __init__(self) -> None:
        ...

class LandscapeSplineMeshEntry(StructBase):
    r"""
    Landscape Spline Mesh Entry
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeSplineSegment.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``center_adjust`` (Vector2D):  [Read-Write] Tweak to center the mesh correctly on the spline
    - ``center_h`` (bool):  [Read-Write] Whether to automatically center the mesh horizontally on the spline
    - ``forward_axis`` (SplineMeshAxis):  [Read-Write] Chooses the forward axis for the spline mesh orientation
    - ``material_overrides`` (Array[MaterialInterface]):  [Read-Write] Overrides mesh's materials
    - ``mesh`` (StaticMesh):  [Read-Write] Mesh to use on the spline
    - ``scale`` (Vector):  [Read-Write] Scale of the spline mesh, (Z=Forwards)
    - ``scale_to_width`` (bool):  [Read-Write] Whether to scale the mesh to fit the width of the spline
    - ``up_axis`` (SplineMeshAxis):  [Read-Write] Chooses the up axis for the spline mesh orientation
    """
    def __init__(self) -> None:
        ...

class GrassInput(StructBase):
    r"""
    Grass Input
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeGrassOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``grass_type`` (LandscapeGrassType):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class LayerBlendInput(StructBase):
    r"""
    Layer Blend Input
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeLayerBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_type`` (LandscapeLayerBlendType):  [Read-Write]
    - ``const_height_input`` (float):  [Read-Write] only used if HeightInput is not hooked up
    - ``const_layer_input`` (Vector):  [Read-Write] only used if LayerInput is not hooked up
    - ``layer_name`` (Name):  [Read-Write]
    - ``preview_weight`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class PhysicalMaterialInput(StructBase):
    r"""
    Structure linking a material expression input with a physical material. For use by UMaterialExpressionLandscapePhysicalMaterialOutput.
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapePhysicalMaterialOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``physical_material`` (PhysicalMaterial):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class InterpolationParameter(StructBase):
    r"""
    Interpolation Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``damping_ratio`` (float):  [Read-Write] Damping ratio - only used when the type is set to SpringDamper. A value of 1 will move quickly and
      smoothly to the target, without overshooting. Values as low as 0 can be used to encourage some overshoot,
      and values around 0.7 can make pose transitions look more natural.
    - ``interpolation_time`` (float):  [Read-Write] Smoothing Time used to move smoothly across the blendpsace from the current parameters to the target
      parameters. The different Smoothing Types will treat this in different ways, but in general a value of
      zero will disable all smoothing, and larger values will smooth more.
    - ``interpolation_type`` (FilterInterpolationType):  [Read-Write] Type of smoothing used for filtering the input value to decide how to get to target.
    - ``max_speed`` (float):  [Read-Write] Maximum speed, in real units. For example, if this axis is degrees then you could use a value of 90 to
      limit the turn rate to 90 degrees per second. Only used when greater than zero and the type is
      set to SpringDamper or Exponential.
    """
    def __init__(self) -> None:
        ...

class PerBoneInterpolation(StructBase):
    r"""
    Per Bone Interpolation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_reference`` (BoneReference):  [Read-Write]
    - ``interpolation_speed_per_sec`` (float):  [Read-Write] If greater than zero, this is the speed at which the sample weights are allowed to change for this specific bone.
      
      A speed of 1 means a sample weight can change from zero to one (or one to zero) in one second.
      A speed of 2 means that this would take half a second.
      
      Smaller values mean slower adjustments of the sample weights, and thus more smoothing. However, a
      value of zero disables this smoothing entirely.
      
      If set, the value overrides the overall Sample Weight Speed which will no longer affect this bone.
    """
    def __init__(self) -> None:
        ...

class BlendSpaceBlendProfile(StructBase):
    r"""
    Blend Space Blend Profile
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_profile`` (BlendProfile):  [Read-Write]
    - ``target_weight_interpolation_speed_per_sec`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class BlendSample(StructBase):
    r"""
    Sample data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animation`` (AnimSequence):  [Read-Write] For linked animations
    - ``include_in_analyse_all`` (bool):  [Read-Write] Whether or not this sample will be moved when the "analyse all" button is used. Note that, even if disabled,
      it will still be available for individual sample analysis/moving
    - ``rate_scale`` (float):  [Read-Write]
    - ``sample_value`` (Vector):  [Read-Write] blend 0->x, blend 1->y, blend 2->z
    """
    def __init__(self) -> None:
        ...

class BlendParameter(StructBase):
    r"""
    Blend Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (str):  [Read-Write]
    - ``grid_num`` (int32):  [Read-Write] The number of grid divisions along this axis.
    - ``max`` (float):  [Read-Write] Maximum value for this axis range.
    - ``min`` (float):  [Read-Write] Minimum value for this axis range.
    - ``snap_to_grid`` (bool):  [Read-Write] If true then samples will always be snapped to the grid on this axis when added, moved, or the axes are changed.
    - ``wrap_input`` (bool):  [Read-Write] If true then the input can go outside the min/max range and the blend space is treated as being cyclic on this axis. If false then input parameters are clamped to the min/max values on this axis.
    """
    def __init__(self) -> None:
        ...

class ExternalDataLayerUID(StructBase):
    r"""
    External Data Layer UID
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ExternalDataLayerUID.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value`` (uint32):  [Read-Only]
    """
    def __init__(self) -> None:
        ...

class HapticFeedbackDetails_Curve(StructBase):
    r"""
    Haptic Feedback Details Curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HapticFeedbackEffect_Curve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``amplitude`` (RuntimeFloatCurve):  [Read-Write] The amplitude to vibrate the haptic device at.  Amplitudes are normalized over the range [0.0, 1.0], with 1.0 being the max setting of the device
    - ``frequency`` (RuntimeFloatCurve):  [Read-Write] The frequency to vibrate the haptic device at.  Frequency ranges vary by device!
    """
    def __init__(self) -> None:
        ...

class HapticFeedbackDetails(HapticFeedbackDetails_Curve):
    r"""
    deprecated: 'HapticFeedbackDetails' was renamed to 'HapticFeedbackDetails_Curve'.
    """
    def __init__(self) -> None:
        ...

class ParameterChannelNames(StructBase):
    r"""
    Parameter Channel Names
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (Text):  [Read-Write]
    - ``b`` (Text):  [Read-Write]
    - ``g`` (Text):  [Read-Write]
    - ``r`` (Text):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class CustomInput(StructBase):
    r"""
    Custom Input
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCustom.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input_name`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class CustomOutput(StructBase):
    r"""
    Custom Output
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCustom.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``output_name`` (Name):  [Read-Write]
    - ``output_type`` (CustomMaterialOutputType):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class CustomDefine(StructBase):
    r"""
    Custom Define
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCustom.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``define_name`` (str):  [Read-Write]
    - ``define_value`` (str):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class DataDrivenShaderPlatformInfoInput(StructBase):
    r"""
    Data Driven Shader Platform Info Input
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDataDrivenShaderPlatformInfoSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input_name`` (Name):  [Read-Write]
    - ``property_condition`` (DataDrivenShaderPlatformInfoCondition):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MaterialLayersFunctionsRuntimeData(StructBase):
    r"""
    Material Layers Functions Runtime Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialLayersFunctions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blends`` (Array[MaterialFunctionInterface]):  [Read-Write]
    - ``layers`` (Array[MaterialFunctionInterface]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MaterialLayersFunctions(MaterialLayersFunctionsRuntimeData):
    r"""
    Material Layers Functions
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialLayersFunctions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blends`` (Array[MaterialFunctionInterface]):  [Read-Write]
    - ``editor_only`` (MaterialLayersFunctionsEditorOnlyData):  [Read-Write]
    - ``layers`` (Array[MaterialFunctionInterface]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class CompositeReroute(StructBase):
    r"""
    Collection of pins used for tunneling between graphs.
    Utilizes reroute expressions to ensure zero overhead in the compiled material.
    
         _________________          _________________
        |   INPUT BASE    |        |   OUTPUT BASE   |
        +--------+--------+        +--------+--------+
        |        |   (>)  |   ->   |  (>)   |        |
        |        |   (>)  |        |  (>)   |        |
        |        |   (>)  |        |  (>)   |        |
        |        |   (>)  |        |  (>)   |        |
        |        |        |        |        |        |
        +--------+--------+        +--------+--------+
        | NODE IN:  NONE  |        | NODE IN:  PINS  |
        | NODE OUT: PINS  |        | NODE OUT: NONE  |
        |_________________|        |_________________|
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPinBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class SwitchCustomInput(StructBase):
    r"""
    Switch Custom Input
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input_name`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class StaticParameterBase(StructBase):
    r"""
    Base parameter properties
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StaticParameterSet.h
    
    """
    def __init__(self) -> None:
        ...

class StaticSwitchParameter(StaticParameterBase):
    r"""
    Holds the information for a static switch parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StaticParameterSet.h
    
    """
    def __init__(self) -> None:
        ...

class StaticComponentMaskParameter(StaticParameterBase):
    r"""
    Holds the information for a static component mask parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StaticParameterSet.h
    
    """
    def __init__(self) -> None:
        ...

class NetworkPhysicsSettings(StructBase):
    r"""
    Network Physics Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NetworkPhysicsSettingsComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``override_sim_proxy_rep_mode`` (bool):  [Read-Write]
    - ``sim_proxy_rep_mode`` (PhysicsReplicationMode):  [Read-Write] Override the EPhysicsReplicationMode if Actor is ENetRole::ROLE_SimulatedProxy and has EPhysicsReplicationMode::Resimulation set
    """
    def __init__(self) -> None:
        ...

class NetworkPhysicsSettingsPredictiveInterpolation(StructBase):
    r"""
    Network Physics Settings Predictive Interpolation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NetworkPhysicsSettingsComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disable_soft_snap`` (bool):  [Read-Write]
    - ``override_disable_soft_snap`` (bool):  [Read-Write] np2.PredictiveInterpolation.DisableSoftSnap
    - ``override_pos_correction_time_base`` (bool):  [Read-Write] np2.PredictiveInterpolation.PosCorrectionTimeBase
    - ``override_pos_correction_time_min`` (bool):  [Read-Write] np2.PredictiveInterpolation.PosCorrectionTimeMin
    - ``override_pos_correction_time_multiplier`` (bool):  [Read-Write] np2.PredictiveInterpolation.PosCorrectionTimeMultiplier
    - ``override_pos_interpolation_time_multiplier`` (bool):  [Read-Write] np2.PredictiveInterpolation.InterpolationTimeMultiplier
    - ``override_post_resim_wait_for_update`` (bool):  [Read-Write] np2.PredictiveInterpolation.PostResimWaitForUpdate
    - ``override_rot_correction_time_base`` (bool):  [Read-Write] np2.PredictiveInterpolation.RotCorrectionTimeBase
    - ``override_rot_correction_time_min`` (bool):  [Read-Write] np2.PredictiveInterpolation.RotCorrectionTimeMin
    - ``override_rot_correction_time_multiplier`` (bool):  [Read-Write] np2.PredictiveInterpolation.RotCorrectionTimeMultiplier
    - ``override_rot_interpolation_time_multiplier`` (bool):  [Read-Write] np2.PredictiveInterpolation.RotInterpolationTimeMultiplier
    - ``override_skip_velocity_rep_on_pos_early_out`` (bool):  [Read-Write] np2.PredictiveInterpolation.SkipVelocityRepOnPosEarlyOut
    - ``override_soft_snap_pos_strength`` (bool):  [Read-Write] np2.PredictiveInterpolation.SoftSnapPosStrength
    - ``override_soft_snap_rot_strength`` (bool):  [Read-Write] np2.PredictiveInterpolation.SoftSnapRotStrength
    - ``override_soft_snap_to_source`` (bool):  [Read-Write] np2.PredictiveInterpolation.SoftSnapToSource
    - ``pos_correction_time_base`` (float):  [Read-Write]
    - ``pos_correction_time_min`` (float):  [Read-Write]
    - ``pos_correction_time_multiplier`` (float):  [Read-Write]
    - ``pos_interpolation_time_multiplier`` (float):  [Read-Write]
    - ``post_resim_wait_for_update`` (bool):  [Read-Write]
    - ``rot_correction_time_base`` (float):  [Read-Write]
    - ``rot_correction_time_min`` (float):  [Read-Write]
    - ``rot_correction_time_multiplier`` (float):  [Read-Write]
    - ``rot_interpolation_time_multiplier`` (float):  [Read-Write]
    - ``skip_velocity_rep_on_pos_early_out`` (bool):  [Read-Write]
    - ``soft_snap_pos_strength`` (float):  [Read-Write]
    - ``soft_snap_rot_strength`` (float):  [Read-Write]
    - ``soft_snap_to_source`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NetworkPhysicsSettingsResimulation(StructBase):
    r"""
    Network Physics Settings Resimulation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NetworkPhysicsSettingsComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ang_vel_stability_multiplier`` (float):  [Read-Write]
    - ``compare_input_to_trigger_rewind`` (bool):  [Read-Write]
    - ``compare_state_to_trigger_rewind`` (bool):  [Read-Write]
    - ``override_ang_vel_stability_multiplier`` (bool):  [Read-Write] np2.Resim.AngVelStabilityMultiplier
    - ``override_compare_input_to_trigger_rewind`` (bool):  [Read-Write] np2.Resim.CompareInputToTriggerRewind
    - ``override_compare_state_to_trigger_rewind`` (bool):  [Read-Write] np2.Resim.CompareStateToTriggerRewind
    - ``override_pos_stability_multiplier`` (bool):  [Read-Write] np2.Resim.PosStabilityMultiplier
    - ``override_redundant_inputs`` (bool):  [Read-Write] Override how many inputs to synchronize each sync to cover packet loss.
    - ``override_redundant_states`` (bool):  [Read-Write] Override how many states to synchronize each sync to cover packet loss.
    - ``override_resimulation_error_threshold`` (bool):  [Read-Write] Project Settings -> Physics -> Replication -> Physics Prediction -> Resimulation Error Threshold
    - ``override_rot_stability_multiplier`` (bool):  [Read-Write] np2.Resim.RotStabilityMultiplier
    - ``override_runtime_correction_enabled`` (bool):  [Read-Write] np2.Resim.RuntimeCorrectionEnabled
    - ``override_runtime_velocity_correction`` (bool):  [Read-Write] np2.Resim.RuntimeVelocityCorrection
    - ``override_vel_stability_multiplier`` (bool):  [Read-Write] np2.Resim.VelStabilityMultiplier
    - ``pos_stability_multiplier`` (float):  [Read-Write]
    - ``redundant_inputs`` (uint8):  [Read-Write]
    - ``redundant_states`` (uint8):  [Read-Write]
    - ``resimulation_error_threshold`` (uint32):  [Read-Write]
    - ``rot_stability_multiplier`` (float):  [Read-Write]
    - ``runtime_correction_enabled`` (bool):  [Read-Write]
    - ``runtime_velocity_correction`` (bool):  [Read-Write]
    - ``vel_stability_multiplier`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class ParticleSystemLOD(StructBase):
    r"""
    Structure containing per-LOD settings that pertain to the entire UParticleSystem.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystem.h
    
    """
    def __init__(self) -> None:
        ...

class NamedEmitterMaterial(StructBase):
    r"""
    Named Emitter Material
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``material`` (MaterialInterface):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class RawDistribution(StructBase):
    r"""
    Base class for raw (baked out) Distribution type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Distribution.h
    
    """
    def __init__(self) -> None:
        ...

class RawDistributionVector(RawDistribution):
    r"""
    Raw Distribution Vector
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DistributionVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distribution`` (DistributionVector):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class RawDistributionFloat(RawDistribution):
    r"""
    Raw Distribution Float
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DistributionFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``distribution`` (DistributionFloat):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class ParticleRandomSeedInfo(StructBase):
    r"""
    Particle Random Seed Info
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleModule.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``get_seed_from_instance`` (bool):  [Read-Write] If true, the module will attempt to get the seed from the owner
      instance. If that fails, it will fall back to getting it from
      the RandomSeeds array.
    - ``instance_seed_is_index`` (bool):  [Read-Write] If true, the seed value retrieved from the instance will be an
      index into the array of seeds.
    - ``parameter_name`` (Name):  [Read-Write] The name to expose to the placed instances for setting this seed
    - ``random_seeds`` (Array[int32]):  [Read-Write] The random seed values to utilize for the module.
      More than 1 means the instance will randomly select one.
    - ``randomly_select_seed_array`` (bool):  [Read-Write] If true, then randomly select a seed entry from the RandomSeeds array
    - ``reset_seed_on_emitter_looping`` (bool):  [Read-Write] If true, then reset the seed upon the emitter looping.
      For looping environmental effects this should likely be set to false to avoid
      a repeating pattern.
    """
    def __init__(self) -> None:
        ...

class HierarchicalSimplification(StructBase):
    r"""
    Hierarchical Simplification
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_specific_exclusion`` (bool):  [Read-Write]
    - ``approximate_settings`` (MeshApproximationSettings):  [Read-Write] Approximate settings, used if SimplificationMethod is Approximate
    - ``desired_bound_radius`` (float):  [Read-Write] Desired Bounding Radius for clustering - this is not guaranteed but used to calculate filling factor for auto clustering
    - ``desired_filling_percentage`` (float):  [Read-Write] Desired Filling Percentage for clustering - this is not guaranteed but used to calculate filling factor  for auto clustering
    - ``merge_setting`` (MeshMergingSettings):  [Read-Write] Merge settings, used if SimplificationMethod is Merge
    - ``min_number_of_actors_to_build`` (int32):  [Read-Write] Min number of actors to build LODActor
    - ``only_generate_clusters_for_volumes`` (bool):  [Read-Write] Only generate clusters for HLOD volumes
    - ``override_draw_distance`` (float):  [Read-Write]
    - ``proxy_setting`` (MeshProxySettings):  [Read-Write] Simplification settings, used if SimplificationMethod is Simplify
    - ``reuse_previous_level_clusters`` (bool):  [Read-Write] Will reuse the clusters generated for the previous (lower) HLOD level
    - ``simplification_method`` (HierarchicalSimplificationMethod):  [Read-Write]
    - ``simplify_mesh`` (bool):  [Read-Write]
      deprecated: Property 'bSimplifyMesh' is deprecated.
    - ``transition_screen_size`` (float):  [Read-Write] The screen radius an mesh object should reach before swapping to the LOD actor, once one of parent displays, it won't draw any of children.
    - ``use_override_draw_distance`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...
    @property
    def simplify_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: Property 'bSimplifyMesh' is deprecated.
        """
        ...
    @simplify_mesh.setter
    def simplify_mesh(self, value: bool) -> None:
        ...

class NaniteSettings(StructBase):
    r"""
    Nanite Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_masked_materials`` (bool):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class BroadphaseSettings(StructBase):
    r"""
    Settings pertaining to which PhysX broadphase to use, and settings for MBP if that is the chosen broadphase type
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``mbp_bounds`` (Box):  [Read-Write] Total bounds for MBP, must cover the game world or collisions are disabled for out of bounds actors
    - ``mbp_num_subdivs`` (uint32):  [Read-Write] Number of times to subdivide the MBP bounds, final number of regions is MBPNumSubdivs^2
    - ``mbp_outer_bounds`` (Box):  [Read-Write] Total bounds for MBP, should cover absolute maximum bounds of the game world where physics is required
    - ``use_mbp_on_client`` (bool):  [Read-Write] Whether to use MBP (Multi Broadphase Pruning
    - ``use_mbp_on_server`` (bool):  [Read-Write]
    - ``use_mbp_outer_bounds`` (bool):  [Read-Write] Whether to have MBP grid over concentrated inner bounds with loose outer bounds
    """
    def __init__(self) -> None:
        ...

class TimecodeCustomAttributeNameSettings(StructBase):
    r"""
    Settings that identify the names of custom attributes that represent the individual components of a timecode and a subframe along with a take name.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CustomAttributes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_attribute_name`` (Name):  [Read-Write] Name of the custom attribute representing the frame component of a timecode.
    - ``hour_attribute_name`` (Name):  [Read-Write] Name of the custom attribute representing the hour component of a timecode.
    - ``minute_attribute_name`` (Name):  [Read-Write] Name of the custom attribute representing the minute component of a timecode.
    - ``rate_attribute_name`` (Name):  [Read-Write] Name of the custom attribute representing the timecode rate. This may be different from
                the animation or capture frame rate, for example when capturing "high" frame rate data
                    at 120 frames per second but recording SMPTE timecode at 30 frames per second.
    - ``second_attribute_name`` (Name):  [Read-Write] Name of the custom attribute representing the second component of a timecode.
    - ``subframe_attribute_name`` (Name):  [Read-Write] Name of the custom attribute representing a subframe value. Though not strictly a component
                    of a timecode, this attribute can be authored to identify samples in between timecodes.
    - ``takename_attribute_name`` (Name):  [Read-Write] Name of the custom attribute representing the name of a take.
    """
    def __init__(self) -> None:
        ...

class CustomAttributeSetting(StructBase):
    r"""
    Custom Attribute Setting
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CustomAttributes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``meaning`` (str):  [Read-Write] Optional property describing the meaning (or role) of the custom attribute, allowing to add context to an attribute
    - ``name`` (str):  [Read-Write] Name of the custom attribute
    """
    def __init__(self) -> None:
        ...

class MirrorFindReplaceExpression(StructBase):
    r"""
    Find and Replace expressions used to generate mirror tables
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MirrorDataTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``find_expression`` (Name):  [Read-Write]
    - ``find_replace_method`` (MirrorFindReplaceMethod):  [Read-Write]
    - ``replace_expression`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class TimeStretchCurve(StructBase):
    r"""
    = Time Stretch Curve =
    
    = What is it?
    
            The Time Stretch Curve is an optional float curve that montages can
            use to define where a montage is allowed to speed up or slow down.
            Let's say we have a montage of default play time T_Original.
            We now want that montage to play for a different T_Target play time
            Typically we would uniformly play rate the animation to reach that goal.
    
            The Time Stretch Curve allows doing the same thing but non uniformly,
            by defining which regions can be play rated more or less.
    
            The Curve values are normalized.
            So a Curve value of 0 means "don't play rate this".
            And a Curve value of 1 means "play rate this the most".
            Intermediate values will be weighted accordingly.
    
            Imagine the following scenario, you have a character attacking with a staff.
            The animation is authored with holds after striking.
            Let's say the character levels up over the course of the game, and
            their attacks are getting faster and faster (play time is shorter).
    
            By using a Time Stretch Curve, most of the time compression could happen
            during the holds. So the strikes look mostly unaffected.
            This allows using a single animation, and scaling it for very different
            desired play times.
    
    = How does it work?
    
            Given a Montage of length T_Original, and a float curve C.
            Curve C is sampled over N segments of fixed time 'SamplingTimeStep'.
            Each element, C_i is normalized. 0 <= C_i <= 1
            and 0 <= i <= N.
    
            We have Sum(SamplingTimeStep) = T_Original = N * SamplingTimeStep
            SamplingTimeStep = T_Original / N
    
            Given a different length T_Target,
            C remaps positions from T_Target to T_Original according to the following function:
            dTO = dT_i * U * (1 + S * C_i)
            where:
            Sum(dTO) = T_Original
            Sum(dT_i) = T_Target
            U = UniformPlayRate
            S = Curve Scale Factor
            C_i = sampled curve value, constant over the interval dTO
    
            dTO is fixed, based on the chosen 'SamplingTimeStep',
            but in practice we can combine consecutive segments that have the same C_i value.
    
            We would like U to be 1 (or -1) as much as possible.
            Meaning the Curve should do all the remapping whenever possible.
            U(niformPlayRate) should only come into play when C can't remap T_Target to T_Original on its own.
            This can happen when trying to speed up the animation,
            but the Curve is not enough to reach that time compression.
            In that event, uniform scaling kicks in.
    
            We call PR_i (or OverallPlayRate for Segment i)
            PR_i = U * (1 + S * C_i)
            dTO = dT_i * PR_i
    
            We also want PR_i > 0, that is it should never backtrack or pause during playback of animation.
            A Montage can still play in reverse with U < 0.
    
    = How is T_Target defined?
    
            When we play a Montage with a PlayRate of PR, we assume this means:
            T_Target = T_Original * PR
            So this system does not change the interface for playing a montage.
    
            If a curve is not defined, the mapping is defined as:
            dTO_i = dT_i * U
    
            If a a curve is defined:
            dTO_i = dT_i * U * (1 + S * C_i)
    
            We can see that no curve means S == 0.
            Also if we're not scaling the montage, T_Target == T_Original, we also have S == 0.
    
            So, this makes the curve completely optional. And it seamlessly integrates with the current montage interface.
            If you want playback time to be half, that means playing the montage with a play rate of 2.
            If there is a TimeStretchCurve, it will be used.
            But regardless or using a curve or not, play back time is guaranteed.
    
    = Finding U and S =
    
            Ideally, we could figure out what U and S are given a T_Target play time.
            Unfortunately, the math for this is very complex.
    
            We update the montage position like this:
            dTO_i = dT_i * U * (1 + C_i)
    
            We sum this over the N time segments:
            Sum(dTO_i) = Sum(dT_i * U * (1 + C_i))
            Sum(dTO_i) = Sum(dT_i) * U + Sum(dT_i * U * S * C_i))
            T_Original = T_Target * U + U * S * Sum(dT_i * C_i)
    
            Where:
            S = (T_Original - T_Target * U) / (U * Sum(dT_i * C_i))
    
            If we were able to get dT_i constant, we could pull it out and get:
            S = (T_Original - T_Target * U) / (U * dT * Sum(C_i))
            Where Sum(C_i) can be pre-computed.
    
            Unfortunately we don't have dT_i constant, and we can't,
            since it is variable, and dependent on what S and U are.
    
            So our approach instead is to precompute lower and upper bounds for this curve.
            We cache the results for dT_i for S = 100.f and S = -1.f + 0.01f
            This gives us data for T_Target_Min and T_Target_Max.
            Within these bounds, we can approximate dT_i, and also Sum(dT_i * C_i) by linear interpolation.
            Outside of these bounds, we rely on U to get us to our desired T_Target play back time.
    
            'ConditionallyUpdateTimeStretchCurveCachedData' takes care of figuring out U and S
            based on a given T_Target play back time.
    
    = 'target' and 'original' space
    
            At run time, we generate a set of markers in what we call 'target' and 'original' space.
            'original' space means in the original play time the montage was authored in.
            So that maps to actual frames of animation and actual position in the montage.
    
            'target' space is the same set of markers, but mapped in play back time.
            That is the actual time it takes to play back this montage.
    
            Taking our play rate equation from above, it is:
            dT_Original = dT_Target * U * (1 + S * C_i)
    
            We see that montage position = playback time * play rate.
    
            Once we have mapped our markers in both 'target' and 'original' space,
            we can easily go from one to the other, since time moves linearly between markers.
            Since between markers the play rate is defined as constant values:
            PR_i = U * (1.f + S * C_i).
            And we know that C_i is constant between two markers.
    
            So if we know between which markers we are in one space, we can switch to the other space instantly,
            as our relative position between these markers will be the same.
    
            So by jumping between these spaces, we can quickly go from a montage position to its playback time.
            We can increase the playback time by the current's frame deltatime,
            and jump back to the corresponding frame of animation.
            That's in a nutshell how this system works.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimeStretchCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve_value_min_precision`` (float):  [Read-Write] Minimum delta allowed between consecutive sampled segments.
      below this value, segments will be combined
      to optimize number of markers.
    - ``markers`` (Array[TimeStretchCurveMarker]):  [Read-Only] Optimized list of markers.
    - ``sampling_rate`` (float):  [Read-Write] Desired Sampling rate of above curve.
      This will be rounded off so we sample the whole curve
      with a fixed time step.
    - ``sum_d_t_i_by_c_i`` (float):  [Read-Only] Cached Sum(dT_i * C_i)
    """
    def __init__(self) -> None:
        ...

class CustomAttributePerBoneData(StructBase):
    r"""
    Custom Attribute Per Bone Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CustomAttributes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attributes`` (Array[CustomAttribute]):  [Read-Only]
    - ``bone_tree_index`` (int32):  [Read-Only]
    """
    def __init__(self) -> None:
        ...

class NodeItem(StructBase):
    r"""
    Node Information to save with
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NodeMappingProviderInterface.h
    
    """
    def __init__(self) -> None:
        ...

class PreviewMeshCollectionEntry(StructBase):
    r"""
    An entry in a preview mesh collection
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PreviewMeshCollection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_blueprint`` (AnimBlueprint):  [Read-Write] The custom animation blueprint for the mesh
    - ``skeletal_mesh`` (SkeletalMesh):  [Read-Write] The skeletal mesh to display
    """
    def __init__(self) -> None:
        ...

class LightmassLightSettings(StructBase):
    r"""
    Per-light settings for Lightmass
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``indirect_lighting_saturation`` (float):  [Read-Write] 0 will be completely desaturated, 1 will be unchanged
    - ``shadow_exponent`` (float):  [Read-Write] Controls the falloff of shadow penumbras
    - ``use_area_shadows_for_stationary_light`` (bool):  [Read-Write] Whether to use area shadows for stationary light precomputed shadowmaps.
      Area shadows get softer the further they are from shadow casters, but require higher lightmap resolution to get the same quality where the shadow is sharp.
    """
    def __init__(self) -> None:
        ...

class LightmassDirectionalLightSettings(LightmassLightSettings):
    r"""
    Directional light settings for Lightmass
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``indirect_lighting_saturation`` (float):  [Read-Write] 0 will be completely desaturated, 1 will be unchanged
    - ``light_source_angle`` (float):  [Read-Write] Angle that the directional light's emissive surface extends relative to a receiver, affects penumbra sizes.
    - ``shadow_exponent`` (float):  [Read-Write] Controls the falloff of shadow penumbras
    - ``use_area_shadows_for_stationary_light`` (bool):  [Read-Write] Whether to use area shadows for stationary light precomputed shadowmaps.
      Area shadows get softer the further they are from shadow casters, but require higher lightmap resolution to get the same quality where the shadow is sharp.
    """
    def __init__(self) -> None:
        ...

class LightmassPointLightSettings(LightmassLightSettings):
    r"""
    Point/spot settings for Lightmass
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``indirect_lighting_saturation`` (float):  [Read-Write] 0 will be completely desaturated, 1 will be unchanged
    - ``shadow_exponent`` (float):  [Read-Write] Controls the falloff of shadow penumbras
    - ``use_area_shadows_for_stationary_light`` (bool):  [Read-Write] Whether to use area shadows for stationary light precomputed shadowmaps.
      Area shadows get softer the further they are from shadow casters, but require higher lightmap resolution to get the same quality where the shadow is sharp.
    """
    def __init__(self) -> None:
        ...

class PerPlatformBool(StructBase):
    r"""
    FPerPlatformBool - bool property with per-platform overrides
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PerPlatformProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default`` (bool):  [Read-Write]
    - ``per_platform`` (Map[Name, bool]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class SplineCurves(StructBase):
    r"""
    Spline Curves
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SplineComponent.h
    
    """
    def __init__(self) -> None:
        ...

class SplineMeshParams(StructBase):
    r"""
    Structure that holds info about spline, passed to renderer to deform UStaticMesh.
    Also used by Lightmass, so be sure to update Lightmass::FSplineMeshParams and the static lighting code if this changes!
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SplineMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_offset`` (Vector2D):  [Read-Write] Ending offset of the mesh from the spline, in component space.
    - ``end_pos`` (Vector):  [Read-Write] End location of spline, in component space.
    - ``end_roll`` (float):  [Read-Write] Roll around spline applied at end, in radians.
    - ``end_scale`` (Vector2D):  [Read-Write] X and Y scale applied to mesh at end of spline.
    - ``end_tangent`` (Vector):  [Read-Write] End tangent of spline, in component space.
    - ``nanite_cluster_bounds_scale`` (float):  [Read-Write] How much to scale the calculated culling bounds of Nanite clusters after deformation.
      NOTE: This should only be set greater than 1.0 if it fixes visible issues with clusters being
      incorrectly culled.
    - ``start_offset`` (Vector2D):  [Read-Write] Starting offset of the mesh from the spline, in component space.
    - ``start_pos`` (Vector):  [Read-Write] Start location of spline, in component space.
    - ``start_roll`` (float):  [Read-Write] Roll around spline applied at start, in radians.
    - ``start_scale`` (Vector2D):  [Read-Write] X and Y scale applied to mesh at start of spline.
    - ``start_tangent`` (Vector):  [Read-Write] Start tangent of spline, in component space.
    """
    def __init__(self) -> None:
        ...

class DialogueContextMapping(StructBase):
    r"""
    Dialogue Context Mapping
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DialogueWave.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``context`` (DialogueContext):  [Read-Write] The context of the dialogue.
    - ``localization_key_format`` (str):  [Read-Write] The format string to use when generating the localization key for this context. This must be unique within the owner dialogue wave.
      Available format markers:
        * {ContextHash} - A hash generated from the speaker and target voices.
    - ``sound_wave`` (SoundWave):  [Read-Write] The soundwave to play for this dialogue.
    """
    def __init__(self) -> None:
        ...

class FontCharacter(StructBase):
    r"""
    This struct is serialized using native serialization so any changes to it require a package version bump.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Font.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``start_u`` (int32):  [Read-Write]
    - ``start_v`` (int32):  [Read-Write]
    - ``texture_index`` (uint8):  [Read-Write]
    - ``u_size`` (int32):  [Read-Write]
    - ``v_size`` (int32):  [Read-Write]
    - ``vertical_offset`` (int32):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class FontImportOptionsData(StructBase):
    r"""
    Font import options
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: FontImportOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha_only`` (bool):  [Read-Write] if true then forces PF_G8 and only maintains Alpha value and discards color
    - ``character_set`` (FontImportCharacterSet):  [Read-Write] Character set for this font
    - ``chars`` (str):  [Read-Write] Explicit list of characters to include in the font
    - ``chars_file_path`` (str):  [Read-Write] Path on disk to a folder where files that contain a list of characters to include in the font
    - ``chars_file_wildcard`` (str):  [Read-Write] File mask wildcard that specifies which files within the CharsFilePath to scan for characters in include in the font
    - ``create_printable_only`` (bool):  [Read-Write] Skips generation of glyphs for any characters that are not considered 'printable'
    - ``distance_field_scale_factor`` (int32):  [Read-Write] Scale factor determines how big to scale the font bitmap during import when generating distance field values
      Note that higher values give better quality but importing will take much longer.
    - ``distance_field_scan_radius_scale`` (float):  [Read-Write] Shrinks or expands the scan radius used to determine the silhouette of the font edges.
    - ``enable_antialiasing`` (bool):  [Read-Write] Whether the font should be antialiased or not.  Usually you should leave this enabled.
    - ``enable_bold`` (bool):  [Read-Write] Whether the font should be generated in bold or not
    - ``enable_drop_shadow`` (bool):  [Read-Write] Enables a very simple, 1-pixel, black colored drop shadow for the generated font
    - ``enable_italic`` (bool):  [Read-Write] Whether the font should be generated in italics or not
    - ``enable_legacy_mode`` (bool):  [Read-Write] Enables legacy font import mode.  This results in lower quality antialiasing and larger glyph bounds, but may be useful when debugging problems
    - ``enable_underline`` (bool):  [Read-Write] Whether the font should be generated with an underline or not
    - ``extend_box_bottom`` (int32):  [Read-Write] How much to extend the bottom of the UV coordinate rectangle for each character in pixels
    - ``extend_box_left`` (int32):  [Read-Write] How much to extend the left of the UV coordinate rectangle for each character in pixels
    - ``extend_box_right`` (int32):  [Read-Write] How much to extend the right of the UV coordinate rectangle for each character in pixels
    - ``extend_box_top`` (int32):  [Read-Write] How much to extend the top of the UV coordinate rectangle for each character in pixels
    - ``font_name`` (str):  [Read-Write] Name of the typeface for the font to import
    - ``foreground_color`` (LinearColor):  [Read-Write] Color of the foreground font pixels.  Usually you should leave this white and instead use the UI Styles editor to change the color of the font on the fly
    - ``height`` (float):  [Read-Write] Height of font (point size)
    - ``include_ascii_range`` (bool):  [Read-Write] When specifying a range of characters and this is enabled, forces ASCII characters (0 thru 255) to be included as well
    - ``kerning`` (int32):  [Read-Write] The initial horizontal spacing adjustment between rendered characters.  This setting will be copied directly into the generated Font object's properties.
    - ``texture_page_max_height`` (int32):  [Read-Write] The maximum vertical size of a texture page for this font in pixels.  The actual height of a texture page may be less than this if the font can fit within a smaller sized texture page.
    - ``texture_page_width`` (int32):  [Read-Write] Horizontal size of each texture page for this font in pixels
    - ``unicode_range`` (str):  [Read-Write] Range of Unicode character values to include in the font.  You can specify ranges using hyphens and/or commas (e.g. '400-900')
    - ``use_distance_field_alpha`` (bool):  [Read-Write] If true then the alpha channel of the font textures will store a distance field instead of a color mask
    - ``x_padding`` (int32):  [Read-Write] Horizontal padding between each font character on the texture page in pixels
    - ``y_padding`` (int32):  [Read-Write] Vertical padding between each font character on the texture page in pixels
    """
    def __init__(self) -> None:
        ...

class CompositeFont(StructBase):
    r"""
    Composite Font
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: CompositeFont.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_ascent_descent_override`` (bool):  [Read-Write] If set to false, the ascent and descent override specified in a Font face will be ignored, and the value from the font source file will be used instead.
    """
    def __init__(self) -> None:
        ...

class ForceFeedbackChannelDetails(StructBase):
    r"""
    Force Feedback Channel Details
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ForceFeedbackEffect.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affects_left_large`` (bool):  [Read-Write] Please note the final channel mapping depends on the software and hardware capabilities of the platform used to run the engine or the game. Refer to documentation for more information.
    - ``affects_left_small`` (bool):  [Read-Write] Please note the final channel mapping depends on the software and hardware capabilities of the platform used to run the engine or the game. Refer to documentation for more information.
    - ``affects_right_large`` (bool):  [Read-Write] Please note the final channel mapping depends on the software and hardware capabilities of the platform used to run the engine or the game. Refer to documentation for more information.
    - ``affects_right_small`` (bool):  [Read-Write] Please note the final channel mapping depends on the software and hardware capabilities of the platform used to run the engine or the game. Refer to documentation for more information.
    - ``curve`` (RuntimeFloatCurve):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class ForceFeedbackEffectOverridenChannelDetails(StructBase):
    r"""
    A wrapper struct for setting channel details on a per-platform basis
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ForceFeedbackEffect.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_details`` (Array[ForceFeedbackChannelDetails]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class TouchInputControl(StructBase):
    r"""
    Touch Input Control
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TouchInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alt_input_key`` (Key):  [Read-Write] The alternate input to send from this control (for sticks, this is the vertical axis)
    - ``center`` (Vector2D):  [Read-Write] The initial center point of the control. If Time Until Reset is < 0, control resets back to here.
      Use negative numbers to invert positioning from top to bottom, left to right. (if <= 1.0, it's relative to screen, > 1.0 is absolute)
    - ``image1`` (Texture2D):  [Read-Write] For sticks, this is the Thumb
    - ``image2`` (Texture2D):  [Read-Write] For sticks, this is the Background
    - ``input_scale`` (Vector2D):  [Read-Write] The scale for control input
    - ``interaction_size`` (Vector2D):  [Read-Write] The interactive size of the control. Measured outward from Center. (if <= 1.0, it's relative to screen, > 1.0 is absolute)
    - ``main_input_key`` (Key):  [Read-Write] The main input to send from this control (for sticks, this is the horizontal axis)
    - ``thumb_size`` (Vector2D):  [Read-Write] For sticks, the size of the thumb (if <= 1.0, it's relative to screen, > 1.0 is absolute)
    - ``treat_as_button`` (bool):  [Read-Write] Set this to true to treat the joystick as a simple button
    - ``visual_size`` (Vector2D):  [Read-Write] The size of the control (if <= 1.0, it's relative to screen, > 1.0 is absolute)
    """
    def __init__(self) -> None:
        ...

class WorldPartitionActorFilter(StructBase):
    r"""
    World Partition Actor Filter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionActorFilter.h
    
    """
    def __init__(self) -> None:
        ...

class CollectionParameterBase(StructBase):
    r"""
    Base struct for collection parameters
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialParameterCollection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter.  Changing this name will break any blueprints that reference the parameter.
    """
    def __init__(self) -> None:
        ...

class CollectionScalarParameter(CollectionParameterBase):
    r"""
    A scalar parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialParameterCollection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_value`` (float):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter.  Changing this name will break any blueprints that reference the parameter.
    """
    def __init__(self) -> None:
        ...

class CollectionVectorParameter(CollectionParameterBase):
    r"""
    A vector parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialParameterCollection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_value`` (LinearColor):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter.  Changing this name will break any blueprints that reference the parameter.
    """
    def __init__(self) -> None:
        ...

class ConstrainComponentPropName(StructBase):
    r"""
    Struct used to specify the property name of the component to constrain
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``component_name`` (Name):  [Read-Write] Name of property
    """
    def __init__(self) -> None:
        ...

class ConstraintInstanceBase(StructBase):
    r"""
    Constraint Instance Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintInstance.h
    
    """
    def __init__(self) -> None:
        ...

class ConstraintInstance(ConstraintInstanceBase):
    r"""
    Container for a physics representation of an object.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_rotation_offset`` (Rotator):  [Read-Write] Specifies the angular offset between the two frames of reference. By default limit goes from (-Angle, +Angle)
      This allows you to bias the limit for swing1 swing2 and twist.
    - ``constraint_bone1`` (Name):  [Read-Write] Name of first bone (body) that this constraint is connecting.
      This will be the 'child' bone in a PhysicsAsset.
    - ``constraint_bone2`` (Name):  [Read-Write] Name of second bone (body) that this constraint is connecting.
      This will be the 'parent' bone in a PhysicsAset.
    - ``joint_name`` (Name):  [Read-Only] Name of bone that this joint is associated with.
    - ``pos1`` (Vector):  [Read-Write] Location of constraint in Body1 reference frame (usually the "child" body for skeletal meshes).
    - ``pos2`` (Vector):  [Read-Write] Location of constraint in Body2 reference frame (usually the "parent" body for skeletal meshes).
    - ``pri_axis1`` (Vector):  [Read-Write] Primary (twist) axis in Body1 reference frame.
    - ``pri_axis2`` (Vector):  [Read-Write] Primary (twist) axis in Body2 reference frame.
    - ``profile_instance`` (ConstraintProfileProperties):  [Read-Write] Constraint Data (properties easily swapped at runtime based on different constraint profiles)
    - ``scale_linear_limits`` (bool):  [Read-Write] If true, linear limits scale using the absolute min of the 3d scale of the owning component
    - ``sec_axis1`` (Vector):  [Read-Write] Secondary axis in Body1 reference frame. Orthogonal to PriAxis1.
    - ``sec_axis2`` (Vector):  [Read-Write] Secondary axis in Body2 reference frame. Orthogonal to PriAxis2.
    """
    def __init__(self) -> None:
        ...

class PhysicsPredictionSettings(StructBase):
    r"""
    Physics Prediction Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_physics_prediction`` (bool):  [Read-Write] Enable networked physics prediction (experimental)
      Note: If an AActor::PhysicsReplicationMode is set to use Resimulation this will allow physics to cache history which is required by resimulation replication.
      Note: This can also affect how physics is solved even when not using resimulation.
    - ``enable_physics_resimulation`` (bool):  [Read-Write] Forces the PlayerController to sync inputs as used in Physics Prediction.
      Only enable this if actively using a custom solution that needs this enabled for resimulation.
      This is automatically enabled when using the recommended NetworkPhysicsComponent on a pawn to handle Rewind / Resimulation.
    - ``max_supported_latency_prediction`` (float):  [Read-Write] Amount of RTT (Round Trip Time) latency for the prediction to support in milliseconds.
    - ``resimulation_error_threshold`` (float):  [Read-Write] Distance in centimeters before a state discrepancy triggers a resimulation
    """
    def __init__(self) -> None:
        ...

class RigidBodyErrorCorrection(StructBase):
    r"""
    Rigid body error correction data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angle_lerp`` (float):  [Read-Write] How much to directly lerp to the correct angle.
    - ``angular_velocity_coefficient`` (float):  [Read-Write] This is the angular analog to LinearVelocityCoefficient.
    - ``error_accumulation_distance_sq`` (float):  [Read-Write] If the body has moved less than the square root of
                    this amount towards a resolved state in the previous
                    frame, then error may accumulate towards a hard snap.
    - ``error_accumulation_seconds`` (float):  [Read-Write] Number of seconds to remain in a heuristically
                    unresolveable state before hard snapping.
    - ``error_accumulation_similarity`` (float):  [Read-Write] If the previous error projected onto the current error
                    is greater than this value (indicating "similarity"
                    between states), then error may accumulate towards a
                    hard snap.
    - ``error_per_angular_difference`` (float):  [Read-Write] Error per degree
    - ``error_per_linear_difference`` (float):  [Read-Write] Error per centimeter
    - ``linear_velocity_coefficient`` (float):  [Read-Write] This is the coefficient `k` in the differential equation:
                    dx/dt = k ( x_target(t) - x(t) ), which is used to update
                    the velocity in a replication step.
    - ``max_linear_hard_snap_distance`` (float):  [Read-Write]
    - ``max_restored_state_error`` (float):  [Read-Write] Maximum allowable error for a state to be considered "resolved"
    - ``ping_extrapolation`` (float):  [Read-Write] Value between 0 and 1 which indicates how much velocity
                    and ping based correction to use
    - ``ping_limit`` (float):  [Read-Write] For the purpose of extrapolation, ping will be clamped to this value
    - ``position_lerp`` (float):  [Read-Write] How much to directly lerp to the correct position. Generally
                    this should be very low, if not zero. A higher value will
                    increase precision along with jerkiness.
    """
    def __init__(self) -> None:
        ...

class PhysicalSurfaceName(StructBase):
    r"""
    Structure that represents the name of physical surfaces.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsSettings.h
    
    """
    def __init__(self) -> None:
        ...

class ChaosPhysicsSettings(StructBase):
    r"""
    Settings container for Chaos physics engine settings, accessed in Chaos through a setting provider interface.
    See: IChaosSettingsProvider
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``dedicated_thread_buffer_mode`` (ChaosBufferMode):  [Read-Write] The buffering mode to use when running with a dedicated thread
    - ``dedicated_thread_tick_mode`` (ChaosSolverTickMode):  [Read-Write] The framerate/timestep ticking mode when running with a dedicated thread
    - ``default_threading_model`` (ChaosThreadingMode):  [Read-Write] Default threading model to use on module initialisation. Can be switched at runtime using p.Chaos.ThreadingModel
    """
    def __init__(self) -> None:
        ...

class PrimaryAssetRules(StructBase):
    r"""
    Structure defining rules for what to do with assets, this is defined per type and can be overridden per asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AssetManagerTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_recursively`` (bool):  [Read-Write] If true, this rule will apply to all referenced Secondary Assets recursively, as long as they are not managed by a higher-priority Primary Asset.
    - ``chunk_id`` (int32):  [Read-Write] Assets will be put into this Chunk ID specifically, if set to something other than -1. The default Chunk is Chunk 0.
    - ``cook_rule`` (PrimaryAssetCookRule):  [Read-Write] Rule describing when this asset should be cooked.
    - ``priority`` (int32):  [Read-Write] Primary Assets with a higher priority will take precedence over lower priorities when assigning management for referenced assets. If priorities match, both will manage the same Secondary Asset.
    """
    def __init__(self) -> None:
        ...

class BoneMirrorInfo(StructBase):
    r"""
    Bone Mirror Info
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_flip_axis`` (AxisType):  [Read-Write] Axis the bone is mirrored across.
    - ``source_index`` (int32):  [Read-Write] The bone to mirror.
    """
    def __init__(self) -> None:
        ...

class SkeletalMeshLODInfo(StructBase):
    r"""
    Struct containing information for a particular LOD level, such as materials and info for when to use it.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedAssetCommon.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_cpu_access`` (bool):  [Read-Write] Keeps this LODs data on the CPU so it can be used for things such as sampling in FX.
    - ``allow_mesh_deformer`` (bool):  [Read-Write] Whether a Mesh Deformer applied to the mesh asset or Skinned Mesh Component should be used on this LOD or not
    - ``bake_pose`` (AnimSequence):  [Read-Write] Pose which should be used to reskin vertex influences for which the bones will be removed in this LOD level, uses ref-pose by default
    - ``bake_pose_override`` (AnimSequence):  [Read-Write] This is used when you are sharing the LOD settings, but you'd like to override the BasePose. This precedes prior to BakePose
    - ``bones_to_prioritize`` (Array[BoneReference]):  [Read-Write] Bones which should be prioritized for the quality, this will be weighted toward keeping source data. Use WeightOfPrioritization to control the value.
    - ``bones_to_remove`` (Array[BoneReference]):  [Read-Write] Bones which should be removed from the skeleton for the LOD level
    - ``build_half_edge_buffers`` (bool):  [Read-Write] If true, we will cache/cook half edge data that provides vertex connectivity information across material sections, which
      may be useful for other systems like Mesh Deformer.
    - ``build_settings`` (SkeletalMeshBuildSettings):  [Read-Write] build settings to apply when building render data.
    - ``lod_hysteresis`` (float):  [Read-Write] Used to avoid 'flickering' when on LOD boundary. Only taken into account when moving from complex->simple.
    - ``morph_target_position_error_tolerance`` (float):  [Read-Write] The Morph target position error tolerance in microns. Larger values result in better compression and lower memory footprint, but also lower quality.
    - ``reduction_settings`` (SkeletalMeshOptimizationSettings):  [Read-Write] Reduction settings to apply when building render data.
    - ``screen_size`` (PerPlatformFloat):  [Read-Write] ScreenSize to display this LOD.
      The screen size is based around the projected diameter of the bounding
      sphere of the model. i.e. 0.5 means half the screen's maximum dimension.
    - ``sections_to_prioritize`` (Array[SectionReference]):  [Read-Write] Sections which should be prioritized for the quality, this will be weighted toward keeping source data. Use WeightOfPrioritization to control the value.
    - ``skin_cache_usage`` (SkinCacheUsage):  [Read-Write] How this LOD uses the skin cache feature. Auto will defer to the default project global option. If Support Ray Tracing is enabled on the mesh, will imply Enabled
    - ``source_import_filename`` (str):  [Read-Only] The filename of the file tha was used to import this LOD if it was not auto generated.
    - ``support_uniformly_distributed_sampling`` (bool):  [Read-Write] Mesh supports uniformly distributed sampling in constant time.
      Memory cost is 8 bytes per triangle.
      Example usage is uniform spawning of particles.
    - ``vertex_attributes`` (Array[SkeletalMeshVertexAttributeInfo]):  [Read-Write] List of vertex attributes to include for rendering and what type they should be
    - ``weight_of_prioritization`` (float):  [Read-Write] How much to consideration to give BonesToPrioritize and SectionsToPrioritize.  The weight is an additional vertex simplification penalty where 0 means nothing.
    """
    def __init__(self) -> None:
        ...

class SkeletalMeshSamplingInfo(StructBase):
    r"""
    Skeletal Mesh Sampling Info
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshSampling.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``regions`` (Array[SkeletalMeshSamplingRegion]):  [Read-Write] Info defining sampling of named regions on this mesh.
    """
    def __init__(self) -> None:
        ...

class SkinWeightProfileInfo(StructBase):
    r"""
    Structure storing user facing properties, and is used to identify profiles at the SkeletalMesh level
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinWeightProfile.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_profile`` (PerPlatformBool):  [Read-Write] Whether or not this Profile should be considered the Default loaded for specific LODs rather than the original Skin Weights of the Skeletal Mesh
    - ``default_profile_from_lod_index`` (PerPlatformInt):  [Read-Write] When DefaultProfile is set any LOD below this LOD Index will override the Skin Weights of the Skeletal Mesh with the Skin Weights from this Profile
    - ``name`` (Name):  [Read-Write] Name of the Skin Weight Profile
    - ``per_lod_source_files`` (Map[int32, str]):  [Read-Only]
    """
    def __init__(self) -> None:
        ...

class SkeletalMeshLODGroupSettings(StructBase):
    r"""
    Skeletal Mesh LODGroup Settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshLODSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_mesh_deformer`` (bool):  [Read-Write] Whether a Mesh Deformer applied to the mesh asset or Skinned Mesh Component should be used on this LOD or not
    - ``bake_pose`` (AnimSequence):  [Read-Write] Pose which should be used to reskin vertex influences for which the bones will be removed in this LOD level, uses ref-pose by default
    - ``bone_filter_action_option`` (BoneFilterActionOption):  [Read-Write] Bones which should be removed from the skeleton for the LOD level
    - ``bone_list`` (Array[BoneFilter]):  [Read-Write] Bones which should be removed from the skeleton for the LOD level
    - ``bones_to_prioritize`` (Array[Name]):  [Read-Write] Bones which should be prioritized for the quality, this will be weighted toward keeping source data. Use WeightOfPrioritization to control the value.
    - ``lod_hysteresis`` (float):  [Read-Write] Used to avoid 'flickering' when on LOD boundary. Only taken into account when moving from complex->simple.
    - ``reduction_settings`` (SkeletalMeshOptimizationSettings):  [Read-Write] The optimization settings to use for the respective LOD level
    - ``screen_size`` (PerPlatformFloat):  [Read-Write] The screen sizes to use for the respective LOD level
    - ``sections_to_prioritize`` (Array[int32]):  [Read-Write] Sections which should be prioritized for the quality, this will be weighted toward keeping source data. Use WeightOfPrioritization to control the value.
    - ``weight_of_prioritization`` (float):  [Read-Write] How much to consideration to give BonesToPrioritize and SectionsToPrioritize.  The weight is an additional vertex simplification penalty where 0 means nothing.
    """
    def __init__(self) -> None:
        ...

class AudioEffectParameters(StructBase):
    r"""
    Audio Effect Parameters
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundMix.h
    
    """
    def __init__(self) -> None:
        ...

class AudioEQEffect(AudioEffectParameters):
    r"""
    Audio EQEffect
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundMix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bandwidth0`` (float):  [Read-Write] Bandwidth of band 0. Region is center frequency +/- Bandwidth /2
    - ``bandwidth1`` (float):  [Read-Write] Bandwidth of band 1. Region is center frequency +/- Bandwidth /2
    - ``bandwidth2`` (float):  [Read-Write] Bandwidth of band 2. Region is center frequency +/- Bandwidth /2
    - ``bandwidth3`` (float):  [Read-Write] Bandwidth of band 3. Region is center frequency +/- Bandwidth /2
    - ``frequency_center0`` (float):  [Read-Write] Center frequency in Hz for band 0
    - ``frequency_center1`` (float):  [Read-Write] Center frequency in Hz for band 1
    - ``frequency_center2`` (float):  [Read-Write] Center frequency in Hz for band 2
    - ``frequency_center3`` (float):  [Read-Write] Center frequency in Hz for band 3
    - ``gain0`` (float):  [Read-Write] Boost/cut of band 0
    - ``gain1`` (float):  [Read-Write] Boost/cut of band 1
    - ``gain2`` (float):  [Read-Write] Boost/cut of band 2
    - ``gain3`` (float):  [Read-Write] Boost/cut of band 3
    """
    def __init__(self) -> None:
        ...

class DialogueWaveParameter(StructBase):
    r"""
    Dialogue Wave Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DialogueTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``context`` (DialogueContext):  [Read-Write] The context to use for the dialogue wave.
    - ``dialogue_wave`` (DialogueWave):  [Read-Write] The dialogue wave to play.
    """
    def __init__(self) -> None:
        ...

class DistanceDatum(StructBase):
    r"""
    Distance Datum
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeDistanceCrossFade.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``fade_in_distance_end`` (float):  [Read-Write] The distance at which this sound has faded in completely.
    - ``fade_in_distance_start`` (float):  [Read-Write] The FadeInDistance at which to start hearing this sound.
             * If you want to hear the sound up close then setting this to 0 might be a good option.
    - ``fade_out_distance_end`` (float):  [Read-Write] The distance at which this sound is no longer audible.
    - ``fade_out_distance_start`` (float):  [Read-Write] The distance at which this sound starts fading out.
    - ``volume`` (float):  [Read-Write] The volume for which this Input should be played.
    """
    def __init__(self) -> None:
        ...

class BPVariableMetaDataEntry(StructBase):
    r"""
    One metadata entry for a variable
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Blueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_key`` (Name):  [Read-Write] Name of metadata key
    - ``data_value`` (str):  [Read-Write] Name of metadata value
    """
    def __init__(self) -> None:
        ...

class InputAxisConfigEntry(StructBase):
    r"""
    Configurable properties for control axes.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerInput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis_key_name`` (Name):  [Read-Only] Axis Key these properties apply to
    - ``axis_properties`` (InputAxisProperties):  [Read-Write] Properties for the Axis Key
    """
    def __init__(self) -> None:
        ...

class PerPlatformSettings(StructBase):
    r"""
    Per Platform Settings
    
    **C++ Source:**
    
    - **Module**: DeveloperSettings
    - **File**: PlatformSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (Array[PlatformSettings]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MovieSceneBaseCacheParams(StructBase):
    r"""
    Base class for the cache parameters that will be used in all the cache sections
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneBaseCacheSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_frame_offset`` (FrameNumber):  [Read-Write] The offset into the end of the animation clip
    - ``first_loop_start_frame_offset`` (FrameNumber):  [Read-Write] The offset for the first loop of the animation clip
    - ``play_rate`` (float):  [Read-Write] The playback rate of the animation clip
    - ``reverse`` (bool):  [Read-Write] Reverse the playback of the animation clip
    - ``start_frame_offset`` (FrameNumber):  [Read-Write] The offset into the beginning of the animation clip
    """
    def __init__(self) -> None:
        ...

class MovieSceneChaosCacheParams(MovieSceneBaseCacheParams):
    r"""
    Movie Scene Chaos Cache Params
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCaching
    - **File**: MovieSceneChaosCacheSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cache_collection`` (ChaosCacheCollection):  [Read-Write] The animation this section plays
    - ``end_frame_offset`` (FrameNumber):  [Read-Write] The offset into the end of the animation clip
    - ``first_loop_start_frame_offset`` (FrameNumber):  [Read-Write] The offset for the first loop of the animation clip
    - ``play_rate`` (float):  [Read-Write] The playback rate of the animation clip
    - ``reverse`` (bool):  [Read-Write] Reverse the playback of the animation clip
    - ``start_frame_offset`` (FrameNumber):  [Read-Write] The offset into the beginning of the animation clip
    """
    def __init__(self) -> None:
        ...

class DatasmithImportInfo(StructBase):
    r"""
    Structure that fill the same role as FAssetImportInfo, but for SourceUri.
    Eventually, the SourceUri should be directly added to FAssetImportInfo and replace the "RelativeFilename".
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    """
    def __init__(self) -> None:
        ...

class RigVMEdGraphDisplaySettings(StructBase):
    r"""
    Rig VMEd Graph Display Settings
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMBlueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_determine_range`` (bool):  [Read-Write]
    - ``average_frames`` (int32):  [Read-Write] If you set this to more than 1 the results will be averaged across multiple frames
    - ``max_duration_color`` (LinearColor):  [Read-Write] The color of the slowest instruction / node
    - ``max_micro_seconds`` (double):  [Read-Write] The duration in microseconds of the slowest instruction / node
    - ``min_duration_color`` (LinearColor):  [Read-Write] The color of the fastest instruction / node
    - ``min_micro_seconds`` (double):  [Read-Write] The duration in microseconds of the fastest instruction / node
    - ``node_run_limit`` (int32):  [Read-Write] A upper limit for counts for nodes used for debugging.
      If a node reaches this count a warning will be issued for the
      node and displayed both in the execution stack as well as in the
      graph. Setting this to <= 1 disables the warning.
      Note: The count limit doesn't apply to functions / collapse nodes.
    - ``node_run_lower_bound`` (int32):  [Read-Write] A lower limit for counts for nodes used for debugging.
      Any node lower than this count won't show the run count.
    - ``show_node_instruction_index`` (bool):  [Read-Write] When enabled shows the first node instruction index
      matching the execution stack window.
    - ``show_node_run_counts`` (bool):  [Read-Write] When enabled shows the node counts both in the graph view as
      we as in the execution stack window.
      The number on each node represents how often the node has been run.
      Keep in mind when looking at nodes in a function the count
      represents the sum of all counts for each node based on all
      references of the function currently running.
    - ``total_micro_seconds`` (double):  [Read-Only] The total duration of the last execution of the rig
    """
    def __init__(self) -> None:
        ...

class RigGraphDisplaySettings(RigVMEdGraphDisplaySettings):
    r"""
    deprecated: 'RigGraphDisplaySettings' was renamed to 'RigVMEdGraphDisplaySettings'.
    """
    def __init__(self) -> None:
        ...

class RigVMRuntimeSettings(StructBase):
    r"""
    Rig VMRuntime Settings
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMExecuteContext.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_profiling`` (bool):  [Read-Write] When enabled records the timing of each instruction / node
      on each node and within the execution stack window.
      Keep in mind when looking at nodes in a function the duration
      represents the accumulated duration of all invocations
      of the function currently running.
      
      Note: This can only be used when in Debug Mode. Click the "Release" button
      in the top toolbar to switch to Debug mode.
    - ``maximum_array_size`` (int32):  [Read-Write] The largest allowed size for arrays within the RigVM.
      Accessing or creating larger arrays will cause runtime errors in the rig.
    """
    def __init__(self) -> None:
        ...

class RigVMPythonSettings(StructBase):
    r"""
    DECLARE_DELEGATE_RetVal(URigVMGraph*, FRigVMBlueprintGetFocusedGraph);
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMBlueprint.h
    
    """
    def __init__(self) -> None:
        ...

class ControlRigPythonSettings(RigVMPythonSettings):
    r"""
    deprecated: 'ControlRigPythonSettings' was renamed to 'RigVMPythonSettings'.
    """
    def __init__(self) -> None:
        ...

class PlatformInterfaceDelegateResult(StructBase):
    r"""
    Generic structure for returning most any kind of data from C++ to delegate functions
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlatformInterfaceBase.h
    
    """
    def __init__(self) -> None:
        ...

class BranchingPointNotifyPayload(StructBase):
    r"""
    Branching Point Notify Payload
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotify.h
    
    """
    def __init__(self) -> None:
        ...

class AssetMapping(StructBase):
    r"""
    This defines one asset mapping
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AssetMappingTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source_asset`` (AnimationAsset):  [Read-Write] source asset *
    - ``target_asset`` (AnimationAsset):  [Read-Write] source asset *
    """
    def __init__(self) -> None:
        ...

class MovieSceneBindingOverrideData(StructBase):
    r"""
    Movie scene binding override data
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneBindingOverrides.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``object`` (Object):  [Read-Write] Specifies the object to override the binding with.
    - ``object_binding_id`` (MovieSceneObjectBindingID):  [Read-Write] Specifies the object binding to override.
    - ``overrides_default`` (bool):  [Read-Write] Specifies whether the default assignment should remain bound (false) or if this should completely override the default binding (true).
    """
    def __init__(self) -> None:
        ...

class HLODProxyMesh(StructBase):
    r"""
    A mesh proxy entry
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODProxyMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``key`` (Name):  [Read-Only] The key generated from an ALODActor. If this differs from that generated from the ALODActor, then the mesh needs regenerating.
    - ``static_mesh`` (StaticMesh):  [Read-Only] The mesh used to display this proxy
    """
    def __init__(self) -> None:
        ...

class KAggregateGeom(StructBase):
    r"""
    Container for an aggregate of collision shapes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AggregateGeom.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``box_elems`` (Array[KBoxElem]):  [Read-Write]
    - ``convex_elems`` (Array[KConvexElem]):  [Read-Write]
    - ``level_set_elems`` (Array[KLevelSetElem]):  [Read-Write]
    - ``skinned_level_set_elems`` (Array[KSkinnedLevelSetElem]):  [Read-Write]
    - ``sphere_elems`` (Array[KSphereElem]):  [Read-Write]
    - ``sphyl_elems`` (Array[KSphylElem]):  [Read-Write]
    - ``tapered_capsule_elems`` (Array[KTaperedCapsuleElem]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class CacheSpawnableTemplate(StructBase):
    r"""
    Cache Spawnable Template
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCaching
    - **File**: ChaosCache.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``component_transform`` (Transform):  [Read-Only]
    - ``duplicated_template`` (Object):  [Read-Only]
    - ``initial_transform`` (Transform):  [Read-Only]
    """
    def __init__(self) -> None:
        ...

class ResponseChannel(StructBase):
    r"""
    Describes response for a single collision response channel
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel`` (Name):  [Read-Write] This should match DisplayName of ECollisionChannel
          Meta data of custom channels can be used as well
    - ``response`` (CollisionResponseType):  [Read-Write] Describes how the channel behaves
    """
    def __init__(self) -> None:
        ...

class BranchFilter(StructBase):
    r"""
    Branch Filter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BoneMaskFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_depth`` (int32):  [Read-Write] Blend Depth *
    - ``bone_name`` (Name):  [Read-Write] Bone Name to filter *
    """
    def __init__(self) -> None:
        ...

class PoseDriverTransform(StructBase):
    r"""
    Translation and rotation for a particular bone at a particular target
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_PoseDriver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``target_rotation`` (Rotator):  [Read-Write] Rotation of this target
    - ``target_translation`` (Vector):  [Read-Write] Translation of this target
    """
    def __init__(self) -> None:
        ...

class AnimPhysConstraintSetup(StructBase):
    r"""
    Constraint setup struct, holds data required to build a physics constraint
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_AnimDynamics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_constraint_type`` (AnimPhysAngularConstraintType):  [Read-Write] Method to use when constraining angular motion
    - ``angular_limits_max`` (Vector):  [Read-Write]
    - ``angular_limits_min`` (Vector):  [Read-Write]
    - ``angular_target`` (Vector):  [Read-Write] The axis to align the angular spring constraint to in the animation pose.
      This typically points down the bone - so values of (1.0, 0.0, 0.0) are common,
      but you can pick other values to align the spring to a different direction.
      Note: This is affected by the Angular Spring Constant.
    - ``angular_target_axis`` (AnimPhysTwistAxis):  [Read-Write] The axis in the simulation pose to align to the Angular Target.
      This is typically the axis pointing along the bone.
      Note: This is affected by the Angular Spring Constant.
    - ``cone_angle`` (float):  [Read-Write] Angle to use when constraining using a cone
    - ``linear_axes_max`` (Vector):  [Read-Write] Maximum linear movement per-axis (Set zero here and in the min limit to lock)
    - ``linear_axes_min`` (Vector):  [Read-Write] Minimum linear movement per-axis (Set zero here and in the max limit to lock)
    - ``linear_x_limit_type`` (AnimPhysLinearConstraintType):  [Read-Write] Whether to limit the linear X axis
    - ``linear_y_limit_type`` (AnimPhysLinearConstraintType):  [Read-Write] Whether to limit the linear Y axis
    - ``linear_z_limit_type`` (AnimPhysLinearConstraintType):  [Read-Write] Whether to limit the linear Z axis
    - ``twist_axis`` (AnimPhysTwistAxis):  [Read-Write] Axis to consider for twist when constraining angular motion (forward axis)
    """
    def __init__(self) -> None:
        ...

class SocketReference(StructBase):
    r"""
    Socket Reference
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BoneSocketReference.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``socket_name`` (Name):  [Read-Write] Target socket to look at. Used if LookAtBone is empty. - You can use  LookAtLocation if you need offset from this point. That location will be used in their local space. *
    """
    def __init__(self) -> None:
        ...

class TakeRecorderPropertyTrackSettings(StructBase):
    r"""
    Take Recorder Property Track Settings
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: IMovieSceneTrackRecorderHost.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``component_path`` (str):  [Read-Write] Optional ActorComponent tag (when keying a component property).
    - ``property_path`` (str):  [Read-Write] Path to the keyed property within the Actor or ActorComponent.
    """
    def __init__(self) -> None:
        ...

class GeometryCollectionCollisionTypeData(StructBase):
    r"""
    Geometry Collection Collision Type Data
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_margin_fraction`` (float):  [Read-Write] A collision margin is a fraction of size used by some boxes and convex shapes to improve collision detection results.
      The core geometry of shapes that support a margin are reduced in size by the margin, and the margin
      is added back on during collision detection. The net result is a shape of the same size but with rounded corners.
    - ``collision_object_reduction_percentage`` (float):  [Read-Write] *  Uniform scale on the collision body. (def: 0)
    - ``collision_particles`` (GeometryCollectionCollisionParticleData):  [Read-Write] *  Collision Particle data for surface samples during Particle-LevelSet collisions.
    - ``collision_type`` (CollisionTypeEnum):  [Read-Write] *  CollisionType defines how to initialize the rigid collision structures.
    - ``implicit_type`` (ImplicitTypeEnum):  [Read-Write] *  CollisionType defines how to initialize the rigid collision structures.
    - ``level_set`` (GeometryCollectionLevelSetData):  [Read-Write] *  LevelSet Resolution data for rasterization.
    """
    def __init__(self) -> None:
        ...

class LightmassParameterValue(StructBase):
    r"""
    Base LightmassParameterValue class
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: UnrealEdTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``override`` (bool):  [Read-Write] If true, override the given parameter with the given settings
    """
    def __init__(self) -> None:
        ...

class LightmassBooleanParameterValue(LightmassParameterValue):
    r"""
    Boolean parameter value
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: UnrealEdTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``override`` (bool):  [Read-Write] If true, override the given parameter with the given settings
    - ``parameter_value`` (bool):  [Read-Write] The boolean value to override the parent value with
    """
    def __init__(self) -> None:
        ...

class LightmassScalarParameterValue(LightmassParameterValue):
    r"""
    Scalar parameter value
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: UnrealEdTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``override`` (bool):  [Read-Write] If true, override the given parameter with the given settings
    - ``parameter_value`` (float):  [Read-Write] The scalar value to override the parent value with
    """
    def __init__(self) -> None:
        ...

class MaterialLayersFunctionsEditorOnlyData(StructBase):
    r"""
    Material Layers Functions Editor Only Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialLayersFunctions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``deleted_parent_layer_guids`` (Array[Guid]):  [Read-Write] List of Guids that exist in the parent material that have been explicitly deleted
      This is needed to distinguish these layers from newly added layers in the parent material
    - ``layer_guids`` (Array[Guid]):  [Read-Write] Guid that identifies each layer in this stack
    - ``layer_link_states`` (Array[MaterialLayerLinkState]):  [Read-Write] State of each layer's link to parent material
    - ``layer_names`` (Array[Text]):  [Read-Write]
    - ``layer_states`` (Array[bool]):  [Read-Write]
    - ``restrict_to_blend_relatives`` (Array[bool]):  [Read-Write]
    - ``restrict_to_layer_relatives`` (Array[bool]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class TimeStretchCurveMarker(StructBase):
    r"""
    Time Stretch Curve Marker
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimeStretchCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Only]
    - ``time`` (float):  [Read-Only]
    """
    def __init__(self) -> None:
        ...

class CustomAttribute(StructBase):
    r"""
    Custom Attribute
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CustomAttributes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Only] Name of this attribute
    - ``times`` (Array[float]):  [Read-Only] Time keys (should match number of Value entries)
    - ``variant_type`` (int32):  [Read-Only] (FVariant) type contained by Values array
    """
    def __init__(self) -> None:
        ...

class ConstraintProfileProperties(StructBase):
    r"""
    Container for properties of a physics constraint that can be easily swapped at runtime. This is useful for switching different setups when going from ragdoll to standup for example
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_break_threshold`` (float):  [Read-Write] Torque needed to break the joint.
    - ``angular_breakable`` (bool):  [Read-Write] Whether it is possible to break the joint with angular force.
    - ``angular_drive`` (AngularDriveConstraint):  [Read-Write]
    - ``angular_plasticity`` (bool):  [Read-Write] Whether it is possible to reset target rotations from the angular displacement.
    - ``angular_plasticity_threshold`` (float):  [Read-Write] [Chaos Only] Degree threshold from target angle needed to reset the target angle.
    - ``cone_limit`` (ConeConstraint):  [Read-Write]
    - ``contact_transfer_scale`` (float):  [Read-Write] [Chaos Only] Colliison transfer on parent from the joints child. Range is 0.0-MAX
    - ``disable_collision`` (bool):  [Read-Write] Disable collision between bodies joined by this constraint.
    - ``enable_mass_conditioning`` (bool):  [Read-Write] Whether mass conditioning is enabled for this joint. Mass conditioning applies a non-physical scale to the mass and inertia of the two
      bodies that only affects this joint, so that the mass and inertia ratios are smaller. This helps stabilize joints where the bodies
      are very different sizes, and especially when the parent body is heavier than the child. However, it can lead to unrealistic
      behaviour, especially when collisions are involved.
    - ``enable_projection`` (bool):  [Read-Write] Projection is a post-solve position and angular fixup consisting of two correction procedures. First, if the constraint limits are exceeded
      by more that the Linear or Angular Tolerance, the bodies are teleported to eliminate the error. Second, if the constraint limits are exceeded
      by less than the tolerance, a semi-physical correction is applied,  with the parent body in the constraint is treated as having infinite mass.
      The teleport tolerance are controlled by ProjectionLinearTolerance and ProjectionAngularTolerance. The semi-physical correction is controlled
      by ProjectionLinearAlpha and ProjectionAnguilarAlpha. You may have one, none, or both systems enabled at the same time.
      
      Projection only works well if the chain is not interacting with other objects (e.g., through collisions) because the projection of the bodies in
      the chain will cause other constraints to be violated. Likewise, if a body is influenced by multiple constraints, then enabling projection on more
      than one constraint may lead to unexpected results - the  "last" constraint would win but the order in which constraints are solved cannot be directly controlled.
      
      Note that the semi-physical projection (ProjectionLinearAlpha and ProjectionAngularAlpha) is only applied to hard-limit constraints and not those with
      soft limits because the soft limit is the point at which the soft-constraint (spring) kicks in, and not really a limit on how far the joint can be separated.
    - ``enable_shock_propagation`` (bool):  [Read-Write] Shock propagation increases the mass of the parent body for the last iteration of the position and velocity solve phases.
      This can help stiffen up joint chains, but is also prone to introducing energy down the chain especially at high alpha.
      It also does not work well if there are collisions on the bodies preventing the joints from correctly resolving - this
      can lead to jitter, especially if collision shock propagation is also enabled.
    - ``linear_break_threshold`` (float):  [Read-Write] Force needed to break the distance constraint.
    - ``linear_breakable`` (bool):  [Read-Write] Whether it is possible to break the joint with linear force.
    - ``linear_drive`` (LinearDriveConstraint):  [Read-Write]
    - ``linear_limit`` (LinearConstraint):  [Read-Write]
    - ``linear_plasticity`` (bool):  [Read-Write] Whether it is possible to reset spring rest length from the linear deformation.
    - ``linear_plasticity_threshold`` (float):  [Read-Write] [Chaos Only] Percent threshold from center of mass distance needed to reset the linear drive position target. This value can be greater than 1.
    - ``linear_plasticity_type`` (ConstraintPlasticityType):  [Read-Write] Whether linear plasticity has a operation mode [free]
    - ``parent_dominates`` (bool):  [Read-Write] When set, the parent body in a constraint will not be affected by the motion of the child
    - ``projection_angular_alpha`` (float):  [Read-Write] How much semi-physical angular projection correction to apply [0-1]. Only used if bEnableProjection is true and if hard limits are used.
    - ``projection_angular_tolerance`` (float):  [Read-Write] If the joint error is above this distance after the solve phase, the child body will be teleported to fix the error. Only used if bEnableProjection is true.
    - ``projection_linear_alpha`` (float):  [Read-Write] How much semi-physical linear projection correction to apply [0-1]. Only used if bEnableProjection is true and if hard limits are used.
    - ``projection_linear_tolerance`` (float):  [Read-Write] If the joint error is above this distance after the solve phase, the child body will be teleported to fix the error. Only used if bEnableProjection is true.
    - ``shock_propagation_alpha`` (float):  [Read-Write] How much shock propagation to apply [0-1]. Shock propagation increases the mass of the parent body for the last iteration of the
      position and velocity solve phases. This can help stiffen up joint chains, but is also prone to introducing energy down the chain
      especially at high alpha. Only used in bEnableShockPropagation is true.
    - ``twist_limit`` (TwistConstraint):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class SkeletalMeshOptimizationSettings(StructBase):
    r"""
    FSkeletalMeshOptimizationSettings - The settings used to optimize a skeletal mesh LOD.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshReductionSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_lod`` (int32):  [Read-Write] Base LOD index to generate this LOD. By default, we generate from LOD 0
    - ``enforce_bone_boundaries`` (bool):  [Read-Write] Penalize edge collapse between vertices that have different major bones.  This will help articulated segments like tongues but can lead to undesirable results under extreme simplification
    - ``improve_triangles_for_cloth`` (bool):  [Read-Write] Better distribution of triangles on 2d meshes, such as flat cloth, but at the cost of potentially worse UVs in those areas.  This generally has little or no effect for mesh regions that aren't laid out on a plane intersecting the origin such as the xy-plane. When this is disabled, the planar regions may simplify to fewer large triangles.
    - ``lock_color_bounaries`` (bool):  [Read-Write] Disallow edge collapse when the vertices do not have a common color
    - ``lock_edges`` (bool):  [Read-Write] Preserve cuts in the mesh surface by locking vertices in place.  Increases the quality of the simplified mesh at edges at the cost of more triangles
    - ``max_bones_per_vertex`` (int32):  [Read-Write] Maximum number of bones that can be assigned to each vertex.
    - ``max_deviation_percentage`` (float):  [Read-Write] If ReductionMethod equals MaxDeviation this value is the maximum deviation from the base mesh as a percentage of the bounding sphere.
      In code, it ranges from [0, 1]. In the editor UI, it ranges from [0, 100]
    - ``max_num_of_triangles`` (uint32):  [Read-Write] The maximum number of triangles to retain
    - ``max_num_of_triangles_percentage`` (uint32):  [Read-Write] The maximum number of triangles to retain when using percentage termination criterion.
    - ``max_num_of_verts`` (uint32):  [Read-Write] The maximum number of vertices to retain
    - ``max_num_of_verts_percentage`` (uint32):  [Read-Write] The maximum number of vertices to retain when using percentage termination criterion.
    - ``merge_coincident_vert_bones`` (bool):  [Read-Write] If enabled this option make sure vertices that share the same location (e.g. UV boundaries) have the same bone weights. This can fix cracks when the characters animate.
    - ``normals_threshold`` (float):  [Read-Write] If the angle between two triangles are above this value, the normals will not be
            smooth over the edge between those two triangles. Set in degrees. This is only used when bRecalcNormals is set to true
    - ``num_of_triangles_percentage`` (float):  [Read-Write] The percentage of triangles to retain as a ratio, e.g. 0.1 indicates 10 percent
    - ``num_of_vert_percentage`` (float):  [Read-Write] The percentage of vertices to retain as a ratio, e.g. 0.1 indicates 10 percent
    - ``recalc_normals`` (bool):  [Read-Write] Whether Normal smoothing groups should be preserved. If true then Hard Edge Angle (NormalsThreshold) is used *
    - ``reduction_method`` (SkeletalMeshOptimizationType):  [Read-Write] The method to use when optimizing the skeletal mesh LOD
    - ``remap_morph_targets`` (bool):  [Read-Write] Remap the morph targets from the base LOD onto the reduce LOD.
    - ``shading_importance`` (SkeletalMeshOptimizationImportance):  [Read-Write] How important shading quality is.
    - ``silhouette_importance`` (SkeletalMeshOptimizationImportance):  [Read-Write] How important the shape of the geometry is.
    - ``skinning_importance`` (SkeletalMeshOptimizationImportance):  [Read-Write] How important skinning quality is.
    - ``termination_criterion`` (SkeletalMeshTerminationCriterion):  [Read-Write] The method to use when optimizing the skeletal mesh LOD
    - ``texture_importance`` (SkeletalMeshOptimizationImportance):  [Read-Write] How important texture density is.
    - ``volume_importance`` (float):  [Read-Write] Default value of 1 attempts to preserve volume.  Smaller values will loose volume by flattening curved surfaces, and larger values will accentuate curved surfaces.
    - ``welding_threshold`` (float):  [Read-Write] The welding threshold distance. Vertices under this distance will be welded.
    """
    def __init__(self) -> None:
        ...

class SectionReference(StructBase):
    r"""
    Section Reference
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedAssetCommon.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``section_index`` (int32):  [Read-Write] Index of the section we reference. *
    """
    def __init__(self) -> None:
        ...

class SkeletalMeshVertexAttributeInfo(StructBase):
    r"""
    A structure to store user-controllable settings for attributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshVertexAttribute.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_type`` (SkeletalMeshVertexAttributeDataType):  [Read-Write] The data type to store the vertex data as for rendering
    - ``enabled_for_render`` (PerPlatformBool):  [Read-Write] Whether this vertex attribute should be included in the render data. Requires a rebuild of the render mesh.
    - ``name`` (Name):  [Read-Only] The name of the vertex attribute
    """
    def __init__(self) -> None:
        ...

class SkeletalMeshSamplingRegion(StructBase):
    r"""
    Defined a named region on a mesh that will have associated triangles and bones for fast sampling at each enabled LOD.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshSampling.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_filters`` (Array[SkeletalMeshSamplingRegionBoneFilter]):  [Read-Write] Filters to determine which triangles and bones to include in this region based on bone.
    - ``lod_index`` (int32):  [Read-Write] The LOD of the mesh that this region applies to.
    - ``material_filters`` (Array[SkeletalMeshSamplingRegionMaterialFilter]):  [Read-Write] Filters to determine which triangles to include in this region based on material.
    - ``name`` (Name):  [Read-Write] Name of this region that users will reference.
    - ``support_uniformly_distributed_sampling`` (bool):  [Read-Write] Mesh supports uniformly distributed sampling in constant time.
      Memory cost is 8 bytes per triangle.
    """
    def __init__(self) -> None:
        ...

class BoneFilter(StructBase):
    r"""
    Bone Filter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshLODSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_name`` (Name):  [Read-Write] Name of Bone Name
    - ``exclude_self`` (bool):  [Read-Write] * Do not include the joint specified
      *
      * This option will work differently based on EBoneFilterActionOption
      * If EBoneFilterActionOption is Remove, it will exclude itself and only remove children
      * For example, if you specify hand, it will only include children of hand(all fingers),
      * not the hand itself if this is true
      *
      * But if the EBoneFilterActionOption is Keep, it will exclude itself but include all parents of it
      * You can't remove joint without children removed, and you can't keep without your parents
    """
    def __init__(self) -> None:
        ...

class InputAxisProperties(StructBase):
    r"""
    Configurable properties for control axes, used to transform raw input into game ready values.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerInput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``dead_zone`` (float):  [Read-Write] What the dead zone of the axis is.  For control axes such as analog sticks.
    - ``exponent`` (float):  [Read-Write] For applying curves to [0..1] axes, e.g. analog sticks
    - ``invert`` (bool):  [Read-Write] Inverts reported values for this axis
    - ``sensitivity`` (float):  [Read-Write] Scaling factor to multiply raw value by.
    """
    def __init__(self) -> None:
        ...

class KShapeElem(StructBase):
    r"""
    Base class of shapes used for collision, such as Sphere, Box, Sphyl, Convex, TaperedCapsule or LevelSet
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ShapeElem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_enabled`` (CollisionEnabled):  [Read-Write] Course per-primitive collision filtering. This allows for individual primitives to
                    be toggled in and out of sim and query collision without changing filtering details.
    - ``contribute_to_mass`` (bool):  [Read-Write] True if this shape should contribute to the overall mass of the body it
                    belongs to. This lets you create extra collision volumes which do not affect
                    the mass properties of an object.
    - ``name`` (Name):  [Read-Write] User-defined name for this shape
    - ``rest_offset`` (float):  [Read-Write] Offset used when generating contact points. This allows you to smooth out
                    the Minkowski sum by radius R. Useful for making objects slide smoothly
                    on top of irregularities
    """
    def __init__(self) -> None:
        ...

class KSphereElem(KShapeElem):
    r"""
    Sphere shape used for collision
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SphereElem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``center`` (Vector):  [Read-Write] Position of the sphere's origin
    - ``collision_enabled`` (CollisionEnabled):  [Read-Write] Course per-primitive collision filtering. This allows for individual primitives to
                    be toggled in and out of sim and query collision without changing filtering details.
    - ``contribute_to_mass`` (bool):  [Read-Write] True if this shape should contribute to the overall mass of the body it
                    belongs to. This lets you create extra collision volumes which do not affect
                    the mass properties of an object.
    - ``name`` (Name):  [Read-Write] User-defined name for this shape
    - ``radius`` (float):  [Read-Write] Radius of the sphere
    - ``rest_offset`` (float):  [Read-Write] Offset used when generating contact points. This allows you to smooth out
                    the Minkowski sum by radius R. Useful for making objects slide smoothly
                    on top of irregularities
    """
    def __init__(self) -> None:
        ...

class KBoxElem(KShapeElem):
    r"""
    Box shape used for collision
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BoxElem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``center`` (Vector):  [Read-Write] Position of the box's origin
    - ``collision_enabled`` (CollisionEnabled):  [Read-Write] Course per-primitive collision filtering. This allows for individual primitives to
                    be toggled in and out of sim and query collision without changing filtering details.
    - ``contribute_to_mass`` (bool):  [Read-Write] True if this shape should contribute to the overall mass of the body it
                    belongs to. This lets you create extra collision volumes which do not affect
                    the mass properties of an object.
    - ``name`` (Name):  [Read-Write] User-defined name for this shape
    - ``rest_offset`` (float):  [Read-Write] Offset used when generating contact points. This allows you to smooth out
                    the Minkowski sum by radius R. Useful for making objects slide smoothly
                    on top of irregularities
    - ``rotation`` (Rotator):  [Read-Write] Rotation of the box
    - ``x`` (float):  [Read-Write] Extent of the box along the y-axis
    - ``y`` (float):  [Read-Write] Extent of the box along the y-axis
    - ``z`` (float):  [Read-Write] Extent of the box along the z-axis
    """
    def __init__(self) -> None:
        ...

class KSphylElem(KShapeElem):
    r"""
    Capsule shape used for collision. Z axis is capsule axis.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SphylElem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``center`` (Vector):  [Read-Write] Position of the capsule's origin
    - ``collision_enabled`` (CollisionEnabled):  [Read-Write] Course per-primitive collision filtering. This allows for individual primitives to
                    be toggled in and out of sim and query collision without changing filtering details.
    - ``contribute_to_mass`` (bool):  [Read-Write] True if this shape should contribute to the overall mass of the body it
                    belongs to. This lets you create extra collision volumes which do not affect
                    the mass properties of an object.
    - ``length`` (float):  [Read-Write] This is of line-segment ie. add Radius to both ends to find total length.
    - ``name`` (Name):  [Read-Write] User-defined name for this shape
    - ``radius`` (float):  [Read-Write] Radius of the capsule
    - ``rest_offset`` (float):  [Read-Write] Offset used when generating contact points. This allows you to smooth out
                    the Minkowski sum by radius R. Useful for making objects slide smoothly
                    on top of irregularities
    - ``rotation`` (Rotator):  [Read-Write] Rotation of the capsule
    """
    def __init__(self) -> None:
        ...

class KConvexElem(KShapeElem):
    r"""
    One convex hull, used for simplified collision.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConvexElem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_enabled`` (CollisionEnabled):  [Read-Write] Course per-primitive collision filtering. This allows for individual primitives to
                    be toggled in and out of sim and query collision without changing filtering details.
    - ``contribute_to_mass`` (bool):  [Read-Write] True if this shape should contribute to the overall mass of the body it
                    belongs to. This lets you create extra collision volumes which do not affect
                    the mass properties of an object.
    - ``name`` (Name):  [Read-Write] User-defined name for this shape
    - ``rest_offset`` (float):  [Read-Write] Offset used when generating contact points. This allows you to smooth out
                    the Minkowski sum by radius R. Useful for making objects slide smoothly
                    on top of irregularities
    """
    def __init__(self) -> None:
        ...

class KTaperedCapsuleElem(KShapeElem):
    r"""
    Capsule shape used for collision. Z axis is capsule axis. Has a start and end radius that can differ.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TaperedCapsuleElem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``center`` (Vector):  [Read-Write] Position of the capsule's origin
    - ``collision_enabled`` (CollisionEnabled):  [Read-Write] Course per-primitive collision filtering. This allows for individual primitives to
                    be toggled in and out of sim and query collision without changing filtering details.
    - ``contribute_to_mass`` (bool):  [Read-Write] True if this shape should contribute to the overall mass of the body it
                    belongs to. This lets you create extra collision volumes which do not affect
                    the mass properties of an object.
    - ``length`` (float):  [Read-Write] Length of line-segment. Add Radius0 and Radius 1 to find total length.
    - ``name`` (Name):  [Read-Write] User-defined name for this shape
    - ``radius0`` (float):  [Read-Write] Radius of the capsule start point
    - ``radius1`` (float):  [Read-Write] Radius of the capsule end point
    - ``rest_offset`` (float):  [Read-Write] Offset used when generating contact points. This allows you to smooth out
                    the Minkowski sum by radius R. Useful for making objects slide smoothly
                    on top of irregularities
    - ``rotation`` (Rotator):  [Read-Write] Rotation of the capsule
    """
    def __init__(self) -> None:
        ...

class KLevelSetElem(KShapeElem):
    r"""
    KLevel Set Elem
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelSetElem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_enabled`` (CollisionEnabled):  [Read-Write] Course per-primitive collision filtering. This allows for individual primitives to
                    be toggled in and out of sim and query collision without changing filtering details.
    - ``contribute_to_mass`` (bool):  [Read-Write] True if this shape should contribute to the overall mass of the body it
                    belongs to. This lets you create extra collision volumes which do not affect
                    the mass properties of an object.
    - ``name`` (Name):  [Read-Write] User-defined name for this shape
    - ``rest_offset`` (float):  [Read-Write] Offset used when generating contact points. This allows you to smooth out
                    the Minkowski sum by radius R. Useful for making objects slide smoothly
                    on top of irregularities
    """
    def __init__(self) -> None:
        ...

class KSkinnedLevelSetElem(KShapeElem):
    r"""
    KSkinned Level Set Elem
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedLevelSetElem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_enabled`` (CollisionEnabled):  [Read-Write] Course per-primitive collision filtering. This allows for individual primitives to
                    be toggled in and out of sim and query collision without changing filtering details.
    - ``contribute_to_mass`` (bool):  [Read-Write] True if this shape should contribute to the overall mass of the body it
                    belongs to. This lets you create extra collision volumes which do not affect
                    the mass properties of an object.
    - ``name`` (Name):  [Read-Write] User-defined name for this shape
    - ``rest_offset`` (float):  [Read-Write] Offset used when generating contact points. This allows you to smooth out
                    the Minkowski sum by radius R. Useful for making objects slide smoothly
                    on top of irregularities
    """
    def __init__(self) -> None:
        ...

class GeometryCollectionLevelSetData(StructBase):
    r"""
    Geometry Collection Level Set Data
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max_cluster_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
    - ``max_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
    - ``min_cluster_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 5)
    - ``min_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 5)
    """
    def __init__(self) -> None:
        ...

class GeometryCollectionCollisionParticleData(StructBase):
    r"""
    Geometry Collection Collision Particle Data
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_particles_fraction`` (float):  [Read-Write] Number of particles on the triangulated surface to use for collisions.
    - ``maximum_collision_particles`` (int32):  [Read-Write] Max number of particles.
    """
    def __init__(self) -> None:
        ...

class ConstraintBaseParams(StructBase):
    r"""
    Constraint Base Params
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``contact_distance`` (float):  [Read-Write] Determines how close to the limit we have to get before turning the joint on. Larger value will be more expensive, but will do a better job not violating constraints. A smaller value will be more efficient, but easier to violate.
    - ``damping`` (float):  [Read-Write] Damping of the soft constraint. Only used when Soft Constraint is on.
    - ``restitution`` (float):  [Read-Write] Controls the amount of bounce when the constraint is violated. A restitution value of 1 will bounce back with the same velocity the limit was hit. A value of 0 will stop dead.
    - ``soft_constraint`` (bool):  [Read-Write] Whether we want to use a soft constraint (spring).
    - ``stiffness`` (float):  [Read-Write] Stiffness of the soft constraint. Only used when Soft Constraint is on.
    """
    def __init__(self) -> None:
        ...

class LinearConstraint(ConstraintBaseParams):
    r"""
    Distance constraint
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``contact_distance`` (float):  [Read-Write] Determines how close to the limit we have to get before turning the joint on. Larger value will be more expensive, but will do a better job not violating constraints. A smaller value will be more efficient, but easier to violate.
    - ``damping`` (float):  [Read-Write] Damping of the soft constraint. Only used when Soft Constraint is on.
    - ``limit`` (float):  [Read-Write] The distance allowed between the two joint reference frames. Distance applies on all axes enabled (one axis means line, two axes implies circle, three axes implies sphere)
    - ``restitution`` (float):  [Read-Write] Controls the amount of bounce when the constraint is violated. A restitution value of 1 will bounce back with the same velocity the limit was hit. A value of 0 will stop dead.
    - ``soft_constraint`` (bool):  [Read-Write] Whether we want to use a soft constraint (spring).
    - ``stiffness`` (float):  [Read-Write] Stiffness of the soft constraint. Only used when Soft Constraint is on.
    - ``x_motion`` (LinearConstraintMotion):  [Read-Write] Indicates the linear constraint applied along the X-axis. Free implies no constraint at all. Locked implies no movement along X is allowed. Limited implies the distance in the joint along all active axes must be less than the Distance provided.
    - ``y_motion`` (LinearConstraintMotion):  [Read-Write] Indicates the linear constraint applied along the Y-axis. Free implies no constraint at all. Locked implies no movement along Y is allowed. Limited implies the distance in the joint along all active axes must be less than the Distance provided.
    - ``z_motion`` (LinearConstraintMotion):  [Read-Write] Indicates the linear constraint applied along theZX-axis. Free implies no constraint at all. Locked implies no movement along Z is allowed. Limited implies the distance in the joint along all active axes must be less than the Distance provided.
    """
    def __init__(self) -> None:
        ...

class ConeConstraint(ConstraintBaseParams):
    r"""
    Cone constraint
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``contact_distance`` (float):  [Read-Write] Determines how close to the limit we have to get before turning the joint on. Larger value will be more expensive, but will do a better job not violating constraints. A smaller value will be more efficient, but easier to violate.
    - ``damping`` (float):  [Read-Write] Damping of the soft constraint. Only used when Soft Constraint is on.
    - ``restitution`` (float):  [Read-Write] Controls the amount of bounce when the constraint is violated. A restitution value of 1 will bounce back with the same velocity the limit was hit. A value of 0 will stop dead.
    - ``soft_constraint`` (bool):  [Read-Write] Whether we want to use a soft constraint (spring).
    - ``stiffness`` (float):  [Read-Write] Stiffness of the soft constraint. Only used when Soft Constraint is on.
    - ``swing1_limit_degrees`` (float):  [Read-Write] Angle of movement along the XY plane. This defines the first symmetric angle of the cone.
    - ``swing1_motion`` (AngularConstraintMotion):  [Read-Write] Indicates whether the Swing1 limit is used.
    - ``swing2_limit_degrees`` (float):  [Read-Write] Angle of movement along the XZ plane. This defines the second symmetric angle of the cone.
    - ``swing2_motion`` (AngularConstraintMotion):  [Read-Write] Indicates whether the Swing2 limit is used.
    """
    def __init__(self) -> None:
        ...

class TwistConstraint(ConstraintBaseParams):
    r"""
    Angular roll constraint
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``contact_distance`` (float):  [Read-Write] Determines how close to the limit we have to get before turning the joint on. Larger value will be more expensive, but will do a better job not violating constraints. A smaller value will be more efficient, but easier to violate.
    - ``damping`` (float):  [Read-Write] Damping of the soft constraint. Only used when Soft Constraint is on.
    - ``restitution`` (float):  [Read-Write] Controls the amount of bounce when the constraint is violated. A restitution value of 1 will bounce back with the same velocity the limit was hit. A value of 0 will stop dead.
    - ``soft_constraint`` (bool):  [Read-Write] Whether we want to use a soft constraint (spring).
    - ``stiffness`` (float):  [Read-Write] Stiffness of the soft constraint. Only used when Soft Constraint is on.
    - ``twist_limit_degrees`` (float):  [Read-Write] Symmetric angle of roll along the X-axis.
    - ``twist_motion`` (AngularConstraintMotion):  [Read-Write] Indicates whether the Twist limit is used.
    """
    def __init__(self) -> None:
        ...

class LinearDriveConstraint(StructBase):
    r"""
    Linear Drive
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintDrives.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_position_drive`` (bool):  [Read-Write]
      deprecated: Enable/disable of drives is done inside the individual constraint drives.
    - ``position_target`` (Vector):  [Read-Write] Target position the linear drive.
    - ``velocity_target`` (Vector):  [Read-Write] Target velocity the linear drive.
    - ``x_drive`` (ConstraintDrive):  [Read-Write]
    - ``y_drive`` (ConstraintDrive):  [Read-Write]
    - ``z_drive`` (ConstraintDrive):  [Read-Write]
    """
    def __init__(self) -> None:
        ...
    @property
    def enable_position_drive(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: Enable/disable of drives is done inside the individual constraint drives.
        """
        ...
    @enable_position_drive.setter
    def enable_position_drive(self, value: bool) -> None:
        ...

class AngularDriveConstraint(StructBase):
    r"""
    Angular Drive
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintDrives.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_drive_mode`` (AngularDriveMode):  [Read-Write] Whether motors use SLERP (spherical lerp) or decompose into a Swing motor (cone constraints) and Twist motor (roll constraints). NOTE: SLERP will NOT work if any of the angular constraints are locked.
    - ``angular_velocity_target`` (Vector):  [Read-Write] Target angular velocity relative to the body reference frame in revolutions per second.
    - ``orientation_target`` (Rotator):  [Read-Write] Target orientation relative to the the body reference frame.
    - ``slerp_drive`` (ConstraintDrive):  [Read-Write] Controls the SLERP (spherical lerp) drive between current orientation/velocity and target orientation/velocity. NOTE: This is only available when all three angular limits are either free or limited. Locking any angular limit will turn off the drive implicitly.
    - ``swing_drive`` (ConstraintDrive):  [Read-Write] Controls the cone constraint drive between current orientation/velocity and target orientation/velocity. This is available as long as there is at least one swing limit set to free or limited.
    - ``twist_drive`` (ConstraintDrive):  [Read-Write] Controls the twist (roll) constraint drive between current orientation/velocity and target orientation/velocity. This is available as long as the twist limit is set to free or limited.
    """
    def __init__(self) -> None:
        ...

class SkeletalMeshSamplingRegionMaterialFilter(StructBase):
    r"""
    Filter to include triangles in a sampling region based on their material.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshSampling.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``material_name`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class SkeletalMeshSamplingRegionBoneFilter(StructBase):
    r"""
    Filter to include or exclude bones and their associated triangles from a sampling region.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshSampling.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_to_children`` (bool):  [Read-Write] If true, this filter will apply to all children of this bone as well.
    - ``bone_name`` (Name):  [Read-Write]
    - ``include_or_exclude`` (bool):  [Read-Write] If true, this filter will include bones. If false, it will exclude them.
    """
    def __init__(self) -> None:
        ...

class ConstraintDrive(StructBase):
    r"""
    Constraint Drive
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintDrives.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``damping`` (float):  [Read-Write] The damping strength of the drive. Force proportional to the velocity error.
    - ``enable_position_drive`` (bool):  [Read-Write] Enables/Disables position drive (orientation if using angular drive)
    - ``enable_velocity_drive`` (bool):  [Read-Write] Enables/Disables velocity drive (angular velocity if using angular drive)
    - ``max_force`` (float):  [Read-Write] The force limit of the drive.
    - ``stiffness`` (float):  [Read-Write] The spring strength of the drive. Force proportional to the position error.
    """
    def __init__(self) -> None:
        ...

class PerSkeletonAnimationSharingSetup(StructBase):
    r"""
    Per Skeleton Animation Sharing Setup
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharing
    - **File**: AnimationSharingTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additive_anim_blueprint`` (type(Class)):  [Read-Write] Animation blueprint used to apply additive animation on top of other states
    - ``animation_states`` (Array[AnimationStateEntry]):  [Read-Write] Definition of different animation states
    - ``blend_anim_blueprint`` (type(Class)):  [Read-Write] Animation blueprint used to perform the blending between states
    - ``skeletal_mesh`` (SkeletalMesh):  [Read-Write] Skeletal mesh used to setup skeletal mesh components
    - ``skeleton`` (Skeleton):  [Read-Write] Skeleton compatible with the animation sharing setup
    - ``state_processor_class`` (type(Class)):  [Read-Write] Interface class used when determining which state an actor is in
    """
    def __init__(self) -> None:
        ...

class AnimationSharingScalability(StructBase):
    r"""
    Animation Sharing Scalability
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharing
    - **File**: AnimationSharingTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_significance_value`` (PerPlatformFloat):  [Read-Write] Significance value tied to whether or not a transition should be blended
    - ``maximum_number_concurrent_blends`` (PerPlatformInt):  [Read-Write] Maximum number of blends which can be running concurrently
    - ``tick_significance_value`` (PerPlatformFloat):  [Read-Write] Significance value tied to whether or not the leader pose components should be ticking
    - ``use_blend_transitions`` (PerPlatformBool):  [Read-Write] Flag whether or not to use blend transitions between states
    """
    def __init__(self) -> None:
        ...

class AnimationStateEntry(StructBase):
    r"""
    Animation State Entry
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharing
    - **File**: AnimationSharingTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additive`` (bool):  [Read-Write] Whether or not this state is an additive state
    - ``animation_setups`` (Array[AnimationSetup]):  [Read-Write] Per state animation setup
    - ``blend_time`` (float):  [Read-Write] Duration of blending when blending to this state
    - ``maximum_number_of_concurrent_instances`` (PerPlatformInt):  [Read-Write] Number of instances that will be created for this state (platform-specific)
    - ``next_state`` (uint8):  [Read-Write] State value to which the actors part of an on demand state should be set to when its animation has finished
    - ``on_demand`` (bool):  [Read-Write] Flag whether or not this state is an on-demand state, this means that we kick off a unique animation when needed
    - ``requires_curves`` (bool):  [Read-Write] Whether or not this animation requires curves or morphtargets to function correctly for follower components
    - ``return_to_previous_state`` (bool):  [Read-Write] Flag whether or not we should return to the previous state, only used when this state is an on-demand one
    - ``set_next_state`` (bool):  [Read-Write]
    - ``state`` (uint8):  [Read-Write] Enum value linked to this state
    - ``wiggle_time_percentage`` (float):  [Read-Write] Percentage of 'wiggle' frames, this is used when we run out of available entries in Components, if one of the on-demand animations has started SequenceLength * WiggleFramePercentage ago or earlier,
            it is used instead of a brand new one
    """
    def __init__(self) -> None:
        ...

class AnimationSetup(StructBase):
    r"""
    Animation Setup
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharing
    - **File**: AnimationSharingTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_blueprint`` (type(Class)):  [Read-Write] Animation blueprint to use for playing back the Animation Sequence
    - ``anim_sequence`` (AnimSequence):  [Read-Write] Animation Sequence to play for this particular setup
    - ``enabled`` (PerPlatformBool):  [Read-Write] Whether or not this setup is enabled for specific platforms
    - ``num_randomized_instances`` (PerPlatformInt):  [Read-Write] The number of randomized instances created from this setup, it will create instance with different start time offsets (Length / Number of Instance) * InstanceIndex
    """
    def __init__(self) -> None:
        ...

class CustomMeshTriangle(StructBase):
    r"""
    Custom Mesh Triangle
    
    **C++ Source:**
    
    - **Plugin**: CustomMeshComponent
    - **Module**: CustomMeshComponent
    - **File**: CustomMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``vertex0`` (Vector):  [Read-Write]
    - ``vertex1`` (Vector):  [Read-Write]
    - ``vertex2`` (Vector):  [Read-Write]
    """
    def __init__(self, vertex0: Vector = [0.000000, 0.000000, 0.000000], vertex1: Vector = [0.000000, 0.000000, 0.000000], vertex2: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def vertex0(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @vertex0.setter
    def vertex0(self, value: Vector) -> None:
        ...
    @property
    def vertex1(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @vertex1.setter
    def vertex1(self, value: Vector) -> None:
        ...
    @property
    def vertex2(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @vertex2.setter
    def vertex2(self, value: Vector) -> None:
        ...

class ConstantQResults(StructBase):
    r"""
    The results of the ConstantQ analysis.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: ConstantQ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``spectrum_values`` (Array[float]):  [Read-Write] The spectrum values from the FFT
    - ``time_seconds`` (float):  [Read-Write] The time in seconds since analysis began of this ConstantQ analysis result
    """
    def __init__(self, time_seconds: float = 0.000000, spectrum_values: Array[float] = []) -> None:
        ...
    @property
    def time_seconds(self) -> float:
        r"""
        (float):  [Read-Only] The time in seconds since analysis began of this ConstantQ analysis result
        """
        ...
    @property
    def spectrum_values(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Only] The spectrum values from the FFT
        """
        ...

class LoudnessResults(StructBase):
    r"""
    The results of the loudness analyis.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Loudness.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``loudness`` (float):  [Read-Write] The raw loudness value in dB
    - ``normalized_loudness`` (float):  [Read-Write] The normalized loudness
    - ``perceptual_energy`` (float):  [Read-Write] The normalized loudness
    - ``time_seconds`` (float):  [Read-Write] The time in seconds since analysis began
    """
    def __init__(self, loudness: float = 0.000000, normalized_loudness: float = 0.000000, perceptual_energy: float = 0.000000, time_seconds: float = 0.000000) -> None:
        ...
    @property
    def loudness(self) -> float:
        r"""
        (float):  [Read-Only] The raw loudness value in dB
        """
        ...
    @property
    def normalized_loudness(self) -> float:
        r"""
        (float):  [Read-Only] The normalized loudness
        """
        ...
    @property
    def perceptual_energy(self) -> float:
        r"""
        (float):  [Read-Only] The normalized loudness
        """
        ...
    @property
    def time_seconds(self) -> float:
        r"""
        (float):  [Read-Only] The time in seconds since analysis began
        """
        ...

class MeterResults(StructBase):
    r"""
    The results of the meter analysis.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Meter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clipping_value`` (float):  [Read-Write] The value (if non-zero) if clipping was detected above the clipping threshold
    - ``meter_value`` (float):  [Read-Write] The meter value
    - ``num_samples_clipping`` (int32):  [Read-Write] The number of samples in the period which were above the clipping threshold. Will be 0 if no clipping was detected.
    - ``peak_value`` (float):  [Read-Write] The peak value
    - ``time_seconds`` (float):  [Read-Write] The time in seconds since analysis began of this meter analysis result
    """
    def __init__(self, time_seconds: float = 0.000000, meter_value: float = 0.000000, peak_value: float = 0.000000, num_samples_clipping: int = 0, clipping_value: float = 0.000000) -> None:
        ...
    @property
    def time_seconds(self) -> float:
        r"""
        (float):  [Read-Only] The time in seconds since analysis began of this meter analysis result
        """
        ...
    @property
    def meter_value(self) -> float:
        r"""
        (float):  [Read-Only] The meter value
        """
        ...
    @property
    def peak_value(self) -> float:
        r"""
        (float):  [Read-Only] The peak value
        """
        ...
    @property
    def num_samples_clipping(self) -> int:
        r"""
        (int32):  [Read-Only] The number of samples in the period which were above the clipping threshold. Will be 0 if no clipping was detected.
        """
        ...
    @property
    def clipping_value(self) -> float:
        r"""
        (float):  [Read-Only] The value (if non-zero) if clipping was detected above the clipping threshold
        """
        ...

class SynesthesiaSpectrumResults(StructBase):
    r"""
    The results of the spectrum analysis.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: SynesthesiaSpectrumAnalysis.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``spectrum_values`` (Array[float]):  [Read-Write] The spectrum values from the FFT
    - ``time_seconds`` (float):  [Read-Write] The time in seconds since analysis began of this SynesthesiaSpectrumAnalysis analysis result
    """
    def __init__(self, time_seconds: float = 0.000000, spectrum_values: Array[float] = []) -> None:
        ...
    @property
    def time_seconds(self) -> float:
        r"""
        (float):  [Read-Only] The time in seconds since analysis began of this SynesthesiaSpectrumAnalysis analysis result
        """
        ...
    @property
    def spectrum_values(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Only] The spectrum values from the FFT
        """
        ...

class MetasoundFrontendVersionNumber(StructBase):
    r"""
    General purpose version number for Metasound Frontend objects.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``major`` (int32):  [Read-Only] Major version number.
    - ``minor`` (int32):  [Read-Only] Minor version number.
    """
    def __init__(self, major: int = 0, minor: int = 0) -> None:
        ...
    @property
    def major(self) -> int:
        r"""
        (int32):  [Read-Only] Major version number.
        """
        ...
    @property
    def minor(self) -> int:
        r"""
        (int32):  [Read-Only] Minor version number.
        """
        ...

class MetasoundFrontendVersion(StructBase):
    r"""
    General purpose version info for Metasound Frontend objects.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Only] Name of version.
    - ``number`` (MetasoundFrontendVersionNumber):  [Read-Only] Version number.
    """
    def __init__(self, name: Name = "None", number: MetasoundFrontendVersionNumber = [1, 0]) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of version.
        """
        ...
    @property
    def number(self) -> MetasoundFrontendVersionNumber:
        r"""
        (MetasoundFrontendVersionNumber):  [Read-Only] Version number.
        """
        ...

class MetasoundFrontendLiteral(StructBase):
    r"""
    Represents the serialized version of variant literal types.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendLiteral.h
    
    """
    def __init__(self) -> None:
        ...

class MetasoundFrontendClassName(StructBase):
    r"""
    Name of a Metasound class
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] Name of class.
    - ``namespace`` (Name):  [Read-Write] Namespace of class.
    - ``variant`` (Name):  [Read-Write] Variant of class. The Variant is used to describe an equivalent class which performs the same operation but on differing types.
    """
    def __init__(self, namespace: Name = "None", name: Name = "None", variant: Name = "None") -> None:
        ...
    @property
    def namespace(self) -> Name:
        r"""
        (Name):  [Read-Write] Namespace of class.
        """
        ...
    @namespace.setter
    def namespace(self, value: Name) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of class.
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def variant(self) -> Name:
        r"""
        (Name):  [Read-Write] Variant of class. The Variant is used to describe an equivalent class which performs the same operation but on differing types.
        """
        ...
    @variant.setter
    def variant(self, value: Name) -> None:
        ...

class WaveTableData(StructBase):
    r"""
    Serialized WaveTable data, that supports multiple bit depth formats.
    
    **C++ Source:**
    
    - **Plugin**: WaveTable
    - **Module**: WaveTable
    - **File**: WaveTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bit_depth`` (WaveTableBitDepth):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class WaveTableTransform(StructBase):
    r"""
    Wave Table Transform
    
    **C++ Source:**
    
    - **Plugin**: WaveTable
    - **Module**: WaveTable
    - **File**: WaveTableTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve`` (WaveTableCurve):  [Read-Write] The curve to apply when transforming the output.
    - ``curve_shared`` (CurveFloat):  [Read-Write] Asset curve reference to apply if output curve type is set to 'Shared.'
    - ``duration`` (float):  [Read-Write] Duration of curve or file.  Only valid if parent SampleRate is set and SamplingMode is set to 'FixedSampleRate'
      (If set to 'FixedResolution', duration is variable depending on the resolution (number of samples in the table data)
      and device's sample rate.
    - ``scalar`` (float):  [Read-Write] When curve set to log, exponential or exponential inverse, value is factor 'b' in following equations with output 'y' and input 'x':
      Exponential: y = x * 10^-b(1-x)
      Exponential (Inverse): y = ((x - 1) * 10^(-bx)) + 1
      Logarithmic: y = b * log(x) + 1
    - ``wave_table_settings`` (WaveTableSettings):  [Read-Write]
    """
    def __init__(self, curve: WaveTableCurve = WaveTableCurve.LINEAR, scalar: float = 0.000000, curve_shared: CurveFloat = None) -> None:
        ...
    @property
    def curve(self) -> WaveTableCurve:
        r"""
        (WaveTableCurve):  [Read-Write] The curve to apply when transforming the output.
        """
        ...
    @curve.setter
    def curve(self, value: WaveTableCurve) -> None:
        ...
    @property
    def scalar(self) -> float:
        r"""
        (float):  [Read-Write] When curve set to log, exponential or exponential inverse, value is factor 'b' in following equations with output 'y' and input 'x':
        Exponential: y = x * 10^-b(1-x)
        Exponential (Inverse): y = ((x - 1) * 10^(-bx)) + 1
        Logarithmic: y = b * log(x) + 1
        """
        ...
    @scalar.setter
    def scalar(self, value: float) -> None:
        ...
    @property
    def curve_shared(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] Asset curve reference to apply if output curve type is set to 'Shared.'
        """
        ...
    @curve_shared.setter
    def curve_shared(self, value: CurveFloat) -> None:
        ...

class WaveTableBankEntry(StructBase):
    r"""
    Wave Table Bank Entry
    
    **C++ Source:**
    
    - **Plugin**: WaveTable
    - **Module**: WaveTable
    - **File**: WaveTableBank.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``transform`` (WaveTableTransform):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class WaveTableSettings(StructBase):
    r"""
    Wave Table Settings
    
    **C++ Source:**
    
    - **Plugin**: WaveTable
    - **Module**: WaveTable
    - **File**: WaveTableSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_index`` (int32):  [Read-Write] Index of channel in file to build WaveTable from (wraps if channel is greater than number in file)
    - ``fade_in`` (float):  [Read-Write] Percent to fade in over.
    - ``fade_out`` (float):  [Read-Write] Percent to fade out over.
    - ``file_path`` (FilePath):  [Read-Write] File to import
    - ``normalize`` (bool):  [Read-Write] Whether or not to normalize the WaveTable.
    - ``phase`` (float):  [Read-Write] Percent to phase shift of table
    - ``remove_offset`` (bool):  [Read-Write] Whether or not to remove offset from original file
      (analogous to "DC offset" in circuit theory).
    - ``source_data`` (WaveTableData):  [Read-Write] Source data last imported from the source file
    - ``source_sample_rate`` (int32):  [Read-Only] Source sample rate from last imported source file
    - ``tail`` (float):  [Read-Write] Percent to remove from end of sampled WaveTable.
    - ``top`` (float):  [Read-Write] Percent to remove from beginning of sampled WaveTable.
    """
    def __init__(self) -> None:
        ...

class MetaSoundOutput(SoundGeneratorOutput):
    r"""
    Exposes the value of an output on a FMetasoundGenerator.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] The output's name
    """
    def __init__(self, name: Name = "None") -> None:
        ...

class MetaSoundAssetDirectory(StructBase):
    r"""
    Meta Sound Asset Directory
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundAssetSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``directory`` (DirectoryPath):  [Read-Write]
    """
    def __init__(self, directory: DirectoryPath = [""]) -> None:
        ...
    @property
    def directory(self) -> DirectoryPath:
        r"""
        (DirectoryPath):  [Read-Write]
        """
        ...
    @directory.setter
    def directory(self, value: DirectoryPath) -> None:
        ...

class MetasoundFrontendVertexHandle(StructBase):
    r"""
    Pair of guids used to address location of vertex within a FrontendDocument graph
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    """
    def __init__(self) -> None:
        ...

class MetaSoundBuilderNodeInputHandle(MetasoundFrontendVertexHandle):
    r"""
    Meta Sound Builder Node Input Handle
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundBuilderSubsystem.h
    
    """
    def __init__(self) -> None:
        ...

class MetaSoundBuilderNodeOutputHandle(MetasoundFrontendVertexHandle):
    r"""
    Meta Sound Builder Node Output Handle
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundBuilderSubsystem.h
    
    """
    def __init__(self) -> None:
        ...

class MetaSoundNodeHandle(StructBase):
    r"""
    Meta Sound Node Handle
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundBuilderSubsystem.h
    
    """
    def __init__(self) -> None:
        ...

class MetaSoundBuilderOptions(StructBase):
    r"""
    Meta Sound Builder Options
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundBuilderSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``force_unique_class_name`` (bool):  [Read-Write] If the resulting MetaSound is building over an existing document, a unique class name will be generated,
      invalidating any referencing MetaSounds and registering the MetaSound as a new entry in the Frontend. If
      building a new document, option is ignored.
    - ``name`` (Name):  [Read-Write] Name of generated object. If object already exists, used as the base name to ensure new object is unique.
    """
    def __init__(self, name: Name = "None", force_unique_class_name: bool = False) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of generated object. If object already exists, used as the base name to ensure new object is unique.
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def force_unique_class_name(self) -> bool:
        r"""
        (bool):  [Read-Write] If the resulting MetaSound is building over an existing document, a unique class name will be generated,
        invalidating any referencing MetaSounds and registering the MetaSound as a new entry in the Frontend. If
        building a new document, option is ignored.
        """
        ...
    @force_unique_class_name.setter
    def force_unique_class_name(self, value: bool) -> None:
        ...

class MetasoundFrontendDocument(StructBase):
    r"""
    Metasound Frontend Document
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``archetype_version`` (MetasoundFrontendVersion):  [Read-Write]
      deprecated: 5.0 - ArchetypeVersion has been migrated to InterfaceVersions array.
    - ``interface_versions`` (Array[MetasoundFrontendVersion]):  [Read-Write]
      deprecated: 5.0 - InterfaceVersions has been migrated to Interfaces set.
    - ``interfaces`` (Set[MetasoundFrontendVersion]):  [Read-Only]
    - ``metadata`` (MetasoundFrontendDocumentMetadata):  [Read-Write]
    - ``root_graph`` (MetasoundFrontendGraphClass):  [Read-Write]
    """
    def __init__(self) -> None:
        ...
    @property
    def archetype_version(self) -> MetasoundFrontendVersion:
        r"""
        (MetasoundFrontendVersion):  [Read-Write]
        deprecated: 5.0 - ArchetypeVersion has been migrated to InterfaceVersions array.
        """
        ...
    @archetype_version.setter
    def archetype_version(self, value: MetasoundFrontendVersion) -> None:
        ...
    @property
    def interface_versions(self) -> Array[MetasoundFrontendVersion]:
        r"""
        (Array[MetasoundFrontendVersion]):  [Read-Write]
        deprecated: 5.0 - InterfaceVersions has been migrated to Interfaces set.
        """
        ...
    @interface_versions.setter
    def interface_versions(self, value: Array[MetasoundFrontendVersion]) -> None:
        ...

class MetasoundFrontendDocumentMetadata(StructBase):
    r"""
    Metasound Frontend Document Metadata
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    """
    def __init__(self) -> None:
        ...

class MetasoundFrontendClass(StructBase):
    r"""
    Metasound Frontend Class
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``interface`` (MetasoundFrontendClassInterface):  [Read-Write]
    - ``metadata`` (MetasoundFrontendClassMetadata):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MetasoundFrontendGraphClass(MetasoundFrontendClass):
    r"""
    Metasound Frontend Graph Class
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``interface`` (MetasoundFrontendClassInterface):  [Read-Write]
    - ``metadata`` (MetasoundFrontendClassMetadata):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class MetasoundFrontendClassMetadata(StructBase):
    r"""
    Metasound Frontend Class Metadata
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``author`` (str):  [Read-Write]
    - ``category_hierarchy`` (Array[Text]):  [Read-Write]
    - ``class_name`` (MetasoundFrontendClassName):  [Read-Only]
    - ``description`` (Text):  [Read-Write]
    - ``display_name`` (Text):  [Read-Write]
    - ``is_deprecated`` (bool):  [Read-Write] If true, this node is deprecated and should not be used in new MetaSounds.
    - ``keywords`` (Array[Text]):  [Read-Write]
    - ``type`` (MetasoundFrontendClassType):  [Read-Only]
    - ``version`` (MetasoundFrontendVersionNumber):  [Read-Only]
    """
    def __init__(self) -> None:
        ...

class MetasoundFrontendClassInterface(StructBase):
    r"""
    Metasound Frontend Class Interface
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``environment`` (Array[MetasoundFrontendClassEnvironmentVariable]):  [Read-Only] Description of class environment variables.
    - ``inputs`` (Array[MetasoundFrontendClassInput]):  [Read-Only] Description of class inputs.
    - ``outputs`` (Array[MetasoundFrontendClassOutput]):  [Read-Only] Description of class outputs.
    """
    def __init__(self) -> None:
        ...

class MetasoundFrontendVertex(StructBase):
    r"""
    An FMetasoundFrontendVertex provides a named connection point of a node.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Only] Name of the vertex. Unique amongst other vertices on the same interface.
    - ``type_name`` (Name):  [Read-Only] Data type name of the vertex.
    """
    def __init__(self) -> None:
        ...

class MetasoundFrontendClassVertex(MetasoundFrontendVertex):
    r"""
    Metasound Frontend Class Vertex
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``metadata`` (MetasoundFrontendVertexMetadata):  [Read-Write] Metadata associated with vertex.
    - ``name`` (Name):  [Read-Only] Name of the vertex. Unique amongst other vertices on the same interface.
    - ``type_name`` (Name):  [Read-Only] Data type name of the vertex.
    """
    def __init__(self) -> None:
        ...

class MetasoundFrontendClassInput(MetasoundFrontendClassVertex):
    r"""
    Contains info for input vertex of a Metasound class.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_literal`` (MetasoundFrontendLiteral):  [Read-Write] Default value for this input.
    - ``metadata`` (MetasoundFrontendVertexMetadata):  [Read-Write] Metadata associated with vertex.
    - ``name`` (Name):  [Read-Only] Name of the vertex. Unique amongst other vertices on the same interface.
    - ``type_name`` (Name):  [Read-Only] Data type name of the vertex.
    """
    def __init__(self) -> None:
        ...

class MetasoundFrontendClassOutput(MetasoundFrontendClassVertex):
    r"""
    Contains info for output vertex of a Metasound class.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``metadata`` (MetasoundFrontendVertexMetadata):  [Read-Write] Metadata associated with vertex.
    - ``name`` (Name):  [Read-Only] Name of the vertex. Unique amongst other vertices on the same interface.
    - ``type_name`` (Name):  [Read-Only] Data type name of the vertex.
    """
    def __init__(self) -> None:
        ...

class MetasoundFrontendClassEnvironmentVariable(StructBase):
    r"""
    Metasound Frontend Class Environment Variable
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    """
    def __init__(self) -> None:
        ...

class MetasoundFrontendVertexMetadata(StructBase):
    r"""
    Metadata associated with a vertex.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundFrontendDocument.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``description`` (Text):  [Read-Write] Description of the vertex.
    - ``display_name`` (Text):  [Read-Write] Display name for a vertex
    """
    def __init__(self) -> None:
        ...

class MeterChannelInfo(StructBase):
    r"""
    Meter Channel Info
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioMeterTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clipping_value`` (float):  [Read-Write]
    - ``meter_value`` (float):  [Read-Write]
    - ``peak_value`` (float):  [Read-Write]
    """
    def __init__(self, meter_value: float = 0.000000, peak_value: float = 0.000000, clipping_value: float = 0.000000) -> None:
        ...
    @property
    def meter_value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @meter_value.setter
    def meter_value(self, value: float) -> None:
        ...
    @property
    def peak_value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @peak_value.setter
    def peak_value(self, value: float) -> None:
        ...
    @property
    def clipping_value(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @clipping_value.setter
    def clipping_value(self, value: float) -> None:
        ...

class AudioMeterStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SAudioMeter
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioMeterStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_image`` (SlateBrush):  [Read-Write] Image to use to represent the background.
    - ``decibels_per_hash`` (int32):  [Read-Write] How wide to draw the decibel scale, if it's enabled
    - ``font`` (SlateFontInfo):  [Read-Write] Font family and size to be used when displaying the meter scale.
    - ``meter_background_image`` (SlateBrush):  [Read-Write] Image to use to represent the meter background.
    - ``meter_padding`` (Vector2D):  [Read-Write] How much padding to add around the meter
    - ``meter_peak_image`` (SlateBrush):  [Read-Write] Image to use to represent the meter peak.
    - ``meter_size`` (Vector2D):  [Read-Write] How thick to draw the meter
    - ``meter_value_background_image`` (SlateBrush):  [Read-Write] Image to use to draw behind the meter value.
    - ``meter_value_image`` (SlateBrush):  [Read-Write] Image to use to represent the meter value.
    - ``meter_value_padding`` (float):  [Read-Write] How much padding to add around the meter value
    - ``peak_value_width`` (float):  [Read-Write] How wide to draw the peak value indicator
    - ``scale_hash_height`` (float):  [Read-Write] The height of each hash mark
    - ``scale_hash_offset`` (float):  [Read-Write] Offset for the hashes
    - ``scale_hash_width`` (float):  [Read-Write] The width of each hash mark
    - ``scale_side`` (bool):  [Read-Write] Which side to show the scale. If vertical, true means left side, false means right side. If horizontal, true means above, false means below.
    - ``show_scale`` (bool):  [Read-Write] Whether or not to show the decibel scale alongside the meter
    - ``value_range_db`` (Vector2D):  [Read-Write] The minimum and maximum value to display in dB (values are clamped in this range)
    """
    def __init__(self, meter_value_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], background_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], meter_background_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], meter_value_background_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], meter_peak_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], meter_size: Vector2D = [0.000000, 0.000000], meter_padding: Vector2D = [0.000000, 0.000000], meter_value_padding: float = 0.000000, peak_value_width: float = 0.000000, value_range_db: Vector2D = [0.000000, 0.000000], show_scale: bool = False, scale_side: bool = False, scale_hash_offset: float = 0.000000, scale_hash_width: float = 0.000000, scale_hash_height: float = 0.000000, decibels_per_hash: int = 0, font: SlateFontInfo = [None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000]) -> None:
        ...
    @property
    def meter_value_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use to represent the meter value.
        """
        ...
    @meter_value_image.setter
    def meter_value_image(self, value: SlateBrush) -> None:
        ...
    @property
    def background_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use to represent the background.
        """
        ...
    @background_image.setter
    def background_image(self, value: SlateBrush) -> None:
        ...
    @property
    def meter_background_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use to represent the meter background.
        """
        ...
    @meter_background_image.setter
    def meter_background_image(self, value: SlateBrush) -> None:
        ...
    @property
    def meter_value_background_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use to draw behind the meter value.
        """
        ...
    @meter_value_background_image.setter
    def meter_value_background_image(self, value: SlateBrush) -> None:
        ...
    @property
    def meter_peak_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use to represent the meter peak.
        """
        ...
    @meter_peak_image.setter
    def meter_peak_image(self, value: SlateBrush) -> None:
        ...
    @property
    def meter_size(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] How thick to draw the meter
        """
        ...
    @meter_size.setter
    def meter_size(self, value: Vector2D) -> None:
        ...
    @property
    def meter_padding(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] How much padding to add around the meter
        """
        ...
    @meter_padding.setter
    def meter_padding(self, value: Vector2D) -> None:
        ...
    @property
    def meter_value_padding(self) -> float:
        r"""
        (float):  [Read-Write] How much padding to add around the meter value
        """
        ...
    @meter_value_padding.setter
    def meter_value_padding(self, value: float) -> None:
        ...
    @property
    def peak_value_width(self) -> float:
        r"""
        (float):  [Read-Write] How wide to draw the peak value indicator
        """
        ...
    @peak_value_width.setter
    def peak_value_width(self, value: float) -> None:
        ...
    @property
    def value_range_db(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The minimum and maximum value to display in dB (values are clamped in this range)
        """
        ...
    @value_range_db.setter
    def value_range_db(self, value: Vector2D) -> None:
        ...
    @property
    def show_scale(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to show the decibel scale alongside the meter
        """
        ...
    @show_scale.setter
    def show_scale(self, value: bool) -> None:
        ...
    @property
    def scale_side(self) -> bool:
        r"""
        (bool):  [Read-Write] Which side to show the scale. If vertical, true means left side, false means right side. If horizontal, true means above, false means below.
        """
        ...
    @scale_side.setter
    def scale_side(self, value: bool) -> None:
        ...
    @property
    def scale_hash_offset(self) -> float:
        r"""
        (float):  [Read-Write] Offset for the hashes
        """
        ...
    @scale_hash_offset.setter
    def scale_hash_offset(self, value: float) -> None:
        ...
    @property
    def scale_hash_width(self) -> float:
        r"""
        (float):  [Read-Write] The width of each hash mark
        """
        ...
    @scale_hash_width.setter
    def scale_hash_width(self, value: float) -> None:
        ...
    @property
    def scale_hash_height(self) -> float:
        r"""
        (float):  [Read-Write] The height of each hash mark
        """
        ...
    @scale_hash_height.setter
    def scale_hash_height(self, value: float) -> None:
        ...
    @property
    def decibels_per_hash(self) -> int:
        r"""
        (int32):  [Read-Write] How wide to draw the decibel scale, if it's enabled
        """
        ...
    @decibels_per_hash.setter
    def decibels_per_hash(self, value: int) -> None:
        ...
    @property
    def font(self) -> SlateFontInfo:
        r"""
        (SlateFontInfo):  [Read-Write] Font family and size to be used when displaying the meter scale.
        """
        ...
    @font.setter
    def font(self, value: SlateFontInfo) -> None:
        ...

class AudioOscilloscopePanelStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SAudioOscilloscopePanelWidget
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioOscilloscopePanelStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``time_ruler_style`` (FixedSampleSequenceRulerStyle):  [Read-Write] The time rule style.
    - ``trigger_threshold_line_style`` (TriggerThresholdLineStyle):  [Read-Write] The triggerthreshold line style.
    - ``value_grid_style`` (SampledSequenceValueGridOverlayStyle):  [Read-Write] The value grid style.
    - ``wave_viewer_style`` (SampledSequenceViewerStyle):  [Read-Write] The waveform view style.
    """
    def __init__(self, time_ruler_style: FixedSampleSequenceRulerStyle = [15.000000, [[255.000000, 0.100000, 0.200000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [[1.000000, 1.000000, 1.000000, 0.900000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[1.000000, 1.000000, 1.000000, 0.900000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "Regular", 10.000000, 0, 0.000000, False, 1.000000], 5.000000, [[0.000000, 0.000000, 0.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], 1280.000000, 30.000000], value_grid_style: SampledSequenceValueGridOverlayStyle = [[[0.000000, 0.000000, 0.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 1.000000, [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "Regular", 10.000000, 0, 0.000000, False, 1.000000], 1280.000000, 720.000000], wave_viewer_style: SampledSequenceViewerStyle = [[[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 1.000000, [[0.000000, 0.000000, 0.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.500000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 1.000000, 2.500000, [[0.020000, 0.020000, 0.020000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], 1280.000000, 720.000000], trigger_threshold_line_style: TriggerThresholdLineStyle = [[1.000000, 1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def time_ruler_style(self) -> FixedSampleSequenceRulerStyle:
        r"""
        (FixedSampleSequenceRulerStyle):  [Read-Write] The time rule style.
        """
        ...
    @time_ruler_style.setter
    def time_ruler_style(self, value: FixedSampleSequenceRulerStyle) -> None:
        ...
    @property
    def value_grid_style(self) -> SampledSequenceValueGridOverlayStyle:
        r"""
        (SampledSequenceValueGridOverlayStyle):  [Read-Write] The value grid style.
        """
        ...
    @value_grid_style.setter
    def value_grid_style(self, value: SampledSequenceValueGridOverlayStyle) -> None:
        ...
    @property
    def wave_viewer_style(self) -> SampledSequenceViewerStyle:
        r"""
        (SampledSequenceViewerStyle):  [Read-Write] The waveform view style.
        """
        ...
    @wave_viewer_style.setter
    def wave_viewer_style(self, value: SampledSequenceViewerStyle) -> None:
        ...
    @property
    def trigger_threshold_line_style(self) -> TriggerThresholdLineStyle:
        r"""
        (TriggerThresholdLineStyle):  [Read-Write] The triggerthreshold line style.
        """
        ...
    @trigger_threshold_line_style.setter
    def trigger_threshold_line_style(self, value: TriggerThresholdLineStyle) -> None:
        ...

class TriggerThresholdLineStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of a trigger threshold line
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: TriggerThresholdLineStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``line_color`` (LinearColor):  [Read-Write] The trigger threshold line color.
    """
    def __init__(self, line_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def line_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The trigger threshold line color.
        """
        ...
    @line_color.setter
    def line_color(self, value: LinearColor) -> None:
        ...

class SampledSequenceViewerStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of a Sampled Sequence Viewer
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioWidgetsSlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_brush`` (SlateBrush):  [Read-Write]
    - ``desired_height`` (float):  [Read-Write]
    - ``desired_width`` (float):  [Read-Write]
    - ``major_grid_line_color`` (SlateColor):  [Read-Write]
    - ``minor_grid_line_color`` (SlateColor):  [Read-Write]
    - ``sample_markers_size`` (float):  [Read-Write]
    - ``sequence_background_color`` (SlateColor):  [Read-Write]
    - ``sequence_color`` (SlateColor):  [Read-Write]
    - ``sequence_line_thickness`` (float):  [Read-Write]
    - ``zero_crossing_line_color`` (SlateColor):  [Read-Write]
    - ``zero_crossing_line_thickness`` (float):  [Read-Write]
    """
    def __init__(self, sequence_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], sequence_line_thickness: float = 0.000000, major_grid_line_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], minor_grid_line_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], zero_crossing_line_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], zero_crossing_line_thickness: float = 0.000000, sample_markers_size: float = 0.000000, sequence_background_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], desired_width: float = 0.000000, desired_height: float = 0.000000) -> None:
        ...
    @property
    def sequence_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @sequence_color.setter
    def sequence_color(self, value: SlateColor) -> None:
        ...
    @property
    def sequence_line_thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @sequence_line_thickness.setter
    def sequence_line_thickness(self, value: float) -> None:
        ...
    @property
    def major_grid_line_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @major_grid_line_color.setter
    def major_grid_line_color(self, value: SlateColor) -> None:
        ...
    @property
    def minor_grid_line_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @minor_grid_line_color.setter
    def minor_grid_line_color(self, value: SlateColor) -> None:
        ...
    @property
    def zero_crossing_line_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @zero_crossing_line_color.setter
    def zero_crossing_line_color(self, value: SlateColor) -> None:
        ...
    @property
    def zero_crossing_line_thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @zero_crossing_line_thickness.setter
    def zero_crossing_line_thickness(self, value: float) -> None:
        ...
    @property
    def sample_markers_size(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @sample_markers_size.setter
    def sample_markers_size(self, value: float) -> None:
        ...
    @property
    def sequence_background_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @sequence_background_color.setter
    def sequence_background_color(self, value: SlateColor) -> None:
        ...
    @property
    def background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @background_brush.setter
    def background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def desired_width(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @desired_width.setter
    def desired_width(self, value: float) -> None:
        ...
    @property
    def desired_height(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @desired_height.setter
    def desired_height(self, value: float) -> None:
        ...

class SampledSequenceValueGridOverlayStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of a Sampled Sequence Value Grid Overlay
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioWidgetsSlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desired_height`` (float):  [Read-Write]
    - ``desired_width`` (float):  [Read-Write]
    - ``grid_color`` (SlateColor):  [Read-Write]
    - ``grid_thickness`` (float):  [Read-Write]
    - ``label_text_color`` (SlateColor):  [Read-Write]
    - ``label_text_font`` (SlateFontInfo):  [Read-Write]
    """
    def __init__(self, grid_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], grid_thickness: float = 0.000000, label_text_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], label_text_font: SlateFontInfo = [None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000], desired_width: float = 0.000000, desired_height: float = 0.000000) -> None:
        ...
    @property
    def grid_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @grid_color.setter
    def grid_color(self, value: SlateColor) -> None:
        ...
    @property
    def grid_thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @grid_thickness.setter
    def grid_thickness(self, value: float) -> None:
        ...
    @property
    def label_text_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @label_text_color.setter
    def label_text_color(self, value: SlateColor) -> None:
        ...
    @property
    def label_text_font(self) -> SlateFontInfo:
        r"""
        (SlateFontInfo):  [Read-Write]
        """
        ...
    @label_text_font.setter
    def label_text_font(self, value: SlateFontInfo) -> None:
        ...
    @property
    def desired_width(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @desired_width.setter
    def desired_width(self, value: float) -> None:
        ...
    @property
    def desired_height(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @desired_height.setter
    def desired_height(self, value: float) -> None:
        ...

class FixedSampleSequenceRulerStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of a Sampled Sequence Time Ruler
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioWidgetsSlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_brush`` (SlateBrush):  [Read-Write]
    - ``background_color`` (SlateColor):  [Read-Write]
    - ``desired_height`` (float):  [Read-Write]
    - ``desired_width`` (float):  [Read-Write]
    - ``handle_brush`` (SlateBrush):  [Read-Write]
    - ``handle_color`` (SlateColor):  [Read-Write]
    - ``handle_width`` (float):  [Read-Write]
    - ``ticks_color`` (SlateColor):  [Read-Write]
    - ``ticks_text_color`` (SlateColor):  [Read-Write]
    - ``ticks_text_font`` (SlateFontInfo):  [Read-Write]
    - ``ticks_text_offset`` (float):  [Read-Write]
    """
    def __init__(self, handle_width: float = 0.000000, handle_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], handle_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], ticks_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], ticks_text_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], ticks_text_font: SlateFontInfo = [None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000], ticks_text_offset: float = 0.000000, background_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], desired_width: float = 0.000000, desired_height: float = 0.000000) -> None:
        ...
    @property
    def handle_width(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @handle_width.setter
    def handle_width(self, value: float) -> None:
        ...
    @property
    def handle_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @handle_color.setter
    def handle_color(self, value: SlateColor) -> None:
        ...
    @property
    def handle_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @handle_brush.setter
    def handle_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def ticks_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @ticks_color.setter
    def ticks_color(self, value: SlateColor) -> None:
        ...
    @property
    def ticks_text_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @ticks_text_color.setter
    def ticks_text_color(self, value: SlateColor) -> None:
        ...
    @property
    def ticks_text_font(self) -> SlateFontInfo:
        r"""
        (SlateFontInfo):  [Read-Write]
        """
        ...
    @ticks_text_font.setter
    def ticks_text_font(self, value: SlateFontInfo) -> None:
        ...
    @property
    def ticks_text_offset(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @ticks_text_offset.setter
    def ticks_text_offset(self, value: float) -> None:
        ...
    @property
    def background_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @background_color.setter
    def background_color(self, value: SlateColor) -> None:
        ...
    @property
    def background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @background_brush.setter
    def background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def desired_width(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @desired_width.setter
    def desired_width(self, value: float) -> None:
        ...
    @property
    def desired_height(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @desired_height.setter
    def desired_height(self, value: float) -> None:
        ...

class AudioVectorscopePanelStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SAudioVectorscopePanelWidget
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioVectorscopePanelStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``value_grid_style`` (SampledSequenceValueGridOverlayStyle):  [Read-Write] The value grid style.
    - ``vector_viewer_style`` (SampledSequenceVectorViewerStyle):  [Read-Write] The vector view style.
    """
    def __init__(self, value_grid_style: SampledSequenceValueGridOverlayStyle = [[[0.000000, 0.000000, 0.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 1.000000, [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "Regular", 10.000000, 0, 0.000000, False, 1.000000], 1280.000000, 720.000000], vector_viewer_style: SampledSequenceVectorViewerStyle = [[[0.000000, 0.000000, 0.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [1.000000, 1.000000, 1.000000, 1.000000], 1.000000]) -> None:
        ...
    @property
    def value_grid_style(self) -> SampledSequenceValueGridOverlayStyle:
        r"""
        (SampledSequenceValueGridOverlayStyle):  [Read-Write] The value grid style.
        """
        ...
    @value_grid_style.setter
    def value_grid_style(self, value: SampledSequenceValueGridOverlayStyle) -> None:
        ...
    @property
    def vector_viewer_style(self) -> SampledSequenceVectorViewerStyle:
        r"""
        (SampledSequenceVectorViewerStyle):  [Read-Write] The vector view style.
        """
        ...
    @vector_viewer_style.setter
    def vector_viewer_style(self, value: SampledSequenceVectorViewerStyle) -> None:
        ...

class SampledSequenceVectorViewerStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of a trigger threshold line
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: SampledSequenceVectorViewerStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_brush`` (SlateBrush):  [Read-Write]
    - ``background_color`` (SlateColor):  [Read-Write] The background color.
    - ``line_color`` (LinearColor):  [Read-Write] The vector view line color.
    - ``line_thickness`` (float):  [Read-Write] The vector view line thickness.
    """
    def __init__(self, background_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], background_brush: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], line_color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], line_thickness: float = 0.000000) -> None:
        ...
    @property
    def background_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] The background color.
        """
        ...
    @background_color.setter
    def background_color(self, value: SlateColor) -> None:
        ...
    @property
    def background_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @background_brush.setter
    def background_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def line_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The vector view line color.
        """
        ...
    @line_color.setter
    def line_color(self, value: LinearColor) -> None:
        ...
    @property
    def line_thickness(self) -> float:
        r"""
        (float):  [Read-Write] The vector view line thickness.
        """
        ...
    @line_thickness.setter
    def line_thickness(self, value: float) -> None:
        ...

class AudioSpectrumPlotStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SAudioSpectrumPlot
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioSpectrumPlotStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis_label_color`` (SlateColor):  [Read-Write]
    - ``axis_label_font`` (SlateFontInfo):  [Read-Write]
    - ``background_color`` (SlateColor):  [Read-Write]
    - ``grid_color`` (SlateColor):  [Read-Write]
    - ``spectrum_color`` (SlateColor):  [Read-Write]
    """
    def __init__(self, background_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], grid_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], axis_label_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], axis_label_font: SlateFontInfo = [None, None, [0, False, False, False, None, [0.000000, 0.000000, 0.000000, 1.000000]], "None", 24.000000, 0, 0.000000, False, 1.000000], spectrum_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED]) -> None:
        ...
    @property
    def background_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @background_color.setter
    def background_color(self, value: SlateColor) -> None:
        ...
    @property
    def grid_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @grid_color.setter
    def grid_color(self, value: SlateColor) -> None:
        ...
    @property
    def axis_label_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @axis_label_color.setter
    def axis_label_color(self, value: SlateColor) -> None:
        ...
    @property
    def axis_label_font(self) -> SlateFontInfo:
        r"""
        (SlateFontInfo):  [Read-Write]
        """
        ...
    @axis_label_font.setter
    def axis_label_font(self, value: SlateFontInfo) -> None:
        ...
    @property
    def spectrum_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @spectrum_color.setter
    def spectrum_color(self, value: SlateColor) -> None:
        ...

class AudioTextBoxStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an Audio Text Box
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioWidgetsSlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_color`` (SlateColor):  [Read-Write] Color used to draw the label background
    - ``background_image`` (SlateBrush):  [Read-Write] Image for the label border
    """
    def __init__(self, background_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], background_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED]) -> None:
        ...
    @property
    def background_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image for the label border
        """
        ...
    @background_image.setter
    def background_image(self, value: SlateBrush) -> None:
        ...
    @property
    def background_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Color used to draw the label background
        """
        ...
    @background_color.setter
    def background_color(self, value: SlateColor) -> None:
        ...

class AudioSliderStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an Audio Slider
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioWidgetsSlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``label_padding`` (float):  [Read-Write] Size of the padding between the label and the slider
    - ``slider_background_color`` (SlateColor):  [Read-Write] Color used to draw the slider background
    - ``slider_background_size`` (Vector2D):  [Read-Write] Size of the slider background (slider default is vertical)
    - ``slider_bar_color`` (SlateColor):  [Read-Write] Color used to draw the slider bar
    - ``slider_style`` (SliderStyle):  [Read-Write] The style to use for the underlying SSlider.
    - ``slider_thumb_color`` (SlateColor):  [Read-Write] Color used to draw the slider thumb (handle)
    - ``text_box_style`` (AudioTextBoxStyle):  [Read-Write] The style to use for the audio text box widget.
    - ``widget_background_color`` (SlateColor):  [Read-Write] Color used to draw the widget background
    - ``widget_background_image`` (SlateBrush):  [Read-Write] Image for the widget background
    """
    def __init__(self, slider_style: SliderStyle = [[SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], 2.000000], text_box_style: AudioTextBoxStyle = [[SlateBrushDrawType.ROUNDED_BOX, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], 0], [[4.000000, 4.000000, 4.000000, 4.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.FIXED_RADIUS, False], None], [[0.000000, 0.000000, 0.000000, 0.000000], 0]], widget_background_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], slider_background_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], slider_background_size: Vector2D = [0.000000, 0.000000], label_padding: float = 0.000000, slider_bar_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], slider_thumb_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], widget_background_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED]) -> None:
        ...
    @property
    def slider_style(self) -> SliderStyle:
        r"""
        (SliderStyle):  [Read-Write] The style to use for the underlying SSlider.
        """
        ...
    @slider_style.setter
    def slider_style(self, value: SliderStyle) -> None:
        ...
    @property
    def text_box_style(self) -> AudioTextBoxStyle:
        r"""
        (AudioTextBoxStyle):  [Read-Write] The style to use for the audio text box widget.
        """
        ...
    @text_box_style.setter
    def text_box_style(self, value: AudioTextBoxStyle) -> None:
        ...
    @property
    def widget_background_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image for the widget background
        """
        ...
    @widget_background_image.setter
    def widget_background_image(self, value: SlateBrush) -> None:
        ...
    @property
    def slider_background_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Color used to draw the slider background
        """
        ...
    @slider_background_color.setter
    def slider_background_color(self, value: SlateColor) -> None:
        ...
    @property
    def slider_background_size(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Size of the slider background (slider default is vertical)
        """
        ...
    @slider_background_size.setter
    def slider_background_size(self, value: Vector2D) -> None:
        ...
    @property
    def label_padding(self) -> float:
        r"""
        (float):  [Read-Write] Size of the padding between the label and the slider
        """
        ...
    @label_padding.setter
    def label_padding(self, value: float) -> None:
        ...
    @property
    def slider_bar_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Color used to draw the slider bar
        """
        ...
    @slider_bar_color.setter
    def slider_bar_color(self, value: SlateColor) -> None:
        ...
    @property
    def slider_thumb_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Color used to draw the slider thumb (handle)
        """
        ...
    @slider_thumb_color.setter
    def slider_thumb_color(self, value: SlateColor) -> None:
        ...
    @property
    def widget_background_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Color used to draw the widget background
        """
        ...
    @widget_background_color.setter
    def widget_background_color(self, value: SlateColor) -> None:
        ...

class AudioRadialSliderStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an Audio Radial Slider
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioWidgetsSlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``center_background_color`` (SlateColor):  [Read-Write] Color used to draw the slider center background
    - ``default_slider_radius`` (float):  [Read-Write] Default size of the slider itself (not including label)
    - ``label_padding`` (float):  [Read-Write] Size of the padding between the label and the slider
    - ``slider_bar_color`` (SlateColor):  [Read-Write] Color used to draw the unprogressed slider bar
    - ``slider_progress_color`` (SlateColor):  [Read-Write] Color used to draw the progress bar
    - ``text_box_style`` (AudioTextBoxStyle):  [Read-Write] The style to use for the audio text box widget.
    """
    def __init__(self, text_box_style: AudioTextBoxStyle = [[SlateBrushDrawType.ROUNDED_BOX, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], 0], [[4.000000, 4.000000, 4.000000, 4.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.FIXED_RADIUS, False], None], [[0.000000, 0.000000, 0.000000, 0.000000], 0]], center_background_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], slider_bar_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], slider_progress_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], label_padding: float = 0.000000, default_slider_radius: float = 0.000000) -> None:
        ...
    @property
    def text_box_style(self) -> AudioTextBoxStyle:
        r"""
        (AudioTextBoxStyle):  [Read-Write] The style to use for the audio text box widget.
        """
        ...
    @text_box_style.setter
    def text_box_style(self, value: AudioTextBoxStyle) -> None:
        ...
    @property
    def center_background_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Color used to draw the slider center background
        """
        ...
    @center_background_color.setter
    def center_background_color(self, value: SlateColor) -> None:
        ...
    @property
    def slider_bar_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Color used to draw the unprogressed slider bar
        """
        ...
    @slider_bar_color.setter
    def slider_bar_color(self, value: SlateColor) -> None:
        ...
    @property
    def slider_progress_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] Color used to draw the progress bar
        """
        ...
    @slider_progress_color.setter
    def slider_progress_color(self, value: SlateColor) -> None:
        ...
    @property
    def label_padding(self) -> float:
        r"""
        (float):  [Read-Write] Size of the padding between the label and the slider
        """
        ...
    @label_padding.setter
    def label_padding(self, value: float) -> None:
        ...
    @property
    def default_slider_radius(self) -> float:
        r"""
        (float):  [Read-Write] Default size of the slider itself (not including label)
        """
        ...
    @default_slider_radius.setter
    def default_slider_radius(self, value: float) -> None:
        ...

class PlayheadOverlayStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of a Waveform Viewer Overlay style
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioWidgetsSlateTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desired_height`` (float):  [Read-Write]
    - ``desired_width`` (float):  [Read-Write]
    - ``playhead_color`` (SlateColor):  [Read-Write]
    - ``playhead_width`` (float):  [Read-Write]
    """
    def __init__(self, playhead_color: SlateColor = [[1.000000, 0.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], playhead_width: float = 0.000000, desired_width: float = 0.000000, desired_height: float = 0.000000) -> None:
        ...
    @property
    def playhead_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @playhead_color.setter
    def playhead_color(self, value: SlateColor) -> None:
        ...
    @property
    def playhead_width(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @playhead_width.setter
    def playhead_width(self, value: float) -> None:
        ...
    @property
    def desired_width(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @desired_width.setter
    def desired_width(self, value: float) -> None:
        ...
    @property
    def desired_height(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @desired_height.setter
    def desired_height(self, value: float) -> None:
        ...

class ProcMeshTangent(StructBase):
    r"""
    Struct used to specify a tangent vector for a vertex
    The Y tangent is computed from the cross product of the vertex normal (Tangent Z) and the TangentX member.
    
    **C++ Source:**
    
    - **Plugin**: ProceduralMeshComponent
    - **Module**: ProceduralMeshComponent
    - **File**: ProceduralMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``flip_tangent_y`` (bool):  [Read-Write] Bool that indicates whether we should flip the Y tangent when we compute it using cross product
    - ``tangent_x`` (Vector):  [Read-Write] Direction of X tangent for this vertex
    """
    def __init__(self, tangent_x: Vector = [0.000000, 0.000000, 0.000000], flip_tangent_y: bool = False) -> None:
        ...
    @property
    def tangent_x(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Direction of X tangent for this vertex
        """
        ...
    @tangent_x.setter
    def tangent_x(self, value: Vector) -> None:
        ...
    @property
    def flip_tangent_y(self) -> bool:
        r"""
        (bool):  [Read-Write] Bool that indicates whether we should flip the Y tangent when we compute it using cross product
        """
        ...
    @flip_tangent_y.setter
    def flip_tangent_y(self, value: bool) -> None:
        ...

class ProcMeshVertex(StructBase):
    r"""
    One vertex for the procedural mesh, used for storing data internally
    
    **C++ Source:**
    
    - **Plugin**: ProceduralMeshComponent
    - **Module**: ProceduralMeshComponent
    - **File**: ProceduralMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (Color):  [Read-Write] Vertex color
    - ``normal`` (Vector):  [Read-Write] Vertex normal
    - ``position`` (Vector):  [Read-Write] Vertex position
    - ``tangent`` (ProcMeshTangent):  [Read-Write] Vertex tangent
    - ``uv0`` (Vector2D):  [Read-Write] Vertex texture co-ordinate
    - ``uv1`` (Vector2D):  [Read-Write] Vertex texture co-ordinate
    - ``uv2`` (Vector2D):  [Read-Write] Vertex texture co-ordinate
    - ``uv3`` (Vector2D):  [Read-Write] Vertex texture co-ordinate
    """
    def __init__(self, position: Vector = [0.000000, 0.000000, 0.000000], normal: Vector = [0.000000, 0.000000, 0.000000], tangent: ProcMeshTangent = [[1.000000, 0.000000, 0.000000], False], color: Color = [0, 0, 0, 0], uv0: Vector2D = [0.000000, 0.000000], uv1: Vector2D = [0.000000, 0.000000], uv2: Vector2D = [0.000000, 0.000000], uv3: Vector2D = [0.000000, 0.000000]) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Vertex position
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...
    @property
    def normal(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Vertex normal
        """
        ...
    @normal.setter
    def normal(self, value: Vector) -> None:
        ...
    @property
    def tangent(self) -> ProcMeshTangent:
        r"""
        (ProcMeshTangent):  [Read-Write] Vertex tangent
        """
        ...
    @tangent.setter
    def tangent(self, value: ProcMeshTangent) -> None:
        ...
    @property
    def color(self) -> Color:
        r"""
        (Color):  [Read-Write] Vertex color
        """
        ...
    @color.setter
    def color(self, value: Color) -> None:
        ...
    @property
    def uv0(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Vertex texture co-ordinate
        """
        ...
    @uv0.setter
    def uv0(self, value: Vector2D) -> None:
        ...
    @property
    def uv1(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Vertex texture co-ordinate
        """
        ...
    @uv1.setter
    def uv1(self, value: Vector2D) -> None:
        ...
    @property
    def uv2(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Vertex texture co-ordinate
        """
        ...
    @uv2.setter
    def uv2(self, value: Vector2D) -> None:
        ...
    @property
    def uv3(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Vertex texture co-ordinate
        """
        ...
    @uv3.setter
    def uv3(self, value: Vector2D) -> None:
        ...

class LocationServicesData(StructBase):
    r"""
    Struct to hold relevant location data retrieved from the mobile implementation's Location Service
    
    **C++ Source:**
    
    - **Plugin**: LocationServicesBPLibrary
    - **Module**: LocationServicesBPLibrary
    - **File**: LocationServicesBPLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``altitude`` (float):  [Read-Write] In meters, if provided with the result
    - ``horizontal_accuracy`` (float):  [Read-Write] Estimated horizontal (Android: overall) accuracy of the result, in meters
    - ``latitude`` (float):  [Read-Write]
    - ``longitude`` (float):  [Read-Write]
    - ``timestamp`` (float):  [Read-Write] Timestamp from when this location data was taken (UTC time in milliseconds since 1 January 1970)
    - ``vertical_accuracy`` (float):  [Read-Write] Estimated accuracy of the result, in meters (iOS only)
    """
    def __init__(self, timestamp: float = 0.000000, longitude: float = 0.000000, latitude: float = 0.000000, horizontal_accuracy: float = 0.000000, vertical_accuracy: float = 0.000000, altitude: float = 0.000000) -> None:
        ...
    @property
    def timestamp(self) -> float:
        r"""
        (float):  [Read-Write] Timestamp from when this location data was taken (UTC time in milliseconds since 1 January 1970)
        """
        ...
    @timestamp.setter
    def timestamp(self, value: float) -> None:
        ...
    @property
    def longitude(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @longitude.setter
    def longitude(self, value: float) -> None:
        ...
    @property
    def latitude(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @latitude.setter
    def latitude(self, value: float) -> None:
        ...
    @property
    def horizontal_accuracy(self) -> float:
        r"""
        (float):  [Read-Write] Estimated horizontal (Android: overall) accuracy of the result, in meters
        """
        ...
    @horizontal_accuracy.setter
    def horizontal_accuracy(self, value: float) -> None:
        ...
    @property
    def vertical_accuracy(self) -> float:
        r"""
        (float):  [Read-Write] Estimated accuracy of the result, in meters (iOS only)
        """
        ...
    @vertical_accuracy.setter
    def vertical_accuracy(self, value: float) -> None:
        ...
    @property
    def altitude(self) -> float:
        r"""
        (float):  [Read-Write] In meters, if provided with the result
        """
        ...
    @altitude.setter
    def altitude(self, value: float) -> None:
        ...

class ResonanceAudioReverbPluginSettings(StructBase):
    r"""
    Resonance Audio Reverb Plugin Settings
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudio
    - **File**: ResonanceAudioReverb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``back_wall_material`` (RaMaterialName):  [Read-Write] Back wall acoustic material
    - ``ceiling_material`` (RaMaterialName):  [Read-Write] Ceiling acoustic material
    - ``enable_room_effects`` (bool):  [Read-Write] Whether Resonance Audio room effects are enabled
    - ``floor_material`` (RaMaterialName):  [Read-Write] Floor acoustic material
    - ``front_wall_material`` (RaMaterialName):  [Read-Write] Front wall acoustic material
    - ``get_transform_from_audio_volume`` (bool):  [Read-Write] Whether the room transform should be taken from the Audio Volume this preset is attached to.
      If not used with the Audio Volume, last saved values will be used.
    - ``left_wall_material`` (RaMaterialName):  [Read-Write] Left wall acoustic material
    - ``reflection_scalar`` (float):  [Read-Write] Early reflections gain multiplier. Default: 1.0
    - ``reverb_brightness`` (float):  [Read-Write] Reverb brightness modifier. Default: 0.0
    - ``reverb_gain`` (float):  [Read-Write] Reverb gain multiplier. Default: 1.0
    - ``reverb_time_modifier`` (float):  [Read-Write] Reverb time modifier. Default: 1.0
    - ``right_wall_material`` (RaMaterialName):  [Read-Write] Right wall acoustic material
    - ``room_dimensions`` (Vector):  [Read-Write] Room dimensions in 3D space
    - ``room_position`` (Vector):  [Read-Write] Room position in 3D space
    - ``room_rotation`` (Quat):  [Read-Write] Room rotation in 3D space
    """
    def __init__(self, enable_room_effects: bool = False, room_position: Vector = [0.000000, 0.000000, 0.000000], room_rotation: Quat = [0.000000, 0.000000, 0.000000, 1.000000], room_dimensions: Vector = [0.000000, 0.000000, 0.000000], left_wall_material: RaMaterialName = RaMaterialName.TRANSPARENT, right_wall_material: RaMaterialName = RaMaterialName.TRANSPARENT, floor_material: RaMaterialName = RaMaterialName.TRANSPARENT, ceiling_material: RaMaterialName = RaMaterialName.TRANSPARENT, front_wall_material: RaMaterialName = RaMaterialName.TRANSPARENT, back_wall_material: RaMaterialName = RaMaterialName.TRANSPARENT, reflection_scalar: float = 0.000000, reverb_gain: float = 0.000000, reverb_time_modifier: float = 0.000000, reverb_brightness: float = 0.000000) -> None:
        ...
    @property
    def enable_room_effects(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether Resonance Audio room effects are enabled
        """
        ...
    @enable_room_effects.setter
    def enable_room_effects(self, value: bool) -> None:
        ...
    @property
    def room_position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Room position in 3D space
        """
        ...
    @room_position.setter
    def room_position(self, value: Vector) -> None:
        ...
    @property
    def room_rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Write] Room rotation in 3D space
        """
        ...
    @room_rotation.setter
    def room_rotation(self, value: Quat) -> None:
        ...
    @property
    def room_dimensions(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Room dimensions in 3D space
        """
        ...
    @room_dimensions.setter
    def room_dimensions(self, value: Vector) -> None:
        ...
    @property
    def left_wall_material(self) -> RaMaterialName:
        r"""
        (RaMaterialName):  [Read-Write] Left wall acoustic material
        """
        ...
    @left_wall_material.setter
    def left_wall_material(self, value: RaMaterialName) -> None:
        ...
    @property
    def right_wall_material(self) -> RaMaterialName:
        r"""
        (RaMaterialName):  [Read-Write] Right wall acoustic material
        """
        ...
    @right_wall_material.setter
    def right_wall_material(self, value: RaMaterialName) -> None:
        ...
    @property
    def floor_material(self) -> RaMaterialName:
        r"""
        (RaMaterialName):  [Read-Write] Floor acoustic material
        """
        ...
    @floor_material.setter
    def floor_material(self, value: RaMaterialName) -> None:
        ...
    @property
    def ceiling_material(self) -> RaMaterialName:
        r"""
        (RaMaterialName):  [Read-Write] Ceiling acoustic material
        """
        ...
    @ceiling_material.setter
    def ceiling_material(self, value: RaMaterialName) -> None:
        ...
    @property
    def front_wall_material(self) -> RaMaterialName:
        r"""
        (RaMaterialName):  [Read-Write] Front wall acoustic material
        """
        ...
    @front_wall_material.setter
    def front_wall_material(self, value: RaMaterialName) -> None:
        ...
    @property
    def back_wall_material(self) -> RaMaterialName:
        r"""
        (RaMaterialName):  [Read-Write] Back wall acoustic material
        """
        ...
    @back_wall_material.setter
    def back_wall_material(self, value: RaMaterialName) -> None:
        ...
    @property
    def reflection_scalar(self) -> float:
        r"""
        (float):  [Read-Write] Early reflections gain multiplier. Default: 1.0
        """
        ...
    @reflection_scalar.setter
    def reflection_scalar(self, value: float) -> None:
        ...
    @property
    def reverb_gain(self) -> float:
        r"""
        (float):  [Read-Write] Reverb gain multiplier. Default: 1.0
        """
        ...
    @reverb_gain.setter
    def reverb_gain(self, value: float) -> None:
        ...
    @property
    def reverb_time_modifier(self) -> float:
        r"""
        (float):  [Read-Write] Reverb time modifier. Default: 1.0
        """
        ...
    @reverb_time_modifier.setter
    def reverb_time_modifier(self, value: float) -> None:
        ...
    @property
    def reverb_brightness(self) -> float:
        r"""
        (float):  [Read-Write] Reverb brightness modifier. Default: 0.0
        """
        ...
    @reverb_brightness.setter
    def reverb_brightness(self, value: float) -> None:
        ...

class Synth1PatchCable(StructBase):
    r"""
    Synth 1Patch Cable
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``depth`` (float):  [Read-Write] The patch depth (how much the modulator modulates the destination)
    - ``destination`` (Synth1PatchDestination):  [Read-Write] The patch destination type
    """
    def __init__(self, depth: float = 0.000000, destination: Synth1PatchDestination = Synth1PatchDestination.OSC1_GAIN) -> None:
        ...
    @property
    def depth(self) -> float:
        r"""
        (float):  [Read-Write] The patch depth (how much the modulator modulates the destination)
        """
        ...
    @depth.setter
    def depth(self, value: float) -> None:
        ...
    @property
    def destination(self) -> Synth1PatchDestination:
        r"""
        (Synth1PatchDestination):  [Read-Write] The patch destination type
        """
        ...
    @destination.setter
    def destination(self, value: Synth1PatchDestination) -> None:
        ...

class PatchId(StructBase):
    r"""
    Patch Id
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Types.h
    
    """
    def __init__(self) -> None:
        ...

class EpicSynth1Patch(StructBase):
    r"""
    Epic Synth 1Patch
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Component.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``patch_cables`` (Array[Synth1PatchCable]):  [Read-Write] Patch cables to patch destinations from the patch source.
    - ``patch_source`` (Synth1PatchSource):  [Read-Write] A modular synth patch source (e.g. LFO1/LFO2/Modulation Envelope)
    """
    def __init__(self, patch_source: Synth1PatchSource = Synth1PatchSource.LFO1, patch_cables: Array[Synth1PatchCable] = []) -> None:
        ...
    @property
    def patch_source(self) -> Synth1PatchSource:
        r"""
        (Synth1PatchSource):  [Read-Write] A modular synth patch source (e.g. LFO1/LFO2/Modulation Envelope)
        """
        ...
    @patch_source.setter
    def patch_source(self, value: Synth1PatchSource) -> None:
        ...
    @property
    def patch_cables(self) -> Array[Synth1PatchCable]:
        r"""
        (Array[Synth1PatchCable]):  [Read-Write] Patch cables to patch destinations from the patch source.
        """
        ...
    @patch_cables.setter
    def patch_cables(self, value: Array[Synth1PatchCable]) -> None:
        ...

class ModularSynthPreset(TableRowBase):
    r"""
    Modular Synth Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Component.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attack_time`` (float):  [Read-Write] The amplitude envelope attack time (in ms) [0.0, 10000]
    - ``chorus_depth`` (float):  [Read-Write] The depth of the chorus effect [0.0, 1.0]
    - ``chorus_enabled`` (bool):  [Read-Write] Whether or not the chorus effect is enabled
    - ``chorus_feedback`` (float):  [Read-Write] The amount of feedback in the chorus effect [0.0, 1.0]
    - ``chorus_frequency`` (float):  [Read-Write] The chorus LFO frequency [0.0, 20.0]
    - ``decay_time`` (float):  [Read-Write] The amplitude envelope decay time (in ms)[0.0, 10000]
    - ``enable_oscillator_sync`` (bool):  [Read-Write] Whether or not oscillator sync is enabled. Oscillator sync forces oscillator 2's phase to align with oscillator 1's phase.
    - ``enable_polyphony`` (bool):  [Read-Write] Whether or not to allow multiple synth voices.
    - ``enable_unison`` (bool):  [Read-Write] Enables forcing the oscillators to have no stereo spread.
    - ``filter_algorithm`` (SynthFilterAlgorithm):  [Read-Write] The output filter circuit/algorithm type (one-pole ladder, ladder, state-variable)
    - ``filter_frequency`` (float):  [Read-Write] The output filter cutoff frequency (hz) [0.0, 20000.0]
    - ``filter_q`` (float):  [Read-Write] The output filter resonance (Q) [0.5, 10]
    - ``filter_type`` (SynthFilterType):  [Read-Write] The output filter type (lowpass, highpass, bandpass, bandstop)
    - ``gain_db`` (float):  [Read-Write] The overall gain to use for the synthesizer in dB [-90.0, 20.0]
    - ``invert_modulation_envelope`` (bool):  [Read-Write] Whether or not to invert the modulation envelope
    - ``invert_modulation_envelope_bias`` (bool):  [Read-Write] Whether or not to invert the modulation envelope bias output
    - ``legato`` (bool):  [Read-Write] Whether or not to use legato mode.
    - ``lfo1_frequency`` (float):  [Read-Write] The frequency to use for LFO 1 (in hz) [0.0, 50.0]
    - ``lfo1_gain`` (float):  [Read-Write] The linear gain to use for LFO 1 [0.0, 1.0]
    - ``lfo1_mode`` (SynthLFOMode):  [Read-Write] The mode to use for LFO 1
    - ``lfo1_patch_type`` (SynthLFOPatchType):  [Read-Write] The built-in patch type to use for LFO 1 (you can route this to any patchable parameter using the Patches parameter)
    - ``lfo1_type`` (SynthLFOType):  [Read-Write] The type of LFO to use for LFO 1
    - ``lfo2_frequency`` (float):  [Read-Write] The frequency to use for LFO 2 (in hz) [0.0, 50.0]
    - ``lfo2_gain`` (float):  [Read-Write] The linear gain to use for LFO 2 [0.0, 1.0]
    - ``lfo2_mode`` (SynthLFOMode):  [Read-Write] The mode to use for LFO 2
    - ``lfo2_patch_type`` (SynthLFOPatchType):  [Read-Write] The built-in patch type to use for LFO 2 (you can route this to any patchable parameter using the Patches parameter)
    - ``lfo2_type`` (SynthLFOType):  [Read-Write] The type of LFO to use for LFO 2
    - ``mod_env_bias_patch_type`` (SynthModEnvBiasPatch):  [Read-Write] The built-in patch type for the envelope modulator bias output. Bias is when the envelope output is offset by the sustain gain.
    - ``mod_env_patch_type`` (SynthModEnvPatch):  [Read-Write] The built-in patch type for the envelope modulator
    - ``modulation_envelope_attack_time`` (float):  [Read-Write] The modulation envelope attack time (in ms) [0.0, 10000]
    - ``modulation_envelope_decay_time`` (float):  [Read-Write] The modulation envelope decay time (in ms) [0.0, 10000]
    - ``modulation_envelope_depth`` (float):  [Read-Write] The "depth" (i.e. how much) modulation envelope to use. This scales the modulation envelope output. [0.0, 1.0]
    - ``modulation_envelope_release_time`` (float):  [Read-Write] The modulation envelope release time (in ms) [0.0, 10000]
    - ``modulation_envelope_sustain_gain`` (float):  [Read-Write] The modulation envelope sustain gain (linear gain) [0.0, 1.0]
    - ``osc1_cents`` (float):  [Read-Write] The cents (hundreds of a semitone) of oscillator 1. [-100.0, 100.0]
    - ``osc1_gain`` (float):  [Read-Write] The linear gain of oscillator 1 [0.0, 1.0]
    - ``osc1_octave`` (float):  [Read-Write] The octave of oscillator 1. [-8.0, 8.0]
    - ``osc1_pulse_width`` (float):  [Read-Write] The pulsewidth of oscillator 1 (when using a square wave type oscillator). [0.0, 1.0]
    - ``osc1_semitones`` (float):  [Read-Write] The semi-tones of oscillator 1. [-12.0, 12.0]
    - ``osc1_type`` (Synth1OscType):  [Read-Write] What type of oscillator to use for oscillator 1
    - ``osc2_cents`` (float):  [Read-Write] The cents (hundreds of a semitone) of oscillator 2. [-100.0, 100.0]
    - ``osc2_gain`` (float):  [Read-Write] The linear gain of oscillator 2 [0.0, 1.0]
    - ``osc2_octave`` (float):  [Read-Write] The octave of oscillator 2. [-8.0, 8.0]
    - ``osc2_pulse_width`` (float):  [Read-Write] The pulsewidth of oscillator 2 (when using a square wave type oscillator). [0.0, 1.0]
    - ``osc2_semitones`` (float):  [Read-Write] The semi-tones of oscillator 2. [-12.0, 12.0]
    - ``osc2_type`` (Synth1OscType):  [Read-Write] What type of oscillator to use for oscillator 2
    - ``pan`` (float):  [Read-Write] The stereo pan to use. 0.0 is center. -1.0 is left, 1.0 is right.
    - ``patches`` (Array[EpicSynth1Patch]):  [Read-Write] The modular synth patch cords to use for the synth. Allows routing the LFO1/LFO2 and Modulation Envelope to any patchable destination.
    - ``portamento`` (float):  [Read-Write] The amount of portamento to use, which is the amount of pitch sliding from current note to next [0.0, 1.0]
    - ``release_time`` (float):  [Read-Write] The amplitude envelope release time (in ms) [0.0, 10000]
    - ``retrigger`` (bool):  [Read-Write] Whether or not to use retrigger mode.
    - ``spread`` (float):  [Read-Write] The amount of stereo spread to use between oscillator 1 and oscillator 2 [0.0, 1.0]
    - ``stereo_delay_enabled`` (bool):  [Read-Write] Whether or not stereo delay is enabled on the synth
    - ``stereo_delay_feedback`` (float):  [Read-Write] The amount of feedback in the stereo delay line [0.0, 1.0]
    - ``stereo_delay_mode`` (SynthStereoDelayMode):  [Read-Write] The stereo delay mode of the synth
    - ``stereo_delay_ratio`` (float):  [Read-Write] The ratio between left and right stereo delay lines (wider value is more separation) [0.0, 1.0]
    - ``stereo_delay_time`` (float):  [Read-Write] The stereo delay time (in ms) [0.0, 2000.0]
    - ``stereo_delay_wetlevel`` (float):  [Read-Write] The output wet level to use for the stereo delay time [0.0, 1.0]
    - ``sustain_gain`` (float):  [Read-Write] The amplitude envelope sustain amount (linear gain) [0.0, 1.0]
    """
    def __init__(self, enable_polyphony: bool = False, osc1_type: Synth1OscType = Synth1OscType.SINE, osc1_gain: float = 0.000000, osc1_octave: float = 0.000000, osc1_semitones: float = 0.000000, osc1_cents: float = 0.000000, osc1_pulse_width: float = 0.000000, osc2_type: Synth1OscType = Synth1OscType.SINE, osc2_gain: float = 0.000000, osc2_octave: float = 0.000000, osc2_semitones: float = 0.000000, osc2_cents: float = 0.000000, osc2_pulse_width: float = 0.000000, portamento: float = 0.000000, enable_unison: bool = False, enable_oscillator_sync: bool = False, spread: float = 0.000000, pan: float = 0.000000, lfo1_frequency: float = 0.000000, lfo1_gain: float = 0.000000, lfo1_type: SynthLFOType = SynthLFOType.SINE, lfo1_mode: SynthLFOMode = SynthLFOMode.SYNC, lfo1_patch_type: SynthLFOPatchType = SynthLFOPatchType.PATCH_TO_NONE, lfo2_frequency: float = 0.000000, lfo2_gain: float = 0.000000, lfo2_type: SynthLFOType = SynthLFOType.SINE, lfo2_mode: SynthLFOMode = SynthLFOMode.SYNC, lfo2_patch_type: SynthLFOPatchType = SynthLFOPatchType.PATCH_TO_NONE, gain_db: float = 0.000000, attack_time: float = 0.000000, decay_time: float = 0.000000, sustain_gain: float = 0.000000, release_time: float = 0.000000, mod_env_patch_type: SynthModEnvPatch = SynthModEnvPatch.PATCH_TO_NONE, mod_env_bias_patch_type: SynthModEnvBiasPatch = SynthModEnvBiasPatch.PATCH_TO_NONE, invert_modulation_envelope: bool = False, invert_modulation_envelope_bias: bool = False, modulation_envelope_depth: float = 0.000000, modulation_envelope_attack_time: float = 0.000000, modulation_envelope_decay_time: float = 0.000000, modulation_envelope_sustain_gain: float = 0.000000, modulation_envelope_release_time: float = 0.000000, legato: bool = False, retrigger: bool = False, filter_frequency: float = 0.000000, filter_q: float = 0.000000, filter_type: SynthFilterType = SynthFilterType.LOW_PASS, filter_algorithm: SynthFilterAlgorithm = SynthFilterAlgorithm.ONE_POLE, stereo_delay_enabled: bool = False, stereo_delay_mode: SynthStereoDelayMode = SynthStereoDelayMode.NORMAL, stereo_delay_time: float = 0.000000, stereo_delay_feedback: float = 0.000000, stereo_delay_wetlevel: float = 0.000000, stereo_delay_ratio: float = 0.000000, chorus_enabled: bool = False, chorus_depth: float = 0.000000, chorus_feedback: float = 0.000000, chorus_frequency: float = 0.000000, patches: Array[EpicSynth1Patch] = []) -> None:
        ...
    @property
    def enable_polyphony(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to allow multiple synth voices.
        """
        ...
    @enable_polyphony.setter
    def enable_polyphony(self, value: bool) -> None:
        ...
    @property
    def osc1_type(self) -> Synth1OscType:
        r"""
        (Synth1OscType):  [Read-Write] What type of oscillator to use for oscillator 1
        """
        ...
    @osc1_type.setter
    def osc1_type(self, value: Synth1OscType) -> None:
        ...
    @property
    def osc1_gain(self) -> float:
        r"""
        (float):  [Read-Write] The linear gain of oscillator 1 [0.0, 1.0]
        """
        ...
    @osc1_gain.setter
    def osc1_gain(self, value: float) -> None:
        ...
    @property
    def osc1_octave(self) -> float:
        r"""
        (float):  [Read-Write] The octave of oscillator 1. [-8.0, 8.0]
        """
        ...
    @osc1_octave.setter
    def osc1_octave(self, value: float) -> None:
        ...
    @property
    def osc1_semitones(self) -> float:
        r"""
        (float):  [Read-Write] The semi-tones of oscillator 1. [-12.0, 12.0]
        """
        ...
    @osc1_semitones.setter
    def osc1_semitones(self, value: float) -> None:
        ...
    @property
    def osc1_cents(self) -> float:
        r"""
        (float):  [Read-Write] The cents (hundreds of a semitone) of oscillator 1. [-100.0, 100.0]
        """
        ...
    @osc1_cents.setter
    def osc1_cents(self, value: float) -> None:
        ...
    @property
    def osc1_pulse_width(self) -> float:
        r"""
        (float):  [Read-Write] The pulsewidth of oscillator 1 (when using a square wave type oscillator). [0.0, 1.0]
        """
        ...
    @osc1_pulse_width.setter
    def osc1_pulse_width(self, value: float) -> None:
        ...
    @property
    def osc2_type(self) -> Synth1OscType:
        r"""
        (Synth1OscType):  [Read-Write] What type of oscillator to use for oscillator 2
        """
        ...
    @osc2_type.setter
    def osc2_type(self, value: Synth1OscType) -> None:
        ...
    @property
    def osc2_gain(self) -> float:
        r"""
        (float):  [Read-Write] The linear gain of oscillator 2 [0.0, 1.0]
        """
        ...
    @osc2_gain.setter
    def osc2_gain(self, value: float) -> None:
        ...
    @property
    def osc2_octave(self) -> float:
        r"""
        (float):  [Read-Write] The octave of oscillator 2. [-8.0, 8.0]
        """
        ...
    @osc2_octave.setter
    def osc2_octave(self, value: float) -> None:
        ...
    @property
    def osc2_semitones(self) -> float:
        r"""
        (float):  [Read-Write] The semi-tones of oscillator 2. [-12.0, 12.0]
        """
        ...
    @osc2_semitones.setter
    def osc2_semitones(self, value: float) -> None:
        ...
    @property
    def osc2_cents(self) -> float:
        r"""
        (float):  [Read-Write] The cents (hundreds of a semitone) of oscillator 2. [-100.0, 100.0]
        """
        ...
    @osc2_cents.setter
    def osc2_cents(self, value: float) -> None:
        ...
    @property
    def osc2_pulse_width(self) -> float:
        r"""
        (float):  [Read-Write] The pulsewidth of oscillator 2 (when using a square wave type oscillator). [0.0, 1.0]
        """
        ...
    @osc2_pulse_width.setter
    def osc2_pulse_width(self, value: float) -> None:
        ...
    @property
    def portamento(self) -> float:
        r"""
        (float):  [Read-Write] The amount of portamento to use, which is the amount of pitch sliding from current note to next [0.0, 1.0]
        """
        ...
    @portamento.setter
    def portamento(self, value: float) -> None:
        ...
    @property
    def enable_unison(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables forcing the oscillators to have no stereo spread.
        """
        ...
    @enable_unison.setter
    def enable_unison(self, value: bool) -> None:
        ...
    @property
    def enable_oscillator_sync(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not oscillator sync is enabled. Oscillator sync forces oscillator 2's phase to align with oscillator 1's phase.
        """
        ...
    @enable_oscillator_sync.setter
    def enable_oscillator_sync(self, value: bool) -> None:
        ...
    @property
    def spread(self) -> float:
        r"""
        (float):  [Read-Write] The amount of stereo spread to use between oscillator 1 and oscillator 2 [0.0, 1.0]
        """
        ...
    @spread.setter
    def spread(self, value: float) -> None:
        ...
    @property
    def pan(self) -> float:
        r"""
        (float):  [Read-Write] The stereo pan to use. 0.0 is center. -1.0 is left, 1.0 is right.
        """
        ...
    @pan.setter
    def pan(self, value: float) -> None:
        ...
    @property
    def lfo1_frequency(self) -> float:
        r"""
        (float):  [Read-Write] The frequency to use for LFO 1 (in hz) [0.0, 50.0]
        """
        ...
    @lfo1_frequency.setter
    def lfo1_frequency(self, value: float) -> None:
        ...
    @property
    def lfo1_gain(self) -> float:
        r"""
        (float):  [Read-Write] The linear gain to use for LFO 1 [0.0, 1.0]
        """
        ...
    @lfo1_gain.setter
    def lfo1_gain(self, value: float) -> None:
        ...
    @property
    def lfo1_type(self) -> SynthLFOType:
        r"""
        (SynthLFOType):  [Read-Write] The type of LFO to use for LFO 1
        """
        ...
    @lfo1_type.setter
    def lfo1_type(self, value: SynthLFOType) -> None:
        ...
    @property
    def lfo1_mode(self) -> SynthLFOMode:
        r"""
        (SynthLFOMode):  [Read-Write] The mode to use for LFO 1
        """
        ...
    @lfo1_mode.setter
    def lfo1_mode(self, value: SynthLFOMode) -> None:
        ...
    @property
    def lfo1_patch_type(self) -> SynthLFOPatchType:
        r"""
        (SynthLFOPatchType):  [Read-Write] The built-in patch type to use for LFO 1 (you can route this to any patchable parameter using the Patches parameter)
        """
        ...
    @lfo1_patch_type.setter
    def lfo1_patch_type(self, value: SynthLFOPatchType) -> None:
        ...
    @property
    def lfo2_frequency(self) -> float:
        r"""
        (float):  [Read-Write] The frequency to use for LFO 2 (in hz) [0.0, 50.0]
        """
        ...
    @lfo2_frequency.setter
    def lfo2_frequency(self, value: float) -> None:
        ...
    @property
    def lfo2_gain(self) -> float:
        r"""
        (float):  [Read-Write] The linear gain to use for LFO 2 [0.0, 1.0]
        """
        ...
    @lfo2_gain.setter
    def lfo2_gain(self, value: float) -> None:
        ...
    @property
    def lfo2_type(self) -> SynthLFOType:
        r"""
        (SynthLFOType):  [Read-Write] The type of LFO to use for LFO 2
        """
        ...
    @lfo2_type.setter
    def lfo2_type(self, value: SynthLFOType) -> None:
        ...
    @property
    def lfo2_mode(self) -> SynthLFOMode:
        r"""
        (SynthLFOMode):  [Read-Write] The mode to use for LFO 2
        """
        ...
    @lfo2_mode.setter
    def lfo2_mode(self, value: SynthLFOMode) -> None:
        ...
    @property
    def lfo2_patch_type(self) -> SynthLFOPatchType:
        r"""
        (SynthLFOPatchType):  [Read-Write] The built-in patch type to use for LFO 2 (you can route this to any patchable parameter using the Patches parameter)
        """
        ...
    @lfo2_patch_type.setter
    def lfo2_patch_type(self, value: SynthLFOPatchType) -> None:
        ...
    @property
    def gain_db(self) -> float:
        r"""
        (float):  [Read-Write] The overall gain to use for the synthesizer in dB [-90.0, 20.0]
        """
        ...
    @gain_db.setter
    def gain_db(self, value: float) -> None:
        ...
    @property
    def attack_time(self) -> float:
        r"""
        (float):  [Read-Write] The amplitude envelope attack time (in ms) [0.0, 10000]
        """
        ...
    @attack_time.setter
    def attack_time(self, value: float) -> None:
        ...
    @property
    def decay_time(self) -> float:
        r"""
        (float):  [Read-Write] The amplitude envelope decay time (in ms)[0.0, 10000]
        """
        ...
    @decay_time.setter
    def decay_time(self, value: float) -> None:
        ...
    @property
    def sustain_gain(self) -> float:
        r"""
        (float):  [Read-Write] The amplitude envelope sustain amount (linear gain) [0.0, 1.0]
        """
        ...
    @sustain_gain.setter
    def sustain_gain(self, value: float) -> None:
        ...
    @property
    def release_time(self) -> float:
        r"""
        (float):  [Read-Write] The amplitude envelope release time (in ms) [0.0, 10000]
        """
        ...
    @release_time.setter
    def release_time(self, value: float) -> None:
        ...
    @property
    def mod_env_patch_type(self) -> SynthModEnvPatch:
        r"""
        (SynthModEnvPatch):  [Read-Write] The built-in patch type for the envelope modulator
        """
        ...
    @mod_env_patch_type.setter
    def mod_env_patch_type(self, value: SynthModEnvPatch) -> None:
        ...
    @property
    def mod_env_bias_patch_type(self) -> SynthModEnvBiasPatch:
        r"""
        (SynthModEnvBiasPatch):  [Read-Write] The built-in patch type for the envelope modulator bias output. Bias is when the envelope output is offset by the sustain gain.
        """
        ...
    @mod_env_bias_patch_type.setter
    def mod_env_bias_patch_type(self, value: SynthModEnvBiasPatch) -> None:
        ...
    @property
    def invert_modulation_envelope(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to invert the modulation envelope
        """
        ...
    @invert_modulation_envelope.setter
    def invert_modulation_envelope(self, value: bool) -> None:
        ...
    @property
    def invert_modulation_envelope_bias(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to invert the modulation envelope bias output
        """
        ...
    @invert_modulation_envelope_bias.setter
    def invert_modulation_envelope_bias(self, value: bool) -> None:
        ...
    @property
    def modulation_envelope_depth(self) -> float:
        r"""
        (float):  [Read-Write] The "depth" (i.e. how much) modulation envelope to use. This scales the modulation envelope output. [0.0, 1.0]
        """
        ...
    @modulation_envelope_depth.setter
    def modulation_envelope_depth(self, value: float) -> None:
        ...
    @property
    def modulation_envelope_attack_time(self) -> float:
        r"""
        (float):  [Read-Write] The modulation envelope attack time (in ms) [0.0, 10000]
        """
        ...
    @modulation_envelope_attack_time.setter
    def modulation_envelope_attack_time(self, value: float) -> None:
        ...
    @property
    def modulation_envelope_decay_time(self) -> float:
        r"""
        (float):  [Read-Write] The modulation envelope decay time (in ms) [0.0, 10000]
        """
        ...
    @modulation_envelope_decay_time.setter
    def modulation_envelope_decay_time(self, value: float) -> None:
        ...
    @property
    def modulation_envelope_sustain_gain(self) -> float:
        r"""
        (float):  [Read-Write] The modulation envelope sustain gain (linear gain) [0.0, 1.0]
        """
        ...
    @modulation_envelope_sustain_gain.setter
    def modulation_envelope_sustain_gain(self, value: float) -> None:
        ...
    @property
    def modulation_envelope_release_time(self) -> float:
        r"""
        (float):  [Read-Write] The modulation envelope release time (in ms) [0.0, 10000]
        """
        ...
    @modulation_envelope_release_time.setter
    def modulation_envelope_release_time(self, value: float) -> None:
        ...
    @property
    def legato(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to use legato mode.
        """
        ...
    @legato.setter
    def legato(self, value: bool) -> None:
        ...
    @property
    def retrigger(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to use retrigger mode.
        """
        ...
    @retrigger.setter
    def retrigger(self, value: bool) -> None:
        ...
    @property
    def filter_frequency(self) -> float:
        r"""
        (float):  [Read-Write] The output filter cutoff frequency (hz) [0.0, 20000.0]
        """
        ...
    @filter_frequency.setter
    def filter_frequency(self, value: float) -> None:
        ...
    @property
    def filter_q(self) -> float:
        r"""
        (float):  [Read-Write] The output filter resonance (Q) [0.5, 10]
        """
        ...
    @filter_q.setter
    def filter_q(self, value: float) -> None:
        ...
    @property
    def filter_type(self) -> SynthFilterType:
        r"""
        (SynthFilterType):  [Read-Write] The output filter type (lowpass, highpass, bandpass, bandstop)
        """
        ...
    @filter_type.setter
    def filter_type(self, value: SynthFilterType) -> None:
        ...
    @property
    def filter_algorithm(self) -> SynthFilterAlgorithm:
        r"""
        (SynthFilterAlgorithm):  [Read-Write] The output filter circuit/algorithm type (one-pole ladder, ladder, state-variable)
        """
        ...
    @filter_algorithm.setter
    def filter_algorithm(self, value: SynthFilterAlgorithm) -> None:
        ...
    @property
    def stereo_delay_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not stereo delay is enabled on the synth
        """
        ...
    @stereo_delay_enabled.setter
    def stereo_delay_enabled(self, value: bool) -> None:
        ...
    @property
    def stereo_delay_mode(self) -> SynthStereoDelayMode:
        r"""
        (SynthStereoDelayMode):  [Read-Write] The stereo delay mode of the synth
        """
        ...
    @stereo_delay_mode.setter
    def stereo_delay_mode(self, value: SynthStereoDelayMode) -> None:
        ...
    @property
    def stereo_delay_time(self) -> float:
        r"""
        (float):  [Read-Write] The stereo delay time (in ms) [0.0, 2000.0]
        """
        ...
    @stereo_delay_time.setter
    def stereo_delay_time(self, value: float) -> None:
        ...
    @property
    def stereo_delay_feedback(self) -> float:
        r"""
        (float):  [Read-Write] The amount of feedback in the stereo delay line [0.0, 1.0]
        """
        ...
    @stereo_delay_feedback.setter
    def stereo_delay_feedback(self, value: float) -> None:
        ...
    @property
    def stereo_delay_wetlevel(self) -> float:
        r"""
        (float):  [Read-Write] The output wet level to use for the stereo delay time [0.0, 1.0]
        """
        ...
    @stereo_delay_wetlevel.setter
    def stereo_delay_wetlevel(self, value: float) -> None:
        ...
    @property
    def stereo_delay_ratio(self) -> float:
        r"""
        (float):  [Read-Write] The ratio between left and right stereo delay lines (wider value is more separation) [0.0, 1.0]
        """
        ...
    @stereo_delay_ratio.setter
    def stereo_delay_ratio(self, value: float) -> None:
        ...
    @property
    def chorus_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not the chorus effect is enabled
        """
        ...
    @chorus_enabled.setter
    def chorus_enabled(self, value: bool) -> None:
        ...
    @property
    def chorus_depth(self) -> float:
        r"""
        (float):  [Read-Write] The depth of the chorus effect [0.0, 1.0]
        """
        ...
    @chorus_depth.setter
    def chorus_depth(self, value: float) -> None:
        ...
    @property
    def chorus_feedback(self) -> float:
        r"""
        (float):  [Read-Write] The amount of feedback in the chorus effect [0.0, 1.0]
        """
        ...
    @chorus_feedback.setter
    def chorus_feedback(self, value: float) -> None:
        ...
    @property
    def chorus_frequency(self) -> float:
        r"""
        (float):  [Read-Write] The chorus LFO frequency [0.0, 20.0]
        """
        ...
    @chorus_frequency.setter
    def chorus_frequency(self, value: float) -> None:
        ...
    @property
    def patches(self) -> Array[EpicSynth1Patch]:
        r"""
        (Array[EpicSynth1Patch]):  [Read-Write] The modular synth patch cords to use for the synth. Allows routing the LFO1/LFO2 and Modulation Envelope to any patchable destination.
        """
        ...
    @patches.setter
    def patches(self, value: Array[EpicSynth1Patch]) -> None:
        ...

class ModularSynthPresetBankEntry(StructBase):
    r"""
    Modular Synth Preset Bank Entry
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Component.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``preset`` (ModularSynthPreset):  [Read-Write]
    - ``preset_name`` (str):  [Read-Write]
    """
    def __init__(self, preset_name: str = "", preset: ModularSynthPreset = [False, Synth1OscType.SAW, 1.000000, 0.000000, 0.000000, 0.000000, 0.500000, Synth1OscType.SAW, 1.000000, 0.000000, 0.000000, 2.500000, 0.500000, 0.000000, False, False, 0.500000, 0.000000, 1.000000, 0.000000, SynthLFOType.SINE, SynthLFOMode.SYNC, SynthLFOPatchType.PATCH_TO_NONE, 1.000000, 0.000000, SynthLFOType.SINE, SynthLFOMode.SYNC, SynthLFOPatchType.PATCH_TO_NONE, -3.000000, 10.000000, 100.000000, 0.707000, 5000.000000, SynthModEnvPatch.PATCH_TO_NONE, SynthModEnvBiasPatch.PATCH_TO_NONE, False, False, 1.000000, 10.000000, 100.000000, 0.707000, 5000.000000, True, False, 8000.000000, 2.000000, SynthFilterType.LOW_PASS, SynthFilterAlgorithm.LADDER, True, SynthStereoDelayMode.PING_PONG, 700.000000, 0.700000, 0.300000, 0.200000, False, 0.200000, 0.500000, 2.000000, []]) -> None:
        ...
    @property
    def preset_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @preset_name.setter
    def preset_name(self, value: str) -> None:
        ...
    @property
    def preset(self) -> ModularSynthPreset:
        r"""
        (ModularSynthPreset):  [Read-Write]
        """
        ...
    @preset.setter
    def preset(self, value: ModularSynthPreset) -> None:
        ...

class SourceEffectBitCrusherBaseSettings(StructBase):
    r"""
    Source Effect Bit Crusher Base Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectBitCrusher.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bit_depth`` (float):  [Read-Write] The reduced bit depth to use for the audio stream
    - ``sample_rate`` (float):  [Read-Write] The reduced frequency to use for the audio stream.
    """
    def __init__(self, sample_rate: float = 0.000000, bit_depth: float = 0.000000) -> None:
        ...
    @property
    def sample_rate(self) -> float:
        r"""
        (float):  [Read-Write] The reduced frequency to use for the audio stream.
        """
        ...
    @sample_rate.setter
    def sample_rate(self, value: float) -> None:
        ...
    @property
    def asset_sample_rate(self) -> float:
        r"""
        deprecated: 'asset_sample_rate' was renamed to 'sample_rate'.
        """
        ...
    @asset_sample_rate.setter
    def asset_sample_rate(self, value: float) -> None:
        ...
    @property
    def bit_depth(self) -> float:
        r"""
        (float):  [Read-Write] The reduced bit depth to use for the audio stream
        """
        ...
    @bit_depth.setter
    def bit_depth(self, value: float) -> None:
        ...

class SourceEffectBitCrusherSettings(StructBase):
    r"""
    Source Effect Bit Crusher Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectBitCrusher.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bit_modulation`` (SoundModulationDestinationSettings):  [Read-Write] The reduced bit depth to use for the audio stream
    - ``sample_rate_modulation`` (SoundModulationDestinationSettings):  [Read-Write] The reduced frequency to use for the audio stream.
    """
    def __init__(self, sample_rate_modulation: SoundModulationDestinationSettings = [1.000000, []], bit_modulation: SoundModulationDestinationSettings = [1.000000, []]) -> None:
        ...
    @property
    def sample_rate_modulation(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] The reduced frequency to use for the audio stream.
        """
        ...
    @sample_rate_modulation.setter
    def sample_rate_modulation(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def bit_modulation(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] The reduced bit depth to use for the audio stream
        """
        ...
    @bit_modulation.setter
    def bit_modulation(self, value: SoundModulationDestinationSettings) -> None:
        ...

class SourceEffectChorusBaseSettings(StructBase):
    r"""
    Source Effect Chorus Base Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectChorus.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``depth`` (float):  [Read-Write] The depth of the chorus effect
    - ``dry_level`` (float):  [Read-Write] The dry level of the chorus effect
    - ``feedback`` (float):  [Read-Write] The feedback of the chorus effect
    - ``frequency`` (float):  [Read-Write] The frequency of the chorus effect
    - ``spread`` (float):  [Read-Write] The spread of the effect (larger means greater difference between left and right delay lines)
    - ``wet_level`` (float):  [Read-Write] The wet level of the chorus effect
    """
    def __init__(self, depth: float = 0.000000, frequency: float = 0.000000, feedback: float = 0.000000, wet_level: float = 0.000000, dry_level: float = 0.000000, spread: float = 0.000000) -> None:
        ...
    @property
    def depth(self) -> float:
        r"""
        (float):  [Read-Write] The depth of the chorus effect
        """
        ...
    @depth.setter
    def depth(self, value: float) -> None:
        ...
    @property
    def frequency(self) -> float:
        r"""
        (float):  [Read-Write] The frequency of the chorus effect
        """
        ...
    @frequency.setter
    def frequency(self, value: float) -> None:
        ...
    @property
    def feedback(self) -> float:
        r"""
        (float):  [Read-Write] The feedback of the chorus effect
        """
        ...
    @feedback.setter
    def feedback(self, value: float) -> None:
        ...
    @property
    def wet_level(self) -> float:
        r"""
        (float):  [Read-Write] The wet level of the chorus effect
        """
        ...
    @wet_level.setter
    def wet_level(self, value: float) -> None:
        ...
    @property
    def dry_level(self) -> float:
        r"""
        (float):  [Read-Write] The dry level of the chorus effect
        """
        ...
    @dry_level.setter
    def dry_level(self, value: float) -> None:
        ...
    @property
    def spread(self) -> float:
        r"""
        (float):  [Read-Write] The spread of the effect (larger means greater difference between left and right delay lines)
        """
        ...
    @spread.setter
    def spread(self, value: float) -> None:
        ...

class SourceEffectChorusSettings(StructBase):
    r"""
    Source Effect Chorus Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectChorus.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``depth`` (float):  [Read-Write]
      deprecated: Property 'Depth' is deprecated.
    - ``depth_modulation`` (SoundModulationDestinationSettings):  [Read-Write] The depth of the chorus effect
    - ``dry_level`` (float):  [Read-Write]
      deprecated: Property 'DryLevel' is deprecated.
    - ``dry_modulation`` (SoundModulationDestinationSettings):  [Read-Write] The dry level of the chorus effect
    - ``feedback`` (float):  [Read-Write]
      deprecated: Property 'Feedback' is deprecated.
    - ``feedback_modulation`` (SoundModulationDestinationSettings):  [Read-Write] The feedback of the chorus effect
    - ``frequency`` (float):  [Read-Write]
      deprecated: Property 'Frequency' is deprecated.
    - ``frequency_modulation`` (SoundModulationDestinationSettings):  [Read-Write] The frequency of the chorus effect
    - ``spread`` (float):  [Read-Write]
      deprecated: Property 'Spread' is deprecated.
    - ``spread_modulation`` (SoundModulationDestinationSettings):  [Read-Write] The spread of the effect (larger means greater difference between left and right delay lines)
    - ``wet_level`` (float):  [Read-Write]
      deprecated: Property 'WetLevel' is deprecated.
    - ``wet_modulation`` (SoundModulationDestinationSettings):  [Read-Write] The wet level of the chorus effect
    """
    def __init__(self, depth_modulation: SoundModulationDestinationSettings = [1.000000, []], frequency_modulation: SoundModulationDestinationSettings = [1.000000, []], feedback_modulation: SoundModulationDestinationSettings = [1.000000, []], wet_modulation: SoundModulationDestinationSettings = [1.000000, []], dry_modulation: SoundModulationDestinationSettings = [1.000000, []], spread_modulation: SoundModulationDestinationSettings = [1.000000, []]) -> None:
        ...
    @property
    def depth(self) -> float:
        r"""
        (float):  [Read-Write]
        deprecated: Property 'Depth' is deprecated.
        """
        ...
    @depth.setter
    def depth(self, value: float) -> None:
        ...
    @property
    def frequency(self) -> float:
        r"""
        (float):  [Read-Write]
        deprecated: Property 'Frequency' is deprecated.
        """
        ...
    @frequency.setter
    def frequency(self, value: float) -> None:
        ...
    @property
    def feedback(self) -> float:
        r"""
        (float):  [Read-Write]
        deprecated: Property 'Feedback' is deprecated.
        """
        ...
    @feedback.setter
    def feedback(self, value: float) -> None:
        ...
    @property
    def wet_level(self) -> float:
        r"""
        (float):  [Read-Write]
        deprecated: Property 'WetLevel' is deprecated.
        """
        ...
    @wet_level.setter
    def wet_level(self, value: float) -> None:
        ...
    @property
    def dry_level(self) -> float:
        r"""
        (float):  [Read-Write]
        deprecated: Property 'DryLevel' is deprecated.
        """
        ...
    @dry_level.setter
    def dry_level(self, value: float) -> None:
        ...
    @property
    def spread(self) -> float:
        r"""
        (float):  [Read-Write]
        deprecated: Property 'Spread' is deprecated.
        """
        ...
    @spread.setter
    def spread(self, value: float) -> None:
        ...
    @property
    def depth_modulation(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] The depth of the chorus effect
        """
        ...
    @depth_modulation.setter
    def depth_modulation(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def frequency_modulation(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] The frequency of the chorus effect
        """
        ...
    @frequency_modulation.setter
    def frequency_modulation(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def feedback_modulation(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] The feedback of the chorus effect
        """
        ...
    @feedback_modulation.setter
    def feedback_modulation(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def wet_modulation(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] The wet level of the chorus effect
        """
        ...
    @wet_modulation.setter
    def wet_modulation(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def dry_modulation(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] The dry level of the chorus effect
        """
        ...
    @dry_modulation.setter
    def dry_modulation(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def spread_modulation(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] The spread of the effect (larger means greater difference between left and right delay lines)
        """
        ...
    @spread_modulation.setter
    def spread_modulation(self, value: SoundModulationDestinationSettings) -> None:
        ...

class SourceEffectConvolutionReverbSettings(StructBase):
    r"""
    Source Effect Convolution Reverb Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectConvolutionReverb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bypass`` (bool):  [Read-Write] If true, input audio is directly routed to output audio with applying any effect.
    - ``dry_volume_db`` (float):  [Read-Write] Controls how much of the dry signal is mixed into the output, in Decibels
    - ``wet_volume_db`` (float):  [Read-Write] Controls how much of the wet signal is mixed into the output, in Decibels
    """
    def __init__(self, wet_volume_db: float = 0.000000, dry_volume_db: float = 0.000000, bypass: bool = False) -> None:
        ...
    @property
    def wet_volume_db(self) -> float:
        r"""
        (float):  [Read-Write] Controls how much of the wet signal is mixed into the output, in Decibels
        """
        ...
    @wet_volume_db.setter
    def wet_volume_db(self, value: float) -> None:
        ...
    @property
    def dry_volume_db(self) -> float:
        r"""
        (float):  [Read-Write] Controls how much of the dry signal is mixed into the output, in Decibels
        """
        ...
    @dry_volume_db.setter
    def dry_volume_db(self, value: float) -> None:
        ...
    @property
    def bypass(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, input audio is directly routed to output audio with applying any effect.
        """
        ...
    @bypass.setter
    def bypass(self, value: bool) -> None:
        ...

class SourceEffectDynamicsProcessorSettings(StructBase):
    r"""
    Source Effect Dynamics Processor Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectDynamicsProcessor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``analog_mode`` (bool):  [Read-Write]
    - ``attack_time_msec`` (float):  [Read-Write]
    - ``dynamics_processor_type`` (SourceEffectDynamicsProcessorType):  [Read-Write]
    - ``input_gain_db`` (float):  [Read-Write]
    - ``knee_bandwidth_db`` (float):  [Read-Write]
    - ``look_ahead_msec`` (float):  [Read-Write]
    - ``output_gain_db`` (float):  [Read-Write]
    - ``peak_mode`` (SourceEffectDynamicsPeakMode):  [Read-Write]
    - ``ratio`` (float):  [Read-Write]
    - ``release_time_msec`` (float):  [Read-Write]
    - ``stereo_linked`` (bool):  [Read-Write]
    - ``threshold_db`` (float):  [Read-Write]
    """
    def __init__(self, dynamics_processor_type: SourceEffectDynamicsProcessorType = SourceEffectDynamicsProcessorType.COMPRESSOR, peak_mode: SourceEffectDynamicsPeakMode = SourceEffectDynamicsPeakMode.MEAN_SQUARED, look_ahead_msec: float = 0.000000, attack_time_msec: float = 0.000000, release_time_msec: float = 0.000000, threshold_db: float = 0.000000, ratio: float = 0.000000, knee_bandwidth_db: float = 0.000000, input_gain_db: float = 0.000000, output_gain_db: float = 0.000000, stereo_linked: bool = False, analog_mode: bool = False) -> None:
        ...
    @property
    def dynamics_processor_type(self) -> SourceEffectDynamicsProcessorType:
        r"""
        (SourceEffectDynamicsProcessorType):  [Read-Write]
        """
        ...
    @dynamics_processor_type.setter
    def dynamics_processor_type(self, value: SourceEffectDynamicsProcessorType) -> None:
        ...
    @property
    def peak_mode(self) -> SourceEffectDynamicsPeakMode:
        r"""
        (SourceEffectDynamicsPeakMode):  [Read-Write]
        """
        ...
    @peak_mode.setter
    def peak_mode(self, value: SourceEffectDynamicsPeakMode) -> None:
        ...
    @property
    def look_ahead_msec(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @look_ahead_msec.setter
    def look_ahead_msec(self, value: float) -> None:
        ...
    @property
    def attack_time_msec(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @attack_time_msec.setter
    def attack_time_msec(self, value: float) -> None:
        ...
    @property
    def release_time_msec(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @release_time_msec.setter
    def release_time_msec(self, value: float) -> None:
        ...
    @property
    def threshold_db(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @threshold_db.setter
    def threshold_db(self, value: float) -> None:
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @ratio.setter
    def ratio(self, value: float) -> None:
        ...
    @property
    def knee_bandwidth_db(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @knee_bandwidth_db.setter
    def knee_bandwidth_db(self, value: float) -> None:
        ...
    @property
    def input_gain_db(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @input_gain_db.setter
    def input_gain_db(self, value: float) -> None:
        ...
    @property
    def output_gain_db(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @output_gain_db.setter
    def output_gain_db(self, value: float) -> None:
        ...
    @property
    def stereo_linked(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @stereo_linked.setter
    def stereo_linked(self, value: bool) -> None:
        ...
    @property
    def analog_mode(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @analog_mode.setter
    def analog_mode(self, value: bool) -> None:
        ...

class SourceEffectEnvelopeFollowerSettings(StructBase):
    r"""
    Source Effect Envelope Follower Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectEnvelopeFollower.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attack_time`` (float):  [Read-Write] The attack time of the envelope follower in milliseconds
    - ``is_analog_mode`` (bool):  [Read-Write] Whether or not the envelope follower is in analog mode
    - ``peak_mode`` (EnvelopeFollowerPeakMode):  [Read-Write] The peak mode of the envelope follower
    - ``release_time`` (float):  [Read-Write] The release time of the envelope follower in milliseconds
    """
    def __init__(self, attack_time: float = 0.000000, release_time: float = 0.000000, peak_mode: EnvelopeFollowerPeakMode = EnvelopeFollowerPeakMode.MEAN_SQUARED, is_analog_mode: bool = False) -> None:
        ...
    @property
    def attack_time(self) -> float:
        r"""
        (float):  [Read-Write] The attack time of the envelope follower in milliseconds
        """
        ...
    @attack_time.setter
    def attack_time(self, value: float) -> None:
        ...
    @property
    def release_time(self) -> float:
        r"""
        (float):  [Read-Write] The release time of the envelope follower in milliseconds
        """
        ...
    @release_time.setter
    def release_time(self, value: float) -> None:
        ...
    @property
    def peak_mode(self) -> EnvelopeFollowerPeakMode:
        r"""
        (EnvelopeFollowerPeakMode):  [Read-Write] The peak mode of the envelope follower
        """
        ...
    @peak_mode.setter
    def peak_mode(self, value: EnvelopeFollowerPeakMode) -> None:
        ...
    @property
    def is_analog_mode(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not the envelope follower is in analog mode
        """
        ...
    @is_analog_mode.setter
    def is_analog_mode(self, value: bool) -> None:
        ...

class SourceEffectEQBand(StructBase):
    r"""
    Source Effect EQBand
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectEQ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bandwidth`` (float):  [Read-Write] The bandwidth (in octaves) of the band
    - ``enabled`` (bool):  [Read-Write] Whether or not the band is enabled. Allows changing bands on the fly.
    - ``frequency`` (float):  [Read-Write] The cutoff frequency of the band
    - ``gain_db`` (float):  [Read-Write] The gain in decibels to apply to the eq band
    """
    def __init__(self, frequency: float = 0.000000, bandwidth: float = 0.000000, gain_db: float = 0.000000, enabled: bool = False) -> None:
        ...
    @property
    def frequency(self) -> float:
        r"""
        (float):  [Read-Write] The cutoff frequency of the band
        """
        ...
    @frequency.setter
    def frequency(self, value: float) -> None:
        ...
    @property
    def bandwidth(self) -> float:
        r"""
        (float):  [Read-Write] The bandwidth (in octaves) of the band
        """
        ...
    @bandwidth.setter
    def bandwidth(self, value: float) -> None:
        ...
    @property
    def gain_db(self) -> float:
        r"""
        (float):  [Read-Write] The gain in decibels to apply to the eq band
        """
        ...
    @gain_db.setter
    def gain_db(self, value: float) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not the band is enabled. Allows changing bands on the fly.
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...

class SourceEffectEQSettings(StructBase):
    r"""
    EQ source effect settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectEQ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``eq_bands`` (Array[SourceEffectEQBand]):  [Read-Write] The EQ bands to use
    """
    def __init__(self, eq_bands: Array[SourceEffectEQBand] = []) -> None:
        ...
    @property
    def eq_bands(self) -> Array[SourceEffectEQBand]:
        r"""
        (Array[SourceEffectEQBand]):  [Read-Write] The EQ bands to use
        """
        ...
    @eq_bands.setter
    def eq_bands(self, value: Array[SourceEffectEQBand]) -> None:
        ...

class SourceEffectFilterAudioBusModulationSettings(StructBase):
    r"""
    Source Effect Filter Audio Bus Modulation Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio_bus`` (AudioBus):  [Read-Write] Audio bus to use to modulate the filter
    - ``envelope_follower_attack_time_msec`` (int32):  [Read-Write] The amplitude envelope follower attack time (in milliseconds) on the audio bus.
    - ``envelope_follower_release_time_msec`` (int32):  [Read-Write] The amplitude envelope follower release time (in milliseconds) on the audio bus.
    - ``envelope_gain_multiplier`` (float):  [Read-Write] An amount to scale the envelope follower output to map to the modulation values.
    - ``filter_param`` (SourceEffectFilterParam):  [Read-Write] Which parameter to modulate.
    - ``max_frequency_modulation`` (float):  [Read-Write] The frequency modulation value (in semitones from the filter frequency) to use when the envelope is loudest
    - ``max_resonance_modulation`` (float):  [Read-Write] The resonance modulation value to use when the envelope is loudest
    - ``min_frequency_modulation`` (float):  [Read-Write] The frequency modulation value (in semitones from the filter frequency) to use when the envelope is quietest
    - ``min_resonance_modulation`` (float):  [Read-Write] The resonance modulation value to use when the envelope is quietest
    """
    def __init__(self, audio_bus: AudioBus = None, envelope_follower_attack_time_msec: int = 0, envelope_follower_release_time_msec: int = 0, envelope_gain_multiplier: float = 0.000000, min_frequency_modulation: float = 0.000000, max_frequency_modulation: float = 0.000000, min_resonance_modulation: float = 0.000000, max_resonance_modulation: float = 0.000000) -> None:
        ...
    @property
    def audio_bus(self) -> AudioBus:
        r"""
        (AudioBus):  [Read-Write] Audio bus to use to modulate the filter
        """
        ...
    @audio_bus.setter
    def audio_bus(self, value: AudioBus) -> None:
        ...
    @property
    def envelope_follower_attack_time_msec(self) -> int:
        r"""
        (int32):  [Read-Write] The amplitude envelope follower attack time (in milliseconds) on the audio bus.
        """
        ...
    @envelope_follower_attack_time_msec.setter
    def envelope_follower_attack_time_msec(self, value: int) -> None:
        ...
    @property
    def envelope_follower_release_time_msec(self) -> int:
        r"""
        (int32):  [Read-Write] The amplitude envelope follower release time (in milliseconds) on the audio bus.
        """
        ...
    @envelope_follower_release_time_msec.setter
    def envelope_follower_release_time_msec(self, value: int) -> None:
        ...
    @property
    def envelope_gain_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] An amount to scale the envelope follower output to map to the modulation values.
        """
        ...
    @envelope_gain_multiplier.setter
    def envelope_gain_multiplier(self, value: float) -> None:
        ...
    @property
    def min_frequency_modulation(self) -> float:
        r"""
        (float):  [Read-Write] The frequency modulation value (in semitones from the filter frequency) to use when the envelope is quietest
        """
        ...
    @min_frequency_modulation.setter
    def min_frequency_modulation(self, value: float) -> None:
        ...
    @property
    def max_frequency_modulation(self) -> float:
        r"""
        (float):  [Read-Write] The frequency modulation value (in semitones from the filter frequency) to use when the envelope is loudest
        """
        ...
    @max_frequency_modulation.setter
    def max_frequency_modulation(self, value: float) -> None:
        ...
    @property
    def min_resonance_modulation(self) -> float:
        r"""
        (float):  [Read-Write] The resonance modulation value to use when the envelope is quietest
        """
        ...
    @min_resonance_modulation.setter
    def min_resonance_modulation(self, value: float) -> None:
        ...
    @property
    def max_resonance_modulation(self) -> float:
        r"""
        (float):  [Read-Write] The resonance modulation value to use when the envelope is loudest
        """
        ...
    @max_resonance_modulation.setter
    def max_resonance_modulation(self, value: float) -> None:
        ...

class SourceEffectFilterSettings(StructBase):
    r"""
    Source Effect Filter Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio_bus_modulation`` (Array[SourceEffectFilterAudioBusModulationSettings]):  [Read-Write] Audio bus settings to use to modulate the filter frequency cutoff (auto-wah) with arbitrary audio from an audio bus
    - ``cutoff_frequency`` (float):  [Read-Write] The filter cutoff frequency
    - ``filter_circuit`` (SourceEffectFilterCircuit):  [Read-Write] The type of filter circuit to use.
    - ``filter_q`` (float):  [Read-Write] The filter resonance.
    - ``filter_type`` (SourceEffectFilterType):  [Read-Write] The type of filter to use.
    """
    def __init__(self, filter_circuit: SourceEffectFilterCircuit = SourceEffectFilterCircuit.ONE_POLE, filter_type: SourceEffectFilterType = SourceEffectFilterType.LOW_PASS, cutoff_frequency: float = 0.000000, filter_q: float = 0.000000, audio_bus_modulation: Array[SourceEffectFilterAudioBusModulationSettings] = []) -> None:
        ...
    @property
    def filter_circuit(self) -> SourceEffectFilterCircuit:
        r"""
        (SourceEffectFilterCircuit):  [Read-Write] The type of filter circuit to use.
        """
        ...
    @filter_circuit.setter
    def filter_circuit(self, value: SourceEffectFilterCircuit) -> None:
        ...
    @property
    def filter_type(self) -> SourceEffectFilterType:
        r"""
        (SourceEffectFilterType):  [Read-Write] The type of filter to use.
        """
        ...
    @filter_type.setter
    def filter_type(self, value: SourceEffectFilterType) -> None:
        ...
    @property
    def cutoff_frequency(self) -> float:
        r"""
        (float):  [Read-Write] The filter cutoff frequency
        """
        ...
    @cutoff_frequency.setter
    def cutoff_frequency(self, value: float) -> None:
        ...
    @property
    def filter_q(self) -> float:
        r"""
        (float):  [Read-Write] The filter resonance.
        """
        ...
    @filter_q.setter
    def filter_q(self, value: float) -> None:
        ...
    @property
    def audio_bus_modulation(self) -> Array[SourceEffectFilterAudioBusModulationSettings]:
        r"""
        (Array[SourceEffectFilterAudioBusModulationSettings]):  [Read-Write] Audio bus settings to use to modulate the filter frequency cutoff (auto-wah) with arbitrary audio from an audio bus
        """
        ...
    @audio_bus_modulation.setter
    def audio_bus_modulation(self, value: Array[SourceEffectFilterAudioBusModulationSettings]) -> None:
        ...

class SourceEffectFoldbackDistortionSettings(StructBase):
    r"""
    Source Effect Foldback Distortion Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectFoldbackDistortion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``input_gain_db`` (float):  [Read-Write] The amount of gain to add to input to allow forcing the triggering of the threshold
    - ``output_gain_db`` (float):  [Read-Write] The amount of gain to apply to the output
    - ``threshold_db`` (float):  [Read-Write] If the audio amplitude is higher than this, it will fold back
    """
    def __init__(self, input_gain_db: float = 0.000000, threshold_db: float = 0.000000, output_gain_db: float = 0.000000) -> None:
        ...
    @property
    def input_gain_db(self) -> float:
        r"""
        (float):  [Read-Write] The amount of gain to add to input to allow forcing the triggering of the threshold
        """
        ...
    @input_gain_db.setter
    def input_gain_db(self, value: float) -> None:
        ...
    @property
    def threshold_db(self) -> float:
        r"""
        (float):  [Read-Write] If the audio amplitude is higher than this, it will fold back
        """
        ...
    @threshold_db.setter
    def threshold_db(self, value: float) -> None:
        ...
    @property
    def output_gain_db(self) -> float:
        r"""
        (float):  [Read-Write] The amount of gain to apply to the output
        """
        ...
    @output_gain_db.setter
    def output_gain_db(self, value: float) -> None:
        ...

class SourceEffectMidSideSpreaderSettings(StructBase):
    r"""
    FSourceEffectMidSideSpreaderSettings
    This is the source effect's setting struct.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMidSideSpreader.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``equal_power`` (bool):  [Read-Write] Indicate whether an equal power relationship between the mid and side channels should be maintained
    - ``input_mode`` (StereoChannelMode):  [Read-Write] Indicate the channel mode of the input signal
    - ``output_mode`` (StereoChannelMode):  [Read-Write] Indicate the channel mode of the output signal
    - ``spread_amount`` (float):  [Read-Write] Amount of Mid/Side Spread. 0.0 is no spread, 1.0 is full wide.
    """
    def __init__(self, spread_amount: float = 0.000000, input_mode: StereoChannelMode = StereoChannelMode.MID_SIDE, output_mode: StereoChannelMode = StereoChannelMode.MID_SIDE, equal_power: bool = False) -> None:
        ...
    @property
    def spread_amount(self) -> float:
        r"""
        (float):  [Read-Write] Amount of Mid/Side Spread. 0.0 is no spread, 1.0 is full wide.
        """
        ...
    @spread_amount.setter
    def spread_amount(self, value: float) -> None:
        ...
    @property
    def input_mode(self) -> StereoChannelMode:
        r"""
        (StereoChannelMode):  [Read-Write] Indicate the channel mode of the input signal
        """
        ...
    @input_mode.setter
    def input_mode(self, value: StereoChannelMode) -> None:
        ...
    @property
    def output_mode(self) -> StereoChannelMode:
        r"""
        (StereoChannelMode):  [Read-Write] Indicate the channel mode of the output signal
        """
        ...
    @output_mode.setter
    def output_mode(self, value: StereoChannelMode) -> None:
        ...
    @property
    def equal_power(self) -> bool:
        r"""
        (bool):  [Read-Write] Indicate whether an equal power relationship between the mid and side channels should be maintained
        """
        ...
    @equal_power.setter
    def equal_power(self, value: bool) -> None:
        ...

class SourceEffectIndividualFilterSettings(StructBase):
    r"""
    Source Effect Individual Filter Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMotionFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cutoff_frequency`` (float):  [Read-Write] The filter cutoff frequency
    - ``filter_circuit`` (SourceEffectMotionFilterCircuit):  [Read-Write] The type of filter circuit to use.
    - ``filter_q`` (float):  [Read-Write] The filter resonance.
    - ``filter_type`` (SourceEffectMotionFilterType):  [Read-Write] The type of filter to use.
    """
    def __init__(self, filter_circuit: SourceEffectMotionFilterCircuit = SourceEffectMotionFilterCircuit.ONE_POLE, filter_type: SourceEffectMotionFilterType = SourceEffectMotionFilterType.LOW_PASS, cutoff_frequency: float = 0.000000, filter_q: float = 0.000000) -> None:
        ...
    @property
    def filter_circuit(self) -> SourceEffectMotionFilterCircuit:
        r"""
        (SourceEffectMotionFilterCircuit):  [Read-Write] The type of filter circuit to use.
        """
        ...
    @filter_circuit.setter
    def filter_circuit(self, value: SourceEffectMotionFilterCircuit) -> None:
        ...
    @property
    def filter_type(self) -> SourceEffectMotionFilterType:
        r"""
        (SourceEffectMotionFilterType):  [Read-Write] The type of filter to use.
        """
        ...
    @filter_type.setter
    def filter_type(self, value: SourceEffectMotionFilterType) -> None:
        ...
    @property
    def cutoff_frequency(self) -> float:
        r"""
        (float):  [Read-Write] The filter cutoff frequency
        """
        ...
    @cutoff_frequency.setter
    def cutoff_frequency(self, value: float) -> None:
        ...
    @property
    def filter_q(self) -> float:
        r"""
        (float):  [Read-Write] The filter resonance.
        """
        ...
    @filter_q.setter
    def filter_q(self, value: float) -> None:
        ...

class SourceEffectMotionFilterModulationSettings(StructBase):
    r"""
    Source Effect Motion Filter Modulation Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMotionFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``modulation_input_range`` (Vector2D):  [Read-Write] The Modulation Clamped Input Range
    - ``modulation_output_maximum_range`` (Vector2D):  [Read-Write] The Modulation Random Maximum Output Range
    - ``modulation_output_minimum_range`` (Vector2D):  [Read-Write] The Modulation Random Minimum Output Range
    - ``modulation_source`` (SourceEffectMotionFilterModSource):  [Read-Write] The Modulation Source
    - ``update_ease_ms`` (float):  [Read-Write] Update Ease Speed in milliseconds
    """
    def __init__(self, modulation_source: SourceEffectMotionFilterModSource = SourceEffectMotionFilterModSource.DISTANCE_FROM_LISTENER, modulation_input_range: Vector2D = [0.000000, 0.000000], modulation_output_minimum_range: Vector2D = [0.000000, 0.000000], modulation_output_maximum_range: Vector2D = [0.000000, 0.000000], update_ease_ms: float = 0.000000) -> None:
        ...
    @property
    def modulation_source(self) -> SourceEffectMotionFilterModSource:
        r"""
        (SourceEffectMotionFilterModSource):  [Read-Write] The Modulation Source
        """
        ...
    @modulation_source.setter
    def modulation_source(self, value: SourceEffectMotionFilterModSource) -> None:
        ...
    @property
    def modulation_input_range(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The Modulation Clamped Input Range
        """
        ...
    @modulation_input_range.setter
    def modulation_input_range(self, value: Vector2D) -> None:
        ...
    @property
    def modulation_output_minimum_range(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The Modulation Random Minimum Output Range
        """
        ...
    @modulation_output_minimum_range.setter
    def modulation_output_minimum_range(self, value: Vector2D) -> None:
        ...
    @property
    def modulation_output_maximum_range(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The Modulation Random Maximum Output Range
        """
        ...
    @modulation_output_maximum_range.setter
    def modulation_output_maximum_range(self, value: Vector2D) -> None:
        ...
    @property
    def update_ease_ms(self) -> float:
        r"""
        (float):  [Read-Write] Update Ease Speed in milliseconds
        """
        ...
    @update_ease_ms.setter
    def update_ease_ms(self, value: float) -> None:
        ...

class SourceEffectMotionFilterSettings(StructBase):
    r"""
    FSourceEffectMotionFilterSettings
    This is the source effect's setting struct.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMotionFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``dry_volume_db`` (float):  [Read-Write] Dry volume pass-through in dB.
    - ``filter_a_settings`` (SourceEffectIndividualFilterSettings):  [Read-Write] Initial settings for Filter A
    - ``filter_b_settings`` (SourceEffectIndividualFilterSettings):  [Read-Write] Initial settings for Filter B
    - ``modulation_mappings`` (Map[SourceEffectMotionFilterModDestination, SourceEffectMotionFilterModulationSettings]):  [Read-Write] Modulation Mappings
    - ``motion_filter_mix`` (float):  [Read-Write] Filter Mix controls the amount of each filter in the signal where -1.0f outputs Only Filter A, 0.0f is an equal balance between Filter A and B, and 1.0f outputs only Filter B. How this blend works depends on the Topology.
    - ``motion_filter_topology`` (SourceEffectMotionFilterTopology):  [Read-Write] In Serial Mode, Filter A will process then Filter B will process; in Parallel mode, Filter A and Filter B will process the dry input seprately, then be mixed together afterward.
    """
    def __init__(self, motion_filter_topology: SourceEffectMotionFilterTopology = SourceEffectMotionFilterTopology.SERIAL_MODE, motion_filter_mix: float = 0.000000, filter_a_settings: SourceEffectIndividualFilterSettings = [SourceEffectMotionFilterCircuit.LADDER, SourceEffectMotionFilterType.LOW_PASS, 800.000000, 2.000000], filter_b_settings: SourceEffectIndividualFilterSettings = [SourceEffectMotionFilterCircuit.LADDER, SourceEffectMotionFilterType.LOW_PASS, 800.000000, 2.000000], modulation_mappings: Map[SourceEffectMotionFilterModDestination, SourceEffectMotionFilterModulationSettings] = {}, dry_volume_db: float = 0.000000) -> None:
        ...
    @property
    def motion_filter_topology(self) -> SourceEffectMotionFilterTopology:
        r"""
        (SourceEffectMotionFilterTopology):  [Read-Write] In Serial Mode, Filter A will process then Filter B will process; in Parallel mode, Filter A and Filter B will process the dry input seprately, then be mixed together afterward.
        """
        ...
    @motion_filter_topology.setter
    def motion_filter_topology(self, value: SourceEffectMotionFilterTopology) -> None:
        ...
    @property
    def motion_filter_mix(self) -> float:
        r"""
        (float):  [Read-Write] Filter Mix controls the amount of each filter in the signal where -1.0f outputs Only Filter A, 0.0f is an equal balance between Filter A and B, and 1.0f outputs only Filter B. How this blend works depends on the Topology.
        """
        ...
    @motion_filter_mix.setter
    def motion_filter_mix(self, value: float) -> None:
        ...
    @property
    def filter_a_settings(self) -> SourceEffectIndividualFilterSettings:
        r"""
        (SourceEffectIndividualFilterSettings):  [Read-Write] Initial settings for Filter A
        """
        ...
    @filter_a_settings.setter
    def filter_a_settings(self, value: SourceEffectIndividualFilterSettings) -> None:
        ...
    @property
    def filter_b_settings(self) -> SourceEffectIndividualFilterSettings:
        r"""
        (SourceEffectIndividualFilterSettings):  [Read-Write] Initial settings for Filter B
        """
        ...
    @filter_b_settings.setter
    def filter_b_settings(self, value: SourceEffectIndividualFilterSettings) -> None:
        ...
    @property
    def modulation_mappings(self) -> Map[SourceEffectMotionFilterModDestination, SourceEffectMotionFilterModulationSettings]:
        r"""
        (Map[SourceEffectMotionFilterModDestination, SourceEffectMotionFilterModulationSettings]):  [Read-Write] Modulation Mappings
        """
        ...
    @modulation_mappings.setter
    def modulation_mappings(self, value: Map[SourceEffectMotionFilterModDestination, SourceEffectMotionFilterModulationSettings]) -> None:
        ...
    @property
    def dry_volume_db(self) -> float:
        r"""
        (float):  [Read-Write] Dry volume pass-through in dB.
        """
        ...
    @dry_volume_db.setter
    def dry_volume_db(self, value: float) -> None:
        ...

class SourceEffectPannerSettings(StructBase):
    r"""
    Source Effect Panner Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectPanner.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``pan`` (float):  [Read-Write] The pan of the source. -1.0 means left, 0.0 means center, 1.0 means right.
    - ``spread`` (float):  [Read-Write] The spread of the source. 1.0 means left only in left channel, right only in right; 0.0 means both mixed, -1.0 means right and left channels are inverted.
    """
    def __init__(self, spread: float = 0.000000, pan: float = 0.000000) -> None:
        ...
    @property
    def spread(self) -> float:
        r"""
        (float):  [Read-Write] The spread of the source. 1.0 means left only in left channel, right only in right; 0.0 means both mixed, -1.0 means right and left channels are inverted.
        """
        ...
    @spread.setter
    def spread(self, value: float) -> None:
        ...
    @property
    def pan(self) -> float:
        r"""
        (float):  [Read-Write] The pan of the source. -1.0 means left, 0.0 means center, 1.0 means right.
        """
        ...
    @pan.setter
    def pan(self, value: float) -> None:
        ...

class SourceEffectPhaserSettings(StructBase):
    r"""
    Source Effect Phaser Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectPhaser.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``feedback`` (float):  [Read-Write] The feedback of the phaser effect
    - ``frequency`` (float):  [Read-Write] The LFO frequency of the phaser effect
    - ``lfo_type`` (PhaserLFOType):  [Read-Write] The phaser LFO type
    - ``use_quadrature_phase`` (bool):  [Read-Write] Whether or not to use quadtrature phase for the LFO modulation
    - ``wet_level`` (float):  [Read-Write] The wet level of the phaser effect
    """
    def __init__(self, wet_level: float = 0.000000, frequency: float = 0.000000, feedback: float = 0.000000, lfo_type: PhaserLFOType = PhaserLFOType.SINE, use_quadrature_phase: bool = False) -> None:
        ...
    @property
    def wet_level(self) -> float:
        r"""
        (float):  [Read-Write] The wet level of the phaser effect
        """
        ...
    @wet_level.setter
    def wet_level(self, value: float) -> None:
        ...
    @property
    def frequency(self) -> float:
        r"""
        (float):  [Read-Write] The LFO frequency of the phaser effect
        """
        ...
    @frequency.setter
    def frequency(self, value: float) -> None:
        ...
    @property
    def feedback(self) -> float:
        r"""
        (float):  [Read-Write] The feedback of the phaser effect
        """
        ...
    @feedback.setter
    def feedback(self, value: float) -> None:
        ...
    @property
    def lfo_type(self) -> PhaserLFOType:
        r"""
        (PhaserLFOType):  [Read-Write] The phaser LFO type
        """
        ...
    @lfo_type.setter
    def lfo_type(self, value: PhaserLFOType) -> None:
        ...
    @property
    def use_quadrature_phase(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to use quadtrature phase for the LFO modulation
        """
        ...
    @use_quadrature_phase.setter
    def use_quadrature_phase(self, value: bool) -> None:
        ...

class SourceEffectRingModulationSettings(StructBase):
    r"""
    Source Effect Ring Modulation Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectRingModulation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio_bus_modulator`` (AudioBus):  [Read-Write] Audio bus to use to modulate the effect
    - ``depth`` (float):  [Read-Write] Ring modulation depth
    - ``dry_level`` (float):  [Read-Write] Gain for the dry signal (no ring mod)
    - ``frequency`` (float):  [Read-Write] Ring modulation frequency
    - ``modulator_type`` (RingModulatorTypeSourceEffect):  [Read-Write] Ring modulation modulator oscillator type
    - ``wet_level`` (float):  [Read-Write] Gain for the wet signal (with ring mod)
    """
    def __init__(self, modulator_type: RingModulatorTypeSourceEffect = RingModulatorTypeSourceEffect.SINE, frequency: float = 0.000000, depth: float = 0.000000, dry_level: float = 0.000000, wet_level: float = 0.000000, audio_bus_modulator: AudioBus = None) -> None:
        ...
    @property
    def modulator_type(self) -> RingModulatorTypeSourceEffect:
        r"""
        (RingModulatorTypeSourceEffect):  [Read-Write] Ring modulation modulator oscillator type
        """
        ...
    @modulator_type.setter
    def modulator_type(self, value: RingModulatorTypeSourceEffect) -> None:
        ...
    @property
    def frequency(self) -> float:
        r"""
        (float):  [Read-Write] Ring modulation frequency
        """
        ...
    @frequency.setter
    def frequency(self, value: float) -> None:
        ...
    @property
    def depth(self) -> float:
        r"""
        (float):  [Read-Write] Ring modulation depth
        """
        ...
    @depth.setter
    def depth(self, value: float) -> None:
        ...
    @property
    def dry_level(self) -> float:
        r"""
        (float):  [Read-Write] Gain for the dry signal (no ring mod)
        """
        ...
    @dry_level.setter
    def dry_level(self, value: float) -> None:
        ...
    @property
    def wet_level(self) -> float:
        r"""
        (float):  [Read-Write] Gain for the wet signal (with ring mod)
        """
        ...
    @wet_level.setter
    def wet_level(self, value: float) -> None:
        ...
    @property
    def audio_bus_modulator(self) -> AudioBus:
        r"""
        (AudioBus):  [Read-Write] Audio bus to use to modulate the effect
        """
        ...
    @audio_bus_modulator.setter
    def audio_bus_modulator(self, value: AudioBus) -> None:
        ...

class SourceEffectSimpleDelaySettings(StructBase):
    r"""
    Source Effect Simple Delay Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectSimpleDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delay_amount`` (float):  [Read-Write] Delay amount in seconds
    - ``delay_based_on_distance`` (bool):  [Read-Write] Whether or not to delay the audio based on the distance to the listener or use manual delay
    - ``dry_amount`` (float):  [Read-Write] Gain stage on dry (non-delayed signal)
    - ``feedback`` (float):  [Read-Write] Amount to feedback into the delay line (because why not)
    - ``speed_of_sound`` (float):  [Read-Write] Speed of sound in meters per second when using distance-based delay
    - ``use_distance_override`` (bool):  [Read-Write] Whether or not to allow the attenuation distance override value vs the distance to listener to be used for distance-based delay.
    - ``wet_amount`` (float):  [Read-Write] Gain stage on wet (delayed) signal
    """
    def __init__(self, speed_of_sound: float = 0.000000, delay_amount: float = 0.000000, dry_amount: float = 0.000000, wet_amount: float = 0.000000, feedback: float = 0.000000, delay_based_on_distance: bool = False, use_distance_override: bool = False) -> None:
        ...
    @property
    def speed_of_sound(self) -> float:
        r"""
        (float):  [Read-Write] Speed of sound in meters per second when using distance-based delay
        """
        ...
    @speed_of_sound.setter
    def speed_of_sound(self, value: float) -> None:
        ...
    @property
    def delay_amount(self) -> float:
        r"""
        (float):  [Read-Write] Delay amount in seconds
        """
        ...
    @delay_amount.setter
    def delay_amount(self, value: float) -> None:
        ...
    @property
    def dry_amount(self) -> float:
        r"""
        (float):  [Read-Write] Gain stage on dry (non-delayed signal)
        """
        ...
    @dry_amount.setter
    def dry_amount(self, value: float) -> None:
        ...
    @property
    def wet_amount(self) -> float:
        r"""
        (float):  [Read-Write] Gain stage on wet (delayed) signal
        """
        ...
    @wet_amount.setter
    def wet_amount(self, value: float) -> None:
        ...
    @property
    def feedback(self) -> float:
        r"""
        (float):  [Read-Write] Amount to feedback into the delay line (because why not)
        """
        ...
    @feedback.setter
    def feedback(self, value: float) -> None:
        ...
    @property
    def delay_based_on_distance(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to delay the audio based on the distance to the listener or use manual delay
        """
        ...
    @delay_based_on_distance.setter
    def delay_based_on_distance(self, value: bool) -> None:
        ...
    @property
    def use_distance_override(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to allow the attenuation distance override value vs the distance to listener to be used for distance-based delay.
        """
        ...
    @use_distance_override.setter
    def use_distance_override(self, value: bool) -> None:
        ...

class SourceEffectStereoDelaySettings(StructBase):
    r"""
    Source Effect Stereo Delay Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectStereoDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delay_mode`` (StereoDelaySourceEffect):  [Read-Write] What mode to set the stereo delay effect.
    - ``delay_ratio`` (float):  [Read-Write] Delay spread for left and right channels. Allows left and right channels to have differential delay amounts. Useful for stereo channel decorrelation.
    - ``delay_time_msec`` (float):  [Read-Write] The base amount of delay in the left and right channels of the delay line.
    - ``dry_level`` (float):  [Read-Write] The dry level of the effect
    - ``feedback`` (float):  [Read-Write] The amount of audio to feedback into the delay line once the delay has been tapped.
    - ``filter_enabled`` (bool):  [Read-Write] Whether or not to enable filtering
    - ``filter_frequency`` (float):  [Read-Write] Cutoff frequency of the filter
    - ``filter_q`` (float):  [Read-Write] Q of the filter
    - ``filter_type`` (StereoDelayFiltertype):  [Read-Write] Filter type to feed feedback audio to
    - ``wet_level`` (float):  [Read-Write] The amount of delay effect to mix with the dry input signal into the effect.
    """
    def __init__(self, delay_mode: StereoDelaySourceEffect = StereoDelaySourceEffect.NORMAL, delay_time_msec: float = 0.000000, feedback: float = 0.000000, delay_ratio: float = 0.000000, wet_level: float = 0.000000, dry_level: float = 0.000000, filter_enabled: bool = False, filter_type: StereoDelayFiltertype = StereoDelayFiltertype.LOWPASS, filter_frequency: float = 0.000000, filter_q: float = 0.000000) -> None:
        ...
    @property
    def delay_mode(self) -> StereoDelaySourceEffect:
        r"""
        (StereoDelaySourceEffect):  [Read-Write] What mode to set the stereo delay effect.
        """
        ...
    @delay_mode.setter
    def delay_mode(self, value: StereoDelaySourceEffect) -> None:
        ...
    @property
    def delay_time_msec(self) -> float:
        r"""
        (float):  [Read-Write] The base amount of delay in the left and right channels of the delay line.
        """
        ...
    @delay_time_msec.setter
    def delay_time_msec(self, value: float) -> None:
        ...
    @property
    def feedback(self) -> float:
        r"""
        (float):  [Read-Write] The amount of audio to feedback into the delay line once the delay has been tapped.
        """
        ...
    @feedback.setter
    def feedback(self, value: float) -> None:
        ...
    @property
    def delay_ratio(self) -> float:
        r"""
        (float):  [Read-Write] Delay spread for left and right channels. Allows left and right channels to have differential delay amounts. Useful for stereo channel decorrelation.
        """
        ...
    @delay_ratio.setter
    def delay_ratio(self, value: float) -> None:
        ...
    @property
    def wet_level(self) -> float:
        r"""
        (float):  [Read-Write] The amount of delay effect to mix with the dry input signal into the effect.
        """
        ...
    @wet_level.setter
    def wet_level(self, value: float) -> None:
        ...
    @property
    def dry_level(self) -> float:
        r"""
        (float):  [Read-Write] The dry level of the effect
        """
        ...
    @dry_level.setter
    def dry_level(self, value: float) -> None:
        ...
    @property
    def filter_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to enable filtering
        """
        ...
    @filter_enabled.setter
    def filter_enabled(self, value: bool) -> None:
        ...
    @property
    def filter_type(self) -> StereoDelayFiltertype:
        r"""
        (StereoDelayFiltertype):  [Read-Write] Filter type to feed feedback audio to
        """
        ...
    @filter_type.setter
    def filter_type(self, value: StereoDelayFiltertype) -> None:
        ...
    @property
    def filter_frequency(self) -> float:
        r"""
        (float):  [Read-Write] Cutoff frequency of the filter
        """
        ...
    @filter_frequency.setter
    def filter_frequency(self, value: float) -> None:
        ...
    @property
    def filter_q(self) -> float:
        r"""
        (float):  [Read-Write] Q of the filter
        """
        ...
    @filter_q.setter
    def filter_q(self, value: float) -> None:
        ...

class SourceEffectWaveShaperSettings(StructBase):
    r"""
    Source Effect Wave Shaper Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectWaveShaper.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``amount`` (float):  [Read-Write] The amount of wave shaping. 0.0 = no wave shaping.
    - ``output_gain_db`` (float):  [Read-Write] The amount of wave shaping. 0.0 = no wave shaping.
    """
    def __init__(self, amount: float = 0.000000, output_gain_db: float = 0.000000) -> None:
        ...
    @property
    def amount(self) -> float:
        r"""
        (float):  [Read-Write] The amount of wave shaping. 0.0 = no wave shaping.
        """
        ...
    @amount.setter
    def amount(self, value: float) -> None:
        ...
    @property
    def output_gain_db(self) -> float:
        r"""
        (float):  [Read-Write] The amount of wave shaping. 0.0 = no wave shaping.
        """
        ...
    @output_gain_db.setter
    def output_gain_db(self, value: float) -> None:
        ...

class SubmixEffectConvolutionReverbSettings(StructBase):
    r"""
    Submix Effect Convolution Reverb Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectConvolutionReverb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_hardware_acceleration`` (bool):  [Read-Write]
      deprecated: Property 'AllowHardwareAcceleration' is deprecated.
    - ``bypass`` (bool):  [Read-Write] If true, input audio is directly routed to output audio with applying any effect.
    - ``dry_volume_db`` (float):  [Read-Write] Controls how much of the dry signal is mixed into the output, in Decibels
    - ``impulse_response`` (AudioImpulseResponse):  [Read-Write]
      deprecated: Property 'ImpulseResponse' is deprecated.
    - ``invert_rear_channel_bleed_phase`` (bool):  [Read-Write] If true, rear channel bleed sends will have their phase inverted.
    - ``mix_input_channel_format_to_impulse_response_format`` (bool):  [Read-Write] If true, the submix input audio is downmixed to match the IR asset audio channel
             * format. If false, the input audio's channels are matched to the IR assets
             * audio channels.
    - ``mix_reverb_output_to_output_channel_format`` (bool):  [Read-Write] If true, the reverberated audio is upmixed or downmixed to match the submix
             * output audio format. If false, the reverberated audio's channels are matched
             * to the submixs output audio channels.
    - ``surround_rear_channel_bleed_amount`` (float):  [Read-Write]
      deprecated: Property 'SurroundRearChannelBleedAmount' is deprecated.
    - ``surround_rear_channel_bleed_db`` (float):  [Read-Write] Amount of audio to be sent to rear channels in quad/surround configurations
    - ``surround_rear_channel_flip`` (bool):  [Read-Write] If true, send Surround Rear Channel Bleed Amount sends front left to back right and vice versa
    - ``wet_volume_db`` (float):  [Read-Write] Controls how much of the wet signal is mixed into the output, in Decibels
    """
    def __init__(self, wet_volume_db: float = 0.000000, dry_volume_db: float = 0.000000, bypass: bool = False, mix_input_channel_format_to_impulse_response_format: bool = False, mix_reverb_output_to_output_channel_format: bool = False, surround_rear_channel_bleed_db: float = 0.000000, invert_rear_channel_bleed_phase: bool = False, surround_rear_channel_flip: bool = False) -> None:
        ...
    @property
    def wet_volume_db(self) -> float:
        r"""
        (float):  [Read-Write] Controls how much of the wet signal is mixed into the output, in Decibels
        """
        ...
    @wet_volume_db.setter
    def wet_volume_db(self, value: float) -> None:
        ...
    @property
    def dry_volume_db(self) -> float:
        r"""
        (float):  [Read-Write] Controls how much of the dry signal is mixed into the output, in Decibels
        """
        ...
    @dry_volume_db.setter
    def dry_volume_db(self, value: float) -> None:
        ...
    @property
    def bypass(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, input audio is directly routed to output audio with applying any effect.
        """
        ...
    @bypass.setter
    def bypass(self, value: bool) -> None:
        ...
    @property
    def mix_input_channel_format_to_impulse_response_format(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the submix input audio is downmixed to match the IR asset audio channel
               * format. If false, the input audio's channels are matched to the IR assets
               * audio channels.
        """
        ...
    @mix_input_channel_format_to_impulse_response_format.setter
    def mix_input_channel_format_to_impulse_response_format(self, value: bool) -> None:
        ...
    @property
    def mix_reverb_output_to_output_channel_format(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the reverberated audio is upmixed or downmixed to match the submix
               * output audio format. If false, the reverberated audio's channels are matched
               * to the submixs output audio channels.
        """
        ...
    @mix_reverb_output_to_output_channel_format.setter
    def mix_reverb_output_to_output_channel_format(self, value: bool) -> None:
        ...
    @property
    def surround_rear_channel_bleed_db(self) -> float:
        r"""
        (float):  [Read-Write] Amount of audio to be sent to rear channels in quad/surround configurations
        """
        ...
    @surround_rear_channel_bleed_db.setter
    def surround_rear_channel_bleed_db(self, value: float) -> None:
        ...
    @property
    def invert_rear_channel_bleed_phase(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, rear channel bleed sends will have their phase inverted.
        """
        ...
    @invert_rear_channel_bleed_phase.setter
    def invert_rear_channel_bleed_phase(self, value: bool) -> None:
        ...
    @property
    def surround_rear_channel_flip(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, send Surround Rear Channel Bleed Amount sends front left to back right and vice versa
        """
        ...
    @surround_rear_channel_flip.setter
    def surround_rear_channel_flip(self, value: bool) -> None:
        ...
    @property
    def surround_rear_channel_bleed_amount(self) -> float:
        r"""
        (float):  [Read-Write]
        deprecated: Property 'SurroundRearChannelBleedAmount' is deprecated.
        """
        ...
    @surround_rear_channel_bleed_amount.setter
    def surround_rear_channel_bleed_amount(self, value: float) -> None:
        ...
    @property
    def impulse_response(self) -> AudioImpulseResponse:
        r"""
        (AudioImpulseResponse):  [Read-Write]
        deprecated: Property 'ImpulseResponse' is deprecated.
        """
        ...
    @impulse_response.setter
    def impulse_response(self, value: AudioImpulseResponse) -> None:
        ...
    @property
    def allow_hardware_acceleration(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: Property 'AllowHardwareAcceleration' is deprecated.
        """
        ...
    @allow_hardware_acceleration.setter
    def allow_hardware_acceleration(self, value: bool) -> None:
        ...

class SubmixEffectDelaySettings(StructBase):
    r"""
    FSubmixEffectDelaySettings
    UStruct used to define user-exposed params for use with your effect.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delay_length`` (float):  [Read-Write] Number of milliseconds of delay.  Caps at max delay at runtime.
    - ``interpolation_time`` (float):  [Read-Write] Number of milliseconds over which a tap will reach it's set length and gain. Smaller values are more responsive, while larger values will make pitching less dramatic.
    - ``maximum_delay_length`` (float):  [Read-Write] Maximum possible length for a delay, in milliseconds. Changing this at runtime will reset the effect.
    """
    def __init__(self, maximum_delay_length: float = 0.000000, interpolation_time: float = 0.000000, delay_length: float = 0.000000) -> None:
        ...
    @property
    def maximum_delay_length(self) -> float:
        r"""
        (float):  [Read-Write] Maximum possible length for a delay, in milliseconds. Changing this at runtime will reset the effect.
        """
        ...
    @maximum_delay_length.setter
    def maximum_delay_length(self, value: float) -> None:
        ...
    @property
    def interpolation_time(self) -> float:
        r"""
        (float):  [Read-Write] Number of milliseconds over which a tap will reach it's set length and gain. Smaller values are more responsive, while larger values will make pitching less dramatic.
        """
        ...
    @interpolation_time.setter
    def interpolation_time(self, value: float) -> None:
        ...
    @property
    def delay_length(self) -> float:
        r"""
        (float):  [Read-Write] Number of milliseconds of delay.  Caps at max delay at runtime.
        """
        ...
    @delay_length.setter
    def delay_length(self, value: float) -> None:
        ...

class SubmixEffectFilterSettings(StructBase):
    r"""
    FSubmixEffectFilterSettings
    UStruct used to define user-exposed params for use with your effect.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``filter_algorithm`` (SubmixFilterAlgorithm):  [Read-Write] What type of filter algorithm to use for the submix filter effect
    - ``filter_frequency`` (float):  [Read-Write] The output filter cutoff frequency (hz) [0.0, 20000.0]
    - ``filter_q`` (float):  [Read-Write] The output filter resonance (Q) [0.5, 10]
    - ``filter_type`` (SubmixFilterType):  [Read-Write] What type of filter to use for the submix filter effect
    """
    def __init__(self, filter_type: SubmixFilterType = SubmixFilterType.LOW_PASS, filter_algorithm: SubmixFilterAlgorithm = SubmixFilterAlgorithm.ONE_POLE, filter_frequency: float = 0.000000, filter_q: float = 0.000000) -> None:
        ...
    @property
    def filter_type(self) -> SubmixFilterType:
        r"""
        (SubmixFilterType):  [Read-Write] What type of filter to use for the submix filter effect
        """
        ...
    @filter_type.setter
    def filter_type(self, value: SubmixFilterType) -> None:
        ...
    @property
    def filter_algorithm(self) -> SubmixFilterAlgorithm:
        r"""
        (SubmixFilterAlgorithm):  [Read-Write] What type of filter algorithm to use for the submix filter effect
        """
        ...
    @filter_algorithm.setter
    def filter_algorithm(self, value: SubmixFilterAlgorithm) -> None:
        ...
    @property
    def filter_frequency(self) -> float:
        r"""
        (float):  [Read-Write] The output filter cutoff frequency (hz) [0.0, 20000.0]
        """
        ...
    @filter_frequency.setter
    def filter_frequency(self, value: float) -> None:
        ...
    @property
    def filter_q(self) -> float:
        r"""
        (float):  [Read-Write] The output filter resonance (Q) [0.5, 10]
        """
        ...
    @filter_q.setter
    def filter_q(self, value: float) -> None:
        ...

class SubmixEffectFlexiverbSettings(StructBase):
    r"""
    Submix Effect Flexiverb Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectFlexiverb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``complexity`` (int32):  [Read-Write]
    - ``decay_time`` (float):  [Read-Write] Time in seconds it will take for the impulse response to decay to -60 dB.
    - ``pre_delay`` (float):  [Read-Write] PreDelay - 0.01 < 10.0 < 40.0 - Amount of delay to the first echo in milliseconds.
    - ``room_dampening`` (float):  [Read-Write] Room Dampening - 0.0 < 0.85 < 1.0 - Frequency at which the room dampens.
    """
    def __init__(self, pre_delay: float = 0.000000, decay_time: float = 0.000000, room_dampening: float = 0.000000, complexity: int = 0) -> None:
        ...
    @property
    def pre_delay(self) -> float:
        r"""
        (float):  [Read-Write] PreDelay - 0.01 < 10.0 < 40.0 - Amount of delay to the first echo in milliseconds.
        """
        ...
    @pre_delay.setter
    def pre_delay(self, value: float) -> None:
        ...
    @property
    def decay_time(self) -> float:
        r"""
        (float):  [Read-Write] Time in seconds it will take for the impulse response to decay to -60 dB.
        """
        ...
    @decay_time.setter
    def decay_time(self, value: float) -> None:
        ...
    @property
    def room_dampening(self) -> float:
        r"""
        (float):  [Read-Write] Room Dampening - 0.0 < 0.85 < 1.0 - Frequency at which the room dampens.
        """
        ...
    @room_dampening.setter
    def room_dampening(self, value: float) -> None:
        ...
    @property
    def complexity(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @complexity.setter
    def complexity(self, value: int) -> None:
        ...

class DynamicsBandSettings(StructBase):
    r"""
    Dynamics Band Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectMultiBandCompressor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attack_time_msec`` (float):  [Read-Write] The amount of time to ramp into any dynamics processing effect in milliseconds.
    - ``crossover_top_frequency`` (float):  [Read-Write] Frequency of the crossover between this band and the next. The last band will have this property ignored
    - ``input_gain_db`` (float):  [Read-Write] The input gain of the dynamics processor in dB
    - ``knee_bandwidth_db`` (float):  [Read-Write] The knee bandwidth of the compressor to use in dB
    - ``output_gain_db`` (float):  [Read-Write] The output gain of the dynamics processor in dB
    - ``ratio`` (float):  [Read-Write] The dynamics processor ratio -- has different meaning depending on the processor type.
    - ``release_time_msec`` (float):  [Read-Write] The amount of time to release the dynamics processing effect in milliseconds
    - ``threshold_db`` (float):  [Read-Write] The threshold at which to perform a dynamics processing operation
    """
    def __init__(self, crossover_top_frequency: float = 0.000000, attack_time_msec: float = 0.000000, release_time_msec: float = 0.000000, threshold_db: float = 0.000000, ratio: float = 0.000000, knee_bandwidth_db: float = 0.000000, input_gain_db: float = 0.000000, output_gain_db: float = 0.000000) -> None:
        ...
    @property
    def crossover_top_frequency(self) -> float:
        r"""
        (float):  [Read-Write] Frequency of the crossover between this band and the next. The last band will have this property ignored
        """
        ...
    @crossover_top_frequency.setter
    def crossover_top_frequency(self, value: float) -> None:
        ...
    @property
    def attack_time_msec(self) -> float:
        r"""
        (float):  [Read-Write] The amount of time to ramp into any dynamics processing effect in milliseconds.
        """
        ...
    @attack_time_msec.setter
    def attack_time_msec(self, value: float) -> None:
        ...
    @property
    def release_time_msec(self) -> float:
        r"""
        (float):  [Read-Write] The amount of time to release the dynamics processing effect in milliseconds
        """
        ...
    @release_time_msec.setter
    def release_time_msec(self, value: float) -> None:
        ...
    @property
    def threshold_db(self) -> float:
        r"""
        (float):  [Read-Write] The threshold at which to perform a dynamics processing operation
        """
        ...
    @threshold_db.setter
    def threshold_db(self, value: float) -> None:
        ...
    @property
    def ratio(self) -> float:
        r"""
        (float):  [Read-Write] The dynamics processor ratio -- has different meaning depending on the processor type.
        """
        ...
    @ratio.setter
    def ratio(self, value: float) -> None:
        ...
    @property
    def knee_bandwidth_db(self) -> float:
        r"""
        (float):  [Read-Write] The knee bandwidth of the compressor to use in dB
        """
        ...
    @knee_bandwidth_db.setter
    def knee_bandwidth_db(self, value: float) -> None:
        ...
    @property
    def input_gain_db(self) -> float:
        r"""
        (float):  [Read-Write] The input gain of the dynamics processor in dB
        """
        ...
    @input_gain_db.setter
    def input_gain_db(self, value: float) -> None:
        ...
    @property
    def output_gain_db(self) -> float:
        r"""
        (float):  [Read-Write] The output gain of the dynamics processor in dB
        """
        ...
    @output_gain_db.setter
    def output_gain_db(self, value: float) -> None:
        ...

class SubmixEffectMultibandCompressorSettings(StructBase):
    r"""
    A submix dynamics processor
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectMultiBandCompressor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``analog_mode`` (bool):  [Read-Write] Toggles treating the attack and release envelopes as analog-style vs digital-style. Analog will respond a bit more naturally/slower.
    - ``bands`` (Array[DynamicsBandSettings]):  [Read-Write] Each band is a full dynamics processor, affecting at a unique frequency range
    - ``bypass`` (bool):  [Read-Write] Whether or not to bypass effect
    - ``dynamics_processor_type`` (SubmixEffectDynamicsProcessorType):  [Read-Write] Controls how each band will react to audio above its threshold
    - ``external_audio_bus`` (AudioBus):  [Read-Write] If set, uses output of provided submix as modulator of input signal for dynamics processor (Uses input signal as default modulator)
    - ``external_submix`` (SoundSubmix):  [Read-Write] If set, uses output of provided submix as modulator of input signal for dynamics processor (Uses input signal as default modulator)
    - ``four_pole`` (bool):  [Read-Write] Turning off FourPole mode will use cheaper, shallower 2-pole crossovers
    - ``key_audition`` (bool):  [Read-Write] Audition the key modulation signal, bypassing enveloping and processing the input signal.
    - ``key_gain_db`` (float):  [Read-Write] Gain to apply to key signal if external input is supplied
    - ``key_source`` (SubmixEffectDynamicsKeySource):  [Read-Write]
    - ``link_mode`` (SubmixEffectDynamicsChannelLinkMode):  [Read-Write] Whether to compress all channels equally, and how to evaluate the overall level
    - ``look_ahead_msec`` (float):  [Read-Write] The amount of time to look ahead of the current audio. Allows for transients to be included in dynamics processing.
    - ``peak_mode`` (SubmixEffectDynamicsPeakMode):  [Read-Write] Controls how quickly the bands will react to a signal above its threshold
    """
    def __init__(self, dynamics_processor_type: SubmixEffectDynamicsProcessorType = SubmixEffectDynamicsProcessorType.COMPRESSOR, peak_mode: SubmixEffectDynamicsPeakMode = SubmixEffectDynamicsPeakMode.MEAN_SQUARED, link_mode: SubmixEffectDynamicsChannelLinkMode = SubmixEffectDynamicsChannelLinkMode.DISABLED, look_ahead_msec: float = 0.000000, analog_mode: bool = False, four_pole: bool = False, bypass: bool = False, key_source: SubmixEffectDynamicsKeySource = SubmixEffectDynamicsKeySource.DEFAULT, external_audio_bus: AudioBus = None, external_submix: SoundSubmix = None, key_gain_db: float = 0.000000, key_audition: bool = False, bands: Array[DynamicsBandSettings] = []) -> None:
        ...
    @property
    def dynamics_processor_type(self) -> SubmixEffectDynamicsProcessorType:
        r"""
        (SubmixEffectDynamicsProcessorType):  [Read-Write] Controls how each band will react to audio above its threshold
        """
        ...
    @dynamics_processor_type.setter
    def dynamics_processor_type(self, value: SubmixEffectDynamicsProcessorType) -> None:
        ...
    @property
    def peak_mode(self) -> SubmixEffectDynamicsPeakMode:
        r"""
        (SubmixEffectDynamicsPeakMode):  [Read-Write] Controls how quickly the bands will react to a signal above its threshold
        """
        ...
    @peak_mode.setter
    def peak_mode(self, value: SubmixEffectDynamicsPeakMode) -> None:
        ...
    @property
    def link_mode(self) -> SubmixEffectDynamicsChannelLinkMode:
        r"""
        (SubmixEffectDynamicsChannelLinkMode):  [Read-Write] Whether to compress all channels equally, and how to evaluate the overall level
        """
        ...
    @link_mode.setter
    def link_mode(self, value: SubmixEffectDynamicsChannelLinkMode) -> None:
        ...
    @property
    def look_ahead_msec(self) -> float:
        r"""
        (float):  [Read-Write] The amount of time to look ahead of the current audio. Allows for transients to be included in dynamics processing.
        """
        ...
    @look_ahead_msec.setter
    def look_ahead_msec(self, value: float) -> None:
        ...
    @property
    def analog_mode(self) -> bool:
        r"""
        (bool):  [Read-Write] Toggles treating the attack and release envelopes as analog-style vs digital-style. Analog will respond a bit more naturally/slower.
        """
        ...
    @analog_mode.setter
    def analog_mode(self, value: bool) -> None:
        ...
    @property
    def four_pole(self) -> bool:
        r"""
        (bool):  [Read-Write] Turning off FourPole mode will use cheaper, shallower 2-pole crossovers
        """
        ...
    @four_pole.setter
    def four_pole(self, value: bool) -> None:
        ...
    @property
    def bypass(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to bypass effect
        """
        ...
    @bypass.setter
    def bypass(self, value: bool) -> None:
        ...
    @property
    def key_source(self) -> SubmixEffectDynamicsKeySource:
        r"""
        (SubmixEffectDynamicsKeySource):  [Read-Write]
        """
        ...
    @key_source.setter
    def key_source(self, value: SubmixEffectDynamicsKeySource) -> None:
        ...
    @property
    def external_audio_bus(self) -> AudioBus:
        r"""
        (AudioBus):  [Read-Write] If set, uses output of provided submix as modulator of input signal for dynamics processor (Uses input signal as default modulator)
        """
        ...
    @external_audio_bus.setter
    def external_audio_bus(self, value: AudioBus) -> None:
        ...
    @property
    def external_submix(self) -> SoundSubmix:
        r"""
        (SoundSubmix):  [Read-Write] If set, uses output of provided submix as modulator of input signal for dynamics processor (Uses input signal as default modulator)
        """
        ...
    @external_submix.setter
    def external_submix(self, value: SoundSubmix) -> None:
        ...
    @property
    def key_gain_db(self) -> float:
        r"""
        (float):  [Read-Write] Gain to apply to key signal if external input is supplied
        """
        ...
    @key_gain_db.setter
    def key_gain_db(self, value: float) -> None:
        ...
    @property
    def key_audition(self) -> bool:
        r"""
        (bool):  [Read-Write] Audition the key modulation signal, bypassing enveloping and processing the input signal.
        """
        ...
    @key_audition.setter
    def key_audition(self, value: bool) -> None:
        ...
    @property
    def bands(self) -> Array[DynamicsBandSettings]:
        r"""
        (Array[DynamicsBandSettings]):  [Read-Write] Each band is a full dynamics processor, affecting at a unique frequency range
        """
        ...
    @bands.setter
    def bands(self, value: Array[DynamicsBandSettings]) -> None:
        ...

class SubmixEffectStereoDelaySettings(StructBase):
    r"""
    Submix Effect Stereo Delay Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectStereoDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delay_mode`` (StereoDelaySourceEffect):  [Read-Write] What mode to set the stereo delay effect.
    - ``delay_ratio`` (float):  [Read-Write] Delay spread for left and right channels. Allows left and right channels to have differential delay amounts. Useful for stereo channel decorrelation.
    - ``delay_time_msec`` (float):  [Read-Write] The base amount of delay in the left and right channels of the delay line.
    - ``dry_level`` (float):  [Read-Write] The dry level of the effect
    - ``feedback`` (float):  [Read-Write] The amount of audio to feedback into the delay line once the delay has been tapped.
    - ``filter_enabled`` (bool):  [Read-Write] Whether or not to enable filtering
    - ``filter_frequency`` (float):  [Read-Write] Cutoff frequency of the filter
    - ``filter_q`` (float):  [Read-Write] Q of the filter
    - ``filter_type`` (StereoDelayFiltertype):  [Read-Write] Filter type to feed feedback audio to
    - ``wet_level`` (float):  [Read-Write] The amount of delay effect to mix with the dry input signal into the effect.
    """
    def __init__(self, delay_mode: StereoDelaySourceEffect = StereoDelaySourceEffect.NORMAL, delay_time_msec: float = 0.000000, feedback: float = 0.000000, delay_ratio: float = 0.000000, wet_level: float = 0.000000, dry_level: float = 0.000000, filter_enabled: bool = False, filter_type: StereoDelayFiltertype = StereoDelayFiltertype.LOWPASS, filter_frequency: float = 0.000000, filter_q: float = 0.000000) -> None:
        ...
    @property
    def delay_mode(self) -> StereoDelaySourceEffect:
        r"""
        (StereoDelaySourceEffect):  [Read-Write] What mode to set the stereo delay effect.
        """
        ...
    @delay_mode.setter
    def delay_mode(self, value: StereoDelaySourceEffect) -> None:
        ...
    @property
    def delay_time_msec(self) -> float:
        r"""
        (float):  [Read-Write] The base amount of delay in the left and right channels of the delay line.
        """
        ...
    @delay_time_msec.setter
    def delay_time_msec(self, value: float) -> None:
        ...
    @property
    def feedback(self) -> float:
        r"""
        (float):  [Read-Write] The amount of audio to feedback into the delay line once the delay has been tapped.
        """
        ...
    @feedback.setter
    def feedback(self, value: float) -> None:
        ...
    @property
    def delay_ratio(self) -> float:
        r"""
        (float):  [Read-Write] Delay spread for left and right channels. Allows left and right channels to have differential delay amounts. Useful for stereo channel decorrelation.
        """
        ...
    @delay_ratio.setter
    def delay_ratio(self, value: float) -> None:
        ...
    @property
    def wet_level(self) -> float:
        r"""
        (float):  [Read-Write] The amount of delay effect to mix with the dry input signal into the effect.
        """
        ...
    @wet_level.setter
    def wet_level(self, value: float) -> None:
        ...
    @property
    def dry_level(self) -> float:
        r"""
        (float):  [Read-Write] The dry level of the effect
        """
        ...
    @dry_level.setter
    def dry_level(self, value: float) -> None:
        ...
    @property
    def filter_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to enable filtering
        """
        ...
    @filter_enabled.setter
    def filter_enabled(self, value: bool) -> None:
        ...
    @property
    def filter_type(self) -> StereoDelayFiltertype:
        r"""
        (StereoDelayFiltertype):  [Read-Write] Filter type to feed feedback audio to
        """
        ...
    @filter_type.setter
    def filter_type(self, value: StereoDelayFiltertype) -> None:
        ...
    @property
    def filter_frequency(self) -> float:
        r"""
        (float):  [Read-Write] Cutoff frequency of the filter
        """
        ...
    @filter_frequency.setter
    def filter_frequency(self, value: float) -> None:
        ...
    @property
    def filter_q(self) -> float:
        r"""
        (float):  [Read-Write] Q of the filter
        """
        ...
    @filter_q.setter
    def filter_q(self, value: float) -> None:
        ...

class SubmixEffectStereoToQuadSettings(StructBase):
    r"""
    Submix Effect Stereo to Quad Settings
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectStereoToQuad.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``flip_channels`` (bool):  [Read-Write] Whether or not to flip the left and right input channels when sending to the rear channel.
      This can be useful to have a stereo field when hearing audio to the left and right in surround output configuration.
    - ``rear_channel_gain`` (float):  [Read-Write] The gain (in decibels) of the rear channels
    """
    def __init__(self, flip_channels: bool = False, rear_channel_gain: float = 0.000000) -> None:
        ...
    @property
    def flip_channels(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to flip the left and right input channels when sending to the rear channel.
        This can be useful to have a stereo field when hearing audio to the left and right in surround output configuration.
        """
        ...
    @flip_channels.setter
    def flip_channels(self, value: bool) -> None:
        ...
    @property
    def rear_channel_gain(self) -> float:
        r"""
        (float):  [Read-Write] The gain (in decibels) of the rear channels
        """
        ...
    @rear_channel_gain.setter
    def rear_channel_gain(self, value: float) -> None:
        ...

class TapDelayInfo(StructBase):
    r"""
    Tap Delay Info
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectTapDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delay_length`` (float):  [Read-Write] Amount of time before this echo is heard in milliseconds.
    - ``gain`` (float):  [Read-Write] How loud this echo should be, in decibels.
    - ``output_channel`` (int32):  [Read-Write] When the Tap Line Mode is set to Send To Channel, designates index of channel from which the echo should play.
    - ``pan_in_degrees`` (float):  [Read-Write] When the Tap Line Mode is set to Panning, designates the angle at which the echo should be panned.
      On Surround systems, 0 is directly in front of the listener, -90 is left, 90 is right, and 180/-180 is directly behind the listener.
      On Stereo systems, <-90 is fully in the left ear, and >90 is fully in the right ear
    - ``tap_line_mode`` (TapLineMode):  [Read-Write] Whether the tap line should send directly to a channel, pan, or not produce sound at all.
    """
    def __init__(self, tap_line_mode: TapLineMode = TapLineMode.SEND_TO_CHANNEL, delay_length: float = 0.000000, gain: float = 0.000000, output_channel: int = 0, pan_in_degrees: float = 0.000000) -> None:
        ...
    @property
    def tap_line_mode(self) -> TapLineMode:
        r"""
        (TapLineMode):  [Read-Write] Whether the tap line should send directly to a channel, pan, or not produce sound at all.
        """
        ...
    @tap_line_mode.setter
    def tap_line_mode(self, value: TapLineMode) -> None:
        ...
    @property
    def delay_length(self) -> float:
        r"""
        (float):  [Read-Write] Amount of time before this echo is heard in milliseconds.
        """
        ...
    @delay_length.setter
    def delay_length(self, value: float) -> None:
        ...
    @property
    def gain(self) -> float:
        r"""
        (float):  [Read-Write] How loud this echo should be, in decibels.
        """
        ...
    @gain.setter
    def gain(self, value: float) -> None:
        ...
    @property
    def output_channel(self) -> int:
        r"""
        (int32):  [Read-Write] When the Tap Line Mode is set to Send To Channel, designates index of channel from which the echo should play.
        """
        ...
    @output_channel.setter
    def output_channel(self, value: int) -> None:
        ...
    @property
    def pan_in_degrees(self) -> float:
        r"""
        (float):  [Read-Write] When the Tap Line Mode is set to Panning, designates the angle at which the echo should be panned.
        On Surround systems, 0 is directly in front of the listener, -90 is left, 90 is right, and 180/-180 is directly behind the listener.
        On Stereo systems, <-90 is fully in the left ear, and >90 is fully in the right ear
        """
        ...
    @pan_in_degrees.setter
    def pan_in_degrees(self, value: float) -> None:
        ...

class SubmixEffectTapDelaySettings(StructBase):
    r"""
    FTapDelaySubmixPresetSettings
    UStruct used to define user-exposed params for use with your effect.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectTapDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``interpolation_time`` (float):  [Read-Write] Number of milliseconds over which a tap will reach it's set length and gain. Smaller values are more responsive, while larger values will make pitching less dramatic.
    - ``maximum_delay_length`` (float):  [Read-Write] Maximum possible length for a delay, in milliseconds. Changing this at runtime will reset the effect.
    - ``taps`` (Array[TapDelayInfo]):  [Read-Write] Each tap's metadata
    """
    def __init__(self, maximum_delay_length: float = 0.000000, interpolation_time: float = 0.000000, taps: Array[TapDelayInfo] = []) -> None:
        ...
    @property
    def maximum_delay_length(self) -> float:
        r"""
        (float):  [Read-Write] Maximum possible length for a delay, in milliseconds. Changing this at runtime will reset the effect.
        """
        ...
    @maximum_delay_length.setter
    def maximum_delay_length(self, value: float) -> None:
        ...
    @property
    def interpolation_time(self) -> float:
        r"""
        (float):  [Read-Write] Number of milliseconds over which a tap will reach it's set length and gain. Smaller values are more responsive, while larger values will make pitching less dramatic.
        """
        ...
    @interpolation_time.setter
    def interpolation_time(self, value: float) -> None:
        ...
    @property
    def taps(self) -> Array[TapDelayInfo]:
        r"""
        (Array[TapDelayInfo]):  [Read-Write] Each tap's metadata
        """
        ...
    @taps.setter
    def taps(self, value: Array[TapDelayInfo]) -> None:
        ...

class Synth2DSliderStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SSynth2DSlider
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: Synth2DSliderStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``background_image`` (SlateBrush):  [Read-Write]
    - ``bar_thickness`` (float):  [Read-Write]
    - ``disabled_bar_image`` (SlateBrush):  [Read-Write]
    - ``disabled_thumb_image`` (SlateBrush):  [Read-Write] Image to use for the 2D handle
    - ``normal_bar_image`` (SlateBrush):  [Read-Write]
    - ``normal_thumb_image`` (SlateBrush):  [Read-Write] Image to use for the 2D handle
    """
    def __init__(self, normal_thumb_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], disabled_thumb_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], normal_bar_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], disabled_bar_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], background_image: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], bar_thickness: float = 0.000000) -> None:
        ...
    @property
    def normal_thumb_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use for the 2D handle
        """
        ...
    @normal_thumb_image.setter
    def normal_thumb_image(self, value: SlateBrush) -> None:
        ...
    @property
    def disabled_thumb_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use for the 2D handle
        """
        ...
    @disabled_thumb_image.setter
    def disabled_thumb_image(self, value: SlateBrush) -> None:
        ...
    @property
    def normal_bar_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @normal_bar_image.setter
    def normal_bar_image(self, value: SlateBrush) -> None:
        ...
    @property
    def disabled_bar_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @disabled_bar_image.setter
    def disabled_bar_image(self, value: SlateBrush) -> None:
        ...
    @property
    def background_image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @background_image.setter
    def background_image(self, value: SlateBrush) -> None:
        ...
    @property
    def bar_thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @bar_thickness.setter
    def bar_thickness(self, value: float) -> None:
        ...

class SynthKnobStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of an SSynthKnob
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthKnobStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``knob_size`` (SynthKnobSize):  [Read-Write] The size of the knobs to use.
    - ``large_knob`` (SlateBrush):  [Read-Write] Image to use for the large knob
    - ``large_knob_overlay`` (SlateBrush):  [Read-Write] Image to use for the dot handle
    - ``max_value_angle`` (float):  [Read-Write] Image to use for the medium knob dot handle
    - ``medium_knob`` (SlateBrush):  [Read-Write] Image to use for the medium large knob
    - ``medium_knob_overlay`` (SlateBrush):  [Read-Write] Image to use for the medium knob dot handle
    - ``min_value_angle`` (float):  [Read-Write] Image to use for the medium knob dot handle
    """
    def __init__(self, large_knob: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], large_knob_overlay: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], medium_knob: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], medium_knob_overlay: SlateBrush = [SlateBrushDrawType.IMAGE, SlateBrushTileType.NO_TILE, SlateBrushMirrorType.NO_MIRROR, [0.000000, 0.000000], [0.000000, 0.000000, 0.000000, 0.000000], [[1.000000, 1.000000, 1.000000, 1.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], [[0.000000, 0.000000, 0.000000, 0.000000], [[0.000000, 0.000000, 0.000000, 0.000000], SlateColorStylingMode.USE_COLOR_SPECIFIED], 0.000000, SlateBrushRoundingType.HALF_HEIGHT_RADIUS, False], None], min_value_angle: float = 0.000000, max_value_angle: float = 0.000000, knob_size: SynthKnobSize = SynthKnobSize.MEDIUM) -> None:
        ...
    @property
    def large_knob(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use for the large knob
        """
        ...
    @large_knob.setter
    def large_knob(self, value: SlateBrush) -> None:
        ...
    @property
    def large_knob_overlay(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use for the dot handle
        """
        ...
    @large_knob_overlay.setter
    def large_knob_overlay(self, value: SlateBrush) -> None:
        ...
    @property
    def medium_knob(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use for the medium large knob
        """
        ...
    @medium_knob.setter
    def medium_knob(self, value: SlateBrush) -> None:
        ...
    @property
    def medium_knob_overlay(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to use for the medium knob dot handle
        """
        ...
    @medium_knob_overlay.setter
    def medium_knob_overlay(self, value: SlateBrush) -> None:
        ...
    @property
    def min_value_angle(self) -> float:
        r"""
        (float):  [Read-Write] Image to use for the medium knob dot handle
        """
        ...
    @min_value_angle.setter
    def min_value_angle(self, value: float) -> None:
        ...
    @property
    def max_value_angle(self) -> float:
        r"""
        (float):  [Read-Write] Image to use for the medium knob dot handle
        """
        ...
    @max_value_angle.setter
    def max_value_angle(self, value: float) -> None:
        ...
    @property
    def knob_size(self) -> SynthKnobSize:
        r"""
        (SynthKnobSize):  [Read-Write] The size of the knobs to use.
        """
        ...
    @knob_size.setter
    def knob_size(self, value: SynthKnobSize) -> None:
        ...

class SynthSlateStyle(SlateWidgetStyle):
    r"""
    Represents the appearance of synth UI elements in slate.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthSlateStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_style`` (SynthSlateColorStyle):  [Read-Write] Image to use when the slider bar is in its disabled state
    - ``size_type`` (SynthSlateSizeType):  [Read-Write] The size of the knobs to use.
    """
    def __init__(self, size_type: SynthSlateSizeType = SynthSlateSizeType.SMALL, color_style: SynthSlateColorStyle = SynthSlateColorStyle.LIGHT) -> None:
        ...
    @property
    def size_type(self) -> SynthSlateSizeType:
        r"""
        (SynthSlateSizeType):  [Read-Write] The size of the knobs to use.
        """
        ...
    @size_type.setter
    def size_type(self, value: SynthSlateSizeType) -> None:
        ...
    @property
    def color_style(self) -> SynthSlateColorStyle:
        r"""
        (SynthSlateColorStyle):  [Read-Write] Image to use when the slider bar is in its disabled state
        """
        ...
    @color_style.setter
    def color_style(self, value: SynthSlateColorStyle) -> None:
        ...

class VersionedNiagaraEmitterData(StructBase):
    r"""
    Struct containing all of the data that can be different between different emitter versions.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEmitter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``add_emitter_default_view_state`` (NiagaraEmitterDefaultSummaryState):  [Read-Write] This determines how emitters will be added to a system by default. If summary view is setup, consider setting this to 'Summary'.
    - ``allocation_mode`` (ParticleAllocationMode):  [Read-Write] The emitter needs to allocate memory for the particles each tick.
      To prevent reallocations, the emitter should allocate as much memory as is needed for the max particle count.
      This setting controls if the allocation size should be automatically determined or manually entered.
    - ``attributes_to_preserve`` (Array[str]):  [Read-Write] An allow list of Particle attributes (e.g. "Particle.Position" or "Particle.Age") that will not be removed from the DataSet  even if they aren't read by the VM.
                Used in conjunction with UNiagaraSystem::bTrimAttributes
    - ``calculate_bounds_mode`` (NiagaraEmitterCalculateBoundMode):  [Read-Write] How should we calculate bounds for the emitter.
      Note: If this is greyed out it means fixed bounds are enabled in the System Properties and these bounds are therefore ignored.
    - ``determinism`` (bool):  [Read-Write] Toggles whether to globally make the random number generator be deterministic or non-deterministic. Any random calculation that is set to the emitter defaults will inherit this value. It is still possible to tweak individual random to be deterministic or not. In this case deterministic means that it will return the same results for the same configuration of the emitter as long as delta time is not variable. Any changes to the emitter's individual scripts will adjust the results.
    - ``fixed_bounds`` (Box):  [Read-Write] The fixed bounding box value. CalculateBoundsMode is the condition whether the fixed bounds can be edited.
      Note: If this is greyed out it means fixed bounds are enabled in the System Properties and these bounds are therefore ignored.
    - ``interpolated_spawning`` (bool):  [Read-Write] When enabled, this will spawn using interpolated parameter values and perform a partial update at spawn time. This adds significant additional cost for spawning but will produce much smoother spawning for high spawn rates, erratic frame rates and fast moving emitters.
    - ``local_space`` (bool):  [Read-Write] Toggles whether or not the particles within this emitter are relative to the emitter origin or in global space.
    - ``max_gpu_particles_spawn_per_frame`` (int32):  [Read-Write] An override on the max number of GPU particles we expect to spawn in a single frame. A value of 0 means it'll use fx.MaxNiagaraGPUParticlesSpawnPerFrame.
    - ``platforms`` (NiagaraPlatformSet):  [Read-Write]
    - ``pre_allocation_count`` (int32):  [Read-Write] The emitter will allocate at least this many particles on it's first tick.
      This can aid performance by avoiding many allocations as an emitter ramps up to it's max size.
    - ``random_seed`` (int32):  [Read-Write] An emitter-based seed for the deterministic random number generator.
    - ``requires_persistent_i_ds`` (bool):  [Read-Write] Creates a stable Identifier (Particles.ID) which does not vary from frame to frame. This comes at a small memory and performance cost. This allows external objects to track the same particle over multiple frames. Particle arrays are tightly packed and a particle's actual index in the array may change from frame to frame. This optionally lets you use a lookup table to track a particle by index in the lookup table.
    - ``scalability_overrides`` (NiagaraEmitterScalabilityOverrides):  [Read-Write]
    - ``sim_stage_execution_loop_editor_data`` (Array[NiagaraSimStageExecutionLoopEditorData]):  [Read-Write]
    - ``sim_target`` (NiagaraSimTarget):  [Read-Write]
    """
    def __init__(self, local_space: bool = False, determinism: bool = False, random_seed: int = 0, interpolated_spawning: bool = False, sim_target: NiagaraSimTarget = NiagaraSimTarget.CPU_SIM, fixed_bounds: Box = [[0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], False], requires_persistent_i_ds: bool = False, max_gpu_particles_spawn_per_frame: int = 0, allocation_mode: ParticleAllocationMode = ParticleAllocationMode.AUTOMATIC_ESTIMATE) -> None:
        ...
    @property
    def local_space(self) -> bool:
        r"""
        (bool):  [Read-Write] Toggles whether or not the particles within this emitter are relative to the emitter origin or in global space.
        """
        ...
    @local_space.setter
    def local_space(self, value: bool) -> None:
        ...
    @property
    def determinism(self) -> bool:
        r"""
        (bool):  [Read-Write] Toggles whether to globally make the random number generator be deterministic or non-deterministic. Any random calculation that is set to the emitter defaults will inherit this value. It is still possible to tweak individual random to be deterministic or not. In this case deterministic means that it will return the same results for the same configuration of the emitter as long as delta time is not variable. Any changes to the emitter's individual scripts will adjust the results.
        """
        ...
    @determinism.setter
    def determinism(self, value: bool) -> None:
        ...
    @property
    def random_seed(self) -> int:
        r"""
        (int32):  [Read-Write] An emitter-based seed for the deterministic random number generator.
        """
        ...
    @random_seed.setter
    def random_seed(self, value: int) -> None:
        ...
    @property
    def interpolated_spawning(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled, this will spawn using interpolated parameter values and perform a partial update at spawn time. This adds significant additional cost for spawning but will produce much smoother spawning for high spawn rates, erratic frame rates and fast moving emitters.
        """
        ...
    @interpolated_spawning.setter
    def interpolated_spawning(self, value: bool) -> None:
        ...
    @property
    def sim_target(self) -> NiagaraSimTarget:
        r"""
        (NiagaraSimTarget):  [Read-Write]
        """
        ...
    @sim_target.setter
    def sim_target(self, value: NiagaraSimTarget) -> None:
        ...
    @property
    def fixed_bounds(self) -> Box:
        r"""
        (Box):  [Read-Write] The fixed bounding box value. CalculateBoundsMode is the condition whether the fixed bounds can be edited.
        Note: If this is greyed out it means fixed bounds are enabled in the System Properties and these bounds are therefore ignored.
        """
        ...
    @fixed_bounds.setter
    def fixed_bounds(self, value: Box) -> None:
        ...
    @property
    def requires_persistent_i_ds(self) -> bool:
        r"""
        (bool):  [Read-Write] Creates a stable Identifier (Particles.ID) which does not vary from frame to frame. This comes at a small memory and performance cost. This allows external objects to track the same particle over multiple frames. Particle arrays are tightly packed and a particle's actual index in the array may change from frame to frame. This optionally lets you use a lookup table to track a particle by index in the lookup table.
        """
        ...
    @requires_persistent_i_ds.setter
    def requires_persistent_i_ds(self, value: bool) -> None:
        ...
    @property
    def max_gpu_particles_spawn_per_frame(self) -> int:
        r"""
        (int32):  [Read-Write] An override on the max number of GPU particles we expect to spawn in a single frame. A value of 0 means it'll use fx.MaxNiagaraGPUParticlesSpawnPerFrame.
        """
        ...
    @max_gpu_particles_spawn_per_frame.setter
    def max_gpu_particles_spawn_per_frame(self, value: int) -> None:
        ...
    @property
    def allocation_mode(self) -> ParticleAllocationMode:
        r"""
        (ParticleAllocationMode):  [Read-Write] The emitter needs to allocate memory for the particles each tick.
        To prevent reallocations, the emitter should allocate as much memory as is needed for the max particle count.
        This setting controls if the allocation size should be automatically determined or manually entered.
        """
        ...
    @allocation_mode.setter
    def allocation_mode(self, value: ParticleAllocationMode) -> None:
        ...

class NiagaraModuleDependency(StructBase):
    r"""
    Niagara Module Dependency
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraScript.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``description`` (Text):  [Read-Write] Detailed description of the dependency
    - ``id`` (Name):  [Read-Write] Specifies the provided id of the required dependent module (e.g. 'ProvidesNormalizedAge')
    - ``only_evaluate_in_script_usage`` (int32):  [Read-Write] This property can limit where the dependency is evaluated. By default, the dependency is enforced in all script usages
    - ``required_version`` (str):  [Read-Write] Specifies the version constraint that module providing the dependency must fulfill.
      Example usages:
      '1.2' requires the exact version 1.2 of the source script
      '1.2+' requires at least version 1.2, but any higher version is also ok
      '1.2-2.0' requires any version between 1.2 and 2.0
    - ``script_constraint`` (NiagaraModuleDependencyScriptConstraint):  [Read-Write] Specifies constraints related to the source script a modules provides as dependency.
    - ``type`` (NiagaraModuleDependencyType):  [Read-Write] Whether the dependency belongs before or after this module
    """
    def __init__(self) -> None:
        ...

class NiagaraEmitterScriptProperties(StructBase):
    r"""
    Niagara Emitter Script Properties
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEmitter.h
    
    """
    def __init__(self) -> None:
        ...

class NiagaraPlatformSet(StructBase):
    r"""
    Niagara Platform Set
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPlatformSet.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``c_var_conditions`` (Array[NiagaraPlatformSetCVarCondition]):  [Read-Write] Set of CVars values we require for this platform set to be enabled. If any of the linked CVars don't have the required values then this platform set will not be enabled.
    - ``device_profile_states`` (Array[NiagaraDeviceProfileStateEntry]):  [Read-Write] States of specific device profiles we've set.
    - ``quality_level_mask`` (int32):  [Read-Write] Mask defining which effects qualities this set matches.
    """
    def __init__(self) -> None:
        ...

class NiagaraEmitterScalabilityOverrides(StructBase):
    r"""
    Container struct for an array of emitter scalability overrides. Enables details customization and data validation.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``overrides`` (Array[NiagaraEmitterScalabilityOverride]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraParameterStore(StructBase):
    r"""
    Base storage class for Niagara parameter values.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraParameterStore.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parameter_offsets`` (Map[NiagaraVariable, int32]):  [Read-Write] Map from parameter defs to their offset in the data table or the data interface. TODO: Separate out into a layout and instance class to reduce duplicated data for this?
      deprecated: Property 'ParameterOffsets' is deprecated.
    """
    def __init__(self) -> None:
        ...
    @property
    def parameter_offsets(self) -> Map[NiagaraVariable, int]:
        r"""
        (Map[NiagaraVariable, int32]):  [Read-Write] Map from parameter defs to their offset in the data table or the data interface. TODO: Separate out into a layout and instance class to reduce duplicated data for this?
        deprecated: Property 'ParameterOffsets' is deprecated.
        """
        ...
    @parameter_offsets.setter
    def parameter_offsets(self, value: Map[NiagaraVariable, int]) -> None:
        ...

class NiagaraEventScriptProperties(NiagaraEmitterScriptProperties):
    r"""
    Niagara Event Script Properties
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEmitter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execution_mode`` (ScriptExecutionMode):  [Read-Write] Controls which particles have the event script run on them.
    - ``max_events_per_frame`` (uint32):  [Read-Write] Controls how many events are consumed by this event handler. If there are more events generated than this value, they will be ignored.
    - ``min_spawn_number`` (uint32):  [Read-Write] The minimum spawn number when random spawn is used. Spawn Number is used as the maximum range.
    - ``random_spawn_number`` (bool):  [Read-Write] Whether using a random spawn number.
    - ``source_emitter_id`` (Guid):  [Read-Write] Id of the Emitter Handle that generated the event. If all zeroes, the event generator is assumed to be this emitter.
    - ``source_event_name`` (Name):  [Read-Write] The name of the event generated. This will be "Collision" for collision events and the Event Name field on the DataSetWrite node in the module graph for others.
    - ``spawn_number`` (uint32):  [Read-Write] Controls whether or not particles are spawned as a result of handling the event. Only valid for EScriptExecutionMode::SpawnedParticles. If Random Spawn Number is used, this will act as the maximum spawn range.
    - ``update_attribute_initial_values`` (bool):  [Read-Write] Should Event Spawn Scripts modify the Initial values for particle attributes they modify.
    """
    def __init__(self) -> None:
        ...

class NiagaraSimStageExecutionLoopEditorData(StructBase):
    r"""
    Niagara Sim Stage Execution Loop Editor Data
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSimStageExecutionData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write]
    - ``num_loops`` (int32):  [Read-Write]
    - ``num_loops_binding_name`` (Name):  [Read-Write]
    - ``stage_name_end`` (Name):  [Read-Write]
    - ``stage_name_start`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraVariableAttributeBinding(StructBase):
    r"""
    Niagara Variable Attribute Binding
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCommon.h
    
    """
    def __init__(self) -> None:
        ...

class NiagaraDeviceProfileStateEntry(StructBase):
    r"""
    Niagara Device Profile State Entry
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPlatformSet.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``profile_name`` (Name):  [Read-Write]
    - ``quality_level_mask`` (uint32):  [Read-Write] The state of each set quality level.
    - ``set_quality_level_mask`` (uint32):  [Read-Write] Which Effects Qualities are set.
    """
    def __init__(self) -> None:
        ...

class NiagaraPlatformSetCVarCondition(StructBase):
    r"""
    Imposes a condition that a CVar must contain a set value or range of values for a platform set to be enabled.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPlatformSet.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``c_var_name`` (Name):  [Read-Write] The name of the CVar we're testing the value of.
    - ``fail_response`` (NiagaraCVarConditionResponse):  [Read-Write] If this CVar condition fails, how should this affect the state of the Platform Set?
    - ``max_float`` (float):  [Read-Write] If the value of the CVar is greater than this maximum then the PlatformSet will not be enabled.
    - ``max_int`` (int32):  [Read-Write] If the value of the CVar is greater than this maximum then the PlatformSet will not be enabled.
    - ``min_float`` (float):  [Read-Write] If the value of the CVar is less than this minimum then the PlatformSet will not be enabled.
    - ``min_int`` (int32):  [Read-Write] If the value of the CVar is less than this minimum then the PlatformSet will not be enabled.
    - ``pass_response`` (NiagaraCVarConditionResponse):  [Read-Write] If this CVar condition passes, how should this affect the state of the Platform Set?
    - ``use_max_float`` (bool):  [Read-Write] True if we should apply the maximum restriction for float CVars.
    - ``use_max_int`` (bool):  [Read-Write] True if we should apply the maximum restriction for int CVars.
    - ``use_min_float`` (bool):  [Read-Write] True if we should apply the minimum restriction for float CVars.
    - ``use_min_int`` (bool):  [Read-Write] True if we should apply the minimum restriction for int CVars.
    - ``value`` (bool):  [Read-Write] The value this CVar must contain for this platform set to be enabled.
    """
    def __init__(self) -> None:
        ...

class NiagaraEmitterScalabilitySettings(StructBase):
    r"""
    Scalability settings for Niagara Emitters on a particular platform set.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``platforms`` (NiagaraPlatformSet):  [Read-Write] The platforms on which these settings are active (unless overridden).
    - ``scale_spawn_count`` (bool):  [Read-Write] Enable spawn count scaling
    - ``spawn_count_scale`` (float):  [Read-Write] Scale factor applied to spawn counts for this emitter.
    """
    def __init__(self) -> None:
        ...

class NiagaraEmitterScalabilityOverride(NiagaraEmitterScalabilitySettings):
    r"""
    Niagara Emitter Scalability Override
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``override_spawn_count_scale`` (bool):  [Read-Write] Controls whether spawn count scale should be overridden.
    - ``platforms`` (NiagaraPlatformSet):  [Read-Write] The platforms on which these settings are active (unless overridden).
    - ``scale_spawn_count`` (bool):  [Read-Write] Enable spawn count scaling
    - ``spawn_count_scale`` (float):  [Read-Write] Scale factor applied to spawn counts for this emitter.
    """
    def __init__(self) -> None:
        ...

class NiagaraVariableBase(StructBase):
    r"""
    Niagara Variable Base
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``type_def`` (NiagaraTypeDefinition):  [Read-Write]
      deprecated: Property 'TypeDef' is deprecated.
    - ``type_def_handle`` (NiagaraTypeDefinitionHandle):  [Read-Write]
    """
    def __init__(self) -> None:
        ...
    @property
    def type_def(self) -> NiagaraTypeDefinition:
        r"""
        (NiagaraTypeDefinition):  [Read-Write]
        deprecated: Property 'TypeDef' is deprecated.
        """
        ...
    @type_def.setter
    def type_def(self, value: NiagaraTypeDefinition) -> None:
        ...

class NiagaraVariable(NiagaraVariableBase):
    r"""
    Niagara Variable
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``type_def`` (NiagaraTypeDefinition):  [Read-Write]
      deprecated: Property 'TypeDef' is deprecated.
    - ``type_def_handle`` (NiagaraTypeDefinitionHandle):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraTypeDefinitionHandle(StructBase):
    r"""
    Niagara Type Definition Handle
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraTypes.h
    
    """
    def __init__(self) -> None:
        ...

class NiagaraTypeDefinition(StructBase):
    r"""
    Niagara Type Definition
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``class_struct_or_enum`` (Object):  [Read-Write] Underlying type for this variable, use FUnderlyingType to determine type without casting
      This can be a UClass, UStruct or UEnum.  Pointing to something like the struct for an FVector, etc.
      In occasional situations this may be a UClass when we're dealing with DataInterface etc.
    - ``flags`` (uint8):  [Read-Write]
    - ``underlying_type`` (uint16):  [Read-Write] See enumeration FUnderlyingType for possible values
    """
    def __init__(self) -> None:
        ...

class NiagaraSimCacheCaptureParameters(StructBase):
    r"""
    Niagara Sim Cache Capture Parameters
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSimCacheCapture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``append_to_sim_cache`` (bool):  [Read-Write] When enabled we will append to the existing simulation cache rather than destroying the existing contents.
    - ``capture_all_frames_immediatly`` (bool):  [Read-Write] When enabled we will capture all the requested frames immediatly.
      This will capture the simulation outside of the main work tick, i.e. if you request a 10 frame capture we will loop capturing 10 frames on the capture call rather than over 10 world ticks.
    - ``capture_fixed_number_of_frames`` (bool):  [Read-Write] When enabled we capture NumFrames number of frames, otherwise the capture will continue until cancelled or the simulation is complete.
    - ``capture_rate`` (int32):  [Read-Write] Allows for reducing the frequency of captured frames in relation to the simulation's frames. The ratio is 1 / CaptureRate, so a CaptureRate of 2 would captures frames 0, 2, 4, etc.
    - ``immediate_capture_delta_time`` (float):  [Read-Write] The delta time in seconds to use when manually advancing the simulation.Defaults to 1 / 60th of a second(0.01666).
    - ``num_frames`` (int32):  [Read-Write] The max number of frames to capture. The capture will stop when the simulation completes or we have rendered this many frames, whichever happens first.
      Set to 0 to capture until simulation completes.
    - ``timeout_frame_count`` (int32):  [Read-Write] When we fail to capture a new frame after this many frames the capture will complete automatically.
    - ``use_timeout`` (bool):  [Read-Write] When enabled the capture will time out if we reach the defined number of frames without anything new to capture.
    """
    def __init__(self, append_to_sim_cache: bool = False, capture_fixed_number_of_frames: bool = False, num_frames: int = 0, capture_rate: int = 0, use_timeout: bool = False, timeout_frame_count: int = 0, capture_all_frames_immediatly: bool = False, immediate_capture_delta_time: float = 0.000000) -> None:
        ...
    @property
    def append_to_sim_cache(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled we will append to the existing simulation cache rather than destroying the existing contents.
        """
        ...
    @append_to_sim_cache.setter
    def append_to_sim_cache(self, value: bool) -> None:
        ...
    @property
    def capture_fixed_number_of_frames(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled we capture NumFrames number of frames, otherwise the capture will continue until cancelled or the simulation is complete.
        """
        ...
    @capture_fixed_number_of_frames.setter
    def capture_fixed_number_of_frames(self, value: bool) -> None:
        ...
    @property
    def num_frames(self) -> int:
        r"""
        (int32):  [Read-Write] The max number of frames to capture. The capture will stop when the simulation completes or we have rendered this many frames, whichever happens first.
        Set to 0 to capture until simulation completes.
        """
        ...
    @num_frames.setter
    def num_frames(self, value: int) -> None:
        ...
    @property
    def capture_rate(self) -> int:
        r"""
        (int32):  [Read-Write] Allows for reducing the frequency of captured frames in relation to the simulation's frames. The ratio is 1 / CaptureRate, so a CaptureRate of 2 would captures frames 0, 2, 4, etc.
        """
        ...
    @capture_rate.setter
    def capture_rate(self, value: int) -> None:
        ...
    @property
    def use_timeout(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled the capture will time out if we reach the defined number of frames without anything new to capture.
        """
        ...
    @use_timeout.setter
    def use_timeout(self, value: bool) -> None:
        ...
    @property
    def timeout_frame_count(self) -> int:
        r"""
        (int32):  [Read-Write] When we fail to capture a new frame after this many frames the capture will complete automatically.
        """
        ...
    @timeout_frame_count.setter
    def timeout_frame_count(self, value: int) -> None:
        ...
    @property
    def capture_all_frames_immediatly(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled we will capture all the requested frames immediatly.
        This will capture the simulation outside of the main work tick, i.e. if you request a 10 frame capture we will loop capturing 10 frames on the capture call rather than over 10 world ticks.
        """
        ...
    @capture_all_frames_immediatly.setter
    def capture_all_frames_immediatly(self, value: bool) -> None:
        ...
    @property
    def immediate_capture_delta_time(self) -> float:
        r"""
        (float):  [Read-Write] The delta time in seconds to use when manually advancing the simulation.Defaults to 1 / 60th of a second(0.01666).
        """
        ...
    @immediate_capture_delta_time.setter
    def immediate_capture_delta_time(self, value: float) -> None:
        ...

class NiagaraSimCacheCreateParameters(StructBase):
    r"""
    Niagara Sim Cache Create Parameters
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSimCache.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_data_interface_caching`` (bool):  [Read-Write] When enabled Data Interface data will be stored in the SimCache.
      This can result in a large increase to the cache size, depending on what Data Interfaces are used
    - ``allow_interpolation`` (bool):  [Read-Write] When enabled we allow the cache to be generated for interpolation.
      This will increase the memory usage for the cache slightly but can allow you to reduce the capture rate.
      By default we will capture and interpolate all Position & Quat types, you can adjust this using the include / exclude list.
    - ``allow_rebasing`` (bool):  [Read-Write] When enabled allows the SimCache to be re-based.
      i.e. World space emitters can be moved to the new component's location
    - ``allow_serialize_large_cache`` (bool):  [Read-Write] When enabled the cache will support serializing large amounts of cache data.
    - ``allow_velocity_extrapolation`` (bool):  [Read-Write] When enabled we allow the cache to be generated for extrapolation.
      This will force the velocity attribute to be maintained.
    - ``attribute_capture_mode`` (NiagaraSimCacheAttributeCaptureMode):  [Read-Write] How do we want to capture attributes for the simulation cache.
      The mode selected depends on what situations the cache can be used in.
    - ``explicit_capture_attributes`` (Array[Name]):  [Read-Write] List of attributes to capture when the capture attribute capture mode is set to explicit.
      For example, adding MyEmitter.Particles.Position will only gather that attribute inside the cache.
    - ``interpolation_exclude_attributes`` (Array[Name]):  [Read-Write] List of specific Attributes to exclude interpolation for.  They must be types that are supported for interpolation.
      For example, MyEmitter.Particles.MyPosition would force MyPosition to be interpolated.
    - ``interpolation_include_attributes`` (Array[Name]):  [Read-Write] List of specific Attributes to include when using interpolation.  They must be types that are supported for interpolation.
      For example, MyEmitter.Particles.MyPosition would force MyPosition to be interpolated.
    - ``rebase_exclude_attributes`` (Array[Name]):  [Read-Write] List of Attributes to force exclude from the SimCache rebase, they should be the full path to the attribute
      For example, MyEmitter.Particles.MyQuat would force the particle attribute MyQuat to be included for MyEmitter
    - ``rebase_include_attributes`` (Array[Name]):  [Read-Write] List of Attributes to force include in the SimCache rebase, they should be the full path to the attribute
      For example, MyEmitter.Particles.MyQuat would force the particle attribute MyQuat to be included for MyEmitter
    """
    def __init__(self, attribute_capture_mode: NiagaraSimCacheAttributeCaptureMode = NiagaraSimCacheAttributeCaptureMode.ALL, allow_rebasing: bool = False, allow_data_interface_caching: bool = False, allow_interpolation: bool = False, allow_velocity_extrapolation: bool = False, allow_serialize_large_cache: bool = False, rebase_include_attributes: Array[Name] = [], rebase_exclude_attributes: Array[Name] = [], interpolation_include_attributes: Array[Name] = [], interpolation_exclude_attributes: Array[Name] = [], explicit_capture_attributes: Array[Name] = []) -> None:
        ...
    @property
    def attribute_capture_mode(self) -> NiagaraSimCacheAttributeCaptureMode:
        r"""
        (NiagaraSimCacheAttributeCaptureMode):  [Read-Write] How do we want to capture attributes for the simulation cache.
        The mode selected depends on what situations the cache can be used in.
        """
        ...
    @attribute_capture_mode.setter
    def attribute_capture_mode(self, value: NiagaraSimCacheAttributeCaptureMode) -> None:
        ...
    @property
    def allow_rebasing(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled allows the SimCache to be re-based.
        i.e. World space emitters can be moved to the new component's location
        """
        ...
    @allow_rebasing.setter
    def allow_rebasing(self, value: bool) -> None:
        ...
    @property
    def allow_data_interface_caching(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled Data Interface data will be stored in the SimCache.
        This can result in a large increase to the cache size, depending on what Data Interfaces are used
        """
        ...
    @allow_data_interface_caching.setter
    def allow_data_interface_caching(self, value: bool) -> None:
        ...
    @property
    def allow_interpolation(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled we allow the cache to be generated for interpolation.
        This will increase the memory usage for the cache slightly but can allow you to reduce the capture rate.
        By default we will capture and interpolate all Position & Quat types, you can adjust this using the include / exclude list.
        """
        ...
    @allow_interpolation.setter
    def allow_interpolation(self, value: bool) -> None:
        ...
    @property
    def allow_velocity_extrapolation(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled we allow the cache to be generated for extrapolation.
        This will force the velocity attribute to be maintained.
        """
        ...
    @allow_velocity_extrapolation.setter
    def allow_velocity_extrapolation(self, value: bool) -> None:
        ...
    @property
    def allow_serialize_large_cache(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled the cache will support serializing large amounts of cache data.
        """
        ...
    @allow_serialize_large_cache.setter
    def allow_serialize_large_cache(self, value: bool) -> None:
        ...
    @property
    def rebase_include_attributes(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] List of Attributes to force include in the SimCache rebase, they should be the full path to the attribute
        For example, MyEmitter.Particles.MyQuat would force the particle attribute MyQuat to be included for MyEmitter
        """
        ...
    @rebase_include_attributes.setter
    def rebase_include_attributes(self, value: Array[Name]) -> None:
        ...
    @property
    def rebase_exclude_attributes(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] List of Attributes to force exclude from the SimCache rebase, they should be the full path to the attribute
        For example, MyEmitter.Particles.MyQuat would force the particle attribute MyQuat to be included for MyEmitter
        """
        ...
    @rebase_exclude_attributes.setter
    def rebase_exclude_attributes(self, value: Array[Name]) -> None:
        ...
    @property
    def interpolation_include_attributes(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] List of specific Attributes to include when using interpolation.  They must be types that are supported for interpolation.
        For example, MyEmitter.Particles.MyPosition would force MyPosition to be interpolated.
        """
        ...
    @interpolation_include_attributes.setter
    def interpolation_include_attributes(self, value: Array[Name]) -> None:
        ...
    @property
    def interpolation_exclude_attributes(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] List of specific Attributes to exclude interpolation for.  They must be types that are supported for interpolation.
        For example, MyEmitter.Particles.MyPosition would force MyPosition to be interpolated.
        """
        ...
    @interpolation_exclude_attributes.setter
    def interpolation_exclude_attributes(self, value: Array[Name]) -> None:
        ...
    @property
    def explicit_capture_attributes(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] List of attributes to capture when the capture attribute capture mode is set to explicit.
        For example, adding MyEmitter.Particles.Position will only gather that attribute inside the cache.
        """
        ...
    @explicit_capture_attributes.setter
    def explicit_capture_attributes(self, value: Array[Name]) -> None:
        ...

class NiagaraDataChannelVariable(NiagaraVariableBase):
    r"""
    Niagara Data Channel Variable
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataChannelPublic.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write]
    - ``type_def`` (NiagaraTypeDefinition):  [Read-Write]
      deprecated: Property 'TypeDef' is deprecated.
    - ``type_def_handle`` (NiagaraTypeDefinitionHandle):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraDataChannelSearchParameters(StructBase):
    r"""
    Parameters used when retrieving a specific set of Data Channel Data to read or write.
    Many Data Channel types will have multiple internal sets of data and these parameters control which the Channel should return to users for access.
    An example of this would be the Islands Data Channel type which will subdivide the world and have a different set of data for each sub division.
    It will return to users the correct data for their location based on these parameters.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataChannelPublic.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``location`` (Vector):  [Read-Write] In cases where there is no owning component for data being read or written to a data channel, we simply pass in a location. We can also use this when bOverrideLocaiton is set.
    - ``override_location`` (bool):  [Read-Write] If true, even if an owning component is set, the data channel should use the Location value rather than the component location. If this is false, the NDC will get any location needed from the owning component.
    - ``owning_component`` (SceneComponent):  [Read-Write] In cases where there is an owning component such as an object spawning from itself etc, then we pass that component in. Some handlers may only use it's location but others may make use of more data.
    """
    def __init__(self, owning_component: SceneComponent = None, location: Vector = [0.000000, 0.000000, 0.000000], override_location: bool = False) -> None:
        ...
    @property
    def owning_component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Write] In cases where there is an owning component such as an object spawning from itself etc, then we pass that component in. Some handlers may only use it's location but others may make use of more data.
        """
        ...
    @owning_component.setter
    def owning_component(self, value: SceneComponent) -> None:
        ...
    @property
    def location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] In cases where there is no owning component for data being read or written to a data channel, we simply pass in a location. We can also use this when bOverrideLocaiton is set.
        """
        ...
    @location.setter
    def location(self, value: Vector) -> None:
        ...
    @property
    def override_location(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, even if an owning component is set, the data channel should use the Location value rather than the component location. If this is false, the NDC will get any location needed from the owning component.
        """
        ...
    @override_location.setter
    def override_location(self, value: bool) -> None:
        ...

class BasicParticleData(StructBase):
    r"""
    Basic Particle Data
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceExport.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``position`` (Vector):  [Read-Write]
    - ``size`` (float):  [Read-Write]
    - ``velocity`` (Vector):  [Read-Write]
    """
    def __init__(self, position: Vector = [0.000000, 0.000000, 0.000000], size: float = 0.000000, velocity: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def size(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class NiagaraPerfBaselineStats(StructBase):
    r"""
    Niagara Perf Baseline Stats
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPerfBaseline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``per_instance_avg_gt`` (float):  [Read-Write] Per instance average time spent on the GameThread (µs).
    - ``per_instance_avg_rt`` (float):  [Read-Write] Per instance average time spent on the RenderThread (µs).
    - ``per_instance_max_gt`` (float):  [Read-Write] Per instance max time spent on the GameThread (µs).
    - ``per_instance_max_rt`` (float):  [Read-Write] Per instance max time spent on the RenderThread (µs).
    """
    def __init__(self, per_instance_avg_gt: float = 0.000000, per_instance_avg_rt: float = 0.000000, per_instance_max_gt: float = 0.000000, per_instance_max_rt: float = 0.000000) -> None:
        ...
    @property
    def per_instance_avg_gt(self) -> float:
        r"""
        (float):  [Read-Write] Per instance average time spent on the GameThread (µs).
        """
        ...
    @per_instance_avg_gt.setter
    def per_instance_avg_gt(self, value: float) -> None:
        ...
    @property
    def per_instance_avg_rt(self) -> float:
        r"""
        (float):  [Read-Write] Per instance average time spent on the RenderThread (µs).
        """
        ...
    @per_instance_avg_rt.setter
    def per_instance_avg_rt(self, value: float) -> None:
        ...
    @property
    def per_instance_max_gt(self) -> float:
        r"""
        (float):  [Read-Write] Per instance max time spent on the GameThread (µs).
        """
        ...
    @per_instance_max_gt.setter
    def per_instance_max_gt(self, value: float) -> None:
        ...
    @property
    def per_instance_max_rt(self) -> float:
        r"""
        (float):  [Read-Write] Per instance max time spent on the RenderThread (µs).
        """
        ...
    @per_instance_max_rt.setter
    def per_instance_max_rt(self, value: float) -> None:
        ...

class NiagaraPosition(Vector3f):
    r"""
    Niagara Position
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (float):  [Read-Write]
    - ``y`` (float):  [Read-Write]
    - ``z`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraSpawnInfo(StructBase):
    r"""
    Data controlling the spawning of particles
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``count`` (int32):  [Read-Write] How many particles to spawn.
    - ``interp_start_dt`` (float):  [Read-Write] The sub frame delta time at which to spawn the first particle.
    - ``interval_dt`` (float):  [Read-Write] The sub frame delta time between each particle.
    - ``spawn_group`` (int32):  [Read-Write] An integer used to identify this spawn info.
      Typically this is unused.
      An example usage is when using multiple spawn modules to spawn from multiple discreet locations.
    """
    def __init__(self, count: int = 0, interp_start_dt: float = 0.000000, interval_dt: float = 0.000000, spawn_group: int = 0) -> None:
        ...
    @property
    def count(self) -> int:
        r"""
        (int32):  [Read-Write] How many particles to spawn.
        """
        ...
    @count.setter
    def count(self, value: int) -> None:
        ...
    @property
    def interp_start_dt(self) -> float:
        r"""
        (float):  [Read-Write] The sub frame delta time at which to spawn the first particle.
        """
        ...
    @interp_start_dt.setter
    def interp_start_dt(self, value: float) -> None:
        ...
    @property
    def interval_dt(self) -> float:
        r"""
        (float):  [Read-Write] The sub frame delta time between each particle.
        """
        ...
    @interval_dt.setter
    def interval_dt(self, value: float) -> None:
        ...
    @property
    def spawn_group(self) -> int:
        r"""
        (int32):  [Read-Write] An integer used to identify this spawn info.
        Typically this is unused.
        An example usage is when using multiple spawn modules to spawn from multiple discreet locations.
        """
        ...
    @spawn_group.setter
    def spawn_group(self, value: int) -> None:
        ...

class NiagaraID(StructBase):
    r"""
    Niagara ID
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``acquire_tag`` (int32):  [Read-Write] A unique tag for when this ID was acquired.
      Allows us to differentiate between particles when one dies and another reuses it's Index.
    - ``index`` (int32):  [Read-Write] Index in the indirection table for this particle. Allows fast access to this particles data.
      Is always unique among currently living particles but will be reused after the particle dies.
    """
    def __init__(self, index: int = 0, acquire_tag: int = 0) -> None:
        ...
    @property
    def index(self) -> int:
        r"""
        (int32):  [Read-Write] Index in the indirection table for this particle. Allows fast access to this particles data.
        Is always unique among currently living particles but will be reused after the particle dies.
        """
        ...
    @index.setter
    def index(self, value: int) -> None:
        ...
    @property
    def acquire_tag(self) -> int:
        r"""
        (int32):  [Read-Write] A unique tag for when this ID was acquired.
        Allows us to differentiate between particles when one dies and another reuses it's Index.
        """
        ...
    @acquire_tag.setter
    def acquire_tag(self, value: int) -> None:
        ...

class NiagaraPlatformSetRedirect(StructBase):
    r"""
    Allows us to replace a specific device profile usage condition in all NiagaraPlatformSets.
    Helpful when dealing with changes to device profile structure.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPlatformSet.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``c_var_condition_disabled`` (NiagaraPlatformSetCVarCondition):  [Read-Write] When in CVar mode, the CVar condition to replace this device profile entry with when the profile entry is in the Disabled state.
    - ``c_var_condition_enabled`` (NiagaraPlatformSetCVarCondition):  [Read-Write] When in CVar mode, the CVar condition to replace this device profile entry with when the profile entry is in the Enabled state.
    - ``mode`` (NiagaraDeviceProfileRedirectMode):  [Read-Write]
    - ``profile_names`` (Array[Name]):  [Read-Write] The names of any device profile entry that will apply this redirect.
    - ``redirect_profile_name`` (Name):  [Read-Write] When in Device Profile mode, the name of the device profile to redirect to.
    """
    def __init__(self) -> None:
        ...

class NiagaraUserParameterBinding(StructBase):
    r"""
    Niagara User Parameter Binding
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCommon.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``parameter`` (NiagaraVariable):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NDIStaticMeshSectionFilter(StructBase):
    r"""
    NDIStatic Mesh Section Filter
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceStaticMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allowed_material_slots`` (Array[int32]):  [Read-Write] Only allow sections these material slots.
    """
    def __init__(self) -> None:
        ...

class NiagaraUObjectPropertyReaderRemap(StructBase):
    r"""
    Niagara UObject Property Reader Remap
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceUObjectPropertyReader.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``graph_name`` (Name):  [Read-Write]
    - ``remap_name`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraVariant(StructBase):
    r"""
    Niagara Variant
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraVariant.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bytes`` (Array[uint8]):  [Read-Write]
    - ``current_mode`` (NiagaraVariantMode):  [Read-Write]
    - ``data_interface`` (NiagaraDataInterface):  [Read-Write]
    - ``object`` (Object):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraCulledComponentInfo(StructBase):
    r"""
    Info on a culled Niagara Component for use by it's cull proxy.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCullProxyComponent.h
    
    """
    def __init__(self) -> None:
        ...

class NiagaraRendererMaterialParameters(StructBase):
    r"""
    Parameters to apply to the material, these are both constant and dynamic bindings
    Having any bindings set will cause a MID to be generated
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraRendererProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attribute_bindings`` (Array[NiagaraMaterialAttributeBinding]):  [Read-Write]
    - ``scalar_parameters`` (Array[NiagaraRendererMaterialScalarParameter]):  [Read-Write]
    - ``static_bool_parameters`` (Array[NiagaraRendererMaterialStaticBoolParameter]):  [Read-Write]
    - ``texture_parameters`` (Array[NiagaraRendererMaterialTextureParameter]):  [Read-Write]
    - ``vector_parameters`` (Array[NiagaraRendererMaterialVectorParameter]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraSystemScalabilityOverrides(StructBase):
    r"""
    Container struct for an array of system scalability overrides. Enables details customization and data validation.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``overrides`` (Array[NiagaraSystemScalabilityOverride]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraSystemScalabilitySettingsArray(StructBase):
    r"""
    Container struct for an array of system scalability settings. Enables details customization and data validation.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (Array[NiagaraSystemScalabilitySettings]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraEmitterScalabilitySettingsArray(StructBase):
    r"""
    Container struct for an array of emitter scalability settings. Enables details customization and data validation.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (Array[NiagaraEmitterScalabilitySettings]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraMaterialAttributeBinding(StructBase):
    r"""
    Niagara Material Attribute Binding
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCommon.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``material_parameter_name`` (Name):  [Read-Write]
    - ``niagara_child_variable`` (NiagaraVariableBase):  [Read-Write]
    - ``niagara_variable`` (NiagaraVariableBase):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraRendererMaterialScalarParameter(StructBase):
    r"""
    Niagara Renderer Material Scalar Parameter
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraRendererProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``material_parameter_name`` (Name):  [Read-Write]
    - ``value`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraRendererMaterialVectorParameter(StructBase):
    r"""
    Niagara Renderer Material Vector Parameter
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraRendererProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``material_parameter_name`` (Name):  [Read-Write]
    - ``value`` (LinearColor):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraRendererMaterialTextureParameter(StructBase):
    r"""
    Niagara Renderer Material Texture Parameter
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraRendererProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``material_parameter_name`` (Name):  [Read-Write]
    - ``texture`` (Texture):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraRendererMaterialStaticBoolParameter(StructBase):
    r"""
    Niagara Renderer Material Static Bool Parameter
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraRendererProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``material_parameter_name`` (Name):  [Read-Write]
    - ``static_variable_name`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class NiagaraSystemScalabilitySettings(StructBase):
    r"""
    Scalability settings for Niagara Systems for a particular platform set (unless overridden).
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``budget_scaling`` (NiagaraGlobalBudgetScaling):  [Read-Write] Settings related to scaling down FX based on the current budget usage.
    - ``cull_by_distance`` (bool):  [Read-Write] Controls whether distance culling is enabled.
    - ``cull_max_instance_count`` (bool):  [Read-Write] Controls whether we should cull systems based on how many instances with the same Effect Type are active.
    - ``cull_per_system_max_instance_count`` (bool):  [Read-Write] Controls whether we should cull systems based on how many instances of the system are active.
    - ``cull_proxy_mode`` (NiagaraCullProxyMode):  [Read-Write] Controls what, if any, proxy will be used in place of culled systems.
    - ``max_distance`` (float):  [Read-Write] Effects of this type are culled beyond this distance.
    - ``max_instances`` (int32):  [Read-Write] Effects of this type will be culled when total active instances using this same EffectType exceeds this number.
      If the effect type has a significance handler, instances are sorted by their significance and only the N most significant will be kept. The rest are culled.
      If it does not have a significance handler, instance count culling will be applied at spawn time only. New FX that would exceed the counts are not spawned/activated.
    - ``max_system_instances`` (int32):  [Read-Write] Effects of this type will be culled when total active instances of the same NiagaraSystem exceeds this number.
      If the effect type has a significance handler, instances are sorted by their significance and only the N most significant will be kept. The rest are culled.
      If it does not have a significance handler, instance count culling will be applied at spawn time only. New FX that would exceed the counts are not spawned/activated.
    - ``max_system_proxies`` (int32):  [Read-Write] Limit on the number of proxies that can be used at once per system.
      While much cheaper than full FX instances, proxies still incur some cost so must have a limit.
      When significance information is available using a significance handler, the most significance proxies will be kept up to this limit.
    - ``platforms`` (NiagaraPlatformSet):  [Read-Write] The platforms on which these settings are active (unless overridden).
    - ``visibility_culling`` (NiagaraSystemVisibilityCullingSettings):  [Read-Write] Settings controlling how systems are culled by visibility.
    """
    def __init__(self) -> None:
        ...

class NiagaraScalabilitySettings(NiagaraSystemScalabilitySettings):
    r"""
    deprecated: 'NiagaraScalabilitySettings' was renamed to 'NiagaraSystemScalabilitySettings'.
    """
    def __init__(self) -> None:
        ...

class NiagaraSystemScalabilityOverride(NiagaraSystemScalabilitySettings):
    r"""
    Niagara System Scalability Override
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``budget_scaling`` (NiagaraGlobalBudgetScaling):  [Read-Write] Settings related to scaling down FX based on the current budget usage.
    - ``cull_by_distance`` (bool):  [Read-Write] Controls whether distance culling is enabled.
    - ``cull_max_instance_count`` (bool):  [Read-Write] Controls whether we should cull systems based on how many instances with the same Effect Type are active.
    - ``cull_per_system_max_instance_count`` (bool):  [Read-Write] Controls whether we should cull systems based on how many instances of the system are active.
    - ``cull_proxy_mode`` (NiagaraCullProxyMode):  [Read-Write] Controls what, if any, proxy will be used in place of culled systems.
    - ``max_distance`` (float):  [Read-Write] Effects of this type are culled beyond this distance.
    - ``max_instances`` (int32):  [Read-Write] Effects of this type will be culled when total active instances using this same EffectType exceeds this number.
      If the effect type has a significance handler, instances are sorted by their significance and only the N most significant will be kept. The rest are culled.
      If it does not have a significance handler, instance count culling will be applied at spawn time only. New FX that would exceed the counts are not spawned/activated.
    - ``max_system_instances`` (int32):  [Read-Write] Effects of this type will be culled when total active instances of the same NiagaraSystem exceeds this number.
      If the effect type has a significance handler, instances are sorted by their significance and only the N most significant will be kept. The rest are culled.
      If it does not have a significance handler, instance count culling will be applied at spawn time only. New FX that would exceed the counts are not spawned/activated.
    - ``max_system_proxies`` (int32):  [Read-Write] Limit on the number of proxies that can be used at once per system.
      While much cheaper than full FX instances, proxies still incur some cost so must have a limit.
      When significance information is available using a significance handler, the most significance proxies will be kept up to this limit.
    - ``override_cull_proxy_settings`` (bool):  [Read-Write] Controls whether we override the cull proxy settings.
    - ``override_distance_settings`` (bool):  [Read-Write] Controls whether we override the distance culling settings.
    - ``override_global_budget_scaling_settings`` (bool):  [Read-Write] Controls whether we override the global budget scaling settings.
    - ``override_instance_count_settings`` (bool):  [Read-Write] Controls whether we override the instance count culling settings.
    - ``override_per_system_instance_count_settings`` (bool):  [Read-Write] Controls whether we override the per system instance count culling settings.
    - ``override_visibility_settings`` (bool):  [Read-Write] Controls whether we override the visibility culling settings.
    - ``platforms`` (NiagaraPlatformSet):  [Read-Write] The platforms on which these settings are active (unless overridden).
    - ``visibility_culling`` (NiagaraSystemVisibilityCullingSettings):  [Read-Write] Settings controlling how systems are culled by visibility.
    """
    def __init__(self) -> None:
        ...

class NiagaraScalabilityOverrides(NiagaraSystemScalabilityOverride):
    r"""
    deprecated: 'NiagaraScalabilityOverrides' was renamed to 'NiagaraSystemScalabilityOverride'.
    """
    def __init__(self) -> None:
        ...

class NiagaraSystemVisibilityCullingSettings(StructBase):
    r"""
    Scalability settings for Niagara Systems for a particular platform set (unless overridden).
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_pre_culling_by_view_frustum`` (bool):  [Read-Write] If true and bCullByViewFrustum is enabled, we allow view frustum checks in pre-culling. Meaning we can cull off screen systems before they even spawn.
    - ``cull_by_view_frustum`` (bool):  [Read-Write] Controls whether view frustum culling is enabled. Niagara can do it's own separate view frustum culling to give coarse visibility culling that does not depend directly on rendering like CullWhenNotRendered.
      This requires fixed bounds to be used in pre-culling.
    - ``cull_when_not_rendered`` (bool):  [Read-Write] Controls whether we cull when not rendered. This includes all reasons for being not rendered such as view frustum, occlusion and hidden flags etc. As this requires feedback form the rendering system, it cannot be used for pre-culling.
    - ``max_time_outside_view_frustum`` (float):  [Read-Write] Effects will be culled if they go longer than this time outside the view frustum.
    - ``max_time_without_render`` (float):  [Read-Write] Effects will be culled if they go longer than this time without being rendered.
    """
    def __init__(self) -> None:
        ...

class NiagaraGlobalBudgetScaling(StructBase):
    r"""
    Niagara Global Budget Scaling
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cull_by_global_budget`` (bool):  [Read-Write] Controls whether global budget based culling is enabled.
    - ``max_distance_scale_by_global_budget_use`` (NiagaraLinearRamp):  [Read-Write] When enabled, MaxDistance is scaled down by the global budget use based on this curve. Allows us to cull more aggressively when performance is poor.
    - ``max_global_budget_usage`` (float):  [Read-Write] Effects will be culled if the global budget usage exceeds this fraction. A global budget usage of 1.0 means current global FX workload has reached it's max budget. Budgets are set by CVars under FX.Budget...
    - ``max_instance_count_scale_by_global_budget_use`` (NiagaraLinearRamp):  [Read-Write] When enabled, Max Effect Type Instances is scaled down by the global budget use based on this curve. Allows us to cull more aggressively when performance is poor.
    - ``max_system_instance_count_scale_by_global_budget_use`` (NiagaraLinearRamp):  [Read-Write] When enabled, Max System Instances is scaled down by the global budget use based on this curve. Allows us to cull more aggressively when performance is poor.
    - ``scale_max_distance_by_global_budget_use`` (bool):  [Read-Write] Controls whether we scale down the MaxDistance based on the global budget use. Allows us to increase aggression of culling when performance is poor.
    - ``scale_max_instance_count_by_global_budget_use`` (bool):  [Read-Write] Controls whether we scale down the system instance counts by global budget usage. Allows us to increase aggression of culling when performance is poor.
    - ``scale_system_instance_count_by_global_budget_use`` (bool):  [Read-Write] Controls whether we scale down the effect type instance counts by global budget usage. Allows us to increase aggression of culling when performance is poor.
    """
    def __init__(self) -> None:
        ...

class NiagaraLinearRamp(StructBase):
    r"""
    Simple linear ramp to drive scaling values.
    TODO: Replace with Curve that can baked down for fast eval and has good inline UI widgets.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_x`` (float):  [Read-Write]
    - ``end_y`` (float):  [Read-Write]
    - ``start_x`` (float):  [Read-Write]
    - ``start_y`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class CurveParameterPair(StructBase):
    r"""
    Curve Parameter Pair
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraAnimNotifies
    - **File**: AnimNotifyState_TimedNiagaraEffect.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_curve_name`` (Name):  [Read-Write] Name of the curve in this montage.
    - ``user_variable_name`` (Name):  [Read-Write] Name of the Niagara user float variable.
    """
    def __init__(self, anim_curve_name: Name = "None", user_variable_name: Name = "None") -> None:
        ...
    @property
    def anim_curve_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of the curve in this montage.
        """
        ...
    @property
    def user_variable_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of the Niagara user float variable.
        """
        ...

class MovieSceneNiagaraCacheParams(MovieSceneBaseCacheParams):
    r"""
    Movie Scene Niagara Cache Params
    
    **C++ Source:**
    
    - **Plugin**: NiagaraSimCaching
    - **Module**: NiagaraSimCaching
    - **File**: MovieSceneNiagaraCacheSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cache_parameters`` (NiagaraSimCacheCreateParameters):  [Read-Write]
    - ``cache_replay_play_mode`` (NiagaraSimCacheSectionPlayMode):  [Read-Write] What should the effect do when the track has no cache data to display
    - ``end_frame_offset`` (FrameNumber):  [Read-Write] The offset into the end of the animation clip
    - ``first_loop_start_frame_offset`` (FrameNumber):  [Read-Write] The offset for the first loop of the animation clip
    - ``lock_cache_to_read_only`` (bool):  [Read-Write] If true then the section properties might still be changed (so the section itself is not locked), but the cache cannot be rerecorded to prevent accidentally overriding the data within
    - ``override_quality_level`` (bool):  [Read-Write]
    - ``play_rate`` (float):  [Read-Write] The playback rate of the animation clip
    - ``record_quality_level`` (PerQualityLevels):  [Read-Write] If set, then the engine scalability setting will be overriden with this value when recording a new cache for this track
    - ``reverse`` (bool):  [Read-Write] Reverse the playback of the animation clip
    - ``section_stretch_mode`` (NiagaraSimCacheSectionStretchMode):  [Read-Write] What should the effect do when the cache section is stretched?
    - ``sim_cache`` (NiagaraSimCache):  [Read-Write] The sim cache this section plays and records into
    - ``start_frame_offset`` (FrameNumber):  [Read-Write] The offset into the beginning of the animation clip
    """
    def __init__(self) -> None:
        ...

class InterchangeAnimationPayLoadKey(StructBase):
    r"""
    Interchange Animation Pay Load Key
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeAnimationTrackSetNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``type`` (InterchangeAnimationPayLoadType):  [Read-Write]
    - ``unique_id`` (str):  [Read-Write]
    """
    def __init__(self, unique_id: str = "", type: InterchangeAnimationPayLoadType = InterchangeAnimationPayLoadType.NONE) -> None:
        ...
    @property
    def unique_id(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @unique_id.setter
    def unique_id(self, value: str) -> None:
        ...
    @property
    def type(self) -> InterchangeAnimationPayLoadType:
        r"""
        (InterchangeAnimationPayLoadType):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: InterchangeAnimationPayLoadType) -> None:
        ...

class InterchangeMeshPayLoadKey(StructBase):
    r"""
    Interchange Mesh Pay Load Key
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeMeshNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``type`` (InterchangeMeshPayLoadType):  [Read-Write]
    - ``unique_id`` (str):  [Read-Write]
    """
    def __init__(self, unique_id: str = "", type: InterchangeMeshPayLoadType = InterchangeMeshPayLoadType.NONE) -> None:
        ...
    @property
    def unique_id(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @unique_id.setter
    def unique_id(self, value: str) -> None:
        ...
    @property
    def type(self) -> InterchangeMeshPayLoadType:
        r"""
        (InterchangeMeshPayLoadType):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: InterchangeMeshPayLoadType) -> None:
        ...

class InterchangeLodSceneNodeContainer(StructBase):
    r"""
    * This container exists only because UPROPERTY cannot support nested container. See FInterchangeMeshInstance.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangePipelineMeshesUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``scene_nodes`` (Array[InterchangeSceneNode]):  [Read-Write] Each scene node here represents a mesh scene node. If it represents a LOD group, there may be more then one mesh scene node for a specific LOD index.
    """
    def __init__(self) -> None:
        ...

class InterchangeMeshInstance(StructBase):
    r"""
    * A mesh instance is a description of a translated scene node that points to a translated mesh asset.
    * A mesh instance that points to an LOD group can have many LODs and many scene mesh nodes per LOD index.
    * A mesh instance that points to a mesh node will have only LOD 0 and will point to one scene mesh node.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangePipelineMeshesUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``has_morph_targets`` (bool):  [Read-Write]
    - ``lod_group_node`` (InterchangeSceneNode):  [Read-Write] This member is null unless the mesh instance represents a LOD group.
    - ``mesh_instance_uid`` (str):  [Read-Write] This ID represents either a LOD group scene node UID or a mesh scene node UID.
    - ``reference_morph_target`` (bool):  [Read-Write]
    - ``reference_skinned_mesh`` (bool):  [Read-Write]
    - ``referencing_mesh_geometry_uids`` (Array[str]):  [Read-Write] All mesh geometry referenced by this MeshInstance.
    - ``scene_node_per_lod_index`` (Map[int32, InterchangeLodSceneNodeContainer]):  [Read-Write] Each scene node here represents a mesh scene node. If it represents a LOD group, there may be more then one mesh scene node for a specific LOD index.
    """
    def __init__(self) -> None:
        ...

class InterchangeMeshGeometry(StructBase):
    r"""
    * A mesh geometry is a description of a translated mesh asset node that defines a geometry.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangePipelineMeshesUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attached_socket_uids`` (Array[str]):  [Read-Write] A list of all scene nodes that represent sockets attached to this mesh.
    - ``mesh_node`` (InterchangeMeshNode):  [Read-Write] The UInterchangeMeshNode pointer represented by this structure.
    - ``mesh_uid`` (str):  [Read-Write] The unique ID of the UInterchangeMeshNode represented by this structure.
    - ``referencing_mesh_instance_uids`` (Array[str]):  [Read-Write] All mesh instances that refer to this UInterchangeMeshNode pointer.
    """
    def __init__(self) -> None:
        ...

class InterchangePipelineMeshesUtilitiesContext(StructBase):
    r"""
    * Represents the context UInterchangePipelineMeshesUtilities will use when the client queries data.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangePipelineMeshesUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``convert_skeletal_mesh_to_static_mesh`` (bool):  [Read-Write] If enabled, all skeletal meshes are converted to static meshes.
    - ``convert_static_mesh_to_skeletal_mesh`` (bool):  [Read-Write] If enabled, all static meshes are converted to skeletal meshes.
    - ``convert_statics_with_morph_targets_to_skeletals`` (bool):  [Read-Write] If enabled, all static meshes that have morph targets will be imported as skeletal meshes instead.
    - ``import_meshes_in_bone_hierarchy`` (bool):  [Read-Write] If enabled, meshes nested in bone hierarchies are imported as meshes instead of being converted to bones. If the meshes are not skinned, they are
      added to the skeletal mesh and removed from the list of static meshes.
    - ``query_geometry_only_if_no_instance`` (bool):  [Read-Write] When querying geometry, this flag will not add MeshGeometry if there is a scene node that points to a geometry.
    """
    def __init__(self, convert_static_mesh_to_skeletal_mesh: bool = False, convert_skeletal_mesh_to_static_mesh: bool = False, convert_statics_with_morph_targets_to_skeletals: bool = False, import_meshes_in_bone_hierarchy: bool = False, query_geometry_only_if_no_instance: bool = False) -> None:
        ...
    @property
    def convert_static_mesh_to_skeletal_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, all static meshes are converted to skeletal meshes.
        """
        ...
    @convert_static_mesh_to_skeletal_mesh.setter
    def convert_static_mesh_to_skeletal_mesh(self, value: bool) -> None:
        ...
    @property
    def convert_skeletal_mesh_to_static_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, all skeletal meshes are converted to static meshes.
        """
        ...
    @convert_skeletal_mesh_to_static_mesh.setter
    def convert_skeletal_mesh_to_static_mesh(self, value: bool) -> None:
        ...
    @property
    def convert_statics_with_morph_targets_to_skeletals(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, all static meshes that have morph targets will be imported as skeletal meshes instead.
        """
        ...
    @convert_statics_with_morph_targets_to_skeletals.setter
    def convert_statics_with_morph_targets_to_skeletals(self, value: bool) -> None:
        ...
    @property
    def import_meshes_in_bone_hierarchy(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, meshes nested in bone hierarchies are imported as meshes instead of being converted to bones. If the meshes are not skinned, they are
        added to the skeletal mesh and removed from the list of static meshes.
        """
        ...
    @import_meshes_in_bone_hierarchy.setter
    def import_meshes_in_bone_hierarchy(self, value: bool) -> None:
        ...
    @property
    def query_geometry_only_if_no_instance(self) -> bool:
        r"""
        (bool):  [Read-Write] When querying geometry, this flag will not add MeshGeometry if there is a scene node that points to a geometry.
        """
        ...
    @query_geometry_only_if_no_instance.setter
    def query_geometry_only_if_no_instance(self, value: bool) -> None:
        ...

class AnimationCurveMetaData(StructBase):
    r"""
    Animation Curve Meta Data
    
    **C++ Source:**
    
    - **Plugin**: AnimationData
    - **Module**: AnimationData
    - **File**: AnimSequencerDataModel.h
    
    """
    def __init__(self) -> None:
        ...

class AnimNode_ControlRigBase(AnimNode_CustomProperty):
    r"""
    Animation node that allows animation ControlRig output to be used in an animation graph
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: AnimNode_ControlRigBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write]
    - ``event_queue`` (Array[ControlRigAnimNodeEventName]):  [Read-Write] The customized event queue to run
    - ``input_bones_to_transfer`` (Array[BoneReference]):  [Read-Write] An inclusive list of bones to transfer as part
      of the input pose transfer phase.
      If this list is empty all bones will be transferred.
    - ``output_bones_to_transfer`` (Array[BoneReference]):  [Read-Write] An inclusive list of bones to transfer as part
      of the output pose transfer phase.
      If this list is empty all bones will be transferred.
    - ``reset_input_pose_to_initial`` (bool):  [Read-Write] If this is checked the rig's pose needs to be reset to its initial
      prior to evaluating the rig.
    - ``source`` (PoseLink):  [Read-Write]
    - ``transfer_input_curves`` (bool):  [Read-Write] If this is checked the curves coming from the AnimBP will be
      transferred into the Control Rig.
    - ``transfer_input_pose`` (bool):  [Read-Write] If this is checked the bone pose coming from the AnimBP will be
      transferred into the Control Rig.
    - ``transfer_pose_in_global_space`` (bool):  [Read-Write] Transferring the pose in global space guarantees a global pose match,
      while transferring in local space ensures a match of the local transforms.
      In general transforms only differ if the hierarchy topology differs
      between the Control Rig and the skeleton used in the AnimBP.
      Note: Turning this off can potentially improve performance.
    """
    def __init__(self) -> None:
        ...

class AnimNode_ControlRig(AnimNode_ControlRigBase):
    r"""
    Animation node that allows animation ControlRig output to be used in an animation graph
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: AnimNode_ControlRig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] alpha value handler
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write]
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write]
    - ``control_rig_class`` (type(Class)):  [Read-Write] The class to use for the rig.
    - ``event_queue`` (Array[ControlRigAnimNodeEventName]):  [Read-Write] The customized event queue to run
    - ``input_bones_to_transfer`` (Array[BoneReference]):  [Read-Write] An inclusive list of bones to transfer as part
      of the input pose transfer phase.
      If this list is empty all bones will be transferred.
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run
      * For example if you have LODThreshold to be 2, it will run until LOD 2 (based on 0 index)
      * when the component LOD becomes 3, it will stop update/evaluate
      * currently transition would be issue and that has to be re-visited
    - ``output_bones_to_transfer`` (Array[BoneReference]):  [Read-Write] An inclusive list of bones to transfer as part
      of the output pose transfer phase.
      If this list is empty all bones will be transferred.
    - ``reset_input_pose_to_initial`` (bool):  [Read-Write] If this is checked the rig's pose needs to be reset to its initial
      prior to evaluating the rig.
    - ``set_ref_pose_from_skeleton`` (bool):  [Read-Write] Override the initial transforms with those taken from the mesh component
    - ``source`` (PoseLink):  [Read-Write]
    - ``transfer_input_curves`` (bool):  [Read-Write] If this is checked the curves coming from the AnimBP will be
      transferred into the Control Rig.
    - ``transfer_input_pose`` (bool):  [Read-Write] If this is checked the bone pose coming from the AnimBP will be
      transferred into the Control Rig.
    - ``transfer_pose_in_global_space`` (bool):  [Read-Write] Transferring the pose in global space guarantees a global pose match,
      while transferring in local space ensures a match of the local transforms.
      In general transforms only differ if the hierarchy topology differs
      between the Control Rig and the skeleton used in the AnimBP.
      Note: Turning this off can potentially improve performance.
    """
    def __init__(self) -> None:
        ...

class RigHierarchySettings(StructBase):
    r"""
    Rig Hierarchy Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigUnitContext.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``procedural_element_limit`` (int32):  [Read-Write] Sets the limit for the number of elements to create procedurally
    """
    def __init__(self) -> None:
        ...

class RigVMDrawContainer(StructBase):
    r"""
    Rig VMDraw Container
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMDrawContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``instructions`` (Array[RigVMDrawInstruction]):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class ControlRigDrawContainer(RigVMDrawContainer):
    r"""
    deprecated: 'ControlRigDrawContainer' was renamed to 'RigVMDrawContainer'.
    """
    def __init__(self) -> None:
        ...

class ControlRigAnimNodeEventName(StructBase):
    r"""
    Control Rig Anim Node Event Name
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: AnimNode_ControlRigBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``event_name`` (Name):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class RigVMDrawInstruction(StructBase):
    r"""
    Rig VMDraw Instruction
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMDrawInstruction.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``positions`` (Array[Vector]):  [Read-Write]
    - ``primitive_type`` (RigVMDrawSettings):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class ControlRigDrawInstruction(RigVMDrawInstruction):
    r"""
    deprecated: 'ControlRigDrawInstruction' was renamed to 'RigVMDrawInstruction'.
    """
    def __init__(self) -> None:
        ...

class FOscillator(StructBase):
    r"""
    Defines oscillation of a single number.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: LegacyCameraShake.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``amplitude`` (float):  [Read-Write] Amplitude of the sinusoidal oscillation.
    - ``frequency`` (float):  [Read-Write] Frequency of the sinusoidal oscillation.
    - ``initial_offset`` (InitialOscillatorOffset):  [Read-Write] Defines how to begin (either at zero, or at a randomized value.
    - ``waveform`` (OscillatorWaveform):  [Read-Write] Type of waveform to use for oscillation.
    """
    def __init__(self, amplitude: float = 0.000000, frequency: float = 0.000000, waveform: OscillatorWaveform = OscillatorWaveform.SINE_WAVE) -> None:
        ...
    @property
    def amplitude(self) -> float:
        r"""
        (float):  [Read-Write] Amplitude of the sinusoidal oscillation.
        """
        ...
    @amplitude.setter
    def amplitude(self, value: float) -> None:
        ...
    @property
    def frequency(self) -> float:
        r"""
        (float):  [Read-Write] Frequency of the sinusoidal oscillation.
        """
        ...
    @frequency.setter
    def frequency(self, value: float) -> None:
        ...
    @property
    def waveform(self) -> OscillatorWaveform:
        r"""
        (OscillatorWaveform):  [Read-Write] Type of waveform to use for oscillation.
        """
        ...
    @waveform.setter
    def waveform(self, value: OscillatorWaveform) -> None:
        ...

class ROscillator(StructBase):
    r"""
    Defines FRotator oscillation.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: LegacyCameraShake.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``pitch`` (FOscillator):  [Read-Write] Pitch oscillation.
    - ``roll`` (FOscillator):  [Read-Write] Roll oscillation.
    - ``yaw`` (FOscillator):  [Read-Write] Yaw oscillation.
    """
    def __init__(self, pitch: FOscillator = [0.000000, 0.000000, OscillatorWaveform.SINE_WAVE], yaw: FOscillator = [0.000000, 0.000000, OscillatorWaveform.SINE_WAVE], roll: FOscillator = [0.000000, 0.000000, OscillatorWaveform.SINE_WAVE]) -> None:
        ...
    @property
    def pitch(self) -> FOscillator:
        r"""
        (FOscillator):  [Read-Write] Pitch oscillation.
        """
        ...
    @pitch.setter
    def pitch(self, value: FOscillator) -> None:
        ...
    @property
    def yaw(self) -> FOscillator:
        r"""
        (FOscillator):  [Read-Write] Yaw oscillation.
        """
        ...
    @yaw.setter
    def yaw(self, value: FOscillator) -> None:
        ...
    @property
    def roll(self) -> FOscillator:
        r"""
        (FOscillator):  [Read-Write] Roll oscillation.
        """
        ...
    @roll.setter
    def roll(self, value: FOscillator) -> None:
        ...

class VOscillator(StructBase):
    r"""
    Defines FVector oscillation.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: LegacyCameraShake.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (FOscillator):  [Read-Write] Oscillation in the X axis.
    - ``y`` (FOscillator):  [Read-Write] Oscillation in the Y axis.
    - ``z`` (FOscillator):  [Read-Write] Oscillation in the Z axis.
    """
    def __init__(self, x: FOscillator = [0.000000, 0.000000, OscillatorWaveform.SINE_WAVE], y: FOscillator = [0.000000, 0.000000, OscillatorWaveform.SINE_WAVE], z: FOscillator = [0.000000, 0.000000, OscillatorWaveform.SINE_WAVE]) -> None:
        ...
    @property
    def x(self) -> FOscillator:
        r"""
        (FOscillator):  [Read-Write] Oscillation in the X axis.
        """
        ...
    @x.setter
    def x(self, value: FOscillator) -> None:
        ...
    @property
    def y(self) -> FOscillator:
        r"""
        (FOscillator):  [Read-Write] Oscillation in the Y axis.
        """
        ...
    @y.setter
    def y(self, value: FOscillator) -> None:
        ...
    @property
    def z(self) -> FOscillator:
        r"""
        (FOscillator):  [Read-Write] Oscillation in the Z axis.
        """
        ...
    @z.setter
    def z(self, value: FOscillator) -> None:
        ...

class CameraAnimationParams(StructBase):
    r"""
    Parameter struct for adding new camera animations to UCameraAnimationCameraModifier
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraAnimationCameraModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration_override`` (float):  [Read-Write] Override the duration of the animation with a new duration (including blends)
    - ``ease_in_duration`` (float):  [Read-Write] Ease-in duration in seconds
    - ``ease_in_type`` (CameraAnimationEasingType):  [Read-Write] Ease-in function type
    - ``ease_out_duration`` (float):  [Read-Write] Ease-out duration in seconds
    - ``ease_out_type`` (CameraAnimationEasingType):  [Read-Write] Ease-out function type
    - ``loop`` (bool):  [Read-Write] Whether the camera animation should loop
    - ``play_rate`` (float):  [Read-Write] Time scale for playing the new camera animation
    - ``play_space`` (CameraAnimationPlaySpace):  [Read-Write] The transform space to use for the new camera shake
    - ``random_start_time`` (bool):  [Read-Write] Whether the camera animation should have a random start time
    - ``scale`` (float):  [Read-Write] Global scale to use for the new camera animation
    - ``start_offset`` (int32):  [Read-Write] Offset, in frames, into the animation to start at
    - ``user_play_space_rot`` (Rotator):  [Read-Write] User space to use when PlaySpace is UserDefined
    """
    def __init__(self, play_rate: float = 0.000000, scale: float = 0.000000, ease_in_type: CameraAnimationEasingType = CameraAnimationEasingType.LINEAR, ease_in_duration: float = 0.000000, ease_out_type: CameraAnimationEasingType = CameraAnimationEasingType.LINEAR, ease_out_duration: float = 0.000000, loop: bool = False, start_offset: int = 0, random_start_time: bool = False, duration_override: float = 0.000000, play_space: CameraAnimationPlaySpace = CameraAnimationPlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def play_rate(self) -> float:
        r"""
        (float):  [Read-Write] Time scale for playing the new camera animation
        """
        ...
    @play_rate.setter
    def play_rate(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write] Global scale to use for the new camera animation
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def ease_in_type(self) -> CameraAnimationEasingType:
        r"""
        (CameraAnimationEasingType):  [Read-Write] Ease-in function type
        """
        ...
    @ease_in_type.setter
    def ease_in_type(self, value: CameraAnimationEasingType) -> None:
        ...
    @property
    def ease_in_duration(self) -> float:
        r"""
        (float):  [Read-Write] Ease-in duration in seconds
        """
        ...
    @ease_in_duration.setter
    def ease_in_duration(self, value: float) -> None:
        ...
    @property
    def ease_out_type(self) -> CameraAnimationEasingType:
        r"""
        (CameraAnimationEasingType):  [Read-Write] Ease-out function type
        """
        ...
    @ease_out_type.setter
    def ease_out_type(self, value: CameraAnimationEasingType) -> None:
        ...
    @property
    def ease_out_duration(self) -> float:
        r"""
        (float):  [Read-Write] Ease-out duration in seconds
        """
        ...
    @ease_out_duration.setter
    def ease_out_duration(self, value: float) -> None:
        ...
    @property
    def loop(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the camera animation should loop
        """
        ...
    @loop.setter
    def loop(self, value: bool) -> None:
        ...
    @property
    def start_offset(self) -> int:
        r"""
        (int32):  [Read-Write] Offset, in frames, into the animation to start at
        """
        ...
    @start_offset.setter
    def start_offset(self, value: int) -> None:
        ...
    @property
    def random_start_time(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the camera animation should have a random start time
        """
        ...
    @random_start_time.setter
    def random_start_time(self, value: bool) -> None:
        ...
    @property
    def duration_override(self) -> float:
        r"""
        (float):  [Read-Write] Override the duration of the animation with a new duration (including blends)
        """
        ...
    @duration_override.setter
    def duration_override(self, value: float) -> None:
        ...
    @property
    def play_space(self) -> CameraAnimationPlaySpace:
        r"""
        (CameraAnimationPlaySpace):  [Read-Write] The transform space to use for the new camera shake
        """
        ...
    @play_space.setter
    def play_space(self, value: CameraAnimationPlaySpace) -> None:
        ...
    @property
    def user_play_space_rot(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] User space to use when PlaySpace is UserDefined
        """
        ...
    @user_play_space_rot.setter
    def user_play_space_rot(self, value: Rotator) -> None:
        ...

class CameraAnimationHandle(StructBase):
    r"""
    A handle to a camera animation running in UCameraAnimationCameraModifier
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraAnimationCameraModifier.h
    
    """
    def __init__(self) -> None:
        ...

class PerlinNoiseShaker(StructBase):
    r"""
    A perlin noise shaker for a single number.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: PerlinNoiseCameraShakePattern.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``amplitude`` (float):  [Read-Write] Amplitude of the perlin noise.
    - ``frequency`` (float):  [Read-Write] Frequency of the sinusoidal oscillation.
    """
    def __init__(self, amplitude: float = 0.000000, frequency: float = 0.000000) -> None:
        ...
    @property
    def amplitude(self) -> float:
        r"""
        (float):  [Read-Write] Amplitude of the perlin noise.
        """
        ...
    @amplitude.setter
    def amplitude(self, value: float) -> None:
        ...
    @property
    def frequency(self) -> float:
        r"""
        (float):  [Read-Write] Frequency of the sinusoidal oscillation.
        """
        ...
    @frequency.setter
    def frequency(self, value: float) -> None:
        ...

class WaveOscillator(StructBase):
    r"""
    A wave oscillator for a single number.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: WaveOscillatorCameraShakePattern.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``amplitude`` (float):  [Read-Write] Amplitude of the sinusoidal oscillation.
    - ``frequency`` (float):  [Read-Write] Frequency of the sinusoidal oscillation.
    - ``initial_offset_type`` (InitialWaveOscillatorOffsetType):  [Read-Write] Defines how to begin the oscillation.
    """
    def __init__(self, amplitude: float = 0.000000, frequency: float = 0.000000, initial_offset_type: InitialWaveOscillatorOffsetType = InitialWaveOscillatorOffsetType.RANDOM) -> None:
        ...
    @property
    def amplitude(self) -> float:
        r"""
        (float):  [Read-Write] Amplitude of the sinusoidal oscillation.
        """
        ...
    @amplitude.setter
    def amplitude(self, value: float) -> None:
        ...
    @property
    def frequency(self) -> float:
        r"""
        (float):  [Read-Write] Frequency of the sinusoidal oscillation.
        """
        ...
    @frequency.setter
    def frequency(self, value: float) -> None:
        ...
    @property
    def initial_offset_type(self) -> InitialWaveOscillatorOffsetType:
        r"""
        (InitialWaveOscillatorOffsetType):  [Read-Write] Defines how to begin the oscillation.
        """
        ...
    @initial_offset_type.setter
    def initial_offset_type(self, value: InitialWaveOscillatorOffsetType) -> None:
        ...

class CameraModeTransition(StructBase):
    r"""
    A camera transition.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraModeTransition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend`` (BlendCameraNode):  [Read-Write] The blend to use to blend a given camera mode in or out.
    - ``conditions`` (Array[CameraModeTransitionCondition]):  [Read-Write] The list of conditions that must pass for this transition to be used.
    """
    def __init__(self) -> None:
        ...

class IntMargin(StructBase):
    r"""
    Describes the space around a 2D area on an integer grid.
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: IntMargin.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bottom`` (int32):  [Read-Write] Holds the margin to the bottom.
    - ``left`` (int32):  [Read-Write] Holds the margin to the left.
    - ``right`` (int32):  [Read-Write] Holds the margin to the right.
    - ``top`` (int32):  [Read-Write] Holds the margin to the top.
    """
    def __init__(self, left: int = 0, top: int = 0, right: int = 0, bottom: int = 0) -> None:
        ...
    @property
    def left(self) -> int:
        r"""
        (int32):  [Read-Write] Holds the margin to the left.
        """
        ...
    @left.setter
    def left(self, value: int) -> None:
        ...
    @property
    def top(self) -> int:
        r"""
        (int32):  [Read-Write] Holds the margin to the top.
        """
        ...
    @top.setter
    def top(self, value: int) -> None:
        ...
    @property
    def right(self) -> int:
        r"""
        (int32):  [Read-Write] Holds the margin to the right.
        """
        ...
    @right.setter
    def right(self, value: int) -> None:
        ...
    @property
    def bottom(self) -> int:
        r"""
        (int32):  [Read-Write] Holds the margin to the bottom.
        """
        ...
    @bottom.setter
    def bottom(self, value: int) -> None:
        ...

class PaperSpriteSocket(StructBase):
    r"""
    
    TODO:: Should have some nice UI and enforce unique names, etc...
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperSprite.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``local_transform`` (Transform):  [Read-Write] Transform in pivot space (*not* texture space)
    - ``socket_name`` (Name):  [Read-Write] Name of the socket
    """
    def __init__(self, local_transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]], socket_name: Name = "None") -> None:
        ...
    @property
    def local_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] Transform in pivot space (*not* texture space)
        """
        ...
    @property
    def socket_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of the socket
        """
        ...

class PaperTileInfo(StructBase):
    r"""
    This is the contents of a tile map cell
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTileLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``packed_tile_index`` (int32):  [Read-Write] This is the index of the current tile within the tile set
    - ``tile_set`` (PaperTileSet):  [Read-Write] The tile set that this tile comes from
    """
    def __init__(self, tile_index: int = 0, tile_set: PaperTileSet = None, flip_h: bool = False, flip_v: bool = False, flip_d: bool = False) -> None:
        ...

class PaperTileMetadata(StructBase):
    r"""
    Information about a single tile in a tile set
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTileSet.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_data`` (SpriteGeometryCollection):  [Read-Write] Collision data for the tile
    - ``user_data_name`` (Name):  [Read-Write] A tag that can be used for grouping and categorizing (consider using it as the index into a UDataTable asset).
    """
    def __init__(self, user_data_name: Name = "None") -> None:
        ...
    @property
    def user_data_name(self) -> Name:
        r"""
        (Name):  [Read-Only] A tag that can be used for grouping and categorizing (consider using it as the index into a UDataTable asset).
        """
        ...

class PaperTerrainMaterialRule(StructBase):
    r"""
    Rule for a single section of a terrain material
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTerrainMaterial.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``body`` (Array[PaperSprite]):  [Read-Write] A set of sprites to randomly choose to fill up the interior space between the caps in a terrain segment
    - ``collision_offset`` (float):  [Read-Write] How much should the collision be lofted from the spline (positive values go out from the spline, negative values go in to the spline)
    - ``description`` (Text):  [Read-Write] Readable description for the rule (unused anywhere, just for clarity when editing the material)
    - ``draw_order`` (int32):  [Read-Write] Specify a draw order for different materials in a spline. Smaller draw orders are drawn first, negative values are allowed.
    - ``enable_collision`` (bool):  [Read-Write] If true, collision is enabled for sections matching this rule
    - ``end_cap`` (PaperSprite):  [Read-Write] The sprite to use at the 'right' (closest to spline end) edge of the terrain segment
    - ``maximum_angle`` (float):  [Read-Write] Maximum slope angle (in degrees) to apply this rule
    - ``minimum_angle`` (float):  [Read-Write] Minimum slope angle (in degrees) to apply this rule
    - ``start_cap`` (PaperSprite):  [Read-Write] The sprite to use at the 'left' (closest to spline start) edge of the terrain segment
    """
    def __init__(self) -> None:
        ...

class PaperFlipbookKeyFrame(StructBase):
    r"""
    Paper Flipbook Key Frame
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperFlipbook.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_run`` (int32):  [Read-Write]
    - ``sprite`` (PaperSprite):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class SpriteInstanceData(StructBase):
    r"""
    Sprite Instance Data
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperGroupedSpriteComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``material_index`` (int32):  [Read-Write]
    - ``source_sprite`` (PaperSprite):  [Read-Write]
    - ``transform`` (Matrix):  [Read-Write]
    - ``vertex_color`` (Color):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class SpriteGeometryCollection(StructBase):
    r"""
    Sprite Geometry Collection
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: SpriteEditorOnlyTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha_threshold`` (float):  [Read-Write] Alpha threshold for a transparent pixel (range 0..1, anything equal or below this value will be considered unimportant)
    - ``avoid_vertex_merging`` (bool):  [Read-Write] Experimental: Hint to the triangulation routine that extra vertices should be preserved
    - ``detail_amount`` (float):  [Read-Write] Amount to detail to consider when shrink-wrapping (range 0..1, 0 = low detail, 1 = high detail)
    - ``geometry_type`` (SpritePolygonMode):  [Read-Write] The geometry type (automatic / manual)
    - ``pixels_per_subdivision_x`` (int32):  [Read-Write] Size of a single subdivision (in pixels) in X (for Diced mode)
    - ``pixels_per_subdivision_y`` (int32):  [Read-Write] Size of a single subdivision (in pixels) in Y (for Diced mode)
    - ``shapes`` (Array[SpriteGeometryShape]):  [Read-Write] List of shapes
    - ``simplify_epsilon`` (float):  [Read-Write] This is the threshold below which multiple vertices will be merged together when doing shrink-wrapping.  Higher values result in fewer vertices.
    """
    def __init__(self) -> None:
        ...

class SpritePolygonCollection(SpriteGeometryCollection):
    r"""
    deprecated: 'SpritePolygonCollection' was renamed to 'SpriteGeometryCollection'.
    """
    def __init__(self) -> None:
        ...

class SpriteGeometryShape(StructBase):
    r"""
    A single piece of geometry (e.g., a polygon which may be convex or concave, a box, or a circle)
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: SpriteEditorOnlyTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``box_position`` (Vector2D):  [Read-Only] Center of the box or circle, acts as the pivot point for polygons (but may not be at the center of them)
    - ``box_size`` (Vector2D):  [Read-Only] Size of the box or major/minor dimensions of the circle
      Note: Only valid when GeometryType is Box or Circle
    - ``negative_winding`` (bool):  [Read-Only] For Polygon geometry, this tells us if the winding should be negative (CW) regardless of the order in Vertices
    - ``rotation`` (float):  [Read-Only] Rotation of the shape (in degrees)
    - ``shape_type`` (SpriteShapeType):  [Read-Only] The type of this piece of geometry
    - ``vertices`` (Array[Vector2D]):  [Read-Write] Vertices for the polygon (valid for Box and Polygon, but empty for Circle)
    """
    def __init__(self) -> None:
        ...

class SpritePolygon(SpriteGeometryShape):
    r"""
    deprecated: 'SpritePolygon' was renamed to 'SpriteGeometryShape'.
    """
    def __init__(self) -> None:
        ...

class ValidateAssetsDetails(StructBase):
    r"""
    Validate Assets Details
    
    **C++ Source:**
    
    - **Plugin**: DataValidation
    - **Module**: DataValidation
    - **File**: EditorValidatorSubsystem.h
    
    """
    def __init__(self) -> None:
        ...

class ValidateAssetsResults(StructBase):
    r"""
    Validate Assets Results
    
    **C++ Source:**
    
    - **Plugin**: DataValidation
    - **Module**: DataValidation
    - **File**: EditorValidatorSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_limit_reached`` (bool):  [Read-Only] True if FValidateAssetSettings::MaxAssetsToValidation was reached
    - ``assets_details`` (Map[str, ValidateAssetsDetails]):  [Read-Only] Per asset details
      Indexed by object path
      Only returned if FValidateAssetsSettings::bCollectPerAssetDetails is true.
    - ``num_checked`` (int32):  [Read-Only] Amount of tested assets
    - ``num_invalid`` (int32):  [Read-Only] Amount of assets with errors
    - ``num_requested`` (int32):  [Read-Only] Total amount of assets that were gathered to validate.
    - ``num_skipped`` (int32):  [Read-Only] Amount of assets skipped
    - ``num_unable_to_validate`` (int32):  [Read-Only] Amount of assets that could not be validated
    - ``num_valid`` (int32):  [Read-Only] Amount of assets without errors or warnings
    - ``num_warnings`` (int32):  [Read-Only] Amount of assets with warnings
    """
    def __init__(self, num_requested: int = 0, num_checked: int = 0, num_valid: int = 0, num_invalid: int = 0, num_skipped: int = 0, num_warnings: int = 0, num_unable_to_validate: int = 0, asset_limit_reached: bool = False, assets_details: Map[str, ValidateAssetsDetails] = {}) -> None:
        ...
    @property
    def num_requested(self) -> int:
        r"""
        (int32):  [Read-Only] Total amount of assets that were gathered to validate.
        """
        ...
    @property
    def num_checked(self) -> int:
        r"""
        (int32):  [Read-Only] Amount of tested assets
        """
        ...
    @property
    def num_valid(self) -> int:
        r"""
        (int32):  [Read-Only] Amount of assets without errors or warnings
        """
        ...
    @property
    def num_invalid(self) -> int:
        r"""
        (int32):  [Read-Only] Amount of assets with errors
        """
        ...
    @property
    def num_skipped(self) -> int:
        r"""
        (int32):  [Read-Only] Amount of assets skipped
        """
        ...
    @property
    def num_warnings(self) -> int:
        r"""
        (int32):  [Read-Only] Amount of assets with warnings
        """
        ...
    @property
    def num_unable_to_validate(self) -> int:
        r"""
        (int32):  [Read-Only] Amount of assets that could not be validated
        """
        ...
    @property
    def asset_limit_reached(self) -> bool:
        r"""
        (bool):  [Read-Only] True if FValidateAssetSettings::MaxAssetsToValidation was reached
        """
        ...
    @property
    def assets_details(self) -> Map[str, ValidateAssetsDetails]:
        r"""
        (Map[str, ValidateAssetsDetails]):  [Read-Only] Per asset details
        Indexed by object path
        Only returned if FValidateAssetsSettings::bCollectPerAssetDetails is true.
        """
        ...

class ValidateAssetsSettings(StructBase):
    r"""
    Validate Assets Settings
    
    **C++ Source:**
    
    - **Plugin**: DataValidation
    - **Module**: DataValidation
    - **File**: EditorValidatorSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``capture_asset_load_logs`` (bool):  [Read-Write] If true, captures log warnings and errors from loading assets for validation and reports them as validation results
    - ``capture_logs_during_validation`` (bool):  [Read-Write] If true, captures log warnings and errors from other operations that happen during validation and adds them to validation results
    - ``collect_per_asset_details`` (bool):  [Read-Write] If true, will add an FValidateAssetsDetails for each asset to the results
    - ``load_assets_for_validation`` (bool):  [Read-Write] If false, unloaded assets will get skipped from validation.
    - ``max_assets_to_validate`` (int32):  [Read-Write] Maximum number of assets to attempt to validate
    - ``show_if_no_failures`` (bool):  [Read-Write] If true, will add notifications for files with no validation and display even if everything passes
    - ``skip_excluded_directories`` (bool):  [Read-Write] If true, will not validate files in excluded directories
    - ``validate_referencers_of_deleted_assets`` (bool):  [Read-Write] Should we validate referencers of deleted assets in changelists
    - ``validation_usecase`` (DataValidationUsecase):  [Read-Write] The usecase requiring datavalidation
    """
    def __init__(self, skip_excluded_directories: bool = False, show_if_no_failures: bool = False, collect_per_asset_details: bool = False, validation_usecase: DataValidationUsecase = DataValidationUsecase.NONE, load_assets_for_validation: bool = False, capture_asset_load_logs: bool = False, capture_logs_during_validation: bool = False, max_assets_to_validate: int = 0, validate_referencers_of_deleted_assets: bool = False) -> None:
        ...
    @property
    def skip_excluded_directories(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, will not validate files in excluded directories
        """
        ...
    @skip_excluded_directories.setter
    def skip_excluded_directories(self, value: bool) -> None:
        ...
    @property
    def show_if_no_failures(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, will add notifications for files with no validation and display even if everything passes
        """
        ...
    @show_if_no_failures.setter
    def show_if_no_failures(self, value: bool) -> None:
        ...
    @property
    def collect_per_asset_details(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, will add an FValidateAssetsDetails for each asset to the results
        """
        ...
    @collect_per_asset_details.setter
    def collect_per_asset_details(self, value: bool) -> None:
        ...
    @property
    def validation_usecase(self) -> DataValidationUsecase:
        r"""
        (DataValidationUsecase):  [Read-Write] The usecase requiring datavalidation
        """
        ...
    @validation_usecase.setter
    def validation_usecase(self, value: DataValidationUsecase) -> None:
        ...
    @property
    def load_assets_for_validation(self) -> bool:
        r"""
        (bool):  [Read-Write] If false, unloaded assets will get skipped from validation.
        """
        ...
    @load_assets_for_validation.setter
    def load_assets_for_validation(self, value: bool) -> None:
        ...
    @property
    def capture_asset_load_logs(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, captures log warnings and errors from loading assets for validation and reports them as validation results
        """
        ...
    @capture_asset_load_logs.setter
    def capture_asset_load_logs(self, value: bool) -> None:
        ...
    @property
    def capture_logs_during_validation(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, captures log warnings and errors from other operations that happen during validation and adds them to validation results
        """
        ...
    @capture_logs_during_validation.setter
    def capture_logs_during_validation(self, value: bool) -> None:
        ...
    @property
    def max_assets_to_validate(self) -> int:
        r"""
        (int32):  [Read-Write] Maximum number of assets to attempt to validate
        """
        ...
    @max_assets_to_validate.setter
    def max_assets_to_validate(self, value: int) -> None:
        ...
    @property
    def validate_referencers_of_deleted_assets(self) -> bool:
        r"""
        (bool):  [Read-Write] Should we validate referencers of deleted assets in changelists
        """
        ...
    @validate_referencers_of_deleted_assets.setter
    def validate_referencers_of_deleted_assets(self, value: bool) -> None:
        ...

class CurveRemapPair(StructBase):
    r"""
    Curve Remap Pair
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: CurveRemapOp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source_curve`` (Name):  [Read-Write] The curve name on the SOURCE skeletal mesh to copy animation data from.
    - ``target_curve`` (Name):  [Read-Write] The curve name on the TARGET skeletal mesh to receive animation data.
    """
    def __init__(self) -> None:
        ...

class RetargetProfile(StructBase):
    r"""
    Retarget Profile
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetProfile.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_chain_settings`` (bool):  [Read-Write] If true, the Chain Settings stored in this profile will be applied to the Retargeter (when plugged into the Retargeter).
    - ``apply_global_settings`` (bool):  [Read-Write] If true, the global settings stored in this profile will be applied to the Retargeter (when plugged into the Retargeter).
    - ``apply_root_settings`` (bool):  [Read-Write] If true, the root settings stored in this profile will be applied to the Retargeter (when plugged into the Retargeter).
    - ``apply_source_retarget_pose`` (bool):  [Read-Write] If true, the Source Retarget Pose specified in this profile will be applied to the Retargeter (when plugged into the Retargeter).
    - ``apply_target_retarget_pose`` (bool):  [Read-Write] If true, the TARGET Retarget Pose specified in this profile will be applied to the Retargeter (when plugged into the Retargeter).
    - ``chain_settings`` (Map[Name, TargetChainSettings]):  [Read-Write] A (potentially sparse) set of setting overrides for the target chains (only applied when bApplyChainSettings is true).
    - ``global_settings`` (RetargetGlobalSettings):  [Read-Write] Retarget settings to control global behavior, like Stride Warping (not applied unless bApplyGlobalSettings is true)
    - ``root_settings`` (TargetRootSettings):  [Read-Write] Retarget settings to control behavior of the retarget root motion (not applied unless bApplyRootSettings is true)
    - ``source_retarget_pose_name`` (Name):  [Read-Write] Override the SOURCE Retarget Pose to use when this profile is active.
      The pose must be present in the Retarget Asset and is not applied unless bApplySourceRetargetPose is true.
    - ``target_retarget_pose_name`` (Name):  [Read-Write] Override the TARGET Retarget Pose to use when this profile is active.
      The pose must be present in the Retarget Asset and is not applied unless bApplyTargetRetargetPose is true.
    """
    def __init__(self, apply_target_retarget_pose: bool = False, target_retarget_pose_name: Name = "None", apply_source_retarget_pose: bool = False, source_retarget_pose_name: Name = "None", apply_chain_settings: bool = False, chain_settings: Map[Name, TargetChainSettings] = {}, apply_root_settings: bool = False, root_settings: TargetRootSettings = [1.000000, 1.000000, 0.000000, [1.000000, 1.000000, 1.000000], 1.000000, 1.000000, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], 1.000000, 0.000000], apply_global_settings: bool = False, global_settings: RetargetGlobalSettings = [True, True, True, True, False, WarpingDirectionSource.GOALS, BasicAxis.Y, "None", 1.000000, 0.000000, 1.000000]) -> None:
        ...
    @property
    def apply_target_retarget_pose(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the TARGET Retarget Pose specified in this profile will be applied to the Retargeter (when plugged into the Retargeter).
        """
        ...
    @apply_target_retarget_pose.setter
    def apply_target_retarget_pose(self, value: bool) -> None:
        ...
    @property
    def target_retarget_pose_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Override the TARGET Retarget Pose to use when this profile is active.
        The pose must be present in the Retarget Asset and is not applied unless bApplyTargetRetargetPose is true.
        """
        ...
    @target_retarget_pose_name.setter
    def target_retarget_pose_name(self, value: Name) -> None:
        ...
    @property
    def apply_source_retarget_pose(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the Source Retarget Pose specified in this profile will be applied to the Retargeter (when plugged into the Retargeter).
        """
        ...
    @apply_source_retarget_pose.setter
    def apply_source_retarget_pose(self, value: bool) -> None:
        ...
    @property
    def source_retarget_pose_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Override the SOURCE Retarget Pose to use when this profile is active.
        The pose must be present in the Retarget Asset and is not applied unless bApplySourceRetargetPose is true.
        """
        ...
    @source_retarget_pose_name.setter
    def source_retarget_pose_name(self, value: Name) -> None:
        ...
    @property
    def apply_chain_settings(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the Chain Settings stored in this profile will be applied to the Retargeter (when plugged into the Retargeter).
        """
        ...
    @apply_chain_settings.setter
    def apply_chain_settings(self, value: bool) -> None:
        ...
    @property
    def chain_settings(self) -> Map[Name, TargetChainSettings]:
        r"""
        (Map[Name, TargetChainSettings]):  [Read-Write] A (potentially sparse) set of setting overrides for the target chains (only applied when bApplyChainSettings is true).
        """
        ...
    @chain_settings.setter
    def chain_settings(self, value: Map[Name, TargetChainSettings]) -> None:
        ...
    @property
    def apply_root_settings(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the root settings stored in this profile will be applied to the Retargeter (when plugged into the Retargeter).
        """
        ...
    @apply_root_settings.setter
    def apply_root_settings(self, value: bool) -> None:
        ...
    @property
    def root_settings(self) -> TargetRootSettings:
        r"""
        (TargetRootSettings):  [Read-Write] Retarget settings to control behavior of the retarget root motion (not applied unless bApplyRootSettings is true)
        """
        ...
    @root_settings.setter
    def root_settings(self, value: TargetRootSettings) -> None:
        ...
    @property
    def apply_global_settings(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the global settings stored in this profile will be applied to the Retargeter (when plugged into the Retargeter).
        """
        ...
    @apply_global_settings.setter
    def apply_global_settings(self, value: bool) -> None:
        ...
    @property
    def global_settings(self) -> RetargetGlobalSettings:
        r"""
        (RetargetGlobalSettings):  [Read-Write] Retarget settings to control global behavior, like Stride Warping (not applied unless bApplyGlobalSettings is true)
        """
        ...
    @global_settings.setter
    def global_settings(self, value: RetargetGlobalSettings) -> None:
        ...

class RetargetGlobalSettings(StructBase):
    r"""
    Retarget Global Settings
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``direction_chain`` (Name):  [Read-Write] When using the "Chain" option as a Direction Source, this defines the chain to use to determine the facing direction of the character.
      Typically this would be the chain that contains the Spine bones.
    - ``direction_source`` (WarpingDirectionSource):  [Read-Write] Defines the source used to determine the forward direction as the character animates in world space. Default is "Goals".
      This method uses various positions on the character to create a "best fit" global rotation that approximates the facing direction of the character over time.
      This global rotation is used to define the forward and sideways directions used when warping goals along those axes.
      The options are:
      Goals: uses the positions of the IK goals to approximate the facing direction. This is best used on characters with a vertical spine, like bipeds.
      Chain: uses the positions of the bones in a retarget chain to approximate the facing direction. This is best when used with the spine chain for characters with a horizontal spine, like quadrupeds.
      Root Bone: uses the rotation of the root bone of the skeleton. This is most robust, but character must have correct root motion with yaw rotation in movement direction.
    - ``enable_fk`` (bool):  [Read-Write] When false, limbs are not copied via FK. Useful for debugging limb issues suspected to be caused by FK chain settings.
      Note: the retargeting order is: Root > FK > IK > Post
    - ``enable_ik`` (bool):  [Read-Write] When false, IK is not applied as part of retargeter. Useful for debugging limb issues suspected to be caused by IK.
      Note: the retargeting order is: Root > FK > IK > Post
    - ``enable_post`` (bool):  [Read-Write] When false, Post operations are not applied as part of retargeter. Useful for debugging issues suspected to be caused by the post phase.
      Note: the retargeting order is: Root > FK > IK > Post
    - ``enable_root`` (bool):  [Read-Write] When false, the motion of the Retarget Root bone is not copied from the source. Useful for debugging issues with the root settings.
      Note: the retargeting order is: Root > FK > IK > Post
    - ``forward_direction`` (BasicAxis):  [Read-Write] The world space axis that represents the forward facing direction for your character. By default, in Unreal, this is +Y.
    - ``sideways_offset`` (float):  [Read-Write] Range -+Inf. Default is 0. A static offset in world units to move the IK goals perpendicular to the forward direction.
      Values less than zero will move the goals towards the center-line of the character. Values greater than zero push the goals outwards.
    - ``warp_forwards`` (float):  [Read-Write] Range 0 to Inf. Default 1. Warps IK goal positions in the forward direction. Useful for stride warping.
      Values below 1 will create smaller, squashed strides. Values greater than 1 will create stretched, longer strides.
    - ``warp_splay`` (float):  [Read-Write] Range 0 to +Inf. Default is 1.0f.
      Values below 1 pull all the goals towards the average of all the goals (towards each other).
      Values greater than 1 push the goals apart.
    - ``warping`` (bool):  [Read-Write] Enable IK Warping.
      These options allow for global modifications to all IK Goals that have "Affected by IK Warping" turned on (the default).
      "Affected by IK Warping" can be found in the IK settings of a retarget chain.
    """
    def __init__(self, enable_root: bool = False, enable_fk: bool = False, enable_ik: bool = False, enable_post: bool = False, warping: bool = False, direction_source: WarpingDirectionSource = WarpingDirectionSource.GOALS, forward_direction: BasicAxis = BasicAxis.X, direction_chain: Name = "None", warp_forwards: float = 0.000000, sideways_offset: float = 0.000000, warp_splay: float = 0.000000) -> None:
        ...
    @property
    def enable_root(self) -> bool:
        r"""
        (bool):  [Read-Write] When false, the motion of the Retarget Root bone is not copied from the source. Useful for debugging issues with the root settings.
        Note: the retargeting order is: Root > FK > IK > Post
        """
        ...
    @enable_root.setter
    def enable_root(self, value: bool) -> None:
        ...
    @property
    def enable_fk(self) -> bool:
        r"""
        (bool):  [Read-Write] When false, limbs are not copied via FK. Useful for debugging limb issues suspected to be caused by FK chain settings.
        Note: the retargeting order is: Root > FK > IK > Post
        """
        ...
    @enable_fk.setter
    def enable_fk(self, value: bool) -> None:
        ...
    @property
    def enable_ik(self) -> bool:
        r"""
        (bool):  [Read-Write] When false, IK is not applied as part of retargeter. Useful for debugging limb issues suspected to be caused by IK.
        Note: the retargeting order is: Root > FK > IK > Post
        """
        ...
    @enable_ik.setter
    def enable_ik(self, value: bool) -> None:
        ...
    @property
    def enable_post(self) -> bool:
        r"""
        (bool):  [Read-Write] When false, Post operations are not applied as part of retargeter. Useful for debugging issues suspected to be caused by the post phase.
        Note: the retargeting order is: Root > FK > IK > Post
        """
        ...
    @enable_post.setter
    def enable_post(self, value: bool) -> None:
        ...
    @property
    def warping(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable IK Warping.
        These options allow for global modifications to all IK Goals that have "Affected by IK Warping" turned on (the default).
        "Affected by IK Warping" can be found in the IK settings of a retarget chain.
        """
        ...
    @warping.setter
    def warping(self, value: bool) -> None:
        ...
    @property
    def direction_source(self) -> WarpingDirectionSource:
        r"""
        (WarpingDirectionSource):  [Read-Write] Defines the source used to determine the forward direction as the character animates in world space. Default is "Goals".
        This method uses various positions on the character to create a "best fit" global rotation that approximates the facing direction of the character over time.
        This global rotation is used to define the forward and sideways directions used when warping goals along those axes.
        The options are:
        Goals: uses the positions of the IK goals to approximate the facing direction. This is best used on characters with a vertical spine, like bipeds.
        Chain: uses the positions of the bones in a retarget chain to approximate the facing direction. This is best when used with the spine chain for characters with a horizontal spine, like quadrupeds.
        Root Bone: uses the rotation of the root bone of the skeleton. This is most robust, but character must have correct root motion with yaw rotation in movement direction.
        """
        ...
    @direction_source.setter
    def direction_source(self, value: WarpingDirectionSource) -> None:
        ...
    @property
    def forward_direction(self) -> BasicAxis:
        r"""
        (BasicAxis):  [Read-Write] The world space axis that represents the forward facing direction for your character. By default, in Unreal, this is +Y.
        """
        ...
    @forward_direction.setter
    def forward_direction(self, value: BasicAxis) -> None:
        ...
    @property
    def direction_chain(self) -> Name:
        r"""
        (Name):  [Read-Write] When using the "Chain" option as a Direction Source, this defines the chain to use to determine the facing direction of the character.
        Typically this would be the chain that contains the Spine bones.
        """
        ...
    @direction_chain.setter
    def direction_chain(self, value: Name) -> None:
        ...
    @property
    def warp_forwards(self) -> float:
        r"""
        (float):  [Read-Write] Range 0 to Inf. Default 1. Warps IK goal positions in the forward direction. Useful for stride warping.
        Values below 1 will create smaller, squashed strides. Values greater than 1 will create stretched, longer strides.
        """
        ...
    @warp_forwards.setter
    def warp_forwards(self, value: float) -> None:
        ...
    @property
    def sideways_offset(self) -> float:
        r"""
        (float):  [Read-Write] Range -+Inf. Default is 0. A static offset in world units to move the IK goals perpendicular to the forward direction.
        Values less than zero will move the goals towards the center-line of the character. Values greater than zero push the goals outwards.
        """
        ...
    @sideways_offset.setter
    def sideways_offset(self, value: float) -> None:
        ...
    @property
    def warp_splay(self) -> float:
        r"""
        (float):  [Read-Write] Range 0 to +Inf. Default is 1.0f.
        Values below 1 pull all the goals towards the average of all the goals (towards each other).
        Values greater than 1 push the goals apart.
        """
        ...
    @warp_splay.setter
    def warp_splay(self, value: float) -> None:
        ...

class TargetRootSettings(StructBase):
    r"""
    Target Root Settings
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affect_ik_horizontal`` (float):  [Read-Write] Range 0 to 1. Default 1. Control whether modifications made to the root will affect the horizontal component of IK positions.
      At 0 the IK positions are independent of the root modifications.
      At 1 the IK positions are calculated relative to the modified root location.
    - ``affect_ik_vertical`` (float):  [Read-Write] Range 0 to 1. Default 0. Control whether modifications made to the root will affect the vertical component of IK positions.
      At 0 the IK positions are independent of the root modifications.
      At 1 the IK positions are calculated relative to the modified root location.
    - ``blend_to_source`` (float):  [Read-Write] Range 0 to 1. Default 0. Blends the retarget root's translation to the exact source location.
      At 0 the root is placed at the retargeted location.
      At 1 the root is placed at the location of the source's retarget root bone.
    - ``blend_to_source_weights`` (Vector):  [Read-Write] Per-axis weights for the Blend to Source.
    - ``rotation_alpha`` (float):  [Read-Write] Range 0 to 1. Default 1. Blends the amount of retargeted root rotation to apply.
      At 0 the root is left at the rotation from the retarget pose.
      At 1 the root is rotated fully to match the source root rotation.
    - ``rotation_offset`` (Rotator):  [Read-Write] Applies a static local-space rotation offset to the retarget root.
    - ``scale_horizontal`` (float):  [Read-Write] Default 1. Scales the motion of the root position in the horizontal plane (X,Y).
    - ``scale_vertical`` (float):  [Read-Write] Default 1. Scales the motion of the root position in the vertical direction (Z).
    - ``translation_alpha`` (float):  [Read-Write] Range 0 to 1. Default 1. Blends the amount of retargeted root translation to apply.
      At 0 the root is left at the position from the retarget pose.
      At 1 the root will follow the source motion according to the behavior defined in the subsequent settings.
    - ``translation_offset`` (Vector):  [Read-Write] Applies a static component-space translation offset to the retarget root.
    """
    def __init__(self, rotation_alpha: float = 0.000000, translation_alpha: float = 0.000000, blend_to_source: float = 0.000000, blend_to_source_weights: Vector = [0.000000, 0.000000, 0.000000], scale_horizontal: float = 0.000000, scale_vertical: float = 0.000000, translation_offset: Vector = [0.000000, 0.000000, 0.000000], rotation_offset: Rotator = [0.000000, 0.000000, 0.000000], affect_ik_horizontal: float = 0.000000, affect_ik_vertical: float = 0.000000) -> None:
        ...
    @property
    def rotation_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range 0 to 1. Default 1. Blends the amount of retargeted root rotation to apply.
        At 0 the root is left at the rotation from the retarget pose.
        At 1 the root is rotated fully to match the source root rotation.
        """
        ...
    @rotation_alpha.setter
    def rotation_alpha(self, value: float) -> None:
        ...
    @property
    def translation_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range 0 to 1. Default 1. Blends the amount of retargeted root translation to apply.
        At 0 the root is left at the position from the retarget pose.
        At 1 the root will follow the source motion according to the behavior defined in the subsequent settings.
        """
        ...
    @translation_alpha.setter
    def translation_alpha(self, value: float) -> None:
        ...
    @property
    def blend_to_source(self) -> float:
        r"""
        (float):  [Read-Write] Range 0 to 1. Default 0. Blends the retarget root's translation to the exact source location.
        At 0 the root is placed at the retargeted location.
        At 1 the root is placed at the location of the source's retarget root bone.
        """
        ...
    @blend_to_source.setter
    def blend_to_source(self, value: float) -> None:
        ...
    @property
    def blend_to_source_weights(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Per-axis weights for the Blend to Source.
        """
        ...
    @blend_to_source_weights.setter
    def blend_to_source_weights(self, value: Vector) -> None:
        ...
    @property
    def scale_horizontal(self) -> float:
        r"""
        (float):  [Read-Write] Default 1. Scales the motion of the root position in the horizontal plane (X,Y).
        """
        ...
    @scale_horizontal.setter
    def scale_horizontal(self, value: float) -> None:
        ...
    @property
    def scale_vertical(self) -> float:
        r"""
        (float):  [Read-Write] Default 1. Scales the motion of the root position in the vertical direction (Z).
        """
        ...
    @scale_vertical.setter
    def scale_vertical(self, value: float) -> None:
        ...
    @property
    def translation_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Applies a static component-space translation offset to the retarget root.
        """
        ...
    @translation_offset.setter
    def translation_offset(self, value: Vector) -> None:
        ...
    @property
    def rotation_offset(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] Applies a static local-space rotation offset to the retarget root.
        """
        ...
    @rotation_offset.setter
    def rotation_offset(self, value: Rotator) -> None:
        ...
    @property
    def affect_ik_horizontal(self) -> float:
        r"""
        (float):  [Read-Write] Range 0 to 1. Default 1. Control whether modifications made to the root will affect the horizontal component of IK positions.
        At 0 the IK positions are independent of the root modifications.
        At 1 the IK positions are calculated relative to the modified root location.
        """
        ...
    @affect_ik_horizontal.setter
    def affect_ik_horizontal(self, value: float) -> None:
        ...
    @property
    def affect_ik_vertical(self) -> float:
        r"""
        (float):  [Read-Write] Range 0 to 1. Default 0. Control whether modifications made to the root will affect the vertical component of IK positions.
        At 0 the IK positions are independent of the root modifications.
        At 1 the IK positions are calculated relative to the modified root location.
        """
        ...
    @affect_ik_vertical.setter
    def affect_ik_vertical(self, value: float) -> None:
        ...

class TargetChainSettings(StructBase):
    r"""
    Target Chain Settings
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``fk`` (TargetChainFKSettings):  [Read-Write] All settings for FK retargeting of this chain.
      FK retargeting runs before the IK pass.
    - ``ik`` (TargetChainIKSettings):  [Read-Write] All settings controlling the IK Goal assigned to this chain.
      The IK pass runs AFTER the FK pass and can be used to fix contacts.
    - ``speed_planting`` (TargetChainSpeedPlantSettings):  [Read-Write] All settings associated with planting IK goals based on the speed of the source.
      Speed planting will pin the IK goal to the location determined by the IK settings above.
    """
    def __init__(self, fk: TargetChainFKSettings = [True, RetargetRotationMode.INTERPOLATED, 1.000000, RetargetTranslationMode.NONE, 1.000000, 0.000000, False, 0.000000], ik: TargetChainIKSettings = [True, 0.000000, [1.000000, 1.000000, 1.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], 1.000000, 1.000000, True], speed_planting: TargetChainSpeedPlantSettings = [False, "None", 15.000000, 250.000000, 1.000000]) -> None:
        ...
    @property
    def fk(self) -> TargetChainFKSettings:
        r"""
        (TargetChainFKSettings):  [Read-Write] All settings for FK retargeting of this chain.
        FK retargeting runs before the IK pass.
        """
        ...
    @fk.setter
    def fk(self, value: TargetChainFKSettings) -> None:
        ...
    @property
    def ik(self) -> TargetChainIKSettings:
        r"""
        (TargetChainIKSettings):  [Read-Write] All settings controlling the IK Goal assigned to this chain.
        The IK pass runs AFTER the FK pass and can be used to fix contacts.
        """
        ...
    @ik.setter
    def ik(self, value: TargetChainIKSettings) -> None:
        ...
    @property
    def speed_planting(self) -> TargetChainSpeedPlantSettings:
        r"""
        (TargetChainSpeedPlantSettings):  [Read-Write] All settings associated with planting IK goals based on the speed of the source.
        Speed planting will pin the IK goal to the location determined by the IK settings above.
        """
        ...
    @speed_planting.setter
    def speed_planting(self, value: TargetChainSpeedPlantSettings) -> None:
        ...

class TargetChainSpeedPlantSettings(StructBase):
    r"""
    Target Chain Speed Plant Settings
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_speed_planting`` (bool):  [Read-Write] The name of the curve on the source animation that contains the speed of the end effector bone.
    - ``speed_curve_name`` (Name):  [Read-Write] The name of the curve on the source animation that contains the speed of the end effector bone.
    - ``speed_threshold`` (float):  [Read-Write] Range 0 to 100. Default 15. The maximum speed a source bone can be moving while being considered 'planted'.
      The target IK goal will not be allowed to move whenever the source bone speed drops below this threshold speed.
    - ``unplant_critical_damping`` (float):  [Read-Write] How much damping to apply to the spring (0 means no damping, 1 means critically damped which means no oscillation)
    - ``unplant_stiffness`` (float):  [Read-Write] How stiff the spring model is that smoothly pulls the IK position after unplanting (more stiffness means more oscillation around the target value)
    """
    def __init__(self, enable_speed_planting: bool = False, speed_curve_name: Name = "None", speed_threshold: float = 0.000000, unplant_stiffness: float = 0.000000, unplant_critical_damping: float = 0.000000) -> None:
        ...
    @property
    def enable_speed_planting(self) -> bool:
        r"""
        (bool):  [Read-Write] The name of the curve on the source animation that contains the speed of the end effector bone.
        """
        ...
    @enable_speed_planting.setter
    def enable_speed_planting(self, value: bool) -> None:
        ...
    @property
    def speed_curve_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of the curve on the source animation that contains the speed of the end effector bone.
        """
        ...
    @speed_curve_name.setter
    def speed_curve_name(self, value: Name) -> None:
        ...
    @property
    def speed_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Range 0 to 100. Default 15. The maximum speed a source bone can be moving while being considered 'planted'.
        The target IK goal will not be allowed to move whenever the source bone speed drops below this threshold speed.
        """
        ...
    @speed_threshold.setter
    def speed_threshold(self, value: float) -> None:
        ...
    @property
    def unplant_stiffness(self) -> float:
        r"""
        (float):  [Read-Write] How stiff the spring model is that smoothly pulls the IK position after unplanting (more stiffness means more oscillation around the target value)
        """
        ...
    @unplant_stiffness.setter
    def unplant_stiffness(self, value: float) -> None:
        ...
    @property
    def unplant_critical_damping(self) -> float:
        r"""
        (float):  [Read-Write] How much damping to apply to the spring (0 means no damping, 1 means critically damped which means no oscillation)
        """
        ...
    @unplant_critical_damping.setter
    def unplant_critical_damping(self, value: float) -> None:
        ...

class TargetChainIKSettings(StructBase):
    r"""
    Target Chain IKSettings
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affected_by_ik_warping`` (bool):  [Read-Write] Is this IK goal affected by the stride warping (in Global Settings). Typically this is true for all feet, but not for hands.
    - ``blend_to_source`` (float):  [Read-Write] Range 0 to 1. Default 0. Blends IK goal position from retargeted location (0) to source bone location (1).
      At 0 the goal is placed at the retargeted location.
      At 1 the goal is placed at the location of the source chain's end bone.
    - ``blend_to_source_weights`` (Vector):  [Read-Write] Range 0 to 1. Default 1. Weight each axis separately when using Blend To Source.
      At 0 the goal is placed at the retargeted location.
      At 1 the goal is placed at the location of the source chain's end bone.
    - ``enable_ik`` (bool):  [Read-Write] Whether to modify the location of the IK goal on this chain. Default is true.
      NOTE: This only has an effect if the chain has an IK Goal assigned to it in the Target IK Rig asset.
      NOTE: If off, and this chain has an IK Goal, the IK will still be evaluated, but the Goal is set to the input bone location (from the FK pass).
    - ``extension`` (float):  [Read-Write] Range 0 to 5. Default 1. Brings IK goal closer (0) or further (1+) from origin of chain.
      At 0 the effector is placed at the origin of the chain (ie Shoulder, Hip etc).
      At 1 the effector is left at the end of the chain (ie Wrist, Foot etc)
      Values in-between 0-1 will slide the effector along the vector from the start to the end of the chain.
      Values greater than 1 will stretch the chain beyond the retargeted length.
    - ``scale_vertical`` (float):  [Read-Write] Range +-Infinity. Default 1. Scales the vertical component of the IK goal's position.
    - ``static_local_offset`` (Vector):  [Read-Write] Default 0, 0, 0. Apply a static local-space offset to IK goal position.
    - ``static_offset`` (Vector):  [Read-Write] Default 0, 0, 0. Apply a static global-space offset to IK goal position.
    - ``static_rotation_offset`` (Rotator):  [Read-Write] Default 0, 0, 0. Apply a static local-space offset to IK goal rotation.
    """
    def __init__(self, enable_ik: bool = False, blend_to_source: float = 0.000000, blend_to_source_weights: Vector = [0.000000, 0.000000, 0.000000], static_offset: Vector = [0.000000, 0.000000, 0.000000], static_local_offset: Vector = [0.000000, 0.000000, 0.000000], static_rotation_offset: Rotator = [0.000000, 0.000000, 0.000000], scale_vertical: float = 0.000000, extension: float = 0.000000, affected_by_ik_warping: bool = False) -> None:
        ...
    @property
    def enable_ik(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to modify the location of the IK goal on this chain. Default is true.
        NOTE: This only has an effect if the chain has an IK Goal assigned to it in the Target IK Rig asset.
        NOTE: If off, and this chain has an IK Goal, the IK will still be evaluated, but the Goal is set to the input bone location (from the FK pass).
        """
        ...
    @enable_ik.setter
    def enable_ik(self, value: bool) -> None:
        ...
    @property
    def blend_to_source(self) -> float:
        r"""
        (float):  [Read-Write] Range 0 to 1. Default 0. Blends IK goal position from retargeted location (0) to source bone location (1).
        At 0 the goal is placed at the retargeted location.
        At 1 the goal is placed at the location of the source chain's end bone.
        """
        ...
    @blend_to_source.setter
    def blend_to_source(self, value: float) -> None:
        ...
    @property
    def blend_to_source_weights(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Range 0 to 1. Default 1. Weight each axis separately when using Blend To Source.
        At 0 the goal is placed at the retargeted location.
        At 1 the goal is placed at the location of the source chain's end bone.
        """
        ...
    @blend_to_source_weights.setter
    def blend_to_source_weights(self, value: Vector) -> None:
        ...
    @property
    def static_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Default 0, 0, 0. Apply a static global-space offset to IK goal position.
        """
        ...
    @static_offset.setter
    def static_offset(self, value: Vector) -> None:
        ...
    @property
    def static_local_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Default 0, 0, 0. Apply a static local-space offset to IK goal position.
        """
        ...
    @static_local_offset.setter
    def static_local_offset(self, value: Vector) -> None:
        ...
    @property
    def static_rotation_offset(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] Default 0, 0, 0. Apply a static local-space offset to IK goal rotation.
        """
        ...
    @static_rotation_offset.setter
    def static_rotation_offset(self, value: Rotator) -> None:
        ...
    @property
    def scale_vertical(self) -> float:
        r"""
        (float):  [Read-Write] Range +-Infinity. Default 1. Scales the vertical component of the IK goal's position.
        """
        ...
    @scale_vertical.setter
    def scale_vertical(self, value: float) -> None:
        ...
    @property
    def extension(self) -> float:
        r"""
        (float):  [Read-Write] Range 0 to 5. Default 1. Brings IK goal closer (0) or further (1+) from origin of chain.
        At 0 the effector is placed at the origin of the chain (ie Shoulder, Hip etc).
        At 1 the effector is left at the end of the chain (ie Wrist, Foot etc)
        Values in-between 0-1 will slide the effector along the vector from the start to the end of the chain.
        Values greater than 1 will stretch the chain beyond the retargeted length.
        """
        ...
    @extension.setter
    def extension(self, value: float) -> None:
        ...
    @property
    def affected_by_ik_warping(self) -> bool:
        r"""
        (bool):  [Read-Write] Is this IK goal affected by the stride warping (in Global Settings). Typically this is true for all feet, but not for hands.
        """
        ...
    @affected_by_ik_warping.setter
    def affected_by_ik_warping(self, value: bool) -> None:
        ...

class TargetChainFKSettings(StructBase):
    r"""
    Target Chain FKSettings
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_fk`` (bool):  [Read-Write] Whether to copy the shape of the chain from the source skeleton using the Rotation and Translation modes. Default is true.
      NOTE: All FK operations run before the IK pass to copy the shape of the FK chain from the source skeleton.
    - ``pole_vector_maintain_offset`` (bool):  [Read-Write] Default is False. When true, the original offset between the source/target pole vectors will be maintained when using Pole Vector Matching.
    - ``pole_vector_matching`` (float):  [Read-Write] Range 0 to 1. Default 1. Matches the twist angle of this chain (along the Pole direction) to the source chain.
      At 0, the chain's pole vector direction will be left alon
      At 1, the root bone of the chain will be twist-rotated in the pole direction to match the orientation of the source chain.
    - ``pole_vector_offset`` (float):  [Read-Write] Range +/- 180. Default 0. An angular offset, in degrees, for the pole direction of the chain.
    - ``rotation_alpha`` (float):  [Read-Write] Range +/- infinity. Default 1. Scales the amount of rotation that is applied.
      If Rotation Mode is None this parameter has no effect.
      Otherwise, this parameter blends the rotation of each bone in the chain from the base retarget pose (0) to the retargeted pose (1).
    - ``rotation_mode`` (RetargetRotationMode):  [Read-Write] Determines how rotation is copied from the source chain to the target chain. Default is Interpolated.
      Interpolated: Source and target chains are normalized by their length, then each target bone rotation is generated by finding the rotation at the same normalized distance on the source chain and interpolating between the neighboring bones.
      One to One: Each target bone rotation is copied from the equivalent bone in the source chain, based on the order in the chain, starting at the root of the chain. If the target chain has more bones than the source, the extra bones will remain at their reference pose.
      One to One Reversed: Same as One-to-One, but starting from the tip of the chain.
      None: The rotation of each target bone in the chain is left at the reference pose.
    - ``translation_alpha`` (float):  [Read-Write] Range +/- infinity. Default 1. Scales the amount of translation that is applied. Exact behavior depends on the Translation Mode.
      In None Mode, this parameter has no effect.
      In Globally Scaled and Absolute modes, the translation offset is scaled by this parameter.
    - ``translation_mode`` (RetargetTranslationMode):  [Read-Write] Determines how translation is copied from the source chain to the target chain. Default is None.
      None: Translation of target bones are left unmodified from the retarget pose.
      Globally Scaled: Translation of target bone is set to the source bone offset multiplied by the global scale of the skeleton (determined by the relative height difference between retarget root bones).
      Absolute: Translation of target bone is set to the absolute position of the source bone.
    """
    def __init__(self, enable_fk: bool = False, rotation_mode: RetargetRotationMode = RetargetRotationMode.INTERPOLATED, rotation_alpha: float = 0.000000, translation_mode: RetargetTranslationMode = RetargetTranslationMode.NONE, translation_alpha: float = 0.000000, pole_vector_matching: float = 0.000000, pole_vector_maintain_offset: bool = False, pole_vector_offset: float = 0.000000) -> None:
        ...
    @property
    def enable_fk(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to copy the shape of the chain from the source skeleton using the Rotation and Translation modes. Default is true.
        NOTE: All FK operations run before the IK pass to copy the shape of the FK chain from the source skeleton.
        """
        ...
    @enable_fk.setter
    def enable_fk(self, value: bool) -> None:
        ...
    @property
    def rotation_mode(self) -> RetargetRotationMode:
        r"""
        (RetargetRotationMode):  [Read-Write] Determines how rotation is copied from the source chain to the target chain. Default is Interpolated.
        Interpolated: Source and target chains are normalized by their length, then each target bone rotation is generated by finding the rotation at the same normalized distance on the source chain and interpolating between the neighboring bones.
        One to One: Each target bone rotation is copied from the equivalent bone in the source chain, based on the order in the chain, starting at the root of the chain. If the target chain has more bones than the source, the extra bones will remain at their reference pose.
        One to One Reversed: Same as One-to-One, but starting from the tip of the chain.
        None: The rotation of each target bone in the chain is left at the reference pose.
        """
        ...
    @rotation_mode.setter
    def rotation_mode(self, value: RetargetRotationMode) -> None:
        ...
    @property
    def rotation_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range +/- infinity. Default 1. Scales the amount of rotation that is applied.
        If Rotation Mode is None this parameter has no effect.
        Otherwise, this parameter blends the rotation of each bone in the chain from the base retarget pose (0) to the retargeted pose (1).
        """
        ...
    @rotation_alpha.setter
    def rotation_alpha(self, value: float) -> None:
        ...
    @property
    def translation_mode(self) -> RetargetTranslationMode:
        r"""
        (RetargetTranslationMode):  [Read-Write] Determines how translation is copied from the source chain to the target chain. Default is None.
        None: Translation of target bones are left unmodified from the retarget pose.
        Globally Scaled: Translation of target bone is set to the source bone offset multiplied by the global scale of the skeleton (determined by the relative height difference between retarget root bones).
        Absolute: Translation of target bone is set to the absolute position of the source bone.
        """
        ...
    @translation_mode.setter
    def translation_mode(self, value: RetargetTranslationMode) -> None:
        ...
    @property
    def translation_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range +/- infinity. Default 1. Scales the amount of translation that is applied. Exact behavior depends on the Translation Mode.
        In None Mode, this parameter has no effect.
        In Globally Scaled and Absolute modes, the translation offset is scaled by this parameter.
        """
        ...
    @translation_alpha.setter
    def translation_alpha(self, value: float) -> None:
        ...
    @property
    def pole_vector_matching(self) -> float:
        r"""
        (float):  [Read-Write] Range 0 to 1. Default 1. Matches the twist angle of this chain (along the Pole direction) to the source chain.
        At 0, the chain's pole vector direction will be left alon
        At 1, the root bone of the chain will be twist-rotated in the pole direction to match the orientation of the source chain.
        """
        ...
    @pole_vector_matching.setter
    def pole_vector_matching(self, value: float) -> None:
        ...
    @property
    def pole_vector_maintain_offset(self) -> bool:
        r"""
        (bool):  [Read-Write] Default is False. When true, the original offset between the source/target pole vectors will be maintained when using Pole Vector Matching.
        """
        ...
    @pole_vector_maintain_offset.setter
    def pole_vector_maintain_offset(self, value: bool) -> None:
        ...
    @property
    def pole_vector_offset(self) -> float:
        r"""
        (float):  [Read-Write] Range +/- 180. Default 0. An angular offset, in degrees, for the pole direction of the chain.
        """
        ...
    @pole_vector_offset.setter
    def pole_vector_offset(self, value: float) -> None:
        ...

class PinBoneData(StructBase):
    r"""
    Pin Bone Data
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: PinBoneOp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_to_pin`` (Name):  [Read-Write] The bone to be affected by this op. Will have it's transform modified to match the BoneToPinTo
    - ``bone_to_pin_to`` (Name):  [Read-Write] The bone, on the target skeleton to pin to.
    """
    def __init__(self) -> None:
        ...

class AnimNode_IKRig(AnimNode_CustomProperty):
    r"""
    Anim Node IKRig
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: AnimNode_IKRig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current strength of the skeletal control
    - ``alpha_bool_blend`` (InputAlphaBoolBlend):  [Read-Write]
    - ``alpha_bool_enabled`` (bool):  [Read-Write]
    - ``alpha_curve_name`` (Name):  [Read-Write]
    - ``alpha_input_type`` (AnimAlphaInputType):  [Read-Write] alpha value handler *
    - ``alpha_scale_bias`` (InputScaleBias):  [Read-Write]
    - ``alpha_scale_bias_clamp`` (InputScaleBiasClamp):  [Read-Write]
    - ``debug_scale`` (float):  [Read-Write] Adjust size of debug drawing.
    - ``enable_debug_draw`` (bool):  [Read-Write] Toggle debug drawing of goals when node is selected.
    - ``goals`` (Array[IKRigGoal]):  [Read-Write] The input goal transforms used by the IK Rig solvers.
    - ``rig_definition_asset`` (IKRigDefinition):  [Read-Write] The IK rig to use to modify the incoming source pose.
    - ``source`` (PoseLink):  [Read-Write] The input pose to start the IK solve relative to.
    - ``start_from_ref_pose`` (bool):  [Read-Write] optionally ignore the input pose and start from the reference pose each solve
    """
    def __init__(self, goals: Array[IKRigGoal] = [], alpha_input_type: AnimAlphaInputType = AnimAlphaInputType.FLOAT, alpha_bool_enabled: bool = False, alpha: float = 0.000000, alpha_scale_bias: InputScaleBias = [1.000000, 0.000000], alpha_bool_blend: InputAlphaBoolBlend = [0.000000, 0.000000, AlphaBlendOption.LINEAR, None], alpha_curve_name: Name = "None", alpha_scale_bias_clamp: InputScaleBiasClamp = [False, False, False, [0.000000, 1.000000], [0.000000, 1.000000], 1.000000, 0.000000, 0.000000, 1.000000, 10.000000, 10.000000]) -> None:
        ...
    @property
    def goals(self) -> Array[IKRigGoal]:
        r"""
        (Array[IKRigGoal]):  [Read-Write] The input goal transforms used by the IK Rig solvers.
        """
        ...
    @goals.setter
    def goals(self, value: Array[IKRigGoal]) -> None:
        ...
    @property
    def alpha_input_type(self) -> AnimAlphaInputType:
        r"""
        (AnimAlphaInputType):  [Read-Write] alpha value handler *
        """
        ...
    @alpha_input_type.setter
    def alpha_input_type(self, value: AnimAlphaInputType) -> None:
        ...
    @property
    def alpha_bool_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @alpha_bool_enabled.setter
    def alpha_bool_enabled(self, value: bool) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write] Current strength of the skeletal control
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...
    @property
    def alpha_scale_bias(self) -> InputScaleBias:
        r"""
        (InputScaleBias):  [Read-Write]
        """
        ...
    @alpha_scale_bias.setter
    def alpha_scale_bias(self, value: InputScaleBias) -> None:
        ...
    @property
    def alpha_bool_blend(self) -> InputAlphaBoolBlend:
        r"""
        (InputAlphaBoolBlend):  [Read-Write]
        """
        ...
    @alpha_bool_blend.setter
    def alpha_bool_blend(self, value: InputAlphaBoolBlend) -> None:
        ...
    @property
    def alpha_curve_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @alpha_curve_name.setter
    def alpha_curve_name(self, value: Name) -> None:
        ...
    @property
    def alpha_scale_bias_clamp(self) -> InputScaleBiasClamp:
        r"""
        (InputScaleBiasClamp):  [Read-Write]
        """
        ...
    @alpha_scale_bias_clamp.setter
    def alpha_scale_bias_clamp(self, value: InputScaleBiasClamp) -> None:
        ...

class IKRigGoal(StructBase):
    r"""
    IKRig Goal
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRigDataTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] Name of the IK Goal. Must correspond to the name of a Goal in the target IKRig asset.
    - ``position`` (Vector):  [Read-Write] Position of the IK goal in Component Space of target actor component.
    - ``position_alpha`` (float):  [Read-Write] Range 0-1, default is 1.0. Smoothly blends the Goal position from the input pose (0.0) to the Goal position (1.0).
    - ``position_space`` (IKRigGoalSpace):  [Read-Write] The space that the goal position is in.
      "Additive" treats the goal transform as an additive offset relative to the Bone at the effector.
      "Component" treats the goal transform as being in the space of the Skeletal Mesh Actor Component.
      "World" treats the goal transform as being in the space of the World.
    - ``rotation`` (Rotator):  [Read-Write] Rotation of the IK goal in Component Space of target actor component.
    - ``rotation_alpha`` (float):  [Read-Write] Range 0-1, default is 1.0. Smoothly blends the Goal rotation from the input pose (0.0) to the Goal rotation (1.0).
    - ``rotation_space`` (IKRigGoalSpace):  [Read-Write] The space that the goal rotation is in.
      "Additive" treats the goal transform as an additive offset relative to the Bone at the effector.
      "Component" treats the goal transform as being in the space of the Skeletal Mesh Actor Component.
      "World" treats the goal transform as being in the space of the World.
    - ``source_bone`` (BoneReference):  [Read-Write] When TransformSource is set to "Bone" mode, the Position and Rotation will be driven by this Bone's input transform.
      When using a Bone as the transform source, the Position and Rotation Alpha values can still be set as desired.
      But the PositionSpace and RotationSpace are no longer relevant and will not be used.
    - ``transform_source`` (IKRigGoalTransformSource):  [Read-Write] Set the source of the transform data for the Goal.
      "Manual Input" uses the values provided by the blueprint node pin.
      "Bone" uses the transform of the bone provided by OptionalSourceBone.
      "Actor Component" uses the transform supplied by any Actor Components that implements the IIKGoalCreatorInterface
    """
    def __init__(self, name: Name = "None", transform_source: IKRigGoalTransformSource = IKRigGoalTransformSource.MANUAL, position: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], position_alpha: float = 0.000000, rotation_alpha: float = 0.000000, position_space: IKRigGoalSpace = IKRigGoalSpace.COMPONENT, rotation_space: IKRigGoalSpace = IKRigGoalSpace.COMPONENT) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] Name of the IK Goal. Must correspond to the name of a Goal in the target IKRig asset.
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def transform_source(self) -> IKRigGoalTransformSource:
        r"""
        (IKRigGoalTransformSource):  [Read-Write] Set the source of the transform data for the Goal.
        "Manual Input" uses the values provided by the blueprint node pin.
        "Bone" uses the transform of the bone provided by OptionalSourceBone.
        "Actor Component" uses the transform supplied by any Actor Components that implements the IIKGoalCreatorInterface
        """
        ...
    @transform_source.setter
    def transform_source(self, value: IKRigGoalTransformSource) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Position of the IK goal in Component Space of target actor component.
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] Rotation of the IK goal in Component Space of target actor component.
        """
        ...
    @rotation.setter
    def rotation(self, value: Rotator) -> None:
        ...
    @property
    def position_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 1.0. Smoothly blends the Goal position from the input pose (0.0) to the Goal position (1.0).
        """
        ...
    @position_alpha.setter
    def position_alpha(self, value: float) -> None:
        ...
    @property
    def rotation_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 1.0. Smoothly blends the Goal rotation from the input pose (0.0) to the Goal rotation (1.0).
        """
        ...
    @rotation_alpha.setter
    def rotation_alpha(self, value: float) -> None:
        ...
    @property
    def position_space(self) -> IKRigGoalSpace:
        r"""
        (IKRigGoalSpace):  [Read-Write] The space that the goal position is in.
        "Additive" treats the goal transform as an additive offset relative to the Bone at the effector.
        "Component" treats the goal transform as being in the space of the Skeletal Mesh Actor Component.
        "World" treats the goal transform as being in the space of the World.
        """
        ...
    @position_space.setter
    def position_space(self, value: IKRigGoalSpace) -> None:
        ...
    @property
    def rotation_space(self) -> IKRigGoalSpace:
        r"""
        (IKRigGoalSpace):  [Read-Write] The space that the goal rotation is in.
        "Additive" treats the goal transform as an additive offset relative to the Bone at the effector.
        "Component" treats the goal transform as being in the space of the Skeletal Mesh Actor Component.
        "World" treats the goal transform as being in the space of the World.
        """
        ...
    @rotation_space.setter
    def rotation_space(self, value: IKRigGoalSpace) -> None:
        ...

class AnimNode_RetargetPoseFromMesh(AnimNode_Base):
    r"""
    Anim Node Retarget Pose from Mesh
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: AnimNode_RetargetPoseFromMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``copy_curves`` (bool):  [Read-Write] Copy curves from SouceMeshComponent. This will copy any curves the source/target Skeleton have in common.
    - ``custom_retarget_profile`` (RetargetProfile):  [Read-Write] connect a custom retarget profile to modify the retargeter's settings at runtime.
    - ``ik_retargeter_asset`` (IKRetargeter):  [Read-Write] Retarget asset to use. Must define a Source and Target IK Rig compatible with the SourceMeshComponent and current anim instance.
    - ``lod_threshold`` (int32):  [Read-Write] * Max LOD that this node is allowed to run.
      * For example if you have LODThreshold at 2, it will run until LOD 2 (based on 0 index) when the component LOD becomes 3, it will stop update/evaluate
      * A value of -1 forces the node to execute at all LOD levels.
    - ``lod_threshold_for_ik`` (int32):  [Read-Write] * Max LOD that IK is allowed to run.
      * For example if you have LODThresholdForIK at 2, it will skip the IK pass on LODs 3 and greater.
      * This only disables IK and does not affect the Root or FK passes.
      * A value of -1 forces the node to execute at all LOD levels.
    - ``source_mesh_component`` (SkeletalMeshComponent):  [Read-Write] The Skeletal Mesh Component to retarget animation from. Assumed to be animated and tick BEFORE this anim instance.
    - ``suppress_warnings`` (bool):  [Read-Write] Toggle whether to print warnings about missing or incorrectly configured retarget configurations.
    - ``use_attached_parent`` (bool):  [Read-Write] If SourceMeshComponent is not valid, and if this is true, it will look for attached parent as a source
    """
    def __init__(self, source_mesh_component: SkeletalMeshComponent = None, use_attached_parent: bool = False, ik_retargeter_asset: IKRetargeter = None, custom_retarget_profile: RetargetProfile = [False, "None", False, "None", False, {}, False, [1.000000, 1.000000, 0.000000, [1.000000, 1.000000, 1.000000], 1.000000, 1.000000, [0.000000, 0.000000, 0.000000], [0.000000, 0.000000, 0.000000], 1.000000, 0.000000], False, [True, True, True, True, False, WarpingDirectionSource.GOALS, BasicAxis.Y, "None", 1.000000, 0.000000, 1.000000]], suppress_warnings: bool = False, copy_curves: bool = False, lod_threshold: int = 0, lod_threshold_for_ik: int = 0) -> None:
        ...
    @property
    def source_mesh_component(self) -> SkeletalMeshComponent:
        r"""
        (SkeletalMeshComponent):  [Read-Write] The Skeletal Mesh Component to retarget animation from. Assumed to be animated and tick BEFORE this anim instance.
        """
        ...
    @source_mesh_component.setter
    def source_mesh_component(self, value: SkeletalMeshComponent) -> None:
        ...
    @property
    def use_attached_parent(self) -> bool:
        r"""
        (bool):  [Read-Write] If SourceMeshComponent is not valid, and if this is true, it will look for attached parent as a source
        """
        ...
    @use_attached_parent.setter
    def use_attached_parent(self, value: bool) -> None:
        ...
    @property
    def ik_retargeter_asset(self) -> IKRetargeter:
        r"""
        (IKRetargeter):  [Read-Write] Retarget asset to use. Must define a Source and Target IK Rig compatible with the SourceMeshComponent and current anim instance.
        """
        ...
    @ik_retargeter_asset.setter
    def ik_retargeter_asset(self, value: IKRetargeter) -> None:
        ...
    @property
    def custom_retarget_profile(self) -> RetargetProfile:
        r"""
        (RetargetProfile):  [Read-Write] connect a custom retarget profile to modify the retargeter's settings at runtime.
        """
        ...
    @custom_retarget_profile.setter
    def custom_retarget_profile(self, value: RetargetProfile) -> None:
        ...
    @property
    def suppress_warnings(self) -> bool:
        r"""
        (bool):  [Read-Write] Toggle whether to print warnings about missing or incorrectly configured retarget configurations.
        """
        ...
    @suppress_warnings.setter
    def suppress_warnings(self, value: bool) -> None:
        ...
    @property
    def copy_curves(self) -> bool:
        r"""
        (bool):  [Read-Write] Copy curves from SouceMeshComponent. This will copy any curves the source/target Skeleton have in common.
        """
        ...
    @copy_curves.setter
    def copy_curves(self, value: bool) -> None:
        ...
    @property
    def lod_threshold(self) -> int:
        r"""
        (int32):  [Read-Write] * Max LOD that this node is allowed to run.
        * For example if you have LODThreshold at 2, it will run until LOD 2 (based on 0 index) when the component LOD becomes 3, it will stop update/evaluate
        * A value of -1 forces the node to execute at all LOD levels.
        """
        ...
    @lod_threshold.setter
    def lod_threshold(self, value: int) -> None:
        ...
    @property
    def lod_threshold_for_ik(self) -> int:
        r"""
        (int32):  [Read-Write] * Max LOD that IK is allowed to run.
        * For example if you have LODThresholdForIK at 2, it will skip the IK pass on LODs 3 and greater.
        * This only disables IK and does not affect the Root or FK passes.
        * A value of -1 forces the node to execute at all LOD levels.
        """
        ...
    @lod_threshold_for_ik.setter
    def lod_threshold_for_ik(self, value: int) -> None:
        ...

class IKRetargetPose(StructBase):
    r"""
    IKRetarget Pose
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargeter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_rotation_offsets`` (Map[Name, Quat]):  [Read-Write] these are LOCAL-space rotation deltas to be applied to a bone to modify it's retarget pose
    - ``root_translation_offset`` (Vector):  [Read-Write] a translational delta in GLOBAL space, applied only to the retarget root bone
    """
    def __init__(self) -> None:
        ...

class BoneChain(StructBase):
    r"""
    Bone Chain
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRigDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``chain_name`` (Name):  [Read-Write]
    - ``end_bone`` (BoneReference):  [Read-Only]
    - ``ik_goal_name`` (Name):  [Read-Only]
    - ``start_bone`` (BoneReference):  [Read-Only]
    """
    def __init__(self, chain_name: Name = "None", ik_goal_name: Name = "None") -> None:
        ...
    @property
    def chain_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @chain_name.setter
    def chain_name(self, value: Name) -> None:
        ...
    @property
    def ik_goal_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...

class RetargetDefinition(StructBase):
    r"""
    Retarget Definition
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRigDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_chains`` (Array[BoneChain]):  [Read-Write]
    - ``root_bone`` (Name):  [Read-Write]
    """
    def __init__(self, root_bone: Name = "None", bone_chains: Array[BoneChain] = []) -> None:
        ...
    @property
    def root_bone(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @root_bone.setter
    def root_bone(self, value: Name) -> None:
        ...
    @property
    def bone_chains(self) -> Array[BoneChain]:
        r"""
        (Array[BoneChain]):  [Read-Write]
        """
        ...
    @bone_chains.setter
    def bone_chains(self, value: Array[BoneChain]) -> None:
        ...

class MovieSceneGeometryCollectionParams(StructBase):
    r"""
    Movie Scene Geometry Collection Params
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionTracks
    - **File**: MovieSceneGeometryCollectionSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_frame_offset`` (FrameNumber):  [Read-Write] The offset into the end of the animation clip
    - ``geometry_collection_cache`` (SoftObjectPath):  [Read-Write] The animation this section plays
    - ``play_rate`` (float):  [Read-Write] The playback rate of the animation clip
    - ``start_frame_offset`` (FrameNumber):  [Read-Write] The offset into the beginning of the animation clip
    """
    def __init__(self) -> None:
        ...

class LocalizableMessage(StructBase):
    r"""
    Localizable Message
    
    **C++ Source:**
    
    - **Plugin**: LocalizableMessage
    - **Module**: LocalizableMessage
    - **File**: LocalizableMessage.h
    
    """
    def __init__(self) -> None:
        ...

class MirrorOptions(StructBase):
    r"""
    FMirrorOptions
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolsetExp
    - **Module**: SkeletalMeshModifiers
    - **File**: SkeletonModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``left_string`` (str):  [Read-Write]
    - ``mirror_axis`` (AxisType):  [Read-Write]
    - ``mirror_children`` (bool):  [Read-Write]
    - ``mirror_rotation`` (bool):  [Read-Write]
    - ``right_string`` (str):  [Read-Write]
    """
    def __init__(self, mirror_axis: AxisType = AxisType.NONE, mirror_rotation: bool = False, left_string: str = "", right_string: str = "", mirror_children: bool = False) -> None:
        ...
    @property
    def mirror_axis(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write]
        """
        ...
    @mirror_axis.setter
    def mirror_axis(self, value: AxisType) -> None:
        ...
    @property
    def mirror_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @mirror_rotation.setter
    def mirror_rotation(self, value: bool) -> None:
        ...
    @property
    def left_string(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @left_string.setter
    def left_string(self, value: str) -> None:
        ...
    @property
    def right_string(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @right_string.setter
    def right_string(self, value: str) -> None:
        ...
    @property
    def mirror_children(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @mirror_children.setter
    def mirror_children(self, value: bool) -> None:
        ...

class OrientOptions(StructBase):
    r"""
    Orient Options
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolsetExp
    - **Module**: SkeletalMeshModifiers
    - **File**: SkeletonModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``orient_children`` (bool):  [Read-Write]
    - ``primary`` (OrientAxis):  [Read-Write]
    - ``secondary`` (OrientAxis):  [Read-Write]
    - ``secondary_target`` (Vector):  [Read-Write]
    - ``use_plane_as_secondary`` (bool):  [Read-Write]
    """
    def __init__(self, primary: OrientAxis = OrientAxis.NONE, secondary: OrientAxis = OrientAxis.NONE, use_plane_as_secondary: bool = False, secondary_target: Vector = [0.000000, 0.000000, 0.000000], orient_children: bool = False) -> None:
        ...
    @property
    def primary(self) -> OrientAxis:
        r"""
        (OrientAxis):  [Read-Write]
        """
        ...
    @primary.setter
    def primary(self, value: OrientAxis) -> None:
        ...
    @property
    def secondary(self) -> OrientAxis:
        r"""
        (OrientAxis):  [Read-Write]
        """
        ...
    @secondary.setter
    def secondary(self, value: OrientAxis) -> None:
        ...
    @property
    def use_plane_as_secondary(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @use_plane_as_secondary.setter
    def use_plane_as_secondary(self, value: bool) -> None:
        ...
    @property
    def secondary_target(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @secondary_target.setter
    def secondary_target(self, value: Vector) -> None:
        ...
    @property
    def orient_children(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @orient_children.setter
    def orient_children(self, value: bool) -> None:
        ...

class InteractiveToolPresetDefinition(StructBase):
    r"""
    Interactive Tool Preset Definition
    
    **C++ Source:**
    
    - **Plugin**: ToolPresets
    - **Module**: ToolPresetAsset
    - **File**: ToolPresetAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``label`` (str):  [Read-Write]
    - ``stored_properties`` (str):  [Read-Only]
    - ``tooltip`` (str):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class InteractiveToolPresetDefintion(InteractiveToolPresetDefinition):
    r"""
    deprecated: 'InteractiveToolPresetDefintion' was renamed to 'InteractiveToolPresetDefinition'.
    """
    def __init__(self) -> None:
        ...

class InteractiveToolPresetStore(StructBase):
    r"""
    Interactive Tool Preset Store
    
    **C++ Source:**
    
    - **Plugin**: ToolPresets
    - **Module**: ToolPresetAsset
    - **File**: ToolPresetAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``named_presets`` (Array[InteractiveToolPresetDefinition]):  [Read-Write]
    - ``tool_icon`` (SlateBrush):  [Read-Only]
    - ``tool_label`` (Text):  [Read-Only]
    """
    def __init__(self) -> None:
        ...

class AbcCompressionSettings(StructBase):
    r"""
    Abc Compression Settings
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bake_matrix_animation`` (bool):  [Read-Write] Whether or not Matrix-only animation should be baked out as vertex animation (or skipped?)
    - ``base_calculation_type`` (BaseCalculationType):  [Read-Write] Determines how the final number of bases that are stored as morph targets are calculated
    - ``max_number_of_bases`` (int32):  [Read-Write] Will generate given fixed number of bases as morph targets
    - ``merge_meshes`` (bool):  [Read-Write] Whether or not the individual meshes should be merged for compression purposes
    - ``minimum_number_of_vertex_influence_percentage`` (float):  [Read-Write] Minimum percentage of influenced vertices required for a morph target to be valid
    - ``percentage_of_total_bases`` (float):  [Read-Write] Will generate given percentage of the given bases as morph targets
    """
    def __init__(self, merge_meshes: bool = False, bake_matrix_animation: bool = False, base_calculation_type: BaseCalculationType = 0, percentage_of_total_bases: float = 0.000000, max_number_of_bases: int = 0, minimum_number_of_vertex_influence_percentage: float = 0.000000) -> None:
        ...
    @property
    def merge_meshes(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not the individual meshes should be merged for compression purposes
        """
        ...
    @merge_meshes.setter
    def merge_meshes(self, value: bool) -> None:
        ...
    @property
    def bake_matrix_animation(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not Matrix-only animation should be baked out as vertex animation (or skipped?)
        """
        ...
    @bake_matrix_animation.setter
    def bake_matrix_animation(self, value: bool) -> None:
        ...
    @property
    def base_calculation_type(self) -> BaseCalculationType:
        r"""
        (BaseCalculationType):  [Read-Write] Determines how the final number of bases that are stored as morph targets are calculated
        """
        ...
    @base_calculation_type.setter
    def base_calculation_type(self, value: BaseCalculationType) -> None:
        ...
    @property
    def percentage_of_total_bases(self) -> float:
        r"""
        (float):  [Read-Write] Will generate given percentage of the given bases as morph targets
        """
        ...
    @percentage_of_total_bases.setter
    def percentage_of_total_bases(self, value: float) -> None:
        ...
    @property
    def max_number_of_bases(self) -> int:
        r"""
        (int32):  [Read-Write] Will generate given fixed number of bases as morph targets
        """
        ...
    @max_number_of_bases.setter
    def max_number_of_bases(self, value: int) -> None:
        ...
    @property
    def minimum_number_of_vertex_influence_percentage(self) -> float:
        r"""
        (float):  [Read-Write] Minimum percentage of influenced vertices required for a morph target to be valid
        """
        ...
    @minimum_number_of_vertex_influence_percentage.setter
    def minimum_number_of_vertex_influence_percentage(self, value: float) -> None:
        ...

class AbcSamplingSettings(StructBase):
    r"""
    Abc Sampling Settings
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_end`` (int32):  [Read-Write] Ending index to stop sampling the animation at
    - ``frame_start`` (int32):  [Read-Write] Starting index to start sampling the animation from
    - ``frame_steps`` (int32):  [Read-Write] Steps to take when sampling the animation
    - ``sampling_type`` (AlembicSamplingType):  [Read-Write] Type of sampling performed while importing the animation
    - ``skip_empty`` (bool):  [Read-Write] Skip empty (pre-roll) frames and start importing at the frame which actually contains data
    - ``time_steps`` (float):  [Read-Write] Time steps to take when sampling the animation
    """
    def __init__(self, sampling_type: AlembicSamplingType = AlembicSamplingType.PER_FRAME, frame_steps: int = 0, time_steps: float = 0.000000, frame_start: int = 0, frame_end: int = 0, skip_empty: bool = False) -> None:
        ...
    @property
    def sampling_type(self) -> AlembicSamplingType:
        r"""
        (AlembicSamplingType):  [Read-Write] Type of sampling performed while importing the animation
        """
        ...
    @sampling_type.setter
    def sampling_type(self, value: AlembicSamplingType) -> None:
        ...
    @property
    def frame_steps(self) -> int:
        r"""
        (int32):  [Read-Write] Steps to take when sampling the animation
        """
        ...
    @frame_steps.setter
    def frame_steps(self, value: int) -> None:
        ...
    @property
    def time_steps(self) -> float:
        r"""
        (float):  [Read-Write] Time steps to take when sampling the animation
        """
        ...
    @time_steps.setter
    def time_steps(self, value: float) -> None:
        ...
    @property
    def frame_start(self) -> int:
        r"""
        (int32):  [Read-Write] Starting index to start sampling the animation from
        """
        ...
    @frame_start.setter
    def frame_start(self, value: int) -> None:
        ...
    @property
    def frame_end(self) -> int:
        r"""
        (int32):  [Read-Write] Ending index to stop sampling the animation at
        """
        ...
    @frame_end.setter
    def frame_end(self, value: int) -> None:
        ...
    @property
    def skip_empty(self) -> bool:
        r"""
        (bool):  [Read-Write] Skip empty (pre-roll) frames and start importing at the frame which actually contains data
        """
        ...
    @skip_empty.setter
    def skip_empty(self, value: bool) -> None:
        ...

class AbcNormalGenerationSettings(StructBase):
    r"""
    Abc Normal Generation Settings
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``force_one_smoothing_group_per_object`` (bool):  [Read-Write] Whether or not to force smooth normals for each individual object rather than calculating smoothing groups
    - ``hard_edge_angle_threshold`` (float):  [Read-Write] Threshold used to determine whether an angle between two normals should be considered hard, closer to 0 means more smooth vs 1
    - ``ignore_degenerate_triangles`` (bool):  [Read-Write] Determines whether or not the degenerate triangles should be ignored when calculating tangents/normals
    - ``recompute_normals`` (bool):  [Read-Write] Determines whether or not the normals should be forced to be recomputed
    - ``skip_computing_tangents`` (bool):  [Read-Write] Determines whether tangents are computed for GeometryCache. Skipping them can improve streaming performance but may cause visual artifacts where they are required
    """
    def __init__(self, force_one_smoothing_group_per_object: bool = False, hard_edge_angle_threshold: float = 0.000000, recompute_normals: bool = False, ignore_degenerate_triangles: bool = False, skip_computing_tangents: bool = False) -> None:
        ...
    @property
    def force_one_smoothing_group_per_object(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to force smooth normals for each individual object rather than calculating smoothing groups
        """
        ...
    @force_one_smoothing_group_per_object.setter
    def force_one_smoothing_group_per_object(self, value: bool) -> None:
        ...
    @property
    def hard_edge_angle_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Threshold used to determine whether an angle between two normals should be considered hard, closer to 0 means more smooth vs 1
        """
        ...
    @hard_edge_angle_threshold.setter
    def hard_edge_angle_threshold(self, value: float) -> None:
        ...
    @property
    def recompute_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] Determines whether or not the normals should be forced to be recomputed
        """
        ...
    @recompute_normals.setter
    def recompute_normals(self, value: bool) -> None:
        ...
    @property
    def ignore_degenerate_triangles(self) -> bool:
        r"""
        (bool):  [Read-Write] Determines whether or not the degenerate triangles should be ignored when calculating tangents/normals
        """
        ...
    @ignore_degenerate_triangles.setter
    def ignore_degenerate_triangles(self, value: bool) -> None:
        ...
    @property
    def skip_computing_tangents(self) -> bool:
        r"""
        (bool):  [Read-Write] Determines whether tangents are computed for GeometryCache. Skipping them can improve streaming performance but may cause visual artifacts where they are required
        """
        ...
    @skip_computing_tangents.setter
    def skip_computing_tangents(self, value: bool) -> None:
        ...

class AbcMaterialSettings(StructBase):
    r"""
    Abc Material Settings
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``create_materials`` (bool):  [Read-Write] Whether or not to create materials according to found Face Set names (will not work without face sets)
    - ``find_materials`` (bool):  [Read-Write] Whether or not to try and find materials according to found Face Set names (will not work without face sets)
    """
    def __init__(self, create_materials: bool = False, find_materials: bool = False) -> None:
        ...
    @property
    def create_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to create materials according to found Face Set names (will not work without face sets)
        """
        ...
    @create_materials.setter
    def create_materials(self, value: bool) -> None:
        ...
    @property
    def find_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to try and find materials according to found Face Set names (will not work without face sets)
        """
        ...
    @find_materials.setter
    def find_materials(self, value: bool) -> None:
        ...

class AbcStaticMeshSettings(StructBase):
    r"""
    Abc Static Mesh Settings
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``generate_lightmap_u_vs`` (bool):  [Read-Write] Flag for whether or not lightmap UVs should be generated
    - ``merge_meshes`` (bool):  [Read-Write] Whether or not to merge the static meshes on import (remember this can cause problems with overlapping UV-sets)
    - ``propagate_matrix_transformations`` (bool):  [Read-Write] This will, if applicable, apply matrix transformations to the meshes
    """
    def __init__(self, merge_meshes: bool = False, propagate_matrix_transformations: bool = False, generate_lightmap_u_vs: bool = False) -> None:
        ...
    @property
    def merge_meshes(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to merge the static meshes on import (remember this can cause problems with overlapping UV-sets)
        """
        ...
    @merge_meshes.setter
    def merge_meshes(self, value: bool) -> None:
        ...
    @property
    def propagate_matrix_transformations(self) -> bool:
        r"""
        (bool):  [Read-Write] This will, if applicable, apply matrix transformations to the meshes
        """
        ...
    @propagate_matrix_transformations.setter
    def propagate_matrix_transformations(self, value: bool) -> None:
        ...
    @property
    def generate_lightmap_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write] Flag for whether or not lightmap UVs should be generated
        """
        ...
    @generate_lightmap_u_vs.setter
    def generate_lightmap_u_vs(self, value: bool) -> None:
        ...

class AbcConversionSettings(StructBase):
    r"""
    Abc Conversion Settings
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``flip_u`` (bool):  [Read-Write] Flag whether or not to flip the U channel in the Texture Coordinates
    - ``flip_v`` (bool):  [Read-Write] Flag whether or not to flip the V channel in the Texture Coordinates
    - ``preset`` (AbcConversionPreset):  [Read-Write] Currently preset that should be applied
    - ``rotation`` (Vector):  [Read-Write] Rotation in Euler angles that should be applied
    - ``scale`` (Vector):  [Read-Write] Scale value that should be applied
    """
    def __init__(self, preset: AbcConversionPreset = AbcConversionPreset.MAYA, flip_u: bool = False, flip_v: bool = False, scale: Vector = [0.000000, 0.000000, 0.000000], rotation: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def preset(self) -> AbcConversionPreset:
        r"""
        (AbcConversionPreset):  [Read-Write] Currently preset that should be applied
        """
        ...
    @preset.setter
    def preset(self, value: AbcConversionPreset) -> None:
        ...
    @property
    def flip_u(self) -> bool:
        r"""
        (bool):  [Read-Write] Flag whether or not to flip the U channel in the Texture Coordinates
        """
        ...
    @flip_u.setter
    def flip_u(self, value: bool) -> None:
        ...
    @property
    def flip_v(self) -> bool:
        r"""
        (bool):  [Read-Write] Flag whether or not to flip the V channel in the Texture Coordinates
        """
        ...
    @flip_v.setter
    def flip_v(self, value: bool) -> None:
        ...
    @property
    def scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Scale value that should be applied
        """
        ...
    @scale.setter
    def scale(self, value: Vector) -> None:
        ...
    @property
    def rotation(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Rotation in Euler angles that should be applied
        """
        ...
    @rotation.setter
    def rotation(self, value: Vector) -> None:
        ...

class AbcGeometryCacheSettings(StructBase):
    r"""
    Abc Geometry Cache Settings
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_constant_topology_optimizations`` (bool):  [Read-Write] Force the preprocessor to only do optimization once instead of when the preprocessor decides. This may lead to some problems with certain meshes but makes sure motion
                blur always works if the topology is constant.
    - ``compressed_position_precision`` (float):  [Read-Write] Precision used for compressing vertex positions (lower = better result but less compression, higher = more lossy compression but smaller size)
    - ``compressed_texture_coordinates_number_of_bits`` (int32):  [Read-Write] Bit-precision used for compressing texture coordinates (hight = better result but less compression, lower = more lossy compression but smaller size)
    - ``flatten_tracks`` (bool):  [Read-Write] Whether or not to merge all vertex animation into one track
    - ``motion_vectors`` (AbcGeometryCacheMotionVectorsImport):  [Read-Write]
    - ``optimize_index_buffers`` (bool):  [Read-Write] Optimizes index buffers for each unique frame, to allow better cache coherency on the GPU. Very costly and time-consuming process, recommended to OFF.
    - ``store_imported_vertex_numbers`` (bool):  [Read-Write] Store the imported vertex numbers. This lets you know the vertex numbers inside the DCC.
      The values of each vertex number will range from 0 to 7 for a cube. Even if the number of positions might be 24.
    """
    def __init__(self, flatten_tracks: bool = False, store_imported_vertex_numbers: bool = False, apply_constant_topology_optimizations: bool = False, motion_vectors: AbcGeometryCacheMotionVectorsImport = AbcGeometryCacheMotionVectorsImport.NO_MOTION_VECTORS, optimize_index_buffers: bool = False, compressed_position_precision: float = 0.000000, compressed_texture_coordinates_number_of_bits: int = 0) -> None:
        ...
    @property
    def flatten_tracks(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to merge all vertex animation into one track
        """
        ...
    @flatten_tracks.setter
    def flatten_tracks(self, value: bool) -> None:
        ...
    @property
    def store_imported_vertex_numbers(self) -> bool:
        r"""
        (bool):  [Read-Write] Store the imported vertex numbers. This lets you know the vertex numbers inside the DCC.
        The values of each vertex number will range from 0 to 7 for a cube. Even if the number of positions might be 24.
        """
        ...
    @store_imported_vertex_numbers.setter
    def store_imported_vertex_numbers(self, value: bool) -> None:
        ...
    @property
    def apply_constant_topology_optimizations(self) -> bool:
        r"""
        (bool):  [Read-Write] Force the preprocessor to only do optimization once instead of when the preprocessor decides. This may lead to some problems with certain meshes but makes sure motion
                  blur always works if the topology is constant.
        """
        ...
    @apply_constant_topology_optimizations.setter
    def apply_constant_topology_optimizations(self, value: bool) -> None:
        ...
    @property
    def motion_vectors(self) -> AbcGeometryCacheMotionVectorsImport:
        r"""
        (AbcGeometryCacheMotionVectorsImport):  [Read-Write]
        """
        ...
    @motion_vectors.setter
    def motion_vectors(self, value: AbcGeometryCacheMotionVectorsImport) -> None:
        ...
    @property
    def optimize_index_buffers(self) -> bool:
        r"""
        (bool):  [Read-Write] Optimizes index buffers for each unique frame, to allow better cache coherency on the GPU. Very costly and time-consuming process, recommended to OFF.
        """
        ...
    @optimize_index_buffers.setter
    def optimize_index_buffers(self, value: bool) -> None:
        ...
    @property
    def compressed_position_precision(self) -> float:
        r"""
        (float):  [Read-Write] Precision used for compressing vertex positions (lower = better result but less compression, higher = more lossy compression but smaller size)
        """
        ...
    @compressed_position_precision.setter
    def compressed_position_precision(self, value: float) -> None:
        ...
    @property
    def compressed_texture_coordinates_number_of_bits(self) -> int:
        r"""
        (int32):  [Read-Write] Bit-precision used for compressing texture coordinates (hight = better result but less compression, lower = more lossy compression but smaller size)
        """
        ...
    @compressed_texture_coordinates_number_of_bits.setter
    def compressed_texture_coordinates_number_of_bits(self, value: int) -> None:
        ...

class ActorLayer(StructBase):
    r"""
    Actor Layer
    
    **C++ Source:**
    
    - **Plugin**: ActorLayerUtilities
    - **Module**: ActorLayerUtilities
    - **File**: ActorLayerUtilities.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Write] The name of this layer
    """
    def __init__(self, name: Name = "None") -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write] The name of this layer
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...

class AudioInputDeviceInfo(StructBase):
    r"""
    Platform audio input device info, in a Blueprint-readable format
    
    **C++ Source:**
    
    - **Plugin**: AudioCapture
    - **Module**: AudioCapture
    - **File**: AudioCaptureBlueprintLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``device_id`` (str):  [Read-Write] ID of the device.
    - ``device_name`` (str):  [Read-Write] The name of the audio device
    - ``input_channels`` (int32):  [Read-Write] The number of channels supported by the audio device
    - ``preferred_sample_rate`` (int32):  [Read-Write] The preferred sample rate of the audio device
    - ``supports_hardware_aec`` (bool):  [Read-Write] Whether or not the device supports Acoustic Echo Canceling
    """
    def __init__(self, device_name: str = "", device_id: str = "", input_channels: int = 0, preferred_sample_rate: int = 0, supports_hardware_aec: bool = False) -> None:
        ...
    @property
    def device_name(self) -> str:
        r"""
        (str):  [Read-Only] The name of the audio device
        """
        ...
    @property
    def device_id(self) -> str:
        r"""
        (str):  [Read-Only] ID of the device.
        """
        ...
    @property
    def input_channels(self) -> int:
        r"""
        (int32):  [Read-Only] The number of channels supported by the audio device
        """
        ...
    @property
    def preferred_sample_rate(self) -> int:
        r"""
        (int32):  [Read-Only] The preferred sample rate of the audio device
        """
        ...
    @property
    def supports_hardware_aec(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether or not the device supports Acoustic Echo Canceling
        """
        ...

class AudioCaptureDeviceInfo(StructBase):
    r"""
    Struct defining the time synth global quantization settings
    
    **C++ Source:**
    
    - **Plugin**: AudioCapture
    - **Module**: AudioCapture
    - **File**: AudioCapture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``device_name`` (Name):  [Read-Write] The name of the audio capture device
    - ``num_input_channels`` (int32):  [Read-Write] The number of input channels
    - ``sample_rate`` (int32):  [Read-Write] The sample rate of the audio capture device
    """
    def __init__(self, device_name: Name = "None", num_input_channels: int = 0, sample_rate: int = 0) -> None:
        ...
    @property
    def device_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of the audio capture device
        """
        ...
    @property
    def num_input_channels(self) -> int:
        r"""
        (int32):  [Read-Only] The number of input channels
        """
        ...
    @property
    def sample_rate(self) -> int:
        r"""
        (int32):  [Read-Only] The sample rate of the audio capture device
        """
        ...

class AppleImageUtilsImageConversionResult(StructBase):
    r"""
    Apple Image Utils Image Conversion Result
    
    **C++ Source:**
    
    - **Plugin**: AppleImageUtils
    - **Module**: AppleImageUtils
    - **File**: AppleImageUtilsBlueprintProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``error`` (str):  [Read-Write]
    - ``image_data`` (Array[uint8]):  [Read-Write]
    """
    def __init__(self, error: str = "", image_data: Array[int] = []) -> None:
        ...
    @property
    def error(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def image_data(self) -> Array[int]:
        r"""
        (Array[uint8]):  [Read-Only]
        """
        ...

class MovieSceneGeometryCacheParams(StructBase):
    r"""
    Movie Scene Geometry Cache Params
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCacheTracks
    - **File**: MovieSceneGeometryCacheSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_frame_offset`` (FrameNumber):  [Read-Write] The offset into the end of the animation clip
    - ``first_loop_start_frame_offset`` (FrameNumber):  [Read-Write] The offset for the first loop of the animation clip
    - ``geometry_cache_asset`` (GeometryCache):  [Read-Write] The animation this section plays
    - ``play_rate`` (float):  [Read-Write] The playback rate of the animation clip
    - ``reverse`` (bool):  [Read-Write] Reverse the playback of the animation clip
    - ``start_frame_offset`` (FrameNumber):  [Read-Write] The offset into the beginning of the animation clip
    """
    def __init__(self, geometry_cache_asset: GeometryCache = None, first_loop_start_frame_offset: FrameNumber = [0], start_frame_offset: FrameNumber = [0], end_frame_offset: FrameNumber = [0], play_rate: float = 0.000000, reverse: bool = False) -> None:
        ...
    @property
    def geometry_cache_asset(self) -> GeometryCache:
        r"""
        (GeometryCache):  [Read-Write] The animation this section plays
        """
        ...
    @geometry_cache_asset.setter
    def geometry_cache_asset(self, value: GeometryCache) -> None:
        ...
    @property
    def first_loop_start_frame_offset(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] The offset for the first loop of the animation clip
        """
        ...
    @first_loop_start_frame_offset.setter
    def first_loop_start_frame_offset(self, value: FrameNumber) -> None:
        ...
    @property
    def start_frame_offset(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] The offset into the beginning of the animation clip
        """
        ...
    @start_frame_offset.setter
    def start_frame_offset(self, value: FrameNumber) -> None:
        ...
    @property
    def end_frame_offset(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] The offset into the end of the animation clip
        """
        ...
    @end_frame_offset.setter
    def end_frame_offset(self, value: FrameNumber) -> None:
        ...
    @property
    def play_rate(self) -> float:
        r"""
        (float):  [Read-Write] The playback rate of the animation clip
        """
        ...
    @play_rate.setter
    def play_rate(self, value: float) -> None:
        ...
    @property
    def reverse(self) -> bool:
        r"""
        (bool):  [Read-Write] Reverse the playback of the animation clip
        """
        ...
    @reverse.setter
    def reverse(self, value: bool) -> None:
        ...

class MovieSceneGeometryCacheSectionTemplateParameters(MovieSceneGeometryCacheParams):
    r"""
    Movie Scene Geometry Cache Section Template Parameters
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCacheTracks
    - **File**: MovieSceneGeometryCacheTemplate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_frame_offset`` (FrameNumber):  [Read-Write] The offset into the end of the animation clip
    - ``first_loop_start_frame_offset`` (FrameNumber):  [Read-Write] The offset for the first loop of the animation clip
    - ``geometry_cache_asset`` (GeometryCache):  [Read-Write] The animation this section plays
    - ``play_rate`` (float):  [Read-Write] The playback rate of the animation clip
    - ``reverse`` (bool):  [Read-Write] Reverse the playback of the animation clip
    - ``start_frame_offset`` (FrameNumber):  [Read-Write] The offset into the beginning of the animation clip
    """
    def __init__(self, geometry_cache_asset: GeometryCache = None, first_loop_start_frame_offset: FrameNumber = [0], start_frame_offset: FrameNumber = [0], end_frame_offset: FrameNumber = [0], play_rate: float = 0.000000, reverse: bool = False) -> None:
        ...

class DynamicMeshChangeInfo(StructBase):
    r"""
    FDynamicMeshChangeInfo stores information about a change to a UDynamicMesh.
    This struct is emitted by the UDynamicMesh OnPreMeshChanged() and OnMeshChanged() delegates.
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: UDynamicMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``flags`` (DynamicMeshAttributeChangeFlags):  [Read-Write]
    - ``is_revert_change`` (bool):  [Read-Write] for changes that are an FChange, indicates whether this is an 'Apply' or 'Revert' of the FChange
    - ``type`` (DynamicMeshChangeType):  [Read-Write]
    """
    def __init__(self, type: DynamicMeshChangeType = DynamicMeshChangeType.GENERAL_EDIT, flags: DynamicMeshAttributeChangeFlags = DynamicMeshAttributeChangeFlags.UNKNOWN, is_revert_change: bool = False) -> None:
        ...
    @property
    def type(self) -> DynamicMeshChangeType:
        r"""
        (DynamicMeshChangeType):  [Read-Only]
        """
        ...
    @property
    def flags(self) -> DynamicMeshAttributeChangeFlags:
        r"""
        (DynamicMeshAttributeChangeFlags):  [Read-Only]
        """
        ...
    @property
    def is_revert_change(self) -> bool:
        r"""
        (bool):  [Read-Only] for changes that are an FChange, indicates whether this is an 'Apply' or 'Revert' of the FChange
        """
        ...

class ModelingToolsAxisFilter(StructBase):
    r"""
    Modeling Tools Axis Filter
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: AxisFilterPropertyType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis_x`` (bool):  [Read-Write] X Axis
    - ``axis_y`` (bool):  [Read-Write] Y Axis
    - ``axis_z`` (bool):  [Read-Write] Z Axis
    """
    def __init__(self) -> None:
        ...

class ModelingToolsColorChannelFilter(StructBase):
    r"""
    Modeling Tools Color Channel Filter
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ColorChannelFilterPropertyType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (bool):  [Read-Write] Alpha Channel
    - ``blue`` (bool):  [Read-Write] Blue Channel
    - ``green`` (bool):  [Read-Write] Green Channel
    - ``red`` (bool):  [Read-Write] Red Channel
    """
    def __init__(self) -> None:
        ...

class CreateMeshObjectParams(StructBase):
    r"""
    FCreateMeshObjectParams is a collection of input data intended to be passed to
    UModelingObjectsCreationAPI::CreateMeshObject(). Not all data necessarily needs
    to be specified, this will depend on the particular implementation. The comments
    below are representative of how this data structure is used in the Tools and
    API implementation(s) provided with Unreal Engine, but end-user implementors
    could abuse these fields as necessary.
    
    The definition of a "mesh object" is implementation-specific.
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_materials`` (Array[MaterialInterface]):  [Read-Write] Optional Materials for a newly-created Mesh Asset, if this is applicable for the created mesh object
    - ``base_name`` (str):  [Read-Write] The base name of the new mesh object
    - ``collision_mode`` (CollisionTraceFlag):  [Read-Write] Which Collision mode to enable on the new mesh object, if supported
    - ``enable_collision`` (bool):  [Read-Write] Specify whether the new mesh object should have collision support/data
    - ``enable_nanite`` (bool):  [Read-Write] Specify whether Nanite should be enabled on this new mesh object
    - ``enable_raytracing_support`` (bool):  [Read-Write] Specify whether normals should be automatically recomputed for this new mesh object
    - ``enable_recompute_normals`` (bool):  [Read-Write] Specify whether normals should be automatically recomputed for this new mesh object
    - ``enable_recompute_tangents`` (bool):  [Read-Write] Specify whether tangents should be automatically recomputed for this new mesh object
    - ``generate_lightmap_u_vs`` (bool):  [Read-Write] Specify whether to auto-generate Lightmap UVs (if applicable for the output mesh type)
    - ``materials`` (Array[MaterialInterface]):  [Read-Write] Materials for the new mesh object
    - ``nanite_proxy_triangle_percent`` (float):  [Read-Write] Specify the Nanite proxy triangle percentage for this new mesh object
      deprecated: Replaced NaniteProxyTrianglePercent with usage of Engine FMeshNaniteSettings
    - ``nanite_settings`` (MeshNaniteSettings):  [Read-Write] Specify the Nanite Settings for this new mesh object, only used if bEnableNanite=true
    - ``source_component`` (PrimitiveComponent):  [Read-Write] A Source Component the new mesh is based on, if such a Component exists
    - ``target_world`` (World):  [Read-Write] The World/Level the new mesh object should be created in (if known)
    - ``transform`` (Transform):  [Read-Write] The 3D local-to-world transform for the new mesh object
    - ``type_hint`` (CreateObjectTypeHint):  [Read-Write] A suggested type for the newly-created Mesh (possibly ignored)
    - ``type_hint_class`` (type(Class)):  [Read-Write] A suggested UClass type for the newly-created Object (possibly ignored)
    - ``type_hint_extended`` (int32):  [Read-Write] An arbitrary integer that can be used to pass data to an API implementation
    """
    def __init__(self) -> None:
        ...
    @property
    def nanite_proxy_triangle_percent(self) -> float:
        r"""
        (float):  [Read-Write] Specify the Nanite proxy triangle percentage for this new mesh object
        deprecated: Replaced NaniteProxyTrianglePercent with usage of Engine FMeshNaniteSettings
        """
        ...
    @nanite_proxy_triangle_percent.setter
    def nanite_proxy_triangle_percent(self, value: float) -> None:
        ...

class CreateMeshObjectResult(StructBase):
    r"""
    FCreateMeshObjectResult is returned by UModelingObjectsCreationAPI::CreateMeshObject()
    to indicate success/failure and provide information about created mesh objects
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``new_actor`` (Actor):  [Read-Only] A pointer to a newly-created Actor for the mesh object, if applicable (eg StaticMeshActor)
    - ``new_asset`` (Object):  [Read-Only] A pointer to a newly-created Asset for the mesh object, if applicable (eg StaticMeshAsset)
    - ``new_component`` (PrimitiveComponent):  [Read-Only] A pointer to a newly-created PrimitiveComponent for the mesh object, if applicable (eg StaticMeshComponent)
    - ``result_code`` (CreateModelingObjectResult):  [Read-Only] Success/Failure status for the requested operation
    """
    def __init__(self) -> None:
        ...

class CreateTextureObjectParams(StructBase):
    r"""
    FCreateTextureObjectParams is a collection of input data intended to be passed to
    UModelingObjectsCreationAPI::CreateTextureObject(). Not all data necessarily needs
    to be specified, this will depend on the particular implementation. The comments
    below are representative of how this data structure is used in the Tools and
    API implementation(s) provided with Unreal Engine, but end-user implementors
    could abuse these fields as necessary.
    
    The definition of a "texture object" is implementation-specific.
    In the UE Editor this is generally a UTexture2D
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_name`` (str):  [Read-Write] The base name of the new mesh object
    - ``generated_transient_texture`` (Texture2D):  [Read-Write] Texture source data. Generally assumed that this is a Texture created in the Transient package
      that is intended to be saved in a permanent package.
    - ``store_relative_to_object`` (Object):  [Read-Write] An object to store the Texture relative to. For example the texture could be stored at the same path.
    - ``target_world`` (World):  [Read-Write] The World/Level the new texture object should be created in (if known).
      Note that Textures generally do not exist as objects in a Level.
      However, it may be necessary to store the texture in a path relative to the
      level (for example if the level is in a Plugin, this would be necessary in-Editor)
    - ``type_hint_extended`` (int32):  [Read-Write] An arbitrary integer that can be used to pass data to an API implementation
    """
    def __init__(self) -> None:
        ...

class CreateTextureObjectResult(StructBase):
    r"""
    FCreateTextureObjectResult is returned by UModelingObjectsCreationAPI::CreateTextureObject()
    to indicate success/failure and provide information about created texture objects
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``new_asset`` (Object):  [Read-Only] A pointer to a newly-created Asset for the texture object
    - ``result_code`` (CreateModelingObjectResult):  [Read-Only] Success/Failure status for the requested operation
    """
    def __init__(self) -> None:
        ...

class CreateMaterialObjectParams(StructBase):
    r"""
    FCreateMaterialObjectParams is a collection of input data intended to be passed to
    UModelingObjectsCreationAPI::CreateMaterialObject().
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_name`` (str):  [Read-Write] The base name of the new Material object
    - ``material_to_duplicate`` (MaterialInterface):  [Read-Write] The parent UMaterial of this material will be duplicated to create the new UMaterial Asset.
    - ``store_relative_to_object`` (Object):  [Read-Write] An object to store the Material relative to.
    - ``target_world`` (World):  [Read-Write] The World/Level the new Material object should be created in (if known).
      Note that Material generally do not exist as objects in a Level.
      However, it may be necessary to store the texture in a path relative to the
      level (for example if the level is in a Plugin, this would be necessary in-Editor)
    """
    def __init__(self) -> None:
        ...

class CreateMaterialObjectResult(StructBase):
    r"""
    FCreateMaterialObjectResult is returned by UModelingObjectsCreationAPI::CreateMaterialObject()
    to indicate success/failure and provide information about created texture objects
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``new_asset`` (Object):  [Read-Only] A pointer to a newly-created Asset for the material object
    - ``result_code`` (CreateModelingObjectResult):  [Read-Only] Success/Failure status for the requested operation
    """
    def __init__(self) -> None:
        ...

class CreateActorParams(StructBase):
    r"""
    FCreateActorParams is a collection of input data intended to be passed to
    UModelingObjectsCreationAPI::CreateNewActor().
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_name`` (str):  [Read-Write] The base name of the new Actor
    - ``target_world`` (World):  [Read-Write] The World/Level the new Actor should be created in (if known).
    - ``template_actor`` (Actor):  [Read-Write] input data
      deprecated: TemplateActor is being deprecated. Please use TemplateAsset instead.
    - ``template_asset`` (Object):  [Read-Write] A template Asset used to determine the type of Actor to spawn.
    - ``transform`` (Transform):  [Read-Write] The 3D local-to-world transform for the new actor
    """
    def __init__(self) -> None:
        ...
    @property
    def template_actor(self) -> Actor:
        r"""
        (Actor):  [Read-Write] input data
        deprecated: TemplateActor is being deprecated. Please use TemplateAsset instead.
        """
        ...
    @template_actor.setter
    def template_actor(self, value: Actor) -> None:
        ...

class CreateActorResult(StructBase):
    r"""
    FCreateActorResult is returned by UModelingObjectsCreationAPI::FCreateActorParams()
    to indicate success/failure and provide information about created actors
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``new_actor`` (Actor):  [Read-Only] A pointer to a newly-created Actor
    - ``result_code`` (CreateModelingObjectResult):  [Read-Only] Success/Failure status for the requested operation
    """
    def __init__(self) -> None:
        ...

class CapturableProperty(StructBase):
    r"""
    Describes a property path that can be captured. It just exposes a display name but
    uses internal data in order to be able to capture exception properties, like materials
    
    **C++ Source:**
    
    - **Plugin**: VariantManager
    - **Module**: VariantManager
    - **File**: CapturableProperty.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (str):  [Read-Only]
    """
    def __init__(self, display_name: str = "") -> None:
        ...
    @property
    def display_name(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class MediaTextureResourceSettings(StructBase):
    r"""
    This struct is used to expose Media Texture settings via Media Plate Component and is a mirror of some
    of the settings.
    
    **C++ Source:**
    
    - **Plugin**: MediaPlate
    - **Module**: MediaPlate
    - **File**: MediaPlateComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``current_num_mips`` (uint8):  [Read-Write] Current number of mips to be generated as output
    - ``enable_gen_mips`` (bool):  [Read-Write] Enable mips generation
    """
    def __init__(self) -> None:
        ...

class SequencerScriptingRange(StructBase):
    r"""
    Sequencer Scripting Range
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: SequencerScriptingRange.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``exclusive_end`` (int32):  [Read-Write]
    - ``has_end_value`` (bool):  [Read-Write]
    - ``has_start_value`` (bool):  [Read-Write]
    - ``inclusive_start`` (int32):  [Read-Write]
    """
    def __init__(self, has_start_value: bool = False, has_end_value: bool = False, inclusive_start: int = 0, exclusive_end: int = 0) -> None:
        ...
    @property
    def has_start_value(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @has_start_value.setter
    def has_start_value(self, value: bool) -> None:
        ...
    @property
    def has_end_value(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @has_end_value.setter
    def has_end_value(self, value: bool) -> None:
        ...
    @property
    def inclusive_start(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @inclusive_start.setter
    def inclusive_start(self, value: int) -> None:
        ...
    @property
    def exclusive_end(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @exclusive_end.setter
    def exclusive_end(self, value: int) -> None:
        ...
    def set_start_seconds(self, start: float) -> None:
        r"""
        x.set_start_seconds(start) -> None
        Set the starting time for the specified range in seconds. Interpreted as the first valid time that is inside the range.
        
        Args:
            start (float):
        """
        ...
    def set_start_frame(self, start: int) -> None:
        r"""
        x.set_start_frame(start) -> None
        Set the starting frame for the specified range. Interpreted as the first valid frame that is inside the range.
        
        Args:
            start (int32):
        """
        ...
    def set_end_seconds(self, end: float) -> None:
        r"""
        x.set_end_seconds(end) -> None
        Set the ending time for the specified range in seconds. Interpreted as the first time that is outside of the range.
        
        Args:
            end (float):
        """
        ...
    def set_end_frame(self, end: int) -> None:
        r"""
        x.set_end_frame(end) -> None
        Set the ending frame for the specified range. Interpreted as the first subsequent frame that is outside of the range.
        
        Args:
            end (int32):
        """
        ...
    def remove_start(self) -> None:
        r"""
        x.remove_start() -> None
        Remove the start from this range, making it infinite
        """
        ...
    def remove_end(self) -> None:
        r"""
        x.remove_end() -> None
        Remove the end from this range, making it infinite
        """
        ...
    def has_start(self) -> bool:
        r"""
        x.has_start() -> bool
        Check whether this range has a start
        
        Returns:
            bool:
        """
        ...
    def has_end(self) -> bool:
        r"""
        x.has_end() -> bool
        Check whether this range has an end
        
        Returns:
            bool:
        """
        ...
    def get_start_seconds(self) -> float:
        r"""
        x.get_start_seconds() -> float
        Get the starting time for the specified range in seconds, if it has one. Defined as the first valid time that is inside the range.
        
        Returns:
            float:
        """
        ...
    def get_start_frame(self) -> int:
        r"""
        x.get_start_frame() -> int32
        Get the starting frame for the specified range, if it has one. Defined as the first valid frame that is inside the range.
        
        Returns:
            int32:
        """
        ...
    def get_end_seconds(self) -> float:
        r"""
        x.get_end_seconds() -> float
        Get the ending time for the specified range in seconds, if it has one. Defined as the first time that is outside of the range.
        
        Returns:
            float:
        """
        ...
    def get_end_frame(self) -> int:
        r"""
        x.get_end_frame() -> int32
        Get the ending frame for the specified range, if it has one. Defined as the first subsequent frame that is outside of the range.
        
        Returns:
            int32:
        """
        ...

class SequencerChannelProxy(StructBase):
    r"""
    Sequencer Channel Proxy
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScriptingEditor
    - **File**: SequencerCurveEditorObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_name`` (Name):  [Read-Write]
    - ``section`` (MovieSceneSection):  [Read-Write]
    """
    def __init__(self, channel_name: Name = "None", section: MovieSceneSection = None) -> None:
        ...
    @property
    def channel_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @channel_name.setter
    def channel_name(self, value: Name) -> None:
        ...
    @property
    def section(self) -> MovieSceneSection:
        r"""
        (MovieSceneSection):  [Read-Write]
        """
        ...
    @section.setter
    def section(self, value: MovieSceneSection) -> None:
        ...

class SequencerBoundObjects(StructBase):
    r"""
    Sequencer Bound Objects
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScriptingEditor
    - **File**: SequencerTools.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``binding_proxy`` (MovieSceneBindingProxy):  [Read-Write]
    - ``bound_objects`` (Array[Object]):  [Read-Write]
    """
    def __init__(self, binding_proxy: MovieSceneBindingProxy = [[], None], bound_objects: Array[Object] = []) -> None:
        ...
    @property
    def binding_proxy(self) -> MovieSceneBindingProxy:
        r"""
        (MovieSceneBindingProxy):  [Read-Write]
        """
        ...
    @binding_proxy.setter
    def binding_proxy(self, value: MovieSceneBindingProxy) -> None:
        ...
    @property
    def bound_objects(self) -> Array[Object]:
        r"""
        (Array[Object]):  [Read-Write]
        """
        ...
    @bound_objects.setter
    def bound_objects(self, value: Array[Object]) -> None:
        ...

class SequencerQuickBindingResult(StructBase):
    r"""
    Wrapper around result of quick binding for event track in sequencer.
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScriptingEditor
    - **File**: SequencerTools.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``payload_names`` (Array[str]):  [Read-Write] Names of the payload variables of the event.
    """
    def __init__(self, payload_names: Array[str] = []) -> None:
        ...
    @property
    def payload_names(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Only] Names of the payload variables of the event.
        """
        ...

class SequencerExportFBXParams(StructBase):
    r"""
    Sequencer Export FBXParams
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScriptingEditor
    - **File**: SequencerTools.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bindings`` (Array[MovieSceneBindingProxy]):  [Read-Write]
    - ``fbx_file_name`` (str):  [Read-Write]
    - ``override_options`` (FbxExportOption):  [Read-Write]
    - ``root_sequence`` (LevelSequence):  [Read-Write]
    - ``sequence`` (LevelSequence):  [Read-Write]
    - ``tracks`` (Array[MovieSceneTrack]):  [Read-Write]
    - ``world`` (World):  [Read-Write]
    """
    def __init__(self, world: World = None, sequence: LevelSequence = None, root_sequence: LevelSequence = None, bindings: Array[MovieSceneBindingProxy] = [], tracks: Array[MovieSceneTrack] = [], override_options: FbxExportOption = None, fbx_file_name: str = "") -> None:
        ...
    @property
    def world(self) -> World:
        r"""
        (World):  [Read-Write]
        """
        ...
    @world.setter
    def world(self, value: World) -> None:
        ...
    @property
    def sequence(self) -> LevelSequence:
        r"""
        (LevelSequence):  [Read-Write]
        """
        ...
    @sequence.setter
    def sequence(self, value: LevelSequence) -> None:
        ...
    @property
    def root_sequence(self) -> LevelSequence:
        r"""
        (LevelSequence):  [Read-Write]
        """
        ...
    @root_sequence.setter
    def root_sequence(self, value: LevelSequence) -> None:
        ...
    @property
    def bindings(self) -> Array[MovieSceneBindingProxy]:
        r"""
        (Array[MovieSceneBindingProxy]):  [Read-Write]
        """
        ...
    @bindings.setter
    def bindings(self, value: Array[MovieSceneBindingProxy]) -> None:
        ...
    @property
    def tracks(self) -> Array[MovieSceneTrack]:
        r"""
        (Array[MovieSceneTrack]):  [Read-Write]
        """
        ...
    @tracks.setter
    def tracks(self, value: Array[MovieSceneTrack]) -> None:
        ...
    @property
    def override_options(self) -> FbxExportOption:
        r"""
        (FbxExportOption):  [Read-Write]
        """
        ...
    @override_options.setter
    def override_options(self, value: FbxExportOption) -> None:
        ...
    @property
    def fbx_file_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @fbx_file_name.setter
    def fbx_file_name(self, value: str) -> None:
        ...

class ImgMediaSourceCustomizationSequenceProxy(StructBase):
    r"""
    This provides customized editing of SequencePath.
    
    **C++ Source:**
    
    - **Plugin**: ImgMedia
    - **Module**: ImgMedia
    - **File**: ImgMediaSource.h
    
    """
    def __init__(self) -> None:
        ...

class InterchangeTestFunction(StructBase):
    r"""
    Interchange Test Function
    
    **C++ Source:**
    
    - **Plugin**: InterchangeTests
    - **Module**: InterchangeTests
    - **File**: InterchangeTestFunction.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_class`` (type(Class)):  [Read-Write] Type of the asset being tested
    - ``check_function`` (Function):  [Read-Write] A function to be called to determine whether the result is correct
    - ``optional_asset_name`` (str):  [Read-Write] Optional name of the asset to test, if there are various contenders
    - ``parameters`` (Map[Name, str]):  [Read-Write] Parameters and their bound values as text
    """
    def __init__(self) -> None:
        ...

class BoneReferencePair(StructBase):
    r"""
    Bone Reference Pair
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: CopyBonesModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source_bone`` (BoneReference):  [Read-Write] Bone to get transform from
    - ``target_bone`` (BoneReference):  [Read-Write] Bone to update with the transform copied from SourceBone
    """
    def __init__(self) -> None:
        ...

class FootDefinition(StructBase):
    r"""
    Foot Definition
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: FootstepAnimEventsModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``foot_bone_name`` (Name):  [Read-Write]
    - ``footstep_notify`` (type(Class)):  [Read-Write]
    - ``footstep_notify_detection_technique`` (DetectionTechnique):  [Read-Write]
    - ``footstep_notify_track_name`` (Name):  [Read-Write]
    - ``reference_bone_name`` (Name):  [Read-Write]
    - ``should_generate_notifies`` (bool):  [Read-Write]
    - ``should_generate_sync_markers`` (bool):  [Read-Write]
    - ``sync_marker_detection_technique`` (DetectionTechnique):  [Read-Write]
    - ``sync_marker_name`` (Name):  [Read-Write]
    - ``sync_marker_track_name`` (Name):  [Read-Write]
    """
    def __init__(self, reference_bone_name: Name = "None") -> None:
        ...
    @property
    def reference_bone_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...

class EncodeRootBoneWeightedBone(StructBase):
    r"""
    Encode Root Bone Weighted Bone
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: EncodeRootBoneModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (BoneReference):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class EncodeRootBoneWeightedBoneAxis(EncodeRootBoneWeightedBone):
    r"""
    Encode Root Bone Weighted Bone Axis
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: EncodeRootBoneModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (BoneReference):  [Read-Write]
    - ``bone_axis`` (EncodeRootBoneAxis):  [Read-Write]
    - ``weight`` (float):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class ControlRigSpline(StructBase):
    r"""
    Control Rig Spline
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineTypes.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_ControlRigSplineBase(RigUnit):
    r"""
    Rig Unit Control Rig Spline Base
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    """
    def __init__(self) -> None:
        ...

class RigUnit_ControlRigSplineFromPoints(RigUnit_ControlRigSplineBase):
    r"""
    * Creates a Spline curve from an array of positions
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``closed`` (bool):  [Read-Write]
    - ``compression`` (float):  [Read-Write]
    - ``points`` (Array[Vector]):  [Read-Write]
    - ``samples_per_segment`` (int32):  [Read-Write]
    - ``spline`` (ControlRigSpline):  [Read-Write]
    - ``spline_mode`` (SplineType):  [Read-Write]
    - ``stretch`` (float):  [Read-Write]
    """
    def __init__(self, points: Array[Vector] = [], spline_mode: SplineType = SplineType.B_SPLINE, closed: bool = False, samples_per_segment: int = 0, compression: float = 0.000000, stretch: float = 0.000000, spline: ControlRigSpline = []) -> None:
        ...
    @property
    def points(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Write]
        """
        ...
    @points.setter
    def points(self, value: Array[Vector]) -> None:
        ...
    @property
    def spline_mode(self) -> SplineType:
        r"""
        (SplineType):  [Read-Write]
        """
        ...
    @spline_mode.setter
    def spline_mode(self, value: SplineType) -> None:
        ...
    @property
    def closed(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @closed.setter
    def closed(self, value: bool) -> None:
        ...
    @property
    def samples_per_segment(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @samples_per_segment.setter
    def samples_per_segment(self, value: int) -> None:
        ...
    @property
    def compression(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @compression.setter
    def compression(self, value: float) -> None:
        ...
    @property
    def stretch(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @stretch.setter
    def stretch(self, value: float) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Only]
        """
        ...

class RigUnit_ControlRigSplineFromTransforms(RigUnit_ControlRigSplineBase):
    r"""
    * Creates a Spline curve from an array of positions
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``closed`` (bool):  [Read-Write]
    - ``compression`` (float):  [Read-Write]
    - ``samples_per_segment`` (int32):  [Read-Write]
    - ``spline`` (ControlRigSpline):  [Read-Write]
    - ``spline_mode`` (SplineType):  [Read-Write]
    - ``stretch`` (float):  [Read-Write]
    - ``transforms`` (Array[Transform]):  [Read-Write]
    """
    def __init__(self, transforms: Array[Transform] = [], spline_mode: SplineType = SplineType.B_SPLINE, closed: bool = False, samples_per_segment: int = 0, compression: float = 0.000000, stretch: float = 0.000000, spline: ControlRigSpline = []) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write]
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def spline_mode(self) -> SplineType:
        r"""
        (SplineType):  [Read-Write]
        """
        ...
    @spline_mode.setter
    def spline_mode(self, value: SplineType) -> None:
        ...
    @property
    def closed(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @closed.setter
    def closed(self, value: bool) -> None:
        ...
    @property
    def samples_per_segment(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @samples_per_segment.setter
    def samples_per_segment(self, value: int) -> None:
        ...
    @property
    def compression(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @compression.setter
    def compression(self, value: float) -> None:
        ...
    @property
    def stretch(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @stretch.setter
    def stretch(self, value: float) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Only]
        """
        ...

class RigUnit_SetSplinePoints(RigUnitMutable):
    r"""
    * Set the points of a spline, given a spline and an array of positions
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``points`` (Array[Vector]):  [Read-Write]
    - ``spline`` (ControlRigSpline):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], points: Array[Vector] = [], spline: ControlRigSpline = []) -> None:
        ...
    @property
    def points(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Write]
        """
        ...
    @points.setter
    def points(self, value: Array[Vector]) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write]
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...

class RigUnit_SetSplineTransforms(RigUnitMutable):
    r"""
    * Set the points of a spline, given a spline and an array of positions
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``spline`` (ControlRigSpline):  [Read-Write]
    - ``transforms`` (Array[Transform]):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], transforms: Array[Transform] = [], spline: ControlRigSpline = []) -> None:
        ...
    @property
    def transforms(self) -> Array[Transform]:
        r"""
        (Array[Transform]):  [Read-Write]
        """
        ...
    @transforms.setter
    def transforms(self, value: Array[Transform]) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write]
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...

class RigUnit_PositionFromControlRigSpline(RigUnit_ControlRigSplineBase):
    r"""
    * Retrieves the position from a given Spline and U value
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``position`` (Vector):  [Read-Write]
    - ``spline`` (ControlRigSpline):  [Read-Write]
    - ``u`` (float):  [Read-Write]
    """
    def __init__(self, spline: ControlRigSpline = [], u: float = 0.000000, position: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write]
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def u(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @u.setter
    def u(self, value: float) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_TransformFromControlRigSpline(RigUnit_ControlRigSplineBase):
    r"""
    * Retrieves the transform from a given Spline and U value based on the given Up Vector and Roll
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``roll`` (float):  [Read-Write]
    - ``spline`` (ControlRigSpline):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``u`` (float):  [Read-Write]
    - ``up_vector`` (Vector):  [Read-Write]
    """
    def __init__(self, spline: ControlRigSpline = [], up_vector: Vector = [0.000000, 0.000000, 0.000000], roll: float = 0.000000, u: float = 0.000000, transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write]
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def up_vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @up_vector.setter
    def up_vector(self, value: Vector) -> None:
        ...
    @property
    def roll(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @roll.setter
    def roll(self, value: float) -> None:
        ...
    @property
    def u(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @u.setter
    def u(self, value: float) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_TransformFromControlRigSpline2(RigUnit_ControlRigSplineBase):
    r"""
    * Retrieves the transform from a given Spline and U value based on the given Up Vector and Roll
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``primary_axis`` (Vector):  [Read-Write]
    - ``secondary_axis`` (Vector):  [Read-Write]
    - ``spline`` (ControlRigSpline):  [Read-Write]
    - ``transform`` (Transform):  [Read-Write]
    - ``u`` (float):  [Read-Write]
    """
    def __init__(self, spline: ControlRigSpline = [], u: float = 0.000000, primary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis: Vector = [0.000000, 0.000000, 0.000000], transform: Transform = [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write]
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def u(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @u.setter
    def u(self, value: float) -> None:
        ...
    @property
    def primary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @secondary_axis.setter
    def secondary_axis(self, value: Vector) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...

class RigUnit_TangentFromControlRigSpline(RigUnit_ControlRigSplineBase):
    r"""
    * Retrieves the tangent from a given Spline and U value
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``spline`` (ControlRigSpline):  [Read-Write]
    - ``tangent`` (Vector):  [Read-Write]
    - ``u`` (float):  [Read-Write]
    """
    def __init__(self, spline: ControlRigSpline = [], u: float = 0.000000, tangent: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write]
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def u(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @u.setter
    def u(self, value: float) -> None:
        ...
    @property
    def tangent(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...

class RigUnit_DrawControlRigSpline(RigUnitMutable):
    r"""
    * Draws the given spline in the viewport
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color`` (LinearColor):  [Read-Write]
    - ``detail`` (int32):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``spline`` (ControlRigSpline):  [Read-Write]
    - ``thickness`` (float):  [Read-Write]
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], spline: ControlRigSpline = [], color: LinearColor = [0.000000, 0.000000, 0.000000, 0.000000], thickness: float = 0.000000, detail: int = 0) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write]
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def thickness(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @thickness.setter
    def thickness(self, value: float) -> None:
        ...
    @property
    def detail(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @detail.setter
    def detail(self, value: int) -> None:
        ...

class RigUnit_GetLengthControlRigSpline(RigUnit):
    r"""
    * Retrieves the length from a given Splin
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``length`` (float):  [Read-Write]
    - ``spline`` (ControlRigSpline):  [Read-Write]
    """
    def __init__(self, spline: ControlRigSpline = [], length: float = 0.000000) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write]
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def length(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_GetLengthAtParamControlRigSpline(RigUnit):
    r"""
    * Retrieves the length from a given Splin
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``length`` (float):  [Read-Write]
    - ``spline`` (ControlRigSpline):  [Read-Write]
    - ``u`` (float):  [Read-Write]
    """
    def __init__(self, spline: ControlRigSpline = [], u: float = 0.000000, length: float = 0.000000) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write]
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def u(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @u.setter
    def u(self, value: float) -> None:
        ...
    @property
    def length(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_FitChainToSplineCurve(RigUnit_HighlevelBaseMutable):
    r"""
    Fits a given chain to a spline curve.
    Additionally provides rotational control matching the features of the Distribute Rotation node.
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alignment`` (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
    - ``debug_settings`` (RigUnit_FitChainToCurve_DebugSettings):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (RigElementKeyCollection):  [Read-Write] The items to align
    - ``maximum`` (float):  [Read-Only] The maximum U value to use on the curve
    - ``minimum`` (float):  [Read-Only] The minimum U value to use on the curve
    - ``pole_vector_position`` (Vector):  [Read-Write] The the position of the pole vector used for aligning the secondary axis.
      Only has an effect if the secondary axis is set.
    - ``primary_axis`` (Vector):  [Read-Write] The major axis being aligned - along the bone
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``rotation_ease_type`` (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
    - ``rotations`` (Array[RigUnit_FitChainToCurve_Rotation]):  [Read-Write] The list of rotations to be applied along the curve
    - ``sampling_precision`` (int32):  [Read-Only] The number of samples to use on the curve. Clamped at 64.
    - ``secondary_axis`` (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector.
      You can use (0.0, 0.0, 0.0) to disable it.
    - ``spline`` (ControlRigSpline):  [Read-Write] The curve to align to
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: RigElementKeyCollection = [[]], spline: ControlRigSpline = [], alignment: ControlRigCurveAlignment = ControlRigCurveAlignment.FRONT, minimum: float = 0.000000, maximum: float = 0.000000, sampling_precision: int = 0, primary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis: Vector = [0.000000, 0.000000, 0.000000], pole_vector_position: Vector = [0.000000, 0.000000, 0.000000], rotations: Array[RigUnit_FitChainToCurve_Rotation] = [], rotation_ease_type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, weight: float = 0.000000, propagate_to_children: bool = False, debug_settings: RigUnit_FitChainToCurve_DebugSettings = [False, 1.000000, [1.000000, 1.000000, 0.000000, 1.000000], [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] The items to align
        """
        ...
    @items.setter
    def items(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write] The curve to align to
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def alignment(self) -> ControlRigCurveAlignment:
        r"""
        (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
        """
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Only] The minimum U value to use on the curve
        """
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Only] The maximum U value to use on the curve
        """
        ...
    @property
    def sampling_precision(self) -> int:
        r"""
        (int32):  [Read-Only] The number of samples to use on the curve. Clamped at 64.
        """
        ...
    @property
    def primary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The major axis being aligned - along the bone
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector.
        You can use (0.0, 0.0, 0.0) to disable it.
        """
        ...
    @secondary_axis.setter
    def secondary_axis(self, value: Vector) -> None:
        ...
    @property
    def pole_vector_position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The the position of the pole vector used for aligning the secondary axis.
        Only has an effect if the secondary axis is set.
        """
        ...
    @pole_vector_position.setter
    def pole_vector_position(self, value: Vector) -> None:
        ...
    @property
    def rotations(self) -> Array[RigUnit_FitChainToCurve_Rotation]:
        r"""
        (Array[RigUnit_FitChainToCurve_Rotation]):  [Read-Write] The list of rotations to be applied along the curve
        """
        ...
    @rotations.setter
    def rotations(self, value: Array[RigUnit_FitChainToCurve_Rotation]) -> None:
        ...
    @property
    def rotation_ease_type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def debug_settings(self) -> RigUnit_FitChainToCurve_DebugSettings:
        r"""
        (RigUnit_FitChainToCurve_DebugSettings):  [Read-Write]
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_FitChainToCurve_DebugSettings) -> None:
        ...

class RigUnit_FitChainToSplineCurveItemArray(RigUnit_HighlevelBaseMutable):
    r"""
    Fits a given chain to a spline curve.
    Additionally provides rotational control matching the features of the Distribute Rotation node.
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alignment`` (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
    - ``debug_settings`` (RigUnit_FitChainToCurve_DebugSettings):  [Read-Write]
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items to align
    - ``maximum`` (float):  [Read-Only] The maximum U value to use on the curve
    - ``minimum`` (float):  [Read-Only] The minimum U value to use on the curve
    - ``pole_vector_position`` (Vector):  [Read-Write] The the position of the pole vector used for aligning the secondary axis.
      Only has an effect if the secondary axis is set.
    - ``primary_axis`` (Vector):  [Read-Write] The major axis being aligned - along the bone
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``rotation_ease_type`` (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
    - ``rotations`` (Array[RigUnit_FitChainToCurve_Rotation]):  [Read-Write] The list of rotations to be applied along the curve
    - ``sampling_precision`` (int32):  [Read-Only] The number of samples to use on the curve. Clamped at 64.
    - ``secondary_axis`` (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector.
      You can use (0.0, 0.0, 0.0) to disable it.
    - ``spline`` (ControlRigSpline):  [Read-Write] The curve to align to
    - ``weight`` (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: Array[RigElementKey] = [], spline: ControlRigSpline = [], alignment: ControlRigCurveAlignment = ControlRigCurveAlignment.FRONT, minimum: float = 0.000000, maximum: float = 0.000000, sampling_precision: int = 0, primary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis: Vector = [0.000000, 0.000000, 0.000000], pole_vector_position: Vector = [0.000000, 0.000000, 0.000000], rotations: Array[RigUnit_FitChainToCurve_Rotation] = [], rotation_ease_type: RigVMAnimEasingType = RigVMAnimEasingType.LINEAR, weight: float = 0.000000, propagate_to_children: bool = False, debug_settings: RigUnit_FitChainToCurve_DebugSettings = [False, 1.000000, [1.000000, 1.000000, 0.000000, 1.000000], [1.000000, 0.000000, 0.000000, 1.000000], [[0.000000, 0.000000, 0.000000], [-0.000000, 0.000000, 0.000000], [1.000000, 1.000000, 1.000000]]]) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The items to align
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write] The curve to align to
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def alignment(self) -> ControlRigCurveAlignment:
        r"""
        (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
        """
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Only] The minimum U value to use on the curve
        """
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Only] The maximum U value to use on the curve
        """
        ...
    @property
    def sampling_precision(self) -> int:
        r"""
        (int32):  [Read-Only] The number of samples to use on the curve. Clamped at 64.
        """
        ...
    @property
    def primary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The major axis being aligned - along the bone
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The minor axis being aligned - towards the pole vector.
        You can use (0.0, 0.0, 0.0) to disable it.
        """
        ...
    @secondary_axis.setter
    def secondary_axis(self, value: Vector) -> None:
        ...
    @property
    def pole_vector_position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The the position of the pole vector used for aligning the secondary axis.
        Only has an effect if the secondary axis is set.
        """
        ...
    @pole_vector_position.setter
    def pole_vector_position(self, value: Vector) -> None:
        ...
    @property
    def rotations(self) -> Array[RigUnit_FitChainToCurve_Rotation]:
        r"""
        (Array[RigUnit_FitChainToCurve_Rotation]):  [Read-Write] The list of rotations to be applied along the curve
        """
        ...
    @rotations.setter
    def rotations(self, value: Array[RigUnit_FitChainToCurve_Rotation]) -> None:
        ...
    @property
    def rotation_ease_type(self) -> RigVMAnimEasingType:
        r"""
        (RigVMAnimEasingType):  [Read-Only] The easing to use between to rotations.
        """
        ...
    @property
    def weight(self) -> float:
        r"""
        (float):  [Read-Write] The weight of the solver - how much the rotation should be applied
        """
        ...
    @weight.setter
    def weight(self, value: float) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...
    @property
    def debug_settings(self) -> RigUnit_FitChainToCurve_DebugSettings:
        r"""
        (RigUnit_FitChainToCurve_DebugSettings):  [Read-Write]
        """
        ...
    @debug_settings.setter
    def debug_settings(self, value: RigUnit_FitChainToCurve_DebugSettings) -> None:
        ...

class RigUnit_SplineConstraint(RigUnit_HighlevelBaseMutable):
    r"""
    Fits a given chain to a spline curve.
    Additionally provides rotational control matching the features of the Distribute Rotation node.
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alignment`` (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items to align
    - ``maximum`` (float):  [Read-Write] The maximum U value to use on the curve
    - ``minimum`` (float):  [Read-Write] The minimum U value to use on the curve
    - ``primary_axis`` (Vector):  [Read-Write]
    - ``propagate_to_children`` (bool):  [Read-Only] If set to true all of the global transforms of the children
      of this bone will be recalculated based on their local transforms.
      Note: This is computationally more expensive than turning it off.
    - ``secondary_axis`` (Vector):  [Read-Write]
    - ``spline`` (ControlRigSpline):  [Read-Write] The curve to align to
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: Array[RigElementKey] = [], spline: ControlRigSpline = [], alignment: ControlRigCurveAlignment = ControlRigCurveAlignment.FRONT, minimum: float = 0.000000, maximum: float = 0.000000, primary_axis: Vector = [0.000000, 0.000000, 0.000000], secondary_axis: Vector = [0.000000, 0.000000, 0.000000], propagate_to_children: bool = False) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The items to align
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write] The curve to align to
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def alignment(self) -> ControlRigCurveAlignment:
        r"""
        (ControlRigCurveAlignment):  [Read-Only] Specifies how to align the chain on the curve
        """
        ...
    @property
    def minimum(self) -> float:
        r"""
        (float):  [Read-Write] The minimum U value to use on the curve
        """
        ...
    @minimum.setter
    def minimum(self, value: float) -> None:
        ...
    @property
    def maximum(self) -> float:
        r"""
        (float):  [Read-Write] The maximum U value to use on the curve
        """
        ...
    @maximum.setter
    def maximum(self, value: float) -> None:
        ...
    @property
    def primary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @primary_axis.setter
    def primary_axis(self, value: Vector) -> None:
        ...
    @property
    def secondary_axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @secondary_axis.setter
    def secondary_axis(self, value: Vector) -> None:
        ...
    @property
    def propagate_to_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true all of the global transforms of the children
        of this bone will be recalculated based on their local transforms.
        Note: This is computationally more expensive than turning it off.
        """
        ...

class RigUnit_FitSplineCurveToChain(RigUnit_HighlevelBaseMutable):
    r"""
    Fits a given spline curve to a chain.
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (RigElementKeyCollection):  [Read-Write] The items to align to
    - ``spline`` (ControlRigSpline):  [Read-Write] The curve to align
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: RigElementKeyCollection = [[]], spline: ControlRigSpline = []) -> None:
        ...
    @property
    def items(self) -> RigElementKeyCollection:
        r"""
        (RigElementKeyCollection):  [Read-Write] The items to align to
        """
        ...
    @items.setter
    def items(self, value: RigElementKeyCollection) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write] The curve to align
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...

class RigUnit_FitSplineCurveToChainItemArray(RigUnit_HighlevelBaseMutable):
    r"""
    Fits a given spline curve to a chain.
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``execute_context`` (ControlRigExecuteContext):  [Read-Write] * This property is used to chain multiple mutable units together
    - ``items`` (Array[RigElementKey]):  [Read-Write] The items to align to
    - ``spline`` (ControlRigSpline):  [Read-Write] The curve to align
    """
    def __init__(self, execute_context: ControlRigExecuteContext = [], items: Array[RigElementKey] = [], spline: ControlRigSpline = []) -> None:
        ...
    @property
    def items(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write] The items to align to
        """
        ...
    @items.setter
    def items(self, value: Array[RigElementKey]) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write] The curve to align
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...

class RigUnit_ClosestParameterFromControlRigSpline(RigUnit_ControlRigSplineBase):
    r"""
    * Retrieves the closest U value from a given Spline and a position
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``position`` (Vector):  [Read-Write]
    - ``spline`` (ControlRigSpline):  [Read-Write]
    - ``u`` (float):  [Read-Write]
    """
    def __init__(self, spline: ControlRigSpline = [], position: Vector = [0.000000, 0.000000, 0.000000], u: float = 0.000000) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write]
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...
    @property
    def u(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class RigUnit_ParameterAtPercentage(RigUnit_ControlRigSplineBase):
    r"""
    * Returns the U parameter of a spline given a length percentage (0.0 - 1.0)
    
    **C++ Source:**
    
    - **Plugin**: ControlRigSpline
    - **Module**: ControlRigSpline
    - **File**: ControlRigSplineUnits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``percentage`` (float):  [Read-Write]
    - ``spline`` (ControlRigSpline):  [Read-Write]
    - ``u`` (float):  [Read-Write]
    """
    def __init__(self, spline: ControlRigSpline = [], percentage: float = 0.000000, u: float = 0.000000) -> None:
        ...
    @property
    def spline(self) -> ControlRigSpline:
        r"""
        (ControlRigSpline):  [Read-Write]
        """
        ...
    @spline.setter
    def spline(self, value: ControlRigSpline) -> None:
        ...
    @property
    def percentage(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @percentage.setter
    def percentage(self, value: float) -> None:
        ...
    @property
    def u(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...

class TemplateSequenceBindingOverrideData(StructBase):
    r"""
    Template sequence binding override data
    
    This is similar to FMovieSceneBindingOverrideData, but works only for a template sequence's root object,
    so we don't need it to store the object binding ID.
    
    **C++ Source:**
    
    - **Plugin**: TemplateSequence
    - **Module**: TemplateSequence
    - **File**: TemplateSequenceActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``object`` (Object):  [Read-Write] Specifies the object binding to override.
    - ``overrides_default`` (bool):  [Read-Write] Specifies whether the default assignment should remain bound (false) or if this should completely override the default binding (true).
    """
    def __init__(self) -> None:
        ...

class EditorDialogLibraryObjectDetailsViewOptions(StructBase):
    r"""
    Editor Dialog Library Object Details View Options
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorDialogLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_resizing`` (bool):  [Read-Write]
    - ``allow_search`` (bool):  [Read-Write]
    - ``min_height`` (int32):  [Read-Write] The minimum dialog height. If zero, default to the medium window height defined by the Editor style.
    - ``min_width`` (int32):  [Read-Write] The minimum dialog width. If zero, default to the medium window width defined by the Editor style.
    - ``show_object_name`` (bool):  [Read-Write]
    - ``value_column_width_ratio`` (float):  [Read-Write] The column size proportion, between 0 and 1, used to display the property value. The remaining of the horizontal space will be used to display the property name.
    """
    def __init__(self, show_object_name: bool = False, allow_search: bool = False, allow_resizing: bool = False, min_width: int = 0, min_height: int = 0, value_column_width_ratio: float = 0.000000) -> None:
        ...
    @property
    def show_object_name(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @show_object_name.setter
    def show_object_name(self, value: bool) -> None:
        ...
    @property
    def allow_search(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_search.setter
    def allow_search(self, value: bool) -> None:
        ...
    @property
    def allow_resizing(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_resizing.setter
    def allow_resizing(self, value: bool) -> None:
        ...
    @property
    def min_width(self) -> int:
        r"""
        (int32):  [Read-Write] The minimum dialog width. If zero, default to the medium window width defined by the Editor style.
        """
        ...
    @min_width.setter
    def min_width(self, value: int) -> None:
        ...
    @property
    def min_height(self) -> int:
        r"""
        (int32):  [Read-Write] The minimum dialog height. If zero, default to the medium window height defined by the Editor style.
        """
        ...
    @min_height.setter
    def min_height(self, value: int) -> None:
        ...
    @property
    def value_column_width_ratio(self) -> float:
        r"""
        (float):  [Read-Write] The column size proportion, between 0 and 1, used to display the property value. The remaining of the horizontal space will be used to display the property name.
        """
        ...
    @value_column_width_ratio.setter
    def value_column_width_ratio(self, value: float) -> None:
        ...

class EditorScriptingJoinStaticMeshActorsOptions_Deprecated(StructBase):
    r"""
    Editor Scripting Join Static Mesh Actors Options Deprecated
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorLevelLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``destroy_source_actors`` (bool):  [Read-Write] Destroy the provided Actors after the operation.
    - ``new_actor_label`` (str):  [Read-Write] Name of the new spawned Actor to replace the provided Actors.
    - ``rename_components_from_source`` (bool):  [Read-Write] Rename StaticMeshComponents based on source Actor's name.
    """
    def __init__(self, destroy_source_actors: bool = False, new_actor_label: str = "", rename_components_from_source: bool = False) -> None:
        ...
    @property
    def destroy_source_actors(self) -> bool:
        r"""
        (bool):  [Read-Write] Destroy the provided Actors after the operation.
        """
        ...
    @destroy_source_actors.setter
    def destroy_source_actors(self, value: bool) -> None:
        ...
    @property
    def new_actor_label(self) -> str:
        r"""
        (str):  [Read-Write] Name of the new spawned Actor to replace the provided Actors.
        """
        ...
    @new_actor_label.setter
    def new_actor_label(self, value: str) -> None:
        ...
    @property
    def rename_components_from_source(self) -> bool:
        r"""
        (bool):  [Read-Write] Rename StaticMeshComponents based on source Actor's name.
        """
        ...
    @rename_components_from_source.setter
    def rename_components_from_source(self, value: bool) -> None:
        ...

class EditorScriptingMergeStaticMeshActorsOptions_Deprecated(EditorScriptingJoinStaticMeshActorsOptions_Deprecated):
    r"""
    Editor Scripting Merge Static Mesh Actors Options Deprecated
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorLevelLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_package_name`` (str):  [Read-Write] The package path you want to save to. ie: /Game/MyFolder
    - ``destroy_source_actors`` (bool):  [Read-Write] Destroy the provided Actors after the operation.
    - ``mesh_merging_settings`` (MeshMergingSettings):  [Read-Write]
    - ``new_actor_label`` (str):  [Read-Write] Name of the new spawned Actor to replace the provided Actors.
    - ``rename_components_from_source`` (bool):  [Read-Write] Rename StaticMeshComponents based on source Actor's name.
    - ``spawn_merged_actor`` (bool):  [Read-Write] Spawn the new merged actors
    """
    def __init__(self, destroy_source_actors: bool = False, new_actor_label: str = "", rename_components_from_source: bool = False, spawn_merged_actor: bool = False, base_package_name: str = "", mesh_merging_settings: MeshMergingSettings = [256, [TextureSizingType.TEXTURE_SIZING_TYPE_USE_SINGLE_TEXTURE_SIZE, 5.000000, 0.500000, 10000.000000, 4.000000, 0.000000, 0.500000, 0.000000, 0.500000, 1.000000, 1.000000, 1.000000, BlendMode.BLEND_OPAQUE, True, True, False, False, False, False, False, False, False, False, False, [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024]], MeshLODSelectionType.CALCULATE_LOD, 0, True, False, False, False, False, False, False, True, False, False, True, True, [False, False, False, True, -2147483648, -1, -1, 1.000000, 0.000000, NaniteFallbackTarget.AUTO, 1.000000, 1.000000, 0.000000, 0]]) -> None:
        ...
    @property
    def spawn_merged_actor(self) -> bool:
        r"""
        (bool):  [Read-Write] Spawn the new merged actors
        """
        ...
    @spawn_merged_actor.setter
    def spawn_merged_actor(self, value: bool) -> None:
        ...
    @property
    def base_package_name(self) -> str:
        r"""
        (str):  [Read-Write] The package path you want to save to. ie: /Game/MyFolder
        """
        ...
    @base_package_name.setter
    def base_package_name(self, value: str) -> None:
        ...
    @property
    def mesh_merging_settings(self) -> MeshMergingSettings:
        r"""
        (MeshMergingSettings):  [Read-Write]
        """
        ...
    @mesh_merging_settings.setter
    def mesh_merging_settings(self, value: MeshMergingSettings) -> None:
        ...

class EditorScriptingCreateProxyMeshActorOptions_Deprecated(EditorScriptingJoinStaticMeshActorsOptions_Deprecated):
    r"""
    Editor Scripting Create Proxy Mesh Actor Options Deprecated
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorLevelLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_package_name`` (str):  [Read-Write] The package path you want to save to. ie: /Game/MyFolder
    - ``destroy_source_actors`` (bool):  [Read-Write] Destroy the provided Actors after the operation.
    - ``mesh_proxy_settings`` (MeshProxySettings):  [Read-Write]
    - ``new_actor_label`` (str):  [Read-Write] Name of the new spawned Actor to replace the provided Actors.
    - ``rename_components_from_source`` (bool):  [Read-Write] Rename StaticMeshComponents based on source Actor's name.
    - ``spawn_merged_actor`` (bool):  [Read-Write] Spawn the new merged actors
    """
    def __init__(self, destroy_source_actors: bool = False, new_actor_label: str = "", rename_components_from_source: bool = False, spawn_merged_actor: bool = False, base_package_name: str = "", mesh_proxy_settings: MeshProxySettings = [300, 3.000000, [TextureSizingType.TEXTURE_SIZING_TYPE_USE_SINGLE_TEXTURE_SIZE, 5.000000, 0.500000, 10000.000000, 4.000000, 0.000000, 0.500000, 0.000000, 0.500000, 1.000000, 1.000000, 1.000000, BlendMode.BLEND_OPAQUE, True, True, False, False, False, False, False, False, False, False, False, [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024]], 0.000000, [0, 0, 0, 255], 20.000000, 130.000000, 256, ProxyNormalComputationMethod.ANGLE_WEIGHTED, LandscapeCullingPrecision.MEDIUM, False, False, False, False, False, True, False, True, False, True, False, True, False, False, [False, False, False, True, -2147483648, -1, -1, 1.000000, 0.000000, NaniteFallbackTarget.AUTO, 1.000000, 1.000000, 0.000000, 0]]) -> None:
        ...
    @property
    def spawn_merged_actor(self) -> bool:
        r"""
        (bool):  [Read-Write] Spawn the new merged actors
        """
        ...
    @spawn_merged_actor.setter
    def spawn_merged_actor(self, value: bool) -> None:
        ...
    @property
    def base_package_name(self) -> str:
        r"""
        (str):  [Read-Write] The package path you want to save to. ie: /Game/MyFolder
        """
        ...
    @base_package_name.setter
    def base_package_name(self, value: str) -> None:
        ...
    @property
    def mesh_proxy_settings(self) -> MeshProxySettings:
        r"""
        (MeshProxySettings):  [Read-Write]
        """
        ...
    @mesh_proxy_settings.setter
    def mesh_proxy_settings(self, value: MeshProxySettings) -> None:
        ...

class EditorScriptingMeshReductionSettings_Deprecated(StructBase):
    r"""
    Deprecated as of 5.0, use the struct FStaticMeshReductionSettings in Static Mesh Editor Library Instead
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorStaticMeshLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``percent_triangles`` (float):  [Read-Write] Percentage of triangles to keep. Ranges from 0.0 to 1.0: 1.0 = no reduction, 0.0 = no triangles.
    - ``screen_size`` (float):  [Read-Write] ScreenSize to display this LOD. Ranges from 0.0 to 1.0.
    """
    def __init__(self, percent_triangles: float = 0.000000, screen_size: float = 0.000000) -> None:
        ...
    @property
    def percent_triangles(self) -> float:
        r"""
        (float):  [Read-Write] Percentage of triangles to keep. Ranges from 0.0 to 1.0: 1.0 = no reduction, 0.0 = no triangles.
        """
        ...
    @percent_triangles.setter
    def percent_triangles(self, value: float) -> None:
        ...
    @property
    def screen_size(self) -> float:
        r"""
        (float):  [Read-Write] ScreenSize to display this LOD. Ranges from 0.0 to 1.0.
        """
        ...
    @screen_size.setter
    def screen_size(self, value: float) -> None:
        ...

class EditorScriptingMeshReductionOptions_Deprecated(StructBase):
    r"""
    Deprecated as of 5.0, use the struct FStaticMeshReductionOptions in Static Mesh Editor Library Instead
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorStaticMeshLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_compute_lod_screen_size`` (bool):  [Read-Write] If true, the screen sizes at which LODs swap are computed automatically
      note: that this is displayed as 'Auto Compute LOD Distances' in the UI
    - ``reduction_settings`` (Array[EditorScriptingMeshReductionSettings_Deprecated]):  [Read-Write] Array of reduction settings to apply to each new LOD mesh.
    """
    def __init__(self, auto_compute_lod_screen_size: bool = False, reduction_settings: Array[EditorScriptingMeshReductionSettings_Deprecated] = []) -> None:
        ...
    @property
    def auto_compute_lod_screen_size(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the screen sizes at which LODs swap are computed automatically
        note: that this is displayed as 'Auto Compute LOD Distances' in the UI
        """
        ...
    @auto_compute_lod_screen_size.setter
    def auto_compute_lod_screen_size(self, value: bool) -> None:
        ...
    @property
    def reduction_settings(self) -> Array[EditorScriptingMeshReductionSettings_Deprecated]:
        r"""
        (Array[EditorScriptingMeshReductionSettings_Deprecated]):  [Read-Write] Array of reduction settings to apply to each new LOD mesh.
        """
        ...
    @reduction_settings.setter
    def reduction_settings(self, value: Array[EditorScriptingMeshReductionSettings_Deprecated]) -> None:
        ...

class JoinStaticMeshActorsOptions(StructBase):
    r"""
    Join Static Mesh Actors Options
    
    **C++ Source:**
    
    - **Module**: StaticMeshEditor
    - **File**: StaticMeshEditorSubsystemHelpers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``destroy_source_actors`` (bool):  [Read-Write] Destroy the provided Actors after the operation.
    - ``new_actor_label`` (str):  [Read-Write] Name of the new spawned Actor to replace the provided Actors.
    - ``rename_components_from_source`` (bool):  [Read-Write] Rename StaticMeshComponents based on source Actor's name.
    """
    def __init__(self, destroy_source_actors: bool = False, new_actor_label: str = "", rename_components_from_source: bool = False) -> None:
        ...
    @property
    def destroy_source_actors(self) -> bool:
        r"""
        (bool):  [Read-Write] Destroy the provided Actors after the operation.
        """
        ...
    @destroy_source_actors.setter
    def destroy_source_actors(self, value: bool) -> None:
        ...
    @property
    def new_actor_label(self) -> str:
        r"""
        (str):  [Read-Write] Name of the new spawned Actor to replace the provided Actors.
        """
        ...
    @new_actor_label.setter
    def new_actor_label(self, value: str) -> None:
        ...
    @property
    def rename_components_from_source(self) -> bool:
        r"""
        (bool):  [Read-Write] Rename StaticMeshComponents based on source Actor's name.
        """
        ...
    @rename_components_from_source.setter
    def rename_components_from_source(self, value: bool) -> None:
        ...

class EditorScriptingJoinStaticMeshActorsOptions(JoinStaticMeshActorsOptions):
    r"""
    deprecated: 'EditorScriptingJoinStaticMeshActorsOptions' was renamed to 'JoinStaticMeshActorsOptions'.
    """
    def __init__(self, destroy_source_actors: bool = False, new_actor_label: str = "", rename_components_from_source: bool = False) -> None:
        ...

class MergeStaticMeshActorsOptions(JoinStaticMeshActorsOptions):
    r"""
    Merge Static Mesh Actors Options
    
    **C++ Source:**
    
    - **Module**: StaticMeshEditor
    - **File**: StaticMeshEditorSubsystemHelpers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_package_name`` (str):  [Read-Write] The package path you want to save to. ie: /Game/MyFolder
    - ``destroy_source_actors`` (bool):  [Read-Write] Destroy the provided Actors after the operation.
    - ``mesh_merging_settings`` (MeshMergingSettings):  [Read-Write]
    - ``new_actor_label`` (str):  [Read-Write] Name of the new spawned Actor to replace the provided Actors.
    - ``rename_components_from_source`` (bool):  [Read-Write] Rename StaticMeshComponents based on source Actor's name.
    - ``spawn_merged_actor`` (bool):  [Read-Write] Spawn the new merged actors
    """
    def __init__(self, destroy_source_actors: bool = False, new_actor_label: str = "", rename_components_from_source: bool = False, spawn_merged_actor: bool = False, base_package_name: str = "", mesh_merging_settings: MeshMergingSettings = [256, [TextureSizingType.TEXTURE_SIZING_TYPE_USE_SINGLE_TEXTURE_SIZE, 5.000000, 0.500000, 10000.000000, 4.000000, 0.000000, 0.500000, 0.000000, 0.500000, 1.000000, 1.000000, 1.000000, BlendMode.BLEND_OPAQUE, True, True, False, False, False, False, False, False, False, False, False, [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024]], MeshLODSelectionType.CALCULATE_LOD, 0, True, False, False, False, False, False, False, True, False, False, True, True, [False, False, False, True, -2147483648, -1, -1, 1.000000, 0.000000, NaniteFallbackTarget.AUTO, 1.000000, 1.000000, 0.000000, 0]]) -> None:
        ...
    @property
    def spawn_merged_actor(self) -> bool:
        r"""
        (bool):  [Read-Write] Spawn the new merged actors
        """
        ...
    @spawn_merged_actor.setter
    def spawn_merged_actor(self, value: bool) -> None:
        ...
    @property
    def base_package_name(self) -> str:
        r"""
        (str):  [Read-Write] The package path you want to save to. ie: /Game/MyFolder
        """
        ...
    @base_package_name.setter
    def base_package_name(self, value: str) -> None:
        ...
    @property
    def mesh_merging_settings(self) -> MeshMergingSettings:
        r"""
        (MeshMergingSettings):  [Read-Write]
        """
        ...
    @mesh_merging_settings.setter
    def mesh_merging_settings(self, value: MeshMergingSettings) -> None:
        ...

class EditorScriptingMergeStaticMeshActorsOptions(MergeStaticMeshActorsOptions):
    r"""
    deprecated: 'EditorScriptingMergeStaticMeshActorsOptions' was renamed to 'MergeStaticMeshActorsOptions'.
    """
    def __init__(self, destroy_source_actors: bool = False, new_actor_label: str = "", rename_components_from_source: bool = False, spawn_merged_actor: bool = False, base_package_name: str = "", mesh_merging_settings: MeshMergingSettings = [256, [TextureSizingType.TEXTURE_SIZING_TYPE_USE_SINGLE_TEXTURE_SIZE, 5.000000, 0.500000, 10000.000000, 4.000000, 0.000000, 0.500000, 0.000000, 0.500000, 1.000000, 1.000000, 1.000000, BlendMode.BLEND_OPAQUE, True, True, False, False, False, False, False, False, False, False, False, [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024]], MeshLODSelectionType.CALCULATE_LOD, 0, True, False, False, False, False, False, False, True, False, False, True, True, [False, False, False, True, -2147483648, -1, -1, 1.000000, 0.000000, NaniteFallbackTarget.AUTO, 1.000000, 1.000000, 0.000000, 0]]) -> None:
        ...

class CreateProxyMeshActorOptions(JoinStaticMeshActorsOptions):
    r"""
    Create Proxy Mesh Actor Options
    
    **C++ Source:**
    
    - **Module**: StaticMeshEditor
    - **File**: StaticMeshEditorSubsystemHelpers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_package_name`` (str):  [Read-Write] The package path you want to save to. ie: /Game/MyFolder
    - ``destroy_source_actors`` (bool):  [Read-Write] Destroy the provided Actors after the operation.
    - ``mesh_proxy_settings`` (MeshProxySettings):  [Read-Write]
    - ``new_actor_label`` (str):  [Read-Write] Name of the new spawned Actor to replace the provided Actors.
    - ``rename_components_from_source`` (bool):  [Read-Write] Rename StaticMeshComponents based on source Actor's name.
    - ``spawn_merged_actor`` (bool):  [Read-Write] Spawn the new merged actors
    """
    def __init__(self, destroy_source_actors: bool = False, new_actor_label: str = "", rename_components_from_source: bool = False, spawn_merged_actor: bool = False, base_package_name: str = "", mesh_proxy_settings: MeshProxySettings = [300, 3.000000, [TextureSizingType.TEXTURE_SIZING_TYPE_USE_SINGLE_TEXTURE_SIZE, 5.000000, 0.500000, 10000.000000, 4.000000, 0.000000, 0.500000, 0.000000, 0.500000, 1.000000, 1.000000, 1.000000, BlendMode.BLEND_OPAQUE, True, True, False, False, False, False, False, False, False, False, False, [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024]], 0.000000, [0, 0, 0, 255], 20.000000, 130.000000, 256, ProxyNormalComputationMethod.ANGLE_WEIGHTED, LandscapeCullingPrecision.MEDIUM, False, False, False, False, False, True, False, True, False, True, False, True, False, False, [False, False, False, True, -2147483648, -1, -1, 1.000000, 0.000000, NaniteFallbackTarget.AUTO, 1.000000, 1.000000, 0.000000, 0]]) -> None:
        ...
    @property
    def spawn_merged_actor(self) -> bool:
        r"""
        (bool):  [Read-Write] Spawn the new merged actors
        """
        ...
    @spawn_merged_actor.setter
    def spawn_merged_actor(self, value: bool) -> None:
        ...
    @property
    def base_package_name(self) -> str:
        r"""
        (str):  [Read-Write] The package path you want to save to. ie: /Game/MyFolder
        """
        ...
    @base_package_name.setter
    def base_package_name(self, value: str) -> None:
        ...
    @property
    def mesh_proxy_settings(self) -> MeshProxySettings:
        r"""
        (MeshProxySettings):  [Read-Write]
        """
        ...
    @mesh_proxy_settings.setter
    def mesh_proxy_settings(self, value: MeshProxySettings) -> None:
        ...

class EditorScriptingCreateProxyMeshActorOptions(CreateProxyMeshActorOptions):
    r"""
    deprecated: 'EditorScriptingCreateProxyMeshActorOptions' was renamed to 'CreateProxyMeshActorOptions'.
    """
    def __init__(self, destroy_source_actors: bool = False, new_actor_label: str = "", rename_components_from_source: bool = False, spawn_merged_actor: bool = False, base_package_name: str = "", mesh_proxy_settings: MeshProxySettings = [300, 3.000000, [TextureSizingType.TEXTURE_SIZING_TYPE_USE_SINGLE_TEXTURE_SIZE, 5.000000, 0.500000, 10000.000000, 4.000000, 0.000000, 0.500000, 0.000000, 0.500000, 1.000000, 1.000000, 1.000000, BlendMode.BLEND_OPAQUE, True, True, False, False, False, False, False, False, False, False, False, [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024], [1024, 1024]], 0.000000, [0, 0, 0, 255], 20.000000, 130.000000, 256, ProxyNormalComputationMethod.ANGLE_WEIGHTED, LandscapeCullingPrecision.MEDIUM, False, False, False, False, False, True, False, True, False, True, False, True, False, False, [False, False, False, True, -2147483648, -1, -1, 1.000000, 0.000000, NaniteFallbackTarget.AUTO, 1.000000, 1.000000, 0.000000, 0]]) -> None:
        ...

class StaticMeshReductionOptions(StructBase):
    r"""
    Static Mesh Reduction Options
    
    **C++ Source:**
    
    - **Module**: StaticMeshEditor
    - **File**: StaticMeshEditorSubsystemHelpers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_compute_lod_screen_size`` (bool):  [Read-Write] If true, the screen sizes at which LODs swap are computed automatically
      note: that this is displayed as 'Auto Compute LOD Distances' in the UI
    - ``reduction_settings`` (Array[StaticMeshReductionSettings]):  [Read-Write] Array of reduction settings to apply to each new LOD mesh.
    """
    def __init__(self, auto_compute_lod_screen_size: bool = False, reduction_settings: Array[StaticMeshReductionSettings] = []) -> None:
        ...
    @property
    def auto_compute_lod_screen_size(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the screen sizes at which LODs swap are computed automatically
        note: that this is displayed as 'Auto Compute LOD Distances' in the UI
        """
        ...
    @auto_compute_lod_screen_size.setter
    def auto_compute_lod_screen_size(self, value: bool) -> None:
        ...
    @property
    def reduction_settings(self) -> Array[StaticMeshReductionSettings]:
        r"""
        (Array[StaticMeshReductionSettings]):  [Read-Write] Array of reduction settings to apply to each new LOD mesh.
        """
        ...
    @reduction_settings.setter
    def reduction_settings(self, value: Array[StaticMeshReductionSettings]) -> None:
        ...

class EditorScriptingMeshReductionOptions(StaticMeshReductionOptions):
    r"""
    deprecated: 'EditorScriptingMeshReductionOptions' was renamed to 'StaticMeshReductionOptions'.
    """
    def __init__(self, auto_compute_lod_screen_size: bool = False, reduction_settings: Array[StaticMeshReductionSettings] = []) -> None:
        ...

class StaticMeshReductionSettings(StructBase):
    r"""
    Static Mesh Reduction Settings
    
    **C++ Source:**
    
    - **Module**: StaticMeshEditor
    - **File**: StaticMeshEditorSubsystemHelpers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``percent_triangles`` (float):  [Read-Write] Percentage of triangles to keep. Ranges from 0.0 to 1.0: 1.0 = no reduction, 0.0 = no triangles.
    - ``screen_size`` (float):  [Read-Write] ScreenSize to display this LOD. Ranges from 0.0 to 1.0.
    """
    def __init__(self, percent_triangles: float = 0.000000, screen_size: float = 0.000000) -> None:
        ...
    @property
    def percent_triangles(self) -> float:
        r"""
        (float):  [Read-Write] Percentage of triangles to keep. Ranges from 0.0 to 1.0: 1.0 = no reduction, 0.0 = no triangles.
        """
        ...
    @percent_triangles.setter
    def percent_triangles(self, value: float) -> None:
        ...
    @property
    def screen_size(self) -> float:
        r"""
        (float):  [Read-Write] ScreenSize to display this LOD. Ranges from 0.0 to 1.0.
        """
        ...
    @screen_size.setter
    def screen_size(self, value: float) -> None:
        ...

class EditorScriptingMeshReductionSettings(StaticMeshReductionSettings):
    r"""
    deprecated: 'EditorScriptingMeshReductionSettings' was renamed to 'StaticMeshReductionSettings'.
    """
    def __init__(self, percent_triangles: float = 0.000000, screen_size: float = 0.000000) -> None:
        ...

class GenerateStaticMeshLODProcess_PreprocessSettings(StructBase):
    r"""
    Generate Static Mesh LODProcess Preprocess Settings
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``filter_group_layer`` (Name):  [Read-Write] Group layer to use for filtering out detail before processing
    - ``thicken_amount`` (float):  [Read-Write] Amount to thicken the mesh prior to Solidifying. The thicken weight map values are multiplied by this value.
      Thickening is primarily intended to repair shape erosion that can occur when using the Solidify Mesh Generators.
    - ``thicken_weight_map_name`` (Name):  [Read-Write] Weight map used during mesh thickening
    """
    def __init__(self) -> None:
        ...

class GenerateStaticMeshLODProcessSettings(StructBase):
    r"""
    Generate Static Mesh LODProcess Settings
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``closure_distance`` (float):  [Read-Write] Offset distance in the Morpohological Closure operation
    - ``mesh_generator`` (GenerateStaticMeshLODProcess_MeshGeneratorModes):  [Read-Write] Method used to generate the initial mesh for AutoLOD processing
    - ``prefilter_grid_resolution`` (int32):  [Read-Write] Grid resolution (along the maximum-length axis) for subsampling before computing the convex hull
    - ``prefilter_vertices`` (bool):  [Read-Write] Whether to subsample input vertices using a regular grid before computing the convex hull
    - ``solidify_voxel_resolution`` (int32):  [Read-Write] Target number of voxels along the maximum dimension for Solidify operation
    - ``winding_threshold`` (float):  [Read-Write] Winding number threshold to determine what is considered inside the mesh during Solidify
    """
    def __init__(self) -> None:
        ...

class GenerateStaticMeshLODProcess_SimplifySettings(StructBase):
    r"""
    Generate Static Mesh LODProcess Simplify Settings
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``method`` (GenerateStaticMeshLODProcess_SimplifyMethod):  [Read-Write] Method used to simplify the mesh created in the Mesh Generation step
    - ``target_count`` (int32):  [Read-Write] Target triangle/vertex count after simplification
    - ``target_percentage`` (float):  [Read-Write] Target triangle/vertex count after simplification
    - ``tolerance`` (float):  [Read-Write] Deviation in World Units (Centimeters)
    """
    def __init__(self) -> None:
        ...

class GenerateStaticMeshLODProcess_NormalsSettings(StructBase):
    r"""
    Generate Static Mesh LODProcess Normals Settings
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angle`` (float):  [Read-Write] Split Normals (ie sharp edge) will be created along mesh edges with opening angles above this threshold
    - ``method`` (GenerateStaticMeshLODProcess_NormalsMethod):  [Read-Write] Type of Normals to generate
    """
    def __init__(self) -> None:
        ...

class GenerateStaticMeshLODProcess_TextureSettings(StructBase):
    r"""
    Generate Static Mesh LODProcess Texture Settings
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bake_resolution`` (GenerateStaticMeshLODBakeResolution):  [Read-Write] Resolution for normal map and texture baking
    - ``bake_thickness`` (float):  [Read-Write] How far away from the output mesh to search for input mesh during baking
    - ``combine_textures`` (bool):  [Read-Write] Generate an atlassed texture where multiple textures are combined into a single output texture
    """
    def __init__(self) -> None:
        ...

class GenerateStaticMeshLODProcess_UVSettings(StructBase):
    r"""
    Generate Static Mesh LODProcess UVSettings
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max_angle_deviation`` (float):  [Read-Write] UV islands will not be merged if their average face normals deviate by larger than this amount
    - ``merging_threshold`` (float):  [Read-Write] Distortion/Stretching Threshold for island merging - larger values increase the allowable UV stretching
    - ``num_initial_patches`` (int32):  [Read-Write] Number of initial patches mesh will be split into before computing island merging
    - ``num_uv_atlas_charts`` (int32):  [Read-Write] Maximum number of charts to create in UVAtlas
    - ``patch_builder`` (GenerateStaticMeshLODProcess_UVSettings_PatchBuilder):  [Read-Write]
    - ``uv_method`` (GenerateStaticMeshLODProcess_AutoUVMethod):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class GenerateStaticMeshLODProcess_CollisionSettings(StructBase):
    r"""
    Generate Static Mesh LODProcess Collision Settings
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_type`` (GenerateStaticMeshLODSimpleCollisionGeometryType):  [Read-Write] Type of simple collision objects to produce
    - ``convex_triangle_count`` (int32):  [Read-Write] Target triangle count for each convex hull after simplification
    - ``hull_tolerance`` (float):  [Read-Write] Target minumum edge length for simplified swept convex hulls
    - ``prefilter_grid_resolution`` (int32):  [Read-Write] Grid resolution (along the maximum-length axis) for subsampling before computing the convex hull
    - ``prefilter_vertices`` (bool):  [Read-Write] Whether to subsample input vertices using a regular grid before computing the convex hull
    - ``simplify_polygons`` (bool):  [Read-Write] Whether to simplify polygons used for swept convex hulls
    - ``sweep_axis`` (GenerateStaticMeshLODProjectedHullAxisMode):  [Read-Write] Which axis to sweep along when computing swept convex hulls
    """
    def __init__(self) -> None:
        ...

class GenerateStaticMeshLODProcess_UVSettings_PatchBuilder(StructBase):
    r"""
    Generate Static Mesh LODProcess UVSettings Patch Builder
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: GenerateStaticMeshLODProcess.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curvature_alignment`` (float):  [Read-Write] This parameter controls alignment of the initial patches to creases in the mesh
    - ``smoothing_alpha`` (float):  [Read-Write] Smoothing parameter; larger values result in faster smoothing in each step.
    - ``smoothing_steps`` (int32):  [Read-Write] Number of smoothing steps to apply; this slightly increases distortion but produces more stable results.
    """
    def __init__(self) -> None:
        ...

class ObjectMixerWidgetUserConfig(StructBase):
    r"""
    User Configurable Variables
    
    **C++ Source:**
    
    - **Plugin**: ObjectMixer
    - **Module**: ObjectMixerEditor
    - **File**: ObjectMixerEditorUWidget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_filter_class`` (type(Class)):  [Read-Write] Sets the default filter class to determine what objects and properties to display in this Object Mixer instance.
    """
    def __init__(self, default_filter_class: Class = None) -> None:
        ...
    @property
    def default_filter_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Sets the default filter class to determine what objects and properties to display in this Object Mixer instance.
        """
        ...
    @default_filter_class.setter
    def default_filter_class(self, value: Class) -> None:
        ...

class AssetActionSupportCondition(StructBase):
    r"""
    Asset Action Support Condition
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: AssetActionUtility.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``failure_reason`` (str):  [Read-Write] This is the failure reason to reply to the user with if the condition above fails.
      If you fill in the reason, it will override the default failure text in the tooltip for the function menu option.
    - ``filter`` (str):  [Read-Write] This is a content browser styled filter.  For example, ..._N AND VirtualTextureStreaming=FALSE, would require that
      asset tag VirtualTextureStreaming be false, and the asset name end in _N.
      
      You can learn more about the content browser search syntax in the "Advanced Search Syntax" documentation.
    - ``show_in_menu_if_filter_fails`` (bool):  [Read-Write] If this filter does not pass, show the corresponding functions from the menu anyways.
      If true, the menu option will display with the error tooltip, but be disabled.
      If false, the menu options will be removed entirely.
    """
    def __init__(self) -> None:
        ...

class RigVMBlueprintLoadLogEntry(StructBase):
    r"""
    Rig VMBlueprint Load Log Entry
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMEditor
    - **File**: RigVMEditorBlueprintLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``message`` (str):  [Read-Only]
    - ``severity`` (RigVMBlueprintLoadLogSeverity):  [Read-Only]
    - ``subject`` (Object):  [Read-Only]
    """
    def __init__(self, severity: RigVMBlueprintLoadLogSeverity = RigVMBlueprintLoadLogSeverity.DISPLAY, subject: Object = None, message: str = "") -> None:
        ...
    @property
    def severity(self) -> RigVMBlueprintLoadLogSeverity:
        r"""
        (RigVMBlueprintLoadLogSeverity):  [Read-Only]
        """
        ...
    @property
    def subject(self) -> Object:
        r"""
        (Object):  [Read-Only]
        """
        ...
    @property
    def message(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...

class RigVMEditorGraphMenuContext(StructBase):
    r"""
    Rig VMEditor Graph Menu Context
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMEditor
    - **File**: RigVMEditorMenuContext.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``graph`` (RigVMGraph):  [Read-Write] The graph associated with this context.
    - ``node`` (RigVMNode):  [Read-Write] The node associated with this context.
    - ``pin`` (RigVMPin):  [Read-Write] The pin associated with this context; may be NULL when over a node.
    """
    def __init__(self, graph: RigVMGraph = None, node: RigVMNode = None, pin: RigVMPin = None) -> None:
        ...
    @property
    def graph(self) -> RigVMGraph:
        r"""
        (RigVMGraph):  [Read-Only] The graph associated with this context.
        """
        ...
    @property
    def node(self) -> RigVMNode:
        r"""
        (RigVMNode):  [Read-Only] The node associated with this context.
        """
        ...
    @property
    def pin(self) -> RigVMPin:
        r"""
        (RigVMPin):  [Read-Only] The pin associated with this context; may be NULL when over a node.
        """
        ...

class RigSpacePickerBakeSettings(StructBase):
    r"""
    Rig Space Picker Bake Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: RigSpacePickerBakeSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_frame`` (FrameNumber):  [Read-Write] DEPRECATED 5.3
      deprecated: Use Settings.EndFrame instead
    - ``reduce_keys`` (bool):  [Read-Write] DEPRECATED 5.3
      deprecated: Use Settings.bReduceKeys instead
    - ``settings`` (BakingAnimationKeySettings):  [Read-Write]
    - ``start_frame`` (FrameNumber):  [Read-Write] DEPRECATED 5.3
      deprecated: Use Settings.StartFrame instead
    - ``target_space`` (RigElementKey):  [Read-Write]
    - ``tolerance`` (float):  [Read-Write] DEPRECATED 5.3
      deprecated: Use Settings.Tolerance instead
    """
    def __init__(self, target_space: RigElementKey = [RigElementType.NONE, "None"], settings: BakingAnimationKeySettings = [[0], [100], BakingKeySettings.KEYS_ONLY, 1, False, 0.001000]) -> None:
        ...
    @property
    def target_space(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Write]
        """
        ...
    @target_space.setter
    def target_space(self, value: RigElementKey) -> None:
        ...
    @property
    def settings(self) -> BakingAnimationKeySettings:
        r"""
        (BakingAnimationKeySettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: BakingAnimationKeySettings) -> None:
        ...
    @property
    def start_frame(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] DEPRECATED 5.3
        deprecated: Use Settings.StartFrame instead
        """
        ...
    @start_frame.setter
    def start_frame(self, value: FrameNumber) -> None:
        ...
    @property
    def end_frame(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] DEPRECATED 5.3
        deprecated: Use Settings.EndFrame instead
        """
        ...
    @end_frame.setter
    def end_frame(self, value: FrameNumber) -> None:
        ...
    @property
    def reduce_keys(self) -> bool:
        r"""
        (bool):  [Read-Write] DEPRECATED 5.3
        deprecated: Use Settings.bReduceKeys instead
        """
        ...
    @reduce_keys.setter
    def reduce_keys(self, value: bool) -> None:
        ...
    @property
    def tolerance(self) -> float:
        r"""
        (float):  [Read-Write] DEPRECATED 5.3
        deprecated: Use Settings.Tolerance instead
        """
        ...
    @tolerance.setter
    def tolerance(self, value: float) -> None:
        ...

class ControlRigSequencerBindingProxy(StructBase):
    r"""
    Control Rig Sequencer Binding Proxy
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigSequencerEditorLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control_rig`` (ControlRig):  [Read-Write]
    - ``proxy`` (MovieSceneBindingProxy):  [Read-Write]
    - ``track`` (MovieSceneControlRigParameterTrack):  [Read-Write]
    """
    def __init__(self, proxy: MovieSceneBindingProxy = [[], None], control_rig: ControlRig = None, track: MovieSceneControlRigParameterTrack = None) -> None:
        ...
    @property
    def proxy(self) -> MovieSceneBindingProxy:
        r"""
        (MovieSceneBindingProxy):  [Read-Only]
        """
        ...
    @property
    def control_rig(self) -> ControlRig:
        r"""
        (ControlRig):  [Read-Only]
        """
        ...
    @property
    def track(self) -> MovieSceneControlRigParameterTrack:
        r"""
        (MovieSceneControlRigParameterTrack):  [Read-Only]
        """
        ...

class AnimDetailProxyFloat(StructBase):
    r"""
    note control rig uses 'float' controls so we call this float though it's a
    double internally so we can use same for non-control rig parameters
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``float`` (double):  [Read-Write]
    """
    def __init__(self, float: float = 0.000000) -> None:
        ...
    @property
    def float(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @float.setter
    def float(self, value: float) -> None:
        ...

class AnimDetailProxyBool(StructBase):
    r"""
    Anim Detail Proxy Bool
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool`` (bool):  [Read-Write]
    """
    def __init__(self, bool: bool = False) -> None:
        ...
    @property
    def bool(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @bool.setter
    def bool(self, value: bool) -> None:
        ...

class ControlRigEnumControlProxyValue(StructBase):
    r"""
    Control Rig Enum Control Proxy Value
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enum_index`` (int32):  [Read-Write]
    """
    def __init__(self) -> None:
        ...

class AnimDetailProxyInteger(StructBase):
    r"""
    Anim Detail Proxy Integer
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``integer`` (int64):  [Read-Write]
    """
    def __init__(self, integer: int = 0) -> None:
        ...
    @property
    def integer(self) -> int:
        r"""
        (int64):  [Read-Write]
        """
        ...
    @integer.setter
    def integer(self, value: int) -> None:
        ...

class AnimDetailProxyVector3(StructBase):
    r"""
    Anim Detail Proxy Vector 3
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    - ``z`` (double):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000, z: float = 0.000000) -> None:
        ...
    @property
    def x(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: float) -> None:
        ...
    @property
    def y(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: float) -> None:
        ...
    @property
    def z(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: float) -> None:
        ...

class AnimDetailProxyLocation(StructBase):
    r"""
    Anim Detail Proxy Location
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``lx`` (double):  [Read-Write]
    - ``ly`` (double):  [Read-Write]
    - ``lz`` (double):  [Read-Write]
    """
    def __init__(self, lx: float = 0.000000, ly: float = 0.000000, lz: float = 0.000000) -> None:
        ...
    @property
    def lx(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @lx.setter
    def lx(self, value: float) -> None:
        ...
    @property
    def ly(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @ly.setter
    def ly(self, value: float) -> None:
        ...
    @property
    def lz(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @lz.setter
    def lz(self, value: float) -> None:
        ...

class AnimDetailProxyRotation(StructBase):
    r"""
    Anim Detail Proxy Rotation
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``rx`` (double):  [Read-Write]
    - ``ry`` (double):  [Read-Write]
    - ``rz`` (double):  [Read-Write]
    """
    def __init__(self, rx: float = 0.000000, ry: float = 0.000000, rz: float = 0.000000) -> None:
        ...
    @property
    def rx(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @rx.setter
    def rx(self, value: float) -> None:
        ...
    @property
    def ry(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @ry.setter
    def ry(self, value: float) -> None:
        ...
    @property
    def rz(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @rz.setter
    def rz(self, value: float) -> None:
        ...

class AnimDetailProxyScale(StructBase):
    r"""
    Anim Detail Proxy Scale
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``sx`` (double):  [Read-Write]
    - ``sy`` (double):  [Read-Write]
    - ``sz`` (double):  [Read-Write]
    """
    def __init__(self, sx: float = 0.000000, sy: float = 0.000000, sz: float = 0.000000) -> None:
        ...
    @property
    def sx(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @sx.setter
    def sx(self, value: float) -> None:
        ...
    @property
    def sy(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @sy.setter
    def sy(self, value: float) -> None:
        ...
    @property
    def sz(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @sz.setter
    def sz(self, value: float) -> None:
        ...

class AnimDetailProxyVector2D(StructBase):
    r"""
    Anim Detail Proxy Vector 2D
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (double):  [Read-Write]
    - ``y`` (double):  [Read-Write]
    """
    def __init__(self, x: float = 0.000000, y: float = 0.000000) -> None:
        ...
    @property
    def x(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: float) -> None:
        ...
    @property
    def y(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: float) -> None:
        ...

class ControlRigRigHierarchyDragAndDropContext(StructBase):
    r"""
    Control Rig Rig Hierarchy Drag and Drop Context
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigContextMenuContext.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``dragged_element_keys`` (Array[RigElementKey]):  [Read-Write]
    - ``target_element_key`` (RigElementKey):  [Read-Write]
    """
    def __init__(self, dragged_element_keys: Array[RigElementKey] = [], target_element_key: RigElementKey = [RigElementType.NONE, "None"]) -> None:
        ...
    @property
    def dragged_element_keys(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...
    @property
    def target_element_key(self) -> RigElementKey:
        r"""
        (RigElementKey):  [Read-Only]
        """
        ...

class ControlRigGraphNodeContextMenuContext(StructBase):
    r"""
    Control Rig Graph Node Context Menu Context
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigContextMenuContext.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``graph`` (RigVMGraph):  [Read-Write] The graph associated with this context.
    - ``node`` (RigVMNode):  [Read-Write] The node associated with this context.
    - ``pin`` (RigVMPin):  [Read-Write] The pin associated with this context; may be NULL when over a node.
    """
    def __init__(self, graph: RigVMGraph = None, node: RigVMNode = None, pin: RigVMPin = None) -> None:
        ...
    @property
    def graph(self) -> RigVMGraph:
        r"""
        (RigVMGraph):  [Read-Only] The graph associated with this context.
        """
        ...
    @property
    def node(self) -> RigVMNode:
        r"""
        (RigVMNode):  [Read-Only] The node associated with this context.
        """
        ...
    @property
    def pin(self) -> RigVMPin:
        r"""
        (RigVMPin):  [Read-Only] The pin associated with this context; may be NULL when over a node.
        """
        ...

class ControlRigRigHierarchyToGraphDragAndDropContext(StructBase):
    r"""
    Control Rig Rig Hierarchy to Graph Drag and Drop Context
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigContextMenuContext.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``dragged_element_keys`` (Array[RigElementKey]):  [Read-Write]
    """
    def __init__(self, dragged_element_keys: Array[RigElementKey] = []) -> None:
        ...
    @property
    def dragged_element_keys(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Only]
        """
        ...

class ControlRigForWorldTransforms(StructBase):
    r"""
    Specification containing a Control Rig and a list of selected Controls we use to get World Transforms for Snapping.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigSnapper.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control_names`` (Array[Name]):  [Read-Write]
    - ``control_rig`` (ControlRig):  [Read-Write]
    """
    def __init__(self, control_rig: ControlRig = None, control_names: Array[Name] = []) -> None:
        ...
    @property
    def control_rig(self) -> ControlRig:
        r"""
        (ControlRig):  [Read-Write]
        """
        ...
    @control_rig.setter
    def control_rig(self, value: ControlRig) -> None:
        ...
    @property
    def control_names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write]
        """
        ...
    @control_names.setter
    def control_names(self, value: Array[Name]) -> None:
        ...

class ControlRigSnapperSelection(StructBase):
    r"""
    Selection from the UI to Snap To. Contains a set of Actors and/or Control Rigs to snap onto or from.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigSnapper.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actors`` (Array[ActorForWorldTransforms]):  [Read-Write]
    - ``control_rigs`` (Array[ControlRigForWorldTransforms]):  [Read-Write]
    """
    def __init__(self, actors: Array[ActorForWorldTransforms] = [], control_rigs: Array[ControlRigForWorldTransforms] = []) -> None:
        ...
    @property
    def actors(self) -> Array[ActorForWorldTransforms]:
        r"""
        (Array[ActorForWorldTransforms]):  [Read-Write]
        """
        ...
    @actors.setter
    def actors(self, value: Array[ActorForWorldTransforms]) -> None:
        ...
    @property
    def control_rigs(self) -> Array[ControlRigForWorldTransforms]:
        r"""
        (Array[ControlRigForWorldTransforms]):  [Read-Write]
        """
        ...
    @control_rigs.setter
    def control_rigs(self, value: Array[ControlRigForWorldTransforms]) -> None:
        ...

class MovieSceneScriptingParams(StructBase):
    r"""
    Movie Scene Scripting Params
    
    **C++ Source:**
    
    - **Plugin**: LevelSequenceEditor
    - **Module**: LevelSequenceEditor
    - **File**: LevelSequenceEditorSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``time_unit`` (MovieSceneTimeUnit):  [Read-Write]
    """
    def __init__(self, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        ...
    @property
    def time_unit(self) -> MovieSceneTimeUnit:
        r"""
        (MovieSceneTimeUnit):  [Read-Write]
        """
        ...
    @time_unit.setter
    def time_unit(self, value: MovieSceneTimeUnit) -> None:
        ...

class AnimNode_PreviewRetargetPose(AnimNode_Base):
    r"""
    a node just to preview a retarget pose
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: IKRetargetAnimInstance.h
    
    """
    def __init__(self) -> None:
        ...

class Object(_ObjectBase):
    r"""
    Direct base class for all UE objects
    note: The full C++ class is located here: Engine\Source\Runtime\CoreUObject\Public\UObject\Object.h
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: NoExportTypes.h
    
    """
    def acquire_editor_element_handle(self, allow_create: bool = True) -> ScriptTypedElementHandle:
        r"""
        x.acquire_editor_element_handle(allow_create=True) -> ScriptTypedElementHandle
        K2 Acquire Editor Object Element Handle
        
        Args:
            allow_create (bool): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...
    def reset_editor_property(self, property_name: Name, change_notify_mode: PropertyAccessChangeNotifyMode = PropertyAccessChangeNotifyMode.DEFAULT) -> bool:
        r"""
        x.reset_editor_property(property_name, change_notify_mode=PropertyAccessChangeNotifyMode.DEFAULT) -> bool
        Attempts to reset the value of a named property on the given object so that it matches the value of the archetype.
        
        Args:
            property_name (Name): The name of the object property to reset the value of.
            change_notify_mode (PropertyAccessChangeNotifyMode): When to emit property change notifications.
        
        Returns:
            bool: Whether the property value was found and correctly reset.
        """
        ...

class Interface(Object):
    r"""
    Interface
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: 
    
    """
    ...

class EditorPathObjectInterface(Interface):
    r"""
    Editor Path Object Interface
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: EditorPathObjectInterface.h
    
    """
    ...

class SlateWidgetStyleContainerBase(Object):
    r"""
    Just a wrapper for the struct with real data in it.
    
    **C++ Source:**
    
    - **Module**: SlateCore
    - **File**: SlateWidgetStyleContainerBase.h
    
    """
    ...

class ButtonWidgetStyle(SlateWidgetStyleContainerBase):
    r"""
    Button Widget Style
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: ButtonWidgetStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``button_style`` (ButtonStyle):  [Read-Write] The actual data describing the button's appearance.
    """
    @property
    def button_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write] The actual data describing the button's appearance.
        """
        ...
    @button_style.setter
    def button_style(self, value: ButtonStyle) -> None:
        ...

class ProgressWidgetStyle(SlateWidgetStyleContainerBase):
    r"""
    Progress Widget Style
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: ProgressWidgetStyle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``progress_bar_style`` (ProgressBarStyle):  [Read-Write] The actual data describing the button's appearance.
    """
    @property
    def progress_bar_style(self) -> ProgressBarStyle:
        r"""
        (ProgressBarStyle):  [Read-Write] The actual data describing the button's appearance.
        """
        ...
    @progress_bar_style.setter
    def progress_bar_style(self, value: ProgressBarStyle) -> None:
        ...

class TypedElementHandleLibrary(Object):
    r"""
    Script exposure for FScriptTypedElementHandle.
    
    **C++ Source:**
    
    - **Module**: TypedElementFramework
    - **File**: TypedElementHandle.h
    
    """
    @classmethod
    def release(cls, element_handle: ScriptTypedElementHandle) -> ScriptTypedElementHandle:
        r"""
        X.release(element_handle) -> ScriptTypedElementHandle
        Release this handle and set it back to an empty state.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            ScriptTypedElementHandle: 
        
            element_handle (ScriptTypedElementHandle):
        """
        ...
    @classmethod
    def not_equal(cls, lhs: ScriptTypedElementHandle, rhs: ScriptTypedElementHandle) -> bool:
        r"""
        X.not_equal(lhs, rhs) -> bool
        Are these two handles not equal?
        
        Args:
            lhs (ScriptTypedElementHandle): 
            rhs (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_set(cls, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        X.is_set(element_handle) -> bool
        Has this handle been initialized to a valid element?
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal(cls, lhs: ScriptTypedElementHandle, rhs: ScriptTypedElementHandle) -> bool:
        r"""
        X.equal(lhs, rhs) -> bool
        Are these two handles equal?
        
        Args:
            lhs (ScriptTypedElementHandle): 
            rhs (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...

class TypedElementRegistry(Object):
    r"""
    Registry of element types and their associated interfaces, along with the elements that represent their instances.
    
    **C++ Source:**
    
    - **Module**: TypedElementFramework
    - **File**: TypedElementRegistry.h
    
    """
    @classmethod
    def get_default_typed_element_registry(cls) -> TypedElementRegistry:
        r"""
        X.get_default_typed_element_registry() -> TypedElementRegistry
        Get the singleton instance of the registry used in most cases.
        
        Returns:
            TypedElementRegistry:
        """
        ...
    def get_element_interface(self, element_handle: ScriptTypedElementHandle, base_interface_type: Class) -> Object:
        r"""
        x.get_element_interface(element_handle, base_interface_type) -> Object
        Get the element interface supported by the given handle, or null if there is no support for this interface or if the handle is invalid.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            base_interface_type (type(Class)): 
        
        Returns:
            Object:
        """
        ...
    def create_element_list(self) -> TypedElementList:
        r"""
        x.create_element_list() -> TypedElementList
        Create an empty list of elements associated with the given registry.
        
        Returns:
            TypedElementList:
        """
        ...

class TypedElementListLibrary(Object):
    r"""
    Typed Element List Library
    
    **C++ Source:**
    
    - **Module**: TypedElementFramework
    - **File**: TypedElementListLibrary.h
    
    """
    @classmethod
    def shrink(cls, element_list: TypedElementList) -> None:
        r"""
        X.shrink(element_list) -> None
        Shrink this element list storage to avoid slack.
        
        Args:
            element_list (TypedElementList):
        """
        ...
    @classmethod
    def reset(cls, element_list: TypedElementList) -> None:
        r"""
        X.reset(element_list) -> None
        Remove all entries from this element list, preserving existing allocations.
        
        Args:
            element_list (TypedElementList):
        """
        ...
    @classmethod
    def reserve(cls, element_list: TypedElementList, size: int) -> None:
        r"""
        X.reserve(element_list, size) -> None
        Pre-allocate enough memory in this element list to store the given number of entries.
        
        Args:
            element_list (TypedElementList): 
            size (int32):
        """
        ...
    @classmethod
    def remove(cls, element_list: TypedElementList, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        X.remove(element_list, element_handle) -> bool
        Remove the given element handle from this element list, if it is in the list.
        
        Args:
            element_list (TypedElementList): 
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool: True if the element handle was removed, false if it isn't in the list.
        """
        ...
    @classmethod
    def num(cls, element_list: TypedElementList) -> int:
        r"""
        X.num(element_list) -> int32
        Get the number of entries within this element list.
        
        Args:
            element_list (TypedElementList): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def is_valid_index(cls, element_list: TypedElementList, index: int) -> bool:
        r"""
        X.is_valid_index(element_list, index) -> bool
        Is the given index a valid entry within this element list?
        
        Args:
            element_list (TypedElementList): 
            index (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def has_elements_of_type(cls, element_list: TypedElementList, element_type_name: Name) -> bool:
        r"""
        X.has_elements_of_type(element_list, element_type_name) -> bool
        Test whether there are elements in this list of the given type.
        
        Args:
            element_list (TypedElementList): 
            element_type_name (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def has_elements(cls, element_list: TypedElementList, base_interface_type: Class = None) -> bool:
        r"""
        X.has_elements(element_list, base_interface_type=None) -> bool
        Test whether there are elements in this list, optionally filtering to elements that implement the given interface.
        
        Args:
            element_list (TypedElementList): 
            base_interface_type (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_element_interface(cls, element_list: TypedElementList, element_handle: ScriptTypedElementHandle, base_interface_type: Class) -> Object:
        r"""
        X.get_element_interface(element_list, element_handle, base_interface_type) -> Object
        Get the element interface from the given handle.
        
        Args:
            element_list (TypedElementList): 
            element_handle (ScriptTypedElementHandle): 
            base_interface_type (type(Class)): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def get_element_handles(cls, element_list: TypedElementList, base_interface_type: Class) -> Array[ScriptTypedElementHandle]:
        r"""
        X.get_element_handles(element_list, base_interface_type) -> Array[ScriptTypedElementHandle]
        Get the handle of every element in this list, optionally filtering to elements that implement the given interface.
        
        Args:
            element_list (TypedElementList): 
            base_interface_type (type(Class)): 
        
        Returns:
            Array[ScriptTypedElementHandle]:
        """
        ...
    @classmethod
    def get_element_handle_at(cls, element_list: TypedElementList, index: int) -> ScriptTypedElementHandle:
        r"""
        X.get_element_handle_at(element_list, index) -> ScriptTypedElementHandle
        Get the element handle at the given index.
        note: Use IsValidIndex to test for validity.
        
        Args:
            element_list (TypedElementList): 
            index (int32): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...
    @classmethod
    def empty(cls, element_list: TypedElementList, slack: int = 0) -> None:
        r"""
        X.empty(element_list, slack=0) -> None
        Remove all entries from this element list, potentially leaving space allocated for the given number of entries.
        
        Args:
            element_list (TypedElementList): 
            slack (int32):
        """
        ...
    @classmethod
    def create_element_list(cls, registry: TypedElementRegistry) -> TypedElementList:
        r"""
        X.create_element_list(registry) -> TypedElementList
        Create an empty list of elements associated with the given registry.
        
        Args:
            registry (TypedElementRegistry): 
        
        Returns:
            TypedElementList:
        """
        ...
    @classmethod
    def count_elements_of_type(cls, element_list: TypedElementList, element_type_name: Name) -> int:
        r"""
        X.count_elements_of_type(element_list, element_type_name) -> int32
        Count the number of elements in this list of the given type.
        
        Args:
            element_list (TypedElementList): 
            element_type_name (Name): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def count_elements(cls, element_list: TypedElementList, base_interface_type: Class = None) -> int:
        r"""
        X.count_elements(element_list, base_interface_type=None) -> int32
        Count the number of elements in this list, optionally filtering to elements that implement the given interface.
        
        Args:
            element_list (TypedElementList): 
            base_interface_type (type(Class)): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def contains(cls, element_list: TypedElementList, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        X.contains(element_list, element_handle) -> bool
        Does this element list contain an entry for the given element handle?
        
        Args:
            element_list (TypedElementList): 
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def clone(cls, element_list: TypedElementList) -> TypedElementList:
        r"""
        X.clone(element_list) -> TypedElementList
        Clone this list instance.
        note: Only copies elements; does not copy any bindings!
        
        Args:
            element_list (TypedElementList): 
        
        Returns:
            TypedElementList:
        """
        ...
    @classmethod
    def append_list(cls, element_list: TypedElementList, other_element_list: TypedElementList) -> None:
        r"""
        X.append_list(element_list, other_element_list) -> None
        Append the another element list to this element list.
        
        Args:
            element_list (TypedElementList): 
            other_element_list (TypedElementList):
        """
        ...
    @classmethod
    def append(cls, element_list: TypedElementList, element_handles: Array[ScriptTypedElementHandle]) -> None:
        r"""
        X.append(element_list, element_handles) -> None
        Append the given element handles to this element list.
        
        Args:
            element_list (TypedElementList): 
            element_handles (Array[ScriptTypedElementHandle]):
        """
        ...
    @classmethod
    def add(cls, element_list: TypedElementList, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        X.add(element_list, element_handle) -> bool
        Add the given element handle to this element list, if it isn't already in the list.
        
        Args:
            element_list (TypedElementList): 
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool: True if the element handle was added, false if it is already in the list.
        """
        ...

class TestTypedElementInterfaceA(Interface):
    r"""
    Test Typed Element Interface A
    
    **C++ Source:**
    
    - **Module**: TypedElementFramework
    - **File**: TypedElementFrameworkTests.h
    
    """
    def set_display_name(self, element_handle: ScriptTypedElementHandle, new_name: Text, notify: bool = True) -> bool:
        r"""
        x.set_display_name(element_handle, new_name, notify=True) -> bool
        Set Display Name
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            new_name (Text): 
            notify (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_display_name(self, element_handle: ScriptTypedElementHandle) -> Text:
        r"""
        x.get_display_name(element_handle) -> Text
        Get Display Name
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            Text:
        """
        ...

class TestTypedElementInterfaceB(Interface):
    r"""
    Test Typed Element Interface B
    
    **C++ Source:**
    
    - **Module**: TypedElementFramework
    - **File**: TypedElementFrameworkTests.h
    
    """
    def mark_as_tested(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.mark_as_tested(element_handle) -> bool
        Mark as Tested
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...

class TestTypedElementInterfaceC(Interface):
    r"""
    Test Typed Element Interface C
    
    **C++ Source:**
    
    - **Module**: TypedElementFramework
    - **File**: TypedElementFrameworkTests.h
    
    """
    def get_is_tested(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.get_is_tested(element_handle) -> bool
        Get Is Tested
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...

class TypedElementSelectionSet(Object):
    r"""
    A wrapper around an element list that ensures mutation goes via the selection
    interfaces, as well as providing some utilities for batching operations.
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementSelectionSet.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_pre_selection_change`` (OnPreChangeDynamic):  [Read-Write] Delegate that is invoked whenever the underlying element list is potentially about to change.
    - ``on_selection_change`` (OnChangeDynamic):  [Read-Write] Delegate that is invoked whenever the underlying element list has been changed.
    """
    @property
    def on_pre_selection_change(self) -> OnPreChangeDynamic:
        r"""
        (OnPreChangeDynamic):  [Read-Write] Delegate that is invoked whenever the underlying element list is potentially about to change.
        """
        ...
    @on_pre_selection_change.setter
    def on_pre_selection_change(self, value: OnPreChangeDynamic) -> None:
        ...
    @property
    def on_selection_change(self) -> OnChangeDynamic:
        r"""
        (OnChangeDynamic):  [Read-Write] Delegate that is invoked whenever the underlying element list has been changed.
        """
        ...
    @on_selection_change.setter
    def on_selection_change(self, value: OnChangeDynamic) -> None:
        ...
    def set_selection(self, element_handles: Array[ScriptTypedElementHandle], selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.set_selection(element_handles, selection_options) -> bool
        Attempt to make the selection the given elements.
        note: Equivalent to calling ClearSelection then SelectElements, but happens in a single batch.
        
        Args:
            element_handles (Array[ScriptTypedElementHandle]): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    def select_elements(self, element_handles: Array[ScriptTypedElementHandle], selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.select_elements(element_handles, selection_options) -> bool
        Attempt to select the given elements.
        
        Args:
            element_handles (Array[ScriptTypedElementHandle]): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    def select_element(self, element_handle: ScriptTypedElementHandle, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.select_element(element_handle, selection_options) -> bool
        Attempt to select the given element.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    def restore_selection_state(self, selection_state: TypedElementSelectionSetState) -> None:
        r"""
        x.restore_selection_state(selection_state) -> None
        Restores the selection set from the given state.
        The calling code is responsible for managing any undo state.
        
        Args:
            selection_state (TypedElementSelectionSetState):
        """
        ...
    def get_selected_element_handles(self, base_interface_type: Class = None) -> Array[ScriptTypedElementHandle]:
        r"""
        x.get_selected_element_handles(base_interface_type=None) -> Array[ScriptTypedElementHandle]
        Get the handle of every selected element, optionally filtering to elements that implement the given interface.
        
        Args:
            base_interface_type (type(Class)): 
        
        Returns:
            Array[ScriptTypedElementHandle]:
        """
        ...
    def is_element_selected(self, element_handle: ScriptTypedElementHandle, selection_options: TypedElementIsSelectedOptions) -> bool:
        r"""
        x.is_element_selected(element_handle, selection_options) -> bool
        Test to see whether the given element is currently considered selected.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_options (TypedElementIsSelectedOptions): 
        
        Returns:
            bool:
        """
        ...
    def has_selected_objects(self, required_class: Class = None) -> bool:
        r"""
        x.has_selected_objects(required_class=None) -> bool
        Test whether there are any selected objects.
        
        Args:
            required_class (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    def has_selected_elements(self, base_interface_type: Class = None) -> bool:
        r"""
        x.has_selected_elements(base_interface_type=None) -> bool
        Test whether there selected elements, optionally filtering to elements that implement the given interface.
        
        Args:
            base_interface_type (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    def get_top_selected_object(self, required_class: Class = None) -> Object:
        r"""
        x.get_top_selected_object(required_class=None) -> Object
        Get the first selected object of the given type.
        
        Args:
            required_class (type(Class)): 
        
        Returns:
            Object:
        """
        ...
    def get_selection_element(self, element_handle: ScriptTypedElementHandle, selection_method: TypedElementSelectionMethod) -> ScriptTypedElementHandle:
        r"""
        x.get_selection_element(element_handle, selection_method) -> ScriptTypedElementHandle
        Given an element, return the element that should actually perform a selection operation.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_method (TypedElementSelectionMethod): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...
    def get_selected_objects(self, required_class: Class = None) -> Array[Object]:
        r"""
        x.get_selected_objects(required_class=None) -> Array[Object]
        Get the array of selected objects from the currently selected elements.
        
        Args:
            required_class (type(Class)): 
        
        Returns:
            Array[Object]:
        """
        ...
    def get_num_selected_elements(self) -> int:
        r"""
        x.get_num_selected_elements() -> int32
        Get the number of selected elements.
        
        Returns:
            int32:
        """
        ...
    def get_current_selection_state(self) -> TypedElementSelectionSetState:
        r"""
        x.get_current_selection_state() -> TypedElementSelectionSetState
        Serializes the current selection set.
        The calling code is responsible for storing any state information. The selection set can be returned to a prior state using RestoreSelectionState.
        
        Returns:
            TypedElementSelectionSetState: the current state of the selection set.
        """
        ...
    def get_bottom_selected_object(self, required_class: Class = None) -> Object:
        r"""
        x.get_bottom_selected_object(required_class=None) -> Object
        Get the last selected object of the given type.
        
        Args:
            required_class (type(Class)): 
        
        Returns:
            Object:
        """
        ...
    def deselect_elements(self, element_handles: Array[ScriptTypedElementHandle], selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.deselect_elements(element_handles, selection_options) -> bool
        Attempt to deselect the given elements.
        
        Args:
            element_handles (Array[ScriptTypedElementHandle]): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    def deselect_element(self, element_handle: ScriptTypedElementHandle, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.deselect_element(element_handle, selection_options) -> bool
        Attempt to deselect the given element.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    def count_selected_objects(self, required_class: Class = None) -> int:
        r"""
        x.count_selected_objects(required_class=None) -> int32
        Count the number of selected objects.
        
        Args:
            required_class (type(Class)): 
        
        Returns:
            int32:
        """
        ...
    def count_selected_elements(self, base_interface_type: Class = None) -> int:
        r"""
        x.count_selected_elements(base_interface_type=None) -> int32
        Count the number of selected elements, optionally filtering to elements that implement the given interface.
        
        Args:
            base_interface_type (type(Class)): 
        
        Returns:
            int32:
        """
        ...
    def clear_selection(self, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.clear_selection(selection_options) -> bool
        Clear the current selection.
        
        Args:
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    def can_select_element(self, element_handle: ScriptTypedElementHandle, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.can_select_element(element_handle, selection_options) -> bool
        Test to see whether the given element can be selected.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool:
        """
        ...
    def can_deselect_element(self, element_handle: ScriptTypedElementHandle, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.can_deselect_element(element_handle, selection_options) -> bool
        Test to see whether the given element can be deselected.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool:
        """
        ...
    def allow_selection_modifiers(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.allow_selection_modifiers(element_handle) -> bool
        Test to see whether selection modifiers (Ctrl or Shift) are allowed while selecting this element.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    def set_selection_from_list(self, element_list: TypedElementList, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.set_selection_from_list(element_list, selection_options) -> bool
        Attempt to make the selection the given elements.
        note: Equivalent to calling ClearSelection then SelectElements, but happens in a single batch.
        
        Args:
            element_list (TypedElementList): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    def select_elements_from_list(self, element_list: TypedElementList, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.select_elements_from_list(element_list, selection_options) -> bool
        Attempt to select the given elements.
        
        Args:
            element_list (TypedElementList): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    def get_normalized_selection(self, normalization_options: TypedElementSelectionNormalizationOptions) -> TypedElementList:
        r"""
        x.get_normalized_selection(normalization_options) -> TypedElementList
        Get a normalized version of this selection set that can be used to perform operations like gizmo manipulation, deletion, copying, etc.
        This will do things like expand out groups, and resolve any parent<->child elements so that duplication operations aren't performed on both the parent and the child.
        
        Args:
            normalization_options (TypedElementSelectionNormalizationOptions): 
        
        Returns:
            TypedElementList:
        """
        ...
    def get_normalized_element_list(self, element_list: TypedElementList, normalization_options: TypedElementSelectionNormalizationOptions) -> TypedElementList:
        r"""
        x.get_normalized_element_list(element_list, normalization_options) -> TypedElementList
        Get a normalized version of the given element list that can be used to perform operations like gizmo manipulation, deletion, copying, etc.
        This will do things like expand out groups, and resolve any parent<->child elements so that duplication operations aren't performed on both the parent and the child.
        
        Args:
            element_list (TypedElementList): 
            normalization_options (TypedElementSelectionNormalizationOptions): 
        
        Returns:
            TypedElementList:
        """
        ...
    def deselect_elements_from_list(self, element_list: TypedElementList, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.deselect_elements_from_list(element_list, selection_options) -> bool
        Attempt to deselect the given elements.
        
        Args:
            element_list (TypedElementList): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...

class TypedElementSelectionSetLibrary(Object):
    r"""
    Library of functions for the scripting of Typed Elements that use both a selection set and a element list
    
    Note: These functions should only be used for scripting purposes only as they come at higher performance cost then their non script implementation
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementSelectionSetLibrary.h
    
    """
    @classmethod
    def set_selection_from_list(cls, selection_set: TypedElementSelectionSet, element_list: TypedElementList, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        X.set_selection_from_list(selection_set, element_list, selection_options) -> bool
        Attempt to make the selection the given elements.
        note: Equivalent to calling ClearSelection then SelectElements, but happens in a single batch.
        
        Args:
            selection_set (TypedElementSelectionSet): 
            element_list (TypedElementList): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    @classmethod
    def select_elements_from_list(cls, selection_set: TypedElementSelectionSet, element_list: TypedElementList, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        X.select_elements_from_list(selection_set, element_list, selection_options) -> bool
        Attempt to select the given elements.
        
        Args:
            selection_set (TypedElementSelectionSet): 
            element_list (TypedElementList): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    @classmethod
    def get_normalized_selection(cls, selection_set: TypedElementSelectionSet, normalization_options: TypedElementSelectionNormalizationOptions) -> TypedElementList:
        r"""
        X.get_normalized_selection(selection_set, normalization_options) -> TypedElementList
        Get a normalized version of this selection set that can be used to perform operations like gizmo manipulation, deletion, copying, etc.
        This will do things like expand out groups, and resolve any parent<->child elements so that duplication operations aren't performed on both the parent and the child.
        
        Args:
            selection_set (TypedElementSelectionSet): 
            normalization_options (TypedElementSelectionNormalizationOptions): 
        
        Returns:
            TypedElementList:
        """
        ...
    @classmethod
    def get_normalized_element_list(cls, selection_set: TypedElementSelectionSet, element_list: TypedElementList, normalization_options: TypedElementSelectionNormalizationOptions) -> TypedElementList:
        r"""
        X.get_normalized_element_list(selection_set, element_list, normalization_options) -> TypedElementList
        Get a normalized version of the given element list that can be used to perform operations like gizmo manipulation, deletion, copying, etc.
        This will do things like expand out groups, and resolve any parent<->child elements so that duplication operations aren't performed on both the parent and the child.
        
        Args:
            selection_set (TypedElementSelectionSet): 
            element_list (TypedElementList): 
            normalization_options (TypedElementSelectionNormalizationOptions): 
        
        Returns:
            TypedElementList:
        """
        ...
    @classmethod
    def deselect_elements_from_list(cls, selection_set: TypedElementSelectionSet, element_list: TypedElementList, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        X.deselect_elements_from_list(selection_set, element_list, selection_options) -> bool
        Attempt to deselect the given elements.
        
        Args:
            selection_set (TypedElementSelectionSet): 
            element_list (TypedElementList): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...

class TypedElementAssetDataInterface(Interface):
    r"""
    Typed Element Asset Data Interface
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementAssetDataInterface.h
    
    """
    def get_asset_data(self, element_handle: ScriptTypedElementHandle) -> AssetData:
        r"""
        x.get_asset_data(element_handle) -> AssetData
        Returns the asset data for the given handle, if it exists.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            AssetData:
        """
        ...
    def get_all_referenced_asset_datas(self, element_handle: ScriptTypedElementHandle) -> Array[AssetData]:
        r"""
        x.get_all_referenced_asset_datas(element_handle) -> Array[AssetData]
        Returns any asset datas for content objects referenced by handle.
        If the given handle itself has valid asset data, it should be returned as the last element of the array.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            Array[AssetData]: An array of valid asset datas.
        """
        ...

class TypedElementHierarchyInterface(Interface):
    r"""
    Typed Element Hierarchy Interface
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementHierarchyInterface.h
    
    """
    def get_parent_element(self, element_handle: ScriptTypedElementHandle, allow_create: bool = True) -> ScriptTypedElementHandle:
        r"""
        x.get_parent_element(element_handle, allow_create=True) -> ScriptTypedElementHandle
        Get the logical parent of this element, if any.
        eg) A component might return its actor, or a static mesh instance might return its ISM component.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            allow_create (bool): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...
    def get_child_elements(self, element_handle: ScriptTypedElementHandle, allow_create: bool = True) -> Array[ScriptTypedElementHandle]:
        r"""
        x.get_child_elements(element_handle, allow_create=True) -> Array[ScriptTypedElementHandle]
        Get the logical children of this element, if any.
        eg) An actor might return its component, or an ISM component might return its static mesh instances.
        note: Appends to OutElementHandles.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            allow_create (bool): 
        
        Returns:
            Array[ScriptTypedElementHandle]: 
        
            out_element_handles (Array[ScriptTypedElementHandle]):
        """
        ...

class TypedElementObjectInterface(Interface):
    r"""
    Typed Element Object Interface
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementObjectInterface.h
    
    """
    def get_object_class(self, element_handle: ScriptTypedElementHandle) -> Class:
        r"""
        x.get_object_class(element_handle) -> type(Class)
        Gets the object instance's class that the handle represents, if any.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            type(Class):
        """
        ...
    def get_object(self, element_handle: ScriptTypedElementHandle) -> Object:
        r"""
        x.get_object(element_handle) -> Object
        Get the object instance that this handle represents, if any.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            Object:
        """
        ...

class TypedElementPrimitiveCustomDataInterface(Interface):
    r"""
    Typed Element Primitive Custom Data Interface
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementPrimitiveCustomDataInterface.h
    
    """
    def set_custom_data_value(self, element_handle: ScriptTypedElementHandle, custom_data_index: int, custom_data_value: float, mark_render_state_dirty: bool = False) -> None:
        r"""
        x.set_custom_data_value(element_handle, custom_data_index, custom_data_value, mark_render_state_dirty=False) -> None
        Sets a single Primitive's CustomData value
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            custom_data_index (int32): 
            custom_data_value (float): 
            mark_render_state_dirty (bool):
        """
        ...
    def set_custom_data(self, element_handle: ScriptTypedElementHandle, custom_data_floats: Array[float], mark_render_state_dirty: bool = False) -> None:
        r"""
        x.set_custom_data(element_handle, custom_data_floats, mark_render_state_dirty=False) -> None
        Sets all Primitive's CustomData values
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            custom_data_floats (Array[float]): 
            mark_render_state_dirty (bool):
        """
        ...

class TypedElementSelectionInterface(Interface):
    r"""
    Typed Element Selection Interface
    
    **C++ Source:**
    
    - **Module**: TypedElementRuntime
    - **File**: TypedElementSelectionInterface.h
    
    """
    def select_element(self, element_handle: ScriptTypedElementHandle, selection_set: TypedElementList, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.select_element(element_handle, selection_set, selection_options) -> bool
        Attempt to select the given element.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_set (TypedElementList): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    def is_element_selected(self, element_handle: ScriptTypedElementHandle, selection_set: TypedElementList, selection_options: TypedElementIsSelectedOptions) -> bool:
        r"""
        x.is_element_selected(element_handle, selection_set, selection_options) -> bool
        Test to see whether the given element is currently considered selected.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_set (TypedElementList): 
            selection_options (TypedElementIsSelectedOptions): 
        
        Returns:
            bool:
        """
        ...
    def get_selection_element(self, element_handle: ScriptTypedElementHandle, current_selection: TypedElementList, selection_method: TypedElementSelectionMethod) -> ScriptTypedElementHandle:
        r"""
        x.get_selection_element(element_handle, current_selection, selection_method) -> ScriptTypedElementHandle
        Given an element, return the element that should actually perform a selection operation.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            current_selection (TypedElementList): 
            selection_method (TypedElementSelectionMethod): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...
    def deselect_element(self, element_handle: ScriptTypedElementHandle, selection_set: TypedElementList, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.deselect_element(element_handle, selection_set, selection_options) -> bool
        Attempt to deselect the given element.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_set (TypedElementList): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool: True if the selection was changed, false otherwise.
        """
        ...
    def can_select_element(self, element_handle: ScriptTypedElementHandle, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.can_select_element(element_handle, selection_options) -> bool
        Test to see whether the given element can be selected.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool:
        """
        ...
    def can_deselect_element(self, element_handle: ScriptTypedElementHandle, selection_options: TypedElementSelectionOptions) -> bool:
        r"""
        x.can_deselect_element(element_handle, selection_options) -> bool
        Test to see whether the given element can be deselected.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_options (TypedElementSelectionOptions): 
        
        Returns:
            bool:
        """
        ...
    def allow_selection_modifiers(self, element_handle: ScriptTypedElementHandle, selection_set: TypedElementList) -> bool:
        r"""
        x.allow_selection_modifiers(element_handle, selection_set) -> bool
        Test to see whether selection modifiers (Ctrl or Shift) are allowed while selecting this element.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            selection_set (TypedElementList): 
        
        Returns:
            bool:
        """
        ...

class SharedImageConstRefBlueprintFns(Object):
    r"""
    Shared Image Const Ref Blueprint Fns
    
    **C++ Source:**
    
    - **Module**: ImageCore
    - **File**: ImageCoreBP.h
    
    """
    @classmethod
    def is_valid(cls, image: SharedImageConstRefBlueprint) -> bool:
        r"""
        X.is_valid(image) -> bool
        Is Valid
        
        Args:
            image (SharedImageConstRefBlueprint): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_width(cls, image: SharedImageConstRefBlueprint) -> int:
        r"""
        X.get_width(image) -> int32
        Returns -1 if Image is invalid
        
        Args:
            image (SharedImageConstRefBlueprint): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_size(cls, image: SharedImageConstRefBlueprint) -> Vector2f:
        r"""
        X.get_size(image) -> Vector2f
        Returns (-1, -1) if Image is invalid
        
        Args:
            image (SharedImageConstRefBlueprint): 
        
        Returns:
            Vector2f:
        """
        ...
    @classmethod
    def get_pixel_value(cls, image: SharedImageConstRefBlueprint, x: int, y: int) -> Tuple[Vector4f, bool]:
        r"""
        X.get_pixel_value(image, x, y) -> (Vector4f, valid=bool)
        Returns the value in the texture for the given pixel as a float vector. If the input position is invalid, the format is invalid,
        or the reference isn't set, bValid will be false and the function will return FVector4(0,0,0,0).
        
        Pixel values are directly returned with no gamma transformation to allow for lookup tables. Also note that
        8 bit formats that you might normally expect to be normalized to 0..1 will return their values directly as 0..256.
        
        This supports all image formats.
        
        G8 is replicated to X/Y/Z/1.
        R16/R32 is returned as R/0/0/1.
        
        Do not use this for full image processing as it will be extremely slow, contact support if you need such
        functionality.
        
        Args:
            image (SharedImageConstRefBlueprint): 
            x (int32): 
            y (int32): 
        
        Returns:
            bool: 
        
            valid (bool):
        """
        ...
    @classmethod
    def get_pixel_linear_color(cls, image: SharedImageConstRefBlueprint, x: int, y: int, failure_color: LinearColor = [0.000000, 0.000000, 0.000000, 1.000000]) -> Tuple[LinearColor, bool]:
        r"""
        X.get_pixel_linear_color(image, x, y, failure_color=[0.000000, 0.000000, 0.000000, 1.000000]) -> (LinearColor, valid=bool)
        Returns the color value for the given pixel. If the input position is invalid, the format is invalid,
        or the reference isn't set, bValid will be false and the function will return FailureColor. The color
        is converted using the image's gamma space in to linear space.
        
        Do not use this for full image processing as it will be extremely slow, contact support if you need such
        functionality.
        
        Args:
            image (SharedImageConstRefBlueprint): 
            x (int32): 
            y (int32): 
            failure_color (LinearColor): 
        
        Returns:
            bool: 
        
            valid (bool):
        """
        ...
    @classmethod
    def get_height(cls, image: SharedImageConstRefBlueprint) -> int:
        r"""
        X.get_height(image) -> int32
        Returns -1 if Image is invalid
        
        Args:
            image (SharedImageConstRefBlueprint): 
        
        Returns:
            int32:
        """
        ...

class AssetRegistryHelpers(Object):
    r"""
    Asset Registry Helpers
    
    **C++ Source:**
    
    - **Module**: AssetRegistry
    - **File**: AssetRegistryHelpers.h
    
    """
    @classmethod
    def to_soft_object_path(cls, asset_data: AssetData) -> SoftObjectPath:
        r"""
        X.to_soft_object_path(asset_data) -> SoftObjectPath
        Convert to a SoftObjectPath for loading
        
        Args:
            asset_data (AssetData): 
        
        Returns:
            SoftObjectPath:
        """
        ...
    @classmethod
    def set_filter_tags_and_values(cls, filter: ARFilter, tags_and_values: Array[TagAndValue]) -> ARFilter:
        r"""
        X.set_filter_tags_and_values(filter, tags_and_values) -> ARFilter
        Populates the FARFilters tags and values map with the passed in tags and values
        
        Args:
            filter (ARFilter): 
            tags_and_values (Array[TagAndValue]): 
        
        Returns:
            ARFilter:
        """
        ...
    @classmethod
    def is_valid(cls, asset_data: AssetData) -> bool:
        r"""
        X.is_valid(asset_data) -> bool
        Checks to see if this AssetData refers to an asset or is NULL
        
        Args:
            asset_data (AssetData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_u_asset(cls, asset_data: AssetData) -> bool:
        r"""
        X.is_u_asset(asset_data) -> bool
        Returns true if this is the primary asset in a package, true for maps and assets but false for secondary objects like class redirectors
        
        Args:
            asset_data (AssetData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_redirector(cls, asset_data: AssetData) -> bool:
        r"""
        X.is_redirector(asset_data) -> bool
        Returns true if the this asset is a redirector.
        
        Args:
            asset_data (AssetData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_asset_loaded(cls, asset_data: AssetData) -> bool:
        r"""
        X.is_asset_loaded(asset_data) -> bool
        Returns true if the asset is loaded
        
        Args:
            asset_data (AssetData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_tag_value(cls, asset_data: AssetData, tag_name: Name) -> Optional[str]:
        r"""
        X.get_tag_value(asset_data, tag_name) -> str or None
        Gets the value associated with the given tag as a string
        
        Args:
            asset_data (AssetData): 
            tag_name (Name): 
        
        Returns:
            str or None: 
        
            out_tag_value (str):
        """
        ...
    @classmethod
    def get_full_name(cls, asset_data: AssetData) -> str:
        r"""
        X.get_full_name(asset_data) -> str
        Returns the full name for the asset in the form: Class ObjectPath
        
        Args:
            asset_data (AssetData): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_export_text_name(cls, asset_data: AssetData) -> str:
        r"""
        X.get_export_text_name(asset_data) -> str
        Returns the name for the asset in the form: Class'ObjectPath'
        
        Args:
            asset_data (AssetData): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_class(cls, asset_data: AssetData) -> Class:
        r"""
        X.get_class(asset_data) -> type(Class)
        Get Class
        
        Args:
            asset_data (AssetData): 
        
        Returns:
            type(Class):
        """
        ...
    @classmethod
    def get_blueprint_assets(cls, filter: ARFilter) -> Array[AssetData]:
        r"""
        X.get_blueprint_assets(filter) -> Array[AssetData]
        Gets asset data for all blueprint assets that match the filter. ClassPaths in the filter specify the blueprint's parent class.
        
        Args:
            filter (ARFilter): 
        
        Returns:
            Array[AssetData]: 
        
            out_asset_data (Array[AssetData]):
        """
        ...
    @classmethod
    def get_asset_registry(cls) -> AssetRegistry:
        r"""
        X.get_asset_registry() -> AssetRegistry
        Get Asset Registry
        
        Returns:
            AssetRegistry:
        """
        ...
    @classmethod
    def get_asset(cls, asset_data: AssetData) -> Object:
        r"""
        X.get_asset(asset_data) -> Object
        Returns the asset UObject if it is loaded or loads the asset if it is unloaded then returns the result
        
        Args:
            asset_data (AssetData): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def find_asset_native_class(cls, asset_data: AssetData) -> Class:
        r"""
        X.find_asset_native_class(asset_data) -> type(Class)
        Returns the first native class of the asset type that can be found.  Normally this is just the FAssetData::GetClass(),
        however if the class is a blueprint generated class it may not be loaded.  In which case GetAncestorClassNames will
        be used to find the first native super class.  This can be slow if temporary caching mode is not on.
        
        Args:
            asset_data (AssetData): 
        
        Returns:
            type(Class):
        """
        ...
    @classmethod
    def create_asset_data(cls, asset: Object, allow_blueprint_class: bool = False) -> AssetData:
        r"""
        X.create_asset_data(asset, allow_blueprint_class=False) -> AssetData
        Creates asset data from a UObject.
        
        Args:
            asset (Object): The asset to create asset data for
            allow_blueprint_class (bool): By default trying to create asset data for a blueprint class will create one for the UBlueprint instead
        
        Returns:
            AssetData:
        """
        ...

class AssetRegistry(Interface):
    r"""
    Asset Registry
    
    **C++ Source:**
    
    - **Module**: AssetRegistry
    - **File**: IAssetRegistry.h
    
    """
    def wait_for_package(self, package_name: str) -> None:
        r"""
        x.wait_for_package(package_name) -> None
        Wait for the scan of a specific package to be complete
        
        Args:
            package_name (str):
        """
        ...
    def wait_for_completion(self) -> None:
        r"""
        x.wait_for_completion() -> None
        Wait for scan to be complete. If called during editor startup before OnPostEngineInit, and there are any assets that use classes in
        not-yet-loaded plugin modules, WaitForCompletion will return silently with those assets still ungathered.
        """
        ...
    def use_filter_to_exclude_assets(self, asset_data_list: Array[AssetData], filter: ARFilter) -> Array[AssetData]:
        r"""
        x.use_filter_to_exclude_assets(asset_data_list, filter) -> Array[AssetData]
        Trims items out of the asset data list that pass the supplied filter
        
        Args:
            asset_data_list (Array[AssetData]): 
            filter (ARFilter): 
        
        Returns:
            Array[AssetData]: 
        
            asset_data_list (Array[AssetData]):
        """
        ...
    def search_all_assets(self, synchronous_search: bool) -> None:
        r"""
        x.search_all_assets(synchronous_search) -> None
        Look for all assets on disk (can be async or synchronous)
        
        Args:
            synchronous_search (bool):
        """
        ...
    def scan_paths_synchronous(self, paths: Array[str], force_rescan: bool = False, ignore_deny_list_scan_filters: bool = False) -> None:
        r"""
        x.scan_paths_synchronous(paths, force_rescan=False, ignore_deny_list_scan_filters=False) -> None
        Scan the supplied paths recursively right now and populate the asset registry. If bForceRescan is true, the paths will be scanned again, even if they were previously scanned
        
        Args:
            paths (Array[str]): 
            force_rescan (bool): 
            ignore_deny_list_scan_filters (bool):
        """
        ...
    def scan_modified_asset_files(self, file_paths: Array[str]) -> None:
        r"""
        x.scan_modified_asset_files(file_paths) -> None
        Forces a rescan of specific filenames, call this when you need to refresh from disk
        
        Args:
            file_paths (Array[str]):
        """
        ...
    def scan_files_synchronous(self, file_paths: Array[str], force_rescan: bool = False) -> None:
        r"""
        x.scan_files_synchronous(file_paths, force_rescan=False) -> None
        Scan the specified individual files right now and populate the asset registry. If bForceRescan is true, the paths will be scanned again, even if they were previously scanned
        
        Args:
            file_paths (Array[str]): 
            force_rescan (bool):
        """
        ...
    def run_assets_through_filter(self, asset_data_list: Array[AssetData], filter: ARFilter) -> Array[AssetData]:
        r"""
        x.run_assets_through_filter(asset_data_list, filter) -> Array[AssetData]
        Trims items out of the asset data list that do not pass the supplied filter
        
        Args:
            asset_data_list (Array[AssetData]): 
            filter (ARFilter): 
        
        Returns:
            Array[AssetData]: 
        
            asset_data_list (Array[AssetData]):
        """
        ...
    def prioritize_search_path(self, path_to_prioritize: str) -> None:
        r"""
        x.prioritize_search_path(path_to_prioritize) -> None
        If assets are currently being asynchronously scanned in the specified path, this will cause them to be scanned before other assets.
        
        Args:
            path_to_prioritize (str):
        """
        ...
    def get_referencers(self, package_name: Name, reference_options: AssetRegistryDependencyOptions) -> Optional[Array[Name]]:
        r"""
        x.get_referencers(package_name, reference_options) -> Array[Name] or None
        Gets a list of packages that reference the supplied package. (On disk references ONLY)
        
        Args:
            package_name (Name): the name of the package for which to gather dependencies (eg, /Game/MyFolder/MyAsset)
            reference_options (AssetRegistryDependencyOptions): which kinds of references to include in the output list
        
        Returns:
            Array[Name] or None: 
        
            out_referencers (Array[Name]): a list of packages that reference the package whose path is PackageName
        """
        ...
    def get_dependencies(self, package_name: Name, dependency_options: AssetRegistryDependencyOptions) -> Optional[Array[Name]]:
        r"""
        x.get_dependencies(package_name, dependency_options) -> Array[Name] or None
        Gets a list of paths to objects that are referenced by the supplied package. (On disk references ONLY)
        
        Args:
            package_name (Name): the name of the package for which to gather dependencies (eg, /Game/MyFolder/MyAsset)
            dependency_options (AssetRegistryDependencyOptions): which kinds of dependencies to include in the output list
        
        Returns:
            Array[Name] or None: 
        
            out_dependencies (Array[Name]): a list of packages that are referenced by the package whose path is PackageName
        """
        ...
    def k2_get_asset_by_object_path(self, object_path: SoftObjectPath, include_only_on_disk_assets: bool = False, skip_ar_filtered_assets: bool = True) -> AssetData:
        r"""
        x.k2_get_asset_by_object_path(object_path, include_only_on_disk_assets=False, skip_ar_filtered_assets=True) -> AssetData
        Gets the asset data for the specified object path
        see: IAssetRegistry class header for bIncludeOnlyOnDiskAssets.
        
        Args:
            object_path (SoftObjectPath): the path of the object to be looked up
            include_only_on_disk_assets (bool): If true, use only DiskGatheredData, do not calculate from UObjects.
            skip_ar_filtered_assets (bool): If true, skips Objects that return true for IsAsset but are not assets in the current platform.
        
        Returns:
            AssetData: the assets data;Will be invalid if object could not be found
        """
        ...
    def is_search_async(self) -> bool:
        r"""
        x.is_search_async() -> bool
        Whether searching is done async (and was started at startup), or synchronously and on-demand, requiring ScanPathsSynchronous or SearchAllAssets.
        
        Returns:
            bool:
        """
        ...
    def is_search_all_assets(self) -> bool:
        r"""
        x.is_search_all_assets() -> bool
        Whether SearchAllAssets has been called, or was auto-called at startup. When async (editor or cooking), if SearchAllAssets has ever been called,
        any newly-mounted directory will be automatically searched.
        
        Returns:
            bool:
        """
        ...
    def is_loading_assets(self) -> bool:
        r"""
        x.is_loading_assets() -> bool
        Returns true if the asset registry is currently loading files and does not yet know about all assets
        
        Returns:
            bool:
        """
        ...
    def has_assets(self, package_path: Name, recursive: bool = False) -> bool:
        r"""
        x.has_assets(package_path, recursive=False) -> bool
        Does the given path contain assets, optionally also testing sub-paths?
        
        Args:
            package_path (Name): the path to query asset data in (eg, /Game/MyFolder)
            recursive (bool): if true, the supplied path will be tested recursively
        
        Returns:
            bool:
        """
        ...
    def get_sub_paths(self, base_path: str, recurse: bool) -> Array[str]:
        r"""
        x.get_sub_paths(base_path, recurse) -> Array[str]
        Gets a list of all paths that are currently cached below the passed-in base path
        
        Args:
            base_path (str): 
            recurse (bool): 
        
        Returns:
            Array[str]: 
        
            out_path_list (Array[str]):
        """
        ...
    def get_derived_class_names(self, class_names: Array[TopLevelAssetPath], excluded_class_names: Set[TopLevelAssetPath]) -> Set[TopLevelAssetPath]:
        r"""
        x.get_derived_class_names(class_names, excluded_class_names) -> Set[TopLevelAssetPath]
        Returns the names of all classes derived by the supplied class names, excluding any classes matching the excluded class names. This can be slow if temporary caching mode is not on
        
        Args:
            class_names (Array[TopLevelAssetPath]): 
            excluded_class_names (Set[TopLevelAssetPath]): 
        
        Returns:
            Set[TopLevelAssetPath]: 
        
            out_derived_class_names (Set[TopLevelAssetPath]):
        """
        ...
    def get_assets_by_paths(self, package_paths: Array[Name], recursive: bool = False, include_only_on_disk_assets: bool = False) -> Optional[Array[AssetData]]:
        r"""
        x.get_assets_by_paths(package_paths, recursive=False, include_only_on_disk_assets=False) -> Array[AssetData] or None
        Gets asset data for all assets in any of the supplied folder paths
        see: IAssetRegistry class header for bIncludeOnlyOnDiskAssets.
        
        Args:
            package_paths (Array[Name]): the paths to query asset data in (eg, /Game/MyFolder)
            recursive (bool): if true, all supplied paths will be searched recursively
            include_only_on_disk_assets (bool): If true, use only DiskGatheredData, do not calculate from UObjects.
        
        Returns:
            Array[AssetData] or None: 
        
            out_asset_data (Array[AssetData]): the list of assets in this path
        """
        ...
    def get_assets_by_path(self, package_path: Name, recursive: bool = False, include_only_on_disk_assets: bool = False) -> Optional[Array[AssetData]]:
        r"""
        x.get_assets_by_path(package_path, recursive=False, include_only_on_disk_assets=False) -> Array[AssetData] or None
        Gets asset data for all assets in the supplied folder path
        see: IAssetRegistry class header for bIncludeOnlyOnDiskAssets.
        
        Args:
            package_path (Name): the path to query asset data in (eg, /Game/MyFolder)
            recursive (bool): if true, all supplied paths will be searched recursively
            include_only_on_disk_assets (bool): If true, use only DiskGatheredData, do not calculate from UObjects.
        
        Returns:
            Array[AssetData] or None: 
        
            out_asset_data (Array[AssetData]): the list of assets in this path
        """
        ...
    def get_assets_by_package_name(self, package_name: Name, include_only_on_disk_assets: bool = False, skip_ar_filtered_assets: bool = True) -> Optional[Array[AssetData]]:
        r"""
        x.get_assets_by_package_name(package_name, include_only_on_disk_assets=False, skip_ar_filtered_assets=True) -> Array[AssetData] or None
        Gets asset data for the assets in the package with the specified package name
        see: IAssetRegistry class header for bIncludeOnlyOnDiskAssets.
        
        Args:
            package_name (Name): the package name for the requested assets (eg, /Game/MyFolder/MyAsset)
            include_only_on_disk_assets (bool): If true, use only DiskGatheredData, do not calculate from UObjects.
            skip_ar_filtered_assets (bool): If true, skips Objects that return true for IsAsset but are not assets in the current platform.
        
        Returns:
            Array[AssetData] or None: 
        
            out_asset_data (Array[AssetData]): the list of assets in this path
        """
        ...
    def get_assets_by_class(self, class_path_name: TopLevelAssetPath, search_sub_classes: bool = False) -> Optional[Array[AssetData]]:
        r"""
        x.get_assets_by_class(class_path_name, search_sub_classes=False) -> Array[AssetData] or None
        Gets asset data for all assets with the supplied class
        
        Args:
            class_path_name (TopLevelAssetPath): the full path of the class name of the assets requested, in a TopLevelAssetPath structure.
            search_sub_classes (bool): if true, all subclasses of the passed in class will be searched as well
        
        Returns:
            Array[AssetData] or None: 
        
            out_asset_data (Array[AssetData]): the list of assets in this path
        """
        ...
    def get_assets(self, filter: ARFilter, skip_ar_filtered_assets: bool = True) -> Optional[Array[AssetData]]:
        r"""
        x.get_assets(filter, skip_ar_filtered_assets=True) -> Array[AssetData] or None
        Gets asset data for all assets that match the filter.
        Assets returned must satisfy every filter component if there is at least one element in the component's array.
        Assets will satisfy a component if they match any of the elements in it.
        
        Args:
            filter (ARFilter): filter to apply to the assets in the AssetRegistry
            skip_ar_filtered_assets (bool): If true, skips Objects that return true for IsAsset but are not assets in the current platform.
        
        Returns:
            Array[AssetData] or None: 
        
            out_asset_data (Array[AssetData]): the list of assets in this path
        """
        ...
    def get_asset_by_object_path(self, object_path: Name, include_only_on_disk_assets: bool = False) -> AssetData:
        r"""
        x.get_asset_by_object_path(object_path, include_only_on_disk_assets=False) -> AssetData
        Get Asset by Object Path
        
        Args:
            object_path (Name): 
            include_only_on_disk_assets (bool): 
        
        Returns:
            AssetData:
        """
        ...
    def get_ancestor_class_names(self, class_path_name: TopLevelAssetPath) -> Optional[Array[TopLevelAssetPath]]:
        r"""
        x.get_ancestor_class_names(class_path_name) -> Array[TopLevelAssetPath] or None
        Returns true if the specified ClassName's ancestors could be found. If so, OutAncestorClassNames is a list of all its ancestors. This can be slow if temporary caching mode is not on
        
        Args:
            class_path_name (TopLevelAssetPath): 
        
        Returns:
            Array[TopLevelAssetPath] or None: 
        
            out_ancestor_class_names (Array[TopLevelAssetPath]):
        """
        ...
    def get_all_cached_paths(self) -> Array[str]:
        r"""
        x.get_all_cached_paths() -> Array[str]
        Gets a list of all paths that are currently cached
        
        Returns:
            Array[str]: 
        
            out_path_list (Array[str]):
        """
        ...
    def get_all_assets(self, include_only_on_disk_assets: bool = False) -> Optional[Array[AssetData]]:
        r"""
        x.get_all_assets(include_only_on_disk_assets=False) -> Array[AssetData] or None
        Gets asset data for all assets in the registry.
        This method may be slow, use a filter if possible to avoid iterating over the entire registry.
        
        Args:
            include_only_on_disk_assets (bool): 
        
        Returns:
            Array[AssetData] or None: 
        
            out_asset_data (Array[AssetData]): the list of assets in this path
        """
        ...

class GameMapsSettings(Object):
    r"""
    Game Maps Settings
    
    **C++ Source:**
    
    - **Module**: EngineSettings
    - **File**: GameMapsSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``editor_startup_map`` (SoftObjectPath):  [Read-Write] If set, this map will be loaded when the Editor starts up.
    - ``editor_template_map_overrides`` (Array[TemplateMapInfoOverride]):  [Read-Write] Map templates that should show up in the new level dialog. This will completely override the default maps chosen by the default editor
    - ``four_player_splitscreen_layout`` (FourPlayerSplitScreenType):  [Read-Write] The viewport layout to use if the screen should be split and there are three local players
    - ``game_default_map`` (SoftObjectPath):  [Read-Write] The map that will be loaded by default when no other map is loaded.
    - ``game_instance_class`` (SoftClassPath):  [Read-Write] The class to use when instantiating the transient GameInstance class
    - ``game_mode_class_aliases`` (Array[GameModeName]):  [Read-Write] List of GameModes to load when game= is specified in the URL (e.g. "DM" could be an alias for "MyProject.MyGameModeMP_DM")
    - ``game_mode_map_prefixes`` (Array[GameModeName]):  [Read-Write] Overrides the GameMode to use when loading a map that starts with a specific prefix
    - ``global_default_game_mode`` (SoftClassPath):  [Read-Write] GameMode to use if not specified in any other way. (e.g. per-map DefaultGameMode or on the URL).
    - ``global_default_server_game_mode`` (SoftClassPath):  [Read-Write] GameMode to use if not specified in any other way. (e.g. per-map DefaultGameMode or on the URL) (DEDICATED SERVERS)
      If not set, the GlobalDefaultGameMode value will be used.
    - ``local_map_options`` (str):  [Read-Write] The default options that will be appended to a map being loaded.
    - ``offset_player_gamepad_ids`` (bool):  [Read-Write] If enabled, this will make so that gamepads start being assigned to the second controller ID in local multiplayer games.
      In PIE sessions with multiple windows, this has the same effect as enabling "Route 1st Gamepad to 2nd Client"
    - ``server_default_map`` (SoftObjectPath):  [Read-Write] The map that will be loaded by default when no other map is loaded (DEDICATED SERVER).
    - ``three_player_splitscreen_layout`` (ThreePlayerSplitScreenType):  [Read-Write] The viewport layout to use if the screen should be split and there are three local players
    - ``transition_map`` (SoftObjectPath):  [Read-Write] The map loaded when transition from one map to another.
    - ``two_player_splitscreen_layout`` (TwoPlayerSplitScreenType):  [Read-Write] The viewport layout to use if the screen should be split and there are two local players
    - ``use_splitscreen`` (bool):  [Read-Write] Whether the screen should be split or not when multiple local players are present
    """
    def set_skip_assigning_gamepad_to_player1(self, skip_first_player: bool = True) -> None:
        r"""
        x.set_skip_assigning_gamepad_to_player1(skip_first_player=True) -> None
        Modify "Skip Assigning Gamepad to Player 1" GameMapsSettings option
        note: This value is saved to local config when changed.
        
        Args:
            skip_first_player (bool): If set connected game pads will only be assigned to the second and subsequent players
        """
        ...
    def get_skip_assigning_gamepad_to_player1(self) -> bool:
        r"""
        x.get_skip_assigning_gamepad_to_player1() -> bool
        Get Skip Assigning Gamepad to Player 1
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_game_maps_settings(cls) -> GameMapsSettings:
        r"""
        X.get_game_maps_settings() -> GameMapsSettings
        Returns the game local maps settings
        
        Returns:
            GameMapsSettings:
        """
        ...

class MeshDescriptionBase(Object):
    r"""
    Mesh Description Base
    
    **C++ Source:**
    
    - **Module**: MeshDescription
    - **File**: MeshDescriptionBase.h
    
    """
    def set_vertex_position(self, vertex_id: VertexID, position: Vector) -> None:
        r"""
        x.set_vertex_position(vertex_id, position) -> None
        Sets a vertex position
        
        Args:
            vertex_id (VertexID): 
            position (Vector):
        """
        ...
    def set_polygon_vertex_instances(self, polygon_id: PolygonID, vertex_instance_i_ds: Array[VertexInstanceID]) -> None:
        r"""
        x.set_polygon_vertex_instances(polygon_id, vertex_instance_i_ds) -> None
        Set the vertex instance at the given index around the polygon to the new value
        
        Args:
            polygon_id (PolygonID): 
            vertex_instance_i_ds (Array[VertexInstanceID]):
        """
        ...
    def set_polygon_polygon_group(self, polygon_id: PolygonID, polygon_group_id: PolygonGroupID) -> None:
        r"""
        x.set_polygon_polygon_group(polygon_id, polygon_group_id) -> None
        Sets the polygon group associated with a polygon
        
        Args:
            polygon_id (PolygonID): 
            polygon_group_id (PolygonGroupID):
        """
        ...
    def reverse_polygon_facing(self, polygon_id: PolygonID) -> None:
        r"""
        x.reverse_polygon_facing(polygon_id) -> None
        Reverse the winding order of the vertices of this polygon
        
        Args:
            polygon_id (PolygonID):
        """
        ...
    def reserve_new_vertices(self, number_of_new_vertices: int) -> None:
        r"""
        x.reserve_new_vertices(number_of_new_vertices) -> None
        Reserves space for this number of new vertices
        
        Args:
            number_of_new_vertices (int32):
        """
        ...
    def reserve_new_vertex_instances(self, number_of_new_vertex_instances: int) -> None:
        r"""
        x.reserve_new_vertex_instances(number_of_new_vertex_instances) -> None
        Reserves space for this number of new vertex instances
        
        Args:
            number_of_new_vertex_instances (int32):
        """
        ...
    def reserve_new_triangles(self, number_of_new_triangles: int) -> None:
        r"""
        x.reserve_new_triangles(number_of_new_triangles) -> None
        Reserves space for this number of new triangles
        
        Args:
            number_of_new_triangles (int32):
        """
        ...
    def reserve_new_polygons(self, number_of_new_polygons: int) -> None:
        r"""
        x.reserve_new_polygons(number_of_new_polygons) -> None
        Reserves space for this number of new polygons
        
        Args:
            number_of_new_polygons (int32):
        """
        ...
    def reserve_new_polygon_groups(self, number_of_new_polygon_groups: int) -> None:
        r"""
        x.reserve_new_polygon_groups(number_of_new_polygon_groups) -> None
        Reserves space for this number of new polygon groups
        
        Args:
            number_of_new_polygon_groups (int32):
        """
        ...
    def reserve_new_edges(self, number_of_new_edges: int) -> None:
        r"""
        x.reserve_new_edges(number_of_new_edges) -> None
        Reserves space for this number of new edges
        
        Args:
            number_of_new_edges (int32):
        """
        ...
    def is_vertex_valid(self, vertex_id: VertexID) -> bool:
        r"""
        x.is_vertex_valid(vertex_id) -> bool
        Returns whether the passed vertex ID is valid
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            bool:
        """
        ...
    def is_vertex_orphaned(self, vertex_id: VertexID) -> bool:
        r"""
        x.is_vertex_orphaned(vertex_id) -> bool
        Returns whether a given vertex is orphaned, i.e. it doesn't form part of any polygon
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            bool:
        """
        ...
    def is_vertex_instance_valid(self, vertex_instance_id: VertexInstanceID) -> bool:
        r"""
        x.is_vertex_instance_valid(vertex_instance_id) -> bool
        Returns whether the passed vertex instance ID is valid
        
        Args:
            vertex_instance_id (VertexInstanceID): 
        
        Returns:
            bool:
        """
        ...
    def is_triangle_valid(self, triangle_id: TriangleID) -> bool:
        r"""
        x.is_triangle_valid(triangle_id) -> bool
        Returns whether the passed triangle ID is valid
        
        Args:
            triangle_id (TriangleID): 
        
        Returns:
            bool:
        """
        ...
    def is_triangle_part_of_ngon(self, triangle_id: TriangleID) -> bool:
        r"""
        x.is_triangle_part_of_ngon(triangle_id) -> bool
        Determines if this triangle is part of an n-gon
        
        Args:
            triangle_id (TriangleID): 
        
        Returns:
            bool:
        """
        ...
    def is_polygon_valid(self, polygon_id: PolygonID) -> bool:
        r"""
        x.is_polygon_valid(polygon_id) -> bool
        Returns whether the passed polygon ID is valid
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            bool:
        """
        ...
    def is_polygon_group_valid(self, polygon_group_id: PolygonGroupID) -> bool:
        r"""
        x.is_polygon_group_valid(polygon_group_id) -> bool
        Returns whether the passed polygon group ID is valid
        
        Args:
            polygon_group_id (PolygonGroupID): 
        
        Returns:
            bool:
        """
        ...
    def is_empty(self) -> bool:
        r"""
        x.is_empty() -> bool
        Return whether the mesh description is empty
        
        Returns:
            bool:
        """
        ...
    def is_edge_valid(self, edge_id: EdgeID) -> bool:
        r"""
        x.is_edge_valid(edge_id) -> bool
        Returns whether the passed edge ID is valid
        
        Args:
            edge_id (EdgeID): 
        
        Returns:
            bool:
        """
        ...
    def is_edge_internal_to_polygon(self, edge_id: EdgeID, polygon_id: PolygonID) -> bool:
        r"""
        x.is_edge_internal_to_polygon(edge_id, polygon_id) -> bool
        Determine whether a given edge is an internal edge between triangles of a specific polygon
        
        Args:
            edge_id (EdgeID): 
            polygon_id (PolygonID): 
        
        Returns:
            bool:
        """
        ...
    def is_edge_internal(self, edge_id: EdgeID) -> bool:
        r"""
        x.is_edge_internal(edge_id) -> bool
        Determine whether a given edge is an internal edge between triangles of a polygon
        
        Args:
            edge_id (EdgeID): 
        
        Returns:
            bool:
        """
        ...
    def get_vertex_vertex_instances(self, vertex_id: VertexID) -> Array[VertexInstanceID]:
        r"""
        x.get_vertex_vertex_instances(vertex_id) -> Array[VertexInstanceID]
        Returns reference to an array of VertexInstance IDs instanced from this vertex
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            Array[VertexInstanceID]: 
        
            out_vertex_instance_i_ds (Array[VertexInstanceID]):
        """
        ...
    def get_vertex_position(self, vertex_id: VertexID) -> Vector:
        r"""
        x.get_vertex_position(vertex_id) -> Vector
        Gets a vertex position
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            Vector:
        """
        ...
    def get_vertex_pair_edge(self, vertex_id0: VertexID, vertex_id1: VertexID) -> EdgeID:
        r"""
        x.get_vertex_pair_edge(vertex_id0, vertex_id1) -> EdgeID
        Returns the edge ID defined by the two given vertex IDs, if there is one; otherwise INDEX_NONE
        
        Args:
            vertex_id0 (VertexID): 
            vertex_id1 (VertexID): 
        
        Returns:
            EdgeID:
        """
        ...
    def get_vertex_instance_vertex(self, vertex_instance_id: VertexInstanceID) -> VertexID:
        r"""
        x.get_vertex_instance_vertex(vertex_instance_id) -> VertexID
        Returns the vertex ID associated with the given vertex instance
        
        Args:
            vertex_instance_id (VertexInstanceID): 
        
        Returns:
            VertexID:
        """
        ...
    def get_vertex_instance_pair_edge(self, vertex_instance_id0: VertexInstanceID, vertex_instance_id1: VertexInstanceID) -> EdgeID:
        r"""
        x.get_vertex_instance_pair_edge(vertex_instance_id0, vertex_instance_id1) -> EdgeID
        Returns the edge ID defined by the two given vertex instance IDs, if there is one; otherwise INDEX_NONE
        
        Args:
            vertex_instance_id0 (VertexInstanceID): 
            vertex_instance_id1 (VertexInstanceID): 
        
        Returns:
            EdgeID:
        """
        ...
    def get_vertex_instance_for_triangle_vertex(self, triangle_id: TriangleID, vertex_id: VertexID) -> VertexInstanceID:
        r"""
        x.get_vertex_instance_for_triangle_vertex(triangle_id, vertex_id) -> VertexInstanceID
        Return the vertex instance which corresponds to the given vertex on the given triangle, or INDEX_NONE
        
        Args:
            triangle_id (TriangleID): 
            vertex_id (VertexID): 
        
        Returns:
            VertexInstanceID:
        """
        ...
    def get_vertex_instance_for_polygon_vertex(self, polygon_id: PolygonID, vertex_id: VertexID) -> VertexInstanceID:
        r"""
        x.get_vertex_instance_for_polygon_vertex(polygon_id, vertex_id) -> VertexInstanceID
        Return the vertex instance which corresponds to the given vertex on the given polygon, or INDEX_NONE
        
        Args:
            polygon_id (PolygonID): 
            vertex_id (VertexID): 
        
        Returns:
            VertexInstanceID:
        """
        ...
    def get_vertex_instance_count(self) -> int:
        r"""
        x.get_vertex_instance_count() -> int32
        Returns the number of vertex instances
        
        Returns:
            int32:
        """
        ...
    def get_vertex_instance_connected_triangles(self, vertex_instance_id: VertexInstanceID) -> Array[TriangleID]:
        r"""
        x.get_vertex_instance_connected_triangles(vertex_instance_id) -> Array[TriangleID]
        Returns reference to an array of Triangle IDs connected to this vertex instance
        
        Args:
            vertex_instance_id (VertexInstanceID): 
        
        Returns:
            Array[TriangleID]: 
        
            out_connected_triangle_i_ds (Array[TriangleID]):
        """
        ...
    def get_vertex_instance_connected_polygons(self, vertex_instance_id: VertexInstanceID) -> Array[PolygonID]:
        r"""
        x.get_vertex_instance_connected_polygons(vertex_instance_id) -> Array[PolygonID]
        Returns the polygons connected to this vertex instance
        
        Args:
            vertex_instance_id (VertexInstanceID): 
        
        Returns:
            Array[PolygonID]: 
        
            out_connected_polygon_i_ds (Array[PolygonID]):
        """
        ...
    def get_vertex_count(self) -> int:
        r"""
        x.get_vertex_count() -> int32
        Returns the number of vertices
        
        Returns:
            int32:
        """
        ...
    def get_vertex_connected_triangles(self, vertex_id: VertexID) -> Array[TriangleID]:
        r"""
        x.get_vertex_connected_triangles(vertex_id) -> Array[TriangleID]
        Returns the triangles connected to this vertex
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            Array[TriangleID]: 
        
            out_connected_triangle_i_ds (Array[TriangleID]):
        """
        ...
    def get_vertex_connected_polygons(self, vertex_id: VertexID) -> Array[PolygonID]:
        r"""
        x.get_vertex_connected_polygons(vertex_id) -> Array[PolygonID]
        Returns the polygons connected to this vertex
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            Array[PolygonID]: 
        
            out_connected_polygon_i_ds (Array[PolygonID]):
        """
        ...
    def get_vertex_connected_edges(self, vertex_id: VertexID) -> Array[EdgeID]:
        r"""
        x.get_vertex_connected_edges(vertex_id) -> Array[EdgeID]
        Returns reference to an array of Edge IDs connected to this vertex
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            Array[EdgeID]: 
        
            out_edge_i_ds (Array[EdgeID]):
        """
        ...
    def get_vertex_adjacent_vertices(self, vertex_id: VertexID) -> Array[VertexID]:
        r"""
        x.get_vertex_adjacent_vertices(vertex_id) -> Array[VertexID]
        Returns the vertices adjacent to this vertex
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            Array[VertexID]: 
        
            out_adjacent_vertex_i_ds (Array[VertexID]):
        """
        ...
    def get_triangle_vertices(self, triangle_id: TriangleID) -> Array[VertexID]:
        r"""
        x.get_triangle_vertices(triangle_id) -> Array[VertexID]
        Returns the vertices which define this triangle
        
        Args:
            triangle_id (TriangleID): 
        
        Returns:
            Array[VertexID]: 
        
            out_vertex_i_ds (Array[VertexID]):
        """
        ...
    def get_triangle_vertex_instances(self, triangle_id: TriangleID) -> Array[VertexInstanceID]:
        r"""
        x.get_triangle_vertex_instances(triangle_id) -> Array[VertexInstanceID]
        Get the vertex instances which define this triangle
        
        Args:
            triangle_id (TriangleID): 
        
        Returns:
            Array[VertexInstanceID]: 
        
            out_vertex_instance_i_ds (Array[VertexInstanceID]):
        """
        ...
    def get_triangle_vertex_instance(self, triangle_id: TriangleID, index: int) -> VertexInstanceID:
        r"""
        x.get_triangle_vertex_instance(triangle_id, index) -> VertexInstanceID
        Get the specified vertex instance by index
        
        Args:
            triangle_id (TriangleID): 
            index (int32): 
        
        Returns:
            VertexInstanceID:
        """
        ...
    def get_triangle_polygon_group(self, triangle_id: TriangleID) -> PolygonGroupID:
        r"""
        x.get_triangle_polygon_group(triangle_id) -> PolygonGroupID
        Get the polygon group which contains this triangle
        
        Args:
            triangle_id (TriangleID): 
        
        Returns:
            PolygonGroupID:
        """
        ...
    def get_triangle_polygon(self, triangle_id: TriangleID) -> PolygonID:
        r"""
        x.get_triangle_polygon(triangle_id) -> PolygonID
        Get the polygon which contains this triangle
        
        Args:
            triangle_id (TriangleID): 
        
        Returns:
            PolygonID:
        """
        ...
    def get_triangle_edges(self, triangle_id: TriangleID) -> Array[EdgeID]:
        r"""
        x.get_triangle_edges(triangle_id) -> Array[EdgeID]
        Returns the edges which define this triangle
        
        Args:
            triangle_id (TriangleID): 
        
        Returns:
            Array[EdgeID]: 
        
            out_edge_i_ds (Array[EdgeID]):
        """
        ...
    def get_triangle_count(self) -> int:
        r"""
        x.get_triangle_count() -> int32
        Returns the number of triangles
        
        Returns:
            int32:
        """
        ...
    def get_triangle_adjacent_triangles(self, triangle_id: TriangleID) -> Array[TriangleID]:
        r"""
        x.get_triangle_adjacent_triangles(triangle_id) -> Array[TriangleID]
        Returns the adjacent triangles to this triangle
        
        Args:
            triangle_id (TriangleID): 
        
        Returns:
            Array[TriangleID]: 
        
            out_triangle_i_ds (Array[TriangleID]):
        """
        ...
    def get_polygon_vertices(self, polygon_id: PolygonID) -> Array[VertexID]:
        r"""
        x.get_polygon_vertices(polygon_id) -> Array[VertexID]
        Returns the vertices which form the polygon perimeter
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            Array[VertexID]: 
        
            out_vertex_i_ds (Array[VertexID]):
        """
        ...
    def get_polygon_vertex_instances(self, polygon_id: PolygonID) -> Array[VertexInstanceID]:
        r"""
        x.get_polygon_vertex_instances(polygon_id) -> Array[VertexInstanceID]
        Returns reference to an array of VertexInstance IDs forming the perimeter of this polygon
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            Array[VertexInstanceID]: 
        
            out_vertex_instance_i_ds (Array[VertexInstanceID]):
        """
        ...
    def get_polygon_triangles(self, polygon_id: PolygonID) -> Array[TriangleID]:
        r"""
        x.get_polygon_triangles(polygon_id) -> Array[TriangleID]
        Return reference to an array of triangle IDs which comprise this polygon
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            Array[TriangleID]: 
        
            out_triangle_i_ds (Array[TriangleID]):
        """
        ...
    def get_polygon_polygon_group(self, polygon_id: PolygonID) -> PolygonGroupID:
        r"""
        x.get_polygon_polygon_group(polygon_id) -> PolygonGroupID
        Return the polygon group associated with a polygon
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            PolygonGroupID:
        """
        ...
    def get_polygon_perimeter_edges(self, polygon_id: PolygonID) -> Array[EdgeID]:
        r"""
        x.get_polygon_perimeter_edges(polygon_id) -> Array[EdgeID]
        Returns the edges which form the polygon perimeter
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            Array[EdgeID]: 
        
            out_edge_i_ds (Array[EdgeID]):
        """
        ...
    def get_polygon_internal_edges(self, polygon_id: PolygonID) -> Array[EdgeID]:
        r"""
        x.get_polygon_internal_edges(polygon_id) -> Array[EdgeID]
        Populate the provided array with a list of edges which are internal to the polygon, i.e. those which separate
                  constituent triangles.
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            Array[EdgeID]: 
        
            out_edge_i_ds (Array[EdgeID]):
        """
        ...
    def get_polygon_group_polygons(self, polygon_group_id: PolygonGroupID) -> Array[PolygonID]:
        r"""
        x.get_polygon_group_polygons(polygon_group_id) -> Array[PolygonID]
        Returns the polygons associated with the given polygon group
        
        Args:
            polygon_group_id (PolygonGroupID): 
        
        Returns:
            Array[PolygonID]: 
        
            out_polygon_i_ds (Array[PolygonID]):
        """
        ...
    def get_polygon_group_count(self) -> int:
        r"""
        x.get_polygon_group_count() -> int32
        Returns the number of polygon groups
        
        Returns:
            int32:
        """
        ...
    def get_polygon_count(self) -> int:
        r"""
        x.get_polygon_count() -> int32
        Returns the number of polygons
        
        Returns:
            int32:
        """
        ...
    def get_polygon_adjacent_polygons(self, polygon_id: PolygonID) -> Array[PolygonID]:
        r"""
        x.get_polygon_adjacent_polygons(polygon_id) -> Array[PolygonID]
        Populates the passed array with adjacent polygons
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            Array[PolygonID]: 
        
            out_polygon_i_ds (Array[PolygonID]):
        """
        ...
    def get_num_vertex_vertex_instances(self, vertex_id: VertexID) -> int:
        r"""
        x.get_num_vertex_vertex_instances(vertex_id) -> int32
        Returns number of vertex instances created from this vertex
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            int32:
        """
        ...
    def get_num_vertex_instance_connected_triangles(self, vertex_instance_id: VertexInstanceID) -> int:
        r"""
        x.get_num_vertex_instance_connected_triangles(vertex_instance_id) -> int32
        Returns the number of triangles connected to this vertex instance
        
        Args:
            vertex_instance_id (VertexInstanceID): 
        
        Returns:
            int32:
        """
        ...
    def get_num_vertex_instance_connected_polygons(self, vertex_instance_id: VertexInstanceID) -> int:
        r"""
        x.get_num_vertex_instance_connected_polygons(vertex_instance_id) -> int32
        Returns the number of polygons connected to this vertex instance.
        
        Args:
            vertex_instance_id (VertexInstanceID): 
        
        Returns:
            int32:
        """
        ...
    def get_num_vertex_connected_triangles(self, vertex_id: VertexID) -> int:
        r"""
        x.get_num_vertex_connected_triangles(vertex_id) -> int32
        Returns number of triangles connected to this vertex
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            int32:
        """
        ...
    def get_num_vertex_connected_polygons(self, vertex_id: VertexID) -> int:
        r"""
        x.get_num_vertex_connected_polygons(vertex_id) -> int32
        Returns the number of polygons connected to this vertex
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            int32:
        """
        ...
    def get_num_vertex_connected_edges(self, vertex_id: VertexID) -> int:
        r"""
        x.get_num_vertex_connected_edges(vertex_id) -> int32
        Returns number of edges connected to this vertex
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            int32:
        """
        ...
    def get_num_polygon_vertices(self, polygon_id: PolygonID) -> int:
        r"""
        x.get_num_polygon_vertices(polygon_id) -> int32
        Returns the number of vertices this polygon has
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            int32:
        """
        ...
    def get_num_polygon_triangles(self, polygon_id: PolygonID) -> int:
        r"""
        x.get_num_polygon_triangles(polygon_id) -> int32
        Return the number of triangles which comprise this polygon
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            int32:
        """
        ...
    def get_num_polygon_internal_edges(self, polygon_id: PolygonID) -> int:
        r"""
        x.get_num_polygon_internal_edges(polygon_id) -> int32
        Return the number of internal edges in this polygon
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            int32:
        """
        ...
    def get_num_polygon_group_polygons(self, polygon_group_id: PolygonGroupID) -> int:
        r"""
        x.get_num_polygon_group_polygons(polygon_group_id) -> int32
        Returns the number of polygons in this polygon group
        
        Args:
            polygon_group_id (PolygonGroupID): 
        
        Returns:
            int32:
        """
        ...
    def get_num_edge_connected_triangles(self, edge_id: EdgeID) -> int:
        r"""
        x.get_num_edge_connected_triangles(edge_id) -> int32
        Returns the number of triangles connected to this edge
        
        Args:
            edge_id (EdgeID): 
        
        Returns:
            int32:
        """
        ...
    def get_num_edge_connected_polygons(self, edge_id: EdgeID) -> int:
        r"""
        x.get_num_edge_connected_polygons(edge_id) -> int32
        Returns the number of polygons connected to this edge
        
        Args:
            edge_id (EdgeID): 
        
        Returns:
            int32:
        """
        ...
    def get_edge_vertices(self, edge_id: EdgeID) -> Array[VertexID]:
        r"""
        x.get_edge_vertices(edge_id) -> Array[VertexID]
        Returns a pair of vertex IDs defining the edge
        
        Args:
            edge_id (EdgeID): 
        
        Returns:
            Array[VertexID]: 
        
            out_vertex_i_ds (Array[VertexID]):
        """
        ...
    def get_edge_vertex(self, edge_id: EdgeID, vertex_number: int) -> VertexID:
        r"""
        x.get_edge_vertex(edge_id, vertex_number) -> VertexID
        Returns the vertex ID corresponding to one of the edge endpoints
        
        Args:
            edge_id (EdgeID): 
            vertex_number (int32): 
        
        Returns:
            VertexID:
        """
        ...
    def get_edge_count(self) -> int:
        r"""
        x.get_edge_count() -> int32
        Returns the number of edges
        
        Returns:
            int32:
        """
        ...
    def get_edge_connected_triangles(self, edge_id: EdgeID) -> Array[TriangleID]:
        r"""
        x.get_edge_connected_triangles(edge_id) -> Array[TriangleID]
        Returns reference to an array of triangle IDs connected to this edge
        
        Args:
            edge_id (EdgeID): 
        
        Returns:
            Array[TriangleID]: 
        
            out_connected_triangle_i_ds (Array[TriangleID]):
        """
        ...
    def get_edge_connected_polygons(self, edge_id: EdgeID) -> Array[PolygonID]:
        r"""
        x.get_edge_connected_polygons(edge_id) -> Array[PolygonID]
        Returns the polygons connected to this edge
        
        Args:
            edge_id (EdgeID): 
        
        Returns:
            Array[PolygonID]: 
        
            out_connected_polygon_i_ds (Array[PolygonID]):
        """
        ...
    def empty(self) -> None:
        r"""
        x.empty() -> None
        Empty the mesh description
        """
        ...
    def delete_vertex_instance(self, vertex_instance_id: VertexInstanceID) -> Array[VertexID]:
        r"""
        x.delete_vertex_instance(vertex_instance_id) -> Array[VertexID]
        Deletes a vertex instance from a mesh
        
        Args:
            vertex_instance_id (VertexInstanceID): 
        
        Returns:
            Array[VertexID]: 
        
            orphaned_vertices (Array[VertexID]):
        """
        ...
    def delete_vertex(self, vertex_id: VertexID) -> None:
        r"""
        x.delete_vertex(vertex_id) -> None
        Deletes a vertex from the mesh
        
        Args:
            vertex_id (VertexID):
        """
        ...
    def delete_triangle(self, triangle_id: TriangleID) -> Tuple[Array[EdgeID], Array[VertexInstanceID], Array[PolygonGroupID]]:
        r"""
        x.delete_triangle(triangle_id) -> (orphaned_edges=Array[EdgeID], orphaned_vertex_instances=Array[VertexInstanceID], orphaned_polygon_groups_ptr=Array[PolygonGroupID])
        Deletes a triangle from the mesh
        
        Args:
            triangle_id (TriangleID): 
        
        Returns:
            tuple: 
        
            orphaned_edges (Array[EdgeID]): 
        
            orphaned_vertex_instances (Array[VertexInstanceID]): 
        
            orphaned_polygon_groups_ptr (Array[PolygonGroupID]):
        """
        ...
    def delete_polygon_group(self, polygon_group_id: PolygonGroupID) -> None:
        r"""
        x.delete_polygon_group(polygon_group_id) -> None
        Deletes a polygon group from the mesh
        
        Args:
            polygon_group_id (PolygonGroupID):
        """
        ...
    def delete_polygon(self, polygon_id: PolygonID) -> Tuple[Array[EdgeID], Array[VertexInstanceID], Array[PolygonGroupID]]:
        r"""
        x.delete_polygon(polygon_id) -> (orphaned_edges=Array[EdgeID], orphaned_vertex_instances=Array[VertexInstanceID], orphaned_polygon_groups=Array[PolygonGroupID])
        Deletes a polygon from the mesh
        
        Args:
            polygon_id (PolygonID): 
        
        Returns:
            tuple: 
        
            orphaned_edges (Array[EdgeID]): 
        
            orphaned_vertex_instances (Array[VertexInstanceID]): 
        
            orphaned_polygon_groups (Array[PolygonGroupID]):
        """
        ...
    def delete_edge(self, edge_id: EdgeID) -> Array[VertexID]:
        r"""
        x.delete_edge(edge_id) -> Array[VertexID]
        Deletes an edge from a mesh
        
        Args:
            edge_id (EdgeID): 
        
        Returns:
            Array[VertexID]: 
        
            orphaned_vertices (Array[VertexID]):
        """
        ...
    def create_vertex_with_id(self, vertex_id: VertexID) -> None:
        r"""
        x.create_vertex_with_id(vertex_id) -> None
        Adds a new vertex to the mesh with the given ID
        
        Args:
            vertex_id (VertexID):
        """
        ...
    def create_vertex_instance_with_id(self, vertex_instance_id: VertexInstanceID, vertex_id: VertexID) -> None:
        r"""
        x.create_vertex_instance_with_id(vertex_instance_id, vertex_id) -> None
        Adds a new vertex instance to the mesh with the given ID
        
        Args:
            vertex_instance_id (VertexInstanceID): 
            vertex_id (VertexID):
        """
        ...
    def create_vertex_instance(self, vertex_id: VertexID) -> VertexInstanceID:
        r"""
        x.create_vertex_instance(vertex_id) -> VertexInstanceID
        Adds a new vertex instance to the mesh and returns its ID
        
        Args:
            vertex_id (VertexID): 
        
        Returns:
            VertexInstanceID:
        """
        ...
    def create_vertex(self) -> VertexID:
        r"""
        x.create_vertex() -> VertexID
        Adds a new vertex to the mesh and returns its ID
        
        Returns:
            VertexID:
        """
        ...
    def create_triangle_with_id(self, triangle_id: TriangleID, polygon_group_id: PolygonGroupID, vertex_instance_i_ds: Array[VertexInstanceID]) -> Array[EdgeID]:
        r"""
        x.create_triangle_with_id(triangle_id, polygon_group_id, vertex_instance_i_ds) -> Array[EdgeID]
        Adds a new triangle to the mesh with the given ID. This will also make an encapsulating polygon, and any missing edges.
        
        Args:
            triangle_id (TriangleID): 
            polygon_group_id (PolygonGroupID): 
            vertex_instance_i_ds (Array[VertexInstanceID]): 
        
        Returns:
            Array[EdgeID]: 
        
            new_edge_i_ds (Array[EdgeID]):
        """
        ...
    def create_triangle(self, polygon_group_id: PolygonGroupID, vertex_instance_i_ds: Array[VertexInstanceID]) -> Tuple[TriangleID, Array[EdgeID]]:
        r"""
        x.create_triangle(polygon_group_id, vertex_instance_i_ds) -> (TriangleID, new_edge_i_ds=Array[EdgeID])
        Adds a new triangle to the mesh and returns its ID. This will also make an encapsulating polygon, and any missing edges.
        
        Args:
            polygon_group_id (PolygonGroupID): 
            vertex_instance_i_ds (Array[VertexInstanceID]): 
        
        Returns:
            Array[EdgeID]: 
        
            new_edge_i_ds (Array[EdgeID]):
        """
        ...
    def create_polygon_with_id(self, polygon_id: PolygonID, polygon_group_id: PolygonGroupID) -> Tuple[Array[VertexInstanceID], Array[EdgeID]]:
        r"""
        x.create_polygon_with_id(polygon_id, polygon_group_id) -> (vertex_instance_i_ds=Array[VertexInstanceID], new_edge_i_ds=Array[EdgeID])
        Adds a new polygon to the mesh with the given ID. This will also make any missing edges, and all constituent triangles.
        
        Args:
            polygon_id (PolygonID): 
            polygon_group_id (PolygonGroupID): 
        
        Returns:
            tuple: 
        
            vertex_instance_i_ds (Array[VertexInstanceID]): 
        
            new_edge_i_ds (Array[EdgeID]):
        """
        ...
    def create_polygon_group_with_id(self, polygon_group_id: PolygonGroupID) -> None:
        r"""
        x.create_polygon_group_with_id(polygon_group_id) -> None
        Adds a new polygon group to the mesh with the given ID
        
        Args:
            polygon_group_id (PolygonGroupID):
        """
        ...
    def create_polygon_group(self) -> PolygonGroupID:
        r"""
        x.create_polygon_group() -> PolygonGroupID
        Adds a new polygon group to the mesh and returns its ID
        
        Returns:
            PolygonGroupID:
        """
        ...
    def create_polygon(self, polygon_group_id: PolygonGroupID) -> Tuple[PolygonID, Array[VertexInstanceID], Array[EdgeID]]:
        r"""
        x.create_polygon(polygon_group_id) -> (PolygonID, vertex_instance_i_ds=Array[VertexInstanceID], new_edge_i_ds=Array[EdgeID])
        Adds a new polygon to the mesh and returns its ID. This will also make any missing edges, and all constituent triangles.
        
        Args:
            polygon_group_id (PolygonGroupID): 
        
        Returns:
            tuple: 
        
            vertex_instance_i_ds (Array[VertexInstanceID]): 
        
            new_edge_i_ds (Array[EdgeID]):
        """
        ...
    def create_edge_with_id(self, edge_id: EdgeID, vertex_id0: VertexID, vertex_id1: VertexID) -> None:
        r"""
        x.create_edge_with_id(edge_id, vertex_id0, vertex_id1) -> None
        Adds a new edge to the mesh with the given ID
        
        Args:
            edge_id (EdgeID): 
            vertex_id0 (VertexID): 
            vertex_id1 (VertexID):
        """
        ...
    def create_edge(self, vertex_id0: VertexID, vertex_id1: VertexID) -> EdgeID:
        r"""
        x.create_edge(vertex_id0, vertex_id1) -> EdgeID
        Adds a new edge to the mesh and returns its ID
        
        Args:
            vertex_id0 (VertexID): 
            vertex_id1 (VertexID): 
        
        Returns:
            EdgeID:
        """
        ...
    def compute_polygon_triangulation(self, polygon_id: PolygonID) -> None:
        r"""
        x.compute_polygon_triangulation(polygon_id) -> None
        Generates triangles and internal edges for the given polygon
        
        Args:
            polygon_id (PolygonID):
        """
        ...

class StaticMeshDescription(MeshDescriptionBase):
    r"""
    A wrapper for MeshDescription, customized for static meshes
    
    **C++ Source:**
    
    - **Module**: StaticMeshDescription
    - **File**: StaticMeshDescription.h
    
    """
    def set_vertex_instance_uv(self, vertex_instance_id: VertexInstanceID, uv: Vector2D, uv_index: int = 0) -> None:
        r"""
        x.set_vertex_instance_uv(vertex_instance_id, uv, uv_index=0) -> None
        Set Vertex Instance UV
        
        Args:
            vertex_instance_id (VertexInstanceID): 
            uv (Vector2D): 
            uv_index (int32):
        """
        ...
    def set_polygon_group_material_slot_name(self, polygon_group_id: PolygonGroupID, slot_name: Name) -> None:
        r"""
        x.set_polygon_group_material_slot_name(polygon_group_id, slot_name) -> None
        Set Polygon Group Material Slot Name
        
        Args:
            polygon_group_id (PolygonGroupID): 
            slot_name (Name):
        """
        ...
    def get_vertex_instance_uv(self, vertex_instance_id: VertexInstanceID, uv_index: int = 0) -> Vector2D:
        r"""
        x.get_vertex_instance_uv(vertex_instance_id, uv_index=0) -> Vector2D
        Get Vertex Instance UV
        
        Args:
            vertex_instance_id (VertexInstanceID): 
            uv_index (int32): 
        
        Returns:
            Vector2D:
        """
        ...
    def create_cube(self, center: Vector, half_extents: Vector, polygon_group: PolygonGroupID) -> Tuple[PolygonID, PolygonID, PolygonID, PolygonID, PolygonID, PolygonID]:
        r"""
        x.create_cube(center, half_extents, polygon_group) -> (polygon_id_plus_x=PolygonID, polygon_id_minus_x=PolygonID, polygon_id_plus_y=PolygonID, polygon_id_minus_y=PolygonID, polygon_id_plus_z=PolygonID, polygon_id_minus_z=PolygonID)
        Create Cube
        
        Args:
            center (Vector): 
            half_extents (Vector): 
            polygon_group (PolygonGroupID): 
        
        Returns:
            tuple: 
        
            polygon_id_plus_x (PolygonID): 
        
            polygon_id_minus_x (PolygonID): 
        
            polygon_id_plus_y (PolygonID): 
        
            polygon_id_minus_y (PolygonID): 
        
            polygon_id_plus_z (PolygonID): 
        
            polygon_id_minus_z (PolygonID):
        """
        ...

class SkeletalMeshDescription(MeshDescriptionBase):
    r"""
    Skeletal Mesh Description
    
    **C++ Source:**
    
    - **Module**: SkeletalMeshDescription
    - **File**: SkeletalMeshDescription.h
    
    """
    ...

class ChaosPhysicalMaterial(Object):
    r"""
    Physical materials are used to define the response of a physical object when
    interacting dynamically with the world.
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: ChaosPhysicalMaterial.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_ether_drag`` (float):  [Read-Write] Uniform angular ether drag, the resistance a body experiences to its rotation.
    - ``friction`` (float):  [Read-Write] Friction value of a surface in motion, controls how easily things can slide on this surface (0 is frictionless, higher values increase the amount of friction)
    - ``linear_ether_drag`` (float):  [Read-Write] Uniform linear ether drag, the resistance a body experiences to its translation.
    - ``restitution`` (float):  [Read-Write] Restitution or 'bounciness' of this surface, between 0 (no bounce) and 1 (outgoing velocity is same as incoming).
    - ``sleeping_angular_velocity_threshold`` (float):  [Read-Write] How much to scale the damage threshold by on any destructible we are applied to
    - ``sleeping_linear_velocity_threshold`` (float):  [Read-Write] How much to scale the damage threshold by on any destructible we are applied to
    - ``static_friction`` (float):  [Read-Write] Friction value of surface at rest, controls how easily things can slide on this surface (0 is frictionless, higher values increase the amount of friction)
    """
    @property
    def friction(self) -> float:
        r"""
        (float):  [Read-Only] Friction value of a surface in motion, controls how easily things can slide on this surface (0 is frictionless, higher values increase the amount of friction)
        """
        ...
    @property
    def static_friction(self) -> float:
        r"""
        (float):  [Read-Only] Friction value of surface at rest, controls how easily things can slide on this surface (0 is frictionless, higher values increase the amount of friction)
        """
        ...
    @property
    def restitution(self) -> float:
        r"""
        (float):  [Read-Only] Restitution or 'bounciness' of this surface, between 0 (no bounce) and 1 (outgoing velocity is same as incoming).
        """
        ...
    @property
    def linear_ether_drag(self) -> float:
        r"""
        (float):  [Read-Only] Uniform linear ether drag, the resistance a body experiences to its translation.
        """
        ...
    @property
    def angular_ether_drag(self) -> float:
        r"""
        (float):  [Read-Only] Uniform angular ether drag, the resistance a body experiences to its rotation.
        """
        ...
    @property
    def sleeping_linear_velocity_threshold(self) -> float:
        r"""
        (float):  [Read-Only] How much to scale the damage threshold by on any destructible we are applied to
        """
        ...
    @property
    def sleeping_angular_velocity_threshold(self) -> float:
        r"""
        (float):  [Read-Only] How much to scale the damage threshold by on any destructible we are applied to
        """
        ...

class PhysicalMaterial(Object):
    r"""
    Physical materials are used to define the response of a physical object when interacting dynamically with the world.
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: PhysicalMaterial.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_friction_impulse`` (float):  [Read-Write] A friction (positional) impulse of at least this magnitude may be applied,
                    regardless the normal force. This is analogous to adding only the lateral part of a
                    "stickiness" to a material
    - ``damage_modifier`` (PhysicalMaterialDamageModifier):  [Read-Write]
    - ``density`` (float):  [Read-Write] Used with the shape of the object to calculate its mass properties. The higher the number, the heavier the object. g per cubic cm.
    - ``friction`` (float):  [Read-Write] Friction value of surface, controls how easily things can slide on this surface (0 is frictionless, higher values increase the amount of friction)
    - ``friction_combine_mode`` (FrictionCombineMode):  [Read-Write] Friction combine mode, controls how friction is computed for multiple materials.
    - ``override_friction_combine_mode`` (bool):  [Read-Write] If set we will use the FrictionCombineMode of this material, instead of the FrictionCombineMode found in the project settings.
    - ``override_restitution_combine_mode`` (bool):  [Read-Write] If set we will use the RestitutionCombineMode of this material, instead of the RestitutionCombineMode found in the project settings.
    - ``raise_mass_to_power`` (float):  [Read-Write] Used to adjust the way that mass increases as objects get larger. This is applied to the mass as calculated based on a 'solid' object.
      In actuality, larger objects do not tend to be solid, and become more like 'shells' (e.g. a car is not a solid piece of metal).
      Values are clamped to 1 or less.
    - ``restitution`` (float):  [Read-Write] Restitution or 'bounciness' of this surface, between 0 (no bounce) and 1 (outgoing velocity is same as incoming).
    - ``restitution_combine_mode`` (FrictionCombineMode):  [Read-Write] Restitution combine mode, controls how restitution is computed for multiple materials.
    - ``show_experimental_properties`` (bool):  [Read-Only] Experimental material properties are enabled via the p.PhysicalMaterial.ShowExperimentalProperties console variable.
                    NOTE: These are _experimental_ properties which may change. Use at your own risk!
    - ``sleep_angular_velocity_threshold`` (float):  [Read-Write] How low the angular velocity can be before solver puts body to sleep.
    - ``sleep_counter_threshold`` (int32):  [Read-Write] How many ticks we can be under thresholds for before solver puts body to sleep.
    - ``sleep_linear_velocity_threshold`` (float):  [Read-Write] How low the linear velocity can be before solver puts body to sleep.
    - ``soft_collision_mode`` (PhysicalMaterialSoftCollisionMode):  [Read-Write] For enable soft collision shell thickness mode
    - ``soft_collision_thickness`` (float):  [Read-Write] Thickness of the layer just inside the collision shape in which contact is considered "soft".
                    The units depend on SoftCollisionMode
    - ``static_friction`` (float):  [Read-Write] Static Friction value of surface, controls how easily things can slide on this surface (0 is frictionless, higher values increase the amount of friction)
    - ``strength`` (PhysicalMaterialStrength):  [Read-Write]
    - ``surface_type`` (PhysicalSurface):  [Read-Write] To edit surface type for your project, use ProjectSettings/Physics/PhysicalSurface section
    """
    @property
    def friction(self) -> float:
        r"""
        (float):  [Read-Only] Friction value of surface, controls how easily things can slide on this surface (0 is frictionless, higher values increase the amount of friction)
        """
        ...
    @property
    def static_friction(self) -> float:
        r"""
        (float):  [Read-Only] Static Friction value of surface, controls how easily things can slide on this surface (0 is frictionless, higher values increase the amount of friction)
        """
        ...
    @property
    def friction_combine_mode(self) -> FrictionCombineMode:
        r"""
        (FrictionCombineMode):  [Read-Only] Friction combine mode, controls how friction is computed for multiple materials.
        """
        ...
    @property
    def override_friction_combine_mode(self) -> bool:
        r"""
        (bool):  [Read-Write] If set we will use the FrictionCombineMode of this material, instead of the FrictionCombineMode found in the project settings.
        """
        ...
    @override_friction_combine_mode.setter
    def override_friction_combine_mode(self, value: bool) -> None:
        ...
    @property
    def restitution(self) -> float:
        r"""
        (float):  [Read-Only] Restitution or 'bounciness' of this surface, between 0 (no bounce) and 1 (outgoing velocity is same as incoming).
        """
        ...
    @property
    def restitution_combine_mode(self) -> FrictionCombineMode:
        r"""
        (FrictionCombineMode):  [Read-Only] Restitution combine mode, controls how restitution is computed for multiple materials.
        """
        ...
    @property
    def override_restitution_combine_mode(self) -> bool:
        r"""
        (bool):  [Read-Write] If set we will use the RestitutionCombineMode of this material, instead of the RestitutionCombineMode found in the project settings.
        """
        ...
    @override_restitution_combine_mode.setter
    def override_restitution_combine_mode(self, value: bool) -> None:
        ...
    @property
    def density(self) -> float:
        r"""
        (float):  [Read-Only] Used with the shape of the object to calculate its mass properties. The higher the number, the heavier the object. g per cubic cm.
        """
        ...
    @property
    def sleep_linear_velocity_threshold(self) -> float:
        r"""
        (float):  [Read-Only] How low the linear velocity can be before solver puts body to sleep.
        """
        ...
    @property
    def sleep_angular_velocity_threshold(self) -> float:
        r"""
        (float):  [Read-Only] How low the angular velocity can be before solver puts body to sleep.
        """
        ...
    @property
    def sleep_counter_threshold(self) -> int:
        r"""
        (int32):  [Read-Only] How many ticks we can be under thresholds for before solver puts body to sleep.
        """
        ...
    @property
    def raise_mass_to_power(self) -> float:
        r"""
        (float):  [Read-Only] Used to adjust the way that mass increases as objects get larger. This is applied to the mass as calculated based on a 'solid' object.
        In actuality, larger objects do not tend to be solid, and become more like 'shells' (e.g. a car is not a solid piece of metal).
        Values are clamped to 1 or less.
        """
        ...
    @property
    def surface_type(self) -> PhysicalSurface:
        r"""
        (PhysicalSurface):  [Read-Only] To edit surface type for your project, use ProjectSettings/Physics/PhysicalSurface section
        """
        ...
    @property
    def strength(self) -> PhysicalMaterialStrength:
        r"""
        (PhysicalMaterialStrength):  [Read-Only]
        """
        ...
    @property
    def damage_modifier(self) -> PhysicalMaterialDamageModifier:
        r"""
        (PhysicalMaterialDamageModifier):  [Read-Only]
        """
        ...

class SpatializationPluginSourceSettingsBase(Object):
    r"""
    This is a class which should be overridden to provide users with settings to use for individual sounds
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: IAudioExtensionPlugin.h
    
    """
    ...

class SourceDataOverridePluginSourceSettingsBase(Object):
    r"""
    This is a class which should be overridden to provide users with settings to use for individual sounds
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: IAudioExtensionPlugin.h
    
    """
    ...

class OcclusionPluginSourceSettingsBase(Object):
    r"""
    This is a class which should be overridden to provide users with settings to use for individual sounds
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: IAudioExtensionPlugin.h
    
    """
    ...

class ReverbPluginSourceSettingsBase(Object):
    r"""
    This is a class which should be overridden to provide users with settings to use for individual sounds
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: IAudioExtensionPlugin.h
    
    """
    ...

class AudioParameterControllerInterface(Interface):
    r"""
    Audio Parameter Controller Interface
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: AudioParameterControllerInterface.h
    
    """
    def set_trigger_parameter(self, name: Name) -> None:
        r"""
        x.set_trigger_parameter(name) -> None
        Executes a named trigger.  Does *not* cache trigger value, so only executes if the sound
        is already playing.  If the intent is for the trigger to execute immediately (if playing)
        and be called on initialization for all future instances, call 'SetBoolParameter' with the
        intended initial trigger behavior (true if trigger desired on initialization, false if not).
        
        Args:
            name (Name):
        """
        ...
    def set_string_parameter(self, name: Name, value: str) -> None:
        r"""
        x.set_string_parameter(name, value) -> None
        Sets a named String
        
        Args:
            name (Name): 
            value (str):
        """
        ...
    def set_string_array_parameter(self, name: Name, value: Array[str]) -> None:
        r"""
        x.set_string_array_parameter(name, value) -> None
        Sets a named String Array
        
        Args:
            name (Name): 
            value (Array[str]):
        """
        ...
    def set_parameters_blueprint(self, parameters: Array[AudioParameter]) -> None:
        r"""
        x.set_parameters_blueprint(parameters) -> None
        Sets an array of parameters as a batch
        
        Args:
            parameters (Array[AudioParameter]):
        """
        ...
    def set_object_parameter(self, name: Name, value: Object) -> None:
        r"""
        x.set_object_parameter(name, value) -> None
        Sets a named UObject
        
        Args:
            name (Name): 
            value (Object):
        """
        ...
    def set_object_array_parameter(self, name: Name, value: Array[Object]) -> None:
        r"""
        x.set_object_array_parameter(name, value) -> None
        Sets a named UObject Array
        
        Args:
            name (Name): 
            value (Array[Object]):
        """
        ...
    def set_int_parameter(self, name: Name, int: int) -> None:
        r"""
        x.set_int_parameter(name, int) -> None
        Sets a named Int32
        
        Args:
            name (Name): 
            int (int32):
        """
        ...
    def set_int_array_parameter(self, name: Name, value: Array[int]) -> None:
        r"""
        x.set_int_array_parameter(name, value) -> None
        Sets a named Int32 Array
        
        Args:
            name (Name): 
            value (Array[int32]):
        """
        ...
    def set_float_parameter(self, name: Name, float: float) -> None:
        r"""
        x.set_float_parameter(name, float) -> None
        Sets a named Float
        
        Args:
            name (Name): 
            float (float):
        """
        ...
    def set_float_array_parameter(self, name: Name, value: Array[float]) -> None:
        r"""
        x.set_float_array_parameter(name, value) -> None
        Sets a named Float Array
        
        Args:
            name (Name): 
            value (Array[float]):
        """
        ...
    def set_bool_parameter(self, name: Name, bool: bool) -> None:
        r"""
        x.set_bool_parameter(name, bool) -> None
        Sets a named Boolean
        
        Args:
            name (Name): 
            bool (bool):
        """
        ...
    def set_bool_array_parameter(self, name: Name, value: Array[bool]) -> None:
        r"""
        x.set_bool_array_parameter(name, value) -> None
        Sets a named Boolean Array
        
        Args:
            name (Name): 
            value (Array[bool]):
        """
        ...
    def reset_parameters(self) -> None:
        r"""
        x.reset_parameters() -> None
        Resets all parameters to their original values.
        """
        ...

class AudioParameterInterface(AudioParameterControllerInterface):
    r"""
    deprecated: 'AudioParameterInterface' was renamed to 'AudioParameterControllerInterface'.
    """
    ...

class AudioEndpointSettingsBase(Object):
    r"""
    This opaque class should be used for specifying settings for how audio should be
    send to an external endpoint.
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: IAudioEndpoint.h
    
    """
    ...

class DummyEndpointSettings(AudioEndpointSettingsBase):
    r"""
    Dummy Endpoint Settings
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: IAudioEndpoint.h
    
    """
    ...

class SoundModulatorBase(Object):
    r"""
    Base class for all modulators
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: IAudioModulation.h
    
    """
    ...

class SoundfieldEndpointSettingsBase(Object):
    r"""
    This opaque class should be used for specifying settings for how audio should be
    send to an external endpoint.
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: ISoundfieldEndpoint.h
    
    """
    ...

class SoundfieldEncodingSettingsBase(Object):
    r"""
    This opaque class should be used for specifying settings for how audio should be encoded
    to your soundfield format for a given submix or file.
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: ISoundfieldFormat.h
    
    """
    ...

class SoundfieldEffectSettingsBase(Object):
    r"""
    Soundfield Effect Settings Base
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: ISoundfieldFormat.h
    
    """
    ...

class SoundfieldEffectBase(Object):
    r"""
    This opaque class should be used for specifying settings for how audio should be encoded
    to your soundfield format for a given submix or file.
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: ISoundfieldFormat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SoundfieldEffectSettingsBase):  [Read-Write] TODO: Filter classes settable on here by GetSettingsClass.
    """
    ...

class AudioLinkSettingsAbstract(Object):
    r"""
    This opaque class should be used for specifying settings for how audio should be
    send to an external audio link.
    
    **C++ Source:**
    
    - **Module**: AudioLinkCore
    - **File**: AudioLinkSettingsAbstract.h
    
    """
    ...

class ClothingInteractor(Object):
    r"""
    Abstract class to control clothing specific interaction.
    Must be cast to the end used clothing simulation object before use.
    
    **C++ Source:**
    
    - **Module**: ClothingSystemRuntimeInterface
    - **File**: ClothingSimulationInteractor.h
    
    """
    ...

class ClothingSimulationInteractor(Object):
    r"""
    If a clothing simulation is able to be interacted with at runtime then a derived
    interactor should be created, and at least the basic API implemented for that
    simulation.
    Only write to the simulation and context during the call to Sync, as that is
    guaranteed to be a safe place to access this data.
    
    **C++ Source:**
    
    - **Module**: ClothingSystemRuntimeInterface
    - **File**: ClothingSimulationInteractor.h
    
    """
    def set_num_substeps(self, num_substeps: int = 1) -> None:
        r"""
        x.set_num_substeps(num_substeps=1) -> None
        Set the number of substeps or subdivisions.
        
        Args:
            num_substeps (int32):
        """
        ...
    def set_num_iterations(self, num_iterations: int = 1) -> None:
        r"""
        x.set_num_iterations(num_iterations=1) -> None
        Set the number of time dependent solver iterations.
        
        Args:
            num_iterations (int32):
        """
        ...
    def set_max_num_iterations(self, max_num_iterations: int = 10) -> None:
        r"""
        x.set_max_num_iterations(max_num_iterations=10) -> None
        Set the maximum number of solver iterations.
        
        Args:
            max_num_iterations (int32):
        """
        ...
    def set_anim_drive_spring_stiffness(self, stiffness: float) -> None:
        r"""
        x.set_anim_drive_spring_stiffness(stiffness) -> None
        Set the stiffness of the spring force for the animation drive.
        
        Args:
            stiffness (float):
        """
        ...
    def physics_asset_updated(self) -> None:
        r"""
        x.physics_asset_updated() -> None
        Called to update collision status without restarting the simulation.
        """
        ...
    def get_simulation_time(self) -> float:
        r"""
        x.get_simulation_time() -> float
        Return the instant average simulation time in ms.
        
        Returns:
            float:
        """
        ...
    def get_num_substeps(self) -> int:
        r"""
        x.get_num_substeps() -> int32
        Return the solver number of subdivisions./
        This could be different from the number set if the simulation hasn't updated yet.
        
        Returns:
            int32:
        """
        ...
    def get_num_kinematic_particles(self) -> int:
        r"""
        x.get_num_kinematic_particles() -> int32
        Return the number of kinematic (animated) particles.
        
        Returns:
            int32:
        """
        ...
    def get_num_iterations(self) -> int:
        r"""
        x.get_num_iterations() -> int32
        Return the solver number of iterations.
        This could be different from the number set if the simulation hasn't updated yet.
        
        Returns:
            int32:
        """
        ...
    def get_num_dynamic_particles(self) -> int:
        r"""
        x.get_num_dynamic_particles() -> int32
        Return the number of dynamic (simulated) particles.
        
        Returns:
            int32:
        """
        ...
    def get_num_cloths(self) -> int:
        r"""
        x.get_num_cloths() -> int32
        Return the number of cloths run by the simulation.
        
        Returns:
            int32:
        """
        ...
    def get_clothing_interactor(self, clothing_asset_name: str) -> ClothingInteractor:
        r"""
        x.get_clothing_interactor(clothing_asset_name) -> ClothingInteractor
        Return a cloth interactor for this simulation.
        
        Args:
            clothing_asset_name (str): 
        
        Returns:
            ClothingInteractor:
        """
        ...
    def enable_gravity_override(self, vector: Vector) -> None:
        r"""
        x.enable_gravity_override(vector) -> None
        Set a new gravity override and enable the override.
        
        Args:
            vector (Vector):
        """
        ...
    def disable_gravity_override(self) -> None:
        r"""
        x.disable_gravity_override() -> None
        Disable any currently set gravity override.
        """
        ...
    def cloth_config_updated(self) -> None:
        r"""
        x.cloth_config_updated() -> None
        Called to update the cloth config without restarting the simulation.
        """
        ...

class ToolMenuBase(Object):
    r"""
    Tool Menu Base
    
    **C++ Source:**
    
    - **Module**: Slate
    - **File**: ToolMenuBase.h
    
    """
    ...

class ToolMenu(ToolMenuBase):
    r"""
    Represents a menu in the ToolMenus system.
    
    An instance of this class is returned by basic APIs such as UToolMenus::RegisterMenu and UToolMenus::ExtendMenu.
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenu.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``close_self_only`` (bool):  [Read-Write]
    - ``menu_name`` (Name):  [Read-Write]
    - ``menu_owner`` (ToolMenuOwner):  [Read-Write]
    - ``menu_parent`` (Name):  [Read-Write]
    - ``menu_type`` (MultiBoxType):  [Read-Write]
    - ``prevent_customization`` (bool):  [Read-Write] Prevent menu from being customized
    - ``searchable`` (bool):  [Read-Write]
    - ``should_close_window_after_menu_selection`` (bool):  [Read-Write]
    - ``style_name`` (Name):  [Read-Write]
    - ``tool_bar_force_small_icons`` (bool):  [Read-Write]
    - ``tool_bar_is_focusable`` (bool):  [Read-Write]
    - ``tutorial_highlight_name`` (Name):  [Read-Write]
    """
    @property
    def menu_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @menu_name.setter
    def menu_name(self, value: Name) -> None:
        ...
    @property
    def menu_parent(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @menu_parent.setter
    def menu_parent(self, value: Name) -> None:
        ...
    @property
    def style_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @style_name.setter
    def style_name(self, value: Name) -> None:
        ...
    @property
    def tutorial_highlight_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @tutorial_highlight_name.setter
    def tutorial_highlight_name(self, value: Name) -> None:
        ...
    @property
    def menu_type(self) -> MultiBoxType:
        r"""
        (MultiBoxType):  [Read-Write]
        """
        ...
    @menu_type.setter
    def menu_type(self, value: MultiBoxType) -> None:
        ...
    @property
    def should_close_window_after_menu_selection(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @should_close_window_after_menu_selection.setter
    def should_close_window_after_menu_selection(self, value: bool) -> None:
        ...
    @property
    def close_self_only(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @close_self_only.setter
    def close_self_only(self, value: bool) -> None:
        ...
    @property
    def searchable(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @searchable.setter
    def searchable(self, value: bool) -> None:
        ...
    @property
    def tool_bar_is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @tool_bar_is_focusable.setter
    def tool_bar_is_focusable(self, value: bool) -> None:
        ...
    @property
    def tool_bar_force_small_icons(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @tool_bar_force_small_icons.setter
    def tool_bar_force_small_icons(self, value: bool) -> None:
        ...
    @property
    def prevent_customization(self) -> bool:
        r"""
        (bool):  [Read-Write] Prevent menu from being customized
        """
        ...
    @prevent_customization.setter
    def prevent_customization(self, value: bool) -> None:
        ...
    @property
    def menu_owner(self) -> ToolMenuOwner:
        r"""
        (ToolMenuOwner):  [Read-Write]
        """
        ...
    @menu_owner.setter
    def menu_owner(self, value: ToolMenuOwner) -> None:
        ...
    def init_menu(self, owner: ToolMenuOwner, name: Name, parent: Name = "None", type: MultiBoxType = MultiBoxType.MENU) -> None:
        r"""
        x.init_menu(owner, name, parent="None", type=MultiBoxType.MENU) -> None
        Init Menu
        
        Args:
            owner (ToolMenuOwner): 
            name (Name): 
            parent (Name): 
            type (MultiBoxType):
        """
        ...
    def add_sub_menu(self, owner: Name, section_name: Name, name: Name, label: Text, tool_tip: Text = "") -> ToolMenu:
        r"""
        x.add_sub_menu(owner, section_name, name, label, tool_tip="") -> ToolMenu
        Add Sub Menu Script
        
        Args:
            owner (Name): 
            section_name (Name): 
            name (Name): 
            label (Text): 
            tool_tip (Text): 
        
        Returns:
            ToolMenu:
        """
        ...
    def add_section(self, section_name: Name, label: Text = "", insert_name: Name = "None", insert_type: ToolMenuInsertType = ToolMenuInsertType.DEFAULT) -> None:
        r"""
        x.add_section(section_name, label="", insert_name="None", insert_type=ToolMenuInsertType.DEFAULT) -> None
        Add Section Script
        
        Args:
            section_name (Name): 
            label (Text): 
            insert_name (Name): 
            insert_type (ToolMenuInsertType):
        """
        ...
    def add_menu_entry_object(self, object: ToolMenuEntryScript) -> None:
        r"""
        x.add_menu_entry_object(object) -> None
        Add Menu Entry Object
        
        Args:
            object (ToolMenuEntryScript):
        """
        ...
    def add_menu_entry(self, section_name: Name, args: ToolMenuEntry) -> None:
        r"""
        x.add_menu_entry(section_name, args) -> None
        Add Menu Entry
        
        Args:
            section_name (Name): 
            args (ToolMenuEntry):
        """
        ...
    def add_dynamic_section(self, section_name: Name, object: ToolMenuSectionDynamic) -> None:
        r"""
        x.add_dynamic_section(section_name, object) -> None
        Add Dynamic Section Script
        
        Args:
            section_name (Name): 
            object (ToolMenuSectionDynamic):
        """
        ...

class ToolMenuContextBase(Object):
    r"""
    Tool Menu Context Base
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuContext.h
    
    """
    ...

class SlateTabManagerContext(ToolMenuContextBase):
    r"""
    Slate Tab Manager Context
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuContext.h
    
    """
    ...

class ToolMenuEntryScript(Object):
    r"""
    Tool Menu Entry Script
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuEntryScript.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data`` (ToolMenuEntryScriptData):  [Read-Write]
    """
    @property
    def data(self) -> ToolMenuEntryScriptData:
        r"""
        (ToolMenuEntryScriptData):  [Read-Write]
        """
        ...
    @data.setter
    def data(self, value: ToolMenuEntryScriptData) -> None:
        ...
    def register_menu_entry(self) -> None:
        r"""
        x.register_menu_entry() -> None
        Register Menu Entry
        """
        ...
    def is_visible(self, context: ToolMenuContext) -> bool:
        r"""
        x.is_visible(context) -> bool
        Is Visible
        
        Args:
            context (ToolMenuContext): 
        
        Returns:
            bool:
        """
        ...
    def init_entry(self, owner_name: Name, menu: Name, section: Name, name: Name, label: Text = "", tool_tip: Text = "") -> None:
        r"""
        x.init_entry(owner_name, menu, section, name, label="", tool_tip="") -> None
        Init Entry
        
        Args:
            owner_name (Name): 
            menu (Name): 
            section (Name): 
            name (Name): 
            label (Text): 
            tool_tip (Text):
        """
        ...
    def get_tool_tip(self, context: ToolMenuContext) -> Text:
        r"""
        x.get_tool_tip(context) -> Text
        Get Tool Tip
        
        Args:
            context (ToolMenuContext): 
        
        Returns:
            Text:
        """
        ...
    def get_label(self, context: ToolMenuContext) -> Text:
        r"""
        x.get_label(context) -> Text
        Get Label
        
        Args:
            context (ToolMenuContext): 
        
        Returns:
            Text:
        """
        ...
    def get_icon(self, context: ToolMenuContext) -> ScriptSlateIcon:
        r"""
        x.get_icon(context) -> ScriptSlateIcon
        Get Icon
        
        Args:
            context (ToolMenuContext): 
        
        Returns:
            ScriptSlateIcon:
        """
        ...
    def get_check_state(self, context: ToolMenuContext) -> CheckBoxState:
        r"""
        x.get_check_state(context) -> CheckBoxState
        Get Check State
        
        Args:
            context (ToolMenuContext): 
        
        Returns:
            CheckBoxState:
        """
        ...
    def execute(self, context: ToolMenuContext) -> None:
        r"""
        x.execute(context) -> None
        Execute
        
        Args:
            context (ToolMenuContext):
        """
        ...
    def construct_menu_entry(self, menu: ToolMenu, section_name: Name, context: ToolMenuContext) -> None:
        r"""
        x.construct_menu_entry(menu, section_name, context) -> None
        Construct Menu Entry
        
        Args:
            menu (ToolMenu): 
            section_name (Name): 
            context (ToolMenuContext):
        """
        ...
    def can_execute(self, context: ToolMenuContext) -> bool:
        r"""
        x.can_execute(context) -> bool
        Can Execute
        
        Args:
            context (ToolMenuContext): 
        
        Returns:
            bool:
        """
        ...

class ToolMenuProfileContext(ToolMenuContextBase):
    r"""
    * A global context that any menu can add/modify to specify which profiles are currently active
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenus.h
    
    """
    ...

class ToolMenus(Object):
    r"""
    Tool Menus
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenus.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``customized_menus`` (Array[CustomizedToolMenu]):  [Read-Write]
    - ``menu_profiles`` (Map[Name, ToolMenuProfileMap]):  [Read-Write] MenuName
    - ``menu_substitutions_during_generate`` (Map[Name, Name]):  [Read-Write] Allow substituting one menu for another during generate but not during find or extend
    """
    def unregister_owner_by_name(self, owner_name: Name) -> None:
        r"""
        x.unregister_owner_by_name(owner_name) -> None
        Removes all entries that were registered under a specific owner name
        
        Args:
            owner_name (Name):
        """
        ...
    def set_section_position(self, menu_name: Name, section_name: Name, other_section_name: Name, position_type: ToolMenuInsertType) -> None:
        r"""
        x.set_section_position(menu_name, section_name, other_section_name, position_type) -> None
        Sets where to insert a section into a menu when generating relative to other section names.
        
        Args:
            menu_name (Name): 
            section_name (Name): 
            other_section_name (Name): 
            position_type (ToolMenuInsertType):
        """
        ...
    def set_section_label(self, menu_name: Name, section_name: Name, label: Text) -> None:
        r"""
        x.set_section_label(menu_name, section_name, label) -> None
        Sets a section's displayed label text.
        
        Args:
            menu_name (Name): 
            section_name (Name): 
            label (Text):
        """
        ...
    def remove_section(self, menu_name: Name, section: Name) -> None:
        r"""
        x.remove_section(menu_name, section) -> None
        Removes a section from a given menu
        
        Args:
            menu_name (Name): 
            section (Name):
        """
        ...
    def remove_menu(self, menu_name: Name) -> None:
        r"""
        x.remove_menu(menu_name) -> None
        Unregisters a menu by name
        
        Args:
            menu_name (Name):
        """
        ...
    def remove_entry(self, menu_name: Name, section: Name, name: Name) -> None:
        r"""
        x.remove_entry(menu_name, section, name) -> None
        Removes a menu entry from a given menu and section
        
        Args:
            menu_name (Name): 
            section (Name): 
            name (Name):
        """
        ...
    def register_menu(self, name: Name, parent: Name = "None", type: MultiBoxType = MultiBoxType.MENU, warn_if_already_registered: bool = True) -> ToolMenu:
        r"""
        x.register_menu(name, parent="None", type=MultiBoxType.MENU, warn_if_already_registered=True) -> ToolMenu
        Registers a menu by name
        
        Args:
            name (Name): 
            parent (Name): Optional name of a menu to layer on top of.
            type (MultiBoxType): Type of menu that will be generated such as: ToolBar, VerticalToolBar, etc..
            warn_if_already_registered (bool): Display warning if already registered
        
        Returns:
            ToolMenu: ToolMenu        Menu object
        """
        ...
    def refresh_menu_widget(self, name: Name) -> bool:
        r"""
        x.refresh_menu_widget(name) -> bool
        Rebuilds all widgets generated from a specific menu.
        
        Args:
            name (Name): 
        
        Returns:
            bool:
        """
        ...
    def refresh_all_widgets(self) -> None:
        r"""
        x.refresh_all_widgets() -> None
        Rebuilds all currently generated widgets next tick.
        """
        ...
    def is_menu_registered(self, name: Name) -> bool:
        r"""
        x.is_menu_registered(name) -> bool
        Determines if a menu has already been registered.
        
        Args:
            name (Name): Name of the menu to find.
        
        Returns:
            bool: bool    True if menu has already been registered.
        """
        ...
    @classmethod
    def get(cls) -> ToolMenus:
        r"""
        X.get() -> ToolMenus
        Get
        
        Returns:
            ToolMenus:
        """
        ...
    def find_menu(self, name: Name) -> ToolMenu:
        r"""
        x.find_menu(name) -> ToolMenu
        Finds an existing menu that has been registered or extended.
        
        Args:
            name (Name): Name of the menu to find.
        
        Returns:
            ToolMenu: ToolMenu        Menu object. Returns null if not found.
        """
        ...
    @classmethod
    def find_context(cls, context: ToolMenuContext, class_: Class) -> Object:
        r"""
        X.find_context(context, class_) -> Object
        Finds a context object of a given class if it exists
        
        Args:
            context (ToolMenuContext): 
            class_ (type(Class)): 
        
        Returns:
            Object:
        """
        ...
    def extend_menu(self, name: Name) -> ToolMenu:
        r"""
        x.extend_menu(name) -> ToolMenu
        Extends a menu without registering the menu or claiming ownership of it. Ok to call even if menu does not exist yet.
        
        Args:
            name (Name): Name of the menu to extend
        
        Returns:
            ToolMenu: ToolMenu        Menu object
        """
        ...
    @classmethod
    def add_menu_entry_object(cls, menu_entry_object: ToolMenuEntryScript) -> bool:
        r"""
        X.add_menu_entry_object(menu_entry_object) -> bool
        Registers menu entry object from blueprint/script
        
        Args:
            menu_entry_object (ToolMenuEntryScript): 
        
        Returns:
            bool:
        """
        ...

class ToolMenuContextExtensions(Object):
    r"""
    Tool Menu Context Extensions
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenusBlueprintLibrary.h
    
    """
    @classmethod
    def find_by_class(cls, context: ToolMenuContext, class_: Class) -> Object:
        r"""
        X.find_by_class(context, class_) -> Object
        Find by Class
        
        Args:
            context (ToolMenuContext): 
            class_ (type(Class)): 
        
        Returns:
            Object:
        """
        ...

class ToolMenuEntryExtensions(Object):
    r"""
    Tool Menu Entry Extensions
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenusBlueprintLibrary.h
    
    """
    @classmethod
    def set_tool_tip(cls, target: ToolMenuEntry, tool_tip: Text) -> ToolMenuEntry:
        r"""
        X.set_tool_tip(target, tool_tip) -> ToolMenuEntry
        Set Tool Tip
        
        Args:
            target (ToolMenuEntry): 
            tool_tip (Text): 
        
        Returns:
            ToolMenuEntry: 
        
            target (ToolMenuEntry):
        """
        ...
    @classmethod
    def set_string_command(cls, target: ToolMenuEntry, type: ToolMenuStringCommandType, custom_type: Name, string: str) -> ToolMenuEntry:
        r"""
        X.set_string_command(target, type, custom_type, string) -> ToolMenuEntry
        Set String Command
        
        Args:
            target (ToolMenuEntry): 
            type (ToolMenuStringCommandType): 
            custom_type (Name): 
            string (str): 
        
        Returns:
            ToolMenuEntry: 
        
            target (ToolMenuEntry):
        """
        ...
    @classmethod
    def set_label(cls, target: ToolMenuEntry, label: Text) -> ToolMenuEntry:
        r"""
        X.set_label(target, label) -> ToolMenuEntry
        Set Label
        
        Args:
            target (ToolMenuEntry): 
            label (Text): 
        
        Returns:
            ToolMenuEntry: 
        
            target (ToolMenuEntry):
        """
        ...
    @classmethod
    def set_icon(cls, target: ToolMenuEntry, style_set_name: Name, style_name: Name = "None", small_style_name: Name = "None") -> ToolMenuEntry:
        r"""
        X.set_icon(target, style_set_name, style_name="None", small_style_name="None") -> ToolMenuEntry
        Set Icon
        
        Args:
            target (ToolMenuEntry): 
            style_set_name (Name): 
            style_name (Name): 
            small_style_name (Name): 
        
        Returns:
            ToolMenuEntry: 
        
            target (ToolMenuEntry):
        """
        ...
    @classmethod
    def init_menu_entry(cls, owner: Name, name: Name, label: Text, tool_tip: Text, command_type: ToolMenuStringCommandType, custom_command_type: Name, command_string: str) -> ToolMenuEntry:
        r"""
        X.init_menu_entry(owner, name, label, tool_tip, command_type, custom_command_type, command_string) -> ToolMenuEntry
        Init Menu Entry
        
        Args:
            owner (Name): 
            name (Name): 
            label (Text): 
            tool_tip (Text): 
            command_type (ToolMenuStringCommandType): 
            custom_command_type (Name): 
            command_string (str): 
        
        Returns:
            ToolMenuEntry:
        """
        ...
    @classmethod
    def get_tool_tip(cls, target: ToolMenuEntry) -> Text:
        r"""
        X.get_tool_tip(target) -> Text
        Get Tool Tip
        
        Args:
            target (ToolMenuEntry): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def get_label(cls, target: ToolMenuEntry) -> Text:
        r"""
        X.get_label(target) -> Text
        Get Label
        
        Args:
            target (ToolMenuEntry): 
        
        Returns:
            Text:
        """
        ...

class ToolMenuSectionExtensions(Object):
    r"""
    Tool Menu Section Extensions
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenusBlueprintLibrary.h
    
    """
    @classmethod
    def set_label(cls, section: ToolMenuSection, label: Text) -> ToolMenuSection:
        r"""
        X.set_label(section, label) -> ToolMenuSection
        Set Label
        
        Args:
            section (ToolMenuSection): 
            label (Text): 
        
        Returns:
            ToolMenuSection: 
        
            section (ToolMenuSection):
        """
        ...
    @classmethod
    def get_label(cls, section: ToolMenuSection) -> Text:
        r"""
        X.get_label(section) -> Text
        Get Label
        
        Args:
            section (ToolMenuSection): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def add_entry_object(cls, section: ToolMenuSection, object: ToolMenuEntryScript) -> ToolMenuSection:
        r"""
        X.add_entry_object(section, object) -> ToolMenuSection
        Add Entry Object
        
        Args:
            section (ToolMenuSection): 
            object (ToolMenuEntryScript): 
        
        Returns:
            ToolMenuSection: 
        
            section (ToolMenuSection):
        """
        ...
    @classmethod
    def add_entry(cls, section: ToolMenuSection, args: ToolMenuEntry) -> ToolMenuSection:
        r"""
        X.add_entry(section, args) -> ToolMenuSection
        Add Entry
        
        Args:
            section (ToolMenuSection): 
            args (ToolMenuEntry): 
        
        Returns:
            ToolMenuSection: 
        
            section (ToolMenuSection):
        """
        ...

class ToolMenuSectionDynamic(Object):
    r"""
    Tool Menu Section Dynamic
    
    **C++ Source:**
    
    - **Module**: ToolMenus
    - **File**: ToolMenuSection.h
    
    """
    def construct_sections(self, menu: ToolMenu, context: ToolMenuContext) -> None:
        r"""
        x.construct_sections(menu, context) -> None
        Construct Sections
        
        Args:
            menu (ToolMenu): 
            context (ToolMenuContext):
        """
        ...

class InterchangeFactoryBase(Object):
    r"""
    Asset factory implementation:
    
    The first three steps use the Interchange factory node to import or reimport the UObject:
    
    1. BeginImportAsset_GameThread - Create the asset UObject. You can also import source data (retrieve payloads) and set up properties on the game thread.
    2. ImportAsset_Async - Import source data (retrieve payloads) and set up properties asynchronously on any thread.
    3. EndImportAsset_GameThread - Anything you need to do on the game thread to finalize the import source data and set up properties. For example, conflict resolution that needs UI.
    
    The last two steps are helpful to change the imported or reimported UObject before and after the PostEditChange (render data build) is called on the asset.
    
    4. SetupObject_GameThread - Do any UObject setup required before the build (before PostEditChange), the UObject dependencies should exist and have all the source data and properties imported.
    5. FinalizeObject_GameThread - Do any final UObject setup after the build (after PostEditChange). Note that the build of an asset can be asynchronous and this function will be call after the async build is done.
    
    Scene factory implementation:
    
    1. ImportSceneObject_GameThread - Create an actor in a level.
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeFactoryBase.h
    
    """
    def get_factory_class(self) -> Class:
        r"""
        x.get_factory_class() -> type(Class)
        Return the UClass this factory can create.
        
        Returns:
            type(Class):
        """
        ...

class InterchangeSourceData(Object):
    r"""
    * Helper class to be able to read different source data
    * File on disk
    * HTTP URL (TODO)
    * Memory buffer (TODO)
    * Stream (TODO)
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeSourceData.h
    
    """
    def set_filename(self, filename: str) -> bool:
        r"""
        x.set_filename(filename) -> bool
        Set Filename
        
        Args:
            filename (str): 
        
        Returns:
            bool:
        """
        ...
    def get_filename(self) -> str:
        r"""
        x.get_filename() -> str
        Get Filename
        
        Returns:
            str:
        """
        ...

class InterchangeWriterBase(Object):
    r"""
    Interchange Writer Base
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeWriterBase.h
    
    """
    ...

class InterchangePipelineBase(Object):
    r"""
    Interchange Pipeline Base
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangePipelineBase.h
    
    """
    def scripted_set_reimport_source_index(self, reimport_object_class: Class, source_file_index: int) -> None:
        r"""
        x.scripted_set_reimport_source_index(reimport_object_class, source_file_index) -> None
        Non-virtual helper that allows Blueprint to implement an event-based function.
        the Interchange framework calls this function, not the virtual one that is called by the default implementation.
        
        Args:
            reimport_object_class (type(Class)): 
            source_file_index (int32):
        """
        ...
    def scripted_get_pipeline_display_name(self) -> str:
        r"""
        x.scripted_get_pipeline_display_name() -> str
        This function is call when we want to list pipeline in the import dialog. If not override the default behavior of this function will search if
        the pipeline have a FString UPROPERTY named "PipelineDisplayName" and return the property value. If there is no FString UPROPERTY call "PipelineDisplayName" it will
        return the name of the pipeline asset (UObject::GetName).
        
        When creating a pipeline (c++, python or blueprint) you can simply add a UPROPERTY name "PipelineDisplayName" to your pipeline, you do not need to override the function.
        Use the same category has your other options and put it on the top.
        The meta tag StandAlonePipelineProperty will hide your PROPERTY if your pipeline is a sub object of another pipeline when showing the import dialog.
        The meta tag PipelineInternalEditionData make sure the property will be show only when we edit the pipeline object (hidden when showing the import dialog).
        
        
        UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Textures", meta = (StandAlonePipelineProperty = "True", PipelineInternalEditionData = "True"))
        FString PipelineDisplayName;
        
        Returns:
            str:
        """
        ...
    def scripted_execute_post_import_pipeline(self, base_node_container: InterchangeBaseNodeContainer, factory_node_key: str, created_asset: Object, is_a_reimport: bool) -> None:
        r"""
        x.scripted_execute_post_import_pipeline(base_node_container, factory_node_key, created_asset, is_a_reimport) -> None
        ScriptedExecutePostImportPipeline is called after an asset is completely imported, after PostEditChange has already been called.
        This can be useful if you need build data for one asset to finish setting up another asset.
        example: A PhysicsAsset needs skeletal mesh render data to be built properly.
        note: the FTaskPostImport calls this function not the virtual one that is call by the default implementation.
        
        Args:
            base_node_container (InterchangeBaseNodeContainer): 
            factory_node_key (str): 
            created_asset (Object): 
            is_a_reimport (bool):
        """
        ...
    def scripted_execute_post_factory_pipeline(self, base_node_container: InterchangeBaseNodeContainer, factory_node_key: str, created_asset: Object, is_a_reimport: bool) -> None:
        r"""
        x.scripted_execute_post_factory_pipeline(base_node_container, factory_node_key, created_asset, is_a_reimport) -> None
        ScriptedExecutePostFactoryPipeline is called after the factory creates an Unreal asset, but before it calls PostEditChange.
        note: The FTaskPreCompletion task calls this function, not the virtual one that is called by the default implementation.
        
        Args:
            base_node_container (InterchangeBaseNodeContainer): 
            factory_node_key (str): 
            created_asset (Object): 
            is_a_reimport (bool):
        """
        ...
    def scripted_execute_pipeline(self, base_node_container: InterchangeBaseNodeContainer, source_datas: Array[InterchangeSourceData], content_base_path: str) -> None:
        r"""
        x.scripted_execute_pipeline(base_node_container, source_datas, content_base_path) -> None
        ScriptedExecutePipeline, is call after the translation and before we parse the graph to call the factory.
        This is where factory node should be created by the pipeline.
        Each factory node represent an unreal asset create that will be create by an interchange factory.
        note: the FTaskPipeline is calling this function not the virtual one that is call by the default implementation.
        
        Args:
            base_node_container (InterchangeBaseNodeContainer): 
            source_datas (Array[InterchangeSourceData]): 
            content_base_path (str):
        """
        ...
    def scripted_execute_export_pipeline(self, base_node_container: InterchangeBaseNodeContainer) -> None:
        r"""
        x.scripted_execute_export_pipeline(base_node_container) -> None
        Non-virtual helper that allows Blueprint to implement an event-based function.
        The Interchange manager calls this function, not the virtual one that is called by the default implementation.
        
        Args:
            base_node_container (InterchangeBaseNodeContainer):
        """
        ...
    def find_or_add_property_states(self, property_path: Name) -> InterchangePipelinePropertyStates:
        r"""
        x.find_or_add_property_states(property_path) -> InterchangePipelinePropertyStates
        Return a mutable property states reference. Add the property states if it doesn't exist.
        
        Args:
            property_path (Name): 
        
        Returns:
            InterchangePipelinePropertyStates:
        """
        ...
    def does_property_states_exist(self, property_path: Name) -> bool:
        r"""
        x.does_property_states_exist(property_path) -> bool
        Return true if the property has valid states, or false if no states were set for the property.
        
        Args:
            property_path (Name): 
        
        Returns:
            bool:
        """
        ...

class InterchangeTranslatorSettings(Object):
    r"""
    Base class for translator settings, the UInterchangeAssetImportData will store this data if the source translator exist
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeTranslatorBase.h
    
    """
    ...

class InterchangeTranslatorBase(Object):
    r"""
    Interchange Translator Base
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeTranslatorBase.h
    
    """
    ...

class InterchangeBaseNode(Object):
    r"""
    This struct is used to store and retrieve key-value attributes. The attributes are stored in a generic FAttributeStorage that serializes the values in a TArray64<uint8>.
    See UE::Interchange::EAttributeTypes to know the supported template types.
    This is an abstract class. This is the base class of the interchange node graph format; all classes in this format should derive from this class.
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeBaseNode.h
    
    """
    def set_parent_uid(self, parent_uid: str) -> bool:
        r"""
        x.set_parent_uid(parent_uid) -> bool
        Set Parent Uid
        
        Args:
            parent_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def set_enabled(self, is_enabled: bool) -> bool:
        r"""
        x.set_enabled(is_enabled) -> bool
        Determine whether this node should be part of the import or export process.
        
        Args:
            is_enabled (bool): If true, this node is imported or exported. If false, it is discarded.
        
        Returns:
            bool: true if the attribute was set, or false otherwise.
        """
        ...
    def set_display_label(self, display_name: str) -> bool:
        r"""
        x.set_display_label(display_name) -> bool
        Change the display label.
        
        Args:
            display_name (str): 
        
        Returns:
            bool:
        """
        ...
    def set_asset_name(self, asset_name: str) -> bool:
        r"""
        x.set_asset_name(asset_name) -> bool
        Set the name for the imported asset this node represents. The asset factory will call GetAssetName().
        
        Args:
            asset_name (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_target_node_uid(self, asset_uid: str) -> bool:
        r"""
        x.remove_target_node_uid(asset_uid) -> bool
        Remove an asset node UID relating to this object.
        
        Args:
            asset_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_attribute(self, node_attribute_key: str) -> bool:
        r"""
        x.remove_attribute(node_attribute_key) -> bool
        Remove the specified attribute from this node. Returns false if it could not be removed. If the attribute does not exist, returns true.
        
        Args:
            node_attribute_key (str): 
        
        Returns:
            bool:
        """
        ...
    def is_enabled(self) -> bool:
        r"""
        x.is_enabled() -> bool
        If true, the node is imported or exported. If false, it is discarded.
        Returns false if the node was disabled. Returns true if the attribute is not there or if it was enabled.
        
        Returns:
            bool:
        """
        ...
    def initialize_node(self, unique_id: str, display_label: str, node_container_type: InterchangeNodeContainerType) -> None:
        r"""
        x.initialize_node(unique_id, display_label, node_container_type) -> None
        Initialize the base data of the node.
        
        Args:
            unique_id (str): The unique ID for this node.
            display_label (str): The name of the node.
            node_container_type (InterchangeNodeContainerType):
        """
        ...
    def get_vector2_attribute(self, node_attribute_key: str) -> Optional[Vector2f]:
        r"""
        x.get_vector2_attribute(node_attribute_key) -> Vector2f or None
        Get a Vector2 attribute from this node. Returns false if the attribute does not exist.
        
        Args:
            node_attribute_key (str): 
        
        Returns:
            Vector2f or None: 
        
            out_value (Vector2f):
        """
        ...
    def get_unique_id(self) -> str:
        r"""
        x.get_unique_id() -> str
        Return the unique ID passed in the constructor.
        
        Returns:
            str:
        """
        ...
    def get_target_node_uids(self) -> Array[str]:
        r"""
        x.get_target_node_uids() -> Array[str]
        Get the target assets relating to this object.
        
        Returns:
            Array[str]: 
        
            out_target_assets (Array[str]):
        """
        ...
    def get_target_node_count(self) -> int:
        r"""
        x.get_target_node_count() -> int32
        Get the number of target assets relating to this object.
        
        Returns:
            int32:
        """
        ...
    def get_string_attribute(self, node_attribute_key: str) -> Optional[str]:
        r"""
        x.get_string_attribute(node_attribute_key) -> str or None
        Get a string attribute from this node. Returns false if the attribute does not exist.
        
        Args:
            node_attribute_key (str): 
        
        Returns:
            str or None: 
        
            out_value (str):
        """
        ...
    def get_parent_uid(self) -> str:
        r"""
        x.get_parent_uid() -> str
        Return the parent unique ID. If the attribute does not exist, returns InvalidNodeUid().
        
        Returns:
            str:
        """
        ...
    def get_node_container_type(self) -> InterchangeNodeContainerType:
        r"""
        x.get_node_container_type() -> InterchangeNodeContainerType
        Return the node container type that defines the purpose of the node (factory node, translated scene node, or translated asset node).
        
        Returns:
            InterchangeNodeContainerType:
        """
        ...
    def get_linear_color_attribute(self, node_attribute_key: str) -> Optional[LinearColor]:
        r"""
        x.get_linear_color_attribute(node_attribute_key) -> LinearColor or None
        Get an FLinearColor attribute from this node. Returns false if the attribute does not exist.
        
        Args:
            node_attribute_key (str): 
        
        Returns:
            LinearColor or None: 
        
            out_value (LinearColor):
        """
        ...
    def get_int32_attribute(self, node_attribute_key: str) -> Optional[int]:
        r"""
        x.get_int32_attribute(node_attribute_key) -> int32 or None
        Get a int32 attribute from this node. Returns false if the attribute does not exist.
        
        Args:
            node_attribute_key (str): 
        
        Returns:
            int32 or None: 
        
            out_value (int32):
        """
        ...
    def get_guid_attribute(self, node_attribute_key: str) -> Optional[Guid]:
        r"""
        x.get_guid_attribute(node_attribute_key) -> Guid or None
        Get a GUID attribute from this node. Returns false if the attribute does not exist.
        
        Args:
            node_attribute_key (str): 
        
        Returns:
            Guid or None: 
        
            out_value (Guid):
        """
        ...
    def get_float_attribute(self, node_attribute_key: str) -> Optional[float]:
        r"""
        x.get_float_attribute(node_attribute_key) -> float or None
        Get a float attribute from this node. Returns false if the attribute does not exist.
        
        Args:
            node_attribute_key (str): 
        
        Returns:
            float or None: 
        
            out_value (float):
        """
        ...
    def get_double_attribute(self, node_attribute_key: str) -> Optional[float]:
        r"""
        x.get_double_attribute(node_attribute_key) -> double or None
        Get a double attribute from this node. Returns false if the attribute does not exist.
        
        Args:
            node_attribute_key (str): 
        
        Returns:
            double or None: 
        
            out_value (double):
        """
        ...
    def get_display_label(self) -> str:
        r"""
        x.get_display_label() -> str
        Return the display label.
        
        Returns:
            str:
        """
        ...
    def get_boolean_attribute(self, node_attribute_key: str) -> Optional[bool]:
        r"""
        x.get_boolean_attribute(node_attribute_key) -> bool or None
        Get a Boolean attribute from this node. Returns false if the attribute does not exist.
        
        Args:
            node_attribute_key (str): 
        
        Returns:
            bool or None: 
        
            out_value (bool):
        """
        ...
    def get_asset_name(self) -> str:
        r"""
        x.get_asset_name() -> str
        Optional. Any node that can import or export an asset should set the desired name for the asset.
        If the attribute was never set, returns GetDisplayLabel().
        
        Returns:
            str:
        """
        ...
    def add_vector2_attribute(self, node_attribute_key: str, value: Vector2f) -> bool:
        r"""
        x.add_vector2_attribute(node_attribute_key, value) -> bool
        Add a Vector2 attribute to this node. Returns false if the attribute does not exist or if it cannot be added.
        
        Args:
            node_attribute_key (str): 
            value (Vector2f): 
        
        Returns:
            bool:
        """
        ...
    def add_target_node_uid(self, asset_uid: str) -> bool:
        r"""
        x.add_target_node_uid(asset_uid) -> bool
        Add an asset node UID relating to this object.
        
        Args:
            asset_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def add_string_attribute(self, node_attribute_key: str, value: str) -> bool:
        r"""
        x.add_string_attribute(node_attribute_key, value) -> bool
        Add a string attribute to this node. Returns false if the attribute does not exist or if it cannot be added.
        
        Args:
            node_attribute_key (str): 
            value (str): 
        
        Returns:
            bool:
        """
        ...
    def add_linear_color_attribute(self, node_attribute_key: str, value: LinearColor) -> bool:
        r"""
        x.add_linear_color_attribute(node_attribute_key, value) -> bool
        Add an FLinearColor attribute to this node. Returns false if the attribute does not exist or if it cannot be added.
        
        Args:
            node_attribute_key (str): 
            value (LinearColor): 
        
        Returns:
            bool:
        """
        ...
    def add_int32_attribute(self, node_attribute_key: str, value: int) -> bool:
        r"""
        x.add_int32_attribute(node_attribute_key, value) -> bool
        Add a int32 attribute to this node. Returns false if the attribute does not exist or if it cannot be added.
        
        Args:
            node_attribute_key (str): 
            value (int32): 
        
        Returns:
            bool:
        """
        ...
    def add_guid_attribute(self, node_attribute_key: str, value: Guid) -> bool:
        r"""
        x.add_guid_attribute(node_attribute_key, value) -> bool
        Add a GUID attribute to this node. Returns false if the attribute does not exist or if it cannot be added.
        
        Args:
            node_attribute_key (str): 
            value (Guid): 
        
        Returns:
            bool:
        """
        ...
    def add_float_attribute(self, node_attribute_key: str, value: float) -> bool:
        r"""
        x.add_float_attribute(node_attribute_key, value) -> bool
        Add a float attribute to this node. Returns false if the attribute does not exist or if it cannot be added.
        
        Args:
            node_attribute_key (str): 
            value (float): 
        
        Returns:
            bool:
        """
        ...
    def add_double_attribute(self, node_attribute_key: str, value: float) -> bool:
        r"""
        x.add_double_attribute(node_attribute_key, value) -> bool
        Add a double attribute to this node. Returns false if the attribute does not exist or if it cannot be added.
        
        Args:
            node_attribute_key (str): 
            value (double): 
        
        Returns:
            bool:
        """
        ...
    def add_boolean_attribute(self, node_attribute_key: str, value: bool) -> bool:
        r"""
        x.add_boolean_attribute(node_attribute_key, value) -> bool
        Add a Boolean attribute to this node. Returns false if the attribute does not exist or if it cannot be added.
        
        Args:
            node_attribute_key (str): 
            value (bool): 
        
        Returns:
            bool:
        """
        ...

class InterchangeBaseNodeContainer(Object):
    r"""
    The Interchange UInterchangeBaseNode graph is a format used to feed factories and writers when they import, reimport, and
    export an asset or scene.
    
    This container holds a flat list of all nodes that have been translated from the source data.
    Translators fill this container, and the import/export managers read it to execute the import/export process.
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeBaseNodeContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``nodes`` (Map[str, InterchangeBaseNode]):  [Read-Only] Flat List of the nodes. Since the nodes are variable size, we store a pointer.
    """
    def set_node_parent_uid(self, node_unique_id: str, new_parent_node_uid: str) -> bool:
        r"""
        x.set_node_parent_uid(node_unique_id, new_parent_node_uid) -> bool
        Set the ParentUid of the node.
        
        Args:
            node_unique_id (str): 
            new_parent_node_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def save_to_file(self, filename: str) -> None:
        r"""
        x.save_to_file(filename) -> None
        Serialize the node container into the specified file.
        
        Args:
            filename (str):
        """
        ...
    def reset_children_cache(self) -> None:
        r"""
        x.reset_children_cache() -> None
        Reset the cache of children UIDs.
        """
        ...
    def reset(self) -> None:
        r"""
        x.reset() -> None
        Empty the container.
        """
        ...
    def replace_node(self, node_unique_id: str, new_node: InterchangeFactoryBaseNode) -> None:
        r"""
        x.replace_node(node_unique_id, new_node) -> None
        Replace Node
        
        Args:
            node_unique_id (str): 
            new_node (InterchangeFactoryBaseNode):
        """
        ...
    def load_from_file(self, filename: str) -> None:
        r"""
        x.load_from_file(filename) -> None
        Serialize the node container from the specified file.
        
        Args:
            filename (str):
        """
        ...
    def is_node_uid_valid(self, node_unique_id: str) -> bool:
        r"""
        x.is_node_uid_valid(node_unique_id) -> bool
        Return true if the node unique ID exists in the container.
        
        Args:
            node_unique_id (str): 
        
        Returns:
            bool:
        """
        ...
    def get_roots(self) -> Array[str]:
        r"""
        x.get_roots() -> Array[str]
        Return all nodes that do not have any parent.
        
        Returns:
            Array[str]: 
        
            root_nodes (Array[str]):
        """
        ...
    def get_nodes(self, class_node: Class) -> Array[str]:
        r"""
        x.get_nodes(class_node) -> Array[str]
        Return all nodes that are of the ClassNode type.
        
        Args:
            class_node (type(Class)): 
        
        Returns:
            Array[str]: 
        
            out_nodes (Array[str]):
        """
        ...
    def get_node_children_uids(self, node_unique_id: str) -> Array[str]:
        r"""
        x.get_node_children_uids(node_unique_id) -> Array[str]
        Get the UIDs of all the node's children.
        
        Args:
            node_unique_id (str): 
        
        Returns:
            Array[str]:
        """
        ...
    def get_node_children_count(self, node_unique_id: str) -> int:
        r"""
        x.get_node_children_count(node_unique_id) -> int32
        Get the number of children the node has.
        
        Args:
            node_unique_id (str): 
        
        Returns:
            int32:
        """
        ...
    def get_node_children(self, node_unique_id: str, child_index: int) -> InterchangeBaseNode:
        r"""
        x.get_node_children(node_unique_id, child_index) -> InterchangeBaseNode
        Get the nth const child of the node
        
        Args:
            node_unique_id (str): 
            child_index (int32): 
        
        Returns:
            InterchangeBaseNode:
        """
        ...
    def get_node(self, node_unique_id: str) -> InterchangeBaseNode:
        r"""
        x.get_node(node_unique_id) -> InterchangeBaseNode
        Get a node pointer. Once added to the container, nodes are considered const.
        
        Args:
            node_unique_id (str): 
        
        Returns:
            InterchangeBaseNode:
        """
        ...
    def get_factory_node(self, node_unique_id: str) -> InterchangeFactoryBaseNode:
        r"""
        x.get_factory_node(node_unique_id) -> InterchangeFactoryBaseNode
        Get a factory node pointer.
        
        Args:
            node_unique_id (str): 
        
        Returns:
            InterchangeFactoryBaseNode:
        """
        ...
    def compute_children_cache(self) -> None:
        r"""
        x.compute_children_cache() -> None
        Fill the cache of children UIDs to optimize the GetNodeChildrenUids call.
        """
        ...
    def add_node(self, node: InterchangeBaseNode) -> str:
        r"""
        x.add_node(node) -> str
        Add a node to the container. The node is added into a TMap.
        return:: return the node unique ID of the added item. If the node already exist it will return the existing ID. Return InvalidNodeUid if the node cannot be added.
        
        Args:
            node (InterchangeBaseNode): a pointer on the node you want to add
        
        Returns:
            str:
        """
        ...

class InterchangeFactoryBaseNode(InterchangeBaseNode):
    r"""
    This struct is used to store and retrieve key-value attributes. The attributes are stored in a generic FAttributeStorage that serializes the values in a TArray64<uint8>.
    See UE::Interchange::EAttributeTypes to know the supported template types.
    This is an abstract class. This is the base class of the Interchange node graph format; all classes in this format should derive from this class.
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeFactoryBaseNode.h
    
    """
    def unset_skip_node_import(self) -> bool:
        r"""
        x.unset_skip_node_import() -> bool
        Remove the skip node attribute. See ShouldSkipNodeImport for more documentation.
        
        Returns:
            bool:
        """
        ...
    def unset_force_node_reimport(self) -> bool:
        r"""
        x.unset_force_node_reimport() -> bool
        Disallow the creation of the Unreal object if it has been previously deleted in the editor.
        
        Returns:
            bool:
        """
        ...
    def should_skip_node_import(self) -> bool:
        r"""
        x.should_skip_node_import() -> bool
        Return true if this node should skip the factory import process, or false otherwise.
        Nodes can be in a situation where we have to skip the import process because we cannot import the associated asset for multiple reasons. For example:
        - An asset can already exist and represents a different type (UClass).
        - An asset can already exist and is being compiled.
        - An asset can already exist and is being imported by another concurrent import task (such as a user importing multiple files at the same time in the same content folder).
        
        Returns:
            bool:
        """
        ...
    def should_force_node_reimport(self) -> bool:
        r"""
        x.should_force_node_reimport() -> bool
        Return whether or not an object should be created even if it has been deleted in the editor.
        Return false by default.
        
        Returns:
            bool:
        """
        ...
    def set_skip_node_import(self) -> bool:
        r"""
        x.set_skip_node_import() -> bool
        Add the skip node attribute. Use this function to cancel the creation of the Unreal asset. See ShouldSkipNodeImport for more documentation.
        
        Returns:
            bool:
        """
        ...
    def set_reimport_strategy_flags(self, reimport_strategy_flags: ReimportStrategyFlags) -> bool:
        r"""
        x.set_reimport_strategy_flags(reimport_strategy_flags) -> bool
        Change the reimport strategy flags.
        
        Args:
            reimport_strategy_flags (ReimportStrategyFlags): 
        
        Returns:
            bool:
        """
        ...
    def set_force_node_reimport(self) -> bool:
        r"""
        x.set_force_node_reimport() -> bool
        Allow the creation of the Unreal object even if it has been previously deleted in the editor.
        
        Returns:
            bool:
        """
        ...
    def set_custom_sub_path(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_sub_path(attribute_value) -> bool
        Set the custom sub-path under PackageBasePath where the assets will be created.
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_reference_object(self, attribute_value: SoftObjectPath) -> bool:
        r"""
        x.set_custom_reference_object(attribute_value) -> bool
        Set the custom ReferenceObject: the UObject this factory node has created.
        
        Args:
            attribute_value (SoftObjectPath): 
        
        Returns:
            bool:
        """
        ...
    def remove_factory_dependency_uid(self, dependency_uid: str) -> bool:
        r"""
        x.remove_factory_dependency_uid(dependency_uid) -> bool
        Remove one dependency from this object.
        
        Args:
            dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def get_reimport_strategy_flags(self) -> ReimportStrategyFlags:
        r"""
        x.get_reimport_strategy_flags() -> ReimportStrategyFlags
        Return the reimport strategy flags.
        
        Returns:
            ReimportStrategyFlags:
        """
        ...
    def get_factory_dependency(self, index: int) -> str:
        r"""
        x.get_factory_dependency(index) -> str
        Retrieve one dependency for this object.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_dependency (str):
        """
        ...
    def get_factory_dependencies_count(self) -> int:
        r"""
        x.get_factory_dependencies_count() -> int32
        Retrieve the number of factory dependencies for this object.
        
        Returns:
            int32:
        """
        ...
    def get_factory_dependencies(self) -> Array[str]:
        r"""
        x.get_factory_dependencies() -> Array[str]
        Retrieve the dependencies for this object.
        
        Returns:
            Array[str]: 
        
            out_dependencies (Array[str]):
        """
        ...
    def get_custom_sub_path(self) -> Optional[str]:
        r"""
        x.get_custom_sub_path() -> str or None
        Return the custom sub-path under PackageBasePath where the assets will be created.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_reference_object(self) -> Optional[SoftObjectPath]:
        r"""
        x.get_custom_reference_object() -> SoftObjectPath or None
        Return the custom ReferenceObject: the UObject this factory node has created.
        
        Returns:
            SoftObjectPath or None: 
        
            attribute_value (SoftObjectPath):
        """
        ...
    def add_factory_dependency_uid(self, dependency_uid: str) -> bool:
        r"""
        x.add_factory_dependency_uid(dependency_uid) -> bool
        Add one dependency to this object.
        
        Args:
            dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeSourceNode(InterchangeBaseNode):
    r"""
    This class allows a translator to add general source data that describes the whole source. Pipelines can use this information.
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeSourceNode.h
    
    """
    def set_custom_source_timeline_start(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_source_timeline_start(attribute_value) -> bool
        Set the start of the source timeline.
        
        Args:
            attribute_value (double): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_source_timeline_end(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_source_timeline_end(attribute_value) -> bool
        Set the end of the source timeline.
        
        Args:
            attribute_value (double): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_source_frame_rate_numerator(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_source_frame_rate_numerator(attribute_value) -> bool
        Set the source frame rate numerator.
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_source_frame_rate_denominator(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_source_frame_rate_denominator(attribute_value) -> bool
        Set the source frame rate denominator.
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_import_unused_material(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_import_unused_material(attribute_value) -> bool
        Set whether to import materials that aren't used.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_animated_time_start(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_animated_time_start(attribute_value) -> bool
        Set the start of the source animated time.
        
        Args:
            attribute_value (double): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_animated_time_end(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_animated_time_end(attribute_value) -> bool
        Set the end of the source animated time.
        
        Args:
            attribute_value (double): 
        
        Returns:
            bool:
        """
        ...
    def initialize_source_node(self, unique_id: str, display_label: str) -> None:
        r"""
        x.initialize_source_node(unique_id, display_label) -> None
        Initialize the base data of the node.
        
        Args:
            unique_id (str): The unique ID for this node.
            display_label (str): The name of the node.
        """
        ...
    def get_custom_source_timeline_start(self) -> Optional[float]:
        r"""
        x.get_custom_source_timeline_start() -> double or None
        Query the start of the source timeline.
        
        Returns:
            double or None: 
        
            attribute_value (double):
        """
        ...
    def get_custom_source_timeline_end(self) -> Optional[float]:
        r"""
        x.get_custom_source_timeline_end() -> double or None
        Query the end of the source timeline.
        
        Returns:
            double or None: 
        
            attribute_value (double):
        """
        ...
    def get_custom_source_frame_rate_numerator(self) -> Optional[int]:
        r"""
        x.get_custom_source_frame_rate_numerator() -> int32 or None
        Query the source frame rate numerator.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_source_frame_rate_denominator(self) -> Optional[int]:
        r"""
        x.get_custom_source_frame_rate_denominator() -> int32 or None
        Query the source frame rate denominator.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_import_unused_material(self) -> Optional[bool]:
        r"""
        x.get_custom_import_unused_material() -> bool or None
        Query whether to import materials that aren't used.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_animated_time_start(self) -> Optional[float]:
        r"""
        x.get_custom_animated_time_start() -> double or None
        Query the start of the source animated time.
        
        Returns:
            double or None: 
        
            attribute_value (double):
        """
        ...
    def get_custom_animated_time_end(self) -> Optional[float]:
        r"""
        x.get_custom_animated_time_end() -> double or None
        Query the end of the source animated time.
        
        Returns:
            double or None: 
        
            attribute_value (double):
        """
        ...

class InterchangeUserDefinedAttributesAPI(Object):
    r"""
    UInterchangeUserDefinedAttributesAPI is used to store and retrieve user-defined attributes such as DCC node attributes, so that pipelines have access to those attributes.
    Every user-defined attribute has a name, a value, and an optional AnimationPayloadKey: an FRichCurve that is a float curve.
    The value type must be supported by the UE::Interchange::EAttributeTypes enumeration.
    
    **C++ Source:**
    
    - **Module**: InterchangeCore
    - **File**: InterchangeUserDefinedAttribute.h
    
    """
    @classmethod
    def remove_user_defined_attribute(cls, interchange_node: InterchangeBaseNode, user_defined_attribute_name: str) -> bool:
        r"""
        X.remove_user_defined_attribute(interchange_node, user_defined_attribute_name) -> bool
        Remove the specified user-defined attribute.
        
        Args:
            interchange_node (InterchangeBaseNode): 
            user_defined_attribute_name (str): The name of the user-defined attribute to remove.
        
        Returns:
            bool: True if the attribute exists and was removed, or if the attribute doesn't exist. Returns false if the attribute exists but could not be removed. Note - User-defined attributes are the user custom attributes from the DCC translated node (for example, extra attributes in Maya). The payload key points to an FRichCurve payload.
        """
        ...
    @classmethod
    def get_user_defined_attribute_infos(cls, interchange_node: InterchangeBaseNode) -> Array[InterchangeUserDefinedAttributeInfo]:
        r"""
        X.get_user_defined_attribute_infos(interchange_node) -> Array[InterchangeUserDefinedAttributeInfo]
        Get User Defined Attribute Infos
        
        Args:
            interchange_node (InterchangeBaseNode): 
        
        Returns:
            Array[InterchangeUserDefinedAttributeInfo]: 
        
            user_defined_attribute_infos (Array[InterchangeUserDefinedAttributeInfo]):
        """
        ...
    @classmethod
    def get_user_defined_attribute_int32(cls, interchange_node: InterchangeBaseNode, user_defined_attribute_name: str) -> Optional[Tuple[int, str]]:
        r"""
        X.get_user_defined_attribute_int32(interchange_node, user_defined_attribute_name) -> (out_value=int32, out_payload_key=str) or None
        Get User Defined Attribute Int 32
        
        Args:
            interchange_node (InterchangeBaseNode): 
            user_defined_attribute_name (str): 
        
        Returns:
            tuple or None: 
        
            out_value (int32): 
        
            out_payload_key (str):
        """
        ...
    @classmethod
    def get_user_defined_attribute_f_string(cls, interchange_node: InterchangeBaseNode, user_defined_attribute_name: str) -> Optional[Tuple[str, str]]:
        r"""
        X.get_user_defined_attribute_f_string(interchange_node, user_defined_attribute_name) -> (out_value=str, out_payload_key=str) or None
        Get User Defined Attribute FString
        
        Args:
            interchange_node (InterchangeBaseNode): 
            user_defined_attribute_name (str): 
        
        Returns:
            tuple or None: 
        
            out_value (str): 
        
            out_payload_key (str):
        """
        ...
    @classmethod
    def get_user_defined_attribute_float(cls, interchange_node: InterchangeBaseNode, user_defined_attribute_name: str) -> Optional[Tuple[float, str]]:
        r"""
        X.get_user_defined_attribute_float(interchange_node, user_defined_attribute_name) -> (out_value=float, out_payload_key=str) or None
        Get User Defined Attribute Float
        
        Args:
            interchange_node (InterchangeBaseNode): 
            user_defined_attribute_name (str): 
        
        Returns:
            tuple or None: 
        
            out_value (float): 
        
            out_payload_key (str):
        """
        ...
    @classmethod
    def get_user_defined_attribute_double(cls, interchange_node: InterchangeBaseNode, user_defined_attribute_name: str) -> Optional[Tuple[float, str]]:
        r"""
        X.get_user_defined_attribute_double(interchange_node, user_defined_attribute_name) -> (out_value=double, out_payload_key=str) or None
        Get User Defined Attribute Double
        
        Args:
            interchange_node (InterchangeBaseNode): 
            user_defined_attribute_name (str): 
        
        Returns:
            tuple or None: 
        
            out_value (double): 
        
            out_payload_key (str):
        """
        ...
    @classmethod
    def get_user_defined_attribute_boolean(cls, interchange_node: InterchangeBaseNode, user_defined_attribute_name: str) -> Optional[Tuple[bool, str]]:
        r"""
        X.get_user_defined_attribute_boolean(interchange_node, user_defined_attribute_name) -> (out_value=bool, out_payload_key=str) or None
        Get User Defined Attribute Boolean
        
        Args:
            interchange_node (InterchangeBaseNode): 
            user_defined_attribute_name (str): 
        
        Returns:
            tuple or None: 
        
            out_value (bool): 
        
            out_payload_key (str):
        """
        ...
    @classmethod
    def duplicate_all_user_defined_attribute(cls, interchange_source_node: InterchangeBaseNode, interchange_destination_node: InterchangeBaseNode, add_source_node_name: bool) -> None:
        r"""
        X.duplicate_all_user_defined_attribute(interchange_source_node, interchange_destination_node, add_source_node_name) -> None
        Duplicate All User Defined Attribute
        
        Args:
            interchange_source_node (InterchangeBaseNode): 
            interchange_destination_node (InterchangeBaseNode): 
            add_source_node_name (bool):
        """
        ...
    @classmethod
    def create_user_defined_attribute_int32(cls, interchange_node: InterchangeBaseNode, user_defined_attribute_name: str, value: int, payload_key: str, requires_delegate: bool = False) -> bool:
        r"""
        X.create_user_defined_attribute_int32(interchange_node, user_defined_attribute_name, value, payload_key, requires_delegate=False) -> bool
        Create User Defined Attribute Int 32
        
        Args:
            interchange_node (InterchangeBaseNode): 
            user_defined_attribute_name (str): 
            value (int32): 
            payload_key (str): 
            requires_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def create_user_defined_attribute_f_string(cls, interchange_node: InterchangeBaseNode, user_defined_attribute_name: str, value: str, payload_key: str, requires_delegate: bool = False) -> bool:
        r"""
        X.create_user_defined_attribute_f_string(interchange_node, user_defined_attribute_name, value, payload_key, requires_delegate=False) -> bool
        Create User Defined Attribute FString
        
        Args:
            interchange_node (InterchangeBaseNode): 
            user_defined_attribute_name (str): 
            value (str): 
            payload_key (str): 
            requires_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def create_user_defined_attribute_float(cls, interchange_node: InterchangeBaseNode, user_defined_attribute_name: str, value: float, payload_key: str, requires_delegate: bool = False) -> bool:
        r"""
        X.create_user_defined_attribute_float(interchange_node, user_defined_attribute_name, value, payload_key, requires_delegate=False) -> bool
        Create User Defined Attribute Float
        
        Args:
            interchange_node (InterchangeBaseNode): 
            user_defined_attribute_name (str): 
            value (float): 
            payload_key (str): 
            requires_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def create_user_defined_attribute_double(cls, interchange_node: InterchangeBaseNode, user_defined_attribute_name: str, value: float, payload_key: str, requires_delegate: bool = False) -> bool:
        r"""
        X.create_user_defined_attribute_double(interchange_node, user_defined_attribute_name, value, payload_key, requires_delegate=False) -> bool
        Create User Defined Attribute Double
        
        Args:
            interchange_node (InterchangeBaseNode): 
            user_defined_attribute_name (str): 
            value (double): 
            payload_key (str): 
            requires_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def create_user_defined_attribute_boolean(cls, interchange_node: InterchangeBaseNode, user_defined_attribute_name: str, value: bool, payload_key: str, requires_delegate: bool = False) -> bool:
        r"""
        X.create_user_defined_attribute_boolean(interchange_node, user_defined_attribute_name, value, payload_key, requires_delegate=False) -> bool
        Create User Defined Attribute Boolean
        
        Args:
            interchange_node (InterchangeBaseNode): 
            user_defined_attribute_name (str): 
            value (bool): 
            payload_key (str): 
            requires_delegate (bool): 
        
        Returns:
            bool:
        """
        ...

class PropertyPathTestObject(Object):
    r"""
    Property Path Test Object
    
    **C++ Source:**
    
    - **Module**: PropertyPath
    - **File**: PropertyPathHelpersTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool`` (bool):  [Read-Write]
    - ``enum_four`` (PropertyPathTestEnum):  [Read-Write]
    - ``enum_one`` (PropertyPathTestEnum):  [Read-Write]
    - ``enum_three`` (PropertyPathTestEnum):  [Read-Write]
    - ``enum_two`` (PropertyPathTestEnum):  [Read-Write]
    - ``float`` (float):  [Read-Write]
    - ``inner_object`` (PropertyPathTestObject):  [Read-Write]
    - ``integer`` (int32):  [Read-Write]
    - ``string`` (str):  [Read-Write]
    - ``struct`` (PropertyPathTestStruct):  [Read-Write]
    - ``struct_const_ref`` (PropertyPathTestStruct):  [Read-Write]
    - ``struct_ref`` (PropertyPathTestStruct):  [Read-Write]
    """
    @property
    def bool(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @bool.setter
    def bool(self, value: bool) -> None:
        ...
    @property
    def integer(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @integer.setter
    def integer(self, value: int) -> None:
        ...
    @property
    def string(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @string.setter
    def string(self, value: str) -> None:
        ...
    @property
    def float(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @float.setter
    def float(self, value: float) -> None:
        ...
    @property
    def struct(self) -> PropertyPathTestStruct:
        r"""
        (PropertyPathTestStruct):  [Read-Write]
        """
        ...
    @struct.setter
    def struct(self, value: PropertyPathTestStruct) -> None:
        ...
    @property
    def struct_ref(self) -> PropertyPathTestStruct:
        r"""
        (PropertyPathTestStruct):  [Read-Write]
        """
        ...
    @struct_ref.setter
    def struct_ref(self, value: PropertyPathTestStruct) -> None:
        ...
    @property
    def struct_const_ref(self) -> PropertyPathTestStruct:
        r"""
        (PropertyPathTestStruct):  [Read-Write]
        """
        ...
    @struct_const_ref.setter
    def struct_const_ref(self, value: PropertyPathTestStruct) -> None:
        ...
    @property
    def inner_object(self) -> PropertyPathTestObject:
        r"""
        (PropertyPathTestObject):  [Read-Only]
        """
        ...

class LiveLinkFramePreProcessor(Object):
    r"""
    Basic object to apply preprocessing to a live link frame.
    Inherit from it to add specific operations / options for a certain type of data
    note: It can only be used on the Game Thread. See ILiveLinkFramePreProcessorWorker for the any thread implementation.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkFramePreProcessor.h
    
    """
    ...

class LiveLinkRole(Object):
    r"""
    Basic object to extend the meaning of incoming live link frames.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkRole.h
    
    """
    ...

class LiveLinkBasicRole(LiveLinkRole):
    r"""
    Role associated for no specific role data.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkBasicRole.h
    
    """
    ...

class LiveLinkInputDeviceRole(LiveLinkBasicRole):
    r"""
    Role associated with Input Device data.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkInputDeviceRole.h
    
    """
    ...

class LiveLinkAnimationRole(LiveLinkBasicRole):
    r"""
    Role associated for Animation / Skeleton data.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkAnimationRole.h
    
    """
    ...

class LiveLinkTransformRole(LiveLinkBasicRole):
    r"""
    Role associated for Camera data.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkTransformRole.h
    
    """
    ...

class LiveLinkCameraRole(LiveLinkTransformRole):
    r"""
    Role associated for Camera data.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkCameraRole.h
    
    """
    ...

class LiveLinkLightRole(LiveLinkTransformRole):
    r"""
    Role associated for Light data.
    
    **C++ Source:**
    
    - **Module**: LiveLinkInterface
    - **File**: LiveLinkLightRole.h
    
    """
    ...

class MovieSceneCaptureProtocolBase(Object):
    r"""
    A capture protocol responsible for dealing with captured frames using some custom method (writing out to disk, streaming, etc)
    
    A typical process for capture consits of the following process:
        Setup -> [ Warm up -> [ Capture Frame ] ] -> Begin Finalize -> [ HasFinishedProcessing ] -> Finalize
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: MovieSceneCaptureProtocolBase.h
    
    """
    def is_capturing(self) -> bool:
        r"""
        x.is_capturing() -> bool
        Check whether we can capture a frame from this protocol
        
        Returns:
            bool:
        """
        ...
    def get_state(self) -> MovieSceneCaptureProtocolState:
        r"""
        x.get_state() -> MovieSceneCaptureProtocolState
        Get the current state of this capture protocol
        
        Returns:
            MovieSceneCaptureProtocolState:
        """
        ...

class MovieSceneAudioCaptureProtocolBase(MovieSceneCaptureProtocolBase):
    r"""
    A class to inherit from for audio capture protocols. Used to filter the UI for protocols used on the audio capture pass.
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: MovieSceneCaptureProtocolBase.h
    
    """
    ...

class NullAudioCaptureProtocol(MovieSceneAudioCaptureProtocolBase):
    r"""
    This is a null audio capture implementation which skips capturing audio. The MovieSceneCapture is explicitly
    aware of this type and will skip processing an audio pass if this is specified.
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: AudioCaptureProtocol.h
    
    """
    ...

class MasterAudioSubmixCaptureProtocol(MovieSceneAudioCaptureProtocolBase):
    r"""
    This is an experimental audio capture implementation which captures the final output from the master submix.
    This requires that your sequence can be played back in real-time (when rendering is disabled).
    If the sequence evaluation hitches the audio will become desynchronized due to their being more time passed
    in real time (platform time) than in the sequence itself.
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: AudioCaptureProtocol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``file_name`` (str):  [Read-Write]
    """
    @property
    def file_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @file_name.setter
    def file_name(self, value: str) -> None:
        ...

class MovieSceneImageCaptureProtocolBase(MovieSceneCaptureProtocolBase):
    r"""
    A class to inherit from for image capture protocols. Used to filter the UI for protocols used on the image capture pass.
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: MovieSceneCaptureProtocolBase.h
    
    """
    ...

class CompositionGraphCaptureProtocol(MovieSceneImageCaptureProtocolBase):
    r"""
    Composition Graph Capture Protocol
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: CompositionGraphCaptureProtocol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``capture_frames_in_hdr`` (bool):  [Read-Write] Whether to capture the frames as HDR textures (*.exr format)
    - ``capture_gamut`` (HDRCaptureGamut):  [Read-Write] The color gamut to use when storing HDR captured data. The gamut depends on whether the bCaptureFramesInHDR option is enabled.
    - ``disable_screen_percentage`` (bool):  [Read-Write] Whether to disable screen percentage
    - ``hdr_compression_quality`` (int32):  [Read-Write] Compression Quality for HDR Frames (0 for no compression, 1 for default compression which can be slow)
    - ``include_render_passes`` (CompositionGraphCapturePasses):  [Read-Write] A list of render passes to include in the capture. Leave empty to export all available passes.
    - ``post_processing_material`` (SoftObjectPath):  [Read-Write] Custom post processing material to use for rendering
    """
    @property
    def include_render_passes(self) -> CompositionGraphCapturePasses:
        r"""
        (CompositionGraphCapturePasses):  [Read-Write] A list of render passes to include in the capture. Leave empty to export all available passes.
        """
        ...
    @include_render_passes.setter
    def include_render_passes(self, value: CompositionGraphCapturePasses) -> None:
        ...
    @property
    def capture_frames_in_hdr(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to capture the frames as HDR textures (*.exr format)
        """
        ...
    @capture_frames_in_hdr.setter
    def capture_frames_in_hdr(self, value: bool) -> None:
        ...
    @property
    def hdr_compression_quality(self) -> int:
        r"""
        (int32):  [Read-Write] Compression Quality for HDR Frames (0 for no compression, 1 for default compression which can be slow)
        """
        ...
    @hdr_compression_quality.setter
    def hdr_compression_quality(self, value: int) -> None:
        ...
    @property
    def capture_gamut(self) -> HDRCaptureGamut:
        r"""
        (HDRCaptureGamut):  [Read-Write] The color gamut to use when storing HDR captured data. The gamut depends on whether the bCaptureFramesInHDR option is enabled.
        """
        ...
    @capture_gamut.setter
    def capture_gamut(self, value: HDRCaptureGamut) -> None:
        ...
    @property
    def post_processing_material(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Write] Custom post processing material to use for rendering
        """
        ...
    @post_processing_material.setter
    def post_processing_material(self, value: SoftObjectPath) -> None:
        ...
    @property
    def disable_screen_percentage(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to disable screen percentage
        """
        ...
    @disable_screen_percentage.setter
    def disable_screen_percentage(self, value: bool) -> None:
        ...

class FrameGrabberProtocol(MovieSceneImageCaptureProtocolBase):
    r"""
    Frame Grabber Protocol
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: FrameGrabberProtocol.h
    
    """
    ...

class ImageSequenceProtocol(FrameGrabberProtocol):
    r"""
    Image Sequence Protocol
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: ImageSequenceProtocol.h
    
    """
    ...

class CompressedImageSequenceProtocol(ImageSequenceProtocol):
    r"""
    Compressed Image Sequence Protocol
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: ImageSequenceProtocol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``compression_quality`` (int32):  [Read-Write] Level of compression to apply to the image, between 1 (worst quality, best compression) and 100 (best quality, worst compression)
    """
    @property
    def compression_quality(self) -> int:
        r"""
        (int32):  [Read-Write] Level of compression to apply to the image, between 1 (worst quality, best compression) and 100 (best quality, worst compression)
        """
        ...
    @compression_quality.setter
    def compression_quality(self, value: int) -> None:
        ...

class ImageSequenceProtocol_BMP(ImageSequenceProtocol):
    r"""
    Image Sequence Protocol BMP
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: ImageSequenceProtocol.h
    
    """
    ...

class ImageSequenceProtocol_PNG(CompressedImageSequenceProtocol):
    r"""
    Image Sequence Protocol PNG
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: ImageSequenceProtocol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``compression_quality`` (int32):  [Read-Write] Level of compression to apply to the image, between 1 (worst quality, best compression) and 100 (best quality, worst compression)
    """
    ...

class ImageSequenceProtocol_JPG(CompressedImageSequenceProtocol):
    r"""
    Image Sequence Protocol JPG
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: ImageSequenceProtocol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``compression_quality`` (int32):  [Read-Write] Level of compression to apply to the image, between 1 (worst quality, best compression) and 100 (best quality, worst compression)
    """
    ...

class ImageSequenceProtocol_EXR(ImageSequenceProtocol):
    r"""
    Image Sequence Protocol EXR
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: ImageSequenceProtocol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``capture_gamut`` (HDRCaptureGamut):  [Read-Write] The color gamut to use when storing HDR captured data.
    - ``compressed`` (bool):  [Read-Write] Whether to write out compressed or uncompressed EXRs
    """
    ...

class MovieSceneCapture(Object):
    r"""
    Class responsible for capturing scene data
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: MovieSceneCapture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_command_line_arguments`` (str):  [Read-Write] Additional command line arguments to pass to the external process when capturing
    - ``audio_capture_protocol`` (MovieSceneAudioCaptureProtocolBase):  [Read-Only]
    - ``audio_capture_protocol_type`` (SoftClassPath):  [Read-Write] The type of capture protocol to use for audio data.
    - ``close_editor_when_capture_starts`` (bool):  [Read-Write] When enabled, the editor will shutdown when the capture starts
    - ``image_capture_protocol`` (MovieSceneImageCaptureProtocolBase):  [Read-Only] Capture protocol responsible for actually capturing frame data
    - ``image_capture_protocol_type`` (SoftClassPath):  [Read-Write] The type of capture protocol to use for image data
    - ``inherited_command_line_arguments`` (str):  [Read-Write] Command line arguments inherited from this process
    - ``settings`` (MovieSceneCaptureSettings):  [Read-Write] Settings that define how to capture
    - ``use_separate_process`` (bool):  [Read-Write] Whether to capture the movie in a separate process or not
    """
    @property
    def settings(self) -> MovieSceneCaptureSettings:
        r"""
        (MovieSceneCaptureSettings):  [Read-Write] Settings that define how to capture
        """
        ...
    @settings.setter
    def settings(self, value: MovieSceneCaptureSettings) -> None:
        ...
    @property
    def use_separate_process(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to capture the movie in a separate process or not
        """
        ...
    @use_separate_process.setter
    def use_separate_process(self, value: bool) -> None:
        ...
    @property
    def close_editor_when_capture_starts(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled, the editor will shutdown when the capture starts
        """
        ...
    @close_editor_when_capture_starts.setter
    def close_editor_when_capture_starts(self, value: bool) -> None:
        ...
    @property
    def additional_command_line_arguments(self) -> str:
        r"""
        (str):  [Read-Write] Additional command line arguments to pass to the external process when capturing
        """
        ...
    @additional_command_line_arguments.setter
    def additional_command_line_arguments(self, value: str) -> None:
        ...
    @property
    def inherited_command_line_arguments(self) -> str:
        r"""
        (str):  [Read-Write] Command line arguments inherited from this process
        """
        ...
    @inherited_command_line_arguments.setter
    def inherited_command_line_arguments(self, value: str) -> None:
        ...
    def set_image_capture_protocol_type(self, protocol_type: Class) -> None:
        r"""
        x.set_image_capture_protocol_type(protocol_type) -> None
        Set Image Capture Protocol Type
        
        Args:
            protocol_type (type(Class)):
        """
        ...
    def set_audio_capture_protocol_type(self, protocol_type: Class) -> None:
        r"""
        x.set_audio_capture_protocol_type(protocol_type) -> None
        Set Audio Capture Protocol Type
        
        Args:
            protocol_type (type(Class)):
        """
        ...
    def get_image_capture_protocol(self) -> MovieSceneCaptureProtocolBase:
        r"""
        x.get_image_capture_protocol() -> MovieSceneCaptureProtocolBase
        Access the capture protocol we are using
        
        Returns:
            MovieSceneCaptureProtocolBase:
        """
        ...
    def get_audio_capture_protocol(self) -> MovieSceneCaptureProtocolBase:
        r"""
        x.get_audio_capture_protocol() -> MovieSceneCaptureProtocolBase
        Get Audio Capture Protocol
        
        Returns:
            MovieSceneCaptureProtocolBase:
        """
        ...

class LevelCapture(MovieSceneCapture):
    r"""
    Level Capture
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: LevelCapture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_command_line_arguments`` (str):  [Read-Write] Additional command line arguments to pass to the external process when capturing
    - ``audio_capture_protocol`` (MovieSceneAudioCaptureProtocolBase):  [Read-Only]
    - ``audio_capture_protocol_type`` (SoftClassPath):  [Read-Write] The type of capture protocol to use for audio data.
    - ``auto_start_capture`` (bool):  [Read-Write] Specifies whether the capture should start immediately, or whether it will be invoked externally (through StartMovieCapture/StopMovieCapture exec commands)
    - ``close_editor_when_capture_starts`` (bool):  [Read-Write] When enabled, the editor will shutdown when the capture starts
    - ``image_capture_protocol`` (MovieSceneImageCaptureProtocolBase):  [Read-Only] Capture protocol responsible for actually capturing frame data
    - ``image_capture_protocol_type`` (SoftClassPath):  [Read-Write] The type of capture protocol to use for image data
    - ``inherited_command_line_arguments`` (str):  [Read-Write] Command line arguments inherited from this process
    - ``settings`` (MovieSceneCaptureSettings):  [Read-Write] Settings that define how to capture
    - ``use_separate_process`` (bool):  [Read-Write] Whether to capture the movie in a separate process or not
    """
    ...

class MovieSceneCaptureEnvironment(Object):
    r"""
    Movie Scene Capture Environment
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: MovieSceneCaptureEnvironment.h
    
    """
    @classmethod
    def is_capture_in_progress(cls) -> bool:
        r"""
        X.is_capture_in_progress() -> bool
        Return true if there is any capture currently active (even in a warm-up state).
        Useful for checking whether to do certain operations in BeginPlay
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_capture_frame_number(cls) -> int:
        r"""
        X.get_capture_frame_number() -> int32
        Get the frame number of the current capture
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_capture_elapsed_time(cls) -> float:
        r"""
        X.get_capture_elapsed_time() -> float
        Get the total elapsed time of the current capture in seconds
        
        Returns:
            float:
        """
        ...
    @classmethod
    def find_image_capture_protocol(cls) -> MovieSceneImageCaptureProtocolBase:
        r"""
        X.find_image_capture_protocol() -> MovieSceneImageCaptureProtocolBase
        Attempt to locate a capture protocol - may not be in a capturing state
        
        Returns:
            MovieSceneImageCaptureProtocolBase:
        """
        ...
    @classmethod
    def find_audio_capture_protocol(cls) -> MovieSceneAudioCaptureProtocolBase:
        r"""
        X.find_audio_capture_protocol() -> MovieSceneAudioCaptureProtocolBase
        Attempt to locate a capture protocol - may not be in a capturing state
        
        Returns:
            MovieSceneAudioCaptureProtocolBase:
        """
        ...

class UserDefinedCaptureProtocol(MovieSceneImageCaptureProtocolBase):
    r"""
    A blueprintable capture protocol that defines how to capture frames from the engine
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: UserDefinedCaptureProtocol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``world`` (World):  [Read-Write] World pointer assigned on Setup
    """
    @property
    def world(self) -> World:
        r"""
        (World):  [Read-Only] World pointer assigned on Setup
        """
        ...
    def stop_capturing_final_pixels(self) -> None:
        r"""
        x.stop_capturing_final_pixels() -> None
        Instruct this protocol to stop capturing LDR final pixels
        """
        ...
    def start_capturing_final_pixels(self, stream_id: CapturedPixelsID) -> None:
        r"""
        x.start_capturing_final_pixels(stream_id) -> None
        Instruct this protocol to start capturing LDR final pixels (including slate widgets and burn-ins)
        
        Args:
            stream_id (CapturedPixelsID): The identifier to use for the final pixels buffer
        """
        ...
    def resolve_buffer(self, buffer: Texture, buffer_id: CapturedPixelsID) -> None:
        r"""
        x.resolve_buffer(buffer, buffer_id) -> None
        * Resolve the specified buffer and pass it directly to the specified handler when done (does not pass to any bound streams)
        *
        *
        
        Args:
            buffer (Texture): The desired buffer to save *
            buffer_id (CapturedPixelsID): The ID of this buffer that is passed to the pixel handler (e.g. a composition pass name).
        """
        ...
    def on_warm_up(self) -> None:
        r"""
        x.on_warm_up() -> None
        Called when the capture process is warming up. Protocols may transition from either an initialized, or capturing state to warm-up
        """
        ...
    def on_tick(self) -> None:
        r"""
        x.on_tick() -> None
        Called after the capture process itself is ticked, after the frame is set up for capture, but before most actors have ticked
        """
        ...
    def on_start_capture(self) -> None:
        r"""
        x.on_start_capture() -> None
        Called when this protocol should start capturing frames
        """
        ...
    def on_setup(self) -> bool:
        r"""
        x.on_setup() -> bool
        Called once at the start of the capture process, but before any warmup frames
        
        Returns:
            bool: true if this protocol set up successfully, false otherwise
        """
        ...
    def on_pre_tick(self) -> None:
        r"""
        x.on_pre_tick() -> None
        Called before the capture process itself is ticked, before each frame is set up for capture
        Useful for any pre-frame set up or resetting the previous frame's state
        """
        ...
    def on_pixels_received(self, pixels: CapturedPixels, id: CapturedPixelsID, frame_metrics: FrameMetrics) -> None:
        r"""
        x.on_pixels_received(pixels, id, frame_metrics) -> None
        Called when pixels have been received for the specified stream name
        
        Args:
            pixels (CapturedPixels): 
            id (CapturedPixelsID): 
            frame_metrics (FrameMetrics):
        """
        ...
    def on_pause_capture(self) -> None:
        r"""
        x.on_pause_capture() -> None
        Called when this protocol should temporarily stop capturing frames
        """
        ...
    def on_finalize(self) -> None:
        r"""
        x.on_finalize() -> None
        Called to complete finalization of this protocol
        """
        ...
    def on_capture_frame(self) -> None:
        r"""
        x.on_capture_frame() -> None
        Called when this protocol should capture the current frame
        """
        ...
    def on_can_finalize(self) -> bool:
        r"""
        x.on_can_finalize() -> bool
        Called to check whether this protocol has finished any pending tasks, and can now be shut down
        
        Returns:
            bool:
        """
        ...
    def on_begin_finalize(self) -> None:
        r"""
        x.on_begin_finalize() -> None
        Called when this protocol is going to be shut down - should not capture any more frames
        """
        ...
    def get_current_frame_metrics(self) -> FrameMetrics:
        r"""
        x.get_current_frame_metrics() -> FrameMetrics
        Access this protocol's current frame metrics
        
        Returns:
            FrameMetrics:
        """
        ...
    def generate_filename(self, frame_metrics: FrameMetrics) -> str:
        r"""
        x.generate_filename(frame_metrics) -> str
        Generate a filename for the current frame
        
        Args:
            frame_metrics (FrameMetrics): 
        
        Returns:
            str:
        """
        ...

class UserDefinedImageCaptureProtocol(UserDefinedCaptureProtocol):
    r"""
    A blueprintable capture protocol tailored to capturing and exporting frames as images
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: UserDefinedCaptureProtocol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``compression_quality`` (int32):  [Read-Write] The compression quality for the image type. For EXRs, 0 = Default ZIP compression, 1 = No compression, PNGs and JPEGs expect a value between 0 and 100
    - ``enable_compression`` (bool):  [Read-Write] Whether to save images with compression or not. Not supported for bitmaps.
    - ``format`` (DesiredImageFormat):  [Read-Write] The image format to save as
    - ``world`` (World):  [Read-Write] World pointer assigned on Setup
    """
    @property
    def format(self) -> DesiredImageFormat:
        r"""
        (DesiredImageFormat):  [Read-Write] The image format to save as
        """
        ...
    @format.setter
    def format(self, value: DesiredImageFormat) -> None:
        ...
    @property
    def enable_compression(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to save images with compression or not. Not supported for bitmaps.
        """
        ...
    @enable_compression.setter
    def enable_compression(self, value: bool) -> None:
        ...
    @property
    def compression_quality(self) -> int:
        r"""
        (int32):  [Read-Write] The compression quality for the image type. For EXRs, 0 = Default ZIP compression, 1 = No compression, PNGs and JPEGs expect a value between 0 and 100
        """
        ...
    @compression_quality.setter
    def compression_quality(self, value: int) -> None:
        ...
    def write_image_to_disk(self, pixel_data: CapturedPixels, stream_id: CapturedPixelsID, frame_metrics: FrameMetrics, copy_image_data: bool = False) -> None:
        r"""
        x.write_image_to_disk(pixel_data, stream_id, frame_metrics, copy_image_data=False) -> None
        * Generate a filename for the current frame using this protocol's file name formatter
        *
        *
        
        Args:
            pixel_data (CapturedPixels): 
            stream_id (CapturedPixelsID): 
            frame_metrics (FrameMetrics): 
            copy_image_data (bool):
        """
        ...
    def generate_filename_for_current_frame(self) -> str:
        r"""
        x.generate_filename_for_current_frame() -> str
        * Generate a filename for the current frame using this protocol's file name formatter
        *
        *
        
        Returns:
            str: A fully qualified file name for the current frame number
        """
        ...
    def generate_filename_for_buffer(self, buffer: Texture, stream_id: CapturedPixelsID) -> str:
        r"""
        x.generate_filename_for_buffer(buffer, stream_id) -> str
        * Generate a filename for the specified buffer using this protocol's file name formatter
        *
        *
        
        Args:
            buffer (Texture): The desired buffer to generate a filename for *
            stream_id (CapturedPixelsID): The ID of the stream for this buffer (e.g. a composition pass name) *
        
        Returns:
            str: A fully qualified file name
        """
        ...

class VideoCaptureProtocol(FrameGrabberProtocol):
    r"""
    Video Capture Protocol
    
    **C++ Source:**
    
    - **Module**: MovieSceneCapture
    - **File**: VideoCaptureProtocol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``compression_quality`` (float):  [Read-Write]
    - ``use_compression`` (bool):  [Read-Write]
    """
    ...

class Actor(Object):
    r"""
    Actor is the base class for an Object that can be placed or spawned in a level.
    Actors may contain a collection of ActorComponents, which can be used to control how actors move, how they are rendered, etc.
    The other main function of an Actor is the replication of properties and function calls across the network during play.
    
    
    Actor initialization has multiple steps, here's the order of important virtual functions that get called:
    - UObject::PostLoad: For actors statically placed in a level, the normal UObject PostLoad gets called both in the editor and during gameplay.
                         This is not called for newly spawned actors.
    - UActorComponent::OnComponentCreated: When an actor is spawned in the editor or during gameplay, this gets called for any native components.
                                           For blueprint-created components, this gets called during construction for that component.
                                           This is not called for components loaded from a level.
    - AActor::PreRegisterAllComponents: For statically placed actors and spawned actors that have native root components, this gets called now.
                                        For blueprint actors without a native root component, these registration functions get called later during construction.
    - UActorComponent::RegisterComponent: All components are registered in editor and at runtime, this creates their physical/visual representation.
                                          These calls may be distributed over multiple frames, but are always after PreRegisterAllComponents.
                                          This may also get called later on after an UnregisterComponent call removes it from the world.
    - AActor::PostRegisterAllComponents: Called for all actors both in the editor and in gameplay, this is the last function that is called in all cases.
    - AActor::PostActorCreated: When an actor is created in the editor or during gameplay, this gets called right before construction.
                                This is not called for components loaded from a level.
    - AActor::UserConstructionScript: Called for blueprints that implement a construction script.
    - AActor::OnConstruction: Called at the end of ExecuteConstruction, which calls the blueprint construction script.
                              This is called after all blueprint-created components are fully created and registered.
                              This is only called during gameplay for spawned actors, and may get rerun in the editor when changing blueprints.
    - AActor::PreInitializeComponents: Called before InitializeComponent is called on the actor's components.
                                       This is only called during gameplay and in certain editor preview windows.
    - UActorComponent::Activate: This will be called only if the component has bAutoActivate set.
                                 It will also got called later on if a component is manually activated.
    - UActorComponent::InitializeComponent: This will be called only if the component has bWantsInitializeComponentSet.
                                            This only happens once per gameplay session.
    - AActor::PostInitializeComponents: Called after the actor's components have been initialized, only during gameplay and some editor previews.
    - AActor::BeginPlay: Called when the level starts ticking, only during actual gameplay.
                         This normally happens right after PostInitializeComponents but can be delayed for networked or child actors.
    see: https://docs.unrealengine.com/Programming/UnrealArchitecture/Actors
    see: https://docs.unrealengine.com/Programming/UnrealArchitecture/Actors/ActorLifecycle
    see: UActorComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Actor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def only_relevant_to_owner(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
        """
        ...
    @property
    def always_relevant(self) -> bool:
        r"""
        (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
        """
        ...
    @always_relevant.setter
    def always_relevant(self, value: bool) -> None:
        ...
    @property
    def hidden(self) -> bool:
        r"""
        (bool):  [Read-Only] Allows us to only see this Actor in the Editor, and not in the actual game.
        see: SetActorHiddenInGame()
        """
        ...
    @property
    def net_use_owner_relevancy(self) -> bool:
        r"""
        (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
        """
        ...
    @net_use_owner_relevancy.setter
    def net_use_owner_relevancy(self, value: bool) -> None:
        ...
    @property
    def auto_destroy_when_finished(self) -> bool:
        r"""
        (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
        """
        ...
    @auto_destroy_when_finished.setter
    def auto_destroy_when_finished(self, value: bool) -> None:
        ...
    @property
    def can_be_damaged(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
        see: https://www.unrealengine.com/blog/damage-in-ue4
        see: TakeDamage(), ReceiveDamage()
        """
        ...
    @can_be_damaged.setter
    def can_be_damaged(self, value: bool) -> None:
        ...
    @property
    def find_camera_component_when_view_target(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
        """
        ...
    @find_camera_component_when_view_target.setter
    def find_camera_component_when_view_target(self, value: bool) -> None:
        ...
    @property
    def generate_overlap_events_during_level_streaming(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
        You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
        see: UpdateOverlapsMethodDuringLevelStreaming
        """
        ...
    @generate_overlap_events_during_level_streaming.setter
    def generate_overlap_events_during_level_streaming(self, value: bool) -> None:
        ...
    @property
    def enable_auto_lod_generation(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
        """
        ...
    @enable_auto_lod_generation.setter
    def enable_auto_lod_generation(self, value: bool) -> None:
        ...
    @property
    def replicates(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this actor will replicate to remote machines
        see: SetReplicates()
        """
        ...
    @property
    def replicate_using_registered_sub_object_list(self) -> bool:
        r"""
        (bool):  [Read-Only] When true the replication system will only replicate the registered subobjects and the replicated actor components list
        When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
        """
        ...
    @property
    def initial_life_span(self) -> float:
        r"""
        (float):  [Read-Only] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
        """
        ...
    @property
    def life_span(self) -> float:
        r"""
        deprecated: 'life_span' was renamed to 'initial_life_span'.
        """
        ...
    @property
    def custom_time_dilation(self) -> float:
        r"""
        (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
        """
        ...
    @custom_time_dilation.setter
    def custom_time_dilation(self, value: float) -> None:
        ...
    @property
    def net_dormancy(self) -> NetDormancy:
        r"""
        (NetDormancy):  [Read-Only] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
        """
        ...
    @property
    def spawn_collision_handling_method(self) -> SpawnActorCollisionHandlingMethod:
        r"""
        (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
        """
        ...
    @spawn_collision_handling_method.setter
    def spawn_collision_handling_method(self, value: SpawnActorCollisionHandlingMethod) -> None:
        ...
    @property
    def net_cull_distance_squared(self) -> float:
        r"""
        (float):  [Read-Only] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
        """
        ...
    @property
    def net_update_frequency(self) -> float:
        r"""
        (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
        """
        ...
    @net_update_frequency.setter
    def net_update_frequency(self, value: float) -> None:
        ...
    @property
    def min_net_update_frequency(self) -> float:
        r"""
        (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
        """
        ...
    @min_net_update_frequency.setter
    def min_net_update_frequency(self, value: float) -> None:
        ...
    @property
    def net_priority(self) -> float:
        r"""
        (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
        """
        ...
    @net_priority.setter
    def net_priority(self, value: float) -> None:
        ...
    @property
    def instigator(self) -> Pawn:
        r"""
        (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
        """
        ...
    @instigator.setter
    def instigator(self, value: Pawn) -> None:
        ...
    @property
    def root_component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Only] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
        """
        ...
    @property
    def pivot_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Local space pivot offset for the actor, only used in the editor
        """
        ...
    @property
    def actor_guid(self) -> Guid:
        r"""
        (Guid):  [Read-Only] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
        see: ActorInstanceGuid, FActorInstanceGuidMapper
        note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
        """
        ...
    @property
    def actor_instance_guid(self) -> Guid:
        r"""
        (Guid):  [Read-Only] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
        see: ActorGuid
        note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
        """
        ...
    @property
    def content_bundle_guid(self) -> Guid:
        r"""
        (Guid):  [Read-Only] The GUID for this actor's content bundle.
        """
        ...
    @property
    def sprite_scale(self) -> float:
        r"""
        (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
        """
        ...
    @sprite_scale.setter
    def sprite_scale(self, value: float) -> None:
        ...
    @property
    def tags(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
        """
        ...
    @tags.setter
    def tags(self, value: Array[Name]) -> None:
        ...
    @property
    def on_take_any_damage(self) -> TakeAnyDamageSignature:
        r"""
        (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
        """
        ...
    @on_take_any_damage.setter
    def on_take_any_damage(self, value: TakeAnyDamageSignature) -> None:
        ...
    @property
    def on_take_point_damage(self) -> TakePointDamageSignature:
        r"""
        (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
        """
        ...
    @on_take_point_damage.setter
    def on_take_point_damage(self, value: TakePointDamageSignature) -> None:
        ...
    @property
    def on_take_radial_damage(self) -> TakeRadialDamageSignature:
        r"""
        (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
        """
        ...
    @on_take_radial_damage.setter
    def on_take_radial_damage(self, value: TakeRadialDamageSignature) -> None:
        ...
    @property
    def on_actor_begin_overlap(self) -> ActorBeginOverlapSignature:
        r"""
        (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
        For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
        note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
        """
        ...
    @on_actor_begin_overlap.setter
    def on_actor_begin_overlap(self, value: ActorBeginOverlapSignature) -> None:
        ...
    @property
    def on_actor_touch(self) -> ActorBeginOverlapSignature:
        r"""
        deprecated: 'on_actor_touch' was renamed to 'on_actor_begin_overlap'.
        """
        ...
    @on_actor_touch.setter
    def on_actor_touch(self, value: ActorBeginOverlapSignature) -> None:
        ...
    @property
    def on_actor_end_overlap(self) -> ActorEndOverlapSignature:
        r"""
        (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
        note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
        """
        ...
    @on_actor_end_overlap.setter
    def on_actor_end_overlap(self, value: ActorEndOverlapSignature) -> None:
        ...
    @property
    def on_actor_un_touch(self) -> ActorEndOverlapSignature:
        r"""
        deprecated: 'on_actor_un_touch' was renamed to 'on_actor_end_overlap'.
        """
        ...
    @on_actor_un_touch.setter
    def on_actor_un_touch(self, value: ActorEndOverlapSignature) -> None:
        ...
    @property
    def on_begin_cursor_over(self) -> ActorBeginCursorOverSignature:
        r"""
        (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
        """
        ...
    @on_begin_cursor_over.setter
    def on_begin_cursor_over(self, value: ActorBeginCursorOverSignature) -> None:
        ...
    @property
    def on_end_cursor_over(self) -> ActorEndCursorOverSignature:
        r"""
        (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
        """
        ...
    @on_end_cursor_over.setter
    def on_end_cursor_over(self, value: ActorEndCursorOverSignature) -> None:
        ...
    @property
    def on_clicked(self) -> ActorOnClickedSignature:
        r"""
        (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
        """
        ...
    @on_clicked.setter
    def on_clicked(self, value: ActorOnClickedSignature) -> None:
        ...
    @property
    def on_released(self) -> ActorOnReleasedSignature:
        r"""
        (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
        """
        ...
    @on_released.setter
    def on_released(self, value: ActorOnReleasedSignature) -> None:
        ...
    @property
    def on_input_touch_begin(self) -> ActorOnInputTouchBeginSignature:
        r"""
        (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
        """
        ...
    @on_input_touch_begin.setter
    def on_input_touch_begin(self, value: ActorOnInputTouchBeginSignature) -> None:
        ...
    @property
    def on_input_touch_end(self) -> ActorOnInputTouchEndSignature:
        r"""
        (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
        """
        ...
    @on_input_touch_end.setter
    def on_input_touch_end(self, value: ActorOnInputTouchEndSignature) -> None:
        ...
    @property
    def on_input_touch_enter(self) -> ActorBeginTouchOverSignature:
        r"""
        (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
        """
        ...
    @on_input_touch_enter.setter
    def on_input_touch_enter(self, value: ActorBeginTouchOverSignature) -> None:
        ...
    @property
    def on_input_touch_leave(self) -> ActorEndTouchOverSignature:
        r"""
        (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
        """
        ...
    @on_input_touch_leave.setter
    def on_input_touch_leave(self, value: ActorEndTouchOverSignature) -> None:
        ...
    @property
    def on_actor_hit(self) -> ActorHitSignature:
        r"""
        (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
        For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
        note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
        """
        ...
    @on_actor_hit.setter
    def on_actor_hit(self, value: ActorHitSignature) -> None:
        ...
    @property
    def on_destroyed(self) -> ActorDestroyedSignature:
        r"""
        (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
        """
        ...
    @on_destroyed.setter
    def on_destroyed(self, value: ActorDestroyedSignature) -> None:
        ...
    @property
    def on_end_play(self) -> ActorEndPlaySignature:
        r"""
        (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
        """
        ...
    @on_end_play.setter
    def on_end_play(self, value: ActorEndPlaySignature) -> None:
        ...
    def was_recently_rendered(self, tolerance: float = 0.200000) -> bool:
        r"""
        x.was_recently_rendered(tolerance=0.200000) -> bool
        Returns true if this actor has been rendered "recently", with a tolerance in seconds to define what "recent" means.
        e.g.: If a tolerance of 0.1 is used, this function will return true only if the actor was rendered in the last 0.1 seconds of game time.
        
        Args:
            tolerance (float): How many seconds ago the actor last render time can be and still count as having been "recently" rendered.
        
        Returns:
            bool: Whether this actor was recently rendered.
        """
        ...
    def tear_off(self) -> None:
        r"""
        x.tear_off() -> None
        Networking - Server - TearOff this actor to stop replication to clients. Will set bTearOff to true.
        """
        ...
    def set_tick_group(self, new_tick_group: TickingGroup) -> None:
        r"""
        x.set_tick_group(new_tick_group) -> None
        Sets the ticking group for this actor.
        
        Args:
            new_tick_group (TickingGroup): the new value to assign
        """
        ...
    def set_tickable_when_paused(self, tickable_when_paused: bool) -> None:
        r"""
        x.set_tickable_when_paused(tickable_when_paused) -> None
        Sets whether this actor can tick when paused.
        
        Args:
            tickable_when_paused (bool):
        """
        ...
    def set_replicates(self, replicates: bool) -> None:
        r"""
        x.set_replicates(replicates) -> None
        Set whether this actor replicates to network clients. When this actor is spawned on the server it will be sent to clients as well.
        Properties flagged for replication will update on clients if they change on the server.
        Internally changes the RemoteRole property and handles the cases where the actor needs to be added to the network actor list.
        see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
        
        Args:
            replicates (bool): Whether this Actor replicates to network clients.
        """
        ...
    def set_replicate_movement(self, replicate_movement: bool) -> None:
        r"""
        x.set_replicate_movement(replicate_movement) -> None
        Set whether this actor's movement replicates to network clients.
        
        Args:
            replicate_movement (bool): Whether this Actor's movement replicates to clients.
        """
        ...
    def set_ray_tracing_group_id(self, raytracing_group_id: int) -> None:
        r"""
        x.set_ray_tracing_group_id(raytracing_group_id) -> None
        Specify a RayTracingGroupId for this actors. Components with invalid RayTracingGroupId will inherit the actors.
        
        Args:
            raytracing_group_id (int32):
        """
        ...
    def set_physics_replication_mode(self, replication_mode: PhysicsReplicationMode) -> None:
        r"""
        x.set_physics_replication_mode(replication_mode) -> None
        Set the physics replication mode of this body, via EPhysicsReplicationMode
        
        Args:
            replication_mode (PhysicsReplicationMode):
        """
        ...
    def set_owner(self, new_owner: Actor) -> None:
        r"""
        x.set_owner(new_owner) -> None
        Set the owner of this Actor, used primarily for network replication.
        
        Args:
            new_owner (Actor): The Actor who takes over ownership of this Actor
        """
        ...
    def set_net_dormancy(self, new_dormancy: NetDormancy) -> None:
        r"""
        x.set_net_dormancy(new_dormancy) -> None
        Puts actor in dormant networking state
        
        Args:
            new_dormancy (NetDormancy):
        """
        ...
    def set_life_span(self, lifespan: float) -> None:
        r"""
        x.set_life_span(lifespan) -> None
        Set the lifespan of this actor. When it expires the object will be destroyed. If requested lifespan is 0, the timer is cleared and the actor will not be destroyed.
        
        Args:
            lifespan (float):
        """
        ...
    def set_is_temporarily_hidden_in_editor(self, is_hidden: bool) -> None:
        r"""
        x.set_is_temporarily_hidden_in_editor(is_hidden) -> None
        Explicitly sets whether or not this actor is hidden in the editor for the duration of the current editor session
        
        Args:
            is_hidden (bool): True if the actor is hidden
        """
        ...
    def set_folder_path(self, new_folder_path: Name) -> None:
        r"""
        x.set_folder_path(new_folder_path) -> None
        Assigns a new folder to this actor. Actor folder paths are only available in development builds.
        
        Args:
            new_folder_path (Name): The new folder to assign to the actor.
        """
        ...
    def set_actor_tick_interval(self, tick_interval: float) -> None:
        r"""
        x.set_actor_tick_interval(tick_interval) -> None
        Sets the tick interval of this actor's primary tick function. Will not enable a disabled tick function. Takes effect on next tick.
        
        Args:
            tick_interval (float): The rate at which this actor should be ticking
        """
        ...
    def set_actor_tick_enabled(self, enabled: bool) -> None:
        r"""
        x.set_actor_tick_enabled(enabled) -> None
        Set this actor's tick functions to be enabled or disabled. Only has an effect if the function is registered
        This only modifies the tick function on actor itself
        
        Args:
            enabled (bool): Whether it should be enabled or not
        """
        ...
    def set_tick_enabled(self, enabled: bool) -> None:
        r"""
        deprecated: 'set_tick_enabled' was renamed to 'set_actor_tick_enabled'.
        """
        ...
    def set_actor_scale3d(self, new_scale3d: Vector) -> None:
        r"""
        x.set_actor_scale3d(new_scale3d) -> None
        Set the Actor's world-space scale.
        
        Args:
            new_scale3d (Vector):
        """
        ...
    def set_actor_relative_scale3d(self, new_relative_scale: Vector) -> None:
        r"""
        x.set_actor_relative_scale3d(new_relative_scale) -> None
        Set the actor's RootComponent to the specified relative scale 3d
        
        Args:
            new_relative_scale (Vector): New scale to set the actor's RootComponent to
        """
        ...
    def set_actor_label(self, new_actor_label: str, mark_dirty: bool = True) -> None:
        r"""
        x.set_actor_label(new_actor_label, mark_dirty=True) -> None
        Assigns a new label to this actor.  Actor labels are only available in development builds.
        
        Args:
            new_actor_label (str): The new label string to assign to the actor.  If empty, the actor will have a default label.
            mark_dirty (bool): If true the actor's package will be marked dirty for saving.  Otherwise it will not be.  You should pass false for this parameter if dirtying is not allowed (like during loads)
        """
        ...
    def set_actor_hidden_in_game(self, new_hidden: bool) -> None:
        r"""
        x.set_actor_hidden_in_game(new_hidden) -> None
        Sets the actor to be hidden in the game
        
        Args:
            new_hidden (bool): Whether or not to hide the actor and all its components
        """
        ...
    def set_actor_hidden(self, new_hidden: bool) -> None:
        r"""
        deprecated: 'set_actor_hidden' was renamed to 'set_actor_hidden_in_game'.
        """
        ...
    def set_actor_enable_collision(self, new_actor_enable_collision: bool) -> None:
        r"""
        x.set_actor_enable_collision(new_actor_enable_collision) -> None
        Allows enabling/disabling collision for the whole actor
        
        Args:
            new_actor_enable_collision (bool):
        """
        ...
    def remove_tick_prerequisite_component(self, prerequisite_component: ActorComponent) -> None:
        r"""
        x.remove_tick_prerequisite_component(prerequisite_component) -> None
        Remove tick dependency on PrerequisiteComponent.
        
        Args:
            prerequisite_component (ActorComponent):
        """
        ...
    def remove_tick_prerequisite_actor(self, prerequisite_actor: Actor) -> None:
        r"""
        x.remove_tick_prerequisite_actor(prerequisite_actor) -> None
        Remove tick dependency on PrerequisiteActor.
        
        Args:
            prerequisite_actor (Actor):
        """
        ...
    def receive_tick(self, delta_seconds: float) -> None:
        r"""
        x.receive_tick(delta_seconds) -> None
        Event called every frame, if ticking is enabled
        
        Args:
            delta_seconds (float):
        """
        ...
    def receive_radial_damage(self, damage_received: float, damage_type: DamageType, origin: Vector, hit_info: HitResult, instigated_by: Controller, damage_causer: Actor) -> None:
        r"""
        x.receive_radial_damage(damage_received, damage_type, origin, hit_info, instigated_by, damage_causer) -> None
        Event when this actor takes RADIAL damage
        
        Args:
            damage_received (float): 
            damage_type (DamageType): 
            origin (Vector): 
            hit_info (HitResult): 
            instigated_by (Controller): 
            damage_causer (Actor):
        """
        ...
    def receive_point_damage(self, damage: float, damage_type: DamageType, hit_location: Vector, hit_normal: Vector, hit_component: PrimitiveComponent, bone_name: Name, shot_from_direction: Vector, instigated_by: Controller, damage_causer: Actor, hit_info: HitResult) -> None:
        r"""
        x.receive_point_damage(damage, damage_type, hit_location, hit_normal, hit_component, bone_name, shot_from_direction, instigated_by, damage_causer, hit_info) -> None
        Event when this actor takes POINT damage
        
        Args:
            damage (float): 
            damage_type (DamageType): 
            hit_location (Vector): 
            hit_normal (Vector): 
            hit_component (PrimitiveComponent): 
            bone_name (Name): 
            shot_from_direction (Vector): 
            instigated_by (Controller): 
            damage_causer (Actor): 
            hit_info (HitResult):
        """
        ...
    def receive_hit(self, my_comp: PrimitiveComponent, other: Actor, other_comp: PrimitiveComponent, self_moved: bool, hit_location: Vector, hit_normal: Vector, normal_impulse: Vector, hit: HitResult) -> None:
        r"""
        x.receive_hit(my_comp, other, other_comp, self_moved, hit_location, hit_normal, normal_impulse, hit) -> None
        Event when this actor bumps into a blocking object, or blocks another actor that bumps into it.
        This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
        For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
        note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
        note: When receiving a hit from another object's movement (bSelfMoved is false), the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
        note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
        
        Args:
            my_comp (PrimitiveComponent): 
            other (Actor): 
            other_comp (PrimitiveComponent): 
            self_moved (bool): 
            hit_location (Vector): 
            hit_normal (Vector): 
            normal_impulse (Vector): 
            hit (HitResult):
        """
        ...
    def receive_end_play(self, end_play_reason: EndPlayReason) -> None:
        r"""
        x.receive_end_play(end_play_reason) -> None
        Event to notify blueprints this actor is being deleted or removed from a level.
        
        Args:
            end_play_reason (EndPlayReason):
        """
        ...
    def receive_destroyed(self) -> None:
        r"""
        x.receive_destroyed() -> None
        Called when the actor has been explicitly destroyed.
        """
        ...
    def receive_begin_play(self) -> None:
        r"""
        x.receive_begin_play() -> None
        Event when play begins for this actor.
        """
        ...
    def receive_async_physics_tick(self, delta_seconds: float, sim_seconds: float) -> None:
        r"""
        x.receive_async_physics_tick(delta_seconds, sim_seconds) -> None
        Event called every physics tick if bAsyncPhysicsTickEnabled is true
        
        Args:
            delta_seconds (float): 
            sim_seconds (float):
        """
        ...
    def receive_any_damage(self, damage: float, damage_type: DamageType, instigated_by: Controller, damage_causer: Actor) -> None:
        r"""
        x.receive_any_damage(damage, damage_type, instigated_by, damage_causer) -> None
        Event when this actor takes ANY damage
        
        Args:
            damage (float): 
            damage_type (DamageType): 
            instigated_by (Controller): 
            damage_causer (Actor):
        """
        ...
    def receive_actor_on_released(self, button_released: Key) -> None:
        r"""
        x.receive_actor_on_released(button_released) -> None
        Event when this actor is under the mouse when left mouse button is released while using the clickable interface.
        
        Args:
            button_released (Key):
        """
        ...
    def receive_actor_on_input_touch_leave(self, finger_index: TouchIndex) -> None:
        r"""
        x.receive_actor_on_input_touch_leave(finger_index) -> None
        Event when this actor has a finger moved off of it with the clickable interface.
        
        Args:
            finger_index (TouchIndex):
        """
        ...
    def receive_actor_on_input_touch_enter(self, finger_index: TouchIndex) -> None:
        r"""
        x.receive_actor_on_input_touch_enter(finger_index) -> None
        Event when this actor has a finger moved over it with the clickable interface.
        
        Args:
            finger_index (TouchIndex):
        """
        ...
    def receive_actor_on_input_touch_end(self, finger_index: TouchIndex) -> None:
        r"""
        x.receive_actor_on_input_touch_end(finger_index) -> None
        Event when this actor is under the finger when untouched when click events are enabled.
        
        Args:
            finger_index (TouchIndex):
        """
        ...
    def receive_actor_on_input_touch_begin(self, finger_index: TouchIndex) -> None:
        r"""
        x.receive_actor_on_input_touch_begin(finger_index) -> None
        Event when this actor is touched when click events are enabled.
        
        Args:
            finger_index (TouchIndex):
        """
        ...
    def receive_actor_on_clicked(self, button_pressed: Key) -> None:
        r"""
        x.receive_actor_on_clicked(button_pressed) -> None
        Event when this actor is clicked by the mouse when using the clickable interface.
        
        Args:
            button_pressed (Key):
        """
        ...
    def receive_actor_end_overlap(self, other_actor: Actor) -> None:
        r"""
        x.receive_actor_end_overlap(other_actor) -> None
        Event when an actor no longer overlaps another actor, and they have separated.
        note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
        
        Args:
            other_actor (Actor):
        """
        ...
    def receive_actor_untouch(self, other_actor: Actor) -> None:
        r"""
        deprecated: 'receive_actor_untouch' was renamed to 'receive_actor_end_overlap'.
        """
        ...
    def receive_actor_end_cursor_over(self) -> None:
        r"""
        x.receive_actor_end_cursor_over() -> None
        Event when this actor has the mouse moved off of it with the clickable interface.
        """
        ...
    def receive_actor_begin_overlap(self, other_actor: Actor) -> None:
        r"""
        x.receive_actor_begin_overlap(other_actor) -> None
        Event when this actor overlaps another actor, for example a player walking into a trigger.
        For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
        note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
        
        Args:
            other_actor (Actor):
        """
        ...
    def receive_actor_touch(self, other_actor: Actor) -> None:
        r"""
        deprecated: 'receive_actor_touch' was renamed to 'receive_actor_begin_overlap'.
        """
        ...
    def receive_actor_begin_cursor_over(self) -> None:
        r"""
        x.receive_actor_begin_cursor_over() -> None
        Event when this actor has the mouse moved over it with the clickable interface.
        """
        ...
    def prestream_textures(self, seconds: float, enable_streaming: bool, cinematic_texture_groups: int = 0) -> None:
        r"""
        x.prestream_textures(seconds, enable_streaming, cinematic_texture_groups=0) -> None
        Calls PrestreamTextures() for all the actor's meshcomponents.
        
        Args:
            seconds (float): Number of seconds to force all mip-levels to be resident
            enable_streaming (bool): Whether to start (true) or stop (false) streaming
            cinematic_texture_groups (int32): Bitfield indicating which texture groups that use extra high-resolution mips
        """
        ...
    def make_noise(self, loudness: float = 1.000000, noise_instigator: Pawn = None, noise_location: Vector = [0.000000, 0.000000, 0.000000], max_range: float = 0.000000, tag: Name = "None") -> None:
        r"""
        x.make_noise(loudness=1.000000, noise_instigator=None, noise_location=[0.000000, 0.000000, 0.000000], max_range=0.000000, tag="None") -> None
        Trigger a noise caused by a given Pawn, at a given location.
        Note that the NoiseInstigator Pawn MUST have a PawnNoiseEmitterComponent for the noise to be detected by a PawnSensingComponent.
        Senders of MakeNoise should have an Instigator if they are not pawns, or pass a NoiseInstigator.
        
        Args:
            loudness (float): The relative loudness of this noise. Usual range is 0 (no noise) to 1 (full volume). If MaxRange is used, this scales the max range, otherwise it affects the hearing range specified by the sensor.
            noise_instigator (Pawn): Pawn responsible for this noise.  Uses the actor's Instigator if NoiseInstigator is null
            noise_location (Vector): Position of noise source.  If zero vector, use the actor's location.
            max_range (float): Max range at which the sound may be heard. A value of 0 indicates no max range (though perception may have its own range). Loudness scales the range. (Note: not supported for legacy PawnSensingComponent, only for AIPerception)
            tag (Name): Identifier for the noise.
        """
        ...
    def teleport(self, dest_location: Vector, dest_rotation: Rotator) -> bool:
        r"""
        x.teleport(dest_location, dest_rotation) -> bool
        Teleport this actor to a new location. If the actor doesn't fit exactly at the location specified, tries to slightly move it out of walls and such.
        
        Args:
            dest_location (Vector): The target destination point
            dest_rotation (Rotator): The target rotation at the destination
        
        Returns:
            bool: true if the actor has been successfully moved, or false if it couldn't fit.
        """
        ...
    def set_actor_transform(self, new_transform: Transform, sweep: bool, teleport: bool) -> Optional[HitResult]:
        r"""
        x.set_actor_transform(new_transform, sweep, teleport) -> HitResult or None
        Set the Actors transform to the specified one.
        
        Args:
            new_transform (Transform): The new transform.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the transform without teleporting will not update the transform of simulated child/attached components.
        
        Returns:
            HitResult or None: 
        
            sweep_hit_result (HitResult):
        """
        ...
    def set_actor_rotation(self, new_rotation: Rotator, teleport_physics: bool) -> bool:
        r"""
        x.set_actor_rotation(new_rotation, teleport_physics) -> bool
        Set the Actor's rotation instantly to the specified rotation.
        
        Args:
            new_rotation (Rotator): The new rotation for the Actor.
            teleport_physics (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the rotation without teleporting will not update the rotation of simulated child/attached components.
        
        Returns:
            bool: Whether the rotation was successfully set.
        """
        ...
    def set_actor_relative_transform(self, new_relative_transform: Transform, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.set_actor_relative_transform(new_relative_transform, sweep, teleport) -> HitResult
        Set the actor's RootComponent to the specified relative transform
        
        Args:
            new_relative_transform (Transform): New relative transform of the actor's root component
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the transform without teleporting will not update the transform of simulated child/attached components.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult):
        """
        ...
    def set_actor_relative_rotation(self, new_relative_rotation: Rotator, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.set_actor_relative_rotation(new_relative_rotation, sweep, teleport) -> HitResult
        Set the actor's RootComponent to the specified relative rotation
        
        Args:
            new_relative_rotation (Rotator): New relative rotation of the actor's root component
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the rotation without teleporting will not update the rotation of simulated child/attached components.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult):
        """
        ...
    def set_actor_relative_location(self, new_relative_location: Vector, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.set_actor_relative_location(new_relative_location, sweep, teleport) -> HitResult
        Set the actor's RootComponent to the specified relative location.
        
        Args:
            new_relative_location (Vector): New relative location of the actor's root component
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult):
        """
        ...
    def set_actor_location_and_rotation(self, new_location: Vector, new_rotation: Rotator, sweep: bool, teleport: bool) -> Optional[HitResult]:
        r"""
        x.set_actor_location_and_rotation(new_location, new_rotation, sweep, teleport) -> HitResult or None
        Move the actor instantly to the specified location and rotation.
        
        Args:
            new_location (Vector): The new location to teleport the Actor to.
            new_rotation (Rotator): The new rotation for the Actor.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components.
        
        Returns:
            HitResult or None: Whether the rotation was successfully set.
        
            sweep_hit_result (HitResult): The hit result from the move if swept.
        """
        ...
    def set_actor_location(self, new_location: Vector, sweep: bool, teleport: bool) -> Optional[HitResult]:
        r"""
        x.set_actor_location(new_location, sweep, teleport) -> HitResult or None
        Move the Actor to the specified location.
        
        Args:
            new_location (Vector): The new location to move the Actor to.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components.
        
        Returns:
            HitResult or None: Whether the location was successfully set (if not swept), or whether movement occurred at all (if swept).
        
            sweep_hit_result (HitResult): The hit result from the move if swept.
        """
        ...
    def on_reset(self) -> None:
        r"""
        x.on_reset() -> None
        Event called when this Actor is reset to its initial state - used when restarting level without reloading.
        """
        ...
    def on_end_view_target(self, pc: PlayerController) -> None:
        r"""
        x.on_end_view_target(pc) -> None
        Event called when this Actor is no longer the view target for the given PlayerController.
        
        Args:
            pc (PlayerController):
        """
        ...
    def on_become_view_target(self, pc: PlayerController) -> None:
        r"""
        x.on_become_view_target(pc) -> None
        Event called when this Actor becomes the view target for the given PlayerController.
        
        Args:
            pc (PlayerController):
        """
        ...
    def get_components_by_class(self, component_class: Class = None) -> Array[ActorComponent]:
        r"""
        x.get_components_by_class(component_class=None) -> Array[ActorComponent]
        Gets all the components that inherit from the given class.
        Currently returns an array of UActorComponent which must be cast to the correct type.
        This intended to only be used by blueprints. Use GetComponents() in C++.
        
        Args:
            component_class (type(Class)): 
        
        Returns:
            Array[ActorComponent]:
        """
        ...
    def get_actor_rotation(self) -> Rotator:
        r"""
        x.get_actor_rotation() -> Rotator
        Returns rotation of the RootComponent of this Actor.
        
        Returns:
            Rotator:
        """
        ...
    def get_actor_location(self) -> Vector:
        r"""
        x.get_actor_location() -> Vector
        Returns the location of the RootComponent of this Actor
        
        Returns:
            Vector:
        """
        ...
    def detach_from_actor(self, location_rule: DetachmentRule = DetachmentRule.KEEP_RELATIVE, rotation_rule: DetachmentRule = DetachmentRule.KEEP_RELATIVE, scale_rule: DetachmentRule = DetachmentRule.KEEP_RELATIVE) -> None:
        r"""
        x.detach_from_actor(location_rule=DetachmentRule.KEEP_RELATIVE, rotation_rule=DetachmentRule.KEEP_RELATIVE, scale_rule=DetachmentRule.KEEP_RELATIVE) -> None
        Detaches the RootComponent of this Actor from any SceneComponent it is currently attached to.
        
        Args:
            location_rule (DetachmentRule): How to handle translation when detaching.
            rotation_rule (DetachmentRule): How to handle rotation when detaching.
            scale_rule (DetachmentRule): How to handle scale when detaching.
        """
        ...
    def destroy_actor(self) -> None:
        r"""
        x.destroy_actor() -> None
        Destroy the actor
        """
        ...
    def attach_to_component(self, parent: SceneComponent, socket_name: Name, location_rule: AttachmentRule, rotation_rule: AttachmentRule, scale_rule: AttachmentRule, weld_simulated_bodies: bool = True) -> bool:
        r"""
        x.attach_to_component(parent, socket_name, location_rule, rotation_rule, scale_rule, weld_simulated_bodies=True) -> bool
        Attaches the RootComponent of this Actor to the supplied component, optionally at a named socket. It is not valid to call this on components that are not Registered.
        
        Args:
            parent (SceneComponent): Parent to attach to.
            socket_name (Name): Optional socket to attach to on the parent.
            location_rule (AttachmentRule): How to handle translation when attaching.
            rotation_rule (AttachmentRule): How to handle rotation when attaching.
            scale_rule (AttachmentRule): How to handle scale when attaching.
            weld_simulated_bodies (bool): Whether to weld together simulated physics bodies. This transfers the shapes in the welded object into the parent (if simulated), which can result in permanent changes that persist even after subsequently detaching.
        
        Returns:
            bool: Whether the attachment was successful or not
        """
        ...
    def attach_to_actor(self, parent_actor: Actor, socket_name: Name, location_rule: AttachmentRule, rotation_rule: AttachmentRule, scale_rule: AttachmentRule, weld_simulated_bodies: bool = True) -> bool:
        r"""
        x.attach_to_actor(parent_actor, socket_name, location_rule, rotation_rule, scale_rule, weld_simulated_bodies=True) -> bool
        Attaches the RootComponent of this Actor to the supplied actor, optionally at a named socket.
        
        Args:
            parent_actor (Actor): Actor to attach this actor's RootComponent to
            socket_name (Name): Socket name to attach to, if any
            location_rule (AttachmentRule): How to handle translation when attaching.
            rotation_rule (AttachmentRule): How to handle rotation when attaching.
            scale_rule (AttachmentRule): How to handle scale when attaching.
            weld_simulated_bodies (bool): Whether to weld together simulated physics bodies.This transfers the shapes in the welded object into the parent (if simulated), which can result in permanent changes that persist even after subsequently detaching.
        
        Returns:
            bool: Whether the attachment was successful or not
        """
        ...
    def add_actor_world_transform_keep_scale(self, delta_transform: Transform, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_actor_world_transform_keep_scale(delta_transform, sweep, teleport) -> HitResult
        Adds a delta to the transform of this actor in world space. Scale is unchanged.
        
        Args:
            delta_transform (Transform): 
            sweep (bool): 
            teleport (bool): 
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult):
        """
        ...
    def add_actor_world_transform(self, delta_transform: Transform, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_actor_world_transform(delta_transform, sweep, teleport) -> HitResult
        Adds a delta to the transform of this actor in world space. Ignores scale and sets it to (1,1,1).
        
        Args:
            delta_transform (Transform): 
            sweep (bool): 
            teleport (bool): 
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult):
        """
        ...
    def add_actor_world_rotation(self, delta_rotation: Rotator, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_actor_world_rotation(delta_rotation, sweep, teleport) -> HitResult
        Adds a delta to the rotation of this actor in world space.
        
        Args:
            delta_rotation (Rotator): The change in rotation.
            sweep (bool): Whether to sweep to the target rotation (not currently supported for rotation).
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the rotation without teleporting will not update the rotation of simulated child/attached components.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): The hit result from the move if swept.
        """
        ...
    def add_actor_world_offset(self, delta_location: Vector, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_actor_world_offset(delta_location, sweep, teleport) -> HitResult
        Adds a delta to the location of this actor in world space.
        
        Args:
            delta_location (Vector): The change in location.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): The hit result from the move if swept.
        """
        ...
    def add_actor_local_transform(self, new_transform: Transform, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_actor_local_transform(new_transform, sweep, teleport) -> HitResult
        Adds a delta to the transform of this component in its local reference frame
        
        Args:
            new_transform (Transform): The change in transform in local space.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the transform without teleporting will not update the transform of simulated child/attached components.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult):
        """
        ...
    def add_actor_local_rotation(self, delta_rotation: Rotator, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_actor_local_rotation(delta_rotation, sweep, teleport) -> HitResult
        Adds a delta to the rotation of this component in its local reference frame
        
        Args:
            delta_rotation (Rotator): The change in rotation in local space.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the rotation without teleporting will not update the rotation of simulated child/attached components.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult):
        """
        ...
    def add_actor_local_offset(self, delta_location: Vector, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_actor_local_offset(delta_location, sweep, teleport) -> HitResult
        Adds a delta to the location of this component in its local reference frame.
        
        Args:
            delta_location (Vector): 
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult):
        """
        ...
    def is_temporarily_hidden_in_editor(self, include_parent: bool = False) -> bool:
        r"""
        x.is_temporarily_hidden_in_editor(include_parent=False) -> bool
        Returns whether or not this actor was explicitly hidden in the editor for the duration of the current editor session
        
        Args:
            include_parent (bool): Whether to recurse up child actor hierarchy or not
        
        Returns:
            bool:
        """
        ...
    def is_selectable(self) -> bool:
        r"""
        x.is_selectable() -> bool
        Returns true if this actor can EVER be selected in a level in the editor.  Can be overridden by specific actors to make them unselectable.
        
        Returns:
            bool:
        """
        ...
    def is_overlapping_actor(self, other: Actor) -> bool:
        r"""
        x.is_overlapping_actor(other) -> bool
        Check whether any component of this Actor is overlapping any component of another Actor.
        
        Args:
            other (Actor): The other Actor to test against
        
        Returns:
            bool: Whether any component of this Actor is overlapping any component of another Actor.
        """
        ...
    def is_hidden_ed_at_startup(self) -> bool:
        r"""
        x.is_hidden_ed_at_startup() -> bool
        Returns true if the actor is hidden upon editor startup/by default, false if it is not
        
        Returns:
            bool:
        """
        ...
    def is_hidden_ed(self) -> bool:
        r"""
        x.is_hidden_ed() -> bool
        Returns true if this actor is hidden in the editor viewports, also checking temporary flags.
        
        Returns:
            bool:
        """
        ...
    def is_editable(self) -> bool:
        r"""
        x.is_editable() -> bool
        Returns true if this actor is allowed to be displayed, selected and manipulated by the editor.
        
        Returns:
            bool:
        """
        ...
    def is_child_actor(self) -> bool:
        r"""
        x.is_child_actor() -> bool
        Returns whether this Actor was spawned by a child actor component
        
        Returns:
            bool:
        """
        ...
    def is_actor_tick_enabled(self) -> bool:
        r"""
        x.is_actor_tick_enabled() -> bool
        Returns whether this actor has tick enabled or not
        
        Returns:
            bool:
        """
        ...
    def is_actor_being_destroyed(self) -> bool:
        r"""
        x.is_actor_being_destroyed() -> bool
        Returns true if this actor is currently being destroyed, some gameplay events may be unsafe
        
        Returns:
            bool:
        """
        ...
    def has_authority(self) -> bool:
        r"""
        x.has_authority() -> bool
        Returns whether this actor has network authority
        
        Returns:
            bool:
        """
        ...
    def get_vertical_distance_to(self, other_actor: Actor) -> float:
        r"""
        x.get_vertical_distance_to(other_actor) -> float
        Returns the distance from this Actor to OtherActor, ignoring XY.
        
        Args:
            other_actor (Actor): 
        
        Returns:
            float:
        """
        ...
    def get_velocity(self) -> Vector:
        r"""
        x.get_velocity() -> Vector
        Returns velocity (in cm/s (Unreal Units/second) of the rootcomponent if it is either using physics or has an associated MovementComponent
        
        Returns:
            Vector:
        """
        ...
    def get_actor_transform(self) -> Transform:
        r"""
        x.get_actor_transform() -> Transform
        Get the actor-to-world transform.
        
        Returns:
            Transform: The transform that transforms from actor space to world space.
        """
        ...
    def get_tickable_when_paused(self) -> bool:
        r"""
        x.get_tickable_when_paused() -> bool
        Gets whether this actor can tick when paused.
        
        Returns:
            bool:
        """
        ...
    def get_squared_horizontal_distance_to(self, other_actor: Actor) -> float:
        r"""
        x.get_squared_horizontal_distance_to(other_actor) -> float
        Returns the squared distance from this Actor to OtherActor, ignoring Z.
        
        Args:
            other_actor (Actor): 
        
        Returns:
            float:
        """
        ...
    def get_squared_distance_to(self, other_actor: Actor) -> float:
        r"""
        x.get_squared_distance_to(other_actor) -> float
        Returns the squared distance from this Actor to OtherActor.
        
        Args:
            other_actor (Actor): 
        
        Returns:
            float:
        """
        ...
    def get_resimulation_threshold(self) -> float:
        r"""
        x.get_resimulation_threshold() -> float
        Get the error threshold in centimeters before this object should enforce a resimulation to trigger.
        
        Returns:
            float:
        """
        ...
    def get_remote_role(self) -> NetRole:
        r"""
        x.get_remote_role() -> NetRole
        Returns how much control the remote machine has over this actor.
        
        Returns:
            NetRole:
        """
        ...
    def get_ray_tracing_group_id(self) -> int:
        r"""
        x.get_ray_tracing_group_id() -> int32
        Return the RayTracingGroupId for this actor.
        
        Returns:
            int32:
        """
        ...
    def get_physics_replication_mode(self) -> PhysicsReplicationMode:
        r"""
        x.get_physics_replication_mode() -> PhysicsReplicationMode
        Get the physics replication mode of this body, via EPhysicsReplicationMode
        
        Returns:
            PhysicsReplicationMode:
        """
        ...
    def get_parent_component(self) -> ChildActorComponent:
        r"""
        x.get_parent_component() -> ChildActorComponent
        If this Actor was created by a Child Actor Component returns that Child Actor Component
        
        Returns:
            ChildActorComponent:
        """
        ...
    def get_parent_actor(self) -> Actor:
        r"""
        x.get_parent_actor() -> Actor
        If this Actor was created by a Child Actor Component returns the Actor that owns that Child Actor Component
        
        Returns:
            Actor:
        """
        ...
    def get_owner(self) -> Actor:
        r"""
        x.get_owner() -> Actor
        Get the owner of this Actor, used primarily for network replication.
        
        Returns:
            Actor:
        """
        ...
    def get_overlapping_components(self) -> Array[PrimitiveComponent]:
        r"""
        x.get_overlapping_components() -> Array[PrimitiveComponent]
        Returns list of components this actor is overlapping.
        
        Returns:
            Array[PrimitiveComponent]: 
        
            overlapping_components (Array[PrimitiveComponent]):
        """
        ...
    def get_touching_components(self) -> Array[PrimitiveComponent]:
        r"""
        deprecated: 'get_touching_components' was renamed to 'get_overlapping_components'.
        """
        ...
    def get_overlapping_actors(self, class_filter: Class = None) -> Array[Actor]:
        r"""
        x.get_overlapping_actors(class_filter=None) -> Array[Actor]
        Returns list of actors this actor is overlapping (any component overlapping any component). Does not return itself.
        
        Args:
            class_filter (type(Class)): [optional] If set, only returns actors of this class or subclasses
        
        Returns:
            Array[Actor]: 
        
            overlapping_actors (Array[Actor]): [out] Returned list of overlapping actors
        """
        ...
    def get_touching_actors(self, class_filter: Class = None) -> Array[Actor]:
        r"""
        deprecated: 'get_touching_actors' was renamed to 'get_overlapping_actors'.
        """
        ...
    def get_local_role(self) -> NetRole:
        r"""
        x.get_local_role() -> NetRole
        Returns how much control the local machine has over this actor.
        
        Returns:
            NetRole:
        """
        ...
    def get_life_span(self) -> float:
        r"""
        x.get_life_span() -> float
        Get the remaining lifespan of this actor. If zero is returned the actor lives forever.
        
        Returns:
            float:
        """
        ...
    def get_level_transform(self) -> Transform:
        r"""
        x.get_level_transform() -> Transform
        Return the FTransform of the level this actor is a part of.
        
        Returns:
            Transform:
        """
        ...
    def get_level(self) -> Level:
        r"""
        x.get_level() -> Level
        Return the ULevel that this Actor is part of.
        
        Returns:
            Level:
        """
        ...
    def get_instigator_controller(self) -> Controller:
        r"""
        x.get_instigator_controller() -> Controller
        Returns the instigator's controller for this actor, or nullptr if there is none.
        
        Returns:
            Controller:
        """
        ...
    def get_instigator(self) -> Pawn:
        r"""
        x.get_instigator() -> Pawn
        Returns the instigator for this actor, or nullptr if there is none.
        
        Returns:
            Pawn:
        """
        ...
    def get_horizontal_dot_product_to(self, other_actor: Actor) -> float:
        r"""
        x.get_horizontal_dot_product_to(other_actor) -> float
        Returns the dot product from this Actor to OtherActor, ignoring Z. Returns -2.0 on failure. Returns 0.0 for coincidental actors.
        
        Args:
            other_actor (Actor): 
        
        Returns:
            float:
        """
        ...
    def get_horizontal_distance_to(self, other_actor: Actor) -> float:
        r"""
        x.get_horizontal_distance_to(other_actor) -> float
        Returns the distance from this Actor to OtherActor, ignoring Z.
        
        Args:
            other_actor (Actor): 
        
        Returns:
            float:
        """
        ...
    def get_game_time_since_creation(self) -> float:
        r"""
        x.get_game_time_since_creation() -> float
        The number of seconds (in game time) since this Actor was created, relative to Get Game Time In Seconds.
        
        Returns:
            float:
        """
        ...
    def get_folder_path(self) -> Name:
        r"""
        x.get_folder_path() -> Name
        Returns this actor's folder path. Actor folder paths are only available in development builds.
        
        Returns:
            Name:
        """
        ...
    def get_dot_product_to(self, other_actor: Actor) -> float:
        r"""
        x.get_dot_product_to(other_actor) -> float
        Returns the dot product from this Actor to OtherActor. Returns -2.0 on failure. Returns 0.0 for coincidental actors.
        
        Args:
            other_actor (Actor): 
        
        Returns:
            float:
        """
        ...
    def get_distance_to(self, other_actor: Actor) -> float:
        r"""
        x.get_distance_to(other_actor) -> float
        Returns the distance from this Actor to OtherActor.
        
        Args:
            other_actor (Actor): 
        
        Returns:
            float:
        """
        ...
    def get_default_actor_label(self) -> str:
        r"""
        x.get_default_actor_label() -> str
        Returns this actor's default label (does not include any numeric suffix).  Actor labels are only available in development builds.
        
        Returns:
            str:
        """
        ...
    def get_components_by_tag(self, component_class: Class = None, tag: Name = ...) -> Array[ActorComponent]:
        r"""
        x.get_components_by_tag(component_class=None, tag) -> Array[ActorComponent]
        Gets all the components that inherit from the given class with a given tag.
        
        Args:
            component_class (type(Class)): 
            tag (Name): 
        
        Returns:
            Array[ActorComponent]:
        """
        ...
    def get_components_by_interface(self, interface: Class) -> Array[ActorComponent]:
        r"""
        x.get_components_by_interface(interface) -> Array[ActorComponent]
        Gets all the components that implements the given interface.
        
        Args:
            interface (type(Class)): 
        
        Returns:
            Array[ActorComponent]:
        """
        ...
    def get_component_by_class(self, component_class: Class = None) -> ActorComponent:
        r"""
        x.get_component_by_class(component_class=None) -> ActorComponent
        Searches components array and returns first encountered component of the specified class
        
        Args:
            component_class (type(Class)): 
        
        Returns:
            ActorComponent:
        """
        ...
    def get_attach_parent_socket_name(self) -> Name:
        r"""
        x.get_attach_parent_socket_name() -> Name
        Walk up the attachment chain from RootComponent until we encounter a different actor, and return the socket name in the component. If we are not attached to a component in a different actor, returns NAME_None
        
        Returns:
            Name:
        """
        ...
    def get_attach_parent_actor(self) -> Actor:
        r"""
        x.get_attach_parent_actor() -> Actor
        Walk up the attachment chain from RootComponent until we encounter a different actor, and return it. If we are not attached to a component in a different actor, returns nullptr
        
        Returns:
            Actor:
        """
        ...
    def get_attached_actors(self, reset_array: bool = True, recursively_include_attached_actors: bool = False) -> Array[Actor]:
        r"""
        x.get_attached_actors(reset_array=True, recursively_include_attached_actors=False) -> Array[Actor]
        Find all Actors which are attached directly to a component in this actor
        
        Args:
            reset_array (bool): 
            recursively_include_attached_actors (bool): 
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]):
        """
        ...
    def get_all_child_actors(self, include_descendants: bool = True) -> Array[Actor]:
        r"""
        x.get_all_child_actors(include_descendants=True) -> Array[Actor]
        Returns a list of all actors spawned by our Child Actor Components, including children of children.
        This does not return the contents of the Children array
        
        Args:
            include_descendants (bool): 
        
        Returns:
            Array[Actor]: 
        
            child_actors (Array[Actor]):
        """
        ...
    def get_actor_up_vector(self) -> Vector:
        r"""
        x.get_actor_up_vector() -> Vector
        Get the up (Z) vector (length 1.0) from this Actor, in world space.
        
        Returns:
            Vector:
        """
        ...
    def get_actor_time_dilation(self) -> float:
        r"""
        x.get_actor_time_dilation() -> float
        Get ActorTimeDilation - this can be used for input control or speed control for slomo.
        We don't want to scale input globally because input can be used for UI, which do not care for TimeDilation.
        
        Returns:
            float:
        """
        ...
    def get_actor_tick_interval(self) -> float:
        r"""
        x.get_actor_tick_interval() -> float
        Returns the tick interval of this actor's primary tick function
        
        Returns:
            float:
        """
        ...
    def get_actor_scale3d(self) -> Vector:
        r"""
        x.get_actor_scale3d() -> Vector
        Returns the Actor's world-space scale.
        
        Returns:
            Vector:
        """
        ...
    def get_actor_right_vector(self) -> Vector:
        r"""
        x.get_actor_right_vector() -> Vector
        Get the right (Y) vector (length 1.0) from this Actor, in world space.
        
        Returns:
            Vector:
        """
        ...
    def get_actor_relative_scale3d(self) -> Vector:
        r"""
        x.get_actor_relative_scale3d() -> Vector
        Return the actor's relative scale 3d
        
        Returns:
            Vector:
        """
        ...
    def get_actor_label(self, create_if_none: bool = True) -> str:
        r"""
        x.get_actor_label(create_if_none=True) -> str
        Returns this actor's current label.  Actor labels are only available in development builds.
        
        Args:
            create_if_none (bool): 
        
        Returns:
            str:
        """
        ...
    def get_actor_forward_vector(self) -> Vector:
        r"""
        x.get_actor_forward_vector() -> Vector
        Get the forward (X) vector (length 1.0) from this Actor, in world space.
        
        Returns:
            Vector:
        """
        ...
    def get_actor_eyes_view_point(self) -> Tuple[Vector, Rotator]:
        r"""
        x.get_actor_eyes_view_point() -> (out_location=Vector, out_rotation=Rotator)
        Returns the point of view of the actor.
        Note that this doesn't mean the camera, but the 'eyes' of the actor.
        For example, for a Pawn, this would define the eye height location,
        and view rotation (which is different from the pawn rotation which has a zeroed pitch component).
        A camera first person view will typically use this view point. Most traces (weapon, AI) will be done from this view point.
        
        Returns:
            tuple: 
        
            out_location (Vector): location of view point
        
            out_rotation (Rotator): view rotation of actor.
        """
        ...
    def get_actor_enable_collision(self) -> bool:
        r"""
        x.get_actor_enable_collision() -> bool
        Get current state of collision for the whole actor
        
        Returns:
            bool:
        """
        ...
    def get_actor_bounds(self, only_colliding_components: bool, include_from_child_actors: bool = False) -> Tuple[Vector, Vector]:
        r"""
        x.get_actor_bounds(only_colliding_components, include_from_child_actors=False) -> (origin=Vector, box_extent=Vector)
        Returns the bounding box of all components that make up this Actor (excluding ChildActorComponents).
        
        Args:
            only_colliding_components (bool): If true, will only return the bounding box for components with collision enabled.
            include_from_child_actors (bool): If true then recurse in to ChildActor components
        
        Returns:
            tuple: 
        
            origin (Vector): Set to the center of the actor in world space
        
            box_extent (Vector): Set to half the actor's size in 3d space
        """
        ...
    def force_net_update(self) -> None:
        r"""
        x.force_net_update() -> None
        Force actor to be updated to clients/demo net drivers
        """
        ...
    def flush_net_dormancy(self) -> None:
        r"""
        x.flush_net_dormancy() -> None
        Forces dormant actor to replicate but doesn't change NetDormancy state (i.e., they will go dormant again if left dormant)
        """
        ...
    def find_component_by_tag(self, component_class: Class = None, tag: Name = ...) -> ActorComponent:
        r"""
        x.find_component_by_tag(component_class=None, tag) -> ActorComponent
        Searches components array and returns first encountered component with a given tag.
        
        Args:
            component_class (type(Class)): 
            tag (Name): 
        
        Returns:
            ActorComponent:
        """
        ...
    def enable_input(self, player_controller: PlayerController) -> None:
        r"""
        x.enable_input(player_controller) -> None
        Pushes this actor on to the stack of input being handled by a PlayerController.
        
        Args:
            player_controller (PlayerController): The PlayerController whose input events we want to receive.
        """
        ...
    def disable_input(self, player_controller: PlayerController) -> None:
        r"""
        x.disable_input(player_controller) -> None
        Removes this actor from the stack of input being handled by a PlayerController.
        
        Args:
            player_controller (PlayerController): The PlayerController whose input events we no longer want to receive. If null, this actor will stop receiving input from all PlayerControllers.
        """
        ...
    def create_input_component(self, input_component_to_create: Class) -> None:
        r"""
        x.create_input_component(input_component_to_create) -> None
        Creates an input component from the input component passed in
        
        Args:
            input_component_to_create (type(Class)): The UInputComponent to create.
        """
        ...
    def can_trigger_resimulation(self) -> bool:
        r"""
        x.can_trigger_resimulation() -> bool
        Can this body trigger a resimulation when Physics Prediction is enabled
        
        Returns:
            bool:
        """
        ...
    def add_tick_prerequisite_component(self, prerequisite_component: ActorComponent) -> None:
        r"""
        x.add_tick_prerequisite_component(prerequisite_component) -> None
        Make this actor tick after PrerequisiteComponent. This only applies to this actor's tick function; dependencies for owned components must be set up separately if desired.
        
        Args:
            prerequisite_component (ActorComponent):
        """
        ...
    def add_tick_prerequisite_actor(self, prerequisite_actor: Actor) -> None:
        r"""
        x.add_tick_prerequisite_actor(prerequisite_actor) -> None
        Make this actor tick after PrerequisiteActor. This only applies to this actor's tick function; dependencies for owned components must be set up separately if desired.
        
        Args:
            prerequisite_actor (Actor):
        """
        ...
    def set_tick_prerequisite(self, prerequisite_actor: Actor) -> None:
        r"""
        deprecated: 'set_tick_prerequisite' was renamed to 'add_tick_prerequisite_actor'.
        """
        ...
    def actor_has_tag(self, tag: Name) -> bool:
        r"""
        x.actor_has_tag(tag) -> bool
        See if this actor's Tags array contains the supplied name tag
        
        Args:
            tag (Name): 
        
        Returns:
            bool:
        """
        ...
    def has_tag(self, tag: Name) -> bool:
        r"""
        deprecated: 'has_tag' was renamed to 'actor_has_tag'.
        """
        ...
    def acquire_editor_element_handle(self, allow_create: bool = True) -> ScriptTypedElementHandle:
        r"""
        x.acquire_editor_element_handle(allow_create=True) -> ScriptTypedElementHandle
        K2 Acquire Editor Actor Element Handle
        
        Args:
            allow_create (bool): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...

class SequenceRecorderGroup(Actor):
    r"""
    Sequence Recorder Group
    
    **C++ Source:**
    
    - **Module**: SequenceRecorder
    - **File**: SequenceRecorderActorGroup.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class BlueprintFunctionLibrary(Object):
    r"""
    This class is a base class for any function libraries exposed to blueprints.
    Methods in subclasses are expected to be static, and no methods should be added to this base class.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintFunctionLibrary.h
    
    """
    ...

class SequenceRecorderLibrary(BlueprintFunctionLibrary):
    r"""
    Sequence Recorder Blueprint Library
    
    **C++ Source:**
    
    - **Module**: SequenceRecorder
    - **File**: SequenceRecorderBlueprintLibrary.h
    
    """
    @classmethod
    def stop_recording_sequence(cls) -> None:
        r"""
        X.stop_recording_sequence() -> None
        Stop recording the current sequence, if any
        """
        ...
    @classmethod
    def start_recording_sequence(cls, actors_to_record: Array[Actor]) -> None:
        r"""
        X.start_recording_sequence(actors_to_record) -> None
        Start recording the passed-in actors to a level sequence.
        
        Args:
            actors_to_record (Array[Actor]): The actors to record
        """
        ...
    @classmethod
    def is_recording_sequence(cls) -> bool:
        r"""
        X.is_recording_sequence() -> bool
        Are we currently recording a sequence
        
        Returns:
            bool:
        """
        ...

class AutomatedLevelSequenceCapture(MovieSceneCapture):
    r"""
    Automated Level Sequence Capture
    
    **C++ Source:**
    
    - **Module**: MovieSceneTools
    - **File**: AutomatedLevelSequenceCapture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_command_line_arguments`` (str):  [Read-Write] Additional command line arguments to pass to the external process when capturing
    - ``audio_capture_protocol`` (MovieSceneAudioCaptureProtocolBase):  [Read-Only]
    - ``audio_capture_protocol_type`` (SoftClassPath):  [Read-Write] The type of capture protocol to use for audio data.
    - ``burn_in_options`` (LevelSequenceBurnInOptions):  [Read-Write]
    - ``close_editor_when_capture_starts`` (bool):  [Read-Write] When enabled, the editor will shutdown when the capture starts
    - ``custom_end_frame`` (FrameNumber):  [Read-Write] Frame number to end capturing.
    - ``custom_start_frame`` (FrameNumber):  [Read-Write] Frame number to start capturing.
    - ``delay_before_shot_warm_up`` (float):  [Read-Write] The number of seconds to wait (in real-time) at shot boundaries.  Useful for allowing post processing effects to settle down before capturing the animation.
    - ``delay_before_warm_up`` (float):  [Read-Write] The number of seconds to wait (in real-time) before we start playing back the warm up frames.  Useful for allowing post processing effects to settle down before capturing the animation.
    - ``delay_every_frame`` (float):  [Read-Write] The number of seconds to wait (in real-time) at every frame.  Useful for allowing post processing effects to settle down before capturing the animation.
    - ``image_capture_protocol`` (MovieSceneImageCaptureProtocolBase):  [Read-Only] Capture protocol responsible for actually capturing frame data
    - ``image_capture_protocol_type`` (SoftClassPath):  [Read-Write] The type of capture protocol to use for image data
    - ``inherited_command_line_arguments`` (str):  [Read-Write] Command line arguments inherited from this process
    - ``level_sequence_asset`` (SoftObjectPath):  [Read-Write] A level sequence asset to playback at runtime - used where the level sequence does not already exist in the world.
    - ``settings`` (MovieSceneCaptureSettings):  [Read-Write] Settings that define how to capture
    - ``shot_name`` (str):  [Read-Write] Optional shot name to render. The frame range to render will be set to the shot frame range.
    - ``use_custom_end_frame`` (bool):  [Read-Write] When enabled, the EndFrame setting will override the default ending frame number
    - ``use_custom_start_frame`` (bool):  [Read-Write] When enabled, the StartFrame setting will override the default starting frame number
    - ``use_separate_process`` (bool):  [Read-Write] Whether to capture the movie in a separate process or not
    - ``warm_up_frame_count`` (int32):  [Read-Write] The number of extra frames to play before the sequence's start frame, to "warm up" the animation.  This is useful if your
                animation contains particles or other runtime effects that are spawned into the scene earlier than your capture start frame
    - ``write_edit_decision_list`` (bool):  [Read-Write] Whether to write edit decision lists (EDLs) if the sequence contains shots
    - ``write_final_cut_pro_xml`` (bool):  [Read-Write] Whether to write Final Cut Pro XML files (XMLs) if the sequence contains shots
    """
    @property
    def level_sequence_asset(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Write] A level sequence asset to playback at runtime - used where the level sequence does not already exist in the world.
        """
        ...
    @level_sequence_asset.setter
    def level_sequence_asset(self, value: SoftObjectPath) -> None:
        ...
    @property
    def shot_name(self) -> str:
        r"""
        (str):  [Read-Write] Optional shot name to render. The frame range to render will be set to the shot frame range.
        """
        ...
    @shot_name.setter
    def shot_name(self, value: str) -> None:
        ...
    @property
    def use_custom_start_frame(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled, the StartFrame setting will override the default starting frame number
        """
        ...
    @use_custom_start_frame.setter
    def use_custom_start_frame(self, value: bool) -> None:
        ...
    @property
    def custom_start_frame(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] Frame number to start capturing.
        """
        ...
    @custom_start_frame.setter
    def custom_start_frame(self, value: FrameNumber) -> None:
        ...
    @property
    def use_custom_end_frame(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled, the EndFrame setting will override the default ending frame number
        """
        ...
    @use_custom_end_frame.setter
    def use_custom_end_frame(self, value: bool) -> None:
        ...
    @property
    def custom_end_frame(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] Frame number to end capturing.
        """
        ...
    @custom_end_frame.setter
    def custom_end_frame(self, value: FrameNumber) -> None:
        ...
    @property
    def warm_up_frame_count(self) -> int:
        r"""
        (int32):  [Read-Write] The number of extra frames to play before the sequence's start frame, to "warm up" the animation.  This is useful if your
                  animation contains particles or other runtime effects that are spawned into the scene earlier than your capture start frame
        """
        ...
    @warm_up_frame_count.setter
    def warm_up_frame_count(self, value: int) -> None:
        ...
    @property
    def delay_before_warm_up(self) -> float:
        r"""
        (float):  [Read-Write] The number of seconds to wait (in real-time) before we start playing back the warm up frames.  Useful for allowing post processing effects to settle down before capturing the animation.
        """
        ...
    @delay_before_warm_up.setter
    def delay_before_warm_up(self, value: float) -> None:
        ...
    @property
    def delay_before_shot_warm_up(self) -> float:
        r"""
        (float):  [Read-Write] The number of seconds to wait (in real-time) at shot boundaries.  Useful for allowing post processing effects to settle down before capturing the animation.
        """
        ...
    @delay_before_shot_warm_up.setter
    def delay_before_shot_warm_up(self, value: float) -> None:
        ...
    @property
    def delay_every_frame(self) -> float:
        r"""
        (float):  [Read-Write] The number of seconds to wait (in real-time) at every frame.  Useful for allowing post processing effects to settle down before capturing the animation.
        """
        ...
    @delay_every_frame.setter
    def delay_every_frame(self, value: float) -> None:
        ...
    @property
    def burn_in_options(self) -> LevelSequenceBurnInOptions:
        r"""
        (LevelSequenceBurnInOptions):  [Read-Write]
        """
        ...
    @burn_in_options.setter
    def burn_in_options(self, value: LevelSequenceBurnInOptions) -> None:
        ...
    @property
    def write_edit_decision_list(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to write edit decision lists (EDLs) if the sequence contains shots
        """
        ...
    @write_edit_decision_list.setter
    def write_edit_decision_list(self, value: bool) -> None:
        ...
    @property
    def write_final_cut_pro_xml(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to write Final Cut Pro XML files (XMLs) if the sequence contains shots
        """
        ...
    @write_final_cut_pro_xml.setter
    def write_final_cut_pro_xml(self, value: bool) -> None:
        ...

class MovieSceneUserImportFBXSettings(Object):
    r"""
    Movie Scene User Import FBXSettings
    
    **C++ Source:**
    
    - **Module**: MovieSceneTools
    - **File**: MovieSceneToolsUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``convert_scene_unit`` (bool):  [Read-Write] Convert the scene from FBX unit to UE unit(centimeter)
    - ``create_cameras`` (bool):  [Read-Write] Whether to create cameras if they don't already exist in the level.
    - ``force_front_x_axis`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system with front X axis instead of -Y
    - ``import_uniform_scale`` (float):  [Read-Write] Import Uniform Scale
    - ``match_by_name_only`` (bool):  [Read-Write] Match fbx node names to sequencer node names
    - ``reduce_keys`` (bool):  [Read-Write] Whether to remove keyframes within a tolerance from the imported tracks
    - ``reduce_keys_tolerance`` (float):  [Read-Write] The tolerance for reduce keys
    - ``replace_transform_track`` (bool):  [Read-Write] Whether to replace the existing transform track or create a new track/section
    """
    ...

class MovieSceneUserImportFBXControlRigSettings(Object):
    r"""
    Movie Scene User Import FBXControl Rig Settings
    
    **C++ Source:**
    
    - **Module**: MovieSceneTools
    - **File**: MovieSceneToolsUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control_channel_mappings`` (Array[ControlToTransformMappings]):  [Read-Write] Mappings for how Control Rig Control Attributes Map to the incoming Transforms
    - ``convert_scene_unit`` (bool):  [Read-Write] Convert the scene from FBX unit to UE unit(centimeter)
    - ``end_time_range`` (FrameNumber):  [Read-Write] End Time Range To Import
    - ``find_and_replace_strings`` (Array[ControlFindReplaceString]):  [Read-Write] Strings In Imported Node To Find And Replace
    - ``force_front_x_axis`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system with front X axis instead of -Y
    - ``import_onto_selected_controls`` (bool):  [Read-Write] Whether or not import onto selected controls or all controls
    - ``import_uniform_scale`` (float):  [Read-Write] Import Uniform Scale
    - ``imported_end_time`` (FrameNumber):  [Read-Only] Imported File
    - ``imported_file_name`` (str):  [Read-Only] Imported File Name
    - ``imported_frame_rate`` (str):  [Read-Only] Incoming File Frame Rate
    - ``imported_node_names`` (Array[str]):  [Read-Only] List Of Imported Names in FBX File
    - ``imported_start_time`` (FrameNumber):  [Read-Only] Imported File Duration in Seconds
    - ``insert_animation`` (bool):  [Read-Write] Whether or not we insert or replace, by default we insert
    - ``specify_time_range`` (bool):  [Read-Write] Whether to import over specific Time Range
    - ``start_time_range`` (FrameNumber):  [Read-Write] Start Time Range To Import
    - ``strip_namespace`` (bool):  [Read-Write] Will strip any namespace from the FBX node names
    - ``time_to_insert_or_replace_animation`` (FrameNumber):  [Read-Write] Time that we insert or replace the imported animation
    """
    def load_control_mappings_from_preset(self, meta_human_preset: bool) -> None:
        r"""
        x.load_control_mappings_from_preset(meta_human_preset) -> None
        Load the default or metahuman preset into the current mappings
        
        Args:
            meta_human_preset (bool):
        """
        ...

class MovieSceneUserExportFBXControlRigSettings(Object):
    r"""
    Movie Scene User Export FBXControl Rig Settings
    
    **C++ Source:**
    
    - **Module**: MovieSceneTools
    - **File**: MovieSceneToolsUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ascii`` (bool):  [Read-Write] If enabled, save as ascii instead of binary
    - ``control_channel_mappings`` (Array[ControlToTransformMappings]):  [Read-Write] Mappings for how Control Rig Control Attributes Map to the incoming Transforms
    - ``export_file_name`` (str):  [Read-Write] Imported File Name
    - ``export_local_time`` (bool):  [Read-Write] If enabled, export sequencer animation in its local time, relative to its sequence.
    - ``export_only_selected_controls`` (bool):  [Read-Write] Whether or not import onto selected controls or all controls
    - ``fbx_export_compatibility`` (FbxExportCompatibility):  [Read-Write] This will set the fbx sdk compatibility when exporting to fbx file. The default value is 2013
    - ``force_front_x_axis`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system with front X axis instead of -Y
    """
    @property
    def fbx_export_compatibility(self) -> FbxExportCompatibility:
        r"""
        (FbxExportCompatibility):  [Read-Write] This will set the fbx sdk compatibility when exporting to fbx file. The default value is 2013
        """
        ...
    @fbx_export_compatibility.setter
    def fbx_export_compatibility(self, value: FbxExportCompatibility) -> None:
        ...
    @property
    def ascii(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, save as ascii instead of binary
        """
        ...
    @ascii.setter
    def ascii(self, value: bool) -> None:
        ...
    @property
    def export_local_time(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export sequencer animation in its local time, relative to its sequence.
        """
        ...
    @export_local_time.setter
    def export_local_time(self, value: bool) -> None:
        ...
    def load_control_mappings_from_preset(self, meta_human_preset: bool) -> None:
        r"""
        x.load_control_mappings_from_preset(meta_human_preset) -> None
        Load the default or metahuman preset into the current mappings
        
        Args:
            meta_human_preset (bool):
        """
        ...

class AssetExportTask(Object):
    r"""
    Contains data for a group of assets to export
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AssetExportTask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automated`` (bool):  [Read-Write] Unattended export
    - ``errors`` (Array[str]):  [Read-Write] Array of error messages encountered during exporter
    - ``exporter`` (Exporter):  [Read-Write] Optional exporter, otherwise it will be determined automatically
    - ``filename`` (str):  [Read-Write] File to export as
    - ``ignore_object_list`` (Array[Object]):  [Read-Write] Array of objects to ignore exporting
    - ``object`` (Object):  [Read-Write] Asset to export
    - ``options`` (Object):  [Read-Write] Exporter specific options
    - ``prompt`` (bool):  [Read-Write] Allow dialog prompts
    - ``replace_identical`` (bool):  [Read-Write] Replace identical files
    - ``selected`` (bool):  [Read-Write] Export selected only
    - ``use_file_archive`` (bool):  [Read-Write] Save to a file archive
    - ``write_empty_files`` (bool):  [Read-Write] Write even if file empty
    """
    @property
    def object(self) -> Object:
        r"""
        (Object):  [Read-Write] Asset to export
        """
        ...
    @object.setter
    def object(self, value: Object) -> None:
        ...
    @property
    def exporter(self) -> Exporter:
        r"""
        (Exporter):  [Read-Write] Optional exporter, otherwise it will be determined automatically
        """
        ...
    @exporter.setter
    def exporter(self, value: Exporter) -> None:
        ...
    @property
    def filename(self) -> str:
        r"""
        (str):  [Read-Write] File to export as
        """
        ...
    @filename.setter
    def filename(self, value: str) -> None:
        ...
    @property
    def selected(self) -> bool:
        r"""
        (bool):  [Read-Write] Export selected only
        """
        ...
    @selected.setter
    def selected(self, value: bool) -> None:
        ...
    @property
    def replace_identical(self) -> bool:
        r"""
        (bool):  [Read-Write] Replace identical files
        """
        ...
    @replace_identical.setter
    def replace_identical(self, value: bool) -> None:
        ...
    @property
    def prompt(self) -> bool:
        r"""
        (bool):  [Read-Write] Allow dialog prompts
        """
        ...
    @prompt.setter
    def prompt(self, value: bool) -> None:
        ...
    @property
    def automated(self) -> bool:
        r"""
        (bool):  [Read-Write] Unattended export
        """
        ...
    @automated.setter
    def automated(self, value: bool) -> None:
        ...
    @property
    def use_file_archive(self) -> bool:
        r"""
        (bool):  [Read-Write] Save to a file archive
        """
        ...
    @use_file_archive.setter
    def use_file_archive(self, value: bool) -> None:
        ...
    @property
    def write_empty_files(self) -> bool:
        r"""
        (bool):  [Read-Write] Write even if file empty
        """
        ...
    @write_empty_files.setter
    def write_empty_files(self, value: bool) -> None:
        ...
    @property
    def ignore_object_list(self) -> Array[Object]:
        r"""
        (Array[Object]):  [Read-Write] Array of objects to ignore exporting
        """
        ...
    @ignore_object_list.setter
    def ignore_object_list(self, value: Array[Object]) -> None:
        ...
    @property
    def options(self) -> Object:
        r"""
        (Object):  [Read-Write] Exporter specific options
        """
        ...
    @options.setter
    def options(self, value: Object) -> None:
        ...
    @property
    def errors(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Array of error messages encountered during exporter
        """
        ...
    @errors.setter
    def errors(self, value: Array[str]) -> None:
        ...

class SequencerExportTask(AssetExportTask):
    r"""
    Contains data for a group of assets to import
    
    **C++ Source:**
    
    - **Module**: MovieSceneTools
    - **File**: SequencerExportTask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automated`` (bool):  [Read-Write] Unattended export
    - ``errors`` (Array[str]):  [Read-Write] Array of error messages encountered during exporter
    - ``exporter`` (Exporter):  [Read-Write] Optional exporter, otherwise it will be determined automatically
    - ``filename`` (str):  [Read-Write] File to export as
    - ``ignore_object_list`` (Array[Object]):  [Read-Write] Array of objects to ignore exporting
    - ``object`` (Object):  [Read-Write] Asset to export
    - ``options`` (Object):  [Read-Write] Exporter specific options
    - ``prompt`` (bool):  [Read-Write] Allow dialog prompts
    - ``replace_identical`` (bool):  [Read-Write] Replace identical files
    - ``selected`` (bool):  [Read-Write] Export selected only
    - ``sequencer_context`` (Object):  [Read-Write] A UWorld for LevelSequences, UUserWidget for WidgetAnimations, or AActor for Actor Sequences, etc...
    - ``use_file_archive`` (bool):  [Read-Write] Save to a file archive
    - ``write_empty_files`` (bool):  [Read-Write] Write even if file empty
    """
    @property
    def sequencer_context(self) -> Object:
        r"""
        (Object):  [Read-Write] A UWorld for LevelSequences, UUserWidget for WidgetAnimations, or AActor for Actor Sequences, etc...
        """
        ...
    @sequencer_context.setter
    def sequencer_context(self, value: Object) -> None:
        ...

class SequencerOutlinerScriptingObject(Object):
    r"""
    Sequencer Outliner Scripting Object
    
    **C++ Source:**
    
    - **Module**: SequencerCore
    - **File**: OutlinerScriptingObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_selection_changed`` (SequencerOutlinerSelectionChanged):  [Read-Write]
    """
    @property
    def on_selection_changed(self) -> SequencerOutlinerSelectionChanged:
        r"""
        (SequencerOutlinerSelectionChanged):  [Read-Write]
        """
        ...
    @on_selection_changed.setter
    def on_selection_changed(self, value: SequencerOutlinerSelectionChanged) -> None:
        ...
    def set_selection(self, selection: Array[SequencerViewModelScriptingStruct]) -> None:
        r"""
        x.set_selection(selection) -> None
        Set Selection
        
        Args:
            selection (Array[SequencerViewModelScriptingStruct]):
        """
        ...
    def get_selection(self) -> Array[SequencerViewModelScriptingStruct]:
        r"""
        x.get_selection() -> Array[SequencerViewModelScriptingStruct]
        Get Selection
        
        Returns:
            Array[SequencerViewModelScriptingStruct]:
        """
        ...
    def get_root_node(self) -> SequencerViewModelScriptingStruct:
        r"""
        x.get_root_node() -> SequencerViewModelScriptingStruct
        Get Root Node
        
        Returns:
            SequencerViewModelScriptingStruct:
        """
        ...
    def get_children(self, node: SequencerViewModelScriptingStruct, type_name: Name = "None") -> Array[SequencerViewModelScriptingStruct]:
        r"""
        x.get_children(node, type_name="None") -> Array[SequencerViewModelScriptingStruct]
        Get Children
        
        Args:
            node (SequencerViewModelScriptingStruct): 
            type_name (Name): 
        
        Returns:
            Array[SequencerViewModelScriptingStruct]:
        """
        ...

class SequencerScriptingLayer(Object):
    r"""
    Sequencer Scripting Layer
    
    **C++ Source:**
    
    - **Module**: SequencerCore
    - **File**: SequencerScriptingLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``outliner`` (SequencerOutlinerScriptingObject):  [Read-Write]
    """
    @property
    def outliner(self) -> SequencerOutlinerScriptingObject:
        r"""
        (SequencerOutlinerScriptingObject):  [Read-Only]
        """
        ...

class SequencerViewModelStructExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto FSequencerScriptingRanges
    
    **C++ Source:**
    
    - **Module**: SequencerCore
    - **File**: ViewModelScriptingStruct.h
    
    """
    @classmethod
    def get_label(cls, view_model: SequencerViewModelScriptingStruct) -> str:
        r"""
        X.get_label(view_model) -> str
        Get Label
        
        Args:
            view_model (SequencerViewModelScriptingStruct): 
        
        Returns:
            str:
        """
        ...

class ContentBrowserAssetContextMenuContext(Object):
    r"""
    Content Browser Asset Context Menu Context
    
    **C++ Source:**
    
    - **Module**: ContentBrowser
    - **File**: ContentBrowserMenuContexts.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``contains_unsupported_assets`` (bool):  [Read-Write]
    - ``selected_assets`` (Array[AssetData]):  [Read-Write] The currently selected assets in the content browser.
    """
    @property
    def selected_assets(self) -> Array[AssetData]:
        r"""
        (Array[AssetData]):  [Read-Only] The currently selected assets in the content browser.
        """
        ...
    @property
    def contains_unsupported_assets(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    def load_selected_objects_if_needed(self) -> Array[Object]:
        r"""
        x.load_selected_objects_if_needed() -> Array[Object]
        Loads the selected assets (if needed) which is based on AssetViewUtils::LoadAssetsIfNeeded, this exists primarily
        for backwards compatability.  Reliance on a black box to determine 'neededness' is not recommended, this function
        will likely be deprecated a few versions after GetSelectedObjects.
        
        Returns:
            Array[Object]:
        """
        ...
    def load_selected_objects(self, load_tags: Set[Name]) -> Array[Object]:
        r"""
        x.load_selected_objects(load_tags) -> Array[Object]
        Loads all the selected assets and returns an array of the objects.
        
        Args:
            load_tags (Set[Name]): 
        
        Returns:
            Array[Object]:
        """
        ...
    def get_selected_objects(self) -> Array[Object]:
        r"""
        x.get_selected_objects() -> Array[Object]
        UE_DEPRECATED(5.2, "GetSelectedObjects has been deprecated.  We no longer automatically load assets on right click.  Please use SelectedAssets and determine whatever you need for your context menu options without actually loading the assets.  When you finally need all or a subset of the selected assets use LoadSelectedAssets or LoadSelectedAssetsIf")
        deprecated: GetSelectedObjects has been deprecated.  We no longer automatically load assets on right click.  If you can work without loading the assets, please use SelectedAssets.  Otherwise call LoadSelectedObjects
        
        Returns:
            Array[Object]:
        """
        ...

class ContentBrowserMenuContext(Object):
    r"""
    Content Browser Menu Context
    
    **C++ Source:**
    
    - **Module**: ContentBrowser
    - **File**: ContentBrowserMenuContexts.h
    
    """
    ...

class ContentBrowserFolderContext(ContentBrowserMenuContext):
    r"""
    Content Browser Folder Context
    
    **C++ Source:**
    
    - **Module**: ContentBrowser
    - **File**: ContentBrowserMenuContexts.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_be_modified`` (bool):  [Read-Write]
    - ``no_folder_on_disk`` (bool):  [Read-Write]
    - ``num_asset_paths`` (int32):  [Read-Write]
    - ``num_class_paths`` (int32):  [Read-Write]
    - ``selected_package_paths`` (Array[str]):  [Read-Write]
    """
    @property
    def can_be_modified(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def no_folder_on_disk(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def num_asset_paths(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def num_class_paths(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def selected_package_paths(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Only]
        """
        ...

class SequencerKeyActor(Actor):
    r"""
    Sequencer Key Actor
    
    **C++ Source:**
    
    - **Module**: Sequencer
    - **File**: SequencerKeyActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class SequencerMeshTrail(Actor):
    r"""
    Sequencer Mesh Trail
    
    **C++ Source:**
    
    - **Module**: Sequencer
    - **File**: SequencerMeshTrail.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class SequencerModuleOutlinerScriptingObject(SequencerOutlinerScriptingObject):
    r"""
    Sequencer Module Outliner Scripting Object
    
    **C++ Source:**
    
    - **Module**: Sequencer
    - **File**: SequencerModuleOutlinerScriptingObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_selection_changed`` (SequencerOutlinerSelectionChanged):  [Read-Write]
    """
    def get_previous_key(self, nodes: Array[SequencerViewModelScriptingStruct], frame_number: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> FrameNumber:
        r"""
        x.get_previous_key(nodes, frame_number, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> FrameNumber
        Get Previous Key
        
        Args:
            nodes (Array[SequencerViewModelScriptingStruct]): 
            frame_number (FrameNumber): 
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            FrameNumber:
        """
        ...
    def get_next_key(self, nodes: Array[SequencerViewModelScriptingStruct], frame_number: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> FrameNumber:
        r"""
        x.get_next_key(nodes, frame_number, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> FrameNumber
        Get Next Key
        
        Args:
            nodes (Array[SequencerViewModelScriptingStruct]): 
            frame_number (FrameNumber): 
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            FrameNumber:
        """
        ...

class SequencerModuleScriptingLayer(SequencerScriptingLayer):
    r"""
    Sequencer Module Scripting Layer
    
    **C++ Source:**
    
    - **Module**: Sequencer
    - **File**: SequencerModuleScriptingLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``outliner`` (SequencerOutlinerScriptingObject):  [Read-Write]
    """
    def get_outliner(self) -> SequencerModuleOutlinerScriptingObject:
        r"""
        x.get_outliner() -> SequencerModuleOutlinerScriptingObject
        Retrieve the outliner
        
        Returns:
            SequencerModuleOutlinerScriptingObject:
        """
        ...

class VREditorAvatarActor(Actor):
    r"""
    Avatar Actor
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorAvatarActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class VREditorBaseActor(Actor):
    r"""
    Represents an actor specifically for VR Editor that has roomspace transformation
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorBaseActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class Visual(Object):
    r"""
    The base class for elements in UMG: slots and widgets.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Visual.h
    
    """
    ...

class Widget(Visual):
    r"""
    This is the base class for all wrapped Slate controls that are exposed to UObjects.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Widget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def slot(self) -> PanelSlot:
        r"""
        (PanelSlot):  [Read-Only] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
        """
        ...
    @property
    def tool_tip_text(self) -> Text:
        r"""
        (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
        """
        ...
    @tool_tip_text.setter
    def tool_tip_text(self, value: Text) -> None:
        ...
    @property
    def tool_tip_widget(self) -> Widget:
        r"""
        (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
        """
        ...
    @property
    def render_transform(self) -> WidgetTransform:
        r"""
        (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
        """
        ...
    @render_transform.setter
    def render_transform(self, value: WidgetTransform) -> None:
        ...
    @property
    def render_transform_pivot(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
        This value is a normalized coordinate about which things like rotations will occur.
        """
        ...
    @render_transform_pivot.setter
    def render_transform_pivot(self, value: Vector2D) -> None:
        ...
    @property
    def flow_direction_preference(self) -> FlowDirectionPreference:
        r"""
        (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
        """
        ...
    @flow_direction_preference.setter
    def flow_direction_preference(self, value: FlowDirectionPreference) -> None:
        ...
    @property
    def is_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
        """
        ...
    @is_enabled.setter
    def is_enabled(self, value: bool) -> None:
        ...
    @property
    def is_volatile(self) -> bool:
        r"""
        (bool):  [Read-Only] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
        changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
        instead of invalidating it every frame, which would prevent the invalidation panel from actually
        ever caching anything.
        """
        ...
    @property
    def cursor(self) -> MouseCursor:
        r"""
        (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
        """
        ...
    @cursor.setter
    def cursor(self, value: MouseCursor) -> None:
        ...
    @property
    def clipping(self) -> WidgetClipping:
        r"""
        (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
        bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
        from being seen.
        
        NOTE: Elements in different clipping spaces can not be batched together, and so there is a
        performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
        content from showing up outside its bounds.
        """
        ...
    @clipping.setter
    def clipping(self, value: WidgetClipping) -> None:
        ...
    @property
    def clip_to_bounds(self) -> WidgetClipping:
        r"""
        deprecated: 'clip_to_bounds' was renamed to 'clipping'.
        """
        ...
    @clip_to_bounds.setter
    def clip_to_bounds(self, value: WidgetClipping) -> None:
        ...
    @property
    def visibility(self) -> SlateVisibility:
        r"""
        (SlateVisibility):  [Read-Write] The visibility of the widget
        """
        ...
    @visibility.setter
    def visibility(self, value: SlateVisibility) -> None:
        ...
    @property
    def visiblity(self) -> SlateVisibility:
        r"""
        deprecated: 'visiblity' was renamed to 'visibility'.
        """
        ...
    @visiblity.setter
    def visiblity(self, value: SlateVisibility) -> None:
        ...
    @property
    def render_opacity(self) -> float:
        r"""
        (float):  [Read-Write] The opacity of the widget
        """
        ...
    @render_opacity.setter
    def render_opacity(self, value: float) -> None:
        ...
    @property
    def opacity(self) -> float:
        r"""
        deprecated: 'opacity' was renamed to 'render_opacity'.
        """
        ...
    @opacity.setter
    def opacity(self, value: float) -> None:
        ...
    @property
    def pixel_snapping(self) -> WidgetPixelSnapping:
        r"""
        (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
        """
        ...
    @pixel_snapping.setter
    def pixel_snapping(self, value: WidgetPixelSnapping) -> None:
        ...
    @property
    def navigation(self) -> WidgetNavigation:
        r"""
        (WidgetNavigation):  [Read-Only] The navigation object for this widget is optionally created if the user has configured custom
        navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
        can occur between widgets.
        """
        ...
    def set_visibility(self, visibility: SlateVisibility) -> None:
        r"""
        x.set_visibility(visibility) -> None
        Sets the visibility of the widget.
        
        Args:
            visibility (SlateVisibility):
        """
        ...
    def set_user_focus(self, player_controller: PlayerController) -> None:
        r"""
        x.set_user_focus(player_controller) -> None
        Sets the focus to this widget for a specific user (if setting focus for the owning user, prefer SetFocus())
        
        Args:
            player_controller (PlayerController):
        """
        ...
    def set_tool_tip_text(self, tool_tip_text: Text) -> None:
        r"""
        x.set_tool_tip_text(tool_tip_text) -> None
        Sets the tooltip text for the widget.
        
        Args:
            tool_tip_text (Text):
        """
        ...
    def set_tool_tip(self, widget: Widget) -> None:
        r"""
        x.set_tool_tip(widget) -> None
        Sets a custom widget as the tooltip of the widget.
        
        Args:
            widget (Widget):
        """
        ...
    def set_render_translation(self, translation: Vector2D) -> None:
        r"""
        x.set_render_translation(translation) -> None
        Set Render Translation
        
        Args:
            translation (Vector2D):
        """
        ...
    def set_render_transform_pivot(self, pivot: Vector2D) -> None:
        r"""
        x.set_render_transform_pivot(pivot) -> None
        Set Render Transform Pivot
        
        Args:
            pivot (Vector2D):
        """
        ...
    def set_render_transform_angle(self, angle: float) -> None:
        r"""
        x.set_render_transform_angle(angle) -> None
        Set Render Transform Angle
        
        Args:
            angle (float):
        """
        ...
    def set_render_angle(self, angle: float) -> None:
        r"""
        deprecated: 'set_render_angle' was renamed to 'set_render_transform_angle'.
        """
        ...
    def set_render_transform(self, transform: WidgetTransform) -> None:
        r"""
        x.set_render_transform(transform) -> None
        Set Render Transform
        
        Args:
            transform (WidgetTransform):
        """
        ...
    def set_render_shear(self, shear: Vector2D) -> None:
        r"""
        x.set_render_shear(shear) -> None
        Set Render Shear
        
        Args:
            shear (Vector2D):
        """
        ...
    def set_render_scale(self, scale: Vector2D) -> None:
        r"""
        x.set_render_scale(scale) -> None
        Set Render Scale
        
        Args:
            scale (Vector2D):
        """
        ...
    def set_render_opacity(self, opacity: float) -> None:
        r"""
        x.set_render_opacity(opacity) -> None
        Sets the visibility of the widget.
        
        Args:
            opacity (float):
        """
        ...
    def set_opacity(self, opacity: float) -> None:
        r"""
        deprecated: 'set_opacity' was renamed to 'set_render_opacity'.
        """
        ...
    def set_navigation_rule_explicit(self, direction: UINavigation, widget: Widget) -> None:
        r"""
        x.set_navigation_rule_explicit(direction, widget) -> None
        Sets the widget navigation rules for a specific direction. This can only be called on widgets that are in a widget tree. This works only for Explicit Rule.
        
        Args:
            direction (UINavigation): 
            widget (Widget): Focus on this widget instance
        """
        ...
    def set_navigation_rule_custom_boundary(self, direction: UINavigation, custom_delegate: CustomWidgetNavigationDelegate) -> None:
        r"""
        x.set_navigation_rule_custom_boundary(direction, custom_delegate) -> None
        Sets the widget navigation rules for a specific direction. This can only be called on widgets that are in a widget tree. This works only for CustomBoundary Rule.
        
        Args:
            direction (UINavigation): 
            custom_delegate (CustomWidgetNavigationDelegate): Custom Delegate that will be called
        """
        ...
    def set_navigation_rule_custom(self, direction: UINavigation, custom_delegate: CustomWidgetNavigationDelegate) -> None:
        r"""
        x.set_navigation_rule_custom(direction, custom_delegate) -> None
        Sets the widget navigation rules for a specific direction. This can only be called on widgets that are in a widget tree. This works only for Custom Rule.
        
        Args:
            direction (UINavigation): 
            custom_delegate (CustomWidgetNavigationDelegate): Custom Delegate that will be called
        """
        ...
    def set_navigation_rule_base(self, direction: UINavigation, rule: UINavigationRule) -> None:
        r"""
        x.set_navigation_rule_base(direction, rule) -> None
        Sets the widget navigation rules for a specific direction. This can only be called on widgets that are in a widget tree. This works only for non Explicit, non Custom and non CustomBoundary Rules.
        
        Args:
            direction (UINavigation): 
            rule (UINavigationRule): The rule to use when navigation is taking place
        """
        ...
    def set_navigation_rule(self, direction: UINavigation, rule: UINavigationRule, widget_to_focus: Name) -> None:
        r"""
        x.set_navigation_rule(direction, rule, widget_to_focus) -> None
        Set Navigation Rule
        deprecated: Function 'SetNavigationRule' is deprecated.
        
        Args:
            direction (UINavigation): 
            rule (UINavigationRule): 
            widget_to_focus (Name):
        """
        ...
    def set_keyboard_focus(self) -> None:
        r"""
        x.set_keyboard_focus() -> None
        Sets the focus to this widget.
        """
        ...
    def set_is_enabled(self, is_enabled: bool) -> None:
        r"""
        x.set_is_enabled(is_enabled) -> None
        Sets the current enabled status of the widget
        
        Args:
            is_enabled (bool):
        """
        ...
    def set_focus(self) -> None:
        r"""
        x.set_focus() -> None
        Sets the focus to this widget for the owning user
        """
        ...
    def set_cursor(self, cursor: MouseCursor) -> None:
        r"""
        x.set_cursor(cursor) -> None
        Sets the cursor to show over the widget.
        
        Args:
            cursor (MouseCursor):
        """
        ...
    def set_clipping(self, clipping: WidgetClipping) -> None:
        r"""
        x.set_clipping(clipping) -> None
        Sets the clipping state of this widget.
        
        Args:
            clipping (WidgetClipping):
        """
        ...
    def set_all_navigation_rules(self, rule: UINavigationRule, widget_to_focus: Name) -> None:
        r"""
        x.set_all_navigation_rules(rule, widget_to_focus) -> None
        Sets the widget navigation rules for all directions. This can only be called on widgets that are in a widget tree.
        
        Args:
            rule (UINavigationRule): The rule to use when navigation is taking place
            widget_to_focus (Name): When using the Explicit rule, focus on this widget
        """
        ...
    def reset_cursor(self) -> None:
        r"""
        x.reset_cursor() -> None
        Resets the cursor to use on the widget, removing any customization for it.
        """
        ...
    def remove_from_parent(self) -> None:
        r"""
        x.remove_from_parent() -> None
        Removes the widget from its parent widget.  If this widget was added to the player's screen or the viewport
        it will also be removed from those containers.
        """
        ...
    def remove_field_value_changed_delegate(self, field_id: FieldNotificationId, delegate: FieldValueChangedDynamicDelegate) -> None:
        r"""
        x.remove_field_value_changed_delegate(field_id, delegate) -> None
        K2 Remove Field Value Changed Delegate
        
        Args:
            field_id (FieldNotificationId): 
            delegate (FieldValueChangedDynamicDelegate):
        """
        ...
    def broadcast_field_value_changed(self, field_id: FieldNotificationId) -> None:
        r"""
        x.broadcast_field_value_changed(field_id) -> None
        K2 Broadcast Field Value Changed
        
        Args:
            field_id (FieldNotificationId):
        """
        ...
    def add_field_value_changed_delegate(self, field_id: FieldNotificationId, delegate: FieldValueChangedDynamicDelegate) -> None:
        r"""
        x.add_field_value_changed_delegate(field_id, delegate) -> None
        K2 Add Field Value Changed Delegate
        
        Args:
            field_id (FieldNotificationId): 
            delegate (FieldValueChangedDynamicDelegate):
        """
        ...
    def is_visible(self) -> bool:
        r"""
        x.is_visible() -> bool
        Returns true if the widget is Visible, HitTestInvisible or SelfHitTestInvisible.
        
        Returns:
            bool:
        """
        ...
    def is_rendered(self) -> bool:
        r"""
        x.is_rendered() -> bool
        Returns true if the widget is Visible, HitTestInvisible or SelfHitTestInvisible and the Render Opacity is greater than 0.
        
        Returns:
            bool:
        """
        ...
    def is_in_viewport(self) -> bool:
        r"""
        x.is_in_viewport() -> bool
        
        
        Returns:
            bool: true if the widget was added to the viewport using AddToViewport or AddToPlayerScreen.
        """
        ...
    def is_hovered(self) -> bool:
        r"""
        x.is_hovered() -> bool
        Returns true if the widget is currently being hovered by a pointer device
        
        Returns:
            bool:
        """
        ...
    def invalidate_layout_and_volatility(self) -> None:
        r"""
        x.invalidate_layout_and_volatility() -> None
        Invalidates the widget from the view of a layout caching widget that may own this widget.
        will force the owning widget to redraw and cache children on the next paint pass.
        """
        ...
    def has_user_focused_descendants(self, player_controller: PlayerController) -> bool:
        r"""
        x.has_user_focused_descendants(player_controller) -> bool
        Returns true if any descendant widget is focused by a specific user.
        
        Args:
            player_controller (PlayerController): 
        
        Returns:
            bool:
        """
        ...
    def has_user_focus(self, player_controller: PlayerController) -> bool:
        r"""
        x.has_user_focus(player_controller) -> bool
        Returns true if this widget is focused by a specific user.
        
        Args:
            player_controller (PlayerController): 
        
        Returns:
            bool:
        """
        ...
    def has_mouse_capture_by_user(self, user_index: int, pointer_index: int = -1) -> bool:
        r"""
        x.has_mouse_capture_by_user(user_index, pointer_index=-1) -> bool
        Checks to see if this widget is the current mouse captor
        
        Args:
            user_index (int32): 
            pointer_index (int32): 
        
        Returns:
            bool: True if this widget has captured the mouse with given user and pointer
        """
        ...
    def has_mouse_capture(self) -> bool:
        r"""
        x.has_mouse_capture() -> bool
        Checks to see if this widget is the current mouse captor
        
        Returns:
            bool: True if this widget has captured the mouse
        """
        ...
    def has_keyboard_focus(self) -> bool:
        r"""
        x.has_keyboard_focus() -> bool
        Checks to see if this widget currently has the keyboard focus
        
        Returns:
            bool: True if this widget has keyboard focus
        """
        ...
    def has_focused_descendants(self) -> bool:
        r"""
        x.has_focused_descendants() -> bool
        Returns true if any descendant widget is focused by any user.
        
        Returns:
            bool:
        """
        ...
    def has_any_user_focus(self) -> bool:
        r"""
        x.has_any_user_focus() -> bool
        Returns true if this widget is focused by any user.
        
        Returns:
            bool:
        """
        ...
    def get_visibility(self) -> SlateVisibility:
        r"""
        x.get_visibility() -> SlateVisibility
        Gets the current visibility of the widget.
        
        Returns:
            SlateVisibility:
        """
        ...
    def get_tick_space_geometry(self) -> Geometry:
        r"""
        x.get_tick_space_geometry() -> Geometry
        Get Tick Space Geometry
        
        Returns:
            Geometry:
        """
        ...
    def get_render_transform_angle(self) -> float:
        r"""
        x.get_render_transform_angle() -> float
        Get Render Transform Angle
        
        Returns:
            float:
        """
        ...
    def get_render_opacity(self) -> float:
        r"""
        x.get_render_opacity() -> float
        Gets the current visibility of the widget.
        
        Returns:
            float:
        """
        ...
    def get_opacity(self) -> float:
        r"""
        deprecated: 'get_opacity' was renamed to 'get_render_opacity'.
        """
        ...
    def get_parent(self) -> PanelWidget:
        r"""
        x.get_parent() -> PanelWidget
        Gets the parent widget
        
        Returns:
            PanelWidget:
        """
        ...
    def get_paint_space_geometry(self) -> Geometry:
        r"""
        x.get_paint_space_geometry() -> Geometry
        Get Paint Space Geometry
        
        Returns:
            Geometry:
        """
        ...
    def get_owning_player(self) -> PlayerController:
        r"""
        x.get_owning_player() -> PlayerController
        Gets the player controller associated with this UI.
        
        Returns:
            PlayerController: The player controller that owns the UI.
        """
        ...
    def get_owning_local_player(self) -> LocalPlayer:
        r"""
        x.get_owning_local_player() -> LocalPlayer
        Gets the local player associated with this UI.
        
        Returns:
            LocalPlayer: The owning local player.
        """
        ...
    def get_is_enabled(self) -> bool:
        r"""
        x.get_is_enabled() -> bool
        Gets the current enabled status of the widget
        
        Returns:
            bool:
        """
        ...
    def get_game_instance(self) -> GameInstance:
        r"""
        x.get_game_instance() -> GameInstance
        Gets the game instance associated with this UI.
        
        Returns:
            GameInstance: a pointer to the owning game instance
        """
        ...
    def get_desired_size(self) -> Vector2D:
        r"""
        x.get_desired_size() -> Vector2D
        Gets the widgets desired size.
        NOTE: The underlying Slate widget must exist and be valid, also at least one pre-pass must
              have occurred before this value will be of any use.
        
        Returns:
            Vector2D: The widget's desired size
        """
        ...
    def get_clipping(self) -> WidgetClipping:
        r"""
        x.get_clipping() -> WidgetClipping
        Gets the clipping state of this widget.
        
        Returns:
            WidgetClipping:
        """
        ...
    def get_cached_geometry(self) -> Geometry:
        r"""
        x.get_cached_geometry() -> Geometry
        Gets the last geometry used to Tick the widget.  This data may not exist yet if this call happens prior to
        the widget having been ticked/painted, or it may be out of date, or a frame behind.
        
        We recommend not to use this data unless there's no other way to solve your problem.  Normally in Slate we
        try and handle these issues by making a dependent widget part of the hierarchy, as to avoid frame behind
        or what are referred to as hysteresis problems, both caused by depending on geometry from the previous frame
        being used to advise how to layout a dependent object the current frame.
        
        Returns:
            Geometry:
        """
        ...
    def get_accessible_text(self) -> Text:
        r"""
        x.get_accessible_text() -> Text
        Gets the accessible text from the underlying Slate accessible widget
        
        Returns:
            Text: The accessible text of the underlying Slate accessible widget. Returns an empty text if accessibility is dsabled or the underlying accessible widget is invalid.
        """
        ...
    def get_accessible_summary_text(self) -> Text:
        r"""
        x.get_accessible_summary_text() -> Text
        Gets the accessible summary text from the underlying Slate accessible widget.
        
        Returns:
            Text: The accessible summary text of the underlying Slate accessible widget. Returns an empty text if accessibility is dsabled or the underlying accessible widget is invalid.
        """
        ...
    def force_volatile(self, force: bool) -> None:
        r"""
        x.force_volatile(force) -> None
        Sets the forced volatility of the widget.
        
        Args:
            force (bool):
        """
        ...
    def force_layout_prepass(self) -> None:
        r"""
        x.force_layout_prepass() -> None
        Forces a pre-pass.  A pre-pass caches the desired size of the widget hierarchy owned by this widget.
        One pre-pass already happens for every widget before Tick occurs.  You only need to perform another
        pre-pass if you are adding child widgets this frame and want them to immediately be visible this frame.
        """
        ...

class UserWidget(Widget):
    r"""
    A widget that enables UI extensibility through WidgetBlueprint.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UserWidget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``color_and_opacity`` (LinearColor):  [Read-Write] The color and opacity of this widget.  Tints all child widgets.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``desired_focus_widget`` (WidgetChild):  [Read-Write]
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``foreground_color`` (SlateColor):  [Read-Write] The foreground color of the widget, this is inherited by sub widgets.  Any color property
      that is marked as inherit will use this color.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Setting this flag to true, allows this widget to accept focus when clicked, or when navigated to.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_visibility_changed`` (OnVisibilityChangedEvent):  [Read-Write] Called when the visibility has changed
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``padding`` (Margin):  [Read-Write] The padding area around the content.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``preview_background`` (Texture2D):  [Read-Write] A preview background that you can use when designing the UI to get a sense of scale on the screen.  Use
      a texture with a screenshot of your game in it, for example if you were designing a HUD.
    - ``priority`` (int32):  [Read-Write]
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``stop_action`` (bool):  [Read-Write]
    - ``tick_frequency`` (WidgetTickFrequency):  [Read-Write] This widget is allowed to tick. If this is unchecked tick will never be called, animations will not play correctly, and latent actions will not execute.
      Uncheck this for performance reasons only
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def color_and_opacity(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color and opacity of this widget.  Tints all child widgets.
        """
        ...
    @color_and_opacity.setter
    def color_and_opacity(self, value: LinearColor) -> None:
        ...
    @property
    def foreground_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] The foreground color of the widget, this is inherited by sub widgets.  Any color property
        that is marked as inherit will use this color.
        """
        ...
    @foreground_color.setter
    def foreground_color(self, value: SlateColor) -> None:
        ...
    @property
    def on_visibility_changed(self) -> OnVisibilityChangedEvent:
        r"""
        (OnVisibilityChangedEvent):  [Read-Write] Called when the visibility has changed
        """
        ...
    @on_visibility_changed.setter
    def on_visibility_changed(self, value: OnVisibilityChangedEvent) -> None:
        ...
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area around the content.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def priority(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @priority.setter
    def priority(self, value: int) -> None:
        ...
    @property
    def is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Write] Setting this flag to true, allows this widget to accept focus when clicked, or when navigated to.
        """
        ...
    @is_focusable.setter
    def is_focusable(self, value: bool) -> None:
        ...
    @property
    def stop_action(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @stop_action.setter
    def stop_action(self, value: bool) -> None:
        ...
    @property
    def tick_frequency(self) -> WidgetTickFrequency:
        r"""
        (WidgetTickFrequency):  [Read-Only] This widget is allowed to tick. If this is unchecked tick will never be called, animations will not play correctly, and latent actions will not execute.
        Uncheck this for performance reasons only
        """
        ...
    def unregister_input_component(self) -> None:
        r"""
        x.unregister_input_component() -> None
        StopListeningForAllInputActions will automatically Register an Input Component with the player input system.
        If you however, want to Pause and Resume, listening for a set of actions, the best way is to use
        UnregisterInputComponent to pause, and RegisterInputComponent to resume listening.
        """
        ...
    def unbind_from_animation_started(self, animation: WidgetAnimation, delegate: WidgetAnimationDynamicEvent) -> None:
        r"""
        x.unbind_from_animation_started(animation, delegate) -> None
        Unbind an animation started delegate.
        
        Args:
            animation (WidgetAnimation): the animation to listen for starting or finishing.
            delegate (WidgetAnimationDynamicEvent): the delegate to call when the animation's state changes
        """
        ...
    def unbind_from_animation_finished(self, animation: WidgetAnimation, delegate: WidgetAnimationDynamicEvent) -> None:
        r"""
        x.unbind_from_animation_finished(animation, delegate) -> None
        Unbind an animation finished delegate.
        
        Args:
            animation (WidgetAnimation): the animation to listen for starting or finishing.
            delegate (WidgetAnimationDynamicEvent): the delegate to call when the animation's state changes
        """
        ...
    def unbind_all_from_animation_started(self, animation: WidgetAnimation) -> None:
        r"""
        x.unbind_all_from_animation_started(animation) -> None
        Unbind All from Animation Started
        
        Args:
            animation (WidgetAnimation):
        """
        ...
    def unbind_all_from_animation_finished(self, animation: WidgetAnimation) -> None:
        r"""
        x.unbind_all_from_animation_finished(animation) -> None
        Unbind All from Animation Finished
        
        Args:
            animation (WidgetAnimation):
        """
        ...
    def tick(self, my_geometry: Geometry, delta_time: float) -> None:
        r"""
        x.tick(my_geometry, delta_time) -> None
        Ticks this widget.  Override in derived classes, but always call the parent implementation.
        
        Args:
            my_geometry (Geometry): The space allotted for this widget
            delta_time (float): Real time passed since last tick
        """
        ...
    def stop_listening_for_input_action(self, action_name: Name, event_type: InputEventType) -> None:
        r"""
        x.stop_listening_for_input_action(action_name, event_type) -> None
        Removes the binding for a particular action's callback.
        
        Args:
            action_name (Name): 
            event_type (InputEventType):
        """
        ...
    def stop_listening_for_all_input_actions(self) -> None:
        r"""
        x.stop_listening_for_all_input_actions() -> None
        Stops listening to all input actions, and unregisters the input component with the player controller.
        """
        ...
    def stop_animations_and_latent_actions(self) -> None:
        r"""
        x.stop_animations_and_latent_actions() -> None
        Cancels any pending Delays or timer callbacks for this widget, and stops all active animations on the widget.
        """
        ...
    def stop_animation(self, animation: WidgetAnimation) -> None:
        r"""
        x.stop_animation(animation) -> None
        Stops an already running animation in this widget
        
        Args:
            animation (WidgetAnimation):
        """
        ...
    def stop_all_animations(self) -> None:
        r"""
        x.stop_all_animations() -> None
        Stop All actively running animations.
        """
        ...
    def set_position_in_viewport(self, position: Vector2D, remove_dpi_scale: bool = True) -> None:
        r"""
        x.set_position_in_viewport(position, remove_dpi_scale=True) -> None
        Sets the widgets position in the viewport.
        
        Args:
            position (Vector2D): The 2D position to set the widget to in the viewport.
            remove_dpi_scale (bool): If you've already calculated inverse DPI, set this to false. Otherwise inverse DPI is applied to the position so that when the location is scaled by DPI, it ends up in the expected position.
        """
        ...
    def set_playback_speed(self, animation: WidgetAnimation, playback_speed: float = 1.000000) -> None:
        r"""
        x.set_playback_speed(animation, playback_speed=1.000000) -> None
        Changes the playback rate of a playing animation
        
        Args:
            animation (WidgetAnimation): The animation that is already playing
            playback_speed (float):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Sets the padding for the user widget, putting a larger gap between the widget border and it's root widget.
        
        Args:
            padding (Margin):
        """
        ...
    def set_owning_player(self, local_player_controller: PlayerController) -> None:
        r"""
        x.set_owning_player(local_player_controller) -> None
        Sets the local player associated with this UI via PlayerController reference.
        
        Args:
            local_player_controller (PlayerController): The PlayerController of the local player you want to be the conceptual owner of this UI.
        """
        ...
    def set_num_loops_to_play(self, animation: WidgetAnimation, num_loops_to_play: int) -> None:
        r"""
        x.set_num_loops_to_play(animation, num_loops_to_play) -> None
        Changes the number of loops to play given a playing animation
        
        Args:
            animation (WidgetAnimation): The animation that is already playing
            num_loops_to_play (int32): The number of loops to play. (0 to loop indefinitely)
        """
        ...
    def set_input_action_priority(self, new_priority: int) -> None:
        r"""
        x.set_input_action_priority(new_priority) -> None
        Set Input Action Priority
        
        Args:
            new_priority (int32):
        """
        ...
    def set_input_action_blocking(self, should_block: bool) -> None:
        r"""
        x.set_input_action_blocking(should_block) -> None
        Set Input Action Blocking
        
        Args:
            should_block (bool):
        """
        ...
    def set_foreground_color(self, foreground_color: SlateColor) -> None:
        r"""
        x.set_foreground_color(foreground_color) -> None
        Sets the foreground color of the widget, this is inherited by sub widgets.  Any color property
        that is marked as inherit will use this color.
        
        Args:
            foreground_color (SlateColor): The foreground color.
        """
        ...
    def set_desired_size_in_viewport(self, size: Vector2D) -> None:
        r"""
        x.set_desired_size_in_viewport(size) -> None
        Set Desired Size in Viewport
        
        Args:
            size (Vector2D):
        """
        ...
    def set_color_and_opacity(self, color_and_opacity: LinearColor) -> None:
        r"""
        x.set_color_and_opacity(color_and_opacity) -> None
        Sets the tint of the widget, this affects all child widgets.
        
        Args:
            color_and_opacity (LinearColor): The tint to apply to all child widgets.
        """
        ...
    def set_animation_current_time(self, animation: WidgetAnimation, time: float) -> None:
        r"""
        x.set_animation_current_time(animation, time) -> None
        Sets the current time of the animation in this widget. Does not change state.
        
        Args:
            animation (WidgetAnimation): 
            time (float):
        """
        ...
    def set_anchors_in_viewport(self, anchors: Anchors) -> None:
        r"""
        x.set_anchors_in_viewport(anchors) -> None
        Set Anchors in Viewport
        
        Args:
            anchors (Anchors):
        """
        ...
    def set_alignment_in_viewport(self, alignment: Vector2D) -> None:
        r"""
        x.set_alignment_in_viewport(alignment) -> None
        Set Alignment in Viewport
        
        Args:
            alignment (Vector2D):
        """
        ...
    def reverse_animation(self, animation: WidgetAnimation) -> None:
        r"""
        x.reverse_animation(animation) -> None
        If an animation is playing, this function will reverse the playback.
        
        Args:
            animation (WidgetAnimation): The playing animation that we want to reverse
        """
        ...
    def remove_from_viewport(self) -> None:
        r"""
        x.remove_from_viewport() -> None
        Remove from Viewport
        deprecated: Use RemoveFromParent instead
        """
        ...
    def remove_extensions(self, extension_type: Class) -> None:
        r"""
        x.remove_extensions(extension_type) -> None
        Remove all extensions of the requested type.
        
        Args:
            extension_type (type(Class)):
        """
        ...
    def remove_extension(self, extension: UserWidgetExtension) -> None:
        r"""
        x.remove_extension(extension) -> None
        Remove the extension.
        
        Args:
            extension (UserWidgetExtension):
        """
        ...
    def register_input_component(self) -> None:
        r"""
        x.register_input_component() -> None
        ListenForInputAction will automatically Register an Input Component with the player input system.
        If you however, want to Pause and Resume, listening for a set of actions, the best way is to use
        UnregisterInputComponent to pause, and RegisterInputComponent to resume listening.
        """
        ...
    def queue_stop_animation(self, animation: WidgetAnimation) -> None:
        r"""
        x.queue_stop_animation(animation) -> None
        Stops an already running animation in this widget
        
        Args:
            animation (WidgetAnimation):
        """
        ...
    def queue_stop_all_animations(self) -> None:
        r"""
        x.queue_stop_all_animations() -> None
        Stop All actively running animations.
        """
        ...
    def queue_play_animation_time_range(self, animation: WidgetAnimation, start_at_time: float = 0.000000, end_at_time: float = 0.000000, num_loops_to_play: int = 1, play_mode: UMGSequencePlayMode = UMGSequencePlayMode.FORWARD, playback_speed: float = 1.000000, restore_state: bool = False) -> None:
        r"""
        x.queue_play_animation_time_range(animation, start_at_time=0.000000, end_at_time=0.000000, num_loops_to_play=1, play_mode=UMGSequencePlayMode.FORWARD, playback_speed=1.000000, restore_state=False) -> None
        Plays an animation in this widget a specified number of times stopping at a specified time
        
        Args:
            animation (WidgetAnimation): The animation to play
            start_at_time (float): The time in the animation from which to start playing, relative to the start position. For looped animations, this will only affect the first playback of the animation.
            end_at_time (float): The absolute time in the animation where to stop, this is only considered in the last loop.
            num_loops_to_play (int32): The number of times to loop this animation (0 to loop indefinitely)
            play_mode (UMGSequencePlayMode): Specifies the playback mode
            playback_speed (float): The speed at which the animation should play
            restore_state (bool): Restores widgets to their pre-animated state when the animation stops
        """
        ...
    def queue_play_animation_reverse(self, animation: WidgetAnimation, playback_speed: float = 1.000000, restore_state: bool = False) -> None:
        r"""
        x.queue_play_animation_reverse(animation, playback_speed=1.000000, restore_state=False) -> None
        Plays an animation on this widget relative to it's current state in reverse.  You should use this version in situations where
        say a user can click a button and that causes a panel to slide out, and you want to reverse that same animation to begin sliding
        in the opposite direction.
        
        Args:
            animation (WidgetAnimation): The animation to play
            playback_speed (float): The speed at which the animation should play
            restore_state (bool): Restores widgets to their pre-animated state when the animation stops
        """
        ...
    def queue_play_animation_forward(self, animation: WidgetAnimation, playback_speed: float = 1.000000, restore_state: bool = False) -> None:
        r"""
        x.queue_play_animation_forward(animation, playback_speed=1.000000, restore_state=False) -> None
        Plays an animation on this widget relative to it's current state forward.  You should use this version in situations where
        say a user can click a button and that causes a panel to slide out, and you want to reverse that same animation to begin sliding
        in the opposite direction.
        
        Args:
            animation (WidgetAnimation): The animation to play
            playback_speed (float): The speed at which the animation should play
            restore_state (bool): Restores widgets to their pre-animated state when the animation stops
        """
        ...
    def queue_play_animation(self, animation: WidgetAnimation, start_at_time: float = 0.000000, num_loops_to_play: int = 1, play_mode: UMGSequencePlayMode = UMGSequencePlayMode.FORWARD, playback_speed: float = 1.000000, restore_state: bool = False) -> None:
        r"""
        x.queue_play_animation(animation, start_at_time=0.000000, num_loops_to_play=1, play_mode=UMGSequencePlayMode.FORWARD, playback_speed=1.000000, restore_state=False) -> None
        Plays an animation in this widget a specified number of times
        
        Args:
            animation (WidgetAnimation): The animation to play
            start_at_time (float): The time in the animation from which to start playing, relative to the start position. For looped animations, this will only affect the first playback of the animation.
            num_loops_to_play (int32): The number of times to loop this animation (0 to loop indefinitely)
            play_mode (UMGSequencePlayMode): Specifies the playback mode
            playback_speed (float): The speed at which the animation should play
            restore_state (bool): Restores widgets to their pre-animated state when the animation stops
        """
        ...
    def queue_pause_animation(self, animation: WidgetAnimation) -> float:
        r"""
        x.queue_pause_animation(animation) -> float
        Pauses an already running animation in this widget
        
        Args:
            animation (WidgetAnimation): 
        
        Returns:
            float: the time point the animation was at when it was paused, relative to its start position.  Use this as the StartAtTime when you trigger PlayAnimation.
        """
        ...
    def pre_construct(self, is_design_time: bool) -> None:
        r"""
        x.pre_construct(is_design_time) -> None
        Called by both the game and the editor.  Allows users to run initial setup for their widgets to better preview
        the setup in the designer and since generally that same setup code is required at runtime, it's called there
        as well.
        
        **WARNING**
        This is intended purely for cosmetic updates using locally owned data, you can not safely access any game related
        state, if you call something that doesn't expect to be run at editor time, you may crash the editor.
        
        In the event you save the asset with blueprint code that causes a crash on evaluation.  You can turn off
        PreConstruct evaluation in the Widget Designer settings in the Editor Preferences.
        
        Args:
            is_design_time (bool):
        """
        ...
    def play_sound(self, sound_to_play: SoundBase) -> None:
        r"""
        x.play_sound(sound_to_play) -> None
        Plays a sound through the UI
        deprecated: Use the UGameplayStatics::PlaySound2D instead.
        
        Args:
            sound_to_play (SoundBase):
        """
        ...
    def play_animation_time_range(self, animation: WidgetAnimation, start_at_time: float = 0.000000, end_at_time: float = 0.000000, num_loops_to_play: int = 1, play_mode: UMGSequencePlayMode = UMGSequencePlayMode.FORWARD, playback_speed: float = 1.000000, restore_state: bool = False) -> UMGSequencePlayer:
        r"""
        x.play_animation_time_range(animation, start_at_time=0.000000, end_at_time=0.000000, num_loops_to_play=1, play_mode=UMGSequencePlayMode.FORWARD, playback_speed=1.000000, restore_state=False) -> UMGSequencePlayer
        Plays an animation in this widget a specified number of times stopping at a specified time
        
        Args:
            animation (WidgetAnimation): The animation to play
            start_at_time (float): The time in the animation from which to start playing, relative to the start position. For looped animations, this will only affect the first playback of the animation.
            end_at_time (float): The absolute time in the animation where to stop, this is only considered in the last loop.
            num_loops_to_play (int32): The number of times to loop this animation (0 to loop indefinitely)
            play_mode (UMGSequencePlayMode): Specifies the playback mode
            playback_speed (float): The speed at which the animation should play
            restore_state (bool): Restores widgets to their pre-animated state when the animation stops
        
        Returns:
            UMGSequencePlayer:
        """
        ...
    def play_animation_to(self, animation: WidgetAnimation, start_at_time: float = 0.000000, end_at_time: float = 0.000000, num_loops_to_play: int = 1, play_mode: UMGSequencePlayMode = UMGSequencePlayMode.FORWARD, playback_speed: float = 1.000000, restore_state: bool = False) -> UMGSequencePlayer:
        r"""
        deprecated: 'play_animation_to' was renamed to 'play_animation_time_range'.
        """
        ...
    def play_animation_reverse(self, animation: WidgetAnimation, playback_speed: float = 1.000000, restore_state: bool = False) -> UMGSequencePlayer:
        r"""
        x.play_animation_reverse(animation, playback_speed=1.000000, restore_state=False) -> UMGSequencePlayer
        Plays an animation on this widget relative to it's current state in reverse.  You should use this version in situations where
        say a user can click a button and that causes a panel to slide out, and you want to reverse that same animation to begin sliding
        in the opposite direction.
        
        Args:
            animation (WidgetAnimation): The animation to play
            playback_speed (float): The speed at which the animation should play
            restore_state (bool): Restores widgets to their pre-animated state when the animation stops
        
        Returns:
            UMGSequencePlayer:
        """
        ...
    def play_animation_forward(self, animation: WidgetAnimation, playback_speed: float = 1.000000, restore_state: bool = False) -> UMGSequencePlayer:
        r"""
        x.play_animation_forward(animation, playback_speed=1.000000, restore_state=False) -> UMGSequencePlayer
        Plays an animation on this widget relative to it's current state forward.  You should use this version in situations where
        say a user can click a button and that causes a panel to slide out, and you want to reverse that same animation to begin sliding
        in the opposite direction.
        
        Args:
            animation (WidgetAnimation): The animation to play
            playback_speed (float): The speed at which the animation should play
            restore_state (bool): Restores widgets to their pre-animated state when the animation stops
        
        Returns:
            UMGSequencePlayer:
        """
        ...
    def play_animation(self, animation: WidgetAnimation, start_at_time: float = 0.000000, num_loops_to_play: int = 1, play_mode: UMGSequencePlayMode = UMGSequencePlayMode.FORWARD, playback_speed: float = 1.000000, restore_state: bool = False) -> UMGSequencePlayer:
        r"""
        x.play_animation(animation, start_at_time=0.000000, num_loops_to_play=1, play_mode=UMGSequencePlayMode.FORWARD, playback_speed=1.000000, restore_state=False) -> UMGSequencePlayer
        Plays an animation in this widget a specified number of times
        
        Args:
            animation (WidgetAnimation): The animation to play
            start_at_time (float): The time in the animation from which to start playing, relative to the start position. For looped animations, this will only affect the first playback of the animation.
            num_loops_to_play (int32): The number of times to loop this animation (0 to loop indefinitely)
            play_mode (UMGSequencePlayMode): Specifies the playback mode
            playback_speed (float): The speed at which the animation should play
            restore_state (bool): Restores widgets to their pre-animated state when the animation stops
        
        Returns:
            UMGSequencePlayer:
        """
        ...
    def play_animation_at_time(self, animation: WidgetAnimation, start_at_time: float = 0.000000, num_loops_to_play: int = 1, play_mode: UMGSequencePlayMode = UMGSequencePlayMode.FORWARD, playback_speed: float = 1.000000, restore_state: bool = False) -> UMGSequencePlayer:
        r"""
        deprecated: 'play_animation_at_time' was renamed to 'play_animation'.
        """
        ...
    def pause_animation(self, animation: WidgetAnimation) -> float:
        r"""
        x.pause_animation(animation) -> float
        Pauses an already running animation in this widget
        
        Args:
            animation (WidgetAnimation): 
        
        Returns:
            float: the time point the animation was at when it was paused, relative to its start position.  Use this as the StartAtTime when you trigger PlayAnimation.
        """
        ...
    def on_touch_started(self, my_geometry: Geometry, touch_event: PointerEvent) -> EventReply:
        r"""
        x.on_touch_started(my_geometry, touch_event) -> EventReply
        Called when a touchpad touch is started (finger down)
        
        Args:
            my_geometry (Geometry): The geometry of the widget receiving the event.
            touch_event (PointerEvent): The touch event generated
        
        Returns:
            EventReply:
        """
        ...
    def on_touch_moved(self, my_geometry: Geometry, touch_event: PointerEvent) -> EventReply:
        r"""
        x.on_touch_moved(my_geometry, touch_event) -> EventReply
        Called when a touchpad touch is moved  (finger moved)
        
        Args:
            my_geometry (Geometry): The geometry of the widget receiving the event.
            touch_event (PointerEvent): The touch event generated
        
        Returns:
            EventReply:
        """
        ...
    def on_touch_gesture(self, my_geometry: Geometry, gesture_event: PointerEvent) -> EventReply:
        r"""
        x.on_touch_gesture(my_geometry, gesture_event) -> EventReply
        Called when the user performs a gesture on trackpad. This event is bubbled.
        
        Args:
            my_geometry (Geometry): The geometry of the widget receiving the event.
            gesture_event (PointerEvent): gesture event
        
        Returns:
            EventReply: Returns whether the event was handled, along with other possible actions
        """
        ...
    def on_touch_force_changed(self, my_geometry: Geometry, touch_event: PointerEvent) -> EventReply:
        r"""
        x.on_touch_force_changed(my_geometry, touch_event) -> EventReply
        Called when a touchpad force has changed (user pressed down harder or let up)
        
        Args:
            my_geometry (Geometry): The geometry of the widget receiving the event.
            touch_event (PointerEvent): The touch event generated
        
        Returns:
            EventReply:
        """
        ...
    def on_touch_ended(self, my_geometry: Geometry, touch_event: PointerEvent) -> EventReply:
        r"""
        x.on_touch_ended(my_geometry, touch_event) -> EventReply
        Called when a touchpad touch is ended (finger lifted)
        
        Args:
            my_geometry (Geometry): The geometry of the widget receiving the event.
            touch_event (PointerEvent): The touch event generated
        
        Returns:
            EventReply:
        """
        ...
    def on_removed_from_focus_path(self, focus_event: FocusEvent) -> None:
        r"""
        x.on_removed_from_focus_path(focus_event) -> None
        If focus is lost on on this widget or on a child widget and this widget is
        no longer part of the focus path.
        
        Args:
            focus_event (FocusEvent): FocusEvent
        """
        ...
    def on_preview_mouse_button_down(self, my_geometry: Geometry, mouse_event: PointerEvent) -> EventReply:
        r"""
        x.on_preview_mouse_button_down(my_geometry, mouse_event) -> EventReply
        Just like OnMouseButtonDown, but tunnels instead of bubbling.
        If this event is handled, OnMouseButtonDown will not be sent.
        
        Use this event sparingly as preview events generally make UIs more
        difficult to reason about.
        
        Args:
            my_geometry (Geometry): The Geometry of the widget receiving the event
            mouse_event (PointerEvent): Information about the input event
        
        Returns:
            EventReply: Whether the event was handled along with possible requests for the system to take action.
        """
        ...
    def on_preview_key_down(self, my_geometry: Geometry, key_event: KeyEvent) -> EventReply:
        r"""
        x.on_preview_key_down(my_geometry, key_event) -> EventReply
        Called after a key (keyboard, controller, ...) is pressed when this widget or a child of this widget has focus
        If a widget handles this event, OnKeyDown will *not* be passed to the focused widget.
        
        This event is primarily to allow parent widgets to consume an event before a child widget processes
        it and it should be used only when there is no better design alternative.
        
        Args:
            my_geometry (Geometry): The Geometry of the widget receiving the event
            key_event (KeyEvent): Key event
        
        Returns:
            EventReply: Returns whether the event was handled, along with other possible actions
        """
        ...
    def on_paint(self, context: PaintContext) -> PaintContext:
        r"""
        x.on_paint(context) -> PaintContext
        On Paint
        
        Args:
            context (PaintContext): 
        
        Returns:
            PaintContext: 
        
            context (PaintContext):
        """
        ...
    def on_mouse_wheel(self, my_geometry: Geometry, mouse_event: PointerEvent) -> EventReply:
        r"""
        x.on_mouse_wheel(my_geometry, mouse_event) -> EventReply
        Called when the mouse wheel is spun. This event is bubbled.
        
        Args:
            my_geometry (Geometry): 
            mouse_event (PointerEvent): Mouse event
        
        Returns:
            EventReply: Returns whether the event was handled, along with other possible actions
        """
        ...
    def on_mouse_move(self, my_geometry: Geometry, mouse_event: PointerEvent) -> EventReply:
        r"""
        x.on_mouse_move(my_geometry, mouse_event) -> EventReply
        The system calls this method to notify the widget that a mouse moved within it. This event is bubbled.
        
        Args:
            my_geometry (Geometry): The Geometry of the widget receiving the event
            mouse_event (PointerEvent): Information about the input event
        
        Returns:
            EventReply: Whether the event was handled along with possible requests for the system to take action.
        """
        ...
    def on_mouse_leave(self, mouse_event: PointerEvent) -> None:
        r"""
        x.on_mouse_leave(mouse_event) -> None
        The system will use this event to notify a widget that the cursor has left it. This event is NOT bubbled.
        
        Args:
            mouse_event (PointerEvent): Information about the input event
        """
        ...
    def on_mouse_enter(self, my_geometry: Geometry, mouse_event: PointerEvent) -> None:
        r"""
        x.on_mouse_enter(my_geometry, mouse_event) -> None
        The system will use this event to notify a widget that the cursor has entered it. This event is NOT bubbled.
        
        Args:
            my_geometry (Geometry): The Geometry of the widget receiving the event
            mouse_event (PointerEvent): Information about the input event
        """
        ...
    def on_mouse_capture_lost(self) -> None:
        r"""
        x.on_mouse_capture_lost() -> None
        Called when mouse capture is lost if it was owned by this widget.
        """
        ...
    def on_mouse_button_up(self, my_geometry: Geometry, mouse_event: PointerEvent) -> EventReply:
        r"""
        x.on_mouse_button_up(my_geometry, mouse_event) -> EventReply
        The system calls this method to notify the widget that a mouse button was release within it. This event is bubbled.
        
        Args:
            my_geometry (Geometry): The Geometry of the widget receiving the event
            mouse_event (PointerEvent): Information about the input event
        
        Returns:
            EventReply: Whether the event was handled along with possible requests for the system to take action.
        """
        ...
    def on_mouse_button_down(self, my_geometry: Geometry, mouse_event: PointerEvent) -> EventReply:
        r"""
        x.on_mouse_button_down(my_geometry, mouse_event) -> EventReply
        The system calls this method to notify the widget that a mouse button was pressed within it. This event is bubbled.
        
        Args:
            my_geometry (Geometry): The Geometry of the widget receiving the event
            mouse_event (PointerEvent): Information about the input event
        
        Returns:
            EventReply: Whether the event was handled along with possible requests for the system to take action.
        """
        ...
    def on_mouse_button_double_click(self, my_geometry: Geometry, mouse_event: PointerEvent) -> EventReply:
        r"""
        x.on_mouse_button_double_click(my_geometry, mouse_event) -> EventReply
        Called when a mouse button is double clicked.  Override this in derived classes.
        
        Args:
            my_geometry (Geometry): Widget geometry
            mouse_event (PointerEvent): Mouse button event
        
        Returns:
            EventReply: Returns whether the event was handled, along with other possible actions
        """
        ...
    def on_motion_detected(self, my_geometry: Geometry, motion_event: MotionEvent) -> EventReply:
        r"""
        x.on_motion_detected(my_geometry, motion_event) -> EventReply
        Called when motion is detected (controller or device)
        e.g. Someone tilts or shakes their controller.
        
        Args:
            my_geometry (Geometry): The geometry of the widget receiving the event.
            motion_event (MotionEvent): 
        
        Returns:
            EventReply:
        """
        ...
    def on_key_up(self, my_geometry: Geometry, key_event: KeyEvent) -> EventReply:
        r"""
        x.on_key_up(my_geometry, key_event) -> EventReply
        Called after a key (keyboard, controller, ...) is released when this widget has focus
        
        Args:
            my_geometry (Geometry): The Geometry of the widget receiving the event
            key_event (KeyEvent): Key event
        
        Returns:
            EventReply: Returns whether the event was handled, along with other possible actions
        """
        ...
    def on_key_down(self, my_geometry: Geometry, key_event: KeyEvent) -> EventReply:
        r"""
        x.on_key_down(my_geometry, key_event) -> EventReply
        Called after a key (keyboard, controller, ...) is pressed when this widget has focus (this event bubbles if not handled)
        
        Args:
            my_geometry (Geometry): The Geometry of the widget receiving the event
            key_event (KeyEvent): Key event
        
        Returns:
            EventReply: Returns whether the event was handled, along with other possible actions
        """
        ...
    def on_key_char(self, my_geometry: Geometry, character_event: CharacterEvent) -> EventReply:
        r"""
        x.on_key_char(my_geometry, character_event) -> EventReply
        Called after a character is entered while this widget has focus
        
        Args:
            my_geometry (Geometry): The Geometry of the widget receiving the event
            character_event (CharacterEvent): Character event
        
        Returns:
            EventReply: Returns whether the event was handled, along with other possible actions
        """
        ...
    def on_initialized(self) -> None:
        r"""
        x.on_initialized() -> None
        Called once only at game time on non-template instances.
        While Construct/Destruct pertain to the underlying Slate, this is called only once for the UUserWidget.
        If you have one-time things to establish up-front (like binding callbacks to events on BindWidget properties), do so here.
        """
        ...
    def on_focus_received(self, my_geometry: Geometry, focus_event: FocusEvent) -> EventReply:
        r"""
        x.on_focus_received(my_geometry, focus_event) -> EventReply
        Called when keyboard focus is given to this widget.  This event does not bubble.
        
        Args:
            my_geometry (Geometry): The Geometry of the widget receiving the event
            focus_event (FocusEvent): FocusEvent
        
        Returns:
            EventReply: Returns whether the event was handled, along with other possible actions
        """
        ...
    def on_focus_lost(self, focus_event: FocusEvent) -> None:
        r"""
        x.on_focus_lost(focus_event) -> None
        Called when this widget loses focus.  This event does not bubble.
        
        Args:
            focus_event (FocusEvent): FocusEvent
        """
        ...
    def on_drop(self, my_geometry: Geometry, pointer_event: PointerEvent, operation: DragDropOperation) -> bool:
        r"""
        x.on_drop(my_geometry, pointer_event, operation) -> bool
        Called when the user is dropping something onto a widget.  Ends the drag and drop operation, even if no widget handles this.
        
        Args:
            my_geometry (Geometry): The geometry of the widget receiving the event.
            pointer_event (PointerEvent): The mouse event from when the drag occurred over the widget.
            operation (DragDropOperation): The drag operation over the widget.
        
        Returns:
            bool: 'true' to indicate you handled the drop operation.
        """
        ...
    def on_drag_over(self, my_geometry: Geometry, pointer_event: PointerEvent, operation: DragDropOperation) -> bool:
        r"""
        x.on_drag_over(my_geometry, pointer_event, operation) -> bool
        Called during drag and drop when the the mouse is being dragged over a widget.
        
        Args:
            my_geometry (Geometry): The geometry of the widget receiving the event.
            pointer_event (PointerEvent): The mouse event from when the drag occurred over the widget.
            operation (DragDropOperation): The drag operation over the widget.
        
        Returns:
            bool: 'true' to indicate that you handled the drag over operation.  Returning 'false' will cause the operation to continue to bubble up.
        """
        ...
    def on_drag_leave(self, pointer_event: PointerEvent, operation: DragDropOperation) -> None:
        r"""
        x.on_drag_leave(pointer_event, operation) -> None
        Called during drag and drop when the drag leaves the widget.
        
        Args:
            pointer_event (PointerEvent): The mouse event from when the drag left the widget.
            operation (DragDropOperation): The drag operation that entered the widget.
        """
        ...
    def on_drag_enter(self, my_geometry: Geometry, pointer_event: PointerEvent, operation: DragDropOperation) -> None:
        r"""
        x.on_drag_enter(my_geometry, pointer_event, operation) -> None
        Called during drag and drop when the drag enters the widget.
        
        Args:
            my_geometry (Geometry): The geometry of the widget receiving the event.
            pointer_event (PointerEvent): The mouse event from when the drag entered the widget.
            operation (DragDropOperation): The drag operation that entered the widget.
        """
        ...
    def on_drag_detected(self, my_geometry: Geometry, pointer_event: PointerEvent) -> DragDropOperation:
        r"""
        x.on_drag_detected(my_geometry, pointer_event) -> DragDropOperation
        Called when Slate detects that a widget started to be dragged.
        
        Args:
            my_geometry (Geometry): 
            pointer_event (PointerEvent): MouseMove that triggered the drag
        
        Returns:
            DragDropOperation: 
        
            operation (DragDropOperation): The drag operation that was detected.
        """
        ...
    def on_drag_cancelled(self, pointer_event: PointerEvent, operation: DragDropOperation) -> None:
        r"""
        x.on_drag_cancelled(pointer_event, operation) -> None
        Called when the user cancels the drag operation, typically when they simply release the mouse button after
        beginning a drag operation, but failing to complete the drag.
        
        Args:
            pointer_event (PointerEvent): Last mouse event from when the drag was canceled.
            operation (DragDropOperation): The drag operation that was canceled.
        """
        ...
    def on_animation_started(self, animation: WidgetAnimation) -> None:
        r"""
        x.on_animation_started(animation) -> None
        Called when an animation is started.
        
        Args:
            animation (WidgetAnimation): the animation that started
        """
        ...
    def on_animation_finished(self, animation: WidgetAnimation) -> None:
        r"""
        x.on_animation_finished(animation) -> None
        Called when an animation has either played all the way through or is stopped
        
        Args:
            animation (WidgetAnimation): The animation that has finished playing
        """
        ...
    def on_analog_value_changed(self, my_geometry: Geometry, analog_input_event: AnalogInputEvent) -> EventReply:
        r"""
        x.on_analog_value_changed(my_geometry, analog_input_event) -> EventReply
        Called when an analog value changes on a button that supports analog
        
        Args:
            my_geometry (Geometry): The Geometry of the widget receiving the event
            analog_input_event (AnalogInputEvent): Analog Event
        
        Returns:
            EventReply: Returns whether the event was handled, along with other possible actions
        """
        ...
    def on_added_to_focus_path(self, focus_event: FocusEvent) -> None:
        r"""
        x.on_added_to_focus_path(focus_event) -> None
        If focus is gained on on this widget or on a child widget and this widget is added
        to the focus path, and wasn't previously part of it, this event is called.
        
        Args:
            focus_event (FocusEvent): FocusEvent
        """
        ...
    def listen_for_input_action(self, action_name: Name, event_type: InputEventType, consume: bool, callback: OnInputAction) -> None:
        r"""
        x.listen_for_input_action(action_name, event_type, consume, callback) -> None
        Listens for a particular Player Input Action by name.  This requires that those actions are being executed, and
        that we're not currently in UI-Only Input Mode.
        
        Args:
            action_name (Name): 
            event_type (InputEventType): 
            consume (bool): 
            callback (OnInputAction):
        """
        ...
    def is_playing_animation(self) -> bool:
        r"""
        x.is_playing_animation() -> bool
        Are we currently playing any animations?
        
        Returns:
            bool:
        """
        ...
    def is_listening_for_input_action(self, action_name: Name) -> bool:
        r"""
        x.is_listening_for_input_action(action_name) -> bool
        Checks if the action has a registered callback with the input component.
        
        Args:
            action_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_interactable(self) -> bool:
        r"""
        x.is_interactable() -> bool
        Gets a value indicating if the widget is interactive.
        
        Returns:
            bool:
        """
        ...
    def is_any_animation_playing(self) -> bool:
        r"""
        x.is_any_animation_playing() -> bool
        
        
        Returns:
            bool: True if any animation is currently playing
        """
        ...
    def is_animation_playing_forward(self, animation: WidgetAnimation) -> bool:
        r"""
        x.is_animation_playing_forward(animation) -> bool
        returns true if the animation is currently playing forward, false otherwise.
        
        Args:
            animation (WidgetAnimation): The playing animation that we want to know about
        
        Returns:
            bool:
        """
        ...
    def is_animation_playing(self, animation: WidgetAnimation) -> bool:
        r"""
        x.is_animation_playing(animation) -> bool
        Gets whether an animation is currently playing on this widget.
        
        Args:
            animation (WidgetAnimation): The animation to check the playback status of
        
        Returns:
            bool: True if the animation is currently playing
        """
        ...
    def get_owning_player_pawn(self) -> Pawn:
        r"""
        x.get_owning_player_pawn() -> Pawn
        Gets the player pawn associated with this UI.
        
        Returns:
            Pawn: Gets the owning player pawn that's owned by the player controller assigned to this widget.
        """
        ...
    def get_owning_player_camera_manager(self) -> PlayerCameraManager:
        r"""
        x.get_owning_player_camera_manager() -> PlayerCameraManager
        Gets the player camera manager associated with this UI.
        
        Returns:
            PlayerCameraManager: Gets the owning player camera manager that's owned by the player controller assigned to this widget.
        """
        ...
    def get_is_visible(self) -> bool:
        r"""
        x.get_is_visible() -> bool
        Get Is Visible
        deprecated: Use IsInViewport instead
        
        Returns:
            bool:
        """
        ...
    def get_extensions(self, extension_type: Class) -> Array[UserWidgetExtension]:
        r"""
        x.get_extensions(extension_type) -> Array[UserWidgetExtension]
        Find the extensions of the requested type.
        
        Args:
            extension_type (type(Class)): 
        
        Returns:
            Array[UserWidgetExtension]:
        """
        ...
    def get_extension(self, extension_type: Class) -> UserWidgetExtension:
        r"""
        x.get_extension(extension_type) -> UserWidgetExtension
        Find the first extension of the requested type.
        
        Args:
            extension_type (type(Class)): 
        
        Returns:
            UserWidgetExtension:
        """
        ...
    def get_animation_current_time(self, animation: WidgetAnimation) -> float:
        r"""
        x.get_animation_current_time(animation) -> float
        Gets the current time of the animation in this widget
        
        Args:
            animation (WidgetAnimation): 
        
        Returns:
            float: the current time of the animation.
        """
        ...
    def get_anchors_in_viewport(self) -> Anchors:
        r"""
        x.get_anchors_in_viewport() -> Anchors
        Get Anchors in Viewport
        
        Returns:
            Anchors:
        """
        ...
    def get_alignment_in_viewport(self) -> Vector2D:
        r"""
        x.get_alignment_in_viewport() -> Vector2D
        Get Alignment in Viewport
        
        Returns:
            Vector2D:
        """
        ...
    def flush_animations(self) -> None:
        r"""
        x.flush_animations() -> None
        Flushes all animations on all widgets to guarantee that any queued updates are processed before this call returns
        """
        ...
    def destruct(self) -> None:
        r"""
        x.destruct() -> None
        Called when a widget is no longer referenced causing the slate resource to destroyed.  Just like
        Construct this event can be called multiple times.
        """
        ...
    def construct(self) -> None:
        r"""
        x.construct() -> None
        Called after the underlying slate widget is constructed.  Depending on how the slate object is used
        this event may be called multiple times due to adding and removing from the hierarchy.
        If you need a true called-once-when-created event, use OnInitialized.
        """
        ...
    def cancel_latent_actions(self) -> None:
        r"""
        x.cancel_latent_actions() -> None
        Cancels any pending Delays or timer callbacks for this widget.
        """
        ...
    def bind_to_animation_started(self, animation: WidgetAnimation, delegate: WidgetAnimationDynamicEvent) -> None:
        r"""
        x.bind_to_animation_started(animation, delegate) -> None
        Bind an animation started delegate.
        
        Args:
            animation (WidgetAnimation): the animation to listen for starting or finishing.
            delegate (WidgetAnimationDynamicEvent): the delegate to call when the animation's state changes
        """
        ...
    def bind_to_animation_finished(self, animation: WidgetAnimation, delegate: WidgetAnimationDynamicEvent) -> None:
        r"""
        x.bind_to_animation_finished(animation, delegate) -> None
        Bind an animation finished delegate.
        
        Args:
            animation (WidgetAnimation): the animation to listen for starting or finishing.
            delegate (WidgetAnimationDynamicEvent): the delegate to call when the animation's state changes
        """
        ...
    def bind_to_animation_event(self, animation: WidgetAnimation, delegate: WidgetAnimationDynamicEvent, animation_event: WidgetAnimationEvent, user_tag: Name = "None") -> None:
        r"""
        x.bind_to_animation_event(animation, delegate, animation_event, user_tag="None") -> None
        Allows binding to a specific animation's event.
        
        Args:
            animation (WidgetAnimation): the animation to listen for starting or finishing.
            delegate (WidgetAnimationDynamicEvent): the delegate to call when the animation's state changes
            animation_event (WidgetAnimationEvent): the event to watch for.
            user_tag (Name): Scopes the delegate to only be called when the animation completes with a specific tag set on it when it was played.
        """
        ...
    def add_to_viewport(self, z_order: int = 0) -> None:
        r"""
        x.add_to_viewport(z_order=0) -> None
        Adds it to the game's viewport and fills the entire screen, unless SetDesiredSizeInViewport is called
        to explicitly set the size.
        
        Args:
            z_order (int32): The higher the number, the more on top this widget will be.
        """
        ...
    def add_to_player_screen(self, z_order: int = 0) -> bool:
        r"""
        x.add_to_player_screen(z_order=0) -> bool
        Adds the widget to the game's viewport in a section dedicated to the player.  This is valuable in a split screen
        game where you need to only show a widget over a player's portion of the viewport.
        
        Args:
            z_order (int32): The higher the number, the more on top this widget will be.
        
        Returns:
            bool:
        """
        ...
    def add_extension(self, extension_type: Class) -> UserWidgetExtension:
        r"""
        x.add_extension(extension_type) -> UserWidgetExtension
        Add the extension of the requested type.
        
        Args:
            extension_type (type(Class)): 
        
        Returns:
            UserWidgetExtension:
        """
        ...

class VREditorBaseUserWidget(UserWidget):
    r"""
    Base class for all of the VR widgets
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorBaseUserWidget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``color_and_opacity`` (LinearColor):  [Read-Write] The color and opacity of this widget.  Tints all child widgets.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``desired_focus_widget`` (WidgetChild):  [Read-Write]
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``foreground_color`` (SlateColor):  [Read-Write] The foreground color of the widget, this is inherited by sub widgets.  Any color property
      that is marked as inherit will use this color.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Setting this flag to true, allows this widget to accept focus when clicked, or when navigated to.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_visibility_changed`` (OnVisibilityChangedEvent):  [Read-Write] Called when the visibility has changed
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``padding`` (Margin):  [Read-Write] The padding area around the content.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``preview_background`` (Texture2D):  [Read-Write] A preview background that you can use when designing the UI to get a sense of scale on the screen.  Use
      a texture with a screenshot of your game in it, for example if you were designing a HUD.
    - ``priority`` (int32):  [Read-Write]
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``stop_action`` (bool):  [Read-Write]
    - ``tick_frequency`` (WidgetTickFrequency):  [Read-Write] This widget is allowed to tick. If this is unchecked tick will never be called, animations will not play correctly, and latent actions will not execute.
      Uncheck this for performance reasons only
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    ...

class ActorComponent(Object):
    r"""
    ActorComponent is the base class for components that define reusable behavior that can be added to different types of Actors.
    ActorComponents that have a transform are known as SceneComponents and those that can be rendered are PrimitiveComponents.
    see: [ActorComponent](https://docs.unrealengine.com/latest/INT/Programming/UnrealArchitecture/Actors/Components/index.html#actorcomponents)
    see: USceneComponent
    see: UPrimitiveComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ActorComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def component_tags(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
        """
        ...
    @component_tags.setter
    def component_tags(self, value: Array[Name]) -> None:
        ...
    @property
    def replicate_using_registered_sub_object_list(self) -> bool:
        r"""
        (bool):  [Read-Only] When true the replication system will only replicate the registered subobjects list
        When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
        """
        ...
    @property
    def replicates(self) -> bool:
        r"""
        (bool):  [Read-Only] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
        """
        ...
    @property
    def auto_activate(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the component is activated at creation or must be explicitly activated.
        """
        ...
    @property
    def is_editor_only(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, the component will be excluded from non-editor builds
        """
        ...
    @property
    def on_component_activated(self) -> ActorComponentActivatedSignature:
        r"""
        (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
        """
        ...
    @on_component_activated.setter
    def on_component_activated(self, value: ActorComponentActivatedSignature) -> None:
        ...
    @property
    def on_component_deactivated(self) -> ActorComponentDeactivateSignature:
        r"""
        (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
        """
        ...
    @on_component_deactivated.setter
    def on_component_deactivated(self, value: ActorComponentDeactivateSignature) -> None:
        ...
    def toggle_active(self) -> None:
        r"""
        x.toggle_active() -> None
        Toggles the active state of the component
        """
        ...
    def set_tick_group(self, new_tick_group: TickingGroup) -> None:
        r"""
        x.set_tick_group(new_tick_group) -> None
        Changes the ticking group for this component
        
        Args:
            new_tick_group (TickingGroup):
        """
        ...
    def set_tickable_when_paused(self, tickable_when_paused: bool) -> None:
        r"""
        x.set_tickable_when_paused(tickable_when_paused) -> None
        Sets whether this component can tick when paused.
        
        Args:
            tickable_when_paused (bool):
        """
        ...
    def set_is_replicated(self, should_replicate: bool) -> None:
        r"""
        x.set_is_replicated(should_replicate) -> None
        Enable or disable replication. This is the equivalent of RemoteRole for actors (only a bool is required for components)
        
        Args:
            should_replicate (bool):
        """
        ...
    def set_component_tick_interval_and_cooldown(self, tick_interval: float) -> None:
        r"""
        x.set_component_tick_interval_and_cooldown(tick_interval) -> None
        Sets the tick interval for this component's primary tick function. Does not enable the tick interval. Takes effect imediately.
        
        Args:
            tick_interval (float): The duration between ticks for this component's primary tick function
        """
        ...
    def set_component_tick_interval(self, tick_interval: float) -> None:
        r"""
        x.set_component_tick_interval(tick_interval) -> None
        Sets the tick interval for this component's primary tick function. Does not enable the tick interval. Takes effect on next tick.
        
        Args:
            tick_interval (float): The duration between ticks for this component's primary tick function
        """
        ...
    def set_component_tick_enabled(self, enabled: bool) -> None:
        r"""
        x.set_component_tick_enabled(enabled) -> None
        Set this component's tick functions to be enabled or disabled. Only has an effect if the function is registered
        
        Args:
            enabled (bool): Whether it should be enabled or not
        """
        ...
    def set_auto_activate(self, new_auto_activate: bool) -> None:
        r"""
        x.set_auto_activate(new_auto_activate) -> None
        Sets whether the component should be auto activate or not. Only safe during construction scripts.
        
        Args:
            new_auto_activate (bool): The new auto activate state of the component
        """
        ...
    def set_active(self, new_active: bool, reset: bool = False) -> None:
        r"""
        x.set_active(new_active, reset=False) -> None
        Sets whether the component is active or not
        
        Args:
            new_active (bool): The new active state of the component
            reset (bool): Whether the activation should happen even if ShouldActivate returns false.
        """
        ...
    def remove_tick_prerequisite_component(self, prerequisite_component: ActorComponent) -> None:
        r"""
        x.remove_tick_prerequisite_component(prerequisite_component) -> None
        Remove tick dependency on PrerequisiteComponent.
        
        Args:
            prerequisite_component (ActorComponent):
        """
        ...
    def remove_tick_prerequisite_actor(self, prerequisite_actor: Actor) -> None:
        r"""
        x.remove_tick_prerequisite_actor(prerequisite_actor) -> None
        Remove tick dependency on PrerequisiteActor.
        
        Args:
            prerequisite_actor (Actor):
        """
        ...
    def receive_tick(self, delta_seconds: float) -> None:
        r"""
        x.receive_tick(delta_seconds) -> None
        Event called every frame if tick is enabled
        
        Args:
            delta_seconds (float):
        """
        ...
    def receive_end_play(self, end_play_reason: EndPlayReason) -> None:
        r"""
        x.receive_end_play(end_play_reason) -> None
        Blueprint implementable event for when the component ends play, generally via destruction or its Actor's EndPlay.
        
        Args:
            end_play_reason (EndPlayReason):
        """
        ...
    def receive_uninitialize_component(self, end_play_reason: EndPlayReason) -> None:
        r"""
        deprecated: 'receive_uninitialize_component' was renamed to 'receive_end_play'.
        """
        ...
    def receive_begin_play(self) -> None:
        r"""
        x.receive_begin_play() -> None
        Blueprint implementable event for when the component is beginning play, called before its owning actor's BeginPlay
        or when the component is dynamically created if the Actor has already BegunPlay.
        """
        ...
    def receive_initialize_component(self) -> None:
        r"""
        deprecated: 'receive_initialize_component' was renamed to 'receive_begin_play'.
        """
        ...
    def receive_async_physics_tick(self, delta_seconds: float, sim_seconds: float) -> None:
        r"""
        x.receive_async_physics_tick(delta_seconds, sim_seconds) -> None
        Event called every async physics tick if bAsyncPhysicsTickEnabled is true
        
        Args:
            delta_seconds (float): 
            sim_seconds (float):
        """
        ...
    def destroy_component(self, object: Object) -> None:
        r"""
        x.destroy_component(object) -> None
        Unregister and mark for pending kill a component.  This may not be used to destroy a component that is owned by an actor unless the owning actor is calling the function.
        
        Args:
            object (Object):
        """
        ...
    def is_component_tick_enabled(self) -> bool:
        r"""
        x.is_component_tick_enabled() -> bool
        Returns whether this component has tick enabled or not
        
        Returns:
            bool:
        """
        ...
    def is_being_destroyed(self) -> bool:
        r"""
        x.is_being_destroyed() -> bool
        Returns whether the component is in the process of being destroyed.
        
        Returns:
            bool:
        """
        ...
    def is_active(self) -> bool:
        r"""
        x.is_active() -> bool
        Returns whether the component is active or not
        
        Returns:
            bool: The active state of the component.
        """
        ...
    def get_owner(self) -> Actor:
        r"""
        x.get_owner() -> Actor
        Follow the Outer chain to get the  AActor  that 'Owns' this component
        
        Returns:
            Actor:
        """
        ...
    def get_component_tick_interval(self) -> float:
        r"""
        x.get_component_tick_interval() -> float
        Returns the tick interval for this component's primary tick function, which is the frequency in seconds at which it will be executed
        
        Returns:
            float:
        """
        ...
    def deactivate(self) -> None:
        r"""
        x.deactivate() -> None
        Deactivates the SceneComponent.
        """
        ...
    def component_has_tag(self, tag: Name) -> bool:
        r"""
        x.component_has_tag(tag) -> bool
        See if this component contains the supplied tag
        
        Args:
            tag (Name): 
        
        Returns:
            bool:
        """
        ...
    def add_tick_prerequisite_component(self, prerequisite_component: ActorComponent) -> None:
        r"""
        x.add_tick_prerequisite_component(prerequisite_component) -> None
        Make this component tick after PrerequisiteComponent.
        
        Args:
            prerequisite_component (ActorComponent):
        """
        ...
    def add_tick_prerequisite_actor(self, prerequisite_actor: Actor) -> None:
        r"""
        x.add_tick_prerequisite_actor(prerequisite_actor) -> None
        Make this component tick after PrerequisiteActor
        
        Args:
            prerequisite_actor (Actor):
        """
        ...
    def activate(self, reset: bool = False) -> None:
        r"""
        x.activate(reset=False) -> None
        Activates the SceneComponent, should be overridden by native child classes.
        
        Args:
            reset (bool): Whether the activation should happen even if ShouldActivate returns false.
        """
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...
    def acquire_editor_element_handle(self, allow_create: bool = True) -> ScriptTypedElementHandle:
        r"""
        x.acquire_editor_element_handle(allow_create=True) -> ScriptTypedElementHandle
        K2 Acquire Editor Component Element Handle
        
        Args:
            allow_create (bool): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...

class SceneComponent(ActorComponent):
    r"""
    A SceneComponent has a transform and supports attachment, but has no rendering or collision capabilities.
    Useful as a 'dummy' component in the hierarchy to offset others.
    see: [Scene Components](https://docs.unrealengine.com/latest/INT/Programming/UnrealArchitecture/Actors/Components/index.html#scenecomponents)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def relative_location(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Location of the component relative to its parent
        """
        ...
    @property
    def relative_translation(self) -> Vector:
        r"""
        deprecated: 'relative_translation' was renamed to 'relative_location'.
        """
        ...
    @property
    def relative_rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] Rotation of the component relative to its parent
        """
        ...
    @property
    def relative_scale3d(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Non-uniform scaling of the component relative to its parent.
        Note that scaling is always applied in local space (no shearing etc)
        """
        ...
    @property
    def absolute_location(self) -> bool:
        r"""
        (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
        """
        ...
    @absolute_location.setter
    def absolute_location(self, value: bool) -> None:
        ...
    @property
    def b_absolute_translation(self) -> bool:
        r"""
        deprecated: 'b_absolute_translation' was renamed to 'absolute_location'.
        """
        ...
    @b_absolute_translation.setter
    def b_absolute_translation(self, value: bool) -> None:
        ...
    @property
    def absolute_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
        """
        ...
    @absolute_rotation.setter
    def absolute_rotation(self, value: bool) -> None:
        ...
    @property
    def absolute_scale(self) -> bool:
        r"""
        (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
        """
        ...
    @absolute_scale.setter
    def absolute_scale(self, value: bool) -> None:
        ...
    @property
    def visible(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
        """
        ...
    @property
    def should_update_physics_volume(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
        see: GetPhysicsVolume()
        """
        ...
    @should_update_physics_volume.setter
    def should_update_physics_volume(self, value: bool) -> None:
        ...
    @property
    def hidden_in_game(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to hide the primitive in game, if the primitive is Visible.
        """
        ...
    @property
    def use_attach_parent_bound(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
        This can be a significant optimization with many components attached together.
        """
        ...
    @use_attach_parent_bound.setter
    def use_attach_parent_bound(self, value: bool) -> None:
        ...
    @property
    def mobility(self) -> ComponentMobility:
        r"""
        (ComponentMobility):  [Read-Only] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
        """
        ...
    @property
    def modify_frequency(self) -> ComponentMobility:
        r"""
        deprecated: 'modify_frequency' was renamed to 'mobility'.
        """
        ...
    @property
    def detail_mode(self) -> DetailMode:
        r"""
        (DetailMode):  [Read-Only] If detail mode is >= system detail mode, primitive won't be rendered.
        """
        ...
    @property
    def physics_volume_changed_delegate(self) -> PhysicsVolumeChanged:
        r"""
        (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
        """
        ...
    @physics_volume_changed_delegate.setter
    def physics_volume_changed_delegate(self, value: PhysicsVolumeChanged) -> None:
        ...
    def toggle_visibility(self, propagate_to_children: bool = False) -> None:
        r"""
        x.toggle_visibility(propagate_to_children=False) -> None
        Toggle visibility of the component
        
        Args:
            propagate_to_children (bool):
        """
        ...
    def set_world_scale3d(self, new_scale: Vector) -> None:
        r"""
        x.set_world_scale3d(new_scale) -> None
        Set the relative scale of the component to put it at the supplied scale in world space.
        
        Args:
            new_scale (Vector): New scale in world space for this component.
        """
        ...
    def set_visibility(self, new_visibility: bool, propagate_to_children: bool = False) -> None:
        r"""
        x.set_visibility(new_visibility, propagate_to_children=False) -> None
        Set visibility of the component, if during game use this to turn on/off
        
        Args:
            new_visibility (bool): 
            propagate_to_children (bool):
        """
        ...
    def set_relative_scale3d(self, new_scale3d: Vector) -> None:
        r"""
        x.set_relative_scale3d(new_scale3d) -> None
        Set the non-uniform scale of the component relative to its parent
        
        Args:
            new_scale3d (Vector):
        """
        ...
    def set_mobility(self, new_mobility: ComponentMobility) -> None:
        r"""
        x.set_mobility(new_mobility) -> None
        Set how often this component is allowed to move during runtime. Causes a component re-register if the component is already registered
        
        Args:
            new_mobility (ComponentMobility):
        """
        ...
    def set_hidden_in_game(self, new_hidden: bool, propagate_to_children: bool = False) -> None:
        r"""
        x.set_hidden_in_game(new_hidden, propagate_to_children=False) -> None
        Changes the value of bHiddenInGame, if false this will disable Visibility during gameplay
        
        Args:
            new_hidden (bool): 
            propagate_to_children (bool):
        """
        ...
    def set_absolute(self, new_absolute_location: bool = False, new_absolute_rotation: bool = False, new_absolute_scale: bool = False) -> None:
        r"""
        x.set_absolute(new_absolute_location=False, new_absolute_rotation=False, new_absolute_scale=False) -> None
        Set which parts of the relative transform should be relative to parent, and which should be relative to world
        
        Args:
            new_absolute_location (bool): 
            new_absolute_rotation (bool): 
            new_absolute_scale (bool):
        """
        ...
    def reset_relative_transform(self) -> None:
        r"""
        x.reset_relative_transform() -> None
        Reset the transform of the component relative to its parent. Sets relative location to zero, relative rotation to no rotation, and Scale to 1.
        """
        ...
    def set_world_transform(self, new_transform: Transform, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.set_world_transform(new_transform, sweep, teleport) -> HitResult
        Set the transform of the component in world space.
        
        Args:
            new_transform (Transform): New transform in world space for the component.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def set_world_rotation(self, new_rotation: Rotator, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.set_world_rotation(new_rotation, sweep, teleport) -> HitResult
        * Put this component at the specified rotation in world space. Updates relative rotation to achieve the final world rotation.
        *
        
        Args:
            new_rotation (Rotator): New rotation in world space for the component. *
            sweep (bool): Whether we sweep to the destination (currently not supported for rotation). *
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). *                                                      If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). *                                                      If false, physics velocity is updated based on the change in position (affecting ragdoll parts). *                                                      If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true. *
        """
        ...
    def set_world_location_and_rotation(self, new_location: Vector, new_rotation: Rotator, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.set_world_location_and_rotation(new_location, new_rotation, sweep, teleport) -> HitResult
        Set the relative location and rotation of the component to put it at the supplied pose in world space.
        
        Args:
            new_location (Vector): New location in world space for the component.
            new_rotation (Rotator): New rotation in world space for the component.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def set_world_location(self, new_location: Vector, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.set_world_location(new_location, sweep, teleport) -> HitResult
        Put this component at the specified location in world space. Updates relative location to achieve the final world location.
        
        Args:
            new_location (Vector): New location in world space for the component.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def set_relative_transform(self, new_transform: Transform, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.set_relative_transform(new_transform, sweep, teleport) -> HitResult
        Set the transform of the component relative to its parent
        
        Args:
            new_transform (Transform): New transform of the component relative to its parent.
            sweep (bool): Whether we sweep to the destination (currently not supported for rotation).
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def set_relative_rotation(self, new_rotation: Rotator, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.set_relative_rotation(new_rotation, sweep, teleport) -> HitResult
        Set the rotation of the component relative to its parent
        
        Args:
            new_rotation (Rotator): New rotation of the component relative to its parent
            sweep (bool): Whether we sweep to the destination (currently not supported for rotation).
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def set_relative_location_and_rotation(self, new_location: Vector, new_rotation: Rotator, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.set_relative_location_and_rotation(new_location, new_rotation, sweep, teleport) -> HitResult
        Set the location and rotation of the component relative to its parent
        
        Args:
            new_location (Vector): New location of the component relative to its parent.
            new_rotation (Rotator): New rotation of the component relative to its parent.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def set_relative_location(self, new_location: Vector, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.set_relative_location(new_location, sweep, teleport) -> HitResult
        Set the location of the component relative to its parent
        
        Args:
            new_location (Vector): New location of the component relative to its parent.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def get_world_transform(self) -> Transform:
        r"""
        x.get_world_transform() -> Transform
        Get the current component-to-world transform for this component
        
        Returns:
            Transform:
        """
        ...
    def get_world_scale(self) -> Vector:
        r"""
        x.get_world_scale() -> Vector
        Returns scale of the component, in world space.
        
        Returns:
            Vector:
        """
        ...
    def get_world_rotation(self) -> Rotator:
        r"""
        x.get_world_rotation() -> Rotator
        Returns rotation of the component, in world space.
        
        Returns:
            Rotator:
        """
        ...
    def get_world_location(self) -> Vector:
        r"""
        x.get_world_location() -> Vector
        Return location of the component, in world space
        
        Returns:
            Vector:
        """
        ...
    def detach_from_component(self, location_rule: DetachmentRule = DetachmentRule.KEEP_RELATIVE, rotation_rule: DetachmentRule = DetachmentRule.KEEP_RELATIVE, scale_rule: DetachmentRule = DetachmentRule.KEEP_RELATIVE, call_modify: bool = True) -> None:
        r"""
        x.detach_from_component(location_rule=DetachmentRule.KEEP_RELATIVE, rotation_rule=DetachmentRule.KEEP_RELATIVE, scale_rule=DetachmentRule.KEEP_RELATIVE, call_modify=True) -> None
        Detach this component from whatever it is attached to. Automatically unwelds components that are welded together (see AttachToComponent), though note that some effects of welding may not be undone.
        
        Args:
            location_rule (DetachmentRule): How to handle translations when detaching.
            rotation_rule (DetachmentRule): How to handle rotation when detaching.
            scale_rule (DetachmentRule): How to handle scales when detaching.
            call_modify (bool): If true, call Modify() on the component and the current attach parent component
        """
        ...
    def attach_to_component(self, parent: SceneComponent, socket_name: Name, location_rule: AttachmentRule, rotation_rule: AttachmentRule, scale_rule: AttachmentRule, weld_simulated_bodies: bool = True) -> bool:
        r"""
        x.attach_to_component(parent, socket_name, location_rule, rotation_rule, scale_rule, weld_simulated_bodies=True) -> bool
        Attach this component to another scene component, optionally at a named socket. It is valid to call this on components whether or not they have been Registered.
        
        Args:
            parent (SceneComponent): Parent to attach to.
            socket_name (Name): Optional socket to attach to on the parent.
            location_rule (AttachmentRule): How to handle translation when attaching.
            rotation_rule (AttachmentRule): How to handle rotation when attaching.
            scale_rule (AttachmentRule): How to handle scale when attaching.
            weld_simulated_bodies (bool): Whether to weld together simulated physics bodies. This transfers the shapes in the welded object into the parent (if simulated), which can result in permanent changes that persist even after subsequently detaching.
        
        Returns:
            bool: True if attachment is successful (or already attached to requested parent/socket), false if attachment is rejected and there is no change in AttachParent.
        """
        ...
    def k2_attach_to(self, parent: SceneComponent, socket_name: Name = "None", attach_type: AttachLocation = AttachLocation.KEEP_RELATIVE_OFFSET, weld_simulated_bodies: bool = True) -> bool:
        r"""
        x.k2_attach_to(parent, socket_name="None", attach_type=AttachLocation.KEEP_RELATIVE_OFFSET, weld_simulated_bodies=True) -> bool
        K2 Attach To
        
        Args:
            parent (SceneComponent): 
            socket_name (Name): 
            attach_type (AttachLocation): 
            weld_simulated_bodies (bool): 
        
        Returns:
            bool:
        """
        ...
    def attach_to(self, parent: SceneComponent, socket_name: Name = "None", attach_type: AttachLocation = AttachLocation.KEEP_RELATIVE_OFFSET, weld_simulated_bodies: bool = True) -> bool:
        r"""
        deprecated: 'attach_to' was renamed to 'k2_attach_to'.
        """
        ...
    def add_world_transform_keep_scale(self, delta_transform: Transform, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_world_transform_keep_scale(delta_transform, sweep, teleport) -> HitResult
        Adds a delta to the transform of the component in world space. Scale is unchanged.
        
        Args:
            delta_transform (Transform): Change in transform in world space for the component. Scale is ignored since we preserve the original scale.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def add_world_transform(self, delta_transform: Transform, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_world_transform(delta_transform, sweep, teleport) -> HitResult
        Adds a delta to the transform of the component in world space. Ignores scale and sets it to (1,1,1).
        
        Args:
            delta_transform (Transform): Change in transform in world space for the component. Scale is ignored.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def add_world_rotation(self, delta_rotation: Rotator, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_world_rotation(delta_rotation, sweep, teleport) -> HitResult
        Adds a delta to the rotation of the component in world space.
        
        Args:
            delta_rotation (Rotator): Change in rotation in world space for the component.
            sweep (bool): Whether we sweep to the destination (currently not supported for rotation).
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def add_world_offset(self, delta_location: Vector, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_world_offset(delta_location, sweep, teleport) -> HitResult
        Adds a delta to the location of the component in world space.
        
        Args:
            delta_location (Vector): Change in location in world space for the component.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def add_relative_rotation(self, delta_rotation: Rotator, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_relative_rotation(delta_rotation, sweep, teleport) -> HitResult
        Adds a delta the rotation of the component relative to its parent
        
        Args:
            delta_rotation (Rotator): Change in rotation of the component relative to is parent.
            sweep (bool): Whether we sweep to the destination (currently not supported for rotation).
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def add_relative_location(self, delta_location: Vector, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_relative_location(delta_location, sweep, teleport) -> HitResult
        Adds a delta to the translation of the component relative to its parent
        
        Args:
            delta_location (Vector): Change in location of the component relative to its parent
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def add_local_transform(self, delta_transform: Transform, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_local_transform(delta_transform, sweep, teleport) -> HitResult
        Adds a delta to the transform of the component in its local reference frame. Scale is unchanged.
        
        Args:
            delta_transform (Transform): Change in transform of the component in its local reference frame. Scale is unchanged.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def add_local_rotation(self, delta_rotation: Rotator, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_local_rotation(delta_rotation, sweep, teleport) -> HitResult
        Adds a delta to the rotation of the component in its local reference frame
        
        Args:
            delta_rotation (Rotator): Change in rotation of the component in its local reference frame.
            sweep (bool): Whether we sweep to the destination (currently not supported for rotation).
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def add_local_offset(self, delta_location: Vector, sweep: bool, teleport: bool) -> HitResult:
        r"""
        x.add_local_offset(delta_location, sweep, teleport) -> HitResult
        Adds a delta to the location of the component in its local reference frame
        
        Args:
            delta_location (Vector): Change in location of the component in its local reference frame.
            sweep (bool): Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
            teleport (bool): Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
        
        Returns:
            HitResult: 
        
            sweep_hit_result (HitResult): Hit result from any impact if sweep is true.
        """
        ...
    def is_visible(self) -> bool:
        r"""
        x.is_visible() -> bool
        Returns true if this component is visible in the current context
        
        Returns:
            bool:
        """
        ...
    def is_simulating_physics(self, bone_name: Name = "None") -> bool:
        r"""
        x.is_simulating_physics(bone_name="None") -> bool
        Returns whether the specified body is currently using physics simulation
        
        Args:
            bone_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_any_simulating_physics(self) -> bool:
        r"""
        x.is_any_simulating_physics() -> bool
        Returns whether the specified body is currently using physics simulation
        
        Returns:
            bool:
        """
        ...
    def get_up_vector(self) -> Vector:
        r"""
        x.get_up_vector() -> Vector
        Get the up (Z) unit direction vector from this component, in world space.
        
        Returns:
            Vector:
        """
        ...
    def get_socket_transform(self, socket_name: Name, transform_space: RelativeTransformSpace = RelativeTransformSpace.RTS_WORLD) -> Transform:
        r"""
        x.get_socket_transform(socket_name, transform_space=RelativeTransformSpace.RTS_WORLD) -> Transform
        Get world-space socket transform.
        
        Args:
            socket_name (Name): Name of the socket or the bone to get the transform
            transform_space (RelativeTransformSpace): 
        
        Returns:
            Transform: Socket transform in world space if socket if found. Otherwise it will return component's transform in world space.
        """
        ...
    def get_socket_rotation(self, socket_name: Name) -> Rotator:
        r"""
        x.get_socket_rotation(socket_name) -> Rotator
        Get world-space socket or bone  FRotator rotation.
        
        Args:
            socket_name (Name): Name of the socket or the bone to get the transform
        
        Returns:
            Rotator: Socket transform in world space if socket if found. Otherwise it will return component's transform in world space.
        """
        ...
    def get_socket_quaternion(self, socket_name: Name) -> Quat:
        r"""
        x.get_socket_quaternion(socket_name) -> Quat
        Get world-space socket or bone FQuat rotation.
        deprecated: Use GetSocketRotation instead, Quat is not fully supported in blueprints.
        
        Args:
            socket_name (Name): Name of the socket or the bone to get the transform
        
        Returns:
            Quat: Socket transform in world space if socket if found. Otherwise it will return component's transform in world space.
        """
        ...
    def get_socket_location(self, socket_name: Name) -> Vector:
        r"""
        x.get_socket_location(socket_name) -> Vector
        Get world-space socket or bone location.
        
        Args:
            socket_name (Name): Name of the socket or the bone to get the transform
        
        Returns:
            Vector: Socket transform in world space if socket is found. Otherwise it will return component's transform in world space.
        """
        ...
    def get_right_vector(self) -> Vector:
        r"""
        x.get_right_vector() -> Vector
        Get the right (Y) unit direction vector from this component, in world space.
        
        Returns:
            Vector:
        """
        ...
    def get_relative_transform(self) -> Transform:
        r"""
        x.get_relative_transform() -> Transform
        Returns the transform of the component relative to its parent
        
        Returns:
            Transform:
        """
        ...
    def get_physics_volume(self) -> PhysicsVolume:
        r"""
        x.get_physics_volume() -> PhysicsVolume
        Get the PhysicsVolume overlapping this component.
        
        Returns:
            PhysicsVolume:
        """
        ...
    def get_parent_components(self) -> Array[SceneComponent]:
        r"""
        x.get_parent_components() -> Array[SceneComponent]
        Gets all attachment parent components up to and including the root component
        
        Returns:
            Array[SceneComponent]: 
        
            parents (Array[SceneComponent]):
        """
        ...
    def get_num_children_components(self) -> int:
        r"""
        x.get_num_children_components() -> int32
        Gets the number of attached children components
        
        Returns:
            int32:
        """
        ...
    def get_forward_vector(self) -> Vector:
        r"""
        x.get_forward_vector() -> Vector
        Get the forward (X) unit direction vector from this component, in world space.
        
        Returns:
            Vector:
        """
        ...
    def get_component_velocity(self) -> Vector:
        r"""
        x.get_component_velocity() -> Vector
        Get velocity of the component: either ComponentVelocity, or the velocity of the physics body if simulating physics.
        
        Returns:
            Vector: Velocity of the component
        """
        ...
    def get_children_components(self, include_all_descendants: bool) -> Array[SceneComponent]:
        r"""
        x.get_children_components(include_all_descendants) -> Array[SceneComponent]
        Gets all components that are attached to this component, possibly recursively
        
        Args:
            include_all_descendants (bool): Whether to include all descendants in the list of children (i.e. grandchildren, great grandchildren, etc.)
        
        Returns:
            Array[SceneComponent]: 
        
            children (Array[SceneComponent]): The list of attached child components
        """
        ...
    def get_child_component(self, child_index: int) -> SceneComponent:
        r"""
        x.get_child_component(child_index) -> SceneComponent
        Gets the attached child component at the specified location
        
        Args:
            child_index (int32): 
        
        Returns:
            SceneComponent:
        """
        ...
    def get_attach_socket_name(self) -> Name:
        r"""
        x.get_attach_socket_name() -> Name
        Get the socket we are attached to.
        
        Returns:
            Name:
        """
        ...
    def get_attach_parent(self) -> SceneComponent:
        r"""
        x.get_attach_parent() -> SceneComponent
        Get the SceneComponent we are attached to.
        
        Returns:
            SceneComponent:
        """
        ...
    def get_all_socket_names(self) -> Array[Name]:
        r"""
        x.get_all_socket_names() -> Array[Name]
        Gets the names of all the sockets on the component.
        
        Returns:
            Array[Name]: Get the names of all the sockets on the component.
        """
        ...
    def does_socket_exist(self, socket_name: Name) -> bool:
        r"""
        x.does_socket_exist(socket_name) -> bool
        Return true if socket with the given name exists
        
        Args:
            socket_name (Name): Name of the socket or the bone to get the transform
        
        Returns:
            bool:
        """
        ...
    def detach_from_parent(self, maintain_world_position: bool = False, call_modify: bool = True) -> None:
        r"""
        x.detach_from_parent(maintain_world_position=False, call_modify=True) -> None
        Detach from Parent
        
        Args:
            maintain_world_position (bool): 
            call_modify (bool):
        """
        ...

class PrimitiveComponent(SceneComponent):
    r"""
    PrimitiveComponents are SceneComponents that contain or generate some sort of geometry, generally to be rendered or used as collision data.
    There are several subclasses for the various types of geometry, but the most common by far are the ShapeComponents (Capsule, Sphere, Box), StaticMeshComponent, and SkeletalMeshComponent.
    ShapeComponents generate geometry that is used for collision detection but are not rendered, while StaticMeshComponents and SkeletalMeshComponents contain pre-built geometry that is rendered, but can also be used for collision detection.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimitiveComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def min_draw_distance(self) -> float:
        r"""
        (float):  [Read-Only] The minimum distance at which the primitive should be rendered,
        measured in world space units from the center of the primitive's bounding sphere to the camera position.
        """
        ...
    @property
    def ld_max_draw_distance(self) -> float:
        r"""
        (float):  [Read-Only] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
        """
        ...
    @property
    def cached_max_draw_distance(self) -> float:
        r"""
        (float):  [Read-Only] The distance to cull this primitive at.
        A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
        """
        ...
    @property
    def indirect_lighting_cache_quality(self) -> IndirectLightingCacheQuality:
        r"""
        (IndirectLightingCacheQuality):  [Read-Only] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
        """
        ...
    @property
    def lightmap_type(self) -> LightmapType:
        r"""
        (LightmapType):  [Read-Only] Controls the type of lightmap used for this component.
        """
        ...
    @property
    def hlod_batching_policy(self) -> HLODBatchingPolicy:
        r"""
        (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
        """
        ...
    @hlod_batching_policy.setter
    def hlod_batching_policy(self, value: HLODBatchingPolicy) -> None:
        ...
    @property
    def enable_auto_lod_generation(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to include this component in HLODs or not.
        """
        ...
    @enable_auto_lod_generation.setter
    def enable_auto_lod_generation(self, value: bool) -> None:
        ...
    @property
    def never_distance_cull(self) -> bool:
        r"""
        (bool):  [Read-Only] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
        """
        ...
    @property
    def always_create_physics_state(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates if we'd like to create physics state all the time (for collision and simulation).
        If you set this to false, it still will create physics state if collision or simulation activated.
        This can help performance if you'd like to avoid overhead of creating physics state when triggers
        """
        ...
    @property
    def generate_overlap_events(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @generate_overlap_events.setter
    def generate_overlap_events(self, value: bool) -> None:
        ...
    @property
    def multi_body_overlap(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
        generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
        influence on single body components.
        """
        ...
    @multi_body_overlap.setter
    def multi_body_overlap(self, value: bool) -> None:
        ...
    @property
    def trace_complex_on_move(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
        If false, collision will be resolved against simple collision bounds instead.
        see: MoveComponent()
        """
        ...
    @trace_complex_on_move.setter
    def trace_complex_on_move(self, value: bool) -> None:
        ...
    @property
    def return_material_on_move(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
        see: MoveComponent(), FHitResult
        """
        ...
    @return_material_on_move.setter
    def return_material_on_move(self, value: bool) -> None:
        ...
    @property
    def allow_cull_distance_volume(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to accept cull distance volumes to modify cached cull distance.
        """
        ...
    @property
    def visible_in_reflection_captures(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will be visible in reflection captures.
        """
        ...
    @property
    def visible_in_real_time_sky_captures(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will be visible in real-time sky light reflection captures.
        """
        ...
    @property
    def visible_in_ray_tracing(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
        """
        ...
    @property
    def render_in_main_pass(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
        """
        ...
    @property
    def render_in_depth_pass(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
        """
        ...
    @property
    def receives_decals(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the primitive receives decals.
        """
        ...
    @property
    def holdout(self) -> bool:
        r"""
        (bool):  [Read-Only] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
        """
        ...
    @property
    def owner_no_see(self) -> bool:
        r"""
        (bool):  [Read-Only] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
        """
        ...
    @property
    def only_owner_see(self) -> bool:
        r"""
        (bool):  [Read-Only] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
        """
        ...
    @property
    def treat_as_background_for_occlusion(self) -> bool:
        r"""
        (bool):  [Read-Only] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
        """
        ...
    @property
    def use_as_occluder(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to render the primitive in the depth only pass.
        This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
        todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
        """
        ...
    @property
    def force_mip_streaming(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
        """
        ...
    @property
    def cast_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the primitive component should cast a shadow or not.
        """
        ...
    @property
    def emissive_light_source(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the primitive will be used as an emissive light source.
        """
        ...
    @property
    def affect_dynamic_indirect_lighting(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the primitive should influence indirect lighting.
        """
        ...
    @property
    def affect_indirect_lighting_while_hidden(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
        """
        ...
    @property
    def affect_distance_field_lighting(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
        """
        ...
    @property
    def cast_dynamic_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
        """
        ...
    @property
    def cast_static_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
        """
        ...
    @property
    def shadow_cache_invalidation_behavior(self) -> ShadowCacheInvalidationBehavior:
        r"""
        (ShadowCacheInvalidationBehavior):  [Read-Only] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
        """
        ...
    @property
    def cast_volumetric_translucent_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the object should cast a volumetric translucent shadow.
        Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
        But have artifacts when used on highly opaque surfaces.
        """
        ...
    @property
    def cast_contact_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the object should cast contact shadows.
        This flag is only used if CastShadow is true.
        """
        ...
    @property
    def self_shadow_only(self) -> bool:
        r"""
        (bool):  [Read-Only] When enabled, the component will only cast a shadow on itself and not other components in the world.
        This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
        """
        ...
    @property
    def cast_far_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
        """
        ...
    @property
    def cast_inset_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
        Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
        """
        ...
    @property
    def cast_cinematic_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
        This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
        """
        ...
    @property
    def cast_hidden_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, the primitive will cast shadows even if bHidden is true.
        Controls whether the primitive should cast shadows when hidden.
        This flag is only used if CastShadow is true.
        """
        ...
    @property
    def cast_shadow_as_two_sided(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether this primitive should cast dynamic shadows as if it were a two sided material.
        """
        ...
    @property
    def light_attachments_as_group(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
        When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
        This is useful for improving performance when multiple movable components are attached together.
        """
        ...
    @property
    def exclude_from_light_attachment_group(self) -> bool:
        r"""
        (bool):  [Read-Only] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
        """
        ...
    @property
    def receive_mobile_csm_shadows(self) -> bool:
        r"""
        (bool):  [Read-Only] Mobile only:
        If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
        """
        ...
    @property
    def single_sample_shadow_from_stationary_lights(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
        When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
        This is currently only used on stationary directional lights.
        """
        ...
    @property
    def ignore_radial_impulse(self) -> bool:
        r"""
        (bool):  [Read-Write] Will ignore radial impulses applied to this component.
        """
        ...
    @ignore_radial_impulse.setter
    def ignore_radial_impulse(self, value: bool) -> None:
        ...
    @property
    def ignore_radial_force(self) -> bool:
        r"""
        (bool):  [Read-Write] Will ignore radial forces applied to this component.
        """
        ...
    @ignore_radial_force.setter
    def ignore_radial_force(self, value: bool) -> None:
        ...
    @property
    def apply_impulse_on_damage(self) -> bool:
        r"""
        (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
        """
        ...
    @apply_impulse_on_damage.setter
    def apply_impulse_on_damage(self, value: bool) -> None:
        ...
    @property
    def replicate_physics_to_autonomous_proxy(self) -> bool:
        r"""
        (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                      server-authoritative simulations, and false for client authoritative simulations.
        """
        ...
    @replicate_physics_to_autonomous_proxy.setter
    def replicate_physics_to_autonomous_proxy(self, value: bool) -> None:
        ...
    @property
    def render_custom_depth(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
        """
        ...
    @property
    def visible_in_scene_capture_only(self) -> bool:
        r"""
        (bool):  [Read-Only] When true, will only be visible in Scene Capture
        """
        ...
    @property
    def hidden_in_scene_capture(self) -> bool:
        r"""
        (bool):  [Read-Only] When true, will not be captured by Scene Capture
        """
        ...
    @property
    def static_when_not_moveable(self) -> bool:
        r"""
        (bool):  [Read-Only] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
        """
        ...
    @property
    def exclude_for_specific_hlod_levels(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write]
        deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
        """
        ...
    @exclude_for_specific_hlod_levels.setter
    def exclude_for_specific_hlod_levels(self, value: Array[int]) -> None:
        ...
    @property
    def can_character_step_up_on(self) -> CanBeCharacterBase:
        r"""
        (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
        This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
        see: FWalkableSlopeOverride
        """
        ...
    @can_character_step_up_on.setter
    def can_character_step_up_on(self, value: CanBeCharacterBase) -> None:
        ...
    @property
    def can_be_character_base(self) -> CanBeCharacterBase:
        r"""
        deprecated: 'can_be_character_base' was renamed to 'can_character_step_up_on'.
        """
        ...
    @can_be_character_base.setter
    def can_be_character_base(self, value: CanBeCharacterBase) -> None:
        ...
    @property
    def lighting_channels(self) -> LightingChannels:
        r"""
        (LightingChannels):  [Read-Only] Channels that this component should be in.  Lights with matching channels will affect the component.
        These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
        """
        ...
    @property
    def ray_tracing_group_id(self) -> int:
        r"""
        (int32):  [Read-Only] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
        -1 means that component doesn't belong to any group.
        """
        ...
    @property
    def custom_depth_stencil_value(self) -> int:
        r"""
        (int32):  [Read-Only] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
        """
        ...
    @property
    def translucency_sort_priority(self) -> int:
        r"""
        (int32):  [Read-Only] Translucent objects with a lower sort priority draw behind objects with a higher priority.
        Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
        This setting is also used to sort objects being drawn into a runtime virtual texture.
        
        Ignored if the object is not translucent.  The default priority is zero.
        Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
        It is especially problematic on dynamic gameplay effects.
        """
        ...
    @property
    def translucency_sort_distance_offset(self) -> float:
        r"""
        (float):  [Read-Only] Modified sort distance offset for translucent objects in world units.
        A positive number will move the sort distance further and a negative number will move the distance closer.
        
        Ignored if the object is not translucent.
        Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
        """
        ...
    @property
    def runtime_virtual_textures(self) -> Array[RuntimeVirtualTexture]:
        r"""
        (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
        The material also needs to be set up to output to a virtual texture.
        """
        ...
    @runtime_virtual_textures.setter
    def runtime_virtual_textures(self, value: Array[RuntimeVirtualTexture]) -> None:
        ...
    @property
    def virtual_texture_render_pass_type(self) -> RuntimeVirtualTextureMainPassType:
        r"""
        (RuntimeVirtualTextureMainPassType):  [Read-Only] Controls if this component draws in the main pass as well as in the virtual texture.
        """
        ...
    @property
    def body_instance(self) -> BodyInstance:
        r"""
        (BodyInstance):  [Read-Only] Physics scene information for this component, holds a single rigid body with multiple shapes.
        """
        ...
    @property
    def on_component_hit(self) -> ComponentHitSignature:
        r"""
        (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
        For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
        note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
        note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
        note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
        """
        ...
    @on_component_hit.setter
    def on_component_hit(self, value: ComponentHitSignature) -> None:
        ...
    @property
    def on_component_begin_overlap(self) -> ComponentBeginOverlapSignature:
        r"""
        (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
        For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
        note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
        note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
        """
        ...
    @on_component_begin_overlap.setter
    def on_component_begin_overlap(self, value: ComponentBeginOverlapSignature) -> None:
        ...
    @property
    def on_component_end_overlap(self) -> ComponentEndOverlapSignature:
        r"""
        (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
        note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
        """
        ...
    @on_component_end_overlap.setter
    def on_component_end_overlap(self, value: ComponentEndOverlapSignature) -> None:
        ...
    @property
    def on_component_wake(self) -> ComponentWakeSignature:
        r"""
        (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
        """
        ...
    @on_component_wake.setter
    def on_component_wake(self, value: ComponentWakeSignature) -> None:
        ...
    @property
    def on_component_sleep(self) -> ComponentSleepSignature:
        r"""
        (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
        """
        ...
    @on_component_sleep.setter
    def on_component_sleep(self, value: ComponentSleepSignature) -> None:
        ...
    @property
    def on_component_physics_state_changed(self) -> ComponentPhysicsStateChanged:
        r"""
        (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
        """
        ...
    @on_component_physics_state_changed.setter
    def on_component_physics_state_changed(self, value: ComponentPhysicsStateChanged) -> None:
        ...
    @property
    def on_begin_cursor_over(self) -> ComponentBeginCursorOverSignature:
        r"""
        (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
        """
        ...
    @on_begin_cursor_over.setter
    def on_begin_cursor_over(self, value: ComponentBeginCursorOverSignature) -> None:
        ...
    @property
    def on_end_cursor_over(self) -> ComponentEndCursorOverSignature:
        r"""
        (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
        """
        ...
    @on_end_cursor_over.setter
    def on_end_cursor_over(self, value: ComponentEndCursorOverSignature) -> None:
        ...
    @property
    def on_clicked(self) -> ComponentOnClickedSignature:
        r"""
        (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
        """
        ...
    @on_clicked.setter
    def on_clicked(self, value: ComponentOnClickedSignature) -> None:
        ...
    @property
    def on_released(self) -> ComponentOnReleasedSignature:
        r"""
        (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
        """
        ...
    @on_released.setter
    def on_released(self, value: ComponentOnReleasedSignature) -> None:
        ...
    @property
    def on_input_touch_begin(self) -> ComponentOnInputTouchBeginSignature:
        r"""
        (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
        """
        ...
    @on_input_touch_begin.setter
    def on_input_touch_begin(self, value: ComponentOnInputTouchBeginSignature) -> None:
        ...
    @property
    def on_input_touch_end(self) -> ComponentOnInputTouchEndSignature:
        r"""
        (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
        """
        ...
    @on_input_touch_end.setter
    def on_input_touch_end(self, value: ComponentOnInputTouchEndSignature) -> None:
        ...
    @property
    def on_input_touch_enter(self) -> ComponentBeginTouchOverSignature:
        r"""
        (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
        """
        ...
    @on_input_touch_enter.setter
    def on_input_touch_enter(self, value: ComponentBeginTouchOverSignature) -> None:
        ...
    @property
    def on_input_touch_leave(self) -> ComponentEndTouchOverSignature:
        r"""
        (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
        """
        ...
    @on_input_touch_leave.setter
    def on_input_touch_leave(self, value: ComponentEndTouchOverSignature) -> None:
        ...
    @property
    def ray_tracing_group_culling_priority(self) -> RayTracingGroupCullingPriority:
        r"""
        (RayTracingGroupCullingPriority):  [Read-Only] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
        """
        ...
    @property
    def custom_depth_stencil_write_mask(self) -> RendererStencilMask:
        r"""
        (RendererStencilMask):  [Read-Only] Mask used for stencil buffer writes.
        """
        ...
    def was_recently_rendered(self, tolerance: float = 0.200000) -> bool:
        r"""
        x.was_recently_rendered(tolerance=0.200000) -> bool
        Returns true if this component has been rendered "recently", with a tolerance in seconds to define what "recent" means.
        e.g.: If a tolerance of 0.1 is used, this function will return true only if the actor was rendered in the last 0.1 seconds of game time.
        
        Args:
            tolerance (float): How many seconds ago the actor last render time can be and still count as having been "recently" rendered.
        
        Returns:
            bool: Whether this actor was recently rendered.
        """
        ...
    def wake_rigid_body(self, bone_name: Name = "None") -> None:
        r"""
        x.wake_rigid_body(bone_name="None") -> None
        'Wake' physics simulation for a single body.
        
        Args:
            bone_name (Name): If a SkeletalMeshComponent, name of body to wake. 'None' indicates root body.
        """
        ...
    def wake_all_rigid_bodies(self) -> None:
        r"""
        x.wake_all_rigid_bodies() -> None
        Ensure simulation is running for all bodies in this component.
        """
        ...
    def set_walkable_slope_override(self, new_override: WalkableSlopeOverride) -> None:
        r"""
        x.set_walkable_slope_override(new_override) -> None
        Sets a new slope override for this component instance.
        
        Args:
            new_override (WalkableSlopeOverride):
        """
        ...
    def set_visible_in_scene_capture_only(self, value: bool) -> None:
        r"""
        x.set_visible_in_scene_capture_only(value) -> None
        Sets bVisibleInSceneCaptureOnly property and marks the render state dirty.
        
        Args:
            value (bool):
        """
        ...
    def set_visible_in_ray_tracing(self, new_visible_in_ray_tracing: bool) -> None:
        r"""
        x.set_visible_in_ray_tracing(new_visible_in_ray_tracing) -> None
        Changes the value of bIsVisibleInRayTracing.
        
        Args:
            new_visible_in_ray_tracing (bool):
        """
        ...
    def set_vector_parameter_for_default_custom_primitive_data(self, parameter_name: Name, value: Vector4) -> None:
        r"""
        x.set_vector_parameter_for_default_custom_primitive_data(parameter_name, value) -> None
        Set a vector parameter for default custom primitive data. This will be serialized and is useful in construction scripts.
        
        Args:
            parameter_name (Name): The parameter name of the custom primitive
            value (Vector4): The new value of the custom primitive
        """
        ...
    def set_vector_parameter_for_custom_primitive_data(self, parameter_name: Name, value: Vector4) -> None:
        r"""
        x.set_vector_parameter_for_custom_primitive_data(parameter_name, value) -> None
        Set a vector parameter for custom primitive data. This sets the run-time data only, so it doesn't serialize.
        
        Args:
            parameter_name (Name): The parameter name of the custom primitive
            value (Vector4): The new value of the custom primitive
        """
        ...
    def set_use_ccd(self, use_ccd: bool, bone_name: Name = "None") -> None:
        r"""
        x.set_use_ccd(use_ccd, bone_name="None") -> None
        Set whether this component should use Continuous Collision Detection
        
        Args:
            use_ccd (bool): 
            bone_name (Name):
        """
        ...
    def set_update_kinematic_from_simulation(self, update_kinematic_from_simulation: bool) -> None:
        r"""
        x.set_update_kinematic_from_simulation(update_kinematic_from_simulation) -> None
        Enables/disables whether this component should be updated by simulation when it is kinematic. This is needed if (for example) its velocity needs to be accessed.
        
        Args:
            update_kinematic_from_simulation (bool):
        """
        ...
    def set_translucent_sort_priority(self, new_translucent_sort_priority: int) -> None:
        r"""
        x.set_translucent_sort_priority(new_translucent_sort_priority) -> None
        Changes the value of TranslucentSortPriority.
        
        Args:
            new_translucent_sort_priority (int32):
        """
        ...
    def set_translucency_sort_distance_offset(self, new_translucency_sort_distance_offset: float) -> None:
        r"""
        x.set_translucency_sort_distance_offset(new_translucency_sort_distance_offset) -> None
        Changes the value of TranslucencySortDistanceOffset.
        
        Args:
            new_translucency_sort_distance_offset (float):
        """
        ...
    def set_static_when_not_moveable(self, static_when_not_moveable: bool) -> None:
        r"""
        x.set_static_when_not_moveable(static_when_not_moveable) -> None
        Set Static when Not Moveable
        
        Args:
            static_when_not_moveable (bool):
        """
        ...
    def set_single_sample_shadow_from_stationary_lights(self, new_single_sample_shadow_from_stationary_lights: bool) -> None:
        r"""
        x.set_single_sample_shadow_from_stationary_lights(new_single_sample_shadow_from_stationary_lights) -> None
        Changes the value of bSingleSampleShadowFromStationaryLights.
        
        Args:
            new_single_sample_shadow_from_stationary_lights (bool):
        """
        ...
    def set_simulate_physics(self, simulate: bool) -> None:
        r"""
        x.set_simulate_physics(simulate) -> None
        Sets whether or not a single body should use physics simulation, or should be 'fixed' (kinematic).
        Note that if this component is currently attached to something, beginning simulation will detach it.
        
        Args:
            simulate (bool): New simulation state for single body
        """
        ...
    def set_scalar_parameter_for_default_custom_primitive_data(self, parameter_name: Name, value: float) -> None:
        r"""
        x.set_scalar_parameter_for_default_custom_primitive_data(parameter_name, value) -> None
        Set a scalar parameter for default custom primitive data. This will be serialized and is useful in construction scripts.
        
        Args:
            parameter_name (Name): The parameter name of the custom primitive
            value (float): The new value of the custom primitive
        """
        ...
    def set_scalar_parameter_for_custom_primitive_data(self, parameter_name: Name, value: float) -> None:
        r"""
        x.set_scalar_parameter_for_custom_primitive_data(parameter_name, value) -> None
        Set a scalar parameter for custom primitive data. This sets the run-time data only, so it doesn't serialize.
        
        Args:
            parameter_name (Name): The parameter name of the custom primitive
            value (float): The new value of the custom primitive
        """
        ...
    def set_render_in_main_pass(self, value: bool) -> None:
        r"""
        x.set_render_in_main_pass(value) -> None
        Sets bRenderInMainPass property and marks the render state dirty.
        
        Args:
            value (bool):
        """
        ...
    def set_render_in_depth_pass(self, value: bool) -> None:
        r"""
        x.set_render_in_depth_pass(value) -> None
        Sets bRenderInDepthPass property and marks the render state dirty.
        
        Args:
            value (bool):
        """
        ...
    def set_render_custom_depth(self, value: bool) -> None:
        r"""
        x.set_render_custom_depth(value) -> None
        Sets the bRenderCustomDepth property and marks the render state dirty.
        
        Args:
            value (bool):
        """
        ...
    def set_receives_decals(self, new_receives_decals: bool) -> None:
        r"""
        x.set_receives_decals(new_receives_decals) -> None
        Changes the value of bReceivesDecals.
        
        Args:
            new_receives_decals (bool):
        """
        ...
    def set_phys_material_override(self, new_phys_material: PhysicalMaterial) -> None:
        r"""
        x.set_phys_material_override(new_phys_material) -> None
        Changes the current PhysMaterialOverride for this component.
        Note that if physics is already running on this component, this will _not_ alter its mass/inertia etc,
        it will only change its surface properties like friction.
        
        Args:
            new_phys_material (PhysicalMaterial):
        """
        ...
    def set_physics_max_angular_velocity_in_radians(self, new_max_ang_vel: float, add_to_current: bool = False, bone_name: Name = "None") -> None:
        r"""
        x.set_physics_max_angular_velocity_in_radians(new_max_ang_vel, add_to_current=False, bone_name="None") -> None
        Set the maximum angular velocity of a single body.
        
        Args:
            new_max_ang_vel (float): New maximum angular velocity to apply to body, in radians per second.
            add_to_current (bool): If true, NewMaxAngVel is added to the existing maximum angular velocity of the body.
            bone_name (Name): If a SkeletalMeshComponent, name of body to modify maximum angular velocity of. 'None' indicates root body.
        """
        ...
    def set_physics_max_angular_velocity_in_degrees(self, new_max_ang_vel: float, add_to_current: bool = False, bone_name: Name = "None") -> None:
        r"""
        x.set_physics_max_angular_velocity_in_degrees(new_max_ang_vel, add_to_current=False, bone_name="None") -> None
        Set the maximum angular velocity of a single body.
        
        Args:
            new_max_ang_vel (float): New maximum angular velocity to apply to body, in degrees per second.
            add_to_current (bool): If true, NewMaxAngVel is added to the existing maximum angular velocity of the body.
            bone_name (Name): If a SkeletalMeshComponent, name of body to modify maximum angular velocity of. 'None' indicates root body.
        """
        ...
    def set_physics_linear_velocity(self, new_vel: Vector, add_to_current: bool = False, bone_name: Name = "None") -> None:
        r"""
        x.set_physics_linear_velocity(new_vel, add_to_current=False, bone_name="None") -> None
        Set the linear velocity of a single body.
        This should be used cautiously - it may be better to use AddForce or AddImpulse.
        
        Args:
            new_vel (Vector): New linear velocity to apply to physics.
            add_to_current (bool): If true, NewVel is added to the existing velocity of the body.
            bone_name (Name): If a SkeletalMeshComponent, name of body to modify velocity of. 'None' indicates root body.
        """
        ...
    def set_rb_linear_velocity(self, new_vel: Vector, add_to_current: bool = False, bone_name: Name = "None") -> None:
        r"""
        deprecated: 'set_rb_linear_velocity' was renamed to 'set_physics_linear_velocity'.
        """
        ...
    def set_physics_angular_velocity_in_radians(self, new_ang_vel: Vector, add_to_current: bool = False, bone_name: Name = "None") -> None:
        r"""
        x.set_physics_angular_velocity_in_radians(new_ang_vel, add_to_current=False, bone_name="None") -> None
        Set the angular velocity of a single body.
        This should be used cautiously - it may be better to use AddTorque or AddImpulse.
        
        Args:
            new_ang_vel (Vector): New angular velocity to apply to body, in radians per second.
            add_to_current (bool): If true, NewAngVel is added to the existing angular velocity of the body.
            bone_name (Name): If a SkeletalMeshComponent, name of body to modify angular velocity of. 'None' indicates root body.
        """
        ...
    def set_physics_angular_velocity_in_degrees(self, new_ang_vel: Vector, add_to_current: bool = False, bone_name: Name = "None") -> None:
        r"""
        x.set_physics_angular_velocity_in_degrees(new_ang_vel, add_to_current=False, bone_name="None") -> None
        Set the angular velocity of a single body.
        This should be used cautiously - it may be better to use AddTorque or AddImpulse.
        
        Args:
            new_ang_vel (Vector): New angular velocity to apply to body, in degrees per second.
            add_to_current (bool): If true, NewAngVel is added to the existing angular velocity of the body.
            bone_name (Name): If a SkeletalMeshComponent, name of body to modify angular velocity of. 'None' indicates root body.
        """
        ...
    def set_owner_no_see(self, new_owner_no_see: bool) -> None:
        r"""
        x.set_owner_no_see(new_owner_no_see) -> None
        Changes the value of bOwnerNoSee.
        
        Args:
            new_owner_no_see (bool):
        """
        ...
    def set_only_owner_see(self, new_only_owner_see: bool) -> None:
        r"""
        x.set_only_owner_see(new_only_owner_see) -> None
        Changes the value of bOnlyOwnerSee.
        
        Args:
            new_only_owner_see (bool):
        """
        ...
    def set_notify_rigid_body_collision(self, new_notify_rigid_body_collision: bool) -> None:
        r"""
        x.set_notify_rigid_body_collision(new_notify_rigid_body_collision) -> None
        Changes the value of bNotifyRigidBodyCollision
        
        Args:
            new_notify_rigid_body_collision (bool):
        """
        ...
    def set_max_depenetration_velocity(self, bone_name: Name = "None", max_depenetration_velocity: float = -1.000000) -> None:
        r"""
        x.set_max_depenetration_velocity(bone_name="None", max_depenetration_velocity=-1.000000) -> None
        The maximum velocity used to depenetrate this object from others when spawned or teleported with initial overlaps (does not affect overlaps as a result of normal movement).
        A value of zero will allow objects that are spawned overlapping to go to sleep without moving rather than pop out of each other. E.g., use zero if you spawn dynamic rocks
        partially embedded in the ground and want them to be interactive but not pop out of the ground when touched.
        A negative value means that the config setting CollisionInitialOverlapDepenetrationVelocity will be used.
        
        Args:
            bone_name (Name): 
            max_depenetration_velocity (float):
        """
        ...
    def set_material_by_name(self, material_slot_name: Name, material: MaterialInterface) -> None:
        r"""
        x.set_material_by_name(material_slot_name, material) -> None
        Changes the material applied to an element of the mesh.
        
        Args:
            material_slot_name (Name): The slot name to access the material of.
            material (MaterialInterface):
        """
        ...
    def set_material(self, element_index: int, material: MaterialInterface) -> None:
        r"""
        x.set_material(element_index, material) -> None
        Changes the material applied to an element of the mesh.
        
        Args:
            element_index (int32): The element to access the material of.
            material (MaterialInterface):
        """
        ...
    def set_mass_scale(self, bone_name: Name = "None", mass_scale: float = 1.000000) -> None:
        r"""
        x.set_mass_scale(bone_name="None", mass_scale=1.000000) -> None
        Change the mass scale used to calculate the mass of a single physics body
        
        Args:
            bone_name (Name): 
            mass_scale (float):
        """
        ...
    def set_mass_override_in_kg(self, bone_name: Name = "None", mass_in_kg: float = 1.000000, override_mass: bool = True) -> None:
        r"""
        x.set_mass_override_in_kg(bone_name="None", mass_in_kg=1.000000, override_mass=True) -> None
        Override the mass (in Kg) of a single physics body.
        Note that in the case where multiple bodies are attached together, the override mass will be set for the entire group.
        Set the Override Mass to false if you want to reset the body's mass to the auto-calculated physx mass.
        
        Args:
            bone_name (Name): 
            mass_in_kg (float): 
            override_mass (bool):
        """
        ...
    def set_linear_damping(self, damping: float) -> None:
        r"""
        x.set_linear_damping(damping) -> None
        Sets the linear damping of this component.
        
        Args:
            damping (float):
        """
        ...
    def set_lighting_channels(self, channel0: bool, channel1: bool, channel2: bool) -> None:
        r"""
        x.set_lighting_channels(channel0, channel1, channel2) -> None
        Set Lighting Channels
        
        Args:
            channel0 (bool): 
            channel1 (bool): 
            channel2 (bool):
        """
        ...
    def set_light_attachments_as_group(self, light_attachments_as_group: bool) -> None:
        r"""
        x.set_light_attachments_as_group(light_attachments_as_group) -> None
        Changes the value of LightAttachmentsAsGroup.
        
        Args:
            light_attachments_as_group (bool):
        """
        ...
    def set_ignore_bounds_for_editor_focus(self, ignore: bool) -> None:
        r"""
        x.set_ignore_bounds_for_editor_focus(ignore) -> None
        Set if we should ignore bounds when focusing the editor camera.
        
        Args:
            ignore (bool):
        """
        ...
    def set_holdout(self, new_holdout: bool) -> None:
        r"""
        x.set_holdout(new_holdout) -> None
        Changes the value of bHoldout (Path Tracing only feature)
        
        Args:
            new_holdout (bool):
        """
        ...
    def set_hidden_in_scene_capture(self, value: bool) -> None:
        r"""
        x.set_hidden_in_scene_capture(value) -> None
        Sets bHideInSceneCapture property and marks the render state dirty.
        
        Args:
            value (bool):
        """
        ...
    def set_exclude_from_light_attachment_group(self, exclude_from_light_attachment_group: bool) -> None:
        r"""
        x.set_exclude_from_light_attachment_group(exclude_from_light_attachment_group) -> None
        Changes the value of ExcludeFromLightAttachmentGroup.
        
        Args:
            exclude_from_light_attachment_group (bool):
        """
        ...
    def set_excluded_from_hlod_level(self, hlod_level: HLODLevelExclusion, excluded: bool) -> None:
        r"""
        x.set_excluded_from_hlod_level(hlod_level, excluded) -> None
        Exclude this primitive from the specified HLOD level
        
        Args:
            hlod_level (HLODLevelExclusion): 
            excluded (bool):
        """
        ...
    def set_enable_gravity(self, gravity_enabled: bool) -> None:
        r"""
        x.set_enable_gravity(gravity_enabled) -> None
        Enables/disables whether this component is affected by gravity. This applies only to components with bSimulatePhysics set to true.
        
        Args:
            gravity_enabled (bool):
        """
        ...
    def set_emissive_light_source(self, new_emissive_light_source: bool) -> None:
        r"""
        x.set_emissive_light_source(new_emissive_light_source) -> None
        Changes the value of EmissiveLightSource.
        
        Args:
            new_emissive_light_source (bool):
        """
        ...
    def set_default_custom_primitive_data_vector4(self, data_index: int, value: Vector4) -> None:
        r"""
        x.set_default_custom_primitive_data_vector4(data_index, value) -> None
        Set default custom primitive data, four floats at once, from index DataIndex to index DataIndex + 3, and marks the render state dirty
        
        Args:
            data_index (int32): 
            value (Vector4):
        """
        ...
    def set_default_custom_primitive_data_vector3(self, data_index: int, value: Vector) -> None:
        r"""
        x.set_default_custom_primitive_data_vector3(data_index, value) -> None
        Set default custom primitive data, three floats at once, from index DataIndex to index DataIndex + 2, and marks the render state dirty
        
        Args:
            data_index (int32): 
            value (Vector):
        """
        ...
    def set_default_custom_primitive_data_vector2(self, data_index: int, value: Vector2D) -> None:
        r"""
        x.set_default_custom_primitive_data_vector2(data_index, value) -> None
        Set default custom primitive data, two floats at once, from index DataIndex to index DataIndex + 1, and marks the render state dirty
        
        Args:
            data_index (int32): 
            value (Vector2D):
        """
        ...
    def set_default_custom_primitive_data_float(self, data_index: int, value: float) -> None:
        r"""
        x.set_default_custom_primitive_data_float(data_index, value) -> None
        Set default custom primitive data at index DataIndex, and marks the render state dirty
        
        Args:
            data_index (int32): 
            value (float):
        """
        ...
    def set_custom_primitive_data_vector4(self, data_index: int, value: Vector4) -> None:
        r"""
        x.set_custom_primitive_data_vector4(data_index, value) -> None
        Set custom primitive data, four floats at once, from index DataIndex to index DataIndex + 3. This sets the run-time data only, so it doesn't serialize.
        
        Args:
            data_index (int32): 
            value (Vector4):
        """
        ...
    def set_custom_primitive_data_vector3(self, data_index: int, value: Vector) -> None:
        r"""
        x.set_custom_primitive_data_vector3(data_index, value) -> None
        Set custom primitive data, three floats at once, from index DataIndex to index DataIndex + 2. This sets the run-time data only, so it doesn't serialize.
        
        Args:
            data_index (int32): 
            value (Vector):
        """
        ...
    def set_custom_primitive_data_vector2(self, data_index: int, value: Vector2D) -> None:
        r"""
        x.set_custom_primitive_data_vector2(data_index, value) -> None
        Set custom primitive data, two floats at once, from index DataIndex to index DataIndex + 1. This sets the run-time data only, so it doesn't serialize.
        
        Args:
            data_index (int32): 
            value (Vector2D):
        """
        ...
    def set_custom_primitive_data_float(self, data_index: int, value: float) -> None:
        r"""
        x.set_custom_primitive_data_float(data_index, value) -> None
        Set custom primitive data at index DataIndex. This sets the run-time data only, so it doesn't serialize.
        
        Args:
            data_index (int32): 
            value (float):
        """
        ...
    def set_custom_depth_stencil_write_mask(self, write_mask_bit: RendererStencilMask) -> None:
        r"""
        x.set_custom_depth_stencil_write_mask(write_mask_bit) -> None
        Sets the CustomDepth stencil write mask and marks the render state dirty.
        
        Args:
            write_mask_bit (RendererStencilMask):
        """
        ...
    def set_custom_depth_stencil_value(self, value: int) -> None:
        r"""
        x.set_custom_depth_stencil_value(value) -> None
        Sets the CustomDepth stencil value (0 - 255) and marks the render state dirty.
        
        Args:
            value (int32):
        """
        ...
    def set_cull_distance(self, new_cull_distance: float) -> None:
        r"""
        x.set_cull_distance(new_cull_distance) -> None
        Changes the value of CullDistance.
        
        Args:
            new_cull_distance (float): The value to assign to CullDistance.
        """
        ...
    def set_constraint_mode(self, constraint_mode: DOFMode) -> None:
        r"""
        x.set_constraint_mode(constraint_mode) -> None
        Sets the constraint mode of the component.
        
        Args:
            constraint_mode (DOFMode): The type of constraint to use.
        """
        ...
    def set_collision_response_to_channel(self, channel: CollisionChannel, new_response: CollisionResponseType) -> None:
        r"""
        x.set_collision_response_to_channel(channel, new_response) -> None
        Changes a member of the ResponseToChannels container for this PrimitiveComponent.
        
        Args:
            channel (CollisionChannel): The channel to change the response of
            new_response (CollisionResponseType): What the new response should be to the supplied Channel
        """
        ...
    def set_collision_response_to_all_channels(self, new_response: CollisionResponseType) -> None:
        r"""
        x.set_collision_response_to_all_channels(new_response) -> None
        Changes all ResponseToChannels container for this PrimitiveComponent. to be NewResponse
        
        Args:
            new_response (CollisionResponseType): What the new response should be to the supplied Channel
        """
        ...
    def set_collision_profile_name(self, collision_profile_name: Name, update_overlaps: bool = True) -> None:
        r"""
        x.set_collision_profile_name(collision_profile_name, update_overlaps=True) -> None
        Set Collision Profile Name
        This function is called by constructors when they set ProfileName
        This will change current CollisionProfileName to be this, and overwrite Collision Setting
        
        Args:
            collision_profile_name (Name): : New Profile Name
            update_overlaps (bool):
        """
        ...
    def set_collision_object_type(self, channel: CollisionChannel) -> None:
        r"""
        x.set_collision_object_type(channel) -> None
        Changes the collision channel that this object uses when it moves
        
        Args:
            channel (CollisionChannel): The new channel for this component to use
        """
        ...
    def set_movement_channel(self, channel: CollisionChannel) -> None:
        r"""
        deprecated: 'set_movement_channel' was renamed to 'set_collision_object_type'.
        """
        ...
    def set_collision_enabled(self, new_type: CollisionEnabled) -> None:
        r"""
        x.set_collision_enabled(new_type) -> None
        Controls what kind of collision is enabled for this body
        
        Args:
            new_type (CollisionEnabled):
        """
        ...
    def set_center_of_mass(self, center_of_mass_offset: Vector, bone_name: Name = "None") -> None:
        r"""
        x.set_center_of_mass(center_of_mass_offset, bone_name="None") -> None
        Set the center of mass of a single body. This will offset the physx-calculated center of mass.
        Note that in the case where multiple bodies are attached together, the center of mass will be set for the entire group.
        
        Args:
            center_of_mass_offset (Vector): User specified offset for the center of mass of this object, from the calculated location.
            bone_name (Name): If a SkeletalMeshComponent, name of body to set center of mass of. 'None' indicates root body.
        """
        ...
    def set_cast_shadow(self, new_cast_shadow: bool) -> None:
        r"""
        x.set_cast_shadow(new_cast_shadow) -> None
        Changes the value of CastShadow.
        
        Args:
            new_cast_shadow (bool):
        """
        ...
    def set_cast_inset_shadow(self, cast_inset_shadow: bool) -> None:
        r"""
        x.set_cast_inset_shadow(cast_inset_shadow) -> None
        Changes the value of CastInsetShadow.
        
        Args:
            cast_inset_shadow (bool):
        """
        ...
    def set_cast_hidden_shadow(self, new_cast_hidden_shadow: bool) -> None:
        r"""
        x.set_cast_hidden_shadow(new_cast_hidden_shadow) -> None
        Changes the value of CastHiddenShadow.
        
        Args:
            new_cast_hidden_shadow (bool):
        """
        ...
    def set_cast_contact_shadow(self, cast_contact_shadow: bool) -> None:
        r"""
        x.set_cast_contact_shadow(cast_contact_shadow) -> None
        Changes the value of bCastContactShadow.
        
        Args:
            cast_contact_shadow (bool):
        """
        ...
    def set_bounds_scale(self, new_bounds_scale: float = 1.000000) -> None:
        r"""
        x.set_bounds_scale(new_bounds_scale=1.000000) -> None
        Scale the bounds of this object, used for frustum culling. Useful for features like WorldPositionOffset.
        
        Args:
            new_bounds_scale (float):
        """
        ...
    def set_angular_damping(self, damping: float) -> None:
        r"""
        x.set_angular_damping(damping) -> None
        Sets the angular damping of this component.
        
        Args:
            damping (float):
        """
        ...
    def set_all_use_ccd(self, use_ccd: bool) -> None:
        r"""
        x.set_all_use_ccd(use_ccd) -> None
        Set whether all bodies in this component should use Continuous Collision Detection
        
        Args:
            use_ccd (bool):
        """
        ...
    def set_all_physics_linear_velocity(self, new_vel: Vector, add_to_current: bool = False) -> None:
        r"""
        x.set_all_physics_linear_velocity(new_vel, add_to_current=False) -> None
        Set the linear velocity of all bodies in this component.
        
        Args:
            new_vel (Vector): New linear velocity to apply to physics.
            add_to_current (bool): If true, NewVel is added to the existing velocity of the body.
        """
        ...
    def set_all_rb_linear_velocity(self, new_vel: Vector, add_to_current: bool = False) -> None:
        r"""
        deprecated: 'set_all_rb_linear_velocity' was renamed to 'set_all_physics_linear_velocity'.
        """
        ...
    def set_all_physics_angular_velocity_in_radians(self, new_ang_vel: Vector, add_to_current: bool = False) -> None:
        r"""
        x.set_all_physics_angular_velocity_in_radians(new_ang_vel, add_to_current=False) -> None
        Set the angular velocity of all bodies in this component.
        
        Args:
            new_ang_vel (Vector): New angular velocity to apply to physics, in radians per second.
            add_to_current (bool): If true, NewAngVel is added to the existing angular velocity of all bodies.
        """
        ...
    def set_all_physics_angular_velocity_in_degrees(self, new_ang_vel: Vector, add_to_current: bool = False) -> None:
        r"""
        x.set_all_physics_angular_velocity_in_degrees(new_ang_vel, add_to_current=False) -> None
        Set the angular velocity of all bodies in this component.
        
        Args:
            new_ang_vel (Vector): New angular velocity to apply to physics, in degrees per second.
            add_to_current (bool): If true, NewAngVel is added to the existing angular velocity of all bodies.
        """
        ...
    def set_all_mass_scale(self, mass_scale: float = 1.000000) -> None:
        r"""
        x.set_all_mass_scale(mass_scale=1.000000) -> None
        Change the mass scale used fo all bodies in this component
        
        Args:
            mass_scale (float):
        """
        ...
    def set_affect_indirect_lighting_while_hidden(self, new_affect_indirect_lighting_while_hidden: bool) -> None:
        r"""
        x.set_affect_indirect_lighting_while_hidden(new_affect_indirect_lighting_while_hidden) -> None
        Changes the value of bAffectIndirectLightingWhileHidden
        
        Args:
            new_affect_indirect_lighting_while_hidden (bool):
        """
        ...
    def set_affect_dynamic_indirect_lighting(self, new_affect_dynamic_indirect_lighting: bool) -> None:
        r"""
        x.set_affect_dynamic_indirect_lighting(new_affect_dynamic_indirect_lighting) -> None
        Changes the value of bAffectDynamicIndirectLighting
        
        Args:
            new_affect_dynamic_indirect_lighting (bool):
        """
        ...
    def set_affect_distance_field_lighting(self, new_affect_distance_field_lighting: bool) -> None:
        r"""
        x.set_affect_distance_field_lighting(new_affect_distance_field_lighting) -> None
        Changes the value of Affect Distance Field Lighting
        
        Args:
            new_affect_distance_field_lighting (bool):
        """
        ...
    def scale_by_moment_of_inertia(self, input_vector: Vector, bone_name: Name = "None") -> Vector:
        r"""
        x.scale_by_moment_of_inertia(input_vector, bone_name="None") -> Vector
        Scales the given vector by the world space moment of inertia. Useful for computing the torque needed to rotate an object.
        
        Args:
            input_vector (Vector): 
            bone_name (Name): 
        
        Returns:
            Vector:
        """
        ...
    def put_rigid_body_to_sleep(self, bone_name: Name = "None") -> None:
        r"""
        x.put_rigid_body_to_sleep(bone_name="None") -> None
        Force a single body back to sleep.
        
        Args:
            bone_name (Name): If a SkeletalMeshComponent, name of body to put to sleep. 'None' indicates root body.
        """
        ...
    def sphere_trace_component(self, trace_start: Vector, trace_end: Vector, sphere_radius: float, trace_complex: bool = True, show_trace: bool = ..., persistent_show_trace: bool = False) -> Optional[Tuple[Vector, Vector, Name, HitResult]]:
        r"""
        x.sphere_trace_component(trace_start, trace_end, sphere_radius, trace_complex=True, show_trace, persistent_show_trace=False) -> (hit_location=Vector, hit_normal=Vector, bone_name=Name, out_hit=HitResult) or None
        Perform a sphere trace against a single component
        
        Args:
            trace_start (Vector): The start of the trace in world-space
            trace_end (Vector): The end of the trace in world-space
            sphere_radius (float): Radius of the sphere to trace against the component
            trace_complex (bool): Whether or not to trace the complex physics representation or just the simple representation
            show_trace (bool): Whether or not to draw the trace in the world (for debugging)
            persistent_show_trace (bool): Whether or not to make the debugging draw stay in the world permanently
        
        Returns:
            tuple or None: 
        
            hit_location (Vector): 
        
            hit_normal (Vector): 
        
            bone_name (Name): 
        
            out_hit (HitResult):
        """
        ...
    def sphere_overlap_component(self, sphere_centre: Vector, sphere_radius: float, trace_complex: bool = True, show_trace: bool = ..., persistent_show_trace: bool = False) -> Optional[Tuple[Vector, Vector, Name, HitResult]]:
        r"""
        x.sphere_overlap_component(sphere_centre, sphere_radius, trace_complex=True, show_trace, persistent_show_trace=False) -> (hit_location=Vector, hit_normal=Vector, bone_name=Name, out_hit=HitResult) or None
        Perform a sphere overlap against a single component
        
        Args:
            sphere_centre (Vector): The centre of the sphere to overlap with the component
            sphere_radius (float): The Radius of the sphere to overlap with the component
            trace_complex (bool): Whether or not to trace the complex physics representation or just the simple representation
            show_trace (bool): Whether or not to draw the trace in the world (for debugging)
            persistent_show_trace (bool): Whether or not to make the debugging draw stay in the world permanently
        
        Returns:
            tuple or None: 
        
            hit_location (Vector): 
        
            hit_normal (Vector): 
        
            bone_name (Name): 
        
            out_hit (HitResult):
        """
        ...
    def line_trace_component(self, trace_start: Vector, trace_end: Vector, trace_complex: bool = True, show_trace: bool = ..., persistent_show_trace: bool = False) -> Optional[Tuple[Vector, Vector, Name, HitResult]]:
        r"""
        x.line_trace_component(trace_start, trace_end, trace_complex=True, show_trace, persistent_show_trace=False) -> (hit_location=Vector, hit_normal=Vector, bone_name=Name, out_hit=HitResult) or None
        Perform a line trace against a single component
        
        Args:
            trace_start (Vector): The start of the trace in world-space
            trace_end (Vector): The end of the trace in world-space
            trace_complex (bool): Whether or not to trace the complex physics representation or just the simple representation
            show_trace (bool): Whether or not to draw the trace in the world (for debugging)
            persistent_show_trace (bool): Whether or not to make the debugging draw stay in the world permanently
        
        Returns:
            tuple or None: 
        
            hit_location (Vector): 
        
            hit_normal (Vector): 
        
            bone_name (Name): 
        
            out_hit (HitResult):
        """
        ...
    def is_query_collision_enabled(self) -> bool:
        r"""
        x.is_query_collision_enabled() -> bool
        Utility to see if there is any query collision enabled on this component.
        
        Returns:
            bool:
        """
        ...
    def is_physics_collision_enabled(self) -> bool:
        r"""
        x.is_physics_collision_enabled() -> bool
        Utility to see if there is any physics collision enabled on this component.
        
        Returns:
            bool:
        """
        ...
    def is_collision_enabled(self) -> bool:
        r"""
        x.is_collision_enabled() -> bool
        Utility to see if there is any form of collision (query or physics) enabled on this component.
        
        Returns:
            bool:
        """
        ...
    def box_overlap_component(self, box_centre: Vector, box: Box, trace_complex: bool = True, show_trace: bool = ..., persistent_show_trace: bool = False) -> Optional[Tuple[Vector, Vector, Name, HitResult]]:
        r"""
        x.box_overlap_component(box_centre, box, trace_complex=True, show_trace, persistent_show_trace=False) -> (hit_location=Vector, hit_normal=Vector, bone_name=Name, out_hit=HitResult) or None
        Perform a box overlap against a single component as an AABB (No rotation)
        
        Args:
            box_centre (Vector): The centre of the box to overlap with the component
            box (Box): Description of the box to use in the overlap
            trace_complex (bool): Whether or not to trace the complex physics representation or just the simple representation
            show_trace (bool): Whether or not to draw the trace in the world (for debugging)
            persistent_show_trace (bool): Whether or not to make the debugging draw stay in the world permanently
        
        Returns:
            tuple or None: 
        
            hit_location (Vector): 
        
            hit_normal (Vector): 
        
            bone_name (Name): 
        
            out_hit (HitResult):
        """
        ...
    def is_overlapping_component(self, other_comp: PrimitiveComponent) -> bool:
        r"""
        x.is_overlapping_component(other_comp) -> bool
        Check whether this component is overlapping another component.
        
        Args:
            other_comp (PrimitiveComponent): Component to test this component against.
        
        Returns:
            bool: Whether this component is overlapping another component.
        """
        ...
    def is_overlapping_actor(self, other: Actor) -> bool:
        r"""
        x.is_overlapping_actor(other) -> bool
        Check whether this component is overlapping any component of the given Actor.
        
        Args:
            other (Actor): Actor to test this component against.
        
        Returns:
            bool: Whether this component is overlapping any component of the given Actor.
        """
        ...
    def is_material_slot_name_valid(self, material_slot_name: Name) -> bool:
        r"""
        x.is_material_slot_name_valid(material_slot_name) -> bool
        Is Material Slot Name Valid
        
        Args:
            material_slot_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_gravity_enabled(self) -> bool:
        r"""
        x.is_gravity_enabled() -> bool
        Returns whether this component is affected by gravity. Returns always false if the component is not simulated.
        
        Returns:
            bool:
        """
        ...
    def is_excluded_from_hlod_level(self, hlod_level: HLODLevelExclusion) -> bool:
        r"""
        x.is_excluded_from_hlod_level(hlod_level) -> bool
        Whether this primitive is excluded from the specified HLOD level
        
        Args:
            hlod_level (HLODLevelExclusion): 
        
        Returns:
            bool:
        """
        ...
    def is_any_rigid_body_awake(self) -> bool:
        r"""
        x.is_any_rigid_body_awake() -> bool
        Returns if any body in this component is currently awake and simulating.
        
        Returns:
            bool:
        """
        ...
    def invalidate_lumen_surface_cache(self) -> None:
        r"""
        x.invalidate_lumen_surface_cache() -> None
        Invalidates Lumen surface cache and forces it to be refreshed. Useful to make material updates more responsive.
        """
        ...
    def ignore_component_when_moving(self, component: PrimitiveComponent, should_ignore: bool) -> None:
        r"""
        x.ignore_component_when_moving(component, should_ignore) -> None
        Tells this component whether to ignore collision with another component when this component is moved.
        The other components may also need to be told to do the same when they move.
        Does not affect movement of this component when simulating physics.
        
        Args:
            component (PrimitiveComponent): 
            should_ignore (bool):
        """
        ...
    def ignore_actor_when_moving(self, actor: Actor, should_ignore: bool) -> None:
        r"""
        x.ignore_actor_when_moving(actor, should_ignore) -> None
        Tells this component whether to ignore collision with all components of a specific Actor when this component is moved.
        Components on the other Actor may also need to be told to do the same when they move.
        Does not affect movement of this component when simulating physics.
        
        Args:
            actor (Actor): 
            should_ignore (bool):
        """
        ...
    def get_walkable_slope_override(self) -> WalkableSlopeOverride:
        r"""
        x.get_walkable_slope_override() -> WalkableSlopeOverride
        Returns the slope override struct for this component.
        
        Returns:
            WalkableSlopeOverride:
        """
        ...
    def get_update_kinematic_from_simulation(self) -> bool:
        r"""
        x.get_update_kinematic_from_simulation() -> bool
        Returns whether this component should be updated by simulation when it is kinematic.
        
        Returns:
            bool:
        """
        ...
    def get_static_when_not_moveable(self) -> bool:
        r"""
        x.get_static_when_not_moveable() -> bool
        Get Static when Not Moveable
        
        Returns:
            bool:
        """
        ...
    def get_physics_linear_velocity_at_point(self, point: Vector, bone_name: Name = "None") -> Vector:
        r"""
        x.get_physics_linear_velocity_at_point(point, bone_name="None") -> Vector
        Get the linear velocity of a point on a single body.
        
        Args:
            point (Vector): Point is specified in world space.
            bone_name (Name): If a SkeletalMeshComponent, name of body to get velocity of. 'None' indicates root body.
        
        Returns:
            Vector:
        """
        ...
    def get_physics_linear_velocity(self, bone_name: Name = "None") -> Vector:
        r"""
        x.get_physics_linear_velocity(bone_name="None") -> Vector
        Get the linear velocity of a single body.
        
        Args:
            bone_name (Name): If a SkeletalMeshComponent, name of body to get velocity of. 'None' indicates root body.
        
        Returns:
            Vector:
        """
        ...
    def get_rb_linear_velocity(self, bone_name: Name = "None") -> Vector:
        r"""
        deprecated: 'get_rb_linear_velocity' was renamed to 'get_physics_linear_velocity'.
        """
        ...
    def get_physics_angular_velocity_in_radians(self, bone_name: Name = "None") -> Vector:
        r"""
        x.get_physics_angular_velocity_in_radians(bone_name="None") -> Vector
        Get the angular velocity of a single body, in radians per second.
        
        Args:
            bone_name (Name): If a SkeletalMeshComponent, name of body to get velocity of. 'None' indicates root body.
        
        Returns:
            Vector:
        """
        ...
    def get_physics_angular_velocity_in_degrees(self, bone_name: Name = "None") -> Vector:
        r"""
        x.get_physics_angular_velocity_in_degrees(bone_name="None") -> Vector
        Get the angular velocity of a single body, in degrees per second.
        
        Args:
            bone_name (Name): If a SkeletalMeshComponent, name of body to get velocity of. 'None' indicates root body.
        
        Returns:
            Vector:
        """
        ...
    def get_overlapping_components(self) -> Array[PrimitiveComponent]:
        r"""
        x.get_overlapping_components() -> Array[PrimitiveComponent]
        Returns unique list of components this component is overlapping.
        
        Returns:
            Array[PrimitiveComponent]: 
        
            out_overlapping_components (Array[PrimitiveComponent]):
        """
        ...
    def get_touching_components(self) -> Array[PrimitiveComponent]:
        r"""
        deprecated: 'get_touching_components' was renamed to 'get_overlapping_components'.
        """
        ...
    def get_overlapping_actors(self, class_filter: Class = None) -> Array[Actor]:
        r"""
        x.get_overlapping_actors(class_filter=None) -> Array[Actor]
        Returns a list of actors that this component is overlapping.
        
        Args:
            class_filter (type(Class)): [optional] If set, only returns actors of this class or subclasses
        
        Returns:
            Array[Actor]: 
        
            overlapping_actors (Array[Actor]): [out] Returned list of overlapping actors
        """
        ...
    def get_touching_actors(self, class_filter: Class = None) -> Array[Actor]:
        r"""
        deprecated: 'get_touching_actors' was renamed to 'get_overlapping_actors'.
        """
        ...
    def get_num_materials(self) -> int:
        r"""
        x.get_num_materials() -> int32
        Return number of material elements in this primitive
        
        Returns:
            int32:
        """
        ...
    def get_max_depenetration_velocity(self, bone_name: Name = "None") -> float:
        r"""
        x.get_max_depenetration_velocity(bone_name="None") -> float
        The maximum velocity used to depenetrate this object from others when spawned or teleported with initial overlaps (does not affect overlaps as a result of normal movement).
        A value of zero will allow objects that are spawned overlapping to go to sleep without moving rather than pop out of each other. E.g., use zero if you spawn dynamic rocks
        partially embedded in the ground and want them to be interactive but not pop out of the ground when touched.
        A negative value means that the config setting CollisionInitialOverlapDepenetrationVelocity will be used.
        
        Args:
            bone_name (Name): 
        
        Returns:
            float:
        """
        ...
    def get_material_slot_names(self) -> Array[Name]:
        r"""
        x.get_material_slot_names() -> Array[Name]
        Get Material Slot Names
        
        Returns:
            Array[Name]:
        """
        ...
    def get_material_index(self, material_slot_name: Name) -> int:
        r"""
        x.get_material_index(material_slot_name) -> int32
        Get Material Index
        
        Args:
            material_slot_name (Name): 
        
        Returns:
            int32:
        """
        ...
    def get_material_from_collision_face_index(self, face_index: int) -> Tuple[MaterialInterface, int]:
        r"""
        x.get_material_from_collision_face_index(face_index) -> (MaterialInterface, section_index=int32)
        Try and retrieve the material applied to a particular collision face of mesh. Used with face index returned from collision trace.
        
        Args:
            face_index (int32): Face index from hit result that was hit by a trace
        
        Returns:
            int32: Material applied to section that the hit face belongs to
        
            section_index (int32): Section of the mesh that the face belongs to
        """
        ...
    def get_material_by_name(self, material_slot_name: Name) -> MaterialInterface:
        r"""
        x.get_material_by_name(material_slot_name) -> MaterialInterface
        Returns the material used by the element in the slot with the specified name.
        
        Args:
            material_slot_name (Name): The slot name to access the material of.
        
        Returns:
            MaterialInterface: the material used in the slot specified, or null if none exists or the slot name is not found.
        """
        ...
    def get_material(self, element_index: int) -> MaterialInterface:
        r"""
        x.get_material(element_index) -> MaterialInterface
        Returns the material used by the element at the specified index
        
        Args:
            element_index (int32): The element to access the material of.
        
        Returns:
            MaterialInterface: the material used by the indexed element of this mesh.
        """
        ...
    def get_mass_scale(self, bone_name: Name = "None") -> float:
        r"""
        x.get_mass_scale(bone_name="None") -> float
        Returns the mass scale used to calculate the mass of a single physics body
        
        Args:
            bone_name (Name): 
        
        Returns:
            float:
        """
        ...
    def get_mass(self) -> float:
        r"""
        x.get_mass() -> float
        Returns the mass of this component in kg.
        
        Returns:
            float:
        """
        ...
    def get_linear_damping(self) -> float:
        r"""
        x.get_linear_damping() -> float
        Returns the linear damping of this component.
        
        Returns:
            float:
        """
        ...
    def get_inertia_tensor(self, bone_name: Name = "None") -> Vector:
        r"""
        x.get_inertia_tensor(bone_name="None") -> Vector
        Returns the inertia tensor of this component in kg cm^2. The inertia tensor is in local component space.
        
        Args:
            bone_name (Name): 
        
        Returns:
            Vector:
        """
        ...
    def get_ignore_bounds_for_editor_focus(self) -> bool:
        r"""
        x.get_ignore_bounds_for_editor_focus() -> bool
        Whether or not the bounds of this component should be considered when focusing the editor camera to an actor with this component in it.
        Useful for debug components which need a bounds for rendering but don't contribute to the visible part of the mesh in a meaningful way
        
        Returns:
            bool:
        """
        ...
    def get_custom_primitive_data_index_for_vector_parameter(self, parameter_name: Name) -> int:
        r"""
        x.get_custom_primitive_data_index_for_vector_parameter(parameter_name) -> int32
        Gets the index of the vector parameter for the custom primitive data array
        
        Args:
            parameter_name (Name): The parameter name of the custom primitive
        
        Returns:
            int32: The index of the custom primitive, INDEX_NONE (-1) if not found
        """
        ...
    def get_custom_primitive_data_index_for_scalar_parameter(self, parameter_name: Name) -> int:
        r"""
        x.get_custom_primitive_data_index_for_scalar_parameter(parameter_name) -> int32
        Gets the index of the scalar parameter for the custom primitive data array
        
        Args:
            parameter_name (Name): The parameter name of the custom primitive
        
        Returns:
            int32: The index of the custom primitive, INDEX_NONE (-1) if not found
        """
        ...
    def get_collision_response_to_channel(self, channel: CollisionChannel) -> CollisionResponseType:
        r"""
        x.get_collision_response_to_channel(channel) -> CollisionResponseType
        Gets the response type given a specific channel
        
        Args:
            channel (CollisionChannel): 
        
        Returns:
            CollisionResponseType:
        """
        ...
    def get_collision_profile_name(self) -> Name:
        r"""
        x.get_collision_profile_name() -> Name
        Get the collision profile name
        
        Returns:
            Name:
        """
        ...
    def get_collision_object_type(self) -> CollisionChannel:
        r"""
        x.get_collision_object_type() -> CollisionChannel
        Gets the collision object type
        
        Returns:
            CollisionChannel:
        """
        ...
    def get_collision_enabled(self) -> CollisionEnabled:
        r"""
        x.get_collision_enabled() -> CollisionEnabled
        Returns the form of collision for this component
        
        Returns:
            CollisionEnabled:
        """
        ...
    def get_closest_point_on_collision(self, point: Vector, bone_name: Name = "None") -> Tuple[float, Vector]:
        r"""
        x.get_closest_point_on_collision(point, bone_name="None") -> (float, out_point_on_body=Vector)
        Returns the distance and closest point to the collision surface.
        Component must have simple collision to be queried for closest point.
        
        Args:
            point (Vector): World 3D vector
            bone_name (Name): If a SkeletalMeshComponent, name of body to set center of mass of. 'None' indicates root body.
        
        Returns:
            Vector: Success if returns > 0.f, if returns 0.f, it is either not convex or inside of the point If returns < 0.f, this primitive does not have collsion
        
            out_point_on_body (Vector): Point on the surface of collision closest to Point
        """
        ...
    def get_center_of_mass(self, bone_name: Name = "None") -> Vector:
        r"""
        x.get_center_of_mass(bone_name="None") -> Vector
        Get the center of mass of a single body. In the case of a welded body this will return the center of mass of the entire welded body (including its parent and children)
        Objects that are not simulated return (0,0,0) as they do not have COM
        
        Args:
            bone_name (Name): If a SkeletalMeshComponent, name of body to get center of mass of. 'None' indicates root body.
        
        Returns:
            Vector:
        """
        ...
    def get_body_instance_async_physics_tick_handle(self, bone_name: Name = "None", get_welded: bool = True, index: int = -1) -> BodyInstanceAsyncPhysicsTickHandle:
        r"""
        x.get_body_instance_async_physics_tick_handle(bone_name="None", get_welded=True, index=-1) -> BodyInstanceAsyncPhysicsTickHandle
        Returns BodyInstanceAsyncPhysicsTickHandle of the component. For use in the Async Physics Tick event
        
        Args:
            bone_name (Name): Used to get body associated with specific bone. NAME_None automatically gets the root most body
            get_welded (bool): If the component has been welded to another component and bGetWelded is true we return the single welded BodyInstance that is used in the simulation
            index (int32): Index used in Components with multiple body instances
        
        Returns:
            BodyInstanceAsyncPhysicsTickHandle: Returns the BodyInstanceAsyncPhysicsTickHandle based on various states (does component have multiple bodies? Is the body welded to another body?)
        """
        ...
    def get_angular_damping(self) -> float:
        r"""
        x.get_angular_damping() -> float
        Returns the angular damping of this component.
        
        Returns:
            float:
        """
        ...
    def create_dynamic_material_instance(self, element_index: int, source_material: MaterialInterface = None, optional_name: Name = "None") -> MaterialInstanceDynamic:
        r"""
        x.create_dynamic_material_instance(element_index, source_material=None, optional_name="None") -> MaterialInstanceDynamic
        Creates a Dynamic Material Instance for the specified element index, optionally from the supplied material.
        
        Args:
            element_index (int32): The index of the skin to replace the material for.  If invalid, the material is unchanged and NULL is returned.
            source_material (MaterialInterface): 
            optional_name (Name): 
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...
    def create_and_set_material_instance_dynamic_from_material(self, element_index: int, parent: MaterialInterface) -> MaterialInstanceDynamic:
        r"""
        x.create_and_set_material_instance_dynamic_from_material(element_index, parent) -> MaterialInstanceDynamic
        Creates a Dynamic Material Instance for the specified element index.  The parent of the instance is set to the material being replaced.
        deprecated: Use CreateDynamicMaterialInstance instead.
        
        Args:
            element_index (int32): The index of the skin to replace the material for.  If invalid, the material is unchanged and NULL is returned.
            parent (MaterialInterface): 
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...
    def create_and_set_material_instance_dynamic(self, element_index: int) -> MaterialInstanceDynamic:
        r"""
        x.create_and_set_material_instance_dynamic(element_index) -> MaterialInstanceDynamic
        Creates a Dynamic Material Instance for the specified element index.  The parent of the instance is set to the material being replaced.
        deprecated: Use CreateDynamicMaterialInstance instead.
        
        Args:
            element_index (int32): The index of the skin to replace the material for.  If invalid, the material is unchanged and NULL is returned.
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...
    def copy_array_of_move_ignore_components(self) -> Array[PrimitiveComponent]:
        r"""
        x.copy_array_of_move_ignore_components() -> Array[PrimitiveComponent]
        Returns the list of actors we currently ignore when moving.
        
        Returns:
            Array[PrimitiveComponent]:
        """
        ...
    def copy_array_of_move_ignore_actors(self) -> Array[Actor]:
        r"""
        x.copy_array_of_move_ignore_actors() -> Array[Actor]
        Returns the list of actors we currently ignore when moving.
        
        Returns:
            Array[Actor]:
        """
        ...
    def get_move_ignore_actors(self) -> Array[Actor]:
        r"""
        deprecated: 'get_move_ignore_actors' was renamed to 'copy_array_of_move_ignore_actors'.
        """
        ...
    def clear_move_ignore_components(self) -> None:
        r"""
        x.clear_move_ignore_components() -> None
        Clear the list of components we ignore when moving.
        """
        ...
    def clear_move_ignore_actors(self) -> None:
        r"""
        x.clear_move_ignore_actors() -> None
        Clear the list of actors we ignore when moving.
        """
        ...
    def can_character_step_up(self, pawn: Pawn) -> bool:
        r"""
        x.can_character_step_up(pawn) -> bool
        Return true if the given Pawn can step up onto this component.
        This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
        see: CanCharacterStepUpOn
        
        Args:
            pawn (Pawn): the Pawn that wants to step onto this component.
        
        Returns:
            bool:
        """
        ...
    def add_velocity_change_impulse_at_location(self, impulse: Vector, location: Vector, bone_name: Name = "None") -> None:
        r"""
        x.add_velocity_change_impulse_at_location(impulse, location, bone_name="None") -> None
        Add an impulse to a single rigid body at a specific location. The Strength is taken as a change in angular velocity instead of an impulse (ie. mass will have no effect).
        
        Args:
            impulse (Vector): Magnitude and direction of impulse to apply.
            location (Vector): Point in world space to apply impulse at.
            bone_name (Name): If a SkeletalMeshComponent, name of bone to apply impulse to. 'None' indicates root body.
        """
        ...
    def add_torque_in_radians(self, torque: Vector, bone_name: Name = "None", accel_change: bool = False) -> None:
        r"""
        x.add_torque_in_radians(torque, bone_name="None", accel_change=False) -> None
        Add a torque to a single rigid body.
        
        Args:
            torque (Vector): Torque to apply. Direction is axis of rotation and magnitude is strength of torque.
            bone_name (Name): If a SkeletalMeshComponent, name of body to apply torque to. 'None' indicates root body.
            accel_change (bool): If true, Torque is taken as a change in angular acceleration instead of a physical torque (i.e. mass will have no effect).
        """
        ...
    def add_torque_in_degrees(self, torque: Vector, bone_name: Name = "None", accel_change: bool = False) -> None:
        r"""
        x.add_torque_in_degrees(torque, bone_name="None", accel_change=False) -> None
        Add a torque to a single rigid body.
        
        Args:
            torque (Vector): Torque to apply. Direction is axis of rotation and magnitude is strength of torque.
            bone_name (Name): If a SkeletalMeshComponent, name of body to apply torque to. 'None' indicates root body.
            accel_change (bool): If true, Torque is taken as a change in angular acceleration instead of a physical torque (i.e. mass will have no effect).
        """
        ...
    def add_radial_impulse(self, origin: Vector, radius: float, strength: float, falloff: RadialImpulseFalloff, vel_change: bool = False) -> None:
        r"""
        x.add_radial_impulse(origin, radius, strength, falloff, vel_change=False) -> None
        Add an impulse to all rigid bodies in this component, radiating out from the specified position.
        
        Args:
            origin (Vector): Point of origin for the radial impulse blast, in world space
            radius (float): Size of radial impulse. Beyond this distance from Origin, there will be no affect.
            strength (float): Maximum strength of impulse applied to body.
            falloff (RadialImpulseFalloff): Allows you to control the strength of the impulse as a function of distance from Origin.
            vel_change (bool): If true, the Strength is taken as a change in velocity instead of an impulse (ie. mass will have no effect).
        """
        ...
    def add_radial_force(self, origin: Vector, radius: float, strength: float, falloff: RadialImpulseFalloff, accel_change: bool = False) -> None:
        r"""
        x.add_radial_force(origin, radius, strength, falloff, accel_change=False) -> None
        Add a force to all bodies in this component, originating from the supplied world-space location.
        
        Args:
            origin (Vector): Origin of force in world space.
            radius (float): Radius within which to apply the force.
            strength (float): Strength of force to apply.
            falloff (RadialImpulseFalloff): Allows you to control the strength of the force as a function of distance from Origin.
            accel_change (bool): If true, Strength is taken as a change in acceleration instead of a physical force (i.e. mass will have no effect).
        """
        ...
    def add_impulse_at_location(self, impulse: Vector, location: Vector, bone_name: Name = "None") -> None:
        r"""
        x.add_impulse_at_location(impulse, location, bone_name="None") -> None
        Add an impulse to a single rigid body at a specific location.
        
        Args:
            impulse (Vector): Magnitude and direction of impulse to apply.
            location (Vector): Point in world space to apply impulse at.
            bone_name (Name): If a SkeletalMeshComponent, name of bone to apply impulse to. 'None' indicates root body.
        """
        ...
    def add_impulse_at_position(self, impulse: Vector, location: Vector, bone_name: Name = "None") -> None:
        r"""
        deprecated: 'add_impulse_at_position' was renamed to 'add_impulse_at_location'.
        """
        ...
    def add_impulse(self, impulse: Vector, bone_name: Name = "None", vel_change: bool = False) -> None:
        r"""
        x.add_impulse(impulse, bone_name="None", vel_change=False) -> None
        Add an impulse to a single rigid body. Good for one time instant burst.
        
        Args:
            impulse (Vector): Magnitude and direction of impulse to apply.
            bone_name (Name): If a SkeletalMeshComponent, name of body to apply impulse to. 'None' indicates root body.
            vel_change (bool): If true, the Strength is taken as a change in velocity instead of an impulse (ie. mass will have no effect).
        """
        ...
    def add_force_at_location_local(self, force: Vector, location: Vector, bone_name: Name = "None") -> None:
        r"""
        x.add_force_at_location_local(force, location, bone_name="None") -> None
        Add a force to a single rigid body at a particular location. Both Force and Location should be in body space.
        This is like a 'thruster'. Good for adding a burst over some (non zero) time. Should be called every frame for the duration of the force.
        
        Args:
            force (Vector): Force vector to apply. Magnitude indicates strength of force.
            location (Vector): Location to apply force, in component space.
            bone_name (Name): If a SkeletalMeshComponent, name of body to apply force to. 'None' indicates root body.
        """
        ...
    def add_force_at_location(self, force: Vector, location: Vector, bone_name: Name = "None") -> None:
        r"""
        x.add_force_at_location(force, location, bone_name="None") -> None
        Add a force to a single rigid body at a particular location in world space.
        This is like a 'thruster'. Good for adding a burst over some (non zero) time. Should be called every frame for the duration of the force.
        
        Args:
            force (Vector): Force vector to apply. Magnitude indicates strength of force.
            location (Vector): Location to apply force, in world space.
            bone_name (Name): If a SkeletalMeshComponent, name of body to apply force to. 'None' indicates root body.
        """
        ...
    def add_force_at_position(self, force: Vector, location: Vector, bone_name: Name = "None") -> None:
        r"""
        deprecated: 'add_force_at_position' was renamed to 'add_force_at_location'.
        """
        ...
    def add_force(self, force: Vector, bone_name: Name = "None", accel_change: bool = False) -> None:
        r"""
        x.add_force(force, bone_name="None", accel_change=False) -> None
        Add a force to a single rigid body.
        This is like a 'thruster'. Good for adding a burst over some (non zero) time. Should be called every frame for the duration of the force.
        
        Args:
            force (Vector): Force vector to apply. Magnitude indicates strength of force.
            bone_name (Name): If a SkeletalMeshComponent, name of body to apply force to. 'None' indicates root body.
            accel_change (bool): If true, Force is taken as a change in acceleration instead of a physical force (i.e. mass will have no effect).
        """
        ...
    def add_angular_impulse_in_radians(self, impulse: Vector, bone_name: Name = "None", vel_change: bool = False) -> None:
        r"""
        x.add_angular_impulse_in_radians(impulse, bone_name="None", vel_change=False) -> None
        Add an angular impulse to a single rigid body. Good for one time instant burst.
        
        Args:
            impulse (Vector): 
            bone_name (Name): If a SkeletalMeshComponent, name of body to apply angular impulse to. 'None' indicates root body.
            vel_change (bool): If true, the Strength is taken as a change in angular velocity instead of an impulse (ie. mass will have no effect).
        """
        ...
    def add_angular_impulse_in_degrees(self, impulse: Vector, bone_name: Name = "None", vel_change: bool = False) -> None:
        r"""
        x.add_angular_impulse_in_degrees(impulse, bone_name="None", vel_change=False) -> None
        Add an angular impulse to a single rigid body. Good for one time instant burst.
        
        Args:
            impulse (Vector): 
            bone_name (Name): If a SkeletalMeshComponent, name of body to apply angular impulse to. 'None' indicates root body.
            vel_change (bool): If true, the Strength is taken as a change in angular velocity instead of an impulse (ie. mass will have no effect).
        """
        ...

class MeshComponent(PrimitiveComponent):
    r"""
    MeshComponent is an abstract base for any component that is an instance of a renderable collection of triangles.
    see: UStaticMeshComponent
    see: USkeletalMeshComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def overlay_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Only] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
        """
        ...
    @property
    def overlay_material_max_draw_distance(self) -> float:
        r"""
        (float):  [Read-Only] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
        """
        ...
    @property
    def enable_material_parameter_caching(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    def set_vector_parameter_value_on_materials(self, parameter_name: Name, parameter_value: Vector) -> None:
        r"""
        x.set_vector_parameter_value_on_materials(parameter_name, parameter_value) -> None
        Set all occurrences of Vector Material Parameters with ParameterName in the set of materials of the SkeletalMesh to ParameterValue
        
        Args:
            parameter_name (Name): 
            parameter_value (Vector):
        """
        ...
    def set_scalar_parameter_value_on_materials(self, parameter_name: Name, parameter_value: float) -> None:
        r"""
        x.set_scalar_parameter_value_on_materials(parameter_name, parameter_value) -> None
        Set all occurrences of Scalar Material Parameters with ParameterName in the set of materials of the SkeletalMesh to ParameterValue
        
        Args:
            parameter_name (Name): 
            parameter_value (float):
        """
        ...
    def set_overlay_material_max_draw_distance(self, max_draw_distance: float) -> None:
        r"""
        x.set_overlay_material_max_draw_distance(max_draw_distance) -> None
        Change the overlay material max draw distance used by this instance
        
        Args:
            max_draw_distance (float):
        """
        ...
    def set_overlay_material(self, new_overlay_material: MaterialInterface) -> None:
        r"""
        x.set_overlay_material(new_overlay_material) -> None
        Change the overlay material used by this instance
        
        Args:
            new_overlay_material (MaterialInterface):
        """
        ...
    def prestream_textures(self, seconds: float, prioritize_character_textures: bool, cinematic_texture_groups: int = 0) -> None:
        r"""
        x.prestream_textures(seconds, prioritize_character_textures, cinematic_texture_groups=0) -> None
        Tell the streaming system to start loading all textures with all mip-levels.
        
        Args:
            seconds (float): Number of seconds to force all mip-levels to be resident
            prioritize_character_textures (bool): Whether character textures should be prioritized for a while by the streaming system
            cinematic_texture_groups (int32): Bitfield indicating which texture groups that use extra high-resolution mips
        """
        ...
    def prestream_mesh_lo_ds(self, seconds: float) -> bool:
        r"""
        x.prestream_mesh_lo_ds(seconds) -> bool
        Tell the streaming system to start streaming in all LODs for the mesh.
         Note: this function may set bIgnoreStreamingMipBias on this component enable the FastForceResident system.
        
        Args:
            seconds (float): Number of seconds to force all LODs to be resident
        
        Returns:
            bool: bool                                                        True if streaming was successfully requested
        """
        ...
    def get_overlay_material_max_draw_distance(self) -> float:
        r"""
        x.get_overlay_material_max_draw_distance() -> float
        Get the overlay material used by this instance
        
        Returns:
            float:
        """
        ...
    def get_overlay_material(self) -> MaterialInterface:
        r"""
        x.get_overlay_material() -> MaterialInterface
        Get the overlay material used by this instance
        
        Returns:
            MaterialInterface:
        """
        ...
    def get_materials(self) -> Array[MaterialInterface]:
        r"""
        x.get_materials() -> Array[MaterialInterface]
        Get Materials
        
        Returns:
            Array[MaterialInterface]:
        """
        ...

class WidgetComponent(MeshComponent):
    r"""
    The widget component provides a surface in the 3D environment on which to render widgets normally rendered to the screen.
    Widgets are first rendered to a render target, then that render target is displayed in the world.
    
    Material Properties set by this component on whatever material overrides the default.
    SlateUI [Texture]
    BackColor [Vector]
    TintColorAndOpacity [Vector]
    OpacityFromTexture [Scalar]
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_gamma_correction`` (bool):  [Read-Write] Widget components that appear in the world will be gamma corrected by the 3D renderer.
      In some cases, widget components are blitted directly into the backbuffer, in which case gamma correction should be enabled.
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``background_color`` (LinearColor):  [Read-Write] The background color of the component
    - ``blend_mode`` (WidgetBlendMode):  [Read-Write] The blend mode for the widget.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``cylinder_arc_angle`` (float):  [Read-Write] Curvature of a cylindrical widget in degrees.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``draw_at_desired_size`` (bool):  [Read-Write] Causes the render target to automatically match the desired size.
      
      WARNING: If you change this every frame, it will be very expensive. If you need
         that effect, you should keep the outer widget's sized locked and dynamically
         scale or resize some inner widget.
    - ``draw_size`` (IntPoint):  [Read-Write] The size of the displayed quad.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``geometry_mode`` (WidgetGeometryMode):  [Read-Write] Controls the geometry of the widget component. See EWidgetGeometryMode.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_two_sided`` (bool):  [Read-Write] Is the component visible from behind?
    - ``layer_z_order`` (int32):  [Read-Write] ZOrder the layer will be created on, note this only matters on the first time a new layer is created, subsequent additions to the same layer will use the initially defined ZOrder
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``manually_redraw`` (bool):  [Read-Write] Should we wait to be told to redraw to actually draw?
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``opacity_from_texture`` (float):  [Read-Write] Sets the amount of opacity from the widget's UI texture to use when rendering the translucent or masked UI to the viewport (0.0-1.0)
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pivot`` (Vector2D):  [Read-Write] The Alignment/Pivot point that the widget is placed at relative to the position.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_hardware_input`` (bool):  [Read-Write] Register with the viewport for hardware input from the true mouse and keyboard.  These widgets
      will more or less react like regular 2D widgets in the viewport, e.g. they can and will steal focus
      from the viewport.
      
      WARNING: If you are making a VR game, definitely do not change this to true.  This option should ONLY be used
      if you're making what would otherwise be a normal menu for a game, just in 3D.  If you also need the game to
      remain responsive and for the player to be able to interact with UI and move around the world (such as a keypad on a door),
      use the WidgetInteractionComponent instead.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``redraw_time`` (float):  [Read-Write] The time in between draws, if 0 - we would redraw every frame.  If 1, we would redraw every second.
      This will work with bManuallyRedraw as well.  So you can say, manually redraw, but only redraw at this
      maximum rate.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``shared_layer_name`` (Name):  [Read-Write] Layer Name the widget will live on
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``space`` (WidgetSpace):  [Read-Write] The coordinate space in which to render the widget
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``tick_mode`` (TickMode):  [Read-Write]
    - ``tick_when_offscreen`` (bool):  [Read-Write] Should the component tick the widget when it's off screen?
    - ``timing_policy`` (WidgetTimingPolicy):  [Read-Write] How this widget should deal with timing, pausing, etc.
    - ``tint_color_and_opacity`` (LinearColor):  [Read-Write] Tint color and opacity for this component
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_invalidation_in_world_space`` (bool):  [Read-Write] Use the invalidation system to update this widget.
      Only valid in World space. In Screen space, the widget is updated by the viewport owners.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``widget_class`` (type(Class)):  [Read-Write] The class of User Widget to create and display an instance of
    - ``window_focusable`` (bool):  [Read-Write] Is the virtual window created to host the widget focusable?
    - ``window_visibility`` (WindowVisibility):  [Read-Write] The visibility of the virtual window created to host the widget
    """
    def set_window_visibility(self, visibility: WindowVisibility) -> None:
        r"""
        x.set_window_visibility(visibility) -> None
        Sets the visibility of the virtual window created to host the widget focusable.
        
        Args:
            visibility (WindowVisibility):
        """
        ...
    def set_window_focusable(self, window_focusable: bool) -> None:
        r"""
        x.set_window_focusable(window_focusable) -> None
        
        see: bWindowFocusable
        
        Args:
            window_focusable (bool):
        """
        ...
    def set_widget_space(self, new_space: WidgetSpace) -> None:
        r"""
        x.set_widget_space(new_space) -> None
        Set Widget Space
        
        Args:
            new_space (WidgetSpace):
        """
        ...
    def set_widget(self, widget: UserWidget) -> None:
        r"""
        x.set_widget(widget) -> None
        Sets the widget to use directly. This function will keep track of the widget till the next time it's called
            with either a newer widget or a nullptr
        
        Args:
            widget (UserWidget):
        """
        ...
    def set_two_sided(self, want_two_sided: bool) -> None:
        r"""
        x.set_two_sided(want_two_sided) -> None
        Sets whether the widget is two-sided or not
        
        Args:
            want_two_sided (bool):
        """
        ...
    def set_tint_color_and_opacity(self, new_tint_color_and_opacity: LinearColor) -> None:
        r"""
        x.set_tint_color_and_opacity(new_tint_color_and_opacity) -> None
        Sets the tint color and opacity scale for this widget
        
        Args:
            new_tint_color_and_opacity (LinearColor):
        """
        ...
    def set_tick_when_offscreen(self, want_tick_when_offscreen: bool) -> None:
        r"""
        x.set_tick_when_offscreen(want_tick_when_offscreen) -> None
        Sets whether the widget ticks when offscreen or not
        
        Args:
            want_tick_when_offscreen (bool):
        """
        ...
    def set_tick_mode(self, tick_mode: TickMode) -> None:
        r"""
        x.set_tick_mode(tick_mode) -> None
        Sets the Tick mode of the Widget Component.
        
        Args:
            tick_mode (TickMode):
        """
        ...
    def set_redraw_time(self, redraw_time: float) -> None:
        r"""
        x.set_redraw_time(redraw_time) -> None
        Set Redraw Time
        
        Args:
            redraw_time (float):
        """
        ...
    def set_pivot(self, pivot: Vector2D) -> None:
        r"""
        x.set_pivot(pivot) -> None
        Set Pivot
        
        Args:
            pivot (Vector2D):
        """
        ...
    def set_owner_player(self, local_player: LocalPlayer) -> None:
        r"""
        x.set_owner_player(local_player) -> None
        Sets the local player that owns this widget component.  Setting the owning player controls
        which player's viewport the widget appears on in a split screen scenario.  Additionally it
        forwards the owning player to the actual UserWidget that is spawned.
        
        Args:
            local_player (LocalPlayer):
        """
        ...
    def set_manually_redraw(self, use_manual_redraw: bool) -> None:
        r"""
        x.set_manually_redraw(use_manual_redraw) -> None
        
        see: bManuallyRedraw
        
        Args:
            use_manual_redraw (bool):
        """
        ...
    def set_geometry_mode(self, geometry_mode: WidgetGeometryMode) -> None:
        r"""
        x.set_geometry_mode(geometry_mode) -> None
        Set Geometry Mode
        
        Args:
            geometry_mode (WidgetGeometryMode):
        """
        ...
    def set_draw_size(self, size: Vector2D) -> None:
        r"""
        x.set_draw_size(size) -> None
        Sets the draw size of the quad in the world
        
        Args:
            size (Vector2D):
        """
        ...
    def set_draw_at_desired_size(self, draw_at_desired_size: bool) -> None:
        r"""
        x.set_draw_at_desired_size(draw_at_desired_size) -> None
        Set Draw at Desired Size
        
        Args:
            draw_at_desired_size (bool):
        """
        ...
    def set_cylinder_arc_angle(self, cylinder_arc_angle: float) -> None:
        r"""
        x.set_cylinder_arc_angle(cylinder_arc_angle) -> None
        Defines the curvature of the widget component when using EWidgetGeometryMode::Cylinder; ignored otherwise.
        
        Args:
            cylinder_arc_angle (float):
        """
        ...
    def set_background_color(self, new_background_color: LinearColor) -> None:
        r"""
        x.set_background_color(new_background_color) -> None
        Sets the background color and opacityscale for this widget
        
        Args:
            new_background_color (LinearColor):
        """
        ...
    def request_render_update(self) -> None:
        r"""
        x.request_render_update() -> None
        Requests that the widget have it's render target updated, if TickMode is disabled, this will force a tick to happen to update the render target.
        """
        ...
    def request_redraw(self) -> None:
        r"""
        x.request_redraw() -> None
        Requests that the widget be redrawn.
        deprecated: Use RequestRenderUpdate instead
        """
        ...
    def is_widget_visible(self) -> bool:
        r"""
        x.is_widget_visible() -> bool
        Returns true if the the Slate window is visible and that the widget is also visible, false otherwise.
        
        Returns:
            bool:
        """
        ...
    def get_window_visiblility(self) -> WindowVisibility:
        r"""
        x.get_window_visiblility() -> WindowVisibility
        Gets the visibility of the virtual window created to host the widget focusable.
        
        Returns:
            WindowVisibility:
        """
        ...
    def get_window_focusable(self) -> bool:
        r"""
        x.get_window_focusable() -> bool
        
        see: bWindowFocusable
        
        Returns:
            bool:
        """
        ...
    def get_widget_space(self) -> WidgetSpace:
        r"""
        x.get_widget_space() -> WidgetSpace
        Get Widget Space
        
        Returns:
            WidgetSpace:
        """
        ...
    def get_widget(self) -> UserWidget:
        r"""
        x.get_widget() -> UserWidget
        Gets the widget that is used by this Widget Component. It will be null if a Slate Widget was set using SetSlateWidget function.
        
        Returns:
            UserWidget:
        """
        ...
    def get_user_widget_object(self) -> UserWidget:
        r"""
        x.get_user_widget_object() -> UserWidget
        Returns the user widget object displayed by this component
        
        Returns:
            UserWidget:
        """
        ...
    def get_two_sided(self) -> bool:
        r"""
        x.get_two_sided() -> bool
        Gets whether the widget is two-sided or not
        
        Returns:
            bool:
        """
        ...
    def get_tick_when_offscreen(self) -> bool:
        r"""
        x.get_tick_when_offscreen() -> bool
        Gets whether the widget ticks when offscreen or not
        
        Returns:
            bool:
        """
        ...
    def get_render_target(self) -> TextureRenderTarget2D:
        r"""
        x.get_render_target() -> TextureRenderTarget2D
        Returns the render target to which the user widget is rendered
        
        Returns:
            TextureRenderTarget2D:
        """
        ...
    def get_redraw_time(self) -> float:
        r"""
        x.get_redraw_time() -> float
        Get Redraw Time
        
        Returns:
            float:
        """
        ...
    def get_pivot(self) -> Vector2D:
        r"""
        x.get_pivot() -> Vector2D
        Returns the pivot point where the UI is rendered about the origin.
        
        Returns:
            Vector2D:
        """
        ...
    def get_owner_player(self) -> LocalPlayer:
        r"""
        x.get_owner_player() -> LocalPlayer
        Gets the local player that owns this widget component.
        
        Returns:
            LocalPlayer:
        """
        ...
    def get_material_instance(self) -> MaterialInstanceDynamic:
        r"""
        x.get_material_instance() -> MaterialInstanceDynamic
        Returns the dynamic material instance used to render the user widget
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...
    def get_manually_redraw(self) -> bool:
        r"""
        x.get_manually_redraw() -> bool
        
        see: bManuallyRedraw
        
        Returns:
            bool:
        """
        ...
    def get_geometry_mode(self) -> WidgetGeometryMode:
        r"""
        x.get_geometry_mode() -> WidgetGeometryMode
        
        see: EWidgetGeometryMode,
        see: GetCylinderArcAngle()
        
        Returns:
            WidgetGeometryMode:
        """
        ...
    def get_draw_size(self) -> Vector2D:
        r"""
        x.get_draw_size() -> Vector2D
        Returns the "specified" draw size of the quad in the world
        
        Returns:
            Vector2D:
        """
        ...
    def get_draw_at_desired_size(self) -> bool:
        r"""
        x.get_draw_at_desired_size() -> bool
        Get Draw at Desired Size
        
        Returns:
            bool:
        """
        ...
    def get_cylinder_arc_angle(self) -> float:
        r"""
        x.get_cylinder_arc_angle() -> float
        Defines the curvature of the widget component when using EWidgetGeometryMode::Cylinder; ignored otherwise.
        
        Returns:
            float:
        """
        ...
    def get_current_draw_size(self) -> Vector2D:
        r"""
        x.get_current_draw_size() -> Vector2D
        Returns the "actual" draw size of the quad in the world
        
        Returns:
            Vector2D:
        """
        ...

class VREditorWidgetComponent(WidgetComponent):
    r"""
    A specialized WidgetComponent for the VREditor
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorWidgetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_gamma_correction`` (bool):  [Read-Write] Widget components that appear in the world will be gamma corrected by the 3D renderer.
      In some cases, widget components are blitted directly into the backbuffer, in which case gamma correction should be enabled.
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``background_color`` (LinearColor):  [Read-Write] The background color of the component
    - ``blend_mode`` (WidgetBlendMode):  [Read-Write] The blend mode for the widget.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``cylinder_arc_angle`` (float):  [Read-Write] Curvature of a cylindrical widget in degrees.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``draw_at_desired_size`` (bool):  [Read-Write] Causes the render target to automatically match the desired size.
      
      WARNING: If you change this every frame, it will be very expensive. If you need
         that effect, you should keep the outer widget's sized locked and dynamically
         scale or resize some inner widget.
    - ``draw_size`` (IntPoint):  [Read-Write] The size of the displayed quad.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``geometry_mode`` (WidgetGeometryMode):  [Read-Write] Controls the geometry of the widget component. See EWidgetGeometryMode.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_two_sided`` (bool):  [Read-Write] Is the component visible from behind?
    - ``layer_z_order`` (int32):  [Read-Write] ZOrder the layer will be created on, note this only matters on the first time a new layer is created, subsequent additions to the same layer will use the initially defined ZOrder
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``manually_redraw`` (bool):  [Read-Write] Should we wait to be told to redraw to actually draw?
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``opacity_from_texture`` (float):  [Read-Write] Sets the amount of opacity from the widget's UI texture to use when rendering the translucent or masked UI to the viewport (0.0-1.0)
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pivot`` (Vector2D):  [Read-Write] The Alignment/Pivot point that the widget is placed at relative to the position.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_hardware_input`` (bool):  [Read-Write] Register with the viewport for hardware input from the true mouse and keyboard.  These widgets
      will more or less react like regular 2D widgets in the viewport, e.g. they can and will steal focus
      from the viewport.
      
      WARNING: If you are making a VR game, definitely do not change this to true.  This option should ONLY be used
      if you're making what would otherwise be a normal menu for a game, just in 3D.  If you also need the game to
      remain responsive and for the player to be able to interact with UI and move around the world (such as a keypad on a door),
      use the WidgetInteractionComponent instead.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``redraw_time`` (float):  [Read-Write] The time in between draws, if 0 - we would redraw every frame.  If 1, we would redraw every second.
      This will work with bManuallyRedraw as well.  So you can say, manually redraw, but only redraw at this
      maximum rate.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``shared_layer_name`` (Name):  [Read-Write] Layer Name the widget will live on
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``space`` (WidgetSpace):  [Read-Write] The coordinate space in which to render the widget
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``tick_mode`` (TickMode):  [Read-Write]
    - ``tick_when_offscreen`` (bool):  [Read-Write] Should the component tick the widget when it's off screen?
    - ``timing_policy`` (WidgetTimingPolicy):  [Read-Write] How this widget should deal with timing, pausing, etc.
    - ``tint_color_and_opacity`` (LinearColor):  [Read-Write] Tint color and opacity for this component
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_invalidation_in_world_space`` (bool):  [Read-Write] Use the invalidation system to update this widget.
      Only valid in World space. In Screen space, the widget is updated by the viewport owners.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``widget_class`` (type(Class)):  [Read-Write] The class of User Widget to create and display an instance of
    - ``window_focusable`` (bool):  [Read-Write] Is the virtual window created to host the widget focusable?
    - ``window_visibility`` (WindowVisibility):  [Read-Write] The visibility of the virtual window created to host the widget
    """
    ...

class VREditorCameraWidgetComponent(VREditorWidgetComponent):
    r"""
    A specialized WidgetComponent that color-corrects cameras previews (viewfinders) in VR
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorCameraWidgetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_gamma_correction`` (bool):  [Read-Write] Widget components that appear in the world will be gamma corrected by the 3D renderer.
      In some cases, widget components are blitted directly into the backbuffer, in which case gamma correction should be enabled.
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``background_color`` (LinearColor):  [Read-Write] The background color of the component
    - ``blend_mode`` (WidgetBlendMode):  [Read-Write] The blend mode for the widget.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``cylinder_arc_angle`` (float):  [Read-Write] Curvature of a cylindrical widget in degrees.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``draw_at_desired_size`` (bool):  [Read-Write] Causes the render target to automatically match the desired size.
      
      WARNING: If you change this every frame, it will be very expensive. If you need
         that effect, you should keep the outer widget's sized locked and dynamically
         scale or resize some inner widget.
    - ``draw_size`` (IntPoint):  [Read-Write] The size of the displayed quad.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``geometry_mode`` (WidgetGeometryMode):  [Read-Write] Controls the geometry of the widget component. See EWidgetGeometryMode.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_two_sided`` (bool):  [Read-Write] Is the component visible from behind?
    - ``layer_z_order`` (int32):  [Read-Write] ZOrder the layer will be created on, note this only matters on the first time a new layer is created, subsequent additions to the same layer will use the initially defined ZOrder
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``manually_redraw`` (bool):  [Read-Write] Should we wait to be told to redraw to actually draw?
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``opacity_from_texture`` (float):  [Read-Write] Sets the amount of opacity from the widget's UI texture to use when rendering the translucent or masked UI to the viewport (0.0-1.0)
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pivot`` (Vector2D):  [Read-Write] The Alignment/Pivot point that the widget is placed at relative to the position.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_hardware_input`` (bool):  [Read-Write] Register with the viewport for hardware input from the true mouse and keyboard.  These widgets
      will more or less react like regular 2D widgets in the viewport, e.g. they can and will steal focus
      from the viewport.
      
      WARNING: If you are making a VR game, definitely do not change this to true.  This option should ONLY be used
      if you're making what would otherwise be a normal menu for a game, just in 3D.  If you also need the game to
      remain responsive and for the player to be able to interact with UI and move around the world (such as a keypad on a door),
      use the WidgetInteractionComponent instead.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``redraw_time`` (float):  [Read-Write] The time in between draws, if 0 - we would redraw every frame.  If 1, we would redraw every second.
      This will work with bManuallyRedraw as well.  So you can say, manually redraw, but only redraw at this
      maximum rate.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``shared_layer_name`` (Name):  [Read-Write] Layer Name the widget will live on
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``space`` (WidgetSpace):  [Read-Write] The coordinate space in which to render the widget
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``tick_mode`` (TickMode):  [Read-Write]
    - ``tick_when_offscreen`` (bool):  [Read-Write] Should the component tick the widget when it's off screen?
    - ``timing_policy`` (WidgetTimingPolicy):  [Read-Write] How this widget should deal with timing, pausing, etc.
    - ``tint_color_and_opacity`` (LinearColor):  [Read-Write] Tint color and opacity for this component
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_invalidation_in_world_space`` (bool):  [Read-Write] Use the invalidation system to update this widget.
      Only valid in World space. In Screen space, the widget is updated by the viewport owners.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``widget_class`` (type(Class)):  [Read-Write] The class of User Widget to create and display an instance of
    - ``window_focusable`` (bool):  [Read-Write] Is the virtual window created to host the widget focusable?
    - ``window_visibility`` (WindowVisibility):  [Read-Write] The visibility of the virtual window created to host the widget
    """
    ...

class VREditorFloatingUI(VREditorBaseActor):
    r"""
    Represents an interactive floating UI panel in the VR Editor
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorFloatingUI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class VREditorDockableWindow(VREditorFloatingUI):
    r"""
    An interactive floating UI panel that can be dragged around
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorDockableWindow.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class VREditorDockableCameraWindow(VREditorDockableWindow):
    r"""
    A specialized dockable window for camera viewfinders in VR that applies the correct material
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorDockableCameraWindow.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class VREditorFloatingCameraUI(VREditorFloatingUI):
    r"""
    Represents an interactive floating UI camera preview panel in the VR Editor
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorFloatingCameraUI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``offset_from_camera`` (Vector):  [Read-Write] The offset of this UI from its camera
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class FloatingText(Actor):
    r"""
    Draws 3D text in the world along with targeting line cues
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorFloatingText.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class ViewportInteractor(Object):
    r"""
    Represents the interactor in the world
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: ViewportInteractor.h
    
    """
    def tick(self, delta_time: float) -> None:
        r"""
        x.tick(delta_time) -> None
        Update for this interactor called by the ViewportWorldInteraction
        
        Args:
            delta_time (float):
        """
        ...
    def shutdown(self) -> None:
        r"""
        x.shutdown() -> None
        Whenever the ViewportWorldInteraction is shut down, the interacts will shut down as well
        """
        ...
    def set_hit_result_gizmo_filter_mode(self, new_filter: HitResultGizmoFilterMode) -> None:
        r"""
        x.set_hit_result_gizmo_filter_mode(new_filter) -> None
        Sets the current gizmo filter mode used for Interaction
        
        Args:
            new_filter (HitResultGizmoFilterMode):
        """
        ...
    def set_dragging_mode(self, new_dragging_mode: ViewportInteractionDraggingMode) -> None:
        r"""
        x.set_dragging_mode(new_dragging_mode) -> None
        Sets the current dragging mode for this interactor
        
        Args:
            new_dragging_mode (ViewportInteractionDraggingMode):
        """
        ...
    def set_can_carry(self, can_carry: bool) -> None:
        r"""
        x.set_can_carry(can_carry) -> None
        Sets if the interactor can carry an object
        
        Args:
            can_carry (bool):
        """
        ...
    def is_hovering_over_gizmo(self) -> bool:
        r"""
        x.is_hovering_over_gizmo() -> bool
        If the interactor laser is currently hovering over a gizmo handle
        
        Returns:
            bool:
        """
        ...
    def handle_input_key_bp(self, action: ViewportActionKeyInput, key: Key, event: InputEventType) -> bool:
        r"""
        x.handle_input_key_bp(action, key, event) -> bool
        To be overridden. Called by HandleInputKey before delegates and default input implementation
        
        Args:
            action (ViewportActionKeyInput): 
            key (Key): 
            event (InputEventType): 
        
        Returns:
            bool: 
        
            out_was_handled (bool):
        """
        ...
    def handle_input_axis_bp(self, action: ViewportActionKeyInput, key: Key, delta: float, delta_time: float) -> bool:
        r"""
        x.handle_input_axis_bp(action, key, delta, delta_time) -> bool
        To be overridden. Called by HandleInputAxis before delegates and default input implementation
        
        Args:
            action (ViewportActionKeyInput): 
            key (Key): 
            delta (float): 
            delta_time (float): 
        
        Returns:
            bool: 
        
            out_was_handled (bool):
        """
        ...
    def get_world_interaction(self) -> ViewportWorldInteraction:
        r"""
        x.get_world_interaction() -> ViewportWorldInteraction
        Gets the world interaction
        
        Returns:
            ViewportWorldInteraction:
        """
        ...
    def get_transform_and_forward_vector(self) -> Optional[Tuple[Transform, Vector]]:
        r"""
        x.get_transform_and_forward_vector() -> (out_hand_transform=Transform, out_forward_vector=Vector) or None
        Creates a hand transform and forward vector for a laser pointer for a given hand
        
        Returns:
            tuple or None: True if we have motion controller data for this hand and could return a valid result
        
            out_hand_transform (Transform): The created hand transform
        
            out_forward_vector (Vector): The forward vector of the hand
        """
        ...
    def get_transform(self) -> Transform:
        r"""
        x.get_transform() -> Transform
        Gets the world transform of this interactor
        
        Returns:
            Transform:
        """
        ...
    def get_room_space_transform(self) -> Transform:
        r"""
        x.get_room_space_transform() -> Transform
        Gets the hand transform of the interactor, in the local tracking space
        
        Returns:
            Transform:
        """
        ...
    def get_other_interactor(self) -> ViewportInteractor:
        r"""
        x.get_other_interactor() -> ViewportInteractor
        Gets the paired interactor assigned by the world interaction, can return null when there is no other interactor
        
        Returns:
            ViewportInteractor:
        """
        ...
    def get_last_transform(self) -> Transform:
        r"""
        x.get_last_transform() -> Transform
        Gets the last world transform of this interactor
        
        Returns:
            Transform:
        """
        ...
    def get_last_room_space_transform(self) -> Transform:
        r"""
        x.get_last_room_space_transform() -> Transform
        Gets the last hand transform of the interactor, in the local tracking space
        
        Returns:
            Transform:
        """
        ...
    def get_laser_pointer(self, even_if_blocked: bool = False, laser_length_override: float = 0.000000) -> Optional[Tuple[Vector, Vector]]:
        r"""
        x.get_laser_pointer(even_if_blocked=False, laser_length_override=0.000000) -> (laser_pointer_start=Vector, laser_pointer_end=Vector) or None
        Gets the start and end point of the laser pointer for the specified hand
        
        Args:
            even_if_blocked (bool): If true, returns a laser pointer even if the hand has UI in front of it (defaults to false)
            laser_length_override (float): If zero the default laser length (VREdMode::GetLaserLength) is used
        
        Returns:
            tuple or None: True if we have motion controller data for this hand and could return a valid result
        
            laser_pointer_start (Vector): 
        
            laser_pointer_end (Vector):
        """
        ...
    def get_hover_location(self) -> Vector:
        r"""
        x.get_hover_location() -> Vector
        Gets the interactor laser hover location
        
        Returns:
            Vector:
        """
        ...
    def get_hit_result_gizmo_filter_mode(self) -> HitResultGizmoFilterMode:
        r"""
        x.get_hit_result_gizmo_filter_mode() -> HitResultGizmoFilterMode
        Gets current gizmo filter mode used for Interaction
        
        Returns:
            HitResultGizmoFilterMode:
        """
        ...
    def get_dragging_mode(self) -> ViewportInteractionDraggingMode:
        r"""
        x.get_dragging_mode() -> ViewportInteractionDraggingMode
        Gets the current interactor data dragging mode
        
        Returns:
            ViewportInteractionDraggingMode:
        """
        ...
    def can_carry(self) -> bool:
        r"""
        x.can_carry() -> bool
        Gets if the interactor can carry an object
        
        Returns:
            bool:
        """
        ...

class VREditorInteractor(ViewportInteractor):
    r"""
    VREditor default interactor
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorInteractor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``hand_mesh_component`` (StaticMeshComponent):  [Read-Write] Access to the current handmesh. Use ReplaceHandMeshComponent() to update the entire StaticMeshComponent.
    - ``is_undo_redo_swipe_enabled`` (bool):  [Read-Write] Whether swiping left/right on touchpad/joystick triggers undo/redo
    """
    @property
    def hand_mesh_component(self) -> StaticMeshComponent:
        r"""
        (StaticMeshComponent):  [Read-Write] Access to the current handmesh. Use ReplaceHandMeshComponent() to update the entire StaticMeshComponent.
        """
        ...
    @hand_mesh_component.setter
    def hand_mesh_component(self, value: StaticMeshComponent) -> None:
        ...
    def update_hand_mesh_relative_transform(self) -> None:
        r"""
        x.update_hand_mesh_relative_transform() -> None
        Update Hand Mesh Relative Transform
        """
        ...
    def try_override_controller_type(self, controller_type: ControllerType) -> bool:
        r"""
        x.try_override_controller_type(controller_type) -> bool
        Temporary set what controller type this is for asymmetric control schemes.
        You can't override the controller type when there's already an override.
        Remove the temporary controller type with EControllerType::Unknown
        
        Args:
            controller_type (ControllerType): 
        
        Returns:
            bool: true if the controller type was changed
        """
        ...
    def setup_component(self, owning_actor: Actor) -> None:
        r"""
        x.setup_component(owning_actor) -> None
        Sets up all components
        
        Args:
            owning_actor (Actor):
        """
        ...
    def set_force_show_laser(self, force_show: bool) -> None:
        r"""
        x.set_force_show_laser(force_show) -> None
        Set if we want to force to show the laser
        
        Args:
            force_show (bool):
        """
        ...
    def set_force_laser_color(self, color: LinearColor) -> None:
        r"""
        x.set_force_laser_color(color) -> None
        Next frame this will be used as color for the laser
        
        Args:
            color (LinearColor):
        """
        ...
    def set_controller_type(self, controller_type: ControllerType) -> None:
        r"""
        x.set_controller_type(controller_type) -> None
        Set what controller type this is for asymmetric control schemes
        
        Args:
            controller_type (ControllerType):
        """
        ...
    def set_controller_hand_side(self, controller_hand_side: Name) -> None:
        r"""
        x.set_controller_hand_side(controller_hand_side) -> None
        Sets the EControllerHand for this motioncontroller
        
        Args:
            controller_hand_side (Name):
        """
        ...
    def replace_hand_mesh_component(self, new_mesh: StaticMesh, mesh_scale: Vector = [1.000000, 1.000000, 1.000000]) -> None:
        r"""
        x.replace_hand_mesh_component(new_mesh, mesh_scale=[1.000000, 1.000000, 1.000000]) -> None
        Replace the default VR controller mesh with a custom one.
        
        Args:
            new_mesh (StaticMesh): 
            mesh_scale (Vector):
        """
        ...
    def is_touching_trackpad(self) -> bool:
        r"""
        x.is_touching_trackpad() -> bool
        Check if the touchpad is currently touched
        
        Returns:
            bool:
        """
        ...
    def is_hovering_over_ui(self) -> bool:
        r"""
        x.is_hovering_over_ui() -> bool
        Gets if this interactor is hovering over UI
        
        Returns:
            bool:
        """
        ...
    def is_clicking_on_ui(self) -> bool:
        r"""
        x.is_clicking_on_ui() -> bool
        Gets if the interactor is clicking on any UI
        
        Returns:
            bool:
        """
        ...
    def init(self, vr_mode: VREditorMode) -> None:
        r"""
        x.init(vr_mode) -> None
        Initialize default values
        
        Args:
            vr_mode (VREditorMode):
        """
        ...
    def get_trackpad_position(self) -> Vector2D:
        r"""
        x.get_trackpad_position() -> Vector2D
        Get the current position of the trackpad or analog stick
        
        Returns:
            Vector2D:
        """
        ...
    def get_teleport_actor(self) -> VREditorTeleporter:
        r"""
        x.get_teleport_actor() -> VREditorTeleporter
        Get Teleport Actor
        
        Returns:
            VREditorTeleporter:
        """
        ...
    def get_slide_delta(self) -> float:
        r"""
        x.get_slide_delta() -> float
        Returns the slide delta for pushing and pulling objects. Needs to be implemented by derived classes (e.g. touchpad for vive controller or scrollweel for mouse )
        
        Returns:
            float:
        """
        ...
    def get_select_and_move_trigger_value(self) -> float:
        r"""
        x.get_select_and_move_trigger_value() -> float
        Gets the trigger value
        
        Returns:
            float:
        """
        ...
    def get_motion_controller_component(self) -> MotionControllerComponent:
        r"""
        x.get_motion_controller_component() -> MotionControllerComponent
        Get the motioncontroller component of this interactor
        
        Returns:
            MotionControllerComponent:
        """
        ...
    def get_last_trackpad_position(self) -> Vector2D:
        r"""
        x.get_last_trackpad_position() -> Vector2D
        Get the last position of the trackpad or analog stick
        
        Returns:
            Vector2D:
        """
        ...
    def get_laser_start(self) -> Vector:
        r"""
        x.get_laser_start() -> Vector
        Getters and setters
        
        Returns:
            Vector:
        """
        ...
    def get_laser_end(self) -> Vector:
        r"""
        x.get_laser_end() -> Vector
        Get Laser End
        
        Returns:
            Vector:
        """
        ...
    def get_hmd_device_type(self) -> Name:
        r"""
        x.get_hmd_device_type() -> Name
        
        
        Returns:
            Name: Returns the type of HMD we're dealing with
        """
        ...
    def get_controller_type(self) -> ControllerType:
        r"""
        x.get_controller_type() -> ControllerType
        Returns what controller type this is for asymmetric control schemes
        
        Returns:
            ControllerType:
        """
        ...
    def get_controller_side(self) -> ControllerHand:
        r"""
        x.get_controller_side() -> ControllerHand
        Get the side of the controller
        
        Returns:
            ControllerHand:
        """
        ...
    def get_controller_hand_side(self) -> Name:
        r"""
        x.get_controller_hand_side() -> Name
        Sets the EControllerHand for this motioncontroller
        
        Returns:
            Name:
        """
        ...

class EditorWorldExtension(Object):
    r"""
    Editor World Extension
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorWorldExtension.h
    
    """
    ...

class VREditorModeBase(EditorWorldExtension):
    r"""
    VREditor Mode Base
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorModeBase.h
    
    """
    ...

class VREditorMode(VREditorModeBase):
    r"""
    VR Editor Mode. Extends editor viewports with functionality for VR controls and object manipulation
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorMode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``interactor_class`` (Class):  [Read-Write] The controller to use when UnrealEd is in VR mode. Use VREditorInteractor get default editor behavior, or select a custom controller for special behavior
    - ``teleporter_class`` (Class):  [Read-Write] The teleporter to use when UnrealEd is in VR mode. Use VREditorTeleporter to get default editor behavior, or select a custom teleporter
    """
    @property
    def interactor_class(self) -> Class:
        r"""
        (Class):  [Read-Write] The controller to use when UnrealEd is in VR mode. Use VREditorInteractor get default editor behavior, or select a custom controller for special behavior
        """
        ...
    @interactor_class.setter
    def interactor_class(self, value: Class) -> None:
        ...
    @property
    def teleporter_class(self) -> Class:
        r"""
        (Class):  [Read-Write] The teleporter to use when UnrealEd is in VR mode. Use VREditorTeleporter to get default editor behavior, or select a custom teleporter
        """
        ...
    @teleporter_class.setter
    def teleporter_class(self, value: Class) -> None:
        ...
    def set_game_view(self, game_view: bool) -> None:
        r"""
        x.set_game_view(game_view) -> None
        Display the scene more closely to how it would appear at runtime (as opposed to edit time).
        
        Args:
            game_view (bool):
        """
        ...
    def is_in_game_view(self) -> bool:
        r"""
        x.is_in_game_view() -> bool
        Returns whether game view is currently active.
        
        Returns:
            bool:
        """
        ...
    def get_world_scale_factor(self) -> float:
        r"""
        x.get_world_scale_factor() -> float
        Gets the world scale factor, which can be multiplied by a scale vector to convert to room space
        
        Returns:
            float:
        """
        ...

class VREditorRadialFloatingUI(VREditorBaseActor):
    r"""
    Represents an interactive floating UI panel in the VR Editor
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorRadialFloatingUI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class VREditorTeleporter(Actor):
    r"""
    VR Editor teleport manager and the visual representation of the teleport
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VREditorTeleporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    def teleport_done(self) -> None:
        r"""
        x.teleport_done() -> None
        Called when teleport is done for cleanup
        """
        ...
    def stop_aiming(self) -> None:
        r"""
        x.stop_aiming() -> None
        Cancel teleport aiming mode without doing the teleport
        """
        ...
    def start_teleport(self) -> None:
        r"""
        x.start_teleport() -> None
        Start teleporting, does a ray trace with the hand passed and calculates the locations for lerp movement in Teleport
        """
        ...
    def start_aiming(self, interactor: ViewportInteractor) -> None:
        r"""
        x.start_aiming(interactor) -> None
        Functions we call to handle teleporting in navigation mode
        
        Args:
            interactor (ViewportInteractor):
        """
        ...
    def shutdown(self) -> None:
        r"""
        x.shutdown() -> None
        Shuts down the teleporter
        """
        ...
    def set_visibility(self, visible: bool) -> None:
        r"""
        x.set_visibility(visible) -> None
        Hide or show the teleporter visuals
        
        Args:
            visible (bool):
        """
        ...
    def set_color(self, color: LinearColor) -> None:
        r"""
        x.set_color(color) -> None
        Sets the color for the teleporter visuals
        
        Args:
            color (LinearColor):
        """
        ...
    def is_teleporting(self) -> bool:
        r"""
        x.is_teleporting() -> bool
        Is Teleporting
        
        Returns:
            bool:
        """
        ...
    def is_aiming(self) -> bool:
        r"""
        x.is_aiming() -> bool
        Whether we are currently aiming to teleport.
        
        Returns:
            bool:
        """
        ...
    def init(self, mode: VREditorMode) -> None:
        r"""
        x.init(mode) -> None
        Initializes the teleporter
        
        Args:
            mode (VREditorMode):
        """
        ...
    def get_vr_mode(self) -> VREditorMode:
        r"""
        x.get_vr_mode() -> VREditorMode
        Get VRMode
        
        Returns:
            VREditorMode:
        """
        ...
    def get_slide_delta(self, interactor: VREditorInteractor, axis: bool) -> float:
        r"""
        x.get_slide_delta(interactor, axis) -> float
        Get slide delta to push/pull or scale the teleporter
        
        Args:
            interactor (VREditorInteractor): 
            axis (bool): 
        
        Returns:
            float:
        """
        ...
    def get_interactor_trying_teleport(self) -> ViewportInteractor:
        r"""
        x.get_interactor_trying_teleport() -> ViewportInteractor
        Get the actor we're currently trying to teleport with.
        Valid during aiming and teleporting.
        
        Returns:
            ViewportInteractor:
        """
        ...
    def do_teleport(self) -> None:
        r"""
        x.do_teleport() -> None
        Do and finalize teleport.
        """
        ...

class VRScoutingInteractor(VREditorInteractor):
    r"""
    Represents the interactor in the world
    
    **C++ Source:**
    
    - **Module**: VREditor
    - **File**: VRScoutingInteractor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``flying_indicator_component`` (StaticMeshComponent):  [Read-Write] Shown in Navigation mode
    - ``hand_mesh_component`` (StaticMeshComponent):  [Read-Write] Access to the current handmesh. Use ReplaceHandMeshComponent() to update the entire StaticMeshComponent.
    - ``is_undo_redo_swipe_enabled`` (bool):  [Read-Write] Whether swiping left/right on touchpad/joystick triggers undo/redo
    - ``receives_editor_input`` (bool):  [Read-Write] If set to true, then this interactor will be able to recieve input delegate callbacks when in the editor. Defaults to true since we will always want this interactor to consume input
    """
    @property
    def flying_indicator_component(self) -> StaticMeshComponent:
        r"""
        (StaticMeshComponent):  [Read-Only] Shown in Navigation mode
        """
        ...
    @property
    def receives_editor_input(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true, then this interactor will be able to recieve input delegate callbacks when in the editor. Defaults to true since we will always want this interactor to consume input
        """
        ...
    @receives_editor_input.setter
    def receives_editor_input(self, value: bool) -> None:
        ...
    def set_gizmo_mode(self, gizmo_mode: GizmoHandleTypes) -> None:
        r"""
        x.set_gizmo_mode(gizmo_mode) -> None
        Sets the gizmo mode for selected object
        
        Args:
            gizmo_mode (GizmoHandleTypes):
        """
        ...
    @classmethod
    def get_selected_actors(cls) -> Array[Actor]:
        r"""
        X.get_selected_actors() -> Array[Actor]
        Gets all actors that are selected in the world editor
        
        Returns:
            Array[Actor]:
        """
        ...
    def get_input_component(self) -> InputComponent:
        r"""
        x.get_input_component() -> InputComponent
        Returns the current InputComponent. This will be NULL unless bReceivesEditorInput is set to true.
        
        Returns:
            InputComponent:
        """
        ...
    def get_gizmo_mode(self) -> GizmoHandleTypes:
        r"""
        x.get_gizmo_mode() -> GizmoHandleTypes
        Gets the gizmo mode for selected object
        
        Returns:
            GizmoHandleTypes:
        """
        ...

class Factory(Object):
    r"""
    Base class for all factories
    An object responsible for creating and importing new objects.
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: Factory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    @property
    def create_new(self) -> bool:
        r"""
        (bool):  [Read-Write] The default value to return from CanCreateNew()
        """
        ...
    @create_new.setter
    def create_new(self, value: bool) -> None:
        ...
    @property
    def supported_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] The class manufactured by this factory.
        """
        ...
    @supported_class.setter
    def supported_class(self, value: Class) -> None:
        ...
    @property
    def context_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Class of the context object used to help create the object.
        """
        ...
    @context_class.setter
    def context_class(self, value: Class) -> None:
        ...
    @property
    def formats(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
        """
        ...
    @formats.setter
    def formats(self, value: Array[str]) -> None:
        ...
    @property
    def edit_after_new(self) -> bool:
        r"""
        (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
        """
        ...
    @edit_after_new.setter
    def edit_after_new(self, value: bool) -> None:
        ...
    @property
    def editor_import(self) -> bool:
        r"""
        (bool):  [Read-Write] true if the factory imports objects from files.
        """
        ...
    @editor_import.setter
    def editor_import(self, value: bool) -> None:
        ...
    @property
    def text(self) -> bool:
        r"""
        (bool):  [Read-Write] true if the factory imports objects from text.
        """
        ...
    @text.setter
    def text(self, value: bool) -> None:
        ...
    @property
    def automated_import_data(self) -> AutomatedAssetImportData:
        r"""
        (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
        """
        ...
    @automated_import_data.setter
    def automated_import_data(self, value: AutomatedAssetImportData) -> None:
        ...
    @property
    def asset_import_task(self) -> AssetImportTask:
        r"""
        (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
        """
        ...
    @asset_import_task.setter
    def asset_import_task(self, value: AssetImportTask) -> None:
        ...
    def script_factory_create_file(self, task: AssetImportTask) -> bool:
        r"""
        x.script_factory_create_file(task) -> bool
        Import object(s) using a task via script
        
        Args:
            task (AssetImportTask): 
        
        Returns:
            bool: True if script implements
        """
        ...
    def script_factory_can_import(self, filename: str) -> bool:
        r"""
        x.script_factory_can_import(filename) -> bool
        Whether the specified file can be imported by this factory. (Implemented in script)
        
        Args:
            filename (str): 
        
        Returns:
            bool: true if the file is supported, false otherwise.
        """
        ...

class RuntimeVirtualTextureFactory(Factory):
    r"""
    Factory for URuntimeVirtualTexture
    
    **C++ Source:**
    
    - **Module**: VirtualTexturingEditor
    - **File**: RuntimeVirtualTextureFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class VirtualTextureBuilderFactory(Factory):
    r"""
    Factory for UVirtualTextureBuilder
    
    **C++ Source:**
    
    - **Module**: VirtualTexturingEditor
    - **File**: VirtualTextureBuilderFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MotionControllerComponent(PrimitiveComponent):
    r"""
    Motion Controller Component
    
    **C++ Source:**
    
    - **Module**: HeadMountedDisplay
    - **File**: MotionControllerComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``current_tracking_status`` (TrackingStatus):  [Read-Write] The tracking status for the device (e.g. full tracking, inertial tracking only, no tracking)
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disable_low_latency_update`` (bool):  [Read-Write] If false, render transforms within the motion controller hierarchy will be updated a second time immediately before rendering.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``motion_source`` (Name):  [Read-Write] Defines which pose this component should receive from the OpenXR Runtime. Left/Right MotionSource is the same as LeftGrip/RightGrip. See OpenXR specification for details on poses.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``player_index`` (int32):  [Read-Write] Which player index this motion controller should automatically follow
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def player_index(self) -> int:
        r"""
        (int32):  [Read-Write] Which player index this motion controller should automatically follow
        """
        ...
    @player_index.setter
    def player_index(self, value: int) -> None:
        ...
    @property
    def motion_source(self) -> Name:
        r"""
        (Name):  [Read-Write] Defines which pose this component should receive from the OpenXR Runtime. Left/Right MotionSource is the same as LeftGrip/RightGrip. See OpenXR specification for details on poses.
        """
        ...
    @motion_source.setter
    def motion_source(self, value: Name) -> None:
        ...
    @property
    def disable_low_latency_update(self) -> bool:
        r"""
        (bool):  [Read-Write] If false, render transforms within the motion controller hierarchy will be updated a second time immediately before rendering.
        """
        ...
    @disable_low_latency_update.setter
    def disable_low_latency_update(self, value: bool) -> None:
        ...
    @property
    def current_tracking_status(self) -> TrackingStatus:
        r"""
        (TrackingStatus):  [Read-Only] The tracking status for the device (e.g. full tracking, inertial tracking only, no tracking)
        """
        ...
    def on_motion_controller_updated(self) -> None:
        r"""
        x.on_motion_controller_updated() -> None
        Blueprint Implementable function for responding to updated data from a motion controller (so we can use custom parameter values from it)
        """
        ...
    def is_tracked(self) -> bool:
        r"""
        x.is_tracked() -> bool
        Whether or not this component had a valid tracked device this frame
        
        Returns:
            bool:
        """
        ...
    def get_parameter_value(self, name: Name) -> Tuple[float, bool]:
        r"""
        x.get_parameter_value(name) -> (float, value_found=bool)
        Returns the value of a custom parameter on the current in use Motion Controller (see member InUseMotionController). Only valid for the duration of OnMotionControllerUpdated
        
        Args:
            name (Name): 
        
        Returns:
            bool: 
        
            value_found (bool):
        """
        ...
    def get_linear_velocity(self) -> Optional[Vector]:
        r"""
        x.get_linear_velocity() -> Vector or None
        If the motion tracking system provides linear velocity at this time the vector will be that velocity in cm/s in unreal world space and the function will return true.  If velocity is unavailable it will return false.
        
        Returns:
            Vector or None: 
        
            out_linear_velocity (Vector):
        """
        ...
    def get_linear_acceleration(self) -> Optional[Vector]:
        r"""
        x.get_linear_acceleration() -> Vector or None
        If the motion tracking system provides linear acceleration at this time the vector will be that acceleration in cm/(s^2) in unreal world space and the function will return true.  If acceleration is unavailable it will return false.
        
        Returns:
            Vector or None: 
        
            out_linear_acceleration (Vector):
        """
        ...
    def get_hand_joint_position(self, joint_index: int) -> Tuple[Vector, bool]:
        r"""
        x.get_hand_joint_position(joint_index) -> (Vector, value_found=bool)
        Get Hand Joint Position
        
        Args:
            joint_index (int32): 
        
        Returns:
            bool: 
        
            value_found (bool):
        """
        ...
    def get_angular_velocity(self) -> Optional[Rotator]:
        r"""
        x.get_angular_velocity() -> Rotator or None
        If the motion tracking system provides angular velocity at this time OutAngularVelocity will be that velocity in deg/s in unreal world space and the function will return true. Note that it is not difficult to rotate a controller at more than 0.5 or 1 rotation per second briefly and some mathmatical operations(such as conversion to quaternion) lose rotations beyond 180 degrees or 360 degrees..  In some cases that is OK becuase the resulting final rotation is the same, but in some cases it would generate incorrect results.   If angular velocity is unavailable it will return false.
        
        Returns:
            Rotator or None: 
        
            out_angular_velocity (Rotator):
        """
        ...

class MouseCursorInteractor(ViewportInteractor):
    r"""
    Viewport interactor for a mouse cursor
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: MouseCursorInteractor.h
    
    """
    ...

class BaseTransformGizmo(Actor):
    r"""
    Base class for transform gizmo
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIBaseTransformGizmo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class ViewportDragOperationComponent(ActorComponent):
    r"""
    Container component for UViewportDragOperation that can be used by objects in the world that are draggable and implement the ViewportInteractableInterface
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: ViewportDragOperation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class ViewportWorldInteraction(EditorWorldExtension):
    r"""
    Viewport World Interaction
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: ViewportWorldInteraction.h
    
    """
    def set_world_to_meters_scale(self, new_world_to_meters_scale: float, compensate_room_world_scale: bool = False) -> None:
        r"""
        x.set_world_to_meters_scale(new_world_to_meters_scale, compensate_room_world_scale=False) -> None
        Sets GNewWorldToMetersScale
        
        Args:
            new_world_to_meters_scale (float): 
            compensate_room_world_scale (bool):
        """
        ...
    def set_room_transform_for_next_frame(self, new_room_transform: Transform) -> None:
        r"""
        x.set_room_transform_for_next_frame(new_room_transform) -> None
        Set Room Transform for Next Frame
        
        Args:
            new_room_transform (Transform):
        """
        ...
    def set_head_transform(self, new_head_transform: Transform) -> None:
        r"""
        x.set_head_transform(new_head_transform) -> None
        Sets a new transform for the room so that the HMD is aligned to the new transform.
                      The Head is kept level to the ground and only rotated on the yaw
        
        Args:
            new_head_transform (Transform):
        """
        ...
    def remove_interactor(self, interactor: ViewportInteractor) -> None:
        r"""
        x.remove_interactor(interactor) -> None
        Removes interactor from the worldinteraction and removes the interactor from its paired interactor if any
        
        Args:
            interactor (ViewportInteractor):
        """
        ...
    def get_world_scale_factor(self) -> float:
        r"""
        x.get_world_scale_factor() -> float
        Gets the world scale factor, which can be multiplied by a scale vector to convert to room space
        
        Returns:
            float:
        """
        ...
    def get_transform_gizmo_actor(self) -> BaseTransformGizmo:
        r"""
        x.get_transform_gizmo_actor() -> BaseTransformGizmo
        Gets the transform gizmo actor, or returns null if we currently don't have one
        
        Returns:
            BaseTransformGizmo:
        """
        ...
    def get_room_transform(self) -> Transform:
        r"""
        x.get_room_transform() -> Transform
        Gets the world space transform of the calibrated VR room origin.  When using a seated VR device, this will feel like the
              camera's world transform (before any HMD positional or rotation adjustments are applied.)
        
        Returns:
            Transform:
        """
        ...
    def get_room_space_head_transform(self) -> Transform:
        r"""
        x.get_room_space_head_transform() -> Transform
        Gets the transform of the viewport / user's HMD in room space
        
        Returns:
            Transform:
        """
        ...
    def get_interactors(self) -> Array[ViewportInteractor]:
        r"""
        x.get_interactors() -> Array[ViewportInteractor]
        Gets all the interactors
        
        Returns:
            Array[ViewportInteractor]:
        """
        ...
    def get_head_transform(self) -> Transform:
        r"""
        x.get_head_transform() -> Transform
        Gets the transform of the viewport / user's HMD in world space
        
        Returns:
            Transform:
        """
        ...
    def add_interactor(self, interactor: ViewportInteractor) -> None:
        r"""
        x.add_interactor(interactor) -> None
        Adds interactor to the worldinteraction
        
        Args:
            interactor (ViewportInteractor):
        """
        ...
    def add_actor_to_exclude_from_hit_tests(self, actor_to_exclude_from_hit_tests: Actor) -> None:
        r"""
        x.add_actor_to_exclude_from_hit_tests(actor_to_exclude_from_hit_tests) -> None
        Adds an actor to the list of actors to never allow an interactor to hit in the scene.  No selection.  No hover.
        There's no need to remove actors from this list.  They'll expire from it automatically when destroyed.
        
        Args:
            actor_to_exclude_from_hit_tests (Actor): The actor that should be forever excluded from hit tests
        """
        ...

class GizmoHandleGroup(SceneComponent):
    r"""
    Base class for gizmo handles
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIGizmoHandle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class AxisGizmoHandleGroup(GizmoHandleGroup):
    r"""
    Base class for gizmo handles on axis
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIGizmoHandle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class StaticMeshComponent(MeshComponent):
    r"""
    StaticMeshComponent is used to create an instance of a UStaticMesh.
    A static mesh is a piece of geometry that consists of a static set of polygons.
    see: https://docs.unrealengine.com/latest/INT/Engine/Content/Types/StaticMeshes/
    see: UStaticMesh
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StaticMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    @property
    def forced_lod_model(self) -> int:
        r"""
        (int32):  [Read-Only] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
        """
        ...
    @property
    def previous_lod_level(self) -> int:
        r"""
        (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
        deprecated: This property is deprecated and no longer supported.
        """
        ...
    @previous_lod_level.setter
    def previous_lod_level(self, value: int) -> None:
        ...
    @property
    def min_lod(self) -> int:
        r"""
        (int32):  [Read-Only] Specifies the smallest LOD that will be used for this component.
        This is ignored if ForcedLodModel is enabled.
        """
        ...
    @property
    def static_mesh(self) -> StaticMesh:
        r"""
        (StaticMesh):  [Read-Only]
        """
        ...
    @property
    def wireframe_color_override(self) -> Color:
        r"""
        (Color):  [Read-Only] Wireframe color to use if bOverrideWireframeColor is true
        """
        ...
    @property
    def force_nanite_for_masked(self) -> bool:
        r"""
        (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
        """
        ...
    @force_nanite_for_masked.setter
    def force_nanite_for_masked(self, value: bool) -> None:
        ...
    @property
    def disallow_nanite(self) -> bool:
        r"""
        (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
        """
        ...
    @disallow_nanite.setter
    def disallow_nanite(self, value: bool) -> None:
        ...
    @property
    def evaluate_world_position_offset(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to evaluate World Position Offset.
        """
        ...
    @evaluate_world_position_offset.setter
    def evaluate_world_position_offset(self, value: bool) -> None:
        ...
    @property
    def world_position_offset_writes_velocity(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether world position offset turns on velocity writes.
        If the WPO isn't static then setting false may give incorrect motion vectors.
        But if we know that the WPO is static then setting false may save performance.
        """
        ...
    @world_position_offset_writes_velocity.setter
    def world_position_offset_writes_velocity(self, value: bool) -> None:
        ...
    @property
    def evaluate_world_position_offset_in_ray_tracing(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
        This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
        """
        ...
    @evaluate_world_position_offset_in_ray_tracing.setter
    def evaluate_world_position_offset_in_ray_tracing(self, value: bool) -> None:
        ...
    @property
    def world_position_offset_disable_distance(self) -> int:
        r"""
        (int32):  [Read-Only] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
        """
        ...
    @property
    def override_wireframe_color(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
        """
        ...
    @property
    def override_min_lod(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
        """
        ...
    @property
    def disallow_mesh_paint_per_instance(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
        """
        ...
    @disallow_mesh_paint_per_instance.setter
    def disallow_mesh_paint_per_instance(self, value: bool) -> None:
        ...
    @property
    def ignore_instance_for_texture_streaming(self) -> bool:
        r"""
        (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
        This can be useful when doing things like applying character textures to static geometry,
        to avoid them using distance-based streaming.
        """
        ...
    @ignore_instance_for_texture_streaming.setter
    def ignore_instance_for_texture_streaming(self, value: bool) -> None:
        ...
    @property
    def override_light_map_res(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to override the lightmap resolution defined in the static mesh.
        """
        ...
    @property
    def cast_distance_field_indirect_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
        This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
        The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
        """
        ...
    @property
    def override_distance_field_self_shadow_bias(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
        """
        ...
    @property
    def sort_triangles(self) -> bool:
        r"""
        (bool):  [Read-Only] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
        """
        ...
    @property
    def reverse_culling(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the static mesh component's backface culling should be reversed
        """
        ...
    @property
    def overridden_light_map_res(self) -> int:
        r"""
        (int32):  [Read-Only] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
        """
        ...
    @property
    def distance_field_indirect_shadow_min_visibility(self) -> float:
        r"""
        (float):  [Read-Only] Controls how dark the dynamic indirect shadow can be.
        """
        ...
    @property
    def distance_field_self_shadow_bias(self) -> float:
        r"""
        (float):  [Read-Only] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
        """
        ...
    @property
    def streaming_distance_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
        """
        ...
    @streaming_distance_multiplier.setter
    def streaming_distance_multiplier(self, value: float) -> None:
        ...
    def update_initial_evaluate_world_position_offset(self) -> None:
        r"""
        x.update_initial_evaluate_world_position_offset() -> None
        This manually updates the initial value of bEvaluateWorldPositionOffset to be the current value.
            This is useful if the default value of bEvaluateWorldPositionOffset is changed after constructing
            the component.
        """
        ...
    def set_world_position_offset_disable_distance(self, new_value: int) -> None:
        r"""
        x.set_world_position_offset_disable_distance(new_value) -> None
        Set World Position Offset Disable Distance
        
        Args:
            new_value (int32):
        """
        ...
    def set_static_mesh(self, new_mesh: StaticMesh) -> bool:
        r"""
        x.set_static_mesh(new_mesh) -> bool
        Change the StaticMesh used by this instance.
        
        Args:
            new_mesh (StaticMesh): 
        
        Returns:
            bool:
        """
        ...
    def set_reverse_culling(self, reverse_culling: bool) -> None:
        r"""
        x.set_reverse_culling(reverse_culling) -> None
        Set forced reverse culling
        
        Args:
            reverse_culling (bool):
        """
        ...
    def set_forced_lod_model(self, new_forced_lod_model: int) -> None:
        r"""
        x.set_forced_lod_model(new_forced_lod_model) -> None
        Set Forced Lod Model
        
        Args:
            new_forced_lod_model (int32):
        """
        ...
    def set_force_disable_nanite(self, force_disable_nanite: bool) -> None:
        r"""
        x.set_force_disable_nanite(force_disable_nanite) -> None
        Force disabling of Nanite rendering. When true, Will swap to the the fallback mesh instead.
        
        Args:
            force_disable_nanite (bool):
        """
        ...
    def set_evaluate_world_position_offset_in_ray_tracing(self, new_value: bool) -> None:
        r"""
        x.set_evaluate_world_position_offset_in_ray_tracing(new_value) -> None
        Set Evaluate World Position Offset in Ray Tracing
        
        Args:
            new_value (bool):
        """
        ...
    def set_evaluate_world_position_offset(self, new_value: bool) -> None:
        r"""
        x.set_evaluate_world_position_offset(new_value) -> None
        Set Evaluate World Position Offset
        
        Args:
            new_value (bool):
        """
        ...
    def set_distance_field_self_shadow_bias(self, new_value: float) -> None:
        r"""
        x.set_distance_field_self_shadow_bias(new_value) -> None
        Sets the component's DistanceFieldSelfShadowBias.  bOverrideDistanceFieldSelfShadowBias must be enabled for this to have an effect.
        
        Args:
            new_value (float):
        """
        ...
    def get_local_bounds(self) -> Tuple[Vector, Vector]:
        r"""
        x.get_local_bounds() -> (min=Vector, max=Vector)
        Get Local bounds
        
        Returns:
            tuple: 
        
            min (Vector): 
        
            max (Vector):
        """
        ...
    def get_initial_evaluate_world_position_offset(self) -> bool:
        r"""
        x.get_initial_evaluate_world_position_offset() -> bool
        Get the initial value of bEvaluateWorldPositionOffset. This is the value when BeginPlay() was last called, or if UpdateInitialEvaluateWorldPositionOffset is called.
        
        Returns:
            bool:
        """
        ...

class StaticMeshReplicatedComponent(StaticMeshComponent):
    r"""
    deprecated: 'StaticMeshReplicatedComponent' was renamed to 'StaticMeshComponent'.
    """
    ...

class GizmoHandleMeshComponent(StaticMeshComponent):
    r"""
    Gizmo Handle Mesh Component
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIGizmoHandleMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    ...

class PivotTransformGizmo(BaseTransformGizmo):
    r"""
    A transform gizmo on the pivot that allows you to interact with selected objects by moving, scaling and rotating.
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIPivotTransformGizmo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class PivotTranslationGizmoHandleGroup(AxisGizmoHandleGroup):
    r"""
    Axis Gizmo handle for translating
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIPivotTransformGizmo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class PivotScaleGizmoHandleGroup(AxisGizmoHandleGroup):
    r"""
    Axis Gizmo handle for scaling
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIPivotTransformGizmo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class PivotPlaneTranslationGizmoHandleGroup(AxisGizmoHandleGroup):
    r"""
    Axis Gizmo handle for plane translation
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIPivotTransformGizmo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class PivotRotationGizmoHandleGroup(AxisGizmoHandleGroup):
    r"""
    Axis Gizmo handle for rotation
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIPivotTransformGizmo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class StretchGizmoHandleGroup(GizmoHandleGroup):
    r"""
    Gizmo handle for stretching/scaling
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIStretchGizmoHandle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class UniformScaleGizmoHandleGroup(GizmoHandleGroup):
    r"""
    Gizmo handle for uniform scaling
    
    **C++ Source:**
    
    - **Module**: ViewportInteraction
    - **File**: VIUniformScaleGizmoHandle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class LevelEditorContextMenuContext(Object):
    r"""
    Level Editor Context Menu Context
    
    **C++ Source:**
    
    - **Module**: LevelEditor
    - **File**: LevelEditorMenuContext.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``context_type`` (LevelEditorMenuContext):  [Read-Only]
    - ``current_selection`` (TypedElementSelectionSet):  [Read-Only]
    - ``cursor_world_location`` (Vector):  [Read-Only]
    - ``hit_proxy_actor`` (Actor):  [Read-Only] If the ContextType is Viewport this property can be set to the HitProxy actor that triggered the ContextMenu.
    - ``selected_components`` (Array[ActorComponent]):  [Read-Only]
    """
    @property
    def context_type(self) -> LevelEditorMenuContext:
        r"""
        (LevelEditorMenuContext):  [Read-Only]
        """
        ...
    @property
    def current_selection(self) -> TypedElementSelectionSet:
        r"""
        (TypedElementSelectionSet):  [Read-Only]
        """
        ...
    @property
    def cursor_world_location(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def selected_components(self) -> Array[ActorComponent]:
        r"""
        (Array[ActorComponent]):  [Read-Only]
        """
        ...
    @property
    def hit_proxy_actor(self) -> Actor:
        r"""
        (Actor):  [Read-Only] If the ContextType is Viewport this property can be set to the HitProxy actor that triggered the ContextMenu.
        """
        ...
    def get_hit_proxy_element(self) -> ScriptTypedElementHandle:
        r"""
        x.get_hit_proxy_element() -> ScriptTypedElementHandle
        Get Script Hit Proxy Element
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...

class QuickActionMenuContext(Object):
    r"""
    Quick Action Menu Context
    
    **C++ Source:**
    
    - **Module**: LevelEditor
    - **File**: LevelEditorMenuContext.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``current_selection`` (TypedElementSelectionSet):  [Read-Only]
    """
    @property
    def current_selection(self) -> TypedElementSelectionSet:
        r"""
        (TypedElementSelectionSet):  [Read-Only]
        """
        ...

class Subsystem(Object):
    r"""
    Subsystems are auto instanced classes that share the lifetime of certain engine constructs
    
       Currently supported Subsystem lifetimes are:
               Engine           -> inherit UEngineSubsystem
               Editor           -> inherit UEditorSubsystem
               GameInstance -> inherit UGameInstanceSubsystem
               World            -> inherit UWorldSubsystem
               LocalPlayer      -> inherit ULocalPlayerSubsystem
    
    
       Normal Example:
               class UMySystem : public UGameInstanceSubsystem
       Which can be accessed by:
               UGameInstance* GameInstance = ...;
               UMySystem* MySystem = GameInstance->GetSubsystem<UMySystem>();
    
       or the following if you need protection from a null GameInstance
               UGameInstance* GameInstance = ...;
               UMyGameSubsystem* MySubsystem = UGameInstance::GetSubsystem<MyGameSubsystem>(GameInstance);
    
    
       You can get also define interfaces that can have multiple implementations.
       Interface Example :
        MySystemInterface
      With 2 concrete derivative classes:
        MyA : public MySystemInterface
        MyB : public MySystemInterface
    
       Which can be accessed by:
               UGameInstance* GameInstance = ...;
               const TArray<UMyGameSubsystem*>& MySubsystems = GameInstance->GetSubsystemArray<MyGameSubsystem>();
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Subsystem.h
    
    """
    ...

class DynamicSubsystem(Subsystem):
    r"""
    Dynamic Subsystems auto populate/depopulate existing collections when modules are loaded and unloaded
    
    Only UEngineSubsystems and UEditorSubsystems allow for dynamic loading.
    
    If instances of your subsystem aren't being created it maybe that the module they are in isn't being explicitly loaded,
    make sure there is a LoadModule("ModuleName") to load the module.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Subsystem.h
    
    """
    ...

class EditorSubsystem(DynamicSubsystem):
    r"""
    UEditorSubsystem
    Base class for auto instanced and initialized systems that share the lifetime of the Editor
    
    UEditorSubsystems are dynamic and will be initialized when the module is loaded if necessary.
    This means that after StartupModule() is called on the module containing a subsystem,
    the subsystem collection with instantiate and initialize the subsystem automatically.
    If the subsystem collection is created post module load then the instances will be created at
    collection initialization time.
    
    **C++ Source:**
    
    - **Module**: EditorSubsystem
    - **File**: EditorSubsystem.h
    
    """
    ...

class LevelEditorSubsystem(EditorSubsystem):
    r"""
    ULevelEditorSubsystem
    Subsystem for exposing Level Editor related functionality to scripts
    
    **C++ Source:**
    
    - **Module**: LevelEditor
    - **File**: LevelEditorSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_editor_camera_moved`` (OnLevelEditorEditorCameraMoved):  [Read-Write] Expose EditorCameraMoved to blueprints
    - ``on_map_changed`` (OnLevelEditorMapChanged):  [Read-Write] Expose MapChanged to blueprints. Note: This executes too early for some editor scripting, consider using OnMapOpened if this doesn't work for you.
    - ``on_map_opened`` (OnLevelEditorMapOpened):  [Read-Write] Expose MapOpened to blueprints
    - ``on_post_save_world`` (OnLevelEditorPostSaveWorld):  [Read-Write] Expose PostSaveWorld to blueprints
    - ``on_pre_save_world`` (OnLevelEditorPreSaveWorld):  [Read-Write] Expose PreSaveWorld to blueprints
    """
    @property
    def on_pre_save_world(self) -> OnLevelEditorPreSaveWorld:
        r"""
        (OnLevelEditorPreSaveWorld):  [Read-Write] Expose PreSaveWorld to blueprints
        """
        ...
    @on_pre_save_world.setter
    def on_pre_save_world(self, value: OnLevelEditorPreSaveWorld) -> None:
        ...
    @property
    def on_post_save_world(self) -> OnLevelEditorPostSaveWorld:
        r"""
        (OnLevelEditorPostSaveWorld):  [Read-Write] Expose PostSaveWorld to blueprints
        """
        ...
    @on_post_save_world.setter
    def on_post_save_world(self, value: OnLevelEditorPostSaveWorld) -> None:
        ...
    @property
    def on_editor_camera_moved(self) -> OnLevelEditorEditorCameraMoved:
        r"""
        (OnLevelEditorEditorCameraMoved):  [Read-Write] Expose EditorCameraMoved to blueprints
        """
        ...
    @on_editor_camera_moved.setter
    def on_editor_camera_moved(self, value: OnLevelEditorEditorCameraMoved) -> None:
        ...
    @property
    def on_map_changed(self) -> OnLevelEditorMapChanged:
        r"""
        (OnLevelEditorMapChanged):  [Read-Write] Expose MapChanged to blueprints. Note: This executes too early for some editor scripting, consider using OnMapOpened if this doesn't work for you.
        """
        ...
    @on_map_changed.setter
    def on_map_changed(self, value: OnLevelEditorMapChanged) -> None:
        ...
    @property
    def on_map_opened(self) -> OnLevelEditorMapOpened:
        r"""
        (OnLevelEditorMapOpened):  [Read-Write] Expose MapOpened to blueprints
        """
        ...
    @on_map_opened.setter
    def on_map_opened(self, value: OnLevelEditorMapOpened) -> None:
        ...
    def set_current_level_by_name(self, level_name: Name) -> bool:
        r"""
        x.set_current_level_by_name(level_name) -> bool
        Set the current level used by the world editor.
        If more than one level shares the same name, the first one encounter of that level name will be used.
        
        Args:
            level_name (Name): The name of the Level the actor belongs to (same name as in the ContentBrowser).
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def set_allows_cinematic_control(self, allow: bool, viewport_config_key: Name = "None") -> None:
        r"""
        x.set_allows_cinematic_control(allow, viewport_config_key="None") -> None
        Set Allows Cinematic Control
        
        Args:
            allow (bool): 
            viewport_config_key (Name):
        """
        ...
    def save_current_level(self) -> bool:
        r"""
        x.save_current_level() -> bool
        Saves the specified Level. Must already be saved at lease once to have a valid path.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def save_all_dirty_levels(self) -> bool:
        r"""
        x.save_all_dirty_levels() -> bool
        Saves all Level currently loaded by the World Editor.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def pilot_level_actor(self, actor_to_pilot: Actor, viewport_config_key: Name = "None") -> None:
        r"""
        x.pilot_level_actor(actor_to_pilot, viewport_config_key="None") -> None
        Pilot Level Actor
        
        Args:
            actor_to_pilot (Actor): 
            viewport_config_key (Name):
        """
        ...
    def new_level_from_template(self, asset_path: str, template_asset_path: str) -> bool:
        r"""
        x.new_level_from_template(asset_path, template_asset_path) -> bool
        Close the current Persistent Level (without saving it). Create a new Level base on another level and save it. Load the new created level.
        
        Args:
            asset_path (str): Asset Path of where the level will be saved. ie. /Game/MyFolder/MyAsset
            template_asset_path (str): Level to be used as Template. ie. /Game/MyFolder/MyAsset
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def new_level(self, asset_path: str, is_partitioned_world: bool = False) -> bool:
        r"""
        x.new_level(asset_path, is_partitioned_world=False) -> bool
        Close the current Persistent Level (without saving it). Create a new blank Level and save it. Load the new created level.
        
        Args:
            asset_path (str): Asset Path of where the level will be saved. ie. /Game/MyFolder/MyAsset
            is_partitioned_world (bool): If true, new map is partitioned.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def load_level(self, asset_path: str) -> bool:
        r"""
        x.load_level(asset_path) -> bool
        Close the current Persistent Level (without saving it). Loads the specified level.
        
        Args:
            asset_path (str): Asset Path of the level to be loaded. ie. /Game/MyFolder/MyAsset
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def is_in_play_in_editor(self) -> bool:
        r"""
        x.is_in_play_in_editor() -> bool
        Is in Play in Editor
        
        Returns:
            bool:
        """
        ...
    def get_viewport_config_keys(self) -> Array[Name]:
        r"""
        x.get_viewport_config_keys() -> Array[Name]
        Get Viewport Config Keys
        
        Returns:
            Array[Name]:
        """
        ...
    def get_selection_set(self) -> TypedElementSelectionSet:
        r"""
        x.get_selection_set() -> TypedElementSelectionSet
        Get the selection set for the current world, you can use this to track
        and create changes to the level editor's selection
        
        Returns:
            TypedElementSelectionSet:
        """
        ...
    def get_pilot_level_actor(self, viewport_config_key: Name = "None") -> Actor:
        r"""
        x.get_pilot_level_actor(viewport_config_key="None") -> Actor
        Get Pilot Level Actor
        
        Args:
            viewport_config_key (Name): 
        
        Returns:
            Actor:
        """
        ...
    def get_current_level(self) -> Level:
        r"""
        x.get_current_level() -> Level
        Get the current level used by the world editor.
        
        Returns:
            Level: The current level
        """
        ...
    def get_allows_cinematic_control(self, viewport_config_key: Name = "None") -> bool:
        r"""
        x.get_allows_cinematic_control(viewport_config_key="None") -> bool
        Get Allows Cinematic Control
        
        Args:
            viewport_config_key (Name): 
        
        Returns:
            bool:
        """
        ...
    def get_active_viewport_config_key(self) -> Name:
        r"""
        x.get_active_viewport_config_key() -> Name
        Get Active Viewport Config Key
        
        Returns:
            Name:
        """
        ...
    def eject_pilot_level_actor(self, viewport_config_key: Name = "None") -> None:
        r"""
        x.eject_pilot_level_actor(viewport_config_key="None") -> None
        Eject Pilot Level Actor
        
        Args:
            viewport_config_key (Name):
        """
        ...
    def editor_set_game_view(self, game_view: bool, viewport_config_key: Name = "None") -> None:
        r"""
        x.editor_set_game_view(game_view, viewport_config_key="None") -> None
        Editor Set Game View
        
        Args:
            game_view (bool): 
            viewport_config_key (Name):
        """
        ...
    def editor_request_end_play(self) -> None:
        r"""
        x.editor_request_end_play() -> None
        Editor Request End Play
        """
        ...
    def editor_play_simulate(self) -> None:
        r"""
        x.editor_play_simulate() -> None
        Editor Play Simulate
        """
        ...
    def editor_invalidate_viewports(self) -> None:
        r"""
        x.editor_invalidate_viewports() -> None
        Editor Invalidate Viewports
        """
        ...
    def editor_get_game_view(self, viewport_config_key: Name = "None") -> bool:
        r"""
        x.editor_get_game_view(viewport_config_key="None") -> bool
        Editor Get Game View
        
        Args:
            viewport_config_key (Name): 
        
        Returns:
            bool:
        """
        ...
    def build_light_maps(self, quality: LightingBuildQuality = LightingBuildQuality.QUALITY_PRODUCTION, with_reflection_captures: bool = False) -> bool:
        r"""
        x.build_light_maps(quality=LightingBuildQuality.QUALITY_PRODUCTION, with_reflection_captures=False) -> bool
        Build Light Maps and optionally the reflection captures.
        
        Args:
            quality (LightingBuildQuality): One of the enum LightingBuildQuality value. Default is Quality_Production.
            with_reflection_captures (bool): Build the related reflection captures after building the light maps.
        
        Returns:
            bool: True if build was successful.
        """
        ...

class Manipulator(Actor):
    r"""
    Manipulator
    
    **C++ Source:**
    
    - **Module**: ComponentVisualizers
    - **File**: Manipulator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class GameplayTask(Object):
    r"""
    Gameplay Task
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTask.h
    
    """
    def end_task(self) -> None:
        r"""
        x.end_task() -> None
        Called explicitly to end the task (usually by the task itself). Calls OnDestroy.
        NOTE:: you need to call EndTask before sending out any "on completed" delegates. If you don't the task will still be in an "active" state while the event receivers may assume it's already "finished"
        """
        ...

class GameplayTaskResource(Object):
    r"""
    Gameplay Task Resource
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTaskResource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``manual_resource_id`` (int32):  [Read-Write] Overrides AutoResourceID. -1 means auto ID will be applied
    - ``manually_set_id`` (bool):  [Read-Write]
    """
    @property
    def manual_resource_id(self) -> int:
        r"""
        (int32):  [Read-Only] Overrides AutoResourceID. -1 means auto ID will be applied
        """
        ...

class GameplayTasksComponent(ActorComponent):
    r"""
    The core ActorComponent for interfacing with the GameplayAbilities System
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTasksComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_claimed_resources_change`` (OnClaimedResourcesChangeSignature):  [Read-Write]
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def on_claimed_resources_change(self) -> OnClaimedResourcesChangeSignature:
        r"""
        (OnClaimedResourcesChangeSignature):  [Read-Write]
        """
        ...
    @on_claimed_resources_change.setter
    def on_claimed_resources_change(self, value: OnClaimedResourcesChangeSignature) -> None:
        ...
    @classmethod
    def run_gameplay_task(cls, task_owner: GameplayTaskOwnerInterface, task: GameplayTask, priority: int, additional_required_resources: Array[Class], additional_claimed_resources: Array[Class]) -> GameplayTaskRunResult:
        r"""
        X.run_gameplay_task(task_owner, task, priority, additional_required_resources, additional_claimed_resources) -> GameplayTaskRunResult
        K2 Run Gameplay Task
        
        Args:
            task_owner (GameplayTaskOwnerInterface): 
            task (GameplayTask): 
            priority (uint8): 
            additional_required_resources (Array[type(Class)]): 
            additional_claimed_resources (Array[type(Class)]): 
        
        Returns:
            GameplayTaskRunResult:
        """
        ...

class GameplayTask_ClaimResource(GameplayTask):
    r"""
    Gameplay Task Claim Resource
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTask_ClaimResource.h
    
    """
    @classmethod
    def claim_resources(cls, task_owner: GameplayTaskOwnerInterface, resource_classes: Array[Class], priority: int = 192, task_instance_name: Name = "None") -> GameplayTask_ClaimResource:
        r"""
        X.claim_resources(task_owner, resource_classes, priority=192, task_instance_name="None") -> GameplayTask_ClaimResource
        Claim Resources
        
        Args:
            task_owner (GameplayTaskOwnerInterface): 
            resource_classes (Array[type(Class)]): 
            priority (uint8): 
            task_instance_name (Name): 
        
        Returns:
            GameplayTask_ClaimResource:
        """
        ...
    @classmethod
    def claim_resource(cls, task_owner: GameplayTaskOwnerInterface, resource_class: Class, priority: int = 192, task_instance_name: Name = "None") -> GameplayTask_ClaimResource:
        r"""
        X.claim_resource(task_owner, resource_class, priority=192, task_instance_name="None") -> GameplayTask_ClaimResource
        Claim Resource
        
        Args:
            task_owner (GameplayTaskOwnerInterface): 
            resource_class (type(Class)): 
            priority (uint8): 
            task_instance_name (Name): 
        
        Returns:
            GameplayTask_ClaimResource:
        """
        ...

class GameplayTask_SpawnActor(GameplayTask):
    r"""
    Convenience task for spawning actors (optionally limiting the spawning to the network authority). If not the net authority, we will not spawn
    and Success will not be called. The nice thing this adds is the ability to modify expose on spawn properties while also implicitly checking
    network role before spawning.
    
    Though this task doesn't do much - games can implement similar tasks that carry out game specific rules. For example a 'SpawnProjectile'
    task that limits the available classes to the games projectile class, and that does game specific stuff on spawn (for example, determining
    firing position from a weapon attachment).
    
    Long term we can also use this task as a sync point. If the executing client could wait execution until the server creates and replicates the
    actor down to it. We could potentially also use this to do predictive actor spawning / reconciliation.
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTask_SpawnActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``did_not_spawn`` (GameplayTaskSpawnActorDelegate):  [Read-Write] Called when we can't spawn: on clients or potentially on server if they fail to spawn (rare)
    - ``success`` (GameplayTaskSpawnActorDelegate):  [Read-Write]
    """
    @property
    def success(self) -> GameplayTaskSpawnActorDelegate:
        r"""
        (GameplayTaskSpawnActorDelegate):  [Read-Write]
        """
        ...
    @success.setter
    def success(self, value: GameplayTaskSpawnActorDelegate) -> None:
        ...
    @property
    def did_not_spawn(self) -> GameplayTaskSpawnActorDelegate:
        r"""
        (GameplayTaskSpawnActorDelegate):  [Read-Write] Called when we can't spawn: on clients or potentially on server if they fail to spawn (rare)
        """
        ...
    @did_not_spawn.setter
    def did_not_spawn(self, value: GameplayTaskSpawnActorDelegate) -> None:
        ...

class GameplayTask_TimeLimitedExecution(GameplayTask):
    r"""
    Adds time limit for running a child task
    - child task needs to be created with UGameplayTask_TimeLimitedExecution passed as TaskOwner
    - activations are tied together and when either UGameplayTask_TimeLimitedExecution or child task is activated, other one starts as well
    - OnFinished and OnTimeExpired are mutually exclusive
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTask_TimeLimitedExecution.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_finished`` (TaskFinishDelegate):  [Read-Write] called when child task finishes execution before time runs out
    - ``on_time_expired`` (TaskFinishDelegate):  [Read-Write] called when time runs out
    """
    @property
    def on_finished(self) -> TaskFinishDelegate:
        r"""
        (TaskFinishDelegate):  [Read-Write] called when child task finishes execution before time runs out
        """
        ...
    @on_finished.setter
    def on_finished(self, value: TaskFinishDelegate) -> None:
        ...
    @property
    def on_time_expired(self) -> TaskFinishDelegate:
        r"""
        (TaskFinishDelegate):  [Read-Write] called when time runs out
        """
        ...
    @on_time_expired.setter
    def on_time_expired(self, value: TaskFinishDelegate) -> None:
        ...

class GameplayTask_WaitDelay(GameplayTask):
    r"""
    Gameplay Task Wait Delay
    
    **C++ Source:**
    
    - **Module**: GameplayTasks
    - **File**: GameplayTask_WaitDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_finish`` (TaskDelayDelegate):  [Read-Write]
    """
    @property
    def on_finish(self) -> TaskDelayDelegate:
        r"""
        (TaskDelayDelegate):  [Read-Write]
        """
        ...
    @on_finish.setter
    def on_finish(self, value: TaskDelayDelegate) -> None:
        ...

class GameplayTagLibrary(BlueprintFunctionLibrary):
    r"""
    Blueprint Gameplay Tag Library
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: BlueprintGameplayTagLibrary.h
    
    """
    @classmethod
    def remove_gameplay_tag(cls, tag_container: GameplayTagContainer, tag: GameplayTag) -> Optional[GameplayTagContainer]:
        r"""
        X.remove_gameplay_tag(tag_container, tag) -> GameplayTagContainer or None
        Remove a single tag from the passed in tag container, returns true if found
        
        Args:
            tag_container (GameplayTagContainer): 
            tag (GameplayTag): The tag to add to the container
        
        Returns:
            GameplayTagContainer or None: 
        
            tag_container (GameplayTagContainer):
        """
        ...
    @classmethod
    def not_equal_gameplay_tag_container(cls, a: GameplayTagContainer, b: GameplayTagContainer) -> bool:
        r"""
        X.not_equal_gameplay_tag_container(a, b) -> bool
        Returns true if the values are not equal (A != B)
        
        Args:
            a (GameplayTagContainer): 
            b (GameplayTagContainer): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_gameplay_tag(cls, a: GameplayTag, b: GameplayTag) -> bool:
        r"""
        X.not_equal_gameplay_tag(a, b) -> bool
        Returns true if the values are not equal (A != B)
        
        Args:
            a (GameplayTag): 
            b (GameplayTag): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def matches_tag(cls, tag_one: GameplayTag, tag_two: GameplayTag, exact_match: bool) -> bool:
        r"""
        X.matches_tag(tag_one, tag_two, exact_match) -> bool
        Determine if TagOne matches against TagTwo
        
        Args:
            tag_one (GameplayTag): Tag to check for match
            tag_two (GameplayTag): Tag to check match against
            exact_match (bool): If true, the tag has to be exactly present, if false then TagOne will include it's parent tags while matching
        
        Returns:
            bool: True if TagOne matches TagTwo
        """
        ...
    @classmethod
    def do_gameplay_tags_match(cls, tag_one: GameplayTag, tag_two: GameplayTag, exact_match: bool) -> bool:
        r"""
        deprecated: 'do_gameplay_tags_match' was renamed to 'matches_tag'.
        """
        ...
    @classmethod
    def matches_any_tags(cls, tag_one: GameplayTag, other_container: GameplayTagContainer, exact_match: bool) -> bool:
        r"""
        X.matches_any_tags(tag_one, other_container, exact_match) -> bool
        Determine if TagOne matches against any tag in OtherContainer
        
        Args:
            tag_one (GameplayTag): Tag to check for match
            other_container (GameplayTagContainer): Container to check against.
            exact_match (bool): If true, the tag has to be exactly present, if false then TagOne will include it's parent tags while matching
        
        Returns:
            bool: True if TagOne matches any tags explicitly present in OtherContainer
        """
        ...
    @classmethod
    def make_literal_gameplay_tag_container(cls, value: GameplayTagContainer) -> GameplayTagContainer:
        r"""
        X.make_literal_gameplay_tag_container(value) -> GameplayTagContainer
        Creates a literal FGameplayTagContainer
        
        Args:
            value (GameplayTagContainer): 
        
        Returns:
            GameplayTagContainer:
        """
        ...
    @classmethod
    def make_literal_gameplay_tag(cls, value: GameplayTag) -> GameplayTag:
        r"""
        X.make_literal_gameplay_tag(value) -> GameplayTag
        Creates a literal FGameplayTag
        
        Args:
            value (GameplayTag): 
        
        Returns:
            GameplayTag:
        """
        ...
    @classmethod
    def make_gameplay_tag_query_match_no_tags(cls, tags: GameplayTagContainer) -> GameplayTagQuery:
        r"""
        X.make_gameplay_tag_query_match_no_tags(tags) -> GameplayTagQuery
        Creates a literal FGameplayTagQuery with a prepopulated NoTagsMatch expression
        
        Args:
            tags (GameplayTagContainer): value to set the FGameplayTagQuery expression
        
        Returns:
            GameplayTagQuery: The literal FGameplayTagQuery
        """
        ...
    @classmethod
    def make_gameplay_tag_query_match_any_tags(cls, tags: GameplayTagContainer) -> GameplayTagQuery:
        r"""
        X.make_gameplay_tag_query_match_any_tags(tags) -> GameplayTagQuery
        Creates a literal FGameplayTagQuery with a prepopulated AnyTagsMatch expression
        
        Args:
            tags (GameplayTagContainer): value to set the FGameplayTagQuery expression
        
        Returns:
            GameplayTagQuery: The literal FGameplayTagQuery
        """
        ...
    @classmethod
    def make_gameplay_tag_query_match_all_tags(cls, tags: GameplayTagContainer) -> GameplayTagQuery:
        r"""
        X.make_gameplay_tag_query_match_all_tags(tags) -> GameplayTagQuery
        Creates a literal FGameplayTagQuery with a prepopulated AllTagsMatch expression
        
        Args:
            tags (GameplayTagContainer): value to set the FGameplayTagQuery expression
        
        Returns:
            GameplayTagQuery: The literal FGameplayTagQuery
        """
        ...
    @classmethod
    def make_gameplay_tag_query(cls, tag_query: GameplayTagQuery) -> GameplayTagQuery:
        r"""
        X.make_gameplay_tag_query(tag_query) -> GameplayTagQuery
        Creates a literal FGameplayTagQuery
        
        Args:
            tag_query (GameplayTagQuery): value to set the FGameplayTagQuery to
        
        Returns:
            GameplayTagQuery: The literal FGameplayTagQuery
        """
        ...
    @classmethod
    def make_gameplay_tag_container_from_tag(cls, single_tag: GameplayTag) -> GameplayTagContainer:
        r"""
        X.make_gameplay_tag_container_from_tag(single_tag) -> GameplayTagContainer
        Creates a FGameplayTagContainer containing a single tag
        
        Args:
            single_tag (GameplayTag): 
        
        Returns:
            GameplayTagContainer:
        """
        ...
    @classmethod
    def make_gameplay_tag_container_from_array(cls, gameplay_tags: Array[GameplayTag]) -> GameplayTagContainer:
        r"""
        X.make_gameplay_tag_container_from_array(gameplay_tags) -> GameplayTagContainer
        Creates a FGameplayTagContainer from the array of passed in tags
        
        Args:
            gameplay_tags (Array[GameplayTag]): 
        
        Returns:
            GameplayTagContainer:
        """
        ...
    @classmethod
    def is_tag_query_empty(cls, tag_query: GameplayTagQuery) -> bool:
        r"""
        X.is_tag_query_empty(tag_query) -> bool
        Check if the specified tag query is empty
        
        Args:
            tag_query (GameplayTagQuery): Query to check
        
        Returns:
            bool: True if the query is empty, false otherwise.
        """
        ...
    @classmethod
    def is_gameplay_tag_valid(cls, gameplay_tag: GameplayTag) -> bool:
        r"""
        X.is_gameplay_tag_valid(gameplay_tag) -> bool
        Returns true if the passed in gameplay tag is non-null
        
        Args:
            gameplay_tag (GameplayTag): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def has_tag(cls, tag_container: GameplayTagContainer, tag: GameplayTag, exact_match: bool) -> bool:
        r"""
        X.has_tag(tag_container, tag, exact_match) -> bool
        Check if the tag container has the specified tag
        
        Args:
            tag_container (GameplayTagContainer): Container to check for the tag
            tag (GameplayTag): Tag to check for in the container
            exact_match (bool): If true, the tag has to be exactly present, if false then TagContainer will include it's parent tags while matching
        
        Returns:
            bool: True if the container has the specified tag, false if it does not
        """
        ...
    @classmethod
    def does_container_have_tag(cls, tag_container: GameplayTagContainer, tag: GameplayTag, exact_match: bool) -> bool:
        r"""
        deprecated: 'does_container_have_tag' was renamed to 'has_tag'.
        """
        ...
    @classmethod
    def has_any_tags(cls, tag_container: GameplayTagContainer, other_container: GameplayTagContainer, exact_match: bool) -> bool:
        r"""
        X.has_any_tags(tag_container, other_container, exact_match) -> bool
        Check if the specified tag container has ANY of the tags in the other container
        
        Args:
            tag_container (GameplayTagContainer): Container to check if it matches any of the tags in the other container
            other_container (GameplayTagContainer): Container to check against.
            exact_match (bool): If true, the tag has to be exactly present, if false then TagContainer will include it's parent tags while matching
        
        Returns:
            bool: True if the container has ANY of the tags in the other container
        """
        ...
    @classmethod
    def does_container_match_any_tags_in_container(cls, tag_container: GameplayTagContainer, other_container: GameplayTagContainer, exact_match: bool) -> bool:
        r"""
        deprecated: 'does_container_match_any_tags_in_container' was renamed to 'has_any_tags'.
        """
        ...
    @classmethod
    def has_all_tags(cls, tag_container: GameplayTagContainer, other_container: GameplayTagContainer, exact_match: bool) -> bool:
        r"""
        X.has_all_tags(tag_container, other_container, exact_match) -> bool
        Check if the specified tag container has ALL of the tags in the other container
        
        Args:
            tag_container (GameplayTagContainer): Container to check if it matches all of the tags in the other container
            other_container (GameplayTagContainer): Container to check against. If this is empty, the check will succeed
            exact_match (bool): If true, the tag has to be exactly present, if false then TagContainer will include it's parent tags while matching
        
        Returns:
            bool: True if the container has ALL of the tags in the other container
        """
        ...
    @classmethod
    def does_container_match_all_tags_in_container(cls, tag_container: GameplayTagContainer, other_container: GameplayTagContainer, exact_match: bool) -> bool:
        r"""
        deprecated: 'does_container_match_all_tags_in_container' was renamed to 'has_all_tags'.
        """
        ...
    @classmethod
    def get_tag_name(cls, gameplay_tag: GameplayTag) -> Name:
        r"""
        X.get_tag_name(gameplay_tag) -> Name
        Returns FName of this tag
        
        Args:
            gameplay_tag (GameplayTag): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def get_num_gameplay_tags_in_container(cls, tag_container: GameplayTagContainer) -> int:
        r"""
        X.get_num_gameplay_tags_in_container(tag_container) -> int32
        Get the number of gameplay tags in the specified container
        
        Args:
            tag_container (GameplayTagContainer): Tag container to get the number of tags from
        
        Returns:
            int32: The number of tags in the specified container
        """
        ...
    @classmethod
    def get_debug_string_from_gameplay_tag_container(cls, tag_container: GameplayTagContainer) -> str:
        r"""
        X.get_debug_string_from_gameplay_tag_container(tag_container) -> str
        Returns an FString listing all of the gameplay tags in the tag container for debugging purposes.
        
        Args:
            tag_container (GameplayTagContainer): The tag container to get the debug string from.
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_debug_string_from_gameplay_tag(cls, gameplay_tag: GameplayTag) -> str:
        r"""
        X.get_debug_string_from_gameplay_tag(gameplay_tag) -> str
        Returns an FString representation of a gameplay tag for debugging purposes.
        
        Args:
            gameplay_tag (GameplayTag): The tag to get the debug string from.
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_all_actors_of_class_matching_tag_query(cls, world_context_object: Object, actor_class: Class, gameplay_tag_query: GameplayTagQuery) -> Array[Actor]:
        r"""
        X.get_all_actors_of_class_matching_tag_query(world_context_object, actor_class, gameplay_tag_query) -> Array[Actor]
        Get an array of all actors of a specific class (or subclass of that class) which match the specified gameplay tag query.
        
        Args:
            world_context_object (Object): 
            actor_class (type(Class)): Class of actors to fetch
            gameplay_tag_query (GameplayTagQuery): Query to match against
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]):
        """
        ...
    @classmethod
    def equal_equal_gameplay_tag_container(cls, a: GameplayTagContainer, b: GameplayTagContainer) -> bool:
        r"""
        X.equal_equal_gameplay_tag_container(a, b) -> bool
        Returns true if the values are equal (A == B)
        
        Args:
            a (GameplayTagContainer): 
            b (GameplayTagContainer): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_gameplay_tag(cls, a: GameplayTag, b: GameplayTag) -> bool:
        r"""
        X.equal_equal_gameplay_tag(a, b) -> bool
        Returns true if the values are equal (A == B)
        
        Args:
            a (GameplayTag): 
            b (GameplayTag): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def does_container_match_tag_query(cls, tag_container: GameplayTagContainer, tag_query: GameplayTagQuery) -> bool:
        r"""
        X.does_container_match_tag_query(tag_container, tag_query) -> bool
        Check if the specified tag container matches the given Tag Query
        
        Args:
            tag_container (GameplayTagContainer): Container to check if it matches all of the tags in the other container
            tag_query (GameplayTagQuery): Query to match against
        
        Returns:
            bool: True if the container matches the query, false otherwise.
        """
        ...
    @classmethod
    def break_gameplay_tag_container(cls, gameplay_tag_container: GameplayTagContainer) -> Array[GameplayTag]:
        r"""
        X.break_gameplay_tag_container(gameplay_tag_container) -> Array[GameplayTag]
        Breaks tag container into explicit array of tags
        
        Args:
            gameplay_tag_container (GameplayTagContainer): 
        
        Returns:
            Array[GameplayTag]: 
        
            gameplay_tags (Array[GameplayTag]):
        """
        ...
    @classmethod
    def append_gameplay_tag_containers(cls, out_tag_container: GameplayTagContainer, tag_container: GameplayTagContainer) -> GameplayTagContainer:
        r"""
        X.append_gameplay_tag_containers(out_tag_container, tag_container) -> GameplayTagContainer
        Appends all tags in the InTagContainer to InOutTagContainer
        
        Args:
            out_tag_container (GameplayTagContainer): The container that will be appended too.
            tag_container (GameplayTagContainer): The container to append.
        
        Returns:
            GameplayTagContainer: 
        
            out_tag_container (GameplayTagContainer): The container that will be appended too.
        """
        ...
    @classmethod
    def add_gameplay_tag(cls, tag_container: GameplayTagContainer, tag: GameplayTag) -> GameplayTagContainer:
        r"""
        X.add_gameplay_tag(tag_container, tag) -> GameplayTagContainer
        Adds a single tag to the passed in tag container
        
        Args:
            tag_container (GameplayTagContainer): 
            tag (GameplayTag): The tag to add to the container
        
        Returns:
            GameplayTagContainer: 
        
            tag_container (GameplayTagContainer):
        """
        ...
    @classmethod
    def add_gameplay_tag_to_container(cls, tag_container: GameplayTagContainer, tag: GameplayTag) -> GameplayTagContainer:
        r"""
        deprecated: 'add_gameplay_tag_to_container' was renamed to 'add_gameplay_tag'.
        """
        ...

class GameplayTagAssetInterface(Interface):
    r"""
    Gameplay Tag Asset Interface
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagAssetInterface.h
    
    """
    def has_matching_gameplay_tag(self, tag_to_check: GameplayTag) -> bool:
        r"""
        x.has_matching_gameplay_tag(tag_to_check) -> bool
        Check if the asset has a gameplay tag that matches against the specified tag (expands to include parents of asset tags)
        
        Args:
            tag_to_check (GameplayTag): Tag to check for a match
        
        Returns:
            bool: True if the asset has a gameplay tag that matches, false if not
        """
        ...
    def has_any_matching_gameplay_tags(self, tag_container: GameplayTagContainer) -> bool:
        r"""
        x.has_any_matching_gameplay_tags(tag_container) -> bool
        Check if the asset has gameplay tags that matches against any of the specified tags (expands to include parents of asset tags)
        
        Args:
            tag_container (GameplayTagContainer): Tag container to check for a match
        
        Returns:
            bool: True if the asset has matches any of the gameplay tags, will be false if container is empty
        """
        ...
    def has_all_matching_gameplay_tags(self, tag_container: GameplayTagContainer) -> bool:
        r"""
        x.has_all_matching_gameplay_tags(tag_container) -> bool
        Check if the asset has gameplay tags that matches against all of the specified tags (expands to include parents of asset tags)
        
        Args:
            tag_container (GameplayTagContainer): Tag container to check for a match
        
        Returns:
            bool: True if the asset has matches all of the gameplay tags, will be true if container is empty
        """
        ...
    def get_owned_gameplay_tags(self) -> GameplayTagContainer:
        r"""
        x.get_owned_gameplay_tags() -> GameplayTagContainer
        Get any owned gameplay tags on the asset
        
        Returns:
            GameplayTagContainer: 
        
            tag_container (GameplayTagContainer):
        """
        ...

class EditableGameplayTagQueryExpression(Object):
    r"""
    Editable Gameplay Tag Query Expression
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagContainer.h
    
    """
    ...

class EditableGameplayTagQueryExpression_AnyTagsMatch(EditableGameplayTagQueryExpression):
    r"""
    Editable Gameplay Tag Query Expression Any Tags Match
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``tags`` (GameplayTagContainer):  [Read-Write]
    """
    ...

class EditableGameplayTagQueryExpression_AllTagsMatch(EditableGameplayTagQueryExpression):
    r"""
    Editable Gameplay Tag Query Expression All Tags Match
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``tags`` (GameplayTagContainer):  [Read-Write]
    """
    ...

class EditableGameplayTagQueryExpression_NoTagsMatch(EditableGameplayTagQueryExpression):
    r"""
    Editable Gameplay Tag Query Expression No Tags Match
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``tags`` (GameplayTagContainer):  [Read-Write]
    """
    ...

class EditableGameplayTagQueryExpression_AnyExprMatch(EditableGameplayTagQueryExpression):
    r"""
    Editable Gameplay Tag Query Expression Any Expr Match
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``expressions`` (Array[EditableGameplayTagQueryExpression]):  [Read-Write]
    """
    ...

class EditableGameplayTagQueryExpression_AllExprMatch(EditableGameplayTagQueryExpression):
    r"""
    Editable Gameplay Tag Query Expression All Expr Match
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``expressions`` (Array[EditableGameplayTagQueryExpression]):  [Read-Write]
    """
    ...

class EditableGameplayTagQueryExpression_NoExprMatch(EditableGameplayTagQueryExpression):
    r"""
    Editable Gameplay Tag Query Expression No Expr Match
    
    **C++ Source:**
    
    - **Module**: GameplayTags
    - **File**: GameplayTagContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``expressions`` (Array[EditableGameplayTagQueryExpression]):  [Read-Write]
    """
    ...

class GameplayDebuggerCategoryReplicator(Actor):
    r"""
    Gameplay Debugger Category Replicator
    
    **C++ Source:**
    
    - **Module**: GameplayDebugger
    - **File**: GameplayDebuggerCategoryReplicator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class GameplayDebuggerPlayerManager(Actor):
    r"""
    Gameplay Debugger Player Manager
    
    **C++ Source:**
    
    - **Module**: GameplayDebugger
    - **File**: GameplayDebuggerPlayerManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class DebugDrawComponent(PrimitiveComponent):
    r"""
    Helper class to derive from to use debug draw delegate functionalities (i.e. DrawDebugLabels)
    The class will take care of registering a delegate to the UDebugDrawService and draw all FText3d provided by the scene proxy.
    This functionality only requires the derived classes to override `CreateDebugSceneProxy`.
    
    It is also possible to add text from other sources of data from the scene proxy but that requires a few extra steps:
     + create a class that inherits from `FDebugDrawDelegateHelper`
                - override `DrawDebugLabels`
                - add a method to be able to populate the source data from the scene proxy
    
                ex: class FMyDelegateHelper : public FDebugDrawDelegateHelper
                        {
                                public:
                                        void SetupFromProxy(const FMySceneProxy* InSceneProxy) { <collect data> };
                                protected:
                                        virtual void DrawDebugLabels(UCanvas* Canvas, APlayerController*) override { <draw data> };
                                private:
                                        TArray<FVector> SomeData;
                        };
    
     + Within the component inheriting from `UDebugDrawComponent`
                - add a property of that new helper type in the component inheriting from `UDebugDrawComponent`
                - override `GetDebugDrawDelegateHelper` to return that new member as the new delegate helper to use
                - and then use it in `CreateDebugSceneProxy` before returning the created proxy.
    
                ex: class MyDebugDrawComponent : public UDebugDrawComponent
                        {
                                protected:
                                        virtual FDebugRenderSceneProxy* CreateDebugSceneProxy() override
                                        {
                                                FMySceneProxy* Proxy = new FMySceneProxy(this);
                                                MyDelegateHelper.SetupFromProxy(Proxy);
                                                return Proxy;
                                        }
    
                                        virtual FDebugDrawDelegateHelper& GetDebugDrawDelegateHelper() override { return MyDelegateHelper; }
                                private:
                                        FMyDelegateHelper MyDelegateHelper;
                        }
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DebugDrawComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class GameplayDebuggerRenderingComponent(DebugDrawComponent):
    r"""
    Gameplay Debugger Rendering Component
    
    **C++ Source:**
    
    - **Module**: GameplayDebugger
    - **File**: GameplayDebuggerRenderingComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class AIAsyncTaskBlueprintProxy(Object):
    r"""
    AIAsync Task Blueprint Proxy
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIAsyncTaskBlueprintProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_fail`` (OAISimpleDelegate):  [Read-Write]
    - ``on_success`` (OAISimpleDelegate):  [Read-Write]
    """
    @property
    def on_success(self) -> OAISimpleDelegate:
        r"""
        (OAISimpleDelegate):  [Read-Write]
        """
        ...
    @on_success.setter
    def on_success(self, value: OAISimpleDelegate) -> None:
        ...
    @property
    def on_fail(self) -> OAISimpleDelegate:
        r"""
        (OAISimpleDelegate):  [Read-Write]
        """
        ...
    @on_fail.setter
    def on_fail(self, value: OAISimpleDelegate) -> None:
        ...

class KismetAIAsyncTaskProxy(AIAsyncTaskBlueprintProxy):
    r"""
    deprecated: 'KismetAIAsyncTaskProxy' was renamed to 'AIAsyncTaskBlueprintProxy'.
    """
    ...

class AISenseConfig(Object):
    r"""
    AISense Config
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISenseConfig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_color`` (Color):  [Read-Write]
    - ``max_age`` (float):  [Read-Write] specifies age limit after stimuli generated by this sense become forgotten. 0 means "never"
    - ``starts_enabled`` (bool):  [Read-Write] determines whether given sense starts in an enabled state
    """
    @property
    def debug_color(self) -> Color:
        r"""
        (Color):  [Read-Only]
        """
        ...
    @property
    def max_age(self) -> float:
        r"""
        (float):  [Read-Only] specifies age limit after stimuli generated by this sense become forgotten. 0 means "never"
        """
        ...
    @property
    def starts_enabled(self) -> bool:
        r"""
        (bool):  [Read-Only] determines whether given sense starts in an enabled state
        """
        ...

class AISenseConfig_Blueprint(AISenseConfig):
    r"""
    AISense Config Blueprint
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISenseConfig_Blueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_color`` (Color):  [Read-Write]
    - ``implementation`` (type(Class)):  [Read-Write]
    - ``max_age`` (float):  [Read-Write] specifies age limit after stimuli generated by this sense become forgotten. 0 means "never"
    - ``starts_enabled`` (bool):  [Read-Write] determines whether given sense starts in an enabled state
    """
    @property
    def implementation(self) -> Class:
        r"""
        (type(Class)):  [Read-Only]
        """
        ...

class AISenseConfig_Hearing(AISenseConfig):
    r"""
    AISense Config Hearing
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISenseConfig_Hearing.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_color`` (Color):  [Read-Write]
    - ``detection_by_affiliation`` (AISenseAffiliationFilter):  [Read-Write]
    - ``hearing_range`` (float):  [Read-Write]
    - ``implementation`` (type(Class)):  [Read-Write]
    - ``lo_s_hearing_range`` (float):  [Read-Write]
    - ``max_age`` (float):  [Read-Write] specifies age limit after stimuli generated by this sense become forgotten. 0 means "never"
    - ``starts_enabled`` (bool):  [Read-Write] determines whether given sense starts in an enabled state
    - ``use_lo_s_hearing`` (bool):  [Read-Write]
    """
    @property
    def implementation(self) -> Class:
        r"""
        (type(Class)):  [Read-Only]
        """
        ...
    @property
    def hearing_range(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def lo_s_hearing_range(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def detection_by_affiliation(self) -> AISenseAffiliationFilter:
        r"""
        (AISenseAffiliationFilter):  [Read-Only]
        """
        ...

class AISenseConfig_Prediction(AISenseConfig):
    r"""
    AISense Config Prediction
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISenseConfig_Prediction.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_color`` (Color):  [Read-Write]
    - ``max_age`` (float):  [Read-Write] specifies age limit after stimuli generated by this sense become forgotten. 0 means "never"
    - ``starts_enabled`` (bool):  [Read-Write] determines whether given sense starts in an enabled state
    """
    ...

class AISenseConfig_Sight(AISenseConfig):
    r"""
    AISense Config Sight
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISenseConfig_Sight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_success_range_from_last_seen_location`` (float):  [Read-Write] If not an InvalidRange (which is the default), we will always be able to see the target that has already been seen if they are within this range of their last seen location.
    - ``debug_color`` (Color):  [Read-Write]
    - ``detection_by_affiliation`` (AISenseAffiliationFilter):  [Read-Write]
    - ``implementation`` (type(Class)):  [Read-Write]
    - ``lose_sight_radius`` (float):  [Read-Write] Maximum sight distance to see target that has been already seen.
    - ``max_age`` (float):  [Read-Write] specifies age limit after stimuli generated by this sense become forgotten. 0 means "never"
    - ``near_clipping_radius`` (float):  [Read-Write] Near clipping distance, to be used with point of view backward offset. Will act as a close by awareness and peripheral vision
    - ``peripheral_vision_angle_degrees`` (float):  [Read-Write] How far to the side AI can see, in degrees. Use SetPeripheralVisionAngle to change the value at runtime.
          The value represents the angle measured in relation to the forward vector, not the whole range.
    - ``point_of_view_backward_offset`` (float):  [Read-Write] Point of view move back distance for cone calculation. In conjunction with near clipping distance, this will act as a close by awareness and peripheral vision.
    - ``sight_radius`` (float):  [Read-Write] Maximum sight distance to notice a target.
    - ``starts_enabled`` (bool):  [Read-Write] determines whether given sense starts in an enabled state
    """
    @property
    def implementation(self) -> Class:
        r"""
        (type(Class)):  [Read-Only]
        """
        ...
    @property
    def sight_radius(self) -> float:
        r"""
        (float):  [Read-Only] Maximum sight distance to notice a target.
        """
        ...
    @property
    def lose_sight_radius(self) -> float:
        r"""
        (float):  [Read-Only] Maximum sight distance to see target that has been already seen.
        """
        ...
    @property
    def peripheral_vision_angle_degrees(self) -> float:
        r"""
        (float):  [Read-Only] How far to the side AI can see, in degrees. Use SetPeripheralVisionAngle to change the value at runtime.
            The value represents the angle measured in relation to the forward vector, not the whole range.
        """
        ...
    @property
    def detection_by_affiliation(self) -> AISenseAffiliationFilter:
        r"""
        (AISenseAffiliationFilter):  [Read-Only]
        """
        ...
    @property
    def auto_success_range_from_last_seen_location(self) -> float:
        r"""
        (float):  [Read-Only] If not an InvalidRange (which is the default), we will always be able to see the target that has already been seen if they are within this range of their last seen location.
        """
        ...
    @property
    def point_of_view_backward_offset(self) -> float:
        r"""
        (float):  [Read-Only] Point of view move back distance for cone calculation. In conjunction with near clipping distance, this will act as a close by awareness and peripheral vision.
        """
        ...
    @property
    def near_clipping_radius(self) -> float:
        r"""
        (float):  [Read-Only] Near clipping distance, to be used with point of view backward offset. Will act as a close by awareness and peripheral vision
        """
        ...

class AISenseConfig_Team(AISenseConfig):
    r"""
    AISense Config Team
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISenseConfig_Team.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_color`` (Color):  [Read-Write]
    - ``max_age`` (float):  [Read-Write] specifies age limit after stimuli generated by this sense become forgotten. 0 means "never"
    - ``starts_enabled`` (bool):  [Read-Write] determines whether given sense starts in an enabled state
    """
    ...

class AISenseConfig_Touch(AISenseConfig):
    r"""
    AISense Config Touch
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISenseConfig_Touch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_color`` (Color):  [Read-Write]
    - ``detection_by_affiliation`` (AISenseAffiliationFilter):  [Read-Write]
    - ``max_age`` (float):  [Read-Write] specifies age limit after stimuli generated by this sense become forgotten. 0 means "never"
    - ``starts_enabled`` (bool):  [Read-Write] determines whether given sense starts in an enabled state
    """
    @property
    def detection_by_affiliation(self) -> AISenseAffiliationFilter:
        r"""
        (AISenseAffiliationFilter):  [Read-Only]
        """
        ...

class AISenseEvent(Object):
    r"""
    AISense Event
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISenseEvent.h
    
    """
    ...

class AISenseEvent_Damage(AISenseEvent):
    r"""
    AISense Event Damage
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISenseEvent_Damage.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``event`` (AIDamageEvent):  [Read-Write]
    """
    @property
    def event(self) -> AIDamageEvent:
        r"""
        (AIDamageEvent):  [Read-Write]
        """
        ...
    @event.setter
    def event(self, value: AIDamageEvent) -> None:
        ...

class AISenseEvent_Hearing(AISenseEvent):
    r"""
    AISense Event Hearing
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISenseEvent_Hearing.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``event`` (AINoiseEvent):  [Read-Write]
    """
    @property
    def event(self) -> AINoiseEvent:
        r"""
        (AINoiseEvent):  [Read-Write]
        """
        ...
    @event.setter
    def event(self, value: AINoiseEvent) -> None:
        ...

class PawnAction(Object):
    r"""
    Things to remember:
    * Actions are created paused
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PawnAction.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_new_same_class_instance`` (bool):  [Read-Write] if this is FALSE and we're trying to push a new instance of a given class,
          but the top of the stack is already an instance of that class ignore the attempted push
    - ``always_notify_on_finished`` (bool):  [Read-Write] if set, action will call OnFinished notify even when ending as FailedToStart
    - ``replace_active_same_class_instance`` (bool):  [Read-Write] if this is TRUE, when we try to push a new instance of an action who has the
          same class as the action on the top of the stack, pop the one on the stack, and push the new one
          NOTE: This trumps bAllowNewClassInstance (e.g. if this is true and bAllowNewClassInstance
          is false the active instance will still be replaced)
    - ``should_pause_movement`` (bool):  [Read-Write] this is a temporary solution to allow having movement action running in background while there's
          another action on top doing its thing
      note: should go away once AI resource locking comes on-line
    """
    @property
    def allow_new_same_class_instance(self) -> bool:
        r"""
        (bool):  [Read-Only] if this is FALSE and we're trying to push a new instance of a given class,
            but the top of the stack is already an instance of that class ignore the attempted push
        """
        ...
    @property
    def replace_active_same_class_instance(self) -> bool:
        r"""
        (bool):  [Read-Write] if this is TRUE, when we try to push a new instance of an action who has the
            same class as the action on the top of the stack, pop the one on the stack, and push the new one
            NOTE: This trumps bAllowNewClassInstance (e.g. if this is true and bAllowNewClassInstance
            is false the active instance will still be replaced)
        """
        ...
    @replace_active_same_class_instance.setter
    def replace_active_same_class_instance(self, value: bool) -> None:
        ...
    @property
    def should_pause_movement(self) -> bool:
        r"""
        (bool):  [Read-Write] this is a temporary solution to allow having movement action running in background while there's
            another action on top doing its thing
        note: should go away once AI resource locking comes on-line
        """
        ...
    @should_pause_movement.setter
    def should_pause_movement(self, value: bool) -> None:
        ...
    @property
    def always_notify_on_finished(self) -> bool:
        r"""
        (bool):  [Read-Write] if set, action will call OnFinished notify even when ending as FailedToStart
        """
        ...
    @always_notify_on_finished.setter
    def always_notify_on_finished(self, value: bool) -> None:
        ...
    def get_action_priority(self) -> AIRequestPriority:
        r"""
        x.get_action_priority() -> AIRequestPriority
        Blueprint interface
        
        Returns:
            AIRequestPriority:
        """
        ...
    def finish(self, with_result: PawnActionResult) -> None:
        r"""
        x.finish(with_result) -> None
        Finish
        
        Args:
            with_result (PawnActionResult):
        """
        ...
    @classmethod
    def create_action_instance(cls, world_context_object: Object, action_class: Class) -> PawnAction:
        r"""
        X.create_action_instance(world_context_object, action_class) -> PawnAction
        Create Action Instance
        deprecated: PawnActions have been deprecated and are no longer being supported. It will get removed in following UE5 releases. Use GameplayTasks or AITasks instead.
        
        Args:
            world_context_object (Object): 
            action_class (type(Class)): 
        
        Returns:
            PawnAction:
        """
        ...

class PawnActionsComponent(ActorComponent):
    r"""
    Pawn Actions Component
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PawnActionsComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``controlled_pawn`` (Pawn):  [Read-Write]
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def controlled_pawn(self) -> Pawn:
        r"""
        (Pawn):  [Read-Only]
        """
        ...
    def push_action(self, new_action: PawnAction, priority: AIRequestPriority, instigator: Object = None) -> bool:
        r"""
        x.push_action(new_action, priority, instigator=None) -> bool
        K2 Push Action
        deprecated: PawnActions have been deprecated and are no longer being supported. It will get removed in following UE5 releases. Use GameplayTasks or AITasks instead.
        
        Args:
            new_action (PawnAction): 
            priority (AIRequestPriority): 
            instigator (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def perform_action(cls, pawn: Pawn, action: PawnAction, priority: AIRequestPriority = AIRequestPriority.HARD_SCRIPT) -> bool:
        r"""
        X.perform_action(pawn, action, priority=AIRequestPriority.HARD_SCRIPT) -> bool
        blueprint interface
        deprecated: PawnActions have been deprecated and are no longer being supported. It will get removed in following UE5 releases. Use GameplayTasks or AITasks instead.
        
        Args:
            pawn (Pawn): 
            action (PawnAction): 
            priority (AIRequestPriority): 
        
        Returns:
            bool:
        """
        ...
    def force_abort_action(self, action_to_abort: PawnAction) -> PawnActionAbortState:
        r"""
        x.force_abort_action(action_to_abort) -> PawnActionAbortState
        Aborts given action instance
        deprecated: PawnActions have been deprecated and are no longer being supported. It will get removed in following UE5 releases. Use GameplayTasks or AITasks instead.
        
        Args:
            action_to_abort (PawnAction): 
        
        Returns:
            PawnActionAbortState:
        """
        ...
    def abort_action(self, action_to_abort: PawnAction) -> PawnActionAbortState:
        r"""
        x.abort_action(action_to_abort) -> PawnActionAbortState
        Aborts given action instance
        deprecated: PawnActions have been deprecated and are no longer being supported. It will get removed in following UE5 releases. Use GameplayTasks or AITasks instead.
        
        Args:
            action_to_abort (PawnAction): 
        
        Returns:
            PawnActionAbortState:
        """
        ...

class PawnAction_BlueprintBase(PawnAction):
    r"""
    Pawn Action Blueprint Base
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PawnAction_BlueprintBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_new_same_class_instance`` (bool):  [Read-Write] if this is FALSE and we're trying to push a new instance of a given class,
          but the top of the stack is already an instance of that class ignore the attempted push
    - ``always_notify_on_finished`` (bool):  [Read-Write] if set, action will call OnFinished notify even when ending as FailedToStart
    - ``replace_active_same_class_instance`` (bool):  [Read-Write] if this is TRUE, when we try to push a new instance of an action who has the
          same class as the action on the top of the stack, pop the one on the stack, and push the new one
          NOTE: This trumps bAllowNewClassInstance (e.g. if this is true and bAllowNewClassInstance
          is false the active instance will still be replaced)
    - ``should_pause_movement`` (bool):  [Read-Write] this is a temporary solution to allow having movement action running in background while there's
          another action on top doing its thing
      note: should go away once AI resource locking comes on-line
    """
    def action_tick(self, controlled_pawn: Pawn, delta_seconds: float) -> None:
        r"""
        x.action_tick(controlled_pawn, delta_seconds) -> None
        Action Tick
        
        Args:
            controlled_pawn (Pawn): 
            delta_seconds (float):
        """
        ...
    def action_start(self, controlled_pawn: Pawn) -> None:
        r"""
        x.action_start(controlled_pawn) -> None
        Blueprint interface
        
        Args:
            controlled_pawn (Pawn):
        """
        ...
    def action_resume(self, controlled_pawn: Pawn) -> None:
        r"""
        x.action_resume(controlled_pawn) -> None
        Action Resume
        
        Args:
            controlled_pawn (Pawn):
        """
        ...
    def action_pause(self, controlled_pawn: Pawn) -> None:
        r"""
        x.action_pause(controlled_pawn) -> None
        Action Pause
        
        Args:
            controlled_pawn (Pawn):
        """
        ...
    def action_finished(self, controlled_pawn: Pawn, with_result: PawnActionResult) -> None:
        r"""
        x.action_finished(controlled_pawn, with_result) -> None
        Action Finished
        
        Args:
            controlled_pawn (Pawn): 
            with_result (PawnActionResult):
        """
        ...

class PawnAction_Move(PawnAction):
    r"""
    Pawn Action Move
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PawnAction_Move.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``acceptable_radius`` (float):  [Read-Write]
    - ``allow_new_same_class_instance`` (bool):  [Read-Write] if this is FALSE and we're trying to push a new instance of a given class,
          but the top of the stack is already an instance of that class ignore the attempted push
    - ``allow_strafe`` (bool):  [Read-Write]
    - ``always_notify_on_finished`` (bool):  [Read-Write] if set, action will call OnFinished notify even when ending as FailedToStart
    - ``filter_class`` (type(Class)):  [Read-Write] "None" will result in default filter being used
    - ``goal_actor`` (Actor):  [Read-Write]
    - ``goal_location`` (Vector):  [Read-Write]
    - ``replace_active_same_class_instance`` (bool):  [Read-Write] if this is TRUE, when we try to push a new instance of an action who has the
          same class as the action on the top of the stack, pop the one on the stack, and push the new one
          NOTE: This trumps bAllowNewClassInstance (e.g. if this is true and bAllowNewClassInstance
          is false the active instance will still be replaced)
    - ``should_pause_movement`` (bool):  [Read-Write] this is a temporary solution to allow having movement action running in background while there's
          another action on top doing its thing
      note: should go away once AI resource locking comes on-line
    """
    @property
    def goal_actor(self) -> Actor:
        r"""
        (Actor):  [Read-Write]
        """
        ...
    @goal_actor.setter
    def goal_actor(self, value: Actor) -> None:
        ...
    @property
    def goal_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @goal_location.setter
    def goal_location(self, value: Vector) -> None:
        ...
    @property
    def acceptable_radius(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @acceptable_radius.setter
    def acceptable_radius(self, value: float) -> None:
        ...
    @property
    def filter_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] "None" will result in default filter being used
        """
        ...
    @filter_class.setter
    def filter_class(self, value: Class) -> None:
        ...
    @property
    def allow_strafe(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_strafe.setter
    def allow_strafe(self, value: bool) -> None:
        ...

class PawnAction_Repeat(PawnAction):
    r"""
    Pawn Action Repeat
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PawnAction_Repeat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_new_same_class_instance`` (bool):  [Read-Write] if this is FALSE and we're trying to push a new instance of a given class,
          but the top of the stack is already an instance of that class ignore the attempted push
    - ``always_notify_on_finished`` (bool):  [Read-Write] if set, action will call OnFinished notify even when ending as FailedToStart
    - ``child_failure_handling_mode`` (PawnActionFailHandling):  [Read-Write]
    - ``replace_active_same_class_instance`` (bool):  [Read-Write] if this is TRUE, when we try to push a new instance of an action who has the
          same class as the action on the top of the stack, pop the one on the stack, and push the new one
          NOTE: This trumps bAllowNewClassInstance (e.g. if this is true and bAllowNewClassInstance
          is false the active instance will still be replaced)
    - ``should_pause_movement`` (bool):  [Read-Write] this is a temporary solution to allow having movement action running in background while there's
          another action on top doing its thing
      note: should go away once AI resource locking comes on-line
    """
    @property
    def child_failure_handling_mode(self) -> PawnActionFailHandling:
        r"""
        (PawnActionFailHandling):  [Read-Only]
        """
        ...

class PawnAction_Sequence(PawnAction):
    r"""
    Pawn Action Sequence
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PawnAction_Sequence.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_new_same_class_instance`` (bool):  [Read-Write] if this is FALSE and we're trying to push a new instance of a given class,
          but the top of the stack is already an instance of that class ignore the attempted push
    - ``always_notify_on_finished`` (bool):  [Read-Write] if set, action will call OnFinished notify even when ending as FailedToStart
    - ``child_failure_handling_mode`` (PawnActionFailHandling):  [Read-Write]
    - ``replace_active_same_class_instance`` (bool):  [Read-Write] if this is TRUE, when we try to push a new instance of an action who has the
          same class as the action on the top of the stack, pop the one on the stack, and push the new one
          NOTE: This trumps bAllowNewClassInstance (e.g. if this is true and bAllowNewClassInstance
          is false the active instance will still be replaced)
    - ``should_pause_movement`` (bool):  [Read-Write] this is a temporary solution to allow having movement action running in background while there's
          another action on top doing its thing
      note: should go away once AI resource locking comes on-line
    """
    @property
    def child_failure_handling_mode(self) -> PawnActionFailHandling:
        r"""
        (PawnActionFailHandling):  [Read-Only]
        """
        ...

class PawnAction_Wait(PawnAction):
    r"""
    uses system timers rather then ticking
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PawnAction_Wait.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_new_same_class_instance`` (bool):  [Read-Write] if this is FALSE and we're trying to push a new instance of a given class,
          but the top of the stack is already an instance of that class ignore the attempted push
    - ``always_notify_on_finished`` (bool):  [Read-Write] if set, action will call OnFinished notify even when ending as FailedToStart
    - ``replace_active_same_class_instance`` (bool):  [Read-Write] if this is TRUE, when we try to push a new instance of an action who has the
          same class as the action on the top of the stack, pop the one on the stack, and push the new one
          NOTE: This trumps bAllowNewClassInstance (e.g. if this is true and bAllowNewClassInstance
          is false the active instance will still be replaced)
    - ``should_pause_movement`` (bool):  [Read-Write] this is a temporary solution to allow having movement action running in background while there's
          another action on top doing its thing
      note: should go away once AI resource locking comes on-line
    """
    ...

class Controller(Actor):
    r"""
    Controllers are non-physical actors that can possess a Pawn to control
    its actions.  PlayerControllers are used by human players to control pawns, while
    AIControllers implement the artificial intelligence for the pawns they control.
    Controllers take control of a pawn using their Possess() method, and relinquish
    control of the pawn by calling UnPossess().
    
    Controllers receive notifications for many of the events occurring for the Pawn they
    are controlling.  This gives the controller the opportunity to implement the behavior
    in response to this event, intercepting the event and superseding the Pawn's default
    behavior.
    
    ControlRotation (accessed via GetControlRotation()), determines the viewing/aiming
    direction of the controlled Pawn and is affected by input such as from a mouse or gamepad.
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Framework/Controller/
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Controller.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``attach_to_pawn`` (bool):  [Read-Write] If true, the controller location will match the possessed Pawn's location. If false, it will not be updated. Rotation will match ControlRotation in either case.
      Since a Controller's location is normally inaccessible, this is intended mainly for purposes of being able to attach
      an Actor that follows the possessed Pawn location, but that still has the full aim rotation (since a Pawn might
      update only some components of the rotation).
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_instigated_any_damage`` (InstigatedAnyDamageSignature):  [Read-Write] Called when the controller has instigated damage in any way
    - ``on_possessed_pawn_changed`` (OnPossessedPawnChanged):  [Read-Write] Called on both authorities and clients when the possessed pawn changes (either OldPawn or NewPawn might be nullptr)
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_state`` (PlayerState):  [Read-Write] PlayerState containing replicated information about the player using this controller (only exists for players, not NPCs).
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def player_state(self) -> PlayerState:
        r"""
        (PlayerState):  [Read-Only] PlayerState containing replicated information about the player using this controller (only exists for players, not NPCs).
        """
        ...
    @property
    def player_replication_info(self) -> PlayerState:
        r"""
        deprecated: 'player_replication_info' was renamed to 'player_state'.
        """
        ...
    @property
    def on_instigated_any_damage(self) -> InstigatedAnyDamageSignature:
        r"""
        (InstigatedAnyDamageSignature):  [Read-Write] Called when the controller has instigated damage in any way
        """
        ...
    @on_instigated_any_damage.setter
    def on_instigated_any_damage(self, value: InstigatedAnyDamageSignature) -> None:
        ...
    @property
    def on_possessed_pawn_changed(self) -> OnPossessedPawnChanged:
        r"""
        (OnPossessedPawnChanged):  [Read-Write] Called on both authorities and clients when the possessed pawn changes (either OldPawn or NewPawn might be nullptr)
        """
        ...
    @on_possessed_pawn_changed.setter
    def on_possessed_pawn_changed(self, value: OnPossessedPawnChanged) -> None:
        ...
    def un_possess(self) -> None:
        r"""
        x.un_possess() -> None
        Called to unpossess our pawn for any reason that is not the pawn being destroyed (destruction handled by PawnDestroyed()).
        """
        ...
    def stop_movement(self) -> None:
        r"""
        x.stop_movement() -> None
        Aborts the move the controller is currently performing
        """
        ...
    def set_initial_location_and_rotation(self, new_location: Vector, new_rotation: Rotator) -> None:
        r"""
        x.set_initial_location_and_rotation(new_location, new_rotation) -> None
        Set the initial location and rotation of the controller, as well as the control rotation. Typically used when the controller is first created.
        
        Args:
            new_location (Vector): 
            new_rotation (Rotator):
        """
        ...
    def set_ignore_move_input(self, new_move_input: bool) -> None:
        r"""
        x.set_ignore_move_input(new_move_input) -> None
        Locks or unlocks movement input, consecutive calls stack up and require the same amount of calls to undo, or can all be undone using ResetIgnoreMoveInput.
        
        Args:
            new_move_input (bool): If true, move input is ignored. If false, input is not ignored.
        """
        ...
    def set_ignore_look_input(self, new_look_input: bool) -> None:
        r"""
        x.set_ignore_look_input(new_look_input) -> None
        Locks or unlocks look input, consecutive calls stack up and require the same amount of calls to undo, or can all be undone using ResetIgnoreLookInput.
        
        Args:
            new_look_input (bool): If true, look input is ignored. If false, input is not ignored.
        """
        ...
    def set_control_rotation(self, new_rotation: Rotator) -> None:
        r"""
        x.set_control_rotation(new_rotation) -> None
        Set the control rotation.
        
        Args:
            new_rotation (Rotator):
        """
        ...
    def reset_ignore_move_input(self) -> None:
        r"""
        x.reset_ignore_move_input() -> None
        Stops ignoring move input by resetting the ignore move input state.
        """
        ...
    def reset_ignore_look_input(self) -> None:
        r"""
        x.reset_ignore_look_input() -> None
        Stops ignoring look input by resetting the ignore look input state.
        """
        ...
    def reset_ignore_input_flags(self) -> None:
        r"""
        x.reset_ignore_input_flags() -> None
        Reset move and look input ignore flags.
        """
        ...
    def receive_un_possess(self, unpossessed_pawn: Pawn) -> None:
        r"""
        x.receive_un_possess(unpossessed_pawn) -> None
        Blueprint implementable event to react to the controller unpossessing a pawn
        
        Args:
            unpossessed_pawn (Pawn):
        """
        ...
    def on_un_possess(self, unpossessed_pawn: Pawn) -> None:
        r"""
        deprecated: 'on_un_possess' was renamed to 'receive_un_possess'.
        """
        ...
    def receive_possess(self, possessed_pawn: Pawn) -> None:
        r"""
        x.receive_possess(possessed_pawn) -> None
        Blueprint implementable event to react to the controller possessing a pawn
        
        Args:
            possessed_pawn (Pawn):
        """
        ...
    def on_possess(self, possessed_pawn: Pawn) -> None:
        r"""
        deprecated: 'on_possess' was renamed to 'receive_possess'.
        """
        ...
    def receive_instigated_any_damage(self, damage: float, damage_type: DamageType, damaged_actor: Actor, damage_causer: Actor) -> None:
        r"""
        x.receive_instigated_any_damage(damage, damage_type, damaged_actor, damage_causer) -> None
        Event when this controller instigates ANY damage
        
        Args:
            damage (float): 
            damage_type (DamageType): 
            damaged_actor (Actor): 
            damage_causer (Actor):
        """
        ...
    def possess(self, pawn: Pawn) -> None:
        r"""
        x.possess(pawn) -> None
        Handles attaching this controller to the specified pawn.
        Only runs on the network authority (where HasAuthority() returns true).
        Derived native classes can override OnPossess to filter the specified pawn.
        When possessed pawn changed, blueprint class gets notified by ReceivePossess
        and OnNewPawn delegate is broadcasted.
        see: HasAuthority, OnPossess, ReceivePossess
        
        Args:
            pawn (Pawn): The Pawn to be possessed.
        """
        ...
    def line_of_sight_to(self, other: Actor, view_point: Vector = [0.000000, 0.000000, 0.000000], alternate_checks: bool = False) -> bool:
        r"""
        x.line_of_sight_to(other, view_point=[0.000000, 0.000000, 0.000000], alternate_checks=False) -> bool
        Checks line to center and top of other actor
        
        Args:
            other (Actor): is the actor whose visibility is being checked.
            view_point (Vector): is eye position visibility is being checked from.  If vect(0,0,0) passed in, uses current viewtarget's eye position.
            alternate_checks (bool): used only in AIController implementation
        
        Returns:
            bool: true if controller's pawn can see Other actor.
        """
        ...
    def get_controlled_pawn(self) -> Pawn:
        r"""
        x.get_controlled_pawn() -> Pawn
        Return the Pawn that is currently 'controlled' by this PlayerController
        
        Returns:
            Pawn:
        """
        ...
    def is_player_controller(self) -> bool:
        r"""
        x.is_player_controller() -> bool
        Returns whether this Controller is a PlayerController.
        
        Returns:
            bool:
        """
        ...
    def is_move_input_ignored(self) -> bool:
        r"""
        x.is_move_input_ignored() -> bool
        Returns true if movement input is ignored.
        
        Returns:
            bool:
        """
        ...
    def is_look_input_ignored(self) -> bool:
        r"""
        x.is_look_input_ignored() -> bool
        Returns true if look input is ignored.
        
        Returns:
            bool:
        """
        ...
    def is_local_player_controller(self) -> bool:
        r"""
        x.is_local_player_controller() -> bool
        Returns whether this Controller is a locally controlled PlayerController.
        
        Returns:
            bool:
        """
        ...
    def is_local_controller(self) -> bool:
        r"""
        x.is_local_controller() -> bool
        Returns whether this Controller is a local controller.
        
        Returns:
            bool:
        """
        ...
    def get_view_target(self) -> Actor:
        r"""
        x.get_view_target() -> Actor
        Get the actor the controller is looking at
        
        Returns:
            Actor:
        """
        ...
    def get_player_view_point(self) -> Tuple[Vector, Rotator]:
        r"""
        x.get_player_view_point() -> (location=Vector, rotation=Rotator)
        Returns Player's Point of View
        For the AI this means the Pawn's 'Eyes' ViewPoint
        For a Human player, this means the Camera's ViewPoint
        output: out_Location, view location of player
        output: out_rotation, view rotation of player
        
        Returns:
            tuple: 
        
            location (Vector): 
        
            rotation (Rotator):
        """
        ...
    def get_desired_rotation(self) -> Rotator:
        r"""
        x.get_desired_rotation() -> Rotator
        Get the desired pawn target rotation
        
        Returns:
            Rotator:
        """
        ...
    def get_control_rotation(self) -> Rotator:
        r"""
        x.get_control_rotation() -> Rotator
        Get the control rotation. This is the full aim rotation, which may be different than a camera orientation (for example in a third person view),
        and may differ from the rotation of the controlled Pawn (which may choose not to visually pitch or roll, for example).
        
        Returns:
            Rotator:
        """
        ...

class AIController(Controller):
    r"""
    AIController is the base class of controllers for AI-controlled Pawns.
    
    Controllers are non-physical actors that can be attached to a pawn to control its actions.
    AIControllers manage the artificial intelligence for the pawns they control.
    In networked games, they only exist on the server.
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Framework/Controller/
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIController.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actions_comp`` (PawnActionsComponent):  [Read-Write]
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_strafe`` (bool):  [Read-Write] Is strafing allowed during movement?
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``attach_to_pawn`` (bool):  [Read-Write] If true, the controller location will match the possessed Pawn's location. If false, it will not be updated. Rotation will match ControlRotation in either case.
      Since a Controller's location is normally inaccessible, this is intended mainly for purposes of being able to attach
      an Actor that follows the possessed Pawn location, but that still has the full aim rotation (since a Pawn might
      update only some components of the rotation).
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``blackboard`` (BlackboardComponent):  [Read-Write] blackboard
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brain_component`` (BrainComponent):  [Read-Write] Component responsible for behaviors.
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_navigation_filter_class`` (type(Class)):  [Read-Write]
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_instigated_any_damage`` (InstigatedAnyDamageSignature):  [Read-Write] Called when the controller has instigated damage in any way
    - ``on_possessed_pawn_changed`` (OnPossessedPawnChanged):  [Read-Write] Called on both authorities and clients when the possessed pawn changes (either OldPawn or NewPawn might be nullptr)
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``path_following_component`` (PathFollowingComponent):  [Read-Only] Component used for moving along a path.
    - ``perception_component`` (AIPerceptionComponent):  [Read-Only]
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_state`` (PlayerState):  [Read-Write] PlayerState containing replicated information about the player using this controller (only exists for players, not NPCs).
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``receive_move_completed`` (AIMoveCompletedSignature):  [Read-Write] Blueprint notification that we've completed the current movement request
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``set_control_rotation_from_pawn_orientation`` (bool):  [Read-Write] Copy Pawn rotation to ControlRotation, if there is no focus point.
    - ``skip_extra_los_checks`` (bool):  [Read-Write] Skip extra line of sight traces to extremities of target being checked.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``start_ai_logic_on_possess`` (bool):  [Read-Write] By default AI's logic does not start when controlled Pawn is possessed. Setting this flag to true
          will make AI logic start when pawn is possessed
    - ``stop_ai_logic_on_unposses`` (bool):  [Read-Write] By default AI's logic gets stopped when controlled Pawn is unpossessed. Setting this flag to false
          will make AI logic persist past losing control over a pawn
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``wants_player_state`` (bool):  [Read-Write] Specifies if this AI wants its own PlayerState.
    """
    @property
    def start_ai_logic_on_possess(self) -> bool:
        r"""
        (bool):  [Read-Write] By default AI's logic does not start when controlled Pawn is possessed. Setting this flag to true
            will make AI logic start when pawn is possessed
        """
        ...
    @start_ai_logic_on_possess.setter
    def start_ai_logic_on_possess(self, value: bool) -> None:
        ...
    @property
    def stop_ai_logic_on_unposses(self) -> bool:
        r"""
        (bool):  [Read-Write] By default AI's logic gets stopped when controlled Pawn is unpossessed. Setting this flag to false
            will make AI logic persist past losing control over a pawn
        """
        ...
    @stop_ai_logic_on_unposses.setter
    def stop_ai_logic_on_unposses(self, value: bool) -> None:
        ...
    @property
    def skip_extra_los_checks(self) -> bool:
        r"""
        (bool):  [Read-Write] Skip extra line of sight traces to extremities of target being checked.
        """
        ...
    @skip_extra_los_checks.setter
    def skip_extra_los_checks(self, value: bool) -> None:
        ...
    @property
    def allow_strafe(self) -> bool:
        r"""
        (bool):  [Read-Write] Is strafing allowed during movement?
        """
        ...
    @allow_strafe.setter
    def allow_strafe(self, value: bool) -> None:
        ...
    @property
    def wants_player_state(self) -> bool:
        r"""
        (bool):  [Read-Write] Specifies if this AI wants its own PlayerState.
        """
        ...
    @wants_player_state.setter
    def wants_player_state(self, value: bool) -> None:
        ...
    @property
    def set_control_rotation_from_pawn_orientation(self) -> bool:
        r"""
        (bool):  [Read-Write] Copy Pawn rotation to ControlRotation, if there is no focus point.
        """
        ...
    @set_control_rotation_from_pawn_orientation.setter
    def set_control_rotation_from_pawn_orientation(self, value: bool) -> None:
        ...
    @property
    def brain_component(self) -> BrainComponent:
        r"""
        (BrainComponent):  [Read-Write] Component responsible for behaviors.
        """
        ...
    @brain_component.setter
    def brain_component(self, value: BrainComponent) -> None:
        ...
    @property
    def actions_comp(self) -> PawnActionsComponent:
        r"""
        (PawnActionsComponent):  [Read-Only]
        """
        ...
    @property
    def blackboard(self) -> BlackboardComponent:
        r"""
        (BlackboardComponent):  [Read-Only] blackboard
        """
        ...
    @property
    def default_navigation_filter_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write]
        """
        ...
    @default_navigation_filter_class.setter
    def default_navigation_filter_class(self, value: Class) -> None:
        ...
    @property
    def receive_move_completed(self) -> AIMoveCompletedSignature:
        r"""
        (AIMoveCompletedSignature):  [Read-Write] Blueprint notification that we've completed the current movement request
        """
        ...
    @receive_move_completed.setter
    def receive_move_completed(self, value: AIMoveCompletedSignature) -> None:
        ...
    def use_blackboard(self, blackboard_asset: BlackboardData) -> Optional[BlackboardComponent]:
        r"""
        x.use_blackboard(blackboard_asset) -> BlackboardComponent or None
        Makes AI use the specified Blackboard asset & creates a Blackboard Component if one does not already exist.
        
        Args:
            blackboard_asset (BlackboardData): The Blackboard asset to use.
        
        Returns:
            BlackboardComponent or None: true if we successfully linked the blackboard asset to the blackboard component.
        
            blackboard_component (BlackboardComponent): The Blackboard component that was used or created to work with the passed-in Blackboard Asset.
        """
        ...
    def unclaim_task_resource(self, resource_class: Class) -> None:
        r"""
        x.unclaim_task_resource(resource_class) -> None
        Unclaim Task Resource
        
        Args:
            resource_class (type(Class)):
        """
        ...
    def set_path_following_component(self, new_pf_component: PathFollowingComponent) -> None:
        r"""
        x.set_path_following_component(new_pf_component) -> None
        Note that this function does not do any pathfollowing state transfer.
            Intended to be called as part of initialization/setup process
        
        Args:
            new_pf_component (PathFollowingComponent):
        """
        ...
    def set_move_block_detection(self, enable: bool) -> None:
        r"""
        x.set_move_block_detection(enable) -> None
        Updates state of movement block detection.
        
        Args:
            enable (bool):
        """
        ...
    def run_behavior_tree(self, bt_asset: BehaviorTree) -> bool:
        r"""
        x.run_behavior_tree(bt_asset) -> bool
        Starts executing behavior tree.
        
        Args:
            bt_asset (BehaviorTree): 
        
        Returns:
            bool:
        """
        ...
    def on_using_black_board(self, blackboard_comp: BlackboardComponent, blackboard_asset: BlackboardData) -> None:
        r"""
        x.on_using_black_board(blackboard_comp, blackboard_asset) -> None
        On Using Black Board
        
        Args:
            blackboard_comp (BlackboardComponent): 
            blackboard_asset (BlackboardData):
        """
        ...
    def move_to_location(self, dest: Vector, acceptance_radius: float = -1.000000, stop_on_overlap: bool = True, use_pathfinding: bool = True, project_destination_to_navigation: bool = False, can_strafe: bool = True, filter_class: Class = None, allow_partial_path: bool = True) -> PathFollowingRequestResult:
        r"""
        x.move_to_location(dest, acceptance_radius=-1.000000, stop_on_overlap=True, use_pathfinding=True, project_destination_to_navigation=False, can_strafe=True, filter_class=None, allow_partial_path=True) -> PathFollowingRequestResult
        Makes AI go toward specified Dest location, aborts any active path following
        note: AcceptanceRadius has default value or -1 due to Header Parser not being able to recognize UPathFollowingComponent::DefaultAcceptanceRadius
        
        Args:
            dest (Vector): 
            acceptance_radius (float): finish move if pawn gets close enough
            stop_on_overlap (bool): add pawn's radius to AcceptanceRadius
            use_pathfinding (bool): use navigation data to calculate path (otherwise it will go in straight line)
            project_destination_to_navigation (bool): project location on navigation data before using it
            can_strafe (bool): set focus related flag: bAllowStrafe
            filter_class (type(Class)): navigation filter for pathfinding adjustments. If none specified DefaultNavigationFilterClass will be used
            allow_partial_path (bool): use incomplete path when goal can't be reached
        
        Returns:
            PathFollowingRequestResult:
        """
        ...
    def move_to_actor(self, goal: Actor, acceptance_radius: float = -1.000000, stop_on_overlap: bool = True, use_pathfinding: bool = True, can_strafe: bool = True, filter_class: Class = None, allow_partial_path: bool = True) -> PathFollowingRequestResult:
        r"""
        x.move_to_actor(goal, acceptance_radius=-1.000000, stop_on_overlap=True, use_pathfinding=True, can_strafe=True, filter_class=None, allow_partial_path=True) -> PathFollowingRequestResult
        Makes AI go toward specified Goal actor (destination will be continuously updated), aborts any active path following
        note: AcceptanceRadius has default value or -1 due to Header Parser not being able to recognize UPathFollowingComponent::DefaultAcceptanceRadius
        
        Args:
            goal (Actor): 
            acceptance_radius (float): finish move if pawn gets close enough
            stop_on_overlap (bool): add pawn's radius to AcceptanceRadius
            use_pathfinding (bool): use navigation data to calculate path (otherwise it will go in straight line)
            can_strafe (bool): set focus related flag: bAllowStrafe
            filter_class (type(Class)): navigation filter for pathfinding adjustments. If none specified DefaultNavigationFilterClass will be used
            allow_partial_path (bool): use incomplete path when goal can't be reached
        
        Returns:
            PathFollowingRequestResult:
        """
        ...
    def set_focus(self, new_focus: Actor) -> None:
        r"""
        x.set_focus(new_focus) -> None
        Set Focus for actor, will set FocalPoint as a result.
        
        Args:
            new_focus (Actor):
        """
        ...
    def set_focal_point(self, fp: Vector) -> None:
        r"""
        x.set_focal_point(fp) -> None
        Set the position that controller should be looking at.
        
        Args:
            fp (Vector):
        """
        ...
    def clear_focus(self) -> None:
        r"""
        x.clear_focus() -> None
        Clears Focus, will also clear FocalPoint as a result
        """
        ...
    def has_partial_path(self) -> bool:
        r"""
        x.has_partial_path() -> bool
        Returns true if the current PathFollowingComponent's path is partial (does not reach desired destination).
        
        Returns:
            bool:
        """
        ...
    def get_path_following_component(self) -> PathFollowingComponent:
        r"""
        x.get_path_following_component() -> PathFollowingComponent
        Returns PathFollowingComponent subobject *
        
        Returns:
            PathFollowingComponent:
        """
        ...
    def get_move_status(self) -> PathFollowingStatus:
        r"""
        x.get_move_status() -> PathFollowingStatus
        Returns status of path following
        
        Returns:
            PathFollowingStatus:
        """
        ...
    def get_immediate_move_destination(self) -> Vector:
        r"""
        x.get_immediate_move_destination() -> Vector
        Returns position of current path segment's end.
        
        Returns:
            Vector:
        """
        ...
    def get_focus_actor(self) -> Actor:
        r"""
        x.get_focus_actor() -> Actor
        Get the focused actor.
        
        Returns:
            Actor:
        """
        ...
    def get_focal_point_on_actor(self, actor: Actor) -> Vector:
        r"""
        x.get_focal_point_on_actor(actor) -> Vector
        Retrieve the focal point this controller should focus to on given actor.
        
        Args:
            actor (Actor): 
        
        Returns:
            Vector:
        """
        ...
    def get_focal_point(self) -> Vector:
        r"""
        x.get_focal_point() -> Vector
        Retrieve the final position that controller should be looking at.
        
        Returns:
            Vector:
        """
        ...
    def get_ai_perception_component(self) -> AIPerceptionComponent:
        r"""
        x.get_ai_perception_component() -> AIPerceptionComponent
        Get AIPerception Component
        
        Returns:
            AIPerceptionComponent:
        """
        ...
    def claim_task_resource(self, resource_class: Class) -> None:
        r"""
        x.claim_task_resource(resource_class) -> None
        Claim Task Resource
        
        Args:
            resource_class (type(Class)):
        """
        ...

class AIResource_Movement(GameplayTaskResource):
    r"""
    AIResource Movement
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIResources.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``manual_resource_id`` (int32):  [Read-Write] Overrides AutoResourceID. -1 means auto ID will be applied
    - ``manually_set_id`` (bool):  [Read-Write]
    """
    ...

class AIResource_Logic(GameplayTaskResource):
    r"""
    AIResource Logic
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIResources.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``manual_resource_id`` (int32):  [Read-Write] Overrides AutoResourceID. -1 means auto ID will be applied
    - ``manually_set_id`` (bool):  [Read-Write]
    """
    ...

class BehaviorTree(Object):
    r"""
    Behavior Tree
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BehaviorTree.h
    
    """
    def get_blackboard_asset(self) -> BlackboardData:
        r"""
        x.get_blackboard_asset() -> BlackboardData
        Returns BlackboardData referenced by the owner object.
        
        Returns:
            BlackboardData:
        """
        ...

class BrainComponent(ActorComponent):
    r"""
    Brain Component
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BrainComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    def stop_logic(self, reason: str) -> None:
        r"""
        x.stop_logic(reason) -> None
        Stops currently running brain logic.
        
        Args:
            reason (str):
        """
        ...
    def start_logic(self) -> None:
        r"""
        x.start_logic() -> None
        Starts brain logic. If brain is already running, will not do anything.
        """
        ...
    def restart_logic(self) -> None:
        r"""
        x.restart_logic() -> None
        Restarts currently running or previously ran brain logic.
        """
        ...
    def is_running(self) -> bool:
        r"""
        x.is_running() -> bool
        Is Running
        
        Returns:
            bool:
        """
        ...
    def is_paused(self) -> bool:
        r"""
        x.is_paused() -> bool
        Is Paused
        
        Returns:
            bool:
        """
        ...

class BehaviorTreeComponent(BrainComponent):
    r"""
    Behavior Tree Component
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BehaviorTreeComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``default_behavior_tree_asset`` (BehaviorTree):  [Read-Write] data asset defining the tree
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def default_behavior_tree_asset(self) -> BehaviorTree:
        r"""
        (BehaviorTree):  [Read-Write] data asset defining the tree
        """
        ...
    @default_behavior_tree_asset.setter
    def default_behavior_tree_asset(self, value: BehaviorTree) -> None:
        ...
    def set_dynamic_subtree(self, inject_tag: GameplayTag, behavior_asset: BehaviorTree) -> None:
        r"""
        x.set_dynamic_subtree(inject_tag, behavior_asset) -> None
        assign subtree to RunBehaviorDynamic task specified by tag.
        
        Args:
            inject_tag (GameplayTag): 
            behavior_asset (BehaviorTree):
        """
        ...
    def get_tag_cooldown_end_time(self, cooldown_tag: GameplayTag) -> float:
        r"""
        x.get_tag_cooldown_end_time(cooldown_tag) -> double
        
        
        Args:
            cooldown_tag (GameplayTag): 
        
        Returns:
            double: the cooldown tag end time, 0.0f if CooldownTag is not found
        """
        ...
    def add_cooldown_tag_duration(self, cooldown_tag: GameplayTag, cooldown_duration: float, add_to_existing_duration: bool) -> None:
        r"""
        x.add_cooldown_tag_duration(cooldown_tag, cooldown_duration, add_to_existing_duration) -> None
        add to the cooldown tag's duration
        
        Args:
            cooldown_tag (GameplayTag): 
            cooldown_duration (float): 
            add_to_existing_duration (bool):
        """
        ...

class BlackboardAssetProvider(Interface):
    r"""
    Blackboard Asset Provider
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BlackboardAssetProvider.h
    
    """
    def get_blackboard_asset(self) -> BlackboardData:
        r"""
        x.get_blackboard_asset() -> BlackboardData
        Returns BlackboardData referenced by the owner object.
        
        Returns:
            BlackboardData:
        """
        ...

class BlackboardComponent(ActorComponent):
    r"""
    Blackboard Component
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BlackboardComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``default_blackboard_asset`` (BlackboardData):  [Read-Write] data asset defining entries. Will be used as part of InitializeComponent
          call provided BlackboardAsset hasn't been already set (via a InitializeBlackboard
          call).
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    def set_value_as_vector(self, key_name: Name, vector_value: Vector) -> None:
        r"""
        x.set_value_as_vector(key_name, vector_value) -> None
        Set Value as Vector
        
        Args:
            key_name (Name): 
            vector_value (Vector):
        """
        ...
    def set_value_as_string(self, key_name: Name, string_value: str) -> None:
        r"""
        x.set_value_as_string(key_name, string_value) -> None
        Set Value as String
        
        Args:
            key_name (Name): 
            string_value (str):
        """
        ...
    def set_value_as_rotator(self, key_name: Name, vector_value: Rotator) -> None:
        r"""
        x.set_value_as_rotator(key_name, vector_value) -> None
        Set Value as Rotator
        
        Args:
            key_name (Name): 
            vector_value (Rotator):
        """
        ...
    def set_value_as_object(self, key_name: Name, object_value: Object) -> None:
        r"""
        x.set_value_as_object(key_name, object_value) -> None
        Set Value as Object
        
        Args:
            key_name (Name): 
            object_value (Object):
        """
        ...
    def set_value_as_name(self, key_name: Name, name_value: Name) -> None:
        r"""
        x.set_value_as_name(key_name, name_value) -> None
        Set Value as Name
        
        Args:
            key_name (Name): 
            name_value (Name):
        """
        ...
    def set_value_as_int(self, key_name: Name, int_value: int) -> None:
        r"""
        x.set_value_as_int(key_name, int_value) -> None
        Set Value as Int
        
        Args:
            key_name (Name): 
            int_value (int32):
        """
        ...
    def set_value_as_float(self, key_name: Name, float_value: float) -> None:
        r"""
        x.set_value_as_float(key_name, float_value) -> None
        Set Value as Float
        
        Args:
            key_name (Name): 
            float_value (float):
        """
        ...
    def set_value_as_enum(self, key_name: Name, enum_value: int) -> None:
        r"""
        x.set_value_as_enum(key_name, enum_value) -> None
        Set Value as Enum
        
        Args:
            key_name (Name): 
            enum_value (uint8):
        """
        ...
    def set_value_as_class(self, key_name: Name, class_value: Class) -> None:
        r"""
        x.set_value_as_class(key_name, class_value) -> None
        Set Value as Class
        
        Args:
            key_name (Name): 
            class_value (type(Class)):
        """
        ...
    def set_value_as_bool(self, key_name: Name, bool_value: bool) -> None:
        r"""
        x.set_value_as_bool(key_name, bool_value) -> None
        Set Value as Bool
        
        Args:
            key_name (Name): 
            bool_value (bool):
        """
        ...
    def is_vector_value_set(self, key_name: Name) -> bool:
        r"""
        x.is_vector_value_set(key_name) -> bool
        If the vector value has been set (and not cleared), this function returns true (indicating that the value should be valid).  If it's not set, the vector value is invalid and this function will return false.  (Also returns false if the key specified does not hold a vector.)
        
        Args:
            key_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def get_value_as_vector(self, key_name: Name) -> Vector:
        r"""
        x.get_value_as_vector(key_name) -> Vector
        Get Value as Vector
        
        Args:
            key_name (Name): 
        
        Returns:
            Vector:
        """
        ...
    def get_value_as_string(self, key_name: Name) -> str:
        r"""
        x.get_value_as_string(key_name) -> str
        Get Value as String
        
        Args:
            key_name (Name): 
        
        Returns:
            str:
        """
        ...
    def get_value_as_rotator(self, key_name: Name) -> Rotator:
        r"""
        x.get_value_as_rotator(key_name) -> Rotator
        Get Value as Rotator
        
        Args:
            key_name (Name): 
        
        Returns:
            Rotator:
        """
        ...
    def get_value_as_object(self, key_name: Name) -> Object:
        r"""
        x.get_value_as_object(key_name) -> Object
        Get Value as Object
        
        Args:
            key_name (Name): 
        
        Returns:
            Object:
        """
        ...
    def get_value_as_name(self, key_name: Name) -> Name:
        r"""
        x.get_value_as_name(key_name) -> Name
        Get Value as Name
        
        Args:
            key_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def get_value_as_int(self, key_name: Name) -> int:
        r"""
        x.get_value_as_int(key_name) -> int32
        Get Value as Int
        
        Args:
            key_name (Name): 
        
        Returns:
            int32:
        """
        ...
    def get_value_as_float(self, key_name: Name) -> float:
        r"""
        x.get_value_as_float(key_name) -> float
        Get Value as Float
        
        Args:
            key_name (Name): 
        
        Returns:
            float:
        """
        ...
    def get_value_as_enum(self, key_name: Name) -> int:
        r"""
        x.get_value_as_enum(key_name) -> uint8
        Get Value as Enum
        
        Args:
            key_name (Name): 
        
        Returns:
            uint8:
        """
        ...
    def get_value_as_class(self, key_name: Name) -> Class:
        r"""
        x.get_value_as_class(key_name) -> type(Class)
        Get Value as Class
        
        Args:
            key_name (Name): 
        
        Returns:
            type(Class):
        """
        ...
    def get_value_as_bool(self, key_name: Name) -> bool:
        r"""
        x.get_value_as_bool(key_name) -> bool
        Get Value as Bool
        
        Args:
            key_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def get_rotation_from_entry(self, key_name: Name) -> Optional[Rotator]:
        r"""
        x.get_rotation_from_entry(key_name) -> Rotator or None
        return false if call failed (most probably no such entry in BB)
        
        Args:
            key_name (Name): 
        
        Returns:
            Rotator or None: 
        
            result_rotation (Rotator):
        """
        ...
    def get_location_from_entry(self, key_name: Name) -> Optional[Vector]:
        r"""
        x.get_location_from_entry(key_name) -> Vector or None
        return false if call failed (most probably no such entry in BB)
        
        Args:
            key_name (Name): 
        
        Returns:
            Vector or None: 
        
            result_location (Vector):
        """
        ...
    def clear_value(self, key_name: Name) -> None:
        r"""
        x.clear_value(key_name) -> None
        Clear Value
        
        Args:
            key_name (Name):
        """
        ...

class DataAsset(Object):
    r"""
    Create a simple asset that stores data related to a particular system in an instance of this class.
    Assets can be made in the Content Browser using any native class that inherits from this.
    If you want data inheritance or a complicated hierarchy, Data Only Blueprint Classes should be created instead.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataAsset.h
    
    """
    ...

class BlackboardData(DataAsset):
    r"""
    Blackboard Data
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BlackboardData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``keys`` (Array[BlackboardEntry]):  [Read-Write] blackboard keys
    - ``parent`` (BlackboardData):  [Read-Write] parent blackboard (keys can be overridden)
    - ``parent_keys`` (Array[BlackboardEntry]):  [Read-Only] all keys inherited from parent chain
    """
    ...

class BTFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    BTFunction Library
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BTFunctionLibrary.h
    
    """
    @classmethod
    def stop_using_external_event(cls, node_owner: BTNode) -> None:
        r"""
        X.stop_using_external_event(node_owner) -> None
        Save variables marked as "instance memory" and clear owning actor
        deprecated: No longer needed
        
        Args:
            node_owner (BTNode):
        """
        ...
    @classmethod
    def start_using_external_event(cls, node_owner: BTNode, owning_actor: Actor) -> None:
        r"""
        X.start_using_external_event(node_owner, owning_actor) -> None
        Initialize variables marked as "instance memory" and set owning actor for blackboard operations
        deprecated: No longer needed
        
        Args:
            node_owner (BTNode): 
            owning_actor (Actor):
        """
        ...
    @classmethod
    def set_blackboard_value_as_vector(cls, node_owner: BTNode, key: BlackboardKeySelector, value: Vector) -> None:
        r"""
        X.set_blackboard_value_as_vector(node_owner, key, value) -> None
        Set Blackboard Value as Vector
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
            value (Vector):
        """
        ...
    @classmethod
    def set_blackboard_value_as_string(cls, node_owner: BTNode, key: BlackboardKeySelector, value: str) -> None:
        r"""
        X.set_blackboard_value_as_string(node_owner, key, value) -> None
        Set Blackboard Value as String
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
            value (str):
        """
        ...
    @classmethod
    def set_blackboard_value_as_rotator(cls, node_owner: BTNode, key: BlackboardKeySelector, value: Rotator) -> None:
        r"""
        X.set_blackboard_value_as_rotator(node_owner, key, value) -> None
        Set Blackboard Value as Rotator
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
            value (Rotator):
        """
        ...
    @classmethod
    def set_blackboard_value_as_object(cls, node_owner: BTNode, key: BlackboardKeySelector, value: Object) -> None:
        r"""
        X.set_blackboard_value_as_object(node_owner, key, value) -> None
        Set Blackboard Value as Object
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
            value (Object):
        """
        ...
    @classmethod
    def set_blackboard_value_as_name(cls, node_owner: BTNode, key: BlackboardKeySelector, value: Name) -> None:
        r"""
        X.set_blackboard_value_as_name(node_owner, key, value) -> None
        Set Blackboard Value as Name
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
            value (Name):
        """
        ...
    @classmethod
    def set_blackboard_value_as_int(cls, node_owner: BTNode, key: BlackboardKeySelector, value: int) -> None:
        r"""
        X.set_blackboard_value_as_int(node_owner, key, value) -> None
        Set Blackboard Value as Int
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
            value (int32):
        """
        ...
    @classmethod
    def set_blackboard_value_as_float(cls, node_owner: BTNode, key: BlackboardKeySelector, value: float) -> None:
        r"""
        X.set_blackboard_value_as_float(node_owner, key, value) -> None
        Set Blackboard Value as Float
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
            value (float):
        """
        ...
    @classmethod
    def set_blackboard_value_as_enum(cls, node_owner: BTNode, key: BlackboardKeySelector, value: int) -> None:
        r"""
        X.set_blackboard_value_as_enum(node_owner, key, value) -> None
        Set Blackboard Value as Enum
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
            value (uint8):
        """
        ...
    @classmethod
    def set_blackboard_value_as_class(cls, node_owner: BTNode, key: BlackboardKeySelector, value: Class) -> None:
        r"""
        X.set_blackboard_value_as_class(node_owner, key, value) -> None
        Set Blackboard Value as Class
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
            value (type(Class)):
        """
        ...
    @classmethod
    def set_blackboard_value_as_bool(cls, node_owner: BTNode, key: BlackboardKeySelector, value: bool) -> None:
        r"""
        X.set_blackboard_value_as_bool(node_owner, key, value) -> None
        Set Blackboard Value as Bool
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
            value (bool):
        """
        ...
    @classmethod
    def get_owners_blackboard(cls, node_owner: BTNode) -> BlackboardComponent:
        r"""
        X.get_owners_blackboard(node_owner) -> BlackboardComponent
        Get Owners Blackboard
        
        Args:
            node_owner (BTNode): 
        
        Returns:
            BlackboardComponent:
        """
        ...
    @classmethod
    def get_blackboard(cls, node_owner: BTNode) -> BlackboardComponent:
        r"""
        deprecated: 'get_blackboard' was renamed to 'get_owners_blackboard'.
        """
        ...
    @classmethod
    def get_owner_component(cls, node_owner: BTNode) -> BehaviorTreeComponent:
        r"""
        X.get_owner_component(node_owner) -> BehaviorTreeComponent
        Get Owner Component
        
        Args:
            node_owner (BTNode): 
        
        Returns:
            BehaviorTreeComponent:
        """
        ...
    @classmethod
    def get_blackboard_value_as_vector(cls, node_owner: BTNode, key: BlackboardKeySelector) -> Vector:
        r"""
        X.get_blackboard_value_as_vector(node_owner, key) -> Vector
        Get Blackboard Value as Vector
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_blackboard_value_as_string(cls, node_owner: BTNode, key: BlackboardKeySelector) -> str:
        r"""
        X.get_blackboard_value_as_string(node_owner, key) -> str
        Get Blackboard Value as String
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_blackboard_value_as_rotator(cls, node_owner: BTNode, key: BlackboardKeySelector) -> Rotator:
        r"""
        X.get_blackboard_value_as_rotator(node_owner, key) -> Rotator
        Get Blackboard Value as Rotator
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def get_blackboard_value_as_object(cls, node_owner: BTNode, key: BlackboardKeySelector) -> Object:
        r"""
        X.get_blackboard_value_as_object(node_owner, key) -> Object
        Get Blackboard Value as Object
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def get_blackboard_value_as_name(cls, node_owner: BTNode, key: BlackboardKeySelector) -> Name:
        r"""
        X.get_blackboard_value_as_name(node_owner, key) -> Name
        Get Blackboard Value as Name
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def get_blackboard_value_as_int(cls, node_owner: BTNode, key: BlackboardKeySelector) -> int:
        r"""
        X.get_blackboard_value_as_int(node_owner, key) -> int32
        Get Blackboard Value as Int
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_blackboard_value_as_float(cls, node_owner: BTNode, key: BlackboardKeySelector) -> float:
        r"""
        X.get_blackboard_value_as_float(node_owner, key) -> float
        Get Blackboard Value as Float
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_blackboard_value_as_enum(cls, node_owner: BTNode, key: BlackboardKeySelector) -> int:
        r"""
        X.get_blackboard_value_as_enum(node_owner, key) -> uint8
        Get Blackboard Value as Enum
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
        
        Returns:
            uint8:
        """
        ...
    @classmethod
    def get_blackboard_value_as_class(cls, node_owner: BTNode, key: BlackboardKeySelector) -> Class:
        r"""
        X.get_blackboard_value_as_class(node_owner, key) -> type(Class)
        Get Blackboard Value as Class
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
        
        Returns:
            type(Class):
        """
        ...
    @classmethod
    def get_blackboard_value_as_bool(cls, node_owner: BTNode, key: BlackboardKeySelector) -> bool:
        r"""
        X.get_blackboard_value_as_bool(node_owner, key) -> bool
        Get Blackboard Value as Bool
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_blackboard_value_as_actor(cls, node_owner: BTNode, key: BlackboardKeySelector) -> Actor:
        r"""
        X.get_blackboard_value_as_actor(node_owner, key) -> Actor
        Get Blackboard Value as Actor
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector): 
        
        Returns:
            Actor:
        """
        ...
    @classmethod
    def clear_blackboard_value_as_vector(cls, node_owner: BTNode, key: BlackboardKeySelector) -> None:
        r"""
        X.clear_blackboard_value_as_vector(node_owner, key) -> None
        (DEPRECATED) Use ClearBlackboardValue instead
        deprecated: Use ClearBlackboardValue instead.
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector):
        """
        ...
    @classmethod
    def clear_blackboard_value(cls, node_owner: BTNode, key: BlackboardKeySelector) -> None:
        r"""
        X.clear_blackboard_value(node_owner, key) -> None
        Resets indicated value to "not set" value, based on values type
        
        Args:
            node_owner (BTNode): 
            key (BlackboardKeySelector):
        """
        ...

class BTNode(Object):
    r"""
    BTNode
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BTNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``node_name`` (str):  [Read-Write] node name
    """
    ...

class BTAuxiliaryNode(BTNode):
    r"""
    Auxiliary nodes are supporting nodes, that receive notification about execution flow and can be ticked
    
    Because some of them can be instanced for specific AI, following virtual functions are not marked as const:
     - OnBecomeRelevant
     - OnCeaseRelevant
     - TickNode
    
    If your node is not being instanced (default behavior), DO NOT change any properties of object within those functions!
    Template nodes are shared across all behavior tree components using the same tree asset and must store
    their runtime properties in provided NodeMemory block (allocation size determined by GetInstanceMemorySize() )
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BTAuxiliaryNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``node_name`` (str):  [Read-Write] node name
    """
    ...

class BTDecorator(BTAuxiliaryNode):
    r"""
    Decorators are supporting nodes placed on parent-child connection, that receive notification about execution flow and can be ticked
    
    Because some of them can be instanced for specific AI, following virtual functions are not marked as const:
     - OnNodeActivation
     - OnNodeDeactivation
     - OnNodeProcessed
     - OnBecomeRelevant (from UBTAuxiliaryNode)
     - OnCeaseRelevant (from UBTAuxiliaryNode)
     - TickNode (from UBTAuxiliaryNode)
    
    If your node is not being instanced (default behavior), DO NOT change any properties of object within those functions!
    Template nodes are shared across all behavior tree components using the same tree asset and must store
    their runtime properties in provided NodeMemory block (allocation size determined by GetInstanceMemorySize() )
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BTDecorator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``flow_abort_mode`` (BTFlowAbortMode):  [Read-Write] flow controller settings
    - ``inverse_condition`` (bool):  [Read-Write] if set, condition check result will be inversed
    - ``node_name`` (str):  [Read-Write] node name
    """
    ...

class BTDecorator_BlueprintBase(BTDecorator):
    r"""
    Base class for blueprint based decorator nodes. Do NOT use it for creating native c++ classes!
    
    Unlike task and services, decorator have two execution chains:
     ExecutionStart-ExecutionFinish and ObserverActivated-ObserverDeactivated
    which makes automatic latent action cleanup impossible. Keep in mind, that
    you HAVE TO verify is given chain is still active after resuming from any
    latent action (like Delay, Timelines, etc).
    
    Helper functions:
    - IsDecoratorExecutionActive (true after ExecutionStart, until ExecutionFinish)
    - IsDecoratorObserverActive (true after ObserverActivated, until ObserverDeactivated)
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BTDecorator_BlueprintBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``check_condition_only_black_board_changes`` (bool):  [Read-Write] Applies only if Decorator has any FBlackboardKeySelector property and if decorator is
          set to abort BT flow. Is set to true ReceiveConditionCheck will be called only on changes
         to observed BB keys. If false or no BB keys observed ReceiveConditionCheck will be called every tick
    - ``custom_description`` (str):  [Read-Write]
    - ``flow_abort_mode`` (BTFlowAbortMode):  [Read-Write] flow controller settings
    - ``inverse_condition`` (bool):  [Read-Write] if set, condition check result will be inversed
    - ``node_name`` (str):  [Read-Write] node name
    - ``show_property_details`` (bool):  [Read-Write] show detailed information about properties
    """
    @property
    def custom_description(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @custom_description.setter
    def custom_description(self, value: str) -> None:
        ...
    def receive_tick_ai(self, owner_controller: AIController, controlled_pawn: Pawn, delta_seconds: float) -> None:
        r"""
        x.receive_tick_ai(owner_controller, controlled_pawn, delta_seconds) -> None
        Alternative AI version of ReceiveTick
        see: ReceiveTick for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn): 
            delta_seconds (float):
        """
        ...
    def receive_tick(self, owner_actor: Actor, delta_seconds: float) -> None:
        r"""
        x.receive_tick(owner_actor, delta_seconds) -> None
        tick function
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor): 
            delta_seconds (float):
        """
        ...
    def receive_observer_deactivated_ai(self, owner_controller: AIController, controlled_pawn: Pawn) -> None:
        r"""
        x.receive_observer_deactivated_ai(owner_controller, controlled_pawn) -> None
        Alternative AI version of ReceiveObserverDeactivated
        see: ReceiveObserverDeactivated for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn):
        """
        ...
    def receive_observer_deactivated(self, owner_actor: Actor) -> None:
        r"""
        x.receive_observer_deactivated(owner_actor) -> None
        called when observer is deactivated (flow controller)
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor):
        """
        ...
    def receive_observer_activated_ai(self, owner_controller: AIController, controlled_pawn: Pawn) -> None:
        r"""
        x.receive_observer_activated_ai(owner_controller, controlled_pawn) -> None
        Alternative AI version of ReceiveObserverActivated
        see: ReceiveObserverActivated for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn):
        """
        ...
    def receive_observer_activated(self, owner_actor: Actor) -> None:
        r"""
        x.receive_observer_activated(owner_actor) -> None
        called when observer is activated (flow controller)
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor):
        """
        ...
    def receive_execution_start_ai(self, owner_controller: AIController, controlled_pawn: Pawn) -> None:
        r"""
        x.receive_execution_start_ai(owner_controller, controlled_pawn) -> None
        Alternative AI version of ReceiveExecutionStart
        see: ReceiveExecutionStart for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn):
        """
        ...
    def receive_execution_start(self, owner_actor: Actor) -> None:
        r"""
        x.receive_execution_start(owner_actor) -> None
        called on execution of underlying node
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor):
        """
        ...
    def receive_execution_finish_ai(self, owner_controller: AIController, controlled_pawn: Pawn, node_result: BTNodeResult) -> None:
        r"""
        x.receive_execution_finish_ai(owner_controller, controlled_pawn, node_result) -> None
        Alternative AI version of ReceiveExecutionFinish
        see: ReceiveExecutionFinish for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn): 
            node_result (BTNodeResult):
        """
        ...
    def receive_execution_finish(self, owner_actor: Actor, node_result: BTNodeResult) -> None:
        r"""
        x.receive_execution_finish(owner_actor, node_result) -> None
        called when execution of underlying node is finished
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor): 
            node_result (BTNodeResult):
        """
        ...
    def perform_condition_check_ai(self, owner_controller: AIController, controlled_pawn: Pawn) -> bool:
        r"""
        x.perform_condition_check_ai(owner_controller, controlled_pawn) -> bool
        Alternative AI version of ReceiveConditionCheck
        see: ReceiveConditionCheck for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn): 
        
        Returns:
            bool:
        """
        ...
    def perform_condition_check(self, owner_actor: Actor) -> bool:
        r"""
        x.perform_condition_check(owner_actor) -> bool
        called when testing if underlying node can be executed, must call FinishConditionCheck
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor): 
        
        Returns:
            bool:
        """
        ...
    def is_decorator_observer_active(self) -> bool:
        r"""
        x.is_decorator_observer_active() -> bool
        check if decorator's observer is currently active
        
        Returns:
            bool:
        """
        ...
    def is_decorator_execution_active(self) -> bool:
        r"""
        x.is_decorator_execution_active() -> bool
        check if decorator is part of currently active branch
        
        Returns:
            bool:
        """
        ...

class BTService(BTAuxiliaryNode):
    r"""
    Behavior Tree service nodes is designed to perform "background" tasks that update AI's knowledge.
    
    Services are being executed when underlying branch of behavior tree becomes active,
    but unlike tasks they don't return any results and can't directly affect execution flow.
    
    Usually they perform periodical checks (see TickNode) and often store results in blackboard.
    If any decorator node below requires results of check beforehand, use OnSearchStart function.
    Keep in mind that any checks performed there have to be instantaneous!
    
    Other typical use case is creating a marker when specific branch is being executed
    (see OnBecomeRelevant, OnCeaseRelevant), by setting a flag in blackboard.
    
    Because some of them can be instanced for specific AI, following virtual functions are not marked as const:
    - OnBecomeRelevant (from UBTAuxiliaryNode)
    - OnCeaseRelevant (from UBTAuxiliaryNode)
    - TickNode (from UBTAuxiliaryNode)
    - OnSearchStart
    
    If your node is not being instanced (default behavior), DO NOT change any properties of object within those functions!
    Template nodes are shared across all behavior tree components using the same tree asset and must store
    their runtime properties in provided NodeMemory block (allocation size determined by GetInstanceMemorySize() )
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BTService.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``call_tick_on_search_start`` (bool):  [Read-Write] call Tick event when task search enters this node (SearchStart will be called as well)
    - ``interval`` (float):  [Read-Write] defines time span between subsequent ticks of the service
    - ``node_name`` (str):  [Read-Write] node name
    - ``random_deviation`` (float):  [Read-Write] adds random range to service's Interval
    - ``restart_timer_on_each_activation`` (bool):  [Read-Write] if set, next tick time will be always reset to service's interval when node is activated
    """
    ...

class BTService_BlueprintBase(BTService):
    r"""
    Base class for blueprint based service nodes. Do NOT use it for creating native c++ classes!
    
    When service receives Deactivation event, all latent actions associated this instance are being removed.
    This prevents from resuming activity started by Activation, but does not handle external events.
    Please use them safely (unregister at abort) and call IsServiceActive() when in doubt.
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BTService_BlueprintBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``call_tick_on_search_start`` (bool):  [Read-Write] call Tick event when task search enters this node (SearchStart will be called as well)
    - ``custom_description`` (str):  [Read-Write]
    - ``interval`` (float):  [Read-Write] defines time span between subsequent ticks of the service
    - ``node_name`` (str):  [Read-Write] node name
    - ``random_deviation`` (float):  [Read-Write] adds random range to service's Interval
    - ``restart_timer_on_each_activation`` (bool):  [Read-Write] if set, next tick time will be always reset to service's interval when node is activated
    - ``show_event_details`` (bool):  [Read-Write] show detailed information about implemented events
    - ``show_property_details`` (bool):  [Read-Write] show detailed information about properties
    """
    @property
    def custom_description(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @custom_description.setter
    def custom_description(self, value: str) -> None:
        ...
    def receive_tick_ai(self, owner_controller: AIController, controlled_pawn: Pawn, delta_seconds: float) -> None:
        r"""
        x.receive_tick_ai(owner_controller, controlled_pawn, delta_seconds) -> None
        Alternative AI version of ReceiveTick function.
        see: ReceiveTick for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn): 
            delta_seconds (float):
        """
        ...
    def receive_tick(self, owner_actor: Actor, delta_seconds: float) -> None:
        r"""
        x.receive_tick(owner_actor, delta_seconds) -> None
        tick function
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor): 
            delta_seconds (float):
        """
        ...
    def receive_search_start_ai(self, owner_controller: AIController, controlled_pawn: Pawn) -> None:
        r"""
        x.receive_search_start_ai(owner_controller, controlled_pawn) -> None
        Alternative AI version of ReceiveSearchStart function.
        see: ReceiveSearchStart for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn):
        """
        ...
    def receive_search_start(self, owner_actor: Actor) -> None:
        r"""
        x.receive_search_start(owner_actor) -> None
        task search enters branch of tree
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor):
        """
        ...
    def receive_deactivation_ai(self, owner_controller: AIController, controlled_pawn: Pawn) -> None:
        r"""
        x.receive_deactivation_ai(owner_controller, controlled_pawn) -> None
        Alternative AI version of ReceiveDeactivation function.
        see: ReceiveDeactivation for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn):
        """
        ...
    def receive_deactivation(self, owner_actor: Actor) -> None:
        r"""
        x.receive_deactivation(owner_actor) -> None
        service became inactive
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor):
        """
        ...
    def receive_activation_ai(self, owner_controller: AIController, controlled_pawn: Pawn) -> None:
        r"""
        x.receive_activation_ai(owner_controller, controlled_pawn) -> None
        Alternative AI version of ReceiveActivation function.
        see: ReceiveActivation for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn):
        """
        ...
    def receive_activation(self, owner_actor: Actor) -> None:
        r"""
        x.receive_activation(owner_actor) -> None
        service became active
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor):
        """
        ...
    def is_service_active(self) -> bool:
        r"""
        x.is_service_active() -> bool
        check if service is currently being active
        
        Returns:
            bool:
        """
        ...

class BTTaskNode(BTNode):
    r"""
    Task are leaf nodes of behavior tree, which perform actual actions
    
    Because some of them can be instanced for specific AI, following virtual functions are not marked as const:
     - ExecuteTask
     - AbortTask
     - TickTask
     - OnMessage
    
    If your node is not being instanced (default behavior), DO NOT change any properties of object within those functions!
    Template nodes are shared across all behavior tree components using the same tree asset and must store
    their runtime properties in provided NodeMemory block (allocation size determined by GetInstanceMemorySize() )
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BTTaskNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ignore_restart_self`` (bool):  [Read-Write] if set, task search will be discarded when this task is selected to execute but is already running
    - ``node_name`` (str):  [Read-Write] node name
    """
    ...

class BTTask_BlueprintBase(BTTaskNode):
    r"""
    Base class for blueprint based task nodes. Do NOT use it for creating native c++ classes!
    
    When task receives Abort event, all latent actions associated this instance are being removed.
    This prevents from resuming activity started by Execute, but does not handle external events.
    Please use them safely (unregister at abort) and call IsTaskExecuting() when in doubt.
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BTTask_BlueprintBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``custom_description`` (str):  [Read-Write]
    - ``ignore_restart_self`` (bool):  [Read-Write] if set, task search will be discarded when this task is selected to execute but is already running
    - ``node_name`` (str):  [Read-Write] node name
    - ``show_property_details`` (bool):  [Read-Write] show detailed information about properties
    - ``tick_interval`` (IntervalCountdown):  [Read-Write] If any of the Tick functions is implemented, how often should they be ticked.
          Values < 0 mean 'every tick'.
    """
    @property
    def custom_description(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @custom_description.setter
    def custom_description(self, value: str) -> None:
        ...
    def set_finish_on_message_with_id(self, message_name: Name, request_id: int = -1) -> None:
        r"""
        x.set_finish_on_message_with_id(message_name, request_id=-1) -> None
        task execution will be finished (with result 'Success') after receiving specified message with indicated ID
        
        Args:
            message_name (Name): 
            request_id (int32):
        """
        ...
    def set_finish_on_message(self, message_name: Name) -> None:
        r"""
        x.set_finish_on_message(message_name) -> None
        task execution will be finished (with result 'Success') after receiving specified message
        
        Args:
            message_name (Name):
        """
        ...
    def receive_tick_ai(self, owner_controller: AIController, controlled_pawn: Pawn, delta_seconds: float) -> None:
        r"""
        x.receive_tick_ai(owner_controller, controlled_pawn, delta_seconds) -> None
        Alternative AI version of tick function.
        see: ReceiveTick for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn): 
            delta_seconds (float):
        """
        ...
    def receive_tick(self, owner_actor: Actor, delta_seconds: float) -> None:
        r"""
        x.receive_tick(owner_actor, delta_seconds) -> None
        tick function
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor): 
            delta_seconds (float):
        """
        ...
    def receive_execute_ai(self, owner_controller: AIController, controlled_pawn: Pawn) -> None:
        r"""
        x.receive_execute_ai(owner_controller, controlled_pawn) -> None
        Alternative AI version of ReceiveExecute
        see: ReceiveExecute for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn):
        """
        ...
    def receive_execute(self, owner_actor: Actor) -> None:
        r"""
        x.receive_execute(owner_actor) -> None
        entry point, task will stay active until FinishExecute is called.
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor):
        """
        ...
    def receive_abort_ai(self, owner_controller: AIController, controlled_pawn: Pawn) -> None:
        r"""
        x.receive_abort_ai(owner_controller, controlled_pawn) -> None
        Alternative AI version of ReceiveAbort
        see: ReceiveAbort for more details
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_controller (AIController): 
            controlled_pawn (Pawn):
        """
        ...
    def receive_abort(self, owner_actor: Actor) -> None:
        r"""
        x.receive_abort(owner_actor) -> None
        if blueprint graph contains this event, task will stay active until FinishAbort is called
        Note: that if both generic and AI event versions are implemented only the more suitable one will be called, meaning the AI version if called for AI, generic one otherwise
        
        Args:
            owner_actor (Actor):
        """
        ...
    def is_task_executing(self) -> bool:
        r"""
        x.is_task_executing() -> bool
        check if task is currently being executed
        
        Returns:
            bool:
        """
        ...
    def is_task_aborting(self) -> bool:
        r"""
        x.is_task_aborting() -> bool
        check if task is currently being aborted
        
        Returns:
            bool:
        """
        ...
    def finish_execute(self, success: bool) -> None:
        r"""
        x.finish_execute(success) -> None
        finishes task execution with Success or Fail result
        
        Args:
            success (bool):
        """
        ...
    def finish_abort(self) -> None:
        r"""
        x.finish_abort() -> None
        aborts task execution
        """
        ...

class AIHelperLibrary(BlueprintFunctionLibrary):
    r"""
    AIBlueprint Helper Library
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIBlueprintHelperLibrary.h
    
    """
    @classmethod
    def unlock_ai_resources_with_animation(cls, anim_instance: AnimInstance, unlock_movement: bool, unlock_ai_logic: bool) -> None:
        r"""
        X.unlock_ai_resources_with_animation(anim_instance, unlock_movement, unlock_ai_logic) -> None
        unlocks indicated AI resources of animated pawn. Will unlock only animation-locked resources
        
        Args:
            anim_instance (AnimInstance): 
            unlock_movement (bool): 
            unlock_ai_logic (bool):
        """
        ...
    @classmethod
    def spawn_ai_from_class(cls, world_context_object: Object, pawn_class: Class, behavior_tree: BehaviorTree, location: Vector, rotation: Rotator = [0.000000, 0.000000, 0.000000], no_collision_fail: bool = False, owner: Actor = None) -> Pawn:
        r"""
        X.spawn_ai_from_class(world_context_object, pawn_class, behavior_tree, location, rotation=[0.000000, 0.000000, 0.000000], no_collision_fail=False, owner=None) -> Pawn
        Spawns AI agent of a given class. The PawnClass needs to have AIController
        set for the function to spawn a controller as well.
        
        Args:
            world_context_object (Object): 
            pawn_class (type(Class)): 
            behavior_tree (BehaviorTree): if set, and the function has successfully spawned and AI controller, this BehaviorTree asset will be assigned to the AI controller, and run.
            location (Vector): 
            rotation (Rotator): 
            no_collision_fail (bool): 
            owner (Actor): lets you spawn the AI in a sublevel rather than in the persistent level (which is the default behavior).
        
        Returns:
            Pawn:
        """
        ...
    @classmethod
    def simple_move_to_location(cls, controller: Controller, goal: Vector) -> None:
        r"""
        X.simple_move_to_location(controller, goal) -> None
        Simple Move to Location
        
        Args:
            controller (Controller): 
            goal (Vector):
        """
        ...
    @classmethod
    def simple_move_to_actor(cls, controller: Controller, goal: Actor) -> None:
        r"""
        X.simple_move_to_actor(controller, goal) -> None
        Simple Move to Actor
        
        Args:
            controller (Controller): 
            goal (Actor):
        """
        ...
    @classmethod
    def send_ai_message(cls, target: Pawn, message: Name, message_source: Object, success: bool = True) -> None:
        r"""
        X.send_ai_message(target, message, message_source, success=True) -> None
        Send AIMessage
        
        Args:
            target (Pawn): 
            message (Name): 
            message_source (Object): 
            success (bool):
        """
        ...
    @classmethod
    def lock_ai_resources_with_animation(cls, anim_instance: AnimInstance, lock_movement: bool, lock_ai_logic: bool) -> None:
        r"""
        X.lock_ai_resources_with_animation(anim_instance, lock_movement, lock_ai_logic) -> None
        locks indicated AI resources of animated pawn
        
        Args:
            anim_instance (AnimInstance): 
            lock_movement (bool): 
            lock_ai_logic (bool):
        """
        ...
    @classmethod
    def is_valid_ai_rotation(cls, rotation: Rotator) -> bool:
        r"""
        X.is_valid_ai_rotation(rotation) -> bool
        Is Valid AIRotation
        
        Args:
            rotation (Rotator): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_ai_location(cls, location: Vector) -> bool:
        r"""
        X.is_valid_ai_location(location) -> bool
        Is Valid AILocation
        
        Args:
            location (Vector): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_ai_direction(cls, direction_vector: Vector) -> bool:
        r"""
        X.is_valid_ai_direction(direction_vector) -> bool
        Is Valid AIDirection
        
        Args:
            direction_vector (Vector): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_next_nav_link_index(cls, controller: Controller) -> int:
        r"""
        X.get_next_nav_link_index(controller) -> int32
        Return the path index of the next nav link for the current path of the given controller. Returns INDEX_NONE if no path or no incoming nav link.
        
        Args:
            controller (Controller): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_current_path_points(cls, controller: Controller) -> Array[Vector]:
        r"""
        X.get_current_path_points(controller) -> Array[Vector]
        Returns an array of navigation path points given controller is currently using.
        
        Args:
            controller (Controller): 
        
        Returns:
            Array[Vector]:
        """
        ...
    @classmethod
    def get_current_path_index(cls, controller: Controller) -> int:
        r"""
        X.get_current_path_index(controller) -> int32
        Return the path index the given controller is currently at. Returns INDEX_NONE if no path.
        
        Args:
            controller (Controller): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_current_path(cls, controller: Controller) -> NavigationPath:
        r"""
        X.get_current_path(controller) -> NavigationPath
        Returns a NEW UOBJECT that is a COPY of navigation path given controller is currently using.
            The result being a copy means you won't be able to influence agent's pathfollowing
            by manipulating received path.
            Please use GetCurrentPathPoints if you only need the array of path points.
        
        Args:
            controller (Controller): 
        
        Returns:
            NavigationPath:
        """
        ...
    @classmethod
    def get_blackboard(cls, target: Actor) -> BlackboardComponent:
        r"""
        X.get_blackboard(target) -> BlackboardComponent
        Get Blackboard
        
        Args:
            target (Actor): 
        
        Returns:
            BlackboardComponent:
        """
        ...
    @classmethod
    def get_ai_controller(cls, controlled_actor: Actor) -> AIController:
        r"""
        X.get_ai_controller(controlled_actor) -> AIController
        The way it works exactly is if the actor passed in is a pawn, then the function retrieves
            pawn's controller cast to AIController. Otherwise the function returns actor cast to AIController.
        
        Args:
            controlled_actor (Actor): 
        
        Returns:
            AIController:
        """
        ...

class DetourCrowdAIController(AIController):
    r"""
    Detour Crowd AIController
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: DetourCrowdAIController.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actions_comp`` (PawnActionsComponent):  [Read-Write]
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_strafe`` (bool):  [Read-Write] Is strafing allowed during movement?
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``attach_to_pawn`` (bool):  [Read-Write] If true, the controller location will match the possessed Pawn's location. If false, it will not be updated. Rotation will match ControlRotation in either case.
      Since a Controller's location is normally inaccessible, this is intended mainly for purposes of being able to attach
      an Actor that follows the possessed Pawn location, but that still has the full aim rotation (since a Pawn might
      update only some components of the rotation).
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``blackboard`` (BlackboardComponent):  [Read-Write] blackboard
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brain_component`` (BrainComponent):  [Read-Write] Component responsible for behaviors.
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_navigation_filter_class`` (type(Class)):  [Read-Write]
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_instigated_any_damage`` (InstigatedAnyDamageSignature):  [Read-Write] Called when the controller has instigated damage in any way
    - ``on_possessed_pawn_changed`` (OnPossessedPawnChanged):  [Read-Write] Called on both authorities and clients when the possessed pawn changes (either OldPawn or NewPawn might be nullptr)
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``path_following_component`` (PathFollowingComponent):  [Read-Only] Component used for moving along a path.
    - ``perception_component`` (AIPerceptionComponent):  [Read-Only]
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_state`` (PlayerState):  [Read-Write] PlayerState containing replicated information about the player using this controller (only exists for players, not NPCs).
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``receive_move_completed`` (AIMoveCompletedSignature):  [Read-Write] Blueprint notification that we've completed the current movement request
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``set_control_rotation_from_pawn_orientation`` (bool):  [Read-Write] Copy Pawn rotation to ControlRotation, if there is no focus point.
    - ``skip_extra_los_checks`` (bool):  [Read-Write] Skip extra line of sight traces to extremities of target being checked.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``start_ai_logic_on_possess`` (bool):  [Read-Write] By default AI's logic does not start when controlled Pawn is possessed. Setting this flag to true
          will make AI logic start when pawn is possessed
    - ``stop_ai_logic_on_unposses`` (bool):  [Read-Write] By default AI's logic gets stopped when controlled Pawn is unpossessed. Setting this flag to false
          will make AI logic persist past losing control over a pawn
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``wants_player_state`` (bool):  [Read-Write] Specifies if this AI wants its own PlayerState.
    """
    ...

class EnvQueryContext(Object):
    r"""
    Env Query Context
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryContext.h
    
    """
    ...

class EnvQueryContext_BlueprintBase(EnvQueryContext):
    r"""
    Env Query Context Blueprint Base
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryContext_BlueprintBase.h
    
    """
    def provide_single_location(self, querier_object: Object, querier_actor: Actor) -> Vector:
        r"""
        x.provide_single_location(querier_object, querier_actor) -> Vector
        Provide Single Location
        
        Args:
            querier_object (Object): 
            querier_actor (Actor): 
        
        Returns:
            Vector: 
        
            resulting_location (Vector):
        """
        ...
    def provide_single_actor(self, querier_object: Object, querier_actor: Actor) -> Actor:
        r"""
        x.provide_single_actor(querier_object, querier_actor) -> Actor
        Provide Single Actor
        
        Args:
            querier_object (Object): 
            querier_actor (Actor): 
        
        Returns:
            Actor: 
        
            resulting_actor (Actor):
        """
        ...
    def provide_locations_set(self, querier_object: Object, querier_actor: Actor) -> Array[Vector]:
        r"""
        x.provide_locations_set(querier_object, querier_actor) -> Array[Vector]
        Provide Locations Set
        
        Args:
            querier_object (Object): 
            querier_actor (Actor): 
        
        Returns:
            Array[Vector]: 
        
            resulting_location_set (Array[Vector]):
        """
        ...
    def provide_actors_set(self, querier_object: Object, querier_actor: Actor) -> Array[Actor]:
        r"""
        x.provide_actors_set(querier_object, querier_actor) -> Array[Actor]
        Provide Actors Set
        
        Args:
            querier_object (Object): 
            querier_actor (Actor): 
        
        Returns:
            Array[Actor]: 
        
            resulting_actors_set (Array[Actor]):
        """
        ...

class EnvQuery(DataAsset):
    r"""
    Env Query
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQuery.h
    
    """
    ...

class EnvQueryInstanceBlueprintWrapper(Object):
    r"""
    Env Query Instance Blueprint Wrapper
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryInstanceBlueprintWrapper.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``item_type`` (type(Class)):  [Read-Write]
    - ``on_query_finished_event`` (EQSQueryDoneSignature):  [Read-Write]
    - ``option_index`` (int32):  [Read-Write] index of query option, that generated items
    - ``query_id`` (int32):  [Read-Write]
    """
    @property
    def query_id(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def item_type(self) -> Class:
        r"""
        (type(Class)):  [Read-Only]
        """
        ...
    @property
    def option_index(self) -> int:
        r"""
        (int32):  [Read-Only] index of query option, that generated items
        """
        ...
    @property
    def on_query_finished_event(self) -> EQSQueryDoneSignature:
        r"""
        (EQSQueryDoneSignature):  [Read-Write]
        """
        ...
    @on_query_finished_event.setter
    def on_query_finished_event(self, value: EQSQueryDoneSignature) -> None:
        ...
    def set_named_param(self, param_name: Name, value: float) -> None:
        r"""
        x.set_named_param(param_name, value) -> None
        Set Named Param
        
        Args:
            param_name (Name): 
            value (float):
        """
        ...
    def get_results_as_locations(self) -> Array[Vector]:
        r"""
        x.get_results_as_locations() -> Array[Vector]
        DEPRECATED!  Use GetQueryResultsAsLocations instead.  Returns an array of locations generated by the query. If the query generated Actors the the array is filled with their locations.
        deprecated: GetQueryResultsAsLocations instead, which is more efficient itself and protects against very bad perf issues in some blueprints.
        
        Returns:
            Array[Vector]:
        """
        ...
    def get_results_as_actors(self) -> Array[Actor]:
        r"""
        x.get_results_as_actors() -> Array[Actor]
        DEPRECATED!  Use GetQueryResultsAsActors instead.  Returns an array filled with resulting actors. Note that it makes sense only if ItemType is a EnvQueryItemType_ActorBase-derived type.
        deprecated: Use GetQueryResultsAsActors instead, which is more efficient itself and protects against very bad perf issues in some blueprints.
        
        Returns:
            Array[Actor]:
        """
        ...
    def get_query_results_as_locations(self) -> Optional[Array[Vector]]:
        r"""
        x.get_query_results_as_locations() -> Array[Vector] or None
        Outputs an array of locations generated by the query. If the query generated Actors the the array is filled with their locations.  Returns false if there is no valid result.
        
        Returns:
            Array[Vector] or None: 
        
            result_locations (Array[Vector]):
        """
        ...
    def get_query_results_as_actors(self) -> Optional[Array[Actor]]:
        r"""
        x.get_query_results_as_actors() -> Array[Actor] or None
        Outputs an array filled with resulting actors.  Note that it makes sense only if ItemType is a EnvQueryItemType_ActorBase-derived type.  Returns false if there is no valid result.
        
        Returns:
            Array[Actor] or None: 
        
            result_actors (Array[Actor]):
        """
        ...
    def get_item_score(self, item_index: int) -> float:
        r"""
        x.get_item_score(item_index) -> float
        Get Item Score
        
        Args:
            item_index (int32): 
        
        Returns:
            float:
        """
        ...

class AISubsystem(Object):
    r"""
    A class representing a common interface and behavior for AI subsystems
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISubsystem.h
    
    """
    ...

class EnvQueryManager(AISubsystem):
    r"""
    Env Query Manager
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryManager.h
    
    """
    @classmethod
    def run_eqs_query(cls, world_context_object: Object, query_template: EnvQuery, querier: Object, run_mode: EnvQueryRunMode, wrapper_class: Class) -> EnvQueryInstanceBlueprintWrapper:
        r"""
        X.run_eqs_query(world_context_object, query_template, querier, run_mode, wrapper_class) -> EnvQueryInstanceBlueprintWrapper
        Run EQSQuery
        
        Args:
            world_context_object (Object): 
            query_template (EnvQuery): 
            querier (Object): 
            run_mode (EnvQueryRunMode): 
            wrapper_class (type(Class)): 
        
        Returns:
            EnvQueryInstanceBlueprintWrapper:
        """
        ...

class EQSRenderingComponent(DebugDrawComponent):
    r"""
    EQSRendering Component
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EQSRenderingComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class Pawn(Actor):
    r"""
    Pawn is the base class of all actors that can be possessed by players or AI.
    They are the physical representations of players and creatures in a level.
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Framework/Pawn/
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Pawn.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``ai_controller_class`` (type(Class)):  [Read-Write] Default class to use when pawn is controlled by AI.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_possess_ai`` (AutoPossessAI):  [Read-Write] Determines when the Pawn creates and is possessed by an AI Controller (on level start, when spawned, etc).
      Only possible if AIControllerClassRef is set, and ignored if AutoPossessPlayer is enabled.
      see: AutoPossessPlayer
    - ``auto_possess_player`` (AutoReceiveInput):  [Read-Write] Determines which PlayerController, if any, should automatically possess the pawn when the level starts or when the pawn is spawned.
      see: AutoPossessAI
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``base_eye_height`` (float):  [Read-Write] Base eye height above collision center.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_affect_navigation_generation`` (bool):  [Read-Write] If set to false (default) given pawn instance will never affect navigation generation (but components could).
      Setting it to true will result in using regular AActor's navigation relevancy
      calculation to check if this pawn instance should affect navigation generation.
      note: Use SetCanAffectNavigationGeneration() to change this value at runtime.
      note: Modifying this value at runtime will result in any navigation change only if runtime navigation generation is enabled.
      note: Override UpdateNavigationRelevance() to propagate the flag to the desired components.
      see: SetCanAffectNavigationGeneration(), UpdateNavigationRelevance()
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``last_hit_by`` (Controller):  [Read-Write] Controller of the last Actor that caused us damage.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_input_component_class`` (type(Class)):  [Read-Write] If set, then this InputComponent class will be used instead of the Input Settings' DefaultInputComponentClass
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_state`` (PlayerState):  [Read-Write] If Pawn is possessed by a player, points to its Player State.  Needed for network play as controllers are not replicated to clients.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``receive_controller_changed_delegate`` (PawnControllerChangedSignature):  [Read-Write] Event called after a pawn's controller has changed, on the server and owning client. This will happen at the same time as the delegate on GameInstance
    - ``receive_restarted_delegate`` (PawnRestartedSignature):  [Read-Write] Event called after a pawn has been restarted, usually by a possession change. This is called on the server for all pawns and the owning client for player pawns
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_controller_rotation_pitch`` (bool):  [Read-Write] If true, this Pawn's pitch will be updated to match the Controller's ControlRotation pitch, if controlled by a PlayerController.
    - ``use_controller_rotation_roll`` (bool):  [Read-Write] If true, this Pawn's roll will be updated to match the Controller's ControlRotation roll, if controlled by a PlayerController.
    - ``use_controller_rotation_yaw`` (bool):  [Read-Write] If true, this Pawn's yaw will be updated to match the Controller's ControlRotation yaw, if controlled by a PlayerController.
    """
    @property
    def use_controller_rotation_pitch(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this Pawn's pitch will be updated to match the Controller's ControlRotation pitch, if controlled by a PlayerController.
        """
        ...
    @use_controller_rotation_pitch.setter
    def use_controller_rotation_pitch(self, value: bool) -> None:
        ...
    @property
    def use_controller_rotation_yaw(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this Pawn's yaw will be updated to match the Controller's ControlRotation yaw, if controlled by a PlayerController.
        """
        ...
    @use_controller_rotation_yaw.setter
    def use_controller_rotation_yaw(self, value: bool) -> None:
        ...
    @property
    def use_controller_rotation_roll(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this Pawn's roll will be updated to match the Controller's ControlRotation roll, if controlled by a PlayerController.
        """
        ...
    @use_controller_rotation_roll.setter
    def use_controller_rotation_roll(self, value: bool) -> None:
        ...
    @property
    def can_affect_navigation_generation(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to false (default) given pawn instance will never affect navigation generation (but components could).
        Setting it to true will result in using regular AActor's navigation relevancy
        calculation to check if this pawn instance should affect navigation generation.
        note: Use SetCanAffectNavigationGeneration() to change this value at runtime.
        note: Modifying this value at runtime will result in any navigation change only if runtime navigation generation is enabled.
        note: Override UpdateNavigationRelevance() to propagate the flag to the desired components.
        see: SetCanAffectNavigationGeneration(), UpdateNavigationRelevance()
        """
        ...
    @property
    def base_eye_height(self) -> float:
        r"""
        (float):  [Read-Write] Base eye height above collision center.
        """
        ...
    @base_eye_height.setter
    def base_eye_height(self, value: float) -> None:
        ...
    @property
    def ai_controller_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Default class to use when pawn is controlled by AI.
        """
        ...
    @ai_controller_class.setter
    def ai_controller_class(self, value: Class) -> None:
        ...
    @property
    def controller_class(self) -> Class:
        r"""
        deprecated: 'controller_class' was renamed to 'ai_controller_class'.
        """
        ...
    @controller_class.setter
    def controller_class(self, value: Class) -> None:
        ...
    @property
    def player_state(self) -> PlayerState:
        r"""
        (PlayerState):  [Read-Only] If Pawn is possessed by a player, points to its Player State.  Needed for network play as controllers are not replicated to clients.
        """
        ...
    @property
    def player_replication_info(self) -> PlayerState:
        r"""
        deprecated: 'player_replication_info' was renamed to 'player_state'.
        """
        ...
    @property
    def last_hit_by(self) -> Controller:
        r"""
        (Controller):  [Read-Only] Controller of the last Actor that caused us damage.
        """
        ...
    @property
    def receive_controller_changed_delegate(self) -> PawnControllerChangedSignature:
        r"""
        (PawnControllerChangedSignature):  [Read-Write] Event called after a pawn's controller has changed, on the server and owning client. This will happen at the same time as the delegate on GameInstance
        """
        ...
    @receive_controller_changed_delegate.setter
    def receive_controller_changed_delegate(self, value: PawnControllerChangedSignature) -> None:
        ...
    @property
    def receive_restarted_delegate(self) -> PawnRestartedSignature:
        r"""
        (PawnRestartedSignature):  [Read-Write] Event called after a pawn has been restarted, usually by a possession change. This is called on the server for all pawns and the owning client for player pawns
        """
        ...
    @receive_restarted_delegate.setter
    def receive_restarted_delegate(self, value: PawnRestartedSignature) -> None:
        ...
    def spawn_default_controller(self) -> None:
        r"""
        x.spawn_default_controller() -> None
        Spawn default controller for this Pawn, and get possessed by it.
        """
        ...
    def set_can_affect_navigation_generation(self, new_value: bool, force_update: bool = False) -> None:
        r"""
        x.set_can_affect_navigation_generation(new_value, force_update=False) -> None
        Use SetCanAffectNavigationGeneration to change this value at runtime.
        Note that calling this function at runtime will result in any navigation change only if runtime navigation generation is enabled.
        
        Args:
            new_value (bool): 
            force_update (bool):
        """
        ...
    def receive_unpossessed(self, old_controller: Controller) -> None:
        r"""
        x.receive_unpossessed(old_controller) -> None
        Event called when the Pawn is no longer possessed by a Controller. Only called on the server (or in standalone)
        
        Args:
            old_controller (Controller):
        """
        ...
    def receive_restarted(self) -> None:
        r"""
        x.receive_restarted() -> None
        Event called after a pawn has been restarted, usually by a possession change. This is called on the server for all pawns and the owning client for player pawns
        """
        ...
    def receive_possessed(self, new_controller: Controller) -> None:
        r"""
        x.receive_possessed(new_controller) -> None
        Event called when the Pawn is possessed by a Controller. Only called on the server (or in standalone)
        
        Args:
            new_controller (Controller):
        """
        ...
    def receive_controller_changed(self, old_controller: Controller, new_controller: Controller) -> None:
        r"""
        x.receive_controller_changed(old_controller, new_controller) -> None
        Event called after a pawn's controller has changed, on the server and owning client. This will happen at the same time as the delegate on GameInstance
        
        Args:
            old_controller (Controller): 
            new_controller (Controller):
        """
        ...
    def pawn_make_noise(self, loudness: float, noise_location: Vector, use_noise_maker_location: bool = True, noise_maker: Actor = None) -> None:
        r"""
        x.pawn_make_noise(loudness, noise_location, use_noise_maker_location=True, noise_maker=None) -> None
        Inform AIControllers that you've made a noise they might hear (they are sent a HearNoise message if they have bHearNoises==true)
        The instigator of this sound is the pawn which is used to call MakeNoise.
        
        Args:
            loudness (float): is the relative loudness of this noise (range 0.0 to 1.0).  Directly affects the hearing range specified by the AI's HearingThreshold.
            noise_location (Vector): Position of noise source.  If zero vector, use the actor's location.
            use_noise_maker_location (bool): If true, use the location of the NoiseMaker rather than NoiseLocation.  If false, use NoiseLocation.
            noise_maker (Actor): Which actor is the source of the noise.  Not to be confused with the Noise Instigator, which is responsible for the noise (and is the pawn on which this function is called).  If not specified, the pawn instigating the noise will be used as the NoiseMaker
        """
        ...
    def is_player_controlled(self) -> bool:
        r"""
        x.is_player_controlled() -> bool
        Returns true if controlled by a human player (possessed by a PlayerController).        This returns true for players controlled by remote clients
        
        Returns:
            bool:
        """
        ...
    def is_pawn_controlled(self) -> bool:
        r"""
        x.is_pawn_controlled() -> bool
        Check if this actor is currently being controlled at all (the actor has a valid Controller, which will be false for remote clients)
        
        Returns:
            bool:
        """
        ...
    def is_move_input_ignored(self) -> bool:
        r"""
        x.is_move_input_ignored() -> bool
        Helper to see if move input is ignored. If our controller is a PlayerController, checks Controller->IsMoveInputIgnored().
        
        Returns:
            bool:
        """
        ...
    def is_locally_viewed(self) -> bool:
        r"""
        x.is_locally_viewed() -> bool
        Is this pawn the ViewTarget of a local PlayerController?  Helpful for determining whether the pawn is
        visible/critical for any VFX.  NOTE: Technically there may be some cases where locally controlled pawns return
        false for this, such as if you are using a remote camera view of some sort.  But generally it will be true for
        locally controlled pawns, and it will always be true for pawns that are being spectated in-game or in Replays.
        
        Returns:
            bool:
        """
        ...
    def is_locally_controlled(self) -> bool:
        r"""
        x.is_locally_controlled() -> bool
        Returns true if controlled by a local (not network) Controller.
        
        Returns:
            bool:
        """
        ...
    def is_controlled(self) -> bool:
        r"""
        x.is_controlled() -> bool
        Is Controlled
        
        Returns:
            bool:
        """
        ...
    def is_bot_controlled(self) -> bool:
        r"""
        x.is_bot_controlled() -> bool
        Returns true if controlled by a bot.
        
        Returns:
            bool:
        """
        ...
    def get_platform_user_id(self) -> PlatformUserId:
        r"""
        x.get_platform_user_id() -> PlatformUserId
        Returns the Platform User ID of the PlayerController that is controlling this character.
        
        Returns an invalid Platform User ID if this character is not controlled by a local player.
        
        Returns:
            PlatformUserId:
        """
        ...
    def get_pending_movement_input_vector(self) -> Vector:
        r"""
        x.get_pending_movement_input_vector() -> Vector
        Return the pending input vector in world space. This is the most up-to-date value of the input vector, pending ConsumeMovementInputVector() which clears it,
        Usually only a PawnMovementComponent will want to read this value, or the Pawn itself if it is responsible for movement.
        see: AddMovementInput(), GetLastMovementInputVector(), ConsumeMovementInputVector()
        
        Returns:
            Vector: The pending input vector in world space.
        """
        ...
    def get_override_input_component_class(self) -> Class:
        r"""
        x.get_override_input_component_class() -> type(Class)
        Get Override Input Component Class
        
        Returns:
            type(Class):
        """
        ...
    def get_nav_agent_location(self) -> Vector:
        r"""
        x.get_nav_agent_location() -> Vector
        Basically retrieved pawn's location on navmesh
        
        Returns:
            Vector:
        """
        ...
    def get_movement_component(self) -> PawnMovementComponent:
        r"""
        x.get_movement_component() -> PawnMovementComponent
        Return our PawnMovementComponent, if we have one.
        
        Returns:
            PawnMovementComponent:
        """
        ...
    @classmethod
    def get_movement_base_actor(cls, pawn: Pawn) -> Actor:
        r"""
        X.get_movement_base_actor(pawn) -> Actor
        Gets the owning actor of the Movement Base Component on which the pawn is standing.
        
        Args:
            pawn (Pawn): 
        
        Returns:
            Actor:
        """
        ...
    def get_local_viewing_player_controller(self) -> PlayerController:
        r"""
        x.get_local_viewing_player_controller() -> PlayerController
        Returns local Player Controller viewing this pawn, whether it is controlling or spectating
        
        Returns:
            PlayerController:
        """
        ...
    def get_last_movement_input_vector(self) -> Vector:
        r"""
        x.get_last_movement_input_vector() -> Vector
        Return the last input vector in world space that was processed by ConsumeMovementInputVector(), which is usually done by the Pawn or PawnMovementComponent.
        Any user that needs to know about the input that last affected movement should use this function.
        For example an animation update would want to use this, since by default the order of updates in a frame is:
        PlayerController (device input) -> MovementComponent -> Pawn -> Mesh (animations)
        see: AddMovementInput(), GetPendingMovementInputVector(), ConsumeMovementInputVector()
        
        Returns:
            Vector: The last input vector in world space that was processed by ConsumeMovementInputVector().
        """
        ...
    def get_control_rotation(self) -> Rotator:
        r"""
        x.get_control_rotation() -> Rotator
        Get the rotation of the Controller, often the 'view' rotation of this Pawn.
        
        Returns:
            Rotator:
        """
        ...
    def get_controller(self) -> Controller:
        r"""
        x.get_controller() -> Controller
        Returns controller for this actor.
        
        Returns:
            Controller:
        """
        ...
    def get_base_aim_rotation(self) -> Rotator:
        r"""
        x.get_base_aim_rotation() -> Rotator
        Return the aim rotation for the Pawn.
        If we have a controller, by default we aim at the player's 'eyes' direction
        that is by default the Pawn rotation for AI, and camera (crosshair) rotation for human players.
        
        Returns:
            Rotator:
        """
        ...
    def detach_from_controller_pending_destroy(self) -> None:
        r"""
        x.detach_from_controller_pending_destroy() -> None
        Call this function to detach safely pawn from its controller, knowing that we will be destroyed soon.
        """
        ...
    def consume_movement_input_vector(self) -> Vector:
        r"""
        x.consume_movement_input_vector() -> Vector
        Returns the pending input vector and resets it to zero.
        This should be used during a movement update (by the Pawn or PawnMovementComponent) to prevent accumulation of control input between frames.
        Copies the pending input vector to the saved input vector (GetLastMovementInputVector()).
        
        Returns:
            Vector: The pending input vector.
        """
        ...
    def add_movement_input(self, world_direction: Vector, scale_value: float = 1.000000, force: bool = False) -> None:
        r"""
        x.add_movement_input(world_direction, scale_value=1.000000, force=False) -> None
        Add movement input along the given world direction vector (usually normalized) scaled by 'ScaleValue'. If ScaleValue < 0, movement will be in the opposite direction.
        Base Pawn classes won't automatically apply movement, it's up to the user to do so in a Tick event. Subclasses such as Character and DefaultPawn automatically handle this input and move.
        see: GetPendingMovementInputVector(), GetLastMovementInputVector(), ConsumeMovementInputVector()
        
        Args:
            world_direction (Vector): Direction in world space to apply input
            scale_value (float): Scale to apply to input. This can be used for analog input, ie a value of 0.5 applies half the normal value, while -1.0 would reverse the direction.
            force (bool): If true always add the input, ignoring the result of IsMoveInputIgnored().
        """
        ...
    def add_controller_yaw_input(self, val: float) -> None:
        r"""
        x.add_controller_yaw_input(val) -> None
        Add input (affecting Yaw) to the Controller's ControlRotation, if it is a local PlayerController.
        This value is multiplied by the PlayerController's InputYawScale value.
        see: PlayerController::InputYawScale
        
        Args:
            val (float): Amount to add to Yaw. This value is multiplied by the PlayerController's InputYawScale value.
        """
        ...
    def add_turn_input(self, val: float) -> None:
        r"""
        deprecated: 'add_turn_input' was renamed to 'add_controller_yaw_input'.
        """
        ...
    def add_yaw_input(self, val: float) -> None:
        r"""
        deprecated: 'add_yaw_input' was renamed to 'add_controller_yaw_input'.
        """
        ...
    def add_controller_roll_input(self, val: float) -> None:
        r"""
        x.add_controller_roll_input(val) -> None
        Add input (affecting Roll) to the Controller's ControlRotation, if it is a local PlayerController.
        This value is multiplied by the PlayerController's InputRollScale value.
        see: PlayerController::InputRollScale
        
        Args:
            val (float): Amount to add to Roll. This value is multiplied by the PlayerController's InputRollScale value.
        """
        ...
    def add_roll_input(self, val: float) -> None:
        r"""
        deprecated: 'add_roll_input' was renamed to 'add_controller_roll_input'.
        """
        ...
    def add_controller_pitch_input(self, val: float) -> None:
        r"""
        x.add_controller_pitch_input(val) -> None
        Add input (affecting Pitch) to the Controller's ControlRotation, if it is a local PlayerController.
        This value is multiplied by the PlayerController's InputPitchScale value.
        see: PlayerController::InputPitchScale
        
        Args:
            val (float): Amount to add to Pitch. This value is multiplied by the PlayerController's InputPitchScale value.
        """
        ...
    def add_look_up_input(self, val: float) -> None:
        r"""
        deprecated: 'add_look_up_input' was renamed to 'add_controller_pitch_input'.
        """
        ...
    def add_pitch_input(self, val: float) -> None:
        r"""
        deprecated: 'add_pitch_input' was renamed to 'add_controller_pitch_input'.
        """
        ...

class Character(Pawn):
    r"""
    Characters are Pawns that have a mesh, collision, and built-in movement logic.
    They are responsible for all physical interaction between the player or AI and the world, and also implement basic networking and input models.
    They are designed for a vertically-oriented player representation that can walk, jump, fly, and swim through the world using CharacterMovementComponent.
    see: APawn, UCharacterMovementComponent
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Framework/Pawn/Character/
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Character.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``ai_controller_class`` (type(Class)):  [Read-Write] Default class to use when pawn is controlled by AI.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_possess_ai`` (AutoPossessAI):  [Read-Write] Determines when the Pawn creates and is possessed by an AI Controller (on level start, when spawned, etc).
      Only possible if AIControllerClassRef is set, and ignored if AutoPossessPlayer is enabled.
      see: AutoPossessPlayer
    - ``auto_possess_player`` (AutoReceiveInput):  [Read-Write] Determines which PlayerController, if any, should automatically possess the pawn when the level starts or when the pawn is spawned.
      see: AutoPossessAI
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``base_eye_height`` (float):  [Read-Write] Base eye height above collision center.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_affect_navigation_generation`` (bool):  [Read-Write] If set to false (default) given pawn instance will never affect navigation generation (but components could).
      Setting it to true will result in using regular AActor's navigation relevancy
      calculation to check if this pawn instance should affect navigation generation.
      note: Use SetCanAffectNavigationGeneration() to change this value at runtime.
      note: Modifying this value at runtime will result in any navigation change only if runtime navigation generation is enabled.
      note: Override UpdateNavigationRelevance() to propagate the flag to the desired components.
      see: SetCanAffectNavigationGeneration(), UpdateNavigationRelevance()
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``capsule_component`` (CapsuleComponent):  [Read-Only] The CapsuleComponent being used for movement collision (by CharacterMovement). Always treated as being vertically aligned in simple collision check functions.
    - ``character_movement`` (CharacterMovementComponent):  [Read-Only] Movement component used for movement logic in various movement modes (walking, falling, etc), containing relevant settings and functions to control movement.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``crouched_eye_height`` (float):  [Read-Write] Default crouched eye height
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_crouched`` (bool):  [Read-Write] Set by character movement to specify that this Character is currently crouched.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``jump_current_count`` (int32):  [Read-Only] Tracks the current number of jumps performed.
      This is incremented in CheckJumpInput, used in CanJump_Implementation, and reset in OnMovementModeChanged.
      When providing overrides for these methods, it's recommended to either manually
      increment / reset this value, or call the Super:: method.
    - ``jump_current_count_pre_jump`` (int32):  [Read-Only] Represents the current number of jumps performed before CheckJumpInput modifies JumpCurrentCount.
      This is set in CheckJumpInput and is used in SetMoveFor and PrepMoveFor instead of JumpCurrentCount
      since CheckJumpInput can modify JumpCurrentCount.
      When providing overrides for these methods, it's recommended to either manually
      set this value, or call the Super:: method.
    - ``jump_force_time_remaining`` (float):  [Read-Only] Amount of jump force time remaining, if JumpMaxHoldTime > 0.
    - ``jump_key_hold_time`` (float):  [Read-Only] Jump key Held Time.
      This is the time that the player has held the jump key, in seconds.
    - ``jump_max_count`` (int32):  [Read-Write] The max number of jumps the character can perform.
      Note that if JumpMaxHoldTime is non zero and StopJumping is not called, the player
      may be able to perform and unlimited number of jumps. Therefore it is usually
      best to call StopJumping() when jump input has ceased (such as a button up event).
    - ``jump_max_hold_time`` (float):  [Read-Write] The max time the jump key can be held.
      Note that if StopJumping() is not called before the max jump hold time is reached,
      then the character will carry on receiving vertical velocity. Therefore it is usually
      best to call StopJumping() when jump input has ceased (such as a button up event).
    - ``landed_delegate`` (LandedSignature):  [Read-Write] Called upon landing when falling, to perform actions based on the Hit result.
      Note that movement mode is still "Falling" during this event. Current Velocity value is the velocity at the time of landing.
      Consider OnMovementModeChanged() as well, as that can be used once the movement mode changes to the new mode (most likely Walking).
      see: OnMovementModeChanged()
    - ``last_hit_by`` (Controller):  [Read-Write] Controller of the last Actor that caused us damage.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``mesh`` (SkeletalMeshComponent):  [Read-Only] The main skeletal mesh associated with this Character (optional sub-object).
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``movement_mode_changed_delegate`` (MovementModeChangedSignature):  [Read-Write] Multicast delegate for MovementMode changing.
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_character_movement_updated`` (CharacterMovementUpdatedSignature):  [Read-Write] Event triggered at the end of a CharacterMovementComponent movement update.
      This is the preferred event to use rather than the Tick event when performing custom updates to CharacterMovement properties based on the current state.
      This is mainly due to the nature of network updates, where client corrections in position from the server can cause multiple iterations of a movement update,
      which allows this event to update as well, while a Tick event would not.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_reached_jump_apex`` (CharacterReachedApexSignature):  [Read-Write] Broadcast when Character's jump reaches its apex. Needs CharacterMovement->bNotifyApex = true
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_input_component_class`` (type(Class)):  [Read-Write] If set, then this InputComponent class will be used instead of the Input Settings' DefaultInputComponentClass
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_state`` (PlayerState):  [Read-Write] If Pawn is possessed by a player, points to its Player State.  Needed for network play as controllers are not replicated to clients.
    - ``pressed_jump`` (bool):  [Read-Write] When true, player wants to jump
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``proxy_jump_force_started_time`` (float):  [Read-Only] Track last time a jump force started for a proxy.
    - ``receive_controller_changed_delegate`` (PawnControllerChangedSignature):  [Read-Write] Event called after a pawn's controller has changed, on the server and owning client. This will happen at the same time as the delegate on GameInstance
    - ``receive_restarted_delegate`` (PawnRestartedSignature):  [Read-Write] Event called after a pawn has been restarted, usually by a possession change. This is called on the server for all pawns and the owning client for player pawns
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_controller_rotation_pitch`` (bool):  [Read-Write] If true, this Pawn's pitch will be updated to match the Controller's ControlRotation pitch, if controlled by a PlayerController.
    - ``use_controller_rotation_roll`` (bool):  [Read-Write] If true, this Pawn's roll will be updated to match the Controller's ControlRotation roll, if controlled by a PlayerController.
    - ``use_controller_rotation_yaw`` (bool):  [Read-Write] If true, this Pawn's yaw will be updated to match the Controller's ControlRotation yaw, if controlled by a PlayerController.
    - ``was_jumping`` (bool):  [Read-Only] Tracks whether or not the character was already jumping last frame.
    """
    @property
    def mesh(self) -> SkeletalMeshComponent:
        r"""
        (SkeletalMeshComponent):  [Read-Only] The main skeletal mesh associated with this Character (optional sub-object).
        """
        ...
    @property
    def character_movement(self) -> CharacterMovementComponent:
        r"""
        (CharacterMovementComponent):  [Read-Only] Movement component used for movement logic in various movement modes (walking, falling, etc), containing relevant settings and functions to control movement.
        """
        ...
    @property
    def capsule_component(self) -> CapsuleComponent:
        r"""
        (CapsuleComponent):  [Read-Only] The CapsuleComponent being used for movement collision (by CharacterMovement). Always treated as being vertically aligned in simple collision check functions.
        """
        ...
    @property
    def crouched_eye_height(self) -> float:
        r"""
        (float):  [Read-Write] Default crouched eye height
        """
        ...
    @crouched_eye_height.setter
    def crouched_eye_height(self, value: float) -> None:
        ...
    @property
    def is_crouched(self) -> bool:
        r"""
        (bool):  [Read-Only] Set by character movement to specify that this Character is currently crouched.
        """
        ...
    @property
    def pressed_jump(self) -> bool:
        r"""
        (bool):  [Read-Only] When true, player wants to jump
        """
        ...
    @property
    def was_jumping(self) -> bool:
        r"""
        (bool):  [Read-Only] Tracks whether or not the character was already jumping last frame.
        """
        ...
    @property
    def jump_key_hold_time(self) -> float:
        r"""
        (float):  [Read-Only] Jump key Held Time.
        This is the time that the player has held the jump key, in seconds.
        """
        ...
    @property
    def jump_force_time_remaining(self) -> float:
        r"""
        (float):  [Read-Only] Amount of jump force time remaining, if JumpMaxHoldTime > 0.
        """
        ...
    @property
    def proxy_jump_force_started_time(self) -> float:
        r"""
        (float):  [Read-Only] Track last time a jump force started for a proxy.
        """
        ...
    @property
    def jump_max_hold_time(self) -> float:
        r"""
        (float):  [Read-Write] The max time the jump key can be held.
        Note that if StopJumping() is not called before the max jump hold time is reached,
        then the character will carry on receiving vertical velocity. Therefore it is usually
        best to call StopJumping() when jump input has ceased (such as a button up event).
        """
        ...
    @jump_max_hold_time.setter
    def jump_max_hold_time(self, value: float) -> None:
        ...
    @property
    def jump_max_count(self) -> int:
        r"""
        (int32):  [Read-Write] The max number of jumps the character can perform.
        Note that if JumpMaxHoldTime is non zero and StopJumping is not called, the player
        may be able to perform and unlimited number of jumps. Therefore it is usually
        best to call StopJumping() when jump input has ceased (such as a button up event).
        """
        ...
    @jump_max_count.setter
    def jump_max_count(self, value: int) -> None:
        ...
    @property
    def jump_current_count(self) -> int:
        r"""
        (int32):  [Read-Only] Tracks the current number of jumps performed.
        This is incremented in CheckJumpInput, used in CanJump_Implementation, and reset in OnMovementModeChanged.
        When providing overrides for these methods, it's recommended to either manually
        increment / reset this value, or call the Super:: method.
        """
        ...
    @property
    def jump_current_count_pre_jump(self) -> int:
        r"""
        (int32):  [Read-Only] Represents the current number of jumps performed before CheckJumpInput modifies JumpCurrentCount.
        This is set in CheckJumpInput and is used in SetMoveFor and PrepMoveFor instead of JumpCurrentCount
        since CheckJumpInput can modify JumpCurrentCount.
        When providing overrides for these methods, it's recommended to either manually
        set this value, or call the Super:: method.
        """
        ...
    @property
    def on_reached_jump_apex(self) -> CharacterReachedApexSignature:
        r"""
        (CharacterReachedApexSignature):  [Read-Write] Broadcast when Character's jump reaches its apex. Needs CharacterMovement->bNotifyApex = true
        """
        ...
    @on_reached_jump_apex.setter
    def on_reached_jump_apex(self, value: CharacterReachedApexSignature) -> None:
        ...
    @property
    def landed_delegate(self) -> LandedSignature:
        r"""
        (LandedSignature):  [Read-Write] Called upon landing when falling, to perform actions based on the Hit result.
        Note that movement mode is still "Falling" during this event. Current Velocity value is the velocity at the time of landing.
        Consider OnMovementModeChanged() as well, as that can be used once the movement mode changes to the new mode (most likely Walking).
        see: OnMovementModeChanged()
        """
        ...
    @landed_delegate.setter
    def landed_delegate(self, value: LandedSignature) -> None:
        ...
    @property
    def movement_mode_changed_delegate(self) -> MovementModeChangedSignature:
        r"""
        (MovementModeChangedSignature):  [Read-Write] Multicast delegate for MovementMode changing.
        """
        ...
    @movement_mode_changed_delegate.setter
    def movement_mode_changed_delegate(self, value: MovementModeChangedSignature) -> None:
        ...
    @property
    def on_character_movement_updated(self) -> CharacterMovementUpdatedSignature:
        r"""
        (CharacterMovementUpdatedSignature):  [Read-Write] Event triggered at the end of a CharacterMovementComponent movement update.
        This is the preferred event to use rather than the Tick event when performing custom updates to CharacterMovement properties based on the current state.
        This is mainly due to the nature of network updates, where client corrections in position from the server can cause multiple iterations of a movement update,
        which allows this event to update as well, while a Tick event would not.
        """
        ...
    @on_character_movement_updated.setter
    def on_character_movement_updated(self, value: CharacterMovementUpdatedSignature) -> None:
        ...
    def un_crouch(self, client_simulation: bool = False) -> None:
        r"""
        x.un_crouch(client_simulation=False) -> None
        Request the character to stop crouching. The request is processed on the next update of the CharacterMovementComponent.
        see: OnEndCrouch
        see: IsCrouched
        see: CharacterMovement->WantsToCrouch
        
        Args:
            client_simulation (bool):
        """
        ...
    def stop_jumping(self) -> None:
        r"""
        x.stop_jumping() -> None
        Stop the character from jumping on the next update.
        Call this from an input event (such as a button 'up' event) to cease applying
        jump Z-velocity. If this is not called, then jump z-velocity will be applied
        until JumpMaxHoldTime is reached.
        """
        ...
    def stop_anim_montage(self, anim_montage: AnimMontage = None) -> None:
        r"""
        x.stop_anim_montage(anim_montage=None) -> None
        Stop Animation Montage. If nullptr, it will stop what's currently active. The Blend Out Time is taken from the montage asset that is being stopped. *
        
        Args:
            anim_montage (AnimMontage):
        """
        ...
    def play_anim_montage(self, anim_montage: AnimMontage, play_rate: float = 1.000000, start_section_name: Name = "None") -> float:
        r"""
        x.play_anim_montage(anim_montage, play_rate=1.000000, start_section_name="None") -> float
        Play Animation Montage on the character mesh. Returns the length of the animation montage in seconds, or 0.f if failed to play. *
        
        Args:
            anim_montage (AnimMontage): 
            play_rate (float): 
            start_section_name (Name): 
        
        Returns:
            float:
        """
        ...
    def on_walking_off_ledge(self, previous_floor_impact_normal: Vector, previous_floor_contact_normal: Vector, previous_location: Vector, time_delta: float) -> None:
        r"""
        x.on_walking_off_ledge(previous_floor_impact_normal, previous_floor_contact_normal, previous_location, time_delta) -> None
        Event fired when the Character is walking off a surface and is about to fall because CharacterMovement->CurrentFloor became unwalkable.
        If CharacterMovement->MovementMode does not change during this event then the character will automatically start falling afterwards.
        note: Z velocity is zero during walking movement, and will be here as well. Another velocity can be computed here if desired and will be used when starting to fall.
        
        Args:
            previous_floor_impact_normal (Vector): Normal of the previous walkable floor.
            previous_floor_contact_normal (Vector): Normal of the contact with the previous walkable floor.
            previous_location (Vector): Previous character location before movement off the ledge.
            time_delta (float):
        """
        ...
    def on_launched(self, launch_velocity: Vector, xy_override: bool, z_override: bool) -> None:
        r"""
        x.on_launched(launch_velocity, xy_override, z_override) -> None
        Let blueprint know that we were launched
        
        Args:
            launch_velocity (Vector): 
            xy_override (bool): 
            z_override (bool):
        """
        ...
    def on_landed(self, hit: HitResult) -> None:
        r"""
        x.on_landed(hit) -> None
        Called upon landing when falling, to perform actions based on the Hit result.
        Note that movement mode is still "Falling" during this event. Current Velocity value is the velocity at the time of landing.
        Consider OnMovementModeChanged() as well, as that can be used once the movement mode changes to the new mode (most likely Walking).
        see: OnMovementModeChanged()
        
        Args:
            hit (HitResult): Result describing the landing that resulted in a valid landing spot.
        """
        ...
    def on_jumped(self) -> None:
        r"""
        x.on_jumped() -> None
        Event fired when the character has just started jumping
        """
        ...
    def launch_character(self, launch_velocity: Vector, xy_override: bool, z_override: bool) -> None:
        r"""
        x.launch_character(launch_velocity, xy_override, z_override) -> None
        Set a pending launch velocity on the Character. This velocity will be processed on the next CharacterMovementComponent tick,
        and will set it to the "falling" state. Triggers the OnLaunched event.
        
        Args:
            launch_velocity (Vector): is the velocity to impart to the Character
            xy_override (bool): if true replace the XY part of the Character's velocity instead of adding to it.
            z_override (bool): if true replace the Z component of the Character's velocity instead of adding to it.
        """
        ...
    def launch(self, launch_velocity: Vector, xy_override: bool, z_override: bool) -> None:
        r"""
        deprecated: 'launch' was renamed to 'launch_character'.
        """
        ...
    def update_custom_movement(self, delta_time: float) -> None:
        r"""
        x.update_custom_movement(delta_time) -> None
        Event for implementing custom character movement mode. Called by CharacterMovement if MovementMode is set to Custom.
        note: C++ code should override UCharacterMovementComponent::PhysCustom() instead.
        see: UCharacterMovementComponent::PhysCustom()
        
        Args:
            delta_time (float):
        """
        ...
    def on_start_crouch(self, half_height_adjust: float, scaled_half_height_adjust: float) -> None:
        r"""
        x.on_start_crouch(half_height_adjust, scaled_half_height_adjust) -> None
        Event when Character crouches.
        
        Args:
            half_height_adjust (float): difference between default collision half-height, and actual crouched capsule half-height.
            scaled_half_height_adjust (float): difference after component scale is taken in to account.
        """
        ...
    def on_movement_mode_changed(self, prev_movement_mode: MovementMode, new_movement_mode: MovementMode, prev_custom_mode: int, new_custom_mode: int) -> None:
        r"""
        x.on_movement_mode_changed(prev_movement_mode, new_movement_mode, prev_custom_mode, new_custom_mode) -> None
        Called from CharacterMovementComponent to notify the character that the movement mode has changed.
        
        Args:
            prev_movement_mode (MovementMode): Movement mode before the change
            new_movement_mode (MovementMode): New movement mode
            prev_custom_mode (uint8): Custom mode before the change (applicable if PrevMovementMode is Custom)
            new_custom_mode (uint8): New custom mode (applicable if NewMovementMode is Custom)
        """
        ...
    def on_end_crouch(self, half_height_adjust: float, scaled_half_height_adjust: float) -> None:
        r"""
        x.on_end_crouch(half_height_adjust, scaled_half_height_adjust) -> None
        Event when Character stops crouching.
        
        Args:
            half_height_adjust (float): difference between default collision half-height, and actual crouched capsule half-height.
            scaled_half_height_adjust (float): difference after component scale is taken in to account.
        """
        ...
    def jump(self) -> None:
        r"""
        x.jump() -> None
        Make the character jump on the next update.
        If you want your character to jump according to the time that the jump key is held,
        then you can set JumpMaxHoldTime to some non-zero value. Make sure in this case to
        call StopJumping() when you want the jump's z-velocity to stop being applied (such
        as on a button up event), otherwise the character will carry on receiving the
        velocity until JumpKeyHoldTime reaches JumpMaxHoldTime.
        """
        ...
    def is_playing_root_motion(self) -> bool:
        r"""
        x.is_playing_root_motion() -> bool
        True if we are playing Anim root motion right now
        
        Returns:
            bool:
        """
        ...
    def is_playing_networked_root_motion_montage(self) -> bool:
        r"""
        x.is_playing_networked_root_motion_montage() -> bool
        True if we are playing Root Motion right now, through a Montage with RootMotionMode == ERootMotionMode::RootMotionFromMontagesOnly.
        This means code path for networked root motion is enabled.
        
        Returns:
            bool:
        """
        ...
    def is_jump_providing_force(self) -> bool:
        r"""
        x.is_jump_providing_force() -> bool
        True if jump is actively providing a force, such as when the jump key is held and the time it has been held is less than JumpMaxHoldTime.
        see: CharacterMovement->IsFalling
        
        Returns:
            bool:
        """
        ...
    def is_jumping(self) -> bool:
        r"""
        deprecated: 'is_jumping' was renamed to 'is_jump_providing_force'.
        """
        ...
    def has_any_root_motion(self) -> bool:
        r"""
        x.has_any_root_motion() -> bool
        True if we are playing root motion from any source right now (anim root motion, root motion source)
        
        Returns:
            bool:
        """
        ...
    def get_current_montage(self) -> AnimMontage:
        r"""
        x.get_current_montage() -> AnimMontage
        Return current playing Montage *
        
        Returns:
            AnimMontage:
        """
        ...
    def get_base_translation_offset(self) -> Vector:
        r"""
        x.get_base_translation_offset() -> Vector
        Get the saved translation offset of mesh. This is how much extra offset is applied from the center of the capsule.
        
        Returns:
            Vector:
        """
        ...
    def get_base_rotation_offset(self) -> Rotator:
        r"""
        x.get_base_rotation_offset() -> Rotator
        Get the saved rotation offset of mesh. This is how much extra rotation is applied from the capsule rotation.
        
        Returns:
            Rotator:
        """
        ...
    def get_anim_root_motion_translation_scale(self) -> float:
        r"""
        x.get_anim_root_motion_translation_scale() -> float
        Returns current value of AnimRootMotionScale
        
        Returns:
            float:
        """
        ...
    def crouch(self, client_simulation: bool = False) -> None:
        r"""
        x.crouch(client_simulation=False) -> None
        Request the character to start crouching. The request is processed on the next update of the CharacterMovementComponent.
        see: OnStartCrouch
        see: IsCrouched
        see: CharacterMovement->WantsToCrouch
        
        Args:
            client_simulation (bool):
        """
        ...
    def can_jump_internal(self) -> bool:
        r"""
        x.can_jump_internal() -> bool
        Customizable event to check if the character can jump in the current state.
        Default implementation returns true if the character is on the ground and not crouching,
        has a valid CharacterMovementComponent and CanEverJump() returns true.
        Default implementation also allows for 'hold to jump higher' functionality:
        As well as returning true when on the ground, it also returns true when GetMaxJumpTime is more
        than zero and IsJumping returns true.
        
        Returns:
            bool: Whether the character can jump in the current state.
        """
        ...
    def can_jump(self) -> bool:
        r"""
        x.can_jump() -> bool
        Check if the character can jump in the current state.
        
        The default implementation may be overridden or extended by implementing the custom CanJump event in Blueprints.
        
        Returns:
            bool: Whether the character can jump in the current state.
        """
        ...
    def can_crouch(self) -> bool:
        r"""
        x.can_crouch() -> bool
        
        
        Returns:
            bool: true if this character is currently able to crouch (and is not currently crouched)
        """
        ...
    def cache_initial_mesh_offset(self, mesh_relative_location: Vector, mesh_relative_rotation: Rotator) -> None:
        r"""
        x.cache_initial_mesh_offset(mesh_relative_location, mesh_relative_rotation) -> None
        Cache mesh offset from capsule. This is used as the target for network smoothing interpolation, when the mesh is offset with lagged smoothing.
        This is automatically called during initialization; call this at runtime if you intend to change the default mesh offset from the capsule.
        see: GetBaseTranslationOffset(), GetBaseRotationOffset()
        
        Args:
            mesh_relative_location (Vector): 
            mesh_relative_rotation (Rotator):
        """
        ...

class EQSTestingPawn(Character):
    r"""
    EQSTesting Pawn
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EQSTestingPawn.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``ai_controller_class`` (type(Class)):  [Read-Write] Default class to use when pawn is controlled by AI.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_possess_ai`` (AutoPossessAI):  [Read-Write] Determines when the Pawn creates and is possessed by an AI Controller (on level start, when spawned, etc).
      Only possible if AIControllerClassRef is set, and ignored if AutoPossessPlayer is enabled.
      see: AutoPossessPlayer
    - ``auto_possess_player`` (AutoReceiveInput):  [Read-Write] Determines which PlayerController, if any, should automatically possess the pawn when the level starts or when the pawn is spawned.
      see: AutoPossessAI
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``base_eye_height`` (float):  [Read-Write] Base eye height above collision center.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_affect_navigation_generation`` (bool):  [Read-Write] If set to false (default) given pawn instance will never affect navigation generation (but components could).
      Setting it to true will result in using regular AActor's navigation relevancy
      calculation to check if this pawn instance should affect navigation generation.
      note: Use SetCanAffectNavigationGeneration() to change this value at runtime.
      note: Modifying this value at runtime will result in any navigation change only if runtime navigation generation is enabled.
      note: Override UpdateNavigationRelevance() to propagate the flag to the desired components.
      see: SetCanAffectNavigationGeneration(), UpdateNavigationRelevance()
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``capsule_component`` (CapsuleComponent):  [Read-Only] The CapsuleComponent being used for movement collision (by CharacterMovement). Always treated as being vertically aligned in simple collision check functions.
    - ``character_movement`` (CharacterMovementComponent):  [Read-Only] Movement component used for movement logic in various movement modes (walking, falling, etc), containing relevant settings and functions to control movement.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``crouched_eye_height`` (float):  [Read-Write] Default crouched eye height
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``draw_failed_items`` (bool):  [Read-Write]
    - ``draw_labels`` (bool):  [Read-Write]
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``highlight_mode`` (EnvQueryHightlightMode):  [Read-Write]
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_crouched`` (bool):  [Read-Write] Set by character movement to specify that this Character is currently crouched.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``jump_current_count`` (int32):  [Read-Only] Tracks the current number of jumps performed.
      This is incremented in CheckJumpInput, used in CanJump_Implementation, and reset in OnMovementModeChanged.
      When providing overrides for these methods, it's recommended to either manually
      increment / reset this value, or call the Super:: method.
    - ``jump_current_count_pre_jump`` (int32):  [Read-Only] Represents the current number of jumps performed before CheckJumpInput modifies JumpCurrentCount.
      This is set in CheckJumpInput and is used in SetMoveFor and PrepMoveFor instead of JumpCurrentCount
      since CheckJumpInput can modify JumpCurrentCount.
      When providing overrides for these methods, it's recommended to either manually
      set this value, or call the Super:: method.
    - ``jump_force_time_remaining`` (float):  [Read-Only] Amount of jump force time remaining, if JumpMaxHoldTime > 0.
    - ``jump_key_hold_time`` (float):  [Read-Only] Jump key Held Time.
      This is the time that the player has held the jump key, in seconds.
    - ``jump_max_count`` (int32):  [Read-Write] The max number of jumps the character can perform.
      Note that if JumpMaxHoldTime is non zero and StopJumping is not called, the player
      may be able to perform and unlimited number of jumps. Therefore it is usually
      best to call StopJumping() when jump input has ceased (such as a button up event).
    - ``jump_max_hold_time`` (float):  [Read-Write] The max time the jump key can be held.
      Note that if StopJumping() is not called before the max jump hold time is reached,
      then the character will carry on receiving vertical velocity. Therefore it is usually
      best to call StopJumping() when jump input has ceased (such as a button up event).
    - ``landed_delegate`` (LandedSignature):  [Read-Write] Called upon landing when falling, to perform actions based on the Hit result.
      Note that movement mode is still "Falling" during this event. Current Velocity value is the velocity at the time of landing.
      Consider OnMovementModeChanged() as well, as that can be used once the movement mode changes to the new mode (most likely Walking).
      see: OnMovementModeChanged()
    - ``last_hit_by`` (Controller):  [Read-Write] Controller of the last Actor that caused us damage.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``mesh`` (SkeletalMeshComponent):  [Read-Only] The main skeletal mesh associated with this Character (optional sub-object).
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``movement_mode_changed_delegate`` (MovementModeChangedSignature):  [Read-Write] Multicast delegate for MovementMode changing.
    - ``nav_agent_properties`` (NavAgentProperties):  [Read-Write]
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_character_movement_updated`` (CharacterMovementUpdatedSignature):  [Read-Write] Event triggered at the end of a CharacterMovementComponent movement update.
      This is the preferred event to use rather than the Tick event when performing custom updates to CharacterMovement properties based on the current state.
      This is mainly due to the nature of network updates, where client corrections in position from the server can cause multiple iterations of a movement update,
      which allows this event to update as well, while a Tick event would not.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_reached_jump_apex`` (CharacterReachedApexSignature):  [Read-Write] Broadcast when Character's jump reaches its apex. Needs CharacterMovement->bNotifyApex = true
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_input_component_class`` (type(Class)):  [Read-Write] If set, then this InputComponent class will be used instead of the Input Settings' DefaultInputComponentClass
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_state`` (PlayerState):  [Read-Write] If Pawn is possessed by a player, points to its Player State.  Needed for network play as controllers are not replicated to clients.
    - ``pressed_jump`` (bool):  [Read-Write] When true, player wants to jump
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``proxy_jump_force_started_time`` (float):  [Read-Only] Track last time a jump force started for a proxy.
    - ``query_config`` (Array[AIDynamicParam]):  [Read-Write]
    - ``query_template`` (EnvQuery):  [Read-Write]
    - ``querying_mode`` (EnvQueryRunMode):  [Read-Write]
    - ``re_run_query_only_on_finished_move`` (bool):  [Read-Write]
    - ``receive_controller_changed_delegate`` (PawnControllerChangedSignature):  [Read-Write] Event called after a pawn's controller has changed, on the server and owning client. This will happen at the same time as the delegate on GameInstance
    - ``receive_restarted_delegate`` (PawnRestartedSignature):  [Read-Write] Event called after a pawn has been restarted, usually by a possession change. This is called on the server for all pawns and the owning client for player pawns
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``should_be_visible_in_game`` (bool):  [Read-Write]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``step_to_debug_draw`` (int32):  [Read-Write]
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``tick_during_game`` (bool):  [Read-Write]
    - ``time_limit_per_step`` (float):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_controller_rotation_pitch`` (bool):  [Read-Write] If true, this Pawn's pitch will be updated to match the Controller's ControlRotation pitch, if controlled by a PlayerController.
    - ``use_controller_rotation_roll`` (bool):  [Read-Write] If true, this Pawn's roll will be updated to match the Controller's ControlRotation roll, if controlled by a PlayerController.
    - ``use_controller_rotation_yaw`` (bool):  [Read-Write] If true, this Pawn's yaw will be updated to match the Controller's ControlRotation yaw, if controlled by a PlayerController.
    - ``was_jumping`` (bool):  [Read-Only] Tracks whether or not the character was already jumping last frame.
    """
    ...

class EnvQueryNode(Object):
    r"""
    Env Query Node
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryNode.h
    
    """
    ...

class EnvQueryGenerator(EnvQueryNode):
    r"""
    Env Query Generator
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryGenerator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_sort_tests`` (bool):  [Read-Write] if set, tests will be automatically sorted for best performance before running query
    - ``option_name`` (str):  [Read-Write]
    """
    ...

class EnvQueryGenerator_BlueprintBase(EnvQueryGenerator):
    r"""
    Env Query Generator Blueprint Base
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: EnvQueryGenerator_BlueprintBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_sort_tests`` (bool):  [Read-Write] if set, tests will be automatically sorted for best performance before running query
    - ``context`` (type(Class)):  [Read-Write] context
    - ``generated_item_type`` (type(Class)):  [Read-Write]
      todo: this should show up only in the generator's BP, but due to the way EQS editor is generating widgets it's there as well It's a bug and we'll fix it
    - ``generators_action_description`` (Text):  [Read-Write] A short description of what test does, like "Generate pawn named Joe"
    - ``option_name`` (str):  [Read-Write]
    """
    def get_querier(self) -> Object:
        r"""
        x.get_querier() -> Object
        Get Querier
        
        Returns:
            Object:
        """
        ...
    def do_item_generation_from_actors(self, context_actors: Array[Actor]) -> None:
        r"""
        x.do_item_generation_from_actors(context_actors) -> None
        Do Item Generation from Actors
        
        Args:
            context_actors (Array[Actor]):
        """
        ...
    def do_item_generation(self, context_locations: Array[Vector]) -> None:
        r"""
        x.do_item_generation(context_locations) -> None
        Do Item Generation
        
        Args:
            context_locations (Array[Vector]):
        """
        ...
    def add_generated_vector(self, generated_vector: Vector) -> None:
        r"""
        x.add_generated_vector(generated_vector) -> None
        Add Generated Vector
        
        Args:
            generated_vector (Vector):
        """
        ...
    def add_generated_actor(self, generated_actor: Actor) -> None:
        r"""
        x.add_generated_actor(generated_actor) -> None
        Add Generated Actor
        
        Args:
            generated_actor (Actor):
        """
        ...

class GridPathAIController(AIController):
    r"""
    Grid Path AIController
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: GridPathAIController.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actions_comp`` (PawnActionsComponent):  [Read-Write]
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_strafe`` (bool):  [Read-Write] Is strafing allowed during movement?
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``attach_to_pawn`` (bool):  [Read-Write] If true, the controller location will match the possessed Pawn's location. If false, it will not be updated. Rotation will match ControlRotation in either case.
      Since a Controller's location is normally inaccessible, this is intended mainly for purposes of being able to attach
      an Actor that follows the possessed Pawn location, but that still has the full aim rotation (since a Pawn might
      update only some components of the rotation).
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``blackboard`` (BlackboardComponent):  [Read-Write] blackboard
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brain_component`` (BrainComponent):  [Read-Write] Component responsible for behaviors.
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_navigation_filter_class`` (type(Class)):  [Read-Write]
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_instigated_any_damage`` (InstigatedAnyDamageSignature):  [Read-Write] Called when the controller has instigated damage in any way
    - ``on_possessed_pawn_changed`` (OnPossessedPawnChanged):  [Read-Write] Called on both authorities and clients when the possessed pawn changes (either OldPawn or NewPawn might be nullptr)
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``path_following_component`` (PathFollowingComponent):  [Read-Only] Component used for moving along a path.
    - ``perception_component`` (AIPerceptionComponent):  [Read-Only]
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_state`` (PlayerState):  [Read-Write] PlayerState containing replicated information about the player using this controller (only exists for players, not NPCs).
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``receive_move_completed`` (AIMoveCompletedSignature):  [Read-Write] Blueprint notification that we've completed the current movement request
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``set_control_rotation_from_pawn_orientation`` (bool):  [Read-Write] Copy Pawn rotation to ControlRotation, if there is no focus point.
    - ``skip_extra_los_checks`` (bool):  [Read-Write] Skip extra line of sight traces to extremities of target being checked.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``start_ai_logic_on_possess`` (bool):  [Read-Write] By default AI's logic does not start when controlled Pawn is possessed. Setting this flag to true
          will make AI logic start when pawn is possessed
    - ``stop_ai_logic_on_unposses`` (bool):  [Read-Write] By default AI's logic gets stopped when controlled Pawn is unpossessed. Setting this flag to false
          will make AI logic persist past losing control over a pawn
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``wants_player_state`` (bool):  [Read-Write] Specifies if this AI wants its own PlayerState.
    """
    ...

class PathFollowingComponent(ActorComponent):
    r"""
    Path Following Component
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PathFollowingComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    def get_path_destination(self) -> Vector:
        r"""
        x.get_path_destination() -> Vector
        Get Path Destination
        deprecated: This function is now deprecated, please use AIController.GetImmediateMoveDestination instead
        
        Returns:
            Vector:
        """
        ...
    def get_path_action_type(self) -> PathFollowingAction:
        r"""
        x.get_path_action_type() -> PathFollowingAction
        Get Path Action Type
        deprecated: This function is now deprecated, please use AIController.GetMoveStatus instead
        
        Returns:
            PathFollowingAction:
        """
        ...

class CrowdFollowingComponent(PathFollowingComponent):
    r"""
    Crowd Following Component
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: CrowdFollowingComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    def suspend_crowd_steering(self, suspend: bool) -> None:
        r"""
        x.suspend_crowd_steering(suspend) -> None
        main switch for crowd steering & avoidance
        
        Args:
            suspend (bool):
        """
        ...

class GridPathFollowingComponent(PathFollowingComponent):
    r"""
    Path following augmented with local navigation grids
    
    Keeps track of nearby grids and use them instead of navigation path when agent is inside.
    Once outside grid, regular path following is resumed.
    
    This allows creating dynamic navigation obstacles with fully static navigation (e.g. static navmesh),
    as long as they are minor modifications for path. Not recommended for blocking off entire corridors.
    
    Does not replace proper avoidance for dynamic obstacles!
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: GridPathFollowingComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class NavigationQueryFilter(Object):
    r"""
    Class containing definition of a navigation query filter
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationQueryFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``areas`` (Array[NavigationFilterArea]):  [Read-Write] list of overrides for navigation areas
    - ``exclude_flags`` (NavigationFilterFlags):  [Read-Write] forbidden flags of navigation nodes
    - ``include_flags`` (NavigationFilterFlags):  [Read-Write] required flags of navigation nodes
    """
    ...

class NavFilter_AIControllerDefault(NavigationQueryFilter):
    r"""
    Nav Filter AIController Default
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: NavFilter_AIControllerDefault.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``areas`` (Array[NavigationFilterArea]):  [Read-Write] list of overrides for navigation areas
    - ``exclude_flags`` (NavigationFilterFlags):  [Read-Write] forbidden flags of navigation nodes
    - ``include_flags`` (NavigationFilterFlags):  [Read-Write] required flags of navigation nodes
    """
    ...

class NavLinkProxy(Actor):
    r"""
    ANavLinkProxy connects areas of Navmesh that don't have a direct navigation path.
    It directly supports Simple Links (see PointLinks array). There can be multiple Simple links per ANavLinkProxy instance.
    Simple links are designed to statically link areas of Navmesh and are associated with a particular area class that the link provides.
    Smart Link functionality is provided via UNavLinkCustomComponent, see SmartLinkComp. They are designed to be able to be dynamically toggled
    between enabled and disabled and provide different area classes for both cases. The area classes can be dynamically modified
    without navmesh rebuilds.
    There can only be at most one smart link per ANavLinkProxy instance.
    Both simple and smart links on a single ANavLinkProxy instance, can be set / enabled at once, as well as either or neither of them.
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: NavLinkProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_smart_link_reached`` (SmartLinkReachedSignature):  [Read-Write]
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``point_links`` (Array[NavigationLink]):  [Read-Write] Navigation links (point to point) added to navigation data
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``smart_link_comp`` (NavLinkCustomComponent):  [Read-Only] Smart link: can affect path following
    - ``smart_link_is_relevant`` (bool):  [Read-Write] Smart link: toggle relevancy
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def point_links(self) -> Array[NavigationLink]:
        r"""
        (Array[NavigationLink]):  [Read-Only] Navigation links (point to point) added to navigation data
        """
        ...
    @property
    def nav_links(self) -> Array[NavigationLink]:
        r"""
        deprecated: 'nav_links' was renamed to 'point_links'.
        """
        ...
    @property
    def on_smart_link_reached(self) -> SmartLinkReachedSignature:
        r"""
        (SmartLinkReachedSignature):  [Read-Write]
        """
        ...
    @on_smart_link_reached.setter
    def on_smart_link_reached(self, value: SmartLinkReachedSignature) -> None:
        ...
    def set_smart_link_enabled(self, enabled: bool) -> None:
        r"""
        x.set_smart_link_enabled(enabled) -> None
        change state of smart link
        
        Args:
            enabled (bool):
        """
        ...
    def resume_path_following(self, agent: Actor) -> None:
        r"""
        x.resume_path_following(agent) -> None
        resume normal path following
        
        Args:
            agent (Actor):
        """
        ...
    def receive_smart_link_reached(self, agent: Actor, destination: Vector) -> None:
        r"""
        x.receive_smart_link_reached(agent, destination) -> None
        called when agent reaches smart link during path following, use ResumePathFollowing() to give control back
        
        Args:
            agent (Actor): 
            destination (Vector):
        """
        ...
    def is_smart_link_enabled(self) -> bool:
        r"""
        x.is_smart_link_enabled() -> bool
        check if smart link is enabled
        
        Returns:
            bool:
        """
        ...
    def has_moving_agents(self) -> bool:
        r"""
        x.has_moving_agents() -> bool
        check if any agent is moving through smart link right now
        
        Returns:
            bool:
        """
        ...

class NavLocalGridManager(Object):
    r"""
    Manager for local navigation grids
    
    Builds non overlapping grid from multiple sources, that can be used later for pathfinding.
    Check also: UGridPathFollowingComponent, FNavLocalGridData
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: NavLocalGridManager.h
    
    """
    @classmethod
    def set_local_navigation_grid_density(cls, world_context_object: Object, cell_size: float) -> bool:
        r"""
        X.set_local_navigation_grid_density(world_context_object, cell_size) -> bool
        Set Local Navigation Grid Density
        
        Args:
            world_context_object (Object): 
            cell_size (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def remove_local_navigation_grid(cls, world_context_object: Object, grid_id: int, rebuild_grids: bool = True) -> None:
        r"""
        X.remove_local_navigation_grid(world_context_object, grid_id, rebuild_grids=True) -> None
        Remove Local Navigation Grid
        
        Args:
            world_context_object (Object): 
            grid_id (int32): 
            rebuild_grids (bool):
        """
        ...
    @classmethod
    def find_local_navigation_grid_path(cls, world_context_object: Object, start: Vector, end: Vector) -> Optional[Array[Vector]]:
        r"""
        X.find_local_navigation_grid_path(world_context_object, start, end) -> Array[Vector] or None
        Find Local Navigation Grid Path
        
        Args:
            world_context_object (Object): 
            start (Vector): 
            end (Vector): 
        
        Returns:
            Array[Vector] or None: 
        
            path_points (Array[Vector]):
        """
        ...
    @classmethod
    def add_local_navigation_grid_for_points(cls, world_context_object: Object, locations: Array[Vector], radius2d: int = 5, height: float = 100.000000, rebuild_grids: bool = True) -> int:
        r"""
        X.add_local_navigation_grid_for_points(world_context_object, locations, radius2d=5, height=100.000000, rebuild_grids=True) -> int32
        creates single grid data for set of points
        
        Args:
            world_context_object (Object): 
            locations (Array[Vector]): 
            radius2d (int32): 
            height (float): 
            rebuild_grids (bool): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def add_local_navigation_grid_for_point(cls, world_context_object: Object, location: Vector, radius2d: int = 5, height: float = 100.000000, rebuild_grids: bool = True) -> int:
        r"""
        X.add_local_navigation_grid_for_point(world_context_object, location, radius2d=5, height=100.000000, rebuild_grids=True) -> int32
        creates new grid data for single point
        
        Args:
            world_context_object (Object): 
            location (Vector): 
            radius2d (int32): 
            height (float): 
            rebuild_grids (bool): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def add_local_navigation_grid_for_capsule(cls, world_context_object: Object, location: Vector, capsule_radius: float, capsule_half_height: float, radius2d: int = 5, height: float = 100.000000, rebuild_grids: bool = True) -> int:
        r"""
        X.add_local_navigation_grid_for_capsule(world_context_object, location, capsule_radius, capsule_half_height, radius2d=5, height=100.000000, rebuild_grids=True) -> int32
        Add Local Navigation Grid for Capsule
        
        Args:
            world_context_object (Object): 
            location (Vector): 
            capsule_radius (float): 
            capsule_half_height (float): 
            radius2d (int32): 
            height (float): 
            rebuild_grids (bool): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def add_local_navigation_grid_for_box(cls, world_context_object: Object, location: Vector, extent: Vector = [1.000000, 1.000000, 1.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], radius2d: int = 5, height: float = 100.000000, rebuild_grids: bool = True) -> int:
        r"""
        X.add_local_navigation_grid_for_box(world_context_object, location, extent=[1.000000, 1.000000, 1.000000], rotation=[0.000000, 0.000000, 0.000000], radius2d=5, height=100.000000, rebuild_grids=True) -> int32
        Add Local Navigation Grid for Box
        
        Args:
            world_context_object (Object): 
            location (Vector): 
            extent (Vector): 
            rotation (Rotator): 
            radius2d (int32): 
            height (float): 
            rebuild_grids (bool): 
        
        Returns:
            int32:
        """
        ...

class AIPerceptionComponent(ActorComponent):
    r"""
    AIPerceptionComponent is used to register as stimuli listener in AIPerceptionSystem
    and gathers registered stimuli. UpdatePerception is called when component gets new stimuli (batched)
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``dominant_sense`` (type(Class)):  [Read-Write] Indicated sense that takes precedence over other senses when determining sensed actor's location.
          Should be set to one of the senses configured in SensesConfig, or None.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_perception_updated`` (PerceptionUpdatedDelegate):  [Read-Write] Might want to move these to special "BP_AIPerceptionComponent"
    - ``on_target_perception_forgotten`` (ActorPerceptionForgetUpdatedDelegate):  [Read-Write] Notifies all bound delegates that the perception info has been forgotten for a given target.
      The notification get broadcast when all stimuli of a given target expire. Note that this
      functionality requires the the actor forgetting must be enabled via AIPerceptionSystem.bForgetStaleActors.
    - ``on_target_perception_info_updated`` (ActorPerceptionInfoUpdatedDelegate):  [Read-Write] Notifies all bound objects that perception info has been updated for a given target.
      The notification is broadcast for any received stimulus or on change of state
      according to the stimulus configuration.
      
      Note - This delegate will be called even if source actor is no longer valid
      by the time a stimulus gets processed so it is better to use source id for bookkeeping.
    - ``on_target_perception_updated`` (ActorPerceptionUpdatedDelegate):  [Read-Write] Notifies all bound objects that perception info has been updated for a given target.
      The notification is broadcast for any received stimulus or on change of state
      according to the stimulus configuration.
      
      Note - This delegate will not be called if source actor is no longer valid
      by the time a stimulus gets processed.
      Use OnTargetPerceptionInfoUpdated providing a source id to handle those cases.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``senses_config`` (Array[AISenseConfig]):  [Read-Write]
    """
    @property
    def on_perception_updated(self) -> PerceptionUpdatedDelegate:
        r"""
        (PerceptionUpdatedDelegate):  [Read-Write] Might want to move these to special "BP_AIPerceptionComponent"
        """
        ...
    @on_perception_updated.setter
    def on_perception_updated(self, value: PerceptionUpdatedDelegate) -> None:
        ...
    @property
    def on_target_perception_forgotten(self) -> ActorPerceptionForgetUpdatedDelegate:
        r"""
        (ActorPerceptionForgetUpdatedDelegate):  [Read-Write] Notifies all bound delegates that the perception info has been forgotten for a given target.
        The notification get broadcast when all stimuli of a given target expire. Note that this
        functionality requires the the actor forgetting must be enabled via AIPerceptionSystem.bForgetStaleActors.
        """
        ...
    @on_target_perception_forgotten.setter
    def on_target_perception_forgotten(self, value: ActorPerceptionForgetUpdatedDelegate) -> None:
        ...
    @property
    def on_target_perception_updated(self) -> ActorPerceptionUpdatedDelegate:
        r"""
        (ActorPerceptionUpdatedDelegate):  [Read-Write] Notifies all bound objects that perception info has been updated for a given target.
        The notification is broadcast for any received stimulus or on change of state
        according to the stimulus configuration.
        
        Note - This delegate will not be called if source actor is no longer valid
        by the time a stimulus gets processed.
        Use OnTargetPerceptionInfoUpdated providing a source id to handle those cases.
        """
        ...
    @on_target_perception_updated.setter
    def on_target_perception_updated(self, value: ActorPerceptionUpdatedDelegate) -> None:
        ...
    @property
    def on_target_perception_info_updated(self) -> ActorPerceptionInfoUpdatedDelegate:
        r"""
        (ActorPerceptionInfoUpdatedDelegate):  [Read-Write] Notifies all bound objects that perception info has been updated for a given target.
        The notification is broadcast for any received stimulus or on change of state
        according to the stimulus configuration.
        
        Note - This delegate will be called even if source actor is no longer valid
        by the time a stimulus gets processed so it is better to use source id for bookkeeping.
        """
        ...
    @on_target_perception_info_updated.setter
    def on_target_perception_info_updated(self, value: ActorPerceptionInfoUpdatedDelegate) -> None:
        ...
    def set_sense_enabled(self, sense_class: Class, enable: bool) -> None:
        r"""
        x.set_sense_enabled(sense_class, enable) -> None
        Note that this works only if given sense has been already configured for
            this component instance
        
        Args:
            sense_class (type(Class)): 
            enable (bool):
        """
        ...
    def request_stimuli_listener_update(self) -> None:
        r"""
        x.request_stimuli_listener_update() -> None
        Notifies AIPerceptionSystem to update properties for this "stimuli listener"
        """
        ...
    def is_sense_enabled(self, sense_class: Class) -> bool:
        r"""
        x.is_sense_enabled(sense_class) -> bool
        Returns if a sense is active. Note that this works only if given sense has been
             already configured for this component instance
        
        Args:
            sense_class (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    def get_perceived_hostile_actors_by_sense(self, sense_to_use: Class) -> Array[Actor]:
        r"""
        x.get_perceived_hostile_actors_by_sense(sense_to_use) -> Array[Actor]
        Get Perceived Hostile Actors by Sense
        
        Args:
            sense_to_use (type(Class)): 
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]):
        """
        ...
    def get_perceived_hostile_actors(self) -> Array[Actor]:
        r"""
        x.get_perceived_hostile_actors() -> Array[Actor]
        blueprint interface
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]):
        """
        ...
    def get_known_perceived_actors(self, sense_to_use: Class) -> Array[Actor]:
        r"""
        x.get_known_perceived_actors(sense_to_use) -> Array[Actor]
        If SenseToUse is none all actors ever perceived in any way (and not forgotten yet) will get fetched
        
        Args:
            sense_to_use (type(Class)): 
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]):
        """
        ...
    def get_currently_perceived_actors(self, sense_to_use: Class) -> Array[Actor]:
        r"""
        x.get_currently_perceived_actors(sense_to_use) -> Array[Actor]
        If SenseToUse is none all actors currently perceived in any way will get fetched
        
        Args:
            sense_to_use (type(Class)): 
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]):
        """
        ...
    def get_actors_perception(self, actor: Actor) -> Optional[ActorPerceptionBlueprintInfo]:
        r"""
        x.get_actors_perception(actor) -> ActorPerceptionBlueprintInfo or None
        Retrieves whatever has been sensed about given actor
        
        Args:
            actor (Actor): 
        
        Returns:
            ActorPerceptionBlueprintInfo or None: 
        
            info (ActorPerceptionBlueprintInfo):
        """
        ...
    def forget_all(self) -> None:
        r"""
        x.forget_all() -> None
        basically cleans up PerceptualData, resulting in loss of all previous perception
        """
        ...

class AIPerceptionStimuliSourceComponent(ActorComponent):
    r"""
    Gives owning actor a way to auto-register as perception system's sense stimuli source
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionStimuliSourceComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_register_as_source`` (bool):  [Read-Write]
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``register_as_source_for_senses`` (Array[type(Class)]):  [Read-Write]
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def auto_register_as_source(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def register_as_source_for_senses(self) -> Array[Class]:
        r"""
        (Array[type(Class)]):  [Read-Only]
        """
        ...
    def unregister_from_sense(self, sense_class: Class) -> None:
        r"""
        x.unregister_from_sense(sense_class) -> None
        Unregisters owning actor from sources list of a specified sense class
        
        Args:
            sense_class (type(Class)):
        """
        ...
    def unregister_from_perception_system(self) -> None:
        r"""
        x.unregister_from_perception_system() -> None
        Unregister owning actor from being a source of sense stimuli
        """
        ...
    def register_with_perception_system(self) -> None:
        r"""
        x.register_with_perception_system() -> None
        Registers owning actor as source of stimuli for senses specified in RegisterAsSourceForSenses.
            Note that you don't have to do it if bAutoRegisterAsSource == true
        """
        ...
    def register_for_sense(self, sense_class: Class) -> None:
        r"""
        x.register_for_sense(sense_class) -> None
        Registers owning actor as source for specified sense class
        
        Args:
            sense_class (type(Class)):
        """
        ...

class AIPerceptionSystem(AISubsystem):
    r"""
    By design checks perception between hostile teams
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AIPerceptionSystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``perception_aging_rate`` (float):  [Read-Write]
    """
    @classmethod
    def report_perception_event(cls, world_context_object: Object, perception_event: AISenseEvent) -> None:
        r"""
        X.report_perception_event(world_context_object, perception_event) -> None
        Report Perception Event
        
        Args:
            world_context_object (Object): 
            perception_event (AISenseEvent):
        """
        ...
    def report_event(self, perception_event: AISenseEvent) -> None:
        r"""
        x.report_event(perception_event) -> None
        Report Event
        
        Args:
            perception_event (AISenseEvent):
        """
        ...
    @classmethod
    def register_perception_stimuli_source(cls, world_context_object: Object, sense: Class, target: Actor) -> bool:
        r"""
        X.register_perception_stimuli_source(world_context_object, sense, target) -> bool
        Register Perception Stimuli Source
        
        Args:
            world_context_object (Object): 
            sense (type(Class)): 
            target (Actor): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_sense_class_for_stimulus(cls, world_context_object: Object, stimulus: AIStimulus) -> Class:
        r"""
        X.get_sense_class_for_stimulus(world_context_object, stimulus) -> type(Class)
        Get Sense Class for Stimulus
        
        Args:
            world_context_object (Object): 
            stimulus (AIStimulus): 
        
        Returns:
            type(Class):
        """
        ...

class AISense(Object):
    r"""
    AISense
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISense.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_register_all_pawns_as_sources`` (bool):  [Read-Write] If true all newly spawned pawns will get auto registered as source for this sense.
    - ``notify_type`` (AISenseNotifyType):  [Read-Write]
    - ``wants_new_pawn_notification`` (bool):  [Read-Write] whether this sense is interested in getting notified about new Pawns being spawned
          this can be used for example for automated sense sources registration
    """
    @property
    def notify_type(self) -> AISenseNotifyType:
        r"""
        (AISenseNotifyType):  [Read-Only]
        """
        ...
    @property
    def wants_new_pawn_notification(self) -> bool:
        r"""
        (bool):  [Read-Only] whether this sense is interested in getting notified about new Pawns being spawned
            this can be used for example for automated sense sources registration
        """
        ...
    @property
    def auto_register_all_pawns_as_sources(self) -> bool:
        r"""
        (bool):  [Read-Only] If true all newly spawned pawns will get auto registered as source for this sense.
        """
        ...

class AISenseConfig_Damage(AISenseConfig):
    r"""
    AISense Config Damage
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISenseConfig_Damage.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_color`` (Color):  [Read-Write]
    - ``implementation`` (type(Class)):  [Read-Write]
    - ``max_age`` (float):  [Read-Write] specifies age limit after stimuli generated by this sense become forgotten. 0 means "never"
    - ``starts_enabled`` (bool):  [Read-Write] determines whether given sense starts in an enabled state
    """
    @property
    def implementation(self) -> Class:
        r"""
        (type(Class)):  [Read-Only]
        """
        ...

class AISense_Blueprint(AISense):
    r"""
    AISense Blueprint
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISense_Blueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_register_all_pawns_as_sources`` (bool):  [Read-Write] If true all newly spawned pawns will get auto registered as source for this sense.
    - ``listener_container`` (Array[AIPerceptionComponent]):  [Read-Write]
    - ``listener_data_type`` (type(Class)):  [Read-Write]
    - ``notify_type`` (AISenseNotifyType):  [Read-Write]
    - ``wants_new_pawn_notification`` (bool):  [Read-Write] whether this sense is interested in getting notified about new Pawns being spawned
          this can be used for example for automated sense sources registration
    """
    @property
    def listener_data_type(self) -> Class:
        r"""
        (type(Class)):  [Read-Write]
        """
        ...
    @listener_data_type.setter
    def listener_data_type(self, value: Class) -> None:
        ...
    @property
    def listener_container(self) -> Array[AIPerceptionComponent]:
        r"""
        (Array[AIPerceptionComponent]):  [Read-Only]
        """
        ...
    def on_update(self, events_to_process: Array[AISenseEvent]) -> float:
        r"""
        x.on_update(events_to_process) -> float
        returns requested amount of time to pass until next frame.
            Return 0 to get update every frame (WARNING: hits performance)
        
        Args:
            events_to_process (Array[AISenseEvent]): 
        
        Returns:
            float:
        """
        ...
    def on_listener_updated(self, actor_listener: Actor, perception_component: AIPerceptionComponent) -> None:
        r"""
        x.on_listener_updated(actor_listener, perception_component) -> None
        
        
        Args:
            actor_listener (Actor): 
            perception_component (AIPerceptionComponent): is ActorListener's AIPerceptionComponent instance
        """
        ...
    def on_listener_unregistered(self, actor_listener: Actor, perception_component: AIPerceptionComponent) -> None:
        r"""
        x.on_listener_unregistered(actor_listener, perception_component) -> None
        called when a listener unregistered from this sense. Most often this is called due to actor's death
        
        Args:
            actor_listener (Actor): 
            perception_component (AIPerceptionComponent): is ActorListener's AIPerceptionComponent instance
        """
        ...
    def on_listener_registered(self, actor_listener: Actor, perception_component: AIPerceptionComponent) -> None:
        r"""
        x.on_listener_registered(actor_listener, perception_component) -> None
        
        
        Args:
            actor_listener (Actor): 
            perception_component (AIPerceptionComponent): is ActorListener's AIPerceptionComponent instance
        """
        ...
    def on_new_pawn(self, new_pawn: Pawn) -> None:
        r"""
        x.on_new_pawn(new_pawn) -> None
        called when sense's instance gets notified about new pawn that has just been spawned
        
        Args:
            new_pawn (Pawn):
        """
        ...
    def get_all_listener_components(self) -> Array[AIPerceptionComponent]:
        r"""
        x.get_all_listener_components() -> Array[AIPerceptionComponent]
        Get All Listener Components
        
        Returns:
            Array[AIPerceptionComponent]: 
        
            listener_components (Array[AIPerceptionComponent]):
        """
        ...
    def get_all_listener_actors(self) -> Array[Actor]:
        r"""
        x.get_all_listener_actors() -> Array[Actor]
        Get All Listener Actors
        
        Returns:
            Array[Actor]: 
        
            listener_actors (Array[Actor]):
        """
        ...

class AISense_Damage(AISense):
    r"""
    AISense Damage
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISense_Damage.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_register_all_pawns_as_sources`` (bool):  [Read-Write] If true all newly spawned pawns will get auto registered as source for this sense.
    - ``notify_type`` (AISenseNotifyType):  [Read-Write]
    - ``wants_new_pawn_notification`` (bool):  [Read-Write] whether this sense is interested in getting notified about new Pawns being spawned
          this can be used for example for automated sense sources registration
    """
    @classmethod
    def report_damage_event(cls, world_context_object: Object, damaged_actor: Actor, instigator: Actor, damage_amount: float, event_location: Vector, hit_location: Vector, tag: Name = "None") -> None:
        r"""
        X.report_damage_event(world_context_object, damaged_actor, instigator, damage_amount, event_location, hit_location, tag="None") -> None
        EventLocation will be reported as Instigator's location at the moment of event happening
        
        Args:
            world_context_object (Object): 
            damaged_actor (Actor): 
            instigator (Actor): 
            damage_amount (float): 
            event_location (Vector): 
            hit_location (Vector): 
            tag (Name):
        """
        ...

class AISense_Hearing(AISense):
    r"""
    AISense Hearing
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISense_Hearing.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_register_all_pawns_as_sources`` (bool):  [Read-Write] If true all newly spawned pawns will get auto registered as source for this sense.
    - ``notify_type`` (AISenseNotifyType):  [Read-Write]
    - ``wants_new_pawn_notification`` (bool):  [Read-Write] whether this sense is interested in getting notified about new Pawns being spawned
          this can be used for example for automated sense sources registration
    """
    @classmethod
    def report_noise_event(cls, world_context_object: Object, noise_location: Vector, loudness: float = 1.000000, instigator: Actor = None, max_range: float = 0.000000, tag: Name = "None") -> None:
        r"""
        X.report_noise_event(world_context_object, noise_location, loudness=1.000000, instigator=None, max_range=0.000000, tag="None") -> None
        Report a noise event.
        
        Args:
            world_context_object (Object): 
            noise_location (Vector): Location of the noise.
            loudness (float): Loudness of the noise. If MaxRange is non-zero, modifies MaxRange, otherwise modifies the squared distance of the sensor's range.
            instigator (Actor): Actor that triggered the noise.
            max_range (float): Max range at which the sound can be heard, multiplied by Loudness. Values <= 0 mean no limit (still limited by listener's range however).
            tag (Name): Identifier for the event.
        """
        ...

class AISense_Prediction(AISense):
    r"""
    AISense Prediction
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISense_Prediction.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_register_all_pawns_as_sources`` (bool):  [Read-Write] If true all newly spawned pawns will get auto registered as source for this sense.
    - ``notify_type`` (AISenseNotifyType):  [Read-Write]
    - ``wants_new_pawn_notification`` (bool):  [Read-Write] whether this sense is interested in getting notified about new Pawns being spawned
          this can be used for example for automated sense sources registration
    """
    @classmethod
    def request_pawn_prediction_event(cls, requestor: Pawn, predicted_actor: Actor, prediction_time: float) -> None:
        r"""
        X.request_pawn_prediction_event(requestor, predicted_actor, prediction_time) -> None
        Asks perception system to supply Requestor with PredictedActor's predicted location in PredictionTime seconds
            Location is being predicted based on PredicterActor's current location and velocity
        
        Args:
            requestor (Pawn): 
            predicted_actor (Actor): 
            prediction_time (float):
        """
        ...
    @classmethod
    def request_controller_prediction_event(cls, requestor: AIController, predicted_actor: Actor, prediction_time: float) -> None:
        r"""
        X.request_controller_prediction_event(requestor, predicted_actor, prediction_time) -> None
        Asks perception system to supply Requestor with PredictedActor's predicted location in PredictionTime seconds
            Location is being predicted based on PredicterActor's current location and velocity
        
        Args:
            requestor (AIController): 
            predicted_actor (Actor): 
            prediction_time (float):
        """
        ...

class AISense_Sight(AISense):
    r"""
    AISense Sight
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISense_Sight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_register_all_pawns_as_sources`` (bool):  [Read-Write] If true all newly spawned pawns will get auto registered as source for this sense.
    - ``high_importance_query_distance_threshold`` (float):  [Read-Write]
    - ``max_async_traces_per_tick`` (int32):  [Read-Write] Maximum number of asynchronous traces that can be requested in a single update call
    - ``max_query_importance`` (float):  [Read-Write]
    - ``max_time_slice_per_tick`` (double):  [Read-Write]
    - ``max_traces_per_tick`` (int32):  [Read-Write]
    - ``min_queries_per_time_slice_check`` (int32):  [Read-Write]
    - ``notify_type`` (AISenseNotifyType):  [Read-Write]
    - ``pending_queries_budget_reduction_ratio`` (float):  [Read-Write] Defines the amount of async trace queries to prevent based on the number of pending queries at the start of an update.
      1 means that the async trace budget is slashed by the pending queries count
      0 means that the async trace budget is not impacted by the pending queries
    - ``sight_limit_query_importance`` (float):  [Read-Write]
    - ``use_asynchronous_trace_for_default_sight_queries`` (bool):  [Read-Write] Defines if we are allowed to use asynchronous trace queries when there is no IAISightTargetInterface for a Target
    - ``wants_new_pawn_notification`` (bool):  [Read-Write] whether this sense is interested in getting notified about new Pawns being spawned
          this can be used for example for automated sense sources registration
    """
    ...

class AISense_Team(AISense):
    r"""
    AISense Team
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISense_Team.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_register_all_pawns_as_sources`` (bool):  [Read-Write] If true all newly spawned pawns will get auto registered as source for this sense.
    - ``notify_type`` (AISenseNotifyType):  [Read-Write]
    - ``wants_new_pawn_notification`` (bool):  [Read-Write] whether this sense is interested in getting notified about new Pawns being spawned
          this can be used for example for automated sense sources registration
    """
    ...

class AISense_Touch(AISense):
    r"""
    AISense Touch
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AISense_Touch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_register_all_pawns_as_sources`` (bool):  [Read-Write] If true all newly spawned pawns will get auto registered as source for this sense.
    - ``notify_type`` (AISenseNotifyType):  [Read-Write]
    - ``wants_new_pawn_notification`` (bool):  [Read-Write] whether this sense is interested in getting notified about new Pawns being spawned
          this can be used for example for automated sense sources registration
    """
    @classmethod
    def report_touch_event(cls, world_context_object: Object, touch_receiver: Actor, other_actor: Actor, location: Vector) -> None:
        r"""
        X.report_touch_event(world_context_object, touch_receiver, other_actor, location) -> None
        Report Touch Event
        
        Args:
            world_context_object (Object): 
            touch_receiver (Actor): 
            other_actor (Actor): 
            location (Vector):
        """
        ...

class PawnSensingComponent(ActorComponent):
    r"""
    SensingComponent encapsulates sensory (ie sight and hearing) settings and functionality for an Actor,
    allowing the actor to see/hear Pawns in the world. It does nothing on network clients.
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: PawnSensingComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_sensing_updates`` (bool):  [Read-Write] If true, component will perform sensing updates. At runtime change this using SetSensingUpdatesEnabled().
    - ``hear_noises`` (bool):  [Read-Write] If true, we will perform audibility tests and will be notified when a Pawn makes a noise that can be heard. Default: true
      IMPORTANT NOTE: If we can see pawns (bSeePawns is true), and the pawn is visible, noise notifications are not triggered.
    - ``hearing_max_sound_age`` (float):  [Read-Write] Max age of sounds we can hear. Should be greater than SensingInterval, or you might miss hearing some sounds!
    - ``hearing_threshold`` (float):  [Read-Write] Max distance at which a makenoise(1.0) loudness sound can be heard, regardless of occlusion
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``los_hearing_threshold`` (float):  [Read-Write] Max distance at which a makenoise(1.0) loudness sound can be heard if unoccluded (LOSHearingThreshold should be > HearingThreshold)
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_hear_noise`` (HearNoiseDelegate):  [Read-Write] Delegate to execute when we hear a noise from a Pawn's PawnNoiseEmitterComponent.
    - ``on_see_pawn`` (SeePawnDelegate):  [Read-Write] Delegate to execute when we see a Pawn.
    - ``only_sense_players`` (bool):  [Read-Write] If true, will only sense player-controlled pawns in the world. Default: true
    - ``peripheral_vision_angle`` (float):  [Read-Write] How far to the side AI can see, in degrees. Use SetPeripheralVisionAngle to change the value at runtime.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``see_pawns`` (bool):  [Read-Write] If true, we will perform visibility tests and will trigger notifications when a Pawn is visible. Default: true
    - ``sensing_interval`` (float):  [Read-Write] Amount of time between pawn sensing updates. Use SetSensingInterval() to adjust this at runtime. A value <= 0 prevents any updates.
    - ``sight_radius`` (float):  [Read-Write] Maximum sight distance.
    """
    @property
    def hearing_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Max distance at which a makenoise(1.0) loudness sound can be heard, regardless of occlusion
        """
        ...
    @hearing_threshold.setter
    def hearing_threshold(self, value: float) -> None:
        ...
    @property
    def los_hearing_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Max distance at which a makenoise(1.0) loudness sound can be heard if unoccluded (LOSHearingThreshold should be > HearingThreshold)
        """
        ...
    @los_hearing_threshold.setter
    def los_hearing_threshold(self, value: float) -> None:
        ...
    @property
    def sight_radius(self) -> float:
        r"""
        (float):  [Read-Write] Maximum sight distance.
        """
        ...
    @sight_radius.setter
    def sight_radius(self, value: float) -> None:
        ...
    @property
    def sensing_interval(self) -> float:
        r"""
        (float):  [Read-Only] Amount of time between pawn sensing updates. Use SetSensingInterval() to adjust this at runtime. A value <= 0 prevents any updates.
        """
        ...
    @property
    def sight_counter_interval(self) -> float:
        r"""
        deprecated: 'sight_counter_interval' was renamed to 'sensing_interval'.
        """
        ...
    @property
    def hearing_max_sound_age(self) -> float:
        r"""
        (float):  [Read-Write] Max age of sounds we can hear. Should be greater than SensingInterval, or you might miss hearing some sounds!
        """
        ...
    @hearing_max_sound_age.setter
    def hearing_max_sound_age(self, value: float) -> None:
        ...
    @property
    def enable_sensing_updates(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, component will perform sensing updates. At runtime change this using SetSensingUpdatesEnabled().
        """
        ...
    @property
    def only_sense_players(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, will only sense player-controlled pawns in the world. Default: true
        """
        ...
    @only_sense_players.setter
    def only_sense_players(self, value: bool) -> None:
        ...
    @property
    def see_pawns(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, we will perform visibility tests and will trigger notifications when a Pawn is visible. Default: true
        """
        ...
    @see_pawns.setter
    def see_pawns(self, value: bool) -> None:
        ...
    @property
    def b_wants_see_player_notify(self) -> bool:
        r"""
        deprecated: 'b_wants_see_player_notify' was renamed to 'see_pawns'.
        """
        ...
    @b_wants_see_player_notify.setter
    def b_wants_see_player_notify(self, value: bool) -> None:
        ...
    @property
    def hear_noises(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, we will perform audibility tests and will be notified when a Pawn makes a noise that can be heard. Default: true
        IMPORTANT NOTE: If we can see pawns (bSeePawns is true), and the pawn is visible, noise notifications are not triggered.
        """
        ...
    @hear_noises.setter
    def hear_noises(self, value: bool) -> None:
        ...
    @property
    def on_see_pawn(self) -> SeePawnDelegate:
        r"""
        (SeePawnDelegate):  [Read-Write] Delegate to execute when we see a Pawn.
        """
        ...
    @on_see_pawn.setter
    def on_see_pawn(self, value: SeePawnDelegate) -> None:
        ...
    @property
    def on_hear_noise(self) -> HearNoiseDelegate:
        r"""
        (HearNoiseDelegate):  [Read-Write] Delegate to execute when we hear a noise from a Pawn's PawnNoiseEmitterComponent.
        """
        ...
    @on_hear_noise.setter
    def on_hear_noise(self, value: HearNoiseDelegate) -> None:
        ...
    @property
    def peripheral_vision_angle(self) -> float:
        r"""
        (float):  [Read-Only] How far to the side AI can see, in degrees. Use SetPeripheralVisionAngle to change the value at runtime.
        """
        ...
    def set_sensing_updates_enabled(self, enabled: bool) -> None:
        r"""
        x.set_sensing_updates_enabled(enabled) -> None
        Enables or disables sensing updates. The timer is reset in either case.
        
        Args:
            enabled (bool):
        """
        ...
    def set_sensing_interval(self, new_sensing_interval: float) -> None:
        r"""
        x.set_sensing_interval(new_sensing_interval) -> None
        Changes the SensingInterval.
        If we are currently waiting for an interval, this can either extend or shorten that interval.
        A value <= 0 prevents any updates.
        
        Args:
            new_sensing_interval (float):
        """
        ...
    def set_peripheral_vision_angle(self, new_peripheral_vision_angle: float) -> None:
        r"""
        x.set_peripheral_vision_angle(new_peripheral_vision_angle) -> None
        Sets PeripheralVisionAngle. Calculates PeripheralVisionCosine from PeripheralVisionAngle
        
        Args:
            new_peripheral_vision_angle (float):
        """
        ...
    def get_peripheral_vision_cosine(self) -> float:
        r"""
        x.get_peripheral_vision_cosine() -> float
        Get Peripheral Vision Cosine
        
        Returns:
            float:
        """
        ...
    def get_peripheral_vision_angle(self) -> float:
        r"""
        x.get_peripheral_vision_angle() -> float
        Get Peripheral Vision Angle
        
        Returns:
            float:
        """
        ...

class SensingComponent(PawnSensingComponent):
    r"""
    deprecated: 'SensingComponent' was renamed to 'PawnSensingComponent'.
    """
    ...

class AITask(GameplayTask):
    r"""
    AITask
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AITask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``owner_controller`` (AIController):  [Read-Write]
    """
    @property
    def owner_controller(self) -> AIController:
        r"""
        (AIController):  [Read-Only]
        """
        ...

class AITask_LockLogic(AITask):
    r"""
    Locks AI logic until removed by external trigger
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AITask_LockLogic.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``owner_controller`` (AIController):  [Read-Write]
    """
    ...

class AITask_MoveTo(AITask):
    r"""
    AITask Move To
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AITask_MoveTo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_move_finished`` (MoveTaskCompletedSignature):  [Read-Write]
    - ``on_request_failed`` (GenericGameplayTaskDelegate):  [Read-Write]
    - ``owner_controller`` (AIController):  [Read-Write]
    """
    @property
    def on_request_failed(self) -> GenericGameplayTaskDelegate:
        r"""
        (GenericGameplayTaskDelegate):  [Read-Write]
        """
        ...
    @on_request_failed.setter
    def on_request_failed(self, value: GenericGameplayTaskDelegate) -> None:
        ...
    @property
    def on_move_finished(self) -> MoveTaskCompletedSignature:
        r"""
        (MoveTaskCompletedSignature):  [Read-Write]
        """
        ...
    @on_move_finished.setter
    def on_move_finished(self, value: MoveTaskCompletedSignature) -> None:
        ...

class AITask_RunEQS(AITask):
    r"""
    AITask Run EQS
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: AITask_RunEQS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``owner_controller`` (AIController):  [Read-Write]
    """
    ...

class DataflowBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Dataflow Blueprint Library
    
    **C++ Source:**
    
    - **Module**: DataflowEngine
    - **File**: DataflowBlueprintLibrary.h
    
    """
    @classmethod
    def evaluate_terminal_node_by_name(cls, dataflow: Dataflow, terminal_node_name: Name, result_asset: Object) -> None:
        r"""
        X.evaluate_terminal_node_by_name(dataflow, terminal_node_name, result_asset) -> None
        Find a specific terminal node by name evaluate it using a specific UObject
        
        Args:
            dataflow (Dataflow): 
            terminal_node_name (Name): 
            result_asset (Object):
        """
        ...

class EdGraph(Object):
    r"""
    Ed Graph
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EdGraph.h
    
    """
    ...

class Dataflow(EdGraph):
    r"""
    UDataflow (UObject)
    
    UObject wrapper for the Dataflow::FGraph
    
    **C++ Source:**
    
    - **Module**: DataflowEngine
    - **File**: DataflowObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active`` (bool):  [Read-Write]
    - ``material`` (Material):  [Read-Write]
    - ``targets`` (Array[Object]):  [Read-Write]
    """
    ...

class ChaosDebugDrawComponent(ActorComponent):
    r"""
    Chaos Debug Draw Component
    
    **C++ Source:**
    
    - **Module**: ChaosSolverEngine
    - **File**: ChaosDebugDrawComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class ChaosEventListenerComponent(ActorComponent):
    r"""
    Base class for listeners that query and respond to a frame's physics data (collision events, break events, etc).
    
    **C++ Source:**
    
    - **Module**: ChaosSolverEngine
    - **File**: ChaosEventListenerComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class ChaosGameplayEventDispatcher(ChaosEventListenerComponent):
    r"""
    Chaos Gameplay Event Dispatcher
    
    **C++ Source:**
    
    - **Module**: ChaosSolverEngine
    - **File**: ChaosGameplayEventDispatcher.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class ChaosNotifyHandlerInterface(Interface):
    r"""
    Chaos Notify Handler Interface
    
    **C++ Source:**
    
    - **Module**: ChaosSolverEngine
    - **File**: ChaosNotifyHandlerInterface.h
    
    """
    ...

class ChaosSolverEngineBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Chaos Solver Engine Blueprint Library
    
    **C++ Source:**
    
    - **Module**: ChaosSolverEngine
    - **File**: ChaosNotifyHandlerInterface.h
    
    """
    @classmethod
    def convert_physics_collision_to_hit_result(cls, physics_collision: ChaosPhysicsCollisionInfo) -> HitResult:
        r"""
        X.convert_physics_collision_to_hit_result(physics_collision) -> HitResult
        Convert Physics Collision to Hit Result
        
        Args:
            physics_collision (ChaosPhysicsCollisionInfo): 
        
        Returns:
            HitResult:
        """
        ...

class ChaosSolverActor(Actor):
    r"""
    Chaos Solver Actor
    
    **C++ Source:**
    
    - **Module**: ChaosSolverEngine
    - **File**: ChaosSolverActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``chaos_debug_substep_control`` (ChaosDebugSubstepControl):  [Read-Write] * Control to pause/step/substep the solver to the next synchronization point.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``floor_height`` (float):  [Read-Write]
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``has_floor`` (bool):  [Read-Write] End deprecated properties
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``properties`` (ChaosSolverConfiguration):  [Read-Write]
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    def set_solver_active(self, active: bool) -> None:
        r"""
        x.set_solver_active(active) -> None
        Controls whether the solver is able to simulate particles it controls
        
        Args:
            active (bool):
        """
        ...
    def set_as_current_world_solver(self) -> None:
        r"""
        x.set_as_current_world_solver() -> None
        Makes this solver the current world solver. Dynamically spawned objects will have their physics state created in this solver.
        """
        ...

class FieldSystemActor(Actor):
    r"""
    Field System Actor
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``field_system_component`` (FieldSystemComponent):  [Read-Only] FieldSystemComponent
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def field_system_component(self) -> FieldSystemComponent:
        r"""
        (FieldSystemComponent):  [Read-Only] FieldSystemComponent
        """
        ...

class FieldSystemComponent(PrimitiveComponent):
    r"""
    FieldSystemComponent
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``field_system`` (FieldSystem):  [Read-Write] Field system asset to be used to store the construction fields. This asset is not required anymore and will be deprecated soon.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_chaos_field`` (bool):  [Read-Write] If enabled the field will be used by all the chaos solvers
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_world_field`` (bool):  [Read-Write] If enabled the field will be pushed to the world fields and will be available to materials and niagara
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``supported_solvers`` (Array[ChaosSolverActor]):  [Read-Write] List of chaos solvers that will use the field
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def field_system(self) -> FieldSystem:
        r"""
        (FieldSystem):  [Read-Only] Field system asset to be used to store the construction fields. This asset is not required anymore and will be deprecated soon.
        """
        ...
    def reset_field_system(self) -> None:
        r"""
        x.reset_field_system() -> None
        RemoveConstructionFields
          This function will remove all the field component construction fields from chaos and from the world
        """
        ...
    def remove_persistent_fields(self) -> None:
        r"""
        x.remove_persistent_fields() -> None
        RemovePersistentFields
          This function will remove all the field component persistent fields from chaos and from the world
        """
        ...
    def apply_uniform_vector_falloff_force(self, enabled: bool, position: Vector, direction: Vector, radius: float, magnitude: float) -> None:
        r"""
        x.apply_uniform_vector_falloff_force(enabled, position, direction, radius, magnitude) -> None
        FalloffUniformForce
          This function will dispatch a command to the physics thread to apply
          a linear force in a uniform direction. The force vector is weaker as
          it moves away from the center.
        
        Args:
            enabled (bool): Is this force enabled for evaluation.
            position (Vector): The origin point of the force
            direction (Vector): The direction of the linear force
            radius (float): Radial influence from the position, positions further away are weaker.
            magnitude (float): The size of the linear force.
        """
        ...
    def apply_strain_field(self, enabled: bool, position: Vector, radius: float, magnitude: float, iterations: int) -> None:
        r"""
        x.apply_strain_field(enabled, position, radius, magnitude, iterations) -> None
        ApplyExternalStran
          This function will dispatch a command to the physics thread to apply
          a strain field on a clustered set of geometry. This is used to trigger a
          breaking event within the solver.
        
        Args:
            enabled (bool): Is this force enabled for evaluation.
            position (Vector): The origin point of the force
            radius (float): Radial influence from the position, positions further away are weaker.
            magnitude (float): The size of the linear force.
            iterations (int32): Levels of evaluation into the cluster hierarchy.
        """
        ...
    def apply_stay_dynamic_field(self, enabled: bool, position: Vector, radius: float) -> None:
        r"""
        x.apply_stay_dynamic_field(enabled, position, radius) -> None
        SetDynamicState
          This function will dispatch a command to the physics thread to apply
          a kinematic to dynamic state change for the particles within the field.
        
        Args:
            enabled (bool): Is this force enabled for evaluation.
            position (Vector): The location of the command
            radius (float): Radial influence from the position
        """
        ...
    def apply_radial_vector_falloff_force(self, enabled: bool, position: Vector, radius: float, magnitude: float) -> None:
        r"""
        x.apply_radial_vector_falloff_force(enabled, position, radius, magnitude) -> None
        FalloffRadialForce
          This function will dispatch a command to the physics thread to apply
          a linear force from a position in space. The force vector is weaker as
          it moves away from the center.
        
        Args:
            enabled (bool): Is this force enabled for evaluation.
            position (Vector): The origin point of the force
            radius (float): Radial influence from the position, positions further away are weaker.
            magnitude (float): The size of the linear force.
        """
        ...
    def apply_radial_force(self, enabled: bool, position: Vector, magnitude: float) -> None:
        r"""
        x.apply_radial_force(enabled, position, magnitude) -> None
        ApplyRadialForce
          This function will dispatch a command to the physics thread to apply
          a linear force that points away from a position.
        
        Args:
            enabled (bool): Is this force enabled for evaluation.
            position (Vector): The origin point of the force
            magnitude (float): The size of the linear force.
        """
        ...
    def apply_physics_field(self, enabled: bool, target: FieldPhysicsType, meta_data: FieldSystemMetaData, field: FieldNodeBase) -> None:
        r"""
        x.apply_physics_field(enabled, target, meta_data, field) -> None
        AddTransientField
          This function will dispatch a command to the physics thread to apply
          a generic evaluation of a user defined transient field network. See documentation,
          for examples of how to recreate variations of the above generic
          fields using field networks
        
        Args:
            enabled (bool): Is this force enabled for evaluation.
            target (FieldPhysicsType): Type of field supported by the solver.
            meta_data (FieldSystemMetaData): Meta data used to assist in evaluation
            field (FieldNodeBase): Base evaluation node for the field network.
        """
        ...
    def apply_linear_force(self, enabled: bool, direction: Vector, magnitude: float) -> None:
        r"""
        x.apply_linear_force(enabled, direction, magnitude) -> None
        ApplyUniformForce
          This function will dispatch a command to the physics thread to apply
          a uniform linear force on each particle within the simulation.
        
        Args:
            enabled (bool): Is this force enabled for evaluation.
            direction (Vector): The direction of the linear force
            magnitude (float): The size of the linear force.
        """
        ...
    def add_persistent_field(self, enabled: bool, target: FieldPhysicsType, meta_data: FieldSystemMetaData, field: FieldNodeBase) -> None:
        r"""
        x.add_persistent_field(enabled, target, meta_data, field) -> None
        AddPersistentField
          This function will dispatch a command to the physics thread to apply
          a generic evaluation of a user defined field network. This command will be persistent in time and will live until
          the component is destroyed or until the RemovePersistenFields function is called. See documentation,
          for examples of how to recreate variations of the above generic
          fields using field networks
        
        Args:
            enabled (bool): Is this force enabled for evaluation.
            target (FieldPhysicsType): Type of field supported by the solver.
            meta_data (FieldSystemMetaData): Meta data used to assist in evaluation
            field (FieldNodeBase): Base evaluation node for the field network.
        """
        ...
    def add_field_command(self, enabled: bool, target: FieldPhysicsType, meta_data: FieldSystemMetaData, field: FieldNodeBase) -> None:
        r"""
        x.add_field_command(enabled, target, meta_data, field) -> None
        AddConstructionField
          This function will dispatch a command to the physics thread to apply
          a generic evaluation of a user defined field network. This command will be used in a
          construction script to setup some particles properties (anchors...). See documentation,
          for examples of how to recreate variations of the above generic
          fields using field networks
        
        Args:
            enabled (bool): Is this force enabled for evaluation.
            target (FieldPhysicsType): Type of field supported by the solver.
            meta_data (FieldSystemMetaData): Meta data used to assist in evaluation
            field (FieldNodeBase): Base evaluation node for the field network.
        """
        ...

class FieldSystemMetaData(ActorComponent):
    r"""
    Context :
      Contexts are used to pass extra data into the field evaluation.
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class FieldSystemMetaDataIteration(FieldSystemMetaData):
    r"""
    * UFieldSystemMetaDataIteration : Not used anymore, just hiding it right now but will probably be deprecated if not used in the future
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``iterations`` (int32):  [Read-Write] Number of iterations (WIP)
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def iterations(self) -> int:
        r"""
        (int32):  [Read-Write] Number of iterations (WIP)
        """
        ...
    @iterations.setter
    def iterations(self, value: int) -> None:
        ...
    def set_meta_data_iteration(self, iterations: int = 1) -> FieldSystemMetaDataIteration:
        r"""
        x.set_meta_data_iteration(iterations=1) -> FieldSystemMetaDataIteration
        Set the number of iteration type
        
        Args:
            iterations (int32): Number of iterations (WIP)
        
        Returns:
            FieldSystemMetaDataIteration:
        """
        ...

class FieldSystemMetaDataProcessingResolution(FieldSystemMetaData):
    r"""
    Control the set of particles on which the field will be applied
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``resolution_type`` (FieldResolutionType):  [Read-Write] Precessing resolution type used to select the particles on which the field will be applied
    """
    @property
    def resolution_type(self) -> FieldResolutionType:
        r"""
        (FieldResolutionType):  [Read-Write] Precessing resolution type used to select the particles on which the field will be applied
        """
        ...
    @resolution_type.setter
    def resolution_type(self, value: FieldResolutionType) -> None:
        ...
    def set_meta_dataa_processing_resolution_type(self, resolution_type: FieldResolutionType) -> FieldSystemMetaDataProcessingResolution:
        r"""
        x.set_meta_dataa_processing_resolution_type(resolution_type) -> FieldSystemMetaDataProcessingResolution
        Set the processing resolution type
        
        Args:
            resolution_type (FieldResolutionType): Type of processing resolution used to select the particles on which the field will be applied
        
        Returns:
            FieldSystemMetaDataProcessingResolution:
        """
        ...

class FieldSystemMetaDataFilter(FieldSystemMetaData):
    r"""
    Filter the particles on which the field will be applied
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``filter_type`` (FieldFilterType):  [Read-Write] Filter state type used to select the particles on which the field will be applied
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``object_type`` (FieldObjectType):  [Read-Write] Filter object type used to select the particles on which the field will be applied
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``position_type`` (FieldPositionType):  [Read-Write] Specify which position type will be used for the field evaluation
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def filter_type(self) -> FieldFilterType:
        r"""
        (FieldFilterType):  [Read-Write] Filter state type used to select the particles on which the field will be applied
        """
        ...
    @filter_type.setter
    def filter_type(self, value: FieldFilterType) -> None:
        ...
    @property
    def object_type(self) -> FieldObjectType:
        r"""
        (FieldObjectType):  [Read-Write] Filter object type used to select the particles on which the field will be applied
        """
        ...
    @object_type.setter
    def object_type(self, value: FieldObjectType) -> None:
        ...
    @property
    def position_type(self) -> FieldPositionType:
        r"""
        (FieldPositionType):  [Read-Write] Specify which position type will be used for the field evaluation
        """
        ...
    @position_type.setter
    def position_type(self, value: FieldPositionType) -> None:
        ...
    def set_meta_data_filter_type(self, filter_type: FieldFilterType, object_type: FieldObjectType, position_type: FieldPositionType) -> FieldSystemMetaDataFilter:
        r"""
        x.set_meta_data_filter_type(filter_type, object_type, position_type) -> FieldSystemMetaDataFilter
        Set the particles filter type
        
        Args:
            filter_type (FieldFilterType): State type used to select the state particles on which the field will be applied
            object_type (FieldObjectType): Object type used to select the type of objects(rigid, cloth...) on which the field will be applied
            position_type (FieldPositionType): Position type used to compute the samples positions
        
        Returns:
            FieldSystemMetaDataFilter:
        """
        ...

class FieldNodeBase(ActorComponent):
    r"""
    Field Evaluation
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class FieldNodeInt(FieldNodeBase):
    r"""
    FieldNodeInt
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class FieldNodeFloat(FieldNodeBase):
    r"""
    FieldNodeFloat
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class FieldNodeVector(FieldNodeBase):
    r"""
    FieldNodeVector
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class UniformInteger(FieldNodeInt):
    r"""
    Set a uniform integer value independently of the sample position. The output is equal to magnitude
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``magnitude`` (int32):  [Read-Write] The field output will be equal the magnitude
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def magnitude(self) -> int:
        r"""
        (int32):  [Read-Write] The field output will be equal the magnitude
        """
        ...
    @magnitude.setter
    def magnitude(self, value: int) -> None:
        ...
    def set_uniform_integer(self, magnitude: int = 0) -> UniformInteger:
        r"""
        x.set_uniform_integer(magnitude=0) -> UniformInteger
        Set a uniform integer value independently of the sample position. The output is equal to magnitude
        
        Args:
            magnitude (int32): The field output will be equal the magnitude
        
        Returns:
            UniformInteger:
        """
        ...

class RadialIntMask(FieldNodeInt):
    r"""
    This function first defines a radial integer field equal to Interior-value inside a sphere / Exterior-value outside. This field will be used alongside the particle input value and the mask condition to compute the particle output value.
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``exterior_value`` (int32):  [Read-Write] If the sample distance from the center is greater than radius, the intermediate value will be set the exterior value
    - ``interior_value`` (int32):  [Read-Write] If the sample distance from the center is less than radius, the intermediate value will be set the interior value
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``position`` (Vector):  [Read-Write] Center position of the radial mask field
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``radius`` (float):  [Read-Write] Radius of the radial mask field
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``set_mask_condition`` (SetMaskConditionType):  [Read-Write] If the mask condition is set to always the output value will be the intermediate one. If set to not interior/exterior the output value will be the intermediate one if the input is different from the interior/exterior value
    """
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write] Radius of the radial mask field
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Center position of the radial mask field
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...
    @property
    def interior_value(self) -> int:
        r"""
        (int32):  [Read-Write] If the sample distance from the center is less than radius, the intermediate value will be set the interior value
        """
        ...
    @interior_value.setter
    def interior_value(self, value: int) -> None:
        ...
    @property
    def exterior_value(self) -> int:
        r"""
        (int32):  [Read-Write] If the sample distance from the center is greater than radius, the intermediate value will be set the exterior value
        """
        ...
    @exterior_value.setter
    def exterior_value(self, value: int) -> None:
        ...
    @property
    def set_mask_condition(self) -> SetMaskConditionType:
        r"""
        (SetMaskConditionType):  [Read-Write] If the mask condition is set to always the output value will be the intermediate one. If set to not interior/exterior the output value will be the intermediate one if the input is different from the interior/exterior value
        """
        ...
    @set_mask_condition.setter
    def set_mask_condition(self, value: SetMaskConditionType) -> None:
        ...
    def set_radial_int_mask(self, radius: float, position: Vector, interior_value: int = 1, exterior_value: int = ..., set_mask_condition_in: SetMaskConditionType = ...) -> RadialIntMask:
        r"""
        x.set_radial_int_mask(radius, position, interior_value=1, exterior_value, set_mask_condition_in) -> RadialIntMask
        This function first defines a radial integer field equal to Interior-value inside a sphere / Exterior-value outside. This field will be used alongside the particle input value and the mask condition to compute the particle output value.
        - If Mask-condition = set-always : the particle output value will be equal to Interior-value if the particle position is inside a sphere / Exterior-value otherwise.
        - If Mask-condition = merge-interior : the particle output value will be equal to Interior-value if the particle position is inside the sphere or if the particle input value is already Interior-Value / Exterior-value otherwise.
        - If Mask-condition = merge-exterior : the particle output value will be equal to Exterior-value if the particle position is outside the sphere or if the particle input value is already Exterior-Value / Interior-value otherwise.
        
        Args:
            radius (float): Radius of the radial field
            position (Vector): Center position of the radial field"
            interior_value (int32): If the sample distance from the center is less than radius, the intermediate value will be set the interior value
            exterior_value (int32): If the sample distance from the center is greater than radius, the intermediate value will be set the exterior value
            set_mask_condition_in (SetMaskConditionType): If the mask condition is set to always the output value will be the intermediate one. If set to not interior/exterior the output value will be the intermediate one if the input is different from the interior/exterior value
        
        Returns:
            RadialIntMask:
        """
        ...

class UniformScalar(FieldNodeFloat):
    r"""
    Set a uniform scalar value independently of the sample position. The output is equal to magnitude
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``magnitude`` (float):  [Read-Write] The field output will be equal the magnitude
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write] The field output will be equal the magnitude
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...
    def set_uniform_scalar(self, magnitude: float = 1.000000) -> UniformScalar:
        r"""
        x.set_uniform_scalar(magnitude=1.000000) -> UniformScalar
        Set a uniform scalar value independently of the sample position. The output is equal to magnitude
        
        Args:
            magnitude (float): The field output will be equal the magnitude
        
        Returns:
            UniformScalar:
        """
        ...

class WaveScalar(FieldNodeFloat):
    r"""
    Set a temporal wave scalar value according to the sample distance from the field position.
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``falloff`` (FieldFalloffType):  [Read-Write] Type of falloff function used if the falloff function is picked
    - ``function`` (WaveFunctionType):  [Read-Write] Wave function used for the field
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``magnitude`` (float):  [Read-Write] Magnitude of the wave function
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``period`` (float):  [Read-Write] Time over which the wave will travel from one peak to another one. The wave velocity is proportional to wavelength/period
    - ``position`` (Vector):  [Read-Write] Center position of the wave field
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``wavelength`` (float):  [Read-Write] Distance between 2 wave peaks
    """
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write] Magnitude of the wave function
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Center position of the wave field
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...
    @property
    def wavelength(self) -> float:
        r"""
        (float):  [Read-Write] Distance between 2 wave peaks
        """
        ...
    @wavelength.setter
    def wavelength(self, value: float) -> None:
        ...
    @property
    def period(self) -> float:
        r"""
        (float):  [Read-Write] Time over which the wave will travel from one peak to another one. The wave velocity is proportional to wavelength/period
        """
        ...
    @period.setter
    def period(self, value: float) -> None:
        ...
    @property
    def function(self) -> WaveFunctionType:
        r"""
        (WaveFunctionType):  [Read-Write] Wave function used for the field
        """
        ...
    @function.setter
    def function(self, value: WaveFunctionType) -> None:
        ...
    @property
    def falloff(self) -> FieldFalloffType:
        r"""
        (FieldFalloffType):  [Read-Write] Type of falloff function used if the falloff function is picked
        """
        ...
    @falloff.setter
    def falloff(self, value: FieldFalloffType) -> None:
        ...
    def set_wave_scalar(self, magnitude: float = 1.000000, position: Vector = ..., wavelength: float = 1000.000000, period: float = 1.000000, time: float = ..., function: WaveFunctionType = ..., falloff: FieldFalloffType = ...) -> WaveScalar:
        r"""
        x.set_wave_scalar(magnitude=1.000000, position, wavelength=1000.000000, period=1.000000, time, function, falloff) -> WaveScalar
        Set a temporal wave scalar value according to the sample distance from the field position.
        
        Args:
            magnitude (float): Magnitude of the wave function
            position (Vector): Center position of the wave field
            wavelength (float): Distance between 2 wave peaks
            period (float): Time over which the wave will travel from one peak to another one. The wave velocity is proportional to wavelength/period
            time (float): 
            function (WaveFunctionType): Wave function used for the field
            falloff (FieldFalloffType): Type of falloff function used if the falloff function is picked
        
        Returns:
            WaveScalar:
        """
        ...

class RadialFalloff(FieldNodeFloat):
    r"""
    Sphere scalar field that will be defined only within a sphere
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``default`` (float):  [Read-Write] The field value will be set to Default if the sample distance from the center is higher than the radius
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``falloff`` (FieldFalloffType):  [Read-Write] Type of falloff function used to model the evolution of the field from the sphere center to the sample position
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``magnitude`` (float):  [Read-Write] Magnitude of the sphere falloff field
    - ``max_range`` (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
    - ``min_range`` (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``position`` (Vector):  [Read-Write] Center position of the sphere falloff field
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``radius`` (float):  [Read-Write] Radius of the sphere falloff field
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write] Magnitude of the sphere falloff field
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...
    @property
    def min_range(self) -> float:
        r"""
        (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
        """
        ...
    @min_range.setter
    def min_range(self, value: float) -> None:
        ...
    @property
    def max_range(self) -> float:
        r"""
        (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
        """
        ...
    @max_range.setter
    def max_range(self, value: float) -> None:
        ...
    @property
    def default(self) -> float:
        r"""
        (float):  [Read-Write] The field value will be set to Default if the sample distance from the center is higher than the radius
        """
        ...
    @default.setter
    def default(self, value: float) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write] Radius of the sphere falloff field
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Center position of the sphere falloff field
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...
    @property
    def falloff(self) -> FieldFalloffType:
        r"""
        (FieldFalloffType):  [Read-Write] Type of falloff function used to model the evolution of the field from the sphere center to the sample position
        """
        ...
    @falloff.setter
    def falloff(self, value: FieldFalloffType) -> None:
        ...
    def set_radial_falloff(self, magnitude: float = 1.000000, min_range: float = 0.000000, max_range: float = 1.000000, default: float = ..., radius: float = ..., position: Vector = ..., falloff: FieldFalloffType = ...) -> RadialFalloff:
        r"""
        x.set_radial_falloff(magnitude=1.000000, min_range=0.000000, max_range=1.000000, default, radius, position, falloff) -> RadialFalloff
        Sphere scalar field that will be defined only within a sphere
        
        Args:
            magnitude (float): Magnitude of the sphere falloff field
            min_range (float): The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
            max_range (float): The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
            default (float): The field value will be set to Default if the sample distance from the center is higher than the radius
            radius (float): Radius of the sphere falloff field
            position (Vector): Center position of the sphere falloff field
            falloff (FieldFalloffType): Type of falloff function used if the falloff function is picked
        
        Returns:
            RadialFalloff:
        """
        ...

class PlaneFalloff(FieldNodeFloat):
    r"""
    Plane scalar field that will be defined only within a distance from a plane
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``default`` (float):  [Read-Write] The field value will be set to Default if the sample distance from the plane is higher than the distance
    - ``distance`` (float):  [Read-Write] Distance limit for the plane falloff field
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``falloff`` (FieldFalloffType):  [Read-Write] Type of falloff function used to model the evolution of the field from the plane surface to the distance isosurface
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``magnitude`` (float):  [Read-Write] Magnitude of the plane falloff field
    - ``max_range`` (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
    - ``min_range`` (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
    - ``normal`` (Vector):  [Read-Write] Plane normal of the plane falloff field
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``position`` (Vector):  [Read-Write] Plane position of the plane falloff field
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write] Magnitude of the plane falloff field
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...
    @property
    def min_range(self) -> float:
        r"""
        (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
        """
        ...
    @min_range.setter
    def min_range(self, value: float) -> None:
        ...
    @property
    def max_range(self) -> float:
        r"""
        (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
        """
        ...
    @max_range.setter
    def max_range(self, value: float) -> None:
        ...
    @property
    def default(self) -> float:
        r"""
        (float):  [Read-Write] The field value will be set to Default if the sample distance from the plane is higher than the distance
        """
        ...
    @default.setter
    def default(self, value: float) -> None:
        ...
    @property
    def distance(self) -> float:
        r"""
        (float):  [Read-Write] Distance limit for the plane falloff field
        """
        ...
    @distance.setter
    def distance(self, value: float) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Plane position of the plane falloff field
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...
    @property
    def normal(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Plane normal of the plane falloff field
        """
        ...
    @normal.setter
    def normal(self, value: Vector) -> None:
        ...
    @property
    def falloff(self) -> FieldFalloffType:
        r"""
        (FieldFalloffType):  [Read-Write] Type of falloff function used to model the evolution of the field from the plane surface to the distance isosurface
        """
        ...
    @falloff.setter
    def falloff(self, value: FieldFalloffType) -> None:
        ...
    def set_plane_falloff(self, magnitude: float = 1.000000, min_range: float = 0.000000, max_range: float = 1.000000, default: float = ..., distance: float = ..., position: Vector = ..., normal: Vector = ..., falloff: FieldFalloffType = ...) -> PlaneFalloff:
        r"""
        x.set_plane_falloff(magnitude=1.000000, min_range=0.000000, max_range=1.000000, default, distance, position, normal, falloff) -> PlaneFalloff
        Plane scalar field that will be defined only within a distance from a plane
        
        Args:
            magnitude (float): Magnitude of the plane falloff field
            min_range (float): The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
            max_range (float): The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
            default (float): The field value will be set to default if the sample projected distance ((Sample Position - Center Position).dot(Plane Normal)) is higher than the Plane Distance
            distance (float): Distance limit for the plane falloff field starting from the center position and extending in the direction of the plane normal
            position (Vector): Plane center position of the plane falloff field
            normal (Vector): Plane normal of the plane falloff field
            falloff (FieldFalloffType): Type of falloff function used to model the evolution of the field from the plane surface to the distance isosurface
        
        Returns:
            PlaneFalloff:
        """
        ...

class BoxFalloff(FieldNodeFloat):
    r"""
    Box scalar field that will be defined only within a box
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``default`` (float):  [Read-Write] The field value will be set to Default if the sample distance from the box is higher than the scale of the transform
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``falloff`` (FieldFalloffType):  [Read-Write] Type of falloff function used to model the evolution of the field from the box surface to the sample position
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``magnitude`` (float):  [Read-Write] Magnitude of the box falloff field
    - ``max_range`` (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
    - ``min_range`` (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``transform`` (Transform):  [Read-Write] Translation, Rotation and Scale of the unit box
    """
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write] Magnitude of the box falloff field
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...
    @property
    def min_range(self) -> float:
        r"""
        (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
        """
        ...
    @min_range.setter
    def min_range(self, value: float) -> None:
        ...
    @property
    def max_range(self) -> float:
        r"""
        (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
        """
        ...
    @max_range.setter
    def max_range(self, value: float) -> None:
        ...
    @property
    def default(self) -> float:
        r"""
        (float):  [Read-Write] The field value will be set to Default if the sample distance from the box is higher than the scale of the transform
        """
        ...
    @default.setter
    def default(self, value: float) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Translation, Rotation and Scale of the unit box
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    @property
    def falloff(self) -> FieldFalloffType:
        r"""
        (FieldFalloffType):  [Read-Write] Type of falloff function used to model the evolution of the field from the box surface to the sample position
        """
        ...
    @falloff.setter
    def falloff(self, value: FieldFalloffType) -> None:
        ...
    def set_box_falloff(self, magnitude: float = 1.000000, min_range: float = 0.000000, max_range: float = 1.000000, default: float = ..., transform: Transform = ..., falloff: FieldFalloffType = ...) -> BoxFalloff:
        r"""
        x.set_box_falloff(magnitude=1.000000, min_range=0.000000, max_range=1.000000, default, transform, falloff) -> BoxFalloff
        Box scalar field that will be defined only within a box
        
        Args:
            magnitude (float): Magnitude of the box falloff field
            min_range (float): The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
            max_range (float): The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
            default (float): The field value will be set to Default if the sample distance from the box is higher than the scale of the transform
            transform (Transform): Translation, Rotation and Scale of the unit box
            falloff (FieldFalloffType): Type of falloff function used to model the evolution of the field from the box surface to the sample position
        
        Returns:
            BoxFalloff:
        """
        ...

class NoiseField(FieldNodeFloat):
    r"""
    Defines a perlin noise scalar value if the sample is within a box
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``max_range`` (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange
    - ``min_range`` (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``transform`` (Transform):  [Read-Write] Transform of the box in which the perlin noise will be defined
    """
    @property
    def min_range(self) -> float:
        r"""
        (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange
        """
        ...
    @min_range.setter
    def min_range(self, value: float) -> None:
        ...
    @property
    def max_range(self) -> float:
        r"""
        (float):  [Read-Write] The initial function value between 0 and 1 will be scaled between MinRange and MaxRange
        """
        ...
    @max_range.setter
    def max_range(self, value: float) -> None:
        ...
    @property
    def transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Transform of the box in which the perlin noise will be defined
        """
        ...
    @transform.setter
    def transform(self, value: Transform) -> None:
        ...
    def set_noise_field(self, min_range: float = 0.000000, max_range: float = 1.000000, transform: Transform = ...) -> NoiseField:
        r"""
        x.set_noise_field(min_range=0.000000, max_range=1.000000, transform) -> NoiseField
        Defines a perlin noise scalar value if the sample is within a box
        
        Args:
            min_range (float): The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
            max_range (float): The initial function value between 0 and 1 will be scaled between MinRange and MaxRange before being multiplied by magnitude
            transform (Transform): Transform of the box in which the perlin noise will be defined
        
        Returns:
            NoiseField:
        """
        ...

class UniformVector(FieldNodeVector):
    r"""
    Set a uniform vector value independently of the sample position.The output is equal to magnitude * direction
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``direction`` (Vector):  [Read-Write] Normalized direction of the uniform vector field
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``magnitude`` (float):  [Read-Write] Magnitude of the uniform vector field
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write] Magnitude of the uniform vector field
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...
    @property
    def direction(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Normalized direction of the uniform vector field
        """
        ...
    @direction.setter
    def direction(self, value: Vector) -> None:
        ...
    def set_uniform_vector(self, magnitude: float = 1.000000, direction: Vector = ...) -> UniformVector:
        r"""
        x.set_uniform_vector(magnitude=1.000000, direction) -> UniformVector
        Set a uniform vector value independently of the sample position.The output is equal to magnitude * direction
        
        Args:
            magnitude (float): Magnitude of the uniform vector field
            direction (Vector): Normalized direction of the uniform vector field
        
        Returns:
            UniformVector:
        """
        ...

class RadialVector(FieldNodeVector):
    r"""
    Set a radial vector value, the direction being the vector from the sample position to the field one. The output is equal to magnitude * direction
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``magnitude`` (float):  [Read-Write] Magnitude of the radial vector field
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``position`` (Vector):  [Read-Write] Center position of the radial vector field
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write] Magnitude of the radial vector field
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...
    @property
    def position(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Center position of the radial vector field
        """
        ...
    @position.setter
    def position(self, value: Vector) -> None:
        ...
    def set_radial_vector(self, magnitude: float = 1.000000, position: Vector = ...) -> RadialVector:
        r"""
        x.set_radial_vector(magnitude=1.000000, position) -> RadialVector
        Set a radial vector value. The direction is the normalized vector from the field position to the sample one. The output is equal to this direction * magnitude.
        
        Args:
            magnitude (float): Magnitude of the radial vector field
            position (Vector): Center position of the radial vector field
        
        Returns:
            RadialVector:
        """
        ...

class RandomVector(FieldNodeVector):
    r"""
    Set a random vector value independently of the sample position. The output is equal to magnitude * random direction
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``magnitude`` (float):  [Read-Write] Magnitude of the random vector field
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write] Magnitude of the random vector field
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...
    def set_random_vector(self, magnitude: float = 1.000000) -> RandomVector:
        r"""
        x.set_random_vector(magnitude=1.000000) -> RandomVector
        Set a random vector value independently of the sample position. The output is equal to magnitude * random direction
        
        Args:
            magnitude (float): Magnitude of the random vector field
        
        Returns:
            RandomVector:
        """
        ...

class OperatorField(FieldNodeBase):
    r"""
    Compute an operation between 2 incoming fields
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``left_field`` (FieldNodeBase):  [Read-Write] Left field to be processed
    - ``magnitude`` (float):  [Read-Write] Magnitude of the operator field
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``operation`` (FieldOperationType):  [Read-Write] Type of operation you want to perform between the 2 fields
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``right_field`` (FieldNodeBase):  [Read-Write] Right field to be processed
    """
    @property
    def magnitude(self) -> float:
        r"""
        (float):  [Read-Write] Magnitude of the operator field
        """
        ...
    @magnitude.setter
    def magnitude(self, value: float) -> None:
        ...
    @property
    def right_field(self) -> FieldNodeBase:
        r"""
        (FieldNodeBase):  [Read-Write] Right field to be processed
        """
        ...
    @right_field.setter
    def right_field(self, value: FieldNodeBase) -> None:
        ...
    @property
    def left_field(self) -> FieldNodeBase:
        r"""
        (FieldNodeBase):  [Read-Write] Left field to be processed
        """
        ...
    @left_field.setter
    def left_field(self, value: FieldNodeBase) -> None:
        ...
    @property
    def operation(self) -> FieldOperationType:
        r"""
        (FieldOperationType):  [Read-Write] Type of operation you want to perform between the 2 fields
        """
        ...
    @operation.setter
    def operation(self, value: FieldOperationType) -> None:
        ...
    def set_operator_field(self, magnitude: float = 1.000000, left_field: FieldNodeBase = ..., right_field: FieldNodeBase = ..., operation: FieldOperationType = ...) -> OperatorField:
        r"""
        x.set_operator_field(magnitude=1.000000, left_field, right_field, operation) -> OperatorField
        Compute an operation between 2 incoming fields
        
        Args:
            magnitude (float): Magnitude of the operator field
            left_field (FieldNodeBase): Input field A to be processed
            right_field (FieldNodeBase): Input field B to be processed
            operation (FieldOperationType): Type of math operation you want to perform between the 2 fields
        
        Returns:
            OperatorField:
        """
        ...

class ToIntegerField(FieldNodeInt):
    r"""
    Convert a scalar field to a integer one
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``float_field`` (FieldNodeFloat):  [Read-Write] Scalar field to be converted to an an integer one
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def float_field(self) -> FieldNodeFloat:
        r"""
        (FieldNodeFloat):  [Read-Write] Scalar field to be converted to an an integer one
        """
        ...
    @float_field.setter
    def float_field(self, value: FieldNodeFloat) -> None:
        ...
    def set_to_integer_field(self, float_field: FieldNodeFloat) -> ToIntegerField:
        r"""
        x.set_to_integer_field(float_field) -> ToIntegerField
        Convert a float field to a integer one
        
        Args:
            float_field (FieldNodeFloat): Float field to be converted to an an integer one
        
        Returns:
            ToIntegerField:
        """
        ...

class ToFloatField(FieldNodeFloat):
    r"""
    Convert an integer field to a scalar one
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``int_field`` (FieldNodeInt):  [Read-Write] Integer field to be converted to an a scalar one
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def int_field(self) -> FieldNodeInt:
        r"""
        (FieldNodeInt):  [Read-Write] Integer field to be converted to an a scalar one
        """
        ...
    @int_field.setter
    def int_field(self, value: FieldNodeInt) -> None:
        ...
    def set_to_float_field(self, integer_field: FieldNodeInt) -> ToFloatField:
        r"""
        x.set_to_float_field(integer_field) -> ToFloatField
        Convert an integer field to a float one
        
        Args:
            integer_field (FieldNodeInt): Integer field to be converted to an a float one
        
        Returns:
            ToFloatField:
        """
        ...

class CullingField(FieldNodeBase):
    r"""
    Evaluate the input field according to the result of the culling field
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``culling`` (FieldNodeBase):  [Read-Write] Culling field to be used
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``field`` (FieldNodeBase):  [Read-Write] Input field that will be evaluated according to the culling field result
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``operation`` (FieldCullingOperationType):  [Read-Write] Evaluate the input field if the result of the culling field is equal to 0 (Inside) or different from 0 (Outside)
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def culling(self) -> FieldNodeBase:
        r"""
        (FieldNodeBase):  [Read-Write] Culling field to be used
        """
        ...
    @culling.setter
    def culling(self, value: FieldNodeBase) -> None:
        ...
    @property
    def field(self) -> FieldNodeBase:
        r"""
        (FieldNodeBase):  [Read-Write] Input field that will be evaluated according to the culling field result
        """
        ...
    @field.setter
    def field(self, value: FieldNodeBase) -> None:
        ...
    @property
    def operation(self) -> FieldCullingOperationType:
        r"""
        (FieldCullingOperationType):  [Read-Write] Evaluate the input field if the result of the culling field is equal to 0 (Inside) or different from 0 (Outside)
        """
        ...
    @operation.setter
    def operation(self, value: FieldCullingOperationType) -> None:
        ...
    def set_culling_field(self, culling: FieldNodeBase, field: FieldNodeBase, operation: FieldCullingOperationType) -> CullingField:
        r"""
        x.set_culling_field(culling, field, operation) -> CullingField
        Evaluate the input field according to the result of the culling field.
        
        Args:
            culling (FieldNodeBase): Culling field to be used.
            field (FieldNodeBase): Input field that will be evaluated according to the culling field result.
            operation (FieldCullingOperationType): Evaluate the input field if the result of the culling field is equal to 0 (Inside) or different from 0 (Outside).
        
        Returns:
            CullingField:
        """
        ...

class ReturnResultsTerminal(FieldNodeBase):
    r"""
    Terminal field of a graph
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    def set_return_results_terminal(self) -> ReturnResultsTerminal:
        r"""
        x.set_return_results_terminal() -> ReturnResultsTerminal
        Terminal field of a graph
        
        Returns:
            ReturnResultsTerminal:
        """
        ...

class GeometryCollectionLibrary(BlueprintFunctionLibrary):
    r"""
    Blueprint library for Geometry Collections.
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionBlueprintLibrary.h
    
    """
    @classmethod
    def set_ism_pool_custom_instance_data(cls, geometry_collection_component: GeometryCollectionComponent, custom_data_index: int, custom_data_value: float) -> None:
        r"""
        X.set_ism_pool_custom_instance_data(geometry_collection_component, custom_data_index, custom_data_value) -> None
        Set a custom instance data value for all instances associated with a geometry collection.
        This assumes that the geometry collection is using a custom instanced renderer.
        
        Args:
            geometry_collection_component (GeometryCollectionComponent): The Geometry Collection Component that we want to set custom instance data on.
            custom_data_index (int32): The custom instance data slot that we want to set.
            custom_data_value (float): The value to set to the custom instance data slot.
        """
        ...

class ChaosDestructionListener(SceneComponent):
    r"""
    Object allowing for retrieving Chaos Destruction data.
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: ChaosBlueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``breaking_event_request_settings`` (ChaosBreakingEventRequestSettings):  [Read-Write] The settings to use for breaking event listening
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``chaos_solver_actors`` (Set[ChaosSolverActor]):  [Read-Write] Which chaos solver actors we're using. If empty, this listener will fallback to the "world" solver.
    - ``collision_event_request_settings`` (ChaosCollisionEventRequestSettings):  [Read-Write] The settings to use for collision event listening
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``geometry_collection_actors`` (Set[GeometryCollectionActor]):  [Read-Write] Which chaos solver actors we're using. If empty, this listener will fallback to the "world" solver.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_breaking_event_listening_enabled`` (bool):  [Read-Write] Whether or not collision event listening is enabled
    - ``is_collision_event_listening_enabled`` (bool):  [Read-Write] Whether or not collision event listening is enabled
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_removal_event_listening_enabled`` (bool):  [Read-Write] Whether or not removal event listening is enabled
    - ``is_trailing_event_listening_enabled`` (bool):  [Read-Write] Whether or not trailing event listening is enabled
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_breaking_events`` (OnChaosBreakingEvents):  [Read-Write] Called when new breaking events are available.
    - ``on_collision_events`` (OnChaosCollisionEvents):  [Read-Write] Called when new collision events are available.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_removal_events`` (OnChaosRemovalEvents):  [Read-Write] Called when new trailing events are available.
    - ``on_trailing_events`` (OnChaosTrailingEvents):  [Read-Write] Called when new trailing events are available.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``removal_event_request_settings`` (ChaosRemovalEventRequestSettings):  [Read-Write] The settings to use for removal event listening
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``trailing_event_request_settings`` (ChaosTrailingEventRequestSettings):  [Read-Write] The settings to use for trailing event listening
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def is_collision_event_listening_enabled(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether or not collision event listening is enabled
        """
        ...
    @property
    def is_breaking_event_listening_enabled(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether or not collision event listening is enabled
        """
        ...
    @property
    def is_trailing_event_listening_enabled(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether or not trailing event listening is enabled
        """
        ...
    @property
    def is_removal_event_listening_enabled(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether or not removal event listening is enabled
        """
        ...
    @property
    def collision_event_request_settings(self) -> ChaosCollisionEventRequestSettings:
        r"""
        (ChaosCollisionEventRequestSettings):  [Read-Only] The settings to use for collision event listening
        """
        ...
    @property
    def breaking_event_request_settings(self) -> ChaosBreakingEventRequestSettings:
        r"""
        (ChaosBreakingEventRequestSettings):  [Read-Only] The settings to use for breaking event listening
        """
        ...
    @property
    def trailing_event_request_settings(self) -> ChaosTrailingEventRequestSettings:
        r"""
        (ChaosTrailingEventRequestSettings):  [Read-Only] The settings to use for trailing event listening
        """
        ...
    @property
    def removal_event_request_settings(self) -> ChaosRemovalEventRequestSettings:
        r"""
        (ChaosRemovalEventRequestSettings):  [Read-Only] The settings to use for removal event listening
        """
        ...
    @property
    def chaos_solver_actors(self) -> Set[ChaosSolverActor]:
        r"""
        (Set[ChaosSolverActor]):  [Read-Only] Which chaos solver actors we're using. If empty, this listener will fallback to the "world" solver.
        """
        ...
    @property
    def geometry_collection_actors(self) -> Set[GeometryCollectionActor]:
        r"""
        (Set[GeometryCollectionActor]):  [Read-Only] Which chaos solver actors we're using. If empty, this listener will fallback to the "world" solver.
        """
        ...
    @property
    def on_collision_events(self) -> OnChaosCollisionEvents:
        r"""
        (OnChaosCollisionEvents):  [Read-Write] Called when new collision events are available.
        """
        ...
    @on_collision_events.setter
    def on_collision_events(self, value: OnChaosCollisionEvents) -> None:
        ...
    @property
    def on_breaking_events(self) -> OnChaosBreakingEvents:
        r"""
        (OnChaosBreakingEvents):  [Read-Write] Called when new breaking events are available.
        """
        ...
    @on_breaking_events.setter
    def on_breaking_events(self, value: OnChaosBreakingEvents) -> None:
        ...
    @property
    def on_trailing_events(self) -> OnChaosTrailingEvents:
        r"""
        (OnChaosTrailingEvents):  [Read-Write] Called when new trailing events are available.
        """
        ...
    @on_trailing_events.setter
    def on_trailing_events(self, value: OnChaosTrailingEvents) -> None:
        ...
    @property
    def on_removal_events(self) -> OnChaosRemovalEvents:
        r"""
        (OnChaosRemovalEvents):  [Read-Write] Called when new trailing events are available.
        """
        ...
    @on_removal_events.setter
    def on_removal_events(self, value: OnChaosRemovalEvents) -> None:
        ...
    def sort_trailing_events(self, trailing_events: Array[ChaosTrailingEventData], sort_method: ChaosTrailingSortMethod) -> Array[ChaosTrailingEventData]:
        r"""
        x.sort_trailing_events(trailing_events, sort_method) -> Array[ChaosTrailingEventData]
        Sorts trailing events according to the given sort method
        
        Args:
            trailing_events (Array[ChaosTrailingEventData]): 
            sort_method (ChaosTrailingSortMethod): 
        
        Returns:
            Array[ChaosTrailingEventData]: 
        
            trailing_events (Array[ChaosTrailingEventData]):
        """
        ...
    def sort_removal_events(self, removal_events: Array[ChaosRemovalEventData], sort_method: ChaosRemovalSortMethod) -> Array[ChaosRemovalEventData]:
        r"""
        x.sort_removal_events(removal_events, sort_method) -> Array[ChaosRemovalEventData]
        Sorts removal events according to the given sort method
        
        Args:
            removal_events (Array[ChaosRemovalEventData]): 
            sort_method (ChaosRemovalSortMethod): 
        
        Returns:
            Array[ChaosRemovalEventData]: 
        
            removal_events (Array[ChaosRemovalEventData]):
        """
        ...
    def sort_collision_events(self, collision_events: Array[ChaosCollisionEventData], sort_method: ChaosCollisionSortMethod) -> Array[ChaosCollisionEventData]:
        r"""
        x.sort_collision_events(collision_events, sort_method) -> Array[ChaosCollisionEventData]
        Sorts collision events according to the given sort method
        
        Args:
            collision_events (Array[ChaosCollisionEventData]): 
            sort_method (ChaosCollisionSortMethod): 
        
        Returns:
            Array[ChaosCollisionEventData]: 
        
            collision_events (Array[ChaosCollisionEventData]):
        """
        ...
    def sort_breaking_events(self, breaking_events: Array[ChaosBreakingEventData], sort_method: ChaosBreakingSortMethod) -> Array[ChaosBreakingEventData]:
        r"""
        x.sort_breaking_events(breaking_events, sort_method) -> Array[ChaosBreakingEventData]
        Sorts breaking events according to the given sort method
        
        Args:
            breaking_events (Array[ChaosBreakingEventData]): 
            sort_method (ChaosBreakingSortMethod): 
        
        Returns:
            Array[ChaosBreakingEventData]: 
        
            breaking_events (Array[ChaosBreakingEventData]):
        """
        ...
    def set_trailing_event_request_settings(self, settings: ChaosTrailingEventRequestSettings) -> None:
        r"""
        x.set_trailing_event_request_settings(settings) -> None
        Sets trailing event request settings dynamically
        
        Args:
            settings (ChaosTrailingEventRequestSettings):
        """
        ...
    def set_trailing_event_enabled(self, is_enabled: bool) -> None:
        r"""
        x.set_trailing_event_enabled(is_enabled) -> None
        Enables or disables trailing event listening
        
        Args:
            is_enabled (bool):
        """
        ...
    def set_removal_event_request_settings(self, settings: ChaosRemovalEventRequestSettings) -> None:
        r"""
        x.set_removal_event_request_settings(settings) -> None
        Sets removal event request settings dynamically
        
        Args:
            settings (ChaosRemovalEventRequestSettings):
        """
        ...
    def set_removal_event_enabled(self, is_enabled: bool) -> None:
        r"""
        x.set_removal_event_enabled(is_enabled) -> None
        Enables or disables removal event listening
        
        Args:
            is_enabled (bool):
        """
        ...
    def set_collision_event_request_settings(self, settings: ChaosCollisionEventRequestSettings) -> None:
        r"""
        x.set_collision_event_request_settings(settings) -> None
        Sets collision event request settings dynamically
        
        Args:
            settings (ChaosCollisionEventRequestSettings):
        """
        ...
    def set_collision_event_enabled(self, is_enabled: bool) -> None:
        r"""
        x.set_collision_event_enabled(is_enabled) -> None
        Enables or disables collision event listening
        
        Args:
            is_enabled (bool):
        """
        ...
    def set_breaking_event_request_settings(self, settings: ChaosBreakingEventRequestSettings) -> None:
        r"""
        x.set_breaking_event_request_settings(settings) -> None
        Sets breaking event request settings dynamically
        
        Args:
            settings (ChaosBreakingEventRequestSettings):
        """
        ...
    def set_breaking_event_enabled(self, is_enabled: bool) -> None:
        r"""
        x.set_breaking_event_enabled(is_enabled) -> None
        Enables or disables breaking event listening
        
        Args:
            is_enabled (bool):
        """
        ...
    def remove_geometry_collection_actor(self, geometry_collection_actor: GeometryCollectionActor) -> None:
        r"""
        x.remove_geometry_collection_actor(geometry_collection_actor) -> None
        Dynamically removes a chaos solver from the listener
        
        Args:
            geometry_collection_actor (GeometryCollectionActor):
        """
        ...
    def remove_chaos_solver_actor(self, chaos_solver_actor: ChaosSolverActor) -> None:
        r"""
        x.remove_chaos_solver_actor(chaos_solver_actor) -> None
        Dynamically removes a chaos solver from the listener
        
        Args:
            chaos_solver_actor (ChaosSolverActor):
        """
        ...
    def is_event_listening(self) -> bool:
        r"""
        x.is_event_listening() -> bool
        Returns if the destruction listener is listening to any events
        
        Returns:
            bool:
        """
        ...
    def add_geometry_collection_actor(self, geometry_collection_actor: GeometryCollectionActor) -> None:
        r"""
        x.add_geometry_collection_actor(geometry_collection_actor) -> None
        Dynamically adds a chaos solver to the listener
        
        Args:
            geometry_collection_actor (GeometryCollectionActor):
        """
        ...
    def add_chaos_solver_actor(self, chaos_solver_actor: ChaosSolverActor) -> None:
        r"""
        x.add_chaos_solver_actor(chaos_solver_actor) -> None
        Dynamically adds a chaos solver to the listener
        
        Args:
            chaos_solver_actor (ChaosSolverActor):
        """
        ...

class GeometryCollectionActor(Actor):
    r"""
    Geometry Collection Actor
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``geometry_collection_component`` (GeometryCollectionComponent):  [Read-Only] GeometryCollectionComponent
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def geometry_collection_component(self) -> GeometryCollectionComponent:
        r"""
        (GeometryCollectionComponent):  [Read-Only] GeometryCollectionComponent
        """
        ...
    def raycast_single(self, start: Vector, end: Vector) -> Optional[HitResult]:
        r"""
        x.raycast_single(start, end) -> HitResult or None
        Raycast Single
        
        Args:
            start (Vector): 
            end (Vector): 
        
        Returns:
            HitResult or None: 
        
            out_hit (HitResult):
        """
        ...

class GeometryCollectionComponent(MeshComponent):
    r"""
    GeometryCollectionComponent
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``abandoned_collision_profile_name`` (Name):  [Read-Write] Whether abandoned particles on the client should continue to have collision (i.e.
      still be in the external/internal acceleration structure).
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``allow_removal_on_break`` (bool):  [Read-Write] Allow removal on break for the instance if the rest collection has it enabled
    - ``allow_removal_on_sleep`` (bool):  [Read-Write] Allow removal on sleep for the instance if the rest collection has it enabled
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``angular_ether_drag`` (float):  [Read-Write] Uniform angular ether drag.
      deprecated: Use PhysicalMaterial instead.
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cache_playback`` (bool):  [Read-Only]
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``chaos_solver_actor`` (ChaosSolverActor):  [Read-Write] Chaos RBD Solver override. Will use the world's default solver actor if null.
    - ``cluster_connection_type`` (ClusterConnectionTypeEnum):  [Read-Write]
      deprecated: Connection types are defined on the asset now.
    - ``cluster_group_index`` (int32):  [Read-Write] Maximum level for cluster breaks.
    - ``collision_group`` (int32):  [Read-Write]
    - ``collision_profile_per_level`` (Array[Name]):  [Read-Write] A per-level collision profile name. If the name is set to NONE or an invalid collision profile, nothing will be changed.
      If the there are more levels than elements in this array, then each level will use the index that best matches it.
      For example, if the particle is level 2, and there is only 1 element in the array, then the particle will use the 0th
      collision profile. AbandonedCollisionProfileName will override this on the client when relevant.
    - ``collision_sample_fraction`` (float):  [Read-Write] Fraction of collision sample particles to keep
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``crumbling_event_includes_children`` (bool):  [Read-Write] If this and bNotifyCrumblings are true, the crumbling events will contain released children indices.
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``custom_renderer_type`` (type(Class)):  [Read-Write] Custom class type that will be used to render the geometry collection instead of using the native rendering.
    - ``damage_model`` (DamageModelTypeEnum):  [Read-Write] Damage model to use for evaluating destruction.
    - ``damage_propagation_data`` (GeometryCollectionDamagePropagationData):  [Read-Write] Data about how damage propagation shoudl behave.
    - ``damage_threshold`` (Array[float]):  [Read-Write]
    - ``density_from_physics_material`` (bool):  [Read-Write] when true, density will be used to compute mass using the assigned physics material
    - ``desired_cache_time`` (float):  [Read-Only]
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_abandon_after_level`` (bool):  [Read-Write] Enables use of ReplicationAbandonAfterLevel to stop providing network updates to
      clients when the updated particle is of a level higher then specified.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_clustering`` (bool):  [Read-Write]
    - ``enable_damage_from_collision`` (bool):  [Read-Write] Whether or not collisions against this geometry collection will apply strain which could cause the geometry collection to fracture.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``enable_replication`` (bool):  [Read-Write] Per-instance override to enable/disable replication for the geometry collection
    - ``enable_run_time_data_collection`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_motion_blur`` (bool):  [Read-Write] If ForceMotionBlur is on, motion blur will always be active, even if the GeometryCollection is at rest.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``global_crumbling_event_includes_children`` (bool):  [Read-Write] If this and bNotifyGlobalCrumblings are true, the crumbling events will contain released children indices.
    - ``gravity_group_index`` (int32):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``initial_angular_velocity`` (Vector):  [Read-Write]
    - ``initial_linear_velocity`` (Vector):  [Read-Write]
    - ``initial_velocity_type`` (InitialVelocityTypeEnum):  [Read-Write]
    - ``initialization_fields`` (Array[FieldSystemActor]):  [Read-Write]
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``linear_ether_drag`` (float):  [Read-Write] Uniform linear ether drag.
      deprecated: Use PhysicalMaterial instead.
    - ``max_cluster_level`` (int32):  [Read-Write] Maximum level for cluster breaks.
    - ``max_simulated_level`` (int32):  [Read-Write] The maximum level to create rigid bodies that could be simulated.
            Example: If we have a Geometry Collection with 2 levels, where:
            0 = Root
            1 = Clusters
            2 = Leaf Nodes
            A setting of '1' would only generate a physics representation of the Root transform and Level 1 clusters.
            The leaf nodes on Level 2 would never be created on the solver, and would therefore never be considered as part of the simulation.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``notify_breaks`` (bool):  [Read-Write] If true, this component will generate breaking events that other systems may subscribe to.
    - ``notify_collisions`` (bool):  [Read-Write] If true, this component will generate collision events that other systems may subscribe to.
    - ``notify_crumblings`` (bool):  [Read-Write] If true, this component will generate crumbling events that other systems may subscribe to.
    - ``notify_geometry_collection_physics_loading_state_change`` (NotifyGeometryCollectionPhysicsLoadingStateChange):  [Read-Write]
    - ``notify_geometry_collection_physics_state_change`` (NotifyGeometryCollectionPhysicsStateChange):  [Read-Write]
    - ``notify_global_breaks`` (bool):  [Read-Write] If true, this component will generate breaking events that will be listened by the global event relay.
    - ``notify_global_collisions`` (bool):  [Read-Write] If true, this component will generate collision events  that will be listened by the global event relay.
    - ``notify_global_crumblings`` (bool):  [Read-Write] If true, this component will generate crumbling events  that will be listened by the global event relay.
    - ``notify_global_removals`` (bool):  [Read-Write] If true, this component will generate removal events  that will be listened by the global event relay.
    - ``notify_removals`` (bool):  [Read-Write] If true, this component will generate removal events that other systems may subscribe to.
    - ``notify_trailing`` (bool):  [Read-Write] If true, this component will generate trailing events that other systems may subscribe to.
    - ``object_type`` (ObjectStateTypeEnum):  [Read-Write] ObjectType defines how to initialize the rigid objects state, Kinematic, Sleeping, Dynamic.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_chaos_break_event`` (OnChaosBreakEvent):  [Read-Write]
    - ``on_chaos_crumbling_event`` (OnChaosCrumblingEvent):  [Read-Write]
    - ``on_chaos_physics_collision`` (OnChaosPhysicsCollision):  [Read-Write]
    - ``on_chaos_removal_event`` (OnChaosRemovalEvent):  [Read-Write]
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``one_way_interaction_level`` (int32):  [Read-Write] All bodies with a level greater than or equal to this will have One-Way Interaction enabled and act like debris (will not apply forces to non-debris bodies)
      Set to -1 to disable (no bodies will have One-Way Interaction enabled)
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_custom_renderer`` (bool):  [Read-Write] If true, CustomRendererType will be used. If false, CustomRendererType comes from the RestCollection.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physical_material`` (ChaosPhysicalMaterial):  [Read-Write] Physical Properties
      deprecated: Physical material now derived from render materials, for instance overrides use PhysicalMaterialOverride.
    - ``physical_material_override`` (PhysicalMaterial):  [Read-Write]
      deprecated: Physical material now derived from render materials, for instance overrides use Colliisons PhysicalMaterialOverride.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``replication_abandon_after_level`` (int32):  [Read-Write] If replicating - the cluster level after which replication will not happen
      see: bEnableAbandonAfterLevel
    - ``replication_abandon_cluster_level`` (int32):  [Read-Write] If replicating - the cluster level to stop sending corrections for geometry collection chunks.
      recommended for smaller leaf levels when the size of the objects means they are no longer
      gameplay relevant to cut down on required bandwidth to update a collection.
      See: bEnableAbandonAfterLevel
      deprecated: GeometryCollection now uses ReplicationAbandonAfterLevel instead of ReplicationAbandonClusterLevel.
    - ``replication_max_position_and_velocity_correction_level`` (int32):  [Read-Write] If replicating - the maximum level where clusters will have their position and velocity send over to the client for tracking and correcting
      When breaking, client will only receive the initial break velocity
      This helps save bandwidth where only the destruction state of the GC is to be replicated but the falling pieces do not need to be tracked precisely
      note: This will have an effect only if set to a value less than ReplicationAbandonAfterLevel
      see: ReplicationAbandonAfterLevel
    - ``rest_collection`` (GeometryCollection):  [Read-Write]
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``run_time_data_collection_guid`` (Guid):  [Read-Write]
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``show_bone_colors`` (bool):  [Read-Write] Display Bone Colors instead of assigned materials
    - ``simulating`` (bool):  [Read-Write]
      deprecated: GeometryCollection now abides the bSimulatePhysics flag from the base class.
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``store_velocities`` (bool):  [Read-Write] If true, this component will save linear and angular velocities on its DynamicCollection.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``update_component_transform_to_root_bone`` (bool):  [Read-Write] Relocate the component so that the original offset to the root bone is maintained
      This only works when the root bone is moving whole being dynamically simulated
      Note: Once the root element is broken, the component will no longer update its position
    - ``update_navigation_in_tick`` (bool):  [Read-Write]
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_material_damage_modifiers`` (bool):  [Read-Write] When on , use the modifiers on the material to adjust the user defined damage threshold values
    - ``use_root_proxy_for_navigation`` (bool):  [Read-Write]
    - ``use_size_specific_damage_threshold`` (bool):  [Read-Write] Damage threshold for clusters at different levels.
    - ``use_static_mesh_collision_for_traces`` (bool):  [Read-Write] todo(chaos): Remove the ability to change this at runtime, as we'll want to use this at cook time instead
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def rest_collection(self) -> GeometryCollection:
        r"""
        (GeometryCollection):  [Read-Only]
        """
        ...
    @property
    def initialization_fields(self) -> Array[FieldSystemActor]:
        r"""
        (Array[FieldSystemActor]):  [Read-Only]
        """
        ...
    @property
    def simulating(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: GeometryCollection now abides the bSimulatePhysics flag from the base class.
        """
        ...
    @simulating.setter
    def simulating(self, value: bool) -> None:
        ...
    @property
    def object_type(self) -> ObjectStateTypeEnum:
        r"""
        (ObjectStateTypeEnum):  [Read-Write] ObjectType defines how to initialize the rigid objects state, Kinematic, Sleeping, Dynamic.
        """
        ...
    @object_type.setter
    def object_type(self, value: ObjectStateTypeEnum) -> None:
        ...
    @property
    def gravity_group_index(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @gravity_group_index.setter
    def gravity_group_index(self, value: int) -> None:
        ...
    @property
    def one_way_interaction_level(self) -> int:
        r"""
        (int32):  [Read-Write] All bodies with a level greater than or equal to this will have One-Way Interaction enabled and act like debris (will not apply forces to non-debris bodies)
        Set to -1 to disable (no bodies will have One-Way Interaction enabled)
        """
        ...
    @one_way_interaction_level.setter
    def one_way_interaction_level(self, value: int) -> None:
        ...
    @property
    def density_from_physics_material(self) -> bool:
        r"""
        (bool):  [Read-Write] when true, density will be used to compute mass using the assigned physics material
        """
        ...
    @density_from_physics_material.setter
    def density_from_physics_material(self, value: bool) -> None:
        ...
    @property
    def force_motion_blur(self) -> bool:
        r"""
        (bool):  [Read-Write] If ForceMotionBlur is on, motion blur will always be active, even if the GeometryCollection is at rest.
        """
        ...
    @force_motion_blur.setter
    def force_motion_blur(self, value: bool) -> None:
        ...
    @property
    def enable_clustering(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @enable_clustering.setter
    def enable_clustering(self, value: bool) -> None:
        ...
    @property
    def cluster_group_index(self) -> int:
        r"""
        (int32):  [Read-Write] Maximum level for cluster breaks.
        """
        ...
    @cluster_group_index.setter
    def cluster_group_index(self, value: int) -> None:
        ...
    @property
    def max_cluster_level(self) -> int:
        r"""
        (int32):  [Read-Write] Maximum level for cluster breaks.
        """
        ...
    @max_cluster_level.setter
    def max_cluster_level(self, value: int) -> None:
        ...
    @property
    def max_simulated_level(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum level to create rigid bodies that could be simulated.
              Example: If we have a Geometry Collection with 2 levels, where:
              0 = Root
              1 = Clusters
              2 = Leaf Nodes
              A setting of '1' would only generate a physics representation of the Root transform and Level 1 clusters.
              The leaf nodes on Level 2 would never be created on the solver, and would therefore never be considered as part of the simulation.
        """
        ...
    @max_simulated_level.setter
    def max_simulated_level(self, value: int) -> None:
        ...
    @property
    def damage_model(self) -> DamageModelTypeEnum:
        r"""
        (DamageModelTypeEnum):  [Read-Write] Damage model to use for evaluating destruction.
        """
        ...
    @damage_model.setter
    def damage_model(self, value: DamageModelTypeEnum) -> None:
        ...
    @property
    def damage_threshold(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Write]
        """
        ...
    @damage_threshold.setter
    def damage_threshold(self, value: Array[float]) -> None:
        ...
    @property
    def use_size_specific_damage_threshold(self) -> bool:
        r"""
        (bool):  [Read-Write] Damage threshold for clusters at different levels.
        """
        ...
    @use_size_specific_damage_threshold.setter
    def use_size_specific_damage_threshold(self, value: bool) -> None:
        ...
    @property
    def use_material_damage_modifiers(self) -> bool:
        r"""
        (bool):  [Read-Write] When on , use the modifiers on the material to adjust the user defined damage threshold values
        """
        ...
    @use_material_damage_modifiers.setter
    def use_material_damage_modifiers(self, value: bool) -> None:
        ...
    @property
    def damage_propagation_data(self) -> GeometryCollectionDamagePropagationData:
        r"""
        (GeometryCollectionDamagePropagationData):  [Read-Write] Data about how damage propagation shoudl behave.
        """
        ...
    @damage_propagation_data.setter
    def damage_propagation_data(self, value: GeometryCollectionDamagePropagationData) -> None:
        ...
    @property
    def enable_damage_from_collision(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not collisions against this geometry collection will apply strain which could cause the geometry collection to fracture.
        """
        ...
    @enable_damage_from_collision.setter
    def enable_damage_from_collision(self, value: bool) -> None:
        ...
    @property
    def allow_removal_on_sleep(self) -> bool:
        r"""
        (bool):  [Read-Write] Allow removal on sleep for the instance if the rest collection has it enabled
        """
        ...
    @allow_removal_on_sleep.setter
    def allow_removal_on_sleep(self, value: bool) -> None:
        ...
    @property
    def allow_removal_on_break(self) -> bool:
        r"""
        (bool):  [Read-Write] Allow removal on break for the instance if the rest collection has it enabled
        """
        ...
    @allow_removal_on_break.setter
    def allow_removal_on_break(self, value: bool) -> None:
        ...
    @property
    def cluster_connection_type(self) -> ClusterConnectionTypeEnum:
        r"""
        (ClusterConnectionTypeEnum):  [Read-Write]
        deprecated: Connection types are defined on the asset now.
        """
        ...
    @cluster_connection_type.setter
    def cluster_connection_type(self, value: ClusterConnectionTypeEnum) -> None:
        ...
    @property
    def collision_group(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @collision_group.setter
    def collision_group(self, value: int) -> None:
        ...
    @property
    def collision_sample_fraction(self) -> float:
        r"""
        (float):  [Read-Write] Fraction of collision sample particles to keep
        """
        ...
    @collision_sample_fraction.setter
    def collision_sample_fraction(self, value: float) -> None:
        ...
    @property
    def linear_ether_drag(self) -> float:
        r"""
        (float):  [Read-Write] Uniform linear ether drag.
        deprecated: Use PhysicalMaterial instead.
        """
        ...
    @linear_ether_drag.setter
    def linear_ether_drag(self, value: float) -> None:
        ...
    @property
    def angular_ether_drag(self) -> float:
        r"""
        (float):  [Read-Write] Uniform angular ether drag.
        deprecated: Use PhysicalMaterial instead.
        """
        ...
    @angular_ether_drag.setter
    def angular_ether_drag(self, value: float) -> None:
        ...
    @property
    def physical_material(self) -> ChaosPhysicalMaterial:
        r"""
        (ChaosPhysicalMaterial):  [Read-Write] Physical Properties
        deprecated: Physical material now derived from render materials, for instance overrides use PhysicalMaterialOverride.
        """
        ...
    @physical_material.setter
    def physical_material(self, value: ChaosPhysicalMaterial) -> None:
        ...
    @property
    def initial_velocity_type(self) -> InitialVelocityTypeEnum:
        r"""
        (InitialVelocityTypeEnum):  [Read-Write]
        """
        ...
    @initial_velocity_type.setter
    def initial_velocity_type(self, value: InitialVelocityTypeEnum) -> None:
        ...
    @property
    def initial_linear_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @initial_linear_velocity.setter
    def initial_linear_velocity(self, value: Vector) -> None:
        ...
    @property
    def initial_angular_velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @initial_angular_velocity.setter
    def initial_angular_velocity(self, value: Vector) -> None:
        ...
    @property
    def physical_material_override(self) -> PhysicalMaterial:
        r"""
        (PhysicalMaterial):  [Read-Write]
        deprecated: Physical material now derived from render materials, for instance overrides use Colliisons PhysicalMaterialOverride.
        """
        ...
    @physical_material_override.setter
    def physical_material_override(self, value: PhysicalMaterial) -> None:
        ...
    @property
    def notify_geometry_collection_physics_state_change(self) -> NotifyGeometryCollectionPhysicsStateChange:
        r"""
        (NotifyGeometryCollectionPhysicsStateChange):  [Read-Write]
        """
        ...
    @notify_geometry_collection_physics_state_change.setter
    def notify_geometry_collection_physics_state_change(self, value: NotifyGeometryCollectionPhysicsStateChange) -> None:
        ...
    @property
    def notify_geometry_collection_physics_loading_state_change(self) -> NotifyGeometryCollectionPhysicsLoadingStateChange:
        r"""
        (NotifyGeometryCollectionPhysicsLoadingStateChange):  [Read-Write]
        """
        ...
    @notify_geometry_collection_physics_loading_state_change.setter
    def notify_geometry_collection_physics_loading_state_change(self, value: NotifyGeometryCollectionPhysicsLoadingStateChange) -> None:
        ...
    @property
    def on_chaos_break_event(self) -> OnChaosBreakEvent:
        r"""
        (OnChaosBreakEvent):  [Read-Write]
        """
        ...
    @on_chaos_break_event.setter
    def on_chaos_break_event(self, value: OnChaosBreakEvent) -> None:
        ...
    @property
    def on_chaos_removal_event(self) -> OnChaosRemovalEvent:
        r"""
        (OnChaosRemovalEvent):  [Read-Write]
        """
        ...
    @on_chaos_removal_event.setter
    def on_chaos_removal_event(self, value: OnChaosRemovalEvent) -> None:
        ...
    @property
    def on_chaos_crumbling_event(self) -> OnChaosCrumblingEvent:
        r"""
        (OnChaosCrumblingEvent):  [Read-Write]
        """
        ...
    @on_chaos_crumbling_event.setter
    def on_chaos_crumbling_event(self, value: OnChaosCrumblingEvent) -> None:
        ...
    @property
    def desired_cache_time(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def cache_playback(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def on_chaos_physics_collision(self) -> OnChaosPhysicsCollision:
        r"""
        (OnChaosPhysicsCollision):  [Read-Write]
        """
        ...
    @on_chaos_physics_collision.setter
    def on_chaos_physics_collision(self, value: OnChaosPhysicsCollision) -> None:
        ...
    @property
    def notify_breaks(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will generate breaking events that other systems may subscribe to.
        """
        ...
    @property
    def notify_collisions(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will generate collision events that other systems may subscribe to.
        """
        ...
    @property
    def notify_trailing(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will generate trailing events that other systems may subscribe to.
        """
        ...
    @property
    def notify_removals(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will generate removal events that other systems may subscribe to.
        """
        ...
    @property
    def notify_crumblings(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will generate crumbling events that other systems may subscribe to.
        """
        ...
    @property
    def crumbling_event_includes_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If this and bNotifyCrumblings are true, the crumbling events will contain released children indices.
        """
        ...
    @property
    def notify_global_breaks(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will generate breaking events that will be listened by the global event relay.
        """
        ...
    @property
    def notify_global_collisions(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will generate collision events  that will be listened by the global event relay.
        """
        ...
    @property
    def notify_global_removals(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will generate removal events  that will be listened by the global event relay.
        """
        ...
    @property
    def notify_global_crumblings(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will generate crumbling events  that will be listened by the global event relay.
        """
        ...
    @property
    def global_crumbling_event_includes_children(self) -> bool:
        r"""
        (bool):  [Read-Only] If this and bNotifyGlobalCrumblings are true, the crumbling events will contain released children indices.
        """
        ...
    @property
    def store_velocities(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will save linear and angular velocities on its DynamicCollection.
        """
        ...
    @property
    def show_bone_colors(self) -> bool:
        r"""
        (bool):  [Read-Write] Display Bone Colors instead of assigned materials
        """
        ...
    @show_bone_colors.setter
    def show_bone_colors(self, value: bool) -> None:
        ...
    @property
    def update_component_transform_to_root_bone(self) -> bool:
        r"""
        (bool):  [Read-Write] Relocate the component so that the original offset to the root bone is maintained
        This only works when the root bone is moving whole being dynamically simulated
        Note: Once the root element is broken, the component will no longer update its position
        """
        ...
    @update_component_transform_to_root_bone.setter
    def update_component_transform_to_root_bone(self, value: bool) -> None:
        ...
    @property
    def use_root_proxy_for_navigation(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @use_root_proxy_for_navigation.setter
    def use_root_proxy_for_navigation(self, value: bool) -> None:
        ...
    @property
    def update_navigation_in_tick(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @update_navigation_in_tick.setter
    def update_navigation_in_tick(self, value: bool) -> None:
        ...
    @property
    def run_time_data_collection_guid(self) -> Guid:
        r"""
        (Guid):  [Read-Only]
        """
        ...
    @property
    def override_custom_renderer(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, CustomRendererType will be used. If false, CustomRendererType comes from the RestCollection.
        """
        ...
    @override_custom_renderer.setter
    def override_custom_renderer(self, value: bool) -> None:
        ...
    @property
    def custom_renderer_type(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Custom class type that will be used to render the geometry collection instead of using the native rendering.
        """
        ...
    @custom_renderer_type.setter
    def custom_renderer_type(self, value: Class) -> None:
        ...
    @property
    def enable_replication(self) -> bool:
        r"""
        (bool):  [Read-Write] Per-instance override to enable/disable replication for the geometry collection
        """
        ...
    @enable_replication.setter
    def enable_replication(self, value: bool) -> None:
        ...
    @property
    def enable_abandon_after_level(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables use of ReplicationAbandonAfterLevel to stop providing network updates to
        clients when the updated particle is of a level higher then specified.
        """
        ...
    @enable_abandon_after_level.setter
    def enable_abandon_after_level(self, value: bool) -> None:
        ...
    @property
    def abandoned_collision_profile_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Whether abandoned particles on the client should continue to have collision (i.e.
        still be in the external/internal acceleration structure).
        """
        ...
    @abandoned_collision_profile_name.setter
    def abandoned_collision_profile_name(self, value: Name) -> None:
        ...
    @property
    def collision_profile_per_level(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] A per-level collision profile name. If the name is set to NONE or an invalid collision profile, nothing will be changed.
        If the there are more levels than elements in this array, then each level will use the index that best matches it.
        For example, if the particle is level 2, and there is only 1 element in the array, then the particle will use the 0th
        collision profile. AbandonedCollisionProfileName will override this on the client when relevant.
        """
        ...
    @collision_profile_per_level.setter
    def collision_profile_per_level(self, value: Array[Name]) -> None:
        ...
    @property
    def replication_abandon_cluster_level(self) -> int:
        r"""
        (int32):  [Read-Write] If replicating - the cluster level to stop sending corrections for geometry collection chunks.
        recommended for smaller leaf levels when the size of the objects means they are no longer
        gameplay relevant to cut down on required bandwidth to update a collection.
        See: bEnableAbandonAfterLevel
        deprecated: GeometryCollection now uses ReplicationAbandonAfterLevel instead of ReplicationAbandonClusterLevel.
        """
        ...
    @replication_abandon_cluster_level.setter
    def replication_abandon_cluster_level(self, value: int) -> None:
        ...
    @property
    def replication_abandon_after_level(self) -> int:
        r"""
        (int32):  [Read-Write] If replicating - the cluster level after which replication will not happen
        see: bEnableAbandonAfterLevel
        """
        ...
    @replication_abandon_after_level.setter
    def replication_abandon_after_level(self, value: int) -> None:
        ...
    @property
    def replication_max_position_and_velocity_correction_level(self) -> int:
        r"""
        (int32):  [Read-Write] If replicating - the maximum level where clusters will have their position and velocity send over to the client for tracking and correcting
        When breaking, client will only receive the initial break velocity
        This helps save bandwidth where only the destruction state of the GC is to be replicated but the falling pieces do not need to be tracked precisely
        note: This will have an effect only if set to a value less than ReplicationAbandonAfterLevel
        see: ReplicationAbandonAfterLevel
        """
        ...
    @replication_max_position_and_velocity_correction_level.setter
    def replication_max_position_and_velocity_correction_level(self, value: int) -> None:
        ...
    @property
    def use_static_mesh_collision_for_traces(self) -> bool:
        r"""
        (bool):  [Read-Write] todo(chaos): Remove the ability to change this at runtime, as we'll want to use this at cook time instead
        """
        ...
    @use_static_mesh_collision_for_traces.setter
    def use_static_mesh_collision_for_traces(self, value: bool) -> None:
        ...
    def set_rest_collection(self, rest_collection_in: GeometryCollection, apply_asset_defaults: bool = True) -> None:
        r"""
        x.set_rest_collection(rest_collection_in, apply_asset_defaults=True) -> None
        RestCollection
        
        Args:
            rest_collection_in (GeometryCollection): 
            apply_asset_defaults (bool):
        """
        ...
    def set_per_particle_collision_profile_name(self, bone_ids: Array[int], profile_name: Name) -> None:
        r"""
        x.set_per_particle_collision_profile_name(bone_ids, profile_name) -> None
        Set Per Particle Collision Profile Name
        
        Args:
            bone_ids (Array[int32]): 
            profile_name (Name):
        """
        ...
    def set_per_level_collision_profile_names(self, profile_names: Array[Name]) -> None:
        r"""
        x.set_per_level_collision_profile_names(profile_names) -> None
        Set Per Level Collision Profile Names
        
        Args:
            profile_names (Array[Name]):
        """
        ...
    def set_notify_removals(self, new_notify_removals: bool) -> None:
        r"""
        x.set_notify_removals(new_notify_removals) -> None
        Changes whether or not this component will get future removal notifications.
        
        Args:
            new_notify_removals (bool):
        """
        ...
    def set_notify_global_removals(self, new_notify_global_removals: bool) -> None:
        r"""
        x.set_notify_global_removals(new_notify_global_removals) -> None
        Changes whether or not this component will get future global removal notifications.
        
        Args:
            new_notify_global_removals (bool):
        """
        ...
    def set_notify_global_crumblings(self, new_notify_global_crumblings: bool, global_new_crumbling_event_includes_children: bool) -> None:
        r"""
        x.set_notify_global_crumblings(new_notify_global_crumblings, global_new_crumbling_event_includes_children) -> None
        Changes whether or not this component will get future global crumbling notifications.
        
        Args:
            new_notify_global_crumblings (bool): 
            global_new_crumbling_event_includes_children (bool):
        """
        ...
    def set_notify_global_collision(self, new_notify_global_collisions: bool) -> None:
        r"""
        x.set_notify_global_collision(new_notify_global_collisions) -> None
        Changes whether or not this component will get future global collision notifications.
        
        Args:
            new_notify_global_collisions (bool):
        """
        ...
    def set_notify_global_breaks(self, new_notify_global_breaks: bool) -> None:
        r"""
        x.set_notify_global_breaks(new_notify_global_breaks) -> None
        Changes whether or not this component will get future global break notifications.
        
        Args:
            new_notify_global_breaks (bool):
        """
        ...
    def set_notify_crumblings(self, new_notify_crumblings: bool, new_crumbling_event_includes_children: bool = False) -> None:
        r"""
        x.set_notify_crumblings(new_notify_crumblings, new_crumbling_event_includes_children=False) -> None
        Changes whether or not this component will get future crumbling notifications.
        
        Args:
            new_notify_crumblings (bool): 
            new_crumbling_event_includes_children (bool):
        """
        ...
    def set_notify_breaks(self, new_notify_breaks: bool) -> None:
        r"""
        x.set_notify_breaks(new_notify_breaks) -> None
        Changes whether or not this component will get future break notifications.
        
        Args:
            new_notify_breaks (bool):
        """
        ...
    def set_local_rest_transforms(self, transforms: Array[Transform], only_leaves: bool) -> None:
        r"""
        x.set_local_rest_transforms(transforms, only_leaves) -> None
        Set the local rest transform, this may be different from the rest collection
        If the geometry collection is already simulating those matrices will be overriden by the physics state updates
        
        Args:
            transforms (Array[Transform]): 
            only_leaves (bool):
        """
        ...
    def set_enable_damage_from_collision(self, value: bool) -> None:
        r"""
        x.set_enable_damage_from_collision(value) -> None
        Set Enable Damage from Collision
        
        Args:
            value (bool):
        """
        ...
    def set_anchored_by_transformed_box(self, box: Box, transform: Transform, anchored: bool, max_level: int = -1) -> None:
        r"""
        x.set_anchored_by_transformed_box(box, transform, anchored, max_level=-1) -> None
        Set all pieces within a world transformed bounding box to be anchored or not
        
        Args:
            box (Box): 
            transform (Transform): 
            anchored (bool): 
            max_level (int32):
        """
        ...
    def set_anchored_by_index(self, index: int, anchored: bool) -> None:
        r"""
        x.set_anchored_by_index(index, anchored) -> None
        Set a piece or cluster to be anchored or not
        
        Args:
            index (int32): 
            anchored (bool):
        """
        ...
    def set_anchored_by_box(self, world_space_box: Box, anchored: bool, max_level: int = -1) -> None:
        r"""
        x.set_anchored_by_box(world_space_box, anchored, max_level=-1) -> None
        Set all pieces within a world space bounding box to be anchored or not
        
        Args:
            world_space_box (Box): 
            anchored (bool): 
            max_level (int32):
        """
        ...
    def set_abandoned_particle_collision_profile_name(self, collision_profile: Name) -> None:
        r"""
        x.set_abandoned_particle_collision_profile_name(collision_profile) -> None
        Set Abandoned Particle Collision Profile Name
        
        Args:
            collision_profile (Name):
        """
        ...
    def remove_all_anchors(self) -> None:
        r"""
        x.remove_all_anchors() -> None
        this will remove anchors on all the pieces ( including the static and kinematic initial states ones ) of the geometry colection
        """
        ...
    def receive_physics_collision(self, collision_info: ChaosPhysicsCollisionInfo) -> None:
        r"""
        x.receive_physics_collision(collision_info) -> None
        Receive Physics Collision
        
        Args:
            collision_info (ChaosPhysicsCollisionInfo):
        """
        ...
    def is_root_broken(self) -> bool:
        r"""
        x.is_root_broken() -> bool
        return true if the root cluster is not longer active at runtime
        
        Returns:
            bool:
        """
        ...
    def get_root_initial_transform(self) -> Transform:
        r"""
        x.get_root_initial_transform() -> Transform
        Get the root item initial transform in world space
        
        Returns:
            Transform:
        """
        ...
    def get_root_index(self) -> int:
        r"""
        x.get_root_index() -> int32
        Get the root item index of the hierarchy
        
        Returns:
            int32:
        """
        ...
    def get_root_current_transform(self) -> Transform:
        r"""
        x.get_root_current_transform() -> Transform
        Get the root item current world transform
        
        Returns:
            Transform:
        """
        ...
    def get_mass_and_extents(self, item_index: int) -> Tuple[float, Box]:
        r"""
        x.get_mass_and_extents(item_index) -> (out_mass=float, out_extents=Box)
        Get mass and extent of a specific piece
        
        Args:
            item_index (int32): item index ( from HitResult) of the cluster to get level from
        
        Returns:
            tuple: 
        
            out_mass (float): 
        
            out_extents (Box):
        """
        ...
    def get_local_bounds(self) -> Box:
        r"""
        x.get_local_bounds() -> Box
        Get local bounds of the geometry collection
        
        Returns:
            Box:
        """
        ...
    def get_initial_local_rest_transforms(self) -> Array[Transform]:
        r"""
        x.get_initial_local_rest_transforms() -> Array[Transform]
        Get the initial rest transforms in component (local) space  space,
        they are the transforms as defined in the rest collection asset
        
        Returns:
            Array[Transform]:
        """
        ...
    def get_initial_level(self, item_index: int) -> int:
        r"""
        x.get_initial_level(item_index) -> int32
        Get the initial level of a specific piece
        Initial level means the level as it is in the unbroken state
        
        Args:
            item_index (int32): item index ( from HitResult) of the cluster to get level from
        
        Returns:
            int32:
        """
        ...
    def get_debug_info(self) -> str:
        r"""
        x.get_debug_info() -> str
        RestCollection
        
        Returns:
            str:
        """
        ...
    def enable_root_proxy_for_custom_renderer(self, enable: bool) -> None:
        r"""
        x.enable_root_proxy_for_custom_renderer(enable) -> None
        Enable or disable root proxy for custom rendering - this can be set at runtime
        
        Args:
            enable (bool):
        """
        ...
    def crumble_cluster(self, item_index: int) -> None:
        r"""
        x.crumble_cluster(item_index) -> None
        Crumbe a cluster into all its pieces
        
        Args:
            item_index (int32): item index ( from HitResult) of the cluster to crumble
        """
        ...
    def crumble_active_clusters(self) -> None:
        r"""
        x.crumble_active_clusters() -> None
        Crumbe active clusters for this entire geometry collection
        this will apply to internal and regular clusters
        """
        ...
    def apply_physics_field(self, enabled: bool, target: GeometryCollectionPhysicsTypeEnum, meta_data: FieldSystemMetaData, field: FieldNodeBase) -> None:
        r"""
        x.apply_physics_field(enabled, target, meta_data, field) -> None
        AddPhysicsField
          This function will dispatch a command to the physics thread to apply
          a generic evaluation of a user defined transient field network. See documentation,
          for examples of how to recreate variations of the above generic
          fields using field networks
        
        Args:
            enabled (bool): Is this force enabled for evaluation.
            target (GeometryCollectionPhysicsTypeEnum): Type of field supported by the solver.
            meta_data (FieldSystemMetaData): Meta data used to assist in evaluation
            field (FieldNodeBase): Base evaluation node for the field network.
        """
        ...
    def apply_linear_velocity(self, item_index: int, linear_velocity: Vector) -> None:
        r"""
        x.apply_linear_velocity(item_index, linear_velocity) -> None
        Apply linear velocity on specific piece
        
        Args:
            item_index (int32): item index ( from HitResult) of the piece to apply velocity on
            linear_velocity (Vector): linear velocity to apply
        """
        ...
    def apply_kinematic_field(self, radius: float, position: Vector) -> None:
        r"""
        x.apply_kinematic_field(radius, position) -> None
        SetDynamicState
          This function will dispatch a command to the physics thread to apply
          a kinematic to dynamic state change for the geo collection particles within the field.
        
        Args:
            radius (float): Radial influence from the position
            position (Vector): The location of the command
        """
        ...
    def apply_internal_strain(self, item_index: int, location: Vector, radius: float = 0.000000, propagation_depth: int = 0, propagation_factor: float = 1.000000, strain: float = 0.000000) -> None:
        r"""
        x.apply_internal_strain(item_index, location, radius=0.000000, propagation_depth=0, propagation_factor=1.000000, strain=0.000000) -> None
        Apply an internal strain to specific piece of the geometry collection
        
        Args:
            item_index (int32): item index ( from HitResult) of the piece to apply strain on
            location (Vector): world location of where to apply the strain
            radius (float): radius from the location point to apply the strain to ( using the center of mass of the pieces )
            propagation_depth (int32): How many level of connection to follow to propagate the strain through
            propagation_factor (float): when using propagation, the factor to multiply the strain from one level to the other, allowing falloff effect
            strain (float): strain / damage to apply
        """
        ...
    def apply_external_strain(self, item_index: int, location: Vector, radius: float = 0.000000, propagation_depth: int = 0, propagation_factor: float = 1.000000, strain: float = 0.000000) -> None:
        r"""
        x.apply_external_strain(item_index, location, radius=0.000000, propagation_depth=0, propagation_factor=1.000000, strain=0.000000) -> None
        Apply an external strain to specific piece of the geometry collection
        
        Args:
            item_index (int32): item index ( from HitResult) of the piece to apply strain on
            location (Vector): world location of where to apply the strain
            radius (float): radius from the location point to apply the strain to ( using the center of mass of the pieces )
            propagation_depth (int32): How many level of connection to follow to propagate the strain through
            propagation_factor (float): when using propagation, the factor to multiply the strain from one level to the other, allowing falloff effect
            strain (float): strain / damage to apply
        """
        ...
    def apply_breaking_linear_velocity(self, item_index: int, linear_velocity: Vector) -> None:
        r"""
        x.apply_breaking_linear_velocity(item_index, linear_velocity) -> None
        Apply linear velocity on breaking pieces for a specific cluster
        If ItemIndex does not represent a cluster this will do nothing
        
        Args:
            item_index (int32): item index ( from HitResult) of the cluster owning the breaking pieces to apply velocity on
            linear_velocity (Vector): linear velocity to apply
        """
        ...
    def apply_breaking_angular_velocity(self, item_index: int, angular_velocity: Vector) -> None:
        r"""
        x.apply_breaking_angular_velocity(item_index, angular_velocity) -> None
        Apply linear velocity on breaking pieces for a specific cluster
        If ItemIndex does not represent a cluster this will do nothing
        
        Args:
            item_index (int32): item index ( from HitResult) of the cluster owning the breaking pieces to apply velocity on
            angular_velocity (Vector): linear velocity to apply
        """
        ...
    def apply_asset_defaults(self) -> None:
        r"""
        x.apply_asset_defaults() -> None
        Apply default values from asset ( damage related data and physics material )
        """
        ...
    def apply_angular_velocity(self, item_index: int, angular_velocity: Vector) -> None:
        r"""
        x.apply_angular_velocity(item_index, angular_velocity) -> None
        Apply angular velocity on specific piece
        
        Args:
            item_index (int32): item index ( from HitResult) of the piece to apply velocity on
            angular_velocity (Vector): linear velocity to apply
        """
        ...

class GeometryCollectionDebugDrawActor(Actor):
    r"""
    Geometry Collection Debug Draw Actor
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionDebugDrawActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``arrow_scale`` (float):  [Read-Write] Size of arrows used for visualizing normals, breaking information, ...etc.
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``axis_scale`` (float):  [Read-Write] Scale of the axis used for visualizing all transforms.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``bounding_box_color`` (Color):  [Read-Write] Color used for the visualization of the bounding boxes.
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``collision_at_origin`` (bool):  [Read-Write] Show the selected rigid body's collision volume at the origin, in local space.
    - ``connectivity_edge_thickness`` (float):  [Read-Write] Line thickness used for the visualization of the rigid clustering connectivity edges.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``debug_draw_clustering`` (bool):  [Read-Write] Show debug visualization for all clustered children associated to the current rigid body id selection.
    - ``debug_draw_hierarchy`` (bool):  [Read-Write] Show debug visualization for the top level node rather than the bottom leaf nodes of a cluster's hierarchy. * Only affects Clustering and Geometry visualization.
    - ``debug_draw_whole_collection`` (bool):  [Read-Write] Show debug visualization for the rest of the geometry collection related to the current rigid body id selection.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``face_color`` (Color):  [Read-Write] Color used for the visualization of the faces.
    - ``face_index_color`` (Color):  [Read-Write] Color used for the visualization of the face indices.
    - ``face_normal_color`` (Color):  [Read-Write] Color used for the visualization of the face normals.
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``geometry_index_color`` (Color):  [Read-Write] Color used for the visualization of the geometry indices.
    - ``geometry_transform_scale`` (float):  [Read-Write] Scale for geometry transform visualization.
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hide_geometry`` (GeometryCollectionDebugDrawActorHideGeometry):  [Read-Write] Geometry visibility setting. Select the part of the geometry to hide in order to better visualize the debug information.
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``level_color`` (Color):  [Read-Write] Color used for the visualization of the levels.
    - ``line_thickness`` (float):  [Read-Write] Thickness of lines when visualizing faces, normals, ...etc.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``normal_scale`` (float):  [Read-Write] Scale factor used for visualizing normals.
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``parent_color`` (Color):  [Read-Write] Color used for the visualization of the link from the parents.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``point_thickness`` (float):  [Read-Write] Thickness of points when visualizing vertices.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``rigid_body_collision_color`` (Color):  [Read-Write] Color used for collision primitives visualization.
    - ``rigid_body_force_color`` (Color):  [Read-Write] Color used for rigid body applied force and torque visualization.
    - ``rigid_body_id_color`` (Color):  [Read-Write] Color used for the visualization of the rigid body ids.
    - ``rigid_body_inertia_color`` (Color):  [Read-Write] Color used for the visualization of the rigid body inertia tensor box.
    - ``rigid_body_info_color`` (Color):  [Read-Write] Color used for the visualization of the rigid body infos.
    - ``rigid_body_transform_scale`` (float):  [Read-Write] Scale for rigid body transform visualization.
    - ``rigid_body_velocity_color`` (Color):  [Read-Write] Color used for rigid body velocities visualization.
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``show_bounding_box`` (bool):  [Read-Write] Show the bounding box for the selected rigid body's associated geometries.
    - ``show_connectivity_edges`` (bool):  [Read-Write] Show the connectivity edges for the selected rigid body's associated cluster nodes.
    - ``show_face_indices`` (bool):  [Read-Write] Show the face indices for the selected rigid body's associated geometries.
    - ``show_face_normals`` (bool):  [Read-Write] Show the face normals for the selected rigid body's associated geometries.
    - ``show_faces`` (bool):  [Read-Write] Show the faces for the selected rigid body's associated geometries.
    - ``show_geometry_index`` (bool):  [Read-Write] Show the geometry index for the selected rigid body's associated geometries.
    - ``show_geometry_transform`` (bool):  [Read-Write] Show the geometry transform for the selected rigid body's associated geometries.
    - ``show_level`` (bool):  [Read-Write] Show the hierarchical level for the selected rigid body's associated cluster nodes.
    - ``show_parent`` (bool):  [Read-Write] Show a link from the selected rigid body's associated cluster nodes to their parent's nodes.
    - ``show_rigid_body_collision`` (bool):  [Read-Write] Show the selected rigid body's collision volume.
    - ``show_rigid_body_force`` (bool):  [Read-Write] Show the selected rigid body's applied force and torque.
    - ``show_rigid_body_id`` (bool):  [Read-Write] Display the selected rigid body's id.
    - ``show_rigid_body_inertia`` (bool):  [Read-Write] Show the selected rigid body's inertia tensor box.
    - ``show_rigid_body_infos`` (bool):  [Read-Write] Show the selected rigid body's on screen text information.
    - ``show_rigid_body_transform`` (bool):  [Read-Write] Show the selected rigid body's transform.
    - ``show_rigid_body_velocity`` (bool):  [Read-Write] Show the selected rigid body's linear and angular velocity.
    - ``show_single_face`` (bool):  [Read-Write] Enable single face visualization for the selected rigid body's associated geometries.
    - ``show_transform`` (bool):  [Read-Write] Show the transform for the selected rigid body's associated cluster nodes.
    - ``show_transform_index`` (bool):  [Read-Write] Show the transform index for the selected rigid body's associated cluster nodes.
    - ``show_vertex_indices`` (bool):  [Read-Write] Show the vertex indices for the selected rigid body's associated geometries.
    - ``show_vertex_normals`` (bool):  [Read-Write] Show the vertex normals for the selected rigid body's associated geometries.
    - ``show_vertices`` (bool):  [Read-Write] Show the vertices for the selected rigid body's associated geometries.
    - ``single_face_color`` (Color):  [Read-Write] Color used for the visualization of the single face.
    - ``single_face_index`` (int32):  [Read-Write] The index of the single face to visualize.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``text_scale`` (float):  [Read-Write] Scale of the font used to display text.
    - ``text_shadow`` (bool):  [Read-Write] Draw shadows under the displayed text.
    - ``transform_index_color`` (Color):  [Read-Write] Color used for the visualization of the transform indices.
    - ``transform_scale`` (float):  [Read-Write] Scale for cluster transform visualization.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_active_visualization`` (bool):  [Read-Write] Adapt visualization depending of the cluster nodes' hierarchical level.
    - ``vertex_color`` (Color):  [Read-Write] Color used for the visualization of the vertices.
    - ``vertex_index_color`` (Color):  [Read-Write] Color used for the visualization of the vertex indices.
    - ``vertex_normal_color`` (Color):  [Read-Write] Color used for the visualization of the vertex normals.
    """
    ...

class GeometryCollectionDebugDrawComponent(ActorComponent):
    r"""
    Geometry Collection Debug Draw Component
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionDebugDrawComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``geometry_collection_render_level_set_actor`` (GeometryCollectionRenderLevelSetActor):  [Read-Write] Level Set singleton actor, containing the Render properties. Automatically populated at play time unless explicitly set.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class GeometryCollectionISMPoolActor(Actor):
    r"""
    Geometry Collection ISMPool Actor
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionISMPoolActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``ism_pool_comp`` (GeometryCollectionISMPoolComponent):  [Read-Only]
    - ``ism_pool_debug_draw_comp`` (GeometryCollectionISMPoolDebugDrawComponent):  [Read-Only]
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def ism_pool_comp(self) -> GeometryCollectionISMPoolComponent:
        r"""
        (GeometryCollectionISMPoolComponent):  [Read-Only]
        """
        ...
    @property
    def ism_pool_debug_draw_comp(self) -> GeometryCollectionISMPoolDebugDrawComponent:
        r"""
        (GeometryCollectionISMPoolDebugDrawComponent):  [Read-Only]
        """
        ...

class GeometryCollectionISMPoolComponent(SceneComponent):
    r"""
    UGeometryCollectionISMPoolComponent.
    Component that manages a pool of ISM components in order to allow multiple client components that use the same meshes to the share ISMs.
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionISMPoolComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class GeometryCollection(Object):
    r"""
    UGeometryCollectionObject (UObject)
    
    UObject wrapper for the FGeometryCollection
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Write] Importing data and options used for this geometry collection
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``auto_instance_meshes`` (Array[GeometryCollectionAutoInstanceMesh]):  [Read-Write] List of unique static mesh / materials pairs for auto instancing.
    - ``auto_instance_transform_remap_indices`` (Array[int32]):  [Read-Only] cache transform remapping for instanced meshes indices
    - ``breadth_first_transform_indices`` (Array[int32]):  [Read-Only] cache transform indices in breadth-first order
    - ``cluster_connection_type`` (ClusterConnectionTypeEnum):  [Read-Write]
    - ``cluster_group_index`` (int32):  [Read-Write] Maximum level for cluster breaks.
    - ``collision_object_reduction_percentage`` (float):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
      deprecated: This property is deprecated. Use the default SizeSpecificData instead.
    - ``collision_particles_fraction`` (float):  [Read-Write] Number of particles on the triangulated surface to use for collisions.
      deprecated: This property is deprecated. Use the default SizeSpecificData instead.
    - ``collision_type`` (CollisionTypeEnum):  [Read-Write] *  CollisionType defines how to initialize the rigid collision structures.
      deprecated: This property is deprecated. Use the default SizeSpecificData instead.
    - ``connection_graph_bounds_filtering_margin`` (float):  [Read-Write]
    - ``convert_vertex_colors_to_srgb`` (bool):  [Read-Write] Convert vertex colors to sRGB for rendering. Exposed to avoid changing vertex color rendering for legacy assets; should typically be true for new geometry collections.
    - ``custom_renderer_type`` (type(Class)):  [Read-Write] Custom class type that will be used to render the geometry collection instead of using the native rendering.
    - ``damage_model`` (DamageModelTypeEnum):  [Read-Write] Damage model to use for evaluating destruction.
    - ``damage_propagation_data`` (GeometryCollectionDamagePropagationData):  [Read-Write] Data about how damage propagation shoudl behave.
    - ``damage_threshold`` (Array[float]):  [Read-Write] Damage threshold for clusters at different levels.
    - ``dataflow_asset`` (Dataflow):  [Read-Write] Dataflow
    - ``dataflow_terminal`` (str):  [Read-Write]
    - ``density_from_physics_material`` (bool):  [Read-Write] Whether to use density ( for mass computation ) from physics material ( if physics material is not set, use the component one or defaults )
    - ``embedded_geometry_exemplar`` (Array[GeometryCollectionEmbeddedExemplar]):  [Read-Write] References for embedded geometry generation
    - ``enable_clustering`` (bool):  [Read-Write]
    - ``enable_nanite`` (bool):  [Read-Write] Enable support for Nanite.
    - ``enable_remove_pieces_on_fracture`` (bool):  [Read-Write] Enable remove pieces on fracture
      deprecated: Use remove on break feature instead ( Fracture editor tools ).
    - ``geometry_source`` (Array[GeometryCollectionSource]):  [Read-Write]
    - ``implicit_type`` (ImplicitTypeEnum):  [Read-Write] *  CollisionType defines how to initialize the rigid collision structures.
      deprecated: This property is deprecated. Use the default SizeSpecificData instead.
    - ``import_collision_from_source`` (bool):  [Read-Write] whether to import collision from the source asset
    - ``mass`` (float):  [Read-Write] Total Mass of Collection. If density, units are in kg/m^3 ( only enabled if physics material is not set )
    - ``mass_as_density`` (bool):  [Read-Write] Mass As Density, units are in kg/m^3 ( only enabled if physics material is not set )
    - ``materials`` (Array[MaterialInterface]):  [Read-Write]
    - ``max_cluster_level`` (int32):  [Read-Write] Maximum level for cluster breaks.
    - ``max_cluster_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
      deprecated: This property is deprecated. Use the default SizeSpecificData instead.
    - ``max_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
      deprecated: This property is deprecated. Use the default SizeSpecificData instead.
    - ``maximum_collision_particles`` (int32):  [Read-Write] Max number of particles.
      deprecated: This property is deprecated. Use the default SizeSpecificData instead.
    - ``maximum_sleep_time`` (Vector2D):  [Read-Write] How long may the particle sleep before initiating removal (in seconds).
    - ``min_cluster_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 5)
      deprecated: This property is deprecated. Use the default SizeSpecificData instead.
    - ``min_level_set_resolution`` (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 5)
      deprecated: This property is deprecated. Use the default SizeSpecificData instead.
    - ``minimum_mass_clamp`` (float):  [Read-Write] Smallest allowable mass (def:0.1)
    - ``optimize_convexes`` (bool):  [Read-Write] whether to optimize convexes for collisions. If true the convex optimizer will generate at runtime one
      single convex shape for physics collisions ignoring all the user defined ones.
      Enable p.Chaos.Convex.SimplifyUnion cvar to be able to use it (experimental)
    - ``overrides`` (Map[str, str]):  [Read-Write]
    - ``per_cluster_only_damage_threshold`` (bool):  [Read-Write] compatibility check, when true, only cluster compute damage from parameters and propagate to direct children
      when false, each child will compute it's damage threshold allowing for more precise and intuitive destruction behavior
    - ``physics_material`` (PhysicalMaterial):  [Read-Write] Physics material to use for the geometry collection
    - ``removal_duration`` (Vector2D):  [Read-Write] How long does the removal process take (in seconds).
    - ``remove_on_fracture_materials`` (Array[MaterialInterface]):  [Read-Write] Materials relating to remove on fracture
      deprecated: Use remove on break feature instead ( Fracture editor tools ).
    - ``remove_on_max_sleep`` (bool):  [Read-Write] Remove particle from simulation and dissolve rendered geometry once sleep threshold has been exceeded.
    - ``root_index`` (int32):  [Read-Only] cached root index for faster queries
    - ``root_proxy`` (SoftObjectPath):  [Read-Write] static mesh to use as a proxy for rendering until the geometry collection is broken
      deprecated: This property is deprecated. Use RootProxyData instead.
    - ``root_proxy_data`` (GeometryCollectionProxyMeshData):  [Read-Write] Static mesh to use as a proxy for rendering until the geometry collection is broken.
    - ``scale_on_removal`` (bool):  [Read-Write] When enabled, particle will scale down (shrink) when using being removed ( using both remove on sleep or remove on break ) - Enabled by default
    - ``size_specific_data`` (Array[GeometryCollectionSizeSpecificData]):  [Read-Write] * Size Specfic Data reflects the default geometry to bind to rigid bodies smaller
      * than the max size volume. This can also be empty to reflect no collision geometry
      * for the collection.
    - ``slow_moving_as_sleeping`` (bool):  [Read-Write] when on non-sleeping, slow moving pieces will be considered as sleeping, this helps removal of jittery but not really moving objects.
    - ``slow_moving_velocity_threshold`` (float):  [Read-Write] When slow moving detection is on, this defines the linear velocity thresholds in cm/s to consider the object as sleeping .
    - ``strip_on_cook`` (bool):  [Read-Write] Strip unnecessary data from the Geometry Collection to keep the memory footprint as small as possible.
    - ``strip_render_data_on_cook`` (bool):  [Read-Write] Strip unnecessary render data from the Geometry Collection to keep the memory footprint as small as possible.
      This may be used if the cooked build uses a custom renderer such as the ISMPool renderer.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``use_full_precision_u_vs`` (bool):  [Read-Write] Whether to use full precision UVs when rendering this geometry. (Does not apply to Nanite rendering)
    - ``use_material_damage_modifiers`` (bool):  [Read-Write] When on , use the modifiers on the material to adjust the user defined damage threshold values
    - ``use_size_specific_damage_threshold`` (bool):  [Read-Write] whether to use size specific damage threshold instead of level based ones ( see Size Specific Data array ).
    """
    @property
    def damage_model(self) -> DamageModelTypeEnum:
        r"""
        (DamageModelTypeEnum):  [Read-Write] Damage model to use for evaluating destruction.
        """
        ...
    @damage_model.setter
    def damage_model(self, value: DamageModelTypeEnum) -> None:
        ...
    @property
    def use_material_damage_modifiers(self) -> bool:
        r"""
        (bool):  [Read-Write] When on , use the modifiers on the material to adjust the user defined damage threshold values
        """
        ...
    @use_material_damage_modifiers.setter
    def use_material_damage_modifiers(self, value: bool) -> None:
        ...
    @property
    def geometry_source(self) -> Array[GeometryCollectionSource]:
        r"""
        (Array[GeometryCollectionSource]):  [Read-Write]
        """
        ...
    @geometry_source.setter
    def geometry_source(self, value: Array[GeometryCollectionSource]) -> None:
        ...
    @property
    def strip_on_cook(self) -> bool:
        r"""
        (bool):  [Read-Write] Strip unnecessary data from the Geometry Collection to keep the memory footprint as small as possible.
        """
        ...
    @strip_on_cook.setter
    def strip_on_cook(self, value: bool) -> None:
        ...
    @property
    def strip_render_data_on_cook(self) -> bool:
        r"""
        (bool):  [Read-Write] Strip unnecessary render data from the Geometry Collection to keep the memory footprint as small as possible.
        This may be used if the cooked build uses a custom renderer such as the ISMPool renderer.
        """
        ...
    @strip_render_data_on_cook.setter
    def strip_render_data_on_cook(self, value: bool) -> None:
        ...
    @property
    def custom_renderer_type(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Custom class type that will be used to render the geometry collection instead of using the native rendering.
        """
        ...
    @custom_renderer_type.setter
    def custom_renderer_type(self, value: Class) -> None:
        ...
    @property
    def root_proxy_data(self) -> GeometryCollectionProxyMeshData:
        r"""
        (GeometryCollectionProxyMeshData):  [Read-Write] Static mesh to use as a proxy for rendering until the geometry collection is broken.
        """
        ...
    @root_proxy_data.setter
    def root_proxy_data(self, value: GeometryCollectionProxyMeshData) -> None:
        ...
    @property
    def enable_nanite(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable support for Nanite.
        """
        ...
    @enable_nanite.setter
    def enable_nanite(self, value: bool) -> None:
        ...
    @property
    def convert_vertex_colors_to_srgb(self) -> bool:
        r"""
        (bool):  [Read-Write] Convert vertex colors to sRGB for rendering. Exposed to avoid changing vertex color rendering for legacy assets; should typically be true for new geometry collections.
        """
        ...
    @convert_vertex_colors_to_srgb.setter
    def convert_vertex_colors_to_srgb(self, value: bool) -> None:
        ...
    @property
    def collision_type(self) -> CollisionTypeEnum:
        r"""
        (CollisionTypeEnum):  [Read-Write] *  CollisionType defines how to initialize the rigid collision structures.
        deprecated: This property is deprecated. Use the default SizeSpecificData instead.
        """
        ...
    @collision_type.setter
    def collision_type(self, value: CollisionTypeEnum) -> None:
        ...
    @property
    def implicit_type(self) -> ImplicitTypeEnum:
        r"""
        (ImplicitTypeEnum):  [Read-Write] *  CollisionType defines how to initialize the rigid collision structures.
        deprecated: This property is deprecated. Use the default SizeSpecificData instead.
        """
        ...
    @implicit_type.setter
    def implicit_type(self, value: ImplicitTypeEnum) -> None:
        ...
    @property
    def min_level_set_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 5)
        deprecated: This property is deprecated. Use the default SizeSpecificData instead.
        """
        ...
    @min_level_set_resolution.setter
    def min_level_set_resolution(self, value: int) -> None:
        ...
    @property
    def max_level_set_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
        deprecated: This property is deprecated. Use the default SizeSpecificData instead.
        """
        ...
    @max_level_set_resolution.setter
    def max_level_set_resolution(self, value: int) -> None:
        ...
    @property
    def min_cluster_level_set_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 5)
        deprecated: This property is deprecated. Use the default SizeSpecificData instead.
        """
        ...
    @min_cluster_level_set_resolution.setter
    def min_cluster_level_set_resolution(self, value: int) -> None:
        ...
    @property
    def max_cluster_level_set_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
        deprecated: This property is deprecated. Use the default SizeSpecificData instead.
        """
        ...
    @max_cluster_level_set_resolution.setter
    def max_cluster_level_set_resolution(self, value: int) -> None:
        ...
    @property
    def collision_object_reduction_percentage(self) -> float:
        r"""
        (float):  [Read-Write] *  Resolution on the smallest axes for the level set. (def: 10)
        deprecated: This property is deprecated. Use the default SizeSpecificData instead.
        """
        ...
    @collision_object_reduction_percentage.setter
    def collision_object_reduction_percentage(self, value: float) -> None:
        ...
    @property
    def root_proxy(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Write] static mesh to use as a proxy for rendering until the geometry collection is broken
        deprecated: This property is deprecated. Use RootProxyData instead.
        """
        ...
    @root_proxy.setter
    def root_proxy(self, value: SoftObjectPath) -> None:
        ...
    @property
    def physics_material(self) -> PhysicalMaterial:
        r"""
        (PhysicalMaterial):  [Read-Only] Physics material to use for the geometry collection
        """
        ...
    @property
    def density_from_physics_material(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to use density ( for mass computation ) from physics material ( if physics material is not set, use the component one or defaults )
        """
        ...
    @density_from_physics_material.setter
    def density_from_physics_material(self, value: bool) -> None:
        ...
    @property
    def mass_as_density(self) -> bool:
        r"""
        (bool):  [Read-Write] Mass As Density, units are in kg/m^3 ( only enabled if physics material is not set )
        """
        ...
    @mass_as_density.setter
    def mass_as_density(self, value: bool) -> None:
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Write] Total Mass of Collection. If density, units are in kg/m^3 ( only enabled if physics material is not set )
        """
        ...
    @mass.setter
    def mass(self, value: float) -> None:
        ...
    @property
    def minimum_mass_clamp(self) -> float:
        r"""
        (float):  [Read-Only] Smallest allowable mass (def:0.1)
        """
        ...
    @property
    def import_collision_from_source(self) -> bool:
        r"""
        (bool):  [Read-Write] whether to import collision from the source asset
        """
        ...
    @import_collision_from_source.setter
    def import_collision_from_source(self, value: bool) -> None:
        ...
    @property
    def optimize_convexes(self) -> bool:
        r"""
        (bool):  [Read-Write] whether to optimize convexes for collisions. If true the convex optimizer will generate at runtime one
        single convex shape for physics collisions ignoring all the user defined ones.
        Enable p.Chaos.Convex.SimplifyUnion cvar to be able to use it (experimental)
        """
        ...
    @optimize_convexes.setter
    def optimize_convexes(self, value: bool) -> None:
        ...
    @property
    def collision_particles_fraction(self) -> float:
        r"""
        (float):  [Read-Write] Number of particles on the triangulated surface to use for collisions.
        deprecated: This property is deprecated. Use the default SizeSpecificData instead.
        """
        ...
    @collision_particles_fraction.setter
    def collision_particles_fraction(self, value: float) -> None:
        ...
    @property
    def maximum_collision_particles(self) -> int:
        r"""
        (int32):  [Read-Write] Max number of particles.
        deprecated: This property is deprecated. Use the default SizeSpecificData instead.
        """
        ...
    @maximum_collision_particles.setter
    def maximum_collision_particles(self, value: int) -> None:
        ...
    @property
    def scale_on_removal(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled, particle will scale down (shrink) when using being removed ( using both remove on sleep or remove on break ) - Enabled by default
        """
        ...
    @scale_on_removal.setter
    def scale_on_removal(self, value: bool) -> None:
        ...
    @property
    def remove_on_max_sleep(self) -> bool:
        r"""
        (bool):  [Read-Only] Remove particle from simulation and dissolve rendered geometry once sleep threshold has been exceeded.
        """
        ...
    @property
    def maximum_sleep_time(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] How long may the particle sleep before initiating removal (in seconds).
        """
        ...
    @property
    def removal_duration(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] How long does the removal process take (in seconds).
        """
        ...
    @property
    def slow_moving_as_sleeping(self) -> bool:
        r"""
        (bool):  [Read-Only] when on non-sleeping, slow moving pieces will be considered as sleeping, this helps removal of jittery but not really moving objects.
        """
        ...
    @property
    def slow_moving_velocity_threshold(self) -> float:
        r"""
        (float):  [Read-Only] When slow moving detection is on, this defines the linear velocity thresholds in cm/s to consider the object as sleeping .
        """
        ...
    @property
    def enable_remove_pieces_on_fracture(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable remove pieces on fracture
        deprecated: Use remove on break feature instead ( Fracture editor tools ).
        """
        ...
    @enable_remove_pieces_on_fracture.setter
    def enable_remove_pieces_on_fracture(self, value: bool) -> None:
        ...
    @property
    def remove_on_fracture_materials(self) -> Array[MaterialInterface]:
        r"""
        (Array[MaterialInterface]):  [Read-Write] Materials relating to remove on fracture
        deprecated: Use remove on break feature instead ( Fracture editor tools ).
        """
        ...
    @remove_on_fracture_materials.setter
    def remove_on_fracture_materials(self, value: Array[MaterialInterface]) -> None:
        ...
    @property
    def asset_import_data(self) -> AssetImportData:
        r"""
        (AssetImportData):  [Read-Write] Importing data and options used for this geometry collection
        """
        ...
    @asset_import_data.setter
    def asset_import_data(self, value: AssetImportData) -> None:
        ...
    @property
    def dataflow_asset(self) -> Dataflow:
        r"""
        (Dataflow):  [Read-Write] Dataflow
        """
        ...
    @dataflow_asset.setter
    def dataflow_asset(self, value: Dataflow) -> None:
        ...
    @property
    def overrides(self) -> Map[str, str]:
        r"""
        (Map[str, str]):  [Read-Write]
        """
        ...
    @overrides.setter
    def overrides(self, value: Map[str, str]) -> None:
        ...
    def set_enable_nanite(self, value: bool) -> None:
        r"""
        x.set_enable_nanite(value) -> None
        Set Enable Nanite
        
        Args:
            value (bool):
        """
        ...
    def set_convert_vertex_colors_to_srgb(self, value: bool) -> None:
        r"""
        x.set_convert_vertex_colors_to_srgb(value) -> None
        Set Convert Vertex Colors to SRGB
        
        Args:
            value (bool):
        """
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class GeometryCollectionRenderLevelSetActor(Actor):
    r"""
    AGeometryCollectionRenderLevelSetActor
    An actor representing the collection of data necessary to
    render volumes.  This references a ray marching material, which
    is used internally by a post process component blendable.  This
    is a workflow that can be improved with a deeper implementation
    in the future if we decide to.  Note that behavior with multiple
    render level set actors isn't currently supported very well,
    but could be improved in the future
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionRenderLevelSetActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enabled`` (bool):  [Read-Write] Enable or disable rendering
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``isovalue`` (float):  [Read-Write] Isovalue of the level set to use for surface reconstruction.  Generally you want
      this to be zero, but it can be useful for exploring the distance values to make
      this negative to see the interior structure of the levelset
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``ray_march_material`` (Material):  [Read-Write] Material that performs ray marching.  Note this must have certain parameters in order
      to work correctly
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``render_volume_bounding_box`` (bool):  [Read-Write] Enable or disable rendering
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``surface_tolerance`` (float):  [Read-Write] Surface tolerance used for rendering.  When surface reconstruction is noisy,
      try tweaking this value
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``target_volume_texture`` (VolumeTexture):  [Read-Write] Volume texture to fill
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def target_volume_texture(self) -> VolumeTexture:
        r"""
        (VolumeTexture):  [Read-Write] Volume texture to fill
        """
        ...
    @target_volume_texture.setter
    def target_volume_texture(self, value: VolumeTexture) -> None:
        ...
    @property
    def ray_march_material(self) -> Material:
        r"""
        (Material):  [Read-Write] Material that performs ray marching.  Note this must have certain parameters in order
        to work correctly
        """
        ...
    @ray_march_material.setter
    def ray_march_material(self, value: Material) -> None:
        ...
    @property
    def surface_tolerance(self) -> float:
        r"""
        (float):  [Read-Write] Surface tolerance used for rendering.  When surface reconstruction is noisy,
        try tweaking this value
        """
        ...
    @surface_tolerance.setter
    def surface_tolerance(self, value: float) -> None:
        ...
    @property
    def isovalue(self) -> float:
        r"""
        (float):  [Read-Write] Isovalue of the level set to use for surface reconstruction.  Generally you want
        this to be zero, but it can be useful for exploring the distance values to make
        this negative to see the interior structure of the levelset
        """
        ...
    @isovalue.setter
    def isovalue(self, value: float) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable or disable rendering
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def render_volume_bounding_box(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable or disable rendering
        """
        ...
    @render_volume_bounding_box.setter
    def render_volume_bounding_box(self, value: bool) -> None:
        ...

class GeometryCollectionISMPoolDebugDrawComponent(DebugDrawComponent):
    r"""
    Geometry Collection ISMPool Debug Draw Component
    
    **C++ Source:**
    
    - **Module**: GeometryCollectionEngine
    - **File**: GeometryCollectionISMPoolDebugDrawComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``show_bounds`` (bool):  [Read-Write]
    - ``show_global_stats`` (bool):  [Read-Write]
    - ``show_stats`` (bool):  [Read-Write]
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class NavigationGraphNode(Actor):
    r"""
    Navigation Graph Node
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationGraphNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class NavigationGraphNodeComponent(SceneComponent):
    r"""
    Navigation Graph Node Component
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationGraphNodeComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class NavLinkDefinition(Object):
    r"""
    Class containing definition of a navigation area
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavLinkDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``links`` (Array[NavigationLink]):  [Read-Write]
    - ``segment_links`` (Array[NavigationSegmentLink]):  [Read-Write]
    """
    ...

class NavLinkTrivial(NavLinkDefinition):
    r"""
    Nav Link Trivial
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavLinkTrivial.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``links`` (Array[NavigationLink]):  [Read-Write]
    - ``segment_links`` (Array[NavigationSegmentLink]):  [Read-Write]
    """
    ...

class NavigationData(Actor):
    r"""
    Represents abstract Navigation Data (sub-classed as NavMesh, NavGraph, etc)
    Used as a common interface for all navigation types handled by NavigationSystem
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_destroy_when_no_navigation`` (bool):  [Read-Write] Should this instance auto-destroy when there's no navigation system on
          world when it gets created/loaded
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``can_be_main_nav_data`` (bool):  [Read-Write] If set, navigation data can act as default one in navigation system's queries
    - ``can_spawn_on_rebuild`` (bool):  [Read-Only] If set, navigation data will be spawned in persistent level during rebuild if actor doesn't exist
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_drawing`` (bool):  [Read-Write] if set to true then this navigation data will be drawing itself when requested as part of "show navigation"
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``force_rebuild_on_load`` (bool):  [Read-Write] By default navigation will skip the first update after being successfully loaded
      setting bForceRebuildOnLoad to false can override this behavior
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``observed_paths_tick_interval`` (float):  [Read-Write] all observed paths will be processed every ObservedPathsTickInterval seconds
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_generation`` (RuntimeGenerationType):  [Read-Write] Navigation data runtime generation options
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class AbstractNavData(NavigationData):
    r"""
    Abstract Nav Data
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: AbstractNavData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_destroy_when_no_navigation`` (bool):  [Read-Write] Should this instance auto-destroy when there's no navigation system on
          world when it gets created/loaded
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``can_be_main_nav_data`` (bool):  [Read-Write] If set, navigation data can act as default one in navigation system's queries
    - ``can_spawn_on_rebuild`` (bool):  [Read-Only] If set, navigation data will be spawned in persistent level during rebuild if actor doesn't exist
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_drawing`` (bool):  [Read-Write] if set to true then this navigation data will be drawing itself when requested as part of "show navigation"
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``force_rebuild_on_load`` (bool):  [Read-Write] By default navigation will skip the first update after being successfully loaded
      setting bForceRebuildOnLoad to false can override this behavior
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``observed_paths_tick_interval`` (float):  [Read-Write] all observed paths will be processed every ObservedPathsTickInterval seconds
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_generation`` (RuntimeGenerationType):  [Read-Write] Navigation data runtime generation options
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class NavAreaBase(Object):
    r"""
    a stub class. Actual implementation in NavigationSystem module.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavAreaBase.h
    
    """
    ...

class NavArea(NavAreaBase):
    r"""
    Class containing definition of a navigation area
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavArea.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_cost`` (float):  [Read-Write] travel cost multiplier for path distance
    - ``draw_color`` (Color):  [Read-Write] area color in navigation view
    - ``fixed_area_entering_cost`` (float):  [Read-Write] entering cost
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict area only to specified agents
    """
    ...

class NavAreaDefinition(NavArea):
    r"""
    deprecated: 'NavAreaDefinition' was renamed to 'NavArea'.
    """
    ...

class NavAreaMeta(NavArea):
    r"""
    A convenience class for an area that has IsMetaArea() == true.
       Do not use this class when determining whether an area class is "meta".
       Call IsMetaArea instead.
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavAreaMeta.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_cost`` (float):  [Read-Write] travel cost multiplier for path distance
    - ``draw_color`` (Color):  [Read-Write] area color in navigation view
    - ``fixed_area_entering_cost`` (float):  [Read-Write] entering cost
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict area only to specified agents
    """
    ...

class NavAreaMeta_SwitchByAgent(NavAreaMeta):
    r"""
    Class containing definition of a navigation area
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavAreaMeta_SwitchByAgent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``agent0_area`` (type(Class)):  [Read-Write]
    - ``agent10_area`` (type(Class)):  [Read-Write]
    - ``agent11_area`` (type(Class)):  [Read-Write]
    - ``agent12_area`` (type(Class)):  [Read-Write]
    - ``agent13_area`` (type(Class)):  [Read-Write]
    - ``agent14_area`` (type(Class)):  [Read-Write]
    - ``agent15_area`` (type(Class)):  [Read-Write]
    - ``agent1_area`` (type(Class)):  [Read-Write]
    - ``agent2_area`` (type(Class)):  [Read-Write]
    - ``agent3_area`` (type(Class)):  [Read-Write]
    - ``agent4_area`` (type(Class)):  [Read-Write]
    - ``agent5_area`` (type(Class)):  [Read-Write]
    - ``agent6_area`` (type(Class)):  [Read-Write]
    - ``agent7_area`` (type(Class)):  [Read-Write]
    - ``agent8_area`` (type(Class)):  [Read-Write]
    - ``agent9_area`` (type(Class)):  [Read-Write]
    - ``default_cost`` (float):  [Read-Write] travel cost multiplier for path distance
    - ``draw_color`` (Color):  [Read-Write] area color in navigation view
    - ``fixed_area_entering_cost`` (float):  [Read-Write] entering cost
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict area only to specified agents
    """
    ...

class NavArea_Default(NavArea):
    r"""
    Regular navigation area, applied to entire navigation data by default
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavArea_Default.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_cost`` (float):  [Read-Write] travel cost multiplier for path distance
    - ``draw_color`` (Color):  [Read-Write] area color in navigation view
    - ``fixed_area_entering_cost`` (float):  [Read-Write] entering cost
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict area only to specified agents
    """
    ...

class NavAreaDefault(NavArea_Default):
    r"""
    deprecated: 'NavAreaDefault' was renamed to 'NavArea_Default'.
    """
    ...

class NavArea_LowHeight(NavArea):
    r"""
    Special area that can be generated in spaces with insufficient free height above. Cannot be traversed by anyone.
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavArea_LowHeight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_cost`` (float):  [Read-Write] travel cost multiplier for path distance
    - ``draw_color`` (Color):  [Read-Write] area color in navigation view
    - ``fixed_area_entering_cost`` (float):  [Read-Write] entering cost
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict area only to specified agents
    """
    ...

class NavArea_Null(NavArea):
    r"""
    In general represents an empty area, that cannot be traversed by anyone. Ever.
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavArea_Null.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_cost`` (float):  [Read-Write] travel cost multiplier for path distance
    - ``draw_color`` (Color):  [Read-Write] area color in navigation view
    - ``fixed_area_entering_cost`` (float):  [Read-Write] entering cost
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict area only to specified agents
    """
    ...

class NavAreaNull(NavArea_Null):
    r"""
    deprecated: 'NavAreaNull' was renamed to 'NavArea_Null'.
    """
    ...

class NavArea_Obstacle(NavArea):
    r"""
    In general represents a high cost area, that shouldn't be traversed by anyone unless no other path exist.
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavArea_Obstacle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_cost`` (float):  [Read-Write] travel cost multiplier for path distance
    - ``draw_color`` (Color):  [Read-Write] area color in navigation view
    - ``fixed_area_entering_cost`` (float):  [Read-Write] entering cost
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict area only to specified agents
    """
    ...

class RecastFilter_UseDefaultArea(NavigationQueryFilter):
    r"""
    Regular navigation area, applied to entire navigation data by default
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: RecastFilter_UseDefaultArea.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``areas`` (Array[NavigationFilterArea]):  [Read-Write] list of overrides for navigation areas
    - ``exclude_flags`` (NavigationFilterFlags):  [Read-Write] forbidden flags of navigation nodes
    - ``include_flags`` (NavigationFilterFlags):  [Read-Write] required flags of navigation nodes
    """
    ...

class NavigationGraph(NavigationData):
    r"""
    currently abstract since it's not full implemented
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_destroy_when_no_navigation`` (bool):  [Read-Write] Should this instance auto-destroy when there's no navigation system on
          world when it gets created/loaded
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``can_be_main_nav_data`` (bool):  [Read-Write] If set, navigation data can act as default one in navigation system's queries
    - ``can_spawn_on_rebuild`` (bool):  [Read-Only] If set, navigation data will be spawned in persistent level during rebuild if actor doesn't exist
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_drawing`` (bool):  [Read-Write] if set to true then this navigation data will be drawing itself when requested as part of "show navigation"
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``force_rebuild_on_load`` (bool):  [Read-Write] By default navigation will skip the first update after being successfully loaded
      setting bForceRebuildOnLoad to false can override this behavior
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``observed_paths_tick_interval`` (float):  [Read-Write] all observed paths will be processed every ObservedPathsTickInterval seconds
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_generation`` (RuntimeGenerationType):  [Read-Write] Navigation data runtime generation options
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class NavigationInvokerComponent(ActorComponent):
    r"""
    Navigation Invoker Component
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationInvokerComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``priority`` (NavigationInvokerPriority):  [Read-Write] Experimental invocation priority. It will modify the order in which invoked tiles are being built if SortPendingTilesMethod is set to SortByPriority.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict navigation generation to specific agents
    - ``tile_generation_radius`` (float):  [Read-Write]
    - ``tile_removal_radius`` (float):  [Read-Write]
    """
    ...

class NavigationPath(Object):
    r"""
    UObject wrapper for FNavigationPath
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationPath.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``path_points`` (Array[Vector]):  [Read-Write]
    - ``path_updated_notifier`` (OnNavigationPathUpdated):  [Read-Write]
    - ``recalculate_on_invalidation`` (NavigationOptionFlag):  [Read-Write]
    """
    @property
    def path_updated_notifier(self) -> OnNavigationPathUpdated:
        r"""
        (OnNavigationPathUpdated):  [Read-Write]
        """
        ...
    @path_updated_notifier.setter
    def path_updated_notifier(self, value: OnNavigationPathUpdated) -> None:
        ...
    @property
    def path_points(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Only]
        """
        ...
    @property
    def recalculate_on_invalidation(self) -> NavigationOptionFlag:
        r"""
        (NavigationOptionFlag):  [Read-Only]
        """
        ...
    def is_valid(self) -> bool:
        r"""
        x.is_valid() -> bool
        Is Valid
        
        Returns:
            bool:
        """
        ...
    def is_string_pulled(self) -> bool:
        r"""
        x.is_string_pulled() -> bool
        Is String Pulled
        
        Returns:
            bool:
        """
        ...
    def is_partial(self) -> bool:
        r"""
        x.is_partial() -> bool
        Is Partial
        
        Returns:
            bool:
        """
        ...
    def get_path_length(self) -> float:
        r"""
        x.get_path_length() -> double
        Get Path Length
        
        Returns:
            double:
        """
        ...
    def get_path_lenght(self) -> float:
        r"""
        deprecated: 'get_path_lenght' was renamed to 'get_path_length'.
        """
        ...
    def get_path_cost(self) -> float:
        r"""
        x.get_path_cost() -> double
        Get Path Cost
        
        Returns:
            double:
        """
        ...
    def get_debug_string(self) -> str:
        r"""
        x.get_debug_string() -> str
        UObject end
        
        Returns:
            str:
        """
        ...
    def enable_recalculation_on_invalidation(self, do_recalculation: NavigationOptionFlag) -> None:
        r"""
        x.enable_recalculation_on_invalidation(do_recalculation) -> None
        if enabled path will request recalculation if it gets invalidated due to a change to underlying navigation
        
        Args:
            do_recalculation (NavigationOptionFlag):
        """
        ...
    def enable_debug_drawing(self, should_draw_debug_data: bool, path_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000]) -> None:
        r"""
        x.enable_debug_drawing(should_draw_debug_data, path_color=[1.000000, 1.000000, 1.000000, 1.000000]) -> None
        Enable Debug Drawing
        
        Args:
            should_draw_debug_data (bool): 
            path_color (LinearColor):
        """
        ...

class World(Object):
    r"""
    The World is the top level object representing a map or a sandbox in which Actors and Components will exist and be rendered.
    
    A World can be a single Persistent Level with an optional list of streaming levels that are loaded and unloaded via volumes and blueprint functions
    or it can be a collection of levels organized with a World Composition.
    
    In a standalone game, generally only a single World exists except during seamless area transitions when both a destination and current world exists.
    In the editor many Worlds exist: The level being edited, each PIE instance, each editor tool which has an interactive rendered viewport, and many more.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: World.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    def get_world_settings(self) -> WorldSettings:
        r"""
        x.get_world_settings() -> WorldSettings
        Returns the AWorldSettings actor associated with this world.
        
        Returns:
            WorldSettings: AWorldSettings actor associated with this world
        """
        ...
    def get_data_layer_manager(self) -> DataLayerManager:
        r"""
        x.get_data_layer_manager() -> DataLayerManager
        Returns the UDataLayerManager associated with this world.
        
        Returns:
            DataLayerManager: UDataLayerManager object associated with this world
        """
        ...

class NavigationSystemBase(Object):
    r"""
    Navigation System Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationSystemBase.h
    
    """
    ...

class NavigationSystemV1(NavigationSystemBase):
    r"""
    Navigation System V1
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationSystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active_tiles_update_interval`` (float):  [Read-Write] Minimal time, in seconds, between active tiles set update
    - ``allow_client_side_navigation`` (bool):  [Read-Write] If false, will not create nav collision when connecting as a client
    - ``auto_create_navigation_data`` (bool):  [Read-Write] Should navigation system spawn default Navigation Data when there's none and there are navigation bounds present?
    - ``crowd_manager_class`` (Class):  [Read-Write]
    - ``data_gathering_mode`` (NavDataGatheringModeConfig):  [Read-Write] Sets how navigation data should be gathered when building collision information
    - ``default_agent_name`` (Name):  [Read-Write] If not None indicates which of navigation datas and supported agents are
      going to be used as the default ones. If navigation agent of this type does
      not exist or is not enabled then the first available nav data will be used
      as the default one
    - ``dirty_area_warning_size_threshold`` (float):  [Read-Write] -1 by default, if set to a positive value dirty areas with any dimensions in 2d over the threshold created at runtime will be logged
    - ``gathering_nav_modifiers_warning_limit_time`` (float):  [Read-Write] -1.0f by default, if set to a positive value, all calls to GetNavigationData will be timed and compared to it.
           Over the limit calls will be logged as warnings.
           In seconds. Non-shipping build only.
    - ``generate_navigation_only_around_navigation_invokers`` (bool):  [Read-Write] If set to true navigation will be generated only around registered "navigation enforcers"
           This has a range of consequences (including how navigation octree operates) so it needs to
           be a conscious decision.
           Once enabled results in whole world being navigable.
      see: RegisterNavigationInvoker
    - ``geometry_export_triangle_count_warning_threshold`` (int32):  [Read-Write] Warnings are logged if exporting the navigation collision for an object exceed this triangle count.
      Use -1 to disable.
    - ``initial_building_locked`` (bool):  [Read-Write] if set to true will result navigation system not rebuild navigation until
          a call to ReleaseInitialBuildingLock() is called. Does not influence
          editor-time generation (i.e. does influence PIE and Game).
          Defaults to false.
    - ``invokers_maximum_distance_from_seed`` (double):  [Read-Write] When in use, invokers farther away from any invoker seed will be ignored (set to -1 to disable).
    - ``on_navigation_generation_finished_delegate`` (OnNavDataGenericEvent):  [Read-Write]
    - ``should_discard_sub_level_nav_data`` (bool):  [Read-Write] If true, games should ignore navigation data inside loaded sublevels
    - ``skip_agent_height_check_when_picking_nav_data`` (bool):  [Read-Write] false by default, if set to true will result in not caring about nav agent height
          when trying to match navigation data to passed in nav agent
    - ``spawn_nav_data_in_nav_bounds_level`` (bool):  [Read-Write] If true will try to spawn the navigation data instance in the sublevel with navigation bounds, if false it will spawn in the persistent level
    - ``supported_agents`` (Array[NavDataConfig]):  [Read-Write] List of agents types supported by this navigation system
    - ``supported_agents_mask`` (NavAgentSelector):  [Read-Write] NavigationSystem's properties in Project Settings define all possible supported agents,
          but a specific navigation system can choose to support only a subset of agents. Set via
          NavigationSystemConfig
    - ``tick_while_paused`` (bool):  [Read-Write] If true, will update navigation even when the game is paused
    """
    @property
    def default_agent_name(self) -> Name:
        r"""
        (Name):  [Read-Only] If not None indicates which of navigation datas and supported agents are
        going to be used as the default ones. If navigation agent of this type does
        not exist or is not enabled then the first available nav data will be used
        as the default one
        """
        ...
    @property
    def crowd_manager_class(self) -> Class:
        r"""
        (Class):  [Read-Only]
        """
        ...
    @property
    def on_navigation_generation_finished_delegate(self) -> OnNavDataGenericEvent:
        r"""
        (OnNavDataGenericEvent):  [Read-Write]
        """
        ...
    @on_navigation_generation_finished_delegate.setter
    def on_navigation_generation_finished_delegate(self, value: OnNavDataGenericEvent) -> None:
        ...
    def unregister_navigation_invoker(self, invoker: Actor) -> None:
        r"""
        x.unregister_navigation_invoker(invoker) -> None
        Removes given actor from the list of active navigation enforcers.
        see: RegisterNavigationInvoker for more details
        
        Args:
            invoker (Actor):
        """
        ...
    def set_max_simultaneous_tile_generation_jobs_count(self, max_number_of_jobs: int) -> None:
        r"""
        x.set_max_simultaneous_tile_generation_jobs_count(max_number_of_jobs) -> None
        will limit the number of simultaneously running navmesh tile generation jobs to specified number.
        
        Args:
            max_number_of_jobs (int32): gets trimmed to be at least 1. You cannot use this function to pause navmesh generation
        """
        ...
    def set_geometry_gathering_mode(self, new_mode: NavDataGatheringModeConfig) -> None:
        r"""
        x.set_geometry_gathering_mode(new_mode) -> None
        Set Geometry Gathering Mode
        
        Args:
            new_mode (NavDataGatheringModeConfig):
        """
        ...
    def reset_max_simultaneous_tile_generation_jobs_count(self) -> None:
        r"""
        x.reset_max_simultaneous_tile_generation_jobs_count() -> None
        Brings limit of simultaneous navmesh tile generation jobs back to Project Setting's default value
        """
        ...
    def register_navigation_invoker(self, invoker: Actor, tile_generation_radius: float = 3000.000000, tile_removal_radius: float = 5000.000000) -> None:
        r"""
        x.register_navigation_invoker(invoker, tile_generation_radius=3000.000000, tile_removal_radius=5000.000000) -> None
        Registers given actor as a "navigation enforcer" which means navigation system will
            make sure navigation is being generated in specified radius around it.
        note:: you need NavigationSystem's GenerateNavigationOnlyAroundNavigationInvokers to be set to true to take advantage of this feature
        
        Args:
            invoker (Actor): 
            tile_generation_radius (float): 
            tile_removal_radius (float):
        """
        ...
    def on_navigation_bounds_updated(self, nav_volume: NavMeshBoundsVolume) -> None:
        r"""
        x.on_navigation_bounds_updated(nav_volume) -> None
        
        todo: document
        
        Args:
            nav_volume (NavMeshBoundsVolume):
        """
        ...
    @classmethod
    def navigation_raycast(cls, world_context_object: Object, ray_start: Vector, ray_end: Vector, filter_class: Class = None, querier: Controller = None) -> Optional[Vector]:
        r"""
        X.navigation_raycast(world_context_object, ray_start, ray_end, filter_class=None, querier=None) -> Vector or None
        Performs navigation raycast on NavigationData appropriate for given Querier.
        
        Args:
            world_context_object (Object): 
            ray_start (Vector): 
            ray_end (Vector): 
            filter_class (type(Class)): 
            querier (Controller): if not passed default navigation data will be used
        
        Returns:
            Vector or None: true if line from RayStart to RayEnd was obstructed. Also, true when no navigation data present
        
            hit_location (Vector): if line was obstructed this will be set to hit location. Otherwise it contains SegmentEnd
        """
        ...
    def k2_replace_area_in_octree_data(self, object: Object, old_area: Class, new_area: Class) -> bool:
        r"""
        x.k2_replace_area_in_octree_data(object, old_area, new_area) -> bool
        K2 Replace Area in Octree Data
        
        Args:
            object (Object): 
            old_area (type(Class)): 
            new_area (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def project_point_to_navigation(cls, world_context_object: Object, point: Vector, nav_data: NavigationData, filter_class: Class, query_extent: Vector = [0.000000, 0.000000, 0.000000]) -> Optional[Vector]:
        r"""
        X.project_point_to_navigation(world_context_object, point, nav_data, filter_class, query_extent=[0.000000, 0.000000, 0.000000]) -> Vector or None
        Project a point onto the NavigationData
        
        Args:
            world_context_object (Object): 
            point (Vector): 
            nav_data (NavigationData): 
            filter_class (type(Class)): 
            query_extent (Vector): 
        
        Returns:
            Vector or None: 
        
            projected_location (Vector):
        """
        ...
    @classmethod
    def get_random_reachable_point_in_radius(cls, world_context_object: Object, origin: Vector, radius: float, nav_data: NavigationData = None, filter_class: Class = None) -> Optional[Vector]:
        r"""
        X.get_random_reachable_point_in_radius(world_context_object, origin, radius, nav_data=None, filter_class=None) -> Vector or None
        Generates a random location reachable from given Origin location.
        
        Args:
            world_context_object (Object): 
            origin (Vector): 
            radius (float): 
            nav_data (NavigationData): 
            filter_class (type(Class)): 
        
        Returns:
            Vector or None: Return Value represents if the call was successful
        
            random_location (Vector):
        """
        ...
    @classmethod
    def get_random_point_in_navigable_radius(cls, world_context_object: Object, origin: Vector, radius: float, nav_data: NavigationData = None, filter_class: Class = None) -> Optional[Vector]:
        r"""
        X.get_random_point_in_navigable_radius(world_context_object, origin, radius, nav_data=None, filter_class=None) -> Vector or None
        K2 Get Random Point in Navigable Radius
        deprecated: GetRandomPointInNavigableRadius is deprecated. Use GetRandomLocationInNavigableRadius instead
        
        Args:
            world_context_object (Object): 
            origin (Vector): 
            radius (float): 
            nav_data (NavigationData): 
            filter_class (type(Class)): 
        
        Returns:
            Vector or None: 
        
            random_location (Vector):
        """
        ...
    @classmethod
    def get_random_location_in_navigable_radius(cls, world_context_object: Object, origin: Vector, radius: float, nav_data: NavigationData = None, filter_class: Class = None) -> Optional[Vector]:
        r"""
        X.get_random_location_in_navigable_radius(world_context_object, origin, radius, nav_data=None, filter_class=None) -> Vector or None
        Generates a random location in navigable space within given radius of Origin.
        
        Args:
            world_context_object (Object): 
            origin (Vector): 
            radius (float): 
            nav_data (NavigationData): 
            filter_class (type(Class)): 
        
        Returns:
            Vector or None: Return Value represents if the call was successful
        
            random_location (Vector):
        """
        ...
    @classmethod
    def is_navigation_being_built_or_locked(cls, world_context_object: Object) -> bool:
        r"""
        X.is_navigation_being_built_or_locked(world_context_object) -> bool
        Is Navigation Being Built or Locked
        
        Args:
            world_context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_navigation_being_built(cls, world_context_object: Object) -> bool:
        r"""
        X.is_navigation_being_built(world_context_object) -> bool
        Is Navigation Being Built
        
        Args:
            world_context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_path_length(cls, world_context_object: Object, path_start: Vector, path_end: Vector, nav_data: NavigationData = None, filter_class: Class = None) -> Tuple[NavigationQueryResult, float]:
        r"""
        X.get_path_length(world_context_object, path_start, path_end, nav_data=None, filter_class=None) -> (NavigationQueryResult, path_length=double)
        Potentially expensive. Use with caution
        
        Args:
            world_context_object (Object): 
            path_start (Vector): 
            path_end (Vector): 
            nav_data (NavigationData): 
            filter_class (type(Class)): 
        
        Returns:
            double: 
        
            path_length (double):
        """
        ...
    @classmethod
    def get_path_cost(cls, world_context_object: Object, path_start: Vector, path_end: Vector, nav_data: NavigationData = None, filter_class: Class = None) -> Tuple[NavigationQueryResult, float]:
        r"""
        X.get_path_cost(world_context_object, path_start, path_end, nav_data=None, filter_class=None) -> (NavigationQueryResult, path_cost=double)
        Potentially expensive. Use with caution. Consider using UPathFollowingComponent::GetRemainingPathCost instead
        
        Args:
            world_context_object (Object): 
            path_start (Vector): 
            path_end (Vector): 
            nav_data (NavigationData): 
            filter_class (type(Class)): 
        
        Returns:
            double: 
        
            path_cost (double):
        """
        ...
    @classmethod
    def get_navigation_system(cls, world_context_object: Object) -> NavigationSystemV1:
        r"""
        X.get_navigation_system(world_context_object) -> NavigationSystemV1
        Blueprint functions
        
        Args:
            world_context_object (Object): 
        
        Returns:
            NavigationSystemV1:
        """
        ...
    @classmethod
    def find_path_to_location_synchronously(cls, world_context_object: Object, path_start: Vector, path_end: Vector, pathfinding_context: Actor = None, filter_class: Class = None) -> NavigationPath:
        r"""
        X.find_path_to_location_synchronously(world_context_object, path_start, path_end, pathfinding_context=None, filter_class=None) -> NavigationPath
        Finds path instantly, in a FindPath Synchronously.
        
        Args:
            world_context_object (Object): 
            path_start (Vector): 
            path_end (Vector): 
            pathfinding_context (Actor): could be one of following: NavigationData (like Navmesh actor), Pawn or Controller. This parameter determines parameters of specific pathfinding query
            filter_class (type(Class)): 
        
        Returns:
            NavigationPath:
        """
        ...
    @classmethod
    def find_path_to_actor_synchronously(cls, world_context_object: Object, path_start: Vector, goal_actor: Actor, tether_distance: float = 50.000000, pathfinding_context: Actor = None, filter_class: Class = None) -> NavigationPath:
        r"""
        X.find_path_to_actor_synchronously(world_context_object, path_start, goal_actor, tether_distance=50.000000, pathfinding_context=None, filter_class=None) -> NavigationPath
        Finds path instantly, in a FindPath Synchronously. Main advantage over FindPathToLocationSynchronously is that
            the resulting path will automatically get updated if goal actor moves more than TetherDistance away from last path node
        
        Args:
            world_context_object (Object): 
            path_start (Vector): 
            goal_actor (Actor): 
            tether_distance (float): 
            pathfinding_context (Actor): could be one of following: NavigationData (like Navmesh actor), Pawn or Controller. This parameter determines parameters of specific pathfinding query
            filter_class (type(Class)): 
        
        Returns:
            NavigationPath:
        """
        ...

class NavigationSystem(NavigationSystemV1):
    r"""
    deprecated: 'NavigationSystem' was renamed to 'NavigationSystemV1'.
    """
    ...

class NavigationTestingActor(Actor):
    r"""
    Navigation Testing Actor
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavigationTestingActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``act_as_navigation_invoker`` (bool):  [Read-Write]
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``backtracking`` (bool):  [Read-Write] Instead of regular pathfinding from source to target location do
          a 'backwards' search that searches from the source, but as if the allowed
          movement direction was coming from the target. Meaningful only for paths
          containing one-direction nav links.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``cost_display_mode`` (NavCostDisplay):  [Read-Write] determines which cost will be shown
    - ``cost_limit_factor`` (float):  [Read-Write] this multiplier is used to compute a max node cost allowed to the open list
          (cost limit = CostLimitFactor*InitialHeuristicEstimate)
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``draw_distance_to_wall`` (bool):  [Read-Write]
    - ``draw_if_nav_data_is_ready_in_radius`` (bool):  [Read-Write] If set, a cylinder is drawn to indicate if the navigation data is ready (has been generated) for the given radius (green when ready, red otherwise).
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``filter_class`` (type(Class)):  [Read-Write] "None" will result in default filter being used
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``gather_detailed_info`` (bool):  [Read-Write] if set, all steps of A* algorithm will be accessible for debugging
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``invoker_component`` (NavigationInvokerComponent):  [Read-Write]
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``minimum_cost_limit`` (float):  [Read-Write] minimum cost limit clamping value (in cost units)
          used to allow large deviation in short paths
    - ``nav_agent_props`` (NavAgentProperties):  [Read-Write]
      todo: document
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``offset_from_corners_distance`` (float):  [Read-Write]
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``other_actor`` (NavigationTestingActor):  [Read-Write]
    - ``path_cost`` (double):  [Read-Only]
    - ``path_exist`` (bool):  [Read-Only]
    - ``path_is_partial`` (bool):  [Read-Only]
    - ``path_search_out_of_nodes`` (bool):  [Read-Only]
    - ``pathfinding_steps`` (int32):  [Read-Only]
    - ``pathfinding_time`` (float):  [Read-Only] Time in micro seconds
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``projected_location`` (Vector):  [Read-Only]
    - ``projected_location_valid`` (bool):  [Read-Only]
    - ``querying_extent`` (Vector):  [Read-Write]
    - ``radius_used_to_validate_nav_data`` (float):  [Read-Write] NavData must be ready for all tiles within radius. When using 0, NavData must be ready at the actor location.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``require_navigable_end_location`` (bool):  [Read-Write] if set, require the end location to be close to the navigation data. The tolerance is controlled by QueryingExtent
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``search_start`` (bool):  [Read-Write] if set, start the search from this actor, else start the search from the other actor
    - ``should_be_visible_in_game`` (bool):  [Read-Write]
    - ``show_best_path`` (bool):  [Read-Write] show current best path
    - ``show_diff_with_previous_step`` (bool):  [Read-Write] show which nodes were modified in current A* step
    - ``show_node_pool`` (bool):  [Read-Write] show polys from open (orange) and closed (yellow) sets
    - ``show_step_index`` (int32):  [Read-Write] Show debug steps up to this index. Use -1 to disable.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``text_canvas_offset`` (Vector2D):  [Read-Write] text canvas offset to apply
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_hierarchical_pathfinding`` (bool):  [Read-Write]
    """
    @property
    def projected_location(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def projected_location_valid(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def path_exist(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def path_is_partial(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def path_search_out_of_nodes(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def pathfinding_time(self) -> float:
        r"""
        (float):  [Read-Only] Time in micro seconds
        """
        ...
    @property
    def path_cost(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...
    @property
    def pathfinding_steps(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...

class NavLinkComponent(PrimitiveComponent):
    r"""
    Nav Link Component
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavLinkComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``links`` (Array[NavigationLink]):  [Read-Write]
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def links(self) -> Array[NavigationLink]:
        r"""
        (Array[NavigationLink]):  [Read-Only]
        """
        ...

class NavRelevantComponent(ActorComponent):
    r"""
    Nav Relevant Component
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavRelevantComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    def set_navigation_relevancy(self, relevant: bool) -> None:
        r"""
        x.set_navigation_relevancy(relevant) -> None
        Set Navigation Relevancy
        
        Args:
            relevant (bool):
        """
        ...

class NavLinkCustomComponent(NavRelevantComponent):
    r"""
    Encapsulates NavLinkCustomInterface interface, can be used with Actors not relevant for navigation
    
    Additional functionality:
    - can be toggled
    - can create obstacle area for easier/forced separation of link end points
    - can broadcast state changes to nearby agents
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavLinkCustomComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``broadcast_channel`` (CollisionChannel):  [Read-Write] trace channel for state change broadcast
    - ``broadcast_interval`` (float):  [Read-Write] interval for state change broadcast (0 = single broadcast)
    - ``broadcast_radius`` (float):  [Read-Write] radius of state change broadcast
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``create_box_obstacle`` (bool):  [Read-Write] if set, box obstacle area will be added to generation
    - ``disabled_area_class`` (type(Class)):  [Read-Write] area class to use when link is disabled
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enabled_area_class`` (type(Class)):  [Read-Write] area class to use when link is enabled
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``link_direction`` (NavLinkDirection):  [Read-Write] direction of link
    - ``link_enabled`` (bool):  [Read-Write] is link currently in enabled state? (area class)
    - ``link_relative_end`` (Vector):  [Read-Write] end point, relative to owner
    - ``link_relative_start`` (Vector):  [Read-Write] start point, relative to owner
    - ``notify_when_disabled`` (bool):  [Read-Write] should link notify nearby agents when it changes state to disabled
    - ``notify_when_enabled`` (bool):  [Read-Write] should link notify nearby agents when it changes state to enabled
    - ``obstacle_area_class`` (type(Class)):  [Read-Write] area class for simple box obstacle
    - ``obstacle_extent`` (Vector):  [Read-Write] extent of simple box obstacle
    - ``obstacle_offset`` (Vector):  [Read-Write] offset of simple box obstacle
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``supported_agents`` (NavAgentSelector):  [Read-Write] restrict area only to specified agents
    """
    ...

class SmartNavLinkComponent(NavLinkCustomComponent):
    r"""
    deprecated: 'SmartNavLinkComponent' was renamed to 'NavLinkCustomComponent'.
    """
    ...

class NavLinkRenderingComponent(PrimitiveComponent):
    r"""
    Nav Link Rendering Component
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavLinkRenderingComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class Brush(Actor):
    r"""
    Brush
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Brush.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def brush_component(self) -> BrushComponent:
        r"""
        (BrushComponent):  [Read-Only]
        """
        ...

class Volume(Brush):
    r"""
    An editable 3D volume placed in a level. Different types of volumes perform different functions
    see: https://docs.unrealengine.com/latest/INT/Engine/Actors/Volumes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Volume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class NavMeshBoundsVolume(Volume):
    r"""
    Nav Mesh Bounds Volume
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavMeshBoundsVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``supported_agents`` (NavAgentSelector):  [Read-Write]
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class NavMeshRenderingComponent(DebugDrawComponent):
    r"""
    Nav Mesh Rendering Component
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavMeshRenderingComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class NavTestRenderingComponent(DebugDrawComponent):
    r"""
    Nav Test Rendering Component
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavTestRenderingComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class RecastNavMesh(NavigationData):
    r"""
    Recast Nav Mesh
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: RecastNavMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``agent_height`` (float):  [Read-Write] Size of the tallest agent that will path with this navmesh.
    - ``agent_max_slope`` (float):  [Read-Write] The maximum slope (angle) that the agent can move on.
    - ``agent_radius`` (float):  [Read-Write] Radius of smallest agent to traverse this navmesh
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_destroy_when_no_navigation`` (bool):  [Read-Write] Should this instance auto-destroy when there's no navigation system on
          world when it gets created/loaded
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``can_be_main_nav_data`` (bool):  [Read-Write] If set, navigation data can act as default one in navigation system's queries
    - ``can_spawn_on_rebuild`` (bool):  [Read-Only] If set, navigation data will be spawned in persistent level during rebuild if actor doesn't exist
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``do_fully_async_nav_data_gathering`` (bool):  [Read-Write] if set, navmesh data gathering will never happen on the game thread and will only be done on background threads
    - ``draw_clusters`` (bool):  [Read-Write] Draw navmesh's clusters and cluster links. (Requires WITH_NAVMESH_CLUSTER_LINKS=1)
    - ``draw_default_polygon_cost`` (bool):  [Read-Write] Draw a label for every poly that indicates its default and fixed costs
    - ``draw_failed_nav_links`` (bool):  [Read-Write]
    - ``draw_filled_polys`` (bool):  [Read-Write] if disabled skips filling drawn navmesh polygons
    - ``draw_labels_on_path_nodes`` (bool):  [Read-Write]
    - ``draw_marked_forbidden_polys`` (bool):  [Read-Write]
    - ``draw_nav_links`` (bool):  [Read-Write]
    - ``draw_nav_mesh_edges`` (bool):  [Read-Write] Draw border-edges
    - ``draw_octree`` (bool):  [Read-Write] Draw octree used to store navigation relevant actors
    - ``draw_octree_details`` (bool):  [Read-Write] Draw octree used to store navigation relevant actors with the elements bounds
    - ``draw_offset`` (float):  [Read-Write] vertical offset added to navmesh's debug representation for better readability
    - ``draw_path_colliding_geometry`` (bool):  [Read-Write] Draw input geometry passed to the navmesh generator.  Recommend disabling other geometry rendering via viewport showflags in editor.
    - ``draw_poly_edges`` (bool):  [Read-Write] Draw edges of every poly (i.e. not only border-edges)
    - ``draw_polygon_flags`` (bool):  [Read-Write] Draw a label for every poly that indicates its poly and area flags
    - ``draw_polygon_labels`` (bool):  [Read-Write] Draw a label for every poly that indicates its poly and tile indices
    - ``draw_tile_bounds`` (bool):  [Read-Write] Draw the tile boundaries
    - ``draw_tile_build_times`` (bool):  [Read-Write]
    - ``draw_tile_build_times_heat_map`` (bool):  [Read-Write]
    - ``draw_tile_labels`` (bool):  [Read-Write]
    - ``draw_tile_resolutions`` (bool):  [Read-Write] Draw the tile resolutions
    - ``draw_triangle_edges`` (bool):  [Read-Write] Draw edges of every navmesh's triangle
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_drawing`` (bool):  [Read-Write] if set to true then this navigation data will be drawing itself when requested as part of "show navigation"
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``filter_low_span_from_tile_cache`` (bool):  [Read-Write] if set, only low height spans with corresponding area modifier will be stored in tile cache (reduces memory, can't modify without full tile rebuild)
    - ``filter_low_span_sequences`` (bool):  [Read-Write] if set, only single low height span will be allowed under valid one
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``fixed_tile_pool_size`` (bool):  [Read-Write] if true, the NavMesh will allocate fixed size pool for tiles, should be enabled to support streaming
    - ``force_rebuild_on_load`` (bool):  [Read-Write] By default navigation will skip the first update after being successfully loaded
      setting bForceRebuildOnLoad to false can override this behavior
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``heuristic_scale`` (float):  [Read-Write] Euclidean distance heuristic scale used while pathfinding
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``invoker_tile_priority_bump_distance_threshold_in_tile_units`` (uint32):  [Read-Write] If >= 1, when sorting pending tiles by priority, tiles near invokers (within the distance threshold) will have their priority increased.
    - ``invoker_tile_priority_bump_increase`` (uint8):  [Read-Write] Priority increase steps for tiles that are withing near distance.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``is_world_partitioned`` (bool):  [Read-Write] In a world partitioned map, is this navmesh using world partitioning
    - ``layer_chunk_splits`` (int32):  [Read-Write] number of chunk splits (along single axis) used for layer's partitioning: ChunkyMonotone
    - ``layer_partitioning`` (RecastPartitioning):  [Read-Write] partitioning method for creating tile layers
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``ledge_slope_filter_mode`` (NavigationLedgeSlopeFilterMode):  [Read-Write] filtering methode used for filtering ledge slopes
    - ``mark_low_height_areas`` (bool):  [Read-Write] mark areas with insufficient free height above instead of cutting them out (accessible only for area modifiers using replace mode)
    - ``max_simplification_error`` (float):  [Read-Write] How much navigable shapes can get simplified - the higher the value the more freedom
    - ``max_simultaneous_tile_generation_jobs_count`` (int32):  [Read-Write] Sets the limit for number of asynchronous tile generators running at one time, also used for some synchronous tasks
    - ``max_vertical_merge_error`` (int32):  [Read-Write] Maximum vertical deviation between raw contour points to allowing merging (in voxel).
      Use a low value (2-5) depending on CellHeight, AgentMaxStepHeight and AgentMaxSlope, to allow more precise contours (also see SimplificationElevationRatio).
      Use very high value to deactivate (Recast behavior).
    - ``merge_region_size`` (float):  [Read-Write] The size limit of regions to be merged with bigger regions (watershed partitioning only)
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``min_region_area`` (float):  [Read-Write] The minimum dimension of area. Areas smaller than this will be discarded
    - ``nav_mesh_origin_offset`` (Vector):  [Read-Write] Use this if you don't want your tiles to start at (0,0,0)
    - ``nav_mesh_resolution_params`` (NavMeshResolutionParam):  [Read-Write] Resolution params
      If using multiple resolutions, it's recommended to chose the highest resolution first and
      set it according to the highest desired precision and then the other resolutions.
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``observed_paths_tick_interval`` (float):  [Read-Write] all observed paths will be processed every ObservedPathsTickInterval seconds
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``perform_voxel_filtering`` (bool):  [Read-Write] controls whether voxel filtering will be applied (via FRecastTileGenerator::ApplyVoxelFilter).
          Results in generated navmesh better fitting navigation bounds, but hits (a bit) generation performance
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``poly_ref_nav_poly_bits`` (int32):  [Read-Only]
    - ``poly_ref_salt_bits`` (int32):  [Read-Only]
    - ``poly_ref_tile_bits`` (int32):  [Read-Only]
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``region_chunk_splits`` (int32):  [Read-Write] number of chunk splits (along single axis) used for region's partitioning: ChunkyMonotone
    - ``region_partitioning`` (RecastPartitioning):  [Read-Write] partitioning method for creating navmesh polys
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_generation`` (RuntimeGenerationType):  [Read-Write] Navigation data runtime generation options
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``simplification_elevation_ratio`` (float):  [Read-Write] When simplifying contours, how much is the vertical error taken into account when comparing with MaxSimplificationError.
      Use 0 to deactivate (Recast behavior), use 1 as a typical value.
    - ``sort_navigation_areas_by_cost`` (bool):  [Read-Write] Controls whether Navigation Areas will be sorted by cost before application
          to navmesh during navmesh generation. This is relevant when there are
          areas overlapping and we want to have area cost express area relevancy
          as well. Setting it to true will result in having area sorted by cost,
          but it will also increase navmesh generation cost a bit
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``tile_generation_debug`` (RecastNavMeshTileGenerationDebug):  [Read-Write]
    - ``tile_number_hard_limit`` (int32):  [Read-Write] Absolute hard limit to number of navmesh tiles. Be very, very careful while modifying it while
          having big maps with navmesh. A single, empty tile takes 176 bytes and empty tiles are
          allocated up front (subject to change, but that's where it's at now)
      note: TileNumberHardLimit is always rounded up to the closest power of 2
    - ``tile_pool_size`` (int32):  [Read-Write] maximum number of tiles NavMesh can hold
    - ``tile_size_uu`` (float):  [Read-Write] size of single tile, expressed in uu
    - ``time_slice_filter_ledge_spans_max_y_process`` (int32):  [Read-Write] The maximum number of y coords to process when time slicing filter ledge spans during navmesh regeneration.
    - ``time_slice_long_duration_debug`` (double):  [Read-Write] If a single time sliced section of navmesh regen code exceeds this duration then it will trigger debug logging
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_extra_top_cell_when_marking_areas`` (bool):  [Read-Write] Expand the top of the area nav modifier's bounds by one cell height when applying to the navmesh.
                    If unset, navmesh on top of surfaces might not be marked by marking bounds flush with top surfaces (since navmesh is generated slightly above collision, depending on cell height).
    - ``vertical_deviation_from_ground_compensation`` (float):  [Read-Write] Value added to each search height to compensate for error between navmesh polys and walkable geometry
    """
    def k2_replace_area_in_tile_bounds(self, bounds: Box, old_area: Class, new_area: Class, replace_links: bool = True) -> bool:
        r"""
        x.k2_replace_area_in_tile_bounds(bounds, old_area, new_area, replace_links=True) -> bool
        
        
        Args:
            bounds (Box): 
            old_area (type(Class)): 
            new_area (type(Class)): 
            replace_links (bool): 
        
        Returns:
            bool: true if any polygon/link has been touched
        """
        ...

class NavModifierComponent(NavRelevantComponent):
    r"""
    Nav Modifier Component
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavModifierComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``area_class`` (type(Class)):  [Read-Write]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``failsafe_extent`` (Vector):  [Read-Write] box extent used ONLY when owning actor doesn't have collision component
    - ``include_agent_height`` (bool):  [Read-Write] Setting to 'true' will result in expanding lower bounding box of the nav
          modifier by agent's height, before applying to navmesh
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``nav_mesh_resolution`` (NavigationDataResolution):  [Read-Write] Experimental: Indicates which navmesh resolution should be used around the actor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def area_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only]
        """
        ...
    def set_area_class(self, new_area_class: Class) -> None:
        r"""
        x.set_area_class(new_area_class) -> None
        Set Area Class
        
        Args:
            new_area_class (type(Class)):
        """
        ...

class NavModifierVolume(Volume):
    r"""
    Allows applying selected AreaClass to navmesh, using Volume's shape
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavModifierVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``area_class`` (type(Class)):  [Read-Write]
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``mask_fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] Experimental: if set, the 2D space occupied by the volume box will ignore FillCollisionUnderneathForNavmesh
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``nav_mesh_resolution`` (NavigationDataResolution):  [Read-Write] Experimental: When not set to None, the navmesh tiles touched by the navigation modifier volume will be built
      using the highest resolution found.
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def area_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only]
        """
        ...
    def set_area_class(self, new_area_class: Class = None) -> None:
        r"""
        x.set_area_class(new_area_class=None) -> None
        Set Area Class
        
        Args:
            new_area_class (type(Class)):
        """
        ...

class NavSystemConfigOverride(Actor):
    r"""
    Nav System Config Override
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: NavSystemConfigOverride.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``load_on_client`` (bool):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``navigation_system_config`` (NavigationSystemConfig):  [Read-Write]
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_policy`` (NavSystemOverridePolicy):  [Read-Write] If there's already a NavigationSystem instance in the world how should this nav override behave
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def navigation_system_config(self) -> NavigationSystemConfig:
        r"""
        (NavigationSystemConfig):  [Read-Only]
        """
        ...
    @property
    def override_policy(self) -> NavSystemOverridePolicy:
        r"""
        (NavSystemOverridePolicy):  [Read-Only] If there's already a NavigationSystem instance in the world how should this nav override behave
        """
        ...
    @property
    def load_on_client(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @load_on_client.setter
    def load_on_client(self, value: bool) -> None:
        ...

class SplineNavModifierComponent(NavModifierComponent):
    r"""
    Assign a chosen NavArea in the vicinity of a spline
    This component must only be attached to an actor with a USplineComponent
    
    **C++ Source:**
    
    - **Module**: NavigationSystem
    - **File**: SplineNavModifierComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``area_class`` (type(Class)):  [Read-Write]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``failsafe_extent`` (Vector):  [Read-Write] box extent used ONLY when owning actor doesn't have collision component
    - ``include_agent_height`` (bool):  [Read-Write] Setting to 'true' will result in expanding lower bounding box of the nav
          modifier by agent's height, before applying to navmesh
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``nav_mesh_resolution`` (NavigationDataResolution):  [Read-Write] Experimental: Indicates which navmesh resolution should be used around the actor.
    - ``num_spline_samples`` (int32):  [Read-Write] How many sections the spline will be divided into for generating overlap volumes. More samples result in finer detail
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``spline_extent`` (double):  [Read-Write] Radius of the tube surrounding the spline which will be used to generate the Nav Modifiers
    """
    ...

class FoliageType_InstancedStaticMeshFactory(Factory):
    r"""
    Foliage Type Instanced Static Mesh Factory
    
    **C++ Source:**
    
    - **Module**: FoliageEdit
    - **File**: FoliageTypeFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class FoliageType_ActorFactory(Factory):
    r"""
    Foliage Type Actor Factory
    
    **C++ Source:**
    
    - **Module**: FoliageEdit
    - **File**: FoliageTypeFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class LandscapeGrassTypeFactory(Factory):
    r"""
    Landscape Grass Type Factory
    
    **C++ Source:**
    
    - **Module**: FoliageEdit
    - **File**: LandscapeGrassTypeFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ProceduralFoliageEditorLibrary(BlueprintFunctionLibrary):
    r"""
    Procedural Foliage Editor Library
    
    **C++ Source:**
    
    - **Module**: FoliageEdit
    - **File**: ProceduralFoliageEditorLibrary.h
    
    """
    @classmethod
    def resimulate_procedural_foliage_volumes(cls, procedural_foliage_volumes: Array[ProceduralFoliageVolume]) -> None:
        r"""
        X.resimulate_procedural_foliage_volumes(procedural_foliage_volumes) -> None
        Resimulate Procedural Foliage Volumes
        
        Args:
            procedural_foliage_volumes (Array[ProceduralFoliageVolume]):
        """
        ...
    @classmethod
    def resimulate_procedural_foliage_components(cls, procedural_foliage_components: Array[ProceduralFoliageComponent]) -> None:
        r"""
        X.resimulate_procedural_foliage_components(procedural_foliage_components) -> None
        Resimulate Procedural Foliage Components
        
        Args:
            procedural_foliage_components (Array[ProceduralFoliageComponent]):
        """
        ...
    @classmethod
    def clear_procedural_foliage_volumes(cls, procedural_foliage_volumes: Array[ProceduralFoliageVolume]) -> None:
        r"""
        X.clear_procedural_foliage_volumes(procedural_foliage_volumes) -> None
        Clear Procedural Foliage Volumes
        
        Args:
            procedural_foliage_volumes (Array[ProceduralFoliageVolume]):
        """
        ...
    @classmethod
    def clear_procedural_foliage_components(cls, procedural_foliage_components: Array[ProceduralFoliageComponent]) -> None:
        r"""
        X.clear_procedural_foliage_components(procedural_foliage_components) -> None
        Clear Procedural Foliage Components
        
        Args:
            procedural_foliage_components (Array[ProceduralFoliageComponent]):
        """
        ...

class ProceduralFoliageSpawnerFactory(Factory):
    r"""
    Procedural Foliage Spawner Factory
    
    **C++ Source:**
    
    - **Module**: FoliageEdit
    - **File**: ProceduralFoliageSpawnerFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MaterialOptions(Object):
    r"""
    Options object to define what and how a material should be baked out
    
    **C++ Source:**
    
    - **Module**: MaterialBaking
    - **File**: MaterialOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``lod_indices`` (Array[int32]):  [Read-Write] LOD indices for which the materials should be baked out
    - ``properties`` (Array[PropertyEntry]):  [Read-Write] Properties which are supposed to be baked out for the material(s)
    - ``texture_coordinate_index`` (int32):  [Read-Write] Specific texture coordinate which should be used to while baking out material properties as the positions stream
    - ``texture_size`` (IntPoint):  [Read-Write] Size of the final texture(s) containing the baked out property data
    - ``use_mesh_data`` (bool):  [Read-Write] Determines whether to not allow usage of the source mesh data while baking out material properties
    - ``use_specific_uv_index`` (bool):  [Read-Write] Flag whether or not the value of TextureCoordinateIndex should be used while baking out material properties
    """
    @property
    def properties(self) -> Array[PropertyEntry]:
        r"""
        (Array[PropertyEntry]):  [Read-Write] Properties which are supposed to be baked out for the material(s)
        """
        ...
    @properties.setter
    def properties(self, value: Array[PropertyEntry]) -> None:
        ...
    @property
    def texture_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Size of the final texture(s) containing the baked out property data
        """
        ...
    @texture_size.setter
    def texture_size(self, value: IntPoint) -> None:
        ...
    @property
    def lod_indices(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write] LOD indices for which the materials should be baked out
        """
        ...
    @lod_indices.setter
    def lod_indices(self, value: Array[int]) -> None:
        ...
    @property
    def use_mesh_data(self) -> bool:
        r"""
        (bool):  [Read-Write] Determines whether to not allow usage of the source mesh data while baking out material properties
        """
        ...
    @use_mesh_data.setter
    def use_mesh_data(self, value: bool) -> None:
        ...
    @property
    def use_specific_uv_index(self) -> bool:
        r"""
        (bool):  [Read-Write] Flag whether or not the value of TextureCoordinateIndex should be used while baking out material properties
        """
        ...
    @use_specific_uv_index.setter
    def use_specific_uv_index(self, value: bool) -> None:
        ...
    @property
    def texture_coordinate_index(self) -> int:
        r"""
        (int32):  [Read-Write] Specific texture coordinate which should be used to while baking out material properties as the positions stream
        """
        ...
    @texture_coordinate_index.setter
    def texture_coordinate_index(self, value: int) -> None:
        ...

class AssetBakeOptions(Object):
    r"""
    Asset bake options object
    
    **C++ Source:**
    
    - **Module**: MaterialBaking
    - **File**: MaterialOptions.h
    
    """
    ...

class MaterialMergeOptions(Object):
    r"""
    Material merge options object
    
    **C++ Source:**
    
    - **Module**: MaterialBaking
    - **File**: MaterialOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_mode`` (BlendMode):  [Read-Write] Blend mode for the final proxy material(s)
    """
    @property
    def blend_mode(self) -> BlendMode:
        r"""
        (BlendMode):  [Read-Write] Blend mode for the final proxy material(s)
        """
        ...
    @blend_mode.setter
    def blend_mode(self, value: BlendMode) -> None:
        ...

class MaterialEditingLibrary(BlueprintFunctionLibrary):
    r"""
    Blueprint library for creating/editing Materials
    
    **C++ Source:**
    
    - **Module**: MaterialEditor
    - **File**: MaterialEditingLibrary.h
    
    """
    @classmethod
    def update_material_instance(cls, instance: MaterialInstanceConstant) -> None:
        r"""
        X.update_material_instance(instance) -> None
        Called after making modifications to a Material Instance to recompile shaders etc.
        
        Args:
            instance (MaterialInstanceConstant):
        """
        ...
    @classmethod
    def update_material_function(cls, material_function: MaterialFunctionInterface, preview_material: Material = None) -> None:
        r"""
        X.update_material_function(material_function, preview_material=None) -> None
        Update a Material Function after edits have been made.
        Will recompile any Materials that use the supplied Material Function.
        
        Args:
            material_function (MaterialFunctionInterface): 
            preview_material (Material):
        """
        ...
    @classmethod
    def set_material_usage(cls, material: Material, usage: MaterialUsage) -> Optional[bool]:
        r"""
        X.set_material_usage(material, usage) -> bool or None
        Enable a particular usage for the supplied material (e.g. SkeletalMesh, ParticleSprite etc)
        
        Args:
            material (Material): Material to change usage for
            usage (MaterialUsage): New usage type to enable for this material
        
        Returns:
            bool or None: 
        
            needs_recompile (bool): Returned to indicate if material needs recompiling after this change
        """
        ...
    @classmethod
    def set_material_instance_vector_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, value: LinearColor, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool:
        r"""
        X.set_material_instance_vector_parameter_value(instance, parameter_name, value, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool
        Set the vector parameter value for a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            value (LinearColor): 
            association (MaterialParameterAssociation): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_material_instance_texture_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, value: Texture, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool:
        r"""
        X.set_material_instance_texture_parameter_value(instance, parameter_name, value, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool
        Set the texture parameter value for a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            value (Texture): 
            association (MaterialParameterAssociation): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_material_instance_static_switch_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, value: bool, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool:
        r"""
        X.set_material_instance_static_switch_parameter_value(instance, parameter_name, value, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool
        Set the static switch parameter value for a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            value (bool): 
            association (MaterialParameterAssociation): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_material_instance_sparse_volume_texture_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, value: SparseVolumeTexture, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool:
        r"""
        X.set_material_instance_sparse_volume_texture_parameter_value(instance, parameter_name, value, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool
        Set the texture parameter value for a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            value (SparseVolumeTexture): 
            association (MaterialParameterAssociation): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_material_instance_scalar_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, value: float, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool:
        r"""
        X.set_material_instance_scalar_parameter_value(instance, parameter_name, value, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool
        Set the scalar (float) parameter value for a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            value (float): 
            association (MaterialParameterAssociation): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_material_instance_runtime_virtual_texture_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, value: RuntimeVirtualTexture, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool:
        r"""
        X.set_material_instance_runtime_virtual_texture_parameter_value(instance, parameter_name, value, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool
        Set the texture parameter value for a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            value (RuntimeVirtualTexture): 
            association (MaterialParameterAssociation): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_material_instance_parent(cls, instance: MaterialInstanceConstant, new_parent: MaterialInterface) -> None:
        r"""
        X.set_material_instance_parent(instance, new_parent) -> None
        Set the parent Material or Material Instance to use for this Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            new_parent (MaterialInterface):
        """
        ...
    @classmethod
    def recompile_material(cls, material: Material) -> None:
        r"""
        X.recompile_material(material) -> None
        Trigger a recompile of a material. Must be performed after making changes to the graph to have changes reflected.
        
        Args:
            material (Material):
        """
        ...
    @classmethod
    def layout_material_function_expressions(cls, material_function: MaterialFunction) -> None:
        r"""
        X.layout_material_function_expressions(material_function) -> None
        Layouts the expressions in a grid pattern
        
        Args:
            material_function (MaterialFunction):
        """
        ...
    @classmethod
    def layout_material_expressions(cls, material: Material) -> None:
        r"""
        X.layout_material_expressions(material) -> None
        Layouts the expressions in a grid pattern
        
        Args:
            material (Material):
        """
        ...
    @classmethod
    def has_material_usage(cls, material: Material, usage: MaterialUsage) -> bool:
        r"""
        X.has_material_usage(material, usage) -> bool
        Check if a particular usage is enabled for the supplied material (e.g. SkeletalMesh, ParticleSprite etc)
        
        Args:
            material (Material): Material to check usage for
            usage (MaterialUsage): Usage type to check for this material
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_vector_parameter_source(cls, material: MaterialInterface, parameter_name: Name) -> Optional[SoftObjectPath]:
        r"""
        X.get_vector_parameter_source(material, parameter_name) -> SoftObjectPath or None
        Returns the path of the asset where the parameter originated, as well as true/false if it was found
        
        Args:
            material (MaterialInterface): The material or material instance you want to look up a parameter from
            parameter_name (Name): The parameter name
        
        Returns:
            SoftObjectPath or None: Whether or not the parameter was found in this material
        
            parameter_source (SoftObjectPath): The soft object path of the asset the parameter originates in
        """
        ...
    @classmethod
    def get_vector_parameter_names(cls, material: MaterialInterface) -> Array[Name]:
        r"""
        X.get_vector_parameter_names(material) -> Array[Name]
        Gets all vector parameter names
        
        Args:
            material (MaterialInterface): 
        
        Returns:
            Array[Name]: 
        
            parameter_names (Array[Name]):
        """
        ...
    @classmethod
    def get_used_textures(cls, material: Material) -> Array[Texture]:
        r"""
        X.get_used_textures(material) -> Array[Texture]
        Get the list of textures used by a material
        
        Args:
            material (Material): 
        
        Returns:
            Array[Texture]:
        """
        ...
    @classmethod
    def get_texture_parameter_source(cls, material: MaterialInterface, parameter_name: Name) -> Optional[SoftObjectPath]:
        r"""
        X.get_texture_parameter_source(material, parameter_name) -> SoftObjectPath or None
        Returns the path of the asset where the parameter originated, as well as true/false if it was found
        
        Args:
            material (MaterialInterface): The material or material instance you want to look up a parameter from
            parameter_name (Name): The parameter name
        
        Returns:
            SoftObjectPath or None: Whether or not the parameter was found in this material
        
            parameter_source (SoftObjectPath): The soft object path of the asset the parameter originates in
        """
        ...
    @classmethod
    def get_texture_parameter_names(cls, material: MaterialInterface) -> Array[Name]:
        r"""
        X.get_texture_parameter_names(material) -> Array[Name]
        Gets all texture parameter names
        
        Args:
            material (MaterialInterface): 
        
        Returns:
            Array[Name]: 
        
            parameter_names (Array[Name]):
        """
        ...
    @classmethod
    def get_statistics(cls, material: MaterialInterface) -> MaterialStatistics:
        r"""
        X.get_statistics(material) -> MaterialStatistics
        Returns statistics about the given material
        
        Args:
            material (MaterialInterface): 
        
        Returns:
            MaterialStatistics:
        """
        ...
    @classmethod
    def get_static_switch_parameter_source(cls, material: MaterialInterface, parameter_name: Name) -> Optional[SoftObjectPath]:
        r"""
        X.get_static_switch_parameter_source(material, parameter_name) -> SoftObjectPath or None
        Returns the path of the asset where the parameter originated, as well as true/false if it was found
        
        Args:
            material (MaterialInterface): The material or material instance you want to look up a parameter from
            parameter_name (Name): The parameter name
        
        Returns:
            SoftObjectPath or None: Whether or not the parameter was found in this material
        
            parameter_source (SoftObjectPath): The soft object path of the asset the parameter originates in
        """
        ...
    @classmethod
    def get_static_switch_parameter_names(cls, material: MaterialInterface) -> Array[Name]:
        r"""
        X.get_static_switch_parameter_names(material) -> Array[Name]
        Gets all static switch parameter names
        
        Args:
            material (MaterialInterface): 
        
        Returns:
            Array[Name]: 
        
            parameter_names (Array[Name]):
        """
        ...
    @classmethod
    def get_scalar_parameter_source(cls, material: MaterialInterface, parameter_name: Name) -> Optional[SoftObjectPath]:
        r"""
        X.get_scalar_parameter_source(material, parameter_name) -> SoftObjectPath or None
        Returns the path of the asset where the parameter originated, as well as true/false if it was found
        
        Args:
            material (MaterialInterface): The material or material instance you want to look up a parameter from
            parameter_name (Name): The parameter name
        
        Returns:
            SoftObjectPath or None: Whether or not the parameter was found in this material
        
            parameter_source (SoftObjectPath): The soft object path of the asset the parameter originates in
        """
        ...
    @classmethod
    def get_scalar_parameter_names(cls, material: MaterialInterface) -> Array[Name]:
        r"""
        X.get_scalar_parameter_names(material) -> Array[Name]
        Gets all scalar parameter names
        
        Args:
            material (MaterialInterface): 
        
        Returns:
            Array[Name]: 
        
            parameter_names (Array[Name]):
        """
        ...
    @classmethod
    def get_num_material_expressions_in_function(cls, material_function: MaterialFunction) -> int:
        r"""
        X.get_num_material_expressions_in_function(material_function) -> int32
        Returns number of material expressions in the supplied material
        
        Args:
            material_function (MaterialFunction): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_num_material_expressions(cls, material: Material) -> int:
        r"""
        X.get_num_material_expressions(material) -> int32
        Returns number of material expressions in the supplied material
        
        Args:
            material (Material): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_nanite_override_material(cls, material: MaterialInterface) -> MaterialInterface:
        r"""
        X.get_nanite_override_material(material) -> MaterialInterface
        Returns any nanite override material for the given material
        
        Args:
            material (MaterialInterface): 
        
        Returns:
            MaterialInterface:
        """
        ...
    @classmethod
    def get_material_selected_nodes(cls, material: Material) -> Set[Object]:
        r"""
        X.get_material_selected_nodes(material) -> Set[Object]
        Get the set of selected nodes from an active material editor
        
        Args:
            material (Material): 
        
        Returns:
            Set[Object]:
        """
        ...
    @classmethod
    def get_material_property_input_node_output_name(cls, material: Material, property_: MaterialProperty) -> str:
        r"""
        X.get_material_property_input_node_output_name(material, property_) -> str
        Get the node output name providing the output for a given material property from an active material editor
        
        Args:
            material (Material): 
            property_ (MaterialProperty): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_material_property_input_node(cls, material: Material, property_: MaterialProperty) -> MaterialExpression:
        r"""
        X.get_material_property_input_node(material, property_) -> MaterialExpression
        Get the node providing the output for a given material property from an active material editor
        
        Args:
            material (Material): 
            property_ (MaterialProperty): 
        
        Returns:
            MaterialExpression:
        """
        ...
    @classmethod
    def get_material_instance_vector_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> LinearColor:
        r"""
        X.get_material_instance_vector_parameter_value(instance, parameter_name, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> LinearColor
        Get the current vector parameter value from a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            association (MaterialParameterAssociation): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def get_material_instance_texture_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> Texture:
        r"""
        X.get_material_instance_texture_parameter_value(instance, parameter_name, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> Texture
        Get the current texture parameter value from a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            association (MaterialParameterAssociation): 
        
        Returns:
            Texture:
        """
        ...
    @classmethod
    def get_material_instance_static_switch_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool:
        r"""
        X.get_material_instance_static_switch_parameter_value(instance, parameter_name, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> bool
        Get the current static switch parameter value from a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            association (MaterialParameterAssociation): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_material_instance_sparse_volume_texture_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> SparseVolumeTexture:
        r"""
        X.get_material_instance_sparse_volume_texture_parameter_value(instance, parameter_name, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> SparseVolumeTexture
        Get the current texture parameter value from a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            association (MaterialParameterAssociation): 
        
        Returns:
            SparseVolumeTexture:
        """
        ...
    @classmethod
    def get_material_instance_scalar_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> float:
        r"""
        X.get_material_instance_scalar_parameter_value(instance, parameter_name, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> float
        Get the current scalar (float) parameter value from a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            association (MaterialParameterAssociation): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_material_instance_runtime_virtual_texture_parameter_value(cls, instance: MaterialInstanceConstant, parameter_name: Name, association: MaterialParameterAssociation = MaterialParameterAssociation.GLOBAL_PARAMETER) -> RuntimeVirtualTexture:
        r"""
        X.get_material_instance_runtime_virtual_texture_parameter_value(instance, parameter_name, association=MaterialParameterAssociation.GLOBAL_PARAMETER) -> RuntimeVirtualTexture
        Get the current texture parameter value from a Material Instance
        
        Args:
            instance (MaterialInstanceConstant): 
            parameter_name (Name): 
            association (MaterialParameterAssociation): 
        
        Returns:
            RuntimeVirtualTexture:
        """
        ...
    @classmethod
    def get_material_expression_node_position(cls, material_expression: MaterialExpression) -> Tuple[int, int]:
        r"""
        X.get_material_expression_node_position(material_expression) -> (node_pos_x=int32, node_pos_y=int32)
        Get the position of the MaterialExpression node.
        
        Args:
            material_expression (MaterialExpression): 
        
        Returns:
            tuple: 
        
            node_pos_x (int32): 
        
            node_pos_y (int32):
        """
        ...
    @classmethod
    def get_material_expression_input_types(cls, material_expression: MaterialExpression) -> Array[int]:
        r"""
        X.get_material_expression_input_types(material_expression) -> Array[int32]
        Get the array of input pin types for a material expression
        
        Args:
            material_expression (MaterialExpression): 
        
        Returns:
            Array[int32]:
        """
        ...
    @classmethod
    def get_material_expression_input_names(cls, material_expression: MaterialExpression) -> Array[str]:
        r"""
        X.get_material_expression_input_names(material_expression) -> Array[str]
        Get the array of input pin names for a material expression
        
        Args:
            material_expression (MaterialExpression): 
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def get_material_default_vector_parameter_value(cls, material: Material, parameter_name: Name) -> LinearColor:
        r"""
        X.get_material_default_vector_parameter_value(material, parameter_name) -> LinearColor
        Get the default vector parameter value from a Material
        
        Args:
            material (Material): 
            parameter_name (Name): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def get_material_default_texture_parameter_value(cls, material: Material, parameter_name: Name) -> Texture:
        r"""
        X.get_material_default_texture_parameter_value(material, parameter_name) -> Texture
        Get the default texture parameter value from a Material
        
        Args:
            material (Material): 
            parameter_name (Name): 
        
        Returns:
            Texture:
        """
        ...
    @classmethod
    def get_material_default_static_switch_parameter_value(cls, material: Material, parameter_name: Name) -> bool:
        r"""
        X.get_material_default_static_switch_parameter_value(material, parameter_name) -> bool
        Get the default static switch parameter value from a Material
        
        Args:
            material (Material): 
            parameter_name (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_material_default_scalar_parameter_value(cls, material: Material, parameter_name: Name) -> float:
        r"""
        X.get_material_default_scalar_parameter_value(material, parameter_name) -> float
        Get the default scalar (float) parameter value from a Material
        
        Args:
            material (Material): 
            parameter_name (Name): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_inputs_for_material_expression(cls, material: Material, material_expression: MaterialExpression) -> Array[MaterialExpression]:
        r"""
        X.get_inputs_for_material_expression(material, material_expression) -> Array[MaterialExpression]
        Get the set of nodes acting as inputs to a node from an active material editor
        
        Args:
            material (Material): 
            material_expression (MaterialExpression): 
        
        Returns:
            Array[MaterialExpression]:
        """
        ...
    @classmethod
    def get_input_node_output_name_for_material_expression(cls, material_expression: MaterialExpression, input_node: MaterialExpression) -> Optional[str]:
        r"""
        X.get_input_node_output_name_for_material_expression(material_expression, input_node) -> str or None
        Get the output name of input node connected to MaterialExpression from an active material editor
        
        Args:
            material_expression (MaterialExpression): 
            input_node (MaterialExpression): 
        
        Returns:
            str or None: 
        
            output_name (str):
        """
        ...
    @classmethod
    def get_child_instances(cls, parent: MaterialInterface) -> Array[AssetData]:
        r"""
        X.get_child_instances(parent) -> Array[AssetData]
        Gets all direct child mat instances
        
        Args:
            parent (MaterialInterface): 
        
        Returns:
            Array[AssetData]: 
        
            child_instances (Array[AssetData]):
        """
        ...
    @classmethod
    def duplicate_material_expression(cls, material: Material, material_function: MaterialFunction, expression: MaterialExpression) -> MaterialExpression:
        r"""
        X.duplicate_material_expression(material, material_function, expression) -> MaterialExpression
        Duplicates the provided material expression adding it to the same material / material function, and copying parameters.
        Note: Does not duplicate transient properties (Ex: GraphNode).
        
        Args:
            material (Material): Material asset to add an expression to
            material_function (MaterialFunction): Specified if adding an expression to a MaterialFunction, used as Outer for new expression object
            expression (MaterialExpression): 
        
        Returns:
            MaterialExpression:
        """
        ...
    @classmethod
    def delete_material_expression_in_function(cls, material_function: MaterialFunction, expression: MaterialExpression) -> None:
        r"""
        X.delete_material_expression_in_function(material_function, expression) -> None
        Delete a specific expression from a material function. Will disconnect from other expressions.
        
        Args:
            material_function (MaterialFunction): 
            expression (MaterialExpression):
        """
        ...
    @classmethod
    def delete_material_expression(cls, material: Material, expression: MaterialExpression) -> None:
        r"""
        X.delete_material_expression(material, expression) -> None
        Delete a specific expression from a material. Will disconnect from other expressions.
        
        Args:
            material (Material): 
            expression (MaterialExpression):
        """
        ...
    @classmethod
    def delete_all_material_expressions_in_function(cls, material_function: MaterialFunction) -> None:
        r"""
        X.delete_all_material_expressions_in_function(material_function) -> None
        Delete all material expressions in the supplied material function
        
        Args:
            material_function (MaterialFunction):
        """
        ...
    @classmethod
    def delete_all_material_expressions(cls, material: Material) -> None:
        r"""
        X.delete_all_material_expressions(material) -> None
        Delete all material expressions in the supplied material
        
        Args:
            material (Material):
        """
        ...
    @classmethod
    def create_material_expression_in_function(cls, material_function: MaterialFunction, expression_class: Class, node_pos_x: int = 0, node_pos_y: int = 0) -> MaterialExpression:
        r"""
        X.create_material_expression_in_function(material_function, expression_class, node_pos_x=0, node_pos_y=0) -> MaterialExpression
        Create a new material expression node within the supplied material function
        
        Args:
            material_function (MaterialFunction): Material function asset to add an expression to
            expression_class (type(Class)): Class of expression to add
            node_pos_x (int32): X position of new expression node
            node_pos_y (int32): Y position of new expression node
        
        Returns:
            MaterialExpression:
        """
        ...
    @classmethod
    def create_material_expression(cls, material: Material, expression_class: Class, node_pos_x: int = 0, node_pos_y: int = 0) -> MaterialExpression:
        r"""
        X.create_material_expression(material, expression_class, node_pos_x=0, node_pos_y=0) -> MaterialExpression
        Create a new material expression node within the supplied material
        
        Args:
            material (Material): Material asset to add an expression to
            expression_class (type(Class)): Class of expression to add
            node_pos_x (int32): X position of new expression node
            node_pos_y (int32): Y position of new expression node
        
        Returns:
            MaterialExpression:
        """
        ...
    @classmethod
    def connect_material_property(cls, from_expression: MaterialExpression, from_output_name: str, property_: MaterialProperty) -> bool:
        r"""
        X.connect_material_property(from_expression, from_output_name, property_) -> bool
        Connect a material expression output to one of the material property inputs (e.g. diffuse color, opacity etc)
        
        Args:
            from_expression (MaterialExpression): Expression to make connection from
            from_output_name (str): Name of output of FromExpression to make connection from
            property_ (MaterialProperty): Property input on material to make connection to
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def connect_material_expressions(cls, from_expression: MaterialExpression, from_output_name: str, to_expression: MaterialExpression, to_input_name: str) -> bool:
        r"""
        X.connect_material_expressions(from_expression, from_output_name, to_expression, to_input_name) -> bool
        Create connection between two material expressions
        
        Args:
            from_expression (MaterialExpression): Expression to make connection from
            from_output_name (str): Name of output of FromExpression to make connection from. Leave empty to use first output.
            to_expression (MaterialExpression): Expression to make connection to
            to_input_name (str): Name of input of ToExpression to make connection to. Leave empty to use first input.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def clear_all_material_instance_parameters(cls, instance: MaterialInstanceConstant) -> None:
        r"""
        X.clear_all_material_instance_parameters(instance) -> None
        Clears all material parameters set by this Material Instance
        
        Args:
            instance (MaterialInstanceConstant):
        """
        ...

class CurveEditorFilterBase(Object):
    r"""
    An abstract base class for Curve Editor Filtering. If you inherit from this class your class will automatically
    show up in the Curve Editor's Filter dropdown. This allows projects to easily create custom filters to edit curve
    data as they only have to implement this class. Any UPROPERTY(EditAnywhere) properties exposed on the class will
    show up in the Curve Editor Filter panel which allows you to easily create customizable properties or advanced filters
    that rely on user supplied settings.
    
    The CDO is directly edited in the Curve Editor Filter panel so if you wish to save user settings between runs you can
    add the "config" property to your UPROPERTY() and it will automatically get saved.
    
    **C++ Source:**
    
    - **Module**: CurveEditor
    - **File**: CurveEditorFilterBase.h
    
    """
    ...

class CurveEditorBakeFilter(CurveEditorFilterBase):
    r"""
    Curve Editor Bake Filter
    
    **C++ Source:**
    
    - **Module**: CurveEditor
    - **File**: CurveEditorBakeFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bake_interval`` (FrameNumber):  [Read-Write] The interval between baked keys.
    - ``bake_interval_in_seconds`` (float):  [Read-Write] The interval between baked keys when there is no valid Display Rate and Tick Resolution.
    - ``custom_range`` (CurveEditorBakeFilterRange):  [Read-Write] Specifies a custom range to use for baking
    - ``custom_range_max_in_seconds`` (float):  [Read-Write] Specifies a custom range to use for baking when there is no valid Display Rate and Tick Resolution.
    - ``custom_range_min_in_seconds`` (float):  [Read-Write] Specifies a custom range to use for baking when there is no valid Display Rate and Tick Resolution.
    - ``custom_range_override`` (bool):  [Read-Write] When enabled, CustomRange will be used for the bake region. Otherwise the selected keys will be used.
    """
    @property
    def bake_interval_in_seconds(self) -> float:
        r"""
        (float):  [Read-Write] The interval between baked keys when there is no valid Display Rate and Tick Resolution.
        """
        ...
    @bake_interval_in_seconds.setter
    def bake_interval_in_seconds(self, value: float) -> None:
        ...
    @property
    def bake_interval(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] The interval between baked keys.
        """
        ...
    @bake_interval.setter
    def bake_interval(self, value: FrameNumber) -> None:
        ...
    @property
    def custom_range_override(self) -> bool:
        r"""
        (bool):  [Read-Write] When enabled, CustomRange will be used for the bake region. Otherwise the selected keys will be used.
        """
        ...
    @custom_range_override.setter
    def custom_range_override(self, value: bool) -> None:
        ...
    @property
    def custom_range_min_in_seconds(self) -> float:
        r"""
        (float):  [Read-Write] Specifies a custom range to use for baking when there is no valid Display Rate and Tick Resolution.
        """
        ...
    @custom_range_min_in_seconds.setter
    def custom_range_min_in_seconds(self, value: float) -> None:
        ...
    @property
    def custom_range_max_in_seconds(self) -> float:
        r"""
        (float):  [Read-Write] Specifies a custom range to use for baking when there is no valid Display Rate and Tick Resolution.
        """
        ...
    @custom_range_max_in_seconds.setter
    def custom_range_max_in_seconds(self, value: float) -> None:
        ...
    @property
    def custom_range(self) -> CurveEditorBakeFilterRange:
        r"""
        (CurveEditorBakeFilterRange):  [Read-Write] Specifies a custom range to use for baking
        """
        ...
    @custom_range.setter
    def custom_range(self, value: CurveEditorBakeFilterRange) -> None:
        ...

class CurveEditorReduceFilter(CurveEditorFilterBase):
    r"""
    Curve Editor Reduce Filter
    
    **C++ Source:**
    
    - **Module**: CurveEditor
    - **File**: CurveEditorReduceFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``sample_rate`` (FrameRate):  [Read-Write] Rate at which the curve should be sampled to compare against value tolerance.
    - ``tolerance`` (float):  [Read-Write] Minimum change in values required for a key to be considered distinct enough to keep.
    - ``try_remove_user_set_tangent_keys`` (bool):  [Read-Write] Flag whether or not to use SampleRate for sampling between evaluated keys, which allows for removing user-tangent keys.
    """
    @property
    def tolerance(self) -> float:
        r"""
        (float):  [Read-Write] Minimum change in values required for a key to be considered distinct enough to keep.
        """
        ...
    @tolerance.setter
    def tolerance(self, value: float) -> None:
        ...
    @property
    def try_remove_user_set_tangent_keys(self) -> bool:
        r"""
        (bool):  [Read-Write] Flag whether or not to use SampleRate for sampling between evaluated keys, which allows for removing user-tangent keys.
        """
        ...
    @try_remove_user_set_tangent_keys.setter
    def try_remove_user_set_tangent_keys(self, value: bool) -> None:
        ...
    @property
    def sample_rate(self) -> FrameRate:
        r"""
        (FrameRate):  [Read-Write] Rate at which the curve should be sampled to compare against value tolerance.
        """
        ...
    @sample_rate.setter
    def sample_rate(self, value: FrameRate) -> None:
        ...

class CameraRig_Crane(Actor):
    r"""
    A simple rig for simulating crane-like camera movements.
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CameraRig_Crane.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``crane_arm_length`` (float):  [Read-Write] Controls the length of the crane arm.
    - ``crane_camera_mount`` (SceneComponent):  [Read-Write] Component to define the attach point for cameras.
    - ``crane_pitch`` (float):  [Read-Write] Controls the pitch of the crane arm.
    - ``crane_pitch_control`` (SceneComponent):  [Read-Write] Component to control Pitch.
    - ``crane_yaw`` (float):  [Read-Write] Controls the yaw of the crane arm.
    - ``crane_yaw_control`` (SceneComponent):  [Read-Write] Component to control Yaw.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``lock_mount_pitch`` (bool):  [Read-Write] Lock the mount pitch so that an attached camera is locked and pitched in the direction of the crane arm
    - ``lock_mount_yaw`` (bool):  [Read-Write] Lock the mount yaw so that an attached camera is locked and oriented in the direction of the crane arm
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``transform_component`` (SceneComponent):  [Read-Write] Root component to give the whole actor a transform.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def crane_pitch(self) -> float:
        r"""
        (float):  [Read-Write] Controls the pitch of the crane arm.
        """
        ...
    @crane_pitch.setter
    def crane_pitch(self, value: float) -> None:
        ...
    @property
    def crane_yaw(self) -> float:
        r"""
        (float):  [Read-Write] Controls the yaw of the crane arm.
        """
        ...
    @crane_yaw.setter
    def crane_yaw(self, value: float) -> None:
        ...
    @property
    def crane_arm_length(self) -> float:
        r"""
        (float):  [Read-Write] Controls the length of the crane arm.
        """
        ...
    @crane_arm_length.setter
    def crane_arm_length(self, value: float) -> None:
        ...
    @property
    def lock_mount_pitch(self) -> bool:
        r"""
        (bool):  [Read-Write] Lock the mount pitch so that an attached camera is locked and pitched in the direction of the crane arm
        """
        ...
    @lock_mount_pitch.setter
    def lock_mount_pitch(self, value: bool) -> None:
        ...
    @property
    def lock_mount_yaw(self) -> bool:
        r"""
        (bool):  [Read-Write] Lock the mount yaw so that an attached camera is locked and oriented in the direction of the crane arm
        """
        ...
    @lock_mount_yaw.setter
    def lock_mount_yaw(self, value: bool) -> None:
        ...

class CameraRig_Rail(Actor):
    r"""
    Camera Rig Rail
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CameraRig_Rail.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``current_position_on_rail`` (float):  [Read-Write] Defines current position of the mount point along the rail, in terms of normalized distance from the beginning of the rail.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``lock_orientation_to_rail`` (bool):  [Read-Write] Determines whether the orientation of the mount should be in the direction of the rail.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``preview_mesh_scale`` (float):  [Read-Write] Determines the scale of the rail mesh preview
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``rail_camera_mount`` (SceneComponent):  [Read-Write] Component to define the attach point for cameras. Moves along the rail.
    - ``rail_spline_component`` (SplineComponent):  [Read-Write] Spline component to define the rail path.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``show_rail_visualization`` (bool):  [Read-Write] Determines whether or not to show the rail mesh preview.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``transform_component`` (SceneComponent):  [Read-Write] Root component to give the whole actor a transform.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def current_position_on_rail(self) -> float:
        r"""
        (float):  [Read-Write] Defines current position of the mount point along the rail, in terms of normalized distance from the beginning of the rail.
        """
        ...
    @current_position_on_rail.setter
    def current_position_on_rail(self, value: float) -> None:
        ...
    @property
    def lock_orientation_to_rail(self) -> bool:
        r"""
        (bool):  [Read-Write] Determines whether the orientation of the mount should be in the direction of the rail.
        """
        ...
    @lock_orientation_to_rail.setter
    def lock_orientation_to_rail(self, value: bool) -> None:
        ...
    def get_rail_spline_component(self) -> SplineComponent:
        r"""
        x.get_rail_spline_component() -> SplineComponent
        Returns the spline component that defines the rail path
        
        Returns:
            SplineComponent:
        """
        ...

class CameraActor(Actor):
    r"""
    A CameraActor is a camera viewpoint that can be placed in a level.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_activate_for_player`` (AutoReceiveInput):  [Read-Write] Specifies which player controller, if any, should automatically use this Camera when the controller is active.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``camera_component`` (CameraComponent):  [Read-Only] The camera component for this camera
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``scene_component`` (SceneComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def camera_component(self) -> CameraComponent:
        r"""
        (CameraComponent):  [Read-Only] The camera component for this camera
        """
        ...
    @property
    def scene_component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Only]
        """
        ...
    def get_auto_activate_player_index(self) -> int:
        r"""
        x.get_auto_activate_player_index() -> int32
        Returns index of the player for whom we auto-activate, or INDEX_NONE (-1) if disabled.
        
        Returns:
            int32:
        """
        ...

class CineCameraActor(CameraActor):
    r"""
    A CineCameraActor is a CameraActor specialized to work like a cinematic camera.
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_activate_for_player`` (AutoReceiveInput):  [Read-Write] Specifies which player controller, if any, should automatically use this Camera when the controller is active.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``camera_component`` (CameraComponent):  [Read-Only] The camera component for this camera
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``lookat_tracking_settings`` (CameraLookatTrackingSettings):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``scene_component`` (SceneComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def lookat_tracking_settings(self) -> CameraLookatTrackingSettings:
        r"""
        (CameraLookatTrackingSettings):  [Read-Write]
        """
        ...
    @lookat_tracking_settings.setter
    def lookat_tracking_settings(self, value: CameraLookatTrackingSettings) -> None:
        ...
    def get_cine_camera_component(self) -> CineCameraComponent:
        r"""
        x.get_cine_camera_component() -> CineCameraComponent
        Returns the CineCameraComponent of this CineCamera
        
        Returns:
            CineCameraComponent:
        """
        ...

class CameraComponent(SceneComponent):
    r"""
    Represents a camera viewpoint and settings, such as projection type, field of view, and post-process overrides.
    The default behavior for an actor used as the camera view target is to look for an attached camera component and use its location, rotation, and settings.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``aspect_ratio`` (float):  [Read-Write] Aspect Ratio (Width/Height)
    - ``aspect_ratio_axis_constraint`` (AspectRatioAxisConstraint):  [Read-Write] Override for the default aspect ratio axis constraint defined on the local player
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_calculate_ortho_planes`` (bool):  [Read-Write] Automatically determine a min/max Near/Far clip plane position depending on OrthoWidth value
    - ``auto_plane_shift`` (float):  [Read-Write] Manually adjusts the planes of this camera, maintaining the distance between them. Positive moves out to the farplane, negative towards the near plane
    - ``camera_mesh`` (StaticMesh):  [Read-Write]
    - ``camera_mesh_hidden_in_game`` (bool):  [Read-Write] If the camera mesh is visible in game. Only relevant when running editor builds.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_aspect_ratio`` (bool):  [Read-Write] If bConstrainAspectRatio is true, black bars will be added if the destination view has a different aspect ratio than this camera requested.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``draw_frustum_allowed`` (bool):  [Read-Write] The Frustum visibility flag for draw frustum component initialization
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``field_of_view`` (float):  [Read-Write] The horizontal field of view (in degrees) in perspective mode (ignored in Orthographic mode)
      
      If the aspect ratio axis constraint (from ULocalPlayer, ALevelSequenceActor, etc.) is set to maintain vertical FOV, the AspectRatio
      property will be used to convert this property's value to a vertical FOV.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``lock_to_hmd`` (bool):  [Read-Write] True if the camera's orientation and position should be locked to the HMD
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``ortho_far_clip_plane`` (float):  [Read-Write] The far plane distance of the orthographic view (in world units)
    - ``ortho_near_clip_plane`` (float):  [Read-Write] The near plane distance of the orthographic view (in world units)
    - ``ortho_width`` (float):  [Read-Write] The desired width (in world units) of the orthographic view (ignored in Perspective mode)
    - ``override_aspect_ratio_axis_constraint`` (bool):  [Read-Write] Whether to override the default aspect ratio axis constraint defined on the local player
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``post_process_blend_weight`` (float):  [Read-Write] Indicates if PostProcessSettings should be used when using this Camera to view through.
    - ``post_process_settings`` (PostProcessSettings):  [Read-Write] Post process settings to use for this camera. Don't forget to check the properties you want to override
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``projection_mode`` (CameraProjectionMode):  [Read-Write] The type of camera
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``update_ortho_planes`` (bool):  [Read-Write] Adjusts the near/far planes and the view origin of the current camera automatically to avoid clipping and light artefacting
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_camera_height_as_view_target`` (bool):  [Read-Write] If UpdateOrthoPlanes is enabled, this setting will use the cameras current height to compensate the distance to the general view (as a pseudo distance to view target when one isn't present)
    - ``use_field_of_view_for_lod`` (bool):  [Read-Write] If true, account for the field of view angle when computing which level of detail to use for meshes.
    - ``use_pawn_control_rotation`` (bool):  [Read-Write] If this camera component is placed on a pawn, should it use the view/control rotation of the pawn where possible?
      see: APawn::GetViewRotation()
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def field_of_view(self) -> float:
        r"""
        (float):  [Read-Write] The horizontal field of view (in degrees) in perspective mode (ignored in Orthographic mode)
        
        If the aspect ratio axis constraint (from ULocalPlayer, ALevelSequenceActor, etc.) is set to maintain vertical FOV, the AspectRatio
        property will be used to convert this property's value to a vertical FOV.
        """
        ...
    @field_of_view.setter
    def field_of_view(self, value: float) -> None:
        ...
    @property
    def ortho_width(self) -> float:
        r"""
        (float):  [Read-Write] The desired width (in world units) of the orthographic view (ignored in Perspective mode)
        """
        ...
    @ortho_width.setter
    def ortho_width(self, value: float) -> None:
        ...
    @property
    def auto_calculate_ortho_planes(self) -> bool:
        r"""
        (bool):  [Read-Write] Automatically determine a min/max Near/Far clip plane position depending on OrthoWidth value
        """
        ...
    @auto_calculate_ortho_planes.setter
    def auto_calculate_ortho_planes(self, value: bool) -> None:
        ...
    @property
    def auto_plane_shift(self) -> float:
        r"""
        (float):  [Read-Write] Manually adjusts the planes of this camera, maintaining the distance between them. Positive moves out to the farplane, negative towards the near plane
        """
        ...
    @auto_plane_shift.setter
    def auto_plane_shift(self, value: float) -> None:
        ...
    @property
    def ortho_near_clip_plane(self) -> float:
        r"""
        (float):  [Read-Write] The near plane distance of the orthographic view (in world units)
        """
        ...
    @ortho_near_clip_plane.setter
    def ortho_near_clip_plane(self, value: float) -> None:
        ...
    @property
    def ortho_far_clip_plane(self) -> float:
        r"""
        (float):  [Read-Write] The far plane distance of the orthographic view (in world units)
        """
        ...
    @ortho_far_clip_plane.setter
    def ortho_far_clip_plane(self, value: float) -> None:
        ...
    @property
    def update_ortho_planes(self) -> bool:
        r"""
        (bool):  [Read-Write] Adjusts the near/far planes and the view origin of the current camera automatically to avoid clipping and light artefacting
        """
        ...
    @update_ortho_planes.setter
    def update_ortho_planes(self, value: bool) -> None:
        ...
    @property
    def use_camera_height_as_view_target(self) -> bool:
        r"""
        (bool):  [Read-Write] If UpdateOrthoPlanes is enabled, this setting will use the cameras current height to compensate the distance to the general view (as a pseudo distance to view target when one isn't present)
        """
        ...
    @use_camera_height_as_view_target.setter
    def use_camera_height_as_view_target(self, value: bool) -> None:
        ...
    @property
    def aspect_ratio(self) -> float:
        r"""
        (float):  [Read-Write] Aspect Ratio (Width/Height)
        """
        ...
    @aspect_ratio.setter
    def aspect_ratio(self, value: float) -> None:
        ...
    @property
    def aspect_ratio_axis_constraint(self) -> AspectRatioAxisConstraint:
        r"""
        (AspectRatioAxisConstraint):  [Read-Write] Override for the default aspect ratio axis constraint defined on the local player
        """
        ...
    @aspect_ratio_axis_constraint.setter
    def aspect_ratio_axis_constraint(self, value: AspectRatioAxisConstraint) -> None:
        ...
    @property
    def constrain_aspect_ratio(self) -> bool:
        r"""
        (bool):  [Read-Write] If bConstrainAspectRatio is true, black bars will be added if the destination view has a different aspect ratio than this camera requested.
        """
        ...
    @constrain_aspect_ratio.setter
    def constrain_aspect_ratio(self, value: bool) -> None:
        ...
    @property
    def override_aspect_ratio_axis_constraint(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to override the default aspect ratio axis constraint defined on the local player
        """
        ...
    @override_aspect_ratio_axis_constraint.setter
    def override_aspect_ratio_axis_constraint(self, value: bool) -> None:
        ...
    @property
    def use_field_of_view_for_lod(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, account for the field of view angle when computing which level of detail to use for meshes.
        """
        ...
    @use_field_of_view_for_lod.setter
    def use_field_of_view_for_lod(self, value: bool) -> None:
        ...
    @property
    def draw_frustum_allowed(self) -> bool:
        r"""
        (bool):  [Read-Write] The Frustum visibility flag for draw frustum component initialization
        """
        ...
    @draw_frustum_allowed.setter
    def draw_frustum_allowed(self, value: bool) -> None:
        ...
    @property
    def camera_mesh_hidden_in_game(self) -> bool:
        r"""
        (bool):  [Read-Write] If the camera mesh is visible in game. Only relevant when running editor builds.
        """
        ...
    @camera_mesh_hidden_in_game.setter
    def camera_mesh_hidden_in_game(self, value: bool) -> None:
        ...
    @property
    def lock_to_hmd(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the camera's orientation and position should be locked to the HMD
        """
        ...
    @lock_to_hmd.setter
    def lock_to_hmd(self, value: bool) -> None:
        ...
    @property
    def use_pawn_control_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] If this camera component is placed on a pawn, should it use the view/control rotation of the pawn where possible?
        see: APawn::GetViewRotation()
        """
        ...
    @use_pawn_control_rotation.setter
    def use_pawn_control_rotation(self, value: bool) -> None:
        ...
    @property
    def b_use_controller_view_rotation(self) -> bool:
        r"""
        deprecated: 'b_use_controller_view_rotation' was renamed to 'use_pawn_control_rotation'.
        """
        ...
    @b_use_controller_view_rotation.setter
    def b_use_controller_view_rotation(self, value: bool) -> None:
        ...
    @property
    def b_use_pawn_view_rotation(self) -> bool:
        r"""
        deprecated: 'b_use_pawn_view_rotation' was renamed to 'use_pawn_control_rotation'.
        """
        ...
    @b_use_pawn_view_rotation.setter
    def b_use_pawn_view_rotation(self, value: bool) -> None:
        ...
    @property
    def projection_mode(self) -> CameraProjectionMode:
        r"""
        (CameraProjectionMode):  [Read-Write] The type of camera
        """
        ...
    @projection_mode.setter
    def projection_mode(self, value: CameraProjectionMode) -> None:
        ...
    @property
    def camera_mesh(self) -> StaticMesh:
        r"""
        (StaticMesh):  [Read-Write]
        """
        ...
    @camera_mesh.setter
    def camera_mesh(self, value: StaticMesh) -> None:
        ...
    @property
    def post_process_blend_weight(self) -> float:
        r"""
        (float):  [Read-Write] Indicates if PostProcessSettings should be used when using this Camera to view through.
        """
        ...
    @post_process_blend_weight.setter
    def post_process_blend_weight(self, value: float) -> None:
        ...
    @property
    def post_process_settings(self) -> PostProcessSettings:
        r"""
        (PostProcessSettings):  [Read-Write] Post process settings to use for this camera. Don't forget to check the properties you want to override
        """
        ...
    @post_process_settings.setter
    def post_process_settings(self, value: PostProcessSettings) -> None:
        ...
    def set_use_field_of_view_for_lod(self, use_field_of_view_for_lod: bool) -> None:
        r"""
        x.set_use_field_of_view_for_lod(use_field_of_view_for_lod) -> None
        Set Use Field Of View for LOD
        
        Args:
            use_field_of_view_for_lod (bool):
        """
        ...
    def set_use_camera_height_as_view_target(self, use_camera_height_as_view_target: bool) -> None:
        r"""
        x.set_use_camera_height_as_view_target(use_camera_height_as_view_target) -> None
        Set Use Camera Height as View Target
        
        Args:
            use_camera_height_as_view_target (bool):
        """
        ...
    def set_update_ortho_planes(self, update_ortho_planes: bool) -> None:
        r"""
        x.set_update_ortho_planes(update_ortho_planes) -> None
        Set Update Ortho Planes
        
        Args:
            update_ortho_planes (bool):
        """
        ...
    def set_projection_mode(self, projection_mode: CameraProjectionMode) -> None:
        r"""
        x.set_projection_mode(projection_mode) -> None
        Set Projection Mode
        
        Args:
            projection_mode (CameraProjectionMode):
        """
        ...
    def set_post_process_blend_weight(self, post_process_blend_weight: float) -> None:
        r"""
        x.set_post_process_blend_weight(post_process_blend_weight) -> None
        Set Post Process Blend Weight
        
        Args:
            post_process_blend_weight (float):
        """
        ...
    def set_ortho_width(self, ortho_width: float) -> None:
        r"""
        x.set_ortho_width(ortho_width) -> None
        Set Ortho Width
        
        Args:
            ortho_width (float):
        """
        ...
    def set_ortho_near_clip_plane(self, ortho_near_clip_plane: float) -> None:
        r"""
        x.set_ortho_near_clip_plane(ortho_near_clip_plane) -> None
        Set Ortho Near Clip Plane
        
        Args:
            ortho_near_clip_plane (float):
        """
        ...
    def set_ortho_far_clip_plane(self, ortho_far_clip_plane: float) -> None:
        r"""
        x.set_ortho_far_clip_plane(ortho_far_clip_plane) -> None
        Set Ortho Far Clip Plane
        
        Args:
            ortho_far_clip_plane (float):
        """
        ...
    def set_field_of_view(self, field_of_view: float) -> None:
        r"""
        x.set_field_of_view(field_of_view) -> None
        Set Field Of View
        
        Args:
            field_of_view (float):
        """
        ...
    def set_constraint_aspect_ratio(self, constrain_aspect_ratio: bool) -> None:
        r"""
        x.set_constraint_aspect_ratio(constrain_aspect_ratio) -> None
        Set Constraint Aspect Ratio
        
        Args:
            constrain_aspect_ratio (bool):
        """
        ...
    def set_auto_plane_shift(self, auto_plane_shift: float) -> None:
        r"""
        x.set_auto_plane_shift(auto_plane_shift) -> None
        Set Auto Plane Shift
        
        Args:
            auto_plane_shift (float):
        """
        ...
    def set_auto_calculate_ortho_planes(self, auto_calculate: bool) -> None:
        r"""
        x.set_auto_calculate_ortho_planes(auto_calculate) -> None
        Set Auto Calculate Ortho Planes
        
        Args:
            auto_calculate (bool):
        """
        ...
    def set_aspect_ratio_axis_constraint(self, aspect_ratio_axis_constraint: AspectRatioAxisConstraint) -> None:
        r"""
        x.set_aspect_ratio_axis_constraint(aspect_ratio_axis_constraint) -> None
        Set Aspect Ratio Axis Constraint
        
        Args:
            aspect_ratio_axis_constraint (AspectRatioAxisConstraint):
        """
        ...
    def set_aspect_ratio(self, aspect_ratio: float) -> None:
        r"""
        x.set_aspect_ratio(aspect_ratio) -> None
        Set Aspect Ratio
        
        Args:
            aspect_ratio (float):
        """
        ...
    def remove_blendable(self, blendable_object: BlendableInterface) -> None:
        r"""
        x.remove_blendable(blendable_object) -> None
        Removes a blendable.
        
        Args:
            blendable_object (BlendableInterface):
        """
        ...
    def get_camera_view(self, delta_time: float) -> MinimalViewInfo:
        r"""
        x.get_camera_view(delta_time) -> MinimalViewInfo
        Returns camera's Point of View.
        Called by Camera class. Subclass and postprocess to add any effects.
        
        Args:
            delta_time (float): 
        
        Returns:
            MinimalViewInfo: 
        
            desired_view (MinimalViewInfo):
        """
        ...
    def add_or_update_blendable(self, blendable_object: BlendableInterface, weight: float = 1.000000) -> None:
        r"""
        x.add_or_update_blendable(blendable_object, weight=1.000000) -> None
        Adds an Blendable (implements IBlendableInterface) to the array of Blendables (if it doesn't exist) and update the weight
        
        Args:
            blendable_object (BlendableInterface): 
            weight (float):
        """
        ...

class CineCameraComponent(CameraComponent):
    r"""
    A specialized version of a camera component, geared toward cinematic usage.
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``aspect_ratio`` (float):  [Read-Write] Aspect Ratio (Width/Height)
    - ``aspect_ratio_axis_constraint`` (AspectRatioAxisConstraint):  [Read-Write] Override for the default aspect ratio axis constraint defined on the local player
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_calculate_ortho_planes`` (bool):  [Read-Write] Automatically determine a min/max Near/Far clip plane position depending on OrthoWidth value
    - ``auto_plane_shift`` (float):  [Read-Write] Manually adjusts the planes of this camera, maintaining the distance between them. Positive moves out to the farplane, negative towards the near plane
    - ``camera_mesh`` (StaticMesh):  [Read-Write]
    - ``camera_mesh_hidden_in_game`` (bool):  [Read-Write] If the camera mesh is visible in game. Only relevant when running editor builds.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_aspect_ratio`` (bool):  [Read-Write] If bConstrainAspectRatio is true, black bars will be added if the destination view has a different aspect ratio than this camera requested.
    - ``crop_settings`` (PlateCropSettings):  [Read-Write] Controls the crop settings.
    - ``current_aperture`` (float):  [Read-Write] Current aperture, in terms of f-stop (e.g. 2.8 for f/2.8)
    - ``current_focal_length`` (float):  [Read-Write] Current focal length of the camera (i.e. controls FoV, zoom)
    - ``current_focus_distance`` (float):  [Read-Only] Read-only. Control this value via FocusSettings.
    - ``current_horizontal_fov`` (float):  [Read-Only] Read-only. Control this value with CurrentFocalLength (and filmback settings).
    - ``custom_near_clipping_plane`` (float):  [Read-Write] Set bOverride_CustomNearClippingPlane to true if you want to use a custom clipping plane instead of GNearClippingPlane.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``draw_frustum_allowed`` (bool):  [Read-Write] The Frustum visibility flag for draw frustum component initialization
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``field_of_view`` (float):  [Read-Write] The horizontal field of view (in degrees) in perspective mode (ignored in Orthographic mode)
      
      If the aspect ratio axis constraint (from ULocalPlayer, ALevelSequenceActor, etc.) is set to maintain vertical FOV, the AspectRatio
      property will be used to convert this property's value to a vertical FOV.
    - ``filmback`` (CameraFilmbackSettings):  [Read-Write] Controls the filmback of the camera.
    - ``focus_settings`` (CameraFocusSettings):  [Read-Write] Controls the camera's focus.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``lens_settings`` (CameraLensSettings):  [Read-Write] Controls the camera's lens.
    - ``lock_to_hmd`` (bool):  [Read-Write] True if the camera's orientation and position should be locked to the HMD
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``ortho_far_clip_plane`` (float):  [Read-Write] The far plane distance of the orthographic view (in world units)
    - ``ortho_near_clip_plane`` (float):  [Read-Write] The near plane distance of the orthographic view (in world units)
    - ``ortho_width`` (float):  [Read-Write] The desired width (in world units) of the orthographic view (ignored in Perspective mode)
    - ``override_aspect_ratio_axis_constraint`` (bool):  [Read-Write] Whether to override the default aspect ratio axis constraint defined on the local player
    - ``override_custom_near_clipping_plane`` (bool):  [Read-Write]
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``post_process_blend_weight`` (float):  [Read-Write] Indicates if PostProcessSettings should be used when using this Camera to view through.
    - ``post_process_settings`` (PostProcessSettings):  [Read-Write] Post process settings to use for this camera. Don't forget to check the properties you want to override
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``projection_mode`` (CameraProjectionMode):  [Read-Write] The type of camera
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``update_ortho_planes`` (bool):  [Read-Write] Adjusts the near/far planes and the view origin of the current camera automatically to avoid clipping and light artefacting
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_camera_height_as_view_target`` (bool):  [Read-Write] If UpdateOrthoPlanes is enabled, this setting will use the cameras current height to compensate the distance to the general view (as a pseudo distance to view target when one isn't present)
    - ``use_field_of_view_for_lod`` (bool):  [Read-Write] If true, account for the field of view angle when computing which level of detail to use for meshes.
    - ``use_pawn_control_rotation`` (bool):  [Read-Write] If this camera component is placed on a pawn, should it use the view/control rotation of the pawn where possible?
      see: APawn::GetViewRotation()
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def filmback(self) -> CameraFilmbackSettings:
        r"""
        (CameraFilmbackSettings):  [Read-Write] Controls the filmback of the camera.
        """
        ...
    @filmback.setter
    def filmback(self, value: CameraFilmbackSettings) -> None:
        ...
    @property
    def lens_settings(self) -> CameraLensSettings:
        r"""
        (CameraLensSettings):  [Read-Write] Controls the camera's lens.
        """
        ...
    @lens_settings.setter
    def lens_settings(self, value: CameraLensSettings) -> None:
        ...
    @property
    def focus_settings(self) -> CameraFocusSettings:
        r"""
        (CameraFocusSettings):  [Read-Write] Controls the camera's focus.
        """
        ...
    @focus_settings.setter
    def focus_settings(self, value: CameraFocusSettings) -> None:
        ...
    @property
    def crop_settings(self) -> PlateCropSettings:
        r"""
        (PlateCropSettings):  [Read-Write] Controls the crop settings.
        """
        ...
    @crop_settings.setter
    def crop_settings(self, value: PlateCropSettings) -> None:
        ...
    @property
    def current_focal_length(self) -> float:
        r"""
        (float):  [Read-Write] Current focal length of the camera (i.e. controls FoV, zoom)
        """
        ...
    @current_focal_length.setter
    def current_focal_length(self, value: float) -> None:
        ...
    @property
    def current_aperture(self) -> float:
        r"""
        (float):  [Read-Write] Current aperture, in terms of f-stop (e.g. 2.8 for f/2.8)
        """
        ...
    @current_aperture.setter
    def current_aperture(self, value: float) -> None:
        ...
    @property
    def current_focus_distance(self) -> float:
        r"""
        (float):  [Read-Only] Read-only. Control this value via FocusSettings.
        """
        ...
    @property
    def override_custom_near_clipping_plane(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_custom_near_clipping_plane.setter
    def override_custom_near_clipping_plane(self, value: bool) -> None:
        ...
    @property
    def custom_near_clipping_plane(self) -> float:
        r"""
        (float):  [Read-Write] Set bOverride_CustomNearClippingPlane to true if you want to use a custom clipping plane instead of GNearClippingPlane.
        """
        ...
    @custom_near_clipping_plane.setter
    def custom_near_clipping_plane(self, value: float) -> None:
        ...
    def set_lens_preset_by_name(self, preset_name: str) -> None:
        r"""
        x.set_lens_preset_by_name(preset_name) -> None
        Set the current lens settings by preset name.
        
        Args:
            preset_name (str):
        """
        ...
    def set_filmback_preset_by_name(self, preset_name: str) -> None:
        r"""
        x.set_filmback_preset_by_name(preset_name) -> None
        Set the current preset settings by preset name.
        
        Args:
            preset_name (str):
        """
        ...
    def set_crop_preset_by_name(self, preset_name: str) -> None:
        r"""
        x.set_crop_preset_by_name(preset_name) -> None
        Set the current lens settings by preset name.
        
        Args:
            preset_name (str):
        """
        ...
    def get_vertical_field_of_view(self) -> float:
        r"""
        x.get_vertical_field_of_view() -> float
        Returns the vertical FOV of the camera with current settings.
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_lens_presets_copy(cls) -> Array[NamedLensPreset]:
        r"""
        X.get_lens_presets_copy() -> Array[NamedLensPreset]
        Get Lens Presets Copy
        
        Returns:
            Array[NamedLensPreset]:
        """
        ...
    def get_lens_preset_name(self) -> str:
        r"""
        x.get_lens_preset_name() -> str
        Returns the lens name of the camera with the current settings.
        
        Returns:
            str:
        """
        ...
    def get_horizontal_field_of_view(self) -> float:
        r"""
        x.get_horizontal_field_of_view() -> float
        Returns the horizonal FOV of the camera with current settings.
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_filmback_presets_copy(cls) -> Array[NamedFilmbackPreset]:
        r"""
        X.get_filmback_presets_copy() -> Array[NamedFilmbackPreset]
        Get Filmback Presets Copy
        
        Returns:
            Array[NamedFilmbackPreset]:
        """
        ...
    def get_filmback_preset_name(self) -> str:
        r"""
        x.get_filmback_preset_name() -> str
        Returns the filmback name of the camera with the current settings.
        
        Returns:
            str:
        """
        ...
    def get_default_filmback_preset_name(self) -> str:
        r"""
        x.get_default_filmback_preset_name() -> str
        Get Default Filmback Preset Name
        
        Returns:
            str:
        """
        ...
    def get_crop_preset_name(self) -> str:
        r"""
        x.get_crop_preset_name() -> str
        Returns the lens name of the camera with the current settings.
        
        Returns:
            str:
        """
        ...

class DeveloperSettings(Object):
    r"""
    The base class of any auto discovered settings object.
    
    **C++ Source:**
    
    - **Module**: DeveloperSettings
    - **File**: DeveloperSettings.h
    
    """
    ...

class CineCameraSettings(DeveloperSettings):
    r"""
    Cine Camera Settings
    
    **C++ Source:**
    
    - **Module**: CinematicCamera
    - **File**: CineCameraSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``crop_presets`` (Array[NamedPlateCropPreset]):  [Read-Write] List of available crop presets
    - ``default_crop_preset_name`` (str):  [Read-Write] Name of the default crop preset
    - ``default_filmback_preset`` (str):  [Read-Write] Name of the default filmback preset
    - ``default_lens_f_stop`` (float):  [Read-Write] Default aperture (will be constrained by default lens)
    - ``default_lens_focal_length`` (float):  [Read-Write] Default focal length (will be constrained by default lens)
    - ``default_lens_preset_name`` (str):  [Read-Write] Name of the default lens preset
    - ``filmback_presets`` (Array[NamedFilmbackPreset]):  [Read-Write] List of available filmback presets
    - ``lens_presets`` (Array[NamedLensPreset]):  [Read-Write] List of available lens presets
    """
    @property
    def default_lens_preset_name(self) -> str:
        r"""
        (str):  [Read-Write] Name of the default lens preset
        """
        ...
    @default_lens_preset_name.setter
    def default_lens_preset_name(self, value: str) -> None:
        ...
    @property
    def default_lens_focal_length(self) -> float:
        r"""
        (float):  [Read-Write] Default focal length (will be constrained by default lens)
        """
        ...
    @default_lens_focal_length.setter
    def default_lens_focal_length(self, value: float) -> None:
        ...
    @property
    def default_lens_f_stop(self) -> float:
        r"""
        (float):  [Read-Write] Default aperture (will be constrained by default lens)
        """
        ...
    @default_lens_f_stop.setter
    def default_lens_f_stop(self, value: float) -> None:
        ...
    @property
    def lens_presets(self) -> Array[NamedLensPreset]:
        r"""
        (Array[NamedLensPreset]):  [Read-Write] List of available lens presets
        """
        ...
    @lens_presets.setter
    def lens_presets(self, value: Array[NamedLensPreset]) -> None:
        ...
    @property
    def default_filmback_preset(self) -> str:
        r"""
        (str):  [Read-Write] Name of the default filmback preset
        """
        ...
    @default_filmback_preset.setter
    def default_filmback_preset(self, value: str) -> None:
        ...
    @property
    def filmback_presets(self) -> Array[NamedFilmbackPreset]:
        r"""
        (Array[NamedFilmbackPreset]):  [Read-Write] List of available filmback presets
        """
        ...
    @filmback_presets.setter
    def filmback_presets(self, value: Array[NamedFilmbackPreset]) -> None:
        ...
    @property
    def default_crop_preset_name(self) -> str:
        r"""
        (str):  [Read-Write] Name of the default crop preset
        """
        ...
    @default_crop_preset_name.setter
    def default_crop_preset_name(self, value: str) -> None:
        ...
    @property
    def crop_presets(self) -> Array[NamedPlateCropPreset]:
        r"""
        (Array[NamedPlateCropPreset]):  [Read-Write] List of available crop presets
        """
        ...
    @crop_presets.setter
    def crop_presets(self, value: Array[NamedPlateCropPreset]) -> None:
        ...
    def get_lens_preset_by_name(self, preset_name: str) -> Optional[CameraLensSettings]:
        r"""
        x.get_lens_preset_by_name(preset_name) -> CameraLensSettings or None
        Gets the Lens settings associated with a given preset name
        Returns true if a preset with the given name was found
        
        Args:
            preset_name (str): 
        
        Returns:
            CameraLensSettings or None: 
        
            lens_settings (CameraLensSettings):
        """
        ...
    def get_filmback_preset_by_name(self, preset_name: str) -> Optional[CameraFilmbackSettings]:
        r"""
        x.get_filmback_preset_by_name(preset_name) -> CameraFilmbackSettings or None
        Gets the Filmback settings associated with a given preset name
        Returns true if a preset with the given name was found
        
        Args:
            preset_name (str): 
        
        Returns:
            CameraFilmbackSettings or None: 
        
            filmback_settings (CameraFilmbackSettings):
        """
        ...
    def get_crop_preset_by_name(self, preset_name: str) -> Optional[PlateCropSettings]:
        r"""
        x.get_crop_preset_by_name(preset_name) -> PlateCropSettings or None
        Gets the Crop settings associated with a given preset name
        Returns true if a preset with the given name was found
        
        Args:
            preset_name (str): 
        
        Returns:
            PlateCropSettings or None: 
        
            crop_settings (PlateCropSettings):
        """
        ...
    @classmethod
    def get_cine_camera_settings(cls) -> CineCameraSettings:
        r"""
        X.get_cine_camera_settings() -> CineCameraSettings
        Get Cine Camera Settings
        
        Returns:
            CineCameraSettings:
        """
        ...

class EngineSubsystem(DynamicSubsystem):
    r"""
    UEngineSubsystem
    Base class for auto instanced and initialized systems that share the lifetime of the Engine
    
    UEngineSubsystems are dynamic and will be initialized when the module is loaded if necessary.
    This means that after StartupModule() is called on the module containing a subsystem,
    the subsystem collection with instantiate and initialize the subsystem automatically.
    If the subsystem collection is created post module load then the instances will be created at
    collection initialization time.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineSubsystem.h
    
    """
    ...

class ConstraintSubsystem(EngineSubsystem):
    r"""
    Constraint Subsystem
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: ConstraintSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_constraint_added_to_system_bp`` (OnConstraintAddedToSystem):  [Read-Write] BP Delegate fired when constraints are added
    - ``on_constraint_removed_from_system_bp`` (OnConstraintRemovedFromSystem):  [Read-Write] BP Delegate fired when constraints are removed
    """
    @property
    def on_constraint_added_to_system_bp(self) -> OnConstraintAddedToSystem:
        r"""
        (OnConstraintAddedToSystem):  [Read-Write] BP Delegate fired when constraints are added
        """
        ...
    @on_constraint_added_to_system_bp.setter
    def on_constraint_added_to_system_bp(self, value: OnConstraintAddedToSystem) -> None:
        ...
    @property
    def on_constraint_removed_from_system_bp(self) -> OnConstraintRemovedFromSystem:
        r"""
        (OnConstraintRemovedFromSystem):  [Read-Write] BP Delegate fired when constraints are removed
        """
        ...
    @on_constraint_removed_from_system_bp.setter
    def on_constraint_removed_from_system_bp(self, value: OnConstraintRemovedFromSystem) -> None:
        ...

class ConstraintsActor(Actor):
    r"""
    Constraints Actor
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: ConstraintsActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class TickableConstraint(Object):
    r"""
    UTickableConstraint
    Represents the basic interface of constraint within the constraints manager.
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: ConstraintsManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active`` (bool):  [Read-Write]
      todo: documentation.
    """
    @property
    def active(self) -> bool:
        r"""
        (bool):  [Read-Write]
        todo: documentation.
        """
        ...
    @active.setter
    def active(self, value: bool) -> None:
        ...

class ConstraintsManager(Object):
    r"""
    UConstraintsManager
    This object gathers the different static/nonanimated constraints of the level and is held by the ConstraintsActor (unique in the level)
    Note in 5.4 all of the constraints are owned by the subsystem, so need to get that to get at animated constraints
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: ConstraintsManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_constraint_added_bp`` (OnConstraintAdded):  [Read-Write] BP Delegate fired when constraints are added
    - ``on_constraint_removed_bp`` (OnConstraintRemoved):  [Read-Write] BP Delegate fired when constraints are removed
    """
    @property
    def on_constraint_added_bp(self) -> OnConstraintAdded:
        r"""
        (OnConstraintAdded):  [Read-Write] BP Delegate fired when constraints are added
        """
        ...
    @on_constraint_added_bp.setter
    def on_constraint_added_bp(self, value: OnConstraintAdded) -> None:
        ...
    @property
    def on_constraint_removed_bp(self) -> OnConstraintRemoved:
        r"""
        (OnConstraintRemoved):  [Read-Write] BP Delegate fired when constraints are removed
        """
        ...
    @on_constraint_removed_bp.setter
    def on_constraint_removed_bp(self, value: OnConstraintRemoved) -> None:
        ...

class ConstraintsScriptingLibrary(BlueprintFunctionLibrary):
    r"""
    This is a set of helper functions to access various parts of the Sequencer and Control Rig API via Python and Blueprints.
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: ConstraintsScripting.h
    
    """
    @classmethod
    def remove_this_constraint(cls, world: World, tickable_constraint: TickableConstraint) -> bool:
        r"""
        X.remove_this_constraint(world, tickable_constraint) -> bool
        Remove specified constraint
        
        Args:
            world (World): World to remove the constraint
            tickable_constraint (TickableConstraint): Constraint to remove
        
        Returns:
            bool: return If constraint removed correctly
        """
        ...
    @classmethod
    def remove_constraint(cls, world: World, index: int) -> bool:
        r"""
        X.remove_constraint(world, index) -> bool
        Remove constraint at specified index
        
        Args:
            world (World): World to remove the constraint
            index (int32): Index to remove from
        
        Returns:
            bool: return If constraint removed correctly
        """
        ...
    @classmethod
    def get_constraints_array(cls, world: World) -> Array[TickableConstraint]:
        r"""
        X.get_constraints_array(world) -> Array[TickableConstraint]
        Get a copy of the constraints in the current world
        
        Args:
            world (World): World we are in
        
        Returns:
            Array[TickableConstraint]: Copy of the constraints in the level
        """
        ...
    @classmethod
    def create_transformable_handle(cls, world: World, object: Object, attachment_name: Name = "None") -> TransformableHandle:
        r"""
        X.create_transformable_handle(world, object, attachment_name="None") -> TransformableHandle
        Create the transformable handle that deals with getting and setting transforms on this object
        
        Args:
            world (World): 
            object (Object): World to create the constraint
            attachment_name (Name): Optional name of the attachment to get the transform. Not that this can represent a scene component's socket name or a control rig control for example.
        
        Returns:
            TransformableHandle: returns the handle for this scene component
        """
        ...
    @classmethod
    def create_transformable_component_handle(cls, world: World, scene_component: SceneComponent, socket_name: Name) -> TransformableComponentHandle:
        r"""
        X.create_transformable_component_handle(world, scene_component, socket_name) -> TransformableComponentHandle
        Create the transformable handle that deals with getting and setting transforms on this scene component
        
        Args:
            world (World): 
            scene_component (SceneComponent): World to create the constraint
            socket_name (Name): Optional name of the socket to get the transform
        
        Returns:
            TransformableComponentHandle: returns the handle for this scene component
        """
        ...
    @classmethod
    def create_from_type(cls, world: World, type: TransformConstraintType) -> TickableTransformConstraint:
        r"""
        X.create_from_type(world, type) -> TickableTransformConstraint
        Create Constraint based on the specified type.
        
        Args:
            world (World): World to create the constraint
            type (TransformConstraintType): The type of constraint
        
        Returns:
            TickableTransformConstraint: return The constraint object
        """
        ...
    @classmethod
    def add_constraint(cls, world: World, parent_handle: TransformableHandle, child_handle: TransformableHandle, constraint: TickableTransformConstraint, maintain_offset: bool) -> bool:
        r"""
        X.add_constraint(world, parent_handle, child_handle, constraint, maintain_offset) -> bool
        Add Constraint
        
        Args:
            world (World): 
            parent_handle (TransformableHandle): 
            child_handle (TransformableHandle): 
            constraint (TickableTransformConstraint): 
            maintain_offset (bool): 
        
        Returns:
            bool:
        """
        ...

class TransformableHandle(Object):
    r"""
    UTransformableHandle
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: TransformableHandle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``constraint_binding_id`` (MovieSceneObjectBindingID):  [Read-Write] possible bindingID
    """
    @property
    def constraint_binding_id(self) -> MovieSceneObjectBindingID:
        r"""
        (MovieSceneObjectBindingID):  [Read-Only] possible bindingID
        """
        ...

class TransformableComponentHandle(TransformableHandle):
    r"""
    Transformable Component Handle
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: TransformableHandle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``component`` (SceneComponent):  [Read-Write] The Component that this handle is pointing at.
    - ``constraint_binding_id`` (MovieSceneObjectBindingID):  [Read-Write] possible bindingID
    - ``socket_name`` (Name):  [Read-Write] Optional socket name on Component.
    """
    @property
    def component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Only] The Component that this handle is pointing at.
        """
        ...
    @property
    def socket_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Optional socket name on Component.
        """
        ...

class TickableTransformConstraint(TickableConstraint):
    r"""
    UTickableTransformConstraint
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active`` (bool):  [Read-Write]
      todo: documentation.
    - ``child_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the child of that constraint.
    - ``dynamic_offset`` (bool):  [Read-Write] Should the child be able to change it's offset dynamically.
    - ``maintain_offset`` (bool):  [Read-Write] Should that constraint maintain the default offset.
    - ``parent_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the parent of that constraint.
    """
    @property
    def parent_trs_handle(self) -> TransformableHandle:
        r"""
        (TransformableHandle):  [Read-Write] The transformable handle representing the parent of that constraint.
        """
        ...
    @parent_trs_handle.setter
    def parent_trs_handle(self, value: TransformableHandle) -> None:
        ...
    @property
    def child_trs_handle(self) -> TransformableHandle:
        r"""
        (TransformableHandle):  [Read-Write] The transformable handle representing the child of that constraint.
        """
        ...
    @child_trs_handle.setter
    def child_trs_handle(self, value: TransformableHandle) -> None:
        ...
    @property
    def maintain_offset(self) -> bool:
        r"""
        (bool):  [Read-Write] Should that constraint maintain the default offset.
        """
        ...
    @maintain_offset.setter
    def maintain_offset(self, value: bool) -> None:
        ...
    @property
    def dynamic_offset(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the child be able to change it's offset dynamically.
        """
        ...
    @dynamic_offset.setter
    def dynamic_offset(self, value: bool) -> None:
        ...

class TickableTranslationConstraint(TickableTransformConstraint):
    r"""
    UTickableTranslationConstraint
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active`` (bool):  [Read-Write]
      todo: documentation.
    - ``axis_filter`` (FilterOptionPerAxis):  [Read-Write] Defines which translation axis is constrained.
    - ``child_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the child of that constraint.
    - ``dynamic_offset`` (bool):  [Read-Write] Should the child be able to change it's offset dynamically.
    - ``maintain_offset`` (bool):  [Read-Write] Should that constraint maintain the default offset.
    - ``offset_translation`` (Vector):  [Read-Write] Defines the local child's translation offset in the parent space.
    - ``parent_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the parent of that constraint.
    """
    @property
    def offset_translation(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Defines the local child's translation offset in the parent space.
        """
        ...
    @offset_translation.setter
    def offset_translation(self, value: Vector) -> None:
        ...
    @property
    def axis_filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write] Defines which translation axis is constrained.
        """
        ...
    @axis_filter.setter
    def axis_filter(self, value: FilterOptionPerAxis) -> None:
        ...

class TickableRotationConstraint(TickableTransformConstraint):
    r"""
    UTickableRotationConstraint
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active`` (bool):  [Read-Write]
      todo: documentation.
    - ``axis_filter`` (FilterOptionPerAxis):  [Read-Write] Defines which rotation axis is constrained.
    - ``child_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the child of that constraint.
    - ``dynamic_offset`` (bool):  [Read-Write] Should the child be able to change it's offset dynamically.
    - ``maintain_offset`` (bool):  [Read-Write] Should that constraint maintain the default offset.
    - ``offset_rotation`` (Quat):  [Read-Write] Defines the local child's rotation offset in the parent space.
    - ``parent_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the parent of that constraint.
    """
    @property
    def offset_rotation(self) -> Quat:
        r"""
        (Quat):  [Read-Write] Defines the local child's rotation offset in the parent space.
        """
        ...
    @offset_rotation.setter
    def offset_rotation(self, value: Quat) -> None:
        ...
    @property
    def axis_filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write] Defines which rotation axis is constrained.
        """
        ...
    @axis_filter.setter
    def axis_filter(self, value: FilterOptionPerAxis) -> None:
        ...

class TickableScaleConstraint(TickableTransformConstraint):
    r"""
    UTickableScaleConstraint
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active`` (bool):  [Read-Write]
      todo: documentation.
    - ``axis_filter`` (FilterOptionPerAxis):  [Read-Write] Defines which scale axis is constrained.
    - ``child_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the child of that constraint.
    - ``dynamic_offset`` (bool):  [Read-Write] Should the child be able to change it's offset dynamically.
    - ``maintain_offset`` (bool):  [Read-Write] Should that constraint maintain the default offset.
    - ``offset_scale`` (Vector):  [Read-Write] Defines the local child's scale offset in the parent space.
    - ``parent_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the parent of that constraint.
    """
    @property
    def offset_scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Defines the local child's scale offset in the parent space.
        """
        ...
    @offset_scale.setter
    def offset_scale(self, value: Vector) -> None:
        ...
    @property
    def axis_filter(self) -> FilterOptionPerAxis:
        r"""
        (FilterOptionPerAxis):  [Read-Write] Defines which scale axis is constrained.
        """
        ...
    @axis_filter.setter
    def axis_filter(self, value: FilterOptionPerAxis) -> None:
        ...

class TickableParentConstraint(TickableTransformConstraint):
    r"""
    UTickableParentConstraint
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active`` (bool):  [Read-Write]
      todo: documentation.
    - ``child_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the child of that constraint.
    - ``dynamic_offset`` (bool):  [Read-Write] Should the child be able to change it's offset dynamically.
    - ``maintain_offset`` (bool):  [Read-Write] Should that constraint maintain the default offset.
    - ``offset_transform`` (Transform):  [Read-Write] Defines the local child's transform offset in the parent space.
    - ``parent_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the parent of that constraint.
    - ``scaling`` (bool):  [Read-Write] Defines whether we propagate the parent scale.
    - ``transform_filter`` (TransformFilter):  [Read-Write] Defines which translation/rotation/scale axis are constrained.
    """
    @property
    def offset_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Defines the local child's transform offset in the parent space.
        """
        ...
    @offset_transform.setter
    def offset_transform(self, value: Transform) -> None:
        ...
    @property
    def scaling(self) -> bool:
        r"""
        (bool):  [Read-Write] Defines whether we propagate the parent scale.
        """
        ...
    @scaling.setter
    def scaling(self, value: bool) -> None:
        ...
    @property
    def transform_filter(self) -> TransformFilter:
        r"""
        (TransformFilter):  [Read-Write] Defines which translation/rotation/scale axis are constrained.
        """
        ...
    @transform_filter.setter
    def transform_filter(self, value: TransformFilter) -> None:
        ...

class TickableLookAtConstraint(TickableTransformConstraint):
    r"""
    UTickableLookAtConstraint
    
    **C++ Source:**
    
    - **Module**: Constraints
    - **File**: TransformConstraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``active`` (bool):  [Read-Write]
      todo: documentation.
    - ``axis`` (Vector):  [Read-Write] Defines the aiming axis.
    - ``child_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the child of that constraint.
    - ``dynamic_offset`` (bool):  [Read-Write] Should the child be able to change it's offset dynamically.
    - ``maintain_offset`` (bool):  [Read-Write] Should that constraint maintain the default offset.
    - ``parent_trs_handle`` (TransformableHandle):  [Read-Write] The transformable handle representing the parent of that constraint.
    """
    @property
    def axis(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Defines the aiming axis.
        """
        ...
    @axis.setter
    def axis(self, value: Vector) -> None:
        ...

class DataLayerEditorSubsystem(EditorSubsystem):
    r"""
    Data Layer Editor Subsystem
    
    **C++ Source:**
    
    - **Module**: DataLayerEditor
    - **File**: DataLayerEditorSubsystem.h
    
    """
    def update_all_view_visibility(self, data_layer_that_changed: DataLayer) -> None:
        r"""
        x.update_all_view_visibility(data_layer_that_changed) -> None
        Update All View Visibility
        deprecated: Per-view Data Layer visibility was removed.
        
        Args:
            data_layer_that_changed (DataLayer):
        """
        ...
    def update_all_actors_visibility(self, notify_selection_change: bool, redraw_viewports: bool) -> bool:
        r"""
        x.update_all_actors_visibility(notify_selection_change, redraw_viewports) -> bool
        Updates the visibility of all actors in the viewports
        
        Args:
            notify_selection_change (bool): If true the Editor is notified of the selection change; if false, the Editor will not be notified
            redraw_viewports (bool): If true the viewports will be redrawn; if false, they will not
        
        Returns:
            bool:
        """
        ...
    def update_actor_visibility(self, actor: Actor, notify_selection_change: bool, redraw_viewports: bool) -> Optional[Tuple[bool, bool]]:
        r"""
        x.update_actor_visibility(actor, notify_selection_change, redraw_viewports) -> (out_selection_changed=bool, out_actor_modified=bool) or None
        Updates the provided actors visibility in the viewports
        
        Args:
            actor (Actor): Actor to update
            notify_selection_change (bool): If true the Editor is notified of the selection change; if false, the Editor will not be notified
            redraw_viewports (bool): If true the viewports will be redrawn; if false, they will not
        
        Returns:
            tuple or None: 
        
            out_selection_changed (bool): [OUT]      Whether the Editors selection changed
        
            out_actor_modified (bool): [OUT]         Whether the actor was modified
        """
        ...
    def update_actor_all_views_visibility(self, actor: Actor) -> None:
        r"""
        x.update_actor_all_views_visibility(actor) -> None
        Update Actor All Views Visibility
        deprecated: Per-view Data Layer visibility was removed.
        
        Args:
            actor (Actor):
        """
        ...
    def toggle_data_layer_visibility(self, data_layer: DataLayerInstance) -> None:
        r"""
        x.toggle_data_layer_visibility(data_layer) -> None
        Toggles the DataLayer's visibility
        
        Args:
            data_layer (DataLayerInstance): The DataLayer to affect
        """
        ...
    def toggle_data_layers_visibility(self, data_layers: Array[DataLayerInstance]) -> None:
        r"""
        x.toggle_data_layers_visibility(data_layers) -> None
        Toggles the visibility of all of the DataLayers
        
        Args:
            data_layers (Array[DataLayerInstance]): The DataLayers to affect
        """
        ...
    def toggle_data_layers_is_loaded_in_editor(self, data_layers: Array[DataLayerInstance], is_from_user_change: bool) -> bool:
        r"""
        x.toggle_data_layers_is_loaded_in_editor(data_layers, is_from_user_change) -> bool
        Toggles the IsLoadedInEditor flag of all of the DataLayers
        
        Args:
            data_layers (Array[DataLayerInstance]): The DataLayers to affect
            is_from_user_change (bool): If this change originates from a user change or not.
        
        Returns:
            bool:
        """
        ...
    def toggle_data_layers_is_dynamically_loaded_in_editor(self, data_layers: Array[DataLayer], is_from_user_change: bool) -> bool:
        r"""
        x.toggle_data_layers_is_dynamically_loaded_in_editor(data_layers, is_from_user_change) -> bool
        Toggle Data Layers Is Dynamically Loaded in Editor
        deprecated: Use ToggleDataLayersIsLoadedInEditor instead
        
        Args:
            data_layers (Array[DataLayer]): 
            is_from_user_change (bool): 
        
        Returns:
            bool:
        """
        ...
    def toggle_data_layer_is_loaded_in_editor(self, data_layer: DataLayerInstance, is_from_user_change: bool) -> bool:
        r"""
        x.toggle_data_layer_is_loaded_in_editor(data_layer, is_from_user_change) -> bool
        Toggles the DataLayer's IsLoadedInEditor flag
        
        Args:
            data_layer (DataLayerInstance): The DataLayer to affect
            is_from_user_change (bool): If this change originates from a user change or not.
        
        Returns:
            bool:
        """
        ...
    def toggle_data_layer_is_dynamically_loaded_in_editor(self, data_layer: DataLayer, is_from_user_change: bool) -> bool:
        r"""
        x.toggle_data_layer_is_dynamically_loaded_in_editor(data_layer, is_from_user_change) -> bool
        Toggle Data Layer Is Dynamically Loaded in Editor
        deprecated: Use ToggleDataLayerIsLoadedInEditor instead
        
        Args:
            data_layer (DataLayer): 
            is_from_user_change (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_parent_data_layer(self, data_layer: DataLayerInstance, parent_data_layer: DataLayerInstance) -> bool:
        r"""
        x.set_parent_data_layer(data_layer, parent_data_layer) -> bool
        Sets a Parent DataLayer for a specified DataLayer
        
        Args:
            data_layer (DataLayerInstance): The child DataLayer.
            parent_data_layer (DataLayerInstance): The parent DataLayer.
        
        Returns:
            bool: true if succeeded, false if failed.
        """
        ...
    def set_data_layer_visibility(self, data_layer: DataLayerInstance, is_visible: bool) -> None:
        r"""
        x.set_data_layer_visibility(data_layer, is_visible) -> None
        Changes the DataLayer's visibility to the provided state
        
        Args:
            data_layer (DataLayerInstance): The DataLayer to affect.
            is_visible (bool): If true the DataLayer will be visible; if false, the DataLayer will not be visible.
        """
        ...
    def set_data_layers_visibility(self, data_layers: Array[DataLayerInstance], is_visible: bool) -> None:
        r"""
        x.set_data_layers_visibility(data_layers, is_visible) -> None
        Changes visibility of the DataLayers to the provided state
        
        Args:
            data_layers (Array[DataLayerInstance]): The DataLayers to affect
            is_visible (bool): If true the DataLayers will be visible; if false, the DataLayers will not be visible
        """
        ...
    def set_data_layers_is_loaded_in_editor(self, data_layers: Array[DataLayerInstance], is_loaded_in_editor: bool, is_from_user_change: bool) -> bool:
        r"""
        x.set_data_layers_is_loaded_in_editor(data_layers, is_loaded_in_editor, is_from_user_change) -> bool
        Changes the IsLoadedInEditor flag of the DataLayers to the provided state
        
        Args:
            data_layers (Array[DataLayerInstance]): The DataLayers to affect
            is_loaded_in_editor (bool): The new value of the flag IsLoadedInEditor. If True, the Editor loading will consider this DataLayer to load or not an Actor part of this DataLayer. An Actor will not be loaded in the Editor if all its DataLayers are not LoadedInEditor.
            is_from_user_change (bool): If this change originates from a user change or not.
        
        Returns:
            bool:
        """
        ...
    def set_data_layers_is_dynamically_loaded_in_editor(self, data_layers: Array[DataLayer], is_loaded_in_editor: bool, is_from_user_change: bool) -> bool:
        r"""
        x.set_data_layers_is_dynamically_loaded_in_editor(data_layers, is_loaded_in_editor, is_from_user_change) -> bool
        Set Data Layers Is Dynamically Loaded in Editor
        deprecated: Use SetDataLayersIsLoadedInEditor instead
        
        Args:
            data_layers (Array[DataLayer]): 
            is_loaded_in_editor (bool): 
            is_from_user_change (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_data_layer_is_loaded_in_editor(self, data_layer: DataLayerInstance, is_loaded_in_editor: bool, is_from_user_change: bool) -> bool:
        r"""
        x.set_data_layer_is_loaded_in_editor(data_layer, is_loaded_in_editor, is_from_user_change) -> bool
        Changes the DataLayer's IsLoadedInEditor flag to the provided state
        
        Args:
            data_layer (DataLayerInstance): The DataLayer to affect.
            is_loaded_in_editor (bool): The new value of the flag IsLoadedInEditor. If True, the Editor loading will consider this DataLayer to load or not an Actor part of this DataLayer. An Actor will not be loaded in the Editor if all its DataLayers are not LoadedInEditor.
            is_from_user_change (bool): If this change originates from a user change or not.
        
        Returns:
            bool:
        """
        ...
    def set_data_layer_is_dynamically_loaded_in_editor(self, data_layer: DataLayer, is_loaded_in_editor: bool, is_from_user_change: bool) -> bool:
        r"""
        x.set_data_layer_is_dynamically_loaded_in_editor(data_layer, is_loaded_in_editor, is_from_user_change) -> bool
        Set Data Layer Is Dynamically Loaded in Editor
        deprecated: Use SetDataLayerIsLoadedInEditor instead
        
        Args:
            data_layer (DataLayer): 
            is_loaded_in_editor (bool): 
            is_from_user_change (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_actor_editor_context_current_external_data_layer(self, external_data_layer_asset: ExternalDataLayerAsset) -> bool:
        r"""
        x.set_actor_editor_context_current_external_data_layer(external_data_layer_asset) -> bool
        Set Actor Editor Context Current External Data Layer
        
        Args:
            external_data_layer_asset (ExternalDataLayerAsset): 
        
        Returns:
            bool:
        """
        ...
    def select_actors_in_data_layers(self, data_layers: Array[DataLayerInstance], select: bool, notify: bool, select_even_if_hidden: bool = False) -> bool:
        r"""
        x.select_actors_in_data_layers(data_layers, select, notify, select_even_if_hidden=False) -> bool
        Selects/de-selects actors belonging to the DataLayers.
        
        Args:
            data_layers (Array[DataLayerInstance]): A valid list of DataLayers.
            select (bool): If true actors are selected; if false, actors are deselected.
            notify (bool): If true the Editor is notified of the selection change; if false, the Editor will not be notified
            select_even_if_hidden (bool): [optional]      If true even hidden actors will be selected; if false, hidden actors won't be selected.
        
        Returns:
            bool: true if at least one actor was selected/deselected.
        """
        ...
    def select_actors_in_data_layer(self, data_layer: DataLayerInstance, select: bool, notify: bool, select_even_if_hidden: bool = False) -> bool:
        r"""
        x.select_actors_in_data_layer(data_layer, select, notify, select_even_if_hidden=False) -> bool
        Selects/de-selects actors belonging to the DataLayer.
        
        Args:
            data_layer (DataLayerInstance): A valid DataLayer.
            select (bool): If true actors are selected; if false, actors are deselected.
            notify (bool): If true the Editor is notified of the selection change; if false, the Editor will not be notified.
            select_even_if_hidden (bool): [optional]      If true even hidden actors will be selected; if false, hidden actors won't be selected.
        
        Returns:
            bool: true if at least one actor was selected/deselected.
        """
        ...
    def rename_data_layer(self, data_layer: DataLayerInstance, new_data_layer_label: Name) -> bool:
        r"""
        x.rename_data_layer(data_layer, new_data_layer_label) -> bool
        Rename Data Layer
        
        Args:
            data_layer (DataLayerInstance): 
            new_data_layer_label (Name): 
        
        Returns:
            bool:
        """
        ...
    def remove_selected_actors_from_data_layers(self, data_layers: Array[DataLayerInstance]) -> bool:
        r"""
        x.remove_selected_actors_from_data_layers(data_layers) -> bool
        Removes selected actors from the DataLayers.
        
        Args:
            data_layers (Array[DataLayerInstance]): A valid list of DataLayers.
        
        Returns:
            bool: true if at least one actor was removed.
        """
        ...
    def remove_selected_actors_from_data_layer(self, data_layer: DataLayerInstance) -> bool:
        r"""
        x.remove_selected_actors_from_data_layer(data_layer) -> bool
        Removes the selected actors from the DataLayer.
        
        Args:
            data_layer (DataLayerInstance): A DataLayer.
        
        Returns:
            bool: true if at least one actor was added.  false is returned if all selected actors already belong to the DataLayer.
        """
        ...
    def remove_from_actor_editor_context(self, data_layer_instance: DataLayerInstance) -> None:
        r"""
        x.remove_from_actor_editor_context(data_layer_instance) -> None
        Remove from Actor Editor Context
        
        Args:
            data_layer_instance (DataLayerInstance):
        """
        ...
    def remove_actors_from_data_layers(self, actors: Array[Actor], data_layers: Array[DataLayerInstance]) -> bool:
        r"""
        x.remove_actors_from_data_layers(actors, data_layers) -> bool
        Remove the actors from the DataLayers
        
        Args:
            actors (Array[Actor]): The actors to remove to the DataLayers
            data_layers (Array[DataLayerInstance]): A valid list of DataLayers.
        
        Returns:
            bool: true if at least one actor was removed from at least one DataLayer.  false is returned if none of the actors belonged to any of the specified DataLayers.
        """
        ...
    def remove_actors_from_data_layer(self, actors: Array[Actor], data_layer: DataLayerInstance) -> bool:
        r"""
        x.remove_actors_from_data_layer(actors, data_layer) -> bool
        Removes the actors from the specified DataLayer.
        
        Args:
            actors (Array[Actor]): The actors to remove from the provided DataLayer
            data_layer (DataLayerInstance): 
        
        Returns:
            bool: true if at least one actor was removed from the DataLayer.  false is returned if all the actors already belonged to the DataLayer.
        """
        ...
    def remove_actors_from_all_data_layers(self, actors: Array[Actor]) -> bool:
        r"""
        x.remove_actors_from_all_data_layers(actors) -> bool
        Removes an actor from all DataLayers.
        
        Args:
            actors (Array[Actor]): 
        
        Returns:
            bool: true if any actor was changed.
        """
        ...
    def remove_actor_from_data_layers(self, actor: Actor, data_layers: Array[DataLayerInstance]) -> bool:
        r"""
        x.remove_actor_from_data_layers(actor, data_layers) -> bool
        Removes the provided actor from the DataLayers.
        
        Args:
            actor (Actor): The actor to remove from the provided DataLayers
            data_layers (Array[DataLayerInstance]): A valid list of DataLayers.
        
        Returns:
            bool: true if the actor was removed from at least one of the provided DataLayers.
        """
        ...
    def remove_actor_from_data_layer(self, actor: Actor, data_layer_to_remove: DataLayerInstance) -> bool:
        r"""
        x.remove_actor_from_data_layer(actor, data_layer_to_remove) -> bool
        Removes an actor from the specified DataLayer.
        
        Args:
            actor (Actor): The actor to remove from the provided DataLayer
            data_layer_to_remove (DataLayerInstance): The DataLayer to remove the actor from
        
        Returns:
            bool: true if the actor was removed from the DataLayer.  false is returned if the actor already belonged to the DataLayer.
        """
        ...
    def remove_actor_from_all_data_layers(self, actor: Actor) -> bool:
        r"""
        x.remove_actor_from_all_data_layers(actor) -> bool
        Removes an actor from all DataLayers.
        
        Args:
            actor (Actor): The actor to modify
        
        Returns:
            bool: true if the actor was changed.
        """
        ...
    def make_all_data_layers_visible(self) -> None:
        r"""
        x.make_all_data_layers_visible() -> None
        Set the visibility of all DataLayers to true
        """
        ...
    def is_actor_valid_for_data_layer_instances(self, actor: Actor, data_layer_instances: Array[DataLayerInstance]) -> bool:
        r"""
        x.is_actor_valid_for_data_layer_instances(actor, data_layer_instances) -> bool
        Checks to see if the specified actor is in an appropriate state to interact with DataLayers
        
        Args:
            actor (Actor): The actor to validate
            data_layer_instances (Array[DataLayerInstance]): The data layers used to do the validation
        
        Returns:
            bool:
        """
        ...
    def is_actor_valid_for_data_layer(self, actor: Actor) -> bool:
        r"""
        x.is_actor_valid_for_data_layer(actor) -> bool
        Is Actor Valid for Data Layer
        
        Args:
            actor (Actor): 
        
        Returns:
            bool:
        """
        ...
    def get_data_layer_instances(self, data_layer_assets: Array[DataLayerAsset]) -> Array[DataLayerInstance]:
        r"""
        x.get_data_layer_instances(data_layer_assets) -> Array[DataLayerInstance]
        Gets the UDataLayerInstances associated to the each DataLayerAssets
        
        Args:
            data_layer_assets (Array[DataLayerAsset]): The array of DataLayerAssets associated to UDataLayerInstances
        
        Returns:
            Array[DataLayerInstance]: The array of UDataLayerInstances corresponding to a DataLayerAsset in the DataLayerAssets array
        """
        ...
    def get_data_layer_instance(self, data_layer_asset: DataLayerAsset) -> DataLayerInstance:
        r"""
        x.get_data_layer_instance(data_layer_asset) -> DataLayerInstance
        Gets the UDataLayerInstance associated to the DataLayerAsset
        
        Args:
            data_layer_asset (DataLayerAsset): The DataLayerAsset associated to the UDataLayerInstance
        
        Returns:
            DataLayerInstance: The UDataLayerInstance of the provided DataLayerAsset
        """
        ...
    def get_data_layer_from_label(self, data_layer_label: Name) -> DataLayerInstance:
        r"""
        x.get_data_layer_from_label(data_layer_label) -> DataLayerInstance
        Get Data Layer from Label
        
        Args:
            data_layer_label (Name): 
        
        Returns:
            DataLayerInstance:
        """
        ...
    def get_data_layer(self, actor_data_layer: ActorDataLayer) -> DataLayerInstance:
        r"""
        x.get_data_layer(actor_data_layer) -> DataLayerInstance
        Get Data Layer
        
        Args:
            actor_data_layer (ActorDataLayer): 
        
        Returns:
            DataLayerInstance:
        """
        ...
    def get_all_data_layers(self) -> Array[DataLayerInstance]:
        r"""
        x.get_all_data_layers() -> Array[DataLayerInstance]
        Returns all Data Layers
        
        Returns:
            Array[DataLayerInstance]:
        """
        ...
    def get_actors_from_data_layers(self, data_layers: Array[DataLayerInstance]) -> Array[Actor]:
        r"""
        x.get_actors_from_data_layers(data_layers) -> Array[Actor]
        Gets all the actors associated with ANY of the specified DataLayers. Analog to AppendActorsFromDataLayers but it returns rather than appends the actors.
        
        Args:
            data_layers (Array[DataLayerInstance]): The DataLayers to find actors for.
        
        Returns:
            Array[Actor]: The list to assign the found actors to.
        """
        ...
    def get_actors_from_data_layer(self, data_layer: DataLayerInstance) -> Array[Actor]:
        r"""
        x.get_actors_from_data_layer(data_layer) -> Array[Actor]
        Gets all the actors associated with the specified DataLayer. Analog to AppendActorsFromDataLayer but it returns rather than appends the actors.
        
        Args:
            data_layer (DataLayerInstance): The DataLayer to find actors for.
        
        Returns:
            Array[Actor]: The list to assign the found actors to.
        """
        ...
    def get_actor_editor_context_current_external_data_layer(self) -> ExternalDataLayerAsset:
        r"""
        x.get_actor_editor_context_current_external_data_layer() -> ExternalDataLayerAsset
        Get Actor Editor Context Current External Data Layer
        
        Returns:
            ExternalDataLayerAsset:
        """
        ...
    def delete_data_layers(self, data_layers_to_delete: Array[DataLayerInstance]) -> None:
        r"""
        x.delete_data_layers(data_layers_to_delete) -> None
        Deletes all of the provided DataLayers
        
        Args:
            data_layers_to_delete (Array[DataLayerInstance]): A valid list of DataLayer.
        """
        ...
    def delete_data_layer(self, data_layer_to_delete: DataLayerInstance) -> None:
        r"""
        x.delete_data_layer(data_layer_to_delete) -> None
        Deletes the provided DataLayer
        
        Args:
            data_layer_to_delete (DataLayerInstance): A valid DataLayer
        """
        ...
    def create_data_layer_instance(self, parameters: DataLayerCreationParameters) -> DataLayerInstance:
        r"""
        x.create_data_layer_instance(parameters) -> DataLayerInstance
        Creates a UDataLayerInstance Object
        
        Args:
            parameters (DataLayerCreationParameters): The Data Layer Instance creation parameters
        
        Returns:
            DataLayerInstance: The newly created UDataLayerInstance Object
        """
        ...
    def create_data_layer(self, parent_data_layer: DataLayerInstance = None) -> DataLayerInstance:
        r"""
        x.create_data_layer(parent_data_layer=None) -> DataLayerInstance
        Create Data Layer
        
        Args:
            parent_data_layer (DataLayerInstance): 
        
        Returns:
            DataLayerInstance:
        """
        ...
    def append_actors_from_data_layers(self, data_layers: Array[DataLayerInstance]) -> Array[Actor]:
        r"""
        x.append_actors_from_data_layers(data_layers) -> Array[Actor]
        Appends all the actors associated with ANY of the specified DataLayers.
        
        Args:
            data_layers (Array[DataLayerInstance]): The DataLayers to find actors for.
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]): The list to append the found actors to.
        """
        ...
    def append_actors_from_data_layer(self, data_layer: DataLayerInstance) -> Array[Actor]:
        r"""
        x.append_actors_from_data_layer(data_layer) -> Array[Actor]
        Appends all the actors associated with the specified DataLayer.
        
        Args:
            data_layer (DataLayerInstance): The DataLayer to find actors for.
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]): The list to append the found actors to.
        """
        ...
    def add_to_actor_editor_context(self, data_layer_instance: DataLayerInstance) -> None:
        r"""
        x.add_to_actor_editor_context(data_layer_instance) -> None
        Add to Actor Editor Context
        
        Args:
            data_layer_instance (DataLayerInstance):
        """
        ...
    def add_selected_actors_to_data_layers(self, data_layers: Array[DataLayerInstance]) -> bool:
        r"""
        x.add_selected_actors_to_data_layers(data_layers) -> bool
        Adds selected actors to the DataLayers.
        
        Args:
            data_layers (Array[DataLayerInstance]): A valid list of DataLayers.
        
        Returns:
            bool: true if at least one actor was added.  false is returned if all selected actors already belong to the DataLayers.
        """
        ...
    def add_selected_actors_to_data_layer(self, data_layer: DataLayerInstance) -> bool:
        r"""
        x.add_selected_actors_to_data_layer(data_layer) -> bool
        Adds selected actors to the DataLayer.
        
        Args:
            data_layer (DataLayerInstance): A DataLayer.
        
        Returns:
            bool: true if at least one actor was added.  false is returned if all selected actors already belong to the DataLayer.
        """
        ...
    def add_actor_to_data_layers(self, actor: Actor, data_layers: Array[DataLayerInstance]) -> bool:
        r"""
        x.add_actor_to_data_layers(actor, data_layers) -> bool
        Adds the provided actor to the DataLayers.
        
        Args:
            actor (Actor): The actor to add to the provided DataLayers
            data_layers (Array[DataLayerInstance]): A valid list of DataLayers.
        
        Returns:
            bool: true if the actor was added to at least one of the provided DataLayers.
        """
        ...
    def add_actor_to_data_layer(self, actor: Actor, data_layer: DataLayerInstance) -> bool:
        r"""
        x.add_actor_to_data_layer(actor, data_layer) -> bool
        Adds the actor to the DataLayer.
        
        Args:
            actor (Actor): The actor to add to the DataLayer
            data_layer (DataLayerInstance): The DataLayer to add the actor to
        
        Returns:
            bool: true if the actor was added.  false is returned if the actor already belongs to the DataLayer.
        """
        ...
    def add_actors_to_data_layers(self, actors: Array[Actor], data_layers: Array[DataLayerInstance]) -> bool:
        r"""
        x.add_actors_to_data_layers(actors, data_layers) -> bool
        Add the actors to the DataLayers
        
        Args:
            actors (Array[Actor]): The actors to add to the DataLayers
            data_layers (Array[DataLayerInstance]): A valid list of DataLayers.
        
        Returns:
            bool: true if at least one actor was added to at least one DataLayer.  false is returned if all the actors already belonged to all specified DataLayers.
        """
        ...
    def add_actors_to_data_layer(self, actors: Array[Actor], data_layer: DataLayerInstance) -> bool:
        r"""
        x.add_actors_to_data_layer(actors, data_layer) -> bool
        Add the actors to the DataLayer
        
        Args:
            actors (Array[Actor]): The actors to add to the DataLayer
            data_layer (DataLayerInstance): The DataLayer to add to
        
        Returns:
            bool: true if at least one actor was added to the DataLayer.  false is returned if all the actors already belonged to the DataLayer.
        """
        ...

class DataLayerFactory(Factory):
    r"""
    Data Layer Factory
    
    **C++ Source:**
    
    - **Module**: DataLayerEditor
    - **File**: DataLayerFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ExternalDataLayerFactory(Factory):
    r"""
    External Data Layer Factory
    
    **C++ Source:**
    
    - **Module**: DataLayerEditor
    - **File**: ExternalDataLayerFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class GizmoBaseComponent(PrimitiveComponent):
    r"""
    Base class for simple Components intended to be used as part of 3D Gizmos.
    Contains common properties and utility functions.
    This class does nothing by itself, use subclasses like UGizmoCircleComponent
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: GizmoBaseComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``color`` (LinearColor):  [Read-Write]
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``hover_size_multiplier`` (float):  [Read-Write]
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pixel_hit_distance_threshold`` (float):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class InternalToolFrameworkActor(Actor):
    r"""
    AInternalToolFrameworkActor is a base class for internal Actors that the
    ToolsFramework may spawn (for gizmos, mesh previews, etc). These Actors
    may need special-case handling, for example to prevent the user from
    selecting and deleting them.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: InteractiveToolObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class GizmoActor(InternalToolFrameworkActor):
    r"""
    AGizmoActor is a base class for Actors that would be created to represent Gizmos in the scene.
    Currently this does not involve any special functionality, but a set of static functions
    are provided to create default Components commonly used in Gizmos.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: GizmoActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class CombinedTransformGizmoActor(GizmoActor):
    r"""
    ACombinedTransformGizmoActor is an Actor type intended to be used with UCombinedTransformGizmo,
    as the in-scene visual representation of the Gizmo.
    
    FCombinedTransformGizmoActorFactory returns an instance of this Actor type (or a subclass), and based on
    which Translate and Rotate UProperties are initialized, will associate those Components
    with UInteractiveGizmo's that implement Axis Translation, Plane Translation, and Axis Rotation.
    
    If a particular sub-Gizmo is not required, simply set that FProperty to null.
    
    The static factory method ::ConstructDefault3AxisGizmo() creates and initializes an
    Actor suitable for use in a standard 3-axis Transformation Gizmo.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: CombinedTransformGizmo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class GizmoArrowComponent(GizmoBaseComponent):
    r"""
    Simple Component intended to be used as part of 3D Gizmos.
    Currently draws the "arrow" as a single 3D line.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: GizmoArrowComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``color`` (LinearColor):  [Read-Write]
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``direction`` (Vector):  [Read-Write]
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``gap`` (float):  [Read-Write]
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``hover_size_multiplier`` (float):  [Read-Write]
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``length`` (float):  [Read-Write]
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pixel_hit_distance_threshold`` (float):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``thickness`` (float):  [Read-Write]
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class GizmoBoxComponent(GizmoBaseComponent):
    r"""
    Simple Component intended to be used as part of 3D Gizmos.
    Draws outline of 3D Box based on parameters.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: GizmoBoxComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``color`` (LinearColor):  [Read-Write]
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``dimensions`` (Vector):  [Read-Write]
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_axis_flip`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``hover_size_multiplier`` (float):  [Read-Write]
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``line_thickness`` (float):  [Read-Write]
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``origin`` (Vector):  [Read-Write]
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pixel_hit_distance_threshold`` (float):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``remove_hidden_lines`` (bool):  [Read-Write]
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``rotation`` (Quat):  [Read-Write]
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class GizmoCircleComponent(GizmoBaseComponent):
    r"""
    Simple Component intended to be used as part of 3D Gizmos.
    Draws a 3D circle based on parameters.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: GizmoCircleComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``color`` (LinearColor):  [Read-Write]
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``draw_full_circle`` (bool):  [Read-Write]
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``hover_size_multiplier`` (float):  [Read-Write]
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``normal`` (Vector):  [Read-Write]
    - ``num_sides`` (int32):  [Read-Write]
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_allow_front_facing_hits`` (bool):  [Read-Write] If the circle was on a 3D sphere, then only the 'front' part of the circle can be hit,
      (in other words, if the ray would hit the sphere first, ignore the hit).
      Dynamically disabled if the circle is parallel to the view plane (ie "fully visible")
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pixel_hit_distance_threshold`` (float):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``radius`` (float):  [Read-Write]
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``thickness`` (float):  [Read-Write]
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``view_aligned`` (bool):  [Read-Write]
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class GizmoLineHandleComponent(GizmoBaseComponent):
    r"""
    Simple Component intended to be used as part of 3D Gizmos.
    Draws line terminated by a short perpendicular handle line based on parameters.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: GizmoLineHandleComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``color`` (LinearColor):  [Read-Write]
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``direction`` (Vector):  [Read-Write]
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``handle_size`` (float):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``hover_size_multiplier`` (float):  [Read-Write]
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``image_scale`` (bool):  [Read-Write]
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``length`` (float):  [Read-Write]
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``normal`` (Vector):  [Read-Write]
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pixel_hit_distance_threshold`` (float):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``thickness`` (float):  [Read-Write]
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class GizmoRectangleComponent(GizmoBaseComponent):
    r"""
    Simple Component intended to be used as part of 3D Gizmos.
    Draws outline of 3D rectangle based on parameters.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: GizmoRectangleComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``color`` (LinearColor):  [Read-Write]
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``direction_x`` (Vector):  [Read-Write]
    - ``direction_y`` (Vector):  [Read-Write]
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``hover_size_multiplier`` (float):  [Read-Write]
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``length_x`` (float):  [Read-Write]
    - ``length_y`` (float):  [Read-Write]
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``offset_x`` (float):  [Read-Write]
    - ``offset_y`` (float):  [Read-Write]
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``orient_y_according_to_camera`` (bool):  [Read-Write] When true, instead of using the provided DirectionY, the component will
      use a direction orthogonal to the camera direction and DirectionX. This
      keeps the rectangle pinned along DirectionX but spun to be flatter
      relative the camera.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pixel_hit_distance_threshold`` (float):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``segment_flags`` (uint8):  [Read-Write]
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``thickness`` (float):  [Read-Write]
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class IntervalGizmoActor(GizmoActor):
    r"""
    AIntervalGizmoActor is an Actor type intended to be used with UIntervalGizmo,
    as the in-scene visual representation of the Gizmo.
    
    FIntervalGizmoActorFactory returns an instance of this Actor type (or a subclass).
    
    If a particular sub-Gizmo is not required, simply set that UProperty to null.
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: IntervalGizmo.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class SubobjectDataBlueprintFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    A function library with wrappers around the getter/setter functions for FSubobjectData
    that will make it easier to use within blueprint contexts.
    
    **C++ Source:**
    
    - **Module**: SubobjectDataInterface
    - **File**: SubobjectDataBlueprintFunctionLibrary.h
    
    """
    @classmethod
    def is_valid(cls, data: SubobjectData) -> bool:
        r"""
        X.is_valid(data) -> bool
        Is Valid
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_scene_component(cls, data: SubobjectData) -> bool:
        r"""
        X.is_scene_component(data) -> bool
        Is Scene Component
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_root_component(cls, data: SubobjectData) -> bool:
        r"""
        X.is_root_component(data) -> bool
        Is Root Component
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_root_actor(cls, data: SubobjectData) -> bool:
        r"""
        X.is_root_actor(data) -> bool
        Is Root Actor
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_native_component(cls, data: SubobjectData) -> bool:
        r"""
        X.is_native_component(data) -> bool
        Is Native Component
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_instanced_component(cls, data: SubobjectData) -> bool:
        r"""
        X.is_instanced_component(data) -> bool
        Is Instanced Component
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_instanced_actor(cls, data: SubobjectData) -> bool:
        r"""
        X.is_instanced_actor(data) -> bool
        Is Instanced Actor
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_inherited_component(cls, data: SubobjectData) -> bool:
        r"""
        X.is_inherited_component(data) -> bool
        Is Inherited Component
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_handle_valid(cls, data_handle: SubobjectDataHandle) -> bool:
        r"""
        X.is_handle_valid(data_handle) -> bool
        Is Handle Valid
        
        Args:
            data_handle (SubobjectDataHandle): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_default_scene_root(cls, data: SubobjectData) -> bool:
        r"""
        X.is_default_scene_root(data) -> bool
        Is Default Scene Root
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_component(cls, data: SubobjectData) -> bool:
        r"""
        X.is_component(data) -> bool
        Returns true if this subobject is a component.
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_child_actor(cls, data: SubobjectData) -> bool:
        r"""
        X.is_child_actor(data) -> bool
        Is Child Actor
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_attached_to(cls, data: SubobjectData, handle: SubobjectDataHandle) -> bool:
        r"""
        X.is_attached_to(data, handle) -> bool
        Is Attached To
        
        Args:
            data (SubobjectData): 
            handle (SubobjectDataHandle): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_actor(cls, data: SubobjectData) -> bool:
        r"""
        X.is_actor(data) -> bool
        Is Actor
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_variable_name(cls, data: SubobjectData) -> Name:
        r"""
        X.get_variable_name(data) -> Name
        Get Variable Name
        
        Args:
            data (SubobjectData): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def get_object_for_blueprint(cls, data: SubobjectData, blueprint: Blueprint) -> Object:
        r"""
        X.get_object_for_blueprint(data, blueprint) -> Object
        Get Object for Blueprint
        
        Args:
            data (SubobjectData): 
            blueprint (Blueprint): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def get_object(cls, data: SubobjectData, even_if_pending_kill: bool = False) -> Object:
        r"""
        X.get_object(data, even_if_pending_kill=False) -> Object
        Get Object
        
        Args:
            data (SubobjectData): 
            even_if_pending_kill (bool): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def get_handle(cls, data: SubobjectData) -> SubobjectDataHandle:
        r"""
        X.get_handle(data) -> SubobjectDataHandle
        
        
        Args:
            data (SubobjectData): 
        
        Returns:
            SubobjectDataHandle: 
        
            out_handle (SubobjectDataHandle):
        """
        ...
    def get_display_name(self, data: SubobjectData) -> Text:
        r"""
        x.get_display_name(data) -> Text
        Get Display Name
        
        Args:
            data (SubobjectData): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def get_data(cls, data_handle: SubobjectDataHandle) -> SubobjectData:
        r"""
        X.get_data(data_handle) -> SubobjectData
        Get Data
        
        Args:
            data_handle (SubobjectDataHandle): 
        
        Returns:
            SubobjectData: 
        
            out_data (SubobjectData):
        """
        ...
    def get_blueprint(self, data: SubobjectData) -> Blueprint:
        r"""
        x.get_blueprint(data) -> Blueprint
        Get Blueprint
        
        Args:
            data (SubobjectData): 
        
        Returns:
            Blueprint:
        """
        ...
    @classmethod
    def can_reparent(cls, data: SubobjectData) -> bool:
        r"""
        X.can_reparent(data) -> bool
        
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool: Whether or not this object represents a subobject that can be reparented to other subobjects based on its context.
        """
        ...
    @classmethod
    def can_rename(cls, data: SubobjectData) -> bool:
        r"""
        X.can_rename(data) -> bool
        Can Rename
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def can_edit(cls, data: SubobjectData) -> bool:
        r"""
        X.can_edit(data) -> bool
        
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool: Whether or not we can edit properties for this subobject
        """
        ...
    @classmethod
    def can_duplicate(cls, data: SubobjectData) -> bool:
        r"""
        X.can_duplicate(data) -> bool
        
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool: Whether or not this object represents a subobject that can be duplicated
        """
        ...
    @classmethod
    def can_delete(cls, data: SubobjectData) -> bool:
        r"""
        X.can_delete(data) -> bool
        
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool: Whether or not this object represents a subobject that can be deleted
        """
        ...
    @classmethod
    def can_copy(cls, data: SubobjectData) -> bool:
        r"""
        X.can_copy(data) -> bool
        
        
        Args:
            data (SubobjectData): 
        
        Returns:
            bool: Whether or not this object represents a subobject that can be copied
        """
        ...

class SubobjectDataSubsystem(EngineSubsystem):
    r"""
    The Subobject Data Subsystem will produce the reflected subobject data
    based on a given root object. A root object can be anything, an actor
    instance clicked on via the level editor, a UBlueprint* by opening an asset,
    or something piped in from python or other scripting languages.
    
    **C++ Source:**
    
    - **Module**: SubobjectDataInterface
    - **File**: SubobjectDataSubsystem.h
    
    """
    def reparent_subobjects(self, params: ReparentSubobjectParams, handles_to_move: Array[SubobjectDataHandle]) -> bool:
        r"""
        x.reparent_subobjects(params, handles_to_move) -> bool
        Attempts to reparent all subobjects in the HandlesToMove array to the new parent handle.
        
        Args:
            params (ReparentSubobjectParams): 
            handles_to_move (Array[SubobjectDataHandle]): 
        
        Returns:
            bool:
        """
        ...
    def reparent_subobject(self, params: ReparentSubobjectParams, to_reparent_handle: SubobjectDataHandle) -> bool:
        r"""
        x.reparent_subobject(params, to_reparent_handle) -> bool
        Attempts to reparent the given subobject to the new parent
        
        Args:
            params (ReparentSubobjectParams): 
            to_reparent_handle (SubobjectDataHandle): The handle of the subobject that will get moved
        
        Returns:
            bool: True if the reparent was successful, false otherwise.
        """
        ...
    @classmethod
    def rename_subobject_member_variable(cls, bp_context: Blueprint, handle: SubobjectDataHandle, new_name: Name) -> None:
        r"""
        X.rename_subobject_member_variable(bp_context, handle, new_name) -> None
        Rename Subobject Member Variable
        
        Args:
            bp_context (Blueprint): 
            handle (SubobjectDataHandle): 
            new_name (Name):
        """
        ...
    def rename_subobject(self, handle: SubobjectDataHandle, new_name: Text) -> bool:
        r"""
        x.rename_subobject(handle, new_name) -> bool
        Attempts to rename the given subobject to the new name.
        
        Args:
            handle (SubobjectDataHandle): Handle to the subobject to rename
            new_name (Text): The new name that is desired for the given subobject
        
        Returns:
            bool: True if the rename was successful, false otherwise.
        """
        ...
    def make_new_scene_root(self, context: SubobjectDataHandle, new_scene_root: SubobjectDataHandle, bp_context: Blueprint) -> bool:
        r"""
        x.make_new_scene_root(context, new_scene_root, bp_context) -> bool
        Make New Scene Root
        
        Args:
            context (SubobjectDataHandle): 
            new_scene_root (SubobjectDataHandle): 
            bp_context (Blueprint): 
        
        Returns:
            bool:
        """
        ...
    def k2_gather_subobject_data_for_instance(self, context: Actor) -> Array[SubobjectDataHandle]:
        r"""
        x.k2_gather_subobject_data_for_instance(context) -> Array[SubobjectDataHandle]
        Gather all subobjects that the given actor instance has. Populates an array of
        handles that will have the given context and all it's subobjects.
        
        Args:
            context (Actor): Object to gather subobjects for
        
        Returns:
            Array[SubobjectDataHandle]: 
        
            out_array (Array[SubobjectDataHandle]): Array to populate (will be emptied first)
        """
        ...
    def k2_gather_subobject_data_for_blueprint(self, context: Blueprint) -> Array[SubobjectDataHandle]:
        r"""
        x.k2_gather_subobject_data_for_blueprint(context) -> Array[SubobjectDataHandle]
        Gather all subobjects that the given Blueprint context has. Populates an array of
        handles that will have the given context and all it's subobjects.
        
        Args:
            context (Blueprint): Object to gather subobjects for
        
        Returns:
            Array[SubobjectDataHandle]: 
        
            out_array (Array[SubobjectDataHandle]): Array to populate (will be emptied first)
        """
        ...
    def k2_find_subobject_data_from_handle(self, handle: SubobjectDataHandle) -> Optional[SubobjectData]:
        r"""
        x.k2_find_subobject_data_from_handle(handle) -> SubobjectData or None
        Attempt to find the subobject data for a given handle. OutData will only
        be valid if the function returns true.
        
        Args:
            handle (SubobjectDataHandle): Handle of the subobject data you want to acquire
        
        Returns:
            SubobjectData or None: bool          true if the data was found
        
            out_data (SubobjectData): Reference to the subobject data to populate
        """
        ...
    def k2_delete_subobjects_from_instance(self, context_handle: SubobjectDataHandle, subobjects_to_delete: Array[SubobjectDataHandle]) -> int:
        r"""
        x.k2_delete_subobjects_from_instance(context_handle, subobjects_to_delete) -> int32
        Attempts to delete the given array of subobjects from their context
        
        Args:
            context_handle (SubobjectDataHandle): The owning context of the subobjects that should be removed
            subobjects_to_delete (Array[SubobjectDataHandle]): Array of subobject handles that should be deleted
        
        Returns:
            int32: The number of subobjects successfully deleted
        """
        ...
    def k2_delete_subobject_from_instance(self, context_handle: SubobjectDataHandle, subobject_to_delete: SubobjectDataHandle) -> int:
        r"""
        x.k2_delete_subobject_from_instance(context_handle, subobject_to_delete) -> int32
        Attempts to delete the given subobject from its context
        
        Args:
            context_handle (SubobjectDataHandle): The owning context of the subobjects that should be removed
            subobject_to_delete (SubobjectDataHandle): The subobject handles that should be deleted
        
        Returns:
            int32: The number of subobjects successfully deleted
        """
        ...
    def is_valid_rename(self, handle: SubobjectDataHandle, new_text: Text) -> Optional[Text]:
        r"""
        x.is_valid_rename(handle, new_text) -> Text or None
        Returns true if the given new text is a valid option to rename the
        subobject with the given handle. Populates the OutErrorMessage if
        it is not valid.
        
        Args:
            handle (SubobjectDataHandle): Handle to the subobject that is being checked
            new_text (Text): The new name that is desired
        
        Returns:
            Text or None: True if the rename is valid
        
            out_error_message (Text): The reasoning for an invalid name
        """
        ...
    def find_handle_for_object(self, context: SubobjectDataHandle, object_to_find: Object, bp_context: Blueprint = None) -> SubobjectDataHandle:
        r"""
        x.find_handle_for_object(context, object_to_find, bp_context=None) -> SubobjectDataHandle
        Attempt to find an existing handle for the given object.
        
        Args:
            context (SubobjectDataHandle): The context that the object to find is within
            object_to_find (Object): The object that you want to find the handle for within the context
            bp_context (Blueprint): 
        
        Returns:
            SubobjectDataHandle: FSubobjectDataHandle  The subobject handle for the object, Invalid handle if not found.
        """
        ...
    def detach_subobject(self, owner_handle: SubobjectDataHandle, child_to_remove: SubobjectDataHandle) -> bool:
        r"""
        x.detach_subobject(owner_handle, child_to_remove) -> bool
        Remove the child subobject from the owner
        
        Args:
            owner_handle (SubobjectDataHandle): 
            child_to_remove (SubobjectDataHandle): 
        
        Returns:
            bool: True if the child was successfully removed.
        """
        ...
    def delete_subobjects(self, context_handle: SubobjectDataHandle, subobjects_to_delete: Array[SubobjectDataHandle], bp_context: Blueprint = None) -> int:
        r"""
        x.delete_subobjects(context_handle, subobjects_to_delete, bp_context=None) -> int32
        Attempts to delete the given array of subobjects from their context
        
        Args:
            context_handle (SubobjectDataHandle): The owning context of the subobjects that should be removed
            subobjects_to_delete (Array[SubobjectDataHandle]): Array of subobject handles that should be deleted
            bp_context (Blueprint): The blueprint context for the given
        
        Returns:
            int32: The number of subobjects successfully deleted
        """
        ...
    def delete_subobject(self, context_handle: SubobjectDataHandle, subobject_to_delete: SubobjectDataHandle, bp_context: Blueprint = None) -> int:
        r"""
        x.delete_subobject(context_handle, subobject_to_delete, bp_context=None) -> int32
        Attempts to delete the given subobject from its blueprint context
        
        Args:
            context_handle (SubobjectDataHandle): The owning context of the subobjects that should be removed
            subobject_to_delete (SubobjectDataHandle): The subobject handles that should be deleted
            bp_context (Blueprint): The blueprint context for the given
        
        Returns:
            int32: The number of subobjects successfully deleted
        """
        ...
    @classmethod
    def create_new_cpp_component(cls, component_class: Class, new_class_path: str, new_class_name: str) -> Class:
        r"""
        X.create_new_cpp_component(component_class, new_class_path, new_class_name) -> type(Class)
        Creates a new C++ component from the specified class type
        The user will be prompted to pick a new subclass name and code will be recompiled
        
        Args:
            component_class (type(Class)): 
            new_class_path (str): 
            new_class_name (str): 
        
        Returns:
            type(Class): The new class that was created
        """
        ...
    @classmethod
    def create_new_bp_component(cls, component_class: Class, new_class_path: str, new_class_name: str) -> Class:
        r"""
        X.create_new_bp_component(component_class, new_class_path, new_class_name) -> type(Class)
        Creates a new Blueprint component from the specified class type
        The user will be prompted to pick a new subclass name and a blueprint asset will be created
        
        Args:
            component_class (type(Class)): 
            new_class_path (str): 
            new_class_name (str): 
        
        Returns:
            type(Class): The new class that was created
        """
        ...
    def copy_subobjects(self, handles: Array[SubobjectDataHandle], bp_context: Blueprint) -> None:
        r"""
        x.copy_subobjects(handles, bp_context) -> None
        Copy Subobjects
        
        Args:
            handles (Array[SubobjectDataHandle]): 
            bp_context (Blueprint):
        """
        ...
    def change_subobject_class(self, handle: SubobjectDataHandle, new_class: Class) -> bool:
        r"""
        x.change_subobject_class(handle, new_class) -> bool
        Attempts to change the subclass of a native component
        
        Args:
            handle (SubobjectDataHandle): Handle to the subobject to change class of
            new_class (type(Class)): The new class that is desired for the given subobject
        
        Returns:
            bool: True if the class change was successful, false otherwise.
        """
        ...
    def can_paste_subobjects(self, root_handle: SubobjectDataHandle, bp_context: Blueprint = None) -> bool:
        r"""
        x.can_paste_subobjects(root_handle, bp_context=None) -> bool
        Can Paste Subobjects
        
        Args:
            root_handle (SubobjectDataHandle): 
            bp_context (Blueprint): 
        
        Returns:
            bool:
        """
        ...
    def can_copy_subobjects(self, handles: Array[SubobjectDataHandle]) -> bool:
        r"""
        x.can_copy_subobjects(handles) -> bool
        Returns true if the given array of handles represents subobjects that
        can be copied.
        
        Args:
            handles (Array[SubobjectDataHandle]): 
        
        Returns:
            bool:
        """
        ...
    def attach_subobject(self, owner_handle: SubobjectDataHandle, child_to_add_handle: SubobjectDataHandle) -> bool:
        r"""
        x.attach_subobject(owner_handle, child_to_add_handle) -> bool
        Add the given subobject to a new owner. This will remove the subobject from its previous
        owner if necessary.
        
        Args:
            owner_handle (SubobjectDataHandle): The new owner to attach to
            child_to_add_handle (SubobjectDataHandle): Handle to the subobject that will become a child of the owner
        
        Returns:
            bool: true if the child was added successfully
        """
        ...
    def add_new_subobject(self, params: AddNewSubobjectParams) -> Tuple[SubobjectDataHandle, Text]:
        r"""
        x.add_new_subobject(params) -> (SubobjectDataHandle, fail_reason=Text)
        Add a new subobject as a child to the given parent object
        
        Args:
            params (AddNewSubobjectParams): Options to consider when adding this subobject
        
        Returns:
            Text: FSubobjectDataHandle          Handle to the newly created subobject, Invalid handle if creation failed
        
            fail_reason (Text):
        """
        ...

class SubobjectEditorMenuContext(Object):
    r"""
    Subobject Editor Menu Context
    
    **C++ Source:**
    
    - **Module**: SubobjectEditor
    - **File**: SubobjectEditorMenuContext.h
    
    """
    def get_selected_objects(self) -> Array[Object]:
        r"""
        x.get_selected_objects() -> Array[Object]
        Get Selected Objects
        
        Returns:
            Array[Object]:
        """
        ...

class SlateFXSubsystem(EngineSubsystem):
    r"""
    Slate FXSubsystem
    
    **C++ Source:**
    
    - **Module**: SlateRHIRenderer
    - **File**: SlateFXSubsystem.h
    
    """
    def get_slate_post_processor(self, post_buffer_bit: SlatePostRT) -> SlateRHIPostBufferProcessor:
        r"""
        x.get_slate_post_processor(post_buffer_bit) -> SlateRHIPostBufferProcessor
        Get post processor for a particular post buffer index, if it exists
        
        Args:
            post_buffer_bit (SlatePostRT): 
        
        Returns:
            SlateRHIPostBufferProcessor:
        """
        ...

class SlateRHIPostBufferProcessor(Object):
    r"""
    Base class for types that can process the backbuffer scene into the slate post buffer.
    
    Implement 'PostProcess' in your derived class. Additionally, you need to create a renderthread proxy that derives from 'FSlateRHIPostBufferProcessorProxy'
    For an example see: USlatePostBufferBlur.
    
    **C++ Source:**
    
    - **Module**: SlateRHIRenderer
    - **File**: SlateRHIPostBufferProcessor.h
    
    """
    ...

class SlatePostBufferBlur(SlateRHIPostBufferProcessor):
    r"""
    Slate Post Buffer Processor that performs a simple gaussian blur to the backbuffer
    
    Create a new asset deriving from this class to use / modify settings.
    
    **C++ Source:**
    
    - **Module**: SlateRHIRenderer
    - **File**: SlatePostBufferBlur.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``gaussian_blur_strength`` (float):  [Read-Write]
    """
    @property
    def gaussian_blur_strength(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @gaussian_blur_strength.setter
    def gaussian_blur_strength(self, value: float) -> None:
        ...

class SlateRHIRendererSettings(DeveloperSettings):
    r"""
    Settings used to control slate rendering
    
    **C++ Source:**
    
    - **Module**: SlateRHIRenderer
    - **File**: SlateRHIRendererSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``slate_post_settings`` (Map[SlatePostRT, SlatePostSettings]):  [Read-Write] Map of all slate post RT's and their settings
      Note that each post RT used in a frame will result in 1 full framebuffer copy for slate to sample from.
      If a post RT is not used, no copy will occur & that post RT will be resized to 1x1 after 2 frames of non-use.
      
      By default only SlatePostRT_0 is enabled. The rest must manually be enabled in settings below.
              // Map is nice since needs no editor customization. After initial run there should be no more than 5 lookups each frame.
    """
    def get_slate_post_setting(self, post_buffer_bit: SlatePostRT) -> SlatePostSettings:
        r"""
        x.get_slate_post_setting(post_buffer_bit) -> SlatePostSettings
        Get settings struct for a particular post buffer index
        
        Args:
            post_buffer_bit (SlatePostRT): 
        
        Returns:
            SlatePostSettings:
        """
        ...
    def get_mutable_slate_post_setting(self, post_buffer_bit: SlatePostRT) -> SlatePostSettings:
        r"""
        x.get_mutable_slate_post_setting(post_buffer_bit) -> SlatePostSettings
        Get settings struct for a particular post buffer index
        
        Args:
            post_buffer_bit (SlatePostRT): 
        
        Returns:
            SlatePostSettings:
        """
        ...

class ListViewBase(Widget):
    r"""
    Bare-bones base class to make creating custom UListView widgets easier.
    Child classes should also inherit from ITypedUMGListView<T> to get a basic public ListView API for free.
    
    Child classes will own the actual SListView<T> widgets, but this provides some boilerplate functionality for generating entries.
    To generate a row for the child list, use GenerateTypedRow with the appropriate SObjectTableRow<T> type for your list
    
    Additionally, the entry widget class can be filtered for a particular class and interface with the EntryClass and EntryInterface metadata arguments
    This can be specified either on the class directly (see below) or on any BindWidget FProperty
    
    Example:
    class UMyUserWidget : public UUserWidget
    {
                UPROPERTY(BindWidget, meta = (EntryClass = MyListEntryWidget))
                UListView* ListView_InventoryItems;
    }
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ListViewBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_dragging`` (bool):  [Read-Write] True to allow dragging of row widgets in the list
    - ``allow_overscroll`` (bool):  [Read-Write] Disable to stop scrollbars from activating inertial overscrolling
    - ``bp_on_entry_generated`` (OnListEntryGeneratedDynamic):  [Read-Write] Called when a row widget is generated for a list item
    - ``bp_on_entry_released`` (OnListEntryReleasedDynamic):  [Read-Write] Called when a row widget is released by the list (i.e. when it no longer represents a list item)
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``enable_fixed_line_offset`` (bool):  [Read-Write]
    - ``enable_right_click_scrolling`` (bool):  [Read-Write] True to allow right click drag scrolling.
    - ``enable_scroll_animation`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list
    - ``enable_touch_animated_scrolling`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list with touch
    - ``enable_touch_scrolling`` (bool):  [Read-Write] True to allow scrolling using touch input.
    - ``entry_widget_class`` (type(Class)):  [Read-Write] The type of widget to create for each entry displayed in the list.
    - ``fixed_line_scroll_offset`` (float):  [Read-Write] Optional fixed offset (in lines) to always apply to the top/left (depending on orientation) of the list.
      If provided, all non-inertial means of scrolling will settle with exactly this offset of the topmost entry.
      Ex: A value of 0.25 would cause the topmost full entry to be offset down by a quarter length of the preceeding entry.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_pointer_scrolling_enabled`` (bool):  [Read-Write] Enable/Disable scrolling using Touch or Mouse.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``num_designer_preview_entries`` (int32):  [Read-Write] The number of dummy item entry widgets to preview in the widget designer
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wheel_scroll_multiplier`` (float):  [Read-Write] The multiplier to apply when wheel scrolling
    """
    @property
    def bp_on_entry_generated(self) -> OnListEntryGeneratedDynamic:
        r"""
        (OnListEntryGeneratedDynamic):  [Read-Write] Called when a row widget is generated for a list item
        """
        ...
    @bp_on_entry_generated.setter
    def bp_on_entry_generated(self, value: OnListEntryGeneratedDynamic) -> None:
        ...
    @property
    def entry_widget_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] The type of widget to create for each entry displayed in the list.
        """
        ...
    @property
    def wheel_scroll_multiplier(self) -> float:
        r"""
        (float):  [Read-Only] The multiplier to apply when wheel scrolling
        """
        ...
    @property
    def enable_scroll_animation(self) -> bool:
        r"""
        (bool):  [Read-Only] True to enable lerped animation when scrolling through the list
        """
        ...
    @property
    def enable_touch_animated_scrolling(self) -> bool:
        r"""
        (bool):  [Read-Only] True to enable lerped animation when scrolling through the list with touch
        """
        ...
    @property
    def allow_dragging(self) -> bool:
        r"""
        (bool):  [Read-Only] True to allow dragging of row widgets in the list
        """
        ...
    @property
    def bp_on_entry_released(self) -> OnListEntryReleasedDynamic:
        r"""
        (OnListEntryReleasedDynamic):  [Read-Write] Called when a row widget is released by the list (i.e. when it no longer represents a list item)
        """
        ...
    @bp_on_entry_released.setter
    def bp_on_entry_released(self, value: OnListEntryReleasedDynamic) -> None:
        ...
    def set_wheel_scroll_multiplier(self, new_wheel_scroll_multiplier: float) -> None:
        r"""
        x.set_wheel_scroll_multiplier(new_wheel_scroll_multiplier) -> None
        Set Wheel Scroll Multiplier
        
        Args:
            new_wheel_scroll_multiplier (float):
        """
        ...
    def set_scroll_offset(self, scroll_offset: float) -> None:
        r"""
        x.set_scroll_offset(scroll_offset) -> None
        Set the scroll offset of this view (in items)
        
        Args:
            scroll_offset (float):
        """
        ...
    def set_scrollbar_visibility(self, visibility: SlateVisibility) -> None:
        r"""
        x.set_scrollbar_visibility(visibility) -> None
        Set Scrollbar Visibility
        
        Args:
            visibility (SlateVisibility):
        """
        ...
    def set_is_pointer_scrolling_enabled(self, is_pointer_scrolling_enabled: bool) -> None:
        r"""
        x.set_is_pointer_scrolling_enabled(is_pointer_scrolling_enabled) -> None
        Enable/Disable the ability of the list to scroll. This should be use as a temporary disable.
        
        Args:
            is_pointer_scrolling_enabled (bool):
        """
        ...
    def scroll_to_top(self) -> None:
        r"""
        x.scroll_to_top() -> None
        Scroll the entire list up to the first item
        """
        ...
    def scroll_to_bottom(self) -> None:
        r"""
        x.scroll_to_bottom() -> None
        Scroll the entire list down to the bottom-most item
        """
        ...
    def request_refresh(self) -> None:
        r"""
        x.request_refresh() -> None
        Sets the list to refresh on the next tick.
        
        Note that refreshing, from a list perspective, is limited to accounting for discrepancies between items and entries.
        In other words, it will only release entries that no longer have items and generate entries for new items (or newly visible items).
        
        It does NOT account for changes within existing items - that is up to the item to announce and an entry to listen to as needed.
        This can be onerous to set up for simple cases, so it's also reasonable (though not ideal) to call RegenerateAllEntries when changes within N list items need to be reflected.
        """
        ...
    def regenerate_all_entries(self) -> None:
        r"""
        x.regenerate_all_entries() -> None
        Full regeneration of all entries in the list. Note that the entry UWidget instances will not be destroyed, but they will be released and re-generated.
        In other words, entry widgets will not receive Destruct/Construct events. They will receive OnEntryReleased and IUserObjectListEntry implementations will receive OnListItemObjectSet.
        """
        ...
    def get_scroll_offset(self) -> float:
        r"""
        x.get_scroll_offset() -> float
        Get the scroll offset of this view (in items)
        
        Returns:
            float:
        """
        ...
    def get_displayed_entry_widgets(self) -> Array[UserWidget]:
        r"""
        x.get_displayed_entry_widgets() -> Array[UserWidget]
        Gets all of the list entry widgets currently being displayed by the list
        
        Returns:
            Array[UserWidget]:
        """
        ...

class ListView(ListViewBase):
    r"""
    A virtualized list that allows up to thousands of items to be displayed.
    
    An important distinction to keep in mind here is "Item" vs. "Entry"
    The list itself is based on a list of n items, but only creates as many entry widgets as can fit on screen.
    For example, a scrolling ListView of 200 items with 5 currently visible will only have created 5 entry widgets.
    
    To make a widget usable as an entry in a ListView, it must inherit from the IUserObjectListEntry interface.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ListView.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_dragging`` (bool):  [Read-Write] True to allow dragging of row widgets in the list
    - ``allow_overscroll`` (bool):  [Read-Write] Disable to stop scrollbars from activating inertial overscrolling
    - ``bp_on_entry_generated`` (OnListEntryGeneratedDynamic):  [Read-Write] Called when a row widget is generated for a list item
    - ``bp_on_entry_initialized`` (OnListEntryInitializedDynamic):  [Read-Write] Called when a row widget is generated for a list item
    - ``bp_on_entry_released`` (OnListEntryReleasedDynamic):  [Read-Write] Called when a row widget is released by the list (i.e. when it no longer represents a list item)
    - ``bp_on_item_clicked`` (SimpleListItemEventDynamic):  [Read-Write]
    - ``bp_on_item_double_clicked`` (SimpleListItemEventDynamic):  [Read-Write]
    - ``bp_on_item_is_hovered_changed`` (OnItemIsHoveredChangedDynamic):  [Read-Write]
    - ``bp_on_item_scrolled_into_view`` (OnListItemScrolledIntoViewDynamic):  [Read-Write]
    - ``bp_on_item_selection_changed`` (OnListItemSelectionChangedDynamic):  [Read-Write]
    - ``bp_on_list_view_scrolled`` (OnListViewScrolledDynamic):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_selection_on_click`` (bool):  [Read-Write]
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``consume_mouse_wheel`` (ConsumeMouseWheel):  [Read-Write]
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``enable_fixed_line_offset`` (bool):  [Read-Write]
    - ``enable_right_click_scrolling`` (bool):  [Read-Write] True to allow right click drag scrolling.
    - ``enable_scroll_animation`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list
    - ``enable_touch_animated_scrolling`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list with touch
    - ``enable_touch_scrolling`` (bool):  [Read-Write] True to allow scrolling using touch input.
    - ``entry_spacing`` (float):  [Read-Write] This deprecated property was originally BlueprintReadOnly. To satisfy the compiler requirment to have a BlueprintGetter for this property,
      it relies on the newly added UFunction GetHorizontalEntrySpacing() to act as its BlueprintGetter.
      deprecated: EntrySpacing has been deprecated. Please use HorizontalEntrySpacing and VerticalEntrySpacing.
    - ``entry_widget_class`` (type(Class)):  [Read-Write] The type of widget to create for each entry displayed in the list.
    - ``fixed_line_scroll_offset`` (float):  [Read-Write] Optional fixed offset (in lines) to always apply to the top/left (depending on orientation) of the list.
      If provided, all non-inertial means of scrolling will settle with exactly this offset of the topmost entry.
      Ex: A value of 0.25 would cause the topmost full entry to be offset down by a quarter length of the preceeding entry.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``horizontal_entry_spacing`` (float):  [Read-Write]
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write]
    - ``is_pointer_scrolling_enabled`` (bool):  [Read-Write] Enable/Disable scrolling using Touch or Mouse.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``num_designer_preview_entries`` (int32):  [Read-Write] The number of dummy item entry widgets to preview in the widget designer
    - ``orientation`` (Orientation):  [Read-Write] The scroll & layout orientation of the list. ListView and TileView only.
      Vertical will scroll vertically and arrange tiles into rows.
      Horizontal will scroll horizontally and arrange tiles into columns.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``return_focus_to_selection`` (bool):  [Read-Write]
    - ``scroll_bar_style`` (ScrollBarStyle):  [Read-Write]
    - ``selection_mode`` (SelectionMode):  [Read-Write]
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``vertical_entry_spacing`` (float):  [Read-Write]
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wheel_scroll_multiplier`` (float):  [Read-Write] The multiplier to apply when wheel scrolling
    - ``widget_style`` (TableViewStyle):  [Read-Write]
    """
    @property
    def widget_style(self) -> TableViewStyle:
        r"""
        (TableViewStyle):  [Read-Only]
        """
        ...
    @property
    def scroll_bar_style(self) -> ScrollBarStyle:
        r"""
        (ScrollBarStyle):  [Read-Only]
        """
        ...
    @property
    def orientation(self) -> Orientation:
        r"""
        (Orientation):  [Read-Only] The scroll & layout orientation of the list. ListView and TileView only.
        Vertical will scroll vertically and arrange tiles into rows.
        Horizontal will scroll horizontally and arrange tiles into columns.
        """
        ...
    @property
    def selection_mode(self) -> SelectionMode:
        r"""
        (SelectionMode):  [Read-Only]
        """
        ...
    @property
    def consume_mouse_wheel(self) -> ConsumeMouseWheel:
        r"""
        (ConsumeMouseWheel):  [Read-Only]
        """
        ...
    @property
    def clear_selection_on_click(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def return_focus_to_selection(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def entry_spacing(self) -> float:
        r"""
        (float):  [Read-Only] This deprecated property was originally BlueprintReadOnly. To satisfy the compiler requirment to have a BlueprintGetter for this property,
        it relies on the newly added UFunction GetHorizontalEntrySpacing() to act as its BlueprintGetter.
        deprecated: EntrySpacing has been deprecated. Please use HorizontalEntrySpacing and VerticalEntrySpacing.
        """
        ...
    @property
    def horizontal_entry_spacing(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def vertical_entry_spacing(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def bp_on_entry_initialized(self) -> OnListEntryInitializedDynamic:
        r"""
        (OnListEntryInitializedDynamic):  [Read-Write] Called when a row widget is generated for a list item
        """
        ...
    @bp_on_entry_initialized.setter
    def bp_on_entry_initialized(self, value: OnListEntryInitializedDynamic) -> None:
        ...
    @property
    def bp_on_item_clicked(self) -> SimpleListItemEventDynamic:
        r"""
        (SimpleListItemEventDynamic):  [Read-Write]
        """
        ...
    @bp_on_item_clicked.setter
    def bp_on_item_clicked(self, value: SimpleListItemEventDynamic) -> None:
        ...
    @property
    def bp_on_item_double_clicked(self) -> SimpleListItemEventDynamic:
        r"""
        (SimpleListItemEventDynamic):  [Read-Write]
        """
        ...
    @bp_on_item_double_clicked.setter
    def bp_on_item_double_clicked(self, value: SimpleListItemEventDynamic) -> None:
        ...
    @property
    def bp_on_item_is_hovered_changed(self) -> OnItemIsHoveredChangedDynamic:
        r"""
        (OnItemIsHoveredChangedDynamic):  [Read-Write]
        """
        ...
    @bp_on_item_is_hovered_changed.setter
    def bp_on_item_is_hovered_changed(self, value: OnItemIsHoveredChangedDynamic) -> None:
        ...
    @property
    def bp_on_item_selection_changed(self) -> OnListItemSelectionChangedDynamic:
        r"""
        (OnListItemSelectionChangedDynamic):  [Read-Write]
        """
        ...
    @bp_on_item_selection_changed.setter
    def bp_on_item_selection_changed(self, value: OnListItemSelectionChangedDynamic) -> None:
        ...
    @property
    def bp_on_item_scrolled_into_view(self) -> OnListItemScrolledIntoViewDynamic:
        r"""
        (OnListItemScrolledIntoViewDynamic):  [Read-Write]
        """
        ...
    @bp_on_item_scrolled_into_view.setter
    def bp_on_item_scrolled_into_view(self, value: OnListItemScrolledIntoViewDynamic) -> None:
        ...
    @property
    def bp_on_list_view_scrolled(self) -> OnListViewScrolledDynamic:
        r"""
        (OnListViewScrolledDynamic):  [Read-Write]
        """
        ...
    @bp_on_list_view_scrolled.setter
    def bp_on_list_view_scrolled(self, value: OnListViewScrolledDynamic) -> None:
        ...
    def set_selection_mode(self, selection_mode: SelectionMode) -> None:
        r"""
        x.set_selection_mode(selection_mode) -> None
        Sets the new selection mode, preserving the current selection where possible.
        
        Args:
            selection_mode (SelectionMode):
        """
        ...
    def set_selected_index(self, index: int) -> None:
        r"""
        x.set_selected_index(index) -> None
        Sets the item at the given index as the sole selected item.
        
        Args:
            index (int32):
        """
        ...
    def scroll_index_into_view(self, index: int) -> None:
        r"""
        x.scroll_index_into_view(index) -> None
        Requests that the item at the given index is scrolled into view
        
        Args:
            index (int32):
        """
        ...
    def remove_item(self, item: Object) -> None:
        r"""
        x.remove_item(item) -> None
        Removes an the item from the list
        
        Args:
            item (Object):
        """
        ...
    def navigate_to_index(self, index: int) -> None:
        r"""
        x.navigate_to_index(index) -> None
        Requests that the item at the given index navigated to, scrolling it into view if needed.
        
        Args:
            index (int32):
        """
        ...
    def is_refresh_pending(self) -> bool:
        r"""
        x.is_refresh_pending() -> bool
        Returns true if a refresh is pending and the list will be rebuilt on the next tick
        
        Returns:
            bool:
        """
        ...
    def get_vertical_entry_spacing(self) -> float:
        r"""
        x.get_vertical_entry_spacing() -> float
        Get the vertical spacing between entries.
        
        Returns:
            float:
        """
        ...
    def get_num_items(self) -> int:
        r"""
        x.get_num_items() -> int32
        Returns the total number of items
        
        Returns:
            int32:
        """
        ...
    def get_list_items(self) -> Array[Object]:
        r"""
        x.get_list_items() -> Array[Object]
        Gets the list of all items in the list.
        Note that each of these items only has a corresponding entry widget when visible. Use GetDisplayedEntryWidgets to get the currently displayed widgets.
        
        Returns:
            Array[Object]:
        """
        ...
    def get_item_at(self, index: int) -> Object:
        r"""
        x.get_item_at(index) -> Object
        Returns the item at the given index
        
        Args:
            index (int32): 
        
        Returns:
            Object:
        """
        ...
    def get_index_for_item(self, item: Object) -> int:
        r"""
        x.get_index_for_item(item) -> int32
        Returns the index that the specified item is at. Will return the first found, or -1 for not found
        
        Args:
            item (Object): 
        
        Returns:
            int32:
        """
        ...
    def get_horizontal_entry_spacing(self) -> float:
        r"""
        x.get_horizontal_entry_spacing() -> float
        Get the horizontal spacing between entries.
        
        Returns:
            float:
        """
        ...
    def clear_list_items(self) -> None:
        r"""
        x.clear_list_items() -> None
        Removes all items from the list
        """
        ...
    def bp_set_selected_item(self, item: Object) -> None:
        r"""
        x.bp_set_selected_item(item) -> None
        Sets the given item as the sole selected item.
        
        Args:
            item (Object):
        """
        ...
    def bp_set_list_items(self, list_items: Array[Object]) -> None:
        r"""
        x.bp_set_list_items(list_items) -> None
        Sets the array of objects to display rows for in the list
        
        Args:
            list_items (Array[Object]):
        """
        ...
    def bp_set_item_selection(self, item: Object, selected: bool) -> None:
        r"""
        x.bp_set_item_selection(item, selected) -> None
        Sets whether the given item is selected.
        
        Args:
            item (Object): 
            selected (bool):
        """
        ...
    def bp_scroll_item_into_view(self, item: Object) -> None:
        r"""
        x.bp_scroll_item_into_view(item) -> None
        Requests that the given item is scrolled into view
        
        Args:
            item (Object):
        """
        ...
    def bp_navigate_to_item(self, item: Object) -> None:
        r"""
        x.bp_navigate_to_item(item) -> None
        Requests that the given item is navigated to, scrolling it into view if needed.
        
        Args:
            item (Object):
        """
        ...
    def bp_is_item_visible(self, item: Object) -> bool:
        r"""
        x.bp_is_item_visible(item) -> bool
        Gets whether the entry for the given object is currently visible in the list
        
        Args:
            item (Object): 
        
        Returns:
            bool:
        """
        ...
    def bp_get_selected_items(self) -> Optional[Array[Object]]:
        r"""
        x.bp_get_selected_items() -> Array[Object] or None
        Gets a list of all the currently selected items
        
        Returns:
            Array[Object] or None: 
        
            items (Array[Object]):
        """
        ...
    def bp_get_selected_item(self) -> Object:
        r"""
        x.bp_get_selected_item() -> Object
        Gets the first selected item, if any; recommended that you only use this for single selection lists.
        
        Returns:
            Object:
        """
        ...
    def bp_get_num_items_selected(self) -> int:
        r"""
        x.bp_get_num_items_selected() -> int32
        Gets the number of items currently selected in the list
        
        Returns:
            int32:
        """
        ...
    def bp_clear_selection(self) -> None:
        r"""
        x.bp_clear_selection() -> None
        Clear selection
        """
        ...
    def bp_cancel_scroll_into_view(self) -> None:
        r"""
        x.bp_cancel_scroll_into_view() -> None
        Cancels a previous request to scroll and item into view.
        """
        ...
    def add_item(self, item: Object) -> None:
        r"""
        x.add_item(item) -> None
        Adds an the item to the list
        
        Args:
            item (Object):
        """
        ...

class WidgetNavigation(Object):
    r"""
    Widget Navigation
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetNavigation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``down`` (WidgetNavigationData):  [Read-Write] Happens when the user presses down arrow, joystick, d-pad.
    - ``left`` (WidgetNavigationData):  [Read-Write] Happens when the user presses left arrow, joystick, d-pad.
    - ``next`` (WidgetNavigationData):  [Read-Write] Happens when the user presses Tab.
    - ``previous`` (WidgetNavigationData):  [Read-Write] Happens when the user presses Shift+Tab.
    - ``right`` (WidgetNavigationData):  [Read-Write] Happens when the user presses right arrow, joystick, d-pad.
    - ``up`` (WidgetNavigationData):  [Read-Write] Happens when the user presses up arrow, joystick, d-pad.
    """
    @property
    def up(self) -> WidgetNavigationData:
        r"""
        (WidgetNavigationData):  [Read-Only] Happens when the user presses up arrow, joystick, d-pad.
        """
        ...
    @property
    def down(self) -> WidgetNavigationData:
        r"""
        (WidgetNavigationData):  [Read-Only] Happens when the user presses down arrow, joystick, d-pad.
        """
        ...
    @property
    def left(self) -> WidgetNavigationData:
        r"""
        (WidgetNavigationData):  [Read-Only] Happens when the user presses left arrow, joystick, d-pad.
        """
        ...
    @property
    def right(self) -> WidgetNavigationData:
        r"""
        (WidgetNavigationData):  [Read-Only] Happens when the user presses right arrow, joystick, d-pad.
        """
        ...
    @property
    def next(self) -> WidgetNavigationData:
        r"""
        (WidgetNavigationData):  [Read-Only] Happens when the user presses Tab.
        """
        ...
    @property
    def previous(self) -> WidgetNavigationData:
        r"""
        (WidgetNavigationData):  [Read-Only] Happens when the user presses Shift+Tab.
        """
        ...

class MovieSceneSignedObject(Object):
    r"""
    namespace UE
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSignedObject.h
    
    """
    ...

class MovieSceneSection(MovieSceneSignedObject):
    r"""
    Base class for movie scene sections
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    def set_row_index(self, new_row_index: int) -> None:
        r"""
        x.set_row_index(new_row_index) -> None
        Sets this section's new row index
        
        Args:
            new_row_index (int32):
        """
        ...
    def set_pre_roll_frames(self, pre_roll_frames: int) -> None:
        r"""
        x.set_pre_roll_frames(pre_roll_frames) -> None
        Gets the number of frames to prepare this section for evaluation before it actually starts.
        
        Args:
            pre_roll_frames (int32):
        """
        ...
    def set_post_roll_frames(self, post_roll_frames: int) -> None:
        r"""
        x.set_post_roll_frames(post_roll_frames) -> None
        Gets/sets the number of frames to continue 'postrolling' this section for after evaluation has ended.
        
        Args:
            post_roll_frames (int32):
        """
        ...
    def set_overlap_priority(self, new_priority: int) -> None:
        r"""
        x.set_overlap_priority(new_priority) -> None
        Sets this section's priority over overlapping sections (higher wins)
        
        Args:
            new_priority (int32):
        """
        ...
    def set_is_locked(self, is_locked: bool) -> None:
        r"""
        x.set_is_locked(is_locked) -> None
        Whether or not this section is locked.
        
        Args:
            is_locked (bool):
        """
        ...
    def set_is_active(self, is_active: bool) -> None:
        r"""
        x.set_is_active(is_active) -> None
        Whether or not this section is active.
        
        Args:
            is_active (bool):
        """
        ...
    def set_completion_mode(self, completion_mode: MovieSceneCompletionMode) -> None:
        r"""
        x.set_completion_mode(completion_mode) -> None
        * Sets this section's completion mode
        
        Args:
            completion_mode (MovieSceneCompletionMode):
        """
        ...
    def set_color_tint(self, color_tint: Color) -> None:
        r"""
        x.set_color_tint(color_tint) -> None
        Set this section's color tint.
        
        Args:
            color_tint (Color):
        """
        ...
    def set_blend_type(self, blend_type: MovieSceneBlendType) -> None:
        r"""
        x.set_blend_type(blend_type) -> None
        Sets this section's blend type
        
        Args:
            blend_type (MovieSceneBlendType):
        """
        ...
    def is_locked(self) -> bool:
        r"""
        x.is_locked() -> bool
        Is Locked
        
        Returns:
            bool:
        """
        ...
    def is_active(self) -> bool:
        r"""
        x.is_active() -> bool
        Is Active
        
        Returns:
            bool:
        """
        ...
    def get_row_index(self) -> int:
        r"""
        x.get_row_index() -> int32
        Gets the row index for this section
        
        Returns:
            int32:
        """
        ...
    def get_pre_roll_frames(self) -> int:
        r"""
        x.get_pre_roll_frames() -> int32
        Get Pre Roll Frames
        
        Returns:
            int32:
        """
        ...
    def get_post_roll_frames(self) -> int:
        r"""
        x.get_post_roll_frames() -> int32
        Get Post Roll Frames
        
        Returns:
            int32:
        """
        ...
    def get_overlap_priority(self) -> int:
        r"""
        x.get_overlap_priority() -> int32
        Gets this section's priority over overlapping sections (higher wins)
        
        Returns:
            int32:
        """
        ...
    def get_completion_mode(self) -> MovieSceneCompletionMode:
        r"""
        x.get_completion_mode() -> MovieSceneCompletionMode
        Gets this section's completion mode
        
        Returns:
            MovieSceneCompletionMode:
        """
        ...
    def get_color_tint(self) -> Color:
        r"""
        x.get_color_tint() -> Color
        Get this section's color tint.
        
        Returns:
            Color:
        """
        ...
    def get_blend_type(self) -> OptionalMovieSceneBlendType:
        r"""
        x.get_blend_type() -> OptionalMovieSceneBlendType
        Gets this section's blend type
        
        Returns:
            OptionalMovieSceneBlendType:
        """
        ...
    def set_start_frame_seconds(self, start_time: float) -> None:
        r"""
        x.set_start_frame_seconds(start_time) -> None
        Set start time in seconds
        
        Args:
            start_time (float): The desired start time for this section
        """
        ...
    def set_start_frame_bounded(self, is_bounded: bool) -> None:
        r"""
        x.set_start_frame_bounded(is_bounded) -> None
        Set start frame bounded
        
        Args:
            is_bounded (bool):
        """
        ...
    def set_start_frame(self, start_frame: int) -> None:
        r"""
        x.set_start_frame(start_frame) -> None
        Set start frame
        
        Args:
            start_frame (int32): The desired start frame for this section
        """
        ...
    def set_range_seconds(self, start_time: float, end_time: float) -> None:
        r"""
        x.set_range_seconds(start_time, end_time) -> None
        Set range in seconds
        
        Args:
            start_time (float): The desired start frame for this section
            end_time (float): The desired end frame for this section
        """
        ...
    def set_range(self, start_frame: int, end_frame: int) -> None:
        r"""
        x.set_range(start_frame, end_frame) -> None
        Set range
        
        Args:
            start_frame (int32): The desired start frame for this section
            end_frame (int32): The desired end frame for this section
        """
        ...
    def set_end_frame_seconds(self, end_time: float) -> None:
        r"""
        x.set_end_frame_seconds(end_time) -> None
        Set end time in seconds
        
        Args:
            end_time (float): The desired end time for this section
        """
        ...
    def set_end_frame_bounded(self, is_bounded: bool) -> None:
        r"""
        x.set_end_frame_bounded(is_bounded) -> None
        Set end frame bounded
        
        Args:
            is_bounded (bool):
        """
        ...
    def set_end_frame(self, end_frame: int) -> None:
        r"""
        x.set_end_frame(end_frame) -> None
        Set end frame
        
        Args:
            end_frame (int32): The desired start frame for this section
        """
        ...
    def has_start_frame(self) -> bool:
        r"""
        x.has_start_frame() -> bool
        Has start frame
        
        Returns:
            bool: Whether this section has a valid start frame (else infinite)
        """
        ...
    def has_end_frame(self) -> bool:
        r"""
        x.has_end_frame() -> bool
        Has end frame
        
        Returns:
            bool: Whether this section has a valid end frame (else infinite)
        """
        ...
    def get_start_frame_seconds(self) -> float:
        r"""
        x.get_start_frame_seconds() -> float
        Get start time in seconds. Will throw an exception if section has no start frame, use HasStartFrame to check first.
        
        Returns:
            float: Start time of this section
        """
        ...
    def get_start_frame(self) -> int:
        r"""
        x.get_start_frame() -> int32
        Get start frame. Will throw an exception if section has no start frame, use HasStartFrame to check first.
        
        Returns:
            int32: Start frame of this section
        """
        ...
    def get_end_frame_seconds(self) -> float:
        r"""
        x.get_end_frame_seconds() -> float
        Get end time in seconds. Will throw an exception if section has no end frame, use HasEndFrame to check first.
        
        Returns:
            float: End time of this section
        """
        ...
    def get_end_frame(self) -> int:
        r"""
        x.get_end_frame() -> int32
        Get end frame. Will throw an exception if section has no end frame, use HasEndFrame to check first.
        
        Returns:
            int32: End frame of this section
        """
        ...
    def get_channels_by_type(self, channel_type: Class) -> Array[MovieSceneScriptingChannel]:
        r"""
        x.get_channels_by_type(channel_type) -> Array[MovieSceneScriptingChannel]
        Find all channels that belong to the specified UMovieSceneSection that match the specific type. This will filter out any children who do not inherit
        from the specified type for you.
        
        Args:
            channel_type (type(Class)): The class type to look for.
        
        Returns:
            Array[MovieSceneScriptingChannel]: An array containing any key channels that match the type specified
        """
        ...
    def get_channel(self, channel_name: Name) -> MovieSceneScriptingChannel:
        r"""
        x.get_channel(channel_name) -> MovieSceneScriptingChannel
        Get channel from specified section and channel name
        
        Args:
            channel_name (Name): The name of the channel.
        
        Returns:
            MovieSceneScriptingChannel: The channel if it exists
        """
        ...
    def get_auto_size_start_frame_seconds(self) -> float:
        r"""
        x.get_auto_size_start_frame_seconds() -> float
        Get start time of the AutoSize in seconds. Will throw an exception if section has no start frame, use GetAutoSizeHasStartFrame to check first.
        
        Returns:
            float: The start frame of the AutoSize data in seconds.
        """
        ...
    def get_auto_size_start_frame(self) -> int:
        r"""
        x.get_auto_size_start_frame() -> int32
        Get start frame of the AutoSize. Will throw an exception if section has no start frame, use GetAutoSizeHasStartFrame to check first.
        
        Returns:
            int32: The start frame of the AutoSize data.
        """
        ...
    def get_auto_size_has_start_frame(self) -> bool:
        r"""
        x.get_auto_size_has_start_frame() -> bool
        Checks to see if this section has an AutoSize implementation, and if so, if that implementation has a start frame.
        
        Returns:
            bool: Whether this section has a valid autosize range, and a valid start frame
        """
        ...
    def get_auto_size_has_end_frame(self) -> bool:
        r"""
        x.get_auto_size_has_end_frame() -> bool
        Checks to see if this section has an AutoSize implementation, and if so, if that implementation has a end frame.
        
        Returns:
            bool: Whether this section has a valid autosize range, and a valid end frame
        """
        ...
    def get_auto_size_end_frame_seconds(self) -> float:
        r"""
        x.get_auto_size_end_frame_seconds() -> float
        Get end time of the AutoSize seconds. Will throw an exception if section has no end frame, use GetAutoSizeHasEndFrame to check first.
        
        Returns:
            float: The end frame of the AutoSize data in seconds.
        """
        ...
    def get_auto_size_end_frame(self) -> int:
        r"""
        x.get_auto_size_end_frame() -> int32
        Get end frame of the AutoSize. Will throw an exception if section has no end frame, use GetAutoSizeHasEndFrame to check first.
        
        Returns:
            int32: The end frame of the AutoSize data.
        """
        ...
    def get_all_channels(self) -> Array[MovieSceneScriptingChannel]:
        r"""
        x.get_all_channels() -> Array[MovieSceneScriptingChannel]
        Find all channels that belong to the specified UMovieSceneSection. Some sections have many channels (such as
        Transforms containing 9 double channels to represent Translation/Rotation/Scale), and a section may have mixed
        channel types.
        
        Returns:
            Array[MovieSceneScriptingChannel]: An array containing any key channels that match the type specified
        """
        ...

class MovieScene2DTransformSection(MovieSceneSection):
    r"""
    A transform section
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MovieScene2DTransformSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneTrack(MovieSceneSignedObject):
    r"""
    Base class for a track in a Movie Scene
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    def set_track_row_display_name(self, name: Text, row_index: int) -> None:
        r"""
        x.set_track_row_display_name(name, row_index) -> None
        Set this track row's display name
        
        Args:
            name (Text): The name for this track
            row_index (int32): The row index for the track
        """
        ...
    def set_sorting_order(self, sorting_order: int) -> None:
        r"""
        x.set_sorting_order(sorting_order) -> None
        Set the sorting order for this track
        
        Args:
            sorting_order (int32): The sorting order to set
        """
        ...
    def set_section_to_key(self, section: MovieSceneSection) -> None:
        r"""
        x.set_section_to_key(section) -> None
        Set the section to key for this track. When properties for this section are modified externally,
        this section will receive those modifications and act accordingly (add/update keys). This is
        especially useful when there are multiple overlapping sections.
        
        Args:
            section (MovieSceneSection): The section to key for this track
        """
        ...
    def set_display_name(self, name: Text) -> None:
        r"""
        x.set_display_name(name) -> None
        Set this track's display name
        
        Args:
            name (Text): The name for this track
        """
        ...
    def set_color_tint(self, color_tint: Color) -> None:
        r"""
        x.set_color_tint(color_tint) -> None
        Set the color tint for this track
        
        Args:
            color_tint (Color): The color tint to set
        """
        ...
    def remove_section(self, section: MovieSceneSection) -> None:
        r"""
        x.remove_section(section) -> None
        Remove the specified section
        
        Args:
            section (MovieSceneSection): The section to remove
        """
        ...
    def get_track_row_display_name(self, row_index: int) -> Text:
        r"""
        x.get_track_row_display_name(row_index) -> Text
        Get this track row's display name
        
        Args:
            row_index (int32): The row index for the track
        
        Returns:
            Text: This track's display name
        """
        ...
    def get_sorting_order(self) -> int:
        r"""
        x.get_sorting_order() -> int32
        Get the sorting order for this track
        
        Returns:
            int32: The sorting order of the requested track
        """
        ...
    def get_section_to_key(self) -> MovieSceneSection:
        r"""
        x.get_section_to_key() -> MovieSceneSection
        Get the section to key for this track
        
        Returns:
            MovieSceneSection: The section to key for the requested track
        """
        ...
    def get_sections(self) -> Array[MovieSceneSection]:
        r"""
        x.get_sections() -> Array[MovieSceneSection]
        Access all this track's sections
        
        Returns:
            Array[MovieSceneSection]: An array of this track's sections
        """
        ...
    def get_display_name(self) -> Text:
        r"""
        x.get_display_name() -> Text
        Get this track's display name
        
        Returns:
            Text: This track's display name
        """
        ...
    def get_color_tint(self) -> Color:
        r"""
        x.get_color_tint() -> Color
        Get the color tint for this track
        
        Returns:
            Color: The color tint of the requested track
        """
        ...
    def add_section(self) -> MovieSceneSection:
        r"""
        x.add_section() -> MovieSceneSection
        Add a new section to this track
        
        Returns:
            MovieSceneSection: The newly create section if successful
        """
        ...

class MovieSceneNameableTrack(MovieSceneTrack):
    r"""
    Base class for movie scene tracks that can be renamed by the user.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneNameableTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieScenePropertyTrack(MovieSceneNameableTrack):
    r"""
    Base class for tracks that animate an object property
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScenePropertyTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    def set_property_name_and_path(self, property_name: Name, property_path: str) -> None:
        r"""
        x.set_property_name_and_path(property_name, property_path) -> None
        Set this track's property name and path
        
        Args:
            property_name (Name): The property name
            property_path (str): The property path
        """
        ...
    def get_unique_track_name(self) -> Name:
        r"""
        x.get_unique_track_name() -> Name
        Get this track's unique name
        
        Returns:
            Name: This track's unique name
        """
        ...
    def get_property_path(self) -> str:
        r"""
        x.get_property_path() -> str
        Get this track's property path
        
        Returns:
            str: This track's property path
        """
        ...
    def get_property_name(self) -> Name:
        r"""
        x.get_property_name() -> Name
        Get this track's property name
        
        Returns:
            Name: This track's property name
        """
        ...

class MovieScene2DTransformTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of 2D transforms in a movie scene
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MovieScene2DTransformTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneMarginSection(MovieSceneSection):
    r"""
    A section in a Margin track
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MovieSceneMarginSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneMarginTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of FMargins in a movie scene
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MovieSceneMarginTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneMaterialTrack(MovieSceneNameableTrack):
    r"""
    Handles manipulation of material parameters in a movie scene.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneMaterialTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneWidgetMaterialTrack(MovieSceneMaterialTrack):
    r"""
    A material track which is specialized for materials which are owned by widget brushes.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MovieSceneWidgetMaterialTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class UMGSequencePlayer(Object):
    r"""
    UMGSequence Player
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UMGSequencePlayer.h
    
    """
    def set_user_tag(self, user_tag: Name) -> None:
        r"""
        x.set_user_tag(user_tag) -> None
        Set User Tag
        
        Args:
            user_tag (Name):
        """
        ...
    def get_user_tag(self) -> Name:
        r"""
        x.get_user_tag() -> Name
        
        
        Returns:
            Name:
        """
        ...

class MovieSceneSequence(MovieSceneSignedObject):
    r"""
    Abstract base class for movie scene animations (C++ version).
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSequence.h
    
    """
    def get_earliest_timecode_source(self) -> MovieSceneTimecodeSource:
        r"""
        x.get_earliest_timecode_source() -> MovieSceneTimecodeSource
        Get the earliest timecode source out of all of the movie scene sections contained within this sequence's movie scene.
        
        Returns:
            MovieSceneTimecodeSource:
        """
        ...
    def find_bindings_by_tag(self, binding_name: Name) -> Array[MovieSceneObjectBindingID]:
        r"""
        x.find_bindings_by_tag(binding_name) -> Array[MovieSceneObjectBindingID]
        Find all object binding IDs associated with the specified tag name (set up through RMB->Expose on Object bindings from within sequencer)
        
        Args:
            binding_name (Name): 
        
        Returns:
            Array[MovieSceneObjectBindingID]:
        """
        ...
    def find_binding_by_tag(self, binding_name: Name) -> MovieSceneObjectBindingID:
        r"""
        x.find_binding_by_tag(binding_name) -> MovieSceneObjectBindingID
        Find the first object binding ID associated with the specified tag name (set up through RMB->Expose on Object bindings from within sequencer)
        
        Args:
            binding_name (Name): 
        
        Returns:
            MovieSceneObjectBindingID:
        """
        ...
    def sort_marked_frames(self) -> None:
        r"""
        x.sort_marked_frames() -> None
        * Sort the marked frames in chronological order
        """
        ...
    def set_work_range_start(self, start_time_in_seconds: float) -> None:
        r"""
        x.set_work_range_start(start_time_in_seconds) -> None
        Set the sequence work range start in seconds
        
        Args:
            start_time_in_seconds (double): The desired work range start time in seconds for this sequence
        """
        ...
    def set_work_range_end(self, end_time_in_seconds: float) -> None:
        r"""
        x.set_work_range_end(end_time_in_seconds) -> None
        Set the sequence work range end in seconds
        
        Args:
            end_time_in_seconds (double):
        """
        ...
    def set_view_range_start(self, start_time_in_seconds: float) -> None:
        r"""
        x.set_view_range_start(start_time_in_seconds) -> None
        Set the sequence view range start in seconds
        
        Args:
            start_time_in_seconds (double): The desired view range start time in seconds for this sequence
        """
        ...
    def set_view_range_end(self, end_time_in_seconds: float) -> None:
        r"""
        x.set_view_range_end(end_time_in_seconds) -> None
        Set the sequence view range end in seconds
        
        Args:
            end_time_in_seconds (double):
        """
        ...
    def set_tick_resolution_directly(self, tick_resolution: FrameRate) -> None:
        r"""
        x.set_tick_resolution_directly(tick_resolution) -> None
        Sets this sequence's tick resolution directly without migrating frame times
        
        Args:
            tick_resolution (FrameRate): The tick resolution of the sequence, defining the smallest unit of time representable on this sequence
        """
        ...
    def set_tick_resolution(self, tick_resolution: FrameRate) -> None:
        r"""
        x.set_tick_resolution(tick_resolution) -> None
        Sets this sequence's tick resolution and migrates frame times
        
        Args:
            tick_resolution (FrameRate): The tick resolution of the sequence, defining the smallest unit of time representable on this sequence
        """
        ...
    def set_read_only(self, read_only: bool) -> None:
        r"""
        x.set_read_only(read_only) -> None
        * Set read only
        *
        *
        bInReadOnly: Whether the movie scene should be read only or not
        
        Args:
            read_only (bool):
        """
        ...
    def set_playback_start_seconds(self, start_time: float) -> None:
        r"""
        x.set_playback_start_seconds(start_time) -> None
        Set playback start of this sequence in seconds
        
        Args:
            start_time (float): The desired start time in seconds for this sequence
        """
        ...
    def set_playback_start(self, start_frame: int) -> None:
        r"""
        x.set_playback_start(start_frame) -> None
        Set playback start of this sequence
        
        Args:
            start_frame (int32): The desired start frame for this sequence
        """
        ...
    def set_playback_range_locked(self, locked: bool) -> None:
        r"""
        x.set_playback_range_locked(locked) -> None
        * Set playback range locked
        *
        *
        bInLocked: Whether the movie scene playback range should be locked
        
        Args:
            locked (bool):
        """
        ...
    def set_playback_end_seconds(self, end_time: float) -> None:
        r"""
        x.set_playback_end_seconds(end_time) -> None
        Set playback end of this sequence in seconds
        
        Args:
            end_time (float): The desired end time in seconds for this sequence
        """
        ...
    def set_playback_end(self, end_frame: int) -> None:
        r"""
        x.set_playback_end(end_frame) -> None
        Set playback end of this sequence
        
        Args:
            end_frame (int32): The desired end frame for this sequence
        """
        ...
    def set_marked_frames_locked(self, locked: bool) -> None:
        r"""
        x.set_marked_frames_locked(locked) -> None
        * Set marked frames locked
        *
        *
        bInLocked: Whether the movie scene marked frames should be locked
        
        Args:
            locked (bool):
        """
        ...
    def set_marked_frame_in_sequence(self, mark_index: int, frame_number: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        x.set_marked_frame_in_sequence(mark_index, frame_number, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        * Sets the frame number for the given marked frame index. Does not maintain sort. Call SortMarkedFrames
        *
        *
        InMarkIndex: The given user marked frame index to edit *
        InFrameNumber: The frame number to set
        
        Args:
            mark_index (int32): 
            frame_number (FrameNumber): 
            time_unit (MovieSceneTimeUnit):
        """
        ...
    def set_marked_frame(self, mark_index: int, frame_number: FrameNumber) -> None:
        r"""
        x.set_marked_frame(mark_index, frame_number) -> None
        Set Marked Frame
        deprecated: SetMarkedFrame is deprecated. Please use SetMarkedFrame that takes a time unit instead
        
        Args:
            mark_index (int32): 
            frame_number (FrameNumber):
        """
        ...
    def set_evaluation_type(self, evaluation_type: MovieSceneEvaluationType) -> None:
        r"""
        x.set_evaluation_type(evaluation_type) -> None
        Set the evaluation type for this sequence
        
        Args:
            evaluation_type (MovieSceneEvaluationType): The evaluation type to set for this sequence
        """
        ...
    def set_display_rate(self, display_rate: FrameRate) -> None:
        r"""
        x.set_display_rate(display_rate) -> None
        Sets this sequence's display rate
        
        Args:
            display_rate (FrameRate): The display rate that this sequence is displayed as
        """
        ...
    def set_clock_source(self, clock_source: UpdateClockSource) -> None:
        r"""
        x.set_clock_source(clock_source) -> None
        Set the clock source for this sequence
        
        Args:
            clock_source (UpdateClockSource): The clock source to set for this sequence
        """
        ...
    def resolve_binding_id(self, object_binding_id: MovieSceneObjectBindingID) -> MovieSceneBindingProxy:
        r"""
        x.resolve_binding_id(object_binding_id) -> MovieSceneBindingProxy
        Make a binding for the given binding ID
        
        Args:
            object_binding_id (MovieSceneObjectBindingID): 
        
        Returns:
            MovieSceneBindingProxy: The new binding proxy
        """
        ...
    def remove_track(self, track: MovieSceneTrack) -> bool:
        r"""
        x.remove_track(track) -> bool
        Removes a track
        
        Args:
            track (MovieSceneTrack): The track to remove
        
        Returns:
            bool: Whether the track was successfully removed
        """
        ...
    def remove_root_folder_from_sequence(self, folder: MovieSceneFolder) -> None:
        r"""
        x.remove_root_folder_from_sequence(folder) -> None
        Remove a root folder from the given sequence. Will throw an exception if the specified folder is not valid or not a root folder.
        
        Args:
            folder (MovieSceneFolder): The folder to remove
        """
        ...
    def remove_master_track(self, track: MovieSceneTrack) -> bool:
        r"""
        x.remove_master_track(track) -> bool
        Remove Master Track
        deprecated: RemoveMasterTrack is deprecated. Please use RemoveTrack instead
        
        Args:
            track (MovieSceneTrack): 
        
        Returns:
            bool:
        """
        ...
    def make_range_seconds(self, start_time: float, duration: float) -> SequencerScriptingRange:
        r"""
        x.make_range_seconds(start_time, duration) -> SequencerScriptingRange
        Make a new range for this sequence in seconds
        
        Args:
            start_time (float): The time in seconds at which to start the range
            duration (float): The length of the range in seconds
        
        Returns:
            SequencerScriptingRange: Specified sequencer range
        """
        ...
    def make_range(self, start_frame: int, duration: int) -> SequencerScriptingRange:
        r"""
        x.make_range(start_frame, duration) -> SequencerScriptingRange
        Make a new range for this sequence in its display rate
        
        Args:
            start_frame (int32): The frame at which to start the range
            duration (int32): The length of the range
        
        Returns:
            SequencerScriptingRange: Specified sequencer range
        """
        ...
    def locate_bound_objects(self, binding: MovieSceneBindingProxy, context: Object) -> Array[Object]:
        r"""
        x.locate_bound_objects(binding, context) -> Array[Object]
        Locate all the objects that correspond to the specified object ID, using the specified context
        
        Args:
            binding (MovieSceneBindingProxy): The object binding
            context (Object): Optional context to use to find the required object
        
        Returns:
            Array[Object]: An array of all bound objects
        """
        ...
    def is_read_only(self) -> bool:
        r"""
        x.is_read_only() -> bool
        * Is read only
        *
        *
        
        Returns:
            bool: Whether the movie scene is read only or not
        """
        ...
    def is_playback_range_locked(self) -> bool:
        r"""
        x.is_playback_range_locked() -> bool
        * Is playback ranged locked
        *
        *
        
        Returns:
            bool: Whether the movie scene playback range is locked
        """
        ...
    def get_work_range_start(self) -> float:
        r"""
        x.get_work_range_start() -> double
        Get the sequence work range start in seconds
        
        Returns:
            double: The work range start time in seconds for this sequence
        """
        ...
    def get_work_range_end(self) -> float:
        r"""
        x.get_work_range_end() -> double
        Get the sequence work range end in seconds
        
        Returns:
            double: The work range end time in seconds for this sequence
        """
        ...
    def get_view_range_start(self) -> float:
        r"""
        x.get_view_range_start() -> double
        Get the sequence view range start in seconds
        
        Returns:
            double: The view range start time in seconds for this sequence
        """
        ...
    def get_view_range_end(self) -> float:
        r"""
        x.get_view_range_end() -> double
        Get the sequence view range end in seconds
        
        Returns:
            double: The view range end time in seconds for this sequence
        """
        ...
    def get_tracks(self) -> Array[MovieSceneTrack]:
        r"""
        x.get_tracks() -> Array[MovieSceneTrack]
        Get all tracks
        
        Returns:
            Array[MovieSceneTrack]: An array containing all tracks in this sequence
        """
        ...
    def get_tick_resolution(self) -> FrameRate:
        r"""
        x.get_tick_resolution() -> FrameRate
        Gets this sequence's tick resolution
        
        Returns:
            FrameRate: The tick resolution of the sequence, defining the smallest unit of time representable on this sequence
        """
        ...
    def get_spawnables(self) -> Array[MovieSceneBindingProxy]:
        r"""
        x.get_spawnables() -> Array[MovieSceneBindingProxy]
        Get all the spawnables in this sequence
        
        Returns:
            Array[MovieSceneBindingProxy]: Spawnables in this sequence
        """
        ...
    def get_root_folders_in_sequence(self) -> Array[MovieSceneFolder]:
        r"""
        x.get_root_folders_in_sequence() -> Array[MovieSceneFolder]
        Get the root folders in the provided sequence
        
        Returns:
            Array[MovieSceneFolder]: The folders contained within the given sequence
        """
        ...
    def get_possessables(self) -> Array[MovieSceneBindingProxy]:
        r"""
        x.get_possessables() -> Array[MovieSceneBindingProxy]
        Get all the possessables in this sequence
        
        Returns:
            Array[MovieSceneBindingProxy]: Possessables in this sequence
        """
        ...
    def get_portable_binding_id(self, destination_sequence: MovieSceneSequence, binding: MovieSceneBindingProxy) -> MovieSceneObjectBindingID:
        r"""
        x.get_portable_binding_id(destination_sequence, binding) -> MovieSceneObjectBindingID
        Get a portable binding ID for a binding that resides in a different sequence to the one where this binding will be resolved.
        note:: This function must be used over GetBindingID when the target binding resides in different shots or sub-sequences.
        note:: Only unique instances of sequences within a root sequences are supported
        
        Args:
            destination_sequence (MovieSceneSequence): The sequence that will own or resolve the resulting binding ID. For example, if the binding ID will be applied to a camera cut section pass the sequence that contains the camera cut track to this parameter.
            binding (MovieSceneBindingProxy): 
        
        Returns:
            MovieSceneObjectBindingID: The binding's id
        """
        ...
    def get_playback_start_seconds(self) -> float:
        r"""
        x.get_playback_start_seconds() -> float
        Get playback start of this sequence in seconds
        
        Returns:
            float: Playback start of this sequence
        """
        ...
    def get_playback_start(self) -> int:
        r"""
        x.get_playback_start() -> int32
        Get playback start of this sequence in display rate resolution
        
        Returns:
            int32: Playback start of this sequence
        """
        ...
    def get_playback_range(self) -> SequencerScriptingRange:
        r"""
        x.get_playback_range() -> SequencerScriptingRange
        Get playback range of this sequence in display rate resolution
        
        Returns:
            SequencerScriptingRange: Playback range of this sequence
        """
        ...
    def get_playback_end_seconds(self) -> float:
        r"""
        x.get_playback_end_seconds() -> float
        Get playback end of this sequence in seconds
        
        Returns:
            float: Playback end of this sequence
        """
        ...
    def get_playback_end(self) -> int:
        r"""
        x.get_playback_end() -> int32
        Get playback end of this sequence in display rate resolution
        
        Returns:
            int32: Playback end of this sequence
        """
        ...
    def get_movie_scene(self) -> MovieScene:
        r"""
        x.get_movie_scene() -> MovieScene
        Get this sequence's movie scene data
        
        Returns:
            MovieScene: This sequence's movie scene data object
        """
        ...
    def get_master_tracks(self) -> Array[MovieSceneTrack]:
        r"""
        x.get_master_tracks() -> Array[MovieSceneTrack]
        Get Master Tracks
        deprecated: GetMasterTracks is deprecated. Please use GetTracks instead
        
        Returns:
            Array[MovieSceneTrack]:
        """
        ...
    def get_marked_frames_from_sequence(self, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[MovieSceneMarkedFrame]:
        r"""
        x.get_marked_frames_from_sequence(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[MovieSceneMarkedFrame]
        * Get the marked frames for this sequence
        *
        *
        
        Args:
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            Array[MovieSceneMarkedFrame]: Return the user marked frames
        """
        ...
    def get_marked_frames(self) -> Array[MovieSceneMarkedFrame]:
        r"""
        x.get_marked_frames() -> Array[MovieSceneMarkedFrame]
        Get Marked Frames
        deprecated: GetMarkedFrames is deprecated. Please use GetMarkedFrames that takes a time unit instead
        
        Returns:
            Array[MovieSceneMarkedFrame]:
        """
        ...
    def get_evaluation_type(self) -> MovieSceneEvaluationType:
        r"""
        x.get_evaluation_type() -> MovieSceneEvaluationType
        Get the evaluation type for this sequence
        
        Returns:
            MovieSceneEvaluationType: The evaluation type for this sequence
        """
        ...
    def get_display_rate(self) -> FrameRate:
        r"""
        x.get_display_rate() -> FrameRate
        Gets this sequence's display rate
        
        Returns:
            FrameRate: The display rate that this sequence is displayed as
        """
        ...
    def get_clock_source(self) -> UpdateClockSource:
        r"""
        x.get_clock_source() -> UpdateClockSource
        Get the clock source for this sequence
        
        Returns:
            UpdateClockSource: The clock source for this sequence
        """
        ...
    def get_bindings(self) -> Array[MovieSceneBindingProxy]:
        r"""
        x.get_bindings() -> Array[MovieSceneBindingProxy]
        Get all the bindings in this sequence
        
        Returns:
            Array[MovieSceneBindingProxy]: An array of unique identifiers for all the bindings in this sequence
        """
        ...
    def get_binding_id(self, binding: MovieSceneBindingProxy) -> MovieSceneObjectBindingID:
        r"""
        x.get_binding_id(binding) -> MovieSceneObjectBindingID
        Get the binding ID for a binding within a sequence.
        note:: The resulting binding is only valid when applied to properties within the same sequence as this binding. Use GetPortableBindingID for bindings which live in different sub-sequences.
        
        Args:
            binding (MovieSceneBindingProxy): 
        
        Returns:
            MovieSceneObjectBindingID: The binding's id
        """
        ...
    def find_tracks_by_type(self, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        x.find_tracks_by_type(track_type) -> Array[MovieSceneTrack]
        Find all tracks of the specified type
        
        Args:
            track_type (type(Class)): A UMovieSceneTrack class type specifying which types of track to return
        
        Returns:
            Array[MovieSceneTrack]: An array containing any tracks that match the type specified
        """
        ...
    def find_tracks_by_exact_type(self, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        x.find_tracks_by_exact_type(track_type) -> Array[MovieSceneTrack]
        Find all tracks of the specified type, not allowing sub-classed types
        
        Args:
            track_type (type(Class)): A UMovieSceneTrack class type specifying the exact types of track to return
        
        Returns:
            Array[MovieSceneTrack]: An array containing any tracks that are exactly the same as the type specified
        """
        ...
    def find_next_marked_frame_in_sequence(self, frame_number: FrameNumber, forward: bool, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> int:
        r"""
        x.find_next_marked_frame_in_sequence(frame_number, forward, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> int32
        * Find the next/previous user marked frame from the given frame number
        *
        *
        InFrameNumber: The frame number to find the next/previous user marked frame from *
        bForward: Find forward from the given frame number.
        
        Args:
            frame_number (FrameNumber): 
            forward (bool): 
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            int32:
        """
        ...
    def find_next_marked_frame(self, frame_number: FrameNumber, forward: bool) -> int:
        r"""
        x.find_next_marked_frame(frame_number, forward) -> int32
        Find Next Marked Frame
        deprecated: FindNextMarkedFrame is deprecated. Please use FindNextMarkedFrame that takes a time unit and defaults to display rate instead
        
        Args:
            frame_number (FrameNumber): 
            forward (bool): 
        
        Returns:
            int32:
        """
        ...
    def find_master_tracks_by_type(self, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        x.find_master_tracks_by_type(track_type) -> Array[MovieSceneTrack]
        Find Master Tracks by Type
        deprecated: FindMasterTracksByType is deprecated. Please use FindTracksByType instead
        
        Args:
            track_type (type(Class)): 
        
        Returns:
            Array[MovieSceneTrack]:
        """
        ...
    def find_master_tracks_by_exact_type(self, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        x.find_master_tracks_by_exact_type(track_type) -> Array[MovieSceneTrack]
        Find Master Tracks by Exact Type
        deprecated: FindMasterTracksByExactType is deprecated. Please use FindTracksByExactType instead
        
        Args:
            track_type (type(Class)): 
        
        Returns:
            Array[MovieSceneTrack]:
        """
        ...
    def find_marked_frame_by_label(self, label: str) -> int:
        r"""
        x.find_marked_frame_by_label(label) -> int32
        * Find the user marked frame by label
        *
        *
        InLabel: The label to the user marked frame to find
        
        Args:
            label (str): 
        
        Returns:
            int32:
        """
        ...
    def find_marked_frame_by_frame_number_in_sequence(self, frame_number: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> int:
        r"""
        x.find_marked_frame_by_frame_number_in_sequence(frame_number, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> int32
        * Find the user marked frame by frame number
        *
        *
        InFrameNumber: The frame number of the user marked frame to find
        
        Args:
            frame_number (FrameNumber): 
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            int32:
        """
        ...
    def find_marked_frame_by_frame_number(self, frame_number: FrameNumber) -> int:
        r"""
        x.find_marked_frame_by_frame_number(frame_number) -> int32
        Find Marked Frame by Frame Number
        deprecated: FindMarkedFrameByFrameNumber is deprecated. Please use FindMarkedFrameByFrameNumber that takes a time unit instead
        
        Args:
            frame_number (FrameNumber): 
        
        Returns:
            int32:
        """
        ...
    def find_binding_by_name(self, name: str) -> MovieSceneBindingProxy:
        r"""
        x.find_binding_by_name(name) -> MovieSceneBindingProxy
        Attempt to locate a binding in this sequence by its name
        
        Args:
            name (str): The display name of the binding to look up
        
        Returns:
            MovieSceneBindingProxy: A unique identifier for the binding, or invalid
        """
        ...
    def find_binding_by_id(self, binding_id: Guid) -> MovieSceneBindingProxy:
        r"""
        x.find_binding_by_id(binding_id) -> MovieSceneBindingProxy
        Attempt to locate a binding in this sequence by its Id
        
        Args:
            binding_id (Guid): The binding Id to look up
        
        Returns:
            MovieSceneBindingProxy: A unique identifier for the binding, or invalid
        """
        ...
    def delete_marked_frames(self) -> None:
        r"""
        x.delete_marked_frames() -> None
        * Delete all user marked frames
        """
        ...
    def delete_marked_frame(self, delete_index: int) -> None:
        r"""
        x.delete_marked_frame(delete_index) -> None
        * Delete the user marked frame by index.
        *
        *
        DeleteIndex: The index to the user marked frame to delete
        
        Args:
            delete_index (int32):
        """
        ...
    def are_marked_frames_locked(self) -> bool:
        r"""
        x.are_marked_frames_locked() -> bool
        * Are marked frames locked
        *
        *
        
        Returns:
            bool: Whether the movie scene marked frames are locked
        """
        ...
    def add_track(self, track_type: Class) -> MovieSceneTrack:
        r"""
        x.add_track(track_type) -> MovieSceneTrack
        Add a new track of the specified type
        
        Args:
            track_type (type(Class)): A UMovieSceneTrack class type to create
        
        Returns:
            MovieSceneTrack: The newly created track, if successful
        """
        ...
    def add_spawnable_from_instance(self, object_to_spawn: Object) -> MovieSceneBindingProxy:
        r"""
        x.add_spawnable_from_instance(object_to_spawn) -> MovieSceneBindingProxy
        Add a new binding to this sequence that will spawn the specified object
        
        Args:
            object_to_spawn (Object): An object instance to use as a template for spawning
        
        Returns:
            MovieSceneBindingProxy: A unique identifier for the new binding
        """
        ...
    def add_spawnable_from_class(self, class_to_spawn: Class) -> MovieSceneBindingProxy:
        r"""
        x.add_spawnable_from_class(class_to_spawn) -> MovieSceneBindingProxy
        Add a new binding to this sequence that will spawn the specified object
        
        Args:
            class_to_spawn (type(Class)): A class or blueprint type to spawn for this binding
        
        Returns:
            MovieSceneBindingProxy: A unique identifier for the new binding
        """
        ...
    def add_root_folder_to_sequence(self, new_folder_name: str) -> MovieSceneFolder:
        r"""
        x.add_root_folder_to_sequence(new_folder_name) -> MovieSceneFolder
        Add a root folder to the given sequence
        
        Args:
            new_folder_name (str): The name to give the added folder
        
        Returns:
            MovieSceneFolder: The newly created folder
        """
        ...
    def add_possessable(self, object_to_possess: Object) -> MovieSceneBindingProxy:
        r"""
        x.add_possessable(object_to_possess) -> MovieSceneBindingProxy
        Add a new binding to this sequence that will possess the specified object
        
        Args:
            object_to_possess (Object): The object that this sequence should possess when evaluating
        
        Returns:
            MovieSceneBindingProxy: A unique identifier for the new binding
        """
        ...
    def add_master_track(self, track_type: Class) -> MovieSceneTrack:
        r"""
        x.add_master_track(track_type) -> MovieSceneTrack
        Add Master Track
        deprecated: AddMasterTrack is deprecated. Please use AddTrack instead
        
        Args:
            track_type (type(Class)): 
        
        Returns:
            MovieSceneTrack:
        """
        ...
    def add_marked_frame_to_sequence(self, marked_frame: MovieSceneMarkedFrame, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> int:
        r"""
        x.add_marked_frame_to_sequence(marked_frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> int32
        * Add a given user marked frame.
        * A unique label will be generated if the marked frame label is empty
        *
        *
        InMarkedFrame: The given user marked frame to add *
        
        Args:
            marked_frame (MovieSceneMarkedFrame): 
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            int32: The index to the newly added marked frame
        """
        ...
    def add_marked_frame(self, marked_frame: MovieSceneMarkedFrame) -> int:
        r"""
        x.add_marked_frame(marked_frame) -> int32
        Add Marked Frame
        deprecated: AddMarkedFrame is deprecated. Please use AddMarkedFrame that takes a time unit instead
        
        Args:
            marked_frame (MovieSceneMarkedFrame): 
        
        Returns:
            int32:
        """
        ...

class WidgetAnimation(MovieSceneSequence):
    r"""
    Widget Animation
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetAnimation.h
    
    """
    def get_start_time(self) -> float:
        r"""
        x.get_start_time() -> float
        Get the start time of this animation.
        see: GetEndTime
        
        Returns:
            float: Start time in seconds.
        """
        ...
    def get_end_time(self) -> float:
        r"""
        x.get_end_time() -> float
        Get the end time of this animation.
        see: GetStartTime
        
        Returns:
            float: End time in seconds.
        """
        ...

class WidgetAnimationPlayCallbackProxy(Object):
    r"""
    Widget Animation Play Callback Proxy
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetAnimationPlayCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``finished`` (WidgetAnimationResult):  [Read-Write] Called when animation has been completed
    """
    @property
    def finished(self) -> WidgetAnimationResult:
        r"""
        (WidgetAnimationResult):  [Read-Write] Called when animation has been completed
        """
        ...
    @finished.setter
    def finished(self, value: WidgetAnimationResult) -> None:
        ...

class BlueprintAsyncActionBase(Object):
    r"""
    BlueprintCallable factory functions for classes which inherit from UBlueprintAsyncActionBase will have a special blueprint node created for it: UK2Node_AsyncAction
    You can stop this node spawning and create a more specific one by adding the UCLASS metadata "HasDedicatedAsyncNode"
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintAsyncActionBase.h
    
    """
    ...

class AsyncTaskDownloadImage(BlueprintAsyncActionBase):
    r"""
    Async Task Download Image
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: AsyncTaskDownloadImage.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_fail`` (DownloadImageDelegate):  [Read-Write]
    - ``on_success`` (DownloadImageDelegate):  [Read-Write]
    """
    @property
    def on_success(self) -> DownloadImageDelegate:
        r"""
        (DownloadImageDelegate):  [Read-Write]
        """
        ...
    @on_success.setter
    def on_success(self, value: DownloadImageDelegate) -> None:
        ...
    @property
    def on_fail(self) -> DownloadImageDelegate:
        r"""
        (DownloadImageDelegate):  [Read-Write]
        """
        ...
    @on_fail.setter
    def on_fail(self, value: DownloadImageDelegate) -> None:
        ...

class GameViewportSubsystem(EngineSubsystem):
    r"""
    Game Viewport Subsystem
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: GameViewportSubsystem.h
    
    """
    @classmethod
    def set_widget_slot_position(cls, slot: GameViewportWidgetSlot, widget: Widget, position: Vector2D, remove_dpi_scale: bool) -> GameViewportWidgetSlot:
        r"""
        X.set_widget_slot_position(slot, widget, position, remove_dpi_scale) -> GameViewportWidgetSlot
        Helper function to set the position in the viewport for the Slot.
        
        Args:
            slot (GameViewportWidgetSlot): 
            widget (Widget): 
            position (Vector2D): The 2D position to set the widget to in the viewport.
            remove_dpi_scale (bool): If you've already calculated inverse DPI, set this to false. Otherwise inverse DPI is applied to the position so that when the location is scaled by DPI, it ends up in the expected position.
        
        Returns:
            GameViewportWidgetSlot:
        """
        ...
    @classmethod
    def set_widget_slot_desired_size(cls, slot: GameViewportWidgetSlot, size: Vector2D) -> GameViewportWidgetSlot:
        r"""
        X.set_widget_slot_desired_size(slot, size) -> GameViewportWidgetSlot
        Helper function to set the desired size in the viewport for the Slot.
        
        Args:
            slot (GameViewportWidgetSlot): 
            size (Vector2D): 
        
        Returns:
            GameViewportWidgetSlot:
        """
        ...
    def set_widget_slot(self, widget: Widget, slot: GameViewportWidgetSlot) -> None:
        r"""
        x.set_widget_slot(widget, slot) -> None
        Update the slot info of a previously added widget or Store the slot info for later use.
        
        Args:
            widget (Widget): 
            slot (GameViewportWidgetSlot):
        """
        ...
    def remove_widget(self, widget: Widget) -> None:
        r"""
        x.remove_widget(widget) -> None
        Removes the widget from the viewport.
        
        Args:
            widget (Widget):
        """
        ...
    def is_widget_added(self, widget: Widget) -> bool:
        r"""
        x.is_widget_added(widget) -> bool
        
        
        Args:
            widget (Widget): 
        
        Returns:
            bool: true if the widget was added to the viewport using AddWidget or AddWidgetForPlayer.
        """
        ...
    def get_widget_slot(self, widget: Widget) -> GameViewportWidgetSlot:
        r"""
        x.get_widget_slot(widget) -> GameViewportWidgetSlot
        The slot info from previously added widget or info that is store for later.
        
        Args:
            widget (Widget): 
        
        Returns:
            GameViewportWidgetSlot:
        """
        ...
    def add_widget_for_player(self, widget: Widget, player: LocalPlayer, slot: GameViewportWidgetSlot) -> bool:
        r"""
        x.add_widget_for_player(widget, player, slot) -> bool
        Adds the widget to the game's viewport in the section dedicated to the player. This is valuable in a split screen
        game where you need to only show a widget over a player's portion of the viewport.
        
        Args:
            widget (Widget): 
            player (LocalPlayer): 
            slot (GameViewportWidgetSlot): 
        
        Returns:
            bool:
        """
        ...
    def add_widget(self, widget: Widget, slot: GameViewportWidgetSlot) -> bool:
        r"""
        x.add_widget(widget, slot) -> bool
        Adds it to the game's viewport.
        
        Args:
            widget (Widget): 
            slot (GameViewportWidgetSlot): 
        
        Returns:
            bool:
        """
        ...

class UserListEntry(Interface):
    r"""
    User List Entry
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: IUserListEntry.h
    
    """
    def bp_on_item_selection_changed(self, is_selected: bool) -> None:
        r"""
        x.bp_on_item_selection_changed(is_selected) -> None
        Called when the selection state of the item represented by this entry changes.
        
        Args:
            is_selected (bool):
        """
        ...
    def bp_on_item_expansion_changed(self, is_expanded: bool) -> None:
        r"""
        x.bp_on_item_expansion_changed(is_expanded) -> None
        Called when the expansion state of the item represented by this entry changes. Tree view entries only.
        
        Args:
            is_expanded (bool):
        """
        ...
    def bp_on_entry_released(self) -> None:
        r"""
        x.bp_on_entry_released() -> None
        Called when this entry is released from the owning table and no longer represents any list item
        """
        ...

class UserListEntryLibrary(BlueprintFunctionLibrary):
    r"""
    Static library to supply "for free" functionality to widgets that implement IUserListEntry
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: IUserListEntry.h
    
    """
    @classmethod
    def is_list_item_selected(cls, user_list_entry: UserListEntry) -> bool:
        r"""
        X.is_list_item_selected(user_list_entry) -> bool
        Returns true if the item represented by this entry is currently selected in the owning list view.
        
        Args:
            user_list_entry (UserListEntry): Note: Visually not transmitted, but this defaults to "self". No need to hook up if calling internally.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_list_item_expanded(cls, user_list_entry: UserListEntry) -> bool:
        r"""
        X.is_list_item_expanded(user_list_entry) -> bool
        Returns true if the item represented by this entry is currently expanded and showing its children. Tree view entries only.
        
        Args:
            user_list_entry (UserListEntry): Note: Visually not transmitted, but this defaults to "self". No need to hook up if calling internally.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_owning_list_view(cls, user_list_entry: UserListEntry) -> ListViewBase:
        r"""
        X.get_owning_list_view(user_list_entry) -> ListViewBase
        Returns the list view that contains this entry.
        
        Args:
            user_list_entry (UserListEntry): Note: Visually not transmitted, but this defaults to "self". No need to hook up if calling internally.
        
        Returns:
            ListViewBase:
        """
        ...

class UserObjectListEntry(UserListEntry):
    r"""
    User Object List Entry
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: IUserObjectListEntry.h
    
    """
    def on_list_item_object_set(self, list_item_object: Object) -> None:
        r"""
        x.on_list_item_object_set(list_item_object) -> None
        Called when this entry is assigned a new item object to represent by the owning list view
        
        Args:
            list_item_object (Object):
        """
        ...

class UserObjectListEntryLibrary(BlueprintFunctionLibrary):
    r"""
    Static library to supply "for free" functionality to widgets that implement IUserListEntry
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: IUserObjectListEntry.h
    
    """
    @classmethod
    def get_list_item_object(cls, user_object_list_entry: UserObjectListEntry) -> Object:
        r"""
        X.get_list_item_object(user_object_list_entry) -> Object
        Returns the item in the owning list view that this entry is currently assigned to represent.
        
        Args:
            user_object_list_entry (UserObjectListEntry): Note: Visually not transmitted, but this defaults to "self". No need to hook up if calling internally.
        
        Returns:
            Object:
        """
        ...

class PanelWidget(Widget):
    r"""
    The base class for all UMG panel widgets.  Panel widgets layout a collection of child widgets.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: PanelWidget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    def remove_child_at(self, index: int) -> bool:
        r"""
        x.remove_child_at(index) -> bool
        Removes a child by it's index.
        
        Args:
            index (int32): 
        
        Returns:
            bool:
        """
        ...
    def remove_child(self, content: Widget) -> bool:
        r"""
        x.remove_child(content) -> bool
        Removes a specific widget from the container.
        
        Args:
            content (Widget): 
        
        Returns:
            bool: true if the widget was found and removed.
        """
        ...
    def has_child(self, content: Widget) -> bool:
        r"""
        x.has_child(content) -> bool
        Returns true if panel contains this widget
        
        Args:
            content (Widget): 
        
        Returns:
            bool:
        """
        ...
    def has_any_children(self) -> bool:
        r"""
        x.has_any_children() -> bool
        Returns true if there are any child widgets in the panel
        
        Returns:
            bool:
        """
        ...
    def get_children_count(self) -> int:
        r"""
        x.get_children_count() -> int32
        Gets number of child widgets in the container.
        
        Returns:
            int32:
        """
        ...
    def get_child_index(self, content: Widget) -> int:
        r"""
        x.get_child_index(content) -> int32
        Gets the index of a specific child widget
        
        Args:
            content (Widget): 
        
        Returns:
            int32:
        """
        ...
    def get_child_at(self, index: int) -> Widget:
        r"""
        x.get_child_at(index) -> Widget
        Gets the widget at an index.
        
        Args:
            index (int32): The index of the widget.
        
        Returns:
            Widget: The widget at the given index, or nothing if there is no widget there.
        """
        ...
    def get_all_children(self) -> Array[Widget]:
        r"""
        x.get_all_children() -> Array[Widget]
        Gets all widgets in the container
        
        Returns:
            Array[Widget]:
        """
        ...
    def clear_children(self) -> None:
        r"""
        x.clear_children() -> None
        Remove all child widgets from the panel widget.
        """
        ...
    def add_child(self, content: Widget) -> PanelSlot:
        r"""
        x.add_child(content) -> PanelSlot
        Adds a new child widget to the container.  Returns the base slot type,
        requires casting to turn it into the type specific to the container.
        
        Args:
            content (Widget): 
        
        Returns:
            PanelSlot:
        """
        ...

class ContentWidget(PanelWidget):
    r"""
    Content Widget
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ContentWidget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    def set_content(self, content: Widget) -> PanelSlot:
        r"""
        x.set_content(content) -> PanelSlot
        Set Content
        
        Args:
            content (Widget): 
        
        Returns:
            PanelSlot:
        """
        ...
    def get_content_slot(self) -> PanelSlot:
        r"""
        x.get_content_slot() -> PanelSlot
        Get Content Slot
        
        Returns:
            PanelSlot:
        """
        ...
    def get_content(self) -> Widget:
        r"""
        x.get_content() -> Widget
        Get Content
        
        Returns:
            Widget:
        """
        ...

class BackgroundBlur(ContentWidget):
    r"""
    A background blur is a container widget that can contain one child widget, providing an opportunity
    to surround it with adjustable padding and apply a post-process Gaussian blur to all content beneath the widget.
    
    * Single Child
    * Blur Effect
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: BackgroundBlur.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``apply_alpha_to_blur`` (bool):  [Read-Write] True to modulate the strength of the blur based on the widget alpha.
    - ``blur_radius`` (int32):  [Read-Write] This is the number of pixels which will be weighted in each direction from any given pixel when computing the blur
      A larger value is more costly but allows for stronger blurs.
    - ``blur_strength`` (float):  [Read-Write] How blurry the background is.  Larger numbers mean more blurry but will result in larger runtime cost on the GPU.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``corner_radius`` (Vector4):  [Read-Write] This is the number of pixels which will be weighted in each direction from any given pixel when computing the blur
      A larger value is more costly but allows for stronger blurs.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the content horizontally.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``low_quality_fallback_brush`` (SlateBrush):  [Read-Write] An image to draw instead of applying a blur when low quality override mode is enabled.
      You can enable low quality mode for background blurs by setting the cvar Slate.ForceBackgroundBlurLowQualityOverride to 1.
      This is usually done in the project's scalability settings
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the content vertically.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the content horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the content vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    @property
    def apply_alpha_to_blur(self) -> bool:
        r"""
        (bool):  [Read-Write] True to modulate the strength of the blur based on the widget alpha.
        """
        ...
    @apply_alpha_to_blur.setter
    def apply_alpha_to_blur(self, value: bool) -> None:
        ...
    @property
    def blur_strength(self) -> float:
        r"""
        (float):  [Read-Write] How blurry the background is.  Larger numbers mean more blurry but will result in larger runtime cost on the GPU.
        """
        ...
    @blur_strength.setter
    def blur_strength(self, value: float) -> None:
        ...
    @property
    def blur_radius(self) -> int:
        r"""
        (int32):  [Read-Write] This is the number of pixels which will be weighted in each direction from any given pixel when computing the blur
        A larger value is more costly but allows for stronger blurs.
        """
        ...
    @blur_radius.setter
    def blur_radius(self, value: int) -> None:
        ...
    @property
    def corner_radius(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] This is the number of pixels which will be weighted in each direction from any given pixel when computing the blur
        A larger value is more costly but allows for stronger blurs.
        """
        ...
    @corner_radius.setter
    def corner_radius(self, value: Vector4) -> None:
        ...
    @property
    def low_quality_fallback_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] An image to draw instead of applying a blur when low quality override mode is enabled.
        You can enable low quality mode for background blurs by setting the cvar Slate.ForceBackgroundBlurLowQualityOverride to 1.
        This is usually done in the project's scalability settings
        """
        ...
    @low_quality_fallback_brush.setter
    def low_quality_fallback_brush(self, value: SlateBrush) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_low_quality_fallback_brush(self, brush: SlateBrush) -> None:
        r"""
        x.set_low_quality_fallback_brush(brush) -> None
        Set Low Quality Fallback Brush
        
        Args:
            brush (SlateBrush):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...
    def set_corner_radius(self, corner_radius: Vector4) -> None:
        r"""
        x.set_corner_radius(corner_radius) -> None
        Set Corner Radius
        
        Args:
            corner_radius (Vector4):
        """
        ...
    def set_blur_strength(self, strength: float) -> None:
        r"""
        x.set_blur_strength(strength) -> None
        Set Blur Strength
        
        Args:
            strength (float):
        """
        ...
    def set_blur_radius(self, blur_radius: int) -> None:
        r"""
        x.set_blur_radius(blur_radius) -> None
        Set Blur Radius
        
        Args:
            blur_radius (int32):
        """
        ...
    def set_apply_alpha_to_blur(self, apply_alpha_to_blur: bool) -> None:
        r"""
        x.set_apply_alpha_to_blur(apply_alpha_to_blur) -> None
        Set Apply Alpha to Blur
        
        Args:
            apply_alpha_to_blur (bool):
        """
        ...

class BackgroundBlurWidget(BackgroundBlur):
    r"""
    deprecated: 'BackgroundBlurWidget' was renamed to 'BackgroundBlur'.
    """
    ...

class PanelSlot(Visual):
    r"""
    The base class for all Slots in UMG.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: PanelSlot.h
    
    """
    ...

class BackgroundBlurSlot(PanelSlot):
    r"""
    The Slot for the UBackgroundBlurSlot, contains the widget displayed in a BackgroundBlur's single slot
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: BackgroundBlurSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class Border(ContentWidget):
    r"""
    A border is a container widget that can contain one child widget, providing an opportunity
    to surround it with a background image and adjustable padding.
    
    * Single Child
    * Image
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Border.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``background`` (SlateBrush):  [Read-Write] Brush to drag as the background
    - ``brush_color`` (LinearColor):  [Read-Write] Color and opacity of the actual border image
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``content_color_and_opacity`` (LinearColor):  [Read-Write] Color and opacity multiplier of content in the border
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``desired_size_scale`` (Vector2D):  [Read-Write] Scales the computed desired size of this border and its contents. Useful
      for making things that slide open without having to hard-code their size.
      Note: if the parent widget is set up to ignore this widget's desired size,
      then changing this value will have no effect.
    - ``flip_for_right_to_left_flow_direction`` (bool):  [Read-Write] Flips the background image if the localization's flow direction is RightToLeft
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the content horizontally.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_mouse_button_down_event`` (OnPointerEvent):  [Read-Write]
    - ``on_mouse_button_up_event`` (OnPointerEvent):  [Read-Write]
    - ``on_mouse_double_click_event`` (OnPointerEvent):  [Read-Write]
    - ``on_mouse_move_event`` (OnPointerEvent):  [Read-Write]
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``show_effect_when_disabled`` (bool):  [Read-Write] Whether or not to show the disabled effect when this border is disabled
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the content vertically.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the content horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the content vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    @property
    def show_effect_when_disabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to show the disabled effect when this border is disabled
        """
        ...
    @show_effect_when_disabled.setter
    def show_effect_when_disabled(self, value: bool) -> None:
        ...
    @property
    def content_color_and_opacity(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Color and opacity multiplier of content in the border
        """
        ...
    @content_color_and_opacity.setter
    def content_color_and_opacity(self, value: LinearColor) -> None:
        ...
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def background(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Only] Brush to drag as the background
        """
        ...
    @property
    def brush_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Color and opacity of the actual border image
        """
        ...
    @brush_color.setter
    def brush_color(self, value: LinearColor) -> None:
        ...
    @property
    def desired_size_scale(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Scales the computed desired size of this border and its contents. Useful
        for making things that slide open without having to hard-code their size.
        Note: if the parent widget is set up to ignore this widget's desired size,
        then changing this value will have no effect.
        """
        ...
    @desired_size_scale.setter
    def desired_size_scale(self, value: Vector2D) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_show_effect_when_disabled(self, show_effect_when_disabled: bool) -> None:
        r"""
        x.set_show_effect_when_disabled(show_effect_when_disabled) -> None
        Set Show Effect when Disabled
        
        Args:
            show_effect_when_disabled (bool):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...
    def set_desired_size_scale(self, scale: Vector2D) -> None:
        r"""
        x.set_desired_size_scale(scale) -> None
        Sets the DesiredSizeScale of this border.
        
        Args:
            scale (Vector2D): The X and Y multipliers for the desired size
        """
        ...
    def set_content_color_and_opacity(self, content_color_and_opacity: LinearColor) -> None:
        r"""
        x.set_content_color_and_opacity(content_color_and_opacity) -> None
        Set Content Color and Opacity
        
        Args:
            content_color_and_opacity (LinearColor):
        """
        ...
    def set_brush_from_texture(self, texture: Texture2D) -> None:
        r"""
        x.set_brush_from_texture(texture) -> None
        Set Brush from Texture
        
        Args:
            texture (Texture2D):
        """
        ...
    def set_brush_from_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_brush_from_material(material) -> None
        Set Brush from Material
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_brush_from_asset(self, asset: SlateBrushAsset) -> None:
        r"""
        x.set_brush_from_asset(asset) -> None
        Set Brush from Asset
        
        Args:
            asset (SlateBrushAsset):
        """
        ...
    def set_brush_color(self, brush_color: LinearColor) -> None:
        r"""
        x.set_brush_color(brush_color) -> None
        Set Brush Color
        
        Args:
            brush_color (LinearColor):
        """
        ...
    def set_brush(self, brush: SlateBrush) -> None:
        r"""
        x.set_brush(brush) -> None
        Set Brush
        
        Args:
            brush (SlateBrush):
        """
        ...
    def get_dynamic_material(self) -> MaterialInstanceDynamic:
        r"""
        x.get_dynamic_material() -> MaterialInstanceDynamic
        Get Dynamic Material
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...

class BorderSlot(PanelSlot):
    r"""
    The Slot for the UBorderSlot, contains the widget displayed in a border's single slot
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: BorderSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class Button(ContentWidget):
    r"""
    The button is a click-able primitive widget to enable basic interaction, you
    can place any other widget inside a button to make a more complex and
    interesting click-able element in your UI.
    
    * Single Child
    * Clickable
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Button.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``background_color`` (LinearColor):  [Read-Write] The color multiplier for the button background
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``click_method`` (ButtonClickMethod):  [Read-Write] The type of mouse action required by the user to trigger the buttons 'Click'
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``color_and_opacity`` (LinearColor):  [Read-Write] The color multiplier for the button content
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Sometimes a button should only be mouse-clickable and never keyboard focusable.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_clicked`` (OnButtonClickedEvent):  [Read-Write] Called when the button is clicked
    - ``on_hovered`` (OnButtonHoverEvent):  [Read-Write]
    - ``on_pressed`` (OnButtonPressedEvent):  [Read-Write] Called when the button is pressed
    - ``on_released`` (OnButtonReleasedEvent):  [Read-Write] Called when the button is released
    - ``on_unhovered`` (OnButtonHoverEvent):  [Read-Write]
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``press_method`` (ButtonPressMethod):  [Read-Write] The type of keyboard/gamepad button press action required by the user to trigger the buttons 'Click'
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``touch_method`` (ButtonTouchMethod):  [Read-Write] The type of touch action required by the user to trigger the buttons 'Click'
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ButtonStyle):  [Read-Write] The button style used at runtime
    """
    @property
    def widget_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write] The button style used at runtime
        """
        ...
    @widget_style.setter
    def widget_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def color_and_opacity(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color multiplier for the button content
        """
        ...
    @color_and_opacity.setter
    def color_and_opacity(self, value: LinearColor) -> None:
        ...
    @property
    def background_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color multiplier for the button background
        """
        ...
    @background_color.setter
    def background_color(self, value: LinearColor) -> None:
        ...
    @property
    def click_method(self) -> ButtonClickMethod:
        r"""
        (ButtonClickMethod):  [Read-Write] The type of mouse action required by the user to trigger the buttons 'Click'
        """
        ...
    @click_method.setter
    def click_method(self, value: ButtonClickMethod) -> None:
        ...
    @property
    def touch_method(self) -> ButtonTouchMethod:
        r"""
        (ButtonTouchMethod):  [Read-Write] The type of touch action required by the user to trigger the buttons 'Click'
        """
        ...
    @touch_method.setter
    def touch_method(self, value: ButtonTouchMethod) -> None:
        ...
    @property
    def press_method(self) -> ButtonPressMethod:
        r"""
        (ButtonPressMethod):  [Read-Write] The type of keyboard/gamepad button press action required by the user to trigger the buttons 'Click'
        """
        ...
    @press_method.setter
    def press_method(self, value: ButtonPressMethod) -> None:
        ...
    @property
    def is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Only] Sometimes a button should only be mouse-clickable and never keyboard focusable.
        """
        ...
    @property
    def on_clicked(self) -> OnButtonClickedEvent:
        r"""
        (OnButtonClickedEvent):  [Read-Write] Called when the button is clicked
        """
        ...
    @on_clicked.setter
    def on_clicked(self, value: OnButtonClickedEvent) -> None:
        ...
    @property
    def on_pressed(self) -> OnButtonPressedEvent:
        r"""
        (OnButtonPressedEvent):  [Read-Write] Called when the button is pressed
        """
        ...
    @on_pressed.setter
    def on_pressed(self, value: OnButtonPressedEvent) -> None:
        ...
    @property
    def on_released(self) -> OnButtonReleasedEvent:
        r"""
        (OnButtonReleasedEvent):  [Read-Write] Called when the button is released
        """
        ...
    @on_released.setter
    def on_released(self, value: OnButtonReleasedEvent) -> None:
        ...
    @property
    def on_hovered(self) -> OnButtonHoverEvent:
        r"""
        (OnButtonHoverEvent):  [Read-Write]
        """
        ...
    @on_hovered.setter
    def on_hovered(self, value: OnButtonHoverEvent) -> None:
        ...
    @property
    def on_unhovered(self) -> OnButtonHoverEvent:
        r"""
        (OnButtonHoverEvent):  [Read-Write]
        """
        ...
    @on_unhovered.setter
    def on_unhovered(self, value: OnButtonHoverEvent) -> None:
        ...
    def set_touch_method(self, touch_method: ButtonTouchMethod) -> None:
        r"""
        x.set_touch_method(touch_method) -> None
        Set Touch Method
        
        Args:
            touch_method (ButtonTouchMethod):
        """
        ...
    def set_style(self, style: ButtonStyle) -> None:
        r"""
        x.set_style(style) -> None
        Sets the color multiplier for the button background
        
        Args:
            style (ButtonStyle):
        """
        ...
    def set_press_method(self, press_method: ButtonPressMethod) -> None:
        r"""
        x.set_press_method(press_method) -> None
        Set Press Method
        
        Args:
            press_method (ButtonPressMethod):
        """
        ...
    def set_color_and_opacity(self, color_and_opacity: LinearColor) -> None:
        r"""
        x.set_color_and_opacity(color_and_opacity) -> None
        Sets the color multiplier for the button content
        
        Args:
            color_and_opacity (LinearColor):
        """
        ...
    def set_click_method(self, click_method: ButtonClickMethod) -> None:
        r"""
        x.set_click_method(click_method) -> None
        Set Click Method
        
        Args:
            click_method (ButtonClickMethod):
        """
        ...
    def set_background_color(self, background_color: LinearColor) -> None:
        r"""
        x.set_background_color(background_color) -> None
        Sets the color multiplier for the button background
        
        Args:
            background_color (LinearColor):
        """
        ...
    def is_pressed(self) -> bool:
        r"""
        x.is_pressed() -> bool
        Returns true if the user is actively pressing the button.  Do not use this for detecting 'Clicks', use the OnClicked event instead.
        
        Returns:
            bool: true if the user is actively pressing the button otherwise false.
        """
        ...

class ButtonSlot(PanelSlot):
    r"""
    The Slot for the UButtonSlot, contains the widget displayed in a button's single slot
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ButtonSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class CanvasPanel(PanelWidget):
    r"""
    The canvas panel is a designer friendly panel that allows widgets to be laid out at arbitrary
    locations, anchored and z-ordered with other children of the canvas.  The canvas is a great widget
    for manual layout, but bad when you want to procedurally just generate widgets and place them in a
    container (unless you want absolute layout).
    
    * Many Children
    * Absolute Layout
    * Anchors
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: CanvasPanel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    def add_child_to_canvas(self, content: Widget) -> CanvasPanelSlot:
        r"""
        x.add_child_to_canvas(content) -> CanvasPanelSlot
        Add Child to Canvas
        
        Args:
            content (Widget): 
        
        Returns:
            CanvasPanelSlot:
        """
        ...

class CanvasPanelSlot(PanelSlot):
    r"""
    Canvas Panel Slot
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: CanvasPanelSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_size`` (bool):  [Read-Write] When AutoSize is true we use the widget's desired size
    - ``layout_data`` (AnchorData):  [Read-Write] The anchoring information for the slot
    - ``z_order`` (int32):  [Read-Write] The order priority this widget is rendered in.  Higher values are rendered last (and so they will appear to be on top).
    """
    @property
    def layout_data(self) -> AnchorData:
        r"""
        (AnchorData):  [Read-Write] The anchoring information for the slot
        """
        ...
    @layout_data.setter
    def layout_data(self, value: AnchorData) -> None:
        ...
    @property
    def auto_size(self) -> bool:
        r"""
        (bool):  [Read-Write] When AutoSize is true we use the widget's desired size
        """
        ...
    @auto_size.setter
    def auto_size(self, value: bool) -> None:
        ...
    @property
    def z_order(self) -> int:
        r"""
        (int32):  [Read-Write] The order priority this widget is rendered in.  Higher values are rendered last (and so they will appear to be on top).
        """
        ...
    @z_order.setter
    def z_order(self, value: int) -> None:
        ...
    def set_z_order(self, z_order: int) -> None:
        r"""
        x.set_z_order(z_order) -> None
        Sets the z-order on the slot
        
        Args:
            z_order (int32):
        """
        ...
    def set_size(self, size: Vector2D) -> None:
        r"""
        x.set_size(size) -> None
        Sets the size of the slot
        
        Args:
            size (Vector2D):
        """
        ...
    def set_position(self, position: Vector2D) -> None:
        r"""
        x.set_position(position) -> None
        Sets the position of the slot
        
        Args:
            position (Vector2D):
        """
        ...
    def set_offsets(self, offset: Margin) -> None:
        r"""
        x.set_offsets(offset) -> None
        Sets the offset data of the slot, which could be position and size, or margins depending on the anchor points
        
        Args:
            offset (Margin):
        """
        ...
    def set_layout(self, layout_data: AnchorData) -> None:
        r"""
        x.set_layout(layout_data) -> None
        Sets the layout data of the slot
        
        Args:
            layout_data (AnchorData):
        """
        ...
    def set_auto_size(self, inb_auto_size: bool) -> None:
        r"""
        x.set_auto_size(inb_auto_size) -> None
        Sets if the slot to be auto-sized
        
        Args:
            inb_auto_size (bool):
        """
        ...
    def set_anchors(self, anchors: Anchors) -> None:
        r"""
        x.set_anchors(anchors) -> None
        Sets the anchors on the slot
        
        Args:
            anchors (Anchors):
        """
        ...
    def set_alignment(self, alignment: Vector2D) -> None:
        r"""
        x.set_alignment(alignment) -> None
        Sets the alignment on the slot
        
        Args:
            alignment (Vector2D):
        """
        ...
    def get_z_order(self) -> int:
        r"""
        x.get_z_order() -> int32
        Gets the z-order on the slot
        
        Returns:
            int32:
        """
        ...
    def get_size(self) -> Vector2D:
        r"""
        x.get_size() -> Vector2D
        Gets the size of the slot
        
        Returns:
            Vector2D:
        """
        ...
    def get_position(self) -> Vector2D:
        r"""
        x.get_position() -> Vector2D
        Gets the position of the slot
        
        Returns:
            Vector2D:
        """
        ...
    def get_offsets(self) -> Margin:
        r"""
        x.get_offsets() -> Margin
        Gets the offset data of the slot, which could be position and size, or margins depending on the anchor points
        
        Returns:
            Margin:
        """
        ...
    def get_layout(self) -> AnchorData:
        r"""
        x.get_layout() -> AnchorData
        Gets the layout data of the slot
        
        Returns:
            AnchorData:
        """
        ...
    def get_auto_size(self) -> bool:
        r"""
        x.get_auto_size() -> bool
        Gets if the slot to be auto-sized
        
        Returns:
            bool:
        """
        ...
    def get_anchors(self) -> Anchors:
        r"""
        x.get_anchors() -> Anchors
        Gets the anchors on the slot
        
        Returns:
            Anchors:
        """
        ...
    def get_alignment(self) -> Vector2D:
        r"""
        x.get_alignment() -> Vector2D
        Gets the alignment on the slot
        
        Returns:
            Vector2D:
        """
        ...

class CheckBox(ContentWidget):
    r"""
    The checkbox widget allows you to display a toggled state of 'unchecked', 'checked' and
    'indeterminable.  You can use the checkbox for a classic checkbox, or as a toggle button,
    or as radio buttons.
    
    * Single Child
    * Toggle
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: CheckBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``checked_state`` (CheckBoxState):  [Read-Write] Whether the check box is currently in a checked state
    - ``click_method`` (ButtonClickMethod):  [Read-Write] The type of mouse action required by the user to trigger the buttons 'Click'
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] How the content of the toggle button should align within the given space
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Sometimes a button should only be mouse-clickable and never keyboard focusable.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_check_state_changed`` (OnCheckBoxComponentStateChanged):  [Read-Write] Called when the checked state has changed
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``press_method`` (ButtonPressMethod):  [Read-Write] The type of keyboard/gamepad button press action required by the user to trigger the buttons 'Click'
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``touch_method`` (ButtonTouchMethod):  [Read-Write] The type of touch action required by the user to trigger the buttons 'Click'
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (CheckBoxStyle):  [Read-Write] The checkbox bar style
    """
    @property
    def checked_state(self) -> CheckBoxState:
        r"""
        (CheckBoxState):  [Read-Write] Whether the check box is currently in a checked state
        """
        ...
    @checked_state.setter
    def checked_state(self, value: CheckBoxState) -> None:
        ...
    @property
    def widget_style(self) -> CheckBoxStyle:
        r"""
        (CheckBoxStyle):  [Read-Write] The checkbox bar style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: CheckBoxStyle) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Only] How the content of the toggle button should align within the given space
        """
        ...
    @property
    def click_method(self) -> ButtonClickMethod:
        r"""
        (ButtonClickMethod):  [Read-Write] The type of mouse action required by the user to trigger the buttons 'Click'
        """
        ...
    @click_method.setter
    def click_method(self, value: ButtonClickMethod) -> None:
        ...
    @property
    def touch_method(self) -> ButtonTouchMethod:
        r"""
        (ButtonTouchMethod):  [Read-Write] The type of touch action required by the user to trigger the buttons 'Click'
        """
        ...
    @touch_method.setter
    def touch_method(self, value: ButtonTouchMethod) -> None:
        ...
    @property
    def press_method(self) -> ButtonPressMethod:
        r"""
        (ButtonPressMethod):  [Read-Write] The type of keyboard/gamepad button press action required by the user to trigger the buttons 'Click'
        """
        ...
    @press_method.setter
    def press_method(self, value: ButtonPressMethod) -> None:
        ...
    @property
    def is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Only] Sometimes a button should only be mouse-clickable and never keyboard focusable.
        """
        ...
    @property
    def on_check_state_changed(self) -> OnCheckBoxComponentStateChanged:
        r"""
        (OnCheckBoxComponentStateChanged):  [Read-Write] Called when the checked state has changed
        """
        ...
    @on_check_state_changed.setter
    def on_check_state_changed(self, value: OnCheckBoxComponentStateChanged) -> None:
        ...
    def set_touch_method(self, touch_method: ButtonTouchMethod) -> None:
        r"""
        x.set_touch_method(touch_method) -> None
        Sets the touch method.
        
        Args:
            touch_method (ButtonTouchMethod):
        """
        ...
    def set_press_method(self, press_method: ButtonPressMethod) -> None:
        r"""
        x.set_press_method(press_method) -> None
        Sets the press method.
        
        Args:
            press_method (ButtonPressMethod):
        """
        ...
    def set_is_checked(self, is_checked: bool) -> None:
        r"""
        x.set_is_checked(is_checked) -> None
        Sets the checked state.
        
        Args:
            is_checked (bool):
        """
        ...
    def set_click_method(self, click_method: ButtonClickMethod) -> None:
        r"""
        x.set_click_method(click_method) -> None
        Sets the click method.
        
        Args:
            click_method (ButtonClickMethod):
        """
        ...
    def set_checked_state(self, checked_state: CheckBoxState) -> None:
        r"""
        x.set_checked_state(checked_state) -> None
        Sets the checked state.
        
        Args:
            checked_state (CheckBoxState):
        """
        ...
    def is_pressed(self) -> bool:
        r"""
        x.is_pressed() -> bool
        Returns true if this button is currently pressed
        
        Returns:
            bool:
        """
        ...
    def is_checked(self) -> bool:
        r"""
        x.is_checked() -> bool
        Returns true if the checkbox is currently checked
        
        Returns:
            bool:
        """
        ...
    def get_checked_state(self) -> CheckBoxState:
        r"""
        x.get_checked_state() -> CheckBoxState
        Returns the full current checked state.
        
        Returns:
            CheckBoxState:
        """
        ...

class CircularThrobber(Widget):
    r"""
    A throbber widget that orients images in a spinning circle.
    
    * No Children
    * Spinner Progress
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: CircularThrobber.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``enable_radius`` (bool):  [Read-Write]
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``image`` (SlateBrush):  [Read-Write] The throbber image.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``number_of_pieces`` (int32):  [Read-Write] How many pieces there are
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``period`` (float):  [Read-Write] The amount of time for a full circle (in seconds)
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``radius`` (float):  [Read-Write] The radius of the circle. If the throbber is a child of Canvas Panel, the 'Size to Content' option must be enabled in order to set Radius.
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def number_of_pieces(self) -> int:
        r"""
        (int32):  [Read-Write] How many pieces there are
        """
        ...
    @number_of_pieces.setter
    def number_of_pieces(self, value: int) -> None:
        ...
    @property
    def period(self) -> float:
        r"""
        (float):  [Read-Write] The amount of time for a full circle (in seconds)
        """
        ...
    @period.setter
    def period(self, value: float) -> None:
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write] The radius of the circle. If the throbber is a child of Canvas Panel, the 'Size to Content' option must be enabled in order to set Radius.
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The throbber image.
        """
        ...
    @image.setter
    def image(self, value: SlateBrush) -> None:
        ...
    def set_radius(self, radius: float) -> None:
        r"""
        x.set_radius(radius) -> None
        Sets the radius of the circle.
        
        Args:
            radius (float):
        """
        ...
    def set_period(self, period: float) -> None:
        r"""
        x.set_period(period) -> None
        Sets the amount of time for a full circle (in seconds).
        
        Args:
            period (float):
        """
        ...
    def set_number_of_pieces(self, number_of_pieces: int) -> None:
        r"""
        x.set_number_of_pieces(number_of_pieces) -> None
        Sets how many pieces there are.
        
        Args:
            number_of_pieces (int32):
        """
        ...

class ComboBox(Widget):
    r"""
    The combobox allows you to display a list of options to the user in a dropdown menu for them to select one.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ComboBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write]
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``items`` (Array[Object]):  [Read-Write] The list of items to be displayed on the combobox.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_generate_widget_event`` (GenerateWidgetForObject):  [Read-Write] Called when the widget is needed for the item.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``scroll_bar_style`` (ScrollBarStyle):  [Read-Write]
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def scroll_bar_style(self) -> ScrollBarStyle:
        r"""
        (ScrollBarStyle):  [Read-Write]
        """
        ...
    @scroll_bar_style.setter
    def scroll_bar_style(self, value: ScrollBarStyle) -> None:
        ...
    @property
    def items(self) -> Array[Object]:
        r"""
        (Array[Object]):  [Read-Write] The list of items to be displayed on the combobox.
        """
        ...
    @items.setter
    def items(self, value: Array[Object]) -> None:
        ...
    @property
    def is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class ComboBoxKey(Widget):
    r"""
    The combobox allows you to display a list of options to the user in a dropdown menu for them to select one.
    Use OnGenerateConentWidgetEvent to return a custom built widget.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ComboBoxKey.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``content_padding`` (Margin):  [Read-Write]
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``enable_gamepad_navigation_mode`` (bool):  [Read-Write] When false, directional keys will change the selection. When true, ComboBox
      must be activated and will only capture arrow input while activated.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``foreground_color`` (SlateColor):  [Read-Write] The foreground color to pass through the hierarchy.
    - ``has_down_arrow`` (bool):  [Read-Write] When false, the down arrow is not generated and it is up to the API consumer
      to make their own visual hint that this is a drop down.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] When true, allows the combo box to receive keyboard focus
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``item_style`` (TableRowStyle):  [Read-Write] The item row style.
    - ``max_list_height`` (float):  [Read-Write] The max height of the combobox list that opens
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_generate_content_widget`` (GenerateWidgetEvent):  [Read-Write] Called when the widget is needed for the content.
    - ``on_generate_item_widget`` (GenerateWidgetEvent):  [Read-Write] Called when the widget is needed for the item.
    - ``on_opening`` (OnOpeningEvent):  [Read-Write] Called when the combobox is opening
    - ``on_selection_changed`` (OnSelectionChangedEvent):  [Read-Write] Called when a new item is selected in the combobox.
    - ``options`` (Array[Name]):  [Read-Write]
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``scroll_bar_style`` (ScrollBarStyle):  [Read-Write] The scroll bar style.
    - ``selected_option`` (Name):  [Read-Write]
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ComboBoxStyle):  [Read-Write] The combobox style.
    """
    @property
    def widget_style(self) -> ComboBoxStyle:
        r"""
        (ComboBoxStyle):  [Read-Write] The combobox style.
        """
        ...
    @widget_style.setter
    def widget_style(self, value: ComboBoxStyle) -> None:
        ...
    @property
    def item_style(self) -> TableRowStyle:
        r"""
        (TableRowStyle):  [Read-Write] The item row style.
        """
        ...
    @item_style.setter
    def item_style(self, value: TableRowStyle) -> None:
        ...
    @property
    def scroll_bar_style(self) -> ScrollBarStyle:
        r"""
        (ScrollBarStyle):  [Read-Only] The scroll bar style.
        """
        ...
    @property
    def foreground_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Only] The foreground color to pass through the hierarchy.
        """
        ...
    @property
    def content_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @content_padding.setter
    def content_padding(self, value: Margin) -> None:
        ...
    @property
    def max_list_height(self) -> float:
        r"""
        (float):  [Read-Write] The max height of the combobox list that opens
        """
        ...
    @max_list_height.setter
    def max_list_height(self, value: float) -> None:
        ...
    @property
    def has_down_arrow(self) -> bool:
        r"""
        (bool):  [Read-Write] When false, the down arrow is not generated and it is up to the API consumer
        to make their own visual hint that this is a drop down.
        """
        ...
    @has_down_arrow.setter
    def has_down_arrow(self, value: bool) -> None:
        ...
    @property
    def enable_gamepad_navigation_mode(self) -> bool:
        r"""
        (bool):  [Read-Write] When false, directional keys will change the selection. When true, ComboBox
        must be activated and will only capture arrow input while activated.
        """
        ...
    @enable_gamepad_navigation_mode.setter
    def enable_gamepad_navigation_mode(self, value: bool) -> None:
        ...
    @property
    def is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Only] When true, allows the combo box to receive keyboard focus
        """
        ...
    @property
    def on_selection_changed(self) -> OnSelectionChangedEvent:
        r"""
        (OnSelectionChangedEvent):  [Read-Write] Called when a new item is selected in the combobox.
        """
        ...
    @on_selection_changed.setter
    def on_selection_changed(self, value: OnSelectionChangedEvent) -> None:
        ...
    @property
    def on_opening(self) -> OnOpeningEvent:
        r"""
        (OnOpeningEvent):  [Read-Write] Called when the combobox is opening
        """
        ...
    @on_opening.setter
    def on_opening(self, value: OnOpeningEvent) -> None:
        ...
    def set_selected_option(self, option: Name) -> None:
        r"""
        x.set_selected_option(option) -> None
        Set the current selected option.
        
        Args:
            option (Name):
        """
        ...
    def remove_option(self, option: Name) -> bool:
        r"""
        x.remove_option(option) -> bool
        Remove an element to the option list.
        
        Args:
            option (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_open(self) -> bool:
        r"""
        x.is_open() -> bool
        Is the combobox menu opened.
        
        Returns:
            bool:
        """
        ...
    def get_selected_option(self) -> Name:
        r"""
        x.get_selected_option() -> Name
        Get the current selected option
        
        Returns:
            Name:
        """
        ...
    def clear_selection(self) -> None:
        r"""
        x.clear_selection() -> None
        Clear the current selection.
        """
        ...
    def clear_options(self) -> None:
        r"""
        x.clear_options() -> None
        Remove all the elements of the option list.
        """
        ...
    def add_option(self, option: Name) -> None:
        r"""
        x.add_option(option) -> None
        Add an element to the option list.
        
        Args:
            option (Name):
        """
        ...

class ComboBoxString(Widget):
    r"""
    The combobox allows you to display a list of options to the user in a dropdown menu for them to select one.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ComboBoxString.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``content_padding`` (Margin):  [Read-Write]
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``default_options`` (Array[str]):  [Read-Write] The default list of items to be displayed on the combobox.
    - ``enable_gamepad_navigation_mode`` (bool):  [Read-Write] When false, directional keys will change the selection. When true, ComboBox
      must be activated and will only capture arrow input while activated.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``font`` (SlateFontInfo):  [Read-Write] The default font to use in the combobox, only applies if you're not implementing OnGenerateWidgetEvent
      to factory each new entry.
    - ``foreground_color`` (SlateColor):  [Read-Write] The foreground color to pass through the hierarchy.
    - ``has_down_arrow`` (bool):  [Read-Write] When false, the down arrow is not generated and it is up to the API consumer
      to make their own visual hint that this is a drop down.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write]
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``item_style`` (TableRowStyle):  [Read-Write] The item row style.
    - ``max_list_height`` (float):  [Read-Write] The max height of the combobox list that opens
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_generate_widget_event`` (GenerateWidgetForString):  [Read-Write] Called when the widget is needed for the item.
    - ``on_opening`` (OnOpeningEvent):  [Read-Write] Called when the combobox is opening
    - ``on_selection_changed`` (OnSelectionChangedEvent):  [Read-Write] Called when a new item is selected in the combobox.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``scroll_bar_style`` (ScrollBarStyle):  [Read-Write] The scroll bar style.
    - ``selected_option`` (str):  [Read-Write] The item in the combobox to select by default
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ComboBoxStyle):  [Read-Write] The style.
    """
    @property
    def widget_style(self) -> ComboBoxStyle:
        r"""
        (ComboBoxStyle):  [Read-Write] The style.
        """
        ...
    @widget_style.setter
    def widget_style(self, value: ComboBoxStyle) -> None:
        ...
    @property
    def item_style(self) -> TableRowStyle:
        r"""
        (TableRowStyle):  [Read-Write] The item row style.
        """
        ...
    @item_style.setter
    def item_style(self, value: TableRowStyle) -> None:
        ...
    @property
    def scroll_bar_style(self) -> ScrollBarStyle:
        r"""
        (ScrollBarStyle):  [Read-Only] The scroll bar style.
        """
        ...
    @property
    def content_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @content_padding.setter
    def content_padding(self, value: Margin) -> None:
        ...
    @property
    def max_list_height(self) -> float:
        r"""
        (float):  [Read-Write] The max height of the combobox list that opens
        """
        ...
    @max_list_height.setter
    def max_list_height(self, value: float) -> None:
        ...
    @property
    def has_down_arrow(self) -> bool:
        r"""
        (bool):  [Read-Write] When false, the down arrow is not generated and it is up to the API consumer
        to make their own visual hint that this is a drop down.
        """
        ...
    @has_down_arrow.setter
    def has_down_arrow(self, value: bool) -> None:
        ...
    @property
    def enable_gamepad_navigation_mode(self) -> bool:
        r"""
        (bool):  [Read-Write] When false, directional keys will change the selection. When true, ComboBox
        must be activated and will only capture arrow input while activated.
        """
        ...
    @enable_gamepad_navigation_mode.setter
    def enable_gamepad_navigation_mode(self, value: bool) -> None:
        ...
    @property
    def font(self) -> SlateFontInfo:
        r"""
        (SlateFontInfo):  [Read-Only] The default font to use in the combobox, only applies if you're not implementing OnGenerateWidgetEvent
        to factory each new entry.
        """
        ...
    @property
    def foreground_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Only] The foreground color to pass through the hierarchy.
        """
        ...
    @property
    def is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def on_selection_changed(self) -> OnSelectionChangedEvent:
        r"""
        (OnSelectionChangedEvent):  [Read-Write] Called when a new item is selected in the combobox.
        """
        ...
    @on_selection_changed.setter
    def on_selection_changed(self, value: OnSelectionChangedEvent) -> None:
        ...
    @property
    def on_opening(self) -> OnOpeningEvent:
        r"""
        (OnOpeningEvent):  [Read-Write] Called when the combobox is opening
        """
        ...
    @on_opening.setter
    def on_opening(self, value: OnOpeningEvent) -> None:
        ...
    def set_selected_option(self, option: str) -> None:
        r"""
        x.set_selected_option(option) -> None
        Set Selected Option
        
        Args:
            option (str):
        """
        ...
    def set_selected_index(self, index: int) -> None:
        r"""
        x.set_selected_index(index) -> None
        Set Selected Index
        
        Args:
            index (int32):
        """
        ...
    def remove_option(self, option: str) -> bool:
        r"""
        x.remove_option(option) -> bool
        Remove Option
        
        Args:
            option (str): 
        
        Returns:
            bool:
        """
        ...
    def refresh_options(self) -> None:
        r"""
        x.refresh_options() -> None
        Refreshes the list of options.  If you added new ones, and want to update the list even if it's
        currently being displayed use this.
        """
        ...
    def is_open(self) -> bool:
        r"""
        x.is_open() -> bool
        Is Open
        
        Returns:
            bool:
        """
        ...
    def get_selected_option(self) -> str:
        r"""
        x.get_selected_option() -> str
        Get Selected Option
        
        Returns:
            str:
        """
        ...
    def get_selected_index(self) -> int:
        r"""
        x.get_selected_index() -> int32
        Get Selected Index
        
        Returns:
            int32:
        """
        ...
    def get_option_count(self) -> int:
        r"""
        x.get_option_count() -> int32
        Returns the number of options
        
        Returns:
            int32:
        """
        ...
    def get_option_at_index(self, index: int) -> str:
        r"""
        x.get_option_at_index(index) -> str
        Get Option at Index
        
        Args:
            index (int32): 
        
        Returns:
            str:
        """
        ...
    def find_option_index(self, option: str) -> int:
        r"""
        x.find_option_index(option) -> int32
        Find Option Index
        
        Args:
            option (str): 
        
        Returns:
            int32:
        """
        ...
    def clear_selection(self) -> None:
        r"""
        x.clear_selection() -> None
        Clear Selection
        """
        ...
    def clear_options(self) -> None:
        r"""
        x.clear_options() -> None
        Clear Options
        """
        ...
    def add_option(self, option: str) -> None:
        r"""
        x.add_option(option) -> None
        Add Option
        
        Args:
            option (str):
        """
        ...

class DynamicEntryBoxBase(Widget):
    r"""
    Base for widgets that support a dynamic number of auto-generated entries at both design- and run-time.
    Contains all functionality needed to create, construct, and cache an arbitrary number of entry widgets, but exposes no means of entry creation or removal
    It's up to child classes to decide how they want to perform the population (some may do so entirely on their own without exposing a thing)
    see: UDynamicEntryBox for a ready-to-use version
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: DynamicEntryBoxBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``entry_box_type`` (DynamicBoxType):  [Read-Write] The type of box panel into which created entries are added. Some differences in functionality exist between each type.
    - ``entry_horizontal_alignment`` (HorizontalAlignment):  [Read-Write] Horizontal alignment of generated entries. Horizontal/Vertical/Wrap boxes only.
    - ``entry_size_rule`` (SlateChildSize):  [Read-Write] Sizing rule to apply to generated entries. Horizontal/Vertical boxes only.
    - ``entry_spacing`` (Vector2D):  [Read-Write] The padding to apply between entries in the box.
      Note horizontal boxes only use the X and vertical boxes only use Y. Value is also ignored for the first entry in the box.
      Wrap and Overlay types use both X and Y for spacing.
    - ``entry_vertical_alignment`` (VerticalAlignment):  [Read-Write] Vertical alignment of generated entries. Horizontal/Vertical/Wrap boxes only.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``max_element_size`` (int32):  [Read-Write] The maximum size of each entry in the dominant axis of the box. Vertical/Horizontal boxes only.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``radial_box_settings`` (RadialBoxSettings):  [Read-Write] Settings only relevant to RadialBox
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``spacing_pattern`` (Array[Vector2D]):  [Read-Write] The looping sequence of entry paddings to apply as entries are created. Overlay boxes only. Ignores EntrySpacing if not empty.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def entry_spacing(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The padding to apply between entries in the box.
        Note horizontal boxes only use the X and vertical boxes only use Y. Value is also ignored for the first entry in the box.
        Wrap and Overlay types use both X and Y for spacing.
        """
        ...
    @entry_spacing.setter
    def entry_spacing(self, value: Vector2D) -> None:
        ...
    @property
    def spacing_pattern(self) -> Array[Vector2D]:
        r"""
        (Array[Vector2D]):  [Read-Only] The looping sequence of entry paddings to apply as entries are created. Overlay boxes only. Ignores EntrySpacing if not empty.
        """
        ...
    @property
    def entry_box_type(self) -> DynamicBoxType:
        r"""
        (DynamicBoxType):  [Read-Only] The type of box panel into which created entries are added. Some differences in functionality exist between each type.
        """
        ...
    @property
    def entry_size_rule(self) -> SlateChildSize:
        r"""
        (SlateChildSize):  [Read-Only] Sizing rule to apply to generated entries. Horizontal/Vertical boxes only.
        """
        ...
    @property
    def entry_horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Only] Horizontal alignment of generated entries. Horizontal/Vertical/Wrap boxes only.
        """
        ...
    @property
    def entry_vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Only] Vertical alignment of generated entries. Horizontal/Vertical/Wrap boxes only.
        """
        ...
    @property
    def max_element_size(self) -> int:
        r"""
        (int32):  [Read-Only] The maximum size of each entry in the dominant axis of the box. Vertical/Horizontal boxes only.
        """
        ...
    @property
    def radial_box_settings(self) -> RadialBoxSettings:
        r"""
        (RadialBoxSettings):  [Read-Write] Settings only relevant to RadialBox
        """
        ...
    @radial_box_settings.setter
    def radial_box_settings(self, value: RadialBoxSettings) -> None:
        ...
    def set_radial_settings(self, settings: RadialBoxSettings) -> None:
        r"""
        x.set_radial_settings(settings) -> None
        Set Radial Settings
        
        Args:
            settings (RadialBoxSettings):
        """
        ...
    def set_entry_spacing(self, entry_spacing: Vector2D) -> None:
        r"""
        x.set_entry_spacing(entry_spacing) -> None
        Set Entry Spacing
        
        Args:
            entry_spacing (Vector2D):
        """
        ...
    def get_num_entries(self) -> int:
        r"""
        x.get_num_entries() -> int32
        Get Num Entries
        
        Returns:
            int32:
        """
        ...
    def get_all_entries(self) -> Array[UserWidget]:
        r"""
        x.get_all_entries() -> Array[UserWidget]
        Get All Entries
        
        Returns:
            Array[UserWidget]:
        """
        ...

class DynamicEntryBox(DynamicEntryBoxBase):
    r"""
    A special box panel that auto-generates its entries at both design-time and runtime.
    Useful for cases where you can have a varying number of entries, but it isn't worth the effort or conceptual overhead to set up a list/tile view.
    Note that entries here are *not* virtualized as they are in the list views, so generally this should be avoided if you intend to scroll through lots of items.
    
    No children can be manually added in the designer - all are auto-generated based on the given entry class.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: DynamicEntryBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``entry_box_type`` (DynamicBoxType):  [Read-Write] The type of box panel into which created entries are added. Some differences in functionality exist between each type.
    - ``entry_horizontal_alignment`` (HorizontalAlignment):  [Read-Write] Horizontal alignment of generated entries. Horizontal/Vertical/Wrap boxes only.
    - ``entry_size_rule`` (SlateChildSize):  [Read-Write] Sizing rule to apply to generated entries. Horizontal/Vertical boxes only.
    - ``entry_spacing`` (Vector2D):  [Read-Write] The padding to apply between entries in the box.
      Note horizontal boxes only use the X and vertical boxes only use Y. Value is also ignored for the first entry in the box.
      Wrap and Overlay types use both X and Y for spacing.
    - ``entry_vertical_alignment`` (VerticalAlignment):  [Read-Write] Vertical alignment of generated entries. Horizontal/Vertical/Wrap boxes only.
    - ``entry_widget_class`` (type(Class)):  [Read-Write] The class of widget to create entries of.
      If natively binding this widget, use the EntryClass UPROPERTY metadata to specify the desired entry widget base class.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``max_element_size`` (int32):  [Read-Write] The maximum size of each entry in the dominant axis of the box. Vertical/Horizontal boxes only.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``num_designer_preview_entries`` (int32):  [Read-Write]
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``radial_box_settings`` (RadialBoxSettings):  [Read-Write] Settings only relevant to RadialBox
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``spacing_pattern`` (Array[Vector2D]):  [Read-Write] The looping sequence of entry paddings to apply as entries are created. Overlay boxes only. Ignores EntrySpacing if not empty.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def entry_widget_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] The class of widget to create entries of.
        If natively binding this widget, use the EntryClass UPROPERTY metadata to specify the desired entry widget base class.
        """
        ...
    def reset(self, delete_widgets: bool = False) -> None:
        r"""
        x.reset(delete_widgets=False) -> None
        Clear out the box entries, optionally deleting the underlying Slate widgets entirely as well.
        
        Args:
            delete_widgets (bool):
        """
        ...
    def remove_entry(self, entry_widget: UserWidget) -> None:
        r"""
        x.remove_entry(entry_widget) -> None
        Remove Entry
        
        Args:
            entry_widget (UserWidget):
        """
        ...
    def bp_create_entry_of_class(self, entry_class: Class) -> UserWidget:
        r"""
        x.bp_create_entry_of_class(entry_class) -> UserWidget
        Creates and establishes a new dynamic entry in the box using the specified class instead of the default.
        
        Args:
            entry_class (type(Class)): 
        
        Returns:
            UserWidget:
        """
        ...
    def bp_create_entry(self) -> UserWidget:
        r"""
        x.bp_create_entry() -> UserWidget
        Creates and establishes a new dynamic entry in the box
        
        Returns:
            UserWidget:
        """
        ...

class EditableText(Widget):
    r"""
    Editable text box widget
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: EditableText.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_context_menu`` (bool):  [Read-Write] Whether the context menu can be opened
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_keyboard_focus_on_commit`` (bool):  [Read-Write] Whether to clear keyboard focus when pressing enter to commit changes
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hint_text`` (Text):  [Read-Write] Hint text that appears when there is no text in the text box
    - ``is_caret_moved_when_gain_focus`` (bool):  [Read-Write] When set to true the caret is moved when gaining focus
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_password`` (bool):  [Read-Write] Sets whether this text box is for storing a password
    - ``is_read_only`` (bool):  [Read-Write] Sets whether this text box can actually be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] How the text should be aligned with the margin.
    - ``keyboard_type`` (VirtualKeyboardType):  [Read-Write] If we're on a platform that requires a virtual keyboard, what kind of keyboard should this widget use?
    - ``minimum_desired_width`` (float):  [Read-Write] The minimum desired Width for the text
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_text_changed`` (OnEditableTextChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
    - ``on_text_committed`` (OnEditableTextCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
    - ``overflow_policy`` (TextOverflowPolicy):  [Read-Write] Sets what happens to text that is clipped and doesn't fit within the clip rect for this widget
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``revert_text_on_escape`` (bool):  [Read-Write] Whether to allow the user to back out of changes when they press the escape key
    - ``select_all_text_on_commit`` (bool):  [Read-Write] Whether to select all text when pressing enter to commit changes
    - ``select_all_text_when_focused`` (bool):  [Read-Write] Whether to select all text when the user clicks to give focus on the widget
    - ``shaped_text_options`` (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text`` (Text):  [Read-Write] The text content for this editable text box widget
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``virtual_keyboard_dismiss_action`` (VirtualKeyboardDismissAction):  [Read-Write] What action should be taken when the virtual keyboard is dismissed?
    - ``virtual_keyboard_options`` (VirtualKeyboardOptions):  [Read-Write] Additional options for the virtual keyboard
    - ``virtual_keyboard_trigger`` (VirtualKeyboardTrigger):  [Read-Write]
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (EditableTextStyle):  [Read-Write] The style
    """
    @property
    def text(self) -> Text:
        r"""
        (Text):  [Read-Write] The text content for this editable text box widget
        """
        ...
    @text.setter
    def text(self, value: Text) -> None:
        ...
    @property
    def hint_text(self) -> Text:
        r"""
        (Text):  [Read-Write] Hint text that appears when there is no text in the text box
        """
        ...
    @hint_text.setter
    def hint_text(self, value: Text) -> None:
        ...
    @property
    def widget_style(self) -> EditableTextStyle:
        r"""
        (EditableTextStyle):  [Read-Write] The style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: EditableTextStyle) -> None:
        ...
    @property
    def is_read_only(self) -> bool:
        r"""
        (bool):  [Read-Write] Sets whether this text box can actually be modified interactively by the user
        """
        ...
    @is_read_only.setter
    def is_read_only(self, value: bool) -> None:
        ...
    @property
    def is_password(self) -> bool:
        r"""
        (bool):  [Read-Write] Sets whether this text box is for storing a password
        """
        ...
    @is_password.setter
    def is_password(self, value: bool) -> None:
        ...
    @property
    def minimum_desired_width(self) -> float:
        r"""
        (float):  [Read-Write] The minimum desired Width for the text
        """
        ...
    @minimum_desired_width.setter
    def minimum_desired_width(self, value: float) -> None:
        ...
    @property
    def is_caret_moved_when_gain_focus(self) -> bool:
        r"""
        (bool):  [Read-Write] When set to true the caret is moved when gaining focus
        """
        ...
    @is_caret_moved_when_gain_focus.setter
    def is_caret_moved_when_gain_focus(self, value: bool) -> None:
        ...
    @property
    def select_all_text_when_focused(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to select all text when the user clicks to give focus on the widget
        """
        ...
    @select_all_text_when_focused.setter
    def select_all_text_when_focused(self, value: bool) -> None:
        ...
    @property
    def revert_text_on_escape(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to allow the user to back out of changes when they press the escape key
        """
        ...
    @revert_text_on_escape.setter
    def revert_text_on_escape(self, value: bool) -> None:
        ...
    @property
    def clear_keyboard_focus_on_commit(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to clear keyboard focus when pressing enter to commit changes
        """
        ...
    @clear_keyboard_focus_on_commit.setter
    def clear_keyboard_focus_on_commit(self, value: bool) -> None:
        ...
    @property
    def select_all_text_on_commit(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to select all text when pressing enter to commit changes
        """
        ...
    @select_all_text_on_commit.setter
    def select_all_text_on_commit(self, value: bool) -> None:
        ...
    @property
    def justification(self) -> TextJustify:
        r"""
        (TextJustify):  [Read-Write] How the text should be aligned with the margin.
        """
        ...
    @justification.setter
    def justification(self, value: TextJustify) -> None:
        ...
    @property
    def overflow_policy(self) -> TextOverflowPolicy:
        r"""
        (TextOverflowPolicy):  [Read-Write] Sets what happens to text that is clipped and doesn't fit within the clip rect for this widget
        """
        ...
    @overflow_policy.setter
    def overflow_policy(self, value: TextOverflowPolicy) -> None:
        ...
    @property
    def shaped_text_options(self) -> ShapedTextOptions:
        r"""
        (ShapedTextOptions):  [Read-Only] Controls how the text within this widget should be shaped.
        """
        ...
    @property
    def on_text_changed(self) -> OnEditableTextChangedEvent:
        r"""
        (OnEditableTextChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
        """
        ...
    @on_text_changed.setter
    def on_text_changed(self, value: OnEditableTextChangedEvent) -> None:
        ...
    @property
    def on_text_committed(self) -> OnEditableTextCommittedEvent:
        r"""
        (OnEditableTextCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
        """
        ...
    @on_text_committed.setter
    def on_text_committed(self, value: OnEditableTextCommittedEvent) -> None:
        ...
    def set_text(self, text: Text) -> None:
        r"""
        x.set_text(text) -> None
        Directly sets the widget text.
        Warning: This will wipe any binding created for the Text property!
        
        Args:
            text (Text): The text to assign to the widget
        """
        ...
    def set_minimum_desired_width(self, min_desired_width: float) -> None:
        r"""
        x.set_minimum_desired_width(min_desired_width) -> None
        Set the minimum desired width for this text box
        
        Args:
            min_desired_width (float): new minimum desired width
        """
        ...
    def set_is_read_only(self, inb_is_ready_only: bool) -> None:
        r"""
        x.set_is_read_only(inb_is_ready_only) -> None
        Set Is Read Only
        
        Args:
            inb_is_ready_only (bool):
        """
        ...
    def set_is_password(self, inb_is_password: bool) -> None:
        r"""
        x.set_is_password(inb_is_password) -> None
        Set Is Password
        
        Args:
            inb_is_password (bool):
        """
        ...
    def set_hint_text(self, hint_text: Text) -> None:
        r"""
        x.set_hint_text(hint_text) -> None
        Set Hint Text
        
        Args:
            hint_text (Text):
        """
        ...
    def set_font_outline_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_font_outline_material(material) -> None
        Set Font Outline Material
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_font_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_font_material(material) -> None
        Set Font Material
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_font(self, font_info: SlateFontInfo) -> None:
        r"""
        x.set_font(font_info) -> None
        Set Font
        
        Args:
            font_info (SlateFontInfo):
        """
        ...
    def get_text(self) -> Text:
        r"""
        x.get_text() -> Text
        Gets the widget text
        
        Returns:
            Text: The widget text
        """
        ...
    def get_justification(self) -> TextJustify:
        r"""
        x.get_justification() -> TextJustify
        Get Justification
        
        Returns:
            TextJustify:
        """
        ...
    def get_hint_text(self) -> Text:
        r"""
        x.get_hint_text() -> Text
        Gets the Hint text that appears when there is no text in the text box
        
        Returns:
            Text:
        """
        ...
    def get_font(self) -> SlateFontInfo:
        r"""
        x.get_font() -> SlateFontInfo
        Get Font
        
        Returns:
            SlateFontInfo:
        """
        ...

class EditableTextBox(Widget):
    r"""
    Allows the user to type in custom text.  Only permits a single line of text to be entered.
    
    * No Children
    * Text Entry
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: EditableTextBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_context_menu`` (bool):  [Read-Write] Whether the context menu can be opened
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_keyboard_focus_on_commit`` (bool):  [Read-Write] Whether to clear keyboard focus when pressing enter to commit changes
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hint_text`` (Text):  [Read-Write] Hint text that appears when there is no text in the text box
    - ``is_caret_moved_when_gain_focus`` (bool):  [Read-Write] Workaround as we lose focus when the auto completion closes.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_password`` (bool):  [Read-Write] Sets whether this text box is for storing a password
    - ``is_read_only`` (bool):  [Read-Write] Sets the Text Box as Readonly to prevent it from being modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] How the text should be aligned with the margin.
    - ``keyboard_type`` (VirtualKeyboardType):  [Read-Write] If we're on a platform that requires a virtual keyboard, what kind of keyboard should this widget use?
    - ``minimum_desired_width`` (float):  [Read-Write] The minimum desired size for the text
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_text_changed`` (OnEditableTextBoxChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
    - ``on_text_committed`` (OnEditableTextBoxCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
    - ``overflow_policy`` (TextOverflowPolicy):  [Read-Write] Sets what happens to text that is clipped and doesn't fit within the clip rect for this widget
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``revert_text_on_escape`` (bool):  [Read-Write] Whether to allow the user to back out of changes when they press the escape key
    - ``select_all_text_on_commit`` (bool):  [Read-Write] Whether to select all text when pressing enter to commit changes
    - ``select_all_text_when_focused`` (bool):  [Read-Write] Whether to select all text when the user clicks to give focus on the widget
    - ``shaped_text_options`` (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text`` (Text):  [Read-Write] The text content for this editable text box widget
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``virtual_keyboard_dismiss_action`` (VirtualKeyboardDismissAction):  [Read-Write] What action should be taken when the virtual keyboard is dismissed?
    - ``virtual_keyboard_options`` (VirtualKeyboardOptions):  [Read-Write] Additional options to use for the virtual keyboard summoned by this widget
    - ``virtual_keyboard_trigger`` (VirtualKeyboardTrigger):  [Read-Write] The type of event that will trigger the display of the virtual keyboard
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (EditableTextBoxStyle):  [Read-Write] The style
    """
    @property
    def text(self) -> Text:
        r"""
        (Text):  [Read-Write] The text content for this editable text box widget
        """
        ...
    @text.setter
    def text(self, value: Text) -> None:
        ...
    @property
    def widget_style(self) -> EditableTextBoxStyle:
        r"""
        (EditableTextBoxStyle):  [Read-Write] The style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: EditableTextBoxStyle) -> None:
        ...
    @property
    def hint_text(self) -> Text:
        r"""
        (Text):  [Read-Write] Hint text that appears when there is no text in the text box
        """
        ...
    @hint_text.setter
    def hint_text(self, value: Text) -> None:
        ...
    @property
    def is_read_only(self) -> bool:
        r"""
        (bool):  [Read-Write] Sets the Text Box as Readonly to prevent it from being modified interactively by the user
        """
        ...
    @is_read_only.setter
    def is_read_only(self, value: bool) -> None:
        ...
    @property
    def is_password(self) -> bool:
        r"""
        (bool):  [Read-Write] Sets whether this text box is for storing a password
        """
        ...
    @is_password.setter
    def is_password(self, value: bool) -> None:
        ...
    @property
    def minimum_desired_width(self) -> float:
        r"""
        (float):  [Read-Write] The minimum desired size for the text
        """
        ...
    @minimum_desired_width.setter
    def minimum_desired_width(self, value: float) -> None:
        ...
    @property
    def is_caret_moved_when_gain_focus(self) -> bool:
        r"""
        (bool):  [Read-Write] Workaround as we lose focus when the auto completion closes.
        """
        ...
    @is_caret_moved_when_gain_focus.setter
    def is_caret_moved_when_gain_focus(self, value: bool) -> None:
        ...
    @property
    def select_all_text_when_focused(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to select all text when the user clicks to give focus on the widget
        """
        ...
    @select_all_text_when_focused.setter
    def select_all_text_when_focused(self, value: bool) -> None:
        ...
    @property
    def revert_text_on_escape(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to allow the user to back out of changes when they press the escape key
        """
        ...
    @revert_text_on_escape.setter
    def revert_text_on_escape(self, value: bool) -> None:
        ...
    @property
    def clear_keyboard_focus_on_commit(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to clear keyboard focus when pressing enter to commit changes
        """
        ...
    @clear_keyboard_focus_on_commit.setter
    def clear_keyboard_focus_on_commit(self, value: bool) -> None:
        ...
    @property
    def select_all_text_on_commit(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to select all text when pressing enter to commit changes
        """
        ...
    @select_all_text_on_commit.setter
    def select_all_text_on_commit(self, value: bool) -> None:
        ...
    @property
    def justification(self) -> TextJustify:
        r"""
        (TextJustify):  [Read-Write] How the text should be aligned with the margin.
        """
        ...
    @justification.setter
    def justification(self, value: TextJustify) -> None:
        ...
    @property
    def overflow_policy(self) -> TextOverflowPolicy:
        r"""
        (TextOverflowPolicy):  [Read-Write] Sets what happens to text that is clipped and doesn't fit within the clip rect for this widget
        """
        ...
    @overflow_policy.setter
    def overflow_policy(self, value: TextOverflowPolicy) -> None:
        ...
    @property
    def shaped_text_options(self) -> ShapedTextOptions:
        r"""
        (ShapedTextOptions):  [Read-Only] Controls how the text within this widget should be shaped.
        """
        ...
    @property
    def on_text_changed(self) -> OnEditableTextBoxChangedEvent:
        r"""
        (OnEditableTextBoxChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
        """
        ...
    @on_text_changed.setter
    def on_text_changed(self, value: OnEditableTextBoxChangedEvent) -> None:
        ...
    @property
    def on_text_committed(self) -> OnEditableTextBoxCommittedEvent:
        r"""
        (OnEditableTextBoxCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
        """
        ...
    @on_text_committed.setter
    def on_text_committed(self, value: OnEditableTextBoxCommittedEvent) -> None:
        ...
    def set_text(self, text: Text) -> None:
        r"""
        x.set_text(text) -> None
        Directly sets the widget text.
        Warning: This will wipe any binding created for the Text property!
        
        Args:
            text (Text): The text to assign to the widget
        """
        ...
    def set_is_read_only(self, read_only: bool) -> None:
        r"""
        x.set_is_read_only(read_only) -> None
        Sets the Text as Readonly to prevent it from being modified interactively by the user
        
        Args:
            read_only (bool):
        """
        ...
    def set_is_password(self, is_password: bool) -> None:
        r"""
        x.set_is_password(is_password) -> None
        Set Is Password
        
        Args:
            is_password (bool):
        """
        ...
    def set_hint_text(self, text: Text) -> None:
        r"""
        x.set_hint_text(text) -> None
        Sets the Hint text that appears when there is no text in the text box
        
        Args:
            text (Text):
        """
        ...
    def set_foreground_color(self, color: LinearColor) -> None:
        r"""
        x.set_foreground_color(color) -> None
        Set Foreground Color
        
        Args:
            color (LinearColor):
        """
        ...
    def set_error(self, error: Text) -> None:
        r"""
        x.set_error(error) -> None
        Set Error
        
        Args:
            error (Text):
        """
        ...
    def has_error(self) -> bool:
        r"""
        x.has_error() -> bool
        Has Error
        
        Returns:
            bool:
        """
        ...
    def get_text(self) -> Text:
        r"""
        x.get_text() -> Text
        Gets the widget text
        
        Returns:
            Text: The widget text
        """
        ...
    def clear_error(self) -> None:
        r"""
        x.clear_error() -> None
        Clear Error
        """
        ...

class ExpandableArea(Widget):
    r"""
    Expandable Area
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ExpandableArea.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``area_padding`` (Margin):  [Read-Write]
    - ``border_brush`` (SlateBrush):  [Read-Write]
    - ``border_color`` (SlateColor):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``header_padding`` (Margin):  [Read-Write]
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_expanded`` (bool):  [Read-Write]
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``max_height`` (float):  [Read-Write] The maximum height of the area
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_expansion_changed`` (OnExpandableAreaExpansionChanged):  [Read-Write] A bindable delegate for the IsChecked.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``style`` (ExpandableAreaStyle):  [Read-Write]
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def border_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write]
        """
        ...
    @border_brush.setter
    def border_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def border_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @border_color.setter
    def border_color(self, value: SlateColor) -> None:
        ...
    @property
    def is_expanded(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_expanded.setter
    def is_expanded(self, value: bool) -> None:
        ...
    @property
    def max_height(self) -> float:
        r"""
        (float):  [Read-Write] The maximum height of the area
        """
        ...
    @max_height.setter
    def max_height(self, value: float) -> None:
        ...
    @property
    def header_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @header_padding.setter
    def header_padding(self, value: Margin) -> None:
        ...
    @property
    def area_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @area_padding.setter
    def area_padding(self, value: Margin) -> None:
        ...
    @property
    def on_expansion_changed(self) -> OnExpandableAreaExpansionChanged:
        r"""
        (OnExpandableAreaExpansionChanged):  [Read-Write] A bindable delegate for the IsChecked.
        """
        ...
    @on_expansion_changed.setter
    def on_expansion_changed(self, value: OnExpandableAreaExpansionChanged) -> None:
        ...
    def set_is_expanded_animated(self, is_expanded: bool) -> None:
        r"""
        x.set_is_expanded_animated(is_expanded) -> None
        Set Is Expanded Animated
        
        Args:
            is_expanded (bool):
        """
        ...
    def set_is_expanded(self, is_expanded: bool) -> None:
        r"""
        x.set_is_expanded(is_expanded) -> None
        Set Is Expanded
        
        Args:
            is_expanded (bool):
        """
        ...
    def get_is_expanded(self) -> bool:
        r"""
        x.get_is_expanded() -> bool
        Get Is Expanded
        
        Returns:
            bool:
        """
        ...

class GridPanel(PanelWidget):
    r"""
    A table-like panel that retains the width of every column throughout the table.
    
    * Many Children
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: GridPanel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``column_fill`` (Array[float]):  [Read-Write] The column fill rules
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``row_fill`` (Array[float]):  [Read-Write] The row fill rules
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def column_fill(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Only] The column fill rules
        """
        ...
    @property
    def row_fill(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Only] The row fill rules
        """
        ...
    def set_row_fill(self, row_index: int, coefficient: float) -> None:
        r"""
        x.set_row_fill(row_index, coefficient) -> None
        Set Row Fill
        
        Args:
            row_index (int32): 
            coefficient (float):
        """
        ...
    def set_column_fill(self, column_index: int, coefficient: float) -> None:
        r"""
        x.set_column_fill(column_index, coefficient) -> None
        Set Column Fill
        
        Args:
            column_index (int32): 
            coefficient (float):
        """
        ...
    def add_child_to_grid(self, content: Widget, row: int = 0, column: int = 0) -> GridSlot:
        r"""
        x.add_child_to_grid(content, row=0, column=0) -> GridSlot
        Add Child to Grid
        
        Args:
            content (Widget): 
            row (int32): 
            column (int32): 
        
        Returns:
            GridSlot:
        """
        ...

class GridSlot(PanelSlot):
    r"""
    A slot for UGridPanel, these slots all share the same size as the largest slot
    in the grid.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: GridSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``column`` (int32):  [Read-Write] The column index of the cell this slot is in
    - ``column_span`` (int32):  [Read-Write]
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``layer`` (int32):  [Read-Write] Positive values offset this cell to be hit-tested and drawn on top of others. Default is 0; i.e. no offset.
    - ``nudge`` (Vector2D):  [Read-Write] Offset this slot's content by some amount; positive values offset to lower right
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``row`` (int32):  [Read-Write] The row index of the cell this slot is in
    - ``row_span`` (int32):  [Read-Write]
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    @property
    def row(self) -> int:
        r"""
        (int32):  [Read-Write] The row index of the cell this slot is in
        """
        ...
    @row.setter
    def row(self, value: int) -> None:
        ...
    @property
    def row_span(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @row_span.setter
    def row_span(self, value: int) -> None:
        ...
    @property
    def column(self) -> int:
        r"""
        (int32):  [Read-Write] The column index of the cell this slot is in
        """
        ...
    @column.setter
    def column(self, value: int) -> None:
        ...
    @property
    def column_span(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @column_span.setter
    def column_span(self, value: int) -> None:
        ...
    @property
    def layer(self) -> int:
        r"""
        (int32):  [Read-Write] Positive values offset this cell to be hit-tested and drawn on top of others. Default is 0; i.e. no offset.
        """
        ...
    @layer.setter
    def layer(self, value: int) -> None:
        ...
    @property
    def nudge(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Offset this slot's content by some amount; positive values offset to lower right
        """
        ...
    @nudge.setter
    def nudge(self, value: Vector2D) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_row_span(self, row_span: int) -> None:
        r"""
        x.set_row_span(row_span) -> None
        How many rows this this slot spans over
        
        Args:
            row_span (int32):
        """
        ...
    def set_row(self, row: int) -> None:
        r"""
        x.set_row(row) -> None
        Sets the row index of the slot, this determines what cell the slot is in the panel
        
        Args:
            row (int32):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_nudge(self, nudge: Vector2D) -> None:
        r"""
        x.set_nudge(nudge) -> None
        Sets the offset for this slot's content by some amount; positive values offset to lower right
        
        Args:
            nudge (Vector2D):
        """
        ...
    def set_layer(self, layer: int) -> None:
        r"""
        x.set_layer(layer) -> None
        Sets positive values offset this cell to be hit-tested and drawn on top of others.
        
        Args:
            layer (int32):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...
    def set_column_span(self, column_span: int) -> None:
        r"""
        x.set_column_span(column_span) -> None
        How many columns this slot spans over
        
        Args:
            column_span (int32):
        """
        ...
    def set_column(self, column: int) -> None:
        r"""
        x.set_column(column) -> None
        Sets the column index of the slot, this determines what cell the slot is in the panel
        
        Args:
            column (int32):
        """
        ...

class HorizontalBox(PanelWidget):
    r"""
    Allows widgets to be laid out in a flow horizontally.
    
    * Many Children
    * Flow Horizontal
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: HorizontalBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    def add_child_to_horizontal_box(self, content: Widget) -> HorizontalBoxSlot:
        r"""
        x.add_child_to_horizontal_box(content) -> HorizontalBoxSlot
        Add Child to Horizontal Box
        
        Args:
            content (Widget): 
        
        Returns:
            HorizontalBoxSlot:
        """
        ...

class HorizontalBoxSlot(PanelSlot):
    r"""
    Horizontal Box Slot
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: HorizontalBoxSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write]
    - ``padding`` (Margin):  [Read-Write] The amount of padding between the slots parent and the content.
    - ``size`` (SlateChildSize):  [Read-Write] How much space this slot should occupy in the direction of the panel.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write]
    """
    @property
    def size(self) -> SlateChildSize:
        r"""
        (SlateChildSize):  [Read-Write] How much space this slot should occupy in the direction of the panel.
        """
        ...
    @size.setter
    def size(self, value: SlateChildSize) -> None:
        ...
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The amount of padding between the slots parent and the content.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write]
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write]
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_size(self, size: SlateChildSize) -> None:
        r"""
        x.set_size(size) -> None
        Set Size
        
        Args:
            size (SlateChildSize):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class Image(Widget):
    r"""
    The image widget allows you to display a Slate Brush, or texture or material in the UI.
    
    * No Children
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Image.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``brush`` (SlateBrush):  [Read-Write] Image to draw
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``color_and_opacity`` (LinearColor):  [Read-Write] Color and opacity
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flip_for_right_to_left_flow_direction`` (bool):  [Read-Write] Flips the image if the localization's flow direction is RightToLeft
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_mouse_button_down_event`` (OnPointerEvent):  [Read-Write]
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] Image to draw
        """
        ...
    @brush.setter
    def brush(self, value: SlateBrush) -> None:
        ...
    @property
    def color_and_opacity(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Color and opacity
        """
        ...
    @color_and_opacity.setter
    def color_and_opacity(self, value: LinearColor) -> None:
        ...
    @property
    def flip_for_right_to_left_flow_direction(self) -> bool:
        r"""
        (bool):  [Read-Write] Flips the image if the localization's flow direction is RightToLeft
        """
        ...
    @flip_for_right_to_left_flow_direction.setter
    def flip_for_right_to_left_flow_direction(self, value: bool) -> None:
        ...
    def set_opacity(self, opacity: float) -> None:
        r"""
        x.set_opacity(opacity) -> None
        Set Opacity
        
        Args:
            opacity (float):
        """
        ...
    def set_desired_size_override(self, desired_size: Vector2D) -> None:
        r"""
        x.set_desired_size_override(desired_size) -> None
        Set Desired Size Override
        
        Args:
            desired_size (Vector2D):
        """
        ...
    def set_brush_size(self, desired_size: Vector2D) -> None:
        r"""
        deprecated: 'set_brush_size' was renamed to 'set_desired_size_override'.
        """
        ...
    def set_color_and_opacity(self, color_and_opacity: LinearColor) -> None:
        r"""
        x.set_color_and_opacity(color_and_opacity) -> None
        Set Color and Opacity
        
        Args:
            color_and_opacity (LinearColor):
        """
        ...
    def set_brush_tint_color(self, tint_color: SlateColor) -> None:
        r"""
        x.set_brush_tint_color(tint_color) -> None
        Set Brush Tint Color
        
        Args:
            tint_color (SlateColor):
        """
        ...
    def set_brush_resource_object(self, resource_object: Object) -> None:
        r"""
        x.set_brush_resource_object(resource_object) -> None
        Set Brush Resource Object
        
        Args:
            resource_object (Object):
        """
        ...
    def set_brush_from_texture_dynamic(self, texture: Texture2DDynamic, match_size: bool = False) -> None:
        r"""
        x.set_brush_from_texture_dynamic(texture, match_size=False) -> None
        Sets the Brush to the specified Dynamic Texture.
        
        Args:
            texture (Texture2DDynamic): Dynamic Texture to use to set on Brush.
            match_size (bool): If true, image will change its size to texture size. If false, texture will be stretched to image size.
        """
        ...
    def set_brush_from_texture(self, texture: Texture2D, match_size: bool = False) -> None:
        r"""
        x.set_brush_from_texture(texture, match_size=False) -> None
        Sets the Brush to the specified Texture.
        
        Args:
            texture (Texture2D): Texture to use to set on Brush.
            match_size (bool): If true, image will change its size to texture size. If false, texture will be stretched to image size.
        """
        ...
    def set_brush_from_soft_texture(self, soft_texture: Texture2D, match_size: bool = False) -> None:
        r"""
        x.set_brush_from_soft_texture(soft_texture, match_size=False) -> None
        Sets the Brush to the specified Soft Texture.
        
        Args:
            soft_texture (Texture2D): Soft Texture to use to set on Brush.
            match_size (bool): If true, image will change its size to texture size. If false, texture will be stretched to image size.
        """
        ...
    def set_brush_from_soft_material(self, soft_material: MaterialInterface) -> None:
        r"""
        x.set_brush_from_soft_material(soft_material) -> None
        Set Brush from Soft Material
        
        Args:
            soft_material (MaterialInterface):
        """
        ...
    def set_brush_from_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_brush_from_material(material) -> None
        Set Brush from Material
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_brush_from_atlas_interface(self, atlas_region: SlateTextureAtlasInterface, match_size: bool = False) -> None:
        r"""
        x.set_brush_from_atlas_interface(atlas_region, match_size=False) -> None
        Sets the Brush to the specified Atlas Region.
        
        Args:
            atlas_region (SlateTextureAtlasInterface): Region of the Atlas to use to set on Brush.
            match_size (bool): If true, image will change its size to atlas region size. If false, atlas region will be stretched to image size.
        """
        ...
    def set_brush_from_asset(self, asset: SlateBrushAsset) -> None:
        r"""
        x.set_brush_from_asset(asset) -> None
        Set Brush from Asset
        
        Args:
            asset (SlateBrushAsset):
        """
        ...
    def set_brush(self, brush: SlateBrush) -> None:
        r"""
        x.set_brush(brush) -> None
        Set Brush
        
        Args:
            brush (SlateBrush):
        """
        ...
    def get_dynamic_material(self) -> MaterialInstanceDynamic:
        r"""
        x.get_dynamic_material() -> MaterialInstanceDynamic
        Get Dynamic Material
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...

class InputKeySelector(Widget):
    r"""
    A widget for selecting a single key or a single key with a modifier.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: InputKeySelector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_gamepad_keys`` (bool):  [Read-Write] When true gamepad keys are allowed in the input chord representing the selected key, otherwise they are ignored.
    - ``allow_modifier_keys`` (bool):  [Read-Write] When true modifier keys such as control and alt are allowed in the
      input chord representing the selected key, if false modifier keys are ignored.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``escape_keys`` (Array[Key]):  [Read-Write] When true gamepad keys are allowed in the input chord representing the selected key, otherwise they are ignored.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``key_selection_text`` (Text):  [Read-Write] Sets the text which is displayed while selecting keys.
    - ``margin`` (Margin):  [Read-Write] The amount of blank space around the text used to display the currently selected key.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``no_key_specified_text`` (Text):  [Read-Write] Sets the text to display when no key text is available or not selecting a key.
    - ``on_is_selecting_key_changed`` (OnIsSelectingKeyChanged):  [Read-Write] Called whenever the key selection mode starts or stops.
    - ``on_key_selected`` (OnKeySelected):  [Read-Write] Called whenever a new key is selected by the user.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``selected_key`` (InputChord):  [Read-Write] The currently selected key chord.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text_style`` (TextBlockStyle):  [Read-Write] The button style used at runtime
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ButtonStyle):  [Read-Write] The button style used at runtime
    """
    @property
    def widget_style(self) -> ButtonStyle:
        r"""
        (ButtonStyle):  [Read-Write] The button style used at runtime
        """
        ...
    @widget_style.setter
    def widget_style(self, value: ButtonStyle) -> None:
        ...
    @property
    def text_style(self) -> TextBlockStyle:
        r"""
        (TextBlockStyle):  [Read-Write] The button style used at runtime
        """
        ...
    @text_style.setter
    def text_style(self, value: TextBlockStyle) -> None:
        ...
    @property
    def selected_key(self) -> InputChord:
        r"""
        (InputChord):  [Read-Write] The currently selected key chord.
        """
        ...
    @selected_key.setter
    def selected_key(self, value: InputChord) -> None:
        ...
    @property
    def margin(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The amount of blank space around the text used to display the currently selected key.
        """
        ...
    @margin.setter
    def margin(self, value: Margin) -> None:
        ...
    @property
    def key_selection_text(self) -> Text:
        r"""
        (Text):  [Read-Write] Sets the text which is displayed while selecting keys.
        """
        ...
    @key_selection_text.setter
    def key_selection_text(self, value: Text) -> None:
        ...
    @property
    def no_key_specified_text(self) -> Text:
        r"""
        (Text):  [Read-Write] Sets the text to display when no key text is available or not selecting a key.
        """
        ...
    @no_key_specified_text.setter
    def no_key_specified_text(self, value: Text) -> None:
        ...
    @property
    def allow_modifier_keys(self) -> bool:
        r"""
        (bool):  [Read-Write] When true modifier keys such as control and alt are allowed in the
        input chord representing the selected key, if false modifier keys are ignored.
        """
        ...
    @allow_modifier_keys.setter
    def allow_modifier_keys(self, value: bool) -> None:
        ...
    @property
    def allow_gamepad_keys(self) -> bool:
        r"""
        (bool):  [Read-Write] When true gamepad keys are allowed in the input chord representing the selected key, otherwise they are ignored.
        """
        ...
    @allow_gamepad_keys.setter
    def allow_gamepad_keys(self, value: bool) -> None:
        ...
    @property
    def escape_keys(self) -> Array[Key]:
        r"""
        (Array[Key]):  [Read-Only] When true gamepad keys are allowed in the input chord representing the selected key, otherwise they are ignored.
        """
        ...
    @property
    def on_key_selected(self) -> OnKeySelected:
        r"""
        (OnKeySelected):  [Read-Write] Called whenever a new key is selected by the user.
        """
        ...
    @on_key_selected.setter
    def on_key_selected(self, value: OnKeySelected) -> None:
        ...
    @property
    def on_is_selecting_key_changed(self) -> OnIsSelectingKeyChanged:
        r"""
        (OnIsSelectingKeyChanged):  [Read-Write] Called whenever the key selection mode starts or stops.
        """
        ...
    @on_is_selecting_key_changed.setter
    def on_is_selecting_key_changed(self, value: OnIsSelectingKeyChanged) -> None:
        ...
    def set_text_block_visibility(self, visibility: SlateVisibility) -> None:
        r"""
        x.set_text_block_visibility(visibility) -> None
        Sets the visibility of the text block.
        
        Args:
            visibility (SlateVisibility):
        """
        ...
    def set_selected_key(self, selected_key: InputChord) -> None:
        r"""
        x.set_selected_key(selected_key) -> None
        Sets the currently selected key.
        
        Args:
            selected_key (InputChord):
        """
        ...
    def set_no_key_specified_text(self, no_key_specified_text: Text) -> None:
        r"""
        x.set_no_key_specified_text(no_key_specified_text) -> None
        Sets the text to display when no key text is available or not selecting a key.
        
        Args:
            no_key_specified_text (Text):
        """
        ...
    def set_key_selection_text(self, key_selection_text: Text) -> None:
        r"""
        x.set_key_selection_text(key_selection_text) -> None
        Sets the text which is displayed while selecting keys.
        
        Args:
            key_selection_text (Text):
        """
        ...
    def set_escape_keys(self, keys: Array[Key]) -> None:
        r"""
        x.set_escape_keys(keys) -> None
        Sets escape keys.
        
        Args:
            keys (Array[Key]):
        """
        ...
    def set_allow_modifier_keys(self, allow_modifier_keys: bool) -> None:
        r"""
        x.set_allow_modifier_keys(allow_modifier_keys) -> None
        Sets whether or not modifier keys are allowed in the selected key.
        
        Args:
            allow_modifier_keys (bool):
        """
        ...
    def set_allow_gamepad_keys(self, allow_gamepad_keys: bool) -> None:
        r"""
        x.set_allow_gamepad_keys(allow_gamepad_keys) -> None
        Sets whether or not gamepad keys are allowed in the selected key.
        
        Args:
            allow_gamepad_keys (bool):
        """
        ...
    def get_is_selecting_key(self) -> bool:
        r"""
        x.get_is_selecting_key() -> bool
        Returns true if the widget is currently selecting a key, otherwise returns false.
        
        Returns:
            bool:
        """
        ...

class InvalidationBox(ContentWidget):
    r"""
    Invalidate
    * Single Child
    * Caching / Performance
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: InvalidationBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_cache`` (bool):  [Read-Write] Should the invalidation panel cache the widgets?  Making this false makes it so the invalidation
      panel stops acting like an invalidation panel, just becomes a simple container widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def can_cache(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the invalidation panel cache the widgets?  Making this false makes it so the invalidation
        panel stops acting like an invalidation panel, just becomes a simple container widget.
        """
        ...
    @can_cache.setter
    def can_cache(self, value: bool) -> None:
        ...
    def set_can_cache(self, can_cache: bool) -> None:
        r"""
        x.set_can_cache(can_cache) -> None
        Tell the InvalidationBox to use the invalidation process.
        note: the other internal flags can disable the option.
        
        Args:
            can_cache (bool):
        """
        ...
    def invalidate_cache(self) -> None:
        r"""
        x.invalidate_cache() -> None
        Invalidate Cache
        deprecated: Function 'InvalidateCache' is deprecated.
        """
        ...
    def get_can_cache(self) -> bool:
        r"""
        x.get_can_cache() -> bool
        
        
        Returns:
            bool: true when the invalidation box cache the widgets. The widgets will be updated only if they get invalidated.
        """
        ...

class MenuAnchor(ContentWidget):
    r"""
    The Menu Anchor allows you to specify an location that a popup menu should be anchored to,
    and should be summoned from.
    * Single Child
    * Popup
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MenuAnchor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``menu_class`` (type(Class)):  [Read-Write] The widget class to spawn when the menu is required.  Creates the widget freshly each time.
      If you want to customize the creation of the popup, you should bind a function to OnGetMenuContentEvent
      instead.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_get_menu_content_event`` (GetWidget):  [Read-Write]
    - ``on_get_user_menu_content_event`` (GetUserWidget):  [Read-Write] Called when the menu content is requested to allow a more customized handling over what to display
    - ``on_menu_open_changed`` (OnMenuOpenChangedEvent):  [Read-Write] Called when the opened state of the menu changes
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``placement`` (MenuPlacement):  [Read-Write] The placement location of the summoned widget.
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``should_defer_painting_after_window_content`` (bool):  [Read-Write]
    - ``should_fit_in_window`` (bool):  [Read-Write] Should the menu anchor attempt to fit the menu inside the window.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``use_application_menu_stack`` (bool):  [Read-Write] Does this menu behave like a normal stacked menu? Set it to false to control the menu's lifetime yourself.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def menu_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] The widget class to spawn when the menu is required.  Creates the widget freshly each time.
        If you want to customize the creation of the popup, you should bind a function to OnGetMenuContentEvent
        instead.
        """
        ...
    @property
    def placement(self) -> MenuPlacement:
        r"""
        (MenuPlacement):  [Read-Write] The placement location of the summoned widget.
        """
        ...
    @placement.setter
    def placement(self, value: MenuPlacement) -> None:
        ...
    @property
    def should_fit_in_window(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the menu anchor attempt to fit the menu inside the window.
        """
        ...
    @should_fit_in_window.setter
    def should_fit_in_window(self, value: bool) -> None:
        ...
    @property
    def should_defer_painting_after_window_content(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def use_application_menu_stack(self) -> bool:
        r"""
        (bool):  [Read-Only] Does this menu behave like a normal stacked menu? Set it to false to control the menu's lifetime yourself.
        """
        ...
    @property
    def on_menu_open_changed(self) -> OnMenuOpenChangedEvent:
        r"""
        (OnMenuOpenChangedEvent):  [Read-Write] Called when the opened state of the menu changes
        """
        ...
    @on_menu_open_changed.setter
    def on_menu_open_changed(self, value: OnMenuOpenChangedEvent) -> None:
        ...
    def toggle_open(self, focus_on_open: bool) -> None:
        r"""
        x.toggle_open(focus_on_open) -> None
        Toggles the menus open state.
        
        Args:
            focus_on_open (bool): Should we focus the popup as soon as it opens?
        """
        ...
    def should_open_due_to_click(self) -> bool:
        r"""
        x.should_open_due_to_click() -> bool
        Returns true if we should open the menu due to a click. Sometimes we should not, if
        the same MouseDownEvent that just closed the menu is about to re-open it because it
        happens to land on the button.
        
        Returns:
            bool:
        """
        ...
    def set_placement(self, placement: MenuPlacement) -> None:
        r"""
        x.set_placement(placement) -> None
        TODO UMG Add Set MenuClass
        
        Args:
            placement (MenuPlacement):
        """
        ...
    def open(self, focus_menu: bool) -> None:
        r"""
        x.open(focus_menu) -> None
        Opens the menu if it is not already open
        
        Args:
            focus_menu (bool):
        """
        ...
    def is_open(self) -> bool:
        r"""
        x.is_open() -> bool
        Returns true if the popup is open; false otherwise.
        
        Returns:
            bool:
        """
        ...
    def has_open_sub_menus(self) -> bool:
        r"""
        x.has_open_sub_menus() -> bool
        Returns whether this menu has open submenus
        
        Returns:
            bool:
        """
        ...
    def get_menu_position(self) -> Vector2D:
        r"""
        x.get_menu_position() -> Vector2D
        Returns the current menu position
        
        Returns:
            Vector2D:
        """
        ...
    def fit_in_window(self, fit: bool) -> None:
        r"""
        x.fit_in_window(fit) -> None
        Fit in Window
        
        Args:
            fit (bool):
        """
        ...
    def close(self) -> None:
        r"""
        x.close() -> None
        Closes the menu if it is currently open.
        """
        ...

class TextLayoutWidget(Widget):
    r"""
    Base class for all widgets that use a text layout.
    Contains the common options that should be exposed for the underlying Slate widget.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: TextWidgetTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``apply_line_height_to_bottom_line`` (bool):  [Read-Write] Whether to leave extra space below the last line due to line height.
    - ``auto_wrap_text`` (bool):  [Read-Write] True if we're wrapping text automatically based on the computed horizontal space for this widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] How the text should be aligned with the margin.
    - ``line_height_percentage`` (float):  [Read-Write] The amount to scale each lines height by.
    - ``margin`` (Margin):  [Read-Write] The amount of blank space left around the edges of text area.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``shaped_text_options`` (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wrap_text_at`` (float):  [Read-Write] Whether text wraps onto a new line when it's length exceeds this width; if this value is zero or negative, no wrapping occurs.
    - ``wrapping_policy`` (TextWrappingPolicy):  [Read-Write] The wrapping policy to use.
    """
    @property
    def shaped_text_options(self) -> ShapedTextOptions:
        r"""
        (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
        """
        ...
    @shaped_text_options.setter
    def shaped_text_options(self, value: ShapedTextOptions) -> None:
        ...
    @property
    def justification(self) -> TextJustify:
        r"""
        (TextJustify):  [Read-Write] How the text should be aligned with the margin.
        """
        ...
    @justification.setter
    def justification(self, value: TextJustify) -> None:
        ...
    @property
    def wrapping_policy(self) -> TextWrappingPolicy:
        r"""
        (TextWrappingPolicy):  [Read-Write] The wrapping policy to use.
        """
        ...
    @wrapping_policy.setter
    def wrapping_policy(self, value: TextWrappingPolicy) -> None:
        ...
    @property
    def auto_wrap_text(self) -> bool:
        r"""
        (bool):  [Read-Write] True if we're wrapping text automatically based on the computed horizontal space for this widget.
        """
        ...
    @auto_wrap_text.setter
    def auto_wrap_text(self, value: bool) -> None:
        ...
    @property
    def wrap_text_at(self) -> float:
        r"""
        (float):  [Read-Write] Whether text wraps onto a new line when it's length exceeds this width; if this value is zero or negative, no wrapping occurs.
        """
        ...
    @wrap_text_at.setter
    def wrap_text_at(self, value: float) -> None:
        ...
    @property
    def margin(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The amount of blank space left around the edges of text area.
        """
        ...
    @margin.setter
    def margin(self, value: Margin) -> None:
        ...
    @property
    def line_height_percentage(self) -> float:
        r"""
        (float):  [Read-Write] The amount to scale each lines height by.
        """
        ...
    @line_height_percentage.setter
    def line_height_percentage(self, value: float) -> None:
        ...
    @property
    def apply_line_height_to_bottom_line(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to leave extra space below the last line due to line height.
        """
        ...
    @apply_line_height_to_bottom_line.setter
    def apply_line_height_to_bottom_line(self, value: bool) -> None:
        ...

class MultiLineEditableText(TextLayoutWidget):
    r"""
    Editable text box widget
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MultiLineEditableText.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_context_menu`` (bool):  [Read-Write] Whether the context menu can be opened
    - ``apply_line_height_to_bottom_line`` (bool):  [Read-Write] Whether to leave extra space below the last line due to line height.
    - ``auto_wrap_text`` (bool):  [Read-Write] True if we're wrapping text automatically based on the computed horizontal space for this widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_keyboard_focus_on_commit`` (bool):  [Read-Write] Whether to clear keyboard focus when pressing enter to commit changes
    - ``clear_text_selection_on_focus_loss`` (bool):  [Read-Write] Whether to clear text selection when focus is lost
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hint_text`` (Text):  [Read-Write] Hint text that appears when there is no text in the text box
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_read_only`` (bool):  [Read-Write] Sets the Text as Readonly to prevent it from being modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] How the text should be aligned with the margin.
    - ``line_height_percentage`` (float):  [Read-Write] The amount to scale each lines height by.
    - ``margin`` (Margin):  [Read-Write] The amount of blank space left around the edges of text area.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_text_changed`` (OnMultiLineEditableTextChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
    - ``on_text_committed`` (OnMultiLineEditableTextCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``revert_text_on_escape`` (bool):  [Read-Write] Whether to allow the user to back out of changes when they press the escape key
    - ``select_all_text_when_focused`` (bool):  [Read-Write] Whether to select all text when the user clicks to give focus on the widget
    - ``shaped_text_options`` (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text`` (Text):  [Read-Write] The text content for this editable text box widget
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``virtual_keyboard_dismiss_action`` (VirtualKeyboardDismissAction):  [Read-Write] What action should be taken when the virtual keyboard is dismissed?
    - ``virtual_keyboard_options`` (VirtualKeyboardOptions):  [Read-Write] Additional options for the virtual keyboard
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (TextBlockStyle):  [Read-Write] The style
    - ``wrap_text_at`` (float):  [Read-Write] Whether text wraps onto a new line when it's length exceeds this width; if this value is zero or negative, no wrapping occurs.
    - ``wrapping_policy`` (TextWrappingPolicy):  [Read-Write] The wrapping policy to use.
    """
    @property
    def text(self) -> Text:
        r"""
        (Text):  [Read-Write] The text content for this editable text box widget
        """
        ...
    @text.setter
    def text(self, value: Text) -> None:
        ...
    @property
    def hint_text(self) -> Text:
        r"""
        (Text):  [Read-Write] Hint text that appears when there is no text in the text box
        """
        ...
    @hint_text.setter
    def hint_text(self, value: Text) -> None:
        ...
    @property
    def widget_style(self) -> TextBlockStyle:
        r"""
        (TextBlockStyle):  [Read-Write] The style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: TextBlockStyle) -> None:
        ...
    @property
    def is_read_only(self) -> bool:
        r"""
        (bool):  [Read-Write] Sets the Text as Readonly to prevent it from being modified interactively by the user
        """
        ...
    @is_read_only.setter
    def is_read_only(self, value: bool) -> None:
        ...
    @property
    def select_all_text_when_focused(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to select all text when the user clicks to give focus on the widget
        """
        ...
    @select_all_text_when_focused.setter
    def select_all_text_when_focused(self, value: bool) -> None:
        ...
    @property
    def revert_text_on_escape(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to allow the user to back out of changes when they press the escape key
        """
        ...
    @revert_text_on_escape.setter
    def revert_text_on_escape(self, value: bool) -> None:
        ...
    @property
    def clear_keyboard_focus_on_commit(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to clear keyboard focus when pressing enter to commit changes
        """
        ...
    @clear_keyboard_focus_on_commit.setter
    def clear_keyboard_focus_on_commit(self, value: bool) -> None:
        ...
    @property
    def on_text_changed(self) -> OnMultiLineEditableTextChangedEvent:
        r"""
        (OnMultiLineEditableTextChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
        """
        ...
    @on_text_changed.setter
    def on_text_changed(self, value: OnMultiLineEditableTextChangedEvent) -> None:
        ...
    @property
    def on_text_committed(self) -> OnMultiLineEditableTextCommittedEvent:
        r"""
        (OnMultiLineEditableTextCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
        """
        ...
    @on_text_committed.setter
    def on_text_committed(self, value: OnMultiLineEditableTextCommittedEvent) -> None:
        ...
    def set_text(self, text: Text) -> None:
        r"""
        x.set_text(text) -> None
        Directly sets the widget text.
        
        Args:
            text (Text): The text to assign to the widget
        """
        ...
    def set_is_read_only(self, read_only: bool) -> None:
        r"""
        x.set_is_read_only(read_only) -> None
        Sets the Text as Readonly to prevent it from being modified interactively by the user
        
        Args:
            read_only (bool):
        """
        ...
    def set_hint_text(self, hint_text: Text) -> None:
        r"""
        x.set_hint_text(hint_text) -> None
        Sets the Hint text that appears when there is no text in the text box
        
        Args:
            hint_text (Text): The text that appears when there is no text in the text box
        """
        ...
    def set_font_outline_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_font_outline_material(material) -> None
        Set Font Outline Material
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_font_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_font_material(material) -> None
        Set Font Material
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_font(self, font_info: SlateFontInfo) -> None:
        r"""
        x.set_font(font_info) -> None
        Set Font
        
        Args:
            font_info (SlateFontInfo):
        """
        ...
    def get_text(self) -> Text:
        r"""
        x.get_text() -> Text
        Gets the widget text
        
        Returns:
            Text: The widget text
        """
        ...
    def get_hint_text(self) -> Text:
        r"""
        x.get_hint_text() -> Text
        Returns the Hint text that appears when there is no text in the text box
        
        Returns:
            Text:
        """
        ...
    def get_font(self) -> SlateFontInfo:
        r"""
        x.get_font() -> SlateFontInfo
        Get Font
        
        Returns:
            SlateFontInfo:
        """
        ...

class MultiLineEditableTextBox(TextLayoutWidget):
    r"""
    Allows a user to enter multiple lines of text
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: MultiLineEditableTextBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_context_menu`` (bool):  [Read-Write] Whether the context menu can be opened
    - ``apply_line_height_to_bottom_line`` (bool):  [Read-Write] Whether to leave extra space below the last line due to line height.
    - ``auto_wrap_text`` (bool):  [Read-Write] True if we're wrapping text automatically based on the computed horizontal space for this widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hint_text`` (Text):  [Read-Write] Hint text that appears when there is no text in the text box
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_read_only`` (bool):  [Read-Write] Sets the Text as Readonly to prevent it from being modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] How the text should be aligned with the margin.
    - ``line_height_percentage`` (float):  [Read-Write] The amount to scale each lines height by.
    - ``margin`` (Margin):  [Read-Write] The amount of blank space left around the edges of text area.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_text_changed`` (OnMultiLineEditableTextBoxChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
    - ``on_text_committed`` (OnMultiLineEditableTextBoxCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``shaped_text_options`` (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text`` (Text):  [Read-Write] The text content for this editable text box widget
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``virtual_keyboard_dismiss_action`` (VirtualKeyboardDismissAction):  [Read-Write] What action should be taken when the virtual keyboard is dismissed?
    - ``virtual_keyboard_options`` (VirtualKeyboardOptions):  [Read-Write] Additional options to be used by the virtual keyboard summoned from this widget
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (EditableTextBoxStyle):  [Read-Write] The style
    - ``wrap_text_at`` (float):  [Read-Write] Whether text wraps onto a new line when it's length exceeds this width; if this value is zero or negative, no wrapping occurs.
    - ``wrapping_policy`` (TextWrappingPolicy):  [Read-Write] The wrapping policy to use.
    """
    @property
    def text(self) -> Text:
        r"""
        (Text):  [Read-Write] The text content for this editable text box widget
        """
        ...
    @text.setter
    def text(self, value: Text) -> None:
        ...
    @property
    def hint_text(self) -> Text:
        r"""
        (Text):  [Read-Write] Hint text that appears when there is no text in the text box
        """
        ...
    @hint_text.setter
    def hint_text(self, value: Text) -> None:
        ...
    @property
    def widget_style(self) -> EditableTextBoxStyle:
        r"""
        (EditableTextBoxStyle):  [Read-Write] The style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: EditableTextBoxStyle) -> None:
        ...
    @property
    def is_read_only(self) -> bool:
        r"""
        (bool):  [Read-Write] Sets the Text as Readonly to prevent it from being modified interactively by the user
        """
        ...
    @is_read_only.setter
    def is_read_only(self, value: bool) -> None:
        ...
    @property
    def on_text_changed(self) -> OnMultiLineEditableTextBoxChangedEvent:
        r"""
        (OnMultiLineEditableTextBoxChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
        """
        ...
    @on_text_changed.setter
    def on_text_changed(self, value: OnMultiLineEditableTextBoxChangedEvent) -> None:
        ...
    @property
    def on_text_committed(self) -> OnMultiLineEditableTextBoxCommittedEvent:
        r"""
        (OnMultiLineEditableTextBoxCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
        """
        ...
    @on_text_committed.setter
    def on_text_committed(self, value: OnMultiLineEditableTextBoxCommittedEvent) -> None:
        ...
    def set_text_style(self, text_style: TextBlockStyle) -> None:
        r"""
        x.set_text_style(text_style) -> None
        Set Text Style
        
        Args:
            text_style (TextBlockStyle):
        """
        ...
    def set_text(self, text: Text) -> None:
        r"""
        x.set_text(text) -> None
        Directly sets the widget text.
        Warning: This will wipe any binding created for the Text property!
        
        Args:
            text (Text): The text to assign to the widget
        """
        ...
    def set_is_read_only(self, read_only: bool) -> None:
        r"""
        x.set_is_read_only(read_only) -> None
        Sets the Text as Readonly to prevent it from being modified interactively by the user
        
        Args:
            read_only (bool):
        """
        ...
    def set_hint_text(self, hint_text: Text) -> None:
        r"""
        x.set_hint_text(hint_text) -> None
        Sets the Hint text that appears when there is no text in the text box
        
        Args:
            hint_text (Text): The text that appears when there is no text in the text box
        """
        ...
    def set_foreground_color(self, color: LinearColor) -> None:
        r"""
        x.set_foreground_color(color) -> None
        Set Foreground Color
        
        Args:
            color (LinearColor):
        """
        ...
    def set_error(self, error: Text) -> None:
        r"""
        x.set_error(error) -> None
        Set Error
        
        Args:
            error (Text):
        """
        ...
    def get_text(self) -> Text:
        r"""
        x.get_text() -> Text
        Gets the widget text
        
        Returns:
            Text: The widget text
        """
        ...
    def get_hint_text(self) -> Text:
        r"""
        x.get_hint_text() -> Text
        Returns the Hint text that appears when there is no text in the text box
        
        Returns:
            Text:
        """
        ...

class NamedSlot(ContentWidget):
    r"""
    Allows you to expose an external slot for your user widget.  When others reuse your user control,
    they can put whatever they want in this named slot.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: NamedSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``expose_on_instance_only`` (bool):  [Read-Write] Named slots exposed on the instance only follow a slightly different set of rules.  For example, they can contain
      some content that the user can replace after dropping it into their tree.  However, these slots can not be inherited
      to be filled in by a subclass.  So if you want this named slot to be extensible in a subclass of this widget, you
      should set or leave this value as false.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    ...

class NativeWidgetHost(Widget):
    r"""
    A NativeWidgetHost is a container widget that can contain one child slate widget.  This should
    be used when all you need is to nest a native widget inside a UMG widget.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: NativeWidgetHost.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    ...

class Overlay(PanelWidget):
    r"""
    Allows widgets to be stacked on top of each other, uses simple flow layout for content on each layer.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Overlay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    def replace_overlay_child_at(self, index: int, content: Widget) -> bool:
        r"""
        x.replace_overlay_child_at(index, content) -> bool
        Replace the widget at the given index it with a different widget.
        
        Args:
            index (int32): 
            content (Widget): 
        
        Returns:
            bool:
        """
        ...
    def add_child_to_overlay(self, content: Widget) -> OverlaySlot:
        r"""
        x.add_child_to_overlay(content) -> OverlaySlot
        Add Child to Overlay
        
        Args:
            content (Widget): 
        
        Returns:
            OverlaySlot:
        """
        ...

class OverlaySlot(PanelSlot):
    r"""
    Slot for the UOverlay panel.  Allows content to be hover above other content.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: OverlaySlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set the alignment of the object vertically.
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set padding area between the slot and the content it contains.
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set the alignment of the object horizontally.
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class PostBufferUpdate(Widget):
    r"""
    Widget that when drawn, will trigger the slate post buffer to update. Does not draw anything itself.
    This allows for you to perform layered UI / sampling effects with the GetSlatePost material functions,
    by placing this widget after UI you would like to be processed / sampled is drawn.
    
    * No Children
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: PostBufferUpdate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``buffers_to_update`` (Array[SlatePostRT]):  [Read-Write] Buffers that we should update, all of these buffers will be affected by 'bPerformDefaultPostBufferUpdate' if disabled
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``perform_default_post_buffer_update`` (bool):  [Read-Write] True if we should do the default post buffer update of the scene before any UI.
      If any PostBufferUpdate widget has this set as false, be default scene copy / processing will not occur.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def perform_default_post_buffer_update(self) -> bool:
        r"""
        (bool):  [Read-Write] True if we should do the default post buffer update of the scene before any UI.
        If any PostBufferUpdate widget has this set as false, be default scene copy / processing will not occur.
        """
        ...
    @perform_default_post_buffer_update.setter
    def perform_default_post_buffer_update(self, value: bool) -> None:
        ...

class ProgressBar(Widget):
    r"""
    The progress bar widget is a simple bar that fills up that can be restyled to fit any number of uses.
    
    * No Children
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ProgressBar.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``bar_fill_style`` (ProgressBarFillStyle):  [Read-Write] Defines the visual style of the progress bar fill - scale or mask
    - ``bar_fill_type`` (ProgressBarFillType):  [Read-Write] Defines the direction in which the progress bar fills
    - ``border_padding`` (Vector2D):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``fill_color_and_opacity`` (LinearColor):  [Read-Write] Fill Color and Opacity
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_marquee`` (bool):  [Read-Write]
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``percent`` (float):  [Read-Write] Used to determine the fill position of the progress bar ranging 0..1
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ProgressBarStyle):  [Read-Write] The progress bar style
    """
    @property
    def widget_style(self) -> ProgressBarStyle:
        r"""
        (ProgressBarStyle):  [Read-Write] The progress bar style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: ProgressBarStyle) -> None:
        ...
    @property
    def percent(self) -> float:
        r"""
        (float):  [Read-Write] Used to determine the fill position of the progress bar ranging 0..1
        """
        ...
    @percent.setter
    def percent(self, value: float) -> None:
        ...
    @property
    def bar_fill_type(self) -> ProgressBarFillType:
        r"""
        (ProgressBarFillType):  [Read-Write] Defines the direction in which the progress bar fills
        """
        ...
    @bar_fill_type.setter
    def bar_fill_type(self, value: ProgressBarFillType) -> None:
        ...
    @property
    def bar_fill_style(self) -> ProgressBarFillStyle:
        r"""
        (ProgressBarFillStyle):  [Read-Write] Defines the visual style of the progress bar fill - scale or mask
        """
        ...
    @bar_fill_style.setter
    def bar_fill_style(self, value: ProgressBarFillStyle) -> None:
        ...
    @property
    def is_marquee(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_marquee.setter
    def is_marquee(self, value: bool) -> None:
        ...
    @property
    def border_padding(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write]
        """
        ...
    @border_padding.setter
    def border_padding(self, value: Vector2D) -> None:
        ...
    @property
    def fill_color_and_opacity(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Fill Color and Opacity
        """
        ...
    @fill_color_and_opacity.setter
    def fill_color_and_opacity(self, value: LinearColor) -> None:
        ...
    def set_percent(self, percent: float) -> None:
        r"""
        x.set_percent(percent) -> None
        Sets the current value of the ProgressBar.
        
        Args:
            percent (float):
        """
        ...
    def set_is_marquee(self, inb_is_marquee: bool) -> None:
        r"""
        x.set_is_marquee(inb_is_marquee) -> None
        Sets the progress bar to show as a marquee.
        
        Args:
            inb_is_marquee (bool):
        """
        ...
    def set_fill_color_and_opacity(self, color: LinearColor) -> None:
        r"""
        x.set_fill_color_and_opacity(color) -> None
        Sets the fill color of the progress bar.
        
        Args:
            color (LinearColor):
        """
        ...

class RetainerBox(ContentWidget):
    r"""
    The Retainer Box renders children widgets to a render target first before
    later rendering that render target to the screen.  This allows both frequency
    and phase to be controlled so that the UI can actually render less often than the
    frequency of the main game render.  It also has the side benefit of allow materials
    to be applied to the render target after drawing the widgets to apply a simple post process.
    
    * Single Child
    * Caching / Performance
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: RetainerBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``effect_material`` (MaterialInterface):  [Read-Write] The effect to optionally apply to the render target.  We will set the texture sampler based on the name
      set in the
      TextureParameter: property. If you want to adjust transparency of the final image, make sure you set Blend Mode to AlphaComposite (Pre-Multiplied Alpha) and make sure to multiply the alpha you're apply across the surface to the color and the alpha of the render target, otherwise you won't see the expected color.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``phase`` (int32):  [Read-Write] The Phase this widget will draw on.
      
      If the Phase is 0, and the PhaseCount is 1, the widget will be drawn fresh every frame.
      If the Phase were 0, and the PhaseCount were 2, this retainer would draw a fresh frame every
      other frame.  So in a 60Hz game, the UI would render at 30Hz.
    - ``phase_count`` (int32):  [Read-Write] The PhaseCount controls how many phases are possible know what to modulus the current frame
      count by to determine if this is the current frame to draw the widget on.
      
      If the Phase is 0, and the PhaseCount is 1, the widget will be drawn fresh every frame.
      If the Phase were 0, and the PhaseCount were 2, this retainer would draw a fresh frame every
      other frame.  So in a 60Hz game, the UI would render at 30Hz.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_on_invalidation`` (bool):  [Read-Write] Should this widget redraw the contents it has every time it receives an invalidation request
      from it's children, similar to the invalidation panel.
    - ``render_on_phase`` (bool):  [Read-Write] Should this widget redraw the contents it has every time the phase occurs.
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``retain_render`` (bool):  [Read-Write]
    - ``show_effects_in_designer`` (bool):  [Read-Write] If true, retained rendering occurs in designer
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``texture_parameter`` (Name):  [Read-Write] The texture sampler parameter of the
      EffectMaterial,: that we'll set to the render target.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def retain_render(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @retain_render.setter
    def retain_render(self, value: bool) -> None:
        ...
    @property
    def render_on_invalidation(self) -> bool:
        r"""
        (bool):  [Read-Only] Should this widget redraw the contents it has every time it receives an invalidation request
        from it's children, similar to the invalidation panel.
        """
        ...
    @property
    def render_on_phase(self) -> bool:
        r"""
        (bool):  [Read-Only] Should this widget redraw the contents it has every time the phase occurs.
        """
        ...
    @property
    def phase(self) -> int:
        r"""
        (int32):  [Read-Only] The Phase this widget will draw on.
        
        If the Phase is 0, and the PhaseCount is 1, the widget will be drawn fresh every frame.
        If the Phase were 0, and the PhaseCount were 2, this retainer would draw a fresh frame every
        other frame.  So in a 60Hz game, the UI would render at 30Hz.
        """
        ...
    @property
    def phase_count(self) -> int:
        r"""
        (int32):  [Read-Only] The PhaseCount controls how many phases are possible know what to modulus the current frame
        count by to determine if this is the current frame to draw the widget on.
        
        If the Phase is 0, and the PhaseCount is 1, the widget will be drawn fresh every frame.
        If the Phase were 0, and the PhaseCount were 2, this retainer would draw a fresh frame every
        other frame.  So in a 60Hz game, the UI would render at 30Hz.
        """
        ...
    @property
    def effect_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Write] The effect to optionally apply to the render target.  We will set the texture sampler based on the name
        set in the
        TextureParameter: property. If you want to adjust transparency of the final image, make sure you set Blend Mode to AlphaComposite (Pre-Multiplied Alpha) and make sure to multiply the alpha you're apply across the surface to the color and the alpha of the render target, otherwise you won't see the expected color.
        """
        ...
    @effect_material.setter
    def effect_material(self, value: MaterialInterface) -> None:
        ...
    @property
    def texture_parameter(self) -> Name:
        r"""
        (Name):  [Read-Write] The texture sampler parameter of the
        EffectMaterial,: that we'll set to the render target.
        """
        ...
    @texture_parameter.setter
    def texture_parameter(self, value: Name) -> None:
        ...
    @property
    def show_effects_in_designer(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, retained rendering occurs in designer
        """
        ...
    def set_texture_parameter(self, texture_parameter: Name) -> None:
        r"""
        x.set_texture_parameter(texture_parameter) -> None
        Sets the name of the texture parameter to set the render target to on the material.
        
        Args:
            texture_parameter (Name):
        """
        ...
    def set_retain_rendering(self, retain_rendering: bool) -> None:
        r"""
        x.set_retain_rendering(retain_rendering) -> None
        Set the flag for if we retain the render or pass-through
        
        Args:
            retain_rendering (bool):
        """
        ...
    def set_rendering_phase(self, render_phase: int, total_phases: int) -> None:
        r"""
        x.set_rendering_phase(render_phase, total_phases) -> None
        Requests the retainer redrawn the contents it has.
        
        Args:
            render_phase (int32): 
            total_phases (int32):
        """
        ...
    def set_effect_material(self, effect_material: MaterialInterface) -> None:
        r"""
        x.set_effect_material(effect_material) -> None
        Set a new effect material to the retainer widget.
        
        Args:
            effect_material (MaterialInterface):
        """
        ...
    def request_render(self) -> None:
        r"""
        x.request_render() -> None
        Requests the retainer redrawn the contents it has.
        """
        ...
    def get_effect_material(self) -> MaterialInstanceDynamic:
        r"""
        x.get_effect_material() -> MaterialInstanceDynamic
        Get the current dynamic effect material applied to the retainer box.
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...

class RichTextBlock(TextLayoutWidget):
    r"""
    The rich text block
    
    * Fancy Text
    * No Children
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: RichTextBlock.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``apply_line_height_to_bottom_line`` (bool):  [Read-Write] Whether to leave extra space below the last line due to line height.
    - ``auto_wrap_text`` (bool):  [Read-Write] True if we're wrapping text automatically based on the computed horizontal space for this widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``decorator_classes`` (Array[type(Class)]):  [Read-Write]
    - ``default_text_style_override`` (TextBlockStyle):  [Read-Write] Text style to apply by default to text in this block
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] How the text should be aligned with the margin.
    - ``line_height_percentage`` (float):  [Read-Write] The amount to scale each lines height by.
    - ``margin`` (Margin):  [Read-Write] The amount of blank space left around the edges of text area.
    - ``min_desired_width`` (float):  [Read-Write] The minimum desired size for the text
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``override_default_style`` (bool):  [Read-Write] True to specify the default text style for this rich text inline, overriding any default provided in the style set table
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``shaped_text_options`` (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text`` (Text):  [Read-Write] The text to display
    - ``text_overflow_policy`` (TextOverflowPolicy):  [Read-Write] Sets what happens to text that is clipped and doesn't fit within the clip rect for this widget
    - ``text_style_set`` (DataTable):  [Read-Write]
    - ``text_transform_policy`` (TextTransformPolicy):  [Read-Write] The text transformation policy to apply to this text block
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wrap_text_at`` (float):  [Read-Write] Whether text wraps onto a new line when it's length exceeds this width; if this value is zero or negative, no wrapping occurs.
    - ``wrapping_policy`` (TextWrappingPolicy):  [Read-Write] The wrapping policy to use.
    """
    @property
    def text(self) -> Text:
        r"""
        (Text):  [Read-Write] The text to display
        """
        ...
    @text.setter
    def text(self, value: Text) -> None:
        ...
    @property
    def text_style_set(self) -> DataTable:
        r"""
        (DataTable):  [Read-Write]
        """
        ...
    @text_style_set.setter
    def text_style_set(self, value: DataTable) -> None:
        ...
    @property
    def default_text_style_override(self) -> TextBlockStyle:
        r"""
        (TextBlockStyle):  [Read-Write] Text style to apply by default to text in this block
        """
        ...
    @default_text_style_override.setter
    def default_text_style_override(self, value: TextBlockStyle) -> None:
        ...
    @property
    def min_desired_width(self) -> float:
        r"""
        (float):  [Read-Write] The minimum desired size for the text
        """
        ...
    @min_desired_width.setter
    def min_desired_width(self, value: float) -> None:
        ...
    @property
    def text_transform_policy(self) -> TextTransformPolicy:
        r"""
        (TextTransformPolicy):  [Read-Write] The text transformation policy to apply to this text block
        """
        ...
    @text_transform_policy.setter
    def text_transform_policy(self, value: TextTransformPolicy) -> None:
        ...
    @property
    def text_overflow_policy(self) -> TextOverflowPolicy:
        r"""
        (TextOverflowPolicy):  [Read-Write] Sets what happens to text that is clipped and doesn't fit within the clip rect for this widget
        """
        ...
    @text_overflow_policy.setter
    def text_overflow_policy(self, value: TextOverflowPolicy) -> None:
        ...
    def set_text_transform_policy(self, transform_policy: TextTransformPolicy) -> None:
        r"""
        x.set_text_transform_policy(transform_policy) -> None
        Set the text transformation policy for this text block.
        
        Args:
            transform_policy (TextTransformPolicy): the new text transformation policy.
        """
        ...
    def set_text_style_set(self, new_text_style_set: DataTable) -> None:
        r"""
        x.set_text_style_set(new_text_style_set) -> None
        Set Text Style Set
        
        Args:
            new_text_style_set (DataTable):
        """
        ...
    def set_text_overflow_policy(self, overflow_policy: TextOverflowPolicy) -> None:
        r"""
        x.set_text_overflow_policy(overflow_policy) -> None
        Set the text overflow policy for this text block.
        
        Args:
            overflow_policy (TextOverflowPolicy): the new text overflow policy.
        """
        ...
    def set_text(self, text: Text) -> None:
        r"""
        x.set_text(text) -> None
        Directly sets the widget text.
        Warning: This will wipe any binding created for the Text property!
        
        Args:
            text (Text): The text to assign to the widget
        """
        ...
    def set_min_desired_width(self, min_desired_width: float) -> None:
        r"""
        x.set_min_desired_width(min_desired_width) -> None
        Set the minimum desired width for this rich text block
        
        Args:
            min_desired_width (float): new minimum desired width
        """
        ...
    def set_default_text_style(self, default_text_style: TextBlockStyle) -> None:
        r"""
        x.set_default_text_style(default_text_style) -> None
        Wholesale override of the currently established default text style
        
        Args:
            default_text_style (TextBlockStyle): The new text style to apply to all default (i.e. undecorated) text in the block
        """
        ...
    def set_default_strike_brush(self, strike_brush: SlateBrush) -> None:
        r"""
        x.set_default_strike_brush(strike_brush) -> None
        Dynamically set the default strike brush for this rich text block
        
        Args:
            strike_brush (SlateBrush): The new brush to use to strike through text
        """
        ...
    def set_default_shadow_offset(self, shadow_offset: Vector2D) -> None:
        r"""
        x.set_default_shadow_offset(shadow_offset) -> None
        Sets the offset that the default text drop shadow should be drawn at
        
        Args:
            shadow_offset (Vector2D): The new offset
        """
        ...
    def set_default_shadow_color_and_opacity(self, shadow_color_and_opacity: LinearColor) -> None:
        r"""
        x.set_default_shadow_color_and_opacity(shadow_color_and_opacity) -> None
        Sets the color and opacity of the default text drop shadow
        Note: if opacity is zero no shadow will be drawn
        
        Args:
            shadow_color_and_opacity (LinearColor): The new drop shadow color and opacity
        """
        ...
    def set_default_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_default_material(material) -> None
        Set Default Material
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_default_font(self, font_info: SlateFontInfo) -> None:
        r"""
        x.set_default_font(font_info) -> None
        Dynamically set the default font info for this rich text block
        
        Args:
            font_info (SlateFontInfo): The new font info
        """
        ...
    def set_default_color_and_opacity(self, color_and_opacity: SlateColor) -> None:
        r"""
        x.set_default_color_and_opacity(color_and_opacity) -> None
        Sets the color and opacity of the default text in this rich text block
        
        Args:
            color_and_opacity (SlateColor): The new text color and opacity
        """
        ...
    def set_decorators(self, decorator_classes: Array[Class]) -> None:
        r"""
        x.set_decorators(decorator_classes) -> None
        Replaces the existing decorators with the list provided
        
        Args:
            decorator_classes (Array[type(Class)]):
        """
        ...
    def set_auto_wrap_text(self, auto_text_wrap: bool) -> None:
        r"""
        x.set_auto_wrap_text(auto_text_wrap) -> None
        Set the auto wrap for this rich text block
        
        Args:
            auto_text_wrap (bool): to turn wrap on or off
        """
        ...
    def refresh_text_layout(self) -> None:
        r"""
        x.refresh_text_layout() -> None
        Causes the text to reflow it's layout and re-evaluate any decorators
        """
        ...
    def get_text_style_set(self) -> DataTable:
        r"""
        x.get_text_style_set() -> DataTable
        Get Text Style Set
        
        Returns:
            DataTable:
        """
        ...
    def get_text(self) -> Text:
        r"""
        x.get_text() -> Text
        Returns widgets text.
        
        Returns:
            Text:
        """
        ...
    def get_default_dynamic_material(self) -> MaterialInstanceDynamic:
        r"""
        x.get_default_dynamic_material() -> MaterialInstanceDynamic
        Creates a dynamic material for the default font or returns it if it already
        exists
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...
    def get_decorator_by_class(self, decorator_class: Class) -> RichTextBlockDecorator:
        r"""
        x.get_decorator_by_class(decorator_class) -> RichTextBlockDecorator
        Get Decorator by Class
        
        Args:
            decorator_class (type(Class)): 
        
        Returns:
            RichTextBlockDecorator:
        """
        ...
    def clear_all_default_style_overrides(self) -> None:
        r"""
        x.clear_all_default_style_overrides() -> None
        Remove all overrides made to the default text style and return to the style specified in the style set data table
        """
        ...

class RichTextBlockDecorator(Object):
    r"""
    Rich Text Block Decorator
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: RichTextBlockDecorator.h
    
    """
    ...

class RichTextBlockImageDecorator(RichTextBlockDecorator):
    r"""
    Allows you to setup an image decorator that can be configured
    to map certain keys to certain images.  We recommend you subclass this
    as a blueprint to configure the instance.
    
    Understands the format <img id="NameOfBrushInTable"></>
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: RichTextBlockImageDecorator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``image_set`` (DataTable):  [Read-Write]
    """
    ...

class SafeZone(ContentWidget):
    r"""
    The Safe-Zone widget is an essential part of developing a game UI that can run on lots of different non-PC platforms.
    While a modern flat panel computer monitor may not have over scan issues, this is a common occurrence for Consoles.
    It's common for TVs to have extra pixels under the bezel, in addition to projectors and projection TVs having potentially
    several vertical and horizontal columns of pixels hidden behind or against a black border of the projection screen.
    
    Useful testing console commands to help, simulate the safe zone on PC,
      r.DebugSafeZone.TitleRatio 0.96
      r.DebugActionZone.ActionRatio 0.96
    
    To enable a red band to visualize the safe zone, use this console command,
    r.DebugSafeZone.Mode controls the debug visualization overlay (0..2, default 0).
      0: Do not display the safe zone overlay.
      1: Display the overlay for the title safe zone.
      2: Display the overlay for the action safe zone.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SafeZone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pad_bottom`` (bool):  [Read-Write] If this safe zone should pad for the bottom side of the screen's safe zone
    - ``pad_left`` (bool):  [Read-Write] If this safe zone should pad for the left side of the screen's safe zone
    - ``pad_right`` (bool):  [Read-Write] If this safe zone should pad for the right side of the screen's safe zone
    - ``pad_top`` (bool):  [Read-Write] If this safe zone should pad for the top side of the screen's safe zone
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def pad_left(self) -> bool:
        r"""
        (bool):  [Read-Write] If this safe zone should pad for the left side of the screen's safe zone
        """
        ...
    @pad_left.setter
    def pad_left(self, value: bool) -> None:
        ...
    @property
    def pad_right(self) -> bool:
        r"""
        (bool):  [Read-Write] If this safe zone should pad for the right side of the screen's safe zone
        """
        ...
    @pad_right.setter
    def pad_right(self, value: bool) -> None:
        ...
    @property
    def pad_top(self) -> bool:
        r"""
        (bool):  [Read-Write] If this safe zone should pad for the top side of the screen's safe zone
        """
        ...
    @pad_top.setter
    def pad_top(self, value: bool) -> None:
        ...
    @property
    def pad_bottom(self) -> bool:
        r"""
        (bool):  [Read-Write] If this safe zone should pad for the bottom side of the screen's safe zone
        """
        ...
    @pad_bottom.setter
    def pad_bottom(self, value: bool) -> None:
        ...
    def set_sides_to_pad(self, pad_left: bool, pad_right: bool, pad_top: bool, pad_bottom: bool) -> None:
        r"""
        x.set_sides_to_pad(pad_left, pad_right, pad_top, pad_bottom) -> None
        Set Sides to Pad
        
        Args:
            pad_left (bool): 
            pad_right (bool): 
            pad_top (bool): 
            pad_bottom (bool):
        """
        ...

class SafeZoneSlot(PanelSlot):
    r"""
    Safe Zone Slot
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SafeZoneSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``h_align`` (HorizontalAlignment):  [Read-Write]
    - ``is_title_safe`` (bool):  [Read-Write]
    - ``padding`` (Margin):  [Read-Write]
    - ``safe_area_scale`` (Margin):  [Read-Write]
    - ``v_align`` (VerticalAlignment):  [Read-Write]
    """
    @property
    def is_title_safe(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_title_safe.setter
    def is_title_safe(self, value: bool) -> None:
        ...
    @property
    def safe_area_scale(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @safe_area_scale.setter
    def safe_area_scale(self, value: Margin) -> None:
        ...
    @property
    def h_align(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write]
        """
        ...
    @h_align.setter
    def h_align(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def v_align(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write]
        """
        ...
    @v_align.setter
    def v_align(self, value: VerticalAlignment) -> None:
        ...
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write]
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...

class ScaleBox(ContentWidget):
    r"""
    Allows you to place content with a desired size and have it scale to meet the constraints placed on this box's alloted area.  If
    you needed to have a background image scale to fill an area but not become distorted with different aspect ratios, or if you need
    to auto fit some text to an area, this is the control for you.
    
    * Single Child
    * Aspect Ratio
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ScaleBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``ignore_inherited_scale`` (bool):  [Read-Write] Optional bool to ignore the inherited scale. Applies inverse scaling to counteract parents before applying the local scale operation.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``stretch`` (Stretch):  [Read-Write] The stretching rule to apply when content is stretched
    - ``stretch_direction`` (StretchDirection):  [Read-Write] Controls in what direction content can be scaled
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``user_specified_scale`` (float):  [Read-Write] Optional scale that can be specified by the User. Used only for UserSpecified stretching.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def stretch(self) -> Stretch:
        r"""
        (Stretch):  [Read-Write] The stretching rule to apply when content is stretched
        """
        ...
    @stretch.setter
    def stretch(self, value: Stretch) -> None:
        ...
    @property
    def stretch_direction(self) -> StretchDirection:
        r"""
        (StretchDirection):  [Read-Write] Controls in what direction content can be scaled
        """
        ...
    @stretch_direction.setter
    def stretch_direction(self, value: StretchDirection) -> None:
        ...
    @property
    def user_specified_scale(self) -> float:
        r"""
        (float):  [Read-Write] Optional scale that can be specified by the User. Used only for UserSpecified stretching.
        """
        ...
    @user_specified_scale.setter
    def user_specified_scale(self, value: float) -> None:
        ...
    @property
    def ignore_inherited_scale(self) -> bool:
        r"""
        (bool):  [Read-Write] Optional bool to ignore the inherited scale. Applies inverse scaling to counteract parents before applying the local scale operation.
        """
        ...
    @ignore_inherited_scale.setter
    def ignore_inherited_scale(self, value: bool) -> None:
        ...
    def set_user_specified_scale(self, user_specified_scale: float) -> None:
        r"""
        x.set_user_specified_scale(user_specified_scale) -> None
        Set User Specified Scale
        
        Args:
            user_specified_scale (float):
        """
        ...
    def set_stretch_direction(self, stretch_direction: StretchDirection) -> None:
        r"""
        x.set_stretch_direction(stretch_direction) -> None
        Set Stretch Direction
        
        Args:
            stretch_direction (StretchDirection):
        """
        ...
    def set_stretch(self, stretch: Stretch) -> None:
        r"""
        x.set_stretch(stretch) -> None
        Set Stretch
        
        Args:
            stretch (Stretch):
        """
        ...
    def set_ignore_inherited_scale(self, ignore_inherited_scale: bool) -> None:
        r"""
        x.set_ignore_inherited_scale(ignore_inherited_scale) -> None
        Set Ignore Inherited Scale
        
        Args:
            ignore_inherited_scale (bool):
        """
        ...

class ScaleBoxSlot(PanelSlot):
    r"""
    The Slot for the UScaleBoxSlot, contains the widget displayed in a button's single slot
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ScaleBoxSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Only] The alignment of the object horizontally.
        """
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Only] The alignment of the object vertically.
        """
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        deprecated: Function 'SetPadding' is deprecated.
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class ScrollBar(Widget):
    r"""
    Scroll Bar
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ScrollBar.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``always_show_scrollbar`` (bool):  [Read-Write]
    - ``always_show_scrollbar_track`` (bool):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``orientation`` (Orientation):  [Read-Write]
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``padding`` (Margin):  [Read-Write] The margin around the scrollbar
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``thickness`` (Vector2D):  [Read-Write] The thickness of the scrollbar thumb
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ScrollBarStyle):  [Read-Write] Style of the scrollbar
    """
    @property
    def widget_style(self) -> ScrollBarStyle:
        r"""
        (ScrollBarStyle):  [Read-Write] Style of the scrollbar
        """
        ...
    @widget_style.setter
    def widget_style(self, value: ScrollBarStyle) -> None:
        ...
    @property
    def always_show_scrollbar(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @always_show_scrollbar.setter
    def always_show_scrollbar(self, value: bool) -> None:
        ...
    @property
    def always_show_scrollbar_track(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @always_show_scrollbar_track.setter
    def always_show_scrollbar_track(self, value: bool) -> None:
        ...
    @property
    def orientation(self) -> Orientation:
        r"""
        (Orientation):  [Read-Only]
        """
        ...
    @property
    def thickness(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The thickness of the scrollbar thumb
        """
        ...
    @thickness.setter
    def thickness(self, value: Vector2D) -> None:
        ...
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The margin around the scrollbar
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    def set_state(self, offset_fraction: float, thumb_size_fraction: float) -> None:
        r"""
        x.set_state(offset_fraction, thumb_size_fraction) -> None
        Set the offset and size of the track's thumb.
        Note that the maximum offset is 1.0-ThumbSizeFraction.
        If the user can view 1/3 of the items in a single page, the maximum offset will be ~0.667f
        
        Args:
            offset_fraction (float): Offset of the thumbnail from the top as a fraction of the total available scroll space.
            thumb_size_fraction (float): Size of thumbnail as a fraction of the total available scroll space.
        """
        ...

class ScrollBox(PanelWidget):
    r"""
    An arbitrary scrollable collection of widgets.  Great for presenting 10-100 widgets in a list.  Doesn't support virtualization.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ScrollBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_overscroll`` (bool):  [Read-Write] Disable to stop scrollbars from activating inertial overscrolling
    - ``allow_right_click_drag_scrolling`` (bool):  [Read-Write] Option to disable right-click-drag scrolling
    - ``always_show_scrollbar`` (bool):  [Read-Write]
    - ``always_show_scrollbar_track`` (bool):  [Read-Write]
    - ``animate_wheel_scrolling`` (bool):  [Read-Write] True to lerp smoothly when wheel scrolling along the scroll box
    - ``back_pad_scrolling`` (bool):  [Read-Write] Whether to back pad this scroll box, allowing user to scroll backward until child contents are no longer visible
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``consume_mouse_wheel`` (ConsumeMouseWheel):  [Read-Write] When mouse wheel events should be consumed.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``front_pad_scrolling`` (bool):  [Read-Write] Whether to front pad this scroll box, allowing user to scroll forward until child contents are no longer visible
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``navigation_destination`` (DescendantScrollDestination):  [Read-Write] Sets where to scroll a widget to when using explicit navigation or if ScrollWhenFocusChanges is enabled
    - ``navigation_scroll_padding`` (float):  [Read-Write] The amount of padding to ensure exists between the item being navigated to, at the edge of the
      scrollbox.  Use this if you want to ensure there's a preview of the next item the user could scroll to.
    - ``on_scroll_bar_visibility_changed`` (OnScrollBarVisibilityChangedEvent):  [Read-Write] Called when the scrollbar visibility has changed
    - ``on_user_scrolled`` (OnUserScrolledEvent):  [Read-Write] Called when the scroll has changed
    - ``orientation`` (Orientation):  [Read-Write] The orientation of the scrolling and stacking in the box.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``scroll_bar_visibility`` (SlateVisibility):  [Read-Write] Visibility
    - ``scroll_when_focus_changes`` (ScrollWhenFocusChanges):  [Read-Write] Scroll behavior when user focus is given to a child widget
    - ``scrollbar_padding`` (Margin):  [Read-Write] The margin around the scrollbar
    - ``scrollbar_thickness`` (Vector2D):  [Read-Write] The thickness of the scrollbar thumb
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wheel_scroll_multiplier`` (float):  [Read-Write] The multiplier to apply when wheel scrolling
    - ``widget_bar_style`` (ScrollBarStyle):  [Read-Write] The bar style
    - ``widget_style`` (ScrollBoxStyle):  [Read-Write] The style
    """
    @property
    def widget_style(self) -> ScrollBoxStyle:
        r"""
        (ScrollBoxStyle):  [Read-Write] The style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: ScrollBoxStyle) -> None:
        ...
    @property
    def widget_bar_style(self) -> ScrollBarStyle:
        r"""
        (ScrollBarStyle):  [Read-Write] The bar style
        """
        ...
    @widget_bar_style.setter
    def widget_bar_style(self, value: ScrollBarStyle) -> None:
        ...
    @property
    def orientation(self) -> Orientation:
        r"""
        (Orientation):  [Read-Write] The orientation of the scrolling and stacking in the box.
        """
        ...
    @orientation.setter
    def orientation(self, value: Orientation) -> None:
        ...
    @property
    def scroll_bar_visibility(self) -> SlateVisibility:
        r"""
        (SlateVisibility):  [Read-Write] Visibility
        """
        ...
    @scroll_bar_visibility.setter
    def scroll_bar_visibility(self, value: SlateVisibility) -> None:
        ...
    @property
    def consume_mouse_wheel(self) -> ConsumeMouseWheel:
        r"""
        (ConsumeMouseWheel):  [Read-Write] When mouse wheel events should be consumed.
        """
        ...
    @consume_mouse_wheel.setter
    def consume_mouse_wheel(self, value: ConsumeMouseWheel) -> None:
        ...
    @property
    def scrollbar_thickness(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The thickness of the scrollbar thumb
        """
        ...
    @scrollbar_thickness.setter
    def scrollbar_thickness(self, value: Vector2D) -> None:
        ...
    @property
    def scrollbar_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The margin around the scrollbar
        """
        ...
    @scrollbar_padding.setter
    def scrollbar_padding(self, value: Margin) -> None:
        ...
    @property
    def always_show_scrollbar(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @always_show_scrollbar.setter
    def always_show_scrollbar(self, value: bool) -> None:
        ...
    @property
    def always_show_scrollbar_track(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @always_show_scrollbar_track.setter
    def always_show_scrollbar_track(self, value: bool) -> None:
        ...
    @property
    def allow_overscroll(self) -> bool:
        r"""
        (bool):  [Read-Write] Disable to stop scrollbars from activating inertial overscrolling
        """
        ...
    @allow_overscroll.setter
    def allow_overscroll(self, value: bool) -> None:
        ...
    @property
    def back_pad_scrolling(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to back pad this scroll box, allowing user to scroll backward until child contents are no longer visible
        """
        ...
    @property
    def front_pad_scrolling(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to front pad this scroll box, allowing user to scroll forward until child contents are no longer visible
        """
        ...
    @property
    def animate_wheel_scrolling(self) -> bool:
        r"""
        (bool):  [Read-Write] True to lerp smoothly when wheel scrolling along the scroll box
        """
        ...
    @animate_wheel_scrolling.setter
    def animate_wheel_scrolling(self, value: bool) -> None:
        ...
    @property
    def navigation_destination(self) -> DescendantScrollDestination:
        r"""
        (DescendantScrollDestination):  [Read-Write] Sets where to scroll a widget to when using explicit navigation or if ScrollWhenFocusChanges is enabled
        """
        ...
    @navigation_destination.setter
    def navigation_destination(self, value: DescendantScrollDestination) -> None:
        ...
    @property
    def navigation_scroll_padding(self) -> float:
        r"""
        (float):  [Read-Only] The amount of padding to ensure exists between the item being navigated to, at the edge of the
        scrollbox.  Use this if you want to ensure there's a preview of the next item the user could scroll to.
        """
        ...
    @property
    def scroll_when_focus_changes(self) -> ScrollWhenFocusChanges:
        r"""
        (ScrollWhenFocusChanges):  [Read-Write] Scroll behavior when user focus is given to a child widget
        """
        ...
    @scroll_when_focus_changes.setter
    def scroll_when_focus_changes(self, value: ScrollWhenFocusChanges) -> None:
        ...
    @property
    def allow_right_click_drag_scrolling(self) -> bool:
        r"""
        (bool):  [Read-Write] Option to disable right-click-drag scrolling
        """
        ...
    @allow_right_click_drag_scrolling.setter
    def allow_right_click_drag_scrolling(self, value: bool) -> None:
        ...
    @property
    def wheel_scroll_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] The multiplier to apply when wheel scrolling
        """
        ...
    @wheel_scroll_multiplier.setter
    def wheel_scroll_multiplier(self, value: float) -> None:
        ...
    @property
    def on_user_scrolled(self) -> OnUserScrolledEvent:
        r"""
        (OnUserScrolledEvent):  [Read-Write] Called when the scroll has changed
        """
        ...
    @on_user_scrolled.setter
    def on_user_scrolled(self, value: OnUserScrolledEvent) -> None:
        ...
    @property
    def on_scroll_bar_visibility_changed(self) -> OnScrollBarVisibilityChangedEvent:
        r"""
        (OnScrollBarVisibilityChangedEvent):  [Read-Write] Called when the scrollbar visibility has changed
        """
        ...
    @on_scroll_bar_visibility_changed.setter
    def on_scroll_bar_visibility_changed(self, value: OnScrollBarVisibilityChangedEvent) -> None:
        ...
    def set_wheel_scroll_multiplier(self, new_wheel_scroll_multiplier: float) -> None:
        r"""
        x.set_wheel_scroll_multiplier(new_wheel_scroll_multiplier) -> None
        Set Wheel Scroll Multiplier
        
        Args:
            new_wheel_scroll_multiplier (float):
        """
        ...
    def set_scroll_when_focus_changes(self, new_scroll_when_focus_changes: ScrollWhenFocusChanges) -> None:
        r"""
        x.set_scroll_when_focus_changes(new_scroll_when_focus_changes) -> None
        Set Scroll when Focus Changes
        
        Args:
            new_scroll_when_focus_changes (ScrollWhenFocusChanges):
        """
        ...
    def set_scroll_offset(self, new_scroll_offset: float) -> None:
        r"""
        x.set_scroll_offset(new_scroll_offset) -> None
        Updates the scroll offset of the scrollbox.
        
        Args:
            new_scroll_offset (float): is in Slate Units.
        """
        ...
    def set_scroll_bar_visibility(self, new_scroll_bar_visibility: SlateVisibility) -> None:
        r"""
        x.set_scroll_bar_visibility(new_scroll_bar_visibility) -> None
        Set Scroll Bar Visibility
        
        Args:
            new_scroll_bar_visibility (SlateVisibility):
        """
        ...
    def set_scrollbar_thickness(self, new_scrollbar_thickness: Vector2D) -> None:
        r"""
        x.set_scrollbar_thickness(new_scrollbar_thickness) -> None
        Set Scrollbar Thickness
        
        Args:
            new_scrollbar_thickness (Vector2D):
        """
        ...
    def set_scrollbar_padding(self, new_scrollbar_padding: Margin) -> None:
        r"""
        x.set_scrollbar_padding(new_scrollbar_padding) -> None
        Set Scrollbar Padding
        
        Args:
            new_scrollbar_padding (Margin):
        """
        ...
    def set_orientation(self, new_orientation: Orientation) -> None:
        r"""
        x.set_orientation(new_orientation) -> None
        Set Orientation
        
        Args:
            new_orientation (Orientation):
        """
        ...
    def set_navigation_destination(self, new_navigation_destination: DescendantScrollDestination) -> None:
        r"""
        x.set_navigation_destination(new_navigation_destination) -> None
        Set Navigation Destination
        
        Args:
            new_navigation_destination (DescendantScrollDestination):
        """
        ...
    def set_consume_mouse_wheel(self, new_consume_mouse_wheel: ConsumeMouseWheel) -> None:
        r"""
        x.set_consume_mouse_wheel(new_consume_mouse_wheel) -> None
        Set Consume Mouse Wheel
        
        Args:
            new_consume_mouse_wheel (ConsumeMouseWheel):
        """
        ...
    def set_animate_wheel_scrolling(self, should_animate_wheel_scrolling: bool) -> None:
        r"""
        x.set_animate_wheel_scrolling(should_animate_wheel_scrolling) -> None
        Set Animate Wheel Scrolling
        
        Args:
            should_animate_wheel_scrolling (bool):
        """
        ...
    def set_always_show_scrollbar(self, new_always_show_scrollbar: bool) -> None:
        r"""
        x.set_always_show_scrollbar(new_always_show_scrollbar) -> None
        Set Always Show Scrollbar
        
        Args:
            new_always_show_scrollbar (bool):
        """
        ...
    def set_allow_overscroll(self, new_allow_overscroll: bool) -> None:
        r"""
        x.set_allow_overscroll(new_allow_overscroll) -> None
        Set Allow Overscroll
        
        Args:
            new_allow_overscroll (bool):
        """
        ...
    def scroll_widget_into_view(self, widget_to_find: Widget, animate_scroll: bool = True, scroll_destination: DescendantScrollDestination = DescendantScrollDestination.INTO_VIEW, padding: float = 0.000000) -> None:
        r"""
        x.scroll_widget_into_view(widget_to_find, animate_scroll=True, scroll_destination=DescendantScrollDestination.INTO_VIEW, padding=0.000000) -> None
        Scrolls the ScrollBox to the widget during the next layout pass.
        
        Args:
            widget_to_find (Widget): 
            animate_scroll (bool): 
            scroll_destination (DescendantScrollDestination): 
            padding (float):
        """
        ...
    def scroll_to_start(self) -> None:
        r"""
        x.scroll_to_start() -> None
        Scrolls the ScrollBox to the top instantly
        """
        ...
    def scroll_to_end(self) -> None:
        r"""
        x.scroll_to_end() -> None
        Scrolls the ScrollBox to the bottom instantly during the next layout pass.
        """
        ...
    def get_view_offset_fraction(self) -> float:
        r"""
        x.get_view_offset_fraction() -> float
        Get View Offset Fraction
        
        Returns:
            float:
        """
        ...
    def get_view_fraction(self) -> float:
        r"""
        x.get_view_fraction() -> float
        Gets the fraction currently visible in the scrollbox
        
        Returns:
            float:
        """
        ...
    def get_scroll_offset_of_end(self) -> float:
        r"""
        x.get_scroll_offset_of_end() -> float
        Gets the scroll offset of the bottom of the ScrollBox in Slate Units.
        
        Returns:
            float:
        """
        ...
    def get_scroll_offset(self) -> float:
        r"""
        x.get_scroll_offset() -> float
        Gets the scroll offset of the scrollbox in Slate Units.
        
        Returns:
            float:
        """
        ...
    def end_inertial_scrolling(self) -> None:
        r"""
        x.end_inertial_scrolling() -> None
        Instantly stops any inertial scrolling that is currently in progress
        """
        ...

class ScrollBoxSlot(PanelSlot):
    r"""
    The Slot for the UScrollBox, contains the widget that are scrollable
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: ScrollBoxSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``size`` (SlateChildSize):  [Read-Write] How much space this slot should occupy in the direction of the panel.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def size(self) -> SlateChildSize:
        r"""
        (SlateChildSize):  [Read-Write] How much space this slot should occupy in the direction of the panel.
        """
        ...
    @size.setter
    def size(self, value: SlateChildSize) -> None:
        ...
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Only] The padding area between the slot and the content it contains.
        """
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Only] The alignment of the object horizontally.
        """
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Only] The alignment of the object vertically.
        """
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class SizeBox(ContentWidget):
    r"""
    A widget that allows you to specify the size it reports to have and desire.  Not all widgets report a desired size
    that you actually desire.  Wrapping them in a SizeBox lets you have the Size Box force them to be a particular size.
    
    * Single Child
    * Fixed Size
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SizeBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``height_override`` (float):  [Read-Write] When specified, ignore the content's desired size and report the HeightOverride as the Box's desired height.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``max_aspect_ratio`` (float):  [Read-Write]
    - ``max_desired_height`` (float):  [Read-Write] When specified, will report the MaxDesiredHeight if smaller than the content's desired height.
    - ``max_desired_width`` (float):  [Read-Write] When specified, will report the MaxDesiredWidth if smaller than the content's desired width.
    - ``min_aspect_ratio`` (float):  [Read-Write]
    - ``min_desired_height`` (float):  [Read-Write] When specified, will report the MinDesiredHeight if larger than the content's desired height.
    - ``min_desired_width`` (float):  [Read-Write] When specified, will report the MinDesiredWidth if larger than the content's desired width.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``override_height_override`` (bool):  [Read-Write]
    - ``override_max_aspect_ratio`` (bool):  [Read-Write]
    - ``override_max_desired_height`` (bool):  [Read-Write]
    - ``override_max_desired_width`` (bool):  [Read-Write]
    - ``override_min_aspect_ratio`` (bool):  [Read-Write]
    - ``override_min_desired_height`` (bool):  [Read-Write]
    - ``override_min_desired_width`` (bool):  [Read-Write]
    - ``override_width_override`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``width_override`` (float):  [Read-Write] When specified, ignore the content's desired size and report the WidthOverride as the Box's desired width.
    """
    @property
    def width_override(self) -> float:
        r"""
        (float):  [Read-Write] When specified, ignore the content's desired size and report the WidthOverride as the Box's desired width.
        """
        ...
    @width_override.setter
    def width_override(self, value: float) -> None:
        ...
    @property
    def height_override(self) -> float:
        r"""
        (float):  [Read-Write] When specified, ignore the content's desired size and report the HeightOverride as the Box's desired height.
        """
        ...
    @height_override.setter
    def height_override(self, value: float) -> None:
        ...
    @property
    def min_desired_width(self) -> float:
        r"""
        (float):  [Read-Write] When specified, will report the MinDesiredWidth if larger than the content's desired width.
        """
        ...
    @min_desired_width.setter
    def min_desired_width(self, value: float) -> None:
        ...
    @property
    def min_desired_height(self) -> float:
        r"""
        (float):  [Read-Write] When specified, will report the MinDesiredHeight if larger than the content's desired height.
        """
        ...
    @min_desired_height.setter
    def min_desired_height(self, value: float) -> None:
        ...
    @property
    def max_desired_width(self) -> float:
        r"""
        (float):  [Read-Write] When specified, will report the MaxDesiredWidth if smaller than the content's desired width.
        """
        ...
    @max_desired_width.setter
    def max_desired_width(self, value: float) -> None:
        ...
    @property
    def max_desired_height(self) -> float:
        r"""
        (float):  [Read-Write] When specified, will report the MaxDesiredHeight if smaller than the content's desired height.
        """
        ...
    @max_desired_height.setter
    def max_desired_height(self, value: float) -> None:
        ...
    @property
    def min_aspect_ratio(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @min_aspect_ratio.setter
    def min_aspect_ratio(self, value: float) -> None:
        ...
    @property
    def max_aspect_ratio(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @max_aspect_ratio.setter
    def max_aspect_ratio(self, value: float) -> None:
        ...
    def set_width_override(self, width_override: float) -> None:
        r"""
        x.set_width_override(width_override) -> None
        When specified, ignore the content's desired size and report the WidthOverride as the Box's desired width.
        
        Args:
            width_override (float):
        """
        ...
    def set_min_desired_width(self, min_desired_width: float) -> None:
        r"""
        x.set_min_desired_width(min_desired_width) -> None
        When specified, will report the MinDesiredWidth if larger than the content's desired width.
        
        Args:
            min_desired_width (float):
        """
        ...
    def set_min_desired_height(self, min_desired_height: float) -> None:
        r"""
        x.set_min_desired_height(min_desired_height) -> None
        When specified, will report the MinDesiredHeight if larger than the content's desired height.
        
        Args:
            min_desired_height (float):
        """
        ...
    def set_min_aspect_ratio(self, min_aspect_ratio: float) -> None:
        r"""
        x.set_min_aspect_ratio(min_aspect_ratio) -> None
        Set Min Aspect Ratio
        
        Args:
            min_aspect_ratio (float):
        """
        ...
    def set_max_desired_width(self, max_desired_width: float) -> None:
        r"""
        x.set_max_desired_width(max_desired_width) -> None
        When specified, will report the MaxDesiredWidth if smaller than the content's desired width.
        
        Args:
            max_desired_width (float):
        """
        ...
    def set_max_desired_height(self, max_desired_height: float) -> None:
        r"""
        x.set_max_desired_height(max_desired_height) -> None
        When specified, will report the MaxDesiredHeight if smaller than the content's desired height.
        
        Args:
            max_desired_height (float):
        """
        ...
    def set_max_aspect_ratio(self, max_aspect_ratio: float) -> None:
        r"""
        x.set_max_aspect_ratio(max_aspect_ratio) -> None
        Set Max Aspect Ratio
        
        Args:
            max_aspect_ratio (float):
        """
        ...
    def set_height_override(self, height_override: float) -> None:
        r"""
        x.set_height_override(height_override) -> None
        When specified, ignore the content's desired size and report the HeightOverride as the Box's desired height.
        
        Args:
            height_override (float):
        """
        ...
    def clear_width_override(self) -> None:
        r"""
        x.clear_width_override() -> None
        Clear Width Override
        """
        ...
    def clear_min_desired_width(self) -> None:
        r"""
        x.clear_min_desired_width() -> None
        Clear Min Desired Width
        """
        ...
    def clear_min_desired_height(self) -> None:
        r"""
        x.clear_min_desired_height() -> None
        Clear Min Desired Height
        """
        ...
    def clear_min_aspect_ratio(self) -> None:
        r"""
        x.clear_min_aspect_ratio() -> None
        Clear Min Aspect Ratio
        """
        ...
    def clear_max_desired_width(self) -> None:
        r"""
        x.clear_max_desired_width() -> None
        Clear Max Desired Width
        """
        ...
    def clear_max_desired_height(self) -> None:
        r"""
        x.clear_max_desired_height() -> None
        Clear Max Desired Height
        """
        ...
    def clear_max_aspect_ratio(self) -> None:
        r"""
        x.clear_max_aspect_ratio() -> None
        Clear Max Aspect Ratio
        """
        ...
    def clear_height_override(self) -> None:
        r"""
        x.clear_height_override() -> None
        Clear Height Override
        """
        ...

class SizeBoxSlot(PanelSlot):
    r"""
    The Slot for the USizeBoxSlot, contains the widget displayed in a button's single slot
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SizeBoxSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class Slider(Widget):
    r"""
    A simple widget that shows a sliding bar with a handle that allows you to control the value in a user define range (between 0..1 by default).
    
    * No Children
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Slider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``indent_handle`` (bool):  [Read-Write] Whether the slidable area should be indented to fit the handle.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Should the slider be focusable?
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``locked`` (bool):  [Read-Write] Whether the handle is interactive or fixed.
    - ``max_value`` (float):  [Read-Write] The maximum value the slider can be set to.
    - ``min_value`` (float):  [Read-Write] The minimum value the slider can be set to.
    - ``mouse_uses_step`` (bool):  [Read-Write] Sets new value if mouse position is greater/less than half the step size.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_controller_capture_begin`` (OnControllerCaptureBeginEvent):  [Read-Write] Invoked when the controller capture begins.
    - ``on_controller_capture_end`` (OnControllerCaptureEndEvent):  [Read-Write] Invoked when the controller capture ends.
    - ``on_mouse_capture_begin`` (OnMouseCaptureBeginEvent):  [Read-Write] Invoked when the mouse is pressed and a capture begins.
    - ``on_mouse_capture_end`` (OnMouseCaptureEndEvent):  [Read-Write] Invoked when the mouse is released and a capture ends.
    - ``on_value_changed`` (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
    - ``orientation`` (Orientation):  [Read-Write] The slider's orientation.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``requires_controller_lock`` (bool):  [Read-Write] Sets whether we have to lock input to change the slider value.
    - ``slider_bar_color`` (LinearColor):  [Read-Write] The color to draw the slider bar in.
    - ``slider_handle_color`` (LinearColor):  [Read-Write] The color to draw the slider handle in.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``step_size`` (float):  [Read-Write] The amount to adjust the value by, when using a controller or keyboard
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``value`` (float):  [Read-Write] The volume value to display.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (SliderStyle):  [Read-Write] The progress bar style
    """
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write] The volume value to display.
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def min_value(self) -> float:
        r"""
        (float):  [Read-Write] The minimum value the slider can be set to.
        """
        ...
    @min_value.setter
    def min_value(self, value: float) -> None:
        ...
    @property
    def max_value(self) -> float:
        r"""
        (float):  [Read-Write] The maximum value the slider can be set to.
        """
        ...
    @max_value.setter
    def max_value(self, value: float) -> None:
        ...
    @property
    def widget_style(self) -> SliderStyle:
        r"""
        (SliderStyle):  [Read-Write] The progress bar style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: SliderStyle) -> None:
        ...
    @property
    def orientation(self) -> Orientation:
        r"""
        (Orientation):  [Read-Write] The slider's orientation.
        """
        ...
    @orientation.setter
    def orientation(self, value: Orientation) -> None:
        ...
    @property
    def slider_bar_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color to draw the slider bar in.
        """
        ...
    @slider_bar_color.setter
    def slider_bar_color(self, value: LinearColor) -> None:
        ...
    @property
    def slider_handle_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color to draw the slider handle in.
        """
        ...
    @slider_handle_color.setter
    def slider_handle_color(self, value: LinearColor) -> None:
        ...
    @property
    def indent_handle(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the slidable area should be indented to fit the handle.
        """
        ...
    @indent_handle.setter
    def indent_handle(self, value: bool) -> None:
        ...
    @property
    def locked(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the handle is interactive or fixed.
        """
        ...
    @locked.setter
    def locked(self, value: bool) -> None:
        ...
    @property
    def mouse_uses_step(self) -> bool:
        r"""
        (bool):  [Read-Only] Sets new value if mouse position is greater/less than half the step size.
        """
        ...
    @property
    def requires_controller_lock(self) -> bool:
        r"""
        (bool):  [Read-Only] Sets whether we have to lock input to change the slider value.
        """
        ...
    @property
    def step_size(self) -> float:
        r"""
        (float):  [Read-Write] The amount to adjust the value by, when using a controller or keyboard
        """
        ...
    @step_size.setter
    def step_size(self, value: float) -> None:
        ...
    @property
    def is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Only] Should the slider be focusable?
        """
        ...
    @property
    def on_mouse_capture_begin(self) -> OnMouseCaptureBeginEvent:
        r"""
        (OnMouseCaptureBeginEvent):  [Read-Write] Invoked when the mouse is pressed and a capture begins.
        """
        ...
    @on_mouse_capture_begin.setter
    def on_mouse_capture_begin(self, value: OnMouseCaptureBeginEvent) -> None:
        ...
    @property
    def on_mouse_capture_end(self) -> OnMouseCaptureEndEvent:
        r"""
        (OnMouseCaptureEndEvent):  [Read-Write] Invoked when the mouse is released and a capture ends.
        """
        ...
    @on_mouse_capture_end.setter
    def on_mouse_capture_end(self, value: OnMouseCaptureEndEvent) -> None:
        ...
    @property
    def on_controller_capture_begin(self) -> OnControllerCaptureBeginEvent:
        r"""
        (OnControllerCaptureBeginEvent):  [Read-Write] Invoked when the controller capture begins.
        """
        ...
    @on_controller_capture_begin.setter
    def on_controller_capture_begin(self, value: OnControllerCaptureBeginEvent) -> None:
        ...
    @property
    def on_controller_capture_end(self) -> OnControllerCaptureEndEvent:
        r"""
        (OnControllerCaptureEndEvent):  [Read-Write] Invoked when the controller capture ends.
        """
        ...
    @on_controller_capture_end.setter
    def on_controller_capture_end(self, value: OnControllerCaptureEndEvent) -> None:
        ...
    @property
    def on_value_changed(self) -> OnFloatValueChangedEvent:
        r"""
        (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
        """
        ...
    @on_value_changed.setter
    def on_value_changed(self, value: OnFloatValueChangedEvent) -> None:
        ...
    def set_value(self, value: float) -> None:
        r"""
        x.set_value(value) -> None
        Sets the current value of the slider.
        
        Args:
            value (float):
        """
        ...
    def set_step_size(self, value: float) -> None:
        r"""
        x.set_step_size(value) -> None
        Sets the amount to adjust the value by, when using a controller or keyboard.
        
        Args:
            value (float):
        """
        ...
    def set_slider_handle_color(self, value: LinearColor) -> None:
        r"""
        x.set_slider_handle_color(value) -> None
        Sets the color of the handle bar
        
        Args:
            value (LinearColor):
        """
        ...
    def set_slider_bar_color(self, value: LinearColor) -> None:
        r"""
        x.set_slider_bar_color(value) -> None
        Sets the color of the slider bar.
        
        Args:
            value (LinearColor):
        """
        ...
    def set_min_value(self, value: float) -> None:
        r"""
        x.set_min_value(value) -> None
        Sets the minimum value of the slider.
        
        Args:
            value (float):
        """
        ...
    def set_max_value(self, value: float) -> None:
        r"""
        x.set_max_value(value) -> None
        Sets the maximum value of the slider.
        
        Args:
            value (float):
        """
        ...
    def set_locked(self, value: bool) -> None:
        r"""
        x.set_locked(value) -> None
        Sets the handle to be interactive or fixed.
        
        Args:
            value (bool):
        """
        ...
    def set_indent_handle(self, value: bool) -> None:
        r"""
        x.set_indent_handle(value) -> None
        Sets if the slidable area should be indented to fit the handle.
        
        Args:
            value (bool):
        """
        ...
    def get_value(self) -> float:
        r"""
        x.get_value() -> float
        Gets the current value of the slider.
        
        Returns:
            float:
        """
        ...
    def get_normalized_value(self) -> float:
        r"""
        x.get_normalized_value() -> float
        Get the current value scaled from 0 to 1
        
        Returns:
            float:
        """
        ...

class Spacer(Widget):
    r"""
    A spacer widget; it does not have a visual representation, and just provides padding between other widgets.
    
    * No Children
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Spacer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``size`` (Vector2D):  [Read-Write] The size of the spacer
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def size(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The size of the spacer
        """
        ...
    @size.setter
    def size(self, value: Vector2D) -> None:
        ...
    def set_size(self, size: Vector2D) -> None:
        r"""
        x.set_size(size) -> None
        Sets the size of the spacer
        
        Args:
            size (Vector2D):
        """
        ...

class SpinBox(Widget):
    r"""
    A numerical entry box that allows for direct entry of the number or allows the user to click and slide the number.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SpinBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``always_uses_delta_snap`` (bool):  [Read-Write] Whether this spin box should use the delta snapping logic for typed values - default false
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_keyboard_focus_on_commit`` (bool):  [Read-Write] Whether to remove the keyboard focus from the spin box when the value is committed
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``delta`` (float):  [Read-Write] The amount by which to change the spin box value as the slider moves.
    - ``enable_slider`` (bool):  [Read-Write] Whether this spin box should have slider feature enabled
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``font`` (SlateFontInfo):  [Read-Write] Font color and opacity (overrides style)
    - ``foreground_color`` (SlateColor):  [Read-Write]
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] The justification the value text should appear as.
    - ``keyboard_type`` (VirtualKeyboardType):  [Read-Write] If we're on a platform that requires a virtual keyboard, what kind of keyboard should this widget use?
    - ``max_fractional_digits`` (int32):  [Read-Write] The maximum required fractional digits - default 6
    - ``max_slider_value`` (float):  [Read-Write] The maximum allowable value that can be specified using the slider
    - ``max_value`` (float):  [Read-Write] The maximum allowable value that can be manually entered into the spin box
    - ``min_desired_width`` (float):  [Read-Write] The minimum width of the spin box
    - ``min_fractional_digits`` (int32):  [Read-Write] The minimum required fractional digits - default 1
    - ``min_slider_value`` (float):  [Read-Write] The minimum allowable value that can be specified using the slider
    - ``min_value`` (float):  [Read-Write] The minimum allowable value that can be manually entered into the spin box
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_begin_slider_movement`` (OnSpinBoxBeginSliderMovement):  [Read-Write] Called right before the slider begins to move
    - ``on_end_slider_movement`` (OnSpinBoxValueChangedEvent):  [Read-Write] Called right after the slider handle is released by the user
    - ``on_value_changed`` (OnSpinBoxValueChangedEvent):  [Read-Write] Called when the value is changed interactively by the user
    - ``on_value_committed`` (OnSpinBoxValueCommittedEvent):  [Read-Write] Called when the value is committed. Occurs when the user presses Enter or the text box loses focus.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``override_max_slider_value`` (bool):  [Read-Write] Whether the optional MaxSliderValue attribute of the widget is set
    - ``override_max_value`` (bool):  [Read-Write] Whether the optional MaxValue attribute of the widget is set
    - ``override_min_slider_value`` (bool):  [Read-Write] Whether the optional MinSliderValue attribute of the widget is set
    - ``override_min_value`` (bool):  [Read-Write] Whether the optional MinValue attribute of the widget is set
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``select_all_text_on_commit`` (bool):  [Read-Write] Whether to select the text in the spin box when the value is committed
    - ``slider_exponent`` (float):  [Read-Write] The exponent by which to increase the delta as the mouse moves. 1 is constant (never increases the delta).
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``value`` (float):  [Read-Write] Value stored in this spin box
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (SpinBoxStyle):  [Read-Write] The Style
    """
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write] Value stored in this spin box
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def widget_style(self) -> SpinBoxStyle:
        r"""
        (SpinBoxStyle):  [Read-Write] The Style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: SpinBoxStyle) -> None:
        ...
    @property
    def min_fractional_digits(self) -> int:
        r"""
        (int32):  [Read-Write] The minimum required fractional digits - default 1
        """
        ...
    @min_fractional_digits.setter
    def min_fractional_digits(self, value: int) -> None:
        ...
    @property
    def max_fractional_digits(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum required fractional digits - default 6
        """
        ...
    @max_fractional_digits.setter
    def max_fractional_digits(self, value: int) -> None:
        ...
    @property
    def always_uses_delta_snap(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this spin box should use the delta snapping logic for typed values - default false
        """
        ...
    @always_uses_delta_snap.setter
    def always_uses_delta_snap(self, value: bool) -> None:
        ...
    @property
    def enable_slider(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this spin box should have slider feature enabled
        """
        ...
    @enable_slider.setter
    def enable_slider(self, value: bool) -> None:
        ...
    @property
    def delta(self) -> float:
        r"""
        (float):  [Read-Write] The amount by which to change the spin box value as the slider moves.
        """
        ...
    @delta.setter
    def delta(self, value: float) -> None:
        ...
    @property
    def slider_exponent(self) -> float:
        r"""
        (float):  [Read-Write] The exponent by which to increase the delta as the mouse moves. 1 is constant (never increases the delta).
        """
        ...
    @slider_exponent.setter
    def slider_exponent(self, value: float) -> None:
        ...
    @property
    def font(self) -> SlateFontInfo:
        r"""
        (SlateFontInfo):  [Read-Write] Font color and opacity (overrides style)
        """
        ...
    @font.setter
    def font(self, value: SlateFontInfo) -> None:
        ...
    @property
    def justification(self) -> TextJustify:
        r"""
        (TextJustify):  [Read-Write] The justification the value text should appear as.
        """
        ...
    @justification.setter
    def justification(self, value: TextJustify) -> None:
        ...
    @property
    def min_desired_width(self) -> float:
        r"""
        (float):  [Read-Write] The minimum width of the spin box
        """
        ...
    @min_desired_width.setter
    def min_desired_width(self, value: float) -> None:
        ...
    @property
    def clear_keyboard_focus_on_commit(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to remove the keyboard focus from the spin box when the value is committed
        """
        ...
    @clear_keyboard_focus_on_commit.setter
    def clear_keyboard_focus_on_commit(self, value: bool) -> None:
        ...
    @property
    def select_all_text_on_commit(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to select the text in the spin box when the value is committed
        """
        ...
    @select_all_text_on_commit.setter
    def select_all_text_on_commit(self, value: bool) -> None:
        ...
    @property
    def foreground_color(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write]
        """
        ...
    @foreground_color.setter
    def foreground_color(self, value: SlateColor) -> None:
        ...
    @property
    def on_value_changed(self) -> OnSpinBoxValueChangedEvent:
        r"""
        (OnSpinBoxValueChangedEvent):  [Read-Write] Called when the value is changed interactively by the user
        """
        ...
    @on_value_changed.setter
    def on_value_changed(self, value: OnSpinBoxValueChangedEvent) -> None:
        ...
    @property
    def on_value_committed(self) -> OnSpinBoxValueCommittedEvent:
        r"""
        (OnSpinBoxValueCommittedEvent):  [Read-Write] Called when the value is committed. Occurs when the user presses Enter or the text box loses focus.
        """
        ...
    @on_value_committed.setter
    def on_value_committed(self, value: OnSpinBoxValueCommittedEvent) -> None:
        ...
    @property
    def on_begin_slider_movement(self) -> OnSpinBoxBeginSliderMovement:
        r"""
        (OnSpinBoxBeginSliderMovement):  [Read-Write] Called right before the slider begins to move
        """
        ...
    @on_begin_slider_movement.setter
    def on_begin_slider_movement(self, value: OnSpinBoxBeginSliderMovement) -> None:
        ...
    @property
    def on_end_slider_movement(self) -> OnSpinBoxValueChangedEvent:
        r"""
        (OnSpinBoxValueChangedEvent):  [Read-Write] Called right after the slider handle is released by the user
        """
        ...
    @on_end_slider_movement.setter
    def on_end_slider_movement(self, value: OnSpinBoxValueChangedEvent) -> None:
        ...
    @property
    def min_value(self) -> float:
        r"""
        (float):  [Read-Write] The minimum allowable value that can be manually entered into the spin box
        """
        ...
    @min_value.setter
    def min_value(self, value: float) -> None:
        ...
    @property
    def max_value(self) -> float:
        r"""
        (float):  [Read-Write] The maximum allowable value that can be manually entered into the spin box
        """
        ...
    @max_value.setter
    def max_value(self, value: float) -> None:
        ...
    @property
    def min_slider_value(self) -> float:
        r"""
        (float):  [Read-Write] The minimum allowable value that can be specified using the slider
        """
        ...
    @min_slider_value.setter
    def min_slider_value(self, value: float) -> None:
        ...
    @property
    def max_slider_value(self) -> float:
        r"""
        (float):  [Read-Write] The maximum allowable value that can be specified using the slider
        """
        ...
    @max_slider_value.setter
    def max_slider_value(self, value: float) -> None:
        ...
    def set_value(self, new_value: float) -> None:
        r"""
        x.set_value(new_value) -> None
        Set the value of the spin box.
        
        Args:
            new_value (float):
        """
        ...
    def set_min_value(self, new_value: float) -> None:
        r"""
        x.set_min_value(new_value) -> None
        Set the minimum value that can be manually set in the spin box.
        
        Args:
            new_value (float):
        """
        ...
    def set_min_slider_value(self, new_value: float) -> None:
        r"""
        x.set_min_slider_value(new_value) -> None
        Set the minimum value that can be specified using the slider.
        
        Args:
            new_value (float):
        """
        ...
    def set_max_value(self, new_value: float) -> None:
        r"""
        x.set_max_value(new_value) -> None
        Set the maximum value that can be manually set in the spin box.
        
        Args:
            new_value (float):
        """
        ...
    def set_max_slider_value(self, new_value: float) -> None:
        r"""
        x.set_max_slider_value(new_value) -> None
        Set the maximum value that can be specified using the slider.
        
        Args:
            new_value (float):
        """
        ...
    def set_foreground_color(self, foreground_color: SlateColor) -> None:
        r"""
        x.set_foreground_color(foreground_color) -> None
        Set Foreground Color
        
        Args:
            foreground_color (SlateColor):
        """
        ...
    def get_value(self) -> float:
        r"""
        x.get_value() -> float
        Get the current value of the spin box.
        
        Returns:
            float:
        """
        ...
    def get_min_value(self) -> float:
        r"""
        x.get_min_value() -> float
        Get the current minimum value that can be manually set in the spin box.
        
        Returns:
            float:
        """
        ...
    def get_min_slider_value(self) -> float:
        r"""
        x.get_min_slider_value() -> float
        Get the current minimum value that can be specified using the slider.
        
        Returns:
            float:
        """
        ...
    def get_max_value(self) -> float:
        r"""
        x.get_max_value() -> float
        Get the current maximum value that can be manually set in the spin box.
        
        Returns:
            float:
        """
        ...
    def get_max_slider_value(self) -> float:
        r"""
        x.get_max_slider_value() -> float
        Get the current maximum value that can be specified using the slider.
        
        Returns:
            float:
        """
        ...
    def clear_min_value(self) -> None:
        r"""
        x.clear_min_value() -> None
        Clear the minimum value that can be manually set in the spin box.
        """
        ...
    def clear_min_slider_value(self) -> None:
        r"""
        x.clear_min_slider_value() -> None
        Clear the minimum value that can be specified using the slider.
        """
        ...
    def clear_max_value(self) -> None:
        r"""
        x.clear_max_value() -> None
        Clear the maximum value that can be manually set in the spin box.
        """
        ...
    def clear_max_slider_value(self) -> None:
        r"""
        x.clear_max_slider_value() -> None
        Clear the maximum value that can be specified using the slider.
        """
        ...

class StackBox(PanelWidget):
    r"""
    A stack box widget is a layout panel allowing child widgets to be automatically laid out
    vertically or horizontally.
    
    * Many Children
    * Flows Vertical or Horizontal
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: StackBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``orientation`` (Orientation):  [Read-Write] The orientation of the stack box.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def orientation(self) -> Orientation:
        r"""
        (Orientation):  [Read-Write] The orientation of the stack box.
        """
        ...
    @orientation.setter
    def orientation(self, value: Orientation) -> None:
        ...
    def replace_stack_box_child_at(self, index: int, content: Widget) -> bool:
        r"""
        x.replace_stack_box_child_at(index, content) -> bool
        Replace the widget at the given index it with a different widget.
        
        Args:
            index (int32): 
            content (Widget): 
        
        Returns:
            bool:
        """
        ...
    def add_child_to_stack_box(self, content: Widget) -> StackBoxSlot:
        r"""
        x.add_child_to_stack_box(content) -> StackBoxSlot
        Adds a new child widget to the container.
        
        Args:
            content (Widget): 
        
        Returns:
            StackBoxSlot:
        """
        ...

class StackBoxSlot(PanelSlot):
    r"""
    The Slot for the UStackBox, contains the widget that is flowed vertically or horizontally.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: StackBoxSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``size`` (SlateChildSize):  [Read-Write] How much space this slot should occupy in the direction of the panel.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def size(self) -> SlateChildSize:
        r"""
        (SlateChildSize):  [Read-Write] How much space this slot should occupy in the direction of the panel.
        """
        ...
    @size.setter
    def size(self, value: SlateChildSize) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...

class TextBlock(TextLayoutWidget):
    r"""
    A simple static text widget.
    
    * No Children
    * Text
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: TextBlock.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``apply_line_height_to_bottom_line`` (bool):  [Read-Write] Whether to leave extra space below the last line due to line height.
    - ``auto_wrap_text`` (bool):  [Read-Write] True if we're wrapping text automatically based on the computed horizontal space for this widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``color_and_opacity`` (SlateColor):  [Read-Write] The color of the text
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``font`` (SlateFontInfo):  [Read-Write] The font to render the text with
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] How the text should be aligned with the margin.
    - ``line_height_percentage`` (float):  [Read-Write] The amount to scale each lines height by.
    - ``margin`` (Margin):  [Read-Write] The amount of blank space left around the edges of text area.
    - ``min_desired_width`` (float):  [Read-Write] The minimum desired size for the text
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``shadow_color_and_opacity`` (LinearColor):  [Read-Write] The color of the shadow
    - ``shadow_offset`` (Vector2D):  [Read-Write] The direction the shadow is cast
    - ``shaped_text_options`` (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
    - ``simple_text_mode`` (bool):  [Read-Write] If this is enabled, text shaping, wrapping, justification are disabled in favor of much faster text layout and measurement.
      This feature is only suitable for "simple" text (ie, text containing only numbers or basic ASCII) as it disables the complex text rendering support required for certain languages (such as Arabic and Thai).
      It is significantly faster for text that can take advantage of it (particularly if that text changes frequently), but shouldn't be used for localized user-facing text.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``strike_brush`` (SlateBrush):  [Read-Write] The brush to strike through text with
    - ``text`` (Text):  [Read-Write] The text to display
    - ``text_overflow_policy`` (TextOverflowPolicy):  [Read-Write] Sets what happens to text that is clipped and doesn't fit within the clip rect for this widget
    - ``text_transform_policy`` (TextTransformPolicy):  [Read-Write] The text transformation policy to apply to this text block.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wrap_text_at`` (float):  [Read-Write] Whether text wraps onto a new line when it's length exceeds this width; if this value is zero or negative, no wrapping occurs.
    - ``wrap_with_invalidation_panel`` (bool):  [Read-Write] If true, it will automatically wrap this text widget with an invalidation panel
    - ``wrapping_policy`` (TextWrappingPolicy):  [Read-Write] The wrapping policy to use.
    """
    @property
    def text(self) -> Text:
        r"""
        (Text):  [Read-Write] The text to display
        """
        ...
    @text.setter
    def text(self, value: Text) -> None:
        ...
    @property
    def color_and_opacity(self) -> SlateColor:
        r"""
        (SlateColor):  [Read-Write] The color of the text
        """
        ...
    @color_and_opacity.setter
    def color_and_opacity(self, value: SlateColor) -> None:
        ...
    @property
    def font(self) -> SlateFontInfo:
        r"""
        (SlateFontInfo):  [Read-Write] The font to render the text with
        """
        ...
    @font.setter
    def font(self, value: SlateFontInfo) -> None:
        ...
    @property
    def strike_brush(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The brush to strike through text with
        """
        ...
    @strike_brush.setter
    def strike_brush(self, value: SlateBrush) -> None:
        ...
    @property
    def shadow_offset(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The direction the shadow is cast
        """
        ...
    @shadow_offset.setter
    def shadow_offset(self, value: Vector2D) -> None:
        ...
    @property
    def shadow_color_and_opacity(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color of the shadow
        """
        ...
    @shadow_color_and_opacity.setter
    def shadow_color_and_opacity(self, value: LinearColor) -> None:
        ...
    @property
    def min_desired_width(self) -> float:
        r"""
        (float):  [Read-Write] The minimum desired size for the text
        """
        ...
    @min_desired_width.setter
    def min_desired_width(self, value: float) -> None:
        ...
    @property
    def wrap_with_invalidation_panel(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, it will automatically wrap this text widget with an invalidation panel
        """
        ...
    @property
    def text_transform_policy(self) -> TextTransformPolicy:
        r"""
        (TextTransformPolicy):  [Read-Write] The text transformation policy to apply to this text block.
        """
        ...
    @text_transform_policy.setter
    def text_transform_policy(self, value: TextTransformPolicy) -> None:
        ...
    @property
    def text_overflow_policy(self) -> TextOverflowPolicy:
        r"""
        (TextOverflowPolicy):  [Read-Write] Sets what happens to text that is clipped and doesn't fit within the clip rect for this widget
        """
        ...
    @text_overflow_policy.setter
    def text_overflow_policy(self, value: TextOverflowPolicy) -> None:
        ...
    @property
    def simple_text_mode(self) -> bool:
        r"""
        (bool):  [Read-Only] If this is enabled, text shaping, wrapping, justification are disabled in favor of much faster text layout and measurement.
        This feature is only suitable for "simple" text (ie, text containing only numbers or basic ASCII) as it disables the complex text rendering support required for certain languages (such as Arabic and Thai).
        It is significantly faster for text that can take advantage of it (particularly if that text changes frequently), but shouldn't be used for localized user-facing text.
        """
        ...
    def set_text_transform_policy(self, transform_policy: TextTransformPolicy) -> None:
        r"""
        x.set_text_transform_policy(transform_policy) -> None
        Set the text transformation policy for this text block.
        
        Args:
            transform_policy (TextTransformPolicy): the new text transformation policy.
        """
        ...
    def set_text_overflow_policy(self, overflow_policy: TextOverflowPolicy) -> None:
        r"""
        x.set_text_overflow_policy(overflow_policy) -> None
        Set the text overflow policy for this text block.
        
        Args:
            overflow_policy (TextOverflowPolicy): the new text overflow policy.
        """
        ...
    def set_text(self, text: Text) -> None:
        r"""
        x.set_text(text) -> None
        Directly sets the widget text.
        Warning: This will wipe any binding created for the Text property!
        
        Args:
            text (Text): The text to assign to the widget
        """
        ...
    def set_strike_brush(self, strike_brush: SlateBrush) -> None:
        r"""
        x.set_strike_brush(strike_brush) -> None
        Dynamically set the strike brush for this text block
        
        Args:
            strike_brush (SlateBrush): The new brush to use to strike through text
        """
        ...
    def set_shadow_offset(self, shadow_offset: Vector2D) -> None:
        r"""
        x.set_shadow_offset(shadow_offset) -> None
        Sets the offset that the text drop shadow should be drawn at
        
        Args:
            shadow_offset (Vector2D): The new offset
        """
        ...
    def set_shadow_color_and_opacity(self, shadow_color_and_opacity: LinearColor) -> None:
        r"""
        x.set_shadow_color_and_opacity(shadow_color_and_opacity) -> None
        Sets the color and opacity of the text drop shadow
        Note: if opacity is zero no shadow will be drawn
        
        Args:
            shadow_color_and_opacity (LinearColor): The new drop shadow color and opacity
        """
        ...
    def set_opacity(self, opacity: float) -> None:
        r"""
        x.set_opacity(opacity) -> None
        Sets the opacity of the text in this text block
        
        Args:
            opacity (float): The new text opacity
        """
        ...
    def set_min_desired_width(self, min_desired_width: float) -> None:
        r"""
        x.set_min_desired_width(min_desired_width) -> None
        Set the minimum desired width for this text block
        
        Args:
            min_desired_width (float): new minimum desired width
        """
        ...
    def set_font_outline_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_font_outline_material(material) -> None
        Set Font Outline Material
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_font_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_font_material(material) -> None
        Set Font Material
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_font(self, font_info: SlateFontInfo) -> None:
        r"""
        x.set_font(font_info) -> None
        Dynamically set the font info for this text block
        
        Args:
            font_info (SlateFontInfo): The new font info
        """
        ...
    def set_color_and_opacity(self, color_and_opacity: SlateColor) -> None:
        r"""
        x.set_color_and_opacity(color_and_opacity) -> None
        Sets the color and opacity of the text in this text block
        
        Args:
            color_and_opacity (SlateColor): The new text color and opacity
        """
        ...
    def set_auto_wrap_text(self, auto_text_wrap: bool) -> None:
        r"""
        x.set_auto_wrap_text(auto_text_wrap) -> None
        Set the auto wrap for this text block.
        
        Args:
            auto_text_wrap (bool): to turn wrap on or off.
        """
        ...
    def get_text(self) -> Text:
        r"""
        x.get_text() -> Text
        Gets the widget text
        
        Returns:
            Text: The widget text
        """
        ...
    def get_dynamic_outline_material(self) -> MaterialInstanceDynamic:
        r"""
        x.get_dynamic_outline_material() -> MaterialInstanceDynamic
        Get Dynamic Outline Material
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...
    def get_dynamic_font_material(self) -> MaterialInstanceDynamic:
        r"""
        x.get_dynamic_font_material() -> MaterialInstanceDynamic
        Get Dynamic Font Material
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...

class Throbber(Widget):
    r"""
    A Throbber widget that shows several zooming circles in a row.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Throbber.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``animate_horizontally`` (bool):  [Read-Write] Should the pieces animate horizontally?
    - ``animate_opacity`` (bool):  [Read-Write] Should the pieces animate their opacity?
    - ``animate_vertically`` (bool):  [Read-Write] Should the pieces animate vertically?
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``image`` (SlateBrush):  [Read-Write] The animated pieces.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``number_of_pieces`` (int32):  [Read-Write] How many pieces there are
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def number_of_pieces(self) -> int:
        r"""
        (int32):  [Read-Write] How many pieces there are
        """
        ...
    @number_of_pieces.setter
    def number_of_pieces(self, value: int) -> None:
        ...
    @property
    def animate_horizontally(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the pieces animate horizontally?
        """
        ...
    @animate_horizontally.setter
    def animate_horizontally(self, value: bool) -> None:
        ...
    @property
    def animate_vertically(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the pieces animate vertically?
        """
        ...
    @animate_vertically.setter
    def animate_vertically(self, value: bool) -> None:
        ...
    @property
    def animate_opacity(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the pieces animate their opacity?
        """
        ...
    @animate_opacity.setter
    def animate_opacity(self, value: bool) -> None:
        ...
    @property
    def image(self) -> SlateBrush:
        r"""
        (SlateBrush):  [Read-Write] The animated pieces.
        """
        ...
    @image.setter
    def image(self, value: SlateBrush) -> None:
        ...
    def set_number_of_pieces(self, number_of_pieces: int) -> None:
        r"""
        x.set_number_of_pieces(number_of_pieces) -> None
        Sets how many pieces there are
        
        Args:
            number_of_pieces (int32):
        """
        ...
    def set_animate_vertically(self, animate_vertically: bool) -> None:
        r"""
        x.set_animate_vertically(animate_vertically) -> None
        Sets whether the pieces animate vertically.
        
        Args:
            animate_vertically (bool):
        """
        ...
    def set_animate_opacity(self, animate_opacity: bool) -> None:
        r"""
        x.set_animate_opacity(animate_opacity) -> None
        Sets whether the pieces animate their opacity.
        
        Args:
            animate_opacity (bool):
        """
        ...
    def set_animate_horizontally(self, animate_horizontally: bool) -> None:
        r"""
        x.set_animate_horizontally(animate_horizontally) -> None
        Sets whether the pieces animate horizontally.
        
        Args:
            animate_horizontally (bool):
        """
        ...

class TileView(ListView):
    r"""
    A ListView that presents the contents as a set of tiles all uniformly sized.
    
    To make a widget usable as an entry in a TileView, it must inherit from the IUserObjectListEntry interface.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: TileView.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_dragging`` (bool):  [Read-Write] True to allow dragging of row widgets in the list
    - ``allow_overscroll`` (bool):  [Read-Write] Disable to stop scrollbars from activating inertial overscrolling
    - ``bp_on_entry_generated`` (OnListEntryGeneratedDynamic):  [Read-Write] Called when a row widget is generated for a list item
    - ``bp_on_entry_initialized`` (OnListEntryInitializedDynamic):  [Read-Write] Called when a row widget is generated for a list item
    - ``bp_on_entry_released`` (OnListEntryReleasedDynamic):  [Read-Write] Called when a row widget is released by the list (i.e. when it no longer represents a list item)
    - ``bp_on_item_clicked`` (SimpleListItemEventDynamic):  [Read-Write]
    - ``bp_on_item_double_clicked`` (SimpleListItemEventDynamic):  [Read-Write]
    - ``bp_on_item_is_hovered_changed`` (OnItemIsHoveredChangedDynamic):  [Read-Write]
    - ``bp_on_item_scrolled_into_view`` (OnListItemScrolledIntoViewDynamic):  [Read-Write]
    - ``bp_on_item_selection_changed`` (OnListItemSelectionChangedDynamic):  [Read-Write]
    - ``bp_on_list_view_scrolled`` (OnListViewScrolledDynamic):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_selection_on_click`` (bool):  [Read-Write]
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``consume_mouse_wheel`` (ConsumeMouseWheel):  [Read-Write]
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``enable_fixed_line_offset`` (bool):  [Read-Write]
    - ``enable_right_click_scrolling`` (bool):  [Read-Write] True to allow right click drag scrolling.
    - ``enable_scroll_animation`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list
    - ``enable_touch_animated_scrolling`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list with touch
    - ``enable_touch_scrolling`` (bool):  [Read-Write] True to allow scrolling using touch input.
    - ``entry_height`` (float):  [Read-Write] The height of each tile
    - ``entry_size_includes_entry_spacing`` (bool):  [Read-Write] True if entry dimensions should be the sum of the entry widget dimensions and the spacing.
      This means the size of the entry widget will be adjusted so that the summation of the widget size and entry spacing always equals entry size.
    - ``entry_spacing`` (float):  [Read-Write] This deprecated property was originally BlueprintReadOnly. To satisfy the compiler requirment to have a BlueprintGetter for this property,
      it relies on the newly added UFunction GetHorizontalEntrySpacing() to act as its BlueprintGetter.
      deprecated: EntrySpacing has been deprecated. Please use HorizontalEntrySpacing and VerticalEntrySpacing.
    - ``entry_widget_class`` (type(Class)):  [Read-Write] The type of widget to create for each entry displayed in the list.
    - ``entry_width`` (float):  [Read-Write] The width of each tile
    - ``fixed_line_scroll_offset`` (float):  [Read-Write] Optional fixed offset (in lines) to always apply to the top/left (depending on orientation) of the list.
      If provided, all non-inertial means of scrolling will settle with exactly this offset of the topmost entry.
      Ex: A value of 0.25 would cause the topmost full entry to be offset down by a quarter length of the preceeding entry.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``horizontal_entry_spacing`` (float):  [Read-Write]
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write]
    - ``is_pointer_scrolling_enabled`` (bool):  [Read-Write] Enable/Disable scrolling using Touch or Mouse.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``num_designer_preview_entries`` (int32):  [Read-Write] The number of dummy item entry widgets to preview in the widget designer
    - ``orientation`` (Orientation):  [Read-Write] The scroll & layout orientation of the list. ListView and TileView only.
      Vertical will scroll vertically and arrange tiles into rows.
      Horizontal will scroll horizontally and arrange tiles into columns.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``return_focus_to_selection`` (bool):  [Read-Write]
    - ``scroll_bar_style`` (ScrollBarStyle):  [Read-Write]
    - ``scrollbar_disabled_visibility`` (SlateVisibility):  [Read-Write] Set the visibility of the Scrollbar when it's not needed
    - ``selection_mode`` (SelectionMode):  [Read-Write]
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tile_alignment`` (ListItemAlignment):  [Read-Write] The method by which to align the tile entries in the available space for the tile view
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``vertical_entry_spacing`` (float):  [Read-Write]
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wheel_scroll_multiplier`` (float):  [Read-Write] The multiplier to apply when wheel scrolling
    - ``widget_style`` (TableViewStyle):  [Read-Write]
    - ``wrap_horizontal_navigation`` (bool):  [Read-Write] True to allow left/right navigation to wrap back to the tile on the opposite edge
    """
    def set_entry_width(self, new_width: float) -> None:
        r"""
        x.set_entry_width(new_width) -> None
        Sets the width of every tile entry
        
        Args:
            new_width (float):
        """
        ...
    def set_entry_height(self, new_height: float) -> None:
        r"""
        x.set_entry_height(new_height) -> None
        Sets the height of every tile entry
        
        Args:
            new_height (float):
        """
        ...
    def get_entry_width(self) -> float:
        r"""
        x.get_entry_width() -> float
        Gets the width of tile entries
        
        Returns:
            float:
        """
        ...
    def get_entry_height(self) -> float:
        r"""
        x.get_entry_height() -> float
        Gets the height of tile entries
        
        Returns:
            float:
        """
        ...

class TreeView(ListView):
    r"""
    Similar to ListView, but can display a hierarchical tree of elements.
    The base items source for the tree identifies the root items, each of which can have n associated child items.
    There is no hard limit to the nesting - child items can have children and so on
    
    To make a widget usable as an entry in a TreeView, it must inherit from the IUserObjectListEntry interface.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: TreeView.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_dragging`` (bool):  [Read-Write] True to allow dragging of row widgets in the list
    - ``allow_overscroll`` (bool):  [Read-Write] Disable to stop scrollbars from activating inertial overscrolling
    - ``bp_on_entry_generated`` (OnListEntryGeneratedDynamic):  [Read-Write] Called when a row widget is generated for a list item
    - ``bp_on_entry_initialized`` (OnListEntryInitializedDynamic):  [Read-Write] Called when a row widget is generated for a list item
    - ``bp_on_entry_released`` (OnListEntryReleasedDynamic):  [Read-Write] Called when a row widget is released by the list (i.e. when it no longer represents a list item)
    - ``bp_on_get_item_children`` (OnGetItemChildrenDynamic):  [Read-Write] Called to get the list of children (if any) that correspond to the given item. Only called if the native C++ version of the event is not bound.
    - ``bp_on_item_clicked`` (SimpleListItemEventDynamic):  [Read-Write]
    - ``bp_on_item_double_clicked`` (SimpleListItemEventDynamic):  [Read-Write]
    - ``bp_on_item_expansion_changed`` (OnItemExpansionChangedDynamic):  [Read-Write]
    - ``bp_on_item_is_hovered_changed`` (OnItemIsHoveredChangedDynamic):  [Read-Write]
    - ``bp_on_item_scrolled_into_view`` (OnListItemScrolledIntoViewDynamic):  [Read-Write]
    - ``bp_on_item_selection_changed`` (OnListItemSelectionChangedDynamic):  [Read-Write]
    - ``bp_on_list_view_scrolled`` (OnListViewScrolledDynamic):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_selection_on_click`` (bool):  [Read-Write]
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``consume_mouse_wheel`` (ConsumeMouseWheel):  [Read-Write]
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``enable_fixed_line_offset`` (bool):  [Read-Write]
    - ``enable_right_click_scrolling`` (bool):  [Read-Write] True to allow right click drag scrolling.
    - ``enable_scroll_animation`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list
    - ``enable_touch_animated_scrolling`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list with touch
    - ``enable_touch_scrolling`` (bool):  [Read-Write] True to allow scrolling using touch input.
    - ``entry_spacing`` (float):  [Read-Write] This deprecated property was originally BlueprintReadOnly. To satisfy the compiler requirment to have a BlueprintGetter for this property,
      it relies on the newly added UFunction GetHorizontalEntrySpacing() to act as its BlueprintGetter.
      deprecated: EntrySpacing has been deprecated. Please use HorizontalEntrySpacing and VerticalEntrySpacing.
    - ``entry_widget_class`` (type(Class)):  [Read-Write] The type of widget to create for each entry displayed in the list.
    - ``fixed_line_scroll_offset`` (float):  [Read-Write] Optional fixed offset (in lines) to always apply to the top/left (depending on orientation) of the list.
      If provided, all non-inertial means of scrolling will settle with exactly this offset of the topmost entry.
      Ex: A value of 0.25 would cause the topmost full entry to be offset down by a quarter length of the preceeding entry.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``horizontal_entry_spacing`` (float):  [Read-Write]
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write]
    - ``is_pointer_scrolling_enabled`` (bool):  [Read-Write] Enable/Disable scrolling using Touch or Mouse.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``num_designer_preview_entries`` (int32):  [Read-Write] The number of dummy item entry widgets to preview in the widget designer
    - ``orientation`` (Orientation):  [Read-Write] The scroll & layout orientation of the list. ListView and TileView only.
      Vertical will scroll vertically and arrange tiles into rows.
      Horizontal will scroll horizontally and arrange tiles into columns.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``return_focus_to_selection`` (bool):  [Read-Write]
    - ``scroll_bar_style`` (ScrollBarStyle):  [Read-Write]
    - ``selection_mode`` (SelectionMode):  [Read-Write]
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``vertical_entry_spacing`` (float):  [Read-Write]
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wheel_scroll_multiplier`` (float):  [Read-Write] The multiplier to apply when wheel scrolling
    - ``widget_style`` (TableViewStyle):  [Read-Write]
    """
    @property
    def bp_on_item_expansion_changed(self) -> OnItemExpansionChangedDynamic:
        r"""
        (OnItemExpansionChangedDynamic):  [Read-Write]
        """
        ...
    @bp_on_item_expansion_changed.setter
    def bp_on_item_expansion_changed(self, value: OnItemExpansionChangedDynamic) -> None:
        ...
    def set_item_expansion(self, item: Object, expand_item: bool) -> None:
        r"""
        x.set_item_expansion(item, expand_item) -> None
        Attempts to expand/collapse the given item (only relevant if the item has children)
        
        Args:
            item (Object): 
            expand_item (bool):
        """
        ...
    def expand_all(self) -> None:
        r"""
        x.expand_all() -> None
        Expands all items with children
        """
        ...
    def collapse_all(self) -> None:
        r"""
        x.collapse_all() -> None
        Collapses all currently expanded items
        """
        ...

class UniformGridPanel(PanelWidget):
    r"""
    A panel that evenly divides up available space between all of its children.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UniformGridPanel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``min_desired_slot_height`` (float):  [Read-Write] The minimum desired height of the slots
    - ``min_desired_slot_width`` (float):  [Read-Write] The minimum desired width of the slots
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``slot_padding`` (Margin):  [Read-Write] Padding given to each slot
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def slot_padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] Padding given to each slot
        """
        ...
    @slot_padding.setter
    def slot_padding(self, value: Margin) -> None:
        ...
    @property
    def min_desired_slot_width(self) -> float:
        r"""
        (float):  [Read-Write] The minimum desired width of the slots
        """
        ...
    @min_desired_slot_width.setter
    def min_desired_slot_width(self, value: float) -> None:
        ...
    @property
    def min_desired_slot_height(self) -> float:
        r"""
        (float):  [Read-Write] The minimum desired height of the slots
        """
        ...
    @min_desired_slot_height.setter
    def min_desired_slot_height(self, value: float) -> None:
        ...
    def set_slot_padding(self, slot_padding: Margin) -> None:
        r"""
        x.set_slot_padding(slot_padding) -> None
        Set Slot Padding
        
        Args:
            slot_padding (Margin):
        """
        ...
    def set_min_desired_slot_width(self, min_desired_slot_width: float) -> None:
        r"""
        x.set_min_desired_slot_width(min_desired_slot_width) -> None
        Set Min Desired Slot Width
        
        Args:
            min_desired_slot_width (float):
        """
        ...
    def set_min_desired_slot_height(self, min_desired_slot_height: float) -> None:
        r"""
        x.set_min_desired_slot_height(min_desired_slot_height) -> None
        Set Min Desired Slot Height
        
        Args:
            min_desired_slot_height (float):
        """
        ...
    def add_child_to_uniform_grid(self, content: Widget, row: int = 0, column: int = 0) -> UniformGridSlot:
        r"""
        x.add_child_to_uniform_grid(content, row=0, column=0) -> UniformGridSlot
        Add Child to Uniform Grid
        
        Args:
            content (Widget): 
            row (int32): 
            column (int32): 
        
        Returns:
            UniformGridSlot:
        """
        ...

class UniformGridSlot(PanelSlot):
    r"""
    A slot for UUniformGridPanel, these slots all share the same size as the largest slot
    in the grid.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UniformGridSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``column`` (int32):  [Read-Write] The column index of the cell this slot is in
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``row`` (int32):  [Read-Write] The row index of the cell this slot is in
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    @property
    def row(self) -> int:
        r"""
        (int32):  [Read-Write] The row index of the cell this slot is in
        """
        ...
    @row.setter
    def row(self, value: int) -> None:
        ...
    @property
    def column(self) -> int:
        r"""
        (int32):  [Read-Write] The column index of the cell this slot is in
        """
        ...
    @column.setter
    def column(self, value: int) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_row(self, row: int) -> None:
        r"""
        x.set_row(row) -> None
        Sets the row index of the slot, this determines what cell the slot is in the panel
        
        Args:
            row (int32):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...
    def set_column(self, column: int) -> None:
        r"""
        x.set_column(column) -> None
        Sets the column index of the slot, this determines what cell the slot is in the panel
        
        Args:
            column (int32):
        """
        ...

class VerticalBox(PanelWidget):
    r"""
    A vertical box widget is a layout panel allowing child widgets to be automatically laid out
    vertically.
    
    * Many Children
    * Flows Vertical
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: VerticalBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    def add_child_to_vertical_box(self, content: Widget) -> VerticalBoxSlot:
        r"""
        x.add_child_to_vertical_box(content) -> VerticalBoxSlot
        Add Child to Vertical Box
        
        Args:
            content (Widget): 
        
        Returns:
            VerticalBoxSlot:
        """
        ...
    def add_child_vertical_box(self, content: Widget) -> VerticalBoxSlot:
        r"""
        deprecated: 'add_child_vertical_box' was renamed to 'add_child_to_vertical_box'.
        """
        ...

class VerticalBoxSlot(PanelSlot):
    r"""
    The Slot for the UVerticalBox, contains the widget that is flowed vertically
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: VerticalBoxSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``size`` (SlateChildSize):  [Read-Write] How much space this slot should occupy in the direction of the panel.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def size(self) -> SlateChildSize:
        r"""
        (SlateChildSize):  [Read-Write] How much space this slot should occupy in the direction of the panel.
        """
        ...
    @size.setter
    def size(self, value: SlateChildSize) -> None:
        ...
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_size(self, size: SlateChildSize) -> None:
        r"""
        x.set_size(size) -> None
        Set Size
        
        Args:
            size (SlateChildSize):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class Viewport(ContentWidget):
    r"""
    Viewport
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: Viewport.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``background_color`` (LinearColor):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def background_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @background_color.setter
    def background_color(self, value: LinearColor) -> None:
        ...
    def spawn(self, actor_class: Class) -> Actor:
        r"""
        x.spawn(actor_class) -> Actor
        Spawn
        
        Args:
            actor_class (type(Class)): 
        
        Returns:
            Actor:
        """
        ...
    def set_view_rotation(self, rotation: Rotator) -> None:
        r"""
        x.set_view_rotation(rotation) -> None
        Set View Rotation
        
        Args:
            rotation (Rotator):
        """
        ...
    def set_view_location(self, location: Vector) -> None:
        r"""
        x.set_view_location(location) -> None
        Set View Location
        
        Args:
            location (Vector):
        """
        ...
    def set_sky_intensity(self, light_intensity: float) -> None:
        r"""
        x.set_sky_intensity(light_intensity) -> None
        Set Sky Intensity
        
        Args:
            light_intensity (float):
        """
        ...
    def set_show_flag(self, show_flag_name: str, value: bool) -> None:
        r"""
        x.set_show_flag(show_flag_name, value) -> None
        Set Show Flag
        
        Args:
            show_flag_name (str): 
            value (bool):
        """
        ...
    def set_light_intensity(self, light_intensity: float) -> None:
        r"""
        x.set_light_intensity(light_intensity) -> None
        Set Light Intensity
        
        Args:
            light_intensity (float):
        """
        ...
    def set_enable_advanced_features(self, enable_advanced_features: bool) -> None:
        r"""
        x.set_enable_advanced_features(enable_advanced_features) -> None
        Set Enable Advanced Features
        
        Args:
            enable_advanced_features (bool):
        """
        ...
    def get_view_rotation(self) -> Rotator:
        r"""
        x.get_view_rotation() -> Rotator
        Get View Rotation
        
        Returns:
            Rotator:
        """
        ...
    def get_viewport_world(self) -> World:
        r"""
        x.get_viewport_world() -> World
        Get Viewport World
        
        Returns:
            World:
        """
        ...
    def get_view_location(self) -> Vector:
        r"""
        x.get_view_location() -> Vector
        Get View Location
        
        Returns:
            Vector:
        """
        ...

class WidgetInteractionComponent(SceneComponent):
    r"""
    This is a component to allow interaction with the Widget Component.  This class allows you to
    simulate a sort of laser pointer device, when it hovers over widgets it will send the basic signals
    to show as if the mouse were moving on top of it.  You'll then tell the component to simulate key presses,
    like Left Mouse, down and up, to simulate a mouse click.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetInteractionComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``debug_color`` (LinearColor):  [Read-Write] Determines the color of the debug lines.
    - ``debug_line_thickness`` (float):  [Read-Write] Determines the thickness of the debug lines.
    - ``debug_sphere_line_thickness`` (float):  [Read-Write] Determines the line thickness of the debug sphere.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_hit_testing`` (bool):  [Read-Write] Should the interaction component perform hit testing (Automatic or Custom) and attempt to
      simulate hover - if you were going to emulate a keyboard you would want to turn this option off
      if the virtual keyboard was separate from the virtual pointer device and used a second interaction
      component.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``interaction_distance`` (float):  [Read-Write] The distance in game units the component should be able to interact with a widget component.
    - ``interaction_source`` (WidgetInteractionSource):  [Read-Write] Should we project from the world location of the component?  If you set this to false, you'll
      need to call SetCustomHitResult(), and provide the result of a custom hit test form whatever
      location you wish.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_hovered_widget_changed`` (OnHoveredWidgetChanged):  [Read-Write] Called when the hovered Widget Component changes.  The interaction component functions at the Slate
      level - so it's unable to report anything about what UWidget is under the hit result.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pointer_index`` (int32):  [Read-Write] Each user virtual controller or virtual finger tips being simulated should use a different pointer index.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``show_debug`` (bool):  [Read-Write] Shows some debugging lines and a hit sphere to help you debug interactions.
    - ``trace_channel`` (CollisionChannel):  [Read-Write] The trace channel to use when tracing for widget components in the world.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_user_index`` (int32):  [Read-Write] Represents the Virtual User Index.  Each virtual user should be represented by a different
      index number, this will maintain separate capture and focus states for them.  Each
      controller or finger-tip should get a unique PointerIndex.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def on_hovered_widget_changed(self) -> OnHoveredWidgetChanged:
        r"""
        (OnHoveredWidgetChanged):  [Read-Write] Called when the hovered Widget Component changes.  The interaction component functions at the Slate
        level - so it's unable to report anything about what UWidget is under the hit result.
        """
        ...
    @on_hovered_widget_changed.setter
    def on_hovered_widget_changed(self, value: OnHoveredWidgetChanged) -> None:
        ...
    @property
    def virtual_user_index(self) -> int:
        r"""
        (int32):  [Read-Write] Represents the Virtual User Index.  Each virtual user should be represented by a different
        index number, this will maintain separate capture and focus states for them.  Each
        controller or finger-tip should get a unique PointerIndex.
        """
        ...
    @virtual_user_index.setter
    def virtual_user_index(self, value: int) -> None:
        ...
    @property
    def pointer_index(self) -> int:
        r"""
        (int32):  [Read-Write] Each user virtual controller or virtual finger tips being simulated should use a different pointer index.
        """
        ...
    @pointer_index.setter
    def pointer_index(self, value: int) -> None:
        ...
    @property
    def trace_channel(self) -> CollisionChannel:
        r"""
        (CollisionChannel):  [Read-Write] The trace channel to use when tracing for widget components in the world.
        """
        ...
    @trace_channel.setter
    def trace_channel(self, value: CollisionChannel) -> None:
        ...
    @property
    def interaction_distance(self) -> float:
        r"""
        (float):  [Read-Write] The distance in game units the component should be able to interact with a widget component.
        """
        ...
    @interaction_distance.setter
    def interaction_distance(self, value: float) -> None:
        ...
    @property
    def interaction_source(self) -> WidgetInteractionSource:
        r"""
        (WidgetInteractionSource):  [Read-Write] Should we project from the world location of the component?  If you set this to false, you'll
        need to call SetCustomHitResult(), and provide the result of a custom hit test form whatever
        location you wish.
        """
        ...
    @interaction_source.setter
    def interaction_source(self, value: WidgetInteractionSource) -> None:
        ...
    @property
    def enable_hit_testing(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the interaction component perform hit testing (Automatic or Custom) and attempt to
        simulate hover - if you were going to emulate a keyboard you would want to turn this option off
        if the virtual keyboard was separate from the virtual pointer device and used a second interaction
        component.
        """
        ...
    @enable_hit_testing.setter
    def enable_hit_testing(self, value: bool) -> None:
        ...
    @property
    def show_debug(self) -> bool:
        r"""
        (bool):  [Read-Write] Shows some debugging lines and a hit sphere to help you debug interactions.
        """
        ...
    @show_debug.setter
    def show_debug(self, value: bool) -> None:
        ...
    @property
    def debug_sphere_line_thickness(self) -> float:
        r"""
        (float):  [Read-Write] Determines the line thickness of the debug sphere.
        """
        ...
    @debug_sphere_line_thickness.setter
    def debug_sphere_line_thickness(self, value: float) -> None:
        ...
    @property
    def debug_line_thickness(self) -> float:
        r"""
        (float):  [Read-Write] Determines the thickness of the debug lines.
        """
        ...
    @debug_line_thickness.setter
    def debug_line_thickness(self, value: float) -> None:
        ...
    @property
    def debug_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Determines the color of the debug lines.
        """
        ...
    @debug_color.setter
    def debug_color(self, value: LinearColor) -> None:
        ...
    def set_focus(self, focus_widget: Widget) -> None:
        r"""
        x.set_focus(focus_widget) -> None
        Set the focus target of the virtual user managed by this component
        
        Args:
            focus_widget (Widget):
        """
        ...
    def set_custom_hit_result(self, hit_result: HitResult) -> None:
        r"""
        x.set_custom_hit_result(hit_result) -> None
        Set custom hit result.  This is only taken into account if InteractionSource is set to EWidgetInteractionSource::Custom.
        
        Args:
            hit_result (HitResult):
        """
        ...
    def send_key_char(self, characters: str, repeat: bool = False) -> bool:
        r"""
        x.send_key_char(characters, repeat=False) -> bool
        Transmits a list of characters to a widget by simulating a OnKeyChar event for each key listed in
        the string.
        
        Args:
            characters (str): 
            repeat (bool): 
        
        Returns:
            bool:
        """
        ...
    def scroll_wheel(self, scroll_delta: float) -> None:
        r"""
        x.scroll_wheel(scroll_delta) -> None
        Sends a scroll wheel event to the widget under the last hit result.
        
        Args:
            scroll_delta (float):
        """
        ...
    def release_pointer_key(self, key: Key) -> None:
        r"""
        x.release_pointer_key(key) -> None
        Releases a key as if the mouse/pointer were the source of it.  Normally you would just use
        Left/Right mouse button for the Key.  However - advanced uses could also be imagined where you
        send other keys to signal widgets to take special actions if they're under the cursor.
        
        Args:
            key (Key):
        """
        ...
    def release_key(self, key: Key) -> bool:
        r"""
        x.release_key(key) -> bool
        Releases a key as if it had been released by the keyboard.
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    def press_pointer_key(self, key: Key) -> None:
        r"""
        x.press_pointer_key(key) -> None
        Presses a key as if the mouse/pointer were the source of it.  Normally you would just use
        Left/Right mouse button for the Key.  However - advanced uses could also be imagined where you
        send other keys to signal widgets to take special actions if they're under the cursor.
        
        Args:
            key (Key):
        """
        ...
    def press_key(self, key: Key, repeat: bool = False) -> bool:
        r"""
        x.press_key(key, repeat=False) -> bool
        Press a key as if it had come from the keyboard.  Avoid using this for 'a-z|A-Z', things like
        the Editable Textbox in Slate expect OnKeyChar to be called to signal a specific character being
        send to the widget.  So for those cases you should use SendKeyChar.
        
        Args:
            key (Key): 
            repeat (bool): 
        
        Returns:
            bool:
        """
        ...
    def press_and_release_key(self, key: Key) -> bool:
        r"""
        x.press_and_release_key(key) -> bool
        Does both the press and release of a simulated keyboard key.
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    def is_over_interactable_widget(self) -> bool:
        r"""
        x.is_over_interactable_widget() -> bool
        Returns true if a widget under the hit result is interactive.  e.g. Slate widgets
        that return true for IsInteractable().
        
        Returns:
            bool:
        """
        ...
    def is_over_hit_test_visible_widget(self) -> bool:
        r"""
        x.is_over_hit_test_visible_widget() -> bool
        Returns true if a widget under the hit result is has a visibility that makes it hit test
        visible.  e.g. Slate widgets that return true for GetVisibility().IsHitTestVisible().
        
        Returns:
            bool:
        """
        ...
    def is_over_focusable_widget(self) -> bool:
        r"""
        x.is_over_focusable_widget() -> bool
        Returns true if a widget under the hit result is focusable.  e.g. Slate widgets that
        return true for SupportsKeyboardFocus().
        
        Returns:
            bool:
        """
        ...
    def get_last_hit_result(self) -> HitResult:
        r"""
        x.get_last_hit_result() -> HitResult
        Gets the last hit result generated by the component.  Returns the custom hit result if that was set.
        
        Returns:
            HitResult:
        """
        ...
    def get_hovered_widget_component(self) -> WidgetComponent:
        r"""
        x.get_hovered_widget_component() -> WidgetComponent
        Get the currently hovered widget component.
        
        Returns:
            WidgetComponent:
        """
        ...
    def get2d_hit_location(self) -> Vector2D:
        r"""
        x.get2d_hit_location() -> Vector2D
        Gets the last hit location on the widget in 2D, local pixel units of the render target.
        
        Returns:
            Vector2D:
        """
        ...

class WidgetSwitcher(PanelWidget):
    r"""
    A widget switcher is like a tab control, but without tabs. At most one widget is visible at time.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetSwitcher.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``active_widget_index`` (int32):  [Read-Write] The slot index to display
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def active_widget_index(self) -> int:
        r"""
        (int32):  [Read-Write] The slot index to display
        """
        ...
    @active_widget_index.setter
    def active_widget_index(self, value: int) -> None:
        ...
    def set_active_widget_index(self, index: int) -> None:
        r"""
        x.set_active_widget_index(index) -> None
        Activates the widget at the specified index.
        
        Args:
            index (int32):
        """
        ...
    def set_active_widget(self, widget: Widget) -> None:
        r"""
        x.set_active_widget(widget) -> None
        Activates the widget and makes it the active index.
        
        Args:
            widget (Widget):
        """
        ...
    def get_widget_at_index(self, index: int) -> Widget:
        r"""
        x.get_widget_at_index(index) -> Widget
        Get a widget at the provided index
        
        Args:
            index (int32): 
        
        Returns:
            Widget:
        """
        ...
    def get_num_widgets(self) -> int:
        r"""
        x.get_num_widgets() -> int32
        Gets the number of widgets that this switcher manages.
        
        Returns:
            int32:
        """
        ...
    def get_active_widget_index(self) -> int:
        r"""
        x.get_active_widget_index() -> int32
        Gets the slot index of the currently active widget
        
        Returns:
            int32:
        """
        ...
    def get_active_widget(self) -> Widget:
        r"""
        x.get_active_widget() -> Widget
        Get the reference of the currently active widget
        
        Returns:
            Widget:
        """
        ...

class WidgetSwitcherSlot(PanelSlot):
    r"""
    The Slot for the UWidgetSwitcher, contains the widget that is flowed vertically
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetSwitcherSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class WindowTitleBarArea(ContentWidget):
    r"""
    A panel for defining a region of the UI that should allow users to drag the window on desktop platforms.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WindowTitleBarArea.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``double_click_toggles_fullscreen`` (bool):  [Read-Write] Should double clicking the title bar area toggle fullscreen instead of maximizing the window.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``window_buttons_enabled`` (bool):  [Read-Write] Should the title bar area diaplay window minimize/maximize/close buttons.
    """
    @property
    def window_buttons_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the title bar area diaplay window minimize/maximize/close buttons.
        """
        ...
    @window_buttons_enabled.setter
    def window_buttons_enabled(self, value: bool) -> None:
        ...
    @property
    def double_click_toggles_fullscreen(self) -> bool:
        r"""
        (bool):  [Read-Write] Should double clicking the title bar area toggle fullscreen instead of maximizing the window.
        """
        ...
    @double_click_toggles_fullscreen.setter
    def double_click_toggles_fullscreen(self, value: bool) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class WindowTitleBarAreaSlot(PanelSlot):
    r"""
    The Slot for the UWindowTitleBarArea
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WindowTitleBarAreaSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...

class WrapBox(PanelWidget):
    r"""
    Arranges widgets left-to-right or top-to-bottom dependently of the orientation.  When the widgets exceed the wrapSize it will place widgets on the next line.
    
    * Many Children
    * Flows
    * Wraps
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WrapBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``explicit_wrap_size`` (bool):  [Read-Write] Use explicit wrap size whenever possible. It greatly simplifies layout calculations and reduces likelihood of "wiggling UI"
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of each line of wrapped content.
    - ``inner_slot_padding`` (Vector2D):  [Read-Write] The inner slot padding goes between slots sharing borders
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``orientation`` (Orientation):  [Read-Write] Determines if the Wrap Box should arranges the widgets left-to-right or top-to-bottom
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wrap_size`` (float):  [Read-Write] When this size is exceeded, elements will start appearing on the next line.
    """
    @property
    def inner_slot_padding(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] The inner slot padding goes between slots sharing borders
        """
        ...
    @inner_slot_padding.setter
    def inner_slot_padding(self, value: Vector2D) -> None:
        ...
    @property
    def wrap_size(self) -> float:
        r"""
        (float):  [Read-Write] When this size is exceeded, elements will start appearing on the next line.
        """
        ...
    @wrap_size.setter
    def wrap_size(self, value: float) -> None:
        ...
    @property
    def explicit_wrap_size(self) -> bool:
        r"""
        (bool):  [Read-Write] Use explicit wrap size whenever possible. It greatly simplifies layout calculations and reduces likelihood of "wiggling UI"
        """
        ...
    @explicit_wrap_size.setter
    def explicit_wrap_size(self, value: bool) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of each line of wrapped content.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def orientation(self) -> Orientation:
        r"""
        (Orientation):  [Read-Write] Determines if the Wrap Box should arranges the widgets left-to-right or top-to-bottom
        """
        ...
    @orientation.setter
    def orientation(self, value: Orientation) -> None:
        ...
    def set_inner_slot_padding(self, padding: Vector2D) -> None:
        r"""
        x.set_inner_slot_padding(padding) -> None
        Sets the inner slot padding goes between slots sharing borders
        
        Args:
            padding (Vector2D):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...
    def add_child_to_wrap_box(self, content: Widget) -> WrapBoxSlot:
        r"""
        x.add_child_to_wrap_box(content) -> WrapBoxSlot
        Add Child to Wrap Box
        
        Args:
            content (Widget): 
        
        Returns:
            WrapBoxSlot:
        """
        ...
    def add_child_wrap_box(self, content: Widget) -> WrapBoxSlot:
        r"""
        deprecated: 'add_child_wrap_box' was renamed to 'add_child_to_wrap_box'.
        """
        ...

class WrapBoxSlot(PanelSlot):
    r"""
    The Slot for the UWrapBox, contains the widget that is flowed vertically
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WrapBoxSlot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``fill_empty_space`` (bool):  [Read-Write] Should this slot fill the remaining space on the line?
    - ``fill_span_when_less_than`` (float):  [Read-Write] If the total available space in the wrap panel drops below this threshold, this slot will attempt to fill an entire line.
      NOTE: A value of 0, denotes no filling will occur.
    - ``force_new_line`` (bool):  [Read-Write] Should this slot start on a new line?
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
    - ``padding`` (Margin):  [Read-Write] The padding area between the slot and the content it contains.
    - ``vertical_alignment`` (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
    """
    @property
    def padding(self) -> Margin:
        r"""
        (Margin):  [Read-Write] The padding area between the slot and the content it contains.
        """
        ...
    @padding.setter
    def padding(self, value: Margin) -> None:
        ...
    @property
    def fill_span_when_less_than(self) -> float:
        r"""
        (float):  [Read-Write] If the total available space in the wrap panel drops below this threshold, this slot will attempt to fill an entire line.
        NOTE: A value of 0, denotes no filling will occur.
        """
        ...
    @fill_span_when_less_than.setter
    def fill_span_when_less_than(self, value: float) -> None:
        ...
    @property
    def horizontal_alignment(self) -> HorizontalAlignment:
        r"""
        (HorizontalAlignment):  [Read-Write] The alignment of the object horizontally.
        """
        ...
    @horizontal_alignment.setter
    def horizontal_alignment(self, value: HorizontalAlignment) -> None:
        ...
    @property
    def vertical_alignment(self) -> VerticalAlignment:
        r"""
        (VerticalAlignment):  [Read-Write] The alignment of the object vertically.
        """
        ...
    @vertical_alignment.setter
    def vertical_alignment(self, value: VerticalAlignment) -> None:
        ...
    @property
    def fill_empty_space(self) -> bool:
        r"""
        (bool):  [Read-Write] Should this slot fill the remaining space on the line?
        """
        ...
    @fill_empty_space.setter
    def fill_empty_space(self, value: bool) -> None:
        ...
    @property
    def force_new_line(self) -> bool:
        r"""
        (bool):  [Read-Write] Should this slot start on a new line?
        """
        ...
    @force_new_line.setter
    def force_new_line(self, value: bool) -> None:
        ...
    def set_vertical_alignment(self, vertical_alignment: VerticalAlignment) -> None:
        r"""
        x.set_vertical_alignment(vertical_alignment) -> None
        Set Vertical Alignment
        
        Args:
            vertical_alignment (VerticalAlignment):
        """
        ...
    def set_padding(self, padding: Margin) -> None:
        r"""
        x.set_padding(padding) -> None
        Set Padding
        
        Args:
            padding (Margin):
        """
        ...
    def set_new_line(self, force_new_line: bool) -> None:
        r"""
        x.set_new_line(force_new_line) -> None
        Set New Line
        
        Args:
            force_new_line (bool):
        """
        ...
    def set_horizontal_alignment(self, horizontal_alignment: HorizontalAlignment) -> None:
        r"""
        x.set_horizontal_alignment(horizontal_alignment) -> None
        Set Horizontal Alignment
        
        Args:
            horizontal_alignment (HorizontalAlignment):
        """
        ...
    def set_fill_span_when_less_than(self, fill_span_when_less_than: float) -> None:
        r"""
        x.set_fill_span_when_less_than(fill_span_when_less_than) -> None
        Set Fill Span when Less Than
        
        Args:
            fill_span_when_less_than (float):
        """
        ...
    def set_fill_empty_space(self, inb_fill_empty_space: bool) -> None:
        r"""
        x.set_fill_empty_space(inb_fill_empty_space) -> None
        Set Fill Empty Space
        
        Args:
            inb_fill_empty_space (bool):
        """
        ...

class DragDropOperation(Object):
    r"""
    This class is the base drag drop operation for UMG, extend it to add additional data and add new functionality.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: DragDropOperation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_drag_visual`` (Widget):  [Read-Write] The Drag Visual is the widget to display when dragging the item.  Normally people create a new widget to represent the
      temporary drag.
    - ``offset`` (Vector2D):  [Read-Write] A percentage offset (-1..+1) from the Pivot location, the percentage is of the desired size of the dragged visual.
    - ``on_drag_cancelled`` (OnDragDropMulticast):  [Read-Write]
    - ``on_dragged`` (OnDragDropMulticast):  [Read-Write]
    - ``on_drop`` (OnDragDropMulticast):  [Read-Write]
    - ``payload`` (Object):  [Read-Write] The payload of the drag operation.  This can be any UObject that you want to pass along as dragged data.  If you
      were building an inventory screen this would be the UObject representing the item being moved to another slot.
    - ``pivot`` (DragPivot):  [Read-Write] Controls where the drag widget visual will appear when dragged relative to the pointer performing
      the drag operation.
    - ``tag`` (str):  [Read-Write] A simple string tag you can optionally use to provide extra metadata about the operation.
    """
    @property
    def tag(self) -> str:
        r"""
        (str):  [Read-Write] A simple string tag you can optionally use to provide extra metadata about the operation.
        """
        ...
    @tag.setter
    def tag(self, value: str) -> None:
        ...
    @property
    def payload(self) -> Object:
        r"""
        (Object):  [Read-Write] The payload of the drag operation.  This can be any UObject that you want to pass along as dragged data.  If you
        were building an inventory screen this would be the UObject representing the item being moved to another slot.
        """
        ...
    @payload.setter
    def payload(self, value: Object) -> None:
        ...
    @property
    def default_drag_visual(self) -> Widget:
        r"""
        (Widget):  [Read-Only] The Drag Visual is the widget to display when dragging the item.  Normally people create a new widget to represent the
        temporary drag.
        """
        ...
    @property
    def pivot(self) -> DragPivot:
        r"""
        (DragPivot):  [Read-Write] Controls where the drag widget visual will appear when dragged relative to the pointer performing
        the drag operation.
        """
        ...
    @pivot.setter
    def pivot(self, value: DragPivot) -> None:
        ...
    @property
    def offset(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] A percentage offset (-1..+1) from the Pivot location, the percentage is of the desired size of the dragged visual.
        """
        ...
    @offset.setter
    def offset(self, value: Vector2D) -> None:
        ...
    @property
    def on_drop(self) -> OnDragDropMulticast:
        r"""
        (OnDragDropMulticast):  [Read-Write]
        """
        ...
    @on_drop.setter
    def on_drop(self, value: OnDragDropMulticast) -> None:
        ...
    @property
    def on_drag_cancelled(self) -> OnDragDropMulticast:
        r"""
        (OnDragDropMulticast):  [Read-Write]
        """
        ...
    @on_drag_cancelled.setter
    def on_drag_cancelled(self, value: OnDragDropMulticast) -> None:
        ...
    @property
    def on_dragged(self) -> OnDragDropMulticast:
        r"""
        (OnDragDropMulticast):  [Read-Write]
        """
        ...
    @on_dragged.setter
    def on_dragged(self, value: OnDragDropMulticast) -> None:
        ...
    def drop(self, pointer_event: PointerEvent) -> None:
        r"""
        x.drop(pointer_event) -> None
        Drop
        
        Args:
            pointer_event (PointerEvent):
        """
        ...
    def dragged(self, pointer_event: PointerEvent) -> None:
        r"""
        x.dragged(pointer_event) -> None
        Dragged
        
        Args:
            pointer_event (PointerEvent):
        """
        ...
    def drag_cancelled(self, pointer_event: PointerEvent) -> None:
        r"""
        x.drag_cancelled(pointer_event) -> None
        Drag Cancelled
        
        Args:
            pointer_event (PointerEvent):
        """
        ...

class SlateLibrary(BlueprintFunctionLibrary):
    r"""
    Slate Blueprint Library
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: SlateBlueprintLibrary.h
    
    """
    @classmethod
    def transform_vector_local_to_absolute(cls, geometry: Geometry, local_vector: Vector2D) -> Vector2D:
        r"""
        X.transform_vector_local_to_absolute(geometry, local_vector) -> Vector2D
        Transform Vector Local to Absolute
        
        Args:
            geometry (Geometry): 
            local_vector (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def transform_vector_absolute_to_local(cls, geometry: Geometry, absolute_vector: Vector2D) -> Vector2D:
        r"""
        X.transform_vector_absolute_to_local(geometry, absolute_vector) -> Vector2D
        Transform Vector Absolute to Local
        
        Args:
            geometry (Geometry): 
            absolute_vector (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def transform_scalar_local_to_absolute(cls, geometry: Geometry, local_scalar: float) -> float:
        r"""
        X.transform_scalar_local_to_absolute(geometry, local_scalar) -> float
        Transform Scalar Local to Absolute
        
        Args:
            geometry (Geometry): 
            local_scalar (float): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def transform_scalar_absolute_to_local(cls, geometry: Geometry, absolute_scalar: float) -> float:
        r"""
        X.transform_scalar_absolute_to_local(geometry, absolute_scalar) -> float
        Transform Scalar Absolute to Local
        
        Args:
            geometry (Geometry): 
            absolute_scalar (float): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def screen_to_widget_local(cls, world_context_object: Object, geometry: Geometry, screen_position: Vector2D, include_window_position: bool = False) -> Vector2D:
        r"""
        X.screen_to_widget_local(world_context_object, geometry, screen_position, include_window_position=False) -> Vector2D
        Translates a screen position in pixels into the local space of a widget with the given geometry.
        If bIncludeWindowPosition is true, then this method will also remove the game window's position (useful when in windowed mode).
        
        Args:
            world_context_object (Object): 
            geometry (Geometry): 
            screen_position (Vector2D): 
            include_window_position (bool): 
        
        Returns:
            Vector2D: 
        
            local_coordinate (Vector2D):
        """
        ...
    @classmethod
    def screen_to_widget_absolute(cls, world_context_object: Object, screen_position: Vector2D, include_window_position: bool = False) -> Vector2D:
        r"""
        X.screen_to_widget_absolute(world_context_object, screen_position, include_window_position=False) -> Vector2D
        Translates a screen position in pixels into absolute application coordinates.
        If bIncludeWindowPosition is true, then this method will also remove the game window's position (useful when in windowed mode).
        
        Args:
            world_context_object (Object): 
            screen_position (Vector2D): 
            include_window_position (bool): 
        
        Returns:
            Vector2D: 
        
            absolute_coordinate (Vector2D):
        """
        ...
    @classmethod
    def screen_to_viewport(cls, world_context_object: Object, screen_position: Vector2D) -> Vector2D:
        r"""
        X.screen_to_viewport(world_context_object, screen_position) -> Vector2D
        Translates a screen position in pixels into the local space of the viewport widget.
        
        Args:
            world_context_object (Object): 
            screen_position (Vector2D): 
        
        Returns:
            Vector2D: 
        
            viewport_position (Vector2D):
        """
        ...
    @classmethod
    def local_to_viewport(cls, world_context_object: Object, geometry: Geometry, local_coordinate: Vector2D) -> Tuple[Vector2D, Vector2D]:
        r"""
        X.local_to_viewport(world_context_object, geometry, local_coordinate) -> (pixel_position=Vector2D, viewport_position=Vector2D)
        Translates local coordinate of the geometry provided into local viewport coordinates.
        
        Args:
            world_context_object (Object): 
            geometry (Geometry): 
            local_coordinate (Vector2D): 
        
        Returns:
            tuple: 
        
            pixel_position (Vector2D): The position in the game's viewport, usable for line traces and other uses where you need a coordinate in the space of viewport resolution units.
        
            viewport_position (Vector2D): The position in the space of other widgets in the viewport.  Like if you wanted to add another widget to the viewport at the same position in viewport space as this location, this is what you would use.
        """
        ...
    @classmethod
    def local_to_absolute(cls, geometry: Geometry, local_coordinate: Vector2D) -> Vector2D:
        r"""
        X.local_to_absolute(geometry, local_coordinate) -> Vector2D
        Translates local coordinates into absolute coordinates
        
        Absolute coordinates could be either desktop or window space depending on what space the root of the widget hierarchy is in.
        
        Args:
            geometry (Geometry): 
            local_coordinate (Vector2D): 
        
        Returns:
            Vector2D: Absolute coordinates
        """
        ...
    @classmethod
    def is_under_location(cls, geometry: Geometry, absolute_coordinate: Vector2D) -> bool:
        r"""
        X.is_under_location(geometry, absolute_coordinate) -> bool
        Absolute coordinates could be either desktop or window space depending on what space the root of the widget hierarchy is in.
        
        Args:
            geometry (Geometry): 
            absolute_coordinate (Vector2D): 
        
        Returns:
            bool: true if the provided location in absolute coordinates is within the bounds of this geometry.
        """
        ...
    @classmethod
    def get_local_top_left(cls, geometry: Geometry) -> Vector2D:
        r"""
        X.get_local_top_left(geometry) -> Vector2D
        Returns the local top/left of the geometry in local space.
        
        Args:
            geometry (Geometry): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def get_local_size(cls, geometry: Geometry) -> Vector2D:
        r"""
        X.get_local_size(geometry) -> Vector2D
        Returns the size of the geometry in local space.
        
        Args:
            geometry (Geometry): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def get_absolute_size(cls, geometry: Geometry) -> Vector2D:
        r"""
        X.get_absolute_size(geometry) -> Vector2D
        Returns the size of the geometry in absolute space.
        
        Args:
            geometry (Geometry): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def equal_equal_slate_brush(cls, a: SlateBrush, b: SlateBrush) -> bool:
        r"""
        X.equal_equal_slate_brush(a, b) -> bool
        Returns whether brushes A and B are identical.
        
        Args:
            a (SlateBrush): 
            b (SlateBrush): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def absolute_to_viewport(cls, world_context_object: Object, absolute_desktop_coordinate: Vector2D) -> Tuple[Vector2D, Vector2D]:
        r"""
        X.absolute_to_viewport(world_context_object, absolute_desktop_coordinate) -> (pixel_position=Vector2D, viewport_position=Vector2D)
        Translates absolute coordinate in desktop space of the geometry provided into local viewport coordinates.
        
        Args:
            world_context_object (Object): 
            absolute_desktop_coordinate (Vector2D): 
        
        Returns:
            tuple: 
        
            pixel_position (Vector2D): The position in the game's viewport, usable for line traces and other uses where you need a coordinate in the space of viewport resolution units.
        
            viewport_position (Vector2D): The position in the space of other widgets in the viewport.  Like if you wanted to add another widget to the viewport at the same position in viewport space as this location, this is what you would use.
        """
        ...
    @classmethod
    def absolute_to_local(cls, geometry: Geometry, absolute_coordinate: Vector2D) -> Vector2D:
        r"""
        X.absolute_to_local(geometry, absolute_coordinate) -> Vector2D
        Absolute coordinates could be either desktop or window space depending on what space the root of the widget hierarchy is in.
        
        Args:
            geometry (Geometry): 
            absolute_coordinate (Vector2D): 
        
        Returns:
            Vector2D: Transforms AbsoluteCoordinate into the local space of this Geometry.
        """
        ...

class WidgetLibrary(BlueprintFunctionLibrary):
    r"""
    Widget Blueprint Library
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetBlueprintLibrary.h
    
    """
    @classmethod
    def unlock_mouse(cls, reply: EventReply) -> Tuple[EventReply, EventReply]:
        r"""
        X.unlock_mouse(reply) -> (EventReply, reply=EventReply)
        Unlock Mouse
        
        Args:
            reply (EventReply): 
        
        Returns:
            EventReply: 
        
            reply (EventReply):
        """
        ...
    @classmethod
    def unhandled(cls) -> EventReply:
        r"""
        X.unhandled() -> EventReply
        The event reply to use when you choose not to handle an event.
        
        Returns:
            EventReply:
        """
        ...
    @classmethod
    def set_window_title_bar_state(cls, title_bar_content: Widget, mode: WindowTitleBarMode, title_bar_drag_enabled: bool, window_buttons_visible: bool, title_bar_visible: bool) -> None:
        r"""
        X.set_window_title_bar_state(title_bar_content, mode, title_bar_drag_enabled, window_buttons_visible, title_bar_visible) -> None
        Set Window Title Bar State
        
        Args:
            title_bar_content (Widget): 
            mode (WindowTitleBarMode): 
            title_bar_drag_enabled (bool): 
            window_buttons_visible (bool): 
            title_bar_visible (bool):
        """
        ...
    @classmethod
    def set_window_title_bar_on_close_clicked_delegate(cls, delegate: OnGameWindowCloseButtonClickedDelegate) -> None:
        r"""
        X.set_window_title_bar_on_close_clicked_delegate(delegate) -> None
        Set Window Title Bar on Close Clicked Delegate
        
        Args:
            delegate (OnGameWindowCloseButtonClickedDelegate):
        """
        ...
    @classmethod
    def set_window_title_bar_close_button_active(cls, active: bool) -> None:
        r"""
        X.set_window_title_bar_close_button_active(active) -> None
        Set Window Title Bar Close Button Active
        
        Args:
            active (bool):
        """
        ...
    @classmethod
    def set_user_focus(cls, reply: EventReply, focus_widget: Widget, all_users: bool = False) -> Tuple[EventReply, EventReply]:
        r"""
        X.set_user_focus(reply, focus_widget, all_users=False) -> (EventReply, reply=EventReply)
        Set User Focus
        
        Args:
            reply (EventReply): 
            focus_widget (Widget): 
            all_users (bool): 
        
        Returns:
            EventReply: 
        
            reply (EventReply):
        """
        ...
    @classmethod
    def set_mouse_position(cls, reply: EventReply, new_mouse_position: Vector2D) -> Tuple[EventReply, EventReply]:
        r"""
        X.set_mouse_position(reply, new_mouse_position) -> (EventReply, reply=EventReply)
        Set Mouse Position
        
        Args:
            reply (EventReply): 
            new_mouse_position (Vector2D): 
        
        Returns:
            EventReply: 
        
            reply (EventReply):
        """
        ...
    @classmethod
    def set_input_mode_ui_only_ex(cls, player_controller: PlayerController, widget_to_focus: Widget = None, mouse_lock_mode: MouseLockMode = MouseLockMode.DO_NOT_LOCK, flush_input: bool = False) -> None:
        r"""
        X.set_input_mode_ui_only_ex(player_controller, widget_to_focus=None, mouse_lock_mode=MouseLockMode.DO_NOT_LOCK, flush_input=False) -> None
        Setup an input mode that allows only the UI to respond to user input.
        
        Note: This means that any bound Input Events in the widget will not be called!
        
        Args:
            player_controller (PlayerController): 
            widget_to_focus (Widget): 
            mouse_lock_mode (MouseLockMode): 
            flush_input (bool):
        """
        ...
    @classmethod
    def set_input_mode_game_only(cls, player_controller: PlayerController, flush_input: bool = False) -> None:
        r"""
        X.set_input_mode_game_only(player_controller, flush_input=False) -> None
        Setup an input mode that allows only player input / player controller to respond to user input.
        
        Note: Any bound Input Events in this widget will be called.
        
        Args:
            player_controller (PlayerController): 
            flush_input (bool):
        """
        ...
    @classmethod
    def set_input_mode_game_and_ui_ex(cls, player_controller: PlayerController, widget_to_focus: Widget = None, mouse_lock_mode: MouseLockMode = MouseLockMode.DO_NOT_LOCK, hide_cursor_during_capture: bool = True, flush_input: bool = False) -> None:
        r"""
        X.set_input_mode_game_and_ui_ex(player_controller, widget_to_focus=None, mouse_lock_mode=MouseLockMode.DO_NOT_LOCK, hide_cursor_during_capture=True, flush_input=False) -> None
        Setup an input mode that allows only the UI to respond to user input, and if the UI doesn't handle it player input / player controller gets a chance.
        
        Note: This means that any bound Input events in the widget will be called.
        
        Args:
            player_controller (PlayerController): 
            widget_to_focus (Widget): 
            mouse_lock_mode (MouseLockMode): 
            hide_cursor_during_capture (bool): 
            flush_input (bool):
        """
        ...
    @classmethod
    def set_hardware_cursor(cls, world_context_object: Object, cursor_shape: MouseCursor, cursor_name: Name, hot_spot: Vector2D) -> bool:
        r"""
        X.set_hardware_cursor(world_context_object, cursor_shape, cursor_name, hot_spot) -> bool
        Loads or sets a hardware cursor from the content directory in the game.
        
        Args:
            world_context_object (Object): 
            cursor_shape (MouseCursor): 
            cursor_name (Name): 
            hot_spot (Vector2D): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_focus_to_game_viewport(cls) -> None:
        r"""
        X.set_focus_to_game_viewport() -> None
        Set Focus to Game Viewport
        """
        ...
    @classmethod
    def set_color_vision_deficiency_type(cls, type: ColorVisionDeficiency, severity: float, correct_deficiency: bool, show_correction_with_deficiency: bool) -> None:
        r"""
        X.set_color_vision_deficiency_type(type, severity, correct_deficiency, show_correction_with_deficiency) -> None
        Apply color deficiency correction settings to the game window
        
        Args:
            type (ColorVisionDeficiency): The type of color deficiency correction to apply.
            severity (float): Intensity of the color deficiency correction effect, from 0 to 1.
            correct_deficiency (bool): Shifts the color spectrum to the visible range based on the current deficiency type.
            show_correction_with_deficiency (bool): If you're correcting the color deficiency, you can use this to visualize what the correction looks like with the deficiency.
        """
        ...
    @classmethod
    def set_brush_resource_to_texture(cls, brush: SlateBrush, texture: Texture2D) -> SlateBrush:
        r"""
        X.set_brush_resource_to_texture(brush, texture) -> SlateBrush
        Sets the resource on a brush to be a UTexture2D.
        
        Args:
            brush (SlateBrush): 
            texture (Texture2D): 
        
        Returns:
            SlateBrush: 
        
            brush (SlateBrush):
        """
        ...
    @classmethod
    def set_brush_resource_to_material(cls, brush: SlateBrush, material: MaterialInterface) -> SlateBrush:
        r"""
        X.set_brush_resource_to_material(brush, material) -> SlateBrush
        Sets the resource on a brush to be a Material.
        
        Args:
            brush (SlateBrush): 
            material (MaterialInterface): 
        
        Returns:
            SlateBrush: 
        
            brush (SlateBrush):
        """
        ...
    @classmethod
    def restore_previous_window_title_bar_state(cls) -> None:
        r"""
        X.restore_previous_window_title_bar_state() -> None
        Restore Previous Window Title Bar State
        """
        ...
    @classmethod
    def release_mouse_capture(cls, reply: EventReply) -> Tuple[EventReply, EventReply]:
        r"""
        X.release_mouse_capture(reply) -> (EventReply, reply=EventReply)
        Release Mouse Capture
        
        Args:
            reply (EventReply): 
        
        Returns:
            EventReply: 
        
            reply (EventReply):
        """
        ...
    @classmethod
    def release_joystick_capture(cls, reply: EventReply, all_joysticks: bool = False) -> Tuple[EventReply, EventReply]:
        r"""
        X.release_joystick_capture(reply, all_joysticks=False) -> (EventReply, reply=EventReply)
        Release Joystick Capture
        deprecated: Use ClearUserFocus() instead
        
        Args:
            reply (EventReply): 
            all_joysticks (bool): 
        
        Returns:
            EventReply: 
        
            reply (EventReply):
        """
        ...
    @classmethod
    def no_resource_brush(cls) -> SlateBrush:
        r"""
        X.no_resource_brush() -> SlateBrush
        Creates a Slate Brush that wont draw anything, the "Null Brush".
        
        Returns:
            SlateBrush: A new slate brush that wont draw anything.
        """
        ...
    @classmethod
    def make_brush_from_texture(cls, texture: Texture2D, width: int = 0, height: int = 0) -> SlateBrush:
        r"""
        X.make_brush_from_texture(texture, width=0, height=0) -> SlateBrush
        Creates a Slate Brush from a Texture2D
        
        Args:
            texture (Texture2D): 
            width (int32): When less than or equal to zero, the Width of the brush will default to the Width of the Texture
            height (int32): When less than or equal to zero, the Height of the brush will default to the Height of the Texture
        
        Returns:
            SlateBrush: A new slate brush using the texture.
        """
        ...
    @classmethod
    def make_brush_from_material(cls, material: MaterialInterface, width: int = 32, height: int = 32) -> SlateBrush:
        r"""
        X.make_brush_from_material(material, width=32, height=32) -> SlateBrush
        Creates a Slate Brush from a Material.  Materials don't have an implicit size, so providing a widget and height
        is required to hint slate with how large the image wants to be by default.
        
        Args:
            material (MaterialInterface): 
            width (int32): 
            height (int32): 
        
        Returns:
            SlateBrush: A new slate brush using the material.
        """
        ...
    @classmethod
    def make_brush_from_asset(cls, brush_asset: SlateBrushAsset) -> SlateBrush:
        r"""
        X.make_brush_from_asset(brush_asset) -> SlateBrush
        Creates a Slate Brush from a Slate Brush Asset
        
        Args:
            brush_asset (SlateBrushAsset): 
        
        Returns:
            SlateBrush: A new slate brush using the asset's brush.
        """
        ...
    @classmethod
    def lock_mouse(cls, reply: EventReply, capturing_widget: Widget) -> Tuple[EventReply, EventReply]:
        r"""
        X.lock_mouse(reply, capturing_widget) -> (EventReply, reply=EventReply)
        Lock Mouse
        
        Args:
            reply (EventReply): 
            capturing_widget (Widget): 
        
        Returns:
            EventReply: 
        
            reply (EventReply):
        """
        ...
    @classmethod
    def is_drag_dropping(cls) -> bool:
        r"""
        X.is_drag_dropping() -> bool
        Returns true if a drag/drop event is occurring that a widget can handle.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def handled(cls) -> EventReply:
        r"""
        X.handled() -> EventReply
        The event reply to use when you choose to handle an event.  This will prevent the event
        from continuing to bubble up / down the widget hierarchy.
        
        Returns:
            EventReply:
        """
        ...
    @classmethod
    def get_safe_zone_padding(cls, world_context_object: Object) -> Tuple[Vector4, Vector2D, Vector4]:
        r"""
        X.get_safe_zone_padding(world_context_object) -> (safe_padding=Vector4, safe_padding_scale=Vector2D, spill_over_padding=Vector4)
        Gets the amount of padding that needs to be added when accounting for the safe zone on TVs.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            tuple: 
        
            safe_padding (Vector4): 
        
            safe_padding_scale (Vector2D): 
        
            spill_over_padding (Vector4):
        """
        ...
    @classmethod
    def get_key_event_from_analog_input_event(cls, event: AnalogInputEvent) -> KeyEvent:
        r"""
        X.get_key_event_from_analog_input_event(event) -> KeyEvent
        Get Key Event from Analog Input Event
        
        Args:
            event (AnalogInputEvent): 
        
        Returns:
            KeyEvent:
        """
        ...
    @classmethod
    def get_input_event_from_pointer_event(cls, event: PointerEvent) -> InputEvent:
        r"""
        X.get_input_event_from_pointer_event(event) -> InputEvent
        Get Input Event from Pointer Event
        
        Args:
            event (PointerEvent): 
        
        Returns:
            InputEvent:
        """
        ...
    @classmethod
    def get_input_event_from_navigation_event(cls, event: NavigationEvent) -> InputEvent:
        r"""
        X.get_input_event_from_navigation_event(event) -> InputEvent
        Get Input Event from Navigation Event
        
        Args:
            event (NavigationEvent): 
        
        Returns:
            InputEvent:
        """
        ...
    @classmethod
    def get_input_event_from_key_event(cls, event: KeyEvent) -> InputEvent:
        r"""
        X.get_input_event_from_key_event(event) -> InputEvent
        Get Input Event from Key Event
        
        Args:
            event (KeyEvent): 
        
        Returns:
            InputEvent:
        """
        ...
    @classmethod
    def get_input_event_from_character_event(cls, event: CharacterEvent) -> InputEvent:
        r"""
        X.get_input_event_from_character_event(event) -> InputEvent
        Get Input Event from Character Event
        
        Args:
            event (CharacterEvent): 
        
        Returns:
            InputEvent:
        """
        ...
    @classmethod
    def get_dynamic_material(cls, brush: SlateBrush) -> Tuple[MaterialInstanceDynamic, SlateBrush]:
        r"""
        X.get_dynamic_material(brush) -> (MaterialInstanceDynamic, brush=SlateBrush)
        Gets the material that allows changes to parameters at runtime.  The brush must already have a material assigned to it,
        if it does it will automatically be converted to a MID.
        
        Args:
            brush (SlateBrush): 
        
        Returns:
            SlateBrush: A material that supports dynamic input from the game.
        
            brush (SlateBrush):
        """
        ...
    @classmethod
    def get_drag_dropping_content(cls) -> DragDropOperation:
        r"""
        X.get_drag_dropping_content() -> DragDropOperation
        Returns the drag and drop operation that is currently occurring if any, otherwise nothing.
        
        Returns:
            DragDropOperation:
        """
        ...
    @classmethod
    def get_brush_resource_as_texture2d(cls, brush: SlateBrush) -> Texture2D:
        r"""
        X.get_brush_resource_as_texture2d(brush) -> Texture2D
        Gets the brush resource as a texture 2D.
        
        Args:
            brush (SlateBrush): 
        
        Returns:
            Texture2D:
        """
        ...
    @classmethod
    def get_brush_resource_as_material(cls, brush: SlateBrush) -> MaterialInterface:
        r"""
        X.get_brush_resource_as_material(brush) -> MaterialInterface
        Gets the brush resource as a material.
        
        Args:
            brush (SlateBrush): 
        
        Returns:
            MaterialInterface:
        """
        ...
    @classmethod
    def get_brush_resource(cls, brush: SlateBrush) -> Object:
        r"""
        X.get_brush_resource(brush) -> Object
        Gets the resource object on a brush.  This could be a UTexture2D or a UMaterialInterface.
        
        Args:
            brush (SlateBrush): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def get_all_widgets_with_interface(cls, world_context_object: Object, interface: Class, top_level_only: bool) -> Array[UserWidget]:
        r"""
        X.get_all_widgets_with_interface(world_context_object, interface, top_level_only) -> Array[UserWidget]
        Find all widgets in the world with the specified interface.
        This is a slow operation, use with caution e.g. do not use every frame.
        
        Args:
            world_context_object (Object): 
            interface (type(Class)): The interface to find. Must be specified or result array will be empty.
            top_level_only (bool): Only the widgets that are direct children of the viewport will be returned.
        
        Returns:
            Array[UserWidget]: 
        
            found_widgets (Array[UserWidget]): Output array of widgets that implement the specified interface.
        """
        ...
    @classmethod
    def get_all_widgets_of_class(cls, world_context_object: Object, widget_class: Class, top_level_only: bool = True) -> Array[UserWidget]:
        r"""
        X.get_all_widgets_of_class(world_context_object, widget_class, top_level_only=True) -> Array[UserWidget]
        Find all widgets of a certain class.
        
        Args:
            world_context_object (Object): 
            widget_class (type(Class)): The widget class to filter by.
            top_level_only (bool): Only the widgets that are direct children of the viewport will be returned.
        
        Returns:
            Array[UserWidget]: 
        
            found_widgets (Array[UserWidget]): The widgets that were found matching the filter.
        """
        ...
    @classmethod
    def end_drag_drop(cls, reply: EventReply) -> Tuple[EventReply, EventReply]:
        r"""
        X.end_drag_drop(reply) -> (EventReply, reply=EventReply)
        An event should return FReply::Handled().EndDragDrop() to request that the current drag/drop operation be terminated.
        
        Args:
            reply (EventReply): 
        
        Returns:
            EventReply: 
        
            reply (EventReply):
        """
        ...
    @classmethod
    def draw_text_formatted(cls, context: PaintContext, text: Text, position: Vector2D, font: Font, font_size: float = 16.000000, font_type_face: Name = "Regular", tint: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000]) -> PaintContext:
        r"""
        X.draw_text_formatted(context, text, position, font, font_size=16.000000, font_type_face="Regular", tint=[1.000000, 1.000000, 1.000000, 1.000000]) -> PaintContext
        Draws text.
        
        Args:
            context (PaintContext): 
            text (Text): The string to draw.
            position (Vector2D): The starting position where the text is drawn in local space.
            font (Font): 
            font_size (float): 
            font_type_face (Name): 
            tint (LinearColor): Color to render the line.
        
        Returns:
            PaintContext: 
        
            context (PaintContext):
        """
        ...
    @classmethod
    def draw_text(cls, context: PaintContext, string: str, position: Vector2D, tint: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000]) -> PaintContext:
        r"""
        X.draw_text(context, string, position, tint=[1.000000, 1.000000, 1.000000, 1.000000]) -> PaintContext
        Draws text.
        deprecated: Use Draw Text instead
        
        Args:
            context (PaintContext): 
            string (str): The string to draw.
            position (Vector2D): The starting position where the text is drawn in local space.
            tint (LinearColor): Color to render the line.
        
        Returns:
            PaintContext: 
        
            context (PaintContext):
        """
        ...
    @classmethod
    def draw_spline(cls, context: PaintContext, start: Vector2D, start_dir: Vector2D, end: Vector2D, end_dir: Vector2D, tint: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], thickness: float = 1.000000) -> PaintContext:
        r"""
        X.draw_spline(context, start, start_dir, end, end_dir, tint=[1.000000, 1.000000, 1.000000, 1.000000], thickness=1.000000) -> PaintContext
        Draws a hermite spline.
        
        Args:
            context (PaintContext): 
            start (Vector2D): Starting position of the spline in local space.
            start_dir (Vector2D): The direction of the spline from the start point.
            end (Vector2D): Ending position of the spline in local space.
            end_dir (Vector2D): The direction of the spline to the end point.
            tint (LinearColor): Color to render the spline.
            thickness (float): How many pixels thick this spline should be.
        
        Returns:
            PaintContext: 
        
            context (PaintContext):
        """
        ...
    @classmethod
    def draw_lines(cls, context: PaintContext, points: Array[Vector2D], tint: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], anti_alias: bool = True, thickness: float = 1.000000) -> PaintContext:
        r"""
        X.draw_lines(context, points, tint=[1.000000, 1.000000, 1.000000, 1.000000], anti_alias=True, thickness=1.000000) -> PaintContext
        Draws several line segments.
        
        Args:
            context (PaintContext): 
            points (Array[Vector2D]): Line pairs, each line needs to be 2 separate points in the array.
            tint (LinearColor): Color to render the line.
            anti_alias (bool): Whether the line should be antialiased.
            thickness (float): How many pixels thick this line should be.
        
        Returns:
            PaintContext: 
        
            context (PaintContext):
        """
        ...
    @classmethod
    def draw_line(cls, context: PaintContext, position_a: Vector2D, position_b: Vector2D, tint: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], anti_alias: bool = True, thickness: float = 1.000000) -> PaintContext:
        r"""
        X.draw_line(context, position_a, position_b, tint=[1.000000, 1.000000, 1.000000, 1.000000], anti_alias=True, thickness=1.000000) -> PaintContext
        Draws a line.
        
        Args:
            context (PaintContext): 
            position_a (Vector2D): Starting position of the line in local space.
            position_b (Vector2D): Ending position of the line in local space.
            tint (LinearColor): Color to render the line.
            anti_alias (bool): Whether the line should be antialiased.
            thickness (float): How many pixels thick this line should be.
        
        Returns:
            PaintContext: 
        
            context (PaintContext):
        """
        ...
    @classmethod
    def draw_box(cls, context: PaintContext, position: Vector2D, size: Vector2D, brush: SlateBrushAsset, tint: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000]) -> PaintContext:
        r"""
        X.draw_box(context, position, size, brush, tint=[1.000000, 1.000000, 1.000000, 1.000000]) -> PaintContext
        Draws a box
        
        Args:
            context (PaintContext): 
            position (Vector2D): 
            size (Vector2D): 
            brush (SlateBrushAsset): 
            tint (LinearColor): 
        
        Returns:
            PaintContext: 
        
            context (PaintContext):
        """
        ...
    @classmethod
    def dismiss_all_menus(cls) -> None:
        r"""
        X.dismiss_all_menus() -> None
        Closes any popup menu
        """
        ...
    @classmethod
    def detect_drag_if_pressed(cls, pointer_event: PointerEvent, widget_detecting_drag: Widget, drag_key: Key) -> EventReply:
        r"""
        X.detect_drag_if_pressed(pointer_event, widget_detecting_drag, drag_key) -> EventReply
        Given the pointer event, emit the DetectDrag reply if the provided key was pressed.
        If the DragKey is a touch key, that will also automatically work.
        
        Args:
            pointer_event (PointerEvent): The pointer device event coming in.
            widget_detecting_drag (Widget): Detect dragging in this widget.
            drag_key (Key): This button should be pressed to detect the drag, won't emit the DetectDrag FEventReply unless this is pressed.
        
        Returns:
            EventReply:
        """
        ...
    @classmethod
    def detect_drag(cls, reply: EventReply, widget_detecting_drag: Widget, drag_key: Key) -> Tuple[EventReply, EventReply]:
        r"""
        X.detect_drag(reply, widget_detecting_drag, drag_key) -> (EventReply, reply=EventReply)
        Ask Slate to detect if a user starts dragging in this widget later.  Slate internally tracks the movement
        and if it surpasses the drag threshold, Slate will send an OnDragDetected event to the widget.
        
        Args:
            reply (EventReply): 
            widget_detecting_drag (Widget): Detect dragging in this widget
            drag_key (Key): This button should be pressed to detect the drag
        
        Returns:
            EventReply: 
        
            reply (EventReply):
        """
        ...
    @classmethod
    def clear_user_focus(cls, reply: EventReply, all_users: bool = False) -> Tuple[EventReply, EventReply]:
        r"""
        X.clear_user_focus(reply, all_users=False) -> (EventReply, reply=EventReply)
        Clear User Focus
        
        Args:
            reply (EventReply): 
            all_users (bool): 
        
        Returns:
            EventReply: 
        
            reply (EventReply):
        """
        ...
    @classmethod
    def capture_mouse(cls, reply: EventReply, capturing_widget: Widget) -> Tuple[EventReply, EventReply]:
        r"""
        X.capture_mouse(reply, capturing_widget) -> (EventReply, reply=EventReply)
        Capture Mouse
        
        Args:
            reply (EventReply): 
            capturing_widget (Widget): 
        
        Returns:
            EventReply: 
        
            reply (EventReply):
        """
        ...
    @classmethod
    def capture_joystick(cls, reply: EventReply, capturing_widget: Widget, all_joysticks: bool = False) -> Tuple[EventReply, EventReply]:
        r"""
        X.capture_joystick(reply, capturing_widget, all_joysticks=False) -> (EventReply, reply=EventReply)
        Capture Joystick
        deprecated: Use SetUserFocus() instead
        
        Args:
            reply (EventReply): 
            capturing_widget (Widget): 
            all_joysticks (bool): 
        
        Returns:
            EventReply: 
        
            reply (EventReply):
        """
        ...
    @classmethod
    def cancel_drag_drop(cls) -> None:
        r"""
        X.cancel_drag_drop() -> None
        Cancels any current drag drop operation.
        """
        ...

class WidgetLayoutLibrary(BlueprintFunctionLibrary):
    r"""
    Widget Layout Library
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetLayoutLibrary.h
    
    """
    @classmethod
    def slot_as_wrap_box_slot(cls, widget: Widget) -> WrapBoxSlot:
        r"""
        X.slot_as_wrap_box_slot(widget) -> WrapBoxSlot
        Gets the slot object on the child widget as a Wrap Box Slot, allowing you to manipulate its information.
        
        Args:
            widget (Widget): The child widget of a Wrap Box.
        
        Returns:
            WrapBoxSlot:
        """
        ...
    @classmethod
    def slot_as_widget_switcher_slot(cls, widget: Widget) -> WidgetSwitcherSlot:
        r"""
        X.slot_as_widget_switcher_slot(widget) -> WidgetSwitcherSlot
        Gets the slot object on the child widget as a Widget Switcher Slot, allowing you to manipulate its information.
        
        Args:
            widget (Widget): The child widget of a Widget Switcher Slot.
        
        Returns:
            WidgetSwitcherSlot:
        """
        ...
    @classmethod
    def slot_as_vertical_box_slot(cls, widget: Widget) -> VerticalBoxSlot:
        r"""
        X.slot_as_vertical_box_slot(widget) -> VerticalBoxSlot
        Gets the slot object on the child widget as a Vertical Box Slot, allowing you to manipulate its information.
        
        Args:
            widget (Widget): The child widget of a Vertical Box.
        
        Returns:
            VerticalBoxSlot:
        """
        ...
    @classmethod
    def slot_as_uniform_grid_slot(cls, widget: Widget) -> UniformGridSlot:
        r"""
        X.slot_as_uniform_grid_slot(widget) -> UniformGridSlot
        Gets the slot object on the child widget as a Uniform Grid Slot, allowing you to manipulate layout information.
        
        Args:
            widget (Widget): The child widget of a uniform grid panel.
        
        Returns:
            UniformGridSlot:
        """
        ...
    @classmethod
    def slot_as_size_box_slot(cls, widget: Widget) -> SizeBoxSlot:
        r"""
        X.slot_as_size_box_slot(widget) -> SizeBoxSlot
        Gets the slot object on the child widget as a Size Box Slot, allowing you to manipulate its information.
        
        Args:
            widget (Widget): The child widget of a Size Box.
        
        Returns:
            SizeBoxSlot:
        """
        ...
    @classmethod
    def slot_as_scroll_box_slot(cls, widget: Widget) -> ScrollBoxSlot:
        r"""
        X.slot_as_scroll_box_slot(widget) -> ScrollBoxSlot
        Gets the slot object on the child widget as a Scroll Box Slot, allowing you to manipulate its information.
        
        Args:
            widget (Widget): The child widget of a Scroll Box.
        
        Returns:
            ScrollBoxSlot:
        """
        ...
    @classmethod
    def slot_as_scale_box_slot(cls, widget: Widget) -> ScaleBoxSlot:
        r"""
        X.slot_as_scale_box_slot(widget) -> ScaleBoxSlot
        Gets the slot object on the child widget as a Scale Box Slot, allowing you to manipulate its information.
        
        Args:
            widget (Widget): The child widget of a Scale Box.
        
        Returns:
            ScaleBoxSlot:
        """
        ...
    @classmethod
    def slot_as_safe_box_slot(cls, widget: Widget) -> SafeZoneSlot:
        r"""
        X.slot_as_safe_box_slot(widget) -> SafeZoneSlot
        Gets the slot object on the child widget as a Safe Box Slot, allowing you to manipulate its information.
        
        Args:
            widget (Widget): The child widget of a Safe Box.
        
        Returns:
            SafeZoneSlot:
        """
        ...
    @classmethod
    def slot_as_overlay_slot(cls, widget: Widget) -> OverlaySlot:
        r"""
        X.slot_as_overlay_slot(widget) -> OverlaySlot
        Gets the slot object on the child widget as a Overlay Slot, allowing you to manipulate layout information.
        
        Args:
            widget (Widget): The child widget of a overlay panel.
        
        Returns:
            OverlaySlot:
        """
        ...
    @classmethod
    def slot_as_horizontal_box_slot(cls, widget: Widget) -> HorizontalBoxSlot:
        r"""
        X.slot_as_horizontal_box_slot(widget) -> HorizontalBoxSlot
        Gets the slot object on the child widget as a Horizontal Box Slot, allowing you to manipulate its information.
        
        Args:
            widget (Widget): The child widget of a Horizontal Box.
        
        Returns:
            HorizontalBoxSlot:
        """
        ...
    @classmethod
    def slot_as_grid_slot(cls, widget: Widget) -> GridSlot:
        r"""
        X.slot_as_grid_slot(widget) -> GridSlot
        Gets the slot object on the child widget as a Grid Slot, allowing you to manipulate layout information.
        
        Args:
            widget (Widget): The child widget of a grid panel.
        
        Returns:
            GridSlot:
        """
        ...
    @classmethod
    def slot_as_canvas_slot(cls, widget: Widget) -> CanvasPanelSlot:
        r"""
        X.slot_as_canvas_slot(widget) -> CanvasPanelSlot
        Gets the slot object on the child widget as a Canvas Slot, allowing you to manipulate layout information.
        
        Args:
            widget (Widget): The child widget of a canvas panel.
        
        Returns:
            CanvasPanelSlot:
        """
        ...
    @classmethod
    def slot_as_border_slot(cls, widget: Widget) -> BorderSlot:
        r"""
        X.slot_as_border_slot(widget) -> BorderSlot
        Gets the slot object on the child widget as a Border Slot, allowing you to manipulate layout information.
        
        Args:
            widget (Widget): The child widget of a border panel.
        
        Returns:
            BorderSlot:
        """
        ...
    @classmethod
    def remove_all_widgets(cls, world_context_object: Object) -> None:
        r"""
        X.remove_all_widgets(world_context_object) -> None
        Removes all widgets from the viewport.
        
        Args:
            world_context_object (Object):
        """
        ...
    @classmethod
    def project_world_location_to_widget_position(cls, player_controller: PlayerController, world_location: Vector, player_viewport_relative: bool) -> Optional[Vector2D]:
        r"""
        X.project_world_location_to_widget_position(player_controller, world_location, player_viewport_relative) -> Vector2D or None
        Gets the projected world to screen position for a player, then converts it into a widget
        position, which takes into account any quality scaling.
        
        Args:
            player_controller (PlayerController): The player controller to project the position in the world to their screen.
            world_location (Vector): The world location to project from.
            player_viewport_relative (bool): Should this be relative to the player viewport subregion (useful when using player attached widgets in split screen or when aspect-ratio constrained)
        
        Returns:
            Vector2D or None: true if the position projects onto the screen.
        
            screen_position (Vector2D): The position in the viewport with quality scale removed and DPI scale remove.
        """
        ...
    @classmethod
    def get_viewport_widget_geometry(cls, world_context_object: Object) -> Geometry:
        r"""
        X.get_viewport_widget_geometry(world_context_object) -> Geometry
        Gets the geometry of the widget holding all widgets added to the "Viewport".  You
        can use this geometry to convert between absolute and local space of widgets held on this
        widget.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            Geometry:
        """
        ...
    @classmethod
    def get_viewport_size(cls, world_context_object: Object) -> Vector2D:
        r"""
        X.get_viewport_size(world_context_object) -> Vector2D
        Gets the size of the game viewport.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def get_viewport_scale(cls, world_context_object: Object) -> float:
        r"""
        X.get_viewport_scale(world_context_object) -> float
        Gets the current DPI Scale being applied to the viewport and all the Widgets.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_player_screen_widget_geometry(cls, player_controller: PlayerController) -> Geometry:
        r"""
        X.get_player_screen_widget_geometry(player_controller) -> Geometry
        Gets the geometry of the widget holding all widgets added to the "Player Screen". You
        can use this geometry to convert between absolute and local space of widgets held on this
        widget.
        
        Args:
            player_controller (PlayerController): 
        
        Returns:
            Geometry:
        """
        ...
    @classmethod
    def get_mouse_position_scaled_by_dpi(cls, player: PlayerController) -> Optional[Tuple[float, float]]:
        r"""
        X.get_mouse_position_scaled_by_dpi(player) -> (location_x=float, location_y=float) or None
        Gets the mouse position of the player controller, scaled by the DPI.  If you're trying to go from raw mouse screenspace coordinates
        to fullscreen widget space, you'll need to transform the mouse into DPI Scaled space.  This function performs that scaling.
        
        MousePositionScaledByDPI = MousePosition * (1 / ViewportScale).
                //UE_DEPRECATED(4.17, "Use GetMousePositionOnViewport() instead.  Optionally and for more options, you can use GetViewportWidgetGeometry and GetPlayerScreenWidgetGeometry are newly introduced to give you the geometry of the viewport and the player screen for widgets to help convert between spaces.")
        
        Args:
            player (PlayerController): 
        
        Returns:
            tuple or None: 
        
            location_x (float): 
        
            location_y (float):
        """
        ...
    @classmethod
    def get_mouse_position_on_viewport(cls, world_context_object: Object) -> Vector2D:
        r"""
        X.get_mouse_position_on_viewport(world_context_object) -> Vector2D
        Gets the platform's mouse cursor position in the local space of the viewport widget.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def get_mouse_position_on_platform(cls) -> Vector2D:
        r"""
        X.get_mouse_position_on_platform() -> Vector2D
        Gets the platform's mouse cursor position.  This is the 'absolute' desktop location of the mouse.
        
        Returns:
            Vector2D:
        """
        ...

class BlueprintCore(Object):
    r"""
    Blueprint Core
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintCore.h
    
    """
    ...

class Blueprint(BlueprintCore):
    r"""
    Blueprints are special assets that provide an intuitive, node-based interface that can be used to create new types of Actors
    and script level events; giving designers and gameplay programmers the tools to quickly create and iterate gameplay from
    within Unreal Editor without ever needing to write a line of code.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Blueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blueprint_category`` (str):  [Read-Write] The category of the Blueprint, used to organize this Blueprint class when displayed in palette windows
    - ``blueprint_description`` (str):  [Read-Write] Shows up in the content browser tooltip when the blueprint is hovered
    - ``blueprint_display_name`` (str):  [Read-Write] Overrides the BP's display name in the editor UI
    - ``blueprint_namespace`` (str):  [Read-Write] The namespace of this blueprint (if set, the Blueprint will be treated differently for the context menu)
    - ``compile_mode`` (BlueprintCompileMode):  [Read-Write] The mode that will be used when compiling this class.
    - ``deprecate`` (bool):  [Read-Write] Deprecates the Blueprint, marking the generated class with the CLASS_Deprecated flag
    - ``generate_abstract_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a abstract class or not.  Should set CLASS_Abstract in the KismetCompiler.
    - ``generate_const_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a const class or not.  Should set CLASS_Const in the KismetCompiler.
    - ``hide_categories`` (Array[str]):  [Read-Write] Additional HideCategories. These are added to HideCategories from parent.
    - ``run_construction_script_in_sequencer`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor in sequencer
    - ``run_construction_script_on_drag`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor as you drag it in the editor, or only when the drag operation is complete
    - ``should_cook_property_guids_value`` (ShouldCookBlueprintPropertyGuids):  [Read-Write] Whether to include the property GUIDs for the generated class in a cooked build.
      note: This option may slightly increase memory usage in a cooked build, but can avoid needing to add CoreRedirect data for Blueprint classes stored within SaveGame archives.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    def set_blueprint_variable_instance_editable(self, variable_name: Name, instance_editable: bool) -> None:
        r"""
        x.set_blueprint_variable_instance_editable(variable_name, instance_editable) -> None
        Sets "Instance Editable" to true/false on a Blueprint variable
        
        Args:
            variable_name (Name): The variable name
            instance_editable (bool): Toggle InstanceEditable
        """
        ...
    def set_blueprint_variable_expose_to_cinematics(self, variable_name: Name, expose_to_cinematics: bool) -> None:
        r"""
        x.set_blueprint_variable_expose_to_cinematics(variable_name, expose_to_cinematics) -> None
        Sets "Expose To Cinematics" to true/false on a Blueprint variable
        
        Args:
            variable_name (Name): The variable name
            expose_to_cinematics (bool): Set to true to expose to cinematics
        """
        ...
    def set_blueprint_variable_expose_on_spawn(self, variable_name: Name, expose_on_spawn: bool) -> None:
        r"""
        x.set_blueprint_variable_expose_on_spawn(variable_name, expose_on_spawn) -> None
        Sets "Expose On Spawn" to true/false on a Blueprint variable
        
        Args:
            variable_name (Name): The variable name
            expose_on_spawn (bool): Set to true to expose on spawn
        """
        ...
    def generated_class(self) -> Class:
        r"""
        x.generated_class() -> type(Class)
        Gets the class generated when this blueprint is compiled
        
        Returns:
            type(Class): UClass*                      The generated class
        """
        ...

class BlueprintEditorLibrary(BlueprintFunctionLibrary):
    r"""
    Blueprint Editor Library
    
    **C++ Source:**
    
    - **Module**: BlueprintEditorLibrary
    - **File**: BlueprintEditorLibrary.h
    
    """
    @classmethod
    def upgrade_operator_nodes(cls, blueprint: Blueprint) -> None:
        r"""
        X.upgrade_operator_nodes(blueprint) -> None
        Replace any old operator nodes (float + float, vector + float, int + vector, etc)
        with the newer Promotable Operator version of the node. Preserve any connections the
        original node had to the newer version of the node.
        
        Args:
            blueprint (Blueprint): Blueprint to upgrade
        """
        ...
    @classmethod
    def set_blueprint_variable_instance_editable(cls, blueprint: Blueprint, variable_name: Name, instance_editable: bool) -> None:
        r"""
        X.set_blueprint_variable_instance_editable(blueprint, variable_name, instance_editable) -> None
        Sets "Instance Editable" to true/false on a Blueprint variable
        
        Args:
            blueprint (Blueprint): The blueprint object
            variable_name (Name): The variable name
            instance_editable (bool): Toggle InstanceEditable
        """
        ...
    @classmethod
    def set_blueprint_variable_expose_to_cinematics(cls, blueprint: Blueprint, variable_name: Name, expose_to_cinematics: bool) -> None:
        r"""
        X.set_blueprint_variable_expose_to_cinematics(blueprint, variable_name, expose_to_cinematics) -> None
        Sets "Expose To Cinematics" to true/false on a Blueprint variable
        
        Args:
            blueprint (Blueprint): The blueprint object
            variable_name (Name): The variable name
            expose_to_cinematics (bool): Set to true to expose to cinematics
        """
        ...
    @classmethod
    def set_blueprint_variable_expose_on_spawn(cls, blueprint: Blueprint, variable_name: Name, expose_on_spawn: bool) -> None:
        r"""
        X.set_blueprint_variable_expose_on_spawn(blueprint, variable_name, expose_on_spawn) -> None
        Sets "Expose On Spawn" to true/false on a Blueprint variable
        
        Args:
            blueprint (Blueprint): The blueprint object
            variable_name (Name): The variable name
            expose_on_spawn (bool): Set to true to expose on spawn
        """
        ...
    @classmethod
    def replace_variable_references(cls, blueprint: Blueprint, old_var_name: Name, new_var_name: Name) -> None:
        r"""
        X.replace_variable_references(blueprint, old_var_name, new_var_name) -> None
        Replace any references of variables with the OldVarName to references of those with the NewVarName if possible
        
        Args:
            blueprint (Blueprint): Blueprint to replace the variable references on
            old_var_name (Name): The variable you want replaced
            new_var_name (Name): The new variable that will be used in the old one's place
        """
        ...
    @classmethod
    def reparent_blueprint(cls, blueprint: Blueprint, new_parent_class: Class) -> None:
        r"""
        X.reparent_blueprint(blueprint, new_parent_class) -> None
        Attempts to reparent the given blueprint to the new chosen parent class.
        
        Args:
            blueprint (Blueprint): Blueprint that you would like to reparent
            new_parent_class (type(Class)): The new parent class to use
        """
        ...
    @classmethod
    def rename_graph(cls, graph: EdGraph, new_name_str: str = "NewGraph") -> None:
        r"""
        X.rename_graph(graph, new_name_str="NewGraph") -> None
        Attempts to rename the given graph with a new name
        
        Args:
            graph (EdGraph): The graph to rename
            new_name_str (str): The new name of the graph
        """
        ...
    @classmethod
    def remove_unused_variables(cls, blueprint: Blueprint) -> int:
        r"""
        X.remove_unused_variables(blueprint) -> int32
        Deletes any unused blueprint created variables the given blueprint.
        An Unused variable is any BP variable that is not referenced in any
        blueprint graphs
        
        Args:
            blueprint (Blueprint): Blueprint that you would like to remove variables from
        
        Returns:
            int32: Number of variables removed
        """
        ...
    @classmethod
    def remove_unused_nodes(cls, blueprint: Blueprint) -> None:
        r"""
        X.remove_unused_nodes(blueprint) -> None
        Remove any nodes in this blueprint that have no connections made to them.
        
        Args:
            blueprint (Blueprint): The blueprint to remove the nodes from
        """
        ...
    @classmethod
    def remove_graph(cls, blueprint: Blueprint, graph: EdGraph) -> None:
        r"""
        X.remove_graph(blueprint, graph) -> None
        Removes the given graph from the blueprint if possible
        
        Args:
            blueprint (Blueprint): The blueprint the graph will be removed from
            graph (EdGraph): The graph to remove
        """
        ...
    @classmethod
    def remove_function_graph(cls, blueprint: Blueprint, func_name: Name) -> None:
        r"""
        X.remove_function_graph(blueprint, func_name) -> None
        Deletes the function of the given name on this blueprint. Does NOT replace function call sites.
        
        Args:
            blueprint (Blueprint): The blueprint to remove the function from
            func_name (Name): The name of the function to remove
        """
        ...
    @classmethod
    def refresh_open_editors_for_blueprint(cls, bp: Blueprint) -> None:
        r"""
        X.refresh_open_editors_for_blueprint(bp) -> None
        Attempt to refresh any open blueprint editors for the given asset
        
        Args:
            bp (Blueprint):
        """
        ...
    @classmethod
    def refresh_all_open_blueprint_editors(cls) -> None:
        r"""
        X.refresh_all_open_blueprint_editors() -> None
        Refresh any open blueprint editors
        """
        ...
    @classmethod
    def get_blueprint_asset(cls, object: Object) -> Blueprint:
        r"""
        X.get_blueprint_asset(object) -> Blueprint
        Casts the provided Object to a Blueprint - the root asset type of a blueprint asset. Note
        that the blueprint asset itself is editor only and not present in cooked assets.
        
        Args:
            object (Object): The object we need to get the UBlueprint from
        
        Returns:
            Blueprint: UBlueprint*   The blueprint type of the given object, nullptr if the object is not a blueprint.
        """
        ...
    @classmethod
    def generated_class(cls, blueprint_obj: Blueprint) -> Class:
        r"""
        X.generated_class(blueprint_obj) -> type(Class)
        Gets the class generated when this blueprint is compiled
        
        Args:
            blueprint_obj (Blueprint): The blueprint object
        
        Returns:
            type(Class): UClass*                      The generated class
        """
        ...
    @classmethod
    def find_graph(cls, blueprint: Blueprint, graph_name: Name) -> EdGraph:
        r"""
        X.find_graph(blueprint, graph_name) -> EdGraph
        Finds the graph with the given name on the blueprint. Null if it doesn't have one.
        
        Args:
            blueprint (Blueprint): Blueprint to search
            graph_name (Name): The name of the graph to search for
        
        Returns:
            EdGraph: UEdGraph*             Pointer to the graph with the given name, null if not found
        """
        ...
    @classmethod
    def find_event_graph(cls, blueprint: Blueprint) -> EdGraph:
        r"""
        X.find_event_graph(blueprint) -> EdGraph
        Finds the event graph of the given blueprint. Null if it doesn't have one. This will only return
        the primary event graph of the blueprint (the graph named "EventGraph").
        
        Args:
            blueprint (Blueprint): Blueprint to search for the event graph on
        
        Returns:
            EdGraph: UEdGraph*             Event graph of the blueprint if it has one, null if it doesn't have one
        """
        ...
    @classmethod
    def compile_blueprint(cls, blueprint: Blueprint) -> None:
        r"""
        X.compile_blueprint(blueprint) -> None
        Compiles the given blueprint.
        
        Args:
            blueprint (Blueprint): Blueprint to compile
        """
        ...
    @classmethod
    def add_function_graph(cls, blueprint: Blueprint, func_name: str = "NewFunction") -> EdGraph:
        r"""
        X.add_function_graph(blueprint, func_name="NewFunction") -> EdGraph
        Adds a function to the given blueprint
        
        Args:
            blueprint (Blueprint): The blueprint to add the function to
            func_name (str): Name of the function to add
        
        Returns:
            EdGraph: UEdGraph*
        """
        ...

class ContentBrowserDataMenuContext_AddNewMenu(Object):
    r"""
    Content Browser Data Menu Context Add New Menu
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataMenuContexts.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_be_modified`` (bool):  [Read-Write]
    - ``contains_valid_package_path`` (bool):  [Read-Write] At least one of the selected paths maps to a mounted content root
    - ``owner_domain`` (ContentBrowserDataMenuContext_AddNewMenuDomain):  [Read-Write]
    - ``selected_paths`` (Array[Name]):  [Read-Write]
    """
    @property
    def selected_paths(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Only]
        """
        ...
    @property
    def contains_valid_package_path(self) -> bool:
        r"""
        (bool):  [Read-Only] At least one of the selected paths maps to a mounted content root
        """
        ...
    @property
    def can_be_modified(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def owner_domain(self) -> ContentBrowserDataMenuContext_AddNewMenuDomain:
        r"""
        (ContentBrowserDataMenuContext_AddNewMenuDomain):  [Read-Only]
        """
        ...

class ContentBrowserDataMenuContext_FolderMenu(Object):
    r"""
    Content Browser Data Menu Context Folder Menu
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataMenuContexts.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_be_modified`` (bool):  [Read-Write]
    - ``selected_items`` (Array[ContentBrowserItem]):  [Read-Write]
    """
    @property
    def selected_items(self) -> Array[ContentBrowserItem]:
        r"""
        (Array[ContentBrowserItem]):  [Read-Only]
        """
        ...
    @property
    def can_be_modified(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class ContentBrowserDataMenuContext_FileMenu(Object):
    r"""
    Content Browser Data Menu Context File Menu
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataMenuContexts.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_be_modified`` (bool):  [Read-Write]
    - ``contains_unsupported_assets`` (bool):  [Read-Write]
    - ``has_cooked_packages`` (bool):  [Read-Write]
    - ``selected_items`` (Array[ContentBrowserItem]):  [Read-Write]
    """
    @property
    def selected_items(self) -> Array[ContentBrowserItem]:
        r"""
        (Array[ContentBrowserItem]):  [Read-Only]
        """
        ...
    @property
    def can_be_modified(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def has_cooked_packages(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def contains_unsupported_assets(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class ContentBrowserDataMenuContext_DragDropMenu(Object):
    r"""
    Content Browser Data Menu Context Drag Drop Menu
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataMenuContexts.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_copy`` (bool):  [Read-Write]
    - ``can_move`` (bool):  [Read-Write]
    - ``dragged_items`` (Array[ContentBrowserItem]):  [Read-Write]
    - ``drop_target_item`` (ContentBrowserItem):  [Read-Write]
    """
    @property
    def drop_target_item(self) -> ContentBrowserItem:
        r"""
        (ContentBrowserItem):  [Read-Only]
        """
        ...
    @property
    def dragged_items(self) -> Array[ContentBrowserItem]:
        r"""
        (Array[ContentBrowserItem]):  [Read-Only]
        """
        ...
    @property
    def can_move(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def can_copy(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class ContentBrowserDataSubsystem(EditorSubsystem):
    r"""
    Subsystem that provides access to Content Browser data.
    This type deals with the composition of multiple data sources, which provide information about the folders and files available in the Content Browser.
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserDataSubsystem.h
    
    """
    def get_items_under_path(self, path: Name, filter: ContentBrowserDataFilter) -> Array[ContentBrowserItem]:
        r"""
        x.get_items_under_path(path, filter) -> Array[ContentBrowserItem]
        Get the items (folders and/or files) that exist under the given virtual path.
        
        Args:
            path (Name): 
            filter (ContentBrowserDataFilter): 
        
        Returns:
            Array[ContentBrowserItem]:
        """
        ...
    def get_items_at_path(self, path: Name, item_type_filter: ContentBrowserItemTypeFilter) -> Array[ContentBrowserItem]:
        r"""
        x.get_items_at_path(path, item_type_filter) -> Array[ContentBrowserItem]
        Get the items (folders and/or files) that exist at the given virtual path.
        note: Multiple items may have the same virtual path if they are different types, or come from different data sources.
        
        Args:
            path (Name): 
            item_type_filter (ContentBrowserItemTypeFilter): 
        
        Returns:
            Array[ContentBrowserItem]:
        """
        ...
    def get_item_at_path(self, path: Name, item_type_filter: ContentBrowserItemTypeFilter) -> ContentBrowserItem:
        r"""
        x.get_item_at_path(path, item_type_filter) -> ContentBrowserItem
        Get the first item (folder and/or file) that exists at the given virtual path.
        
        Args:
            path (Name): 
            item_type_filter (ContentBrowserItemTypeFilter): 
        
        Returns:
            ContentBrowserItem:
        """
        ...
    def get_available_data_sources(self) -> Array[Name]:
        r"""
        x.get_available_data_sources() -> Array[Name]
        Get the list of current available data sources.
        
        Returns:
            Array[Name]:
        """
        ...
    def get_active_data_sources(self) -> Array[Name]:
        r"""
        x.get_active_data_sources() -> Array[Name]
        Get the list of current active data sources.
        
        Returns:
            Array[Name]:
        """
        ...
    def deactivate_data_source(self, name: Name) -> bool:
        r"""
        x.deactivate_data_source(name) -> bool
        Attempt to deactivate the named data source.
        
        Args:
            name (Name): 
        
        Returns:
            bool: True if the data source was available and active, false otherwise.
        """
        ...
    def deactivate_all_data_sources(self) -> None:
        r"""
        x.deactivate_all_data_sources() -> None
        Deactivate all active data sources.
        """
        ...
    def activate_data_source(self, name: Name) -> bool:
        r"""
        x.activate_data_source(name) -> bool
        Attempt to activate the named data source.
        
        Args:
            name (Name): 
        
        Returns:
            bool: True if the data source was available and not already active, false otherwise.
        """
        ...
    def activate_all_data_sources(self) -> None:
        r"""
        x.activate_all_data_sources() -> None
        Activate all available data sources.
        """
        ...

class ContentBrowserItemLibrary(BlueprintFunctionLibrary):
    r"""
    TODO: Script API exposure
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserItem.h
    
    """
    @classmethod
    def is_folder(cls, item: ContentBrowserItem) -> bool:
        r"""
        X.is_folder(item) -> bool
        Is Folder
        
        Args:
            item (ContentBrowserItem): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_file(cls, item: ContentBrowserItem) -> bool:
        r"""
        X.is_file(item) -> bool
        Is File
        
        Args:
            item (ContentBrowserItem): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_virtual_path(cls, item: ContentBrowserItem) -> Name:
        r"""
        X.get_virtual_path(item) -> Name
        Get Virtual Path
        
        Args:
            item (ContentBrowserItem): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def get_display_name(cls, item: ContentBrowserItem) -> Text:
        r"""
        X.get_display_name(item) -> Text
        Get Display Name
        
        Args:
            item (ContentBrowserItem): 
        
        Returns:
            Text:
        """
        ...

class ContentBrowserItemPathExtensions(BlueprintFunctionLibrary):
    r"""
    Content Browser Item Path Extensions
    
    **C++ Source:**
    
    - **Module**: ContentBrowserData
    - **File**: ContentBrowserItemPath.h
    
    """
    @classmethod
    def set_path(cls, item_path: ContentBrowserItemPath, path: Name, path_type: ContentBrowserPathType) -> ContentBrowserItemPath:
        r"""
        X.set_path(item_path, path, path_type) -> ContentBrowserItemPath
        Set the path being stored
        
        Args:
            item_path (ContentBrowserItemPath): 
            path (Name): 
            path_type (ContentBrowserPathType): 
        
        Returns:
            ContentBrowserItemPath: 
        
            item_path (ContentBrowserItemPath):
        """
        ...
    @classmethod
    def get_virtual_path(cls, item_path: ContentBrowserItemPath) -> Name:
        r"""
        X.get_virtual_path(item_path) -> Name
        Returns virtual path as FName (eg, "/All/Plugins/PluginA/MyFile").
        
        Args:
            item_path (ContentBrowserItemPath): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def get_internal_path(cls, item_path: ContentBrowserItemPath) -> Name:
        r"""
        X.get_internal_path(item_path) -> Name
        Returns internal path if there is one (eg,. "/PluginA/MyFile").
        
        Args:
            item_path (ContentBrowserItemPath): 
        
        Returns:
            Name:
        """
        ...

class ClothingAssetBase(Object):
    r"""
    An interface object for any clothing asset the engine can use.
    Any clothing asset concrete object should derive from this.
    
    **C++ Source:**
    
    - **Module**: ClothingSystemRuntimeInterface
    - **File**: ClothingAssetBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``imported_file_path`` (str):  [Read-Only] If this asset was imported from a file, this will be the original path
    """
    ...

class ClothingAssetCommon(ClothingAssetBase):
    r"""
    Implementation of non-solver specific, but common Engine related functionality.
    
    Solver specific implementations may wish to override this class to construct
    their own default instances of child classes, such as \c ClothSimConfig and
    \c CustomData, as well as override the \c AddNewLod() factory to build their
    own implementation of \c UClothLODDataBase.
    
    **C++ Source:**
    
    - **Module**: ClothingSystemRuntimeCommon
    - **File**: ClothingAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cloth_configs`` (Map[Name, ClothConfigBase]):  [Read-Only] Simulation specific cloth parameters.
      Use GetClothConfig() to retrieve the correct parameters/config type for the desired cloth simulation system.
    - ``imported_file_path`` (str):  [Read-Only] If this asset was imported from a file, this will be the original path
    - ``physics_asset`` (PhysicsAsset):  [Read-Write] The physics asset to extract collisions from when building a simulation.
    """
    @property
    def cloth_configs(self) -> Map[Name, ClothConfigBase]:
        r"""
        (Map[Name, ClothConfigBase]):  [Read-Only] Simulation specific cloth parameters.
        Use GetClothConfig() to retrieve the correct parameters/config type for the desired cloth simulation system.
        """
        ...

class ClothingAsset(ClothingAssetCommon):
    r"""
    deprecated: 'ClothingAsset' was renamed to 'ClothingAssetCommon'.
    """
    ...

class ClothingAssetNv(ClothingAssetCommon):
    r"""
    deprecated: 'ClothingAssetNv' was renamed to 'ClothingAssetCommon'.
    """
    ...

class InterchangeBlueprintPipelineBase(Blueprint):
    r"""
    Interchange Blueprint Pipeline Base
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangeBlueprintPipelineBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blueprint_category`` (str):  [Read-Write] The category of the Blueprint, used to organize this Blueprint class when displayed in palette windows
    - ``blueprint_description`` (str):  [Read-Write] Shows up in the content browser tooltip when the blueprint is hovered
    - ``blueprint_display_name`` (str):  [Read-Write] Overrides the BP's display name in the editor UI
    - ``blueprint_namespace`` (str):  [Read-Write] The namespace of this blueprint (if set, the Blueprint will be treated differently for the context menu)
    - ``compile_mode`` (BlueprintCompileMode):  [Read-Write] The mode that will be used when compiling this class.
    - ``deprecate`` (bool):  [Read-Write] Deprecates the Blueprint, marking the generated class with the CLASS_Deprecated flag
    - ``generate_abstract_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a abstract class or not.  Should set CLASS_Abstract in the KismetCompiler.
    - ``generate_const_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a const class or not.  Should set CLASS_Const in the KismetCompiler.
    - ``hide_categories`` (Array[str]):  [Read-Write] Additional HideCategories. These are added to HideCategories from parent.
    - ``run_construction_script_in_sequencer`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor in sequencer
    - ``run_construction_script_on_drag`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor as you drag it in the editor, or only when the drag operation is complete
    - ``should_cook_property_guids_value`` (ShouldCookBlueprintPropertyGuids):  [Read-Write] Whether to include the property GUIDs for the generated class in a cooked build.
      note: This option may slightly increase memory usage in a cooked build, but can avoid needing to add CoreRedirect data for Blueprint classes stored within SaveGame archives.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    ...

class InterchangeFilePickerBase(Object):
    r"""
    Interchange File Picker Base
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangeFilePickerBase.h
    
    """
    def scripted_file_picker_for_translator_type(self, translator_type: InterchangeTranslatorType) -> Optional[Tuple[InterchangeFilePickerParameters, Array[str]]]:
        r"""
        x.scripted_file_picker_for_translator_type(translator_type) -> (parameters=InterchangeFilePickerParameters, out_filenames=Array[str]) or None
        Non-virtual helper that allows Blueprint to implement an event-based function to implement FilePickerForTranslatorType().
        
        Args:
            translator_type (InterchangeTranslatorType): 
        
        Returns:
            tuple or None: 
        
            parameters (InterchangeFilePickerParameters): 
        
            out_filenames (Array[str]):
        """
        ...
    def scripted_file_picker_for_translator_asset_type(self, translator_asset_type: InterchangeTranslatorAssetType) -> Optional[Tuple[InterchangeFilePickerParameters, Array[str]]]:
        r"""
        x.scripted_file_picker_for_translator_asset_type(translator_asset_type) -> (parameters=InterchangeFilePickerParameters, out_filenames=Array[str]) or None
        Non-virtual helper that allows Blueprint to implement an event-based function to implement FilePickerForTranslatorAssetType().
        
        Args:
            translator_asset_type (InterchangeTranslatorAssetType): 
        
        Returns:
            tuple or None: 
        
            parameters (InterchangeFilePickerParameters): 
        
            out_filenames (Array[str]):
        """
        ...

class InterchangePipelineConfigurationBase(Object):
    r"""
    Interchange Pipeline Configuration Base
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangePipelineConfigurationBase.h
    
    """
    def scripted_show_scene_pipeline_configuration_dialog(self, source_data: InterchangeSourceData, translator: InterchangeTranslatorBase, base_node_container: InterchangeBaseNodeContainer) -> Tuple[InterchangePipelineConfigurationDialogResult, Array[InterchangeStackInfo], Array[InterchangePipelineBase]]:
        r"""
        x.scripted_show_scene_pipeline_configuration_dialog(source_data, translator, base_node_container) -> (InterchangePipelineConfigurationDialogResult, pipeline_stacks=Array[InterchangeStackInfo], out_pipelines=Array[InterchangePipelineBase])
        Non-virtual helper that allows Blueprint to implement an event-based function to implement ShowScenePipelineConfigurationDialog().
        
        Args:
            source_data (InterchangeSourceData): 
            translator (InterchangeTranslatorBase): 
            base_node_container (InterchangeBaseNodeContainer): 
        
        Returns:
            tuple: 
        
            pipeline_stacks (Array[InterchangeStackInfo]): 
        
            out_pipelines (Array[InterchangePipelineBase]):
        """
        ...
    def scripted_show_reimport_pipeline_configuration_dialog(self, source_data: InterchangeSourceData, translator: InterchangeTranslatorBase, base_node_container: InterchangeBaseNodeContainer, reimport_asset: Object) -> Tuple[InterchangePipelineConfigurationDialogResult, Array[InterchangeStackInfo], Array[InterchangePipelineBase]]:
        r"""
        x.scripted_show_reimport_pipeline_configuration_dialog(source_data, translator, base_node_container, reimport_asset) -> (InterchangePipelineConfigurationDialogResult, pipeline_stacks=Array[InterchangeStackInfo], out_pipelines=Array[InterchangePipelineBase])
        Non-virtual helper that allows Blueprint to implement an event-based function to implement ShowReimportPipelineConfigurationDialog().
        
        Args:
            source_data (InterchangeSourceData): 
            translator (InterchangeTranslatorBase): 
            base_node_container (InterchangeBaseNodeContainer): 
            reimport_asset (Object): 
        
        Returns:
            tuple: 
        
            pipeline_stacks (Array[InterchangeStackInfo]): 
        
            out_pipelines (Array[InterchangePipelineBase]):
        """
        ...
    def scripted_show_pipeline_configuration_dialog(self, source_data: InterchangeSourceData, translator: InterchangeTranslatorBase, base_node_container: InterchangeBaseNodeContainer) -> Tuple[InterchangePipelineConfigurationDialogResult, Array[InterchangeStackInfo], Array[InterchangePipelineBase]]:
        r"""
        x.scripted_show_pipeline_configuration_dialog(source_data, translator, base_node_container) -> (InterchangePipelineConfigurationDialogResult, pipeline_stacks=Array[InterchangeStackInfo], out_pipelines=Array[InterchangePipelineBase])
        Non-virtual helper that allows Blueprint to implement an event-based function to implement ShowPipelineConfigurationDialog().
        
        Args:
            source_data (InterchangeSourceData): 
            translator (InterchangeTranslatorBase): 
            base_node_container (InterchangeBaseNodeContainer): 
        
        Returns:
            tuple: 
        
            pipeline_stacks (Array[InterchangeStackInfo]): 
        
            out_pipelines (Array[InterchangePipelineBase]):
        """
        ...

class InterchangePythonPipelineBase(InterchangePipelineBase):
    r"""
    * This class represents a Python pipeline. It is used by the TSoftClassPtr of the PythonPipeline asset.
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangePythonPipelineBase.h
    
    """
    ...

class InterchangePythonPipelineAsset(Object):
    r"""
    * This class is a helper class for Python pipelines. It allows the class picker to filter the Content Browser instance we want to support
    * in the pipeline stack.
    *
    * Use this class factory to be able to create an instance of a Python pipeline in the Content Browser.
    * A Python pipeline does not have any locked properties, and all default values must be set in the Python script.
    * This restriction exists because Python classes are transient, so any assets created from a Python class cannot be saved.
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangePythonPipelineBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``generated_pipeline`` (InterchangePythonPipelineBase):  [Read-Only] The transient pipeline we generate when we load the Python pipeline.
    - ``json_default_properties`` (str):  [Read-Only]
    - ``python_class`` (Class):  [Read-Write] The Python class we want to use as a pipeline.
    """
    ...

class AssetImportData(Object):
    r"""
    todo: Make this class better suited to multiple import paths - maybe have FAssetImportInfo use a map rather than array?
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    def scripted_add_filename(self, path: str, index: int, source_file_label: str) -> None:
        r"""
        x.scripted_add_filename(path, index, source_file_label) -> None
        Add or update a filename at the specified index. If the index is greater then the number of source file,
        it will add empty filenames to fill up to the specified index. The timespan and MD5 will be computed.
        
        Args:
            path (str): 
            index (int32): 
            source_file_label (str):
        """
        ...
    def get_first_filename(self) -> str:
        r"""
        x.get_first_filename() -> str
        Helper function to return the first filename stored in this data. The resulting filename will be absolute (ie, not relative to the asset).
        
        Returns:
            str:
        """
        ...
    def extract_filenames(self) -> Array[str]:
        r"""
        x.extract_filenames() -> Array[str]
        K2 Extract Filenames
        
        Returns:
            Array[str]:
        """
        ...

class InterchangeAssetImportData(AssetImportData):
    r"""
    Interchange Asset Import Data
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangeAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``node_container`` (InterchangeBaseNodeContainer):  [Read-Write]
      deprecated: Use GetNodeContainer/SetNodeContainer instead.
    - ``node_unique_id`` (str):  [Read-Only] The Node UID passed to the factory that existed in the graph that was used to create this asset.
    - ``pipelines`` (Array[Object]):  [Read-Write]
      deprecated: Use GetPipelines/SetPipelines instead.
    - ``scene_import_asset`` (SoftObjectPath):  [Read-Write] On a level import, set to the UInterchangeSceneImportAsset created during the import.
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    @property
    def node_container(self) -> InterchangeBaseNodeContainer:
        r"""
        (InterchangeBaseNodeContainer):  [Read-Write]
        deprecated: Use GetNodeContainer/SetNodeContainer instead.
        """
        ...
    @node_container.setter
    def node_container(self, value: InterchangeBaseNodeContainer) -> None:
        ...
    @property
    def pipelines(self) -> Array[Object]:
        r"""
        (Array[Object]):  [Read-Write]
        deprecated: Use GetPipelines/SetPipelines instead.
        """
        ...
    @pipelines.setter
    def pipelines(self, value: Array[Object]) -> None:
        ...
    def set_translator_settings(self, translator_settings: InterchangeTranslatorSettings) -> None:
        r"""
        x.set_translator_settings(translator_settings) -> None
        Set Translator Settings
        
        Args:
            translator_settings (InterchangeTranslatorSettings):
        """
        ...
    def set_pipelines(self, pipelines: Array[Object]) -> None:
        r"""
        x.set_pipelines(pipelines) -> None
        Set Pipelines
        
        Args:
            pipelines (Array[Object]):
        """
        ...
    def set_node_container(self, node_container: InterchangeBaseNodeContainer) -> None:
        r"""
        x.set_node_container(node_container) -> None
        Set Node Container
        
        Args:
            node_container (InterchangeBaseNodeContainer):
        """
        ...
    def script_get_first_filename(self) -> str:
        r"""
        x.script_get_first_filename() -> str
        Return the first filename stored in this data. The resulting filename will be absolute (that is, not relative to the asset).
        
        Returns:
            str:
        """
        ...
    def script_extract_filenames(self) -> Array[str]:
        r"""
        x.script_extract_filenames() -> Array[str]
        Extract all the (resolved) filenames.
        
        Returns:
            Array[str]:
        """
        ...
    def script_extract_display_labels(self) -> Array[str]:
        r"""
        x.script_extract_display_labels() -> Array[str]
        Extract all the filename labels.
        
        Returns:
            Array[str]:
        """
        ...
    def get_translator_settings(self) -> InterchangeTranslatorSettings:
        r"""
        x.get_translator_settings() -> InterchangeTranslatorSettings
        Get Translator Settings
        
        Returns:
            InterchangeTranslatorSettings:
        """
        ...
    def get_stored_node(self, node_unique_id: str) -> InterchangeBaseNode:
        r"""
        x.get_stored_node(node_unique_id) -> InterchangeBaseNode
        Get Stored Node
        
        Args:
            node_unique_id (str): 
        
        Returns:
            InterchangeBaseNode:
        """
        ...
    def get_stored_factory_node(self, node_unique_id: str) -> InterchangeFactoryBaseNode:
        r"""
        x.get_stored_factory_node(node_unique_id) -> InterchangeFactoryBaseNode
        Get Stored Factory Node
        
        Args:
            node_unique_id (str): 
        
        Returns:
            InterchangeFactoryBaseNode:
        """
        ...
    def get_pipelines(self) -> Array[Object]:
        r"""
        x.get_pipelines() -> Array[Object]
        Returns Array of non-null pipelines
        
        Returns:
            Array[Object]:
        """
        ...
    def get_number_of_pipelines(self) -> int:
        r"""
        x.get_number_of_pipelines() -> int32
        Get Number Of Pipelines
        
        Returns:
            int32:
        """
        ...
    def get_node_container(self) -> InterchangeBaseNodeContainer:
        r"""
        x.get_node_container() -> InterchangeBaseNodeContainer
        Get Node Container
        
        Returns:
            InterchangeBaseNodeContainer:
        """
        ...

class InterchangePipelineStackOverride(Object):
    r"""
    This class is used to pass override pipelines in the ImportAssetTask Options member.
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangeManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``override_pipelines`` (Array[SoftObjectPath]):  [Read-Write]
    """
    @property
    def override_pipelines(self) -> Array[SoftObjectPath]:
        r"""
        (Array[SoftObjectPath]):  [Read-Write]
        """
        ...
    @override_pipelines.setter
    def override_pipelines(self, value: Array[SoftObjectPath]) -> None:
        ...
    def add_python_pipeline(self, pipeline_base: InterchangePythonPipelineBase) -> None:
        r"""
        x.add_python_pipeline(pipeline_base) -> None
        Add Python Pipeline
        
        Args:
            pipeline_base (InterchangePythonPipelineBase):
        """
        ...
    def add_pipeline(self, pipeline_base: InterchangePipelineBase) -> None:
        r"""
        x.add_pipeline(pipeline_base) -> None
        Add Pipeline
        
        Args:
            pipeline_base (InterchangePipelineBase):
        """
        ...
    def add_blueprint_pipeline(self, pipeline_base: InterchangeBlueprintPipelineBase) -> None:
        r"""
        x.add_blueprint_pipeline(pipeline_base) -> None
        Add Blueprint Pipeline
        
        Args:
            pipeline_base (InterchangeBlueprintPipelineBase):
        """
        ...

class InterchangeManager(Object):
    r"""
    Interchange Manager
    
    **C++ Source:**
    
    - **Module**: InterchangeEngine
    - **File**: InterchangeManager.h
    
    """
    def import_scene(self, content_path: str, source_data: InterchangeSourceData, import_asset_parameters: ImportAssetParameters) -> bool:
        r"""
        x.import_scene(content_path, source_data, import_asset_parameters) -> bool
        Call this to start a scene import process. The caller must specify the source data.
        This process can import many different assets and their transforms (USceneComponent), store the result in a Blueprint, and add the Blueprint to the level.
        
        Args:
            content_path (str): The path where the imported assets will be created.
            source_data (InterchangeSourceData): The source data input to translate. This object will be duplicated to allow thread-safe operations.
            import_asset_parameters (ImportAssetParameters): All parameters that need to be passed to the import asset function.
        
        Returns:
            bool: true if the import succeeds, or false otherwise.
        """
        ...
    def import_asset(self, content_path: str, source_data: InterchangeSourceData, import_asset_parameters: ImportAssetParameters) -> bool:
        r"""
        x.import_asset(content_path, source_data, import_asset_parameters) -> bool
        Call this to start an asset import process. The caller must specify the source data.
        This process can import many different assets into the game content.
        
        Args:
            content_path (str): The path where the imported assets will be created.
            source_data (InterchangeSourceData): The source data input to translate.
            import_asset_parameters (ImportAssetParameters): All parameters that need to be passed to the import asset function.
        
        Returns:
            bool: true if the import succeeds, or false otherwise.
        """
        ...
    def get_registered_factory_class(self, class_to_make: Class) -> Class:
        r"""
        x.get_registered_factory_class(class_to_make) -> type(Class)
        Script helper to get a registered factory for a specified class.
        return:: The registered factory class if found, or NULL if no registered factory was found.
        
        Args:
            class_to_make (type(Class)): 
        
        Returns:
            type(Class):
        """
        ...
    @classmethod
    def get_interchange_manager_scripted(cls) -> InterchangeManager:
        r"""
        X.get_interchange_manager_scripted() -> InterchangeManager
        Return the pointer to the Interchange Manager singleton.
        note: We need to return a pointer to have a valid Blueprint-callable function.
        
        Returns:
            InterchangeManager:
        """
        ...
    def export_scene(self, world: Object, is_automated: bool = False) -> bool:
        r"""
        x.export_scene(world, is_automated=False) -> bool
        Call this to start a scene export process. The caller must specify a source data.
        
        Args:
            world (Object): The scene to export.
            is_automated (bool): If true, the import process will not show any UI or dialogs.
        
        Returns:
            bool: true if the export succeeds, or false otherwise.
        """
        ...
    def export_asset(self, asset: Object, is_automated: bool = False) -> bool:
        r"""
        x.export_asset(asset, is_automated=False) -> bool
        Call this to start an asset export process. The caller must specify a source data.
        
        Args:
            asset (Object): The asset to export.
            is_automated (bool): If true, the exporter will not show any UI or dialogs.
        
        Returns:
            bool: true if the export succeeds, or false otherwise.
        """
        ...
    @classmethod
    def create_source_data(cls, file_name: str) -> InterchangeSourceData:
        r"""
        X.create_source_data(file_name) -> InterchangeSourceData
        * Script helper to create a source data object that points to a file on disk.
        *
        return:: A new UInterchangeSourceData.
        
        Args:
            file_name (str): 
        
        Returns:
            InterchangeSourceData:
        """
        ...

class AssetTools(Interface):
    r"""
    Asset Tools
    
    **C++ Source:**
    
    - **Module**: AssetTools
    - **File**: IAssetTools.h
    
    """
    def rename_referencing_soft_object_paths(self, packages_to_check: Array[Package], asset_redirector_map: Map[SoftObjectPath, SoftObjectPath]) -> None:
        r"""
        x.rename_referencing_soft_object_paths(packages_to_check, asset_redirector_map) -> None
        Function that renames all FSoftObjectPath object with the old asset path to the new one.
        
        Args:
            packages_to_check (Array[Package]): Packages to check for referencing FSoftObjectPath.
            asset_redirector_map (Map[SoftObjectPath, SoftObjectPath]): Map from old asset path to new asset path
        """
        ...
    def rename_assets_with_dialog(self, assets_and_names: Array[AssetRenameData], auto_checkout: bool = False) -> AssetRenameResult:
        r"""
        x.rename_assets_with_dialog(assets_and_names, auto_checkout=False) -> AssetRenameResult
        Renames assets using the specified names.
        
        Args:
            assets_and_names (Array[AssetRenameData]): 
            auto_checkout (bool): 
        
        Returns:
            AssetRenameResult:
        """
        ...
    def rename_assets(self, assets_and_names: Array[AssetRenameData]) -> bool:
        r"""
        x.rename_assets(assets_and_names) -> bool
        Renames assets using the specified names.
        
        Args:
            assets_and_names (Array[AssetRenameData]): 
        
        Returns:
            bool:
        """
        ...
    def open_editor_for_assets(self, assets: Array[Object]) -> None:
        r"""
        x.open_editor_for_assets(assets) -> None
        Opens editor for assets
        deprecated: Please use UAssetEditorSubsystem::OpenEditorForAssets instead.
        
        Args:
            assets (Array[Object]):
        """
        ...
    def migrate_packages(self, package_names_to_migrate: Array[Name], destination_path: str, options: MigrationOptions = [False, False, AssetMigrationConflict.SKIP, ""]) -> None:
        r"""
        x.migrate_packages(package_names_to_migrate, destination_path, options=[False, False, AssetMigrationConflict.SKIP, ""]) -> None
        Migrate packages and dependencies to another folder
        
        Args:
            package_names_to_migrate (Array[Name]): 
            destination_path (str): 
            options (MigrationOptions):
        """
        ...
    def import_asset_tasks(self, import_tasks: Array[AssetImportTask]) -> None:
        r"""
        x.import_asset_tasks(import_tasks) -> None
        Imports assets using tasks specified.
        
        Args:
            import_tasks (Array[AssetImportTask]): Tasks that specify how to import each file
        """
        ...
    def import_assets_with_dialog(self, destination_path: str) -> Array[Object]:
        r"""
        x.import_assets_with_dialog(destination_path) -> Array[Object]
        Opens a file open dialog to choose files to import to the destination path.
        
        Args:
            destination_path (str): Path to import files to
        
        Returns:
            Array[Object]: list of successfully imported assets
        """
        ...
    def import_assets_automated(self, import_data: AutomatedAssetImportData) -> Array[Object]:
        r"""
        x.import_assets_automated(import_data) -> Array[Object]
        Imports assets using data specified completely up front.  Does not ever ask any questions of the user or show any modal error messages
        
        Args:
            import_data (AutomatedAssetImportData): 
        
        Returns:
            Array[Object]: list of successfully imported assets
        """
        ...
    def find_soft_references_to_object(self, target_object: SoftObjectPath) -> Array[Object]:
        r"""
        x.find_soft_references_to_object(target_object) -> Array[Object]
        Returns list of objects that soft reference the given soft object path. This will load assets into memory to verify
        
        Args:
            target_object (SoftObjectPath): 
        
        Returns:
            Array[Object]: 
        
            referencing_objects (Array[Object]):
        """
        ...
    def export_assets_with_dialog(self, assets_to_export: Array[str], prompt_for_individual_filenames: bool) -> None:
        r"""
        x.export_assets_with_dialog(assets_to_export, prompt_for_individual_filenames) -> None
        Exports the specified objects to file. First prompting the user to pick an export directory and optionally prompting the user to pick a unique directory per file
        
        Args:
            assets_to_export (Array[str]): List of assets to export
            prompt_for_individual_filenames (bool):
        """
        ...
    def export_assets(self, assets_to_export: Array[str], export_path: str) -> None:
        r"""
        x.export_assets(assets_to_export, export_path) -> None
        Exports the specified objects to file.
        
        Args:
            assets_to_export (Array[str]): List of full asset names (e.g /Game/Path/Asset) to export
            export_path (str): The directory path to export to.
        """
        ...
    def duplicate_asset_with_dialog_and_title(self, asset_name: str, package_path: str, original_object: Object, dialog_title: Text) -> Object:
        r"""
        x.duplicate_asset_with_dialog_and_title(asset_name, package_path, original_object, dialog_title) -> Object
        Opens an asset picker dialog and creates an asset with the specified name and path.
        Uses OriginalObject as the duplication source.
        Uses DialogTitle as the dialog's title.
        
        Args:
            asset_name (str): 
            package_path (str): 
            original_object (Object): 
            dialog_title (Text): 
        
        Returns:
            Object:
        """
        ...
    def duplicate_asset_with_dialog(self, asset_name: str, package_path: str, original_object: Object) -> Object:
        r"""
        x.duplicate_asset_with_dialog(asset_name, package_path, original_object) -> Object
        Opens an asset picker dialog and creates an asset with the specified name and path. Uses OriginalObject as the duplication source.
        
        Args:
            asset_name (str): 
            package_path (str): 
            original_object (Object): 
        
        Returns:
            Object:
        """
        ...
    def duplicate_asset(self, asset_name: str, package_path: str, original_object: Object) -> Object:
        r"""
        x.duplicate_asset(asset_name, package_path, original_object) -> Object
        Creates an asset with the specified name and path. Uses OriginalObject as the duplication source.
        
        Args:
            asset_name (str): 
            package_path (str): 
            original_object (Object): 
        
        Returns:
            Object:
        """
        ...
    def diff_assets(self, old_asset: Object, new_asset: Object, old_revision: RevisionInfo, new_revision: RevisionInfo) -> None:
        r"""
        x.diff_assets(old_asset, new_asset, old_revision, new_revision) -> None
        Try and diff two assets using class-specific tool. Will do nothing if either asset is NULL, or they are not the same class.
        
        Args:
            old_asset (Object): 
            new_asset (Object): 
            old_revision (RevisionInfo): 
            new_revision (RevisionInfo):
        """
        ...
    def diff_against_depot(self, object: Object, package_path: str, package_name: str) -> None:
        r"""
        x.diff_against_depot(object, package_path, package_name) -> None
        Try to diff the local version of an asset against the latest one from the depot
        
        Args:
            object (Object): The object we want to compare against the depot
            package_path (str): The fullpath to the package
            package_name (str): The name of the package
        """
        ...
    def create_unique_asset_name(self, base_package_name: str, suffix: str) -> Tuple[str, str]:
        r"""
        x.create_unique_asset_name(base_package_name, suffix) -> (out_package_name=str, out_asset_name=str)
        Creates a unique package and asset name taking the form InBasePackageName+InSuffix
        
        Args:
            base_package_name (str): 
            suffix (str): 
        
        Returns:
            tuple: 
        
            out_package_name (str): 
        
            out_asset_name (str):
        """
        ...
    def create_asset_with_dialog(self, asset_name: str, package_path: str, asset_class: Class, factory: Factory, calling_context: Name = "None", call_configure_properties: bool = True) -> Object:
        r"""
        x.create_asset_with_dialog(asset_name, package_path, asset_class, factory, calling_context="None", call_configure_properties=True) -> Object
        Opens an asset picker dialog and creates an asset with the specified name and path
        
        Args:
            asset_name (str): 
            package_path (str): 
            asset_class (type(Class)): 
            factory (Factory): 
            calling_context (Name): 
            call_configure_properties (bool): 
        
        Returns:
            Object:
        """
        ...
    def create_asset(self, asset_name: str, package_path: str, asset_class: Class, factory: Factory, calling_context: Name = "None") -> Object:
        r"""
        x.create_asset(asset_name, package_path, asset_class, factory, calling_context="None") -> Object
        Creates an asset with the specified name, path, and factory
        
        Args:
            asset_name (str): the name of the new asset
            package_path (str): the package that will contain the new asset
            asset_class (type(Class)): the class of the new asset
            factory (Factory): the factory that will build the new asset
            calling_context (Name): optional name of the module or method calling CreateAsset() - this is passed to the factory
        
        Returns:
            Object: the new asset or NULL if it fails
        """
        ...
    def begin_advanced_copy_packages(self, input_names_to_copy: Array[Name], target_path: str, on_copy_complete: AdvancedCopyCompletedEvent) -> None:
        r"""
        x.begin_advanced_copy_packages(input_names_to_copy, target_path, on_copy_complete) -> None
        Begin Advanced Copy Packages
        
        Args:
            input_names_to_copy (Array[Name]): 
            target_path (str): 
            on_copy_complete (AdvancedCopyCompletedEvent):
        """
        ...

class AssetToolsHelpers(Object):
    r"""
    Asset Tools Helpers
    
    **C++ Source:**
    
    - **Module**: AssetTools
    - **File**: IAssetTools.h
    
    """
    @classmethod
    def get_asset_tools(cls) -> AssetTools:
        r"""
        X.get_asset_tools() -> AssetTools
        Get Asset Tools
        
        Returns:
            AssetTools:
        """
        ...

class SourceControl(Object):
    r"""
    Editor source control common functionality.
    note: Many of these source control methods use *smart* file strings which can be one of: - fully qualified path - relative path - long package name - asset path - export text path (often stored on clipboard) For example: - D:\Epic\Dev-Ent\Projects\Python3rdBP\Content\Mannequin\Animations\ThirdPersonIdle.uasset - Content\Mannequin\Animations\ThirdPersonIdle.uasset - /Game/Mannequin/Animations/ThirdPersonIdle - /Game/Mannequin/Animations/ThirdPersonIdle.ThirdPersonIdle - AnimSequence'/Game/Mannequin/Animations/ThirdPersonIdle.ThirdPersonIdle'
    
    **C++ Source:**
    
    - **Module**: SourceControl
    - **File**: SourceControlHelpers.h
    
    """
    @classmethod
    def sync_files(cls, files: Array[str], silent: bool = False) -> bool:
        r"""
        X.sync_files(files, silent=False) -> bool
        Use currently set source control provider to sync files or directories to the head revision.
        note: Blocks until action is complete.
        
        Args:
            files (Array[str]): Files or directories to sync - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def sync_file(cls, file: str, silent: bool = False) -> bool:
        r"""
        X.sync_file(file, silent=False) -> bool
        Use currently set source control provider to sync a file or directory to the head revision.
        note: Blocks until action is complete.
        
        Args:
            file (str): The file or directory to sync - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def revert_unchanged_files(cls, files: Array[str], silent: bool = False) -> bool:
        r"""
        X.revert_unchanged_files(files, silent=False) -> bool
        Use currently set source control provider to revert files provided no changes have been made.
        note: Blocks until action is complete.
        
        Args:
            files (Array[str]): Files to check out - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def revert_unchanged_file(cls, file: str, silent: bool = False) -> bool:
        r"""
        X.revert_unchanged_file(file, silent=False) -> bool
        Use currently set source control provider to revert a file provided no changes have been made.
        note: Blocks until action is complete.
        
        Args:
            file (str): File to check out - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def revert_files(cls, files: Array[str], silent: bool = False) -> bool:
        r"""
        X.revert_files(files, silent=False) -> bool
        Use currently set source control provider to revert files regardless whether any changes will be lost or not.
        note: Blocks until action is complete.
        
        Args:
            files (Array[str]): Files to revert - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def revert_file(cls, file: str, silent: bool = False) -> bool:
        r"""
        X.revert_file(file, silent=False) -> bool
        Use currently set source control provider to revert a file regardless whether any changes will be lost or not.
        note: Blocks until action is complete.
        
        Args:
            file (str): The file to revert - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def revert_and_reload_packages(cls, packages_to_revert: Array[str], revert_all: bool = False, reload_world: bool = False) -> bool:
        r"""
        X.revert_and_reload_packages(packages_to_revert, revert_all=False, reload_world=False) -> bool
        Reverts the provided files then reloads packages.
        
        Args:
            packages_to_revert (Array[str]): The packages to revert
            revert_all (bool): Whether to revert all files
            reload_world (bool): Reload the world
        
        Returns:
            bool: true if succeeded.
        """
        ...
    @classmethod
    def query_file_state(cls, file: str, silent: bool = False) -> SourceControlState:
        r"""
        X.query_file_state(file, silent=False) -> SourceControlState
        Use currently set source control provider to query a file's source control state.
        note: Blocks until action is complete.
        
        Args:
            file (str): The file to query - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            SourceControlState: Source control state - see USourceControlState. It will have bIsValid set to false if it could not have its values set.
        """
        ...
    @classmethod
    def mark_files_for_delete(cls, files: Array[str], silent: bool = False) -> bool:
        r"""
        X.mark_files_for_delete(files, silent=False) -> bool
        Use currently set source control provider to remove files from source control and delete the files.
        note: Blocks until action is complete.
        
        Args:
            files (Array[str]): 
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def mark_files_for_add(cls, files: Array[str], silent: bool = False) -> bool:
        r"""
        X.mark_files_for_add(files, silent=False) -> bool
        Use currently set source control provider to mark files for add. Does nothing (and returns true) for any file that is already under SC
        note: Blocks until action is complete.
        
        Args:
            files (Array[str]): Files to check out - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def mark_file_for_delete(cls, file: str, silent: bool = False) -> bool:
        r"""
        X.mark_file_for_delete(file, silent=False) -> bool
        Use currently set source control provider to remove file from source control and
        delete the file.
        note: Blocks until action is complete.
        
        Args:
            file (str): The file to delete - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def mark_file_for_add(cls, file: str, silent: bool = False) -> bool:
        r"""
        X.mark_file_for_add(file, silent=False) -> bool
        Use currently set source control provider to mark a file for add. Does nothing (and returns true) if the file is already under SC
        note: Blocks until action is complete.
        
        Args:
            file (str): The file to add - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def last_error_msg(cls) -> Text:
        r"""
        X.last_error_msg() -> Text
        Get status text set by SourceControl system if an error occurs regardless whether bSilent is set or not.
        Only set if there was an error.
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def is_enabled(cls) -> bool:
        r"""
        X.is_enabled() -> bool
        Determine if there is a source control system enabled
        
        Returns:
            bool: true if enabled, false if not
        """
        ...
    @classmethod
    def is_available(cls) -> bool:
        r"""
        X.is_available() -> bool
        Quick check if currently set source control provider is enabled and available for use
        (server-based providers can use this to return whether the server is available or not)
        
        Returns:
            bool: true if source control is available, false if it is not
        """
        ...
    @classmethod
    def current_provider(cls) -> str:
        r"""
        X.current_provider() -> str
        Determine the name of the current source control provider.
        
        Returns:
            str: the name of the current source control provider. If one is not set then "None" is returned.
        """
        ...
    @classmethod
    def copy_file(cls, source_file: str, dest_file: str, silent: bool = False) -> bool:
        r"""
        X.copy_file(source_file, dest_file, silent=False) -> bool
        Use currently set source control provider to copy a file.
        note: Blocks until action is complete.
        
        Args:
            source_file (str): Source file string to copy from - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            dest_file (str): Source file string to copy to - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard). If package, then uses same extension as source file.
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def check_out_or_add_files(cls, files: Array[str], silent: bool = False) -> bool:
        r"""
        X.check_out_or_add_files(files, silent=False) -> bool
        Use currently set source control provider to check out files or mark them for add.
        note: Blocks until action is complete.
        
        Args:
            files (Array[str]): The files to check out/add - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def check_out_or_add_file(cls, file: str, silent: bool = False) -> bool:
        r"""
        X.check_out_or_add_file(file, silent=False) -> bool
        Use currently set source control provider to check out file or mark it for add.
        note: Blocks until action is complete.
        
        Args:
            file (str): The file to check out/add - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def check_out_files(cls, files: Array[str], silent: bool = False) -> bool:
        r"""
        X.check_out_files(files, silent=False) -> bool
        Use currently set source control provider to check out specified files.
        note: Blocks until action is complete.
        
        Args:
            files (Array[str]): Files to check out - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def check_out_file(cls, file: str, silent: bool = False) -> bool:
        r"""
        X.check_out_file(file, silent=False) -> bool
        Use currently set source control provider to check out a file.
        note: Blocks until action is complete.
        
        Args:
            file (str): The file to check out - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def check_in_files(cls, files: Array[str], description: str, silent: bool = False, keep_checked_out: bool = False) -> bool:
        r"""
        X.check_in_files(files, description, silent=False, keep_checked_out=False) -> bool
        Use currently set source control provider to check in specified files.
        note: Blocks until action is complete.
        
        Args:
            files (Array[str]): Files to check out - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            description (str): Description for check in
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
            keep_checked_out (bool): Keep files checked-out after checking in. This is helpful for maintaining "ownership" of files if further operations are needed.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def check_in_file(cls, file: str, description: str, silent: bool = False, keep_checked_out: bool = False) -> bool:
        r"""
        X.check_in_file(file, description, silent=False, keep_checked_out=False) -> bool
        Use currently set source control provider to check in a file.
        note: Blocks until action is complete.
        
        Args:
            file (str): The file to check in - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            description (str): Description for check in
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
            keep_checked_out (bool): Keep files checked-out after checking in. This is helpful for maintaining "ownership" of files if further operations are needed.
        
        Returns:
            bool: true if succeeded, false if failed and can call LastErrorMsg() for more info.
        """
        ...
    @classmethod
    def async_query_file_state(cls, file_state_callback: QueryFileStateDelegate, file: str, silent: bool = False) -> None:
        r"""
        X.async_query_file_state(file_state_callback, file, silent=False) -> None
        Query the source control state of the specified file, asynchronously.
        
        Args:
            file_state_callback (QueryFileStateDelegate): Source control state - see USourceControlState. It will have bIsValid set to false if it could not have its values set.
            file (str): The file to query - can be either fully qualified path, relative path, long package name, asset path or export text path (often stored on clipboard)
            silent (bool): if false (default) then write out any error info to the Log. Any error text can be retrieved by LastErrorMsg() regardless.
        """
        ...

class BlueprintEditorToolMenuContext(Object):
    r"""
    Blueprint Editor Tool Menu Context
    
    **C++ Source:**
    
    - **Module**: Kismet
    - **File**: BlueprintEditorContext.h
    
    """
    def get_blueprint_obj(self) -> Blueprint:
        r"""
        x.get_blueprint_obj() -> Blueprint
        Get Blueprint Obj
        
        Returns:
            Blueprint:
        """
        ...

class AssetEditorContextInterface(Interface):
    r"""
    Asset Editor Context Interface
    
    **C++ Source:**
    
    - **Module**: EditorFramework
    - **File**: AssetEditorContextInterface.h
    
    """
    ...

class AnimationGraph(EdGraph):
    r"""
    Animation Graph
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimationGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_options`` (AnimGraphBlendOptions):  [Read-Write] Blending options for animation graphs in Linked Animation Blueprints.
    """
    def get_graph_nodes_of_class(self, node_class: Class, include_child_classes: bool = True) -> Array[AnimGraphNode_Base]:
        r"""
        x.get_graph_nodes_of_class(node_class, include_child_classes=True) -> Array[AnimGraphNode_Base]
        Returns contained graph nodes of the specified (or child) class
        
        Args:
            node_class (type(Class)): 
            include_child_classes (bool): 
        
        Returns:
            Array[AnimGraphNode_Base]: 
        
            graph_nodes (Array[AnimGraphNode_Base]):
        """
        ...

class AnimationBlendSpaceSampleGraph(AnimationGraph):
    r"""
    Animation Blend Space Sample Graph
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimationBlendSpaceSampleGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_options`` (AnimGraphBlendOptions):  [Read-Write] Blending options for animation graphs in Linked Animation Blueprints.
    """
    ...

class AnimationCustomTransitionGraph(AnimationGraph):
    r"""
    Animation Custom Transition Graph
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimationCustomTransitionGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_options`` (AnimGraphBlendOptions):  [Read-Write] Blending options for animation graphs in Linked Animation Blueprints.
    """
    ...

class AnimationStateGraph(AnimationGraph):
    r"""
    Animation State Graph
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimationStateGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_options`` (AnimGraphBlendOptions):  [Read-Write] Blending options for animation graphs in Linked Animation Blueprints.
    """
    ...

class AnimationTransitionGraph(AnimationGraph):
    r"""
    Animation Transition Graph
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimationTransitionGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_options`` (AnimGraphBlendOptions):  [Read-Write] Blending options for animation graphs in Linked Animation Blueprints.
    """
    ...

class AnimGraphNodeCustomizationInterface(Interface):
    r"""
    Anim Graph Node Customization Interface
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNodeCustomizationInterface.h
    
    """
    def get_title_color(self) -> LinearColor:
        r"""
        x.get_title_color() -> LinearColor
        Get the custom color for this node
        
        Returns:
            LinearColor:
        """
        ...

class EdGraphNode(Object):
    r"""
    Ed Graph Node
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EdGraphNode.h
    
    """
    ...

class K2Node(EdGraphNode):
    r"""
    Abstract base class of all blueprint graph nodes.
    
    **C++ Source:**
    
    - **Module**: BlueprintGraph
    - **File**: K2Node.h
    
    """
    ...

class AnimGraphNode_Base(K2Node):
    r"""
    This is the base class for any animation graph nodes that generate or consume an animation pose in
    the animation blend graph.
    
    Any concrete implementations will be paired with a runtime graph node derived from FAnimNode_Base
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_Base.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_AssetPlayerBase(AnimGraphNode_Base):
    r"""
    Helper / intermediate for asset player graphical nodes
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_AssetPlayerBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BlendSpaceBase(AnimGraphNode_AssetPlayerBase):
    r"""
    Anim Graph Node Blend Space Base
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BlendSpaceBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_AimOffsetLookAt(AnimGraphNode_BlendSpaceBase):
    r"""
    Anim Graph Node Aim Offset Look At
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_AimOffsetLookAt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_AimOffsetLookAt):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_SkeletalControlBase(AnimGraphNode_Base):
    r"""
    This is the base class for the 'source version' of all skeletal control animation graph nodes
    (nodes that manipulate the pose rather than playing animations to create a pose or blending between poses)
    
    Concrete subclasses should contain a member struct derived from FAnimNode_SkeletalControlBase
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_SkeletalControlBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_AnimDynamics(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Anim Dynamics
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_AnimDynamics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_AnimDynamics):  [Read-Write]
    - ``preview_live`` (bool):  [Read-Write] Preview the live physics object on the mesh
    - ``show_angular_limits`` (bool):  [Read-Write] Show angular limit ranges in the viewport
    - ``show_collision_spheres`` (bool):  [Read-Write] If planar limits are enabled and the collision mode isn't CoM, draw sphere collision sizes
    - ``show_linear_limits`` (bool):  [Read-Write] Show linear (prismatic) limits in the viewport
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``show_planar_limit`` (bool):  [Read-Write] Show planar limit info (actual plane, plane normal) in the viewport
    - ``show_spherical_limit`` (bool):  [Read-Write] Show spherical limits in the viewport (preview live only)
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_ApplyAdditive(AnimGraphNode_Base):
    r"""
    Anim Graph Node Apply Additive
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_ApplyAdditive.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_ApplyAdditive):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_ApplyLimits(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Apply Limits
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_ApplyLimits.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_ApplyLimits):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_ApplyMeshSpaceAdditive(AnimGraphNode_Base):
    r"""
    Anim Graph Node Apply Mesh Space Additive
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_ApplyMeshSpaceAdditive.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_ApplyMeshSpaceAdditive):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BlendBoneByChannel(AnimGraphNode_Base):
    r"""
    Anim Graph Node Blend Bone by Channel
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BlendBoneByChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``blend_node`` (AnimNode_BlendBoneByChannel):  [Read-Write]
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BlendListBase(AnimGraphNode_Base):
    r"""
    Anim Graph Node Blend List Base
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BlendListBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BlendListByBool(AnimGraphNode_BlendListBase):
    r"""
    Anim Graph Node Blend List by Bool
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BlendListByBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_BlendListByBool):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BlendListByEnum(AnimGraphNode_BlendListBase):
    r"""
    Anim Graph Node Blend List by Enum
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BlendListByEnum.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_BlendListByEnum):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BlendListByInt(AnimGraphNode_BlendListBase):
    r"""
    Anim Graph Node Blend List by Int
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BlendListByInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_BlendListByInt):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BlendSpaceEvaluator(AnimGraphNode_BlendSpaceBase):
    r"""
    Anim Graph Node Blend Space Evaluator
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BlendSpaceEvaluator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_BlendSpaceEvaluator):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BlendSpaceGraphBase(AnimGraphNode_Base):
    r"""
    Anim Graph Node Blend Space Graph Base
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BlendSpaceGraphBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BlendSpaceGraph(AnimGraphNode_BlendSpaceGraphBase):
    r"""
    Anim Graph Node Blend Space Graph
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BlendSpaceGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_BlendSpaceGraph):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BlendSpacePlayer(AnimGraphNode_BlendSpaceBase):
    r"""
    Anim Graph Node Blend Space Player
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BlendSpacePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_BlendSpacePlayer):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BlendSpace(AnimGraphNode_BlendSpacePlayer):
    r"""
    deprecated: 'AnimGraphNode_BlendSpace' was renamed to 'AnimGraphNode_BlendSpacePlayer'.
    """
    ...

class AnimGraphNode_BlendSpaceSampleResult(AnimGraphNode_Base):
    r"""
    Anim Graph Node Blend Space Sample Result
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BlendSpaceSampleResult.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_BlendSpaceSampleResult):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_BoneDrivenController(AnimGraphNode_SkeletalControlBase):
    r"""
    This is the 'source version' of a bone driven controller, which maps part of the state from one bone to another (e.g., 2 * source.x -> target.z)
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_BoneDrivenController.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_BoneDrivenController):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_CallFunction(AnimGraphNode_Base):
    r"""
    Anim Graph Node Call Function
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_CallFunction.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_CallFunction):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_CCDIK(AnimGraphNode_SkeletalControlBase):
    r"""
    Editor node for CCDIK IK skeletal controller
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_CCDIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_CCDIK):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_ComponentToLocalSpace(AnimGraphNode_Base):
    r"""
    Anim Graph Node Component to Local Space
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_ComponentToLocalSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_ConvertComponentToLocalSpace):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_Constraint(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Constraint
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_Constraint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_Constraint):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_CopyBone(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Copy Bone
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_CopyBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_CopyBone):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_CopyBoneDelta(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Copy Bone Delta
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_CopyBoneDelta.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_CopyBoneDelta):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_CopyPoseFromMesh(AnimGraphNode_Base):
    r"""
    Anim Graph Node Copy Pose from Mesh
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_CopyPoseFromMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_CopyPoseFromMesh):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_CurveSource(AnimGraphNode_Base):
    r"""
    Supply curves from some external source (e.g. audio)
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_CurveSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_CurveSource):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_CustomProperty(AnimGraphNode_Base):
    r"""
    Anim Graph Node Custom Property
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_CustomProperty.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_StateResult(AnimGraphNode_Base):
    r"""
    Anim Graph Node State Result
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_StateResult.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_StateResult):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``state_entry_function`` (MemberReference):  [Read-Write] Function called when the owning state is entered, meaning it becomes the state machine's current state.
    - ``state_exit_function`` (MemberReference):  [Read-Write] Function called when the owning state is exited, meaning it stops being the state machine's current state.
      
      Notes:
      - This will not be called if the state machine node loses relevancy. Please use "On State Interrupt" for that case.
    - ``state_fully_blended_in_function`` (MemberReference):  [Read-Write] Function called when the owning state is fully blended in.
      
      Notes:
      - This is only called for the state machine's current state since its the most recent transition's target state.
      - This will not be called if the state is skipped. This can happen when the flag bSkipFirstUpdateTransition on the state machine node is set to true.
    - ``state_fully_blended_out_function`` (MemberReference):  [Read-Write] Function called when the owning state is fully blended out.
      
      Notes:
      - This will be called for any states that had weight.
      - This will not be called if the state is skipped. This can happen when the flag bSkipFirstUpdateTransition on the state machine node is set to true.
      - This will not be called if the state machine node loses relevancy. Please use "On State Interrupt" for that case.
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_CustomTransitionResult(AnimGraphNode_StateResult):
    r"""
    Anim Graph Node Custom Transition Result
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_CustomTransitionResult.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_StateResult):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``state_entry_function`` (MemberReference):  [Read-Write] Function called when the owning state is entered, meaning it becomes the state machine's current state.
    - ``state_exit_function`` (MemberReference):  [Read-Write] Function called when the owning state is exited, meaning it stops being the state machine's current state.
      
      Notes:
      - This will not be called if the state machine node loses relevancy. Please use "On State Interrupt" for that case.
    - ``state_fully_blended_in_function`` (MemberReference):  [Read-Write] Function called when the owning state is fully blended in.
      
      Notes:
      - This is only called for the state machine's current state since its the most recent transition's target state.
      - This will not be called if the state is skipped. This can happen when the flag bSkipFirstUpdateTransition on the state machine node is set to true.
    - ``state_fully_blended_out_function`` (MemberReference):  [Read-Write] Function called when the owning state is fully blended out.
      
      Notes:
      - This will be called for any states that had weight.
      - This will not be called if the state is skipped. This can happen when the flag bSkipFirstUpdateTransition on the state machine node is set to true.
      - This will not be called if the state machine node loses relevancy. Please use "On State Interrupt" for that case.
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_DeadBlending(AnimGraphNode_Base):
    r"""
    Anim Graph Node Dead Blending
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_DeadBlending.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_DeadBlending):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_Fabrik(AnimGraphNode_SkeletalControlBase):
    r"""
    Editor node for FABRIK IK skeletal controller
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_Fabrik.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_Fabrik):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_HandIKRetargeting(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Hand IKRetargeting
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_HandIKRetargeting.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_HandIKRetargeting):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_RefPoseBase(AnimGraphNode_Base):
    r"""
    Anim Graph Node Ref Pose Base
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_RefPoseBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_RefPose):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_IdentityPose(AnimGraphNode_RefPoseBase):
    r"""
    Anim Graph Node Identity Pose
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_IdentityPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_RefPose):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_Inertialization(AnimGraphNode_Base):
    r"""
    Anim Graph Node Inertialization
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_Inertialization.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_Inertialization):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_LayeredBoneBlend(AnimGraphNode_BlendListBase):
    r"""
    Anim Graph Node Layered Bone Blend
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_LayeredBoneBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_LayeredBoneBlend):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_LegIK(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Leg IK
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_LegIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_LegIK):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_LinkedAnimGraphBase(AnimGraphNode_CustomProperty):
    r"""
    Anim Graph Node Linked Anim Graph Base
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_LinkedAnimGraphBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_SubInstanceBase(AnimGraphNode_LinkedAnimGraphBase):
    r"""
    deprecated: 'AnimGraphNode_SubInstanceBase' was renamed to 'AnimGraphNode_LinkedAnimGraphBase'.
    """
    ...

class AnimGraphNode_LinkedAnimGraph(AnimGraphNode_LinkedAnimGraphBase):
    r"""
    Anim Graph Node Linked Anim Graph
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_LinkedAnimGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_LinkedAnimGraph):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_SubInstance(AnimGraphNode_LinkedAnimGraph):
    r"""
    deprecated: 'AnimGraphNode_SubInstance' was renamed to 'AnimGraphNode_LinkedAnimGraph'.
    """
    ...

class AnimGraphNode_LinkedAnimLayer(AnimGraphNode_LinkedAnimGraphBase):
    r"""
    Anim Graph Node Linked Anim Layer
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_LinkedAnimLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_LinkedAnimLayer):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_Layer(AnimGraphNode_LinkedAnimLayer):
    r"""
    deprecated: 'AnimGraphNode_Layer' was renamed to 'AnimGraphNode_LinkedAnimLayer'.
    """
    ...

class AnimGraphNode_LinkedInputPose(AnimGraphNode_Base):
    r"""
    Anim Graph Node Linked Input Pose
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_LinkedInputPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``inputs`` (Array[AnimBlueprintFunctionPinInfo]):  [Read-Write]
    - ``node`` (AnimNode_LinkedInputPose):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_SubInput(AnimGraphNode_LinkedInputPose):
    r"""
    deprecated: 'AnimGraphNode_SubInput' was renamed to 'AnimGraphNode_LinkedInputPose'.
    """
    ...

class AnimGraphNode_LocalRefPose(AnimGraphNode_RefPoseBase):
    r"""
    Anim Graph Node Local Ref Pose
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_LocalRefPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_RefPose):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_LocalToComponentSpace(AnimGraphNode_Base):
    r"""
    Anim Graph Node Local to Component Space
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_LocalToComponentSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_ConvertLocalToComponentSpace):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_LookAt(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Look At
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_LookAt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_LookAt):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_MakeDynamicAdditive(AnimGraphNode_Base):
    r"""
    Anim Graph Node Make Dynamic Additive
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_MakeDynamicAdditive.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_MakeDynamicAdditive):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_MeshRefPose(AnimGraphNode_Base):
    r"""
    Anim Graph Node Mesh Ref Pose
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_MeshRefPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_MeshSpaceRefPose):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_Mirror(AnimGraphNode_Base):
    r"""
    Anim Graph Node Mirror
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_Mirror.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_Mirror):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_ModifyBone(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Modify Bone
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_ModifyBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_ModifyBone):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_ModifyCurve(AnimGraphNode_Base):
    r"""
    Easy way to modify curve values on a pose
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_ModifyCurve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_ModifyCurve):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_MultiWayBlend(AnimGraphNode_Base):
    r"""
    Anim Graph Node Multi Way Blend
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_MultiWayBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_MultiWayBlend):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_ObserveBone(AnimGraphNode_SkeletalControlBase):
    r"""
    This allows you to observe the state of a bone at a particular point in the graph, showing it in any space and optionally relative to the reference pose
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_ObserveBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_ObserveBone):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_PoseHandler(AnimGraphNode_AssetPlayerBase):
    r"""
    Anim Graph Node Pose Handler
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_PoseHandler.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_PoseBlendNode(AnimGraphNode_PoseHandler):
    r"""
    Anim Graph Node Pose Blend Node
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_PoseBlendNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_PoseBlendNode):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_PoseByName(AnimGraphNode_AssetPlayerBase):
    r"""
    Anim Graph Node Pose by Name
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_PoseByName.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_PoseByName):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_PoseDriver(AnimGraphNode_PoseHandler):
    r"""
    Anim Graph Node Pose Driver
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_PoseDriver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis_length`` (float):  [Read-Write] Length of axis in world units used for debug drawing
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``cone_subdivision`` (int32):  [Read-Write] Number of subdivisions / lines used when debug drawing a cone
    - ``draw_debug_cones`` (bool):  [Read-Write] If checked the cones will be drawn in 3d for debugging
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_PoseDriver):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    @property
    def node(self) -> AnimNode_PoseDriver:
        r"""
        (AnimNode_PoseDriver):  [Read-Write]
        """
        ...
    @node.setter
    def node(self, value: AnimNode_PoseDriver) -> None:
        ...
    def set_source_bones(self, bone_names: Array[Name]) -> None:
        r"""
        x.set_source_bones(bone_names) -> None
        Sets the pose-driver its source bones by name
        
        Args:
            bone_names (Array[Name]):
        """
        ...
    def set_rbf_parameters(self, parameters: RBFParams) -> None:
        r"""
        x.set_rbf_parameters(parameters) -> None
        Set RBFParameters
        
        Args:
            parameters (RBFParams):
        """
        ...
    def set_pose_driver_source(self, driver_source: PoseDriverSource) -> None:
        r"""
        x.set_pose_driver_source(driver_source) -> None
        Set Pose Driver Source
        
        Args:
            driver_source (PoseDriverSource):
        """
        ...
    def set_pose_driver_output(self, driver_output: PoseDriverOutput) -> None:
        r"""
        x.set_pose_driver_output(driver_output) -> None
        Set Pose Driver Output
        
        Args:
            driver_output (PoseDriverOutput):
        """
        ...
    def set_driving_bones(self, bone_names: Array[Name]) -> None:
        r"""
        x.set_driving_bones(bone_names) -> None
        Set the pose-driver its driven bones by name
        
        Args:
            bone_names (Array[Name]):
        """
        ...
    def get_source_bone_names(self) -> Array[Name]:
        r"""
        x.get_source_bone_names() -> Array[Name]
        Returns the pose-driver its source bones by name
        
        Returns:
            Array[Name]: 
        
            bone_names (Array[Name]):
        """
        ...
    def get_rbf_parameters(self) -> RBFParams:
        r"""
        x.get_rbf_parameters() -> RBFParams
        Get RBFParameters
        
        Returns:
            RBFParams:
        """
        ...
    def get_pose_driver_source(self) -> PoseDriverSource:
        r"""
        x.get_pose_driver_source() -> PoseDriverSource
        Get Pose Driver Source
        
        Returns:
            PoseDriverSource:
        """
        ...
    def get_pose_driver_output(self) -> PoseDriverOutput:
        r"""
        x.get_pose_driver_output() -> PoseDriverOutput
        Get Pose Driver Output
        
        Returns:
            PoseDriverOutput:
        """
        ...
    def get_driving_bone_names(self) -> Array[Name]:
        r"""
        x.get_driving_bone_names() -> Array[Name]
        Returns the pose-driver its driven bones by name
        
        Returns:
            Array[Name]: 
        
            bone_names (Array[Name]):
        """
        ...
    def copy_targets_from_pose_asset(self) -> None:
        r"""
        x.copy_targets_from_pose_asset() -> None
        Util to replace current contents of PoseTargets with info from assigned PoseAsset
        """
        ...

class AnimGraphNode_OrientationDriver(AnimGraphNode_PoseDriver):
    r"""
    deprecated: 'AnimGraphNode_OrientationDriver' was renamed to 'AnimGraphNode_PoseDriver'.
    """
    ...

class AnimGraphNode_PoseSnapshot(AnimGraphNode_Base):
    r"""
    Anim Graph Node Pose Snapshot
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_PoseSnapshot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_PoseSnapshot):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_RandomPlayer(AnimGraphNode_Base):
    r"""
    Anim Graph Node Random Player
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_RandomPlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_RandomPlayer):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_ResetRoot(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Reset Root
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_ResetRoot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_ResetRoot):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_RigidBody(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Rigid Body
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_RigidBody.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_RigidBody):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_Ragdoll(AnimGraphNode_RigidBody):
    r"""
    deprecated: 'AnimGraphNode_Ragdoll' was renamed to 'AnimGraphNode_RigidBody'.
    """
    ...

class AnimGraphNode_Root(AnimGraphNode_Base):
    r"""
    Anim Graph Node Root
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_Root.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_Root):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_RotateRootBone(AnimGraphNode_Base):
    r"""
    Anim Graph Node Rotate Root Bone
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_RotateRootBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_RotateRootBone):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_RotationMultiplier(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Rotation Multiplier
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_RotationMultiplier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_RotationMultiplier):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_RotationOffsetBlendSpace(AnimGraphNode_BlendSpaceBase):
    r"""
    Anim Graph Node Rotation Offset Blend Space
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_RotationOffsetBlendSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_RotationOffsetBlendSpace):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_RotationOffsetBlendSpaceGraph(AnimGraphNode_BlendSpaceGraphBase):
    r"""
    Anim Graph Node Rotation Offset Blend Space Graph
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_RotationOffsetBlendSpaceGraph.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_RotationOffsetBlendSpaceGraph):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_SaveCachedPose(AnimGraphNode_Base):
    r"""
    Anim Graph Node Save Cached Pose
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_SaveCachedPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``cache_name`` (str):  [Read-Write]
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_SaveCachedPose):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_ScaleChainLength(AnimGraphNode_Base):
    r"""
    Anim Graph Node Scale Chain Length
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_ScaleChainLength.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_ScaleChainLength):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_SequenceEvaluator(AnimGraphNode_AssetPlayerBase):
    r"""
    Anim Graph Node Sequence Evaluator
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_SequenceEvaluator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_SequenceEvaluator):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_SequencePlayer(AnimGraphNode_AssetPlayerBase):
    r"""
    Anim Graph Node Sequence Player
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_SequencePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_SequencePlayer):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_Slot(AnimGraphNode_Base):
    r"""
    Anim Graph Node Slot
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_Slot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_Slot):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_SplineIK(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Spline IK
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_SplineIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_SplineIK):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_SpringBone(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Spring Bone
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_SpringBone.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_SpringBone):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_StateMachineBase(AnimGraphNode_Base):
    r"""
    Anim Graph Node State Machine Base
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_StateMachineBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_StateMachine(AnimGraphNode_StateMachineBase):
    r"""
    Anim Graph Node State Machine
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_StateMachine.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_StateMachine):  [Read-Write] Runtime state machine representation (empty; populated during compilation)
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_Sync(AnimGraphNode_Base):
    r"""
    Anim Graph Node Sync
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_Sync.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_Sync):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_Trail(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Trail
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_Trail.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_Trail):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_TransitionPoseEvaluator(AnimGraphNode_Base):
    r"""
    Anim Graph Node Transition Pose Evaluator
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_TransitionPoseEvaluator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_TransitionPoseEvaluator):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    @property
    def node(self) -> AnimNode_TransitionPoseEvaluator:
        r"""
        (AnimNode_TransitionPoseEvaluator):  [Read-Write]
        """
        ...
    @node.setter
    def node(self, value: AnimNode_TransitionPoseEvaluator) -> None:
        ...

class AnimGraphNode_TransitionResult(AnimGraphNode_Base):
    r"""
    Anim Graph Node Transition Result
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_TransitionResult.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_TransitionResult):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_TwistCorrectiveNode(AnimGraphNode_SkeletalControlBase):
    r"""
    This is the 'source version' of a bone driven controller, which maps part of the state from one bone to another (e.g., 2 * source.x -> target.z)
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_TwistCorrectiveNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_TwistCorrectiveNode):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_TwoBoneIK(AnimGraphNode_SkeletalControlBase):
    r"""
    Anim Graph Node Two Bone IK
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_TwoBoneIK.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``enable_debug_draw`` (bool):  [Read-Write] Enable drawing of the debug information of the node
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_TwoBoneIK):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_TwoWayBlend(AnimGraphNode_Base):
    r"""
    Anim Graph Node Two Way Blend
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_TwoWayBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``blend_node`` (AnimNode_TwoWayBlend):  [Read-Write]
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_UseCachedPose(AnimGraphNode_Base):
    r"""
    Anim Graph Node Use Cached Pose
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNode_UseCachedPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class SkinnedMeshComponent(MeshComponent):
    r"""
    Skinned mesh component that supports bone skinned mesh rendering.
    This class does not support animation.
    see: USkeletalMeshComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capsule_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the capsule indirect shadow can be.
    - ``cast_capsule_direct_shadow`` (bool):  [Read-Write] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for direct shadowing from lights.
      This type of shadowing is approximate but handles extremely wide area shadowing well.  The softness of the shadow depends on the light's LightSourceAngle / SourceRadius.
      This flag will force bCastInsetShadow to be enabled.
    - ``cast_capsule_indirect_shadow`` (bool):  [Read-Write] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for shadowing indirect lighting (from lightmaps or skylight).
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``component_use_fixed_skel_bounds`` (bool):  [Read-Write] When true, skip using the physics asset etc. and always use the fixed bounds defined in the SkeletalMesh.
    - ``consider_all_bodies_for_bounds`` (bool):  [Read-Write] If true, when updating bounds from a PhysicsAsset, consider _all_ BodySetups, not just those flagged with bConsiderForBounds.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disable_morph_target`` (bool):  [Read-Write] Disable Morphtarget for this component.
    - ``display_debug_update_rate_optimizations`` (bool):  [Read-Write] Enable on screen debugging of update rate optimization.
      Red = Skipping 0 frames, Green = skipping 1 frame, Blue = skipping 2 frames, black = skipping more than 2 frames.
      todo:: turn this into a console command.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``enable_update_rate_optimizations`` (bool):  [Read-Write] if TRUE, Owner will determine how often animation will be updated and evaluated. See AnimUpdateRateTick()
      This allows to skip frames for performance. (For example based on visibility and size on screen).
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``forced_lod_model`` (int32):  [Read-Write]
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_leader_pose_component_lod`` (bool):  [Read-Write] Flag that when set will ensure UpdateLODStatus will not take the LeaderPoseComponent's current LOD in consideration when determining the correct LOD level (this requires LeaderPoseComponent's LOD to always be >= determined LOD otherwise bone transforms could be missing
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``leader_pose_component`` (SkinnedMeshComponent):  [Read-Write] If set, this SkeletalMeshComponent will not use its SpaceBase for bone transform, but will
      use the component space transforms from the LeaderPoseComponent. This is used when constructing a character using multiple skeletal meshes sharing the same
      skeleton within the same Actor.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``mesh_deformer`` (MeshDeformer):  [Read-Write] The mesh deformer to use. If no mesh deformer is set from here or the SkeletalMesh, then we fall back to the fixed function deformation.
    - ``mesh_deformer_instance`` (MeshDeformerInstance):  [Read-Write]
      deprecated: Use the GetMeshDeformerInstance function instead
    - ``mesh_deformer_instance_settings`` (MeshDeformerInstanceSettings):  [Read-Only] Object containing instance settings for the bound MeshDeformer.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod_model`` (int32):  [Read-Write] This is the min LOD that this component will use.  (e.g. if set to 2 then only 2+ LOD Models will be used.) This is useful to set on
      meshes which are known to be a certain distance away and still want to have better LODs when zoomed in on them.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether we should use the min lod specified in MinLodModel for this component instead of the min lod in the mesh
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``per_bone_motion_blur`` (bool):  [Read-Write] If true, use per-bone motion blur on this skeletal mesh (requires additional rendering, can be disabled to save performance).
    - ``physics_asset_override`` (PhysicsAsset):  [Read-Write] PhysicsAsset is set in SkeletalMesh by default, but you can override with this value
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``render_static`` (bool):  [Read-Write] If true, render as static in reference pose.
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``set_mesh_deformer`` (bool):  [Read-Write] If true, MeshDeformer will be used. If false, use the default mesh deformer on the SkeletalMesh.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``skeletal_mesh`` (SkeletalMesh):  [Read-Write]
      deprecated: Use USkeletalMeshComponent::GetSkeletalMeshAsset() or GetSkinnedAsset() instead.
    - ``skin_cache_usage`` (Array[SkinCacheUsage]):  [Read-Write] How this Component's LOD uses the skin cache feature. Auto will defer to the asset's (SkeletalMesh) option. If Ray Tracing is enabled, will imply Enabled
    - ``skinned_asset`` (SkinnedAsset):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired streaming distance of streaming textures that uses UV 0.
      1.0 is the default, whereas a higher value makes the textures stream in sooner from far away.
      A lower value (0.0-1.0) makes the textures stream in later (you have to be closer).
      Value can be < 0 (from legcay content, or code changes)
    - ``sync_attach_parent_lod`` (bool):  [Read-Write] If true, this component uses its parents LOD when attached if available
      ForcedLOD can override this change. By default, it will use parent LOD.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_bounds_from_leader_pose_component`` (bool):  [Read-Write] When true, we will just using the bounds from our LeaderPoseComponent.  This is useful for when we have a Mesh Parented
      to the main SkelMesh (e.g. outline mesh or a full body overdraw effect that is toggled) that is always going to be the same
      bounds as parent.  We want to do no calculations in that case.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visibility_based_anim_tick_option`` (VisibilityBasedAnimTickOption):  [Read-Write] * This is tick animation frequency option based on this component rendered or not or using montage
      *  You can change this default value in the INI file
      * Mostly related with performance
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def skeletal_mesh(self) -> SkeletalMesh:
        r"""
        (SkeletalMesh):  [Read-Only]
        deprecated: Use USkeletalMeshComponent::GetSkeletalMeshAsset() or GetSkinnedAsset() instead.
        """
        ...
    @property
    def skinned_asset(self) -> SkinnedAsset:
        r"""
        (SkinnedAsset):  [Read-Only]
        """
        ...
    @property
    def leader_pose_component(self) -> SkinnedMeshComponent:
        r"""
        (SkinnedMeshComponent):  [Read-Only] If set, this SkeletalMeshComponent will not use its SpaceBase for bone transform, but will
        use the component space transforms from the LeaderPoseComponent. This is used when constructing a character using multiple skeletal meshes sharing the same
        skeleton within the same Actor.
        """
        ...
    @property
    def master_pose_component(self) -> SkinnedMeshComponent:
        r"""
        deprecated: 'master_pose_component' was renamed to 'leader_pose_component'.
        """
        ...
    @property
    def skin_cache_usage(self) -> Array[SkinCacheUsage]:
        r"""
        (Array[SkinCacheUsage]):  [Read-Only] How this Component's LOD uses the skin cache feature. Auto will defer to the asset's (SkeletalMesh) option. If Ray Tracing is enabled, will imply Enabled
        """
        ...
    @property
    def set_mesh_deformer(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, MeshDeformer will be used. If false, use the default mesh deformer on the SkeletalMesh.
        """
        ...
    @property
    def mesh_deformer(self) -> MeshDeformer:
        r"""
        (MeshDeformer):  [Read-Only] The mesh deformer to use. If no mesh deformer is set from here or the SkeletalMesh, then we fall back to the fixed function deformation.
        """
        ...
    @property
    def mesh_deformer_instance_settings(self) -> MeshDeformerInstanceSettings:
        r"""
        (MeshDeformerInstanceSettings):  [Read-Only] Object containing instance settings for the bound MeshDeformer.
        """
        ...
    @property
    def mesh_deformer_instance(self) -> MeshDeformerInstance:
        r"""
        (MeshDeformerInstance):  [Read-Only]
        deprecated: Use the GetMeshDeformerInstance function instead
        """
        ...
    @property
    def physics_asset_override(self) -> PhysicsAsset:
        r"""
        (PhysicsAsset):  [Read-Only] PhysicsAsset is set in SkeletalMesh by default, but you can override with this value
        """
        ...
    @property
    def forced_lod_model(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def min_lod_model(self) -> int:
        r"""
        (int32):  [Read-Only] This is the min LOD that this component will use.  (e.g. if set to 2 then only 2+ LOD Models will be used.) This is useful to set on
        meshes which are known to be a certain distance away and still want to have better LODs when zoomed in on them.
        """
        ...
    @property
    def streaming_distance_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Allows adjusting the desired streaming distance of streaming textures that uses UV 0.
        1.0 is the default, whereas a higher value makes the textures stream in sooner from far away.
        A lower value (0.0-1.0) makes the textures stream in later (you have to be closer).
        Value can be < 0 (from legcay content, or code changes)
        """
        ...
    @streaming_distance_multiplier.setter
    def streaming_distance_multiplier(self, value: float) -> None:
        ...
    @property
    def visibility_based_anim_tick_option(self) -> VisibilityBasedAnimTickOption:
        r"""
        (VisibilityBasedAnimTickOption):  [Read-Write] * This is tick animation frequency option based on this component rendered or not or using montage
        *  You can change this default value in the INI file
        * Mostly related with performance
        """
        ...
    @visibility_based_anim_tick_option.setter
    def visibility_based_anim_tick_option(self, value: VisibilityBasedAnimTickOption) -> None:
        ...
    @property
    def mesh_component_update_flag(self) -> VisibilityBasedAnimTickOption:
        r"""
        deprecated: 'mesh_component_update_flag' was renamed to 'visibility_based_anim_tick_option'.
        """
        ...
    @mesh_component_update_flag.setter
    def mesh_component_update_flag(self, value: VisibilityBasedAnimTickOption) -> None:
        ...
    @property
    def override_min_lod(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether we should use the min lod specified in MinLodModel for this component instead of the min lod in the mesh
        """
        ...
    @property
    def use_bounds_from_leader_pose_component(self) -> bool:
        r"""
        (bool):  [Read-Write] When true, we will just using the bounds from our LeaderPoseComponent.  This is useful for when we have a Mesh Parented
        to the main SkelMesh (e.g. outline mesh or a full body overdraw effect that is toggled) that is always going to be the same
        bounds as parent.  We want to do no calculations in that case.
        """
        ...
    @use_bounds_from_leader_pose_component.setter
    def use_bounds_from_leader_pose_component(self, value: bool) -> None:
        ...
    @property
    def b_use_bounds_from_master_pose_component(self) -> bool:
        r"""
        deprecated: 'b_use_bounds_from_master_pose_component' was renamed to 'use_bounds_from_leader_pose_component'.
        """
        ...
    @b_use_bounds_from_master_pose_component.setter
    def b_use_bounds_from_master_pose_component(self, value: bool) -> None:
        ...
    @property
    def disable_morph_target(self) -> bool:
        r"""
        (bool):  [Read-Write] Disable Morphtarget for this component.
        """
        ...
    @disable_morph_target.setter
    def disable_morph_target(self, value: bool) -> None:
        ...
    @property
    def per_bone_motion_blur(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, use per-bone motion blur on this skeletal mesh (requires additional rendering, can be disabled to save performance).
        """
        ...
    @property
    def component_use_fixed_skel_bounds(self) -> bool:
        r"""
        (bool):  [Read-Write] When true, skip using the physics asset etc. and always use the fixed bounds defined in the SkeletalMesh.
        """
        ...
    @component_use_fixed_skel_bounds.setter
    def component_use_fixed_skel_bounds(self, value: bool) -> None:
        ...
    @property
    def consider_all_bodies_for_bounds(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, when updating bounds from a PhysicsAsset, consider _all_ BodySetups, not just those flagged with bConsiderForBounds.
        """
        ...
    @consider_all_bodies_for_bounds.setter
    def consider_all_bodies_for_bounds(self, value: bool) -> None:
        ...
    @property
    def sync_attach_parent_lod(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this component uses its parents LOD when attached if available
        ForcedLOD can override this change. By default, it will use parent LOD.
        """
        ...
    @sync_attach_parent_lod.setter
    def sync_attach_parent_lod(self, value: bool) -> None:
        ...
    @property
    def cast_capsule_direct_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for direct shadowing from lights.
        This type of shadowing is approximate but handles extremely wide area shadowing well.  The softness of the shadow depends on the light's LightSourceAngle / SourceRadius.
        This flag will force bCastInsetShadow to be enabled.
        """
        ...
    @property
    def cast_capsule_indirect_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for shadowing indirect lighting (from lightmaps or skylight).
        """
        ...
    @property
    def enable_update_rate_optimizations(self) -> bool:
        r"""
        (bool):  [Read-Write] if TRUE, Owner will determine how often animation will be updated and evaluated. See AnimUpdateRateTick()
        This allows to skip frames for performance. (For example based on visibility and size on screen).
        """
        ...
    @enable_update_rate_optimizations.setter
    def enable_update_rate_optimizations(self, value: bool) -> None:
        ...
    @property
    def display_debug_update_rate_optimizations(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable on screen debugging of update rate optimization.
        Red = Skipping 0 frames, Green = skipping 1 frame, Blue = skipping 2 frames, black = skipping more than 2 frames.
        todo:: turn this into a console command.
        """
        ...
    @display_debug_update_rate_optimizations.setter
    def display_debug_update_rate_optimizations(self, value: bool) -> None:
        ...
    @property
    def render_static(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, render as static in reference pose.
        """
        ...
    @property
    def ignore_leader_pose_component_lod(self) -> bool:
        r"""
        (bool):  [Read-Only] Flag that when set will ensure UpdateLODStatus will not take the LeaderPoseComponent's current LOD in consideration when determining the correct LOD level (this requires LeaderPoseComponent's LOD to always be >= determined LOD otherwise bone transforms could be missing
        """
        ...
    @property
    def b_ignore_master_pose_component_lod(self) -> bool:
        r"""
        deprecated: 'b_ignore_master_pose_component_lod' was renamed to 'ignore_leader_pose_component_lod'.
        """
        ...
    @property
    def capsule_indirect_shadow_min_visibility(self) -> float:
        r"""
        (float):  [Read-Only] Controls how dark the capsule indirect shadow can be.
        """
        ...
    def unset_mesh_deformer(self) -> None:
        r"""
        x.unset_mesh_deformer() -> None
        Unset any MeshDeformer applied to this Component.
        """
        ...
    def unload_skin_weight_profile(self, profile_name: Name) -> None:
        r"""
        x.unload_skin_weight_profile(profile_name) -> None
        Unload a Skin Weight Profile's skin weight buffer (if created)
        
        Args:
            profile_name (Name):
        """
        ...
    def un_hide_bone_by_name(self, bone_name: Name) -> None:
        r"""
        x.un_hide_bone_by_name(bone_name) -> None
        UnHide the specified bone with name.  Currently this just enforces a scale of 0 for the hidden bones.
        Compared to HideBone By Index - This keeps track of list of bones and update when LOD changes
        
        Args:
            bone_name (Name): Name of bone to unhide
        """
        ...
    def transform_to_bone_space(self, bone_name: Name, position: Vector, rotation: Rotator) -> Tuple[Vector, Rotator]:
        r"""
        x.transform_to_bone_space(bone_name, position, rotation) -> (out_position=Vector, out_rotation=Rotator)
        Transform a location/rotation from world space to bone relative space.
        This is handy if you know the location in world space for a bone attachment, as AttachComponent takes location/rotation in bone-relative space.
        
        Args:
            bone_name (Name): Name of bone
            position (Vector): Input position
            rotation (Rotator): Input rotation
        
        Returns:
            tuple: 
        
            out_position (Vector): (out) Transformed position
        
            out_rotation (Rotator): (out) Transformed rotation
        """
        ...
    def transform_from_bone_space(self, bone_name: Name, position: Vector, rotation: Rotator) -> Tuple[Vector, Rotator]:
        r"""
        x.transform_from_bone_space(bone_name, position, rotation) -> (out_position=Vector, out_rotation=Rotator)
        Transform a location/rotation in bone relative space to world space.
        
        Args:
            bone_name (Name): Name of bone
            position (Vector): Input position
            rotation (Rotator): Input rotation
        
        Returns:
            tuple: 
        
            out_position (Vector): (out) Transformed position
        
            out_rotation (Rotator): (out) Transformed rotation
        """
        ...
    def show_material_section(self, material_id: int, section_index: int, show: bool, lod_index: int) -> None:
        r"""
        x.show_material_section(material_id, section_index, show, lod_index) -> None
        Allows hiding of a particular material (by ID) on this instance of a SkeletalMesh.
        
        Args:
            material_id (int32): Index of the material show/hide
            section_index (int32): 
            show (bool): True to show the material, false to hide it
            lod_index (int32): Index of the LOD to modify material visibility within
        """
        ...
    def show_all_material_sections(self, lod_index: int) -> None:
        r"""
        x.show_all_material_sections(lod_index) -> None
        Clear any material visibility modifications made by ShowMaterialSection
        
        Args:
            lod_index (int32):
        """
        ...
    def set_vertex_offset_usage(self, lod_index: int, usage: int) -> None:
        r"""
        x.set_vertex_offset_usage(lod_index, usage) -> None
        Set Vertex Offset Usage
        
        Args:
            lod_index (int32): 
            usage (int32):
        """
        ...
    def set_vertex_color_override_linear_color(self, lod_index: int, vertex_colors: Array[LinearColor]) -> None:
        r"""
        x.set_vertex_color_override_linear_color(lod_index, vertex_colors) -> None
        Allow override of vertex colors on a per-component basis, taking array of Blueprint-friendly LinearColors.
        
        Args:
            lod_index (int32): 
            vertex_colors (Array[LinearColor]):
        """
        ...
    def set_skin_weight_profile(self, profile_name: Name) -> bool:
        r"""
        x.set_skin_weight_profile(profile_name) -> bool
        Setup an override Skin Weight Profile for this component
        
        Args:
            profile_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def set_skin_weight_override(self, lod_index: int, skin_weights: Array[SkelMeshSkinWeightInfo]) -> None:
        r"""
        x.set_skin_weight_override(lod_index, skin_weights) -> None
        Allow override of skin weights on a per-component basis.
        
        Args:
            lod_index (int32): 
            skin_weights (Array[SkelMeshSkinWeightInfo]):
        """
        ...
    def set_skinned_asset_and_update(self, new_mesh: SkinnedAsset, reinit_pose: bool = True) -> None:
        r"""
        x.set_skinned_asset_and_update(new_mesh, reinit_pose=True) -> None
        Change the SkinnedAsset that is rendered for this Component. Will re-initialize the animation tree etc.
        
        Args:
            new_mesh (SkinnedAsset): New mesh to set for this component
            reinit_pose (bool): Whether we should keep current pose or reinitialize.
        """
        ...
    def set_skeletal_mesh(self, new_mesh: SkinnedAsset, reinit_pose: bool = True) -> None:
        r"""
        deprecated: 'set_skeletal_mesh' was renamed to 'set_skinned_asset_and_update'.
        """
        ...
    def set_render_static(self, new_value: bool) -> None:
        r"""
        x.set_render_static(new_value) -> None
        Set whether this skinned mesh should be rendered as static mesh in a reference pose
        
        Args:
            new_value (bool):
        """
        ...
    def set_pre_skinning_offsets(self, lod_index: int, offsets: Array[Vector]) -> None:
        r"""
        x.set_pre_skinning_offsets(lod_index, offsets) -> None
        Set Pre Skinning Offsets
        
        Args:
            lod_index (int32): 
            offsets (Array[Vector]):
        """
        ...
    def set_post_skinning_offsets(self, lod_index: int, offsets: Array[Vector]) -> None:
        r"""
        x.set_post_skinning_offsets(lod_index, offsets) -> None
        Set Post Skinning Offsets
        
        Args:
            lod_index (int32): 
            offsets (Array[Vector]):
        """
        ...
    def set_physics_asset(self, new_physics_asset: PhysicsAsset, force_re_init: bool = False) -> None:
        r"""
        x.set_physics_asset(new_physics_asset, force_re_init=False) -> None
        Override the Physics Asset of the mesh. It uses SkeletalMesh.PhysicsAsset, but if you'd like to override use this function
        
        Args:
            new_physics_asset (PhysicsAsset): New PhysicsAsset
            force_re_init (bool): Force reinitialize
        """
        ...
    def set_min_lod(self, new_min_lod: int) -> None:
        r"""
        x.set_min_lod(new_min_lod) -> None
        Set Min LOD
        deprecated: Use USkinnedMeshComponent::OverrideMinLOD() instead.
        
        Args:
            new_min_lod (int32):
        """
        ...
    def set_mesh_deformer(self, mesh_deformer: MeshDeformer) -> None:
        r"""
        x.set_mesh_deformer(mesh_deformer) -> None
        Change the MeshDeformer that is used for this Component.
        
        Args:
            mesh_deformer (MeshDeformer): New mesh deformer to set for this component
        """
        ...
    def set_leader_pose_component(self, new_leader_bone_component: SkinnedMeshComponent, force_update: bool = False, follower_should_tick_pose: bool = False) -> None:
        r"""
        x.set_leader_pose_component(new_leader_bone_component, force_update=False, follower_should_tick_pose=False) -> None
        Set LeaderPoseComponent for this component
        
        Args:
            new_leader_bone_component (SkinnedMeshComponent): New LeaderPoseComponent
            force_update (bool): If false, the function will be skipped if NewLeaderBoneComponent is the same as currently setup (default)
            follower_should_tick_pose (bool): If false, Follower components will not execute TickPose (default)
        """
        ...
    def set_master_pose_component(self, new_leader_bone_component: SkinnedMeshComponent, force_update: bool = False, follower_should_tick_pose: bool = False) -> None:
        r"""
        deprecated: 'set_master_pose_component' was renamed to 'set_leader_pose_component'.
        """
        ...
    def set_forced_lod(self, new_forced_lod: int) -> None:
        r"""
        x.set_forced_lod(new_forced_lod) -> None
        Set ForcedLodModel of the mesh component
        
        Args:
            new_forced_lod (int32): Set new ForcedLODModel that forces to set the incoming LOD. Range from [1, Max Number of LOD]. This will affect in the next tick update.
        """
        ...
    def set_cast_capsule_indirect_shadow(self, new_value: bool) -> None:
        r"""
        x.set_cast_capsule_indirect_shadow(new_value) -> None
        Set Cast Capsule Indirect Shadow
        
        Args:
            new_value (bool):
        """
        ...
    def set_cast_capsule_direct_shadow(self, new_value: bool) -> None:
        r"""
        x.set_cast_capsule_direct_shadow(new_value) -> None
        Set Cast Capsule Direct Shadow
        
        Args:
            new_value (bool):
        """
        ...
    def set_capsule_indirect_shadow_min_visibility(self, new_value: float) -> None:
        r"""
        x.set_capsule_indirect_shadow_min_visibility(new_value) -> None
        Set Capsule Indirect Shadow Min Visibility
        
        Args:
            new_value (float):
        """
        ...
    def override_min_lod(self, new_min_lod: int) -> None:
        r"""
        x.override_min_lod(new_min_lod) -> None
        Override the Min LOD of the mesh component
        
        Args:
            new_min_lod (int32): Override new MinLodModel that make sure the LOD does not go below of this value. Range from [0, Max Number of LOD - 1]. This will affect in the next tick update.
        """
        ...
    def is_using_skin_weight_profile(self) -> bool:
        r"""
        x.is_using_skin_weight_profile() -> bool
        Check whether or not a Skin Weight Profile is currently set
        
        Returns:
            bool:
        """
        ...
    def is_material_section_shown(self, material_id: int, lod_index: int) -> bool:
        r"""
        x.is_material_section_shown(material_id, lod_index) -> bool
        Returns whether a specific material section is currently hidden on this component (by using ShowMaterialSection)
        
        Args:
            material_id (int32): 
            lod_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def is_bone_hidden_by_name(self, bone_name: Name) -> bool:
        r"""
        x.is_bone_hidden_by_name(bone_name) -> bool
        Determines if the specified bone is hidden.
        
        Args:
            bone_name (Name): Name of bone to check
        
        Returns:
            bool: true if hidden
        """
        ...
    def hide_bone_by_name(self, bone_name: Name, phys_body_option: PhysBodyOp) -> None:
        r"""
        x.hide_bone_by_name(bone_name, phys_body_option) -> None
        Hides the specified bone with name.  Currently this just enforces a scale of 0 for the hidden bones.
        Compared to HideBone By Index - This keeps track of list of bones and update when LOD changes
        
        Args:
            bone_name (Name): Name of bone to hide
            phys_body_option (PhysBodyOp): Option for physics bodies that attach to the bones to be hidden
        """
        ...
    def get_vertex_offset_usage(self, lod_index: int) -> int:
        r"""
        x.get_vertex_offset_usage(lod_index) -> int32
        Get Vertex Offset Usage
        
        Args:
            lod_index (int32): 
        
        Returns:
            int32:
        """
        ...
    def get_twist_and_swing_angle_of_delta_rotation_from_ref_pose(self, bone_name: Name) -> Optional[Tuple[float, float]]:
        r"""
        x.get_twist_and_swing_angle_of_delta_rotation_from_ref_pose(bone_name) -> (out_twist_angle=float, out_swing_angle=float) or None
        Get Twist and Swing Angle in Degree of Delta Rotation from Reference Pose in Local space
        
        First this function gets rotation of current, and rotation of ref pose in local space, and
        And gets twist/swing angle value from refpose aligned.
        
        Args:
            bone_name (Name): Name of the bone
        
        Returns:
            tuple or None: true if succeed. False otherwise. Often due to incorrect bone name.
        
            out_twist_angle (float): TwistAngle in degree
        
            out_swing_angle (float): SwingAngle in degree
        """
        ...
    def get_socket_bone_name(self, socket_name: Name) -> Name:
        r"""
        x.get_socket_bone_name(socket_name) -> Name
        Returns bone name linked to a given named socket on the skeletal mesh component.
        If you're unsure to deal with sockets or bones names, you can use this function to filter through, and always return the bone name.
        
        Args:
            socket_name (Name): 
        
        Returns:
            Name: bone name
        """
        ...
    def get_skinned_asset(self) -> SkinnedAsset:
        r"""
        x.get_skinned_asset() -> SkinnedAsset
        Get the SkinnedAsset rendered for this mesh.
        
        Returns:
            SkinnedAsset: the SkinnedAsset set to this mesh.
        """
        ...
    def get_skeletal_mesh_deprecated(self) -> SkeletalMesh:
        r"""
        x.get_skeletal_mesh_deprecated() -> SkeletalMesh
        Get Skeletal Mesh DEPRECATED
        deprecated: Use USkeletalMeshComponent::GetSkeletalMeshAsset() or GetSkinnedAsset() instead.
        
        Returns:
            SkeletalMesh:
        """
        ...
    def get_ref_pose_transform(self, bone_index: int) -> Transform:
        r"""
        x.get_ref_pose_transform(bone_index) -> Transform
        Gets the local-space transform of a bone in the reference pose.
        
        Args:
            bone_index (int32): Index of the bone
        
        Returns:
            Transform: Local space reference transform
        """
        ...
    def get_ref_pose_position(self, bone_index: int) -> Vector:
        r"""
        x.get_ref_pose_position(bone_index) -> Vector
        Gets the local-space position of a bone in the reference pose.
        
        Args:
            bone_index (int32): Index of the bone
        
        Returns:
            Vector: Local space reference position
        """
        ...
    def get_predicted_lod_level(self) -> int:
        r"""
        x.get_predicted_lod_level() -> int32
        Get predicted LOD level. This value is usually calculated in UpdateLODStatus, but can be modified by skeletal mesh streaming.
        
        Returns:
            int32:
        """
        ...
    def get_parent_bone(self, bone_name: Name) -> Name:
        r"""
        x.get_parent_bone(bone_name) -> Name
        Get Parent Bone of the input bone
        
        Args:
            bone_name (Name): Name of the bone
        
        Returns:
            Name: the name of the parent bone for the specified bone. Returns 'None' if the bone does not exist or it is the root bone
        """
        ...
    def get_num_lo_ds(self) -> int:
        r"""
        x.get_num_lo_ds() -> int32
        Get the number of LODs on this component
        
        Returns:
            int32:
        """
        ...
    def get_num_bones(self) -> int:
        r"""
        x.get_num_bones() -> int32
        Returns the number of bones in the skeleton.
        
        Returns:
            int32:
        """
        ...
    def get_mesh_deformer_instance(self) -> MeshDeformerInstance:
        r"""
        x.get_mesh_deformer_instance() -> MeshDeformerInstance
        Get Mesh Deformer Instance
        
        Returns:
            MeshDeformerInstance:
        """
        ...
    def get_forced_lod(self) -> int:
        r"""
        x.get_forced_lod() -> int32
        Get ForcedLodModel of the mesh component. Note that the actual forced LOD level is the return value minus one and zero means no forced LOD
        
        Returns:
            int32:
        """
        ...
    def get_delta_transform_from_ref_pose(self, bone_name: Name, base_name: Name = "None") -> Transform:
        r"""
        x.get_delta_transform_from_ref_pose(bone_name, base_name="None") -> Transform
        Get delta transform from reference pose based on BaseNode.
        This uses last frame up-to-date transform, so it will have a frame delay if you use this info in the AnimGraph
        
        Args:
            bone_name (Name): Name of the bone
            base_name (Name): Name of the base bone - if none, it will use parent as a base
        
        Returns:
            Transform: the delta transform from refpose in that given space (BaseName)
        """
        ...
    def get_current_skin_weight_profile_name(self) -> Name:
        r"""
        x.get_current_skin_weight_profile_name() -> Name
        Return the name of the Skin Weight Profile that is currently set otherwise returns 'None'
        
        Returns:
            Name:
        """
        ...
    def get_bone_transform(self, bone_name: Name, transform_space: RelativeTransformSpace = RelativeTransformSpace.RTS_WORLD) -> Transform:
        r"""
        x.get_bone_transform(bone_name, transform_space=RelativeTransformSpace.RTS_WORLD) -> Transform
        Get world-space bone transform.
        
        Args:
            bone_name (Name): Name of the the bone to get the transform
            transform_space (RelativeTransformSpace): 
        
        Returns:
            Transform: Bone transform in world space if bone is found. Otherwise it will return component's transform in world space.
        """
        ...
    def get_bone_name(self, bone_index: int) -> Name:
        r"""
        x.get_bone_name(bone_index) -> Name
        Get Bone Name from index
        
        Args:
            bone_index (int32): Index of the bone
        
        Returns:
            Name: the name of the bone at the specified index
        """
        ...
    def get_bone_index(self, bone_name: Name) -> int:
        r"""
        x.get_bone_index(bone_name) -> int32
        Find the index of bone by name. Looks in the current SkeletalMesh being used by this SkeletalMeshComponent.
        see: USkeletalMesh::GetBoneIndex.
        
        Args:
            bone_name (Name): Name of bone to look up
        
        Returns:
            int32: Index of the named bone in the current SkeletalMesh. Will return INDEX_NONE if bone not found.
        """
        ...
    def match_ref_bone(self, bone_name: Name) -> int:
        r"""
        deprecated: 'match_ref_bone' was renamed to 'get_bone_index'.
        """
        ...
    def find_closest_bone_k2(self, test_location: Vector, ignore_scale: float = 0.000000, require_physics_asset: bool = False) -> Tuple[Name, Vector]:
        r"""
        x.find_closest_bone_k2(test_location, ignore_scale=0.000000, require_physics_asset=False) -> (Name, bone_location=Vector)
        finds the closest bone to the given location
        
        Args:
            test_location (Vector): the location to test against
            ignore_scale (float): (optional) if specified, only bones with scaling larger than the specified factor are considered
            require_physics_asset (bool): (optional) if true, only bones with physics will be considered
        
        Returns:
            Vector: the name of the bone that was found, or 'None' if no bone was found
        
            bone_location (Vector): (optional, out) if specified, set to the world space location of the bone that was found, or (0,0,0) if no bone was found
        """
        ...
    def clear_vertex_color_override(self, lod_index: int) -> None:
        r"""
        x.clear_vertex_color_override(lod_index) -> None
        Clear any applied vertex color override
        
        Args:
            lod_index (int32):
        """
        ...
    def clear_skin_weight_profile(self) -> None:
        r"""
        x.clear_skin_weight_profile() -> None
        Clear the Skin Weight Profile from this component, in case it is set
        """
        ...
    def clear_skin_weight_override(self, lod_index: int) -> None:
        r"""
        x.clear_skin_weight_override(lod_index) -> None
        Clear any applied skin weight override
        
        Args:
            lod_index (int32):
        """
        ...
    def bone_is_child_of(self, bone_name: Name, parent_bone_name: Name) -> bool:
        r"""
        x.bone_is_child_of(bone_name, parent_bone_name) -> bool
        Tests if BoneName is child of (or equal to) ParentBoneName.
        
        Args:
            bone_name (Name): Name of the bone
            parent_bone_name (Name): 
        
        Returns:
            bool: true if child (strictly, not same). false otherwise Note - will return false if ChildBoneIndex is the same as ParentBoneIndex ie. must be strictly a child.
        """
        ...

class SkeletalMeshComponent(SkinnedMeshComponent):
    r"""
    SkeletalMeshComponent is used to create an instance of an animated SkeletalMesh asset.
    see: https://docs.unrealengine.com/latest/INT/Engine/Content/Types/SkeletalMeshes/
    see: USkeletalMesh
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_anim_curve_evaluation`` (bool):  [Read-Write] Disable animation curves for this component. If this is set true, no curves will be processed
    - ``allow_cloth_actors`` (bool):  [Read-Write] Toggles creation of cloth simulation. Distinct from the simulation toggle below in that, if off, avoids allocating
      the actors entirely instead of just skipping the simulation step.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``anim_blueprint_generated_class`` (type(AnimBlueprintGeneratedClass)):  [Read-Write]
    - ``anim_class`` (type(Class)):  [Read-Write] The AnimBlueprint class to use. Use 'SetAnimInstanceClass' to change at runtime.
    - ``animation_data`` (SingleAnimationPlayData):  [Read-Write]
    - ``animation_mode`` (AnimationMode):  [Read-Write] Whether to use Animation Blueprint or play Single Animation Asset.
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capsule_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the capsule indirect shadow can be.
    - ``cast_capsule_direct_shadow`` (bool):  [Read-Write] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for direct shadowing from lights.
      This type of shadowing is approximate but handles extremely wide area shadowing well.  The softness of the shadow depends on the light's LightSourceAngle / SourceRadius.
      This flag will force bCastInsetShadow to be enabled.
    - ``cast_capsule_indirect_shadow`` (bool):  [Read-Write] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for shadowing indirect lighting (from lightmaps or skylight).
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``cloth_blend_weight`` (float):  [Read-Write] weight to blend between simulated results and key-framed positions
      if weight is 1.0, shows only cloth simulation results and 0.0 will show only skinned results
    - ``cloth_max_distance_scale`` (float):  [Read-Write]
    - ``cloth_velocity_scale`` (float):  [Read-Write] Scale applied to the component induced velocity of all cloth particles prior to stepping the cloth solver.
      Use 1.0 for fully induced velocity (default), or use 0.0 for no induced velocity, and any other values in between for a reduced induced velocity.
      When set to 0.0, it also provides a way to force the clothing to simulate in local space.
      This value multiplies to individual cloth's velocity scale settings, still allowing for differences in behavior between the various pieces of clothing within the same component.
    - ``clothing_simulation_factory`` (type(Class)):  [Read-Write] Class of the object responsible for
    - ``collide_with_attached_children`` (bool):  [Read-Write] can't collide with part of attached children if total collision volumes exceed 16 capsules or 32 planes per convex
    - ``collide_with_environment`` (bool):  [Read-Write] can't collide with part of environment if total collision volumes exceed 16 capsules or 32 planes per convex
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``component_use_fixed_skel_bounds`` (bool):  [Read-Write] When true, skip using the physics asset etc. and always use the fixed bounds defined in the SkeletalMesh.
    - ``consider_all_bodies_for_bounds`` (bool):  [Read-Write] If true, when updating bounds from a PhysicsAsset, consider _all_ BodySetups, not just those flagged with bConsiderForBounds.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``default_animating_rig_override`` (Object):  [Read-Write] Default Animating Rig to Use if bOverrideDefaultAnimatingRig is true
    - ``defer_kinematic_bone_update`` (bool):  [Read-Write] Whether animation and world transform updates are deferred. If this is on, the kinematic bodies (scene query data) will not update until the next time the physics simulation is run
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disable_cloth_simulation`` (bool):  [Read-Write] Disable cloth simulation and play original animation without simulation
    - ``disable_morph_target`` (bool):  [Read-Write] Disable Morphtarget for this component.
    - ``disable_post_process_blueprint`` (bool):  [Read-Write] Controls whether or not this component will evaluate its post process instance. The post-process
      Instance is dictated by the skeletal mesh so this is used for per-instance control.
    - ``disable_rigid_body_anim_node`` (bool):  [Read-Write] Disable rigid body animation nodes and play original animation without simulation
    - ``display_debug_update_rate_optimizations`` (bool):  [Read-Write] Enable on screen debugging of update rate optimization.
      Red = Skipping 0 frames, Green = skipping 1 frame, Blue = skipping 2 frames, black = skipping more than 2 frames.
      todo:: turn this into a console command.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``enable_per_poly_collision`` (bool):  [Read-Write] Uses skinned data for collision data.
    - ``enable_physics_on_dedicated_server`` (bool):  [Read-Write] If true, simulate physics for this component on a dedicated server.
      This should be set if simulating physics and replicating with a dedicated server.
          Note: This property cannot be changed at runtime.
    - ``enable_update_rate_optimizations`` (bool):  [Read-Write] if TRUE, Owner will determine how often animation will be updated and evaluated. See AnimUpdateRateTick()
      This allows to skip frames for performance. (For example based on visibility and size on screen).
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_collision_update`` (bool):  [Read-Write] Forces the cloth simulation to constantly update its external collisions, at the expense of performance.
      This will help to prevent missed collisions if the cloth's skeletal mesh component isn't moving,
      and when instead, wind or other moving objects are causing new collision shapes to come into the cloth's vicinity.
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``forced_lod_model`` (int32):  [Read-Write]
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``global_anim_rate_scale`` (float):  [Read-Write] Used to scale speed of all animations on this skeletal mesh.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_leader_pose_component_lod`` (bool):  [Read-Write] Flag that when set will ensure UpdateLODStatus will not take the LeaderPoseComponent's current LOD in consideration when determining the correct LOD level (this requires LeaderPoseComponent's LOD to always be >= determined LOD otherwise bone transforms could be missing
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``include_component_location_into_bounds`` (bool):  [Read-Write] If true, the Location of this Component will be included into its bounds calculation
      (this can be useful when using SMU_OnlyTickPoseWhenRendered on a character that moves away from the root and no bones are left near the origin of the component)
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``kinematic_bones_update_type`` (KinematicBonesUpdateToPhysics):  [Read-Write] If we are running physics, should we update non-simulated bones based on the animation bone positions.
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``leader_pose_component`` (SkinnedMeshComponent):  [Read-Write] If set, this SkeletalMeshComponent will not use its SpaceBase for bone transform, but will
      use the component space transforms from the LeaderPoseComponent. This is used when constructing a character using multiple skeletal meshes sharing the same
      skeleton within the same Actor.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``mesh_deformer`` (MeshDeformer):  [Read-Write] The mesh deformer to use. If no mesh deformer is set from here or the SkeletalMesh, then we fall back to the fixed function deformation.
    - ``mesh_deformer_instance`` (MeshDeformerInstance):  [Read-Write]
      deprecated: Use the GetMeshDeformerInstance function instead
    - ``mesh_deformer_instance_settings`` (MeshDeformerInstanceSettings):  [Read-Only] Object containing instance settings for the bound MeshDeformer.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod_model`` (int32):  [Read-Write] This is the min LOD that this component will use.  (e.g. if set to 2 then only 2+ LOD Models will be used.) This is useful to set on
      meshes which are known to be a certain distance away and still want to have better LODs when zoomed in on them.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``no_skeleton_update`` (bool):  [Read-Write] Skips Ticking and Bone Refresh.
    - ``on_anim_initialized`` (OnAnimInitialized):  [Read-Write] Broadcast when the components anim instance is initialized
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_constraint_broken`` (ConstraintBrokenSignature):  [Read-Write] Notification when constraint is broken.
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_plastic_deformation`` (PlasticDeformationEventSignature):  [Read-Write] Notification when constraint plasticity drive target changes.
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_default_animating_rig`` (bool):  [Read-Write] If true, DefaultAnimatingRigOverride will be used. If false, use the DefaultAnimatingRig in the SkeletalMesh
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether we should use the min lod specified in MinLodModel for this component instead of the min lod in the mesh
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``pause_anims`` (bool):  [Read-Write] pauses this component's animations (doesn't tick them, but still refreshes bones)
    - ``per_bone_motion_blur`` (bool):  [Read-Write] If true, use per-bone motion blur on this skeletal mesh (requires additional rendering, can be disabled to save performance).
    - ``physics_asset_override`` (PhysicsAsset):  [Read-Write] PhysicsAsset is set in SkeletalMesh by default, but you can override with this value
    - ``physics_transform_update_mode`` (PhysicsTransformUpdateMode):  [Read-Write] Whether physics simulation updates component transform.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``propagate_curves_to_followers`` (bool):  [Read-Write] If true, propagates calls to ApplyAnimationCurvesToComponent for follower components, only needed if follower components do not tick themselves
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``render_static`` (bool):  [Read-Write] If true, render as static in reference pose.
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``reset_after_teleport`` (bool):  [Read-Write] reset the clothing after moving the clothing position (called teleport)
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``set_mesh_deformer`` (bool):  [Read-Write] If true, MeshDeformer will be used. If false, use the default mesh deformer on the SkeletalMesh.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``skeletal_mesh`` (SkeletalMesh):  [Read-Write]
      deprecated: Use USkeletalMeshComponent::GetSkeletalMeshAsset() or GetSkinnedAsset() instead.
    - ``skeletal_mesh_asset`` (SkeletalMesh):  [Read-Write]
    - ``skin_cache_usage`` (Array[SkinCacheUsage]):  [Read-Write] How this Component's LOD uses the skin cache feature. Auto will defer to the asset's (SkeletalMesh) option. If Ray Tracing is enabled, will imply Enabled
    - ``skinned_asset`` (SkinnedAsset):  [Read-Write]
    - ``skip_bounds_update_when_interpolating`` (bool):  [Read-Write] Whether to skip bounds update when interpolating. Bounds are updated to the target interpolation pose only on ticks when they are evaluated.
    - ``skip_kinematic_update_when_interpolating`` (bool):  [Read-Write] Whether to skip UpdateKinematicBonesToAnim() when interpolating. Kinematic bones are updated to the target interpolation pose only on ticks when they are evaluated.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired streaming distance of streaming textures that uses UV 0.
      1.0 is the default, whereas a higher value makes the textures stream in sooner from far away.
      A lower value (0.0-1.0) makes the textures stream in later (you have to be closer).
      Value can be < 0 (from legcay content, or code changes)
    - ``sync_attach_parent_lod`` (bool):  [Read-Write] If true, this component uses its parents LOD when attached if available
      ForcedLOD can override this change. By default, it will use parent LOD.
    - ``teleport_distance_threshold`` (float):  [Read-Write] Conduct teleportation if the character's movement is greater than this threshold in 1 frame.
      Zero or negative values will skip the check.
      You can also do force teleport manually using ForceNextUpdateTeleport() / ForceNextUpdateTeleportAndReset().
    - ``teleport_rotation_threshold`` (float):  [Read-Write] Rotation threshold in degrees, ranging from 0 to 180.
      Conduct teleportation if the character's rotation is greater than this threshold in 1 frame.
      Zero or negative values will skip the check.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``update_animation_in_editor`` (bool):  [Read-Write] If true, this will Tick until disabled
    - ``update_cloth_in_editor`` (bool):  [Read-Write] If true, will play cloth in editor
    - ``update_joints_from_animation`` (bool):  [Read-Write] If we should pass joint position to joints each frame, so that they can be used by motorized joints to drive the
      ragdoll based on the animation.
    - ``update_mesh_when_kinematic`` (bool):  [Read-Write] If true, then the physics bodies will be used to drive the skeletal mesh even when they are
      kinematic (not simulating), otherwise the skeletal mesh will be driven by the animation input
      when the bodies are kinematic
    - ``update_overlaps_on_animation_finalize`` (bool):  [Read-Write] Controls whether blending in physics bones will refresh overlaps on this component, defaults to true but can be disabled in cases where we know anim->physics blending doesn't meaningfully change overlaps
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_bounds_from_leader_pose_component`` (bool):  [Read-Write] When true, we will just using the bounds from our LeaderPoseComponent.  This is useful for when we have a Mesh Parented
      to the main SkelMesh (e.g. outline mesh or a full body overdraw effect that is toggled) that is always going to be the same
      bounds as parent.  We want to do no calculations in that case.
    - ``use_ref_pose_on_init_anim`` (bool):  [Read-Write] On InitAnim should we set to ref pose (if false use first tick of animation data). If enabled, takes precedence over UAnimationSettings::bTickAnimationOnSkeletalMeshInit
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visibility_based_anim_tick_option`` (VisibilityBasedAnimTickOption):  [Read-Write] * This is tick animation frequency option based on this component rendered or not or using montage
      *  You can change this default value in the INI file
      * Mostly related with performance
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wait_for_parallel_cloth_task`` (bool):  [Read-Write] Whether we should stall the Cloth tick task until the cloth simulation is complete. This is required if we want up-to-date
      cloth data on the game thread, for example if we want to generate particles at cloth vertices.
    """
    @property
    def skeletal_mesh_asset(self) -> SkeletalMesh:
        r"""
        (SkeletalMesh):  [Read-Write]
        """
        ...
    @skeletal_mesh_asset.setter
    def skeletal_mesh_asset(self, value: SkeletalMesh) -> None:
        ...
    @property
    def anim_blueprint_generated_class(self) -> AnimBlueprintGeneratedClass:
        r"""
        (type(AnimBlueprintGeneratedClass)):  [Read-Only]
        """
        ...
    @property
    def animation_blueprint(self) -> AnimBlueprintGeneratedClass:
        r"""
        deprecated: 'animation_blueprint' was renamed to 'anim_blueprint_generated_class'.
        """
        ...
    @property
    def anim_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] The AnimBlueprint class to use. Use 'SetAnimInstanceClass' to change at runtime.
        """
        ...
    @property
    def animation_data(self) -> SingleAnimationPlayData:
        r"""
        (SingleAnimationPlayData):  [Read-Write]
        """
        ...
    @animation_data.setter
    def animation_data(self, value: SingleAnimationPlayData) -> None:
        ...
    @property
    def global_anim_rate_scale(self) -> float:
        r"""
        (float):  [Read-Write] Used to scale speed of all animations on this skeletal mesh.
        """
        ...
    @global_anim_rate_scale.setter
    def global_anim_rate_scale(self, value: float) -> None:
        ...
    @property
    def kinematic_bones_update_type(self) -> KinematicBonesUpdateToPhysics:
        r"""
        (KinematicBonesUpdateToPhysics):  [Read-Write] If we are running physics, should we update non-simulated bones based on the animation bone positions.
        """
        ...
    @kinematic_bones_update_type.setter
    def kinematic_bones_update_type(self, value: KinematicBonesUpdateToPhysics) -> None:
        ...
    @property
    def physics_transform_update_mode(self) -> PhysicsTransformUpdateMode:
        r"""
        (PhysicsTransformUpdateMode):  [Read-Write] Whether physics simulation updates component transform.
        """
        ...
    @physics_transform_update_mode.setter
    def physics_transform_update_mode(self, value: PhysicsTransformUpdateMode) -> None:
        ...
    @property
    def animation_mode(self) -> AnimationMode:
        r"""
        (AnimationMode):  [Read-Only] Whether to use Animation Blueprint or play Single Animation Asset.
        """
        ...
    @property
    def disable_post_process_blueprint(self) -> bool:
        r"""
        (bool):  [Read-Write] Controls whether or not this component will evaluate its post process instance. The post-process
        Instance is dictated by the skeletal mesh so this is used for per-instance control.
        """
        ...
    @disable_post_process_blueprint.setter
    def disable_post_process_blueprint(self, value: bool) -> None:
        ...
    @property
    def enable_physics_on_dedicated_server(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, simulate physics for this component on a dedicated server.
        This should be set if simulating physics and replicating with a dedicated server.
            Note: This property cannot be changed at runtime.
        """
        ...
    @enable_physics_on_dedicated_server.setter
    def enable_physics_on_dedicated_server(self, value: bool) -> None:
        ...
    @property
    def update_mesh_when_kinematic(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, then the physics bodies will be used to drive the skeletal mesh even when they are
        kinematic (not simulating), otherwise the skeletal mesh will be driven by the animation input
        when the bodies are kinematic
        """
        ...
    @update_mesh_when_kinematic.setter
    def update_mesh_when_kinematic(self, value: bool) -> None:
        ...
    @property
    def update_joints_from_animation(self) -> bool:
        r"""
        (bool):  [Read-Write] If we should pass joint position to joints each frame, so that they can be used by motorized joints to drive the
        ragdoll based on the animation.
        """
        ...
    @update_joints_from_animation.setter
    def update_joints_from_animation(self, value: bool) -> None:
        ...
    @property
    def allow_cloth_actors(self) -> bool:
        r"""
        (bool):  [Read-Write] Toggles creation of cloth simulation. Distinct from the simulation toggle below in that, if off, avoids allocating
        the actors entirely instead of just skipping the simulation step.
        """
        ...
    @allow_cloth_actors.setter
    def allow_cloth_actors(self, value: bool) -> None:
        ...
    @property
    def disable_cloth_simulation(self) -> bool:
        r"""
        (bool):  [Read-Write] Disable cloth simulation and play original animation without simulation
        """
        ...
    @disable_cloth_simulation.setter
    def disable_cloth_simulation(self, value: bool) -> None:
        ...
    @property
    def collide_with_environment(self) -> bool:
        r"""
        (bool):  [Read-Write] can't collide with part of environment if total collision volumes exceed 16 capsules or 32 planes per convex
        """
        ...
    @collide_with_environment.setter
    def collide_with_environment(self, value: bool) -> None:
        ...
    @property
    def collide_with_attached_children(self) -> bool:
        r"""
        (bool):  [Read-Write] can't collide with part of attached children if total collision volumes exceed 16 capsules or 32 planes per convex
        """
        ...
    @collide_with_attached_children.setter
    def collide_with_attached_children(self, value: bool) -> None:
        ...
    @property
    def force_collision_update(self) -> bool:
        r"""
        (bool):  [Read-Write] Forces the cloth simulation to constantly update its external collisions, at the expense of performance.
        This will help to prevent missed collisions if the cloth's skeletal mesh component isn't moving,
        and when instead, wind or other moving objects are causing new collision shapes to come into the cloth's vicinity.
        """
        ...
    @force_collision_update.setter
    def force_collision_update(self, value: bool) -> None:
        ...
    @property
    def cloth_velocity_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scale applied to the component induced velocity of all cloth particles prior to stepping the cloth solver.
        Use 1.0 for fully induced velocity (default), or use 0.0 for no induced velocity, and any other values in between for a reduced induced velocity.
        When set to 0.0, it also provides a way to force the clothing to simulate in local space.
        This value multiplies to individual cloth's velocity scale settings, still allowing for differences in behavior between the various pieces of clothing within the same component.
        """
        ...
    @cloth_velocity_scale.setter
    def cloth_velocity_scale(self, value: float) -> None:
        ...
    @property
    def reset_after_teleport(self) -> bool:
        r"""
        (bool):  [Read-Write] reset the clothing after moving the clothing position (called teleport)
        """
        ...
    @reset_after_teleport.setter
    def reset_after_teleport(self, value: bool) -> None:
        ...
    @property
    def defer_kinematic_bone_update(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether animation and world transform updates are deferred. If this is on, the kinematic bodies (scene query data) will not update until the next time the physics simulation is run
        """
        ...
    @property
    def no_skeleton_update(self) -> bool:
        r"""
        (bool):  [Read-Write] Skips Ticking and Bone Refresh.
        """
        ...
    @no_skeleton_update.setter
    def no_skeleton_update(self, value: bool) -> None:
        ...
    @property
    def pause_anims(self) -> bool:
        r"""
        (bool):  [Read-Write] pauses this component's animations (doesn't tick them, but still refreshes bones)
        """
        ...
    @pause_anims.setter
    def pause_anims(self, value: bool) -> None:
        ...
    @property
    def enable_per_poly_collision(self) -> bool:
        r"""
        (bool):  [Read-Only] Uses skinned data for collision data.
        """
        ...
    @property
    def include_component_location_into_bounds(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, the Location of this Component will be included into its bounds calculation
        (this can be useful when using SMU_OnlyTickPoseWhenRendered on a character that moves away from the root and no bones are left near the origin of the component)
        """
        ...
    @property
    def propagate_curves_to_followers(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, propagates calls to ApplyAnimationCurvesToComponent for follower components, only needed if follower components do not tick themselves
        """
        ...
    @propagate_curves_to_followers.setter
    def propagate_curves_to_followers(self, value: bool) -> None:
        ...
    @property
    def b_propagate_curves_to_slaves(self) -> bool:
        r"""
        deprecated: 'b_propagate_curves_to_slaves' was renamed to 'propagate_curves_to_followers'.
        """
        ...
    @b_propagate_curves_to_slaves.setter
    def b_propagate_curves_to_slaves(self, value: bool) -> None:
        ...
    @property
    def skip_kinematic_update_when_interpolating(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to skip UpdateKinematicBonesToAnim() when interpolating. Kinematic bones are updated to the target interpolation pose only on ticks when they are evaluated.
        """
        ...
    @skip_kinematic_update_when_interpolating.setter
    def skip_kinematic_update_when_interpolating(self, value: bool) -> None:
        ...
    @property
    def skip_bounds_update_when_interpolating(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to skip bounds update when interpolating. Bounds are updated to the target interpolation pose only on ticks when they are evaluated.
        """
        ...
    @skip_bounds_update_when_interpolating.setter
    def skip_bounds_update_when_interpolating(self, value: bool) -> None:
        ...
    @property
    def cloth_blend_weight(self) -> float:
        r"""
        (float):  [Read-Write] weight to blend between simulated results and key-framed positions
        if weight is 1.0, shows only cloth simulation results and 0.0 will show only skinned results
        """
        ...
    @cloth_blend_weight.setter
    def cloth_blend_weight(self, value: float) -> None:
        ...
    @property
    def wait_for_parallel_cloth_task(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we should stall the Cloth tick task until the cloth simulation is complete. This is required if we want up-to-date
        cloth data on the game thread, for example if we want to generate particles at cloth vertices.
        """
        ...
    @wait_for_parallel_cloth_task.setter
    def wait_for_parallel_cloth_task(self, value: bool) -> None:
        ...
    @property
    def cloth_max_distance_scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @cloth_max_distance_scale.setter
    def cloth_max_distance_scale(self, value: float) -> None:
        ...
    @property
    def on_constraint_broken(self) -> ConstraintBrokenSignature:
        r"""
        (ConstraintBrokenSignature):  [Read-Write] Notification when constraint is broken.
        """
        ...
    @on_constraint_broken.setter
    def on_constraint_broken(self, value: ConstraintBrokenSignature) -> None:
        ...
    @property
    def on_plastic_deformation(self) -> PlasticDeformationEventSignature:
        r"""
        (PlasticDeformationEventSignature):  [Read-Write] Notification when constraint plasticity drive target changes.
        """
        ...
    @on_plastic_deformation.setter
    def on_plastic_deformation(self, value: PlasticDeformationEventSignature) -> None:
        ...
    @property
    def teleport_distance_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Conduct teleportation if the character's movement is greater than this threshold in 1 frame.
        Zero or negative values will skip the check.
        You can also do force teleport manually using ForceNextUpdateTeleport() / ForceNextUpdateTeleportAndReset().
        """
        ...
    @teleport_distance_threshold.setter
    def teleport_distance_threshold(self, value: float) -> None:
        ...
    @property
    def teleport_rotation_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Rotation threshold in degrees, ranging from 0 to 180.
        Conduct teleportation if the character's rotation is greater than this threshold in 1 frame.
        Zero or negative values will skip the check.
        """
        ...
    @teleport_rotation_threshold.setter
    def teleport_rotation_threshold(self, value: float) -> None:
        ...
    @property
    def on_anim_initialized(self) -> OnAnimInitialized:
        r"""
        (OnAnimInitialized):  [Read-Write] Broadcast when the components anim instance is initialized
        """
        ...
    @on_anim_initialized.setter
    def on_anim_initialized(self, value: OnAnimInitialized) -> None:
        ...
    @property
    def default_animating_rig_override(self) -> Object:
        r"""
        (Object):  [Read-Write] Default Animating Rig to Use if bOverrideDefaultAnimatingRig is true
        """
        ...
    @default_animating_rig_override.setter
    def default_animating_rig_override(self, value: Object) -> None:
        ...
    def unlink_anim_class_layers(self, class_: Class) -> None:
        r"""
        x.unlink_anim_class_layers(class_) -> None
        Runs through all layer nodes, attempting to find layer nodes that are currently running the specified class, then resets each to its default value.
        State sharing rules are as with SetLayerOverlay.
        If InClass is null, does nothing.
        
        Args:
            class_ (type(Class)):
        """
        ...
    def clear_layer_overlay(self, class_: Class) -> None:
        r"""
        deprecated: 'clear_layer_overlay' was renamed to 'unlink_anim_class_layers'.
        """
        ...
    def unbind_cloth_from_leader_pose_component(self, restore_simulation_space: bool = True) -> None:
        r"""
        x.unbind_cloth_from_leader_pose_component(restore_simulation_space=True) -> None
        If this component has a valid LeaderPoseComponent and has previously had its cloth bound to the
        MCP, this function will unbind the cloth and resume simulation.
        
        Args:
            restore_simulation_space (bool): if true and the leader pose cloth was originally simulating in world space, we will restore this setting. This will cause the leader component to reset which may be undesirable.
        """
        ...
    def unbind_cloth_from_master_pose_component(self, restore_simulation_space: bool = True) -> None:
        r"""
        deprecated: 'unbind_cloth_from_master_pose_component' was renamed to 'unbind_cloth_from_leader_pose_component'.
        """
        ...
    def toggle_disable_post_process_blueprint(self) -> None:
        r"""
        x.toggle_disable_post_process_blueprint() -> None
        Toggles whether the post process blueprint will run for this component
        """
        ...
    def term_bodies_below(self, parent_bone_name: Name) -> None:
        r"""
        x.term_bodies_below(parent_bone_name) -> None
        Terminate physics on all bodies below the named bone, effectively disabling collision forever. If you terminate, you won't be able to re-init later.
        
        Args:
            parent_bone_name (Name):
        """
        ...
    def suspend_clothing_simulation(self) -> None:
        r"""
        x.suspend_clothing_simulation() -> None
        Stops simulating clothing, but does not show clothing ref pose. Keeps the last known simulation state
        """
        ...
    def stop(self) -> None:
        r"""
        x.stop() -> None
        Animation play functions
              *
              * These changes status of animation instance, which is transient data, which means it won't serialize with this component
              * Because of that reason, it is not safe to be used during construction script
              * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
        """
        ...
    def snapshot_pose(self, snapshot: PoseSnapshot) -> PoseSnapshot:
        r"""
        x.snapshot_pose(snapshot) -> PoseSnapshot
        Takes a snapshot of this skeletal mesh component's pose and saves it to the specified snapshot.
        The snapshot is taken at the current LOD, so if for example you took the snapshot at LOD1
        and then used it at LOD0 any bones not in LOD1 will use the reference pose
        
        Args:
            snapshot (PoseSnapshot): 
        
        Returns:
            PoseSnapshot: 
        
            snapshot (PoseSnapshot):
        """
        ...
    def set_update_cloth_in_editor(self, new_update_state: bool) -> None:
        r"""
        x.set_update_cloth_in_editor(new_update_state) -> None
        Sets whether or not to animate cloth in the editor. Requires Update Animation In Editor to also be true.
        This is supported only in the editor
        
        Args:
            new_update_state (bool):
        """
        ...
    def set_update_animation_in_editor(self, new_update_state: bool) -> None:
        r"""
        x.set_update_animation_in_editor(new_update_state) -> None
        Sets whether or not to force tick component in order to update animation and refresh transform for this component
        This is supported only in the editor
        
        Args:
            new_update_state (bool):
        """
        ...
    def set_skeletal_mesh_asset(self, new_mesh: SkeletalMesh) -> None:
        r"""
        x.set_skeletal_mesh_asset(new_mesh) -> None
        Set the SkeletalMesh rendered for this mesh.
        
        Args:
            new_mesh (SkeletalMesh):
        """
        ...
    def set_position(self, pos: float, fire_notifies: bool = True) -> None:
        r"""
        x.set_position(pos, fire_notifies=True) -> None
        Animation play functions
              *
              * These changes status of animation instance, which is transient data, which means it won't serialize with this component
              * Because of that reason, it is not safe to be used during construction script
              * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
        
        Args:
            pos (float): 
            fire_notifies (bool):
        """
        ...
    def set_play_rate(self, rate: float) -> None:
        r"""
        x.set_play_rate(rate) -> None
        Animation play functions
              *
              * These changes status of animation instance, which is transient data, which means it won't serialize with this component
              * Because of that reason, it is not safe to be used during construction script
              * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
        
        Args:
            rate (float):
        """
        ...
    def set_physics_blend_weight(self, physics_blend_weight: float) -> None:
        r"""
        x.set_physics_blend_weight(physics_blend_weight) -> None
        This is global set up for setting physics blend weight
        This does multiple things automatically
        If PhysicsBlendWeight == 1.f, it will enable Simulation, and if PhysicsBlendWeight == 0.f, it will disable Simulation.
        Also it will respect each body's setup, so if the body is fixed, it won't simulate. Vice versa
        So if you'd like all bodies to change manually, do not use this function, but SetAllBodiesPhysicsBlendWeight
        
        Args:
            physics_blend_weight (float):
        """
        ...
    def set_notify_rigid_body_collision_below(self, new_notify_rigid_body_collision: bool, bone_name: Name = "None", include_self: bool = True) -> None:
        r"""
        x.set_notify_rigid_body_collision_below(new_notify_rigid_body_collision, bone_name="None", include_self=True) -> None
        Changes the value of bNotifyRigidBodyCollision on all bodies below a given bone
        
        Args:
            new_notify_rigid_body_collision (bool): The value to assign to bNotifyRigidBodyCollision
            bone_name (Name): Name of the body to turn hit notifies on (and below)
            include_self (bool): Whether to modify the given body (useful for roots with multiple children)
        """
        ...
    def set_morph_target(self, morph_target_name: Name, value: float, remove_zero_weight: bool = True) -> None:
        r"""
        x.set_morph_target(morph_target_name, value, remove_zero_weight=True) -> None
        Set Morph Target with Name and Value(0-1)
        
        Args:
            morph_target_name (Name): 
            value (float): 
            remove_zero_weight (bool): : Used by editor code when it should stay in the active list with zero weight
        """
        ...
    def set_enable_physics_blending(self, new_blend_physics: bool) -> None:
        r"""
        x.set_enable_physics_blending(new_blend_physics) -> None
        Disable physics blending of bones *
        
        Args:
            new_blend_physics (bool):
        """
        ...
    def set_enable_gravity_on_all_bodies_below(self, enable_gravity: bool, bone_name: Name, include_self: bool = True) -> None:
        r"""
        x.set_enable_gravity_on_all_bodies_below(enable_gravity, bone_name, include_self=True) -> None
        Enables or disables gravity to all bodies below the given bone.
        NAME_None indicates all bodies will be edited.
        In that case, consider using UPrimitiveComponent::EnableGravity.
        
        Args:
            enable_gravity (bool): Whether gravity should be enabled or disabled.
            bone_name (Name): The name of the top most bone.
            include_self (bool): Whether the bone specified should be edited.
        """
        ...
    def set_enable_body_gravity(self, enable_gravity: bool, bone_name: Name) -> None:
        r"""
        x.set_enable_body_gravity(enable_gravity, bone_name) -> None
        Enables or disables gravity for the given bone.
        NAME_None indicates the root body will be edited.
        If the bone name given is otherwise invalid, nothing happens.
        
        Args:
            enable_gravity (bool): Whether gravity should be enabled or disabled.
            bone_name (Name): The name of the bone to modify.
        """
        ...
    def set_disable_anim_curves(self, disable_anim_curves: bool) -> None:
        r"""
        x.set_disable_anim_curves(disable_anim_curves) -> None
        Set Disable Anim Curves
        
        Args:
            disable_anim_curves (bool):
        """
        ...
    def set_constraint_profile_for_all(self, profile_name: Name, default_if_not_found: bool = False) -> None:
        r"""
        x.set_constraint_profile_for_all(profile_name, default_if_not_found=False) -> None
        Sets the constraint profile properties (limits, motors, etc...) to match the constraint profile as defined in the physics asset for all constraints. If profile name is not found the joint is set to use the default constraint profile.
        
        Args:
            profile_name (Name): 
            default_if_not_found (bool):
        """
        ...
    def set_constraint_profile(self, joint_name: Name, profile_name: Name, default_if_not_found: bool = False) -> None:
        r"""
        x.set_constraint_profile(joint_name, profile_name, default_if_not_found=False) -> None
        Sets the constraint profile properties (limits, motors, etc...) to match the constraint profile as defined in the physics asset. If profile name is not found the joint is set to use the default constraint profile.
        
        Args:
            joint_name (Name): 
            profile_name (Name): 
            default_if_not_found (bool):
        """
        ...
    def set_cloth_max_distance_scale(self, scale: float) -> None:
        r"""
        x.set_cloth_max_distance_scale(scale) -> None
        Set Cloth Max Distance Scale
        
        Args:
            scale (float):
        """
        ...
    def set_body_simulate_physics(self, bone_name: Name, simulate: bool) -> None:
        r"""
        x.set_body_simulate_physics(bone_name, simulate) -> None
        Set a single bone to be simulated (or not)
        
        Args:
            bone_name (Name): 
            simulate (bool):
        """
        ...
    def set_body_notify_rigid_body_collision(self, new_notify_rigid_body_collision: bool, bone_name: Name = "None") -> None:
        r"""
        x.set_body_notify_rigid_body_collision(new_notify_rigid_body_collision, bone_name="None") -> None
        Changes the value of bNotifyRigidBodyCollision for a given body
        
        Args:
            new_notify_rigid_body_collision (bool): The value to assign to bNotifyRigidBodyCollision
            bone_name (Name): Name of the body to turn hit notifies on/off. None implies root body
        """
        ...
    def set_anim_class(self, new_class: Class) -> None:
        r"""
        x.set_anim_class(new_class) -> None
        Set the anim instance class. Clears and re-initializes the anim instance with the new class and sets animation mode to 'AnimationBlueprint'
        
        Args:
            new_class (type(Class)):
        """
        ...
    def set_anim_instance_class(self, new_class: Class) -> None:
        r"""
        deprecated: 'set_anim_instance_class' was renamed to 'set_anim_class'.
        """
        ...
    def k2_set_anim_instance_class(self, new_class: Class) -> None:
        r"""
        deprecated: 'k2_set_anim_instance_class' was renamed to 'set_anim_class'.
        """
        ...
    def set_animation_mode(self, animation_mode: AnimationMode, force_init_anim_script_instance: bool = True) -> None:
        r"""
        x.set_animation_mode(animation_mode, force_init_anim_script_instance=True) -> None
        Set the Animation Mode
        
        Args:
            animation_mode (AnimationMode): : Requested AnimationMode
            force_init_anim_script_instance (bool): : Init AnimScriptInstance if the AnimationMode is AnimationBlueprint even if the new animation mode is the same as current (this allows to use BP construction script to do this)
        """
        ...
    def set_animation(self, new_anim_to_play: AnimationAsset) -> None:
        r"""
        x.set_animation(new_anim_to_play) -> None
        Animation play functions
              *
              * These changes status of animation instance, which is transient data, which means it won't serialize with this component
              * Because of that reason, it is not safe to be used during construction script
              * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
        
        Args:
            new_anim_to_play (AnimationAsset):
        """
        ...
    def set_angular_limits(self, bone_name: Name, swing1_limit_angle: float, twist_limit_angle: float, swing2_limit_angle: float) -> None:
        r"""
        x.set_angular_limits(bone_name, swing1_limit_angle, twist_limit_angle, swing2_limit_angle) -> None
        Sets the Angular Motion Ranges for a named constraint
        
        Args:
            bone_name (Name): Name of bone to adjust constraint ranges for
            swing1_limit_angle (float): Size of limit in degrees, 0 means locked, 180 means free
            twist_limit_angle (float): Size of limit in degrees, 0 means locked, 180 means free
            swing2_limit_angle (float): Size of limit in degrees, 0 means locked, 180 means free
        """
        ...
    def set_allow_rigid_body_anim_node(self, allow: bool, reinit_anim: bool = True) -> None:
        r"""
        x.set_allow_rigid_body_anim_node(allow, reinit_anim=True) -> None
        Sets whether or not to allow rigid body animation nodes for this component
        
        Args:
            allow (bool): 
            reinit_anim (bool):
        """
        ...
    def set_allowed_anim_curves_evaluation(self, list: Array[Name], allow: bool) -> None:
        r"""
        x.set_allowed_anim_curves_evaluation(list, allow) -> None
        resets, and then only allow the following list to be allowed/disallowed
        
        Args:
            list (Array[Name]): 
            allow (bool):
        """
        ...
    def set_allow_cloth_actors(self, allow: bool) -> None:
        r"""
        x.set_allow_cloth_actors(allow) -> None
        Sets whether cloth assets should be created/simulated in this component.
        This will update the conditional flag and you will want to call RecreateClothingActors for it to take effect.
        
        Args:
            allow (bool): Whether to allow the creation of cloth assets and simulation.
        """
        ...
    def set_allow_anim_curve_evaluation(self, allow: bool) -> None:
        r"""
        x.set_allow_anim_curve_evaluation(allow) -> None
        Set Allow Anim Curve Evaluation
        
        Args:
            allow (bool):
        """
        ...
    def set_all_motors_angular_velocity_drive(self, enable_swing_drive: bool, enable_twist_drive: bool, skip_custom_physics_type: bool = False) -> None:
        r"""
        x.set_all_motors_angular_velocity_drive(enable_swing_drive, enable_twist_drive, skip_custom_physics_type=False) -> None
        Enable or Disable AngularVelocityDrive. If motor is in SLERP mode it will be turned on if either EnableSwingDrive OR EnableTwistDrive are enabled. In Twist and Swing mode the twist and the swing can be controlled individually.
        
        Args:
            enable_swing_drive (bool): 
            enable_twist_drive (bool): 
            skip_custom_physics_type (bool):
        """
        ...
    def set_all_motors_angular_position_drive(self, enable_swing_drive: bool, enable_twist_drive: bool, skip_custom_physics_type: bool = False) -> None:
        r"""
        x.set_all_motors_angular_position_drive(enable_swing_drive, enable_twist_drive, skip_custom_physics_type=False) -> None
        Enable or Disable AngularPositionDrive. If motor is in SLERP mode it will be turned on if either EnableSwingDrive OR EnableTwistDrive are enabled. In Twist and Swing mode the twist and the swing can be controlled individually.
        
        Args:
            enable_swing_drive (bool): 
            enable_twist_drive (bool): 
            skip_custom_physics_type (bool):
        """
        ...
    def set_all_motors_angular_drive_params(self, spring: float, damping: float, force_limit: float, skip_custom_physics_type: bool = False) -> None:
        r"""
        x.set_all_motors_angular_drive_params(spring, damping, force_limit, skip_custom_physics_type=False) -> None
        Set Angular Drive motors params for all constraint instances
        
        Args:
            spring (float): 
            damping (float): 
            force_limit (float): 
            skip_custom_physics_type (bool):
        """
        ...
    def set_all_bodies_simulate_physics(self, new_simulate: bool) -> None:
        r"""
        x.set_all_bodies_simulate_physics(new_simulate) -> None
        Set bSimulatePhysics to true for all bone bodies. Does not change the component bSimulatePhysics flag.
        
        Args:
            new_simulate (bool):
        """
        ...
    def set_all_bodies_physics_blend_weight(self, physics_blend_weight: float, skip_custom_physics_type: bool = False) -> None:
        r"""
        x.set_all_bodies_physics_blend_weight(physics_blend_weight, skip_custom_physics_type=False) -> None
        Set All Bodies Physics Blend Weight
        
        Args:
            physics_blend_weight (float): 
            skip_custom_physics_type (bool):
        """
        ...
    def set_all_bodies_below_simulate_physics(self, bone_name: Name, new_simulate: bool, include_self: bool = True) -> None:
        r"""
        x.set_all_bodies_below_simulate_physics(bone_name, new_simulate, include_self=True) -> None
        Set all of the bones below passed in bone to be simulated
        
        Args:
            bone_name (Name): 
            new_simulate (bool): 
            include_self (bool):
        """
        ...
    def set_all_bodies_below_physics_disabled(self, bone_name: Name, disabled: bool, include_self: bool = True) -> None:
        r"""
        x.set_all_bodies_below_physics_disabled(bone_name, disabled, include_self=True) -> None
        [WARNING: Chaos Only]
        Set all of the bones below passed in bone to be disabled or not for the associated physics solver
        Bodies will not be colliding or be part of the physics simulation.
        This is different from SetAllBodiesBelowSimulatePhysics that changes bodies to Kinematic/simulated
        
        Args:
            bone_name (Name): 
            disabled (bool): 
            include_self (bool):
        """
        ...
    def set_all_bodies_below_physics_blend_weight(self, bone_name: Name, physics_blend_weight: float, skip_custom_physics_type: bool = False, include_self: bool = True) -> None:
        r"""
        x.set_all_bodies_below_physics_blend_weight(bone_name, physics_blend_weight, skip_custom_physics_type=False, include_self=True) -> None
        Set all of the bones below passed in bone to be simulated
        
        Args:
            bone_name (Name): 
            physics_blend_weight (float): 
            skip_custom_physics_type (bool): 
            include_self (bool):
        """
        ...
    def set_all_bodies_below_linear_velocity(self, bone_name: Name, linear_velocity: Vector, include_self: bool = True) -> None:
        r"""
        x.set_all_bodies_below_linear_velocity(bone_name, linear_velocity, include_self=True) -> None
        set the linear velocity of the child bodies to match that of the given parent bone
        
        Args:
            bone_name (Name): 
            linear_velocity (Vector): 
            include_self (bool):
        """
        ...
    def resume_clothing_simulation(self) -> None:
        r"""
        x.resume_clothing_simulation() -> None
        Resumes a previously suspended clothing simulation, teleporting the clothing on the next tick
        """
        ...
    def reset_cloth_teleport_mode(self) -> None:
        r"""
        x.reset_cloth_teleport_mode() -> None
        Reset the teleport mode of a next update to 'Continuous'
        """
        ...
    def reset_anim_instance_dynamics(self, teleport_type: TeleportType = TeleportType.RESET_PHYSICS) -> None:
        r"""
        x.reset_anim_instance_dynamics(teleport_type=TeleportType.RESET_PHYSICS) -> None
        Informs any active anim instances (main instance, linked instances, post instance) that a dynamics reset is required
        for example if a teleport occurs.
        
        Args:
            teleport_type (TeleportType):
        """
        ...
    def reset_allowed_anim_curve_evaluation(self) -> None:
        r"""
        x.reset_allowed_anim_curve_evaluation() -> None
        By reset, it will allow all the curves to be evaluated
        """
        ...
    def reset_all_bodies_simulate_physics(self) -> None:
        r"""
        x.reset_all_bodies_simulate_physics() -> None
        Allows you to reset bodies Simulate state based on where bUsePhysics is set to true in the BodySetup.
        """
        ...
    def play_animation(self, new_anim_to_play: AnimationAsset, looping: bool) -> None:
        r"""
        x.play_animation(new_anim_to_play, looping) -> None
        Animation play functions
               *
               * These changes status of animation instance, which is transient data, which means it won't serialize with this component
               * Because of that reason, it is not safe to be used during construction script
               * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
        
        Args:
            new_anim_to_play (AnimationAsset): 
            looping (bool):
        """
        ...
    def play(self, looping: bool) -> None:
        r"""
        x.play(looping) -> None
        Animation play functions
              *
              * These changes status of animation instance, which is transient data, which means it won't serialize with this component
              * Because of that reason, it is not safe to be used during construction script
              * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
        
        Args:
            looping (bool):
        """
        ...
    def override_animation_data(self, anim_to_play: AnimationAsset, is_looping: bool = True, is_playing: bool = True, position: float = 0.000000, play_rate: float = 1.000000) -> None:
        r"""
        x.override_animation_data(anim_to_play, is_looping=True, is_playing=True, position=0.000000, play_rate=1.000000) -> None
        This overrides current AnimationData parameter in the SkeletalMeshComponent. This will serialize when the component serialize
        so it can be used during construction script. However note that this will override current existing data
        This can be useful if you'd like to make a blueprint with custom default animation per component
        This sets single player mode, which means you can't use AnimBlueprint with it
        
        Args:
            anim_to_play (AnimationAsset): 
            is_looping (bool): 
            is_playing (bool): 
            position (float): 
            play_rate (float):
        """
        ...
    def link_anim_graph_by_tag(self, tag: Name, class_: Class) -> None:
        r"""
        x.link_anim_graph_by_tag(tag, class_) -> None
        Runs through all nodes, attempting to find linked instance by name/tag, then sets the class of each node if the tag matches
        
        Args:
            tag (Name): 
            class_ (type(Class)):
        """
        ...
    def set_sub_instance_class_by_tag(self, tag: Name, class_: Class) -> None:
        r"""
        deprecated: 'set_sub_instance_class_by_tag' was renamed to 'link_anim_graph_by_tag'.
        """
        ...
    def link_anim_class_layers(self, class_: Class) -> None:
        r"""
        x.link_anim_class_layers(class_) -> None
        Runs through all layer nodes, attempting to find layer nodes that are implemented by the specified class, then sets up a linked instance of the class for each.
        Allocates one linked instance to run each of the groups specified in the class, so state is shared. If a layer is not grouped (ie. NAME_None), then state is not shared
        and a separate linked instance is allocated for each layer node.
        If InClass is null, then all layers are reset to their defaults.
        
        Args:
            class_ (type(Class)):
        """
        ...
    def set_layer_overlay(self, class_: Class) -> None:
        r"""
        deprecated: 'set_layer_overlay' was renamed to 'link_anim_class_layers'.
        """
        ...
    def get_closest_point_on_physics_asset(self, world_position: Vector) -> Optional[Tuple[Vector, Vector, Name, float]]:
        r"""
        x.get_closest_point_on_physics_asset(world_position) -> (closest_world_position=Vector, normal=Vector, bone_name=Name, distance=float) or None
        Given a world position, find the closest point on the physics asset. Note that this is independent of collision and welding. This is based purely on animation position
        
        Args:
            world_position (Vector): The point we want the closest point to (i.e. for all bodies in the physics asset, find the one that has a point closest to WorldPosition)
        
        Returns:
            tuple or None: true if we found a closest point
        
            closest_world_position (Vector): 
        
            normal (Vector): 
        
            bone_name (Name): 
        
            distance (float):
        """
        ...
    def is_playing(self) -> bool:
        r"""
        x.is_playing() -> bool
        Animation play functions
              *
              * These changes status of animation instance, which is transient data, which means it won't serialize with this component
              * Because of that reason, it is not safe to be used during construction script
              * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
        
        Returns:
            bool:
        """
        ...
    def is_clothing_simulation_suspended(self) -> bool:
        r"""
        x.is_clothing_simulation_suspended() -> bool
        Gets whether or not the clothing simulation is currently suspended
        
        Returns:
            bool:
        """
        ...
    def is_body_gravity_enabled(self, bone_name: Name) -> bool:
        r"""
        x.is_body_gravity_enabled(bone_name) -> bool
        Checks whether or not gravity is enabled on the given bone.
        NAME_None indicates the root body should be queried.
        If the bone name given is otherwise invalid, false is returned.
        
        Args:
            bone_name (Name): The name of the bone to check.
        
        Returns:
            bool: True if gravity is enabled on the bone.
        """
        ...
    def has_valid_animation_instance(self) -> bool:
        r"""
        x.has_valid_animation_instance() -> bool
        Returns whether there are any valid instances to run, currently this means whether we have
        have an animation instance or a post process instance available to process.
        
        Returns:
            bool:
        """
        ...
    def get_transform_attribute_ref(self, bone_name: Name, attribute_name: Name, out_value: Transform, lookup_type: CustomBoneAttributeLookup = CustomBoneAttributeLookup.BONE_ONLY) -> Optional[Transform]:
        r"""
        x.get_transform_attribute_ref(bone_name, attribute_name, out_value, lookup_type=CustomBoneAttributeLookup.BONE_ONLY) -> Transform or None
        Get FTransform type attribute value.
        
        Args:
            bone_name (Name): Name of the bone to retrieve try and retrieve the attribute from
            attribute_name (Name): Name of the attribute to retrieve
            out_value (Transform): (reference) Retrieved attribute value if found, otherwise is set to DefaultValue
            lookup_type (CustomBoneAttributeLookup): Determines how the attribute is retrieved from the specified BoneName (see ECustomBoneAttributeLookup)
        
        Returns:
            Transform or None: Whether or not the atttribute was successfully retrieved
        
            out_value (Transform): (reference) Retrieved attribute value if found, otherwise is set to DefaultValue
        """
        ...
    def get_transform_attribute(self, bone_name: Name, attribute_name: Name, default_value: Transform, lookup_type: CustomBoneAttributeLookup = CustomBoneAttributeLookup.BONE_ONLY) -> Optional[Transform]:
        r"""
        x.get_transform_attribute(bone_name, attribute_name, default_value, lookup_type=CustomBoneAttributeLookup.BONE_ONLY) -> Transform or None
        Get FTransform type attribute value.
        
        Args:
            bone_name (Name): Name of the bone to retrieve try and retrieve the attribute from
            attribute_name (Name): Name of the attribute to retrieve
            default_value (Transform): 
            lookup_type (CustomBoneAttributeLookup): Determines how the attribute is retrieved from the specified BoneName (see ECustomBoneAttributeLookup)
        
        Returns:
            Transform or None: Whether or not the atttribute was successfully retrieved
        
            out_value (Transform): (reference) Retrieved attribute value if found, otherwise is set to DefaultValue
        """
        ...
    def get_string_attribute_ref(self, bone_name: Name, attribute_name: Name, out_value: str, lookup_type: CustomBoneAttributeLookup = CustomBoneAttributeLookup.BONE_ONLY) -> Optional[str]:
        r"""
        x.get_string_attribute_ref(bone_name, attribute_name, out_value, lookup_type=CustomBoneAttributeLookup.BONE_ONLY) -> str or None
        Get string type attribute value.
        
        Args:
            bone_name (Name): Name of the bone to retrieve try and retrieve the attribute from
            attribute_name (Name): Name of the attribute to retrieve
            out_value (str): (reference) Retrieved attribute value if found, otherwise is set to DefaultValue
            lookup_type (CustomBoneAttributeLookup): Determines how the attribute is retrieved from the specified BoneName (see ECustomBoneAttributeLookup)
        
        Returns:
            str or None: Whether or not the atttribute was successfully retrieved
        
            out_value (str): (reference) Retrieved attribute value if found, otherwise is set to DefaultValue
        """
        ...
    def get_string_attribute(self, bone_name: Name, attribute_name: Name, default_value: str, lookup_type: CustomBoneAttributeLookup = CustomBoneAttributeLookup.BONE_ONLY) -> Optional[str]:
        r"""
        x.get_string_attribute(bone_name, attribute_name, default_value, lookup_type=CustomBoneAttributeLookup.BONE_ONLY) -> str or None
        Get string type attribute value.
        
        Args:
            bone_name (Name): Name of the bone to retrieve try and retrieve the attribute from
            attribute_name (Name): Name of the attribute to retrieve
            default_value (str): In case the attribute could not be found
            lookup_type (CustomBoneAttributeLookup): Determines how the attribute is retrieved from the specified BoneName (see ECustomBoneAttributeLookup)
        
        Returns:
            str or None: Whether or not the atttribute was successfully retrieved
        
            out_value (str): Retrieved attribute value if found, otherwise is set to DefaultValue
        """
        ...
    def get_skeletal_mesh_asset(self) -> SkeletalMesh:
        r"""
        x.get_skeletal_mesh_asset() -> SkeletalMesh
        Get the SkeletalMesh rendered for this mesh.
        
        Returns:
            SkeletalMesh:
        """
        ...
    def get_skeletal_center_of_mass(self) -> Vector:
        r"""
        x.get_skeletal_center_of_mass() -> Vector
        Returns the center of mass of the skeletal mesh, instead of the root body's location
        
        Returns:
            Vector:
        """
        ...
    def get_post_process_instance(self) -> AnimInstance:
        r"""
        x.get_post_process_instance() -> AnimInstance
        Returns the active post process instance is one is available. This is set on the mesh that this
        component is using, and is evaluated immediately after the main instance.
        
        Returns:
            AnimInstance:
        """
        ...
    def get_position(self) -> float:
        r"""
        x.get_position() -> float
        Animation play functions
              *
              * These changes status of animation instance, which is transient data, which means it won't serialize with this component
              * Because of that reason, it is not safe to be used during construction script
              * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
        
        Returns:
            float:
        """
        ...
    def get_play_rate(self) -> float:
        r"""
        x.get_play_rate() -> float
        Animation play functions
              *
              * These changes status of animation instance, which is transient data, which means it won't serialize with this component
              * Because of that reason, it is not safe to be used during construction script
              * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
        
        Returns:
            float:
        """
        ...
    def get_morph_target(self, morph_target_name: Name) -> float:
        r"""
        x.get_morph_target(morph_target_name) -> float
        Get Morph target with given name
        
        Args:
            morph_target_name (Name): 
        
        Returns:
            float:
        """
        ...
    def get_linked_anim_layer_instance_by_group(self, group: Name) -> AnimInstance:
        r"""
        x.get_linked_anim_layer_instance_by_group(group) -> AnimInstance
        Gets the layer linked instance corresponding to the specified group
        
        Args:
            group (Name): 
        
        Returns:
            AnimInstance:
        """
        ...
    def get_layer_sub_instance_by_group(self, group: Name) -> AnimInstance:
        r"""
        deprecated: 'get_layer_sub_instance_by_group' was renamed to 'get_linked_anim_layer_instance_by_group'.
        """
        ...
    def get_linked_anim_layer_instance_by_class(self, class_: Class) -> AnimInstance:
        r"""
        x.get_linked_anim_layer_instance_by_class(class_) -> AnimInstance
        Gets the first layer linked instance corresponding to the specified class
        
        Args:
            class_ (type(Class)): 
        
        Returns:
            AnimInstance:
        """
        ...
    def get_layer_sub_instance_by_class(self, class_: Class) -> AnimInstance:
        r"""
        deprecated: 'get_layer_sub_instance_by_class' was renamed to 'get_linked_anim_layer_instance_by_class'.
        """
        ...
    def get_linked_anim_graph_instances_by_tag(self, tag: Name) -> Array[AnimInstance]:
        r"""
        x.get_linked_anim_graph_instances_by_tag(tag) -> Array[AnimInstance]
        Get Linked Anim Graph Instances by Tag
        deprecated: Tags are unique so this funciton is no longer supported. Please use GetLinkedAnimGraphInstanceByTag instead
        
        Args:
            tag (Name): 
        
        Returns:
            Array[AnimInstance]: 
        
            out_linked_instances (Array[AnimInstance]):
        """
        ...
    def get_sub_instances_by_tag(self, tag: Name) -> Array[AnimInstance]:
        r"""
        deprecated: 'get_sub_instances_by_tag' was renamed to 'get_linked_anim_graph_instances_by_tag'.
        """
        ...
    def get_linked_anim_graph_instance_by_tag(self, tag: Name) -> AnimInstance:
        r"""
        x.get_linked_anim_graph_instance_by_tag(tag) -> AnimInstance
        Returns the a tagged linked instance node. If no linked instances are found or none are tagged with the
        supplied name, this will return NULL.
        
        Args:
            tag (Name): 
        
        Returns:
            AnimInstance:
        """
        ...
    def get_sub_instance_by_tag(self, tag: Name) -> AnimInstance:
        r"""
        deprecated: 'get_sub_instance_by_tag' was renamed to 'get_linked_anim_graph_instance_by_tag'.
        """
        ...
    def get_integer_attribute_ref(self, bone_name: Name, attribute_name: Name, out_value: int, lookup_type: CustomBoneAttributeLookup = CustomBoneAttributeLookup.BONE_ONLY) -> Optional[int]:
        r"""
        x.get_integer_attribute_ref(bone_name, attribute_name, out_value, lookup_type=CustomBoneAttributeLookup.BONE_ONLY) -> int32 or None
        Get integer type attribute value.
        
        Args:
            bone_name (Name): Name of the bone to retrieve try and retrieve the attribute from
            attribute_name (Name): Name of the attribute to retrieve
            out_value (int32): (reference) Retrieved attribute value if found, otherwise is set to DefaultValue
            lookup_type (CustomBoneAttributeLookup): Determines how the attribute is retrieved from the specified BoneName (see ECustomBoneAttributeLookup)
        
        Returns:
            int32 or None: Whether or not the atttribute was successfully retrieved
        
            out_value (int32): (reference) Retrieved attribute value if found, otherwise is set to DefaultValue
        """
        ...
    def get_integer_attribute(self, bone_name: Name, attribute_name: Name, default_value: int, lookup_type: CustomBoneAttributeLookup = CustomBoneAttributeLookup.BONE_ONLY) -> Optional[int]:
        r"""
        x.get_integer_attribute(bone_name, attribute_name, default_value, lookup_type=CustomBoneAttributeLookup.BONE_ONLY) -> int32 or None
        Get integer type attribute value.
        
        Args:
            bone_name (Name): Name of the bone to retrieve try and retrieve the attribute from
            attribute_name (Name): Name of the attribute to retrieve
            default_value (int32): In case the attribute could not be found
            lookup_type (CustomBoneAttributeLookup): Determines how the attribute is retrieved from the specified BoneName (see ECustomBoneAttributeLookup)
        
        Returns:
            int32 or None: Whether or not the atttribute was successfully retrieved
        
            out_value (int32): Retrieved attribute value if found, otherwise is set to DefaultValue
        """
        ...
    def get_float_attribute_ref(self, bone_name: Name, attribute_name: Name, out_value: float, lookup_type: CustomBoneAttributeLookup = CustomBoneAttributeLookup.BONE_ONLY) -> Optional[float]:
        r"""
        x.get_float_attribute_ref(bone_name, attribute_name, out_value, lookup_type=CustomBoneAttributeLookup.BONE_ONLY) -> float or None
        Get float type attribute value.
        
        Args:
            bone_name (Name): Name of the bone to retrieve try and retrieve the attribute from
            attribute_name (Name): Name of the attribute to retrieve
            out_value (float): (reference) Retrieved attribute value if found, otherwise is set to DefaultValue
            lookup_type (CustomBoneAttributeLookup): Determines how the attribute is retrieved from the specified BoneName (see ECustomBoneAttributeLookup)
        
        Returns:
            float or None: Whether or not the atttribute was successfully retrieved
        
            out_value (float): (reference) Retrieved attribute value if found, otherwise is set to DefaultValue
        """
        ...
    def get_float_attribute(self, bone_name: Name, attribute_name: Name, default_value: float, lookup_type: CustomBoneAttributeLookup = CustomBoneAttributeLookup.BONE_ONLY) -> Optional[float]:
        r"""
        x.get_float_attribute(bone_name, attribute_name, default_value, lookup_type=CustomBoneAttributeLookup.BONE_ONLY) -> float or None
        Get float type attribute value.
        
        Args:
            bone_name (Name): Name of the bone to retrieve try and retrieve the attribute from
            attribute_name (Name): Name of the attribute to retrieve
            default_value (float): In case the attribute could not be found
            lookup_type (CustomBoneAttributeLookup): Determines how the attribute is retrieved from the specified BoneName (see ECustomBoneAttributeLookup)
        
        Returns:
            float or None: Whether or not the atttribute was successfully retrieved
        
            out_value (float): Retrieved attribute value if found, otherwise is set to DefaultValue
        """
        ...
    def get_disable_anim_curves(self) -> bool:
        r"""
        x.get_disable_anim_curves() -> bool
        Get Disable Anim Curves
        
        Returns:
            bool:
        """
        ...
    def get_default_animating_rig(self) -> Object:
        r"""
        x.get_default_animating_rig() -> Object
        Get Default Animating Rig
        
        Returns:
            Object:
        """
        ...
    def get_current_joint_angles(self, bone_name: Name) -> Tuple[float, float, float]:
        r"""
        x.get_current_joint_angles(bone_name) -> (swing1_angle=float, twist_angle=float, swing2_angle=float)
        Gets the current Angular state for a named bone constraint
        
        Args:
            bone_name (Name): Name of bone to get constraint ranges for
        
        Returns:
            tuple: 
        
            swing1_angle (float): current angular state of the constraint
        
            twist_angle (float): current angular state of the constraint
        
            swing2_angle (float): current angular state of the constraint
        """
        ...
    def get_constraints_from_body(self, body_name: Name, parent_constraints: bool, child_constraints: bool, includes_terminated: bool) -> Array[ConstraintInstanceAccessor]:
        r"""
        x.get_constraints_from_body(body_name, parent_constraints, child_constraints, includes_terminated) -> Array[ConstraintInstanceAccessor]
        Gets all the constraints attached to a body
        
        Args:
            body_name (Name): name of the body to get the attached constraints from
            parent_constraints (bool): return constraints where BodyName is the child of the constraint
            child_constraints (bool): return constraints where BodyName is the parent of the constraint
            includes_terminated (bool): 
        
        Returns:
            Array[ConstraintInstanceAccessor]: 
        
            out_constraints (Array[ConstraintInstanceAccessor]): returned list of constraints matching the parameters
        """
        ...
    def get_constraints(self, includes_terminated: bool) -> Array[ConstraintInstanceAccessor]:
        r"""
        x.get_constraints(includes_terminated) -> Array[ConstraintInstanceAccessor]
        Gets all the constraints
        
        Args:
            includes_terminated (bool): 
        
        Returns:
            Array[ConstraintInstanceAccessor]: 
        
            out_constraints (Array[ConstraintInstanceAccessor]): returned list of constraints matching the parameters
        """
        ...
    def get_constraint_by_name(self, constraint_name: Name, includes_terminated: bool) -> ConstraintInstanceAccessor:
        r"""
        x.get_constraint_by_name(constraint_name, includes_terminated) -> ConstraintInstanceAccessor
        Gets a constraint by its name
        
        Args:
            constraint_name (Name): name of the constraint
            includes_terminated (bool): 
        
        Returns:
            ConstraintInstanceAccessor:
        """
        ...
    def get_cloth_max_distance_scale(self) -> float:
        r"""
        x.get_cloth_max_distance_scale() -> float
        Get/Set the max distance scale of clothing mesh vertices
        
        Returns:
            float:
        """
        ...
    def get_clothing_simulation_interactor(self) -> ClothingSimulationInteractor:
        r"""
        x.get_clothing_simulation_interactor() -> ClothingSimulationInteractor
        Get the current interactor for a clothing simulation, if the current simulation supports runtime interaction.
        
        Returns:
            ClothingSimulationInteractor:
        """
        ...
    def get_bone_mass(self, bone_name: Name = "None", scale_mass: bool = True) -> float:
        r"""
        x.get_bone_mass(bone_name="None", scale_mass=True) -> float
        Returns the mass (in kg) of the given bone
        
        Args:
            bone_name (Name): Name of the body to return. 'None' indicates root body.
            scale_mass (bool): If true, the mass is scaled by the bone's MassScale.
        
        Returns:
            float:
        """
        ...
    def get_bone_linear_velocity(self, bone_name: Name) -> Vector:
        r"""
        x.get_bone_linear_velocity(bone_name) -> Vector
        Get Bone Linear Velocity
        
        Args:
            bone_name (Name): 
        
        Returns:
            Vector:
        """
        ...
    def get_anim_instance(self) -> AnimInstance:
        r"""
        x.get_anim_instance() -> AnimInstance
        Returns the animation instance that is driving the class (if available). This is typically an instance of
        the class set as AnimBlueprintGeneratedClass (generated by an animation blueprint)
        Since this instance is transient, it is not safe to be used during construction script
        
        Returns:
            AnimInstance:
        """
        ...
    def get_animation_mode(self) -> AnimationMode:
        r"""
        x.get_animation_mode() -> AnimationMode
        Get Animation Mode
        
        Returns:
            AnimationMode:
        """
        ...
    def get_allow_rigid_body_anim_node(self) -> bool:
        r"""
        x.get_allow_rigid_body_anim_node() -> bool
        Get Allow Rigid Body Anim Node
        
        Returns:
            bool:
        """
        ...
    def get_allowed_anim_curve_evaluate(self) -> bool:
        r"""
        x.get_allowed_anim_curve_evaluate() -> bool
        Get Allowed Anim Curve Evaluate
        
        Returns:
            bool:
        """
        ...
    def get_allow_cloth_actors(self) -> bool:
        r"""
        x.get_allow_cloth_actors() -> bool
        Get Allow Cloth Actors
        
        Returns:
            bool:
        """
        ...
    def force_cloth_next_update_teleport_and_reset(self) -> None:
        r"""
        x.force_cloth_next_update_teleport_and_reset() -> None
        Used to indicate we should force 'teleport and reset' during the next call to UpdateClothState.
        This can be used to reset it from a bad state or by a teleport where the old state is not important anymore.
        """
        ...
    def force_cloth_next_update_teleport(self) -> None:
        r"""
        x.force_cloth_next_update_teleport() -> None
        Used to indicate we should force 'teleport' during the next call to UpdateClothState,
        This will transform positions and velocities and thus keep the simulation state, just translate it to a new pose.
        """
        ...
    def find_constraint_bone_name(self, constraint_index: int) -> Name:
        r"""
        x.find_constraint_bone_name(constraint_index) -> Name
        Find Constraint Name from index
        
        Args:
            constraint_index (int32): Index of constraint to look for
        
        Returns:
            Name: Constraint Joint Name
        """
        ...
    def clear_morph_targets(self) -> None:
        r"""
        x.clear_morph_targets() -> None
        Clear all Morph Target that are set to this mesh
        """
        ...
    def break_constraint(self, impulse: Vector, hit_location: Vector, bone_name: Name) -> None:
        r"""
        x.break_constraint(impulse, hit_location, bone_name) -> None
        Break a constraint off a Gore mesh.
        
        Args:
            impulse (Vector): vector of impulse
            hit_location (Vector): location of the hit
            bone_name (Name): Name of bone to break constraint for
        """
        ...
    def bind_cloth_to_leader_pose_component(self) -> None:
        r"""
        x.bind_cloth_to_leader_pose_component() -> None
        If this component has a valid LeaderPoseComponent then this function makes cloth items on the follower component
        take the transforms of the cloth items on the leader component instead of simulating separately.
        Note: This will FORCE any cloth actor on the leader component to simulate in local space. Also The meshes used in the components must be identical for the cloth to bind correctly
        """
        ...
    def bind_cloth_to_master_pose_component(self) -> None:
        r"""
        deprecated: 'bind_cloth_to_master_pose_component' was renamed to 'bind_cloth_to_leader_pose_component'.
        """
        ...
    def allow_anim_curve_evaluation(self, name_of_curve: Name, allow: bool) -> None:
        r"""
        x.allow_anim_curve_evaluation(name_of_curve, allow) -> None
        Allow Anim Curve Evaluation
        
        Args:
            name_of_curve (Name): 
            allow (bool):
        """
        ...
    def add_impulse_to_all_bodies_below(self, impulse: Vector, bone_name: Name = "None", vel_change: bool = False, include_self: bool = True) -> None:
        r"""
        x.add_impulse_to_all_bodies_below(impulse, bone_name="None", vel_change=False, include_self=True) -> None
        Add impulse to all single rigid bodies below. Good for one time instant burst.
        
        Args:
            impulse (Vector): Magnitude and direction of impulse to apply.
            bone_name (Name): If a SkeletalMeshComponent, name of body to apply impulse to. 'None' indicates root body.
            vel_change (bool): If true, the Strength is taken as a change in velocity instead of an impulse (ie. mass will have no effect).
            include_self (bool): If false, Force is only applied to bodies below but not given bone name.
        """
        ...
    def add_force_to_all_bodies_below(self, force: Vector, bone_name: Name = "None", accel_change: bool = False, include_self: bool = True) -> None:
        r"""
        x.add_force_to_all_bodies_below(force, bone_name="None", accel_change=False, include_self=True) -> None
        Add a force to all rigid bodies below.
        This is like a 'thruster'. Good for adding a burst over some (non zero) time. Should be called every frame for the duration of the force.
        
        Args:
            force (Vector): Force vector to apply. Magnitude indicates strength of force.
            bone_name (Name): If a SkeletalMeshComponent, name of body to apply force to. 'None' indicates root body.
            accel_change (bool): If true, Force is taken as a change in acceleration instead of a physical force (i.e. mass will have no effect).
            include_self (bool): If false, Force is only applied to bodies below but not given bone name.
        """
        ...
    def accumulate_all_bodies_below_physics_blend_weight(self, bone_name: Name, add_physics_blend_weight: float, skip_custom_physics_type: bool = False) -> None:
        r"""
        x.accumulate_all_bodies_below_physics_blend_weight(bone_name, add_physics_blend_weight, skip_custom_physics_type=False) -> None
        Accumulate AddPhysicsBlendWeight to physics blendweight for all of the bones below passed in bone to be simulated
        
        Args:
            bone_name (Name): 
            add_physics_blend_weight (float): 
            skip_custom_physics_type (bool):
        """
        ...

class SingleAnimSkeletalComponent(SkeletalMeshComponent):
    r"""
    deprecated: 'SingleAnimSkeletalComponent' was renamed to 'SkeletalMeshComponent'.
    """
    ...

class SkeletalMeshReplicatedComponent(SkeletalMeshComponent):
    r"""
    deprecated: 'SkeletalMeshReplicatedComponent' was renamed to 'SkeletalMeshComponent'.
    """
    ...

class AnimInstance(Object):
    r"""
    Anim Instance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    @property
    def on_montage_blending_out(self) -> OnMontageBlendingOutStartedMCDelegate:
        r"""
        (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
        """
        ...
    @on_montage_blending_out.setter
    def on_montage_blending_out(self, value: OnMontageBlendingOutStartedMCDelegate) -> None:
        ...
    @property
    def on_montage_blended_in(self) -> OnMontageBlendedInEndedMCDelegate:
        r"""
        (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
        """
        ...
    @on_montage_blended_in.setter
    def on_montage_blended_in(self, value: OnMontageBlendedInEndedMCDelegate) -> None:
        ...
    @property
    def on_montage_started(self) -> OnMontageStartedMCDelegate:
        r"""
        (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
        """
        ...
    @on_montage_started.setter
    def on_montage_started(self, value: OnMontageStartedMCDelegate) -> None:
        ...
    @property
    def on_montage_ended(self) -> OnMontageEndedMCDelegate:
        r"""
        (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
        """
        ...
    @on_montage_ended.setter
    def on_montage_ended(self, value: OnMontageEndedMCDelegate) -> None:
        ...
    @property
    def on_all_montage_instances_ended(self) -> OnAllMontageInstancesEndedMCDelegate:
        r"""
        (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
        """
        ...
    @on_all_montage_instances_ended.setter
    def on_all_montage_instances_ended(self, value: OnAllMontageInstancesEndedMCDelegate) -> None:
        ...
    def was_anim_notify_state_active_in_any_state(self, anim_notify_state_type: Class) -> bool:
        r"""
        x.was_anim_notify_state_active_in_any_state(anim_notify_state_type) -> bool
        Get whether a particular notify state was active in any state machine last tick.
        
        Args:
            anim_notify_state_type (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    def unlock_ai_resources(self, unlock_movement: bool, unlock_ai_logic: bool) -> None:
        r"""
        x.unlock_ai_resources(unlock_movement, unlock_ai_logic) -> None
        unlocks indicated AI resources of animated pawn. Will unlock only animation-locked resources.
            DEPRECATED. Use UnlockAIResourcesWithAnimation instead
        deprecated: Use UnlockAIResourcesWithAnimation instead
        
        Args:
            unlock_movement (bool): 
            unlock_ai_logic (bool):
        """
        ...
    def unlink_anim_class_layers(self, class_: Class) -> None:
        r"""
        x.unlink_anim_class_layers(class_) -> None
        Runs through all layer nodes, attempting to find layer nodes that are currently running the specified class, then resets each to its default value.
        State sharing rules are as with SetLayerOverlay.
        If InClass is null, does nothing.
        
        Args:
            class_ (type(Class)):
        """
        ...
    def clear_layer_overlay(self, class_: Class) -> None:
        r"""
        deprecated: 'clear_layer_overlay' was renamed to 'unlink_anim_class_layers'.
        """
        ...
    def try_get_pawn_owner(self) -> Pawn:
        r"""
        x.try_get_pawn_owner() -> Pawn
        kismet event functions
        
        Returns:
            Pawn:
        """
        ...
    def stop_slot_animation(self, blend_out_time: float = 0.250000, slot_node_name: Name = "None") -> None:
        r"""
        x.stop_slot_animation(blend_out_time=0.250000, slot_node_name="None") -> None
        Stops currently playing slot animation slot or all
        
        Args:
            blend_out_time (float): 
            slot_node_name (Name):
        """
        ...
    def snapshot_pose(self, snapshot: PoseSnapshot) -> PoseSnapshot:
        r"""
        x.snapshot_pose(snapshot) -> PoseSnapshot
        Takes a snapshot of the current skeletal mesh component pose and saves it to the specified snapshot.
        The snapshot is taken at the current LOD, so if for example you took the snapshot at LOD1
        and then used it at LOD0 any bones not in LOD1 will use the reference pose
        
        Args:
            snapshot (PoseSnapshot): 
        
        Returns:
            PoseSnapshot: 
        
            snapshot (PoseSnapshot):
        """
        ...
    def set_use_main_instance_montage_evaluation_data(self, set: bool) -> None:
        r"""
        x.set_use_main_instance_montage_evaluation_data(set) -> None
        Set Use Main Instance Montage Evaluation Data
        
        Args:
            set (bool):
        """
        ...
    def set_root_motion_mode(self, value: RootMotionMode) -> None:
        r"""
        x.set_root_motion_mode(value) -> None
        Set RootMotionMode
        
        Args:
            value (RootMotionMode):
        """
        ...
    def set_receive_notifies_from_linked_instances(self, set: bool) -> None:
        r"""
        x.set_receive_notifies_from_linked_instances(set) -> None
        Set whether to process notifies from any linked anim instances
        
        Args:
            set (bool):
        """
        ...
    def set_propagate_notifies_to_linked_instances(self, set: bool) -> None:
        r"""
        x.set_propagate_notifies_to_linked_instances(set) -> None
        Set whether to propagate notifies to any linked anim instances
        
        Args:
            set (bool):
        """
        ...
    def set_morph_target(self, morph_target_name: Name, value: float) -> None:
        r"""
        x.set_morph_target(morph_target_name, value) -> None
        Sets a morph target to a certain weight.
        
        Args:
            morph_target_name (Name): 
            value (float):
        """
        ...
    def save_pose_snapshot(self, snapshot_name: Name) -> None:
        r"""
        x.save_pose_snapshot(snapshot_name) -> None
        Takes a snapshot of the current skeletal mesh component pose & saves it internally.
        This snapshot can then be retrieved by name in the animation blueprint for blending.
        The snapshot is taken at the current LOD, so if for example you took the snapshot at LOD1 and then used it at LOD0 any bones not in LOD1 will use the reference pose
        
        Args:
            snapshot_name (Name):
        """
        ...
    def reset_dynamics(self, teleport_type: TeleportType) -> None:
        r"""
        x.reset_dynamics(teleport_type) -> None
        Reset any dynamics running simulation-style updates (e.g. on teleport, time skip etc.)
        
        Args:
            teleport_type (TeleportType):
        """
        ...
    def request_transition_event(self, event_name: Name, request_timeout: float, queue_mode: TransitionRequestQueueMode, overwrite_mode: TransitionRequestOverwriteMode) -> bool:
        r"""
        x.request_transition_event(event_name, request_timeout, queue_mode, overwrite_mode) -> bool
        Attempts to queue a transition request, returns true if the request was successful
        
        Args:
            event_name (Name): 
            request_timeout (double): 
            queue_mode (TransitionRequestQueueMode): 
            overwrite_mode (TransitionRequestOverwriteMode): 
        
        Returns:
            bool:
        """
        ...
    def request_slot_group_inertialization(self, slot_group_name: Name, duration: float, blend_profile: BlendProfile = None) -> None:
        r"""
        x.request_slot_group_inertialization(slot_group_name, duration, blend_profile=None) -> None
        Requests an inertial blend during the next anim graph update. Requires your anim graph to have a slot node belonging to the specified group name
        
        Args:
            slot_group_name (Name): 
            duration (float): 
            blend_profile (BlendProfile):
        """
        ...
    def remove_pose_snapshot(self, snapshot_name: Name) -> None:
        r"""
        x.remove_pose_snapshot(snapshot_name) -> None
        Remove a previously saved pose snapshot from the internal snapshot cache
        
        Args:
            snapshot_name (Name):
        """
        ...
    def play_slot_animation_as_dynamic_montage_with_blend_settings(self, asset: AnimSequenceBase, slot_node_name: Name, blend_in_settings: MontageBlendSettings, blend_out_settings: MontageBlendSettings, play_rate: float = 1.000000, loop_count: int = 1, blend_out_trigger_time: float = -1.000000, time_to_start_montage_at: float = 0.000000) -> AnimMontage:
        r"""
        x.play_slot_animation_as_dynamic_montage_with_blend_settings(asset, slot_node_name, blend_in_settings, blend_out_settings, play_rate=1.000000, loop_count=1, blend_out_trigger_time=-1.000000, time_to_start_montage_at=0.000000) -> AnimMontage
        Play normal animation asset on the slot node by creating a dynamic UAnimMontage with blend in settings. You can only play one asset (whether montage or animsequence) at a time per SlotGroup.
        
        Args:
            asset (AnimSequenceBase): 
            slot_node_name (Name): 
            blend_in_settings (MontageBlendSettings): 
            blend_out_settings (MontageBlendSettings): 
            play_rate (float): 
            loop_count (int32): 
            blend_out_trigger_time (float): 
            time_to_start_montage_at (float): 
        
        Returns:
            AnimMontage:
        """
        ...
    def play_slot_animation_as_dynamic_montage_with_blend_args(self, asset: AnimSequenceBase, slot_node_name: Name, blend_in: AlphaBlendArgs, blend_out: AlphaBlendArgs, play_rate: float = 1.000000, loop_count: int = 1, blend_out_trigger_time: float = -1.000000, time_to_start_montage_at: float = 0.000000) -> AnimMontage:
        r"""
        x.play_slot_animation_as_dynamic_montage_with_blend_args(asset, slot_node_name, blend_in, blend_out, play_rate=1.000000, loop_count=1, blend_out_trigger_time=-1.000000, time_to_start_montage_at=0.000000) -> AnimMontage
        Play normal animation asset on the slot node by creating a dynamic UAnimMontage with blend in arguments. You can only play one asset (whether montage or animsequence) at a time per SlotGroup.
        
        Args:
            asset (AnimSequenceBase): 
            slot_node_name (Name): 
            blend_in (AlphaBlendArgs): 
            blend_out (AlphaBlendArgs): 
            play_rate (float): 
            loop_count (int32): 
            blend_out_trigger_time (float): 
            time_to_start_montage_at (float): 
        
        Returns:
            AnimMontage:
        """
        ...
    def play_slot_animation_as_dynamic_montage(self, asset: AnimSequenceBase, slot_node_name: Name, blend_in_time: float = 0.250000, blend_out_time: float = 0.250000, play_rate: float = 1.000000, loop_count: int = 1, blend_out_trigger_time: float = -1.000000, time_to_start_montage_at: float = 0.000000) -> AnimMontage:
        r"""
        x.play_slot_animation_as_dynamic_montage(asset, slot_node_name, blend_in_time=0.250000, blend_out_time=0.250000, play_rate=1.000000, loop_count=1, blend_out_trigger_time=-1.000000, time_to_start_montage_at=0.000000) -> AnimMontage
        Play normal animation asset on the slot node by creating a dynamic UAnimMontage. You can only play one asset (whether montage or animsequence) at a time per SlotGroup.
        
        Args:
            asset (AnimSequenceBase): 
            slot_node_name (Name): 
            blend_in_time (float): 
            blend_out_time (float): 
            play_rate (float): 
            loop_count (int32): 
            blend_out_trigger_time (float): 
            time_to_start_montage_at (float): 
        
        Returns:
            AnimMontage:
        """
        ...
    def montage_sync_stop_following(self, montage_follower: AnimMontage) -> None:
        r"""
        x.montage_sync_stop_following(montage_follower) -> None
        Stop following the montage's leader in this anim instance
        
        Args:
            montage_follower (AnimMontage): : The montage we want to stop synchronizing
        """
        ...
    def montage_sync_follow(self, montage_follower: AnimMontage, other_anim_instance: AnimInstance, montage_leader: AnimMontage) -> None:
        r"""
        x.montage_sync_follow(montage_follower, other_anim_instance, montage_leader) -> None
        Synchronize a montage to another anim instance's montage. Both montages must be playing already
        
        Args:
            montage_follower (AnimMontage): : The montage that will follow the leader in OtherAnimInstance
            other_anim_instance (AnimInstance): : The other anim instance we want to synchronize to. Can be set to self
            montage_leader (AnimMontage): : The montage we want to follow in the other anim instance
        """
        ...
    def montage_stop_with_blend_settings(self, blend_out_settings: MontageBlendSettings, montage: AnimMontage = None) -> None:
        r"""
        x.montage_stop_with_blend_settings(blend_out_settings, montage=None) -> None
        Same as Montage_Stop, but all blend settings are provided instead of using the ones on the montage asset
        
        Args:
            blend_out_settings (MontageBlendSettings): 
            montage (AnimMontage):
        """
        ...
    def montage_stop_with_blend_out(self, blend_out: AlphaBlendArgs, montage: AnimMontage = None) -> None:
        r"""
        x.montage_stop_with_blend_out(blend_out, montage=None) -> None
        Same as Montage_Stop. Uses values from the AlphaBlendArgs. Other settings come from the montage asset
        
        Args:
            blend_out (AlphaBlendArgs): 
            montage (AnimMontage):
        """
        ...
    def montage_stop_group_by_name(self, blend_out_time: float, group_name: Name) -> None:
        r"""
        x.montage_stop_group_by_name(blend_out_time, group_name) -> None
        Stops all active montages belonging to a group.
        
        Args:
            blend_out_time (float): 
            group_name (Name):
        """
        ...
    def montage_stop(self, blend_out_time: float, montage: AnimMontage = None) -> None:
        r"""
        x.montage_stop(blend_out_time, montage=None) -> None
        Stopped montages will blend out using their montage asset's BlendOut, with InBlendOutTime as the BlendTime
        
        Args:
            blend_out_time (float): 
            montage (AnimMontage):
        """
        ...
    def montage_set_position(self, montage: AnimMontage, new_position: float) -> None:
        r"""
        x.montage_set_position(montage, new_position) -> None
        Set position.
        
        Args:
            montage (AnimMontage): 
            new_position (float):
        """
        ...
    def montage_set_play_rate(self, montage: AnimMontage, new_play_rate: float = 1.000000) -> None:
        r"""
        x.montage_set_play_rate(montage, new_play_rate=1.000000) -> None
        Change AnimMontage play rate. NewPlayRate = 1.0 is the default playback rate.
        
        Args:
            montage (AnimMontage): 
            new_play_rate (float):
        """
        ...
    def montage_set_next_section(self, section_name_to_change: Name, next_section: Name, montage: AnimMontage = None) -> None:
        r"""
        x.montage_set_next_section(section_name_to_change, next_section, montage=None) -> None
        Relink new next section AFTER SectionNameToChange in run-time
            You can link section order the way you like in editor, but in run-time if you'd like to change it dynamically,
            use this function to relink the next section
            For example, you can have Start->Loop->Loop->Loop.... but when you want it to end, you can relink
            next section of Loop to be End to finish the montage, in which case, it stops looping by Loop->End.
        
        Args:
            section_name_to_change (Name): : This should be the name of the Montage Section after which you want to insert a new next section
            next_section (Name): : new next section
            montage (AnimMontage):
        """
        ...
    def montage_resume(self, montage: AnimMontage) -> None:
        r"""
        x.montage_resume(montage) -> None
        Resumes a paused animation montage. If reference is NULL, it will resume ALL active montages.
        
        Args:
            montage (AnimMontage):
        """
        ...
    def montage_play_with_blend_settings(self, montage_to_play: AnimMontage, blend_in_settings: MontageBlendSettings, play_rate: float = 1.000000, return_value_type: MontagePlayReturnType = MontagePlayReturnType.MONTAGE_LENGTH, time_to_start_montage_at: float = 0.000000, stop_all_montages: bool = True) -> float:
        r"""
        x.montage_play_with_blend_settings(montage_to_play, blend_in_settings, play_rate=1.000000, return_value_type=MontagePlayReturnType.MONTAGE_LENGTH, time_to_start_montage_at=0.000000, stop_all_montages=True) -> float
        Plays an animation montage. Same as Montage_Play, but you can overwrite all of the montage's default blend in settings.
        
        Args:
            montage_to_play (AnimMontage): 
            blend_in_settings (MontageBlendSettings): 
            play_rate (float): 
            return_value_type (MontagePlayReturnType): 
            time_to_start_montage_at (float): 
            stop_all_montages (bool): 
        
        Returns:
            float:
        """
        ...
    def montage_play_with_blend_in(self, montage_to_play: AnimMontage, blend_in: AlphaBlendArgs, play_rate: float = 1.000000, return_value_type: MontagePlayReturnType = MontagePlayReturnType.MONTAGE_LENGTH, time_to_start_montage_at: float = 0.000000, stop_all_montages: bool = True) -> float:
        r"""
        x.montage_play_with_blend_in(montage_to_play, blend_in, play_rate=1.000000, return_value_type=MontagePlayReturnType.MONTAGE_LENGTH, time_to_start_montage_at=0.000000, stop_all_montages=True) -> float
        Plays an animation montage. Same as Montage_Play, but you can specify an AlphaBlend for Blend In settings.
        
        Args:
            montage_to_play (AnimMontage): 
            blend_in (AlphaBlendArgs): 
            play_rate (float): 
            return_value_type (MontagePlayReturnType): 
            time_to_start_montage_at (float): 
            stop_all_montages (bool): 
        
        Returns:
            float:
        """
        ...
    def montage_play(self, montage_to_play: AnimMontage, play_rate: float = 1.000000, return_value_type: MontagePlayReturnType = MontagePlayReturnType.MONTAGE_LENGTH, time_to_start_montage_at: float = 0.000000, stop_all_montages: bool = True) -> float:
        r"""
        x.montage_play(montage_to_play, play_rate=1.000000, return_value_type=MontagePlayReturnType.MONTAGE_LENGTH, time_to_start_montage_at=0.000000, stop_all_montages=True) -> float
        Plays an animation montage. Returns the length of the animation montage in seconds. Returns 0.f if failed to play.
        
        Args:
            montage_to_play (AnimMontage): 
            play_rate (float): 
            return_value_type (MontagePlayReturnType): 
            time_to_start_montage_at (float): 
            stop_all_montages (bool): 
        
        Returns:
            float:
        """
        ...
    def montage_pause(self, montage: AnimMontage = None) -> None:
        r"""
        x.montage_pause(montage=None) -> None
        Pauses the animation montage. If reference is NULL, it will pause ALL active montages.
        
        Args:
            montage (AnimMontage):
        """
        ...
    def montage_jump_to_sections_end(self, section_name: Name, montage: AnimMontage = None) -> None:
        r"""
        x.montage_jump_to_sections_end(section_name, montage=None) -> None
        Makes a montage jump to the end of a named section. If Montage reference is NULL, it will do that to all active montages.
        
        Args:
            section_name (Name): 
            montage (AnimMontage):
        """
        ...
    def montage_jump_to_section(self, section_name: Name, montage: AnimMontage = None) -> None:
        r"""
        x.montage_jump_to_section(section_name, montage=None) -> None
        Makes a montage jump to a named section. If Montage reference is NULL, it will do that to all active montages.
        
        Args:
            section_name (Name): 
            montage (AnimMontage):
        """
        ...
    def montage_is_playing(self, montage: AnimMontage) -> bool:
        r"""
        x.montage_is_playing(montage) -> bool
        Returns true if the animation montage is currently active and playing.
              If reference is NULL, it will return true is ANY montage is currently active and playing.
        
        Args:
            montage (AnimMontage): 
        
        Returns:
            bool:
        """
        ...
    def montage_is_active(self, montage: AnimMontage) -> bool:
        r"""
        x.montage_is_active(montage) -> bool
        Returns true if the animation montage is active. If the Montage reference is NULL, it will return true if any Montage is active.
        
        Args:
            montage (AnimMontage): 
        
        Returns:
            bool:
        """
        ...
    def montage_get_position(self, montage: AnimMontage) -> float:
        r"""
        x.montage_get_position(montage) -> float
        Get Current Montage Position
        
        Args:
            montage (AnimMontage): 
        
        Returns:
            float:
        """
        ...
    def montage_get_play_rate(self, montage: AnimMontage) -> float:
        r"""
        x.montage_get_play_rate(montage) -> float
        Get PlayRate for Montage. This does not account for RateScale, so it may not reflect the actual play rate seen in game (see Montage_GetEffectivePlayRate).
              If Montage reference is NULL, PlayRate for any Active Montage will be returned.
              If Montage is not playing, 0 is returned.
        
        Args:
            montage (AnimMontage): 
        
        Returns:
            float:
        """
        ...
    def montage_get_is_stopped(self, montage: AnimMontage) -> bool:
        r"""
        x.montage_get_is_stopped(montage) -> bool
        return true if Montage is not currently active. (not valid or blending out)
        
        Args:
            montage (AnimMontage): 
        
        Returns:
            bool:
        """
        ...
    def montage_get_effective_play_rate(self, montage: AnimMontage) -> float:
        r"""
        x.montage_get_effective_play_rate(montage) -> float
        Get scaled PlayRate for Montage. This accounts for RateScale, so it will reflect the actual play rate seen in game.
              If Montage reference is NULL, scaled PlayRate for any Active Montage will be returned.
              If Montage is not playing, 0 is returned.
        
        Args:
            montage (AnimMontage): 
        
        Returns:
            float:
        """
        ...
    def montage_get_current_section(self, montage: AnimMontage = None) -> Name:
        r"""
        x.montage_get_current_section(montage=None) -> Name
        Returns the name of the current animation montage section.
        
        Args:
            montage (AnimMontage): 
        
        Returns:
            Name:
        """
        ...
    def montage_get_blend_time(self, montage: AnimMontage) -> float:
        r"""
        x.montage_get_blend_time(montage) -> float
        Get the current blend time of the Montage.
              If Montage reference is NULL, it will return the current blend time on the first active Montage found.
        
        Args:
            montage (AnimMontage): 
        
        Returns:
            float:
        """
        ...
    def lock_ai_resources(self, lock_movement: bool, lock_ai_logic: bool) -> None:
        r"""
        x.lock_ai_resources(lock_movement, lock_ai_logic) -> None
        locks indicated AI resources of animated pawn
            DEPRECATED. Use LockAIResourcesWithAnimation instead
        deprecated: Use LockAIResourcesWithAnimation instead
        
        Args:
            lock_movement (bool): 
            lock_ai_logic (bool):
        """
        ...
    def link_anim_graph_by_tag(self, tag: Name, class_: Class) -> None:
        r"""
        x.link_anim_graph_by_tag(tag, class_) -> None
        Runs through all nodes, attempting to find a linked instance by name/tag, then sets the class of each node if the tag matches
        
        Args:
            tag (Name): 
            class_ (type(Class)):
        """
        ...
    def set_sub_instance_class_by_tag(self, tag: Name, class_: Class) -> None:
        r"""
        deprecated: 'set_sub_instance_class_by_tag' was renamed to 'link_anim_graph_by_tag'.
        """
        ...
    def link_anim_class_layers(self, class_: Class) -> None:
        r"""
        x.link_anim_class_layers(class_) -> None
        Runs through all layer nodes, attempting to find layer nodes that are implemented by the specified class, then sets up a linked instance of the class for each.
        Allocates one linked instance to run each of the groups specified in the class, so state is shared. If a layer is not grouped (ie. NAME_None), then state is not shared
        and a separate linked instance is allocated for each layer node.
        If InClass is null, then all layers are reset to their defaults.
        
        Args:
            class_ (type(Class)):
        """
        ...
    def set_layer_overlay(self, class_: Class) -> None:
        r"""
        deprecated: 'set_layer_overlay' was renamed to 'link_anim_class_layers'.
        """
        ...
    def is_using_main_instance_montage_evaluation_data(self) -> bool:
        r"""
        x.is_using_main_instance_montage_evaluation_data() -> bool
        Is Using Main Instance Montage Evaluation Data
        
        Returns:
            bool:
        """
        ...
    def is_sync_group_between_markers(self, sync_group_name: Name, previous_marker: Name, next_marker: Name, respect_marker_order: bool = True) -> bool:
        r"""
        x.is_sync_group_between_markers(sync_group_name, previous_marker, next_marker, respect_marker_order=True) -> bool
        Is Sync Group Between Markers
        
        Args:
            sync_group_name (Name): 
            previous_marker (Name): 
            next_marker (Name): 
            respect_marker_order (bool): 
        
        Returns:
            bool:
        """
        ...
    def is_slot_active(self, slot_node_name: Name) -> bool:
        r"""
        x.is_slot_active(slot_node_name) -> bool
        Return true if this instance has an active montage in the given slot. A UAnimMontage that is playing in the slot and blending out is not determined to be "active".
        
        Args:
            slot_node_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_playing_slot_animation(self, asset: AnimSequenceBase, slot_node_name: Name) -> bool:
        r"""
        x.is_playing_slot_animation(asset, slot_node_name) -> bool
        Return true if it's playing the slot animation
        
        Args:
            asset (AnimSequenceBase): 
            slot_node_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_any_montage_playing(self) -> bool:
        r"""
        x.is_any_montage_playing() -> bool
        Returns true if any montage is playing currently. Doesn't mean it's active though, it could be blending out.
        
        Returns:
            bool:
        """
        ...
    def has_marker_been_hit_this_frame(self, sync_group: Name, marker_name: Name) -> bool:
        r"""
        x.has_marker_been_hit_this_frame(sync_group, marker_name) -> bool
        Has Marker Been Hit This Frame
        
        Args:
            sync_group (Name): 
            marker_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def get_time_to_closest_marker(self, sync_group: Name, marker_name: Name) -> Optional[float]:
        r"""
        x.get_time_to_closest_marker(sync_group, marker_name) -> float or None
        --- AI communication end ---
        
        Args:
            sync_group (Name): 
            marker_name (Name): 
        
        Returns:
            float or None: 
        
            out_marker_time (float):
        """
        ...
    def get_sync_group_position(self, sync_group_name: Name) -> MarkerSyncAnimPosition:
        r"""
        x.get_sync_group_position(sync_group_name) -> MarkerSyncAnimPosition
        Get Sync Group Position
        
        Args:
            sync_group_name (Name): 
        
        Returns:
            MarkerSyncAnimPosition:
        """
        ...
    def get_receive_notifies_from_linked_instances(self) -> bool:
        r"""
        x.get_receive_notifies_from_linked_instances() -> bool
        Get whether to process notifies from any linked anim instances
        
        Returns:
            bool:
        """
        ...
    def get_propagate_notifies_to_linked_instances(self) -> bool:
        r"""
        x.get_propagate_notifies_to_linked_instances() -> bool
        Get whether to propagate notifies to any linked anim instances
        
        Returns:
            bool:
        """
        ...
    def get_owning_component(self) -> SkeletalMeshComponent:
        r"""
        x.get_owning_component() -> SkeletalMeshComponent
        Returns the skeletal mesh component that has created this AnimInstance
        
        Returns:
            SkeletalMeshComponent:
        """
        ...
    def get_owning_actor(self) -> Actor:
        r"""
        x.get_owning_actor() -> Actor
        Returns the owning actor of this AnimInstance
        
        Returns:
            Actor:
        """
        ...
    def get_linked_anim_layer_instances_by_group(self, group: Name) -> Array[AnimInstance]:
        r"""
        x.get_linked_anim_layer_instances_by_group(group) -> Array[AnimInstance]
        Runs through all nodes, attempting to find all distinct layer linked instances in the group
        
        Args:
            group (Name): 
        
        Returns:
            Array[AnimInstance]: 
        
            out_linked_instances (Array[AnimInstance]):
        """
        ...
    def get_linked_anim_layer_instance_by_group_and_class(self, group: Name, class_: Class) -> AnimInstance:
        r"""
        x.get_linked_anim_layer_instance_by_group_and_class(group, class_) -> AnimInstance
        Gets layer linked instance that matches group and class
        
        Args:
            group (Name): 
            class_ (type(Class)): 
        
        Returns:
            AnimInstance:
        """
        ...
    def get_linked_anim_layer_instance_by_group(self, group: Name) -> AnimInstance:
        r"""
        x.get_linked_anim_layer_instance_by_group(group) -> AnimInstance
        Gets the layer linked instance corresponding to the specified group
        
        Args:
            group (Name): 
        
        Returns:
            AnimInstance:
        """
        ...
    def get_layer_sub_instance_by_group(self, group: Name) -> AnimInstance:
        r"""
        deprecated: 'get_layer_sub_instance_by_group' was renamed to 'get_linked_anim_layer_instance_by_group'.
        """
        ...
    def get_linked_anim_layer_instance_by_class(self, class_: Class, check_for_child_class: bool = False) -> AnimInstance:
        r"""
        x.get_linked_anim_layer_instance_by_class(class_, check_for_child_class=False) -> AnimInstance
        Gets the first layer linked instance corresponding to the specified class, optionally if bCheckForChildClass is true, it will check IsChildOf on InClass.
        
        Args:
            class_ (type(Class)): 
            check_for_child_class (bool): 
        
        Returns:
            AnimInstance:
        """
        ...
    def get_layer_sub_instance_by_class(self, class_: Class, check_for_child_class: bool = False) -> AnimInstance:
        r"""
        deprecated: 'get_layer_sub_instance_by_class' was renamed to 'get_linked_anim_layer_instance_by_class'.
        """
        ...
    def get_linked_anim_graph_instances_by_tag(self, tag: Name) -> Array[AnimInstance]:
        r"""
        x.get_linked_anim_graph_instances_by_tag(tag) -> Array[AnimInstance]
        Get Linked Anim Graph Instances by Tag
        deprecated: Tags are unique so this function is no longer supported. Please use GetLinkedAnimGraphInstanceByTag instead
        
        Args:
            tag (Name): 
        
        Returns:
            Array[AnimInstance]: 
        
            out_linked_instances (Array[AnimInstance]):
        """
        ...
    def get_sub_instances_by_tag(self, tag: Name) -> Array[AnimInstance]:
        r"""
        deprecated: 'get_sub_instances_by_tag' was renamed to 'get_linked_anim_graph_instances_by_tag'.
        """
        ...
    def get_linked_anim_graph_instance_by_tag(self, tag: Name) -> AnimInstance:
        r"""
        x.get_linked_anim_graph_instance_by_tag(tag) -> AnimInstance
        Runs through all nodes, attempting to find the first linked instance by name/tag
        
        Args:
            tag (Name): 
        
        Returns:
            AnimInstance:
        """
        ...
    def get_sub_instance_by_tag(self, tag: Name) -> AnimInstance:
        r"""
        deprecated: 'get_sub_instance_by_tag' was renamed to 'get_linked_anim_graph_instance_by_tag'.
        """
        ...
    def get_delta_seconds(self) -> float:
        r"""
        x.get_delta_seconds() -> float
        Get the current delta time
        
        Returns:
            float:
        """
        ...
    def get_curve_value_with_default(self, curve_name: Name, default_value: float) -> Optional[float]:
        r"""
        x.get_curve_value_with_default(curve_name, default_value) -> float or None
        Returns whether a named curve was found, its value, and a default value when it's not found.
        
        Args:
            curve_name (Name): The name of the curve.
            default_value (float): Value to use when the curve is not found.
        
        Returns:
            float or None: 
        
            out_value (float): The curve's value.
        """
        ...
    def get_curve_value(self, curve_name: Name) -> float:
        r"""
        x.get_curve_value(curve_name) -> float
        Returns the value of a named curve.
        
        Args:
            curve_name (Name): 
        
        Returns:
            float:
        """
        ...
    def get_current_active_montage(self) -> AnimMontage:
        r"""
        x.get_current_active_montage() -> AnimMontage
        Get a current Active Montage in this AnimInstance.
                      Note that there might be multiple Active at the same time. This will only return the first active one it finds. *
        
        Returns:
            AnimMontage:
        """
        ...
    def get_all_curve_names(self) -> Array[Name]:
        r"""
        x.get_all_curve_names() -> Array[Name]
        This returns all curve names. This is the same as calling GetActiveCurveNames with CurveType == AttributeCurve
        
        Returns:
            Array[Name]: 
        
            out_names (Array[Name]):
        """
        ...
    def get_active_curve_names(self, curve_type: AnimCurveType) -> Array[Name]:
        r"""
        x.get_active_curve_names(curve_type) -> Array[Name]
        This returns last up-to-date list of active curve names
        
        Args:
            curve_type (AnimCurveType): 
        
        Returns:
            Array[Name]: 
        
            out_names (Array[Name]):
        """
        ...
    def dynamic_montage_is_playing_from(self, animation: AnimSequenceBase) -> bool:
        r"""
        x.dynamic_montage_is_playing_from(animation) -> bool
        Returns true if there is an animation montage is currently active and playing that was created from the provided animation.
        
        Args:
            animation (AnimSequenceBase): 
        
        Returns:
            bool:
        """
        ...
    def clear_transition_events(self, event_name: Name) -> None:
        r"""
        x.clear_transition_events(event_name) -> None
        Removes all queued transition requests with the given event name
        
        Args:
            event_name (Name):
        """
        ...
    def clear_morph_targets(self) -> None:
        r"""
        x.clear_morph_targets() -> None
        Clears the current morph targets.
        """
        ...
    def clear_all_transition_events(self) -> None:
        r"""
        x.clear_all_transition_events() -> None
        Removes all queued transition requests
        """
        ...
    def calculate_direction(self, velocity: Vector, base_rotation: Rotator) -> float:
        r"""
        x.calculate_direction(velocity, base_rotation) -> float
        Calculate Direction
        
        Args:
            velocity (Vector): 
            base_rotation (Rotator): 
        
        Returns:
            float:
        """
        ...
    def blueprint_update_animation(self, delta_time_x: float) -> None:
        r"""
        x.blueprint_update_animation(delta_time_x) -> None
        Executed when the Animation is updated
        
        Args:
            delta_time_x (float):
        """
        ...
    def kismet_update_animation(self, delta_time_x: float) -> None:
        r"""
        deprecated: 'kismet_update_animation' was renamed to 'blueprint_update_animation'.
        """
        ...
    def blueprint_thread_safe_update_animation(self, delta_time: float) -> None:
        r"""
        x.blueprint_thread_safe_update_animation(delta_time) -> None
        Executed when the Animation Blueprint is updated on a worker thread, just prior to graph update
        
        Args:
            delta_time (float):
        """
        ...
    def blueprint_post_evaluate_animation(self) -> None:
        r"""
        x.blueprint_post_evaluate_animation() -> None
        Executed after the Animation is evaluated
        """
        ...
    def blueprint_linked_animation_layers_initialized(self) -> None:
        r"""
        x.blueprint_linked_animation_layers_initialized() -> None
        Executed when the all Linked Animation Layers are initialized
        """
        ...
    def blueprint_initialize_animation(self) -> None:
        r"""
        x.blueprint_initialize_animation() -> None
        Executed when the Animation is initialized
        """
        ...
    def kismet_initialize_animation(self) -> None:
        r"""
        deprecated: 'kismet_initialize_animation' was renamed to 'blueprint_initialize_animation'.
        """
        ...
    def blueprint_begin_play(self) -> None:
        r"""
        x.blueprint_begin_play() -> None
        Executed when begin play is called on the owning component
        """
        ...
    def blueprint_get_slot_montage_local_weight(self, slot_node_name: Name) -> float:
        r"""
        x.blueprint_get_slot_montage_local_weight(slot_node_name) -> float
        Get local weight of any montages this slot node is playing. If this slot is not currently playing a montage, it will return 0.
        
        Args:
            slot_node_name (Name): 
        
        Returns:
            float:
        """
        ...
    def blueprint_get_main_anim_instance(self) -> AnimInstance:
        r"""
        x.blueprint_get_main_anim_instance() -> AnimInstance
        Get the 'main' anim instance, i.e. the one that is hosted on the skeletal mesh component
        
        Returns:
            AnimInstance:
        """
        ...

class VimInstance(AnimInstance):
    r"""
    deprecated: 'VimInstance' was renamed to 'AnimInstance'.
    """
    ...

class AnimPreviewAttacheInstance(AnimInstance):
    r"""
    This Instance only contains one AnimationAsset, and produce poses
    Used by Preview in AnimGraph, Playing single animation in Kismet2 and etc
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimPreviewAttacheInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    ...

class AnimSingleNodeInstance(AnimInstance):
    r"""
    Anim Single Node Instance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimSingleNodeInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    def stop_anim(self) -> None:
        r"""
        x.stop_anim() -> None
        Stop Anim
        """
        ...
    def set_reverse(self, reverse: bool) -> None:
        r"""
        x.set_reverse(reverse) -> None
        Set Reverse
        
        Args:
            reverse (bool):
        """
        ...
    def set_preview_curve_override(self, pose_name: Name, value: float, remove_if_zero: bool) -> None:
        r"""
        x.set_preview_curve_override(pose_name, value, remove_if_zero) -> None
        Set pose value
        
        Args:
            pose_name (Name): 
            value (float): 
            remove_if_zero (bool):
        """
        ...
    def set_position_with_previous_time(self, position: float, previous_time: float, fire_notifies: bool = True) -> None:
        r"""
        x.set_position_with_previous_time(position, previous_time, fire_notifies=True) -> None
        Set Position with Previous Time
        
        Args:
            position (float): 
            previous_time (float): 
            fire_notifies (bool):
        """
        ...
    def set_position(self, position: float, fire_notifies: bool = True) -> None:
        r"""
        x.set_position(position, fire_notifies=True) -> None
        Set Position
        
        Args:
            position (float): 
            fire_notifies (bool):
        """
        ...
    def set_play_rate(self, play_rate: float) -> None:
        r"""
        x.set_play_rate(play_rate) -> None
        Set Play Rate
        
        Args:
            play_rate (float):
        """
        ...
    def set_playing(self, is_playing: bool) -> None:
        r"""
        x.set_playing(is_playing) -> None
        Set Playing
        
        Args:
            is_playing (bool):
        """
        ...
    def set_mirror_data_table(self, mirror_data_table: MirrorDataTable) -> None:
        r"""
        x.set_mirror_data_table(mirror_data_table) -> None
        Set Mirror Data Table
        
        Args:
            mirror_data_table (MirrorDataTable):
        """
        ...
    def set_looping(self, is_looping: bool) -> None:
        r"""
        x.set_looping(is_looping) -> None
        Set Looping
        
        Args:
            is_looping (bool):
        """
        ...
    def set_blend_space_position(self, position: Vector) -> None:
        r"""
        x.set_blend_space_position(position) -> None
        Set Blend Space Position
        
        Args:
            position (Vector):
        """
        ...
    def set_animation_asset(self, new_asset: AnimationAsset, is_looping: bool = True, play_rate: float = 1.000000) -> None:
        r"""
        x.set_animation_asset(new_asset, is_looping=True, play_rate=1.000000) -> None
        Set New Asset - calls InitializeAnimation, for now we need MeshComponent *
        
        Args:
            new_asset (AnimationAsset): 
            is_looping (bool): 
            play_rate (float):
        """
        ...
    def play_anim(self, is_looping: bool = False, play_rate: float = 1.000000, start_position: float = 0.000000) -> None:
        r"""
        x.play_anim(is_looping=False, play_rate=1.000000, start_position=0.000000) -> None
        For AnimSequence specific *
        
        Args:
            is_looping (bool): 
            play_rate (float): 
            start_position (float):
        """
        ...
    def get_mirror_data_table(self) -> MirrorDataTable:
        r"""
        x.get_mirror_data_table() -> MirrorDataTable
        Get Mirror Data Table
        
        Returns:
            MirrorDataTable:
        """
        ...
    def get_length(self) -> float:
        r"""
        x.get_length() -> float
        Get Length
        
        Returns:
            float:
        """
        ...
    def get_animation_asset(self) -> AnimationAsset:
        r"""
        x.get_animation_asset() -> AnimationAsset
        Get the currently used asset
        
        Returns:
            AnimationAsset:
        """
        ...

class AnimPreviewInstance(AnimSingleNodeInstance):
    r"""
    This Instance only contains one AnimationAsset, and produce poses
    Used by Preview in AnimGraph, Playing single animation in Kismet2 and etc
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimPreviewInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    ...

class AnimStateNodeBase(EdGraphNode):
    r"""
    Anim State Node Base
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimStateNodeBase.h
    
    """
    ...

class AnimStateAliasNode(AnimStateNodeBase):
    r"""
    Anim State Alias Node
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimStateAliasNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_alias`` (bool):  [Read-Write]
    """
    @property
    def global_alias(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @global_alias.setter
    def global_alias(self, value: bool) -> None:
        ...

class AnimStateTransitionNode(AnimStateNodeBase):
    r"""
    Anim State Transition Node
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimStateTransitionNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_rule_based_on_sequence_player_in_state`` (bool):  [Read-Write] Try setting the rule automatically based on most relevant asset player node's remaining time and the Automatic Rule Trigger Time of the transition, ignoring the internal time
    - ``automatic_rule_trigger_time`` (float):  [Read-Write] When should the automatic transition rule trigger relative to the time remaining on the relevant asset player:
       < 0 means trigger the transition 'Crossfade Duration' seconds before the end of the asset player, so a standard blend would finish just as the asset player ends
      >= 0 means trigger the transition 'Automatic Rule Trigger Time' seconds before the end of the asset player
    - ``bidirectional`` (bool):  [Read-Write] This transition can go both directions
    - ``blend_mode`` (AlphaBlendOption):  [Read-Write]
    - ``blend_profile`` (BlendProfile):  [Read-Write] The blend profile to use to evaluate this transition per-bone
    - ``crossfade_duration`` (float):  [Read-Write] The duration to cross-fade for
    - ``custom_blend_curve`` (CurveFloat):  [Read-Write]
    - ``logic_type`` (TransitionLogicType):  [Read-Write] What transition logic to use
    - ``priority_order`` (int32):  [Read-Write] The priority order of this transition. If multiple transitions out of a state go
      true at the same time, the one with the smallest priority order will take precedent
    - ``sync_group_name_to_require_valid_markers_rule`` (Name):  [Read-Write] If SyncGroupName is specified, Transition will only be taken if the SyncGroup has valid markers (other transition rules still apply in addition to that).
    - ``transition_end`` (AnimNotifyEvent):  [Read-Write]
    - ``transition_interrupt`` (AnimNotifyEvent):  [Read-Write]
    - ``transition_start`` (AnimNotifyEvent):  [Read-Write]
    """
    @property
    def logic_type(self) -> TransitionLogicType:
        r"""
        (TransitionLogicType):  [Read-Write] What transition logic to use
        """
        ...
    @logic_type.setter
    def logic_type(self, value: TransitionLogicType) -> None:
        ...

class AnimBlueprint(Blueprint):
    r"""
    An Anim Blueprint is essentially a specialized Blueprint whose graphs control the animation of a Skeletal Mesh.
    It can perform blending of animations, directly control the bones of the skeleton, and output a final pose
    for a Skeletal Mesh each frame.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimBlueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blueprint_category`` (str):  [Read-Write] The category of the Blueprint, used to organize this Blueprint class when displayed in palette windows
    - ``blueprint_description`` (str):  [Read-Write] Shows up in the content browser tooltip when the blueprint is hovered
    - ``blueprint_display_name`` (str):  [Read-Write] Overrides the BP's display name in the editor UI
    - ``blueprint_namespace`` (str):  [Read-Write] The namespace of this blueprint (if set, the Blueprint will be treated differently for the context menu)
    - ``compile_mode`` (BlueprintCompileMode):  [Read-Write] The mode that will be used when compiling this class.
    - ``default_binding_class`` (type(Class)):  [Read-Write] The default binding type that any new nodes will use when created
    - ``deprecate`` (bool):  [Read-Write] Deprecates the Blueprint, marking the generated class with the CLASS_Deprecated flag
    - ``enable_linked_anim_layer_instance_sharing`` (bool):  [Read-Write] If true, linked animation layers will be instantiated only once per AnimClass instead of once per AnimInstance, AnimClass and AnimGroup.
            Extra instances will be created if two or more active anim graph override the same layer Function
    - ``generate_abstract_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a abstract class or not.  Should set CLASS_Abstract in the KismetCompiler.
    - ``generate_const_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a const class or not.  Should set CLASS_Const in the KismetCompiler.
    - ``hide_categories`` (Array[str]):  [Read-Write] Additional HideCategories. These are added to HideCategories from parent.
    - ``run_construction_script_in_sequencer`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor in sequencer
    - ``run_construction_script_on_drag`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor as you drag it in the editor, or only when the drag operation is complete
    - ``should_cook_property_guids_value`` (ShouldCookBlueprintPropertyGuids):  [Read-Write] Whether to include the property GUIDs for the generated class in a cooked build.
      note: This option may slightly increase memory usage in a cooked build, but can avoid needing to add CoreRedirect data for Blueprint classes stored within SaveGame archives.
    - ``target_skeleton`` (Skeleton):  [Read-Write] This is the target skeleton asset for anim instances created from this blueprint; all animations
      referenced by the BP should be compatible with this skeleton.  For advanced use only, it is easy
      to cause errors if this is modified without updating or replacing all referenced animations.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``use_multi_threaded_animation_update`` (bool):  [Read-Write] Allows this anim Blueprint to update its native update, blend tree, montages and asset players on
      a worker thread. The compiler will attempt to pick up any issues that may occur with threaded update.
      For updates to run in multiple threads both this flag and the project setting "Allow Multi Threaded
      Animation Update" should be set.
    - ``warn_about_blueprint_usage`` (bool):  [Read-Write] Selecting this option will cause the compiler to emit warnings whenever a call into Blueprint
      is made from the animation graph. This can help track down optimizations that need to be made.
    """
    def get_nodes_of_class(self, node_class: Class, include_child_classes: bool = True) -> Array[AnimGraphNode_Base]:
        r"""
        x.get_nodes_of_class(node_class, include_child_classes=True) -> Array[AnimGraphNode_Base]
        Returns all Animation Graph Nodes of the provided Node Class contained by the Animation Blueprint
        
        Args:
            node_class (type(Class)): 
            include_child_classes (bool): 
        
        Returns:
            Array[AnimGraphNode_Base]: 
        
            graph_nodes (Array[AnimGraphNode_Base]):
        """
        ...
    def get_animation_graphs(self) -> Array[AnimationGraph]:
        r"""
        x.get_animation_graphs() -> Array[AnimationGraph]
        Returns all Animation Graphs contained by the provided Animation Blueprint
        
        Returns:
            Array[AnimationGraph]: 
        
            animation_graphs (Array[AnimationGraph]):
        """
        ...
    def add_node_asset_override(self, target: AnimationAsset, override: AnimationAsset, print_applied_overrides: bool = False) -> None:
        r"""
        x.add_node_asset_override(target, override, print_applied_overrides=False) -> None
        Adds an Animation Asset override for the provided AnimationBlueprint, replacing any instance of Target with Override
        
        Args:
            target (AnimationAsset): The Animation Asset to add an override for (overrides all instances of the asset)
            override (AnimationAsset): The Animation Asset to used to override the Target with (types have to match)
            print_applied_overrides (bool): Flag whether or not to print the applied overrides
        """
        ...

class VimBlueprint(AnimBlueprint):
    r"""
    deprecated: 'VimBlueprint' was renamed to 'AnimBlueprint'.
    """
    ...

class AnimationLibrary(BlueprintFunctionLibrary):
    r"""
    Blueprint library for altering and analyzing animation / skeletal data
    
    **C++ Source:**
    
    - **Module**: AnimationBlueprintLibrary
    - **File**: AnimationBlueprintLibrary.h
    
    """
    @classmethod
    def set_variable_frame_stripping_settings(cls, animation_sequence: AnimSequence, variable_frame_stripping_settings: VariableFrameStrippingSettings) -> None:
        r"""
        X.set_variable_frame_stripping_settings(animation_sequence, variable_frame_stripping_settings) -> None
        Sets the Variable Frame Stripping Settings for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            variable_frame_stripping_settings (VariableFrameStrippingSettings):
        """
        ...
    @classmethod
    def set_root_motion_lock_type(cls, animation_sequence: AnimSequence, root_motion_lock_type: RootMotionRootLock) -> None:
        r"""
        X.set_root_motion_lock_type(animation_sequence, root_motion_lock_type) -> None
        Sets the Root Motion Lock Type for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            root_motion_lock_type (RootMotionRootLock):
        """
        ...
    @classmethod
    def set_root_motion_enabled(cls, animation_sequence: AnimSequence, enabled: bool) -> None:
        r"""
        X.set_root_motion_enabled(animation_sequence, enabled) -> None
        Sets whether or not Root Motion is Enabled for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            enabled (bool):
        """
        ...
    @classmethod
    def set_rate_scale(cls, animation_sequence_base: AnimSequenceBase, rate_scale: float) -> None:
        r"""
        X.set_rate_scale(animation_sequence_base, rate_scale) -> None
        Sets the (Play) Rate Scale for the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            rate_scale (float):
        """
        ...
    @classmethod
    def set_is_root_motion_lock_forced(cls, animation_sequence: AnimSequence, forced: bool) -> None:
        r"""
        X.set_is_root_motion_lock_forced(animation_sequence, forced) -> None
        Sets whether or not Root Motion locking is Forced for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            forced (bool):
        """
        ...
    @classmethod
    def set_curve_compression_settings(cls, animation_sequence: AnimSequence, compression_settings: AnimCurveCompressionSettings) -> None:
        r"""
        X.set_curve_compression_settings(animation_sequence, compression_settings) -> None
        Sets the Curve Compression Settings for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            compression_settings (AnimCurveCompressionSettings):
        """
        ...
    @classmethod
    def set_bone_compression_settings(cls, animation_sequence: AnimSequence, compression_settings: AnimBoneCompressionSettings) -> None:
        r"""
        X.set_bone_compression_settings(animation_sequence, compression_settings) -> None
        Sets the Bone Compression Settings for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            compression_settings (AnimBoneCompressionSettings):
        """
        ...
    @classmethod
    def set_animation_interpolation_type(cls, animation_sequence: AnimSequence, interpolation_type: AnimInterpolationType) -> None:
        r"""
        X.set_animation_interpolation_type(animation_sequence, interpolation_type) -> None
        Sets the Animation Interpolation type for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            interpolation_type (AnimInterpolationType):
        """
        ...
    @classmethod
    def set_additive_base_pose_type(cls, animation_sequence: AnimSequence, additive_base_pose_type: AdditiveBasePoseType) -> None:
        r"""
        X.set_additive_base_pose_type(animation_sequence, additive_base_pose_type) -> None
        Sets the Additive Base Pose type for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            additive_base_pose_type (AdditiveBasePoseType):
        """
        ...
    @classmethod
    def set_additive_animation_type(cls, animation_sequence: AnimSequence, additive_animation_type: AdditiveAnimationType) -> None:
        r"""
        X.set_additive_animation_type(animation_sequence, additive_animation_type) -> None
        Sets the Additive Animation type for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            additive_animation_type (AdditiveAnimationType):
        """
        ...
    @classmethod
    def replace_anim_notify_states(cls, animation_sequence_base: AnimSequenceBase, old_notify_class: Class, new_notify_class: Class, on_notify_state_replaced: OnNotifyStateReplaced) -> None:
        r"""
        X.replace_anim_notify_states(animation_sequence_base, old_notify_class, new_notify_class, on_notify_state_replaced) -> None
        Replaces animation notifies in the specified Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            old_notify_class (type(Class)): 
            new_notify_class (type(Class)): 
            on_notify_state_replaced (OnNotifyStateReplaced):
        """
        ...
    @classmethod
    def replace_anim_notifies(cls, animation_sequence_base: AnimSequenceBase, old_notify_class: Class, new_notify_class: Class, on_notify_replaced: OnNotifyReplaced) -> None:
        r"""
        X.replace_anim_notifies(animation_sequence_base, old_notify_class, new_notify_class, on_notify_replaced) -> None
        Replaces animation notifies in the specified Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            old_notify_class (type(Class)): 
            new_notify_class (type(Class)): 
            on_notify_replaced (OnNotifyReplaced):
        """
        ...
    @classmethod
    def remove_virtual_bones(cls, animation_sequence: AnimSequence, virtual_bone_names: Array[Name]) -> None:
        r"""
        X.remove_virtual_bones(animation_sequence, virtual_bone_names) -> None
        Removes Virtual Bones with the specified Bone Names from the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            virtual_bone_names (Array[Name]):
        """
        ...
    @classmethod
    def remove_virtual_bone(cls, animation_sequence: AnimSequence, virtual_bone_name: Name) -> None:
        r"""
        X.remove_virtual_bone(animation_sequence, virtual_bone_name) -> None
        Removes a Virtual Bone with the specified Bone Name from the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            virtual_bone_name (Name):
        """
        ...
    @classmethod
    def remove_meta_data_of_class(cls, animation_asset: AnimationAsset, meta_data_class: Class) -> None:
        r"""
        X.remove_meta_data_of_class(animation_asset, meta_data_class) -> None
        Removes all Meta Data Instance of the specified Class from the given Animation Asset
        
        Args:
            animation_asset (AnimationAsset): 
            meta_data_class (type(Class)):
        """
        ...
    @classmethod
    def remove_meta_data(cls, animation_asset: AnimationAsset, meta_data_object: AnimMetaData) -> None:
        r"""
        X.remove_meta_data(animation_asset, meta_data_object) -> None
        Removes the specified Meta Data Instance from the given Animation Asset
        
        Args:
            animation_asset (AnimationAsset): 
            meta_data_object (AnimMetaData):
        """
        ...
    @classmethod
    def remove_curve(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name, remove_name_from_skeleton: bool = False) -> None:
        r"""
        X.remove_curve(animation_sequence_base, curve_name, remove_name_from_skeleton=False) -> None
        Removes an Animation Curve by Name from the given Animation Sequence (Raw Animation Curves [Names] may not be removed from the Skeleton)
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
            remove_name_from_skeleton (bool):
        """
        ...
    @classmethod
    def remove_bone_animation(cls, animation_sequence: AnimSequence, bone_name: Name, include_children: bool = True, finalize: bool = True) -> None:
        r"""
        X.remove_bone_animation(animation_sequence, bone_name, include_children=True, finalize=True) -> None
        Removes an Animation Curve by Name from the given Animation Sequence (Raw Animation Curves [Names] may not be removed from the Skeleton)
        
        Args:
            animation_sequence (AnimSequence): : AnimSequence
            bone_name (Name): : Name of bone track user wants to remove
            include_children (bool): : true if user wants to include all children of BoneName
            finalize (bool): : If you set this to true, it will trigger compression. If you set bFinalize to be false, you'll have to manually trigger Finalize.
        """
        ...
    @classmethod
    def remove_animation_sync_markers_by_track(cls, animation_sequence: AnimSequence, notify_track_name: Name) -> int:
        r"""
        X.remove_animation_sync_markers_by_track(animation_sequence, notify_track_name) -> int32
        Removes All Animation Sync Marker found within the Animation Sequence that belong to the specific Notify Track, and returns the number of removed instances
        
        Args:
            animation_sequence (AnimSequence): 
            notify_track_name (Name): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def remove_animation_sync_markers_by_name(cls, animation_sequence: AnimSequence, marker_name: Name) -> int:
        r"""
        X.remove_animation_sync_markers_by_name(animation_sequence, marker_name) -> int32
        Removes All Animation Sync Marker found within the Animation Sequence whose name matches MarkerName, and returns the number of removed instances
        
        Args:
            animation_sequence (AnimSequence): 
            marker_name (Name): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def remove_animation_notify_track(cls, animation_sequence_base: AnimSequenceBase, notify_track_name: Name) -> None:
        r"""
        X.remove_animation_notify_track(animation_sequence_base, notify_track_name) -> None
        Removes an Animation Notify Track from Animation Sequence by Name
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            notify_track_name (Name):
        """
        ...
    @classmethod
    def remove_animation_notify_events_by_track(cls, animation_sequence_base: AnimSequenceBase, notify_track_name: Name) -> int:
        r"""
        X.remove_animation_notify_events_by_track(animation_sequence_base, notify_track_name) -> int32
        Removes Animation Notify Events found by Track within the Animation Sequence, and returns the number of removed name instances
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            notify_track_name (Name): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def remove_animation_notify_events_by_name(cls, animation_sequence_base: AnimSequenceBase, notify_name: Name) -> int:
        r"""
        X.remove_animation_notify_events_by_name(animation_sequence_base, notify_name) -> int32
        Removes Animation Notify Events found by Name within the Animation Sequence, and returns the number of removed name instances
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            notify_name (Name): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def remove_all_virtual_bones(cls, animation_sequence: AnimSequence) -> None:
        r"""
        X.remove_all_virtual_bones(animation_sequence) -> None
        Removes all Virtual Bones from the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence):
        """
        ...
    @classmethod
    def remove_all_meta_data(cls, animation_asset: AnimationAsset) -> None:
        r"""
        X.remove_all_meta_data(animation_asset) -> None
        Removes all Meta Data from the given Animation Asset
        
        Args:
            animation_asset (AnimationAsset):
        """
        ...
    @classmethod
    def remove_all_curve_data(cls, animation_sequence_base: AnimSequenceBase) -> None:
        r"""
        X.remove_all_curve_data(animation_sequence_base) -> None
        Removes all Animation Curve Data from the given Animation Sequence (Raw Animation Curves [Names] may not be removed from the Skeleton)
        
        Args:
            animation_sequence_base (AnimSequenceBase):
        """
        ...
    @classmethod
    def remove_all_bone_animation(cls, animation_sequence: AnimSequence) -> None:
        r"""
        X.remove_all_bone_animation(animation_sequence) -> None
        Removes all Animation Bone Track Data from the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence):
        """
        ...
    @classmethod
    def remove_all_animation_sync_markers(cls, animation_sequence: AnimSequence) -> None:
        r"""
        X.remove_all_animation_sync_markers(animation_sequence) -> None
        Removes All Animation Sync Markers found within the Animation Sequence, and returns the number of removed instances
        
        Args:
            animation_sequence (AnimSequence):
        """
        ...
    @classmethod
    def remove_all_animation_notify_tracks(cls, animation_sequence_base: AnimSequenceBase) -> None:
        r"""
        X.remove_all_animation_notify_tracks(animation_sequence_base) -> None
        Removes All Animation Notify Tracks from Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase):
        """
        ...
    @classmethod
    def is_valid_time(cls, animation_sequence_base: AnimSequenceBase, time: float) -> bool:
        r"""
        X.is_valid_time(animation_sequence_base, time) -> bool
        Checks whether or not the given Time Value lies within the given Animation Sequence's Length
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            time (float): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    @classmethod
    def is_valid_raw_animation_track_name(cls, animation_sequence_base: AnimSequenceBase, track_name: Name) -> bool:
        r"""
        X.is_valid_raw_animation_track_name(animation_sequence_base, track_name) -> bool
        Checks whether or not the given Animation Track Name is contained within the Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            track_name (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_anim_notify_track_name(cls, animation_sequence_base: AnimSequenceBase, notify_track_name: Name) -> bool:
        r"""
        X.is_valid_anim_notify_track_name(animation_sequence_base, notify_track_name) -> bool
        Checks whether or not the given Track Name is a valid Animation Notify Track in the Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            notify_track_name (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_animation_sync_marker_name(cls, animation_sequence: AnimSequence, marker_name: Name) -> bool:
        r"""
        X.is_valid_animation_sync_marker_name(animation_sequence, marker_name) -> bool
        Checks whether or not the given Marker Name is a valid Animation Sync Marker Name
        
        Args:
            animation_sequence (AnimSequence): 
            marker_name (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_root_motion_lock_forced(cls, animation_sequence: AnimSequence) -> bool:
        r"""
        X.is_root_motion_lock_forced(animation_sequence) -> bool
        Checks whether or not Root Motion locking is Forced for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_root_motion_enabled(cls, animation_sequence: AnimSequence) -> bool:
        r"""
        X.is_root_motion_enabled(animation_sequence) -> bool
        Checks whether or not Root Motion is Enabled for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_vector_keys(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name) -> Tuple[Array[float], Array[Vector]]:
        r"""
        X.get_vector_keys(animation_sequence_base, curve_name) -> (times=Array[float], values=Array[Vector])
        Retrieves, a multiple of, Vector Key(s) from the specified Animation Curve inside of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
        
        Returns:
            tuple: 
        
            times (Array[float]): 
        
            values (Array[Vector]):
        """
        ...
    @classmethod
    def get_variable_frame_stripping_settings(cls, animation_sequence: AnimSequence) -> VariableFrameStrippingSettings:
        r"""
        X.get_variable_frame_stripping_settings(animation_sequence) -> VariableFrameStrippingSettings
        Retrieves the Variable Frame Stripping Settings for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
        
        Returns:
            VariableFrameStrippingSettings: 
        
            variable_frame_stripping_settings (VariableFrameStrippingSettings):
        """
        ...
    @classmethod
    def get_unique_marker_names(cls, animation_sequence: AnimSequence) -> Array[Name]:
        r"""
        X.get_unique_marker_names(animation_sequence) -> Array[Name]
        Retrieves all the Unique Names for the Animation Sync Markers contained by the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
        
        Returns:
            Array[Name]: 
        
            marker_names (Array[Name]):
        """
        ...
    @classmethod
    def get_transformation_keys(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name) -> Tuple[Array[float], Array[Transform]]:
        r"""
        X.get_transformation_keys(animation_sequence_base, curve_name) -> (times=Array[float], values=Array[Transform])
        Retrieves, a multiple of, Transformation Key(s) from the specified Animation Curve inside of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
        
        Returns:
            tuple: 
        
            times (Array[float]): 
        
            values (Array[Transform]):
        """
        ...
    @classmethod
    def get_time_at_frame(cls, animation_sequence_base: AnimSequenceBase, frame: int) -> float:
        r"""
        X.get_time_at_frame(animation_sequence_base, frame) -> float
        Retrieves the Time Value at the specified Frame Indexfor the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            frame (int32): 
        
        Returns:
            float: 
        
            time (float):
        """
        ...
    @classmethod
    def get_sequence_length(cls, animation_sequence_base: AnimSequenceBase) -> float:
        r"""
        X.get_sequence_length(animation_sequence_base) -> float
        Retrieves the Length of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
        
        Returns:
            float: 
        
            length (float):
        """
        ...
    @classmethod
    def get_root_motion_lock_type(cls, animation_sequence: AnimSequence) -> RootMotionRootLock:
        r"""
        X.get_root_motion_lock_type(animation_sequence) -> RootMotionRootLock
        Retrieves the Root Motion Lock Type for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
        
        Returns:
            RootMotionRootLock: 
        
            lock_type (RootMotionRootLock):
        """
        ...
    @classmethod
    def get_raw_track_scale_data(cls, animation_sequence_base: AnimSequenceBase, track_name: Name) -> Array[Vector]:
        r"""
        X.get_raw_track_scale_data(animation_sequence_base, track_name) -> Array[Vector]
        Get Raw Track Scale Data
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            track_name (Name): 
        
        Returns:
            Array[Vector]: 
        
            scale_data (Array[Vector]):
        """
        ...
    @classmethod
    def get_raw_track_rotation_data(cls, animation_sequence_base: AnimSequenceBase, track_name: Name) -> Array[Quat]:
        r"""
        X.get_raw_track_rotation_data(animation_sequence_base, track_name) -> Array[Quat]
        Get Raw Track Rotation Data
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            track_name (Name): 
        
        Returns:
            Array[Quat]: 
        
            rotation_data (Array[Quat]):
        """
        ...
    @classmethod
    def get_raw_track_position_data(cls, animation_sequence_base: AnimSequenceBase, track_name: Name) -> Array[Vector]:
        r"""
        X.get_raw_track_position_data(animation_sequence_base, track_name) -> Array[Vector]
        Get Raw Track Position Data
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            track_name (Name): 
        
        Returns:
            Array[Vector]: 
        
            position_data (Array[Vector]):
        """
        ...
    @classmethod
    def get_raw_track_data(cls, animation_sequence_base: AnimSequenceBase, track_name: Name) -> Tuple[Array[Vector], Array[Quat], Array[Vector]]:
        r"""
        X.get_raw_track_data(animation_sequence_base, track_name) -> (position_keys=Array[Vector], rotation_keys=Array[Quat], scaling_keys=Array[Vector])
        Get Raw Track Data
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            track_name (Name): 
        
        Returns:
            tuple: 
        
            position_keys (Array[Vector]): 
        
            rotation_keys (Array[Quat]): 
        
            scaling_keys (Array[Vector]):
        """
        ...
    @classmethod
    def get_rate_scale(cls, animation_sequence_base: AnimSequenceBase) -> float:
        r"""
        X.get_rate_scale(animation_sequence_base) -> float
        Retrieves the (Play) Rate Scale of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
        
        Returns:
            float: 
        
            rate_scale (float):
        """
        ...
    @classmethod
    def get_num_keys(cls, animation_sequence_base: AnimSequenceBase) -> int:
        r"""
        X.get_num_keys(animation_sequence_base) -> int32
        Retrieves the number of animation keys for the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
        
        Returns:
            int32: 
        
            num_keys (int32):
        """
        ...
    @classmethod
    def get_num_frames(cls, animation_sequence_base: AnimSequenceBase) -> int:
        r"""
        X.get_num_frames(animation_sequence_base) -> int32
        Retrieves the number of animation frames for the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
        
        Returns:
            int32: 
        
            num_frames (int32):
        """
        ...
    @classmethod
    def get_nodes_of_class(cls, animation_blueprint: AnimBlueprint, node_class: Class, include_child_classes: bool = True) -> Array[AnimGraphNode_Base]:
        r"""
        X.get_nodes_of_class(animation_blueprint, node_class, include_child_classes=True) -> Array[AnimGraphNode_Base]
        Returns all Animation Graph Nodes of the provided Node Class contained by the Animation Blueprint
        
        Args:
            animation_blueprint (AnimBlueprint): 
            node_class (type(Class)): 
            include_child_classes (bool): 
        
        Returns:
            Array[AnimGraphNode_Base]: 
        
            graph_nodes (Array[AnimGraphNode_Base]):
        """
        ...
    @classmethod
    def get_montage_slot_names(cls, animation_montage: AnimMontage) -> Array[Name]:
        r"""
        X.get_montage_slot_names(animation_montage) -> Array[Name]
        Retrieves the Names of the Animation Slots used in the given Montage
        
        Args:
            animation_montage (AnimMontage): 
        
        Returns:
            Array[Name]: 
        
            slot_names (Array[Name]):
        """
        ...
    @classmethod
    def get_meta_data_of_class(cls, animation_asset: AnimationAsset, meta_data_class: Class) -> Array[AnimMetaData]:
        r"""
        X.get_meta_data_of_class(animation_asset, meta_data_class) -> Array[AnimMetaData]
        Retrieves all Meta Data Instances from the given Animation Asset
        
        Args:
            animation_asset (AnimationAsset): 
            meta_data_class (type(Class)): 
        
        Returns:
            Array[AnimMetaData]: 
        
            meta_data_of_class (Array[AnimMetaData]):
        """
        ...
    @classmethod
    def get_meta_data(cls, animation_asset: AnimationAsset) -> Array[AnimMetaData]:
        r"""
        X.get_meta_data(animation_asset) -> Array[AnimMetaData]
        Retrieves all Meta Data Instances from the given Animation Asset
        
        Args:
            animation_asset (AnimationAsset): 
        
        Returns:
            Array[AnimMetaData]: 
        
            meta_data (Array[AnimMetaData]):
        """
        ...
    @classmethod
    def get_frame_at_time(cls, animation_sequence_base: AnimSequenceBase, time: float) -> int:
        r"""
        X.get_frame_at_time(animation_sequence_base, time) -> int32
        Retrieves the Frame Index at the specified Time Value for the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            time (float): 
        
        Returns:
            int32: 
        
            frame (int32):
        """
        ...
    @classmethod
    def get_float_value_at_time(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name, time: float) -> float:
        r"""
        X.get_float_value_at_time(animation_sequence_base, curve_name, time) -> float
        Retrieves an evaluated float value for a given time from the specified Animation Curve inside of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
            time (float): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_float_keys(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name) -> Tuple[Array[float], Array[float]]:
        r"""
        X.get_float_keys(animation_sequence_base, curve_name) -> (times=Array[float], values=Array[float])
        Retrieves, a multiple of, Float Key(s) from the specified Animation Curve inside of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
        
        Returns:
            tuple: 
        
            times (Array[float]): 
        
            values (Array[float]):
        """
        ...
    @classmethod
    def get_curve_compression_settings(cls, animation_sequence: AnimSequence) -> AnimCurveCompressionSettings:
        r"""
        X.get_curve_compression_settings(animation_sequence) -> AnimCurveCompressionSettings
        Retrieves the Curve Compression Settings for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
        
        Returns:
            AnimCurveCompressionSettings: 
        
            compression_settings (AnimCurveCompressionSettings):
        """
        ...
    @classmethod
    def get_bone_poses_for_time(cls, animation_sequence_base: AnimSequenceBase, bone_names: Array[Name], time: float, extract_root_motion: bool, preview_mesh: SkeletalMesh = None) -> Array[Transform]:
        r"""
        X.get_bone_poses_for_time(animation_sequence_base, bone_names, time, extract_root_motion, preview_mesh=None) -> Array[Transform]
        Get Bone Poses for Time
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            bone_names (Array[Name]): 
            time (float): 
            extract_root_motion (bool): 
            preview_mesh (SkeletalMesh): 
        
        Returns:
            Array[Transform]: 
        
            poses (Array[Transform]):
        """
        ...
    @classmethod
    def get_bone_poses_for_frame(cls, animation_sequence_base: AnimSequenceBase, bone_names: Array[Name], frame: int, extract_root_motion: bool, preview_mesh: SkeletalMesh = None) -> Array[Transform]:
        r"""
        X.get_bone_poses_for_frame(animation_sequence_base, bone_names, frame, extract_root_motion, preview_mesh=None) -> Array[Transform]
        Get Bone Poses for Frame
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            bone_names (Array[Name]): 
            frame (int32): 
            extract_root_motion (bool): 
            preview_mesh (SkeletalMesh): 
        
        Returns:
            Array[Transform]: 
        
            poses (Array[Transform]):
        """
        ...
    @classmethod
    def get_bone_pose_for_time(cls, animation_sequence_base: AnimSequenceBase, bone_name: Name, time: float, extract_root_motion: bool) -> Transform:
        r"""
        X.get_bone_pose_for_time(animation_sequence_base, bone_name, time, extract_root_motion) -> Transform
        Get Bone Pose for Time
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            bone_name (Name): 
            time (float): 
            extract_root_motion (bool): 
        
        Returns:
            Transform: 
        
            pose (Transform):
        """
        ...
    @classmethod
    def get_bone_pose_for_frame(cls, animation_sequence_base: AnimSequenceBase, bone_name: Name, frame: int, extract_root_motion: bool) -> Transform:
        r"""
        X.get_bone_pose_for_frame(animation_sequence_base, bone_name, frame, extract_root_motion) -> Transform
        Get Bone Pose for Frame
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            bone_name (Name): 
            frame (int32): 
            extract_root_motion (bool): 
        
        Returns:
            Transform: 
        
            pose (Transform):
        """
        ...
    @classmethod
    def get_bone_compression_settings(cls, animation_sequence: AnimSequence) -> AnimBoneCompressionSettings:
        r"""
        X.get_bone_compression_settings(animation_sequence) -> AnimBoneCompressionSettings
        Retrieves the Bone Compression Settings for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
        
        Returns:
            AnimBoneCompressionSettings: 
        
            compression_settings (AnimBoneCompressionSettings):
        """
        ...
    @classmethod
    def get_anim_notify_event_trigger_time(cls, notify_event: AnimNotifyEvent) -> float:
        r"""
        X.get_anim_notify_event_trigger_time(notify_event) -> float
        Returns the actual trigger time for a NotifyEvent
        
        Args:
            notify_event (AnimNotifyEvent): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_anim_notify_event_duration(cls, notify_event: AnimNotifyEvent) -> float:
        r"""
        X.get_anim_notify_event_duration(notify_event) -> float
        Returns the duration for a NotifyEvent, only non-zero for Anim Notify States
        
        Args:
            notify_event (AnimNotifyEvent): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_animation_track_names(cls, animation_sequence_base: AnimSequenceBase) -> Array[Name]:
        r"""
        X.get_animation_track_names(animation_sequence_base) -> Array[Name]
        Retrieves the Names of the individual ATracks for the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
        
        Returns:
            Array[Name]: 
        
            track_names (Array[Name]):
        """
        ...
    @classmethod
    def get_animation_sync_markers_for_track(cls, animation_sequence: AnimSequence, notify_track_name: Name) -> Array[AnimSyncMarker]:
        r"""
        X.get_animation_sync_markers_for_track(animation_sequence, notify_track_name) -> Array[AnimSyncMarker]
        Retrieves all Animation Sync Markers for the given Notify Track Name from the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            notify_track_name (Name): 
        
        Returns:
            Array[AnimSyncMarker]: 
        
            markers (Array[AnimSyncMarker]):
        """
        ...
    @classmethod
    def get_animation_sync_markers(cls, animation_sequence: AnimSequence) -> Array[AnimSyncMarker]:
        r"""
        X.get_animation_sync_markers(animation_sequence) -> Array[AnimSyncMarker]
        Retrieves all the Animation Sync Markers for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
        
        Returns:
            Array[AnimSyncMarker]: 
        
            markers (Array[AnimSyncMarker]):
        """
        ...
    @classmethod
    def get_animation_notify_track_names(cls, animation_sequence_base: AnimSequenceBase) -> Array[Name]:
        r"""
        X.get_animation_notify_track_names(animation_sequence_base) -> Array[Name]
        Retrieves all Unique Animation Notify Track Names found within the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
        
        Returns:
            Array[Name]: 
        
            track_names (Array[Name]):
        """
        ...
    @classmethod
    def get_animation_notify_events_for_track(cls, animation_sequence_base: AnimSequenceBase, notify_track_name: Name) -> Array[AnimNotifyEvent]:
        r"""
        X.get_animation_notify_events_for_track(animation_sequence_base, notify_track_name) -> Array[AnimNotifyEvent]
        Retrieves all Animation Notify Events for the given Notify Track Name from the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            notify_track_name (Name): 
        
        Returns:
            Array[AnimNotifyEvent]: 
        
            events (Array[AnimNotifyEvent]):
        """
        ...
    @classmethod
    def get_animation_notify_events(cls, animation_sequence_base: AnimSequenceBase) -> Array[AnimNotifyEvent]:
        r"""
        X.get_animation_notify_events(animation_sequence_base) -> Array[AnimNotifyEvent]
        Retrieves all Animation Notify Events found within the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
        
        Returns:
            Array[AnimNotifyEvent]: 
        
            notify_events (Array[AnimNotifyEvent]):
        """
        ...
    @classmethod
    def get_animation_notify_event_names(cls, animation_sequence_base: AnimSequenceBase) -> Array[Name]:
        r"""
        X.get_animation_notify_event_names(animation_sequence_base) -> Array[Name]
        Retrieves all Unique Animation Notify Events found within the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
        
        Returns:
            Array[Name]: 
        
            event_names (Array[Name]):
        """
        ...
    @classmethod
    def get_animation_interpolation_type(cls, animation_sequence: AnimSequence) -> AnimInterpolationType:
        r"""
        X.get_animation_interpolation_type(animation_sequence) -> AnimInterpolationType
        Retrieves the Animation Interpolation type for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
        
        Returns:
            AnimInterpolationType: 
        
            interpolation_type (AnimInterpolationType):
        """
        ...
    @classmethod
    def get_animation_graphs(cls, animation_blueprint: AnimBlueprint) -> Array[AnimationGraph]:
        r"""
        X.get_animation_graphs(animation_blueprint) -> Array[AnimationGraph]
        Returns all Animation Graphs contained by the provided Animation Blueprint
        
        Args:
            animation_blueprint (AnimBlueprint): 
        
        Returns:
            Array[AnimationGraph]: 
        
            animation_graphs (Array[AnimationGraph]):
        """
        ...
    @classmethod
    def get_animation_curve_names(cls, animation_sequence_base: AnimSequenceBase, curve_type: RawCurveTrackTypes) -> Array[Name]:
        r"""
        X.get_animation_curve_names(animation_sequence_base, curve_type) -> Array[Name]
        Retrieves the Names of the individual float curves for the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_type (RawCurveTrackTypes): 
        
        Returns:
            Array[Name]: 
        
            curve_names (Array[Name]):
        """
        ...
    @classmethod
    def get_additive_base_pose_type(cls, animation_sequence: AnimSequence) -> AdditiveBasePoseType:
        r"""
        X.get_additive_base_pose_type(animation_sequence) -> AdditiveBasePoseType
        Retrieves the Additive Base Pose type for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
        
        Returns:
            AdditiveBasePoseType: 
        
            additive_base_pose_type (AdditiveBasePoseType):
        """
        ...
    @classmethod
    def get_additive_animation_type(cls, animation_sequence: AnimSequence) -> AdditiveAnimationType:
        r"""
        X.get_additive_animation_type(animation_sequence) -> AdditiveAnimationType
        Retrieves the Additive Animation type for the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
        
        Returns:
            AdditiveAnimationType: 
        
            additive_animation_type (AdditiveAnimationType):
        """
        ...
    @classmethod
    def find_bone_path_to_root(cls, animation_sequence_base: AnimSequenceBase, bone_name: Name) -> Array[Name]:
        r"""
        X.find_bone_path_to_root(animation_sequence_base, bone_name) -> Array[Name]
        Finds the Bone Path from the given Bone to the Root Bone
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            bone_name (Name): 
        
        Returns:
            Array[Name]: 
        
            bone_path (Array[Name]):
        """
        ...
    @classmethod
    def finalize_bone_animation(cls, animation_sequence: AnimSequence) -> None:
        r"""
        X.finalize_bone_animation(animation_sequence) -> None
        Finalize Bone Animation
        deprecated: FinalizeBoneAnimation has been deprecated, use UAnimDataController instead
        
        Args:
            animation_sequence (AnimSequence):
        """
        ...
    @classmethod
    def evaluate_root_bone_timecode_subframe_attribute_at_time(cls, animation_sequence_base: AnimSequenceBase, eval_time: float) -> Optional[float]:
        r"""
        X.evaluate_root_bone_timecode_subframe_attribute_at_time(animation_sequence_base, eval_time) -> float or None
        Evaluates the subframe timecode attribute (e.g. "TCSubframe") of the root bone and returns the resulting value.
        
        Since the subframe component of FFrameTime is clamped to the range [0.0, 1.0), it cannot accurately represent the use
        case where the timecode metadata represents subframe values as whole numbered subframes instead of as a percentage of a
        frame the way the engine does. The subframe component of the FQualifiedFrameTime returned by
        EvaluateRootBoneTimecodeAttributesAtTime() may not reflect the authored subframe metadata in that case.
        
        This function allows access to the subframe values that were actually authored in the timecode metadata.
        return:: true if the root bone had a subframe timecode attribute that could be evaluated and a value was set, or false otherwise.
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            eval_time (float): 
        
        Returns:
            float or None: 
        
            out_subframe (float):
        """
        ...
    @classmethod
    def evaluate_root_bone_timecode_attributes_at_time(cls, animation_sequence_base: AnimSequenceBase, eval_time: float) -> Optional[QualifiedTime]:
        r"""
        X.evaluate_root_bone_timecode_attributes_at_time(animation_sequence_base, eval_time) -> QualifiedTime or None
        Evaluates timecode attributes (e.g. "TCFrame", "TCSecond", etc.) of the root bone and returns the resulting qualified frame time.
        return:: true if the root bone had timecode attributes that could be evaluated and a qualified frame time was set, or false otherwise.
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            eval_time (float): 
        
        Returns:
            QualifiedTime or None: 
        
            out_qualified_frame_time (QualifiedTime):
        """
        ...
    @classmethod
    def does_curve_exist(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name, curve_type: RawCurveTrackTypes) -> bool:
        r"""
        X.does_curve_exist(animation_sequence_base, curve_name, curve_type) -> bool
        Checks whether or not the given Curve Name exist on the Skeleton referenced by the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
            curve_type (RawCurveTrackTypes): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def does_bone_name_exist(cls, animation_sequence: AnimSequence, bone_name: Name) -> bool:
        r"""
        X.does_bone_name_exist(animation_sequence, bone_name) -> bool
        Checks whether or not the given Bone Name exist on the Skeleton referenced by the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            bone_name (Name): 
        
        Returns:
            bool: 
        
            exists (bool):
        """
        ...
    @classmethod
    def copy_anim_notifies_from_sequence(cls, source_animation_sequence_base: AnimSequenceBase, destination_animation_sequence_base: AnimSequenceBase, delete_existing_notifies: bool = False) -> None:
        r"""
        X.copy_anim_notifies_from_sequence(source_animation_sequence_base, destination_animation_sequence_base, delete_existing_notifies=False) -> None
        Copies animation notifies from Src Animation Sequence to Dest. Creates anim notify tracks as necessary. Returns true on success.
        
        Args:
            source_animation_sequence_base (AnimSequenceBase): 
            destination_animation_sequence_base (AnimSequenceBase): 
            delete_existing_notifies (bool):
        """
        ...
    @classmethod
    def copy_animation_curve_names_to_skeleton(cls, old_skeleton: Skeleton, new_skeleton: Skeleton, sequence_base: AnimSequenceBase, curve_type: RawCurveTrackTypes) -> None:
        r"""
        X.copy_animation_curve_names_to_skeleton(old_skeleton, new_skeleton, sequence_base, curve_type) -> None
        Ensures that any curve names that do not exist on the NewSkeleton are added to it, in which case the SmartName on the actual curve itself will also be updated
        deprecated: It is no longer necessary to copy curve names to the skeleton. If metadata is required to be updated, please use the metadata setting APIs.
        
        Args:
            old_skeleton (Skeleton): 
            new_skeleton (Skeleton): 
            sequence_base (AnimSequenceBase): 
            curve_type (RawCurveTrackTypes):
        """
        ...
    @classmethod
    def contains_meta_data_of_class(cls, animation_asset: AnimationAsset, meta_data_class: Class) -> bool:
        r"""
        X.contains_meta_data_of_class(animation_asset, meta_data_class) -> bool
        Checks whether or not the given Animation Asset contains Meta Data Instance of the specified Meta Data Class
        
        Args:
            animation_asset (AnimationAsset): 
            meta_data_class (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def add_virtual_bone(cls, animation_sequence: AnimSequence, source_bone_name: Name, target_bone_name: Name) -> Name:
        r"""
        X.add_virtual_bone(animation_sequence, source_bone_name, target_bone_name) -> Name
        Adds a Virtual Bone between the Source and Target Bones to the given Animation Sequence
        
        Args:
            animation_sequence (AnimSequence): 
            source_bone_name (Name): 
            target_bone_name (Name): 
        
        Returns:
            Name: 
        
            virtual_bone_name (Name):
        """
        ...
    @classmethod
    def add_vector_curve_keys(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name, times: Array[float], vectors: Array[Vector]) -> None:
        r"""
        X.add_vector_curve_keys(animation_sequence_base, curve_name, times, vectors) -> None
        Adds a multiple of Vector Keys to the specified Animation Curve inside of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
            times (Array[float]): 
            vectors (Array[Vector]):
        """
        ...
    @classmethod
    def add_vector_curve_key(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name, time: float, vector: Vector) -> None:
        r"""
        X.add_vector_curve_key(animation_sequence_base, curve_name, time, vector) -> None
        Adds a Vector Key to the specified Animation Curve inside of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
            time (float): 
            vector (Vector):
        """
        ...
    @classmethod
    def add_transformation_curve_keys(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name, times: Array[float], transforms: Array[Transform]) -> None:
        r"""
        X.add_transformation_curve_keys(animation_sequence_base, curve_name, times, transforms) -> None
        Adds a multiple of Transformation Keys to the specified Animation Curve inside of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
            times (Array[float]): 
            transforms (Array[Transform]):
        """
        ...
    @classmethod
    def add_transformation_curve_key(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name, time: float, transform: Transform) -> None:
        r"""
        X.add_transformation_curve_key(animation_sequence_base, curve_name, time, transform) -> None
        Adds a Transformation Key to the specified Animation Curve inside of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
            time (float): 
            transform (Transform):
        """
        ...
    @classmethod
    def add_node_asset_override(cls, anim_blueprint: AnimBlueprint, target: AnimationAsset, override: AnimationAsset, print_applied_overrides: bool = False) -> None:
        r"""
        X.add_node_asset_override(anim_blueprint, target, override, print_applied_overrides=False) -> None
        Adds an Animation Asset override for the provided AnimationBlueprint, replacing any instance of Target with Override
        
        Args:
            anim_blueprint (AnimBlueprint): The Animation Blueprint to add/set the Override for
            target (AnimationAsset): The Animation Asset to add an override for (overrides all instances of the asset)
            override (AnimationAsset): The Animation Asset to used to override the Target with (types have to match)
            print_applied_overrides (bool): Flag whether or not to print the applied overrides
        """
        ...
    @classmethod
    def add_meta_data_object(cls, animation_asset: AnimationAsset, meta_data_object: AnimMetaData) -> None:
        r"""
        X.add_meta_data_object(animation_asset, meta_data_object) -> None
        Adds an instance of the specified MetaData Class to the given Animation Asset (requires MetaDataObject's outer to be the Animation Asset)
        
        Args:
            animation_asset (AnimationAsset): 
            meta_data_object (AnimMetaData):
        """
        ...
    @classmethod
    def add_meta_data(cls, animation_asset: AnimationAsset, meta_data_class: Class) -> AnimMetaData:
        r"""
        X.add_meta_data(animation_asset, meta_data_class) -> AnimMetaData
        Creates and Adds an instance of the specified MetaData Class to the given Animation Asset
        
        Args:
            animation_asset (AnimationAsset): 
            meta_data_class (type(Class)): 
        
        Returns:
            AnimMetaData: 
        
            meta_data_instance (AnimMetaData):
        """
        ...
    @classmethod
    def add_float_curve_keys(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name, times: Array[float], values: Array[float]) -> None:
        r"""
        X.add_float_curve_keys(animation_sequence_base, curve_name, times, values) -> None
        Adds a multiple of Float Keys to the specified Animation Curve inside of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
            times (Array[float]): 
            values (Array[float]):
        """
        ...
    @classmethod
    def add_float_curve_key(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name, time: float, value: float) -> None:
        r"""
        X.add_float_curve_key(animation_sequence_base, curve_name, time, value) -> None
        Adds a Float Key to the specified Animation Curve inside of the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
            time (float): 
            value (float):
        """
        ...
    @classmethod
    def add_curve(cls, animation_sequence_base: AnimSequenceBase, curve_name: Name, curve_type: RawCurveTrackTypes = RawCurveTrackTypes.RCT_FLOAT, meta_data_curve: bool = False) -> None:
        r"""
        X.add_curve(animation_sequence_base, curve_name, curve_type=RawCurveTrackTypes.RCT_FLOAT, meta_data_curve=False) -> None
        Adds an Animation Curve by Type and Name to the given Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            curve_name (Name): 
            curve_type (RawCurveTrackTypes): 
            meta_data_curve (bool):
        """
        ...
    @classmethod
    def add_animation_sync_marker(cls, animation_sequence: AnimSequence, marker_name: Name, time: float, notify_track_name: Name) -> None:
        r"""
        X.add_animation_sync_marker(animation_sequence, marker_name, time, notify_track_name) -> None
        Adds an Animation Sync Marker to Notify track in the given Animation with the corresponding Marker Name and Time
        
        Args:
            animation_sequence (AnimSequence): 
            marker_name (Name): 
            time (float): 
            notify_track_name (Name):
        """
        ...
    @classmethod
    def add_animation_notify_track(cls, animation_sequence_base: AnimSequenceBase, notify_track_name: Name, track_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000]) -> None:
        r"""
        X.add_animation_notify_track(animation_sequence_base, notify_track_name, track_color=[1.000000, 1.000000, 1.000000, 1.000000]) -> None
        Adds an Animation Notify Track to the Animation Sequence
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            notify_track_name (Name): 
            track_color (LinearColor):
        """
        ...
    @classmethod
    def add_animation_notify_state_event_object(cls, animation_sequence_base: AnimSequenceBase, start_time: float, duration: float, notify_state: AnimNotifyState, notify_track_name: Name) -> None:
        r"""
        X.add_animation_notify_state_event_object(animation_sequence_base, start_time, duration, notify_state, notify_track_name) -> None
        Adds an the specific Animation Notify State to the Animation Sequence (requires Notify State's outer to be the Animation Sequence)
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            start_time (float): 
            duration (float): 
            notify_state (AnimNotifyState): 
            notify_track_name (Name):
        """
        ...
    @classmethod
    def add_animation_notify_state_event(cls, animation_sequence_base: AnimSequenceBase, notify_track_name: Name, start_time: float, duration: float, notify_state_class: Class) -> AnimNotifyState:
        r"""
        X.add_animation_notify_state_event(animation_sequence_base, notify_track_name, start_time, duration, notify_state_class) -> AnimNotifyState
        Adds an Animation Notify State Event to Notify track in the given Animation with the given Notify State creation data
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            notify_track_name (Name): 
            start_time (float): 
            duration (float): 
            notify_state_class (type(Class)): 
        
        Returns:
            AnimNotifyState:
        """
        ...
    @classmethod
    def add_animation_notify_event_object(cls, animation_sequence_base: AnimSequenceBase, start_time: float, notify: AnimNotify, notify_track_name: Name) -> None:
        r"""
        X.add_animation_notify_event_object(animation_sequence_base, start_time, notify, notify_track_name) -> None
        Adds an the specific Animation Notify to the Animation Sequence (requires Notify's outer to be the Animation Sequence)
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            start_time (float): 
            notify (AnimNotify): 
            notify_track_name (Name):
        """
        ...
    @classmethod
    def add_animation_notify_event(cls, animation_sequence_base: AnimSequenceBase, notify_track_name: Name, start_time: float, notify_class: Class) -> AnimNotify:
        r"""
        X.add_animation_notify_event(animation_sequence_base, notify_track_name, start_time, notify_class) -> AnimNotify
        Adds an Animation Notify Event to Notify track in the given Animation with the given Notify creation data
        
        Args:
            animation_sequence_base (AnimSequenceBase): 
            notify_track_name (Name): 
            start_time (float): 
            notify_class (type(Class)): 
        
        Returns:
            AnimNotify:
        """
        ...

class Skeleton(Object):
    r"""
    USkeleton : that links between mesh and animation
            - Bone hierarchy for animations
            - Bone/track linkup between mesh and animation
            - Retargetting related
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Skeleton.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``bone_tree`` (Array[BoneNode]):  [Read-Only] Skeleton bone tree - each contains name and parent index*
    - ``compatible_skeletons`` (Array[Skeleton]):  [Read-Write] The list of compatible skeletons. This skeleton will be able to use animation data originating from skeletons within this array, such as animation sequences.
      This property is not bi-directional.
      
      This is an array of TSoftObjectPtr in order to prevent all skeletons to be loaded, as we only want to load things on demand.
      As this is EditAnywhere and an array of TSoftObjectPtr, checking validity of pointers is needed.
    """
    @property
    def compatible_skeletons(self) -> Array[Skeleton]:
        r"""
        (Array[Skeleton]):  [Read-Only] The list of compatible skeletons. This skeleton will be able to use animation data originating from skeletons within this array, such as animation sequences.
        This property is not bi-directional.
        
        This is an array of TSoftObjectPtr in order to prevent all skeletons to be loaded, as we only want to load things on demand.
        As this is EditAnywhere and an array of TSoftObjectPtr, checking validity of pointers is needed.
        """
        ...
    def get_blend_profile(self, profile_name: Name) -> BlendProfile:
        r"""
        x.get_blend_profile(profile_name) -> BlendProfile
        Get the specified blend profile by name
        
        Args:
            profile_name (Name): 
        
        Returns:
            BlendProfile:
        """
        ...
    def add_compatible_skeleton_soft(self, source_skeleton: Skeleton) -> None:
        r"""
        x.add_compatible_skeleton_soft(source_skeleton) -> None
        Add Compatible Skeleton Soft
        
        Args:
            source_skeleton (Skeleton):
        """
        ...
    def add_compatible_skeleton(self, source_skeleton: Skeleton) -> None:
        r"""
        x.add_compatible_skeleton(source_skeleton) -> None
        Add Compatible Skeleton
        
        Args:
            source_skeleton (Skeleton):
        """
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...
    def get_reference_pose(self) -> AnimPose:
        r"""
        x.get_reference_pose() -> AnimPose
        Populates an Anim Pose with the reference poses stored for the provided USkeleton
        
        Returns:
            AnimPose: 
        
            out_pose (AnimPose): Anim pose to hold the reference pose
        """
        ...
    def get_curve_identifiers(self, curve_type: RawCurveTrackTypes) -> Array[AnimationCurveIdentifier]:
        r"""
        x.get_curve_identifiers(curve_type) -> Array[AnimationCurveIdentifier]
        Retrieves all curve identifiers for a specific curve types from the provided Skeleton
        deprecated: Curve identifiers are no longer retrievable globally from the skeleton, they are specified per-animation.
        
        Args:
            curve_type (RawCurveTrackTypes): Type of the curve identifers to retrieve
        
        Returns:
            Array[AnimationCurveIdentifier]: Array of FAnimationCurveIdentifier instances each representing a unique curve if the operation was successful, empyty array otherwise
        """
        ...
    def get_curve_identifier(self, name: Name, curve_type: RawCurveTrackTypes) -> AnimationCurveIdentifier:
        r"""
        x.get_curve_identifier(name, curve_type) -> AnimationCurveIdentifier
        Get Curve Identifier
        deprecated: Please use SetCurveIdentifier.
        
        Args:
            name (Name): 
            curve_type (RawCurveTrackTypes): 
        
        Returns:
            AnimationCurveIdentifier:
        """
        ...
    def find_curve_identifier(self, name: Name, curve_type: RawCurveTrackTypes) -> AnimationCurveIdentifier:
        r"""
        x.find_curve_identifier(name, curve_type) -> AnimationCurveIdentifier
        Tries to construct a valid FAnimationCurveIdentifier instance. It tries to find the underlying SmartName on the provided Skeleton for the provided curve type.
        deprecated: Curve identifiers are no longer retrievable globally from the skeleton, they are specified per-animation.
        
        Args:
            name (Name): Name of the curve to find
            curve_type (RawCurveTrackTypes): Type of the curve to find
        
        Returns:
            AnimationCurveIdentifier: Valid FAnimationCurveIdentifier if the name exists on the skeleton and the operation was successful, invalid otherwise
        """
        ...

class AnimationAsset(Object):
    r"""
    Animation Asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    def set_preview_skeletal_mesh(self, preview_mesh: SkeletalMesh) -> None:
        r"""
        x.set_preview_skeletal_mesh(preview_mesh) -> None
        Sets or updates the preview skeletal mesh
        
        Args:
            preview_mesh (SkeletalMesh):
        """
        ...
    def get_play_length(self) -> float:
        r"""
        x.get_play_length() -> float
        Get Play Length
        
        Returns:
            float:
        """
        ...
    def find_meta_data_by_class(self, meta_data_class: Class) -> AnimMetaData:
        r"""
        x.find_meta_data_by_class(meta_data_class) -> AnimMetaData
        Returns the first metadata of the specified class
        
        Args:
            meta_data_class (type(Class)): 
        
        Returns:
            AnimMetaData:
        """
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...
    def get_skeleton(self) -> Skeleton:
        r"""
        x.get_skeleton() -> Skeleton
        
        
        Returns:
            Skeleton: The target USkeleton for the provided UAnimationAsset
        """
        ...
    def create_attribute_identifier(self, attribute_name: Name, bone_name: Name, attribute_type: ScriptStruct, validate_exists_on_asset: bool = False) -> AnimationAttributeIdentifier:
        r"""
        x.create_attribute_identifier(attribute_name, bone_name, attribute_type, validate_exists_on_asset=False) -> AnimationAttributeIdentifier
        Constructs a valid FAnimationAttributeIdentifier instance. Ensuring that the underlying BoneName exists on the Skeleton for the provided AnimationAsset.
        
        Args:
            attribute_name (Name): Name of the attribute
            bone_name (Name): Name of the bone this attribute should be attributed to
            attribute_type (ScriptStruct): Type of the underlying data (to-be) stored by this attribute
            validate_exists_on_asset (bool): Whether or not the attribute should exist on the AnimationAsset. False by default.
        
        Returns:
            AnimationAttributeIdentifier: Valid FAnimationCurveIdentifier if the operation was successful
        """
        ...

class AnimSequenceBase(AnimationAsset):
    r"""
    Anim Sequence Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimSequenceBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``controller`` (AnimationDataController):  [Read-Only] UAnimDataController instance set to operate on DataModel
    - ``data_model`` (AnimDataModel):  [Read-Only]
    - ``data_model_interface`` (AnimationDataModel):  [Read-Only] IAnimationDataModel instance containing (source) animation data
    - ``loop`` (bool):  [Read-Write] The default looping behavior of this animation.
      Asset players can override this
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``rate_scale`` (float):  [Read-Write] Number for tweaking playback rate of this animation globally.
    - ``sequence_length`` (float):  [Read-Only]
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    @property
    def sequence_length(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def data_model(self) -> AnimDataModel:
        r"""
        (AnimDataModel):  [Read-Only]
        """
        ...
    @property
    def data_model_interface(self) -> AnimationDataModel:
        r"""
        (AnimationDataModel):  [Read-Only] IAnimationDataModel instance containing (source) animation data
        """
        ...
    @property
    def controller(self) -> AnimationDataController:
        r"""
        (AnimationDataController):  [Read-Only] UAnimDataController instance set to operate on DataModel
        """
        ...
    def get_anim_pose_at_time(self, time: float, evaluation_options: AnimPoseEvaluationOptions) -> AnimPose:
        r"""
        x.get_anim_pose_at_time(time, evaluation_options) -> AnimPose
        Evaluates an Animation Sequence Base to generate a valid Anim Pose instance
        
        Args:
            time (double): Time at which the pose should be evaluated
            evaluation_options (AnimPoseEvaluationOptions): Options determining the way the pose should be evaluated
        
        Returns:
            AnimPose: 
        
            pose (AnimPose): Anim Pose to hold the evaluated data
        """
        ...
    def get_anim_pose_at_frame(self, frame_index: int, evaluation_options: AnimPoseEvaluationOptions) -> AnimPose:
        r"""
        x.get_anim_pose_at_frame(frame_index, evaluation_options) -> AnimPose
        Evaluates an Animation Sequence Base to generate a valid Anim Pose instance
        
        Args:
            frame_index (int32): Exact frame at which the pose should be evaluated
            evaluation_options (AnimPoseEvaluationOptions): Options determining the way the pose should be evaluated
        
        Returns:
            AnimPose: 
        
            pose (AnimPose): Anim Pose to hold the evaluated data
        """
        ...
    def add_transform_attribute(self, attribute_name: Name, bone_name: Name, keys: Array[float], values: Array[Transform]) -> bool:
        r"""
        x.add_transform_attribute(attribute_name, bone_name, keys, values) -> bool
        Add Transform Attribute
        
        Args:
            attribute_name (Name): 
            bone_name (Name): 
            keys (Array[float]): 
            values (Array[Transform]): 
        
        Returns:
            bool:
        """
        ...

class AnimPoseExtensions(BlueprintFunctionLibrary):
    r"""
    Script exposed functionality for populating, retrieving data from and setting data on FAnimPose
    
    **C++ Source:**
    
    - **Module**: AnimationBlueprintLibrary
    - **File**: AnimPose.h
    
    """
    @classmethod
    def set_bone_pose(cls, pose: AnimPose, transform: Transform, bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> AnimPose:
        r"""
        X.set_bone_pose(pose, transform, bone_name, space=AnimPoseSpaces.LOCAL) -> AnimPose
        Sets the transform for the provided bone name for a pose
        
        Args:
            pose (AnimPose): Anim Pose to set transform in
            transform (Transform): Transform to set the bone to
            bone_name (Name): Name of the bone to set
            space (AnimPoseSpaces): Space in which the transform should be set
        
        Returns:
            AnimPose: 
        
            pose (AnimPose): Anim Pose to set transform in
        """
        ...
    @classmethod
    def is_valid(cls, pose: AnimPose) -> bool:
        r"""
        X.is_valid(pose) -> bool
        Returns whether the Anim Pose contains valid data
        
        Args:
            pose (AnimPose): Anim Pose to validate
        
        Returns:
            bool: Result of the validation
        """
        ...
    @classmethod
    def get_socket_pose(cls, pose: AnimPose, socket_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        X.get_socket_pose(pose, socket_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the transform for the provided socket name from a pose
        
        Args:
            pose (AnimPose): Anim Pose to retrieve the transform from
            socket_name (Name): Name of the socket to retrieve
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    @classmethod
    def get_socket_names(cls, pose: AnimPose) -> Array[Name]:
        r"""
        X.get_socket_names(pose) -> Array[Name]
        Returns an array of socket names contained by the pose
        
        Args:
            pose (AnimPose): Anim Pose to retrieve the names from
        
        Returns:
            Array[Name]: 
        
            sockets (Array[Name]): Array to be populated with the socket names
        """
        ...
    @classmethod
    def get_relative_transform(cls, pose: AnimPose, from_bone_name: Name, to_bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        X.get_relative_transform(pose, from_bone_name, to_bone_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the relative transform between the two provided bone names
        
        Args:
            pose (AnimPose): Anim Pose to retrieve the transform from
            from_bone_name (Name): Name of the bone to retrieve the transform relative from
            to_bone_name (Name): Name of the bone to retrieve the transform relative to
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Relative transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    @classmethod
    def get_relative_to_ref_pose_transform(cls, pose: AnimPose, bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        X.get_relative_to_ref_pose_transform(pose, bone_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the relative transform between reference and animated bone transform
        
        Args:
            pose (AnimPose): Anim Pose to retrieve the transform from
            bone_name (Name): Name of the bone to retrieve the relative transform for
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Relative transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    @classmethod
    def get_ref_pose_relative_transform(cls, pose: AnimPose, from_bone_name: Name, to_bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        X.get_ref_pose_relative_transform(pose, from_bone_name, to_bone_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the relative transform for the reference pose between the two provided bone names
        
        Args:
            pose (AnimPose): Anim Pose to retrieve the transform from
            from_bone_name (Name): Name of the bone to retrieve the transform relative from
            to_bone_name (Name): Name of the bone to retrieve the transform relative to
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Relative transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    @classmethod
    def get_reference_pose(cls, skeleton: Skeleton) -> AnimPose:
        r"""
        X.get_reference_pose(skeleton) -> AnimPose
        Populates an Anim Pose with the reference poses stored for the provided USkeleton
        
        Args:
            skeleton (Skeleton): USkeleton object to retrieve the reference pose from
        
        Returns:
            AnimPose: 
        
            out_pose (AnimPose): Anim pose to hold the reference pose
        """
        ...
    @classmethod
    def get_ref_bone_pose(cls, pose: AnimPose, bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        X.get_ref_bone_pose(pose, bone_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the reference pose transform for the provided bone name
        
        Args:
            pose (AnimPose): Anim Pose to retrieve the transform from
            bone_name (Name): Name of the bone to retrieve
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    @classmethod
    def get_curve_weight(cls, pose: AnimPose, curve_name: Name) -> float:
        r"""
        X.get_curve_weight(pose, curve_name) -> float
        Returns the weight of an evaluated curve - if found
        
        Args:
            pose (AnimPose): Anim Pose to retrieve the value from
            curve_name (Name): Curve to retrieve the weight value for
        
        Returns:
            float: Curve weight value, if found - 0.f otherwise
        """
        ...
    @classmethod
    def get_curve_names(cls, pose: AnimPose) -> Array[Name]:
        r"""
        X.get_curve_names(pose) -> Array[Name]
        Returns an array of curve names contained by the pose
        
        Args:
            pose (AnimPose): Anim Pose to retrieve the names from
        
        Returns:
            Array[Name]: 
        
            curves (Array[Name]): Array to be populated with the curve names
        """
        ...
    @classmethod
    def get_bone_pose(cls, pose: AnimPose, bone_name: Name, space: AnimPoseSpaces = AnimPoseSpaces.LOCAL) -> Transform:
        r"""
        X.get_bone_pose(pose, bone_name, space=AnimPoseSpaces.LOCAL) -> Transform
        Retrieves the transform for the provided bone name from a pose
        
        Args:
            pose (AnimPose): Anim Pose to retrieve the transform from
            bone_name (Name): Name of the bone to retrieve
            space (AnimPoseSpaces): Space in which the transform should be retrieved
        
        Returns:
            Transform: Transform in requested space for bone if found, otherwise return identity transform
        """
        ...
    @classmethod
    def get_bone_names(cls, pose: AnimPose) -> Array[Name]:
        r"""
        X.get_bone_names(pose) -> Array[Name]
        Returns an array of bone names contained by the pose
        
        Args:
            pose (AnimPose): Anim Pose to retrieve the names from
        
        Returns:
            Array[Name]: 
        
            bones (Array[Name]): Array to be populated with the bone names
        """
        ...
    @classmethod
    def get_anim_pose_at_time(cls, animation_sequence_base: AnimSequenceBase, time: float, evaluation_options: AnimPoseEvaluationOptions) -> AnimPose:
        r"""
        X.get_anim_pose_at_time(animation_sequence_base, time, evaluation_options) -> AnimPose
        Evaluates an Animation Sequence Base to generate a valid Anim Pose instance
        
        Args:
            animation_sequence_base (AnimSequenceBase): Animation sequence base to evaluate the pose from
            time (double): Time at which the pose should be evaluated
            evaluation_options (AnimPoseEvaluationOptions): Options determining the way the pose should be evaluated
        
        Returns:
            AnimPose: 
        
            pose (AnimPose): Anim Pose to hold the evaluated data
        """
        ...
    @classmethod
    def get_anim_pose_at_frame(cls, animation_sequence_base: AnimSequenceBase, frame_index: int, evaluation_options: AnimPoseEvaluationOptions) -> AnimPose:
        r"""
        X.get_anim_pose_at_frame(animation_sequence_base, frame_index, evaluation_options) -> AnimPose
        Evaluates an Animation Sequence Base to generate a valid Anim Pose instance
        
        Args:
            animation_sequence_base (AnimSequenceBase): Animation sequence base to evaluate the pose from
            frame_index (int32): Exact frame at which the pose should be evaluated
            evaluation_options (AnimPoseEvaluationOptions): Options determining the way the pose should be evaluated
        
        Returns:
            AnimPose: 
        
            pose (AnimPose): Anim Pose to hold the evaluated data
        """
        ...
    @classmethod
    def evaluate_animation_blueprint_with_input_pose(cls, input_pose: AnimPose, target_skeletal_mesh: SkeletalMesh, animation_blueprint: AnimBlueprint) -> AnimPose:
        r"""
        X.evaluate_animation_blueprint_with_input_pose(input_pose, target_skeletal_mesh, animation_blueprint) -> AnimPose
        Evaluates an Animation Blueprint instance, using the provided Anim Pose and its Input Pose value, generating a valid Anim Pose using the result. Warning this function may cause performance issues.
        
        Args:
            input_pose (AnimPose): Anim Pose used to populate the input pose node value inside of the Animation Blueprint
            target_skeletal_mesh (SkeletalMesh): USkeletalMesh object used as the target skeletal mesh, should have same USkeleton as InputPose and Animation Blueprint
            animation_blueprint (AnimBlueprint): Animation Blueprint to generate an AnimInstance with, used to evaluate the output Anim Pose
        
        Returns:
            AnimPose: 
        
            out_pose (AnimPose): Anim pose to hold the data from evaluating the Animation Blueprint instance
        """
        ...

class AnimNodeRigidBodyLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on a rigid body anim node
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNode_RigidBody_Library.h
    
    """
    @classmethod
    def set_override_physics_asset(cls, node: RigidBodyAnimNodeReference, physics_asset: PhysicsAsset) -> RigidBodyAnimNodeReference:
        r"""
        X.set_override_physics_asset(node, physics_asset) -> RigidBodyAnimNodeReference
        Set the physics asset on the rigid body anim graph node (RBAN).
        
        Args:
            node (RigidBodyAnimNodeReference): 
            physics_asset (PhysicsAsset): 
        
        Returns:
            RigidBodyAnimNodeReference:
        """
        ...
    @classmethod
    def convert_to_rigid_body_anim_node_pure(cls, node: AnimNodeReference) -> Tuple[RigidBodyAnimNodeReference, bool]:
        r"""
        X.convert_to_rigid_body_anim_node_pure(node) -> (rigid_body_anim_node=RigidBodyAnimNodeReference, result=bool)
        Get a rigid body anim node context from an anim node context (pure)
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            rigid_body_anim_node (RigidBodyAnimNodeReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_rigid_body_anim_node(cls, node: AnimNodeReference) -> Tuple[RigidBodyAnimNodeReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_rigid_body_anim_node(node) -> (RigidBodyAnimNodeReference, result=AnimNodeReferenceConversionResult)
        Get a rigid body anim node context from an anim node context
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...

class BlendSpaceLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on a blend space anim node.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: BlendSpaceLibrary.h
    
    """
    @classmethod
    def snap_to_position(cls, blend_space: BlendSpaceReference, new_position: Vector) -> None:
        r"""
        X.snap_to_position(blend_space, new_position) -> None
        Forces the Position to the specified value
        
        Args:
            blend_space (BlendSpaceReference): 
            new_position (Vector):
        """
        ...
    @classmethod
    def get_position(cls, blend_space: BlendSpaceReference) -> Vector:
        r"""
        X.get_position(blend_space) -> Vector
        Get the current position of the blend space.
        
        Args:
            blend_space (BlendSpaceReference): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_filtered_position(cls, blend_space: BlendSpaceReference) -> Vector:
        r"""
        X.get_filtered_position(blend_space) -> Vector
        Get the current sample coordinates after going through the filtering.
        
        Args:
            blend_space (BlendSpaceReference): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def convert_to_blend_space_pure(cls, node: AnimNodeReference) -> Tuple[BlendSpaceReference, bool]:
        r"""
        X.convert_to_blend_space_pure(node) -> (blend_space=BlendSpaceReference, result=bool)
        Get a blend space context from an anim node context (pure).
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            blend_space (BlendSpaceReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_blend_space(cls, node: AnimNodeReference) -> Tuple[BlendSpaceReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_blend_space(node) -> (BlendSpaceReference, result=AnimNodeReferenceConversionResult)
        Get a blend space context from an anim node context.
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...

class SequencerAnimationOverride(Interface):
    r"""
    Sequencer Animation Override
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: SequencerAnimationOverride.h
    
    """
    def get_sequencer_anim_slot_names(self) -> Array[Name]:
        r"""
        x.get_sequencer_anim_slot_names() -> Array[Name]
        Should return a list of valid slot names for Sequencer to output to in the case that Sequencer is not permitted to nuke the anim instance.
        Will be chosen by the user in drop down on the skeletal animation section properties. Should be named descriptively, as in some contexts (UEFN), the user
        will not be able to view the animation blueprint itself to determine the mixing behavior of the slot.
        
        Returns:
            Array[Name]:
        """
        ...
    def allows_cinematic_override(self) -> bool:
        r"""
        x.allows_cinematic_override() -> bool
        Whether this animation blueprint allows Sequencer to nuke this anim instance and replace it during Sequencer playback.
        
        Returns:
            bool:
        """
        ...

class AnimationStateMachineLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on anim state machine node contexts
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimationStateMachineLibrary.h
    
    """
    @classmethod
    def set_state(cls, update_context: AnimUpdateContext, node: AnimationStateMachineReference, target_state: Name, duration: float, blend_type: TransitionLogicType, blend_profile: BlendProfile, alpha_blend_option: AlphaBlendOption, custom_blend_curve: CurveFloat) -> None:
        r"""
        X.set_state(update_context, node, target_state, duration, blend_type, blend_profile, alpha_blend_option, custom_blend_curve) -> None
        Manually set the current state of the state machine
                      NOTE: Custom blend type is not supported
        
        Args:
            update_context (AnimUpdateContext): 
            node (AnimationStateMachineReference): 
            target_state (Name): 
            duration (float): 
            blend_type (TransitionLogicType): 
            blend_profile (BlendProfile): 
            alpha_blend_option (AlphaBlendOption): 
            custom_blend_curve (CurveFloat):
        """
        ...
    @classmethod
    def is_state_blending_out(cls, update_context: AnimUpdateContext, node: AnimationStateResultReference) -> bool:
        r"""
        X.is_state_blending_out(update_context, node) -> bool
        Returns whether the state the node belongs to is blending out
        
        Args:
            update_context (AnimUpdateContext): 
            node (AnimationStateResultReference): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_state_blending_in(cls, update_context: AnimUpdateContext, node: AnimationStateResultReference) -> bool:
        r"""
        X.is_state_blending_in(update_context, node) -> bool
        Returns whether the state the node belongs to is blending in
        
        Args:
            update_context (AnimUpdateContext): 
            node (AnimationStateResultReference): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_state(cls, update_context: AnimUpdateContext, node: AnimationStateMachineReference) -> Name:
        r"""
        X.get_state(update_context, node) -> Name
        Returns the name of the current state of this state machine
        
        Args:
            update_context (AnimUpdateContext): 
            node (AnimationStateMachineReference): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def get_relevant_anim_time_remaining_fraction(cls, update_context: AnimUpdateContext, node: AnimationStateResultReference) -> float:
        r"""
        X.get_relevant_anim_time_remaining_fraction(update_context, node) -> float
        Returns the remaining animation time as a fraction of the duration for the state's most relevant asset player
        
        Args:
            update_context (AnimUpdateContext): 
            node (AnimationStateResultReference): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_relevant_anim_time_remaining(cls, update_context: AnimUpdateContext, node: AnimationStateResultReference) -> float:
        r"""
        X.get_relevant_anim_time_remaining(update_context, node) -> float
        Returns the remaining animation time of the state's most relevant asset player
        
        Args:
            update_context (AnimUpdateContext): 
            node (AnimationStateResultReference): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def convert_to_animation_state_result_pure(cls, node: AnimNodeReference) -> Tuple[AnimationStateResultReference, bool]:
        r"""
        X.convert_to_animation_state_result_pure(node) -> (animation_state=AnimationStateResultReference, result=bool)
        Get an anim state reference from an anim node reference (pure)
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            animation_state (AnimationStateResultReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_animation_state_result(cls, node: AnimNodeReference) -> Tuple[AnimationStateResultReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_animation_state_result(node) -> (animation_state=AnimationStateResultReference, result=AnimNodeReferenceConversionResult)
        Get an anim state reference from an anim node reference
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            animation_state (AnimationStateResultReference): 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...
    @classmethod
    def convert_to_animation_state_machine_pure(cls, node: AnimNodeReference) -> Tuple[AnimationStateMachineReference, bool]:
        r"""
        X.convert_to_animation_state_machine_pure(node) -> (animation_state=AnimationStateMachineReference, result=bool)
        Get an anim state machine from an anim node reference (pure)
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            animation_state (AnimationStateMachineReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_animation_state_machine(cls, node: AnimNodeReference) -> Tuple[AnimationStateMachineReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_animation_state_machine(node) -> (animation_state=AnimationStateMachineReference, result=AnimNodeReferenceConversionResult)
        Get an anim state machine from an anim node reference
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            animation_state (AnimationStateMachineReference): 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...

class AnimExecutionContextLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on anim node contexts
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimExecutionContextLibrary.h
    
    """
    @classmethod
    def is_active(cls, context: AnimExecutionContext) -> bool:
        r"""
        X.is_active(context) -> bool
        Get whether this branch of the graph is active (i.e. NOT blending out).
        
        Args:
            context (AnimExecutionContext): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_delta_time(cls, context: AnimUpdateContext) -> float:
        r"""
        X.get_delta_time(context) -> float
        Get the current delta time in seconds
        
        Args:
            context (AnimUpdateContext): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_current_weight(cls, context: AnimUpdateContext) -> float:
        r"""
        X.get_current_weight(context) -> float
        Get the current weight of this branch of the graph
        
        Args:
            context (AnimUpdateContext): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_anim_instance(cls, context: AnimExecutionContext) -> AnimInstance:
        r"""
        X.get_anim_instance(context) -> AnimInstance
        Get the anim instance that hosts this context
        
        Args:
            context (AnimExecutionContext): 
        
        Returns:
            AnimInstance:
        """
        ...
    @classmethod
    def convert_to_update_context(cls, context: AnimExecutionContext) -> Tuple[AnimUpdateContext, AnimExecutionContextConversionResult]:
        r"""
        X.convert_to_update_context(context) -> (AnimUpdateContext, result=AnimExecutionContextConversionResult)
        Convert to an update context
        
        Args:
            context (AnimExecutionContext): 
        
        Returns:
            AnimExecutionContextConversionResult: 
        
            result (AnimExecutionContextConversionResult):
        """
        ...
    @classmethod
    def convert_to_pose_context(cls, context: AnimExecutionContext) -> Tuple[AnimPoseContext, AnimExecutionContextConversionResult]:
        r"""
        X.convert_to_pose_context(context) -> (AnimPoseContext, result=AnimExecutionContextConversionResult)
        Convert to a pose context
        
        Args:
            context (AnimExecutionContext): 
        
        Returns:
            AnimExecutionContextConversionResult: 
        
            result (AnimExecutionContextConversionResult):
        """
        ...
    @classmethod
    def convert_to_initialization_context(cls, context: AnimExecutionContext) -> Tuple[AnimInitializationContext, AnimExecutionContextConversionResult]:
        r"""
        X.convert_to_initialization_context(context) -> (AnimInitializationContext, result=AnimExecutionContextConversionResult)
        Convert to an initialization context
        
        Args:
            context (AnimExecutionContext): 
        
        Returns:
            AnimExecutionContextConversionResult: 
        
            result (AnimExecutionContextConversionResult):
        """
        ...
    @classmethod
    def convert_to_component_space_pose_context(cls, context: AnimExecutionContext) -> Tuple[AnimComponentSpacePoseContext, AnimExecutionContextConversionResult]:
        r"""
        X.convert_to_component_space_pose_context(context) -> (AnimComponentSpacePoseContext, result=AnimExecutionContextConversionResult)
        Convert to a component space pose context
        
        Args:
            context (AnimExecutionContext): 
        
        Returns:
            AnimExecutionContextConversionResult: 
        
            result (AnimExecutionContextConversionResult):
        """
        ...

class AnimNotify(Object):
    r"""
    Anim Notify
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotify.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify instance should fire in animation editors
    """
    @property
    def notify_color(self) -> Color:
        r"""
        (Color):  [Read-Only] Color of Notify in editor
        """
        ...
    @property
    def should_fire_in_editor(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether this notify instance should fire in animation editors
        """
        ...
    def received_notify(self, mesh_comp: SkeletalMeshComponent, animation: AnimSequenceBase, event_reference: AnimNotifyEventReference) -> bool:
        r"""
        x.received_notify(mesh_comp, animation, event_reference) -> bool
        Received Notify
        
        Args:
            mesh_comp (SkeletalMeshComponent): 
            animation (AnimSequenceBase): 
            event_reference (AnimNotifyEventReference): 
        
        Returns:
            bool:
        """
        ...
    def get_notify_name(self) -> str:
        r"""
        x.get_notify_name() -> str
        Implementable event to get a custom name for the notify
        
        Returns:
            str:
        """
        ...
    def get_default_trigger_weight_threshold(self) -> float:
        r"""
        x.get_default_trigger_weight_threshold() -> float
        TriggerWeightThreshold to use when creating notifies of this type
        
        Returns:
            float:
        """
        ...

class AnimNotify_PlayMontageNotify(AnimNotify):
    r"""
    UAnimNotify_PlayMontageNotify
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNotify_PlayMontageNotify.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``notify_name`` (Name):  [Read-Write] Name of notify that is passed to the PlayMontage K2Node.
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify instance should fire in animation editors
    """
    @property
    def notify_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of notify that is passed to the PlayMontage K2Node.
        """
        ...

class AnimNotifyState(Object):
    r"""
    Anim Notify State
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotifyState.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify state instance should fire in animation editors
    """
    @property
    def notify_color(self) -> Color:
        r"""
        (Color):  [Read-Only] Color of Notify in editor
        """
        ...
    @property
    def should_fire_in_editor(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether this notify state instance should fire in animation editors
        """
        ...
    def received_notify_tick(self, mesh_comp: SkeletalMeshComponent, animation: AnimSequenceBase, frame_delta_time: float, event_reference: AnimNotifyEventReference) -> bool:
        r"""
        x.received_notify_tick(mesh_comp, animation, frame_delta_time, event_reference) -> bool
        Received Notify Tick
        
        Args:
            mesh_comp (SkeletalMeshComponent): 
            animation (AnimSequenceBase): 
            frame_delta_time (float): 
            event_reference (AnimNotifyEventReference): 
        
        Returns:
            bool:
        """
        ...
    def received_notify_end(self, mesh_comp: SkeletalMeshComponent, animation: AnimSequenceBase, event_reference: AnimNotifyEventReference) -> bool:
        r"""
        x.received_notify_end(mesh_comp, animation, event_reference) -> bool
        Received Notify End
        
        Args:
            mesh_comp (SkeletalMeshComponent): 
            animation (AnimSequenceBase): 
            event_reference (AnimNotifyEventReference): 
        
        Returns:
            bool:
        """
        ...
    def received_notify_begin(self, mesh_comp: SkeletalMeshComponent, animation: AnimSequenceBase, total_duration: float, event_reference: AnimNotifyEventReference) -> bool:
        r"""
        x.received_notify_begin(mesh_comp, animation, total_duration, event_reference) -> bool
        Received Notify Begin
        
        Args:
            mesh_comp (SkeletalMeshComponent): 
            animation (AnimSequenceBase): 
            total_duration (float): 
            event_reference (AnimNotifyEventReference): 
        
        Returns:
            bool:
        """
        ...
    def get_notify_name(self) -> str:
        r"""
        x.get_notify_name() -> str
        Implementable event to get a custom name for the notify
        
        Returns:
            str:
        """
        ...
    def get_default_trigger_weight_threshold(self) -> float:
        r"""
        x.get_default_trigger_weight_threshold() -> float
        TriggerWeightThreshold to use when creating notifies of this type
        
        Returns:
            float:
        """
        ...

class AnimNotify_PlayMontageNotifyWindow(AnimNotifyState):
    r"""
    UAnimNotify_PlayMontageNotifyWindow
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimNotify_PlayMontageNotify.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``notify_name`` (Name):  [Read-Write] Name of notify that is passed to ability.
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify state instance should fire in animation editors
    """
    @property
    def notify_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of notify that is passed to ability.
        """
        ...

class AnimSequencerInstance(AnimInstance):
    r"""
    Anim Sequencer Instance
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: AnimSequencerInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    ...

class BlendListBaseLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on anim state machine node contexts
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: BlendListBaseLibrary.h
    
    """
    @classmethod
    def reset_node(cls, blend_list_base: BlendListBaseReference) -> None:
        r"""
        X.reset_node(blend_list_base) -> None
        Reset target blend list node to that the next blend is executed from a blank state
        
        Args:
            blend_list_base (BlendListBaseReference):
        """
        ...
    @classmethod
    def convert_to_blend_list_base(cls, node: AnimNodeReference) -> Tuple[BlendListBaseReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_blend_list_base(node) -> (BlendListBaseReference, result=AnimNodeReferenceConversionResult)
        Get a blend list base context from an anim node context.
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...

class BlendSpacePlayerLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on a blend space player anim node.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: BlendSpacePlayerLibrary.h
    
    """
    @classmethod
    def snap_to_position(cls, blend_space_player: BlendSpacePlayerReference, new_position: Vector) -> None:
        r"""
        X.snap_to_position(blend_space_player, new_position) -> None
        Forces the Position to the specified value
        
        Args:
            blend_space_player (BlendSpacePlayerReference): 
            new_position (Vector):
        """
        ...
    @classmethod
    def should_reset_play_time_when_blend_space_changes(cls, blend_space_player: BlendSpacePlayerReference) -> bool:
        r"""
        X.should_reset_play_time_when_blend_space_changes(blend_space_player) -> bool
        Get the current value of whether the current play time should reset when BlendSpace changes of the blend space player.
        
        Args:
            blend_space_player (BlendSpacePlayerReference): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_reset_play_time_when_blend_space_changes(cls, blend_space_player: BlendSpacePlayerReference, reset: bool) -> BlendSpacePlayerReference:
        r"""
        X.set_reset_play_time_when_blend_space_changes(blend_space_player, reset) -> BlendSpacePlayerReference
        Set whether the current play time should reset when BlendSpace changes of the blend space player.
        
        Args:
            blend_space_player (BlendSpacePlayerReference): 
            reset (bool): 
        
        Returns:
            BlendSpacePlayerReference:
        """
        ...
    @classmethod
    def set_play_rate(cls, blend_space_player: BlendSpacePlayerReference, play_rate: float) -> BlendSpacePlayerReference:
        r"""
        X.set_play_rate(blend_space_player, play_rate) -> BlendSpacePlayerReference
        Set the play rate of the blend space player.
        
        Args:
            blend_space_player (BlendSpacePlayerReference): 
            play_rate (float): 
        
        Returns:
            BlendSpacePlayerReference:
        """
        ...
    @classmethod
    def set_loop(cls, blend_space_player: BlendSpacePlayerReference, loop: bool) -> BlendSpacePlayerReference:
        r"""
        X.set_loop(blend_space_player, loop) -> BlendSpacePlayerReference
        Set the loop of the blend space player.
        
        Args:
            blend_space_player (BlendSpacePlayerReference): 
            loop (bool): 
        
        Returns:
            BlendSpacePlayerReference:
        """
        ...
    @classmethod
    def set_blend_space_with_inertial_blending(cls, update_context: AnimUpdateContext, blend_space_player: BlendSpacePlayerReference, blend_space: BlendSpace, blend_time: float = 0.200000) -> BlendSpacePlayerReference:
        r"""
        X.set_blend_space_with_inertial_blending(update_context, blend_space_player, blend_space, blend_time=0.200000) -> BlendSpacePlayerReference
        Set the current BlendSpace of the blend space player with an interial blend time.
        
        Args:
            update_context (AnimUpdateContext): 
            blend_space_player (BlendSpacePlayerReference): 
            blend_space (BlendSpace): 
            blend_time (float): 
        
        Returns:
            BlendSpacePlayerReference:
        """
        ...
    @classmethod
    def set_blend_space(cls, blend_space_player: BlendSpacePlayerReference, blend_space: BlendSpace) -> BlendSpacePlayerReference:
        r"""
        X.set_blend_space(blend_space_player, blend_space) -> BlendSpacePlayerReference
        Set the current BlendSpace of the blend space player.
        
        Args:
            blend_space_player (BlendSpacePlayerReference): 
            blend_space (BlendSpace): 
        
        Returns:
            BlendSpacePlayerReference:
        """
        ...
    @classmethod
    def get_start_position(cls, blend_space_player: BlendSpacePlayerReference) -> float:
        r"""
        X.get_start_position(blend_space_player) -> float
        Get the current start position of the blend space player.
        
        Args:
            blend_space_player (BlendSpacePlayerReference): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_position(cls, blend_space_player: BlendSpacePlayerReference) -> Vector:
        r"""
        X.get_position(blend_space_player) -> Vector
        Get the current position of the blend space player.
        
        Args:
            blend_space_player (BlendSpacePlayerReference): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_play_rate(cls, blend_space_player: BlendSpacePlayerReference) -> float:
        r"""
        X.get_play_rate(blend_space_player) -> float
        Get the current play rate of the blend space player.
        
        Args:
            blend_space_player (BlendSpacePlayerReference): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_loop(cls, blend_space_player: BlendSpacePlayerReference) -> bool:
        r"""
        X.get_loop(blend_space_player) -> bool
        Get the current loop of the blend space player.
        
        Args:
            blend_space_player (BlendSpacePlayerReference): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_blend_space(cls, blend_space_player: BlendSpacePlayerReference) -> BlendSpace:
        r"""
        X.get_blend_space(blend_space_player) -> BlendSpace
        Get the current BlendSpace of the blend space player.
        
        Args:
            blend_space_player (BlendSpacePlayerReference): 
        
        Returns:
            BlendSpace:
        """
        ...
    @classmethod
    def convert_to_blend_space_player_pure(cls, node: AnimNodeReference) -> Tuple[BlendSpacePlayerReference, bool]:
        r"""
        X.convert_to_blend_space_player_pure(node) -> (blend_space_player=BlendSpacePlayerReference, result=bool)
        Get a blend space player context from an anim node context (pure).
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            blend_space_player (BlendSpacePlayerReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_blend_space_player(cls, node: AnimNodeReference) -> Tuple[BlendSpacePlayerReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_blend_space_player(node) -> (BlendSpacePlayerReference, result=AnimNodeReferenceConversionResult)
        Get a blend space player context from an anim node context.
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...

class AnimGraphLibrary(BlueprintFunctionLibrary):
    r"""
    A library of the most common animation blueprint functions.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: KismetAnimationLibrary.h
    
    """
    @classmethod
    def two_bone_ik(cls, root_pos: Vector, joint_pos: Vector, end_pos: Vector, joint_target: Vector, effector: Vector, allow_stretching: bool = False, start_stretch_ratio: float = 1.000000, max_stretch_scale: float = 1.200000) -> Tuple[Vector, Vector]:
        r"""
        X.two_bone_ik(root_pos, joint_pos, end_pos, joint_target, effector, allow_stretching=False, start_stretch_ratio=1.000000, max_stretch_scale=1.200000) -> (out_joint_pos=Vector, out_end_pos=Vector)
        Computes the transform for two bones using inverse kinematics.
        
        Args:
            root_pos (Vector): The input root position of the two bone chain
            joint_pos (Vector): The input center (elbow) position of the two bone chain
            end_pos (Vector): The input end (wrist) position of the two bone chain
            joint_target (Vector): The IK target for the write to reach
            effector (Vector): The position of the target effector for the IK Chain.
            allow_stretching (bool): If set to true the bones are allowed to stretch
            start_stretch_ratio (float): The ratio at which the bones should start to stretch. The higher the value, the later the stretching wil start.
            max_stretch_scale (float): The maximum multiplier for the stretch to reach.
        
        Returns:
            tuple: 
        
            out_joint_pos (Vector): The resulting position for the center (elbow)
        
            out_end_pos (Vector): The resulting position for the end (wrist)
        """
        ...
    @classmethod
    def k2_start_profiling_timer(cls) -> None:
        r"""
        X.k2_start_profiling_timer() -> None
        This function starts measuring the time for a profiling bracket
        """
        ...
    @classmethod
    def make_vector_from_perlin_noise(cls, x: float, y: float, z: float, range_out_min_x: float = -1.000000, range_out_max_x: float = 1.000000, range_out_min_y: float = -1.000000, range_out_max_y: float = 1.000000, range_out_min_z: float = -1.000000, range_out_max_z: float = 1.000000) -> Vector:
        r"""
        X.make_vector_from_perlin_noise(x, y, z, range_out_min_x=-1.000000, range_out_max_x=1.000000, range_out_min_y=-1.000000, range_out_max_y=1.000000, range_out_min_z=-1.000000, range_out_max_z=1.000000) -> Vector
        This function creates perlin noise from input X, Y, Z, and then range map to RangeOut, and out put to OutX, OutY, OutZ
        
        Args:
            x (float): The x component for the input position of the noise
            y (float): The y component for the input position of the noise
            z (float): The z component for the input position of the noise
            range_out_min_x (float): The minimum for the output range for the x component
            range_out_max_x (float): The maximum for the output range for the x component
            range_out_min_y (float): The minimum for the output range for the y component
            range_out_max_y (float): The maximum for the output range for the y component
            range_out_min_z (float): The minimum for the output range for the z component
            range_out_max_z (float): The maximum for the output range for the z component
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def make_float_from_perlin_noise(cls, value: float, range_out_min: float, range_out_max: float) -> float:
        r"""
        X.make_float_from_perlin_noise(value, range_out_min, range_out_max) -> float
        This function creates perlin noise for a single float and then range map to RangeOut
        
        Args:
            value (float): The input value for the noise function
            range_out_min (float): The minimum for the output range
            range_out_max (float): The maximum for the output range
        
        Returns:
            float:
        """
        ...
    @classmethod
    def look_at(cls, current_transform: Transform, target_position: Vector, look_at_vector: Vector, use_up_vector: bool = False, up_vector: Vector = ..., clamp_cone_in_degree: float = ...) -> Transform:
        r"""
        X.look_at(current_transform, target_position, look_at_vector, use_up_vector=False, up_vector, clamp_cone_in_degree) -> Transform
        Computes the transform which is "looking" at target position with a local axis.
        
        Args:
            current_transform (Transform): The input transform to modify
            target_position (Vector): The position this transform should look at
            look_at_vector (Vector): The local vector to align with the target
            use_up_vector (bool): If set to true the lookat will also perform a twist rotation
            up_vector (Vector): The position to use for the upvector target (only used is bUseUpVector is turned on)
            clamp_cone_in_degree (float): A limit for only allowing the lookat to rotate as much as defined by the float value
        
        Returns:
            Transform:
        """
        ...
    @classmethod
    def k2_end_profiling_timer(cls, log: bool = True, log_prefix: str = "") -> float:
        r"""
        X.k2_end_profiling_timer(log=True, log_prefix="") -> float
        This function ends measuring a profiling bracket and optionally logs the result
        result: The time spent in milliseconds
        
        Args:
            log (bool): If set to true the result is logged to the OutputLog
            log_prefix (str): A prefix to use for the log
        
        Returns:
            float:
        """
        ...
    @classmethod
    def distance_between_sockets(cls, component: SkeletalMeshComponent, socket_or_bone_name_a: Name, socket_space_a: RelativeTransformSpace, socket_or_bone_name_b: Name, socket_space_b: RelativeTransformSpace, remap_range: bool = False, range_min: float = ..., range_max: float = ..., out_range_min: float = ..., out_range_max: float = ...) -> float:
        r"""
        X.distance_between_sockets(component, socket_or_bone_name_a, socket_space_a, socket_or_bone_name_b, socket_space_b, remap_range=False, range_min, range_max, out_range_min, out_range_max) -> float
        Computes the distance between two bones / sockets and can remap the range.
        
        Args:
            component (SkeletalMeshComponent): The skeletal component to look for the sockets / bones within
            socket_or_bone_name_a (Name): The name of the first socket / bone
            socket_space_a (RelativeTransformSpace): The space for the first socket / bone
            socket_or_bone_name_b (Name): The name of the second socket / bone
            socket_space_b (RelativeTransformSpace): The space for the second socket / bone
            remap_range (bool): If set to true, the distance will be remapped using the range parameters
            range_min (float): The minimum for the input range (commonly == 0.0)
            range_max (float): The maximum for the input range (the max expected distance)
            out_range_min (float): The minimum for the output range (commonly == 0.0)
            out_range_max (float): The maximum for the output range (commonly == 1.0)
        
        Returns:
            float:
        """
        ...
    @classmethod
    def direction_between_sockets(cls, component: SkeletalMeshComponent, socket_or_bone_name_from: Name, socket_or_bone_name_to: Name) -> Vector:
        r"""
        X.direction_between_sockets(component, socket_or_bone_name_from, socket_or_bone_name_to) -> Vector
        Computes the direction between two bones / sockets.
        
        Args:
            component (SkeletalMeshComponent): The skeletal component to look for the sockets / bones within
            socket_or_bone_name_from (Name): The name of the first socket / bone
            socket_or_bone_name_to (Name): The name of the second socket / bone
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def calculate_velocity_from_sockets(cls, delta_seconds: float, component: SkeletalMeshComponent, socket_or_bone_name: Name, reference_socket_or_bone: Name, socket_space: RelativeTransformSpace, offset_in_bone_space: Vector, history: PositionHistory, number_of_samples: int = 16, velocity_min: float = 0.000000, velocity_max: float = 128.000000, easing_type: EasingFuncType = ..., custom_curve: RuntimeFloatCurve = ...) -> Tuple[float, PositionHistory]:
        r"""
        X.calculate_velocity_from_sockets(delta_seconds, component, socket_or_bone_name, reference_socket_or_bone, socket_space, offset_in_bone_space, history, number_of_samples=16, velocity_min=0.000000, velocity_max=128.000000, easing_type, custom_curve) -> (float, history=PositionHistory)
        This function calculates the velocity of an offset position on a bone / socket over time.
        The bone's / socket's motion can be expressed within a reference frame (another bone / socket).
        You need to hook up a valid PositionHistory variable to this for storage.
        
        Args:
            delta_seconds (float): The time passed in seconds
            component (SkeletalMeshComponent): The skeletal component to look for the bones / sockets
            socket_or_bone_name (Name): The name of the bone / socket to track.
            reference_socket_or_bone (Name): The name of the bone / socket to use as a frame of reference (or None if no frame of reference == world space).
            socket_space (RelativeTransformSpace): The space to use for the two sockets / bones
            offset_in_bone_space (Vector): The relative position in the space of the bone / socket to track over time.
            history (PositionHistory): The history to use for storage.
            number_of_samples (int32): The number of samples to use for the history. The higher the number of samples - the smoother the velocity changes.
            velocity_min (float): The minimum velocity to use for normalization (if both min and max are set to 0, normalization is turned off)
            velocity_max (float): The maximum velocity to use for normalization (if both min and max are set to 0, normalization is turned off)
            easing_type (EasingFuncType): The easing function to use
            custom_curve (RuntimeFloatCurve): The curve to use if the easing type is "Custom"
        
        Returns:
            PositionHistory: 
        
            history (PositionHistory): The history to use for storage.
        """
        ...
    @classmethod
    def calculate_velocity_from_position_history(cls, delta_seconds: float, position: Vector, history: PositionHistory, number_of_samples: int = 16, velocity_min: float = 0.000000, velocity_max: float = 128.000000) -> Tuple[float, PositionHistory]:
        r"""
        X.calculate_velocity_from_position_history(delta_seconds, position, history, number_of_samples=16, velocity_min=0.000000, velocity_max=128.000000) -> (float, history=PositionHistory)
        This function calculates the velocity of a position changing over time.
        You need to hook up a valid PositionHistory variable to this for storage.
        
        Args:
            delta_seconds (float): The time passed in seconds
            position (Vector): The position to track over time.
            history (PositionHistory): The history to use for storage.
            number_of_samples (int32): The number of samples to use for the history. The higher the number of samples - the smoother the velocity changes.
            velocity_min (float): The minimum velocity to use for normalization (if both min and max are set to 0, normalization is turned off)
            velocity_max (float): The maximum velocity to use for normalization (if both min and max are set to 0, normalization is turned off)
        
        Returns:
            PositionHistory: 
        
            history (PositionHistory): The history to use for storage.
        """
        ...
    @classmethod
    def calculate_direction(cls, velocity: Vector, base_rotation: Rotator) -> float:
        r"""
        X.calculate_direction(velocity, base_rotation) -> float
        Returns degree of the angle between Velocity and Rotation forward vector
        The range of return will be from [-180, 180]. Useful for feeding directional blendspaces.
        
        Args:
            velocity (Vector): The velocity to use as direction relative to BaseRotation
            base_rotation (Rotator): The base rotation, e.g. of a pawn
        
        Returns:
            float:
        """
        ...

class LayeredBoneBlendLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on a layered bone blend anim node.
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: LayeredBoneBlendLibrary.h
    
    """
    @classmethod
    def set_blend_mask(cls, update_context: AnimUpdateContext, layered_bone_blend: LayeredBoneBlendReference, pose_index: int, blend_mask_name: Name) -> LayeredBoneBlendReference:
        r"""
        X.set_blend_mask(update_context, layered_bone_blend, pose_index, blend_mask_name) -> LayeredBoneBlendReference
        Sets the currently-used blend mask for a blended input pose by name.
        
        Args:
            update_context (AnimUpdateContext): The update context to use. This is used to extract the current skeleton to derive the blend mask from
            layered_bone_blend (LayeredBoneBlendReference): A reference to the node
            pose_index (int32): The pose index to set the blend mask for
            blend_mask_name (Name): The name of the blend mask to use
        
        Returns:
            LayeredBoneBlendReference:
        """
        ...
    @classmethod
    def get_num_poses(cls, layered_bone_blend: LayeredBoneBlendReference) -> int:
        r"""
        X.get_num_poses(layered_bone_blend) -> int32
        Get the number of poses that a layered bone blend node has (this does not include the base pose)
        
        Args:
            layered_bone_blend (LayeredBoneBlendReference): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def convert_to_layered_bone_blend(cls, node: AnimNodeReference) -> Tuple[LayeredBoneBlendReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_layered_bone_blend(node) -> (LayeredBoneBlendReference, result=AnimNodeReferenceConversionResult)
        Get a layered bone blend context from an anim node context.
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...
    @classmethod
    def convert_to_layered_blend_per_bone_pure(cls, node: AnimNodeReference) -> Tuple[LayeredBoneBlendReference, bool]:
        r"""
        X.convert_to_layered_blend_per_bone_pure(node) -> (layered_bone_blend=LayeredBoneBlendReference, result=bool)
        Get a layered bone blend context from an anim node context (pure).
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            layered_bone_blend (LayeredBoneBlendReference): 
        
            result (bool):
        """
        ...

class LinkedAnimGraphLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on anim node contexts
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: LinkedAnimGraphLibrary.h
    
    """
    @classmethod
    def has_linked_anim_instance(cls, node: LinkedAnimGraphReference) -> bool:
        r"""
        X.has_linked_anim_instance(node) -> bool
        Returns whether the node hosts an instance (e.g. linked anim graph or layer)
        
        Args:
            node (LinkedAnimGraphReference): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_linked_anim_instance(cls, node: LinkedAnimGraphReference) -> AnimInstance:
        r"""
        X.get_linked_anim_instance(node) -> AnimInstance
        Get the linked instance is hosted by this node. If the node does not host an instance then HasLinkedAnimInstance will return false
        
        Args:
            node (LinkedAnimGraphReference): 
        
        Returns:
            AnimInstance:
        """
        ...
    @classmethod
    def convert_to_linked_anim_graph_pure(cls, node: AnimNodeReference) -> Tuple[LinkedAnimGraphReference, bool]:
        r"""
        X.convert_to_linked_anim_graph_pure(node) -> (linked_anim_graph=LinkedAnimGraphReference, result=bool)
        Get a linked anim graph reference from an anim node reference (pure)
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            linked_anim_graph (LinkedAnimGraphReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_linked_anim_graph(cls, node: AnimNodeReference) -> Tuple[LinkedAnimGraphReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_linked_anim_graph(node) -> (LinkedAnimGraphReference, result=AnimNodeReferenceConversionResult)
        Get a linked anim graph reference from an anim node reference
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...

class MirrorAnimLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations that can be run on a Mirror node via Anim Node Functions such as "On Become Relevant" and "On Update".
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: MirrorAnimLibrary.h
    
    """
    @classmethod
    def set_mirror_transition_blend_time(cls, mirror_node: MirrorAnimNodeReference, blend_time: float) -> MirrorAnimNodeReference:
        r"""
        X.set_mirror_transition_blend_time(mirror_node, blend_time) -> MirrorAnimNodeReference
        Set how long to blend using inertialization when switching mirrored state
        
        Args:
            mirror_node (MirrorAnimNodeReference): 
            blend_time (float): 
        
        Returns:
            MirrorAnimNodeReference:
        """
        ...
    @classmethod
    def set_mirror(cls, mirror_node: MirrorAnimNodeReference, mirror: bool) -> MirrorAnimNodeReference:
        r"""
        X.set_mirror(mirror_node, mirror) -> MirrorAnimNodeReference
        Set the mirror state
        
        Args:
            mirror_node (MirrorAnimNodeReference): 
            mirror (bool): 
        
        Returns:
            MirrorAnimNodeReference:
        """
        ...
    @classmethod
    def get_mirror_transition_blend_time(cls, mirror_node: MirrorAnimNodeReference) -> float:
        r"""
        X.get_mirror_transition_blend_time(mirror_node) -> float
        Get how long to blend using inertialization when switching mirrored state
        
        Args:
            mirror_node (MirrorAnimNodeReference): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_mirror_data_table(cls, mirror_node: MirrorAnimNodeReference) -> MirrorDataTable:
        r"""
        X.get_mirror_data_table(mirror_node) -> MirrorDataTable
        Get MirrorDataTable used to perform mirroring
        
        Args:
            mirror_node (MirrorAnimNodeReference): 
        
        Returns:
            MirrorDataTable:
        """
        ...
    @classmethod
    def get_mirror(cls, mirror_node: MirrorAnimNodeReference) -> bool:
        r"""
        X.get_mirror(mirror_node) -> bool
        Get the mirror state
        
        Args:
            mirror_node (MirrorAnimNodeReference): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def convert_to_mirror_node_pure(cls, node: AnimNodeReference) -> Tuple[MirrorAnimNodeReference, bool]:
        r"""
        X.convert_to_mirror_node_pure(node) -> (mirror_node=MirrorAnimNodeReference, result=bool)
        Get a mirror context from an anim node context (pure)
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            mirror_node (MirrorAnimNodeReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_mirror_node(cls, node: AnimNodeReference) -> Tuple[MirrorAnimNodeReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_mirror_node(node) -> (MirrorAnimNodeReference, result=AnimNodeReferenceConversionResult)
        Get a mirror node context from an anim node context
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...

class ModifyCurveAnimLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations that can be run on a Modify Curve Node via Anim Node Functions such as "On Become Relevant" and "On Update".
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: ModifyCurveLibrary.h
    
    """
    @classmethod
    def set_curve_map(cls, modify_curve_node: ModifyCurveAnimNodeReference, curve_map: Map[Name, float]) -> ModifyCurveAnimNodeReference:
        r"""
        X.set_curve_map(modify_curve_node, curve_map) -> ModifyCurveAnimNodeReference
        Set Curve Map
        
        Args:
            modify_curve_node (ModifyCurveAnimNodeReference): 
            curve_map (Map[Name, float]): 
        
        Returns:
            ModifyCurveAnimNodeReference:
        """
        ...
    @classmethod
    def set_apply_mode(cls, modify_curve_node: ModifyCurveAnimNodeReference, mode: ModifyCurveApplyMode) -> ModifyCurveAnimNodeReference:
        r"""
        X.set_apply_mode(modify_curve_node, mode) -> ModifyCurveAnimNodeReference
        Set Apply Mode
        
        Args:
            modify_curve_node (ModifyCurveAnimNodeReference): 
            mode (ModifyCurveApplyMode): 
        
        Returns:
            ModifyCurveAnimNodeReference:
        """
        ...
    @classmethod
    def set_alpha(cls, modify_curve_node: ModifyCurveAnimNodeReference, alpha: float) -> ModifyCurveAnimNodeReference:
        r"""
        X.set_alpha(modify_curve_node, alpha) -> ModifyCurveAnimNodeReference
        Set Alpha
        
        Args:
            modify_curve_node (ModifyCurveAnimNodeReference): 
            alpha (float): 
        
        Returns:
            ModifyCurveAnimNodeReference:
        """
        ...
    @classmethod
    def get_apply_mode(cls, modify_curve_node: ModifyCurveAnimNodeReference) -> ModifyCurveApplyMode:
        r"""
        X.get_apply_mode(modify_curve_node) -> ModifyCurveApplyMode
        Get Apply Mode
        
        Args:
            modify_curve_node (ModifyCurveAnimNodeReference): 
        
        Returns:
            ModifyCurveApplyMode:
        """
        ...
    @classmethod
    def get_alpha(cls, modify_curve_node: ModifyCurveAnimNodeReference) -> float:
        r"""
        X.get_alpha(modify_curve_node) -> float
        Get Alpha
        
        Args:
            modify_curve_node (ModifyCurveAnimNodeReference): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def convert_to_modify_curve_node_pure(cls, node: AnimNodeReference) -> Tuple[ModifyCurveAnimNodeReference, bool]:
        r"""
        X.convert_to_modify_curve_node_pure(node) -> (modify_curve_node=ModifyCurveAnimNodeReference, result=bool)
        Get a modify curve context from an anim node context (pure)
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            modify_curve_node (ModifyCurveAnimNodeReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_modify_curve_node(cls, node: AnimNodeReference) -> Tuple[ModifyCurveAnimNodeReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_modify_curve_node(node) -> (ModifyCurveAnimNodeReference, result=AnimNodeReferenceConversionResult)
        Get a modify curve node context from an anim node context
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...

class PlayMontageCallbackProxy(Object):
    r"""
    Play Montage Callback Proxy
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: PlayMontageCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_blend_out`` (OnMontagePlayDelegate):  [Read-Write] Called when Montage starts blending out and is not interrupted
    - ``on_completed`` (OnMontagePlayDelegate):  [Read-Write] Called when Montage finished playing and wasn't interrupted
    - ``on_interrupted`` (OnMontagePlayDelegate):  [Read-Write] Called when Montage has been interrupted (or failed to play)
    - ``on_notify_begin`` (OnMontagePlayDelegate):  [Read-Write]
    - ``on_notify_end`` (OnMontagePlayDelegate):  [Read-Write]
    """
    @property
    def on_completed(self) -> OnMontagePlayDelegate:
        r"""
        (OnMontagePlayDelegate):  [Read-Write] Called when Montage finished playing and wasn't interrupted
        """
        ...
    @on_completed.setter
    def on_completed(self, value: OnMontagePlayDelegate) -> None:
        ...
    @property
    def on_blend_out(self) -> OnMontagePlayDelegate:
        r"""
        (OnMontagePlayDelegate):  [Read-Write] Called when Montage starts blending out and is not interrupted
        """
        ...
    @on_blend_out.setter
    def on_blend_out(self, value: OnMontagePlayDelegate) -> None:
        ...
    @property
    def on_interrupted(self) -> OnMontagePlayDelegate:
        r"""
        (OnMontagePlayDelegate):  [Read-Write] Called when Montage has been interrupted (or failed to play)
        """
        ...
    @on_interrupted.setter
    def on_interrupted(self, value: OnMontagePlayDelegate) -> None:
        ...
    @property
    def on_notify_begin(self) -> OnMontagePlayDelegate:
        r"""
        (OnMontagePlayDelegate):  [Read-Write]
        """
        ...
    @on_notify_begin.setter
    def on_notify_begin(self, value: OnMontagePlayDelegate) -> None:
        ...
    @property
    def on_notify_end(self) -> OnMontagePlayDelegate:
        r"""
        (OnMontagePlayDelegate):  [Read-Write]
        """
        ...
    @on_notify_end.setter
    def on_notify_end(self, value: OnMontagePlayDelegate) -> None:
        ...

class SequenceEvaluatorLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on a sequence evaluator anim node
    Note: Experimental and subject to change!
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: SequenceEvaluatorLibrary.h
    
    """
    @classmethod
    def set_sequence_with_inertial_blending(cls, update_context: AnimUpdateContext, sequence_evaluator: SequenceEvaluatorReference, sequence: AnimSequenceBase, blend_time: float = 0.200000) -> SequenceEvaluatorReference:
        r"""
        X.set_sequence_with_inertial_blending(update_context, sequence_evaluator, sequence, blend_time=0.200000) -> SequenceEvaluatorReference
        Set the current sequence of the sequence evaluator with an inertial blend time
        
        Args:
            update_context (AnimUpdateContext): 
            sequence_evaluator (SequenceEvaluatorReference): 
            sequence (AnimSequenceBase): 
            blend_time (float): 
        
        Returns:
            SequenceEvaluatorReference:
        """
        ...
    @classmethod
    def set_sequence(cls, sequence_evaluator: SequenceEvaluatorReference, sequence: AnimSequenceBase) -> SequenceEvaluatorReference:
        r"""
        X.set_sequence(sequence_evaluator, sequence) -> SequenceEvaluatorReference
        Set the current sequence of the sequence evaluator
        
        Args:
            sequence_evaluator (SequenceEvaluatorReference): 
            sequence (AnimSequenceBase): 
        
        Returns:
            SequenceEvaluatorReference:
        """
        ...
    @classmethod
    def set_explicit_time(cls, sequence_evaluator: SequenceEvaluatorReference, time: float) -> SequenceEvaluatorReference:
        r"""
        X.set_explicit_time(sequence_evaluator, time) -> SequenceEvaluatorReference
        Set the current accumulated time of the sequence evaluator
        
        Args:
            sequence_evaluator (SequenceEvaluatorReference): 
            time (float): 
        
        Returns:
            SequenceEvaluatorReference:
        """
        ...
    @classmethod
    def set_explicit_frame(cls, sequence_evaluator: SequenceEvaluatorReference, frame: int) -> SequenceEvaluatorReference:
        r"""
        X.set_explicit_frame(sequence_evaluator, frame) -> SequenceEvaluatorReference
        Set the current accumulated time, using a frame number, of the sequence evaluator
        
        Args:
            sequence_evaluator (SequenceEvaluatorReference): 
            frame (int32): 
        
        Returns:
            SequenceEvaluatorReference:
        """
        ...
    @classmethod
    def get_sequence(cls, sequence_evaluator: SequenceEvaluatorReference) -> AnimSequenceBase:
        r"""
        X.get_sequence(sequence_evaluator) -> AnimSequenceBase
        Gets the current sequence of the sequence evaluator
        
        Args:
            sequence_evaluator (SequenceEvaluatorReference): 
        
        Returns:
            AnimSequenceBase:
        """
        ...
    @classmethod
    def get_accumulated_time(cls, sequence_evaluator: SequenceEvaluatorReference) -> float:
        r"""
        X.get_accumulated_time(sequence_evaluator) -> float
        Gets the current accumulated time of the sequence evaluator
        
        Args:
            sequence_evaluator (SequenceEvaluatorReference): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def convert_to_sequence_evaluator_pure(cls, node: AnimNodeReference) -> Tuple[SequenceEvaluatorReference, bool]:
        r"""
        X.convert_to_sequence_evaluator_pure(node) -> (sequence_evaluator=SequenceEvaluatorReference, result=bool)
        Get a sequence evaluator context from an anim node context (pure)
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            sequence_evaluator (SequenceEvaluatorReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_sequence_evaluator(cls, node: AnimNodeReference) -> Tuple[SequenceEvaluatorReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_sequence_evaluator(node) -> (SequenceEvaluatorReference, result=AnimNodeReferenceConversionResult)
        Get a sequence evaluator context from an anim node context
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...
    @classmethod
    def advance_time(cls, update_context: AnimUpdateContext, sequence_evaluator: SequenceEvaluatorReference, play_rate: float = 1.000000) -> SequenceEvaluatorReference:
        r"""
        X.advance_time(update_context, sequence_evaluator, play_rate=1.000000) -> SequenceEvaluatorReference
        Advance the current accumulated time of the sequence evaluator
        
        Args:
            update_context (AnimUpdateContext): 
            sequence_evaluator (SequenceEvaluatorReference): 
            play_rate (float): 
        
        Returns:
            SequenceEvaluatorReference:
        """
        ...

class SequencePlayerLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on a sequence player anim node
    Note: Experimental and subject to change!
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: SequencePlayerLibrary.h
    
    """
    @classmethod
    def set_start_position(cls, sequence_player: SequencePlayerReference, start_position: float) -> SequencePlayerReference:
        r"""
        X.set_start_position(sequence_player, start_position) -> SequencePlayerReference
        Set the start position of the sequence player.
        If this is called from On Become Relevant or On Initial Update then it should be accompanied by a call to
        SetAccumulatedTime to achieve the desired effect of resetting the play time of a sequence player.
        
        Args:
            sequence_player (SequencePlayerReference): 
            start_position (float): 
        
        Returns:
            SequencePlayerReference:
        """
        ...
    @classmethod
    def set_sequence_with_inertial_blending(cls, update_context: AnimUpdateContext, sequence_player: SequencePlayerReference, sequence: AnimSequenceBase, blend_time: float = 0.200000) -> SequencePlayerReference:
        r"""
        X.set_sequence_with_inertial_blending(update_context, sequence_player, sequence, blend_time=0.200000) -> SequencePlayerReference
        Set the current sequence of the sequence player with an inertial blend time
        
        Args:
            update_context (AnimUpdateContext): 
            sequence_player (SequencePlayerReference): 
            sequence (AnimSequenceBase): 
            blend_time (float): 
        
        Returns:
            SequencePlayerReference:
        """
        ...
    @classmethod
    def set_sequence(cls, sequence_player: SequencePlayerReference, sequence: AnimSequenceBase) -> SequencePlayerReference:
        r"""
        X.set_sequence(sequence_player, sequence) -> SequencePlayerReference
        Set the current sequence of the sequence player
        
        Args:
            sequence_player (SequencePlayerReference): 
            sequence (AnimSequenceBase): 
        
        Returns:
            SequencePlayerReference:
        """
        ...
    @classmethod
    def set_play_rate(cls, sequence_player: SequencePlayerReference, play_rate: float) -> SequencePlayerReference:
        r"""
        X.set_play_rate(sequence_player, play_rate) -> SequencePlayerReference
        Set the play rate of the sequence player
        
        Args:
            sequence_player (SequencePlayerReference): 
            play_rate (float): 
        
        Returns:
            SequencePlayerReference:
        """
        ...
    @classmethod
    def set_accumulated_time(cls, sequence_player: SequencePlayerReference, time: float) -> SequencePlayerReference:
        r"""
        X.set_accumulated_time(sequence_player, time) -> SequencePlayerReference
        Set the current accumulated time of the sequence player
        
        Args:
            sequence_player (SequencePlayerReference): 
            time (float): 
        
        Returns:
            SequencePlayerReference:
        """
        ...
    @classmethod
    def get_start_position(cls, sequence_player: SequencePlayerReference) -> float:
        r"""
        X.get_start_position(sequence_player) -> float
        Get the start position of the sequence player
        
        Args:
            sequence_player (SequencePlayerReference): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_sequence_pure(cls, sequence_player: SequencePlayerReference) -> AnimSequenceBase:
        r"""
        X.get_sequence_pure(sequence_player) -> AnimSequenceBase
        Get the current sequence of the sequence player
        
        Args:
            sequence_player (SequencePlayerReference): 
        
        Returns:
            AnimSequenceBase:
        """
        ...
    @classmethod
    def get_sequence(cls, sequence_player: SequencePlayerReference, sequence_base: AnimSequenceBase) -> Tuple[SequencePlayerReference, AnimSequenceBase]:
        r"""
        X.get_sequence(sequence_player, sequence_base) -> (SequencePlayerReference, sequence_base=AnimSequenceBase)
        Get the current sequence of the sequence player - DEPRECATED, please use pure version
        deprecated: Function 'GetSequence' is deprecated.
        
        Args:
            sequence_player (SequencePlayerReference): 
            sequence_base (AnimSequenceBase): 
        
        Returns:
            AnimSequenceBase: 
        
            sequence_base (AnimSequenceBase):
        """
        ...
    @classmethod
    def get_play_rate(cls, sequence_player: SequencePlayerReference) -> float:
        r"""
        X.get_play_rate(sequence_player) -> float
        Get the play rate of the sequence player
        
        Args:
            sequence_player (SequencePlayerReference): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_loop_animation(cls, sequence_player: SequencePlayerReference) -> bool:
        r"""
        X.get_loop_animation(sequence_player) -> bool
        Get the looping state of the sequence player
        
        Args:
            sequence_player (SequencePlayerReference): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_accumulated_time(cls, sequence_player: SequencePlayerReference) -> float:
        r"""
        X.get_accumulated_time(sequence_player) -> float
        Gets the current accumulated time of the sequence player
        
        Args:
            sequence_player (SequencePlayerReference): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def convert_to_sequence_player_pure(cls, node: AnimNodeReference) -> Tuple[SequencePlayerReference, bool]:
        r"""
        X.convert_to_sequence_player_pure(node) -> (sequence_player=SequencePlayerReference, result=bool)
        Get a sequence player context from an anim node context (pure)
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            sequence_player (SequencePlayerReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_sequence_player(cls, node: AnimNodeReference) -> Tuple[SequencePlayerReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_sequence_player(node) -> (SequencePlayerReference, result=AnimNodeReferenceConversionResult)
        Get a sequence player context from an anim node context
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...
    @classmethod
    def compute_play_rate_from_duration(cls, sequence_player: SequencePlayerReference, duration: float = 1.000000) -> float:
        r"""
        X.compute_play_rate_from_duration(sequence_player, duration=1.000000) -> float
        Returns the Play Rate to provide when playing this animation if a specific animation duration is desired
        
        Args:
            sequence_player (SequencePlayerReference): 
            duration (float): 
        
        Returns:
            float:
        """
        ...

class SkeletalControlLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on a skeletal control anim node
    Note: Experimental and subject to change!
    
    **C++ Source:**
    
    - **Module**: AnimGraphRuntime
    - **File**: SkeletalControlLibrary.h
    
    """
    @classmethod
    def set_alpha(cls, skeletal_control: SkeletalControlReference, alpha: float) -> SkeletalControlReference:
        r"""
        X.set_alpha(skeletal_control, alpha) -> SkeletalControlReference
        Set the alpha value of this skeletal control
        
        Args:
            skeletal_control (SkeletalControlReference): 
            alpha (float): 
        
        Returns:
            SkeletalControlReference:
        """
        ...
    @classmethod
    def get_alpha(cls, skeletal_control: SkeletalControlReference) -> float:
        r"""
        X.get_alpha(skeletal_control) -> float
        Get the alpha value of this skeletal control
        
        Args:
            skeletal_control (SkeletalControlReference): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def convert_to_skeletal_control_pure(cls, node: AnimNodeReference) -> Tuple[SkeletalControlReference, bool]:
        r"""
        X.convert_to_skeletal_control_pure(node) -> (skeletal_control=SkeletalControlReference, result=bool)
        Get a skeletal control from an anim node (pure)
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            skeletal_control (SkeletalControlReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_skeletal_control(cls, node: AnimNodeReference) -> Tuple[SkeletalControlReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_skeletal_control(node) -> (SkeletalControlReference, result=AnimNodeReferenceConversionResult)
        Get a skeletal control from an anim node
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...

class MovieSceneTransformOrigin(Interface):
    r"""
    Movie Scene Transform Origin
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: IMovieSceneTransformOrigin.h
    
    """
    def bp_get_transform_origin(self) -> Transform:
        r"""
        x.bp_get_transform_origin() -> Transform
        Get the transform from which all absolute component transform sections should be relative. Scale is ignored.
        
        Returns:
            Transform:
        """
        ...

class MovieSceneTestSequence(MovieSceneSequence):
    r"""
    Simple type of sequence for use in automated tests.
    
    Bound objects are specified manually on the sequence and will be simply returned when
    bindings are resolved.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneTestDataBuilders.h
    
    """
    ...

class MovieScene3DConstraintSection(MovieSceneSection):
    r"""
    Base class for 3D constraint section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScene3DConstraintSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``constraint_binding_id`` (MovieSceneObjectBindingID):  [Read-Write] The constraint binding that this movie Constraint uses
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    def set_constraint_binding_id(self, constraint_binding_id: MovieSceneObjectBindingID) -> None:
        r"""
        x.set_constraint_binding_id(constraint_binding_id) -> None
        Sets the constraint binding for this Constraint section
        
        Args:
            constraint_binding_id (MovieSceneObjectBindingID):
        """
        ...
    def get_constraint_binding_id(self) -> MovieSceneObjectBindingID:
        r"""
        x.get_constraint_binding_id() -> MovieSceneObjectBindingID
        Gets the constraint binding for this Constraint section
        
        Returns:
            MovieSceneObjectBindingID:
        """
        ...

class MovieScene3DAttachSection(MovieScene3DConstraintSection):
    r"""
    A 3D Attach section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScene3DAttachSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attach_component_name`` (Name):  [Read-Write]
    - ``attach_socket_name`` (Name):  [Read-Write]
    - ``attachment_location_rule`` (AttachmentRule):  [Read-Write]
    - ``attachment_rotation_rule`` (AttachmentRule):  [Read-Write]
    - ``attachment_scale_rule`` (AttachmentRule):  [Read-Write]
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``constraint_binding_id`` (MovieSceneObjectBindingID):  [Read-Write] The constraint binding that this movie Constraint uses
    - ``detachment_location_rule`` (DetachmentRule):  [Read-Write]
    - ``detachment_rotation_rule`` (DetachmentRule):  [Read-Write]
    - ``detachment_scale_rule`` (DetachmentRule):  [Read-Write]
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    @property
    def attach_socket_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @attach_socket_name.setter
    def attach_socket_name(self, value: Name) -> None:
        ...
    @property
    def attach_component_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @attach_component_name.setter
    def attach_component_name(self, value: Name) -> None:
        ...
    @property
    def attachment_location_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write]
        """
        ...
    @attachment_location_rule.setter
    def attachment_location_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def attachment_rotation_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write]
        """
        ...
    @attachment_rotation_rule.setter
    def attachment_rotation_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def attachment_scale_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write]
        """
        ...
    @attachment_scale_rule.setter
    def attachment_scale_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def detachment_location_rule(self) -> DetachmentRule:
        r"""
        (DetachmentRule):  [Read-Write]
        """
        ...
    @detachment_location_rule.setter
    def detachment_location_rule(self, value: DetachmentRule) -> None:
        ...
    @property
    def detachment_rotation_rule(self) -> DetachmentRule:
        r"""
        (DetachmentRule):  [Read-Write]
        """
        ...
    @detachment_rotation_rule.setter
    def detachment_rotation_rule(self, value: DetachmentRule) -> None:
        ...
    @property
    def detachment_scale_rule(self) -> DetachmentRule:
        r"""
        (DetachmentRule):  [Read-Write]
        """
        ...
    @detachment_scale_rule.setter
    def detachment_scale_rule(self, value: DetachmentRule) -> None:
        ...

class MovieScene3DPathSection(MovieScene3DConstraintSection):
    r"""
    A 3D Path section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScene3DPathSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``constraint_binding_id`` (MovieSceneObjectBindingID):  [Read-Write] The constraint binding that this movie Constraint uses
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``follow`` (bool):  [Read-Write] Follow Curve
    - ``force_upright`` (bool):  [Read-Write] Force Upright
    - ``front_axis_enum`` (MovieScene3DPathSection_Axis):  [Read-Write] Front Axis
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``reverse`` (bool):  [Read-Write] Reverse Timing
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    - ``up_axis_enum`` (MovieScene3DPathSection_Axis):  [Read-Write] Up Axis
    """
    @property
    def front_axis_enum(self) -> MovieScene3DPathSection_Axis:
        r"""
        (MovieScene3DPathSection_Axis):  [Read-Write] Front Axis
        """
        ...
    @front_axis_enum.setter
    def front_axis_enum(self, value: MovieScene3DPathSection_Axis) -> None:
        ...
    @property
    def up_axis_enum(self) -> MovieScene3DPathSection_Axis:
        r"""
        (MovieScene3DPathSection_Axis):  [Read-Write] Up Axis
        """
        ...
    @up_axis_enum.setter
    def up_axis_enum(self, value: MovieScene3DPathSection_Axis) -> None:
        ...
    @property
    def follow(self) -> bool:
        r"""
        (bool):  [Read-Write] Follow Curve
        """
        ...
    @follow.setter
    def follow(self, value: bool) -> None:
        ...
    @property
    def reverse(self) -> bool:
        r"""
        (bool):  [Read-Write] Reverse Timing
        """
        ...
    @reverse.setter
    def reverse(self, value: bool) -> None:
        ...
    @property
    def force_upright(self) -> bool:
        r"""
        (bool):  [Read-Write] Force Upright
        """
        ...
    @force_upright.setter
    def force_upright(self, value: bool) -> None:
        ...

class MovieScene3DTransformSection(MovieSceneSection):
    r"""
    A 3D transform section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScene3DTransformSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``show3d_trajectory`` (Show3DTrajectory):  [Read-Write] Whether to show the 3d trajectory
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    - ``use_quaternion_interpolation`` (bool):  [Read-Write] Whether to use a quaternion linear interpolation between keys. This finds the 'shortest' rotation between keyed orientations.
    """
    ...

class MovieSceneActorReferenceSection(MovieSceneSection):
    r"""
    A single actor reference point section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneActorReferenceSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneAudioSection(MovieSceneSection):
    r"""
    Audio section, for use in the audio track, or by attached audio objects
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneAudioSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] The attenuation settings to use.
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``looping`` (bool):  [Read-Write] Allow looping if the section length is greater than the sound duration
    - ``override_attenuation`` (bool):  [Read-Write] Should the attenuation settings on this section be used.
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``sound`` (SoundBase):  [Read-Write] The sound cue or wave that this section plays
    - ``start_frame_offset`` (FrameNumber):  [Read-Write] The offset into the beginning of the audio clip
    - ``suppress_subtitles`` (bool):  [Read-Write]
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    @property
    def sound(self) -> SoundBase:
        r"""
        (SoundBase):  [Read-Write] The sound cue or wave that this section plays
        """
        ...
    @sound.setter
    def sound(self, value: SoundBase) -> None:
        ...
    def set_suppress_subtitles(self, suppress_subtitles: bool) -> None:
        r"""
        x.set_suppress_subtitles(suppress_subtitles) -> None
        Set whether subtitles should be suppressed
        
        Args:
            suppress_subtitles (bool):
        """
        ...
    def set_start_offset(self, start_offset: FrameNumber) -> None:
        r"""
        x.set_start_offset(start_offset) -> None
        Set the offset into the beginning of the audio clip
        
        Args:
            start_offset (FrameNumber):
        """
        ...
    def set_sound(self, sound: SoundBase) -> None:
        r"""
        x.set_sound(sound) -> None
        Sets this section's sound
        
        Args:
            sound (SoundBase):
        """
        ...
    def set_override_attenuation(self, override_attenuation: bool) -> None:
        r"""
        x.set_override_attenuation(override_attenuation) -> None
        Set whether the attentuation should be overriden
        
        Args:
            override_attenuation (bool):
        """
        ...
    def set_looping(self, looping: bool) -> None:
        r"""
        x.set_looping(looping) -> None
        Set whether the sound should be looped
        
        Args:
            looping (bool):
        """
        ...
    def set_attenuation_settings(self, attenuation_settings: SoundAttenuation) -> None:
        r"""
        x.set_attenuation_settings(attenuation_settings) -> None
        Set the attenuation settings for this audio section
        
        Args:
            attenuation_settings (SoundAttenuation):
        """
        ...
    def get_suppress_subtitles(self) -> bool:
        r"""
        x.get_suppress_subtitles() -> bool
        
        
        Returns:
            bool: Whether subtitles should be suppressed
        """
        ...
    def get_start_offset(self) -> FrameNumber:
        r"""
        x.get_start_offset() -> FrameNumber
        Get the offset into the beginning of the audio clip
        
        Returns:
            FrameNumber:
        """
        ...
    def get_sound(self) -> SoundBase:
        r"""
        x.get_sound() -> SoundBase
        Gets the sound for this section
        
        Returns:
            SoundBase:
        """
        ...
    def get_override_attenuation(self) -> bool:
        r"""
        x.get_override_attenuation() -> bool
        
        
        Returns:
            bool: Whether override settings on this section should be used
        """
        ...
    def get_looping(self) -> bool:
        r"""
        x.get_looping() -> bool
        
        
        Returns:
            bool: Whether to allow looping if the section length is greater than the sound duration
        """
        ...
    def get_attenuation_settings(self) -> SoundAttenuation:
        r"""
        x.get_attenuation_settings() -> SoundAttenuation
        
        
        Returns:
            SoundAttenuation: The attenuation settings
        """
        ...

class MovieSceneBaseCacheSection(MovieSceneSection):
    r"""
    Movie scene section that control base cache playback
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneBaseCacheSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneByteSection(MovieSceneSection):
    r"""
    A single byte section.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneByteSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneCameraCutSection(MovieSceneSection):
    r"""
    Movie CameraCuts are sections on the CameraCuts track, that show what the viewer "sees"
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCameraCutSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``camera_binding_id`` (MovieSceneObjectBindingID):  [Read-Write] The camera binding that this movie CameraCut uses
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``lock_previous_camera`` (bool):  [Read-Write] When blending, lock the previous camera (camera cut or gameplay camera).
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    def set_camera_binding_id(self, camera_binding_id: MovieSceneObjectBindingID) -> None:
        r"""
        x.set_camera_binding_id(camera_binding_id) -> None
        Sets the camera binding for this CameraCut section
        
        Args:
            camera_binding_id (MovieSceneObjectBindingID):
        """
        ...
    def get_camera_binding_id(self) -> MovieSceneObjectBindingID:
        r"""
        x.get_camera_binding_id() -> MovieSceneObjectBindingID
        Gets the camera binding for this CameraCut section
        
        Returns:
            MovieSceneObjectBindingID:
        """
        ...

class MovieSceneShotSection(MovieSceneCameraCutSection):
    r"""
    deprecated: 'MovieSceneShotSection' was renamed to 'MovieSceneCameraCutSection'.
    """
    ...

class MovieSceneCameraShakeSection(MovieSceneSection):
    r"""
    Movie Scene Camera Shake Section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCameraShakeSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``shake_data`` (MovieSceneCameraShakeSectionData):  [Read-Write]
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneCameraShakeSourceShakeSection(MovieSceneSection):
    r"""
    Movie Scene Camera Shake Source Shake Section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCameraShakeSourceShakeSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``shake_data`` (MovieSceneCameraShakeSectionData):  [Read-Write]
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneCameraShakeSourceTriggerSection(MovieSceneSection):
    r"""
    Movie Scene Camera Shake Source Trigger Section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCameraShakeSourceTriggerSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneSubSection(MovieSceneSection):
    r"""
    Implements a section in sub-sequence tracks.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSubSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``network_mask`` (uint8):  [Read-Write]
    - ``parameters`` (MovieSceneSectionParameters):  [Read-Write]
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``sub_sequence`` (MovieSceneSequence):  [Read-Write] Movie scene being played by this section
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    @property
    def parameters(self) -> MovieSceneSectionParameters:
        r"""
        (MovieSceneSectionParameters):  [Read-Write]
        """
        ...
    @parameters.setter
    def parameters(self, value: MovieSceneSectionParameters) -> None:
        ...
    def set_sequence(self, sequence: MovieSceneSequence) -> None:
        r"""
        x.set_sequence(sequence) -> None
        Sets the sequence played by this section.
        see: GetSequence
        
        Args:
            sequence (MovieSceneSequence): The sequence to play.
        """
        ...
    def get_sequence(self) -> MovieSceneSequence:
        r"""
        x.get_sequence() -> MovieSceneSequence
        Get the sequence that is assigned to this section.
        see: SetSequence
        
        Returns:
            MovieSceneSequence: The sequence.
        """
        ...
    def get_parent_sequence_frame(self, frame: int, parent_sequence: MovieSceneSequence) -> int:
        r"""
        x.get_parent_sequence_frame(frame, parent_sequence) -> int32
        Get the frame in the space of its parent sequence
        
        Args:
            frame (int32): The desired local frame
            parent_sequence (MovieSceneSequence): The parent sequence to traverse from
        
        Returns:
            int32: The frame at the parent sequence
        """
        ...

class MovieSceneCinematicShotSection(MovieSceneSubSection):
    r"""
    Implements a cinematic shot section.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCinematicShotSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``network_mask`` (uint8):  [Read-Write]
    - ``parameters`` (MovieSceneSectionParameters):  [Read-Write]
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``sub_sequence`` (MovieSceneSequence):  [Read-Write] Movie scene being played by this section
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    def set_shot_display_name(self, shot_display_name: str) -> None:
        r"""
        x.set_shot_display_name(shot_display_name) -> None
        Set the shot display name
        
        Args:
            shot_display_name (str):
        """
        ...
    def get_shot_display_name(self) -> str:
        r"""
        x.get_shot_display_name() -> str
        
        
        Returns:
            str: The shot display name. if empty, returns the sequence's name
        """
        ...

class MovieSceneColorSection(MovieSceneSection):
    r"""
    A single floating point section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneColorSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneComponentMaterialParameterSection(MovieSceneSection):
    r"""
    A movie scene section containing data for material parameters.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneComponentMaterialParameterSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    def remove_scalar_parameter(self, parameter_info: MaterialParameterInfo) -> bool:
        r"""
        x.remove_scalar_parameter(parameter_info) -> bool
        Removes a scalar parameter from this section.
        
        Args:
            parameter_info (MaterialParameterInfo): The material parameter info of the scalar parameter to remove.
        
        Returns:
            bool: True if a parameter with that name was found and removed, otherwise false.
        """
        ...
    def remove_color_parameter(self, parameter_info: MaterialParameterInfo) -> bool:
        r"""
        x.remove_color_parameter(parameter_info) -> bool
        Removes a color parameter from this section.
        
        Args:
            parameter_info (MaterialParameterInfo): The material parameter info of the color parameter to remove.
        
        Returns:
            bool: True if a parameter with that name was found and removed, otherwise false.
        """
        ...
    def add_scalar_parameter_key(self, parameter_info: MaterialParameterInfo, time: FrameNumber, value: float, layer_name: str, asset_name: str) -> None:
        r"""
        x.add_scalar_parameter_key(parameter_info, time, value, layer_name, asset_name) -> None
        Adds a a key for a specific scalar parameter at the specified time with the specified value.
        
        Args:
            parameter_info (MaterialParameterInfo): 
            time (FrameNumber): 
            value (float): 
            layer_name (str): 
            asset_name (str):
        """
        ...
    def add_color_parameter_key(self, parameter_info: MaterialParameterInfo, time: FrameNumber, value: LinearColor, layer_name: str, asset_name: str) -> None:
        r"""
        x.add_color_parameter_key(parameter_info, time, value, layer_name, asset_name) -> None
        Adds a a key for a specific color parameter at the specified time with the specified value.
        
        Args:
            parameter_info (MaterialParameterInfo): 
            time (FrameNumber): 
            value (LinearColor): 
            layer_name (str): 
            asset_name (str):
        """
        ...

class MovieSceneParameterSection(MovieSceneSection):
    r"""
    A single movie scene section which can contain data for multiple named parameters.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneParameterSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    def remove_vector_parameter(self, parameter_name: Name) -> bool:
        r"""
        x.remove_vector_parameter(parameter_name) -> bool
        Removes a vector parameter from this section.
        
        Args:
            parameter_name (Name): The name of the vector parameter to remove.
        
        Returns:
            bool: True if a parameter with that name was found and removed, otherwise false.
        """
        ...
    def remove_vector2d_parameter(self, parameter_name: Name) -> bool:
        r"""
        x.remove_vector2d_parameter(parameter_name) -> bool
        Removes a vector2D parameter from this section.
        
        Args:
            parameter_name (Name): The name of the vector2D parameter to remove.
        
        Returns:
            bool: True if a parameter with that name was found and removed, otherwise false.
        """
        ...
    def remove_transform_parameter(self, parameter_name: Name) -> bool:
        r"""
        x.remove_transform_parameter(parameter_name) -> bool
        Removes a transform parameter from this section.
        
        Args:
            parameter_name (Name): The name of the transform parameter to remove.
        
        Returns:
            bool: True if a parameter with that name was found and removed, otherwise false.
        """
        ...
    def remove_scalar_parameter(self, parameter_name: Name) -> bool:
        r"""
        x.remove_scalar_parameter(parameter_name) -> bool
        Removes a scalar parameter from this section.
        
        Args:
            parameter_name (Name): The name of the scalar parameter to remove.
        
        Returns:
            bool: True if a parameter with that name was found and removed, otherwise false.
        """
        ...
    def remove_color_parameter(self, parameter_name: Name) -> bool:
        r"""
        x.remove_color_parameter(parameter_name) -> bool
        Removes a color parameter from this section.
        
        Args:
            parameter_name (Name): The name of the color parameter to remove.
        
        Returns:
            bool: True if a parameter with that name was found and removed, otherwise false.
        """
        ...
    def remove_bool_parameter(self, parameter_name: Name) -> bool:
        r"""
        x.remove_bool_parameter(parameter_name) -> bool
        Removes a bool parameter from this section.
        
        Args:
            parameter_name (Name): The name of the bool parameter to remove.
        
        Returns:
            bool: True if a parameter with that name was found and removed, otherwise false.
        """
        ...
    def get_parameter_names(self) -> Set[Name]:
        r"""
        x.get_parameter_names() -> Set[Name]
        Gets the set of all parameter names used by this section.
        
        Returns:
            Set[Name]: 
        
            parameter_names (Set[Name]):
        """
        ...
    def add_vector_parameter_key(self, parameter_name: Name, time: FrameNumber, value: Vector) -> None:
        r"""
        x.add_vector_parameter_key(parameter_name, time, value) -> None
        Adds a a key for a specific vector parameter at the specified time with the specified value.
        
        Args:
            parameter_name (Name): 
            time (FrameNumber): 
            value (Vector):
        """
        ...
    def add_vector2d_parameter_key(self, parameter_name: Name, time: FrameNumber, value: Vector2D) -> None:
        r"""
        x.add_vector2d_parameter_key(parameter_name, time, value) -> None
        Adds a a key for a specific vector2D parameter at the specified time with the specified value.
        
        Args:
            parameter_name (Name): 
            time (FrameNumber): 
            value (Vector2D):
        """
        ...
    def add_transform_parameter_key(self, parameter_name: Name, time: FrameNumber, value: Transform) -> None:
        r"""
        x.add_transform_parameter_key(parameter_name, time, value) -> None
        Adds a a key for a specific color parameter at the specified time with the specified value.
        
        Args:
            parameter_name (Name): 
            time (FrameNumber): 
            value (Transform):
        """
        ...
    def add_scalar_parameter_key(self, parameter_name: Name, time: FrameNumber, value: float) -> None:
        r"""
        x.add_scalar_parameter_key(parameter_name, time, value) -> None
        Adds a a key for a specific scalar parameter at the specified time with the specified value.
        
        Args:
            parameter_name (Name): 
            time (FrameNumber): 
            value (float):
        """
        ...
    def add_color_parameter_key(self, parameter_name: Name, time: FrameNumber, value: LinearColor) -> None:
        r"""
        x.add_color_parameter_key(parameter_name, time, value) -> None
        Adds a a key for a specific color parameter at the specified time with the specified value.
        
        Args:
            parameter_name (Name): 
            time (FrameNumber): 
            value (LinearColor):
        """
        ...
    def add_bool_parameter_key(self, parameter_name: Name, time: FrameNumber, value: bool) -> None:
        r"""
        x.add_bool_parameter_key(parameter_name, time, value) -> None
        Adds a a key for a specific bool parameter at the specified time with the specified value.
        
        Args:
            parameter_name (Name): 
            time (FrameNumber): 
            value (bool):
        """
        ...

class MovieSceneMaterialParameterSection(MovieSceneParameterSection):
    r"""
    deprecated: 'MovieSceneMaterialParameterSection' was renamed to 'MovieSceneParameterSection'.
    """
    ...

class MovieSceneCustomPrimitiveDataSection(MovieSceneParameterSection):
    r"""
    Movie scene section that animates custom primitive data scalars, vector2s, vector3s, and colors
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCustomPrimitiveDataSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneCVarSection(MovieSceneSection):
    r"""
    A CVar section is responsible for applying a user-supplied value to the specified cvar, and then restoring the previous value after the section ends.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCVarSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``console_variable_collections`` (Array[MovieSceneConsoleVariableCollection]):  [Read-Write] Array of console variable preset assets that this track should operate on
    - ``console_variables`` (MovieSceneCVarOverrides):  [Read-Write] The name of the console variable and the value, separated by ' ' or '=', ie: "foo.bar=1" or "foo.bar 1".
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    def set_from_string(self, string: str) -> None:
        r"""
        x.set_from_string(string) -> None
        Set from String
        
        Args:
            string (str):
        """
        ...
    def get_string(self) -> str:
        r"""
        x.get_string() -> str
        Get String
        
        Returns:
            str:
        """
        ...

class MovieSceneDataLayerSection(MovieSceneSection):
    r"""
    Movie Scene Data Layer Section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneDataLayerSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write] A list of data layers that should be loaded or unloaded by this section
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Write]
      deprecated: Use DataLayer Assets Instead
    - ``desired_state`` (DataLayerRuntimeState):  [Read-Write] The desired state for the data layers on this section when the section is actively evaluating.
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``flush_on_activated`` (bool):  [Read-Write] Determine if we need to flush level streaming when the data layers are activated. May result in a hitch.
    - ``flush_on_unload`` (bool):  [Read-Write] Determine if we need to flush level streaming when the data layers unloads.
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``perform_gc_on_unload`` (bool):  [Read-Write] Determine if we need to perform a GC when the data layers unloads.
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``preroll_state`` (DataLayerRuntimeState):  [Read-Write] The desired state for the data layers on this section when the section is pre or post-rolling.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    @property
    def data_layers(self) -> Array[ActorDataLayer]:
        r"""
        (Array[ActorDataLayer]):  [Read-Write]
        deprecated: Use DataLayer Assets Instead
        """
        ...
    @data_layers.setter
    def data_layers(self, value: Array[ActorDataLayer]) -> None:
        ...
    def set_preroll_state(self, preroll_state: DataLayerRuntimeState) -> None:
        r"""
        x.set_preroll_state(preroll_state) -> None
        Set Preroll State
        
        Args:
            preroll_state (DataLayerRuntimeState):
        """
        ...
    def set_perform_gc_on_unload(self, perform_gc_on_unload: bool) -> None:
        r"""
        x.set_perform_gc_on_unload(perform_gc_on_unload) -> None
        Set Perform GCOn Unload
        
        Args:
            perform_gc_on_unload (bool):
        """
        ...
    def set_flush_on_unload(self, flush_on_unload: bool) -> None:
        r"""
        x.set_flush_on_unload(flush_on_unload) -> None
        Set Flush on Unload
        
        Args:
            flush_on_unload (bool):
        """
        ...
    def set_flush_on_activated(self, flush_on_activated: bool) -> None:
        r"""
        x.set_flush_on_activated(flush_on_activated) -> None
        Set Flush on Activated
        
        Args:
            flush_on_activated (bool):
        """
        ...
    def set_desired_state(self, desired_state: DataLayerRuntimeState) -> None:
        r"""
        x.set_desired_state(desired_state) -> None
        Set Desired State
        
        Args:
            desired_state (DataLayerRuntimeState):
        """
        ...
    def set_data_layers(self, data_layers: Array[ActorDataLayer]) -> None:
        r"""
        x.set_data_layers(data_layers) -> None
        Set Data Layers
        
        Args:
            data_layers (Array[ActorDataLayer]):
        """
        ...
    def set_data_layer_assets(self, data_layer_assets: Array[DataLayerAsset]) -> None:
        r"""
        x.set_data_layer_assets(data_layer_assets) -> None
        Set Data Layer Assets
        
        Args:
            data_layer_assets (Array[DataLayerAsset]):
        """
        ...
    def get_preroll_state(self) -> DataLayerRuntimeState:
        r"""
        x.get_preroll_state() -> DataLayerRuntimeState
        Get Preroll State
        
        Returns:
            DataLayerRuntimeState:
        """
        ...
    def get_perform_gc_on_unload(self) -> bool:
        r"""
        x.get_perform_gc_on_unload() -> bool
        Get Perform GCOn Unload
        
        Returns:
            bool:
        """
        ...
    def get_flush_on_unload(self) -> bool:
        r"""
        x.get_flush_on_unload() -> bool
        Get Flush on Unload
        
        Returns:
            bool:
        """
        ...
    def get_flush_on_activated(self) -> bool:
        r"""
        x.get_flush_on_activated() -> bool
        Get Flush on Activated
        
        Returns:
            bool:
        """
        ...
    def get_desired_state(self) -> DataLayerRuntimeState:
        r"""
        x.get_desired_state() -> DataLayerRuntimeState
        Get Desired State
        
        Returns:
            DataLayerRuntimeState:
        """
        ...
    def get_data_layers(self) -> Array[ActorDataLayer]:
        r"""
        x.get_data_layers() -> Array[ActorDataLayer]
        Get Data Layers
        
        Returns:
            Array[ActorDataLayer]:
        """
        ...
    def get_data_layer_assets(self) -> Array[DataLayerAsset]:
        r"""
        x.get_data_layer_assets() -> Array[DataLayerAsset]
        Get Data Layer Assets
        
        Returns:
            Array[DataLayerAsset]:
        """
        ...

class MovieSceneDoubleSection(MovieSceneSection):
    r"""
    A double precision floating point section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneDoubleSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneEnumSection(MovieSceneSection):
    r"""
    A single enum section.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEnumSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneEventSectionBase(MovieSceneSection):
    r"""
    Base class for all event sections. Manages dirtying the section and track on recompilation of the director blueprint.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEventSectionBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneEventRepeaterSection(MovieSceneEventSectionBase):
    r"""
    Event section that will trigger its event exactly once, every time it is evaluated.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEventRepeaterSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``event`` (MovieSceneEvent):  [Read-Write] The event that should be triggered each time this section is evaluated
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneEventSection(MovieSceneSection):
    r"""
    Implements a section in movie scene event tracks.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEventSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneEventTriggerSection(MovieSceneEventSectionBase):
    r"""
    Event section that triggeres specific timed events.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEventTriggerSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneFadeSection(MovieSceneSection):
    r"""
    A single floating point section.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneFadeSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``fade_audio`` (bool):  [Read-Write] Fade audio.
    - ``fade_color`` (LinearColor):  [Read-Write] Fade color.
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneFloatSection(MovieSceneSection):
    r"""
    A single floating point section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneFloatSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneIntegerSection(MovieSceneSection):
    r"""
    A single integer section.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneIntegerSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneLevelVisibilitySection(MovieSceneSection):
    r"""
    A section for use with the movie scene level visibility track, which controls streamed level visibility.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneLevelVisibilitySection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``level_names`` (Array[Name]):  [Read-Write] The short names of the levels who's visibility is controlled by this section.
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    - ``visibility`` (LevelVisibility):  [Read-Write] Whether or not the levels in this section should be visible or hidden.
    """
    def set_visibility(self, visibility: LevelVisibility) -> None:
        r"""
        x.set_visibility(visibility) -> None
        Set Visibility
        
        Args:
            visibility (LevelVisibility):
        """
        ...
    def set_level_names(self, level_names: Array[Name]) -> None:
        r"""
        x.set_level_names(level_names) -> None
        Set Level Names
        
        Args:
            level_names (Array[Name]):
        """
        ...
    def get_visibility(self) -> LevelVisibility:
        r"""
        x.get_visibility() -> LevelVisibility
        Get Visibility
        
        Returns:
            LevelVisibility:
        """
        ...
    def get_level_names(self) -> Array[Name]:
        r"""
        x.get_level_names() -> Array[Name]
        Get Level Names
        
        Returns:
            Array[Name]:
        """
        ...

class MovieSceneObjectPropertySection(MovieSceneSection):
    r"""
    Movie Scene Object Property Section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneObjectPropertySection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneParticleSection(MovieSceneSection):
    r"""
    Particle section, for particle toggling and triggering.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneParticleSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieScenePrimitiveMaterialSection(MovieSceneSection):
    r"""
    Movie Scene Primitive Material Section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScenePrimitiveMaterialSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneSkeletalAnimationSection(MovieSceneSection):
    r"""
    Movie scene section that control skeletal animation
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneSkeletalAnimationSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``matched_location_offset`` (Vector):  [Read-Only] Location offset determined by matching
    - ``matched_rotation_offset`` (Rotator):  [Read-Only] Rotation offset determined by matching
    - ``params`` (MovieSceneSkeletalAnimationParams):  [Read-Write]
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``show_skeleton`` (bool):  [Read-Write] Whether to show the underlying skeleton for this section.
    - ``start_location_offset`` (Vector):  [Read-Write] Location offset applied before the matched offset
    - ``start_rotation_offset`` (Rotator):  [Read-Write] Location offset applied after the matched offset
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    @property
    def params(self) -> MovieSceneSkeletalAnimationParams:
        r"""
        (MovieSceneSkeletalAnimationParams):  [Read-Write]
        """
        ...
    @params.setter
    def params(self, value: MovieSceneSkeletalAnimationParams) -> None:
        ...
    @property
    def start_location_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Location offset applied before the matched offset
        """
        ...
    @start_location_offset.setter
    def start_location_offset(self, value: Vector) -> None:
        ...
    @property
    def start_rotation_offset(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] Location offset applied after the matched offset
        """
        ...
    @start_rotation_offset.setter
    def start_rotation_offset(self, value: Rotator) -> None:
        ...
    @property
    def matched_location_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Location offset determined by matching
        """
        ...
    @property
    def matched_rotation_offset(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] Rotation offset determined by matching
        """
        ...
    @property
    def show_skeleton(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to show the underlying skeleton for this section.
        """
        ...
    @show_skeleton.setter
    def show_skeleton(self, value: bool) -> None:
        ...

class MovieSceneSlomoSection(MovieSceneSection):
    r"""
    A single floating point section.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneSlomoSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneStringSection(MovieSceneSection):
    r"""
    A single string section
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneStringSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneFloatVectorSection(MovieSceneSection):
    r"""
    A float vector section.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneVectorSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneVectorSection(MovieSceneFloatVectorSection):
    r"""
    deprecated: 'MovieSceneVectorSection' was renamed to 'MovieSceneFloatVectorSection'.
    """
    ...

class MovieSceneDoubleVectorSection(MovieSceneSection):
    r"""
    A double vector section.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneVectorSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneBoolSection(MovieSceneSection):
    r"""
    A single bool section.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneBoolSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneVisibilitySection(MovieSceneBoolSection):
    r"""
    A spawn section.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneVisibilitySection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneAsyncAction_SequencePrediction(BlueprintAsyncActionBase):
    r"""
    Async BP action that represents a pending prediction that is dispatched on a playing sequence.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScenePredictionSystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``failure`` (MovieSceneActorPredictionFailure):  [Read-Write] Called when a message is broadcast on the specified channel. Use GetPayload() to request the message payload.
    - ``result`` (MovieSceneActorPredictionResult):  [Read-Write] Called when a message is broadcast on the specified channel. Use GetPayload() to request the message payload.
    """
    @property
    def result(self) -> MovieSceneActorPredictionResult:
        r"""
        (MovieSceneActorPredictionResult):  [Read-Write] Called when a message is broadcast on the specified channel. Use GetPayload() to request the message payload.
        """
        ...
    @result.setter
    def result(self, value: MovieSceneActorPredictionResult) -> None:
        ...
    @property
    def failure(self) -> MovieSceneActorPredictionFailure:
        r"""
        (MovieSceneActorPredictionFailure):  [Read-Write] Called when a message is broadcast on the specified channel. Use GetPayload() to request the message payload.
        """
        ...
    @failure.setter
    def failure(self, value: MovieSceneActorPredictionFailure) -> None:
        ...
    @classmethod
    def predict_world_transform_at_time(cls, player: MovieSceneSequencePlayer, target_component: SceneComponent, time_in_seconds: float) -> MovieSceneAsyncAction_SequencePrediction:
        r"""
        X.predict_world_transform_at_time(player, target_component, time_in_seconds) -> MovieSceneAsyncAction_SequencePrediction
        Initiate an asynchronous prediction for the specified component's world transform at a specific time in a sequence
        Changes in attachment between the sequence's current time, and the predicted time are not accounted for
        Calling this function on a stopped sequence player is undefined.
        
        Args:
            player (MovieSceneSequencePlayer): An active, currently playing sequence player to use for predicting the transform
            target_component (SceneComponent): The component to predict a world transform for
            time_in_seconds (float): The time within the sequence to predict the transform at
        
        Returns:
            MovieSceneAsyncAction_SequencePrediction: An asynchronous prediction object that contains Result and Failure delegates
        """
        ...
    @classmethod
    def predict_world_transform_at_frame(cls, player: MovieSceneSequencePlayer, target_component: SceneComponent, frame_time: FrameTime) -> MovieSceneAsyncAction_SequencePrediction:
        r"""
        X.predict_world_transform_at_frame(player, target_component, frame_time) -> MovieSceneAsyncAction_SequencePrediction
        Initiate an asynchronous prediction for the specified component's world transform at a specific time in a sequence
        Changes in attachment between the sequence's current time, and the predicted time are not accounted for
        Calling this function on a stopped sequence player is undefined.
        
        Args:
            player (MovieSceneSequencePlayer): An active, currently playing sequence player to use for predicting the transform
            target_component (SceneComponent): The component to predict a world transform for
            frame_time (FrameTime): The frame time to predict at in the sequence's display rate
        
        Returns:
            MovieSceneAsyncAction_SequencePrediction: An asynchronous prediction object that contains Result and Failure delegates
        """
        ...
    @classmethod
    def predict_local_transform_at_time(cls, player: MovieSceneSequencePlayer, target_component: SceneComponent, time_in_seconds: float) -> MovieSceneAsyncAction_SequencePrediction:
        r"""
        X.predict_local_transform_at_time(player, target_component, time_in_seconds) -> MovieSceneAsyncAction_SequencePrediction
        Initiate an asynchronous prediction for the specified component's local transform at a specific time in a sequence
        Changes in attachment between the sequence's current time, and the predicted time are not accounted for
        Calling this function on a stopped sequence player is undefined.
        
        Args:
            player (MovieSceneSequencePlayer): An active, currently playing sequence player to use for predicting the transform
            target_component (SceneComponent): The component to predict a world transform for
            time_in_seconds (float): The time within the sequence to predict the transform at
        
        Returns:
            MovieSceneAsyncAction_SequencePrediction: An asynchronous prediction object that contains Result and Failure delegates
        """
        ...
    @classmethod
    def predict_local_transform_at_frame(cls, player: MovieSceneSequencePlayer, target_component: SceneComponent, frame_time: FrameTime) -> MovieSceneAsyncAction_SequencePrediction:
        r"""
        X.predict_local_transform_at_frame(player, target_component, frame_time) -> MovieSceneAsyncAction_SequencePrediction
        Initiate an asynchronous prediction for the specified component's local transform at a specific time in a sequence
        Changes in attachment between the sequence's current time, and the predicted time are not accounted for
        Calling this function on a stopped sequence player is undefined.
        
        Args:
            player (MovieSceneSequencePlayer): An active, currently playing sequence player to use for predicting the transform
            target_component (SceneComponent): The component to predict a world transform for
            frame_time (FrameTime): The frame time to predict at in the sequence's display rate
        
        Returns:
            MovieSceneAsyncAction_SequencePrediction: An asynchronous prediction object that contains Result and Failure delegates
        """
        ...

class MovieScene3DConstraintTrack(MovieSceneTrack):
    r"""
    Base class for constraint tracks (tracks that are dependent upon other objects).
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScene3DConstraintTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieScene3DAttachTrack(MovieScene3DConstraintTrack):
    r"""
    Handles manipulation of path tracks in a movie scene.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScene3DAttachTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieScene3DPathTrack(MovieScene3DConstraintTrack):
    r"""
    Handles manipulation of path tracks in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScene3DPathTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieScene3DTransformTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of component transforms in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScene3DTransformTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneActorReferenceTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of actor reference properties in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneActorReferenceTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneAudioTrack(MovieSceneNameableTrack):
    r"""
    Handles manipulation of audio.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneAudioTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneBoolTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of float properties in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneBoolTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneByteTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of byte properties in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneByteTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    def set_byte_track_enum(self, enum: Enum) -> None:
        r"""
        x.set_byte_track_enum(enum) -> None
        Set this byte track's enum
        
        Args:
            enum (Enum): The enum to set
        """
        ...
    def get_byte_track_enum(self) -> Enum:
        r"""
        x.get_byte_track_enum() -> Enum
        Get this byte track's enum
        
        Returns:
            Enum: The enum for this byte track
        """
        ...

class MovieSceneCameraCutTrack(MovieSceneNameableTrack):
    r"""
    Handles manipulation of CameraCut properties in a movie scene.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCameraCutTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneShotTrack(MovieSceneCameraCutTrack):
    r"""
    deprecated: 'MovieSceneShotTrack' was renamed to 'MovieSceneCameraCutTrack'.
    """
    ...

class MovieSceneCameraShakeSourceShakeTrack(MovieSceneNameableTrack):
    r"""
    Movie Scene Camera Shake Source Shake Track
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCameraShakeSourceShakeTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneCameraShakeSourceTriggerTrack(MovieSceneTrack):
    r"""
    Movie Scene Camera Shake Source Trigger Track
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCameraShakeSourceTriggerTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneCameraShakeTrack(MovieSceneNameableTrack):
    r"""
    Movie Scene Camera Shake Track
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCameraShakeTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneSubTrack(MovieSceneNameableTrack):
    r"""
    A track that holds sub-sequences within a larger sequence.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSubTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneCinematicShotTrack(MovieSceneSubTrack):
    r"""
    A track that holds consecutive sub sequences.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCinematicShotTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneColorTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of float properties in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneColorTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneCustomPrimitiveDataTrack(MovieSceneNameableTrack):
    r"""
    Handles manipulation of custom primitive data in a movie scene.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCustomPrimitiveDataTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneCVarTrack(MovieSceneNameableTrack):
    r"""
    Track for setting (and restoring) Console Variables during playback.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneCVarTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneDataLayerTrack(MovieSceneNameableTrack):
    r"""
    A track that controls loading, unloading and visibility of data layers
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneDataLayerTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneDoubleTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of double properties in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneDoubleTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneEnumTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of byte properties in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEnumTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneEulerTransformTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of 3D euler transform properties in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEulerTransformTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneEventTrack(MovieSceneNameableTrack):
    r"""
    Implements a movie scene track that triggers discrete events during playback.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneEventTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``event_position`` (FireEventsAtPosition):  [Read-Write] Defines where in the evaluation to trigger events
    - ``fire_events_when_backwards`` (bool):  [Read-Write] If events should be fired when passed playing the sequence backwards.
    - ``fire_events_when_forwards`` (bool):  [Read-Write] If events should be fired when passed playing the sequence forwards.
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    def add_event_trigger_section(self) -> MovieSceneEventTriggerSection:
        r"""
        x.add_event_trigger_section() -> MovieSceneEventTriggerSection
        Create a new event trigger section for the given track
        
        Returns:
            MovieSceneEventTriggerSection: The newly created event trigger section
        """
        ...
    def add_event_repeater_section(self) -> MovieSceneEventRepeaterSection:
        r"""
        x.add_event_repeater_section() -> MovieSceneEventRepeaterSection
        Create a new event repeater section for the given track
        
        Returns:
            MovieSceneEventRepeaterSection: The newly created event repeater section
        """
        ...

class MovieSceneFloatTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of float properties in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneFloatTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneFadeTrack(MovieSceneFloatTrack):
    r"""
    Implements a movie scene track that controls a fade.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneFadeTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneIntegerTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of integer properties in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneIntegerTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneLevelVisibilityTrack(MovieSceneNameableTrack):
    r"""
    A track for controlling the visibility of streamed levels.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneLevelVisibilityTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneMaterialParameterCollectionTrack(MovieSceneMaterialTrack):
    r"""
    Handles manipulation of material parameter collections in a movie scene.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneMaterialParameterCollectionTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``mpc`` (MaterialParameterCollection):  [Read-Write] The material parameter collection to manipulate
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneComponentMaterialTrack(MovieSceneMaterialTrack):
    r"""
    A material track which is specialized for animation materials which are owned by actor components.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneMaterialTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``material_index`` (int32):  [Read-Write] The index of this material this track is animating. Has been deprecated in favor of MaterialInfo
      deprecated: Use MaterialInfo instead.
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    @property
    def material_index(self) -> int:
        r"""
        (int32):  [Read-Write] The index of this material this track is animating. Has been deprecated in favor of MaterialInfo
        deprecated: Use MaterialInfo instead.
        """
        ...
    @material_index.setter
    def material_index(self, value: int) -> None:
        ...
    def set_material_info(self, material_info: ComponentMaterialInfo) -> None:
        r"""
        x.set_material_info(material_info) -> None
        Set material info of the component that is animated by the material track.
        
        Args:
            material_info (ComponentMaterialInfo): The desired material info to animate.
        """
        ...
    def set_material_index(self, material_index: int) -> None:
        r"""
        x.set_material_index(material_index) -> None
        Set Material Index
        deprecated: Use SetMaterialInfo instead
        
        Args:
            material_index (int32):
        """
        ...
    def get_material_info(self) -> ComponentMaterialInfo:
        r"""
        x.get_material_info() -> ComponentMaterialInfo
        Get material info of the component that is animated by the material track.
        deprecated: Use SetMaterialInfo instead
        
        Returns:
            ComponentMaterialInfo: The material info.
        """
        ...
    def get_material_index(self) -> int:
        r"""
        x.get_material_index() -> int32
        Get Material Index
        deprecated: Use SetMaterialInfo instead
        
        Returns:
            int32:
        """
        ...

class MovieSceneObjectPropertyTrack(MovieScenePropertyTrack):
    r"""
    Movie Scene Object Property Track
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneObjectPropertyTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    def set_object_property_class(self, property_class: Class) -> None:
        r"""
        x.set_object_property_class(property_class) -> None
        Set this object property track's property class
        
        Args:
            property_class (type(Class)): The property class to set
        """
        ...
    def get_object_property_class(self) -> Class:
        r"""
        x.get_object_property_class() -> type(Class)
        Get this object property track's property class
        
        Returns:
            type(Class): The property class for this object property track
        """
        ...

class MovieSceneParticleParameterTrack(MovieSceneNameableTrack):
    r"""
    Handles manipulation of material parameters in a movie scene.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneParticleParameterTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneParticleTrack(MovieSceneNameableTrack):
    r"""
    Handles triggering of particle emitters
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneParticleTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieScenePrimitiveMaterialTrack(MovieScenePropertyTrack):
    r"""
    Movie Scene Primitive Material Track
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieScenePrimitiveMaterialTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    def set_material_info(self, material_info: ComponentMaterialInfo) -> None:
        r"""
        x.set_material_info(material_info) -> None
        Set material info of the component that is animated by the material track.
        
        Args:
            material_info (ComponentMaterialInfo): The desired material info to animate.
        """
        ...
    def set_material_index(self, material_index: int) -> None:
        r"""
        x.set_material_index(material_index) -> None
        Set Material Index
        deprecated: Use SetMaterialInfo instead
        
        Args:
            material_index (int32):
        """
        ...
    def get_material_info(self) -> ComponentMaterialInfo:
        r"""
        x.get_material_info() -> ComponentMaterialInfo
        Get material info of the component that is animated by the material track.
        deprecated: Use SetMaterialInfo instead
        
        Returns:
            ComponentMaterialInfo: The material info.
        """
        ...
    def get_material_index(self) -> int:
        r"""
        x.get_material_index() -> int32
        Get Material Index
        deprecated: Use SetMaterialInfo instead
        
        Returns:
            int32:
        """
        ...

class MovieSceneSkeletalAnimationTrack(MovieSceneNameableTrack):
    r"""
    Handles animation of skeletal mesh actors
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneSkeletalAnimationTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_first_child_of_root`` (bool):  [Read-Write] Whether to blend and adjust the first child node with animation instead of the root, this should be true for blending when the root is static, false if the animations have proper root motion
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``show_root_motion_trail`` (bool):  [Read-Write] Whether to show the position of the root for this sections
    - ``swap_root_bone`` (SwapRootBone):  [Read-Write] If on the root bone transform will be swapped to the specified root
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    @property
    def swap_root_bone(self) -> SwapRootBone:
        r"""
        (SwapRootBone):  [Read-Write] If on the root bone transform will be swapped to the specified root
        """
        ...
    @swap_root_bone.setter
    def swap_root_bone(self, value: SwapRootBone) -> None:
        ...

class MovieSceneSlomoTrack(MovieSceneFloatTrack):
    r"""
    Implements a movie scene track that controls a movie scene's world time dilation.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneSlomoTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneStringTrack(MovieScenePropertyTrack):
    r"""
    Implements a movie scene track that holds a series of strings.
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneStringTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneTransformTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of 3D transform properties in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneTransformTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneFloatVectorTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of float vectors in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneVectorTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    def set_num_channels_used(self, num_channels_used: int) -> None:
        r"""
        x.set_num_channels_used(num_channels_used) -> None
        Set the number of channels used for this track
        
        Args:
            num_channels_used (int32): The number of channels to use for this track
        """
        ...
    def get_num_channels_used(self) -> int:
        r"""
        x.get_num_channels_used() -> int32
        Get the number of channels used for this track
        
        Returns:
            int32: The number of channels used for this track
        """
        ...

class MovieSceneVectorTrack(MovieSceneFloatVectorTrack):
    r"""
    deprecated: 'MovieSceneVectorTrack' was renamed to 'MovieSceneFloatVectorTrack'.
    """
    ...

class MovieSceneDoubleVectorTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of double vectors in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneVectorTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    def set_num_channels_used(self, num_channels_used: int) -> None:
        r"""
        x.set_num_channels_used(num_channels_used) -> None
        Set the number of channels used for this track
        
        Args:
            num_channels_used (int32): The number of channels to use for this track
        """
        ...
    def get_num_channels_used(self) -> int:
        r"""
        x.get_num_channels_used() -> int32
        Get the number of channels used for this track
        
        Returns:
            int32: The number of channels used for this track
        """
        ...

class MovieSceneVisibilityTrack(MovieScenePropertyTrack):
    r"""
    Handles manipulation of visibility properties in a movie scene
    
    **C++ Source:**
    
    - **Module**: MovieSceneTracks
    - **File**: MovieSceneVisibilityTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class EngineCustomTimeStep(Object):
    r"""
    A CustomTimeStep control the Engine Framerate/Timestep.
    This will update the FApp::CurrentTime/FApp::DeltaTime.
    This is useful when you want the engine to be synchronized with an external clock (genlock).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineCustomTimeStep.h
    
    """
    ...

class FixedFrameRateCustomTimeStep(EngineCustomTimeStep):
    r"""
    Class to control the Engine TimeStep via a FixedFrameRate
    
    **C++ Source:**
    
    - **Module**: TimeManagement
    - **File**: FixedFrameRateCustomTimeStep.h
    
    """
    ...

class GenlockedCustomTimeStep(FixedFrameRateCustomTimeStep):
    r"""
    Class to control the Engine Timestep from a Genlock signal.
    
    **C++ Source:**
    
    - **Module**: TimeManagement
    - **File**: GenlockedCustomTimeStep.h
    
    """
    ...

class GenlockedFixedRateCustomTimeStep(GenlockedCustomTimeStep):
    r"""
    Control the Engine TimeStep via a fixed frame rate.
    
    Philosophy:
    
      * Quantized increments but keeping up with platform time.
    
      * FApp::GetDeltaTime
          - Forced to a multiple of the desired FrameTime.
    
      * FApp::GetCurrentTime
          - Incremented in multiples of the desired FrameTime.
          - Corresponds to platform time minus any fractional FrameTime.
    
    **C++ Source:**
    
    - **Module**: TimeManagement
    - **File**: GenlockedFixedRateCustomTimeStep.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``force_single_frame_delta_time`` (bool):  [Read-Write] When true, delta time will always be 1/FrameRate, regardless of how much real time has elapsed
    - ``frame_rate`` (FrameRate):  [Read-Write] Desired frame rate
    - ``should_block`` (bool):  [Read-Write] Indicates that this custom time step should block to enforce the specified frame rate. Set to false if this is enforced elsewhere.
    """
    ...

class TimecodeProvider(Object):
    r"""
    A class responsible of fetching a timecode from a source.
    Note, FApp::GetTimecode and FApp::GetTimecodeFramerate should be used to retrieve
    the current system Timecode and Framerate.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimecodeProvider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_delay`` (float):  [Read-Write] Number of frames to subtract from the qualified frame time when GetDelayedQualifiedFrameTime or GetDelayedTimecode is called.
      see: GetDelayedQualifiedFrameTime, GetDelayedTimecode
    """
    def get_timecode(self) -> Timecode:
        r"""
        x.get_timecode() -> Timecode
        Return the frame time converted into a timecode value.
        
        Returns:
            Timecode:
        """
        ...
    def get_synchronization_state(self) -> TimecodeProviderSynchronizationState:
        r"""
        x.get_synchronization_state() -> TimecodeProviderSynchronizationState
        The state of the TimecodeProvider and if it's currently synchronized and the Timecode and FrameRate getters are valid.
        
        Returns:
            TimecodeProviderSynchronizationState:
        """
        ...
    def get_qualified_frame_time(self) -> QualifiedTime:
        r"""
        x.get_qualified_frame_time() -> QualifiedTime
        Return current frame time.
        Since it may be called several times per frame, it is suggested to return a cached value.
        
        Returns:
            QualifiedTime:
        """
        ...
    def get_frame_rate(self) -> FrameRate:
        r"""
        x.get_frame_rate() -> FrameRate
        Return the frame rate of the frame time.
        
        Returns:
            FrameRate:
        """
        ...
    def get_delayed_timecode(self) -> Timecode:
        r"""
        x.get_delayed_timecode() -> Timecode
        Return the delayed frame time converted into a timecode value.
        
        Returns:
            Timecode:
        """
        ...
    def get_delayed_qualified_frame_time(self) -> QualifiedTime:
        r"""
        x.get_delayed_qualified_frame_time() -> QualifiedTime
        Return current frame time with FrameDelay applied.
        Only assume valid when GetSynchronizationState() returns Synchronized.
        
        Returns:
            QualifiedTime:
        """
        ...
    def fetch_timecode(self) -> Optional[QualifiedTime]:
        r"""
        x.fetch_timecode() -> QualifiedTime or None
        Fetch current timecode from its source. e.g. From hardware/network/file/etc.
        It is recommended to cache the fetched timecode.
        
        Returns:
            QualifiedTime or None: 
        
            out_frame_time (QualifiedTime):
        """
        ...
    def fetch_and_update(self) -> None:
        r"""
        x.fetch_and_update() -> None
        Update the state of the provider. Call it to ensure timecode and state are updated.
        It is suggested to fetch timecode from its source and cache it for the getters.
        """
        ...

class GenlockedTimecodeProvider(TimecodeProvider):
    r"""
    This timecode provider base class will try to use the engine genlock sync to adjust its count.
    
    **C++ Source:**
    
    - **Module**: TimeManagement
    - **File**: GenlockedTimecodeProvider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_delay`` (float):  [Read-Write] Number of frames to subtract from the qualified frame time when GetDelayedQualifiedFrameTime or GetDelayedTimecode is called.
      see: GetDelayedQualifiedFrameTime, GetDelayedTimecode
    - ``use_genlock_to_count`` (bool):  [Read-Write] Use Genlock Sync to update Timecode count
    """
    ...

class TimeManagementLibrary(BlueprintFunctionLibrary):
    r"""
    Time Management Blueprint Library
    
    **C++ Source:**
    
    - **Module**: TimeManagement
    - **File**: TimeManagementBlueprintLibrary.h
    
    """
    @classmethod
    def transform_time(cls, source_time: FrameTime, source_rate: FrameRate, destination_rate: FrameRate) -> FrameTime:
        r"""
        X.transform_time(source_time, source_rate, destination_rate) -> FrameTime
        Converts the specified time from one framerate to another framerate. This is useful for converting between tick resolution and display rate.
        
        Args:
            source_time (FrameTime): 
            source_rate (FrameRate): 
            destination_rate (FrameRate): 
        
        Returns:
            FrameTime:
        """
        ...
    @classmethod
    def subtract_frame_number_integer(cls, a: FrameNumber, b: int) -> FrameNumber:
        r"""
        X.subtract_frame_number_integer(a, b) -> FrameNumber
        Subtraction (FrameNumber A - int B)
        
        Args:
            a (FrameNumber): 
            b (int32): 
        
        Returns:
            FrameNumber:
        """
        ...
    @classmethod
    def subtract_frame_number_frame_number(cls, a: FrameNumber, b: FrameNumber) -> FrameNumber:
        r"""
        X.subtract_frame_number_frame_number(a, b) -> FrameNumber
        Subtraction (FrameNumber A - FrameNumber B)
        
        Args:
            a (FrameNumber): 
            b (FrameNumber): 
        
        Returns:
            FrameNumber:
        """
        ...
    @classmethod
    def snap_frame_time_to_rate(cls, source_time: FrameTime, source_rate: FrameRate, snap_to_rate: FrameRate) -> FrameTime:
        r"""
        X.snap_frame_time_to_rate(source_time, source_rate, snap_to_rate) -> FrameTime
        Snaps the given SourceTime to the nearest frame in the specified Destination Framerate. Useful for determining the nearest frame for another resolution. Returns the frame time in the destination frame rate.
        
        Args:
            source_time (FrameTime): 
            source_rate (FrameRate): 
            snap_to_rate (FrameRate): 
        
        Returns:
            FrameTime:
        """
        ...
    @classmethod
    def multiply_seconds_frame_rate(cls, time_in_seconds: float, frame_rate: FrameRate) -> FrameTime:
        r"""
        X.multiply_seconds_frame_rate(time_in_seconds, frame_rate) -> FrameTime
        Multiplies a value in seconds against a FrameRate to get a new FrameTime.
        
        Args:
            time_in_seconds (float): 
            frame_rate (FrameRate): 
        
        Returns:
            FrameTime:
        """
        ...
    @classmethod
    def multiply_frame_number_integer(cls, a: FrameNumber, b: int) -> FrameNumber:
        r"""
        X.multiply_frame_number_integer(a, b) -> FrameNumber
        Multiply (FrameNumber A * B)
        
        Args:
            a (FrameNumber): 
            b (int32): 
        
        Returns:
            FrameNumber:
        """
        ...
    @classmethod
    def is_valid_multiple_of(cls, frame_rate: FrameRate, other_framerate: FrameRate) -> bool:
        r"""
        X.is_valid_multiple_of(frame_rate, other_framerate) -> bool
        Checks if this framerate is an even multiple of another framerate, ie: 60 is a multiple of 30, but 59.94 is not.
        
        Args:
            frame_rate (FrameRate): 
            other_framerate (FrameRate): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_framerate(cls, frame_rate: FrameRate) -> bool:
        r"""
        X.is_valid_framerate(frame_rate) -> bool
        Verifies that this is a valid framerate with a non-zero denominator.
        
        Args:
            frame_rate (FrameRate): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_timecode_frame_rate(cls) -> FrameRate:
        r"""
        X.get_timecode_frame_rate() -> FrameRate
        Gets the current timecode frame rate.
        
        Returns:
            FrameRate:
        """
        ...
    @classmethod
    def get_timecode(cls) -> Timecode:
        r"""
        X.get_timecode() -> Timecode
        Get the current timecode of the engine.
        
        Returns:
            Timecode:
        """
        ...
    @classmethod
    def divide_frame_number_integer(cls, a: FrameNumber, b: int) -> FrameNumber:
        r"""
        X.divide_frame_number_integer(a, b) -> FrameNumber
        Divide (FrameNumber A / B)
        
        Args:
            a (FrameNumber): 
            b (int32): 
        
        Returns:
            FrameNumber:
        """
        ...
    @classmethod
    def conv_timecode_to_string(cls, timecode: Timecode, force_sign_display: bool = False) -> str:
        r"""
        X.conv_timecode_to_string(timecode, force_sign_display=False) -> str
        Converts an Timecode to a string (hh:mm:ss:ff). If bForceSignDisplay then the number sign will always be prepended instead of just when expressing a negative time.
        
        Args:
            timecode (Timecode): 
            force_sign_display (bool): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_qualified_frame_time_to_seconds(cls, frame_time: QualifiedTime) -> float:
        r"""
        X.conv_qualified_frame_time_to_seconds(frame_time) -> float
        Converts an QualifiedFrameTime to seconds.
        
        Args:
            frame_time (QualifiedTime): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def conv_frame_rate_to_seconds(cls, frame_rate: FrameRate) -> float:
        r"""
        X.conv_frame_rate_to_seconds(frame_rate) -> float
        Conv Frame Rate to Seconds
        deprecated: FrameRateToInterval replaces this function, which returns the expected result of seconds per frame, rather than (incorrectly) frames per second.
        
        Args:
            frame_rate (FrameRate): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def conv_frame_rate_to_interval(cls, frame_rate: FrameRate) -> float:
        r"""
        X.conv_frame_rate_to_interval(frame_rate) -> float
        Converts a FrameRate to an interval float representing the frame time in seconds ie: 1/30 returns 0.0333333
        
        Args:
            frame_rate (FrameRate): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def frame_number_to_integer(cls, frame_number: FrameNumber) -> int:
        r"""
        X.frame_number_to_integer(frame_number) -> int32
        Converts a FrameNumber to an int32 for use in functions that take int32 frame counts for convenience.
        
        Args:
            frame_number (FrameNumber): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def add_frame_number_integer(cls, a: FrameNumber, b: int) -> FrameNumber:
        r"""
        X.add_frame_number_integer(a, b) -> FrameNumber
        Addition (FrameNumber A + int B)
        
        Args:
            a (FrameNumber): 
            b (int32): 
        
        Returns:
            FrameNumber:
        """
        ...
    @classmethod
    def add_frame_number_frame_number(cls, a: FrameNumber, b: FrameNumber) -> FrameNumber:
        r"""
        X.add_frame_number_frame_number(a, b) -> FrameNumber
        Addition (FrameNumber A + FrameNumber B)
        
        Args:
            a (FrameNumber): 
            b (FrameNumber): 
        
        Returns:
            FrameNumber:
        """
        ...

class MovieSceneBoundObjectProxy(Interface):
    r"""
    Movie Scene Bound Object Proxy
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: IMovieSceneBoundObjectProxy.h
    
    """
    def bp_get_bound_object_for_sequencer(self, resolved_object: Object) -> Object:
        r"""
        x.bp_get_bound_object_for_sequencer(resolved_object) -> Object
        Retrieve the bound object that this interface wants to animate. Could be 'this' or a transient child object.
        
        Args:
            resolved_object (Object): 
        
        Returns:
            Object: Pointer to the object that should be animated, or nullptr if it's not valid.
        """
        ...

class MovieSceneBindingEventReceiverInterface(Interface):
    r"""
    Movie Scene Binding Event Receiver Interface
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneBindingEventReceiverInterface.h
    
    """
    def on_object_unbound_by_sequencer(self, player: MovieSceneSequencePlayer, binding_id: MovieSceneObjectBindingID) -> None:
        r"""
        x.on_object_unbound_by_sequencer(player, binding_id) -> None
        On Object Unbound by Sequencer
        
        Args:
            player (MovieSceneSequencePlayer): 
            binding_id (MovieSceneObjectBindingID):
        """
        ...
    def on_object_bound_by_sequencer(self, player: MovieSceneSequencePlayer, binding_id: MovieSceneObjectBindingID) -> None:
        r"""
        x.on_object_bound_by_sequencer(player, binding_id) -> None
        On Object Bound by Sequencer
        
        Args:
            player (MovieSceneSequencePlayer): 
            binding_id (MovieSceneObjectBindingID):
        """
        ...

class MovieSceneEasingFunction(Interface):
    r"""
    Movie Scene Easing Function
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneEasingFunction.h
    
    """
    def on_evaluate(self, interp: float) -> float:
        r"""
        x.on_evaluate(interp) -> float
        Evaluate the easing with an interpolation value between 0 and 1
        
        Args:
            interp (float): 
        
        Returns:
            float:
        """
        ...

class MovieSceneBuiltInEasingFunction(Object):
    r"""
    Movie Scene Built in Easing Function
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneEasingCurves.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``type`` (MovieSceneBuiltInEasing):  [Read-Write]
    """
    def on_evaluate(self, interp: float) -> float:
        r"""
        x.on_evaluate(interp) -> float
        Evaluate the easing with an interpolation value between 0 and 1
        
        Args:
            interp (float): 
        
        Returns:
            float:
        """
        ...

class BuiltInDynamicBindingResolverLibrary(BlueprintFunctionLibrary):
    r"""
    Default dynamic binding resolver library, with several basic resolver functions.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneDynamicBinding.h
    
    """
    @classmethod
    def resolve_to_player_pawn(cls, world_context_object: Object, player_controller_index: int = 0) -> MovieSceneDynamicBindingResolveResult:
        r"""
        X.resolve_to_player_pawn(world_context_object, player_controller_index=0) -> MovieSceneDynamicBindingResolveResult
        Resolve the bound object to the player's pawn
        
        Args:
            world_context_object (Object): 
            player_controller_index (int32): 
        
        Returns:
            MovieSceneDynamicBindingResolveResult:
        """
        ...

class MovieSceneFolder(Object):
    r"""
    Represents a folder used for organizing objects in tracks in a movie scene.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneFolder.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``folder_color`` (Color):  [Read-Write] This folder's color
    """
    def set_folder_name(self, folder_name: Name) -> bool:
        r"""
        x.set_folder_name(folder_name) -> bool
        Set the name of the given folder
        
        Args:
            folder_name (Name): The new name for the folder
        
        Returns:
            bool: True if the setting of the folder name succeeds
        """
        ...
    def set_folder_color(self, folder_color: Color) -> bool:
        r"""
        x.set_folder_color(folder_color) -> bool
        Set the display color of the given folder
        
        Args:
            folder_color (Color): The new display color for the folder
        
        Returns:
            bool: True if the folder's display color is set successfully
        """
        ...
    def remove_child_track(self, track: MovieSceneTrack) -> bool:
        r"""
        x.remove_child_track(track) -> bool
        Remove a track from the given folder
        
        Args:
            track (MovieSceneTrack): The track to remove
        
        Returns:
            bool: True if the removal succeeds
        """
        ...
    def remove_child_object_binding(self, object_binding: MovieSceneBindingProxy) -> bool:
        r"""
        x.remove_child_object_binding(object_binding) -> bool
        Remove an object binding from the given folder
        
        Args:
            object_binding (MovieSceneBindingProxy): The object binding to remove
        
        Returns:
            bool: True if the operation succeeds
        """
        ...
    def remove_child_master_track(self, track: MovieSceneTrack) -> bool:
        r"""
        x.remove_child_master_track(track) -> bool
        Remove Child Master Track
        deprecated: RemoveChildMasterTrack is deprecated. Please use RemoveChildTrack instead
        
        Args:
            track (MovieSceneTrack): 
        
        Returns:
            bool:
        """
        ...
    def remove_child_folder(self, folder_to_remove: MovieSceneFolder) -> bool:
        r"""
        x.remove_child_folder(folder_to_remove) -> bool
        Remove a child folder from the given folder
        
        Args:
            folder_to_remove (MovieSceneFolder): The child folder to be removed
        
        Returns:
            bool: True if the removal succeeds
        """
        ...
    def get_folder_name(self) -> Name:
        r"""
        x.get_folder_name() -> Name
        Get the given folder's display name
        
        Returns:
            Name: The target folder's name
        """
        ...
    def get_folder_color(self) -> Color:
        r"""
        x.get_folder_color() -> Color
        Get the display color of the given folder
        
        Returns:
            Color: The display color of the given folder
        """
        ...
    def get_child_tracks(self) -> Array[MovieSceneTrack]:
        r"""
        x.get_child_tracks() -> Array[MovieSceneTrack]
        Get the tracks contained by this folder
        
        Returns:
            Array[MovieSceneTrack]: The tracks under the given folder
        """
        ...
    def get_child_object_bindings(self) -> Array[MovieSceneBindingProxy]:
        r"""
        x.get_child_object_bindings() -> Array[MovieSceneBindingProxy]
        Get the object bindings contained by this folder
        
        Returns:
            Array[MovieSceneBindingProxy]: The object bindings under the given folder
        """
        ...
    def get_child_master_tracks(self) -> Array[MovieSceneTrack]:
        r"""
        x.get_child_master_tracks() -> Array[MovieSceneTrack]
        Get Child Master Tracks
        deprecated: GetChildMasterTracks is deprecated. Please use GetChildTracks instead
        
        Returns:
            Array[MovieSceneTrack]:
        """
        ...
    def get_child_folders(self) -> Array[MovieSceneFolder]:
        r"""
        x.get_child_folders() -> Array[MovieSceneFolder]
        Get the child folders of a given folder
        
        Returns:
            Array[MovieSceneFolder]: The child folders associated with the given folder
        """
        ...
    def add_child_track(self, track: MovieSceneTrack) -> bool:
        r"""
        x.add_child_track(track) -> bool
        Add a track to this folder
        
        Args:
            track (MovieSceneTrack): The track to add to the folder
        
        Returns:
            bool: True if the addition is successful
        """
        ...
    def add_child_object_binding(self, object_binding: MovieSceneBindingProxy) -> bool:
        r"""
        x.add_child_object_binding(object_binding) -> bool
        Add a guid for an object binding to this folder
        
        Args:
            object_binding (MovieSceneBindingProxy): The binding to add to the folder
        
        Returns:
            bool: True if the addition is successful
        """
        ...
    def add_child_master_track(self, track: MovieSceneTrack) -> bool:
        r"""
        x.add_child_master_track(track) -> bool
        Add Child Master Track
        deprecated: AddChildMasterTrack is deprecated. Please use AddChildTrack instead
        
        Args:
            track (MovieSceneTrack): 
        
        Returns:
            bool:
        """
        ...
    def add_child_folder(self, folder_to_add: MovieSceneFolder) -> bool:
        r"""
        x.add_child_folder(folder_to_add) -> bool
        Add a child folder to the target folder
        
        Args:
            folder_to_add (MovieSceneFolder): The child folder to be added
        
        Returns:
            bool: True if the addition is successful
        """
        ...

class MovieSceneMetaData(Object):
    r"""
    Movie scene meta-data that is stored on UMovieScene assets
    Meta-data is retrieved through ULevelSequence::FindMetaData<ULevelSequenceMetaData>()
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneMetaData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``author`` (str):  [Read-Write] The author that created this metadata
    - ``created`` (DateTime):  [Read-Write] The created date at which the metadata was initiated
    - ``notes`` (str):  [Read-Write] Notes for the metadata
    """
    def set_notes(self, notes: str) -> None:
        r"""
        x.set_notes(notes) -> None
        Set this metadata's notes
        
        Args:
            notes (str):
        """
        ...
    def set_created(self, created: DateTime) -> None:
        r"""
        x.set_created(created) -> None
        Set this metadata's created date
        
        Args:
            created (DateTime):
        """
        ...
    def set_author(self, author: str) -> None:
        r"""
        x.set_author(author) -> None
        Set this metadata's author
        
        Args:
            author (str):
        """
        ...
    def get_notes(self) -> str:
        r"""
        x.get_notes() -> str
        
        
        Returns:
            str: The notes for this metadata
        """
        ...
    def get_created(self) -> DateTime:
        r"""
        x.get_created() -> DateTime
        
        
        Returns:
            DateTime: The created date for this metadata
        """
        ...
    def get_author(self) -> str:
        r"""
        x.get_author() -> str
        
        
        Returns:
            str: The author for this metadata
        """
        ...

class MovieSceneSequencePlayer(Object):
    r"""
    Abstract class that provides consistent player behaviour for various animation players
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSequencePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_finished`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player finishes naturally (without explicitly calling stop)
    - ``on_pause`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is paused
    - ``on_play`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is played
    - ``on_play_reverse`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is played in reverse
    - ``on_stop`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is stopped
    """
    @property
    def on_play(self) -> OnMovieSceneSequencePlayerEvent:
        r"""
        (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is played
        """
        ...
    @on_play.setter
    def on_play(self, value: OnMovieSceneSequencePlayerEvent) -> None:
        ...
    @property
    def on_play_reverse(self) -> OnMovieSceneSequencePlayerEvent:
        r"""
        (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is played in reverse
        """
        ...
    @on_play_reverse.setter
    def on_play_reverse(self, value: OnMovieSceneSequencePlayerEvent) -> None:
        ...
    @property
    def on_stop(self) -> OnMovieSceneSequencePlayerEvent:
        r"""
        (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is stopped
        """
        ...
    @on_stop.setter
    def on_stop(self, value: OnMovieSceneSequencePlayerEvent) -> None:
        ...
    @property
    def on_pause(self) -> OnMovieSceneSequencePlayerEvent:
        r"""
        (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is paused
        """
        ...
    @on_pause.setter
    def on_pause(self, value: OnMovieSceneSequencePlayerEvent) -> None:
        ...
    @property
    def on_finished(self) -> OnMovieSceneSequencePlayerEvent:
        r"""
        (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player finishes naturally (without explicitly calling stop)
        """
        ...
    @on_finished.setter
    def on_finished(self, value: OnMovieSceneSequencePlayerEvent) -> None:
        ...
    def stop_at_current_time(self) -> None:
        r"""
        x.stop_at_current_time() -> None
        Stop playback without moving the cursor.
        """
        ...
    def stop(self) -> None:
        r"""
        x.stop() -> None
        Stop playback and move the cursor to the end (or start, for reversed playback) of the sequence.
        """
        ...
    def set_weight(self, weight: float) -> None:
        r"""
        x.set_weight(weight) -> None
        Set a manual weight to be multiplied with all blendable elements within this sequence
        note:: It is recommended that a weight between 0 and 1 is supplied, though this is not enforced
        note:: It is recommended that either FMovieSceneSequencePlaybackSettings::DynamicWeighting should be true for this player or the asset it's playing back should be set to enable dynamic weight to avoid undesirable behavior
        
        Args:
            weight (double): The weight to suuply to all elements in this sequence
        """
        ...
    def set_time_range(self, start_time: float, duration: float) -> None:
        r"""
        x.set_time_range(start_time, duration) -> None
        Set the valid play range for this sequence, determined by a starting time  and a duration (in seconds)
        
        Args:
            start_time (float): The time to start playing back the sequence in seconds
            duration (float): The length to play for
        """
        ...
    def set_play_rate(self, play_rate: float) -> None:
        r"""
        x.set_play_rate(play_rate) -> None
        Set the playback rate of this player. Negative values will play the animation in reverse.
        
        Args:
            play_rate (float): The new rate of playback for the animation.
        """
        ...
    def set_playback_position(self, playback_params: MovieSceneSequencePlaybackParams) -> None:
        r"""
        x.set_playback_position(playback_params) -> None
        Set the current time of the player by evaluating from the current time to the specified time, as if the sequence is playing.
        Triggers events that lie within the evaluated range. Does not alter the persistent playback status of the player (IsPlaying).
        
        Args:
            playback_params (MovieSceneSequencePlaybackParams): The position settings (ie. the position to set playback to)
        """
        ...
    def set_frame_rate(self, frame_rate: FrameRate) -> None:
        r"""
        x.set_frame_rate(frame_rate) -> None
        Set the frame-rate that this player should play with, making all frame numbers in the specified time-space
        
        Args:
            frame_rate (FrameRate):
        """
        ...
    def set_frame_range(self, start_frame: int, duration: int, sub_frames: float = 0.000000) -> None:
        r"""
        x.set_frame_range(start_frame, duration, sub_frames=0.000000) -> None
        Set the valid play range for this sequence, determined by a starting frame number (in this sequence player's plaback frame), and a number of frames duration
        
        Args:
            start_frame (int32): The frame number to start playing back the sequence
            duration (int32): The number of frames to play
            sub_frames (float):
        """
        ...
    def set_disable_camera_cuts(self, disable_camera_cuts: bool) -> None:
        r"""
        x.set_disable_camera_cuts(disable_camera_cuts) -> None
        Set whether to disable camera cuts
        
        Args:
            disable_camera_cuts (bool):
        """
        ...
    def set_completion_mode_override(self, completion_mode_override: MovieSceneCompletionModeOverride) -> None:
        r"""
        x.set_completion_mode_override(completion_mode_override) -> None
        Set the state of the completion mode override. Note, setting the state to force restore state will only take effect if the sequence hasn't started playing
        
        Args:
            completion_mode_override (MovieSceneCompletionModeOverride):
        """
        ...
    def scrub(self) -> None:
        r"""
        x.scrub() -> None
        Scrub playback.
        """
        ...
    def restore_state(self) -> None:
        r"""
        x.restore_state() -> None
        Restore any changes made by this player to their original state
        """
        ...
    def remove_weight(self) -> None:
        r"""
        x.remove_weight() -> None
        Removes a previously assigned weight
        """
        ...
    def play_to(self, playback_params: MovieSceneSequencePlaybackParams, play_to_params: MovieSceneSequencePlayToParams) -> None:
        r"""
        x.play_to(playback_params, play_to_params) -> None
        Play from the current position to the requested position and pause. If requested position is before the current position,
        playback will be reversed. Playback to the requested position will be cancelled if Stop() or Pause() is invoked during this
        playback.
        
        Args:
            playback_params (MovieSceneSequencePlaybackParams): The position settings (ie. the position to play to)
            play_to_params (MovieSceneSequencePlayToParams):
        """
        ...
    def play_reverse(self) -> None:
        r"""
        x.play_reverse() -> None
        Reverse playback.
        """
        ...
    def play_looping(self, num_loops: int = -1) -> None:
        r"""
        x.play_looping(num_loops=-1) -> None
        Start playback from the current time cursor position, looping the specified number of times.
        
        Args:
            num_loops (int32): The number of loops to play. -1 indicates infinite looping.
        """
        ...
    def play(self) -> None:
        r"""
        x.play() -> None
        Start playback forwards from the current time cursor position, using the current play rate.
        """
        ...
    def pause(self) -> None:
        r"""
        x.pause() -> None
        Pause playback.
        """
        ...
    def is_reversed(self) -> bool:
        r"""
        x.is_reversed() -> bool
        Check whether playback is reversed.
        
        Returns:
            bool:
        """
        ...
    def is_playing(self) -> bool:
        r"""
        x.is_playing() -> bool
        Check whether the sequence is actively playing.
        
        Returns:
            bool:
        """
        ...
    def is_paused(self) -> bool:
        r"""
        x.is_paused() -> bool
        Check whether the sequence is paused.
        
        Returns:
            bool:
        """
        ...
    def go_to_end_and_stop(self) -> None:
        r"""
        x.go_to_end_and_stop() -> None
        Go to end of the sequence and stop. Adheres to 'When Finished' section rules.
        """
        ...
    def get_start_time(self) -> QualifiedTime:
        r"""
        x.get_start_time() -> QualifiedTime
        Get the offset within the level sequence to start playing
        
        Returns:
            QualifiedTime:
        """
        ...
    def get_sequence_name(self, add_client_info: bool = False) -> str:
        r"""
        x.get_sequence_name(add_client_info=False) -> str
        Get the name of the sequence this player is playing
        
        Args:
            add_client_info (bool): If true, add client index if running as a client
        
        Returns:
            str: the name of the sequence, or None if no sequence is set
        """
        ...
    def get_sequence(self) -> MovieSceneSequence:
        r"""
        x.get_sequence() -> MovieSceneSequence
        Access the sequence this player is playing
        
        Returns:
            MovieSceneSequence: the sequence currently assigned to this player
        """
        ...
    def get_play_rate(self) -> float:
        r"""
        x.get_play_rate() -> float
        Get the playback rate of this player.
        
        Returns:
            float:
        """
        ...
    def get_object_bindings(self, object: Object) -> Array[MovieSceneObjectBindingID]:
        r"""
        x.get_object_bindings(object) -> Array[MovieSceneObjectBindingID]
        Get the object bindings for the requested object
        
        Args:
            object (Object): 
        
        Returns:
            Array[MovieSceneObjectBindingID]:
        """
        ...
    def get_frame_rate(self) -> FrameRate:
        r"""
        x.get_frame_rate() -> FrameRate
        Get this sequence's display rate.
        
        Returns:
            FrameRate:
        """
        ...
    def get_frame_duration(self) -> int:
        r"""
        x.get_frame_duration() -> int32
        Get this sequence's duration in frames
        
        Returns:
            int32:
        """
        ...
    def get_end_time(self) -> QualifiedTime:
        r"""
        x.get_end_time() -> QualifiedTime
        Get the offset within the level sequence to finish playing
        
        Returns:
            QualifiedTime:
        """
        ...
    def get_duration(self) -> QualifiedTime:
        r"""
        x.get_duration() -> QualifiedTime
        Get the total duration of the sequence
        
        Returns:
            QualifiedTime:
        """
        ...
    def get_disable_camera_cuts(self) -> bool:
        r"""
        x.get_disable_camera_cuts() -> bool
        Set whether to disable camera cuts
        
        Returns:
            bool:
        """
        ...
    def get_current_time(self) -> QualifiedTime:
        r"""
        x.get_current_time() -> QualifiedTime
        Get the current playback position
        
        Returns:
            QualifiedTime: The current playback position
        """
        ...
    def get_completion_mode_override(self) -> MovieSceneCompletionModeOverride:
        r"""
        x.get_completion_mode_override() -> MovieSceneCompletionModeOverride
        Get the state of the completion mode override
        
        Returns:
            MovieSceneCompletionModeOverride:
        """
        ...
    def get_bound_objects(self, object_binding: MovieSceneObjectBindingID) -> Array[Object]:
        r"""
        x.get_bound_objects(object_binding) -> Array[Object]
        Retrieve all objects currently bound to the specified binding identifier
        
        Args:
            object_binding (MovieSceneObjectBindingID): 
        
        Returns:
            Array[Object]:
        """
        ...
    def change_playback_direction(self) -> None:
        r"""
        x.change_playback_direction() -> None
        Changes the direction of playback (go in reverse if it was going forward, or vice versa)
        """
        ...

class MovieSceneBindingLifetimeSection(MovieSceneSection):
    r"""
    Binding lifetime section that will connect an object binding while active, and disconnect it afterwards.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneBindingLifetimeSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneHookSection(MovieSceneSection):
    r"""
    Movie Scene Hook Section
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneHookSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneSpawnSection(MovieSceneBoolSection):
    r"""
    A spawn section.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSpawnSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class TestMovieSceneTrack(MovieSceneTrack):
    r"""
    Test Movie Scene Track
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneTestObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class TestMovieSceneSection(MovieSceneSection):
    r"""
    Test Movie Scene Section
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneTestObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class TestMovieSceneSequence(MovieSceneSequence):
    r"""
    Test Movie Scene Sequence
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneTestObjects.h
    
    """
    ...

class TestMovieSceneSubTrack(MovieSceneSubTrack):
    r"""
    Test Movie Scene Sub Track
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneTestObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class TestMovieSceneSubSection(MovieSceneSubSection):
    r"""
    Test Movie Scene Sub Section
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneTestObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``network_mask`` (uint8):  [Read-Write]
    - ``parameters`` (MovieSceneSectionParameters):  [Read-Write]
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``sub_sequence`` (MovieSceneSequence):  [Read-Write] Movie scene being played by this section
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class TestMovieSceneEvalHookTrack(MovieSceneTrack):
    r"""
    Test Movie Scene Eval Hook Track
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneTestObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class TestMovieSceneEvalHookSection(MovieSceneHookSection):
    r"""
    Test Movie Scene Eval Hook Section
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneTestObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneBindingLifetimeTrack(MovieSceneTrack):
    r"""
    Handles when an object binding should be activated/deactivated
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneBindingLifetimeTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneSpawnTrack(MovieSceneTrack):
    r"""
    Handles when a spawnable should be spawned and destroyed
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneSpawnTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class AudioLinkBlueprintInterface(Interface):
    r"""
    Audio Link Blueprint Interface
    
    **C++ Source:**
    
    - **Module**: AudioLinkEngine
    - **File**: IAudioLinkBlueprintInterface.h
    
    """
    def stop_link(self) -> None:
        r"""
        x.stop_link() -> None
        Stop an audio component's sound, issue any delegates if needed
        """
        ...
    def set_link_sound(self, new_sound: SoundBase) -> None:
        r"""
        x.set_link_sound(new_sound) -> None
        Set Link Sound
        
        Args:
            new_sound (SoundBase):
        """
        ...
    def play_link(self, start_time: float = 0.000000) -> None:
        r"""
        x.play_link(start_time=0.000000) -> None
        Play Link
        
        Args:
            start_time (float):
        """
        ...
    def is_link_playing(self) -> bool:
        r"""
        x.is_link_playing() -> bool
        Is Link Playing
        
        Returns:
            bool:
        """
        ...

class AudioDeviceNotificationSubsystem(EngineSubsystem):
    r"""
    UAudioDeviceNotificationSubsystem
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioDeviceNotificationSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_capture_device_changed`` (OnAudioDefaultDeviceChanged):  [Read-Write] Multicast delegate triggered when default capture device changes
    - ``default_render_device_changed`` (OnAudioDefaultDeviceChanged):  [Read-Write] Multicast delegate triggered when default render device changes
    - ``device_added`` (OnAudioDeviceChange):  [Read-Write] Multicast delegate triggered when a device is added
    - ``device_removed`` (OnAudioDeviceChange):  [Read-Write] Multicast delegate triggered when a device is removed
    - ``device_state_changed`` (OnAudioDeviceStateChanged):  [Read-Write] Multicast delegate triggered on device state change
    - ``device_switched`` (OnAudioDeviceChange):  [Read-Write] Multicast delegate triggered on device switch
    """
    @property
    def default_capture_device_changed(self) -> OnAudioDefaultDeviceChanged:
        r"""
        (OnAudioDefaultDeviceChanged):  [Read-Write] Multicast delegate triggered when default capture device changes
        """
        ...
    @default_capture_device_changed.setter
    def default_capture_device_changed(self, value: OnAudioDefaultDeviceChanged) -> None:
        ...
    @property
    def default_render_device_changed(self) -> OnAudioDefaultDeviceChanged:
        r"""
        (OnAudioDefaultDeviceChanged):  [Read-Write] Multicast delegate triggered when default render device changes
        """
        ...
    @default_render_device_changed.setter
    def default_render_device_changed(self, value: OnAudioDefaultDeviceChanged) -> None:
        ...
    @property
    def device_added(self) -> OnAudioDeviceChange:
        r"""
        (OnAudioDeviceChange):  [Read-Write] Multicast delegate triggered when a device is added
        """
        ...
    @device_added.setter
    def device_added(self, value: OnAudioDeviceChange) -> None:
        ...
    @property
    def device_removed(self) -> OnAudioDeviceChange:
        r"""
        (OnAudioDeviceChange):  [Read-Write] Multicast delegate triggered when a device is removed
        """
        ...
    @device_removed.setter
    def device_removed(self, value: OnAudioDeviceChange) -> None:
        ...
    @property
    def device_state_changed(self) -> OnAudioDeviceStateChanged:
        r"""
        (OnAudioDeviceStateChanged):  [Read-Write] Multicast delegate triggered on device state change
        """
        ...
    @device_state_changed.setter
    def device_state_changed(self, value: OnAudioDeviceStateChanged) -> None:
        ...
    @property
    def device_switched(self) -> OnAudioDeviceChange:
        r"""
        (OnAudioDeviceChange):  [Read-Write] Multicast delegate triggered on device switch
        """
        ...
    @device_switched.setter
    def device_switched(self, value: OnAudioDeviceChange) -> None:
        ...

class AudioMixerLibrary(BlueprintFunctionLibrary):
    r"""
    Audio Mixer Blueprint Library
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerBlueprintLibrary.h
    
    """
    @classmethod
    def unregister_audio_bus_from_submix(cls, world_context_object: Object, sound_submix: SoundSubmix, audio_bus: AudioBus) -> None:
        r"""
        X.unregister_audio_bus_from_submix(world_context_object, sound_submix, audio_bus) -> None
        Unregisters an audio bus that could have been registered to a submix.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix): 
            audio_bus (AudioBus):
        """
        ...
    @classmethod
    def trim_audio_cache(cls, megabytes_to_free: float) -> float:
        r"""
        X.trim_audio_cache(megabytes_to_free) -> float
        Trim memory used by the audio cache. Returns the number of megabytes freed.
        
        Args:
            megabytes_to_free (float): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def swap_audio_output_device(cls, world_context_object: Object, new_device_id: str, on_completed_device_swap: OnCompletedDeviceSwap) -> None:
        r"""
        X.swap_audio_output_device(world_context_object, new_device_id, on_completed_device_swap) -> None
        Hotswaps to the requested audio output device
        
        Args:
            world_context_object (Object): 
            new_device_id (str): the device Id to swap to
            on_completed_device_swap (OnCompletedDeviceSwap): the event to fire when the audio endpoint devices have been retrieved
        """
        ...
    @classmethod
    def stop_recording_output(cls, world_context_object: Object, export_type: AudioRecordingExportType, name: str, path: str, submix_to_record: SoundSubmix = None, existing_sound_wave_to_overwrite: SoundWave = None) -> SoundWave:
        r"""
        X.stop_recording_output(world_context_object, export_type, name, path, submix_to_record=None, existing_sound_wave_to_overwrite=None) -> SoundWave
        Stop recording audio. Path can be absolute, or relative (to the /Saved/BouncedWavFiles folder). By leaving the Submix To Record field blank, you can record the master output of the game.
        
        Args:
            world_context_object (Object): 
            export_type (AudioRecordingExportType): 
            name (str): 
            path (str): 
            submix_to_record (SoundSubmix): 
            existing_sound_wave_to_overwrite (SoundWave): 
        
        Returns:
            SoundWave:
        """
        ...
    @classmethod
    def stop_audio_bus(cls, world_context_object: Object, audio_bus: AudioBus) -> None:
        r"""
        X.stop_audio_bus(world_context_object, audio_bus) -> None
        Stops the given audio bus.
        
        Args:
            world_context_object (Object): 
            audio_bus (AudioBus):
        """
        ...
    @classmethod
    def stop_analyzing_output(cls, world_context_object: Object, submix_to_stop_analyzing: SoundSubmix = None) -> None:
        r"""
        X.stop_analyzing_output(world_context_object, submix_to_stop_analyzing=None) -> None
        Stop spectrum analysis.
        
        Args:
            world_context_object (Object): 
            submix_to_stop_analyzing (SoundSubmix):
        """
        ...
    @classmethod
    def start_recording_output(cls, world_context_object: Object, expected_duration: float, submix_to_record: SoundSubmix = None) -> None:
        r"""
        X.start_recording_output(world_context_object, expected_duration, submix_to_record=None) -> None
        Start recording audio. By leaving the Submix To Record field blank, you can record the master output of the game.
        
        Args:
            world_context_object (Object): 
            expected_duration (float): 
            submix_to_record (SoundSubmix):
        """
        ...
    @classmethod
    def start_audio_bus(cls, world_context_object: Object, audio_bus: AudioBus) -> None:
        r"""
        X.start_audio_bus(world_context_object, audio_bus) -> None
        Starts the given audio bus.
        
        Args:
            world_context_object (Object): 
            audio_bus (AudioBus):
        """
        ...
    @classmethod
    def start_analyzing_output(cls, world_context_object: Object, submix_to_analyze: SoundSubmix = None, fft_size: FFTSize = FFTSize.DEFAULT_SIZE, interpolation_method: FFTPeakInterpolationMethod = FFTPeakInterpolationMethod.LINEAR, window_type: FFTWindowType = FFTWindowType.HANN, hop_size: float = 0.000000, spectrum_type: AudioSpectrumType = AudioSpectrumType.MAGNITUDE_SPECTRUM) -> None:
        r"""
        X.start_analyzing_output(world_context_object, submix_to_analyze=None, fft_size=FFTSize.DEFAULT_SIZE, interpolation_method=FFTPeakInterpolationMethod.LINEAR, window_type=FFTWindowType.HANN, hop_size=0.000000, spectrum_type=AudioSpectrumType.MAGNITUDE_SPECTRUM) -> None
        Start spectrum analysis of the audio output. By leaving the Submix To Analyze blank, you can analyze the master output of the game.
        
        Args:
            world_context_object (Object): 
            submix_to_analyze (SoundSubmix): 
            fft_size (FFTSize): 
            interpolation_method (FFTPeakInterpolationMethod): 
            window_type (FFTWindowType): 
            hop_size (float): 
            spectrum_type (AudioSpectrumType):
        """
        ...
    @classmethod
    def set_submix_effect_chain_override(cls, world_context_object: Object, sound_submix: SoundSubmix, submix_effect_preset_chain: Array[SoundEffectSubmixPreset], fade_time_sec: float) -> None:
        r"""
        X.set_submix_effect_chain_override(world_context_object, sound_submix, submix_effect_preset_chain, fade_time_sec) -> None
        Sets a submix effect chain override on the given submix. The effect chain will cross fade from the base effect chain or current override to the new override.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix): 
            submix_effect_preset_chain (Array[SoundEffectSubmixPreset]): 
            fade_time_sec (float):
        """
        ...
    @classmethod
    def set_bypass_source_effect_chain_entry(cls, world_context_object: Object, preset_chain: SoundEffectSourcePresetChain, entry_index: int, bypassed: bool) -> None:
        r"""
        X.set_bypass_source_effect_chain_entry(world_context_object, preset_chain, entry_index, bypassed) -> None
        Set whether or not to bypass the effect at the source effect chain index.
        
        Args:
            world_context_object (Object): 
            preset_chain (SoundEffectSourcePresetChain): 
            entry_index (int32): 
            bypassed (bool):
        """
        ...
    @classmethod
    def resume_recording_output(cls, world_context_object: Object, submix_to_pause: SoundSubmix = None) -> None:
        r"""
        X.resume_recording_output(world_context_object, submix_to_pause=None) -> None
        Resume recording audio after pausing. By leaving the Submix To Pause field blank, you can record the master output of the game.
        
        Args:
            world_context_object (Object): 
            submix_to_pause (SoundSubmix):
        """
        ...
    @classmethod
    def replace_submix_effect(cls, world_context_object: Object, sound_submix: SoundSubmix, submix_chain_index: int, submix_effect_preset: SoundEffectSubmixPreset) -> None:
        r"""
        X.replace_submix_effect(world_context_object, sound_submix, submix_chain_index, submix_effect_preset) -> None
        Replaces the submix effect at the given submix chain index, adds the effect if there is none at that index.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix): 
            submix_chain_index (int32): 
            submix_effect_preset (SoundEffectSubmixPreset):
        """
        ...
    @classmethod
    def replace_sound_effect_submix(cls, world_context_object: Object, sound_submix: SoundSubmix, submix_chain_index: int, submix_effect_preset: SoundEffectSubmixPreset) -> None:
        r"""
        X.replace_sound_effect_submix(world_context_object, sound_submix, submix_chain_index, submix_effect_preset) -> None
        Replace Sound Effect Submix
        deprecated: Function 'ReplaceSoundEffectSubmix' is deprecated.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix): 
            submix_chain_index (int32): 
            submix_effect_preset (SoundEffectSubmixPreset):
        """
        ...
    @classmethod
    def remove_submix_effect_preset_at_index(cls, world_context_object: Object, sound_submix: SoundSubmix, submix_chain_index: int) -> None:
        r"""
        X.remove_submix_effect_preset_at_index(world_context_object, sound_submix, submix_chain_index) -> None
        Remove Submix Effect Preset at Index
        deprecated: Function 'RemoveSubmixEffectPresetAtIndex' is deprecated.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix): 
            submix_chain_index (int32):
        """
        ...
    @classmethod
    def remove_submix_effect_preset(cls, world_context_object: Object, sound_submix: SoundSubmix, submix_effect_preset: SoundEffectSubmixPreset) -> None:
        r"""
        X.remove_submix_effect_preset(world_context_object, sound_submix, submix_effect_preset) -> None
        Remove Submix Effect Preset
        deprecated: Function 'RemoveSubmixEffectPreset' is deprecated.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix): 
            submix_effect_preset (SoundEffectSubmixPreset):
        """
        ...
    @classmethod
    def remove_submix_effect_at_index(cls, world_context_object: Object, sound_submix: SoundSubmix, submix_chain_index: int) -> None:
        r"""
        X.remove_submix_effect_at_index(world_context_object, sound_submix, submix_chain_index) -> None
        Removes the submix effect at the given submix chain index, if there is a submix effect at that index.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix): 
            submix_chain_index (int32):
        """
        ...
    @classmethod
    def remove_submix_effect(cls, world_context_object: Object, sound_submix: SoundSubmix, submix_effect_preset: SoundEffectSubmixPreset) -> None:
        r"""
        X.remove_submix_effect(world_context_object, sound_submix, submix_effect_preset) -> None
        Removes all instances of a submix effect preset from the given submix.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix): 
            submix_effect_preset (SoundEffectSubmixPreset):
        """
        ...
    @classmethod
    def remove_source_effect_from_preset_chain(cls, world_context_object: Object, preset_chain: SoundEffectSourcePresetChain, entry_index: int) -> None:
        r"""
        X.remove_source_effect_from_preset_chain(world_context_object, preset_chain, entry_index) -> None
        Removes source effect entry from preset chain. Only affects the instance of preset chain.
        
        Args:
            world_context_object (Object): 
            preset_chain (SoundEffectSourcePresetChain): 
            entry_index (int32):
        """
        ...
    @classmethod
    def remove_master_submix_effect(cls, world_context_object: Object, submix_effect_preset: SoundEffectSubmixPreset) -> None:
        r"""
        X.remove_master_submix_effect(world_context_object, submix_effect_preset) -> None
        Removes a submix effect preset from the master submix.
        
        Args:
            world_context_object (Object): 
            submix_effect_preset (SoundEffectSubmixPreset):
        """
        ...
    @classmethod
    def register_audio_bus_to_submix(cls, world_context_object: Object, sound_submix: SoundSubmix, audio_bus: AudioBus) -> None:
        r"""
        X.register_audio_bus_to_submix(world_context_object, sound_submix, audio_bus) -> None
        Registers an audio bus to a submix so the submix output can be routed to the audiobus.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix): 
            audio_bus (AudioBus):
        """
        ...
    @classmethod
    def prime_sound_for_playback(cls, sound_wave: SoundWave, on_load_completion: OnSoundLoadComplete) -> None:
        r"""
        X.prime_sound_for_playback(sound_wave, on_load_completion) -> None
        Begin loading a sound into the cache so that it can be played immediately.
        
        Args:
            sound_wave (SoundWave): 
            on_load_completion (OnSoundLoadComplete):
        """
        ...
    @classmethod
    def prime_sound_cue_for_playback(cls, sound_cue: SoundCue) -> None:
        r"""
        X.prime_sound_cue_for_playback(sound_cue) -> None
        Begin loading any sounds referenced by a sound cue into the cache so that it can be played immediately.
        
        Args:
            sound_cue (SoundCue):
        """
        ...
    @classmethod
    def pause_recording_output(cls, world_context_object: Object, submix_to_pause: SoundSubmix = None) -> None:
        r"""
        X.pause_recording_output(world_context_object, submix_to_pause=None) -> None
        Pause recording audio, without finalizing the recording to disk. By leaving the Submix To Record field blank, you can record the master output of the game.
        
        Args:
            world_context_object (Object): 
            submix_to_pause (SoundSubmix):
        """
        ...
    @classmethod
    def make_preset_spectral_analysis_band_settings(cls, band_preset_type: AudioSpectrumBandPresetType, num_bands: int = 10, attack_time_msec: int = 10, release_time_msec: int = 10) -> Array[SoundSubmixSpectralAnalysisBandSettings]:
        r"""
        X.make_preset_spectral_analysis_band_settings(band_preset_type, num_bands=10, attack_time_msec=10, release_time_msec=10) -> Array[SoundSubmixSpectralAnalysisBandSettings]
        Make an array of bands which span the frequency range of a given EAudioSpectrumBandPresetType.
        
        Args:
            band_preset_type (AudioSpectrumBandPresetType): The type audio content which the bands encompass.
            num_bands (int32): The number of bands used to represent the spectrum.
            attack_time_msec (int32): The attack time (in milliseconds) to apply to each band's envelope tracker.
            release_time_msec (int32): The release time (in milliseconds) to apply to each band's envelope tracker.
        
        Returns:
            Array[SoundSubmixSpectralAnalysisBandSettings]:
        """
        ...
    @classmethod
    def make_musical_spectral_analysis_band_settings(cls, num_semitones: int = 60, starting_musical_note: MusicalNoteName = MusicalNoteName.C, starting_octave: int = 2, attack_time_msec: int = 10, release_time_msec: int = 10) -> Array[SoundSubmixSpectralAnalysisBandSettings]:
        r"""
        X.make_musical_spectral_analysis_band_settings(num_semitones=60, starting_musical_note=MusicalNoteName.C, starting_octave=2, attack_time_msec=10, release_time_msec=10) -> Array[SoundSubmixSpectralAnalysisBandSettings]
        Make an array of musically spaced bands with ascending frequency.
        
        Args:
            num_semitones (int32): The number of semitones to represent.
            starting_musical_note (MusicalNoteName): 
            starting_octave (int32): The octave of the first note in the array.
            attack_time_msec (int32): The attack time (in milliseconds) to apply to each band's envelope tracker.
            release_time_msec (int32): The release time (in milliseconds) to apply to each band's envelope tracker.
        
        Returns:
            Array[SoundSubmixSpectralAnalysisBandSettings]:
        """
        ...
    @classmethod
    def make_full_spectrum_spectral_analysis_band_settings(cls, num_bands: int = 30, minimum_frequency: float = 40.000000, maximum_frequency: float = 16000.000000, attack_time_msec: int = 10, release_time_msec: int = 10) -> Array[SoundSubmixSpectralAnalysisBandSettings]:
        r"""
        X.make_full_spectrum_spectral_analysis_band_settings(num_bands=30, minimum_frequency=40.000000, maximum_frequency=16000.000000, attack_time_msec=10, release_time_msec=10) -> Array[SoundSubmixSpectralAnalysisBandSettings]
        Make an array of logarithmically spaced bands.
        
        Args:
            num_bands (int32): The number of bands to used to represent the spectrum.
            minimum_frequency (float): The center frequency of the first band.
            maximum_frequency (float): The center frequency of the last band.
            attack_time_msec (int32): The attack time (in milliseconds) to apply to each band's envelope tracker.
            release_time_msec (int32): The release time (in milliseconds) to apply to each band's envelope tracker.
        
        Returns:
            Array[SoundSubmixSpectralAnalysisBandSettings]:
        """
        ...
    @classmethod
    def is_audio_bus_active(cls, world_context_object: Object, audio_bus: AudioBus) -> bool:
        r"""
        X.is_audio_bus_active(world_context_object, audio_bus) -> bool
        Queries if the given audio bus is active (and audio can be mixed to it).
        
        Args:
            world_context_object (Object): 
            audio_bus (AudioBus): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_phase_for_frequencies(cls, world_context_object: Object, frequencies: Array[float], submix_to_analyze: SoundSubmix = None) -> Array[float]:
        r"""
        X.get_phase_for_frequencies(world_context_object, frequencies, submix_to_analyze=None) -> Array[float]
        Retrieve the phases for the given frequencies.
        
        Args:
            world_context_object (Object): 
            frequencies (Array[float]): 
            submix_to_analyze (SoundSubmix): 
        
        Returns:
            Array[float]: 
        
            phases (Array[float]):
        """
        ...
    @classmethod
    def get_number_of_entries_in_source_effect_chain(cls, world_context_object: Object, preset_chain: SoundEffectSourcePresetChain) -> int:
        r"""
        X.get_number_of_entries_in_source_effect_chain(world_context_object, preset_chain) -> int32
        Returns the number of effect chain entries in the given source effect chain.
        
        Args:
            world_context_object (Object): 
            preset_chain (SoundEffectSourcePresetChain): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_magnitude_for_frequencies(cls, world_context_object: Object, frequencies: Array[float], submix_to_analyze: SoundSubmix = None) -> Array[float]:
        r"""
        X.get_magnitude_for_frequencies(world_context_object, frequencies, submix_to_analyze=None) -> Array[float]
        Retrieve the magnitudes for the given frequencies.
        
        Args:
            world_context_object (Object): 
            frequencies (Array[float]): 
            submix_to_analyze (SoundSubmix): 
        
        Returns:
            Array[float]: 
        
            magnitudes (Array[float]):
        """
        ...
    @classmethod
    def get_current_audio_output_device_name(cls, world_context_object: Object, on_obtain_current_device_event: OnMainAudioOutputDeviceObtained) -> None:
        r"""
        X.get_current_audio_output_device_name(world_context_object, on_obtain_current_device_event) -> None
        Gets information about the currently used audio output device
        
        Args:
            world_context_object (Object): 
            on_obtain_current_device_event (OnMainAudioOutputDeviceObtained): the event to fire when the audio endpoint devices have been retrieved
        """
        ...
    @classmethod
    def get_available_audio_output_devices(cls, world_context_object: Object, on_obtain_devices_event: OnAudioOutputDevicesObtained) -> None:
        r"""
        X.get_available_audio_output_devices(world_context_object, on_obtain_devices_event) -> None
        Gets information about all audio output devices available in the system
        
        Args:
            world_context_object (Object): 
            on_obtain_devices_event (OnAudioOutputDevicesObtained): the event to fire when the audio endpoint devices have been retrieved
        """
        ...
    @classmethod
    def conv_audio_output_device_info_to_string(cls, info: AudioOutputDeviceInfo) -> str:
        r"""
        X.conv_audio_output_device_info_to_string(info) -> str
        Returns the device info in a human readable format
        
        Args:
            info (AudioOutputDeviceInfo): The audio device data to print
        
        Returns:
            str: The data in a string format
        """
        ...
    @classmethod
    def clear_submix_effects(cls, world_context_object: Object, sound_submix: SoundSubmix) -> None:
        r"""
        X.clear_submix_effects(world_context_object, sound_submix) -> None
        Clears all submix effects on the given submix.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix):
        """
        ...
    @classmethod
    def clear_submix_effect_chain_override(cls, world_context_object: Object, sound_submix: SoundSubmix, fade_time_sec: float) -> None:
        r"""
        X.clear_submix_effect_chain_override(world_context_object, sound_submix, fade_time_sec) -> None
        Clears all submix effect overrides on the given submix and returns it to the default effect chain.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix): 
            fade_time_sec (float):
        """
        ...
    @classmethod
    def clear_master_submix_effects(cls, world_context_object: Object) -> None:
        r"""
        X.clear_master_submix_effects(world_context_object) -> None
        Clears all master submix effects.
        
        Args:
            world_context_object (Object):
        """
        ...
    @classmethod
    def add_submix_effect(cls, world_context_object: Object, sound_submix: SoundSubmix, submix_effect_preset: SoundEffectSubmixPreset) -> int:
        r"""
        X.add_submix_effect(world_context_object, sound_submix, submix_effect_preset) -> int32
        Adds a submix effect preset to the given submix at the end of its submix effect chain. Returns the number of submix effects.
        
        Args:
            world_context_object (Object): 
            sound_submix (SoundSubmix): 
            submix_effect_preset (SoundEffectSubmixPreset): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def add_source_effect_to_preset_chain(cls, world_context_object: Object, preset_chain: SoundEffectSourcePresetChain, entry: SourceEffectChainEntry) -> None:
        r"""
        X.add_source_effect_to_preset_chain(world_context_object, preset_chain, entry) -> None
        Adds source effect entry to preset chain. Only effects the instance of the preset chain
        
        Args:
            world_context_object (Object): 
            preset_chain (SoundEffectSourcePresetChain): 
            entry (SourceEffectChainEntry):
        """
        ...
    @classmethod
    def add_master_submix_effect(cls, world_context_object: Object, submix_effect_preset: SoundEffectSubmixPreset) -> None:
        r"""
        X.add_master_submix_effect(world_context_object, submix_effect_preset) -> None
        Adds a submix effect preset to the master submix.
        
        Args:
            world_context_object (Object): 
            submix_effect_preset (SoundEffectSubmixPreset):
        """
        ...

class SoundBase(Object):
    r"""
    The base class for a playable sound object
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] Attenuation settings package for the sound
    - ``audio_properties_bindings`` (AudioPropertiesBindings):  [Read-Write]
    - ``audio_properties_sheet`` (AudioPropertiesSheetAssetBase):  [Read-Write]
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``bypass_volume_scale_for_priority`` (bool):  [Read-Write] Bypass volume weighting priority upon evaluating whether sound should remain active when max channel count is met (See platform Audio Settings).
    - ``concurrency_overrides`` (SoundConcurrencySettings):  [Read-Write] If Override Concurrency is true, concurrency settings to use.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] Set of concurrency settings to observe (if override is set to false).  Sound must pass all concurrency settings to play.
    - ``debug`` (bool):  [Read-Write] When "au.3dVisualize.Attenuation" has been specified, draw this sound's attenuation shape when the sound is audible. For debugging purposes only.
    - ``duration`` (float):  [Read-Only] Duration of sound in seconds.
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``max_distance`` (float):  [Read-Only] The max distance of the asset, as determined by attenuation settings.
    - ``override_concurrency`` (bool):  [Read-Write] Whether or not to override the sound concurrency object with local concurrency settings.
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``priority`` (float):  [Read-Write] Used to determine whether sound can play or remain active if channel limit is met, where higher value is higher priority
      (see platform's Audio Settings 'Max Channels' property). Unless bypassed, value is weighted with the final volume of the
      sound to produce final runtime priority value.
    - ``sound_class_object`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix_object`` (SoundSubmixBase):  [Read-Write] Submix to route sound output to. If unset, falls back to referenced SoundClass submix.
      If SoundClass submix is unset, sends to the 'Master Submix' as set in the 'Audio' category of Project Settings'.
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] Array of submix sends to which a prescribed amount (see 'Send Level') of this sound is sent.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``total_samples`` (float):  [Read-Only] Total number of samples (in the thousands). Useful as a metric to analyze the relative size of a given sound asset in content browser.
    - ``virtualization_mode`` (VirtualizationMode):  [Read-Write] Virtualization behavior, determining if a sound may revive and how it continues playing when culled or evicted (limited to looping sounds).
    """
    @property
    def sound_class_object(self) -> SoundClass:
        r"""
        (SoundClass):  [Read-Only] Sound class this sound belongs to
        """
        ...
    @property
    def override_concurrency(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to override the sound concurrency object with local concurrency settings.
        """
        ...
    @override_concurrency.setter
    def override_concurrency(self, value: bool) -> None:
        ...
    @property
    def enable_bus_sends(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
        """
        ...
    @enable_bus_sends.setter
    def enable_bus_sends(self, value: bool) -> None:
        ...
    @property
    def bypass_volume_scale_for_priority(self) -> bool:
        r"""
        (bool):  [Read-Write] Bypass volume weighting priority upon evaluating whether sound should remain active when max channel count is met (See platform Audio Settings).
        """
        ...
    @bypass_volume_scale_for_priority.setter
    def bypass_volume_scale_for_priority(self, value: bool) -> None:
        ...
    @property
    def virtualization_mode(self) -> VirtualizationMode:
        r"""
        (VirtualizationMode):  [Read-Write] Virtualization behavior, determining if a sound may revive and how it continues playing when culled or evicted (limited to looping sounds).
        """
        ...
    @virtualization_mode.setter
    def virtualization_mode(self, value: VirtualizationMode) -> None:
        ...
    @property
    def concurrency_set(self) -> Set[SoundConcurrency]:
        r"""
        (Set[SoundConcurrency]):  [Read-Write] Set of concurrency settings to observe (if override is set to false).  Sound must pass all concurrency settings to play.
        """
        ...
    @concurrency_set.setter
    def concurrency_set(self, value: Set[SoundConcurrency]) -> None:
        ...
    @property
    def concurrency_overrides(self) -> SoundConcurrencySettings:
        r"""
        (SoundConcurrencySettings):  [Read-Write] If Override Concurrency is true, concurrency settings to use.
        """
        ...
    @concurrency_overrides.setter
    def concurrency_overrides(self, value: SoundConcurrencySettings) -> None:
        ...
    @property
    def duration(self) -> float:
        r"""
        (float):  [Read-Only] Duration of sound in seconds.
        """
        ...
    @property
    def max_distance(self) -> float:
        r"""
        (float):  [Read-Only] The max distance of the asset, as determined by attenuation settings.
        """
        ...
    @property
    def total_samples(self) -> float:
        r"""
        (float):  [Read-Only] Total number of samples (in the thousands). Useful as a metric to analyze the relative size of a given sound asset in content browser.
        """
        ...
    @property
    def priority(self) -> float:
        r"""
        (float):  [Read-Write] Used to determine whether sound can play or remain active if channel limit is met, where higher value is higher priority
        (see platform's Audio Settings 'Max Channels' property). Unless bypassed, value is weighted with the final volume of the
        sound to produce final runtime priority value.
        """
        ...
    @priority.setter
    def priority(self, value: float) -> None:
        ...
    @property
    def sound_submix_object(self) -> SoundSubmixBase:
        r"""
        (SoundSubmixBase):  [Read-Write] Submix to route sound output to. If unset, falls back to referenced SoundClass submix.
        If SoundClass submix is unset, sends to the 'Master Submix' as set in the 'Audio' category of Project Settings'.
        """
        ...
    @sound_submix_object.setter
    def sound_submix_object(self, value: SoundSubmixBase) -> None:
        ...
    @property
    def sound_submix_sends(self) -> Array[SoundSubmixSendInfo]:
        r"""
        (Array[SoundSubmixSendInfo]):  [Read-Write] Array of submix sends to which a prescribed amount (see 'Send Level') of this sound is sent.
        """
        ...
    @sound_submix_sends.setter
    def sound_submix_sends(self, value: Array[SoundSubmixSendInfo]) -> None:
        ...
    @property
    def source_effect_chain(self) -> SoundEffectSourcePresetChain:
        r"""
        (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
        """
        ...
    @source_effect_chain.setter
    def source_effect_chain(self, value: SoundEffectSourcePresetChain) -> None:
        ...
    @property
    def bus_sends(self) -> Array[SoundSourceBusSendInfo]:
        r"""
        (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
        """
        ...
    @bus_sends.setter
    def bus_sends(self, value: Array[SoundSourceBusSendInfo]) -> None:
        ...
    @property
    def pre_effect_bus_sends(self) -> Array[SoundSourceBusSendInfo]:
        r"""
        (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
        """
        ...
    @pre_effect_bus_sends.setter
    def pre_effect_bus_sends(self, value: Array[SoundSourceBusSendInfo]) -> None:
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class SoundWave(SoundBase):
    r"""
    Sound Wave
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundWave.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] Attenuation settings package for the sound
    - ``audio_properties_bindings`` (AudioPropertiesBindings):  [Read-Write]
    - ``audio_properties_sheet`` (AudioPropertiesSheetAssetBase):  [Read-Write]
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``bypass_volume_scale_for_priority`` (bool):  [Read-Write] Bypass volume weighting priority upon evaluating whether sound should remain active when max channel count is met (See platform Audio Settings).
    - ``comment`` (str):  [Read-Write] Provides contextual information for the sound to the translator.
    - ``compression_quality`` (int32):  [Read-Write] Platform agnostic compression quality. 1..100 with 1 being best compression and 100 being best quality. ADPCM and PCM sound asset compression types ignore this parameter.
    - ``concurrency_overrides`` (SoundConcurrencySettings):  [Read-Write] If Override Concurrency is true, concurrency settings to use.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] Set of concurrency settings to observe (if override is set to false).  Sound must pass all concurrency settings to play.
    - ``cue_points`` (Array[SoundWaveCuePoint]):  [Read-Only] Cue point data parsed fro the .wav file. Contains "Loop Regions" as cue points as well!
    - ``curves`` (CurveTable):  [Read-Write] Curves associated with this sound wave
    - ``debug`` (bool):  [Read-Write] When "au.3dVisualize.Attenuation" has been specified, draw this sound's attenuation shape when the sound is audible. For debugging purposes only.
    - ``duration`` (float):  [Read-Only] Duration of sound in seconds.
    - ``enable_amplitude_envelope_analysis`` (bool):  [Read-Write] Whether or not to enable cook-time amplitude envelope analysis.
    - ``enable_baked_fft_analysis`` (bool):  [Read-Write] Whether or not to enable cook-time baked FFT analysis.
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_cloud_streaming`` (bool):  [Read-Write] If enabled, this wave may be streamed from the cloud using the Opus format. Loading behavior must NOT be `Force Inline`. Requires a suitable support plugin to be installed.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds. Describes how quickly the envelope analyzer responds to increasing amplitudes.
    - ``envelope_follower_frame_size`` (int32):  [Read-Write] How many audio frames to average a new envelope value. Larger values use less memory for audio envelope data but will result in lower envelope accuracy.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds. Describes how quickly the envelope analyzer responds to decreasing amplitudes.
    - ``fft_analysis_attack_time`` (int32):  [Read-Write] Attack time in milliseconds of the spectral envelope follower.
    - ``fft_analysis_frame_size`` (int32):  [Read-Write] How many audio frames analyze at a time.
    - ``fft_analysis_release_time`` (int32):  [Read-Write] Release time in milliseconds of the spectral envelope follower.
    - ``fft_size`` (SoundWaveFFTSize):  [Read-Write] The FFT window size to use for fft analysis.
    - ``frequencies_to_analyze`` (Array[float]):  [Read-Write] The frequencies (in hz) to analyze when doing baked FFT analysis.
    - ``imported_sample_rate`` (int32):  [Read-Only] Sample rate of the imported sound wave.
    - ``initial_chunk_size`` (int32):  [Read-Write] Please use size of First Chunk in Seconds.
      deprecated: Property 'InitialChunkSize' is deprecated.
    - ``is_ambisonics`` (bool):  [Read-Write] Whether or not this source is ambisonics file format. If set, sound always uses the
      'Master Ambisonics Submix' as set in the 'Audio' category of Project Settings'
      and ignores submix if provided locally or in the referenced SoundClass.
    - ``loading_behavior`` (SoundWaveLoadingBehavior):  [Read-Write] Specifies how and when compressed audio data is loaded for asset if stream caching is enabled.
    - ``looping`` (bool):  [Read-Write] If set, when played directly (not through a sound cue) the wave will be played looping.
    - ``manual_word_wrap`` (bool):  [Read-Write] If set to true will disable automatic generation of line breaks - use if the subtitles have been split manually.
    - ``mature`` (bool):  [Read-Write] If set to true if this sound is considered to contain mature/adult content.
    - ``max_distance`` (float):  [Read-Only] The max distance of the asset, as determined by attenuation settings.
    - ``modulation_settings`` (SoundModulationDefaultRoutingSettings):  [Read-Write] Modulation Settings
    - ``num_channels`` (int32):  [Read-Only] Number of channels of multichannel data; 1 or 2 for regular mono and stereo files
    - ``override_concurrency`` (bool):  [Read-Write] Whether or not to override the sound concurrency object with local concurrency settings.
    - ``override_sound_to_use_for_analysis`` (SoundWave):  [Read-Write] Specify a sound to use for the baked analysis. Will default to this USoundWave if not set.
    - ``pitch`` (float):  [Read-Write] Playback pitch for sound.
    - ``platform_settings`` (Map[Guid, SoundWaveCloudStreamingPlatformSettings]):  [Read-Write] Optionally disables cloud streaming per platform
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``priority`` (float):  [Read-Write] Used to determine whether sound can play or remain active if channel limit is met, where higher value is higher priority
      (see platform's Audio Settings 'Max Channels' property). Unless bypassed, value is weighted with the final volume of the
      sound to produce final runtime priority value.
    - ``sample_rate`` (int32):  [Read-Only] Cooked sample rate of the asset. Can be modified by sample rate override.
    - ``sample_rate_quality`` (SoundwaveSampleRateSettings):  [Read-Write] Determines the max sample rate to use if the platform enables "Resampling For Device" in project settings.
           For example, if the platform enables Resampling For Device and specifies 32000 for High, then setting High here will
           force the sound wave to be _at most_ 32000. Does nothing if Resampling For Device is disabled.
    - ``seekable_streaming`` (bool):  [Read-Write] Deprecated compression type properties
      deprecated: 5.0 - Property is deprecated. bSeekableStreaming now means ADPCM codec in SoundAssetCompressionType.
    - ``single_line`` (bool):  [Read-Write] If set to true the subtitles display as a sequence of single lines as opposed to multiline.
    - ``size_of_first_audio_chunk_in_seconds`` (PerPlatformFloat):  [Read-Write] How much audio to add to First Audio Chunk (in seconds)
    - ``sound_asset_compression_type`` (SoundAssetCompressionType):  [Read-Write] The compression type to use for the sound wave asset.
    - ``sound_class_object`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_group`` (SoundGroup):  [Read-Write]
    - ``sound_submix_object`` (SoundSubmixBase):  [Read-Write] Submix to route sound output to. If unset, falls back to referenced SoundClass submix.
      If SoundClass submix is unset, sends to the 'Master Submix' as set in the 'Audio' category of Project Settings'.
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] Array of submix sends to which a prescribed amount (see 'Send Level') of this sound is sent.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``spoken_text`` (str):  [Read-Write] A localized version of the text that is actually spoken phonetically in the audio.
      deprecated: Use Subtitles instead.
    - ``streaming_priority`` (int32):  [Read-Write]
      deprecated: 5.0 - Property is deprecated. Streaming priority has no effect with stream caching enabled.
    - ``subtitle_priority`` (float):  [Read-Write] The priority of the subtitle.
    - ``subtitles`` (Array[SubtitleCue]):  [Read-Write] Subtitle cues.
    - ``timecode_info`` (SoundWaveTimecodeInfo):  [Read-Only] Information about the time-code from import, if available.
    - ``total_samples`` (float):  [Read-Only] Total number of samples (in the thousands). Useful as a metric to analyze the relative size of a given sound asset in content browser.
    - ``transformations`` (Array[WaveformTransformationBase]):  [Read-Write] Waveform edits to be applied to this SoundWave on cook (editing transformations will trigger a cook)
    - ``treat_file_as_looping_for_analysis`` (bool):  [Read-Write] Whether or not we should treat the sound wave used for analysis (this or the override) as looping while performing analysis.
      A looping sound may include the end of the file for inclusion in analysis for envelope and FFT analysis.
    - ``use_bink_audio`` (bool):  [Read-Write]
      deprecated: 5.0 - Property is deprecated. bUseBinkAudio now means Bink codec in SoundAssetCompressionType.
    - ``virtualization_mode`` (VirtualizationMode):  [Read-Write] Virtualization behavior, determining if a sound may revive and how it continues playing when culled or evicted (limited to looping sounds).
    - ``volume`` (float):  [Read-Write] Playback volume of sound 0 to 1 - Default is 1.0.
    """
    @property
    def streaming_priority(self) -> int:
        r"""
        (int32):  [Read-Write]
        deprecated: 5.0 - Property is deprecated. Streaming priority has no effect with stream caching enabled.
        """
        ...
    @streaming_priority.setter
    def streaming_priority(self, value: int) -> None:
        ...
    @property
    def seekable_streaming(self) -> bool:
        r"""
        (bool):  [Read-Write] Deprecated compression type properties
        deprecated: 5.0 - Property is deprecated. bSeekableStreaming now means ADPCM codec in SoundAssetCompressionType.
        """
        ...
    @seekable_streaming.setter
    def seekable_streaming(self, value: bool) -> None:
        ...
    @property
    def use_bink_audio(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: 5.0 - Property is deprecated. bUseBinkAudio now means Bink codec in SoundAssetCompressionType.
        """
        ...
    @use_bink_audio.setter
    def use_bink_audio(self, value: bool) -> None:
        ...
    @property
    def modulation_settings(self) -> SoundModulationDefaultRoutingSettings:
        r"""
        (SoundModulationDefaultRoutingSettings):  [Read-Write] Modulation Settings
        """
        ...
    @modulation_settings.setter
    def modulation_settings(self, value: SoundModulationDefaultRoutingSettings) -> None:
        ...
    @property
    def initial_chunk_size(self) -> int:
        r"""
        (int32):  [Read-Write] Please use size of First Chunk in Seconds.
        deprecated: Property 'InitialChunkSize' is deprecated.
        """
        ...
    @initial_chunk_size.setter
    def initial_chunk_size(self, value: int) -> None:
        ...
    @property
    def mature(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true if this sound is considered to contain mature/adult content.
        """
        ...
    @property
    def manual_word_wrap(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true will disable automatic generation of line breaks - use if the subtitles have been split manually.
        """
        ...
    @property
    def single_line(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true the subtitles display as a sequence of single lines as opposed to multiline.
        """
        ...
    @property
    def spoken_text(self) -> str:
        r"""
        (str):  [Read-Write] A localized version of the text that is actually spoken phonetically in the audio.
        deprecated: Use Subtitles instead.
        """
        ...
    @spoken_text.setter
    def spoken_text(self, value: str) -> None:
        ...
    @property
    def subtitle_priority(self) -> float:
        r"""
        (float):  [Read-Only] The priority of the subtitle.
        """
        ...
    @property
    def cue_points(self) -> Array[SoundWaveCuePoint]:
        r"""
        (Array[SoundWaveCuePoint]):  [Read-Only] Cue point data parsed fro the .wav file. Contains "Loop Regions" as cue points as well!
        """
        ...
    @property
    def subtitles(self) -> Array[SubtitleCue]:
        r"""
        (Array[SubtitleCue]):  [Read-Only] Subtitle cues.
        """
        ...
    def set_sound_asset_compression_type(self, sound_asset_compression_type: SoundAssetCompressionType, mark_dirty: bool = True) -> None:
        r"""
        x.set_sound_asset_compression_type(sound_asset_compression_type, mark_dirty=True) -> None
        Procedurally set the compression type.
        
        Args:
            sound_asset_compression_type (SoundAssetCompressionType): 
            mark_dirty (bool):
        """
        ...
    def get_sound_asset_compression_type(self) -> SoundAssetCompressionType:
        r"""
        x.get_sound_asset_compression_type() -> SoundAssetCompressionType
        Returns the sound's asset compression type.
        
        Returns:
            SoundAssetCompressionType:
        """
        ...
    def get_loop_regions(self) -> Array[SoundWaveCuePoint]:
        r"""
        x.get_loop_regions() -> Array[SoundWaveCuePoint]
        Filters for the cue points that _are_ loop regions and returns those as a new array
        
        Returns:
            Array[SoundWaveCuePoint]:
        """
        ...
    def get_cue_points(self) -> Array[SoundWaveCuePoint]:
        r"""
        x.get_cue_points() -> Array[SoundWaveCuePoint]
        Filters for the cue points that are _not_ loop regions and returns those as a new array
        
        Returns:
            Array[SoundWaveCuePoint]:
        """
        ...

class SoundWaveProcedural(SoundWave):
    r"""
    Sound Wave Procedural
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundWaveProcedural.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] Attenuation settings package for the sound
    - ``audio_properties_bindings`` (AudioPropertiesBindings):  [Read-Write]
    - ``audio_properties_sheet`` (AudioPropertiesSheetAssetBase):  [Read-Write]
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``bypass_volume_scale_for_priority`` (bool):  [Read-Write] Bypass volume weighting priority upon evaluating whether sound should remain active when max channel count is met (See platform Audio Settings).
    - ``comment`` (str):  [Read-Write] Provides contextual information for the sound to the translator.
    - ``compression_quality`` (int32):  [Read-Write] Platform agnostic compression quality. 1..100 with 1 being best compression and 100 being best quality. ADPCM and PCM sound asset compression types ignore this parameter.
    - ``concurrency_overrides`` (SoundConcurrencySettings):  [Read-Write] If Override Concurrency is true, concurrency settings to use.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] Set of concurrency settings to observe (if override is set to false).  Sound must pass all concurrency settings to play.
    - ``cue_points`` (Array[SoundWaveCuePoint]):  [Read-Only] Cue point data parsed fro the .wav file. Contains "Loop Regions" as cue points as well!
    - ``curves`` (CurveTable):  [Read-Write] Curves associated with this sound wave
    - ``debug`` (bool):  [Read-Write] When "au.3dVisualize.Attenuation" has been specified, draw this sound's attenuation shape when the sound is audible. For debugging purposes only.
    - ``duration`` (float):  [Read-Only] Duration of sound in seconds.
    - ``enable_amplitude_envelope_analysis`` (bool):  [Read-Write] Whether or not to enable cook-time amplitude envelope analysis.
    - ``enable_baked_fft_analysis`` (bool):  [Read-Write] Whether or not to enable cook-time baked FFT analysis.
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_cloud_streaming`` (bool):  [Read-Write] If enabled, this wave may be streamed from the cloud using the Opus format. Loading behavior must NOT be `Force Inline`. Requires a suitable support plugin to be installed.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds. Describes how quickly the envelope analyzer responds to increasing amplitudes.
    - ``envelope_follower_frame_size`` (int32):  [Read-Write] How many audio frames to average a new envelope value. Larger values use less memory for audio envelope data but will result in lower envelope accuracy.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds. Describes how quickly the envelope analyzer responds to decreasing amplitudes.
    - ``fft_analysis_attack_time`` (int32):  [Read-Write] Attack time in milliseconds of the spectral envelope follower.
    - ``fft_analysis_frame_size`` (int32):  [Read-Write] How many audio frames analyze at a time.
    - ``fft_analysis_release_time`` (int32):  [Read-Write] Release time in milliseconds of the spectral envelope follower.
    - ``fft_size`` (SoundWaveFFTSize):  [Read-Write] The FFT window size to use for fft analysis.
    - ``frequencies_to_analyze`` (Array[float]):  [Read-Write] The frequencies (in hz) to analyze when doing baked FFT analysis.
    - ``imported_sample_rate`` (int32):  [Read-Only] Sample rate of the imported sound wave.
    - ``initial_chunk_size`` (int32):  [Read-Write] Please use size of First Chunk in Seconds.
      deprecated: Property 'InitialChunkSize' is deprecated.
    - ``is_ambisonics`` (bool):  [Read-Write] Whether or not this source is ambisonics file format. If set, sound always uses the
      'Master Ambisonics Submix' as set in the 'Audio' category of Project Settings'
      and ignores submix if provided locally or in the referenced SoundClass.
    - ``loading_behavior`` (SoundWaveLoadingBehavior):  [Read-Write] Specifies how and when compressed audio data is loaded for asset if stream caching is enabled.
    - ``looping`` (bool):  [Read-Write] If set, when played directly (not through a sound cue) the wave will be played looping.
    - ``manual_word_wrap`` (bool):  [Read-Write] If set to true will disable automatic generation of line breaks - use if the subtitles have been split manually.
    - ``mature`` (bool):  [Read-Write] If set to true if this sound is considered to contain mature/adult content.
    - ``max_distance`` (float):  [Read-Only] The max distance of the asset, as determined by attenuation settings.
    - ``modulation_settings`` (SoundModulationDefaultRoutingSettings):  [Read-Write] Modulation Settings
    - ``num_channels`` (int32):  [Read-Only] Number of channels of multichannel data; 1 or 2 for regular mono and stereo files
    - ``override_concurrency`` (bool):  [Read-Write] Whether or not to override the sound concurrency object with local concurrency settings.
    - ``override_sound_to_use_for_analysis`` (SoundWave):  [Read-Write] Specify a sound to use for the baked analysis. Will default to this USoundWave if not set.
    - ``pitch`` (float):  [Read-Write] Playback pitch for sound.
    - ``platform_settings`` (Map[Guid, SoundWaveCloudStreamingPlatformSettings]):  [Read-Write] Optionally disables cloud streaming per platform
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``priority`` (float):  [Read-Write] Used to determine whether sound can play or remain active if channel limit is met, where higher value is higher priority
      (see platform's Audio Settings 'Max Channels' property). Unless bypassed, value is weighted with the final volume of the
      sound to produce final runtime priority value.
    - ``sample_rate`` (int32):  [Read-Only] Cooked sample rate of the asset. Can be modified by sample rate override.
    - ``sample_rate_quality`` (SoundwaveSampleRateSettings):  [Read-Write] Determines the max sample rate to use if the platform enables "Resampling For Device" in project settings.
           For example, if the platform enables Resampling For Device and specifies 32000 for High, then setting High here will
           force the sound wave to be _at most_ 32000. Does nothing if Resampling For Device is disabled.
    - ``seekable_streaming`` (bool):  [Read-Write] Deprecated compression type properties
      deprecated: 5.0 - Property is deprecated. bSeekableStreaming now means ADPCM codec in SoundAssetCompressionType.
    - ``single_line`` (bool):  [Read-Write] If set to true the subtitles display as a sequence of single lines as opposed to multiline.
    - ``size_of_first_audio_chunk_in_seconds`` (PerPlatformFloat):  [Read-Write] How much audio to add to First Audio Chunk (in seconds)
    - ``sound_asset_compression_type`` (SoundAssetCompressionType):  [Read-Write] The compression type to use for the sound wave asset.
    - ``sound_class_object`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_group`` (SoundGroup):  [Read-Write]
    - ``sound_submix_object`` (SoundSubmixBase):  [Read-Write] Submix to route sound output to. If unset, falls back to referenced SoundClass submix.
      If SoundClass submix is unset, sends to the 'Master Submix' as set in the 'Audio' category of Project Settings'.
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] Array of submix sends to which a prescribed amount (see 'Send Level') of this sound is sent.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``spoken_text`` (str):  [Read-Write] A localized version of the text that is actually spoken phonetically in the audio.
      deprecated: Use Subtitles instead.
    - ``streaming_priority`` (int32):  [Read-Write]
      deprecated: 5.0 - Property is deprecated. Streaming priority has no effect with stream caching enabled.
    - ``subtitle_priority`` (float):  [Read-Write] The priority of the subtitle.
    - ``subtitles`` (Array[SubtitleCue]):  [Read-Write] Subtitle cues.
    - ``timecode_info`` (SoundWaveTimecodeInfo):  [Read-Only] Information about the time-code from import, if available.
    - ``total_samples`` (float):  [Read-Only] Total number of samples (in the thousands). Useful as a metric to analyze the relative size of a given sound asset in content browser.
    - ``transformations`` (Array[WaveformTransformationBase]):  [Read-Write] Waveform edits to be applied to this SoundWave on cook (editing transformations will trigger a cook)
    - ``treat_file_as_looping_for_analysis`` (bool):  [Read-Write] Whether or not we should treat the sound wave used for analysis (this or the override) as looping while performing analysis.
      A looping sound may include the end of the file for inclusion in analysis for envelope and FFT analysis.
    - ``use_bink_audio`` (bool):  [Read-Write]
      deprecated: 5.0 - Property is deprecated. bUseBinkAudio now means Bink codec in SoundAssetCompressionType.
    - ``virtualization_mode`` (VirtualizationMode):  [Read-Write] Virtualization behavior, determining if a sound may revive and how it continues playing when culled or evicted (limited to looping sounds).
    - ``volume`` (float):  [Read-Write] Playback volume of sound 0 to 1 - Default is 1.0.
    """
    ...

class SynthSound(SoundWaveProcedural):
    r"""
    Synth Sound
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: SynthComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] Attenuation settings package for the sound
    - ``audio_properties_bindings`` (AudioPropertiesBindings):  [Read-Write]
    - ``audio_properties_sheet`` (AudioPropertiesSheetAssetBase):  [Read-Write]
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``bypass_volume_scale_for_priority`` (bool):  [Read-Write] Bypass volume weighting priority upon evaluating whether sound should remain active when max channel count is met (See platform Audio Settings).
    - ``comment`` (str):  [Read-Write] Provides contextual information for the sound to the translator.
    - ``compression_quality`` (int32):  [Read-Write] Platform agnostic compression quality. 1..100 with 1 being best compression and 100 being best quality. ADPCM and PCM sound asset compression types ignore this parameter.
    - ``concurrency_overrides`` (SoundConcurrencySettings):  [Read-Write] If Override Concurrency is true, concurrency settings to use.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] Set of concurrency settings to observe (if override is set to false).  Sound must pass all concurrency settings to play.
    - ``cue_points`` (Array[SoundWaveCuePoint]):  [Read-Only] Cue point data parsed fro the .wav file. Contains "Loop Regions" as cue points as well!
    - ``curves`` (CurveTable):  [Read-Write] Curves associated with this sound wave
    - ``debug`` (bool):  [Read-Write] When "au.3dVisualize.Attenuation" has been specified, draw this sound's attenuation shape when the sound is audible. For debugging purposes only.
    - ``duration`` (float):  [Read-Only] Duration of sound in seconds.
    - ``enable_amplitude_envelope_analysis`` (bool):  [Read-Write] Whether or not to enable cook-time amplitude envelope analysis.
    - ``enable_baked_fft_analysis`` (bool):  [Read-Write] Whether or not to enable cook-time baked FFT analysis.
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_cloud_streaming`` (bool):  [Read-Write] If enabled, this wave may be streamed from the cloud using the Opus format. Loading behavior must NOT be `Force Inline`. Requires a suitable support plugin to be installed.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds. Describes how quickly the envelope analyzer responds to increasing amplitudes.
    - ``envelope_follower_frame_size`` (int32):  [Read-Write] How many audio frames to average a new envelope value. Larger values use less memory for audio envelope data but will result in lower envelope accuracy.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds. Describes how quickly the envelope analyzer responds to decreasing amplitudes.
    - ``fft_analysis_attack_time`` (int32):  [Read-Write] Attack time in milliseconds of the spectral envelope follower.
    - ``fft_analysis_frame_size`` (int32):  [Read-Write] How many audio frames analyze at a time.
    - ``fft_analysis_release_time`` (int32):  [Read-Write] Release time in milliseconds of the spectral envelope follower.
    - ``fft_size`` (SoundWaveFFTSize):  [Read-Write] The FFT window size to use for fft analysis.
    - ``frequencies_to_analyze`` (Array[float]):  [Read-Write] The frequencies (in hz) to analyze when doing baked FFT analysis.
    - ``imported_sample_rate`` (int32):  [Read-Only] Sample rate of the imported sound wave.
    - ``initial_chunk_size`` (int32):  [Read-Write] Please use size of First Chunk in Seconds.
      deprecated: Property 'InitialChunkSize' is deprecated.
    - ``is_ambisonics`` (bool):  [Read-Write] Whether or not this source is ambisonics file format. If set, sound always uses the
      'Master Ambisonics Submix' as set in the 'Audio' category of Project Settings'
      and ignores submix if provided locally or in the referenced SoundClass.
    - ``loading_behavior`` (SoundWaveLoadingBehavior):  [Read-Write] Specifies how and when compressed audio data is loaded for asset if stream caching is enabled.
    - ``looping`` (bool):  [Read-Write] If set, when played directly (not through a sound cue) the wave will be played looping.
    - ``manual_word_wrap`` (bool):  [Read-Write] If set to true will disable automatic generation of line breaks - use if the subtitles have been split manually.
    - ``mature`` (bool):  [Read-Write] If set to true if this sound is considered to contain mature/adult content.
    - ``max_distance`` (float):  [Read-Only] The max distance of the asset, as determined by attenuation settings.
    - ``modulation_settings`` (SoundModulationDefaultRoutingSettings):  [Read-Write] Modulation Settings
    - ``num_channels`` (int32):  [Read-Only] Number of channels of multichannel data; 1 or 2 for regular mono and stereo files
    - ``override_concurrency`` (bool):  [Read-Write] Whether or not to override the sound concurrency object with local concurrency settings.
    - ``override_sound_to_use_for_analysis`` (SoundWave):  [Read-Write] Specify a sound to use for the baked analysis. Will default to this USoundWave if not set.
    - ``pitch`` (float):  [Read-Write] Playback pitch for sound.
    - ``platform_settings`` (Map[Guid, SoundWaveCloudStreamingPlatformSettings]):  [Read-Write] Optionally disables cloud streaming per platform
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``priority`` (float):  [Read-Write] Used to determine whether sound can play or remain active if channel limit is met, where higher value is higher priority
      (see platform's Audio Settings 'Max Channels' property). Unless bypassed, value is weighted with the final volume of the
      sound to produce final runtime priority value.
    - ``sample_rate`` (int32):  [Read-Only] Cooked sample rate of the asset. Can be modified by sample rate override.
    - ``sample_rate_quality`` (SoundwaveSampleRateSettings):  [Read-Write] Determines the max sample rate to use if the platform enables "Resampling For Device" in project settings.
           For example, if the platform enables Resampling For Device and specifies 32000 for High, then setting High here will
           force the sound wave to be _at most_ 32000. Does nothing if Resampling For Device is disabled.
    - ``seekable_streaming`` (bool):  [Read-Write] Deprecated compression type properties
      deprecated: 5.0 - Property is deprecated. bSeekableStreaming now means ADPCM codec in SoundAssetCompressionType.
    - ``single_line`` (bool):  [Read-Write] If set to true the subtitles display as a sequence of single lines as opposed to multiline.
    - ``size_of_first_audio_chunk_in_seconds`` (PerPlatformFloat):  [Read-Write] How much audio to add to First Audio Chunk (in seconds)
    - ``sound_asset_compression_type`` (SoundAssetCompressionType):  [Read-Write] The compression type to use for the sound wave asset.
    - ``sound_class_object`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_group`` (SoundGroup):  [Read-Write]
    - ``sound_submix_object`` (SoundSubmixBase):  [Read-Write] Submix to route sound output to. If unset, falls back to referenced SoundClass submix.
      If SoundClass submix is unset, sends to the 'Master Submix' as set in the 'Audio' category of Project Settings'.
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] Array of submix sends to which a prescribed amount (see 'Send Level') of this sound is sent.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``spoken_text`` (str):  [Read-Write] A localized version of the text that is actually spoken phonetically in the audio.
      deprecated: Use Subtitles instead.
    - ``streaming_priority`` (int32):  [Read-Write]
      deprecated: 5.0 - Property is deprecated. Streaming priority has no effect with stream caching enabled.
    - ``subtitle_priority`` (float):  [Read-Write] The priority of the subtitle.
    - ``subtitles`` (Array[SubtitleCue]):  [Read-Write] Subtitle cues.
    - ``timecode_info`` (SoundWaveTimecodeInfo):  [Read-Only] Information about the time-code from import, if available.
    - ``total_samples`` (float):  [Read-Only] Total number of samples (in the thousands). Useful as a metric to analyze the relative size of a given sound asset in content browser.
    - ``transformations`` (Array[WaveformTransformationBase]):  [Read-Write] Waveform edits to be applied to this SoundWave on cook (editing transformations will trigger a cook)
    - ``treat_file_as_looping_for_analysis`` (bool):  [Read-Write] Whether or not we should treat the sound wave used for analysis (this or the override) as looping while performing analysis.
      A looping sound may include the end of the file for inclusion in analysis for envelope and FFT analysis.
    - ``use_bink_audio`` (bool):  [Read-Write]
      deprecated: 5.0 - Property is deprecated. bUseBinkAudio now means Bink codec in SoundAssetCompressionType.
    - ``virtualization_mode`` (VirtualizationMode):  [Read-Write] Virtualization behavior, determining if a sound may revive and how it continues playing when culled or evicted (limited to looping sounds).
    - ``volume`` (float):  [Read-Write] Playback volume of sound 0 to 1 - Default is 1.0.
    """
    ...

class SynthComponent(SceneComponent):
    r"""
    Synth Component
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: SynthComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``allow_spatialization`` (bool):  [Read-Write] Is this audio component allowed to be spatialized?
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] What sound concurrency to use for sounds generated by this audio component
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulation_routing`` (SoundModulationDefaultRoutingSettings):  [Read-Write]
    - ``on_audio_envelope_value`` (OnSynthEnvelopeValue):  [Read-Write]
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``override_attenuation`` (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sound_class`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] Submix this sound belongs to
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] An array of submix sends. Audio from this sound will send a portion of its audio to these effects.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def allow_spatialization(self) -> bool:
        r"""
        (bool):  [Read-Write] Is this audio component allowed to be spatialized?
        """
        ...
    @allow_spatialization.setter
    def allow_spatialization(self, value: bool) -> None:
        ...
    @property
    def override_attenuation(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
        """
        ...
    @override_attenuation.setter
    def override_attenuation(self, value: bool) -> None:
        ...
    @property
    def enable_bus_sends(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
        """
        ...
    @enable_bus_sends.setter
    def enable_bus_sends(self, value: bool) -> None:
        ...
    @property
    def attenuation_settings(self) -> SoundAttenuation:
        r"""
        (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
        """
        ...
    @attenuation_settings.setter
    def attenuation_settings(self, value: SoundAttenuation) -> None:
        ...
    @property
    def attenuation_overrides(self) -> SoundAttenuationSettings:
        r"""
        (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
        """
        ...
    @attenuation_overrides.setter
    def attenuation_overrides(self, value: SoundAttenuationSettings) -> None:
        ...
    @property
    def concurrency_set(self) -> Set[SoundConcurrency]:
        r"""
        (Set[SoundConcurrency]):  [Read-Write] What sound concurrency to use for sounds generated by this audio component
        """
        ...
    @concurrency_set.setter
    def concurrency_set(self, value: Set[SoundConcurrency]) -> None:
        ...
    @property
    def modulation_routing(self) -> SoundModulationDefaultRoutingSettings:
        r"""
        (SoundModulationDefaultRoutingSettings):  [Read-Write]
        """
        ...
    @modulation_routing.setter
    def modulation_routing(self, value: SoundModulationDefaultRoutingSettings) -> None:
        ...
    @property
    def sound_submix_sends(self) -> Array[SoundSubmixSendInfo]:
        r"""
        (Array[SoundSubmixSendInfo]):  [Read-Write] An array of submix sends. Audio from this sound will send a portion of its audio to these effects.
        """
        ...
    @sound_submix_sends.setter
    def sound_submix_sends(self, value: Array[SoundSubmixSendInfo]) -> None:
        ...
    @property
    def bus_sends(self) -> Array[SoundSourceBusSendInfo]:
        r"""
        (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
        """
        ...
    @bus_sends.setter
    def bus_sends(self, value: Array[SoundSourceBusSendInfo]) -> None:
        ...
    @property
    def pre_effect_bus_sends(self) -> Array[SoundSourceBusSendInfo]:
        r"""
        (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
        """
        ...
    @pre_effect_bus_sends.setter
    def pre_effect_bus_sends(self, value: Array[SoundSourceBusSendInfo]) -> None:
        ...
    @property
    def is_ui_sound(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
        """
        ...
    @is_ui_sound.setter
    def is_ui_sound(self, value: bool) -> None:
        ...
    @property
    def envelope_follower_attack_time(self) -> int:
        r"""
        (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
        envelope value of sounds played with this audio component. Only used in audio mixer.
        """
        ...
    @envelope_follower_attack_time.setter
    def envelope_follower_attack_time(self, value: int) -> None:
        ...
    @property
    def envelope_follower_release_time(self) -> int:
        r"""
        (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
        envelope value of sounds played with this audio component. Only used in audio mixer.
        """
        ...
    @envelope_follower_release_time.setter
    def envelope_follower_release_time(self, value: int) -> None:
        ...
    @property
    def on_audio_envelope_value(self) -> OnSynthEnvelopeValue:
        r"""
        (OnSynthEnvelopeValue):  [Read-Write]
        """
        ...
    @on_audio_envelope_value.setter
    def on_audio_envelope_value(self, value: OnSynthEnvelopeValue) -> None:
        ...
    def stop(self) -> None:
        r"""
        x.stop() -> None
        Stops the synth generating audio.
        """
        ...
    def start(self) -> None:
        r"""
        x.start() -> None
        Starts the synth generating audio.
        """
        ...
    def set_volume_multiplier(self, volume_multiplier: float) -> None:
        r"""
        x.set_volume_multiplier(volume_multiplier) -> None
        Set a new volume multiplier
        
        Args:
            volume_multiplier (float):
        """
        ...
    def set_submix_send(self, submix: SoundSubmixBase, send_level: float) -> None:
        r"""
        x.set_submix_send(submix, send_level) -> None
        Sets how much audio the sound should send to the given submix.
        
        Args:
            submix (SoundSubmixBase): 
            send_level (float):
        """
        ...
    def set_source_bus_send_pre_effect(self, sound_source_bus: SoundSourceBus, source_bus_send_level: float) -> None:
        r"""
        x.set_source_bus_send_pre_effect(sound_source_bus, source_bus_send_level) -> None
        Sets how much audio the sound should send to the given SourceBus (pre effect).
        
        Args:
            sound_source_bus (SoundSourceBus): 
            source_bus_send_level (float):
        """
        ...
    def set_source_bus_send_post_effect(self, sound_source_bus: SoundSourceBus, source_bus_send_level: float) -> None:
        r"""
        x.set_source_bus_send_post_effect(sound_source_bus, source_bus_send_level) -> None
        Sets how much audio the sound should send to the given SourceBus (post effect).
        
        Args:
            sound_source_bus (SoundSourceBus): 
            source_bus_send_level (float):
        """
        ...
    def set_output_to_bus_only(self, output_to_bus_only: bool) -> None:
        r"""
        x.set_output_to_bus_only(output_to_bus_only) -> None
        Sets whether or not the synth component outputs its audio to any source or audio buses.
        
        Args:
            output_to_bus_only (bool):
        """
        ...
    def set_modulation_routing(self, modulators: Set[SoundModulatorBase], destination: ModulationDestination, routing_method: ModulationRouting = ModulationRouting.INHERIT) -> None:
        r"""
        x.set_modulation_routing(modulators, destination, routing_method=ModulationRouting.INHERIT) -> None
        Sets the routing for one of the given Synth component's Modulation Destinations.
        
        Args:
            modulators (Set[SoundModulatorBase]): The set of modulators to apply to the given destination on the component.
            destination (ModulationDestination): The destination to assign the modulators to.
            routing_method (ModulationRouting): The routing method to use for the given modulator.
        """
        ...
    def set_low_pass_filter_frequency(self, low_pass_filter_frequency: float) -> None:
        r"""
        x.set_low_pass_filter_frequency(low_pass_filter_frequency) -> None
        Sets lowpass filter frequency of the audio component.
        
        Args:
            low_pass_filter_frequency (float):
        """
        ...
    def set_low_pass_filter_enabled(self, low_pass_filter_enabled: bool) -> None:
        r"""
        x.set_low_pass_filter_enabled(low_pass_filter_enabled) -> None
        Sets whether or not the low pass filter is enabled on the audio component.
        
        Args:
            low_pass_filter_enabled (bool):
        """
        ...
    def set_audio_bus_send_pre_effect(self, audio_bus: AudioBus, audio_bus_send_level: float) -> None:
        r"""
        x.set_audio_bus_send_pre_effect(audio_bus, audio_bus_send_level) -> None
        Sets how much audio the sound should send to the given AudioBus (pre effect).
        
        Args:
            audio_bus (AudioBus): 
            audio_bus_send_level (float):
        """
        ...
    def set_audio_bus_send_post_effect(self, audio_bus: AudioBus, audio_bus_send_level: float) -> None:
        r"""
        x.set_audio_bus_send_post_effect(audio_bus, audio_bus_send_level) -> None
        Sets how much audio the sound should send to the given AudioBus (post effect).
        
        Args:
            audio_bus (AudioBus): 
            audio_bus_send_level (float):
        """
        ...
    def is_playing(self) -> bool:
        r"""
        x.is_playing() -> bool
        Returns true if this component is currently playing.
        
        Returns:
            bool:
        """
        ...
    def get_modulators(self, destination: ModulationDestination) -> Set[SoundModulatorBase]:
        r"""
        x.get_modulators(destination) -> Set[SoundModulatorBase]
        Gets the set of currently active modulators for a given Modulation Destination.
        
        Args:
            destination (ModulationDestination): The Destination to retrieve the Modulators from.
        
        Returns:
            Set[SoundModulatorBase]: The set of of Modulators applied to this component for the given Destination.
        """
        ...
    def fade_out(self, fade_out_duration: float, fade_volume_level: float, fade_curve: AudioFaderCurve = AudioFaderCurve.LINEAR) -> None:
        r"""
        x.fade_out(fade_out_duration, fade_volume_level, fade_curve=AudioFaderCurve.LINEAR) -> None
        This function allows designers to call a delayed Stop on an Audio Component instance while applying a
        volume curve over time. Parameters allow designers to indicate the duration of the fade and the curve shape.
        
        Args:
            fade_out_duration (float): how long it should take to reach the FadeVolumeLevel
            fade_volume_level (float): the percentage of the AudioComponents's calculated volume in which to fade to
            fade_curve (AudioFaderCurve): The curve to use when interpolating between the old and new volume
        """
        ...
    def fade_in(self, fade_in_duration: float, fade_volume_level: float = 1.000000, start_time: float = 0.000000, fade_curve: AudioFaderCurve = AudioFaderCurve.LINEAR) -> None:
        r"""
        x.fade_in(fade_in_duration, fade_volume_level=1.000000, start_time=0.000000, fade_curve=AudioFaderCurve.LINEAR) -> None
        This function allows designers to call Play on an Audio Component instance while applying a volume curve over time.
        Parameters allow designers to indicate the duration of the fade, the curve shape, and the start time if seeking into the sound.
        
        Args:
            fade_in_duration (float): How long it should take to reach the FadeVolumeLevel
            fade_volume_level (float): The percentage of the AudioComponents's calculated volume to fade to
            start_time (float): 
            fade_curve (AudioFaderCurve): The curve to use when interpolating between the old and new volume
        """
        ...
    def adjust_volume(self, adjust_volume_duration: float, adjust_volume_level: float, fade_curve: AudioFaderCurve = AudioFaderCurve.LINEAR) -> None:
        r"""
        x.adjust_volume(adjust_volume_duration, adjust_volume_level, fade_curve=AudioFaderCurve.LINEAR) -> None
        This function allows designers to trigger an adjustment to the sound instance’s playback Volume with options for smoothly applying a curve over time.
        
        Args:
            adjust_volume_duration (float): The length of time in which to interpolate between the initial volume and the new volume.
            adjust_volume_level (float): The new volume to set the Audio Component to.
            fade_curve (AudioFaderCurve): The curve used when interpolating between the old and new volume.
        """
        ...

class SoundEffectPreset(Object):
    r"""
    Sound Effect Preset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundEffectPreset.h
    
    """
    ...

class SoundEffectSubmixPreset(SoundEffectPreset):
    r"""
    Preset of a submix effect that can be shared between sounds.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundEffectSubmix.h
    
    """
    ...

class SubmixEffectDynamicsProcessorPreset(SoundEffectSubmixPreset):
    r"""
    Submix Effect Dynamics Processor Preset
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectDynamicsProcessor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SubmixEffectDynamicsProcessorSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SubmixEffectDynamicsProcessorSettings:
        r"""
        (SubmixEffectDynamicsProcessorSettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: SubmixEffectDynamicsProcessorSettings) -> None:
        ...
    def set_settings(self, settings: SubmixEffectDynamicsProcessorSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SubmixEffectDynamicsProcessorSettings):
        """
        ...
    def set_external_submix(self, submix: SoundSubmix) -> None:
        r"""
        x.set_external_submix(submix) -> None
        Sets the source key input as the provided Submix's output.  If no object is provided, key is set
        to effect's input.
        
        Args:
            submix (SoundSubmix):
        """
        ...
    def set_audio_bus(self, audio_bus: AudioBus) -> None:
        r"""
        x.set_audio_bus(audio_bus) -> None
        Sets the source key input as the provided AudioBus' output.  If no object is provided, key is set
        to effect's input.
        
        Args:
            audio_bus (AudioBus):
        """
        ...
    def reset_key(self) -> None:
        r"""
        x.reset_key() -> None
        Reset Key
        """
        ...

class SubmixEffectSubmixEQPreset(SoundEffectSubmixPreset):
    r"""
    Submix Effect Submix EQPreset
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectEQ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SubmixEffectSubmixEQSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SubmixEffectSubmixEQSettings:
        r"""
        (SubmixEffectSubmixEQSettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: SubmixEffectSubmixEQSettings) -> None:
        ...
    def set_settings(self, settings: SubmixEffectSubmixEQSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SubmixEffectSubmixEQSettings):
        """
        ...

class SubmixEffectReverbPreset(SoundEffectSubmixPreset):
    r"""
    Submix Effect Reverb Preset
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerSubmixEffectReverb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SubmixEffectReverbSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SubmixEffectReverbSettings:
        r"""
        (SubmixEffectReverbSettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: SubmixEffectReverbSettings) -> None:
        ...
    def set_settings_with_reverb_effect(self, reverb_effect: ReverbEffect, wet_level: float, dry_level: float = 0.000000) -> None:
        r"""
        x.set_settings_with_reverb_effect(reverb_effect, wet_level, dry_level=0.000000) -> None
        Set Settings with Reverb Effect
        
        Args:
            reverb_effect (ReverbEffect): 
            wet_level (float): 
            dry_level (float):
        """
        ...
    def set_settings(self, settings: SubmixEffectReverbSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SubmixEffectReverbSettings):
        """
        ...

class SubmixEffectReverbFastPreset(SubmixEffectReverbPreset):
    r"""
    deprecated: 'SubmixEffectReverbFastPreset' was renamed to 'SubmixEffectReverbPreset'.
    """
    ...

class AudioGenerator(Object):
    r"""
    Audio Generator
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioGenerator.h
    
    """
    ...

class QuartzClockHandle(Object):
    r"""
    This class is a BP / Game thread wrapper around FQuartzClockProxy
       (to talk to the underlying clock)
    
    ...and inherits from FQuartzTickableObject
       (to listen to the underlying clock)
    
    It can subscribe to Quantized Event & Metronome delegates to synchronize
    gameplay & VFX to Quartz events fired from the Audio Engine
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: AudioMixerClockHandle.h
    
    """
    def unsubscribe_from_time_division(self, world_context_object: Object, quantization_boundary: QuartzCommandQuantization) -> QuartzClockHandle:
        r"""
        x.unsubscribe_from_time_division(world_context_object, quantization_boundary) -> QuartzClockHandle
        Unsubscribe from Time Division
        
        Args:
            world_context_object (Object): 
            quantization_boundary (QuartzCommandQuantization): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def unsubscribe_from_all_time_divisions(self, world_context_object: Object) -> QuartzClockHandle:
        r"""
        x.unsubscribe_from_all_time_divisions(world_context_object) -> QuartzClockHandle
        Unsubscribe from All Time Divisions
        
        Args:
            world_context_object (Object): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def subscribe_to_quantization_event(self, world_context_object: Object, quantization_boundary: QuartzCommandQuantization, on_quantization_event: OnQuartzMetronomeEventBP) -> QuartzClockHandle:
        r"""
        x.subscribe_to_quantization_event(world_context_object, quantization_boundary, on_quantization_event) -> QuartzClockHandle
        Metronome subscription
        
        Args:
            world_context_object (Object): 
            quantization_boundary (QuartzCommandQuantization): 
            on_quantization_event (OnQuartzMetronomeEventBP): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def subscribe_to_all_quantization_events(self, world_context_object: Object, on_quantization_event: OnQuartzMetronomeEventBP) -> QuartzClockHandle:
        r"""
        x.subscribe_to_all_quantization_events(world_context_object, on_quantization_event) -> QuartzClockHandle
        Subscribe to All Quantization Events
        
        Args:
            world_context_object (Object): 
            on_quantization_event (OnQuartzMetronomeEventBP): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def stop_clock(self, world_context_object: Object, cancel_pending_events: bool) -> QuartzClockHandle:
        r"""
        x.stop_clock(world_context_object, cancel_pending_events) -> QuartzClockHandle
        Stop Clock
        
        Args:
            world_context_object (Object): 
            cancel_pending_events (bool): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def start_other_clock(self, world_context_object: Object, other_clock_name: Name, quantization_boundary: QuartzQuantizationBoundary, delegate: OnQuartzCommandEventBP) -> None:
        r"""
        x.start_other_clock(world_context_object, other_clock_name, quantization_boundary, delegate) -> None
        "other" clock manipulation
        
        Args:
            world_context_object (Object): 
            other_clock_name (Name): 
            quantization_boundary (QuartzQuantizationBoundary): 
            delegate (OnQuartzCommandEventBP):
        """
        ...
    def start_clock(self, world_context_object: Object) -> QuartzClockHandle:
        r"""
        x.start_clock(world_context_object) -> QuartzClockHandle
        Clock manipulation
        
        Args:
            world_context_object (Object): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def set_ticks_per_second(self, world_context_object: Object, quantization_boundary: QuartzQuantizationBoundary, delegate: OnQuartzCommandEventBP, ticks_per_second: float = 10.000000) -> QuartzClockHandle:
        r"""
        x.set_ticks_per_second(world_context_object, quantization_boundary, delegate, ticks_per_second=10.000000) -> QuartzClockHandle
        Set Ticks Per Second
        
        Args:
            world_context_object (Object): 
            quantization_boundary (QuartzQuantizationBoundary): 
            delegate (OnQuartzCommandEventBP): 
            ticks_per_second (float): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def set_thirty_second_notes_per_minute(self, world_context_object: Object, quantization_boundary: QuartzQuantizationBoundary, delegate: OnQuartzCommandEventBP, thirty_seconds_notes_per_minute: float = 960.000000) -> QuartzClockHandle:
        r"""
        x.set_thirty_second_notes_per_minute(world_context_object, quantization_boundary, delegate, thirty_seconds_notes_per_minute=960.000000) -> QuartzClockHandle
        Set Thirty Second Notes Per Minute
        
        Args:
            world_context_object (Object): 
            quantization_boundary (QuartzQuantizationBoundary): 
            delegate (OnQuartzCommandEventBP): 
            thirty_seconds_notes_per_minute (float): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def set_seconds_per_tick(self, world_context_object: Object, quantization_boundary: QuartzQuantizationBoundary, delegate: OnQuartzCommandEventBP, seconds_per_tick: float = 0.250000) -> QuartzClockHandle:
        r"""
        x.set_seconds_per_tick(world_context_object, quantization_boundary, delegate, seconds_per_tick=0.250000) -> QuartzClockHandle
        Set Seconds Per Tick
        
        Args:
            world_context_object (Object): 
            quantization_boundary (QuartzQuantizationBoundary): 
            delegate (OnQuartzCommandEventBP): 
            seconds_per_tick (float): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def set_milliseconds_per_tick(self, world_context_object: Object, quantization_boundary: QuartzQuantizationBoundary, delegate: OnQuartzCommandEventBP, milliseconds_per_tick: float = 100.000000) -> QuartzClockHandle:
        r"""
        x.set_milliseconds_per_tick(world_context_object, quantization_boundary, delegate, milliseconds_per_tick=100.000000) -> QuartzClockHandle
        Metronome Alteration (setters)
        
        Args:
            world_context_object (Object): 
            quantization_boundary (QuartzQuantizationBoundary): 
            delegate (OnQuartzCommandEventBP): 
            milliseconds_per_tick (float): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def set_beats_per_minute(self, world_context_object: Object, quantization_boundary: QuartzQuantizationBoundary, delegate: OnQuartzCommandEventBP, beats_per_minute: float = 60.000000) -> QuartzClockHandle:
        r"""
        x.set_beats_per_minute(world_context_object, quantization_boundary, delegate, beats_per_minute=60.000000) -> QuartzClockHandle
        Set Beats Per Minute
        
        Args:
            world_context_object (Object): 
            quantization_boundary (QuartzQuantizationBoundary): 
            delegate (OnQuartzCommandEventBP): 
            beats_per_minute (float): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def resume_clock(self, world_context_object: Object) -> QuartzClockHandle:
        r"""
        x.resume_clock(world_context_object) -> QuartzClockHandle
        Resume Clock
        
        Args:
            world_context_object (Object): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def reset_transport_quantized(self, world_context_object: Object, quantization_boundary: QuartzQuantizationBoundary, delegate: OnQuartzCommandEventBP) -> QuartzClockHandle:
        r"""
        x.reset_transport_quantized(world_context_object, quantization_boundary, delegate) -> QuartzClockHandle
        Reset Transport Quantized
        
        Args:
            world_context_object (Object): 
            quantization_boundary (QuartzQuantizationBoundary): 
            delegate (OnQuartzCommandEventBP): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def reset_transport(self, world_context_object: Object, delegate: OnQuartzCommandEventBP) -> None:
        r"""
        x.reset_transport(world_context_object, delegate) -> None
        Reset Transport
        
        Args:
            world_context_object (Object): 
            delegate (OnQuartzCommandEventBP):
        """
        ...
    def pause_clock(self, world_context_object: Object) -> QuartzClockHandle:
        r"""
        x.pause_clock(world_context_object) -> QuartzClockHandle
        Pause Clock
        
        Args:
            world_context_object (Object): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def notify_on_quantization_boundary(self, world_context_object: Object, quantization_boundary: QuartzQuantizationBoundary, delegate: OnQuartzCommandEventBP, ms_offset: float = 0.000000) -> None:
        r"""
        x.notify_on_quantization_boundary(world_context_object, quantization_boundary, delegate, ms_offset=0.000000) -> None
        Notify on Quantization Boundary
        
        Args:
            world_context_object (Object): 
            quantization_boundary (QuartzQuantizationBoundary): 
            delegate (OnQuartzCommandEventBP): 
            ms_offset (float):
        """
        ...
    def is_clock_running(self, world_context_object: Object) -> bool:
        r"""
        x.is_clock_running(world_context_object) -> bool
        Is Clock Running
        
        Args:
            world_context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def get_ticks_per_second(self, world_context_object: Object) -> float:
        r"""
        x.get_ticks_per_second(world_context_object) -> float
        Get Ticks Per Second
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_thirty_second_notes_per_minute(self, world_context_object: Object) -> float:
        r"""
        x.get_thirty_second_notes_per_minute(world_context_object) -> float
        Get Thirty Second Notes Per Minute
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_seconds_per_tick(self, world_context_object: Object) -> float:
        r"""
        x.get_seconds_per_tick(world_context_object) -> float
        Get Seconds Per Tick
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_milliseconds_per_tick(self, world_context_object: Object) -> float:
        r"""
        x.get_milliseconds_per_tick(world_context_object) -> float
        Metronome getters
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_estimated_run_time(self, world_context_object: Object) -> float:
        r"""
        x.get_estimated_run_time(world_context_object) -> float
        Returns the amount of time, in seconds, the clock has been running. Caution: due to latency, this will not be perfectly accurate
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_duration_of_quantization_type_in_seconds(self, world_context_object: Object, quantization_type: QuartzCommandQuantization, multiplier: float = 1.000000) -> float:
        r"""
        x.get_duration_of_quantization_type_in_seconds(world_context_object, quantization_type, multiplier=1.000000) -> float
        Returns the duration in seconds of the given Quantization Type
        
        Args:
            world_context_object (Object): 
            quantization_type (QuartzCommandQuantization): 
            multiplier (float): 
        
        Returns:
            float: The duration, in seconds, of a multiplier amount of the Quantization Type, or -1 in the case the clock is invalid
        """
        ...
    def get_current_timestamp(self, world_context_object: Object) -> QuartzTransportTimeStamp:
        r"""
        x.get_current_timestamp(world_context_object) -> QuartzTransportTimeStamp
        Retrieves a timestamp for the clock
        
        Args:
            world_context_object (Object): 
        
        Returns:
            QuartzTransportTimeStamp:
        """
        ...
    def get_beats_per_minute(self, world_context_object: Object) -> float:
        r"""
        x.get_beats_per_minute(world_context_object) -> float
        Get Beats Per Minute
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_beat_progress_percent(self, quantization_boundary: QuartzCommandQuantization = QuartzCommandQuantization.BEAT, phase_offset: float = 0.000000, ms_offset: float = 0.000000) -> float:
        r"""
        x.get_beat_progress_percent(quantization_boundary=QuartzCommandQuantization.BEAT, phase_offset=0.000000, ms_offset=0.000000) -> float
        Returns the current progress until the next occurrence of the provided musical duration as a float value from 0 (previous beat) to 1 (next beat).
        This is useful for indexing into curves to animate parameters to musical time.
        Ms and Phase offsets are combined internally.
        
        Args:
            quantization_boundary (QuartzCommandQuantization): 
            phase_offset (float): 
            ms_offset (float): 
        
        Returns:
            float:
        """
        ...

class WorldSubsystem(Subsystem):
    r"""
    UWorldSubsystem
    Base class for auto instanced and initialized systems that share the lifetime of a UWorld
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldSubsystem.h
    
    """
    ...

class TickableWorldSubsystem(WorldSubsystem):
    r"""
    UTickableWorldSubsystem
    Base class for auto instanced and initialized systems that share the lifetime of a UWorld and are ticking along with it
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldSubsystem.h
    
    """
    ...

class QuartzSubsystem(TickableWorldSubsystem):
    r"""
    Quartz Subsystem
    
    **C++ Source:**
    
    - **Module**: AudioMixer
    - **File**: QuartzSubsystem.h
    
    """
    def set_quartz_subsystem_tickable_when_paused(self, tickable_when_paused: bool) -> None:
        r"""
        x.set_quartz_subsystem_tickable_when_paused(tickable_when_paused) -> None
        Set Quartz Subsystem Tickable when Paused
        
        Args:
            tickable_when_paused (bool):
        """
        ...
    def is_quartz_enabled(self) -> bool:
        r"""
        x.is_quartz_enabled() -> bool
        Is Quartz Enabled
        
        Returns:
            bool:
        """
        ...
    def is_clock_running(self, world_context_object: Object, clock_name: Name) -> bool:
        r"""
        x.is_clock_running(world_context_object, clock_name) -> bool
        returns true if the clock is running
        
        Args:
            world_context_object (Object): 
            clock_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def get_round_trip_min_latency(self, world_context_object: Object) -> float:
        r"""
        x.get_round_trip_min_latency(world_context_object) -> float
        Get Round Trip Min Latency
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_round_trip_max_latency(self, world_context_object: Object) -> float:
        r"""
        x.get_round_trip_max_latency(world_context_object) -> float
        Get Round Trip Max Latency
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_round_trip_average_latency(self, world_context_object: Object) -> float:
        r"""
        x.get_round_trip_average_latency(world_context_object) -> float
        latency data (Round trip)
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_handle_for_clock(self, world_context_object: Object, clock_name: Name) -> QuartzClockHandle:
        r"""
        x.get_handle_for_clock(world_context_object, clock_name) -> QuartzClockHandle
        get handle for existing clock
        
        Args:
            world_context_object (Object): 
            clock_name (Name): 
        
        Returns:
            QuartzClockHandle:
        """
        ...
    def get_game_thread_to_audio_render_thread_min_latency(self, world_context_object: Object) -> float:
        r"""
        x.get_game_thread_to_audio_render_thread_min_latency(world_context_object) -> float
        Get Game Thread to Audio Render Thread Min Latency
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_game_thread_to_audio_render_thread_max_latency(self, world_context_object: Object) -> float:
        r"""
        x.get_game_thread_to_audio_render_thread_max_latency(world_context_object) -> float
        Get Game Thread to Audio Render Thread Max Latency
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_game_thread_to_audio_render_thread_average_latency(self, world_context_object: Object) -> float:
        r"""
        x.get_game_thread_to_audio_render_thread_average_latency(world_context_object) -> float
        latency data (Game thread -> Audio Render Thread)
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float:
        """
        ...
    def get_estimated_clock_run_time(self, world_context_object: Object, clock_name: Name) -> float:
        r"""
        x.get_estimated_clock_run_time(world_context_object, clock_name) -> float
        Returns the amount of time, in seconds, the clock has been running. Caution: due to latency, this will not be perfectly accurate
        
        Args:
            world_context_object (Object): 
            clock_name (Name): 
        
        Returns:
            float:
        """
        ...
    def get_duration_of_quantization_type_in_seconds(self, world_context_object: Object, clock_name: Name, quantization_type: QuartzCommandQuantization, multiplier: float = 1.000000) -> float:
        r"""
        x.get_duration_of_quantization_type_in_seconds(world_context_object, clock_name, quantization_type, multiplier=1.000000) -> float
        Returns the duration in seconds of the given Quantization Type
        
        Args:
            world_context_object (Object): 
            clock_name (Name): 
            quantization_type (QuartzCommandQuantization): 
            multiplier (float): 
        
        Returns:
            float:
        """
        ...
    def get_current_clock_timestamp(self, world_context_object: Object, clock_name: Name) -> QuartzTransportTimeStamp:
        r"""
        x.get_current_clock_timestamp(world_context_object, clock_name) -> QuartzTransportTimeStamp
        Retrieves a timestamp for the clock
        
        Args:
            world_context_object (Object): 
            clock_name (Name): 
        
        Returns:
            QuartzTransportTimeStamp:
        """
        ...
    def get_audio_render_thread_to_game_thread_min_latency(self) -> float:
        r"""
        x.get_audio_render_thread_to_game_thread_min_latency() -> float
        Get Audio Render Thread to Game Thread Min Latency
        
        Returns:
            float:
        """
        ...
    def get_audio_render_thread_to_game_thread_max_latency(self) -> float:
        r"""
        x.get_audio_render_thread_to_game_thread_max_latency() -> float
        Get Audio Render Thread to Game Thread Max Latency
        
        Returns:
            float:
        """
        ...
    def get_audio_render_thread_to_game_thread_average_latency(self) -> float:
        r"""
        x.get_audio_render_thread_to_game_thread_average_latency() -> float
        latency data (Audio Render Thread -> Game thread)
        
        Returns:
            float:
        """
        ...
    def does_clock_exist(self, world_context_object: Object, clock_name: Name) -> bool:
        r"""
        x.does_clock_exist(world_context_object, clock_name) -> bool
        returns true if the clock exists
        
        Args:
            world_context_object (Object): 
            clock_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def delete_clock_by_name(self, world_context_object: Object, clock_name: Name) -> None:
        r"""
        x.delete_clock_by_name(world_context_object, clock_name) -> None
        delete an existing clock given its name
        
        Args:
            world_context_object (Object): 
            clock_name (Name):
        """
        ...
    def delete_clock_by_handle(self, world_context_object: Object, clock_handle: QuartzClockHandle) -> QuartzClockHandle:
        r"""
        x.delete_clock_by_handle(world_context_object, clock_handle) -> QuartzClockHandle
        delete an existing clock given its clock handle
        
        Args:
            world_context_object (Object): 
            clock_handle (QuartzClockHandle): 
        
        Returns:
            QuartzClockHandle: 
        
            clock_handle (QuartzClockHandle):
        """
        ...
    def create_new_clock(self, world_context_object: Object, clock_name: Name, settings: QuartzClockSettings, override_settings_if_clock_exists: bool = False, use_audio_engine_clock_manager: bool = True) -> QuartzClockHandle:
        r"""
        x.create_new_clock(world_context_object, clock_name, settings, override_settings_if_clock_exists=False, use_audio_engine_clock_manager=True) -> QuartzClockHandle
        Clock Creation
        create a new clock (or return handle if clock already exists)
        
        Args:
            world_context_object (Object): 
            clock_name (Name): 
            settings (QuartzClockSettings): 
            override_settings_if_clock_exists (bool): 
            use_audio_engine_clock_manager (bool): 
        
        Returns:
            QuartzClockHandle:
        """
        ...

class StreamableRenderAsset(Object):
    r"""
    Streamable Render Asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StreamableRenderAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``never_stream`` (bool):  [Read-Write]
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    """
    @property
    def num_cinematic_mip_levels(self) -> int:
        r"""
        (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
        """
        ...
    @num_cinematic_mip_levels.setter
    def num_cinematic_mip_levels(self, value: int) -> None:
        ...
    @property
    def never_stream(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @never_stream.setter
    def never_stream(self, value: bool) -> None:
        ...
    @property
    def global_force_mip_levels_to_be_resident(self) -> bool:
        r"""
        (bool):  [Read-Only] Global and serialized version of ForceMiplevelsToBeResident.
        """
        ...
    def set_force_mip_levels_to_be_resident(self, seconds: float, cinematic_lod_group_mask: int = 0) -> None:
        r"""
        x.set_force_mip_levels_to_be_resident(seconds, cinematic_lod_group_mask=0) -> None
        Tells the streaming system that it should force all mip-levels to be resident for a number of seconds.
        
        Args:
            seconds (float): Duration in seconds
            cinematic_lod_group_mask (int32):
        """
        ...

class Texture(StreamableRenderAsset):
    r"""
    Texture
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Texture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    @property
    def adjust_brightness(self) -> float:
        r"""
        (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
        """
        ...
    @adjust_brightness.setter
    def adjust_brightness(self, value: float) -> None:
        ...
    @property
    def adjust_brightness_curve(self) -> float:
        r"""
        (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
        """
        ...
    @adjust_brightness_curve.setter
    def adjust_brightness_curve(self, value: float) -> None:
        ...
    @property
    def adjust_vibrance(self) -> float:
        r"""
        (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
        """
        ...
    @adjust_vibrance.setter
    def adjust_vibrance(self, value: float) -> None:
        ...
    @property
    def adjust_saturation(self) -> float:
        r"""
        (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
        """
        ...
    @adjust_saturation.setter
    def adjust_saturation(self, value: float) -> None:
        ...
    @property
    def adjust_rgb_curve(self) -> float:
        r"""
        (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
        """
        ...
    @adjust_rgb_curve.setter
    def adjust_rgb_curve(self, value: float) -> None:
        ...
    @property
    def adjust_hue(self) -> float:
        r"""
        (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
        """
        ...
    @adjust_hue.setter
    def adjust_hue(self, value: float) -> None:
        ...
    @property
    def adjust_min_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
        """
        ...
    @adjust_min_alpha.setter
    def adjust_min_alpha(self, value: float) -> None:
        ...
    @property
    def adjust_max_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
        """
        ...
    @adjust_max_alpha.setter
    def adjust_max_alpha(self, value: float) -> None:
        ...
    @property
    def compression_no_alpha(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
        """
        ...
    @compression_no_alpha.setter
    def compression_no_alpha(self, value: bool) -> None:
        ...
    @property
    def compress_final(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
        """
        ...
    @compress_final.setter
    def compress_final(self, value: bool) -> None:
        ...
    @property
    def defer_compression(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
        """
        ...
    @defer_compression.setter
    def defer_compression(self, value: bool) -> None:
        ...
    @property
    def lossy_compression_amount(self) -> TextureLossyCompressionAmount:
        r"""
        (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
             applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
             unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
        """
        ...
    @lossy_compression_amount.setter
    def lossy_compression_amount(self, value: TextureLossyCompressionAmount) -> None:
        ...
    @property
    def oodle_texture_sdk_version(self) -> Name:
        r"""
        (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
        """
        ...
    @oodle_texture_sdk_version.setter
    def oodle_texture_sdk_version(self, value: Name) -> None:
        ...
    @property
    def max_texture_size(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
        """
        ...
    @max_texture_size.setter
    def max_texture_size(self, value: int) -> None:
        ...
    @property
    def compression_quality(self) -> TextureCompressionQuality:
        r"""
        (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
        """
        ...
    @compression_quality.setter
    def compression_quality(self, value: TextureCompressionQuality) -> None:
        ...
    @property
    def do_scale_mips_for_alpha_coverage(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
        """
        ...
    @do_scale_mips_for_alpha_coverage.setter
    def do_scale_mips_for_alpha_coverage(self, value: bool) -> None:
        ...
    @property
    def alpha_coverage_thresholds(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
        """
        ...
    @alpha_coverage_thresholds.setter
    def alpha_coverage_thresholds(self, value: Vector4) -> None:
        ...
    @property
    def use_new_mip_filter(self) -> bool:
        r"""
        (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
        """
        ...
    @use_new_mip_filter.setter
    def use_new_mip_filter(self, value: bool) -> None:
        ...
    @property
    def preserve_border(self) -> bool:
        r"""
        (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
        """
        ...
    @preserve_border.setter
    def preserve_border(self, value: bool) -> None:
        ...
    @property
    def flip_green_channel(self) -> bool:
        r"""
        (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
        """
        ...
    @flip_green_channel.setter
    def flip_green_channel(self, value: bool) -> None:
        ...
    @property
    def power_of_two_mode(self) -> TexturePowerOfTwoSetting:
        r"""
        (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
        """
        ...
    @power_of_two_mode.setter
    def power_of_two_mode(self, value: TexturePowerOfTwoSetting) -> None:
        ...
    @property
    def padding_color(self) -> Color:
        r"""
        (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
        """
        ...
    @padding_color.setter
    def padding_color(self, value: Color) -> None:
        ...
    @property
    def pad_with_border_color(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
        """
        ...
    @pad_with_border_color.setter
    def pad_with_border_color(self, value: bool) -> None:
        ...
    @property
    def resize_during_build_x(self) -> int:
        r"""
        (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
        """
        ...
    @resize_during_build_x.setter
    def resize_during_build_x(self, value: int) -> None:
        ...
    @property
    def resize_during_build_y(self) -> int:
        r"""
        (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
        """
        ...
    @resize_during_build_y.setter
    def resize_during_build_y(self, value: int) -> None:
        ...
    @property
    def chroma_key_texture(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
        """
        ...
    @chroma_key_texture.setter
    def chroma_key_texture(self, value: bool) -> None:
        ...
    @property
    def chroma_key_threshold(self) -> float:
        r"""
        (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
        """
        ...
    @chroma_key_threshold.setter
    def chroma_key_threshold(self, value: float) -> None:
        ...
    @property
    def chroma_key_color(self) -> Color:
        r"""
        (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
        """
        ...
    @chroma_key_color.setter
    def chroma_key_color(self, value: Color) -> None:
        ...
    @property
    def mip_gen_settings(self) -> TextureMipGenSettings:
        r"""
        (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
        """
        ...
    @mip_gen_settings.setter
    def mip_gen_settings(self, value: TextureMipGenSettings) -> None:
        ...
    @property
    def composite_texture(self) -> Texture:
        r"""
        (Texture):  [Read-Write]
        """
        ...
    @composite_texture.setter
    def composite_texture(self, value: Texture) -> None:
        ...
    @property
    def composite_texture_mode(self) -> CompositeTextureMode:
        r"""
        (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
        """
        ...
    @composite_texture_mode.setter
    def composite_texture_mode(self, value: CompositeTextureMode) -> None:
        ...
    @property
    def composite_power(self) -> float:
        r"""
        (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
        this is not a slider because the texture update would not be fast enough
        """
        ...
    @composite_power.setter
    def composite_power(self, value: float) -> None:
        ...
    @property
    def lod_bias(self) -> int:
        r"""
        (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
        """
        ...
    @lod_bias.setter
    def lod_bias(self, value: int) -> None:
        ...
    @property
    def compression_settings(self) -> TextureCompressionSettings:
        r"""
        (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
        """
        ...
    @compression_settings.setter
    def compression_settings(self, value: TextureCompressionSettings) -> None:
        ...
    @property
    def filter(self) -> TextureFilter:
        r"""
        (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
        """
        ...
    @filter.setter
    def filter(self, value: TextureFilter) -> None:
        ...
    @property
    def mip_load_options(self) -> TextureMipLoadOptions:
        r"""
        (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
        """
        ...
    @mip_load_options.setter
    def mip_load_options(self, value: TextureMipLoadOptions) -> None:
        ...
    @property
    def cook_platform_tiling_settings(self) -> TextureCookPlatformTilingSettings:
        r"""
        (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
        """
        ...
    @cook_platform_tiling_settings.setter
    def cook_platform_tiling_settings(self, value: TextureCookPlatformTilingSettings) -> None:
        ...
    @property
    def oodle_preserve_extremes(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
        """
        ...
    @oodle_preserve_extremes.setter
    def oodle_preserve_extremes(self, value: bool) -> None:
        ...
    @property
    def lod_group(self) -> TextureGroup:
        r"""
        (TextureGroup):  [Read-Write] Texture group this texture belongs to
        """
        ...
    @lod_group.setter
    def lod_group(self, value: TextureGroup) -> None:
        ...
    @property
    def availability(self) -> TextureAvailability:
        r"""
        (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
        For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
        """
        ...
    @availability.setter
    def availability(self, value: TextureAvailability) -> None:
        ...
    @property
    def srgb(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
        """
        ...
    @srgb.setter
    def srgb(self, value: bool) -> None:
        ...
    @property
    def normalize_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
        """
        ...
    @normalize_normals.setter
    def normalize_normals(self, value: bool) -> None:
        ...
    @property
    def use_legacy_gamma(self) -> bool:
        r"""
        (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
        """
        ...
    @use_legacy_gamma.setter
    def use_legacy_gamma(self, value: bool) -> None:
        ...
    @property
    def source_color_settings(self) -> TextureSourceColorSettings:
        r"""
        (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
        """
        ...
    @source_color_settings.setter
    def source_color_settings(self, value: TextureSourceColorSettings) -> None:
        ...
    @property
    def virtual_texture_streaming(self) -> bool:
        r"""
        (bool):  [Read-Only] Is this texture streamed in using VT
        """
        ...
    def compute_texture_source_channel_min_max(self) -> Optional[Tuple[LinearColor, LinearColor]]:
        r"""
        x.compute_texture_source_channel_min_max() -> (out_color_min=LinearColor, out_color_max=LinearColor) or None
        Scan the texture source pixels to compute the min & max values of the RGBA channels.
        Uses texture source, not available in runtime games.
        Causes texture source data to be loaded, is computed by scanning pixels when called.
        Will set Min=Max=zero and return false on failure
        
        Returns:
            tuple or None: 
        
            out_color_min (LinearColor): 
        
            out_color_max (LinearColor):
        """
        ...
    def blueprint_get_texture_source_disk_and_memory_size(self) -> Tuple[int, int]:
        r"""
        x.blueprint_get_texture_source_disk_and_memory_size() -> (out_disk_size=int64, out_memory_size=int64)
        Gets the memory size of the texture source top mip, in bytes, and the size on disk of the asset, which may be compressed.
        Uses texture source, not available in runtime games.
        Does not cause texture source to be loaded, queries cached values.
        Returns zero for error.
        
        Returns:
            tuple: 
        
            out_disk_size (int64): 
        
            out_memory_size (int64):
        """
        ...
    def blueprint_get_memory_size(self) -> int:
        r"""
        x.blueprint_get_memory_size() -> int64
        Gets the memory size of the texture, in bytes.
        This is the size in GPU memory of the built platformdata, accounting for LODBias, etc.
        Returns zero for error.
        
        Returns:
            int64:
        """
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...
    def export_to_disk(self, filename: str, options: ImageWriteOptions) -> None:
        r"""
        x.export_to_disk(filename, options) -> None
        Export the specified texture to disk
        
        Args:
            filename (str): The filename on disk to save as
            options (ImageWriteOptions): Parameters defining the various export options
        """
        ...

class MediaTexture(Texture):
    r"""
    Implements a texture asset for rendering video tracks from UMediaPlayer assets.
    
    note: derives directly from UTexture, not from UTexture2D or UTexture2DDynamic
       maybe should have been UTexture2DDynamic?
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``auto_clear`` (bool):  [Read-Write] Whether to clear the texture when no media is being played (default = enabled).
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``clear_color`` (LinearColor):  [Read-Write] The color used to clear the texture if AutoClear is enabled (default = black).
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``current_aspect_ratio`` (float):  [Read-Write] Current aspect ratio
    - ``current_orientation`` (MediaTextureOrientation):  [Read-Write] Current media orientation
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``enable_gen_mips`` (bool):  [Read-Write] Basic enablement for mip generation (default = false).
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``media_player`` (MediaPlayer):  [Read-Write] The media player asset associated with this texture.
      
      This property is meant for design-time convenience. To change the
      associated media player at run-time, use the SetMediaPlayer method.
      see: SetMediaPlayer
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``new_style_output`` (bool):  [Read-Write] Enable new style output.
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``num_mips`` (uint8):  [Read-Write] The number of mips to use (default = 1).
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``output_format`` (MediaTextureOutputFormat):  [Read-Write] DEPRECATED 5.4
      deprecated: Output format was unused (not connected to active logic) and is now deprecated. References to it can be safely deleted.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    @property
    def address_x(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
        """
        ...
    @address_x.setter
    def address_x(self, value: TextureAddress) -> None:
        ...
    @property
    def address_y(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
        """
        ...
    @address_y.setter
    def address_y(self, value: TextureAddress) -> None:
        ...
    @property
    def auto_clear(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to clear the texture when no media is being played (default = enabled).
        """
        ...
    @auto_clear.setter
    def auto_clear(self, value: bool) -> None:
        ...
    @property
    def clear_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] The color used to clear the texture if AutoClear is enabled (default = black).
        """
        ...
    @clear_color.setter
    def clear_color(self, value: LinearColor) -> None:
        ...
    @property
    def enable_gen_mips(self) -> bool:
        r"""
        (bool):  [Read-Only] Basic enablement for mip generation (default = false).
        """
        ...
    @property
    def num_mips(self) -> int:
        r"""
        (uint8):  [Read-Write] The number of mips to use (default = 1).
        """
        ...
    @num_mips.setter
    def num_mips(self, value: int) -> None:
        ...
    @property
    def new_style_output(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable new style output.
        """
        ...
    @new_style_output.setter
    def new_style_output(self, value: bool) -> None:
        ...
    @property
    def output_format(self) -> MediaTextureOutputFormat:
        r"""
        (MediaTextureOutputFormat):  [Read-Write] DEPRECATED 5.4
        deprecated: Output format was unused (not connected to active logic) and is now deprecated. References to it can be safely deleted.
        """
        ...
    @output_format.setter
    def output_format(self, value: MediaTextureOutputFormat) -> None:
        ...
    @property
    def current_aspect_ratio(self) -> float:
        r"""
        (float):  [Read-Only] Current aspect ratio
        """
        ...
    @property
    def current_orientation(self) -> MediaTextureOrientation:
        r"""
        (MediaTextureOrientation):  [Read-Only] Current media orientation
        """
        ...
    def update_resource(self) -> None:
        r"""
        x.update_resource() -> None
        Creates a new resource for the texture, and updates any cached references to the resource.
        This obviously is just an override to expose to blueprints.
        """
        ...
    def set_media_player(self, new_media_player: MediaPlayer) -> None:
        r"""
        x.set_media_player(new_media_player) -> None
        Set the media player that provides the video samples.
        see: GetMediaPlayer
        
        Args:
            new_media_player (MediaPlayer): The player to set.
        """
        ...
    def get_width(self) -> int:
        r"""
        x.get_width() -> int32
        Gets the current width of the texture.
        see: GetAspectRatio, GetHeight
        
        Returns:
            int32: Texture width (in pixels).
        """
        ...
    def get_texture_num_mips(self) -> int:
        r"""
        x.get_texture_num_mips() -> int32
        Gets the current numbe of mips of the texture.
        
        Returns:
            int32: Number of mips.
        """
        ...
    def get_media_player(self) -> MediaPlayer:
        r"""
        x.get_media_player() -> MediaPlayer
        Get the media player that provides the video samples.
        see: SetMediaPlayer
        
        Returns:
            MediaPlayer: The texture's media player, or nullptr if not set.
        """
        ...
    def get_height(self) -> int:
        r"""
        x.get_height() -> int32
        Gets the current height of the texture.
        see: GetAspectRatio, GetWidth
        
        Returns:
            int32: Texture height (in pixels).
        """
        ...
    def get_aspect_ratio(self) -> float:
        r"""
        x.get_aspect_ratio() -> float
        Gets the current aspect ratio of the texture.
        see: GetHeight, GetWidth
        
        Returns:
            float: Texture aspect ratio.
        """
        ...

class MediaSource(Object):
    r"""
    Abstract base class for media sources.
    
    Media sources describe the location and/or settings of media objects that can
    be played in a media player, such as a video file on disk, a video stream on
    the internet, or a web cam attached to or built into the target device. The
    location is encoded as a media URL string, whose URI scheme and optional file
    extension will be used to locate a suitable media player.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaSource.h
    
    """
    def validate(self) -> bool:
        r"""
        x.validate() -> bool
        Validate the media source settings (must be implemented in child classes).
        
        Returns:
            bool: true if validation passed, false otherwise.
        """
        ...
    def set_media_option_string(self, key: Name, value: str) -> None:
        r"""
        x.set_media_option_string(key, value) -> None
        Set a string parameter to pass to the player.
        
        Args:
            key (Name): 
            value (str):
        """
        ...
    def set_media_option_int64(self, key: Name, value: int) -> None:
        r"""
        x.set_media_option_int64(key, value) -> None
        Set an integer64 parameter to pass to the player.
        
        Args:
            key (Name): 
            value (int64):
        """
        ...
    def set_media_option_float(self, key: Name, value: float) -> None:
        r"""
        x.set_media_option_float(key, value) -> None
        Set a float parameter to pass to the player.
        
        Args:
            key (Name): 
            value (float):
        """
        ...
    def set_media_option_bool(self, key: Name, value: bool) -> None:
        r"""
        x.set_media_option_bool(key, value) -> None
        Set a boolean parameter to pass to the player.
        
        Args:
            key (Name): 
            value (bool):
        """
        ...
    def get_url(self) -> str:
        r"""
        x.get_url() -> str
        Get the media source's URL string (must be implemented in child classes).
        see: GetProxies
        
        Returns:
            str: The media URL.
        """
        ...

class BaseMediaSource(MediaSource):
    r"""
    Base class for concrete media sources.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: BaseMediaSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``platform_player_names`` (Map[str, Name]):  [Read-Write] Override native media player plug-ins per platform (Empty = find one automatically).
    """
    @property
    def platform_player_names(self) -> Map[str, Name]:
        r"""
        (Map[str, Name]):  [Read-Write] Override native media player plug-ins per platform (Empty = find one automatically).
        """
        ...
    @platform_player_names.setter
    def platform_player_names(self, value: Map[str, Name]) -> None:
        ...

class FileMediaSource(BaseMediaSource):
    r"""
    File Media Source
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: FileMediaSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``file_path`` (str):  [Read-Write] The path to the media file to be played.
      see: SetFilePath
    - ``platform_player_names`` (Map[str, Name]):  [Read-Write] Override native media player plug-ins per platform (Empty = find one automatically).
    - ``precache_file`` (bool):  [Read-Write] Load entire media file into memory and play from there (if possible).
    """
    @property
    def file_path(self) -> str:
        r"""
        (str):  [Read-Write] The path to the media file to be played.
        see: SetFilePath
        """
        ...
    @file_path.setter
    def file_path(self, value: str) -> None:
        ...
    @property
    def precache_file(self) -> bool:
        r"""
        (bool):  [Read-Write] Load entire media file into memory and play from there (if possible).
        """
        ...
    @precache_file.setter
    def precache_file(self, value: bool) -> None:
        ...
    def set_file_path(self, path: str) -> None:
        r"""
        x.set_file_path(path) -> None
        Set the path to the media file that this source represents.
        
        Automatically converts full paths to media sources that reside in the
        Engine's or project's /Content/Movies directory into relative paths.
        see: FilePath, GetFilePath
        
        Args:
            path (str): The path to set.
        """
        ...

class MediaComponent(ActorComponent):
    r"""
    Media Component
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``media_player`` (MediaPlayer):  [Read-Write] This component's media player
    - ``media_texture`` (MediaTexture):  [Read-Write] This component's media texture
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def media_texture(self) -> MediaTexture:
        r"""
        (MediaTexture):  [Read-Only] This component's media texture
        """
        ...
    @property
    def media_player(self) -> MediaPlayer:
        r"""
        (MediaPlayer):  [Read-Only] This component's media player
        """
        ...
    def get_media_texture(self) -> MediaTexture:
        r"""
        x.get_media_texture() -> MediaTexture
        Get the media texture that this component owns, bound to its media player.
        
        Returns:
            MediaTexture:
        """
        ...
    def get_media_player(self) -> MediaPlayer:
        r"""
        x.get_media_player() -> MediaPlayer
        Get the media player that this component owns
        
        Returns:
            MediaPlayer:
        """
        ...

class MediaTimeStampInfo(Object):
    r"""
    Media Time Stamp Info
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaPlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``sequence_index`` (int64):  [Read-Write]
    - ``time`` (Timespan):  [Read-Write]
    """
    @property
    def time(self) -> Timespan:
        r"""
        (Timespan):  [Read-Only]
        """
        ...
    @property
    def sequence_index(self) -> int:
        r"""
        (int64):  [Read-Only]
        """
        ...

class MediaPlayer(Object):
    r"""
    Implements a media player asset that can play movies and other media sources.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaPlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affected_by_pie_handling`` (bool):  [Read-Write] Whether this player should stop when entering or exiting PIE.
    - ``cache_ahead`` (Timespan):  [Read-Write] Duration of samples to cache ahead of the play head.
      see: CacheBehind, CacheBehindGame
    - ``cache_behind`` (Timespan):  [Read-Write] Duration of samples to cache behind the play head (when not running as game).
      see: CacheAhead, CacheBehindGame
    - ``cache_behind_game`` (Timespan):  [Read-Write] Duration of samples to cache behind the play head (when running as game).
      see: CacheAhead, CacheBehind
    - ``horizontal_field_of_view`` (float):  [Read-Write] The initial horizontal field of view (in Euler degrees; default = 90).
      
      This setting is used only for 360 videos. It determines the portion of the
      video that is visible at a time. To modify the field of view at runtime in
      Blueprints, use the SetHorizontalFieldOfView function.
      see: GetHorizontalFieldOfView, SetHorizontalFieldOfView, VerticalFieldOfView, ViewRotation
    - ``loop`` (bool):  [Read-Write] Whether the player should loop when media playback reaches the end.
      
      Use the SetLooping function to change this value at runtime.
      see: IsLooping, SetLooping
    - ``native_audio_out`` (bool):  [Read-Write] Output any audio via the operating system's sound mixer instead of a Sound Wave asset.
      
      If enabled, the assigned Sound Wave asset will be ignored. The SetNativeVolume
      function can then be used to change the audio output volume at runtime. Note that
      not all media player plug-ins may support native audio output on all platforms.
      see: SetNativeVolume
    - ``on_end_reached`` (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when playback has reached the end of the media.
    - ``on_media_closed`` (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when a media source has been closed.
    - ``on_media_open_failed`` (OnMediaPlayerMediaOpenFailed):  [Read-Write] A delegate that is invoked when a media source has failed to open.
      
      This delegate is only executed if OpenSource / OpenUrl returned true and
      the media failed to open asynchronously later. It is not executed if
      OpenSource / OpenUrl returned false, indicating an immediate failure.
      see: OnMediaOpened
    - ``on_media_opened`` (OnMediaPlayerMediaOpened):  [Read-Write] A delegate that is invoked when a media source has been opened.
      
      Depending on whether the underlying player implementation opens the media
      synchronously or asynchronously, this event may be executed before or
      after the call to OpenSource / OpenUrl returns.
      see: OnMediaOpenFailed, OnTracksChanged
    - ``on_metadata_changed`` (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when the media metadata changed.
      see: OnMediaOpened
    - ``on_playback_resumed`` (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when media playback has been resumed.
      see: OnPlaybackSuspended
    - ``on_playback_suspended`` (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when media playback has been suspended.
      see: OnPlaybackResumed
    - ``on_seek_completed`` (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when a seek operation completed successfully.
      
      Depending on whether the underlying player implementation performs seeks
      synchronously or asynchronously, this event may be executed before or
      after the call to Seek returns.
    - ``on_tracks_changed`` (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when the media track collection changed.
      see: OnMediaOpened
    - ``play_on_open`` (bool):  [Read-Write] Automatically start playback after media opened successfully.
      
      If disabled, listen to the OnMediaOpened Blueprint event to detect when
      the media finished opening, and then start playback using the Play function.
      see: OpenFile, OpenPlaylist, OpenPlaylistIndex, OpenSource, OpenUrl, Play
    - ``playlist`` (MediaPlaylist):  [Read-Write] The play list to use, if any.
      
      Use the OpenPlaylist or OpenPlaylistIndex function to change this value at runtime.
      see: OpenPlaylist, OpenPlaylistIndex
    - ``playlist_index`` (int32):  [Read-Write] The current index of the source in the play list being played.
      
      Use the Previous and Next methods to change this value at runtime.
      see: Next, Previous
    - ``shuffle`` (bool):  [Read-Write] Whether playback should shuffle media sources in the play list.
      see: OpenPlaylist, OpenPlaylistIndex
    - ``time_delay`` (Timespan):  [Read-Write] Delay of the player's time.
      see: SetTimeDelay, GetTimeDelay
    - ``vertical_field_of_view`` (float):  [Read-Write] The initial vertical field of view (in Euler degrees; default = 60).
      
      This setting is used only for 360 videos. It determines the portion of the
      video that is visible at a time. To modify the field of view at runtime in
      Blueprints, use the SetHorizontalFieldOfView function.
      
      Please note that some 360 video players may be able to change only the
      horizontal field of view, and this setting may be ignored.
      see: GetVerticalFieldOfView, SetVerticalFieldOfView, HorizontalFieldOfView, ViewRotation
    - ``view_rotation`` (Rotator):  [Read-Write] The initial view rotation.
      
      This setting is used only for 360 videos. It determines the rotation of
      the video's view. To modify the view orientation at runtime in Blueprints,
      use the GetViewRotation and SetViewRotation functions.
      
      Please note that not all players may support video view rotations.
      see: GetViewRotation, SetViewRotation, HorizontalFieldOfView, VerticalFieldOfView
    """
    @property
    def on_end_reached(self) -> OnMediaPlayerMediaEvent:
        r"""
        (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when playback has reached the end of the media.
        """
        ...
    @on_end_reached.setter
    def on_end_reached(self, value: OnMediaPlayerMediaEvent) -> None:
        ...
    @property
    def on_media_closed(self) -> OnMediaPlayerMediaEvent:
        r"""
        (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when a media source has been closed.
        """
        ...
    @on_media_closed.setter
    def on_media_closed(self, value: OnMediaPlayerMediaEvent) -> None:
        ...
    @property
    def on_media_opened(self) -> OnMediaPlayerMediaOpened:
        r"""
        (OnMediaPlayerMediaOpened):  [Read-Write] A delegate that is invoked when a media source has been opened.
        
        Depending on whether the underlying player implementation opens the media
        synchronously or asynchronously, this event may be executed before or
        after the call to OpenSource / OpenUrl returns.
        see: OnMediaOpenFailed, OnTracksChanged
        """
        ...
    @on_media_opened.setter
    def on_media_opened(self, value: OnMediaPlayerMediaOpened) -> None:
        ...
    @property
    def on_media_open_failed(self) -> OnMediaPlayerMediaOpenFailed:
        r"""
        (OnMediaPlayerMediaOpenFailed):  [Read-Write] A delegate that is invoked when a media source has failed to open.
        
        This delegate is only executed if OpenSource / OpenUrl returned true and
        the media failed to open asynchronously later. It is not executed if
        OpenSource / OpenUrl returned false, indicating an immediate failure.
        see: OnMediaOpened
        """
        ...
    @on_media_open_failed.setter
    def on_media_open_failed(self, value: OnMediaPlayerMediaOpenFailed) -> None:
        ...
    @property
    def on_playback_resumed(self) -> OnMediaPlayerMediaEvent:
        r"""
        (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when media playback has been resumed.
        see: OnPlaybackSuspended
        """
        ...
    @on_playback_resumed.setter
    def on_playback_resumed(self, value: OnMediaPlayerMediaEvent) -> None:
        ...
    @property
    def on_playback_suspended(self) -> OnMediaPlayerMediaEvent:
        r"""
        (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when media playback has been suspended.
        see: OnPlaybackResumed
        """
        ...
    @on_playback_suspended.setter
    def on_playback_suspended(self, value: OnMediaPlayerMediaEvent) -> None:
        ...
    @property
    def on_seek_completed(self) -> OnMediaPlayerMediaEvent:
        r"""
        (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when a seek operation completed successfully.
        
        Depending on whether the underlying player implementation performs seeks
        synchronously or asynchronously, this event may be executed before or
        after the call to Seek returns.
        """
        ...
    @on_seek_completed.setter
    def on_seek_completed(self, value: OnMediaPlayerMediaEvent) -> None:
        ...
    @property
    def on_tracks_changed(self) -> OnMediaPlayerMediaEvent:
        r"""
        (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when the media track collection changed.
        see: OnMediaOpened
        """
        ...
    @on_tracks_changed.setter
    def on_tracks_changed(self, value: OnMediaPlayerMediaEvent) -> None:
        ...
    @property
    def on_metadata_changed(self) -> OnMediaPlayerMediaEvent:
        r"""
        (OnMediaPlayerMediaEvent):  [Read-Write] A delegate that is invoked when the media metadata changed.
        see: OnMediaOpened
        """
        ...
    @on_metadata_changed.setter
    def on_metadata_changed(self, value: OnMediaPlayerMediaEvent) -> None:
        ...
    @property
    def cache_ahead(self) -> Timespan:
        r"""
        (Timespan):  [Read-Write] Duration of samples to cache ahead of the play head.
        see: CacheBehind, CacheBehindGame
        """
        ...
    @cache_ahead.setter
    def cache_ahead(self, value: Timespan) -> None:
        ...
    @property
    def cache_behind(self) -> Timespan:
        r"""
        (Timespan):  [Read-Write] Duration of samples to cache behind the play head (when not running as game).
        see: CacheAhead, CacheBehindGame
        """
        ...
    @cache_behind.setter
    def cache_behind(self, value: Timespan) -> None:
        ...
    @property
    def cache_behind_game(self) -> Timespan:
        r"""
        (Timespan):  [Read-Write] Duration of samples to cache behind the play head (when running as game).
        see: CacheAhead, CacheBehind
        """
        ...
    @cache_behind_game.setter
    def cache_behind_game(self, value: Timespan) -> None:
        ...
    @property
    def native_audio_out(self) -> bool:
        r"""
        (bool):  [Read-Write] Output any audio via the operating system's sound mixer instead of a Sound Wave asset.
        
        If enabled, the assigned Sound Wave asset will be ignored. The SetNativeVolume
        function can then be used to change the audio output volume at runtime. Note that
        not all media player plug-ins may support native audio output on all platforms.
        see: SetNativeVolume
        """
        ...
    @native_audio_out.setter
    def native_audio_out(self, value: bool) -> None:
        ...
    @property
    def play_on_open(self) -> bool:
        r"""
        (bool):  [Read-Write] Automatically start playback after media opened successfully.
        
        If disabled, listen to the OnMediaOpened Blueprint event to detect when
        the media finished opening, and then start playback using the Play function.
        see: OpenFile, OpenPlaylist, OpenPlaylistIndex, OpenSource, OpenUrl, Play
        """
        ...
    @play_on_open.setter
    def play_on_open(self, value: bool) -> None:
        ...
    @property
    def shuffle(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether playback should shuffle media sources in the play list.
        see: OpenPlaylist, OpenPlaylistIndex
        """
        ...
    @shuffle.setter
    def shuffle(self, value: bool) -> None:
        ...
    @property
    def loop(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the player should loop when media playback reaches the end.
        
        Use the SetLooping function to change this value at runtime.
        see: IsLooping, SetLooping
        """
        ...
    @property
    def playlist(self) -> MediaPlaylist:
        r"""
        (MediaPlaylist):  [Read-Only] The play list to use, if any.
        
        Use the OpenPlaylist or OpenPlaylistIndex function to change this value at runtime.
        see: OpenPlaylist, OpenPlaylistIndex
        """
        ...
    @property
    def playlist_index(self) -> int:
        r"""
        (int32):  [Read-Only] The current index of the source in the play list being played.
        
        Use the Previous and Next methods to change this value at runtime.
        see: Next, Previous
        """
        ...
    @property
    def time_delay(self) -> Timespan:
        r"""
        (Timespan):  [Read-Only] Delay of the player's time.
        see: SetTimeDelay, GetTimeDelay
        """
        ...
    @property
    def affected_by_pie_handling(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this player should stop when entering or exiting PIE.
        """
        ...
    @affected_by_pie_handling.setter
    def affected_by_pie_handling(self, value: bool) -> None:
        ...
    def supports_seeking(self) -> bool:
        r"""
        x.supports_seeking() -> bool
        Check whether the currently loaded media can jump to a certain position.
        see: SupportsRate, SupportsScrubbing
        
        Returns:
            bool: true if seeking is supported, false otherwise.
        """
        ...
    def supports_scrubbing(self) -> bool:
        r"""
        x.supports_scrubbing() -> bool
        Check whether the currently loaded media supports scrubbing.
        see: SupportsRate, SupportsSeeking
        
        Returns:
            bool: true if scrubbing is supported, false otherwise.
        """
        ...
    def supports_rate(self, rate: float, unthinned: bool) -> bool:
        r"""
        x.supports_rate(rate, unthinned) -> bool
        Check whether the specified playback rate is supported.
        see: SupportsScrubbing, SupportsSeeking
        
        Args:
            rate (float): The playback rate to check.
            unthinned (bool): Whether no frames should be dropped at the given rate.
        
        Returns:
            bool:
        """
        ...
    def supports_playback_time_range(self) -> bool:
        r"""
        x.supports_playback_time_range() -> bool
        Check whether the player supports playing back of range within the media.
        see: GetPlaybackTimeRange, SetPlaybackTimeRange
        
        Returns:
            bool: true if playing back a range is supported, false otherwise.
        """
        ...
    def set_view_rotation(self, rotation: Rotator, absolute: bool) -> bool:
        r"""
        x.set_view_rotation(rotation, absolute) -> bool
        Set the view's rotation (only for 360 videos).
        see: GetViewRotation, SetViewField
        
        Args:
            rotation (Rotator): The desired view rotation.
            absolute (bool): 
        
        Returns:
            bool: true on success, false otherwise.
        """
        ...
    def set_view_field(self, horizontal: float, vertical: float, absolute: bool) -> bool:
        r"""
        x.set_view_field(horizontal, vertical, absolute) -> bool
        Set the field of view (only for 360 videos).
        see: GetHorizontalFieldOfView, GetVerticalFieldOfView, SetViewRotation
        
        Args:
            horizontal (float): Horizontal field of view (in Euler degrees).
            vertical (float): Vertical field of view (in Euler degrees).
            absolute (bool): 
        
        Returns:
            bool: true on success, false otherwise.
        """
        ...
    def set_video_track_frame_rate(self, track_index: int, format_index: int, frame_rate: float) -> bool:
        r"""
        x.set_video_track_frame_rate(track_index, format_index, frame_rate) -> bool
        Set the frame rate of the specified video track.
        see: GetVideoTrackAspectRatio, GetVideoTrackDimensions, GetVideoTrackFrameRate, GetVideoTrackFrameRates, GetVideoTrackType
        
        Args:
            track_index (int32): The index of the track, or INDEX_NONE for the selected one.
            format_index (int32): Index of the track format, or INDEX_NONE for the selected one.
            frame_rate (float): The frame rate to set (must be in range of format's supported frame rates).
        
        Returns:
            bool: true on success, false otherwise.
        """
        ...
    def set_track_format(self, track_type: MediaPlayerTrack, track_index: int, format_index: int) -> bool:
        r"""
        x.set_track_format(track_type, track_index, format_index) -> bool
        Set the format on the specified track.
        
        Selecting the format will not switch to the specified track. To switch
        tracks, use SelectTrack instead. If the track is already selected, the
        format change will be applied immediately.
        see: GetNumTrackFormats, GetNumTracks, GetTrackFormat, SelectTrack
        
        Args:
            track_type (MediaPlayerTrack): The type of track to update.
            track_index (int32): The index of the track to update.
            format_index (int32): The index of the format to select (must be valid).
        
        Returns:
            bool: true if the track was selected, false otherwise.
        """
        ...
    def set_time_delay(self, time_delay: Timespan) -> None:
        r"""
        x.set_time_delay(time_delay) -> None
        Delay of the player's time.
        
        This setting can be used to manually sync multiple sources.
        Set to 1 seconds, if you would like that Player to play 1 second behind its current time.
        If the value is too big, it is possible that the player would not hold that frame for that long.
        see: GetTimeDelay
        
        Args:
            time_delay (Timespan):
        """
        ...
    def set_rate(self, rate: float) -> bool:
        r"""
        x.set_rate(rate) -> bool
        Changes the media's playback rate.
        see: GetRate, SupportsRate
        
        Args:
            rate (float): The playback rate to set.
        
        Returns:
            bool: true on success, false otherwise.
        """
        ...
    def set_playback_time_range(self, time_range: FloatInterval) -> bool:
        r"""
        x.set_playback_time_range(time_range) -> bool
        Blueprint accessible version of SetPlaybackTimeRange().
        The range is set through a blueprint usable float interval which may not have enough
        precision to represent the range accurately.
        
        Args:
            time_range (FloatInterval): 
        
        Returns:
            bool:
        """
        ...
    def set_native_volume(self, volume: float) -> bool:
        r"""
        x.set_native_volume(volume) -> bool
        Set the volume on the native player if not mixing with Sound Wave asset.
        
        The SetNativeVolume can be used to change the audio output volume at runtime. Note that
        not all media player plug-ins may support native audio output on all platforms.
        see: NativeAudioOut
        
        Args:
            volume (float): The volume to set.
        
        Returns:
            bool: true on success, false otherwise.
        """
        ...
    def set_media_options(self, options: MediaSource) -> None:
        r"""
        x.set_media_options(options) -> None
        Sets the media options used by the player.
        
        Args:
            options (MediaSource): Options to pass to the player.
        """
        ...
    def set_looping(self, looping: bool) -> bool:
        r"""
        x.set_looping(looping) -> bool
        Enables or disables playback looping.
        see: IsLooping
        
        Args:
            looping (bool): Whether playback should be looped.
        
        Returns:
            bool: true on success, false otherwise.
        """
        ...
    def set_desired_player_name(self, player_name: Name) -> None:
        r"""
        x.set_desired_player_name(player_name) -> None
        Set the name of the desired native player.
        see: GetDesiredPlayerName
        
        Args:
            player_name (Name): The name of the player to set.
        """
        ...
    def set_block_on_time(self, time: Timespan) -> None:
        r"""
        x.set_block_on_time(time) -> None
        Set the time on which to block.
        
        If set, this player will block in TickInput or TickFetch until the video sample
        for the specified time are actually available.
        
        Args:
            time (Timespan): The time to block on, or FTimespan::MinValue to disable.
        """
        ...
    def select_track(self, track_type: MediaPlayerTrack, track_index: int) -> bool:
        r"""
        x.select_track(track_type, track_index) -> bool
        Select the active track of the given type.
        
        The selected track will use its currently active format. Active formats will
        be remembered on a per track basis. The first available format is active by
        default. To switch the track format, use SetTrackFormat instead.
        see: GetNumTracks, GetSelectedTrack, SetTrackFormat
        
        Args:
            track_type (MediaPlayerTrack): The type of track to select.
            track_index (int32): The index of the track to select, or INDEX_NONE to deselect.
        
        Returns:
            bool: true if the track was selected, false otherwise.
        """
        ...
    def seek(self, time: Timespan) -> bool:
        r"""
        x.seek(time) -> bool
        Seeks to the specified playback time.
        see: GetTime, Rewind
        
        Args:
            time (Timespan): The playback time to set.
        
        Returns:
            bool: true on success, false otherwise.
        """
        ...
    def rewind(self) -> bool:
        r"""
        x.rewind() -> bool
        Rewinds the media to the beginning.
        
        This is the same as seeking to zero time.
        see: GetTime, Seek
        
        Returns:
            bool: true if rewinding, false otherwise.
        """
        ...
    def reopen(self) -> bool:
        r"""
        x.reopen() -> bool
        Reopens the currently opened media or play list.
        see: Close, Open, OpenFile, OpenPlaylist, OpenPlaylistIndex, OpenSource, OpenUrl
        
        Returns:
            bool: true if the media will be opened, false otherwise.
        """
        ...
    def previous(self) -> bool:
        r"""
        x.previous() -> bool
        Open the previous item in the current play list.
        
        The player will start playing the new media source if it was playing
        something previously, otherwise it will only open the media source.
        see: Close, Next, OpenUrl, OpenSource, Play, SetPlaylist
        
        Returns:
            bool: true on success, false otherwise.
        """
        ...
    def play_and_seek(self) -> None:
        r"""
        x.play_and_seek() -> None
        Starts playback from the media opened event, but can be used elsewhere.
        """
        ...
    def play(self) -> bool:
        r"""
        x.play() -> bool
        Starts media playback.
        
        This is the same as setting the playback rate to 1.0.
        see: CanPlay, GetRate, Next, Pause, Previous, SetRate
        
        Returns:
            bool: true if playback is starting, false otherwise.
        """
        ...
    def pause(self) -> bool:
        r"""
        x.pause() -> bool
        Pauses media playback.
        
        This is the same as setting the playback rate to 0.0.
        see: CanPause, Close, Next, Play, Previous, Rewind, Seek
        
        Returns:
            bool: true if playback is being paused, false otherwise.
        """
        ...
    def open_url(self, url: str) -> bool:
        r"""
        x.open_url(url) -> bool
        Opens the specified media URL.
        
        A return value of true indicates that the player will attempt to open
        the media, but it may fail to do so later for other reasons, i.e. if
        a connection to the media server timed out. Use the OnMediaOpened and
        OnMediaOpenFailed delegates to detect if and when the media is ready!
        see: GetUrl, Close, OpenFile, OpenPlaylist, OpenPlaylistIndex, OpenSource, Reopen
        
        Args:
            url (str): The URL to open.
        
        Returns:
            bool: true if the URL will be opened, false otherwise.
        """
        ...
    def open_source_with_options(self, media_source: MediaSource, options: MediaPlayerOptions) -> bool:
        r"""
        x.open_source_with_options(media_source, options) -> bool
        Open the specified media source with supplied options applied.
        
        A return value of true indicates that the player will attempt to open
        the media, but it may fail to do so later for other reasons, i.e. if
        a connection to the media server timed out. Use the OnMediaOpened and
        OnMediaOpenFailed delegates to detect if and when the media is ready!
        see: Close, OpenFile, OpenPlaylist, OpenPlaylistIndex, OpenUrl, Reopen
        
        Args:
            media_source (MediaSource): The media source to open.
            options (MediaPlayerOptions): The media player options to apply.
        
        Returns:
            bool: true if the source will be opened, false otherwise.
        """
        ...
    def open_source_latent(self, world_context_object: Object, latent_info: LatentActionInfo, media_source: MediaSource, options: MediaPlayerOptions) -> bool:
        r"""
        x.open_source_latent(world_context_object, latent_info, media_source, options) -> bool
        Open the specified media source with options using a latent action.
        
        A result of true indicates that the player successfully completed all requested operations.
        see: Close, OpenFile, OpenPlaylist, OpenPlaylistIndex, OpenUrl, Reopen
        
        Args:
            world_context_object (Object): 
            latent_info (LatentActionInfo): 
            media_source (MediaSource): The media source to open.
            options (MediaPlayerOptions): The media player options to apply.
        
        Returns:
            bool: 
        
            success (bool): All requested operations have completed successfully.
        """
        ...
    def open_source(self, media_source: MediaSource) -> bool:
        r"""
        x.open_source(media_source) -> bool
        Open the specified media source.
        
        A return value of true indicates that the player will attempt to open
        the media, but it may fail to do so later for other reasons, i.e. if
        a connection to the media server timed out. Use the OnMediaOpened and
        OnMediaOpenFailed delegates to detect if and when the media is ready!
        see: Close, OpenFile, OpenPlaylist, OpenPlaylistIndex, OpenUrl, Reopen
        
        Args:
            media_source (MediaSource): The media source to open.
        
        Returns:
            bool: true if the source will be opened, false otherwise.
        """
        ...
    def open_playlist_index(self, playlist: MediaPlaylist, index: int) -> bool:
        r"""
        x.open_playlist_index(playlist, index) -> bool
        Open a particular media source in the specified play list.
        see: Close, OpenFile, OpenPlaylist, OpenSource, OpenUrl, Reopen
        
        Args:
            playlist (MediaPlaylist): The play list to open.
            index (int32): The index of the source to open.
        
        Returns:
            bool: true if the source will be opened, false otherwise.
        """
        ...
    def open_playlist(self, playlist: MediaPlaylist) -> bool:
        r"""
        x.open_playlist(playlist) -> bool
        Open the first media source in the specified play list.
        see: Close, OpenFile, OpenPlaylistIndex, OpenSource, OpenUrl, Reopen
        
        Args:
            playlist (MediaPlaylist): The play list to open.
        
        Returns:
            bool: true if the source will be opened, false otherwise.
        """
        ...
    def open_file(self, file_path: str) -> bool:
        r"""
        x.open_file(file_path) -> bool
        Opens the specified media file path.
        
        A return value of true indicates that the player will attempt to open
        the media, but it may fail to do so later for other reasons, i.e. if
        a connection to the media server timed out. Use the OnMediaOpened and
        OnMediaOpenFailed delegates to detect if and when the media is ready!
        see: GetUrl, Close, OpenPlaylist, OpenPlaylistIndex, OpenSource, OpenUrl, Reopen
        
        Args:
            file_path (str): The file path to open.
        
        Returns:
            bool: true if the file path will be opened, false otherwise.
        """
        ...
    def next(self) -> bool:
        r"""
        x.next() -> bool
        Open the next item in the current play list.
        
        The player will start playing the new media source if it was playing
        something previously, otherwise it will only open the media source.
        see: Close, OpenUrl, OpenSource, Play, Previous, SetPlaylist
        
        Returns:
            bool: true on success, false otherwise.
        """
        ...
    def is_ready(self) -> bool:
        r"""
        x.is_ready() -> bool
        Check whether media is ready for playback.
        
        A player is ready for playback if it has a media source opened that
        finished preparing and is not in an error state.
        see: HasError, IsBuffering, IsConnecting, IsLooping, IsPaused, IsPlaying, IsPreparing
        
        Returns:
            bool: true if media is ready, false otherwise.
        """
        ...
    def is_preparing(self) -> bool:
        r"""
        x.is_preparing() -> bool
        Check whether the media is currently opening or buffering.
        see: CanPlay, IsBuffering, IsConnecting, IsLooping, IsPaused, IsPlaying, IsReady, Play
        
        Returns:
            bool: true if playback is being prepared, false otherwise.
        """
        ...
    def is_playing(self) -> bool:
        r"""
        x.is_playing() -> bool
        Check whether playback has started.
        see: CanPlay, IsBuffering, IsConnecting, IsLooping, IsPaused, IsPlaying, IsPreparing, IsReady, Play
        
        Returns:
            bool: true if playback has started, false otherwise.
        """
        ...
    def is_paused(self) -> bool:
        r"""
        x.is_paused() -> bool
        Check whether playback is currently paused.
        see: CanPause, IsBuffering, IsConnecting, IsLooping, IsPaused, IsPlaying, IsPreparing, IsReady, Pause
        
        Returns:
            bool: true if playback is paused, false otherwise.
        """
        ...
    def is_looping(self) -> bool:
        r"""
        x.is_looping() -> bool
        Check whether playback is looping.
        see: IsBuffering, IsConnecting, IsPaused, IsPlaying, IsPreparing, IsReady, SetLooping
        
        Returns:
            bool: true if looping, false otherwise.
        """
        ...
    def is_connecting(self) -> bool:
        r"""
        x.is_connecting() -> bool
        Check whether the player is currently connecting to a media source.
        see: IsBuffering, IsLooping, IsPaused, IsPlaying, IsPreparing, IsReady
        
        Returns:
            bool: true if connecting, false otherwise.
        """
        ...
    def is_closed(self) -> bool:
        r"""
        x.is_closed() -> bool
        Whether media is currently closed.
        
        Returns:
            bool: true if media is closed, false otherwise.
        """
        ...
    def is_buffering(self) -> bool:
        r"""
        x.is_buffering() -> bool
        Check whether playback is buffering data.
        see: IsConnecting, IsLooping, IsPaused, IsPlaying, IsPreparing, IsReady
        
        Returns:
            bool: true if looping, false otherwise.
        """
        ...
    def has_error(self) -> bool:
        r"""
        x.has_error() -> bool
        Check whether the player is in an error state.
        
        When the player is in an error state, no further operations are possible.
        The current media must be closed, and a new media source must be opened
        before the player can be used again. Errors are usually caused by faulty
        media files or interrupted network connections.
        see: IsReady
        
        Returns:
            bool:
        """
        ...
    def get_view_rotation(self) -> Rotator:
        r"""
        x.get_view_rotation() -> Rotator
        Get the current view rotation (only for 360 videos).
        see: GetHorizontalFieldOfView, GetVerticalFieldOfView, SetViewRotation
        
        Returns:
            Rotator: View rotation, or zero rotator if not available.
        """
        ...
    def get_video_track_type(self, track_index: int, format_index: int) -> str:
        r"""
        x.get_video_track_type(track_index, format_index) -> str
        Get the type of the specified video track format.
        see: GetVideoTrackAspectRatio, GetVideoTrackDimensions, GetVideoTrackFrameRate, GetVideoTrackFrameRates
        
        Args:
            track_index (int32): The index of the track, or INDEX_NONE for the selected one.
            format_index (int32): Index of the track format, or INDEX_NONE for the selected one.
        
        Returns:
            str: Video format type string.
        """
        ...
    def get_video_track_frame_rates(self, track_index: int, format_index: int) -> FloatRange:
        r"""
        x.get_video_track_frame_rates(track_index, format_index) -> FloatRange
        Get the supported range of frame rates of the specified video track.
        see: GetVideoTrackAspectRatio, GetVideoTrackDimensions, GetVideoTrackFrameRate, GetVideoTrackType
        
        Args:
            track_index (int32): The index of the track, or INDEX_NONE for the selected one.
            format_index (int32): Index of the track format, or INDEX_NONE for the selected one.
        
        Returns:
            FloatRange: Frame rate range (in frames per second).
        """
        ...
    def get_video_track_frame_rate(self, track_index: int, format_index: int) -> float:
        r"""
        x.get_video_track_frame_rate(track_index, format_index) -> float
        Get the frame rate of the specified video track.
        see: GetVideoTrackAspectRatio, GetVideoTrackDimensions, GetVideoTrackFrameRates, GetVideoTrackType, SetVideoTrackFrameRate
        
        Args:
            track_index (int32): The index of the track, or INDEX_NONE for the selected one.
            format_index (int32): Index of the track format, or INDEX_NONE for the selected one.
        
        Returns:
            float: Frame rate (in frames per second).
        """
        ...
    def get_video_track_dimensions(self, track_index: int, format_index: int) -> IntPoint:
        r"""
        x.get_video_track_dimensions(track_index, format_index) -> IntPoint
        Get the current dimensions of the specified video track.
        see: GetVideoTrackAspectRatio, GetVideoTrackFrameRate, GetVideoTrackFrameRates, GetVideoTrackType
        
        Args:
            track_index (int32): The index of the track, or INDEX_NONE for the selected one.
            format_index (int32): Index of the track format, or INDEX_NONE for the selected one.
        
        Returns:
            IntPoint: Video dimensions (in pixels).
        """
        ...
    def get_video_track_aspect_ratio(self, track_index: int, format_index: int) -> float:
        r"""
        x.get_video_track_aspect_ratio(track_index, format_index) -> float
        Get the aspect ratio of the specified video track.
        see: GetVideoTrackDimensions, GetVideoTrackFrameRate, GetVideoTrackFrameRates, GetVideoTrackType
        
        Args:
            track_index (int32): Index of the video track, or INDEX_NONE for the selected one.
            format_index (int32): Index of the track format, or INDEX_NONE for the selected one.
        
        Returns:
            float: Aspect ratio.
        """
        ...
    def get_vertical_field_of_view(self) -> float:
        r"""
        x.get_vertical_field_of_view() -> float
        Get the current vertical field of view (only for 360 videos).
        see: GetHorizontalFieldOfView, GetViewRotation, SetVerticalFieldOfView
        
        Returns:
            float: Vertical field of view (in Euler degrees), or 0.0 if not available.
        """
        ...
    def get_url(self) -> str:
        r"""
        x.get_url() -> str
        Get the URL of the currently loaded media, if any.
        see: OpenUrl
        
        Returns:
            str: Media URL, or empty string if no media was loaded.
        """
        ...
    def get_track_language(self, track_type: MediaPlayerTrack, track_index: int) -> str:
        r"""
        x.get_track_language(track_type, track_index) -> str
        Get the language tag of the specified track.
        see: GetNumTracks, GetTrackDisplayName
        
        Args:
            track_type (MediaPlayerTrack): The type of track.
            track_index (int32): The index of the track, or INDEX_NONE for the selected one.
        
        Returns:
            str: Language tag, i.e. "en-US" for English, or "und" for undefined.
        """
        ...
    def get_track_format(self, track_type: MediaPlayerTrack, track_index: int) -> int:
        r"""
        x.get_track_format(track_type, track_index) -> int32
        Get the index of the active format of the specified track type.
        see: GetNumTrackFormats, GetSelectedTrack, SetTrackFormat
        
        Args:
            track_type (MediaPlayerTrack): The type of track.
            track_index (int32): The index of the track, or INDEX_NONE for the selected one.
        
        Returns:
            int32: The index of the selected format.
        """
        ...
    def get_track_display_name(self, track_type: MediaPlayerTrack, track_index: int) -> Text:
        r"""
        x.get_track_display_name(track_type, track_index) -> Text
        Get the human readable name of the specified track.
        see: GetNumTracks, GetTrackLanguage
        
        Args:
            track_type (MediaPlayerTrack): The type of track.
            track_index (int32): The index of the track, or INDEX_NONE for the selected one.
        
        Returns:
            Text: Display name.
        """
        ...
    def get_time_stamp(self) -> MediaTimeStampInfo:
        r"""
        x.get_time_stamp() -> MediaTimeStampInfo
        Get the media's current playback timestamp.
        see: GetDuration, Seek
        
        Returns:
            MediaTimeStampInfo: Playback timestamp.
        """
        ...
    def get_time_delay(self) -> Timespan:
        r"""
        x.get_time_delay() -> Timespan
        Delay of the player's time.
        see: SetTimeDelay
        
        Returns:
            Timespan: Delay added to the player's time used to manually sync multiple sources.
        """
        ...
    def get_time(self) -> Timespan:
        r"""
        x.get_time() -> Timespan
        Get the media's current playback time.
        see: GetDuration, Seek
        
        Returns:
            Timespan: Playback time.
        """
        ...
    def get_supported_rates(self, unthinned: bool) -> Array[FloatRange]:
        r"""
        x.get_supported_rates(unthinned) -> Array[FloatRange]
        Get the supported playback rates.
        see: SetRate, SupportsRate
        
        Args:
            unthinned (bool): Whether the rates are for unthinned playback.
        
        Returns:
            Array[FloatRange]: 
        
            out_rates (Array[FloatRange]):
        """
        ...
    def get_selected_track(self, track_type: MediaPlayerTrack) -> int:
        r"""
        x.get_selected_track(track_type) -> int32
        Get the index of the currently selected track of the given type.
        see: GetNumTracks, GetTrackFormat, SelectTrack
        
        Args:
            track_type (MediaPlayerTrack): The type of track to get.
        
        Returns:
            int32: The index of the selected track, or INDEX_NONE if no track is active.
        """
        ...
    def get_rate(self) -> float:
        r"""
        x.get_rate() -> float
        Get the media's current playback rate.
        see: SetRate, SupportsRate
        
        Returns:
            float: The playback rate.
        """
        ...
    def get_playlist_index(self) -> int:
        r"""
        x.get_playlist_index() -> int32
        Get the current play list index.
        see: GetPlaylist
        
        Returns:
            int32: Play list index.
        """
        ...
    def get_playlist(self) -> MediaPlaylist:
        r"""
        x.get_playlist() -> MediaPlaylist
        Get the current play list.
        
        Media players always have a valid play list. In C++ code you can use
        the GetPlaylistRef to get a reference instead of a pointer to it.
        see: GetPlaylistIndex, GetPlaylistRef
        
        Returns:
            MediaPlaylist: The play list.
        """
        ...
    def get_player_name(self) -> Name:
        r"""
        x.get_player_name() -> Name
        Get the name of the current native media player.
        see: GetMediaName
        
        Returns:
            Name: Player name, or NAME_None if not available.
        """
        ...
    def get_playback_time_range(self, range_to_get: MediaTimeRangeBPType) -> FloatInterval:
        r"""
        x.get_playback_time_range(range_to_get) -> FloatInterval
        Blueprint accessible version of GetPlaybackTimeRange.
        This returns the range truncated into a blueprint usable float interval and should not
        be used for live streams as 32 bit floats can not store wallclock times with enough precision.
        
        Args:
            range_to_get (MediaTimeRangeBPType): 
        
        Returns:
            FloatInterval:
        """
        ...
    def get_num_tracks(self, track_type: MediaPlayerTrack) -> int:
        r"""
        x.get_num_tracks(track_type) -> int32
        Get the number of tracks of the given type.
        see: GetNumTrackFormats, GetSelectedTrack, SelectTrack
        
        Args:
            track_type (MediaPlayerTrack): The type of media tracks.
        
        Returns:
            int32: Number of tracks.
        """
        ...
    def get_num_track_formats(self, track_type: MediaPlayerTrack, track_index: int) -> int:
        r"""
        x.get_num_track_formats(track_type, track_index) -> int32
        Get the number of formats of the specified track.
        see: GetNumTracks, GetSelectedTrack, SelectTrack
        
        Args:
            track_type (MediaPlayerTrack): The type of media tracks.
            track_index (int32): The index of the track.
        
        Returns:
            int32: Number of formats.
        """
        ...
    def get_media_name(self) -> Text:
        r"""
        x.get_media_name() -> Text
        Get the human readable name of the currently loaded media source.
        see: GetPlayerName, GetUrl
        
        Returns:
            Text: Media source name, or empty text if no media is opened
        """
        ...
    def get_media_metadata_items(self) -> Map[str, MediaMetadataItemsBPT]:
        r"""
        x.get_media_metadata_items() -> Map[str, MediaMetadataItemsBPT]
        This is the blueprint accessible version of the GetMediaMetadata.
        note: Listen to EMediaEvent::MetadataChanged to catch updates to this data
        
        Returns:
            Map[str, MediaMetadataItemsBPT]: Map with arrays of FMediaMetaDataItem entries describing any metadata found in the current stream
        """
        ...
    def get_horizontal_field_of_view(self) -> float:
        r"""
        x.get_horizontal_field_of_view() -> float
        Get the current horizontal field of view (only for 360 videos).
        see: GetVerticalFieldOfView, GetViewRotation, SetHorizontalFieldOfView
        
        Returns:
            float: Horizontal field of view (in Euler degrees).
        """
        ...
    def get_duration(self) -> Timespan:
        r"""
        x.get_duration() -> Timespan
        Get the media's duration.
        see: GetTime, Seek
        
        Returns:
            Timespan: A time span representing the duration.
        """
        ...
    def get_display_time_stamp(self) -> MediaTimeStampInfo:
        r"""
        x.get_display_time_stamp() -> MediaTimeStampInfo
        Get the media's current playback timestamp as appropriate for display.
        see: GetDuration, Seek
        
        Returns:
            MediaTimeStampInfo: Playback timestamp.
        """
        ...
    def get_display_time(self) -> Timespan:
        r"""
        x.get_display_time() -> Timespan
        Get the media's current playback time as appropriate for display.
        see: GetDuration, Seek
        
        Returns:
            Timespan: Playback time.
        """
        ...
    def get_desired_player_name(self) -> Name:
        r"""
        x.get_desired_player_name() -> Name
        Get the name of the current desired native player.
        see: SetDesiredPlayerName
        
        Returns:
            Name: The name of the desired player, or NAME_None if not set.
        """
        ...
    def get_audio_track_type(self, track_index: int, format_index: int) -> str:
        r"""
        x.get_audio_track_type(track_index, format_index) -> str
        Get the type of the specified audio track format.
        see: GetAudioTrackSampleRate, GetAudioTrackSampleRate
        
        Args:
            track_index (int32): The index of the track, or INDEX_NONE for the selected one.
            format_index (int32): Index of the track format, or INDEX_NONE for the selected one.
        
        Returns:
            str: Audio format type string.
        """
        ...
    def get_audio_track_sample_rate(self, track_index: int, format_index: int) -> int:
        r"""
        x.get_audio_track_sample_rate(track_index, format_index) -> int32
        Get the sample rate of the specified audio track.
        see: GetAudioTrackChannels, GetAudioTrackType
        
        Args:
            track_index (int32): Index of the audio track, or INDEX_NONE for the selected one.
            format_index (int32): Index of the track format, or INDEX_NONE for the selected one.
        
        Returns:
            int32: Samples per second.
        """
        ...
    def get_audio_track_channels(self, track_index: int, format_index: int) -> int:
        r"""
        x.get_audio_track_channels(track_index, format_index) -> int32
        Get the number of channels in the specified audio track.
        see: GetAudioTrackSampleRate, GetAudioTrackType
        
        Args:
            track_index (int32): Index of the audio track, or INDEX_NONE for the selected one.
            format_index (int32): Index of the track format, or INDEX_NONE for the selected one.
        
        Returns:
            int32: Number of channels.
        """
        ...
    def close(self) -> None:
        r"""
        x.close() -> None
        Close the currently open media, if any.
        see: OnMediaClosed, OpenPlaylist, OpenPlaylistIndex, OpenSource, OpenUrl, Pause, Play
        """
        ...
    def can_play_url(self, url: str) -> bool:
        r"""
        x.can_play_url(url) -> bool
        Check whether the specified URL can be played by this player.
        
        If a desired player name is set for this player, it will only check
        whether that particular player type can play the specified URL.
        see: CanPlaySource, SetDesiredPlayerName
        
        Args:
            url (str): The URL to check.
        
        Returns:
            bool:
        """
        ...
    def can_play_source(self, media_source: MediaSource) -> bool:
        r"""
        x.can_play_source(media_source) -> bool
        Check whether the specified media source can be played by this player.
        
        If a desired player name is set for this player, it will only check
        whether that particular player type can play the specified source.
        see: CanPlayUrl, SetDesiredPlayerName
        
        Args:
            media_source (MediaSource): The media source to check.
        
        Returns:
            bool: true if the media source can be opened, false otherwise.
        """
        ...
    def can_pause(self) -> bool:
        r"""
        x.can_pause() -> bool
        Check whether media playback can be paused right now.
        
        Playback can be paused if the media supports pausing and if it is currently playing.
        see: CanPlay, Pause
        
        Returns:
            bool: true if pausing playback can be paused, false otherwise.
        """
        ...

class MediaPlaylist(Object):
    r"""
    Implements a media play list.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaPlaylist.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``items`` (Array[MediaSource]):  [Read-Write] List of media sources to play.
    """
    def replace(self, index: int, replacement: MediaSource) -> bool:
        r"""
        x.replace(index, replacement) -> bool
        Replace the media source at the specified position.
        see: Add, Insert, RemoveAll, RemoveAt
        
        Args:
            index (int32): The index of the media source to replace.
            replacement (MediaSource): The replacement media source.
        
        Returns:
            bool: true if the media source was replaced, false otherwise.
        """
        ...
    def remove_at(self, index: int) -> bool:
        r"""
        x.remove_at(index) -> bool
        Remove the media source at the specified position.
        see: Add, Insert, RemoveAll, Replace
        
        Args:
            index (int32): The index of the media source to remove.
        
        Returns:
            bool: true if the media source was removed, false otherwise.
        """
        ...
    def remove(self, media_source: MediaSource) -> bool:
        r"""
        x.remove(media_source) -> bool
        Remove all occurrences of the given media source in the play list.
        see: Add, Insert, Remove, Replace
        
        Args:
            media_source (MediaSource): The media source to remove.
        
        Returns:
            bool: true if the media source was removed, false otherwise.
        """
        ...
    def num(self) -> int:
        r"""
        x.num() -> int32
        Get the number of media sources in the play list.
        
        Returns:
            int32: Number of media sources.
        """
        ...
    def insert(self, media_source: MediaSource, index: int) -> None:
        r"""
        x.insert(media_source, index) -> None
        Insert a media source into the play list at the given position.
        see: Add, Remove, RemoveAll, Replace
        
        Args:
            media_source (MediaSource): The media source to insert.
            index (int32): The index to insert into.
        """
        ...
    def get_random(self) -> Tuple[MediaSource, int]:
        r"""
        x.get_random() -> (MediaSource, out_index=int32)
        Get a random media source in the play list.
        see: Get, GetNext, GetPrevious
        
        Returns:
            int32: The random media source, or nullptr if the list is empty.
        
            out_index (int32): Will contain the index of the returned media source.
        """
        ...
    def get_previous(self) -> Tuple[MediaSource, int]:
        r"""
        x.get_previous() -> (MediaSource, out_index=int32)
        Get the previous media source in the play list.
        see: , GetNext, GetRandom
        
        Returns:
            int32: The media source before the current one, or nullptr if the list is empty.
        
            out_index (int32): Index of the current media source (will contain the new index).
        """
        ...
    def get_next(self) -> Tuple[MediaSource, int]:
        r"""
        x.get_next() -> (MediaSource, out_index=int32)
        Get the next media source in the play list.
        see: , GetPrevious, GetRandom
        
        Returns:
            int32: The media source after the current one, or nullptr if the list is empty.
        
            out_index (int32): Index of the current media source (will contain the new index).
        """
        ...
    def get(self, index: int) -> MediaSource:
        r"""
        x.get(index) -> MediaSource
        Get the media source at the specified index.
        see: GetNext, GetRandom
        
        Args:
            index (int32): The index of the media source to get.
        
        Returns:
            MediaSource: The media source, or nullptr if the index doesn't exist.
        """
        ...
    def add_url(self, url: str) -> bool:
        r"""
        x.add_url(url) -> bool
        Add a media URL to the play list.
        see: Add, AddFile, Insert, RemoveAll, Remove, Replace
        
        Args:
            url (str): The URL to add.
        
        Returns:
            bool: true if the URL was added, false otherwise.
        """
        ...
    def add_file(self, file_path: str) -> bool:
        r"""
        x.add_file(file_path) -> bool
        Add a media file path to the play list.
        see: Add, AddUrl, Insert, RemoveAll, Remove, Replace
        
        Args:
            file_path (str): The file path to add.
        
        Returns:
            bool: true if the file was added, false otherwise.
        """
        ...
    def add(self, media_source: MediaSource) -> bool:
        r"""
        x.add(media_source) -> bool
        Add a media source to the play list.
        see: AddFile, AddUrl, Insert, RemoveAll, Remove, Replace
        
        Args:
            media_source (MediaSource): The media source to append.
        
        Returns:
            bool: true if the media source was added, false otherwise.
        """
        ...

class MediaSoundComponent(SynthComponent):
    r"""
    Implements a sound component for playing a media player's audio output.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaSoundComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``allow_spatialization`` (bool):  [Read-Write] Is this audio component allowed to be spatialized?
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``channels`` (MediaSoundChannels):  [Read-Write] Media sound channel type.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] What sound concurrency to use for sounds generated by this audio component
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``dynamic_rate_adjustment`` (bool):  [Read-Write] Dynamically adjust the sample rate if audio and media clock desynchronize.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``media_player`` (MediaPlayer):  [Read-Write] The media player asset associated with this component.
      
      This property is meant for design-time convenience. To change the
      associated media player at run-time, use the SetMediaPlayer method.
      see: SetMediaPlayer
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulation_routing`` (SoundModulationDefaultRoutingSettings):  [Read-Write]
    - ``on_audio_envelope_value`` (OnSynthEnvelopeValue):  [Read-Write]
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``override_attenuation`` (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``rate_adjustment_factor`` (float):  [Read-Write] Factor for calculating the sample rate adjustment.
      
      If dynamic rate adjustment is enabled, this number is multiplied with the drift
      between the audio and media clock (in 100ns ticks) to determine the adjustment.
      that is to be multiplied into the current playrate.
    - ``rate_adjustment_range`` (FloatRange):  [Read-Write] The allowed range of dynamic rate adjustment.
      
      If dynamic rate adjustment is enabled, and the necessary adjustment
      falls outside of this range, audio samples will be dropped.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sound_class`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] Submix this sound belongs to
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] An array of submix sends. Audio from this sound will send a portion of its audio to these effects.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    def set_spectral_analysis_settings(self, frequencies_to_analyze: Array[float], fft_size: MediaSoundComponentFFTSize = MediaSoundComponentFFTSize.MEDIUM_512) -> None:
        r"""
        x.set_spectral_analysis_settings(frequencies_to_analyze, fft_size=MediaSoundComponentFFTSize.MEDIUM_512) -> None
        Sets the settings to use for spectral analysis.
        
        Args:
            frequencies_to_analyze (Array[float]): 
            fft_size (MediaSoundComponentFFTSize):
        """
        ...
    def set_media_player(self, new_media_player: MediaPlayer) -> None:
        r"""
        x.set_media_player(new_media_player) -> None
        Set the media player that provides the audio samples.
        see: GetMediaPlayer
        
        Args:
            new_media_player (MediaPlayer): The player to set.
        """
        ...
    def set_envelope_followingsettings(self, attack_time_msec: int, release_time_msec: int) -> None:
        r"""
        x.set_envelope_followingsettings(attack_time_msec, release_time_msec) -> None
        Sets the envelope attack and release times (in ms).
        
        Args:
            attack_time_msec (int32): 
            release_time_msec (int32):
        """
        ...
    def set_enable_spectral_analysis(self, spectral_analysis_enabled: bool) -> None:
        r"""
        x.set_enable_spectral_analysis(spectral_analysis_enabled) -> None
        Turns on spectral analysis of the audio generated in the media sound component.
        
        Args:
            spectral_analysis_enabled (bool):
        """
        ...
    def set_enable_envelope_following(self, envelope_following: bool) -> None:
        r"""
        x.set_enable_envelope_following(envelope_following) -> None
        Turns on amplitude envelope following the audio in the media sound component.
        
        Args:
            envelope_following (bool):
        """
        ...
    def get_spectral_data(self) -> Array[MediaSoundComponentSpectralData]:
        r"""
        x.get_spectral_data() -> Array[MediaSoundComponentSpectralData]
        Retrieves the spectral data if spectral analysis is enabled.
        
        Returns:
            Array[MediaSoundComponentSpectralData]:
        """
        ...
    def get_normalized_spectral_data(self) -> Array[MediaSoundComponentSpectralData]:
        r"""
        x.get_normalized_spectral_data() -> Array[MediaSoundComponentSpectralData]
        Retrieves and normalizes the spectral data if spectral analysis is enabled.
        
        Returns:
            Array[MediaSoundComponentSpectralData]:
        """
        ...
    def get_media_player(self) -> MediaPlayer:
        r"""
        x.get_media_player() -> MediaPlayer
        Get the media player that provides the audio samples.
        see: SetMediaPlayer
        
        Returns:
            MediaPlayer: The component's media player, or nullptr if not set.
        """
        ...
    def get_envelope_value(self) -> float:
        r"""
        x.get_envelope_value() -> float
        Retrieves the current amplitude envelope.
        
        Returns:
            float:
        """
        ...
    def get_attenuation_settings_to_apply(self) -> Optional[SoundAttenuationSettings]:
        r"""
        x.get_attenuation_settings_to_apply() -> SoundAttenuationSettings or None
        Get the attenuation settings based on the current component settings.
        
        Returns:
            SoundAttenuationSettings or None: true if attenuation settings were returned, false if attenuation is disabled.
        
            out_attenuation_settings (SoundAttenuationSettings): Will contain the attenuation settings, if available.
        """
        ...

class PlatformMediaSource(MediaSource):
    r"""
    A media source that selects other media sources based on target platform.
    
    Use this asset to override media sources on a per-platform basis.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: PlatformMediaSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``platform_media_sources`` (Map[str, MediaSource]):  [Read-Write] Media sources per platform.
    """
    ...

class StreamMediaSource(BaseMediaSource):
    r"""
    Stream Media Source
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: StreamMediaSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``platform_player_names`` (Map[str, Name]):  [Read-Write] Override native media player plug-ins per platform (Empty = find one automatically).
    - ``stream_url`` (str):  [Read-Write] The URL to the media stream to be played.
    """
    @property
    def stream_url(self) -> str:
        r"""
        (str):  [Read-Write] The URL to the media stream to be played.
        """
        ...
    @stream_url.setter
    def stream_url(self, value: str) -> None:
        ...

class TimeSynchronizableMediaSource(BaseMediaSource):
    r"""
    Base class for media sources that can be synchronized with the engine's timecode.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: TimeSynchronizableMediaSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_delay`` (int32):  [Read-Write] When using Time Synchronization, how many frame back should it read.
    - ``platform_player_names`` (Map[str, Name]):  [Read-Write] Override native media player plug-ins per platform (Empty = find one automatically).
    - ``time_delay`` (double):  [Read-Write] When not using Time Synchronization, how far back it time should it read.
    - ``use_time_synchronization`` (bool):  [Read-Write] Synchronize the media with the engine's timecode.
      The media player has be able to read timecode.
      The media player will try to play the corresponding frame, base on the frame's timecode value.
    """
    @property
    def use_time_synchronization(self) -> bool:
        r"""
        (bool):  [Read-Write] Synchronize the media with the engine's timecode.
        The media player has be able to read timecode.
        The media player will try to play the corresponding frame, base on the frame's timecode value.
        """
        ...
    @use_time_synchronization.setter
    def use_time_synchronization(self, value: bool) -> None:
        ...

class MediaLibrary(BlueprintFunctionLibrary):
    r"""
    Blueprint library for Media related functions.
    
    **C++ Source:**
    
    - **Module**: MediaAssets
    - **File**: MediaBlueprintFunctionLibrary.h
    
    """
    @classmethod
    def enumerate_webcam_capture_devices(cls, filter: int = -1) -> Array[MediaCaptureDevice]:
        r"""
        X.enumerate_webcam_capture_devices(filter=-1) -> Array[MediaCaptureDevice]
        Enumerate available audio capture devices.
        
        To filter for a specific subset of devices, use the MakeBitmask node
        with EMediaWebcamCaptureDeviceFilter as the Bitmask Enum.
        
        Args:
            filter (int32): The types of capture devices to return (-1 = all).
        
        Returns:
            Array[MediaCaptureDevice]: 
        
            out_devices (Array[MediaCaptureDevice]): Will contain the available capture devices.
        """
        ...
    @classmethod
    def enumerate_video_capture_devices(cls, filter: int = -1) -> Array[MediaCaptureDevice]:
        r"""
        X.enumerate_video_capture_devices(filter=-1) -> Array[MediaCaptureDevice]
        Enumerate available audio capture devices.
        
        To filter for a specific subset of devices, use the MakeBitmask node
        with EMediaVideoCaptureDeviceFilter as the Bitmask Enum.
        
        Args:
            filter (int32): The types of capture devices to return (-1 = all).
        
        Returns:
            Array[MediaCaptureDevice]: 
        
            out_devices (Array[MediaCaptureDevice]): Will contain the available capture devices.
        """
        ...
    @classmethod
    def enumerate_audio_capture_devices(cls, filter: int = -1) -> Array[MediaCaptureDevice]:
        r"""
        X.enumerate_audio_capture_devices(filter=-1) -> Array[MediaCaptureDevice]
        Enumerate available audio capture devices.
        
        To filter for a specific subset of devices, use the MakeBitmask node
        with EMediaAudioCaptureDeviceFilter as the Bitmask Enum.
        
        Args:
            filter (int32): The types of capture devices to return (-1 = all).
        
        Returns:
            Array[MediaCaptureDevice]: 
        
            out_devices (Array[MediaCaptureDevice]): Will contain the available capture devices.
        """
        ...

class DefaultLevelSequenceInstanceData(Object):
    r"""
    Default instance data class that level sequences understand. Implements IMovieSceneTransformOrigin.
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: DefaultLevelSequenceInstanceData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``transform_origin`` (Transform):  [Read-Write] Specifies a transform that offsets all absolute transform sections in this sequence. Scale is ignored. Not applied to Relative or Additive sections.
    - ``transform_origin_actor`` (Actor):  [Read-Write] When set, this actor's world position will be used as the transform origin for all absolute transform sections
    """
    @property
    def transform_origin_actor(self) -> Actor:
        r"""
        (Actor):  [Read-Write] When set, this actor's world position will be used as the transform origin for all absolute transform sections
        """
        ...
    @transform_origin_actor.setter
    def transform_origin_actor(self, value: Actor) -> None:
        ...
    @property
    def transform_origin(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Specifies a transform that offsets all absolute transform sections in this sequence. Scale is ignored. Not applied to Relative or Additive sections.
        """
        ...
    @transform_origin.setter
    def transform_origin(self, value: Transform) -> None:
        ...
    def bp_get_transform_origin(self) -> Transform:
        r"""
        x.bp_get_transform_origin() -> Transform
        Get the transform from which all absolute component transform sections should be relative. Scale is ignored.
        
        Returns:
            Transform:
        """
        ...

class AssetUserData(Object):
    r"""
    Object that can be subclassed to store custom data on Unreal asset objects.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AssetUserData.h
    
    """
    ...

class AnimSequenceLevelSequenceLink(AssetUserData):
    r"""
    Link To Level Sequence That may be driving the anim sequence
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: AnimSequenceLevelSequenceLink.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``path_to_level_sequence`` (SoftObjectPath):  [Read-Write]
    - ``skel_track_guid`` (Guid):  [Read-Write]
    """
    @property
    def skel_track_guid(self) -> Guid:
        r"""
        (Guid):  [Read-Write]
        """
        ...
    @skel_track_guid.setter
    def skel_track_guid(self, value: Guid) -> None:
        ...
    @property
    def path_to_level_sequence(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Write]
        """
        ...
    @path_to_level_sequence.setter
    def path_to_level_sequence(self, value: SoftObjectPath) -> None:
        ...

class LevelSequence(MovieSceneSequence):
    r"""
    Movie scene animation for Actors.
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequence.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    """
    def remove_meta_data_by_class(self, class_: Class) -> None:
        r"""
        x.remove_meta_data_by_class(class_) -> None
        Remove meta-data of a particular type for this level sequence instance, if it exists
        
        Args:
            class_ (type(Class)): The class type that you wish to remove the metadata for
        """
        ...
    def find_or_add_meta_data_by_class(self, class_: Class) -> Object:
        r"""
        x.find_or_add_meta_data_by_class(class_) -> Object
        Find meta-data of a particular type for this level sequence instance, adding it if it doesn't already exist.
        
        Args:
            class_ (type(Class)): Class that you wish to find or create the metadata object for.
        
        Returns:
            Object: An instance of this class as metadata on this Level Sequence.
        """
        ...
    def find_meta_data_by_class(self, class_: Class) -> Object:
        r"""
        x.find_meta_data_by_class(class_) -> Object
        Find meta-data of a particular type for this level sequence instance.
        
        Args:
            class_ (type(Class)): Class that you wish to find the metadata object for.
        
        Returns:
            Object: An instance of this class if it already exists as metadata on this Level Sequence, otherwise null.
        """
        ...
    def copy_meta_data(self, meta_data: Object) -> Object:
        r"""
        x.copy_meta_data(meta_data) -> Object
        Copy the specified meta data into this level sequence, overwriting any existing meta-data of the same type
        Meta-data may implement the ILevelSequenceMetaData interface in order to hook into default ULevelSequence functionality.
        
        Args:
            meta_data (Object): Existing Metadata Object that you wish to copy into this Level Sequence.
        
        Returns:
            Object: The newly copied instance of the Metadata that now exists on this sequence.
        """
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class LevelSequenceBurnInInitSettings(Object):
    r"""
    Level Sequence Burn in Init Settings
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequenceActor.h
    
    """
    ...

class LevelSequenceBurnInOptions(Object):
    r"""
    Level Sequence Burn in Options
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequenceActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``burn_in_class`` (SoftClassPath):  [Read-Write]
    - ``settings`` (LevelSequenceBurnInInitSettings):  [Read-Write]
    - ``use_burn_in`` (bool):  [Read-Write]
    """
    @property
    def use_burn_in(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @use_burn_in.setter
    def use_burn_in(self, value: bool) -> None:
        ...
    @property
    def burn_in_class(self) -> SoftClassPath:
        r"""
        (SoftClassPath):  [Read-Write]
        """
        ...
    @burn_in_class.setter
    def burn_in_class(self, value: SoftClassPath) -> None:
        ...
    @property
    def settings(self) -> LevelSequenceBurnInInitSettings:
        r"""
        (LevelSequenceBurnInInitSettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: LevelSequenceBurnInInitSettings) -> None:
        ...
    def set_burn_in(self, burn_in_class: SoftClassPath) -> None:
        r"""
        x.set_burn_in(burn_in_class) -> None
        Loads the specified class path and initializes an instance, then stores it in Settings.
        
        Args:
            burn_in_class (SoftClassPath):
        """
        ...

class LevelSequenceActor(Actor):
    r"""
    Actor responsible for controlling a specific level sequence in the world.
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequenceActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``binding_overrides`` (MovieSceneBindingOverrides):  [Read-Write] Mapping of actors to override the sequence bindings with
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``burn_in_options`` (LevelSequenceBurnInOptions):  [Read-Write]
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``camera_settings`` (LevelSequenceCameraSettings):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_instance_data`` (Object):  [Read-Write] Instance data that can be used to dynamically control sequence evaluation at runtime
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``level_sequence_asset`` (LevelSequence):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_instance_data`` (bool):  [Read-Write] Enable specification of dynamic instance data to be supplied to the sequence during playback
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``playback_settings`` (MovieSceneSequencePlaybackSettings):  [Read-Write]
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_playback`` (bool):  [Read-Write] If true, playback of this level sequence on the server will be synchronized across other clients
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``sequence_player`` (LevelSequencePlayer):  [Read-Write]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def playback_settings(self) -> MovieSceneSequencePlaybackSettings:
        r"""
        (MovieSceneSequencePlaybackSettings):  [Read-Only]
        """
        ...
    @property
    def sequence_player(self) -> LevelSequencePlayer:
        r"""
        (LevelSequencePlayer):  [Read-Only]
        """
        ...
    @property
    def level_sequence_asset(self) -> LevelSequence:
        r"""
        (LevelSequence):  [Read-Only]
        """
        ...
    @property
    def camera_settings(self) -> LevelSequenceCameraSettings:
        r"""
        (LevelSequenceCameraSettings):  [Read-Write]
        """
        ...
    @camera_settings.setter
    def camera_settings(self, value: LevelSequenceCameraSettings) -> None:
        ...
    @property
    def burn_in_options(self) -> LevelSequenceBurnInOptions:
        r"""
        (LevelSequenceBurnInOptions):  [Read-Only]
        """
        ...
    @property
    def binding_overrides(self) -> MovieSceneBindingOverrides:
        r"""
        (MovieSceneBindingOverrides):  [Read-Only] Mapping of actors to override the sequence bindings with
        """
        ...
    @property
    def override_instance_data(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable specification of dynamic instance data to be supplied to the sequence during playback
        """
        ...
    @override_instance_data.setter
    def override_instance_data(self, value: bool) -> None:
        ...
    @property
    def replicate_playback(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, playback of this level sequence on the server will be synchronized across other clients
        """
        ...
    @replicate_playback.setter
    def replicate_playback(self, value: bool) -> None:
        ...
    @property
    def default_instance_data(self) -> Object:
        r"""
        (Object):  [Read-Write] Instance data that can be used to dynamically control sequence evaluation at runtime
        """
        ...
    @default_instance_data.setter
    def default_instance_data(self, value: Object) -> None:
        ...
    def show_burnin(self) -> None:
        r"""
        x.show_burnin() -> None
        Show burnin
        """
        ...
    def set_sequence(self, sequence: LevelSequence) -> None:
        r"""
        x.set_sequence(sequence) -> None
        Set the level sequence being played by this actor.
        see: GetSequence
        
        Args:
            sequence (LevelSequence): The sequence object to set.
        """
        ...
    def set_binding_by_tag(self, binding_tag: Name, actors: Array[Actor], allow_bindings_from_asset: bool = False) -> None:
        r"""
        x.set_binding_by_tag(binding_tag, actors, allow_bindings_from_asset=False) -> None
        Assigns an set of actors to all the bindings tagged with the specified name in this sequence. Object Bindings can be tagged within the sequence UI by RMB -> Tags... on the object binding in the tree.
        
        Args:
            binding_tag (Name): The unique tag name to lookup bindings with
            actors (Array[Actor]): The actors to assign to all the tagged bindings
            allow_bindings_from_asset (bool): If false the new bindings being supplied here will replace the bindings set in the level sequence asset, meaning the original object animated by Sequencer will no longer be animated. Bindings set to spawnables will not spawn if false. If true, new bindings will be in addition to ones set set in Sequencer UI. This function will not modify the original asset.
        """
        ...
    def set_binding(self, binding: MovieSceneObjectBindingID, actors: Array[Actor], allow_bindings_from_asset: bool = False) -> None:
        r"""
        x.set_binding(binding, actors, allow_bindings_from_asset=False) -> None
        Overrides the specified binding with the specified actors, optionally still allowing the bindings defined in the Level Sequence asset
        
        Args:
            binding (MovieSceneObjectBindingID): Binding to modify
            actors (Array[Actor]): Actors to bind
            allow_bindings_from_asset (bool): If false the new bindings being supplied here will replace the bindings set in the level sequence asset, meaning the original object animated by Sequencer will no longer be animated. Bindings set to spawnables will not spawn if false. If true, new bindings will be in addition to ones set set in Sequencer UI. This function will not modify the original asset.
        """
        ...
    def reset_bindings(self) -> None:
        r"""
        x.reset_bindings() -> None
        Resets all overridden bindings back to the defaults defined by the Level Sequence asset
        """
        ...
    def reset_binding(self, binding: MovieSceneObjectBindingID) -> None:
        r"""
        x.reset_binding(binding) -> None
        Resets the specified binding back to the defaults defined by the Level Sequence asset
        
        Args:
            binding (MovieSceneObjectBindingID):
        """
        ...
    def remove_binding_by_tag(self, tag: Name, actor: Actor) -> None:
        r"""
        x.remove_binding_by_tag(tag, actor) -> None
        Removes the specified actor from the specified binding's actor array
        
        Args:
            tag (Name): 
            actor (Actor):
        """
        ...
    def remove_binding(self, binding: MovieSceneObjectBindingID, actor: Actor) -> None:
        r"""
        x.remove_binding(binding, actor) -> None
        Removes the specified actor from the specified binding's actor array
        
        Args:
            binding (MovieSceneObjectBindingID): 
            actor (Actor):
        """
        ...
    def hide_burnin(self) -> None:
        r"""
        x.hide_burnin() -> None
        Hide burnin
        """
        ...
    def get_sequence(self) -> LevelSequence:
        r"""
        x.get_sequence() -> LevelSequence
        Get the level sequence being played by this actor.
        see: SetSequence
        
        Returns:
            LevelSequence: Level sequence, or nullptr if not assigned or if it cannot be loaded.
        """
        ...
    def find_named_bindings(self, tag: Name) -> Array[MovieSceneObjectBindingID]:
        r"""
        x.find_named_bindings(tag) -> Array[MovieSceneObjectBindingID]
        Retrieve all the bindings that have been tagged with the specified name
        
        Args:
            tag (Name): The unique tag name to lookup bindings with. Object Bindings can be tagged within the sequence UI by RMB -> Tags... on the object binding in the tree.
        
        Returns:
            Array[MovieSceneObjectBindingID]: An array containing all the bindings that are tagged with this name, potentially empty.
        """
        ...
    def find_named_binding(self, tag: Name) -> MovieSceneObjectBindingID:
        r"""
        x.find_named_binding(tag) -> MovieSceneObjectBindingID
        Retrieve the first object binding that has been tagged with the specified name
        
        Args:
            tag (Name): 
        
        Returns:
            MovieSceneObjectBindingID:
        """
        ...
    def add_binding_by_tag(self, binding_tag: Name, actor: Actor, allow_bindings_from_asset: bool = False) -> None:
        r"""
        x.add_binding_by_tag(binding_tag, actor, allow_bindings_from_asset=False) -> None
        Binds an actor to all the bindings tagged with the specified name in this sequence. Does not remove any exising bindings that have been set up through this API. Object Bindings can be tagged within the sequence UI by RMB -> Tags... on the object binding in the tree.
        
        Args:
            binding_tag (Name): The unique tag name to lookup bindings with
            actor (Actor): The actor to assign to all the tagged bindings
            allow_bindings_from_asset (bool): If false the new bindings being supplied here will replace the bindings set in the level sequence asset, meaning the original object animated by Sequencer will no longer be animated. Bindings set to spawnables will not spawn if false. If true, new bindings will be in addition to ones set set in Sequencer UI. This function will not modify the original asset.
        """
        ...
    def add_binding(self, binding: MovieSceneObjectBindingID, actor: Actor, allow_bindings_from_asset: bool = False) -> None:
        r"""
        x.add_binding(binding, actor, allow_bindings_from_asset=False) -> None
        Adds the specified actor to the overridden bindings for the specified binding ID, optionally still allowing the bindings defined in the Level Sequence asset
        
        Args:
            binding (MovieSceneObjectBindingID): Binding to modify
            actor (Actor): Actor to bind
            allow_bindings_from_asset (bool): If false the new bindings being supplied here will replace the bindings set in the level sequence asset, meaning the original object animated by Sequencer will no longer be animated. Bindings set to spawnables will not spawn if false. If true, new bindings will be in addition to ones set set in Sequencer UI. This function will not modify the original asset.
        """
        ...

class ReplicatedLevelSequenceActor(LevelSequenceActor):
    r"""
    A level sequence actor that is set to always be relevant for networking purposes
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequenceActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``binding_overrides`` (MovieSceneBindingOverrides):  [Read-Write] Mapping of actors to override the sequence bindings with
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``burn_in_options`` (LevelSequenceBurnInOptions):  [Read-Write]
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``camera_settings`` (LevelSequenceCameraSettings):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_instance_data`` (Object):  [Read-Write] Instance data that can be used to dynamically control sequence evaluation at runtime
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``level_sequence_asset`` (LevelSequence):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_instance_data`` (bool):  [Read-Write] Enable specification of dynamic instance data to be supplied to the sequence during playback
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``playback_settings`` (MovieSceneSequencePlaybackSettings):  [Read-Write]
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_playback`` (bool):  [Read-Write] If true, playback of this level sequence on the server will be synchronized across other clients
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``sequence_player`` (LevelSequencePlayer):  [Read-Write]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class LevelSequenceAnimSequenceLink(AssetUserData):
    r"""
    Link To Set of Anim Sequences that we may be linked to.
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequenceAnimSequenceLink.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_sequence_links`` (Array[LevelSequenceAnimSequenceLinkItem]):  [Read-Write]
    """
    @property
    def anim_sequence_links(self) -> Array[LevelSequenceAnimSequenceLinkItem]:
        r"""
        (Array[LevelSequenceAnimSequenceLinkItem]):  [Read-Write]
        """
        ...
    @anim_sequence_links.setter
    def anim_sequence_links(self, value: Array[LevelSequenceAnimSequenceLinkItem]) -> None:
        ...

class LevelSequenceBurnIn(UserWidget):
    r"""
    Base class for level sequence burn ins
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequenceBurnIn.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``color_and_opacity`` (LinearColor):  [Read-Write] The color and opacity of this widget.  Tints all child widgets.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``desired_focus_widget`` (WidgetChild):  [Read-Write]
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``foreground_color`` (SlateColor):  [Read-Write] The foreground color of the widget, this is inherited by sub widgets.  Any color property
      that is marked as inherit will use this color.
    - ``frame_information`` (LevelSequencePlayerSnapshot):  [Read-Write] Snapshot of frame information.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Setting this flag to true, allows this widget to accept focus when clicked, or when navigated to.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``level_sequence_actor`` (LevelSequenceActor):  [Read-Write] The actor to get our burn in frames from
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_visibility_changed`` (OnVisibilityChangedEvent):  [Read-Write] Called when the visibility has changed
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``padding`` (Margin):  [Read-Write] The padding area around the content.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``preview_background`` (Texture2D):  [Read-Write] A preview background that you can use when designing the UI to get a sense of scale on the screen.  Use
      a texture with a screenshot of your game in it, for example if you were designing a HUD.
    - ``priority`` (int32):  [Read-Write]
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``stop_action`` (bool):  [Read-Write]
    - ``tick_frequency`` (WidgetTickFrequency):  [Read-Write] This widget is allowed to tick. If this is unchecked tick will never be called, animations will not play correctly, and latent actions will not execute.
      Uncheck this for performance reasons only
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def frame_information(self) -> LevelSequencePlayerSnapshot:
        r"""
        (LevelSequencePlayerSnapshot):  [Read-Only] Snapshot of frame information.
        """
        ...
    @property
    def level_sequence_actor(self) -> LevelSequenceActor:
        r"""
        (LevelSequenceActor):  [Read-Only] The actor to get our burn in frames from
        """
        ...
    def set_settings(self, settings: Object) -> None:
        r"""
        x.set_settings(settings) -> None
        Called when this burn in is receiving its settings
        
        Args:
            settings (Object):
        """
        ...
    def get_settings_class(self) -> Class:
        r"""
        x.get_settings_class() -> type(Class)
        Get the settings class to use for this burn in
        
        Returns:
            type(Class):
        """
        ...

class LevelSequenceDirector(Object):
    r"""
    Level Sequence Director
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequenceDirector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``player`` (LevelSequencePlayer):  [Read-Write] Pointer to the player that's playing back this director's sequence. Only valid in game or in PIE/Simulate.
    """
    @property
    def player(self) -> LevelSequencePlayer:
        r"""
        (LevelSequencePlayer):  [Read-Only] Pointer to the player that's playing back this director's sequence. Only valid in game or in PIE/Simulate.
        """
        ...
    def on_created(self) -> None:
        r"""
        x.on_created() -> None
        Called when this director is created
        """
        ...
    def get_sequence(self) -> MovieSceneSequence:
        r"""
        x.get_sequence() -> MovieSceneSequence
        * Get the current sequence that this director is playing back within
        
        Returns:
            MovieSceneSequence:
        """
        ...
    def get_root_sequence_time(self) -> QualifiedTime:
        r"""
        x.get_root_sequence_time() -> QualifiedTime
        Get the current time for the outermost (root) sequence
        
        Returns:
            QualifiedTime: The current playback position of the outermost (root) sequence
        """
        ...
    def get_master_sequence_time(self) -> QualifiedTime:
        r"""
        x.get_master_sequence_time() -> QualifiedTime
        Get Master Sequence Time
        deprecated: Use GetRootSequenceTime
        
        Returns:
            QualifiedTime:
        """
        ...
    def get_current_time(self) -> QualifiedTime:
        r"""
        x.get_current_time() -> QualifiedTime
        Get the current time for this director's sub-sequence (or the root sequence, if this is a root sequence director)
        
        Returns:
            QualifiedTime: The current playback position of this director's sequence
        """
        ...
    def get_bound_objects(self, object_binding: MovieSceneObjectBindingID) -> Array[Object]:
        r"""
        x.get_bound_objects(object_binding) -> Array[Object]
        Resolve the bindings inside this sub-sequence that relate to the specified ID
        note:: ObjectBinding should be constructed from the same sequence as this Sequence Director's owning Sequence (see the GetSequenceBinding node)
        
        Args:
            object_binding (MovieSceneObjectBindingID): The ID for the object binding inside this sub-sequence or one of its children to resolve
        
        Returns:
            Array[Object]:
        """
        ...
    def get_bound_object(self, object_binding: MovieSceneObjectBindingID) -> Object:
        r"""
        x.get_bound_object(object_binding) -> Object
        Resolve the first valid binding inside this sub-sequence that relates to the specified ID
        note:: ObjectBinding should be constructed from the same sequence as this Sequence Director's owning Sequence (see the GetSequenceBinding node)
        
        Args:
            object_binding (MovieSceneObjectBindingID): The ID for the object binding inside this sub-sequence or one of its children to resolve
        
        Returns:
            Object:
        """
        ...
    def get_bound_actors(self, object_binding: MovieSceneObjectBindingID) -> Array[Actor]:
        r"""
        x.get_bound_actors(object_binding) -> Array[Actor]
        Resolve the actor bindings inside this sub-sequence that relate to the specified ID
        note:: ObjectBinding should be constructed from the same sequence as this Sequence Director's owning Sequence (see the GetSequenceBinding node)
        
        Args:
            object_binding (MovieSceneObjectBindingID): The ID for the object binding inside this sub-sequence or one of its children to resolve
        
        Returns:
            Array[Actor]:
        """
        ...
    def get_bound_actor(self, object_binding: MovieSceneObjectBindingID) -> Actor:
        r"""
        x.get_bound_actor(object_binding) -> Actor
        Resolve the first valid Actor binding inside this sub-sequence that relates to the specified ID
        note:: ObjectBinding should be constructed from the same sequence as this Sequence Director's owning Sequence (see the GetSequenceBinding node)
        
        Args:
            object_binding (MovieSceneObjectBindingID): The ID for the object binding inside this sub-sequence or one of its children to resolve
        
        Returns:
            Actor:
        """
        ...

class LevelSequencePlayer(MovieSceneSequencePlayer):
    r"""
    ULevelSequencePlayer is used to actually "play" an level sequence asset at runtime.
    
    This class keeps track of playback state and provides functions for manipulating
    an level sequence while its playing.
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: LevelSequencePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_camera_cut`` (OnLevelSequencePlayerCameraCutEvent):  [Read-Write] Event triggered when there is a camera cut
    - ``on_finished`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player finishes naturally (without explicitly calling stop)
    - ``on_pause`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is paused
    - ``on_play`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is played
    - ``on_play_reverse`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is played in reverse
    - ``on_stop`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is stopped
    """
    @property
    def on_camera_cut(self) -> OnLevelSequencePlayerCameraCutEvent:
        r"""
        (OnLevelSequencePlayerCameraCutEvent):  [Read-Write] Event triggered when there is a camera cut
        """
        ...
    @on_camera_cut.setter
    def on_camera_cut(self, value: OnLevelSequencePlayerCameraCutEvent) -> None:
        ...
    def get_active_camera_component(self) -> CameraComponent:
        r"""
        x.get_active_camera_component() -> CameraComponent
        Get the active camera cut camera
        
        Returns:
            CameraComponent:
        """
        ...
    @classmethod
    def create_level_sequence_player(cls, world_context_object: Object, level_sequence: LevelSequence, settings: MovieSceneSequencePlaybackSettings) -> Tuple[LevelSequencePlayer, LevelSequenceActor]:
        r"""
        X.create_level_sequence_player(world_context_object, level_sequence, settings) -> (LevelSequencePlayer, out_actor=LevelSequenceActor)
        Create a new level sequence player.
        
        Args:
            world_context_object (Object): Context object from which to retrieve a UWorld.
            level_sequence (LevelSequence): The level sequence to play.
            settings (MovieSceneSequencePlaybackSettings): The desired playback settings
        
        Returns:
            LevelSequenceActor: 
        
            out_actor (LevelSequenceActor): The level sequence actor created to play this sequence.
        """
        ...

class LevelSequenceMediaController(Actor):
    r"""
    Replicated actor class that is responsible for instigating various cinematic assets (Media, Audio, Level Sequences) in a synchronized fasion
    
    **C++ Source:**
    
    - **Module**: LevelSequence
    - **File**: SequenceMediaController.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``media_component`` (MediaComponent):  [Read-Only] Media component that contains the media player to synchronize with
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``sequence`` (LevelSequenceActor):  [Read-Write] Pointer to the sequence actor to use for playback
    - ``server_start_time_seconds`` (float):  [Read-Write] Replicated time at which the server started the sequence (taken from AGameStateBase::GetServerWorldTimeSeconds)
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def sequence(self) -> LevelSequenceActor:
        r"""
        (LevelSequenceActor):  [Read-Only] Pointer to the sequence actor to use for playback
        """
        ...
    @property
    def media_component(self) -> MediaComponent:
        r"""
        (MediaComponent):  [Read-Only] Media component that contains the media player to synchronize with
        """
        ...
    @property
    def server_start_time_seconds(self) -> float:
        r"""
        (float):  [Read-Only] Replicated time at which the server started the sequence (taken from AGameStateBase::GetServerWorldTimeSeconds)
        """
        ...
    def synchronize_to_server(self, desync_threshold_seconds: float = 2.000000) -> None:
        r"""
        x.synchronize_to_server(desync_threshold_seconds=2.000000) -> None
        Forcibly synchronize the sequence to the server's position if it has diverged by more than the specified threshold
        
        Args:
            desync_threshold_seconds (float):
        """
        ...
    def play(self) -> None:
        r"""
        x.play() -> None
        Play
        """
        ...
    def get_sequence(self) -> LevelSequenceActor:
        r"""
        x.get_sequence() -> LevelSequenceActor
        Access this actor's Level Sequence Actor
        
        Returns:
            LevelSequenceActor:
        """
        ...
    def get_media_component(self) -> MediaComponent:
        r"""
        x.get_media_component() -> MediaComponent
        Access this actor's media component
        
        Returns:
            MediaComponent:
        """
        ...

class ActorElementsCopy(Object):
    r"""
    Actor Elements Copy
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ActorElementEditorCopyAndPaste.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actors_to_copy`` (Array[Actor]):  [Read-Write]
    """
    @property
    def actors_to_copy(self) -> Array[Actor]:
        r"""
        (Array[Actor]):  [Read-Write]
        """
        ...
    @actors_to_copy.setter
    def actors_to_copy(self, value: Array[Actor]) -> None:
        ...

class Exporter(Object):
    r"""
    Exporter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Exporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    @property
    def supported_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Supported class of this exporter
        """
        ...
    @supported_class.setter
    def supported_class(self, value: Class) -> None:
        ...
    @property
    def format_extension(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] File extension to use for this exporter
        """
        ...
    @format_extension.setter
    def format_extension(self, value: Array[str]) -> None:
        ...
    @property
    def format_description(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Descriptiong of the export format
        """
        ...
    @format_description.setter
    def format_description(self, value: Array[str]) -> None:
        ...
    @property
    def text(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this will export the data as text
        """
        ...
    @text.setter
    def text(self, value: bool) -> None:
        ...
    @property
    def export_task(self) -> AssetExportTask:
        r"""
        (AssetExportTask):  [Read-Write]
        """
        ...
    @export_task.setter
    def export_task(self, value: AssetExportTask) -> None:
        ...
    def script_run_asset_export_task(self, task: AssetExportTask) -> bool:
        r"""
        x.script_run_asset_export_task(task) -> bool
        Export the given object to file.  Overridden by script based exporters.
        
        Args:
            task (AssetExportTask): The task to export.
        
        Returns:
            bool: true if overridden by script exporter.
        """
        ...
    @classmethod
    def run_asset_export_tasks(cls, export_tasks: Array[AssetExportTask]) -> bool:
        r"""
        X.run_asset_export_tasks(export_tasks) -> bool
        Export the given objects to files.  Child classes do not override this, but they do provide an Export() function
        to do the resource-specific export work.
        
        Args:
            export_tasks (Array[AssetExportTask]): The array of tasks to export.
        
        Returns:
            bool: true if all tasks ran without error
        """
        ...
    @classmethod
    def run_asset_export_task(cls, task: AssetExportTask) -> bool:
        r"""
        X.run_asset_export_task(task) -> bool
        Export the given object to file.  Child classes do not override this, but they do provide an Export() function
        to do the resource-specific export work.
        
        Args:
            task (AssetExportTask): The task to export.
        
        Returns:
            bool: true if the the object was successfully exported
        """
        ...

class ActorElementsExporterT3D(Exporter):
    r"""
    Actor Elements Exporter T3D
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ActorElementEditorCopyAndPaste.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class ActorGroupingUtils(Object):
    r"""
    Helper class for grouping actors in the level editor
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ActorGroupingUtils.h
    
    """
    def unlock_selected_groups(self) -> None:
        r"""
        x.unlock_selected_groups() -> None
        Unlocks any groups in the current selection
        """
        ...
    def ungroup_selected(self) -> None:
        r"""
        x.ungroup_selected() -> None
        Disbands any groups in the current selection, does not attempt to maintain any hierarchy
        """
        ...
    def ungroup_actors(self, actors_to_ungroup: Array[Actor]) -> None:
        r"""
        x.ungroup_actors(actors_to_ungroup) -> None
        Disbands any groups that the provided actors belong to, does not attempt to maintain any hierarchy
        
        Args:
            actors_to_ungroup (Array[Actor]):
        """
        ...
    @classmethod
    def set_grouping_active(cls, grouping_active: bool) -> None:
        r"""
        X.set_grouping_active(grouping_active) -> None
        Set Grouping Active
        
        Args:
            grouping_active (bool):
        """
        ...
    def remove_selected_from_group(self) -> None:
        r"""
        x.remove_selected_from_group() -> None
        Removes any groups or actors in the current selection from their immediate parent.
        If all actors/subgroups are removed, the parent group will be destroyed.
        """
        ...
    def lock_selected_groups(self) -> None:
        r"""
        x.lock_selected_groups() -> None
        Locks any groups in the current selection
        """
        ...
    @classmethod
    def is_grouping_active(cls) -> bool:
        r"""
        X.is_grouping_active() -> bool
        Is Grouping Active
        
        Returns:
            bool:
        """
        ...
    def group_selected(self) -> GroupActor:
        r"""
        x.group_selected() -> GroupActor
        Creates a new group from the current selection removing the actors from any existing groups they are already in
        
        Returns:
            GroupActor:
        """
        ...
    def group_actors(self, actors_to_group: Array[Actor]) -> GroupActor:
        r"""
        x.group_actors(actors_to_group) -> GroupActor
        Creates a new group from the provided list of actors removing the actors from any existing groups they are already in
        
        Args:
            actors_to_group (Array[Actor]): 
        
        Returns:
            GroupActor:
        """
        ...
    @classmethod
    def get(cls) -> ActorGroupingUtils:
        r"""
        X.get() -> ActorGroupingUtils
        Convenience method for accessing grouping utils in a blueprint or script
        
        Returns:
            ActorGroupingUtils:
        """
        ...
    def can_group_selected_actors(self) -> bool:
        r"""
        x.can_group_selected_actors() -> bool
        * Check if the currently selected actors can be grouped together
        
        Returns:
            bool:
        """
        ...
    def can_group_actors(self, actors_to_group: Array[Actor]) -> bool:
        r"""
        x.can_group_actors(actors_to_group) -> bool
        Check if the provided list of actors can be grouped together
        
        Args:
            actors_to_group (Array[Actor]): 
        
        Returns:
            bool:
        """
        ...
    def add_selected_to_group(self) -> None:
        r"""
        x.add_selected_to_group() -> None
        Activates "Add to Group" mode which allows the user to select a group to append current selection
        """
        ...

class BlendSpaceFactory1D(Factory):
    r"""
    Blend Space Factory 1D
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: BlendSpaceFactory1D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``preview_skeletal_mesh`` (SkeletalMesh):  [Read-Write] The preview mesh to use for the created blendspace
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``target_skeleton`` (Skeleton):  [Read-Write] Target skeleton for the created blendspace
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    @property
    def target_skeleton(self) -> Skeleton:
        r"""
        (Skeleton):  [Read-Write] Target skeleton for the created blendspace
        """
        ...
    @target_skeleton.setter
    def target_skeleton(self, value: Skeleton) -> None:
        ...
    @property
    def preview_skeletal_mesh(self) -> SkeletalMesh:
        r"""
        (SkeletalMesh):  [Read-Write] The preview mesh to use for the created blendspace
        """
        ...
    @preview_skeletal_mesh.setter
    def preview_skeletal_mesh(self, value: SkeletalMesh) -> None:
        ...

class AimOffsetBlendSpaceFactory1D(BlendSpaceFactory1D):
    r"""
    Aim Offset Blend Space Factory 1D
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AimOffsetBlendSpaceFactory1D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``preview_skeletal_mesh`` (SkeletalMesh):  [Read-Write] The preview mesh to use for the created blendspace
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``target_skeleton`` (Skeleton):  [Read-Write] Target skeleton for the created blendspace
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class BlendSpaceFactoryNew(Factory):
    r"""
    Blend Space Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: BlendSpaceFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``preview_skeletal_mesh`` (SkeletalMesh):  [Read-Write] The preview mesh to use for the created blendspace
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``target_skeleton`` (Skeleton):  [Read-Write] Target skeleton for the created blendspace
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    @property
    def target_skeleton(self) -> Skeleton:
        r"""
        (Skeleton):  [Read-Write] Target skeleton for the created blendspace
        """
        ...
    @target_skeleton.setter
    def target_skeleton(self, value: Skeleton) -> None:
        ...
    @property
    def preview_skeletal_mesh(self) -> SkeletalMesh:
        r"""
        (SkeletalMesh):  [Read-Write] The preview mesh to use for the created blendspace
        """
        ...
    @preview_skeletal_mesh.setter
    def preview_skeletal_mesh(self, value: SkeletalMesh) -> None:
        ...

class AimOffsetBlendSpaceFactoryNew(BlendSpaceFactoryNew):
    r"""
    Aim Offset Blend Space Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AimOffsetBlendSpaceFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``preview_skeletal_mesh`` (SkeletalMesh):  [Read-Write] The preview mesh to use for the created blendspace
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``target_skeleton`` (Skeleton):  [Read-Write] Target skeleton for the created blendspace
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AnimBlueprintFactory(Factory):
    r"""
    Anim Blueprint Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AnimBlueprintFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``blueprint_type`` (BlueprintType):  [Read-Write] The type of blueprint that will be created
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Write] The parent class of the created blueprint
    - ``preview_skeletal_mesh`` (SkeletalMesh):  [Read-Write] The preview mesh to use with this animation blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``target_skeleton`` (Skeleton):  [Read-Write] The kind of skeleton that animation graphs compiled from the blueprint will animate
    - ``template`` (bool):  [Read-Write] Whether the created blueprint should be a template with no target skeleton
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class VimBlueprintFactory(AnimBlueprintFactory):
    r"""
    deprecated: 'VimBlueprintFactory' was renamed to 'AnimBlueprintFactory'.
    """
    ...

class AnimLayerInterfaceFactory(AnimBlueprintFactory):
    r"""
    Anim Layer Interface Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AnimBlueprintFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``blueprint_type`` (BlueprintType):  [Read-Write] The type of blueprint that will be created
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Write] The parent class of the created blueprint
    - ``preview_skeletal_mesh`` (SkeletalMesh):  [Read-Write] The preview mesh to use with this animation blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``target_skeleton`` (Skeleton):  [Read-Write] The kind of skeleton that animation graphs compiled from the blueprint will animate
    - ``template`` (bool):  [Read-Write] Whether the created blueprint should be a template with no target skeleton
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AnimBoneCompressionSettingsFactory(Factory):
    r"""
    Anim Bone Compression Settings Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AnimBoneCompressionSettingsFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AnimCompositeFactory(Factory):
    r"""
    Anim Composite Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AnimCompositeFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AnimCurveCompressionSettingsFactory(Factory):
    r"""
    Anim Curve Compression Settings Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AnimCurveCompressionSettingsFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AnimMontageFactory(Factory):
    r"""
    Anim Montage Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AnimMontageFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``source_animation`` (AnimSequence):  [Read-Write] Used when creating a montage from an AnimSequence, becomes the only AnimSequence contained
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``target_skeleton`` (Skeleton):  [Read-Write]
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    @property
    def target_skeleton(self) -> Skeleton:
        r"""
        (Skeleton):  [Read-Write]
        """
        ...
    @target_skeleton.setter
    def target_skeleton(self, value: Skeleton) -> None:
        ...
    @property
    def source_animation(self) -> AnimSequence:
        r"""
        (AnimSequence):  [Read-Write] Used when creating a montage from an AnimSequence, becomes the only AnimSequence contained
        """
        ...
    @source_animation.setter
    def source_animation(self, value: AnimSequence) -> None:
        ...

class AnimSeqExportOption(Object):
    r"""
    Anim Seq Export Option
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AnimSeqExportOption.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve_interpolation`` (RichCurveInterpMode):  [Read-Write] This defines how values between keys are calculated for curves
    - ``delay_before_start`` (FrameNumber):  [Read-Write] Number of Display Rate frames to delay at the same frame before doing the export. It will evalaute first, then any warm up, then the export. Use it if there is some post anim BP effects you want to ran repeatedly at the start.
    - ``evaluate_all_skeletal_mesh_components`` (bool):  [Read-Write] If true we evaluate all other skeletal mesh components under the same actor, this may be needed for example, to get physics to get baked
    - ``exclude_animation_names`` (Array[str]):  [Read-Write] Exclude all animation bones/curves that match this list
    - ``export_attribute_curves`` (bool):  [Read-Write] If enabled, export the attribute curves from the animation
    - ``export_material_curves`` (bool):  [Read-Write] If enabled, export the material curves from the animation
    - ``export_morph_targets`` (bool):  [Read-Write] If enabled, export the morph targets from the animation
    - ``export_transforms`` (bool):  [Read-Write] If enabled, export the transforms from the animation
    - ``include_animation_names`` (Array[str]):  [Read-Write] Include only the animation bones/curves that match this list
    - ``interpolation`` (AnimInterpolationType):  [Read-Write] This defines how values between keys are calculated for transforms
    - ``record_in_world_space`` (bool):  [Read-Write] If enabled we record in World Space otherwise we record from 0,0,0
    - ``transact_recording`` (bool):  [Read-Write] Whether or not to transact the animation sequence data recording
    - ``warm_up_frames`` (FrameNumber):  [Read-Write] Number of Display Rate frames to evaluate before doing the export. It will evaluate after any Delay. This will use frames before the start frame. Use it if there is some post anim BP effects you want to run before export start time.
    """
    @property
    def export_transforms(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export the transforms from the animation
        """
        ...
    @export_transforms.setter
    def export_transforms(self, value: bool) -> None:
        ...
    @property
    def export_morph_targets(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export the morph targets from the animation
        """
        ...
    @export_morph_targets.setter
    def export_morph_targets(self, value: bool) -> None:
        ...
    @property
    def export_attribute_curves(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export the attribute curves from the animation
        """
        ...
    @export_attribute_curves.setter
    def export_attribute_curves(self, value: bool) -> None:
        ...
    @property
    def export_material_curves(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export the material curves from the animation
        """
        ...
    @export_material_curves.setter
    def export_material_curves(self, value: bool) -> None:
        ...
    @property
    def record_in_world_space(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled we record in World Space otherwise we record from 0,0,0
        """
        ...
    @record_in_world_space.setter
    def record_in_world_space(self, value: bool) -> None:
        ...
    @property
    def evaluate_all_skeletal_mesh_components(self) -> bool:
        r"""
        (bool):  [Read-Write] If true we evaluate all other skeletal mesh components under the same actor, this may be needed for example, to get physics to get baked
        """
        ...
    @evaluate_all_skeletal_mesh_components.setter
    def evaluate_all_skeletal_mesh_components(self, value: bool) -> None:
        ...
    @property
    def interpolation(self) -> AnimInterpolationType:
        r"""
        (AnimInterpolationType):  [Read-Write] This defines how values between keys are calculated for transforms
        """
        ...
    @interpolation.setter
    def interpolation(self, value: AnimInterpolationType) -> None:
        ...
    @property
    def curve_interpolation(self) -> RichCurveInterpMode:
        r"""
        (RichCurveInterpMode):  [Read-Write] This defines how values between keys are calculated for curves
        """
        ...
    @curve_interpolation.setter
    def curve_interpolation(self, value: RichCurveInterpMode) -> None:
        ...
    @property
    def include_animation_names(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Include only the animation bones/curves that match this list
        """
        ...
    @include_animation_names.setter
    def include_animation_names(self, value: Array[str]) -> None:
        ...
    @property
    def exclude_animation_names(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Exclude all animation bones/curves that match this list
        """
        ...
    @exclude_animation_names.setter
    def exclude_animation_names(self, value: Array[str]) -> None:
        ...
    @property
    def warm_up_frames(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] Number of Display Rate frames to evaluate before doing the export. It will evaluate after any Delay. This will use frames before the start frame. Use it if there is some post anim BP effects you want to run before export start time.
        """
        ...
    @warm_up_frames.setter
    def warm_up_frames(self, value: FrameNumber) -> None:
        ...
    @property
    def delay_before_start(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] Number of Display Rate frames to delay at the same frame before doing the export. It will evalaute first, then any warm up, then the export. Use it if there is some post anim BP effects you want to ran repeatedly at the start.
        """
        ...
    @delay_before_start.setter
    def delay_before_start(self, value: FrameNumber) -> None:
        ...
    @property
    def transact_recording(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to transact the animation sequence data recording
        """
        ...
    @transact_recording.setter
    def transact_recording(self, value: bool) -> None:
        ...

class ExporterFBX(Exporter):
    r"""
    Exporter FBX
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ExporterFbx.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class AnimSequenceExporterFBX(ExporterFBX):
    r"""
    Anim Sequence Exporter FBX
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AnimSequenceExporterFBX.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class AnimSequenceFactory(Factory):
    r"""
    Anim Sequence Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AnimSequenceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``preview_skeletal_mesh`` (SkeletalMesh):  [Read-Write] The preview mesh to use with this animation
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``target_skeleton`` (Skeleton):  [Read-Write]
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    @property
    def target_skeleton(self) -> Skeleton:
        r"""
        (Skeleton):  [Read-Write]
        """
        ...
    @target_skeleton.setter
    def target_skeleton(self, value: Skeleton) -> None:
        ...
    @property
    def preview_skeletal_mesh(self) -> SkeletalMesh:
        r"""
        (SkeletalMesh):  [Read-Write] The preview mesh to use with this animation
        """
        ...
    @preview_skeletal_mesh.setter
    def preview_skeletal_mesh(self, value: SkeletalMesh) -> None:
        ...

class AnimStreamableFactory(Factory):
    r"""
    Anim Streamable Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AnimStreamableFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AssetEditorSubsystem(EditorSubsystem):
    r"""
    UAssetEditorSubsystem
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AssetEditorSubsystem.h
    
    """
    def open_editor_for_assets(self, assets: Array[Object], opened_method: AssetTypeActivationOpenedMethod = AssetTypeActivationOpenedMethod.EDIT) -> bool:
        r"""
        x.open_editor_for_assets(assets, opened_method=AssetTypeActivationOpenedMethod.EDIT) -> bool
        Tries to open an editor for all of the specified assets.
        If any of the assets are already open, it will not create a new editor for them.
        If all assets are of the same type, the supporting AssetTypeAction (if it exists) is responsible for the details of how to handle opening multiple assets at once.
        
        Args:
            assets (Array[Object]): 
            opened_method (AssetTypeActivationOpenedMethod): 
        
        Returns:
            bool:
        """
        ...
    def close_all_editors_for_asset(self, asset: Object) -> int:
        r"""
        x.close_all_editors_for_asset(asset) -> int32
        Close all active editors for the supplied asset and return the number of asset editors that were closed
        
        Args:
            asset (Object): 
        
        Returns:
            int32:
        """
        ...

class AssetEditorToolkitMenuContext(Object):
    r"""
    Asset Editor Toolkit Menu Context
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AssetEditorToolkitMenuContext.h
    
    """
    def get_editing_objects(self) -> Array[Object]:
        r"""
        x.get_editing_objects() -> Array[Object]
        Get Editing Objects
        
        Returns:
            Array[Object]:
        """
        ...

class AssetGuideline(AssetUserData):
    r"""
    User data that can be attached to assets to check on load for guidlelines (plugins, project settings, etc).
    
    This class intentionally does not accept FText arguments. The project using your bundled asset would need to have
    your localization tables, and we currently do not support text table referencing.
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AssetGuideline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``guideline_name`` (Name):  [Read-Write] Name of this guideline, we will only check once per unique guideline name.
    - ``plugins`` (Array[str]):  [Read-Write] Plugins to check for on load
    - ``project_settings`` (Array[IniStringValue]):  [Read-Write] Project settings to check for on load. Look at your .ini's to populate this.
    """
    ...

class AssetImportTask(Object):
    r"""
    Contains data for a group of assets to import
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AssetImportTask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``async_`` (bool):  [Read-Write] Perform the import asynchronously for file formats where async import is available
    - ``automated`` (bool):  [Read-Write] Avoid dialogs
    - ``destination_name`` (str):  [Read-Write] Optional custom name to import as (if you are using interchange the name must be set in a pipeline and this field will be ignored)
    - ``destination_path`` (str):  [Read-Write] Path where asset will be imported to
    - ``factory`` (Factory):  [Read-Write] Optional factory to use
    - ``filename`` (str):  [Read-Write] Filename to import
    - ``imported_object_paths`` (Array[str]):  [Read-Write] Paths to objects created or updated after import
    - ``options`` (Object):  [Read-Write] Import options specific to the type of asset
    - ``replace_existing`` (bool):  [Read-Write] Overwrite existing assets
    - ``replace_existing_settings`` (bool):  [Read-Write] Replace existing settings when overwriting existing assets
    - ``result`` (Array[Object]):  [Read-Write]
      deprecated: Please use the GetObjects function instead.
    - ``save`` (bool):  [Read-Write] Save after importing
    """
    @property
    def filename(self) -> str:
        r"""
        (str):  [Read-Write] Filename to import
        """
        ...
    @filename.setter
    def filename(self, value: str) -> None:
        ...
    @property
    def destination_path(self) -> str:
        r"""
        (str):  [Read-Write] Path where asset will be imported to
        """
        ...
    @destination_path.setter
    def destination_path(self, value: str) -> None:
        ...
    @property
    def destination_name(self) -> str:
        r"""
        (str):  [Read-Write] Optional custom name to import as (if you are using interchange the name must be set in a pipeline and this field will be ignored)
        """
        ...
    @destination_name.setter
    def destination_name(self, value: str) -> None:
        ...
    @property
    def replace_existing(self) -> bool:
        r"""
        (bool):  [Read-Write] Overwrite existing assets
        """
        ...
    @replace_existing.setter
    def replace_existing(self, value: bool) -> None:
        ...
    @property
    def replace_existing_settings(self) -> bool:
        r"""
        (bool):  [Read-Write] Replace existing settings when overwriting existing assets
        """
        ...
    @replace_existing_settings.setter
    def replace_existing_settings(self, value: bool) -> None:
        ...
    @property
    def automated(self) -> bool:
        r"""
        (bool):  [Read-Write] Avoid dialogs
        """
        ...
    @automated.setter
    def automated(self, value: bool) -> None:
        ...
    @property
    def save(self) -> bool:
        r"""
        (bool):  [Read-Write] Save after importing
        """
        ...
    @save.setter
    def save(self, value: bool) -> None:
        ...
    @property
    def async_(self) -> bool:
        r"""
        (bool):  [Read-Write] Perform the import asynchronously for file formats where async import is available
        """
        ...
    @async_.setter
    def async_(self, value: bool) -> None:
        ...
    @property
    def factory(self) -> Factory:
        r"""
        (Factory):  [Read-Write] Optional factory to use
        """
        ...
    @factory.setter
    def factory(self, value: Factory) -> None:
        ...
    @property
    def options(self) -> Object:
        r"""
        (Object):  [Read-Write] Import options specific to the type of asset
        """
        ...
    @options.setter
    def options(self, value: Object) -> None:
        ...
    @property
    def imported_object_paths(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Paths to objects created or updated after import
        """
        ...
    @imported_object_paths.setter
    def imported_object_paths(self, value: Array[str]) -> None:
        ...
    @property
    def result(self) -> Array[Object]:
        r"""
        (Array[Object]):  [Read-Write]
        deprecated: Please use the GetObjects function instead.
        """
        ...
    @result.setter
    def result(self, value: Array[Object]) -> None:
        ...
    def is_async_import_complete(self) -> bool:
        r"""
        x.is_async_import_complete() -> bool
        Query whether this asynchronous import task is complete, and the results are ready to read.
        This will always return true in the case of a blocking import.
        
        Returns:
            bool:
        """
        ...
    def get_objects(self) -> Array[Object]:
        r"""
        x.get_objects() -> Array[Object]
        Get the list of imported objects.
        Note that if the import was asynchronous, this will block until the results are ready.
        To test whether asynchronous results are ready or not, use IsAsyncImportComplete().
        
        Returns:
            Array[Object]:
        """
        ...

class AutomatedAssetImportData(Object):
    r"""
    Contains data for a group of assets to import
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: AutomatedAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``destination_path`` (str):  [Read-Write] Content path in the projects content directory where assets will be imported
    - ``factory`` (Factory):  [Read-Write] Pointer to the factory currently being used
    - ``factory_name`` (str):  [Read-Write] Name of the factory to use when importing these assets. If not specified the factory type will be auto detected
    - ``filenames`` (Array[str]):  [Read-Write] Filenames to import
    - ``group_name`` (str):  [Read-Write] Display name of the group. This is for logging purposes only.
    - ``level_to_load`` (str):  [Read-Write] Full path to level to load before importing this group (only matters if importing assets into a level)
    - ``replace_existing`` (bool):  [Read-Write] Whether or not to replace existing assets
    - ``skip_read_only`` (bool):  [Read-Write] Whether or not to skip importing over read only assets that could not be checked out
    """
    @property
    def group_name(self) -> str:
        r"""
        (str):  [Read-Write] Display name of the group. This is for logging purposes only.
        """
        ...
    @group_name.setter
    def group_name(self, value: str) -> None:
        ...
    @property
    def filenames(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Filenames to import
        """
        ...
    @filenames.setter
    def filenames(self, value: Array[str]) -> None:
        ...
    @property
    def destination_path(self) -> str:
        r"""
        (str):  [Read-Write] Content path in the projects content directory where assets will be imported
        """
        ...
    @destination_path.setter
    def destination_path(self, value: str) -> None:
        ...
    @property
    def factory_name(self) -> str:
        r"""
        (str):  [Read-Write] Name of the factory to use when importing these assets. If not specified the factory type will be auto detected
        """
        ...
    @factory_name.setter
    def factory_name(self, value: str) -> None:
        ...
    @property
    def replace_existing(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to replace existing assets
        """
        ...
    @replace_existing.setter
    def replace_existing(self, value: bool) -> None:
        ...
    @property
    def skip_read_only(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to skip importing over read only assets that could not be checked out
        """
        ...
    @skip_read_only.setter
    def skip_read_only(self, value: bool) -> None:
        ...
    @property
    def factory(self) -> Factory:
        r"""
        (Factory):  [Read-Write] Pointer to the factory currently being used
        """
        ...
    @factory.setter
    def factory(self, value: Factory) -> None:
        ...
    @property
    def level_to_load(self) -> str:
        r"""
        (str):  [Read-Write] Full path to level to load before importing this group (only matters if importing assets into a level)
        """
        ...
    @level_to_load.setter
    def level_to_load(self, value: str) -> None:
        ...

class BlueprintFactory(Factory):
    r"""
    Blueprint Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: BlueprintFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Write] The parent class of the created blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class BlueprintFunctionLibraryFactory(BlueprintFactory):
    r"""
    Blueprint Function Library Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: BlueprintFunctionLibraryFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Write] The parent class of the created blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class BlueprintInterfaceFactory(BlueprintFactory):
    r"""
    Blueprint Interface Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: BlueprintInterfaceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Write] The parent class of the created blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class BlueprintMacroFactory(BlueprintFactory):
    r"""
    Blueprint Macro Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: BlueprintMacroFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Write] The parent class of the created blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class CanvasRenderTarget2DFactoryNew(Factory):
    r"""
    Canvas Render Target 2DFactory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CanvasRenderTarget2DFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ComponentElementsCopy(Object):
    r"""
    Component Elements Copy
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ComponentElementEditorCopyAndPaste.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``components_to_copy`` (Array[ActorComponent]):  [Read-Write]
    """
    @property
    def components_to_copy(self) -> Array[ActorComponent]:
        r"""
        (Array[ActorComponent]):  [Read-Write]
        """
        ...
    @components_to_copy.setter
    def components_to_copy(self, value: Array[ActorComponent]) -> None:
        ...

class ComponentElementsExporterT3D(Exporter):
    r"""
    Component Elements Exporter T3D
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ComponentElementEditorCopyAndPaste.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class CompositeCurveTableFactory(Factory):
    r"""
    Composite Curve Table Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CompositeCurveTableFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class DataTableFactory(Factory):
    r"""
    Data Table Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: DataTableFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``struct`` (ScriptStruct):  [Read-Write]
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    @property
    def struct(self) -> ScriptStruct:
        r"""
        (ScriptStruct):  [Read-Write]
        """
        ...
    @struct.setter
    def struct(self, value: ScriptStruct) -> None:
        ...

class CompositeDataTableFactory(DataTableFactory):
    r"""
    Composite Data Table Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CompositeDataTableFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``struct`` (ScriptStruct):  [Read-Write]
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class CSVImportFactory(Factory):
    r"""
    CSVImport Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CSVImportFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``automated_import_settings`` (CSVImportSettings):  [Read-Write]
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    @property
    def automated_import_settings(self) -> CSVImportSettings:
        r"""
        (CSVImportSettings):  [Read-Write]
        """
        ...
    @automated_import_settings.setter
    def automated_import_settings(self, value: CSVImportSettings) -> None:
        ...

class CurveFactory(Factory):
    r"""
    Factory that creates curve assets, prompting to pick the kind of curve at creation time
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CurveFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``curve_class`` (type(Class)):  [Read-Write] The type of blueprint that will be created
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class CurveFloatFactory(CurveFactory):
    r"""
    Factory that creates float curve assets
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CurveFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``curve_class`` (type(Class)):  [Read-Write] The type of blueprint that will be created
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class CurveLinearColorFactory(CurveFactory):
    r"""
    Factory that creates linear color curve assets
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CurveFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``curve_class`` (type(Class)):  [Read-Write] The type of blueprint that will be created
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class CurveVectorFactory(CurveFactory):
    r"""
    Factory that creates vector curve assets
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CurveFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``curve_class`` (type(Class)):  [Read-Write] The type of blueprint that will be created
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class CurveImportFactory(Factory):
    r"""
    Curve Import Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CurveImportFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class CurveLinearColorAtlasFactory(Factory):
    r"""
    Curve Linear Color Atlas Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CurveLinearColorAtlasFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class CurveTableFactory(Factory):
    r"""
    Creates a CurveTable with Rich Curves
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: CurveTableFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class DataAssetFactory(Factory):
    r"""
    Data Asset Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: DataAssetFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``data_asset_class`` (type(Class)):  [Read-Write]
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class DebugSkelMeshComponent(SkeletalMeshComponent):
    r"""
    Debug Skel Mesh Component
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: DebugSkelMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_anim_curve_evaluation`` (bool):  [Read-Write] Disable animation curves for this component. If this is set true, no curves will be processed
    - ``allow_cloth_actors`` (bool):  [Read-Write] Toggles creation of cloth simulation. Distinct from the simulation toggle below in that, if off, avoids allocating
      the actors entirely instead of just skipping the simulation step.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``anim_blueprint_generated_class`` (type(AnimBlueprintGeneratedClass)):  [Read-Write]
    - ``anim_class`` (type(Class)):  [Read-Write] The AnimBlueprint class to use. Use 'SetAnimInstanceClass' to change at runtime.
    - ``animation_data`` (SingleAnimationPlayData):  [Read-Write]
    - ``animation_mode`` (AnimationMode):  [Read-Write] Whether to use Animation Blueprint or play Single Animation Asset.
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capsule_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the capsule indirect shadow can be.
    - ``cast_capsule_direct_shadow`` (bool):  [Read-Write] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for direct shadowing from lights.
      This type of shadowing is approximate but handles extremely wide area shadowing well.  The softness of the shadow depends on the light's LightSourceAngle / SourceRadius.
      This flag will force bCastInsetShadow to be enabled.
    - ``cast_capsule_indirect_shadow`` (bool):  [Read-Write] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for shadowing indirect lighting (from lightmaps or skylight).
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``cloth_blend_weight`` (float):  [Read-Write] weight to blend between simulated results and key-framed positions
      if weight is 1.0, shows only cloth simulation results and 0.0 will show only skinned results
    - ``cloth_max_distance_scale`` (float):  [Read-Write]
    - ``cloth_velocity_scale`` (float):  [Read-Write] Scale applied to the component induced velocity of all cloth particles prior to stepping the cloth solver.
      Use 1.0 for fully induced velocity (default), or use 0.0 for no induced velocity, and any other values in between for a reduced induced velocity.
      When set to 0.0, it also provides a way to force the clothing to simulate in local space.
      This value multiplies to individual cloth's velocity scale settings, still allowing for differences in behavior between the various pieces of clothing within the same component.
    - ``clothing_simulation_factory`` (type(Class)):  [Read-Write] Class of the object responsible for
    - ``collide_with_attached_children`` (bool):  [Read-Write] can't collide with part of attached children if total collision volumes exceed 16 capsules or 32 planes per convex
    - ``collide_with_environment`` (bool):  [Read-Write] can't collide with part of environment if total collision volumes exceed 16 capsules or 32 planes per convex
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``component_use_fixed_skel_bounds`` (bool):  [Read-Write] When true, skip using the physics asset etc. and always use the fixed bounds defined in the SkeletalMesh.
    - ``consider_all_bodies_for_bounds`` (bool):  [Read-Write] If true, when updating bounds from a PhysicsAsset, consider _all_ BodySetups, not just those flagged with bConsiderForBounds.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``default_animating_rig_override`` (Object):  [Read-Write] Default Animating Rig to Use if bOverrideDefaultAnimatingRig is true
    - ``defer_kinematic_bone_update`` (bool):  [Read-Write] Whether animation and world transform updates are deferred. If this is on, the kinematic bodies (scene query data) will not update until the next time the physics simulation is run
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disable_cloth_simulation`` (bool):  [Read-Write] Disable cloth simulation and play original animation without simulation
    - ``disable_morph_target`` (bool):  [Read-Write] Disable Morphtarget for this component.
    - ``disable_post_process_blueprint`` (bool):  [Read-Write] Controls whether or not this component will evaluate its post process instance. The post-process
      Instance is dictated by the skeletal mesh so this is used for per-instance control.
    - ``disable_rigid_body_anim_node`` (bool):  [Read-Write] Disable rigid body animation nodes and play original animation without simulation
    - ``display_debug_update_rate_optimizations`` (bool):  [Read-Write] Enable on screen debugging of update rate optimization.
      Red = Skipping 0 frames, Green = skipping 1 frame, Blue = skipping 2 frames, black = skipping more than 2 frames.
      todo:: turn this into a console command.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``enable_per_poly_collision`` (bool):  [Read-Write] Uses skinned data for collision data.
    - ``enable_physics_on_dedicated_server`` (bool):  [Read-Write] If true, simulate physics for this component on a dedicated server.
      This should be set if simulating physics and replicating with a dedicated server.
          Note: This property cannot be changed at runtime.
    - ``enable_update_rate_optimizations`` (bool):  [Read-Write] if TRUE, Owner will determine how often animation will be updated and evaluated. See AnimUpdateRateTick()
      This allows to skip frames for performance. (For example based on visibility and size on screen).
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_collision_update`` (bool):  [Read-Write] Forces the cloth simulation to constantly update its external collisions, at the expense of performance.
      This will help to prevent missed collisions if the cloth's skeletal mesh component isn't moving,
      and when instead, wind or other moving objects are causing new collision shapes to come into the cloth's vicinity.
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``forced_lod_model`` (int32):  [Read-Write]
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``global_anim_rate_scale`` (float):  [Read-Write] Used to scale speed of all animations on this skeletal mesh.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_leader_pose_component_lod`` (bool):  [Read-Write] Flag that when set will ensure UpdateLODStatus will not take the LeaderPoseComponent's current LOD in consideration when determining the correct LOD level (this requires LeaderPoseComponent's LOD to always be >= determined LOD otherwise bone transforms could be missing
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``include_component_location_into_bounds`` (bool):  [Read-Write] If true, the Location of this Component will be included into its bounds calculation
      (this can be useful when using SMU_OnlyTickPoseWhenRendered on a character that moves away from the root and no bones are left near the origin of the component)
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``kinematic_bones_update_type`` (KinematicBonesUpdateToPhysics):  [Read-Write] If we are running physics, should we update non-simulated bones based on the animation bone positions.
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``leader_pose_component`` (SkinnedMeshComponent):  [Read-Write] If set, this SkeletalMeshComponent will not use its SpaceBase for bone transform, but will
      use the component space transforms from the LeaderPoseComponent. This is used when constructing a character using multiple skeletal meshes sharing the same
      skeleton within the same Actor.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``mesh_deformer`` (MeshDeformer):  [Read-Write] The mesh deformer to use. If no mesh deformer is set from here or the SkeletalMesh, then we fall back to the fixed function deformation.
    - ``mesh_deformer_instance`` (MeshDeformerInstance):  [Read-Write]
      deprecated: Use the GetMeshDeformerInstance function instead
    - ``mesh_deformer_instance_settings`` (MeshDeformerInstanceSettings):  [Read-Only] Object containing instance settings for the bound MeshDeformer.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod_model`` (int32):  [Read-Write] This is the min LOD that this component will use.  (e.g. if set to 2 then only 2+ LOD Models will be used.) This is useful to set on
      meshes which are known to be a certain distance away and still want to have better LODs when zoomed in on them.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``no_skeleton_update`` (bool):  [Read-Write] Skips Ticking and Bone Refresh.
    - ``on_anim_initialized`` (OnAnimInitialized):  [Read-Write] Broadcast when the components anim instance is initialized
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_constraint_broken`` (ConstraintBrokenSignature):  [Read-Write] Notification when constraint is broken.
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_plastic_deformation`` (PlasticDeformationEventSignature):  [Read-Write] Notification when constraint plasticity drive target changes.
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_default_animating_rig`` (bool):  [Read-Write] If true, DefaultAnimatingRigOverride will be used. If false, use the DefaultAnimatingRig in the SkeletalMesh
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether we should use the min lod specified in MinLodModel for this component instead of the min lod in the mesh
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``pause_anims`` (bool):  [Read-Write] pauses this component's animations (doesn't tick them, but still refreshes bones)
    - ``per_bone_motion_blur`` (bool):  [Read-Write] If true, use per-bone motion blur on this skeletal mesh (requires additional rendering, can be disabled to save performance).
    - ``physics_asset_override`` (PhysicsAsset):  [Read-Write] PhysicsAsset is set in SkeletalMesh by default, but you can override with this value
    - ``physics_transform_update_mode`` (PhysicsTransformUpdateMode):  [Read-Write] Whether physics simulation updates component transform.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``propagate_curves_to_followers`` (bool):  [Read-Write] If true, propagates calls to ApplyAnimationCurvesToComponent for follower components, only needed if follower components do not tick themselves
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``render_static`` (bool):  [Read-Write] If true, render as static in reference pose.
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``reset_after_teleport`` (bool):  [Read-Write] reset the clothing after moving the clothing position (called teleport)
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``set_mesh_deformer`` (bool):  [Read-Write] If true, MeshDeformer will be used. If false, use the default mesh deformer on the SkeletalMesh.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``skeletal_mesh`` (SkeletalMesh):  [Read-Write]
      deprecated: Use USkeletalMeshComponent::GetSkeletalMeshAsset() or GetSkinnedAsset() instead.
    - ``skeletal_mesh_asset`` (SkeletalMesh):  [Read-Write]
    - ``skin_cache_usage`` (Array[SkinCacheUsage]):  [Read-Write] How this Component's LOD uses the skin cache feature. Auto will defer to the asset's (SkeletalMesh) option. If Ray Tracing is enabled, will imply Enabled
    - ``skinned_asset`` (SkinnedAsset):  [Read-Write]
    - ``skip_bounds_update_when_interpolating`` (bool):  [Read-Write] Whether to skip bounds update when interpolating. Bounds are updated to the target interpolation pose only on ticks when they are evaluated.
    - ``skip_kinematic_update_when_interpolating`` (bool):  [Read-Write] Whether to skip UpdateKinematicBonesToAnim() when interpolating. Kinematic bones are updated to the target interpolation pose only on ticks when they are evaluated.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired streaming distance of streaming textures that uses UV 0.
      1.0 is the default, whereas a higher value makes the textures stream in sooner from far away.
      A lower value (0.0-1.0) makes the textures stream in later (you have to be closer).
      Value can be < 0 (from legcay content, or code changes)
    - ``sync_attach_parent_lod`` (bool):  [Read-Write] If true, this component uses its parents LOD when attached if available
      ForcedLOD can override this change. By default, it will use parent LOD.
    - ``teleport_distance_threshold`` (float):  [Read-Write] Conduct teleportation if the character's movement is greater than this threshold in 1 frame.
      Zero or negative values will skip the check.
      You can also do force teleport manually using ForceNextUpdateTeleport() / ForceNextUpdateTeleportAndReset().
    - ``teleport_rotation_threshold`` (float):  [Read-Write] Rotation threshold in degrees, ranging from 0 to 180.
      Conduct teleportation if the character's rotation is greater than this threshold in 1 frame.
      Zero or negative values will skip the check.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``update_animation_in_editor`` (bool):  [Read-Write] If true, this will Tick until disabled
    - ``update_cloth_in_editor`` (bool):  [Read-Write] If true, will play cloth in editor
    - ``update_joints_from_animation`` (bool):  [Read-Write] If we should pass joint position to joints each frame, so that they can be used by motorized joints to drive the
      ragdoll based on the animation.
    - ``update_mesh_when_kinematic`` (bool):  [Read-Write] If true, then the physics bodies will be used to drive the skeletal mesh even when they are
      kinematic (not simulating), otherwise the skeletal mesh will be driven by the animation input
      when the bodies are kinematic
    - ``update_overlaps_on_animation_finalize`` (bool):  [Read-Write] Controls whether blending in physics bones will refresh overlaps on this component, defaults to true but can be disabled in cases where we know anim->physics blending doesn't meaningfully change overlaps
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_bounds_from_leader_pose_component`` (bool):  [Read-Write] When true, we will just using the bounds from our LeaderPoseComponent.  This is useful for when we have a Mesh Parented
      to the main SkelMesh (e.g. outline mesh or a full body overdraw effect that is toggled) that is always going to be the same
      bounds as parent.  We want to do no calculations in that case.
    - ``use_ref_pose_on_init_anim`` (bool):  [Read-Write] On InitAnim should we set to ref pose (if false use first tick of animation data). If enabled, takes precedence over UAnimationSettings::bTickAnimationOnSkeletalMeshInit
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visibility_based_anim_tick_option`` (VisibilityBasedAnimTickOption):  [Read-Write] * This is tick animation frequency option based on this component rendered or not or using montage
      *  You can change this default value in the INI file
      * Mostly related with performance
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wait_for_parallel_cloth_task`` (bool):  [Read-Write] Whether we should stall the Cloth tick task until the cloth simulation is complete. This is required if we want up-to-date
      cloth data on the game thread, for example if we want to generate particles at cloth vertices.
    """
    ...

class EditorActorSubsystem(EditorSubsystem):
    r"""
    UEditorActorUtilitiesSubsystem
    Subsystem for exposing actor related utilities to scripts,
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorActorSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_delete_actors_begin`` (OnDeleteActorsBegin):  [Read-Write]
    - ``on_delete_actors_end`` (OnDeleteActorsEnd):  [Read-Write]
    - ``on_duplicate_actors_begin`` (OnEditCutActorsBegin):  [Read-Write]
    - ``on_duplicate_actors_end`` (OnDuplicateActorsEnd):  [Read-Write]
    - ``on_edit_copy_actors_begin`` (OnEditCopyActorsBegin):  [Read-Write]
    - ``on_edit_copy_actors_end`` (OnEditCopyActorsEnd):  [Read-Write]
    - ``on_edit_cut_actors_begin`` (OnEditCutActorsBegin):  [Read-Write]
    - ``on_edit_cut_actors_end`` (OnEditCutActorsEnd):  [Read-Write]
    - ``on_edit_paste_actors_begin`` (OnEditPasteActorsBegin):  [Read-Write]
    - ``on_edit_paste_actors_end`` (OnEditPasteActorsEnd):  [Read-Write]
    - ``on_new_actors_dropped`` (OnEditNewActorsDropped):  [Read-Write]
    - ``on_new_actors_placed`` (OnEditNewActorsPlaced):  [Read-Write]
    """
    @property
    def on_new_actors_dropped(self) -> OnEditNewActorsDropped:
        r"""
        (OnEditNewActorsDropped):  [Read-Write]
        """
        ...
    @on_new_actors_dropped.setter
    def on_new_actors_dropped(self, value: OnEditNewActorsDropped) -> None:
        ...
    @property
    def on_new_actors_placed(self) -> OnEditNewActorsPlaced:
        r"""
        (OnEditNewActorsPlaced):  [Read-Write]
        """
        ...
    @on_new_actors_placed.setter
    def on_new_actors_placed(self, value: OnEditNewActorsPlaced) -> None:
        ...
    @property
    def on_edit_cut_actors_begin(self) -> OnEditCutActorsBegin:
        r"""
        (OnEditCutActorsBegin):  [Read-Write]
        """
        ...
    @on_edit_cut_actors_begin.setter
    def on_edit_cut_actors_begin(self, value: OnEditCutActorsBegin) -> None:
        ...
    @property
    def on_edit_cut_actors_end(self) -> OnEditCutActorsEnd:
        r"""
        (OnEditCutActorsEnd):  [Read-Write]
        """
        ...
    @on_edit_cut_actors_end.setter
    def on_edit_cut_actors_end(self, value: OnEditCutActorsEnd) -> None:
        ...
    @property
    def on_edit_copy_actors_begin(self) -> OnEditCopyActorsBegin:
        r"""
        (OnEditCopyActorsBegin):  [Read-Write]
        """
        ...
    @on_edit_copy_actors_begin.setter
    def on_edit_copy_actors_begin(self, value: OnEditCopyActorsBegin) -> None:
        ...
    @property
    def on_edit_copy_actors_end(self) -> OnEditCopyActorsEnd:
        r"""
        (OnEditCopyActorsEnd):  [Read-Write]
        """
        ...
    @on_edit_copy_actors_end.setter
    def on_edit_copy_actors_end(self, value: OnEditCopyActorsEnd) -> None:
        ...
    @property
    def on_edit_paste_actors_begin(self) -> OnEditPasteActorsBegin:
        r"""
        (OnEditPasteActorsBegin):  [Read-Write]
        """
        ...
    @on_edit_paste_actors_begin.setter
    def on_edit_paste_actors_begin(self, value: OnEditPasteActorsBegin) -> None:
        ...
    @property
    def on_edit_paste_actors_end(self) -> OnEditPasteActorsEnd:
        r"""
        (OnEditPasteActorsEnd):  [Read-Write]
        """
        ...
    @on_edit_paste_actors_end.setter
    def on_edit_paste_actors_end(self, value: OnEditPasteActorsEnd) -> None:
        ...
    @property
    def on_duplicate_actors_begin(self) -> OnEditCutActorsBegin:
        r"""
        (OnEditCutActorsBegin):  [Read-Write]
        """
        ...
    @on_duplicate_actors_begin.setter
    def on_duplicate_actors_begin(self, value: OnEditCutActorsBegin) -> None:
        ...
    @property
    def on_duplicate_actors_end(self) -> OnDuplicateActorsEnd:
        r"""
        (OnDuplicateActorsEnd):  [Read-Write]
        """
        ...
    @on_duplicate_actors_end.setter
    def on_duplicate_actors_end(self, value: OnDuplicateActorsEnd) -> None:
        ...
    @property
    def on_delete_actors_begin(self) -> OnDeleteActorsBegin:
        r"""
        (OnDeleteActorsBegin):  [Read-Write]
        """
        ...
    @on_delete_actors_begin.setter
    def on_delete_actors_begin(self, value: OnDeleteActorsBegin) -> None:
        ...
    @property
    def on_delete_actors_end(self) -> OnDeleteActorsEnd:
        r"""
        (OnDeleteActorsEnd):  [Read-Write]
        """
        ...
    @on_delete_actors_end.setter
    def on_delete_actors_end(self, value: OnDeleteActorsEnd) -> None:
        ...
    def spawn_actor_from_object(self, object_to_use: Object, location: Vector, rotation: Rotator = [0.000000, 0.000000, 0.000000], transient: bool = False) -> Actor:
        r"""
        x.spawn_actor_from_object(object_to_use, location, rotation=[0.000000, 0.000000, 0.000000], transient=False) -> Actor
        Create an actor and place it in the world editor. The Actor can be created from a Factory, Archetype, Blueprint, Class or an Asset.
        The actor will be created in the current level and will be selected.
        
        Args:
            object_to_use (Object): Asset to attempt to use for an actor to place.
            location (Vector): Location of the new actor.
            rotation (Rotator): 
            transient (bool): 
        
        Returns:
            Actor: The created actor.
        """
        ...
    def spawn_actor_from_class(self, actor_class: Class, location: Vector, rotation: Rotator = [0.000000, 0.000000, 0.000000], transient: bool = False) -> Actor:
        r"""
        x.spawn_actor_from_class(actor_class, location, rotation=[0.000000, 0.000000, 0.000000], transient=False) -> Actor
        Create an actor and place it in the world editor. Can be created from a Blueprint or a Class.
        The actor will be created in the current level and will be selected.
        
        Args:
            actor_class (type(Class)): Asset to attempt to use for an actor to place.
            location (Vector): Location of the new actor.
            rotation (Rotator): 
            transient (bool): 
        
        Returns:
            Actor: The created actor.
        """
        ...
    def set_selected_level_actors(self, actors_to_select: Array[Actor]) -> None:
        r"""
        x.set_selected_level_actors(actors_to_select) -> None
        Clear the current world editor selection and select the provided actors. Exclude actor that are pending kill, in PIE, PreviewEditor, ...
        
        Args:
            actors_to_select (Array[Actor]): Actor that should be selected in the world editor.
        """
        ...
    def set_component_transform(self, scene_component: SceneComponent, world_transform: Transform) -> bool:
        r"""
        x.set_component_transform(scene_component, world_transform) -> bool
        Sets the world transform of the given component, if possible.
        
        Args:
            scene_component (SceneComponent): 
            world_transform (Transform): 
        
        Returns:
            bool: false if the world transform could not be set.
        """
        ...
    def set_actor_transform(self, actor: Actor, world_transform: Transform) -> bool:
        r"""
        x.set_actor_transform(actor, world_transform) -> bool
        Sets the world transform of the given actor, if possible.
        
        Args:
            actor (Actor): 
            world_transform (Transform): 
        
        Returns:
            bool: false if the world transform could not be set.
        """
        ...
    def set_actor_selection_state(self, actor: Actor, should_be_selected: bool) -> None:
        r"""
        x.set_actor_selection_state(actor, should_be_selected) -> None
        Set the selection state for the selected actor
        
        Args:
            actor (Actor): 
            should_be_selected (bool):
        """
        ...
    def select_nothing(self) -> None:
        r"""
        x.select_nothing() -> None
        Selects nothing in the editor (another way to clear the selection)
        """
        ...
    def select_all_children(self, recurse_children: bool) -> None:
        r"""
        x.select_all_children(recurse_children) -> None
        Select all children actors of the current selection.
        
        Args:
            recurse_children (bool): True to recurse through all descendants of the children
        """
        ...
    def select_all(self, world: World) -> None:
        r"""
        x.select_all(world) -> None
        Select all actors and BSP models in the given world, except those which are hidden
        
        Args:
            world (World): The world the actors are to be selected in.
        """
        ...
    def invert_selection(self, world: World) -> None:
        r"""
        x.invert_selection(world) -> None
        Invert the selection in the given world
        
        Args:
            world (World): The world the selection is in.
        """
        ...
    def get_selected_level_actors(self) -> Array[Actor]:
        r"""
        x.get_selected_level_actors() -> Array[Actor]
        Find all loaded Actors that are selected in the world editor. Exclude actor that are pending kill, in PIE, PreviewEditor, ...
        
        Returns:
            Array[Actor]: List of found Actors
        """
        ...
    def get_all_level_actors_components(self) -> Array[ActorComponent]:
        r"""
        x.get_all_level_actors_components() -> Array[ActorComponent]
        Find all loaded ActorComponent own by an actor in the world editor. Exclude actor that are pending kill, in PIE, PreviewEditor, ...
        
        Returns:
            Array[ActorComponent]: List of found ActorComponent
        """
        ...
    def get_all_level_actors(self) -> Array[Actor]:
        r"""
        x.get_all_level_actors() -> Array[Actor]
        Find all loaded Actors in the world editor. Exclude actor that are pending kill, in PIE, PreviewEditor, ...
        
        Returns:
            Array[Actor]: List of found Actors
        """
        ...
    def get_actor_reference(self, path_to_actor: str) -> Actor:
        r"""
        x.get_actor_reference(path_to_actor) -> Actor
        Attempts to find the actor specified by PathToActor in the current editor world
        
        Args:
            path_to_actor (str): The path to the actor (e.g. PersistentLevel.PlayerStart)
        
        Returns:
            Actor: A reference to the actor, or none if it wasn't found
        """
        ...
    def duplicate_selected_actors(self, world: World) -> None:
        r"""
        x.duplicate_selected_actors(world) -> None
        Duplicate all the selected actors in the given world
        
        Args:
            world (World): The world the actors are selected in.
        """
        ...
    def duplicate_actors(self, actors_to_duplicate: Array[Actor], to_world: World = None, offset: Vector = [0.000000, 0.000000, 0.000000]) -> Array[Actor]:
        r"""
        x.duplicate_actors(actors_to_duplicate, to_world=None, offset=[0.000000, 0.000000, 0.000000]) -> Array[Actor]
        Duplicate actors from the world editor.
        
        Args:
            actors_to_duplicate (Array[Actor]): Actors to duplicate.
            to_world (World): World to place the duplicated actors in. *
            offset (Vector): Translation to offset duplicated actors by.
        
        Returns:
            Array[Actor]: The duplicated actors, or empty if it didn't succeed
        """
        ...
    def duplicate_actor(self, actor_to_duplicate: Actor, to_world: World = None, offset: Vector = [0.000000, 0.000000, 0.000000]) -> Actor:
        r"""
        x.duplicate_actor(actor_to_duplicate, to_world=None, offset=[0.000000, 0.000000, 0.000000]) -> Actor
        Duplicate an actor from the world editor.
        
        Args:
            actor_to_duplicate (Actor): Actor to duplicate.
            to_world (World): World to place the duplicated actor in.
            offset (Vector): Translation to offset duplicated actor by.
        
        Returns:
            Actor: The duplicated actor, or none if it didn't succeed
        """
        ...
    def destroy_actors(self, actors_to_destroy: Array[Actor]) -> bool:
        r"""
        x.destroy_actors(actors_to_destroy) -> bool
        Destroy the actors from the world editor. Notify the Editor that the actor got destroyed.
        
        Args:
            actors_to_destroy (Array[Actor]): Actors to destroy.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def destroy_actor(self, actor_to_destroy: Actor) -> bool:
        r"""
        x.destroy_actor(actor_to_destroy) -> bool
        Destroy the actor from the world editor. Notify the Editor that the actor got destroyed.
        
        Args:
            actor_to_destroy (Actor): Actor to destroy.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def delete_selected_actors(self, world: World) -> None:
        r"""
        x.delete_selected_actors(world) -> None
        Delete all the selected actors in the given world
        
        Args:
            world (World): The world the actors are selected in.
        """
        ...
    def convert_actors(self, actors: Array[Actor], actor_class: Class, static_mesh_package_path: str) -> Array[Actor]:
        r"""
        x.convert_actors(actors, actor_class, static_mesh_package_path) -> Array[Actor]
        Replace in the level all Actors provided with a new actor of type ActorClass. Destroy all Actors provided.
        
        Args:
            actors (Array[Actor]): List of Actors to replace.
            actor_class (type(Class)): Class/Blueprint of the new actor that will be spawn.
            static_mesh_package_path (str): If the list contains Brushes and it is requested to change them to StaticMesh, StaticMeshPackagePath is the package path to where the StaticMesh will be created. ie. /Game/MyFolder/
        
        Returns:
            Array[Actor]:
        """
        ...
    def clear_actor_selection_set(self) -> None:
        r"""
        x.clear_actor_selection_set() -> None
        Remove all actors from the selection set
        """
        ...

class EditorAnimBaseObj(Object):
    r"""
    Editor Anim Base Obj
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorAnimBaseObj.h
    
    """
    ...

class EditorAnimCompositeSegment(EditorAnimBaseObj):
    r"""
    Editor Anim Composite Segment
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorAnimCompositeSegment.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_segment`` (AnimSegment):  [Read-Write] Default blend in time.
    """
    ...

class EditorAnimSegment(EditorAnimBaseObj):
    r"""
    Editor Anim Segment
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorAnimSegment.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_segment`` (AnimSegment):  [Read-Write] Default blend in time.
    """
    ...

class EditorAssetSubsystem(EditorSubsystem):
    r"""
    UEditorAssetSubsystem
    Subsystem for exposing asset related utilities to scripts.
    Asset Paths can be represented in the following ways:
                 (Reference/Text Path)   StaticMesh'/Game/MyFolder/MyAsset.MyAsset'
                 (Full Name)                             StaticMesh /Game/MyFolder/MyAsset.MyAsset
                 (Path Name)                             /Game/MyFolder/MyAsset.MyAsset
                 (Package Name)                  /Game/MyFolder/MyAsset
    Directory Paths can be represented in the following ways:
                 /Game/MyNewFolder/
                 /Game/MyNewFolder
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorAssetSubsystem.h
    
    """
    def set_metadata_tag(self, object: Object, tag: Name, value: str) -> None:
        r"""
        x.set_metadata_tag(object, tag, value) -> None
        Set the value associated with a given tag of a loaded asset's metadata.
        
        Args:
            object (Object): The object from which to retrieve the metadata.
            tag (Name): The tag to set in the metadata.
            value (str): The string value to associate with the tag.
        """
        ...
    def save_loaded_assets(self, assets_to_save: Array[Object], only_if_is_dirty: bool = True) -> bool:
        r"""
        x.save_loaded_assets(assets_to_save, only_if_is_dirty=True) -> bool
        Save the packages the assets live in. All objects that live in the packages will be saved. Will try to checkout the files.
        
        Args:
            assets_to_save (Array[Object]): Assets that we want to save.
            only_if_is_dirty (bool): Only checkout asset that are dirty.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def save_loaded_asset(self, asset_to_save: Object, only_if_is_dirty: bool = True) -> bool:
        r"""
        x.save_loaded_asset(asset_to_save, only_if_is_dirty=True) -> bool
        Save the package the asset lives in. All objects that live in the package will be saved. Will try to checkout the file.
        
        Args:
            asset_to_save (Object): Asset that we want to save.
            only_if_is_dirty (bool): Only checkout asset that are dirty.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def save_directory(self, directory_path: str, only_if_is_dirty: bool = True, recursive: bool = True) -> bool:
        r"""
        x.save_directory(directory_path, only_if_is_dirty=True, recursive=True) -> bool
        Save the packages the assets live in inside the directory. All objects that are in the directory will be saved.
        Will try to checkout the file first. Assets will be loaded before being saved.
        
        Args:
            directory_path (str): Directory that will be checked out and saved.
            only_if_is_dirty (bool): Only checkout asset that are dirty.
            recursive (bool): The search will be recursive and it will save the asset in the sub folders.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def save_asset(self, asset_to_save: str, only_if_is_dirty: bool = True) -> bool:
        r"""
        x.save_asset(asset_to_save, only_if_is_dirty=True) -> bool
        Save the packages the assets live in. All objects that live in the package will be saved.
        Will try to checkout the file first. The Asset will be loaded before being saved.
        
        Args:
            asset_to_save (str): Asset Path of the asset that we want to save.
            only_if_is_dirty (bool): Only checkout/save the asset if it's dirty.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def rename_loaded_asset(self, source_asset: Object, destination_asset_path: str) -> bool:
        r"""
        x.rename_loaded_asset(source_asset, destination_asset_path) -> bool
        Rename an asset that is already loaded. Equivalent to a Move operation.
        Will try to checkout the file.
        
        Args:
            source_asset (Object): Asset that we want to copy from.
            destination_asset_path (str): Asset Path of the duplicated asset.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def rename_directory(self, source_directory_path: str, destination_directory_path: str) -> bool:
        r"""
        x.rename_directory(source_directory_path, destination_directory_path) -> bool
        Rename a directory. Equivalent to a Move operation moving all contained assets.
        Will try to checkout the files. The Assets will be loaded before being renamed.
        
        Args:
            source_directory_path (str): Directory of the assets that we want to rename from.
            destination_directory_path (str): Directory of the renamed asset.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def rename_asset(self, source_asset_path: str, destination_asset_path: str) -> bool:
        r"""
        x.rename_asset(source_asset_path, destination_asset_path) -> bool
        Rename an asset. Equivalent to a Move operation.
        Will try to checkout the file. The Asset will be loaded before being renamed.
        
        Args:
            source_asset_path (str): Asset Path of the asset that we want to copy from.
            destination_asset_path (str): Asset Path of the renamed asset.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def remove_on_extract_asset_from_file(self, delegate: OnExtractAssetFromFileDynamic) -> None:
        r"""
        x.remove_on_extract_asset_from_file(delegate) -> None
        Call this to remove a callback added with AddOnExtractAssetFromFile.
        
        Args:
            delegate (OnExtractAssetFromFileDynamic):
        """
        ...
    def remove_metadata_tag(self, object: Object, tag: Name) -> None:
        r"""
        x.remove_metadata_tag(object, tag) -> None
        Remove the given tag from a loaded asset's metadata.
        
        Args:
            object (Object): The object from which to retrieve the metadata.
            tag (Name): The tag to remove from the metadata.
        """
        ...
    def make_directory(self, directory_path: str) -> bool:
        r"""
        x.make_directory(directory_path) -> bool
        Create a directory on disk.
        
        Args:
            directory_path (str): Long Path Name of the directory.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def load_blueprint_class(self, asset_path: str) -> Class:
        r"""
        x.load_blueprint_class(asset_path) -> type(Class)
        Load a Blueprint asset and return its generated class. It will verify if the object is already loaded and only load it if it's necessary.
        
        Args:
            asset_path (str): Asset Path of the Blueprint asset.
        
        Returns:
            type(Class): Found or loaded class.
        """
        ...
    def load_asset(self, asset_path: str) -> Object:
        r"""
        x.load_asset(asset_path) -> Object
        Load an asset. It will verify if the object is already loaded and only load it if it's necessary.
        
        Args:
            asset_path (str): Asset Path of the asset to load
        
        Returns:
            Object: Found or loaded asset.
        """
        ...
    def list_assets_by_tag_value(self, tag_name: Name, tag_value: str) -> Array[str]:
        r"""
        x.list_assets_by_tag_value(tag_name, tag_value) -> Array[str]
        Return the list of all the assets that have the pair of Tag/Value.
        
        Args:
            tag_name (Name): The tag associated with the assets requested.
            tag_value (str): The value associated with the assets requested.
        
        Returns:
            Array[str]: The list of assets found.
        """
        ...
    def list_assets(self, directory_path: str, recursive: bool = True, include_folder: bool = False) -> Array[str]:
        r"""
        x.list_assets(directory_path, recursive=True, include_folder=False) -> Array[str]
        Return the list of all the assets found in the DirectoryPath.
        
        Args:
            directory_path (str): Directory path of the asset we want the list from.
            recursive (bool): The search will be recursive and will look in sub folders.
            include_folder (bool): The result will include folders name.
        
        Returns:
            Array[str]: The list of assets found.
        """
        ...
    def get_tag_values(self, asset_path: str) -> Map[Name, str]:
        r"""
        x.get_tag_values(asset_path) -> Map[Name, str]
        Gets all TagValues (from Asset Registry) associated with an (unloaded) asset as strings value.
        
        Args:
            asset_path (str): Asset Path we are trying to find.
        
        Returns:
            Map[Name, str]: The list of all TagNames & TagValues.
        """
        ...
    def get_path_name_for_loaded_asset(self, loaded_asset: Object) -> str:
        r"""
        x.get_path_name_for_loaded_asset(loaded_asset) -> str
        Return a valid AssetPath for a loaded asset.
        Similar to GetPathName(). The format will be: /Game/MyFolder/MyAsset.MyAsset
        
        Args:
            loaded_asset (Object): The loaded asset to get the path of.
        
        Returns:
            str: If valid, the asset Path of the loaded asset.
        """
        ...
    def get_metadata_tag_values(self, object: Object) -> Map[Name, str]:
        r"""
        x.get_metadata_tag_values(object) -> Map[Name, str]
        Get all tags/values of a loaded asset's metadata.
        
        Args:
            object (Object): The object from which to retrieve the metadata.
        
        Returns:
            Map[Name, str]: The list of all Tags and Values.
        """
        ...
    def get_metadata_tag(self, object: Object, tag: Name) -> str:
        r"""
        x.get_metadata_tag(object, tag) -> str
        Get the value associated with the given tag of a loaded asset's metadata.
        
        Args:
            object (Object): The object from which to retrieve the metadata.
            tag (Name): The tag to find in the metadata.
        
        Returns:
            str: The string value associated with the tag.
        """
        ...
    def find_package_referencers_for_asset(self, asset_path: str, load_assets_to_confirm: bool = False) -> Array[str]:
        r"""
        x.find_package_referencers_for_asset(asset_path, load_assets_to_confirm=False) -> Array[str]
        Find Package Referencers for an asset. Only Soft and Hard dependencies will be looked for.
        Soft are dependencies which don't need to be loaded for the object to be used.
        Hard are dependencies which are required for correct usage of the source asset and must be loaded at the same time.
        Other references may exist. The asset may be currently used in memory by another asset, by the editor or by code.
        Package dependencies are cached with the asset. False positives can happen until all the assets are loaded and re-saved.
        
        Args:
            asset_path (str): Asset Path of the asset that we are looking for.
            load_assets_to_confirm (bool): Whether the asset and any potential referencers will be loaded to confirm the dependencies.
        
        Returns:
            Array[str]: The package paths of the referencers.
        """
        ...
    def find_asset_data(self, asset_path: str) -> AssetData:
        r"""
        x.find_asset_data(asset_path) -> AssetData
        Return the AssetData for the Asset that can then be used with AssetRegistryHelpers.
        
        Args:
            asset_path (str): Asset Path to retrieve data from.
        
        Returns:
            AssetData: The AssetData found.
        """
        ...
    def duplicate_loaded_asset(self, source_asset: Object, destination_asset_path: str) -> Object:
        r"""
        x.duplicate_loaded_asset(source_asset, destination_asset_path) -> Object
        Duplicate an asset that is already loaded. Will try to checkout the file.
        
        Args:
            source_asset (Object): Asset that we want to copy from.
            destination_asset_path (str): Asset Path of the duplicated asset.
        
        Returns:
            Object: The duplicated object if the operation succeeds
        """
        ...
    def duplicate_directory(self, source_directory_path: str, destination_directory_path: str) -> bool:
        r"""
        x.duplicate_directory(source_directory_path, destination_directory_path) -> bool
        Duplicate a directory and the assets in it.
        Will try to checkout the files. The Assets will be loaded before being duplicated.
        
        Args:
            source_directory_path (str): Directory of the assets that we want to duplicate from.
            destination_directory_path (str): Directory of the duplicated asset.
        
        Returns:
            bool: The duplicated object if the operation succeeds.
        """
        ...
    def duplicate_asset(self, source_asset_path: str, destination_asset_path: str) -> Object:
        r"""
        x.duplicate_asset(source_asset_path, destination_asset_path) -> Object
        Duplicate an asset. Will try to checkout the file. The Asset will be loaded before being duplicated.
        
        Args:
            source_asset_path (str): Asset Path of the asset that we want to copy from.
            destination_asset_path (str): Asset Path of the duplicated asset.
        
        Returns:
            Object: The duplicated object if the operation succeeds.
        """
        ...
    def does_directory_exist(self, directory_path: str) -> bool:
        r"""
        x.does_directory_exist(directory_path) -> bool
        Check if a directory exists.
        
        Args:
            directory_path (str): Long Path Name of the directory.
        
        Returns:
            bool: True if it does exist and it is valid.
        """
        ...
    def does_directory_contain_assets(self, directory_path: str, recursive: bool = True) -> bool:
        r"""
        x.does_directory_contain_assets(directory_path, recursive=True) -> bool
        Check if a directory contains any assets.
        
        Args:
            directory_path (str): Long Path Name of the directory.
            recursive (bool): 
        
        Returns:
            bool: True if there is any assets.
        """
        ...
    def does_asset_exist(self, asset_path: str) -> bool:
        r"""
        x.does_asset_exist(asset_path) -> bool
        Check if an asset exists in the Asset Registry.
        
        Args:
            asset_path (str): Asset Path to check for existence.
        
        Returns:
            bool: True if the asset exists and is valid.
        """
        ...
    def do_assets_exist(self, asset_paths: Array[str]) -> bool:
        r"""
        x.do_assets_exist(asset_paths) -> bool
        Check if assets exist in the Asset Registry.
        
        Args:
            asset_paths (Array[str]): Asset Paths of the assets to check for existence.
        
        Returns:
            bool: True if all assets exist and are valid.
        """
        ...
    def delete_loaded_assets(self, assets_to_delete: Array[Object]) -> bool:
        r"""
        x.delete_loaded_assets(assets_to_delete) -> bool
        Delete assets that are already loaded.
        This is a Force Delete. It does not check if the assets have references in other Levels or by Actors.
        It will close all the asset editors and may clear the Transaction buffer (Undo History).
        Will try to mark the files as deleted.
        
        Args:
            assets_to_delete (Array[Object]): Loaded assets to delete.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def delete_loaded_asset(self, asset_to_delete: Object) -> bool:
        r"""
        x.delete_loaded_asset(asset_to_delete) -> bool
        Delete an asset that is already loaded.
        This is a Force Delete. It does not check if the asset has references in other Levels or by Actors.
        It will close all the asset editors and may clear the Transaction buffer (Undo History).
        Will try to mark the file as deleted.
        
        Args:
            asset_to_delete (Object): Asset to delete.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def delete_directory(self, directory_path: str) -> bool:
        r"""
        x.delete_directory(directory_path) -> bool
        Delete the packages inside a directory. If the directory is then empty, delete the directory.
        This is a Force Delete. It does not check if the assets have references in other Levels or by Actors.
        It will close all the asset editors and may clear the Transaction buffer (Undo History).
        Will try to mark the file as deleted. Assets will be loaded before being deleted.
        The search is always recursive. It will try to delete the sub folders.
        
        Args:
            directory_path (str): Directory that will be marked for deletion and deleted.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def delete_asset(self, asset_path_to_delete: str) -> bool:
        r"""
        x.delete_asset(asset_path_to_delete) -> bool
        Delete the package an asset is in. All objects in the package will be deleted.
        This is a Force Delete. It does not check if the asset has references in other Levels or by Actors.
        It will close all the asset editors and may clear the Transaction buffer (Undo History).
        Will try to mark the file as deleted. The Asset will be loaded before being deleted.
        
        Args:
            asset_path_to_delete (str): Asset Path of the asset to delete.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def consolidate_assets(self, asset_to_consolidate_to: Object, assets_to_consolidate: Array[Object]) -> bool:
        r"""
        x.consolidate_assets(asset_to_consolidate_to, assets_to_consolidate) -> bool
        Consolidates assets by replacing all references/uses of the provided AssetsToConsolidate with references to AssetToConsolidateTo.
        This is useful when you want all references of assets to be replaced by a single asset.
        The function first attempts to directly replace all relevant references located within objects that are already loaded and in memory.
        Next, it deletes the AssetsToConsolidate, leaving behind object redirectors to AssetToConsolidateTo.
        note: The AssetsToConsolidate are DELETED by this function.
        note: Modified objects will be saved if the operation succeeds.
        
        Args:
            asset_to_consolidate_to (Object): Asset to which all references of the AssetsToConsolidate will instead refer to after this operation completes.
            assets_to_consolidate (Array[Object]): All references to these assets will be modified to reference AssetToConsolidateTo instead.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def checkout_loaded_assets(self, assets_to_checkout: Array[Object]) -> bool:
        r"""
        x.checkout_loaded_assets(assets_to_checkout) -> bool
        Checkout the assets.
        
        Args:
            assets_to_checkout (Array[Object]): Assets to checkout.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def checkout_loaded_asset(self, asset_to_checkout: Object) -> bool:
        r"""
        x.checkout_loaded_asset(asset_to_checkout) -> bool
        Checkout the asset corresponding to an object.
        
        Args:
            asset_to_checkout (Object): Asset to checkout.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def checkout_directory(self, directory_path: str, recursive: bool = True) -> bool:
        r"""
        x.checkout_directory(directory_path, recursive=True) -> bool
        Checkout all assets in a directory. It will load the assets if needed.
        All objects that are in the directory will be checked out. Assets will be loaded before being checked out.
        
        Args:
            directory_path (str): Directory of the assets to be checked out.
            recursive (bool): If the AssetPath is a folder, the search will be recursive and will checkout the assets in the sub folders.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def checkout_asset(self, asset_to_checkout: str) -> bool:
        r"""
        x.checkout_asset(asset_to_checkout) -> bool
        Checkout an asset.
        
        Args:
            asset_to_checkout (str): Asset Path of the asset that we want to checkout.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    def add_on_extract_asset_from_file(self, delegate: OnExtractAssetFromFileDynamic) -> None:
        r"""
        x.add_on_extract_asset_from_file(delegate) -> None
        Call this to add a callback to extract an asset from a file,
        for example from a drag and drop operation.
        
        Args:
            delegate (OnExtractAssetFromFileDynamic):
        """
        ...

class EditorCompositeSection(EditorAnimBaseObj):
    r"""
    Editor Composite Section
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorCompositeSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``composite_section`` (CompositeSection):  [Read-Write] Default blend in time.
    """
    ...

class EditorLevelUtils(Object):
    r"""
    Editor Level Utils
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorLevelUtils.h
    
    """
    @classmethod
    def set_level_visibility(cls, level: Level, should_be_visible: bool, force_layers_visible: bool, modify_mode: LevelVisibilityDirtyMode = LevelVisibilityDirtyMode.MODIFY_ON_CHANGE) -> None:
        r"""
        X.set_level_visibility(level, should_be_visible, force_layers_visible, modify_mode=LevelVisibilityDirtyMode.MODIFY_ON_CHANGE) -> None
        Sets a level's visibility in the editor. Less efficient than SetLevelsVisibility when changing the visibility of multiple levels simultaneously.
        
        Args:
            level (Level): The level to modify.
            should_be_visible (bool): The level's new visibility state.
            force_layers_visible (bool): If true and the level is visible, force the level's layers to be visible.
            modify_mode (LevelVisibilityDirtyMode): ELevelVisibilityDirtyMode mode value.
        """
        ...
    @classmethod
    def set_levels_visibility(cls, levels: Array[Level], should_be_visible: Array[bool], force_layers_visible: bool, modify_mode: LevelVisibilityDirtyMode = LevelVisibilityDirtyMode.MODIFY_ON_CHANGE) -> None:
        r"""
        X.set_levels_visibility(levels, should_be_visible, force_layers_visible, modify_mode=LevelVisibilityDirtyMode.MODIFY_ON_CHANGE) -> None
        Sets a level's visibility in the editor. More efficient than SetLevelsVisibility when changing the visibility of multiple levels simultaneously.
        
        Args:
            levels (Array[Level]): The levels to modify.
            should_be_visible (Array[bool]): The level's new visibility state for each level.
            force_layers_visible (bool): If true and the level is visible, force the level's layers to be visible.
            modify_mode (LevelVisibilityDirtyMode): ELevelVisibilityDirtyMode mode value.
        """
        ...
    @classmethod
    def move_selected_actors_to_level(cls, dest_level: LevelStreaming, warn_about_references: bool = True) -> int:
        r"""
        X.move_selected_actors_to_level(dest_level, warn_about_references=True) -> int32
        Moves the currently selected actors to the specified streaming level. The new actors will be selected
        
        Args:
            dest_level (LevelStreaming): 
            warn_about_references (bool): Whether or not to show a modal warning about referenced actors that may no longer function after being moved
        
        Returns:
            int32: The number of actors that were successfully moved to the new level
        """
        ...
    @classmethod
    def move_actors_to_level(cls, actors_to_move: Array[Actor], dest_streaming_level: LevelStreaming, warn_about_references: bool = True, warn_about_renaming: bool = True) -> int:
        r"""
        X.move_actors_to_level(actors_to_move, dest_streaming_level, warn_about_references=True, warn_about_renaming=True) -> int32
        Moves the specified list of actors to the specified streaming level. The new actors will be selected
        
        Args:
            actors_to_move (Array[Actor]): List of actors to move
            dest_streaming_level (LevelStreaming): The destination streaming level of the current world to move the actors to
            warn_about_references (bool): Whether or not to show a modal warning about referenced actors that may no longer function after being moved
            warn_about_renaming (bool): 
        
        Returns:
            int32: The number of actors that were successfully moved to the new level
        """
        ...
    @classmethod
    def make_level_current(cls, streaming_level: LevelStreaming) -> None:
        r"""
        X.make_level_current(streaming_level) -> None
        Makes the specified streaming level the current level for editing.
        The current level is where actors are spawned to when calling SpawnActor
        
        Args:
            streaming_level (LevelStreaming):
        """
        ...
    @classmethod
    def remove_level_from_world(cls, level: Level, clear_selection: bool = True, reset_transaction_buffer: bool = True) -> bool:
        r"""
        X.remove_level_from_world(level, clear_selection=True, reset_transaction_buffer=True) -> bool
        Removes given level from the world. Note, this will only work for sub-levels in the main level.
        
        Args:
            level (Level): Level asset to remove from the world.
            clear_selection (bool): If true, it will clear the editor selection.
            reset_transaction_buffer (bool): If true, it will reset the transaction buffer (i.e. clear undo history)
        
        Returns:
            bool: True if the level was successfully removed.
        """
        ...
    @classmethod
    def add_level_to_world_with_transform(cls, world: World, level_package_name: str, level_streaming_class: Class, level_transform: Transform) -> LevelStreaming:
        r"""
        X.add_level_to_world_with_transform(world, level_package_name, level_streaming_class, level_transform) -> LevelStreaming
        Adds the named level package to the world at the given position.  Does nothing if the level already exists in the world.
        
        Args:
            world (World): 
            level_package_name (str): The package name ("e.g /Game/MyLevel") of the level package to add.
            level_streaming_class (type(Class)): The streaming class type to use for the level.
            level_transform (Transform): The origin of the new level in the world.
        
        Returns:
            LevelStreaming: The new level, or NULL if the level couldn't added.
        """
        ...
    @classmethod
    def add_level_to_world(cls, world: World, level_package_name: str, level_streaming_class: Class) -> LevelStreaming:
        r"""
        X.add_level_to_world(world, level_package_name, level_streaming_class) -> LevelStreaming
        Adds the named level package to the world.  Does nothing if the level already exists in the world.
        
        Args:
            world (World): 
            level_package_name (str): The package name ("e.g /Game/MyLevel") of the level package to add.
            level_streaming_class (type(Class)): The streaming class type to use for the level.
        
        Returns:
            LevelStreaming: The new level, or NULL if the level couldn't added.
        """
        ...
    @classmethod
    def get_levels(cls, world: World) -> Array[Level]:
        r"""
        X.get_levels(world) -> Array[Level]
        Returns all levels for a world.
        
        Args:
            world (World): World containing levels
        
        Returns:
            Array[Level]: Set of all levels
        """
        ...
    @classmethod
    def create_new_streaming_level(cls, level_streaming_class: Class, new_level_path: str = "", move_selected_actors_into_new_level: bool = False) -> LevelStreaming:
        r"""
        X.create_new_streaming_level(level_streaming_class, new_level_path="", move_selected_actors_into_new_level=False) -> LevelStreaming
        Creates a new streaming level in the current world
        
        Args:
            level_streaming_class (type(Class)): The streaming class type instead to use for the level.
            new_level_path (str): Optional path to the level package path format ("e.g /Game/MyLevel").  If empty, the user will be prompted during the save process.
            move_selected_actors_into_new_level (bool): If true, move any selected actors into the new level.
        
        Returns:
            LevelStreaming: Returns the newly created level, or NULL on failure
        """
        ...

class EnumFactory(Factory):
    r"""
    Enum Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EnumFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class FbxAssetImportData(AssetImportData):
    r"""
    Base class for import data and options used when importing any asset from FBX
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``convert_scene`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system
    - ``convert_scene_unit`` (bool):  [Read-Write] Convert the scene from FBX unit to UE unit (centimeter).
    - ``force_front_x_axis`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system with front X axis instead of -Y
    - ``import_rotation`` (Rotator):  [Read-Write]
    - ``import_translation`` (Vector):  [Read-Write]
    - ``import_uniform_scale`` (float):  [Read-Write]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    @property
    def import_translation(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @import_translation.setter
    def import_translation(self, value: Vector) -> None:
        ...
    @property
    def import_rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @import_rotation.setter
    def import_rotation(self, value: Rotator) -> None:
        ...
    @property
    def import_uniform_scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @import_uniform_scale.setter
    def import_uniform_scale(self, value: float) -> None:
        ...
    @property
    def convert_scene(self) -> bool:
        r"""
        (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system
        """
        ...
    @convert_scene.setter
    def convert_scene(self, value: bool) -> None:
        ...
    @property
    def force_front_x_axis(self) -> bool:
        r"""
        (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system with front X axis instead of -Y
        """
        ...
    @force_front_x_axis.setter
    def force_front_x_axis(self, value: bool) -> None:
        ...
    @property
    def convert_scene_unit(self) -> bool:
        r"""
        (bool):  [Read-Write] Convert the scene from FBX unit to UE unit (centimeter).
        """
        ...
    @convert_scene_unit.setter
    def convert_scene_unit(self, value: bool) -> None:
        ...

class FbxAnimSequenceImportData(FbxAssetImportData):
    r"""
    Import data and options used when importing any mesh from FBX
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxAnimSequenceImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``add_curve_metadata_to_skeleton`` (bool):  [Read-Write] Whether to automatically add curve metadata to an animation's skeleton. If this is disabled, curve metadata will be added to skeletal meshes for morph targets, but no metadata entry will be created for general curves.
    - ``animation_length`` (FBXAnimationLengthImportType):  [Read-Write] Which animation range to import. The one defined at Exported, at Animated time or define a range manually
    - ``convert_scene`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system
    - ``convert_scene_unit`` (bool):  [Read-Write] Convert the scene from FBX unit to UE unit (centimeter).
    - ``custom_sample_rate`` (int32):  [Read-Write] Sample fbx animation data at the specified sample rate, 0 find automaticaly the best sample rate
    - ``delete_existing_custom_attribute_curves`` (bool):  [Read-Write] If true, all previous node attributes imported as Animation Curves will be deleted when doing a re-import.
    - ``delete_existing_morph_target_curves`` (bool):  [Read-Write] If enabled, this will delete this type of asset from the FBX
    - ``delete_existing_non_curve_custom_attributes`` (bool):  [Read-Write] If true, all previous node attributes imported as Animation Attributes will be deleted when doing a re-import.
    - ``do_not_import_curve_with_zero`` (bool):  [Read-Write] When importing custom attribute or morphtarget as curve, do not import if it doesn't have any value other than zero. This is to avoid adding extra curves to evaluate
    - ``force_front_x_axis`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system with front X axis instead of -Y
    - ``frame_import_range`` (Int32Interval):  [Read-Write] Frame range used when Set Range is used in Animation Length
    - ``import_bone_tracks`` (bool):  [Read-Write] Import bone transform tracks. If false, this will discard any bone transform tracks. (useful for curves only animations)
    - ``import_custom_attribute`` (bool):  [Read-Write] If true, import node attributes as either Animation Curves or Animation Attributes
    - ``import_meshes_in_bone_hierarchy`` (bool):  [Read-Write] If checked, meshes nested in bone hierarchies will be imported instead of being converted to bones.
    - ``import_rotation`` (Rotator):  [Read-Write]
    - ``import_translation`` (Vector):  [Read-Write]
    - ``import_uniform_scale`` (float):  [Read-Write]
    - ``material_curve_suffixes`` (Array[str]):  [Read-Write] Set Material Curve Type for the custom attribute with the following suffixes. This doesn't matter if Set Material Curve Type is true
    - ``preserve_local_transform`` (bool):  [Read-Write] If enabled, this will import a curve within the animation
    - ``remove_redundant_keys`` (bool):  [Read-Write] When importing custom attribute as curve, remove redundant keys
    - ``set_material_drive_parameter_on_custom_attribute`` (bool):  [Read-Write] Set Material Curve Type for all custom attributes that exists
    - ``snap_to_closest_frame_boundary`` (bool):  [Read-Write] If enabled, snaps the animation to the closest frame boundary using the import sampling rate
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``use_default_sample_rate`` (bool):  [Read-Write] If enabled, samples all animation curves to 30 FPS
    """
    ...

class FbxExportOption(Object):
    r"""
    Fbx Export Option
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxExportOption.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ascii`` (bool):  [Read-Write] If enabled, save as ascii instead of binary
    - ``bake_actor_animation`` (MovieSceneBakeType):  [Read-Write] Bake settings for exported non-camera, non-light object animation
    - ``bake_camera_and_light_animation`` (MovieSceneBakeType):  [Read-Write] Bake settings for camera and light animation curves. Camera Scale not exported.
    - ``collision`` (bool):  [Read-Write] If enabled, export collision
    - ``export_local_time`` (bool):  [Read-Write] If enabled, export sequencer animation in its local time, relative to its sequence.
    - ``export_morph_targets`` (bool):  [Read-Write] If enabled, export the morph targets
    - ``export_preview_mesh`` (bool):  [Read-Write] If enable, the preview mesh link to the exported animations will be also exported.
    - ``export_source_mesh`` (bool):  [Read-Write] * If enabled, export the highest LOD source data instead of the render data.
      * Note:
      *     - No LOD will be exported for static meshes. (Level Of Detail option will be ignored)
      *     - No Collision will be exported for static meshes. (Collision option will be ignore)
    - ``fbx_export_compatibility`` (FbxExportCompatibility):  [Read-Write] This will set the fbx sdk compatibility when exporting to fbx file. The default value is 2013
    - ``force_front_x_axis`` (bool):  [Read-Write] If enabled, export with X axis as the front axis instead of default -Y
    - ``level_of_detail`` (bool):  [Read-Write] If enabled, export the level of detail
    - ``map_skeletal_motion_to_root`` (bool):  [Read-Write] If enable, Map skeletal actor motion to the root bone of the skeleton.
    - ``vertex_color`` (bool):  [Read-Write] If enabled, export vertex color
    """
    @property
    def fbx_export_compatibility(self) -> FbxExportCompatibility:
        r"""
        (FbxExportCompatibility):  [Read-Write] This will set the fbx sdk compatibility when exporting to fbx file. The default value is 2013
        """
        ...
    @fbx_export_compatibility.setter
    def fbx_export_compatibility(self, value: FbxExportCompatibility) -> None:
        ...
    @property
    def ascii(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, save as ascii instead of binary
        """
        ...
    @ascii.setter
    def ascii(self, value: bool) -> None:
        ...
    @property
    def force_front_x_axis(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export with X axis as the front axis instead of default -Y
        """
        ...
    @force_front_x_axis.setter
    def force_front_x_axis(self, value: bool) -> None:
        ...
    @property
    def vertex_color(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export vertex color
        """
        ...
    @vertex_color.setter
    def vertex_color(self, value: bool) -> None:
        ...
    @property
    def level_of_detail(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export the level of detail
        """
        ...
    @level_of_detail.setter
    def level_of_detail(self, value: bool) -> None:
        ...
    @property
    def collision(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export collision
        """
        ...
    @collision.setter
    def collision(self, value: bool) -> None:
        ...
    @property
    def export_source_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write] * If enabled, export the highest LOD source data instead of the render data.
        * Note:
        *     - No LOD will be exported for static meshes. (Level Of Detail option will be ignored)
        *     - No Collision will be exported for static meshes. (Collision option will be ignore)
        """
        ...
    @export_source_mesh.setter
    def export_source_mesh(self, value: bool) -> None:
        ...
    @property
    def export_morph_targets(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export the morph targets
        """
        ...
    @export_morph_targets.setter
    def export_morph_targets(self, value: bool) -> None:
        ...
    @property
    def export_preview_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write] If enable, the preview mesh link to the exported animations will be also exported.
        """
        ...
    @export_preview_mesh.setter
    def export_preview_mesh(self, value: bool) -> None:
        ...
    @property
    def map_skeletal_motion_to_root(self) -> bool:
        r"""
        (bool):  [Read-Write] If enable, Map skeletal actor motion to the root bone of the skeleton.
        """
        ...
    @map_skeletal_motion_to_root.setter
    def map_skeletal_motion_to_root(self, value: bool) -> None:
        ...
    @property
    def export_local_time(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export sequencer animation in its local time, relative to its sequence.
        """
        ...
    @export_local_time.setter
    def export_local_time(self, value: bool) -> None:
        ...
    @property
    def bake_camera_and_light_animation(self) -> MovieSceneBakeType:
        r"""
        (MovieSceneBakeType):  [Read-Write] Bake settings for camera and light animation curves. Camera Scale not exported.
        """
        ...
    @bake_camera_and_light_animation.setter
    def bake_camera_and_light_animation(self, value: MovieSceneBakeType) -> None:
        ...
    @property
    def bake_actor_animation(self) -> MovieSceneBakeType:
        r"""
        (MovieSceneBakeType):  [Read-Write] Bake settings for exported non-camera, non-light object animation
        """
        ...
    @bake_actor_animation.setter
    def bake_actor_animation(self, value: MovieSceneBakeType) -> None:
        ...

class FbxFactory(Factory):
    r"""
    Fbx Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class FbxImportUI(Object):
    r"""
    Fbx Import UI
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxImportUI.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_end_frame`` (str):  [Read-Only] The fbx animation end frame
    - ``anim_sequence_import_data`` (FbxAnimSequenceImportData):  [Read-Write] Import data used when importing animations
    - ``anim_start_frame`` (str):  [Read-Only] The fbx animation start frame
    - ``auto_compute_lod_distances`` (bool):  [Read-Write] If checked, the editor will automatically compute screen size values for the static mesh's LODs. If unchecked, the user can enter custom screen size values for each LOD.
    - ``automated_import_should_detect_type`` (bool):  [Read-Write] If true the automated import path should detect the import type.  If false the import type was specified by the user
    - ``create_physics_asset`` (bool):  [Read-Write] If checked, create new PhysicsAsset if it doesn't have it
    - ``file_axis_direction`` (str):  [Read-Only] The file axis direction, up vector and hand
    - ``file_creator`` (str):  [Read-Only] The file creator information
    - ``file_creator_application`` (str):  [Read-Only] The file vendor information, software name and version that was use to create the file
    - ``file_sample_rate`` (str):  [Read-Only] The fbx animation frame rate
    - ``file_units`` (str):  [Read-Only] The file units
    - ``file_version`` (str):  [Read-Only] The fbx file version
    - ``import_animations`` (bool):  [Read-Write] True to import animations from the FBX File
    - ``import_as_skeletal`` (bool):  [Read-Write] Whether to import the incoming FBX as a skeletal object
    - ``import_materials`` (bool):  [Read-Write] If no existing materials are found, whether to automatically create Unreal materials for materials found in the FBX scene
    - ``import_mesh`` (bool):  [Read-Write] Whether to import the mesh. Allows animation only import when importing a skeletal mesh.
    - ``import_rigid_mesh`` (bool):  [Read-Write] Enables importing of 'rigid skeletalmesh' (unskinned, hierarchy-based animation) from this FBX file, no longer shown, used behind the scenes
    - ``import_textures`` (bool):  [Read-Write] Whether or not we should import textures. This option is disabled when we are importing materials because textures are always imported in that case.
    - ``is_obj_import`` (bool):  [Read-Write] Whether or not the imported file is in OBJ format
    - ``lod_distance0`` (float):  [Read-Write] Set a screen size value for LOD 0
    - ``lod_distance1`` (float):  [Read-Write] Set a screen size value for LOD 1
    - ``lod_distance2`` (float):  [Read-Write] Set a screen size value for LOD 2
    - ``lod_distance3`` (float):  [Read-Write] Set a screen size value for LOD 3
    - ``lod_distance4`` (float):  [Read-Write] Set a screen size value for LOD 4
    - ``lod_distance5`` (float):  [Read-Write] Set a screen size value for LOD 5
    - ``lod_distance6`` (float):  [Read-Write] Set a screen size value for LOD 6
    - ``lod_distance7`` (float):  [Read-Write] Set a screen size value for LOD 7
    - ``lod_number`` (int32):  [Read-Write] Set the number of LODs for the editor to import. Setting the value to 0 imports the number of LODs found in the file (up to the maximum).
    - ``mesh_type_to_import`` (FBXImportType):  [Read-Write] Type of asset to import from the FBX file
    - ``minimum_lod_number`` (int32):  [Read-Write] Set the minimum LOD used for rendering. Setting the value to 0 will use the default value of LOD0.
    - ``original_import_type`` (FBXImportType):  [Read-Write] The original detected type of this import
    - ``override_animation_name`` (str):  [Read-Write] Override for the name of the animation to import. By default, it will be the name of FBX *
    - ``override_full_name`` (bool):  [Read-Write] Use the string in "Name" field as full name of mesh. The option only works when the scene contains one mesh.
    - ``physics_asset`` (PhysicsAsset):  [Read-Write] If this is set, use this PhysicsAsset. It is possible bCreatePhysicsAsset == false, and PhysicsAsset == NULL. It is possible they do not like to create anything.
    - ``reset_to_fbx_on_material_conflict`` (bool):  [Read-Write] If true, the imported material sections will automatically be reset to the imported data in case of a reimport conflict.
    - ``skeletal_mesh_import_data`` (FbxSkeletalMeshImportData):  [Read-Write] Import data used when importing skeletal meshes
    - ``skeleton`` (Skeleton):  [Read-Write] Skeleton to use for imported asset. When importing a mesh, leaving this as "None" will create a new skeleton. When importing an animation this MUST be specified to import the asset.
    - ``static_mesh_import_data`` (FbxStaticMeshImportData):  [Read-Write] Import data used when importing static meshes
    - ``texture_import_data`` (FbxTextureImportData):  [Read-Write] Import data used when importing textures
    """
    @property
    def is_obj_import(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not the imported file is in OBJ format
        """
        ...
    @is_obj_import.setter
    def is_obj_import(self, value: bool) -> None:
        ...
    @property
    def original_import_type(self) -> FBXImportType:
        r"""
        (FBXImportType):  [Read-Write] The original detected type of this import
        """
        ...
    @original_import_type.setter
    def original_import_type(self, value: FBXImportType) -> None:
        ...
    @property
    def mesh_type_to_import(self) -> FBXImportType:
        r"""
        (FBXImportType):  [Read-Write] Type of asset to import from the FBX file
        """
        ...
    @mesh_type_to_import.setter
    def mesh_type_to_import(self, value: FBXImportType) -> None:
        ...
    @property
    def override_full_name(self) -> bool:
        r"""
        (bool):  [Read-Write] Use the string in "Name" field as full name of mesh. The option only works when the scene contains one mesh.
        """
        ...
    @override_full_name.setter
    def override_full_name(self, value: bool) -> None:
        ...
    @property
    def import_as_skeletal(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to import the incoming FBX as a skeletal object
        """
        ...
    @import_as_skeletal.setter
    def import_as_skeletal(self, value: bool) -> None:
        ...
    @property
    def import_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to import the mesh. Allows animation only import when importing a skeletal mesh.
        """
        ...
    @import_mesh.setter
    def import_mesh(self, value: bool) -> None:
        ...
    @property
    def skeleton(self) -> Skeleton:
        r"""
        (Skeleton):  [Read-Write] Skeleton to use for imported asset. When importing a mesh, leaving this as "None" will create a new skeleton. When importing an animation this MUST be specified to import the asset.
        """
        ...
    @skeleton.setter
    def skeleton(self, value: Skeleton) -> None:
        ...
    @property
    def create_physics_asset(self) -> bool:
        r"""
        (bool):  [Read-Write] If checked, create new PhysicsAsset if it doesn't have it
        """
        ...
    @create_physics_asset.setter
    def create_physics_asset(self, value: bool) -> None:
        ...
    @property
    def physics_asset(self) -> PhysicsAsset:
        r"""
        (PhysicsAsset):  [Read-Write] If this is set, use this PhysicsAsset. It is possible bCreatePhysicsAsset == false, and PhysicsAsset == NULL. It is possible they do not like to create anything.
        """
        ...
    @physics_asset.setter
    def physics_asset(self, value: PhysicsAsset) -> None:
        ...
    @property
    def auto_compute_lod_distances(self) -> bool:
        r"""
        (bool):  [Read-Write] If checked, the editor will automatically compute screen size values for the static mesh's LODs. If unchecked, the user can enter custom screen size values for each LOD.
        """
        ...
    @auto_compute_lod_distances.setter
    def auto_compute_lod_distances(self, value: bool) -> None:
        ...
    @property
    def lod_distance0(self) -> float:
        r"""
        (float):  [Read-Write] Set a screen size value for LOD 0
        """
        ...
    @lod_distance0.setter
    def lod_distance0(self, value: float) -> None:
        ...
    @property
    def lod_distance1(self) -> float:
        r"""
        (float):  [Read-Write] Set a screen size value for LOD 1
        """
        ...
    @lod_distance1.setter
    def lod_distance1(self, value: float) -> None:
        ...
    @property
    def lod_distance2(self) -> float:
        r"""
        (float):  [Read-Write] Set a screen size value for LOD 2
        """
        ...
    @lod_distance2.setter
    def lod_distance2(self, value: float) -> None:
        ...
    @property
    def lod_distance3(self) -> float:
        r"""
        (float):  [Read-Write] Set a screen size value for LOD 3
        """
        ...
    @lod_distance3.setter
    def lod_distance3(self, value: float) -> None:
        ...
    @property
    def lod_distance4(self) -> float:
        r"""
        (float):  [Read-Write] Set a screen size value for LOD 4
        """
        ...
    @lod_distance4.setter
    def lod_distance4(self, value: float) -> None:
        ...
    @property
    def lod_distance5(self) -> float:
        r"""
        (float):  [Read-Write] Set a screen size value for LOD 5
        """
        ...
    @lod_distance5.setter
    def lod_distance5(self, value: float) -> None:
        ...
    @property
    def lod_distance6(self) -> float:
        r"""
        (float):  [Read-Write] Set a screen size value for LOD 6
        """
        ...
    @lod_distance6.setter
    def lod_distance6(self, value: float) -> None:
        ...
    @property
    def lod_distance7(self) -> float:
        r"""
        (float):  [Read-Write] Set a screen size value for LOD 7
        """
        ...
    @lod_distance7.setter
    def lod_distance7(self, value: float) -> None:
        ...
    @property
    def minimum_lod_number(self) -> int:
        r"""
        (int32):  [Read-Write] Set the minimum LOD used for rendering. Setting the value to 0 will use the default value of LOD0.
        """
        ...
    @minimum_lod_number.setter
    def minimum_lod_number(self, value: int) -> None:
        ...
    @property
    def lod_number(self) -> int:
        r"""
        (int32):  [Read-Write] Set the number of LODs for the editor to import. Setting the value to 0 imports the number of LODs found in the file (up to the maximum).
        """
        ...
    @lod_number.setter
    def lod_number(self, value: int) -> None:
        ...
    @property
    def import_animations(self) -> bool:
        r"""
        (bool):  [Read-Write] True to import animations from the FBX File
        """
        ...
    @import_animations.setter
    def import_animations(self, value: bool) -> None:
        ...
    @property
    def override_animation_name(self) -> str:
        r"""
        (str):  [Read-Write] Override for the name of the animation to import. By default, it will be the name of FBX *
        """
        ...
    @override_animation_name.setter
    def override_animation_name(self, value: str) -> None:
        ...
    @property
    def import_rigid_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables importing of 'rigid skeletalmesh' (unskinned, hierarchy-based animation) from this FBX file, no longer shown, used behind the scenes
        """
        ...
    @import_rigid_mesh.setter
    def import_rigid_mesh(self, value: bool) -> None:
        ...
    @property
    def import_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] If no existing materials are found, whether to automatically create Unreal materials for materials found in the FBX scene
        """
        ...
    @import_materials.setter
    def import_materials(self, value: bool) -> None:
        ...
    @property
    def import_textures(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not we should import textures. This option is disabled when we are importing materials because textures are always imported in that case.
        """
        ...
    @import_textures.setter
    def import_textures(self, value: bool) -> None:
        ...
    @property
    def reset_to_fbx_on_material_conflict(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the imported material sections will automatically be reset to the imported data in case of a reimport conflict.
        """
        ...
    @reset_to_fbx_on_material_conflict.setter
    def reset_to_fbx_on_material_conflict(self, value: bool) -> None:
        ...
    @property
    def static_mesh_import_data(self) -> FbxStaticMeshImportData:
        r"""
        (FbxStaticMeshImportData):  [Read-Write] Import data used when importing static meshes
        """
        ...
    @static_mesh_import_data.setter
    def static_mesh_import_data(self, value: FbxStaticMeshImportData) -> None:
        ...
    @property
    def skeletal_mesh_import_data(self) -> FbxSkeletalMeshImportData:
        r"""
        (FbxSkeletalMeshImportData):  [Read-Write] Import data used when importing skeletal meshes
        """
        ...
    @skeletal_mesh_import_data.setter
    def skeletal_mesh_import_data(self, value: FbxSkeletalMeshImportData) -> None:
        ...
    @property
    def anim_sequence_import_data(self) -> FbxAnimSequenceImportData:
        r"""
        (FbxAnimSequenceImportData):  [Read-Write] Import data used when importing animations
        """
        ...
    @anim_sequence_import_data.setter
    def anim_sequence_import_data(self, value: FbxAnimSequenceImportData) -> None:
        ...
    @property
    def texture_import_data(self) -> FbxTextureImportData:
        r"""
        (FbxTextureImportData):  [Read-Write] Import data used when importing textures
        """
        ...
    @texture_import_data.setter
    def texture_import_data(self, value: FbxTextureImportData) -> None:
        ...
    @property
    def automated_import_should_detect_type(self) -> bool:
        r"""
        (bool):  [Read-Write] If true the automated import path should detect the import type.  If false the import type was specified by the user
        """
        ...
    @automated_import_should_detect_type.setter
    def automated_import_should_detect_type(self, value: bool) -> None:
        ...
    def reset_to_default(self) -> None:
        r"""
        x.reset_to_default() -> None
        Reset to Default
        """
        ...

class FbxMeshImportData(FbxAssetImportData):
    r"""
    Import data and options used when importing any mesh from FBX
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxMeshImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bake_pivot_in_vertex`` (bool):  [Read-Write] - Experimental - If this option is true the inverse node rotation pivot will be apply to the mesh vertices. The pivot from the DCC will then be the origin of the mesh. Note: "TransformVertexToAbsolute" must be false.
    - ``compute_weighted_normals`` (bool):  [Read-Write] Enabling this option will use weighted normals algorithm (area and angle) when computing normals or tangents
    - ``convert_scene`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system
    - ``convert_scene_unit`` (bool):  [Read-Write] Convert the scene from FBX unit to UE unit (centimeter).
    - ``force_front_x_axis`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system with front X axis instead of -Y
    - ``import_mesh_lo_ds`` (bool):  [Read-Write] If enabled, creates LOD models for Unreal meshes from LODs in the import file; If not enabled, only the base mesh from the LOD group is imported
    - ``import_rotation`` (Rotator):  [Read-Write]
    - ``import_translation`` (Vector):  [Read-Write]
    - ``import_uniform_scale`` (float):  [Read-Write]
    - ``normal_generation_method`` (FBXNormalGenerationMethod):  [Read-Write] Use the MikkTSpace tangent space generator for generating normals and tangents on the mesh
    - ``normal_import_method`` (FBXNormalImportMethod):  [Read-Write] Enabling this option will read the tangents(tangent,binormal,normal) from FBX file instead of generating them automatically.
    - ``reorder_material_to_fbx_order`` (bool):  [Read-Write] If checked, The material list will be reorder to the same order has the FBX file.
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``transform_vertex_to_absolute`` (bool):  [Read-Write] If this option is true the node absolute transform (transform, offset and pivot) will be apply to the mesh vertices.
    """
    @property
    def transform_vertex_to_absolute(self) -> bool:
        r"""
        (bool):  [Read-Write] If this option is true the node absolute transform (transform, offset and pivot) will be apply to the mesh vertices.
        """
        ...
    @transform_vertex_to_absolute.setter
    def transform_vertex_to_absolute(self, value: bool) -> None:
        ...
    @property
    def bake_pivot_in_vertex(self) -> bool:
        r"""
        (bool):  [Read-Write] - Experimental - If this option is true the inverse node rotation pivot will be apply to the mesh vertices. The pivot from the DCC will then be the origin of the mesh. Note: "TransformVertexToAbsolute" must be false.
        """
        ...
    @bake_pivot_in_vertex.setter
    def bake_pivot_in_vertex(self, value: bool) -> None:
        ...
    @property
    def import_mesh_lo_ds(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, creates LOD models for Unreal meshes from LODs in the import file; If not enabled, only the base mesh from the LOD group is imported
        """
        ...
    @import_mesh_lo_ds.setter
    def import_mesh_lo_ds(self, value: bool) -> None:
        ...
    @property
    def normal_import_method(self) -> FBXNormalImportMethod:
        r"""
        (FBXNormalImportMethod):  [Read-Write] Enabling this option will read the tangents(tangent,binormal,normal) from FBX file instead of generating them automatically.
        """
        ...
    @normal_import_method.setter
    def normal_import_method(self, value: FBXNormalImportMethod) -> None:
        ...
    @property
    def normal_generation_method(self) -> FBXNormalGenerationMethod:
        r"""
        (FBXNormalGenerationMethod):  [Read-Write] Use the MikkTSpace tangent space generator for generating normals and tangents on the mesh
        """
        ...
    @normal_generation_method.setter
    def normal_generation_method(self, value: FBXNormalGenerationMethod) -> None:
        ...
    @property
    def compute_weighted_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] Enabling this option will use weighted normals algorithm (area and angle) when computing normals or tangents
        """
        ...
    @compute_weighted_normals.setter
    def compute_weighted_normals(self, value: bool) -> None:
        ...
    @property
    def reorder_material_to_fbx_order(self) -> bool:
        r"""
        (bool):  [Read-Write] If checked, The material list will be reorder to the same order has the FBX file.
        """
        ...
    @reorder_material_to_fbx_order.setter
    def reorder_material_to_fbx_order(self, value: bool) -> None:
        ...

class SceneImportFactory(Factory):
    r"""
    * Base class for all factories that import objects into a scene (e.g in a level)
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SceneImportFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class FbxSceneImportFactory(SceneImportFactory):
    r"""
    Fbx Scene Import Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxSceneImportFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``scene_import_options`` (FbxSceneImportOptions):  [Read-Write] Import options UI detail when importing fbx scene
    - ``scene_import_options_skeletal_mesh`` (FbxSceneImportOptionsSkeletalMesh):  [Read-Write] Import options UI detail when importing fbx scene skeletal mesh
    - ``scene_import_options_static_mesh`` (FbxSceneImportOptionsStaticMesh):  [Read-Write] Import options UI detail when importing fbx scene static mesh
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    @property
    def scene_import_options(self) -> FbxSceneImportOptions:
        r"""
        (FbxSceneImportOptions):  [Read-Write] Import options UI detail when importing fbx scene
        """
        ...
    @scene_import_options.setter
    def scene_import_options(self, value: FbxSceneImportOptions) -> None:
        ...
    @property
    def scene_import_options_static_mesh(self) -> FbxSceneImportOptionsStaticMesh:
        r"""
        (FbxSceneImportOptionsStaticMesh):  [Read-Write] Import options UI detail when importing fbx scene static mesh
        """
        ...
    @scene_import_options_static_mesh.setter
    def scene_import_options_static_mesh(self, value: FbxSceneImportOptionsStaticMesh) -> None:
        ...
    @property
    def scene_import_options_skeletal_mesh(self) -> FbxSceneImportOptionsSkeletalMesh:
        r"""
        (FbxSceneImportOptionsSkeletalMesh):  [Read-Write] Import options UI detail when importing fbx scene skeletal mesh
        """
        ...
    @scene_import_options_skeletal_mesh.setter
    def scene_import_options_skeletal_mesh(self, value: FbxSceneImportOptionsSkeletalMesh) -> None:
        ...

class FbxSceneImportOptions(Object):
    r"""
    Fbx_AddToBlueprint UMETA(DisplayName = "Add to an existing Blueprint asset"),
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxSceneImportOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bake_pivot_in_vertex`` (bool):  [Read-Write] - Experimental - If this option is true the inverse node pivot will be apply to the mesh vertices. The pivot from the DCC will then be the origin of the mesh. This option only work with static meshes.
    - ``create_content_folder_hierarchy`` (bool):  [Read-Write] If checked, a folder's hierarchy will be created under the import asset path. All the created folders will match the actor hierarchy. In case there is more than one actor that links to an asset, the shared asset will be placed at the first actor's place.
    - ``force_front_x_axis`` (bool):  [Read-Write] Whether to force the front axis to be align with X instead of -Y.
    - ``hierarchy_type`` (FBXSceneOptionsCreateHierarchyType):  [Read-Write] Choose if you want to generate the scene hierarchy with normal level actors, one actor with multiple components, or one blueprint asset with multiple components.
    - ``import_as_dynamic`` (bool):  [Read-Write] If checked, the mobility of all actors or components will be dynamic. If unchecked, they will be static.
    - ``import_skeletal_mesh_lo_ds`` (bool):  [Read-Write] If enabled, creates LOD models for Unreal skeletal meshes from LODs in the import file; If not enabled, only the base skeletal mesh from the LOD group is imported.
    - ``import_static_mesh_lo_ds`` (bool):  [Read-Write] If enabled, creates LOD models for Unreal static meshes from LODs in the import file; If not enabled, only the base static mesh from the LOD group is imported.
    - ``invert_normal_maps`` (bool):  [Read-Write] If enabled, this option will cause normal map Y (Green) values to be inverted when importing textures
    """
    ...

class FbxSceneImportOptionsSkeletalMesh(Object):
    r"""
    Fbx Scene Import Options Skeletal Mesh
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxSceneImportOptionsSkeletalMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animation_length`` (FBXAnimationLengthImportType):  [Read-Write] Type of asset to import from the FBX file
    - ``create_physics_asset`` (bool):  [Read-Write] If checked, create new PhysicsAsset if it doesn't have it
    - ``custom_sample_rate`` (int32):  [Read-Write] Sample fbx animation data at the specified sample rate, 0 find automaticaly the best sample rate
    - ``delete_existing_custom_attribute_curves`` (bool):  [Read-Write] If true, all previous node attributes imported as Animation Curves will be deleted when doing a re-import.
    - ``delete_existing_morph_target_curves`` (bool):  [Read-Write] Type of asset to import from the FBX file
    - ``delete_existing_non_curve_custom_attributes`` (bool):  [Read-Write] If true, all previous node attributes imported as Animation Attributes will be deleted when doing a re-import.
    - ``frame_import_range`` (Int32Interval):  [Read-Write] Frame range used when Set Range is used in Animation Length
    - ``import_animations`` (bool):  [Read-Write] True to import animations from the FBX File
    - ``import_custom_attribute`` (bool):  [Read-Write] If true, import node attributes as either Animation Curves or Animation Attributes
    - ``import_meshes_in_bone_hierarchy`` (bool):  [Read-Write] If checked, meshes nested in bone hierarchies will be imported instead of being converted to bones.
    - ``import_morph_targets`` (bool):  [Read-Write] If enabled, creates Unreal morph objects for the imported meshes
    - ``import_vertex_attributes`` (bool):  [Read-Write] If enabled, import single-channel/weight/alpha vertex attributes
    - ``keep_sections_separate`` (bool):  [Read-Write] If checked, sections with matching materials are kept separate and will not get combined.
    - ``morph_threshold_position`` (float):  [Read-Write] Threshold to compare vertex position equality when computing morph target deltas.
    - ``preserve_local_transform`` (bool):  [Read-Write] Type of asset to import from the FBX file
    - ``preserve_smoothing_groups`` (bool):  [Read-Write] If checked, triangles with non-matching smoothing groups will be physically split.
    - ``snap_to_closest_frame_boundary`` (bool):  [Read-Write] If enabled, snaps the animation to the closest frame boundary using the import sampling rate
    - ``threshold_position`` (float):  [Read-Write] Threshold to compare vertex position equality.
    - ``threshold_tangent_normal`` (float):  [Read-Write] Threshold to compare normal, tangent or bi-normal equality.
    - ``threshold_uv`` (float):  [Read-Write] Threshold to compare UV equality.
    - ``update_skeleton_reference_pose`` (bool):  [Read-Write] If enabled, update the Skeleton (of the mesh being imported)'s reference pose.
    - ``use_default_sample_rate`` (bool):  [Read-Write] If enabled, samples all animation curves to 30 FPS
    """
    ...

class FbxSceneImportOptionsStaticMesh(Object):
    r"""
    Fbx Scene Import Options Static Mesh
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxSceneImportOptionsStaticMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_generate_collision`` (bool):  [Read-Write] If checked, collision will automatically be generated (ignored if custom collision is imported or used).
    - ``build_reversed_index_buffer`` (bool):  [Read-Write]
    - ``generate_lightmap_u_vs`` (bool):  [Read-Write]
    - ``normal_generation_method`` (FBXSceneNormalGenerationMethod):  [Read-Write] Use the MikkTSpace tangent space generator for generating normals and tangents on the mesh
    - ``normal_import_method`` (FBXSceneNormalImportMethod):  [Read-Write] Enabling this option will read the tangents(tangent,binormal,normal) from FBX file instead of generating them automatically.
    - ``one_convex_hull_per_ucx`` (bool):  [Read-Write] If checked, one convex hull per UCX_ prefixed collision mesh will be generated instead of decomposing into multiple hulls
    - ``remove_degenerates`` (bool):  [Read-Write] Disabling this option will keep degenerate triangles found.  In general you should leave this option on.
    - ``vertex_color_import_option`` (FbxSceneVertexColorImportOption):  [Read-Write] Specify how vertex colors should be imported
    - ``vertex_override_color`` (Color):  [Read-Write] Specify override color in the case that VertexColorImportOption is set to Override
    """
    ...

class FbxSkeletalMeshImportData(FbxMeshImportData):
    r"""
    Import data and options used when importing a static mesh from fbx
    Notes:
    - Meta data ImportType i.e.       meta = (ImportType = "SkeletalMesh|GeoOnly")
        - SkeletalMesh : the property will be shown when importing skeletalmesh
        - GeoOnly: The property will be hide if we import skinning only
        - RigOnly: The property will be hide if we import geo only
        - RigAndGeo: The property will be show only if we import both skinning and geometry, it will be hiden otherwise
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxSkeletalMeshImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bake_pivot_in_vertex`` (bool):  [Read-Write] - Experimental - If this option is true the inverse node rotation pivot will be apply to the mesh vertices. The pivot from the DCC will then be the origin of the mesh. Note: "TransformVertexToAbsolute" must be false.
    - ``compute_weighted_normals`` (bool):  [Read-Write] Enabling this option will use weighted normals algorithm (area and angle) when computing normals or tangents
    - ``convert_scene`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system
    - ``convert_scene_unit`` (bool):  [Read-Write] Convert the scene from FBX unit to UE unit (centimeter).
    - ``force_front_x_axis`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system with front X axis instead of -Y
    - ``import_content_type`` (FBXImportContentType):  [Read-Write] Filter the content we want to import from the incoming FBX skeletal mesh.
    - ``import_mesh_lo_ds`` (bool):  [Read-Write] If enabled, creates LOD models for Unreal meshes from LODs in the import file; If not enabled, only the base mesh from the LOD group is imported
    - ``import_meshes_in_bone_hierarchy`` (bool):  [Read-Write] If checked, meshes nested in bone hierarchies will be imported instead of being converted to bones.
    - ``import_morph_targets`` (bool):  [Read-Write] If enabled, creates Unreal morph objects for the imported meshes
    - ``import_rotation`` (Rotator):  [Read-Write]
    - ``import_translation`` (Vector):  [Read-Write]
    - ``import_uniform_scale`` (float):  [Read-Write]
    - ``import_vertex_attributes`` (bool):  [Read-Write] If enabled, creates a named vertex attribute for each single-channel weight map of the imported mesh.
    - ``keep_sections_separate`` (bool):  [Read-Write] If checked, sections with matching materials are kept separate and will not get combined.
    - ``morph_threshold_position`` (float):  [Read-Write] Threshold to compare vertex position equality when computing morph target deltas.
    - ``normal_generation_method`` (FBXNormalGenerationMethod):  [Read-Write] Use the MikkTSpace tangent space generator for generating normals and tangents on the mesh
    - ``normal_import_method`` (FBXNormalImportMethod):  [Read-Write] Enabling this option will read the tangents(tangent,binormal,normal) from FBX file instead of generating them automatically.
    - ``preserve_smoothing_groups`` (bool):  [Read-Write] If checked, triangles with non-matching smoothing groups will be physically split.
    - ``reorder_material_to_fbx_order`` (bool):  [Read-Write] If checked, The material list will be reorder to the same order has the FBX file.
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``threshold_position`` (float):  [Read-Write] Threshold to compare vertex position equality.
    - ``threshold_tangent_normal`` (float):  [Read-Write] Threshold to compare normal, tangent or bi-normal equality.
    - ``threshold_uv`` (float):  [Read-Write] Threshold to compare UV equality.
    - ``transform_vertex_to_absolute`` (bool):  [Read-Write] If this option is true the node absolute transform (transform, offset and pivot) will be apply to the mesh vertices.
    - ``update_skeleton_reference_pose`` (bool):  [Read-Write] If enabled, update the Skeleton (of the mesh being imported)'s reference pose.
    - ``use_t0_as_ref_pose`` (bool):  [Read-Write] Enable this option to use frame 0 as reference pose
    - ``vertex_color_import_option`` (VertexColorImportOption):  [Read-Write] Specify how vertex colors should be imported
    - ``vertex_override_color`` (Color):  [Read-Write] Specify override color in the case that VertexColorImportOption is set to Override
    """
    @property
    def vertex_color_import_option(self) -> VertexColorImportOption:
        r"""
        (VertexColorImportOption):  [Read-Write] Specify how vertex colors should be imported
        """
        ...
    @vertex_color_import_option.setter
    def vertex_color_import_option(self, value: VertexColorImportOption) -> None:
        ...
    @property
    def vertex_override_color(self) -> Color:
        r"""
        (Color):  [Read-Write] Specify override color in the case that VertexColorImportOption is set to Override
        """
        ...
    @vertex_override_color.setter
    def vertex_override_color(self, value: Color) -> None:
        ...

class FbxStaticMeshImportData(FbxMeshImportData):
    r"""
    Fbx Static Mesh Import Data
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxStaticMeshImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_generate_collision`` (bool):  [Read-Write] If checked, collision will automatically be generated (ignored if custom collision is imported or used).
    - ``bake_pivot_in_vertex`` (bool):  [Read-Write] - Experimental - If this option is true the inverse node rotation pivot will be apply to the mesh vertices. The pivot from the DCC will then be the origin of the mesh. Note: "TransformVertexToAbsolute" must be false.
    - ``build_nanite`` (bool):  [Read-Write] If enabled, allows to render objects with Nanite
    - ``build_reversed_index_buffer`` (bool):  [Read-Write]
    - ``combine_meshes`` (bool):  [Read-Write] If enabled, combines all meshes into a single mesh
    - ``compute_weighted_normals`` (bool):  [Read-Write] Enabling this option will use weighted normals algorithm (area and angle) when computing normals or tangents
    - ``convert_scene`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system
    - ``convert_scene_unit`` (bool):  [Read-Write] Convert the scene from FBX unit to UE unit (centimeter).
    - ``distance_field_resolution_scale`` (float):  [Read-Write] Scale to apply to the mesh when allocating the distance field volume texture.
      The default scale is 1, which is assuming that the mesh will be placed unscaled in the world.
    - ``force_front_x_axis`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system with front X axis instead of -Y
    - ``generate_lightmap_u_vs`` (bool):  [Read-Write]
    - ``import_mesh_lo_ds`` (bool):  [Read-Write] If enabled, creates LOD models for Unreal meshes from LODs in the import file; If not enabled, only the base mesh from the LOD group is imported
    - ``import_rotation`` (Rotator):  [Read-Write]
    - ``import_translation`` (Vector):  [Read-Write]
    - ``import_uniform_scale`` (float):  [Read-Write]
    - ``normal_generation_method`` (FBXNormalGenerationMethod):  [Read-Write] Use the MikkTSpace tangent space generator for generating normals and tangents on the mesh
    - ``normal_import_method`` (FBXNormalImportMethod):  [Read-Write] Enabling this option will read the tangents(tangent,binormal,normal) from FBX file instead of generating them automatically.
    - ``one_convex_hull_per_ucx`` (bool):  [Read-Write] If checked, one convex hull per UCX_ prefixed collision mesh will be generated instead of decomposing into multiple hulls
    - ``remove_degenerates`` (bool):  [Read-Write] Disabling this option will keep degenerate triangles found.  In general you should leave this option on.
    - ``reorder_material_to_fbx_order`` (bool):  [Read-Write] If checked, The material list will be reorder to the same order has the FBX file.
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``static_mesh_lod_group`` (Name):  [Read-Write] The LODGroup to associate with this mesh when it is imported
    - ``transform_vertex_to_absolute`` (bool):  [Read-Write] If this option is true the node absolute transform (transform, offset and pivot) will be apply to the mesh vertices.
    - ``vertex_color_import_option`` (VertexColorImportOption):  [Read-Write] Specify how vertex colors should be imported
    - ``vertex_override_color`` (Color):  [Read-Write] Specify override color in the case that VertexColorImportOption is set to Override
    """
    @property
    def static_mesh_lod_group(self) -> Name:
        r"""
        (Name):  [Read-Write] The LODGroup to associate with this mesh when it is imported
        """
        ...
    @static_mesh_lod_group.setter
    def static_mesh_lod_group(self, value: Name) -> None:
        ...
    @property
    def vertex_color_import_option(self) -> VertexColorImportOption:
        r"""
        (VertexColorImportOption):  [Read-Write] Specify how vertex colors should be imported
        """
        ...
    @vertex_color_import_option.setter
    def vertex_color_import_option(self, value: VertexColorImportOption) -> None:
        ...
    @property
    def vertex_override_color(self) -> Color:
        r"""
        (Color):  [Read-Write] Specify override color in the case that VertexColorImportOption is set to Override
        """
        ...
    @vertex_override_color.setter
    def vertex_override_color(self, value: Color) -> None:
        ...
    @property
    def remove_degenerates(self) -> bool:
        r"""
        (bool):  [Read-Write] Disabling this option will keep degenerate triangles found.  In general you should leave this option on.
        """
        ...
    @remove_degenerates.setter
    def remove_degenerates(self, value: bool) -> None:
        ...
    @property
    def build_reversed_index_buffer(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @build_reversed_index_buffer.setter
    def build_reversed_index_buffer(self, value: bool) -> None:
        ...
    @property
    def build_nanite(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, allows to render objects with Nanite
        """
        ...
    @build_nanite.setter
    def build_nanite(self, value: bool) -> None:
        ...
    @property
    def generate_lightmap_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @generate_lightmap_u_vs.setter
    def generate_lightmap_u_vs(self, value: bool) -> None:
        ...
    @property
    def one_convex_hull_per_ucx(self) -> bool:
        r"""
        (bool):  [Read-Write] If checked, one convex hull per UCX_ prefixed collision mesh will be generated instead of decomposing into multiple hulls
        """
        ...
    @one_convex_hull_per_ucx.setter
    def one_convex_hull_per_ucx(self, value: bool) -> None:
        ...
    @property
    def auto_generate_collision(self) -> bool:
        r"""
        (bool):  [Read-Write] If checked, collision will automatically be generated (ignored if custom collision is imported or used).
        """
        ...
    @auto_generate_collision.setter
    def auto_generate_collision(self, value: bool) -> None:
        ...
    @property
    def combine_meshes(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, combines all meshes into a single mesh
        """
        ...
    @combine_meshes.setter
    def combine_meshes(self, value: bool) -> None:
        ...
    @property
    def distance_field_resolution_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scale to apply to the mesh when allocating the distance field volume texture.
        The default scale is 1, which is assuming that the mesh will be placed unscaled in the world.
        """
        ...
    @distance_field_resolution_scale.setter
    def distance_field_resolution_scale(self, value: float) -> None:
        ...

class FbxTextureImportData(FbxAssetImportData):
    r"""
    Import data and options used when importing any mesh from FBX
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FbxTextureImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_color_name`` (str):  [Read-Write]
    - ``base_diffuse_texture_name`` (str):  [Read-Write]
    - ``base_emissive_color_name`` (str):  [Read-Write]
    - ``base_emmisive_texture_name`` (str):  [Read-Write]
    - ``base_material_name`` (SoftObjectPath):  [Read-Write] Base material to instance from when importing materials.
    - ``base_normal_texture_name`` (str):  [Read-Write]
    - ``base_opacity_texture_name`` (str):  [Read-Write]
    - ``base_specular_texture_name`` (str):  [Read-Write]
    - ``convert_scene`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system
    - ``convert_scene_unit`` (bool):  [Read-Write] Convert the scene from FBX unit to UE unit (centimeter).
    - ``force_front_x_axis`` (bool):  [Read-Write] Convert the scene from FBX coordinate system to UE coordinate system with front X axis instead of -Y
    - ``import_rotation`` (Rotator):  [Read-Write]
    - ``import_translation`` (Vector):  [Read-Write]
    - ``import_uniform_scale`` (float):  [Read-Write]
    - ``invert_normal_maps`` (bool):  [Read-Write] If importing textures is enabled, this option will cause normal map Y (Green) values to be inverted
    - ``material_search_location`` (MaterialSearchLocation):  [Read-Write] Specify where we should search for matching materials when importing
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    @property
    def invert_normal_maps(self) -> bool:
        r"""
        (bool):  [Read-Write] If importing textures is enabled, this option will cause normal map Y (Green) values to be inverted
        """
        ...
    @invert_normal_maps.setter
    def invert_normal_maps(self, value: bool) -> None:
        ...
    @property
    def material_search_location(self) -> MaterialSearchLocation:
        r"""
        (MaterialSearchLocation):  [Read-Write] Specify where we should search for matching materials when importing
        """
        ...
    @material_search_location.setter
    def material_search_location(self, value: MaterialSearchLocation) -> None:
        ...
    @property
    def base_material_name(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Write] Base material to instance from when importing materials.
        """
        ...
    @base_material_name.setter
    def base_material_name(self, value: SoftObjectPath) -> None:
        ...
    @property
    def base_color_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @base_color_name.setter
    def base_color_name(self, value: str) -> None:
        ...
    @property
    def base_diffuse_texture_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @base_diffuse_texture_name.setter
    def base_diffuse_texture_name(self, value: str) -> None:
        ...
    @property
    def base_normal_texture_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @base_normal_texture_name.setter
    def base_normal_texture_name(self, value: str) -> None:
        ...
    @property
    def base_emissive_color_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @base_emissive_color_name.setter
    def base_emissive_color_name(self, value: str) -> None:
        ...
    @property
    def base_emmisive_texture_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @base_emmisive_texture_name.setter
    def base_emmisive_texture_name(self, value: str) -> None:
        ...
    @property
    def base_specular_texture_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @base_specular_texture_name.setter
    def base_specular_texture_name(self, value: str) -> None:
        ...
    @property
    def base_opacity_texture_name(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @base_opacity_texture_name.setter
    def base_opacity_texture_name(self, value: str) -> None:
        ...

class EditorLoadingAndSavingUtils(Object):
    r"""
    This class is a wrapper for editor loading and saving functionality
    It is meant to contain only functions that can be executed in script (but are also allowed in C++).
    It is separated from FEditorFileUtils to ensure new easier to use methods can be created without breaking FEditorFileUtils backwards compatibility
    However this should be used in place of FEditorFileUtils wherever possible as the goal is to deprecate FEditorFileUtils eventually
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FileHelpers.h
    
    """
    @classmethod
    def unload_packages(cls, packages_to_unload: Array[Package]) -> Tuple[bool, Text]:
        r"""
        X.unload_packages(packages_to_unload) -> (out_any_packages_unloaded=bool, out_error_message=Text)
        Unloads a list of packages
        
        Args:
            packages_to_unload (Array[Package]): Array of packages to unload.
        
        Returns:
            tuple: 
        
            out_any_packages_unloaded (bool): 
        
            out_error_message (Text):
        """
        ...
    @classmethod
    def save_packages_with_dialog(cls, packages_to_save: Array[Package], only_dirty: bool) -> bool:
        r"""
        X.save_packages_with_dialog(packages_to_save, only_dirty) -> bool
        Save all packages. Optionally prompting the user to select which packages to save.
        Prompt the user to select which dirty packages to save and check them out from source control (if enabled).
        
        Args:
            packages_to_save (Array[Package]): The list of packages to save.  Both map and content packages are supported
            only_dirty (bool): 
        
        Returns:
            bool: true on success, false on fail.
        """
        ...
    @classmethod
    def save_packages(cls, packages_to_save: Array[Package], only_dirty: bool) -> bool:
        r"""
        X.save_packages(packages_to_save, only_dirty) -> bool
        Save all packages.
        Assume all dirty packages should be saved and check out from source control (if enabled).
        
        Args:
            packages_to_save (Array[Package]): The list of packages to save.  Both map and content packages are supported
            only_dirty (bool): 
        
        Returns:
            bool: true on success, false on fail.
        """
        ...
    @classmethod
    def save_map(cls, world: World, asset_path: str) -> bool:
        r"""
        X.save_map(world, asset_path) -> bool
        Saves the specified map, returning true on success.
        
        Args:
            world (World): The world to save.
            asset_path (str): The valid content directory path and name for the asset.  E.g "/Game/MyMap"
        
        Returns:
            bool: true if the map was saved successfully.
        """
        ...
    @classmethod
    def save_dirty_packages_with_dialog(cls, save_map_packages: bool, save_content_packages: bool) -> bool:
        r"""
        X.save_dirty_packages_with_dialog(save_map_packages, save_content_packages) -> bool
        Looks at all currently loaded packages and saves them if their "bDirty" flag is set.
        Prompt the user to select which dirty packages to save and check them out from source control (if enabled).
        
        Args:
            save_map_packages (bool): true if map packages should be saved
            save_content_packages (bool): true if we should save content packages.
        
        Returns:
            bool: true on success, false on fail.
        """
        ...
    @classmethod
    def save_dirty_packages(cls, save_map_packages: bool, save_content_packages: bool) -> bool:
        r"""
        X.save_dirty_packages(save_map_packages, save_content_packages) -> bool
        Looks at all currently loaded packages and saves them if their "bDirty" flag is set.
        Assume all dirty packages should be saved and check out from source control (if enabled).
        
        Args:
            save_map_packages (bool): true if map packages should be saved
            save_content_packages (bool): true if we should save content packages.
        
        Returns:
            bool: true on success, false on fail.
        """
        ...
    @classmethod
    def save_current_level(cls) -> bool:
        r"""
        X.save_current_level() -> bool
        Saves the active level, prompting the use for checkout if necessary.
        
        Returns:
            bool: true on success, False on fail
        """
        ...
    @classmethod
    def reload_packages(cls, packages_to_reload: Array[Package], interaction_mode: ReloadPackagesInteractionMode = ReloadPackagesInteractionMode.INTERACTIVE) -> Tuple[bool, Text]:
        r"""
        X.reload_packages(packages_to_reload, interaction_mode=ReloadPackagesInteractionMode.INTERACTIVE) -> (out_any_packages_reloaded=bool, out_error_message=Text)
        Helper function that attempts to reload the specified top-level packages.
        
        Args:
            packages_to_reload (Array[Package]): The list of packages that should be reloaded
            interaction_mode (ReloadPackagesInteractionMode): Whether the function is allowed to ask the user questions (such as whether to reload dirty packages)
        
        Returns:
            tuple: 
        
            out_any_packages_reloaded (bool): True if the set of loaded packages was changed
        
            out_error_message (Text): An error message specifying any problems with reloading packages
        """
        ...
    @classmethod
    def new_map_from_template(cls, path_to_template_level: str, save_existing_map: bool) -> World:
        r"""
        X.new_map_from_template(path_to_template_level, save_existing_map) -> World
        New Map from Template
        
        Args:
            path_to_template_level (str): 
            save_existing_map (bool): 
        
        Returns:
            World:
        """
        ...
    @classmethod
    def new_blank_map(cls, save_existing_map: bool) -> World:
        r"""
        X.new_blank_map(save_existing_map) -> World
        New Blank Map
        
        Args:
            save_existing_map (bool): 
        
        Returns:
            World:
        """
        ...
    @classmethod
    def load_map_with_dialog(cls) -> World:
        r"""
        X.load_map_with_dialog() -> World
        Prompts the user to save the current map if necessary, the presents a load dialog and
        loads a new map if selected by the user.
        
        Returns:
            World:
        """
        ...
    @classmethod
    def load_map(cls, filename: str) -> World:
        r"""
        X.load_map(filename) -> World
        Loads the specified map.  Does not prompt the user to save the current map.
        
        Args:
            filename (str): Level package filename, including path.
        
        Returns:
            World: true if the map was loaded successfully.
        """
        ...
    @classmethod
    def import_scene(cls, filename: str) -> None:
        r"""
        X.import_scene(filename) -> None
        Imports a file such as (FBX or obj) and spawns actors f into the current level
        
        Args:
            filename (str):
        """
        ...
    @classmethod
    def get_dirty_map_packages(cls) -> Array[Package]:
        r"""
        X.get_dirty_map_packages() -> Array[Package]
        Appends array with all currently dirty map packages.
        
        Returns:
            Array[Package]: 
        
            out_dirty_packages (Array[Package]): Array to append dirty packages to.
        """
        ...
    @classmethod
    def get_dirty_content_packages(cls) -> Array[Package]:
        r"""
        X.get_dirty_content_packages() -> Array[Package]
        Appends array with all currently dirty content packages.
        
        Returns:
            Array[Package]: 
        
            out_dirty_packages (Array[Package]): Array to append dirty packages to.
        """
        ...
    @classmethod
    def export_scene(cls, export_selected_actors_only: bool) -> None:
        r"""
        X.export_scene(export_selected_actors_only) -> None
        Exports the current scene
        
        Args:
            export_selected_actors_only (bool):
        """
        ...

class FontFactory(Factory):
    r"""
    Font Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FontFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class FontFileImportFactory(Factory):
    r"""
    Font File Import Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: FontFileImportFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ForceFeedbackAttenuationFactory(Factory):
    r"""
    Force Feedback Attenuation Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ForceFeedbackAttenuationFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ForceFeedbackEffectFactory(Factory):
    r"""
    Force Feedback Effect Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ForceFeedbackEffectFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class GroupActor(Actor):
    r"""
    Group Actor
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: GroupActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class HapticFeedbackEffectBufferFactory(Factory):
    r"""
    Haptic Feedback Effect Buffer Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: HapticFeedbackEffectBufferFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class HapticFeedbackEffectCurveFactory(Factory):
    r"""
    Haptic Feedback Effect Curve Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: HapticFeedbackEffectCurveFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class HapticFeedbackEffectSoundWaveFactory(Factory):
    r"""
    Haptic Feedback Effect Sound Wave Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: HapticFeedbackEffectSoundWaveFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class HierarchicalLODVolume(Volume):
    r"""
    An invisible volume used to manually define/create an HLOD cluster.
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: HierarchicalLODVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``apply_only_to_specific_hlod_levels`` (Array[int32]):  [Read-Write] If set, this volume will only be applied to HLOD levels contained in the array.  If empty, it will apply to ALL HLOD levels
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``include_overlapping_actors`` (bool):  [Read-Write] When set this volume will incorporate actors which bounds overlap with the volume, otherwise only actors which are completely inside of the volume are incorporated
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class ImportSubsystem(EditorSubsystem):
    r"""
    UImportSubsystem
    Subsystem for importing assets in the editor,
    Contains utility functions and callbacks for hooking into importing.
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ImportSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_asset_post_import`` (OnAssetPostImport_Dyn):  [Read-Write]
    - ``on_asset_post_lod_import`` (OnAssetPostLODImport_Dyn):  [Read-Write]
    - ``on_asset_pre_import`` (OnAssetPreImport_Dyn):  [Read-Write]
    - ``on_asset_reimport`` (OnAssetReimport_Dyn):  [Read-Write]
    """
    @property
    def on_asset_pre_import(self) -> OnAssetPreImport_Dyn:
        r"""
        (OnAssetPreImport_Dyn):  [Read-Write]
        """
        ...
    @on_asset_pre_import.setter
    def on_asset_pre_import(self, value: OnAssetPreImport_Dyn) -> None:
        ...
    @property
    def on_asset_post_import(self) -> OnAssetPostImport_Dyn:
        r"""
        (OnAssetPostImport_Dyn):  [Read-Write]
        """
        ...
    @on_asset_post_import.setter
    def on_asset_post_import(self, value: OnAssetPostImport_Dyn) -> None:
        ...
    @property
    def on_asset_reimport(self) -> OnAssetReimport_Dyn:
        r"""
        (OnAssetReimport_Dyn):  [Read-Write]
        """
        ...
    @on_asset_reimport.setter
    def on_asset_reimport(self, value: OnAssetReimport_Dyn) -> None:
        ...
    @property
    def on_asset_post_lod_import(self) -> OnAssetPostLODImport_Dyn:
        r"""
        (OnAssetPostLODImport_Dyn):  [Read-Write]
        """
        ...
    @on_asset_post_lod_import.setter
    def on_asset_post_lod_import(self, value: OnAssetPostLODImport_Dyn) -> None:
        ...

class LayersSubsystem(EditorSubsystem):
    r"""
    Layers Subsystem
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: LayersSubsystem.h
    
    """
    def update_all_view_visibility(self, layer_that_changed: Name) -> None:
        r"""
        x.update_all_view_visibility(layer_that_changed) -> None
        Updates the visibility for all actors for all views.
        
        Args:
            layer_that_changed (Name): If one layer was changed (toggled in view pop-up, etc), then we only need to modify actors that use that layer.
        """
        ...
    def update_all_actors_visibility(self, notify_selection_change: bool, redraw_viewports: bool) -> bool:
        r"""
        x.update_all_actors_visibility(notify_selection_change, redraw_viewports) -> bool
        Updates the visibility of all actors in the viewports
        
        Args:
            notify_selection_change (bool): If true the Editor is notified of the selection change; if false, the Editor will not be notified
            redraw_viewports (bool): If true the viewports will be redrawn; if false, they will not
        
        Returns:
            bool:
        """
        ...
    def update_actor_visibility(self, actor: Actor, notify_selection_change: bool, redraw_viewports: bool) -> Optional[Tuple[bool, bool]]:
        r"""
        x.update_actor_visibility(actor, notify_selection_change, redraw_viewports) -> (out_selection_changed=bool, out_actor_modified=bool) or None
        Updates the provided actors visibility in the viewports
        
        Args:
            actor (Actor): Actor to update
            notify_selection_change (bool): If true the Editor is notified of the selection change; if false, the Editor will not be notified
            redraw_viewports (bool): If true the viewports will be redrawn; if false, they will not
        
        Returns:
            tuple or None: 
        
            out_selection_changed (bool): [OUT]      Whether the Editors selection changed
        
            out_actor_modified (bool): [OUT]         Whether the actor was modified
        """
        ...
    def update_actor_all_views_visibility(self, actor: Actor) -> None:
        r"""
        x.update_actor_all_views_visibility(actor) -> None
        Updates per-view visibility for the given actor for all views
        
        Args:
            actor (Actor): Actor to update
        """
        ...
    def try_get_layer(self, layer_name: Name) -> Optional[Layer]:
        r"""
        x.try_get_layer(layer_name) -> Layer or None
        Attempts to get the ULayer Object of the provided layer name.
        
        Args:
            layer_name (Name): The name of the layer whose ULayer Object to retrieve
        
        Returns:
            Layer or None: If true a valid ULayer Object was found and set to OutLayer; if false, a valid ULayer object was not found and invalid set to OutLayer
        
            out_layer (Layer):
        """
        ...
    def toggle_layer_visibility(self, layer_name: Name) -> None:
        r"""
        x.toggle_layer_visibility(layer_name) -> None
        Toggles the named layer's visibility
        
        Args:
            layer_name (Name): The name of the layer to affect
        """
        ...
    def toggle_layers_visibility(self, layer_names: Array[Name]) -> None:
        r"""
        x.toggle_layers_visibility(layer_names) -> None
        Toggles the visibility of all of the named layers
        
        Args:
            layer_names (Array[Name]): The names of the layers to affect
        """
        ...
    def set_layer_visibility(self, layer_name: Name, is_visible: bool) -> None:
        r"""
        x.set_layer_visibility(layer_name, is_visible) -> None
        Changes the named layer's visibility to the provided state
        
        Args:
            layer_name (Name): The name of the layer to affect.
            is_visible (bool): If true the layer will be visible; if false, the layer will not be visible.
        """
        ...
    def set_layers_visibility(self, layer_names: Array[Name], is_visible: bool) -> None:
        r"""
        x.set_layers_visibility(layer_names, is_visible) -> None
        Changes visibility of the named layers to the provided state
        
        Args:
            layer_names (Array[Name]): The names of the layers to affect
            is_visible (bool): If true the layers will be visible; if false, the layers will not be visible
        """
        ...
    def select_actors_in_layers(self, layer_names: Array[Name], select: bool, notify: bool, select_even_if_hidden: bool = False) -> bool:
        r"""
        x.select_actors_in_layers(layer_names, select, notify, select_even_if_hidden=False) -> bool
        Selects/de-selects actors belonging to the named layers.
        
        Args:
            layer_names (Array[Name]): A valid list of layer names.
            select (bool): If true actors are selected; if false, actors are deselected.
            notify (bool): If true the Editor is notified of the selection change; if false, the Editor will not be notified
            select_even_if_hidden (bool): [optional]      If true even hidden actors will be selected; if false, hidden actors won't be selected.
        
        Returns:
            bool: true if at least one actor was selected/deselected.
        """
        ...
    def select_actors_in_layer(self, layer_name: Name, select: bool, notify: bool, select_even_if_hidden: bool = False) -> bool:
        r"""
        x.select_actors_in_layer(layer_name, select, notify, select_even_if_hidden=False) -> bool
        Selects/de-selects actors belonging to the named layer.
        
        Args:
            layer_name (Name): A valid layer name.
            select (bool): If true actors are selected; if false, actors are deselected.
            notify (bool): If true the Editor is notified of the selection change; if false, the Editor will not be notified.
            select_even_if_hidden (bool): [optional]      If true even hidden actors will be selected; if false, hidden actors won't be selected.
        
        Returns:
            bool: true if at least one actor was selected/deselected.
        """
        ...
    def rename_layer(self, original_layer_name: Name, new_layer_name: Name) -> bool:
        r"""
        x.rename_layer(original_layer_name, new_layer_name) -> bool
        Renames the provided originally named layer to the provided new name
        
        Args:
            original_layer_name (Name): The name of the layer to be renamed
            new_layer_name (Name): The new name for the layer to be renamed
        
        Returns:
            bool:
        """
        ...
    def remove_selected_actors_from_layers(self, layer_names: Array[Name]) -> bool:
        r"""
        x.remove_selected_actors_from_layers(layer_names) -> bool
        Removes selected actors from the named layers.
        
        Args:
            layer_names (Array[Name]): A valid list of layer names.
        
        Returns:
            bool: true if at least one actor was removed.
        """
        ...
    def remove_selected_actors_from_layer(self, layer_name: Name) -> bool:
        r"""
        x.remove_selected_actors_from_layer(layer_name) -> bool
        Removes the selected actors from the named layer.
        
        Args:
            layer_name (Name): A layer name.
        
        Returns:
            bool: true if at least one actor was added.  false is returned if all selected actors already belong to the named layer.
        """
        ...
    def remove_level_layer_information(self, level: Level) -> None:
        r"""
        x.remove_level_layer_information(level) -> None
        Purges any information regarding layers associated with the level and it contents
        
        Args:
            level (Level): The process
        """
        ...
    def remove_actors_from_layers(self, actors: Array[Actor], layer_names: Array[Name], update_stats: bool = True) -> bool:
        r"""
        x.remove_actors_from_layers(actors, layer_names, update_stats=True) -> bool
        Remove the actors to the named layers
        
        Args:
            actors (Array[Actor]): The actors to remove to the named layers
            layer_names (Array[Name]): A valid list of layer names.
            update_stats (bool): 
        
        Returns:
            bool: true if at least one actor was removed from at least one layer.  false is returned if none of the actors belonged to any of the specified layers.
        """
        ...
    def remove_actors_from_layer(self, actors: Array[Actor], layer_name: Name, update_stats: bool = True) -> bool:
        r"""
        x.remove_actors_from_layer(actors, layer_name, update_stats=True) -> bool
        Removes the actors from the specified layer.
        
        Args:
            actors (Array[Actor]): The actors to remove from the provided layer
            layer_name (Name): 
            update_stats (bool): 
        
        Returns:
            bool: true if at least one actor was removed from the layer.  false is returned if all the actors already belonged to the layer.
        """
        ...
    def remove_actor_from_layers(self, actor: Actor, layer_names: Array[Name], update_stats: bool = True) -> bool:
        r"""
        x.remove_actor_from_layers(actor, layer_names, update_stats=True) -> bool
        Removes the provided actor from the named layers.
        
        Args:
            actor (Actor): The actor to remove from the provided layers
            layer_names (Array[Name]): A valid list of layer names.
            update_stats (bool): 
        
        Returns:
            bool: true if the actor was removed from at least one of the provided layers.
        """
        ...
    def remove_actor_from_layer(self, actor: Actor, layer_to_remove: Name, update_stats: bool = True) -> bool:
        r"""
        x.remove_actor_from_layer(actor, layer_to_remove, update_stats=True) -> bool
        Removes an actor from the specified layer.
        
        Args:
            actor (Actor): The actor to remove from the provided layer
            layer_to_remove (Name): The name of the layer to remove the actor from
            update_stats (bool): 
        
        Returns:
            bool: true if the actor was removed from the layer.  false is returned if the actor already belonged to the layer.
        """
        ...
    def make_all_layers_visible(self) -> None:
        r"""
        x.make_all_layers_visible() -> None
        Set the visibility of all layers to true
        """
        ...
    def is_layer(self, layer_name: Name) -> bool:
        r"""
        x.is_layer(layer_name) -> bool
        Checks whether the ULayer Object of the provided layer name exists.
        
        Args:
            layer_name (Name): The name of the layer whose ULayer Object to retrieve
        
        Returns:
            bool: If true a valid ULayer Object was found; if false, a valid ULayer object was not found
        """
        ...
    def is_actor_valid_for_layer(self, actor: Actor) -> bool:
        r"""
        x.is_actor_valid_for_layer(actor) -> bool
        Checks to see if the specified actor is in an appropriate state to interact with layers
        
        Args:
            actor (Actor): The actor to validate
        
        Returns:
            bool:
        """
        ...
    def initialize_new_actor_layers(self, actor: Actor) -> bool:
        r"""
        x.initialize_new_actor_layers(actor) -> bool
        Synchronizes an newly created Actor's layers with the layer system
        
        Args:
            actor (Actor): The actor to initialize
        
        Returns:
            bool:
        """
        ...
    def get_world(self) -> World:
        r"""
        x.get_world() -> World
        Get the current UWorld object.
        
        Returns:
            World: The UWorld* object
        """
        ...
    def get_selected_actors(self) -> Array[Actor]:
        r"""
        x.get_selected_actors() -> Array[Actor]
        Find and return the selected actors.
        
        Returns:
            Array[Actor]: The selected AActor's as a TArray.
        """
        ...
    def get_layer(self, layer_name: Name) -> Layer:
        r"""
        x.get_layer(layer_name) -> Layer
        Gets the ULayer Object of the named layer
        
        Args:
            layer_name (Name): The name of the layer whose ULayer Object is returned
        
        Returns:
            Layer: The ULayer Object of the provided layer name
        """
        ...
    def get_actors_from_layers(self, layer_names: Array[Name]) -> Array[Actor]:
        r"""
        x.get_actors_from_layers(layer_names) -> Array[Actor]
        Gets all the actors associated with ANY of the specified layers. Analog to AppendActorsFromLayers but it returns rather than appends the actors.
        
        Args:
            layer_names (Array[Name]): The layers to find actors for.
        
        Returns:
            Array[Actor]: The list to assign the found actors to.
        """
        ...
    def get_actors_from_layer(self, layer_name: Name) -> Array[Actor]:
        r"""
        x.get_actors_from_layer(layer_name) -> Array[Actor]
        Gets all the actors associated with the specified layer. Analog to AppendActorsFromLayer but it returns rather than appends the actors.
        
        Args:
            layer_name (Name): The layer to find actors for.
        
        Returns:
            Array[Actor]: The list to assign the found actors to.
        """
        ...
    def editor_refresh_layer_browser(self) -> None:
        r"""
        x.editor_refresh_layer_browser() -> None
        Delegate handler for FEditorDelegates::RefreshLayerBrowser. It internally calls UpdateAllActorsVisibility to refresh the actors of each layer.
        """
        ...
    def editor_map_change(self) -> None:
        r"""
        x.editor_map_change() -> None
        Delegate handler for FEditorDelegates::MapChange. It internally calls LayersChanged.Broadcast.
        """
        ...
    def disassociate_actors_from_layers(self, actors: Array[Actor]) -> bool:
        r"""
        x.disassociate_actors_from_layers(actors) -> bool
        Disassociates actors from the layer system, generally used before deleting the Actors
        
        Args:
            actors (Array[Actor]): The actors to disassociate from the layer system
        
        Returns:
            bool:
        """
        ...
    def disassociate_actor_from_layers(self, actor: Actor) -> bool:
        r"""
        x.disassociate_actor_from_layers(actor) -> bool
        Disassociates an Actor's layers from the layer system, general used before deleting the Actor
        
        Args:
            actor (Actor): The actor to disassociate from the layer system
        
        Returns:
            bool:
        """
        ...
    def delete_layers(self, layers_to_delete: Array[Name]) -> None:
        r"""
        x.delete_layers(layers_to_delete) -> None
        Deletes all of the provided layers, disassociating all actors from them
        
        Args:
            layers_to_delete (Array[Name]): A valid list of layer names.
        """
        ...
    def delete_layer(self, layer_to_delete: Name) -> None:
        r"""
        x.delete_layer(layer_to_delete) -> None
        Deletes the provided layer, disassociating all actors from them
        
        Args:
            layer_to_delete (Name): A valid layer name
        """
        ...
    def create_layer(self, layer_name: Name) -> Layer:
        r"""
        x.create_layer(layer_name) -> Layer
        Creates a ULayer Object for the named layer
        
        Args:
            layer_name (Name): The name of the layer to create
        
        Returns:
            Layer: The newly created ULayer Object for the named layer
        """
        ...
    def append_actors_from_layers(self, layer_names: Array[Name]) -> Array[Actor]:
        r"""
        x.append_actors_from_layers(layer_names) -> Array[Actor]
        Appends all the actors associated with ANY of the specified layers.
        
        Args:
            layer_names (Array[Name]): The layers to find actors for.
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]): The list to append the found actors to.
        """
        ...
    def append_actors_from_layer(self, layer_name: Name) -> Array[Actor]:
        r"""
        x.append_actors_from_layer(layer_name) -> Array[Actor]
        Appends all the actors associated with the specified layer.
        
        Args:
            layer_name (Name): The layer to find actors for.
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]): The list to append the found actors to.
        """
        ...
    def add_selected_actors_to_layers(self, layer_names: Array[Name]) -> bool:
        r"""
        x.add_selected_actors_to_layers(layer_names) -> bool
        Adds selected actors to the named layers.
        
        Args:
            layer_names (Array[Name]): A valid list of layer names.
        
        Returns:
            bool: true if at least one actor was added.  false is returned if all selected actors already belong to the named layers.
        """
        ...
    def add_selected_actors_to_layer(self, layer_name: Name) -> bool:
        r"""
        x.add_selected_actors_to_layer(layer_name) -> bool
        Adds selected actors to the named layer.
        
        Args:
            layer_name (Name): A layer name.
        
        Returns:
            bool: true if at least one actor was added.  false is returned if all selected actors already belong to the named layer.
        """
        ...
    def add_level_layer_information(self, level: Level) -> None:
        r"""
        x.add_level_layer_information(level) -> None
        Aggregates any information regarding layers associated with the level and it contents
        
        Args:
            level (Level): The process
        """
        ...
    def add_all_layers_to(self) -> Array[Layer]:
        r"""
        x.add_all_layers_to() -> Array[Layer]
        Gets all known layers and appends them to the provided array
        
        Returns:
            Array[Layer]: 
        
            out_layers (Array[Layer]):
        """
        ...
    def add_all_layer_names_to(self) -> Array[Name]:
        r"""
        x.add_all_layer_names_to() -> Array[Name]
        Gets all known layers and appends their names to the provide array
        
        Returns:
            Array[Name]: 
        
            out_layer_names (Array[Name]):
        """
        ...
    def add_actor_to_layers(self, actor: Actor, layer_names: Array[Name]) -> bool:
        r"""
        x.add_actor_to_layers(actor, layer_names) -> bool
        Adds the provided actor to the named layers.
        
        Args:
            actor (Actor): The actor to add to the provided layers
            layer_names (Array[Name]): A valid list of layer names.
        
        Returns:
            bool: true if the actor was added to at least one of the provided layers.
        """
        ...
    def add_actor_to_layer(self, actor: Actor, layer_name: Name) -> bool:
        r"""
        x.add_actor_to_layer(actor, layer_name) -> bool
        Adds the actor to the named layer.
        
        Args:
            actor (Actor): The actor to add to the named layer
            layer_name (Name): The name of the layer to add the actor to
        
        Returns:
            bool: true if the actor was added.  false is returned if the actor already belongs to the layer.
        """
        ...
    def add_actors_to_layers(self, actors: Array[Actor], layer_names: Array[Name]) -> bool:
        r"""
        x.add_actors_to_layers(actors, layer_names) -> bool
        Add the actors to the named layers
        
        Args:
            actors (Array[Actor]): The actors to add to the named layers
            layer_names (Array[Name]): A valid list of layer names.
        
        Returns:
            bool: true if at least one actor was added to at least one layer.  false is returned if all the actors already belonged to all specified layers.
        """
        ...
    def add_actors_to_layer(self, actors: Array[Actor], layer_name: Name) -> bool:
        r"""
        x.add_actors_to_layer(actors, layer_name) -> bool
        Add the actors to the named layer
        
        Args:
            actors (Array[Actor]): The actors to add to the named layer
            layer_name (Name): The name of the layer to add to
        
        Returns:
            bool: true if at least one actor was added to the layer.  false is returned if all the actors already belonged to the layer.
        """
        ...

class CommonResolutionMenuContext(ToolMenuContextBase):
    r"""
    Common Resolution Menu Context
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: LevelEditorPlaySettings.h
    
    """
    ...

class LevelExporterFBX(ExporterFBX):
    r"""
    Level Exporter FBX
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: LevelExporterFBX.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class LevelExporterLOD(Exporter):
    r"""
    Level Exporter LOD
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: LevelExporterLOD.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class LevelExporterOBJ(Exporter):
    r"""
    Level Exporter OBJ
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: LevelExporterOBJ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class LevelExporterSTL(Exporter):
    r"""
    Level Exporter STL
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: LevelExporterSTL.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class LevelExporterT3D(Exporter):
    r"""
    Level Exporter T3D
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: LevelExporterT3D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class LevelFactory(Factory):
    r"""
    Level Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: LevelFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class LightWeightInstanceFactory(Factory):
    r"""
    Light Weight Instance Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: LightWeightInstanceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MaterialEditorInstanceConstant(Object):
    r"""
    Material Editor Instance Constant
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialEditorInstanceConstant.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_property_overrides`` (MaterialInstanceBasePropertyOverrides):  [Read-Write]
    - ``lightmass_settings`` (LightmassParameterizedMaterialSettings):  [Read-Write] The Lightmass override settings for this object.
    - ``nanite_override`` (bool):  [Read-Write] When set we will use the override from NaniteOverrideMaterial. Otherwise we inherit any override on the parent.
    - ``nanite_override_material`` (MaterialInterface):  [Read-Write] An override material which will be used instead of this one when rendering with nanite.
    - ``override_subsurface_profile`` (bool):  [Read-Write] Defines if SubsurfaceProfile from tis instance is used or it uses the parent one.
    - ``parameter_groups`` (Array[EditorParameterGroup]):  [Read-Write]
    - ``parent`` (MaterialInterface):  [Read-Write] since the Parent may point across levels and the property editor needs to import this text, it must be marked lazy so it doesn't set itself to NULL in FindImportedObject
    - ``phys_material`` (PhysicalMaterial):  [Read-Write] Physical material to use for this graphics material. Used for sounds, effects etc.
    - ``refraction_depth_bias`` (float):  [Read-Write] This is the refraction depth bias, larger values offset distortion to prevent closer objects from rendering into the distorted surface at acute viewing angles but increases the disconnect between surface and where the refraction starts.
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Screen Space Subsurface Scattering
    - ``use_old_style_mic_editor_groups`` (bool):  [Read-Write] Should we use old style typed arrays for unassigned parameters instead of a None group (new style)?
    """
    @property
    def subsurface_profile(self) -> SubsurfaceProfile:
        r"""
        (SubsurfaceProfile):  [Read-Only] SubsurfaceProfile, for Screen Space Subsurface Scattering
        """
        ...

class MaterialEditorMeshComponent(StaticMeshComponent):
    r"""
    Material Editor Mesh Component
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialEditorMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    ...

class MaterialFactoryNew(Factory):
    r"""
    Material Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MaterialFunctionFactoryNew(Factory):
    r"""
    Material Function Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialFunctionFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MaterialFunctionInstanceFactory(Factory):
    r"""
    Material Function Instance Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialFunctionInstanceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MaterialFunctionMaterialLayerInstanceFactory(MaterialFunctionInstanceFactory):
    r"""
    Material Function Material Layer Instance Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialFunctionInstanceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MaterialFunctionMaterialLayerBlendInstanceFactory(MaterialFunctionInstanceFactory):
    r"""
    Material Function Material Layer Blend Instance Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialFunctionInstanceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MaterialFunctionMaterialLayerBlendFactory(Factory):
    r"""
    Material Function Material Layer Blend Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialFunctionMaterialLayerBlendFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MaterialFunctionMaterialLayerFactory(Factory):
    r"""
    Material Function Material Layer Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialFunctionMaterialLayerFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MaterialImportHelpers(Object):
    r"""
    Material Import Helpers
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialImportHelpers.h
    
    """
    @classmethod
    def find_existing_material_from_search_location(cls, material_full_name: str, base_package_path: str, search_location: MaterialSearchLocation) -> Tuple[MaterialInterface, Text]:
        r"""
        X.find_existing_material_from_search_location(material_full_name, base_package_path, search_location) -> (MaterialInterface, out_error=Text)
        Find Existing Material from Search Location
        
        Args:
            material_full_name (str): 
            base_package_path (str): 
            search_location (MaterialSearchLocation): 
        
        Returns:
            Text: 
        
            out_error (Text):
        """
        ...
    @classmethod
    def find_existing_material(cls, base_path: str, material_full_name: str, recursive_paths: bool) -> Tuple[MaterialInterface, Text]:
        r"""
        X.find_existing_material(base_path, material_full_name, recursive_paths) -> (MaterialInterface, out_error=Text)
        Find Existing Material
        
        Args:
            base_path (str): 
            material_full_name (str): 
            recursive_paths (bool): 
        
        Returns:
            Text: 
        
            out_error (Text):
        """
        ...

class MaterialInstanceConstantFactoryNew(Factory):
    r"""
    Material Instance Constant Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialInstanceConstantFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MaterialParameterCollectionFactoryNew(Factory):
    r"""
    Material Parameter Collection Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MaterialParameterCollectionFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MirrorDataTableFactory(Factory):
    r"""
    Mirror Data Table Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: MirrorDataTableFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ModelExporterT3D(Exporter):
    r"""
    Model Exporter T3D
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ModelExporterT3D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class ModelFactory(Factory):
    r"""
    Model Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ModelFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NeuralProfileFactory(Factory):
    r"""
    Neural Profile Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: NeuralProfileFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ObjectExporterT3D(Exporter):
    r"""
    Object Exporter T3D
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ObjectExporterT3D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class ObjectLibraryFactory(Factory):
    r"""
    Object Library Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ObjectLibraryFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PackageFactory(Factory):
    r"""
    Package Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PackageFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PackageTools(Object):
    r"""
    Package Tools
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PackageTools.h
    
    """
    @classmethod
    def sanitize_package_name(cls, package_name: str) -> str:
        r"""
        X.sanitize_package_name(package_name) -> str
        Replaces all invalid package name characters with _
        
        Args:
            package_name (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def package_name_to_filename(cls, package_name: str, extension: str = "") -> str:
        r"""
        X.package_name_to_filename(package_name, extension="") -> str
        Converts a long package name to a file name.
        This can be called on package paths as well, provide no extension in that case.
        Will return an empty string if it fails.
        
        Args:
            package_name (str): Long Package Name
            extension (str): Package extension.
        
        Returns:
            str: Package filename, or empty if it failed.
        """
        ...
    @classmethod
    def filename_to_package_name(cls, filename: str) -> str:
        r"""
        X.filename_to_package_name(filename) -> str
        Tries to convert a given relative or absolute filename to a long package name or path starting with a root like /Game
        This works on both package names and directories, and it does not validate that it actually exists on disk.
        
        Args:
            filename (str): Filename to convert.
        
        Returns:
            str: Resulting long package name if the supplied filename properly maps to a long package root, empty string otherwise.
        """
        ...

class PackFactory(Factory):
    r"""
    Factory for unpacking upack files
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PackFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ParticleSystemFactoryNew(Factory):
    r"""
    Particle System Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ParticleSystemFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PhysicalMaterialFactoryNew(Factory):
    r"""
    Physical Material Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PhysicalMaterialFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``physical_material_class`` (type(Class)):  [Read-Write]
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PhysicalMaterialMaskFactory(Factory):
    r"""
    Physical Material Mask Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PhysicalMaterialMaskFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``physical_material_mask_class`` (type(Class)):  [Read-Write]
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PhysicsAssetFactory(Factory):
    r"""
    Physics Asset Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PhysicsAssetFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PolysExporterOBJ(Exporter):
    r"""
    Polys Exporter OBJ
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PolysExporterOBJ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class PolysExporterT3D(Exporter):
    r"""
    Polys Exporter T3D
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PolysExporterT3D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class PolysFactory(Factory):
    r"""
    Polys Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PolysFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PoseAssetFactory(Factory):
    r"""
    Pose Asset Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PoseAssetFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``pose_names`` (Array[str]):  [Read-Write] Optional. If specified the poses will be named according to this array.
            If you don't specify, or you don't specify enough names for all poses, then default names will be generated.
    - ``source_animation`` (AnimSequence):  [Read-Write] Used when creating a composite from an AnimSequence, becomes the only AnimSequence contained
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    @property
    def source_animation(self) -> AnimSequence:
        r"""
        (AnimSequence):  [Read-Write] Used when creating a composite from an AnimSequence, becomes the only AnimSequence contained
        """
        ...
    @source_animation.setter
    def source_animation(self, value: AnimSequence) -> None:
        ...
    @property
    def pose_names(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Optional. If specified the poses will be named according to this array.
              If you don't specify, or you don't specify enough names for all poses, then default names will be generated.
        """
        ...
    @pose_names.setter
    def pose_names(self, value: Array[str]) -> None:
        ...

class MaterialInterface(Object):
    r"""
    Material Interface
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Write] Importing data and options used for this material
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``lightmass_settings`` (LightmassMaterialInterfaceSettings):  [Read-Write] The Lightmass settings for this object.
    - ``neural_profile`` (NeuralProfile):  [Read-Write] Neural network profile. For internal usage, not editable/visible
    - ``preview_mesh`` (SoftObjectPath):  [Read-Write] The mesh used by the material editor to preview the material.
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Screen Space Subsurface Scattering..
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    @property
    def subsurface_profile(self) -> SubsurfaceProfile:
        r"""
        (SubsurfaceProfile):  [Read-Only] SubsurfaceProfile, for Screen Space Subsurface Scattering..
        """
        ...
    @property
    def neural_profile(self) -> NeuralProfile:
        r"""
        (NeuralProfile):  [Read-Only] Neural network profile. For internal usage, not editable/visible
        """
        ...
    def set_force_mip_levels_to_be_resident(self, override_force_miplevels_to_be_resident: bool, force_miplevels_to_be_resident_value: bool, force_duration: float, cinematic_texture_groups: int = 0, fast_response: bool = False) -> None:
        r"""
        x.set_force_mip_levels_to_be_resident(override_force_miplevels_to_be_resident, force_miplevels_to_be_resident_value, force_duration, cinematic_texture_groups=0, fast_response=False) -> None
        Force the streaming system to disregard the normal logic for the specified duration and
        instead always load all mip-levels for all textures used by this material.
        
        Args:
            override_force_miplevels_to_be_resident (bool): Whether to use (true) or ignore (false) the bForceMiplevelsToBeResidentValue parameter.
            force_miplevels_to_be_resident_value (bool): true forces all mips to stream in. false lets other factors decide what to do with the mips.
            force_duration (float): Number of seconds to keep all mip-levels in memory, disregarding the normal priority logic. Negative value turns it off.
            cinematic_texture_groups (int32): Bitfield indicating texture groups that should use extra high-resolution mips
            fast_response (bool): USE WITH EXTREME CAUTION! Fast response textures incur sizable GT overhead and disturb streaming metric calculation. Avoid whenever possible.
        """
        ...
    def get_physical_material_mask(self) -> PhysicalMaterialMask:
        r"""
        x.get_physical_material_mask() -> PhysicalMaterialMask
        Return a pointer to the physical material mask used by this material instance.
        
        Returns:
            PhysicalMaterialMask: The physical material.
        """
        ...
    def get_physical_material_from_map(self, index: int) -> PhysicalMaterial:
        r"""
        x.get_physical_material_from_map(index) -> PhysicalMaterial
        Return a pointer to the physical material from mask map at given index.
        
        Args:
            index (int32): 
        
        Returns:
            PhysicalMaterial: The physical material.
        """
        ...
    def get_physical_material(self) -> PhysicalMaterial:
        r"""
        x.get_physical_material() -> PhysicalMaterial
        Return a pointer to the physical material used by this material instance.
        
        Returns:
            PhysicalMaterial: The physical material.
        """
        ...
    def get_parameter_info(self, association: MaterialParameterAssociation, parameter_name: Name, layer_function: MaterialFunctionInterface) -> MaterialParameterInfo:
        r"""
        x.get_parameter_info(association, parameter_name, layer_function) -> MaterialParameterInfo
        Get Parameter Info
        
        Args:
            association (MaterialParameterAssociation): 
            parameter_name (Name): 
            layer_function (MaterialFunctionInterface): 
        
        Returns:
            MaterialParameterInfo:
        """
        ...
    def get_nanite_overide_material(self) -> MaterialInterface:
        r"""
        x.get_nanite_overide_material() -> MaterialInterface
        Get the associated nanite override material.
        
        Returns:
            MaterialInterface:
        """
        ...
    def get_blend_mode(self) -> BlendMode:
        r"""
        x.get_blend_mode() -> BlendMode
        Get Blend Mode
        
        Returns:
            BlendMode:
        """
        ...
    def get_base_material(self) -> Material:
        r"""
        x.get_base_material() -> Material
        Walks up parent chain and finds the base Material that this is an instance of. Just calls the virtual GetMaterial()
        
        Returns:
            Material:
        """
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class Material(MaterialInterface):
    r"""
    A Material is an asset which can be applied to a mesh to control the visual look of the scene.
    When light from the scene hits the surface, the shading model of the material is used to calculate how that light interacts with the surface.
    
    Warning: Creating new materials directly increases shader compile times!  Consider creating a Material Instance off of an existing material instead.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Material.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_front_layer_translucency`` (bool):  [Read-Write] Allows a translucent material to be used with Front Layer Translucency by compiling additional shaders. Useful for controlling what should be included in Front Layer Translucency.
    - ``allow_negative_emissive_color`` (bool):  [Read-Write] Whether the material should allow outputting negative emissive color values.  Only allowed on unlit materials.
    - ``allow_translucent_custom_depth_writes`` (bool):  [Read-Write] Allows a translucent material to be used with custom depth writing by compiling additional shaders.
    - ``allow_variable_rate_shading`` (bool):  [Read-Write] Allows the use of variable rate shading when evaluating this material. This will only apply to the base/translucency pass.
    - ``always_evaluate_world_position_offset`` (bool):  [Read-Write] Forces World Position Offset to always be evaluated for this material, even if the primitive it's applied to has disabled it
      via "Evaluate World Position Offset" or "World Position Offset Disable Distance".
    - ``apply_cloud_fogging`` (bool):  [Read-Write] When true, translucent materials receive cloud contribution as part of the fog evaluation, per vertex or per pixel according to the other selected options. This is a rough approximation but can help in some cases. Defaults to false. Fog is applied on clouds, so Apply Fogging must be true to use this feature.
    - ``asset_import_data`` (AssetImportData):  [Read-Write] Importing data and options used for this material
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``automatically_set_usage_in_editor`` (bool):  [Read-Write] Whether to automatically set usage flags based on what the material is applied to in the editor.
      It can be useful to disable this on a base material with many instances, where adding another usage flag accidentally (eg bUsedWithSkeletalMeshes) can add a lot of shader permutations.
    - ``blend_mode`` (BlendMode):  [Read-Write] Determines how the material's color is blended with background colors.
    - ``blendable_location`` (BlendableLocation):  [Read-Write] Where the node is inserted in the (post processing) graph, only used if domain is PostProcess
    - ``blendable_output_alpha`` (bool):  [Read-Write] If this is enabled, the blendable will output alpha
    - ``blendable_priority`` (int32):  [Read-Write] If multiple nodes with the same  type are inserted at the same point, this defined order and if they get combined, only used if domain is PostProcess
    - ``cast_dynamic_shadow_as_masked`` (bool):  [Read-Write] Whether the material should cast shadows as masked even though it has a translucent blend mode.
    - ``cast_ray_traced_shadows`` (bool):  [Read-Write] when true, the material casts ray tracing shadows.
    - ``compute_fog_per_pixel`` (bool):  [Read-Write] When true, translucent materials have fog computed for every pixel, which costs more but fixes artifacts due to low tessellation.
    - ``contact_shadows`` (bool):  [Read-Write] Contact shadows on translucency
    - ``decal_blend_mode`` (DecalBlendMode):  [Read-Write]
      deprecated: No longer used.
    - ``disable_depth_test`` (bool):  [Read-Write] Whether to draw on top of opaque pixels even if behind them. This only has meaning for translucency.
    - ``displacement_scaling`` (DisplacementScaling):  [Read-Write]
    - ``dither_opacity_mask`` (bool):  [Read-Write] Dither opacity mask. When combined with Temporal AA this can be used as a form of limited translucency which supports all lighting features.
    - ``dithered_lod_transition`` (bool):  [Read-Write] Whether meshes rendered with the material should support dithered LOD transitions.
    - ``enable_exec_wire`` (bool):  [Read-Write]
    - ``enable_mobile_separate_translucency`` (bool):  [Read-Write] Indicates that the translucent material should not be affected by bloom or DOF. (Note: Depth testing is not available)
    - ``enable_new_hlsl_generator`` (bool):  [Read-Write]
    - ``enable_responsive_aa`` (bool):  [Read-Write] Indicates that the material should be rendered using responsive anti-aliasing. Improves sharpness of small moving particles such as sparks.
      Only use for small moving features because it will cause aliasing of the background.
    - ``enable_stencil_test`` (bool):  [Read-Write] Selectively execute post process material only for pixels that pass the stencil test against the Custom Depth/Stencil buffer.
      Pixels that fail the stencil test are filled with the previous post process material output or scene color.
    - ``enable_tessellation`` (bool):  [Read-Write] Whether tessellation is enabled on the material. NOTE: Required for displacement to work.
    - ``float_precision_mode`` (MaterialFloatPrecisionMode):  [Read-Write] How to use full (highp) precision in the pixel shader.
      highp is slower than the default (mediump) but can be used to work around precision-related rendering errors.
      Use 'Full-precision for MaterialExpressions only' if you still want to keep the precision of the halfs in .ush/.usf
      This setting has no effect on older mobile devices that do not support high precision.
    - ``forward_blends_sky_light_cubemaps`` (bool):  [Read-Write] * Enables blending of sky light cubemap textures. When disabled, the secondary cubemap is only visible when the blend factor is 1.
    - ``forward_render_use_preintegrated_gf_for_simple_ibl`` (bool):  [Read-Write] Forward (including mobile) renderer: use preintegrated GF lut for simple IBL, but will use one more sampler.
    - ``fully_rough`` (bool):  [Read-Write] Forces the material to be completely rough. Saves a number of instructions and one sampler.
    - ``generate_spherical_particle_normals`` (bool):  [Read-Write] Whether to generate spherical normals for particles that use this material.
    - ``has_pixel_animation`` (bool):  [Read-Write] Whether the opaque material has any pixel animations happening, that isn't included in the geometric velocities.
      This allows to disable renderer's heuristics that assumes animation is fully described with motion vector, such as TSR's anti-flickering heuristic.
    - ``is_blendable`` (bool):  [Read-Write] Allows blendability to be turned off, only used if domain is PostProcess
    - ``is_sky`` (bool):  [Read-Write] Unlit and Opaque materials can be used as sky material on a sky dome mesh. When IsSky is true, these meshes will not receive any contribution from the aerial perspective. Height and Volumetric fog effects will still be applied.
    - ``is_thin_surface`` (bool):  [Read-Write] Indicates that the material should be rendered as a thin surface (i.e., without inner volume). Only used by Substrate materials. Enabling ThinSurface will disable subsurface profiles.
    - ``lightmass_settings`` (LightmassMaterialInterfaceSettings):  [Read-Write] The Lightmass settings for this object.
    - ``material_decal_response`` (MaterialDecalResponse):  [Read-Write] Defines how the material reacts on DBuffer decals (Affects look, performance and texture/sample usage).
      Non DBuffer Decals can be disabled on the primitive (e.g. static mesh)
    - ``material_domain`` (MaterialDomain):  [Read-Write] The domain that the material's attributes will be evaluated in.
      Certain pieces of material functionality are only valid in certain domains, for example vertex normal is only valid on a surface.
    - ``max_world_position_offset_displacement`` (float):  [Read-Write] Specifies the max world position offset of the material. Use this value to resolve issues with culling and self-occlusion caused by
      World Position Offset, and/or to restrict how much offset is permitted (i.e. values are clamped on each axis).
      NOTE: A value of 0.0 effectively means "no maximum", and will not clamp the offsets, however it will also not extend culling bounds.
    - ``mobile_enable_high_quality_brdf`` (bool):  [Read-Write] Use the high quality brdf functions on mobile to get better visual effects but adds GPU cost.
    - ``nanite_override_material`` (MaterialOverrideNanite):  [Read-Write] An override material which will be used instead of this one when rendering with Nanite.
    - ``neural_profile`` (NeuralProfile):  [Read-Write] Neural network profile. For internal usage, not editable/visible
    - ``neural_profile_id`` (int8):  [Read-Write] Set by reference object cannot be modified.
    - ``normal_curvature_to_roughness`` (bool):  [Read-Write] Reduce roughness based on screen space normal changes.
    - ``num_customized_u_vs`` (int32):  [Read-Write] Number of customized UV inputs to display.  Unconnected customized UV inputs will just pass through the vertex UVs.
    - ``opacity_mask_clip_value`` (float):  [Read-Write] If BlendMode is BLEND_Masked, the surface is not rendered where OpacityMask < OpacityMaskClipValue.
      If BlendMode is BLEND_Translucent, BLEND_Additive, or BLEND_Modulate, and "Output Depth and Velocity" is enabled,
      the object velocity is not rendered where Opacity < OpacityMaskClipValue.
    - ``output_translucent_velocity`` (bool):  [Read-Write] When true, translucent materials will output motion vectors and write to depth buffer in velocity pass.
    - ``parameter_group_data`` (Array[ParameterGroupData]):  [Read-Write]
      deprecated: GetEditorOnlyData().ParameterGroupData
    - ``phys_material`` (PhysicalMaterial):  [Read-Write] Physical material to use for this graphics material. Used for sounds, effects etc.
    - ``phys_material_mask`` (PhysicalMaterialMask):  [Read-Write] Physical material mask to use for this graphics material. Used for sounds, effects etc.
    - ``physical_material_map`` (PhysicalMaterial):  [Read-Write] Physical material mask map to use for this graphics material. Used for sounds, effects etc.
    - ``preshader_gap`` (uint16):  [Read-Write] If non-zero, overrides r.Material.PreshaderGapInterval for this material.  Workaround for a platform specific register overflow bug.
    - ``preview_mesh`` (SoftObjectPath):  [Read-Write] The mesh used by the material editor to preview the material.
    - ``refraction_coverage_mode`` (RefractionCoverageMode):  [Read-Write] Controls whether refraction takes into account the material surface coverage, or not.
    - ``refraction_depth_bias`` (float):  [Read-Write] This is the refraction depth bias, larger values offset distortion to prevent closer objects from rendering into the distorted surface at acute viewing angles but increases the disconnect between surface and where the refraction starts.
    - ``refraction_method`` (RefractionMode):  [Read-Write] Controls how the Refraction input is interpreted and how the refraction offset into scene color is computed for this material.
    - ``screen_space_reflections`` (bool):  [Read-Write] SSR on translucency
    - ``shading_model`` (MaterialShadingModel):  [Read-Write] Determines how inputs are combined to create the material's final color.
    - ``shading_rate`` (MaterialShadingRate):  [Read-Write] Select what shading rate to apply, on platforms that support variable rate shading.
      Non-1x1 rates will reduce the rasterization fidelity for the material; they will not super-sample the material.
      This can save GPU performance on materials where reduced fidelity is acceptable.
    - ``stencil_compare`` (MaterialStencilCompare):  [Read-Write]
    - ``stencil_ref_value`` (uint8):  [Read-Write]
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Screen Space Subsurface Scattering..
    - ``tangent_space_normal`` (bool):  [Read-Write] Whether the material takes a tangent space normal or a world space normal as input.
      (TangentSpace requires extra instructions but is often more convenient).
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``translucency_directional_lighting_intensity`` (float):  [Read-Write] Useful for artificially increasing the influence of the normal on the lighting result for translucency.
      A value larger than 1 increases the influence of the normal, a value smaller than 1 makes the lighting more ambient.
    - ``translucency_lighting_mode`` (TranslucencyLightingMode):  [Read-Write] Sets the lighting mode that will be used on this material if it is translucent.
    - ``translucency_pass`` (MaterialTranslucencyPass):  [Read-Write] Specifies the separate pass in which to render translucency.
      This can be used to avoid artifacts caused by certain post processing effects.
    - ``translucent_backscattering_exponent`` (float):  [Read-Write] Controls how diffuse the material's backscattering is when using the MSM_Subsurface shading model.
      Larger exponents give a less diffuse look (smaller, brighter backscattering highlight).
      This is only used when the object is casting a volumetric translucent shadow from a directional light.
    - ``translucent_multiple_scattering_extinction`` (LinearColor):  [Read-Write] Colored extinction factor used to approximate multiple scattering in dense volumes.
      This is only used when the object is casting a volumetric translucent shadow.
    - ``translucent_self_shadow_density_scale`` (float):  [Read-Write] Scale used to make translucent self-shadowing more or less opaque than the material's shadow on other objects.
      This is only used when the object is casting a volumetric translucent shadow.
    - ``translucent_self_shadow_second_density_scale`` (float):  [Read-Write] Used to make a second self shadow gradient, to add interesting shading in the shadow of the first.
    - ``translucent_self_shadow_second_opacity`` (float):  [Read-Write] Controls the strength of the second self shadow gradient.
    - ``translucent_shadow_density_scale`` (float):  [Read-Write] Scale used to make translucent shadows more or less opaque than the material's actual opacity.
    - ``translucent_shadow_start_offset`` (float):  [Read-Write] Local space distance to bias the translucent shadow.  Positive values move the shadow away from the light.
    - ``two_sided`` (bool):  [Read-Write] Indicates that the material should be rendered without backface culling and the normal should be flipped for backfaces.
    - ``use_alpha_to_coverage`` (bool):  [Read-Write] Use alpha to coverage for masked material on mobile, make sure MSAA is enabled as well.
    - ``use_emissive_for_dynamic_area_lighting`` (bool):  [Read-Write] If enabled, the material's emissive colour is injected into the LightPropagationVolume
    - ``use_hq_forward_reflections`` (bool):  [Read-Write] * Forward renderer: enables multiple parallax-corrected reflection captures that blend together.
    - ``use_lightmap_directionality`` (bool):  [Read-Write] Use lightmap directionality and per pixel normals. If disabled, lighting from lightmaps will be flat but cheaper.
    - ``use_material_attributes`` (bool):  [Read-Write] when true, the material attributes pin is used instead of the regular pins.
    - ``use_planar_forward_reflections`` (bool):  [Read-Write] Enables planar reflection when using the forward renderer or mobile. Enabling this setting reduces the number of samplers available to the material as one more sampler will be used for the planar reflection.
    - ``use_translucency_vertex_fog`` (bool):  [Read-Write] When true, translucent materials are fogged. Defaults to true.
    - ``used_shading_models`` (str):  [Read-Only] These are the shading models present in this material. Note that all these shading models might not be used in all feature levels and quality levels.
    - ``used_with_beam_trails`` (bool):  [Read-Write] Indicates that the material and its instances can be used with beam trails
      This will result in the shaders required to support beam trails being compiled which will increase shader compile time and memory usage.
    - ``used_with_clothing`` (bool):  [Read-Write] Indicates that the material and its instances can be used with clothing
      This will result in the shaders required to support clothing being compiled which will increase shader compile time and memory usage.
    - ``used_with_editor_compositing`` (bool):  [Read-Write] Indicates that the material and its instances can be used with editor compositing
      This will result in the shaders required to support editor compositing being compiled which will increase shader compile time and memory usage.
    - ``used_with_geometry_cache`` (bool):  [Read-Write]
    - ``used_with_geometry_collections`` (bool):  [Read-Write] Indicates that the material and its instances can be use with geometry collections
      This will result in the shaders required to support geometry collections being compiled which will increase shader compile time and memory usage.
    - ``used_with_hair_strands`` (bool):  [Read-Write] Indicates that the material and its instances can be use with hair strands
      This will result in the shaders required to support hair strands geometries being compiled which will increase shader compile time and memory usage.
    - ``used_with_heterogeneous_volumes`` (bool):  [Read-Write] Indicates that the material and its instances with heterogeneous volumes. Without that flag, it can only be used on volumetric fog.
      This will result in the shaders required to support Heterogeneous Volumes rendering being compiled which will increase shader compile time and memory usage.
    - ``used_with_instanced_static_meshes`` (bool):  [Read-Write] Indicates that the material and its instances can be used with instanced static meshes
      This will result in the shaders required to support instanced static meshes being compiled which will increase shader compile time and memory usage.
    - ``used_with_lidar_point_cloud`` (bool):  [Read-Write] Indicates that the material and its instances can be use with LiDAR Point Clouds
      This will result in the shaders required to support LiDAR Point Cloud geometries being compiled which will increase shader compile time and memory usage.
    - ``used_with_mesh_particles`` (bool):  [Read-Write] Indicates that the material and its instances can be used with mesh particles
      This will result in the shaders required to support mesh particles being compiled which will increase shader compile time and memory usage.
    - ``used_with_morph_targets`` (bool):  [Read-Write] Indicates that the material and its instances can be used with morph targets
      This will result in the shaders required to support morph targets being compiled which will increase shader compile time and memory usage.
    - ``used_with_nanite`` (bool):  [Read-Write] Indicates that the material and its instances can be used with Nanite meshes.
      This will result in the shaders required to support Nanite geometries being compiled which will increase shader compile time and memory usage.
    - ``used_with_neural_networks`` (bool):  [Read-Write] Indicates that the material and its instances can be used with neural network engine.
      This will result in the shaders required to support neural network engine being compiled which will increase shader compile time and memory usage.
      In addition, an additional pass will run before the postprocess pass for neural network engine, which will increase the rendering cost due to
      buffer copy and inference.
    - ``used_with_niagara_mesh_particles`` (bool):  [Read-Write]
    - ``used_with_niagara_ribbons`` (bool):  [Read-Write]
    - ``used_with_niagara_sprites`` (bool):  [Read-Write] Indicates that the material and its instances can be used with Niagara sprites (meshes and ribbons, respectively)
      This will result in the shaders required to support Niagara sprites being compiled which will increase shader compile time and memory usage.
    - ``used_with_particle_sprites`` (bool):  [Read-Write] Indicates that the material and its instances can be used with particle sprites
      This will result in the shaders required to support particle sprites being compiled which will increase shader compile time and memory usage.
    - ``used_with_skeletal_mesh`` (bool):  [Read-Write] Indicates that the material and its instances can be used with skeletal meshes.
      This will result in the shaders required to support skeletal meshes being compiled which will increase shader compile time and memory usage.
    - ``used_with_spline_meshes`` (bool):  [Read-Write] Indicates that the material and its instances can be used with spline meshes
      This will result in the shaders required to support spline meshes being compiled which will increase shader compile time and memory usage.
    - ``used_with_static_lighting`` (bool):  [Read-Write] Indicates that the material and its instances can be used with static lighting
      This will result in the shaders required to support static lighting being compiled which will increase shader compile time and memory usage.
    - ``used_with_virtual_heightfield_mesh`` (bool):  [Read-Write] Indicates that the material and its instances can be used with Virtual Heightfield Mesh.
      This will result in the shaders required to support Virtual Heightfield Mesh geometries being compiled which will increase shader compile time and memory usage.
    - ``used_with_volumetric_cloud`` (bool):  [Read-Write] Indicates that the material and its instances with volumetric cloud. Without that flag, it can only be used on volumetric fog.
      This will result in the shaders required to support Volumetric Cloud rendering being compiled which will increase shader compile time and memory usage.
    - ``used_with_water`` (bool):  [Read-Write] Indicates that the material and its instances can be use with water
      This will result in the shaders required to support water meshes being compiled which will increase shader compile time and memory usage.
    - ``wireframe`` (bool):  [Read-Write] Enables a wireframe view of the mesh the material is applied to.
    - ``write_only_alpha`` (bool):  [Read-Write] Whether the transluency pass should write its alpha, and only the alpha, into the framebuffer
    """
    @property
    def material_domain(self) -> MaterialDomain:
        r"""
        (MaterialDomain):  [Read-Only] The domain that the material's attributes will be evaluated in.
        Certain pieces of material functionality are only valid in certain domains, for example vertex normal is only valid on a surface.
        """
        ...
    @property
    def blend_mode(self) -> BlendMode:
        r"""
        (BlendMode):  [Read-Only] Determines how the material's color is blended with background colors.
        """
        ...
    @property
    def decal_blend_mode(self) -> DecalBlendMode:
        r"""
        (DecalBlendMode):  [Read-Write]
        deprecated: No longer used.
        """
        ...
    @decal_blend_mode.setter
    def decal_blend_mode(self, value: DecalBlendMode) -> None:
        ...
    @property
    def material_decal_response(self) -> MaterialDecalResponse:
        r"""
        (MaterialDecalResponse):  [Read-Only] Defines how the material reacts on DBuffer decals (Affects look, performance and texture/sample usage).
        Non DBuffer Decals can be disabled on the primitive (e.g. static mesh)
        """
        ...
    @property
    def displacement_scaling(self) -> DisplacementScaling:
        r"""
        (DisplacementScaling):  [Read-Write]
        """
        ...
    @displacement_scaling.setter
    def displacement_scaling(self, value: DisplacementScaling) -> None:
        ...
    @property
    def use_emissive_for_dynamic_area_lighting(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the material's emissive colour is injected into the LightPropagationVolume
        """
        ...
    @use_emissive_for_dynamic_area_lighting.setter
    def use_emissive_for_dynamic_area_lighting(self, value: bool) -> None:
        ...
    @property
    def used_with_skeletal_mesh(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with skeletal meshes.
        This will result in the shaders required to support skeletal meshes being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_editor_compositing(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with editor compositing
        This will result in the shaders required to support editor compositing being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_particle_sprites(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with particle sprites
        This will result in the shaders required to support particle sprites being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_beam_trails(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with beam trails
        This will result in the shaders required to support beam trails being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_mesh_particles(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with mesh particles
        This will result in the shaders required to support mesh particles being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_niagara_sprites(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with Niagara sprites (meshes and ribbons, respectively)
        This will result in the shaders required to support Niagara sprites being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_niagara_ribbons(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def used_with_niagara_mesh_particles(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def used_with_geometry_cache(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def used_with_static_lighting(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with static lighting
        This will result in the shaders required to support static lighting being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_morph_targets(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with morph targets
        This will result in the shaders required to support morph targets being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_spline_meshes(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with spline meshes
        This will result in the shaders required to support spline meshes being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_instanced_static_meshes(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with instanced static meshes
        This will result in the shaders required to support instanced static meshes being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_geometry_collections(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be use with geometry collections
        This will result in the shaders required to support geometry collections being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_clothing(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with clothing
        This will result in the shaders required to support clothing being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_water(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be use with water
        This will result in the shaders required to support water meshes being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_hair_strands(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be use with hair strands
        This will result in the shaders required to support hair strands geometries being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_lidar_point_cloud(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be use with LiDAR Point Clouds
        This will result in the shaders required to support LiDAR Point Cloud geometries being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_virtual_heightfield_mesh(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with Virtual Heightfield Mesh.
        This will result in the shaders required to support Virtual Heightfield Mesh geometries being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_nanite(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances can be used with Nanite meshes.
        This will result in the shaders required to support Nanite geometries being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_volumetric_cloud(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances with volumetric cloud. Without that flag, it can only be used on volumetric fog.
        This will result in the shaders required to support Volumetric Cloud rendering being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def used_with_heterogeneous_volumes(self) -> bool:
        r"""
        (bool):  [Read-Only] Indicates that the material and its instances with heterogeneous volumes. Without that flag, it can only be used on volumetric fog.
        This will result in the shaders required to support Heterogeneous Volumes rendering being compiled which will increase shader compile time and memory usage.
        """
        ...
    @property
    def automatically_set_usage_in_editor(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to automatically set usage flags based on what the material is applied to in the editor.
        It can be useful to disable this on a base material with many instances, where adding another usage flag accidentally (eg bUsedWithSkeletalMeshes) can add a lot of shader permutations.
        """
        ...
    @property
    def fully_rough(self) -> bool:
        r"""
        (bool):  [Read-Only] Forces the material to be completely rough. Saves a number of instructions and one sampler.
        """
        ...
    @property
    def float_precision_mode(self) -> MaterialFloatPrecisionMode:
        r"""
        (MaterialFloatPrecisionMode):  [Read-Only] How to use full (highp) precision in the pixel shader.
        highp is slower than the default (mediump) but can be used to work around precision-related rendering errors.
        Use 'Full-precision for MaterialExpressions only' if you still want to keep the precision of the halfs in .ush/.usf
        This setting has no effect on older mobile devices that do not support high precision.
        """
        ...
    @property
    def use_lightmap_directionality(self) -> bool:
        r"""
        (bool):  [Read-Only] Use lightmap directionality and per pixel normals. If disabled, lighting from lightmaps will be flat but cheaper.
        """
        ...
    @property
    def mobile_enable_high_quality_brdf(self) -> bool:
        r"""
        (bool):  [Read-Only] Use the high quality brdf functions on mobile to get better visual effects but adds GPU cost.
        """
        ...
    @property
    def use_alpha_to_coverage(self) -> bool:
        r"""
        (bool):  [Read-Only] Use alpha to coverage for masked material on mobile, make sure MSAA is enabled as well.
        """
        ...
    @property
    def forward_render_use_preintegrated_gf_for_simple_ibl(self) -> bool:
        r"""
        (bool):  [Read-Only] Forward (including mobile) renderer: use preintegrated GF lut for simple IBL, but will use one more sampler.
        """
        ...
    @property
    def use_hq_forward_reflections(self) -> bool:
        r"""
        (bool):  [Read-Only] * Forward renderer: enables multiple parallax-corrected reflection captures that blend together.
        """
        ...
    @property
    def forward_blends_sky_light_cubemaps(self) -> bool:
        r"""
        (bool):  [Read-Only] * Enables blending of sky light cubemap textures. When disabled, the secondary cubemap is only visible when the blend factor is 1.
        """
        ...
    @property
    def use_planar_forward_reflections(self) -> bool:
        r"""
        (bool):  [Read-Only] Enables planar reflection when using the forward renderer or mobile. Enabling this setting reduces the number of samplers available to the material as one more sampler will be used for the planar reflection.
        """
        ...
    @property
    def normal_curvature_to_roughness(self) -> bool:
        r"""
        (bool):  [Read-Only] Reduce roughness based on screen space normal changes.
        """
        ...
    @property
    def blendable_location(self) -> BlendableLocation:
        r"""
        (BlendableLocation):  [Read-Write] Where the node is inserted in the (post processing) graph, only used if domain is PostProcess
        """
        ...
    @blendable_location.setter
    def blendable_location(self, value: BlendableLocation) -> None:
        ...
    @property
    def blendable_output_alpha(self) -> bool:
        r"""
        (bool):  [Read-Write] If this is enabled, the blendable will output alpha
        """
        ...
    @blendable_output_alpha.setter
    def blendable_output_alpha(self, value: bool) -> None:
        ...
    @property
    def blendable_priority(self) -> int:
        r"""
        (int32):  [Read-Write] If multiple nodes with the same  type are inserted at the same point, this defined order and if they get combined, only used if domain is PostProcess
        """
        ...
    @blendable_priority.setter
    def blendable_priority(self, value: int) -> None:
        ...
    @property
    def is_blendable(self) -> bool:
        r"""
        (bool):  [Read-Write] Allows blendability to be turned off, only used if domain is PostProcess
        """
        ...
    @is_blendable.setter
    def is_blendable(self, value: bool) -> None:
        ...
    @property
    def max_world_position_offset_displacement(self) -> float:
        r"""
        (float):  [Read-Write] Specifies the max world position offset of the material. Use this value to resolve issues with culling and self-occlusion caused by
        World Position Offset, and/or to restrict how much offset is permitted (i.e. values are clamped on each axis).
        NOTE: A value of 0.0 effectively means "no maximum", and will not clamp the offsets, however it will also not extend culling bounds.
        """
        ...
    @max_world_position_offset_displacement.setter
    def max_world_position_offset_displacement(self, value: float) -> None:
        ...
    @property
    def max_world_position_offset_distance(self) -> float:
        r"""
        deprecated: 'max_world_position_offset_distance' was renamed to 'max_world_position_offset_displacement'.
        """
        ...
    @max_world_position_offset_distance.setter
    def max_world_position_offset_distance(self, value: float) -> None:
        ...
    @property
    def always_evaluate_world_position_offset(self) -> bool:
        r"""
        (bool):  [Read-Write] Forces World Position Offset to always be evaluated for this material, even if the primitive it's applied to has disabled it
        via "Evaluate World Position Offset" or "World Position Offset Disable Distance".
        """
        ...
    @always_evaluate_world_position_offset.setter
    def always_evaluate_world_position_offset(self, value: bool) -> None:
        ...
    @property
    def parameter_group_data(self) -> Array[ParameterGroupData]:
        r"""
        (Array[ParameterGroupData]):  [Read-Write]
        deprecated: GetEditorOnlyData().ParameterGroupData
        """
        ...
    @parameter_group_data.setter
    def parameter_group_data(self, value: Array[ParameterGroupData]) -> None:
        ...

class PreviewMaterial(Material):
    r"""
    Preview Material
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PreviewMaterial.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_front_layer_translucency`` (bool):  [Read-Write] Allows a translucent material to be used with Front Layer Translucency by compiling additional shaders. Useful for controlling what should be included in Front Layer Translucency.
    - ``allow_negative_emissive_color`` (bool):  [Read-Write] Whether the material should allow outputting negative emissive color values.  Only allowed on unlit materials.
    - ``allow_translucent_custom_depth_writes`` (bool):  [Read-Write] Allows a translucent material to be used with custom depth writing by compiling additional shaders.
    - ``allow_variable_rate_shading`` (bool):  [Read-Write] Allows the use of variable rate shading when evaluating this material. This will only apply to the base/translucency pass.
    - ``always_evaluate_world_position_offset`` (bool):  [Read-Write] Forces World Position Offset to always be evaluated for this material, even if the primitive it's applied to has disabled it
      via "Evaluate World Position Offset" or "World Position Offset Disable Distance".
    - ``apply_cloud_fogging`` (bool):  [Read-Write] When true, translucent materials receive cloud contribution as part of the fog evaluation, per vertex or per pixel according to the other selected options. This is a rough approximation but can help in some cases. Defaults to false. Fog is applied on clouds, so Apply Fogging must be true to use this feature.
    - ``asset_import_data`` (AssetImportData):  [Read-Write] Importing data and options used for this material
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``automatically_set_usage_in_editor`` (bool):  [Read-Write] Whether to automatically set usage flags based on what the material is applied to in the editor.
      It can be useful to disable this on a base material with many instances, where adding another usage flag accidentally (eg bUsedWithSkeletalMeshes) can add a lot of shader permutations.
    - ``blend_mode`` (BlendMode):  [Read-Write] Determines how the material's color is blended with background colors.
    - ``blendable_location`` (BlendableLocation):  [Read-Write] Where the node is inserted in the (post processing) graph, only used if domain is PostProcess
    - ``blendable_output_alpha`` (bool):  [Read-Write] If this is enabled, the blendable will output alpha
    - ``blendable_priority`` (int32):  [Read-Write] If multiple nodes with the same  type are inserted at the same point, this defined order and if they get combined, only used if domain is PostProcess
    - ``cast_dynamic_shadow_as_masked`` (bool):  [Read-Write] Whether the material should cast shadows as masked even though it has a translucent blend mode.
    - ``cast_ray_traced_shadows`` (bool):  [Read-Write] when true, the material casts ray tracing shadows.
    - ``compute_fog_per_pixel`` (bool):  [Read-Write] When true, translucent materials have fog computed for every pixel, which costs more but fixes artifacts due to low tessellation.
    - ``contact_shadows`` (bool):  [Read-Write] Contact shadows on translucency
    - ``decal_blend_mode`` (DecalBlendMode):  [Read-Write]
      deprecated: No longer used.
    - ``disable_depth_test`` (bool):  [Read-Write] Whether to draw on top of opaque pixels even if behind them. This only has meaning for translucency.
    - ``displacement_scaling`` (DisplacementScaling):  [Read-Write]
    - ``dither_opacity_mask`` (bool):  [Read-Write] Dither opacity mask. When combined with Temporal AA this can be used as a form of limited translucency which supports all lighting features.
    - ``dithered_lod_transition`` (bool):  [Read-Write] Whether meshes rendered with the material should support dithered LOD transitions.
    - ``enable_exec_wire`` (bool):  [Read-Write]
    - ``enable_mobile_separate_translucency`` (bool):  [Read-Write] Indicates that the translucent material should not be affected by bloom or DOF. (Note: Depth testing is not available)
    - ``enable_new_hlsl_generator`` (bool):  [Read-Write]
    - ``enable_responsive_aa`` (bool):  [Read-Write] Indicates that the material should be rendered using responsive anti-aliasing. Improves sharpness of small moving particles such as sparks.
      Only use for small moving features because it will cause aliasing of the background.
    - ``enable_stencil_test`` (bool):  [Read-Write] Selectively execute post process material only for pixels that pass the stencil test against the Custom Depth/Stencil buffer.
      Pixels that fail the stencil test are filled with the previous post process material output or scene color.
    - ``enable_tessellation`` (bool):  [Read-Write] Whether tessellation is enabled on the material. NOTE: Required for displacement to work.
    - ``float_precision_mode`` (MaterialFloatPrecisionMode):  [Read-Write] How to use full (highp) precision in the pixel shader.
      highp is slower than the default (mediump) but can be used to work around precision-related rendering errors.
      Use 'Full-precision for MaterialExpressions only' if you still want to keep the precision of the halfs in .ush/.usf
      This setting has no effect on older mobile devices that do not support high precision.
    - ``forward_blends_sky_light_cubemaps`` (bool):  [Read-Write] * Enables blending of sky light cubemap textures. When disabled, the secondary cubemap is only visible when the blend factor is 1.
    - ``forward_render_use_preintegrated_gf_for_simple_ibl`` (bool):  [Read-Write] Forward (including mobile) renderer: use preintegrated GF lut for simple IBL, but will use one more sampler.
    - ``fully_rough`` (bool):  [Read-Write] Forces the material to be completely rough. Saves a number of instructions and one sampler.
    - ``generate_spherical_particle_normals`` (bool):  [Read-Write] Whether to generate spherical normals for particles that use this material.
    - ``has_pixel_animation`` (bool):  [Read-Write] Whether the opaque material has any pixel animations happening, that isn't included in the geometric velocities.
      This allows to disable renderer's heuristics that assumes animation is fully described with motion vector, such as TSR's anti-flickering heuristic.
    - ``is_blendable`` (bool):  [Read-Write] Allows blendability to be turned off, only used if domain is PostProcess
    - ``is_sky`` (bool):  [Read-Write] Unlit and Opaque materials can be used as sky material on a sky dome mesh. When IsSky is true, these meshes will not receive any contribution from the aerial perspective. Height and Volumetric fog effects will still be applied.
    - ``is_thin_surface`` (bool):  [Read-Write] Indicates that the material should be rendered as a thin surface (i.e., without inner volume). Only used by Substrate materials. Enabling ThinSurface will disable subsurface profiles.
    - ``lightmass_settings`` (LightmassMaterialInterfaceSettings):  [Read-Write] The Lightmass settings for this object.
    - ``material_decal_response`` (MaterialDecalResponse):  [Read-Write] Defines how the material reacts on DBuffer decals (Affects look, performance and texture/sample usage).
      Non DBuffer Decals can be disabled on the primitive (e.g. static mesh)
    - ``material_domain`` (MaterialDomain):  [Read-Write] The domain that the material's attributes will be evaluated in.
      Certain pieces of material functionality are only valid in certain domains, for example vertex normal is only valid on a surface.
    - ``max_world_position_offset_displacement`` (float):  [Read-Write] Specifies the max world position offset of the material. Use this value to resolve issues with culling and self-occlusion caused by
      World Position Offset, and/or to restrict how much offset is permitted (i.e. values are clamped on each axis).
      NOTE: A value of 0.0 effectively means "no maximum", and will not clamp the offsets, however it will also not extend culling bounds.
    - ``mobile_enable_high_quality_brdf`` (bool):  [Read-Write] Use the high quality brdf functions on mobile to get better visual effects but adds GPU cost.
    - ``nanite_override_material`` (MaterialOverrideNanite):  [Read-Write] An override material which will be used instead of this one when rendering with Nanite.
    - ``neural_profile`` (NeuralProfile):  [Read-Write] Neural network profile. For internal usage, not editable/visible
    - ``neural_profile_id`` (int8):  [Read-Write] Set by reference object cannot be modified.
    - ``normal_curvature_to_roughness`` (bool):  [Read-Write] Reduce roughness based on screen space normal changes.
    - ``num_customized_u_vs`` (int32):  [Read-Write] Number of customized UV inputs to display.  Unconnected customized UV inputs will just pass through the vertex UVs.
    - ``opacity_mask_clip_value`` (float):  [Read-Write] If BlendMode is BLEND_Masked, the surface is not rendered where OpacityMask < OpacityMaskClipValue.
      If BlendMode is BLEND_Translucent, BLEND_Additive, or BLEND_Modulate, and "Output Depth and Velocity" is enabled,
      the object velocity is not rendered where Opacity < OpacityMaskClipValue.
    - ``output_translucent_velocity`` (bool):  [Read-Write] When true, translucent materials will output motion vectors and write to depth buffer in velocity pass.
    - ``parameter_group_data`` (Array[ParameterGroupData]):  [Read-Write]
      deprecated: GetEditorOnlyData().ParameterGroupData
    - ``phys_material`` (PhysicalMaterial):  [Read-Write] Physical material to use for this graphics material. Used for sounds, effects etc.
    - ``phys_material_mask`` (PhysicalMaterialMask):  [Read-Write] Physical material mask to use for this graphics material. Used for sounds, effects etc.
    - ``physical_material_map`` (PhysicalMaterial):  [Read-Write] Physical material mask map to use for this graphics material. Used for sounds, effects etc.
    - ``preshader_gap`` (uint16):  [Read-Write] If non-zero, overrides r.Material.PreshaderGapInterval for this material.  Workaround for a platform specific register overflow bug.
    - ``preview_mesh`` (SoftObjectPath):  [Read-Write] The mesh used by the material editor to preview the material.
    - ``refraction_coverage_mode`` (RefractionCoverageMode):  [Read-Write] Controls whether refraction takes into account the material surface coverage, or not.
    - ``refraction_depth_bias`` (float):  [Read-Write] This is the refraction depth bias, larger values offset distortion to prevent closer objects from rendering into the distorted surface at acute viewing angles but increases the disconnect between surface and where the refraction starts.
    - ``refraction_method`` (RefractionMode):  [Read-Write] Controls how the Refraction input is interpreted and how the refraction offset into scene color is computed for this material.
    - ``screen_space_reflections`` (bool):  [Read-Write] SSR on translucency
    - ``shading_model`` (MaterialShadingModel):  [Read-Write] Determines how inputs are combined to create the material's final color.
    - ``shading_rate`` (MaterialShadingRate):  [Read-Write] Select what shading rate to apply, on platforms that support variable rate shading.
      Non-1x1 rates will reduce the rasterization fidelity for the material; they will not super-sample the material.
      This can save GPU performance on materials where reduced fidelity is acceptable.
    - ``stencil_compare`` (MaterialStencilCompare):  [Read-Write]
    - ``stencil_ref_value`` (uint8):  [Read-Write]
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Screen Space Subsurface Scattering..
    - ``tangent_space_normal`` (bool):  [Read-Write] Whether the material takes a tangent space normal or a world space normal as input.
      (TangentSpace requires extra instructions but is often more convenient).
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``translucency_directional_lighting_intensity`` (float):  [Read-Write] Useful for artificially increasing the influence of the normal on the lighting result for translucency.
      A value larger than 1 increases the influence of the normal, a value smaller than 1 makes the lighting more ambient.
    - ``translucency_lighting_mode`` (TranslucencyLightingMode):  [Read-Write] Sets the lighting mode that will be used on this material if it is translucent.
    - ``translucency_pass`` (MaterialTranslucencyPass):  [Read-Write] Specifies the separate pass in which to render translucency.
      This can be used to avoid artifacts caused by certain post processing effects.
    - ``translucent_backscattering_exponent`` (float):  [Read-Write] Controls how diffuse the material's backscattering is when using the MSM_Subsurface shading model.
      Larger exponents give a less diffuse look (smaller, brighter backscattering highlight).
      This is only used when the object is casting a volumetric translucent shadow from a directional light.
    - ``translucent_multiple_scattering_extinction`` (LinearColor):  [Read-Write] Colored extinction factor used to approximate multiple scattering in dense volumes.
      This is only used when the object is casting a volumetric translucent shadow.
    - ``translucent_self_shadow_density_scale`` (float):  [Read-Write] Scale used to make translucent self-shadowing more or less opaque than the material's shadow on other objects.
      This is only used when the object is casting a volumetric translucent shadow.
    - ``translucent_self_shadow_second_density_scale`` (float):  [Read-Write] Used to make a second self shadow gradient, to add interesting shading in the shadow of the first.
    - ``translucent_self_shadow_second_opacity`` (float):  [Read-Write] Controls the strength of the second self shadow gradient.
    - ``translucent_shadow_density_scale`` (float):  [Read-Write] Scale used to make translucent shadows more or less opaque than the material's actual opacity.
    - ``translucent_shadow_start_offset`` (float):  [Read-Write] Local space distance to bias the translucent shadow.  Positive values move the shadow away from the light.
    - ``two_sided`` (bool):  [Read-Write] Indicates that the material should be rendered without backface culling and the normal should be flipped for backfaces.
    - ``use_alpha_to_coverage`` (bool):  [Read-Write] Use alpha to coverage for masked material on mobile, make sure MSAA is enabled as well.
    - ``use_emissive_for_dynamic_area_lighting`` (bool):  [Read-Write] If enabled, the material's emissive colour is injected into the LightPropagationVolume
    - ``use_hq_forward_reflections`` (bool):  [Read-Write] * Forward renderer: enables multiple parallax-corrected reflection captures that blend together.
    - ``use_lightmap_directionality`` (bool):  [Read-Write] Use lightmap directionality and per pixel normals. If disabled, lighting from lightmaps will be flat but cheaper.
    - ``use_material_attributes`` (bool):  [Read-Write] when true, the material attributes pin is used instead of the regular pins.
    - ``use_planar_forward_reflections`` (bool):  [Read-Write] Enables planar reflection when using the forward renderer or mobile. Enabling this setting reduces the number of samplers available to the material as one more sampler will be used for the planar reflection.
    - ``use_translucency_vertex_fog`` (bool):  [Read-Write] When true, translucent materials are fogged. Defaults to true.
    - ``used_shading_models`` (str):  [Read-Only] These are the shading models present in this material. Note that all these shading models might not be used in all feature levels and quality levels.
    - ``used_with_beam_trails`` (bool):  [Read-Write] Indicates that the material and its instances can be used with beam trails
      This will result in the shaders required to support beam trails being compiled which will increase shader compile time and memory usage.
    - ``used_with_clothing`` (bool):  [Read-Write] Indicates that the material and its instances can be used with clothing
      This will result in the shaders required to support clothing being compiled which will increase shader compile time and memory usage.
    - ``used_with_editor_compositing`` (bool):  [Read-Write] Indicates that the material and its instances can be used with editor compositing
      This will result in the shaders required to support editor compositing being compiled which will increase shader compile time and memory usage.
    - ``used_with_geometry_cache`` (bool):  [Read-Write]
    - ``used_with_geometry_collections`` (bool):  [Read-Write] Indicates that the material and its instances can be use with geometry collections
      This will result in the shaders required to support geometry collections being compiled which will increase shader compile time and memory usage.
    - ``used_with_hair_strands`` (bool):  [Read-Write] Indicates that the material and its instances can be use with hair strands
      This will result in the shaders required to support hair strands geometries being compiled which will increase shader compile time and memory usage.
    - ``used_with_heterogeneous_volumes`` (bool):  [Read-Write] Indicates that the material and its instances with heterogeneous volumes. Without that flag, it can only be used on volumetric fog.
      This will result in the shaders required to support Heterogeneous Volumes rendering being compiled which will increase shader compile time and memory usage.
    - ``used_with_instanced_static_meshes`` (bool):  [Read-Write] Indicates that the material and its instances can be used with instanced static meshes
      This will result in the shaders required to support instanced static meshes being compiled which will increase shader compile time and memory usage.
    - ``used_with_lidar_point_cloud`` (bool):  [Read-Write] Indicates that the material and its instances can be use with LiDAR Point Clouds
      This will result in the shaders required to support LiDAR Point Cloud geometries being compiled which will increase shader compile time and memory usage.
    - ``used_with_mesh_particles`` (bool):  [Read-Write] Indicates that the material and its instances can be used with mesh particles
      This will result in the shaders required to support mesh particles being compiled which will increase shader compile time and memory usage.
    - ``used_with_morph_targets`` (bool):  [Read-Write] Indicates that the material and its instances can be used with morph targets
      This will result in the shaders required to support morph targets being compiled which will increase shader compile time and memory usage.
    - ``used_with_nanite`` (bool):  [Read-Write] Indicates that the material and its instances can be used with Nanite meshes.
      This will result in the shaders required to support Nanite geometries being compiled which will increase shader compile time and memory usage.
    - ``used_with_neural_networks`` (bool):  [Read-Write] Indicates that the material and its instances can be used with neural network engine.
      This will result in the shaders required to support neural network engine being compiled which will increase shader compile time and memory usage.
      In addition, an additional pass will run before the postprocess pass for neural network engine, which will increase the rendering cost due to
      buffer copy and inference.
    - ``used_with_niagara_mesh_particles`` (bool):  [Read-Write]
    - ``used_with_niagara_ribbons`` (bool):  [Read-Write]
    - ``used_with_niagara_sprites`` (bool):  [Read-Write] Indicates that the material and its instances can be used with Niagara sprites (meshes and ribbons, respectively)
      This will result in the shaders required to support Niagara sprites being compiled which will increase shader compile time and memory usage.
    - ``used_with_particle_sprites`` (bool):  [Read-Write] Indicates that the material and its instances can be used with particle sprites
      This will result in the shaders required to support particle sprites being compiled which will increase shader compile time and memory usage.
    - ``used_with_skeletal_mesh`` (bool):  [Read-Write] Indicates that the material and its instances can be used with skeletal meshes.
      This will result in the shaders required to support skeletal meshes being compiled which will increase shader compile time and memory usage.
    - ``used_with_spline_meshes`` (bool):  [Read-Write] Indicates that the material and its instances can be used with spline meshes
      This will result in the shaders required to support spline meshes being compiled which will increase shader compile time and memory usage.
    - ``used_with_static_lighting`` (bool):  [Read-Write] Indicates that the material and its instances can be used with static lighting
      This will result in the shaders required to support static lighting being compiled which will increase shader compile time and memory usage.
    - ``used_with_virtual_heightfield_mesh`` (bool):  [Read-Write] Indicates that the material and its instances can be used with Virtual Heightfield Mesh.
      This will result in the shaders required to support Virtual Heightfield Mesh geometries being compiled which will increase shader compile time and memory usage.
    - ``used_with_volumetric_cloud`` (bool):  [Read-Write] Indicates that the material and its instances with volumetric cloud. Without that flag, it can only be used on volumetric fog.
      This will result in the shaders required to support Volumetric Cloud rendering being compiled which will increase shader compile time and memory usage.
    - ``used_with_water`` (bool):  [Read-Write] Indicates that the material and its instances can be use with water
      This will result in the shaders required to support water meshes being compiled which will increase shader compile time and memory usage.
    - ``wireframe`` (bool):  [Read-Write] Enables a wireframe view of the mesh the material is applied to.
    - ``write_only_alpha`` (bool):  [Read-Write] Whether the transluency pass should write its alpha, and only the alpha, into the framebuffer
    """
    ...

class PreviewMeshCollectionFactory(Factory):
    r"""
    Preview Mesh Collection Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PreviewMeshCollectionFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PropertyEditorTestObject(Object):
    r"""
    Property Editor Test Object
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_property_array`` (Array[Actor]):  [Read-Write]
    - ``actor_set`` (Set[Actor]):  [Read-Write]
    - ``actor_with_meta_class`` (SoftObjectPath):  [Read-Write]
    - ``always_disabled`` (int32):  [Read-Write]
    - ``anim_class_interface`` (AnimClassInterface):  [Read-Write]
    - ``any_material_interface`` (MaterialInterface):  [Read-Write]
    - ``array_of_edit_inline_new_sm_cs`` (Array[StaticMeshComponent]):  [Read-Write]
    - ``array_of_structs`` (Array[PropertyEditorTestBasicStruct]):  [Read-Write]
    - ``array_of_structs_with_edit_condition`` (Array[PropertyEditorTestBasicStruct]):  [Read-Write]
    - ``array_of_structs_with_inline_condition`` (Array[PropertyEditorTestEditCondition]):  [Read-Write]
    - ``array_with_edit_condition`` (Array[Texture2D]):  [Read-Write]
    - ``asset_pointer_with_allowed_and_whitespace`` (Object):  [Read-Write]
    - ``asset_reference_custom_struct_with_edit_condition`` (SoftObjectPath):  [Read-Write]
    - ``asset_reference_custom_struct_with_thumbnail`` (SoftObjectPath):  [Read-Write]
    - ``blendable_interface`` (BlendableInterface):  [Read-Write]
    - ``bool_property`` (bool):  [Read-Write]
    - ``bool_property_array`` (Array[bool]):  [Read-Write]
    - ``byte_property`` (uint8):  [Read-Write]
    - ``byte_property_array`` (Array[uint8]):  [Read-Write] Byte
    - ``category_inline_edit_condition`` (bool):  [Read-Write]
    - ``class_property`` (type(Class)):  [Read-Write]
    - ``class_property_with_allowed`` (type(Class)):  [Read-Write]
    - ``class_property_with_disallowed`` (type(Class)):  [Read-Write]
    - ``color_property`` (Color):  [Read-Write]
    - ``color_property_array`` (Array[Color]):  [Read-Write]
    - ``component_reference`` (ComponentReference):  [Read-Write]
    - ``date_time`` (DateTime):  [Read-Write]
    - ``directory_path`` (DirectoryPath):  [Read-Write]
    - ``disabled_by_can_edit_change`` (SoftObjectPath):  [Read-Write]
    - ``disabled_when_flags_is_odd`` (bool):  [Read-Write]
    - ``double_property`` (double):  [Read-Write]
    - ``edit_color_set`` (Set[PropertyEditorTestEditColor]):  [Read-Write]
    - ``edit_condition`` (bool):  [Read-Write]
    - ``edit_condition_asset_reference_custom_struct_with_edit_condition`` (bool):  [Read-Write]
    - ``edit_condition_flags`` (int64):  [Read-Write]
    - ``edit_condition_for_arrays`` (bool):  [Read-Write]
    - ``edit_condition_for_directory_path`` (bool):  [Read-Write]
    - ``edit_condition_for_fixed_array`` (bool):  [Read-Write]
    - ``edit_condition_struct_with_multiple_instances2`` (bool):  [Read-Write]
    - ``edit_inline_new_static_mesh_component`` (StaticMeshComponent):  [Read-Write]
    - ``enabled_by_previous`` (bool):  [Read-Write]
    - ``enabled_when_blue`` (bool):  [Read-Write]
    - ``enabled_when_category_checked`` (float):  [Read-Write]
    - ``enabled_when_enum_is2`` (bool):  [Read-Write]
    - ``enabled_when_enum_is4`` (bool):  [Read-Write]
    - ``enabled_when_flags_has_two_or_four`` (bool):  [Read-Write]
    - ``enabled_when_float_greater_than5`` (bool):  [Read-Write]
    - ``enabled_when_float_less_than10`` (bool):  [Read-Write]
    - ``enabled_when_int_greater_or_equal5`` (bool):  [Read-Write]
    - ``enabled_when_int_less_or_equal10`` (bool):  [Read-Write]
    - ``enabled_when_pink`` (bool):  [Read-Write]
    - ``enables_next`` (bool):  [Read-Write]
    - ``enum_as_byte_edit_condition`` (PropertyEditorTestEnum):  [Read-Write]
    - ``enum_bitflags`` (int32):  [Read-Write]
    - ``enum_byte_property`` (PropertyEditorTestEnum):  [Read-Write]
    - ``enum_edit_condition`` (PropertyEditorTestEditColor):  [Read-Write]
    - ``enum_property`` (PropertyEditorTestEditColor):  [Read-Write]
    - ``enum_property_array`` (Array[PropertyEditorTestEnum]):  [Read-Write]
    - ``enum_underscores`` (PropertyEditorTestUnderscores):  [Read-Write]
    - ``exact_point_or_spot_light_actor_reference`` (SoftObjectPath):  [Read-Write]
    - ``exactly_point_light_actor_reference`` (SoftObjectPath):  [Read-Write]
    - ``fixed_array_of_ints`` (Array[int32]):  [Read-Write]
    - ``fixed_array_with_edit_condition`` (str):  [Read-Write]
    - ``float_edit_condition`` (float):  [Read-Write]
    - ``float_property`` (float):  [Read-Write]
    - ``float_property_array`` (Array[float]):  [Read-Write]
    - ``float_property_with_clamped_range`` (float):  [Read-Write] This is a custom tooltip that should be shown
    - ``float_range`` (FloatRange):  [Read-Only]
    - ``float_set`` (Set[float]):  [Read-Write]
    - ``gigabyte_property`` (double):  [Read-Write]
    - ``guid`` (Guid):  [Read-Write]
    - ``has_non_editable_inline_condition`` (float):  [Read-Write]
    - ``inline_edit_condition_with_meta`` (float):  [Read-Write]
    - ``inline_edit_condition_with_meta_toggle`` (bool):  [Read-Write]
    - ``inline_edit_condition_without_meta`` (float):  [Read-Write]
    - ``inline_property`` (ComponentMobility):  [Read-Write]
    - ``instanced_struct_array`` (Array[PropertyEditorTestInstancedStruct]):  [Read-Write]
    - ``instanced_u_object_array`` (Array[PropertyEditorTestInstancedObject]):  [Read-Write]
    - ``int16_property`` (int16):  [Read-Write]
    - ``int32_property`` (int32):  [Read-Write]
    - ``int32_set`` (Set[int32]):  [Read-Write]
    - ``int32_to_string_map`` (Map[int32, str]):  [Read-Write]
    - ``int32_to_struct_map`` (Map[int32, PropertyEditorTestBasicStruct]):  [Read-Write]
    - ``int64_property`` (int64):  [Read-Write]
    - ``int8_property`` (int8):  [Read-Write]
    - ``int_point_property`` (IntPoint):  [Read-Write]
    - ``int_property32_array`` (Array[int32]):  [Read-Write] Integer
    - ``int_property_with_clamped_range`` (int32):  [Read-Write]
    - ``int_that_cannot_be_changed`` (int32):  [Read-Only]
    - ``int_to_custom_map`` (Map[int32, PropertyEditorTestBasicStruct]):  [Read-Write]
    - ``int_to_enum_map`` (Map[int32, PropertyEditorTestEnum]):  [Read-Write]
    - ``int_to_sub_struct_map`` (Map[int32, PropertyEditorTestSubStruct]):  [Read-Write]
    - ``integer_edit_condition`` (int32):  [Read-Write]
    - ``light_actor_reference`` (SoftObjectPath):  [Read-Write]
    - ``light_or_static_mesh_actor_reference`` (SoftObjectPath):  [Read-Write] NOTE: intentionally misplaced space in AllowedClasses
    - ``light_propagation_volume_blendable`` (BlendableInterface):  [Read-Write] This is an IBlendableInterface that only allows for ULightPropagationVolumeBlendable objects
    - ``linear_color_property`` (LinearColor):  [Read-Write]
    - ``linear_color_property_array`` (Array[LinearColor]):  [Read-Write]
    - ``linear_color_set`` (Set[LinearColor]):  [Read-Write]
    - ``linear_color_to_string_map`` (Map[LinearColor, str]):  [Read-Write]
    - ``linear_color_to_vector_map`` (Map[LinearColor, Vector]):  [Read-Write]
    - ``material_no_thumbnail`` (MaterialInterface):  [Read-Write]
    - ``material_or_texture_asset_reference`` (SoftObjectPath):  [Read-Write]
    - ``matrix_property`` (Matrix):  [Read-Write]
    - ``name_property`` (Name):  [Read-Write]
    - ``name_property_array`` (Array[Name]):  [Read-Write]
    - ``name_set`` (Set[Name]):  [Read-Write]
    - ``name_to_color_map`` (Map[Name, LinearColor]):  [Read-Write]
    - ``name_to_custom_map`` (Map[Name, PropertyEditorTestBasicStruct]):  [Read-Write]
    - ``name_to_name_map`` (Map[Name, Name]):  [Read-Write]
    - ``name_to_object_map`` (Map[Name, Object]):  [Read-Write]
    - ``nested_array_of_ints`` (int32):  [Read-Write]
    - ``not_light_actor_reference`` (SoftObjectPath):  [Read-Write]
    - ``object_property`` (Object):  [Read-Write]
    - ``object_property_array`` (Array[Object]):  [Read-Write]
    - ``object_property_array_with_title`` (Array[PropertyEditorTestInstancedObject]):  [Read-Write]
    - ``object_set`` (Set[Object]):  [Read-Write]
    - ``object_that_cannot_be_changed`` (PrimitiveComponent):  [Read-Only]
    - ``object_to_color_map`` (Map[Object, LinearColor]):  [Read-Write]
    - ``object_to_int32_map`` (Map[Object, int32]):  [Read-Write]
    - ``only_actors_allowed`` (Actor):  [Read-Write]
    - ``per_platform_float`` (PerPlatformFloat):  [Read-Write]
    - ``per_platform_int`` (PerPlatformInt):  [Read-Write]
    - ``primary_asset_id`` (PrimaryAssetId):  [Read-Write]
    - ``primary_asset_id_without_thumbnail`` (PrimaryAssetId):  [Read-Write]
    - ``property_that_hides`` (ComponentMobility):  [Read-Write]
    - ``rich_curve`` (RichCurve):  [Read-Write]
    - ``rotator_property`` (Rotator):  [Read-Write]
    - ``rotator_property_array`` (Array[Rotator]):  [Read-Write]
    - ``shared_edit_condition`` (bool):  [Read-Write]
    - ``simple_property_with_edit_condition`` (int32):  [Read-Write]
    - ``soft_object_path`` (SoftObjectPath):  [Read-Write]
    - ``static_array_of_ints`` (int32):  [Read-Write]
    - ``static_array_of_ints_with_enum_labels`` (int32):  [Read-Write]
    - ``static_mesh_prop`` (StaticMesh):  [Read-Write]
    - ``string_password_property`` (str):  [Read-Write]
    - ``string_property`` (str):  [Read-Write]
    - ``string_property_array`` (Array[str]):  [Read-Write]
    - ``string_set`` (Set[str]):  [Read-Write]
    - ``string_that_cannot_be_changed`` (str):  [Read-Only]
    - ``string_to_actor_map`` (Map[str, Actor]):  [Read-Write]
    - ``string_to_color_map`` (Map[str, LinearColor]):  [Read-Write]
    - ``string_to_float_map`` (Map[str, float]):  [Read-Write]
    - ``string_to_multiline_text_map`` (Map[str, Text]):  [Read-Write]
    - ``string_to_object_map`` (Map[str, Object]):  [Read-Write]
    - ``struct`` (PropertyEditTestTextStruct):  [Read-Write]
    - ``struct_property_array`` (Array[PropertyEditorTestBasicStruct]):  [Read-Write]
    - ``struct_property_array_with_formatted_title`` (Array[PropertyEditorTestBasicStruct]):  [Read-Write]
    - ``struct_property_array_with_formatted_title_error`` (Array[PropertyEditorTestBasicStruct]):  [Read-Write]
    - ``struct_property_array_with_title`` (Array[PropertyEditorTestBasicStruct]):  [Read-Write]
    - ``struct_property_array_with_title_error`` (Array[PropertyEditorTestBasicStruct]):  [Read-Write]
    - ``struct_with_inline_condition`` (PropertyEditorTestEditCondition):  [Read-Write]
    - ``struct_with_multiple_instances1`` (PropertyEditorTestBasicStruct):  [Read-Write]
    - ``struct_with_multiple_instances2`` (PropertyEditorTestBasicStruct):  [Read-Write]
    - ``subcategory`` (bool):  [Read-Write]
    - ``subcategory_advanced`` (bool):  [Read-Write]
    - ``subcategory_bar_advanced`` (bool):  [Read-Write]
    - ``subcategory_bar_simple`` (bool):  [Read-Write]
    - ``subcategory_foo_advanced`` (bool):  [Read-Write]
    - ``subcategory_foo_simple`` (bool):  [Read-Write]
    - ``subcategory_last`` (bool):  [Read-Write]
    - ``subclass_of_texture`` (type(Class)):  [Read-Write]
    - ``subclass_of_with_allowed`` (type(Class)):  [Read-Write]
    - ``subclass_of_with_disallowed`` (type(Class)):  [Read-Write]
    - ``text_password_property`` (Text):  [Read-Write]
    - ``text_property`` (Text):  [Read-Write]
    - ``text_property_array`` (Array[Text]):  [Read-Write]
    - ``texture_or_blendable_interface`` (Object):  [Read-Write] Allows either an object that's derived from UTexture or IBlendableInterface, to ensure that Object Property handles know how to
      filter for AllowedClasses correctly.
    - ``texture_prop`` (Texture):  [Read-Write]
    - ``this_is_broken_if_its_visible_in_a_details_view`` (PropertyEditorTestBasicStruct):  [Read-Write]
    - ``timecode_property_array`` (Array[Timecode]):  [Read-Write]
    - ``timespan`` (Timespan):  [Read-Write]
    - ``transform_property`` (Transform):  [Read-Write]
    - ``unsigned_int16_property`` (uint16):  [Read-Write]
    - ``unsigned_int32_property`` (uint32):  [Read-Write]
    - ``unsigned_int64_property`` (uint64):  [Read-Write]
    - ``uses_shared_edit_condition1`` (float):  [Read-Write]
    - ``uses_shared_edit_condition2`` (float):  [Read-Write]
    - ``vector2_property`` (Vector2D):  [Read-Write]
    - ``vector2_property_array`` (Array[Vector2D]):  [Read-Write]
    - ``vector3_property`` (Vector):  [Read-Write]
    - ``vector3_property_array`` (Array[Vector]):  [Read-Write]
    - ``vector4_property`` (Vector4):  [Read-Write]
    - ``vector4_property_array`` (Array[Vector4]):  [Read-Write]
    - ``vector_set`` (Set[Vector]):  [Read-Write]
    - ``vector_to_float_map`` (Map[Vector, float]):  [Read-Write]
    - ``visible_when_static`` (bool):  [Read-Write]
    - ``visible_when_stationary`` (int32):  [Read-Write]
    """
    ...

class BlueprintPropertyTestObject(Object):
    r"""
    Blueprint Property Test Object
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``object_a`` (SoundBase):  [Read-Write]
    - ``object_b`` (SoundBase):  [Read-Write]
    - ``should_be_hidden`` (int32):  [Read-Write]
    - ``should_be_visible`` (int32):  [Read-Write]
    """
    ...

class BlueprintPropertyContainerTestObject(Object):
    r"""
    Blueprint Property Container Test Object
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``array`` (Array[BlueprintPropertyTestObject]):  [Read-Write]
    """
    ...

class TestSparseClassDataBase(Object):
    r"""
    Test Sparse Class Data Base
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    """
    ...

class TestSparseClassData(TestSparseClassDataBase):
    r"""
    Test Sparse Class Data
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    """
    ...

class PropertyEditorTestActor(Actor):
    r"""
    Property Editor Test Actor
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``defaults_only`` (float):  [Read-Write]
    - ``defaults_only_subcategory`` (float):  [Read-Write]
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``get_options_value`` (Name):  [Read-Write]
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instance_only`` (float):  [Read-Write]
    - ``instance_only_subcategory`` (float):  [Read-Write]
    - ``instanced_u_object_array`` (Array[PropertyEditorTestInstancedObject]):  [Read-Write]
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``multi_line_map`` (Map[int32, Text]):  [Read-Write]
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class ReimportCurveFactory(CSVImportFactory):
    r"""
    Reimport Curve Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ReimportCurveFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``automated_import_settings`` (CSVImportSettings):  [Read-Write]
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ReimportCurveTableFactory(CSVImportFactory):
    r"""
    Reimport Curve Table Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ReimportCurveTableFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``automated_import_settings`` (CSVImportSettings):  [Read-Write]
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ReimportDataTableFactory(CSVImportFactory):
    r"""
    Reimport Data Table Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ReimportDataTableFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``automated_import_settings`` (CSVImportSettings):  [Read-Write]
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ReimportFbxAnimSequenceFactory(FbxFactory):
    r"""
    Reimport Fbx Anim Sequence Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ReimportFbxAnimSequenceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ReimportFbxSceneFactory(FbxSceneImportFactory):
    r"""
    Reimport Fbx Scene Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ReimportFbxSceneFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``scene_import_options`` (FbxSceneImportOptions):  [Read-Write] Import options UI detail when importing fbx scene
    - ``scene_import_options_skeletal_mesh`` (FbxSceneImportOptionsSkeletalMesh):  [Read-Write] Import options UI detail when importing fbx scene skeletal mesh
    - ``scene_import_options_static_mesh`` (FbxSceneImportOptionsStaticMesh):  [Read-Write] Import options UI detail when importing fbx scene static mesh
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    def script_reimport_helper(self, obj: Object) -> None:
        r"""
        x.script_reimport_helper(obj) -> None
        Script helper to allow fbx scene reimport from scripted language
               *
        
        Args:
            obj (Object):
        """
        ...

class ReimportFbxSkeletalMeshFactory(FbxFactory):
    r"""
    Reimport Fbx Skeletal Mesh Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ReimportFbxSkeletalMeshFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ReimportFbxStaticMeshFactory(FbxFactory):
    r"""
    Reimport Fbx Static Mesh Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ReimportFbxStaticMeshFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TextureFactory(Factory):
    r"""
    Texture Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Channel values to compare to when preserving alpha coverage from a mask for mips
    - ``alpha_to_emissive`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's emissive color
    - ``alpha_to_opacity`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's opacity
    - ``alpha_to_opacity_mask`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's opacity mask
    - ``alpha_to_roughness`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's roughness
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``blending`` (BlendMode):  [Read-Write] The blend mode of the created material
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings for the texture
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_material`` (bool):  [Read-Write] If enabled, a material will automatically be created for the texture
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``defer_compression`` (bool):  [Read-Write] If enabled, compression is deferred until the texture is saved
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``flip_normal_map_green_channel`` (bool):  [Read-Write] If enabled, the texture's green channel will be inverted. This is useful for some normal maps
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``lod_group`` (TextureGroup):  [Read-Write] The group the texture belongs to
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] The mip-map generation settings for the texture; Allows customization of the content of the mip-map chain
    - ``no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be discarded during compression
    - ``preserve_border`` (bool):  [Read-Write] If enabled, preserve the value of border pixels when creating mip-maps
    - ``rgb_to_base_color`` (bool):  [Read-Write] If enabled, link the texture to the created material's base color
    - ``rgb_to_emissive`` (bool):  [Read-Write] If enabled, link the texture to the created material's emissive color
    - ``shading_model`` (MaterialShadingModel):  [Read-Write] The shading model of the created material
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    - ``two_sided`` (bool):  [Read-Write] If enabled, the created material will be two-sided
    - ``use_new_mip_filter`` (bool):  [Read-Write] Whether to use newer & faster mip generation filter
    """
    ...

class ReimportTextureFactory(TextureFactory):
    r"""
    Reimport Texture Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ReimportTextureFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Channel values to compare to when preserving alpha coverage from a mask for mips
    - ``alpha_to_emissive`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's emissive color
    - ``alpha_to_opacity`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's opacity
    - ``alpha_to_opacity_mask`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's opacity mask
    - ``alpha_to_roughness`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's roughness
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``blending`` (BlendMode):  [Read-Write] The blend mode of the created material
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings for the texture
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_material`` (bool):  [Read-Write] If enabled, a material will automatically be created for the texture
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``defer_compression`` (bool):  [Read-Write] If enabled, compression is deferred until the texture is saved
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``flip_normal_map_green_channel`` (bool):  [Read-Write] If enabled, the texture's green channel will be inverted. This is useful for some normal maps
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``lod_group`` (TextureGroup):  [Read-Write] The group the texture belongs to
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] The mip-map generation settings for the texture; Allows customization of the content of the mip-map chain
    - ``no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be discarded during compression
    - ``preserve_border`` (bool):  [Read-Write] If enabled, preserve the value of border pixels when creating mip-maps
    - ``rgb_to_base_color`` (bool):  [Read-Write] If enabled, link the texture to the created material's base color
    - ``rgb_to_emissive`` (bool):  [Read-Write] If enabled, link the texture to the created material's emissive color
    - ``shading_model`` (MaterialShadingModel):  [Read-Write] The shading model of the created material
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    - ``two_sided`` (bool):  [Read-Write] If enabled, the created material will be two-sided
    - ``use_new_mip_filter`` (bool):  [Read-Write] Whether to use newer & faster mip generation filter
    """
    ...

class VectorFieldStaticFactory(Factory):
    r"""
    Vector Field Static Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: VectorFieldStaticFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ReimportVectorFieldStaticFactory(VectorFieldStaticFactory):
    r"""
    Reimport Vector Field Static Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ReimportVectorFieldStaticFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class RenderTargetExporterPNG(Exporter):
    r"""
    note : URenderTargetExporterHDR deleted
          export to HDR is discouraged, use PNG or EXR
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: RenderTargetExporterHDR.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class RenderTargetExporterEXR(Exporter):
    r"""
    Render Target Exporter EXR
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: RenderTargetExporterHDR.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class SequenceExporterT3D(Exporter):
    r"""
    Sequence Exporter T3D
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SequenceExporterT3D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class SkeletalMeshExporterFBX(ExporterFBX):
    r"""
    Skeletal Mesh Exporter FBX
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SkeletalMeshExporterFBX.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class SkeletonFactory(Factory):
    r"""
    Skeleton Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SkeletonFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SlateBrushAssetFactory(Factory):
    r"""
    Factory for creating SlateBrushAssets
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SlateBrushAssetFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SlateWidgetStyleAssetFactory(Factory):
    r"""
    Factory for creating SlateStyles
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SlateWidgetStyleAssetFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``style_type`` (type(Class)):  [Read-Write]
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundExporterOGG(Exporter):
    r"""
    Sound Exporter OGG
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SoundExporterOGG.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class SoundExporterWAV(Exporter):
    r"""
    Sound Exporter WAV
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SoundExporterWAV.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class SoundSurroundExporterWAV(Exporter):
    r"""
    Sound Surround Exporter WAV
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SoundSurroundExporterWAV.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class SpecularProfileFactory(Factory):
    r"""
    Specular Profile Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SpecularProfileFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class StaticMeshExporterFBX(ExporterFBX):
    r"""
    Static Mesh Exporter FBX
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: StaticMeshExporterFBX.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class StaticMeshExporterOBJ(Exporter):
    r"""
    Static Mesh Exporter OBJ
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: StaticMeshExporterOBJ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class StringTableFactory(Factory):
    r"""
    String Table Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: StringTableFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class StructureFactory(Factory):
    r"""
    Structure Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: StructureFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SubsurfaceProfileFactory(Factory):
    r"""
    Subsurface Profile Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SubsurfaceProfileFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SubUVAnimationFactory(Factory):
    r"""
    Sub UVAnimation Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: SubUVAnimationFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TextBufferExporterTXT(Exporter):
    r"""
    Text Buffer Exporter TXT
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextBufferExporterTXT.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class Texture2DArrayFactory(Factory):
    r"""
    Factory for creating volume texture
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: Texture2DArrayFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class Texture2DFactoryNew(Factory):
    r"""
    Texture 2DFactory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: Texture2dFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TextureCubeArrayFactory(Factory):
    r"""
    Factory for creating volume texture
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureCubeArrayFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TextureCubeExporterHDR(Exporter):
    r"""
    Texture Cube Exporter HDR
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureCubeExporterHDR.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class RenderTargetCubeExporterHDR(TextureCubeExporterHDR):
    r"""
    Render Target Cube Exporter HDR
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureCubeExporterHDR.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class TextureExporterGeneric(Exporter):
    r"""
    Texture Exporter Generic
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterGeneric.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class TextureExporterBMP(TextureExporterGeneric):
    r"""
    Texture Exporter BMP
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterBMP.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class VirtualTextureBuilderExporterBMP(TextureExporterBMP):
    r"""
    Virtual Texture Builder Exporter BMP
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterBMP.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class TextureExporterDDS(TextureExporterGeneric):
    r"""
    Texture Exporter DDS
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterDDS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class VirtualTextureBuilderExporterDDS(TextureExporterDDS):
    r"""
    Virtual Texture Builder Exporter DDS
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterDDS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class TextureExporterEXR(TextureExporterGeneric):
    r"""
    Texture Exporter EXR
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterEXR.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class VirtualTextureBuilderExporterEXR(TextureExporterEXR):
    r"""
    Virtual Texture Builder Exporter EXR
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterEXR.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class TextureExporterHDR(TextureExporterGeneric):
    r"""
    Texture Exporter HDR
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterHDR.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class VirtualTextureBuilderExporterHDR(TextureExporterHDR):
    r"""
    Virtual Texture Builder Exporter HDR
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterHDR.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class TextureExporterPCX(Exporter):
    r"""
    Texture Exporter PCX
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterPCX.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class TextureExporterPNG(TextureExporterGeneric):
    r"""
    Texture Exporter PNG
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterPNG.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class VirtualTextureBuilderExporterPNG(TextureExporterPNG):
    r"""
    Virtual Texture Builder Exporter PNG
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterPNG.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class TextureExporterJPEG(Exporter):
    r"""
    JPEG is not UTextureExporterGeneric
    JPEG exporter writes stored JPEG bits in TextureSource compressed payloads
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterPNG.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class TextureExporterUEJPEG(Exporter):
    r"""
    Texture Exporter UEJPEG
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterPNG.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class TextureExporterTGA(TextureExporterGeneric):
    r"""
    Texture Exporter TGA
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureExporterTGA.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class UDIMTextureFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    UDIMTexture Function Library
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureFactory.h
    
    """
    @classmethod
    def make_udim_virtual_texture_from_texture2_ds(cls, output_path_name: str, source_textures: Array[Texture2D], block_coords: Array[IntPoint], keep_existing_settings: bool = False, check_out_and_save: bool = False) -> Texture2D:
        r"""
        X.make_udim_virtual_texture_from_texture2_ds(output_path_name, source_textures, block_coords, keep_existing_settings=False, check_out_and_save=False) -> Texture2D
        Make a UDIM virtual texture from a list of regular 2D textures
        
        Args:
            output_path_name (str): Path name of the UDIM texture (e.g. /Game/MyTexture)
            source_textures (Array[Texture2D]): List of regular 2D textures to be packed into the atlas
            block_coords (Array[IntPoint]): Coordinates of the corresponding texture in the atlas
            keep_existing_settings (bool): Whether to keep existing settings if a texture with the same path name exists. Otherwise, settings will be copied from the first source texture
            check_out_and_save (bool): Whether to check out and save the UDIM texture
        
        Returns:
            Texture2D: UTexture2D*                   Pointer to the UDIM texture or null if failed
        """
        ...

class TextureRenderTarget2DArrayFactoryNew(Factory):
    r"""
    Texture Render Target 2DArray Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureRenderTarget2DArrayFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TextureRenderTargetCubeFactoryNew(Factory):
    r"""
    Texture Render Target Cube Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureRenderTargetCubeFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TextureRenderTargetFactoryNew(Factory):
    r"""
    Texture Render Target Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureRenderTargetFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TextureRenderTargetVolumeFactoryNew(Factory):
    r"""
    Texture Render Target Volume Factory New
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TextureRenderTargetVolumeFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SkeletalMeshActor(Actor):
    r"""
    SkeletalMeshActor is an instance of a USkeletalMesh in the world.
    Skeletal meshes are deformable meshes that can be animated and change their geometry at run-time.
    Skeletal meshes dragged into the level from the Content Browser are automatically converted to StaticMeshActors.
    see: https://docs.unrealengine.com/latest/INT/Engine/Content/Types/SkeletalMeshes/
    see: USkeletalMesh
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``should_do_anim_notifies`` (bool):  [Read-Write] Whether or not this actor should respond to anim notifies - CURRENTLY ONLY AFFECTS PlayParticleEffect NOTIFIES*
    - ``skeletal_mesh_component`` (SkeletalMeshComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def should_do_anim_notifies(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not this actor should respond to anim notifies - CURRENTLY ONLY AFFECTS PlayParticleEffect NOTIFIES*
        """
        ...
    @should_do_anim_notifies.setter
    def should_do_anim_notifies(self, value: bool) -> None:
        ...
    @property
    def skeletal_mesh_component(self) -> SkeletalMeshComponent:
        r"""
        (SkeletalMeshComponent):  [Read-Only]
        """
        ...

class SingleAnimSkeletalActor(SkeletalMeshActor):
    r"""
    deprecated: 'SingleAnimSkeletalActor' was renamed to 'SkeletalMeshActor'.
    """
    ...

class SkeletalPhysicsActor(SkeletalMeshActor):
    r"""
    deprecated: 'SkeletalPhysicsActor' was renamed to 'SkeletalMeshActor'.
    """
    ...

class AnimationThumbnailSkeletalMeshActor(SkeletalMeshActor):
    r"""
    Animation Thumbnail Skeletal Mesh Actor
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: ThumbnailHelpers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``should_do_anim_notifies`` (bool):  [Read-Write] Whether or not this actor should respond to anim notifies - CURRENTLY ONLY AFFECTS PlayParticleEffect NOTIFIES*
    - ``skeletal_mesh_component`` (SkeletalMeshComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class TouchInterfaceFactory(Factory):
    r"""
    Touch Interface Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TouchInterfaceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TrueTypeFontFactory(TextureFactory):
    r"""
    True Type Font Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: TrueTypeFontFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Channel values to compare to when preserving alpha coverage from a mask for mips
    - ``alpha_to_emissive`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's emissive color
    - ``alpha_to_opacity`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's opacity
    - ``alpha_to_opacity_mask`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's opacity mask
    - ``alpha_to_roughness`` (bool):  [Read-Write] If enabled, link the texture's alpha to the created material's roughness
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``blending`` (BlendMode):  [Read-Write] The blend mode of the created material
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings for the texture
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_material`` (bool):  [Read-Write] If enabled, a material will automatically be created for the texture
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``defer_compression`` (bool):  [Read-Write] If enabled, compression is deferred until the texture is saved
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``flip_normal_map_green_channel`` (bool):  [Read-Write] If enabled, the texture's green channel will be inverted. This is useful for some normal maps
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``import_options`` (FontImportOptions):  [Read-Write] Import options for the font
    - ``lod_group`` (TextureGroup):  [Read-Write] The group the texture belongs to
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] The mip-map generation settings for the texture; Allows customization of the content of the mip-map chain
    - ``no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be discarded during compression
    - ``preserve_border`` (bool):  [Read-Write] If enabled, preserve the value of border pixels when creating mip-maps
    - ``rgb_to_base_color`` (bool):  [Read-Write] If enabled, link the texture to the created material's base color
    - ``rgb_to_emissive`` (bool):  [Read-Write] If enabled, link the texture to the created material's emissive color
    - ``shading_model`` (MaterialShadingModel):  [Read-Write] The shading model of the created material
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    - ``two_sided`` (bool):  [Read-Write] If enabled, the created material will be two-sided
    - ``use_new_mip_filter`` (bool):  [Read-Write] Whether to use newer & faster mip generation filter
    """
    ...

class UnrealEditorSubsystem(EditorSubsystem):
    r"""
    UUnrealEditorSubsystem
    Subsystem for exposing editor functionality to scripts
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: UnrealEditorSubsystem.h
    
    """
    def set_level_viewport_camera_info(self, camera_location: Vector, camera_rotation: Rotator) -> None:
        r"""
        x.set_level_viewport_camera_info(camera_location, camera_rotation) -> None
        Sets information about the camera position for the primary level editor viewport.
        In the UnrealEd module instead of Level Editor as it uses FLevelEditorViewportClient which is in this module
        
        Args:
            camera_location (Vector): Location the camera will be moved to.
            camera_rotation (Rotator): Rotation the camera will be set to.
        """
        ...
    def get_level_viewport_camera_info(self) -> Optional[Tuple[Vector, Rotator]]:
        r"""
        x.get_level_viewport_camera_info() -> (camera_location=Vector, camera_rotation=Rotator) or None
        Gets information about the camera position for the primary level editor viewport.  In non-editor builds, these will be zeroed
        In the UnrealEd module instead of Level Editor as it uses FLevelEditorViewportClient which is in this module
        
        Returns:
            tuple or None: Whether or not we were able to get a camera for a level editing viewport
        
            camera_location (Vector): (out) Current location of the level editing viewport camera, or zero if none found
        
            camera_rotation (Rotator): (out) Current rotation of the level editing viewport camera, or zero if none found
        """
        ...
    def get_game_world(self) -> World:
        r"""
        x.get_game_world() -> World
        Get Game World
        
        Returns:
            World:
        """
        ...
    def get_editor_world(self) -> World:
        r"""
        x.get_editor_world() -> World
        Find the World in the world editor. It can then be used as WorldContext by other libraries like GameplayStatics.
        
        Returns:
            World: The World used by the world editor.
        """
        ...

class VariableFrameStrippingSettingsFactory(Factory):
    r"""
    Variable Frame Stripping Settings Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: VariableFrameStrippingSettingsFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class VectorFieldExporter(Exporter):
    r"""
    Vector Field Exporter
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: VectorFieldExporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class VolumeTextureFactory(Factory):
    r"""
    Factory for creating volume texture
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: VolumeTextureFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class WorldFactory(Factory):
    r"""
    World Factory
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: WorldFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class InstancedStaticMeshComponent(StaticMeshComponent):
    r"""
    A component that efficiently renders multiple instances of the same StaticMesh.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InstancedStaticMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``instance_end_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance completely fades out.
    - ``instance_lod_distance_scale`` (float):  [Read-Write] Scale applied to change the computation of LOD distances when using the StaticMesh screen sizes.
      Smaller values make LODs transition earlier.
    - ``instance_start_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance begins to fade out.
    - ``instancing_random_seed`` (int32):  [Read-Write] Value used to seed the random number stream that generates random numbers for each of this mesh's instances.
            The random number is stored in a buffer accessible to materials through the PerInstanceRandom expression. If
            this is set to zero (default), it will be populated automatically by the editor.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``num_custom_data_floats`` (int32):  [Read-Write] Defines the number of floats that will be available per instance for custom data
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``per_instance_sm_custom_data`` (Array[float]):  [Read-Write] Array of custom data for instances. This will contains NumCustomDataFloats*InstanceCount entries. The entries are represented sequantially, in instance order. Can be read in a material and manipulated through Blueprints.
          Example: If NumCustomDataFloats is 1, then each entry will belong to an instance. Custom data 0 will belong to Instance 0. Custom data 1 will belong to Instance 1 etc.
          Example: If NumCustomDataFloats is 2, then each pair of sequential entries belong to an instance. Custom data 0 and 1 will belong to Instance 0. Custom data 2 and 3 will belong to Instance 2 etc.
    - ``per_instance_sm_data`` (Array[InstancedStaticMeshInstanceData]):  [Read-Write] Array of instances, bulk serialized.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``use_gpu_lod_selection`` (bool):  [Read-Write] If true, this component will use GPU LOD selection.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    @property
    def instancing_random_seed(self) -> int:
        r"""
        (int32):  [Read-Write] Value used to seed the random number stream that generates random numbers for each of this mesh's instances.
              The random number is stored in a buffer accessible to materials through the PerInstanceRandom expression. If
              this is set to zero (default), it will be populated automatically by the editor.
        """
        ...
    @instancing_random_seed.setter
    def instancing_random_seed(self, value: int) -> None:
        ...
    @property
    def instance_lod_distance_scale(self) -> float:
        r"""
        (float):  [Read-Only] Scale applied to change the computation of LOD distances when using the StaticMesh screen sizes.
        Smaller values make LODs transition earlier.
        """
        ...
    @property
    def instance_start_cull_distance(self) -> int:
        r"""
        (int32):  [Read-Only] Distance from camera at which each instance begins to fade out.
        """
        ...
    @property
    def instance_end_cull_distance(self) -> int:
        r"""
        (int32):  [Read-Only] Distance from camera at which each instance completely fades out.
        """
        ...
    @property
    def use_gpu_lod_selection(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will use GPU LOD selection.
        """
        ...
    def update_instance_transform(self, instance_index: int, new_instance_transform: Transform, world_space: bool = False, mark_render_state_dirty: bool = False, teleport: bool = False) -> bool:
        r"""
        x.update_instance_transform(instance_index, new_instance_transform, world_space=False, mark_render_state_dirty=False, teleport=False) -> bool
        Update the transform for the instance specified.
        
        Args:
            instance_index (int32): The index of the instance to update
            new_instance_transform (Transform): The new transform
            world_space (bool): If true, the new transform is interpreted as a World Space transform, otherwise it is interpreted as Local Space
            mark_render_state_dirty (bool): If true, the change should be visible immediately. If you are updating many instances you should only set this to true for the last instance.
            teleport (bool): Whether or not the instance's physics should be moved normally, or teleported (moved instantly, ignoring velocity).
        
        Returns:
            bool: True on success.
        """
        ...
    def set_num_custom_data_floats(self, num_custom_data_floats: int) -> None:
        r"""
        x.set_num_custom_data_floats(num_custom_data_floats) -> None
        Update number of custom data entries per instance. This applies to all instances and will reallocate the full custom data buffer and reset all values to 0
        
        Args:
            num_custom_data_floats (int32):
        """
        ...
    def set_lod_distance_scale(self, lod_distance_scale: float) -> None:
        r"""
        x.set_lod_distance_scale(lod_distance_scale) -> None
        Sets the LOD scale.
        
        Args:
            lod_distance_scale (float):
        """
        ...
    def set_custom_data_value(self, instance_index: int, custom_data_index: int, custom_data_value: float, mark_render_state_dirty: bool = False) -> bool:
        r"""
        x.set_custom_data_value(instance_index, custom_data_index, custom_data_value, mark_render_state_dirty=False) -> bool
        Update custom data for specific instance
        
        Args:
            instance_index (int32): 
            custom_data_index (int32): 
            custom_data_value (float): 
            mark_render_state_dirty (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_cull_distances(self, start_cull_distance: int, end_cull_distance: int) -> None:
        r"""
        x.set_cull_distances(start_cull_distance, end_cull_distance) -> None
        Sets the fading start and culling end distances for this component.
        
        Args:
            start_cull_distance (int32): 
            end_cull_distance (int32):
        """
        ...
    def remove_instances(self, instances_to_remove: Array[int]) -> bool:
        r"""
        x.remove_instances(instances_to_remove) -> bool
        Remove the instances specified. Returns True on success.
        
        Args:
            instances_to_remove (Array[int32]): 
        
        Returns:
            bool:
        """
        ...
    def remove_instance(self, instance_index: int) -> bool:
        r"""
        x.remove_instance(instance_index) -> bool
        Remove the instance specified. Returns True on success.
        
        Args:
            instance_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def is_valid_instance(self, instance_index: int) -> bool:
        r"""
        x.is_valid_instance(instance_index) -> bool
        Does the given index map to a valid instance in this component?
        
        Args:
            instance_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_lod_distance_scale(self) -> float:
        r"""
        x.get_lod_distance_scale() -> float
        Gets the current LOD scale.
        
        Returns:
            float:
        """
        ...
    def get_instance_transform(self, instance_index: int, world_space: bool = False) -> Optional[Transform]:
        r"""
        x.get_instance_transform(instance_index, world_space=False) -> Transform or None
        Get the transform for the instance specified. Instance is returned in local space of this component unless bWorldSpace is set.  Returns True on success.
        
        Args:
            instance_index (int32): 
            world_space (bool): 
        
        Returns:
            Transform or None: 
        
            out_instance_transform (Transform):
        """
        ...
    def get_instances_overlapping_sphere(self, center: Vector, radius: float, sphere_in_world_space: bool = True) -> Array[int]:
        r"""
        x.get_instances_overlapping_sphere(center, radius, sphere_in_world_space=True) -> Array[int32]
        Returns the instances with instance bounds overlapping the specified sphere. The return value is an array of instance indices.
        
        Args:
            center (Vector): 
            radius (float): 
            sphere_in_world_space (bool): 
        
        Returns:
            Array[int32]:
        """
        ...
    def get_instances_overlapping_box(self, box: Box, box_in_world_space: bool = True) -> Array[int]:
        r"""
        x.get_instances_overlapping_box(box, box_in_world_space=True) -> Array[int32]
        Returns the instances with instance bounds overlapping the specified box. The return value is an array of instance indices.
        
        Args:
            box (Box): 
            box_in_world_space (bool): 
        
        Returns:
            Array[int32]:
        """
        ...
    def get_instance_count(self) -> int:
        r"""
        x.get_instance_count() -> int32
        Get the number of instances in this component.
        
        Returns:
            int32:
        """
        ...
    def get_cull_distances(self) -> Tuple[int, int]:
        r"""
        x.get_cull_distances() -> (out_start_cull_distance=int32, out_end_cull_distance=int32)
        Gets the fading start and culling end distances for this component.
        
        Returns:
            tuple: 
        
            out_start_cull_distance (int32): 
        
            out_end_cull_distance (int32):
        """
        ...
    def clear_instances(self) -> None:
        r"""
        x.clear_instances() -> None
        Clear all instances being rendered by this component.
        """
        ...
    def batch_update_instances_transforms(self, start_instance_index: int, new_instances_transforms: Array[Transform], world_space: bool = False, mark_render_state_dirty: bool = False, teleport: bool = False) -> bool:
        r"""
        x.batch_update_instances_transforms(start_instance_index, new_instances_transforms, world_space=False, mark_render_state_dirty=False, teleport=False) -> bool
        Update the transform for an array of instances.
        
        Args:
            start_instance_index (int32): The starting index of the instances to update
            new_instances_transforms (Array[Transform]): The new transforms
            world_space (bool): If true, the new transforms are interpreted as a World Space transform, otherwise it is interpreted as Local Space
            mark_render_state_dirty (bool): If true, the change should be visible immediately. If you are updating many instances you should only set this to true for the last instance.
            teleport (bool): Whether or not the instances physics should be moved normally, or teleported (moved instantly, ignoring velocity).
        
        Returns:
            bool: True on success.
        """
        ...
    def batch_update_instances_transform(self, start_instance_index: int, num_instances: int, new_instances_transform: Transform, world_space: bool = False, mark_render_state_dirty: bool = False, teleport: bool = False) -> bool:
        r"""
        x.batch_update_instances_transform(start_instance_index, num_instances, new_instances_transform, world_space=False, mark_render_state_dirty=False, teleport=False) -> bool
        Update the transform for a number of instances.
        
        Args:
            start_instance_index (int32): The starting index of the instances to update
            num_instances (int32): The number of instances to update
            new_instances_transform (Transform): The new transform
            world_space (bool): If true, the new transform is interpreted as a World Space transform, otherwise it is interpreted as Local Space
            mark_render_state_dirty (bool): If true, the change should be visible immediately. If you are updating many instances you should only set this to true for the last instance.
            teleport (bool): Whether or not the instances physics should be moved normally, or teleported (moved instantly, ignoring velocity).
        
        Returns:
            bool: True on success.
        """
        ...
    def add_instance_world_space(self, world_transform: Transform) -> int:
        r"""
        x.add_instance_world_space(world_transform) -> int32
        Add Instance World Space
        deprecated: Use 'Add Instance' or 'Add Instances' with 'World Space' set to true.
        
        Args:
            world_transform (Transform): 
        
        Returns:
            int32:
        """
        ...
    def add_instances(self, instance_transforms: Array[Transform], should_return_indices: bool, world_space: bool = False, update_navigation: bool = True) -> Array[int]:
        r"""
        x.add_instances(instance_transforms, should_return_indices, world_space=False, update_navigation=True) -> Array[int32]
        Add multiple instances to this component. Transform is given in local space of this component unless bWorldSpace is set.
        
        Args:
            instance_transforms (Array[Transform]): 
            should_return_indices (bool): 
            world_space (bool): 
            update_navigation (bool): 
        
        Returns:
            Array[int32]:
        """
        ...
    def add_instance(self, instance_transform: Transform, world_space: bool = False) -> int:
        r"""
        x.add_instance(instance_transform, world_space=False) -> int32
        Add an instance to this component. Transform is given in local space of this component unless bWorldSpace is set.
        
        Args:
            instance_transform (Transform): 
            world_space (bool): 
        
        Returns:
            int32:
        """
        ...
    def acquire_editor_element_handle(self, instance_index: int, allow_create: bool = True) -> ScriptTypedElementHandle:
        r"""
        x.acquire_editor_element_handle(instance_index, allow_create=True) -> ScriptTypedElementHandle
        K2 Acquire Editor SMInstance Element Handle
        
        Args:
            instance_index (int32): 
            allow_create (bool): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...

class HierarchicalInstancedStaticMeshComponent(InstancedStaticMeshComponent):
    r"""
    Hierarchical Instanced Static Mesh Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HierarchicalInstancedStaticMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``instance_end_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance completely fades out.
    - ``instance_lod_distance_scale`` (float):  [Read-Write] Scale applied to change the computation of LOD distances when using the StaticMesh screen sizes.
      Smaller values make LODs transition earlier.
    - ``instance_start_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance begins to fade out.
    - ``instancing_random_seed`` (int32):  [Read-Write] Value used to seed the random number stream that generates random numbers for each of this mesh's instances.
            The random number is stored in a buffer accessible to materials through the PerInstanceRandom expression. If
            this is set to zero (default), it will be populated automatically by the editor.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``num_custom_data_floats`` (int32):  [Read-Write] Defines the number of floats that will be available per instance for custom data
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``per_instance_sm_custom_data`` (Array[float]):  [Read-Write] Array of custom data for instances. This will contains NumCustomDataFloats*InstanceCount entries. The entries are represented sequantially, in instance order. Can be read in a material and manipulated through Blueprints.
          Example: If NumCustomDataFloats is 1, then each entry will belong to an instance. Custom data 0 will belong to Instance 0. Custom data 1 will belong to Instance 1 etc.
          Example: If NumCustomDataFloats is 2, then each pair of sequential entries belong to an instance. Custom data 0 and 1 will belong to Instance 0. Custom data 2 and 3 will belong to Instance 2 etc.
    - ``per_instance_sm_data`` (Array[InstancedStaticMeshInstanceData]):  [Read-Write] Array of instances, bulk serialized.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``use_gpu_lod_selection`` (bool):  [Read-Write] If true, this component will use GPU LOD selection.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    ...

class FoliageInstancedStaticMeshComponent(HierarchicalInstancedStaticMeshComponent):
    r"""
    Foliage Instanced Static Mesh Component
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: FoliageInstancedStaticMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``instance_end_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance completely fades out.
    - ``instance_lod_distance_scale`` (float):  [Read-Write] Scale applied to change the computation of LOD distances when using the StaticMesh screen sizes.
      Smaller values make LODs transition earlier.
    - ``instance_start_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance begins to fade out.
    - ``instancing_random_seed`` (int32):  [Read-Write] Value used to seed the random number stream that generates random numbers for each of this mesh's instances.
            The random number is stored in a buffer accessible to materials through the PerInstanceRandom expression. If
            this is set to zero (default), it will be populated automatically by the editor.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``num_custom_data_floats`` (int32):  [Read-Write] Defines the number of floats that will be available per instance for custom data
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_instance_take_point_damage`` (InstancePointDamageSignature):  [Read-Write]
    - ``on_instance_take_radial_damage`` (InstanceRadialDamageSignature):  [Read-Write]
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``per_instance_sm_custom_data`` (Array[float]):  [Read-Write] Array of custom data for instances. This will contains NumCustomDataFloats*InstanceCount entries. The entries are represented sequantially, in instance order. Can be read in a material and manipulated through Blueprints.
          Example: If NumCustomDataFloats is 1, then each entry will belong to an instance. Custom data 0 will belong to Instance 0. Custom data 1 will belong to Instance 1 etc.
          Example: If NumCustomDataFloats is 2, then each pair of sequential entries belong to an instance. Custom data 0 and 1 will belong to Instance 0. Custom data 2 and 3 will belong to Instance 2 etc.
    - ``per_instance_sm_data`` (Array[InstancedStaticMeshInstanceData]):  [Read-Write] Array of instances, bulk serialized.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``use_gpu_lod_selection`` (bool):  [Read-Write] If true, this component will use GPU LOD selection.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    @property
    def on_instance_take_point_damage(self) -> InstancePointDamageSignature:
        r"""
        (InstancePointDamageSignature):  [Read-Write]
        """
        ...
    @on_instance_take_point_damage.setter
    def on_instance_take_point_damage(self, value: InstancePointDamageSignature) -> None:
        ...
    @property
    def on_instance_take_radial_damage(self) -> InstanceRadialDamageSignature:
        r"""
        (InstanceRadialDamageSignature):  [Read-Write]
        """
        ...
    @on_instance_take_radial_damage.setter
    def on_instance_take_radial_damage(self, value: InstanceRadialDamageSignature) -> None:
        ...

class FoliageType(Object):
    r"""
    Foliage Type
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: FoliageType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true.
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the foliage should inject light into the Light Propagation Volume.  This flag is only used if CastShadow is true.
    - ``align_max_angle`` (float):  [Read-Write] The maximum angle in degrees that foliage instances will be adjusted away from the vertical
    - ``align_to_normal`` (bool):  [Read-Write] Whether foliage instances should have their angle adjusted away from vertical to match the normal of the surface they're painted on
      If AlignToNormal is enabled and RandomYaw is disabled, the instance will be rotated so that the +X axis points down-slope
    - ``average_normal`` (bool):  [Read-Write] Will average normal based on Foliage Type base radius (this as a cost as it will do extra line traces)
    - ``average_normal_sample_count`` (int32):  [Read-Write] Line trace count to use around hit location when averaging normal
    - ``average_normal_single_component`` (bool):  [Read-Write] Whether to discard normals originating from other hit components or not when averaging normals
    - ``average_spread_distance`` (float):  [Read-Write] The average distance between the spreading instance and its seeds. For example, a tree with an AverageSpreadDistance 10 will ensure the average distance between the tree and its seeds is 10cm
    - ``body_instance`` (BodyInstance):  [Read-Write] Custom collision for foliage
    - ``can_grow_in_shade`` (bool):  [Read-Write] If true, seeds of this type will ignore shade radius during overlap tests with other types.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows. This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the foliage should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the foliage should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this foliage should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the foliage should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``collision_radius`` (float):  [Read-Write] The CollisionRadius determines when two instances overlap. When two instances overlap a winner will be picked based on rules and priority.
    - ``collision_scale`` (Vector):  [Read-Write] The foliage instance's collision bounding box will be scaled by the specified amount before performing the overlap check
    - ``collision_with_world`` (bool):  [Read-Write] If checked, an overlap test with existing world geometry is performed before each instance is placed
    - ``cull_distance`` (Int32Interval):  [Read-Write] The distance where instances will begin to fade out if using a PerInstanceFadeAmount material node. 0 disables.
      When the entire cluster is beyond this distance, the cluster is completely culled and not rendered at all.
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_navigable_geometry`` (HasCustomNavigableGeometry):  [Read-Write] Force navmesh
    - ``density`` (float):  [Read-Write] Foliage instances will be placed at this density, specified in instances per 1000x1000 unit area
    - ``density_adjustment_factor`` (float):  [Read-Write] The factor by which to adjust the density of instances. Values >1 will increase density while values <1 will decrease it.
    - ``density_falloff`` (FoliageDensityFalloff):  [Read-Write]
    - ``distribution_seed`` (int32):  [Read-Write] The seed that determines placement of initial seeds.
    - ``enable_cull_distance_scaling`` (bool):  [Read-Write] * Whether this foliage type should be affected by the Engine's "foliage.CullDistanceScale" setting
    - ``enable_density_scaling`` (bool):  [Read-Write] Whether this foliage type should be affected by the Engine Scalability system's Foliage scalability setting.
      Enable for detail meshes that don't really affect the game. Disable for anything important.
      Typically, this will be enabled for small meshes without collision (e.g. grass) and disabled for large meshes with collision (e.g. trees)
    - ``enable_discard_on_load`` (bool):  [Read-Write] Whether this foliage type should be discarded when CVarFoliageDiscardDataOnLoad is enabled.
    - ``evaluate_world_position_offset`` (bool):  [Read-Write]
    - ``exclusion_landscape_layers`` (Array[Name]):  [Read-Write] If layer names are specified, painting on landscape will exclude the foliage to areas of landscape without the specified layers painted
    - ``ground_slope_angle`` (FloatInterval):  [Read-Write] Foliage instances will only be placed on surfaces sloping in the specified angle range from the horizontal
    - ``height`` (FloatInterval):  [Read-Write] The valid altitude range where foliage instances will be placed, specified using minimum and maximum world coordinate Z values
    - ``include_in_hlod`` (bool):  [Read-Write]
    - ``initial_seed_density`` (float):  [Read-Write] Specifies the number of seeds to populate along 10 meters. The number is implicitly squared to cover a 10m x 10m area
    - ``landscape_layers`` (Array[Name]):  [Read-Write] If layer names are specified, painting on landscape will limit the foliage to areas of landscape with the specified layers painted
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Lighting channels that placed foliage will be assigned. Lights with matching channels will affect the foliage.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``max_age`` (float):  [Read-Write] Specifies the oldest a seed can be. After reaching this age the instance will still spread seeds, but will not get any older
    - ``max_initial_age`` (float):  [Read-Write] Allows a new seed to be older than 0 when created. New seeds will be randomly assigned an age in the range [0,MaxInitialAge]
    - ``max_initial_seed_offset`` (float):  [Read-Write] The seed that determines placement of initial seeds.
    - ``minimum_exclusion_layer_weight`` (float):  [Read-Write] Specifies the minimum value above which the landscape exclusion layer weight value must be, in order for foliage instances to be excluded in a specific area
    - ``minimum_layer_weight`` (float):  [Read-Write] Specifies the minimum value above which the landscape layer weight value must be, in order for foliage instances to be placed in a specific area
    - ``mobility`` (ComponentMobility):  [Read-Write] Mobility property to apply to foliage components
    - ``num_steps`` (int32):  [Read-Write] The number of times we age the species and spread its seeds.
    - ``overlap_priority`` (float):  [Read-Write] When two instances overlap we must determine which instance to remove.
      The instance with a lower OverlapPriority will be removed.
      In the case where OverlapPriority is the same regular simulation rules apply.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Overrides the lightmap resolution defined in the static mesh
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``procedural_scale`` (FloatInterval):  [Read-Write] The scale range of this type when being procedurally generated. Configured with the Scale Curve.
    - ``radius`` (float):  [Read-Write] The minimum distance between foliage instances
    - ``random_pitch_angle`` (float):  [Read-Write] A random pitch adjustment can be applied to each instance, up to the specified angle in degrees, from the original vertical
    - ``random_yaw`` (bool):  [Read-Write] If selected, foliage instances will have a random yaw rotation around their vertical axis applied
    - ``reapply_align_to_normal`` (bool):  [Read-Write] If checked, foliage instances will have their normal alignment adjusted by the Reapply tool
    - ``reapply_collision_with_world`` (bool):  [Read-Write] If checked, foliage instances will have an overlap test with the world reapplied, and overlapping instances will be removed by the Reapply tool
    - ``reapply_density`` (bool):  [Read-Write] If checked, the density of foliage instances already placed will be adjusted by the density adjustment factor.
    - ``reapply_ground_slope`` (bool):  [Read-Write] If checked, foliage instances not meeting the ground slope condition will be removed by the Reapply too
    - ``reapply_height`` (bool):  [Read-Write] If checked, foliage instances not meeting the valid Z height condition will be removed by the Reapply tool
    - ``reapply_landscape_layers`` (bool):  [Read-Write] If checked, foliage instances painted on areas that do not have the appropriate landscape layer painted will be removed by the Reapply tool
    - ``reapply_radius`` (bool):  [Read-Write] If checked, foliage instances not meeting the new Radius constraint will be removed
    - ``reapply_random_pitch_angle`` (bool):  [Read-Write] If checked, foliage instances will have their pitch adjusted by the Reapply tool
    - ``reapply_random_yaw`` (bool):  [Read-Write] If checked, foliage instances will have their yaw adjusted by the Reapply tool
    - ``reapply_scale_x`` (bool):  [Read-Write] If checked, foliage instances will have their X scale adjusted by the Reapply tool
    - ``reapply_scale_y`` (bool):  [Read-Write] If checked, foliage instances will have their Y scale adjusted by the Reapply tool
    - ``reapply_scale_z`` (bool):  [Read-Write] If checked, foliage instances will have their Z scale adjusted by the Reapply tool
    - ``reapply_scaling`` (bool):  [Read-Write] If checked, foliage instances will have their scale adjusted to fit the specified scaling behavior by the Reapply tool
    - ``reapply_vertex_color_mask`` (bool):  [Read-Write] If checked, foliage instances no longer matching the vertex color constraint will be removed by the Reapply too
    - ``reapply_z_offset`` (bool):  [Read-Write] If checked, foliage instances will have their Z offset adjusted by the Reapply tool
    - ``receives_decals`` (bool):  [Read-Write] Whether the foliage receives decals.
    - ``render_custom_depth`` (bool):  [Read-Write] If true, the foliage will be rendered in the CustomDepth pass (usually used for outlines)
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the instances.
      The mesh material also needs to be set up to output to a virtual texture.
    - ``scale_curve`` (RuntimeFloatCurve):  [Read-Write] Instance scale factor as a function of normalized age (i.e. Current Age / Max Age).
      X = 0 corresponds to Age = 0, X = 1 corresponds to Age = Max Age.
      Y = 0 corresponds to Min Scale, Y = 1 corresponds to Max Scale.
    - ``scale_x`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a foliage instance's X Scale property
    - ``scale_y`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a foliage instance's Y Scale property
    - ``scale_z`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a foliage instance's Z Scale property
    - ``scaling`` (FoliageScaling):  [Read-Write] Specifies foliage instance scaling behavior when painting.
    - ``seeds_per_step`` (int32):  [Read-Write] The number of seeds an instance will spread in a single step of the simulation.
    - ``shade_radius`` (float):  [Read-Write] The ShadeRadius determines when two instances overlap. If an instance can grow in the shade this radius is ignored.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``single_instance_mode_override_radius`` (bool):  [Read-Write] Option to override radius used to detect collision with other instances when painting in single instance mode
    - ``single_instance_mode_radius`` (float):  [Read-Write] The radius used in single instance mode to detect collision with other instances
    - ``spawns_in_shade`` (bool):  [Read-Write] Whether new seeds are spawned exclusively in shade. Occurs in a second pass after all types that do not spawn in shade have been simulated.
      Only valid when CanGrowInShade is true.
    - ``spread_variance`` (float):  [Read-Write] Specifies how much seed distance varies from the average. For example, a tree with an AverageSpreadDistance 10 and a SpreadVariance 1 will produce seeds with an average distance of 10cm plus or minus 1cm
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``use_as_occluder`` (bool):  [Read-Write] If enabled, foliage will render a pre-pass which allows it to occlude other primitives, and also allows
      it to correctly receive DBuffer decals. Enabling this setting may have a negative performance impact.
    - ``vertex_color_mask_by_channel`` (FoliageVertexColorChannelMask):  [Read-Write]
    - ``virtual_texture_cull_mips`` (int32):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write]
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write]
    - ``z_offset`` (FloatInterval):  [Read-Write] Specifies a range from minimum to maximum of the offset to apply to a foliage instance's Z location
    """
    @property
    def z_offset(self) -> FloatInterval:
        r"""
        (FloatInterval):  [Read-Write] Specifies a range from minimum to maximum of the offset to apply to a foliage instance's Z location
        """
        ...
    @z_offset.setter
    def z_offset(self, value: FloatInterval) -> None:
        ...
    @property
    def align_to_normal(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether foliage instances should have their angle adjusted away from vertical to match the normal of the surface they're painted on
        If AlignToNormal is enabled and RandomYaw is disabled, the instance will be rotated so that the +X axis points down-slope
        """
        ...
    @align_to_normal.setter
    def align_to_normal(self, value: bool) -> None:
        ...
    @property
    def average_normal(self) -> bool:
        r"""
        (bool):  [Read-Write] Will average normal based on Foliage Type base radius (this as a cost as it will do extra line traces)
        """
        ...
    @average_normal.setter
    def average_normal(self, value: bool) -> None:
        ...
    @property
    def average_normal_single_component(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to discard normals originating from other hit components or not when averaging normals
        """
        ...
    @average_normal_single_component.setter
    def average_normal_single_component(self, value: bool) -> None:
        ...
    @property
    def align_max_angle(self) -> float:
        r"""
        (float):  [Read-Write] The maximum angle in degrees that foliage instances will be adjusted away from the vertical
        """
        ...
    @align_max_angle.setter
    def align_max_angle(self, value: float) -> None:
        ...
    @property
    def random_yaw(self) -> bool:
        r"""
        (bool):  [Read-Write] If selected, foliage instances will have a random yaw rotation around their vertical axis applied
        """
        ...
    @random_yaw.setter
    def random_yaw(self, value: bool) -> None:
        ...
    @property
    def random_pitch_angle(self) -> float:
        r"""
        (float):  [Read-Write] A random pitch adjustment can be applied to each instance, up to the specified angle in degrees, from the original vertical
        """
        ...
    @random_pitch_angle.setter
    def random_pitch_angle(self, value: float) -> None:
        ...
    @property
    def ground_slope_angle(self) -> FloatInterval:
        r"""
        (FloatInterval):  [Read-Write] Foliage instances will only be placed on surfaces sloping in the specified angle range from the horizontal
        """
        ...
    @ground_slope_angle.setter
    def ground_slope_angle(self, value: FloatInterval) -> None:
        ...
    @property
    def height(self) -> FloatInterval:
        r"""
        (FloatInterval):  [Read-Write] The valid altitude range where foliage instances will be placed, specified using minimum and maximum world coordinate Z values
        """
        ...
    @height.setter
    def height(self, value: FloatInterval) -> None:
        ...
    @property
    def landscape_layers(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] If layer names are specified, painting on landscape will limit the foliage to areas of landscape with the specified layers painted
        """
        ...
    @landscape_layers.setter
    def landscape_layers(self, value: Array[Name]) -> None:
        ...
    @property
    def minimum_layer_weight(self) -> float:
        r"""
        (float):  [Read-Write] Specifies the minimum value above which the landscape layer weight value must be, in order for foliage instances to be placed in a specific area
        """
        ...
    @minimum_layer_weight.setter
    def minimum_layer_weight(self, value: float) -> None:
        ...
    @property
    def exclusion_landscape_layers(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] If layer names are specified, painting on landscape will exclude the foliage to areas of landscape without the specified layers painted
        """
        ...
    @exclusion_landscape_layers.setter
    def exclusion_landscape_layers(self, value: Array[Name]) -> None:
        ...
    @property
    def minimum_exclusion_layer_weight(self) -> float:
        r"""
        (float):  [Read-Write] Specifies the minimum value above which the landscape exclusion layer weight value must be, in order for foliage instances to be excluded in a specific area
        """
        ...
    @minimum_exclusion_layer_weight.setter
    def minimum_exclusion_layer_weight(self, value: float) -> None:
        ...
    @property
    def collision_with_world(self) -> bool:
        r"""
        (bool):  [Read-Write] If checked, an overlap test with existing world geometry is performed before each instance is placed
        """
        ...
    @collision_with_world.setter
    def collision_with_world(self, value: bool) -> None:
        ...
    @property
    def collision_scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The foliage instance's collision bounding box will be scaled by the specified amount before performing the overlap check
        """
        ...
    @collision_scale.setter
    def collision_scale(self, value: Vector) -> None:
        ...
    @property
    def average_normal_sample_count(self) -> int:
        r"""
        (int32):  [Read-Write] Line trace count to use around hit location when averaging normal
        """
        ...
    @average_normal_sample_count.setter
    def average_normal_sample_count(self, value: int) -> None:
        ...
    @property
    def mobility(self) -> ComponentMobility:
        r"""
        (ComponentMobility):  [Read-Only] Mobility property to apply to foliage components
        """
        ...
    @property
    def cast_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the foliage should cast a shadow or not.
        """
        ...
    @property
    def affect_dynamic_indirect_lighting(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the foliage should inject light into the Light Propagation Volume.  This flag is only used if CastShadow is true.
        """
        ...
    @property
    def affect_distance_field_lighting(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true.
        """
        ...
    @property
    def cast_dynamic_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the foliage should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true.
        """
        ...
    @property
    def cast_static_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the foliage should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
        """
        ...
    @property
    def cast_contact_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the object should cast contact shadows. This flag is only used if CastShadow is true.
        """
        ...
    @property
    def cast_shadow_as_two_sided(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether this foliage should cast dynamic shadows as if it were a two sided material.
        """
        ...
    @property
    def receives_decals(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the foliage receives decals.
        """
        ...
    @property
    def override_light_map_res(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to override the lightmap resolution defined in the static mesh.
        """
        ...
    @property
    def shadow_cache_invalidation_behavior(self) -> ShadowCacheInvalidationBehavior:
        r"""
        (ShadowCacheInvalidationBehavior):  [Read-Only] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
        """
        ...
    @property
    def overridden_light_map_res(self) -> int:
        r"""
        (int32):  [Read-Only] Overrides the lightmap resolution defined in the static mesh
        """
        ...
    @property
    def lightmap_type(self) -> LightmapType:
        r"""
        (LightmapType):  [Read-Only] Controls the type of lightmap used for this component.
        """
        ...
    @property
    def use_as_occluder(self) -> bool:
        r"""
        (bool):  [Read-Only] If enabled, foliage will render a pre-pass which allows it to occlude other primitives, and also allows
        it to correctly receive DBuffer decals. Enabling this setting may have a negative performance impact.
        """
        ...
    @property
    def visible_in_ray_tracing(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def evaluate_world_position_offset(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def world_position_offset_disable_distance(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def lighting_channels(self) -> LightingChannels:
        r"""
        (LightingChannels):  [Read-Only] Lighting channels that placed foliage will be assigned. Lights with matching channels will affect the foliage.
        These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
        """
        ...
    @property
    def render_custom_depth(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, the foliage will be rendered in the CustomDepth pass (usually used for outlines)
        """
        ...
    @property
    def custom_depth_stencil_write_mask(self) -> RendererStencilMask:
        r"""
        (RendererStencilMask):  [Read-Only] Mask used for stencil buffer writes.
        """
        ...
    @property
    def custom_depth_stencil_value(self) -> int:
        r"""
        (int32):  [Read-Only] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
        """
        ...
    @property
    def translucency_sort_priority(self) -> int:
        r"""
        (int32):  [Read-Only] Translucent objects with a lower sort priority draw behind objects with a higher priority.
        Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
        This setting is also used to sort objects being drawn into a runtime virtual texture.
        
        Ignored if the object is not translucent.  The default priority is zero.
        Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
        It is especially problematic on dynamic gameplay effects.
        """
        ...
    @property
    def runtime_virtual_textures(self) -> Array[RuntimeVirtualTexture]:
        r"""
        (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the instances.
        The mesh material also needs to be set up to output to a virtual texture.
        """
        ...
    @runtime_virtual_textures.setter
    def runtime_virtual_textures(self, value: Array[RuntimeVirtualTexture]) -> None:
        ...
    @property
    def virtual_texture_cull_mips(self) -> int:
        r"""
        (int32):  [Read-Only] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
        Larger values reduce the effective draw distance in the runtime virtual texture.
        This culling method doesn't take into account primitive size or virtual texture size.
        """
        ...
    @property
    def virtual_texture_render_pass_type(self) -> RuntimeVirtualTextureMainPassType:
        r"""
        (RuntimeVirtualTextureMainPassType):  [Read-Only] Controls if this component draws in the main pass as well as in the virtual texture.
        """
        ...
    @property
    def include_in_hlod(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @include_in_hlod.setter
    def include_in_hlod(self, value: bool) -> None:
        ...

class FoliageType_Actor(FoliageType):
    r"""
    Foliage Type Actor
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: FoliageType_Actor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_class`` (type(Class)):  [Read-Write]
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true.
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the foliage should inject light into the Light Propagation Volume.  This flag is only used if CastShadow is true.
    - ``align_max_angle`` (float):  [Read-Write] The maximum angle in degrees that foliage instances will be adjusted away from the vertical
    - ``align_to_normal`` (bool):  [Read-Write] Whether foliage instances should have their angle adjusted away from vertical to match the normal of the surface they're painted on
      If AlignToNormal is enabled and RandomYaw is disabled, the instance will be rotated so that the +X axis points down-slope
    - ``average_normal`` (bool):  [Read-Write] Will average normal based on Foliage Type base radius (this as a cost as it will do extra line traces)
    - ``average_normal_sample_count`` (int32):  [Read-Write] Line trace count to use around hit location when averaging normal
    - ``average_normal_single_component`` (bool):  [Read-Write] Whether to discard normals originating from other hit components or not when averaging normals
    - ``average_spread_distance`` (float):  [Read-Write] The average distance between the spreading instance and its seeds. For example, a tree with an AverageSpreadDistance 10 will ensure the average distance between the tree and its seeds is 10cm
    - ``body_instance`` (BodyInstance):  [Read-Write] Custom collision for foliage
    - ``can_grow_in_shade`` (bool):  [Read-Write] If true, seeds of this type will ignore shade radius during overlap tests with other types.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows. This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the foliage should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the foliage should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this foliage should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the foliage should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``collision_radius`` (float):  [Read-Write] The CollisionRadius determines when two instances overlap. When two instances overlap a winner will be picked based on rules and priority.
    - ``collision_scale`` (Vector):  [Read-Write] The foliage instance's collision bounding box will be scaled by the specified amount before performing the overlap check
    - ``collision_with_world`` (bool):  [Read-Write] If checked, an overlap test with existing world geometry is performed before each instance is placed
    - ``cull_distance`` (Int32Interval):  [Read-Write] The distance where instances will begin to fade out if using a PerInstanceFadeAmount material node. 0 disables.
      When the entire cluster is beyond this distance, the cluster is completely culled and not rendered at all.
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_navigable_geometry`` (HasCustomNavigableGeometry):  [Read-Write] Force navmesh
    - ``density`` (float):  [Read-Write] Foliage instances will be placed at this density, specified in instances per 1000x1000 unit area
    - ``density_adjustment_factor`` (float):  [Read-Write] The factor by which to adjust the density of instances. Values >1 will increase density while values <1 will decrease it.
    - ``density_falloff`` (FoliageDensityFalloff):  [Read-Write]
    - ``distribution_seed`` (int32):  [Read-Write] The seed that determines placement of initial seeds.
    - ``enable_cull_distance_scaling`` (bool):  [Read-Write] * Whether this foliage type should be affected by the Engine's "foliage.CullDistanceScale" setting
    - ``enable_density_scaling`` (bool):  [Read-Write] Whether this foliage type should be affected by the Engine Scalability system's Foliage scalability setting.
      Enable for detail meshes that don't really affect the game. Disable for anything important.
      Typically, this will be enabled for small meshes without collision (e.g. grass) and disabled for large meshes with collision (e.g. trees)
    - ``enable_discard_on_load`` (bool):  [Read-Write] Whether this foliage type should be discarded when CVarFoliageDiscardDataOnLoad is enabled.
    - ``evaluate_world_position_offset`` (bool):  [Read-Write]
    - ``exclusion_landscape_layers`` (Array[Name]):  [Read-Write] If layer names are specified, painting on landscape will exclude the foliage to areas of landscape without the specified layers painted
    - ``ground_slope_angle`` (FloatInterval):  [Read-Write] Foliage instances will only be placed on surfaces sloping in the specified angle range from the horizontal
    - ``height`` (FloatInterval):  [Read-Write] The valid altitude range where foliage instances will be placed, specified using minimum and maximum world coordinate Z values
    - ``include_in_hlod`` (bool):  [Read-Write]
    - ``initial_seed_density`` (float):  [Read-Write] Specifies the number of seeds to populate along 10 meters. The number is implicitly squared to cover a 10m x 10m area
    - ``landscape_layers`` (Array[Name]):  [Read-Write] If layer names are specified, painting on landscape will limit the foliage to areas of landscape with the specified layers painted
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Lighting channels that placed foliage will be assigned. Lights with matching channels will affect the foliage.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``max_age`` (float):  [Read-Write] Specifies the oldest a seed can be. After reaching this age the instance will still spread seeds, but will not get any older
    - ``max_initial_age`` (float):  [Read-Write] Allows a new seed to be older than 0 when created. New seeds will be randomly assigned an age in the range [0,MaxInitialAge]
    - ``max_initial_seed_offset`` (float):  [Read-Write] The seed that determines placement of initial seeds.
    - ``minimum_exclusion_layer_weight`` (float):  [Read-Write] Specifies the minimum value above which the landscape exclusion layer weight value must be, in order for foliage instances to be excluded in a specific area
    - ``minimum_layer_weight`` (float):  [Read-Write] Specifies the minimum value above which the landscape layer weight value must be, in order for foliage instances to be placed in a specific area
    - ``mobility`` (ComponentMobility):  [Read-Write] Mobility property to apply to foliage components
    - ``num_steps`` (int32):  [Read-Write] The number of times we age the species and spread its seeds.
    - ``overlap_priority`` (float):  [Read-Write] When two instances overlap we must determine which instance to remove.
      The instance with a lower OverlapPriority will be removed.
      In the case where OverlapPriority is the same regular simulation rules apply.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Overrides the lightmap resolution defined in the static mesh
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``procedural_scale`` (FloatInterval):  [Read-Write] The scale range of this type when being procedurally generated. Configured with the Scale Curve.
    - ``radius`` (float):  [Read-Write] The minimum distance between foliage instances
    - ``random_pitch_angle`` (float):  [Read-Write] A random pitch adjustment can be applied to each instance, up to the specified angle in degrees, from the original vertical
    - ``random_yaw`` (bool):  [Read-Write] If selected, foliage instances will have a random yaw rotation around their vertical axis applied
    - ``reapply_align_to_normal`` (bool):  [Read-Write] If checked, foliage instances will have their normal alignment adjusted by the Reapply tool
    - ``reapply_collision_with_world`` (bool):  [Read-Write] If checked, foliage instances will have an overlap test with the world reapplied, and overlapping instances will be removed by the Reapply tool
    - ``reapply_density`` (bool):  [Read-Write] If checked, the density of foliage instances already placed will be adjusted by the density adjustment factor.
    - ``reapply_ground_slope`` (bool):  [Read-Write] If checked, foliage instances not meeting the ground slope condition will be removed by the Reapply too
    - ``reapply_height`` (bool):  [Read-Write] If checked, foliage instances not meeting the valid Z height condition will be removed by the Reapply tool
    - ``reapply_landscape_layers`` (bool):  [Read-Write] If checked, foliage instances painted on areas that do not have the appropriate landscape layer painted will be removed by the Reapply tool
    - ``reapply_radius`` (bool):  [Read-Write] If checked, foliage instances not meeting the new Radius constraint will be removed
    - ``reapply_random_pitch_angle`` (bool):  [Read-Write] If checked, foliage instances will have their pitch adjusted by the Reapply tool
    - ``reapply_random_yaw`` (bool):  [Read-Write] If checked, foliage instances will have their yaw adjusted by the Reapply tool
    - ``reapply_scale_x`` (bool):  [Read-Write] If checked, foliage instances will have their X scale adjusted by the Reapply tool
    - ``reapply_scale_y`` (bool):  [Read-Write] If checked, foliage instances will have their Y scale adjusted by the Reapply tool
    - ``reapply_scale_z`` (bool):  [Read-Write] If checked, foliage instances will have their Z scale adjusted by the Reapply tool
    - ``reapply_scaling`` (bool):  [Read-Write] If checked, foliage instances will have their scale adjusted to fit the specified scaling behavior by the Reapply tool
    - ``reapply_vertex_color_mask`` (bool):  [Read-Write] If checked, foliage instances no longer matching the vertex color constraint will be removed by the Reapply too
    - ``reapply_z_offset`` (bool):  [Read-Write] If checked, foliage instances will have their Z offset adjusted by the Reapply tool
    - ``receives_decals`` (bool):  [Read-Write] Whether the foliage receives decals.
    - ``render_custom_depth`` (bool):  [Read-Write] If true, the foliage will be rendered in the CustomDepth pass (usually used for outlines)
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the instances.
      The mesh material also needs to be set up to output to a virtual texture.
    - ``scale_curve`` (RuntimeFloatCurve):  [Read-Write] Instance scale factor as a function of normalized age (i.e. Current Age / Max Age).
      X = 0 corresponds to Age = 0, X = 1 corresponds to Age = Max Age.
      Y = 0 corresponds to Min Scale, Y = 1 corresponds to Max Scale.
    - ``scale_x`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a foliage instance's X Scale property
    - ``scale_y`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a foliage instance's Y Scale property
    - ``scale_z`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a foliage instance's Z Scale property
    - ``scaling`` (FoliageScaling):  [Read-Write] Specifies foliage instance scaling behavior when painting.
    - ``seeds_per_step`` (int32):  [Read-Write] The number of seeds an instance will spread in a single step of the simulation.
    - ``shade_radius`` (float):  [Read-Write] The ShadeRadius determines when two instances overlap. If an instance can grow in the shade this radius is ignored.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_attach_to_base_component`` (bool):  [Read-Write]
    - ``single_instance_mode_override_radius`` (bool):  [Read-Write] Option to override radius used to detect collision with other instances when painting in single instance mode
    - ``single_instance_mode_radius`` (float):  [Read-Write] The radius used in single instance mode to detect collision with other instances
    - ``spawns_in_shade`` (bool):  [Read-Write] Whether new seeds are spawned exclusively in shade. Occurs in a second pass after all types that do not spawn in shade have been simulated.
      Only valid when CanGrowInShade is true.
    - ``spread_variance`` (float):  [Read-Write] Specifies how much seed distance varies from the average. For example, a tree with an AverageSpreadDistance 10 and a SpreadVariance 1 will produce seeds with an average distance of 10cm plus or minus 1cm
    - ``static_mesh_only`` (bool):  [Read-Write] If enabled, will place an instanced static mesh representation of this actor without placing an actual actor
    - ``static_mesh_only_component_class`` (type(Class)):  [Read-Write]
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``use_as_occluder`` (bool):  [Read-Write] If enabled, foliage will render a pre-pass which allows it to occlude other primitives, and also allows
      it to correctly receive DBuffer decals. Enabling this setting may have a negative performance impact.
    - ``vertex_color_mask_by_channel`` (FoliageVertexColorChannelMask):  [Read-Write]
    - ``virtual_texture_cull_mips`` (int32):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write]
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write]
    - ``z_offset`` (FloatInterval):  [Read-Write] Specifies a range from minimum to maximum of the offset to apply to a foliage instance's Z location
    """
    ...

class FoliageType_InstancedStaticMesh(FoliageType):
    r"""
    Foliage Type Instanced Static Mesh
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: FoliageType_InstancedStaticMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true.
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the foliage should inject light into the Light Propagation Volume.  This flag is only used if CastShadow is true.
    - ``align_max_angle`` (float):  [Read-Write] The maximum angle in degrees that foliage instances will be adjusted away from the vertical
    - ``align_to_normal`` (bool):  [Read-Write] Whether foliage instances should have their angle adjusted away from vertical to match the normal of the surface they're painted on
      If AlignToNormal is enabled and RandomYaw is disabled, the instance will be rotated so that the +X axis points down-slope
    - ``average_normal`` (bool):  [Read-Write] Will average normal based on Foliage Type base radius (this as a cost as it will do extra line traces)
    - ``average_normal_sample_count`` (int32):  [Read-Write] Line trace count to use around hit location when averaging normal
    - ``average_normal_single_component`` (bool):  [Read-Write] Whether to discard normals originating from other hit components or not when averaging normals
    - ``average_spread_distance`` (float):  [Read-Write] The average distance between the spreading instance and its seeds. For example, a tree with an AverageSpreadDistance 10 will ensure the average distance between the tree and its seeds is 10cm
    - ``body_instance`` (BodyInstance):  [Read-Write] Custom collision for foliage
    - ``can_grow_in_shade`` (bool):  [Read-Write] If true, seeds of this type will ignore shade radius during overlap tests with other types.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows. This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the foliage should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the foliage should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this foliage should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the foliage should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``collision_radius`` (float):  [Read-Write] The CollisionRadius determines when two instances overlap. When two instances overlap a winner will be picked based on rules and priority.
    - ``collision_scale`` (Vector):  [Read-Write] The foliage instance's collision bounding box will be scaled by the specified amount before performing the overlap check
    - ``collision_with_world`` (bool):  [Read-Write] If checked, an overlap test with existing world geometry is performed before each instance is placed
    - ``component_class`` (type(Class)):  [Read-Write] The component class to use for foliage instances.
      You can make a Blueprint subclass of FoliageInstancedStaticMeshComponent to implement custom behavior and assign that class here.
    - ``cull_distance`` (Int32Interval):  [Read-Write] The distance where instances will begin to fade out if using a PerInstanceFadeAmount material node. 0 disables.
      When the entire cluster is beyond this distance, the cluster is completely culled and not rendered at all.
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_navigable_geometry`` (HasCustomNavigableGeometry):  [Read-Write] Force navmesh
    - ``density`` (float):  [Read-Write] Foliage instances will be placed at this density, specified in instances per 1000x1000 unit area
    - ``density_adjustment_factor`` (float):  [Read-Write] The factor by which to adjust the density of instances. Values >1 will increase density while values <1 will decrease it.
    - ``density_falloff`` (FoliageDensityFalloff):  [Read-Write]
    - ``distribution_seed`` (int32):  [Read-Write] The seed that determines placement of initial seeds.
    - ``enable_cull_distance_scaling`` (bool):  [Read-Write] * Whether this foliage type should be affected by the Engine's "foliage.CullDistanceScale" setting
    - ``enable_density_scaling`` (bool):  [Read-Write] Whether this foliage type should be affected by the Engine Scalability system's Foliage scalability setting.
      Enable for detail meshes that don't really affect the game. Disable for anything important.
      Typically, this will be enabled for small meshes without collision (e.g. grass) and disabled for large meshes with collision (e.g. trees)
    - ``enable_discard_on_load`` (bool):  [Read-Write] Whether this foliage type should be discarded when CVarFoliageDiscardDataOnLoad is enabled.
    - ``evaluate_world_position_offset`` (bool):  [Read-Write]
    - ``exclusion_landscape_layers`` (Array[Name]):  [Read-Write] If layer names are specified, painting on landscape will exclude the foliage to areas of landscape without the specified layers painted
    - ``ground_slope_angle`` (FloatInterval):  [Read-Write] Foliage instances will only be placed on surfaces sloping in the specified angle range from the horizontal
    - ``height`` (FloatInterval):  [Read-Write] The valid altitude range where foliage instances will be placed, specified using minimum and maximum world coordinate Z values
    - ``include_in_hlod`` (bool):  [Read-Write]
    - ``initial_seed_density`` (float):  [Read-Write] Specifies the number of seeds to populate along 10 meters. The number is implicitly squared to cover a 10m x 10m area
    - ``landscape_layers`` (Array[Name]):  [Read-Write] If layer names are specified, painting on landscape will limit the foliage to areas of landscape with the specified layers painted
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Lighting channels that placed foliage will be assigned. Lights with matching channels will affect the foliage.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``max_age`` (float):  [Read-Write] Specifies the oldest a seed can be. After reaching this age the instance will still spread seeds, but will not get any older
    - ``max_initial_age`` (float):  [Read-Write] Allows a new seed to be older than 0 when created. New seeds will be randomly assigned an age in the range [0,MaxInitialAge]
    - ``max_initial_seed_offset`` (float):  [Read-Write] The seed that determines placement of initial seeds.
    - ``mesh`` (StaticMesh):  [Read-Write]
    - ``minimum_exclusion_layer_weight`` (float):  [Read-Write] Specifies the minimum value above which the landscape exclusion layer weight value must be, in order for foliage instances to be excluded in a specific area
    - ``minimum_layer_weight`` (float):  [Read-Write] Specifies the minimum value above which the landscape layer weight value must be, in order for foliage instances to be placed in a specific area
    - ``mobility`` (ComponentMobility):  [Read-Write] Mobility property to apply to foliage components
    - ``nanite_override_materials`` (Array[MaterialInterface]):  [Read-Write] Nanite material overrides for foliage instances.
    - ``num_steps`` (int32):  [Read-Write] The number of times we age the species and spread its seeds.
    - ``overlap_priority`` (float):  [Read-Write] When two instances overlap we must determine which instance to remove.
      The instance with a lower OverlapPriority will be removed.
      In the case where OverlapPriority is the same regular simulation rules apply.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Overrides the lightmap resolution defined in the static mesh
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides for foliage instances.
    - ``procedural_scale`` (FloatInterval):  [Read-Write] The scale range of this type when being procedurally generated. Configured with the Scale Curve.
    - ``radius`` (float):  [Read-Write] The minimum distance between foliage instances
    - ``random_pitch_angle`` (float):  [Read-Write] A random pitch adjustment can be applied to each instance, up to the specified angle in degrees, from the original vertical
    - ``random_yaw`` (bool):  [Read-Write] If selected, foliage instances will have a random yaw rotation around their vertical axis applied
    - ``reapply_align_to_normal`` (bool):  [Read-Write] If checked, foliage instances will have their normal alignment adjusted by the Reapply tool
    - ``reapply_collision_with_world`` (bool):  [Read-Write] If checked, foliage instances will have an overlap test with the world reapplied, and overlapping instances will be removed by the Reapply tool
    - ``reapply_density`` (bool):  [Read-Write] If checked, the density of foliage instances already placed will be adjusted by the density adjustment factor.
    - ``reapply_ground_slope`` (bool):  [Read-Write] If checked, foliage instances not meeting the ground slope condition will be removed by the Reapply too
    - ``reapply_height`` (bool):  [Read-Write] If checked, foliage instances not meeting the valid Z height condition will be removed by the Reapply tool
    - ``reapply_landscape_layers`` (bool):  [Read-Write] If checked, foliage instances painted on areas that do not have the appropriate landscape layer painted will be removed by the Reapply tool
    - ``reapply_radius`` (bool):  [Read-Write] If checked, foliage instances not meeting the new Radius constraint will be removed
    - ``reapply_random_pitch_angle`` (bool):  [Read-Write] If checked, foliage instances will have their pitch adjusted by the Reapply tool
    - ``reapply_random_yaw`` (bool):  [Read-Write] If checked, foliage instances will have their yaw adjusted by the Reapply tool
    - ``reapply_scale_x`` (bool):  [Read-Write] If checked, foliage instances will have their X scale adjusted by the Reapply tool
    - ``reapply_scale_y`` (bool):  [Read-Write] If checked, foliage instances will have their Y scale adjusted by the Reapply tool
    - ``reapply_scale_z`` (bool):  [Read-Write] If checked, foliage instances will have their Z scale adjusted by the Reapply tool
    - ``reapply_scaling`` (bool):  [Read-Write] If checked, foliage instances will have their scale adjusted to fit the specified scaling behavior by the Reapply tool
    - ``reapply_vertex_color_mask`` (bool):  [Read-Write] If checked, foliage instances no longer matching the vertex color constraint will be removed by the Reapply too
    - ``reapply_z_offset`` (bool):  [Read-Write] If checked, foliage instances will have their Z offset adjusted by the Reapply tool
    - ``receives_decals`` (bool):  [Read-Write] Whether the foliage receives decals.
    - ``render_custom_depth`` (bool):  [Read-Write] If true, the foliage will be rendered in the CustomDepth pass (usually used for outlines)
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the instances.
      The mesh material also needs to be set up to output to a virtual texture.
    - ``scale_curve`` (RuntimeFloatCurve):  [Read-Write] Instance scale factor as a function of normalized age (i.e. Current Age / Max Age).
      X = 0 corresponds to Age = 0, X = 1 corresponds to Age = Max Age.
      Y = 0 corresponds to Min Scale, Y = 1 corresponds to Max Scale.
    - ``scale_x`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a foliage instance's X Scale property
    - ``scale_y`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a foliage instance's Y Scale property
    - ``scale_z`` (FloatInterval):  [Read-Write] Specifies the range of scale, from minimum to maximum, to apply to a foliage instance's Z Scale property
    - ``scaling`` (FoliageScaling):  [Read-Write] Specifies foliage instance scaling behavior when painting.
    - ``seeds_per_step`` (int32):  [Read-Write] The number of seeds an instance will spread in a single step of the simulation.
    - ``shade_radius`` (float):  [Read-Write] The ShadeRadius determines when two instances overlap. If an instance can grow in the shade this radius is ignored.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``single_instance_mode_override_radius`` (bool):  [Read-Write] Option to override radius used to detect collision with other instances when painting in single instance mode
    - ``single_instance_mode_radius`` (float):  [Read-Write] The radius used in single instance mode to detect collision with other instances
    - ``spawns_in_shade`` (bool):  [Read-Write] Whether new seeds are spawned exclusively in shade. Occurs in a second pass after all types that do not spawn in shade have been simulated.
      Only valid when CanGrowInShade is true.
    - ``spread_variance`` (float):  [Read-Write] Specifies how much seed distance varies from the average. For example, a tree with an AverageSpreadDistance 10 and a SpreadVariance 1 will produce seeds with an average distance of 10cm plus or minus 1cm
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``use_as_occluder`` (bool):  [Read-Write] If enabled, foliage will render a pre-pass which allows it to occlude other primitives, and also allows
      it to correctly receive DBuffer decals. Enabling this setting may have a negative performance impact.
    - ``vertex_color_mask_by_channel`` (FoliageVertexColorChannelMask):  [Read-Write]
    - ``virtual_texture_cull_mips`` (int32):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write]
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write]
    - ``z_offset`` (FloatInterval):  [Read-Write] Specifies a range from minimum to maximum of the offset to apply to a foliage instance's Z location
    """
    @property
    def mesh(self) -> StaticMesh:
        r"""
        (StaticMesh):  [Read-Write]
        """
        ...
    @mesh.setter
    def mesh(self, value: StaticMesh) -> None:
        ...
    @property
    def override_materials(self) -> Array[MaterialInterface]:
        r"""
        (Array[MaterialInterface]):  [Read-Write] Material overrides for foliage instances.
        """
        ...
    @override_materials.setter
    def override_materials(self, value: Array[MaterialInterface]) -> None:
        ...
    @property
    def nanite_override_materials(self) -> Array[MaterialInterface]:
        r"""
        (Array[MaterialInterface]):  [Read-Write] Nanite material overrides for foliage instances.
        """
        ...
    @nanite_override_materials.setter
    def nanite_override_materials(self, value: Array[MaterialInterface]) -> None:
        ...

class InstancedFoliageSettings(FoliageType_InstancedStaticMesh):
    r"""
    deprecated: 'InstancedFoliageSettings' was renamed to 'FoliageType_InstancedStaticMesh'.
    """
    ...

class PartitionActor(Actor):
    r"""
    Actor base class for instance containers placed on a grid.
    See UActorPartitionSubsystem.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PartitionActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class ISMPartitionActor(PartitionActor):
    r"""
    Actor base class for instance containers placed on a grid.
          See UActorPartitionSubsystem.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ISMPartitionActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class InstancedFoliageActor(ISMPartitionActor):
    r"""
    Instanced Foliage Actor
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: InstancedFoliageActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @classmethod
    def remove_all_instances(cls, world_context_object: Object, foliage_type: FoliageType) -> None:
        r"""
        X.remove_all_instances(world_context_object, foliage_type) -> None
        Remove All Instances
        
        Args:
            world_context_object (Object): 
            foliage_type (FoliageType):
        """
        ...
    @classmethod
    def add_instances(cls, world_context_object: Object, foliage_type: FoliageType, transforms: Array[Transform]) -> None:
        r"""
        X.add_instances(world_context_object, foliage_type, transforms) -> None
        Add Instances
        
        Args:
            world_context_object (Object): 
            foliage_type (FoliageType): 
            transforms (Array[Transform]):
        """
        ...

class InteractiveFoliageComponent(StaticMeshComponent):
    r"""
    Interactive Foliage Component
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: InteractiveFoliageComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    ...

class FoliageStatistics(BlueprintFunctionLibrary):
    r"""
    Foliage Statistics
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: FoliageStatistics.h
    
    """
    @classmethod
    def foliage_overlapping_sphere_count(cls, world_context_object: Object, static_mesh: StaticMesh, center_position: Vector, radius: float) -> int:
        r"""
        X.foliage_overlapping_sphere_count(world_context_object, static_mesh, center_position, radius) -> int32
        Counts how many foliage instances overlap a given sphere
        
        Args:
            world_context_object (Object): 
            static_mesh (StaticMesh): 
            center_position (Vector): The center position of the sphere
            radius (float): The radius of the sphere. return number of foliage instances with their mesh set to Mesh that overlap the sphere
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def foliage_overlapping_box_transforms(cls, world_context_object: Object, static_mesh: StaticMesh, box: Box) -> Array[Transform]:
        r"""
        X.foliage_overlapping_box_transforms(world_context_object, static_mesh, box) -> Array[Transform]
        Get the transform of every instance overlapping the provided FBox
        
        Args:
            world_context_object (Object): 
            static_mesh (StaticMesh): Mesh to get instances of
            box (Box): Box to use for overlap
        
        Returns:
            Array[Transform]: 
        
            out_transforms (Array[Transform]): Array to populate with transforms
        """
        ...
    @classmethod
    def foliage_overlapping_box_count(cls, world_context_object: Object, static_mesh: StaticMesh, box: Box) -> int:
        r"""
        X.foliage_overlapping_box_count(world_context_object, static_mesh, box) -> int32
        Gets the number of instances overlapping a provided box
        
        Args:
            world_context_object (Object): 
            static_mesh (StaticMesh): Mesh to count
            box (Box): Box to overlap
        
        Returns:
            int32:
        """
        ...

class GrassInstancedStaticMeshComponent(HierarchicalInstancedStaticMeshComponent):
    r"""
    Grass Instanced Static Mesh Component
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: GrassInstancedStaticMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``instance_end_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance completely fades out.
    - ``instance_lod_distance_scale`` (float):  [Read-Write] Scale applied to change the computation of LOD distances when using the StaticMesh screen sizes.
      Smaller values make LODs transition earlier.
    - ``instance_start_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance begins to fade out.
    - ``instancing_random_seed`` (int32):  [Read-Write] Value used to seed the random number stream that generates random numbers for each of this mesh's instances.
            The random number is stored in a buffer accessible to materials through the PerInstanceRandom expression. If
            this is set to zero (default), it will be populated automatically by the editor.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``num_custom_data_floats`` (int32):  [Read-Write] Defines the number of floats that will be available per instance for custom data
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``per_instance_sm_custom_data`` (Array[float]):  [Read-Write] Array of custom data for instances. This will contains NumCustomDataFloats*InstanceCount entries. The entries are represented sequantially, in instance order. Can be read in a material and manipulated through Blueprints.
          Example: If NumCustomDataFloats is 1, then each entry will belong to an instance. Custom data 0 will belong to Instance 0. Custom data 1 will belong to Instance 1 etc.
          Example: If NumCustomDataFloats is 2, then each pair of sequential entries belong to an instance. Custom data 0 and 1 will belong to Instance 0. Custom data 2 and 3 will belong to Instance 2 etc.
    - ``per_instance_sm_data`` (Array[InstancedStaticMeshInstanceData]):  [Read-Write] Array of instances, bulk serialized.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``use_gpu_lod_selection`` (bool):  [Read-Write] If true, this component will use GPU LOD selection.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    ...

class StaticMeshActor(Actor):
    r"""
    StaticMeshActor is an instance of a UStaticMesh in the world.
    Static meshes are geometry that do not animate or otherwise deform, and are more efficient to render than other types of geometry.
    Static meshes dragged into the level from the Content Browser are automatically converted to StaticMeshActors.
    see: https://docs.unrealengine.com/latest/INT/Engine/Actors/StaticMeshActor/
    see: UStaticMesh
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StaticMeshActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``navigation_geometry_gathering_mode`` (NavDataGatheringMode):  [Read-Write]
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``static_mesh_component`` (StaticMeshComponent):  [Read-Only]
    - ``static_mesh_physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Set which replication mode to use for this static mesh instance if it both replicates and simulates physics.
    - ``static_mesh_replicate_movement`` (bool):  [Read-Write] This static mesh should replicate movement. Automatically sets the RemoteRole and bReplicateMovement flags. Meant to be edited on placed actors (those other two properties are not)
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def static_mesh_component(self) -> StaticMeshComponent:
        r"""
        (StaticMeshComponent):  [Read-Only]
        """
        ...
    def set_mobility(self, mobility: ComponentMobility) -> None:
        r"""
        x.set_mobility(mobility) -> None
        Function to change mobility type
        
        Args:
            mobility (ComponentMobility):
        """
        ...

class InterpActor(StaticMeshActor):
    r"""
    deprecated: 'InterpActor' was renamed to 'StaticMeshActor'.
    """
    ...

class PhysicsActor(StaticMeshActor):
    r"""
    deprecated: 'PhysicsActor' was renamed to 'StaticMeshActor'.
    """
    ...

class InteractiveFoliageActor(StaticMeshActor):
    r"""
    Interactive Foliage Actor
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: InteractiveFoliageActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``foliage_damage_impulse_scale`` (float):  [Read-Write] Scales forces applied from damage events.
    - ``foliage_damping`` (float):  [Read-Write] Determines the amount of energy lost by the spring as it oscillates.
      This force is similar to air friction.
    - ``foliage_stiffness`` (float):  [Read-Write] Determines how strong the force that pushes toward the spring's center will be.
    - ``foliage_stiffness_quadratic`` (float):  [Read-Write] Same as FoliageStiffness, but the strength of this force increases with the square of the distance to the spring's center.
      This force is used to prevent the spring from extending past a certain point due to touch and damage forces.
    - ``foliage_touch_impulse_scale`` (float):  [Read-Write] Scales forces applied from touch events.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``max_damage_impulse`` (float):  [Read-Write] Clamps the magnitude of each damage force applied.
    - ``max_force`` (float):  [Read-Write] Clamps the magnitude of combined forces applied each update.
    - ``max_touch_impulse`` (float):  [Read-Write] Clamps the magnitude of each touch force applied.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``navigation_geometry_gathering_mode`` (NavDataGatheringMode):  [Read-Write]
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``static_mesh_component`` (StaticMeshComponent):  [Read-Only]
    - ``static_mesh_physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Set which replication mode to use for this static mesh instance if it both replicates and simulates physics.
    - ``static_mesh_replicate_movement`` (bool):  [Read-Write] This static mesh should replicate movement. Automatically sets the RemoteRole and bReplicateMovement flags. Meant to be edited on placed actors (those other two properties are not)
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def foliage_damage_impulse_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scales forces applied from damage events.
        """
        ...
    @foliage_damage_impulse_scale.setter
    def foliage_damage_impulse_scale(self, value: float) -> None:
        ...
    @property
    def foliage_touch_impulse_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scales forces applied from touch events.
        """
        ...
    @foliage_touch_impulse_scale.setter
    def foliage_touch_impulse_scale(self, value: float) -> None:
        ...
    @property
    def foliage_stiffness(self) -> float:
        r"""
        (float):  [Read-Write] Determines how strong the force that pushes toward the spring's center will be.
        """
        ...
    @foliage_stiffness.setter
    def foliage_stiffness(self, value: float) -> None:
        ...
    @property
    def foliage_stiffness_quadratic(self) -> float:
        r"""
        (float):  [Read-Write] Same as FoliageStiffness, but the strength of this force increases with the square of the distance to the spring's center.
        This force is used to prevent the spring from extending past a certain point due to touch and damage forces.
        """
        ...
    @foliage_stiffness_quadratic.setter
    def foliage_stiffness_quadratic(self, value: float) -> None:
        ...
    @property
    def foliage_damping(self) -> float:
        r"""
        (float):  [Read-Write] Determines the amount of energy lost by the spring as it oscillates.
        This force is similar to air friction.
        """
        ...
    @foliage_damping.setter
    def foliage_damping(self, value: float) -> None:
        ...
    @property
    def max_damage_impulse(self) -> float:
        r"""
        (float):  [Read-Write] Clamps the magnitude of each damage force applied.
        """
        ...
    @max_damage_impulse.setter
    def max_damage_impulse(self, value: float) -> None:
        ...
    @property
    def max_touch_impulse(self) -> float:
        r"""
        (float):  [Read-Write] Clamps the magnitude of each touch force applied.
        """
        ...
    @max_touch_impulse.setter
    def max_touch_impulse(self, value: float) -> None:
        ...
    @property
    def max_force(self) -> float:
        r"""
        (float):  [Read-Write] Clamps the magnitude of combined forces applied each update.
        """
        ...
    @max_force.setter
    def max_force(self, value: float) -> None:
        ...

class ProceduralFoliageBlockingVolume(Volume):
    r"""
    An invisible volume used to block ProceduralFoliage instances from being spawned.
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: ProceduralFoliageBlockingVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``density_falloff`` (FoliageDensityFalloff):  [Read-Write]
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``procedural_foliage_volume`` (ProceduralFoliageVolume):  [Read-Write]
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class ProceduralFoliageComponent(ActorComponent):
    r"""
    Procedural Foliage Component
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: ProceduralFoliageComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_bsp`` (bool):  [Read-Write] Whether to place foliage on BSP
    - ``allow_foliage`` (bool):  [Read-Write] Whether to place foliage on other blocking foliage geometry
    - ``allow_landscape`` (bool):  [Read-Write] Whether to place foliage on landscape
    - ``allow_static_mesh`` (bool):  [Read-Write] Whether to place foliage on StaticMesh
    - ``allow_translucent`` (bool):  [Read-Write] Whether to place foliage on translucent geometry
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``foliage_spawner`` (ProceduralFoliageSpawner):  [Read-Write] The procedural foliage spawner used to generate foliage instances within this volume.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``show_debug_tiles`` (bool):  [Read-Write] Whether to visualize the tiles used for the foliage spawner simulation
    - ``tile_overlap`` (float):  [Read-Write] The amount of overlap between simulation tiles (in cm).
    """
    @property
    def foliage_spawner(self) -> ProceduralFoliageSpawner:
        r"""
        (ProceduralFoliageSpawner):  [Read-Write] The procedural foliage spawner used to generate foliage instances within this volume.
        """
        ...
    @foliage_spawner.setter
    def foliage_spawner(self, value: ProceduralFoliageSpawner) -> None:
        ...
    @property
    def procedural_foliage(self) -> ProceduralFoliageSpawner:
        r"""
        deprecated: 'procedural_foliage' was renamed to 'foliage_spawner'.
        """
        ...
    @procedural_foliage.setter
    def procedural_foliage(self, value: ProceduralFoliageSpawner) -> None:
        ...
    @property
    def tile_overlap(self) -> float:
        r"""
        (float):  [Read-Write] The amount of overlap between simulation tiles (in cm).
        """
        ...
    @tile_overlap.setter
    def tile_overlap(self, value: float) -> None:
        ...
    @property
    def overlap(self) -> float:
        r"""
        deprecated: 'overlap' was renamed to 'tile_overlap'.
        """
        ...
    @overlap.setter
    def overlap(self, value: float) -> None:
        ...
    @property
    def allow_landscape(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to place foliage on landscape
        """
        ...
    @allow_landscape.setter
    def allow_landscape(self, value: bool) -> None:
        ...
    @property
    def allow_bsp(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to place foliage on BSP
        """
        ...
    @allow_bsp.setter
    def allow_bsp(self, value: bool) -> None:
        ...
    @property
    def allow_static_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to place foliage on StaticMesh
        """
        ...
    @allow_static_mesh.setter
    def allow_static_mesh(self, value: bool) -> None:
        ...
    @property
    def allow_translucent(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to place foliage on translucent geometry
        """
        ...
    @allow_translucent.setter
    def allow_translucent(self, value: bool) -> None:
        ...
    @property
    def allow_foliage(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to place foliage on other blocking foliage geometry
        """
        ...
    @allow_foliage.setter
    def allow_foliage(self, value: bool) -> None:
        ...
    @property
    def show_debug_tiles(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to visualize the tiles used for the foliage spawner simulation
        """
        ...
    @show_debug_tiles.setter
    def show_debug_tiles(self, value: bool) -> None:
        ...

class ProceduralFoliageSpawner(Object):
    r"""
    Procedural Foliage Spawner
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: ProceduralFoliageSpawner.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``foliage_types`` (Array[FoliageTypeObject]):  [Read-Write] The types of foliage to procedurally spawn.
    - ``minimum_quad_tree_size`` (float):  [Read-Write] Minimum size of the quad tree used during the simulation. Reduce if too many instances are in splittable leaf quads (as warned in the log).
    - ``num_unique_tiles`` (int32):  [Read-Write] The number of unique tiles to generate. The final simulation is a procedurally determined combination of the various unique tiles.
    - ``override_foliage_terrain_materials`` (Array[MaterialInterface]):  [Read-Write] Procedural foliage will only spawn on materials specified here. These are only used if 'Use Override Foliage Terrain Materials' is checked.
    - ``random_seed`` (int32):  [Read-Write] The seed used for generating the randomness of the simulation.
    - ``tile_size`` (float):  [Read-Write] Length of the tile (in cm) along one axis. The total area of the tile will be TileSize*TileSize.
    - ``use_override_foliage_terrain_materials`` (bool):  [Read-Write] If checked, will override the default behavior of using the global foliage material list and instead use the Override Foliage Terrain Materials defined here.
      If the override is used, you must manually provide ALL materials this procedural foliage spawner should spawn on top of.
    """
    @property
    def random_seed(self) -> int:
        r"""
        (int32):  [Read-Only] The seed used for generating the randomness of the simulation.
        """
        ...
    @property
    def tile_size(self) -> float:
        r"""
        (float):  [Read-Only] Length of the tile (in cm) along one axis. The total area of the tile will be TileSize*TileSize.
        """
        ...
    @property
    def num_unique_tiles(self) -> int:
        r"""
        (int32):  [Read-Only] The number of unique tiles to generate. The final simulation is a procedurally determined combination of the various unique tiles.
        """
        ...
    @property
    def minimum_quad_tree_size(self) -> float:
        r"""
        (float):  [Read-Only] Minimum size of the quad tree used during the simulation. Reduce if too many instances are in splittable leaf quads (as warned in the log).
        """
        ...
    def simulate(self, num_steps: int = -1) -> None:
        r"""
        x.simulate(num_steps=-1) -> None
        Simulate
        
        Args:
            num_steps (int32):
        """
        ...

class ProceduralFoliage(ProceduralFoliageSpawner):
    r"""
    deprecated: 'ProceduralFoliage' was renamed to 'ProceduralFoliageSpawner'.
    """
    ...

class ProceduralFoliageVolume(Volume):
    r"""
    Procedural Foliage Volume
    
    **C++ Source:**
    
    - **Module**: Foliage
    - **File**: ProceduralFoliageVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``procedural_component`` (ProceduralFoliageComponent):  [Read-Only]
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def procedural_component(self) -> ProceduralFoliageComponent:
        r"""
        (ProceduralFoliageComponent):  [Read-Only]
        """
        ...

class ProceduralFoliageActor(ProceduralFoliageVolume):
    r"""
    deprecated: 'ProceduralFoliageActor' was renamed to 'ProceduralFoliageVolume'.
    """
    ...

class ImageWriteBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Function library containing utility methods for writing images on a global async queue
    
    **C++ Source:**
    
    - **Module**: ImageWriteQueue
    - **File**: ImageWriteBlueprintLibrary.h
    
    """
    @classmethod
    def export_to_disk(cls, texture: Texture, filename: str, options: ImageWriteOptions) -> None:
        r"""
        X.export_to_disk(texture, filename, options) -> None
        Export the specified texture to disk
        
        Args:
            texture (Texture): The texture or render target to export
            filename (str): The filename on disk to save as
            options (ImageWriteOptions): Parameters defining the various export options
        """
        ...

class SparseVolumeTextureViewerComponent(PrimitiveComponent):
    r"""
    A component used to inspect sparse volume textures.
    
    **C++ Source:**
    
    - **Module**: Renderer
    - **File**: SparseVolumeTextureViewerComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``apply_per_frame_transforms`` (bool):  [Read-Write]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``blocking_streaming_requests`` (bool):  [Read-Write]
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``extinction`` (float):  [Read-Write]
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``frame`` (float):  [Read-Write]
    - ``frame_rate`` (float):  [Read-Write]
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``looping`` (bool):  [Read-Write]
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mip_level`` (int32):  [Read-Write]
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pivot_at_centroid`` (bool):  [Read-Write]
    - ``playing`` (bool):  [Read-Write]
    - ``preview_attribute`` (SparseVolumeTexturePreviewAttribute):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_playback`` (bool):  [Read-Write]
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sparse_volume_texture_preview`` (SparseVolumeTexture):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``voxel_size`` (float):  [Read-Write]
    """
    @property
    def sparse_volume_texture_preview(self) -> SparseVolumeTexture:
        r"""
        (SparseVolumeTexture):  [Read-Write]
        """
        ...
    @sparse_volume_texture_preview.setter
    def sparse_volume_texture_preview(self, value: SparseVolumeTexture) -> None:
        ...
    @property
    def frame(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @frame.setter
    def frame(self, value: float) -> None:
        ...
    @property
    def frame_rate(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @frame_rate.setter
    def frame_rate(self, value: float) -> None:
        ...
    @property
    def playing(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @playing.setter
    def playing(self, value: bool) -> None:
        ...
    @property
    def looping(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @looping.setter
    def looping(self, value: bool) -> None:
        ...
    @property
    def reverse_playback(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def blocking_streaming_requests(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def apply_per_frame_transforms(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def pivot_at_centroid(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def voxel_size(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @voxel_size.setter
    def voxel_size(self, value: float) -> None:
        ...
    @property
    def preview_attribute(self) -> SparseVolumeTexturePreviewAttribute:
        r"""
        (SparseVolumeTexturePreviewAttribute):  [Read-Write]
        """
        ...
    @preview_attribute.setter
    def preview_attribute(self, value: SparseVolumeTexturePreviewAttribute) -> None:
        ...
    @property
    def mip_level(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @mip_level.setter
    def mip_level(self, value: int) -> None:
        ...
    @property
    def extinction(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @extinction.setter
    def extinction(self, value: float) -> None:
        ...

class Info(Actor):
    r"""
    Info is the base class of an Actor that isn't meant to have a physical representation in the world, used primarily
    for "manager" type classes that hold settings data about the world, but might need to be an Actor for replication purposes.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Info.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class SparseVolumeTextureViewer(Info):
    r"""
    A placeable actor that represents a participating media material around a planet, e.g. clouds.
    
    **C++ Source:**
    
    - **Module**: Renderer
    - **File**: SparseVolumeTextureViewerComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``sparse_volume_texture_viewer_component`` (SparseVolumeTextureViewerComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def sparse_volume_texture_viewer_component(self) -> SparseVolumeTextureViewerComponent:
        r"""
        (SparseVolumeTextureViewerComponent):  [Read-Only]
        """
        ...

class ControlPointMeshComponent(StaticMeshComponent):
    r"""
    Control Point Mesh Component
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: ControlPointMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    ...

class LandscapeProxy(PartitionActor):
    r"""
    Landscape Proxy
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``bake_material_position_offset_into_collision`` (bool):  [Read-Write] Whether to bake the landscape material's vertical world position offset into the collision heightfield.
                    Note: Only z (vertical) offset is supported. XY offsets are ignored.
                    Does not work with an XY offset map (mesh collision)
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``body_instance`` (BodyInstance):  [Read-Write] Collision profile settings for this landscape
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows. This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades(only for directional lights).  This flag is only used if CastShadow is true.
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.  Controls whether the primitive should cast shadows when hidden.  This flag is only used if CastShadow is true.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.  This flag is only used if CastShadow is true.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``collision_mip_level`` (int32):  [Read-Write] Landscape LOD to use for collision tests. Higher numbers use less memory and process faster, but are much less accurate
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_phys_material`` (PhysicalMaterial):  [Read-Write] Default physical material, used when no per-layer values physical materials
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_nanite`` (bool):  [Read-Write] Use Nanite to render landscape as a mesh on supported platforms.
    - ``export_lod`` (int32):  [Read-Write] LOD level to use when exporting the landscape to obj or FBX
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``fill_collision_under_landscape_for_navmesh`` (bool):  [Read-Write] Set to true to prevent navmesh generation under the terrain geometry
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events`` (bool):  [Read-Write] If true, Landscape will generate overlap events when other components are overlapping it (eg Begin Overlap).
      Both the Landscape and the other component must have this flag enabled for overlap events to occur.
      see: [Overlap Events](https://docs.unrealengine.com/InteractiveExperiences/Physics/Collision/Overview#overlapandgenerateoverlapevents)
      see: UpdateOverlaps(), BeginComponentOverlap(), EndComponentOverlap()
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``hlod_mesh_source_lod`` (int32):  [Read-Write] Specify which LOD to use for the HLOD mesh if HLODMeshSourceLODPolicy is set to SpecificLOD
    - ``hlod_mesh_source_lod_policy`` (LandscapeHLODMeshSourceLODPolicy):  [Read-Write] Specify how to choose the LOD used as input for the HLOD mesh
    - ``hlod_texture_size`` (int32):  [Read-Write] Specify the texture size to use for the HLOD mesh if HLODTextureSizePolicy is set to SpecificSize
    - ``hlod_texture_size_policy`` (LandscapeHLODTextureSizePolicy):  [Read-Write] Specify how to choose the texture size of the resulting HLOD mesh
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``landscape_hole_material`` (MaterialInterface):  [Read-Write] Material used to render landscape components with holes. If not set, LandscapeMaterial will be used (blend mode will be overridden to Masked if it is set to Opaque)
    - ``landscape_material`` (MaterialInterface):  [Read-Write] Combined material used to render the landscape
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this Landscape should be in.  Lights with matching channels will affect the Landscape.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``lod0_distribution_setting`` (float):  [Read-Write] The distribution setting used to change the LOD 0 generation, 1.25 is the normal distribution, numbers influence directly the LOD0 proportion on screen.
    - ``lod0_screen_size`` (float):  [Read-Write] This is the starting screen size used to calculate the distribution. You can increase the value if you want less LOD0 component, and you use very large landscape component.
    - ``lod_blend_range`` (float):  [Read-Write] This controls the area that blends LOD between neighboring sections. At 1.0 it blends across the entire section, and lower numbers reduce the blend region to be closer to the boundary.
    - ``lod_distribution_setting`` (float):  [Read-Write] The distribution setting used to change the LOD generation, 3 is the normal distribution, small number mean you want your last LODs to take more screen space and big number mean you want your first LODs to take more screen space.
    - ``lod_group_key`` (uint32):  [Read-Write] Specifies the LOD Group (Zero is No Group). All landscapes in the same group calculate their LOD together, allowing matching border LODs to fix geometry seams.
    - ``max_lod_level`` (int32):  [Read-Write] Max LOD level to use when rendering, -1 means the max available
    - ``max_painted_layers_per_component`` (int32):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``nanite_lod_index`` (int32):  [Read-Write] LOD level of the landscape when generating the Nanite mesh. Mostly there for debug reasons, since Nanite is meant to allow high density meshes, we want to use 0 most of the times.
    - ``nanite_max_edge_length_factor`` (float):  [Read-Write]
    - ``nanite_position_precision`` (int32):  [Read-Write]
    - ``nanite_skirt_depth`` (float):  [Read-Write]
    - ``nanite_skirt_enabled`` (bool):  [Read-Write]
    - ``navigation_geometry_gathering_mode`` (NavDataGatheringMode):  [Read-Write]
    - ``negative_z_bounds_extension`` (float):  [Read-Write] Allows overriding the landscape bounds. This is useful if you distort the landscape with world-position-offset, for example
      Extension value in the negative Z axis, positive value increases bound size
      Note that this can also be overridden per-component when the component is selected with the component select tool
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``non_nanite_virtual_shadow_map_constant_depth_bias`` (float):  [Read-Write] Constant bias to handle the worst artifacts of the continuous LOD morphing when rendering to VSM.
      Only applies when using non-Nanite landscape and VSM.
    - ``non_nanite_virtual_shadow_map_invalidation_height_error_threshold`` (float):  [Read-Write] For non-Nanite landscape, cached VSM pages need to be invalidated when continuous LOD morphing introduces a height difference that is too large between the current landscape component's profile and the one that was used when the shadow was shadow was last cached.
      This height threshold (in Unreal units) controls this invalidation rate (a smaller threshold will reduce the likeliness of shadow artifacts, but will make the invalidations occur more frequently, which is not desirable in terms of performance.
      Disabled if 0.0.
      Only applies when using non-Nanite landscape and VSM.
    - ``non_nanite_virtual_shadow_map_invalidation_screen_size_limit`` (float):  [Read-Write] Screen size under which VSM invalidation stops occurring.
      As the height difference between 2 mip levels increases when the LOD level increases (because of undersampling), VSM pages tend to be invalidated more frequently even though it's getting less and less relevant to do so, since this will mean that the screen size of the landscape section decreases, thus the artifacts actually become less noticeable.
      We therefore artificially attenuate the VSM invalidation rate as the screen size decreases, to avoid invalidating VSM pages too often, as it becomes less and less impactful.
      A higher value will accentuate this attenuation (better performance but more artifacts) and vice versa.
      If 0.0, the attenuation of the VSM invalidation rate will be disabled entirely.
      Only applies when using non-Nanite landscape and VSM.
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``per_lod_override_materials`` (Array[LandscapePerLODMaterialOverride]):  [Read-Write]
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``positive_z_bounds_extension`` (float):  [Read-Write] Allows overriding the landscape bounds. This is useful if you distort the landscape with world-position-offset, for example
      Extension value in the positive Z axis, positive value increases bound size
      Note that this can also be overridden per-component when the component is selected with the component select tool
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``render_custom_depth`` (bool):  [Read-Write] If true, the Landscape will be rendered in the CustomDepth pass (usually used for outlines)
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw this landscape.
      The material also needs to be set up to output to a virtual texture.
    - ``scalable_lod0_distribution_setting`` (PerQualityLevelFloat):  [Read-Write] Scalable (per-quality) version of 'LOD 0'.
    - ``scalable_lod0_screen_size`` (PerQualityLevelFloat):  [Read-Write] Scalable (per-quality) version of 'LOD 0 Screen Size'.
    - ``scalable_lod_distribution_setting`` (PerQualityLevelFloat):  [Read-Write] Scalable (per-quality) version of 'Other LODs'.
    - ``set_create_runtime_virtual_texture_volumes`` (bool):  [Read-Only] Placeholder for details customization button.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``simple_collision_mip_level`` (int32):  [Read-Write] If set higher than the "Collision Mip Level", this specifies the Landscape LOD to use for "simple collision" tests, otherwise the "Collision Mip Level" is used for both simple and complex collision.
      Does not work with an XY offset map (mesh collision)
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``static_lighting_lod`` (int32):  [Read-Write] LOD level to use when running lightmass (increase to 1 or 2 for large landscapes to stop lightmass crashing)
    - ``static_lighting_resolution`` (float):  [Read-Write] The resolution to cache lighting at, in texels/quad in one axis
      Total resolution would be changed by StaticLightingResolution*StaticLightingResolution
      Automatically calculate proper value for removing seams
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows artists to adjust the distance where textures using UV 0 are streamed in/out.
      1.0 is the default, whereas a higher value increases the streamed-in resolution.
      Value can be < 0 (from legcay content, or code changes)
    - ``strip_grass_when_cooked_client`` (bool):  [Read-Write] Strip Grass data when cooked for client
    - ``strip_grass_when_cooked_server`` (bool):  [Read-Write] Strip Grass data when cooked for server
    - ``strip_physics_when_cooked_client`` (bool):  [Read-Write] Strip Physics/collision components when cooked for client
    - ``strip_physics_when_cooked_server`` (bool):  [Read-Write] Strip Physics/collision components when cooked for server
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_compressed_heightmap_storage`` (bool):  [Read-Write] Enable compressed heightmap texture storage.
    - ``use_dynamic_material_instance`` (bool):  [Read-Write] When set to true it will generate MaterialInstanceDynamic for each components, so material can be changed at runtime
    - ``use_landscape_for_culling_invisible_hlod_vertices`` (bool):  [Read-Write] Flag whether or not this Landscape's surface can be used for culling hidden triangles *
    - ``use_material_position_offset_in_static_lighting`` (bool):  [Read-Write] Whether to use the landscape material's vertical world position offset when calculating static lighting.
      Note: Only z (vertical) offset is supported. XY offsets are ignored.
      Does not work correctly with an XY offset map (mesh collision)
    - ``use_scalable_lod_settings`` (bool):  [Read-Write] Allows to specify LOD distribution settings per quality level. Using this will ignore the r.LandscapeLOD0DistributionScale CVar.
    - ``used_for_navigation`` (bool):  [Read-Write] Hints navigation system whether this landscape will ever be navigated on. true by default, but make sure to set it to false for faraway, background landscapes
    - ``virtual_texture_lod_bias`` (int32):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
      Higher values reduce vertex count when rendering to the runtime virtual texture.
    - ``virtual_texture_num_lods`` (int32):  [Read-Write] Number of mesh levels to use when rendering landscape into runtime virtual texture.
      Lower values reduce vertex count when rendering to the runtime virtual texture but decrease accuracy when using values that require vertex interpolation.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``virtual_texture_render_with_quad`` (bool):  [Read-Write] Use a single quad to render this landscape to runtime virtual texture pages.
      This is the fastest path but it only gives correct results if the runtime virtual texture orientation is aligned with the landscape.
      If the two are unaligned we need to render to the virtual texture using LODs with sufficient density.
    - ``virtual_texture_render_with_quad_hq`` (bool):  [Read-Write] Use highest quality heightmap interpolation when using a single quad to render this landscape to runtime virtual texture pages.
      This also requires the project setting: r.VT.RVT.HighQualityPerPixelHeight.
    """
    @property
    def enable_nanite(self) -> bool:
        r"""
        (bool):  [Read-Only] Use Nanite to render landscape as a mesh on supported platforms.
        """
        ...
    @property
    def landscape_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Write] Combined material used to render the landscape
        """
        ...
    @landscape_material.setter
    def landscape_material(self, value: MaterialInterface) -> None:
        ...
    @property
    def runtime_virtual_textures(self) -> Array[RuntimeVirtualTexture]:
        r"""
        (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw this landscape.
        The material also needs to be set up to output to a virtual texture.
        """
        ...
    @runtime_virtual_textures.setter
    def runtime_virtual_textures(self, value: Array[RuntimeVirtualTexture]) -> None:
        ...
    @property
    def virtual_texture_render_with_quad(self) -> bool:
        r"""
        (bool):  [Read-Only] Use a single quad to render this landscape to runtime virtual texture pages.
        This is the fastest path but it only gives correct results if the runtime virtual texture orientation is aligned with the landscape.
        If the two are unaligned we need to render to the virtual texture using LODs with sufficient density.
        """
        ...
    @property
    def virtual_texture_render_with_quad_hq(self) -> bool:
        r"""
        (bool):  [Read-Only] Use highest quality heightmap interpolation when using a single quad to render this landscape to runtime virtual texture pages.
        This also requires the project setting: r.VT.RVT.HighQualityPerPixelHeight.
        """
        ...
    @property
    def virtual_texture_num_lods(self) -> int:
        r"""
        (int32):  [Read-Only] Number of mesh levels to use when rendering landscape into runtime virtual texture.
        Lower values reduce vertex count when rendering to the runtime virtual texture but decrease accuracy when using values that require vertex interpolation.
        """
        ...
    @property
    def virtual_texture_lod_bias(self) -> int:
        r"""
        (int32):  [Read-Only] Bias to the LOD selected for rendering to runtime virtual textures.
        Higher values reduce vertex count when rendering to the runtime virtual texture.
        """
        ...
    @property
    def virtual_texture_render_pass_type(self) -> RuntimeVirtualTextureMainPassType:
        r"""
        (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
        """
        ...
    @virtual_texture_render_pass_type.setter
    def virtual_texture_render_pass_type(self, value: RuntimeVirtualTextureMainPassType) -> None:
        ...
    @property
    def cast_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the primitive component should cast a shadow or not.
        """
        ...
    @property
    def cast_dynamic_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
        """
        ...
    @property
    def cast_static_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
        """
        ...
    @property
    def shadow_cache_invalidation_behavior(self) -> ShadowCacheInvalidationBehavior:
        r"""
        (ShadowCacheInvalidationBehavior):  [Read-Only] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
        """
        ...
    @property
    def cast_contact_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the object should cast contact shadows. This flag is only used if CastShadow is true.
        """
        ...
    @property
    def cast_far_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] When enabled, the component will be rendering into the far shadow cascades(only for directional lights).  This flag is only used if CastShadow is true.
        """
        ...
    @property
    def cast_hidden_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, the primitive will cast shadows even if bHidden is true.  Controls whether the primitive should cast shadows when hidden.  This flag is only used if CastShadow is true.
        """
        ...
    @property
    def cast_shadow_as_two_sided(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether this primitive should cast dynamic shadows as if it were a two sided material.  This flag is only used if CastShadow is true.
        """
        ...
    @property
    def affect_distance_field_lighting(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
        """
        ...
    @property
    def lighting_channels(self) -> LightingChannels:
        r"""
        (LightingChannels):  [Read-Only] Channels that this Landscape should be in.  Lights with matching channels will affect the Landscape.
        These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
        """
        ...
    @property
    def render_custom_depth(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, the Landscape will be rendered in the CustomDepth pass (usually used for outlines)
        """
        ...
    @property
    def custom_depth_stencil_write_mask(self) -> RendererStencilMask:
        r"""
        (RendererStencilMask):  [Read-Only] Mask used for stencil buffer writes.
        """
        ...
    @property
    def custom_depth_stencil_value(self) -> int:
        r"""
        (int32):  [Read-Only] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
        """
        ...
    @property
    def ld_max_draw_distance(self) -> float:
        r"""
        (float):  [Read-Only] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
        """
        ...
    @property
    def body_instance(self) -> BodyInstance:
        r"""
        (BodyInstance):  [Read-Only] Collision profile settings for this landscape
        """
        ...
    @property
    def generate_overlap_events(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, Landscape will generate overlap events when other components are overlapping it (eg Begin Overlap).
        Both the Landscape and the other component must have this flag enabled for overlap events to occur.
        see: [Overlap Events](https://docs.unrealengine.com/InteractiveExperiences/Physics/Collision/Overview#overlapandgenerateoverlapevents)
        see: UpdateOverlaps(), BeginComponentOverlap(), EndComponentOverlap()
        """
        ...
    def set_landscape_material_vector_parameter_value(self, parameter_name: Name, value: LinearColor) -> None:
        r"""
        x.set_landscape_material_vector_parameter_value(parameter_name, value) -> None
        Set an MID vector parameter value for all landscape components.
        
        Args:
            parameter_name (Name): 
            value (LinearColor):
        """
        ...
    def set_landscape_material_texture_parameter_value(self, parameter_name: Name, value: Texture) -> None:
        r"""
        x.set_landscape_material_texture_parameter_value(parameter_name, value) -> None
        Set an MID texture parameter value for all landscape components.
        
        Args:
            parameter_name (Name): 
            value (Texture):
        """
        ...
    def set_landscape_material_scalar_parameter_value(self, parameter_name: Name, value: float) -> None:
        r"""
        x.set_landscape_material_scalar_parameter_value(parameter_name, value) -> None
        Set a MID scalar (float) parameter value for all landscape components.
        
        Args:
            parameter_name (Name): 
            value (float):
        """
        ...
    def landscape_import_weightmap_from_render_target(self, render_target: TextureRenderTarget2D, layer_name: Name) -> bool:
        r"""
        x.landscape_import_weightmap_from_render_target(render_target, layer_name) -> bool
        Overwrites a landscape weightmap with render target data
        Only works in the editor
        
        Args:
            render_target (TextureRenderTarget2D): 
            layer_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def landscape_import_heightmap_from_render_target(self, render_target: TextureRenderTarget2D, import_height_from_rg_channel: bool = False) -> bool:
        r"""
        x.landscape_import_heightmap_from_render_target(render_target, import_height_from_rg_channel=False) -> bool
        Overwrites a landscape heightmap with render target data
        
        Args:
            render_target (TextureRenderTarget2D): Valid render target with a format of RTF_RGBA16f, RTF_RGBA32f or RTF_RGBA8
            import_height_from_rg_channel (bool): Only relevant when using format RTF_RGBA16f or RTF_RGBA32f, and will tell us if we should import the height data from the R channel only of the Render target or from R & G. Note that using RTF_RGBA16f with InImportHeightFromRGChannel == false, could have precision loss Only works in the editor
        
        Returns:
            bool:
        """
        ...
    def landscape_export_weightmap_to_render_target(self, render_target: TextureRenderTarget2D, layer_name: Name) -> bool:
        r"""
        x.landscape_export_weightmap_to_render_target(render_target, layer_name) -> bool
        Output a landscape weightmap to a render target
        Only works in the editor
        
        Args:
            render_target (TextureRenderTarget2D): 
            layer_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def landscape_export_heightmap_to_render_target(self, render_target: TextureRenderTarget2D, export_height_into_rg_channel: bool = False, export_landscape_proxies: bool = True) -> bool:
        r"""
        x.landscape_export_heightmap_to_render_target(render_target, export_height_into_rg_channel=False, export_landscape_proxies=True) -> bool
        Output a landscape heightmap to a render target
        
        Args:
            render_target (TextureRenderTarget2D): Valid render target with a format of RTF_RGBA16f, RTF_RGBA32f or RTF_RGBA8
            export_height_into_rg_channel (bool): Tell us if we should export the height that is internally stored as R & G (for 16 bits) to a single R channel of the render target (the format need to be RTF_RGBA16f or RTF_RGBA32f) Note that using RTF_RGBA16f with InExportHeightIntoRGChannel == false, could have precision loss.
            export_landscape_proxies (bool): Option to also export components of all proxies of Landscape actor (if LandscapeProxy is the Landscape Actor)
        
        Returns:
            bool:
        """
        ...
    def get_landscape_actor(self) -> Landscape:
        r"""
        x.get_landscape_actor() -> Landscape
        Get Landscape Actor
        
        Returns:
            Landscape:
        """
        ...
    def editor_apply_spline(self, spline_component: SplineComponent, start_width: float = 200.000000, end_width: float = 200.000000, start_side_falloff: float = 200.000000, end_side_falloff: float = 200.000000, start_roll: float = 0.000000, end_roll: float = 0.000000, num_subdivisions: int = 20, raise_heights: bool = True, lower_heights: bool = True, paint_layer: LandscapeLayerInfoObject = None, edit_layer_name: Name = "None") -> None:
        r"""
        x.editor_apply_spline(spline_component, start_width=200.000000, end_width=200.000000, start_side_falloff=200.000000, end_side_falloff=200.000000, start_roll=0.000000, end_roll=0.000000, num_subdivisions=20, raise_heights=True, lower_heights=True, paint_layer=None, edit_layer_name="None") -> None
        Deform landscape using a given spline
        
        Args:
            spline_component (SplineComponent): The component containing the spline data
            start_width (float): Width of the spline at the start node, in Spline Component local space
            end_width (float): Width of the spline at the end node, in Spline Component local space
            start_side_falloff (float): Width of the falloff at either side of the spline at the start node, in Spline Component local space
            end_side_falloff (float): Width of the falloff at either side of the spline at the end node, in Spline Component local space
            start_roll (float): Roll applied to the spline at the start node, in degrees. 0 is flat
            end_roll (float): Roll applied to the spline at the end node, in degrees. 0 is flat
            num_subdivisions (int32): Number of triangles to place along the spline when applying it to the landscape. Higher numbers give better results, but setting it too high will be slow and may cause artifacts
            raise_heights (bool): Allow the landscape to be raised up to the level of the spline. If both bRaiseHeights and bLowerHeights are false, no height modification of the landscape will be performed
            lower_heights (bool): Allow the landscape to be lowered down to the level of the spline. If both bRaiseHeights and bLowerHeights are false, no height modification of the landscape will be performed
            paint_layer (LandscapeLayerInfoObject): LayerInfo to paint, or none to skip painting. The landscape must be configured with the same layer info in one of its layers or this will do nothing!
            edit_layer_name (Name): Name of the landscape edit layer to affect (in Edit Layers mode)
        """
        ...
    def delete_unused_layers(self) -> None:
        r"""
        x.delete_unused_layers() -> None
        Delete all unused layers in components. Warning: any update of the component could re-introduce them.
        """
        ...
    def change_lod_distance_factor(self, lod_distance_factor: float) -> None:
        r"""
        x.change_lod_distance_factor(lod_distance_factor) -> None
        Change the Level of Detail distance factor
        deprecated: This value can't be changed anymore, you should edit the property LODDistributionSetting of the Landscape
        
        Args:
            lod_distance_factor (float):
        """
        ...
    def change_component_screen_size_to_use_sub_sections(self, component_screen_size_to_use_sub_sections: float) -> None:
        r"""
        x.change_component_screen_size_to_use_sub_sections(component_screen_size_to_use_sub_sections) -> None
        Change ComponentScreenSizeToUseSubSections value on the render proxy.
        deprecated: This value can't be changed anymore and has been ineffective for several versions now. Please stop using it
        
        Args:
            component_screen_size_to_use_sub_sections (float):
        """
        ...

class Landscape(LandscapeProxy):
    r"""
    Landscape
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: Landscape.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``are_new_landscape_actors_spatially_loaded`` (bool):  [Read-Write] Landscape actor has authority on default streaming behavior for new actors : LandscapeStreamingProxies & LandscapeSplineActors
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``bake_material_position_offset_into_collision`` (bool):  [Read-Write] Whether to bake the landscape material's vertical world position offset into the collision heightfield.
                    Note: Only z (vertical) offset is supported. XY offsets are ignored.
                    Does not work with an XY offset map (mesh collision)
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``body_instance`` (BodyInstance):  [Read-Write] Collision profile settings for this landscape
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``can_have_layers_content`` (bool):  [Read-Write]
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows. This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades(only for directional lights).  This flag is only used if CastShadow is true.
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.  Controls whether the primitive should cast shadows when hidden.  This flag is only used if CastShadow is true.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.  This flag is only used if CastShadow is true.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``collision_mip_level`` (int32):  [Read-Write] Landscape LOD to use for collision tests. Higher numbers use less memory and process faster, but are much less accurate
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_phys_material`` (PhysicalMaterial):  [Read-Write] Default physical material, used when no per-layer values physical materials
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_nanite`` (bool):  [Read-Write] Use Nanite to render landscape as a mesh on supported platforms.
    - ``export_lod`` (int32):  [Read-Write] LOD level to use when exporting the landscape to obj or FBX
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``fill_collision_under_landscape_for_navmesh`` (bool):  [Read-Write] Set to true to prevent navmesh generation under the terrain geometry
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events`` (bool):  [Read-Write] If true, Landscape will generate overlap events when other components are overlapping it (eg Begin Overlap).
      Both the Landscape and the other component must have this flag enabled for overlap events to occur.
      see: [Overlap Events](https://docs.unrealengine.com/InteractiveExperiences/Physics/Collision/Overview#overlapandgenerateoverlapevents)
      see: UpdateOverlaps(), BeginComponentOverlap(), EndComponentOverlap()
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``hlod_mesh_source_lod`` (int32):  [Read-Write] Specify which LOD to use for the HLOD mesh if HLODMeshSourceLODPolicy is set to SpecificLOD
    - ``hlod_mesh_source_lod_policy`` (LandscapeHLODMeshSourceLODPolicy):  [Read-Write] Specify how to choose the LOD used as input for the HLOD mesh
    - ``hlod_texture_size`` (int32):  [Read-Write] Specify the texture size to use for the HLOD mesh if HLODTextureSizePolicy is set to SpecificSize
    - ``hlod_texture_size_policy`` (LandscapeHLODTextureSizePolicy):  [Read-Write] Specify how to choose the texture size of the resulting HLOD mesh
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``landscape_hole_material`` (MaterialInterface):  [Read-Write] Material used to render landscape components with holes. If not set, LandscapeMaterial will be used (blend mode will be overridden to Masked if it is set to Opaque)
    - ``landscape_material`` (MaterialInterface):  [Read-Write] Combined material used to render the landscape
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this Landscape should be in.  Lights with matching channels will affect the Landscape.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``lod0_distribution_setting`` (float):  [Read-Write] The distribution setting used to change the LOD 0 generation, 1.25 is the normal distribution, numbers influence directly the LOD0 proportion on screen.
    - ``lod0_screen_size`` (float):  [Read-Write] This is the starting screen size used to calculate the distribution. You can increase the value if you want less LOD0 component, and you use very large landscape component.
    - ``lod_blend_range`` (float):  [Read-Write] This controls the area that blends LOD between neighboring sections. At 1.0 it blends across the entire section, and lower numbers reduce the blend region to be closer to the boundary.
    - ``lod_distribution_setting`` (float):  [Read-Write] The distribution setting used to change the LOD generation, 3 is the normal distribution, small number mean you want your last LODs to take more screen space and big number mean you want your first LODs to take more screen space.
    - ``lod_group_key`` (uint32):  [Read-Write] Specifies the LOD Group (Zero is No Group). All landscapes in the same group calculate their LOD together, allowing matching border LODs to fix geometry seams.
    - ``max_lod_level`` (int32):  [Read-Write] Max LOD level to use when rendering, -1 means the max available
    - ``max_painted_layers_per_component`` (int32):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``nanite_lod_index`` (int32):  [Read-Write] LOD level of the landscape when generating the Nanite mesh. Mostly there for debug reasons, since Nanite is meant to allow high density meshes, we want to use 0 most of the times.
    - ``nanite_max_edge_length_factor`` (float):  [Read-Write]
    - ``nanite_position_precision`` (int32):  [Read-Write]
    - ``nanite_skirt_depth`` (float):  [Read-Write]
    - ``nanite_skirt_enabled`` (bool):  [Read-Write]
    - ``navigation_geometry_gathering_mode`` (NavDataGatheringMode):  [Read-Write]
    - ``negative_z_bounds_extension`` (float):  [Read-Write] Allows overriding the landscape bounds. This is useful if you distort the landscape with world-position-offset, for example
      Extension value in the negative Z axis, positive value increases bound size
      Note that this can also be overridden per-component when the component is selected with the component select tool
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``non_nanite_virtual_shadow_map_constant_depth_bias`` (float):  [Read-Write] Constant bias to handle the worst artifacts of the continuous LOD morphing when rendering to VSM.
      Only applies when using non-Nanite landscape and VSM.
    - ``non_nanite_virtual_shadow_map_invalidation_height_error_threshold`` (float):  [Read-Write] For non-Nanite landscape, cached VSM pages need to be invalidated when continuous LOD morphing introduces a height difference that is too large between the current landscape component's profile and the one that was used when the shadow was shadow was last cached.
      This height threshold (in Unreal units) controls this invalidation rate (a smaller threshold will reduce the likeliness of shadow artifacts, but will make the invalidations occur more frequently, which is not desirable in terms of performance.
      Disabled if 0.0.
      Only applies when using non-Nanite landscape and VSM.
    - ``non_nanite_virtual_shadow_map_invalidation_screen_size_limit`` (float):  [Read-Write] Screen size under which VSM invalidation stops occurring.
      As the height difference between 2 mip levels increases when the LOD level increases (because of undersampling), VSM pages tend to be invalidated more frequently even though it's getting less and less relevant to do so, since this will mean that the screen size of the landscape section decreases, thus the artifacts actually become less noticeable.
      We therefore artificially attenuate the VSM invalidation rate as the screen size decreases, to avoid invalidating VSM pages too often, as it becomes less and less impactful.
      A higher value will accentuate this attenuation (better performance but more artifacts) and vice versa.
      If 0.0, the attenuation of the VSM invalidation rate will be disabled entirely.
      Only applies when using non-Nanite landscape and VSM.
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``per_lod_override_materials`` (Array[LandscapePerLODMaterialOverride]):  [Read-Write]
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``positive_z_bounds_extension`` (float):  [Read-Write] Allows overriding the landscape bounds. This is useful if you distort the landscape with world-position-offset, for example
      Extension value in the positive Z axis, positive value increases bound size
      Note that this can also be overridden per-component when the component is selected with the component select tool
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``render_custom_depth`` (bool):  [Read-Write] If true, the Landscape will be rendered in the CustomDepth pass (usually used for outlines)
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw this landscape.
      The material also needs to be set up to output to a virtual texture.
    - ``scalable_lod0_distribution_setting`` (PerQualityLevelFloat):  [Read-Write] Scalable (per-quality) version of 'LOD 0'.
    - ``scalable_lod0_screen_size`` (PerQualityLevelFloat):  [Read-Write] Scalable (per-quality) version of 'LOD 0 Screen Size'.
    - ``scalable_lod_distribution_setting`` (PerQualityLevelFloat):  [Read-Write] Scalable (per-quality) version of 'Other LODs'.
    - ``set_create_runtime_virtual_texture_volumes`` (bool):  [Read-Only] Placeholder for details customization button.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``simple_collision_mip_level`` (int32):  [Read-Write] If set higher than the "Collision Mip Level", this specifies the Landscape LOD to use for "simple collision" tests, otherwise the "Collision Mip Level" is used for both simple and complex collision.
      Does not work with an XY offset map (mesh collision)
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``static_lighting_lod`` (int32):  [Read-Write] LOD level to use when running lightmass (increase to 1 or 2 for large landscapes to stop lightmass crashing)
    - ``static_lighting_resolution`` (float):  [Read-Write] The resolution to cache lighting at, in texels/quad in one axis
      Total resolution would be changed by StaticLightingResolution*StaticLightingResolution
      Automatically calculate proper value for removing seams
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows artists to adjust the distance where textures using UV 0 are streamed in/out.
      1.0 is the default, whereas a higher value increases the streamed-in resolution.
      Value can be < 0 (from legcay content, or code changes)
    - ``strip_grass_when_cooked_client`` (bool):  [Read-Write] Strip Grass data when cooked for client
    - ``strip_grass_when_cooked_server`` (bool):  [Read-Write] Strip Grass data when cooked for server
    - ``strip_physics_when_cooked_client`` (bool):  [Read-Write] Strip Physics/collision components when cooked for client
    - ``strip_physics_when_cooked_server`` (bool):  [Read-Write] Strip Physics/collision components when cooked for server
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_compressed_heightmap_storage`` (bool):  [Read-Write] Enable compressed heightmap texture storage.
    - ``use_dynamic_material_instance`` (bool):  [Read-Write] When set to true it will generate MaterialInstanceDynamic for each components, so material can be changed at runtime
    - ``use_landscape_for_culling_invisible_hlod_vertices`` (bool):  [Read-Write] Flag whether or not this Landscape's surface can be used for culling hidden triangles *
    - ``use_material_position_offset_in_static_lighting`` (bool):  [Read-Write] Whether to use the landscape material's vertical world position offset when calculating static lighting.
      Note: Only z (vertical) offset is supported. XY offsets are ignored.
      Does not work correctly with an XY offset map (mesh collision)
    - ``use_scalable_lod_settings`` (bool):  [Read-Write] Allows to specify LOD distribution settings per quality level. Using this will ignore the r.LandscapeLOD0DistributionScale CVar.
    - ``used_for_navigation`` (bool):  [Read-Write] Hints navigation system whether this landscape will ever be navigated on. true by default, but make sure to set it to false for faraway, background landscapes
    - ``virtual_texture_lod_bias`` (int32):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
      Higher values reduce vertex count when rendering to the runtime virtual texture.
    - ``virtual_texture_num_lods`` (int32):  [Read-Write] Number of mesh levels to use when rendering landscape into runtime virtual texture.
      Lower values reduce vertex count when rendering to the runtime virtual texture but decrease accuracy when using values that require vertex interpolation.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``virtual_texture_render_with_quad`` (bool):  [Read-Write] Use a single quad to render this landscape to runtime virtual texture pages.
      This is the fastest path but it only gives correct results if the runtime virtual texture orientation is aligned with the landscape.
      If the two are unaligned we need to render to the virtual texture using LODs with sufficient density.
    - ``virtual_texture_render_with_quad_hq`` (bool):  [Read-Write] Use highest quality heightmap interpolation when using a single quad to render this landscape to runtime virtual texture pages.
      This also requires the project setting: r.VT.RVT.HighQualityPerPixelHeight.
    """
    def render_weightmaps(self, world_transform: Transform, extents: Box2D, weightmap_layer_names: Array[Name], out_render_target: TextureRenderTarget) -> bool:
        r"""
        x.render_weightmaps(world_transform, extents, weightmap_layer_names, out_render_target) -> bool
        Render the final weightmaps for the requested layers, in the requested top-down window, as one -atlased- texture in the provided render target (2D or 2DArray)
         Can be called at runtime.
        
        Args:
            world_transform (Transform): World transform of the area where the texture should be rendered
            extents (Box2D): Extents of the area where the texture should be rendered (local to InWorldTransform). If size is zero, then the entire loaded landscape will be exported.
            weightmap_layer_names (Array[Name]): List of weightmap layers that are being requested to render
            out_render_target (TextureRenderTarget): Render target in which the texture will be rendered. The size/format of the render target will be respected. - If a UTextureRenderTarget2D is passed, the requested layers will be packed in the RGBA channels in order (up to the number of channels available with the render target's format). - If a UTextureRenderTarget2DArray is passed, the requested layers will be packed in the RGBA channels of each slice (up to the number of channels * slices available with the render target's format and number of slices).
        
        Returns:
            bool: false in case of failure (e.g. invalid inputs, incompatible render target format...)
        """
        ...
    def render_weightmap(self, world_transform: Transform, extents: Box2D, weightmap_layer_name: Name, out_render_target: TextureRenderTarget2D) -> bool:
        r"""
        x.render_weightmap(world_transform, extents, weightmap_layer_name, out_render_target) -> bool
        Render the final weightmap for the requested layer, in the requested top-down window, as one -atlased- texture in the provided render target 2D
         Can be called at runtime.
        
        Args:
            world_transform (Transform): World transform of the area where the texture should be rendered
            extents (Box2D): Extents of the area where the texture should be rendered (local to InWorldTransform). If size is zero, then the entire loaded landscape will be exported.
            weightmap_layer_name (Name): Weightmap layer that is being requested to render
            out_render_target (TextureRenderTarget2D): Render target in which the texture will be rendered. The size/format of the render target will be respected.
        
        Returns:
            bool: false in case of failure (e.g. invalid inputs, incompatible render target format...)
        """
        ...
    def render_heightmap(self, world_transform: Transform, extents: Box2D, out_render_target: TextureRenderTarget2D) -> bool:
        r"""
        x.render_heightmap(world_transform, extents, out_render_target) -> bool
        Render the final heightmap in the requested top-down window as one -atlased- texture in the provided render target 2D
         Can be called at runtime.
        
        Args:
            world_transform (Transform): World transform of the area where the texture should be rendered
            extents (Box2D): Extents of the area where the texture should be rendered (local to InWorldTransform). If size is zero, then the entire loaded landscape will be exported.
            out_render_target (TextureRenderTarget2D): Render target in which the texture will be rendered. The size/format of the render target will be respected.
        
        Returns:
            bool: false in case of failure (e.g. invalid inputs, incompatible render target format...)
        """
        ...
    def get_target_layer_names(self, include_visibility_layer: bool = False) -> Array[Name]:
        r"""
        x.get_target_layer_names(include_visibility_layer=False) -> Array[Name]
        Retrieves the names of valid paint layers on this landscape (editor-only : returns nothing at runtime)
        
        Args:
            include_visibility_layer (bool): whether the visibility layer's name should be included in the list or not
        
        Returns:
            Array[Name]: the list of paint layer names
        """
        ...
    def force_layers_full_update(self) -> None:
        r"""
        x.force_layers_full_update() -> None
        Force Layers Full Update
        """
        ...

class LandscapeLODStreamingProxy_DEPRECATED(StreamableRenderAsset):
    r"""
    Landscape LODStreaming Proxy DEPRECATED
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``never_stream`` (bool):  [Read-Write]
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    """
    ...

class LandscapeComponent(PrimitiveComponent):
    r"""
    Landscape Component
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``collision_mip_level`` (int32):  [Read-Write] Heightfield mipmap used to generate collision
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``forced_lod`` (int32):  [Read-Write] Forced LOD level to use when rendering
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``layer_allow_list`` (Array[LandscapeLayerInfoObject]):  [Read-Write] List of layers allowed to be painted on this component
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lighting_lod_bias`` (int32):  [Read-Write] LOD level Bias to use when lighting building via lightmass, -1 Means automatic LOD calculation based on ForcedLOD + LODBias
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lod_bias`` (int32):  [Read-Write] LOD level Bias to use when rendering
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``negative_z_bounds_extension`` (float):  [Read-Write] Allows overriding the landscape bounds. This is useful if you distort the landscape with world-position-offset, for example
      Extension value in the negative Z axis, positive value increases bound size
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``override_hole_material`` (MaterialInterface):  [Read-Write]
    - ``override_material`` (MaterialInterface):  [Read-Write]
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``per_lod_override_materials`` (Array[LandscapePerLODMaterialOverride]):  [Read-Write]
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``positive_z_bounds_extension`` (float):  [Read-Write] Allows overriding the landscape bounds. This is useful if you distort the landscape with world-position-offset, for example
      Extension value in the positive Z axis, positive value increases bound size
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``section_base_x`` (int32):  [Read-Only] X offset from global components grid origin (in quads)
    - ``section_base_y`` (int32):  [Read-Only] Y offset from global components grid origin (in quads)
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``simple_collision_mip_level`` (int32):  [Read-Write] Heightfield mipmap used to generate simple collision
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_lighting_resolution`` (float):  [Read-Write] StaticLightingResolution overriding per component, default value 0 means no overriding
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def section_base_x(self) -> int:
        r"""
        (int32):  [Read-Only] X offset from global components grid origin (in quads)
        """
        ...
    @property
    def section_base_y(self) -> int:
        r"""
        (int32):  [Read-Only] Y offset from global components grid origin (in quads)
        """
        ...
    @property
    def override_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Write]
        """
        ...
    @override_material.setter
    def override_material(self, value: MaterialInterface) -> None:
        ...
    @property
    def override_hole_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Write]
        """
        ...
    @override_hole_material.setter
    def override_hole_material(self, value: MaterialInterface) -> None:
        ...
    @property
    def forced_lod(self) -> int:
        r"""
        (int32):  [Read-Only] Forced LOD level to use when rendering
        """
        ...
    @property
    def lod_bias(self) -> int:
        r"""
        (int32):  [Read-Only] LOD level Bias to use when rendering
        """
        ...
    def set_lod_bias(self, lod_bias: int) -> None:
        r"""
        x.set_lod_bias(lod_bias) -> None
        Set LODBias
        
        Args:
            lod_bias (int32):
        """
        ...
    def set_forced_lod(self, forced_lod: int) -> None:
        r"""
        x.set_forced_lod(forced_lod) -> None
        Set Forced LOD
        
        Args:
            forced_lod (int32):
        """
        ...
    def get_material_instance_dynamic(self, index: int) -> MaterialInstanceDynamic:
        r"""
        x.get_material_instance_dynamic(index) -> MaterialInstanceDynamic
        Gets the landscape material instance dynamic for this component
        
        Args:
            index (int32): 
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...
    def editor_get_paint_layer_weight_by_name_at_location(self, location: Vector, paint_layer_name: Name) -> float:
        r"""
        x.editor_get_paint_layer_weight_by_name_at_location(location, paint_layer_name) -> float
        Gets the landscape paint layer weight value at the given position using layer name. Returns 0 in case it fails.
        
        Args:
            location (Vector): 
            paint_layer_name (Name): 
        
        Returns:
            float:
        """
        ...
    def editor_get_paint_layer_weight_at_location(self, location: Vector, paint_layer: LandscapeLayerInfoObject) -> float:
        r"""
        x.editor_get_paint_layer_weight_at_location(location, paint_layer) -> float
        Gets the landscape paint layer weight value at the given position using LandscapeLayerInfo . Returns 0 in case it fails.
        
        Args:
            location (Vector): 
            paint_layer (LandscapeLayerInfoObject): 
        
        Returns:
            float:
        """
        ...

class LandscapeGizmoActor(Actor):
    r"""
    Landscape Gizmo Actor
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeGizmoActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``height`` (float):  [Read-Write]
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``length_z`` (float):  [Read-Write]
    - ``margin_z`` (float):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``min_relative_z`` (float):  [Read-Write]
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relative_scale_z`` (float):  [Read-Write]
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``target_landscape_info`` (LandscapeInfo):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``width`` (float):  [Read-Write]
    """
    ...

class LandscapeGizmoActiveActor(LandscapeGizmoActor):
    r"""
    Landscape Gizmo Active Actor
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeGizmoActiveActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``height`` (float):  [Read-Write]
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layer_infos`` (Array[LandscapeLayerInfoObject]):  [Read-Only]
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``length_z`` (float):  [Read-Write]
    - ``margin_z`` (float):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``min_relative_z`` (float):  [Read-Write]
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relative_scale_z`` (float):  [Read-Write]
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``target_landscape_info`` (LandscapeInfo):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``width`` (float):  [Read-Write]
    """
    ...

class LandscapeGizmoRenderComponent(PrimitiveComponent):
    r"""
    Landscape Gizmo Render Component
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeGizmoRenderComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class LandscapeGrassType(Object):
    r"""
    Landscape Grass Type
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeGrassType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_density_scaling`` (bool):  [Read-Write] Whether this grass type should be affected by the Engine Scalability system's Foliage grass.DensityScale setting.
      This is enabled by default but can be disabled should this grass type be important for gameplay reasons.
    - ``grass_varieties`` (Array[GrassVariety]):  [Read-Write]
    """
    @property
    def grass_varieties(self) -> Array[GrassVariety]:
        r"""
        (Array[GrassVariety]):  [Read-Only]
        """
        ...
    @property
    def enable_density_scaling(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether this grass type should be affected by the Engine Scalability system's Foliage grass.DensityScale setting.
        This is enabled by default but can be disabled should this grass type be important for gameplay reasons.
        """
        ...

class LandscapeHeightfieldCollisionComponent(PrimitiveComponent):
    r"""
    Landscape Heightfield Collision Component
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeHeightfieldCollisionComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    def get_render_component(self) -> LandscapeComponent:
        r"""
        x.get_render_component() -> LandscapeComponent
        Returns associated landscape component
        
        Returns:
            LandscapeComponent:
        """
        ...

class LandscapeLayerInfoObject(Object):
    r"""
    Landscape Layer Info Object
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeLayerInfoObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``hardness`` (float):  [Read-Write] Defines how much 'resistance' areas painted with this layer will offer to the Erosion tool. A hardness of 0 means the layer is fully affected by erosion, while 1 means fully unaffected.
    - ``layer_name`` (Name):  [Read-Only]
    - ``layer_usage_debug_color`` (LinearColor):  [Read-Write] The color to use for layer usage debug
    - ``minimum_collision_relevance_weight`` (float):  [Read-Write] The minimum weight that needs to be painted for that layer to be picked up as the dominant physical layer.
    - ``no_weight_blend`` (bool):  [Read-Write] Prevents this layer to be weight-blended with others.
    - ``phys_material`` (PhysicalMaterial):  [Read-Write] Physical material to use when this layer is the predominant one at a given location. Note: this is ignored if the Landscape Physical Material node is used in the landscape material.
    - ``spline_falloff_modulation_bias`` (float):  [Read-Write] Defines the offset to use when sampling the Spline Falloff Modulation Texture.
    - ``spline_falloff_modulation_color_mask`` (SplineModulationColorMask):  [Read-Write] Defines which channel of the Spline Falloff Modulation Texture to use.
    - ``spline_falloff_modulation_scale`` (float):  [Read-Write] Allows to scale the value sampled from the Spline Falloff Modulation Texture.
    - ``spline_falloff_modulation_texture`` (Texture2D):  [Read-Write] Texture to modulate the Splines Falloff Layer Alpha
    - ``spline_falloff_modulation_tiling`` (float):  [Read-Write] Defines the tiling to use when sampling the Spline Falloff Modulation Texture.
    """
    ...

class MaterialInstance(MaterialInterface):
    r"""
    Material Instance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Write] Importing data and options used for this material
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``base_property_overrides`` (MaterialInstanceBasePropertyOverrides):  [Read-Write]
    - ``double_vector_parameter_values`` (Array[DoubleVectorParameterValue]):  [Read-Write] DoubleVector parameters.
    - ``font_parameter_values`` (Array[FontParameterValue]):  [Read-Write] Font parameters.
    - ``lightmass_settings`` (LightmassMaterialInterfaceSettings):  [Read-Write] The Lightmass settings for this object.
    - ``nanite_override_material`` (MaterialOverrideNanite):  [Read-Write] An override material which will be used instead of this one when rendering with Nanite.
    - ``neural_profile`` (NeuralProfile):  [Read-Write] Neural network profile. For internal usage, not editable/visible
    - ``override_subsurface_profile`` (bool):  [Read-Write] Defines if SubsurfaceProfile from this instance is used or it uses the parent one.
    - ``parent`` (MaterialInterface):  [Read-Write] Parent material.
    - ``phys_material`` (PhysicalMaterial):  [Read-Write] Physical material to use for this graphics material. Used for sounds, effects etc.
    - ``physical_material_map`` (PhysicalMaterial):  [Read-Write] Physical material map used with physical material mask, when it exists.
    - ``preview_mesh`` (SoftObjectPath):  [Read-Write] The mesh used by the material editor to preview the material.
    - ``runtime_virtual_texture_parameter_values`` (Array[RuntimeVirtualTextureParameterValue]):  [Read-Write] RuntimeVirtualTexture parameters.
    - ``scalar_parameter_values`` (Array[ScalarParameterValue]):  [Read-Write] Scalar parameters.
    - ``sparse_volume_texture_parameter_values`` (Array[SparseVolumeTextureParameterValue]):  [Read-Write] Sparse Volume Texture parameters.
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Screen Space Subsurface Scattering..
    - ``texture_parameter_values`` (Array[TextureParameterValue]):  [Read-Write] Texture parameters.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``vector_parameter_values`` (Array[VectorParameterValue]):  [Read-Write] Vector parameters.
    """
    @property
    def phys_material(self) -> PhysicalMaterial:
        r"""
        (PhysicalMaterial):  [Read-Write] Physical material to use for this graphics material. Used for sounds, effects etc.
        """
        ...
    @phys_material.setter
    def phys_material(self, value: PhysicalMaterial) -> None:
        ...
    @property
    def parent(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Only] Parent material.
        """
        ...
    @property
    def override_subsurface_profile(self) -> bool:
        r"""
        (bool):  [Read-Only] Defines if SubsurfaceProfile from this instance is used or it uses the parent one.
        """
        ...
    @property
    def scalar_parameter_values(self) -> Array[ScalarParameterValue]:
        r"""
        (Array[ScalarParameterValue]):  [Read-Only] Scalar parameters.
        """
        ...
    @property
    def vector_parameter_values(self) -> Array[VectorParameterValue]:
        r"""
        (Array[VectorParameterValue]):  [Read-Only] Vector parameters.
        """
        ...
    @property
    def double_vector_parameter_values(self) -> Array[DoubleVectorParameterValue]:
        r"""
        (Array[DoubleVectorParameterValue]):  [Read-Only] DoubleVector parameters.
        """
        ...
    @property
    def texture_parameter_values(self) -> Array[TextureParameterValue]:
        r"""
        (Array[TextureParameterValue]):  [Read-Only] Texture parameters.
        """
        ...
    @property
    def runtime_virtual_texture_parameter_values(self) -> Array[RuntimeVirtualTextureParameterValue]:
        r"""
        (Array[RuntimeVirtualTextureParameterValue]):  [Read-Only] RuntimeVirtualTexture parameters.
        """
        ...
    @property
    def sparse_volume_texture_parameter_values(self) -> Array[SparseVolumeTextureParameterValue]:
        r"""
        (Array[SparseVolumeTextureParameterValue]):  [Read-Only] Sparse Volume Texture parameters.
        """
        ...
    @property
    def font_parameter_values(self) -> Array[FontParameterValue]:
        r"""
        (Array[FontParameterValue]):  [Read-Only] Font parameters.
        """
        ...

class MaterialInstanceConstant(MaterialInstance):
    r"""
    Material Instances may be used to change the appearance of a material without incurring an expensive recompilation of the material.
    General modification of the material cannot be supported without recompilation, so the instances are limited to changing the values of
    predefined material parameters. The parameters are statically defined in the compiled material by a unique name, type and default value.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstanceConstant.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Write] Importing data and options used for this material
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``base_property_overrides`` (MaterialInstanceBasePropertyOverrides):  [Read-Write]
    - ``double_vector_parameter_values`` (Array[DoubleVectorParameterValue]):  [Read-Write] DoubleVector parameters.
    - ``font_parameter_values`` (Array[FontParameterValue]):  [Read-Write] Font parameters.
    - ``lightmass_settings`` (LightmassMaterialInterfaceSettings):  [Read-Write] The Lightmass settings for this object.
    - ``nanite_override_material`` (MaterialOverrideNanite):  [Read-Write] An override material which will be used instead of this one when rendering with Nanite.
    - ``neural_profile`` (NeuralProfile):  [Read-Write] Neural network profile. For internal usage, not editable/visible
    - ``override_subsurface_profile`` (bool):  [Read-Write] Defines if SubsurfaceProfile from this instance is used or it uses the parent one.
    - ``parent`` (MaterialInterface):  [Read-Write] Parent material.
    - ``phys_material`` (PhysicalMaterial):  [Read-Write] Physical material to use for this graphics material. Used for sounds, effects etc.
    - ``phys_material_mask`` (PhysicalMaterialMask):  [Read-Write] Physical material mask to use for this graphics material. Used for sounds, effects etc.
    - ``physical_material_map`` (PhysicalMaterial):  [Read-Write] Physical material map used with physical material mask, when it exists.
    - ``preview_mesh`` (SoftObjectPath):  [Read-Write] The mesh used by the material editor to preview the material.
    - ``runtime_virtual_texture_parameter_values`` (Array[RuntimeVirtualTextureParameterValue]):  [Read-Write] RuntimeVirtualTexture parameters.
    - ``scalar_parameter_values`` (Array[ScalarParameterValue]):  [Read-Write] Scalar parameters.
    - ``sparse_volume_texture_parameter_values`` (Array[SparseVolumeTextureParameterValue]):  [Read-Write] Sparse Volume Texture parameters.
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Screen Space Subsurface Scattering..
    - ``texture_parameter_values`` (Array[TextureParameterValue]):  [Read-Write] Texture parameters.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``vector_parameter_values`` (Array[VectorParameterValue]):  [Read-Write] Vector parameters.
    """
    def set_nanite_override_material(self, enable_override: bool, override_material: MaterialInterface) -> None:
        r"""
        x.set_nanite_override_material(enable_override, override_material) -> None
        Set an override material which will be used when rendering with nanite.
        
        Args:
            enable_override (bool): 
            override_material (MaterialInterface):
        """
        ...
    def get_vector_parameter_value(self, parameter_name: Name) -> LinearColor:
        r"""
        x.get_vector_parameter_value(parameter_name) -> LinearColor
        Get the MIC vector parameter value
        
        Args:
            parameter_name (Name): 
        
        Returns:
            LinearColor:
        """
        ...
    def get_texture_parameter_value(self, parameter_name: Name) -> Texture:
        r"""
        x.get_texture_parameter_value(parameter_name) -> Texture
        Get the MIC texture parameter value
        
        Args:
            parameter_name (Name): 
        
        Returns:
            Texture:
        """
        ...
    def get_scalar_parameter_value(self, parameter_name: Name) -> float:
        r"""
        x.get_scalar_parameter_value(parameter_name) -> float
        Get the scalar (float) parameter value from an MIC
        
        Args:
            parameter_name (Name): 
        
        Returns:
            float:
        """
        ...

class LandscapeMaterialInstanceConstant(MaterialInstanceConstant):
    r"""
    Landscape Material Instance Constant
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeMaterialInstanceConstant.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Write] Importing data and options used for this material
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``base_property_overrides`` (MaterialInstanceBasePropertyOverrides):  [Read-Write]
    - ``double_vector_parameter_values`` (Array[DoubleVectorParameterValue]):  [Read-Write] DoubleVector parameters.
    - ``font_parameter_values`` (Array[FontParameterValue]):  [Read-Write] Font parameters.
    - ``lightmass_settings`` (LightmassMaterialInterfaceSettings):  [Read-Write] The Lightmass settings for this object.
    - ``nanite_override_material`` (MaterialOverrideNanite):  [Read-Write] An override material which will be used instead of this one when rendering with Nanite.
    - ``neural_profile`` (NeuralProfile):  [Read-Write] Neural network profile. For internal usage, not editable/visible
    - ``override_subsurface_profile`` (bool):  [Read-Write] Defines if SubsurfaceProfile from this instance is used or it uses the parent one.
    - ``parent`` (MaterialInterface):  [Read-Write] Parent material.
    - ``phys_material`` (PhysicalMaterial):  [Read-Write] Physical material to use for this graphics material. Used for sounds, effects etc.
    - ``phys_material_mask`` (PhysicalMaterialMask):  [Read-Write] Physical material mask to use for this graphics material. Used for sounds, effects etc.
    - ``physical_material_map`` (PhysicalMaterial):  [Read-Write] Physical material map used with physical material mask, when it exists.
    - ``preview_mesh`` (SoftObjectPath):  [Read-Write] The mesh used by the material editor to preview the material.
    - ``runtime_virtual_texture_parameter_values`` (Array[RuntimeVirtualTextureParameterValue]):  [Read-Write] RuntimeVirtualTexture parameters.
    - ``scalar_parameter_values`` (Array[ScalarParameterValue]):  [Read-Write] Scalar parameters.
    - ``sparse_volume_texture_parameter_values`` (Array[SparseVolumeTextureParameterValue]):  [Read-Write] Sparse Volume Texture parameters.
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Screen Space Subsurface Scattering..
    - ``texture_parameter_values`` (Array[TextureParameterValue]):  [Read-Write] Texture parameters.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``vector_parameter_values`` (Array[VectorParameterValue]):  [Read-Write] Vector parameters.
    """
    ...

class LandscapeMeshCollisionComponent(LandscapeHeightfieldCollisionComponent):
    r"""
    Landscape Mesh Collision Component
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeMeshCollisionComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class LandscapeMeshProxyActor(Actor):
    r"""
    Landscape Mesh Proxy Actor
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeMeshProxyActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``landscape_mesh_proxy_component`` (LandscapeMeshProxyComponent):  [Read-Only]
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def landscape_mesh_proxy_component(self) -> LandscapeMeshProxyComponent:
        r"""
        (LandscapeMeshProxyComponent):  [Read-Only]
        """
        ...

class LandscapeMeshProxyComponent(StaticMeshComponent):
    r"""
    Landscape Mesh Proxy Component
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeMeshProxyComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    ...

class LandscapeSplinesComponent(PrimitiveComponent):
    r"""
    ULandscapeSplinesComponent
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeSplinesComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    def get_spline_mesh_components(self) -> Array[SplineMeshComponent]:
        r"""
        x.get_spline_mesh_components() -> Array[SplineMeshComponent]
        Get a list of spline mesh components representing this landscape spline (Editor only)
        
        Returns:
            Array[SplineMeshComponent]:
        """
        ...

class LandscapeSplineControlPoint(Object):
    r"""
    Landscape Spline Control Point
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeSplineControlPoint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``body_instance`` (BodyInstance):  [Read-Write] Mesh Collision Settings
    - ``cast_shadow`` (bool):  [Read-Write] Whether the Control Point Mesh should cast a shadow.
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``end_falloff`` (float):  [Read-Write] Falloff at the start/end of the spline (if this point is a start or end point, otherwise ignored).
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the mesh in game
    - ``layer_name`` (Name):  [Read-Write] Name of blend layer to paint when applying spline to landscape
      If "none", no layer is painted
    - ``layer_width_ratio`` (float):  [Read-Write] Layer Width ratio of the spline at this point.
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance for the mesh used on this control point
    - ``left_side_falloff_factor`` (float):  [Read-Write]
    - ``left_side_layer_falloff_factor`` (float):  [Read-Write]
    - ``location`` (Vector):  [Read-Write] Location in Landscape-space
    - ``lower_terrain`` (bool):  [Read-Write] If the spline is below the terrain, whether to lower the terrain down to the level of the spline when applying it to the landscape.
    - ``material_overrides`` (Array[MaterialInterface]):  [Read-Write] Overrides mesh's materials
    - ``mesh`` (StaticMesh):  [Read-Write] Mesh to use on the control point
    - ``mesh_scale`` (Vector):  [Read-Write] Scale of the control point mesh
    - ``place_spline_meshes_in_streaming_levels`` (bool):  [Read-Write] Whether control point mesh should be placed in landscape proxy streaming level (true) or the spline's level (false)
    - ``raise_terrain`` (bool):  [Read-Write] If the spline is above the terrain, whether to raise the terrain up to the level of the spline when applying it to the landscape.
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``right_side_falloff_factor`` (float):  [Read-Write]
    - ``right_side_layer_falloff_factor`` (float):  [Read-Write]
    - ``rotation`` (Rotator):  [Read-Write] Rotation of tangent vector at this point (in landscape-space)
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the spline segment.
      The material also needs to be set up to output to a virtual texture.
    - ``segment_mesh_offset`` (float):  [Read-Write] Vertical offset of the spline segment mesh. Useful for a river's surface, among other things.
    - ``side_falloff`` (float):  [Read-Write] Falloff at the sides of the spline at this point.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
    - ``virtual_texture_cull_mips`` (int32):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int32):  [Read-Write] Lod bias for rendering to runtime virtual texture.
    - ``virtual_texture_main_pass_max_draw_distance`` (float):  [Read-Write] Desired cull distance in the main pass if we are rendering to both the virtual texture AND the main pass. A value of 0 has no effect.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``width`` (float):  [Read-Write] Half-Width of the spline at this point.
    """
    @property
    def body_instance(self) -> BodyInstance:
        r"""
        (BodyInstance):  [Read-Only] Mesh Collision Settings
        """
        ...

class LandscapeSplineSegment(Object):
    r"""
    Landscape Spline Segment
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeSplineSegment.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``body_instance`` (BodyInstance):  [Read-Write] Mesh Collision Settings
    - ``cast_shadow`` (bool):  [Read-Write] Whether the Spline Meshes should cast a shadow.
    - ``connections`` (LandscapeSplineSegmentConnection):  [Read-Write] Directly editable data:
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the mesh in game
    - ``layer_name`` (Name):  [Read-Write] Name of blend layer to paint when applying spline to landscape
      If "none", no layer is painted
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance for all the mesh pieces used in this spline
    - ``lower_terrain`` (bool):  [Read-Write] If the spline is below the terrain, whether to lower the terrain down to the level of the spline when applying it to the landscape.
    - ``place_spline_meshes_in_streaming_levels`` (bool):  [Read-Write] Whether spline meshes should be placed in landscape proxy streaming levels (true) or the spline's level (false)
    - ``raise_terrain`` (bool):  [Read-Write] If the spline is above the terrain, whether to raise the terrain up to the level of the spline when applying it to the landscape.
    - ``random_seed`` (int32):  [Read-Write] Random seed used for choosing which order to use spline meshes. Ignored if only one mesh is set.
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the spline segment.
      The material also needs to be set up to output to a virtual texture.
    - ``spline_meshes`` (Array[LandscapeSplineMeshEntry]):  [Read-Write] Spline meshes from this list are used in random order along the spline.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
    - ``virtual_texture_cull_mips`` (int32):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int32):  [Read-Write] Lod bias for rendering to runtime virtual texture.
    - ``virtual_texture_main_pass_max_draw_distance`` (float):  [Read-Write] Desired cull distance in the main pass if we are rendering to both the virtual texture AND the main pass. A value of 0 has no effect.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    """
    @property
    def body_instance(self) -> BodyInstance:
        r"""
        (BodyInstance):  [Read-Only] Mesh Collision Settings
        """
        ...

class LandscapeStreamingProxy(LandscapeProxy):
    r"""
    Landscape Streaming Proxy
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeStreamingProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``bake_material_position_offset_into_collision`` (bool):  [Read-Write] Whether to bake the landscape material's vertical world position offset into the collision heightfield.
                    Note: Only z (vertical) offset is supported. XY offsets are ignored.
                    Does not work with an XY offset map (mesh collision)
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``body_instance`` (BodyInstance):  [Read-Write] Collision profile settings for this landscape
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows. This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades(only for directional lights).  This flag is only used if CastShadow is true.
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.  Controls whether the primitive should cast shadows when hidden.  This flag is only used if CastShadow is true.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.  This flag is only used if CastShadow is true.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``collision_mip_level`` (int32):  [Read-Write] Landscape LOD to use for collision tests. Higher numbers use less memory and process faster, but are much less accurate
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_phys_material`` (PhysicalMaterial):  [Read-Write] Default physical material, used when no per-layer values physical materials
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_nanite`` (bool):  [Read-Write] Use Nanite to render landscape as a mesh on supported platforms.
    - ``export_lod`` (int32):  [Read-Write] LOD level to use when exporting the landscape to obj or FBX
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``fill_collision_under_landscape_for_navmesh`` (bool):  [Read-Write] Set to true to prevent navmesh generation under the terrain geometry
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events`` (bool):  [Read-Write] If true, Landscape will generate overlap events when other components are overlapping it (eg Begin Overlap).
      Both the Landscape and the other component must have this flag enabled for overlap events to occur.
      see: [Overlap Events](https://docs.unrealengine.com/InteractiveExperiences/Physics/Collision/Overview#overlapandgenerateoverlapevents)
      see: UpdateOverlaps(), BeginComponentOverlap(), EndComponentOverlap()
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``hlod_mesh_source_lod`` (int32):  [Read-Write] Specify which LOD to use for the HLOD mesh if HLODMeshSourceLODPolicy is set to SpecificLOD
    - ``hlod_mesh_source_lod_policy`` (LandscapeHLODMeshSourceLODPolicy):  [Read-Write] Specify how to choose the LOD used as input for the HLOD mesh
    - ``hlod_texture_size`` (int32):  [Read-Write] Specify the texture size to use for the HLOD mesh if HLODTextureSizePolicy is set to SpecificSize
    - ``hlod_texture_size_policy`` (LandscapeHLODTextureSizePolicy):  [Read-Write] Specify how to choose the texture size of the resulting HLOD mesh
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``landscape_actor_ref`` (Landscape):  [Read-Write]
    - ``landscape_hole_material`` (MaterialInterface):  [Read-Write] Material used to render landscape components with holes. If not set, LandscapeMaterial will be used (blend mode will be overridden to Masked if it is set to Opaque)
    - ``landscape_material`` (MaterialInterface):  [Read-Write] Combined material used to render the landscape
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this Landscape should be in.  Lights with matching channels will affect the Landscape.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``lod0_distribution_setting`` (float):  [Read-Write] The distribution setting used to change the LOD 0 generation, 1.25 is the normal distribution, numbers influence directly the LOD0 proportion on screen.
    - ``lod0_screen_size`` (float):  [Read-Write] This is the starting screen size used to calculate the distribution. You can increase the value if you want less LOD0 component, and you use very large landscape component.
    - ``lod_blend_range`` (float):  [Read-Write] This controls the area that blends LOD between neighboring sections. At 1.0 it blends across the entire section, and lower numbers reduce the blend region to be closer to the boundary.
    - ``lod_distribution_setting`` (float):  [Read-Write] The distribution setting used to change the LOD generation, 3 is the normal distribution, small number mean you want your last LODs to take more screen space and big number mean you want your first LODs to take more screen space.
    - ``lod_group_key`` (uint32):  [Read-Write] Specifies the LOD Group (Zero is No Group). All landscapes in the same group calculate their LOD together, allowing matching border LODs to fix geometry seams.
    - ``max_lod_level`` (int32):  [Read-Write] Max LOD level to use when rendering, -1 means the max available
    - ``max_painted_layers_per_component`` (int32):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``nanite_lod_index`` (int32):  [Read-Write] LOD level of the landscape when generating the Nanite mesh. Mostly there for debug reasons, since Nanite is meant to allow high density meshes, we want to use 0 most of the times.
    - ``nanite_max_edge_length_factor`` (float):  [Read-Write]
    - ``nanite_position_precision`` (int32):  [Read-Write]
    - ``nanite_skirt_depth`` (float):  [Read-Write]
    - ``nanite_skirt_enabled`` (bool):  [Read-Write]
    - ``navigation_geometry_gathering_mode`` (NavDataGatheringMode):  [Read-Write]
    - ``negative_z_bounds_extension`` (float):  [Read-Write] Allows overriding the landscape bounds. This is useful if you distort the landscape with world-position-offset, for example
      Extension value in the negative Z axis, positive value increases bound size
      Note that this can also be overridden per-component when the component is selected with the component select tool
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``non_nanite_virtual_shadow_map_constant_depth_bias`` (float):  [Read-Write] Constant bias to handle the worst artifacts of the continuous LOD morphing when rendering to VSM.
      Only applies when using non-Nanite landscape and VSM.
    - ``non_nanite_virtual_shadow_map_invalidation_height_error_threshold`` (float):  [Read-Write] For non-Nanite landscape, cached VSM pages need to be invalidated when continuous LOD morphing introduces a height difference that is too large between the current landscape component's profile and the one that was used when the shadow was shadow was last cached.
      This height threshold (in Unreal units) controls this invalidation rate (a smaller threshold will reduce the likeliness of shadow artifacts, but will make the invalidations occur more frequently, which is not desirable in terms of performance.
      Disabled if 0.0.
      Only applies when using non-Nanite landscape and VSM.
    - ``non_nanite_virtual_shadow_map_invalidation_screen_size_limit`` (float):  [Read-Write] Screen size under which VSM invalidation stops occurring.
      As the height difference between 2 mip levels increases when the LOD level increases (because of undersampling), VSM pages tend to be invalidated more frequently even though it's getting less and less relevant to do so, since this will mean that the screen size of the landscape section decreases, thus the artifacts actually become less noticeable.
      We therefore artificially attenuate the VSM invalidation rate as the screen size decreases, to avoid invalidating VSM pages too often, as it becomes less and less impactful.
      A higher value will accentuate this attenuation (better performance but more artifacts) and vice versa.
      If 0.0, the attenuation of the VSM invalidation rate will be disabled entirely.
      Only applies when using non-Nanite landscape and VSM.
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``per_lod_override_materials`` (Array[LandscapePerLODMaterialOverride]):  [Read-Write]
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``positive_z_bounds_extension`` (float):  [Read-Write] Allows overriding the landscape bounds. This is useful if you distort the landscape with world-position-offset, for example
      Extension value in the positive Z axis, positive value increases bound size
      Note that this can also be overridden per-component when the component is selected with the component select tool
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``render_custom_depth`` (bool):  [Read-Write] If true, the Landscape will be rendered in the CustomDepth pass (usually used for outlines)
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw this landscape.
      The material also needs to be set up to output to a virtual texture.
    - ``scalable_lod0_distribution_setting`` (PerQualityLevelFloat):  [Read-Write] Scalable (per-quality) version of 'LOD 0'.
    - ``scalable_lod0_screen_size`` (PerQualityLevelFloat):  [Read-Write] Scalable (per-quality) version of 'LOD 0 Screen Size'.
    - ``scalable_lod_distribution_setting`` (PerQualityLevelFloat):  [Read-Write] Scalable (per-quality) version of 'Other LODs'.
    - ``set_create_runtime_virtual_texture_volumes`` (bool):  [Read-Only] Placeholder for details customization button.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``simple_collision_mip_level`` (int32):  [Read-Write] If set higher than the "Collision Mip Level", this specifies the Landscape LOD to use for "simple collision" tests, otherwise the "Collision Mip Level" is used for both simple and complex collision.
      Does not work with an XY offset map (mesh collision)
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``static_lighting_lod`` (int32):  [Read-Write] LOD level to use when running lightmass (increase to 1 or 2 for large landscapes to stop lightmass crashing)
    - ``static_lighting_resolution`` (float):  [Read-Write] The resolution to cache lighting at, in texels/quad in one axis
      Total resolution would be changed by StaticLightingResolution*StaticLightingResolution
      Automatically calculate proper value for removing seams
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows artists to adjust the distance where textures using UV 0 are streamed in/out.
      1.0 is the default, whereas a higher value increases the streamed-in resolution.
      Value can be < 0 (from legcay content, or code changes)
    - ``strip_grass_when_cooked_client`` (bool):  [Read-Write] Strip Grass data when cooked for client
    - ``strip_grass_when_cooked_server`` (bool):  [Read-Write] Strip Grass data when cooked for server
    - ``strip_physics_when_cooked_client`` (bool):  [Read-Write] Strip Physics/collision components when cooked for client
    - ``strip_physics_when_cooked_server`` (bool):  [Read-Write] Strip Physics/collision components when cooked for server
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_compressed_heightmap_storage`` (bool):  [Read-Write] Enable compressed heightmap texture storage.
    - ``use_dynamic_material_instance`` (bool):  [Read-Write] When set to true it will generate MaterialInstanceDynamic for each components, so material can be changed at runtime
    - ``use_landscape_for_culling_invisible_hlod_vertices`` (bool):  [Read-Write] Flag whether or not this Landscape's surface can be used for culling hidden triangles *
    - ``use_material_position_offset_in_static_lighting`` (bool):  [Read-Write] Whether to use the landscape material's vertical world position offset when calculating static lighting.
      Note: Only z (vertical) offset is supported. XY offsets are ignored.
      Does not work correctly with an XY offset map (mesh collision)
    - ``use_scalable_lod_settings`` (bool):  [Read-Write] Allows to specify LOD distribution settings per quality level. Using this will ignore the r.LandscapeLOD0DistributionScale CVar.
    - ``used_for_navigation`` (bool):  [Read-Write] Hints navigation system whether this landscape will ever be navigated on. true by default, but make sure to set it to false for faraway, background landscapes
    - ``virtual_texture_lod_bias`` (int32):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
      Higher values reduce vertex count when rendering to the runtime virtual texture.
    - ``virtual_texture_num_lods`` (int32):  [Read-Write] Number of mesh levels to use when rendering landscape into runtime virtual texture.
      Lower values reduce vertex count when rendering to the runtime virtual texture but decrease accuracy when using values that require vertex interpolation.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``virtual_texture_render_with_quad`` (bool):  [Read-Write] Use a single quad to render this landscape to runtime virtual texture pages.
      This is the fastest path but it only gives correct results if the runtime virtual texture orientation is aligned with the landscape.
      If the two are unaligned we need to render to the virtual texture using LODs with sufficient density.
    - ``virtual_texture_render_with_quad_hq`` (bool):  [Read-Write] Use highest quality heightmap interpolation when using a single quad to render this landscape to runtime virtual texture pages.
      This also requires the project setting: r.VT.RVT.HighQualityPerPixelHeight.
    """
    ...

class MaterialExpression(Object):
    r"""
    Material Expression
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpression.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    @property
    def material_expression_editor_x(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @material_expression_editor_x.setter
    def material_expression_editor_x(self, value: int) -> None:
        ...
    @property
    def material_expression_editor_y(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @material_expression_editor_y.setter
    def material_expression_editor_y(self, value: int) -> None:
        ...

class MaterialExpressionCustomOutput(MaterialExpression):
    r"""
    Material Expression Custom Output
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCustomOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLandscapeGrassOutput(MaterialExpressionCustomOutput):
    r"""
    Material Expression Landscape Grass Output
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeGrassOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``grass_types`` (Array[GrassInput]):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLandscapeLayerBlend(MaterialExpression):
    r"""
    Material Expression Landscape Layer Blend
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeLayerBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``layers`` (Array[LayerBlendInput]):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLandscapeLayerCoords(MaterialExpression):
    r"""
    Material Expression Landscape Layer Coords
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeLayerCoords.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``custom_uv_type`` (LandscapeCustomizedCoordType):  [Read-Write] Determines the mapping place to use on the terrain.
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``mapping_pan_u`` (float):  [Read-Write] Offset to apply to the mapping along U.
    - ``mapping_pan_v`` (float):  [Read-Write] Offset to apply to the mapping along V.
    - ``mapping_rotation`` (float):  [Read-Write] Rotation to apply to the mapping.
    - ``mapping_scale`` (float):  [Read-Write] Uniform scale to apply to the mapping.
    - ``mapping_type`` (TerrainCoordMappingType):  [Read-Write] Determines the mapping place to use on the terrain.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionTerrainLayerCoords(MaterialExpressionLandscapeLayerCoords):
    r"""
    deprecated: 'MaterialExpressionTerrainLayerCoords' was renamed to 'MaterialExpressionLandscapeLayerCoords'.
    """
    ...

class ControlPointMeshActor(Actor):
    r"""
    ControlPointMeshActor is an actor with a ControlPointMeshComponent.
    see: UControlPointMeshComponent
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: ControlPointMeshActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``control_point_mesh_component`` (ControlPointMeshComponent):  [Read-Only]
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def control_point_mesh_component(self) -> ControlPointMeshComponent:
        r"""
        (ControlPointMeshComponent):  [Read-Only]
        """
        ...

class LandscapeBlueprintBrushBase(Actor):
    r"""
    Landscape Blueprint Brush Base
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeBlueprintBrushBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``affect_heightmap`` (bool):  [Read-Write]
    - ``affect_visibility_layer`` (bool):  [Read-Write]
    - ``affect_weightmap`` (bool):  [Read-Write]
    - ``affected_weightmap_layers`` (Array[Name]):  [Read-Write]
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_on_property_change`` (bool):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def update_on_property_change(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @update_on_property_change.setter
    def update_on_property_change(self, value: bool) -> None:
        ...
    @property
    def affect_heightmap(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @affect_heightmap.setter
    def affect_heightmap(self, value: bool) -> None:
        ...
    @property
    def affect_weightmap(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @affect_weightmap.setter
    def affect_weightmap(self, value: bool) -> None:
        ...
    @property
    def affect_visibility_layer(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @affect_visibility_layer.setter
    def affect_visibility_layer(self, value: bool) -> None:
        ...
    @property
    def affected_weightmap_layers(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write]
        """
        ...
    @affected_weightmap_layers.setter
    def affected_weightmap_layers(self, value: Array[Name]) -> None:
        ...
    def request_landscape_update(self, user_triggered: bool = False) -> None:
        r"""
        x.request_landscape_update(user_triggered=False) -> None
        Request Landscape Update
        
        Args:
            user_triggered (bool):
        """
        ...
    def render_layer(self, parameters: LandscapeBrushParameters) -> TextureRenderTarget2D:
        r"""
        x.render_layer(parameters) -> TextureRenderTarget2D
        Render Layer
        
        Args:
            parameters (LandscapeBrushParameters): 
        
        Returns:
            TextureRenderTarget2D:
        """
        ...
    def render(self, is_heightmap: bool, combined_result: TextureRenderTarget2D, weightmap_layer_name: Name) -> TextureRenderTarget2D:
        r"""
        x.render(is_heightmap, combined_result, weightmap_layer_name) -> TextureRenderTarget2D
        Render
        deprecated: Please use RenderLayer instead.
        
        Args:
            is_heightmap (bool): 
            combined_result (TextureRenderTarget2D): 
            weightmap_layer_name (Name): 
        
        Returns:
            TextureRenderTarget2D:
        """
        ...
    def initialize(self, landscape_transform: Transform, landscape_size: IntPoint, landscape_render_target_size: IntPoint) -> None:
        r"""
        x.initialize(landscape_transform, landscape_size, landscape_render_target_size) -> None
        Initialize
        
        Args:
            landscape_transform (Transform): 
            landscape_size (IntPoint): 
            landscape_render_target_size (IntPoint):
        """
        ...
    def get_blueprint_render_dependencies(self) -> Array[Object]:
        r"""
        x.get_blueprint_render_dependencies() -> Array[Object]
        Get Blueprint Render Dependencies
        
        Returns:
            Array[Object]: 
        
            out_streamable_assets (Array[Object]):
        """
        ...

class LandscapeNaniteComponent(StaticMeshComponent):
    r"""
    Landscape Nanite Component
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeNaniteComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    ...

class LandscapeSplineActor(Actor):
    r"""
    Landscape Spline Actor
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeSplineActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``landscape_actor`` (Landscape):  [Read-Write] Landscape *
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class LandscapeSplineMeshesActor(PartitionActor):
    r"""
    This class is only intended to be used by UWorldPartitionLandscapeSplineMeshesBuilder which extracts and clones
    landscape spline and control point static meshes into partitioned actors
    
    This serves as an optimization as these actors will be streamed at runtime
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeSplineMeshesActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``static_mesh_components`` (Array[StaticMeshComponent]):  [Read-Only]
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def static_mesh_components(self) -> Array[StaticMeshComponent]:
        r"""
        (Array[StaticMeshComponent]):  [Read-Only]
        """
        ...

class MaterialExpressionLandscapeLayerSample(MaterialExpression):
    r"""
    Material Expression Landscape Layer Sample
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeLayerSample.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write]
    - ``preview_weight`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionLandscapeLayerSwitch(MaterialExpression):
    r"""
    Material Expression Landscape Layer Switch
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeLayerSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write]
    - ``preview_used`` (bool):  [Read-Write]
    """
    ...

class MaterialExpressionTerrainLayerSwitch(MaterialExpressionLandscapeLayerSwitch):
    r"""
    deprecated: 'MaterialExpressionTerrainLayerSwitch' was renamed to 'MaterialExpressionLandscapeLayerSwitch'.
    """
    ...

class MaterialExpressionLandscapeLayerWeight(MaterialExpression):
    r"""
    Material Expression Landscape Layer Weight
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeLayerWeight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_base`` (Vector):  [Read-Write] only used if Base is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write]
    - ``preview_weight`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionTerrainLayerWeight(MaterialExpressionLandscapeLayerWeight):
    r"""
    deprecated: 'MaterialExpressionTerrainLayerWeight' was renamed to 'MaterialExpressionLandscapeLayerWeight'.
    """
    ...

class MaterialExpressionLandscapePhysicalMaterialOutput(MaterialExpressionCustomOutput):
    r"""
    Custom output node to write out physical material weights.
    This can be used to generate the dominant physical material for each point on a landscape.
    Note that the use of a material output node to generate this information is optional and when a node of this type is not present we fall back on a CPU path which analyzes landscape layer data.
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapePhysicalMaterialOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``inputs`` (Array[PhysicalMaterialInput]):  [Read-Write] Array of physical material inputs.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLandscapeVisibilityMask(MaterialExpression):
    r"""
    Material Expression Landscape Visibility Mask
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: MaterialExpressionLandscapeVisibilityMask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class AnimationAssetExtensions(BlueprintFunctionLibrary):
    r"""
    Animation Asset Extensions
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationAssetExtensions.h
    
    """
    @classmethod
    def get_skeleton(cls, asset: AnimationAsset) -> Skeleton:
        r"""
        X.get_skeleton(asset) -> Skeleton
        
        
        Args:
            asset (AnimationAsset): Animation Asset to retrieve the Skeleton for
        
        Returns:
            Skeleton: The target USkeleton for the provided UAnimationAsset
        """
        ...

class AnimationDataModelNotifiesExtensions(BlueprintFunctionLibrary):
    r"""
    Animation Data Model Notifies Extensions
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataNotifications.h
    
    """
    @classmethod
    def get_payload(cls, payload: AnimDataModelNotifPayload) -> EmptyPayload:
        r"""
        X.get_payload(payload) -> EmptyPayload
        Get Payload
        
        Args:
            payload (AnimDataModelNotifPayload): 
        
        Returns:
            EmptyPayload:
        """
        ...
    @classmethod
    def copy_payload(cls, payload: AnimDataModelNotifPayload, expected_struct: ScriptStruct, out_payload: EmptyPayload) -> EmptyPayload:
        r"""
        X.copy_payload(payload, expected_struct, out_payload) -> EmptyPayload
        Copy Payload
        
        Args:
            payload (AnimDataModelNotifPayload): 
            expected_struct (ScriptStruct): 
            out_payload (EmptyPayload): 
        
        Returns:
            EmptyPayload: 
        
            out_payload (EmptyPayload):
        """
        ...

class RawAnimSequenceTrackExtensions(BlueprintFunctionLibrary):
    r"""
    Raw Anim Sequence Track Extensions
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimTypes.h
    
    """
    @classmethod
    def get_scale_keys(cls, track: RawAnimSequenceTrack) -> Array[Vector]:
        r"""
        X.get_scale_keys(track) -> Array[Vector]
        Returns the scale keys contained by the FRawAnimSequenceTrack
        
        Args:
            track (RawAnimSequenceTrack): 
        
        Returns:
            Array[Vector]:
        """
        ...
    @classmethod
    def get_rotational_keys(cls, track: RawAnimSequenceTrack) -> Array[Quat]:
        r"""
        X.get_rotational_keys(track) -> Array[Quat]
        Returns the rotational keys contained by the FRawAnimSequenceTrack
        
        Args:
            track (RawAnimSequenceTrack): 
        
        Returns:
            Array[Quat]:
        """
        ...
    @classmethod
    def get_positional_keys(cls, track: RawAnimSequenceTrack) -> Array[Vector]:
        r"""
        X.get_positional_keys(track) -> Array[Vector]
        Returns the positional keys contained by the FRawAnimSequenceTrack
        
        Args:
            track (RawAnimSequenceTrack): 
        
        Returns:
            Array[Vector]:
        """
        ...

class AsyncPhysicsData(Object):
    r"""
    The base class for async physics data. Inherit from this to create custom data for async physics tick.
    When no data is available (say due to massive latency or packet loss) we fall back on the default constructed data.
    This means you should set the default values to something equivalent to no input (for example bPlayerWantsToJump should probably default to false)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncPhysicsData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``replication_redundancy`` (int32):  [Read-Write] Determines how many times we redundantly send data to server. The higher this number the less packet loss, but more bandwidth is used
    """
    ...

class AudioPanelWidgetInterface(Interface):
    r"""
    Audio Panel Widget Interface
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioPanelWidgetInterface.h
    
    """
    def get_icon_brush_name(self) -> Name:
        r"""
        x.get_icon_brush_name() -> Name
        Get Icon Brush Name
        
        Returns:
            Name:
        """
        ...
    def get_editor_name(self) -> Text:
        r"""
        x.get_editor_name() -> Text
        Get Editor Name
        
        Returns:
            Text:
        """
        ...

class BlendSpace(AnimationAsset):
    r"""
    Allows multiple animations to be blended between based on input parameters
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_mesh_space_blending`` (bool):  [Read-Write] If set then blending is performed in mesh space if there are per-bone sample smoothing overrides.
      
      Note that mesh space blending is significantly more expensive (slower) than normal blending when the
      samples are regular animations (i.e. not additive animations that are already set to apply in mesh
      space), and is typically only useful if you want some parts of the skeleton to achieve a pose
      in mesh space faster or slower than others - for example to make the head move faster than the
      body/arms when aiming, so the character looks at the target slightly before aiming at it.
      
      Note also that blend space assets with additive/mesh space samples will always blend in mesh space, and
      also that enabling this option with blend space graphs producing additive/mesh space samples may cause
      undesired results.
    - ``analysis_properties`` (AnalysisProperties):  [Read-Write] Analysis properties for each axis. Note that these can be null. They will be created/set from
      FBlendSpaceDetails::HandleAnalysisFunctionChanged
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``axis_to_scale_animation`` (BlendSpaceAxis):  [Read-Write] If you have input smoothing, this specifies the axis on which to scale the animation playback speed. E.g. for
      locomotion animation, the speed axis will scale the animation speed in order to make up the difference
      between the target and the result of blending the samples.
    - ``blend_parameters`` (BlendParameter):  [Read-Write] Blend Parameters for each axis. *
    - ``interpolate_using_grid`` (bool):  [Read-Write] If true then interpolation is done via a grid at runtime. If false the interpolation uses the triangulation.
    - ``interpolation_param`` (InterpolationParameter):  [Read-Write] Input Smoothing parameters for each input axis
    - ``loop`` (bool):  [Read-Write] The default looping behavior of this blend space.
      Asset players can override this
    - ``manual_per_bone_overrides`` (Array[PerBoneInterpolation]):  [Read-Write] Per bone sample smoothing settings, which affect the specified bone and all its descendants in the skeleton.
      These act as overrides to the global sample smoothing speed, which means the global sample smoothing speed does
      not affect these bones. Note that they also override each other - so a per-bone setting on the chest will not
      affect the hand if there is a per-bone setting on the arm.
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``notify_trigger_mode`` (NotifyTriggerMode):  [Read-Write] The current mode used by the BlendSpace to decide which animation notifies to fire. Valid options are:
            - AllAnimations: All notify events will fire
            - HighestWeightedAnimation: Notify events will only fire from the highest weighted animation
            - None: No notify events will fire from any animations
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``per_bone_blend_mode`` (BlendSpacePerBoneBlendMode):  [Read-Write] There are two ways to use per pone sample smoothing: Blend profiles and manually maintaining the per bone overrides.
    - ``per_bone_blend_profile`` (BlendSpaceBlendProfile):  [Read-Write] Reference to a blend profile of the corresponding skeleton to be used for per bone smoothing in case the per bone blend mode is set to use a blend profile.
    - ``preferred_triangulation_direction`` (PreferredTriangulationDirection):  [Read-Write] Preferred edge direction when the triangulation has to make an arbitrary choice
    - ``preview_base_pose`` (AnimSequence):  [Read-Write] Preview Base pose for additive BlendSpace *
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``sample_data`` (Array[BlendSample]):  [Read-Write] Sample animation data
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``target_weight_interpolation_ease_in_out`` (bool):  [Read-Write] If set then this eases in/out the sample weight adjustments, using the speed to determine how much smoothing to apply.
    - ``target_weight_interpolation_speed_per_sec`` (float):  [Read-Write] If greater than zero, this is the speed at which the sample weights are allowed to change.
      
      A speed of 1 means a sample weight can change from zero to one (or one to zero) in one second.
      A speed of 2 means that this would take half a second.
      
      This allows the Blend Space to switch to new parameters without going through intermediate states,
      effectively blending between where it was and where the new target is. For example, imagine we have
      a blend space for locomotion, moving left, forward and right. Now if you interpolate the inputs of
      the blend space itself, from one extreme to the other, you will go from left, to forward, to right.
      As an alternative, by setting this Sample Weight Speed to a value higher than zero, it will go
      directly from left to right, without going through moving forward first.
      
      Smaller values mean slower adjustments of the sample weights, and thus more smoothing. However, a
      value of zero disables this smoothing entirely.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    ...

class BlendSpaceBase(BlendSpace):
    r"""
    deprecated: 'BlendSpaceBase' was renamed to 'BlendSpace'.
    """
    ...

class ReflectionCapture(Actor):
    r"""
    Reflection Capture
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ReflectionCapture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``capture_component`` (ReflectionCaptureComponent):  [Read-Only] Reflection capture component.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def capture_component(self) -> ReflectionCaptureComponent:
        r"""
        (ReflectionCaptureComponent):  [Read-Only] Reflection capture component.
        """
        ...

class BoxReflectionCapture(ReflectionCapture):
    r"""
    Actor used to capture the scene for reflection in a box shape
    see: https://docs.unrealengine.com/latest/INT/Resources/ContentExamples/Reflections/1_3/index.html
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BoxReflectionCapture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``capture_component`` (ReflectionCaptureComponent):  [Read-Only] Reflection capture component.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class ReflectionCaptureComponent(SceneComponent):
    r"""
    -> will be exported to EngineDecalClasses.h
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ReflectionCaptureComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``brightness`` (float):  [Read-Write] A brightness control to scale the captured scene's reflection intensity.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capture_offset`` (Vector):  [Read-Write] World space offset to apply before capturing.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``cubemap`` (TextureCube):  [Read-Write] Cubemap to use for reflection if ReflectionSourceType is set to RS_SpecifiedCubemap.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``reflection_source_type`` (ReflectionSourceType):  [Read-Write] Indicates where to get the reflection source from.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``source_cubemap_angle`` (float):  [Read-Write] Angle to rotate the source cubemap when SourceType is set to SLS_SpecifiedCubemap.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def reflection_source_type(self) -> ReflectionSourceType:
        r"""
        (ReflectionSourceType):  [Read-Only] Indicates where to get the reflection source from.
        """
        ...
    @property
    def cubemap(self) -> TextureCube:
        r"""
        (TextureCube):  [Read-Only] Cubemap to use for reflection if ReflectionSourceType is set to RS_SpecifiedCubemap.
        """
        ...
    @property
    def source_cubemap_angle(self) -> float:
        r"""
        (float):  [Read-Only] Angle to rotate the source cubemap when SourceType is set to SLS_SpecifiedCubemap.
        """
        ...
    @property
    def brightness(self) -> float:
        r"""
        (float):  [Read-Only] A brightness control to scale the captured scene's reflection intensity.
        """
        ...
    @property
    def capture_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] World space offset to apply before capturing.
        """
        ...
    @capture_offset.setter
    def capture_offset(self, value: Vector) -> None:
        ...

class BoxReflectionCaptureComponent(ReflectionCaptureComponent):
    r"""
    -> will be exported to EngineDecalClasses.h
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BoxReflectionCaptureComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``box_transition_distance`` (float):  [Read-Write] Adjust capture transition distance
    - ``brightness`` (float):  [Read-Write] A brightness control to scale the captured scene's reflection intensity.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capture_offset`` (Vector):  [Read-Write] World space offset to apply before capturing.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``cubemap`` (TextureCube):  [Read-Write] Cubemap to use for reflection if ReflectionSourceType is set to RS_SpecifiedCubemap.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``reflection_source_type`` (ReflectionSourceType):  [Read-Write] Indicates where to get the reflection source from.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``source_cubemap_angle`` (float):  [Read-Write] Angle to rotate the source cubemap when SourceType is set to SLS_SpecifiedCubemap.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def box_transition_distance(self) -> float:
        r"""
        (float):  [Read-Write] Adjust capture transition distance
        """
        ...
    @box_transition_distance.setter
    def box_transition_distance(self, value: float) -> None:
        ...

class BuiltInAttributesExtensions(BlueprintFunctionLibrary):
    r"""
    Built in Attributes Extensions
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BuiltInAttributeTypes.h
    
    """
    @classmethod
    def add_transform_attribute(cls, anim_sequence_base: AnimSequenceBase, attribute_name: Name, bone_name: Name, keys: Array[float], values: Array[Transform]) -> bool:
        r"""
        X.add_transform_attribute(anim_sequence_base, attribute_name, bone_name, keys, values) -> bool
        Add Transform Attribute
        
        Args:
            anim_sequence_base (AnimSequenceBase): 
            attribute_name (Name): 
            bone_name (Name): 
            keys (Array[float]): 
            values (Array[Transform]): 
        
        Returns:
            bool:
        """
        ...

class ChaosBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Chaos Blueprint Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChaosBlueprintLibrary.h
    
    """
    @classmethod
    def get_event_relay_from_context(cls, context_object: Object) -> ChaosEventRelay:
        r"""
        X.get_event_relay_from_context(context_object) -> ChaosEventRelay
        Get Event Relay from Context
        
        Args:
            context_object (Object): 
        
        Returns:
            ChaosEventRelay:
        """
        ...

class ChaosEventRelay(Object):
    r"""
    An object managing events
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChaosEventRelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_break_event`` (BreakEventSignature):  [Read-Write]
    - ``on_collision_event`` (CollisionEventSignature):  [Read-Write]
    - ``on_crumbling_event`` (CrumblingEventSignature):  [Read-Write]
    - ``on_removal_event`` (RemovalEventSignature):  [Read-Write]
    """
    @property
    def on_collision_event(self) -> CollisionEventSignature:
        r"""
        (CollisionEventSignature):  [Read-Write]
        """
        ...
    @on_collision_event.setter
    def on_collision_event(self, value: CollisionEventSignature) -> None:
        ...
    @property
    def on_break_event(self) -> BreakEventSignature:
        r"""
        (BreakEventSignature):  [Read-Write]
        """
        ...
    @on_break_event.setter
    def on_break_event(self, value: BreakEventSignature) -> None:
        ...
    @property
    def on_removal_event(self) -> RemovalEventSignature:
        r"""
        (RemovalEventSignature):  [Read-Write]
        """
        ...
    @on_removal_event.setter
    def on_removal_event(self, value: RemovalEventSignature) -> None:
        ...
    @property
    def on_crumbling_event(self) -> CrumblingEventSignature:
        r"""
        (CrumblingEventSignature):  [Read-Write]
        """
        ...
    @on_crumbling_event.setter
    def on_crumbling_event(self, value: CrumblingEventSignature) -> None:
        ...

class DataLayerManager(Object):
    r"""
    Data Layer Manager
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayerManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_data_layer_instance_runtime_state_changed`` (OnDataLayerInstanceRuntimeStateChanged):  [Read-Write]
    """
    @property
    def on_data_layer_instance_runtime_state_changed(self) -> OnDataLayerInstanceRuntimeStateChanged:
        r"""
        (OnDataLayerInstanceRuntimeStateChanged):  [Read-Write]
        """
        ...
    @on_data_layer_instance_runtime_state_changed.setter
    def on_data_layer_instance_runtime_state_changed(self, value: OnDataLayerInstanceRuntimeStateChanged) -> None:
        ...
    def set_data_layer_runtime_state(self, data_layer_asset: DataLayerAsset, state: DataLayerRuntimeState, is_recursive: bool = False) -> bool:
        r"""
        x.set_data_layer_runtime_state(data_layer_asset, state, is_recursive=False) -> bool
        Set Data Layer Runtime State
        
        Args:
            data_layer_asset (DataLayerAsset): 
            state (DataLayerRuntimeState): 
            is_recursive (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_data_layer_instance_runtime_state(self, data_layer_instance: DataLayerInstance, state: DataLayerRuntimeState, is_recursive: bool = False) -> bool:
        r"""
        x.set_data_layer_instance_runtime_state(data_layer_instance, state, is_recursive=False) -> bool
        Set Data Layer Instance Runtime State
        
        Args:
            data_layer_instance (DataLayerInstance): 
            state (DataLayerRuntimeState): 
            is_recursive (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_data_layer_instances(self) -> Array[DataLayerInstance]:
        r"""
        x.get_data_layer_instances() -> Array[DataLayerInstance]
        Get Data Layer Instances
        
        Returns:
            Array[DataLayerInstance]:
        """
        ...
    def get_data_layer_instance_runtime_state(self, data_layer_instance: DataLayerInstance) -> DataLayerRuntimeState:
        r"""
        x.get_data_layer_instance_runtime_state(data_layer_instance) -> DataLayerRuntimeState
        Get Data Layer Instance Runtime State
        
        Args:
            data_layer_instance (DataLayerInstance): 
        
        Returns:
            DataLayerRuntimeState:
        """
        ...
    def get_data_layer_instance_from_name(self, data_layer_instance_name: Name) -> DataLayerInstance:
        r"""
        x.get_data_layer_instance_from_name(data_layer_instance_name) -> DataLayerInstance
        Get Data Layer Instance from Name
        
        Args:
            data_layer_instance_name (Name): 
        
        Returns:
            DataLayerInstance:
        """
        ...
    def get_data_layer_instance_from_asset(self, data_layer_asset: DataLayerAsset) -> DataLayerInstance:
        r"""
        x.get_data_layer_instance_from_asset(data_layer_asset) -> DataLayerInstance
        Get Data Layer Instance from Asset
        
        Args:
            data_layer_asset (DataLayerAsset): 
        
        Returns:
            DataLayerInstance:
        """
        ...
    def get_data_layer_instance_effective_runtime_state(self, data_layer_instance: DataLayerInstance) -> DataLayerRuntimeState:
        r"""
        x.get_data_layer_instance_effective_runtime_state(data_layer_instance) -> DataLayerRuntimeState
        Get Data Layer Instance Effective Runtime State
        
        Args:
            data_layer_instance (DataLayerInstance): 
        
        Returns:
            DataLayerRuntimeState:
        """
        ...

class DialogueSoundWaveProxy(SoundBase):
    r"""
    Dialogue Sound Wave Proxy
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DialogueSoundWaveProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] Attenuation settings package for the sound
    - ``audio_properties_bindings`` (AudioPropertiesBindings):  [Read-Write]
    - ``audio_properties_sheet`` (AudioPropertiesSheetAssetBase):  [Read-Write]
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``bypass_volume_scale_for_priority`` (bool):  [Read-Write] Bypass volume weighting priority upon evaluating whether sound should remain active when max channel count is met (See platform Audio Settings).
    - ``concurrency_overrides`` (SoundConcurrencySettings):  [Read-Write] If Override Concurrency is true, concurrency settings to use.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] Set of concurrency settings to observe (if override is set to false).  Sound must pass all concurrency settings to play.
    - ``debug`` (bool):  [Read-Write] When "au.3dVisualize.Attenuation" has been specified, draw this sound's attenuation shape when the sound is audible. For debugging purposes only.
    - ``duration`` (float):  [Read-Only] Duration of sound in seconds.
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``max_distance`` (float):  [Read-Only] The max distance of the asset, as determined by attenuation settings.
    - ``override_concurrency`` (bool):  [Read-Write] Whether or not to override the sound concurrency object with local concurrency settings.
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``priority`` (float):  [Read-Write] Used to determine whether sound can play or remain active if channel limit is met, where higher value is higher priority
      (see platform's Audio Settings 'Max Channels' property). Unless bypassed, value is weighted with the final volume of the
      sound to produce final runtime priority value.
    - ``sound_class_object`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix_object`` (SoundSubmixBase):  [Read-Write] Submix to route sound output to. If unset, falls back to referenced SoundClass submix.
      If SoundClass submix is unset, sends to the 'Master Submix' as set in the 'Audio' category of Project Settings'.
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] Array of submix sends to which a prescribed amount (see 'Send Level') of this sound is sent.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``total_samples`` (float):  [Read-Only] Total number of samples (in the thousands). Useful as a metric to analyze the relative size of a given sound asset in content browser.
    - ``virtualization_mode`` (VirtualizationMode):  [Read-Write] Virtualization behavior, determining if a sound may revive and how it continues playing when culled or evicted (limited to looping sounds).
    """
    ...

class Light(Actor):
    r"""
    Light
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Light.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``light_component`` (LightComponent):  [Read-Write]
      todo: document
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def light_component(self) -> LightComponent:
        r"""
        (LightComponent):  [Read-Only]
        todo: document
        """
        ...
    def toggle_enabled(self) -> None:
        r"""
        x.toggle_enabled() -> None
        Toggle Enabled
        deprecated: Function 'ToggleEnabled' is deprecated.
        """
        ...
    def set_light_function_scale(self, new_light_function_scale: Vector) -> None:
        r"""
        x.set_light_function_scale(new_light_function_scale) -> None
        Set Light Function Scale
        deprecated: Function 'SetLightFunctionScale' is deprecated.
        
        Args:
            new_light_function_scale (Vector):
        """
        ...
    def set_light_function_material(self, new_light_function_material: MaterialInterface) -> None:
        r"""
        x.set_light_function_material(new_light_function_material) -> None
        Set Light Function Material
        deprecated: Function 'SetLightFunctionMaterial' is deprecated.
        
        Args:
            new_light_function_material (MaterialInterface):
        """
        ...
    def set_light_function_fade_distance(self, new_light_function_fade_distance: float) -> None:
        r"""
        x.set_light_function_fade_distance(new_light_function_fade_distance) -> None
        Set Light Function Fade Distance
        deprecated: Function 'SetLightFunctionFadeDistance' is deprecated.
        
        Args:
            new_light_function_fade_distance (float):
        """
        ...
    def set_light_color(self, new_light_color: LinearColor) -> None:
        r"""
        x.set_light_color(new_light_color) -> None
        Set Light Color
        deprecated: Function 'SetLightColor' is deprecated.
        
        Args:
            new_light_color (LinearColor):
        """
        ...
    def set_enabled(self, set_enabled: bool) -> None:
        r"""
        x.set_enabled(set_enabled) -> None
        BEGIN DEPRECATED (use component functions now in level script)
        deprecated: Function 'SetEnabled' is deprecated.
        
        Args:
            set_enabled (bool):
        """
        ...
    def set_cast_shadows(self, new_value: bool) -> None:
        r"""
        x.set_cast_shadows(new_value) -> None
        Set Cast Shadows
        deprecated: Function 'SetCastShadows' is deprecated.
        
        Args:
            new_value (bool):
        """
        ...
    def set_brightness(self, new_brightness: float) -> None:
        r"""
        x.set_brightness(new_brightness) -> None
        Set Brightness
        deprecated: Function 'SetBrightness' is deprecated.
        
        Args:
            new_brightness (float):
        """
        ...
    def set_affect_translucent_lighting(self, new_value: bool) -> None:
        r"""
        x.set_affect_translucent_lighting(new_value) -> None
        Set Affect Translucent Lighting
        deprecated: Function 'SetAffectTranslucentLighting' is deprecated.
        
        Args:
            new_value (bool):
        """
        ...
    def is_enabled(self) -> bool:
        r"""
        x.is_enabled() -> bool
        Is Enabled
        deprecated: Function 'IsEnabled' is deprecated.
        
        Returns:
            bool:
        """
        ...
    def get_light_color(self) -> LinearColor:
        r"""
        x.get_light_color() -> LinearColor
        Get Light Color
        deprecated: Function 'GetLightColor' is deprecated.
        
        Returns:
            LinearColor:
        """
        ...
    def get_brightness(self) -> float:
        r"""
        x.get_brightness() -> float
        Get Brightness
        deprecated: Function 'GetBrightness' is deprecated.
        
        Returns:
            float:
        """
        ...

class DirectionalLight(Light):
    r"""
    Implements a directional light actor.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DirectionalLight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``directional_light_component`` (DirectionalLightComponent):  [Read-Only] EditorOnly reference to the light component to allow it to be displayed in the details panel correctly
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``light_component`` (LightComponent):  [Read-Write]
      todo: document
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class DirectionalLightMovable(DirectionalLight):
    r"""
    deprecated: 'DirectionalLightMovable' was renamed to 'DirectionalLight'.
    """
    ...

class DirectionalLightStatic(DirectionalLight):
    r"""
    deprecated: 'DirectionalLightStatic' was renamed to 'DirectionalLight'.
    """
    ...

class DirectionalLightStationary(DirectionalLight):
    r"""
    deprecated: 'DirectionalLightStationary' was renamed to 'DirectionalLight'.
    """
    ...

class Emitter(Actor):
    r"""
    Emitter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Emitter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_particle_burst`` (ParticleBurstSignature):  [Read-Write]
    - ``on_particle_collide`` (ParticleCollisionSignature):  [Read-Write]
    - ``on_particle_death`` (ParticleDeathSignature):  [Read-Write]
    - ``on_particle_spawn`` (ParticleSpawnSignature):  [Read-Write]
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``particle_system_component`` (ParticleSystemComponent):  [Read-Only]
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``post_update_tick_group`` (bool):  [Read-Write]
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def particle_system_component(self) -> ParticleSystemComponent:
        r"""
        (ParticleSystemComponent):  [Read-Only]
        """
        ...
    @property
    def post_update_tick_group(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @post_update_tick_group.setter
    def post_update_tick_group(self, value: bool) -> None:
        ...
    @property
    def on_particle_spawn(self) -> ParticleSpawnSignature:
        r"""
        (ParticleSpawnSignature):  [Read-Write]
        """
        ...
    @on_particle_spawn.setter
    def on_particle_spawn(self, value: ParticleSpawnSignature) -> None:
        ...
    @property
    def on_particle_burst(self) -> ParticleBurstSignature:
        r"""
        (ParticleBurstSignature):  [Read-Write]
        """
        ...
    @on_particle_burst.setter
    def on_particle_burst(self, value: ParticleBurstSignature) -> None:
        ...
    @property
    def on_particle_death(self) -> ParticleDeathSignature:
        r"""
        (ParticleDeathSignature):  [Read-Write]
        """
        ...
    @on_particle_death.setter
    def on_particle_death(self, value: ParticleDeathSignature) -> None:
        ...
    @property
    def on_particle_collide(self) -> ParticleCollisionSignature:
        r"""
        (ParticleCollisionSignature):  [Read-Write]
        """
        ...
    @on_particle_collide.setter
    def on_particle_collide(self, value: ParticleCollisionSignature) -> None:
        ...
    def toggle_active(self) -> None:
        r"""
        x.toggle_active() -> None
        Toggle Active
        deprecated: Function 'ToggleActive' is deprecated.
        """
        ...
    def set_vector_parameter(self, parameter_name: Name, param: Vector) -> None:
        r"""
        x.set_vector_parameter(parameter_name, param) -> None
        Set Vector Parameter
        deprecated: Function 'SetVectorParameter' is deprecated.
        
        Args:
            parameter_name (Name): 
            param (Vector):
        """
        ...
    def set_template(self, new_template: ParticleSystem) -> None:
        r"""
        x.set_template(new_template) -> None
        Set Template
        deprecated: Function 'SetTemplate' is deprecated.
        
        Args:
            new_template (ParticleSystem):
        """
        ...
    def set_material_parameter(self, parameter_name: Name, param: MaterialInterface) -> None:
        r"""
        x.set_material_parameter(parameter_name, param) -> None
        Set Material Parameter
        deprecated: Function 'SetMaterialParameter' is deprecated.
        
        Args:
            parameter_name (Name): 
            param (MaterialInterface):
        """
        ...
    def set_float_parameter(self, parameter_name: Name, param: float) -> None:
        r"""
        x.set_float_parameter(parameter_name, param) -> None
        Set Float Parameter
        deprecated: Function 'SetFloatParameter' is deprecated.
        
        Args:
            parameter_name (Name): 
            param (float):
        """
        ...
    def set_color_parameter(self, parameter_name: Name, param: LinearColor) -> None:
        r"""
        x.set_color_parameter(parameter_name, param) -> None
        Set Color Parameter
        deprecated: Function 'SetColorParameter' is deprecated.
        
        Args:
            parameter_name (Name): 
            param (LinearColor):
        """
        ...
    def set_actor_parameter(self, parameter_name: Name, param: Actor) -> None:
        r"""
        x.set_actor_parameter(parameter_name, param) -> None
        Set Actor Parameter
        deprecated: Function 'SetActorParameter' is deprecated.
        
        Args:
            parameter_name (Name): 
            param (Actor):
        """
        ...
    def is_active(self) -> bool:
        r"""
        x.is_active() -> bool
        Is Active
        deprecated: Function 'IsActive' is deprecated.
        
        Returns:
            bool:
        """
        ...
    def deactivate(self) -> None:
        r"""
        x.deactivate() -> None
        Deactivate
        deprecated: Function 'Deactivate' is deprecated.
        """
        ...
    def activate(self) -> None:
        r"""
        x.activate() -> None
        BEGIN DEPRECATED (use component functions now in level script)
        deprecated: Function 'Activate' is deprecated.
        """
        ...

class EmitterSpawnable(Emitter):
    r"""
    deprecated: 'EmitterSpawnable' was renamed to 'Emitter'.
    """
    ...

class EmitterCameraLensEffectBase(Emitter):
    r"""
    Emitter Camera Lens Effect Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EmitterCameraLensEffectBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_multiple_instances`` (bool):  [Read-Write] true if multiple instances of this emitter can exist simultaneously, false otherwise.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``base_fov`` (float):  [Read-Write] This is the assumed FOV for which the effect was authored. The code will make automatic adjustments to make it look the same at different FOVs
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``emitters_to_treat_as_same`` (Array[type(Class)]):  [Read-Write] If an emitter class in this array is currently playing, do not play this effect.
      Useful for preventing multiple similar or expensive camera effects from playing simultaneously.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_particle_burst`` (ParticleBurstSignature):  [Read-Write]
    - ``on_particle_collide`` (ParticleCollisionSignature):  [Read-Write]
    - ``on_particle_death`` (ParticleDeathSignature):  [Read-Write]
    - ``on_particle_spawn`` (ParticleSpawnSignature):  [Read-Write]
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``particle_system_component`` (ParticleSystemComponent):  [Read-Only]
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``post_update_tick_group`` (bool):  [Read-Write]
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``ps_camera_effect`` (ParticleSystem):  [Read-Write] Particle System to use
    - ``relative_transform`` (Transform):  [Read-Write] Effect-to-camera transform to allow arbitrary placement of the particle system .
      Note the X component of the location will be scaled with camera fov to keep the lens effect the same apparent size.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``reset_when_retriggered`` (bool):  [Read-Write] If bAllowMultipleInstances is true and this effect is retriggered, the particle system will be reset if this is true
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    def get_primary_particle_component(self) -> FXSystemComponent:
        r"""
        x.get_primary_particle_component() -> FXSystemComponent
        Get Primary Particle Component
        
        Returns:
            FXSystemComponent:
        """
        ...
    def get_particle_components(self) -> Array[FXSystemComponent]:
        r"""
        x.get_particle_components() -> Array[FXSystemComponent]
        Get Particle Components
        
        Returns:
            Array[FXSystemComponent]:
        """
        ...

class ExponentialHeightFog(Info):
    r"""
    Implements an Actor for exponential height fog.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ExponentialHeightFog.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``component`` (ExponentialHeightFogComponent):  [Read-Only]
      todo: document
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def component(self) -> ExponentialHeightFogComponent:
        r"""
        (ExponentialHeightFogComponent):  [Read-Only]
        todo: document
        """
        ...

class ExponentialHeightFogComponent(SceneComponent):
    r"""
    Used to create fogging effects such as clouds but with a density that is related to the height of the fog.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ExponentialHeightFogComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``directional_inscattering_exponent`` (float):  [Read-Write] Controls the size of the directional inscattering cone, which is used to approximate inscattering from a directional light.
      Note: there must be a directional light with bUsedAsAtmosphereSunLight enabled for DirectionalInscattering to be used.
    - ``directional_inscattering_luminance`` (LinearColor):  [Read-Write] Controls the color of the directional inscattering, which is used to approximate inscattering from a directional light.
      Note: there must be a directional light with bUsedAsAtmosphereSunLight enabled for DirectionalInscattering to be used.
    - ``directional_inscattering_start_distance`` (float):  [Read-Write] Controls the start distance from the viewer of the directional inscattering, which is used to approximate inscattering from a directional light.
      Note: there must be a directional light with bUsedAsAtmosphereSunLight enabled for DirectionalInscattering to be used.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_volumetric_fog`` (bool):  [Read-Write] Whether to enable Volumetric fog.  Scalability settings control the resolution of the fog simulation.
      Note that Volumetric fog currently does not support StartDistance, FogMaxOpacity and FogCutoffDistance.
      Volumetric fog also can't match exponential height fog in general as exponential height fog has non-physical behavior.
    - ``fog_cutoff_distance`` (float):  [Read-Write] Scene elements past this distance will not have fog applied.  This is useful for excluding skyboxes which already have fog baked in.
    - ``fog_density`` (float):  [Read-Write] Global density factor.
    - ``fog_height_falloff`` (float):  [Read-Write] Height density factor, controls how the density increases as height decreases.
      Smaller values make the visible transition larger.
    - ``fog_inscattering_luminance`` (LinearColor):  [Read-Write]
    - ``fog_max_opacity`` (float):  [Read-Write] Maximum opacity of the fog.
      A value of 1 means the fog can become fully opaque at a distance and replace scene color completely,
      A value of 0 means the fog color will not be factored in at all.
    - ``fully_directional_inscattering_color_distance`` (float):  [Read-Write] Distance at which InscatteringColorCubemap should be used directly for the Inscattering Color.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``inscattering_color_cubemap`` (TextureCube):  [Read-Write] Cubemap that can be specified for fog color, which is useful to make distant, heavily fogged scene elements match the sky.
      When the cubemap is specified, FogInscatteringColor is ignored and Directional inscattering is disabled.
    - ``inscattering_color_cubemap_angle`` (float):  [Read-Write] Angle to rotate the InscatteringColorCubemap around the Z axis.
    - ``inscattering_texture_tint`` (LinearColor):  [Read-Write] Tint color used when InscatteringColorCubemap is specified, for quick edits without having to reimport InscatteringColorCubemap.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``non_directional_inscattering_color_distance`` (float):  [Read-Write] Distance at which only the average color of InscatteringColorCubemap should be used as Inscattering Color.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``override_light_colors_with_fog_inscattering_colors`` (bool):  [Read-Write] Whether to use FogInscatteringColor for the Sky Light volumetric scattering color and DirectionalInscatteringColor for the Directional Light scattering color.
      Make sure your directional light has 'Atmosphere Sun Light' enabled!
      Enabling this allows Volumetric fog to better match Height fog in the distance, but produces non-physical volumetric lighting that may not match surface lighting.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (basepass, transparency)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``second_fog_data`` (ExponentialHeightFogData):  [Read-Write] Settings for the second fog. Setting the density of this to 0 means it doesn't have any influence.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sky_atmosphere_ambient_contribution_color_scale`` (LinearColor):  [Read-Write] Color used to modulate the SkyAtmosphere component contribution to the non directional component of the fog. Only effective when r.SupportSkyAtmosphereAffectsHeightFog>0
    - ``start_distance`` (float):  [Read-Write] Distance from the camera that the fog will start, in world units.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volumetric_fog_albedo`` (Color):  [Read-Write] The height fog particle reflectiveness used by volumetric fog.
      Water particles in air have an albedo near white, while dust has slightly darker value.
    - ``volumetric_fog_distance`` (float):  [Read-Write] Distance over which volumetric fog should be computed, after the start distance.  Larger values extend the effect into the distance but expose under-sampling artifacts in details.
    - ``volumetric_fog_emissive`` (LinearColor):  [Read-Write] Light emitted by height fog.  This is a density so more light is emitted the further you are looking through the fog.
      In most cases skylight is a better choice, however right now volumetric fog does not support precomputed lighting,
      So stationary skylights are unshadowed and static skylights don't affect volumetric fog at all.
    - ``volumetric_fog_extinction_scale`` (float):  [Read-Write] Scales the height fog particle extinction amount used by volumetric fog.  Values larger than 1 cause fog particles everywhere absorb more light.
    - ``volumetric_fog_near_fade_in_distance`` (float):  [Read-Write] Distance over which volumetric fog will fade in from the start distance.
    - ``volumetric_fog_scattering_distribution`` (float):  [Read-Write] Controls the scattering phase function - how much incoming light scatters in various directions.
      A distribution value of 0 scatters equally in all directions, while .9 scatters predominantly in the light direction.
      In order to have visible volumetric fog light shafts from the side, the distribution will need to be closer to 0.
    - ``volumetric_fog_start_distance`` (float):  [Read-Write] Distance from the camera that the volumetric fog will start, in world units.
    - ``volumetric_fog_static_lighting_scattering_intensity`` (float):  [Read-Write]
    """
    @property
    def fog_density(self) -> float:
        r"""
        (float):  [Read-Only] Global density factor.
        """
        ...
    @property
    def fog_height_falloff(self) -> float:
        r"""
        (float):  [Read-Only] Height density factor, controls how the density increases as height decreases.
        Smaller values make the visible transition larger.
        """
        ...
    @property
    def second_fog_data(self) -> ExponentialHeightFogData:
        r"""
        (ExponentialHeightFogData):  [Read-Only] Settings for the second fog. Setting the density of this to 0 means it doesn't have any influence.
        """
        ...
    @property
    def fog_inscattering_luminance(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...
    @property
    def sky_atmosphere_ambient_contribution_color_scale(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Color used to modulate the SkyAtmosphere component contribution to the non directional component of the fog. Only effective when r.SupportSkyAtmosphereAffectsHeightFog>0
        """
        ...
    @property
    def inscattering_color_cubemap(self) -> TextureCube:
        r"""
        (TextureCube):  [Read-Only] Cubemap that can be specified for fog color, which is useful to make distant, heavily fogged scene elements match the sky.
        When the cubemap is specified, FogInscatteringColor is ignored and Directional inscattering is disabled.
        """
        ...
    @property
    def inscattering_color_cubemap_angle(self) -> float:
        r"""
        (float):  [Read-Only] Angle to rotate the InscatteringColorCubemap around the Z axis.
        """
        ...
    @property
    def inscattering_texture_tint(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Tint color used when InscatteringColorCubemap is specified, for quick edits without having to reimport InscatteringColorCubemap.
        """
        ...
    @property
    def fully_directional_inscattering_color_distance(self) -> float:
        r"""
        (float):  [Read-Only] Distance at which InscatteringColorCubemap should be used directly for the Inscattering Color.
        """
        ...
    @property
    def non_directional_inscattering_color_distance(self) -> float:
        r"""
        (float):  [Read-Only] Distance at which only the average color of InscatteringColorCubemap should be used as Inscattering Color.
        """
        ...
    @property
    def directional_inscattering_exponent(self) -> float:
        r"""
        (float):  [Read-Only] Controls the size of the directional inscattering cone, which is used to approximate inscattering from a directional light.
        Note: there must be a directional light with bUsedAsAtmosphereSunLight enabled for DirectionalInscattering to be used.
        """
        ...
    @property
    def directional_inscattering_start_distance(self) -> float:
        r"""
        (float):  [Read-Only] Controls the start distance from the viewer of the directional inscattering, which is used to approximate inscattering from a directional light.
        Note: there must be a directional light with bUsedAsAtmosphereSunLight enabled for DirectionalInscattering to be used.
        """
        ...
    @property
    def directional_inscattering_luminance(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Controls the color of the directional inscattering, which is used to approximate inscattering from a directional light.
        Note: there must be a directional light with bUsedAsAtmosphereSunLight enabled for DirectionalInscattering to be used.
        """
        ...
    @property
    def fog_max_opacity(self) -> float:
        r"""
        (float):  [Read-Only] Maximum opacity of the fog.
        A value of 1 means the fog can become fully opaque at a distance and replace scene color completely,
        A value of 0 means the fog color will not be factored in at all.
        """
        ...
    @property
    def start_distance(self) -> float:
        r"""
        (float):  [Read-Only] Distance from the camera that the fog will start, in world units.
        """
        ...
    @property
    def fog_cutoff_distance(self) -> float:
        r"""
        (float):  [Read-Only] Scene elements past this distance will not have fog applied.  This is useful for excluding skyboxes which already have fog baked in.
        """
        ...
    @property
    def enable_volumetric_fog(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to enable Volumetric fog.  Scalability settings control the resolution of the fog simulation.
        Note that Volumetric fog currently does not support StartDistance, FogMaxOpacity and FogCutoffDistance.
        Volumetric fog also can't match exponential height fog in general as exponential height fog has non-physical behavior.
        """
        ...
    @property
    def volumetric_fog_scattering_distribution(self) -> float:
        r"""
        (float):  [Read-Only] Controls the scattering phase function - how much incoming light scatters in various directions.
        A distribution value of 0 scatters equally in all directions, while .9 scatters predominantly in the light direction.
        In order to have visible volumetric fog light shafts from the side, the distribution will need to be closer to 0.
        """
        ...
    @property
    def volumetric_fog_albedo(self) -> Color:
        r"""
        (Color):  [Read-Only] The height fog particle reflectiveness used by volumetric fog.
        Water particles in air have an albedo near white, while dust has slightly darker value.
        """
        ...
    @property
    def volumetric_fog_emissive(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Light emitted by height fog.  This is a density so more light is emitted the further you are looking through the fog.
        In most cases skylight is a better choice, however right now volumetric fog does not support precomputed lighting,
        So stationary skylights are unshadowed and static skylights don't affect volumetric fog at all.
        """
        ...
    @property
    def volumetric_fog_extinction_scale(self) -> float:
        r"""
        (float):  [Read-Only] Scales the height fog particle extinction amount used by volumetric fog.  Values larger than 1 cause fog particles everywhere absorb more light.
        """
        ...
    @property
    def volumetric_fog_distance(self) -> float:
        r"""
        (float):  [Read-Only] Distance over which volumetric fog should be computed, after the start distance.  Larger values extend the effect into the distance but expose under-sampling artifacts in details.
        """
        ...
    @property
    def volumetric_fog_start_distance(self) -> float:
        r"""
        (float):  [Read-Only] Distance from the camera that the volumetric fog will start, in world units.
        """
        ...
    @property
    def volumetric_fog_near_fade_in_distance(self) -> float:
        r"""
        (float):  [Read-Only] Distance over which volumetric fog will fade in from the start distance.
        """
        ...
    @property
    def volumetric_fog_static_lighting_scattering_intensity(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def override_light_colors_with_fog_inscattering_colors(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to use FogInscatteringColor for the Sky Light volumetric scattering color and DirectionalInscatteringColor for the Directional Light scattering color.
        Make sure your directional light has 'Atmosphere Sun Light' enabled!
        Enabling this allows Volumetric fog to better match Height fog in the distance, but produces non-physical volumetric lighting that may not match surface lighting.
        """
        ...
    @property
    def holdout(self) -> bool:
        r"""
        (bool):  [Read-Only] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
        """
        ...
    @property
    def render_in_main_pass(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will be rendered in the main pass (basepass, transparency)
        """
        ...
    def set_volumetric_fog_scattering_distribution(self, new_value: float) -> None:
        r"""
        x.set_volumetric_fog_scattering_distribution(new_value) -> None
        Set Volumetric Fog Scattering Distribution
        
        Args:
            new_value (float):
        """
        ...
    def set_volumetric_fog_extinction_scale(self, new_value: float) -> None:
        r"""
        x.set_volumetric_fog_extinction_scale(new_value) -> None
        Set Volumetric Fog Extinction Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_volumetric_fog_emissive(self, new_value: LinearColor) -> None:
        r"""
        x.set_volumetric_fog_emissive(new_value) -> None
        Set Volumetric Fog Emissive
        
        Args:
            new_value (LinearColor):
        """
        ...
    def set_volumetric_fog_distance(self, new_value: float) -> None:
        r"""
        x.set_volumetric_fog_distance(new_value) -> None
        Set Volumetric Fog Distance
        
        Args:
            new_value (float):
        """
        ...
    def set_volumetric_fog_albedo(self, new_value: Color) -> None:
        r"""
        x.set_volumetric_fog_albedo(new_value) -> None
        Set Volumetric Fog Albedo
        
        Args:
            new_value (Color):
        """
        ...
    def set_volumetric_fog(self, new_value: bool) -> None:
        r"""
        x.set_volumetric_fog(new_value) -> None
        Set Volumetric Fog
        
        Args:
            new_value (bool):
        """
        ...
    def set_start_distance(self, value: float) -> None:
        r"""
        x.set_start_distance(value) -> None
        Set Start Distance
        
        Args:
            value (float):
        """
        ...
    def set_second_fog_height_offset(self, value: float) -> None:
        r"""
        x.set_second_fog_height_offset(value) -> None
        Set Second Fog Height Offset
        
        Args:
            value (float):
        """
        ...
    def set_second_fog_height_falloff(self, value: float) -> None:
        r"""
        x.set_second_fog_height_falloff(value) -> None
        Set Second Fog Height Falloff
        
        Args:
            value (float):
        """
        ...
    def set_second_fog_density(self, value: float) -> None:
        r"""
        x.set_second_fog_density(value) -> None
        Set Second Fog Density
        
        Args:
            value (float):
        """
        ...
    def set_second_fog_data(self, new_value: ExponentialHeightFogData) -> None:
        r"""
        x.set_second_fog_data(new_value) -> None
        Set Second Fog Data
        
        Args:
            new_value (ExponentialHeightFogData):
        """
        ...
    def set_render_in_main_pass(self, value: bool) -> None:
        r"""
        x.set_render_in_main_pass(value) -> None
        Set Render in Main Pass
        
        Args:
            value (bool):
        """
        ...
    def set_non_directional_inscattering_color_distance(self, value: float) -> None:
        r"""
        x.set_non_directional_inscattering_color_distance(value) -> None
        Set Non Directional Inscattering Color Distance
        
        Args:
            value (float):
        """
        ...
    def set_inscattering_texture_tint(self, value: LinearColor) -> None:
        r"""
        x.set_inscattering_texture_tint(value) -> None
        Set Inscattering Texture Tint
        
        Args:
            value (LinearColor):
        """
        ...
    def set_inscattering_color_cubemap_angle(self, value: float) -> None:
        r"""
        x.set_inscattering_color_cubemap_angle(value) -> None
        Set Inscattering Color Cubemap Angle
        
        Args:
            value (float):
        """
        ...
    def set_inscattering_color_cubemap(self, value: TextureCube) -> None:
        r"""
        x.set_inscattering_color_cubemap(value) -> None
        Set Inscattering Color Cubemap
        
        Args:
            value (TextureCube):
        """
        ...
    def set_holdout(self, new_holdout: bool) -> None:
        r"""
        x.set_holdout(new_holdout) -> None
        Set Holdout
        
        Args:
            new_holdout (bool):
        """
        ...
    def set_fully_directional_inscattering_color_distance(self, value: float) -> None:
        r"""
        x.set_fully_directional_inscattering_color_distance(value) -> None
        Set Fully Directional Inscattering Color Distance
        
        Args:
            value (float):
        """
        ...
    def set_fog_max_opacity(self, value: float) -> None:
        r"""
        x.set_fog_max_opacity(value) -> None
        Set Fog Max Opacity
        
        Args:
            value (float):
        """
        ...
    def set_fog_inscattering_color(self, value: LinearColor) -> None:
        r"""
        x.set_fog_inscattering_color(value) -> None
        Set Fog Inscattering Color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_fog_height_falloff(self, value: float) -> None:
        r"""
        x.set_fog_height_falloff(value) -> None
        Set Fog Height Falloff
        
        Args:
            value (float):
        """
        ...
    def set_fog_density(self, value: float) -> None:
        r"""
        x.set_fog_density(value) -> None
        Set Fog Density
        
        Args:
            value (float):
        """
        ...
    def set_fog_cutoff_distance(self, value: float) -> None:
        r"""
        x.set_fog_cutoff_distance(value) -> None
        Set Fog Cutoff Distance
        
        Args:
            value (float):
        """
        ...
    def set_directional_inscattering_start_distance(self, value: float) -> None:
        r"""
        x.set_directional_inscattering_start_distance(value) -> None
        Set Directional Inscattering Start Distance
        
        Args:
            value (float):
        """
        ...
    def set_directional_inscattering_exponent(self, value: float) -> None:
        r"""
        x.set_directional_inscattering_exponent(value) -> None
        Set Directional Inscattering Exponent
        
        Args:
            value (float):
        """
        ...
    def set_directional_inscattering_color(self, value: LinearColor) -> None:
        r"""
        x.set_directional_inscattering_color(value) -> None
        Set Directional Inscattering Color
        
        Args:
            value (LinearColor):
        """
        ...

class DataLayerAsset(DataAsset):
    r"""
    Data Layer Asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayerAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_layer_type`` (DataLayerType):  [Read-Write] Whether the Data Layer affects actor runtime loading
    - ``debug_color`` (Color):  [Read-Write]
    - ``load_filter`` (DataLayerLoadFilter):  [Read-Write]
    - ``supports_actor_filters`` (bool):  [Read-Write]
    """
    def is_server_only(self) -> bool:
        r"""
        x.is_server_only() -> bool
        Is Server Only
        
        Returns:
            bool:
        """
        ...
    def is_runtime(self) -> bool:
        r"""
        x.is_runtime() -> bool
        Is Runtime
        
        Returns:
            bool:
        """
        ...
    def is_client_only(self) -> bool:
        r"""
        x.is_client_only() -> bool
        Is Client Only
        
        Returns:
            bool:
        """
        ...
    def get_type(self) -> DataLayerType:
        r"""
        x.get_type() -> DataLayerType
        Get Type
        
        Returns:
            DataLayerType:
        """
        ...
    def get_debug_color(self) -> Color:
        r"""
        x.get_debug_color() -> Color
        Get Debug Color
        
        Returns:
            Color:
        """
        ...

class ExternalDataLayerAsset(DataLayerAsset):
    r"""
    External Data Layer Asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ExternalDataLayerAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_layer_type`` (DataLayerType):  [Read-Write] Whether the Data Layer affects actor runtime loading
    - ``debug_color`` (Color):  [Read-Write]
    - ``load_filter`` (DataLayerLoadFilter):  [Read-Write]
    - ``supports_actor_filters`` (bool):  [Read-Write]
    - ``uid`` (ExternalDataLayerUID):  [Read-Only]
    """
    ...

class DataLayerInstance(Object):
    r"""
    Data Layer Instance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayerInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``initial_runtime_state`` (DataLayerRuntimeState):  [Read-Write] Initial runtime state of this data layer instance. Only supported if it's runtime and not client/server only.
    - ``is_initially_loaded_in_editor`` (bool):  [Read-Write] Determines the default value of the data layer's loaded state in editor if it hasn't been changed in data layer outliner by the user
    - ``is_initially_visible`` (bool):  [Read-Write] Whether actors associated with the Data Layer should be initially visible in the viewport when loading the map
    """
    def is_visible(self) -> bool:
        r"""
        x.is_visible() -> bool
        Is Visible
        
        Returns:
            bool:
        """
        ...
    def is_server_only(self) -> bool:
        r"""
        x.is_server_only() -> bool
        Is Server Only
        
        Returns:
            bool:
        """
        ...
    def is_runtime(self) -> bool:
        r"""
        x.is_runtime() -> bool
        Is Runtime
        
        Returns:
            bool:
        """
        ...
    def is_initially_visible(self) -> bool:
        r"""
        x.is_initially_visible() -> bool
        Is Initially Visible
        
        Returns:
            bool:
        """
        ...
    def is_effective_visible(self) -> bool:
        r"""
        x.is_effective_visible() -> bool
        Is Effective Visible
        
        Returns:
            bool:
        """
        ...
    def is_client_only(self) -> bool:
        r"""
        x.is_client_only() -> bool
        Is Client Only
        
        Returns:
            bool:
        """
        ...
    def get_type(self) -> DataLayerType:
        r"""
        x.get_type() -> DataLayerType
        Get Type
        
        Returns:
            DataLayerType:
        """
        ...
    def get_initial_runtime_state(self) -> DataLayerRuntimeState:
        r"""
        x.get_initial_runtime_state() -> DataLayerRuntimeState
        Get Initial Runtime State
        
        Returns:
            DataLayerRuntimeState:
        """
        ...
    def get_debug_color(self) -> Color:
        r"""
        x.get_debug_color() -> Color
        Get Debug Color
        
        Returns:
            Color:
        """
        ...
    def get_data_layer_short_name(self) -> str:
        r"""
        x.get_data_layer_short_name() -> str
        Get Data Layer Short Name
        
        Returns:
            str:
        """
        ...
    def get_data_layer_full_name(self) -> str:
        r"""
        x.get_data_layer_full_name() -> str
        Get Data Layer Full Name
        
        Returns:
            str:
        """
        ...
    def get_asset(self) -> DataLayerAsset:
        r"""
        x.get_asset() -> DataLayerAsset
        Get Asset
        
        Returns:
            DataLayerAsset:
        """
        ...

class DataLayerInstanceWithAsset(DataLayerInstance):
    r"""
    Data Layer Instance with Asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayerInstanceWithAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_layer_asset`` (DataLayerAsset):  [Read-Write]
    - ``initial_runtime_state`` (DataLayerRuntimeState):  [Read-Write] Initial runtime state of this data layer instance. Only supported if it's runtime and not client/server only.
    - ``is_included_in_actor_filter_default`` (bool):  [Read-Write] Whether actors assigned to this DataLayer are included by default when used in a filter
    - ``is_initially_loaded_in_editor`` (bool):  [Read-Write] Determines the default value of the data layer's loaded state in editor if it hasn't been changed in data layer outliner by the user
    - ``is_initially_visible`` (bool):  [Read-Write] Whether actors associated with the Data Layer should be initially visible in the viewport when loading the map
    """
    ...

class ExternalDataLayerInstance(DataLayerInstanceWithAsset):
    r"""
    External Data Layer Instance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ExternalDataLayerInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_layer_asset`` (DataLayerAsset):  [Read-Write]
    - ``initial_runtime_state`` (DataLayerRuntimeState):  [Read-Write] Initial runtime state of this data layer instance. Only supported if it's runtime and not client/server only.
    - ``is_included_in_actor_filter_default`` (bool):  [Read-Write] Whether actors assigned to this DataLayer are included by default when used in a filter
    - ``is_initially_loaded_in_editor`` (bool):  [Read-Write] Determines the default value of the data layer's loaded state in editor if it hasn't been changed in data layer outliner by the user
    - ``is_initially_visible`` (bool):  [Read-Write] Whether actors associated with the Data Layer should be initially visible in the viewport when loading the map
    """
    ...

class FieldNotificationLibrary(BlueprintFunctionLibrary):
    r"""
    The Field Notification system allows a user to know when a property value is modified at runtime (note that it can be a function return value).
    The class needs to implement the INotifyFieldValueChanged interface.
    The property' setter  usually follows this pattern "if (new value != old value) assign the new value; broadcast that the value changed;".
    The Blueprint implementation handles that setter logic automatically with SetPropertyValueAndBroadcast.
    When a property value is modified by replication, the RepNotify will call BroadcastFieldValueChanged.
    A function can also be a Field Notify. The function needs to be const and return a single value.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: FieldNotificationLibrary.h
    
    """
    @classmethod
    def broadcast_field_value_changed(cls, object: Object, field_id: FieldNotificationId) -> None:
        r"""
        X.broadcast_field_value_changed(object, field_id) -> None
        Broadcast that the Field value changed.
        
        Args:
            object (Object): 
            field_id (FieldNotificationId):
        """
        ...
    @classmethod
    def broadcast_fields_value_changed(cls, object: Object, field_ids: Array[FieldNotificationId]) -> None:
        r"""
        X.broadcast_fields_value_changed(object, field_ids) -> None
        Broadcast that a list of Field values changed.
        
        Args:
            object (Object): 
            field_ids (Array[FieldNotificationId]):
        """
        ...

class ForceFeedbackAttenuation(Object):
    r"""
    Wrapper class that can be created as an asset for force feedback attenuation properties which allows reuse
    of the properties for multiple attenuation components
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ForceFeedbackAttenuation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attenuation`` (ForceFeedbackAttenuationSettings):  [Read-Write]
    """
    @property
    def attenuation(self) -> ForceFeedbackAttenuationSettings:
        r"""
        (ForceFeedbackAttenuationSettings):  [Read-Only]
        """
        ...

class GameNetworkManager(Info):
    r"""
    Handles game-specific networking management (cheat detection, bandwidth management, etc.).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameNetworkManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class SpotLight(Light):
    r"""
    Spot Light
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SpotLight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``light_component`` (LightComponent):  [Read-Write]
      todo: document
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``spot_light_component`` (SpotLightComponent):  [Read-Only]
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def spot_light_component(self) -> SpotLightComponent:
        r"""
        (SpotLightComponent):  [Read-Only]
        """
        ...
    def set_outer_cone_angle(self, new_outer_cone_angle: float) -> None:
        r"""
        x.set_outer_cone_angle(new_outer_cone_angle) -> None
        Set Outer Cone Angle
        deprecated: Function 'SetOuterConeAngle' is deprecated.
        
        Args:
            new_outer_cone_angle (float):
        """
        ...
    def set_inner_cone_angle(self, new_inner_cone_angle: float) -> None:
        r"""
        x.set_inner_cone_angle(new_inner_cone_angle) -> None
        BEGIN DEPRECATED (use component functions now in level script)
        deprecated: Function 'SetInnerConeAngle' is deprecated.
        
        Args:
            new_inner_cone_angle (float):
        """
        ...

class SpotLightMovable(SpotLight):
    r"""
    deprecated: 'SpotLightMovable' was renamed to 'SpotLight'.
    """
    ...

class SpotLightStatic(SpotLight):
    r"""
    deprecated: 'SpotLightStatic' was renamed to 'SpotLight'.
    """
    ...

class SpotLightStationary(SpotLight):
    r"""
    deprecated: 'SpotLightStationary' was renamed to 'SpotLight'.
    """
    ...

class GeneratedMeshAreaLight(SpotLight):
    r"""
    Implements a light that is created after a lighting build with Lightmass and handles mesh area light influence on dynamic objects.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GeneratedMeshAreaLight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``light_component`` (LightComponent):  [Read-Write]
      todo: document
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``spot_light_component`` (SpotLightComponent):  [Read-Only]
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class HapticFeedbackEffect_Base(Object):
    r"""
    Haptic Feedback Effect Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HapticFeedbackEffect_Base.h
    
    """
    ...

class HapticFeedbackEffect_Buffer(HapticFeedbackEffect_Base):
    r"""
    Haptic Feedback Effect Buffer
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HapticFeedbackEffect_Buffer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``amplitudes`` (Array[uint8]):  [Read-Write]
    - ``sample_rate`` (int32):  [Read-Write]
    """
    ...

class HapticFeedbackEffect_Curve(HapticFeedbackEffect_Base):
    r"""
    Haptic Feedback Effect Curve
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HapticFeedbackEffect_Curve.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``haptic_details`` (HapticFeedbackDetails_Curve):  [Read-Write]
    """
    ...

class HapticFeedbackEffect(HapticFeedbackEffect_Curve):
    r"""
    deprecated: 'HapticFeedbackEffect' was renamed to 'HapticFeedbackEffect_Curve'.
    """
    ...

class HapticFeedbackEffect_SoundWave(HapticFeedbackEffect_Base):
    r"""
    Haptic Feedback Effect Sound Wave
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HapticFeedbackEffect_SoundWave.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``sound_wave`` (SoundWave):  [Read-Write]
    - ``use_stereo`` (bool):  [Read-Write] If true on a vr controller the left and right stereo channels would be applied to the left and right controller, respectively.
    """
    ...

class HLODInstancedStaticMeshComponent(InstancedStaticMeshComponent):
    r"""
    HLODInstanced Static Mesh Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODInstancedStaticMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``instance_end_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance completely fades out.
    - ``instance_lod_distance_scale`` (float):  [Read-Write] Scale applied to change the computation of LOD distances when using the StaticMesh screen sizes.
      Smaller values make LODs transition earlier.
    - ``instance_start_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance begins to fade out.
    - ``instancing_random_seed`` (int32):  [Read-Write] Value used to seed the random number stream that generates random numbers for each of this mesh's instances.
            The random number is stored in a buffer accessible to materials through the PerInstanceRandom expression. If
            this is set to zero (default), it will be populated automatically by the editor.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``num_custom_data_floats`` (int32):  [Read-Write] Defines the number of floats that will be available per instance for custom data
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``per_instance_sm_custom_data`` (Array[float]):  [Read-Write] Array of custom data for instances. This will contains NumCustomDataFloats*InstanceCount entries. The entries are represented sequantially, in instance order. Can be read in a material and manipulated through Blueprints.
          Example: If NumCustomDataFloats is 1, then each entry will belong to an instance. Custom data 0 will belong to Instance 0. Custom data 1 will belong to Instance 1 etc.
          Example: If NumCustomDataFloats is 2, then each pair of sequential entries belong to an instance. Custom data 0 and 1 will belong to Instance 0. Custom data 2 and 3 will belong to Instance 2 etc.
    - ``per_instance_sm_data`` (Array[InstancedStaticMeshInstanceData]):  [Read-Write] Array of instances, bulk serialized.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``use_gpu_lod_selection`` (bool):  [Read-Write] If true, this component will use GPU LOD selection.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    ...

class AnimationDataController(Interface):
    r"""
    Animation Data Controller
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: IAnimationDataController.h
    
    """
    def update_curve_names_from_skeleton(self, skeleton: Skeleton, supported_curve_type: RawCurveTrackTypes, should_transact: bool = True) -> None:
        r"""
        x.update_curve_names_from_skeleton(skeleton, supported_curve_type, should_transact=True) -> None
        Update Curve Names from Skeleton
        deprecated: This function is no longer used.
        
        Args:
            skeleton (Skeleton): 
            supported_curve_type (RawCurveTrackTypes): 
            should_transact (bool):
        """
        ...
    def set_transform_curve_keys(self, curve_id: AnimationCurveIdentifier, transform_values: Array[Transform], time_keys: Array[float], should_transact: bool = True) -> bool:
        r"""
        x.set_transform_curve_keys(curve_id, transform_values, time_keys, should_transact=True) -> bool
        Replace the keys for the transform curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the transform curve for which the keys are to be set
            transform_values (Array[Transform]): Transform Values with which the existing values are to be replaced
            time_keys (Array[float]): Time Keys with which the existing keys are to be replaced
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the transform curve keys were successfully set
        """
        ...
    def set_transform_curve_key(self, curve_id: AnimationCurveIdentifier, time: float, value: Transform, should_transact: bool = True) -> bool:
        r"""
        x.set_transform_curve_key(curve_id, time, value, should_transact=True) -> bool
        Sets a single key for the transform curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        In case a key for any of the individual transform channel curves already exists the value is replaced.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the transform curve for which the key is to be set
            time (float): Time of the key to be set
            value (Transform): Value of the key to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the transform curve key was successfully set
        """
        ...
    def set_play_length(self, length: float, should_transact: bool = True) -> None:
        r"""
        x.set_play_length(length, should_transact=True) -> None
        Set Play Length
        deprecated: SetPlayLength is deprecated use SetNumberOfFrames instead.
        
        Args:
            length (float): 
            should_transact (bool):
        """
        ...
    def set_number_of_frames(self, new_length_in_frames: FrameNumber, should_transact: bool = True) -> None:
        r"""
        x.set_number_of_frames(new_length_in_frames, should_transact=True) -> None
        Sets the total play-able length in seconds. Broadcasts a EAnimDataModelNotifyType::SequenceLengthChanged notify if successful.
        The number of frames and keys for the provided length is recalculated according to the current value of UAnimDataModel::FrameRate.
        
        Args:
            new_length_in_frames (FrameNumber): Total new play-able number of frames value (according to frame rate), has to be positive and non-zero
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def set_model(self, model: AnimationDataModel) -> None:
        r"""
        x.set_model(model) -> None
        Sets the AnimDataModel instance this controller is supposed to be targeting
        
        Args:
            model (AnimationDataModel): IAnimationDataModel instance to target
        """
        ...
    def set_frame_rate(self, frame_rate: FrameRate, should_transact: bool = True) -> None:
        r"""
        x.set_frame_rate(frame_rate, should_transact=True) -> None
        Sets the frame rate according to which the bone animation is expected to be sampled. Broadcasts a EAnimDataModelNotifyType::FrameRateChanged notify if successful.
        The number of frames and keys for the provided frame rate is recalculated according to the current value of UAnimDataModel::PlayLength.
        
        Args:
            frame_rate (FrameRate): The new sampling frame rate, has to be positive and non-zero
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def set_curve_keys(self, curve_id: AnimationCurveIdentifier, curve_keys: Array[RichCurveKey], should_transact: bool = True) -> bool:
        r"""
        x.set_curve_keys(curve_id, curve_keys, should_transact=True) -> bool
        Replace the keys for the curve with provided identifier and name. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the keys are to be replaced
            curve_keys (Array[RichCurveKey]): Keys with which the existing keys are to be replaced
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not replacing curve keys was successful
        """
        ...
    def set_curve_key(self, curve_id: AnimationCurveIdentifier, key: RichCurveKey, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_key(curve_id, key, should_transact=True) -> bool
        Sets a single key for the curve with provided identifier and name. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        In case a key for the provided key time already exists the key is replaced.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the key is to be set
            key (RichCurveKey): Key to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve key was successfully set
        """
        ...
    def set_curve_flags(self, curve_id: AnimationCurveIdentifier, flags: int, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_flags(curve_id, flags, should_transact=True) -> bool
        Replace the flags for the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveFlagsChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the flag state is to be set
            flags (int32): Flag mask with which the existing flags are to be replaced
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the flag mask was successfully set
        """
        ...
    def set_curve_flag(self, curve_id: AnimationCurveIdentifier, flag: AnimAssetCurveFlags, state: bool = True, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_flag(curve_id, flag, state=True, should_transact=True) -> bool
        Set an individual flag for the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveFlagsChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the flag state is to be set
            flag (AnimAssetCurveFlags): Flag for which the state is supposed to be set
            state (bool): State of the flag to be, true=set/false=not set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the flag state was successfully set
        """
        ...
    def set_curve_comment(self, curve_id: AnimationCurveIdentifier, comment: str = "/**\n\t* Changes the comment of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveCommentChanged notify if successful.\n\t* Currently changing curve comments is only supported for float curves.\n\t*\n\t* @param\tCurveId\t\t\t\tIdentifier of the curve to change the comment for\n\t* @param\tComment\t\t\t\tComment to which the curve is to be set\n\t* @param\tbShouldTransact\t\tWhether or not any undo-redo changes should be generated\n\t*\n\t* @return\tWhether or not the curve comment was successfully changed\n\t*/", should_transact: bool = True) -> bool:
        r"""
        x.set_curve_comment(curve_id, comment="/**\n\t* Changes the comment of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveCommentChanged notify if successful.\n\t* Currently changing curve comments is only supported for float curves.\n\t*\n\t* @param\tCurveId\t\t\t\tIdentifier of the curve to change the comment for\n\t* @param\tComment\t\t\t\tComment to which the curve is to be set\n\t* @param\tbShouldTransact\t\tWhether or not any undo-redo changes should be generated\n\t*\n\t* @return\tWhether or not the curve comment was successfully changed\n\t*/", should_transact=True) -> bool
        Changes the comment of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveCommentChanged notify if successful.
        Currently changing curve comments is only supported for float curves.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier of the curve to change the comment for
            comment (str): Comment to which the curve is to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve comment was successfully changed
        """
        ...
    def set_curve_color(self, curve_id: AnimationCurveIdentifier, color: LinearColor, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_color(curve_id, color, should_transact=True) -> bool
        Changes the color of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveColorChanged notify if successful.
        Currently changing curve colors is only supported for float curves.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier of the curve to change the color for
            color (LinearColor): Color to which the curve is to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve color was successfully changed
        """
        ...
    def set_bone_track_keys(self, bone_name: Name, positional_keys: Array[Vector], rotational_keys: Array[Quat], scaling_keys: Array[Vector], should_transact: bool = True) -> bool:
        r"""
        x.set_bone_track_keys(bone_name, positional_keys, rotational_keys, scaling_keys, should_transact=True) -> bool
        Removes an existing bone animation track with the provided name. Broadcasts a EAnimDataModelNotifyType::TrackChanged notify if successful.
        The provided number of keys provided is expected to match for each component, and be non-zero.
        
        Args:
            bone_name (Name): Bone name of the track for which the keys should be set
            positional_keys (Array[Vector]): Array of keys for the translation component
            rotational_keys (Array[Quat]): Array of keys for the rotation component
            scaling_keys (Array[Vector]): Array of keys for the scale component
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the keys were successfully set
        """
        ...
    def scale_curve(self, curve_id: AnimationCurveIdentifier, origin: float, factor: float, should_transact: bool = True) -> bool:
        r"""
        x.scale_curve(curve_id, origin, factor, should_transact=True) -> bool
        Scales the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveScaled notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier of the curve to scale
            origin (float): Time to use as the origin when scaling the curve
            factor (float): Factor with which the curve is supposed to be scaled
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not scaling the curve was successful
        """
        ...
    def resize_play_length(self, new_length: float, t0: float, t1: float, should_transact: bool = True) -> None:
        r"""
        x.resize_play_length(new_length, t0, t1, should_transact=True) -> None
        Resize Play Length
        deprecated: ResizePlayLength is deprecated use ResizeNumberOfFrames instead.
        
        Args:
            new_length (float): 
            t0 (float): 
            t1 (float): 
            should_transact (bool):
        """
        ...
    def resize_number_of_frames(self, new_length_in_frames: FrameNumber, t0: FrameNumber, t1: FrameNumber, should_transact: bool = True) -> None:
        r"""
        x.resize_number_of_frames(new_length_in_frames, t0, t1, should_transact=True) -> None
        Sets the total play-able length in seconds. Broadcasts a EAnimDataModelNotifyType::SequenceLengthChanged notify if successful.
        T0 and T1 are expected to represent the window of time that was either added or removed. E.g. for insertion T0 indicates the time
        at which additional time starts and T1 were it ends. For removal T0 indicates the time at which time should be started to remove, and T1 indicates the end. Giving a total of T1 - T0 added or removed length.
        The number of frames and keys for the provided length is recalculated according to the current value of UAnimDataModel::FrameRate.
        
        Args:
            new_length_in_frames (FrameNumber): Total new play-able number of frames value (according to frame rate), has to be positive and non-zero
            t0 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length starts
            t1 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length ends
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def resize_in_frames(self, new_length_in_frames: FrameNumber, t0: FrameNumber, t1: FrameNumber, should_transact: bool = True) -> None:
        r"""
        x.resize_in_frames(new_length_in_frames, t0, t1, should_transact=True) -> None
        Sets the total play-able length in seconds and resizes curves. Broadcasts EAnimDataModelNotifyType::SequenceLengthChanged
        and EAnimDataModelNotifyType::CurveChanged notifies if successful.
        T0 and T1 are expected to represent the window of time that was either added or removed. E.g. for insertion T0 indicates the time
        at which additional time starts and T1 were it ends. For removal T0 indicates the time at which time should be started to remove, and T1 indicates the end. Giving a total of T1 - T0 added or removed length.
        The number of frames and keys for the provided length is recalculated according to the current value of UAnimDataModel::FrameRate.
        
        Args:
            new_length_in_frames (FrameNumber): Total new play-able number of frames value (according to frame rate), has to be positive and non-zero
            t0 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length starts
            t1 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length ends
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def resize(self, length: float, t0: float, t1: float, should_transact: bool = True) -> None:
        r"""
        x.resize(length, t0, t1, should_transact=True) -> None
        Resize
        deprecated: Resize is deprecated use ResizeInFrames instead.
        
        Args:
            length (float): 
            t0 (float): 
            t1 (float): 
            should_transact (bool):
        """
        ...
    def rename_curve(self, curve_to_rename_id: AnimationCurveIdentifier, new_curve_id: AnimationCurveIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.rename_curve(curve_to_rename_id, new_curve_id, should_transact=True) -> bool
        Renames the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveRenamed notify if successful.
        
        Args:
            curve_to_rename_id (AnimationCurveIdentifier): Identifier for the curve to be renamed
            new_curve_id (AnimationCurveIdentifier): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully renamed
        """
        ...
    def remove_transform_curve_key(self, curve_id: AnimationCurveIdentifier, time: float, should_transact: bool = True) -> bool:
        r"""
        x.remove_transform_curve_key(curve_id, time, should_transact=True) -> bool
        Removes a single key for the transform curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the transform curve for which the key is to be removed
            time (float): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the transform curve key was successfully removed
        """
        ...
    def remove_curve_key(self, curve_id: AnimationCurveIdentifier, time: float, should_transact: bool = True) -> bool:
        r"""
        x.remove_curve_key(curve_id, time, should_transact=True) -> bool
        Remove a single key from the curve with provided identifier and name. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the key is to be removed
            time (float): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve key was successfully removed
        """
        ...
    def remove_curve(self, curve_id: AnimationCurveIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.remove_curve(curve_id, should_transact=True) -> bool
        Remove the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveRemoved notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the to-be-removed curve
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully removed
        """
        ...
    def remove_bone_track(self, bone_name: Name, should_transact: bool = True) -> bool:
        r"""
        x.remove_bone_track(bone_name, should_transact=True) -> bool
        Removes an existing bone animation track with the provided name. Broadcasts a EAnimDataModelNotifyType::TrackRemoved notify if successful.
        
        Args:
            bone_name (Name): Bone name of the track which should be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the removal was successful
        """
        ...
    def remove_attribute_key(self, attribute_identifier: AnimationAttributeIdentifier, time: float, should_transact: bool = True) -> bool:
        r"""
        x.remove_attribute_key(attribute_identifier, time, should_transact=True) -> bool
        Remove a single key from the attribute with provided identifier. Broadcasts a EAnimDataModelNotifyType::AttributeChanged notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the attribute from which the key is to be removed
            time (float): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute key was successfully removed
        """
        ...
    def remove_attribute(self, attribute_identifier: AnimationAttributeIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.remove_attribute(attribute_identifier, should_transact=True) -> bool
        Removes an attribute, if found, with the provided information. Broadcasts a EAnimDataModelNotifyType::AttributeRemoved notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-removed attribute
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute was successfully removed
        """
        ...
    def remove_all_curves_of_type(self, supported_curve_type: RawCurveTrackTypes, should_transact: bool = True) -> None:
        r"""
        x.remove_all_curves_of_type(supported_curve_type, should_transact=True) -> None
        Removes all the curves of the provided type. Broadcasts a EAnimDataModelNotifyType::CurveRemoved for each removed curve, wrapped within BracketOpened/BracketClosed notifies.
        
        Args:
            supported_curve_type (RawCurveTrackTypes): Type for which all curves are to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def remove_all_bone_tracks(self, should_transact: bool = True) -> None:
        r"""
        x.remove_all_bone_tracks(should_transact=True) -> None
        Removes all existing Bone Animation tracks. Broadcasts a EAnimDataModelNotifyType::TrackRemoved for each removed track, wrapped within BracketOpened/BracketClosed notifies.
        
        Args:
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def remove_all_attributes_for_bone(self, bone_name: Name, should_transact: bool = True) -> int:
        r"""
        x.remove_all_attributes_for_bone(bone_name, should_transact=True) -> int32
        Removes all attributes for the specified bone name, if any. Broadcasts a EAnimDataModelNotifyType::AttributeRemoved notify for each removed attribute.
        
        Args:
            bone_name (Name): Name of the bone to remove attributes for
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            int32: Total number of removes attributes
        """
        ...
    def remove_all_attributes(self, should_transact: bool = True) -> int:
        r"""
        x.remove_all_attributes(should_transact=True) -> int32
        Removes all stored attributes. Broadcasts a EAnimDataModelNotifyType::AttributeRemoved notify for each removed attribute.
        
        Args:
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            int32: Total number of removes attributes
        """
        ...
    def open_bracket(self, title: Text, should_transact: bool = True) -> None:
        r"""
        x.open_bracket(title, should_transact=True) -> None
        Opens an interaction bracket, used for combining a set of controller actions. Broadcasts a EAnimDataModelNotifyType::BracketOpened notify,
        this can be used by any Views or dependent systems to halt any unnecessary or invalid operations until the (last) bracket is closed.
        
        Args:
            title (Text): Description of the bracket, e.g. "Generating Curve Data"
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def insert_bone_track(self, bone_name: Name, desired_index: int, should_transact: bool = True) -> int:
        r"""
        x.insert_bone_track(bone_name, desired_index, should_transact=True) -> int32
        Insert Bone Track
        deprecated: InsertBoneTrack is deprecated use AddBoneTrack instead.
        
        Args:
            bone_name (Name): 
            desired_index (int32): 
            should_transact (bool): 
        
        Returns:
            int32:
        """
        ...
    def get_model_interface(self) -> AnimationDataModel:
        r"""
        x.get_model_interface() -> AnimationDataModel
        
        
        Returns:
            AnimationDataModel: The IAnimationDataModel instance this controller is currently targeting
        """
        ...
    def find_or_add_curve_names_on_skeleton(self, skeleton: Skeleton, supported_curve_type: RawCurveTrackTypes, should_transact: bool = True) -> None:
        r"""
        x.find_or_add_curve_names_on_skeleton(skeleton, supported_curve_type, should_transact=True) -> None
        Find or Add Curve Names on Skeleton
        deprecated: This function is no longer used.
        
        Args:
            skeleton (Skeleton): 
            supported_curve_type (RawCurveTrackTypes): 
            should_transact (bool):
        """
        ...
    def duplicate_curve(self, copy_curve_id: AnimationCurveIdentifier, new_curve_id: AnimationCurveIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.duplicate_curve(copy_curve_id, new_curve_id, should_transact=True) -> bool
        Duplicated the curve with the identifier. Broadcasts a EAnimDataModelNotifyType::CurveAdded notify if successful.
        
        Args:
            copy_curve_id (AnimationCurveIdentifier): Identifier for the to-be-duplicated curve
            new_curve_id (AnimationCurveIdentifier): Identifier for the to-be-added curve
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully duplicated
        """
        ...
    def duplicate_attribute(self, attribute_identifier: AnimationAttributeIdentifier, new_attribute_identifier: AnimationAttributeIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.duplicate_attribute(attribute_identifier, new_attribute_identifier, should_transact=True) -> bool
        Duplicated the attribute (curve) with the identifier. Broadcasts a EAnimDataModelNotifyType::AttributeAdded notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-duplicated attribute
            new_attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-added attribute
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute was successfully duplicated
        """
        ...
    def close_bracket(self, should_transact: bool = True) -> None:
        r"""
        x.close_bracket(should_transact=True) -> None
        Closes a previously opened interaction bracket, used for combining a set of controller actions. Broadcasts a EAnimDataModelNotifyType::BracketClosed notify.
        
        Args:
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def add_curve(self, curve_id: AnimationCurveIdentifier, curve_flags: int = 4, should_transact: bool = True) -> bool:
        r"""
        x.add_curve(curve_id, curve_flags=4, should_transact=True) -> bool
        Adds a new curve with the provided information. Broadcasts a EAnimDataModelNotifyType::CurveAdded notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the to-be-added curve
            curve_flags (int32): Flags to be set for the curve
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully added
        """
        ...
    def add_bone_track(self, bone_name: Name, should_transact: bool = True) -> int:
        r"""
        x.add_bone_track(bone_name, should_transact=True) -> int32
        Add Bone Track
        deprecated: AddBoneTrack returning index is deprecated use AddBoneCurve returning bool instead.
        
        Args:
            bone_name (Name): 
            should_transact (bool): 
        
        Returns:
            int32:
        """
        ...
    def add_bone_curve(self, bone_name: Name, should_transact: bool = True) -> bool:
        r"""
        x.add_bone_curve(bone_name, should_transact=True) -> bool
        Add Bone Curve
        
        Args:
            bone_name (Name): 
            should_transact (bool): 
        
        Returns:
            bool:
        """
        ...
    def add_attribute(self, attribute_identifier: AnimationAttributeIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.add_attribute(attribute_identifier, should_transact=True) -> bool
        Adds a new attribute with the provided information. Broadcasts a EAnimDataModelNotifyType::AttributeAdded notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-added attribute
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute was successfully added
        """
        ...

class AnimationDataModel(Interface):
    r"""
    Animation Data Model
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: IAnimationDataModel.h
    
    """
    def is_valid_bone_track_name(self, track_name: Name) -> bool:
        r"""
        x.is_valid_bone_track_name(track_name) -> bool
        Is Valid Bone Track Name
        
        Args:
            track_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_valid_bone_track_index(self, track_index: int) -> bool:
        r"""
        x.is_valid_bone_track_index(track_index) -> bool
        Is Valid Bone Track Index
        
        Args:
            track_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_play_length(self) -> float:
        r"""
        x.get_play_length() -> double
        
        
        Returns:
            double: Total length of play-able animation data
        """
        ...
    def get_num_bone_tracks(self) -> int:
        r"""
        x.get_num_bone_tracks() -> int32
        
        
        Returns:
            int32: Total number of bone animation tracks
        """
        ...
    def get_number_of_transform_curves(self) -> int:
        r"""
        x.get_number_of_transform_curves() -> int32
        
        
        Returns:
            int32: Total number of stored FTransform curves
        """
        ...
    def get_number_of_keys(self) -> int:
        r"""
        x.get_number_of_keys() -> int32
        
        
        Returns:
            int32: Total number of animation data keys stored
        """
        ...
    def get_number_of_frames(self) -> int:
        r"""
        x.get_number_of_frames() -> int32
        
        
        Returns:
            int32: Total number of frames of animation data stored
        """
        ...
    def get_number_of_float_curves(self) -> int:
        r"""
        x.get_number_of_float_curves() -> int32
        
        
        Returns:
            int32: Total number of stored float curves
        """
        ...
    def get_frame_rate(self) -> FrameRate:
        r"""
        x.get_frame_rate() -> FrameRate
        
        
        Returns:
            FrameRate: Frame rate at which the animation data is key-ed
        """
        ...
    def get_bone_track_names(self) -> Array[Name]:
        r"""
        x.get_bone_track_names() -> Array[Name]
        Populates the provided array with all contained (bone) track names
        
        Returns:
            Array[Name]: 
        
            out_names (Array[Name]): [out] Array containing all bone track names
        """
        ...
    def get_bone_track_index_by_name(self, track_name: Name) -> int:
        r"""
        x.get_bone_track_index_by_name(track_name) -> int32
        Get Bone Track Index by Name
        
        Args:
            track_name (Name): 
        
        Returns:
            int32:
        """
        ...
    def get_bone_track_index(self, track: BoneAnimationTrack) -> int:
        r"""
        x.get_bone_track_index(track) -> int32
        Get Bone Track Index
        
        Args:
            track (BoneAnimationTrack): 
        
        Returns:
            int32:
        """
        ...
    def get_bone_track_by_name(self, track_name: Name) -> BoneAnimationTrack:
        r"""
        x.get_bone_track_by_name(track_name) -> BoneAnimationTrack
        Get Bone Track by Name
        
        Args:
            track_name (Name): 
        
        Returns:
            BoneAnimationTrack:
        """
        ...
    def get_bone_track_by_index(self, track_index: int) -> BoneAnimationTrack:
        r"""
        x.get_bone_track_by_index(track_index) -> BoneAnimationTrack
        Get Bone Track by Index
        
        Args:
            track_index (int32): 
        
        Returns:
            BoneAnimationTrack:
        """
        ...
    def get_bone_animation_tracks(self) -> Array[BoneAnimationTrack]:
        r"""
        x.get_bone_animation_tracks() -> Array[BoneAnimationTrack]
        Get Bone Animation Tracks
        
        Returns:
            Array[BoneAnimationTrack]:
        """
        ...
    def get_animation_sequence(self) -> AnimSequence:
        r"""
        x.get_animation_sequence() -> AnimSequence
        
        
        Returns:
            AnimSequence: The outer UAnimSequence object if found, otherwise returns a nullptr
        """
        ...

class Interface_AssetUserData(Interface):
    r"""
    Interface Asset User Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Interface_AssetUserData.h
    
    """
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class TextLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet Text Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetTextLibrary.h
    
    """
    @classmethod
    def text_trim_trailing(cls, text: Text) -> Text:
        r"""
        X.text_trim_trailing(text) -> Text
        Removes trailing whitespace characters.
        
        Args:
            text (Text): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def text_trim_preceding_and_trailing(cls, text: Text) -> Text:
        r"""
        X.text_trim_preceding_and_trailing(text) -> Text
        Removes whitespace characters from the front and end of the text.
        
        Args:
            text (Text): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def text_trim_preceding(cls, text: Text) -> Text:
        r"""
        X.text_trim_preceding(text) -> Text
        Removes whitespace characters from the front of the text.
        
        Args:
            text (Text): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def text_to_upper(cls, text: Text) -> Text:
        r"""
        X.text_to_upper(text) -> Text
        Transforms the text to uppercase in a culture correct way.
        note: The returned instance is linked to the original and will be rebuilt if the active culture is changed.
        
        Args:
            text (Text): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def text_to_lower(cls, text: Text) -> Text:
        r"""
        X.text_to_lower(text) -> Text
        Transforms the text to lowercase in a culture correct way.
        note: The returned instance is linked to the original and will be rebuilt if the active culture is changed.
        
        Args:
            text (Text): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def text_is_transient(cls, text: Text) -> bool:
        r"""
        X.text_is_transient(text) -> bool
        Returns true if text is transient.
        
        Args:
            text (Text): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def text_is_from_string_table(cls, text: Text) -> bool:
        r"""
        X.text_is_from_string_table(text) -> bool
        Returns true if the given text is referencing a string table.
        
        Args:
            text (Text): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def text_is_empty(cls, text: Text) -> bool:
        r"""
        X.text_is_empty(text) -> bool
        Returns true if text is empty.
        
        Args:
            text (Text): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def text_is_culture_invariant(cls, text: Text) -> bool:
        r"""
        X.text_is_culture_invariant(text) -> bool
        Returns true if text is culture invariant.
        
        Args:
            text (Text): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def text_from_string_table(cls, table_id: Name, key: str) -> Text:
        r"""
        X.text_from_string_table(table_id, key) -> Text
        Attempts to create a text instance from a string table ID and key.
        note: This exists to allow programmatic look-up of a string table entry from dynamic content - you should favor setting your string table reference on a text property or pin wherever possible as it is significantly more robust (see "Make Literal Text").
        
        Args:
            table_id (Name): 
            key (str): 
        
        Returns:
            Text: The found text, or a dummy text if the entry could not be found.
        """
        ...
    @classmethod
    def string_table_id_and_key_from_text(cls, text: Text) -> Optional[Tuple[Name, str]]:
        r"""
        X.string_table_id_and_key_from_text(text) -> (out_table_id=Name, out_key=str) or None
        Attempts to get the String Table ID and key used by the given text.
        
        Args:
            text (Text): 
        
        Returns:
            tuple or None: True if the String Table ID and key were found, false otherwise.
        
            out_table_id (Name): 
        
            out_key (str):
        """
        ...
    @classmethod
    def polyglot_data_to_text(cls, polyglot_data: PolyglotTextData) -> Text:
        r"""
        X.polyglot_data_to_text(polyglot_data) -> Text
        Get the text instance created from this polyglot data.
        
        Args:
            polyglot_data (PolyglotTextData): 
        
        Returns:
            Text: The text instance, or an empty text if the data is invalid.
        """
        ...
    @classmethod
    def not_equal_text_text(cls, a: Text, b: Text) -> bool:
        r"""
        X.not_equal_text_text(a, b) -> bool
        Returns true if A and B are linguistically not equal (A != B).
        
        Args:
            a (Text): 
            b (Text): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_ignore_case_text_text(cls, a: Text, b: Text) -> bool:
        r"""
        X.not_equal_ignore_case_text_text(a, b) -> bool
        Returns true if A and B are linguistically not equal (A != B), ignoring case.
        
        Args:
            a (Text): 
            b (Text): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def make_invariant_text(cls, string: str) -> Text:
        r"""
        X.make_invariant_text(string) -> Text
        Converts string to culture invariant text. Use 'Make Literal Text' to create localizable text, or 'Format' if concatenating localized text
        
        Args:
            string (str): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def is_polyglot_data_valid(cls, polyglot_data: PolyglotTextData) -> Tuple[bool, Text]:
        r"""
        X.is_polyglot_data_valid(polyglot_data) -> (is_valid=bool, error_message=Text)
        Check whether the given polyglot data is valid.
        
        Args:
            polyglot_data (PolyglotTextData): 
        
        Returns:
            tuple: 
        
            is_valid (bool): 
        
            error_message (Text):
        """
        ...
    @classmethod
    def get_text_source_string(cls, text: Text) -> str:
        r"""
        X.get_text_source_string(text) -> str
        Get the (non-localized) source string of the given text.
        note: For a generated text (eg, the result of a Format), this will deep build the source string as if the generation had run for the native language.
        
        Args:
            text (Text): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_text_id(cls, text: Text) -> Optional[Tuple[str, str]]:
        r"""
        X.get_text_id(text) -> (out_namespace=str, out_key=str) or None
        Attempts to get the ID (namespace and key) used by the given text.
        
        Args:
            text (Text): 
        
        Returns:
            tuple or None: True if the namespace (which may be empty) and key were found, false otherwise.
        
            out_namespace (str): 
        
            out_key (str):
        """
        ...
    @classmethod
    def get_empty_text(cls) -> Text:
        r"""
        X.get_empty_text() -> Text
        Returns an empty piece of text.
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def find_text_in_localization_table(cls, namespace: str, key: str, source_string: str = "") -> Optional[Text]:
        r"""
        X.find_text_in_localization_table(namespace, key, source_string="") -> Text or None
        Attempts to find existing Text using the representation found in the loc tables for the specified namespace and key.
        
        Args:
            namespace (str): The namespace of the text to find (if any).
            key (str): The key of the text to find.
            source_string (str): If set (not empty) then the found text must also have been created from this source string.
        
        Returns:
            Text or None: 
        
            out_text (Text):
        """
        ...
    @classmethod
    def equal_equal_text_text(cls, a: Text, b: Text) -> bool:
        r"""
        X.equal_equal_text_text(a, b) -> bool
        Returns true if A and B are linguistically equal (A == B).
        
        Args:
            a (Text): 
            b (Text): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_ignore_case_text_text(cls, a: Text, b: Text) -> bool:
        r"""
        X.equal_equal_ignore_case_text_text(a, b) -> bool
        Returns true if A and B are linguistically equal (A == B), ignoring case.
        
        Args:
            a (Text): 
            b (Text): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def conv_vector_to_text(cls, vec: Vector) -> Text:
        r"""
        X.conv_vector_to_text(vec) -> Text
        Converts a vector value to localized formatted text, in the form 'X= Y= Z='
        
        Args:
            vec (Vector): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_vector2d_to_text(cls, vec: Vector2D) -> Text:
        r"""
        X.conv_vector2d_to_text(vec) -> Text
        Converts a vector2d value to localized formatted text, in the form 'X= Y='
        
        Args:
            vec (Vector2D): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_transform_to_text(cls, trans: Transform) -> Text:
        r"""
        X.conv_transform_to_text(trans) -> Text
        Converts a transform value to localized formatted text, in the form 'Translation: X= Y= Z= Rotation: P= Y= R= Scale: X= Y= Z='
        
        Args:
            trans (Transform): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_text_to_string(cls, text: Text) -> str:
        r"""
        X.conv_text_to_string(text) -> str
        Converts localizable text to the string
        
        Args:
            text (Text): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_string_to_text(cls, string: str) -> Text:
        r"""
        X.conv_string_to_text(string) -> Text
        Converts string to culture invariant text. Use 'Make Literal Text' to create localizable text, or 'Format' if concatenating localized text
        
        Args:
            string (str): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_rotator_to_text(cls, rot: Rotator) -> Text:
        r"""
        X.conv_rotator_to_text(rot) -> Text
        Converts a rotator value to localized formatted text, in the form 'P= Y= R='
        
        Args:
            rot (Rotator): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_object_to_text(cls, obj: Object) -> Text:
        r"""
        X.conv_object_to_text(obj) -> Text
        Converts a UObject value to culture invariant text by calling the object's GetName method
        
        Args:
            obj (Object): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_name_to_text(cls, name: Name) -> Text:
        r"""
        X.conv_name_to_text(name) -> Text
        Converts Name to culture invariant text
        
        Args:
            name (Name): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_int_to_text(cls, value: int, always_sign: bool = False, use_grouping: bool = True, minimum_integral_digits: int = 1, maximum_integral_digits: int = 324) -> Text:
        r"""
        X.conv_int_to_text(value, always_sign=False, use_grouping=True, minimum_integral_digits=1, maximum_integral_digits=324) -> Text
        Converts a passed in integer to text based on formatting options
        
        Args:
            value (int32): 
            always_sign (bool): 
            use_grouping (bool): 
            minimum_integral_digits (int32): 
            maximum_integral_digits (int32): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_int64_to_text(cls, value: int, always_sign: bool = False, use_grouping: bool = True, minimum_integral_digits: int = 1, maximum_integral_digits: int = 324) -> Text:
        r"""
        X.conv_int64_to_text(value, always_sign=False, use_grouping=True, minimum_integral_digits=1, maximum_integral_digits=324) -> Text
        Converts a passed in integer to text based on formatting options
        
        Args:
            value (int64): 
            always_sign (bool): 
            use_grouping (bool): 
            minimum_integral_digits (int32): 
            maximum_integral_digits (int32): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_double_to_text(cls, value: float, rounding_mode: RoundingMode, always_sign: bool = False, use_grouping: bool = True, minimum_integral_digits: int = 1, maximum_integral_digits: int = 324, minimum_fractional_digits: int = 0, maximum_fractional_digits: int = 3) -> Text:
        r"""
        X.conv_double_to_text(value, rounding_mode, always_sign=False, use_grouping=True, minimum_integral_digits=1, maximum_integral_digits=324, minimum_fractional_digits=0, maximum_fractional_digits=3) -> Text
        Converts a passed in double to text based on formatting options
        
        Args:
            value (double): 
            rounding_mode (RoundingMode): 
            always_sign (bool): 
            use_grouping (bool): 
            minimum_integral_digits (int32): 
            maximum_integral_digits (int32): 
            minimum_fractional_digits (int32): 
            maximum_fractional_digits (int32): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_float_to_text(cls, value: float, rounding_mode: RoundingMode, always_sign: bool = False, use_grouping: bool = True, minimum_integral_digits: int = 1, maximum_integral_digits: int = 324, minimum_fractional_digits: int = 0, maximum_fractional_digits: int = 3) -> Text:
        r"""
        deprecated: 'conv_float_to_text' was renamed to 'conv_double_to_text'.
        """
        ...
    @classmethod
    def conv_color_to_text(cls, color: LinearColor) -> Text:
        r"""
        X.conv_color_to_text(color) -> Text
        Converts a linear color value to localized formatted text, in the form '(R=,G=,B=,A=)'
        
        Args:
            color (LinearColor): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_byte_to_text(cls, value: int) -> Text:
        r"""
        X.conv_byte_to_text(value) -> Text
        Converts a byte value to formatted text
        
        Args:
            value (uint8): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def conv_bool_to_text(cls, bool: bool) -> Text:
        r"""
        X.conv_bool_to_text(bool) -> Text
        Converts a boolean value to formatted text, either 'true' or 'false'
        
        Args:
            bool (bool): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def as_time_zone_time_date_time(cls, date_time: DateTime, time_zone: str = "") -> Text:
        r"""
        X.as_time_zone_time_date_time(date_time, time_zone="") -> Text
        Converts a passed in date & time to a text, formatted as a time using the given timezone (default is the local timezone). This will convert the given date & time from UTC to the given timezone (taking into account DST).
        
        Args:
            date_time (DateTime): 
            time_zone (str): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def as_time_zone_date_time_date_time(cls, date_time: DateTime, time_zone: str = "") -> Text:
        r"""
        X.as_time_zone_date_time_date_time(date_time, time_zone="") -> Text
        Converts a passed in date & time to a text, formatted as a date & time using the given timezone (default is the local timezone). This will convert the given date & time from UTC to the given timezone (taking into account DST).
        
        Args:
            date_time (DateTime): 
            time_zone (str): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def as_time_zone_date_date_time(cls, date_time: DateTime, time_zone: str = "") -> Text:
        r"""
        X.as_time_zone_date_date_time(date_time, time_zone="") -> Text
        Converts a passed in date & time to a text, formatted as a date using the given timezone (default is the local timezone). This will convert the given date & time from UTC to the given timezone (taking into account DST).
        
        Args:
            date_time (DateTime): 
            time_zone (str): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def as_timespan_timespan(cls, timespan: Timespan) -> Text:
        r"""
        X.as_timespan_timespan(timespan) -> Text
        Converts a passed in time span to a text, formatted as a time span
        
        Args:
            timespan (Timespan): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def as_time_date_time(cls, in_: DateTime) -> Text:
        r"""
        X.as_time_date_time(in_) -> Text
        Converts a passed in date & time to a text, formatted as a time using an invariant timezone. This will use the given date & time as-is, so it's assumed to already be in the correct timezone.
        
        Args:
            in_ (DateTime): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def as_percent_float(cls, value: float, rounding_mode: RoundingMode, always_sign: bool = False, use_grouping: bool = True, minimum_integral_digits: int = 1, maximum_integral_digits: int = 324, minimum_fractional_digits: int = 0, maximum_fractional_digits: int = 3) -> Text:
        r"""
        X.as_percent_float(value, rounding_mode, always_sign=False, use_grouping=True, minimum_integral_digits=1, maximum_integral_digits=324, minimum_fractional_digits=0, maximum_fractional_digits=3) -> Text
        Converts a passed in float to a text, formatted as a percent
        
        Args:
            value (float): 
            rounding_mode (RoundingMode): 
            always_sign (bool): 
            use_grouping (bool): 
            minimum_integral_digits (int32): 
            maximum_integral_digits (int32): 
            minimum_fractional_digits (int32): 
            maximum_fractional_digits (int32): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def as_date_time_date_time(cls, in_: DateTime) -> Text:
        r"""
        X.as_date_time_date_time(in_) -> Text
        Converts a passed in date & time to a text, formatted as a date & time using an invariant timezone. This will use the given date & time as-is, so it's assumed to already be in the correct timezone.
        
        Args:
            in_ (DateTime): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def as_date_date_time(cls, date_time: DateTime) -> Text:
        r"""
        X.as_date_date_time(date_time) -> Text
        Converts a passed in date & time to a text, formatted as a date using an invariant timezone. This will use the given date & time as-is, so it's assumed to already be in the correct timezone.
        
        Args:
            date_time (DateTime): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def as_currency_base(cls, base_value: int, currency_code: str) -> Text:
        r"""
        X.as_currency_base(base_value, currency_code) -> Text
        Generate an FText that represents the passed number as currency in the current culture.
        BaseVal is specified in the smallest fractional value of the currency and will be converted for formatting according to the selected culture.
        Keep in mind the CurrencyCode is completely independent of the culture it's displayed in (and they do not imply one another).
        For example: FText::AsCurrencyBase(650, TEXT("EUR")); would return an FText of "<EUR>6.50" in most English cultures (en_US/en_UK) and "6,50<EUR>" in Spanish (es_ES) (where <EUR> is U+20AC)
        
        Args:
            base_value (int32): 
            currency_code (str): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def as_currency_integer(cls, value: int, rounding_mode: RoundingMode, always_sign: bool = False, use_grouping: bool = True, minimum_integral_digits: int = 1, maximum_integral_digits: int = 324, minimum_fractional_digits: int = 0, maximum_fractional_digits: int = 3, currency_code: str = "") -> Text:
        r"""
        X.as_currency_integer(value, rounding_mode, always_sign=False, use_grouping=True, minimum_integral_digits=1, maximum_integral_digits=324, minimum_fractional_digits=0, maximum_fractional_digits=3, currency_code="") -> Text
        Converts a passed in integer to a text formatted as a currency
        
        Args:
            value (int32): 
            rounding_mode (RoundingMode): 
            always_sign (bool): 
            use_grouping (bool): 
            minimum_integral_digits (int32): 
            maximum_integral_digits (int32): 
            minimum_fractional_digits (int32): 
            maximum_fractional_digits (int32): 
            currency_code (str): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def as_currency_float(cls, value: float, rounding_mode: RoundingMode, always_sign: bool = False, use_grouping: bool = True, minimum_integral_digits: int = 1, maximum_integral_digits: int = 324, minimum_fractional_digits: int = 0, maximum_fractional_digits: int = 3, currency_code: str = "") -> Text:
        r"""
        X.as_currency_float(value, rounding_mode, always_sign=False, use_grouping=True, minimum_integral_digits=1, maximum_integral_digits=324, minimum_fractional_digits=0, maximum_fractional_digits=3, currency_code="") -> Text
        Converts a passed in float to a text formatted as a currency
        
        Args:
            value (float): 
            rounding_mode (RoundingMode): 
            always_sign (bool): 
            use_grouping (bool): 
            minimum_integral_digits (int32): 
            maximum_integral_digits (int32): 
            minimum_fractional_digits (int32): 
            maximum_fractional_digits (int32): 
            currency_code (str): 
        
        Returns:
            Text:
        """
        ...

class LevelStreaming(Object):
    r"""
    Abstract base class of container object encapsulating data required for streaming and providing
    interface for when a level should be streamed in and out of memory.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelStreaming.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disable_distance_streaming`` (bool):  [Read-Write] Whether this level streaming object should be ignored by world composition distance streaming,
      so streaming state can be controlled by other systems (ex: in blueprints)
    - ``draw_on_level_status_map`` (bool):  [Read-Write] If true, will be drawn on the 'level streaming status' map (STAT LEVELMAP console command)
    - ``editor_streaming_volumes`` (Array[LevelStreamingVolume]):  [Read-Write] The level streaming volumes bound to this level.
    - ``is_static`` (bool):  [Read-Write] Whether this level only contains static actors that aren't affected by gameplay or replication.
      If true, the engine can make certain optimizations and will add this level to the StaticLevels collection.
    - ``level_color`` (LinearColor):  [Read-Write] The level color used for visualization. (Show -> Advanced -> Level Coloration)
    - ``level_lod_index`` (int32):  [Read-Write] Requested LOD. Non LOD sub-levels have Index = -1
    - ``level_transform`` (Transform):  [Read-Write] Transform applied to actors after loading.
    - ``min_time_between_volume_unload_requests`` (float):  [Read-Write] Cooldown time in seconds between volume-based unload requests.  Used in preventing spurious unload requests.
    - ``on_level_hidden`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is no longer visible, may not be removed from world yet
    - ``on_level_loaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed in
    - ``on_level_shown`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is added to the world and is visible
    - ``on_level_unloaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed out
    - ``should_be_loaded`` (bool):  [Read-Write] Whether the level should be loaded
    - ``should_be_visible`` (bool):  [Read-Write] Whether the level should be visible if it is loaded
    - ``should_block_on_load`` (bool):  [Read-Write] Whether we want to force a blocking load
    - ``should_block_on_unload`` (bool):  [Read-Write] Whether we want to force a blocking unload
    - ``streaming_priority`` (int32):  [Read-Write] The relative priority of considering the streaming level. Changing the priority will not interrupt the currently considered level, but will affect the next time a level is being selected for evaluation.
    - ``world_asset`` (World):  [Read-Only] The reference to the world containing the level to load
    """
    @property
    def world_asset(self) -> World:
        r"""
        (World):  [Read-Only] The reference to the world containing the level to load
        """
        ...
    @property
    def streaming_priority(self) -> int:
        r"""
        (int32):  [Read-Write] The relative priority of considering the streaming level. Changing the priority will not interrupt the currently considered level, but will affect the next time a level is being selected for evaluation.
        """
        ...
    @streaming_priority.setter
    def streaming_priority(self, value: int) -> None:
        ...
    @property
    def level_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] Transform applied to actors after loading.
        """
        ...
    @level_transform.setter
    def level_transform(self, value: Transform) -> None:
        ...
    @property
    def level_lod_index(self) -> int:
        r"""
        (int32):  [Read-Write] Requested LOD. Non LOD sub-levels have Index = -1
        """
        ...
    @level_lod_index.setter
    def level_lod_index(self, value: int) -> None:
        ...
    @property
    def should_be_visible(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the level should be visible if it is loaded
        """
        ...
    @should_be_visible.setter
    def should_be_visible(self, value: bool) -> None:
        ...
    @property
    def should_be_loaded(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the level should be loaded
        """
        ...
    @should_be_loaded.setter
    def should_be_loaded(self, value: bool) -> None:
        ...
    @property
    def should_block_on_load(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we want to force a blocking load
        """
        ...
    @should_block_on_load.setter
    def should_block_on_load(self, value: bool) -> None:
        ...
    @property
    def should_block_on_unload(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we want to force a blocking unload
        """
        ...
    @should_block_on_unload.setter
    def should_block_on_unload(self, value: bool) -> None:
        ...
    @property
    def disable_distance_streaming(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this level streaming object should be ignored by world composition distance streaming,
        so streaming state can be controlled by other systems (ex: in blueprints)
        """
        ...
    @disable_distance_streaming.setter
    def disable_distance_streaming(self, value: bool) -> None:
        ...
    @property
    def on_level_loaded(self) -> LevelStreamingLoadedStatus:
        r"""
        (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed in
        """
        ...
    @on_level_loaded.setter
    def on_level_loaded(self, value: LevelStreamingLoadedStatus) -> None:
        ...
    @property
    def on_level_unloaded(self) -> LevelStreamingLoadedStatus:
        r"""
        (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed out
        """
        ...
    @on_level_unloaded.setter
    def on_level_unloaded(self, value: LevelStreamingLoadedStatus) -> None:
        ...
    @property
    def on_level_shown(self) -> LevelStreamingVisibilityStatus:
        r"""
        (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is added to the world and is visible
        """
        ...
    @on_level_shown.setter
    def on_level_shown(self, value: LevelStreamingVisibilityStatus) -> None:
        ...
    @property
    def on_level_hidden(self) -> LevelStreamingVisibilityStatus:
        r"""
        (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is no longer visible, may not be removed from world yet
        """
        ...
    @on_level_hidden.setter
    def on_level_hidden(self, value: LevelStreamingVisibilityStatus) -> None:
        ...
    def set_is_requesting_unload_and_removal(self, is_requesting_unload_and_removal: bool) -> None:
        r"""
        x.set_is_requesting_unload_and_removal(is_requesting_unload_and_removal) -> None
        Sets if the streaming level should be unloaded and removed.
        
        Args:
            is_requesting_unload_and_removal (bool):
        """
        ...
    def is_streaming_state_pending(self) -> bool:
        r"""
        x.is_streaming_state_pending() -> bool
        Returns whether level has streaming state change pending
        
        Returns:
            bool:
        """
        ...
    def is_level_visible(self) -> bool:
        r"""
        x.is_level_visible() -> bool
        Returns whether streaming level is visible
        
        Returns:
            bool:
        """
        ...
    def is_level_loaded(self) -> bool:
        r"""
        x.is_level_loaded() -> bool
        Returns whether streaming level is loaded
        
        Returns:
            bool:
        """
        ...
    def get_world_asset_package_f_name(self) -> Name:
        r"""
        x.get_world_asset_package_f_name() -> Name
        Gets the package name for the world asset referred to by this level streaming as an FName
        
        Returns:
            Name:
        """
        ...
    def get_loaded_level(self) -> Level:
        r"""
        x.get_loaded_level() -> Level
        Gets a pointer to the LoadedLevel value
        
        Returns:
            Level:
        """
        ...
    def get_is_requesting_unload_and_removal(self) -> bool:
        r"""
        x.get_is_requesting_unload_and_removal() -> bool
        Returns if the streaming level has requested to be unloaded and removed.
        
        Returns:
            bool:
        """
        ...
    def create_instance(self, unique_instance_name: str) -> LevelStreaming:
        r"""
        x.create_instance(unique_instance_name) -> LevelStreaming
        Creates a new instance of this streaming level with a provided unique instance name
        
        Args:
            unique_instance_name (str): 
        
        Returns:
            LevelStreaming:
        """
        ...

class LevelStreamingAlwaysLoaded(LevelStreaming):
    r"""
    Level Streaming Always Loaded
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelStreamingAlwaysLoaded.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disable_distance_streaming`` (bool):  [Read-Write] Whether this level streaming object should be ignored by world composition distance streaming,
      so streaming state can be controlled by other systems (ex: in blueprints)
    - ``draw_on_level_status_map`` (bool):  [Read-Write] If true, will be drawn on the 'level streaming status' map (STAT LEVELMAP console command)
    - ``editor_streaming_volumes`` (Array[LevelStreamingVolume]):  [Read-Write] The level streaming volumes bound to this level.
    - ``is_static`` (bool):  [Read-Write] Whether this level only contains static actors that aren't affected by gameplay or replication.
      If true, the engine can make certain optimizations and will add this level to the StaticLevels collection.
    - ``level_color`` (LinearColor):  [Read-Write] The level color used for visualization. (Show -> Advanced -> Level Coloration)
    - ``level_lod_index`` (int32):  [Read-Write] Requested LOD. Non LOD sub-levels have Index = -1
    - ``level_transform`` (Transform):  [Read-Write] Transform applied to actors after loading.
    - ``min_time_between_volume_unload_requests`` (float):  [Read-Write] Cooldown time in seconds between volume-based unload requests.  Used in preventing spurious unload requests.
    - ``on_level_hidden`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is no longer visible, may not be removed from world yet
    - ``on_level_loaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed in
    - ``on_level_shown`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is added to the world and is visible
    - ``on_level_unloaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed out
    - ``should_be_loaded`` (bool):  [Read-Write] Whether the level should be loaded
    - ``should_be_visible`` (bool):  [Read-Write] Whether the level should be visible if it is loaded
    - ``should_block_on_load`` (bool):  [Read-Write] Whether we want to force a blocking load
    - ``should_block_on_unload`` (bool):  [Read-Write] Whether we want to force a blocking unload
    - ``streaming_priority`` (int32):  [Read-Write] The relative priority of considering the streaming level. Changing the priority will not interrupt the currently considered level, but will affect the next time a level is being selected for evaluation.
    - ``world_asset`` (World):  [Read-Only] The reference to the world containing the level to load
    """
    ...

class LevelStreamingDynamic(LevelStreaming):
    r"""
    Level Streaming Dynamic
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelStreamingDynamic.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disable_distance_streaming`` (bool):  [Read-Write] Whether this level streaming object should be ignored by world composition distance streaming,
      so streaming state can be controlled by other systems (ex: in blueprints)
    - ``draw_on_level_status_map`` (bool):  [Read-Write] If true, will be drawn on the 'level streaming status' map (STAT LEVELMAP console command)
    - ``editor_streaming_volumes`` (Array[LevelStreamingVolume]):  [Read-Write] The level streaming volumes bound to this level.
    - ``initially_loaded`` (bool):  [Read-Write] Whether the level should be loaded at startup
    - ``initially_visible`` (bool):  [Read-Write] Whether the level should be visible at startup if it is loaded
    - ``is_static`` (bool):  [Read-Write] Whether this level only contains static actors that aren't affected by gameplay or replication.
      If true, the engine can make certain optimizations and will add this level to the StaticLevels collection.
    - ``level_color`` (LinearColor):  [Read-Write] The level color used for visualization. (Show -> Advanced -> Level Coloration)
    - ``level_lod_index`` (int32):  [Read-Write] Requested LOD. Non LOD sub-levels have Index = -1
    - ``level_transform`` (Transform):  [Read-Write] Transform applied to actors after loading.
    - ``min_time_between_volume_unload_requests`` (float):  [Read-Write] Cooldown time in seconds between volume-based unload requests.  Used in preventing spurious unload requests.
    - ``on_level_hidden`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is no longer visible, may not be removed from world yet
    - ``on_level_loaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed in
    - ``on_level_shown`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is added to the world and is visible
    - ``on_level_unloaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed out
    - ``should_be_loaded`` (bool):  [Read-Write] Whether the level should be loaded
    - ``should_be_visible`` (bool):  [Read-Write] Whether the level should be visible if it is loaded
    - ``should_block_on_load`` (bool):  [Read-Write] Whether we want to force a blocking load
    - ``should_block_on_unload`` (bool):  [Read-Write] Whether we want to force a blocking unload
    - ``streaming_priority`` (int32):  [Read-Write] The relative priority of considering the streaming level. Changing the priority will not interrupt the currently considered level, but will affect the next time a level is being selected for evaluation.
    - ``world_asset`` (World):  [Read-Only] The reference to the world containing the level to load
    """
    @classmethod
    def load_level_instance_by_soft_object_ptr(cls, world_context_object: Object, level: World, location: Vector, rotation: Rotator, optional_level_name_override: str = "", optional_level_streaming_class: Class = None, load_as_temp_package: bool = False) -> Tuple[LevelStreamingDynamic, bool]:
        r"""
        X.load_level_instance_by_soft_object_ptr(world_context_object, level, location, rotation, optional_level_name_override="", optional_level_streaming_class=None, load_as_temp_package=False) -> (LevelStreamingDynamic, out_success=bool)
        Load Level Instance by Soft Object Ptr
        
        Args:
            world_context_object (Object): 
            level (World): 
            location (Vector): 
            rotation (Rotator): 
            optional_level_name_override (str): 
            optional_level_streaming_class (type(Class)): 
            load_as_temp_package (bool): 
        
        Returns:
            bool: 
        
            out_success (bool):
        """
        ...
    @classmethod
    def load_level_instance(cls, world_context_object: Object, level_name: str, location: Vector, rotation: Rotator, optional_level_name_override: str = "", optional_level_streaming_class: Class = None, load_as_temp_package: bool = False) -> Tuple[LevelStreamingDynamic, bool]:
        r"""
        X.load_level_instance(world_context_object, level_name, location, rotation, optional_level_name_override="", optional_level_streaming_class=None, load_as_temp_package=False) -> (LevelStreamingDynamic, out_success=bool)
        Stream in a level with a specific location and rotation. You can create multiple instances of the same level!
        
        The level to be loaded does not have to be in the persistent map's Levels list, however to ensure that the .umap does get
        packaged, please be sure to include the .umap in your Packaging Settings:
        
          Project Settings -> Packaging -> List of Maps to Include in a Packaged Build (you may have to show advanced or type in filter)
        
        Args:
            world_context_object (Object): 
            level_name (str): Level package name to load, ex: /Game/Maps/MyMapName, specifying short name like MyMapName will force very slow search on disk
            location (Vector): World space location where the level should be spawned
            rotation (Rotator): World space rotation for rotating the entire level
            optional_level_name_override (str): If set, the loaded level package have this name, which is used by other functions like UnloadStreamLevel. Note this is necessary for server and client networking because the level must have the same name on both.
            optional_level_streaming_class (type(Class)): If set, the level streaming class will be used instead of ULevelStreamingDynamic
            load_as_temp_package (bool): If set, package path is prefixed by /Temp
        
        Returns:
            bool: Streaming level object for a level instance
        
            out_success (bool): Whether operation was successful (map was found and added to the sub-levels list)
        """
        ...

class LevelStreamingKismet(LevelStreamingDynamic):
    r"""
    deprecated: 'LevelStreamingKismet' was renamed to 'LevelStreamingDynamic'.
    """
    ...

class LevelStreamingPersistent(LevelStreaming):
    r"""
    Level Streaming Persistent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelStreamingPersistent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disable_distance_streaming`` (bool):  [Read-Write] Whether this level streaming object should be ignored by world composition distance streaming,
      so streaming state can be controlled by other systems (ex: in blueprints)
    - ``draw_on_level_status_map`` (bool):  [Read-Write] If true, will be drawn on the 'level streaming status' map (STAT LEVELMAP console command)
    - ``editor_streaming_volumes`` (Array[LevelStreamingVolume]):  [Read-Write] The level streaming volumes bound to this level.
    - ``is_static`` (bool):  [Read-Write] Whether this level only contains static actors that aren't affected by gameplay or replication.
      If true, the engine can make certain optimizations and will add this level to the StaticLevels collection.
    - ``level_color`` (LinearColor):  [Read-Write] The level color used for visualization. (Show -> Advanced -> Level Coloration)
    - ``level_lod_index`` (int32):  [Read-Write] Requested LOD. Non LOD sub-levels have Index = -1
    - ``level_transform`` (Transform):  [Read-Write] Transform applied to actors after loading.
    - ``min_time_between_volume_unload_requests`` (float):  [Read-Write] Cooldown time in seconds between volume-based unload requests.  Used in preventing spurious unload requests.
    - ``on_level_hidden`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is no longer visible, may not be removed from world yet
    - ``on_level_loaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed in
    - ``on_level_shown`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is added to the world and is visible
    - ``on_level_unloaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed out
    - ``should_be_loaded`` (bool):  [Read-Write] Whether the level should be loaded
    - ``should_be_visible`` (bool):  [Read-Write] Whether the level should be visible if it is loaded
    - ``should_block_on_load`` (bool):  [Read-Write] Whether we want to force a blocking load
    - ``should_block_on_unload`` (bool):  [Read-Write] Whether we want to force a blocking unload
    - ``streaming_priority`` (int32):  [Read-Write] The relative priority of considering the streaming level. Changing the priority will not interrupt the currently considered level, but will affect the next time a level is being selected for evaluation.
    - ``world_asset`` (World):  [Read-Only] The reference to the world containing the level to load
    """
    ...

class LevelStreamingVolume(Volume):
    r"""
    Level Streaming Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelStreamingVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``disabled`` (bool):  [Read-Write] If true, this streaming volume is ignored by the streaming volume code.  Used to either
      disable a level streaming volume without disassociating it from the level, or to toggle
      the control of a level's streaming between Kismet and volume streaming.
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``editor_pre_vis_only`` (bool):  [Read-Write] If true, this streaming volume should only be used for editor streaming level previs.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``streaming_level_names`` (Array[Name]):  [Read-Only] Levels names affected by this level streaming volume.
    - ``streaming_usage`` (StreamingVolumeUsage):  [Read-Write] Determines what this volume is used for, e.g. whether to control loading, loading and visibility or just visibilty (blocking on load)
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def streaming_level_names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Only] Levels names affected by this level streaming volume.
        """
        ...
    @property
    def editor_pre_vis_only(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this streaming volume should only be used for editor streaming level previs.
        """
        ...
    @editor_pre_vis_only.setter
    def editor_pre_vis_only(self, value: bool) -> None:
        ...
    @property
    def disabled(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this streaming volume is ignored by the streaming volume code.  Used to either
        disable a level streaming volume without disassociating it from the level, or to toggle
        the control of a level's streaming between Kismet and volume streaming.
        """
        ...
    @disabled.setter
    def disabled(self, value: bool) -> None:
        ...
    @property
    def streaming_usage(self) -> StreamingVolumeUsage:
        r"""
        (StreamingVolumeUsage):  [Read-Write] Determines what this volume is used for, e.g. whether to control loading, loading and visibility or just visibilty (blocking on load)
        """
        ...
    @streaming_usage.setter
    def streaming_usage(self, value: StreamingVolumeUsage) -> None:
        ...

class LightComponentBase(SceneComponent):
    r"""
    Light Component Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightComponentBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_global_illumination`` (bool):  [Read-Write] Whether the light affects global illumination, when ray-traced global illumination is enabled.
    - ``affect_reflection`` (bool):  [Read-Write] Whether the light affects objects in reflections, when ray-traced reflection is enabled.
    - ``affect_translucent_lighting`` (bool):  [Read-Write] Whether the light affects translucency or not.  Disabling this can save GPU time when there are many small lights.
    - ``affects_world`` (bool):  [Read-Write] Whether the light can affect the world, or whether it is disabled.
      A disabled light will not contribute to the scene in any way.  This setting cannot be changed at runtime and unbuilds lighting when changed.
      Setting this to false has the same effect as deleting the light, so it is useful for non-destructive experiments.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_deep_shadow`` (bool):  [Read-Write] Whether the light should cast high quality hair-strands self-shadowing. When this option is enabled, an extra GPU cost for this light.
    - ``cast_dynamic_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from dynamic objects.  Also requires Cast Shadows to be set to True.
    - ``cast_raytraced_shadow`` (CastRayTracedShadow):  [Read-Write]
    - ``cast_shadows`` (bool):  [Read-Write] Whether the light should cast any shadows.
    - ``cast_static_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from static objects.  Also requires Cast Shadows to be set to True.
    - ``cast_volumetric_shadow`` (bool):  [Read-Write] Whether the light shadows volumetric fog.  Disabling this can save GPU time.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``deep_shadow_layer_distribution`` (float):  [Read-Write] Change the deep shadow layers distribution 0:linear distribution (uniform layer distribution), 1:exponential (more details on near small details).
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``indirect_lighting_intensity`` (float):  [Read-Write] Scales the indirect lighting contribution from this light.
      A value of 0 disables any GI from this light. Default is 1.
    - ``intensity`` (float):  [Read-Write] Total energy that the light emits.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``light_color`` (Color):  [Read-Write] Filter color of the light.
      Note that this can change the light's effective intensity.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``samples_per_pixel`` (int32):  [Read-Write] Samples per pixel for ray tracing
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``transmission`` (bool):  [Read-Write] Whether light from this light transmits through surfaces with subsurface scattering profiles. Requires light to be movable.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volumetric_scattering_intensity`` (float):  [Read-Write] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
    """
    @property
    def intensity(self) -> float:
        r"""
        (float):  [Read-Only] Total energy that the light emits.
        """
        ...
    @property
    def brightness(self) -> float:
        r"""
        deprecated: 'brightness' was renamed to 'intensity'.
        """
        ...
    @property
    def light_color(self) -> Color:
        r"""
        (Color):  [Read-Only] Filter color of the light.
        Note that this can change the light's effective intensity.
        """
        ...
    @property
    def affects_world(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light can affect the world, or whether it is disabled.
        A disabled light will not contribute to the scene in any way.  This setting cannot be changed at runtime and unbuilds lighting when changed.
        Setting this to false has the same effect as deleting the light, so it is useful for non-destructive experiments.
        """
        ...
    @property
    def cast_shadows(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light should cast any shadows.
        """
        ...
    @property
    def cast_static_shadows(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light should cast shadows from static objects.  Also requires Cast Shadows to be set to True.
        """
        ...
    @property
    def cast_dynamic_shadows(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light should cast shadows from dynamic objects.  Also requires Cast Shadows to be set to True.
        """
        ...
    @property
    def affect_translucent_lighting(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light affects translucency or not.  Disabling this can save GPU time when there are many small lights.
        """
        ...
    @property
    def transmission(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether light from this light transmits through surfaces with subsurface scattering profiles. Requires light to be movable.
        """
        ...
    @property
    def cast_volumetric_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light shadows volumetric fog.  Disabling this can save GPU time.
        """
        ...
    @property
    def cast_deep_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light should cast high quality hair-strands self-shadowing. When this option is enabled, an extra GPU cost for this light.
        """
        ...
    @property
    def cast_raytraced_shadow(self) -> CastRayTracedShadow:
        r"""
        (CastRayTracedShadow):  [Read-Only]
        """
        ...
    @property
    def affect_reflection(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light affects objects in reflections, when ray-traced reflection is enabled.
        """
        ...
    @property
    def affect_global_illumination(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light affects global illumination, when ray-traced global illumination is enabled.
        """
        ...
    @property
    def deep_shadow_layer_distribution(self) -> float:
        r"""
        (float):  [Read-Only] Change the deep shadow layers distribution 0:linear distribution (uniform layer distribution), 1:exponential (more details on near small details).
        """
        ...
    @property
    def indirect_lighting_intensity(self) -> float:
        r"""
        (float):  [Read-Only] Scales the indirect lighting contribution from this light.
        A value of 0 disables any GI from this light. Default is 1.
        """
        ...
    @property
    def volumetric_scattering_intensity(self) -> float:
        r"""
        (float):  [Read-Only] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
        """
        ...
    @property
    def samples_per_pixel(self) -> int:
        r"""
        (int32):  [Read-Only] Samples per pixel for ray tracing
        """
        ...
    def set_samples_per_pixel(self, new_value: int) -> None:
        r"""
        x.set_samples_per_pixel(new_value) -> None
        Set Samples Per Pixel
        
        Args:
            new_value (int32):
        """
        ...
    def set_cast_volumetric_shadow(self, new_value: bool) -> None:
        r"""
        x.set_cast_volumetric_shadow(new_value) -> None
        Set Cast Volumetric Shadow
        
        Args:
            new_value (bool):
        """
        ...
    def set_cast_shadows(self, new_value: bool) -> None:
        r"""
        x.set_cast_shadows(new_value) -> None
        Sets whether this light casts shadows
        
        Args:
            new_value (bool):
        """
        ...
    def set_cast_raytraced_shadows(self, new_value: CastRayTracedShadow) -> None:
        r"""
        x.set_cast_raytraced_shadows(new_value) -> None
        Set Cast Raytraced Shadows
        
        Args:
            new_value (CastRayTracedShadow):
        """
        ...
    def set_cast_raytraced_shadow(self, new_value: bool) -> None:
        r"""
        x.set_cast_raytraced_shadow(new_value) -> None
        Set Cast Raytraced Shadow
        deprecated: ULightComponentBase::SetCastRaytracedShadow is deprecated. Use ULightComponentBase::SetCastRaytracedShadows instead.
        
        Args:
            new_value (bool):
        """
        ...
    def set_cast_deep_shadow(self, new_value: bool) -> None:
        r"""
        x.set_cast_deep_shadow(new_value) -> None
        Set Cast Deep Shadow
        
        Args:
            new_value (bool):
        """
        ...
    def set_affect_reflection(self, new_value: bool) -> None:
        r"""
        x.set_affect_reflection(new_value) -> None
        Set Affect Reflection
        
        Args:
            new_value (bool):
        """
        ...
    def set_affect_global_illumination(self, new_value: bool) -> None:
        r"""
        x.set_affect_global_illumination(new_value) -> None
        Set Affect Global Illumination
        
        Args:
            new_value (bool):
        """
        ...
    def get_light_color(self) -> LinearColor:
        r"""
        x.get_light_color() -> LinearColor
        Gets the light color as a linear color
        
        Returns:
            LinearColor:
        """
        ...

class Texture2D(Texture):
    r"""
    Texture 2D
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Texture2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    @property
    def address_x(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
        """
        ...
    @address_x.setter
    def address_x(self, value: TextureAddress) -> None:
        ...
    @property
    def address_y(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
        """
        ...
    @address_y.setter
    def address_y(self, value: TextureAddress) -> None:
        ...
    def blueprint_get_size_y(self) -> int:
        r"""
        x.blueprint_get_size_y() -> int32
        Gets the Y size of the texture, in pixels
        
        Returns:
            int32:
        """
        ...
    def blueprint_get_size_x(self) -> int:
        r"""
        x.blueprint_get_size_x() -> int32
        Gets the X size of the texture, in pixels
        
        Returns:
            int32:
        """
        ...
    def blueprint_get_cpu_copy(self) -> SharedImageConstRefBlueprint:
        r"""
        x.blueprint_get_cpu_copy() -> SharedImageConstRefBlueprint
        Blueprint Get CPUCopy
        
        Returns:
            SharedImageConstRefBlueprint:
        """
        ...

class LightMapTexture2D(Texture2D):
    r"""
    Light Map Texture 2D
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightMapTexture2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    ...

class LightmassPortal(Actor):
    r"""
    Lightmass Portal
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightmassPortal.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``portal_component`` (LightmassPortalComponent):  [Read-Only]
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def portal_component(self) -> LightmassPortalComponent:
        r"""
        (LightmassPortalComponent):  [Read-Only]
        """
        ...

class LightmassPortalComponent(SceneComponent):
    r"""
    Lightmass Portal Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightmassPortalComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class LocalFogVolume(Info):
    r"""
    Actor used to position a local fog volume in the scene.
    see: https://docs.unrealengine.com/???
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LocalFogVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``local_fog_volume_volume`` (LocalFogVolumeComponent):  [Read-Only] Object used to visualize the local fog volume
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def local_fog_volume_volume(self) -> LocalFogVolumeComponent:
        r"""
        (LocalFogVolumeComponent):  [Read-Only] Object used to visualize the local fog volume
        """
        ...

class MaterialExpressionAbs(MaterialExpression):
    r"""
    Material Expression Abs
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionAbs.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionAbsorptionMediumMaterialOutput(MaterialExpressionCustomOutput):
    r"""
    Material output expression for setting absorption properties of solid refractive glass (for the Path Tracer Only).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionAbsorptionMediumMaterialOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionActorPositionWS(MaterialExpression):
    r"""
    Material Expression Actor Position WS
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionActorPositionWS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``origin_type`` (PositionOrigin):  [Read-Write]
    """
    ...

class MaterialExpressionAdd(MaterialExpression):
    r"""
    Material Expression Add
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionAdd.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_a`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_b`` (float):  [Read-Write] only used if B is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionTextureBase(MaterialExpression):
    r"""
    Material Expression Texture Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``texture`` (Texture):  [Read-Write]
    """
    @property
    def texture(self) -> Texture:
        r"""
        (Texture):  [Read-Write]
        """
        ...
    @texture.setter
    def texture(self, value: Texture) -> None:
        ...
    @property
    def sampler_type(self) -> MaterialSamplerType:
        r"""
        (MaterialSamplerType):  [Read-Write]
        """
        ...
    @sampler_type.setter
    def sampler_type(self, value: MaterialSamplerType) -> None:
        ...

class MaterialExpressionTextureSample(MaterialExpressionTextureBase):
    r"""
    Material Expression Texture Sample
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureSample.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionTextureSampleParameter(MaterialExpressionTextureSample):
    r"""
    Material Expression Texture Sample Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureSampleParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``parameter_name`` (Name):  [Read-Write]
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionTextureSampleParameter2D(MaterialExpressionTextureSampleParameter):
    r"""
    Material Expression Texture Sample Parameter 2D
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureSampleParameter2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``parameter_name`` (Name):  [Read-Write]
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionAntialiasedTextureMask(MaterialExpressionTextureSampleParameter2D):
    r"""
    Material Expression Antialiased Texture Mask
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionAntialiasedTextureMask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``channel`` (TextureColorChannel):  [Read-Write]
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``parameter_name`` (Name):  [Read-Write]
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``texture`` (Texture):  [Read-Write]
    - ``threshold`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionAppendVector(MaterialExpression):
    r"""
    Material Expression Append Vector
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionAppendVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionArccosine(MaterialExpression):
    r"""
    Material Expression Arccosine
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionArccosine.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionArccosineFast(MaterialExpression):
    r"""
    Material Expression Arccosine Fast
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionArccosineFast.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionArcsine(MaterialExpression):
    r"""
    Material Expression Arcsine
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionArcsine.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionArcsineFast(MaterialExpression):
    r"""
    Material Expression Arcsine Fast
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionArcsineFast.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionArctangent(MaterialExpression):
    r"""
    Material Expression Arctangent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionArctangent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionArctangent2(MaterialExpression):
    r"""
    Material Expression Arctangent 2
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionArctangent2.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionArctangent2Fast(MaterialExpression):
    r"""
    Material Expression Arctangent 2Fast
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionArctangent2Fast.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionArctangentFast(MaterialExpression):
    r"""
    Material Expression Arctangent Fast
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionArctangentFast.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionAtmosphericFogColor(MaterialExpression):
    r"""
    Material Expression Atmospheric Fog Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionAtmosphericFogColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the WorldPosition input.
    """
    ...

class MaterialExpressionAtmosphericLightColor(MaterialExpression):
    r"""
    Material Expression Atmospheric Light Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionAtmosphericLightColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionAtmosphericLightVector(MaterialExpression):
    r"""
    Material Expression Atmospheric Light Vector
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionAtmosphericLightVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionBentNormalCustomOutput(MaterialExpressionCustomOutput):
    r"""
    Material Expression Bent Normal Custom Output
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionBentNormalCustomOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionBinaryOp(MaterialExpression):
    r"""
    Material Expression Binary Op
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionBinaryOp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_a`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_b`` (float):  [Read-Write] only used if B is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLess(MaterialExpressionBinaryOp):
    r"""
    Material Expression Less
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionBinaryOp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_a`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_b`` (float):  [Read-Write] only used if B is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionBlackBody(MaterialExpression):
    r"""
    Material Expression Black Body
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionBlackBody.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionBlendMaterialAttributes(MaterialExpression):
    r"""
    Material Expression Blend Material Attributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionBlendMaterialAttributes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``pixel_attribute_blend_type`` (MaterialAttributeBlend):  [Read-Write] Optionally skip blending attributes of this type.
    - ``vertex_attribute_blend_type`` (MaterialAttributeBlend):  [Read-Write] Optionally skip blending attributes of this type.
    """
    ...

class MaterialExpressionBounds(MaterialExpression):
    r"""
    Material Expression Bounds
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionBounds.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``type`` (MaterialExpressionBoundsType):  [Read-Write] The type of bounds to output
    """
    ...

class MaterialExpressionBreakMaterialAttributes(MaterialExpression):
    r"""
    Material Expression Break Material Attributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionBreakMaterialAttributes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionBumpOffset(MaterialExpression):
    r"""
    Material Expression Bump Offset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionBumpOffset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_coordinate`` (uint32):  [Read-Write] only used if Coordinate is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``height_ratio`` (float):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``reference_plane`` (float):  [Read-Write] Perceived height as a fraction of width.
    """
    ...

class MaterialExpressionCameraPositionWS(MaterialExpression):
    r"""
    Material Expression Camera Position WS
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCameraPositionWS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionCameraVectorWS(MaterialExpression):
    r"""
    Material Expression Camera Vector WS
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCameraVectorWS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionCeil(MaterialExpression):
    r"""
    Material Expression Ceil
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCeil.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionParameter(MaterialExpression):
    r"""
    Material Expression Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    """
    ...

class MaterialExpressionVectorParameter(MaterialExpressionParameter):
    r"""
    Material Expression Vector Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVectorParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``default_value`` (LinearColor):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter
    - ``primitive_data_index`` (uint8):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``use_custom_primitive_data`` (bool):  [Read-Write]
    """
    ...

class MaterialExpressionChannelMaskParameter(MaterialExpressionVectorParameter):
    r"""
    Material Expression Channel Mask Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionChannelMaskParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``default_value`` (LinearColor):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``mask_channel`` (ChannelMaskParameterColor):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter
    - ``primitive_data_index`` (uint8):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``use_custom_primitive_data`` (bool):  [Read-Write]
    """
    ...

class MaterialExpressionClamp(MaterialExpression):
    r"""
    Material Expression Clamp
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionClamp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clamp_mode`` (ClampMode):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``max_default`` (float):  [Read-Write]
    - ``min_default`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionClearCoatNormalCustomOutput(MaterialExpressionCustomOutput):
    r"""
    Material Expression Clear Coat Normal Custom Output
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionClearCoatNormalCustomOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionCloudSampleAttribute(MaterialExpression):
    r"""
    Material Expression Cloud Sample Attribute
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCloudLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionCollectionParameter(MaterialExpression):
    r"""
    Material Expression Collection Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCollectionParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (MaterialParameterCollection):  [Read-Write] The Parameter Collection to use.
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] Name of the parameter being referenced.
    """
    ...

class MaterialExpressionComment(MaterialExpression):
    r"""
    Material Expression Comment
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionComment.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_comment_bubble`` (bool):  [Read-Write] Whether to use Comment Color to color the background of the comment bubble shown when zoomed out.
    - ``comment_bubble_visible_in_details_panel`` (bool):  [Read-Write] Whether to show a zoom-invariant comment bubble when zoomed out (making the comment readable at any distance).
    - ``comment_color`` (LinearColor):  [Read-Write] Color to style comment with
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``font_size`` (int32):  [Read-Write] Size of the text in the comment box
    - ``group_mode`` (bool):  [Read-Write] Whether the comment should move any fully enclosed nodes around when it is moved
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``text`` (str):  [Read-Write]
    """
    ...

class MaterialExpressionComponentMask(MaterialExpression):
    r"""
    Material Expression Component Mask
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionComponentMask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``a`` (bool):  [Read-Write]
    - ``b`` (bool):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``g`` (bool):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``r`` (bool):  [Read-Write]
    """
    ...

class MaterialExpressionComposite(MaterialExpression):
    r"""
    Composite (subgraph) expression. Exists purely for organzational purposes.
    Under the hood uses reroute expressions for graph compilation. See below
    to understand how a particular reroute's input / output correlates to
    the inputs / outputs of composites and their pin bases.
    
         _________________          _________________
        |   INPUT BASE    |        |   OUTPUT BASE   |
        +--------+--------+        +--------+--------+
        |        |   (>)  |   ->   |  (>)   |        |
        |        |   (>)  |        |  (>)   |        |
        |        |   (>)  |        |  (>)   |        |
        |        |   (>)  |        |  (>)   |        |
        |        |        |        |        |        |
        +--------+--------+        +--------+--------+
        | NODE IN:  NONE  |        | NODE IN:  PINS  |
        | NODE OUT: PINS  |        | NODE OUT: NONE  |
        |_________________|        |_________________|
    
                      ^                |
                      |                v
                 ____________________________
                |         COMPOSITE          |
                +---------+--------+---------+
            ->  |    (>)  |        |  (>)    |  ->
                |    (>)  |        |  (>)    |
                |    (>)  |        |  (>)    |
                |    (>)  |        |  (>)    |
                |         |        |         |
                +---------+--------+---------+
                | NODE IN:  TO INPUT BASE    |
                | NODE OUT: FROM OUTPUT BASE |
                |____________________________|
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionComposite.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``subgraph_name`` (str):  [Read-Write]
    """
    ...

class MaterialExpressionConstant(MaterialExpression):
    r"""
    Material Expression Constant
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionConstant.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``r`` (float):  [Read-Write]
    """
    @property
    def r(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @r.setter
    def r(self, value: float) -> None:
        ...

class MaterialExpressionConstant2Vector(MaterialExpression):
    r"""
    Material Expression Constant 2Vector
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionConstant2Vector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``g`` (float):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``r`` (float):  [Read-Write]
    """
    @property
    def r(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @r.setter
    def r(self, value: float) -> None:
        ...
    @property
    def g(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @g.setter
    def g(self, value: float) -> None:
        ...

class MaterialExpressionConstant3Vector(MaterialExpression):
    r"""
    Material Expression Constant 3Vector
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionConstant3Vector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``constant`` (LinearColor):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    @property
    def constant(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @constant.setter
    def constant(self, value: LinearColor) -> None:
        ...

class MaterialExpressionConstant4Vector(MaterialExpression):
    r"""
    Material Expression Constant 4Vector
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionConstant4Vector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``constant`` (LinearColor):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    @property
    def constant(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @constant.setter
    def constant(self, value: LinearColor) -> None:
        ...

class MaterialExpressionConstantBiasScale(MaterialExpression):
    r"""
    Material Expression Constant Bias Scale
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionConstantBiasScale.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bias`` (float):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``scale`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionCosine(MaterialExpression):
    r"""
    Material Expression Cosine
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCosine.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``period`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionCrossProduct(MaterialExpression):
    r"""
    Material Expression Cross Product
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCrossProduct.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionScalarParameter(MaterialExpressionParameter):
    r"""
    Material Expression Scalar Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionScalarParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_value`` (float):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter
    - ``primitive_data_index`` (uint8):  [Read-Write]
    - ``slider_max`` (float):  [Read-Write] Sets the upper bound for the slider on this parameter in the material instance editor.
      The slider will be disabled if SliderMax <= SliderMin.
    - ``slider_min`` (float):  [Read-Write] Sets the lower bound for the slider on this parameter in the material instance editor.
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``use_custom_primitive_data`` (bool):  [Read-Write]
    """
    ...

class MaterialExpressionCurveAtlasRowParameter(MaterialExpressionScalarParameter):
    r"""
    Material Expression Curve Atlas Row Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCurveAtlasRowParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``atlas`` (CurveLinearColorAtlas):  [Read-Write]
    - ``curve`` (CurveLinearColor):  [Read-Write]
    - ``default_value`` (float):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter
    - ``primitive_data_index`` (uint8):  [Read-Write]
    - ``slider_max`` (float):  [Read-Write] Sets the upper bound for the slider on this parameter in the material instance editor.
      The slider will be disabled if SliderMax <= SliderMin.
    - ``slider_min`` (float):  [Read-Write] Sets the lower bound for the slider on this parameter in the material instance editor.
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``use_custom_primitive_data`` (bool):  [Read-Write]
    """
    ...

class MaterialExpressionCustom(MaterialExpression):
    r"""
    Material Expression Custom
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionCustom.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_defines`` (Array[CustomDefine]):  [Read-Write]
    - ``additional_outputs`` (Array[CustomOutput]):  [Read-Write]
    - ``code`` (str):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``description`` (str):  [Read-Write]
    - ``include_file_paths`` (Array[str]):  [Read-Write]
    - ``inputs`` (Array[CustomInput]):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``output_type`` (CustomMaterialOutputType):  [Read-Write]
    - ``show_code`` (bool):  [Read-Only]
    """
    ...

class MaterialExpressionDataDrivenShaderPlatformInfoSwitch(MaterialExpression):
    r"""
    Material Expression Data Driven Shader Platform Info Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDataDrivenShaderPlatformInfoSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ddspi_property_names`` (Array[DataDrivenShaderPlatformInfoInput]):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDBufferTexture(MaterialExpression):
    r"""
    Material Expression DBuffer Texture
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDBufferTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``d_buffer_texture_id`` (DBufferTextureId):  [Read-Write] Which DBuffer texture we want to make a lookup into.
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDDX(MaterialExpression):
    r"""
    Material Expression DDX
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDDX.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDDY(MaterialExpression):
    r"""
    Material Expression DDY
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDDY.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDecalColor(MaterialExpression):
    r"""
    Material Expression Decal Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDecalColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDecalDerivative(MaterialExpression):
    r"""
    Material Expression Decal Derivative
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDecalDerivative.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDecalLifetimeOpacity(MaterialExpression):
    r"""
    Material Expression Decal Lifetime Opacity
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDecalLifetimeOpacity.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDecalMipmapLevel(MaterialExpression):
    r"""
    Material Expression Decal Mipmap Level
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDecalMipmapLevel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_height`` (float):  [Read-Write]
    - ``const_width`` (float):  [Read-Write] only used if TextureSize is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDeltaTime(MaterialExpression):
    r"""
    Material Expression Delta Time
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDeltaTime.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDepthFade(MaterialExpression):
    r"""
    Material Expression Depth Fade
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDepthFade.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``fade_distance_default`` (float):  [Read-Write] World space distance over which the fade should take place.  This is used when FadeDistance is unconnected.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``opacity_default`` (float):  [Read-Write] Opacity which will be scaled by the result of the fade.  This is used when InOpacity is unconnected.
    """
    ...

class MaterialExpressionDepthOfFieldFunction(MaterialExpression):
    r"""
    Material Expression Depth Of Field Function
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDepthOfFieldFunction.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``function_value`` (DepthOfFieldFunctionValue):  [Read-Write] Determines the mapping place to use on the terrain.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDeriveNormalZ(MaterialExpression):
    r"""
    Material Expression Derive Normal Z
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDeriveNormalZ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDesaturation(MaterialExpression):
    r"""
    Material Expression Desaturation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDesaturation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``luminance_factors`` (LinearColor):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDistance(MaterialExpression):
    r"""
    Material Expression Distance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDistance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDistanceCullFade(MaterialExpression):
    r"""
    Material Expression Distance Cull Fade
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDistanceCullFade.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDistanceFieldApproxAO(MaterialExpression):
    r"""
    Material Expression Distance Field Approx AO
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDistanceFieldApproxAO.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_distance_default`` (float):  [Read-Write] only used if BaseDistance is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``num_steps`` (uint32):  [Read-Write] Number of samples used to calculate occlusion
    - ``radius_default`` (float):  [Read-Write] only used if Radius is not hooked up
    - ``step_scale_default`` (float):  [Read-Write] Used to control step distance distribution
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the Position input.
    """
    ...

class MaterialExpressionDistanceFieldGradient(MaterialExpression):
    r"""
    Material Expression Distance Field Gradient
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDistanceFieldGradient.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the Position input.
    """
    ...

class MaterialExpressionDistanceFieldsRenderingSwitch(MaterialExpression):
    r"""
    Material output expression to switch logic according to whether distance fields renderering is supported on this project and feature level.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDistanceFieldsRenderingSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDistanceToNearestSurface(MaterialExpression):
    r"""
    Material Expression Distance to Nearest Surface
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDistanceToNearestSurface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the Position input.
    """
    ...

class MaterialExpressionDivide(MaterialExpression):
    r"""
    Material Expression Divide
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDivide.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_a`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_b`` (float):  [Read-Write] only used if B is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDotProduct(MaterialExpression):
    r"""
    Material Expression Dot Product
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDotProduct.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDoubleVectorParameter(MaterialExpressionParameter):
    r"""
    Material Expression Double Vector Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDoubleVectorParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_value`` (Vector4d):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    """
    ...

class MaterialExpressionDynamicParameter(MaterialExpression):
    r"""
    Material Expression Dynamic Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionDynamicParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_value`` (LinearColor):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``param_names`` (Array[str]):  [Read-Write] The names of the parameters.
      These will show up in Cascade when editing a particle system
      that uses the material it is in...
    - ``parameter_index`` (uint32):  [Read-Write] The index of the dynamic parameter for use in tools that allow > 1
    """
    ...

class MaterialExpressionExecBegin(MaterialExpression):
    r"""
    Material Expression Exec Begin
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionExecBegin.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionExecEnd(MaterialExpression):
    r"""
    Material Expression Exec End
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionExecEnd.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionExponential(MaterialExpression):
    r"""
    Material Expression Exponential
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionExponential.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMaterialXExponential(MaterialExpressionExponential):
    r"""
    deprecated: 'MaterialExpressionMaterialXExponential' was renamed to 'MaterialExpressionExponential'.
    """
    ...

class MaterialExpressionExponential2(MaterialExpression):
    r"""
    Material Expression Exponential 2
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionExponential2.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionEyeAdaptation(MaterialExpression):
    r"""
    Provides access to the EyeAdaptation render target.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionEyeAdaptation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionEyeAdaptationInverse(MaterialExpression):
    r"""
    Provides access to the EyeAdaptation render target.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionEyeAdaptationInverse.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionFeatureLevelSwitch(MaterialExpression):
    r"""
    Material Expression Feature Level Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionFeatureLevelSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionFloor(MaterialExpression):
    r"""
    Material Expression Floor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionFloor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionFmod(MaterialExpression):
    r"""
    Material Expression Fmod
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionFmod.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionFontSample(MaterialExpression):
    r"""
    Material Expression Font Sample
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionFontSample.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``font`` (Font):  [Read-Write] font resource that will be sampled
    - ``font_texture_page`` (int32):  [Read-Write] allow access to the various font pages
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionFontSampleParameter(MaterialExpressionFontSample):
    r"""
    Material Expression Font Sample Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionFontSampleParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``font`` (Font):  [Read-Write] font resource that will be sampled
    - ``font_texture_page`` (int32):  [Read-Write] allow access to the various font pages
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] name to be referenced when we want to find and set thsi parameter
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list. The lower the number the higher up in the parameter list.
    """
    ...

class MaterialExpressionForLoop(MaterialExpression):
    r"""
    Material Expression for Loop
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionForLoop.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionFrac(MaterialExpression):
    r"""
    Material Expression Frac
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionFrac.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionFresnel(MaterialExpression):
    r"""
    Material Expression Fresnel
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionFresnel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_reflect_fraction`` (float):  [Read-Write] Specifies the fraction of specular reflection when the surfaces is viewed from straight on.
      A value of 1 effectively disables Fresnel.
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``exponent`` (float):  [Read-Write] The exponent to pass into the pow() function
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionFunctionInput(MaterialExpression):
    r"""
    Material Expression Function Input
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionFunctionInput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``description`` (str):  [Read-Write] The input's description, which will be used as a tooltip on the connector in function call expressions that use this function.
    - ``input_name`` (Name):  [Read-Write] The input's name, which will be drawn on the connector in function call expressions that use this function.
    - ``input_type`` (FunctionInputType):  [Read-Write] Type of this input.
      Input code chunks will be cast to this type, and a compiler error will be emitted if the cast fails.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``preview_value`` (Vector4f):  [Read-Write] Value used to preview this input when editing the material function.
    - ``sort_priority`` (int32):  [Read-Write] Controls where the input is displayed relative to the other inputs.
    - ``use_preview_value_as_default`` (bool):  [Read-Write] Whether to use the preview value or texture as the default value for this input.
    """
    @property
    def input_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The input's name, which will be drawn on the connector in function call expressions that use this function.
        """
        ...
    @input_name.setter
    def input_name(self, value: Name) -> None:
        ...
    @property
    def input_type(self) -> FunctionInputType:
        r"""
        (FunctionInputType):  [Read-Write] Type of this input.
        Input code chunks will be cast to this type, and a compiler error will be emitted if the cast fails.
        """
        ...
    @input_type.setter
    def input_type(self, value: FunctionInputType) -> None:
        ...
    @property
    def preview_value(self) -> Vector4f:
        r"""
        (Vector4f):  [Read-Write] Value used to preview this input when editing the material function.
        """
        ...
    @preview_value.setter
    def preview_value(self, value: Vector4f) -> None:
        ...
    @property
    def use_preview_value_as_default(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to use the preview value or texture as the default value for this input.
        """
        ...
    @use_preview_value_as_default.setter
    def use_preview_value_as_default(self, value: bool) -> None:
        ...
    @property
    def sort_priority(self) -> int:
        r"""
        (int32):  [Read-Write] Controls where the input is displayed relative to the other inputs.
        """
        ...
    @sort_priority.setter
    def sort_priority(self, value: int) -> None:
        ...

class MaterialExpressionFunctionOutput(MaterialExpression):
    r"""
    Material Expression Function Output
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionFunctionOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``description`` (str):  [Read-Write] The output's description, which will be used as a tooltip on the connector in function call expressions that use this function.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``output_name`` (Name):  [Read-Write] The output's name, which will be drawn on the connector in function call expressions that use this function.
    - ``sort_priority`` (int32):  [Read-Write] Controls where the output is displayed relative to the other outputs.
    """
    @property
    def output_name(self) -> Name:
        r"""
        (Name):  [Read-Write] The output's name, which will be drawn on the connector in function call expressions that use this function.
        """
        ...
    @output_name.setter
    def output_name(self, value: Name) -> None:
        ...

class MaterialExpressionGenericConstant(MaterialExpression):
    r"""
    Material Expression Generic Constant
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionGenericConstant.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionConstantDouble(MaterialExpressionGenericConstant):
    r"""
    Material Expression Constant Double
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionGenericConstant.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``value`` (double):  [Read-Write]
    """
    @property
    def value(self) -> float:
        r"""
        (double):  [Read-Write]
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...

class MaterialExpressionGetLocal(MaterialExpression):
    r"""
    Material Expression Get Local
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionGetLocal.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``local_name`` (Name):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionGetMaterialAttributes(MaterialExpression):
    r"""
    Material Expression Get Material Attributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionGetMaterialAttributes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attribute_get_types`` (Array[Guid]):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionGIReplace(MaterialExpression):
    r"""
    Material Expression GIReplace
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionGIReplace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionHairAttributes(MaterialExpression):
    r"""
    Material Expression Hair Attributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionHairAttributes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``use_tangent_space`` (bool):  [Read-Write] If enabled, this nodes outputs a tangent space tangent, otherwise it outputs a world space tangent.
    """
    ...

class MaterialExpressionHairColor(MaterialExpression):
    r"""
    Material Expression Hair Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionHairColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionHsvToRgb(MaterialExpression):
    r"""
    Material Expression Hsv to Rgb
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionHsvToRgb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMaterialXHsvToRgb(MaterialExpressionHsvToRgb):
    r"""
    deprecated: 'MaterialExpressionMaterialXHsvToRgb' was renamed to 'MaterialExpressionHsvToRgb'.
    """
    ...

class MaterialExpressionIf(MaterialExpression):
    r"""
    Material Expression If
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionIf.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_b`` (float):  [Read-Write] only used if B is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``equals_threshold`` (float):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionIfThenElse(MaterialExpression):
    r"""
    Material Expression if Then Else
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionIfThenElse.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionInverseLinearInterpolate(MaterialExpression):
    r"""
    Material Expression Inverse Linear Interpolate
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionInverseLinearInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clamp_result`` (bool):  [Read-Write] Clamp the result to 0 to 1
    - ``const_a`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_b`` (float):  [Read-Write] only used if B is not hooked up
    - ``const_value`` (float):  [Read-Write] only used if Value is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionIsOrthographic(MaterialExpression):
    r"""
    Material Expression Is Orthographic
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionIsOrthographic.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLength(MaterialExpression):
    r"""
    Material Expression Length
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionLength.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMaterialXLength(MaterialExpressionLength):
    r"""
    deprecated: 'MaterialExpressionMaterialXLength' was renamed to 'MaterialExpressionLength'.
    """
    ...

class MaterialExpressionLightmapUVs(MaterialExpression):
    r"""
    Material Expression Lightmap UVs
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionLightmapUVs.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLightmassReplace(MaterialExpression):
    r"""
    Material Expression Lightmass Replace
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionLightmassReplace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLightVector(MaterialExpression):
    r"""
    Material Expression Light Vector
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionLightVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLinearInterpolate(MaterialExpression):
    r"""
    Material Expression Linear Interpolate
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionLinearInterpolate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_a`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``const_b`` (float):  [Read-Write] only used if B is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLogarithm(MaterialExpression):
    r"""
    Material Expression Logarithm
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionLogarithm.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMaterialXLogarithm(MaterialExpressionLogarithm):
    r"""
    deprecated: 'MaterialExpressionMaterialXLogarithm' was renamed to 'MaterialExpressionLogarithm'.
    """
    ...

class MaterialExpressionLogarithm10(MaterialExpression):
    r"""
    Material Expression Logarithm 10
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionLogarithm10.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLogarithm2(MaterialExpression):
    r"""
    Material Expression Logarithm 2
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionLogarithm2.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMakeMaterialAttributes(MaterialExpression):
    r"""
    Material Expression Make Material Attributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionMakeMaterialAttributes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMapARPassthroughCameraUV(MaterialExpression):
    r"""
    Material Expression Map ARPassthrough Camera UV
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionMapARPassthroughCameraUV.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMaterialAttributeLayers(MaterialExpression):
    r"""
    Material Expression Material Attribute Layers
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionMaterialAttributeLayers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_layers`` (MaterialLayersFunctions):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMaterialFunctionCall(MaterialExpression):
    r"""
    Material Expression Material Function Call
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionMaterialFunctionCall.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``material_function`` (MaterialFunctionInterface):  [Read-Write] The function to call.
    """
    def set_material_function(self, new_material_function: MaterialFunctionInterface) -> bool:
        r"""
        x.set_material_function(new_material_function) -> bool
        Set Material Function
        
        Args:
            new_material_function (MaterialFunctionInterface): 
        
        Returns:
            bool:
        """
        ...

class MaterialExpressionMaterialLayerOutput(MaterialExpressionFunctionOutput):
    r"""
    Material Expression Material Layer Output
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionMaterialLayerOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``description`` (str):  [Read-Write] The output's description, which will be used as a tooltip on the connector in function call expressions that use this function.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``output_name`` (Name):  [Read-Write] The output's name, which will be drawn on the connector in function call expressions that use this function.
    - ``sort_priority`` (int32):  [Read-Write] Controls where the output is displayed relative to the other outputs.
    """
    ...

class MaterialExpressionMaterialProxyReplace(MaterialExpression):
    r"""
    Material Expression Material Proxy Replace
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionMaterialProxyReplace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMax(MaterialExpression):
    r"""
    Material Expression Max
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionMax.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_a`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_b`` (float):  [Read-Write] only used if B is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMin(MaterialExpression):
    r"""
    Material Expression Min
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionMin.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_a`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_b`` (float):  [Read-Write] only used if B is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMultiply(MaterialExpression):
    r"""
    Material Expression Multiply
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionMultiply.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_a`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_b`` (float):  [Read-Write] only used if B is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionRerouteBase(MaterialExpression):
    r"""
    Material Expression Reroute Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRerouteBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionNamedRerouteBase(MaterialExpressionRerouteBase):
    r"""
    Material Expression Named Reroute Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionNamedReroute.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionNamedRerouteDeclaration(MaterialExpressionNamedRerouteBase):
    r"""
    Material Expression Named Reroute Declaration
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionNamedReroute.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``node_color`` (LinearColor):  [Read-Write] The color of the graph node. The same color will apply to all linked usages of this Declaration node
    """
    ...

class MaterialExpressionNamedRerouteUsage(MaterialExpressionNamedRerouteBase):
    r"""
    Material Expression Named Reroute Usage
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionNamedReroute.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionNaniteReplace(MaterialExpression):
    r"""
    Material Expression Nanite Replace
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionNaniteReplace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionNeuralNetworkInput(MaterialExpressionCustomOutput):
    r"""
    Material Expression Neural Network Input
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionNeuralPostProcessNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``neural_index_type`` (NeuralIndexType):  [Read-Write] Indexing type: write to the texture or buffer
    """
    ...

class MaterialExpressionNeuralNetworkOutput(MaterialExpression):
    r"""
    The input node that holds the output from the neural network to the post process material
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionNeuralPostProcessNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``neural_index_type`` (NeuralIndexType):  [Read-Write] Indexing type: read from the texture or buffer.
                     Texture index is valid only when the first 2 dimension of the input and output dimension matches.
    """
    ...

class MaterialExpressionNoise(MaterialExpression):
    r"""
    Material Expression Noise
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionNoise.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``level_scale`` (float):  [Read-Write] usually 2 but higher values allow efficient use of few levels
    - ``levels`` (int32):  [Read-Write] 1 = fast but little detail, .. larger numbers cost more performance
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``noise_function`` (NoiseFunction):  [Read-Write] Noise function, affects performance and look
    - ``output_max`` (float):  [Read-Write]
    - ``output_min`` (float):  [Read-Write]
    - ``quality`` (int32):  [Read-Write] Lower numbers are faster and lower quality, higher numbers are slower and higher quality
    - ``repeat_size`` (uint32):  [Read-Write] How many units in each tile (if Tiling is on)
    - ``scale`` (float):  [Read-Write] can also be done with a multiply on the Position
    - ``tiling`` (bool):  [Read-Write] Whether to use tiling noise pattern, useful for baking to seam-free repeating textures
    - ``turbulence`` (bool):  [Read-Write] How multiple frequencies are getting combined
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the Position input.
    """
    ...

class MaterialExpressionNormalize(MaterialExpression):
    r"""
    Material Expression Normalize
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionNormalize.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionObjectBounds(MaterialExpression):
    r"""
    Material Expression Object Bounds
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionObjectBounds.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionObjectLocalBounds(MaterialExpression):
    r"""
    Material Expression Object Local Bounds
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionObjectLocalBounds.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionObjectOrientation(MaterialExpression):
    r"""
    Material Expression Object Orientation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionObjectOrientation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionObjectPositionWS(MaterialExpression):
    r"""
    Material Expression Object Position WS
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionObjectPositionWS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``origin_type`` (PositionOrigin):  [Read-Write]
    """
    ...

class MaterialExpressionObjectRadius(MaterialExpression):
    r"""
    Material Expression Object Radius
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionObjectRadius.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionOneMinus(MaterialExpression):
    r"""
    Material Expression One Minus
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionOneMinus.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPanner(MaterialExpression):
    r"""
    Material Expression Panner
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPanner.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_coordinate`` (uint32):  [Read-Write] only used if Coordinate is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``fractional_part`` (bool):  [Read-Write] Output only the fractional part of the pan calculation for greater precision.
      Output is greater than or equal to 0 and less than 1.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``speed_x`` (float):  [Read-Write]
    - ``speed_y`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionParticleColor(MaterialExpression):
    r"""
    Material Expression Particle Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionParticleDirection(MaterialExpression):
    r"""
    Material Expression Particle Direction
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleDirection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionParticleMacroUV(MaterialExpression):
    r"""
    Material Expression Particle Macro UV
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleMacroUV.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionParticleMotionBlurFade(MaterialExpression):
    r"""
    Material Expression Particle Motion Blur Fade
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleMotionBlurFade.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionParticlePositionWS(MaterialExpression):
    r"""
    Material Expression Particle Position WS
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticlePositionWS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``origin_type`` (PositionOrigin):  [Read-Write]
    """
    ...

class MaterialExpressionParticleRadius(MaterialExpression):
    r"""
    Material Expression Particle Radius
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleRadius.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionParticleRandom(MaterialExpression):
    r"""
    Material Expression Particle Random
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleRandom.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionParticleRelativeTime(MaterialExpression):
    r"""
    Material Expression Particle Relative Time
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleRelativeTime.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionParticleSize(MaterialExpression):
    r"""
    Material Expression Particle Size
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleSize.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionParticleSpeed(MaterialExpression):
    r"""
    Material Expression Particle Speed
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleSpeed.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionParticleSpriteRotation(MaterialExpression):
    r"""
    Material Expression Particle Sprite Rotation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleSpriteRotation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionParticleSubUV(MaterialExpressionTextureSample):
    r"""
    Material Expression Particle Sub UV
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleSubUV.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``blend`` (bool):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionParticleSubUVProperties(MaterialExpression):
    r"""
    Material Expression Particle Sub UVProperties
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionParticleSubUVProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPathTracingBufferTexture(MaterialExpression):
    r"""
    Path tracing buffer is only accessable in postprocess material.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPathTracingBufferTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``path_tracing_buffer_texture_id`` (PathTracingBufferTextureId):  [Read-Write] Which path tracing buffer texture we want to make a lookup into.
    """
    ...

class MaterialExpressionPathTracingQualitySwitch(MaterialExpression):
    r"""
    Material Expression Path Tracing Quality Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPathTracingQualitySwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPathTracingRayTypeSwitch(MaterialExpression):
    r"""
    Material Expression Path Tracing Ray Type Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPathTracingRayTypeSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPerInstanceCustomData(MaterialExpression):
    r"""
    Material Expression Per Instance Custom Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPerInstanceCustomData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_default_value`` (float):  [Read-Write]
    - ``data_index`` (uint32):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPerInstanceCustomData3Vector(MaterialExpression):
    r"""
    Material Expression Per Instance Custom Data 3Vector
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPerInstanceCustomData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_default_value`` (LinearColor):  [Read-Write]
    - ``data_index`` (uint32):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPerInstanceFadeAmount(MaterialExpression):
    r"""
    Material Expression Per Instance Fade Amount
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPerInstanceFadeAmount.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPerInstanceRandom(MaterialExpression):
    r"""
    Material Expression Per Instance Random
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPerInstanceRandom.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPinBase(MaterialExpression):
    r"""
    Material Expression Pin Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPinBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``reroute_pins`` (Array[CompositeReroute]):  [Read-Write] Underlying reroute pins used to compile material. Must call Modify after editing to update output expressions.
    """
    ...

class MaterialExpressionPixelDepth(MaterialExpression):
    r"""
    Material Expression Pixel Depth
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPixelDepth.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPixelNormalWS(MaterialExpression):
    r"""
    Material Expression Pixel Normal WS
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPixelNormalWS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPower(MaterialExpression):
    r"""
    Material Expression Power
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPower.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_exponent`` (float):  [Read-Write] only used if Exponent is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPrecomputedAOMask(MaterialExpression):
    r"""
    Material Expression Precomputed AOMask
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPrecomputedAOMask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPreSkinnedLocalBounds(MaterialExpression):
    r"""
    Material Expression Pre Skinned Local Bounds
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPreSkinnedLocalBounds.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPreSkinnedNormal(MaterialExpression):
    r"""
    Material Expression Pre Skinned Normal
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPreSkinnedNormal.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPreSkinnedPosition(MaterialExpression):
    r"""
    Material Expression Pre Skinned Position
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPreSkinnedPosition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPreviousFrameSwitch(MaterialExpression):
    r"""
    Material Expression Previous Frame Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionPreviousFrameSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionQualitySwitch(MaterialExpression):
    r"""
    Material Expression Quality Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionQualitySwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionRayTracingQualitySwitch(MaterialExpression):
    r"""
    Material Expression Ray Tracing Quality Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRayTracingQualitySwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionReflectionCapturePassSwitch(MaterialExpression):
    r"""
    Material Expression Reflection Capture Pass Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionReflectionCapturePassSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionReflectionVectorWS(MaterialExpression):
    r"""
    Material Expression Reflection Vector WS
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionReflectionVectorWS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``normalize_custom_world_normal`` (bool):  [Read-Write] (true): The specified world normal will be normalized. (false): WorldNormal will just be used as is, faster but possible artifacts if normal length isn't 1
    """
    ...

class MaterialExpressionRequiredSamplersSwitch(MaterialExpression):
    r"""
    Material Expression Required Samplers Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRequiredSamplersSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``required_samplers`` (uint32):  [Read-Write]
    """
    ...

class MaterialExpressionReroute(MaterialExpressionRerouteBase):
    r"""
    Material Expression Reroute
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionReroute.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionRgbToHsv(MaterialExpression):
    r"""
    Material Expression Rgb to Hsv
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRgbToHsv.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMaterialXRgbToHsv(MaterialExpressionRgbToHsv):
    r"""
    deprecated: 'MaterialExpressionMaterialXRgbToHsv' was renamed to 'MaterialExpressionRgbToHsv'.
    """
    ...

class MaterialExpressionRotateAboutAxis(MaterialExpression):
    r"""
    Material Expression Rotate About Axis
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRotateAboutAxis.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``period`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionRotator(MaterialExpression):
    r"""
    Material Expression Rotator
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRotator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``center_x`` (float):  [Read-Write]
    - ``center_y`` (float):  [Read-Write]
    - ``const_coordinate`` (uint32):  [Read-Write] only used if Coordinate is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``speed`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionRound(MaterialExpression):
    r"""
    Material Expression Round
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRound.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionRuntimeVirtualTextureOutput(MaterialExpressionCustomOutput):
    r"""
    Material output expression for writing to a runtime virtual texture.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRuntimeVirtualTextureOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionRuntimeVirtualTextureReplace(MaterialExpression):
    r"""
    Material output expression to switch logic for a path that renders to runtime virtual texture pages.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRuntimeVirtualTextureReplace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionRuntimeVirtualTextureSample(MaterialExpression):
    r"""
    Material expression for sampling from a runtime virtual texture.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRuntimeVirtualTextureSample.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adaptive`` (bool):  [Read-Write] Enable sparse adaptive page tables. Note that the bound Virtual Texture should have valid adaptive virtual texture settings for sampling to work correctly.
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``enable_feedback`` (bool):  [Read-Write] Enable virtual texture feedback.
      Disabling this can result in the virtual texture not reaching the correct mip level.
      It should only be used in cases where we don't care about the correct mip level being resident, or some other process is maintaining the correct level.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``material_type`` (RuntimeVirtualTextureMaterialType):  [Read-Write] How to interpret the virtual texture contents. Note that the bound Virtual Texture should have the same setting for sampling to work correctly.
    - ``mip_value_mode`` (RuntimeVirtualTextureMipValueMode):  [Read-Write] Defines how the mip level is calculated for the virtual texture lookup.
    - ``single_physical_space`` (bool):  [Read-Write] Enable page table channel packing. Note that the bound Virtual Texture should have the same setting for sampling to work correctly.
    - ``texture_address_mode`` (RuntimeVirtualTextureTextureAddressMode):  [Read-Write] Defines the texture addressing mode.
    - ``virtual_texture`` (RuntimeVirtualTexture):  [Read-Write] The virtual texture object to sample.
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the WorldPosition input.
    """
    ...

class MaterialExpressionRuntimeVirtualTextureSampleParameter(MaterialExpressionRuntimeVirtualTextureSample):
    r"""
    Material Expression Runtime Virtual Texture Sample Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionRuntimeVirtualTextureSampleParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adaptive`` (bool):  [Read-Write] Enable sparse adaptive page tables. Note that the bound Virtual Texture should have valid adaptive virtual texture settings for sampling to work correctly.
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``enable_feedback`` (bool):  [Read-Write] Enable virtual texture feedback.
      Disabling this can result in the virtual texture not reaching the correct mip level.
      It should only be used in cases where we don't care about the correct mip level being resident, or some other process is maintaining the correct level.
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``material_type`` (RuntimeVirtualTextureMaterialType):  [Read-Write] How to interpret the virtual texture contents. Note that the bound Virtual Texture should have the same setting for sampling to work correctly.
    - ``mip_value_mode`` (RuntimeVirtualTextureMipValueMode):  [Read-Write] Defines how the mip level is calculated for the virtual texture lookup.
    - ``parameter_name`` (Name):  [Read-Write] Name to be referenced when we want to find and set this parameter
    - ``single_physical_space`` (bool):  [Read-Write] Enable page table channel packing. Note that the bound Virtual Texture should have the same setting for sampling to work correctly.
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list. The lower the number the higher up in the parameter list.
    - ``texture_address_mode`` (RuntimeVirtualTextureTextureAddressMode):  [Read-Write] Defines the texture addressing mode.
    - ``virtual_texture`` (RuntimeVirtualTexture):  [Read-Write] The virtual texture object to sample.
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the WorldPosition input.
    """
    ...

class MaterialExpressionSamplePhysicsVectorField(MaterialExpression):
    r"""
    Material expresions to sample the global field
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSamplePhysicsField.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``field_target`` (FieldVectorType):  [Read-Write] Target Type to be accessed
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the WorldPosition input.
    """
    ...

class MaterialExpressionSamplePhysicsScalarField(MaterialExpression):
    r"""
    Material Expression Sample Physics Scalar Field
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSamplePhysicsField.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``field_target`` (FieldScalarType):  [Read-Write] Target Type to be accessed
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the WorldPosition input.
    """
    ...

class MaterialExpressionSamplePhysicsIntegerField(MaterialExpression):
    r"""
    Material Expression Sample Physics Integer Field
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSamplePhysicsField.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``field_target`` (FieldIntegerType):  [Read-Write] Target Type to be accessed
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the WorldPosition input.
    """
    ...

class MaterialExpressionSaturate(MaterialExpression):
    r"""
    Material Expression Saturate
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSaturate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSceneColor(MaterialExpression):
    r"""
    Material Expression Scene Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSceneColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_input`` (Vector2D):  [Read-Write] only used if Input is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``input_mode`` (MaterialSceneAttributeInputMode):  [Read-Write] Coordinates - UV coordinates to apply to the scene color lookup.
      OffsetFraction -      An offset to apply to the scene color lookup in a 2d fraction of the screen.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSceneDepth(MaterialExpression):
    r"""
    Material Expression Scene Depth
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSceneDepth.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_input`` (Vector2D):  [Read-Write] only used if Input is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``input_mode`` (MaterialSceneAttributeInputMode):  [Read-Write] Coordinates - UV coordinates to apply to the scene depth lookup.
      OffsetFraction - An offset to apply to the scene depth lookup in a 2d fraction of the screen.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSceneDepthWithoutWater(MaterialExpression):
    r"""
    Material Expression Scene Depth Without Water
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSceneDepthWithoutWater.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_input`` (Vector2D):  [Read-Write] only used if Input is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``fallback_depth`` (float):  [Read-Write] Depth to fall back to in case the needed texture isn't available on a particular platform or configuration
    - ``input_mode`` (MaterialSceneAttributeInputMode):  [Read-Write] Coordinates - UV coordinates to apply to the scene depth lookup.
      OffsetFraction - An offset to apply to the scene depth lookup in a 2d fraction of the screen.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSceneTexelSize(MaterialExpression):
    r"""
    Material Expression Scene Texel Size
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSceneTexelSize.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSceneTexture(MaterialExpression):
    r"""
    Material Expression Scene Texture
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSceneTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``filtered`` (bool):  [Read-Write] Whether to use point sampled texture lookup (default) or using [bi-linear] filtered (can be slower, avoid faceted lock with distortions), some SceneTextures cannot be filtered
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``scene_texture_id`` (SceneTextureId):  [Read-Write] Which scene texture (screen aligned texture) we want to make a lookup into
    """
    ...

class MaterialExpressionScreenPosition(MaterialExpression):
    r"""
    Material Expression Screen Position
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionScreenPosition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSetLocal(MaterialExpression):
    r"""
    Material Expression Set Local
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSetLocal.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``local_name`` (Name):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSetMaterialAttributes(MaterialExpression):
    r"""
    Material Expression Set Material Attributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSetMaterialAttributes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attribute_set_types`` (Array[Guid]):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionShaderStageSwitch(MaterialExpression):
    r"""
    Material Expression Shader Stage Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionShaderStageSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionShadingModel(MaterialExpression):
    r"""
    Material Expression Shading Model
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionShadingModel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``shading_model`` (MaterialShadingModel):  [Read-Write]
    """
    ...

class MaterialExpressionShadingPathSwitch(MaterialExpression):
    r"""
    Material Expression Shading Path Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionShadingPathSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionShadowReplace(MaterialExpression):
    r"""
    Material Expression Shadow Replace
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionShadowReplace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSign(MaterialExpression):
    r"""
    Material Expression Sign
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSign.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSine(MaterialExpression):
    r"""
    Material Expression Sine
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSine.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``period`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionSingleLayerWaterMaterialOutput(MaterialExpressionCustomOutput):
    r"""
    Material output expression for writing single layer water volume material properties.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSingleLayerWaterMaterialOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSkyAtmosphereLightDirection(MaterialExpression):
    r"""
    Material Expression Sky Atmosphere Light Direction
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSkyAtmosphereLightDirection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``light_index`` (int32):  [Read-Write] Index of the atmosphere light to sample.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    @property
    def light_index(self) -> int:
        r"""
        (int32):  [Read-Write] Index of the atmosphere light to sample.
        """
        ...
    @light_index.setter
    def light_index(self, value: int) -> None:
        ...

class MaterialExpressionSkyAtmosphereLightIlluminance(MaterialExpression):
    r"""
    Material Expression Sky Atmosphere Light Illuminance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSkyAtmosphereLightIlluminance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``light_index`` (int32):  [Read-Write] Index of the atmosphere light to sample.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the WorldPosition input.
    """
    @property
    def light_index(self) -> int:
        r"""
        (int32):  [Read-Write] Index of the atmosphere light to sample.
        """
        ...
    @light_index.setter
    def light_index(self, value: int) -> None:
        ...

class MaterialExpressionSkyAtmosphereLightIlluminanceOnGround(MaterialExpression):
    r"""
    Material Expression Sky Atmosphere Light Illuminance on Ground
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSkyAtmosphereLightIlluminance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``light_index`` (int32):  [Read-Write] Index of the atmosphere light to sample.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    @property
    def light_index(self) -> int:
        r"""
        (int32):  [Read-Write] Index of the atmosphere light to sample.
        """
        ...
    @light_index.setter
    def light_index(self, value: int) -> None:
        ...

class MaterialExpressionSkyAtmosphereLightDiskLuminance(MaterialExpression):
    r"""
    Material Expression Sky Atmosphere Light Disk Luminance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSkyAtmosphereLightIlluminance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``light_index`` (int32):  [Read-Write] Index of the atmosphere light to sample.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    @property
    def light_index(self) -> int:
        r"""
        (int32):  [Read-Write] Index of the atmosphere light to sample.
        """
        ...
    @light_index.setter
    def light_index(self, value: int) -> None:
        ...

class MaterialExpressionSkyAtmosphereAerialPerspective(MaterialExpression):
    r"""
    Material Expression Sky Atmosphere Aerial Perspective
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSkyAtmosphereLightIlluminance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the WorldPosition input.
    """
    ...

class MaterialExpressionSkyAtmosphereDistantLightScatteredLuminance(MaterialExpression):
    r"""
    Material Expression Sky Atmosphere Distant Light Scattered Luminance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSkyAtmosphereLightIlluminance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSkyAtmosphereViewLuminance(MaterialExpression):
    r"""
    Material Expression Sky Atmosphere View Luminance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSkyAtmosphereViewLuminance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSkyLightEnvMapSample(MaterialExpression):
    r"""
    Material Expression Sky Light Env Map Sample
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSkyLightEnvMapSample.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSmoothStep(MaterialExpression):
    r"""
    Material Expression Smooth Step
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSmoothStep.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_max`` (float):  [Read-Write] only used if Max is not hooked up
    - ``const_min`` (float):  [Read-Write] only used if Min is not hooked up
    - ``const_value`` (float):  [Read-Write] only used if Value is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSobol(MaterialExpression):
    r"""
    Material Expression Sobol
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSobol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_index`` (uint32):  [Read-Write] Sobol point number. Only used if Index is not connected.
    - ``const_seed`` (Vector2D):  [Read-Write] 2D Seed for sequence randomization. Only used if Seed is not connected.
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSparseVolumeTextureBase(MaterialExpression):
    r"""
    Material Expression Sparse Volume Texture Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSparseVolumeTextureBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``sparse_volume_texture`` (SparseVolumeTexture):  [Read-Write] The Sparse Virtual Texture to sample.
    """
    @property
    def sparse_volume_texture(self) -> SparseVolumeTexture:
        r"""
        (SparseVolumeTexture):  [Read-Write] The Sparse Virtual Texture to sample.
        """
        ...
    @sparse_volume_texture.setter
    def sparse_volume_texture(self, value: SparseVolumeTexture) -> None:
        ...

class MaterialExpressionSparseVolumeTextureObject(MaterialExpressionSparseVolumeTextureBase):
    r"""
    Material Expression Sparse Volume Texture Object
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSparseVolumeTextureObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``sparse_volume_texture`` (SparseVolumeTexture):  [Read-Write] The Sparse Virtual Texture to sample.
    """
    ...

class MaterialExpressionSparseVolumeTextureSample(MaterialExpressionSparseVolumeTextureBase):
    r"""
    Material expression for sampling from a runtime virtual texture.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSparseVolumeTextureSample.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the USparseVolumeTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sparse_volume_texture`` (SparseVolumeTexture):  [Read-Write] The Sparse Virtual Texture to sample.
    """
    ...

class MaterialExpressionSparseVolumeTextureSampleParameter(MaterialExpressionSparseVolumeTextureSample):
    r"""
    Material Expression Sparse Volume Texture Sample Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSparseVolumeTextureSample.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] Name to be referenced when we want to find and set this parameter
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the USparseVolumeTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list. The lower the number the higher up in the parameter list.
    - ``sparse_volume_texture`` (SparseVolumeTexture):  [Read-Write] The Sparse Virtual Texture to sample.
    """
    ...

class MaterialExpressionSparseVolumeTextureObjectParameter(MaterialExpressionSparseVolumeTextureSampleParameter):
    r"""
    Material Expression Sparse Volume Texture Object Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSparseVolumeTextureObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] Name to be referenced when we want to find and set this parameter
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the USparseVolumeTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list. The lower the number the higher up in the parameter list.
    - ``sparse_volume_texture`` (SparseVolumeTexture):  [Read-Write] The Sparse Virtual Texture to sample.
    """
    ...

class MaterialExpressionSpeedTree(MaterialExpression):
    r"""
    Material Expression Speed Tree
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSpeedTree.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accurate_wind_velocities`` (bool):  [Read-Write] Support accurate velocities from wind. This will incur extra cost per vertex.
    - ``billboard_threshold`` (float):  [Read-Write] The threshold for triangles to be removed from the bilboard mesh when not facing the camera (0 = none pass, 1 = all pass).
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``geometry_type`` (SpeedTreeGeometryType):  [Read-Write] The type of SpeedTree geometry on which this material will be used
    - ``lod_type`` (SpeedTreeLODType):  [Read-Write] The type of LOD to use
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``wind_type`` (SpeedTreeWindType):  [Read-Write] The type of wind effect used on this tree. This can only go as high as it was in the SpeedTree Modeler, but you can set it to a lower option for lower quality wind and faster rendering.
    """
    ...

class MaterialExpressionSphereMask(MaterialExpression):
    r"""
    Material Expression Sphere Mask
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSphereMask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attenuation_radius`` (float):  [Read-Write] in the unit that A and B are measured
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``hardness_percent`` (float):  [Read-Write] in percent 0%=soft .. 100%=hard
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSphericalParticleOpacity(MaterialExpression):
    r"""
    Material Expression Spherical Particle Opacity
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSphericalParticleOpacity.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``constant_density`` (float):  [Read-Write] Constant density of the particle sphere.  Will be overridden if Density is connected.
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSquareRoot(MaterialExpression):
    r"""
    Material Expression Square Root
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSquareRoot.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSRGBColorToWorkingColorSpace(MaterialExpression):
    r"""
    Material Expression SRGBColor to Working Color Space
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSRGBColorToWorkingColorSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStaticBool(MaterialExpression):
    r"""
    Material Expression Static Bool
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionStaticBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``value`` (bool):  [Read-Write]
    """
    ...

class MaterialExpressionStaticBoolParameter(MaterialExpressionParameter):
    r"""
    Material Expression Static Bool Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionStaticBoolParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_value`` (bool):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``dynamic_branch`` (bool):  [Read-Write] Change Parameter from "static bool" to (dynamic) bool type which enables it to be used with dynamic branching
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    """
    ...

class MaterialExpressionStaticComponentMaskParameter(MaterialExpressionParameter):
    r"""
    Material Expression Static Component Mask Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionStaticComponentMaskParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_a`` (bool):  [Read-Write]
    - ``default_b`` (bool):  [Read-Write]
    - ``default_g`` (bool):  [Read-Write]
    - ``default_r`` (bool):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    """
    ...

class MaterialExpressionStaticSwitch(MaterialExpression):
    r"""
    Material Expression Static Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionStaticSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_value`` (bool):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStaticSwitchParameter(MaterialExpressionStaticBoolParameter):
    r"""
    Material Expression Static Switch Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionStaticSwitchParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_value`` (bool):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``dynamic_branch`` (bool):  [Read-Write] Change Parameter from "static bool" to (dynamic) bool type which enables it to be used with dynamic branching
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``parameter_name`` (Name):  [Read-Write] The name of the parameter
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    """
    ...

class MaterialExpressionStep(MaterialExpression):
    r"""
    Material Expression Step
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionStep.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_x`` (float):  [Read-Write] only used if X is not hooked up
    - ``const_y`` (float):  [Read-Write] only used if Y is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSubstrateBSDF(MaterialExpression):
    r"""
    UMaterialExpressionSubstrateBSDF can only be used for Substrate nodes ouputing SubstrateData that would need a preview,
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataBSDF(MaterialExpressionSubstrateBSDF):
    r"""
    deprecated: 'MaterialExpressionStrataBSDF' was renamed to 'MaterialExpressionSubstrateBSDF'.
    """
    ...

class MaterialExpressionSubstrateShadingModels(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Shading Models
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``shading_model_override`` (MaterialShadingModel):  [Read-Write]
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Screen Space Subsurface Scattering. The profile needs to be set up on both the Substrate diffuse node, and the material node at the moment.
    """
    @property
    def subsurface_profile(self) -> SubsurfaceProfile:
        r"""
        (SubsurfaceProfile):  [Read-Only] SubsurfaceProfile, for Screen Space Subsurface Scattering. The profile needs to be set up on both the Substrate diffuse node, and the material node at the moment.
        """
        ...

class MaterialExpressionStrataLegacyConversion(MaterialExpressionSubstrateShadingModels):
    r"""
    deprecated: 'MaterialExpressionStrataLegacyConversion' was renamed to 'MaterialExpressionSubstrateShadingModels'.
    """
    ...

class MaterialExpressionSubstrateSlabBSDF(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Slab BSDF
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``specular_profile`` (SpecularProfile):  [Read-Write] SpecularProfile, for modulating specular appearance and simulating more complex visuals such as iridescence.
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Screen Space Subsurface Scattering. The profile needs to be set up on both the Substrate diffuse node, and the material node at the moment.
    - ``use_sss_diffusion`` (bool):  [Read-Write] Whether to use light diffusion (i.e., SSS diffusion) or wrap-approximation for material with scattering behavior. This option trades quality over performance and will result into visual differences.
    """
    @property
    def subsurface_profile(self) -> SubsurfaceProfile:
        r"""
        (SubsurfaceProfile):  [Read-Only] SubsurfaceProfile, for Screen Space Subsurface Scattering. The profile needs to be set up on both the Substrate diffuse node, and the material node at the moment.
        """
        ...
    @property
    def specular_profile(self) -> SpecularProfile:
        r"""
        (SpecularProfile):  [Read-Only] SpecularProfile, for modulating specular appearance and simulating more complex visuals such as iridescence.
        """
        ...

class MaterialExpressionStrataSlabBSDF(MaterialExpressionSubstrateSlabBSDF):
    r"""
    deprecated: 'MaterialExpressionStrataSlabBSDF' was renamed to 'MaterialExpressionSubstrateSlabBSDF'.
    """
    ...

class MaterialExpressionSubstrateSimpleClearCoatBSDF(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Simple Clear Coat BSDF
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataSimpleClearCoatBSDF(MaterialExpressionSubstrateSimpleClearCoatBSDF):
    r"""
    deprecated: 'MaterialExpressionStrataSimpleClearCoatBSDF' was renamed to 'MaterialExpressionSubstrateSimpleClearCoatBSDF'.
    """
    ...

class MaterialExpressionSubstrateVolumetricFogCloudBSDF(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Volumetric Fog Cloud BSDF
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataVolumetricFogCloudBSDF(MaterialExpressionSubstrateVolumetricFogCloudBSDF):
    r"""
    deprecated: 'MaterialExpressionStrataVolumetricFogCloudBSDF' was renamed to 'MaterialExpressionSubstrateVolumetricFogCloudBSDF'.
    """
    ...

class MaterialExpressionSubstrateUnlitBSDF(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Unlit BSDF
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataUnlitBSDF(MaterialExpressionSubstrateUnlitBSDF):
    r"""
    deprecated: 'MaterialExpressionStrataUnlitBSDF' was renamed to 'MaterialExpressionSubstrateUnlitBSDF'.
    """
    ...

class MaterialExpressionSubstrateHairBSDF(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Hair BSDF
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataHairBSDF(MaterialExpressionSubstrateHairBSDF):
    r"""
    deprecated: 'MaterialExpressionStrataHairBSDF' was renamed to 'MaterialExpressionSubstrateHairBSDF'.
    """
    ...

class MaterialExpressionSubstrateEyeBSDF(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Eye BSDF
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Subsurface Scattering diffusion.
    """
    @property
    def subsurface_profile(self) -> SubsurfaceProfile:
        r"""
        (SubsurfaceProfile):  [Read-Only] SubsurfaceProfile, for Subsurface Scattering diffusion.
        """
        ...

class MaterialExpressionStrataEyeBSDF(MaterialExpressionSubstrateEyeBSDF):
    r"""
    deprecated: 'MaterialExpressionStrataEyeBSDF' was renamed to 'MaterialExpressionSubstrateEyeBSDF'.
    """
    ...

class MaterialExpressionSubstrateSingleLayerWaterBSDF(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Single Layer Water BSDF
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataSingleLayerWaterBSDF(MaterialExpressionSubstrateSingleLayerWaterBSDF):
    r"""
    deprecated: 'MaterialExpressionStrataSingleLayerWaterBSDF' was renamed to 'MaterialExpressionSubstrateSingleLayerWaterBSDF'.
    """
    ...

class MaterialExpressionSubstrateLightFunction(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Light Function
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataLightFunction(MaterialExpressionSubstrateLightFunction):
    r"""
    deprecated: 'MaterialExpressionStrataLightFunction' was renamed to 'MaterialExpressionSubstrateLightFunction'.
    """
    ...

class MaterialExpressionSubstratePostProcess(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Post Process
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataPostProcess(MaterialExpressionSubstratePostProcess):
    r"""
    deprecated: 'MaterialExpressionStrataPostProcess' was renamed to 'MaterialExpressionSubstratePostProcess'.
    """
    ...

class MaterialExpressionSubstrateUI(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate UI
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataUI(MaterialExpressionSubstrateUI):
    r"""
    deprecated: 'MaterialExpressionStrataUI' was renamed to 'MaterialExpressionSubstrateUI'.
    """
    ...

class MaterialExpressionSubstrateConvertToDecal(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Convert to Decal
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataConvertToDecal(MaterialExpressionSubstrateConvertToDecal):
    r"""
    deprecated: 'MaterialExpressionStrataConvertToDecal' was renamed to 'MaterialExpressionSubstrateConvertToDecal'.
    """
    ...

class MaterialExpressionSubstrateConvertMaterialAttributes(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Convert Material Attributes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``shading_model_override`` (MaterialShadingModel):  [Read-Write]
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Screen Space Subsurface Scattering. The profile needs to be set up on both the Substrate diffuse node, and the material node at the moment.
    """
    @property
    def subsurface_profile(self) -> SubsurfaceProfile:
        r"""
        (SubsurfaceProfile):  [Read-Only] SubsurfaceProfile, for Screen Space Subsurface Scattering. The profile needs to be set up on both the Substrate diffuse node, and the material node at the moment.
        """
        ...

class MaterialExpressionSubstrateHorizontalMixing(MaterialExpressionSubstrateBSDF):
    r"""
    /
     Operator nodes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``use_parameter_blending`` (bool):  [Read-Write] Merge Background and Foreground into a single material by mixing their inputs rather than their evaluation. This makes lighting evaluation cheaper (Default: off)
    """
    ...

class MaterialExpressionStrataHorizontalMixing(MaterialExpressionSubstrateHorizontalMixing):
    r"""
    deprecated: 'MaterialExpressionStrataHorizontalMixing' was renamed to 'MaterialExpressionSubstrateHorizontalMixing'.
    """
    ...

class MaterialExpressionSubstrateVerticalLayering(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Vertical Layering
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``use_parameter_blending`` (bool):  [Read-Write] Merge Top and Base into a single material by mixing their inputs rather than their evaluation. This makes lighting evaluation cheaper (Default: off)
    """
    ...

class MaterialExpressionStrataVerticalLayering(MaterialExpressionSubstrateVerticalLayering):
    r"""
    deprecated: 'MaterialExpressionStrataVerticalLayering' was renamed to 'MaterialExpressionSubstrateVerticalLayering'.
    """
    ...

class MaterialExpressionSubstrateAdd(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Add
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``use_parameter_blending`` (bool):  [Read-Write] Merge A and B into a single material by mixing their inputs rather than their evaluation. This makes lighting evaluation cheaper (Default: off)
    """
    ...

class MaterialExpressionStrataAdd(MaterialExpressionSubstrateAdd):
    r"""
    deprecated: 'MaterialExpressionStrataAdd' was renamed to 'MaterialExpressionSubstrateAdd'.
    """
    ...

class MaterialExpressionSubstrateWeight(MaterialExpressionSubstrateBSDF):
    r"""
    Material Expression Substrate Weight
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataWeight(MaterialExpressionSubstrateWeight):
    r"""
    deprecated: 'MaterialExpressionStrataWeight' was renamed to 'MaterialExpressionSubstrateWeight'.
    """
    ...

class MaterialExpressionSubstrateUtilityBase(MaterialExpression):
    r"""
    /
     Utilities
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataUtilityBase(MaterialExpressionSubstrateUtilityBase):
    r"""
    deprecated: 'MaterialExpressionStrataUtilityBase' was renamed to 'MaterialExpressionSubstrateUtilityBase'.
    """
    ...

class MaterialExpressionSubstrateTransmittanceToMFP(MaterialExpressionSubstrateUtilityBase):
    r"""
    Material Expression Substrate Transmittance to MFP
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataTransmittanceToMFP(MaterialExpressionSubstrateTransmittanceToMFP):
    r"""
    deprecated: 'MaterialExpressionStrataTransmittanceToMFP' was renamed to 'MaterialExpressionSubstrateTransmittanceToMFP'.
    """
    ...

class MaterialExpressionSubstrateMetalnessToDiffuseAlbedoF0(MaterialExpressionSubstrateUtilityBase):
    r"""
    Material Expression Substrate Metalness to Diffuse Albedo F0
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataMetalnessToDiffuseAlbedoF0(MaterialExpressionSubstrateMetalnessToDiffuseAlbedoF0):
    r"""
    deprecated: 'MaterialExpressionStrataMetalnessToDiffuseAlbedoF0' was renamed to 'MaterialExpressionSubstrateMetalnessToDiffuseAlbedoF0'.
    """
    ...

class MaterialExpressionSubstrateHazinessToSecondaryRoughness(MaterialExpressionSubstrateUtilityBase):
    r"""
    Material Expression Substrate Haziness to Secondary Roughness
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataHazinessToSecondaryRoughness(MaterialExpressionSubstrateHazinessToSecondaryRoughness):
    r"""
    deprecated: 'MaterialExpressionStrataHazinessToSecondaryRoughness' was renamed to 'MaterialExpressionSubstrateHazinessToSecondaryRoughness'.
    """
    ...

class MaterialExpressionSubstrateThinFilm(MaterialExpressionSubstrateUtilityBase):
    r"""
    Material Expression Substrate Thin Film
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubstrate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionStrataThinFilm(MaterialExpressionSubstrateThinFilm):
    r"""
    deprecated: 'MaterialExpressionStrataThinFilm' was renamed to 'MaterialExpressionSubstrateThinFilm'.
    """
    ...

class MaterialExpressionSubsurfaceMediumMaterialOutput(MaterialExpressionCustomOutput):
    r"""
    Material output expression for setting the mean free path and scattering distribution properties of subsurface profile (for the Path Tracer Only).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubsurfaceMediumMaterialOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSubtract(MaterialExpression):
    r"""
    Material Expression Subtract
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSubtract.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_a`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_b`` (float):  [Read-Write] only used if B is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSwitch(MaterialExpression):
    r"""
    Material Expression Switch
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_default`` (float):  [Read-Write] only used if Selector is not hooked up
    - ``const_switch_value`` (float):  [Read-Write] only used if Selector is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``description`` (str):  [Read-Write]
    - ``inputs`` (Array[SwitchCustomInput]):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionTangent(MaterialExpression):
    r"""
    Material Expression Tangent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTangent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``period`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionTangentOutput(MaterialExpressionCustomOutput):
    r"""
    Material Expression Tangent Output
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTangentOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionTemporalSobol(MaterialExpression):
    r"""
    Material Expression Temporal Sobol
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTemporalSobol.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_index`` (uint32):  [Read-Write] Sobol point number. Only used if Index is not connected.
    - ``const_seed`` (Vector2D):  [Read-Write] 2D Seed for sequence randomization. Only used if Seed is not connected.
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionTextureCoordinate(MaterialExpression):
    r"""
    Material Expression Texture Coordinate
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureCoordinate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``coordinate_index`` (int32):  [Read-Write] Texture coordinate index
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``u_tiling`` (float):  [Read-Write] Controls how much the texture tiles horizontally, by scaling the U component of the vertex UVs by the specified amount.
    - ``un_mirror_u`` (bool):  [Read-Write] Would like to unmirror U or V
      - if the texture is mirrored and if you would like to undo mirroring for this texture sample, use this to unmirror
    - ``un_mirror_v`` (bool):  [Read-Write]
    - ``v_tiling`` (float):  [Read-Write] Controls how much the texture tiles vertically, by scaling the V component of the vertex UVs by the specified amount.
    """
    @property
    def coordinate_index(self) -> int:
        r"""
        (int32):  [Read-Write] Texture coordinate index
        """
        ...
    @coordinate_index.setter
    def coordinate_index(self, value: int) -> None:
        ...
    @property
    def u_tiling(self) -> float:
        r"""
        (float):  [Read-Write] Controls how much the texture tiles horizontally, by scaling the U component of the vertex UVs by the specified amount.
        """
        ...
    @u_tiling.setter
    def u_tiling(self, value: float) -> None:
        ...
    @property
    def v_tiling(self) -> float:
        r"""
        (float):  [Read-Write] Controls how much the texture tiles vertically, by scaling the V component of the vertex UVs by the specified amount.
        """
        ...
    @v_tiling.setter
    def v_tiling(self, value: float) -> None:
        ...

class MaterialExpressionTextureObject(MaterialExpressionTextureBase):
    r"""
    Material Expression Texture Object
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionTextureObjectParameter(MaterialExpressionTextureSampleParameter):
    r"""
    Material Expression Texture Object Parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureObjectParameter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``parameter_name`` (Name):  [Read-Write]
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionTextureProperty(MaterialExpression):
    r"""
    Material Expression Texture Property
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureProperty.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``property_`` (MaterialExposedTextureProperty):  [Read-Write] Texture property to be accessed
    """
    ...

class MaterialExpressionTextureSampleParameter2DArray(MaterialExpressionTextureSampleParameter):
    r"""
    Material Expression Texture Sample Parameter 2DArray
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureSampleParameter2DArray.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``parameter_name`` (Name):  [Read-Write]
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionTextureSampleParameterCube(MaterialExpressionTextureSampleParameter):
    r"""
    Material Expression Texture Sample Parameter Cube
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureSampleParameterCube.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``parameter_name`` (Name):  [Read-Write]
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionTextureSampleParameterCubeArray(MaterialExpressionTextureSampleParameter):
    r"""
    Material Expression Texture Sample Parameter Cube Array
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureSampleParameterCubeArray.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``parameter_name`` (Name):  [Read-Write]
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionTextureSampleParameterSubUV(MaterialExpressionTextureSampleParameter2D):
    r"""
    Material Expression Texture Sample Parameter Sub UV
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureSampleParameterSubUV.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``blend`` (bool):  [Read-Write]
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``parameter_name`` (Name):  [Read-Write]
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionTextureSampleParameterVolume(MaterialExpressionTextureSampleParameter):
    r"""
    Material Expression Texture Sample Parameter Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTextureSampleParameterVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``parameter_name`` (Name):  [Read-Write]
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionThinTranslucentMaterialOutput(MaterialExpressionCustomOutput):
    r"""
    Material output expression for setting absorption properties of thin translucent materials.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionThinTranslucentMaterialOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionTime(MaterialExpression):
    r"""
    Material Expression Time
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTime.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``ignore_pause`` (bool):  [Read-Write] This time continues advancing regardless of whether the game is paused.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``override_period`` (bool):  [Read-Write] Enables or disables the Period value.
    - ``period`` (float):  [Read-Write] Period at which to wrap around time
    """
    ...

class MaterialExpressionTransform(MaterialExpression):
    r"""
    Material Expression Transform
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``transform_source_type`` (MaterialVectorCoordTransformSource):  [Read-Write] Source coordinate space of the FVector
    - ``transform_type`` (MaterialVectorCoordTransform):  [Read-Write] Destination coordinate space of the FVector
    """
    ...

class MaterialExpressionTransformPosition(MaterialExpression):
    r"""
    Material Expression Transform Position
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTransformPosition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``transform_source_type`` (MaterialPositionTransformSource):  [Read-Write] source format of the position that will be transformed
    - ``transform_type`` (MaterialPositionTransformSource):  [Read-Write] type of transform to apply to the input expression
    """
    ...

class MaterialExpressionTruncate(MaterialExpression):
    r"""
    Material Expression Truncate
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTruncate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionTruncateLWC(MaterialExpression):
    r"""
    Material Expression Truncate LWC
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTruncateLWC.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionTwoSidedSign(MaterialExpression):
    r"""
    Material Expression Two Sided Sign
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionTwoSidedSign.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionVectorNoise(MaterialExpression):
    r"""
    Material Expression Vector Noise
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVectorNoise.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``noise_function`` (VectorNoiseFunction):  [Read-Write] Noise function, affects performance and look
    - ``quality`` (int32):  [Read-Write] For noise functions where applicable, lower numbers are faster and lower quality, higher numbers are slower and higher quality
    - ``tile_size`` (uint32):  [Read-Write] How many units in each tile (if Tiling is on)
      For Perlin noise functions, Tile Size must be a multiple of three
    - ``tiling`` (bool):  [Read-Write] Whether tile the noise pattern, useful for baking to seam-free repeating textures
    - ``world_position_origin_type`` (PositionOrigin):  [Read-Write] Defines the reference space for the Position input.
    """
    ...

class MaterialExpressionVertexColor(MaterialExpression):
    r"""
    Material Expression Vertex Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVertexColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionVertexInterpolator(MaterialExpressionCustomOutput):
    r"""
    Material Expression Vertex Interpolator
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVertexInterpolator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionVertexNormalWS(MaterialExpression):
    r"""
    Material Expression Vertex Normal WS
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVertexNormalWS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionVertexTangentWS(MaterialExpression):
    r"""
    Material Expression Vertex Tangent WS
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVertexTangentWS.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionViewProperty(MaterialExpression):
    r"""
    Material Expression View Property
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionViewProperty.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``property_`` (MaterialExposedViewProperty):  [Read-Write] View input property to be accessed
    """
    ...

class MaterialExpressionViewSize(MaterialExpression):
    r"""
    Material Expression View Size
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionViewSize.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionVirtualTextureFeatureSwitch(MaterialExpression):
    r"""
    Material output expression to switch logic according to whether virtual texturing is supported on this project, platform and feature level.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVirtualTextureFeatureSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionVolumetricAdvancedMaterialInput(MaterialExpression):
    r"""
    Material Expression Volumetric Advanced Material Input
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVolumetricAdvancedMaterialInput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionVolumetricCloudEmptySpaceSkippingInput(MaterialExpression):
    r"""
    Material Expression Volumetric Cloud Empty Space Skipping Input
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVolumetricAdvancedMaterialInput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionVolumetricAdvancedMaterialOutput(MaterialExpressionCustomOutput):
    r"""
    Material output expression for writing advanced volumetric material properties.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVolumetricAdvancedMaterialOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clamp_multi_scattering_contribution`` (bool):  [Read-Write] Set whether multiple scattering contribution entry is clamped in [0,1] or not. When disabled, the artist is in charge for ensuring the visual remain in a reasonable brighness range.
    - ``const_multi_scattering_contribution`` (float):  [Read-Write] Only used if MultiScatteringContribution is not hooked up. Multi-scattering approximation: represents how much contribution each successive octave will add. Valid range is [0,1], from low to high contribution
    - ``const_multi_scattering_eccentricity`` (float):  [Read-Write] Only used if MultiScatteringEccentricity is not hooked up. Multi-scattering approximation: represents how much the phase will become isotropic for each successive octave. Valid range is [0,1], from anisotropic to isotropic phase.
    - ``const_multi_scattering_occlusion`` (float):  [Read-Write] Only used if MultiScatteringOcclusion is not hooked up. Multi-scattering approximation: represents how much occlusion will be reduced for each successive octave. Valid range is [0,1], from low to high occlusion.
    - ``const_phase_blend`` (float):  [Read-Write] Only used if PhaseBlend is not hooked up. Lerp factor when blending the two phase functions parameterized by G and G2. Valid range is [0,1].
    - ``const_phase_g`` (float):  [Read-Write] Only used if PhaseG is not hooked up. Parameter 'g' input to the phase function  describing how much forward(g<0) or backward (g>0) light scatter around.
    - ``const_phase_g2`` (float):  [Read-Write] Only used if PhaseG2 is not hooked up. Parameter 'g' input to the second phase function  describing how much forward(g<0) or backward (g>0) light scatter around. Valid range is [-1,1].
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``gray_scale_material`` (bool):  [Read-Write] Set this for the material to only be considered grey scale, only using the R chanel of the input parameters internally. The lighting will still be colored. This is an optimisation.
    - ``ground_contribution`` (bool):  [Read-Write] Sample the shadowed lighting contribution from the ground onto the medium (single scattering). This adds some costs to the tracing when enabled.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``multi_scattering_approximation_octave_count`` (uint32):  [Read-Write] How many octave to use for the multiple-scattering approximation. This makes the shader more expensive so you should only use 0 or 1 for better performance, and tweak multiple scattering parameters accordingly. 0 means single scattering only. The maximum value is 2 (expenssive).
    - ``per_sample_phase_evaluation`` (bool):  [Read-Write] Set this to true to force the phase function to be evaluated per sample, instead once per pixel (globally). Per sample evaluation is slower.
    - ``ray_march_volume_shadow`` (bool):  [Read-Write] Disable this to use the cloud shadow map instead of secondary raymarching. This is usually enough for clouds viewed from the ground and it result in a performance boost. Shadow now have infinite length but also becomes less accurate and gray scale.
    """
    ...

class MaterialExpressionVolumetricCloudEmptySpaceSkippingOutput(MaterialExpressionCustomOutput):
    r"""
    USed to help the cloud system to fast skip empty space areas when ray marching.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionVolumetricAdvancedMaterialOutput.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionWhileLoop(MaterialExpression):
    r"""
    Material Expression While Loop
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionWhileLoop.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionWorldPosition(MaterialExpression):
    r"""
    Material Expression World Position
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialExpressionWorldPosition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``world_position_shader_offset`` (WorldPositionIncludedOffsets):  [Read-Write]
    """
    ...

class MaterialFunctionInterface(Object):
    r"""
    A Material Function is a collection of material expressions that can be reused in different materials
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialFunctionInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    ...

class MaterialFunction(MaterialFunctionInterface):
    r"""
    A Material Function is a collection of material expressions that can be reused in different materials
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialFunction.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``description`` (str):  [Read-Write] Description of the function which will be displayed as a tooltip wherever the function is used.
    - ``enable_exec_wire`` (bool):  [Read-Write]
    - ``enable_new_hlsl_generator`` (bool):  [Read-Write]
    - ``expose_to_library`` (bool):  [Read-Write] Whether to list this function in the material function library, which is a window in the material editor that lists categorized functions.
    - ``library_categories_text`` (Array[Text]):  [Read-Write] Categories that this function belongs to in the material function library.
      Ideally categories should be chosen carefully so that there are not too many.
    - ``prefix_parameter_names`` (bool):  [Read-Write] If true, parameters in this function will have a prefix added to their group name.
    - ``preview_blend_mode`` (BlendMode):  [Read-Write] Determines the blend mode when previewing a material function.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``user_exposed_caption`` (str):  [Read-Write] Name of the function to be displayed on the node within the material editor instead of the asset name.
    """
    ...

class MaterialFunctionInstance(MaterialFunctionInterface):
    r"""
    A material function instance defines parameter overrides for a parent material function.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialFunctionInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``double_vector_parameter_values`` (Array[DoubleVectorParameterValue]):  [Read-Write] DoubleVector parameters.
    - ``font_parameter_values`` (Array[FontParameterValue]):  [Read-Write] Font parameters.
    - ``parent`` (MaterialFunctionInterface):  [Read-Write] Parent function.
    - ``runtime_virtual_texture_parameter_values`` (Array[RuntimeVirtualTextureParameterValue]):  [Read-Write] Runtime virtual texture parameters.
    - ``scalar_parameter_values`` (Array[ScalarParameterValue]):  [Read-Write] Scalar parameters.
    - ``sparse_volume_texture_parameter_values`` (Array[SparseVolumeTextureParameterValue]):  [Read-Write] Sparse volume texture parameters.
    - ``static_component_mask_parameter_values`` (Array[StaticComponentMaskParameter]):  [Read-Write] Static component mask parameters.
    - ``static_switch_parameter_values`` (Array[StaticSwitchParameter]):  [Read-Write] Static switch parameters.
    - ``texture_parameter_values`` (Array[TextureParameterValue]):  [Read-Write] Texture parameters.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``vector_parameter_values`` (Array[VectorParameterValue]):  [Read-Write] Vector parameters.
    """
    @property
    def parent(self) -> MaterialFunctionInterface:
        r"""
        (MaterialFunctionInterface):  [Read-Only] Parent function.
        """
        ...

class MaterialFunctionMaterialLayer(MaterialFunction):
    r"""
    Specialized Material Function that acts as a layer
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialFunctionMaterialLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``description`` (str):  [Read-Write] Description of the function which will be displayed as a tooltip wherever the function is used.
    - ``enable_exec_wire`` (bool):  [Read-Write]
    - ``enable_new_hlsl_generator`` (bool):  [Read-Write]
    - ``expose_to_library`` (bool):  [Read-Write] Whether to list this function in the material function library, which is a window in the material editor that lists categorized functions.
    - ``library_categories_text`` (Array[Text]):  [Read-Write] Categories that this function belongs to in the material function library.
      Ideally categories should be chosen carefully so that there are not too many.
    - ``prefix_parameter_names`` (bool):  [Read-Write] If true, parameters in this function will have a prefix added to their group name.
    - ``preview_blend_mode`` (BlendMode):  [Read-Write] Determines the blend mode when previewing a material function.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``user_exposed_caption`` (str):  [Read-Write] Name of the function to be displayed on the node within the material editor instead of the asset name.
    """
    ...

class MaterialFunctionMaterialLayerInstance(MaterialFunctionInstance):
    r"""
    Specialized Material Function Instance that instances a layer
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialFunctionMaterialLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``double_vector_parameter_values`` (Array[DoubleVectorParameterValue]):  [Read-Write] DoubleVector parameters.
    - ``font_parameter_values`` (Array[FontParameterValue]):  [Read-Write] Font parameters.
    - ``parent`` (MaterialFunctionInterface):  [Read-Write] Parent function.
    - ``runtime_virtual_texture_parameter_values`` (Array[RuntimeVirtualTextureParameterValue]):  [Read-Write] Runtime virtual texture parameters.
    - ``scalar_parameter_values`` (Array[ScalarParameterValue]):  [Read-Write] Scalar parameters.
    - ``sparse_volume_texture_parameter_values`` (Array[SparseVolumeTextureParameterValue]):  [Read-Write] Sparse volume texture parameters.
    - ``static_component_mask_parameter_values`` (Array[StaticComponentMaskParameter]):  [Read-Write] Static component mask parameters.
    - ``static_switch_parameter_values`` (Array[StaticSwitchParameter]):  [Read-Write] Static switch parameters.
    - ``texture_parameter_values`` (Array[TextureParameterValue]):  [Read-Write] Texture parameters.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``vector_parameter_values`` (Array[VectorParameterValue]):  [Read-Write] Vector parameters.
    """
    ...

class MaterialFunctionMaterialLayerBlend(MaterialFunction):
    r"""
    Specialized Material Function that acts as a blend
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialFunctionMaterialLayerBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``description`` (str):  [Read-Write] Description of the function which will be displayed as a tooltip wherever the function is used.
    - ``enable_exec_wire`` (bool):  [Read-Write]
    - ``enable_new_hlsl_generator`` (bool):  [Read-Write]
    - ``expose_to_library`` (bool):  [Read-Write] Whether to list this function in the material function library, which is a window in the material editor that lists categorized functions.
    - ``library_categories_text`` (Array[Text]):  [Read-Write] Categories that this function belongs to in the material function library.
      Ideally categories should be chosen carefully so that there are not too many.
    - ``prefix_parameter_names`` (bool):  [Read-Write] If true, parameters in this function will have a prefix added to their group name.
    - ``preview_blend_mode`` (BlendMode):  [Read-Write] Determines the blend mode when previewing a material function.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``user_exposed_caption`` (str):  [Read-Write] Name of the function to be displayed on the node within the material editor instead of the asset name.
    """
    ...

class MaterialFunctionMaterialLayerBlendInstance(MaterialFunctionInstance):
    r"""
    Specialized Material Function Instance that instances a blend
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialFunctionMaterialLayerBlend.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``double_vector_parameter_values`` (Array[DoubleVectorParameterValue]):  [Read-Write] DoubleVector parameters.
    - ``font_parameter_values`` (Array[FontParameterValue]):  [Read-Write] Font parameters.
    - ``parent`` (MaterialFunctionInterface):  [Read-Write] Parent function.
    - ``runtime_virtual_texture_parameter_values`` (Array[RuntimeVirtualTextureParameterValue]):  [Read-Write] Runtime virtual texture parameters.
    - ``scalar_parameter_values`` (Array[ScalarParameterValue]):  [Read-Write] Scalar parameters.
    - ``sparse_volume_texture_parameter_values`` (Array[SparseVolumeTextureParameterValue]):  [Read-Write] Sparse volume texture parameters.
    - ``static_component_mask_parameter_values`` (Array[StaticComponentMaskParameter]):  [Read-Write] Static component mask parameters.
    - ``static_switch_parameter_values`` (Array[StaticSwitchParameter]):  [Read-Write] Static switch parameters.
    - ``texture_parameter_values`` (Array[TextureParameterValue]):  [Read-Write] Texture parameters.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``vector_parameter_values`` (Array[VectorParameterValue]):  [Read-Write] Vector parameters.
    """
    ...

class NetworkPhysicsSettingsComponent(ActorComponent):
    r"""
    USTRUCT()
    struct FNetworkPhysicsSettingsRewindData
    {
           GENERATED_BODY()
    };
    
    USTRUCT()
    struct FNetworkPhysicsSettingsRenderInterpolation
    {
           GENERATED_BODY()
    };
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NetworkPhysicsSettingsComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``general_settings`` (NetworkPhysicsSettings):  [Read-Write]
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``predictive_interpolation_settings`` (NetworkPhysicsSettingsPredictiveInterpolation):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``resimulation_settings`` (NetworkPhysicsSettingsResimulation):  [Read-Write]
    """
    ...

class FXSystemAsset(Object):
    r"""
    FXSystem Asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max_pool_size`` (uint32):  [Read-Write] Max number of components of this system to keep resident in the world component pool.
    - ``pool_prime_size`` (uint32):  [Read-Write] How many instances we should use to initially prime the pool.
      This can amortize runtime activation cost by moving it to load time.
      Use with care as this could cause large hitches for systems loaded/unloaded during play rather than at level load.
    """
    ...

class ParticleSystem(FXSystemAsset):
    r"""
    A ParticleSystem is a complete particle effect that contains any number of ParticleEmitters. By allowing multiple emitters
    in a system, the designer can create elaborate particle effects that are held in a single system. Once created using
    Cascade, a ParticleSystem can then be inserted into a level or created in script.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_managed_ticking`` (bool):  [Read-Write] Whether or not to allow instances of this system to have their ticks managed.
    - ``auto_deactivate`` (bool):  [Read-Write] Auto-deactivate system if all emitters are determined to not spawn particles again, regardless of lifetime.
    - ``custom_occlusion_bounds`` (Box):  [Read-Write] The occlusion bounds to use if OcclusionBoundsMethod is set to EPSOBM_CustomBounds
    - ``delay`` (float):  [Read-Write] How long this Particle system should delay when ActivateSystem is called on it.
    - ``delay_low`` (float):  [Read-Write] The low end of the emitter delay if using a range.
    - ``fixed_relative_bounding_box`` (Box):  [Read-Write] Fixed relative bounding box for particle system.
    - ``insignificance_delay`` (float):  [Read-Write] Time delay between all emitters becoming insignificant and the systems insignificant reaction.
    - ``insignificant_reaction`` (ParticleSystemInsignificanceReaction):  [Read-Write] The reaction this system takes when all emitters are insignificant.
    - ``lod_distance_check_time`` (float):  [Read-Write] How often (in seconds) the system should perform the LOD distance check.
    - ``lod_distances`` (Array[float]):  [Read-Write] The array of distances for each LOD level in the system.
      Used when LODMethod is set to PARTICLESYSTEMLODMETHOD_Automatic.
      
      Example: System with 3 LOD levels
              LODDistances(0) = 0.0
              LODDistances(1) = 2500.0
              LODDistances(2) = 5000.0
      
              In this case, when the system is [   0.0 ..   2499.9] from the camera, LOD level 0 will be used.
                                                                               [2500.0 ..   4999.9] from the camera, LOD level 1 will be used.
                                                                               [5000.0 .. INFINITY] from the camera, LOD level 2 will be used.
    - ``lod_method`` (ParticleSystemLODMethod):  [Read-Write] The method of LOD level determination to utilize for this particle system
        PARTICLESYSTEMLODMETHOD_Automatic - Automatically set the LOD level, checking every LODDistanceCheckTime seconds.
      PARTICLESYSTEMLODMETHOD_DirectSet - LOD level is directly set by the game code.
      PARTICLESYSTEMLODMETHOD_ActivateAutomatic - LOD level is determined at Activation time, then left alone unless directly set by game code.
    - ``lod_settings`` (Array[ParticleSystemLOD]):  [Read-Write]
    - ``macro_uv_position`` (Vector):  [Read-Write] Local space position that UVs generated with the ParticleMacroUV material node will be centered on.
    - ``macro_uv_radius`` (float):  [Read-Write] World space radius that UVs generated with the ParticleMacroUV material node will tile based on.
    - ``max_pool_size`` (uint32):  [Read-Write] Max number of components of this system to keep resident in the world component pool.
    - ``max_significance_level`` (ParticleSignificanceLevel):  [Read-Write] The maximum level of significance for emitters in this system. Any emitters with a higher significance will be capped at this significance level.
    - ``min_time_between_ticks`` (uint32):  [Read-Write] Minimum duration between ticks; 33=tick at max. 30FPS, 16=60FPS, 8=120FPS
    - ``named_material_slots`` (Array[NamedEmitterMaterial]):  [Read-Write] Array of named material slots for use by emitters of this system.
      Emitters can use these instead of their own materials by providing the name to the NamedMaterialOverrides property of their required module.
      These materials can be overridden using CreateNamedDynamicMaterialInstance() on a ParticleSystemComponent.
    - ``occlusion_bounds_method`` (ParticleSystemOcclusionBoundsMethod):  [Read-Write] Which occlusion bounds method to use for this particle system.
      EPSOBM_None - Don't determine occlusion for this system.
      EPSOBM_ParticleBounds - Use the bounds of the component when determining occlusion.
    - ``orient_z_axis_toward_camera`` (bool):  [Read-Write] If true, the system's Z axis will be oriented toward the camera
    - ``pool_prime_size`` (uint32):  [Read-Write] How many instances we should use to initially prime the pool.
      This can amortize runtime activation cost by moving it to load time.
      Use with care as this could cause large hitches for systems loaded/unloaded during play rather than at level load.
    - ``seconds_before_inactive`` (float):  [Read-Write] Number of seconds of emitter not being rendered that need to pass before it
      no longer gets ticked/ becomes inactive.
    - ``system_update_mode`` (ParticleSystemUpdateMode):  [Read-Write]
    - ``thumbnail_warmup`` (float):  [Read-Write] The time to warm-up the system for the thumbnail image
    - ``update_time_fps`` (float):  [Read-Write] UpdateTime_FPS - the frame per second to update at in FixedTime mode
    - ``use_delay_range`` (bool):  [Read-Write] If true, select the emitter delay from the range
              [DelayLow..Delay]
    - ``use_fixed_relative_bounding_box`` (bool):  [Read-Write] Whether to use the fixed relative bounding box or calculate it every frame.
    - ``use_realtime_thumbnail`` (bool):  [Read-Write] Inidicates the old 'real-time' thumbnail rendering should be used
    - ``warmup_tick_rate`` (float):  [Read-Write] WarmupTickRate - the time step for each tick during warm up.
             Increasing this improves performance. Decreasing, improves accuracy.
             Set to 0 to use the default tick time.
    - ``warmup_time`` (float):  [Read-Write] WarmupTime - the time to warm-up the particle system when first rendered
      Warning: WarmupTime is implemented by simulating the particle system for the time requested upon activation.
      This is extremely prone to cause hitches, especially with large particle counts - use with caution.
    """
    def contains_emitter_type(self, type_data: Class) -> bool:
        r"""
        x.contains_emitter_type(type_data) -> bool
        Returns true if this system contains an emitter of the pasesd type.
        
        Args:
            type_data (type(Class)): The emitter type to check for. Must be a child class of UParticleModuleTypeDataBase
        
        Returns:
            bool:
        """
        ...

class ParticleModule(Object):
    r"""
    Particle Module
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleModule.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``b3d_draw_mode`` (bool):  [Read-Write] If true, the module should render its 3D visualization helper
    - ``module_editor_color`` (Color):  [Read-Write] The color to draw the modules curves in the curve editor.
          If bCurvesAsColor is true, it overrides this value.
    """
    ...

class ParticleModuleLightBase(ParticleModule):
    r"""
    Particle Module Light Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleModuleLightBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``b3d_draw_mode`` (bool):  [Read-Write] If true, the module should render its 3D visualization helper
    - ``module_editor_color`` (Color):  [Read-Write] The color to draw the modules curves in the curve editor.
          If bCurvesAsColor is true, it overrides this value.
    """
    ...

class ParticleModuleLight(ParticleModuleLightBase):
    r"""
    Particle Module Light
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleModuleLight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affects_translucency`` (bool):  [Read-Write] Whether lights from this module should affect translucency.
      Use with caution.  Modules enabling this should only make a few particle lights at most, and the smaller they are, the less they will cost.
    - ``b3d_draw_mode`` (bool):  [Read-Write] If true, the module should render its 3D visualization helper
    - ``brightness_over_life`` (RawDistributionFloat):  [Read-Write] Brightness scale for the light, which can be setup as a curve over the particle's lifetime.
    - ``color_scale_over_life`` (RawDistributionVector):  [Read-Write] Scale that is applied to the particle's color to calculate the light's color, and can be setup as a curve over the particle's lifetime.
    - ``high_quality_lights`` (bool):  [Read-Write] Converts the particle lights into high quality lights as if they came from a PointLightComponent.  High quality lights cost significantly more on both CPU and GPU.
    - ``inverse_exposure_blend`` (float):  [Read-Write] Blend Factor used to blend between Intensity and Intensity/Exposure.
      This is useful for gameplay lights that should have constant brighness on screen independent of current exposure.
      This feature can cause issues with exposure particularly when used on the primary light on a scene, as such it's usage should be limited.
    - ``light_exponent`` (RawDistributionFloat):  [Read-Write] Provides the light's exponent when inverse squared falloff is disabled.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this light should affect.
      Only affect high quality lights
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``module_editor_color`` (Color):  [Read-Write] The color to draw the modules curves in the curve editor.
          If bCurvesAsColor is true, it overrides this value.
    - ``override_inverse_exposure_blend`` (bool):  [Read-Write] When enabled we will override the project default setting with our local setting.
    - ``preview_light_radius`` (bool):  [Read-Write] Will draw wireframe spheres to preview the light radius if enabled.
      Note: this is intended for previewing and the value will not be saved, it will always revert to disabled.
    - ``radius_scale`` (RawDistributionFloat):  [Read-Write] Scales the particle's radius, to calculate the light's radius.
    - ``shadow_casting_lights`` (bool):  [Read-Write] Whether to cast shadows from the particle lights.  Requires High Quality Lights to be enabled.
      Warning: This can be incredibly expensive on the GPU - use with caution.
    - ``spawn_fraction`` (float):  [Read-Write] Fraction of particles in this emitter to create lights on.
    - ``use_inverse_squared_falloff`` (bool):  [Read-Write] Whether to use physically based inverse squared falloff from the light.  If unchecked, the LightExponent distribution will be used instead.
    - ``volumetric_scattering_intensity`` (float):  [Read-Write] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
    """
    @property
    def inverse_exposure_blend(self) -> float:
        r"""
        (float):  [Read-Only] Blend Factor used to blend between Intensity and Intensity/Exposure.
        This is useful for gameplay lights that should have constant brighness on screen independent of current exposure.
        This feature can cause issues with exposure particularly when used on the primary light on a scene, as such it's usage should be limited.
        """
        ...
    @property
    def lighting_channels(self) -> LightingChannels:
        r"""
        (LightingChannels):  [Read-Only] Channels that this light should affect.
        Only affect high quality lights
        These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
        """
        ...
    @property
    def volumetric_scattering_intensity(self) -> float:
        r"""
        (float):  [Read-Only] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
        """
        ...

class ParticleModuleLight_Seeded(ParticleModuleLight):
    r"""
    Particle Module Light Seeded
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleModuleLight_Seeded.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affects_translucency`` (bool):  [Read-Write] Whether lights from this module should affect translucency.
      Use with caution.  Modules enabling this should only make a few particle lights at most, and the smaller they are, the less they will cost.
    - ``b3d_draw_mode`` (bool):  [Read-Write] If true, the module should render its 3D visualization helper
    - ``brightness_over_life`` (RawDistributionFloat):  [Read-Write] Brightness scale for the light, which can be setup as a curve over the particle's lifetime.
    - ``color_scale_over_life`` (RawDistributionVector):  [Read-Write] Scale that is applied to the particle's color to calculate the light's color, and can be setup as a curve over the particle's lifetime.
    - ``high_quality_lights`` (bool):  [Read-Write] Converts the particle lights into high quality lights as if they came from a PointLightComponent.  High quality lights cost significantly more on both CPU and GPU.
    - ``inverse_exposure_blend`` (float):  [Read-Write] Blend Factor used to blend between Intensity and Intensity/Exposure.
      This is useful for gameplay lights that should have constant brighness on screen independent of current exposure.
      This feature can cause issues with exposure particularly when used on the primary light on a scene, as such it's usage should be limited.
    - ``light_exponent`` (RawDistributionFloat):  [Read-Write] Provides the light's exponent when inverse squared falloff is disabled.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this light should affect.
      Only affect high quality lights
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``module_editor_color`` (Color):  [Read-Write] The color to draw the modules curves in the curve editor.
          If bCurvesAsColor is true, it overrides this value.
    - ``override_inverse_exposure_blend`` (bool):  [Read-Write] When enabled we will override the project default setting with our local setting.
    - ``preview_light_radius`` (bool):  [Read-Write] Will draw wireframe spheres to preview the light radius if enabled.
      Note: this is intended for previewing and the value will not be saved, it will always revert to disabled.
    - ``radius_scale`` (RawDistributionFloat):  [Read-Write] Scales the particle's radius, to calculate the light's radius.
    - ``random_seed_info`` (ParticleRandomSeedInfo):  [Read-Write] The random seed(s) to use for looking up values in StartLocation
    - ``shadow_casting_lights`` (bool):  [Read-Write] Whether to cast shadows from the particle lights.  Requires High Quality Lights to be enabled.
      Warning: This can be incredibly expensive on the GPU - use with caution.
    - ``spawn_fraction`` (float):  [Read-Write] Fraction of particles in this emitter to create lights on.
    - ``use_inverse_squared_falloff`` (bool):  [Read-Write] Whether to use physically based inverse squared falloff from the light.  If unchecked, the LightExponent distribution will be used instead.
    - ``volumetric_scattering_intensity`` (float):  [Read-Write] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
    """
    ...

class FXSystemComponent(PrimitiveComponent):
    r"""
    FXSystem Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystemComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    def set_vector_parameter(self, parameter_name: Name, param: Vector) -> None:
        r"""
        x.set_vector_parameter(parameter_name, param) -> None
        Set a named vector instance parameter on this ParticleSystemComponent.
        Updates the parameter if it already exists, or creates a new entry if not.
        
        Args:
            parameter_name (Name): 
            param (Vector):
        """
        ...
    def set_use_auto_manage_attachment(self, auto_manage: bool) -> None:
        r"""
        x.set_use_auto_manage_attachment(auto_manage) -> None
        Sets whether we should automatically attach to AutoAttachParent when activated, and detach from our parent when completed.
        This overrides any current attachment that may be present at the time of activation (deferring initial attachment until activation, if AutoAttachParent is null).
        When enabled, detachment occurs regardless of whether AutoAttachParent is assigned, and the relative transform from the time of activation is restored.
        This also disables attachment on dedicated servers, where we don't actually activate even if bAutoActivate is true.
        see: SetAutoAttachmentParameters()
        
        Args:
            auto_manage (bool):
        """
        ...
    def set_int_parameter(self, parameter_name: Name, param: int) -> None:
        r"""
        x.set_int_parameter(parameter_name, param) -> None
        Change a named int parameter
        
        Args:
            parameter_name (Name): 
            param (int32):
        """
        ...
    def set_float_parameter(self, parameter_name: Name, param: float) -> None:
        r"""
        x.set_float_parameter(parameter_name, param) -> None
        Change a named float parameter
        
        Args:
            parameter_name (Name): 
            param (float):
        """
        ...
    def set_emitter_enable(self, emitter_name: Name, new_enable_state: bool) -> None:
        r"""
        x.set_emitter_enable(emitter_name, new_enable_state) -> None
        Enables / disables an emitter by halting spawning of new particles.
        You will still pay the cost of the emitter update.
        
        Args:
            emitter_name (Name): The name of the emitter
            new_enable_state (bool): The value to set it to
        """
        ...
    def set_color_parameter(self, parameter_name: Name, param: LinearColor) -> None:
        r"""
        x.set_color_parameter(parameter_name, param) -> None
        Set a named color instance parameter on this ParticleSystemComponent.
        Updates the parameter if it already exists, or creates a new entry if not.
        
        Args:
            parameter_name (Name): 
            param (LinearColor):
        """
        ...
    def set_bool_parameter(self, parameter_name: Name, param: bool) -> None:
        r"""
        x.set_bool_parameter(parameter_name, param) -> None
        Change a named boolean parameter, ParticleSystemComponent converts to float.
        
        Args:
            parameter_name (Name): 
            param (bool):
        """
        ...
    def set_auto_attachment_parameters(self, parent: SceneComponent, socket_name: Name, location_rule: AttachmentRule, rotation_rule: AttachmentRule, scale_rule: AttachmentRule) -> None:
        r"""
        x.set_auto_attachment_parameters(parent, socket_name, location_rule, rotation_rule, scale_rule) -> None
        Set AutoAttachParent, AutoAttachSocketName, AutoAttachLocationRule, AutoAttachRotationRule, AutoAttachScaleRule to the specified parameters. Does not change bAutoManageAttachment; that must be set separately.
        see: bAutoManageAttachment, AutoAttachParent, AutoAttachSocketName, AutoAttachLocationRule, AutoAttachRotationRule, AutoAttachScaleRule
        
        Args:
            parent (SceneComponent): Component to attach to.
            socket_name (Name): Socket on Parent to attach to.
            location_rule (AttachmentRule): Option for how we handle our location when we attach to Parent.
            rotation_rule (AttachmentRule): Option for how we handle our rotation when we attach to Parent.
            scale_rule (AttachmentRule): Option for how we handle our scale when we attach to Parent.
        """
        ...
    def set_actor_parameter(self, parameter_name: Name, param: Actor) -> None:
        r"""
        x.set_actor_parameter(parameter_name, param) -> None
        Set a named actor instance parameter on this ParticleSystemComponent.
        Updates the parameter if it already exists, or creates a new entry if not.
        
        Args:
            parameter_name (Name): 
            param (Actor):
        """
        ...
    def release_to_pool(self) -> None:
        r"""
        x.release_to_pool() -> None
        Deactivates this system and releases it to the pool on completion.
        Usage of this PSC reference after this call is unsafe.
        You should clear out your references to it.
        """
        ...
    def get_fx_system_asset(self) -> FXSystemAsset:
        r"""
        x.get_fx_system_asset() -> FXSystemAsset
        Get the referenced FXSystem asset.
        
        Returns:
            FXSystemAsset:
        """
        ...

class ParticleSystemComponent(FXSystemComponent):
    r"""
    A particle emitter.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleSystemComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``allow_recycling`` (bool):  [Read-Write] If true, this Particle System will be available for recycling after it has completed. Auto-destroyed systems cannot be recycled.
      Some systems (currently particle trail effects) can recycle components to avoid respawning them to play new effects.
      This is only an optimization and does not change particle system behavior, aside from not triggering normal component initialization events more than once.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_attach_location_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our location when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_parent`` (SceneComponent):  [Read-Only] Component we automatically attach to when activated, if bAutoManageAttachment is true.
      If null during registration, we assign the existing AttachParent and defer attachment until we activate.
      see: bAutoManageAttachment
    - ``auto_attach_rotation_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our rotation when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_scale_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our scale when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_socket_name`` (Name):  [Read-Write] Socket we automatically attach to on the AutoAttachParent, if bAutoManageAttachment is true.
      If no auto attach socket name is set during registration, the current attach socket will be
      assigned to AutoAttachSocketName and used when activated.
      see: bAutoManageAttachment
    - ``auto_attach_weld_simulated_bodies`` (bool):  [Read-Write] Option for how we handle bWeldSimulatedBodies when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment
    - ``auto_manage_attachment`` (bool):  [Read-Write] True if we should automatically attach to AutoAttachParent when activated, and detach from our parent when completed.
      This overrides any current attachment that may be present at the time of activation (deferring initial attachment until activation, if AutoAttachParent is null).
      When enabled, detachment occurs regardless of whether AutoAttachParent is assigned, and the relative transform from the time of activation is restored.
      This also disables attachment on dedicated servers, where we don't actually activate even if bAutoActivate is true.
      see: AutoAttachParent, AutoAttachSocketName, AutoAttachLocationType
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``custom_time_dilation`` (float):  [Read-Write] Scales DeltaTime in UParticleSystemComponent::Tick(...)
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``instance_parameters`` (Array[ParticleSysParam]):  [Read-Write] Array holding name instance parameters for this ParticleSystemComponent.
      Parameters can be used in Cascade using DistributionFloat/VectorParticleParameters.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lod_method`` (ParticleSystemLODMethod):  [Read-Write] The method of LOD level determination to utilize for this particle system
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_particle_burst`` (ParticleBurstSignature):  [Read-Write]
    - ``on_particle_collide`` (ParticleCollisionSignature):  [Read-Write]
    - ``on_particle_death`` (ParticleDeathSignature):  [Read-Write]
    - ``on_particle_spawn`` (ParticleSpawnSignature):  [Read-Write]
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``on_system_finished`` (OnSystemFinished):  [Read-Write] Called when the particle system is done
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``override_lod_method`` (bool):  [Read-Write] indicates that the component's LODMethod overrides the Template's
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``reset_on_detach`` (bool):  [Read-Write]
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``seconds_before_inactive`` (float):  [Read-Write] Number of seconds of emitter not being rendered that need to pass before it
      no longer gets ticked/ becomes inactive.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``template`` (ParticleSystem):  [Read-Write]
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def template(self) -> ParticleSystem:
        r"""
        (ParticleSystem):  [Read-Only]
        """
        ...
    @property
    def reset_on_detach(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @reset_on_detach.setter
    def reset_on_detach(self, value: bool) -> None:
        ...
    @property
    def allow_recycling(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this Particle System will be available for recycling after it has completed. Auto-destroyed systems cannot be recycled.
        Some systems (currently particle trail effects) can recycle components to avoid respawning them to play new effects.
        This is only an optimization and does not change particle system behavior, aside from not triggering normal component initialization events more than once.
        """
        ...
    @allow_recycling.setter
    def allow_recycling(self, value: bool) -> None:
        ...
    @property
    def auto_manage_attachment(self) -> bool:
        r"""
        (bool):  [Read-Only] True if we should automatically attach to AutoAttachParent when activated, and detach from our parent when completed.
        This overrides any current attachment that may be present at the time of activation (deferring initial attachment until activation, if AutoAttachParent is null).
        When enabled, detachment occurs regardless of whether AutoAttachParent is assigned, and the relative transform from the time of activation is restored.
        This also disables attachment on dedicated servers, where we don't actually activate even if bAutoActivate is true.
        see: AutoAttachParent, AutoAttachSocketName, AutoAttachLocationType
        """
        ...
    @property
    def auto_attach_weld_simulated_bodies(self) -> bool:
        r"""
        (bool):  [Read-Write] Option for how we handle bWeldSimulatedBodies when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment
        """
        ...
    @auto_attach_weld_simulated_bodies.setter
    def auto_attach_weld_simulated_bodies(self, value: bool) -> None:
        ...
    @property
    def override_lod_method(self) -> bool:
        r"""
        (bool):  [Read-Write] indicates that the component's LODMethod overrides the Template's
        """
        ...
    @override_lod_method.setter
    def override_lod_method(self, value: bool) -> None:
        ...
    @property
    def lod_method(self) -> ParticleSystemLODMethod:
        r"""
        (ParticleSystemLODMethod):  [Read-Write] The method of LOD level determination to utilize for this particle system
        """
        ...
    @lod_method.setter
    def lod_method(self, value: ParticleSystemLODMethod) -> None:
        ...
    @property
    def instance_parameters(self) -> Array[ParticleSysParam]:
        r"""
        (Array[ParticleSysParam]):  [Read-Write] Array holding name instance parameters for this ParticleSystemComponent.
        Parameters can be used in Cascade using DistributionFloat/VectorParticleParameters.
        """
        ...
    @instance_parameters.setter
    def instance_parameters(self, value: Array[ParticleSysParam]) -> None:
        ...
    @property
    def on_particle_spawn(self) -> ParticleSpawnSignature:
        r"""
        (ParticleSpawnSignature):  [Read-Write]
        """
        ...
    @on_particle_spawn.setter
    def on_particle_spawn(self, value: ParticleSpawnSignature) -> None:
        ...
    @property
    def on_particle_burst(self) -> ParticleBurstSignature:
        r"""
        (ParticleBurstSignature):  [Read-Write]
        """
        ...
    @on_particle_burst.setter
    def on_particle_burst(self, value: ParticleBurstSignature) -> None:
        ...
    @property
    def on_particle_death(self) -> ParticleDeathSignature:
        r"""
        (ParticleDeathSignature):  [Read-Write]
        """
        ...
    @on_particle_death.setter
    def on_particle_death(self, value: ParticleDeathSignature) -> None:
        ...
    @property
    def on_particle_collide(self) -> ParticleCollisionSignature:
        r"""
        (ParticleCollisionSignature):  [Read-Write]
        """
        ...
    @on_particle_collide.setter
    def on_particle_collide(self, value: ParticleCollisionSignature) -> None:
        ...
    @property
    def seconds_before_inactive(self) -> float:
        r"""
        (float):  [Read-Write] Number of seconds of emitter not being rendered that need to pass before it
        no longer gets ticked/ becomes inactive.
        """
        ...
    @seconds_before_inactive.setter
    def seconds_before_inactive(self, value: float) -> None:
        ...
    @property
    def custom_time_dilation(self) -> float:
        r"""
        (float):  [Read-Write] Scales DeltaTime in UParticleSystemComponent::Tick(...)
        """
        ...
    @custom_time_dilation.setter
    def custom_time_dilation(self, value: float) -> None:
        ...
    @property
    def auto_attach_parent(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Only] Component we automatically attach to when activated, if bAutoManageAttachment is true.
        If null during registration, we assign the existing AttachParent and defer attachment until we activate.
        see: bAutoManageAttachment
        """
        ...
    @property
    def auto_attach_socket_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Socket we automatically attach to on the AutoAttachParent, if bAutoManageAttachment is true.
        If no auto attach socket name is set during registration, the current attach socket will be
        assigned to AutoAttachSocketName and used when activated.
        see: bAutoManageAttachment
        """
        ...
    @auto_attach_socket_name.setter
    def auto_attach_socket_name(self, value: Name) -> None:
        ...
    @property
    def auto_attach_location_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write] Options for how we handle our location when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment, EAttachmentRule
        """
        ...
    @auto_attach_location_rule.setter
    def auto_attach_location_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def auto_attach_rotation_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write] Options for how we handle our rotation when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment, EAttachmentRule
        """
        ...
    @auto_attach_rotation_rule.setter
    def auto_attach_rotation_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def auto_attach_scale_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write] Options for how we handle our scale when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment, EAttachmentRule
        """
        ...
    @auto_attach_scale_rule.setter
    def auto_attach_scale_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def on_system_finished(self) -> OnSystemFinished:
        r"""
        (OnSystemFinished):  [Read-Write] Called when the particle system is done
        """
        ...
    @on_system_finished.setter
    def on_system_finished(self, value: OnSystemFinished) -> None:
        ...
    def set_trail_source_data(self, first_socket_name: Name, second_socket_name: Name, width_mode: TrailWidthMode, width: float) -> None:
        r"""
        x.set_trail_source_data(first_socket_name, second_socket_name, width_mode, width) -> None
        Sets the defining data for all trails in this component.
        
        Args:
            first_socket_name (Name): The name of the first socket for the trail.
            second_socket_name (Name): The name of the second socket for the trail.
            width_mode (TrailWidthMode): How the width value is applied to the trail.
            width (float): The width of the trail.
        """
        ...
    def set_template(self, new_template: ParticleSystem) -> None:
        r"""
        x.set_template(new_template) -> None
        Change the ParticleSystem used by this ParticleSystemComponent
        
        Args:
            new_template (ParticleSystem):
        """
        ...
    def set_material_parameter(self, parameter_name: Name, param: MaterialInterface) -> None:
        r"""
        x.set_material_parameter(parameter_name, param) -> None
        Set a named material instance parameter on this ParticleSystemComponent.
        Updates the parameter if it already exists, or creates a new entry if not.
        
        Args:
            parameter_name (Name): 
            param (MaterialInterface):
        """
        ...
    def set_beam_target_tangent(self, emitter_index: int, new_tangent_point: Vector, target_index: int) -> None:
        r"""
        x.set_beam_target_tangent(emitter_index, new_tangent_point, target_index) -> None
        Set the beam target tangent
        
        Args:
            emitter_index (int32): The index of the emitter to set it on
            new_tangent_point (Vector): The value to set it to
            target_index (int32): Which beam within the emitter to set it on
        """
        ...
    def set_beam_target_strength(self, emitter_index: int, new_target_strength: float, target_index: int) -> None:
        r"""
        x.set_beam_target_strength(emitter_index, new_target_strength, target_index) -> None
        Set the beam target strength
        
        Args:
            emitter_index (int32): The index of the emitter to set it on
            new_target_strength (float): The value to set it to
            target_index (int32): Which beam within the emitter to set it on
        """
        ...
    def set_beam_target_point(self, emitter_index: int, new_target_point: Vector, target_index: int) -> None:
        r"""
        x.set_beam_target_point(emitter_index, new_target_point, target_index) -> None
        Set the beam target point
        
        Args:
            emitter_index (int32): The index of the emitter to set it on
            new_target_point (Vector): The value to set it to
            target_index (int32): Which beam within the emitter to set it on
        """
        ...
    def set_beam_source_tangent(self, emitter_index: int, new_tangent_point: Vector, source_index: int) -> None:
        r"""
        x.set_beam_source_tangent(emitter_index, new_tangent_point, source_index) -> None
        Set the beam source tangent
        
        Args:
            emitter_index (int32): The index of the emitter to set it on
            new_tangent_point (Vector): The value to set it to
            source_index (int32): Which beam within the emitter to set it on
        """
        ...
    def set_beam_source_strength(self, emitter_index: int, new_source_strength: float, source_index: int) -> None:
        r"""
        x.set_beam_source_strength(emitter_index, new_source_strength, source_index) -> None
        Set the beam source strength
        
        Args:
            emitter_index (int32): The index of the emitter to set it on
            new_source_strength (float): The value to set it to
            source_index (int32): Which beam within the emitter to set it on
        """
        ...
    def set_beam_source_point(self, emitter_index: int, new_source_point: Vector, source_index: int) -> None:
        r"""
        x.set_beam_source_point(emitter_index, new_source_point, source_index) -> None
        Set the beam source point
        
        Args:
            emitter_index (int32): The index of the emitter to set it on
            new_source_point (Vector): The value to set it to
            source_index (int32): Which beam within the emitter to set it on
        """
        ...
    def set_beam_end_point(self, emitter_index: int, new_end_point: Vector) -> None:
        r"""
        x.set_beam_end_point(emitter_index, new_end_point) -> None
        Set the beam end point
        
        Args:
            emitter_index (int32): The index of the emitter to set it on
            new_end_point (Vector): The value to set it to
        """
        ...
    def set_auto_attach_params(self, parent: SceneComponent, socket_name: Name = "None", location_type: AttachLocation = AttachLocation.KEEP_RELATIVE_OFFSET) -> None:
        r"""
        x.set_auto_attach_params(parent, socket_name="None", location_type=AttachLocation.KEEP_RELATIVE_OFFSET) -> None
        DEPRECATED: Set AutoAttachParent, AutoAttachSocketName, AutoAttachLocationType to the specified parameters. Does not change bAutoManageAttachment; that must be set separately.
        deprecated: Please use Set Auto Attachment Parameters
        see: bAutoManageAttachment, AutoAttachParent, AutoAttachSocketName, AutoAttachLocationType
        
        Args:
            parent (SceneComponent): Component to attach to.
            socket_name (Name): Socket on Parent to attach to.
            location_type (AttachLocation): Option for how we handle our location when we attach to Parent.
        """
        ...
    def get_num_active_particles(self) -> int:
        r"""
        x.get_num_active_particles() -> int32
        Get the current number of active particles in this system
        
        Returns:
            int32:
        """
        ...
    def get_named_material(self, name: Name) -> MaterialInterface:
        r"""
        x.get_named_material(name) -> MaterialInterface
        Returns a named material. If this named material is not found, returns NULL.
        
        Args:
            name (Name): 
        
        Returns:
            MaterialInterface:
        """
        ...
    def get_beam_target_tangent(self, emitter_index: int, target_index: int) -> Optional[Vector]:
        r"""
        x.get_beam_target_tangent(emitter_index, target_index) -> Vector or None
        Get the beam target tangent
        
        Args:
            emitter_index (int32): The index of the emitter to get
            target_index (int32): Which beam within the emitter to get
        
        Returns:
            Vector or None: true            EmitterIndex and TargetIndex are valid - OutTangentPoint is valid false           EmitterIndex or TargetIndex is invalid - OutTangentPoint is invalid
        
            out_tangent_point (Vector): Value of target tangent
        """
        ...
    def get_beam_target_strength(self, emitter_index: int, target_index: int) -> Optional[float]:
        r"""
        x.get_beam_target_strength(emitter_index, target_index) -> float or None
        Get the beam target strength
        
        Args:
            emitter_index (int32): The index of the emitter to get
            target_index (int32): Which beam within the emitter to get
        
        Returns:
            float or None: true            EmitterIndex and TargetIndex are valid - OutTargetStrength is valid false           EmitterIndex or TargetIndex is invalid - OutTargetStrength is invalid
        
            out_target_strength (float): Value of target tangent
        """
        ...
    def get_beam_target_point(self, emitter_index: int, target_index: int) -> Optional[Vector]:
        r"""
        x.get_beam_target_point(emitter_index, target_index) -> Vector or None
        Get the beam target point
        
        Args:
            emitter_index (int32): The index of the emitter to get
            target_index (int32): Which beam within the emitter to get
        
        Returns:
            Vector or None: true            EmitterIndex and TargetIndex are valid - OutTargetPoint is valid false           EmitterIndex or TargetIndex is invalid - OutTargetPoint is invalid
        
            out_target_point (Vector): Value of target point
        """
        ...
    def get_beam_source_tangent(self, emitter_index: int, source_index: int) -> Optional[Vector]:
        r"""
        x.get_beam_source_tangent(emitter_index, source_index) -> Vector or None
        Get the beam source tangent
        
        Args:
            emitter_index (int32): The index of the emitter to get
            source_index (int32): Which beam within the emitter to get
        
        Returns:
            Vector or None: true            EmitterIndex and SourceIndex are valid - OutTangentPoint is valid false           EmitterIndex or SourceIndex is invalid - OutTangentPoint is invalid
        
            out_tangent_point (Vector): Value of source tangent
        """
        ...
    def get_beam_source_strength(self, emitter_index: int, source_index: int) -> Optional[float]:
        r"""
        x.get_beam_source_strength(emitter_index, source_index) -> float or None
        Get the beam source strength
        
        Args:
            emitter_index (int32): The index of the emitter to get
            source_index (int32): Which beam within the emitter to get
        
        Returns:
            float or None: true            EmitterIndex and SourceIndex are valid - OutSourceStrength is valid false           EmitterIndex or SourceIndex is invalid - OutSourceStrength is invalid
        
            out_source_strength (float): Value of source tangent
        """
        ...
    def get_beam_source_point(self, emitter_index: int, source_index: int) -> Optional[Vector]:
        r"""
        x.get_beam_source_point(emitter_index, source_index) -> Vector or None
        Get the beam source point
        
        Args:
            emitter_index (int32): The index of the emitter to get
            source_index (int32): Which beam within the emitter to get
        
        Returns:
            Vector or None: true            EmitterIndex and SourceIndex are valid - OutSourcePoint is valid false           EmitterIndex or SourceIndex is invalid - OutSourcePoint is invalid
        
            out_source_point (Vector): Value of source point
        """
        ...
    def get_beam_end_point(self, emitter_index: int) -> Optional[Vector]:
        r"""
        x.get_beam_end_point(emitter_index) -> Vector or None
        Get the beam end point
        
        Args:
            emitter_index (int32): The index of the emitter to get the value of
        
        Returns:
            Vector or None: true            EmitterIndex is valid and End point is set - OutEndPoint is valid false           EmitterIndex invalid or End point is not set - OutEndPoint is invalid
        
            out_end_point (Vector):
        """
        ...
    def generate_particle_event(self, event_name: Name, emitter_time: float, location: Vector, direction: Vector, velocity: Vector) -> None:
        r"""
        x.generate_particle_event(event_name, emitter_time, location, direction, velocity) -> None
        Record a kismet event.
        
        Args:
            event_name (Name): The name of the event that fired.
            emitter_time (float): The emitter time when the event fired.
            location (Vector): The location of the particle when the event fired.
            direction (Vector): 
            velocity (Vector): The velocity of the particle when the event fired.
        """
        ...
    def end_trails(self) -> None:
        r"""
        x.end_trails() -> None
        Ends all trail emitters in this component.
        """
        ...
    def create_named_dynamic_material_instance(self, name: Name, source_material: MaterialInterface = None) -> MaterialInstanceDynamic:
        r"""
        x.create_named_dynamic_material_instance(name, source_material=None) -> MaterialInstanceDynamic
        Creates a Dynamic Material Instance for the specified named material override, optionally from the supplied material.
        
        Args:
            name (Name): 
            source_material (MaterialInterface): 
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...
    def begin_trails(self, first_socket_name: Name, second_socket_name: Name, width_mode: TrailWidthMode, width: float) -> None:
        r"""
        x.begin_trails(first_socket_name, second_socket_name, width_mode, width) -> None
        Begins all trail emitters in this component.
        
        Args:
            first_socket_name (Name): The name of the first socket for the trail.
            second_socket_name (Name): The name of the second socket for the trail.
            width_mode (TrailWidthMode): How the width value is applied to the trail.
            width (float): The width of the trail.
        """
        ...

class PhysicsObjectBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Physics Object Blueprint Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsObjectBlueprintLibrary.h
    
    """
    @classmethod
    def get_physics_object_world_transform(cls, component: PrimitiveComponent, bone_name: Name) -> Transform:
        r"""
        X.get_physics_object_world_transform(component, bone_name) -> Transform
        Get Physics Object World Transform
        
        Args:
            component (PrimitiveComponent): 
            bone_name (Name): 
        
        Returns:
            Transform:
        """
        ...
    @classmethod
    def get_closest_physics_object_from_world_location(cls, component: PrimitiveComponent, world_location: Vector) -> ClosestPhysicsObjectResult:
        r"""
        X.get_closest_physics_object_from_world_location(component, world_location) -> ClosestPhysicsObjectResult
        Get Closest Physics Object from World Location
        
        Args:
            component (PrimitiveComponent): 
            world_location (Vector): 
        
        Returns:
            ClosestPhysicsObjectResult:
        """
        ...
    @classmethod
    def extract_closest_physics_object_results(cls, result: ClosestPhysicsObjectResult) -> Optional[Name]:
        r"""
        X.extract_closest_physics_object_results(result) -> Name or None
        Extract Closest Physics Object Results
        
        Args:
            result (ClosestPhysicsObjectResult): 
        
        Returns:
            Name or None: 
        
            out_name (Name):
        """
        ...
    @classmethod
    def apply_radial_impulse(cls, component: PrimitiveComponent, origin: Vector, radius: float, strength: float, falloff: RadialImpulseFalloff, apply_strain: bool, strain: float, vel_change: bool = False, min_value: float = 0.000000, max_value: float = 1.000000) -> None:
        r"""
        X.apply_radial_impulse(component, origin, radius, strength, falloff, apply_strain, strain, vel_change=False, min_value=0.000000, max_value=1.000000) -> None
        Apply a physics radial impulse with an optional strain on a specific component
        Effect is applied within a sphere. When using linear falloff the effect will be minimum at the outer edge of the sphere and maximum at its center
        
        Args:
            component (PrimitiveComponent): Primitive component to apply the impulse / strain on
            origin (Vector): Positition of the origin of the radial effect in world space
            radius (float): Radius of the radial effect ( beyond the radius, impulse will not be applied )
            strength (float): Strength of the impulse to apply ( Unit : (Kg * m / s) or ( m /s ) if bVelChange is true
            falloff (RadialImpulseFalloff): Type of falloff to use ( constant, linear )
            apply_strain (bool): Whether or not to apply strain on top of the impulse ( for destructible objects )
            strain (float): If bApplyStrain is true, Strain to apply to the physics particles ( for destructible objects )
            vel_change (bool): If true, impulse Strength parameter is interpretation as a change of velocity
            min_value (float): When using linear falloff, this define the falloff value at the outer edge of the sphere
            max_value (float): When using linear falloff, this define the falloff value at the center of the sphere
        """
        ...

class PhysicsSpringComponent(SceneComponent):
    r"""
    Note: this component is still work in progress. Uses raycast springs for simple vehicle forces
       Used with objects that have physics to create a spring down the X direction
       ie. point X in the direction you want generate spring.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsSpringComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``ignore_self`` (bool):  [Read-Write] If true, the spring will ignore all components in its own actor
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``spring_channel`` (CollisionChannel):  [Read-Write] Strength of thrust force applied to the base object.
    - ``spring_compression`` (float):  [Read-Write] The current compression of the spring. A spring at rest will have SpringCompression 0.
    - ``spring_damping`` (float):  [Read-Write] Specifies how quickly the spring can absorb energy of a body. The higher the damping the less oscillation
    - ``spring_length_at_rest`` (float):  [Read-Write] Determines how long the spring will be along the X-axis at rest. The spring will apply 0 force on a body when it's at rest.
    - ``spring_radius`` (float):  [Read-Write] Determines the radius of the spring.
    - ``spring_stiffness`` (float):  [Read-Write] Specifies how much strength the spring has. The higher the SpringStiffness the more force the spring can push on a body with.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def spring_stiffness(self) -> float:
        r"""
        (float):  [Read-Write] Specifies how much strength the spring has. The higher the SpringStiffness the more force the spring can push on a body with.
        """
        ...
    @spring_stiffness.setter
    def spring_stiffness(self, value: float) -> None:
        ...
    @property
    def spring_damping(self) -> float:
        r"""
        (float):  [Read-Write] Specifies how quickly the spring can absorb energy of a body. The higher the damping the less oscillation
        """
        ...
    @spring_damping.setter
    def spring_damping(self, value: float) -> None:
        ...
    @property
    def spring_length_at_rest(self) -> float:
        r"""
        (float):  [Read-Write] Determines how long the spring will be along the X-axis at rest. The spring will apply 0 force on a body when it's at rest.
        """
        ...
    @spring_length_at_rest.setter
    def spring_length_at_rest(self, value: float) -> None:
        ...
    @property
    def spring_radius(self) -> float:
        r"""
        (float):  [Read-Write] Determines the radius of the spring.
        """
        ...
    @spring_radius.setter
    def spring_radius(self, value: float) -> None:
        ...
    @property
    def spring_channel(self) -> CollisionChannel:
        r"""
        (CollisionChannel):  [Read-Write] Strength of thrust force applied to the base object.
        """
        ...
    @spring_channel.setter
    def spring_channel(self, value: CollisionChannel) -> None:
        ...
    @property
    def ignore_self(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the spring will ignore all components in its own actor
        """
        ...
    @ignore_self.setter
    def ignore_self(self, value: bool) -> None:
        ...
    @property
    def spring_compression(self) -> float:
        r"""
        (float):  [Read-Only] The current compression of the spring. A spring at rest will have SpringCompression 0.
        """
        ...
    def get_spring_resting_point(self) -> Vector:
        r"""
        x.get_spring_resting_point() -> Vector
        Returns the spring resting point in world space.
        
        Returns:
            Vector:
        """
        ...
    def get_spring_direction(self) -> Vector:
        r"""
        x.get_spring_direction() -> Vector
        Returns the spring direction from start to resting point
        
        Returns:
            Vector:
        """
        ...
    def get_spring_current_end_point(self) -> Vector:
        r"""
        x.get_spring_current_end_point() -> Vector
        Returns the spring current end point in world space.
        
        Returns:
            Vector:
        """
        ...
    def get_normalized_compression_scalar(self) -> float:
        r"""
        x.get_normalized_compression_scalar() -> float
        Returns the spring compression as a normalized scalar along spring direction.
        0 implies spring is at rest
        1 implies fully compressed
        
        Returns:
            float:
        """
        ...

class PhysicsThreadLibrary(BlueprintFunctionLibrary):
    r"""
    Physics Thread Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsThreadLibrary.h
    
    """
    @classmethod
    def add_force(cls, handle: BodyInstanceAsyncPhysicsTickHandle, force: Vector, accel_change: bool = False) -> None:
        r"""
        X.add_force(handle, force, accel_change=False) -> None
        Add a force to a single rigid body.
        This is like a 'thruster'. Good for adding a burst over some (non zero) time. Should be called every frame for the duration of the force.
        
        Args:
            handle (BodyInstanceAsyncPhysicsTickHandle): 
            force (Vector): Force vector to apply. Magnitude indicates strength of force.
            accel_change (bool): If true, Force is taken as a change in acceleration instead of a physical force (i.e. mass will have no effect).
        """
        ...

class PhysicsThrusterComponent(SceneComponent):
    r"""
    Used with objects that have physics to apply a force down the negative-X direction
    ie. point X in the direction you want the thrust in.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsThrusterComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``thrust_strength`` (float):  [Read-Write] Strength of thrust force applied to the base object.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def thrust_strength(self) -> float:
        r"""
        (float):  [Read-Write] Strength of thrust force applied to the base object.
        """
        ...
    @thrust_strength.setter
    def thrust_strength(self, value: float) -> None:
        ...

class RB_ThrusterComponent(PhysicsThrusterComponent):
    r"""
    deprecated: 'RB_ThrusterComponent' was renamed to 'PhysicsThrusterComponent'.
    """
    ...

class SceneCapture(Actor):
    r"""
    Scene Capture
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneCapture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``scene_component`` (SceneComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def scene_component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Only]
        """
        ...

class PlanarReflection(SceneCapture):
    r"""
    Planar Reflection
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlanarReflection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``planar_reflection_component`` (PlanarReflectionComponent):  [Read-Only] Planar reflection component.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``scene_component`` (SceneComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def planar_reflection_component(self) -> PlanarReflectionComponent:
        r"""
        (PlanarReflectionComponent):  [Read-Only] Planar reflection component.
        """
        ...
    def on_interp_toggle(self, enable: bool) -> None:
        r"""
        x.on_interp_toggle(enable) -> None
        On Interp Toggle
        
        Args:
            enable (bool):
        """
        ...

class SceneCaptureComponent(SceneComponent):
    r"""
    -> will be exported to EngineDecalClasses.h
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneCaptureComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``always_persist_rendering_state`` (bool):  [Read-Write] Whether to persist the rendering state even if bCaptureEveryFrame==false.  This allows velocities for Motion Blur and Temporal AA to be computed.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capture_every_frame`` (bool):  [Read-Write] Whether to update the capture's contents every frame.  If disabled, the component will render once on load and then only when moved.
    - ``capture_on_movement`` (bool):  [Read-Write] Whether to update the capture's contents on movement.  Disable if you are going to capture manually from blueprint.
    - ``capture_sort_priority`` (int32):  [Read-Write] Capture priority within the frame to sort scene capture on GPU to resolve interdependencies between multiple capture components. Highest come first.
    - ``capture_source`` (SceneCaptureSource):  [Read-Write]
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_actors`` (Array[Actor]):  [Read-Write] The actors to hide in the scene capture.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``lod_distance_factor`` (float):  [Read-Write] Scales the distance used by LOD. Set to values greater than 1 to cause the scene capture to use lower LODs than the main view to speed up the scene capture pass.
    - ``max_view_distance_override`` (float):  [Read-Write] if > 0, sets a maximum render distance override.  Can be used to cull distant objects from a reflection if the reflecting plane is in an enclosed area like a hallway or room
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``primitive_render_mode`` (SceneCapturePrimitiveRenderMode):  [Read-Write] Controls what primitives get rendered into the scene capture.
    - ``profiling_event_name`` (str):  [Read-Write] Name of the profiling event.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``show_flag_settings`` (Array[EngineShowFlagsSetting]):  [Read-Write] ShowFlags for the SceneCapture's ViewFamily, to control rendering settings for this view. Hidden but accessible through details customization
    - ``show_only_actors`` (Array[Actor]):  [Read-Write] The only actors to be rendered by this scene capture, if PrimitiveRenderMode is set to UseShowOnlyList.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_ray_tracing_if_enabled`` (bool):  [Read-Write] Whether to use ray tracing for this capture. Ray Tracing must be enabled in the project.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def primitive_render_mode(self) -> SceneCapturePrimitiveRenderMode:
        r"""
        (SceneCapturePrimitiveRenderMode):  [Read-Write] Controls what primitives get rendered into the scene capture.
        """
        ...
    @primitive_render_mode.setter
    def primitive_render_mode(self, value: SceneCapturePrimitiveRenderMode) -> None:
        ...
    @property
    def capture_source(self) -> SceneCaptureSource:
        r"""
        (SceneCaptureSource):  [Read-Write]
        """
        ...
    @capture_source.setter
    def capture_source(self, value: SceneCaptureSource) -> None:
        ...
    @property
    def capture_every_frame(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to update the capture's contents every frame.  If disabled, the component will render once on load and then only when moved.
        """
        ...
    @capture_every_frame.setter
    def capture_every_frame(self, value: bool) -> None:
        ...
    @property
    def capture_on_movement(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to update the capture's contents on movement.  Disable if you are going to capture manually from blueprint.
        """
        ...
    @capture_on_movement.setter
    def capture_on_movement(self, value: bool) -> None:
        ...
    @property
    def always_persist_rendering_state(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to persist the rendering state even if bCaptureEveryFrame==false.  This allows velocities for Motion Blur and Temporal AA to be computed.
        """
        ...
    @always_persist_rendering_state.setter
    def always_persist_rendering_state(self, value: bool) -> None:
        ...
    @property
    def hidden_actors(self) -> Array[Actor]:
        r"""
        (Array[Actor]):  [Read-Write] The actors to hide in the scene capture.
        """
        ...
    @hidden_actors.setter
    def hidden_actors(self, value: Array[Actor]) -> None:
        ...
    @property
    def show_only_actors(self) -> Array[Actor]:
        r"""
        (Array[Actor]):  [Read-Write] The only actors to be rendered by this scene capture, if PrimitiveRenderMode is set to UseShowOnlyList.
        """
        ...
    @show_only_actors.setter
    def show_only_actors(self, value: Array[Actor]) -> None:
        ...
    @property
    def max_view_distance_override(self) -> float:
        r"""
        (float):  [Read-Write] if > 0, sets a maximum render distance override.  Can be used to cull distant objects from a reflection if the reflecting plane is in an enclosed area like a hallway or room
        """
        ...
    @max_view_distance_override.setter
    def max_view_distance_override(self, value: float) -> None:
        ...
    @property
    def capture_sort_priority(self) -> int:
        r"""
        (int32):  [Read-Only] Capture priority within the frame to sort scene capture on GPU to resolve interdependencies between multiple capture components. Highest come first.
        """
        ...
    @property
    def use_ray_tracing_if_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to use ray tracing for this capture. Ray Tracing must be enabled in the project.
        """
        ...
    @use_ray_tracing_if_enabled.setter
    def use_ray_tracing_if_enabled(self, value: bool) -> None:
        ...
    @property
    def show_flag_settings(self) -> Array[EngineShowFlagsSetting]:
        r"""
        (Array[EngineShowFlagsSetting]):  [Read-Write] ShowFlags for the SceneCapture's ViewFamily, to control rendering settings for this view. Hidden but accessible through details customization
        """
        ...
    @show_flag_settings.setter
    def show_flag_settings(self, value: Array[EngineShowFlagsSetting]) -> None:
        ...
    @property
    def profiling_event_name(self) -> str:
        r"""
        (str):  [Read-Write] Name of the profiling event.
        """
        ...
    @profiling_event_name.setter
    def profiling_event_name(self, value: str) -> None:
        ...
    def show_only_component(self, component: PrimitiveComponent) -> None:
        r"""
        x.show_only_component(component) -> None
        Adds the component to our list of show-only components.
        
        Args:
            component (PrimitiveComponent):
        """
        ...
    def show_only_actor_components(self, actor: Actor, include_from_child_actors: bool = False) -> None:
        r"""
        x.show_only_actor_components(actor, include_from_child_actors=False) -> None
        Adds all primitive components in the actor to our list of show-only components.
        
        Args:
            actor (Actor): 
            include_from_child_actors (bool): Whether to include the components from child actors
        """
        ...
    def set_capture_sort_priority(self, new_capture_sort_priority: int) -> None:
        r"""
        x.set_capture_sort_priority(new_capture_sort_priority) -> None
        Changes the value of TranslucentSortPriority.
        
        Args:
            new_capture_sort_priority (int32):
        """
        ...
    def remove_show_only_component(self, component: PrimitiveComponent) -> None:
        r"""
        x.remove_show_only_component(component) -> None
        Removes a component from the Show Only list.
        
        Args:
            component (PrimitiveComponent):
        """
        ...
    def remove_show_only_actor_components(self, actor: Actor, include_from_child_actors: bool = False) -> None:
        r"""
        x.remove_show_only_actor_components(actor, include_from_child_actors=False) -> None
        Removes an actor's components from the Show Only list.
        
        Args:
            actor (Actor): 
            include_from_child_actors (bool): Whether to remove the components from child actors
        """
        ...
    def hide_component(self, component: PrimitiveComponent) -> None:
        r"""
        x.hide_component(component) -> None
        Adds the component to our list of hidden components.
        
        Args:
            component (PrimitiveComponent):
        """
        ...
    def hide_actor_components(self, actor: Actor, include_from_child_actors: bool = False) -> None:
        r"""
        x.hide_actor_components(actor, include_from_child_actors=False) -> None
        Adds all primitive components in the actor to our list of hidden components.
        
        Args:
            actor (Actor): 
            include_from_child_actors (bool): Whether to include the components from child actors
        """
        ...
    def clear_show_only_components(self) -> None:
        r"""
        x.clear_show_only_components() -> None
        Clears the Show Only list.
        """
        ...
    def clear_hidden_components(self) -> None:
        r"""
        x.clear_hidden_components() -> None
        Clears the hidden list.
        """
        ...

class PlanarReflectionComponent(SceneCaptureComponent):
    r"""
    UPlanarReflectionComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlanarReflectionComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``always_persist_rendering_state`` (bool):  [Read-Write] Whether to persist the rendering state even if bCaptureEveryFrame==false.  This allows velocities for Motion Blur and Temporal AA to be computed.
    - ``angle_from_plane_fade_end`` (float):  [Read-Write] Receiving pixels whose normal is at this angle from the reflection plane will have completely faded out the planar reflection.
    - ``angle_from_plane_fade_start`` (float):  [Read-Write] Receiving pixels whose normal is at this angle from the reflection plane will begin to fade out the planar reflection.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capture_every_frame`` (bool):  [Read-Write] Whether to update the capture's contents every frame.  If disabled, the component will render once on load and then only when moved.
    - ``capture_on_movement`` (bool):  [Read-Write] Whether to update the capture's contents on movement.  Disable if you are going to capture manually from blueprint.
    - ``capture_sort_priority`` (int32):  [Read-Write] Capture priority within the frame to sort scene capture on GPU to resolve interdependencies between multiple capture components. Highest come first.
    - ``capture_source`` (SceneCaptureSource):  [Read-Write]
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``distance_from_plane_fadeout_end`` (float):  [Read-Write] Receiving pixels at this distance from the reflection plane will have completely faded out the planar reflection.
    - ``distance_from_plane_fadeout_start`` (float):  [Read-Write] Receiving pixels at this distance from the reflection plane will begin to fade out the planar reflection.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``extra_fov`` (float):  [Read-Write] Additional FOV used when rendering to the reflection texture.
      This is useful when normal distortion is causing reads outside the reflection texture.
      Larger values increase rendering thread and GPU cost, as more objects and triangles have to be rendered into the planar reflection.
    - ``hidden_actors`` (Array[Actor]):  [Read-Write] The actors to hide in the scene capture.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``lod_distance_factor`` (float):  [Read-Write] Scales the distance used by LOD. Set to values greater than 1 to cause the scene capture to use lower LODs than the main view to speed up the scene capture pass.
    - ``max_view_distance_override`` (float):  [Read-Write] if > 0, sets a maximum render distance override.  Can be used to cull distant objects from a reflection if the reflecting plane is in an enclosed area like a hallway or room
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``normal_distortion_strength`` (float):  [Read-Write] Controls the strength of normals when distorting the planar reflection.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``prefilter_roughness`` (float):  [Read-Write] The roughness value to prefilter the planar reflection texture with, useful for hiding low resolution.  Larger values have larger GPU cost.
    - ``prefilter_roughness_distance`` (float):  [Read-Write] The distance at which the prefilter roughness value will be achieved.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``primitive_render_mode`` (SceneCapturePrimitiveRenderMode):  [Read-Write] Controls what primitives get rendered into the scene capture.
    - ``profiling_event_name`` (str):  [Read-Write] Name of the profiling event.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_scene_two_sided`` (bool):  [Read-Write] Whether to render the scene as two-sided, which can be useful to hide artifacts where normal distortion would read 'under' an object that has been clipped by the reflection plane.
      With this setting enabled, the backfaces of a mesh would be displayed in the clipped region instead of the background which is potentially a bright sky.
      Be sure to add the water plane to HiddenActors if enabling this, as the water plane will now block the reflection.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``screen_percentage`` (int32):  [Read-Write] Downsample percent, can be used to reduce GPU time rendering the planar reflection.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``show_flag_settings`` (Array[EngineShowFlagsSetting]):  [Read-Write] ShowFlags for the SceneCapture's ViewFamily, to control rendering settings for this view. Hidden but accessible through details customization
    - ``show_only_actors`` (Array[Actor]):  [Read-Write] The only actors to be rendered by this scene capture, if PrimitiveRenderMode is set to UseShowOnlyList.
    - ``show_preview_plane`` (bool):  [Read-Write]
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_ray_tracing_if_enabled`` (bool):  [Read-Write] Whether to use ray tracing for this capture. Ray Tracing must be enabled in the project.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class PlaneReflectionCapture(ReflectionCapture):
    r"""
    Plane Reflection Capture
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlaneReflectionCapture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``capture_component`` (ReflectionCaptureComponent):  [Read-Only] Reflection capture component.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class PlaneReflectionCaptureComponent(ReflectionCaptureComponent):
    r"""
    -> will be exported to EngineDecalClasses.h
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlaneReflectionCaptureComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``brightness`` (float):  [Read-Write] A brightness control to scale the captured scene's reflection intensity.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capture_offset`` (Vector):  [Read-Write] World space offset to apply before capturing.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``cubemap`` (TextureCube):  [Read-Write] Cubemap to use for reflection if ReflectionSourceType is set to RS_SpecifiedCubemap.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``influence_radius_scale`` (float):  [Read-Write] Radius of the area that can receive reflections from this capture.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``reflection_source_type`` (ReflectionSourceType):  [Read-Write] Indicates where to get the reflection source from.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``source_cubemap_angle`` (float):  [Read-Write] Angle to rotate the source cubemap when SourceType is set to SLS_SpecifiedCubemap.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def influence_radius_scale(self) -> float:
        r"""
        (float):  [Read-Write] Radius of the area that can receive reflections from this capture.
        """
        ...
    @influence_radius_scale.setter
    def influence_radius_scale(self, value: float) -> None:
        ...

class PlayerCameraManager(Actor):
    r"""
    A PlayerCameraManager is responsible for managing the camera for a particular
    player. It defines the final view properties used by other systems (e.g. the renderer),
    meaning you can think of it as your virtual eyeball in the world. It can compute the
    final camera properties directly, or it can arbitrate/blend between other objects or
    actors that influence the camera (e.g. blending from one CameraActor to another).
    
    The PlayerCameraManagers primary external responsibility is to reliably respond to
    various Get*() functions, such as GetCameraViewPoint. Most everything else is
    implementation detail and overrideable by user projects.
    
    By default, a PlayerCameraManager maintains a "view target", which is the primary actor
    the camera is associated with. It can also apply various "post" effects to the final
    view state, such as camera animations, shakes, post-process effects or special
    effects such as dirt on the lens.
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Framework/Camera/
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerCameraManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_calculate_ortho_planes`` (bool):  [Read-Write] True when this camera should automatically calculated the Near+Far planes
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_plane_shift`` (float):  [Read-Write] Manually adjusts the planes of this camera, maintaining the distance between them. Positive moves out to the farplane, negative towards the near plane
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``client_simulating_view_target`` (bool):  [Read-Write] True if clients are handling setting their own viewtarget and the server should not replicate it.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_aspect_ratio`` (float):  [Read-Write] Default aspect ratio. Most of the time the value from a camera component will be used instead.
    - ``default_constrain_aspect_ratio`` (bool):  [Read-Write] True if black bars should be added if the destination view has a different aspect ratio (only used when a view target doesn't specify whether or not to constrain the aspect ratio; most of the time the value from a camera component is used instead)
    - ``default_fov`` (float):  [Read-Write] FOV to use by default.
    - ``default_modifiers`` (Array[type(Class)]):  [Read-Write] List of modifiers to create by default for this camera
    - ``default_ortho_width`` (float):  [Read-Write] The default desired width (in world units) of the orthographic view (ignored in Perspective mode)
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``free_cam_distance`` (float):  [Read-Write] Distance to place free camera from view target (used in certain CameraStyles)
    - ``free_cam_offset`` (Vector):  [Read-Write] Offset to Z free camera position (used in certain CameraStyles)
    - ``game_camera_cut_this_frame`` (bool):  [Read-Write] True if we did a camera cut this frame. Automatically reset to false every frame.
      This flag affects various things in the renderer (such as whether to use the occlusion queries from last frame, and motion blur).
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_orthographic`` (bool):  [Read-Write] True when this camera should use an orthographic perspective instead of FOV
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_audio_fade_change_event`` (OnAudioFadeChangeSignature):  [Read-Write] If bound, broadcast on fade start (with fade time) instead of manually altering audio device's primary volume directly
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``transform_component`` (SceneComponent):  [Read-Only] Dummy component we can use to attach things to the camera.
    - ``update_ortho_planes`` (bool):  [Read-Write] Adjusts the near/far planes and the view origin of the current camera automatically to avoid clipping and light artefacting
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_camera_height_as_view_target`` (bool):  [Read-Write] If UpdateOrthoPlanes is enabled, this setting will use the cameras current height to compensate the distance to the general view (as a pseudo distance to view target when one isn't present)
    - ``use_client_side_camera_updates`` (bool):  [Read-Write] True if server will use camera positions replicated from the client instead of calculating them locally.
    - ``view_pitch_max`` (float):  [Read-Write] Maximum view pitch, in degrees.
    - ``view_pitch_min`` (float):  [Read-Write] Minimum view pitch, in degrees.
    - ``view_roll_max`` (float):  [Read-Write] Maximum view roll, in degrees.
    - ``view_roll_min`` (float):  [Read-Write] Minimum view roll, in degrees.
    - ``view_target_offset`` (Vector):  [Read-Write] Offset to view target (used in certain CameraStyles)
    - ``view_yaw_max`` (float):  [Read-Write] Maximum view yaw, in degrees.
    - ``view_yaw_min`` (float):  [Read-Write] Minimum view yaw, in degrees.
    """
    @property
    def transform_component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Only] Dummy component we can use to attach things to the camera.
        """
        ...
    @property
    def default_fov(self) -> float:
        r"""
        (float):  [Read-Write] FOV to use by default.
        """
        ...
    @default_fov.setter
    def default_fov(self, value: float) -> None:
        ...
    @property
    def default_ortho_width(self) -> float:
        r"""
        (float):  [Read-Write] The default desired width (in world units) of the orthographic view (ignored in Perspective mode)
        """
        ...
    @default_ortho_width.setter
    def default_ortho_width(self, value: float) -> None:
        ...
    @property
    def default_aspect_ratio(self) -> float:
        r"""
        (float):  [Read-Write] Default aspect ratio. Most of the time the value from a camera component will be used instead.
        """
        ...
    @default_aspect_ratio.setter
    def default_aspect_ratio(self, value: float) -> None:
        ...
    @property
    def default_modifiers(self) -> Array[Class]:
        r"""
        (Array[type(Class)]):  [Read-Only] List of modifiers to create by default for this camera
        """
        ...
    @property
    def free_cam_distance(self) -> float:
        r"""
        (float):  [Read-Write] Distance to place free camera from view target (used in certain CameraStyles)
        """
        ...
    @free_cam_distance.setter
    def free_cam_distance(self, value: float) -> None:
        ...
    @property
    def free_cam_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Offset to Z free camera position (used in certain CameraStyles)
        """
        ...
    @free_cam_offset.setter
    def free_cam_offset(self, value: Vector) -> None:
        ...
    @property
    def view_target_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Offset to view target (used in certain CameraStyles)
        """
        ...
    @view_target_offset.setter
    def view_target_offset(self, value: Vector) -> None:
        ...
    @property
    def on_audio_fade_change_event(self) -> OnAudioFadeChangeSignature:
        r"""
        (OnAudioFadeChangeSignature):  [Read-Write] If bound, broadcast on fade start (with fade time) instead of manually altering audio device's primary volume directly
        """
        ...
    @on_audio_fade_change_event.setter
    def on_audio_fade_change_event(self, value: OnAudioFadeChangeSignature) -> None:
        ...
    @property
    def is_orthographic(self) -> bool:
        r"""
        (bool):  [Read-Write] True when this camera should use an orthographic perspective instead of FOV
        """
        ...
    @is_orthographic.setter
    def is_orthographic(self, value: bool) -> None:
        ...
    @property
    def auto_calculate_ortho_planes(self) -> bool:
        r"""
        (bool):  [Read-Write] True when this camera should automatically calculated the Near+Far planes
        """
        ...
    @auto_calculate_ortho_planes.setter
    def auto_calculate_ortho_planes(self, value: bool) -> None:
        ...
    @property
    def auto_plane_shift(self) -> float:
        r"""
        (float):  [Read-Write] Manually adjusts the planes of this camera, maintaining the distance between them. Positive moves out to the farplane, negative towards the near plane
        """
        ...
    @auto_plane_shift.setter
    def auto_plane_shift(self, value: float) -> None:
        ...
    @property
    def update_ortho_planes(self) -> bool:
        r"""
        (bool):  [Read-Write] Adjusts the near/far planes and the view origin of the current camera automatically to avoid clipping and light artefacting
        """
        ...
    @update_ortho_planes.setter
    def update_ortho_planes(self, value: bool) -> None:
        ...
    @property
    def use_camera_height_as_view_target(self) -> bool:
        r"""
        (bool):  [Read-Write] If UpdateOrthoPlanes is enabled, this setting will use the cameras current height to compensate the distance to the general view (as a pseudo distance to view target when one isn't present)
        """
        ...
    @use_camera_height_as_view_target.setter
    def use_camera_height_as_view_target(self, value: bool) -> None:
        ...
    @property
    def default_constrain_aspect_ratio(self) -> bool:
        r"""
        (bool):  [Read-Write] True if black bars should be added if the destination view has a different aspect ratio (only used when a view target doesn't specify whether or not to constrain the aspect ratio; most of the time the value from a camera component is used instead)
        """
        ...
    @default_constrain_aspect_ratio.setter
    def default_constrain_aspect_ratio(self, value: bool) -> None:
        ...
    @property
    def client_simulating_view_target(self) -> bool:
        r"""
        (bool):  [Read-Write] True if clients are handling setting their own viewtarget and the server should not replicate it.
        """
        ...
    @client_simulating_view_target.setter
    def client_simulating_view_target(self, value: bool) -> None:
        ...
    @property
    def use_client_side_camera_updates(self) -> bool:
        r"""
        (bool):  [Read-Only] True if server will use camera positions replicated from the client instead of calculating them locally.
        """
        ...
    @property
    def game_camera_cut_this_frame(self) -> bool:
        r"""
        (bool):  [Read-Only] True if we did a camera cut this frame. Automatically reset to false every frame.
        This flag affects various things in the renderer (such as whether to use the occlusion queries from last frame, and motion blur).
        """
        ...
    @property
    def view_pitch_min(self) -> float:
        r"""
        (float):  [Read-Write] Minimum view pitch, in degrees.
        """
        ...
    @view_pitch_min.setter
    def view_pitch_min(self, value: float) -> None:
        ...
    @property
    def view_pitch_max(self) -> float:
        r"""
        (float):  [Read-Write] Maximum view pitch, in degrees.
        """
        ...
    @view_pitch_max.setter
    def view_pitch_max(self, value: float) -> None:
        ...
    @property
    def view_yaw_min(self) -> float:
        r"""
        (float):  [Read-Write] Minimum view yaw, in degrees.
        """
        ...
    @view_yaw_min.setter
    def view_yaw_min(self, value: float) -> None:
        ...
    @property
    def view_yaw_max(self) -> float:
        r"""
        (float):  [Read-Write] Maximum view yaw, in degrees.
        """
        ...
    @view_yaw_max.setter
    def view_yaw_max(self, value: float) -> None:
        ...
    @property
    def view_roll_min(self) -> float:
        r"""
        (float):  [Read-Write] Minimum view roll, in degrees.
        """
        ...
    @view_roll_min.setter
    def view_roll_min(self, value: float) -> None:
        ...
    @property
    def view_roll_max(self) -> float:
        r"""
        (float):  [Read-Write] Maximum view roll, in degrees.
        """
        ...
    @view_roll_max.setter
    def view_roll_max(self, value: float) -> None:
        ...
    def stop_camera_shake(self, shake_instance: CameraShakeBase, immediately: bool = True) -> None:
        r"""
        x.stop_camera_shake(shake_instance, immediately=True) -> None
        Immediately stops the given shake instance and invalidates it.
        
        Args:
            shake_instance (CameraShakeBase): 
            immediately (bool):
        """
        ...
    def stop_camera_fade(self) -> None:
        r"""
        x.stop_camera_fade() -> None
        Stops camera fading.
        """
        ...
    def stop_all_instances_of_camera_shake_from_source(self, shake: Class, source_component: CameraShakeSourceComponent, immediately: bool = True) -> None:
        r"""
        x.stop_all_instances_of_camera_shake_from_source(shake, source_component, immediately=True) -> None
        Stops playing all shakes of the given class originating from the given source.
        
        Args:
            shake (type(Class)): 
            source_component (CameraShakeSourceComponent): 
            immediately (bool):
        """
        ...
    def stop_all_instances_of_camera_shake(self, shake: Class, immediately: bool = True) -> None:
        r"""
        x.stop_all_instances_of_camera_shake(shake, immediately=True) -> None
        Stops playing all shakes of the given class.
        
        Args:
            shake (type(Class)): 
            immediately (bool):
        """
        ...
    def stop_all_camera_shakes_from_source(self, source_component: CameraShakeSourceComponent, immediately: bool = True) -> None:
        r"""
        x.stop_all_camera_shakes_from_source(source_component, immediately=True) -> None
        Stops playing all shakes originating from the given source.
        
        Args:
            source_component (CameraShakeSourceComponent): 
            immediately (bool):
        """
        ...
    def stop_all_camera_shakes(self, immediately: bool = True) -> None:
        r"""
        x.stop_all_camera_shakes(immediately=True) -> None
        Stops all active camera shakes on this camera.
        
        Args:
            immediately (bool):
        """
        ...
    def start_camera_shake_from_source(self, shake_class: Class, source_component: CameraShakeSourceComponent, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> CameraShakeBase:
        r"""
        x.start_camera_shake_from_source(shake_class, source_component, scale=1.000000, play_space=CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot=[0.000000, 0.000000, 0.000000]) -> CameraShakeBase
        Plays a camera shake on this camera.
        
        Args:
            shake_class (type(Class)): 
            source_component (CameraShakeSourceComponent): The source from which the camera shake originates.
            scale (float): Applies an additional constant scale on top of the dynamic scale computed with the distance to the source
            play_space (CameraShakePlaySpace): Which coordinate system to play the shake in (affects oscillations and camera anims)
            user_play_space_rot (Rotator): Coordinate system to play shake when PlaySpace == CAPS_UserDefined.
        
        Returns:
            CameraShakeBase:
        """
        ...
    def play_camera_shake_from_source(self, shake_class: Class, source_component: CameraShakeSourceComponent, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> CameraShakeBase:
        r"""
        deprecated: 'play_camera_shake_from_source' was renamed to 'start_camera_shake_from_source'.
        """
        ...
    def start_matinee_camera_shake_from_source(self, shake_class: Class, source_component: CameraShakeSourceComponent, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> CameraShakeBase:
        r"""
        deprecated: 'start_matinee_camera_shake_from_source' was renamed to 'start_camera_shake_from_source'.
        """
        ...
    def start_camera_shake(self, shake_class: Class, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> CameraShakeBase:
        r"""
        x.start_camera_shake(shake_class, scale=1.000000, play_space=CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot=[0.000000, 0.000000, 0.000000]) -> CameraShakeBase
        Plays a camera shake on this camera.
        
        Args:
            shake_class (type(Class)): 
            scale (float): Scalar defining how "intense" to play the shake. 1.0 is normal (as authored).
            play_space (CameraShakePlaySpace): Which coordinate system to play the shake in (affects oscillations and camera anims)
            user_play_space_rot (Rotator): Coordinate system to play shake when PlaySpace == CAPS_UserDefined.
        
        Returns:
            CameraShakeBase:
        """
        ...
    def play_camera_shake(self, shake_class: Class, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> CameraShakeBase:
        r"""
        deprecated: 'play_camera_shake' was renamed to 'start_camera_shake'.
        """
        ...
    def start_matinee_camera_shake(self, shake_class: Class, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> CameraShakeBase:
        r"""
        deprecated: 'start_matinee_camera_shake' was renamed to 'start_camera_shake'.
        """
        ...
    def start_camera_fade(self, from_alpha: float, to_alpha: float, duration: float, color: LinearColor, should_fade_audio: bool = False, hold_when_finished: bool = False) -> None:
        r"""
        x.start_camera_fade(from_alpha, to_alpha, duration, color, should_fade_audio=False, hold_when_finished=False) -> None
        Does a camera fade to/from a solid color.  Animates automatically.
        
        Args:
            from_alpha (float): Alpha at which to begin the fade. Range [0..1], where 0 is fully transparent and 1 is fully opaque solid color.
            to_alpha (float): Alpha at which to finish the fade.
            duration (float): How long the fade should take, in seconds.
            color (LinearColor): Color to fade to/from.
            should_fade_audio (bool): True to fade audio volume along with the alpha of the solid color.
            hold_when_finished (bool): True for fade to hold at the ToAlpha until explicitly stopped (e.g. with StopCameraFade)
        """
        ...
    def set_manual_camera_fade(self, fade_amount: float, color: LinearColor, fade_audio: bool) -> None:
        r"""
        x.set_manual_camera_fade(fade_amount, color, fade_audio) -> None
        Turns on camera fading at the given opacity. Does not auto-animate, allowing user to animate themselves.
        Call StopCameraFade to turn fading back off.
        
        Args:
            fade_amount (float): 
            color (LinearColor): 
            fade_audio (bool):
        """
        ...
    def set_game_camera_cut_this_frame(self) -> None:
        r"""
        x.set_game_camera_cut_this_frame() -> None
        Sets the bGameCameraCutThisFrame flag to true (indicating we did a camera cut this frame; useful for game code to call, e.g., when performing a teleport that should be seamless)
        """
        ...
    def remove_generic_camera_lens_effect(self, emitter: CameraLensEffectInterface) -> None:
        r"""
        x.remove_generic_camera_lens_effect(emitter) -> None
        Removes the given lens effect from the camera.
        
        Args:
            emitter (CameraLensEffectInterface): the emitter actor to remove from the camera
        """
        ...
    def remove_camera_modifier(self, modifier_to_remove: CameraModifier) -> bool:
        r"""
        x.remove_camera_modifier(modifier_to_remove) -> bool
        Removes the given camera modifier from this camera (if it's on the camera in the first place) and discards it.
        
        Args:
            modifier_to_remove (CameraModifier): 
        
        Returns:
            bool: True if successfully removed, false otherwise.
        """
        ...
    def photography_camera_modify(self, new_camera_location: Vector, previous_camera_location: Vector, original_camera_location: Vector) -> Vector:
        r"""
        x.photography_camera_modify(new_camera_location, previous_camera_location, original_camera_location) -> Vector
        Implementable blueprint hook to allow a PlayerCameraManager subclass to
        constrain or otherwise modify the camera during free-camera photography.
        For example, a blueprint may wish to limit the distance from the camera's
        original point, or forbid the camera from passing through walls.
        NewCameraLocation contains the proposed new camera location.
        PreviousCameraLocation contains the camera location in the previous frame.
        OriginalCameraLocation contains the camera location before the game was put
        into photography mode.
        Return ResultCameraLocation as modified according to your constraints.
        
        Args:
            new_camera_location (Vector): 
            previous_camera_location (Vector): 
            original_camera_location (Vector): 
        
        Returns:
            Vector: 
        
            result_camera_location (Vector):
        """
        ...
    def on_photography_session_start(self) -> None:
        r"""
        x.on_photography_session_start() -> None
        Event triggered upon entering Photography mode (before pausing, if
        r.Photography.AutoPause is 1).
        """
        ...
    def on_photography_session_end(self) -> None:
        r"""
        x.on_photography_session_end() -> None
        Event triggered upon leaving Photography mode (after unpausing, if
        r.Photography.AutoPause is 1).
        """
        ...
    def on_photography_multi_part_capture_start(self) -> None:
        r"""
        x.on_photography_multi_part_capture_start() -> None
        Event triggered upon the start of a multi-part photograph capture (i.e. a
        stereoscopic or 360-degree shot).  This is an ideal time to turn off
        rendering effects that tile badly (UI, subtitles, vignette, very aggressive
        bloom, etc; most of these are automatically disabled when
        r.Photography.AutoPostprocess is 1).
        """
        ...
    def on_photography_multi_part_capture_end(self) -> None:
        r"""
        x.on_photography_multi_part_capture_end() -> None
        Event triggered upon the end of a multi-part photograph capture, when manual
        free-roaming photographic camera control is about to be returned to the user.
        Here you may re-enable whatever was turned off within
        OnPhotographyMultiPartCaptureStart.
        """
        ...
    def get_owning_player_controller(self) -> PlayerController:
        r"""
        x.get_owning_player_controller() -> PlayerController
        Returns the PlayerController that owns this camera.
        
        Returns:
            PlayerController:
        """
        ...
    def get_fov_angle(self) -> float:
        r"""
        x.get_fov_angle() -> float
        Returns the camera's current full FOV angle, in degrees.
        
        Returns:
            float:
        """
        ...
    def get_camera_rotation(self) -> Rotator:
        r"""
        x.get_camera_rotation() -> Rotator
        Returns camera's current rotation.
        
        Returns:
            Rotator:
        """
        ...
    def get_camera_location(self) -> Vector:
        r"""
        x.get_camera_location() -> Vector
        Returns camera's current location.
        
        Returns:
            Vector:
        """
        ...
    def find_camera_modifier_by_class(self, modifier_class: Class) -> CameraModifier:
        r"""
        x.find_camera_modifier_by_class(modifier_class) -> CameraModifier
        Returns camera modifier for this camera of the given class, if it exists.
        Exact class match only. If there are multiple modifiers of the same class, the first one is returned.
        
        Args:
            modifier_class (type(Class)): 
        
        Returns:
            CameraModifier:
        """
        ...
    def clear_camera_lens_effects(self) -> None:
        r"""
        x.clear_camera_lens_effects() -> None
        Removes all camera lens effects.
        """
        ...
    def blueprint_update_camera(self, camera_target: Actor) -> Optional[Tuple[Vector, Rotator, float]]:
        r"""
        x.blueprint_update_camera(camera_target) -> (new_camera_location=Vector, new_camera_rotation=Rotator, new_camera_fov=float) or None
        Blueprint hook to allow blueprints to override existing camera behavior or implement custom cameras.
        If this function returns true, we will use the given returned values and skip further calculations to determine
        final camera POV.
        
        Args:
            camera_target (Actor): 
        
        Returns:
            tuple or None: 
        
            new_camera_location (Vector): 
        
            new_camera_rotation (Rotator): 
        
            new_camera_fov (float):
        """
        ...
    def kismet_update_camera(self, camera_target: Actor) -> Optional[Tuple[Vector, Rotator, float]]:
        r"""
        deprecated: 'kismet_update_camera' was renamed to 'blueprint_update_camera'.
        """
        ...
    def add_new_camera_modifier(self, modifier_class: Class) -> CameraModifier:
        r"""
        x.add_new_camera_modifier(modifier_class) -> CameraModifier
        Creates and initializes a new camera modifier of the specified class.
        
        Args:
            modifier_class (type(Class)): The class of camera modifier to create.
        
        Returns:
            CameraModifier: Returns the newly created camera modifier.
        """
        ...
    def add_generic_camera_lens_effect(self, lens_effect_emitter_class: Class) -> CameraLensEffectInterface:
        r"""
        x.add_generic_camera_lens_effect(lens_effect_emitter_class) -> CameraLensEffectInterface
        Creates a camera lens effect of the given class on this camera.
        
        Args:
            lens_effect_emitter_class (type(Class)): Class of lens effect emitter to create.
        
        Returns:
            CameraLensEffectInterface: Returns the new emitter actor.
        """
        ...

class PluginBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    A function library of utilities for querying information about plugins.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PluginBlueprintLibrary.h
    
    """
    @classmethod
    def is_plugin_mounted(cls, plugin_name: str) -> bool:
        r"""
        X.is_plugin_mounted(plugin_name) -> bool
        Determine whether a plugin is mounted.
        
        Args:
            plugin_name (str): Name of the plugin
        
        Returns:
            bool: true if the named plugin is mounted, or false otherwise
        """
        ...
    @classmethod
    def get_plugin_version_name(cls, plugin_name: str) -> Optional[str]:
        r"""
        X.get_plugin_version_name(plugin_name) -> str or None
        Get the version name of a plugin.
        
        Args:
            plugin_name (str): Name of the plugin
        
        Returns:
            str or None: true if the named plugin was found and the plugin's version name was stored in OutVersionName, or false otherwise
        
            out_version_name (str): Version name of the plugin, if found
        """
        ...
    @classmethod
    def get_plugin_version(cls, plugin_name: str) -> Optional[int]:
        r"""
        X.get_plugin_version(plugin_name) -> int32 or None
        Get the version number of a plugin.
        
        Args:
            plugin_name (str): Name of the plugin
        
        Returns:
            int32 or None: true if the named plugin was found and the plugin's version number was stored in OutVersion, or false otherwise
        
            out_version (int32): Version number of the plugin, if found
        """
        ...
    @classmethod
    def get_plugin_name_for_object_path(cls, object_path: SoftObjectPath) -> Optional[str]:
        r"""
        X.get_plugin_name_for_object_path(object_path) -> str or None
        Get the name of the plugin containing an object.
        
        Args:
            object_path (SoftObjectPath): Path to the object
        
        Returns:
            str or None: true if the object is contained within a plugin and the plugin name was stored in OutPluginName, or false otherwise
        
            out_plugin_name (str): Name of the plugin containing the object, if found
        """
        ...
    @classmethod
    def get_plugin_mounted_asset_path(cls, plugin_name: str) -> Optional[str]:
        r"""
        X.get_plugin_mounted_asset_path(plugin_name) -> str or None
        Get the virtual root path for assets in a plugin.
        
        Args:
            plugin_name (str): Name of the plugin
        
        Returns:
            str or None: true if the named plugin was found and the plugin's virtual root path was stored in OutAssetPath, or false otherwise
        
            out_asset_path (str): Virtual root path for the plugin's assets, if found
        """
        ...
    @classmethod
    def get_plugin_editor_custom_virtual_path(cls, plugin_name: str) -> Optional[str]:
        r"""
        X.get_plugin_editor_custom_virtual_path(plugin_name) -> str or None
        Get the editor custom virtual path of a plugin.
        
        Args:
            plugin_name (str): Name of the plugin
        
        Returns:
            str or None: true if the named plugin was found and the plugin's editor custom virtual path was stored in OutVirtualPath, or false otherwise
        
            out_virtual_path (str): Editor custom virtual path of the plugin, if found
        """
        ...
    @classmethod
    def get_plugin_descriptor_file_path(cls, plugin_name: str) -> Optional[str]:
        r"""
        X.get_plugin_descriptor_file_path(plugin_name) -> str or None
        Get the filesystem path to a plugin's descriptor.
        
        Args:
            plugin_name (str): Name of the plugin
        
        Returns:
            str or None: true if the named plugin was found and the plugin descriptor filesystem path was stored in OutFilePath, or false otherwise
        
            out_file_path (str): Filesystem path to the plugin's descriptor, if found
        """
        ...
    @classmethod
    def get_plugin_description(cls, plugin_name: str) -> Optional[str]:
        r"""
        X.get_plugin_description(plugin_name) -> str or None
        Get the description of a plugin.
        
        Args:
            plugin_name (str): Name of the plugin
        
        Returns:
            str or None: true if the named plugin was found and the plugin's description was stored in OutDescription, or false otherwise
        
            out_description (str): Description of the plugin, if found
        """
        ...
    @classmethod
    def get_plugin_content_dir(cls, plugin_name: str) -> Optional[str]:
        r"""
        X.get_plugin_content_dir(plugin_name) -> str or None
        Get the filesystem path to a plugin's content directory.
        
        Args:
            plugin_name (str): Name of the plugin
        
        Returns:
            str or None: true if the named plugin was found and the plugin content directory filesystem path was stored in OutContentDir, or false otherwise
        
            out_content_dir (str): Filesystem path to the plugin's content directory, if found
        """
        ...
    @classmethod
    def get_plugin_base_dir(cls, plugin_name: str) -> Optional[str]:
        r"""
        X.get_plugin_base_dir(plugin_name) -> str or None
        Get the filesystem path to a plugin's base directory.
        
        Args:
            plugin_name (str): Name of the plugin
        
        Returns:
            str or None: true if the named plugin was found and the plugin base directory filesystem path was stored in OutBaseDir, or false otherwise
        
            out_base_dir (str): Filesystem path to the plugin's base directory, if found
        """
        ...
    @classmethod
    def get_enabled_plugin_names(cls) -> Array[str]:
        r"""
        X.get_enabled_plugin_names() -> Array[str]
        Get the names of all enabled plugins.
        
        Returns:
            Array[str]: The names of all enabled plugins.
        """
        ...
    @classmethod
    def get_additional_project_plugin_search_paths(cls) -> Array[str]:
        r"""
        X.get_additional_project_plugin_search_paths() -> Array[str]
        Get the list of extra directories added by the project that are
        recursively searched for plugins.
        
        Returns:
            Array[str]: The additional project filesystem plugin search paths.
        """
        ...
    @classmethod
    def get_additional_plugin_search_paths(cls) -> Array[str]:
        r"""
        X.get_additional_plugin_search_paths() -> Array[str]
        Get the list of extra directories that are recursively searched for
        plugins (aside from the engine and project plugin directories).
        
        Returns:
            Array[str]: The additional filesystem plugin search paths.
        """
        ...

class PointLight(Light):
    r"""
    Point Light
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PointLight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``light_component`` (LightComponent):  [Read-Write]
      todo: document
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``point_light_component`` (PointLightComponent):  [Read-Only]
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def point_light_component(self) -> PointLightComponent:
        r"""
        (PointLightComponent):  [Read-Only]
        """
        ...
    def set_radius(self, new_radius: float) -> None:
        r"""
        x.set_radius(new_radius) -> None
        BEGIN DEPRECATED (use component functions now in level script)
        deprecated: Function 'SetRadius' is deprecated.
        
        Args:
            new_radius (float):
        """
        ...
    def set_light_falloff_exponent(self, new_light_falloff_exponent: float) -> None:
        r"""
        x.set_light_falloff_exponent(new_light_falloff_exponent) -> None
        Set Light Falloff Exponent
        deprecated: Function 'SetLightFalloffExponent' is deprecated.
        
        Args:
            new_light_falloff_exponent (float):
        """
        ...

class PointLightMovable(PointLight):
    r"""
    deprecated: 'PointLightMovable' was renamed to 'PointLight'.
    """
    ...

class PointLightStatic(PointLight):
    r"""
    deprecated: 'PointLightStatic' was renamed to 'PointLight'.
    """
    ...

class PointLightStationary(PointLight):
    r"""
    deprecated: 'PointLightStationary' was renamed to 'PointLight'.
    """
    ...

class PrecomputedVisibilityOverrideVolume(Volume):
    r"""
    Precomputed Visibility Override Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrecomputedVisibilityOverrideVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_invisible_actors`` (Array[Actor]):  [Read-Write] Array of actors that will always be considered invisible by Precomputed Visibility when viewed from inside this volume.
    - ``override_invisible_levels`` (Array[Name]):  [Read-Write] Array of level names whose actors will always be considered invisible by Precomputed Visibility when viewed from inside this volume.
    - ``override_visible_actors`` (Array[Actor]):  [Read-Write] Array of actors that will always be considered visible by Precomputed Visibility when viewed from inside this volume.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def override_visible_actors(self) -> Array[Actor]:
        r"""
        (Array[Actor]):  [Read-Write] Array of actors that will always be considered visible by Precomputed Visibility when viewed from inside this volume.
        """
        ...
    @override_visible_actors.setter
    def override_visible_actors(self, value: Array[Actor]) -> None:
        ...
    @property
    def override_invisible_actors(self) -> Array[Actor]:
        r"""
        (Array[Actor]):  [Read-Write] Array of actors that will always be considered invisible by Precomputed Visibility when viewed from inside this volume.
        """
        ...
    @override_invisible_actors.setter
    def override_invisible_actors(self, value: Array[Actor]) -> None:
        ...
    @property
    def override_invisible_levels(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Array of level names whose actors will always be considered invisible by Precomputed Visibility when viewed from inside this volume.
        """
        ...
    @override_invisible_levels.setter
    def override_invisible_levels(self, value: Array[Name]) -> None:
        ...

class RigidBodyBase(Actor):
    r"""
    Rigid Body Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RigidBodyBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class RadialForceActor(RigidBodyBase):
    r"""
    Radial Force Actor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RadialForceActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``force_component`` (RadialForceComponent):  [Read-Only] Force component
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def force_component(self) -> RadialForceComponent:
        r"""
        (RadialForceComponent):  [Read-Only] Force component
        """
        ...
    def toggle_force(self) -> None:
        r"""
        x.toggle_force() -> None
        Toggle Force
        deprecated: Function 'ToggleForce' is deprecated.
        """
        ...
    def fire_impulse(self) -> None:
        r"""
        x.fire_impulse() -> None
        BEGIN DEPRECATED (use component functions now in level script)
        deprecated: Function 'FireImpulse' is deprecated.
        """
        ...
    def enable_force(self) -> None:
        r"""
        x.enable_force() -> None
        Enable Force
        deprecated: Function 'EnableForce' is deprecated.
        """
        ...
    def disable_force(self) -> None:
        r"""
        x.disable_force() -> None
        Disable Force
        deprecated: Function 'DisableForce' is deprecated.
        """
        ...

class SceneCapture2D(SceneCapture):
    r"""
    Scene Capture 2D
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneCapture2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``capture_component2d`` (SceneCaptureComponent2D):  [Read-Only] Scene capture component.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``scene_component`` (SceneComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def capture_component2d(self) -> SceneCaptureComponent2D:
        r"""
        (SceneCaptureComponent2D):  [Read-Only] Scene capture component.
        """
        ...
    def on_interp_toggle(self, enable: bool) -> None:
        r"""
        x.on_interp_toggle(enable) -> None
        On Interp Toggle
        
        Args:
            enable (bool):
        """
        ...

class SceneCaptureComponent2D(SceneCaptureComponent):
    r"""
    Used to capture a 'snapshot' of the scene from a single plane and feed it to a render target.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneCaptureComponent2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``always_persist_rendering_state`` (bool):  [Read-Write] Whether to persist the rendering state even if bCaptureEveryFrame==false.  This allows velocities for Motion Blur and Temporal AA to be computed.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_calculate_ortho_planes`` (bool):  [Read-Write] Automatically determine a min/max Near/Far clip plane position depending on OrthoWidth value
    - ``auto_plane_shift`` (float):  [Read-Write] Manually adjusts the planes of this camera, maintaining the distance between them. Positive moves out to the farplane, negative towards the near plane
    - ``camera_cut_this_frame`` (bool):  [Read-Write] True if we did a camera cut this frame. Automatically reset to false at every capture.
      This flag affects various things in the renderer (such as whether to use the occlusion queries from last frame, and motion blur).
      Similar to UPlayerCameraManager::bGameCameraCutThisFrame.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capture_every_frame`` (bool):  [Read-Write] Whether to update the capture's contents every frame.  If disabled, the component will render once on load and then only when moved.
    - ``capture_on_movement`` (bool):  [Read-Write] Whether to update the capture's contents on movement.  Disable if you are going to capture manually from blueprint.
    - ``capture_sort_priority`` (int32):  [Read-Write] Capture priority within the frame to sort scene capture on GPU to resolve interdependencies between multiple capture components. Highest come first.
    - ``capture_source`` (SceneCaptureSource):  [Read-Write]
    - ``clip_plane_base`` (Vector):  [Read-Write] Base position for the clip plane, can be any position on the plane.
    - ``clip_plane_normal`` (Vector):  [Read-Write] Normal for the plane.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``composite_mode`` (SceneCaptureCompositeMode):  [Read-Write] When enabled, the scene capture will composite into the render target instead of overwriting its contents.
    - ``consider_unrendered_opaque_pixel_as_fully_translucent`` (bool):  [Read-Write] Whether to only render exponential height fog on opaque pixels which were rendered by the scene capture.
    - ``custom_near_clipping_plane`` (float):  [Read-Write] Set bOverride_CustomNearClippingPlane to true if you want to use a custom clipping plane instead of GNearClippingPlane.
    - ``custom_projection_matrix`` (Matrix):  [Read-Write] The custom projection matrix to use
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_clip_plane`` (bool):  [Read-Write] Enables a clip plane while rendering the scene capture which is useful for portals.
      The global clip plane must be enabled in the renderer project settings for this to work.
    - ``enable_orthographic_tiling`` (bool):  [Read-Write] Render the scene in n frames (i.e TileCount) - Ignored in Perspective mode, works only in Orthographic mode when CaptureSource uses SceneColor (not FinalColor)
      If CaptureSource uses FinalColor, tiling will be ignored and a Warning message will be logged
    - ``fov_angle`` (float):  [Read-Write] Camera field of view (in degrees).
    - ``hidden_actors`` (Array[Actor]):  [Read-Write] The actors to hide in the scene capture.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``lod_distance_factor`` (float):  [Read-Write] Scales the distance used by LOD. Set to values greater than 1 to cause the scene capture to use lower LODs than the main view to speed up the scene capture pass.
    - ``max_view_distance_override`` (float):  [Read-Write] if > 0, sets a maximum render distance override.  Can be used to cull distant objects from a reflection if the reflecting plane is in an enclosed area like a hallway or room
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``num_x_tiles`` (int32):  [Read-Write] Number of X tiles to render. Ignored in Perspective mode, works only in Orthographic mode
    - ``num_y_tiles`` (int32):  [Read-Write] Number of Y tiles to render. Ignored in Perspective mode, works only in Orthographic mode
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``ortho_width`` (float):  [Read-Write] The desired width (in world units) of the orthographic view (ignored in Perspective mode)
    - ``override_custom_near_clipping_plane`` (bool):  [Read-Write]
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``post_process_blend_weight`` (float):  [Read-Write] Range (0.0, 1.0) where 0 indicates no effect, 1 indicates full effect.
    - ``post_process_settings`` (PostProcessSettings):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``primitive_render_mode`` (SceneCapturePrimitiveRenderMode):  [Read-Write] Controls what primitives get rendered into the scene capture.
    - ``profiling_event_name`` (str):  [Read-Write] Name of the profiling event.
    - ``projection_type`` (CameraProjectionMode):  [Read-Write]
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_in_main_renderer`` (bool):  [Read-Write] Render scene capture as additional render passes of the main renderer rather than as an independent renderer. Can only apply to scene depth and device depth modes.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``show_flag_settings`` (Array[EngineShowFlagsSetting]):  [Read-Write] ShowFlags for the SceneCapture's ViewFamily, to control rendering settings for this view. Hidden but accessible through details customization
    - ``show_only_actors`` (Array[Actor]):  [Read-Write] The only actors to be rendered by this scene capture, if PrimitiveRenderMode is set to UseShowOnlyList.
    - ``texture_target`` (TextureRenderTarget2D):  [Read-Write] Output render target of the scene capture that can be read in materials.
    - ``update_ortho_planes`` (bool):  [Read-Write] Adjusts the near/far planes and the view origin of the current camera automatically to avoid clipping and light artefacting
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_camera_height_as_view_target`` (bool):  [Read-Write] If UpdateOrthoPlanes is enabled, this setting will use the cameras current height to compensate the distance to the general view (as a pseudo distance to view target when one isn't present)
    - ``use_custom_projection_matrix`` (bool):  [Read-Write] Whether a custom projection matrix will be used during rendering. Use with caution. Does not currently affect culling
    - ``use_faux_ortho_view_pos`` (bool):  [Read-Write]
      deprecated: 5.4 - bUseFauxOrthoViewPos has been deprecated alongside updates to Orthographic camera fixes
    - ``use_ray_tracing_if_enabled`` (bool):  [Read-Write] Whether to use ray tracing for this capture. Ray Tracing must be enabled in the project.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def projection_type(self) -> CameraProjectionMode:
        r"""
        (CameraProjectionMode):  [Read-Write]
        """
        ...
    @projection_type.setter
    def projection_type(self, value: CameraProjectionMode) -> None:
        ...
    @property
    def fov_angle(self) -> float:
        r"""
        (float):  [Read-Write] Camera field of view (in degrees).
        """
        ...
    @fov_angle.setter
    def fov_angle(self, value: float) -> None:
        ...
    @property
    def ortho_width(self) -> float:
        r"""
        (float):  [Read-Write] The desired width (in world units) of the orthographic view (ignored in Perspective mode)
        """
        ...
    @ortho_width.setter
    def ortho_width(self, value: float) -> None:
        ...
    @property
    def auto_calculate_ortho_planes(self) -> bool:
        r"""
        (bool):  [Read-Write] Automatically determine a min/max Near/Far clip plane position depending on OrthoWidth value
        """
        ...
    @auto_calculate_ortho_planes.setter
    def auto_calculate_ortho_planes(self, value: bool) -> None:
        ...
    @property
    def auto_plane_shift(self) -> float:
        r"""
        (float):  [Read-Write] Manually adjusts the planes of this camera, maintaining the distance between them. Positive moves out to the farplane, negative towards the near plane
        """
        ...
    @auto_plane_shift.setter
    def auto_plane_shift(self, value: float) -> None:
        ...
    @property
    def update_ortho_planes(self) -> bool:
        r"""
        (bool):  [Read-Write] Adjusts the near/far planes and the view origin of the current camera automatically to avoid clipping and light artefacting
        """
        ...
    @update_ortho_planes.setter
    def update_ortho_planes(self, value: bool) -> None:
        ...
    @property
    def use_camera_height_as_view_target(self) -> bool:
        r"""
        (bool):  [Read-Write] If UpdateOrthoPlanes is enabled, this setting will use the cameras current height to compensate the distance to the general view (as a pseudo distance to view target when one isn't present)
        """
        ...
    @use_camera_height_as_view_target.setter
    def use_camera_height_as_view_target(self, value: bool) -> None:
        ...
    @property
    def texture_target(self) -> TextureRenderTarget2D:
        r"""
        (TextureRenderTarget2D):  [Read-Write] Output render target of the scene capture that can be read in materials.
        """
        ...
    @texture_target.setter
    def texture_target(self, value: TextureRenderTarget2D) -> None:
        ...
    @property
    def composite_mode(self) -> SceneCaptureCompositeMode:
        r"""
        (SceneCaptureCompositeMode):  [Read-Write] When enabled, the scene capture will composite into the render target instead of overwriting its contents.
        """
        ...
    @composite_mode.setter
    def composite_mode(self, value: SceneCaptureCompositeMode) -> None:
        ...
    @property
    def post_process_settings(self) -> PostProcessSettings:
        r"""
        (PostProcessSettings):  [Read-Write]
        """
        ...
    @post_process_settings.setter
    def post_process_settings(self, value: PostProcessSettings) -> None:
        ...
    @property
    def post_process_blend_weight(self) -> float:
        r"""
        (float):  [Read-Write] Range (0.0, 1.0) where 0 indicates no effect, 1 indicates full effect.
        """
        ...
    @post_process_blend_weight.setter
    def post_process_blend_weight(self, value: float) -> None:
        ...
    @property
    def override_custom_near_clipping_plane(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_custom_near_clipping_plane.setter
    def override_custom_near_clipping_plane(self, value: bool) -> None:
        ...
    @property
    def custom_near_clipping_plane(self) -> float:
        r"""
        (float):  [Read-Write] Set bOverride_CustomNearClippingPlane to true if you want to use a custom clipping plane instead of GNearClippingPlane.
        """
        ...
    @custom_near_clipping_plane.setter
    def custom_near_clipping_plane(self, value: float) -> None:
        ...
    @property
    def use_custom_projection_matrix(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether a custom projection matrix will be used during rendering. Use with caution. Does not currently affect culling
        """
        ...
    @use_custom_projection_matrix.setter
    def use_custom_projection_matrix(self, value: bool) -> None:
        ...
    @property
    def custom_projection_matrix(self) -> Matrix:
        r"""
        (Matrix):  [Read-Write] The custom projection matrix to use
        """
        ...
    @custom_projection_matrix.setter
    def custom_projection_matrix(self, value: Matrix) -> None:
        ...
    @property
    def use_faux_ortho_view_pos(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: 5.4 - bUseFauxOrthoViewPos has been deprecated alongside updates to Orthographic camera fixes
        """
        ...
    @use_faux_ortho_view_pos.setter
    def use_faux_ortho_view_pos(self, value: bool) -> None:
        ...
    @property
    def enable_orthographic_tiling(self) -> bool:
        r"""
        (bool):  [Read-Write] Render the scene in n frames (i.e TileCount) - Ignored in Perspective mode, works only in Orthographic mode when CaptureSource uses SceneColor (not FinalColor)
        If CaptureSource uses FinalColor, tiling will be ignored and a Warning message will be logged
        """
        ...
    @enable_orthographic_tiling.setter
    def enable_orthographic_tiling(self, value: bool) -> None:
        ...
    @property
    def num_x_tiles(self) -> int:
        r"""
        (int32):  [Read-Write] Number of X tiles to render. Ignored in Perspective mode, works only in Orthographic mode
        """
        ...
    @num_x_tiles.setter
    def num_x_tiles(self, value: int) -> None:
        ...
    @property
    def num_y_tiles(self) -> int:
        r"""
        (int32):  [Read-Write] Number of Y tiles to render. Ignored in Perspective mode, works only in Orthographic mode
        """
        ...
    @num_y_tiles.setter
    def num_y_tiles(self, value: int) -> None:
        ...
    @property
    def enable_clip_plane(self) -> bool:
        r"""
        (bool):  [Read-Write] Enables a clip plane while rendering the scene capture which is useful for portals.
        The global clip plane must be enabled in the renderer project settings for this to work.
        """
        ...
    @enable_clip_plane.setter
    def enable_clip_plane(self, value: bool) -> None:
        ...
    @property
    def clip_plane_base(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Base position for the clip plane, can be any position on the plane.
        """
        ...
    @clip_plane_base.setter
    def clip_plane_base(self, value: Vector) -> None:
        ...
    @property
    def clip_plane_normal(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Normal for the plane.
        """
        ...
    @clip_plane_normal.setter
    def clip_plane_normal(self, value: Vector) -> None:
        ...
    @property
    def render_in_main_renderer(self) -> bool:
        r"""
        (bool):  [Read-Write] Render scene capture as additional render passes of the main renderer rather than as an independent renderer. Can only apply to scene depth and device depth modes.
        """
        ...
    @render_in_main_renderer.setter
    def render_in_main_renderer(self, value: bool) -> None:
        ...
    @property
    def camera_cut_this_frame(self) -> bool:
        r"""
        (bool):  [Read-Write] True if we did a camera cut this frame. Automatically reset to false at every capture.
        This flag affects various things in the renderer (such as whether to use the occlusion queries from last frame, and motion blur).
        Similar to UPlayerCameraManager::bGameCameraCutThisFrame.
        """
        ...
    @camera_cut_this_frame.setter
    def camera_cut_this_frame(self, value: bool) -> None:
        ...
    @property
    def consider_unrendered_opaque_pixel_as_fully_translucent(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to only render exponential height fog on opaque pixels which were rendered by the scene capture.
        """
        ...
    @consider_unrendered_opaque_pixel_as_fully_translucent.setter
    def consider_unrendered_opaque_pixel_as_fully_translucent(self, value: bool) -> None:
        ...
    def remove_blendable(self, blendable_object: BlendableInterface) -> None:
        r"""
        x.remove_blendable(blendable_object) -> None
        Removes a blendable.
        
        Args:
            blendable_object (BlendableInterface):
        """
        ...
    def capture_scene(self) -> None:
        r"""
        x.capture_scene() -> None
        Render the scene to the texture target immediately.
        This should not be used if bCaptureEveryFrame is enabled, or the scene capture will render redundantly.
        If r.SceneCapture.CullByDetailMode is set, nothing will happen if DetailMode is higher than r.DetailMode.
        """
        ...
    def update_content(self) -> None:
        r"""
        deprecated: 'update_content' was renamed to 'capture_scene'.
        """
        ...
    def add_or_update_blendable(self, blendable_object: BlendableInterface, weight: float = 1.000000) -> None:
        r"""
        x.add_or_update_blendable(blendable_object, weight=1.000000) -> None
        Adds an Blendable (implements IBlendableInterface) to the array of Blendables (if it doesn't exist) and update the weight
        
        Args:
            blendable_object (BlendableInterface): 
            weight (float):
        """
        ...

class SceneCaptureComponentCube(SceneCaptureComponent):
    r"""
    Used to capture a 'snapshot' of the scene from a 6 planes and feed it to a render target.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneCaptureComponentCube.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``always_persist_rendering_state`` (bool):  [Read-Write] Whether to persist the rendering state even if bCaptureEveryFrame==false.  This allows velocities for Motion Blur and Temporal AA to be computed.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capture_every_frame`` (bool):  [Read-Write] Whether to update the capture's contents every frame.  If disabled, the component will render once on load and then only when moved.
    - ``capture_on_movement`` (bool):  [Read-Write] Whether to update the capture's contents on movement.  Disable if you are going to capture manually from blueprint.
    - ``capture_rotation`` (bool):  [Read-Write] Preserve the rotation of the actor when updating the capture. The default behavior is to capture the cube aligned to the world axis system.
    - ``capture_sort_priority`` (int32):  [Read-Write] Capture priority within the frame to sort scene capture on GPU to resolve interdependencies between multiple capture components. Highest come first.
    - ``capture_source`` (SceneCaptureSource):  [Read-Write]
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_actors`` (Array[Actor]):  [Read-Write] The actors to hide in the scene capture.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``lod_distance_factor`` (float):  [Read-Write] Scales the distance used by LOD. Set to values greater than 1 to cause the scene capture to use lower LODs than the main view to speed up the scene capture pass.
    - ``max_view_distance_override`` (float):  [Read-Write] if > 0, sets a maximum render distance override.  Can be used to cull distant objects from a reflection if the reflecting plane is in an enclosed area like a hallway or room
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``primitive_render_mode`` (SceneCapturePrimitiveRenderMode):  [Read-Write] Controls what primitives get rendered into the scene capture.
    - ``profiling_event_name`` (str):  [Read-Write] Name of the profiling event.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``show_flag_settings`` (Array[EngineShowFlagsSetting]):  [Read-Write] ShowFlags for the SceneCapture's ViewFamily, to control rendering settings for this view. Hidden but accessible through details customization
    - ``show_only_actors`` (Array[Actor]):  [Read-Write] The only actors to be rendered by this scene capture, if PrimitiveRenderMode is set to UseShowOnlyList.
    - ``texture_target`` (TextureRenderTargetCube):  [Read-Write] Temporary render target that can be used by the editor.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_ray_tracing_if_enabled`` (bool):  [Read-Write] Whether to use ray tracing for this capture. Ray Tracing must be enabled in the project.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def texture_target(self) -> TextureRenderTargetCube:
        r"""
        (TextureRenderTargetCube):  [Read-Write] Temporary render target that can be used by the editor.
        """
        ...
    @texture_target.setter
    def texture_target(self, value: TextureRenderTargetCube) -> None:
        ...
    @property
    def capture_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] Preserve the rotation of the actor when updating the capture. The default behavior is to capture the cube aligned to the world axis system.
        """
        ...
    @capture_rotation.setter
    def capture_rotation(self, value: bool) -> None:
        ...
    def capture_scene(self) -> None:
        r"""
        x.capture_scene() -> None
        Render the scene to the texture target immediately.
        This should not be used if bCaptureEveryFrame is enabled, or the scene capture will render redundantly.
        If r.SceneCapture.CullByDetailMode is set, nothing will happen if DetailMode is higher than r.DetailMode.
        """
        ...
    def update_content(self) -> None:
        r"""
        deprecated: 'update_content' was renamed to 'capture_scene'.
        """
        ...

class SceneCaptureCube(SceneCapture):
    r"""
    Scene Capture Cube
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SceneCaptureCube.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``capture_component_cube`` (SceneCaptureComponentCube):  [Read-Only] Scene capture component.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``scene_component`` (SceneComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def capture_component_cube(self) -> SceneCaptureComponentCube:
        r"""
        (SceneCaptureComponentCube):  [Read-Only] Scene capture component.
        """
        ...
    def on_interp_toggle(self, enable: bool) -> None:
        r"""
        x.on_interp_toggle(enable) -> None
        On Interp Toggle
        
        Args:
            enable (bool):
        """
        ...

class ShadowMapTexture2D(Texture2D):
    r"""
    Shadow Map Texture 2D
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ShadowMapTexture2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    ...

class SkeletalMeshSocket(Object):
    r"""
    Skeletal Mesh Socket
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshSocket.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_name`` (Name):  [Read-Only]
    - ``force_always_animated`` (bool):  [Read-Write] If true then the hierarchy of bones this socket is attached to will always be
                evaluated, even if it had previously been removed due to the current lod setting
    - ``relative_location`` (Vector):  [Read-Write]
    - ``relative_rotation`` (Rotator):  [Read-Write]
    - ``relative_scale`` (Vector):  [Read-Write]
    - ``socket_name`` (Name):  [Read-Only] Defines a named attachment location on the USkeletalMesh.
      These are set up in editor and used as a shortcut instead of specifying
      everything explicitly to AttachComponent in the SkeletalMeshComponent.
      The Outer of a SkeletalMeshSocket should always be the USkeletalMesh.
    """
    @property
    def socket_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Defines a named attachment location on the USkeletalMesh.
        These are set up in editor and used as a shortcut instead of specifying
        everything explicitly to AttachComponent in the SkeletalMeshComponent.
        The Outer of a SkeletalMeshSocket should always be the USkeletalMesh.
        """
        ...
    @property
    def bone_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def relative_location(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def relative_rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only]
        """
        ...
    @property
    def relative_scale(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def force_always_animated(self) -> bool:
        r"""
        (bool):  [Read-Only] If true then the hierarchy of bones this socket is attached to will always be
                  evaluated, even if it had previously been removed due to the current lod setting
        """
        ...
    def initialize_socket_from_location(self, skel_comp: SkeletalMeshComponent, world_location: Vector, world_normal: Vector) -> None:
        r"""
        x.initialize_socket_from_location(skel_comp, world_location, world_normal) -> None
        Sets BoneName, RelativeLocation and RelativeRotation based on closest bone to WorldLocation and WorldNormal
        
        Args:
            skel_comp (SkeletalMeshComponent): 
            world_location (Vector): 
            world_normal (Vector):
        """
        ...
    def get_socket_location(self, skel_comp: SkeletalMeshComponent) -> Vector:
        r"""
        x.get_socket_location(skel_comp) -> Vector
        Get Socket Location
        
        Args:
            skel_comp (SkeletalMeshComponent): 
        
        Returns:
            Vector:
        """
        ...

class SkyLight(Info):
    r"""
    Sky Light
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkyLight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``light_component`` (SkyLightComponent):  [Read-Only]
      todo: document
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def light_component(self) -> SkyLightComponent:
        r"""
        (SkyLightComponent):  [Read-Only]
        todo: document
        """
        ...

class SkyLightComponent(LightComponentBase):
    r"""
    Sky Light Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkyLightComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_global_illumination`` (bool):  [Read-Write] Whether the light affects global illumination, when ray-traced global illumination is enabled.
    - ``affect_reflection`` (bool):  [Read-Write] Whether the light affects objects in reflections, when ray-traced reflection is enabled.
    - ``affect_translucent_lighting`` (bool):  [Read-Write] Whether the light affects translucency or not.  Disabling this can save GPU time when there are many small lights.
    - ``affects_world`` (bool):  [Read-Write] Whether the light can affect the world, or whether it is disabled.
      A disabled light will not contribute to the scene in any way.  This setting cannot be changed at runtime and unbuilds lighting when changed.
      Setting this to false has the same effect as deleting the light, so it is useful for non-destructive experiments.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capture_emissive_only`` (bool):  [Read-Write] Only capture emissive materials. Skips all lighting making the capture cheaper. Recomended when using CaptureEveryFrame
    - ``cast_deep_shadow`` (bool):  [Read-Write] Whether the light should cast high quality hair-strands self-shadowing. When this option is enabled, an extra GPU cost for this light.
    - ``cast_dynamic_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from dynamic objects.  Also requires Cast Shadows to be set to True.
    - ``cast_raytraced_shadow`` (CastRayTracedShadow):  [Read-Write]
    - ``cast_shadows`` (bool):  [Read-Write] Whether the light should cast any shadows.
    - ``cast_static_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from static objects.  Also requires Cast Shadows to be set to True.
    - ``cast_volumetric_shadow`` (bool):  [Read-Write] Whether the light shadows volumetric fog.  Disabling this can save GPU time.
    - ``cloud_ambient_occlusion`` (bool):  [Read-Write] Whether the cloud should occlude sky contribution within the atmosphere (progressively fading multiple scattering out) or not.
    - ``cloud_ambient_occlusion_aperture_scale`` (float):  [Read-Write] Controls the cone aperture angle over which the sky occlusion due to volumetric clouds is evaluated. A value of 1 means `take into account the entire hemisphere` resulting in blurry occlusion, while a value of 0 means `take into account a single up occlusion direction up` resulting in sharp occlusion.
    - ``cloud_ambient_occlusion_extent`` (float):  [Read-Write] The world space radius of the cloud ambient occlusion map around the camera in kilometers.
    - ``cloud_ambient_occlusion_map_resolution_scale`` (float):  [Read-Write] Scale the cloud ambient occlusion map resolution, base resolution is 512. The resolution is still clamped to 'r.VolumetricCloud.SkyAO.MaxResolution'.
    - ``cloud_ambient_occlusion_strength`` (float):  [Read-Write] The strength of the ambient occlusion, higher value will block more light.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``contrast`` (float):  [Read-Write] Contrast S-curve applied to the computed AO.  A value of 0 means no contrast increase, 1 is a significant contrast increase.
    - ``cubemap`` (TextureCube):  [Read-Write] Cubemap to use for sky lighting if SourceType is set to SLS_SpecifiedCubemap.
    - ``cubemap_resolution`` (int32):  [Read-Write] Maximum resolution for the very top processed cubemap mip. Must be a power of 2.
    - ``deep_shadow_layer_distribution`` (float):  [Read-Write] Change the deep shadow layers distribution 0:linear distribution (uniform layer distribution), 1:exponential (more details on near small details).
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``indirect_lighting_intensity`` (float):  [Read-Write] Scales the indirect lighting contribution from this light.
      A value of 0 disables any GI from this light. Default is 1.
    - ``intensity`` (float):  [Read-Write] Total energy that the light emits.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``light_color`` (Color):  [Read-Write] Filter color of the light.
      Note that this can change the light's effective intensity.
    - ``lower_hemisphere_color`` (LinearColor):  [Read-Write]
    - ``lower_hemisphere_is_black`` (bool):  [Read-Write] Whether all distant lighting from the lower hemisphere should be set to LowerHemisphereColor.
      Enabling this is accurate when lighting a scene on a planet where the ground blocks the sky,
      However disabling it can be useful to approximate skylight bounce lighting (eg Movable light).
    - ``min_occlusion`` (float):  [Read-Write] Controls the darkest that a fully occluded area can get.  This tends to destroy contact shadows, use Contrast or OcclusionExponent instead.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``occlusion_combine_mode`` (OcclusionCombineMode):  [Read-Write] Controls how occlusion from Distance Field Ambient Occlusion is combined with Screen Space Ambient Occlusion.
    - ``occlusion_exponent`` (float):  [Read-Write] Exponent applied to the computed AO.  Values lower than 1 brighten occlusion overall without losing contact shadows.
    - ``occlusion_max_distance`` (float):  [Read-Write] Max distance that the occlusion of one point will affect another.
      Higher values increase the cost of Distance Field AO exponentially.
    - ``occlusion_tint`` (Color):  [Read-Write] Tint color on occluded areas, artistic control.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``real_time_capture`` (bool):  [Read-Write] When enabled, the sky will be captured and convolved to achieve dynamic diffuse and specular environment lighting.
      SkyAtmosphere, VolumetricCloud Components as well as sky domes with Sky materials are taken into account.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``samples_per_pixel`` (int32):  [Read-Write] Samples per pixel for ray tracing
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sky_distance_threshold`` (float):  [Read-Write] Distance from the sky light at which any geometry should be treated as part of the sky.
      This is also used by reflection captures, so update reflection captures to see the impact.
    - ``source_cubemap_angle`` (float):  [Read-Write] Angle to rotate the source cubemap when SourceType is set to SLS_SpecifiedCubemap.
    - ``source_type`` (SkyLightSourceType):  [Read-Write] Indicates where to get the light contribution from.
    - ``transmission`` (bool):  [Read-Write] Whether light from this light transmits through surfaces with subsurface scattering profiles. Requires light to be movable.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volumetric_scattering_intensity`` (float):  [Read-Write] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
    """
    @property
    def real_time_capture(self) -> bool:
        r"""
        (bool):  [Read-Only] When enabled, the sky will be captured and convolved to achieve dynamic diffuse and specular environment lighting.
        SkyAtmosphere, VolumetricCloud Components as well as sky domes with Sky materials are taken into account.
        """
        ...
    @property
    def source_type(self) -> SkyLightSourceType:
        r"""
        (SkyLightSourceType):  [Read-Only] Indicates where to get the light contribution from.
        """
        ...
    @property
    def cubemap(self) -> TextureCube:
        r"""
        (TextureCube):  [Read-Only] Cubemap to use for sky lighting if SourceType is set to SLS_SpecifiedCubemap.
        """
        ...
    @property
    def source_cubemap_angle(self) -> float:
        r"""
        (float):  [Read-Only] Angle to rotate the source cubemap when SourceType is set to SLS_SpecifiedCubemap.
        """
        ...
    @property
    def cubemap_resolution(self) -> int:
        r"""
        (int32):  [Read-Only] Maximum resolution for the very top processed cubemap mip. Must be a power of 2.
        """
        ...
    @property
    def sky_distance_threshold(self) -> float:
        r"""
        (float):  [Read-Only] Distance from the sky light at which any geometry should be treated as part of the sky.
        This is also used by reflection captures, so update reflection captures to see the impact.
        """
        ...
    @property
    def capture_emissive_only(self) -> bool:
        r"""
        (bool):  [Read-Only] Only capture emissive materials. Skips all lighting making the capture cheaper. Recomended when using CaptureEveryFrame
        """
        ...
    @property
    def lower_hemisphere_is_black(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether all distant lighting from the lower hemisphere should be set to LowerHemisphereColor.
        Enabling this is accurate when lighting a scene on a planet where the ground blocks the sky,
        However disabling it can be useful to approximate skylight bounce lighting (eg Movable light).
        """
        ...
    @property
    def lower_hemisphere_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only]
        """
        ...
    @property
    def occlusion_max_distance(self) -> float:
        r"""
        (float):  [Read-Only] Max distance that the occlusion of one point will affect another.
        Higher values increase the cost of Distance Field AO exponentially.
        """
        ...
    @property
    def contrast(self) -> float:
        r"""
        (float):  [Read-Only] Contrast S-curve applied to the computed AO.  A value of 0 means no contrast increase, 1 is a significant contrast increase.
        """
        ...
    @property
    def occlusion_exponent(self) -> float:
        r"""
        (float):  [Read-Only] Exponent applied to the computed AO.  Values lower than 1 brighten occlusion overall without losing contact shadows.
        """
        ...
    @property
    def min_occlusion(self) -> float:
        r"""
        (float):  [Read-Only] Controls the darkest that a fully occluded area can get.  This tends to destroy contact shadows, use Contrast or OcclusionExponent instead.
        """
        ...
    @property
    def occlusion_tint(self) -> Color:
        r"""
        (Color):  [Read-Only] Tint color on occluded areas, artistic control.
        """
        ...
    @property
    def cloud_ambient_occlusion(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the cloud should occlude sky contribution within the atmosphere (progressively fading multiple scattering out) or not.
        """
        ...
    @property
    def cloud_ambient_occlusion_strength(self) -> float:
        r"""
        (float):  [Read-Only] The strength of the ambient occlusion, higher value will block more light.
        """
        ...
    @property
    def cloud_ambient_occlusion_extent(self) -> float:
        r"""
        (float):  [Read-Only] The world space radius of the cloud ambient occlusion map around the camera in kilometers.
        """
        ...
    @property
    def cloud_ambient_occlusion_map_resolution_scale(self) -> float:
        r"""
        (float):  [Read-Only] Scale the cloud ambient occlusion map resolution, base resolution is 512. The resolution is still clamped to 'r.VolumetricCloud.SkyAO.MaxResolution'.
        """
        ...
    @property
    def cloud_ambient_occlusion_aperture_scale(self) -> float:
        r"""
        (float):  [Read-Only] Controls the cone aperture angle over which the sky occlusion due to volumetric clouds is evaluated. A value of 1 means `take into account the entire hemisphere` resulting in blurry occlusion, while a value of 0 means `take into account a single up occlusion direction up` resulting in sharp occlusion.
        """
        ...
    @property
    def occlusion_combine_mode(self) -> OcclusionCombineMode:
        r"""
        (OcclusionCombineMode):  [Read-Only] Controls how occlusion from Distance Field Ambient Occlusion is combined with Screen Space Ambient Occlusion.
        """
        ...
    def set_volumetric_scattering_intensity(self, new_intensity: float) -> None:
        r"""
        x.set_volumetric_scattering_intensity(new_intensity) -> None
        Set Volumetric Scattering Intensity
        
        Args:
            new_intensity (float):
        """
        ...
    def set_source_cubemap_angle(self, new_value: float) -> None:
        r"""
        x.set_source_cubemap_angle(new_value) -> None
        Sets the angle of the cubemap used when SourceType is set to SpecifiedCubemap and it is non static. It will cause the skylight to update on the next tick.
        
        Args:
            new_value (float):
        """
        ...
    def set_occlusion_tint(self, tint: Color) -> None:
        r"""
        x.set_occlusion_tint(tint) -> None
        Set Occlusion Tint
        
        Args:
            tint (Color):
        """
        ...
    def set_occlusion_exponent(self, occlusion_exponent: float) -> None:
        r"""
        x.set_occlusion_exponent(occlusion_exponent) -> None
        Set Occlusion Exponent
        
        Args:
            occlusion_exponent (float):
        """
        ...
    def set_occlusion_contrast(self, occlusion_contrast: float) -> None:
        r"""
        x.set_occlusion_contrast(occlusion_contrast) -> None
        Set Occlusion Contrast
        
        Args:
            occlusion_contrast (float):
        """
        ...
    def set_min_occlusion(self, min_occlusion: float) -> None:
        r"""
        x.set_min_occlusion(min_occlusion) -> None
        Set Min Occlusion
        
        Args:
            min_occlusion (float):
        """
        ...
    def set_lower_hemisphere_color(self, lower_hemisphere_color: LinearColor) -> None:
        r"""
        x.set_lower_hemisphere_color(lower_hemisphere_color) -> None
        Set Lower Hemisphere Color
        
        Args:
            lower_hemisphere_color (LinearColor):
        """
        ...
    def set_light_color(self, new_light_color: LinearColor) -> None:
        r"""
        x.set_light_color(new_light_color) -> None
        Set color of the light
        
        Args:
            new_light_color (LinearColor):
        """
        ...
    def set_intensity(self, new_intensity: float) -> None:
        r"""
        x.set_intensity(new_intensity) -> None
        Set Intensity
        
        Args:
            new_intensity (float):
        """
        ...
    def set_brightness(self, new_intensity: float) -> None:
        r"""
        deprecated: 'set_brightness' was renamed to 'set_intensity'.
        """
        ...
    def set_indirect_lighting_intensity(self, new_intensity: float) -> None:
        r"""
        x.set_indirect_lighting_intensity(new_intensity) -> None
        Set Indirect Lighting Intensity
        
        Args:
            new_intensity (float):
        """
        ...
    def set_cubemap_blend(self, source_cubemap: TextureCube, destination_cubemap: TextureCube, blend_fraction: float) -> None:
        r"""
        x.set_cubemap_blend(source_cubemap, destination_cubemap, blend_fraction) -> None
        Creates sky lighting from a blend between two cubemaps, which is only valid when SourceType is set to SpecifiedCubemap.
        This can be used to seamlessly transition sky lighting between different times of day.
        The caller should continue to update the blend until BlendFraction is 0 or 1 to reduce rendering cost.
        The caller is responsible for avoiding pops due to changing the source or destination.
        
        Args:
            source_cubemap (TextureCube): 
            destination_cubemap (TextureCube): 
            blend_fraction (float):
        """
        ...
    def set_cubemap(self, new_cubemap: TextureCube) -> None:
        r"""
        x.set_cubemap(new_cubemap) -> None
        Sets the cubemap used when SourceType is set to SpecifiedCubemap, and causes a skylight update on the next tick.
        
        Args:
            new_cubemap (TextureCube):
        """
        ...
    def recapture_sky(self) -> None:
        r"""
        x.recapture_sky() -> None
        Recaptures the scene for the skylight.
        This is useful for making sure the sky light is up to date after changing something in the world that it would capture.
        Warning: this is very costly and will definitely cause a hitch.
        """
        ...

class SoundAttenuation(Object):
    r"""
    Defines how a sound changes volume with distance to the listener
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundAttenuation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attenuation`` (SoundAttenuationSettings):  [Read-Write]
    """
    @property
    def attenuation(self) -> SoundAttenuationSettings:
        r"""
        (SoundAttenuationSettings):  [Read-Write]
        """
        ...
    @attenuation.setter
    def attenuation(self, value: SoundAttenuationSettings) -> None:
        ...

class SoundEffectPresetWidgetInterface(AudioPanelWidgetInterface):
    r"""
    Sound Effect Preset Widget Interface
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundEffectPresetWidgetInterface.h
    
    """
    def on_property_changed(self, preset: SoundEffectPreset, property_name: Name) -> None:
        r"""
        x.on_property_changed(preset, property_name) -> None
        Called when the preset object is changed
        
        Args:
            preset (SoundEffectPreset): 
            property_name (Name):
        """
        ...
    def on_constructed(self, preset: SoundEffectPreset) -> None:
        r"""
        x.on_constructed(preset) -> None
        Called when the preset widget is constructed
        
        Args:
            preset (SoundEffectPreset):
        """
        ...
    def get_class(self) -> Class:
        r"""
        x.get_class() -> type(Class)
        Returns the class of Preset the widget supports
        
        Returns:
            type(Class):
        """
        ...

class SoundEffectSourcePreset(SoundEffectPreset):
    r"""
    Preset of a source effect that can be shared between chains.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundEffectSource.h
    
    """
    ...

class SoundEffectSourcePresetChain(Object):
    r"""
    Chain of source effect presets that can be shared between referencing sounds.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundEffectSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``chain`` (Array[SourceEffectChainEntry]):  [Read-Write] Chain of source effects to use for this sound source.
    - ``play_effect_chain_tails`` (bool):  [Read-Write] Whether to keep the source alive for the duration of the effect chain tails.
    """
    ...

class SoundNode(Object):
    r"""
    Sound Node
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    """
    @property
    def child_nodes(self) -> Array[SoundNode]:
        r"""
        (Array[SoundNode]):  [Read-Only]
        """
        ...

class SoundNodeModulatorContinuous(SoundNode):
    r"""
    Allows named parameter based manipulation of pitch and volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeModulatorContinuous.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``pitch_modulation_params`` (ModulatorContinuousParams):  [Read-Write]
    - ``volume_modulation_params`` (ModulatorContinuousParams):  [Read-Write]
    """
    ...

class SoundSubmixWidgetInterface(Interface):
    r"""
    Sound Submix Widget Interface
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmixWidgetInterface.h
    
    """
    def on_constructed(self, sound_submix: SoundSubmixBase) -> None:
        r"""
        x.on_constructed(sound_submix) -> None
        On Constructed
        
        Args:
            sound_submix (SoundSubmixBase):
        """
        ...

class SparseVolumeTexture(Object):
    r"""
    SparseVolumeTexture base interface to communicate with material graph and shader bindings.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SparseVolumeTexture.h
    
    """
    def get_size_z(self) -> int:
        r"""
        x.get_size_z() -> int32
        Get Size Z
        
        Returns:
            int32:
        """
        ...
    def get_size_y(self) -> int:
        r"""
        x.get_size_y() -> int32
        Get Size Y
        
        Returns:
            int32:
        """
        ...
    def get_size_x(self) -> int:
        r"""
        x.get_size_x() -> int32
        Get Size X
        
        Returns:
            int32:
        """
        ...
    def get_num_mip_levels(self) -> int:
        r"""
        x.get_num_mip_levels() -> int32
        Get Num Mip Levels
        
        Returns:
            int32:
        """
        ...
    def get_num_frames(self) -> int:
        r"""
        x.get_num_frames() -> int32
        Get Num Frames
        
        Returns:
            int32:
        """
        ...
    def get_frame_transform(self) -> Transform:
        r"""
        x.get_frame_transform() -> Transform
        Get Frame Transform
        
        Returns:
            Transform:
        """
        ...

class SparseVolumeTextureFrame(SparseVolumeTexture):
    r"""
    Represents a frame in a SparseVolumeTexture sequence and owns the actual data needed for rendering. Is owned by a UStreamableSparseVolumeTexture object.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SparseVolumeTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``transform`` (Transform):  [Read-Only]
    """
    ...

class StreamableSparseVolumeTexture(SparseVolumeTexture):
    r"""
    Represents a streamable SparseVolumeTexture asset and serves as base class for UStaticSparseVolumeTexture and UAnimatedSparseVolumeTexture. It has an array of USparseVolumeTextureFrame.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SparseVolumeTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``address_z`` (TextureAddress):  [Read-Write] The addressing mode to use for the Z axis.
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``fallback_value_a`` (Vector4f):  [Read-Only]
    - ``fallback_value_b`` (Vector4f):  [Read-Only]
    - ``format_a`` (PixelFormat):  [Read-Only]
    - ``format_b`` (PixelFormat):  [Read-Only]
    - ``local_ddc_only`` (bool):  [Read-Write] If enabled, the SparseVolumeTexture is only going to use the local DDC. For certain assets it might be reasonable to also use the remote DDC, but for larger assets this will mean long up- and download times.
    - ``num_frames`` (int32):  [Read-Only]
    - ``num_mip_levels`` (int32):  [Read-Only]
    - ``number_of_prefetch_frames`` (int32):  [Read-Write] When using non-blocking streaming requests, upcoming frames are loaded into memory in advance. This property controls how many frames to prefetch.
    - ``prefetch_percentage_bias`` (float):  [Read-Write] When using non-blocking streaming requests, upcoming frames are loaded into memory in advance. This property applies a bias in percent to how much data is prefetched for every frame.
      A value of 20.0 adds 20% to all prefetch percentages. So if PrefetchPercentageStepSize is set to 20.0, frame N+1 is prefetched at 80% + 20% = 100%, frame N+2 at 60% + 20% = 80%, N+3 at 40% + 20% = 60% etc.
    - ``prefetch_percentage_step_size`` (float):  [Read-Write] When using non-blocking streaming requests, upcoming frames are loaded into memory in advance. This property controls the size reduction in percent of each additional prefetched frames.
      A value of 20.0 would prefetch frame N+1 at 80%, N+2 at 60%, N+3 at 40% etc.
    - ``streaming_pool_size_factor`` (float):  [Read-Write] The SVT streaming pool is sized such that it can hold the largest frame multiplied by this value. There should be some slack to allow for prefetching frames.
    - ``volume_resolution`` (IntVector):  [Read-Only]
    """
    @property
    def address_x(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
        """
        ...
    @address_x.setter
    def address_x(self, value: TextureAddress) -> None:
        ...
    @property
    def address_y(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
        """
        ...
    @address_y.setter
    def address_y(self, value: TextureAddress) -> None:
        ...
    @property
    def address_z(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the Z axis.
        """
        ...
    @address_z.setter
    def address_z(self, value: TextureAddress) -> None:
        ...
    @property
    def local_ddc_only(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the SparseVolumeTexture is only going to use the local DDC. For certain assets it might be reasonable to also use the remote DDC, but for larger assets this will mean long up- and download times.
        """
        ...
    @local_ddc_only.setter
    def local_ddc_only(self, value: bool) -> None:
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class StaticSparseVolumeTexture(StreamableSparseVolumeTexture):
    r"""
    Represents a streamable SparseVolumeTexture asset with a single frame. Although there is only a single frame, it is still recommended to use USparseVolumeTextureFrame::GetFrameAndIssueStreamingRequest().
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SparseVolumeTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``address_z`` (TextureAddress):  [Read-Write] The addressing mode to use for the Z axis.
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``fallback_value_a`` (Vector4f):  [Read-Only]
    - ``fallback_value_b`` (Vector4f):  [Read-Only]
    - ``format_a`` (PixelFormat):  [Read-Only]
    - ``format_b`` (PixelFormat):  [Read-Only]
    - ``local_ddc_only`` (bool):  [Read-Write] If enabled, the SparseVolumeTexture is only going to use the local DDC. For certain assets it might be reasonable to also use the remote DDC, but for larger assets this will mean long up- and download times.
    - ``num_frames`` (int32):  [Read-Only]
    - ``num_mip_levels`` (int32):  [Read-Only]
    - ``number_of_prefetch_frames`` (int32):  [Read-Write] When using non-blocking streaming requests, upcoming frames are loaded into memory in advance. This property controls how many frames to prefetch.
    - ``prefetch_percentage_bias`` (float):  [Read-Write] When using non-blocking streaming requests, upcoming frames are loaded into memory in advance. This property applies a bias in percent to how much data is prefetched for every frame.
      A value of 20.0 adds 20% to all prefetch percentages. So if PrefetchPercentageStepSize is set to 20.0, frame N+1 is prefetched at 80% + 20% = 100%, frame N+2 at 60% + 20% = 80%, N+3 at 40% + 20% = 60% etc.
    - ``prefetch_percentage_step_size`` (float):  [Read-Write] When using non-blocking streaming requests, upcoming frames are loaded into memory in advance. This property controls the size reduction in percent of each additional prefetched frames.
      A value of 20.0 would prefetch frame N+1 at 80%, N+2 at 60%, N+3 at 40% etc.
    - ``streaming_pool_size_factor`` (float):  [Read-Write] The SVT streaming pool is sized such that it can hold the largest frame multiplied by this value. There should be some slack to allow for prefetching frames.
    - ``volume_resolution`` (IntVector):  [Read-Only]
    """
    ...

class AnimatedSparseVolumeTexture(StreamableSparseVolumeTexture):
    r"""
    Represents a streamable SparseVolumeTexture with one or more frames. Use USparseVolumeTextureFrame::GetFrameAndIssueStreamingRequest() to bind extract a particular frame to be used for rendering.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SparseVolumeTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``address_z`` (TextureAddress):  [Read-Write] The addressing mode to use for the Z axis.
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``fallback_value_a`` (Vector4f):  [Read-Only]
    - ``fallback_value_b`` (Vector4f):  [Read-Only]
    - ``format_a`` (PixelFormat):  [Read-Only]
    - ``format_b`` (PixelFormat):  [Read-Only]
    - ``local_ddc_only`` (bool):  [Read-Write] If enabled, the SparseVolumeTexture is only going to use the local DDC. For certain assets it might be reasonable to also use the remote DDC, but for larger assets this will mean long up- and download times.
    - ``num_frames`` (int32):  [Read-Only]
    - ``num_mip_levels`` (int32):  [Read-Only]
    - ``number_of_prefetch_frames`` (int32):  [Read-Write] When using non-blocking streaming requests, upcoming frames are loaded into memory in advance. This property controls how many frames to prefetch.
    - ``prefetch_percentage_bias`` (float):  [Read-Write] When using non-blocking streaming requests, upcoming frames are loaded into memory in advance. This property applies a bias in percent to how much data is prefetched for every frame.
      A value of 20.0 adds 20% to all prefetch percentages. So if PrefetchPercentageStepSize is set to 20.0, frame N+1 is prefetched at 80% + 20% = 100%, frame N+2 at 60% + 20% = 80%, N+3 at 40% + 20% = 60% etc.
    - ``prefetch_percentage_step_size`` (float):  [Read-Write] When using non-blocking streaming requests, upcoming frames are loaded into memory in advance. This property controls the size reduction in percent of each additional prefetched frames.
      A value of 20.0 would prefetch frame N+1 at 80%, N+2 at 60%, N+3 at 40% etc.
    - ``streaming_pool_size_factor`` (float):  [Read-Write] The SVT streaming pool is sized such that it can hold the largest frame multiplied by this value. There should be some slack to allow for prefetching frames.
    - ``volume_resolution`` (IntVector):  [Read-Only]
    """
    ...

class AnimatedSparseVolumeTextureController(Object):
    r"""
    Utility (blueprint) class for controlling SparseVolumeTexture playback.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SparseVolumeTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blocking_streaming_requests`` (bool):  [Read-Write]
    - ``frame_rate`` (float):  [Read-Write]
    - ``is_playing`` (bool):  [Read-Write]
    - ``mip_level`` (int32):  [Read-Write]
    - ``sparse_volume_texture`` (SparseVolumeTexture):  [Read-Write]
    - ``time`` (float):  [Read-Write]
    """
    @property
    def sparse_volume_texture(self) -> SparseVolumeTexture:
        r"""
        (SparseVolumeTexture):  [Read-Write]
        """
        ...
    @sparse_volume_texture.setter
    def sparse_volume_texture(self, value: SparseVolumeTexture) -> None:
        ...
    @property
    def time(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @time.setter
    def time(self, value: float) -> None:
        ...
    @property
    def is_playing(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_playing.setter
    def is_playing(self, value: bool) -> None:
        ...
    @property
    def frame_rate(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @frame_rate.setter
    def frame_rate(self, value: float) -> None:
        ...
    @property
    def mip_level(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @mip_level.setter
    def mip_level(self, value: int) -> None:
        ...
    @property
    def blocking_streaming_requests(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @blocking_streaming_requests.setter
    def blocking_streaming_requests(self, value: bool) -> None:
        ...
    def update(self, delta_time: float) -> None:
        r"""
        x.update(delta_time) -> None
        Update
        
        Args:
            delta_time (float):
        """
        ...
    def stop(self) -> None:
        r"""
        x.stop() -> None
        Stop
        """
        ...
    def play(self) -> None:
        r"""
        x.play() -> None
        Play
        """
        ...
    def pause(self) -> None:
        r"""
        x.pause() -> None
        Pause
        """
        ...
    def get_frame_by_index(self, frame_index: int) -> SparseVolumeTextureFrame:
        r"""
        x.get_frame_by_index(frame_index) -> SparseVolumeTextureFrame
        Get Frame by Index
        
        Args:
            frame_index (int32): 
        
        Returns:
            SparseVolumeTextureFrame:
        """
        ...
    def get_fractional_frame_index(self) -> float:
        r"""
        x.get_fractional_frame_index() -> float
        Get Fractional Frame Index
        
        Returns:
            float:
        """
        ...
    def get_duration(self) -> float:
        r"""
        x.get_duration() -> float
        Get Duration
        
        Returns:
            float:
        """
        ...
    def get_current_frames_for_interpolation(self) -> Tuple[SparseVolumeTextureFrame, SparseVolumeTextureFrame, float]:
        r"""
        x.get_current_frames_for_interpolation() -> (frame0=SparseVolumeTextureFrame, frame1=SparseVolumeTextureFrame, lerp_alpha=float)
        Get Current Frames for Interpolation
        
        Returns:
            tuple: 
        
            frame0 (SparseVolumeTextureFrame): 
        
            frame1 (SparseVolumeTextureFrame): 
        
            lerp_alpha (float):
        """
        ...
    def get_current_frame(self) -> SparseVolumeTextureFrame:
        r"""
        x.get_current_frame() -> SparseVolumeTextureFrame
        Get Current Frame
        
        Returns:
            SparseVolumeTextureFrame:
        """
        ...

class SphereReflectionCapture(ReflectionCapture):
    r"""
    Actor used to capture the scene for reflection in a sphere shape.
    see: https://docs.unrealengine.com/latest/INT/Resources/ContentExamples/Reflections/1_4
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SphereReflectionCapture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``capture_component`` (ReflectionCaptureComponent):  [Read-Only] Reflection capture component.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class SphereReflectionCaptureComponent(ReflectionCaptureComponent):
    r"""
    -> will be exported to EngineDecalClasses.h
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SphereReflectionCaptureComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``brightness`` (float):  [Read-Write] A brightness control to scale the captured scene's reflection intensity.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capture_offset`` (Vector):  [Read-Write] World space offset to apply before capturing.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``cubemap`` (TextureCube):  [Read-Write] Cubemap to use for reflection if ReflectionSourceType is set to RS_SpecifiedCubemap.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``influence_radius`` (float):  [Read-Write] Radius of the area that can receive reflections from this capture.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``reflection_source_type`` (ReflectionSourceType):  [Read-Write] Indicates where to get the reflection source from.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``source_cubemap_angle`` (float):  [Read-Write] Angle to rotate the source cubemap when SourceType is set to SLS_SpecifiedCubemap.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def influence_radius(self) -> float:
        r"""
        (float):  [Read-Write] Radius of the area that can receive reflections from this capture.
        """
        ...
    @influence_radius.setter
    def influence_radius(self, value: float) -> None:
        ...

class StaticMeshSocket(Object):
    r"""
    Static Mesh Socket
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StaticMeshSocket.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``preview_static_mesh`` (StaticMesh):  [Read-Write]
    - ``relative_location`` (Vector):  [Read-Write]
    - ``relative_rotation`` (Rotator):  [Read-Write]
    - ``relative_scale`` (Vector):  [Read-Write]
    - ``socket_name`` (Name):  [Read-Write] Defines a named attachment location on the UStaticMesh.
      These are set up in editor and used as a shortcut instead of specifying
      everything explicitly to AttachComponent in the StaticMeshComponent.
      The Outer of a StaticMeshSocket should always be the UStaticMesh.
    - ``tag`` (str):  [Read-Write]
    """
    @property
    def socket_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Defines a named attachment location on the UStaticMesh.
        These are set up in editor and used as a shortcut instead of specifying
        everything explicitly to AttachComponent in the StaticMeshComponent.
        The Outer of a StaticMeshSocket should always be the UStaticMesh.
        """
        ...
    @property
    def relative_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @relative_location.setter
    def relative_location(self, value: Vector) -> None:
        ...
    @property
    def relative_rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @relative_rotation.setter
    def relative_rotation(self, value: Rotator) -> None:
        ...
    @property
    def relative_scale(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @relative_scale.setter
    def relative_scale(self, value: Vector) -> None:
        ...
    @property
    def tag(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @tag.setter
    def tag(self, value: str) -> None:
        ...

class StereoLayerShape(Object):
    r"""
    Stereo Layer Shape
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StereoLayerComponent.h
    
    """
    ...

class StereoLayerShapeQuad(StereoLayerShape):
    r"""
    Stereo Layer Shape Quad
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StereoLayerComponent.h
    
    """
    ...

class StereoLayerShapeCylinder(StereoLayerShape):
    r"""
    Stereo Layer Shape Cylinder
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StereoLayerComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``height`` (int32):  [Read-Write] Height of the stereo layer cylinder *
    - ``overlay_arc`` (float):  [Read-Write] Arc angle for the stereo layer cylinder *
    - ``radius`` (float):  [Read-Write] Radial size of the rendered stereo layer cylinder *
    """
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Only] Radial size of the rendered stereo layer cylinder *
        """
        ...
    @property
    def overlay_arc(self) -> float:
        r"""
        (float):  [Read-Only] Arc angle for the stereo layer cylinder *
        """
        ...
    @property
    def height(self) -> int:
        r"""
        (int32):  [Read-Only] Height of the stereo layer cylinder *
        """
        ...
    def set_radius(self, radius: float) -> None:
        r"""
        x.set_radius(radius) -> None
        Set Radius
        
        Args:
            radius (float):
        """
        ...
    def set_overlay_arc(self, overlay_arc: float) -> None:
        r"""
        x.set_overlay_arc(overlay_arc) -> None
        Set Overlay Arc
        
        Args:
            overlay_arc (float):
        """
        ...
    def set_height(self, height: int) -> None:
        r"""
        x.set_height(height) -> None
        Set Height
        
        Args:
            height (int32):
        """
        ...

class StereoLayerShapeCubemap(StereoLayerShape):
    r"""
    Stereo Layer Shape Cubemap
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StereoLayerComponent.h
    
    """
    ...

class StereoLayerShapeEquirect(StereoLayerShape):
    r"""
    Stereo Layer Shape Equirect
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StereoLayerComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``left_bias`` (Vector2D):  [Read-Write] Left eye's texture coordinate bias after mapping to 2D.
    - ``left_scale`` (Vector2D):  [Read-Write] Left eye's texture coordinate scale after mapping to 2D.
    - ``left_uv_rect`` (Box2D):  [Read-Write] Left source texture UVRect, specifying portion of input texture corresponding to left eye.
    - ``radius`` (float):  [Read-Write] Sphere radius. As of UE 5.3, equirect layers are supported only by the Oculus OpenXR runtime and only with a radius of 0 (infinite sphere).
    - ``right_bias`` (Vector2D):  [Read-Write] Right eye's texture coordinate bias after mapping to 2D.
    - ``right_scale`` (Vector2D):  [Read-Write] Right eye's texture coordinate scale after mapping to 2D.
    - ``right_uv_rect`` (Box2D):  [Read-Write] Right source texture UVRect, specifying portion of input texture corresponding to right eye.
    """
    @property
    def left_uv_rect(self) -> Box2D:
        r"""
        (Box2D):  [Read-Only] Left source texture UVRect, specifying portion of input texture corresponding to left eye.
        """
        ...
    @property
    def right_uv_rect(self) -> Box2D:
        r"""
        (Box2D):  [Read-Only] Right source texture UVRect, specifying portion of input texture corresponding to right eye.
        """
        ...
    @property
    def left_scale(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] Left eye's texture coordinate scale after mapping to 2D.
        """
        ...
    @property
    def right_scale(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] Right eye's texture coordinate scale after mapping to 2D.
        """
        ...
    @property
    def left_bias(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] Left eye's texture coordinate bias after mapping to 2D.
        """
        ...
    @property
    def right_bias(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] Right eye's texture coordinate bias after mapping to 2D.
        """
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Only] Sphere radius. As of UE 5.3, equirect layers are supported only by the Oculus OpenXR runtime and only with a radius of 0 (infinite sphere).
        """
        ...
    def set_equirect_props(self, scale_biases: EquirectProps) -> None:
        r"""
        x.set_equirect_props(scale_biases) -> None
        Set Equirect layer properties: UVRect, Scale, and Bias
        
        Args:
            scale_biases (EquirectProps):
        """
        ...

class StereoLayerComponent(SceneComponent):
    r"""
    A geometry layer within the stereo rendered viewport.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StereoLayerComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``additional_flags`` (Array[Name]):  [Read-Write] Additional flags not included in IStereoLayers::ELayerFlags
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``left_texture`` (Texture):  [Read-Write] Texture displayed on the stereo layer for left eye, if stereoscopic textures are supported on the platform and by the layer shape *
    - ``live_texture`` (bool):  [Read-Write] True if the stereo layer texture needs to update itself every frame(scene capture, video, etc.)
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``no_alpha_channel`` (bool):  [Read-Write] True if the texture should not use its own alpha channel (1.0 will be substituted)
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``priority`` (int32):  [Read-Write] Render priority among all stereo layers, higher priority render on top of lower priority *
    - ``quad_preserve_texture_ratio`` (bool):  [Read-Write] True if the quad should internally set it's Y value based on the set texture's dimensions
    - ``quad_size`` (Vector2D):  [Read-Write] Size of the rendered stereo layer quad *
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``shape`` (StereoLayerShape):  [Read-Write] Specifies which shape of layer it is.  Note that some shapes will be supported only on certain platforms! *
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``stereo_layer_type`` (StereoLayerType):  [Read-Write] Specifies how and where the quad is rendered to the screen *
    - ``supports_depth`` (bool):  [Read-Write] True if the stereo layer needs to support depth intersections with the scene geometry, if available on the platform
    - ``texture`` (Texture):  [Read-Write] Texture displayed on the stereo layer (if stereoscopic textures are supported on the platform and more than one texture is provided, this will be the right eye) *
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``uv_rect`` (Box2D):  [Read-Write] UV coordinates mapped to the quad face *
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def live_texture(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the stereo layer texture needs to update itself every frame(scene capture, video, etc.)
        """
        ...
    @live_texture.setter
    def live_texture(self, value: bool) -> None:
        ...
    @property
    def supports_depth(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the stereo layer needs to support depth intersections with the scene geometry, if available on the platform
        """
        ...
    @supports_depth.setter
    def supports_depth(self, value: bool) -> None:
        ...
    @property
    def no_alpha_channel(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the texture should not use its own alpha channel (1.0 will be substituted)
        """
        ...
    @no_alpha_channel.setter
    def no_alpha_channel(self, value: bool) -> None:
        ...
    @property
    def texture(self) -> Texture:
        r"""
        (Texture):  [Read-Only] Texture displayed on the stereo layer (if stereoscopic textures are supported on the platform and more than one texture is provided, this will be the right eye) *
        """
        ...
    @property
    def left_texture(self) -> Texture:
        r"""
        (Texture):  [Read-Only] Texture displayed on the stereo layer for left eye, if stereoscopic textures are supported on the platform and by the layer shape *
        """
        ...
    @property
    def quad_preserve_texture_ratio(self) -> bool:
        r"""
        (bool):  [Read-Write] True if the quad should internally set it's Y value based on the set texture's dimensions
        """
        ...
    @quad_preserve_texture_ratio.setter
    def quad_preserve_texture_ratio(self, value: bool) -> None:
        ...
    @property
    def additional_flags(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Only] Additional flags not included in IStereoLayers::ELayerFlags
        """
        ...
    @property
    def quad_size(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] Size of the rendered stereo layer quad *
        """
        ...
    @property
    def uv_rect(self) -> Box2D:
        r"""
        (Box2D):  [Read-Only] UV coordinates mapped to the quad face *
        """
        ...
    @property
    def stereo_layer_type(self) -> StereoLayerType:
        r"""
        (StereoLayerType):  [Read-Only] Specifies how and where the quad is rendered to the screen *
        """
        ...
    @property
    def shape(self) -> StereoLayerShape:
        r"""
        (StereoLayerShape):  [Read-Only] Specifies which shape of layer it is.  Note that some shapes will be supported only on certain platforms! *
        """
        ...
    @property
    def priority(self) -> int:
        r"""
        (int32):  [Read-Only] Render priority among all stereo layers, higher priority render on top of lower priority *
        """
        ...
    def set_uv_rect(self, uv_rect: Box2D) -> None:
        r"""
        x.set_uv_rect(uv_rect) -> None
        Change the UV coordinates mapped to the quad face
        
        Args:
            uv_rect (Box2D):
        """
        ...
    def set_texture(self, texture: Texture) -> None:
        r"""
        x.set_texture(texture) -> None
        Change the texture displayed on the stereo layer.
        
        If stereoscopic layer textures are supported on the platform and LeftTexture is set, this property controls the texture for the right eye.
        
        Args:
            texture (Texture):
        """
        ...
    def set_quad_size(self, quad_size: Vector2D) -> None:
        r"""
        x.set_quad_size(quad_size) -> None
        Change the quad size. This is the unscaled height and width, before component scale is applied.
        
        Args:
            quad_size (Vector2D):
        """
        ...
    def set_priority(self, priority: int) -> None:
        r"""
        x.set_priority(priority) -> None
        Change the layer's render priority, higher priorities render on top of lower priorities
        
        Args:
            priority (int32):
        """
        ...
    def set_left_texture(self, texture: Texture) -> None:
        r"""
        x.set_left_texture(texture) -> None
        Change the texture displayed on the stereo layer for left eye, if stereoscopic layer textures are supported on the platform.
        
        Args:
            texture (Texture):
        """
        ...
    def set_equirect_props(self, equirect_props: EquirectProps) -> None:
        r"""
        x.set_equirect_props(equirect_props) -> None
        Set Equirect layer properties: UVRect, Scale, Bias and Radius.
        deprecated: Use UStereoLayerShapeEquirect::SetEquirectProps() instead.
        
        Args:
            equirect_props (EquirectProps):
        """
        ...
    def mark_texture_for_update(self) -> None:
        r"""
        x.mark_texture_for_update() -> None
        Manually mark the stereo layer texture for updating
        """
        ...
    def get_uv_rect(self) -> Box2D:
        r"""
        x.get_uv_rect() -> Box2D
        
        
        Returns:
            Box2D: the UV coordinates mapped to the quad face
        """
        ...
    def get_texture(self) -> Texture:
        r"""
        x.get_texture() -> Texture
        
        
        Returns:
            Texture: the texture mapped to the stereo layer.
        """
        ...
    def get_quad_size(self) -> Vector2D:
        r"""
        x.get_quad_size() -> Vector2D
        
        
        Returns:
            Vector2D: the height and width of the rendered quad
        """
        ...
    def get_priority(self) -> int:
        r"""
        x.get_priority() -> int32
        
        
        Returns:
            int32: the render priority
        """
        ...
    def get_left_texture(self) -> Texture:
        r"""
        x.get_left_texture() -> Texture
        
        
        Returns:
            Texture: the texture mapped to the stereo layer for left eye, if stereoscopic layer textures are supported on the platform.
        """
        ...

class TextRenderActor(Actor):
    r"""
    Text Render Actor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextRenderActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``text_render`` (TextRenderComponent):  [Read-Only] Component to render a text in 3d with a font
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def text_render(self) -> TextRenderComponent:
        r"""
        (TextRenderComponent):  [Read-Only] Component to render a text in 3d with a font
        """
        ...

class TextRenderComponent(PrimitiveComponent):
    r"""
    Renders text in the world with given font. Contains usual font related attributes such as Scale, Alignment, Color etc.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextRenderComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``always_render_as_text`` (bool):  [Read-Write] Allows text to draw unmodified when using debug visualization modes. *
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``font`` (Font):  [Read-Write] Text font
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``horiz_spacing_adjust`` (float):  [Read-Write] Horizontal adjustment per character, default is 0.0
    - ``horizontal_alignment`` (HorizTextAligment):  [Read-Write] Horizontal text alignment
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``text`` (Text):  [Read-Write] Text content, can be multi line using <br> as line separator
    - ``text_material`` (MaterialInterface):  [Read-Write] Text material
    - ``text_render_color`` (Color):  [Read-Write] Color of the text, can be accessed as vertex color
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``vert_spacing_adjust`` (float):  [Read-Write] Vertical adjustment per character, default is 0.0
    - ``vertical_alignment`` (VerticalTextAligment):  [Read-Write] Vertical text alignment
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``world_size`` (float):  [Read-Write] Vertical size of the fonts largest character in world units. Transform, XScale and YScale will affect final size.
    - ``x_scale`` (float):  [Read-Write] Horizontal scale, default is 1.0
    - ``y_scale`` (float):  [Read-Write] Vertical scale, default is 1.0
    """
    @property
    def text(self) -> Text:
        r"""
        (Text):  [Read-Only] Text content, can be multi line using <br> as line separator
        """
        ...
    @property
    def text_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Only] Text material
        """
        ...
    @property
    def font(self) -> Font:
        r"""
        (Font):  [Read-Only] Text font
        """
        ...
    @property
    def horizontal_alignment(self) -> HorizTextAligment:
        r"""
        (HorizTextAligment):  [Read-Only] Horizontal text alignment
        """
        ...
    @property
    def vertical_alignment(self) -> VerticalTextAligment:
        r"""
        (VerticalTextAligment):  [Read-Only] Vertical text alignment
        """
        ...
    @property
    def text_render_color(self) -> Color:
        r"""
        (Color):  [Read-Only] Color of the text, can be accessed as vertex color
        """
        ...
    @property
    def x_scale(self) -> float:
        r"""
        (float):  [Read-Only] Horizontal scale, default is 1.0
        """
        ...
    @property
    def y_scale(self) -> float:
        r"""
        (float):  [Read-Only] Vertical scale, default is 1.0
        """
        ...
    @property
    def world_size(self) -> float:
        r"""
        (float):  [Read-Only] Vertical size of the fonts largest character in world units. Transform, XScale and YScale will affect final size.
        """
        ...
    @property
    def horiz_spacing_adjust(self) -> float:
        r"""
        (float):  [Read-Only] Horizontal adjustment per character, default is 0.0
        """
        ...
    @property
    def vert_spacing_adjust(self) -> float:
        r"""
        (float):  [Read-Only] Vertical adjustment per character, default is 0.0
        """
        ...
    @property
    def always_render_as_text(self) -> bool:
        r"""
        (bool):  [Read-Only] Allows text to draw unmodified when using debug visualization modes. *
        """
        ...
    def set_y_scale(self, value: float) -> None:
        r"""
        x.set_y_scale(value) -> None
        Change the text Y scale and signal the primitives to be rebuilt
        
        Args:
            value (float):
        """
        ...
    def set_x_scale(self, value: float) -> None:
        r"""
        x.set_x_scale(value) -> None
        Change the text X scale and signal the primitives to be rebuilt
        
        Args:
            value (float):
        """
        ...
    def set_world_size(self, value: float) -> None:
        r"""
        x.set_world_size(value) -> None
        Change the world size of the text and signal the primitives to be rebuilt
        
        Args:
            value (float):
        """
        ...
    def set_vert_spacing_adjust(self, value: float) -> None:
        r"""
        x.set_vert_spacing_adjust(value) -> None
        Change the text vertical spacing adjustment and signal the primitives to be rebuilt
        
        Args:
            value (float):
        """
        ...
    def set_vertical_alignment(self, value: VerticalTextAligment) -> None:
        r"""
        x.set_vertical_alignment(value) -> None
        Change the vertical alignment and signal the primitives to be rebuilt
        
        Args:
            value (VerticalTextAligment):
        """
        ...
    def set_text_render_color(self, value: Color) -> None:
        r"""
        x.set_text_render_color(value) -> None
        Change the text render color and signal the primitives to be rebuilt
        
        Args:
            value (Color):
        """
        ...
    def set_text_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_text_material(material) -> None
        Change the text material and signal the primitives to be rebuilt
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_horiz_spacing_adjust(self, value: float) -> None:
        r"""
        x.set_horiz_spacing_adjust(value) -> None
        Change the text horizontal spacing adjustment and signal the primitives to be rebuilt
        
        Args:
            value (float):
        """
        ...
    def set_horizontal_alignment(self, value: HorizTextAligment) -> None:
        r"""
        x.set_horizontal_alignment(value) -> None
        Change the horizontal alignment and signal the primitives to be rebuilt
        
        Args:
            value (HorizTextAligment):
        """
        ...
    def set_font(self, value: Font) -> None:
        r"""
        x.set_font(value) -> None
        Change the font and signal the primitives to be rebuilt
        
        Args:
            value (Font):
        """
        ...
    def set_text(self, value: Text) -> None:
        r"""
        x.set_text(value) -> None
        Change the text value and signal the primitives to be rebuilt
        
        Args:
            value (Text):
        """
        ...
    def get_text_world_size(self) -> Vector:
        r"""
        x.get_text_world_size() -> Vector
        Get world space size of text
        
        Returns:
            Vector:
        """
        ...
    def get_text_local_size(self) -> Vector:
        r"""
        x.get_text_local_size() -> Vector
        Get local size of text
        
        Returns:
            Vector:
        """
        ...

class TimelineComponent(ActorComponent):
    r"""
    TimelineComponent holds a series of events, floats, vectors or colors with associated keyframes.
    Events can be triggered at keyframes along the timeline.
    Floats, vectors, and colors are interpolated between keyframes along the timeline.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimelineComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    def stop(self) -> None:
        r"""
        x.stop() -> None
        Stop playback of timeline
        """
        ...
    def set_vector_curve(self, new_vector_curve: CurveVector, vector_track_name: Name) -> None:
        r"""
        x.set_vector_curve(new_vector_curve, vector_track_name) -> None
        Update a certain vector track's curve
        
        Args:
            new_vector_curve (CurveVector): 
            vector_track_name (Name):
        """
        ...
    def set_timeline_post_update_func(self, new_timeline_post_update_func: OnTimelineEvent) -> None:
        r"""
        x.set_timeline_post_update_func(new_timeline_post_update_func) -> None
        Set the delegate to call after each timeline tick
        
        Args:
            new_timeline_post_update_func (OnTimelineEvent):
        """
        ...
    def set_timeline_length_mode(self, new_length_mode: TimelineLengthMode) -> None:
        r"""
        x.set_timeline_length_mode(new_length_mode) -> None
        Sets the length mode of the timeline
        
        Args:
            new_length_mode (TimelineLengthMode):
        """
        ...
    def set_timeline_length(self, new_length: float) -> None:
        r"""
        x.set_timeline_length(new_length) -> None
        Set length of the timeline
        
        Args:
            new_length (float):
        """
        ...
    def set_timeline_finished_func(self, new_timeline_finished_func: OnTimelineEvent) -> None:
        r"""
        x.set_timeline_finished_func(new_timeline_finished_func) -> None
        Set the delegate to call when timeline is finished
        
        Args:
            new_timeline_finished_func (OnTimelineEvent):
        """
        ...
    def set_play_rate(self, new_rate: float) -> None:
        r"""
        x.set_play_rate(new_rate) -> None
        Sets the new play rate for this timeline
        
        Args:
            new_rate (float):
        """
        ...
    def set_playback_position(self, new_position: float, fire_events: bool, fire_update: bool = True) -> None:
        r"""
        x.set_playback_position(new_position, fire_events, fire_update=True) -> None
        Jump to a position in the timeline.
        
        Args:
            new_position (float): 
            fire_events (bool): If true, event functions that are between current position and new playback position will fire.
            fire_update (bool): If true, the update output exec will fire after setting the new playback position.
        """
        ...
    def set_new_time(self, new_time: float) -> None:
        r"""
        x.set_new_time(new_time) -> None
        Set the new playback position time to use
        
        Args:
            new_time (float):
        """
        ...
    def set_looping(self, new_looping: bool) -> None:
        r"""
        x.set_looping(new_looping) -> None
        true means we would loop, false means we should not.
        
        Args:
            new_looping (bool):
        """
        ...
    def set_linear_color_curve(self, new_linear_color_curve: CurveLinearColor, linear_color_track_name: Name) -> None:
        r"""
        x.set_linear_color_curve(new_linear_color_curve, linear_color_track_name) -> None
        Update a certain linear color track's curve
        
        Args:
            new_linear_color_curve (CurveLinearColor): 
            linear_color_track_name (Name):
        """
        ...
    def set_ignore_time_dilation(self, new_ignore_time_dilation: bool) -> None:
        r"""
        x.set_ignore_time_dilation(new_ignore_time_dilation) -> None
        Set whether to ignore time dilation.
        
        Args:
            new_ignore_time_dilation (bool):
        """
        ...
    def set_float_curve(self, new_float_curve: CurveFloat, float_track_name: Name) -> None:
        r"""
        x.set_float_curve(new_float_curve, float_track_name) -> None
        Update a certain float track's curve
        
        Args:
            new_float_curve (CurveFloat): 
            float_track_name (Name):
        """
        ...
    def reverse_from_end(self) -> None:
        r"""
        x.reverse_from_end() -> None
        Start playback of timeline in reverse from the end
        """
        ...
    def reverse(self) -> None:
        r"""
        x.reverse() -> None
        Start playback of timeline in reverse
        """
        ...
    def play_from_start(self) -> None:
        r"""
        x.play_from_start() -> None
        Start playback of timeline from the start
        """
        ...
    def play(self) -> None:
        r"""
        x.play() -> None
        Start playback of timeline
        """
        ...
    def is_reversing(self) -> bool:
        r"""
        x.is_reversing() -> bool
        Get whether we are reversing or not
        
        Returns:
            bool:
        """
        ...
    def is_playing(self) -> bool:
        r"""
        x.is_playing() -> bool
        Get whether this timeline is playing or not.
        
        Returns:
            bool:
        """
        ...
    def is_looping(self) -> bool:
        r"""
        x.is_looping() -> bool
        Get whether we are looping or not
        
        Returns:
            bool:
        """
        ...
    def get_timeline_length(self) -> float:
        r"""
        x.get_timeline_length() -> float
        Get length of the timeline
        
        Returns:
            float:
        """
        ...
    def get_scaled_timeline_length(self) -> float:
        r"""
        x.get_scaled_timeline_length() -> float
        Get length of the timeline divided by the play rate
        
        Returns:
            float:
        """
        ...
    def get_play_rate(self) -> float:
        r"""
        x.get_play_rate() -> float
        Get the current play rate for this timeline
        
        Returns:
            float:
        """
        ...
    def get_playback_position(self) -> float:
        r"""
        x.get_playback_position() -> float
        Get the current playback position of the Timeline
        
        Returns:
            float:
        """
        ...
    def get_ignore_time_dilation(self) -> bool:
        r"""
        x.get_ignore_time_dilation() -> bool
        Get whether to ignore time dilation.
        
        Returns:
            bool:
        """
        ...
    def add_interp_vector(self, vector_curve: CurveVector, interp_func: OnTimelineVector, property_name: Name = "None", track_name: Name = "None") -> None:
        r"""
        x.add_interp_vector(vector_curve, interp_func, property_name="None", track_name="None") -> None
        Add a vector interpolation to the timeline
        
        Args:
            vector_curve (CurveVector): 
            interp_func (OnTimelineVector): 
            property_name (Name): 
            track_name (Name):
        """
        ...
    def add_interp_linear_color(self, linear_color_curve: CurveLinearColor, interp_func: OnTimelineLinearColor, property_name: Name = "None", track_name: Name = "None") -> None:
        r"""
        x.add_interp_linear_color(linear_color_curve, interp_func, property_name="None", track_name="None") -> None
        Add a linear color interpolation to the timeline
        
        Args:
            linear_color_curve (CurveLinearColor): 
            interp_func (OnTimelineLinearColor): 
            property_name (Name): 
            track_name (Name):
        """
        ...
    def add_interp_float(self, float_curve: CurveFloat, interp_func: OnTimelineFloat, property_name: Name = "None", track_name: Name = "None") -> None:
        r"""
        x.add_interp_float(float_curve, interp_func, property_name="None", track_name="None") -> None
        Add a float interpolation to the timeline
        
        Args:
            float_curve (CurveFloat): 
            interp_func (OnTimelineFloat): 
            property_name (Name): 
            track_name (Name):
        """
        ...
    def add_event(self, time: float, event_func: OnTimelineEvent) -> None:
        r"""
        x.add_event(time, event_func) -> None
        Add a callback event to the timeline
        
        Args:
            time (float): 
            event_func (OnTimelineEvent):
        """
        ...

class TriggerBase(Actor):
    r"""
    An actor used to generate collision events (begin/end overlap) in the level.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TriggerBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``collision_component`` (ShapeComponent):  [Read-Only] Shape component used for collision
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_component`` (BillboardComponent):  [Read-Write] Billboard used to see the trigger in the editor
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def collision_component(self) -> ShapeComponent:
        r"""
        (ShapeComponent):  [Read-Only] Shape component used for collision
        """
        ...
    @property
    def sprite_component(self) -> BillboardComponent:
        r"""
        (BillboardComponent):  [Read-Only] Billboard used to see the trigger in the editor
        """
        ...

class TriggerBox(TriggerBase):
    r"""
    A box shaped trigger, used to generate overlap events in the level
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TriggerBox.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``collision_component`` (ShapeComponent):  [Read-Only] Shape component used for collision
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_component`` (BillboardComponent):  [Read-Write] Billboard used to see the trigger in the editor
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class TriggerCapsule(TriggerBase):
    r"""
    A capsule shaped trigger, used to generate overlap events in the level
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TriggerCapsule.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``collision_component`` (ShapeComponent):  [Read-Only] Shape component used for collision
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_component`` (BillboardComponent):  [Read-Write] Billboard used to see the trigger in the editor
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class TriggerSphere(TriggerBase):
    r"""
    A sphere shaped trigger, used to generate overlap events in the level
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TriggerSphere.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``collision_component`` (ShapeComponent):  [Read-Only] Shape component used for collision
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_component`` (BillboardComponent):  [Read-Write] Billboard used to see the trigger in the editor
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class UniversalObjectLocatorScriptingExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto FUniversalObjectLocators for scripting
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: UniversalObjectLocatorScriptingExtensions.h
    
    """
    @classmethod
    def universal_object_locator_from_string(cls, string: str) -> UniversalObjectLocator:
        r"""
        X.universal_object_locator_from_string(string) -> UniversalObjectLocator
        Construct a new universal object locator from a string
        
        Args:
            string (str): 
        
        Returns:
            UniversalObjectLocator:
        """
        ...
    @classmethod
    def to_string(cls, locator: UniversalObjectLocator) -> str:
        r"""
        X.to_string(locator) -> str
        Convert the specified locator to its string representation
        
        Args:
            locator (UniversalObjectLocator): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def sync_unload(cls, locator: UniversalObjectLocator, context: Object = None) -> None:
        r"""
        X.sync_unload(locator, context=None) -> None
        Attempt to resolve the object locator by unloading the object if possible.
        
        Args:
            locator (UniversalObjectLocator): 
            context (Object): (Optional) Context object to use for resolving the object. This should usually be the object that owns or created the locator.
        """
        ...
    @classmethod
    def sync_load(cls, locator: UniversalObjectLocator, context: Object = None) -> Object:
        r"""
        X.sync_load(locator, context=None) -> Object
        Attempt to resolve the object locator by finding or loading the object.
        
        Args:
            locator (UniversalObjectLocator): 
            context (Object): (Optional) Context object to use for resolving the object. This should usually be the object that owns or created the locator.
        
        Returns:
            Object: The resolve object pointer, or null if it was not found.
        """
        ...
    @classmethod
    def sync_find(cls, locator: UniversalObjectLocator, context: Object = None) -> Object:
        r"""
        X.sync_find(locator, context=None) -> Object
        Attempt to resolve the object locator by finding the object. If it is not currently loaded or created,
        
        Args:
            locator (UniversalObjectLocator): 
            context (Object): (Optional) Context object to use for resolving the object. This should usually be the object that owns or created the locator.
        
        Returns:
            Object: The resolve object pointer, or null if it was not found.
        """
        ...
    @classmethod
    def make_universal_object_locator(cls, object: Object, context: Object) -> UniversalObjectLocator:
        r"""
        X.make_universal_object_locator(object, context) -> UniversalObjectLocator
        Construct a new universal object locator
        
        Args:
            object (Object): 
            context (Object): 
        
        Returns:
            UniversalObjectLocator:
        """
        ...
    @classmethod
    def is_empty(cls, locator: UniversalObjectLocator) -> bool:
        r"""
        X.is_empty(locator) -> bool
        Check whether the specified locator is empty; not equivalent to Resolve() != None.
        An empty locator will never resolve to a valid object.
        
        Args:
            locator (UniversalObjectLocator): 
        
        Returns:
            bool:
        """
        ...

class VectorFieldComponent(PrimitiveComponent):
    r"""
    A Component referencing a vector field.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VectorFieldComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``intensity`` (float):  [Read-Write] The intensity at which the vector field is applied.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``tightness`` (float):  [Read-Write] How tightly particles follow the vector field.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``vector_field`` (VectorField):  [Read-Write] The vector field asset.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def vector_field(self) -> VectorField:
        r"""
        (VectorField):  [Read-Write] The vector field asset.
        """
        ...
    @vector_field.setter
    def vector_field(self, value: VectorField) -> None:
        ...
    @property
    def intensity(self) -> float:
        r"""
        (float):  [Read-Write] The intensity at which the vector field is applied.
        """
        ...
    @intensity.setter
    def intensity(self, value: float) -> None:
        ...
    @property
    def tightness(self) -> float:
        r"""
        (float):  [Read-Write] How tightly particles follow the vector field.
        """
        ...
    @tightness.setter
    def tightness(self, value: float) -> None:
        ...
    def set_intensity(self, new_intensity: float) -> None:
        r"""
        x.set_intensity(new_intensity) -> None
        Set the intensity of the vector field.
        
        Args:
            new_intensity (float): The new intensity of the vector field.
        """
        ...

class WindDirectionalSourceComponent(SceneComponent):
    r"""
    Component that provides a directional wind source. Only affects SpeedTree assets.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WindDirectionalSourceComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``max_gust_amount`` (float):  [Read-Write]
    - ``min_gust_amount`` (float):  [Read-Write]
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``point_wind`` (bool):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``radius`` (float):  [Read-Write]
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``speed`` (float):  [Read-Write]
    - ``strength`` (float):  [Read-Write]
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def strength(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @strength.setter
    def strength(self, value: float) -> None:
        ...
    @property
    def speed(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @speed.setter
    def speed(self, value: float) -> None:
        ...
    @property
    def min_gust_amount(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def max_gust_amount(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def point_wind(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    def set_wind_type(self, new_type: WindSourceType) -> None:
        r"""
        x.set_wind_type(new_type) -> None
        Set the type of wind generator to use
        
        Args:
            new_type (WindSourceType):
        """
        ...
    def set_strength(self, new_strength: float) -> None:
        r"""
        x.set_strength(new_strength) -> None
        Sets the strength of the generated wind
        
        Args:
            new_strength (float):
        """
        ...
    def set_speed(self, new_speed: float) -> None:
        r"""
        x.set_speed(new_speed) -> None
        Sets the windspeed of the generated wind
        
        Args:
            new_speed (float):
        """
        ...
    def set_radius(self, new_radius: float) -> None:
        r"""
        x.set_radius(new_radius) -> None
        Set the effect radius for point wind
        
        Args:
            new_radius (float):
        """
        ...
    def set_minimum_gust_amount(self, new_min_gust: float) -> None:
        r"""
        x.set_minimum_gust_amount(new_min_gust) -> None
        Set minimum deviation for wind gusts
        
        Args:
            new_min_gust (float):
        """
        ...
    def set_maximum_gust_amount(self, new_max_gust: float) -> None:
        r"""
        x.set_maximum_gust_amount(new_max_gust) -> None
        Set maximum deviation for wind gusts
        
        Args:
            new_max_gust (float):
        """
        ...

class HierarchicalLODSetup(Object):
    r"""
    Hierarchical LODSetup
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``hierarchical_lod_setup`` (Array[HierarchicalSimplification]):  [Read-Write] Hierarchical LOD Setup
    - ``override_base_material`` (MaterialInterface):  [Read-Write]
    """
    ...

class WorldSettings(Info):
    r"""
    Actor containing all script accessible world properties.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``ai_system_class`` (Class):  [Read-Write]
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``base_navmesh_data_layers`` (Array[DataLayerAsset]):  [Read-Write] A list of runtime data layers that should be included in the base navmesh.
      Editor data layers and actors outside data layers will be included.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``broadphase_settings`` (BroadphaseSettings):  [Read-Write]
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_ambient_zone_settings`` (InteriorSettings):  [Read-Write] Default interior settings applied to sounds that have "apply ambient volumes" set to true on their SoundClass.
    - ``default_base_sound_mix`` (SoundMix):  [Read-Write] Default Base SoundMix.
    - ``default_color_scale`` (Vector):  [Read-Write] Default color scale for the level
    - ``default_game_mode`` (type(Class)):  [Read-Write] The default GameMode to use when starting this map in the game. If this value is NULL, the INI setting for default game type is used.
    - ``default_max_distance_field_occlusion_distance`` (float):  [Read-Write] Max occlusion distance used by mesh distance fields, overridden if there is a movable skylight.
    - ``default_physics_volume_class`` (type(Class)):  [Read-Write] level specific default physics volume
    - ``default_reverb_settings`` (ReverbSettings):  [Read-Write] Default reverb settings used by audio volumes.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``dynamic_indirect_shadows_self_shadowing_intensity`` (float):  [Read-Write] Controls the intensity of self-shadowing from capsule indirect shadows.
      These types of shadows use approximate occluder representations, so reducing self-shadowing intensity can hide those artifacts.
    - ``enable_ai_system`` (bool):  [Read-Write] if set to false AI system will not get created. Use it to disable all AI-related activity on a map
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_large_worlds`` (bool):  [Read-Write]
      deprecated: As of UE 5.1 all worlds are large. Set UE_USE_UE4_WORLD_MAX in EngineDefines.h to alter this.
    - ``enable_navigation_system`` (bool):  [Read-Write]
    - ``enable_world_bounds_checks`` (bool):  [Read-Write] If true, enables CheckStillInWorld checks
    - ``enable_world_composition`` (bool):  [Read-Write] Enables tools for composing a tiled world.
      Level has to be saved and all sub-levels removed before enabling this option.
    - ``enable_world_origin_rebasing`` (bool):  [Read-Write] World origin will shift to a camera position when camera goes far away from current origin
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``force_no_precomputed_lighting`` (bool):  [Read-Write] Whether to force lightmaps and other precomputed lighting to not be created even when the engine thinks they are needed.
      This is useful for improving iteration in levels with fully dynamic lighting and shadowing.
      Note that any lighting and shadowing interactions that are usually precomputed will be lost if this is enabled.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``generate_single_cluster_for_level`` (bool):  [Read-Write] If set to true, all eligible actors in this level will be added to a single cluster representing the entire level (used for small sublevels)
    - ``global_distance_field_view_distance`` (float):  [Read-Write] Distance from the camera that the global distance field should cover.
    - ``global_gravity_set`` (bool):  [Read-Write] If set to true we will use GlobalGravityZ instead of project setting DefaultGravityZ
    - ``global_gravity_z`` (float):  [Read-Write] optional level specific gravity override set by level designer
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hide_enable_streaming_warning`` (bool):  [Read-Write] if set to true, this hide the streaming disabled warning available in the viewport
    - ``hierarchical_lod_setup`` (Array[HierarchicalSimplification]):  [Read-Write] Hierarchical LOD Setup
    - ``hlod_baking_transform`` (Transform):  [Read-Write] Specify the transform to apply to the source meshes when building HLODs.
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``hlod_setup_asset`` (Class):  [Read-Write] If set overrides the level settings and global project settings
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instanced_foliage_grid_size`` (uint32):  [Read-Write] Size of the grid for instanced foliage actors, only used for partitioned worlds
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``kill_z`` (float):  [Read-Write] any actor falling below this level gets destroyed
    - ``kill_z_damage_type`` (type(Class)):  [Read-Write] The type of damage inflicted when a actor falls below KillZ
    - ``landscape_spline_meshes_grid_size`` (uint32):  [Read-Write]
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``lightmass_settings`` (LightmassWorldInfoSettings):  [Read-Write] LIGHTMASS RELATED SETTINGS *
    - ``max_global_time_dilation`` (float):  [Read-Write] Highest acceptable global time dilation.
    - ``max_undilated_frame_time`` (float):  [Read-Write] Largest possible frametime, not considering dilation. Equiv to 1/SlowestFPS.
    - ``min_global_time_dilation`` (float):  [Read-Write] Lowest acceptable global time dilation.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``min_undilated_frame_time`` (float):  [Read-Write] Smallest possible frametime, not considering dilation. Equiv to 1/FastestFPS.
    - ``minimize_bsp_sections`` (bool):  [Read-Write] Causes the BSP build to generate as few sections as possible.
      This is useful when you need to reduce draw calls but can reduce texture streaming efficiency and effective lightmap resolution.
      Note - changes require a rebuild to propagate.  Also, be sure to select all surfaces and make sure they all have the same flags to minimize section count.
    - ``nanite_settings`` (NaniteSettings):  [Read-Write] NANITE SETTINGS *
    - ``navigation_data_builder_loading_cell_size`` (uint32):  [Read-Write] Loading cell size used when building navigation data iteratively.
      The actual cell size used will be rounded using the NavigationDataChunkGridSize.
      It's recommended to use a value as high as the hardware memory allows to load.
    - ``navigation_data_chunk_grid_size`` (uint32):  [Read-Write] Size of the grid for navigation data chunk actors
    - ``navigation_system_config`` (NavigationSystemConfig):  [Read-Write] Holds parameters for NavigationSystem's creation. Set to Null will result
          in NavigationSystem instance not being created for this world. Note that
          if set NavigationSystemConfigOverride will be used instead.
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_base_material`` (MaterialInterface):  [Read-Write] If set overrides the project-wide base material used for Proxy Materials
    - ``override_default_broadphase_settings`` (bool):  [Read-Write]
    - ``packed_light_and_shadow_map_texture_size`` (int32):  [Read-Write] Maximum size of textures for packed light and shadow maps
    - ``physics_collision_handler_class`` (type(Class)):  [Read-Write] optional level specific collision handler
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``place_cells_only_along_camera_tracks`` (bool):  [Read-Write] Whether to place visibility cells only along camera tracks or only above shadow casting surfaces.
    - ``precompute_visibility`` (bool):  [Read-Write] Whether to place visibility cells inside Precomputed Visibility Volumes and along camera tracks in this level.
      Precomputing visibility reduces rendering thread time at the cost of some runtime memory and somewhat increased lighting build times.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``reuse_address_and_port`` (bool):  [Read-Write] Whether to configure the listening socket to allow reuse of the address and port. If this is true, be sure no other
      servers can run on the same port, otherwise this can lead to undefined behavior since packets will go to two servers.
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``show_instanced_foliage_grid`` (bool):  [Read-Write]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_client_side_level_streaming_volumes`` (bool):  [Read-Write] Enables client-side streaming volumes instead of server-side.
      Expected usage scenario: server has all streaming levels always loaded, clients independently stream levels in/out based on streaming volumes.
    - ``visibility_aggressiveness`` (VisibilityAggressiveness):  [Read-Write] Determines how aggressive precomputed visibility should be.
      More aggressive settings cull more objects but also cause more visibility errors like popping.
    - ``visibility_cell_size`` (int32):  [Read-Write] World space size of precomputed visibility cells in x and y.
      Smaller sizes produce more effective occlusion culling at the cost of increased runtime memory usage and lighting build times.
    - ``world_partition`` (WorldPartition):  [Read-Only]
    - ``world_to_meters`` (float):  [Read-Write] scale of 1uu to 1m in real world measurements, for HMD and other physically tracked devices (e.g. 1uu = 1cm would be 100.0)
    """
    @property
    def enable_world_bounds_checks(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, enables CheckStillInWorld checks
        """
        ...
    @property
    def enable_navigation_system(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def enable_ai_system(self) -> bool:
        r"""
        (bool):  [Read-Only] if set to false AI system will not get created. Use it to disable all AI-related activity on a map
        """
        ...
    @property
    def enable_world_composition(self) -> bool:
        r"""
        (bool):  [Read-Only] Enables tools for composing a tiled world.
        Level has to be saved and all sub-levels removed before enabling this option.
        """
        ...
    @property
    def use_client_side_level_streaming_volumes(self) -> bool:
        r"""
        (bool):  [Read-Only] Enables client-side streaming volumes instead of server-side.
        Expected usage scenario: server has all streaming levels always loaded, clients independently stream levels in/out based on streaming volumes.
        """
        ...
    @property
    def enable_world_origin_rebasing(self) -> bool:
        r"""
        (bool):  [Read-Only] World origin will shift to a camera position when camera goes far away from current origin
        """
        ...
    @property
    def global_gravity_set(self) -> bool:
        r"""
        (bool):  [Read-Only] If set to true we will use GlobalGravityZ instead of project setting DefaultGravityZ
        """
        ...
    @property
    def ai_system_class(self) -> Class:
        r"""
        (Class):  [Read-Only]
        """
        ...
    @property
    def navigation_system_config(self) -> NavigationSystemConfig:
        r"""
        (NavigationSystemConfig):  [Read-Only] Holds parameters for NavigationSystem's creation. Set to Null will result
            in NavigationSystem instance not being created for this world. Note that
            if set NavigationSystemConfigOverride will be used instead.
        """
        ...
    @property
    def world_to_meters(self) -> float:
        r"""
        (float):  [Read-Only] scale of 1uu to 1m in real world measurements, for HMD and other physically tracked devices (e.g. 1uu = 1cm would be 100.0)
        """
        ...
    @property
    def kill_z(self) -> float:
        r"""
        (float):  [Read-Only] any actor falling below this level gets destroyed
        """
        ...
    @property
    def kill_z_damage_type(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] The type of damage inflicted when a actor falls below KillZ
        """
        ...
    @property
    def global_gravity_z(self) -> float:
        r"""
        (float):  [Read-Only] optional level specific gravity override set by level designer
        """
        ...
    @property
    def default_physics_volume_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] level specific default physics volume
        """
        ...
    @property
    def physics_collision_handler_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] optional level specific collision handler
        """
        ...
    @property
    def default_game_mode(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] The default GameMode to use when starting this map in the game. If this value is NULL, the INI setting for default game type is used.
        """
        ...
    @property
    def default_game_type(self) -> Class:
        r"""
        deprecated: 'default_game_type' was renamed to 'default_game_mode'.
        """
        ...
    @property
    def default_color_scale(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Default color scale for the level
        """
        ...
    @property
    def lightmass_settings(self) -> LightmassWorldInfoSettings:
        r"""
        (LightmassWorldInfoSettings):  [Read-Write] LIGHTMASS RELATED SETTINGS *
        """
        ...
    @lightmass_settings.setter
    def lightmass_settings(self, value: LightmassWorldInfoSettings) -> None:
        ...
    @property
    def enable_large_worlds(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: As of UE 5.1 all worlds are large. Set UE_USE_UE4_WORLD_MAX in EngineDefines.h to alter this.
        """
        ...
    @enable_large_worlds.setter
    def enable_large_worlds(self, value: bool) -> None:
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class WorldInfo(WorldSettings):
    r"""
    deprecated: 'WorldInfo' was renamed to 'WorldSettings'.
    """
    ...

class Texture2DArray(Texture):
    r"""
    Texture 2DArray
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Texture2DArray.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``address_z`` (TextureAddress):  [Read-Write] The addressing mode to use for the Z axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``source_textures`` (Array[Texture2D]):  [Read-Write] Add Textures
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    ...

class AvoidanceManager(Object):
    r"""
    Avoidance Manager
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AvoidanceManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``artificial_radius_expansion`` (float):  [Read-Write] Multiply the radius of all STORED avoidance objects by this value to allow a little extra room for avoidance maneuvers.
    - ``default_time_to_live`` (float):  [Read-Write] How long an avoidance UID must not be updated before the system will put it back in the pool. Actual delay is up to 150% of this value.
    - ``delta_time_to_predict`` (float):  [Read-Write] This is how far forward in time (seconds) we extend our velocity cones and thus our prediction
    - ``height_check_margin`` (float):  [Read-Write] Allowable height margin between obstacles and agents. This is over and above the difference in agent heights.
    - ``lock_time_after_avoid`` (float):  [Read-Write] How long to stay on course (barring collision) after making an avoidance move
    - ``lock_time_after_clean`` (float):  [Read-Write] How long to stay on course (barring collision) after making an unobstructed move (should be > 0.0, but can be less than a full frame)
    """
    def register_movement_component(self, movement_comp: MovementComponent, avoidance_weight: float = 0.500000) -> bool:
        r"""
        x.register_movement_component(movement_comp, avoidance_weight=0.500000) -> bool
        Register with the given avoidance manager.
        
        Args:
            movement_comp (MovementComponent): 
            avoidance_weight (float): When avoiding each other, actors divert course in proportion to their relative weights. Range is 0.0 to 1.0. Special: at 1.0, actor will not divert course at all.
        
        Returns:
            bool:
        """
        ...
    def get_object_count(self) -> int:
        r"""
        x.get_object_count() -> int32
        Get the number of avoidance objects currently in the manager.
        
        Returns:
            int32:
        """
        ...
    def get_new_avoidance_uid(self) -> int:
        r"""
        x.get_new_avoidance_uid() -> int32
        Get appropriate UID for use when reporting to this function or requesting RVO assistance.
        
        Returns:
            int32:
        """
        ...
    def get_avoidance_velocity_for_component(self, movement_comp: MovementComponent) -> Vector:
        r"""
        x.get_avoidance_velocity_for_component(movement_comp) -> Vector
        Calculate avoidance velocity for component (avoids collisions with the supplied component)
        
        Args:
            movement_comp (MovementComponent): 
        
        Returns:
            Vector:
        """
        ...

class AmbientSound(Actor):
    r"""
    A sound actor that can be placed in a level
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AmbientSound.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``audio_component`` (AudioComponent):  [Read-Only] Audio component that handles sound playing
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def audio_component(self) -> AudioComponent:
        r"""
        (AudioComponent):  [Read-Only] Audio component that handles sound playing
        """
        ...
    def stop(self) -> None:
        r"""
        x.stop() -> None
        Stop
        deprecated: Function 'Stop' is deprecated.
        """
        ...
    def play(self, start_time: float = 0.000000) -> None:
        r"""
        x.play(start_time=0.000000) -> None
        Play
        deprecated: Function 'Play' is deprecated.
        
        Args:
            start_time (float):
        """
        ...
    def fade_out(self, fade_out_duration: float, fade_volume_level: float) -> None:
        r"""
        x.fade_out(fade_out_duration, fade_volume_level) -> None
        Fade Out
        deprecated: Function 'FadeOut' is deprecated.
        
        Args:
            fade_out_duration (float): 
            fade_volume_level (float):
        """
        ...
    def fade_in(self, fade_in_duration: float, fade_volume_level: float = 1.000000) -> None:
        r"""
        x.fade_in(fade_in_duration, fade_volume_level=1.000000) -> None
        BEGIN DEPRECATED (use component functions now in level script)
        deprecated: Function 'FadeIn' is deprecated.
        
        Args:
            fade_in_duration (float): 
            fade_volume_level (float):
        """
        ...
    def adjust_volume(self, adjust_volume_duration: float, adjust_volume_level: float) -> None:
        r"""
        x.adjust_volume(adjust_volume_duration, adjust_volume_level) -> None
        Adjust Volume
        deprecated: Function 'AdjustVolume' is deprecated.
        
        Args:
            adjust_volume_duration (float): 
            adjust_volume_level (float):
        """
        ...

class AimOffsetBlendSpace(BlendSpace):
    r"""
    An Aim Offset is an asset that stores a blendable series of poses to help a character aim a weapon.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AimOffsetBlendSpace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_mesh_space_blending`` (bool):  [Read-Write] If set then blending is performed in mesh space if there are per-bone sample smoothing overrides.
      
      Note that mesh space blending is significantly more expensive (slower) than normal blending when the
      samples are regular animations (i.e. not additive animations that are already set to apply in mesh
      space), and is typically only useful if you want some parts of the skeleton to achieve a pose
      in mesh space faster or slower than others - for example to make the head move faster than the
      body/arms when aiming, so the character looks at the target slightly before aiming at it.
      
      Note also that blend space assets with additive/mesh space samples will always blend in mesh space, and
      also that enabling this option with blend space graphs producing additive/mesh space samples may cause
      undesired results.
    - ``analysis_properties`` (AnalysisProperties):  [Read-Write] Analysis properties for each axis. Note that these can be null. They will be created/set from
      FBlendSpaceDetails::HandleAnalysisFunctionChanged
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``axis_to_scale_animation`` (BlendSpaceAxis):  [Read-Write] If you have input smoothing, this specifies the axis on which to scale the animation playback speed. E.g. for
      locomotion animation, the speed axis will scale the animation speed in order to make up the difference
      between the target and the result of blending the samples.
    - ``blend_parameters`` (BlendParameter):  [Read-Write] Blend Parameters for each axis. *
    - ``interpolate_using_grid`` (bool):  [Read-Write] If true then interpolation is done via a grid at runtime. If false the interpolation uses the triangulation.
    - ``interpolation_param`` (InterpolationParameter):  [Read-Write] Input Smoothing parameters for each input axis
    - ``loop`` (bool):  [Read-Write] The default looping behavior of this blend space.
      Asset players can override this
    - ``manual_per_bone_overrides`` (Array[PerBoneInterpolation]):  [Read-Write] Per bone sample smoothing settings, which affect the specified bone and all its descendants in the skeleton.
      These act as overrides to the global sample smoothing speed, which means the global sample smoothing speed does
      not affect these bones. Note that they also override each other - so a per-bone setting on the chest will not
      affect the hand if there is a per-bone setting on the arm.
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``notify_trigger_mode`` (NotifyTriggerMode):  [Read-Write] The current mode used by the BlendSpace to decide which animation notifies to fire. Valid options are:
            - AllAnimations: All notify events will fire
            - HighestWeightedAnimation: Notify events will only fire from the highest weighted animation
            - None: No notify events will fire from any animations
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``per_bone_blend_mode`` (BlendSpacePerBoneBlendMode):  [Read-Write] There are two ways to use per pone sample smoothing: Blend profiles and manually maintaining the per bone overrides.
    - ``per_bone_blend_profile`` (BlendSpaceBlendProfile):  [Read-Write] Reference to a blend profile of the corresponding skeleton to be used for per bone smoothing in case the per bone blend mode is set to use a blend profile.
    - ``preferred_triangulation_direction`` (PreferredTriangulationDirection):  [Read-Write] Preferred edge direction when the triangulation has to make an arbitrary choice
    - ``preview_base_pose`` (AnimSequence):  [Read-Write] Preview Base pose for additive BlendSpace *
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``sample_data`` (Array[BlendSample]):  [Read-Write] Sample animation data
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``target_weight_interpolation_ease_in_out`` (bool):  [Read-Write] If set then this eases in/out the sample weight adjustments, using the speed to determine how much smoothing to apply.
    - ``target_weight_interpolation_speed_per_sec`` (float):  [Read-Write] If greater than zero, this is the speed at which the sample weights are allowed to change.
      
      A speed of 1 means a sample weight can change from zero to one (or one to zero) in one second.
      A speed of 2 means that this would take half a second.
      
      This allows the Blend Space to switch to new parameters without going through intermediate states,
      effectively blending between where it was and where the new target is. For example, imagine we have
      a blend space for locomotion, moving left, forward and right. Now if you interpolate the inputs of
      the blend space itself, from one extreme to the other, you will go from left, to forward, to right.
      As an alternative, by setting this Sample Weight Speed to a value higher than zero, it will go
      directly from left to right, without going through moving forward first.
      
      Smaller values mean slower adjustments of the sample weights, and thus more smoothing. However, a
      value of zero disables this smoothing entirely.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    ...

class BlendSpace1D(BlendSpace):
    r"""
    Allows multiple animations to be blended between based on input parameters
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace1D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_mesh_space_blending`` (bool):  [Read-Write] If set then blending is performed in mesh space if there are per-bone sample smoothing overrides.
      
      Note that mesh space blending is significantly more expensive (slower) than normal blending when the
      samples are regular animations (i.e. not additive animations that are already set to apply in mesh
      space), and is typically only useful if you want some parts of the skeleton to achieve a pose
      in mesh space faster or slower than others - for example to make the head move faster than the
      body/arms when aiming, so the character looks at the target slightly before aiming at it.
      
      Note also that blend space assets with additive/mesh space samples will always blend in mesh space, and
      also that enabling this option with blend space graphs producing additive/mesh space samples may cause
      undesired results.
    - ``analysis_properties`` (AnalysisProperties):  [Read-Write] Analysis properties for each axis. Note that these can be null. They will be created/set from
      FBlendSpaceDetails::HandleAnalysisFunctionChanged
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``axis_to_scale_animation`` (BlendSpaceAxis):  [Read-Write] If you have input smoothing, this specifies the axis on which to scale the animation playback speed. E.g. for
      locomotion animation, the speed axis will scale the animation speed in order to make up the difference
      between the target and the result of blending the samples.
    - ``blend_parameters`` (BlendParameter):  [Read-Write] Blend Parameters for each axis. *
    - ``interpolate_using_grid`` (bool):  [Read-Write] If true then interpolation is done via a grid at runtime. If false the interpolation uses the triangulation.
    - ``interpolation_param`` (InterpolationParameter):  [Read-Write] Input Smoothing parameters for each input axis
    - ``loop`` (bool):  [Read-Write] The default looping behavior of this blend space.
      Asset players can override this
    - ``manual_per_bone_overrides`` (Array[PerBoneInterpolation]):  [Read-Write] Per bone sample smoothing settings, which affect the specified bone and all its descendants in the skeleton.
      These act as overrides to the global sample smoothing speed, which means the global sample smoothing speed does
      not affect these bones. Note that they also override each other - so a per-bone setting on the chest will not
      affect the hand if there is a per-bone setting on the arm.
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``notify_trigger_mode`` (NotifyTriggerMode):  [Read-Write] The current mode used by the BlendSpace to decide which animation notifies to fire. Valid options are:
            - AllAnimations: All notify events will fire
            - HighestWeightedAnimation: Notify events will only fire from the highest weighted animation
            - None: No notify events will fire from any animations
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``per_bone_blend_mode`` (BlendSpacePerBoneBlendMode):  [Read-Write] There are two ways to use per pone sample smoothing: Blend profiles and manually maintaining the per bone overrides.
    - ``per_bone_blend_profile`` (BlendSpaceBlendProfile):  [Read-Write] Reference to a blend profile of the corresponding skeleton to be used for per bone smoothing in case the per bone blend mode is set to use a blend profile.
    - ``preferred_triangulation_direction`` (PreferredTriangulationDirection):  [Read-Write] Preferred edge direction when the triangulation has to make an arbitrary choice
    - ``preview_base_pose`` (AnimSequence):  [Read-Write] Preview Base pose for additive BlendSpace *
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``sample_data`` (Array[BlendSample]):  [Read-Write] Sample animation data
    - ``scale_animation`` (bool):  [Read-Write] If you have input smoothing, whether to scale the animation speed. E.g. for locomotion animation,
      the speed axis will scale the animation speed in order to make up the difference between the target
      and the result of blending the samples.
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``target_weight_interpolation_ease_in_out`` (bool):  [Read-Write] If set then this eases in/out the sample weight adjustments, using the speed to determine how much smoothing to apply.
    - ``target_weight_interpolation_speed_per_sec`` (float):  [Read-Write] If greater than zero, this is the speed at which the sample weights are allowed to change.
      
      A speed of 1 means a sample weight can change from zero to one (or one to zero) in one second.
      A speed of 2 means that this would take half a second.
      
      This allows the Blend Space to switch to new parameters without going through intermediate states,
      effectively blending between where it was and where the new target is. For example, imagine we have
      a blend space for locomotion, moving left, forward and right. Now if you interpolate the inputs of
      the blend space itself, from one extreme to the other, you will go from left, to forward, to right.
      As an alternative, by setting this Sample Weight Speed to a value higher than zero, it will go
      directly from left to right, without going through moving forward first.
      
      Smaller values mean slower adjustments of the sample weights, and thus more smoothing. However, a
      value of zero disables this smoothing entirely.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    ...

class AimOffsetBlendSpace1D(BlendSpace1D):
    r"""
    An Aim Offset is an asset that stores a blendable series of poses to help a character aim a weapon.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AimOffsetBlendSpace1D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_mesh_space_blending`` (bool):  [Read-Write] If set then blending is performed in mesh space if there are per-bone sample smoothing overrides.
      
      Note that mesh space blending is significantly more expensive (slower) than normal blending when the
      samples are regular animations (i.e. not additive animations that are already set to apply in mesh
      space), and is typically only useful if you want some parts of the skeleton to achieve a pose
      in mesh space faster or slower than others - for example to make the head move faster than the
      body/arms when aiming, so the character looks at the target slightly before aiming at it.
      
      Note also that blend space assets with additive/mesh space samples will always blend in mesh space, and
      also that enabling this option with blend space graphs producing additive/mesh space samples may cause
      undesired results.
    - ``analysis_properties`` (AnalysisProperties):  [Read-Write] Analysis properties for each axis. Note that these can be null. They will be created/set from
      FBlendSpaceDetails::HandleAnalysisFunctionChanged
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``axis_to_scale_animation`` (BlendSpaceAxis):  [Read-Write] If you have input smoothing, this specifies the axis on which to scale the animation playback speed. E.g. for
      locomotion animation, the speed axis will scale the animation speed in order to make up the difference
      between the target and the result of blending the samples.
    - ``blend_parameters`` (BlendParameter):  [Read-Write] Blend Parameters for each axis. *
    - ``interpolate_using_grid`` (bool):  [Read-Write] If true then interpolation is done via a grid at runtime. If false the interpolation uses the triangulation.
    - ``interpolation_param`` (InterpolationParameter):  [Read-Write] Input Smoothing parameters for each input axis
    - ``loop`` (bool):  [Read-Write] The default looping behavior of this blend space.
      Asset players can override this
    - ``manual_per_bone_overrides`` (Array[PerBoneInterpolation]):  [Read-Write] Per bone sample smoothing settings, which affect the specified bone and all its descendants in the skeleton.
      These act as overrides to the global sample smoothing speed, which means the global sample smoothing speed does
      not affect these bones. Note that they also override each other - so a per-bone setting on the chest will not
      affect the hand if there is a per-bone setting on the arm.
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``notify_trigger_mode`` (NotifyTriggerMode):  [Read-Write] The current mode used by the BlendSpace to decide which animation notifies to fire. Valid options are:
            - AllAnimations: All notify events will fire
            - HighestWeightedAnimation: Notify events will only fire from the highest weighted animation
            - None: No notify events will fire from any animations
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``per_bone_blend_mode`` (BlendSpacePerBoneBlendMode):  [Read-Write] There are two ways to use per pone sample smoothing: Blend profiles and manually maintaining the per bone overrides.
    - ``per_bone_blend_profile`` (BlendSpaceBlendProfile):  [Read-Write] Reference to a blend profile of the corresponding skeleton to be used for per bone smoothing in case the per bone blend mode is set to use a blend profile.
    - ``preferred_triangulation_direction`` (PreferredTriangulationDirection):  [Read-Write] Preferred edge direction when the triangulation has to make an arbitrary choice
    - ``preview_base_pose`` (AnimSequence):  [Read-Write] Preview Base pose for additive BlendSpace *
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``sample_data`` (Array[BlendSample]):  [Read-Write] Sample animation data
    - ``scale_animation`` (bool):  [Read-Write] If you have input smoothing, whether to scale the animation speed. E.g. for locomotion animation,
      the speed axis will scale the animation speed in order to make up the difference between the target
      and the result of blending the samples.
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``target_weight_interpolation_ease_in_out`` (bool):  [Read-Write] If set then this eases in/out the sample weight adjustments, using the speed to determine how much smoothing to apply.
    - ``target_weight_interpolation_speed_per_sec`` (float):  [Read-Write] If greater than zero, this is the speed at which the sample weights are allowed to change.
      
      A speed of 1 means a sample weight can change from zero to one (or one to zero) in one second.
      A speed of 2 means that this would take half a second.
      
      This allows the Blend Space to switch to new parameters without going through intermediate states,
      effectively blending between where it was and where the new target is. For example, imagine we have
      a blend space for locomotion, moving left, forward and right. Now if you interpolate the inputs of
      the blend space itself, from one extreme to the other, you will go from left, to forward, to right.
      As an alternative, by setting this Sample Weight Speed to a value higher than zero, it will go
      directly from left to right, without going through moving forward first.
      
      Smaller values mean slower adjustments of the sample weights, and thus more smoothing. However, a
      value of zero disables this smoothing entirely.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    ...

class AnimationSettings(DeveloperSettings):
    r"""
    Default animation settings.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimationSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attribute_blend_modes`` (Map[Name, CustomAttributeBlendType]):  [Read-Write] Animation Attribute specific blend types (by name)
    - ``bone_custom_attributes_names`` (Array[CustomAttributeSetting]):  [Read-Write] List of animation attribute names to import directly on their corresponding bone names. The meaning field allows to contextualize the attribute name and customize tooling for it.
    - ``bone_names_with_custom_attributes`` (Array[str]):  [Read-Write] List of bone names for which all animation attributes are directly imported on the bone.
    - ``bone_timecode_custom_attribute_name_settings`` (TimecodeCustomAttributeNameSettings):  [Read-Write] Names that identify bone animation attributes representing the individual components of a timecode and a subframe along with a take name.
                These will be included in the list of bone custom attribute names to import.
    - ``compress_commandlet_version`` (int32):  [Read-Only] Compression version for recompress commandlet, bump this to trigger full recompressed, otherwise only new imported animations will be recompressed
    - ``default_attribute_blend_mode`` (CustomAttributeBlendType):  [Read-Write] Default Animation Attribute blend type
    - ``default_frame_rate`` (FrameRate):  [Read-Write] Project specific default frame-rate used when (re)initializing any animation based data
    - ``enable_performance_log`` (bool):  [Read-Write] If true, recompression will log performance information
    - ``enforce_supported_frame_rates`` (bool):  [Read-Write] Whether to enforce the project to only use entries from SupportedFrameRates for the animation assets, if disable will warn instead
    - ``first_recompress_using_current_or_default`` (bool):  [Read-Write] If true, then the animation will be first recompressed with it's current compressor if non-NULL, or with the global default compressor (specified in the engine ini)
      Also known as "Run Current Default Compressor"
    - ``force_below_threshold`` (bool):  [Read-Write] If true and the existing compression error is greater than Alternative Compression Threshold, then any compression technique (even one that increases the size) with a lower error will be used until it falls below the threshold
    - ``force_recompression`` (bool):  [Read-Write] If true, this will forcibly recompress every animation, this should not be checked in enabled
    - ``key_end_effectors_match_name_array`` (Array[str]):  [Read-Write] List of bone names to treat with higher precision, in addition to any bones with sockets
    - ``mirror_find_replace_expressions`` (Array[MirrorFindReplaceExpression]):  [Read-Write] Find and Replace Expressions used for mirroring
    - ``raise_max_error_to_existing`` (bool):  [Read-Write] , EditAnywhere, Category = Compression
      deprecated: No longer used.
    - ``strip_animation_data_on_dedicated_server`` (bool):  [Read-Write] If true, animation track data will be stripped from dedicated server cooked data
    - ``tick_animation_on_skeletal_mesh_init`` (bool):  [Read-Write] If true, pre-4.19 behavior of zero-ticking animations during skeletal mesh init
    - ``transform_attribute_names`` (Array[str]):  [Read-Write] Names to match against when importing FBX node transform curves as attributes (can use ? and * wildcards)
    - ``user_defined_struct_attributes`` (Array[UserDefinedStruct]):  [Read-Write] Register user defined structs as animation attributes
    """
    @property
    def raise_max_error_to_existing(self) -> bool:
        r"""
        (bool):  [Read-Write] , EditAnywhere, Category = Compression
        deprecated: No longer used.
        """
        ...
    @raise_max_error_to_existing.setter
    def raise_max_error_to_existing(self, value: bool) -> None:
        ...
    def get_bone_custom_attribute_names_to_import(self) -> Array[str]:
        r"""
        x.get_bone_custom_attribute_names_to_import() -> Array[str]
        Gets the complete list of bone animation attribute names to consider for import.
                  This includes the designated timecode animation attributes as well as other bone animation attributes identified in the settings.
        
        Returns:
            Array[str]:
        """
        ...

class AnimCompositeBase(AnimSequenceBase):
    r"""
    Anim Composite Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCompositeBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``common_target_frame_rate`` (FrameRate):  [Read-Only] Frame-rate used to represent this Animation Montage (best fitting for placed Animation Sequences)
    - ``controller`` (AnimationDataController):  [Read-Only] UAnimDataController instance set to operate on DataModel
    - ``data_model`` (AnimDataModel):  [Read-Only]
    - ``data_model_interface`` (AnimationDataModel):  [Read-Only] IAnimationDataModel instance containing (source) animation data
    - ``loop`` (bool):  [Read-Write] The default looping behavior of this animation.
      Asset players can override this
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``rate_scale`` (float):  [Read-Write] Number for tweaking playback rate of this animation globally.
    - ``sequence_length`` (float):  [Read-Only]
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    ...

class AnimComposite(AnimCompositeBase):
    r"""
    Animation Composites serve as a way to combine multiple animations together and treat them as a single unit.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimComposite.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``common_target_frame_rate`` (FrameRate):  [Read-Only] Frame-rate used to represent this Animation Montage (best fitting for placed Animation Sequences)
    - ``controller`` (AnimationDataController):  [Read-Only] UAnimDataController instance set to operate on DataModel
    - ``data_model`` (AnimDataModel):  [Read-Only]
    - ``data_model_interface`` (AnimationDataModel):  [Read-Only] IAnimationDataModel instance containing (source) animation data
    - ``loop`` (bool):  [Read-Write] The default looping behavior of this animation.
      Asset players can override this
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``preview_base_pose`` (AnimSequence):  [Read-Write] Preview Base pose for additive BlendSpace *
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``rate_scale`` (float):  [Read-Write] Number for tweaking playback rate of this animation globally.
    - ``sequence_length`` (float):  [Read-Only]
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    ...

class AnimDataModel(Object):
    r"""
    The Model represents the source data for animations. It contains both bone animation data as well as animated curves.
    They are currently only a sub-object of a AnimSequenceBase instance. The instance derives all runtime data from the source data.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimDataModel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animated_bone_attributes`` (Array[AnimatedBoneAttribute]):  [Read-Only] Container with all animated (bone) attribute data
    - ``bone_animation_tracks`` (Array[BoneAnimationTrack]):  [Read-Only] All individual bone animation tracks
    - ``curve_data`` (AnimationCurveData):  [Read-Only] Container with all animated curve data
    - ``frame_rate`` (FrameRate):  [Read-Only] Rate at which the animated data is sampled
    - ``modified_event`` (AnimDataModelModifiedDynamicEvent):  [Read-Write] Dynamic delegate event allows scripting to register to any broadcasted notify.
    - ``number_of_frames`` (int32):  [Read-Only] Total number of sampled animated frames
    - ``number_of_keys`` (int32):  [Read-Only] Total number of sampled animated keys
    - ``play_length`` (float):  [Read-Only]
    """
    @property
    def modified_event(self) -> AnimDataModelModifiedDynamicEvent:
        r"""
        (AnimDataModelModifiedDynamicEvent):  [Read-Write] Dynamic delegate event allows scripting to register to any broadcasted notify.
        """
        ...
    @modified_event.setter
    def modified_event(self, value: AnimDataModelModifiedDynamicEvent) -> None:
        ...
    @property
    def bone_animation_tracks(self) -> Array[BoneAnimationTrack]:
        r"""
        (Array[BoneAnimationTrack]):  [Read-Only] All individual bone animation tracks
        """
        ...
    @property
    def play_length(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def frame_rate(self) -> FrameRate:
        r"""
        (FrameRate):  [Read-Only] Rate at which the animated data is sampled
        """
        ...
    @property
    def number_of_frames(self) -> int:
        r"""
        (int32):  [Read-Only] Total number of sampled animated frames
        """
        ...
    @property
    def number_of_keys(self) -> int:
        r"""
        (int32):  [Read-Only] Total number of sampled animated keys
        """
        ...
    @property
    def curve_data(self) -> AnimationCurveData:
        r"""
        (AnimationCurveData):  [Read-Only] Container with all animated curve data
        """
        ...
    @property
    def animated_bone_attributes(self) -> Array[AnimatedBoneAttribute]:
        r"""
        (Array[AnimatedBoneAttribute]):  [Read-Only] Container with all animated (bone) attribute data
        """
        ...
    def is_valid_bone_track_name(self, track_name: Name) -> bool:
        r"""
        x.is_valid_bone_track_name(track_name) -> bool
        Is Valid Bone Track Name
        
        Args:
            track_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_valid_bone_track_index(self, track_index: int) -> bool:
        r"""
        x.is_valid_bone_track_index(track_index) -> bool
        Is Valid Bone Track Index
        
        Args:
            track_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_play_length(self) -> float:
        r"""
        x.get_play_length() -> double
        
        
        Returns:
            double: Total length of play-able animation data
        """
        ...
    def get_num_bone_tracks(self) -> int:
        r"""
        x.get_num_bone_tracks() -> int32
        
        
        Returns:
            int32: Total number of bone animation tracks
        """
        ...
    def get_number_of_transform_curves(self) -> int:
        r"""
        x.get_number_of_transform_curves() -> int32
        
        
        Returns:
            int32: Total number of stored FTransform curves
        """
        ...
    def get_number_of_keys(self) -> int:
        r"""
        x.get_number_of_keys() -> int32
        
        
        Returns:
            int32: Total number of animation data keys stored
        """
        ...
    def get_number_of_frames(self) -> int:
        r"""
        x.get_number_of_frames() -> int32
        
        
        Returns:
            int32: Total number of frames of animation data stored
        """
        ...
    def get_number_of_float_curves(self) -> int:
        r"""
        x.get_number_of_float_curves() -> int32
        
        
        Returns:
            int32: Total number of stored float curves
        """
        ...
    def get_frame_rate(self) -> FrameRate:
        r"""
        x.get_frame_rate() -> FrameRate
        
        
        Returns:
            FrameRate: Frame rate at which the animation data is key-ed
        """
        ...
    def get_bone_track_names(self) -> Array[Name]:
        r"""
        x.get_bone_track_names() -> Array[Name]
        Populates the provided array with all contained (bone) track names
        
        Returns:
            Array[Name]: 
        
            out_names (Array[Name]): [out] Array containing all bone track names
        """
        ...
    def get_bone_track_index_by_name(self, track_name: Name) -> int:
        r"""
        x.get_bone_track_index_by_name(track_name) -> int32
        Get Bone Track Index by Name
        
        Args:
            track_name (Name): 
        
        Returns:
            int32:
        """
        ...
    def get_bone_track_index(self, track: BoneAnimationTrack) -> int:
        r"""
        x.get_bone_track_index(track) -> int32
        Get Bone Track Index
        
        Args:
            track (BoneAnimationTrack): 
        
        Returns:
            int32:
        """
        ...
    def get_bone_track_by_name(self, track_name: Name) -> BoneAnimationTrack:
        r"""
        x.get_bone_track_by_name(track_name) -> BoneAnimationTrack
        Get Bone Track by Name
        
        Args:
            track_name (Name): 
        
        Returns:
            BoneAnimationTrack:
        """
        ...
    def get_bone_track_by_index(self, track_index: int) -> BoneAnimationTrack:
        r"""
        x.get_bone_track_by_index(track_index) -> BoneAnimationTrack
        Get Bone Track by Index
        
        Args:
            track_index (int32): 
        
        Returns:
            BoneAnimationTrack:
        """
        ...
    def get_bone_animation_tracks(self) -> Array[BoneAnimationTrack]:
        r"""
        x.get_bone_animation_tracks() -> Array[BoneAnimationTrack]
        Get Bone Animation Tracks
        
        Returns:
            Array[BoneAnimationTrack]:
        """
        ...
    def get_animation_sequence(self) -> AnimSequence:
        r"""
        x.get_animation_sequence() -> AnimSequence
        
        
        Returns:
            AnimSequence: The outer UAnimSequence object if found, otherwise returns a nullptr
        """
        ...

class AnimMetaData(Object):
    r"""
    Anim Meta Data
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimMetaData.h
    
    """
    ...

class AnimMontage(AnimCompositeBase):
    r"""
    Any property you're adding to AnimMontage and parent class has to be considered for Child Asset
    
    Child Asset is considered to be only asset mapping feature using everything else in the class
    For example, you can just use all parent's setting  for the montage, but only remap assets
    This isn't magic bullet unfortunately and it is consistent effort of keeping the data synced with parent
    If you add new property, please make sure those property has to be copied for children.
    If it does, please add the copy in the function RefreshParentAssetData
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimMontage.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``blend_in`` (AlphaBlend):  [Read-Write] Blend in option.
    - ``blend_mode_in`` (MontageBlendMode):  [Read-Write]
    - ``blend_mode_out`` (MontageBlendMode):  [Read-Write]
    - ``blend_out`` (AlphaBlend):  [Read-Write] Blend out option. This is only used when it blends out itself. If it's interrupted by other montages, it will use new montage's BlendIn option to blend out.
    - ``blend_out_trigger_time`` (float):  [Read-Write] Time from Sequence End to trigger blend out.
      <0 means using BlendOutTime, so BlendOut finishes as Montage ends.
      >=0 means using 'SequenceEnd - BlendOutTriggerTime' to trigger blend out.
    - ``blend_profile_in`` (BlendProfile):  [Read-Write] The blend profile to use.
    - ``blend_profile_out`` (BlendProfile):  [Read-Write] The blend profile to use.
    - ``common_target_frame_rate`` (FrameRate):  [Read-Only] Frame-rate used to represent this Animation Montage (best fitting for placed Animation Sequences)
    - ``controller`` (AnimationDataController):  [Read-Only] UAnimDataController instance set to operate on DataModel
    - ``data_model`` (AnimDataModel):  [Read-Only]
    - ``data_model_interface`` (AnimationDataModel):  [Read-Only] IAnimationDataModel instance containing (source) animation data
    - ``enable_auto_blend_out`` (bool):  [Read-Write] When it hits end, it automatically blends out. If this is false, it won't blend out but keep the last pose until stopped explicitly
    - ``loop`` (bool):  [Read-Write] The default looping behavior of this animation.
      Asset players can override this
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``preview_base_pose`` (AnimSequence):  [Read-Write] Preview Base pose for additive BlendSpace *
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``rate_scale`` (float):  [Read-Write] Number for tweaking playback rate of this animation globally.
    - ``sequence_length`` (float):  [Read-Only]
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``sync_group`` (Name):  [Read-Write] If you're using marker based sync for this montage, make sure to add sync group name. For now we only support one group
    - ``sync_slot_index`` (int32):  [Read-Write] Index of the slot track used for collecting sync markers
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``time_stretch_curve`` (TimeStretchCurve):  [Read-Write] Time stretch curve will only be used when the montage has a non-default play rate
    - ``time_stretch_curve_name`` (Name):  [Read-Write] Name of optional TimeStretchCurveName to look for in Montage. Time stretch curve will only be used when the montage has a non-default play rate
    """
    @property
    def blend_mode_in(self) -> MontageBlendMode:
        r"""
        (MontageBlendMode):  [Read-Only]
        """
        ...
    @property
    def blend_mode_out(self) -> MontageBlendMode:
        r"""
        (MontageBlendMode):  [Read-Only]
        """
        ...
    @property
    def blend_profile_in(self) -> BlendProfile:
        r"""
        (BlendProfile):  [Read-Only] The blend profile to use.
        """
        ...
    @property
    def blend_profile_out(self) -> BlendProfile:
        r"""
        (BlendProfile):  [Read-Only] The blend profile to use.
        """
        ...
    def is_valid_section_name(self, section_name: Name) -> bool:
        r"""
        x.is_valid_section_name(section_name) -> bool
        
        
        Args:
            section_name (Name): 
        
        Returns:
            bool: true if valid section
        """
        ...
    def is_valid_additive_slot(self, slot_node_name: Name) -> bool:
        r"""
        x.is_valid_additive_slot(slot_node_name) -> bool
        Check if this slot has a valid additive animation for the specified slot.
        The slot name should not include the group name.
        i.e. for "DefaultGroup.DefaultSlot", the slot name is "DefaultSlot".
        
        Args:
            slot_node_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_dynamic_montage(self) -> bool:
        r"""
        x.is_dynamic_montage() -> bool
        Is Dynamic Montage
        
        Returns:
            bool:
        """
        ...
    def get_section_name(self, section_index: int) -> Name:
        r"""
        x.get_section_name(section_index) -> Name
        Get SectionName from SectionIndex. Returns NAME_None if not found
        
        Args:
            section_index (int32): 
        
        Returns:
            Name:
        """
        ...
    def get_section_index(self, section_name: Name) -> int:
        r"""
        x.get_section_index(section_name) -> int32
        Get SectionIndex from SectionName. Returns INDEX_None if not found
        
        Args:
            section_name (Name): 
        
        Returns:
            int32:
        """
        ...
    def get_num_sections(self) -> int:
        r"""
        x.get_num_sections() -> int32
        Returns the number of sections this montage has
        
        Returns:
            int32:
        """
        ...
    def get_group_name(self) -> Name:
        r"""
        x.get_group_name() -> Name
        Get the Montage's Group Name. This is the group from the first slot.
        
        Returns:
            Name:
        """
        ...
    def get_first_anim_reference(self) -> AnimSequenceBase:
        r"""
        x.get_first_anim_reference() -> AnimSequenceBase
        Get First Anim Reference
        
        Returns:
            AnimSequenceBase:
        """
        ...
    def get_default_blend_out_time(self) -> float:
        r"""
        x.get_default_blend_out_time() -> float
        Get Default Blend Out Time
        
        Returns:
            float:
        """
        ...
    def get_default_blend_in_time(self) -> float:
        r"""
        x.get_default_blend_in_time() -> float
        Get Default Blend in Time
        
        Returns:
            float:
        """
        ...
    def get_blend_out_args(self) -> AlphaBlendArgs:
        r"""
        x.get_blend_out_args() -> AlphaBlendArgs
        Get Blend Out Args
        
        Returns:
            AlphaBlendArgs:
        """
        ...
    def get_blend_in_args(self) -> AlphaBlendArgs:
        r"""
        x.get_blend_in_args() -> AlphaBlendArgs
        Get Blend in Args
        
        Returns:
            AlphaBlendArgs:
        """
        ...
    @classmethod
    def create_slot_animation_as_dynamic_montage_with_blend_settings(cls, asset: AnimSequenceBase, slot_node_name: Name, blend_in_settings: MontageBlendSettings, blend_out_settings: MontageBlendSettings, play_rate: float = 1.000000, loop_count: int = 1, blend_out_trigger_time: float = -1.000000) -> AnimMontage:
        r"""
        X.create_slot_animation_as_dynamic_montage_with_blend_settings(asset, slot_node_name, blend_in_settings, blend_out_settings, play_rate=1.000000, loop_count=1, blend_out_trigger_time=-1.000000) -> AnimMontage
        Utility function to create dynamic montage from AnimSequence with blend in settings
        
        Args:
            asset (AnimSequenceBase): 
            slot_node_name (Name): 
            blend_in_settings (MontageBlendSettings): 
            blend_out_settings (MontageBlendSettings): 
            play_rate (float): 
            loop_count (int32): 
            blend_out_trigger_time (float): 
        
        Returns:
            AnimMontage:
        """
        ...

class UAnimNotifyLibrary(BlueprintFunctionLibrary):
    r"""
    A library of commonly used functionality for Notifies, exposed to blueprint.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotifyLibrary.h
    
    """
    @classmethod
    def notify_state_reached_end(cls, event_reference: AnimNotifyEventReference) -> bool:
        r"""
        X.notify_state_reached_end(event_reference) -> bool
        Get whether the notify state reached the end (was not cancelled)
        
        Args:
            event_reference (AnimNotifyEventReference): The event to inspect
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_current_animation_time_ratio(cls, event_reference: AnimNotifyEventReference) -> float:
        r"""
        X.get_current_animation_time_ratio(event_reference) -> float
        Get the current anim notify time as a ratio (0 -> 1) through the animation for when this notify was fired
        
        Args:
            event_reference (AnimNotifyEventReference): The event to inspect
        
        Returns:
            float: the time as a ratio (0 -> 1) through the animation for when this notify was fired
        """
        ...
    @classmethod
    def get_current_animation_time(cls, event_reference: AnimNotifyEventReference) -> float:
        r"""
        X.get_current_animation_time(event_reference) -> float
        Get the current anim notify time in seconds for when this notify was fired
        
        Args:
            event_reference (AnimNotifyEventReference): The event to inspect
        
        Returns:
            float: the time in seconds through the current animation for when this notify was fired
        """
        ...
    @classmethod
    def get_current_animation_notify_state_time_ratio(cls, event_reference: AnimNotifyEventReference) -> float:
        r"""
        X.get_current_animation_notify_state_time_ratio(event_reference) -> float
        Gets the current time as a ratio (0 -> 1) relative to the start of the notify state
        
        Args:
            event_reference (AnimNotifyEventReference): The event to inspect
        
        Returns:
            float: the current time as a ratio (0 -> 1) relative to the start of the notify state
        """
        ...
    @classmethod
    def get_current_animation_notify_state_time(cls, event_reference: AnimNotifyEventReference) -> float:
        r"""
        X.get_current_animation_notify_state_time(event_reference) -> float
        Gets the current time in seconds relative to the start of the notify state, clamped to the range of the notify
        state
        
        Args:
            event_reference (AnimNotifyEventReference): The event to inspect
        
        Returns:
            float: the current time in seconds relative to the start of the notify state, clamped to the range of the notify state
        """
        ...

class UAnimNotifyMirrorInspectionLibrary(BlueprintFunctionLibrary):
    r"""
    A library of commonly used functionality for Notifies related to mirroring, exposed to blueprint.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotifyMirrorInspectionLibrary.h
    
    """
    @classmethod
    def is_triggered_by_mirrored_animation(cls, event_reference: AnimNotifyEventReference) -> bool:
        r"""
        X.is_triggered_by_mirrored_animation(event_reference) -> bool
        Get whether the animation which triggered this notify was mirrored.
        
        Args:
            event_reference (AnimNotifyEventReference): The event to inspect
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_mirror_data_table(cls, event_reference: AnimNotifyEventReference) -> MirrorDataTable:
        r"""
        X.get_mirror_data_table(event_reference) -> MirrorDataTable
        If the notify is mirrored, return the mirror data table that was active.
        
        Args:
            event_reference (AnimNotifyEventReference): The event to inspect
        
        Returns:
            MirrorDataTable:
        """
        ...

class UAnimNotifyStateMachineInspectionLibrary(BlueprintFunctionLibrary):
    r"""
    A library of commonly used functionality for Notifies related to state machines, exposed to blueprint.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotifyStateMachineInspectionLibrary.h
    
    """
    @classmethod
    def is_triggered_by_state_machine(cls, event_reference: AnimNotifyEventReference, anim_instance: AnimInstance, state_machine_name: Name) -> bool:
        r"""
        X.is_triggered_by_state_machine(event_reference, anim_instance, state_machine_name) -> bool
        Get whether the notify was triggered from the specified state machine
        
        Args:
            event_reference (AnimNotifyEventReference): The event to inspect
            anim_instance (AnimInstance): 
            state_machine_name (Name): The Name of a state machine to test
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_triggered_by_state_in_state_machine(cls, event_reference: AnimNotifyEventReference, anim_instance: AnimInstance, state_machine_name: Name, state_name: Name) -> bool:
        r"""
        X.is_triggered_by_state_in_state_machine(event_reference, anim_instance, state_machine_name, state_name) -> bool
        Get whether a particular state in a specific state machine triggered the notify
        
        Args:
            event_reference (AnimNotifyEventReference): The event to inspect
            anim_instance (AnimInstance): 
            state_machine_name (Name): The name of a state machine to test
            state_name (Name): The name of a state to test
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_triggered_by_state(cls, event_reference: AnimNotifyEventReference, anim_instance: AnimInstance, state_name: Name) -> bool:
        r"""
        X.is_triggered_by_state(event_reference, anim_instance, state_name) -> bool
        Get whether a state with the given name in any state machine triggered the notify
        
        Args:
            event_reference (AnimNotifyEventReference): The event to inspect
            anim_instance (AnimInstance): 
            state_name (Name): The name of a state to test
        
        Returns:
            bool:
        """
        ...

class AnimNotifyState_DisableRootMotion(AnimNotifyState):
    r"""
    Anim Notify State Disable Root Motion
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotifyState_DisableRootMotion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify state instance should fire in animation editors
    """
    ...

class AnimNotifyState_TimedParticleEffect(AnimNotifyState):
    r"""
    Timed Particle Effect Notify
    Allows a looping particle effect to be played in an animation that will activate
    at the beginning of the notify and deactivate at the end.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotifyState_TimedParticleEffect.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``destroy_at_end`` (bool):  [Read-Write] Whether the particle system should be immediately destroyed at the end of the notify state or be allowed to finish
    - ``location_offset`` (Vector):  [Read-Write] Offset from the socket or bone to place the particle system
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``ps_template`` (ParticleSystem):  [Read-Write] The particle system to spawn for the notify state
    - ``rotation_offset`` (Rotator):  [Read-Write] Rotation offset from the socket or bone for the particle system
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify state instance should fire in animation editors
    - ``socket_name`` (Name):  [Read-Write] The socket or bone to attach the system to
    """
    ...

class AnimNotifyState_Trail(AnimNotifyState):
    r"""
    Anim Notify State Trail
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotifyState_Trail.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``first_socket_name`` (Name):  [Read-Write] Name of the first socket defining this trail.
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``ps_template`` (ParticleSystem):  [Read-Write] The particle system to use for this trail.
    - ``recycle_spawned_systems`` (bool):  [Read-Write]
    - ``render_geometry`` (bool):  [Read-Write] If true, render the trail geometry (this should typically be on)
    - ``render_spawn_points`` (bool):  [Read-Write] If true, render stars at each spawned particle point along the trail
    - ``render_tangents`` (bool):  [Read-Write] If true, render a line showing the tangent at each spawned particle point along the trail
    - ``render_tessellation`` (bool):  [Read-Write] If true, render the tessellated path between spawned particles
    - ``second_socket_name`` (Name):  [Read-Write] Name of the second socket defining this trail.
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify state instance should fire in animation editors
    - ``width_scale_curve`` (Name):  [Read-Write] Name of the curve to drive the width scale.
    - ``width_scale_mode`` (TrailWidthMode):  [Read-Write] Controls the way width scale is applied. In each method a width scale of 1.0 will mean the width is unchanged from the position of the sockets. A width scale of 0.0 will cause a trail of zero width.
      From Centre = Trail width is scaled outwards from the centre point between the two sockets.
      From First = Trail width is scaled outwards from the position of the first socket.
      From Second = Trail width is scaled outwards from the position of the Second socket.
    """
    @property
    def ps_template(self) -> ParticleSystem:
        r"""
        (ParticleSystem):  [Read-Only] The particle system to use for this trail.
        """
        ...
    @property
    def first_socket_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of the first socket defining this trail.
        """
        ...
    @property
    def second_socket_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of the second socket defining this trail.
        """
        ...
    @property
    def width_scale_mode(self) -> TrailWidthMode:
        r"""
        (TrailWidthMode):  [Read-Only] Controls the way width scale is applied. In each method a width scale of 1.0 will mean the width is unchanged from the position of the sockets. A width scale of 0.0 will cause a trail of zero width.
        From Centre = Trail width is scaled outwards from the centre point between the two sockets.
        From First = Trail width is scaled outwards from the position of the first socket.
        From Second = Trail width is scaled outwards from the position of the Second socket.
        """
        ...
    @property
    def width_scale_curve(self) -> Name:
        r"""
        (Name):  [Read-Only] Name of the curve to drive the width scale.
        """
        ...
    @property
    def recycle_spawned_systems(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    def override_ps_template(self, mesh_comp: SkeletalMeshComponent, animation: AnimSequenceBase) -> ParticleSystem:
        r"""
        x.override_ps_template(mesh_comp, animation) -> ParticleSystem
        Override PSTemplate
        
        Args:
            mesh_comp (SkeletalMeshComponent): 
            animation (AnimSequenceBase): 
        
        Returns:
            ParticleSystem:
        """
        ...

class AnimNotify_PauseClothingSimulation(AnimNotify):
    r"""
    Anim Notify Pause Clothing Simulation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotify_PauseClothingSimulation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify instance should fire in animation editors
    """
    ...

class AnimNotify_PlayParticleEffect(AnimNotify):
    r"""
    Anim Notify Play Particle Effect
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotify_PlayParticleEffect.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attached`` (bool):  [Read-Write] Should attach to the bone/socket
    - ``location_offset`` (Vector):  [Read-Write] Location offset from the socket
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``ps_template`` (ParticleSystem):  [Read-Write] Particle System to Spawn
    - ``rotation_offset`` (Rotator):  [Read-Write] Rotation offset from socket
    - ``scale`` (Vector):  [Read-Write] Scale to spawn the particle system at
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify instance should fire in animation editors
    - ``socket_name`` (Name):  [Read-Write] SocketName to attach to
    """
    @property
    def ps_template(self) -> ParticleSystem:
        r"""
        (ParticleSystem):  [Read-Only] Particle System to Spawn
        """
        ...
    @property
    def location_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Location offset from the socket
        """
        ...
    @property
    def rotation_offset(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] Rotation offset from socket
        """
        ...
    @property
    def attached(self) -> bool:
        r"""
        (bool):  [Read-Only] Should attach to the bone/socket
        """
        ...
    @property
    def socket_name(self) -> Name:
        r"""
        (Name):  [Read-Only] SocketName to attach to
        """
        ...

class AnimNotify_PlayParticleEffect_C(AnimNotify_PlayParticleEffect):
    r"""
    deprecated: 'AnimNotify_PlayParticleEffect_C' was renamed to 'AnimNotify_PlayParticleEffect'.
    """
    ...

class AnimNotify_PlaySound(AnimNotify):
    r"""
    Anim Notify Play Sound
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotify_PlaySound.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attach_name`` (Name):  [Read-Write] Socket or bone name to attach sound to
    - ``follow`` (bool):  [Read-Write] If this sound should follow its owner
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``pitch_multiplier`` (float):  [Read-Write] Pitch Multiplier
    - ``preview_ignore_attenuation`` (bool):  [Read-Write]
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify instance should fire in animation editors
    - ``sound`` (SoundBase):  [Read-Write] Sound to Play
    - ``volume_multiplier`` (float):  [Read-Write] Volume Multiplier
    """
    @property
    def sound(self) -> SoundBase:
        r"""
        (SoundBase):  [Read-Only] Sound to Play
        """
        ...
    @property
    def volume_multiplier(self) -> float:
        r"""
        (float):  [Read-Only] Volume Multiplier
        """
        ...
    @property
    def pitch_multiplier(self) -> float:
        r"""
        (float):  [Read-Only] Pitch Multiplier
        """
        ...
    @property
    def follow(self) -> bool:
        r"""
        (bool):  [Read-Only] If this sound should follow its owner
        """
        ...
    @property
    def attach_name(self) -> Name:
        r"""
        (Name):  [Read-Only] Socket or bone name to attach sound to
        """
        ...

class AnimNotify_PlaySound_C(AnimNotify_PlaySound):
    r"""
    deprecated: 'AnimNotify_PlaySound_C' was renamed to 'AnimNotify_PlaySound'.
    """
    ...

class AnimNotify_ResetClothingSimulation(AnimNotify):
    r"""
    Anim Notify Reset Clothing Simulation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotify_ResetClothingSimulation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify instance should fire in animation editors
    """
    ...

class AnimNotify_ResetDynamics(AnimNotify):
    r"""
    Anim Notify Reset Dynamics
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotify_ResetDynamics.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify instance should fire in animation editors
    """
    ...

class AnimNotify_ResumeClothingSimulation(AnimNotify):
    r"""
    Anim Notify Resume Clothing Simulation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimNotify_ResumeClothingSimulation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify instance should fire in animation editors
    """
    ...

class AnimSequence(AnimSequenceBase):
    r"""
    Anim Sequence
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimSequence.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additive_anim_type`` (AdditiveAnimationType):  [Read-Write] Additive animation type. *
    - ``allow_frame_stripping`` (bool):  [Read-Write] Allow frame stripping to be performed on this animation if the platform requests it
      Can be disabled if animation has high frequency movements that are being lost.
    - ``animation_track_names`` (Array[Name]):  [Read-Only]
    - ``asset_import_data`` (AssetImportData):  [Read-Only] Importing data and options used for this mesh
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``bone_compression_settings`` (AnimBoneCompressionSettings):  [Read-Write] The bone compression settings used to compress bones in this sequence.
    - ``compression_error_threshold_scale`` (float):  [Read-Write] Set a scale for error threshold on compression. This is useful if the animation will
      be played back at a different scale (e.g. if you know the animation will be played
      on an actor/component that is scaled up by a factor of 10, set this value to 10)
    - ``controller`` (AnimationDataController):  [Read-Only] UAnimDataController instance set to operate on DataModel
    - ``curve_compression_settings`` (AnimCurveCompressionSettings):  [Read-Write] The curve compression settings used to compress curves in this sequence.
    - ``data_model`` (AnimDataModel):  [Read-Only]
    - ``data_model_interface`` (AnimationDataModel):  [Read-Only] IAnimationDataModel instance containing (source) animation data
    - ``do_not_override_compression`` (bool):  [Read-Write] Do not attempt to override compression scheme when running CompressAnimations commandlet.
      Some high frequency animations are too sensitive and shouldn't be changed.
    - ``enable_root_motion`` (bool):  [Read-Write] If this is on, it will allow extracting of root motion *
    - ``force_root_lock`` (bool):  [Read-Write] Force Root Bone Lock even if Root Motion is not enabled
    - ``interpolation`` (AnimInterpolationType):  [Read-Write] This defines how values between keys are calculated *
    - ``loop`` (bool):  [Read-Write] The default looping behavior of this animation.
      Asset players can override this
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``number_of_sampled_frames`` (int32):  [Read-Only]
    - ``number_of_sampled_keys`` (int32):  [Read-Only]
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``per_bone_custom_attribute_data`` (Array[CustomAttributePerBoneData]):  [Read-Only]
    - ``platform_target_frame_rate`` (PerPlatformFrameRate):  [Read-Only]
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``rate_scale`` (float):  [Read-Write] Number for tweaking playback rate of this animation globally.
    - ``ref_frame_index`` (int32):  [Read-Write] Additve reference frame if RefPoseType == AnimFrame *
    - ``ref_pose_seq`` (AnimSequence):  [Read-Write] Additive reference animation if it's relevant - i.e. AnimScaled or AnimFrame *
    - ``ref_pose_type`` (AdditiveBasePoseType):  [Read-Write] Additive refrerence pose type. Refer above enum type
    - ``retarget_source`` (Name):  [Read-Write] Base pose to use when retargeting
    - ``retarget_source_asset`` (SkeletalMesh):  [Read-Write] If RetargetSource is set to Default (None), this is asset for the base pose to use when retargeting. Transform data will be saved in RetargetSourceAssetReferencePose.
    - ``root_motion_root_lock`` (RootMotionRootLock):  [Read-Write] Root Bone will be locked to that position when extracting root motion.*
    - ``sequence_length`` (float):  [Read-Only]
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``strip_anim_data_on_dedicated_server`` (StripAnimDataOnDedicatedServerSettings):  [Read-Write] Enum used to decide whether we should strip animation data on dedicated server
    - ``target_frame_rate`` (FrameRate):  [Read-Only]
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``use_normalized_root_motion_scale`` (bool):  [Read-Write] If this is on, it will use a normalized scale value for the root motion extracted: FVector(1.0, 1.0, 1.0) *
    - ``variable_frame_stripping_settings`` (VariableFrameStrippingSettings):  [Read-Write]
    """
    def remove_custom_attribute(self, bone_name: Name, attribute_name: Name) -> None:
        r"""
        x.remove_custom_attribute(bone_name, attribute_name) -> None
        Remove Custom Attribute
        deprecated: RemoveCustomAttribute has been deprecated, use UAnimDataController::RemoveAttribute instead
        
        Args:
            bone_name (Name): 
            attribute_name (Name):
        """
        ...
    def remove_all_custom_attributes_for_bone(self, bone_name: Name) -> None:
        r"""
        x.remove_all_custom_attributes_for_bone(bone_name) -> None
        Remove All Custom Attributes for Bone
        deprecated: RemoveAllCustomAttributesForBone has been deprecated, use UAnimDataController::RemoveAllAttributesForBone instead
        
        Args:
            bone_name (Name):
        """
        ...
    def remove_all_custom_attributes(self) -> None:
        r"""
        x.remove_all_custom_attributes() -> None
        Remove All Custom Attributes
        deprecated: RemoveAllCustomAttributes has been deprecated, use UAnimDataController::RemoveAllAttributes instead
        """
        ...
    def add_bone_string_custom_attribute(self, bone_name: Name, attribute_name: Name, time_keys: Array[float], value_keys: Array[str]) -> None:
        r"""
        x.add_bone_string_custom_attribute(bone_name, attribute_name, time_keys, value_keys) -> None
        Add Bone String Custom Attribute
        deprecated: AddBoneStringCustomAttribute has been deprecated, use UAnimDataController::AddAttribute instead
        
        Args:
            bone_name (Name): 
            attribute_name (Name): 
            time_keys (Array[float]): 
            value_keys (Array[str]):
        """
        ...
    def add_bone_integer_custom_attribute(self, bone_name: Name, attribute_name: Name, time_keys: Array[float], value_keys: Array[int]) -> None:
        r"""
        x.add_bone_integer_custom_attribute(bone_name, attribute_name, time_keys, value_keys) -> None
        Add Bone Integer Custom Attribute
        deprecated: AddBoneIntegerCustomAttribute has been deprecated, use UAnimDataController::AddAttribute instead
        
        Args:
            bone_name (Name): 
            attribute_name (Name): 
            time_keys (Array[float]): 
            value_keys (Array[int32]):
        """
        ...
    def add_bone_float_custom_attribute(self, bone_name: Name, attribute_name: Name, time_keys: Array[float], value_keys: Array[float]) -> None:
        r"""
        x.add_bone_float_custom_attribute(bone_name, attribute_name, time_keys, value_keys) -> None
        Add Bone Float Custom Attribute
        deprecated: AddBoneFloatCustomAttribute has been deprecated, use UAnimDataController::AddAttribute instead
        
        Args:
            bone_name (Name): 
            attribute_name (Name): 
            time_keys (Array[float]): 
            value_keys (Array[float]):
        """
        ...

class AnimStreamable(AnimSequenceBase):
    r"""
    Anim Streamable
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimStreamable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``bone_compression_settings`` (AnimBoneCompressionSettings):  [Read-Write] The bone compression settings used to compress bones in this sequence.
    - ``controller`` (AnimationDataController):  [Read-Only] UAnimDataController instance set to operate on DataModel
    - ``curve_compression_settings`` (AnimCurveCompressionSettings):  [Read-Write] The curve compression settings used to compress curves in this sequence.
    - ``data_model`` (AnimDataModel):  [Read-Only]
    - ``data_model_interface`` (AnimationDataModel):  [Read-Only] IAnimationDataModel instance containing (source) animation data
    - ``enable_root_motion`` (bool):  [Read-Write] If this is on, it will allow extracting of root motion *
    - ``force_root_lock`` (bool):  [Read-Write] Force Root Bone Lock even if Root Motion is not enabled
    - ``interpolation`` (AnimInterpolationType):  [Read-Write] This defines how values between keys are calculated *
    - ``loop`` (bool):  [Read-Write] The default looping behavior of this animation.
      Asset players can override this
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``rate_scale`` (float):  [Read-Write] Number for tweaking playback rate of this animation globally.
    - ``retarget_source`` (Name):  [Read-Write] Base pose to use when retargeting
    - ``root_motion_root_lock`` (RootMotionRootLock):  [Read-Write] Root Bone will be locked to that position when extracting root motion.*
    - ``sequence_length`` (float):  [Read-Only]
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``use_normalized_root_motion_scale`` (bool):  [Read-Write] If this is on, it will use a normalized scale value for the root motion extracted: FVector(1.0, 1.0, 1.0) *
    - ``variable_frame_stripping_settings`` (VariableFrameStrippingSettings):  [Read-Write] The settings used to control whether or not to use variable frame stripping and its amount
    """
    ...

class AnimationAttributeIdentifierExtensions(BlueprintFunctionLibrary):
    r"""
    Script-exposed functionality for wrapping native functionality and constructing valid FAnimationAttributeIdentifier instances
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AttributeIdentifier.h
    
    """
    @classmethod
    def is_valid(cls, identifier: AnimationAttributeIdentifier) -> Optional[AnimationAttributeIdentifier]:
        r"""
        X.is_valid(identifier) -> AnimationAttributeIdentifier or None
        
        
        Args:
            identifier (AnimationAttributeIdentifier): 
        
        Returns:
            AnimationAttributeIdentifier or None: Whether or not the Attribute Identifier is valid
        
            identifier (AnimationAttributeIdentifier):
        """
        ...
    @classmethod
    def create_attribute_identifier(cls, animation_asset: AnimationAsset, attribute_name: Name, bone_name: Name, attribute_type: ScriptStruct, validate_exists_on_asset: bool = False) -> AnimationAttributeIdentifier:
        r"""
        X.create_attribute_identifier(animation_asset, attribute_name, bone_name, attribute_type, validate_exists_on_asset=False) -> AnimationAttributeIdentifier
        Constructs a valid FAnimationAttributeIdentifier instance. Ensuring that the underlying BoneName exists on the Skeleton for the provided AnimationAsset.
        
        Args:
            animation_asset (AnimationAsset): Animation asset to retrieve Skeleton from
            attribute_name (Name): Name of the attribute
            bone_name (Name): Name of the bone this attribute should be attributed to
            attribute_type (ScriptStruct): Type of the underlying data (to-be) stored by this attribute
            validate_exists_on_asset (bool): Whether or not the attribute should exist on the AnimationAsset. False by default.
        
        Returns:
            AnimationAttributeIdentifier: Valid FAnimationCurveIdentifier if the operation was successful
        """
        ...

class BlendProfile(Object):
    r"""
    A blend profile is a set of per-bone scales that can be used in transitions and blend lists
    to tweak the weights of specific bones. The scales are applied to the normal weight for that bone
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendProfile.h
    
    """
    ...

class BoneMaskFilter(Object):
    r"""
    Bone Mask Filter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BoneMaskFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_poses`` (Array[InputBlendPose]):  [Read-Write]
    """
    ...

class CachedAnimDataLibrary(BlueprintFunctionLibrary):
    r"""
    A library of commonly used functionality from the CachedAnimData family, exposed to blueprint.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CachedAnimDataLibrary.h
    
    """
    @classmethod
    def state_machine_is_state_relevant(cls, anim_instance: AnimInstance, cached_anim_state_data: CachedAnimStateData) -> bool:
        r"""
        X.state_machine_is_state_relevant(anim_instance, cached_anim_state_data) -> bool
        Returns whether a state is relevant (specified in the provided FCachedAnimStateData)
        
        Args:
            anim_instance (AnimInstance): 
            cached_anim_state_data (CachedAnimStateData): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def state_machine_get_local_weight(cls, anim_instance: AnimInstance, cached_anim_state_data: CachedAnimStateData) -> float:
        r"""
        X.state_machine_get_local_weight(anim_instance, cached_anim_state_data) -> float
        Returns the weight of a state, relative to its state machine (specified in the provided FCachedAnimStateData)
        
        Args:
            anim_instance (AnimInstance): 
            cached_anim_state_data (CachedAnimStateData): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def state_machine_get_global_weight(cls, anim_instance: AnimInstance, cached_anim_state_data: CachedAnimStateData) -> float:
        r"""
        X.state_machine_get_global_weight(anim_instance, cached_anim_state_data) -> float
        Returns the weight of a state, relative to the graph (specified in the provided FCachedAnimStateData)
        
        Args:
            anim_instance (AnimInstance): 
            cached_anim_state_data (CachedAnimStateData): 
        
        Returns:
            float:
        """
        ...

class AnimationCurveIdentifierExtensions(BlueprintFunctionLibrary):
    r"""
    Script-exposed functionality for wrapping native functionality and constructing valid FAnimationCurveIdentifier instances
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveIdentifier.h
    
    """
    @classmethod
    def set_curve_identifier(cls, out_identifier: AnimationCurveIdentifier, name: Name, curve_type: RawCurveTrackTypes) -> AnimationCurveIdentifier:
        r"""
        X.set_curve_identifier(out_identifier, name, curve_type) -> AnimationCurveIdentifier
        Constructs a valid FAnimationCurveIdentifier instance.
        
        Args:
            out_identifier (AnimationCurveIdentifier): The identifier to set up
            name (Name): Name of the curve to find or add
            curve_type (RawCurveTrackTypes): Type of the curve to find or add
        
        Returns:
            AnimationCurveIdentifier: 
        
            out_identifier (AnimationCurveIdentifier): The identifier to set up
        """
        ...
    @classmethod
    def is_valid(cls, identifier: AnimationCurveIdentifier) -> Optional[AnimationCurveIdentifier]:
        r"""
        X.is_valid(identifier) -> AnimationCurveIdentifier or None
        
        
        Args:
            identifier (AnimationCurveIdentifier): 
        
        Returns:
            AnimationCurveIdentifier or None: Whether or not the Curve Identifier is valid
        
            identifier (AnimationCurveIdentifier):
        """
        ...
    @classmethod
    def get_type(cls, identifier: AnimationCurveIdentifier) -> Tuple[RawCurveTrackTypes, AnimationCurveIdentifier]:
        r"""
        X.get_type(identifier) -> (RawCurveTrackTypes, identifier=AnimationCurveIdentifier)
        
        
        Args:
            identifier (AnimationCurveIdentifier): 
        
        Returns:
            AnimationCurveIdentifier: The animation curve type for the curve represented by the Curve Identifier
        
            identifier (AnimationCurveIdentifier):
        """
        ...
    @classmethod
    def get_transform_child_curve_identifier(cls, out_identifier: AnimationCurveIdentifier, channel: TransformCurveChannel, axis: VectorCurveChannel) -> Optional[AnimationCurveIdentifier]:
        r"""
        X.get_transform_child_curve_identifier(out_identifier, channel, axis) -> AnimationCurveIdentifier or None
        Converts a valid FAnimationCurveIdentifier instance with RCT_Transform curve type to target a child curve.
        
        Args:
            out_identifier (AnimationCurveIdentifier): [out] Identifier to be converted
            channel (TransformCurveChannel): Channel to target
            axis (VectorCurveChannel): Axis within channel to target
        
        Returns:
            AnimationCurveIdentifier or None: Valid FAnimationCurveIdentifier if the operation was successful
        
            out_identifier (AnimationCurveIdentifier): [out] Identifier to be converted
        """
        ...
    @classmethod
    def get_name(cls, identifier: AnimationCurveIdentifier) -> Tuple[Name, AnimationCurveIdentifier]:
        r"""
        X.get_name(identifier) -> (Name, identifier=AnimationCurveIdentifier)
        
        
        Args:
            identifier (AnimationCurveIdentifier): 
        
        Returns:
            AnimationCurveIdentifier: The name used for displaying the Curve Identifier
        
            identifier (AnimationCurveIdentifier):
        """
        ...
    @classmethod
    def get_curve_identifiers(cls, skeleton: Skeleton, curve_type: RawCurveTrackTypes) -> Array[AnimationCurveIdentifier]:
        r"""
        X.get_curve_identifiers(skeleton, curve_type) -> Array[AnimationCurveIdentifier]
        Retrieves all curve identifiers for a specific curve types from the provided Skeleton
        deprecated: Curve identifiers are no longer retrievable globally from the skeleton, they are specified per-animation.
        
        Args:
            skeleton (Skeleton): Skeleton from which to retrieve the curve identifiers
            curve_type (RawCurveTrackTypes): Type of the curve identifers to retrieve
        
        Returns:
            Array[AnimationCurveIdentifier]: Array of FAnimationCurveIdentifier instances each representing a unique curve if the operation was successful, empyty array otherwise
        """
        ...
    @classmethod
    def get_curve_identifier(cls, skeleton: Skeleton, name: Name, curve_type: RawCurveTrackTypes) -> AnimationCurveIdentifier:
        r"""
        X.get_curve_identifier(skeleton, name, curve_type) -> AnimationCurveIdentifier
        Get Curve Identifier
        deprecated: Please use SetCurveIdentifier.
        
        Args:
            skeleton (Skeleton): 
            name (Name): 
            curve_type (RawCurveTrackTypes): 
        
        Returns:
            AnimationCurveIdentifier:
        """
        ...
    @classmethod
    def find_curve_identifier(cls, skeleton: Skeleton, name: Name, curve_type: RawCurveTrackTypes) -> AnimationCurveIdentifier:
        r"""
        X.find_curve_identifier(skeleton, name, curve_type) -> AnimationCurveIdentifier
        Tries to construct a valid FAnimationCurveIdentifier instance. It tries to find the underlying SmartName on the provided Skeleton for the provided curve type.
        deprecated: Curve identifiers are no longer retrievable globally from the skeleton, they are specified per-animation.
        
        Args:
            skeleton (Skeleton): Skeleton on which to look for the curve name
            name (Name): Name of the curve to find
            curve_type (RawCurveTrackTypes): Type of the curve to find
        
        Returns:
            AnimationCurveIdentifier: Valid FAnimationCurveIdentifier if the name exists on the skeleton and the operation was successful, invalid otherwise
        """
        ...

class CurveSourceInterface(Interface):
    r"""
    Curve Source Interface
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveSourceInterface.h
    
    """
    def get_curve_value(self, curve_name: Name) -> float:
        r"""
        x.get_curve_value(curve_name) -> float
        Get the value for a specified curve
        
        Args:
            curve_name (Name): 
        
        Returns:
            float:
        """
        ...
    def get_curves(self) -> Array[NamedCurveValue]:
        r"""
        x.get_curves() -> Array[NamedCurveValue]
        Evaluate all curves that this source provides
        
        Returns:
            Array[NamedCurveValue]: 
        
            out_values (Array[NamedCurveValue]):
        """
        ...
    def get_binding_name(self) -> Name:
        r"""
        x.get_binding_name() -> Name
        Get the name that this curve source can be bound to by.
        Clients of this curve source will use this name to identify this source.
        
        Returns:
            Name:
        """
        ...

class DataTable(Object):
    r"""
    Imported spreadsheet table.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only] The file this data table was imported from, may be empty
    - ``ignore_extra_fields`` (bool):  [Read-Write] Set to true to ignore extra fields in the import data, if false it will warn about them
    - ``ignore_missing_fields`` (bool):  [Read-Write] Set to true to ignore any fields that are expected but missing, if false it will warn about them
    - ``import_key_field`` (str):  [Read-Write] Explicit field in import data to use as key. If this is empty it uses Name for JSON and the first field found for CSV
    - ``row_struct`` (ScriptStruct):  [Read-Only] Structure to use for each row of the table, must inherit from FTableRowBase
    - ``strip_from_client_builds`` (bool):  [Read-Write] Set to true to not cook this data table into client builds. Useful for sensitive tables that only servers should know about.
    """
    def get_row_struct(self) -> ScriptStruct:
        r"""
        x.get_row_struct() -> ScriptStruct
        Get the row struct used by the given Data Table, if any
        
        Returns:
            ScriptStruct:
        """
        ...
    def get_row_names(self) -> Array[Name]:
        r"""
        x.get_row_names() -> Array[Name]
        Get Data Table Row Names
        
        Returns:
            Array[Name]: 
        
            out_row_names (Array[Name]):
        """
        ...
    def get_column_names(self) -> Array[Name]:
        r"""
        x.get_column_names() -> Array[Name]
        Get the name of each column in this Data Table.
        note: These are always the raw property names (
        see: GetDataTableColumnAsString) rather than the friendly export name that would be used in a CSV/JSON export (
        see: GetDataTableColumnNameFromExportName).
        
        Returns:
            Array[Name]: 
        
            out_column_names (Array[Name]):
        """
        ...
    def get_column_name_from_export_name(self, column_export_name: str) -> Optional[Name]:
        r"""
        x.get_column_name_from_export_name(column_export_name) -> Name or None
        Get the raw property name of a data table column from its friendly export name.
        
        Args:
            column_export_name (str): 
        
        Returns:
            Name or None: True if a column was found for the friendly name, false otherwise.
        
            out_column_name (Name):
        """
        ...
    def get_column_export_names(self) -> Array[str]:
        r"""
        x.get_column_export_names() -> Array[str]
        Get the friendly export name of each column in this Data Table.
        see: GetDataTableColumnNameFromExportName.
        
        Returns:
            Array[str]: 
        
            out_export_column_names (Array[str]):
        """
        ...
    def get_column_as_string(self, property_name: Name) -> Array[str]:
        r"""
        x.get_column_as_string(property_name) -> Array[str]
        Export from the DataTable all the row for one column. Export it as string. The row name is not included.
        see: GetDataTableColumnNames.
        see: GetDataTableColumnNameFromExportName.
        
        Args:
            property_name (Name): 
        
        Returns:
            Array[str]:
        """
        ...
    def fill_from_json_string(self, json_string: str, import_row_struct: ScriptStruct = None) -> bool:
        r"""
        x.fill_from_json_string(json_string, import_row_struct=None) -> bool
        Empty and fill a Data Table from JSON string.
        
        Args:
            json_string (str): The Data that representing the contents of a JSON file.
            import_row_struct (ScriptStruct): Optional row struct to apply on import. If set will also force the import to run automated (no questions or dialogs).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    def fill_from_json_file(self, json_file_path: str, import_row_struct: ScriptStruct = None) -> bool:
        r"""
        x.fill_from_json_file(json_file_path, import_row_struct=None) -> bool
        Empty and fill a Data Table from JSON file.
        
        Args:
            json_file_path (str): The file path of the JSON file.
            import_row_struct (ScriptStruct): Optional row struct to apply on import. If set will also force the import to run automated (no questions or dialogs).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    def fill_from_csv_string(self, csv_string: str, import_row_struct: ScriptStruct = None) -> bool:
        r"""
        x.fill_from_csv_string(csv_string, import_row_struct=None) -> bool
        Empty and fill a Data Table from CSV string.
        
        Args:
            csv_string (str): The Data that representing the contents of a CSV file.
            import_row_struct (ScriptStruct): Optional row struct to apply on import. If set will also force the import to run automated (no questions or dialogs).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    def fill_from_csv_file(self, csv_file_path: str, import_row_struct: ScriptStruct = None) -> bool:
        r"""
        x.fill_from_csv_file(csv_file_path, import_row_struct=None) -> bool
        Empty and fill a Data Table from CSV file.
        
        Args:
            csv_file_path (str): The file path of the CSV file.
            import_row_struct (ScriptStruct): Optional row struct to apply on import. If set will also force the import to run automated (no questions or dialogs).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    def export_to_json_string(self) -> Optional[str]:
        r"""
        x.export_to_json_string() -> str or None
        Export a Data Table to JSON string.
        
        Returns:
            str or None: True if the operation succeeds, check the log for errors if it didn't succeed.
        
            out_json_string (str): Output representing the contents of a JSON file.
        """
        ...
    def export_to_json_file(self, json_file_path: str) -> bool:
        r"""
        x.export_to_json_file(json_file_path) -> bool
        Export a Data Table to JSON file.
        
        Args:
            json_file_path (str): The file path of the JSON file to write (output file is UTF-8).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    def export_to_csv_string(self) -> Optional[str]:
        r"""
        x.export_to_csv_string() -> str or None
        Export a Data Table to CSV string.
        
        Returns:
            str or None: True if the operation succeeds, check the log for errors if it didn't succeed.
        
            out_csv_string (str): Output representing the contents of a CSV file.
        """
        ...
    def export_to_csv_file(self, csv_file_path: str) -> bool:
        r"""
        x.export_to_csv_file(csv_file_path) -> bool
        Export a Data Table to CSV file.
        
        Args:
            csv_file_path (str): The file path of the CSV file to write (output file is UTF-8).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    def does_row_exist(self, row_name: Name) -> bool:
        r"""
        x.does_row_exist(row_name) -> bool
        Returns whether or not Table contains a row named RowName
        
        Args:
            row_name (Name): 
        
        Returns:
            bool:
        """
        ...

class MirrorDataTable(DataTable):
    r"""
    AutoExpandCategories = "MirrorDataTable,ImportOptions"
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MirrorDataTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only] The file this data table was imported from, may be empty
    - ``ignore_extra_fields`` (bool):  [Read-Write] Set to true to ignore extra fields in the import data, if false it will warn about them
    - ``ignore_missing_fields`` (bool):  [Read-Write] Set to true to ignore any fields that are expected but missing, if false it will warn about them
    - ``import_key_field`` (str):  [Read-Write] Explicit field in import data to use as key. If this is empty it uses Name for JSON and the first field found for CSV
    - ``mirror_axis`` (AxisType):  [Read-Write]
    - ``mirror_find_replace_expressions`` (Array[MirrorFindReplaceExpression]):  [Read-Write]
    - ``mirror_root_motion`` (bool):  [Read-Write]
    - ``row_struct`` (ScriptStruct):  [Read-Only] Structure to use for each row of the table, must inherit from FTableRowBase
    - ``skeleton`` (Skeleton):  [Read-Write]
    - ``strip_from_client_builds`` (bool):  [Read-Write] Set to true to not cook this data table into client builds. Useful for sensitive tables that only servers should know about.
    """
    ...

class NodeMappingContainer(Object):
    r"""
    Node Mapping Container Class
    * This saves source items, and target items, and mapping between
    * Used by Retargeting, Control Rig mapping. Will need to improve interface better
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NodeMappingContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source_asset`` (Object):  [Read-Write] source asset that is used to create source
      should be UNodeMappingProviderInterface
    - ``source_items`` (Map[Name, NodeItem]):  [Read-Only]
    - ``source_to_target`` (Map[Name, Name]):  [Read-Write]
    - ``target_asset`` (Object):  [Read-Write] source asset that is used to create target
      should be UNodeMappingProviderInterface
    - ``target_items`` (Map[Name, NodeItem]):  [Read-Only]
    """
    ...

class PoseAsset(AnimationAsset):
    r"""
    Pose Asset that can be blended by weight of curves
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PoseAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additive_pose`` (bool):  [Read-Write] Whether or not Additive Pose or not - these are property that needs post process, so
    - ``asset_mapping_table`` (AssetMappingTable):  [Read-Only] Asset mapping table when ParentAsset is set
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``meta_data`` (Array[AnimMetaData]):  [Read-Write] Meta data that can be saved with the asset
      
      You can query by GetMetaData function
    - ``parent_asset`` (AnimationAsset):  [Read-Only] Parent Asset, if set, you won't be able to edit any data in here but just mapping table
      
      During cooking, this data will be used to bake out to normal asset
    - ``preview_pose_asset`` (PoseAsset):  [Read-Write] The default skeletal mesh to use when previewing this asset - this only applies when you open Persona using this asset//
      todo:: note that this doesn't retarget right now
    - ``retarget_source`` (Name):  [Read-Write] Base pose to use when retargeting
    - ``retarget_source_asset`` (SkeletalMesh):  [Read-Write] If RetargetSource is set to Default (None), this is asset for the base pose to use when retargeting. Transform data will be saved in RetargetSourceAssetReferencePose.
    - ``skeleton`` (Skeleton):  [Read-Only] Pointer to the Skeleton this asset can be played on .
    - ``source_animation`` (AnimSequence):  [Read-Write]
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    def update_pose_from_animation(self, anim_sequence: AnimSequence) -> None:
        r"""
        x.update_pose_from_animation(anim_sequence) -> None
        Contained poses are re-generated from the provided Animation Sequence
        
        Args:
            anim_sequence (AnimSequence):
        """
        ...
    def set_base_pose_name(self, new_base_pose_name: Name) -> bool:
        r"""
        x.set_base_pose_name(new_base_pose_name) -> bool
        Set base pose index by name, NAME_None indicates reference pose - returns true if set successfully
        
        Args:
            new_base_pose_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def rename_pose(self, original_pose_name: Name, new_pose_name: Name) -> None:
        r"""
        x.rename_pose(original_pose_name, new_pose_name) -> None
        Renames a specific pose
        
        Args:
            original_pose_name (Name): 
            new_pose_name (Name):
        """
        ...
    def get_pose_names(self) -> Array[Name]:
        r"""
        x.get_pose_names() -> Array[Name]
        Returns the name of all contained poses
        
        Returns:
            Array[Name]: 
        
            pose_names (Array[Name]):
        """
        ...
    def get_base_pose_name(self) -> Name:
        r"""
        x.get_base_pose_name() -> Name
        Returns base pose name, only valid when additive, NAME_None indicates reference pose
        
        Returns:
            Name:
        """
        ...

class PreviewMeshCollection(DataAsset):
    r"""
    A simple collection of skeletal meshes used for in-editor preview
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PreviewMeshCollection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``skeletal_meshes`` (Array[PreviewMeshCollectionEntry]):  [Read-Write] The skeletal meshes that this collection contains
    - ``skeleton`` (Skeleton):  [Read-Only]
    """
    ...

class AsyncActionLoadPrimaryAssetBase(BlueprintAsyncActionBase):
    r"""
    Base class of all asset manager load calls
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionLoadPrimaryAsset.h
    
    """
    ...

class AsyncActionLoadPrimaryAsset(AsyncActionLoadPrimaryAssetBase):
    r"""
    Async Action Load Primary Asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionLoadPrimaryAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``completed`` (OnPrimaryAssetLoaded):  [Read-Write]
    """
    @property
    def completed(self) -> OnPrimaryAssetLoaded:
        r"""
        (OnPrimaryAssetLoaded):  [Read-Write]
        """
        ...
    @completed.setter
    def completed(self, value: OnPrimaryAssetLoaded) -> None:
        ...

class AsyncActionLoadPrimaryAssetClass(AsyncActionLoadPrimaryAssetBase):
    r"""
    Async Action Load Primary Asset Class
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionLoadPrimaryAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``completed`` (OnPrimaryAssetClassLoaded):  [Read-Write]
    """
    @property
    def completed(self) -> OnPrimaryAssetClassLoaded:
        r"""
        (OnPrimaryAssetClassLoaded):  [Read-Write]
        """
        ...
    @completed.setter
    def completed(self, value: OnPrimaryAssetClassLoaded) -> None:
        ...

class AsyncActionLoadPrimaryAssetList(AsyncActionLoadPrimaryAssetBase):
    r"""
    Async Action Load Primary Asset List
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionLoadPrimaryAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``completed`` (OnPrimaryAssetListLoaded):  [Read-Write]
    """
    @property
    def completed(self) -> OnPrimaryAssetListLoaded:
        r"""
        (OnPrimaryAssetListLoaded):  [Read-Write]
        """
        ...
    @completed.setter
    def completed(self, value: OnPrimaryAssetListLoaded) -> None:
        ...

class AsyncActionLoadPrimaryAssetClassList(AsyncActionLoadPrimaryAssetBase):
    r"""
    Async Action Load Primary Asset Class List
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionLoadPrimaryAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``completed`` (OnPrimaryAssetClassListLoaded):  [Read-Write]
    """
    @property
    def completed(self) -> OnPrimaryAssetClassListLoaded:
        r"""
        (OnPrimaryAssetClassListLoaded):  [Read-Write]
        """
        ...
    @completed.setter
    def completed(self, value: OnPrimaryAssetClassListLoaded) -> None:
        ...

class AsyncActionChangePrimaryAssetBundles(AsyncActionLoadPrimaryAssetBase):
    r"""
    Async Action Change Primary Asset Bundles
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionLoadPrimaryAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``completed`` (OnPrimaryAssetBundlesChanged):  [Read-Write]
    """
    @property
    def completed(self) -> OnPrimaryAssetBundlesChanged:
        r"""
        (OnPrimaryAssetBundlesChanged):  [Read-Write]
        """
        ...
    @completed.setter
    def completed(self, value: OnPrimaryAssetBundlesChanged) -> None:
        ...

class AtmosphericFog(Info):
    r"""
    A placeable fog actor that simulates atmospheric light scattering
    see: https://docs.unrealengine.com/latest/INT/Engine/Actors/FogEffects/AtmosphericFog/index.html
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AtmosphericFog.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``atmospheric_fog_component`` (AtmosphericFogComponent):  [Read-Only] Main fog component
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def atmospheric_fog_component(self) -> AtmosphericFogComponent:
        r"""
        (AtmosphericFogComponent):  [Read-Only] Main fog component
        """
        ...

class SkyAtmosphereComponent(SceneComponent):
    r"""
    A component that represents a planet atmosphere material and simulates sky and light scattering within it.
    see: https://docs.unrealengine.com/en-US/Engine/Actors/FogEffects/SkyAtmosphere/index.html
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkyAtmosphereComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``aerial_perspective_start_depth`` (float):  [Read-Write] The distance (kilometers) at which we start evaluating the aerial perspective. Having the aerial perspective starts away from the camera can help with performance: pixels not affected by the aerial perspective will have their computation skipped using early depth test.
    - ``aerial_pespective_view_distance_scale`` (float):  [Read-Write] Makes the aerial perspective look thicker by scaling distances from view to surfaces (opaque and translucent).
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``atmosphere_height`` (float):  [Read-Write] The height of the atmosphere layer above the ground in kilometers.
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bottom_radius`` (float):  [Read-Write] The radius in kilometers from the center of the planet to the ground level.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``ground_albedo`` (Color):  [Read-Write] The ground albedo that will tint the atmosphere when the sun light will bounce on it. Only taken into account when MultiScattering>0.0.
    - ``height_fog_contribution`` (float):  [Read-Write] Scale the sky and atmosphere lights contribution to the height fog when SupportSkyAtmosphereAffectsHeightFog project setting is true.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mie_absorption`` (LinearColor):  [Read-Write] The Mie absorption coefficients resulting from particles in the air at an altitude of 0 kilometer. As it becomes higher, light will be absorbed more.
    - ``mie_absorption_scale`` (float):  [Read-Write] Mie absorption coefficient scale.
    - ``mie_anisotropy`` (float):  [Read-Write] A value of 0 mean light is uniformly scattered. A value closer to 1 means lights will scatter more forward, resulting in halos around light sources.
    - ``mie_exponential_distribution`` (float):  [Read-Write] The altitude in kilometer at which Mie effects are reduced to 40%.
    - ``mie_scattering`` (LinearColor):  [Read-Write] The Mie scattering coefficients resulting from particles in the air at an altitude of 0 kilometer. As it becomes higher, light will be scattered more.
    - ``mie_scattering_scale`` (float):  [Read-Write] Mie scattering coefficient scale.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_scattering_factor`` (float):  [Read-Write] Factor applied to multiple scattering only (after the sun light has bounced around in the atmosphere at least once).
      Multiple scattering is evaluated using a dual scattering approach.
      A value of 2 is recommended to better represent default atmosphere when r.SkyAtmosphere.MultiScatteringLUT.HighQuality=0.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``other_absorption`` (LinearColor):  [Read-Write] Absorption coefficients for another atmosphere layer. Density increase from 0 to 1 between 10 to 25km and decreases from 1 to 0 between 25 to 40km. The default values represents ozone molecules absorption in the Earth atmosphere.
    - ``other_absorption_scale`` (float):  [Read-Write] Absorption coefficients for another atmosphere layer. Density increase from 0 to 1 between 10 to 25km and decreases from 1 to 0 between 25 to 40km. This approximates ozone molecules distribution in the Earth atmosphere.
    - ``other_tent_distribution`` (TentDistribution):  [Read-Write] Represents the altitude based tent distribution of absorption particles in the atmosphere.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``rayleigh_exponential_distribution`` (float):  [Read-Write] The altitude in kilometer at which Rayleigh scattering effect is reduced to 40%.
    - ``rayleigh_scattering`` (LinearColor):  [Read-Write] The Rayleigh scattering coefficients resulting from molecules in the air at an altitude of 0 kilometer.
    - ``rayleigh_scattering_scale`` (float):  [Read-Write] Rayleigh scattering coefficient scale.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (basepass, transparency)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sky_luminance_factor`` (LinearColor):  [Read-Write] Scales the luminance of pixels representing the sky. This will impact the captured sky light.
    - ``trace_sample_count_scale`` (float):  [Read-Write] Scale the atmosphere tracing sample count. Quality level scalability
      The sample count is still clamped according to scalability setting to 'r.SkyAtmosphere.SampleCountMax' when 'r.SkyAtmosphere.FastSkyLUT' is 0.
      The sample count is still clamped according to scalability setting to 'r.SkyAtmosphere.FastSkyLUT.SampleCountMax' when 'r.SkyAtmosphere.FastSkyLUT' is 1.
      The sample count is still clamped for aerial perspective according to  'r.SkyAtmosphere.AerialPerspectiveLUT.SampleCountMaxPerSlice'.
    - ``transform_mode`` (SkyAtmosphereTransformMode):  [Read-Write] The ground albedo that will tint the atmosphere when the sun light will bounce on it. Only taken into account when MultiScattering>0.0.
    - ``transmittance_min_light_elevation_angle`` (float):  [Read-Write] The minimum elevation angle in degree that should be used to evaluate the sun transmittance to the ground. Useful to maintain a visible sun light and shadow on meshes even when the sun has started going below the horizon. This does not affect the aerial perspective.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def transform_mode(self) -> SkyAtmosphereTransformMode:
        r"""
        (SkyAtmosphereTransformMode):  [Read-Only] The ground albedo that will tint the atmosphere when the sun light will bounce on it. Only taken into account when MultiScattering>0.0.
        """
        ...
    @property
    def bottom_radius(self) -> float:
        r"""
        (float):  [Read-Only] The radius in kilometers from the center of the planet to the ground level.
        """
        ...
    @property
    def ground_albedo(self) -> Color:
        r"""
        (Color):  [Read-Only] The ground albedo that will tint the atmosphere when the sun light will bounce on it. Only taken into account when MultiScattering>0.0.
        """
        ...
    @property
    def atmosphere_height(self) -> float:
        r"""
        (float):  [Read-Only] The height of the atmosphere layer above the ground in kilometers.
        """
        ...
    @property
    def multi_scattering_factor(self) -> float:
        r"""
        (float):  [Read-Only] Factor applied to multiple scattering only (after the sun light has bounced around in the atmosphere at least once).
        Multiple scattering is evaluated using a dual scattering approach.
        A value of 2 is recommended to better represent default atmosphere when r.SkyAtmosphere.MultiScatteringLUT.HighQuality=0.
        """
        ...
    @property
    def trace_sample_count_scale(self) -> float:
        r"""
        (float):  [Read-Only] Scale the atmosphere tracing sample count. Quality level scalability
        The sample count is still clamped according to scalability setting to 'r.SkyAtmosphere.SampleCountMax' when 'r.SkyAtmosphere.FastSkyLUT' is 0.
        The sample count is still clamped according to scalability setting to 'r.SkyAtmosphere.FastSkyLUT.SampleCountMax' when 'r.SkyAtmosphere.FastSkyLUT' is 1.
        The sample count is still clamped for aerial perspective according to  'r.SkyAtmosphere.AerialPerspectiveLUT.SampleCountMaxPerSlice'.
        """
        ...
    @property
    def rayleigh_scattering_scale(self) -> float:
        r"""
        (float):  [Read-Only] Rayleigh scattering coefficient scale.
        """
        ...
    @property
    def rayleigh_scattering(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The Rayleigh scattering coefficients resulting from molecules in the air at an altitude of 0 kilometer.
        """
        ...
    @property
    def rayleigh_exponential_distribution(self) -> float:
        r"""
        (float):  [Read-Only] The altitude in kilometer at which Rayleigh scattering effect is reduced to 40%.
        """
        ...
    @property
    def mie_scattering_scale(self) -> float:
        r"""
        (float):  [Read-Only] Mie scattering coefficient scale.
        """
        ...
    @property
    def mie_scattering(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The Mie scattering coefficients resulting from particles in the air at an altitude of 0 kilometer. As it becomes higher, light will be scattered more.
        """
        ...
    @property
    def mie_absorption_scale(self) -> float:
        r"""
        (float):  [Read-Only] Mie absorption coefficient scale.
        """
        ...
    @property
    def mie_absorption(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The Mie absorption coefficients resulting from particles in the air at an altitude of 0 kilometer. As it becomes higher, light will be absorbed more.
        """
        ...
    @property
    def mie_anisotropy(self) -> float:
        r"""
        (float):  [Read-Only] A value of 0 mean light is uniformly scattered. A value closer to 1 means lights will scatter more forward, resulting in halos around light sources.
        """
        ...
    @property
    def mie_exponential_distribution(self) -> float:
        r"""
        (float):  [Read-Only] The altitude in kilometer at which Mie effects are reduced to 40%.
        """
        ...
    @property
    def other_absorption_scale(self) -> float:
        r"""
        (float):  [Read-Only] Absorption coefficients for another atmosphere layer. Density increase from 0 to 1 between 10 to 25km and decreases from 1 to 0 between 25 to 40km. This approximates ozone molecules distribution in the Earth atmosphere.
        """
        ...
    @property
    def other_absorption(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Absorption coefficients for another atmosphere layer. Density increase from 0 to 1 between 10 to 25km and decreases from 1 to 0 between 25 to 40km. The default values represents ozone molecules absorption in the Earth atmosphere.
        """
        ...
    @property
    def other_tent_distribution(self) -> TentDistribution:
        r"""
        (TentDistribution):  [Read-Only] Represents the altitude based tent distribution of absorption particles in the atmosphere.
        """
        ...
    @property
    def sky_luminance_factor(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Scales the luminance of pixels representing the sky. This will impact the captured sky light.
        """
        ...
    @property
    def aerial_pespective_view_distance_scale(self) -> float:
        r"""
        (float):  [Read-Only] Makes the aerial perspective look thicker by scaling distances from view to surfaces (opaque and translucent).
        """
        ...
    @property
    def height_fog_contribution(self) -> float:
        r"""
        (float):  [Read-Only] Scale the sky and atmosphere lights contribution to the height fog when SupportSkyAtmosphereAffectsHeightFog project setting is true.
        """
        ...
    @property
    def transmittance_min_light_elevation_angle(self) -> float:
        r"""
        (float):  [Read-Only] The minimum elevation angle in degree that should be used to evaluate the sun transmittance to the ground. Useful to maintain a visible sun light and shadow on meshes even when the sun has started going below the horizon. This does not affect the aerial perspective.
        """
        ...
    @property
    def aerial_perspective_start_depth(self) -> float:
        r"""
        (float):  [Read-Only] The distance (kilometers) at which we start evaluating the aerial perspective. Having the aerial perspective starts away from the camera can help with performance: pixels not affected by the aerial perspective will have their computation skipped using early depth test.
        """
        ...
    @property
    def holdout(self) -> bool:
        r"""
        (bool):  [Read-Only] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
        """
        ...
    @property
    def render_in_main_pass(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will be rendered in the main pass (basepass, transparency)
        """
        ...
    def set_sky_luminance_factor(self, new_value: LinearColor) -> None:
        r"""
        x.set_sky_luminance_factor(new_value) -> None
        Set Sky Luminance Factor
        
        Args:
            new_value (LinearColor):
        """
        ...
    def set_render_in_main_pass(self, value: bool) -> None:
        r"""
        x.set_render_in_main_pass(value) -> None
        Set Render in Main Pass
        
        Args:
            value (bool):
        """
        ...
    def set_rayleigh_scattering_scale(self, new_value: float) -> None:
        r"""
        x.set_rayleigh_scattering_scale(new_value) -> None
        Set Rayleigh Scattering Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_rayleigh_scattering(self, new_value: LinearColor) -> None:
        r"""
        x.set_rayleigh_scattering(new_value) -> None
        Set Rayleigh Scattering
        
        Args:
            new_value (LinearColor):
        """
        ...
    def set_rayleigh_exponential_distribution(self, new_value: float) -> None:
        r"""
        x.set_rayleigh_exponential_distribution(new_value) -> None
        Set Rayleigh Exponential Distribution
        
        Args:
            new_value (float):
        """
        ...
    def set_other_absorption_scale(self, new_value: float) -> None:
        r"""
        x.set_other_absorption_scale(new_value) -> None
        Set Other Absorption Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_other_absorption(self, new_value: LinearColor) -> None:
        r"""
        x.set_other_absorption(new_value) -> None
        Set Other Absorption
        
        Args:
            new_value (LinearColor):
        """
        ...
    def set_multi_scattering_factor(self, new_value: float) -> None:
        r"""
        x.set_multi_scattering_factor(new_value) -> None
        Set Multi Scattering Factor
        
        Args:
            new_value (float):
        """
        ...
    def set_mie_scattering_scale(self, new_value: float) -> None:
        r"""
        x.set_mie_scattering_scale(new_value) -> None
        Set Mie Scattering Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_mie_scattering(self, new_value: LinearColor) -> None:
        r"""
        x.set_mie_scattering(new_value) -> None
        Set Mie Scattering
        
        Args:
            new_value (LinearColor):
        """
        ...
    def set_mie_exponential_distribution(self, new_value: float) -> None:
        r"""
        x.set_mie_exponential_distribution(new_value) -> None
        Set Mie Exponential Distribution
        
        Args:
            new_value (float):
        """
        ...
    def set_mie_anisotropy(self, new_value: float) -> None:
        r"""
        x.set_mie_anisotropy(new_value) -> None
        Set Mie Anisotropy
        
        Args:
            new_value (float):
        """
        ...
    def set_mie_absorption_scale(self, new_value: float) -> None:
        r"""
        x.set_mie_absorption_scale(new_value) -> None
        Set Mie Absorption Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_mie_absorption(self, new_value: LinearColor) -> None:
        r"""
        x.set_mie_absorption(new_value) -> None
        Set Mie Absorption
        
        Args:
            new_value (LinearColor):
        """
        ...
    def set_holdout(self, new_holdout: bool) -> None:
        r"""
        x.set_holdout(new_holdout) -> None
        Set Holdout
        
        Args:
            new_holdout (bool):
        """
        ...
    def set_height_fog_contribution(self, new_value: float) -> None:
        r"""
        x.set_height_fog_contribution(new_value) -> None
        Set Height Fog Contribution
        
        Args:
            new_value (float):
        """
        ...
    def set_ground_albedo(self, new_value: Color) -> None:
        r"""
        x.set_ground_albedo(new_value) -> None
        Set Ground Albedo
        
        Args:
            new_value (Color):
        """
        ...
    def set_bottom_radius(self, new_value: float) -> None:
        r"""
        x.set_bottom_radius(new_value) -> None
        Set Bottom Radius
        
        Args:
            new_value (float):
        """
        ...
    def set_atmosphere_height(self, new_value: float) -> None:
        r"""
        x.set_atmosphere_height(new_value) -> None
        Set Atmosphere Height
        
        Args:
            new_value (float):
        """
        ...
    def set_aerial_pespective_view_distance_scale(self, new_value: float) -> None:
        r"""
        x.set_aerial_pespective_view_distance_scale(new_value) -> None
        Set Aerial Pespective View Distance Scale
        
        Args:
            new_value (float):
        """
        ...
    def reset_atmosphere_light_direction_override(self, atmosphere_light_index: int) -> None:
        r"""
        x.reset_atmosphere_light_direction_override(atmosphere_light_index) -> None
        Reset Atmosphere Light Direction Override
        
        Args:
            atmosphere_light_index (int32):
        """
        ...
    def override_atmosphere_light_direction(self, atmosphere_light_index: int, light_direction: Vector) -> None:
        r"""
        x.override_atmosphere_light_direction(atmosphere_light_index, light_direction) -> None
        Override Atmosphere Light Direction
        
        Args:
            atmosphere_light_index (int32): 
            light_direction (Vector):
        """
        ...
    def is_atmosphere_light_direction_overriden(self, atmosphere_light_index: int) -> bool:
        r"""
        x.is_atmosphere_light_direction_overriden(atmosphere_light_index) -> bool
        Is Atmosphere Light Direction Overriden
        
        Args:
            atmosphere_light_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_overriden_atmosphere_light_direction(self, atmosphere_light_index: int) -> Vector:
        r"""
        x.get_overriden_atmosphere_light_direction(atmosphere_light_index) -> Vector
        Get Overriden Atmosphere Light Direction
        
        Args:
            atmosphere_light_index (int32): 
        
        Returns:
            Vector:
        """
        ...
    def get_atmosphere_transmitance_on_ground_at_planet_top(self, directional_light: DirectionalLightComponent) -> LinearColor:
        r"""
        x.get_atmosphere_transmitance_on_ground_at_planet_top(directional_light) -> LinearColor
        Get Atmosphere Transmitance on Ground at Planet Top
        
        Args:
            directional_light (DirectionalLightComponent): 
        
        Returns:
            LinearColor:
        """
        ...

class AtmosphericFogComponent(SkyAtmosphereComponent):
    r"""
    Used to create fogging effects such as clouds.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AtmosphericFogComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``aerial_perspective_start_depth`` (float):  [Read-Write] The distance (kilometers) at which we start evaluating the aerial perspective. Having the aerial perspective starts away from the camera can help with performance: pixels not affected by the aerial perspective will have their computation skipped using early depth test.
    - ``aerial_pespective_view_distance_scale`` (float):  [Read-Write] Makes the aerial perspective look thicker by scaling distances from view to surfaces (opaque and translucent).
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``atmosphere_height`` (float):  [Read-Write] The height of the atmosphere layer above the ground in kilometers.
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bottom_radius`` (float):  [Read-Write] The radius in kilometers from the center of the planet to the ground level.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``ground_albedo`` (Color):  [Read-Write] The ground albedo that will tint the atmosphere when the sun light will bounce on it. Only taken into account when MultiScattering>0.0.
    - ``height_fog_contribution`` (float):  [Read-Write] Scale the sky and atmosphere lights contribution to the height fog when SupportSkyAtmosphereAffectsHeightFog project setting is true.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mie_absorption`` (LinearColor):  [Read-Write] The Mie absorption coefficients resulting from particles in the air at an altitude of 0 kilometer. As it becomes higher, light will be absorbed more.
    - ``mie_absorption_scale`` (float):  [Read-Write] Mie absorption coefficient scale.
    - ``mie_anisotropy`` (float):  [Read-Write] A value of 0 mean light is uniformly scattered. A value closer to 1 means lights will scatter more forward, resulting in halos around light sources.
    - ``mie_exponential_distribution`` (float):  [Read-Write] The altitude in kilometer at which Mie effects are reduced to 40%.
    - ``mie_scattering`` (LinearColor):  [Read-Write] The Mie scattering coefficients resulting from particles in the air at an altitude of 0 kilometer. As it becomes higher, light will be scattered more.
    - ``mie_scattering_scale`` (float):  [Read-Write] Mie scattering coefficient scale.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_scattering_factor`` (float):  [Read-Write] Factor applied to multiple scattering only (after the sun light has bounced around in the atmosphere at least once).
      Multiple scattering is evaluated using a dual scattering approach.
      A value of 2 is recommended to better represent default atmosphere when r.SkyAtmosphere.MultiScatteringLUT.HighQuality=0.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``other_absorption`` (LinearColor):  [Read-Write] Absorption coefficients for another atmosphere layer. Density increase from 0 to 1 between 10 to 25km and decreases from 1 to 0 between 25 to 40km. The default values represents ozone molecules absorption in the Earth atmosphere.
    - ``other_absorption_scale`` (float):  [Read-Write] Absorption coefficients for another atmosphere layer. Density increase from 0 to 1 between 10 to 25km and decreases from 1 to 0 between 25 to 40km. This approximates ozone molecules distribution in the Earth atmosphere.
    - ``other_tent_distribution`` (TentDistribution):  [Read-Write] Represents the altitude based tent distribution of absorption particles in the atmosphere.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``rayleigh_exponential_distribution`` (float):  [Read-Write] The altitude in kilometer at which Rayleigh scattering effect is reduced to 40%.
    - ``rayleigh_scattering`` (LinearColor):  [Read-Write] The Rayleigh scattering coefficients resulting from molecules in the air at an altitude of 0 kilometer.
    - ``rayleigh_scattering_scale`` (float):  [Read-Write] Rayleigh scattering coefficient scale.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (basepass, transparency)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sky_luminance_factor`` (LinearColor):  [Read-Write] Scales the luminance of pixels representing the sky. This will impact the captured sky light.
    - ``trace_sample_count_scale`` (float):  [Read-Write] Scale the atmosphere tracing sample count. Quality level scalability
      The sample count is still clamped according to scalability setting to 'r.SkyAtmosphere.SampleCountMax' when 'r.SkyAtmosphere.FastSkyLUT' is 0.
      The sample count is still clamped according to scalability setting to 'r.SkyAtmosphere.FastSkyLUT.SampleCountMax' when 'r.SkyAtmosphere.FastSkyLUT' is 1.
      The sample count is still clamped for aerial perspective according to  'r.SkyAtmosphere.AerialPerspectiveLUT.SampleCountMaxPerSlice'.
    - ``transform_mode`` (SkyAtmosphereTransformMode):  [Read-Write] The ground albedo that will tint the atmosphere when the sun light will bounce on it. Only taken into account when MultiScattering>0.0.
    - ``transmittance_min_light_elevation_angle`` (float):  [Read-Write] The minimum elevation angle in degree that should be used to evaluate the sun transmittance to the ground. Useful to maintain a visible sun light and shadow on meshes even when the sun has started going below the horizon. This does not affect the aerial perspective.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    def set_sun_multiplier(self, new_sun_multiplier: float) -> None:
        r"""
        x.set_sun_multiplier(new_sun_multiplier) -> None
        Deprecated
        
        Args:
            new_sun_multiplier (float):
        """
        ...
    def set_start_distance(self, new_start_distance: float) -> None:
        r"""
        x.set_start_distance(new_start_distance) -> None
        Deprecated
        
        Args:
            new_start_distance (float):
        """
        ...
    def set_precompute_params(self, density_height: float, max_scattering_order: int, inscatter_altitude_sample_num: int) -> None:
        r"""
        x.set_precompute_params(density_height, max_scattering_order, inscatter_altitude_sample_num) -> None
        Deprecated
        
        Args:
            density_height (float): 
            max_scattering_order (int32): 
            inscatter_altitude_sample_num (int32):
        """
        ...
    def set_fog_multiplier(self, new_fog_multiplier: float) -> None:
        r"""
        x.set_fog_multiplier(new_fog_multiplier) -> None
        Deprecated
        
        Args:
            new_fog_multiplier (float):
        """
        ...
    def set_distance_scale(self, new_distance_scale: float) -> None:
        r"""
        x.set_distance_scale(new_distance_scale) -> None
        Deprecated
        
        Args:
            new_distance_scale (float):
        """
        ...
    def set_distance_offset(self, new_distance_offset: float) -> None:
        r"""
        x.set_distance_offset(new_distance_offset) -> None
        Deprecated
        
        Args:
            new_distance_offset (float):
        """
        ...
    def set_density_offset(self, new_density_offset: float) -> None:
        r"""
        x.set_density_offset(new_density_offset) -> None
        Deprecated
        
        Args:
            new_density_offset (float):
        """
        ...
    def set_density_multiplier(self, new_density_multiplier: float) -> None:
        r"""
        x.set_density_multiplier(new_density_multiplier) -> None
        Deprecated
        
        Args:
            new_density_multiplier (float):
        """
        ...
    def set_default_light_color(self, new_light_color: LinearColor) -> None:
        r"""
        x.set_default_light_color(new_light_color) -> None
        Deprecated
        
        Args:
            new_light_color (LinearColor):
        """
        ...
    def set_default_brightness(self, new_brightness: float) -> None:
        r"""
        x.set_default_brightness(new_brightness) -> None
        Deprecated
        
        Args:
            new_brightness (float):
        """
        ...
    def set_altitude_scale(self, new_altitude_scale: float) -> None:
        r"""
        x.set_altitude_scale(new_altitude_scale) -> None
        Deprecated
        
        Args:
            new_altitude_scale (float):
        """
        ...
    def disable_sun_disk(self, new_sun_disk: bool) -> None:
        r"""
        x.disable_sun_disk(new_sun_disk) -> None
        Deprecated
        
        Args:
            new_sun_disk (bool):
        """
        ...
    def disable_ground_scattering(self, new_ground_scattering: bool) -> None:
        r"""
        x.disable_ground_scattering(new_ground_scattering) -> None
        Deprecated
        
        Args:
            new_ground_scattering (bool):
        """
        ...

class AudioBus(Object):
    r"""
    An audio bus is an object which represents an audio patch cord. Audio can be sent to it. It can be sonified using USoundSourceBuses.
    Instances of the audio bus are created in the audio engine.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioBus.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio_bus_channels`` (AudioBusChannels):  [Read-Write] Number of channels to use for the Audio Bus.
    """
    ...

class AudioVolume(Volume):
    r"""
    Audio Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``ambient_zone_settings`` (InteriorSettings):  [Read-Write] Impacts sounds that have "Apply Ambient Volumes" set to true in their Sound Class, based on whether the sound sources and the player are inside or outside the audio volume
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enabled`` (bool):  [Read-Write] Whether this volume is currently enabled and able to affect sounds
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``priority`` (float):  [Read-Write] Priority of this volume. In the case of overlapping volumes, the one with the highest priority
      is chosen. The order is undefined if two or more overlapping volumes have the same priority.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``settings`` (ReverbSettings):  [Read-Write] Reverb settings to use for this volume.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``submix_override_settings`` (Array[AudioVolumeSubmixOverrideSettings]):  [Read-Write] Submix effect chain override settings. Will override the effect chains on the given submixes when the conditions are met.
    - ``submix_send_settings`` (Array[AudioVolumeSubmixSendSettings]):  [Read-Write] Submix send settings to use for this volume. Allows audio to dynamically send to submixes based on source and listener locations relative to this volume.
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def priority(self) -> float:
        r"""
        (float):  [Read-Only] Priority of this volume. In the case of overlapping volumes, the one with the highest priority
        is chosen. The order is undefined if two or more overlapping volumes have the same priority.
        """
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether this volume is currently enabled and able to affect sounds
        """
        ...
    @property
    def settings(self) -> ReverbSettings:
        r"""
        (ReverbSettings):  [Read-Only] Reverb settings to use for this volume.
        """
        ...
    @property
    def ambient_zone_settings(self) -> InteriorSettings:
        r"""
        (InteriorSettings):  [Read-Only] Impacts sounds that have "Apply Ambient Volumes" set to true in their Sound Class, based on whether the sound sources and the player are inside or outside the audio volume
        """
        ...
    @property
    def submix_send_settings(self) -> Array[AudioVolumeSubmixSendSettings]:
        r"""
        (Array[AudioVolumeSubmixSendSettings]):  [Read-Only] Submix send settings to use for this volume. Allows audio to dynamically send to submixes based on source and listener locations relative to this volume.
        """
        ...
    @property
    def submix_override_settings(self) -> Array[AudioVolumeSubmixOverrideSettings]:
        r"""
        (Array[AudioVolumeSubmixOverrideSettings]):  [Read-Only] Submix effect chain override settings. Will override the effect chains on the given submixes when the conditions are met.
        """
        ...
    def set_submix_send_settings(self, new_submix_send_settings: Array[AudioVolumeSubmixSendSettings]) -> None:
        r"""
        x.set_submix_send_settings(new_submix_send_settings) -> None
        Set Submix Send Settings
        
        Args:
            new_submix_send_settings (Array[AudioVolumeSubmixSendSettings]):
        """
        ...
    def set_submix_override_settings(self, new_submix_override_settings: Array[AudioVolumeSubmixOverrideSettings]) -> None:
        r"""
        x.set_submix_override_settings(new_submix_override_settings) -> None
        Set Submix Override Settings
        
        Args:
            new_submix_override_settings (Array[AudioVolumeSubmixOverrideSettings]):
        """
        ...
    def set_reverb_settings(self, new_reverb_settings: ReverbSettings) -> None:
        r"""
        x.set_reverb_settings(new_reverb_settings) -> None
        Set Reverb Settings
        
        Args:
            new_reverb_settings (ReverbSettings):
        """
        ...
    def set_priority(self, new_priority: float) -> None:
        r"""
        x.set_priority(new_priority) -> None
        Set Priority
        
        Args:
            new_priority (float):
        """
        ...
    def set_interior_settings(self, new_interior_settings: InteriorSettings) -> None:
        r"""
        x.set_interior_settings(new_interior_settings) -> None
        Set Interior Settings
        
        Args:
            new_interior_settings (InteriorSettings):
        """
        ...
    def set_enabled(self, new_enabled: bool) -> None:
        r"""
        x.set_enabled(new_enabled) -> None
        Set Enabled
        
        Args:
            new_enabled (bool):
        """
        ...

class ReverbVolume(AudioVolume):
    r"""
    deprecated: 'ReverbVolume' was renamed to 'AudioVolume'.
    """
    ...

class ReverbVolumeToggleable(AudioVolume):
    r"""
    deprecated: 'ReverbVolumeToggleable' was renamed to 'AudioVolume'.
    """
    ...

class ActorSoundParameterInterface(Interface):
    r"""
    Actor Sound Parameter Interface
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ActorSoundParameterInterface.h
    
    """
    def get_actor_sound_params(self) -> Array[AudioParameter]:
        r"""
        x.get_actor_sound_params() -> Array[AudioParameter]
        Overrides logic for gathering AudioParameters to set by default when an AudioComponent/ActiveSound plays with a given actor as its Owner.
        
        Returns:
            Array[AudioParameter]: 
        
            params (Array[AudioParameter]):
        """
        ...

class SoundParameterControllerInterface(AudioParameterControllerInterface):
    r"""
    Sound Parameter Controller Interface
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundParameterControllerInterface.h
    
    """
    ...

class AudioParameterConversionStatics(BlueprintFunctionLibrary):
    r"""
    Audio Parameter Conversion Statics
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundParameterControllerInterface.h
    
    """
    @classmethod
    def string_to_audio_parameter(cls, name: Name, string: str) -> AudioParameter:
        r"""
        X.string_to_audio_parameter(name, string) -> AudioParameter
        String to Audio Parameter
        
        Args:
            name (Name): 
            string (str): 
        
        Returns:
            AudioParameter:
        """
        ...
    @classmethod
    def string_array_to_audio_parameter(cls, name: Name, strings: Array[str]) -> AudioParameter:
        r"""
        X.string_array_to_audio_parameter(name, strings) -> AudioParameter
        String Array to Audio Parameter
        
        Args:
            name (Name): 
            strings (Array[str]): 
        
        Returns:
            AudioParameter:
        """
        ...
    @classmethod
    def object_to_audio_parameter(cls, name: Name, object: Object) -> AudioParameter:
        r"""
        X.object_to_audio_parameter(name, object) -> AudioParameter
        Object to Audio Parameter
        
        Args:
            name (Name): 
            object (Object): 
        
        Returns:
            AudioParameter:
        """
        ...
    @classmethod
    def object_array_to_audio_parameter(cls, name: Name, objects: Array[Object]) -> AudioParameter:
        r"""
        X.object_array_to_audio_parameter(name, objects) -> AudioParameter
        Object Array to Audio Parameter
        
        Args:
            name (Name): 
            objects (Array[Object]): 
        
        Returns:
            AudioParameter:
        """
        ...
    @classmethod
    def integer_to_audio_parameter(cls, name: Name, integer: int) -> AudioParameter:
        r"""
        X.integer_to_audio_parameter(name, integer) -> AudioParameter
        Integer to Audio Parameter
        
        Args:
            name (Name): 
            integer (int32): 
        
        Returns:
            AudioParameter:
        """
        ...
    @classmethod
    def integer_array_to_audio_parameter(cls, name: Name, integers: Array[int]) -> AudioParameter:
        r"""
        X.integer_array_to_audio_parameter(name, integers) -> AudioParameter
        Integer Array to Audio Parameter
        
        Args:
            name (Name): 
            integers (Array[int32]): 
        
        Returns:
            AudioParameter:
        """
        ...
    @classmethod
    def float_to_audio_parameter(cls, name: Name, float: float) -> AudioParameter:
        r"""
        X.float_to_audio_parameter(name, float) -> AudioParameter
        Float to Audio Parameter
        
        Args:
            name (Name): 
            float (float): 
        
        Returns:
            AudioParameter:
        """
        ...
    @classmethod
    def float_array_to_audio_parameter(cls, name: Name, floats: Array[float]) -> AudioParameter:
        r"""
        X.float_array_to_audio_parameter(name, floats) -> AudioParameter
        Float Array to Audio Parameter
        
        Args:
            name (Name): 
            floats (Array[float]): 
        
        Returns:
            AudioParameter:
        """
        ...
    @classmethod
    def boolean_to_audio_parameter(cls, name: Name, bool: bool) -> AudioParameter:
        r"""
        X.boolean_to_audio_parameter(name, bool) -> AudioParameter
        Boolean to Audio Parameter
        
        Args:
            name (Name): 
            bool (bool): 
        
        Returns:
            AudioParameter:
        """
        ...
    @classmethod
    def boolean_array_to_audio_parameter(cls, name: Name, bools: Array[bool]) -> AudioParameter:
        r"""
        X.boolean_array_to_audio_parameter(name, bools) -> AudioParameter
        Boolean Array to Audio Parameter
        
        Args:
            name (Name): 
            bools (Array[bool]): 
        
        Returns:
            AudioParameter:
        """
        ...

class BlockingVolume(Volume):
    r"""
    An invisible volume used to block other actors.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlockingVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class DynamicBlockingVolume(BlockingVolume):
    r"""
    deprecated: 'DynamicBlockingVolume' was renamed to 'BlockingVolume'.
    """
    ...

class BrushShape(Brush):
    r"""
    A brush that acts as a template for geometry mode modifiers like "Lathe".
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BrushShape.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class CameraBlockingVolume(Volume):
    r"""
    A volume which blocks the Camera channel by default.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraBlockingVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class CameraLensEffectInterface(Interface):
    r"""
    Camera Lens Effect Interface
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraLensEffectInterface.h
    
    """
    def get_primary_particle_component(self) -> FXSystemComponent:
        r"""
        x.get_primary_particle_component() -> FXSystemComponent
        Get Primary Particle Component
        
        Returns:
            FXSystemComponent:
        """
        ...
    def get_particle_components(self) -> Array[FXSystemComponent]:
        r"""
        x.get_particle_components() -> Array[FXSystemComponent]
        Get Particle Components
        
        Returns:
            Array[FXSystemComponent]:
        """
        ...

class CameraLensEffectInterfaceClassSupportLibrary(BlueprintFunctionLibrary):
    r"""
    Camera Lens Effect Interface Class Support Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraLensEffectInterface.h
    
    """
    @classmethod
    def set_interface_class(cls, class_: Class, var: CameraLensInterfaceClassSupport) -> Tuple[CameraLensInterfaceClassSupport, InterfaceValidResult]:
        r"""
        X.set_interface_class(class_, var) -> (var=CameraLensInterfaceClassSupport, result=InterfaceValidResult)
        Set the represented class of the passed in variable. Note: Check the tooltips on the individual pins.
        You cannot bypass the validation by connecting a wires to this node!!
        
        Args:
            class_ (type(Class)): MUST implement CameraLensEffectInterface - when connecting variables to the input, take care that the input class does in fact implement the interface.
            var (CameraLensInterfaceClassSupport): The wrapper (for validation purposes) of the lens effect class.
        
        Returns:
            tuple: 
        
            var (CameraLensInterfaceClassSupport): The wrapper (for validation purposes) of the lens effect class.
        
            result (InterfaceValidResult):
        """
        ...
    @classmethod
    def is_interface_valid(cls, camera_lens: CameraLensEffectInterface) -> InterfaceValidResult:
        r"""
        X.is_interface_valid(camera_lens) -> InterfaceValidResult
        Evaluate the live interface to see if it is a valid reference.
        
        Args:
            camera_lens (CameraLensEffectInterface): 
        
        Returns:
            InterfaceValidResult: 
        
            result (InterfaceValidResult):
        """
        ...
    @classmethod
    def is_interface_class_valid(cls, camera_lens: CameraLensInterfaceClassSupport) -> InterfaceValidResult:
        r"""
        X.is_interface_class_valid(camera_lens) -> InterfaceValidResult
        Check whether or not the interface class is valid
        
        Args:
            camera_lens (CameraLensInterfaceClassSupport): 
        
        Returns:
            InterfaceValidResult: 
        
            result (InterfaceValidResult):
        """
        ...
    @classmethod
    def get_interface_class(cls, camera_lens: CameraLensInterfaceClassSupport) -> Class:
        r"""
        X.get_interface_class(camera_lens) -> type(Class)
        Returns the class represented by this lens effect wrapper...
        
        Args:
            camera_lens (CameraLensInterfaceClassSupport): 
        
        Returns:
            type(Class):
        """
        ...

class CameraModifier(Object):
    r"""
    A CameraModifier is a base class for objects that may adjust the final camera properties after
    being computed by the APlayerCameraManager (
    see: ModifyCamera). A CameraModifier can be stateful, and is associated uniquely with a specific APlayerCameraManager.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current blend alpha.
    - ``alpha_in_time`` (float):  [Read-Write] When blending in, alpha proceeds from 0 to 1 over this time
    - ``alpha_out_time`` (float):  [Read-Write] When blending out, alpha proceeds from 1 to 0 over this time
    - ``camera_owner`` (PlayerCameraManager):  [Read-Write] Camera this object is associated with.
    - ``debug`` (bool):  [Read-Write] If true, enables certain debug visualization features.
    - ``exclusive`` (bool):  [Read-Write] If true, no other modifiers of same priority allowed.
    - ``priority`` (uint8):  [Read-Write] Priority value that determines the order in which modifiers are applied. 0 = highest priority, 255 = lowest.
    """
    @property
    def exclusive(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, no other modifiers of same priority allowed.
        """
        ...
    @property
    def priority(self) -> int:
        r"""
        (uint8):  [Read-Only] Priority value that determines the order in which modifiers are applied. 0 = highest priority, 255 = lowest.
        """
        ...
    @property
    def camera_owner(self) -> PlayerCameraManager:
        r"""
        (PlayerCameraManager):  [Read-Only] Camera this object is associated with.
        """
        ...
    @property
    def alpha_in_time(self) -> float:
        r"""
        (float):  [Read-Only] When blending in, alpha proceeds from 0 to 1 over this time
        """
        ...
    @property
    def alpha_out_time(self) -> float:
        r"""
        (float):  [Read-Only] When blending out, alpha proceeds from 1 to 0 over this time
        """
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Only] Current blend alpha.
        """
        ...
    def is_pending_disable(self) -> bool:
        r"""
        x.is_pending_disable() -> bool
        
        
        Returns:
            bool: Returns true if modifier is pending disable, false otherwise.
        """
        ...
    def is_disabled(self) -> bool:
        r"""
        x.is_disabled() -> bool
        
        
        Returns:
            bool: Returns true if modifier is disabled, false otherwise.
        """
        ...
    def get_view_target(self) -> Actor:
        r"""
        x.get_view_target() -> Actor
        
        
        Returns:
            Actor: Returns the actor the camera is currently viewing.
        """
        ...
    def enable_modifier(self) -> None:
        r"""
        x.enable_modifier() -> None
        Enables this modifier.
        """
        ...
    def disable_modifier(self, immediate: bool = False) -> None:
        r"""
        x.disable_modifier(immediate=False) -> None
        Disables this modifier.
        
        Args:
            immediate (bool): true to disable with no blend out, false (default) to allow blend out
        """
        ...
    def blueprint_modify_post_process(self, delta_time: float) -> Tuple[float, PostProcessSettings]:
        r"""
        x.blueprint_modify_post_process(delta_time) -> (post_process_blend_weight=float, post_process_settings=PostProcessSettings)
        Called per tick that the modifier is active to allow Blueprinted modifiers to modify the camera's postprocess effects.
        Scaling by Alpha happens after this in code, so no need to deal with that in the blueprint.
        
        Args:
            delta_time (float): Change in time since last update
        
        Returns:
            tuple: 
        
            post_process_blend_weight (float): (out) Blend weight applied to the entire postprocess structure.
        
            post_process_settings (PostProcessSettings): (out) Post process structure defining what settings and values to override.
        """
        ...
    def blueprint_modify_camera(self, delta_time: float, view_location: Vector, view_rotation: Rotator, fov: float) -> Tuple[Vector, Rotator, float]:
        r"""
        x.blueprint_modify_camera(delta_time, view_location, view_rotation, fov) -> (new_view_location=Vector, new_view_rotation=Rotator, new_fov=float)
        Called per tick that the modifier is active to allow Blueprinted modifiers to modify the camera's transform.
        Scaling by Alpha happens after this in code, so no need to deal with that in the blueprint.
        
        Args:
            delta_time (float): Change in time since last update
            view_location (Vector): The current camera location.
            view_rotation (Rotator): The current camera rotation.
            fov (float): The current camera fov.
        
        Returns:
            tuple: 
        
            new_view_location (Vector): (out) The modified camera location.
        
            new_view_rotation (Rotator): (out) The modified camera rotation.
        
            new_fov (float): (out) The modified camera FOV.
        """
        ...

class CameraModifier_CameraShake(CameraModifier):
    r"""
    A UCameraModifier_CameraShake is a camera modifier that can apply a UCameraShakeBase to
    the owning camera.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraModifier_CameraShake.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current blend alpha.
    - ``alpha_in_time`` (float):  [Read-Write] When blending in, alpha proceeds from 0 to 1 over this time
    - ``alpha_out_time`` (float):  [Read-Write] When blending out, alpha proceeds from 1 to 0 over this time
    - ``camera_owner`` (PlayerCameraManager):  [Read-Write] Camera this object is associated with.
    - ``debug`` (bool):  [Read-Write] If true, enables certain debug visualization features.
    - ``exclusive`` (bool):  [Read-Write] If true, no other modifiers of same priority allowed.
    - ``priority`` (uint8):  [Read-Write] Priority value that determines the order in which modifiers are applied. 0 = highest priority, 255 = lowest.
    - ``split_screen_shake_scale`` (float):  [Read-Write] Scaling factor applied to all camera shakes in when in splitscreen mode. Normally used to reduce shaking, since shakes feel more intense in a smaller viewport.
    """
    ...

class CameraShakeBase(Object):
    r"""
    Base class for a camera shake. A camera shake contains a root shake "pattern" which is
    the object that contains the actual logic driving how the camera is shaken. Keeping the two
    separate makes it possible to completely change how a shake works without having to create
    a completely different asset.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``root_shake_pattern`` (CameraShakePattern):  [Read-Write] The root pattern for this camera shake
    - ``shake_scale`` (float):  [Read-Write] The overall scale to apply to the shake. Only valid when the shake is active.
    - ``single_instance`` (bool):  [Read-Write] If true to only allow a single instance of this shake class to play at any given time.
      Subsequent attempts to play this shake will simply restart the timer.
    """
    @property
    def shake_scale(self) -> float:
        r"""
        (float):  [Read-Write] The overall scale to apply to the shake. Only valid when the shake is active.
        """
        ...
    @shake_scale.setter
    def shake_scale(self, value: float) -> None:
        ...
    def set_root_shake_pattern(self, pattern: CameraShakePattern) -> None:
        r"""
        x.set_root_shake_pattern(pattern) -> None
        Sets the root pattern of this camera shake
        
        Args:
            pattern (CameraShakePattern):
        """
        ...
    def get_root_shake_pattern(self) -> CameraShakePattern:
        r"""
        x.get_root_shake_pattern() -> CameraShakePattern
        Gets the root pattern of this camera shake
        
        Returns:
            CameraShakePattern:
        """
        ...

class CameraShakeSourceActor(Actor):
    r"""
    Camera Shake Source Actor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeSourceActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``camera_shake_source_component`` (CameraShakeSourceComponent):  [Read-Only]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def camera_shake_source_component(self) -> CameraShakeSourceComponent:
        r"""
        (CameraShakeSourceComponent):  [Read-Only]
        """
        ...

class CameraShakeSourceComponent(SceneComponent):
    r"""
    Camera Shake Source Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeSourceComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation`` (CameraShakeAttenuation):  [Read-Write] The attenuation profile for how camera shakes' intensity falls off with distance
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_start`` (bool):  [Read-Write] Whether to auto start when created
    - ``camera_shake`` (type(Class)):  [Read-Write] The camera shake class to use for this camera shake source actor
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``inner_attenuation_radius`` (float):  [Read-Write] Under this distance from the source, the camera shakes are at full intensity
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``outer_attenuation_radius`` (float):  [Read-Write] Outside of this distance from the source, the camera shakes don't apply at all
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def attenuation(self) -> CameraShakeAttenuation:
        r"""
        (CameraShakeAttenuation):  [Read-Write] The attenuation profile for how camera shakes' intensity falls off with distance
        """
        ...
    @attenuation.setter
    def attenuation(self, value: CameraShakeAttenuation) -> None:
        ...
    @property
    def inner_attenuation_radius(self) -> float:
        r"""
        (float):  [Read-Write] Under this distance from the source, the camera shakes are at full intensity
        """
        ...
    @inner_attenuation_radius.setter
    def inner_attenuation_radius(self, value: float) -> None:
        ...
    @property
    def outer_attenuation_radius(self) -> float:
        r"""
        (float):  [Read-Write] Outside of this distance from the source, the camera shakes don't apply at all
        """
        ...
    @outer_attenuation_radius.setter
    def outer_attenuation_radius(self, value: float) -> None:
        ...
    @property
    def camera_shake(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] The camera shake class to use for this camera shake source actor
        """
        ...
    @camera_shake.setter
    def camera_shake(self, value: Class) -> None:
        ...
    @property
    def auto_start(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to auto start when created
        """
        ...
    @auto_start.setter
    def auto_start(self, value: bool) -> None:
        ...
    @property
    def b_auto_play(self) -> bool:
        r"""
        deprecated: 'b_auto_play' was renamed to 'auto_start'.
        """
        ...
    @b_auto_play.setter
    def b_auto_play(self, value: bool) -> None:
        ...
    def stop_all_camera_shakes_of_type(self, camera_shake: Class, immediately: bool = True) -> None:
        r"""
        x.stop_all_camera_shakes_of_type(camera_shake, immediately=True) -> None
        Stops a camera shake originating from this source
        
        Args:
            camera_shake (type(Class)): 
            immediately (bool):
        """
        ...
    def stop_all_camera_shakes(self, immediately: bool = True) -> None:
        r"""
        x.stop_all_camera_shakes(immediately=True) -> None
        Stops all currently active camera shakes that are originating from this source from all player controllers
        
        Args:
            immediately (bool):
        """
        ...
    def start_camera_shake(self, camera_shake: Class, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        r"""
        x.start_camera_shake(camera_shake, scale=1.000000, play_space=CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot=[0.000000, 0.000000, 0.000000]) -> None
        Starts a new camera shake originating from this source, and apply it on all player controllers
        
        Args:
            camera_shake (type(Class)): 
            scale (float): 
            play_space (CameraShakePlaySpace): 
            user_play_space_rot (Rotator):
        """
        ...
    def play_camera_shake(self, camera_shake: Class, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        r"""
        deprecated: 'play_camera_shake' was renamed to 'start_camera_shake'.
        """
        ...
    def start(self) -> None:
        r"""
        x.start() -> None
        Start
        """
        ...
    def play(self) -> None:
        r"""
        deprecated: 'play' was renamed to 'start'.
        """
        ...
    def get_attenuation_factor(self, location: Vector) -> float:
        r"""
        x.get_attenuation_factor(location) -> float
        Computes an attenuation factor from this source
        
        Args:
            location (Vector): 
        
        Returns:
            float:
        """
        ...

class TextureRenderTarget(Texture):
    r"""
    Texture Render Target
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureRenderTarget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``target_gamma`` (float):  [Read-Write] Will override FTextureRenderTarget2DResource::GetDisplayGamma if > 0.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    @property
    def target_gamma(self) -> float:
        r"""
        (float):  [Read-Write] Will override FTextureRenderTarget2DResource::GetDisplayGamma if > 0.
        """
        ...
    @target_gamma.setter
    def target_gamma(self, value: float) -> None:
        ...

class TextureRenderTarget2D(TextureRenderTarget):
    r"""
    TextureRenderTarget2D
    
    2D render target texture resource. This can be used as a target
    for rendering as well as rendered as a regular 2D texture resource.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureRenderTarget2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``auto_generate_mips`` (bool):  [Read-Write] Whether to support Mip maps for this render target texture
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``clear_color`` (LinearColor):  [Read-Write] the color the texture is cleared to
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``gpu_shared_flag`` (bool):  [Read-Write] Whether to support GPU sharing of the underlying native texture resource.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``mips_address_u`` (TextureAddress):  [Read-Write] AutoGenerateMips sampler address mode for U channel. Defaults to clamp.
    - ``mips_address_v`` (TextureAddress):  [Read-Write] AutoGenerateMips sampler address mode for V channel. Defaults to clamp.
    - ``mips_sampler_filter`` (TextureFilter):  [Read-Write] Sampler filter type for AutoGenerateMips. Defaults to match texture filter.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``render_target_format`` (TextureRenderTargetFormat):  [Read-Write] Format of the texture render target.
      Data written to the render target will be quantized to this format, which can limit the range and precision.
      The largest format (RTF_RGBA32f) uses 16x more memory and bandwidth than the smallest (RTF_R8) and can greatly affect performance.
      Use the smallest format that has enough precision and range for what you are doing.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``size_x`` (int32):  [Read-Write] The width of the texture.
    - ``size_y`` (int32):  [Read-Write] The height of the texture.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``target_gamma`` (float):  [Read-Write] Will override FTextureRenderTarget2DResource::GetDisplayGamma if > 0.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    @property
    def size_x(self) -> int:
        r"""
        (int32):  [Read-Only] The width of the texture.
        """
        ...
    @property
    def size_y(self) -> int:
        r"""
        (int32):  [Read-Only] The height of the texture.
        """
        ...
    @property
    def clear_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] the color the texture is cleared to
        """
        ...
    @property
    def address_x(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
        """
        ...
    @address_x.setter
    def address_x(self, value: TextureAddress) -> None:
        ...
    @property
    def address_y(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
        """
        ...
    @address_y.setter
    def address_y(self, value: TextureAddress) -> None:
        ...
    @property
    def gpu_shared_flag(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to support GPU sharing of the underlying native texture resource.
        """
        ...
    @property
    def render_target_format(self) -> TextureRenderTargetFormat:
        r"""
        (TextureRenderTargetFormat):  [Read-Only] Format of the texture render target.
        Data written to the render target will be quantized to this format, which can limit the range and precision.
        The largest format (RTF_RGBA32f) uses 16x more memory and bandwidth than the smallest (RTF_R8) and can greatly affect performance.
        Use the smallest format that has enough precision and range for what you are doing.
        """
        ...
    @property
    def auto_generate_mips(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to support Mip maps for this render target texture
        """
        ...
    @property
    def mips_sampler_filter(self) -> TextureFilter:
        r"""
        (TextureFilter):  [Read-Only] Sampler filter type for AutoGenerateMips. Defaults to match texture filter.
        """
        ...
    @property
    def mips_address_u(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Only] AutoGenerateMips sampler address mode for U channel. Defaults to clamp.
        """
        ...
    @property
    def mips_address_v(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Only] AutoGenerateMips sampler address mode for V channel. Defaults to clamp.
        """
        ...

class CanvasRenderTarget2D(TextureRenderTarget2D):
    r"""
    CanvasRenderTarget2D is 2D render target which exposes a Canvas interface to allow you to draw elements onto
    it directly.  Use CreateCanvasRenderTarget2D() to create a render target texture by unique name, then
    bind a function to the OnCanvasRenderTargetUpdate delegate which will be called when the render target is
    updated.  If you need to repaint your canvas every single frame, simply call UpdateResource() on it from a Tick
    function.  Also, remember to hold onto your new canvas render target with a reference so that it doesn't get
    garbage collected.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CanvasRenderTarget2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``auto_generate_mips`` (bool):  [Read-Write] Whether to support Mip maps for this render target texture
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``clear_color`` (LinearColor):  [Read-Write] the color the texture is cleared to
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``gpu_shared_flag`` (bool):  [Read-Write] Whether to support GPU sharing of the underlying native texture resource.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``mips_address_u`` (TextureAddress):  [Read-Write] AutoGenerateMips sampler address mode for U channel. Defaults to clamp.
    - ``mips_address_v`` (TextureAddress):  [Read-Write] AutoGenerateMips sampler address mode for V channel. Defaults to clamp.
    - ``mips_sampler_filter`` (TextureFilter):  [Read-Write] Sampler filter type for AutoGenerateMips. Defaults to match texture filter.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``on_canvas_render_target_update`` (OnCanvasRenderTargetUpdate):  [Read-Write] Called when this Canvas Render Target is asked to update its texture resource.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``render_target_format`` (TextureRenderTargetFormat):  [Read-Write] Format of the texture render target.
      Data written to the render target will be quantized to this format, which can limit the range and precision.
      The largest format (RTF_RGBA32f) uses 16x more memory and bandwidth than the smallest (RTF_R8) and can greatly affect performance.
      Use the smallest format that has enough precision and range for what you are doing.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``sample_count`` (TextureRenderTargetSampleCount):  [Read-Write] MSAA sample count.
    - ``size_x`` (int32):  [Read-Write] The width of the texture.
    - ``size_y`` (int32):  [Read-Write] The height of the texture.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``target_gamma`` (float):  [Read-Write] Will override FTextureRenderTarget2DResource::GetDisplayGamma if > 0.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    @property
    def on_canvas_render_target_update(self) -> OnCanvasRenderTargetUpdate:
        r"""
        (OnCanvasRenderTargetUpdate):  [Read-Write] Called when this Canvas Render Target is asked to update its texture resource.
        """
        ...
    @on_canvas_render_target_update.setter
    def on_canvas_render_target_update(self, value: OnCanvasRenderTargetUpdate) -> None:
        ...
    @property
    def sample_count(self) -> TextureRenderTargetSampleCount:
        r"""
        (TextureRenderTargetSampleCount):  [Read-Write] MSAA sample count.
        """
        ...
    @sample_count.setter
    def sample_count(self, value: TextureRenderTargetSampleCount) -> None:
        ...
    def update_resource(self) -> None:
        r"""
        x.update_resource() -> None
        Updates the the canvas render target texture's resource. This is where the render target will create or
        find a canvas object to use.  It also calls UpdateResourceImmediate() to clear the render target texture
        from the deferred rendering list, to stop the texture from being cleared the next frame. From there it
        will ask the rendering thread to set up the RHI viewport. The canvas is then set up for rendering and
        then the user's update delegate is called.  The canvas is then flushed and the RHI resolves the
        texture to make it available for rendering.
        """
        ...
    def receive_update(self, canvas: Canvas, width: int, height: int) -> None:
        r"""
        x.receive_update(canvas, width, height) -> None
        Allows a Blueprint to implement how this Canvas Render Target 2D should be updated.
        
        Args:
            canvas (Canvas): Canvas object that can be used to paint to the render target
            width (int32): Width of the render target.
            height (int32): Height of the render target.
        """
        ...
    def get_size(self) -> Tuple[int, int]:
        r"""
        x.get_size() -> (width=int32, height=int32)
        Gets a specific render target's size from the global map of canvas render targets.
        
        Returns:
            tuple: 
        
            width (int32): Output variable for the render target's width
        
            height (int32): Output variable for the render target's height
        """
        ...
    @classmethod
    def create_canvas_render_target2d(cls, world_context_object: Object, canvas_render_target2d_class: Class, width: int = 1024, height: int = 1024) -> CanvasRenderTarget2D:
        r"""
        X.create_canvas_render_target2d(world_context_object, canvas_render_target2d_class, width=1024, height=1024) -> CanvasRenderTarget2D
        Creates a new canvas render target and initializes it to the specified dimensions
        
        Args:
            world_context_object (Object): The world where this render target will be rendered for
            canvas_render_target2d_class (type(Class)): Class of the render target.  Unless you want to use a special sub-class, you can simply pass UCanvasRenderTarget2D::StaticClass() here.
            width (int32): Width of the render target.
            height (int32): Height of the render target.
        
        Returns:
            CanvasRenderTarget2D: Returns the instanced render target.
        """
        ...

class PlayerController(Controller):
    r"""
    PlayerControllers are used by human players to control Pawns.
    
    ControlRotation (accessed via GetControlRotation()), determines the aiming
    orientation of the controlled Pawn.
    
    In networked games, PlayerControllers exist on the server for every player-controlled pawn,
    and also on the controlling client's machine. They do NOT exist on a client's
    machine for pawns controlled by remote players elsewhere on the network.
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Framework/Controller/PlayerController/
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerController.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_data_class`` (type(Class)):  [Read-Write] The type of async physics data object to use
      deprecated: AsyncPhysicsDataClass is deprecated. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``async_physics_data_component_deprecared`` (AsyncPhysicsInputComponent):  [Read-Write]
      deprecated: AsyncPhysicsDataComponent is deprecated. please see the new C++ NetworkPhysicsComponent
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``attach_to_pawn`` (bool):  [Read-Write] If true, the controller location will match the possessed Pawn's location. If false, it will not be updated. Rotation will match ControlRotation in either case.
      Since a Controller's location is normally inaccessible, this is intended mainly for purposes of being able to attach
      an Actor that follows the possessed Pawn location, but that still has the full aim rotation (since a Pawn might
      update only some components of the rotation).
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_manage_active_camera_target`` (bool):  [Read-Write] True to allow this player controller to manage the camera target for you,
      typically by using the possessed pawn as the camera target. Set to false
      if you want to manually control the camera target.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``cheat_class`` (type(Class)):  [Read-Write] Class of my CheatManager.
      see: CheatManager for more information about when it will be instantiated.
    - ``cheat_manager`` (CheatManager):  [Read-Write] Object that manages "cheat" commands.
      
      By default:
            - In Shipping configurations, the manager is always disabled because UE_WITH_CHEAT_MANAGER is 0
        - When playing in the editor, cheats are always enabled
        - In other cases, cheats are enabled by default in single player games but can be forced on with the EnableCheats console command
      
      This behavior can be changed either by overriding APlayerController::EnableCheats or AGameModeBase::AllowCheats.
    - ``click_event_keys`` (Array[Key]):  [Read-Write] List of keys that will cause click events to be forwarded, default to left click
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``current_click_trace_channel`` (CollisionChannel):  [Read-Write] Trace channel currently being used for determining what world object was clicked on.
    - ``current_mouse_cursor`` (MouseCursor):  [Read-Write] Currently visible mouse cursor
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_click_trace_channel`` (CollisionChannel):  [Read-Write] Default trace channel used for determining what world object was clicked on.
    - ``default_mouse_cursor`` (MouseCursor):  [Read-Write] Type of mouse cursor to show by default
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_click_events`` (bool):  [Read-Write] Whether actor/component click events should be generated.
    - ``enable_motion_controls`` (bool):  [Read-Write] Whether or not to consider input from motion sources (tilt, acceleration, etc)
    - ``enable_mouse_over_events`` (bool):  [Read-Write] Whether actor/component mouse over events should be generated.
    - ``enable_streaming_source`` (bool):  [Read-Write] Whether the PlayerController should be used as a World Partiton streaming source.
    - ``enable_touch_events`` (bool):  [Read-Write] Whether actor/component touch events should be generated.
    - ``enable_touch_over_events`` (bool):  [Read-Write] Whether actor/component touch over events should be generated.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``force_feedback_enabled`` (bool):  [Read-Write]
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hit_result_trace_distance`` (float):  [Read-Write] Distance to trace when computing click events
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_pitch_scale`` (float):  [Read-Write] Pitch input speed scaling
      deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``input_roll_scale`` (float):  [Read-Write] Roll input speed scaling
      deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``input_yaw_scale`` (float):  [Read-Write] Yaw input speed scaling
      deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_instigated_any_damage`` (InstigatedAnyDamageSignature):  [Read-Write] Called when the controller has instigated damage in any way
    - ``on_possessed_pawn_changed`` (OnPossessedPawnChanged):  [Read-Write] Called on both authorities and clients when the possessed pawn changes (either OldPawn or NewPawn might be nullptr)
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_player_input_class`` (type(Class)):  [Read-Write] If set, then this UPlayerInput class will be used instead of the Input Settings' DefaultPlayerInputClass
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_camera_manager`` (PlayerCameraManager):  [Read-Write] Camera manager associated with this Player Controller.
    - ``player_camera_manager_class`` (type(Class)):  [Read-Write] PlayerCamera class should be set for each game, otherwise Engine.PlayerCameraManager is used
    - ``player_is_waiting`` (bool):  [Read-Only] True if PlayerController is currently waiting for the match to start or to respawn. Only valid in Spectating state.
    - ``player_state`` (PlayerState):  [Read-Write] PlayerState containing replicated information about the player using this controller (only exists for players, not NPCs).
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``should_perform_full_tick_when_paused`` (bool):  [Read-Write] Whether we fully tick when the game is paused, if our tick function is allowed to do so. If false, we do a minimal update during the tick.
    - ``show_mouse_cursor`` (bool):  [Read-Write] Whether the mouse cursor should be displayed.
    - ``smooth_target_view_rotation_speed`` (float):  [Read-Write] Interp speed for blending remote view rotation for smoother client updates
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``streaming_source_debug_color`` (Color):  [Read-Write] Color used for debugging.
    - ``streaming_source_priority`` (StreamingSourcePriority):  [Read-Write] PlayerController streaming source priority.
    - ``streaming_source_shapes`` (Array[StreamingSourceShape]):  [Read-Write] Optional aggregated shape list used to build a custom shape for the streaming source. When empty, fallbacks sphere shape with a radius equal to grid's loading range.
    - ``streaming_source_should_activate`` (bool):  [Read-Write] Whether the PlayerController streaming source should activate cells after loading.
    - ``streaming_source_should_block_on_slow_streaming`` (bool):  [Read-Write] Whether the PlayerController streaming source should block on slow streaming.
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def player_camera_manager(self) -> PlayerCameraManager:
        r"""
        (PlayerCameraManager):  [Read-Only] Camera manager associated with this Player Controller.
        """
        ...
    @property
    def player_camera(self) -> PlayerCameraManager:
        r"""
        deprecated: 'player_camera' was renamed to 'player_camera_manager'.
        """
        ...
    @property
    def player_camera_manager_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] PlayerCamera class should be set for each game, otherwise Engine.PlayerCameraManager is used
        """
        ...
    @property
    def player_camera_class(self) -> Class:
        r"""
        deprecated: 'player_camera_class' was renamed to 'player_camera_manager_class'.
        """
        ...
    @property
    def smooth_target_view_rotation_speed(self) -> float:
        r"""
        (float):  [Read-Write] Interp speed for blending remote view rotation for smoother client updates
        """
        ...
    @smooth_target_view_rotation_speed.setter
    def smooth_target_view_rotation_speed(self, value: float) -> None:
        ...
    @property
    def cheat_manager(self) -> CheatManager:
        r"""
        (CheatManager):  [Read-Only] Object that manages "cheat" commands.
        
        By default:
              - In Shipping configurations, the manager is always disabled because UE_WITH_CHEAT_MANAGER is 0
          - When playing in the editor, cheats are always enabled
          - In other cases, cheats are enabled by default in single player games but can be forced on with the EnableCheats console command
        
        This behavior can be changed either by overriding APlayerController::EnableCheats or AGameModeBase::AllowCheats.
        """
        ...
    @property
    def cheat_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] Class of my CheatManager.
        see: CheatManager for more information about when it will be instantiated.
        """
        ...
    @property
    def async_physics_data_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] The type of async physics data object to use
        deprecated: AsyncPhysicsDataClass is deprecated. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
        """
        ...
    @async_physics_data_class.setter
    def async_physics_data_class(self, value: Class) -> None:
        ...
    @property
    def async_physics_data_component_deprecared(self) -> AsyncPhysicsInputComponent:
        r"""
        (AsyncPhysicsInputComponent):  [Read-Write]
        deprecated: AsyncPhysicsDataComponent is deprecated. please see the new C++ NetworkPhysicsComponent
        """
        ...
    @async_physics_data_component_deprecared.setter
    def async_physics_data_component_deprecared(self, value: AsyncPhysicsInputComponent) -> None:
        ...
    @property
    def player_is_waiting(self) -> bool:
        r"""
        (bool):  [Read-Only] True if PlayerController is currently waiting for the match to start or to respawn. Only valid in Spectating state.
        """
        ...
    @property
    def input_yaw_scale(self) -> float:
        r"""
        (float):  [Read-Write] Yaw input speed scaling
        deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
        """
        ...
    @input_yaw_scale.setter
    def input_yaw_scale(self, value: float) -> None:
        ...
    @property
    def look_right_scale(self) -> float:
        r"""
        deprecated: 'look_right_scale' was renamed to 'input_yaw_scale'.
        """
        ...
    @look_right_scale.setter
    def look_right_scale(self, value: float) -> None:
        ...
    @property
    def input_pitch_scale(self) -> float:
        r"""
        (float):  [Read-Write] Pitch input speed scaling
        deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
        """
        ...
    @input_pitch_scale.setter
    def input_pitch_scale(self, value: float) -> None:
        ...
    @property
    def look_up_scale(self) -> float:
        r"""
        deprecated: 'look_up_scale' was renamed to 'input_pitch_scale'.
        """
        ...
    @look_up_scale.setter
    def look_up_scale(self, value: float) -> None:
        ...
    @property
    def input_roll_scale(self) -> float:
        r"""
        (float):  [Read-Write] Roll input speed scaling
        deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
        """
        ...
    @input_roll_scale.setter
    def input_roll_scale(self, value: float) -> None:
        ...
    @property
    def show_mouse_cursor(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the mouse cursor should be displayed.
        """
        ...
    @show_mouse_cursor.setter
    def show_mouse_cursor(self, value: bool) -> None:
        ...
    @property
    def enable_click_events(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether actor/component click events should be generated.
        """
        ...
    @enable_click_events.setter
    def enable_click_events(self, value: bool) -> None:
        ...
    @property
    def enable_touch_events(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether actor/component touch events should be generated.
        """
        ...
    @enable_touch_events.setter
    def enable_touch_events(self, value: bool) -> None:
        ...
    @property
    def enable_mouse_over_events(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether actor/component mouse over events should be generated.
        """
        ...
    @enable_mouse_over_events.setter
    def enable_mouse_over_events(self, value: bool) -> None:
        ...
    @property
    def enable_touch_over_events(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether actor/component touch over events should be generated.
        """
        ...
    @enable_touch_over_events.setter
    def enable_touch_over_events(self, value: bool) -> None:
        ...
    @property
    def force_feedback_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @force_feedback_enabled.setter
    def force_feedback_enabled(self, value: bool) -> None:
        ...
    @property
    def enable_motion_controls(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to consider input from motion sources (tilt, acceleration, etc)
        """
        ...
    @enable_motion_controls.setter
    def enable_motion_controls(self, value: bool) -> None:
        ...
    @property
    def enable_streaming_source(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the PlayerController should be used as a World Partiton streaming source.
        """
        ...
    @enable_streaming_source.setter
    def enable_streaming_source(self, value: bool) -> None:
        ...
    @property
    def streaming_source_should_activate(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the PlayerController streaming source should activate cells after loading.
        """
        ...
    @streaming_source_should_activate.setter
    def streaming_source_should_activate(self, value: bool) -> None:
        ...
    @property
    def streaming_source_should_block_on_slow_streaming(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the PlayerController streaming source should block on slow streaming.
        """
        ...
    @streaming_source_should_block_on_slow_streaming.setter
    def streaming_source_should_block_on_slow_streaming(self, value: bool) -> None:
        ...
    @property
    def streaming_source_priority(self) -> StreamingSourcePriority:
        r"""
        (StreamingSourcePriority):  [Read-Write] PlayerController streaming source priority.
        """
        ...
    @streaming_source_priority.setter
    def streaming_source_priority(self, value: StreamingSourcePriority) -> None:
        ...
    @property
    def streaming_source_debug_color(self) -> Color:
        r"""
        (Color):  [Read-Write] Color used for debugging.
        """
        ...
    @streaming_source_debug_color.setter
    def streaming_source_debug_color(self, value: Color) -> None:
        ...
    @property
    def streaming_source_shapes(self) -> Array[StreamingSourceShape]:
        r"""
        (Array[StreamingSourceShape]):  [Read-Write] Optional aggregated shape list used to build a custom shape for the streaming source. When empty, fallbacks sphere shape with a radius equal to grid's loading range.
        """
        ...
    @streaming_source_shapes.setter
    def streaming_source_shapes(self, value: Array[StreamingSourceShape]) -> None:
        ...
    @property
    def click_event_keys(self) -> Array[Key]:
        r"""
        (Array[Key]):  [Read-Write] List of keys that will cause click events to be forwarded, default to left click
        """
        ...
    @click_event_keys.setter
    def click_event_keys(self, value: Array[Key]) -> None:
        ...
    @property
    def default_mouse_cursor(self) -> MouseCursor:
        r"""
        (MouseCursor):  [Read-Only] Type of mouse cursor to show by default
        """
        ...
    @property
    def current_mouse_cursor(self) -> MouseCursor:
        r"""
        (MouseCursor):  [Read-Write] Currently visible mouse cursor
        """
        ...
    @current_mouse_cursor.setter
    def current_mouse_cursor(self, value: MouseCursor) -> None:
        ...
    @property
    def default_click_trace_channel(self) -> CollisionChannel:
        r"""
        (CollisionChannel):  [Read-Only] Default trace channel used for determining what world object was clicked on.
        """
        ...
    @property
    def current_click_trace_channel(self) -> CollisionChannel:
        r"""
        (CollisionChannel):  [Read-Write] Trace channel currently being used for determining what world object was clicked on.
        """
        ...
    @current_click_trace_channel.setter
    def current_click_trace_channel(self, value: CollisionChannel) -> None:
        ...
    @property
    def hit_result_trace_distance(self) -> float:
        r"""
        (float):  [Read-Write] Distance to trace when computing click events
        """
        ...
    @hit_result_trace_distance.setter
    def hit_result_trace_distance(self, value: float) -> None:
        ...
    @property
    def should_perform_full_tick_when_paused(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we fully tick when the game is paused, if our tick function is allowed to do so. If false, we do a minimal update during the tick.
        """
        ...
    @should_perform_full_tick_when_paused.setter
    def should_perform_full_tick_when_paused(self, value: bool) -> None:
        ...
    def was_input_key_just_released(self, key: Key) -> bool:
        r"""
        x.was_input_key_just_released(key) -> bool
        Returns true if the given key/button was down last frame and up this frame.
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    def was_input_key_just_pressed(self, key: Key) -> bool:
        r"""
        x.was_input_key_just_pressed(key) -> bool
        Returns true if the given key/button was up last frame and down this frame.
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    def streaming_source_should_block_on_slow_streaming(self) -> bool:
        r"""
        x.streaming_source_should_block_on_slow_streaming() -> bool
        Whether the PlayerController streaming source should block on slow streaming.
        Default implementation returns bStreamingSourceShouldBlockOnSlowStreaming but can be overriden in child classes.
        
        Returns:
            bool: true if it should.
        """
        ...
    def streaming_source_should_activate(self) -> bool:
        r"""
        x.streaming_source_should_activate() -> bool
        Whether the PlayerController streaming source should activate cells after loading.
        Default implementation returns bStreamingSourceShouldActivate but can be overriden in child classes.
        
        Returns:
            bool: true if it should.
        """
        ...
    def stop_haptic_effect(self, hand: ControllerHand) -> None:
        r"""
        x.stop_haptic_effect(hand) -> None
        Stops a playing haptic feedback curve
        
        Args:
            hand (ControllerHand): Which hand to stop the effect for
        """
        ...
    def set_virtual_joystick_visibility(self, visible: bool) -> None:
        r"""
        x.set_virtual_joystick_visibility(visible) -> None
        Set the virtual joystick visibility.
        
        Args:
            visible (bool):
        """
        ...
    def set_view_target_with_blend(self, new_view_target: Actor, blend_time: float = 0.000000, blend_func: ViewTargetBlendFunction = ViewTargetBlendFunction.VT_BLEND_LINEAR, blend_exp: float = 0.000000, lock_outgoing: bool = False) -> None:
        r"""
        x.set_view_target_with_blend(new_view_target, blend_time=0.000000, blend_func=ViewTargetBlendFunction.VT_BLEND_LINEAR, blend_exp=0.000000, lock_outgoing=False) -> None
        Set the view target blending with variable control
        
        Args:
            new_view_target (Actor): new actor to set as view target
            blend_time (float): time taken to blend
            blend_func (ViewTargetBlendFunction): Cubic, Linear etc functions for blending
            blend_exp (float): Exponent, used by certain blend functions to control the shape of the curve.
            lock_outgoing (bool): If true, lock outgoing viewtarget to last frame's camera position for the remainder of the blend.
        """
        ...
    def set_mouse_location(self, x: int, y: int) -> None:
        r"""
        x.set_mouse_location(x, y) -> None
        Positions the mouse cursor in screen space, in pixels.
        
        Args:
            x (int32): 
            y (int32):
        """
        ...
    def set_mouse_cursor_widget(self, cursor: MouseCursor, cursor_widget: UserWidget) -> None:
        r"""
        x.set_mouse_cursor_widget(cursor, cursor_widget) -> None
        Sets the Widget for the Mouse Cursor to display
        
        Args:
            cursor (MouseCursor): the cursor to set the widget for
            cursor_widget (UserWidget): the widget to set the cursor to
        """
        ...
    def set_haptics_by_value(self, frequency: float, amplitude: float, hand: ControllerHand) -> None:
        r"""
        x.set_haptics_by_value(frequency, amplitude, hand) -> None
        Sets the value of the haptics for the specified hand directly, using frequency and amplitude.  NOTE:  If a curve is already
        playing for this hand, it will be cancelled in favour of the specified values.
        
        Args:
            frequency (float): The normalized frequency [0.0, 1.0] to play through the haptics system
            amplitude (float): The normalized amplitude [0.0, 1.0] to set the haptic feedback to
            hand (ControllerHand): Which hand to play the effect on
        """
        ...
    def set_disable_haptics(self, new_disabled: bool) -> None:
        r"""
        x.set_disable_haptics(new_disabled) -> None
        Allows the player controller to disable all haptic requests from being fired, e.g. in the case of a level loading
        
        Args:
            new_disabled (bool): If TRUE, the haptics will stop and prevented from being enabled again until set to FALSE
        """
        ...
    def set_deprecated_input_yaw_scale(self, new_value: float) -> None:
        r"""
        x.set_deprecated_input_yaw_scale(new_value) -> None
        Set Deprecated Input Yaw Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_deprecated_input_roll_scale(self, new_value: float) -> None:
        r"""
        x.set_deprecated_input_roll_scale(new_value) -> None
        Set Deprecated Input Roll Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_deprecated_input_pitch_scale(self, new_value: float) -> None:
        r"""
        x.set_deprecated_input_pitch_scale(new_value) -> None
        Set Deprecated Input Pitch Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_controller_light_color(self, color: Color) -> None:
        r"""
        x.set_controller_light_color(color) -> None
        Sets the light color of the player's controller
        
        Args:
            color (Color): The color for the light to be
        """
        ...
    def set_cinematic_mode(self, cinematic_mode: bool, hide_player: bool = True, affects_hud: bool = True, affects_movement: bool = ..., affects_turning: bool = ...) -> None:
        r"""
        x.set_cinematic_mode(cinematic_mode, hide_player=True, affects_hud=True, affects_movement, affects_turning) -> None
        Server/SP only function for changing whether the player is in cinematic mode.  Updates values of various state variables, then replicates the call to the client
        to sync the current cinematic mode.
        
        Args:
            cinematic_mode (bool): specify true if the player is entering cinematic mode; false if the player is leaving cinematic mode.
            hide_player (bool): specify true to hide the player's pawn (only relevant if bInCinematicMode is true)
            affects_hud (bool): specify true if we should show/hide the HUD to match the value of bCinematicMode
            affects_movement (bool): specify true to disable movement in cinematic mode, enable it when leaving
            affects_turning (bool): specify true to disable turning in cinematic mode or enable it when leaving
        """
        ...
    def set_audio_listener_override(self, attach_to_component: SceneComponent, location: Vector, rotation: Rotator) -> None:
        r"""
        x.set_audio_listener_override(attach_to_component, location, rotation) -> None
        Used to override the default positioning of the audio listener
        
        Args:
            attach_to_component (SceneComponent): Optional component to attach the audio listener to
            location (Vector): Depending on whether Component is attached this is either an offset from its location or an absolute position
            rotation (Rotator): Depending on whether Component is attached this is either an offset from its rotation or an absolute rotation
        """
        ...
    def set_audio_listener_attenuation_override(self, attach_to_component: SceneComponent, attenuation_location_o_verride: Vector) -> None:
        r"""
        x.set_audio_listener_attenuation_override(attach_to_component, attenuation_location_o_verride) -> None
        Set Audio Listener Attenuation Override
        
        Args:
            attach_to_component (SceneComponent): 
            attenuation_location_o_verride (Vector):
        """
        ...
    def reset_controller_light_color(self) -> None:
        r"""
        x.reset_controller_light_color() -> None
        Resets the light color of the player's controller to default
        """
        ...
    def project_world_location_to_screen(self, world_location: Vector, player_viewport_relative: bool = False) -> Optional[Vector2D]:
        r"""
        x.project_world_location_to_screen(world_location, player_viewport_relative=False) -> Vector2D or None
        Convert a World Space 3D position into a 2D Screen Space position.
        
        Args:
            world_location (Vector): 
            player_viewport_relative (bool): 
        
        Returns:
            Vector2D or None: true if the world coordinate was successfully projected to the screen.
        
            screen_location (Vector2D):
        """
        ...
    def play_haptic_effect(self, haptic_effect: HapticFeedbackEffect_Base, hand: ControllerHand, scale: float = 1.000000, loop: bool = False) -> None:
        r"""
        x.play_haptic_effect(haptic_effect, hand, scale=1.000000, loop=False) -> None
        Play a haptic feedback curve on the player's controller
        
        Args:
            haptic_effect (HapticFeedbackEffect_Base): The haptic effect to play
            hand (ControllerHand): Which hand to play the effect on
            scale (float): Scale between 0.0 and 1.0 on the intensity of playback
            loop (bool):
        """
        ...
    def play_dynamic_force_feedback(self, intensity: float, duration: float = -1.000000, affects_left_large: bool = True, affects_left_small: bool = True, affects_right_large: bool = True, affects_right_small: bool = True, action: DynamicForceFeedbackAction = ..., latent_info: LatentActionInfo = ...) -> None:
        r"""
        x.play_dynamic_force_feedback(intensity, duration=-1.000000, affects_left_large=True, affects_left_small=True, affects_right_large=True, affects_right_small=True, action, latent_info) -> None
        Latent action that controls the playing of force feedback
        Begins playing when Start is called.  Calling Update or Stop if the feedback is not active will have no effect.
        Completed will execute when Stop is called or the duration ends.
        When Update is called the Intensity, Duration, and affect values will be updated with the current inputs
        
        Args:
            intensity (float): How strong the feedback should be.  Valid values are between 0.0 and 1.0
            duration (float): How long the feedback should play for.  If the value is negative it will play until stopped
            affects_left_large (bool): Whether the intensity should be applied to the large left servo
            affects_left_small (bool): Whether the intensity should be applied to the small left servo
            affects_right_large (bool): Whether the intensity should be applied to the large right servo
            affects_right_small (bool): Whether the intensity should be applied to the small right servo
            action (DynamicForceFeedbackAction): 
            latent_info (LatentActionInfo):
        """
        ...
    def k2_client_play_force_feedback(self, force_feedback_effect: ForceFeedbackEffect, tag: Name, looping: bool, ignore_time_dilation: bool, play_while_paused: bool) -> None:
        r"""
        x.k2_client_play_force_feedback(force_feedback_effect, tag, looping, ignore_time_dilation, play_while_paused) -> None
        Play a force feedback pattern on the player's controller
        
        Args:
            force_feedback_effect (ForceFeedbackEffect): The force feedback pattern to play
            tag (Name): A tag that allows stopping of an effect.  If another effect with this Tag is playing, it will be stopped and replaced
            looping (bool): Whether the pattern should be played repeatedly or be a single one shot
            ignore_time_dilation (bool): Whether the pattern should ignore time dilation
            play_while_paused (bool): Whether the pattern should continue to play while the game is paused
        """
        ...
    def client_play_force_feedback(self, force_feedback_effect: ForceFeedbackEffect, tag: Name, looping: bool, ignore_time_dilation: bool, play_while_paused: bool) -> None:
        r"""
        deprecated: 'client_play_force_feedback' was renamed to 'k2_client_play_force_feedback'.
        """
        ...
    def is_streaming_source_enabled(self) -> bool:
        r"""
        x.is_streaming_source_enabled() -> bool
        Whether the PlayerController should be used as a World Partiton streaming source.
        Default implementation returns bEnableStreamingSource but can be overriden in child classes.
        
        Returns:
            bool: true if it should.
        """
        ...
    def is_input_key_down(self, key: Key) -> bool:
        r"""
        x.is_input_key_down(key) -> bool
        Returns true if the given key/button is pressed on the input of the controller (if present)
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    def get_viewport_size(self) -> Tuple[int, int]:
        r"""
        x.get_viewport_size() -> (size_x=int32, size_y=int32)
        Helper to get the size of the HUD canvas for this player controller.  Returns 0 if there is no HUD
        
        Returns:
            tuple: 
        
            size_x (int32): 
        
            size_y (int32):
        """
        ...
    def get_streaming_source_shapes(self) -> Array[StreamingSourceShape]:
        r"""
        x.get_streaming_source_shapes() -> Array[StreamingSourceShape]
        Gets the streaming source priority.
        Default implementation returns StreamingSourceShapes but can be overriden in child classes.
        
        Returns:
            Array[StreamingSourceShape]: 
        
            out_shapes (Array[StreamingSourceShape]):
        """
        ...
    def get_streaming_source_priority(self) -> StreamingSourcePriority:
        r"""
        x.get_streaming_source_priority() -> StreamingSourcePriority
        Gets the streaming source priority.
        Default implementation returns StreamingSourcePriority but can be overriden in child classes.
        
        Returns:
            StreamingSourcePriority: the streaming source priority.
        """
        ...
    def get_streaming_source_location_and_rotation(self) -> Tuple[Vector, Rotator]:
        r"""
        x.get_streaming_source_location_and_rotation() -> (out_location=Vector, out_rotation=Rotator)
        Gets the streaming source location and rotation.
        Default implementation returns APlayerController::GetPlayerViewPoint but can be overriden in child classes.
        
        Returns:
            tuple: 
        
            out_location (Vector): 
        
            out_rotation (Rotator):
        """
        ...
    def get_spectator_pawn(self) -> SpectatorPawn:
        r"""
        x.get_spectator_pawn() -> SpectatorPawn
        Get the Pawn used when spectating. nullptr when not spectating.
        
        Returns:
            SpectatorPawn:
        """
        ...
    def get_platform_user_id(self) -> PlatformUserId:
        r"""
        x.get_platform_user_id() -> PlatformUserId
        Returns the platform user that is assigned to this Player Controller's Local Player.
        If there is no local player, then this will return PLATFORMUSERID_NONE
        
        Returns:
            PlatformUserId:
        """
        ...
    def get_override_player_input_class(self) -> Class:
        r"""
        x.get_override_player_input_class() -> type(Class)
        Get Override Player Input Class
        
        Returns:
            type(Class):
        """
        ...
    def get_mouse_position(self) -> Optional[Tuple[float, float]]:
        r"""
        x.get_mouse_position() -> (location_x=float, location_y=float) or None
        Retrieves the X and Y screen coordinates of the mouse cursor. Returns false if there is no associated mouse device
        
        Returns:
            tuple or None: 
        
            location_x (float): 
        
            location_y (float):
        """
        ...
    def get_input_vector_key_state(self, key: Key) -> Vector:
        r"""
        x.get_input_vector_key_state(key) -> Vector
        Returns the vector value for the given key/button.
        
        Args:
            key (Key): 
        
        Returns:
            Vector:
        """
        ...
    def get_input_touch_state(self, finger_index: TouchIndex) -> Tuple[float, float, bool]:
        r"""
        x.get_input_touch_state(finger_index) -> (location_x=float, location_y=float, is_currently_pressed=bool)
        Retrieves the X and Y screen coordinates of the specified touch key. Returns false if the touch index is not down
        
        Args:
            finger_index (TouchIndex): 
        
        Returns:
            tuple: 
        
            location_x (float): 
        
            location_y (float): 
        
            is_currently_pressed (bool):
        """
        ...
    def get_input_mouse_delta(self) -> Tuple[float, float]:
        r"""
        x.get_input_mouse_delta() -> (delta_x=float, delta_y=float)
        Retrieves how far the mouse moved this frame.
        
        Returns:
            tuple: 
        
            delta_x (float): 
        
            delta_y (float):
        """
        ...
    def get_input_motion_state(self) -> Tuple[Vector, Vector, Vector, Vector]:
        r"""
        x.get_input_motion_state() -> (tilt=Vector, rotation_rate=Vector, gravity=Vector, acceleration=Vector)
        Retrieves the current motion state of the player's input device
        
        Returns:
            tuple: 
        
            tilt (Vector): 
        
            rotation_rate (Vector): 
        
            gravity (Vector): 
        
            acceleration (Vector):
        """
        ...
    def get_input_key_time_down(self, key: Key) -> float:
        r"""
        x.get_input_key_time_down(key) -> float
        Returns how long the given key/button has been down.  Returns 0 if it's up or it just went down this frame.
        
        Args:
            key (Key): 
        
        Returns:
            float:
        """
        ...
    def get_input_analog_stick_state(self, which_stick: ControllerAnalogStick) -> Tuple[float, float]:
        r"""
        x.get_input_analog_stick_state(which_stick) -> (stick_x=float, stick_y=float)
        Retrieves the X and Y displacement of the given analog stick.
        
        Args:
            which_stick (ControllerAnalogStick): 
        
        Returns:
            tuple: 
        
            stick_x (float): 
        
            stick_y (float):
        """
        ...
    def get_input_analog_key_state(self, key: Key) -> float:
        r"""
        x.get_input_analog_key_state(key) -> float
        Returns the analog value for the given key/button.  If analog isn't supported, returns 1 for down and 0 for up.
        
        Args:
            key (Key): 
        
        Returns:
            float:
        """
        ...
    def get_hud(self) -> HUD:
        r"""
        x.get_hud() -> HUD
        Gets the HUD currently being used by this player controller
        
        Returns:
            HUD:
        """
        ...
    def get_hit_result_under_finger_for_objects(self, finger_index: TouchIndex, object_types: Array[ObjectTypeQuery], trace_complex: bool = True) -> Optional[HitResult]:
        r"""
        x.get_hit_result_under_finger_for_objects(finger_index, object_types, trace_complex=True) -> HitResult or None
        Performs a collision query under the finger, looking for object types
        
        Args:
            finger_index (TouchIndex): 
            object_types (Array[ObjectTypeQuery]): 
            trace_complex (bool): 
        
        Returns:
            HitResult or None: 
        
            hit_result (HitResult):
        """
        ...
    def get_hit_result_under_finger_by_channel(self, finger_index: TouchIndex, trace_channel: TraceTypeQuery, trace_complex: bool = True) -> Optional[HitResult]:
        r"""
        x.get_hit_result_under_finger_by_channel(finger_index, trace_channel, trace_complex=True) -> HitResult or None
        Performs a collision query under the finger, looking on a trace channel
        
        Args:
            finger_index (TouchIndex): 
            trace_channel (TraceTypeQuery): 
            trace_complex (bool): 
        
        Returns:
            HitResult or None: 
        
            hit_result (HitResult):
        """
        ...
    def get_hit_result_under_finger(self, finger_index: TouchIndex, trace_channel: CollisionChannel = CollisionChannel.ECC_VISIBILITY, trace_complex: bool = True) -> Optional[HitResult]:
        r"""
        x.get_hit_result_under_finger(finger_index, trace_channel=CollisionChannel.ECC_VISIBILITY, trace_complex=True) -> HitResult or None
        Get Hit Result Under Finger
        deprecated: Use new GetHitResultUnderFingerByChannel or GetHitResultUnderFingerForObject
        
        Args:
            finger_index (TouchIndex): 
            trace_channel (CollisionChannel): 
            trace_complex (bool): 
        
        Returns:
            HitResult or None: 
        
            hit_result (HitResult):
        """
        ...
    def get_hit_result_under_cursor_for_objects(self, object_types: Array[ObjectTypeQuery], trace_complex: bool = True) -> Optional[HitResult]:
        r"""
        x.get_hit_result_under_cursor_for_objects(object_types, trace_complex=True) -> HitResult or None
        Performs a collision query under the mouse cursor, looking for object types
        
        Args:
            object_types (Array[ObjectTypeQuery]): 
            trace_complex (bool): 
        
        Returns:
            HitResult or None: 
        
            hit_result (HitResult):
        """
        ...
    def get_hit_result_under_cursor_by_channel(self, trace_channel: TraceTypeQuery, trace_complex: bool = True) -> Optional[HitResult]:
        r"""
        x.get_hit_result_under_cursor_by_channel(trace_channel, trace_complex=True) -> HitResult or None
        Performs a collision query under the mouse cursor, looking on a trace channel
        
        Args:
            trace_channel (TraceTypeQuery): 
            trace_complex (bool): 
        
        Returns:
            HitResult or None: 
        
            hit_result (HitResult):
        """
        ...
    def get_hit_result_under_cursor(self, trace_channel: CollisionChannel = CollisionChannel.ECC_VISIBILITY, trace_complex: bool = True) -> Optional[HitResult]:
        r"""
        x.get_hit_result_under_cursor(trace_channel=CollisionChannel.ECC_VISIBILITY, trace_complex=True) -> HitResult or None
        Get Hit Result Under Cursor
        deprecated: Use new GetHitResultUnderCursorByChannel or GetHitResultUnderCursorForObject
        
        Args:
            trace_channel (CollisionChannel): 
            trace_complex (bool): 
        
        Returns:
            HitResult or None: 
        
            hit_result (HitResult):
        """
        ...
    def get_focal_location(self) -> Vector:
        r"""
        x.get_focal_location() -> Vector
        Returns the location the PlayerController is focused on.
         If there is a possessed Pawn, returns the Pawn's location.
         If there is a spectator Pawn, returns that Pawn's location.
         Otherwise, returns the PlayerController's spawn location (usually the last known Pawn location after it has died).
        
        Returns:
            Vector:
        """
        ...
    def get_deprecated_input_yaw_scale(self) -> float:
        r"""
        x.get_deprecated_input_yaw_scale() -> float
        Get Deprecated Input Yaw Scale
        
        Returns:
            float:
        """
        ...
    def get_deprecated_input_roll_scale(self) -> float:
        r"""
        x.get_deprecated_input_roll_scale() -> float
        Get Deprecated Input Roll Scale
        
        Returns:
            float:
        """
        ...
    def get_deprecated_input_pitch_scale(self) -> float:
        r"""
        x.get_deprecated_input_pitch_scale() -> float
        Get Deprecated Input Pitch Scale
        
        Returns:
            float:
        """
        ...
    def get_async_physics_data_to_write(self) -> AsyncPhysicsData:
        r"""
        x.get_async_physics_data_to_write() -> AsyncPhysicsData
        Get Async Physics Data to Write
        
        Returns:
            AsyncPhysicsData:
        """
        ...
    def get_async_physics_data_to_consume(self) -> AsyncPhysicsData:
        r"""
        x.get_async_physics_data_to_consume() -> AsyncPhysicsData
        Get Async Physics Data to Consume
        
        Returns:
            AsyncPhysicsData:
        """
        ...
    def deproject_screen_position_to_world(self, screen_x: float, screen_y: float) -> Optional[Tuple[Vector, Vector]]:
        r"""
        x.deproject_screen_position_to_world(screen_x, screen_y) -> (world_location=Vector, world_direction=Vector) or None
        Convert 2D screen position to World Space 3D position and direction. Returns false if unable to determine value. *
        
        Args:
            screen_x (float): 
            screen_y (float): 
        
        Returns:
            tuple or None: 
        
            world_location (Vector): 
        
            world_direction (Vector):
        """
        ...
    def deproject_mouse_position_to_world(self) -> Optional[Tuple[Vector, Vector]]:
        r"""
        x.deproject_mouse_position_to_world() -> (world_location=Vector, world_direction=Vector) or None
        Convert current mouse 2D position to World Space 3D position and direction. Returns false if unable to determine value. *
        
        Returns:
            tuple or None: 
        
            world_location (Vector): 
        
            world_direction (Vector):
        """
        ...
    def client_stop_force_feedback(self, force_feedback_effect: ForceFeedbackEffect, tag: Name) -> None:
        r"""
        x.client_stop_force_feedback(force_feedback_effect, tag) -> None
        Stops a playing force feedback pattern
        
        Args:
            force_feedback_effect (ForceFeedbackEffect): If set only patterns from that effect will be stopped
            tag (Name): If not none only the pattern with this tag will be stopped
        """
        ...
    def client_stop_camera_shakes_from_source(self, source_component: CameraShakeSourceComponent, immediately: bool = True) -> None:
        r"""
        x.client_stop_camera_shakes_from_source(source_component, immediately=True) -> None
        Stop camera shake on client.
        
        Args:
            source_component (CameraShakeSourceComponent): 
            immediately (bool):
        """
        ...
    def client_stop_camera_shake(self, shake: Class, immediately: bool = True) -> None:
        r"""
        x.client_stop_camera_shake(shake, immediately=True) -> None
        Stop camera shake on client.
        
        Args:
            shake (type(Class)): 
            immediately (bool):
        """
        ...
    def client_start_camera_shake_from_source(self, shake: Class, source_component: CameraShakeSourceComponent) -> None:
        r"""
        x.client_start_camera_shake_from_source(shake, source_component) -> None
        Play Camera Shake localized to a given source
        
        Args:
            shake (type(Class)): Camera shake animation to play
            source_component (CameraShakeSourceComponent): The source from which the camera shakes originates
        """
        ...
    def client_play_camera_shake_from_source(self, shake: Class, source_component: CameraShakeSourceComponent) -> None:
        r"""
        deprecated: 'client_play_camera_shake_from_source' was renamed to 'client_start_camera_shake_from_source'.
        """
        ...
    def client_start_camera_shake(self, shake: Class, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        r"""
        x.client_start_camera_shake(shake, scale=1.000000, play_space=CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot=[0.000000, 0.000000, 0.000000]) -> None
        Play Camera Shake
        
        Args:
            shake (type(Class)): Camera shake animation to play
            scale (float): Scalar defining how "intense" to play the anim
            play_space (CameraShakePlaySpace): Which coordinate system to play the shake in (used for CameraAnims within the shake).
            user_play_space_rot (Rotator): Matrix used when PlaySpace = CAPS_UserDefined
        """
        ...
    def client_play_camera_shake(self, shake: Class, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> None:
        r"""
        deprecated: 'client_play_camera_shake' was renamed to 'client_start_camera_shake'.
        """
        ...
    def client_spawn_generic_camera_lens_effect(self, lens_effect_emitter_class: Class) -> None:
        r"""
        x.client_spawn_generic_camera_lens_effect(lens_effect_emitter_class) -> None
        Spawn a camera lens effect (e.g. blood).
        
        Args:
            lens_effect_emitter_class (type(Class)):
        """
        ...
    def client_set_hud(self, new_hud_class: Class) -> None:
        r"""
        x.client_set_hud(new_hud_class) -> None
        Set the client's class of HUD and spawns a new instance of it. If there was already a HUD active, it is destroyed.
        
        Args:
            new_hud_class (type(Class)):
        """
        ...
    def client_clear_camera_lens_effects(self) -> None:
        r"""
        x.client_clear_camera_lens_effects() -> None
        Removes all Camera Lens Effects.
        """
        ...
    def clear_audio_listener_override(self) -> None:
        r"""
        x.clear_audio_listener_override() -> None
        Clear any overrides that have been applied to audio listener
        """
        ...
    def clear_audio_listener_attenuation_override(self) -> None:
        r"""
        x.clear_audio_listener_attenuation_override() -> None
        Clear Audio Listener Attenuation Override
        """
        ...
    def can_restart_player(self) -> bool:
        r"""
        x.can_restart_player() -> bool
        Returns true if this controller thinks it's able to restart. Called from GameModeBase::PlayerCanRestart
        
        Returns:
            bool:
        """
        ...
    def add_yaw_input(self, val: float) -> None:
        r"""
        x.add_yaw_input(val) -> None
        Add Yaw (turn) input. This value is multiplied by InputYawScale.
        
        Args:
            val (float): Amount to add to Yaw. This value is multiplied by InputYawScale.
        """
        ...
    def add_turn_input(self, val: float) -> None:
        r"""
        deprecated: 'add_turn_input' was renamed to 'add_yaw_input'.
        """
        ...
    def add_roll_input(self, val: float) -> None:
        r"""
        x.add_roll_input(val) -> None
        Add Roll input. This value is multiplied by InputRollScale.
        
        Args:
            val (float): Amount to add to Roll. This value is multiplied by InputRollScale.
        """
        ...
    def add_pitch_input(self, val: float) -> None:
        r"""
        x.add_pitch_input(val) -> None
        Add Pitch (look up) input. This value is multiplied by InputPitchScale.
        
        Args:
            val (float): Amount to add to Pitch. This value is multiplied by InputPitchScale.
        """
        ...
    def add_look_up_input(self, val: float) -> None:
        r"""
        deprecated: 'add_look_up_input' was renamed to 'add_pitch_input'.
        """
        ...
    def activate_touch_interface(self, new_touch_interface: TouchInterface) -> None:
        r"""
        x.activate_touch_interface(new_touch_interface) -> None
        Activates a new touch interface for this player controller
        
        Args:
            new_touch_interface (TouchInterface):
        """
        ...

class CheatManager(Object):
    r"""
    Cheat Manager is a central blueprint to implement test and debug code and actions that are not to ship with the game.
    As the Cheat Manager is not instanced in shipping builds, it is for debugging purposes only
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CheatManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_camera_controller_class`` (type(Class)):  [Read-Write] Debug camera - used to have independent camera without stopping gameplay
    """
    @property
    def debug_camera_controller_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] Debug camera - used to have independent camera without stopping gameplay
        """
        ...
    def walk(self) -> None:
        r"""
        x.walk() -> None
        Return to walking movement mode from Fly or Ghost cheat.
        """
        ...
    def teleport(self) -> None:
        r"""
        x.teleport() -> None
        Teleport to surface player is looking at.
        """
        ...
    def slomo(self, new_time_dilation: float) -> None:
        r"""
        x.slomo(new_time_dilation) -> None
        Modify time dilation to change apparent speed of passage of time. e.g. "Slomo 0.1" makes everything move very slowly, while "Slomo 10" makes everything move very fast.
        
        Args:
            new_time_dilation (float):
        """
        ...
    def receive_init_cheat_manager(self) -> None:
        r"""
        x.receive_init_cheat_manager() -> None
        BP implementable event for when CheatManager is created to allow any needed initialization.
        """
        ...
    def receive_end_play(self) -> None:
        r"""
        x.receive_end_play() -> None
        This is the End Play event for the CheatManager
        """
        ...
    def players_only(self) -> None:
        r"""
        x.players_only() -> None
        Freeze everything in the level except for players.
        """
        ...
    def god(self) -> None:
        r"""
        x.god() -> None
        Invulnerability cheat.
        """
        ...
    def ghost(self) -> None:
        r"""
        x.ghost() -> None
        Pawn no longer collides with the world, and can fly
        """
        ...
    def get_player_controller(self) -> PlayerController:
        r"""
        x.get_player_controller() -> PlayerController
        Get Player Controller
        
        Returns:
            PlayerController:
        """
        ...
    def freeze_frame(self, delay: float) -> None:
        r"""
        x.freeze_frame(delay) -> None
        Pause the game for Delay seconds.
        
        Args:
            delay (float):
        """
        ...
    def fly(self) -> None:
        r"""
        x.fly() -> None
        Pawn can fly.
        """
        ...
    def enable_debug_camera(self) -> None:
        r"""
        x.enable_debug_camera() -> None
        Switch controller to debug camera without locking gameplay and with locking local player controller input
        """
        ...
    def disable_debug_camera(self) -> None:
        r"""
        x.disable_debug_camera() -> None
        Switch controller from debug camera back to normal controller
        """
        ...
    def destroy_target(self) -> None:
        r"""
        x.destroy_target() -> None
        Destroy the actor you're looking at.
        """
        ...
    def damage_target(self, damage_amount: float) -> None:
        r"""
        x.damage_target(damage_amount) -> None
        Damage the actor you're looking at (sourced from the player).
        
        Args:
            damage_amount (float):
        """
        ...
    def change_size(self, f: float) -> None:
        r"""
        x.change_size(f) -> None
        Scale the player's size to be F * default size.
        
        Args:
            f (float):
        """
        ...

class CheatManagerExtension(Object):
    r"""
    A cheat manager extension can extend the main cheat manager in a modular way, being enabled or disabled when the system associated with the cheats is enabled or disabled
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CheatManager.h
    
    """
    def removed_from_cheat_manager(self) -> None:
        r"""
        x.removed_from_cheat_manager() -> None
        Removed from Cheat Manager
        """
        ...
    def get_player_controller(self) -> PlayerController:
        r"""
        x.get_player_controller() -> PlayerController
        Get Player Controller
        
        Returns:
            PlayerController:
        """
        ...
    def added_to_cheat_manager(self) -> None:
        r"""
        x.added_to_cheat_manager() -> None
        Added to Cheat Manager
        """
        ...

class ApplicationLifecycleComponent(ActorComponent):
    r"""
    Component to handle receiving notifications from the OS about application state (activated, suspended, termination, etc).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ApplicationLifecycleComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``application_has_entered_foreground_delegate`` (ApplicationLifetimeDelegate):  [Read-Write] Called when the application is returning to the foreground (reverse any processing done in the EnterBackground delegate)
    - ``application_has_reactivated_delegate`` (ApplicationLifetimeDelegate):  [Read-Write] Called when the application has been reactivated (reverse any processing done in the Deactivate delegate)
    - ``application_received_startup_arguments_delegate`` (ApplicationStartupArgumentsDelegate):  [Read-Write] Called with arguments passed to the application on statup, perhaps meta data passed on by another application which launched this one.
    - ``application_should_unload_resources_delegate`` (ApplicationLifetimeDelegate):  [Read-Write] Called when the OS is running low on resources and asks the application to free up any cached resources, drop graphics quality etc.
    - ``application_will_deactivate_delegate`` (ApplicationLifetimeDelegate):  [Read-Write] This is called when the application is about to be deactivated (e.g., due to a phone call or SMS or the sleep button).
      The game should be paused if possible, etc...
    - ``application_will_enter_background_delegate`` (ApplicationLifetimeDelegate):  [Read-Write] This is called when the application is being backgrounded (e.g., due to switching
      to another app or closing it via the home button)
      The game should release shared resources, save state, etc..., since it can be
      terminated from the background state without any further warning.
    - ``application_will_terminate_delegate`` (ApplicationLifetimeDelegate):  [Read-Write] This *may* be called when the application is getting terminated by the OS.
      There is no guarantee that this will ever be called on a mobile device,
      save state when ApplicationWillEnterBackgroundDelegate is called instead.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_low_power_mode_delegate`` (OnLowPowerModeDelegate):  [Read-Write] Called when we are in low power mode
    - ``on_temperature_change_delegate`` (OnTemperatureChangeDelegate):  [Read-Write] Called when temperature level has changed, and receives the severity
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def application_will_deactivate_delegate(self) -> ApplicationLifetimeDelegate:
        r"""
        (ApplicationLifetimeDelegate):  [Read-Write] This is called when the application is about to be deactivated (e.g., due to a phone call or SMS or the sleep button).
        The game should be paused if possible, etc...
        """
        ...
    @application_will_deactivate_delegate.setter
    def application_will_deactivate_delegate(self, value: ApplicationLifetimeDelegate) -> None:
        ...
    @property
    def application_has_reactivated_delegate(self) -> ApplicationLifetimeDelegate:
        r"""
        (ApplicationLifetimeDelegate):  [Read-Write] Called when the application has been reactivated (reverse any processing done in the Deactivate delegate)
        """
        ...
    @application_has_reactivated_delegate.setter
    def application_has_reactivated_delegate(self, value: ApplicationLifetimeDelegate) -> None:
        ...
    @property
    def application_will_enter_background_delegate(self) -> ApplicationLifetimeDelegate:
        r"""
        (ApplicationLifetimeDelegate):  [Read-Write] This is called when the application is being backgrounded (e.g., due to switching
        to another app or closing it via the home button)
        The game should release shared resources, save state, etc..., since it can be
        terminated from the background state without any further warning.
        """
        ...
    @application_will_enter_background_delegate.setter
    def application_will_enter_background_delegate(self, value: ApplicationLifetimeDelegate) -> None:
        ...
    @property
    def application_has_entered_foreground_delegate(self) -> ApplicationLifetimeDelegate:
        r"""
        (ApplicationLifetimeDelegate):  [Read-Write] Called when the application is returning to the foreground (reverse any processing done in the EnterBackground delegate)
        """
        ...
    @application_has_entered_foreground_delegate.setter
    def application_has_entered_foreground_delegate(self, value: ApplicationLifetimeDelegate) -> None:
        ...
    @property
    def application_will_terminate_delegate(self) -> ApplicationLifetimeDelegate:
        r"""
        (ApplicationLifetimeDelegate):  [Read-Write] This *may* be called when the application is getting terminated by the OS.
        There is no guarantee that this will ever be called on a mobile device,
        save state when ApplicationWillEnterBackgroundDelegate is called instead.
        """
        ...
    @application_will_terminate_delegate.setter
    def application_will_terminate_delegate(self, value: ApplicationLifetimeDelegate) -> None:
        ...
    @property
    def application_should_unload_resources_delegate(self) -> ApplicationLifetimeDelegate:
        r"""
        (ApplicationLifetimeDelegate):  [Read-Write] Called when the OS is running low on resources and asks the application to free up any cached resources, drop graphics quality etc.
        """
        ...
    @application_should_unload_resources_delegate.setter
    def application_should_unload_resources_delegate(self, value: ApplicationLifetimeDelegate) -> None:
        ...
    @property
    def application_received_startup_arguments_delegate(self) -> ApplicationStartupArgumentsDelegate:
        r"""
        (ApplicationStartupArgumentsDelegate):  [Read-Write] Called with arguments passed to the application on statup, perhaps meta data passed on by another application which launched this one.
        """
        ...
    @application_received_startup_arguments_delegate.setter
    def application_received_startup_arguments_delegate(self, value: ApplicationStartupArgumentsDelegate) -> None:
        ...
    @property
    def on_temperature_change_delegate(self) -> OnTemperatureChangeDelegate:
        r"""
        (OnTemperatureChangeDelegate):  [Read-Write] Called when temperature level has changed, and receives the severity
        """
        ...
    @on_temperature_change_delegate.setter
    def on_temperature_change_delegate(self, value: OnTemperatureChangeDelegate) -> None:
        ...
    @property
    def on_low_power_mode_delegate(self) -> OnLowPowerModeDelegate:
        r"""
        (OnLowPowerModeDelegate):  [Read-Write] Called when we are in low power mode
        """
        ...
    @on_low_power_mode_delegate.setter
    def on_low_power_mode_delegate(self, value: OnLowPowerModeDelegate) -> None:
        ...

class ArrowComponent(PrimitiveComponent):
    r"""
    A simple arrow rendered using lines. Useful for indicating which way an object is facing.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ArrowComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``arrow_color`` (Color):  [Read-Write] Color to draw arrow
    - ``arrow_length`` (float):  [Read-Write] Total length of drawn arrow including head
    - ``arrow_size`` (float):  [Read-Write] Relative size to scale drawn arrow by
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_screen_size_scaled`` (bool):  [Read-Write] Set to limit the screen size of this arrow
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``screen_size`` (float):  [Read-Write] The size on screen to limit this arrow to (in screen space)
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_a_sprite`` (bool):  [Read-Write] If true, don't show the arrow when EngineShowFlags.BillboardSprites is disabled.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_in_editor_scaling`` (bool):  [Read-Write] Whether to use in-editor arrow scaling (i.e. to be affected by the global arrow scale)
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def arrow_color(self) -> Color:
        r"""
        (Color):  [Read-Write] Color to draw arrow
        """
        ...
    @arrow_color.setter
    def arrow_color(self, value: Color) -> None:
        ...
    @property
    def arrow_size(self) -> float:
        r"""
        (float):  [Read-Write] Relative size to scale drawn arrow by
        """
        ...
    @arrow_size.setter
    def arrow_size(self, value: float) -> None:
        ...
    @property
    def arrow_length(self) -> float:
        r"""
        (float):  [Read-Write] Total length of drawn arrow including head
        """
        ...
    @arrow_length.setter
    def arrow_length(self, value: float) -> None:
        ...
    @property
    def screen_size(self) -> float:
        r"""
        (float):  [Read-Write] The size on screen to limit this arrow to (in screen space)
        """
        ...
    @screen_size.setter
    def screen_size(self, value: float) -> None:
        ...
    @property
    def is_screen_size_scaled(self) -> bool:
        r"""
        (bool):  [Read-Write] Set to limit the screen size of this arrow
        """
        ...
    @is_screen_size_scaled.setter
    def is_screen_size_scaled(self, value: bool) -> None:
        ...
    @property
    def treat_as_a_sprite(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, don't show the arrow when EngineShowFlags.BillboardSprites is disabled.
        """
        ...
    @treat_as_a_sprite.setter
    def treat_as_a_sprite(self, value: bool) -> None:
        ...
    @property
    def use_in_editor_scaling(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to use in-editor arrow scaling (i.e. to be affected by the global arrow scale)
        """
        ...
    @use_in_editor_scaling.setter
    def use_in_editor_scaling(self, value: bool) -> None:
        ...
    def set_arrow_color(self, new_color: LinearColor) -> None:
        r"""
        x.set_arrow_color(new_color) -> None
        Updates the arrow's colour, and tells it to refresh
        
        Args:
            new_color (LinearColor):
        """
        ...
    def set_arrow_color_new(self, new_color: LinearColor) -> None:
        r"""
        deprecated: 'set_arrow_color_new' was renamed to 'set_arrow_color'.
        """
        ...

class InitialActiveSoundParams(Object):
    r"""
    Convenience class to get audio parameters set on an active sound's playback
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio_params`` (Array[AudioParameter]):  [Read-Write] Collection of parameters to be sent to the active sound
    """
    @property
    def audio_params(self) -> Array[AudioParameter]:
        r"""
        (Array[AudioParameter]):  [Read-Write] Collection of parameters to be sent to the active sound
        """
        ...
    @audio_params.setter
    def audio_params(self, value: Array[AudioParameter]) -> None:
        ...

class AudioComponent(SceneComponent):
    r"""
    AudioComponent is used to play a Sound
    see: https://docs.unrealengine.com/WorkingWithAudio/Overview
    see: USoundBase
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``allow_spatialization`` (bool):  [Read-Write] Overrides spatialization enablement in either the attenuation asset or on this audio component's attenuation settings override.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_attach_location_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our location when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_parent`` (SceneComponent):  [Read-Only] Component we automatically attach to when activated, if bAutoManageAttachment is true.
      If null during registration, we assign the existing AttachParent and defer attachment until we activate.
      see: bAutoManageAttachment
    - ``auto_attach_rotation_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our rotation when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_scale_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our scale when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_socket_name`` (Name):  [Read-Write] Socket we automatically attach to on the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment
    - ``auto_manage_attachment`` (bool):  [Read-Write] True if we should automatically attach to AutoAttachParent when Played, and detach from our parent when playback is completed.
      This overrides any current attachment that may be present at the time of activation (deferring initial attachment until activation, if AutoAttachParent is null).
      If enabled, this AudioComponent's WorldLocation will no longer be reliable when not currently playing audio, and any attach children will also be
      detached/attached along with it.
      When enabled, detachment occurs regardless of whether AutoAttachParent is assigned, and the relative transform from the time of activation is restored.
      This also disables attachment on dedicated servers, where we don't actually activate even if bAutoActivate is true.
      see: AutoAttachParent, AutoAttachSocketName, AutoAttachLocationType
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``can_play_multiple_instances`` (bool):  [Read-Write] If true, the Audio Component will play multiple sound instances at once. Switching sounds or calling play while already playing
      will not stop already active instances. Virtualization for all played sounds will be disabled. Disabling while sound(s) are playing
      will not take effect until the AudioComponent is stopped and restarted.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] What sound concurrency rules to use for sounds generated by this audio component
    - ``default_parameters`` (Array[AudioParameter]):  [Read-Write] Array of parameters for this AudioComponent. Changes to this array directly will
      not be forwarded to the sound if the component is actively playing, and will be superseded
      by parameters set via the actor interface if set, or the instance parameters.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disable_parameter_updates_while_playing`` (bool):  [Read-Write] If true, the Audio Component will ignore parameter updates for already-playing sound(s).
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_low_pass_filter`` (bool):  [Read-Write] Whether or not to apply a low-pass filter to the sound that plays in this audio component.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``low_pass_filter_frequency`` (float):  [Read-Write] If enabled, the frequency of the Lowpass Filter (in Hz) to apply to this voice. A frequency of 0.0 is the device sample rate and will bypass the filter.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulation_routing`` (SoundModulationDefaultRoutingSettings):  [Read-Write]
    - ``on_audio_finished`` (OnAudioFinished):  [Read-Write] Called when we finish playing audio, either because it played to completion or because a Stop() call turned it off early
    - ``on_audio_multi_envelope_value`` (OnAudioMultiEnvelopeValue):  [Read-Write]
    - ``on_audio_play_state_changed`` (OnAudioPlayStateChanged):  [Read-Write] This function returns the Targeted Audio Component's current Play State.
      Playing, if the sound is currently playing.
      Stopped, if the sound is stopped.
      Paused, if the sound is currently playing, but paused.
      Fading In, if the sound is in the process of Fading In.
      Fading Out, if the sound is in the process of Fading Out.
    - ``on_audio_playback_percent`` (OnAudioPlaybackPercent):  [Read-Write] Called as a sound plays on the audio component to allow BP to perform actions based on playback percentage.
      Computed as samples played divided by total samples, taking into account pitch.
      Not currently implemented on all platforms.
    - ``on_audio_single_envelope_value`` (OnAudioSingleEnvelopeValue):  [Read-Write]
    - ``on_audio_virtualization_changed`` (OnAudioVirtualizationChanged):  [Read-Write] Called when virtualization state changes
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``override_attenuation`` (bool):  [Read-Write] Allows defining attenuation settings directly on this audio component without using an attenuation settings asset.
    - ``override_priority`` (bool):  [Read-Write] Whether or not to override the priority of the given sound with the value provided.
    - ``override_subtitle_priority`` (bool):  [Read-Write] Whether or not to override the sound's subtitle priority.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pitch_modulation_max`` (float):  [Read-Write] The upper bound to use when randomly determining a pitch multiplier
    - ``pitch_modulation_min`` (float):  [Read-Write] The lower bound to use when randomly determining a pitch multiplier
    - ``pitch_multiplier`` (float):  [Read-Write] A pitch multiplier to apply to sounds generated by this component
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``priority`` (float):  [Read-Write] If enabled, overrides the priority of the selected sound with the value provided.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sound`` (SoundBase):  [Read-Write] The sound to be played
    - ``sound_class_override`` (SoundClass):  [Read-Write] SoundClass that overrides that set on the referenced SoundBase when component is played.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The chain of Source Effects to apply to the sounds playing on the Audio Component
    - ``subtitle_priority`` (float):  [Read-Write] Used by the subtitle manager to prioritize subtitles wave instances spawned by this component.
    - ``suppress_subtitles`` (bool):  [Read-Write] If true, subtitles in the sound data will be ignored.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volume_modulation_max`` (float):  [Read-Write] The upper bound to use when randomly determining a volume multiplier
    - ``volume_modulation_min`` (float):  [Read-Write] The lower bound to use when randomly determining a volume multiplier
    - ``volume_multiplier`` (float):  [Read-Write] A volume multiplier to apply to sounds generated by this component
    """
    @property
    def sound(self) -> SoundBase:
        r"""
        (SoundBase):  [Read-Write] The sound to be played
        """
        ...
    @sound.setter
    def sound(self, value: SoundBase) -> None:
        ...
    @property
    def default_parameters(self) -> Array[AudioParameter]:
        r"""
        (Array[AudioParameter]):  [Read-Write] Array of parameters for this AudioComponent. Changes to this array directly will
        not be forwarded to the sound if the component is actively playing, and will be superseded
        by parameters set via the actor interface if set, or the instance parameters.
        """
        ...
    @default_parameters.setter
    def default_parameters(self, value: Array[AudioParameter]) -> None:
        ...
    @property
    def instance_parameters(self) -> Array[AudioParameter]:
        r"""
        deprecated: 'instance_parameters' was renamed to 'default_parameters'.
        """
        ...
    @instance_parameters.setter
    def instance_parameters(self, value: Array[AudioParameter]) -> None:
        ...
    @property
    def allow_spatialization(self) -> bool:
        r"""
        (bool):  [Read-Write] Overrides spatialization enablement in either the attenuation asset or on this audio component's attenuation settings override.
        """
        ...
    @allow_spatialization.setter
    def allow_spatialization(self, value: bool) -> None:
        ...
    @property
    def override_attenuation(self) -> bool:
        r"""
        (bool):  [Read-Write] Allows defining attenuation settings directly on this audio component without using an attenuation settings asset.
        """
        ...
    @override_attenuation.setter
    def override_attenuation(self, value: bool) -> None:
        ...
    @property
    def override_subtitle_priority(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to override the sound's subtitle priority.
        """
        ...
    @override_subtitle_priority.setter
    def override_subtitle_priority(self, value: bool) -> None:
        ...
    @property
    def is_ui_sound(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
        """
        ...
    @is_ui_sound.setter
    def is_ui_sound(self, value: bool) -> None:
        ...
    @property
    def enable_low_pass_filter(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to apply a low-pass filter to the sound that plays in this audio component.
        """
        ...
    @enable_low_pass_filter.setter
    def enable_low_pass_filter(self, value: bool) -> None:
        ...
    @property
    def override_priority(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not to override the priority of the given sound with the value provided.
        """
        ...
    @override_priority.setter
    def override_priority(self, value: bool) -> None:
        ...
    @property
    def suppress_subtitles(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, subtitles in the sound data will be ignored.
        """
        ...
    @suppress_subtitles.setter
    def suppress_subtitles(self, value: bool) -> None:
        ...
    @property
    def can_play_multiple_instances(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the Audio Component will play multiple sound instances at once. Switching sounds or calling play while already playing
        will not stop already active instances. Virtualization for all played sounds will be disabled. Disabling while sound(s) are playing
        will not take effect until the AudioComponent is stopped and restarted.
        """
        ...
    @can_play_multiple_instances.setter
    def can_play_multiple_instances(self, value: bool) -> None:
        ...
    @property
    def disable_parameter_updates_while_playing(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the Audio Component will ignore parameter updates for already-playing sound(s).
        """
        ...
    @disable_parameter_updates_while_playing.setter
    def disable_parameter_updates_while_playing(self, value: bool) -> None:
        ...
    @property
    def auto_manage_attachment(self) -> bool:
        r"""
        (bool):  [Read-Only] True if we should automatically attach to AutoAttachParent when Played, and detach from our parent when playback is completed.
        This overrides any current attachment that may be present at the time of activation (deferring initial attachment until activation, if AutoAttachParent is null).
        If enabled, this AudioComponent's WorldLocation will no longer be reliable when not currently playing audio, and any attach children will also be
        detached/attached along with it.
        When enabled, detachment occurs regardless of whether AutoAttachParent is assigned, and the relative transform from the time of activation is restored.
        This also disables attachment on dedicated servers, where we don't actually activate even if bAutoActivate is true.
        see: AutoAttachParent, AutoAttachSocketName, AutoAttachLocationType
        """
        ...
    @property
    def pitch_modulation_min(self) -> float:
        r"""
        (float):  [Read-Write] The lower bound to use when randomly determining a pitch multiplier
        """
        ...
    @pitch_modulation_min.setter
    def pitch_modulation_min(self, value: float) -> None:
        ...
    @property
    def pitch_multiplier_min(self) -> float:
        r"""
        deprecated: 'pitch_multiplier_min' was renamed to 'pitch_modulation_min'.
        """
        ...
    @pitch_multiplier_min.setter
    def pitch_multiplier_min(self, value: float) -> None:
        ...
    @property
    def pitch_modulation_max(self) -> float:
        r"""
        (float):  [Read-Write] The upper bound to use when randomly determining a pitch multiplier
        """
        ...
    @pitch_modulation_max.setter
    def pitch_modulation_max(self, value: float) -> None:
        ...
    @property
    def pitch_multiplier_max(self) -> float:
        r"""
        deprecated: 'pitch_multiplier_max' was renamed to 'pitch_modulation_max'.
        """
        ...
    @pitch_multiplier_max.setter
    def pitch_multiplier_max(self, value: float) -> None:
        ...
    @property
    def volume_modulation_min(self) -> float:
        r"""
        (float):  [Read-Write] The lower bound to use when randomly determining a volume multiplier
        """
        ...
    @volume_modulation_min.setter
    def volume_modulation_min(self, value: float) -> None:
        ...
    @property
    def volume_multiplier_min(self) -> float:
        r"""
        deprecated: 'volume_multiplier_min' was renamed to 'volume_modulation_min'.
        """
        ...
    @volume_multiplier_min.setter
    def volume_multiplier_min(self, value: float) -> None:
        ...
    @property
    def volume_modulation_max(self) -> float:
        r"""
        (float):  [Read-Write] The upper bound to use when randomly determining a volume multiplier
        """
        ...
    @volume_modulation_max.setter
    def volume_modulation_max(self, value: float) -> None:
        ...
    @property
    def volume_multiplier_max(self) -> float:
        r"""
        deprecated: 'volume_multiplier_max' was renamed to 'volume_modulation_max'.
        """
        ...
    @volume_multiplier_max.setter
    def volume_multiplier_max(self, value: float) -> None:
        ...
    @property
    def volume_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] A volume multiplier to apply to sounds generated by this component
        """
        ...
    @volume_multiplier.setter
    def volume_multiplier(self, value: float) -> None:
        ...
    @property
    def envelope_follower_attack_time(self) -> int:
        r"""
        (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
        envelope value of sounds played with this audio component.
        """
        ...
    @envelope_follower_attack_time.setter
    def envelope_follower_attack_time(self, value: int) -> None:
        ...
    @property
    def envelope_follower_release_time(self) -> int:
        r"""
        (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
        envelope value of sounds played with this audio component.
        """
        ...
    @envelope_follower_release_time.setter
    def envelope_follower_release_time(self, value: int) -> None:
        ...
    @property
    def priority(self) -> float:
        r"""
        (float):  [Read-Write] If enabled, overrides the priority of the selected sound with the value provided.
        """
        ...
    @priority.setter
    def priority(self, value: float) -> None:
        ...
    @property
    def subtitle_priority(self) -> float:
        r"""
        (float):  [Read-Write] Used by the subtitle manager to prioritize subtitles wave instances spawned by this component.
        """
        ...
    @subtitle_priority.setter
    def subtitle_priority(self, value: float) -> None:
        ...
    @property
    def source_effect_chain(self) -> SoundEffectSourcePresetChain:
        r"""
        (SoundEffectSourcePresetChain):  [Read-Write] The chain of Source Effects to apply to the sounds playing on the Audio Component
        """
        ...
    @source_effect_chain.setter
    def source_effect_chain(self, value: SoundEffectSourcePresetChain) -> None:
        ...
    @property
    def pitch_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] A pitch multiplier to apply to sounds generated by this component
        """
        ...
    @pitch_multiplier.setter
    def pitch_multiplier(self, value: float) -> None:
        ...
    @property
    def low_pass_filter_frequency(self) -> float:
        r"""
        (float):  [Read-Write] If enabled, the frequency of the Lowpass Filter (in Hz) to apply to this voice. A frequency of 0.0 is the device sample rate and will bypass the filter.
        """
        ...
    @low_pass_filter_frequency.setter
    def low_pass_filter_frequency(self, value: float) -> None:
        ...
    @property
    def attenuation_settings(self) -> SoundAttenuation:
        r"""
        (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
        """
        ...
    @attenuation_settings.setter
    def attenuation_settings(self, value: SoundAttenuation) -> None:
        ...
    @property
    def attenuation_overrides(self) -> SoundAttenuationSettings:
        r"""
        (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
        """
        ...
    @attenuation_overrides.setter
    def attenuation_overrides(self, value: SoundAttenuationSettings) -> None:
        ...
    @property
    def concurrency_set(self) -> Set[SoundConcurrency]:
        r"""
        (Set[SoundConcurrency]):  [Read-Write] What sound concurrency rules to use for sounds generated by this audio component
        """
        ...
    @concurrency_set.setter
    def concurrency_set(self, value: Set[SoundConcurrency]) -> None:
        ...
    @property
    def auto_attach_location_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write] Options for how we handle our location when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment, EAttachmentRule
        """
        ...
    @auto_attach_location_rule.setter
    def auto_attach_location_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def auto_attach_rotation_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write] Options for how we handle our rotation when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment, EAttachmentRule
        """
        ...
    @auto_attach_rotation_rule.setter
    def auto_attach_rotation_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def auto_attach_scale_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write] Options for how we handle our scale when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment, EAttachmentRule
        """
        ...
    @auto_attach_scale_rule.setter
    def auto_attach_scale_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def modulation_routing(self) -> SoundModulationDefaultRoutingSettings:
        r"""
        (SoundModulationDefaultRoutingSettings):  [Read-Write]
        """
        ...
    @modulation_routing.setter
    def modulation_routing(self, value: SoundModulationDefaultRoutingSettings) -> None:
        ...
    @property
    def on_audio_play_state_changed(self) -> OnAudioPlayStateChanged:
        r"""
        (OnAudioPlayStateChanged):  [Read-Write] This function returns the Targeted Audio Component's current Play State.
        Playing, if the sound is currently playing.
        Stopped, if the sound is stopped.
        Paused, if the sound is currently playing, but paused.
        Fading In, if the sound is in the process of Fading In.
        Fading Out, if the sound is in the process of Fading Out.
        """
        ...
    @on_audio_play_state_changed.setter
    def on_audio_play_state_changed(self, value: OnAudioPlayStateChanged) -> None:
        ...
    @property
    def on_audio_virtualization_changed(self) -> OnAudioVirtualizationChanged:
        r"""
        (OnAudioVirtualizationChanged):  [Read-Write] Called when virtualization state changes
        """
        ...
    @on_audio_virtualization_changed.setter
    def on_audio_virtualization_changed(self, value: OnAudioVirtualizationChanged) -> None:
        ...
    @property
    def on_audio_finished(self) -> OnAudioFinished:
        r"""
        (OnAudioFinished):  [Read-Write] Called when we finish playing audio, either because it played to completion or because a Stop() call turned it off early
        """
        ...
    @on_audio_finished.setter
    def on_audio_finished(self, value: OnAudioFinished) -> None:
        ...
    @property
    def on_audio_playback_percent(self) -> OnAudioPlaybackPercent:
        r"""
        (OnAudioPlaybackPercent):  [Read-Write] Called as a sound plays on the audio component to allow BP to perform actions based on playback percentage.
        Computed as samples played divided by total samples, taking into account pitch.
        Not currently implemented on all platforms.
        """
        ...
    @on_audio_playback_percent.setter
    def on_audio_playback_percent(self, value: OnAudioPlaybackPercent) -> None:
        ...
    @property
    def on_audio_single_envelope_value(self) -> OnAudioSingleEnvelopeValue:
        r"""
        (OnAudioSingleEnvelopeValue):  [Read-Write]
        """
        ...
    @on_audio_single_envelope_value.setter
    def on_audio_single_envelope_value(self, value: OnAudioSingleEnvelopeValue) -> None:
        ...
    @property
    def on_audio_multi_envelope_value(self) -> OnAudioMultiEnvelopeValue:
        r"""
        (OnAudioMultiEnvelopeValue):  [Read-Write]
        """
        ...
    @on_audio_multi_envelope_value.setter
    def on_audio_multi_envelope_value(self, value: OnAudioMultiEnvelopeValue) -> None:
        ...
    @property
    def auto_attach_parent(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Only] Component we automatically attach to when activated, if bAutoManageAttachment is true.
        If null during registration, we assign the existing AttachParent and defer attachment until we activate.
        see: bAutoManageAttachment
        """
        ...
    @property
    def auto_attach_socket_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Socket we automatically attach to on the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment
        """
        ...
    @auto_attach_socket_name.setter
    def auto_attach_socket_name(self, value: Name) -> None:
        ...
    def stop_delayed(self, delay_time: float) -> None:
        r"""
        x.stop_delayed(delay_time) -> None
        Cues request to stop sound after the provided delay (in seconds), stopping immediately if delay is zero or negative
        
        Args:
            delay_time (float):
        """
        ...
    def stop(self) -> None:
        r"""
        x.stop() -> None
        Stop an audio component's sound, issue any delegates if needed
        """
        ...
    def set_wave_parameter(self, name: Name, wave: SoundWave) -> None:
        r"""
        x.set_wave_parameter(name, wave) -> None
        Sets the parameter matching the name indicated to the provided Wave. Provided for convenience/backward compatibility
        with SoundCues (The parameter interface supports any object and is up to the system querying it to determine whether
        it is a valid type).
        
        Args:
            name (Name): The name of the parameter to assign the wave to.
            wave (SoundWave): The wave value to set.
        """
        ...
    def set_volume_multiplier(self, new_volume_multiplier: float) -> None:
        r"""
        x.set_volume_multiplier(new_volume_multiplier) -> None
        Set a new volume multiplier
        
        Args:
            new_volume_multiplier (float):
        """
        ...
    def set_ui_sound(self, ui_sound: bool) -> None:
        r"""
        x.set_ui_sound(ui_sound) -> None
        Set whether sounds generated by this audio component should be considered UI sounds
        
        Args:
            ui_sound (bool):
        """
        ...
    def set_submix_send(self, submix: SoundSubmixBase, send_level: float) -> None:
        r"""
        x.set_submix_send(submix, send_level) -> None
        Allows designers to target a specific Audio Component instance’s sound set the send level (volume of sound copied) to the indicated Submix.
        
        Args:
            submix (SoundSubmixBase): The Submix to send the signal to.
            send_level (float): The scalar used to alter the volume of the copied signal.
        """
        ...
    def set_source_bus_send_pre_effect(self, sound_source_bus: SoundSourceBus, source_bus_send_level: float) -> None:
        r"""
        x.set_source_bus_send_pre_effect(sound_source_bus, source_bus_send_level) -> None
        Allows designers to target a specific Audio Component instance’s sound and set the send level (volume of sound copied)
        to the indicated Source Bus. If the Source Bus is not already part of the sound’s sends, the reference will be added to
        this instance’s Override sends. This particular send occurs before the Source Effect processing chain.
        
        Args:
            sound_source_bus (SoundSourceBus): The Bus to send the signal to.
            source_bus_send_level (float): The scalar used to alter the volume of the copied signal.
        """
        ...
    def set_source_bus_send_post_effect(self, sound_source_bus: SoundSourceBus, source_bus_send_level: float) -> None:
        r"""
        x.set_source_bus_send_post_effect(sound_source_bus, source_bus_send_level) -> None
        Allows designers to target a specific Audio Component instance’s sound and set the send level (volume of sound copied)
        to the indicated Source Bus. If the Source Bus is not already part of the sound’s sends, the reference will be added to
        this instance’s Override sends. This particular send occurs after the Source Effect processing chain.
        
        Args:
            sound_source_bus (SoundSourceBus): The Bus to send the signal to
            source_bus_send_level (float): The scalar used to alter the volume of the copied signal
        """
        ...
    def set_sound(self, new_sound: SoundBase) -> None:
        r"""
        x.set_sound(new_sound) -> None
        Set what sound is played by this component
        
        Args:
            new_sound (SoundBase):
        """
        ...
    def set_pitch_multiplier(self, new_pitch_multiplier: float) -> None:
        r"""
        x.set_pitch_multiplier(new_pitch_multiplier) -> None
        Set a new pitch multiplier
        
        Args:
            new_pitch_multiplier (float):
        """
        ...
    def set_paused(self, pause: bool) -> None:
        r"""
        x.set_paused(pause) -> None
        Pause an audio component playing its sound cue, issue any delegates if needed
        
        Args:
            pause (bool):
        """
        ...
    def set_output_to_bus_only(self, output_to_bus_only: bool) -> None:
        r"""
        x.set_output_to_bus_only(output_to_bus_only) -> None
        Sets whether or not to output the audio to bus only.
        
        Args:
            output_to_bus_only (bool):
        """
        ...
    def set_modulation_routing(self, modulators: Set[SoundModulatorBase], destination: ModulationDestination, routing_method: ModulationRouting = ModulationRouting.INHERIT) -> None:
        r"""
        x.set_modulation_routing(modulators, destination, routing_method=ModulationRouting.INHERIT) -> None
        Sets the routing for one of the given Audio component's Modulation Destinations.
        
        Args:
            modulators (Set[SoundModulatorBase]): The set of modulators to apply to the given destination on the component.
            destination (ModulationDestination): The destination to assign the modulators to.
            routing_method (ModulationRouting): The routing method to use for the given modulator.
        """
        ...
    def set_low_pass_filter_frequency(self, low_pass_filter_frequency: float) -> None:
        r"""
        x.set_low_pass_filter_frequency(low_pass_filter_frequency) -> None
        Sets a cutoff frequency, in Hz, for the targeted Audio Component’s sound’s Low Pass Filter calculation.
        The lowest cutoff frequency from all of the sound instance’s possible LPF calculations wins.
        
        Args:
            low_pass_filter_frequency (float):
        """
        ...
    def set_low_pass_filter_enabled(self, low_pass_filter_enabled: bool) -> None:
        r"""
        x.set_low_pass_filter_enabled(low_pass_filter_enabled) -> None
        When set to TRUE, enables an additional Low Pass Filter Frequency to be calculated in with the
        sound instance’s LPF total, allowing designers to set filter settings for the targeted Audio Component’s
        sound instance.
        
        Args:
            low_pass_filter_enabled (bool):
        """
        ...
    def set_int_parameter(self, name: Name, int: int) -> None:
        r"""
        x.set_int_parameter(name, int) -> None
        Sets a named Int32
        
        Args:
            name (Name): 
            int (int32):
        """
        ...
    def set_float_parameter(self, name: Name, float: float) -> None:
        r"""
        x.set_float_parameter(name, float) -> None
        Sets a named Float
        
        Args:
            name (Name): 
            float (float):
        """
        ...
    def set_bool_parameter(self, name: Name, bool: bool) -> None:
        r"""
        x.set_bool_parameter(name, bool) -> None
        Sets a named Boolean
        
        Args:
            name (Name): 
            bool (bool):
        """
        ...
    def set_audio_bus_send_pre_effect(self, audio_bus: AudioBus, audio_bus_send_level: float) -> None:
        r"""
        x.set_audio_bus_send_pre_effect(audio_bus, audio_bus_send_level) -> None
        Sets how much audio the sound should send to the given Audio Bus (PRE Source Effects).
        if the Bus Send doesn't already exist, it will be added to the overrides on the active sound.
        
        Args:
            audio_bus (AudioBus): The Bus to send the signal to
            audio_bus_send_level (float): The scalar used to alter the volume of the copied signal
        """
        ...
    def set_audio_bus_send_post_effect(self, audio_bus: AudioBus, audio_bus_send_level: float) -> None:
        r"""
        x.set_audio_bus_send_post_effect(audio_bus, audio_bus_send_level) -> None
        Sets how much audio the sound should send to the given Audio Bus (POST Source Effects).
        if the Audio Bus Send doesn't already exist, it will be added to the overrides on the active sound.
        
        Args:
            audio_bus (AudioBus): The Bus to send the signal to
            audio_bus_send_level (float): The scalar used to alter the volume of the copied signal
        """
        ...
    def play_quantized(self, world_context_object: Object, clock_handle: QuartzClockHandle, quantization_boundary: QuartzQuantizationBoundary, delegate: OnQuartzCommandEventBP, start_time: float = 0.000000, fade_in_duration: float = 0.000000, fade_volume_level: float = 1.000000, fade_curve: AudioFaderCurve = AudioFaderCurve.LINEAR) -> Tuple[QuartzClockHandle, QuartzQuantizationBoundary]:
        r"""
        x.play_quantized(world_context_object, clock_handle, quantization_boundary, delegate, start_time=0.000000, fade_in_duration=0.000000, fade_volume_level=1.000000, fade_curve=AudioFaderCurve.LINEAR) -> (clock_handle=QuartzClockHandle, quantization_boundary=QuartzQuantizationBoundary)
        Start a sound playing on an audio component on a given quantization boundary with the handle to an existing clock
        
        Args:
            world_context_object (Object): 
            clock_handle (QuartzClockHandle): 
            quantization_boundary (QuartzQuantizationBoundary): 
            delegate (OnQuartzCommandEventBP): 
            start_time (float): 
            fade_in_duration (float): 
            fade_volume_level (float): 
            fade_curve (AudioFaderCurve): 
        
        Returns:
            tuple: 
        
            clock_handle (QuartzClockHandle): 
        
            quantization_boundary (QuartzQuantizationBoundary):
        """
        ...
    def play(self, start_time: float = 0.000000) -> None:
        r"""
        x.play(start_time=0.000000) -> None
        Begins playing the targeted Audio Component's sound at the designated Start Time, seeking into a sound.
        
        Args:
            start_time (float): The offset, in seconds, to begin reading the sound at
        """
        ...
    def is_virtualized(self) -> bool:
        r"""
        x.is_virtualized() -> bool
        Returns if the sound is virtualized.
        
        Returns:
            bool:
        """
        ...
    def is_playing(self) -> bool:
        r"""
        x.is_playing() -> bool
        Returns TRUE if the targeted Audio Component’s sound is playing.
        Doesn't indicate if the sound is paused or fading in/out. Use GetPlayState() to get the full play state.
        
        Returns:
            bool:
        """
        ...
    def has_cooked_fft_data(self) -> bool:
        r"""
        x.has_cooked_fft_data() -> bool
        Queries if the sound wave playing in this audio component has cooked FFT data, returns FALSE if none found.
        
        Returns:
            bool:
        """
        ...
    def has_cooked_amplitude_envelope_data(self) -> bool:
        r"""
        x.has_cooked_amplitude_envelope_data() -> bool
        Queries whether or not the targeted Audio Component instance’s sound has Amplitude Envelope Data, returns FALSE if none found.
        
        Returns:
            bool:
        """
        ...
    def get_play_state(self) -> AudioComponentPlayState:
        r"""
        x.get_play_state() -> AudioComponentPlayState
        Returns the enumerated play states of the audio component.
        
        Returns:
            AudioComponentPlayState:
        """
        ...
    def get_modulators(self, destination: ModulationDestination) -> Set[SoundModulatorBase]:
        r"""
        x.get_modulators(destination) -> Set[SoundModulatorBase]
        Gets the set of currently active modulators for a given Modulation Destination.
        
        Args:
            destination (ModulationDestination): The Destination to retrieve the Modulators from.
        
        Returns:
            Set[SoundModulatorBase]: The set of of Modulators applied to this component for the given Destination.
        """
        ...
    def get_cooked_fft_data_for_all_playing_sounds(self) -> Optional[Array[SoundWaveSpectralDataPerSound]]:
        r"""
        x.get_cooked_fft_data_for_all_playing_sounds() -> Array[SoundWaveSpectralDataPerSound] or None
        Retrieves the current-time cooked spectral data of the sounds playing on the audio component.
        Spectral data is not averaged or interpolated. Instead an array of data with all playing sound waves with cooked data is returned.
        Returns true if there is data and the audio component is playing.
        
        Returns:
            Array[SoundWaveSpectralDataPerSound] or None: 
        
            out_sound_wave_spectral_data (Array[SoundWaveSpectralDataPerSound]):
        """
        ...
    def get_cooked_fft_data(self, frequencies_to_get: Array[float]) -> Optional[Array[SoundWaveSpectralData]]:
        r"""
        x.get_cooked_fft_data(frequencies_to_get) -> Array[SoundWaveSpectralData] or None
        Retrieves the current-time cooked spectral data of the sounds playing on the audio component.
        Spectral data is averaged and interpolated for all playing sounds on this audio component.
        Returns true if there is data and the audio component is playing.
        
        Args:
            frequencies_to_get (Array[float]): 
        
        Returns:
            Array[SoundWaveSpectralData] or None: 
        
            out_sound_wave_spectral_data (Array[SoundWaveSpectralData]):
        """
        ...
    def get_cooked_envelope_data_for_all_playing_sounds(self) -> Optional[Array[SoundWaveEnvelopeDataPerSound]]:
        r"""
        x.get_cooked_envelope_data_for_all_playing_sounds() -> Array[SoundWaveEnvelopeDataPerSound] or None
        Retrieves the current-time amplitude envelope data of the sounds playing on the audio component.
        Envelope data is not averaged or interpolated. Instead an array of data with all playing sound waves with cooked data is returned.
        Returns true if there is data and the audio component is playing.
        
        Returns:
            Array[SoundWaveEnvelopeDataPerSound] or None: 
        
            out_envelope_data (Array[SoundWaveEnvelopeDataPerSound]):
        """
        ...
    def get_cooked_envelope_data(self) -> Optional[float]:
        r"""
        x.get_cooked_envelope_data() -> float or None
        Retrieves Cooked Amplitude Envelope Data at the current playback time. If there are multiple
        SoundWaves playing, data is interpolated and averaged across all playing sound waves.
        Returns FALSE if no data was found.
        
        Returns:
            float or None: 
        
            out_envelope_data (float):
        """
        ...
    def fade_out(self, fade_out_duration: float, fade_volume_level: float, fade_curve: AudioFaderCurve = AudioFaderCurve.LINEAR) -> None:
        r"""
        x.fade_out(fade_out_duration, fade_volume_level, fade_curve=AudioFaderCurve.LINEAR) -> None
        This function allows designers to call a delayed Stop on an Audio Component instance while applying a
        volume curve over time. Parameters allow designers to indicate the duration of the fade and the curve shape.
        
        Args:
            fade_out_duration (float): how long it should take to reach the FadeVolumeLevel
            fade_volume_level (float): the percentage of the AudioComponents's calculated volume in which to fade to
            fade_curve (AudioFaderCurve): The curve to use when interpolating between the old and new volume
        """
        ...
    def fade_in(self, fade_in_duration: float, fade_volume_level: float = 1.000000, start_time: float = 0.000000, fade_curve: AudioFaderCurve = AudioFaderCurve.LINEAR) -> None:
        r"""
        x.fade_in(fade_in_duration, fade_volume_level=1.000000, start_time=0.000000, fade_curve=AudioFaderCurve.LINEAR) -> None
        This function allows designers to call Play on an Audio Component instance while applying a volume curve over time.
        Parameters allow designers to indicate the duration of the fade, the curve shape, and the start time if seeking into the sound.
        
        Args:
            fade_in_duration (float): How long it should take to reach the FadeVolumeLevel
            fade_volume_level (float): The percentage of the AudioComponents's calculated volume to fade to
            start_time (float): 
            fade_curve (AudioFaderCurve): The curve to use when interpolating between the old and new volume
        """
        ...
    def get_attenuation_settings_to_apply(self) -> Optional[SoundAttenuationSettings]:
        r"""
        x.get_attenuation_settings_to_apply() -> SoundAttenuationSettings or None
        Retrieves Attenuation Settings data on the targeted Audio Component. Returns FALSE if no settings were found.
        Because the Attenuation Settings data structure is copied, FALSE returns will return default values.
        
        Returns:
            SoundAttenuationSettings or None: 
        
            out_attenuation_settings (SoundAttenuationSettings):
        """
        ...
    def adjust_volume(self, adjust_volume_duration: float, adjust_volume_level: float, fade_curve: AudioFaderCurve = AudioFaderCurve.LINEAR) -> None:
        r"""
        x.adjust_volume(adjust_volume_duration, adjust_volume_level, fade_curve=AudioFaderCurve.LINEAR) -> None
        This function allows designers to trigger an adjustment to the sound instance’s playback Volume with options for smoothly applying a curve over time.
        
        Args:
            adjust_volume_duration (float): The length of time in which to interpolate between the initial volume and the new volume.
            adjust_volume_level (float): The new volume to set the Audio Component to.
            fade_curve (AudioFaderCurve): The curve used when interpolating between the old and new volume.
        """
        ...
    def adjust_attenuation(self, attenuation_settings: SoundAttenuationSettings) -> None:
        r"""
        x.adjust_attenuation(attenuation_settings) -> None
        This function is used to modify the Attenuation Settings on the targeted Audio Component instance. It is worth noting that Attenuation Settings are only passed to new Active Sounds on start, so modified Attenuation data should be set before sound playback.
        
        Args:
            attenuation_settings (SoundAttenuationSettings):
        """
        ...
    def set_trigger_parameter(self, name: Name) -> None:
        r"""
        x.set_trigger_parameter(name) -> None
        Executes a named trigger.  Does *not* cache trigger value, so only executes if the sound
        is already playing.  If the intent is for the trigger to execute immediately (if playing)
        and be called on initialization for all future instances, call 'SetBoolParameter' with the
        intended initial trigger behavior (true if trigger desired on initialization, false if not).
        
        Args:
            name (Name):
        """
        ...
    def set_string_parameter(self, name: Name, value: str) -> None:
        r"""
        x.set_string_parameter(name, value) -> None
        Sets a named String
        
        Args:
            name (Name): 
            value (str):
        """
        ...
    def set_string_array_parameter(self, name: Name, value: Array[str]) -> None:
        r"""
        x.set_string_array_parameter(name, value) -> None
        Sets a named String Array
        
        Args:
            name (Name): 
            value (Array[str]):
        """
        ...
    def set_parameters_blueprint(self, parameters: Array[AudioParameter]) -> None:
        r"""
        x.set_parameters_blueprint(parameters) -> None
        Sets an array of parameters as a batch
        
        Args:
            parameters (Array[AudioParameter]):
        """
        ...
    def set_object_parameter(self, name: Name, value: Object) -> None:
        r"""
        x.set_object_parameter(name, value) -> None
        Sets a named UObject
        
        Args:
            name (Name): 
            value (Object):
        """
        ...
    def set_object_array_parameter(self, name: Name, value: Array[Object]) -> None:
        r"""
        x.set_object_array_parameter(name, value) -> None
        Sets a named UObject Array
        
        Args:
            name (Name): 
            value (Array[Object]):
        """
        ...
    def set_int_array_parameter(self, name: Name, value: Array[int]) -> None:
        r"""
        x.set_int_array_parameter(name, value) -> None
        Sets a named Int32 Array
        
        Args:
            name (Name): 
            value (Array[int32]):
        """
        ...
    def set_float_array_parameter(self, name: Name, value: Array[float]) -> None:
        r"""
        x.set_float_array_parameter(name, value) -> None
        Sets a named Float Array
        
        Args:
            name (Name): 
            value (Array[float]):
        """
        ...
    def set_bool_array_parameter(self, name: Name, value: Array[bool]) -> None:
        r"""
        x.set_bool_array_parameter(name, value) -> None
        Sets a named Boolean Array
        
        Args:
            name (Name): 
            value (Array[bool]):
        """
        ...
    def reset_parameters(self) -> None:
        r"""
        x.reset_parameters() -> None
        Resets all parameters to their original values.
        """
        ...

class BillboardComponent(PrimitiveComponent):
    r"""
    A 2d texture that will be rendered always facing the camera.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BillboardComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_screen_size_scaled`` (bool):  [Read-Write]
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``opacity_mask_ref_val`` (float):  [Read-Write] The billboard is not rendered where texture opacity < OpacityMaskRefVal
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``screen_size`` (float):  [Read-Write]
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sprite`` (Texture2D):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``u`` (float):  [Read-Write]
    - ``ul`` (float):  [Read-Write]
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_in_editor_scaling`` (bool):  [Read-Write] Whether to use in-editor arrow scaling (i.e. to be affected by the global arrow scale)
    - ``v`` (float):  [Read-Write]
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``vl`` (float):  [Read-Write]
    """
    @property
    def sprite(self) -> Texture2D:
        r"""
        (Texture2D):  [Read-Write]
        """
        ...
    @sprite.setter
    def sprite(self, value: Texture2D) -> None:
        ...
    @property
    def is_screen_size_scaled(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_screen_size_scaled.setter
    def is_screen_size_scaled(self, value: bool) -> None:
        ...
    @property
    def screen_size(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @screen_size.setter
    def screen_size(self, value: float) -> None:
        ...
    @property
    def u(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @u.setter
    def u(self, value: float) -> None:
        ...
    @property
    def ul(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @ul.setter
    def ul(self, value: float) -> None:
        ...
    @property
    def v(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @v.setter
    def v(self, value: float) -> None:
        ...
    @property
    def vl(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @vl.setter
    def vl(self, value: float) -> None:
        ...
    @property
    def opacity_mask_ref_val(self) -> float:
        r"""
        (float):  [Read-Write] The billboard is not rendered where texture opacity < OpacityMaskRefVal
        """
        ...
    @opacity_mask_ref_val.setter
    def opacity_mask_ref_val(self, value: float) -> None:
        ...
    @property
    def use_in_editor_scaling(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to use in-editor arrow scaling (i.e. to be affected by the global arrow scale)
        """
        ...
    @use_in_editor_scaling.setter
    def use_in_editor_scaling(self, value: bool) -> None:
        ...
    def set_uv(self, new_u: int, new_ul: int, new_v: int, new_vl: int) -> None:
        r"""
        x.set_uv(new_u, new_ul, new_v, new_vl) -> None
        Change the sprite's UVs
        
        Args:
            new_u (int32): 
            new_ul (int32): 
            new_v (int32): 
            new_vl (int32):
        """
        ...
    def set_sprite_and_uv(self, new_sprite: Texture2D, new_u: int, new_ul: int, new_v: int, new_vl: int) -> None:
        r"""
        x.set_sprite_and_uv(new_sprite, new_u, new_ul, new_v, new_vl) -> None
        Change the sprite texture and the UV's used by this component
        
        Args:
            new_sprite (Texture2D): 
            new_u (int32): 
            new_ul (int32): 
            new_v (int32): 
            new_vl (int32):
        """
        ...
    def set_sprite(self, new_sprite: Texture2D) -> None:
        r"""
        x.set_sprite(new_sprite) -> None
        Change the sprite texture used by this component
        
        Args:
            new_sprite (Texture2D):
        """
        ...
    def set_opacity_mask_ref_val(self, ref_val: float) -> None:
        r"""
        x.set_opacity_mask_ref_val(ref_val) -> None
        Changed the opacity masked used by this component
        
        Args:
            ref_val (float):
        """
        ...

class SpriteComponent(BillboardComponent):
    r"""
    deprecated: 'SpriteComponent' was renamed to 'BillboardComponent'.
    """
    ...

class BoundsCopyComponent(ActorComponent):
    r"""
    Component used to copy the bounds of another Actor.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BoundsCopyComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bounds_source_actor`` (Actor):  [Read-Write] Actor to copy the bounds from to set up the transform.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``keep_own_bounds_scale`` (bool):  [Read-Write] If true, the actor's scale will be changed so that after adjustment, its own bounds match the source bounds.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``use_colliding_components_for_own_bounds`` (bool):  [Read-Write] If true, the actor's own bounds will include its colliding components bounds.
    - ``use_colliding_components_for_source_bounds`` (bool):  [Read-Write] If true, the source actor's bounds will include its colliding components bounds.
    """
    def set_transform_to_bounds(self) -> None:
        r"""
        x.set_transform_to_bounds() -> None
        Set this component transform to include the BoundsSourceActor bounds
        """
        ...
    def set_rotation(self) -> None:
        r"""
        x.set_rotation() -> None
        Copy the rotation from BoundsSourceActor to this component
        """
        ...

class ShapeComponent(PrimitiveComponent):
    r"""
    ShapeComponent is a PrimitiveComponent that is represented by a simple geometrical shape (sphere, capsule, box, etc).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ShapeComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``area_class_override`` (type(Class)):  [Read-Write] Navigation area type override, null / none = no change to nav mesh.
      bDynamicObstacle must be true and bUseSystemDefaultAreaClass false to use this.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``dynamic_obstacle`` (bool):  [Read-Write] If set, shape will be exported for navigation as dynamic modifier instead of using regular collision data
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``line_thickness`` (float):  [Read-Write] Used to control the line thickness when rendering
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``shape_color`` (Color):  [Read-Write] Color used to draw the shape.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_system_default_obstacle_area_class`` (bool):  [Read-Write] Uses FNavigationSystem::GetDefaultObstacleArea() by default instead of AreaClassOverride, bDynamicObstacle must be true to use this.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def shape_color(self) -> Color:
        r"""
        (Color):  [Read-Only] Color used to draw the shape.
        """
        ...
    @property
    def line_thickness(self) -> float:
        r"""
        (float):  [Read-Only] Used to control the line thickness when rendering
        """
        ...
    def set_line_thickness(self, thickness: float) -> None:
        r"""
        x.set_line_thickness(thickness) -> None
        Set the LineThickness
        
        Args:
            thickness (float):
        """
        ...

class BoxComponent(ShapeComponent):
    r"""
    A box generally used for simple collision. Bounds are rendered as lines in the editor.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BoxComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``area_class_override`` (type(Class)):  [Read-Write] Navigation area type override, null / none = no change to nav mesh.
      bDynamicObstacle must be true and bUseSystemDefaultAreaClass false to use this.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``box_extent`` (Vector):  [Read-Write] The extents (radii dimensions) of the box *
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``dynamic_obstacle`` (bool):  [Read-Write] If set, shape will be exported for navigation as dynamic modifier instead of using regular collision data
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``line_thickness`` (float):  [Read-Write] Used to control the line thickness when rendering
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``shape_color`` (Color):  [Read-Write] Color used to draw the shape.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_system_default_obstacle_area_class`` (bool):  [Read-Write] Uses FNavigationSystem::GetDefaultObstacleArea() by default instead of AreaClassOverride, bDynamicObstacle must be true to use this.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def box_extent(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The extents (radii dimensions) of the box *
        """
        ...
    def set_box_extent(self, box_extent: Vector, update_overlaps: bool = True) -> None:
        r"""
        x.set_box_extent(box_extent, update_overlaps=True) -> None
        Change the box extent size. This is the unscaled size, before component scale is applied.
        
        Args:
            box_extent (Vector): 
            update_overlaps (bool):
        """
        ...
    def get_unscaled_box_extent(self) -> Vector:
        r"""
        x.get_unscaled_box_extent() -> Vector
        
        
        Returns:
            Vector: the box extent, ignoring component scale.
        """
        ...
    def get_scaled_box_extent(self) -> Vector:
        r"""
        x.get_scaled_box_extent() -> Vector
        
        
        Returns:
            Vector: the box extent, scaled by the component scale.
        """
        ...

class BrushComponent(PrimitiveComponent):
    r"""
    A brush component defines a shape that can be modified within the editor. They are used both as part of BSP building, and for volumes.
    see: https://docs.unrealengine.com/latest/INT/Engine/Actors/Volumes
    see: https://docs.unrealengine.com/latest/INT/Engine/Actors/Brushes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BrushComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class CapsuleComponent(ShapeComponent):
    r"""
    A capsule generally used for simple collision. Bounds are rendered as lines in the editor.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CapsuleComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``area_class_override`` (type(Class)):  [Read-Write] Navigation area type override, null / none = no change to nav mesh.
      bDynamicObstacle must be true and bUseSystemDefaultAreaClass false to use this.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capsule_half_height`` (float):  [Read-Write] Half-height, from center of capsule to the end of top or bottom hemisphere.
      This cannot be less than CapsuleRadius.
    - ``capsule_radius`` (float):  [Read-Write] Radius of cap hemispheres and center cylinder.
      This cannot be more than CapsuleHalfHeight.
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``dynamic_obstacle`` (bool):  [Read-Write] If set, shape will be exported for navigation as dynamic modifier instead of using regular collision data
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``line_thickness`` (float):  [Read-Write] Used to control the line thickness when rendering
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``shape_color`` (Color):  [Read-Write] Color used to draw the shape.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_system_default_obstacle_area_class`` (bool):  [Read-Write] Uses FNavigationSystem::GetDefaultObstacleArea() by default instead of AreaClassOverride, bDynamicObstacle must be true to use this.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def capsule_half_height(self) -> float:
        r"""
        (float):  [Read-Only] Half-height, from center of capsule to the end of top or bottom hemisphere.
        This cannot be less than CapsuleRadius.
        """
        ...
    @property
    def capsule_height(self) -> float:
        r"""
        deprecated: 'capsule_height' was renamed to 'capsule_half_height'.
        """
        ...
    @property
    def capsule_radius(self) -> float:
        r"""
        (float):  [Read-Only] Radius of cap hemispheres and center cylinder.
        This cannot be more than CapsuleHalfHeight.
        """
        ...
    def set_capsule_size(self, radius: float, half_height: float, update_overlaps: bool = True) -> None:
        r"""
        x.set_capsule_size(radius, half_height, update_overlaps=True) -> None
        Change the capsule size. This is the unscaled size, before component scale is applied.
        
        Args:
            radius (float): : radius of end-cap hemispheres and center cylinder.
            half_height (float): : half-height, from capsule center to end of top or bottom hemisphere.
            update_overlaps (bool):
        """
        ...
    def set_capsule_radius(self, radius: float, update_overlaps: bool = True) -> None:
        r"""
        x.set_capsule_radius(radius, update_overlaps=True) -> None
        Set the capsule radius. This is the unscaled radius, before component scale is applied.
        If this capsule collides, updates touching array for owner actor.
        
        Args:
            radius (float): : radius of end-cap hemispheres and center cylinder.
            update_overlaps (bool):
        """
        ...
    def set_capsule_half_height(self, half_height: float, update_overlaps: bool = True) -> None:
        r"""
        x.set_capsule_half_height(half_height, update_overlaps=True) -> None
        Set the capsule half-height. This is the unscaled half-height, before component scale is applied.
        If this capsule collides, updates touching array for owner actor.
        
        Args:
            half_height (float): : half-height, from capsule center to end of top or bottom hemisphere.
            update_overlaps (bool):
        """
        ...
    def get_unscaled_capsule_size_without_hemisphere(self) -> Tuple[float, float]:
        r"""
        x.get_unscaled_capsule_size_without_hemisphere() -> (out_radius=float, out_half_height_without_hemisphere=float)
        Returns the capsule radius and half-height, ignoring component scaling. Half-height excludes the hemisphere end cap.
        
        Returns:
            tuple: 
        
            out_radius (float): Radius of the capsule, ignoring component scaling.
        
            out_half_height_without_hemisphere (float): Half-height of the capsule, scaled by the component scale. Excludes the hemisphere end cap.
        """
        ...
    def get_unscaled_capsule_size(self) -> Tuple[float, float]:
        r"""
        x.get_unscaled_capsule_size() -> (out_radius=float, out_half_height=float)
        Returns the capsule radius and half-height scaled by the component scale. Half-height includes the hemisphere end cap.
        
        Returns:
            tuple: 
        
            out_radius (float): Radius of the capsule, scaled by the component scale.
        
            out_half_height (float): Half-height of the capsule, scaled by the component scale. Includes the hemisphere end cap.
        """
        ...
    def get_unscaled_capsule_radius(self) -> float:
        r"""
        x.get_unscaled_capsule_radius() -> float
        Returns the capsule radius, ignoring component scaling.
        
        Returns:
            float: the capsule radius, ignoring component scaling.
        """
        ...
    def get_unscaled_capsule_half_height_without_hemisphere(self) -> float:
        r"""
        x.get_unscaled_capsule_half_height_without_hemisphere() -> float
        Returns the capsule half-height minus radius (to exclude the hemisphere), ignoring component scaling. This excludes the hemisphere end cap.
        From the center of the capsule this is the vertical distance along the straight cylindrical portion to the point just before the curve of top hemisphere begins.
        
        Returns:
            float: The capsule half-height minus radius, ignoring component scaling.
        """
        ...
    def get_unscaled_capsule_half_height(self) -> float:
        r"""
        x.get_unscaled_capsule_half_height() -> float
        Returns the capsule half-height, ignoring component scaling. This includes the hemisphere end cap.
        
        Returns:
            float: The capsule radius, ignoring component scaling.
        """
        ...
    def get_shape_scale(self) -> float:
        r"""
        x.get_shape_scale() -> float
        Get the scale used by this shape. This is a uniform scale that is the minimum of any non-uniform scaling.
        
        Returns:
            float: the scale used by this shape.
        """
        ...
    def get_scaled_capsule_size_without_hemisphere(self) -> Tuple[float, float]:
        r"""
        x.get_scaled_capsule_size_without_hemisphere() -> (out_radius=float, out_half_height_without_hemisphere=float)
        Returns the capsule radius and half-height scaled by the component scale. Half-height excludes the hemisphere end cap.
        
        Returns:
            tuple: 
        
            out_radius (float): Radius of the capsule, ignoring component scaling.
        
            out_half_height_without_hemisphere (float): Half-height of the capsule, scaled by the component scale. Excludes the hemisphere end cap.
        """
        ...
    def get_scaled_capsule_size(self) -> Tuple[float, float]:
        r"""
        x.get_scaled_capsule_size() -> (out_radius=float, out_half_height=float)
        Returns the capsule radius and half-height scaled by the component scale. Half-height includes the hemisphere end cap.
        
        Returns:
            tuple: 
        
            out_radius (float): Radius of the capsule, scaled by the component scale.
        
            out_half_height (float): Half-height of the capsule, scaled by the component scale. Includes the hemisphere end cap.
        """
        ...
    def get_scaled_capsule_radius(self) -> float:
        r"""
        x.get_scaled_capsule_radius() -> float
        Returns the capsule radius scaled by the component scale.
        
        Returns:
            float: The capsule radius scaled by the component scale.
        """
        ...
    def get_scaled_capsule_half_height_without_hemisphere(self) -> float:
        r"""
        x.get_scaled_capsule_half_height_without_hemisphere() -> float
        Returns the capsule half-height minus radius (to exclude the hemisphere), scaled by the component scale.
        From the center of the capsule this is the vertical distance along the straight cylindrical portion to the point just before the curve of top hemisphere begins.
        
        Returns:
            float: The capsule half-height minus radius, scaled by the component scale.
        """
        ...
    def get_scaled_capsule_half_height(self) -> float:
        r"""
        x.get_scaled_capsule_half_height() -> float
        Returns the capsule half-height scaled by the component scale. This includes both the cylinder and hemisphere cap.
        
        Returns:
            float: The capsule half-height scaled by the component scale.
        """
        ...

class MovementComponent(ActorComponent):
    r"""
    MovementComponent is an abstract component class that defines functionality for moving a PrimitiveComponent (our UpdatedComponent) each tick.
    Base functionality includes:
       - Restricting movement to a plane or axis.
       - Utility functions for special handling of collision results (SlideAlongSurface(), ComputeSlideVector(), TwoWallAdjust()).
       - Utility functions for moving when there may be initial penetration (SafeMoveUpdatedComponent(), ResolvePenetration()).
       - Automatically registering the component tick and finding a component to move on the owning Actor.
    Normally the root component of the owning actor is moved, however another component may be selected (see SetUpdatedComponent()).
    During swept (non-teleporting) movement only collision of UpdatedComponent is considered, attached components will teleport to the end location ignoring collision.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MovementComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_register_physics_volume_updates`` (bool):  [Read-Write] If true, then applies the value of bComponentShouldUpdatePhysicsVolume to the UpdatedComponent. If false, will not change bShouldUpdatePhysicsVolume on the UpdatedComponent at all.
      see: bComponentShouldUpdatePhysicsVolume
    - ``auto_register_updated_component`` (bool):  [Read-Write] If true, registers the owner's Root component as the UpdatedComponent if there is not one currently assigned.
    - ``auto_update_tick_registration`` (bool):  [Read-Write] If true, whenever the updated component is changed, this component will enable or disable its tick dependent on whether it has something to update.
      This will NOT enable tick at startup if bAutoActivate is false, because presumably you have a good reason for not wanting it to start ticking initially.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_should_update_physics_volume`` (bool):  [Read-Write] If true, enables bShouldUpdatePhysicsVolume on the UpdatedComponent during initialization from SetUpdatedComponent(), otherwise disables such updates.
      Only enabled if bAutoRegisterPhysicsVolumeUpdates is true.
      WARNING: UpdatePhysicsVolume is potentially expensive if overlap events are also *disabled* because it requires a separate query against all physics volumes in the world.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_to_plane`` (bool):  [Read-Write] If true, movement will be constrained to a plane.
      see: PlaneConstraintNormal, PlaneConstraintOrigin, PlaneConstraintAxisSetting
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``plane_constraint_axis_setting`` (PlaneConstraintAxisSetting):  [Read-Write] Setting that controls behavior when movement is restricted to a 2D plane defined by a specific axis/normal,
      so that movement along the locked axis is not be possible.
      see: SetPlaneConstraintAxisSetting
    - ``plane_constraint_normal`` (Vector):  [Read-Write] The normal or axis of the plane that constrains movement, if bConstrainToPlane is enabled.
      If for example you wanted to constrain movement to the X-Z plane (so that Y cannot change), the normal would be set to X=0 Y=1 Z=0.
      This is recalculated whenever PlaneConstraintAxisSetting changes. It is normalized once the component is registered with the game world.
      see: bConstrainToPlane, SetPlaneConstraintNormal(), SetPlaneConstraintFromVectors()
    - ``plane_constraint_origin`` (Vector):  [Read-Write] The origin of the plane that constrains movement, if plane constraint is enabled.
      This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
      see: bConstrainToPlane, SetPlaneConstraintOrigin().
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``snap_to_plane_at_start`` (bool):  [Read-Write] If true and plane constraints are enabled, then the updated component will be snapped to the plane when first attached.
    - ``tick_before_owner`` (bool):  [Read-Write] If true, after registration we will add a tick dependency to tick before our owner (if we can both tick).
      This is important when our tick causes an update in the owner's position, so that when the owner ticks it uses the most recent position without lag.
      Disabling this can improve performance if both objects tick but the order of ticks doesn't matter.
    - ``update_only_if_rendered`` (bool):  [Read-Write] If true, skips TickComponent() if UpdatedComponent was not recently rendered.
    - ``updated_component`` (SceneComponent):  [Read-Write] The component we move and update.
      If this is null at startup and bAutoRegisterUpdatedComponent is true, the owning Actor's root component will automatically be set as our UpdatedComponent at startup.
      see: bAutoRegisterUpdatedComponent, SetUpdatedComponent(), UpdatedPrimitive
    - ``updated_primitive`` (PrimitiveComponent):  [Read-Write] UpdatedComponent, cast as a UPrimitiveComponent. May be invalid if UpdatedComponent was null or not a UPrimitiveComponent.
    - ``velocity`` (Vector):  [Read-Write] Current velocity of updated component.
    """
    @property
    def updated_component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Only] The component we move and update.
        If this is null at startup and bAutoRegisterUpdatedComponent is true, the owning Actor's root component will automatically be set as our UpdatedComponent at startup.
        see: bAutoRegisterUpdatedComponent, SetUpdatedComponent(), UpdatedPrimitive
        """
        ...
    @property
    def updated_primitive(self) -> PrimitiveComponent:
        r"""
        (PrimitiveComponent):  [Read-Only] UpdatedComponent, cast as a UPrimitiveComponent. May be invalid if UpdatedComponent was null or not a UPrimitiveComponent.
        """
        ...
    @property
    def velocity(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Current velocity of updated component.
        """
        ...
    @velocity.setter
    def velocity(self, value: Vector) -> None:
        ...
    @property
    def plane_constraint_normal(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The normal or axis of the plane that constrains movement, if bConstrainToPlane is enabled.
        If for example you wanted to constrain movement to the X-Z plane (so that Y cannot change), the normal would be set to X=0 Y=1 Z=0.
        This is recalculated whenever PlaneConstraintAxisSetting changes. It is normalized once the component is registered with the game world.
        see: bConstrainToPlane, SetPlaneConstraintNormal(), SetPlaneConstraintFromVectors()
        """
        ...
    @property
    def plane_constraint_origin(self) -> Vector:
        r"""
        (Vector):  [Read-Only] The origin of the plane that constrains movement, if plane constraint is enabled.
        This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
        see: bConstrainToPlane, SetPlaneConstraintOrigin().
        """
        ...
    @property
    def update_only_if_rendered(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, skips TickComponent() if UpdatedComponent was not recently rendered.
        """
        ...
    @update_only_if_rendered.setter
    def update_only_if_rendered(self, value: bool) -> None:
        ...
    @property
    def auto_update_tick_registration(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, whenever the updated component is changed, this component will enable or disable its tick dependent on whether it has something to update.
        This will NOT enable tick at startup if bAutoActivate is false, because presumably you have a good reason for not wanting it to start ticking initially.
        """
        ...
    @property
    def tick_before_owner(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, after registration we will add a tick dependency to tick before our owner (if we can both tick).
        This is important when our tick causes an update in the owner's position, so that when the owner ticks it uses the most recent position without lag.
        Disabling this can improve performance if both objects tick but the order of ticks doesn't matter.
        """
        ...
    @property
    def auto_register_updated_component(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, registers the owner's Root component as the UpdatedComponent if there is not one currently assigned.
        """
        ...
    @property
    def constrain_to_plane(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, movement will be constrained to a plane.
        see: PlaneConstraintNormal, PlaneConstraintOrigin, PlaneConstraintAxisSetting
        """
        ...
    @property
    def snap_to_plane_at_start(self) -> bool:
        r"""
        (bool):  [Read-Only] If true and plane constraints are enabled, then the updated component will be snapped to the plane when first attached.
        """
        ...
    @property
    def auto_register_physics_volume_updates(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, then applies the value of bComponentShouldUpdatePhysicsVolume to the UpdatedComponent. If false, will not change bShouldUpdatePhysicsVolume on the UpdatedComponent at all.
        see: bComponentShouldUpdatePhysicsVolume
        """
        ...
    @property
    def component_should_update_physics_volume(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, enables bShouldUpdatePhysicsVolume on the UpdatedComponent during initialization from SetUpdatedComponent(), otherwise disables such updates.
        Only enabled if bAutoRegisterPhysicsVolumeUpdates is true.
        WARNING: UpdatePhysicsVolume is potentially expensive if overlap events are also *disabled* because it requires a separate query against all physics volumes in the world.
        """
        ...
    def stop_movement_immediately(self) -> None:
        r"""
        x.stop_movement_immediately() -> None
        Stops movement immediately (zeroes velocity, usually zeros acceleration for components with acceleration).
        """
        ...
    def snap_updated_component_to_plane(self) -> None:
        r"""
        x.snap_updated_component_to_plane() -> None
        Snap the updated component to the plane constraint, if enabled.
        """
        ...
    def set_updated_component(self, new_updated_component: SceneComponent) -> None:
        r"""
        x.set_updated_component(new_updated_component) -> None
        Assign the component we move and update.
        
        Args:
            new_updated_component (SceneComponent):
        """
        ...
    def set_plane_constraint_origin(self, plane_origin: Vector) -> None:
        r"""
        x.set_plane_constraint_origin(plane_origin) -> None
        Sets the origin of the plane that constrains movement, enforced if the plane constraint is enabled.
        
        Args:
            plane_origin (Vector):
        """
        ...
    def set_plane_constraint_normal(self, plane_normal: Vector) -> None:
        r"""
        x.set_plane_constraint_normal(plane_normal) -> None
        Sets the normal of the plane that constrains movement, enforced if the plane constraint is enabled.
        Changing the normal automatically sets PlaneConstraintAxisSetting to "Custom".
        
        Args:
            plane_normal (Vector): The normal of the plane. If non-zero in length, it will be normalized.
        """
        ...
    def set_plane_constraint_from_vectors(self, forward: Vector, up: Vector) -> None:
        r"""
        x.set_plane_constraint_from_vectors(forward, up) -> None
        Uses the Forward and Up vectors to compute the plane that constrains movement, enforced if the plane constraint is enabled.
        
        Args:
            forward (Vector): 
            up (Vector):
        """
        ...
    def set_plane_constraint_enabled(self, enabled: bool) -> None:
        r"""
        x.set_plane_constraint_enabled(enabled) -> None
        Sets whether or not the plane constraint is enabled.
        
        Args:
            enabled (bool):
        """
        ...
    def set_plane_constraint_axis_setting(self, new_axis_setting: PlaneConstraintAxisSetting) -> None:
        r"""
        x.set_plane_constraint_axis_setting(new_axis_setting) -> None
        Set the plane constraint axis setting.
        Changing this setting will modify the current value of PlaneConstraintNormal.
        
        Args:
            new_axis_setting (PlaneConstraintAxisSetting): New plane constraint axis setting.
        """
        ...
    def move_updated_component(self, delta: Vector, new_rotation: Rotator, sweep: bool = True, teleport: bool = False) -> Optional[HitResult]:
        r"""
        x.move_updated_component(delta, new_rotation, sweep=True, teleport=False) -> HitResult or None
        Moves our UpdatedComponent by the given Delta, and sets rotation to NewRotation.
        Respects the plane constraint, if enabled.
        
        Args:
            delta (Vector): 
            new_rotation (Rotator): 
            sweep (bool): 
            teleport (bool): 
        
        Returns:
            HitResult or None: True if some movement occurred, false if no movement occurred. Result of any impact will be stored in OutHit.
        
            out_hit (HitResult):
        """
        ...
    def is_exceeding_max_speed(self, max_speed: float) -> bool:
        r"""
        x.is_exceeding_max_speed(max_speed) -> bool
        Returns true if the current velocity is exceeding the given max speed (usually the result of GetMaxSpeed()), within a small error tolerance.
        Note that under normal circumstances updates cause by acceleration will not cause this to be true, however external forces or changes in the max speed limit
        can cause the max speed to be violated.
        
        Args:
            max_speed (float): 
        
        Returns:
            bool:
        """
        ...
    def get_plane_constraint_origin(self) -> Vector:
        r"""
        x.get_plane_constraint_origin() -> Vector
        Get the plane constraint origin. This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
        
        Returns:
            Vector: The origin of the plane that constrains movement, if the plane constraint is enabled.
        """
        ...
    def get_plane_constraint_normal(self) -> Vector:
        r"""
        x.get_plane_constraint_normal() -> Vector
        Returns the normal of the plane that constrains movement, enforced if the plane constraint is enabled.
        
        Returns:
            Vector:
        """
        ...
    def get_plane_constraint_axis_setting(self) -> PlaneConstraintAxisSetting:
        r"""
        x.get_plane_constraint_axis_setting() -> PlaneConstraintAxisSetting
        Get the plane constraint axis setting.
        
        Returns:
            PlaneConstraintAxisSetting:
        """
        ...
    def get_physics_volume(self) -> PhysicsVolume:
        r"""
        x.get_physics_volume() -> PhysicsVolume
        Returns the PhysicsVolume this MovementComponent is using, or the world's default physics volume if none. *
        
        Returns:
            PhysicsVolume:
        """
        ...
    def get_max_speed(self) -> float:
        r"""
        x.get_max_speed() -> float
        Returns maximum speed of component in current movement mode.
        
        Returns:
            float:
        """
        ...
    def get_gravity_z(self) -> float:
        r"""
        x.get_gravity_z() -> float
        Returns gravity that affects this component
        
        Returns:
            float:
        """
        ...
    def constrain_normal_to_plane(self, normal: Vector) -> Vector:
        r"""
        x.constrain_normal_to_plane(normal) -> Vector
        Constrain a normal vector (of unit length) to the plane constraint, if enabled.
        
        Args:
            normal (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def constrain_location_to_plane(self, location: Vector) -> Vector:
        r"""
        x.constrain_location_to_plane(location) -> Vector
        Constrain a position vector to the plane constraint, if enabled.
        
        Args:
            location (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def constrain_position_to_plane(self, location: Vector) -> Vector:
        r"""
        deprecated: 'constrain_position_to_plane' was renamed to 'constrain_location_to_plane'.
        """
        ...
    def constrain_direction_to_plane(self, direction: Vector) -> Vector:
        r"""
        x.constrain_direction_to_plane(direction) -> Vector
        Constrain a direction vector to the plane constraint, if enabled.
        see: SetPlaneConstraint
        
        Args:
            direction (Vector): 
        
        Returns:
            Vector:
        """
        ...

class NavMovementComponent(MovementComponent):
    r"""
    NavMovementComponent defines base functionality for MovementComponents that move any 'agent' that may be involved in AI pathfinding.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavMovementComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_register_physics_volume_updates`` (bool):  [Read-Write] If true, then applies the value of bComponentShouldUpdatePhysicsVolume to the UpdatedComponent. If false, will not change bShouldUpdatePhysicsVolume on the UpdatedComponent at all.
      see: bComponentShouldUpdatePhysicsVolume
    - ``auto_register_updated_component`` (bool):  [Read-Write] If true, registers the owner's Root component as the UpdatedComponent if there is not one currently assigned.
    - ``auto_update_tick_registration`` (bool):  [Read-Write] If true, whenever the updated component is changed, this component will enable or disable its tick dependent on whether it has something to update.
      This will NOT enable tick at startup if bAutoActivate is false, because presumably you have a good reason for not wanting it to start ticking initially.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_should_update_physics_volume`` (bool):  [Read-Write] If true, enables bShouldUpdatePhysicsVolume on the UpdatedComponent during initialization from SetUpdatedComponent(), otherwise disables such updates.
      Only enabled if bAutoRegisterPhysicsVolumeUpdates is true.
      WARNING: UpdatePhysicsVolume is potentially expensive if overlap events are also *disabled* because it requires a separate query against all physics volumes in the world.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_to_plane`` (bool):  [Read-Write] If true, movement will be constrained to a plane.
      see: PlaneConstraintNormal, PlaneConstraintOrigin, PlaneConstraintAxisSetting
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``fixed_path_braking_distance`` (float):  [Read-Write] Braking distance override used with acceleration driven path following (bUseAccelerationForPaths)
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``nav_agent_props`` (NavAgentProperties):  [Read-Write] Properties that define how the component can move.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``plane_constraint_axis_setting`` (PlaneConstraintAxisSetting):  [Read-Write] Setting that controls behavior when movement is restricted to a 2D plane defined by a specific axis/normal,
      so that movement along the locked axis is not be possible.
      see: SetPlaneConstraintAxisSetting
    - ``plane_constraint_normal`` (Vector):  [Read-Write] The normal or axis of the plane that constrains movement, if bConstrainToPlane is enabled.
      If for example you wanted to constrain movement to the X-Z plane (so that Y cannot change), the normal would be set to X=0 Y=1 Z=0.
      This is recalculated whenever PlaneConstraintAxisSetting changes. It is normalized once the component is registered with the game world.
      see: bConstrainToPlane, SetPlaneConstraintNormal(), SetPlaneConstraintFromVectors()
    - ``plane_constraint_origin`` (Vector):  [Read-Write] The origin of the plane that constrains movement, if plane constraint is enabled.
      This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
      see: bConstrainToPlane, SetPlaneConstraintOrigin().
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``snap_to_plane_at_start`` (bool):  [Read-Write] If true and plane constraints are enabled, then the updated component will be snapped to the plane when first attached.
    - ``tick_before_owner`` (bool):  [Read-Write] If true, after registration we will add a tick dependency to tick before our owner (if we can both tick).
      This is important when our tick causes an update in the owner's position, so that when the owner ticks it uses the most recent position without lag.
      Disabling this can improve performance if both objects tick but the order of ticks doesn't matter.
    - ``update_nav_agent_with_owners_collision`` (bool):  [Read-Write] If set to true NavAgentProps' radius and height will be updated with Owner's collision capsule size
    - ``update_only_if_rendered`` (bool):  [Read-Write] If true, skips TickComponent() if UpdatedComponent was not recently rendered.
    - ``updated_component`` (SceneComponent):  [Read-Write] The component we move and update.
      If this is null at startup and bAutoRegisterUpdatedComponent is true, the owning Actor's root component will automatically be set as our UpdatedComponent at startup.
      see: bAutoRegisterUpdatedComponent, SetUpdatedComponent(), UpdatedPrimitive
    - ``updated_primitive`` (PrimitiveComponent):  [Read-Write] UpdatedComponent, cast as a UPrimitiveComponent. May be invalid if UpdatedComponent was null or not a UPrimitiveComponent.
    - ``use_acceleration_for_paths`` (bool):  [Read-Write] If set, pathfollowing will control character movement via acceleration values. If false, it will set velocities directly.
    - ``use_fixed_braking_distance_for_paths`` (bool):  [Read-Write] If set, FixedPathBrakingDistance will be used for path following deceleration
    - ``velocity`` (Vector):  [Read-Write] Current velocity of updated component.
    """
    @property
    def nav_agent_props(self) -> NavAgentProperties:
        r"""
        (NavAgentProperties):  [Read-Write] Properties that define how the component can move.
        """
        ...
    @nav_agent_props.setter
    def nav_agent_props(self, value: NavAgentProperties) -> None:
        ...
    def stop_movement_keep_pathing(self) -> None:
        r"""
        x.stop_movement_keep_pathing() -> None
        Stops movement immediately (reset velocity) but keeps following current path
        """
        ...
    def stop_active_movement(self) -> None:
        r"""
        x.stop_active_movement() -> None
        Stops applying further movement (usually zeros acceleration).
        """
        ...
    def is_swimming(self) -> bool:
        r"""
        x.is_swimming() -> bool
        Returns true if currently swimming (moving through a fluid volume)
        
        Returns:
            bool:
        """
        ...
    def is_moving_on_ground(self) -> bool:
        r"""
        x.is_moving_on_ground() -> bool
        Returns true if currently moving on the ground (e.g. walking or driving)
        
        Returns:
            bool:
        """
        ...
    def is_flying(self) -> bool:
        r"""
        x.is_flying() -> bool
        Returns true if currently flying (moving through a non-fluid volume without resting on the ground)
        
        Returns:
            bool:
        """
        ...
    def is_falling(self) -> bool:
        r"""
        x.is_falling() -> bool
        Returns true if currently falling (not flying, in a non-fluid volume, and not on the ground)
        
        Returns:
            bool:
        """
        ...
    def is_crouching(self) -> bool:
        r"""
        x.is_crouching() -> bool
        Returns true if currently crouching
        
        Returns:
            bool:
        """
        ...

class PawnMovementComponent(NavMovementComponent):
    r"""
    PawnMovementComponent can be used to update movement for an associated Pawn.
    It also provides ways to accumulate and read directional input in a generic way (with AddInputVector(), ConsumeInputVector(), etc).
    see: APawn
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PawnMovementComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_register_physics_volume_updates`` (bool):  [Read-Write] If true, then applies the value of bComponentShouldUpdatePhysicsVolume to the UpdatedComponent. If false, will not change bShouldUpdatePhysicsVolume on the UpdatedComponent at all.
      see: bComponentShouldUpdatePhysicsVolume
    - ``auto_register_updated_component`` (bool):  [Read-Write] If true, registers the owner's Root component as the UpdatedComponent if there is not one currently assigned.
    - ``auto_update_tick_registration`` (bool):  [Read-Write] If true, whenever the updated component is changed, this component will enable or disable its tick dependent on whether it has something to update.
      This will NOT enable tick at startup if bAutoActivate is false, because presumably you have a good reason for not wanting it to start ticking initially.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_should_update_physics_volume`` (bool):  [Read-Write] If true, enables bShouldUpdatePhysicsVolume on the UpdatedComponent during initialization from SetUpdatedComponent(), otherwise disables such updates.
      Only enabled if bAutoRegisterPhysicsVolumeUpdates is true.
      WARNING: UpdatePhysicsVolume is potentially expensive if overlap events are also *disabled* because it requires a separate query against all physics volumes in the world.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_to_plane`` (bool):  [Read-Write] If true, movement will be constrained to a plane.
      see: PlaneConstraintNormal, PlaneConstraintOrigin, PlaneConstraintAxisSetting
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``fixed_path_braking_distance`` (float):  [Read-Write] Braking distance override used with acceleration driven path following (bUseAccelerationForPaths)
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``nav_agent_props`` (NavAgentProperties):  [Read-Write] Properties that define how the component can move.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``plane_constraint_axis_setting`` (PlaneConstraintAxisSetting):  [Read-Write] Setting that controls behavior when movement is restricted to a 2D plane defined by a specific axis/normal,
      so that movement along the locked axis is not be possible.
      see: SetPlaneConstraintAxisSetting
    - ``plane_constraint_normal`` (Vector):  [Read-Write] The normal or axis of the plane that constrains movement, if bConstrainToPlane is enabled.
      If for example you wanted to constrain movement to the X-Z plane (so that Y cannot change), the normal would be set to X=0 Y=1 Z=0.
      This is recalculated whenever PlaneConstraintAxisSetting changes. It is normalized once the component is registered with the game world.
      see: bConstrainToPlane, SetPlaneConstraintNormal(), SetPlaneConstraintFromVectors()
    - ``plane_constraint_origin`` (Vector):  [Read-Write] The origin of the plane that constrains movement, if plane constraint is enabled.
      This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
      see: bConstrainToPlane, SetPlaneConstraintOrigin().
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``snap_to_plane_at_start`` (bool):  [Read-Write] If true and plane constraints are enabled, then the updated component will be snapped to the plane when first attached.
    - ``tick_before_owner`` (bool):  [Read-Write] If true, after registration we will add a tick dependency to tick before our owner (if we can both tick).
      This is important when our tick causes an update in the owner's position, so that when the owner ticks it uses the most recent position without lag.
      Disabling this can improve performance if both objects tick but the order of ticks doesn't matter.
    - ``update_nav_agent_with_owners_collision`` (bool):  [Read-Write] If set to true NavAgentProps' radius and height will be updated with Owner's collision capsule size
    - ``update_only_if_rendered`` (bool):  [Read-Write] If true, skips TickComponent() if UpdatedComponent was not recently rendered.
    - ``updated_component`` (SceneComponent):  [Read-Write] The component we move and update.
      If this is null at startup and bAutoRegisterUpdatedComponent is true, the owning Actor's root component will automatically be set as our UpdatedComponent at startup.
      see: bAutoRegisterUpdatedComponent, SetUpdatedComponent(), UpdatedPrimitive
    - ``updated_primitive`` (PrimitiveComponent):  [Read-Write] UpdatedComponent, cast as a UPrimitiveComponent. May be invalid if UpdatedComponent was null or not a UPrimitiveComponent.
    - ``use_acceleration_for_paths`` (bool):  [Read-Write] If set, pathfollowing will control character movement via acceleration values. If false, it will set velocities directly.
    - ``use_fixed_braking_distance_for_paths`` (bool):  [Read-Write] If set, FixedPathBrakingDistance will be used for path following deceleration
    - ``velocity`` (Vector):  [Read-Write] Current velocity of updated component.
    """
    def is_move_input_ignored(self) -> bool:
        r"""
        x.is_move_input_ignored() -> bool
        Helper to see if move input is ignored. If there is no Pawn or UpdatedComponent, returns true, otherwise defers to the Pawn's implementation of IsMoveInputIgnored().
        
        Returns:
            bool:
        """
        ...
    def get_pending_input_vector(self) -> Vector:
        r"""
        x.get_pending_input_vector() -> Vector
        Return the pending input vector in world space. This is the most up-to-date value of the input vector, pending ConsumeMovementInputVector() which clears it.
        PawnMovementComponents implementing movement usually want to use either this or ConsumeInputVector() as these functions represent the most recent state of input.
        see: AddInputVector(), ConsumeInputVector(), GetLastInputVector()
        
        Returns:
            Vector: The pending input vector in world space.
        """
        ...
    def get_input_vector(self) -> Vector:
        r"""
        deprecated: 'get_input_vector' was renamed to 'get_pending_input_vector'.
        """
        ...
    def get_pawn_owner(self) -> Pawn:
        r"""
        x.get_pawn_owner() -> Pawn
        Return the Pawn that owns UpdatedComponent.
        
        Returns:
            Pawn:
        """
        ...
    def get_last_input_vector(self) -> Vector:
        r"""
        x.get_last_input_vector() -> Vector
        Return the last input vector in world space that was processed by ConsumeInputVector(), which is usually done by the Pawn or PawnMovementComponent.
        Any user that needs to know about the input that last affected movement should use this function.
        see: AddInputVector(), ConsumeInputVector(), GetPendingInputVector()
        
        Returns:
            Vector: The last input vector in world space that was processed by ConsumeInputVector().
        """
        ...
    def consume_input_vector(self) -> Vector:
        r"""
        x.consume_input_vector() -> Vector
        Returns the pending input vector and resets it to zero.
               * This should be used during a movement update (by the Pawn or PawnMovementComponent) to prevent accumulation of control input between frames.
               * Copies the pending input vector to the saved input vector (GetLastMovementInputVector()).
               *
        
        Returns:
            Vector: The pending input vector.
        """
        ...
    def add_input_vector(self, world_vector: Vector, force: bool = False) -> None:
        r"""
        x.add_input_vector(world_vector, force=False) -> None
        Adds the given vector to the accumulated input in world space. Input vectors are usually between 0 and 1 in magnitude.
        They are accumulated during a frame then applied as acceleration during the movement update.
        see: APawn::AddMovementInput()
        
        Args:
            world_vector (Vector): Direction in world space to apply input
            force (bool): If true always add the input, ignoring the result of IsMoveInputIgnored().
        """
        ...

class CharacterMovementComponent(PawnMovementComponent):
    r"""
    CharacterMovementComponent handles movement logic for the associated Character owner.
    It supports various movement modes including: walking, falling, swimming, flying, custom.
    
    Movement is affected primarily by current Velocity and Acceleration. Acceleration is updated each frame
    based on the input vector accumulated thus far (see UPawnMovementComponent::GetPendingInputVector()).
    
    Networking is fully implemented, with server-client correction and prediction included.
    see: ACharacter, UPawnMovementComponent
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Framework/Pawn/Character/
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CharacterMovementComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``air_control`` (float):  [Read-Write] When falling, amount of lateral movement control available to the character.
      0 = no control, 1 = full control at max speed of MaxWalkSpeed.
    - ``air_control_boost_multiplier`` (float):  [Read-Write] When falling, multiplier applied to AirControl when lateral velocity is less than AirControlBoostVelocityThreshold.
      Setting this to zero will disable air control boosting. Final result is clamped at 1.
    - ``air_control_boost_velocity_threshold`` (float):  [Read-Write] When falling, if lateral velocity magnitude is less than this value, AirControl is multiplied by AirControlBoostMultiplier.
      Setting this to zero will disable air control boosting.
    - ``allow_physics_rotation_during_anim_root_motion`` (bool):  [Read-Write]
    - ``always_check_floor`` (bool):  [Read-Write] Whether we always force floor checks for stationary Characters while walking.
      Normally floor checks are avoided if possible when not moving, but this can be used to force them if there are use-cases where they are being skipped erroneously
      (such as objects moving up into the character from below).
    - ``apply_gravity_while_jumping`` (bool):  [Read-Write] Apply gravity while the character is actively jumping (e.g. holding the jump key).
      Helps remove frame-rate dependent jump height, but may alter base jump height.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_register_physics_volume_updates`` (bool):  [Read-Write] If true, then applies the value of bComponentShouldUpdatePhysicsVolume to the UpdatedComponent. If false, will not change bShouldUpdatePhysicsVolume on the UpdatedComponent at all.
      see: bComponentShouldUpdatePhysicsVolume
    - ``auto_register_updated_component`` (bool):  [Read-Write] If true, registers the owner's Root component as the UpdatedComponent if there is not one currently assigned.
    - ``auto_update_tick_registration`` (bool):  [Read-Write] If true, whenever the updated component is changed, this component will enable or disable its tick dependent on whether it has something to update.
      This will NOT enable tick at startup if bAutoActivate is false, because presumably you have a good reason for not wanting it to start ticking initially.
    - ``avoidance_consideration_radius`` (float):  [Read-Write]
    - ``avoidance_group`` (NavAvoidanceMask):  [Read-Write] Moving actor's group mask
    - ``avoidance_uid`` (int32):  [Read-Only] No default value, for now it's assumed to be valid if GetAvoidanceManager() returns non-NULL.
    - ``avoidance_weight`` (float):  [Read-Write] De facto default value 0.5 (due to that being the default in the avoidance registration function), indicates RVO behavior.
    - ``based_movement_ignore_physics_base`` (bool):  [Read-Write] Property to set if UpdateBasedMovement should ignore collision with actors part of the current MovementBase, if the base is simulated by physics
    - ``braking_deceleration_falling`` (float):  [Read-Write] Lateral deceleration when falling and not applying acceleration.
      see: MaxAcceleration
    - ``braking_deceleration_flying`` (float):  [Read-Write] Deceleration when flying and not applying acceleration.
      see: MaxAcceleration
    - ``braking_deceleration_swimming`` (float):  [Read-Write] Deceleration when swimming and not applying acceleration.
      see: MaxAcceleration
    - ``braking_deceleration_walking`` (float):  [Read-Write] Deceleration when walking and not applying acceleration. This is a constant opposing force that directly lowers velocity by a constant value.
      see: GroundFriction, MaxAcceleration
    - ``braking_friction`` (float):  [Read-Write] Friction (drag) coefficient applied when braking (whenever Acceleration = 0, or if character is exceeding max speed); actual value used is this multiplied by BrakingFrictionFactor.
      When braking, this property allows you to control how much friction is applied when moving across the ground, applying an opposing force that scales with current velocity.
      Braking is composed of friction (velocity-dependent drag) and constant deceleration.
      This is the current value, used in all movement modes; if this is not desired, override it or bUseSeparateBrakingFriction when movement mode changes.
      note: Only used if bUseSeparateBrakingFriction setting is true, otherwise current friction such as GroundFriction is used.
      see: bUseSeparateBrakingFriction, BrakingFrictionFactor, GroundFriction, BrakingDecelerationWalking
    - ``braking_friction_factor`` (float):  [Read-Write] Factor used to multiply actual value of friction used when braking.
      This applies to any friction value that is currently used, which may depend on bUseSeparateBrakingFriction.
      note: This is 2 by default for historical reasons, a value of 1 gives the true drag equation.
      see: bUseSeparateBrakingFriction, GroundFriction, BrakingFriction
    - ``braking_sub_step_time`` (float):  [Read-Write] Time substepping when applying braking friction. Smaller time steps increase accuracy at the slight cost of performance, especially if there are large frame times.
    - ``buoyancy`` (float):  [Read-Write] Water buoyancy. A ratio (1.0 = neutral buoyancy, 0.0 = no buoyancy)
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``can_walk_off_ledges`` (bool):  [Read-Write] If true, Character can walk off a ledge.
    - ``can_walk_off_ledges_when_crouching`` (bool):  [Read-Write] If true, Character can walk off a ledge when crouching.
    - ``component_should_update_physics_volume`` (bool):  [Read-Write] If true, enables bShouldUpdatePhysicsVolume on the UpdatedComponent during initialization from SetUpdatedComponent(), otherwise disables such updates.
      Only enabled if bAutoRegisterPhysicsVolumeUpdates is true.
      WARNING: UpdatePhysicsVolume is potentially expensive if overlap events are also *disabled* because it requires a separate query against all physics volumes in the world.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_to_plane`` (bool):  [Read-Write] If true, movement will be constrained to a plane.
      see: PlaneConstraintNormal, PlaneConstraintOrigin, PlaneConstraintAxisSetting
    - ``crouch_maintains_base_location`` (bool):  [Read-Only] If true, crouching should keep the base of the capsule in place by lowering the center of the shrunken capsule. If false, the base of the capsule moves up and the center stays in place.
      The same behavior applies when the character uncrouches: if true, the base is kept in the same location and the center moves up. If false, the capsule grows and only moves up if the base impacts something.
      By default this variable is set when the movement mode changes: set to true when walking and false otherwise. Feel free to override the behavior when the movement mode changes.
    - ``crouched_half_height`` (float):  [Read-Write]
    - ``current_floor`` (FindFloorResult):  [Read-Only] Information about the floor the Character is standing on (updated only during walking movement).
    - ``custom_movement_mode`` (uint8):  [Read-Write] Current custom sub-mode if MovementMode is set to Custom.
      This is automatically replicated through the Character owner and for client-server movement functions.
      see: SetMovementMode()
    - ``default_land_movement_mode`` (MovementMode):  [Read-Write] Default movement mode when not in water. Used at player startup or when teleported.
      see: DefaultWaterMovementMode
      see: bRunPhysicsWithNoController
    - ``default_water_movement_mode`` (MovementMode):  [Read-Write] Default movement mode when in water. Used at player startup or when teleported.
      see: DefaultLandMovementMode
      see: bRunPhysicsWithNoController
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_physics_interaction`` (bool):  [Read-Write] If enabled, the player will interact with physics objects when walking into them.
    - ``enable_scoped_movement_updates`` (bool):  [Read-Write] If true, high-level movement updates will be wrapped in a movement scope that accumulates updates and defers a bulk of the work until the end.
      When enabled, touch and hit events will not be triggered until the end of multiple moves within an update, which can improve performance.
      see: FScopedMovementUpdate
    - ``enable_server_dual_move_scoped_movement_updates`` (bool):  [Read-Write] Optional scoped movement update to combine moves for cheaper performance on the server when the client sends two moves in one packet.
      Be warned that since this wraps a larger scope than is normally done with bEnableScopedMovementUpdates, this can result in subtle changes in behavior
      in regards to when overlap events are handled, when attached components are moved, etc.
      see: bEnableScopedMovementUpdates
    - ``falling_lateral_friction`` (float):  [Read-Write] Friction to apply to lateral air movement when falling.
      If bUseSeparateBrakingFriction is false, also affects the ability to stop more quickly when braking (whenever Acceleration is zero).
      see: BrakingFriction, bUseSeparateBrakingFriction
    - ``fixed_path_braking_distance`` (float):  [Read-Write] Braking distance override used with acceleration driven path following (bUseAccelerationForPaths)
    - ``force_next_floor_check`` (bool):  [Read-Only] Force the Character in MOVE_Walking to do a check for a valid floor even if it hasn't moved. Cleared after next floor check.
      Normally if bAlwaysCheckFloor is false we try to avoid the floor check unless some conditions are met, but this can be used to force the next check to always run.
    - ``former_base_velocity_decay_half_life`` (float):  [Read-Write] When applying a root motion override while falling off a moving object, this controls how long it takes to lose half the former base's velocity (in seconds).
      Set to 0 to ignore former bases (default).
      Set to -1 for no decay.
      Any other positive value sets the half-life for exponential decay.
    - ``gravity_direction`` (Vector):  [Read-Only] A normalized vector representing the direction of gravity for gravity relative movement modes: walking, falling,
      and custom movement modes. Gravity direction remaps player input as being within the plane defined by the gravity
      direction. Movement simulation values like velocity and acceleration are maintained in their existing world coordinate
      space but are transformed internally as gravity relative (for instance moving forward up a vertical wall that gravity is
      defined to be perpendicular to and jump "up" from that wall). If ShouldRemainVertical() is true the character's capsule
      will be oriented to align with the gravity direction.
    - ``gravity_scale`` (float):  [Read-Write] Custom gravity scale. Gravity is multiplied by this amount for the character.
    - ``gravity_to_world_transform`` (Quat):  [Read-Only] A cached quaternion representing the inverse rotation from world space to gravity relative space defined by GravityDirection.
    - ``ground_friction`` (float):  [Read-Write] Setting that affects movement control. Higher values allow faster changes in direction.
      If bUseSeparateBrakingFriction is false, also affects the ability to stop more quickly when braking (whenever Acceleration is zero), where it is multiplied by BrakingFrictionFactor.
      When braking, this property allows you to control how much friction is applied when moving across the ground, applying an opposing force that scales with current velocity.
      This can be used to simulate slippery surfaces such as ice or oil by changing the value (possibly based on the material pawn is standing on).
      see: BrakingDecelerationWalking, BrakingFriction, bUseSeparateBrakingFriction, BrakingFrictionFactor
    - ``groups_to_avoid`` (NavAvoidanceMask):  [Read-Write] Will avoid other agents if they are in one of specified groups
    - ``groups_to_ignore`` (NavAvoidanceMask):  [Read-Write] Will NOT avoid other agents if they are in one of specified groups, higher priority than GroupsToAvoid
    - ``ignore_base_rotation`` (bool):  [Read-Write] Whether the character ignores changes in rotation of the base it is standing on.
      If true, the character maintains current world rotation.
      If false, the character rotates with the moving base.
    - ``ignore_client_movement_error_checks_and_correction`` (bool):  [Read-Write] If true, we should ignore server location difference checks for client error on this movement component.
      This can be useful when character is moving at extreme speeds for a duration and you need it to look
      smooth on clients without the server correcting the client. Make sure to disable when done, as this would
      break this character's server-client movement correction.
      see: bServerAcceptClientAuthoritativePosition, ServerCheckClientError()
    - ``impart_base_angular_velocity`` (bool):  [Read-Write] If true, impart the base component's tangential components of angular velocity when jumping or falling off it.
      Only those components of the velocity allowed by the separate component settings (bImpartBaseVelocityX etc) will be applied.
      see: bImpartBaseVelocityX, bImpartBaseVelocityY, bImpartBaseVelocityZ
    - ``impart_base_velocity_x`` (bool):  [Read-Write] If true, impart the base actor's X velocity when falling off it (which includes jumping)
    - ``impart_base_velocity_y`` (bool):  [Read-Write] If true, impart the base actor's Y velocity when falling off it (which includes jumping)
    - ``impart_base_velocity_z`` (bool):  [Read-Write] If true, impart the base actor's Z velocity when falling off it (which includes jumping)
    - ``initial_push_force_factor`` (float):  [Read-Write] Initial impulse force to apply when the player bounces into a blocking physics object.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``jump_off_jump_z_factor`` (float):  [Read-Write] Fraction of JumpZVelocity to use when automatically "jumping off" of a base actor that's not allowed to be a base for a character. (For example, if you're not allowed to stand on other players.)
    - ``jump_out_of_water_pitch`` (float):  [Read-Write] When exiting water, jump if control pitch angle is this high or above.
    - ``jump_z_velocity`` (float):  [Read-Write] Initial velocity (instantaneous vertical acceleration) when jumping.
    - ``just_teleported`` (bool):  [Read-Only] Used by movement code to determine if a change in position is based on normal movement or a teleport. If not a teleport, velocity can be recomputed based on the change in position.
    - ``ledge_check_threshold`` (float):  [Read-Write] Used in determining if pawn is going off ledge.  If the ledge is "shorter" than this value then the pawn will be able to walk off it. *
    - ``listen_server_network_simulated_smooth_location_time`` (float):  [Read-Write] Similar setting as NetworkSimulatedSmoothLocationTime but only used on Listen servers.
    - ``listen_server_network_simulated_smooth_rotation_time`` (float):  [Read-Write] Similar setting as NetworkSimulatedSmoothRotationTime but only used on Listen servers.
    - ``maintain_horizontal_ground_velocity`` (bool):  [Read-Write] If true, walking movement always maintains horizontal velocity when moving up ramps, which causes movement up ramps to be faster parallel to the ramp surface.
      If false, then walking movement maintains velocity magnitude parallel to the ramp surface.
    - ``mass`` (float):  [Read-Write] Mass of pawn (for when momentum is imparted to it).
    - ``max_acceleration`` (float):  [Read-Write] Max Acceleration (rate of change of velocity)
    - ``max_custom_movement_speed`` (float):  [Read-Write] The maximum speed when using Custom movement mode.
    - ``max_depenetration_with_geometry`` (float):  [Read-Write] Max distance we allow simulated proxies to depenetrate when moving out of anything but Pawns.
      This is generally more tolerant than with Pawns, because other geometry is either not moving, or is moving predictably with a bit of delay compared to on the server.
      see: MaxDepenetrationWithGeometryAsProxy, MaxDepenetrationWithPawn, MaxDepenetrationWithPawnAsProxy
    - ``max_depenetration_with_geometry_as_proxy`` (float):  [Read-Write] Max distance we allow simulated proxies to depenetrate when moving out of anything but Pawns.
      This is generally more tolerant than with Pawns, because other geometry is either not moving, or is moving predictably with a bit of delay compared to on the server.
      see: MaxDepenetrationWithGeometry, MaxDepenetrationWithPawn, MaxDepenetrationWithPawnAsProxy
    - ``max_depenetration_with_pawn`` (float):  [Read-Write] Max distance we are allowed to depenetrate when moving out of other Pawns.
      see: MaxDepenetrationWithGeometry, MaxDepenetrationWithGeometryAsProxy, MaxDepenetrationWithPawnAsProxy
    - ``max_depenetration_with_pawn_as_proxy`` (float):  [Read-Write] Max distance we allow simulated proxies to depenetrate when moving out of other Pawns.
      Typically we don't want a large value, because we receive a server authoritative position that we should not then ignore by pushing them out of the local player.
      see: MaxDepenetrationWithGeometry, MaxDepenetrationWithGeometryAsProxy, MaxDepenetrationWithPawn
    - ``max_fly_speed`` (float):  [Read-Write] The maximum flying speed.
    - ``max_jump_apex_attempts_per_simulation`` (int32):  [Read-Write] Max number of attempts per simulation to attempt to exactly reach the jump apex when falling movement reaches the top of the arc.
      Limiting this prevents deep recursion when special cases cause collision or other conditions which reactivate the apex condition.
    - ``max_out_of_water_step_height`` (float):  [Read-Write] Maximum step height for getting out of water
    - ``max_simulation_iterations`` (int32):  [Read-Write] Max number of iterations used for each discrete simulation step.
      Used primarily in the the more advanced movement modes that break up larger time steps (usually those applying gravity such as falling and walking).
      Increasing this value can address issues with fast-moving objects or complex collision scenarios, at the cost of performance.
      
      WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
      see: MaxSimulationTimeStep
    - ``max_simulation_time_step`` (float):  [Read-Write] Max time delta for each discrete simulation step.
      Used primarily in the the more advanced movement modes that break up larger time steps (usually those applying gravity such as falling and walking).
      Lowering this value can address issues with fast-moving objects or complex collision scenarios, at the cost of performance.
      
      WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
      see: MaxSimulationIterations
    - ``max_step_height`` (float):  [Read-Write] Maximum height character can step up
    - ``max_swim_speed`` (float):  [Read-Write] The maximum swimming speed.
    - ``max_touch_force`` (float):  [Read-Write] Maximum force applied to touched physics objects. If < 0.0f, there is no maximum.
    - ``max_walk_speed`` (float):  [Read-Write] The maximum ground speed when walking. Also determines maximum lateral speed when falling.
    - ``max_walk_speed_crouched`` (float):  [Read-Write] The maximum ground speed when walking and crouched.
    - ``min_analog_walk_speed`` (float):  [Read-Write] The ground speed that we should accelerate up to when walking at minimum analog stick tilt
    - ``min_touch_force`` (float):  [Read-Write] Minimum Force applied to touched physics objects. If < 0.0f, there is no minimum.
    - ``movement_mode`` (MovementMode):  [Read-Write] Actor's current movement mode (walking, falling, etc).
         - walking:  Walking on a surface, under the effects of friction, and able to "step up" barriers. Vertical velocity is zero.
         - falling:  Falling under the effects of gravity, after jumping or walking off the edge of a surface.
         - flying:   Flying, ignoring the effects of gravity.
         - swimming: Swimming through a fluid volume, under the effects of gravity and buoyancy.
         - custom:   User-defined custom movement mode, including many possible sub-modes.
      This is automatically replicated through the Character owner and for client-server movement functions.
      see: SetMovementMode(), CustomMovementMode
    - ``nav_agent_props`` (NavAgentProperties):  [Read-Write] Properties that define how the component can move.
    - ``nav_mesh_projection_height_scale_down`` (float):  [Read-Write] Scale of the total capsule height to use for projection from navmesh to underlying geometry in the downward direction.
      In other words, trace down to [CapsuleHeight * NavMeshProjectionHeightScaleDown] below nav mesh.
    - ``nav_mesh_projection_height_scale_up`` (float):  [Read-Write] Scale of the total capsule height to use for projection from navmesh to underlying geometry in the upward direction.
      In other words, start the trace at [CapsuleHeight * NavMeshProjectionHeightScaleUp] above nav mesh.
    - ``nav_mesh_projection_interp_speed`` (float):  [Read-Write] Speed at which to interpolate agent navmesh offset between traces. 0: Instant (no interp) > 0: Interp speed")
    - ``nav_mesh_projection_interval`` (float):  [Read-Write] How often we should raycast to project from navmesh to underlying geometry
    - ``nav_walking_floor_dist_tolerance`` (float):  [Read-Write] Ignore small differences in ground height between server and client data during NavWalking mode
    - ``net_proxy_shrink_half_height`` (float):  [Read-Write] Shrink simulated proxy capsule half height by this amount, to account for network rounding that may cause encroachment. Changing during gameplay is not supported.
      see: AdjustProxyCapsuleSize()
    - ``net_proxy_shrink_radius`` (float):  [Read-Write] Shrink simulated proxy capsule radius by this amount, to account for network rounding that may cause encroachment. Changing during gameplay is not supported.
      see: AdjustProxyCapsuleSize()
    - ``network_always_replicate_transform_update_timestamp`` (bool):  [Read-Write] Flag used on the server to determine whether to always replicate ReplicatedServerLastTransformUpdateTimeStamp to clients.
      Normally this is only sent when the network smoothing mode on character movement is set to Linear smoothing (on the server), to save bandwidth.
      Setting this to true will force the timestamp to replicate regardless, in case the server doesn't know about the smoothing mode, or if the timestamp is used for another purpose.
    - ``network_large_client_correction_distance`` (float):  [Read-Write] If client error is larger than this, sets bNetworkLargeClientCorrection to reduce delay between client adjustments.
      see: NetworkMinTimeBetweenClientAdjustments, NetworkMinTimeBetweenClientAdjustmentsLargeCorrection
    - ``network_max_smooth_update_distance`` (float):  [Read-Write] Maximum distance character is allowed to lag behind server location when interpolating between updates.
    - ``network_min_time_between_client_ack_good_moves`` (float):  [Read-Write] Minimum time on the server between acknowledging good client moves. This can save on bandwidth. Set to 0 to disable throttling.
    - ``network_min_time_between_client_adjustments`` (float):  [Read-Write] Minimum time on the server between sending client adjustments when client has exceeded allowable position error.
      Should be >= NetworkMinTimeBetweenClientAdjustmentsLargeCorrection (the larger value is used regardless).
      This can save on bandwidth. Set to 0 to disable throttling.
      see: ServerLastClientAdjustmentTime
    - ``network_min_time_between_client_adjustments_large_correction`` (float):  [Read-Write] Minimum time on the server between sending client adjustments when client has exceeded allowable position error by a large amount (NetworkLargeClientCorrectionDistance).
      Should be <= NetworkMinTimeBetweenClientAdjustments (the smaller value is used regardless).
      see: NetworkMinTimeBetweenClientAdjustments
    - ``network_no_smooth_update_distance`` (float):  [Read-Write] Maximum distance beyond which character is teleported to the new server location without any smoothing.
    - ``network_simulated_smooth_location_time`` (float):  [Read-Write] How long to take to smoothly interpolate from the old pawn position on the client to the corrected one sent by the server. Not used by Linear smoothing.
    - ``network_simulated_smooth_rotation_time`` (float):  [Read-Write] How long to take to smoothly interpolate from the old pawn rotation on the client to the corrected one sent by the server. Not used by Linear smoothing.
    - ``network_skip_proxy_prediction_on_net_update`` (bool):  [Read-Write] Whether we skip prediction on frames where a proxy receives a network update. This can avoid expensive prediction on those frames,
      with the side-effect of predicting with a frame of additional latency.
    - ``network_smoothing_mode`` (NetworkSmoothingMode):  [Read-Write] Smoothing mode for simulated proxies in network game.
    - ``notify_apex`` (bool):  [Read-Only] If true, event NotifyJumpApex() to CharacterOwner's controller when at apex of jump. Is cleared when event is triggered.
      By default this is off, and if you want the event to fire you typically set it to true when movement mode changes to "Falling" from another mode (see OnMovementModeChanged).
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``orient_rotation_to_movement`` (bool):  [Read-Write] If true, rotate the Character toward the direction of acceleration, using RotationRate as the rate of rotation change. Overrides UseControllerDesiredRotation.
      Normally you will want to make sure that other settings are cleared, such as bUseControllerRotationYaw on the Character.
    - ``outof_water_z`` (float):  [Read-Write] Z velocity applied when pawn tries to get out of water
    - ``perch_additional_height`` (float):  [Read-Write] When perching on a ledge, add this additional distance to MaxStepHeight when determining how high above a walkable floor we can perch.
      Note that we still enforce MaxStepHeight to start the step up; this just allows the character to hang off the edge or step slightly higher off the floor.
      (
      see: PerchRadiusThreshold)
    - ``perch_radius_threshold`` (float):  [Read-Write] Don't allow the character to perch on the edge of a surface if the contact is this close to the edge of the capsule.
      Note that characters will not fall off if they are within MaxStepHeight of a walkable surface below.
    - ``plane_constraint_axis_setting`` (PlaneConstraintAxisSetting):  [Read-Write] Setting that controls behavior when movement is restricted to a 2D plane defined by a specific axis/normal,
      so that movement along the locked axis is not be possible.
      see: SetPlaneConstraintAxisSetting
    - ``plane_constraint_normal`` (Vector):  [Read-Write] The normal or axis of the plane that constrains movement, if bConstrainToPlane is enabled.
      If for example you wanted to constrain movement to the X-Z plane (so that Y cannot change), the normal would be set to X=0 Y=1 Z=0.
      This is recalculated whenever PlaneConstraintAxisSetting changes. It is normalized once the component is registered with the game world.
      see: bConstrainToPlane, SetPlaneConstraintNormal(), SetPlaneConstraintFromVectors()
    - ``plane_constraint_origin`` (Vector):  [Read-Write] The origin of the plane that constrains movement, if plane constraint is enabled.
      This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
      see: bConstrainToPlane, SetPlaneConstraintOrigin().
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``project_nav_mesh_on_both_world_channels`` (bool):  [Read-Write] Use both WorldStatic and WorldDynamic channels for NavWalking geometry conforming
    - ``project_nav_mesh_walking`` (bool):  [Read-Write] Whether to raycast to underlying geometry to better conform navmesh-walking characters
    - ``push_force_factor`` (float):  [Read-Write] Force to apply when the player collides with a blocking physics object.
    - ``push_force_point_z_offset_factor`` (float):  [Read-Write] Z-Offset for the position the force is applied to. 0.0f is the center of the physics object, 1.0f is the top and -1.0f is the bottom of the object.
    - ``push_force_scaled_to_mass`` (bool):  [Read-Write] If enabled, the PushForceFactor is applied per kg mass of the affected object.
    - ``push_force_using_z_offset`` (bool):  [Read-Write] If enabled, the PushForce location is moved using PushForcePointZOffsetFactor. Otherwise simply use the impact point.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``repulsion_force`` (float):  [Read-Write] Force per kg applied constantly to all overlapping components.
    - ``requested_move_use_acceleration`` (bool):  [Read-Write] Should use acceleration for path following?
      If true, acceleration is applied when path following to reach the target velocity.
      If false, path following velocity is set directly, disregarding acceleration.
    - ``rotation_rate`` (Rotator):  [Read-Write] Change in rotation per second, used when UseControllerDesiredRotation or OrientRotationToMovement are true. Set a negative value for infinite rotation rate and instant turns.
    - ``run_physics_with_no_controller`` (bool):  [Read-Write] If true, movement will be performed even if there is no Controller for the Character owner.
      Normally without a Controller, movement will be aborted and velocity and acceleration are zeroed if the character is walking.
      Characters that are spawned without a Controller but with this flag enabled will initialize the movement mode to DefaultLandMovementMode or DefaultWaterMovementMode appropriately.
      see: DefaultLandMovementMode, DefaultWaterMovementMode
    - ``scale_push_force_to_velocity`` (bool):  [Read-Write] If enabled, the applied push force will try to get the physics object to the same velocity than the player, not faster. This will only
                    scale the force down, it will never apply more force than defined by PushForceFactor.
    - ``server_accept_client_authoritative_position`` (bool):  [Read-Write] If true, and server does not detect client position error, server will copy the client movement location/velocity/etc after simulating the move.
      This can be useful for short bursts of movement that are difficult to sync over the network.
      Note that if bIgnoreClientMovementErrorChecksAndCorrection is used, this means the server will not detect an error.
      Also see GameNetworkManager->ClientAuthorativePosition which permanently enables this behavior.
      see: bIgnoreClientMovementErrorChecksAndCorrection, ServerShouldUseAuthoritativePosition()
    - ``snap_to_plane_at_start`` (bool):  [Read-Write] If true and plane constraints are enabled, then the updated component will be snapped to the plane when first attached.
    - ``standing_downward_force_scale`` (float):  [Read-Write] Force applied to objects we stand on (due to Mass and Gravity) is scaled by this amount.
    - ``stay_based_in_air`` (bool):  [Read-Write] Property to set if characters should stay based on objects while jumping
    - ``stay_based_in_air_height`` (float):  [Read-Write] Property used to set how high above base characters should stay based on objects while jumping if bStayBasedInAir is set
    - ``sweep_while_nav_walking`` (bool):  [Read-Write] Whether or not the character should sweep for collision geometry while walking.
      see: USceneComponent::MoveComponent.
    - ``tick_before_owner`` (bool):  [Read-Write] If true, after registration we will add a tick dependency to tick before our owner (if we can both tick).
      This is important when our tick causes an update in the owner's position, so that when the owner ticks it uses the most recent position without lag.
      Disabling this can improve performance if both objects tick but the order of ticks doesn't matter.
    - ``touch_force_factor`` (float):  [Read-Write] Force to apply to physics objects that are touched by the player.
    - ``touch_force_scaled_to_mass`` (bool):  [Read-Write] If enabled, the TouchForceFactor is applied per kg mass of the affected object.
    - ``update_nav_agent_with_owners_collision`` (bool):  [Read-Write] If set to true NavAgentProps' radius and height will be updated with Owner's collision capsule size
    - ``update_only_if_rendered`` (bool):  [Read-Write] If true, skips TickComponent() if UpdatedComponent was not recently rendered.
    - ``updated_component`` (SceneComponent):  [Read-Write] The component we move and update.
      If this is null at startup and bAutoRegisterUpdatedComponent is true, the owning Actor's root component will automatically be set as our UpdatedComponent at startup.
      see: bAutoRegisterUpdatedComponent, SetUpdatedComponent(), UpdatedPrimitive
    - ``updated_primitive`` (PrimitiveComponent):  [Read-Write] UpdatedComponent, cast as a UPrimitiveComponent. May be invalid if UpdatedComponent was null or not a UPrimitiveComponent.
    - ``use_acceleration_for_paths`` (bool):  [Read-Write] If set, pathfollowing will control character movement via acceleration values. If false, it will set velocities directly.
    - ``use_controller_desired_rotation`` (bool):  [Read-Write] If true, smoothly rotate the Character toward the Controller's desired rotation (typically Controller->ControlRotation), using RotationRate as the rate of rotation change. Overridden by OrientRotationToMovement.
      Normally you will want to make sure that other settings are cleared, such as bUseControllerRotationYaw on the Character.
    - ``use_fixed_braking_distance_for_paths`` (bool):  [Read-Write] If set, FixedPathBrakingDistance will be used for path following deceleration
    - ``use_flat_base_for_floor_checks`` (bool):  [Read-Write] Performs floor checks as if the character is using a shape with a flat base.
      This avoids the situation where characters slowly lower off the side of a ledge (as their capsule 'balances' on the edge).
    - ``use_rvo_avoidance`` (bool):  [Read-Write] If set, component will use RVO avoidance. This only runs on the server.
    - ``use_separate_braking_friction`` (bool):  [Read-Write] If true, BrakingFriction will be used to slow the character to a stop (when there is no Acceleration).
      If false, braking uses the same friction passed to CalcVelocity() (ie GroundFriction when walking), multiplied by BrakingFrictionFactor.
      This setting applies to all movement modes; if only desired in certain modes, consider toggling it when movement modes change.
      see: BrakingFriction
    - ``velocity`` (Vector):  [Read-Write] Current velocity of updated component.
    - ``walkable_floor_angle`` (float):  [Read-Write] Max angle in degrees of a walkable surface. Any greater than this and it is too steep to be walkable.
    - ``walkable_floor_z`` (float):  [Read-Only] Minimum Z value for floor normal. If less, not a walkable surface. Computed from WalkableFloorAngle.
    - ``wants_to_crouch`` (bool):  [Read-Only] If true, try to crouch (or keep crouching) on next update. If false, try to stop crouching on next update.
    - ``world_to_gravity_transform`` (Quat):  [Read-Only] A cached quaternion representing the rotation from world space to gravity relative space defined by GravityDirection.
    """
    @property
    def gravity_scale(self) -> float:
        r"""
        (float):  [Read-Write] Custom gravity scale. Gravity is multiplied by this amount for the character.
        """
        ...
    @gravity_scale.setter
    def gravity_scale(self, value: float) -> None:
        ...
    @property
    def max_step_height(self) -> float:
        r"""
        (float):  [Read-Write] Maximum height character can step up
        """
        ...
    @max_step_height.setter
    def max_step_height(self, value: float) -> None:
        ...
    @property
    def jump_z_velocity(self) -> float:
        r"""
        (float):  [Read-Write] Initial velocity (instantaneous vertical acceleration) when jumping.
        """
        ...
    @jump_z_velocity.setter
    def jump_z_velocity(self, value: float) -> None:
        ...
    @property
    def jump_z(self) -> float:
        r"""
        deprecated: 'jump_z' was renamed to 'jump_z_velocity'.
        """
        ...
    @jump_z.setter
    def jump_z(self, value: float) -> None:
        ...
    @property
    def jump_off_jump_z_factor(self) -> float:
        r"""
        (float):  [Read-Write] Fraction of JumpZVelocity to use when automatically "jumping off" of a base actor that's not allowed to be a base for a character. (For example, if you're not allowed to stand on other players.)
        """
        ...
    @jump_off_jump_z_factor.setter
    def jump_off_jump_z_factor(self, value: float) -> None:
        ...
    @property
    def gravity_direction(self) -> Vector:
        r"""
        (Vector):  [Read-Only] A normalized vector representing the direction of gravity for gravity relative movement modes: walking, falling,
        and custom movement modes. Gravity direction remaps player input as being within the plane defined by the gravity
        direction. Movement simulation values like velocity and acceleration are maintained in their existing world coordinate
        space but are transformed internally as gravity relative (for instance moving forward up a vertical wall that gravity is
        defined to be perpendicular to and jump "up" from that wall). If ShouldRemainVertical() is true the character's capsule
        will be oriented to align with the gravity direction.
        """
        ...
    @property
    def world_to_gravity_transform(self) -> Quat:
        r"""
        (Quat):  [Read-Only] A cached quaternion representing the rotation from world space to gravity relative space defined by GravityDirection.
        """
        ...
    @property
    def gravity_to_world_transform(self) -> Quat:
        r"""
        (Quat):  [Read-Only] A cached quaternion representing the inverse rotation from world space to gravity relative space defined by GravityDirection.
        """
        ...
    @property
    def movement_mode(self) -> MovementMode:
        r"""
        (MovementMode):  [Read-Only] Actor's current movement mode (walking, falling, etc).
           - walking:  Walking on a surface, under the effects of friction, and able to "step up" barriers. Vertical velocity is zero.
           - falling:  Falling under the effects of gravity, after jumping or walking off the edge of a surface.
           - flying:   Flying, ignoring the effects of gravity.
           - swimming: Swimming through a fluid volume, under the effects of gravity and buoyancy.
           - custom:   User-defined custom movement mode, including many possible sub-modes.
        This is automatically replicated through the Character owner and for client-server movement functions.
        see: SetMovementMode(), CustomMovementMode
        """
        ...
    @property
    def custom_movement_mode(self) -> int:
        r"""
        (uint8):  [Read-Only] Current custom sub-mode if MovementMode is set to Custom.
        This is automatically replicated through the Character owner and for client-server movement functions.
        see: SetMovementMode()
        """
        ...
    @property
    def network_smoothing_mode(self) -> NetworkSmoothingMode:
        r"""
        (NetworkSmoothingMode):  [Read-Only] Smoothing mode for simulated proxies in network game.
        """
        ...
    @property
    def ground_friction(self) -> float:
        r"""
        (float):  [Read-Write] Setting that affects movement control. Higher values allow faster changes in direction.
        If bUseSeparateBrakingFriction is false, also affects the ability to stop more quickly when braking (whenever Acceleration is zero), where it is multiplied by BrakingFrictionFactor.
        When braking, this property allows you to control how much friction is applied when moving across the ground, applying an opposing force that scales with current velocity.
        This can be used to simulate slippery surfaces such as ice or oil by changing the value (possibly based on the material pawn is standing on).
        see: BrakingDecelerationWalking, BrakingFriction, bUseSeparateBrakingFriction, BrakingFrictionFactor
        """
        ...
    @ground_friction.setter
    def ground_friction(self, value: float) -> None:
        ...
    @property
    def max_walk_speed(self) -> float:
        r"""
        (float):  [Read-Write] The maximum ground speed when walking. Also determines maximum lateral speed when falling.
        """
        ...
    @max_walk_speed.setter
    def max_walk_speed(self, value: float) -> None:
        ...
    @property
    def ground_speed(self) -> float:
        r"""
        deprecated: 'ground_speed' was renamed to 'max_walk_speed'.
        """
        ...
    @ground_speed.setter
    def ground_speed(self, value: float) -> None:
        ...
    @property
    def max_walk_speed_crouched(self) -> float:
        r"""
        (float):  [Read-Write] The maximum ground speed when walking and crouched.
        """
        ...
    @max_walk_speed_crouched.setter
    def max_walk_speed_crouched(self, value: float) -> None:
        ...
    @property
    def max_swim_speed(self) -> float:
        r"""
        (float):  [Read-Write] The maximum swimming speed.
        """
        ...
    @max_swim_speed.setter
    def max_swim_speed(self, value: float) -> None:
        ...
    @property
    def water_speed(self) -> float:
        r"""
        deprecated: 'water_speed' was renamed to 'max_swim_speed'.
        """
        ...
    @water_speed.setter
    def water_speed(self, value: float) -> None:
        ...
    @property
    def max_fly_speed(self) -> float:
        r"""
        (float):  [Read-Write] The maximum flying speed.
        """
        ...
    @max_fly_speed.setter
    def max_fly_speed(self, value: float) -> None:
        ...
    @property
    def air_speed(self) -> float:
        r"""
        deprecated: 'air_speed' was renamed to 'max_fly_speed'.
        """
        ...
    @air_speed.setter
    def air_speed(self, value: float) -> None:
        ...
    @property
    def max_custom_movement_speed(self) -> float:
        r"""
        (float):  [Read-Write] The maximum speed when using Custom movement mode.
        """
        ...
    @max_custom_movement_speed.setter
    def max_custom_movement_speed(self, value: float) -> None:
        ...
    @property
    def max_acceleration(self) -> float:
        r"""
        (float):  [Read-Write] Max Acceleration (rate of change of velocity)
        """
        ...
    @max_acceleration.setter
    def max_acceleration(self, value: float) -> None:
        ...
    @property
    def accel_rate(self) -> float:
        r"""
        deprecated: 'accel_rate' was renamed to 'max_acceleration'.
        """
        ...
    @accel_rate.setter
    def accel_rate(self, value: float) -> None:
        ...
    @property
    def min_analog_walk_speed(self) -> float:
        r"""
        (float):  [Read-Write] The ground speed that we should accelerate up to when walking at minimum analog stick tilt
        """
        ...
    @min_analog_walk_speed.setter
    def min_analog_walk_speed(self, value: float) -> None:
        ...
    @property
    def braking_friction_factor(self) -> float:
        r"""
        (float):  [Read-Write] Factor used to multiply actual value of friction used when braking.
        This applies to any friction value that is currently used, which may depend on bUseSeparateBrakingFriction.
        note: This is 2 by default for historical reasons, a value of 1 gives the true drag equation.
        see: bUseSeparateBrakingFriction, GroundFriction, BrakingFriction
        """
        ...
    @braking_friction_factor.setter
    def braking_friction_factor(self, value: float) -> None:
        ...
    @property
    def braking_friction(self) -> float:
        r"""
        (float):  [Read-Write] Friction (drag) coefficient applied when braking (whenever Acceleration = 0, or if character is exceeding max speed); actual value used is this multiplied by BrakingFrictionFactor.
        When braking, this property allows you to control how much friction is applied when moving across the ground, applying an opposing force that scales with current velocity.
        Braking is composed of friction (velocity-dependent drag) and constant deceleration.
        This is the current value, used in all movement modes; if this is not desired, override it or bUseSeparateBrakingFriction when movement mode changes.
        note: Only used if bUseSeparateBrakingFriction setting is true, otherwise current friction such as GroundFriction is used.
        see: bUseSeparateBrakingFriction, BrakingFrictionFactor, GroundFriction, BrakingDecelerationWalking
        """
        ...
    @braking_friction.setter
    def braking_friction(self, value: float) -> None:
        ...
    @property
    def braking_sub_step_time(self) -> float:
        r"""
        (float):  [Read-Write] Time substepping when applying braking friction. Smaller time steps increase accuracy at the slight cost of performance, especially if there are large frame times.
        """
        ...
    @braking_sub_step_time.setter
    def braking_sub_step_time(self, value: float) -> None:
        ...
    @property
    def braking_deceleration_walking(self) -> float:
        r"""
        (float):  [Read-Write] Deceleration when walking and not applying acceleration. This is a constant opposing force that directly lowers velocity by a constant value.
        see: GroundFriction, MaxAcceleration
        """
        ...
    @braking_deceleration_walking.setter
    def braking_deceleration_walking(self, value: float) -> None:
        ...
    @property
    def braking_deceleration(self) -> float:
        r"""
        deprecated: 'braking_deceleration' was renamed to 'braking_deceleration_walking'.
        """
        ...
    @braking_deceleration.setter
    def braking_deceleration(self, value: float) -> None:
        ...
    @property
    def braking_deceleration_falling(self) -> float:
        r"""
        (float):  [Read-Write] Lateral deceleration when falling and not applying acceleration.
        see: MaxAcceleration
        """
        ...
    @braking_deceleration_falling.setter
    def braking_deceleration_falling(self, value: float) -> None:
        ...
    @property
    def braking_deceleration_swimming(self) -> float:
        r"""
        (float):  [Read-Write] Deceleration when swimming and not applying acceleration.
        see: MaxAcceleration
        """
        ...
    @braking_deceleration_swimming.setter
    def braking_deceleration_swimming(self, value: float) -> None:
        ...
    @property
    def braking_deceleration_flying(self) -> float:
        r"""
        (float):  [Read-Write] Deceleration when flying and not applying acceleration.
        see: MaxAcceleration
        """
        ...
    @braking_deceleration_flying.setter
    def braking_deceleration_flying(self, value: float) -> None:
        ...
    @property
    def air_control(self) -> float:
        r"""
        (float):  [Read-Write] When falling, amount of lateral movement control available to the character.
        0 = no control, 1 = full control at max speed of MaxWalkSpeed.
        """
        ...
    @air_control.setter
    def air_control(self, value: float) -> None:
        ...
    @property
    def air_control_boost_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] When falling, multiplier applied to AirControl when lateral velocity is less than AirControlBoostVelocityThreshold.
        Setting this to zero will disable air control boosting. Final result is clamped at 1.
        """
        ...
    @air_control_boost_multiplier.setter
    def air_control_boost_multiplier(self, value: float) -> None:
        ...
    @property
    def air_control_boost_velocity_threshold(self) -> float:
        r"""
        (float):  [Read-Write] When falling, if lateral velocity magnitude is less than this value, AirControl is multiplied by AirControlBoostMultiplier.
        Setting this to zero will disable air control boosting.
        """
        ...
    @air_control_boost_velocity_threshold.setter
    def air_control_boost_velocity_threshold(self, value: float) -> None:
        ...
    @property
    def falling_lateral_friction(self) -> float:
        r"""
        (float):  [Read-Write] Friction to apply to lateral air movement when falling.
        If bUseSeparateBrakingFriction is false, also affects the ability to stop more quickly when braking (whenever Acceleration is zero).
        see: BrakingFriction, bUseSeparateBrakingFriction
        """
        ...
    @falling_lateral_friction.setter
    def falling_lateral_friction(self, value: float) -> None:
        ...
    @property
    def crouched_half_height(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @crouched_half_height.setter
    def crouched_half_height(self, value: float) -> None:
        ...
    @property
    def crouch_height(self) -> float:
        r"""
        deprecated: 'crouch_height' was renamed to 'crouched_half_height'.
        """
        ...
    @crouch_height.setter
    def crouch_height(self, value: float) -> None:
        ...
    @property
    def buoyancy(self) -> float:
        r"""
        (float):  [Read-Write] Water buoyancy. A ratio (1.0 = neutral buoyancy, 0.0 = no buoyancy)
        """
        ...
    @buoyancy.setter
    def buoyancy(self, value: float) -> None:
        ...
    @property
    def perch_radius_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Don't allow the character to perch on the edge of a surface if the contact is this close to the edge of the capsule.
        Note that characters will not fall off if they are within MaxStepHeight of a walkable surface below.
        """
        ...
    @perch_radius_threshold.setter
    def perch_radius_threshold(self, value: float) -> None:
        ...
    @property
    def perch_additional_height(self) -> float:
        r"""
        (float):  [Read-Write] When perching on a ledge, add this additional distance to MaxStepHeight when determining how high above a walkable floor we can perch.
        Note that we still enforce MaxStepHeight to start the step up; this just allows the character to hang off the edge or step slightly higher off the floor.
        (
        see: PerchRadiusThreshold)
        """
        ...
    @perch_additional_height.setter
    def perch_additional_height(self, value: float) -> None:
        ...
    @property
    def rotation_rate(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] Change in rotation per second, used when UseControllerDesiredRotation or OrientRotationToMovement are true. Set a negative value for infinite rotation rate and instant turns.
        """
        ...
    @rotation_rate.setter
    def rotation_rate(self, value: Rotator) -> None:
        ...
    @property
    def use_separate_braking_friction(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, BrakingFriction will be used to slow the character to a stop (when there is no Acceleration).
        If false, braking uses the same friction passed to CalcVelocity() (ie GroundFriction when walking), multiplied by BrakingFrictionFactor.
        This setting applies to all movement modes; if only desired in certain modes, consider toggling it when movement modes change.
        see: BrakingFriction
        """
        ...
    @use_separate_braking_friction.setter
    def use_separate_braking_friction(self, value: bool) -> None:
        ...
    @property
    def apply_gravity_while_jumping(self) -> bool:
        r"""
        (bool):  [Read-Write] Apply gravity while the character is actively jumping (e.g. holding the jump key).
        Helps remove frame-rate dependent jump height, but may alter base jump height.
        """
        ...
    @apply_gravity_while_jumping.setter
    def apply_gravity_while_jumping(self, value: bool) -> None:
        ...
    @property
    def use_controller_desired_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, smoothly rotate the Character toward the Controller's desired rotation (typically Controller->ControlRotation), using RotationRate as the rate of rotation change. Overridden by OrientRotationToMovement.
        Normally you will want to make sure that other settings are cleared, such as bUseControllerRotationYaw on the Character.
        """
        ...
    @use_controller_desired_rotation.setter
    def use_controller_desired_rotation(self, value: bool) -> None:
        ...
    @property
    def orient_rotation_to_movement(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, rotate the Character toward the direction of acceleration, using RotationRate as the rate of rotation change. Overrides UseControllerDesiredRotation.
        Normally you will want to make sure that other settings are cleared, such as bUseControllerRotationYaw on the Character.
        """
        ...
    @orient_rotation_to_movement.setter
    def orient_rotation_to_movement(self, value: bool) -> None:
        ...
    @property
    def b_orient_to_movement(self) -> bool:
        r"""
        deprecated: 'b_orient_to_movement' was renamed to 'orient_rotation_to_movement'.
        """
        ...
    @b_orient_to_movement.setter
    def b_orient_to_movement(self, value: bool) -> None:
        ...
    @property
    def sweep_while_nav_walking(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not the character should sweep for collision geometry while walking.
        see: USceneComponent::MoveComponent.
        """
        ...
    @sweep_while_nav_walking.setter
    def sweep_while_nav_walking(self, value: bool) -> None:
        ...
    @property
    def run_physics_with_no_controller(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, movement will be performed even if there is no Controller for the Character owner.
        Normally without a Controller, movement will be aborted and velocity and acceleration are zeroed if the character is walking.
        Characters that are spawned without a Controller but with this flag enabled will initialize the movement mode to DefaultLandMovementMode or DefaultWaterMovementMode appropriately.
        see: DefaultLandMovementMode, DefaultWaterMovementMode
        """
        ...
    @run_physics_with_no_controller.setter
    def run_physics_with_no_controller(self, value: bool) -> None:
        ...
    @property
    def force_next_floor_check(self) -> bool:
        r"""
        (bool):  [Read-Only] Force the Character in MOVE_Walking to do a check for a valid floor even if it hasn't moved. Cleared after next floor check.
        Normally if bAlwaysCheckFloor is false we try to avoid the floor check unless some conditions are met, but this can be used to force the next check to always run.
        """
        ...
    @property
    def can_walk_off_ledges(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, Character can walk off a ledge.
        """
        ...
    @can_walk_off_ledges.setter
    def can_walk_off_ledges(self, value: bool) -> None:
        ...
    @property
    def can_walk_off_ledges_when_crouching(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, Character can walk off a ledge when crouching.
        """
        ...
    @can_walk_off_ledges_when_crouching.setter
    def can_walk_off_ledges_when_crouching(self, value: bool) -> None:
        ...
    @property
    def enable_physics_interaction(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the player will interact with physics objects when walking into them.
        """
        ...
    @enable_physics_interaction.setter
    def enable_physics_interaction(self, value: bool) -> None:
        ...
    @property
    def touch_force_scaled_to_mass(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the TouchForceFactor is applied per kg mass of the affected object.
        """
        ...
    @touch_force_scaled_to_mass.setter
    def touch_force_scaled_to_mass(self, value: bool) -> None:
        ...
    @property
    def push_force_scaled_to_mass(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the PushForceFactor is applied per kg mass of the affected object.
        """
        ...
    @push_force_scaled_to_mass.setter
    def push_force_scaled_to_mass(self, value: bool) -> None:
        ...
    @property
    def push_force_using_z_offset(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the PushForce location is moved using PushForcePointZOffsetFactor. Otherwise simply use the impact point.
        """
        ...
    @push_force_using_z_offset.setter
    def push_force_using_z_offset(self, value: bool) -> None:
        ...
    @property
    def scale_push_force_to_velocity(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the applied push force will try to get the physics object to the same velocity than the player, not faster. This will only
                      scale the force down, it will never apply more force than defined by PushForceFactor.
        """
        ...
    @scale_push_force_to_velocity.setter
    def scale_push_force_to_velocity(self, value: bool) -> None:
        ...
    @property
    def max_out_of_water_step_height(self) -> float:
        r"""
        (float):  [Read-Write] Maximum step height for getting out of water
        """
        ...
    @max_out_of_water_step_height.setter
    def max_out_of_water_step_height(self, value: float) -> None:
        ...
    @property
    def outof_water_z(self) -> float:
        r"""
        (float):  [Read-Write] Z velocity applied when pawn tries to get out of water
        """
        ...
    @outof_water_z.setter
    def outof_water_z(self, value: float) -> None:
        ...
    @property
    def mass(self) -> float:
        r"""
        (float):  [Read-Write] Mass of pawn (for when momentum is imparted to it).
        """
        ...
    @mass.setter
    def mass(self, value: float) -> None:
        ...
    @property
    def standing_downward_force_scale(self) -> float:
        r"""
        (float):  [Read-Write] Force applied to objects we stand on (due to Mass and Gravity) is scaled by this amount.
        """
        ...
    @standing_downward_force_scale.setter
    def standing_downward_force_scale(self, value: float) -> None:
        ...
    @property
    def initial_push_force_factor(self) -> float:
        r"""
        (float):  [Read-Write] Initial impulse force to apply when the player bounces into a blocking physics object.
        """
        ...
    @initial_push_force_factor.setter
    def initial_push_force_factor(self, value: float) -> None:
        ...
    @property
    def push_force_factor(self) -> float:
        r"""
        (float):  [Read-Write] Force to apply when the player collides with a blocking physics object.
        """
        ...
    @push_force_factor.setter
    def push_force_factor(self, value: float) -> None:
        ...
    @property
    def push_force_point_z_offset_factor(self) -> float:
        r"""
        (float):  [Read-Write] Z-Offset for the position the force is applied to. 0.0f is the center of the physics object, 1.0f is the top and -1.0f is the bottom of the object.
        """
        ...
    @push_force_point_z_offset_factor.setter
    def push_force_point_z_offset_factor(self, value: float) -> None:
        ...
    @property
    def touch_force_factor(self) -> float:
        r"""
        (float):  [Read-Write] Force to apply to physics objects that are touched by the player.
        """
        ...
    @touch_force_factor.setter
    def touch_force_factor(self, value: float) -> None:
        ...
    @property
    def min_touch_force(self) -> float:
        r"""
        (float):  [Read-Write] Minimum Force applied to touched physics objects. If < 0.0f, there is no minimum.
        """
        ...
    @min_touch_force.setter
    def min_touch_force(self, value: float) -> None:
        ...
    @property
    def max_touch_force(self) -> float:
        r"""
        (float):  [Read-Write] Maximum force applied to touched physics objects. If < 0.0f, there is no maximum.
        """
        ...
    @max_touch_force.setter
    def max_touch_force(self, value: float) -> None:
        ...
    @property
    def repulsion_force(self) -> float:
        r"""
        (float):  [Read-Write] Force per kg applied constantly to all overlapping components.
        """
        ...
    @repulsion_force.setter
    def repulsion_force(self, value: float) -> None:
        ...
    @property
    def max_simulation_time_step(self) -> float:
        r"""
        (float):  [Read-Write] Max time delta for each discrete simulation step.
        Used primarily in the the more advanced movement modes that break up larger time steps (usually those applying gravity such as falling and walking).
        Lowering this value can address issues with fast-moving objects or complex collision scenarios, at the cost of performance.
        
        WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
        see: MaxSimulationIterations
        """
        ...
    @max_simulation_time_step.setter
    def max_simulation_time_step(self, value: float) -> None:
        ...
    @property
    def max_simulation_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] Max number of iterations used for each discrete simulation step.
        Used primarily in the the more advanced movement modes that break up larger time steps (usually those applying gravity such as falling and walking).
        Increasing this value can address issues with fast-moving objects or complex collision scenarios, at the cost of performance.
        
        WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
        see: MaxSimulationTimeStep
        """
        ...
    @max_simulation_iterations.setter
    def max_simulation_iterations(self, value: int) -> None:
        ...
    @property
    def max_jump_apex_attempts_per_simulation(self) -> int:
        r"""
        (int32):  [Read-Write] Max number of attempts per simulation to attempt to exactly reach the jump apex when falling movement reaches the top of the arc.
        Limiting this prevents deep recursion when special cases cause collision or other conditions which reactivate the apex condition.
        """
        ...
    @max_jump_apex_attempts_per_simulation.setter
    def max_jump_apex_attempts_per_simulation(self, value: int) -> None:
        ...
    @property
    def max_depenetration_with_geometry(self) -> float:
        r"""
        (float):  [Read-Write] Max distance we allow simulated proxies to depenetrate when moving out of anything but Pawns.
        This is generally more tolerant than with Pawns, because other geometry is either not moving, or is moving predictably with a bit of delay compared to on the server.
        see: MaxDepenetrationWithGeometryAsProxy, MaxDepenetrationWithPawn, MaxDepenetrationWithPawnAsProxy
        """
        ...
    @max_depenetration_with_geometry.setter
    def max_depenetration_with_geometry(self, value: float) -> None:
        ...
    @property
    def max_depenetration_with_geometry_as_proxy(self) -> float:
        r"""
        (float):  [Read-Write] Max distance we allow simulated proxies to depenetrate when moving out of anything but Pawns.
        This is generally more tolerant than with Pawns, because other geometry is either not moving, or is moving predictably with a bit of delay compared to on the server.
        see: MaxDepenetrationWithGeometry, MaxDepenetrationWithPawn, MaxDepenetrationWithPawnAsProxy
        """
        ...
    @max_depenetration_with_geometry_as_proxy.setter
    def max_depenetration_with_geometry_as_proxy(self, value: float) -> None:
        ...
    @property
    def max_depenetration_with_pawn(self) -> float:
        r"""
        (float):  [Read-Write] Max distance we are allowed to depenetrate when moving out of other Pawns.
        see: MaxDepenetrationWithGeometry, MaxDepenetrationWithGeometryAsProxy, MaxDepenetrationWithPawnAsProxy
        """
        ...
    @max_depenetration_with_pawn.setter
    def max_depenetration_with_pawn(self, value: float) -> None:
        ...
    @property
    def max_depenetration_with_pawn_as_proxy(self) -> float:
        r"""
        (float):  [Read-Write] Max distance we allow simulated proxies to depenetrate when moving out of other Pawns.
        Typically we don't want a large value, because we receive a server authoritative position that we should not then ignore by pushing them out of the local player.
        see: MaxDepenetrationWithGeometry, MaxDepenetrationWithGeometryAsProxy, MaxDepenetrationWithPawn
        """
        ...
    @max_depenetration_with_pawn_as_proxy.setter
    def max_depenetration_with_pawn_as_proxy(self, value: float) -> None:
        ...
    @property
    def ledge_check_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Used in determining if pawn is going off ledge.  If the ledge is "shorter" than this value then the pawn will be able to walk off it. *
        """
        ...
    @ledge_check_threshold.setter
    def ledge_check_threshold(self, value: float) -> None:
        ...
    @property
    def jump_out_of_water_pitch(self) -> float:
        r"""
        (float):  [Read-Write] When exiting water, jump if control pitch angle is this high or above.
        """
        ...
    @jump_out_of_water_pitch.setter
    def jump_out_of_water_pitch(self, value: float) -> None:
        ...
    @property
    def current_floor(self) -> FindFloorResult:
        r"""
        (FindFloorResult):  [Read-Only] Information about the floor the Character is standing on (updated only during walking movement).
        """
        ...
    @property
    def default_land_movement_mode(self) -> MovementMode:
        r"""
        (MovementMode):  [Read-Write] Default movement mode when not in water. Used at player startup or when teleported.
        see: DefaultWaterMovementMode
        see: bRunPhysicsWithNoController
        """
        ...
    @default_land_movement_mode.setter
    def default_land_movement_mode(self, value: MovementMode) -> None:
        ...
    @property
    def default_water_movement_mode(self) -> MovementMode:
        r"""
        (MovementMode):  [Read-Write] Default movement mode when in water. Used at player startup or when teleported.
        see: DefaultLandMovementMode
        see: bRunPhysicsWithNoController
        """
        ...
    @default_water_movement_mode.setter
    def default_water_movement_mode(self, value: MovementMode) -> None:
        ...
    @property
    def maintain_horizontal_ground_velocity(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, walking movement always maintains horizontal velocity when moving up ramps, which causes movement up ramps to be faster parallel to the ramp surface.
        If false, then walking movement maintains velocity magnitude parallel to the ramp surface.
        """
        ...
    @maintain_horizontal_ground_velocity.setter
    def maintain_horizontal_ground_velocity(self, value: bool) -> None:
        ...
    @property
    def impart_base_velocity_x(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, impart the base actor's X velocity when falling off it (which includes jumping)
        """
        ...
    @impart_base_velocity_x.setter
    def impart_base_velocity_x(self, value: bool) -> None:
        ...
    @property
    def impart_base_velocity_y(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, impart the base actor's Y velocity when falling off it (which includes jumping)
        """
        ...
    @impart_base_velocity_y.setter
    def impart_base_velocity_y(self, value: bool) -> None:
        ...
    @property
    def impart_base_velocity_z(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, impart the base actor's Z velocity when falling off it (which includes jumping)
        """
        ...
    @impart_base_velocity_z.setter
    def impart_base_velocity_z(self, value: bool) -> None:
        ...
    @property
    def impart_base_angular_velocity(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, impart the base component's tangential components of angular velocity when jumping or falling off it.
        Only those components of the velocity allowed by the separate component settings (bImpartBaseVelocityX etc) will be applied.
        see: bImpartBaseVelocityX, bImpartBaseVelocityY, bImpartBaseVelocityZ
        """
        ...
    @impart_base_angular_velocity.setter
    def impart_base_angular_velocity(self, value: bool) -> None:
        ...
    @property
    def just_teleported(self) -> bool:
        r"""
        (bool):  [Read-Only] Used by movement code to determine if a change in position is based on normal movement or a teleport. If not a teleport, velocity can be recomputed based on the change in position.
        """
        ...
    @property
    def ignore_client_movement_error_checks_and_correction(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, we should ignore server location difference checks for client error on this movement component.
        This can be useful when character is moving at extreme speeds for a duration and you need it to look
        smooth on clients without the server correcting the client. Make sure to disable when done, as this would
        break this character's server-client movement correction.
        see: bServerAcceptClientAuthoritativePosition, ServerCheckClientError()
        """
        ...
    @ignore_client_movement_error_checks_and_correction.setter
    def ignore_client_movement_error_checks_and_correction(self, value: bool) -> None:
        ...
    @property
    def server_accept_client_authoritative_position(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, and server does not detect client position error, server will copy the client movement location/velocity/etc after simulating the move.
        This can be useful for short bursts of movement that are difficult to sync over the network.
        Note that if bIgnoreClientMovementErrorChecksAndCorrection is used, this means the server will not detect an error.
        Also see GameNetworkManager->ClientAuthorativePosition which permanently enables this behavior.
        see: bIgnoreClientMovementErrorChecksAndCorrection, ServerShouldUseAuthoritativePosition()
        """
        ...
    @server_accept_client_authoritative_position.setter
    def server_accept_client_authoritative_position(self, value: bool) -> None:
        ...
    @property
    def notify_apex(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, event NotifyJumpApex() to CharacterOwner's controller when at apex of jump. Is cleared when event is triggered.
        By default this is off, and if you want the event to fire you typically set it to true when movement mode changes to "Falling" from another mode (see OnMovementModeChanged).
        """
        ...
    @property
    def wants_to_crouch(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, try to crouch (or keep crouching) on next update. If false, try to stop crouching on next update.
        """
        ...
    @property
    def crouch_maintains_base_location(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, crouching should keep the base of the capsule in place by lowering the center of the shrunken capsule. If false, the base of the capsule moves up and the center stays in place.
        The same behavior applies when the character uncrouches: if true, the base is kept in the same location and the center moves up. If false, the capsule grows and only moves up if the base impacts something.
        By default this variable is set when the movement mode changes: set to true when walking and false otherwise. Feel free to override the behavior when the movement mode changes.
        """
        ...
    @property
    def b_crouch_moves_character_down(self) -> bool:
        r"""
        deprecated: 'b_crouch_moves_character_down' was renamed to 'crouch_maintains_base_location'.
        """
        ...
    @property
    def ignore_base_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the character ignores changes in rotation of the base it is standing on.
        If true, the character maintains current world rotation.
        If false, the character rotates with the moving base.
        """
        ...
    @ignore_base_rotation.setter
    def ignore_base_rotation(self, value: bool) -> None:
        ...
    @property
    def always_check_floor(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we always force floor checks for stationary Characters while walking.
        Normally floor checks are avoided if possible when not moving, but this can be used to force them if there are use-cases where they are being skipped erroneously
        (such as objects moving up into the character from below).
        """
        ...
    @always_check_floor.setter
    def always_check_floor(self, value: bool) -> None:
        ...
    @property
    def use_flat_base_for_floor_checks(self) -> bool:
        r"""
        (bool):  [Read-Write] Performs floor checks as if the character is using a shape with a flat base.
        This avoids the situation where characters slowly lower off the side of a ledge (as their capsule 'balances' on the edge).
        """
        ...
    @use_flat_base_for_floor_checks.setter
    def use_flat_base_for_floor_checks(self, value: bool) -> None:
        ...
    @property
    def use_rvo_avoidance(self) -> bool:
        r"""
        (bool):  [Read-Only] If set, component will use RVO avoidance. This only runs on the server.
        """
        ...
    @property
    def requested_move_use_acceleration(self) -> bool:
        r"""
        (bool):  [Read-Write] Should use acceleration for path following?
        If true, acceleration is applied when path following to reach the target velocity.
        If false, path following velocity is set directly, disregarding acceleration.
        """
        ...
    @requested_move_use_acceleration.setter
    def requested_move_use_acceleration(self, value: bool) -> None:
        ...
    @property
    def allow_physics_rotation_during_anim_root_motion(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @allow_physics_rotation_during_anim_root_motion.setter
    def allow_physics_rotation_during_anim_root_motion(self, value: bool) -> None:
        ...
    @property
    def former_base_velocity_decay_half_life(self) -> float:
        r"""
        (float):  [Read-Write] When applying a root motion override while falling off a moving object, this controls how long it takes to lose half the former base's velocity (in seconds).
        Set to 0 to ignore former bases (default).
        Set to -1 for no decay.
        Any other positive value sets the half-life for exponential decay.
        """
        ...
    @former_base_velocity_decay_half_life.setter
    def former_base_velocity_decay_half_life(self, value: float) -> None:
        ...
    @property
    def project_nav_mesh_walking(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to raycast to underlying geometry to better conform navmesh-walking characters
        """
        ...
    @property
    def project_nav_mesh_on_both_world_channels(self) -> bool:
        r"""
        (bool):  [Read-Only] Use both WorldStatic and WorldDynamic channels for NavWalking geometry conforming
        """
        ...
    @property
    def avoidance_consideration_radius(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def avoidance_uid(self) -> int:
        r"""
        (int32):  [Read-Only] No default value, for now it's assumed to be valid if GetAvoidanceManager() returns non-NULL.
        """
        ...
    @property
    def avoidance_group(self) -> NavAvoidanceMask:
        r"""
        (NavAvoidanceMask):  [Read-Only] Moving actor's group mask
        """
        ...
    @property
    def groups_to_avoid(self) -> NavAvoidanceMask:
        r"""
        (NavAvoidanceMask):  [Read-Only] Will avoid other agents if they are in one of specified groups
        """
        ...
    @property
    def groups_to_ignore(self) -> NavAvoidanceMask:
        r"""
        (NavAvoidanceMask):  [Read-Only] Will NOT avoid other agents if they are in one of specified groups, higher priority than GroupsToAvoid
        """
        ...
    @property
    def avoidance_weight(self) -> float:
        r"""
        (float):  [Read-Only] De facto default value 0.5 (due to that being the default in the avoidance registration function), indicates RVO behavior.
        """
        ...
    @property
    def nav_mesh_projection_interval(self) -> float:
        r"""
        (float):  [Read-Write] How often we should raycast to project from navmesh to underlying geometry
        """
        ...
    @nav_mesh_projection_interval.setter
    def nav_mesh_projection_interval(self, value: float) -> None:
        ...
    @property
    def nav_mesh_projection_interp_speed(self) -> float:
        r"""
        (float):  [Read-Write] Speed at which to interpolate agent navmesh offset between traces. 0: Instant (no interp) > 0: Interp speed")
        """
        ...
    @nav_mesh_projection_interp_speed.setter
    def nav_mesh_projection_interp_speed(self, value: float) -> None:
        ...
    @property
    def nav_mesh_projection_height_scale_up(self) -> float:
        r"""
        (float):  [Read-Write] Scale of the total capsule height to use for projection from navmesh to underlying geometry in the upward direction.
        In other words, start the trace at [CapsuleHeight * NavMeshProjectionHeightScaleUp] above nav mesh.
        """
        ...
    @nav_mesh_projection_height_scale_up.setter
    def nav_mesh_projection_height_scale_up(self, value: float) -> None:
        ...
    @property
    def nav_mesh_projection_capsule_height_scale_up(self) -> float:
        r"""
        deprecated: 'nav_mesh_projection_capsule_height_scale_up' was renamed to 'nav_mesh_projection_height_scale_up'.
        """
        ...
    @nav_mesh_projection_capsule_height_scale_up.setter
    def nav_mesh_projection_capsule_height_scale_up(self, value: float) -> None:
        ...
    @property
    def nav_mesh_projection_height_scale_down(self) -> float:
        r"""
        (float):  [Read-Write] Scale of the total capsule height to use for projection from navmesh to underlying geometry in the downward direction.
        In other words, trace down to [CapsuleHeight * NavMeshProjectionHeightScaleDown] below nav mesh.
        """
        ...
    @nav_mesh_projection_height_scale_down.setter
    def nav_mesh_projection_height_scale_down(self, value: float) -> None:
        ...
    @property
    def nav_mesh_projection_capsule_height_scale_down(self) -> float:
        r"""
        deprecated: 'nav_mesh_projection_capsule_height_scale_down' was renamed to 'nav_mesh_projection_height_scale_down'.
        """
        ...
    @nav_mesh_projection_capsule_height_scale_down.setter
    def nav_mesh_projection_capsule_height_scale_down(self, value: float) -> None:
        ...
    @property
    def nav_walking_floor_dist_tolerance(self) -> float:
        r"""
        (float):  [Read-Write] Ignore small differences in ground height between server and client data during NavWalking mode
        """
        ...
    @nav_walking_floor_dist_tolerance.setter
    def nav_walking_floor_dist_tolerance(self, value: float) -> None:
        ...
    @property
    def based_movement_ignore_physics_base(self) -> bool:
        r"""
        (bool):  [Read-Write] Property to set if UpdateBasedMovement should ignore collision with actors part of the current MovementBase, if the base is simulated by physics
        """
        ...
    @based_movement_ignore_physics_base.setter
    def based_movement_ignore_physics_base(self, value: bool) -> None:
        ...
    @property
    def stay_based_in_air(self) -> bool:
        r"""
        (bool):  [Read-Write] Property to set if characters should stay based on objects while jumping
        """
        ...
    @stay_based_in_air.setter
    def stay_based_in_air(self, value: bool) -> None:
        ...
    @property
    def stay_based_in_air_height(self) -> float:
        r"""
        (float):  [Read-Write] Property used to set how high above base characters should stay based on objects while jumping if bStayBasedInAir is set
        """
        ...
    @stay_based_in_air_height.setter
    def stay_based_in_air_height(self, value: float) -> None:
        ...
    def set_walkable_floor_z(self, walkable_floor_z: float) -> None:
        r"""
        x.set_walkable_floor_z(walkable_floor_z) -> None
        Set the Z component of the normal of the steepest walkable surface for the character. Also computes WalkableFloorAngle.
        
        Args:
            walkable_floor_z (float):
        """
        ...
    def set_walkable_floor_angle(self, walkable_floor_angle: float) -> None:
        r"""
        x.set_walkable_floor_angle(walkable_floor_angle) -> None
        Set the max angle in degrees of a walkable surface for the character. Also computes WalkableFloorZ.
        
        Args:
            walkable_floor_angle (float):
        """
        ...
    def set_movement_mode(self, new_movement_mode: MovementMode, new_custom_mode: int = 0) -> None:
        r"""
        x.set_movement_mode(new_movement_mode, new_custom_mode=0) -> None
        Change movement mode.
        
        Args:
            new_movement_mode (MovementMode): The new movement mode
            new_custom_mode (uint8): The new custom sub-mode, only applicable if NewMovementMode is Custom.
        """
        ...
    def set_groups_to_ignore_mask(self, group_mask: NavAvoidanceMask) -> None:
        r"""
        x.set_groups_to_ignore_mask(group_mask) -> None
        Set Groups to Ignore Mask
        
        Args:
            group_mask (NavAvoidanceMask):
        """
        ...
    def set_groups_to_ignore(self, group_flags: int) -> None:
        r"""
        x.set_groups_to_ignore(group_flags) -> None
        Set Groups to Ignore
        deprecated: Please use SetGroupsToIgnoreMask function instead.
        
        Args:
            group_flags (int32):
        """
        ...
    def set_groups_to_avoid_mask(self, group_mask: NavAvoidanceMask) -> None:
        r"""
        x.set_groups_to_avoid_mask(group_mask) -> None
        Set Groups to Avoid Mask
        
        Args:
            group_mask (NavAvoidanceMask):
        """
        ...
    def set_groups_to_avoid(self, group_flags: int) -> None:
        r"""
        x.set_groups_to_avoid(group_flags) -> None
        Set Groups to Avoid
        deprecated: Please use SetGroupsToAvoidMask function instead.
        
        Args:
            group_flags (int32):
        """
        ...
    def set_gravity_direction(self, gravity_dir: Vector) -> None:
        r"""
        x.set_gravity_direction(gravity_dir) -> None
        Set a custom, local gravity direction to use during movement simulation.
        The gravity direction must be synchronized by external systems between the autonomous
        and authority processes. The gravity direction will be corrected as part of movement
        corrections should the movement state diverge.
        SetGravityDirection is responsible for initializing cached values used to tranform to
        from gravity relative space.
        
        Args:
            gravity_dir (Vector): A non-zero vector representing the new gravity direction. The vector will be normalized.
        """
        ...
    def set_avoidance_group_mask(self, group_mask: NavAvoidanceMask) -> None:
        r"""
        x.set_avoidance_group_mask(group_mask) -> None
        Set Avoidance Group Mask
        
        Args:
            group_mask (NavAvoidanceMask):
        """
        ...
    def set_avoidance_group(self, group_flags: int) -> None:
        r"""
        x.set_avoidance_group(group_flags) -> None
        Set Avoidance Group
        deprecated: Please use SetAvoidanceGroupMask function instead.
        
        Args:
            group_flags (int32):
        """
        ...
    def set_avoidance_enabled(self, enable: bool) -> None:
        r"""
        x.set_avoidance_enabled(enable) -> None
        Change avoidance state and registers in RVO manager if needed
        
        Args:
            enable (bool):
        """
        ...
    def get_walkable_floor_z(self) -> float:
        r"""
        x.get_walkable_floor_z() -> float
        Get the Z component of the normal of the steepest walkable surface for the character. Any lower than this and it is not walkable.
        
        Returns:
            float:
        """
        ...
    def get_walkable_floor_angle(self) -> float:
        r"""
        x.get_walkable_floor_angle() -> float
        Get the max angle in degrees of a walkable surface for the character.
        
        Returns:
            float:
        """
        ...
    def find_floor(self, capsule_location: Vector) -> FindFloorResult:
        r"""
        x.find_floor(capsule_location) -> FindFloorResult
        Sweeps a vertical trace to find the floor for the capsule at the given location. Will attempt to perch if ShouldComputePerchResult() returns true for the downward sweep result.
        No floor will be found if collision is disabled on the capsule!
        
        Args:
            capsule_location (Vector): Location where the capsule sweep should originate
        
        Returns:
            FindFloorResult: 
        
            floor_result (FindFloorResult): Result of the floor check
        """
        ...
    def compute_floor_distance(self, capsule_location: Vector, line_distance: float, sweep_distance: float, sweep_radius: float) -> FindFloorResult:
        r"""
        x.compute_floor_distance(capsule_location, line_distance, sweep_distance, sweep_radius) -> FindFloorResult
        Compute distance to the floor from bottom sphere of capsule and store the result in FloorResult.
        This distance is the swept distance of the capsule to the first point impacted by the lower hemisphere, or distance from the bottom of the capsule in the case of a line trace.
        This function does not care if collision is disabled on the capsule (unlike FindFloor).
        
        Args:
            capsule_location (Vector): Location where the capsule sweep should originate
            line_distance (float): If non-zero, max distance to test for a simple line check from the capsule base. Used only if the sweep test fails to find a walkable floor, and only returns a valid result if the impact normal is a walkable normal.
            sweep_distance (float): If non-zero, max distance to use when sweeping a capsule downwards for the test. MUST be greater than or equal to the line distance.
            sweep_radius (float): The radius to use for sweep tests. Should be <= capsule radius.
        
        Returns:
            FindFloorResult: 
        
            floor_result (FindFloorResult): Result of the floor check
        """
        ...
    def is_walking(self) -> bool:
        r"""
        x.is_walking() -> bool
        Returns true if the character is in the 'Walking' movement mode.
        
        Returns:
            bool:
        """
        ...
    def is_walkable(self, hit: HitResult) -> bool:
        r"""
        x.is_walkable(hit) -> bool
        Return true if the hit result should be considered a walkable surface for the character.
        
        Args:
            hit (HitResult): 
        
        Returns:
            bool:
        """
        ...
    def has_custom_gravity(self) -> bool:
        r"""
        x.has_custom_gravity() -> bool
        Whether the gravity direction is different from UCharacterMovementComponent::DefaultGravityDirection.
        
        Returns:
            bool:
        """
        ...
    def get_valid_perch_radius(self) -> float:
        r"""
        x.get_valid_perch_radius() -> float
        Returns the radius within which we can stand on the edge of a surface without falling (if this is a walkable surface).
        Simply computed as the capsule radius minus the result of GetPerchRadiusThreshold().
        
        Returns:
            float:
        """
        ...
    def get_perch_radius_threshold(self) -> float:
        r"""
        x.get_perch_radius_threshold() -> float
        Returns The distance from the edge of the capsule within which we don't allow the character to perch on the edge of a surface.
        
        Returns:
            float:
        """
        ...
    def get_movement_base(self) -> PrimitiveComponent:
        r"""
        x.get_movement_base() -> PrimitiveComponent
        Return PrimitiveComponent we are based on (standing and walking on).
        
        Returns:
            PrimitiveComponent:
        """
        ...
    def get_min_analog_speed(self) -> float:
        r"""
        x.get_min_analog_speed() -> float
        Returns maximum acceleration for the current state.
        
        Returns:
            float:
        """
        ...
    def get_max_jump_height_with_jump_time(self) -> float:
        r"""
        x.get_max_jump_height_with_jump_time() -> float
        Compute the max jump height based on the JumpZVelocity velocity and gravity.
        This does take into account the CharacterOwner's MaxJumpHoldTime.
        
        Returns:
            float:
        """
        ...
    def get_max_jump_height(self) -> float:
        r"""
        x.get_max_jump_height() -> float
        Compute the max jump height based on the JumpZVelocity velocity and gravity.
        This does not take into account the CharacterOwner's MaxJumpHoldTime.
        
        Returns:
            float:
        """
        ...
    def get_max_braking_deceleration(self) -> float:
        r"""
        x.get_max_braking_deceleration() -> float
        Returns maximum deceleration for the current state when braking (ie when there is no acceleration).
        
        Returns:
            float:
        """
        ...
    def get_max_acceleration(self) -> float:
        r"""
        x.get_max_acceleration() -> float
        Returns maximum acceleration for the current state.
        
        Returns:
            float:
        """
        ...
    def get_last_update_velocity(self) -> Vector:
        r"""
        x.get_last_update_velocity() -> Vector
        Returns the velocity at the end of the last tick.
        
        Returns:
            Vector:
        """
        ...
    def get_last_update_rotation(self) -> Rotator:
        r"""
        x.get_last_update_rotation() -> Rotator
        Returns the rotation at the end of the last tick.
        
        Returns:
            Rotator:
        """
        ...
    def get_last_update_requested_velocity(self) -> Vector:
        r"""
        x.get_last_update_requested_velocity() -> Vector
        Returns velocity requested by path following
        
        Returns:
            Vector:
        """
        ...
    def get_last_update_location(self) -> Vector:
        r"""
        x.get_last_update_location() -> Vector
        Returns the location at the end of the last tick.
        
        Returns:
            Vector:
        """
        ...
    def get_imparted_movement_base_velocity(self) -> Vector:
        r"""
        x.get_imparted_movement_base_velocity() -> Vector
        If we have a movement base, get the velocity that should be imparted by that base, usually when jumping off of it.
        Only applies the components of the velocity enabled by bImpartBaseVelocityX, bImpartBaseVelocityY, bImpartBaseVelocityZ.
        
        Returns:
            Vector:
        """
        ...
    def get_gravity_direction(self) -> Vector:
        r"""
        x.get_gravity_direction() -> Vector
        Returns the current gravity direction.
        
        Returns:
            Vector:
        """
        ...
    def get_current_acceleration(self) -> Vector:
        r"""
        x.get_current_acceleration() -> Vector
        Returns current acceleration, computed from input vector each update.
        
        Returns:
            Vector:
        """
        ...
    def get_character_owner(self) -> Character:
        r"""
        x.get_character_owner() -> Character
        Get the Character that owns UpdatedComponent.
        
        Returns:
            Character:
        """
        ...
    def get_analog_input_modifier(self) -> float:
        r"""
        x.get_analog_input_modifier() -> float
        Returns modifier [0..1] based on the magnitude of the last input vector, which is used to modify the acceleration and max speed during movement.
        
        Returns:
            float:
        """
        ...
    def disable_movement(self) -> None:
        r"""
        x.disable_movement() -> None
        Make movement impossible (sets movement mode to MOVE_None).
        """
        ...
    def clear_accumulated_forces(self) -> None:
        r"""
        x.clear_accumulated_forces() -> None
        Clears forces accumulated through AddImpulse() and AddForce(), and also pending launch velocity.
        """
        ...
    def calc_velocity(self, delta_time: float, friction: float, fluid: bool, braking_deceleration: float) -> None:
        r"""
        x.calc_velocity(delta_time, friction, fluid, braking_deceleration) -> None
        Updates Velocity and Acceleration based on the current state, applying the effects of friction and acceleration or deceleration. Does not apply gravity.
        This is used internally during movement updates. Normally you don't need to call this from outside code, but you might want to use it for custom movement modes.
        
        Args:
            delta_time (float): time elapsed since last frame.
            friction (float): coefficient of friction when not accelerating, or in the direction opposite acceleration.
            fluid (bool): true if moving through a fluid, causing Friction to always be applied regardless of acceleration.
            braking_deceleration (float): deceleration applied when not accelerating, or when exceeding max velocity.
        """
        ...
    def add_impulse(self, impulse: Vector, velocity_change: bool = False) -> None:
        r"""
        x.add_impulse(impulse, velocity_change=False) -> None
        Add impulse to character. Impulses are accumulated each tick and applied together
        so multiple calls to this function will accumulate.
        An impulse is an instantaneous force, usually applied once. If you want to continually apply
        forces each frame, use AddForce().
        Note that changing the momentum of characters like this can change the movement mode.
        
        Args:
            impulse (Vector): Impulse to apply.
            velocity_change (bool): Whether or not the impulse is relative to mass.
        """
        ...
    def add_momentum(self, impulse: Vector, velocity_change: bool = False) -> None:
        r"""
        deprecated: 'add_momentum' was renamed to 'add_impulse'.
        """
        ...
    def add_force(self, force: Vector) -> None:
        r"""
        x.add_force(force) -> None
        Add force to character. Forces are accumulated each tick and applied together
        so multiple calls to this function will accumulate.
        Forces are scaled depending on timestep, so they can be applied each frame. If you want an
        instantaneous force, use AddImpulse.
        Adding a force always takes the actor's mass into account.
        Note that changing the momentum of characters like this can change the movement mode.
        
        Args:
            force (Vector): Force to apply.
        """
        ...

class MovementComp_Character(CharacterMovementComponent):
    r"""
    deprecated: 'MovementComp_Character' was renamed to 'CharacterMovementComponent'.
    """
    ...

class ChildActorComponent(SceneComponent):
    r"""
    A component that spawns an Actor when registered, and destroys it when unregistered.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ChildActorComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``child_actor`` (Actor):  [Read-Write] The actor that we spawned and own
    - ``child_actor_class`` (type(Class)):  [Read-Write] The class of Actor to spawn
    - ``child_actor_is_transient`` (bool):  [Read-Write] Should the spawned actor be marked as transient?
      note: The spawned actor will also be marked transient if this component or its owner actor are transient, regardless of the state of this flag.
    - ``child_actor_template`` (Actor):  [Read-Only] Property to point to the template child actor for details panel purposes
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def child_actor_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] The class of Actor to spawn
        """
        ...
    @property
    def child_actor(self) -> Actor:
        r"""
        (Actor):  [Read-Only] The actor that we spawned and own
        """
        ...
    def set_child_actor_class(self, class_: Class) -> None:
        r"""
        x.set_child_actor_class(class_) -> None
        Sets the class to use for the child actor.
        If called on a template component (owned by a CDO), the properties of any existing child actor template will be copied as best possible to the template.
        If called on a component instance in a world (and the class is changing), the created ChildActor will use the class defaults as template.
        
        Args:
            class_ (type(Class)): The Actor subclass to spawn as a child actor
        """
        ...

class DecalComponent(SceneComponent):
    r"""
    A material that is rendered onto the surface of a mesh. A kind of 'bumper sticker' for a model.
    see: https://docs.unrealengine.com/latest/INT/Engine/Actors/DecalActor
    see: UDecalActor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DecalComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``decal_color`` (LinearColor):  [Read-Write] Decal color, can be accessed using the material Decal Color node.
    - ``decal_material`` (MaterialInterface):  [Read-Write] Decal material.
    - ``decal_size`` (Vector):  [Read-Write] Decal size in local space (does not include the component scale), technically redundant but there for convenience
    - ``destroy_owner_after_fade`` (bool):  [Read-Write] Automatically destroys the owning actor after fully fading out.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``fade_duration`` (float):  [Read-Write] Time in seconds for the decal to fade out. Set fade duration and start delay to 0 to make persistent. Only fades in active simulation or game.
    - ``fade_in_duration`` (float):  [Read-Write]
    - ``fade_in_start_delay`` (float):  [Read-Write]
    - ``fade_screen_size`` (float):  [Read-Write]
    - ``fade_start_delay`` (float):  [Read-Write] Time in seconds to wait before beginning to fade out the decal. Set fade duration and start delay to 0 to make persistent.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sort_order`` (int32):  [Read-Write] Controls the order in which decal elements are rendered.  Higher values draw later (on top).
      Setting many different sort orders on many different decals prevents sorting by state and can reduce performance.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def decal_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Only] Decal material.
        """
        ...
    @property
    def sort_order(self) -> int:
        r"""
        (int32):  [Read-Only] Controls the order in which decal elements are rendered.  Higher values draw later (on top).
        Setting many different sort orders on many different decals prevents sorting by state and can reduce performance.
        """
        ...
    @property
    def fade_screen_size(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def fade_start_delay(self) -> float:
        r"""
        (float):  [Read-Only] Time in seconds to wait before beginning to fade out the decal. Set fade duration and start delay to 0 to make persistent.
        """
        ...
    @property
    def fade_duration(self) -> float:
        r"""
        (float):  [Read-Only] Time in seconds for the decal to fade out. Set fade duration and start delay to 0 to make persistent. Only fades in active simulation or game.
        """
        ...
    @property
    def fade_in_duration(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def fade_in_start_delay(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def destroy_owner_after_fade(self) -> bool:
        r"""
        (bool):  [Read-Only] Automatically destroys the owning actor after fully fading out.
        """
        ...
    @property
    def decal_size(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Decal size in local space (does not include the component scale), technically redundant but there for convenience
        """
        ...
    @property
    def decal_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Decal color, can be accessed using the material Decal Color node.
        """
        ...
    def set_sort_order(self, value: int) -> None:
        r"""
        x.set_sort_order(value) -> None
        Sets the sort order for the decal component. Higher values draw later (on top). This will force the decal to reattach
        
        Args:
            value (int32):
        """
        ...
    def set_fade_screen_size(self, new_fade_screen_size: float) -> None:
        r"""
        x.set_fade_screen_size(new_fade_screen_size) -> None
        Set the FadeScreenSize for this decal component
        
        Args:
            new_fade_screen_size (float):
        """
        ...
    def set_fade_out(self, start_delay: float, duration: float, destroy_owner_after_fade: bool = True) -> None:
        r"""
        x.set_fade_out(start_delay, duration, destroy_owner_after_fade=True) -> None
        Sets the decal's fade start time, duration and if the owning actor should be destroyed after the decal is fully faded out.
        The default value of 0 for FadeStartDelay and FadeDuration makes the decal persistent. See DecalLifetimeOpacity material
        node to control the look of "fading out."
        
        Args:
            start_delay (float): Time in seconds to wait before beginning to fade out the decal.
            duration (float): Time in second for the decal to fade out.
            destroy_owner_after_fade (bool): Should the owning actor automatically be destroyed after it is completely faded out.
        """
        ...
    def set_fade_in(self, start_delay: float, duration: float) -> None:
        r"""
        x.set_fade_in(start_delay, duration) -> None
        Set Fade In
        
        Args:
            start_delay (float): 
            duration (float):
        """
        ...
    def set_decal_material(self, new_decal_material: MaterialInterface) -> None:
        r"""
        x.set_decal_material(new_decal_material) -> None
        setting decal material on decal component. This will force the decal to reattach
        
        Args:
            new_decal_material (MaterialInterface):
        """
        ...
    def set_decal_color(self, color: LinearColor) -> None:
        r"""
        x.set_decal_color(color) -> None
        Sets the decal color.
        
        Args:
            color (LinearColor):
        """
        ...
    def get_fade_start_delay(self) -> float:
        r"""
        x.get_fade_start_delay() -> float
        Get Fade Start Delay
        
        Returns:
            float:
        """
        ...
    def get_fade_in_start_delay(self) -> float:
        r"""
        x.get_fade_in_start_delay() -> float
        Get Fade in Start Delay
        
        Returns:
            float:
        """
        ...
    def get_fade_in_duration(self) -> float:
        r"""
        x.get_fade_in_duration() -> float
        Get Fade in Duration
        
        Returns:
            float:
        """
        ...
    def get_fade_duration(self) -> float:
        r"""
        x.get_fade_duration() -> float
        Get Fade Duration
        
        Returns:
            float:
        """
        ...
    def get_decal_material(self) -> MaterialInterface:
        r"""
        x.get_decal_material() -> MaterialInterface
        Accessor for decal material
        
        Returns:
            MaterialInterface:
        """
        ...
    def create_dynamic_material_instance(self) -> MaterialInstanceDynamic:
        r"""
        x.create_dynamic_material_instance() -> MaterialInstanceDynamic
        Utility to allocate a new Dynamic Material Instance, set its parent to the currently applied material, and assign it
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...
    def create_mid_for_decal(self) -> MaterialInstanceDynamic:
        r"""
        deprecated: 'create_mid_for_decal' was renamed to 'create_dynamic_material_instance'.
        """
        ...

class LightComponent(LightComponentBase):
    r"""
    Light Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_global_illumination`` (bool):  [Read-Write] Whether the light affects global illumination, when ray-traced global illumination is enabled.
    - ``affect_reflection`` (bool):  [Read-Write] Whether the light affects objects in reflections, when ray-traced reflection is enabled.
    - ``affect_translucent_lighting`` (bool):  [Read-Write] Whether the light affects translucency or not.  Disabling this can save GPU time when there are many small lights.
    - ``affects_world`` (bool):  [Read-Write] Whether the light can affect the world, or whether it is disabled.
      A disabled light will not contribute to the scene in any way.  This setting cannot be changed at runtime and unbuilds lighting when changed.
      Setting this to false has the same effect as deleting the light, so it is useful for non-destructive experiments.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bloom_max_brightness`` (float):  [Read-Write] After exposure is applied, scene color brightness larger than BloomMaxBrightness will be rescaled down to BloomMaxBrightness.
    - ``bloom_scale`` (float):  [Read-Write] Scales the additive color.
    - ``bloom_threshold`` (float):  [Read-Write] Scene color must be larger than this to create bloom in the light shafts.
    - ``bloom_tint`` (Color):  [Read-Write] Multiplies against scene color to create the bloom color.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_deep_shadow`` (bool):  [Read-Write] Whether the light should cast high quality hair-strands self-shadowing. When this option is enabled, an extra GPU cost for this light.
    - ``cast_dynamic_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from dynamic objects.  Also requires Cast Shadows to be set to True.
    - ``cast_raytraced_shadow`` (CastRayTracedShadow):  [Read-Write]
    - ``cast_shadows`` (bool):  [Read-Write] Whether the light should cast any shadows.
    - ``cast_shadows_from_cinematic_objects_only`` (bool):  [Read-Write] Whether the light should only cast shadows from components marked as bCastCinematicShadows.
      This is useful for setting up cinematic Movable spotlights aimed at characters and avoiding the shadow depth rendering costs of the background.
      Note: this only works with dynamic shadow maps, not with static shadowing or Ray Traced Distance Field shadows.
    - ``cast_static_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from static objects.  Also requires Cast Shadows to be set to True.
    - ``cast_translucent_shadows`` (bool):  [Read-Write] Whether the light is allowed to cast dynamic shadows from translucency.
    - ``cast_volumetric_shadow`` (bool):  [Read-Write] Whether the light shadows volumetric fog.  Disabling this can save GPU time.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``contact_shadow_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" enabled. 0 = no shadow, 1 (default) = fully shadowed.
    - ``contact_shadow_length`` (float):  [Read-Write] Length of screen space ray trace for sharp contact shadows. Zero is disabled.
    - ``contact_shadow_length_in_ws`` (bool):  [Read-Write] Where Length of screen space ray trace for sharp contact shadows is in world space units or in screen space units.
    - ``contact_shadow_non_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" disabled. 0 (default) = no shadow, 1 = fully shadowed.
    - ``deep_shadow_layer_distribution`` (float):  [Read-Write] Change the deep shadow layers distribution 0:linear distribution (uniform layer distribution), 1:exponential (more details on near small details).
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disabled_brightness`` (float):  [Read-Write] Brightness factor applied to the light when the light function is specified but disabled, for example in scene captures that use SceneCapView_LitNoShadows.
      This should be set to the average brightness of the light function material's emissive input, which should be between 0 and 1.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_light_shaft_bloom`` (bool):  [Read-Write] Whether to render light shaft bloom from this light.
      For directional lights, the color around the light direction will be blurred radially and added back to the scene.
      for point lights, the color on pixels closer than the light's SourceRadius will be blurred radially and added back to the scene.
    - ``force_cached_shadows_for_movable_primitives`` (bool):  [Read-Write] Enables cached shadows for movable primitives for this light even if r.shadow.cachedshadowscastfrommovableprimitives is 0
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``ies_brightness_scale`` (float):  [Read-Write] Global scale for IES brightness contribution. Only available when "Use IES Brightness" is selected, and a valid IES profile texture is set
    - ``ies_texture`` (TextureLightProfile):  [Read-Write] IES texture (light profiles from real world measured data)
    - ``indirect_lighting_intensity`` (float):  [Read-Write] Scales the indirect lighting contribution from this light.
      A value of 0 disables any GI from this light. Default is 1.
    - ``intensity`` (float):  [Read-Write] Total energy that the light emits.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``light_color`` (Color):  [Read-Write] Filter color of the light.
      Note that this can change the light's effective intensity.
    - ``light_function_fade_distance`` (float):  [Read-Write] Distance at which the light function should be completely faded to DisabledBrightness.
      This is useful for hiding aliasing from light functions applied in the distance.
    - ``light_function_material`` (MaterialInterface):  [Read-Write] The light function material to be applied to this light.
      Note that only non-lightmapped lights (UseDirectLightMap=False) can have a light function.
      Light functions are supported within VolumetricFog, but only for Directional, Point and Spot lights. Rect lights are not supported.
    - ``light_function_scale`` (Vector):  [Read-Write] Scales the light function projection.  X and Y scale in the directions perpendicular to the light's direction, Z scales along the light direction.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this light should affect.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``max_distance_fade_range`` (float):  [Read-Write]
    - ``max_draw_distance`` (float):  [Read-Write]
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_start_offset_depth_scale`` (float):  [Read-Write] Controls how large of an offset ray traced shadows have from the receiving surface as the camera gets further away.
      This can be useful to hide self-shadowing artifacts from low resolution distance fields on huge static meshes.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``samples_per_pixel`` (int32):  [Read-Write] Samples per pixel for ray tracing
    - ``shadow_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``shadow_resolution_scale`` (float):  [Read-Write] Scales the resolution of shadowmaps used to shadow this light.  By default shadowmap resolution is chosen based on screen size of the caster.
      Setting the scale to zero disables shadow maps, but does not disable, e.g., contact shadows.
      Note: shadowmap resolution is still clamped by 'r.Shadow.MaxResolution'
    - ``shadow_sharpen`` (float):  [Read-Write] Amount to sharpen shadow filtering
    - ``shadow_slope_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are. This works in addition to shadow bias, by increasing the
      amount of bias depending on the slope of a surface.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``specular_scale`` (float):  [Read-Write] Multiplier on specular highlights. Use only with great care! Any value besides 1 is not physical!
      Can be used to artistically remove highlights mimicking polarizing filters or photo touch up.
    - ``temperature`` (float):  [Read-Write] Color temperature in Kelvin of the blackbody illuminant.
      White (D65) is 6500K.
    - ``transmission`` (bool):  [Read-Write] Whether light from this light transmits through surfaces with subsurface scattering profiles. Requires light to be movable.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_ies_brightness`` (bool):  [Read-Write] true: take light brightness from IES profile, false: use the light brightness - the maximum light in one direction is used to define no masking. Use with InverseSquareFalloff. Will be disabled if a valid IES profile texture is not supplied.
    - ``use_ray_traced_distance_field_shadows`` (bool):  [Read-Write] Whether to use ray traced distance field area shadows.  The project setting bGenerateMeshDistanceFields must be enabled for this to have effect.
      Distance field shadows support area lights so they create soft shadows with sharp contacts.
      They have less aliasing artifacts than standard shadowmaps, but inherit all the limitations of distance field representations (only uniform scale, no deformation).
      These shadows have a low per-object cost (and don't depend on triangle count) so they are effective for distant shadows from a dynamic sun.
    - ``use_temperature`` (bool):  [Read-Write] false: use white (D65) as illuminant.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volumetric_scattering_intensity`` (float):  [Read-Write] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
    """
    @property
    def temperature(self) -> float:
        r"""
        (float):  [Read-Only] Color temperature in Kelvin of the blackbody illuminant.
        White (D65) is 6500K.
        """
        ...
    @property
    def use_temperature(self) -> bool:
        r"""
        (bool):  [Read-Only] false: use white (D65) as illuminant.
        """
        ...
    @property
    def specular_scale(self) -> float:
        r"""
        (float):  [Read-Only] Multiplier on specular highlights. Use only with great care! Any value besides 1 is not physical!
        Can be used to artistically remove highlights mimicking polarizing filters or photo touch up.
        """
        ...
    @property
    def shadow_resolution_scale(self) -> float:
        r"""
        (float):  [Read-Only] Scales the resolution of shadowmaps used to shadow this light.  By default shadowmap resolution is chosen based on screen size of the caster.
        Setting the scale to zero disables shadow maps, but does not disable, e.g., contact shadows.
        Note: shadowmap resolution is still clamped by 'r.Shadow.MaxResolution'
        """
        ...
    @property
    def shadow_bias(self) -> float:
        r"""
        (float):  [Read-Only] Controls how accurate self shadowing of whole scene shadows from this light are.
        At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
        larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
        around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
        """
        ...
    @property
    def shadow_slope_bias(self) -> float:
        r"""
        (float):  [Read-Only] Controls how accurate self shadowing of whole scene shadows from this light are. This works in addition to shadow bias, by increasing the
        amount of bias depending on the slope of a surface.
        At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
        larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
        around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
        """
        ...
    @property
    def shadow_sharpen(self) -> float:
        r"""
        (float):  [Read-Only] Amount to sharpen shadow filtering
        """
        ...
    @property
    def contact_shadow_length(self) -> float:
        r"""
        (float):  [Read-Write] Length of screen space ray trace for sharp contact shadows. Zero is disabled.
        """
        ...
    @contact_shadow_length.setter
    def contact_shadow_length(self, value: float) -> None:
        ...
    @property
    def contact_shadow_length_in_ws(self) -> bool:
        r"""
        (bool):  [Read-Write] Where Length of screen space ray trace for sharp contact shadows is in world space units or in screen space units.
        """
        ...
    @contact_shadow_length_in_ws.setter
    def contact_shadow_length_in_ws(self, value: bool) -> None:
        ...
    @property
    def contact_shadow_casting_intensity(self) -> float:
        r"""
        (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" enabled. 0 = no shadow, 1 (default) = fully shadowed.
        """
        ...
    @contact_shadow_casting_intensity.setter
    def contact_shadow_casting_intensity(self, value: float) -> None:
        ...
    @property
    def contact_shadow_non_casting_intensity(self) -> float:
        r"""
        (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" disabled. 0 (default) = no shadow, 1 = fully shadowed.
        """
        ...
    @contact_shadow_non_casting_intensity.setter
    def contact_shadow_non_casting_intensity(self, value: float) -> None:
        ...
    @property
    def cast_translucent_shadows(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light is allowed to cast dynamic shadows from translucency.
        """
        ...
    @property
    def cast_shadows_from_cinematic_objects_only(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light should only cast shadows from components marked as bCastCinematicShadows.
        This is useful for setting up cinematic Movable spotlights aimed at characters and avoiding the shadow depth rendering costs of the background.
        Note: this only works with dynamic shadow maps, not with static shadowing or Ray Traced Distance Field shadows.
        """
        ...
    @property
    def force_cached_shadows_for_movable_primitives(self) -> bool:
        r"""
        (bool):  [Read-Only] Enables cached shadows for movable primitives for this light even if r.shadow.cachedshadowscastfrommovableprimitives is 0
        """
        ...
    @property
    def lighting_channels(self) -> LightingChannels:
        r"""
        (LightingChannels):  [Read-Only] Channels that this light should affect.
        These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
        """
        ...
    @property
    def light_function_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Only] The light function material to be applied to this light.
        Note that only non-lightmapped lights (UseDirectLightMap=False) can have a light function.
        Light functions are supported within VolumetricFog, but only for Directional, Point and Spot lights. Rect lights are not supported.
        """
        ...
    @property
    def light_function_scale(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Scales the light function projection.  X and Y scale in the directions perpendicular to the light's direction, Z scales along the light direction.
        """
        ...
    @property
    def ies_texture(self) -> TextureLightProfile:
        r"""
        (TextureLightProfile):  [Read-Only] IES texture (light profiles from real world measured data)
        """
        ...
    @property
    def use_ies_brightness(self) -> bool:
        r"""
        (bool):  [Read-Only] true: take light brightness from IES profile, false: use the light brightness - the maximum light in one direction is used to define no masking. Use with InverseSquareFalloff. Will be disabled if a valid IES profile texture is not supplied.
        """
        ...
    @property
    def ies_brightness_scale(self) -> float:
        r"""
        (float):  [Read-Only] Global scale for IES brightness contribution. Only available when "Use IES Brightness" is selected, and a valid IES profile texture is set
        """
        ...
    @property
    def light_function_fade_distance(self) -> float:
        r"""
        (float):  [Read-Only] Distance at which the light function should be completely faded to DisabledBrightness.
        This is useful for hiding aliasing from light functions applied in the distance.
        """
        ...
    @property
    def disabled_brightness(self) -> float:
        r"""
        (float):  [Read-Only] Brightness factor applied to the light when the light function is specified but disabled, for example in scene captures that use SceneCapView_LitNoShadows.
        This should be set to the average brightness of the light function material's emissive input, which should be between 0 and 1.
        """
        ...
    @property
    def enable_light_shaft_bloom(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to render light shaft bloom from this light.
        For directional lights, the color around the light direction will be blurred radially and added back to the scene.
        for point lights, the color on pixels closer than the light's SourceRadius will be blurred radially and added back to the scene.
        """
        ...
    @property
    def bloom_scale(self) -> float:
        r"""
        (float):  [Read-Only] Scales the additive color.
        """
        ...
    @property
    def bloom_threshold(self) -> float:
        r"""
        (float):  [Read-Only] Scene color must be larger than this to create bloom in the light shafts.
        """
        ...
    @property
    def bloom_max_brightness(self) -> float:
        r"""
        (float):  [Read-Only] After exposure is applied, scene color brightness larger than BloomMaxBrightness will be rescaled down to BloomMaxBrightness.
        """
        ...
    @property
    def bloom_tint(self) -> Color:
        r"""
        (Color):  [Read-Only] Multiplies against scene color to create the bloom color.
        """
        ...
    @property
    def use_ray_traced_distance_field_shadows(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to use ray traced distance field area shadows.  The project setting bGenerateMeshDistanceFields must be enabled for this to have effect.
        Distance field shadows support area lights so they create soft shadows with sharp contacts.
        They have less aliasing artifacts than standard shadowmaps, but inherit all the limitations of distance field representations (only uniform scale, no deformation).
        These shadows have a low per-object cost (and don't depend on triangle count) so they are effective for distant shadows from a dynamic sun.
        """
        ...
    @property
    def ray_start_offset_depth_scale(self) -> float:
        r"""
        (float):  [Read-Only] Controls how large of an offset ray traced shadows have from the receiving surface as the camera gets further away.
        This can be useful to hide self-shadowing artifacts from low resolution distance fields on huge static meshes.
        """
        ...
    def set_volumetric_scattering_intensity(self, new_intensity: float) -> None:
        r"""
        x.set_volumetric_scattering_intensity(new_intensity) -> None
        Set Volumetric Scattering Intensity
        
        Args:
            new_intensity (float):
        """
        ...
    def set_use_temperature(self, new_value: bool) -> None:
        r"""
        x.set_use_temperature(new_value) -> None
        Set Use Temperature
        
        Args:
            new_value (bool):
        """
        ...
    def set_use_ies_brightness(self, new_value: bool) -> None:
        r"""
        x.set_use_ies_brightness(new_value) -> None
        Set Use IESBrightness
        
        Args:
            new_value (bool):
        """
        ...
    def set_transmission(self, new_value: bool) -> None:
        r"""
        x.set_transmission(new_value) -> None
        Set Transmission
        
        Args:
            new_value (bool):
        """
        ...
    def set_temperature(self, new_temperature: float) -> None:
        r"""
        x.set_temperature(new_temperature) -> None
        Set Temperature
        
        Args:
            new_temperature (float):
        """
        ...
    def set_specular_scale(self, new_value: float) -> None:
        r"""
        x.set_specular_scale(new_value) -> None
        Set Specular Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_shadow_slope_bias(self, new_value: float) -> None:
        r"""
        x.set_shadow_slope_bias(new_value) -> None
        Set Shadow Slope Bias
        
        Args:
            new_value (float):
        """
        ...
    def set_shadow_bias(self, new_value: float) -> None:
        r"""
        x.set_shadow_bias(new_value) -> None
        Set Shadow Bias
        
        Args:
            new_value (float):
        """
        ...
    def set_lighting_channels(self, channel0: bool, channel1: bool, channel2: bool) -> None:
        r"""
        x.set_lighting_channels(channel0, channel1, channel2) -> None
        Set Lighting Channels
        
        Args:
            channel0 (bool): 
            channel1 (bool): 
            channel2 (bool):
        """
        ...
    def set_light_function_scale(self, new_light_function_scale: Vector) -> None:
        r"""
        x.set_light_function_scale(new_light_function_scale) -> None
        Set Light Function Scale
        
        Args:
            new_light_function_scale (Vector):
        """
        ...
    def set_light_function_material(self, new_light_function_material: MaterialInterface) -> None:
        r"""
        x.set_light_function_material(new_light_function_material) -> None
        Set Light Function Material
        
        Args:
            new_light_function_material (MaterialInterface):
        """
        ...
    def set_light_function_fade_distance(self, new_light_function_fade_distance: float) -> None:
        r"""
        x.set_light_function_fade_distance(new_light_function_fade_distance) -> None
        Set Light Function Fade Distance
        
        Args:
            new_light_function_fade_distance (float):
        """
        ...
    def set_light_function_disabled_brightness(self, new_value: float) -> None:
        r"""
        x.set_light_function_disabled_brightness(new_value) -> None
        Set Light Function Disabled Brightness
        
        Args:
            new_value (float):
        """
        ...
    def set_light_color(self, new_light_color: LinearColor, srgb: bool = True) -> None:
        r"""
        x.set_light_color(new_light_color, srgb=True) -> None
        Set color of the light
        
        Args:
            new_light_color (LinearColor): 
            srgb (bool):
        """
        ...
    def set_intensity(self, new_intensity: float) -> None:
        r"""
        x.set_intensity(new_intensity) -> None
        Set intensity of the light
        
        Args:
            new_intensity (float):
        """
        ...
    def set_brightness(self, new_intensity: float) -> None:
        r"""
        deprecated: 'set_brightness' was renamed to 'set_intensity'.
        """
        ...
    def set_indirect_lighting_intensity(self, new_intensity: float) -> None:
        r"""
        x.set_indirect_lighting_intensity(new_intensity) -> None
        Set Indirect Lighting Intensity
        
        Args:
            new_intensity (float):
        """
        ...
    def set_ies_texture(self, new_value: TextureLightProfile) -> None:
        r"""
        x.set_ies_texture(new_value) -> None
        Set IESTexture
        
        Args:
            new_value (TextureLightProfile):
        """
        ...
    def set_ies_brightness_scale(self, new_value: float) -> None:
        r"""
        x.set_ies_brightness_scale(new_value) -> None
        Set IESBrightness Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_force_cached_shadows_for_movable_primitives(self, new_value: bool) -> None:
        r"""
        x.set_force_cached_shadows_for_movable_primitives(new_value) -> None
        Set Force Cached Shadows for Movable Primitives
        
        Args:
            new_value (bool):
        """
        ...
    def set_enable_light_shaft_bloom(self, new_value: bool) -> None:
        r"""
        x.set_enable_light_shaft_bloom(new_value) -> None
        Set Enable Light Shaft Bloom
        
        Args:
            new_value (bool):
        """
        ...
    def set_bloom_tint(self, new_value: Color) -> None:
        r"""
        x.set_bloom_tint(new_value) -> None
        Set Bloom Tint
        
        Args:
            new_value (Color):
        """
        ...
    def set_bloom_threshold(self, new_value: float) -> None:
        r"""
        x.set_bloom_threshold(new_value) -> None
        Set Bloom Threshold
        
        Args:
            new_value (float):
        """
        ...
    def set_bloom_scale(self, new_value: float) -> None:
        r"""
        x.set_bloom_scale(new_value) -> None
        Set Bloom Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_bloom_max_brightness(self, new_value: float) -> None:
        r"""
        x.set_bloom_max_brightness(new_value) -> None
        Set Bloom Max Brightness
        
        Args:
            new_value (float):
        """
        ...
    def set_affect_translucent_lighting(self, new_value: bool) -> None:
        r"""
        x.set_affect_translucent_lighting(new_value) -> None
        Set Affect Translucent Lighting
        
        Args:
            new_value (bool):
        """
        ...

class DirectionalLightComponent(LightComponent):
    r"""
    A light component that has parallel rays. Will provide a uniform lighting across any affected surface (eg. The Sun). This will affect all objects in the defined light-mass importance volume.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DirectionalLightComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_global_illumination`` (bool):  [Read-Write] Whether the light affects global illumination, when ray-traced global illumination is enabled.
    - ``affect_reflection`` (bool):  [Read-Write] Whether the light affects objects in reflections, when ray-traced reflection is enabled.
    - ``affect_translucent_lighting`` (bool):  [Read-Write] Whether the light affects translucency or not.  Disabling this can save GPU time when there are many small lights.
    - ``affects_world`` (bool):  [Read-Write] Whether the light can affect the world, or whether it is disabled.
      A disabled light will not contribute to the scene in any way.  This setting cannot be changed at runtime and unbuilds lighting when changed.
      Setting this to false has the same effect as deleting the light, so it is useful for non-destructive experiments.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``atmosphere_sun_disk_color_scale`` (LinearColor):  [Read-Write] A color multiplied with the sun disk luminance.
    - ``atmosphere_sun_light`` (bool):  [Read-Write] Whether the directional light can interact with the atmosphere, cloud and generate a visual disk. All of which compose the visual sky.
    - ``atmosphere_sun_light_index`` (int32):  [Read-Write] Two atmosphere lights are supported. For instance: a sun and a moon, or two suns.
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bloom_max_brightness`` (float):  [Read-Write] After exposure is applied, scene color brightness larger than BloomMaxBrightness will be rescaled down to BloomMaxBrightness.
    - ``bloom_scale`` (float):  [Read-Write] Scales the additive color.
    - ``bloom_threshold`` (float):  [Read-Write] Scene color must be larger than this to create bloom in the light shafts.
    - ``bloom_tint`` (Color):  [Read-Write] Multiplies against scene color to create the bloom color.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cascade_distribution_exponent`` (float):  [Read-Write] Controls whether the cascades are distributed closer to the camera (larger exponent) or further from the camera (smaller exponent).
      An exponent of 1 means that cascade transitions will happen at a distance proportional to their resolution.
    - ``cascade_transition_fraction`` (float):  [Read-Write] Proportion of the fade region between cascades.
      Pixels within the fade region of two cascades have their shadows blended to avoid hard transitions between quality levels.
      A value of zero eliminates the fade region, creating hard transitions.
      Higher values increase the size of the fade region, creating a more gradual transition between cascades.
      The value is expressed as a percentage proportion (i.e. 0.1 = 10% overlap).
      Ideal values are the smallest possible which still hide the transition.
      An increased fade region size causes an increase in shadow rendering cost.
    - ``cast_cloud_shadows`` (bool):  [Read-Write] Whether the light should cast any shadows from clouds onto the atmosphere and other scene elements.
    - ``cast_deep_shadow`` (bool):  [Read-Write] Whether the light should cast high quality hair-strands self-shadowing. When this option is enabled, an extra GPU cost for this light.
    - ``cast_dynamic_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from dynamic objects.  Also requires Cast Shadows to be set to True.
    - ``cast_modulated_shadows`` (bool):  [Read-Write] Whether the light should cast modulated shadows from dynamic objects (mobile only).  Also requires Cast Shadows to be set to True.
    - ``cast_raytraced_shadow`` (CastRayTracedShadow):  [Read-Write]
    - ``cast_shadows`` (bool):  [Read-Write] Whether the light should cast any shadows.
    - ``cast_shadows_from_cinematic_objects_only`` (bool):  [Read-Write] Whether the light should only cast shadows from components marked as bCastCinematicShadows.
      This is useful for setting up cinematic Movable spotlights aimed at characters and avoiding the shadow depth rendering costs of the background.
      Note: this only works with dynamic shadow maps, not with static shadowing or Ray Traced Distance Field shadows.
    - ``cast_shadows_on_atmosphere`` (bool):  [Read-Write] Whether the light should cast any shadows from opaque meshes onto the atmosphere.
    - ``cast_shadows_on_clouds`` (bool):  [Read-Write] Whether the light should cast any shadows from opaque meshes onto clouds. This is disabled when 'Atmosphere Sun Light Index' is set to 1.
    - ``cast_static_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from static objects.  Also requires Cast Shadows to be set to True.
    - ``cast_translucent_shadows`` (bool):  [Read-Write] Whether the light is allowed to cast dynamic shadows from translucency.
    - ``cast_volumetric_shadow`` (bool):  [Read-Write] Whether the light shadows volumetric fog.  Disabling this can save GPU time.
    - ``cloud_scattered_luminance_scale`` (LinearColor):  [Read-Write] Scales the lights contribution when scattered in cloud participating media. This can help counter balance the fact that our multiple scattering solution is only an approximation.
    - ``cloud_shadow_depth_bias`` (float):  [Read-Write] The bias applied to the shadow front depth of the volumetric cloud shadow map.
    - ``cloud_shadow_extent`` (float):  [Read-Write] The world space radius of the cloud shadow map around the camera in kilometers.
    - ``cloud_shadow_map_resolution_scale`` (float):  [Read-Write] Scale the cloud shadow map resolution, base resolution is 512. The resolution is still clamped to 'r.VolumetricCloud.ShadowMap.MaxResolution'.
    - ``cloud_shadow_on_atmosphere_strength`` (float):  [Read-Write] The strength of the shadow on atmosphere. Disabled when 0.
    - ``cloud_shadow_on_surface_strength`` (float):  [Read-Write] The strength of the shadow on opaque and transparent meshes. Disabled when 0.
    - ``cloud_shadow_ray_sample_count_scale`` (float):  [Read-Write] Scale the shadow map tracing sample count.
      The sample count resolution is still clamped according to scalability setting to 'r.VolumetricCloud.ShadowMap.RaySampleMaxCount'.
    - ``cloud_shadow_strength`` (float):  [Read-Write] The overall strength of the cloud shadow, higher value will block more light.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``contact_shadow_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" enabled. 0 = no shadow, 1 (default) = fully shadowed.
    - ``contact_shadow_length`` (float):  [Read-Write] Length of screen space ray trace for sharp contact shadows. Zero is disabled.
    - ``contact_shadow_length_in_ws`` (bool):  [Read-Write] Where Length of screen space ray trace for sharp contact shadows is in world space units or in screen space units.
    - ``contact_shadow_non_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" disabled. 0 (default) = no shadow, 1 = fully shadowed.
    - ``deep_shadow_layer_distribution`` (float):  [Read-Write] Change the deep shadow layers distribution 0:linear distribution (uniform layer distribution), 1:exponential (more details on near small details).
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disabled_brightness`` (float):  [Read-Write] Brightness factor applied to the light when the light function is specified but disabled, for example in scene captures that use SceneCapView_LitNoShadows.
      This should be set to the average brightness of the light function material's emissive input, which should be between 0 and 1.
    - ``distance_field_shadow_distance`` (float):  [Read-Write] Distance at which the ray traced shadow cascade should end.  Distance field shadows will cover the range between 'Dynamic Shadow Distance' this distance.
    - ``dynamic_shadow_cascades`` (int32):  [Read-Write] Number of cascades to split the view frustum into for the whole scene dynamic shadow.
      More cascades result in better shadow resolution, but adds significant rendering cost.
    - ``dynamic_shadow_distance_movable_light`` (float):  [Read-Write] How far Cascaded Shadow Map dynamic shadows will cover for a movable light, measured from the camera.
      A value of 0 disables the dynamic shadow.
    - ``dynamic_shadow_distance_stationary_light`` (float):  [Read-Write] How far Cascaded Shadow Map dynamic shadows will cover for a stationary light, measured from the camera.
      A value of 0 disables the dynamic shadow.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_light_shaft_bloom`` (bool):  [Read-Write] Whether to render light shaft bloom from this light.
      For directional lights, the color around the light direction will be blurred radially and added back to the scene.
      for point lights, the color on pixels closer than the light's SourceRadius will be blurred radially and added back to the scene.
    - ``enable_light_shaft_occlusion`` (bool):  [Read-Write] Whether to occlude fog and atmosphere inscattering with screenspace blurred occlusion from this light.
    - ``far_shadow_cascade_count`` (int32):  [Read-Write] 0: no Far Shadow Cascades, otherwise the number of cascades between DynamicShadowDistance and FarShadowDistance that are covered by Far Shadow Cascades.
    - ``far_shadow_distance`` (float):  [Read-Write] Distance at which the far shadow cascade should end.  Far shadows will cover the range between 'Dynamic Shadow Distance' and this distance.
    - ``force_cached_shadows_for_movable_primitives`` (bool):  [Read-Write] Enables cached shadows for movable primitives for this light even if r.shadow.cachedshadowscastfrommovableprimitives is 0
    - ``forward_shading_priority`` (int32):  [Read-Write] Forward lighting priority for the single directional light that will be used for forward shading, translucent, single layer water and volumetric fog.
      When two lights have equal priorities, the selection will be based on their overall brightness as a fallback.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``ies_brightness_scale`` (float):  [Read-Write] Global scale for IES brightness contribution. Only available when "Use IES Brightness" is selected, and a valid IES profile texture is set
    - ``ies_texture`` (TextureLightProfile):  [Read-Write] IES texture (light profiles from real world measured data)
    - ``indirect_lighting_intensity`` (float):  [Read-Write] Scales the indirect lighting contribution from this light.
      A value of 0 disables any GI from this light. Default is 1.
    - ``intensity`` (float):  [Read-Write] Total energy that the light emits.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``light_color`` (Color):  [Read-Write] Filter color of the light.
      Note that this can change the light's effective intensity.
    - ``light_function_fade_distance`` (float):  [Read-Write] Distance at which the light function should be completely faded to DisabledBrightness.
      This is useful for hiding aliasing from light functions applied in the distance.
    - ``light_function_material`` (MaterialInterface):  [Read-Write] The light function material to be applied to this light.
      Note that only non-lightmapped lights (UseDirectLightMap=False) can have a light function.
      Light functions are supported within VolumetricFog, but only for Directional, Point and Spot lights. Rect lights are not supported.
    - ``light_function_scale`` (Vector):  [Read-Write] Scales the light function projection.  X and Y scale in the directions perpendicular to the light's direction, Z scales along the light direction.
    - ``light_shaft_override_direction`` (Vector):  [Read-Write] Can be used to make light shafts come from somewhere other than the light's actual direction.
      This will only be used when non-zero.  It does not have to be normalized.
    - ``light_source_angle`` (float):  [Read-Write] Angle subtended by light source in degrees (also known as angular diameter).
      Defaults to 0.5357 which is the angle for our sun.
    - ``light_source_soft_angle`` (float):  [Read-Write] Angle subtended by soft light source in degrees.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this light should affect.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmass_settings`` (LightmassDirectionalLightSettings):  [Read-Write] The Lightmass settings for this object.
    - ``max_distance_fade_range`` (float):  [Read-Write]
    - ``max_draw_distance`` (float):  [Read-Write]
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulated_shadow_color`` (Color):  [Read-Write] Color to modulate against the scene color when rendering modulated shadows. (mobile only)
    - ``occlusion_depth_range`` (float):  [Read-Write] Everything closer to the camera than this distance will occlude light shafts.
    - ``occlusion_mask_darkness`` (float):  [Read-Write] Controls how dark the occlusion masking is, a value of 1 results in no darkening term.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``per_pixel_atmosphere_transmittance`` (bool):  [Read-Write] Whether to apply atmosphere transmittance per pixel on opaque meshes, instead of using the light global transmittance. Note: VolumetricCloud per pixel transmittance option is selectable on the VolumetricCloud component itself.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_start_offset_depth_scale`` (float):  [Read-Write] Controls how large of an offset ray traced shadows have from the receiving surface as the camera gets further away.
      This can be useful to hide self-shadowing artifacts from low resolution distance fields on huge static meshes.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``samples_per_pixel`` (int32):  [Read-Write] Samples per pixel for ray tracing
    - ``shadow_amount`` (float):  [Read-Write] Control the amount of shadow occlusion. A value of 0 means no occlusion, thus no shadow.
    - ``shadow_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``shadow_cascade_bias_distribution`` (float):  [Read-Write] Controls the depth bias scaling across cascades. This allows to mitigage the shadow acne difference on shadow cascades transition.
      A value of 1 scales shadow bias based on each cascade size (Default).
      A value of 0 scales shadow bias uniformly accross all cacascade.
    - ``shadow_distance_fadeout_fraction`` (float):  [Read-Write] Controls the size of the fade out region at the far extent of the dynamic shadow's influence.
      This is specified as a fraction of DynamicShadowDistance.
    - ``shadow_resolution_scale`` (float):  [Read-Write] Scales the resolution of shadowmaps used to shadow this light.  By default shadowmap resolution is chosen based on screen size of the caster.
      Setting the scale to zero disables shadow maps, but does not disable, e.g., contact shadows.
      Note: shadowmap resolution is still clamped by 'r.Shadow.MaxResolution'
    - ``shadow_sharpen`` (float):  [Read-Write] Amount to sharpen shadow filtering
    - ``shadow_slope_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are. This works in addition to shadow bias, by increasing the
      amount of bias depending on the slope of a surface.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``shadow_source_angle_factor`` (float):  [Read-Write] Shadow source angle factor, relative to the light source angle.
      Defaults to 1.0 to coincide with light source angle.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``specular_scale`` (float):  [Read-Write] Multiplier on specular highlights. Use only with great care! Any value besides 1 is not physical!
      Can be used to artistically remove highlights mimicking polarizing filters or photo touch up.
    - ``temperature`` (float):  [Read-Write] Color temperature in Kelvin of the blackbody illuminant.
      White (D65) is 6500K.
    - ``trace_distance`` (float):  [Read-Write] Determines how far shadows can be cast, in world units.  Larger values increase the shadowing cost.
    - ``transmission`` (bool):  [Read-Write] Whether light from this light transmits through surfaces with subsurface scattering profiles. Requires light to be movable.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_ies_brightness`` (bool):  [Read-Write] true: take light brightness from IES profile, false: use the light brightness - the maximum light in one direction is used to define no masking. Use with InverseSquareFalloff. Will be disabled if a valid IES profile texture is not supplied.
    - ``use_inset_shadows_for_movable_objects`` (bool):  [Read-Write] Stationary lights only: Whether to use per-object inset shadows for movable components, even though cascaded shadow maps are enabled.
      This allows dynamic objects to have a shadow even when they are outside of the cascaded shadow map, which is important when DynamicShadowDistanceStationaryLight is small.
      If DynamicShadowDistanceStationaryLight is large (currently > 8000), this will be forced off.
      Disabling this can reduce shadowing cost significantly with many movable objects.
    - ``use_ray_traced_distance_field_shadows`` (bool):  [Read-Write] Whether to use ray traced distance field area shadows.  The project setting bGenerateMeshDistanceFields must be enabled for this to have effect.
      Distance field shadows support area lights so they create soft shadows with sharp contacts.
      They have less aliasing artifacts than standard shadowmaps, but inherit all the limitations of distance field representations (only uniform scale, no deformation).
      These shadows have a low per-object cost (and don't depend on triangle count) so they are effective for distant shadows from a dynamic sun.
    - ``use_temperature`` (bool):  [Read-Write] false: use white (D65) as illuminant.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volumetric_scattering_intensity`` (float):  [Read-Write] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
    """
    @property
    def shadow_cascade_bias_distribution(self) -> float:
        r"""
        (float):  [Read-Only] Controls the depth bias scaling across cascades. This allows to mitigage the shadow acne difference on shadow cascades transition.
        A value of 1 scales shadow bias based on each cascade size (Default).
        A value of 0 scales shadow bias uniformly accross all cacascade.
        """
        ...
    @property
    def enable_light_shaft_occlusion(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to occlude fog and atmosphere inscattering with screenspace blurred occlusion from this light.
        """
        ...
    @property
    def occlusion_mask_darkness(self) -> float:
        r"""
        (float):  [Read-Only] Controls how dark the occlusion masking is, a value of 1 results in no darkening term.
        """
        ...
    @property
    def occlusion_depth_range(self) -> float:
        r"""
        (float):  [Read-Only] Everything closer to the camera than this distance will occlude light shafts.
        """
        ...
    @property
    def light_shaft_override_direction(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Can be used to make light shafts come from somewhere other than the light's actual direction.
        This will only be used when non-zero.  It does not have to be normalized.
        """
        ...
    @property
    def dynamic_shadow_distance_movable_light(self) -> float:
        r"""
        (float):  [Read-Only] How far Cascaded Shadow Map dynamic shadows will cover for a movable light, measured from the camera.
        A value of 0 disables the dynamic shadow.
        """
        ...
    @property
    def movable_whole_scene_dynamic_shadow_radius(self) -> float:
        r"""
        deprecated: 'movable_whole_scene_dynamic_shadow_radius' was renamed to 'dynamic_shadow_distance_movable_light'.
        """
        ...
    @property
    def dynamic_shadow_distance_stationary_light(self) -> float:
        r"""
        (float):  [Read-Only] How far Cascaded Shadow Map dynamic shadows will cover for a stationary light, measured from the camera.
        A value of 0 disables the dynamic shadow.
        """
        ...
    @property
    def stationary_whole_scene_dynamic_shadow_radius(self) -> float:
        r"""
        deprecated: 'stationary_whole_scene_dynamic_shadow_radius' was renamed to 'dynamic_shadow_distance_stationary_light'.
        """
        ...
    @property
    def dynamic_shadow_cascades(self) -> int:
        r"""
        (int32):  [Read-Only] Number of cascades to split the view frustum into for the whole scene dynamic shadow.
        More cascades result in better shadow resolution, but adds significant rendering cost.
        """
        ...
    @property
    def cascade_distribution_exponent(self) -> float:
        r"""
        (float):  [Read-Only] Controls whether the cascades are distributed closer to the camera (larger exponent) or further from the camera (smaller exponent).
        An exponent of 1 means that cascade transitions will happen at a distance proportional to their resolution.
        """
        ...
    @property
    def cascade_transition_fraction(self) -> float:
        r"""
        (float):  [Read-Only] Proportion of the fade region between cascades.
        Pixels within the fade region of two cascades have their shadows blended to avoid hard transitions between quality levels.
        A value of zero eliminates the fade region, creating hard transitions.
        Higher values increase the size of the fade region, creating a more gradual transition between cascades.
        The value is expressed as a percentage proportion (i.e. 0.1 = 10% overlap).
        Ideal values are the smallest possible which still hide the transition.
        An increased fade region size causes an increase in shadow rendering cost.
        """
        ...
    @property
    def shadow_distance_fadeout_fraction(self) -> float:
        r"""
        (float):  [Read-Only] Controls the size of the fade out region at the far extent of the dynamic shadow's influence.
        This is specified as a fraction of DynamicShadowDistance.
        """
        ...
    @property
    def use_inset_shadows_for_movable_objects(self) -> bool:
        r"""
        (bool):  [Read-Only] Stationary lights only: Whether to use per-object inset shadows for movable components, even though cascaded shadow maps are enabled.
        This allows dynamic objects to have a shadow even when they are outside of the cascaded shadow map, which is important when DynamicShadowDistanceStationaryLight is small.
        If DynamicShadowDistanceStationaryLight is large (currently > 8000), this will be forced off.
        Disabling this can reduce shadowing cost significantly with many movable objects.
        """
        ...
    @property
    def far_shadow_cascade_count(self) -> int:
        r"""
        (int32):  [Read-Only] 0: no Far Shadow Cascades, otherwise the number of cascades between DynamicShadowDistance and FarShadowDistance that are covered by Far Shadow Cascades.
        """
        ...
    @property
    def far_shadow_distance(self) -> float:
        r"""
        (float):  [Read-Only] Distance at which the far shadow cascade should end.  Far shadows will cover the range between 'Dynamic Shadow Distance' and this distance.
        """
        ...
    @property
    def distance_field_shadow_distance(self) -> float:
        r"""
        (float):  [Read-Only] Distance at which the ray traced shadow cascade should end.  Distance field shadows will cover the range between 'Dynamic Shadow Distance' this distance.
        """
        ...
    @property
    def forward_shading_priority(self) -> int:
        r"""
        (int32):  [Read-Only] Forward lighting priority for the single directional light that will be used for forward shading, translucent, single layer water and volumetric fog.
        When two lights have equal priorities, the selection will be based on their overall brightness as a fallback.
        """
        ...
    @property
    def light_source_angle(self) -> float:
        r"""
        (float):  [Read-Only] Angle subtended by light source in degrees (also known as angular diameter).
        Defaults to 0.5357 which is the angle for our sun.
        """
        ...
    @property
    def light_source_soft_angle(self) -> float:
        r"""
        (float):  [Read-Only] Angle subtended by soft light source in degrees.
        """
        ...
    @property
    def shadow_source_angle_factor(self) -> float:
        r"""
        (float):  [Read-Only] Shadow source angle factor, relative to the light source angle.
        Defaults to 1.0 to coincide with light source angle.
        """
        ...
    @property
    def trace_distance(self) -> float:
        r"""
        (float):  [Read-Only] Determines how far shadows can be cast, in world units.  Larger values increase the shadowing cost.
        """
        ...
    @property
    def atmosphere_sun_light(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the directional light can interact with the atmosphere, cloud and generate a visual disk. All of which compose the visual sky.
        """
        ...
    @property
    def atmosphere_sun_light_index(self) -> int:
        r"""
        (int32):  [Read-Only] Two atmosphere lights are supported. For instance: a sun and a moon, or two suns.
        """
        ...
    @property
    def atmosphere_sun_disk_color_scale(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] A color multiplied with the sun disk luminance.
        """
        ...
    @property
    def per_pixel_atmosphere_transmittance(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to apply atmosphere transmittance per pixel on opaque meshes, instead of using the light global transmittance. Note: VolumetricCloud per pixel transmittance option is selectable on the VolumetricCloud component itself.
        """
        ...
    @property
    def cast_shadows_on_clouds(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light should cast any shadows from opaque meshes onto clouds. This is disabled when 'Atmosphere Sun Light Index' is set to 1.
        """
        ...
    @property
    def cast_shadows_on_atmosphere(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light should cast any shadows from opaque meshes onto the atmosphere.
        """
        ...
    @property
    def cast_cloud_shadows(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light should cast any shadows from clouds onto the atmosphere and other scene elements.
        """
        ...
    @property
    def cloud_shadow_strength(self) -> float:
        r"""
        (float):  [Read-Only] The overall strength of the cloud shadow, higher value will block more light.
        """
        ...
    @property
    def cloud_shadow_on_atmosphere_strength(self) -> float:
        r"""
        (float):  [Read-Only] The strength of the shadow on atmosphere. Disabled when 0.
        """
        ...
    @property
    def cloud_shadow_on_surface_strength(self) -> float:
        r"""
        (float):  [Read-Only] The strength of the shadow on opaque and transparent meshes. Disabled when 0.
        """
        ...
    @property
    def cloud_shadow_depth_bias(self) -> float:
        r"""
        (float):  [Read-Only] The bias applied to the shadow front depth of the volumetric cloud shadow map.
        """
        ...
    @property
    def cloud_shadow_extent(self) -> float:
        r"""
        (float):  [Read-Only] The world space radius of the cloud shadow map around the camera in kilometers.
        """
        ...
    @property
    def cloud_shadow_map_resolution_scale(self) -> float:
        r"""
        (float):  [Read-Only] Scale the cloud shadow map resolution, base resolution is 512. The resolution is still clamped to 'r.VolumetricCloud.ShadowMap.MaxResolution'.
        """
        ...
    @property
    def cloud_shadow_ray_sample_count_scale(self) -> float:
        r"""
        (float):  [Read-Only] Scale the shadow map tracing sample count.
        The sample count resolution is still clamped according to scalability setting to 'r.VolumetricCloud.ShadowMap.RaySampleMaxCount'.
        """
        ...
    @property
    def cloud_scattered_luminance_scale(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Scales the lights contribution when scattered in cloud participating media. This can help counter balance the fact that our multiple scattering solution is only an approximation.
        """
        ...
    @property
    def cast_modulated_shadows(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the light should cast modulated shadows from dynamic objects (mobile only).  Also requires Cast Shadows to be set to True.
        """
        ...
    @property
    def modulated_shadow_color(self) -> Color:
        r"""
        (Color):  [Read-Only] Color to modulate against the scene color when rendering modulated shadows. (mobile only)
        """
        ...
    @property
    def shadow_amount(self) -> float:
        r"""
        (float):  [Read-Only] Control the amount of shadow occlusion. A value of 0 means no occlusion, thus no shadow.
        """
        ...
    def set_shadow_source_angle_factor(self, new_value: float) -> None:
        r"""
        x.set_shadow_source_angle_factor(new_value) -> None
        Set Shadow Source Angle Factor
        
        Args:
            new_value (float):
        """
        ...
    def set_shadow_distance_fadeout_fraction(self, new_value: float) -> None:
        r"""
        x.set_shadow_distance_fadeout_fraction(new_value) -> None
        Set Shadow Distance Fadeout Fraction
        
        Args:
            new_value (float):
        """
        ...
    def set_shadow_cascade_bias_distribution(self, new_value: float) -> None:
        r"""
        x.set_shadow_cascade_bias_distribution(new_value) -> None
        Set Shadow Cascade Bias Distribution
        
        Args:
            new_value (float):
        """
        ...
    def set_shadow_amount(self, new_value: float) -> None:
        r"""
        x.set_shadow_amount(new_value) -> None
        Set Shadow Amount
        
        Args:
            new_value (float):
        """
        ...
    def set_occlusion_mask_darkness(self, new_value: float) -> None:
        r"""
        x.set_occlusion_mask_darkness(new_value) -> None
        Set Occlusion Mask Darkness
        
        Args:
            new_value (float):
        """
        ...
    def set_occlusion_depth_range(self, new_value: float) -> None:
        r"""
        x.set_occlusion_depth_range(new_value) -> None
        Set Occlusion Depth Range
        
        Args:
            new_value (float):
        """
        ...
    def set_light_source_soft_angle(self, new_value: float) -> None:
        r"""
        x.set_light_source_soft_angle(new_value) -> None
        Set Light Source Soft Angle
        
        Args:
            new_value (float):
        """
        ...
    def set_light_source_angle(self, new_value: float) -> None:
        r"""
        x.set_light_source_angle(new_value) -> None
        Set Light Source Angle
        
        Args:
            new_value (float):
        """
        ...
    def set_light_shaft_override_direction(self, new_value: Vector) -> None:
        r"""
        x.set_light_shaft_override_direction(new_value) -> None
        Set Light Shaft Override Direction
        
        Args:
            new_value (Vector):
        """
        ...
    def set_forward_shading_priority(self, new_value: int) -> None:
        r"""
        x.set_forward_shading_priority(new_value) -> None
        Set Forward Shading Priority
        
        Args:
            new_value (int32):
        """
        ...
    def set_enable_light_shaft_occlusion(self, new_value: bool) -> None:
        r"""
        x.set_enable_light_shaft_occlusion(new_value) -> None
        Set Enable Light Shaft Occlusion
        
        Args:
            new_value (bool):
        """
        ...
    def set_dynamic_shadow_distance_stationary_light(self, new_value: float) -> None:
        r"""
        x.set_dynamic_shadow_distance_stationary_light(new_value) -> None
        Set Dynamic Shadow Distance Stationary Light
        
        Args:
            new_value (float):
        """
        ...
    def set_dynamic_shadow_distance_movable_light(self, new_value: float) -> None:
        r"""
        x.set_dynamic_shadow_distance_movable_light(new_value) -> None
        Set Dynamic Shadow Distance Movable Light
        
        Args:
            new_value (float):
        """
        ...
    def set_dynamic_shadow_cascades(self, new_value: int) -> None:
        r"""
        x.set_dynamic_shadow_cascades(new_value) -> None
        Set Dynamic Shadow Cascades
        
        Args:
            new_value (int32):
        """
        ...
    def set_cascade_transition_fraction(self, new_value: float) -> None:
        r"""
        x.set_cascade_transition_fraction(new_value) -> None
        Set Cascade Transition Fraction
        
        Args:
            new_value (float):
        """
        ...
    def set_cascade_distribution_exponent(self, new_value: float) -> None:
        r"""
        x.set_cascade_distribution_exponent(new_value) -> None
        Set Cascade Distribution Exponent
        
        Args:
            new_value (float):
        """
        ...
    def set_atmosphere_sun_light_index(self, new_value: int) -> None:
        r"""
        x.set_atmosphere_sun_light_index(new_value) -> None
        Set Atmosphere Sun Light Index
        
        Args:
            new_value (int32):
        """
        ...
    def set_atmosphere_sun_light(self, new_value: bool) -> None:
        r"""
        x.set_atmosphere_sun_light(new_value) -> None
        Set Atmosphere Sun Light
        
        Args:
            new_value (bool):
        """
        ...

class DrawFrustumComponent(PrimitiveComponent):
    r"""
    Utility component for drawing a view frustum. Origin is at the component location, frustum points down position X axis.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DrawFrustumComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``frustum_angle`` (float):  [Read-Write] Angle of longest dimension of view shape.
      If the angle is 0 then an orthographic projection is used
    - ``frustum_aspect_ratio`` (float):  [Read-Write] Ratio of horizontal size over vertical size.
    - ``frustum_color`` (Color):  [Read-Write] Color to draw the wireframe frustum.
    - ``frustum_enabled`` (bool):  [Read-Write] Enable or disable frustum visualization for this camera
    - ``frustum_end_dist`` (float):  [Read-Write] Distance from origin to stop drawing the frustum.
    - ``frustum_start_dist`` (float):  [Read-Write] Distance from origin to start drawing the frustum.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``texture`` (Texture):  [Read-Write] optional texture to show on the near plane
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def frustum_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable or disable frustum visualization for this camera
        """
        ...
    @frustum_enabled.setter
    def frustum_enabled(self, value: bool) -> None:
        ...
    @property
    def frustum_color(self) -> Color:
        r"""
        (Color):  [Read-Write] Color to draw the wireframe frustum.
        """
        ...
    @frustum_color.setter
    def frustum_color(self, value: Color) -> None:
        ...
    @property
    def frustum_angle(self) -> float:
        r"""
        (float):  [Read-Write] Angle of longest dimension of view shape.
        If the angle is 0 then an orthographic projection is used
        """
        ...
    @frustum_angle.setter
    def frustum_angle(self, value: float) -> None:
        ...
    @property
    def frustum_aspect_ratio(self) -> float:
        r"""
        (float):  [Read-Write] Ratio of horizontal size over vertical size.
        """
        ...
    @frustum_aspect_ratio.setter
    def frustum_aspect_ratio(self, value: float) -> None:
        ...
    @property
    def frustum_start_dist(self) -> float:
        r"""
        (float):  [Read-Write] Distance from origin to start drawing the frustum.
        """
        ...
    @frustum_start_dist.setter
    def frustum_start_dist(self, value: float) -> None:
        ...
    @property
    def frustum_end_dist(self) -> float:
        r"""
        (float):  [Read-Write] Distance from origin to stop drawing the frustum.
        """
        ...
    @frustum_end_dist.setter
    def frustum_end_dist(self, value: float) -> None:
        ...
    @property
    def texture(self) -> Texture:
        r"""
        (Texture):  [Read-Write] optional texture to show on the near plane
        """
        ...
    @texture.setter
    def texture(self, value: Texture) -> None:
        ...

class SphereComponent(ShapeComponent):
    r"""
    A sphere generally used for simple collision. Bounds are rendered as lines in the editor.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SphereComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``area_class_override`` (type(Class)):  [Read-Write] Navigation area type override, null / none = no change to nav mesh.
      bDynamicObstacle must be true and bUseSystemDefaultAreaClass false to use this.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``dynamic_obstacle`` (bool):  [Read-Write] If set, shape will be exported for navigation as dynamic modifier instead of using regular collision data
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``line_thickness`` (float):  [Read-Write] Used to control the line thickness when rendering
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``shape_color`` (Color):  [Read-Write] Color used to draw the shape.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sphere_radius`` (float):  [Read-Write] The radius of the sphere *
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_system_default_obstacle_area_class`` (bool):  [Read-Write] Uses FNavigationSystem::GetDefaultObstacleArea() by default instead of AreaClassOverride, bDynamicObstacle must be true to use this.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def sphere_radius(self) -> float:
        r"""
        (float):  [Read-Only] The radius of the sphere *
        """
        ...
    def set_sphere_radius(self, sphere_radius: float, update_overlaps: bool = True) -> None:
        r"""
        x.set_sphere_radius(sphere_radius, update_overlaps=True) -> None
        Change the sphere radius. This is the unscaled radius, before component scale is applied.
        
        Args:
            sphere_radius (float): 
            update_overlaps (bool):
        """
        ...
    def get_unscaled_sphere_radius(self) -> float:
        r"""
        x.get_unscaled_sphere_radius() -> float
        
        
        Returns:
            float: the radius of the sphere, ignoring component scale.
        """
        ...
    def get_shape_scale(self) -> float:
        r"""
        x.get_shape_scale() -> float
        Get the scale used by this shape. This is a uniform scale that is the minimum of any non-uniform scaling.
        
        Returns:
            float: the scale used by this shape.
        """
        ...
    def get_scaled_sphere_radius(self) -> float:
        r"""
        x.get_scaled_sphere_radius() -> float
        
        
        Returns:
            float: the radius of the sphere, with component scale applied.
        """
        ...

class DrawSphereComponent(SphereComponent):
    r"""
    A sphere generally used for simple collision. Bounds are rendered as lines in the editor.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DrawSphereComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``area_class_override`` (type(Class)):  [Read-Write] Navigation area type override, null / none = no change to nav mesh.
      bDynamicObstacle must be true and bUseSystemDefaultAreaClass false to use this.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``dynamic_obstacle`` (bool):  [Read-Write] If set, shape will be exported for navigation as dynamic modifier instead of using regular collision data
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``line_thickness`` (float):  [Read-Write] Used to control the line thickness when rendering
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``shape_color`` (Color):  [Read-Write] Color used to draw the shape.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sphere_radius`` (float):  [Read-Write] The radius of the sphere *
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_system_default_obstacle_area_class`` (bool):  [Read-Write] Uses FNavigationSystem::GetDefaultObstacleArea() by default instead of AreaClassOverride, bDynamicObstacle must be true to use this.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class ForceFeedbackComponent(SceneComponent):
    r"""
    ForceFeedbackComponent allows placing a rumble effect in to the world and having it apply to player characters who come near it
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ForceFeedbackComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_overrides`` (ForceFeedbackAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for effects generated by this component
    - ``attenuation_settings`` (ForceFeedbackAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for effects generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``force_feedback_effect`` (ForceFeedbackEffect):  [Read-Write] The feedback effect to be played
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``ignore_time_dilation`` (bool):  [Read-Write] Should the playback of the forcefeedback pattern ignore time dilation and use the app's delta time
    - ``intensity_multiplier`` (float):  [Read-Write] The intensity multiplier to apply to effects generated by this component
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``looping`` (bool):  [Read-Write]
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_force_feedback_finished`` (OnForceFeedbackFinished):  [Read-Write] called when we finish playing audio, either because it played to completion or because a Stop() call turned it off early
    - ``override_attenuation`` (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def force_feedback_effect(self) -> ForceFeedbackEffect:
        r"""
        (ForceFeedbackEffect):  [Read-Only] The feedback effect to be played
        """
        ...
    @property
    def looping(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @looping.setter
    def looping(self, value: bool) -> None:
        ...
    @property
    def ignore_time_dilation(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the playback of the forcefeedback pattern ignore time dilation and use the app's delta time
        """
        ...
    @ignore_time_dilation.setter
    def ignore_time_dilation(self, value: bool) -> None:
        ...
    @property
    def override_attenuation(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
        """
        ...
    @override_attenuation.setter
    def override_attenuation(self, value: bool) -> None:
        ...
    @property
    def intensity_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] The intensity multiplier to apply to effects generated by this component
        """
        ...
    @intensity_multiplier.setter
    def intensity_multiplier(self, value: float) -> None:
        ...
    @property
    def attenuation_settings(self) -> ForceFeedbackAttenuation:
        r"""
        (ForceFeedbackAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for effects generated by this component
        """
        ...
    @attenuation_settings.setter
    def attenuation_settings(self, value: ForceFeedbackAttenuation) -> None:
        ...
    @property
    def attenuation_overrides(self) -> ForceFeedbackAttenuationSettings:
        r"""
        (ForceFeedbackAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for effects generated by this component
        """
        ...
    @attenuation_overrides.setter
    def attenuation_overrides(self, value: ForceFeedbackAttenuationSettings) -> None:
        ...
    @property
    def on_force_feedback_finished(self) -> OnForceFeedbackFinished:
        r"""
        (OnForceFeedbackFinished):  [Read-Write] called when we finish playing audio, either because it played to completion or because a Stop() call turned it off early
        """
        ...
    @on_force_feedback_finished.setter
    def on_force_feedback_finished(self, value: OnForceFeedbackFinished) -> None:
        ...
    def stop(self) -> None:
        r"""
        x.stop() -> None
        Stop playing the feedback effect
        """
        ...
    def set_intensity_multiplier(self, new_intensity_multiplier: float) -> None:
        r"""
        x.set_intensity_multiplier(new_intensity_multiplier) -> None
        Set a new intensity multiplier
        
        Args:
            new_intensity_multiplier (float):
        """
        ...
    def set_force_feedback_effect(self, new_force_feedback_effect: ForceFeedbackEffect) -> None:
        r"""
        x.set_force_feedback_effect(new_force_feedback_effect) -> None
        Set what force feedback effect is played by this component
        
        Args:
            new_force_feedback_effect (ForceFeedbackEffect):
        """
        ...
    def play(self, start_time: float = 0.000000) -> None:
        r"""
        x.play(start_time=0.000000) -> None
        Start a feedback effect playing
        
        Args:
            start_time (float):
        """
        ...
    def get_attenuation_settings_to_apply(self) -> Optional[ForceFeedbackAttenuationSettings]:
        r"""
        x.get_attenuation_settings_to_apply() -> ForceFeedbackAttenuationSettings or None
        BP Get Attenuation Settings to Apply
        
        Returns:
            ForceFeedbackAttenuationSettings or None: 
        
            out_attenuation_settings (ForceFeedbackAttenuationSettings):
        """
        ...
    def adjust_attenuation(self, attenuation_settings: ForceFeedbackAttenuationSettings) -> None:
        r"""
        x.adjust_attenuation(attenuation_settings) -> None
        Modify the attenuation settings of the component
        
        Args:
            attenuation_settings (ForceFeedbackAttenuationSettings):
        """
        ...

class HeterogeneousVolumeComponent(MeshComponent):
    r"""
    A component that represents a heterogeneous volume.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HeterogeneousVolumeComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``end_frame`` (float):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``frame`` (float):  [Read-Write]
    - ``frame_rate`` (float):  [Read-Write]
    - ``frame_transform`` (Transform):  [Read-Only]
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``issue_blocking_requests`` (bool):  [Read-Write]
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lighting_downsample_factor`` (float):  [Read-Write]
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``looping`` (bool):  [Read-Write]
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pivot_at_centroid`` (bool):  [Read-Write]
    - ``playing`` (bool):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_bias_factor`` (float):  [Read-Write]
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``shadow_step_factor`` (float):  [Read-Write]
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``start_frame`` (float):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``step_factor`` (float):  [Read-Write]
    - ``streaming_mip_bias`` (float):  [Read-Write] Bias to apply to the calculated mip level to stream at. This property essentially influences the distance from the
      volume at which certain mip levels are no longer requested. Higher values result in earlier mip level transitions.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``volume_resolution`` (IntVector):  [Read-Write]
    """
    @property
    def volume_resolution(self) -> IntVector:
        r"""
        (IntVector):  [Read-Only]
        """
        ...
    @property
    def frame_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only]
        """
        ...
    @property
    def frame(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @frame.setter
    def frame(self, value: float) -> None:
        ...
    def set_volume_resolution(self, new_value: IntVector) -> None:
        r"""
        x.set_volume_resolution(new_value) -> None
        Set Volume Resolution
        
        Args:
            new_value (IntVector):
        """
        ...
    def set_streaming_mip_bias(self, new_value: int) -> None:
        r"""
        x.set_streaming_mip_bias(new_value) -> None
        Set Streaming Mip Bias
        
        Args:
            new_value (int32):
        """
        ...
    def set_start_frame(self, new_value: float) -> None:
        r"""
        x.set_start_frame(new_value) -> None
        Set Start Frame
        
        Args:
            new_value (float):
        """
        ...
    def set_playing(self, new_value: bool) -> None:
        r"""
        x.set_playing(new_value) -> None
        Set Playing
        
        Args:
            new_value (bool):
        """
        ...
    def set_looping(self, new_value: bool) -> None:
        r"""
        x.set_looping(new_value) -> None
        Set Looping
        
        Args:
            new_value (bool):
        """
        ...
    def set_frame_rate(self, new_value: float) -> None:
        r"""
        x.set_frame_rate(new_value) -> None
        Set Frame Rate
        
        Args:
            new_value (float):
        """
        ...
    def set_frame(self, new_value: float) -> None:
        r"""
        x.set_frame(new_value) -> None
        Set Frame
        
        Args:
            new_value (float):
        """
        ...
    def set_end_frame(self, new_value: float) -> None:
        r"""
        x.set_end_frame(new_value) -> None
        Set End Frame
        
        Args:
            new_value (float):
        """
        ...
    def play(self) -> None:
        r"""
        x.play() -> None
        Play
        """
        ...

class HeterogeneousVolume(Info):
    r"""
    A placeable actor that represents a heterogeneous volume.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HeterogeneousVolumeComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``heterogeneous_volume_component`` (HeterogeneousVolumeComponent):  [Read-Only]
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def heterogeneous_volume_component(self) -> HeterogeneousVolumeComponent:
        r"""
        (HeterogeneousVolumeComponent):  [Read-Only]
        """
        ...

class InputComponent(ActorComponent):
    r"""
    Implement an Actor component for input bindings.
    
    An Input Component is a transient component that enables an Actor to bind various forms of input events to delegate functions.
    Input components are processed from a stack managed by the PlayerController and processed by the PlayerInput.
    Each binding can consume the input event preventing other components on the input stack from processing the input.
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Input/index.html
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    def was_controller_key_just_released(self, key: Key) -> bool:
        r"""
        x.was_controller_key_just_released(key) -> bool
        Returns true if the given key/button was down last frame and up this frame.
        deprecated: Use PlayerController.WasInputKeyJustReleased instead.
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    def was_controller_key_just_pressed(self, key: Key) -> bool:
        r"""
        x.was_controller_key_just_pressed(key) -> bool
        Returns true if the given key/button was up last frame and down this frame.
        deprecated: Use PlayerController.WasInputKeyJustPressed instead.
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    def is_controller_key_down(self, key: Key) -> bool:
        r"""
        x.is_controller_key_down(key) -> bool
        Returns true if the given key/button is pressed on the input of the controller (if present)
        deprecated: Use PlayerController.IsInputKeyDown instead.
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    def get_touch_state(self, finger_index: int) -> Tuple[float, float, bool]:
        r"""
        x.get_touch_state(finger_index) -> (location_x=float, location_y=float, is_currently_pressed=bool)
        Returns the location of a touch, and if it's held down
        deprecated: Use PlayerController.GetInputTouchState instead.
        
        Args:
            finger_index (int32): 
        
        Returns:
            tuple: 
        
            location_x (float): 
        
            location_y (float): 
        
            is_currently_pressed (bool):
        """
        ...
    def get_controller_vector_key_state(self, key: Key) -> Vector:
        r"""
        x.get_controller_vector_key_state(key) -> Vector
        Returns the vector value for the given key/button.
        deprecated: Use PlayerController.GetInputVectorKeyState instead.
        
        Args:
            key (Key): 
        
        Returns:
            Vector:
        """
        ...
    def get_controller_mouse_delta(self) -> Tuple[float, float]:
        r"""
        x.get_controller_mouse_delta() -> (delta_x=float, delta_y=float)
        Retrieves how far the mouse moved this frame.
        deprecated: Use PlayerController.GetInputMouseDelta instead.
        
        Returns:
            tuple: 
        
            delta_x (float): 
        
            delta_y (float):
        """
        ...
    def get_controller_key_time_down(self, key: Key) -> float:
        r"""
        x.get_controller_key_time_down(key) -> float
        Returns how long the given key/button has been down.  Returns 0 if it's up or it just went down this frame.
        deprecated: Use PlayerController.GetInputKeyTimeDown instead.
        
        Args:
            key (Key): 
        
        Returns:
            float:
        """
        ...
    def get_controller_analog_stick_state(self, which_stick: ControllerAnalogStick) -> Tuple[float, float]:
        r"""
        x.get_controller_analog_stick_state(which_stick) -> (stick_x=float, stick_y=float)
        Retrieves the X and Y displacement of the given analog stick.  For WhickStick, 0 = left, 1 = right.
        deprecated: Use PlayerController.GetInputAnalogStickState instead.
        
        Args:
            which_stick (ControllerAnalogStick): 
        
        Returns:
            tuple: 
        
            stick_x (float): 
        
            stick_y (float):
        """
        ...
    def get_controller_analog_key_state(self, key: Key) -> float:
        r"""
        x.get_controller_analog_key_state(key) -> float
        Returns the analog value for the given key/button.  If analog isn't supported, returns 1 for down and 0 for up.
        deprecated: Use PlayerController.GetInputAnalogKeyState instead.
        
        Args:
            key (Key): 
        
        Returns:
            float:
        """
        ...

class InterpToMovementComponent(MovementComponent):
    r"""
    Move the root component between a series of points over a given time *
    see: UMovementComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InterpToMovementComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_register_physics_volume_updates`` (bool):  [Read-Write] If true, then applies the value of bComponentShouldUpdatePhysicsVolume to the UpdatedComponent. If false, will not change bShouldUpdatePhysicsVolume on the UpdatedComponent at all.
      see: bComponentShouldUpdatePhysicsVolume
    - ``auto_register_updated_component`` (bool):  [Read-Write] If true, registers the owner's Root component as the UpdatedComponent if there is not one currently assigned.
    - ``auto_update_tick_registration`` (bool):  [Read-Write] If true, whenever the updated component is changed, this component will enable or disable its tick dependent on whether it has something to update.
      This will NOT enable tick at startup if bAutoActivate is false, because presumably you have a good reason for not wanting it to start ticking initially.
    - ``behaviour_type`` (InterpToBehaviourType):  [Read-Write] Movement behaviour of the component
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``check_if_still_in_world`` (bool):  [Read-Write] Do we want this comp to perform CheckStillInWorld checks?
    - ``component_should_update_physics_volume`` (bool):  [Read-Write] If true, enables bShouldUpdatePhysicsVolume on the UpdatedComponent during initialization from SetUpdatedComponent(), otherwise disables such updates.
      Only enabled if bAutoRegisterPhysicsVolumeUpdates is true.
      WARNING: UpdatePhysicsVolume is potentially expensive if overlap events are also *disabled* because it requires a separate query against all physics volumes in the world.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_to_plane`` (bool):  [Read-Write] If true, movement will be constrained to a plane.
      see: PlaneConstraintNormal, PlaneConstraintOrigin, PlaneConstraintAxisSetting
    - ``control_points`` (Array[InterpControlPoint]):  [Read-Write] List of control points to visit.
    - ``duration`` (float):  [Read-Write] How long to take to move from the first point to the last (or vice versa)
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``force_sub_stepping`` (bool):  [Read-Write] If true, forces sub-stepping to break up movement into discrete smaller steps to improve accuracy of the trajectory.
      Objects that move in a straight line typically do *not* need to set this, as movement always uses continuous collision detection (sweeps) so collision is not missed.
      Sub-stepping is automatically enabled when under the effects of gravity or when homing towards a target.
      see: MaxSimulationTimeStep, MaxSimulationIterations
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``max_simulation_iterations`` (int32):  [Read-Write] Max number of iterations used for each discrete simulation step.
      Increasing this value can address issues with fast-moving objects or complex collision scenarios, at the cost of performance.
      
      WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
      see: MaxSimulationTimeStep, bForceSubStepping
    - ``max_simulation_time_step`` (float):  [Read-Write] Max time delta for each discrete simulation step.
      Lowering this value can address issues with fast-moving objects or complex collision scenarios, at the cost of performance.
      
      WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
      see: MaxSimulationIterations, bForceSubStepping
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_interp_to_reverse`` (OnInterpToReverseDelegate):  [Read-Write] Called when InterpTo impacts something and reverse is enabled.
    - ``on_interp_to_stop`` (OnInterpToStopDelegate):  [Read-Write] Called when InterpTo has come to a stop.
    - ``on_reset_delegate`` (OnInterpToResetDelegate):  [Read-Write] Called when InterpTo reached the end and reset back to start .
    - ``on_wait_begin_delegate`` (OnInterpToWaitBeginDelegate):  [Read-Write] Called when InterpTo has come to a stop but will resume when possible.
    - ``on_wait_end_delegate`` (OnInterpToWaitEndDelegate):  [Read-Write] Called when InterpTo has resumed following a stop.
    - ``pause_on_impact`` (bool):  [Read-Write] If true, will pause movement on impact. If false it will behave as if the end of the movement range was reached based on the BehaviourType.
    - ``plane_constraint_axis_setting`` (PlaneConstraintAxisSetting):  [Read-Write] Setting that controls behavior when movement is restricted to a 2D plane defined by a specific axis/normal,
      so that movement along the locked axis is not be possible.
      see: SetPlaneConstraintAxisSetting
    - ``plane_constraint_normal`` (Vector):  [Read-Write] The normal or axis of the plane that constrains movement, if bConstrainToPlane is enabled.
      If for example you wanted to constrain movement to the X-Z plane (so that Y cannot change), the normal would be set to X=0 Y=1 Z=0.
      This is recalculated whenever PlaneConstraintAxisSetting changes. It is normalized once the component is registered with the game world.
      see: bConstrainToPlane, SetPlaneConstraintNormal(), SetPlaneConstraintFromVectors()
    - ``plane_constraint_origin`` (Vector):  [Read-Write] The origin of the plane that constrains movement, if plane constraint is enabled.
      This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
      see: bConstrainToPlane, SetPlaneConstraintOrigin().
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``snap_to_plane_at_start`` (bool):  [Read-Write] If true and plane constraints are enabled, then the updated component will be snapped to the plane when first attached.
    - ``speed_multiplier`` (float):  [Read-Write] Change the speed of movement.
    - ``sweep`` (bool):  [Read-Write] If true, will sweep for blocking collision during movement. If false, it will simply teleport to the next position and ignore collision.
    - ``teleport_type`` (TeleportType):  [Read-Write] Physics teleport type.
    - ``tick_before_owner`` (bool):  [Read-Write] If true, after registration we will add a tick dependency to tick before our owner (if we can both tick).
      This is important when our tick causes an update in the owner's position, so that when the owner ticks it uses the most recent position without lag.
      Disabling this can improve performance if both objects tick but the order of ticks doesn't matter.
    - ``update_only_if_rendered`` (bool):  [Read-Write] If true, skips TickComponent() if UpdatedComponent was not recently rendered.
    - ``updated_component`` (SceneComponent):  [Read-Write] The component we move and update.
      If this is null at startup and bAutoRegisterUpdatedComponent is true, the owning Actor's root component will automatically be set as our UpdatedComponent at startup.
      see: bAutoRegisterUpdatedComponent, SetUpdatedComponent(), UpdatedPrimitive
    - ``updated_primitive`` (PrimitiveComponent):  [Read-Write] UpdatedComponent, cast as a UPrimitiveComponent. May be invalid if UpdatedComponent was null or not a UPrimitiveComponent.
    - ``velocity`` (Vector):  [Read-Write] Current velocity of updated component.
    """
    @property
    def duration(self) -> float:
        r"""
        (float):  [Read-Write] How long to take to move from the first point to the last (or vice versa)
        """
        ...
    @duration.setter
    def duration(self, value: float) -> None:
        ...
    @property
    def pause_on_impact(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, will pause movement on impact. If false it will behave as if the end of the movement range was reached based on the BehaviourType.
        """
        ...
    @pause_on_impact.setter
    def pause_on_impact(self, value: bool) -> None:
        ...
    @property
    def sweep(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, will sweep for blocking collision during movement. If false, it will simply teleport to the next position and ignore collision.
        """
        ...
    @sweep.setter
    def sweep(self, value: bool) -> None:
        ...
    @property
    def teleport_type(self) -> TeleportType:
        r"""
        (TeleportType):  [Read-Write] Physics teleport type.
        """
        ...
    @teleport_type.setter
    def teleport_type(self, value: TeleportType) -> None:
        ...
    @property
    def behaviour_type(self) -> InterpToBehaviourType:
        r"""
        (InterpToBehaviourType):  [Read-Write] Movement behaviour of the component
        """
        ...
    @behaviour_type.setter
    def behaviour_type(self, value: InterpToBehaviourType) -> None:
        ...
    @property
    def check_if_still_in_world(self) -> bool:
        r"""
        (bool):  [Read-Write] Do we want this comp to perform CheckStillInWorld checks?
        """
        ...
    @check_if_still_in_world.setter
    def check_if_still_in_world(self, value: bool) -> None:
        ...
    @property
    def force_sub_stepping(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, forces sub-stepping to break up movement into discrete smaller steps to improve accuracy of the trajectory.
        Objects that move in a straight line typically do *not* need to set this, as movement always uses continuous collision detection (sweeps) so collision is not missed.
        Sub-stepping is automatically enabled when under the effects of gravity or when homing towards a target.
        see: MaxSimulationTimeStep, MaxSimulationIterations
        """
        ...
    @force_sub_stepping.setter
    def force_sub_stepping(self, value: bool) -> None:
        ...
    @property
    def on_interp_to_reverse(self) -> OnInterpToReverseDelegate:
        r"""
        (OnInterpToReverseDelegate):  [Read-Write] Called when InterpTo impacts something and reverse is enabled.
        """
        ...
    @on_interp_to_reverse.setter
    def on_interp_to_reverse(self, value: OnInterpToReverseDelegate) -> None:
        ...
    @property
    def on_interp_to_stop(self) -> OnInterpToStopDelegate:
        r"""
        (OnInterpToStopDelegate):  [Read-Write] Called when InterpTo has come to a stop.
        """
        ...
    @on_interp_to_stop.setter
    def on_interp_to_stop(self, value: OnInterpToStopDelegate) -> None:
        ...
    @property
    def on_wait_begin_delegate(self) -> OnInterpToWaitBeginDelegate:
        r"""
        (OnInterpToWaitBeginDelegate):  [Read-Write] Called when InterpTo has come to a stop but will resume when possible.
        """
        ...
    @on_wait_begin_delegate.setter
    def on_wait_begin_delegate(self, value: OnInterpToWaitBeginDelegate) -> None:
        ...
    @property
    def on_wait_end_delegate(self) -> OnInterpToWaitEndDelegate:
        r"""
        (OnInterpToWaitEndDelegate):  [Read-Write] Called when InterpTo has resumed following a stop.
        """
        ...
    @on_wait_end_delegate.setter
    def on_wait_end_delegate(self, value: OnInterpToWaitEndDelegate) -> None:
        ...
    @property
    def on_reset_delegate(self) -> OnInterpToResetDelegate:
        r"""
        (OnInterpToResetDelegate):  [Read-Write] Called when InterpTo reached the end and reset back to start .
        """
        ...
    @on_reset_delegate.setter
    def on_reset_delegate(self, value: OnInterpToResetDelegate) -> None:
        ...
    @property
    def max_simulation_time_step(self) -> float:
        r"""
        (float):  [Read-Write] Max time delta for each discrete simulation step.
        Lowering this value can address issues with fast-moving objects or complex collision scenarios, at the cost of performance.
        
        WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
        see: MaxSimulationIterations, bForceSubStepping
        """
        ...
    @max_simulation_time_step.setter
    def max_simulation_time_step(self, value: float) -> None:
        ...
    @property
    def speed_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Change the speed of movement.
        """
        ...
    @speed_multiplier.setter
    def speed_multiplier(self, value: float) -> None:
        ...
    @property
    def max_simulation_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] Max number of iterations used for each discrete simulation step.
        Increasing this value can address issues with fast-moving objects or complex collision scenarios, at the cost of performance.
        
        WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
        see: MaxSimulationTimeStep, bForceSubStepping
        """
        ...
    @max_simulation_iterations.setter
    def max_simulation_iterations(self, value: int) -> None:
        ...
    @property
    def control_points(self) -> Array[InterpControlPoint]:
        r"""
        (Array[InterpControlPoint]):  [Read-Write] List of control points to visit.
        """
        ...
    @control_points.setter
    def control_points(self, value: Array[InterpControlPoint]) -> None:
        ...
    def stop_simulating(self, hit_result: HitResult) -> None:
        r"""
        x.stop_simulating(hit_result) -> None
        Clears the reference to UpdatedComponent, fires stop event, and stops ticking.
        
        Args:
            hit_result (HitResult):
        """
        ...
    def restart_movement(self, initial_direction: float = 1.000000) -> None:
        r"""
        x.restart_movement(initial_direction=1.000000) -> None
        Reset to start. Sets time to zero and direction to 1.
        
        Args:
            initial_direction (float):
        """
        ...
    def reset_control_points(self) -> None:
        r"""
        x.reset_control_points() -> None
        Clear the control points array and set to stopped.
        """
        ...
    def finalise_control_points(self) -> None:
        r"""
        x.finalise_control_points() -> None
        Initialise the control points array. Call after adding control points if they are add after begin play .
        """
        ...
    def add_control_point_position(self, pos: Vector, position_is_relative: bool = True) -> None:
        r"""
        x.add_control_point_position(pos, position_is_relative=True) -> None
        Add a control point that represents a position.
        
        Args:
            pos (Vector): 
            position_is_relative (bool):
        """
        ...

class LineBatchComponent(PrimitiveComponent):
    r"""
    The line batch component buffers and draws lines (and some other line-based shapes) in a scene.
        This can be useful for debug drawing, but is not very performant for runtime use.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LineBatchComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class LocalFogVolumeComponent(SceneComponent):
    r"""
    Local Fog Volume Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LocalFogVolumeComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``fog_albedo`` (LinearColor):  [Read-Write] Controls the albedo of this fog volume.
    - ``fog_emissive`` (LinearColor):  [Read-Write] Controls the emissive color of this fog volume.
    - ``fog_phase_g`` (float):  [Read-Write] Controls the phase `G` parameter, describing the directionality of the scattering within this fog volume.
    - ``fog_sort_priority`` (int32):  [Read-Write] The priority can be used as a way to override the sorting by distance. A lower value means the volume will be considered further away, i.e. it will draw behind the one with a higher priority value.
    - ``height_fog_extinction`` (float):  [Read-Write] The density of the radial fog representing its extinction coefficient at height 0 in the unit sphere. The final look of the volume is determined by combining the "Coverage=1-Transmittance" of both radial and height fog in order to achieve both soft edges and height fog.
    - ``height_fog_falloff`` (float):  [Read-Write] Controls how the density decreases as height increases. Smaller values make the visible transition larger. 1.0 is the lowest value before visual artifact are visible at the horizon.
    - ``height_fog_offset`` (float):  [Read-Write] Height offset, relative to the actor Z position.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``radial_fog_extinction`` (float):  [Read-Write] The density of the radial fog representing its extinction coefficient at the center of the sphere. The final look of the volume is determined by combining the "Coverage=1-Transmittance" of both radial and height fog in order to achieve both soft edges and height fog.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def radial_fog_extinction(self) -> float:
        r"""
        (float):  [Read-Only] The density of the radial fog representing its extinction coefficient at the center of the sphere. The final look of the volume is determined by combining the "Coverage=1-Transmittance" of both radial and height fog in order to achieve both soft edges and height fog.
        """
        ...
    @property
    def height_fog_extinction(self) -> float:
        r"""
        (float):  [Read-Only] The density of the radial fog representing its extinction coefficient at height 0 in the unit sphere. The final look of the volume is determined by combining the "Coverage=1-Transmittance" of both radial and height fog in order to achieve both soft edges and height fog.
        """
        ...
    @property
    def height_fog_falloff(self) -> float:
        r"""
        (float):  [Read-Only] Controls how the density decreases as height increases. Smaller values make the visible transition larger. 1.0 is the lowest value before visual artifact are visible at the horizon.
        """
        ...
    @property
    def height_fog_offset(self) -> float:
        r"""
        (float):  [Read-Only] Height offset, relative to the actor Z position.
        """
        ...
    @property
    def fog_phase_g(self) -> float:
        r"""
        (float):  [Read-Only] Controls the phase `G` parameter, describing the directionality of the scattering within this fog volume.
        """
        ...
    @property
    def fog_albedo(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Controls the albedo of this fog volume.
        """
        ...
    @property
    def fog_emissive(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Controls the emissive color of this fog volume.
        """
        ...
    @property
    def fog_sort_priority(self) -> int:
        r"""
        (int32):  [Read-Only] The priority can be used as a way to override the sorting by distance. A lower value means the volume will be considered further away, i.e. it will draw behind the one with a higher priority value.
        """
        ...
    def set_radial_fog_extinction(self, new_value: float) -> None:
        r"""
        x.set_radial_fog_extinction(new_value) -> None
        Set Radial Fog Extinction
        
        Args:
            new_value (float):
        """
        ...
    def set_height_fog_offset(self, new_value: float) -> None:
        r"""
        x.set_height_fog_offset(new_value) -> None
        Set Height Fog Offset
        
        Args:
            new_value (float):
        """
        ...
    def set_height_fog_falloff(self, new_value: float) -> None:
        r"""
        x.set_height_fog_falloff(new_value) -> None
        Set Height Fog Falloff
        
        Args:
            new_value (float):
        """
        ...
    def set_height_fog_extinction(self, new_value: float) -> None:
        r"""
        x.set_height_fog_extinction(new_value) -> None
        Set Height Fog Extinction
        
        Args:
            new_value (float):
        """
        ...
    def set_fog_phase_g(self, new_value: float) -> None:
        r"""
        x.set_fog_phase_g(new_value) -> None
        Set Fog Phase G
        
        Args:
            new_value (float):
        """
        ...
    def set_fog_emissive(self, new_value: LinearColor) -> None:
        r"""
        x.set_fog_emissive(new_value) -> None
        Set Fog Emissive
        
        Args:
            new_value (LinearColor):
        """
        ...
    def set_fog_albedo(self, new_value: LinearColor) -> None:
        r"""
        x.set_fog_albedo(new_value) -> None
        Set Fog Albedo
        
        Args:
            new_value (LinearColor):
        """
        ...

class LocalLightComponent(LightComponent):
    r"""
    A light component which emits light from a single point equally in all directions.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LocalLightComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_global_illumination`` (bool):  [Read-Write] Whether the light affects global illumination, when ray-traced global illumination is enabled.
    - ``affect_reflection`` (bool):  [Read-Write] Whether the light affects objects in reflections, when ray-traced reflection is enabled.
    - ``affect_translucent_lighting`` (bool):  [Read-Write] Whether the light affects translucency or not.  Disabling this can save GPU time when there are many small lights.
    - ``affects_world`` (bool):  [Read-Write] Whether the light can affect the world, or whether it is disabled.
      A disabled light will not contribute to the scene in any way.  This setting cannot be changed at runtime and unbuilds lighting when changed.
      Setting this to false has the same effect as deleting the light, so it is useful for non-destructive experiments.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_radius`` (float):  [Read-Write] Bounds the light's visible influence.
      This clamping of the light's influence is not physically correct but very important for performance, larger lights cost more.
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bloom_max_brightness`` (float):  [Read-Write] After exposure is applied, scene color brightness larger than BloomMaxBrightness will be rescaled down to BloomMaxBrightness.
    - ``bloom_scale`` (float):  [Read-Write] Scales the additive color.
    - ``bloom_threshold`` (float):  [Read-Write] Scene color must be larger than this to create bloom in the light shafts.
    - ``bloom_tint`` (Color):  [Read-Write] Multiplies against scene color to create the bloom color.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_deep_shadow`` (bool):  [Read-Write] Whether the light should cast high quality hair-strands self-shadowing. When this option is enabled, an extra GPU cost for this light.
    - ``cast_dynamic_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from dynamic objects.  Also requires Cast Shadows to be set to True.
    - ``cast_raytraced_shadow`` (CastRayTracedShadow):  [Read-Write]
    - ``cast_shadows`` (bool):  [Read-Write] Whether the light should cast any shadows.
    - ``cast_shadows_from_cinematic_objects_only`` (bool):  [Read-Write] Whether the light should only cast shadows from components marked as bCastCinematicShadows.
      This is useful for setting up cinematic Movable spotlights aimed at characters and avoiding the shadow depth rendering costs of the background.
      Note: this only works with dynamic shadow maps, not with static shadowing or Ray Traced Distance Field shadows.
    - ``cast_static_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from static objects.  Also requires Cast Shadows to be set to True.
    - ``cast_translucent_shadows`` (bool):  [Read-Write] Whether the light is allowed to cast dynamic shadows from translucency.
    - ``cast_volumetric_shadow`` (bool):  [Read-Write] Whether the light shadows volumetric fog.  Disabling this can save GPU time.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``contact_shadow_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" enabled. 0 = no shadow, 1 (default) = fully shadowed.
    - ``contact_shadow_length`` (float):  [Read-Write] Length of screen space ray trace for sharp contact shadows. Zero is disabled.
    - ``contact_shadow_length_in_ws`` (bool):  [Read-Write] Where Length of screen space ray trace for sharp contact shadows is in world space units or in screen space units.
    - ``contact_shadow_non_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" disabled. 0 (default) = no shadow, 1 = fully shadowed.
    - ``deep_shadow_layer_distribution`` (float):  [Read-Write] Change the deep shadow layers distribution 0:linear distribution (uniform layer distribution), 1:exponential (more details on near small details).
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disabled_brightness`` (float):  [Read-Write] Brightness factor applied to the light when the light function is specified but disabled, for example in scene captures that use SceneCapView_LitNoShadows.
      This should be set to the average brightness of the light function material's emissive input, which should be between 0 and 1.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_light_shaft_bloom`` (bool):  [Read-Write] Whether to render light shaft bloom from this light.
      For directional lights, the color around the light direction will be blurred radially and added back to the scene.
      for point lights, the color on pixels closer than the light's SourceRadius will be blurred radially and added back to the scene.
    - ``force_cached_shadows_for_movable_primitives`` (bool):  [Read-Write] Enables cached shadows for movable primitives for this light even if r.shadow.cachedshadowscastfrommovableprimitives is 0
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``ies_brightness_scale`` (float):  [Read-Write] Global scale for IES brightness contribution. Only available when "Use IES Brightness" is selected, and a valid IES profile texture is set
    - ``ies_texture`` (TextureLightProfile):  [Read-Write] IES texture (light profiles from real world measured data)
    - ``indirect_lighting_intensity`` (float):  [Read-Write] Scales the indirect lighting contribution from this light.
      A value of 0 disables any GI from this light. Default is 1.
    - ``intensity`` (float):  [Read-Write] Total energy that the light emits.
    - ``intensity_units`` (LightUnits):  [Read-Write] Units used for the intensity.
      The peak luminous intensity is measured in candelas,
      while the luminous power is measured in lumens.
    - ``inverse_exposure_blend`` (float):  [Read-Write] Blend Factor used to blend between Intensity and Intensity/Exposure.
      This is useful for gameplay lights that should have constant brighness on screen independent of current exposure.
      This feature can cause issues with exposure particularly when used on the primary light on a scene, as such it's usage should be limited.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``light_color`` (Color):  [Read-Write] Filter color of the light.
      Note that this can change the light's effective intensity.
    - ``light_function_fade_distance`` (float):  [Read-Write] Distance at which the light function should be completely faded to DisabledBrightness.
      This is useful for hiding aliasing from light functions applied in the distance.
    - ``light_function_material`` (MaterialInterface):  [Read-Write] The light function material to be applied to this light.
      Note that only non-lightmapped lights (UseDirectLightMap=False) can have a light function.
      Light functions are supported within VolumetricFog, but only for Directional, Point and Spot lights. Rect lights are not supported.
    - ``light_function_scale`` (Vector):  [Read-Write] Scales the light function projection.  X and Y scale in the directions perpendicular to the light's direction, Z scales along the light direction.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this light should affect.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmass_settings`` (LightmassPointLightSettings):  [Read-Write] The Lightmass settings for this object.
    - ``max_distance_fade_range`` (float):  [Read-Write]
    - ``max_draw_distance`` (float):  [Read-Write]
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_start_offset_depth_scale`` (float):  [Read-Write] Controls how large of an offset ray traced shadows have from the receiving surface as the camera gets further away.
      This can be useful to hide self-shadowing artifacts from low resolution distance fields on huge static meshes.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``samples_per_pixel`` (int32):  [Read-Write] Samples per pixel for ray tracing
    - ``shadow_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``shadow_resolution_scale`` (float):  [Read-Write] Scales the resolution of shadowmaps used to shadow this light.  By default shadowmap resolution is chosen based on screen size of the caster.
      Setting the scale to zero disables shadow maps, but does not disable, e.g., contact shadows.
      Note: shadowmap resolution is still clamped by 'r.Shadow.MaxResolution'
    - ``shadow_sharpen`` (float):  [Read-Write] Amount to sharpen shadow filtering
    - ``shadow_slope_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are. This works in addition to shadow bias, by increasing the
      amount of bias depending on the slope of a surface.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``specular_scale`` (float):  [Read-Write] Multiplier on specular highlights. Use only with great care! Any value besides 1 is not physical!
      Can be used to artistically remove highlights mimicking polarizing filters or photo touch up.
    - ``temperature`` (float):  [Read-Write] Color temperature in Kelvin of the blackbody illuminant.
      White (D65) is 6500K.
    - ``transmission`` (bool):  [Read-Write] Whether light from this light transmits through surfaces with subsurface scattering profiles. Requires light to be movable.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_ies_brightness`` (bool):  [Read-Write] true: take light brightness from IES profile, false: use the light brightness - the maximum light in one direction is used to define no masking. Use with InverseSquareFalloff. Will be disabled if a valid IES profile texture is not supplied.
    - ``use_ray_traced_distance_field_shadows`` (bool):  [Read-Write] Whether to use ray traced distance field area shadows.  The project setting bGenerateMeshDistanceFields must be enabled for this to have effect.
      Distance field shadows support area lights so they create soft shadows with sharp contacts.
      They have less aliasing artifacts than standard shadowmaps, but inherit all the limitations of distance field representations (only uniform scale, no deformation).
      These shadows have a low per-object cost (and don't depend on triangle count) so they are effective for distant shadows from a dynamic sun.
    - ``use_temperature`` (bool):  [Read-Write] false: use white (D65) as illuminant.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volumetric_scattering_intensity`` (float):  [Read-Write] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
    """
    @property
    def intensity_units(self) -> LightUnits:
        r"""
        (LightUnits):  [Read-Only] Units used for the intensity.
        The peak luminous intensity is measured in candelas,
        while the luminous power is measured in lumens.
        """
        ...
    @property
    def inverse_exposure_blend(self) -> float:
        r"""
        (float):  [Read-Only] Blend Factor used to blend between Intensity and Intensity/Exposure.
        This is useful for gameplay lights that should have constant brighness on screen independent of current exposure.
        This feature can cause issues with exposure particularly when used on the primary light on a scene, as such it's usage should be limited.
        """
        ...
    @property
    def attenuation_radius(self) -> float:
        r"""
        (float):  [Read-Only] Bounds the light's visible influence.
        This clamping of the light's influence is not physically correct but very important for performance, larger lights cost more.
        """
        ...
    def set_intensity_units(self, new_intensity_units: LightUnits) -> None:
        r"""
        x.set_intensity_units(new_intensity_units) -> None
        Set the units used for the intensity of the light
        
        Args:
            new_intensity_units (LightUnits):
        """
        ...
    def set_attenuation_radius(self, new_radius: float) -> None:
        r"""
        x.set_attenuation_radius(new_radius) -> None
        Set Attenuation Radius
        
        Args:
            new_radius (float):
        """
        ...
    @classmethod
    def get_units_conversion_factor(cls, src_units: LightUnits, target_units: LightUnits, cos_half_cone_angle: float = -1.000000) -> float:
        r"""
        X.get_units_conversion_factor(src_units, target_units, cos_half_cone_angle=-1.000000) -> float
        Get Units Conversion Factor
        
        Args:
            src_units (LightUnits): 
            target_units (LightUnits): 
            cos_half_cone_angle (float): 
        
        Returns:
            float:
        """
        ...

class LODSyncComponent(ActorComponent):
    r"""
    Implement an Actor component for LOD Sync of different components
    
    This is a component that allows multiple different components to sync together of their LOD
    
    This allows to find the highest LOD of all the parts, and sync to that LOD
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LODSyncComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``components_to_sync`` (Array[ComponentSync]):  [Read-Write] Array of components whose LOD may drive or be driven by this component.
      Components that are flagged as 'Drive' are treated as being in priority order, with the last component having highest priority. The highest priority
      visible component will set the LOD for all other components. If no components are visible, then the highest priority non-visible component will set LOD.
    - ``custom_lod_mapping`` (Map[Name, LODMappingData]):  [Read-Write] by default, the mapping will be one to one
      but if you want custom, add here.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``forced_lod`` (int32):  [Read-Write] if -1, it's automatically switching
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``min_lod`` (int32):  [Read-Write] Minimum LOD to use when syncing components
    - ``num_lo_ds`` (int32):  [Read-Write] if -1, it's default and it will calculate the max number of LODs from all sub components
      if not, it is a number of LODs (not the max index of LODs)
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def num_lo_ds(self) -> int:
        r"""
        (int32):  [Read-Write] if -1, it's default and it will calculate the max number of LODs from all sub components
        if not, it is a number of LODs (not the max index of LODs)
        """
        ...
    @num_lo_ds.setter
    def num_lo_ds(self, value: int) -> None:
        ...
    @property
    def forced_lod(self) -> int:
        r"""
        (int32):  [Read-Write] if -1, it's automatically switching
        """
        ...
    @forced_lod.setter
    def forced_lod(self, value: int) -> None:
        ...
    @property
    def min_lod(self) -> int:
        r"""
        (int32):  [Read-Write] Minimum LOD to use when syncing components
        """
        ...
    @min_lod.setter
    def min_lod(self, value: int) -> None:
        ...
    @property
    def components_to_sync(self) -> Array[ComponentSync]:
        r"""
        (Array[ComponentSync]):  [Read-Write] Array of components whose LOD may drive or be driven by this component.
        Components that are flagged as 'Drive' are treated as being in priority order, with the last component having highest priority. The highest priority
        visible component will set the LOD for all other components. If no components are visible, then the highest priority non-visible component will set LOD.
        """
        ...
    @components_to_sync.setter
    def components_to_sync(self, value: Array[ComponentSync]) -> None:
        ...
    @property
    def custom_lod_mapping(self) -> Map[Name, LODMappingData]:
        r"""
        (Map[Name, LODMappingData]):  [Read-Write] by default, the mapping will be one to one
        but if you want custom, add here.
        """
        ...
    @custom_lod_mapping.setter
    def custom_lod_mapping(self, value: Map[Name, LODMappingData]) -> None:
        ...
    def get_lod_sync_debug_text(self) -> str:
        r"""
        x.get_lod_sync_debug_text() -> str
        Returns a string detailing
        
        Returns:
            str:
        """
        ...

class MaterialBillboardComponent(PrimitiveComponent):
    r"""
    A 2d material that will be rendered always facing the camera.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialBillboardComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``elements`` (Array[MaterialSpriteElement]):  [Read-Write] Current array of material billboard elements
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def elements(self) -> Array[MaterialSpriteElement]:
        r"""
        (Array[MaterialSpriteElement]):  [Read-Only] Current array of material billboard elements
        """
        ...
    def set_elements(self, new_elements: Array[MaterialSpriteElement]) -> None:
        r"""
        x.set_elements(new_elements) -> None
        Set all elements of this material billboard component
        
        Args:
            new_elements (Array[MaterialSpriteElement]):
        """
        ...
    def add_element(self, material: MaterialInterface, distance_to_opacity_curve: CurveFloat, size_is_in_screen_space: bool, base_size_x: float, base_size_y: float, distance_to_size_curve: CurveFloat) -> None:
        r"""
        x.add_element(material, distance_to_opacity_curve, size_is_in_screen_space, base_size_x, base_size_y, distance_to_size_curve) -> None
        Adds an element to the sprite.
        
        Args:
            material (MaterialInterface): 
            distance_to_opacity_curve (CurveFloat): 
            size_is_in_screen_space (bool): 
            base_size_x (float): 
            base_size_y (float): 
            distance_to_size_curve (CurveFloat):
        """
        ...

class MaterialSpriteComponent(MaterialBillboardComponent):
    r"""
    deprecated: 'MaterialSpriteComponent' was renamed to 'MaterialBillboardComponent'.
    """
    ...

class ModelComponent(PrimitiveComponent):
    r"""
    ModelComponents are PrimitiveComponents that represent elements of BSP geometry in a ULevel object.
    They are used exclusively by ULevel and are not intended as general-purpose components.
    see: ULevel
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ModelComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class PawnNoiseEmitterComponent(ActorComponent):
    r"""
    PawnNoiseEmitterComponent tracks noise event data used by SensingComponents to hear a Pawn.
    This component is intended to exist on either a Pawn or its Controller. It does nothing on network clients.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PawnNoiseEmitterComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ai_perception_system_compatibility_mode`` (bool):  [Read-Write] If set to true (default value) will notify AIPerceptionSystem about noise events
      otherwise only PawnSensingComponents will be able to pick up noises generated by this component
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``noise_lifetime`` (float):  [Read-Write] After this amount of time, new sound events will overwrite previous sounds even if they are not louder (allows old sounds to decay)
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def noise_lifetime(self) -> float:
        r"""
        (float):  [Read-Write] After this amount of time, new sound events will overwrite previous sounds even if they are not louder (allows old sounds to decay)
        """
        ...
    @noise_lifetime.setter
    def noise_lifetime(self, value: float) -> None:
        ...
    def make_noise(self, noise_maker: Actor, loudness: float, noise_location: Vector) -> None:
        r"""
        x.make_noise(noise_maker, loudness, noise_location) -> None
        Cache noises instigated by the owning pawn for AI sensing
        
        Args:
            noise_maker (Actor): is the actual actor which made the noise
            loudness (float): is the relative loudness of the noise (0.0 to 1.0)
            noise_location (Vector): is the position of the noise
        """
        ...

class PlatformEventsComponent(ActorComponent):
    r"""
    Component to handle receiving notifications from the OS about platform events.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlatformEventsComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``platform_changed_to_laptop_mode_delegate`` (PlatformEventDelegate):  [Read-Write] This is called when a convertible laptop changed into laptop mode.
    - ``platform_changed_to_tablet_mode_delegate`` (PlatformEventDelegate):  [Read-Write] This is called when a convertible laptop changed into tablet mode.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def platform_changed_to_laptop_mode_delegate(self) -> PlatformEventDelegate:
        r"""
        (PlatformEventDelegate):  [Read-Write] This is called when a convertible laptop changed into laptop mode.
        """
        ...
    @platform_changed_to_laptop_mode_delegate.setter
    def platform_changed_to_laptop_mode_delegate(self, value: PlatformEventDelegate) -> None:
        ...
    @property
    def platform_changed_to_tablet_mode_delegate(self) -> PlatformEventDelegate:
        r"""
        (PlatformEventDelegate):  [Read-Write] This is called when a convertible laptop changed into tablet mode.
        """
        ...
    @platform_changed_to_tablet_mode_delegate.setter
    def platform_changed_to_tablet_mode_delegate(self, value: PlatformEventDelegate) -> None:
        ...
    def supports_convertible_laptops(self) -> bool:
        r"""
        x.supports_convertible_laptops() -> bool
        Check whether the platform supports convertible laptops.
        
        Note: This does not necessarily mean that the platform is a convertible laptop.
        For example, convertible laptops running Windows 7 or older will return false,
        and regular laptops running Windows 8 or newer will return true.
        see: IsInLaptopMode, IsInTabletMode
        
        Returns:
            bool: true for convertible laptop platforms, false otherwise.
        """
        ...
    def is_in_tablet_mode(self) -> bool:
        r"""
        x.is_in_tablet_mode() -> bool
        Check whether a convertible laptop is laptop mode.
        see: IsInLaptopMode, SupportsConvertibleLaptops
        
        Returns:
            bool: true if in tablet mode, false otherwise or if not a convertible laptop.
        """
        ...
    def is_in_laptop_mode(self) -> bool:
        r"""
        x.is_in_laptop_mode() -> bool
        Check whether a convertible laptop is laptop mode.
        see: IsInTabletMode, SupportsConvertibleLaptops
        
        Returns:
            bool: true if in laptop mode, false otherwise or if not a convertible laptop.
        """
        ...

class PointLightComponent(LocalLightComponent):
    r"""
    A light component which emits light from a single point equally in all directions.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PointLightComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_global_illumination`` (bool):  [Read-Write] Whether the light affects global illumination, when ray-traced global illumination is enabled.
    - ``affect_reflection`` (bool):  [Read-Write] Whether the light affects objects in reflections, when ray-traced reflection is enabled.
    - ``affect_translucent_lighting`` (bool):  [Read-Write] Whether the light affects translucency or not.  Disabling this can save GPU time when there are many small lights.
    - ``affects_world`` (bool):  [Read-Write] Whether the light can affect the world, or whether it is disabled.
      A disabled light will not contribute to the scene in any way.  This setting cannot be changed at runtime and unbuilds lighting when changed.
      Setting this to false has the same effect as deleting the light, so it is useful for non-destructive experiments.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_radius`` (float):  [Read-Write] Bounds the light's visible influence.
      This clamping of the light's influence is not physically correct but very important for performance, larger lights cost more.
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bloom_max_brightness`` (float):  [Read-Write] After exposure is applied, scene color brightness larger than BloomMaxBrightness will be rescaled down to BloomMaxBrightness.
    - ``bloom_scale`` (float):  [Read-Write] Scales the additive color.
    - ``bloom_threshold`` (float):  [Read-Write] Scene color must be larger than this to create bloom in the light shafts.
    - ``bloom_tint`` (Color):  [Read-Write] Multiplies against scene color to create the bloom color.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_deep_shadow`` (bool):  [Read-Write] Whether the light should cast high quality hair-strands self-shadowing. When this option is enabled, an extra GPU cost for this light.
    - ``cast_dynamic_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from dynamic objects.  Also requires Cast Shadows to be set to True.
    - ``cast_raytraced_shadow`` (CastRayTracedShadow):  [Read-Write]
    - ``cast_shadows`` (bool):  [Read-Write] Whether the light should cast any shadows.
    - ``cast_shadows_from_cinematic_objects_only`` (bool):  [Read-Write] Whether the light should only cast shadows from components marked as bCastCinematicShadows.
      This is useful for setting up cinematic Movable spotlights aimed at characters and avoiding the shadow depth rendering costs of the background.
      Note: this only works with dynamic shadow maps, not with static shadowing or Ray Traced Distance Field shadows.
    - ``cast_static_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from static objects.  Also requires Cast Shadows to be set to True.
    - ``cast_translucent_shadows`` (bool):  [Read-Write] Whether the light is allowed to cast dynamic shadows from translucency.
    - ``cast_volumetric_shadow`` (bool):  [Read-Write] Whether the light shadows volumetric fog.  Disabling this can save GPU time.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``contact_shadow_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" enabled. 0 = no shadow, 1 (default) = fully shadowed.
    - ``contact_shadow_length`` (float):  [Read-Write] Length of screen space ray trace for sharp contact shadows. Zero is disabled.
    - ``contact_shadow_length_in_ws`` (bool):  [Read-Write] Where Length of screen space ray trace for sharp contact shadows is in world space units or in screen space units.
    - ``contact_shadow_non_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" disabled. 0 (default) = no shadow, 1 = fully shadowed.
    - ``deep_shadow_layer_distribution`` (float):  [Read-Write] Change the deep shadow layers distribution 0:linear distribution (uniform layer distribution), 1:exponential (more details on near small details).
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disabled_brightness`` (float):  [Read-Write] Brightness factor applied to the light when the light function is specified but disabled, for example in scene captures that use SceneCapView_LitNoShadows.
      This should be set to the average brightness of the light function material's emissive input, which should be between 0 and 1.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_light_shaft_bloom`` (bool):  [Read-Write] Whether to render light shaft bloom from this light.
      For directional lights, the color around the light direction will be blurred radially and added back to the scene.
      for point lights, the color on pixels closer than the light's SourceRadius will be blurred radially and added back to the scene.
    - ``force_cached_shadows_for_movable_primitives`` (bool):  [Read-Write] Enables cached shadows for movable primitives for this light even if r.shadow.cachedshadowscastfrommovableprimitives is 0
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``ies_brightness_scale`` (float):  [Read-Write] Global scale for IES brightness contribution. Only available when "Use IES Brightness" is selected, and a valid IES profile texture is set
    - ``ies_texture`` (TextureLightProfile):  [Read-Write] IES texture (light profiles from real world measured data)
    - ``indirect_lighting_intensity`` (float):  [Read-Write] Scales the indirect lighting contribution from this light.
      A value of 0 disables any GI from this light. Default is 1.
    - ``intensity`` (float):  [Read-Write] Total energy that the light emits.
    - ``intensity_units`` (LightUnits):  [Read-Write] Units used for the intensity.
      The peak luminous intensity is measured in candelas,
      while the luminous power is measured in lumens.
    - ``inverse_exposure_blend`` (float):  [Read-Write] Blend Factor used to blend between Intensity and Intensity/Exposure.
      This is useful for gameplay lights that should have constant brighness on screen independent of current exposure.
      This feature can cause issues with exposure particularly when used on the primary light on a scene, as such it's usage should be limited.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``light_color`` (Color):  [Read-Write] Filter color of the light.
      Note that this can change the light's effective intensity.
    - ``light_falloff_exponent`` (float):  [Read-Write] Controls the radial falloff of the light when UseInverseSquaredFalloff is disabled.
      2 is almost linear and very unrealistic and around 8 it looks reasonable.
      With large exponents, the light has contribution to only a small area of its influence radius but still costs the same as low exponents.
    - ``light_function_fade_distance`` (float):  [Read-Write] Distance at which the light function should be completely faded to DisabledBrightness.
      This is useful for hiding aliasing from light functions applied in the distance.
    - ``light_function_material`` (MaterialInterface):  [Read-Write] The light function material to be applied to this light.
      Note that only non-lightmapped lights (UseDirectLightMap=False) can have a light function.
      Light functions are supported within VolumetricFog, but only for Directional, Point and Spot lights. Rect lights are not supported.
    - ``light_function_scale`` (Vector):  [Read-Write] Scales the light function projection.  X and Y scale in the directions perpendicular to the light's direction, Z scales along the light direction.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this light should affect.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmass_settings`` (LightmassPointLightSettings):  [Read-Write] The Lightmass settings for this object.
    - ``max_distance_fade_range`` (float):  [Read-Write]
    - ``max_draw_distance`` (float):  [Read-Write]
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_start_offset_depth_scale`` (float):  [Read-Write] Controls how large of an offset ray traced shadows have from the receiving surface as the camera gets further away.
      This can be useful to hide self-shadowing artifacts from low resolution distance fields on huge static meshes.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``samples_per_pixel`` (int32):  [Read-Write] Samples per pixel for ray tracing
    - ``shadow_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``shadow_resolution_scale`` (float):  [Read-Write] Scales the resolution of shadowmaps used to shadow this light.  By default shadowmap resolution is chosen based on screen size of the caster.
      Setting the scale to zero disables shadow maps, but does not disable, e.g., contact shadows.
      Note: shadowmap resolution is still clamped by 'r.Shadow.MaxResolution'
    - ``shadow_sharpen`` (float):  [Read-Write] Amount to sharpen shadow filtering
    - ``shadow_slope_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are. This works in addition to shadow bias, by increasing the
      amount of bias depending on the slope of a surface.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``soft_source_radius`` (float):  [Read-Write] Soft radius of light source shape.
      Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
    - ``source_length`` (float):  [Read-Write] Length of light source shape.
      Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
    - ``source_radius`` (float):  [Read-Write] Radius of light source shape.
      Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
    - ``specular_scale`` (float):  [Read-Write] Multiplier on specular highlights. Use only with great care! Any value besides 1 is not physical!
      Can be used to artistically remove highlights mimicking polarizing filters or photo touch up.
    - ``temperature`` (float):  [Read-Write] Color temperature in Kelvin of the blackbody illuminant.
      White (D65) is 6500K.
    - ``transmission`` (bool):  [Read-Write] Whether light from this light transmits through surfaces with subsurface scattering profiles. Requires light to be movable.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_ies_brightness`` (bool):  [Read-Write] true: take light brightness from IES profile, false: use the light brightness - the maximum light in one direction is used to define no masking. Use with InverseSquareFalloff. Will be disabled if a valid IES profile texture is not supplied.
    - ``use_inverse_squared_falloff`` (bool):  [Read-Write] Whether to use physically based inverse squared distance falloff, where AttenuationRadius is only clamping the light's contribution.
      Disabling inverse squared falloff can be useful when placing fill lights (don't want a super bright spot near the light).
      When enabled, the light's Intensity is in units of lumens, where 1700 lumens is a 100W lightbulb.
      When disabled, the light's Intensity is a brightness scale.
    - ``use_ray_traced_distance_field_shadows`` (bool):  [Read-Write] Whether to use ray traced distance field area shadows.  The project setting bGenerateMeshDistanceFields must be enabled for this to have effect.
      Distance field shadows support area lights so they create soft shadows with sharp contacts.
      They have less aliasing artifacts than standard shadowmaps, but inherit all the limitations of distance field representations (only uniform scale, no deformation).
      These shadows have a low per-object cost (and don't depend on triangle count) so they are effective for distant shadows from a dynamic sun.
    - ``use_temperature`` (bool):  [Read-Write] false: use white (D65) as illuminant.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volumetric_scattering_intensity`` (float):  [Read-Write] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
    """
    @property
    def use_inverse_squared_falloff(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to use physically based inverse squared distance falloff, where AttenuationRadius is only clamping the light's contribution.
        Disabling inverse squared falloff can be useful when placing fill lights (don't want a super bright spot near the light).
        When enabled, the light's Intensity is in units of lumens, where 1700 lumens is a 100W lightbulb.
        When disabled, the light's Intensity is a brightness scale.
        """
        ...
    @property
    def light_falloff_exponent(self) -> float:
        r"""
        (float):  [Read-Only] Controls the radial falloff of the light when UseInverseSquaredFalloff is disabled.
        2 is almost linear and very unrealistic and around 8 it looks reasonable.
        With large exponents, the light has contribution to only a small area of its influence radius but still costs the same as low exponents.
        """
        ...
    @property
    def source_radius(self) -> float:
        r"""
        (float):  [Read-Only] Radius of light source shape.
        Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
        """
        ...
    @property
    def soft_source_radius(self) -> float:
        r"""
        (float):  [Read-Only] Soft radius of light source shape.
        Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
        """
        ...
    @property
    def source_length(self) -> float:
        r"""
        (float):  [Read-Only] Length of light source shape.
        Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
        """
        ...
    def set_use_inverse_squared_falloff(self, new_value: bool) -> None:
        r"""
        x.set_use_inverse_squared_falloff(new_value) -> None
        Set Use Inverse Squared Falloff
        
        Args:
            new_value (bool):
        """
        ...
    def set_source_radius(self, new_value: float) -> None:
        r"""
        x.set_source_radius(new_value) -> None
        Set Source Radius
        
        Args:
            new_value (float):
        """
        ...
    def set_source_length(self, new_value: float) -> None:
        r"""
        x.set_source_length(new_value) -> None
        Set Source Length
        
        Args:
            new_value (float):
        """
        ...
    def set_soft_source_radius(self, new_value: float) -> None:
        r"""
        x.set_soft_source_radius(new_value) -> None
        Set Soft Source Radius
        
        Args:
            new_value (float):
        """
        ...
    def set_light_falloff_exponent(self, new_light_falloff_exponent: float) -> None:
        r"""
        x.set_light_falloff_exponent(new_light_falloff_exponent) -> None
        Set Light Falloff Exponent
        
        Args:
            new_light_falloff_exponent (float):
        """
        ...
    def set_inverse_exposure_blend(self, new_inverse_exposure_blend: float) -> None:
        r"""
        x.set_inverse_exposure_blend(new_inverse_exposure_blend) -> None
        Set Inverse Exposure Blend
        
        Args:
            new_inverse_exposure_blend (float):
        """
        ...

class PoseableMeshComponent(SkinnedMeshComponent):
    r"""
    UPoseableMeshComponent that allows bone transforms to be driven by blueprint.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PoseableMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capsule_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the capsule indirect shadow can be.
    - ``cast_capsule_direct_shadow`` (bool):  [Read-Write] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for direct shadowing from lights.
      This type of shadowing is approximate but handles extremely wide area shadowing well.  The softness of the shadow depends on the light's LightSourceAngle / SourceRadius.
      This flag will force bCastInsetShadow to be enabled.
    - ``cast_capsule_indirect_shadow`` (bool):  [Read-Write] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for shadowing indirect lighting (from lightmaps or skylight).
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``component_use_fixed_skel_bounds`` (bool):  [Read-Write] When true, skip using the physics asset etc. and always use the fixed bounds defined in the SkeletalMesh.
    - ``consider_all_bodies_for_bounds`` (bool):  [Read-Write] If true, when updating bounds from a PhysicsAsset, consider _all_ BodySetups, not just those flagged with bConsiderForBounds.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disable_morph_target`` (bool):  [Read-Write] Disable Morphtarget for this component.
    - ``display_debug_update_rate_optimizations`` (bool):  [Read-Write] Enable on screen debugging of update rate optimization.
      Red = Skipping 0 frames, Green = skipping 1 frame, Blue = skipping 2 frames, black = skipping more than 2 frames.
      todo:: turn this into a console command.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``enable_update_rate_optimizations`` (bool):  [Read-Write] if TRUE, Owner will determine how often animation will be updated and evaluated. See AnimUpdateRateTick()
      This allows to skip frames for performance. (For example based on visibility and size on screen).
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``forced_lod_model`` (int32):  [Read-Write]
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_leader_pose_component_lod`` (bool):  [Read-Write] Flag that when set will ensure UpdateLODStatus will not take the LeaderPoseComponent's current LOD in consideration when determining the correct LOD level (this requires LeaderPoseComponent's LOD to always be >= determined LOD otherwise bone transforms could be missing
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``leader_pose_component`` (SkinnedMeshComponent):  [Read-Write] If set, this SkeletalMeshComponent will not use its SpaceBase for bone transform, but will
      use the component space transforms from the LeaderPoseComponent. This is used when constructing a character using multiple skeletal meshes sharing the same
      skeleton within the same Actor.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``mesh_deformer`` (MeshDeformer):  [Read-Write] The mesh deformer to use. If no mesh deformer is set from here or the SkeletalMesh, then we fall back to the fixed function deformation.
    - ``mesh_deformer_instance`` (MeshDeformerInstance):  [Read-Write]
      deprecated: Use the GetMeshDeformerInstance function instead
    - ``mesh_deformer_instance_settings`` (MeshDeformerInstanceSettings):  [Read-Only] Object containing instance settings for the bound MeshDeformer.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod_model`` (int32):  [Read-Write] This is the min LOD that this component will use.  (e.g. if set to 2 then only 2+ LOD Models will be used.) This is useful to set on
      meshes which are known to be a certain distance away and still want to have better LODs when zoomed in on them.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether we should use the min lod specified in MinLodModel for this component instead of the min lod in the mesh
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``per_bone_motion_blur`` (bool):  [Read-Write] If true, use per-bone motion blur on this skeletal mesh (requires additional rendering, can be disabled to save performance).
    - ``physics_asset_override`` (PhysicsAsset):  [Read-Write] PhysicsAsset is set in SkeletalMesh by default, but you can override with this value
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``render_static`` (bool):  [Read-Write] If true, render as static in reference pose.
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``set_mesh_deformer`` (bool):  [Read-Write] If true, MeshDeformer will be used. If false, use the default mesh deformer on the SkeletalMesh.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``skeletal_mesh`` (SkeletalMesh):  [Read-Write]
      deprecated: Use USkeletalMeshComponent::GetSkeletalMeshAsset() or GetSkinnedAsset() instead.
    - ``skin_cache_usage`` (Array[SkinCacheUsage]):  [Read-Write] How this Component's LOD uses the skin cache feature. Auto will defer to the asset's (SkeletalMesh) option. If Ray Tracing is enabled, will imply Enabled
    - ``skinned_asset`` (SkinnedAsset):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired streaming distance of streaming textures that uses UV 0.
      1.0 is the default, whereas a higher value makes the textures stream in sooner from far away.
      A lower value (0.0-1.0) makes the textures stream in later (you have to be closer).
      Value can be < 0 (from legcay content, or code changes)
    - ``sync_attach_parent_lod`` (bool):  [Read-Write] If true, this component uses its parents LOD when attached if available
      ForcedLOD can override this change. By default, it will use parent LOD.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_bounds_from_leader_pose_component`` (bool):  [Read-Write] When true, we will just using the bounds from our LeaderPoseComponent.  This is useful for when we have a Mesh Parented
      to the main SkelMesh (e.g. outline mesh or a full body overdraw effect that is toggled) that is always going to be the same
      bounds as parent.  We want to do no calculations in that case.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visibility_based_anim_tick_option`` (VisibilityBasedAnimTickOption):  [Read-Write] * This is tick animation frequency option based on this component rendered or not or using montage
      *  You can change this default value in the INI file
      * Mostly related with performance
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    def set_bone_transform_by_name(self, bone_name: Name, transform: Transform, bone_space: BoneSpaces) -> None:
        r"""
        x.set_bone_transform_by_name(bone_name, transform, bone_space) -> None
        Set Bone Transform by Name
        
        Args:
            bone_name (Name): 
            transform (Transform): 
            bone_space (BoneSpaces):
        """
        ...
    def set_bone_scale_by_name(self, bone_name: Name, scale3d: Vector, bone_space: BoneSpaces) -> None:
        r"""
        x.set_bone_scale_by_name(bone_name, scale3d, bone_space) -> None
        Set Bone Scale by Name
        
        Args:
            bone_name (Name): 
            scale3d (Vector): 
            bone_space (BoneSpaces):
        """
        ...
    def set_bone_rotation_by_name(self, bone_name: Name, rotation: Rotator, bone_space: BoneSpaces) -> None:
        r"""
        x.set_bone_rotation_by_name(bone_name, rotation, bone_space) -> None
        Set Bone Rotation by Name
        
        Args:
            bone_name (Name): 
            rotation (Rotator): 
            bone_space (BoneSpaces):
        """
        ...
    def set_bone_location_by_name(self, bone_name: Name, location: Vector, bone_space: BoneSpaces) -> None:
        r"""
        x.set_bone_location_by_name(bone_name, location, bone_space) -> None
        Set Bone Location by Name
        
        Args:
            bone_name (Name): 
            location (Vector): 
            bone_space (BoneSpaces):
        """
        ...
    def reset_bone_transform_by_name(self, bone_name: Name) -> None:
        r"""
        x.reset_bone_transform_by_name(bone_name) -> None
        Reset Bone Transform by Name
        
        Args:
            bone_name (Name):
        """
        ...
    def get_bone_transform_by_name(self, bone_name: Name, bone_space: BoneSpaces) -> Transform:
        r"""
        x.get_bone_transform_by_name(bone_name, bone_space) -> Transform
        Get Bone Transform by Name
        
        Args:
            bone_name (Name): 
            bone_space (BoneSpaces): 
        
        Returns:
            Transform:
        """
        ...
    def get_bone_scale_by_name(self, bone_name: Name, bone_space: BoneSpaces) -> Vector:
        r"""
        x.get_bone_scale_by_name(bone_name, bone_space) -> Vector
        Get Bone Scale by Name
        
        Args:
            bone_name (Name): 
            bone_space (BoneSpaces): 
        
        Returns:
            Vector:
        """
        ...
    def get_bone_rotation_by_name(self, bone_name: Name, bone_space: BoneSpaces) -> Rotator:
        r"""
        x.get_bone_rotation_by_name(bone_name, bone_space) -> Rotator
        Get Bone Rotation by Name
        
        Args:
            bone_name (Name): 
            bone_space (BoneSpaces): 
        
        Returns:
            Rotator:
        """
        ...
    def get_bone_location_by_name(self, bone_name: Name, bone_space: BoneSpaces) -> Vector:
        r"""
        x.get_bone_location_by_name(bone_name, bone_space) -> Vector
        Get Bone Location by Name
        
        Args:
            bone_name (Name): 
            bone_space (BoneSpaces): 
        
        Returns:
            Vector:
        """
        ...
    def copy_pose_from_skeletal_component(self, component_to_copy: SkeletalMeshComponent) -> None:
        r"""
        x.copy_pose_from_skeletal_component(component_to_copy) -> None
        Copy Pose from Skeletal Component
        
        Args:
            component_to_copy (SkeletalMeshComponent):
        """
        ...

class PostProcessComponent(SceneComponent):
    r"""
    PostProcessComponent. Enables Post process controls for blueprints.
       Will use a parent UShapeComponent to provide volume data if available.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PostProcessComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``blend_radius`` (float):  [Read-Write] World space radius around the volume that is used for blending (only if not unbound).
    - ``blend_weight`` (float):  [Read-Write] 0:no effect, 1:full effect
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enabled`` (bool):  [Read-Write] Whether this volume is enabled or not.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``priority`` (float):  [Read-Write] Priority of this volume. In the case of overlapping volumes the one with the highest priority
      overrides the lower priority ones. The order is undefined if two or more overlapping volumes have the same priority.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``settings`` (PostProcessSettings):  [Read-Write] Post process settings to use for this volume.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``unbound`` (bool):  [Read-Write] set this to false to use the parent shape component as volume bounds. True affects the whole world regardless.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def settings(self) -> PostProcessSettings:
        r"""
        (PostProcessSettings):  [Read-Write] Post process settings to use for this volume.
        """
        ...
    @settings.setter
    def settings(self, value: PostProcessSettings) -> None:
        ...
    @property
    def priority(self) -> float:
        r"""
        (float):  [Read-Write] Priority of this volume. In the case of overlapping volumes the one with the highest priority
        overrides the lower priority ones. The order is undefined if two or more overlapping volumes have the same priority.
        """
        ...
    @priority.setter
    def priority(self, value: float) -> None:
        ...
    @property
    def blend_radius(self) -> float:
        r"""
        (float):  [Read-Write] World space radius around the volume that is used for blending (only if not unbound).
        """
        ...
    @blend_radius.setter
    def blend_radius(self, value: float) -> None:
        ...
    @property
    def blend_weight(self) -> float:
        r"""
        (float):  [Read-Write] 0:no effect, 1:full effect
        """
        ...
    @blend_weight.setter
    def blend_weight(self, value: float) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this volume is enabled or not.
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def unbound(self) -> bool:
        r"""
        (bool):  [Read-Write] set this to false to use the parent shape component as volume bounds. True affects the whole world regardless.
        """
        ...
    @unbound.setter
    def unbound(self, value: bool) -> None:
        ...
    def add_or_update_blendable(self, blendable_object: BlendableInterface, weight: float = 1.000000) -> None:
        r"""
        x.add_or_update_blendable(blendable_object, weight=1.000000) -> None
        Adds an Blendable (implements IBlendableInterface) to the array of Blendables (if it doesn't exist) and update the weight
        
        Args:
            blendable_object (BlendableInterface): 
            weight (float):
        """
        ...

class ProjectileMovementComponent(MovementComponent):
    r"""
    ProjectileMovementComponent updates the position of another component during its tick.
    
    Behavior such as bouncing after impacts and homing toward a target are supported.
    
    Normally the root component of the owning actor is moved, however another component may be selected (see SetUpdatedComponent()).
    If the updated component is simulating physics, only the initial launch parameters (when initial velocity is non-zero)
    will affect the projectile, and the physics sim will take over from there.
    see: UMovementComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ProjectileMovementComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_register_physics_volume_updates`` (bool):  [Read-Write] If true, then applies the value of bComponentShouldUpdatePhysicsVolume to the UpdatedComponent. If false, will not change bShouldUpdatePhysicsVolume on the UpdatedComponent at all.
      see: bComponentShouldUpdatePhysicsVolume
    - ``auto_register_updated_component`` (bool):  [Read-Write] If true, registers the owner's Root component as the UpdatedComponent if there is not one currently assigned.
    - ``auto_update_tick_registration`` (bool):  [Read-Write] If true, whenever the updated component is changed, this component will enable or disable its tick dependent on whether it has something to update.
      This will NOT enable tick at startup if bAutoActivate is false, because presumably you have a good reason for not wanting it to start ticking initially.
    - ``bounce_additional_iterations`` (int32):  [Read-Write] On the first few bounces (up to this amount), allow extra iterations over MaxSimulationIterations if necessary.
    - ``bounce_angle_affects_friction`` (bool):  [Read-Write] Controls the effects of friction on velocity parallel to the impact surface when bouncing.
      If true, friction will be modified based on the angle of impact, making friction higher for perpendicular impacts and lower for glancing impacts.
      If false, a bounce will retain a proportion of tangential velocity equal to (1.0 - Friction), acting as a "horizontal restitution".
    - ``bounce_velocity_stop_simulating_threshold`` (float):  [Read-Write] If velocity is below this threshold after a bounce, stops simulating and triggers the OnProjectileStop event.
      Ignored if bShouldBounce is false, in which case the projectile stops simulating on the first impact.
      see: StopSimulating(), OnProjectileStop
    - ``bounciness`` (float):  [Read-Write] Percentage of velocity maintained after the bounce in the direction of the normal of impact (coefficient of restitution).
      1.0 = no velocity lost, 0.0 = no bounce. Ignored if bShouldBounce is false.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_should_update_physics_volume`` (bool):  [Read-Write] If true, enables bShouldUpdatePhysicsVolume on the UpdatedComponent during initialization from SetUpdatedComponent(), otherwise disables such updates.
      Only enabled if bAutoRegisterPhysicsVolumeUpdates is true.
      WARNING: UpdatePhysicsVolume is potentially expensive if overlap events are also *disabled* because it requires a separate query against all physics volumes in the world.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_to_plane`` (bool):  [Read-Write] If true, movement will be constrained to a plane.
      see: PlaneConstraintNormal, PlaneConstraintOrigin, PlaneConstraintAxisSetting
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``force_sub_stepping`` (bool):  [Read-Write] If true, forces sub-stepping to break up movement into discrete smaller steps to improve accuracy of the trajectory.
      Objects that move in a straight line typically do *not* need to set this, as movement always uses continuous collision detection (sweeps) so collision is not missed.
      Sub-stepping is automatically enabled when under the effects of gravity or when homing towards a target.
      see: MaxSimulationTimeStep, MaxSimulationIterations
    - ``friction`` (float):  [Read-Write] Coefficient of friction, affecting the resistance to sliding along a surface.
      Normal range is [0,1] : 0.0 = no friction, 1.0+ = very high friction.
      Also affects the percentage of velocity maintained after the bounce in the direction tangent to the normal of impact.
      Ignored if bShouldBounce is false.
      see: bBounceAngleAffectsFriction
    - ``homing_acceleration_magnitude`` (float):  [Read-Write] The magnitude of our acceleration towards the homing target. Overall velocity magnitude will still be limited by MaxSpeed.
    - ``homing_target_component`` (SceneComponent):  [Read-Only] The current target we are homing towards. Can only be set at runtime (when projectile is spawned or updating).
      see: bIsHomingProjectile
    - ``initial_speed`` (float):  [Read-Write] Initial speed of projectile. If greater than zero, this will override the initial Velocity value and instead treat Velocity as a direction.
    - ``initial_velocity_in_local_space`` (bool):  [Read-Write] If true, the initial Velocity is interpreted as being in local space upon startup.
      see: SetVelocityInLocalSpace()
    - ``interp_location_max_lag_distance`` (float):  [Read-Write] Max distance behind UpdatedComponent which the interpolated component is allowed to lag.
    - ``interp_location_snap_to_target_distance`` (float):  [Read-Write] Max distance behind UpdatedComponent beyond which the interpolated component is snapped to the target location instead.
      For instance if the target teleports this far beyond the interpolated component, the interpolation is snapped to match the target.
    - ``interp_location_time`` (float):  [Read-Write] "Time" over which most of the location interpolation occurs, when the UpdatedComponent (target) moves ahead of the interpolated component.
      Since the implementation uses exponential lagged smoothing, this is a rough time value and experimentation should inform a final result.
      A value of zero is effectively instantaneous interpolation.
    - ``interp_movement`` (bool):  [Read-Write] If true and there is an interpolated component set, location (and optionally rotation) interpolation is enabled which allows the interpolated object to smooth uneven updates
      of the UpdatedComponent's location (usually to smooth network updates). This requires using SetInterpolatedComponent() to indicate the visual component that lags behind the collision,
      and using MoveInterpolationTarget() when the new target location/rotation is received (usually on a net update).
      see: SetInterpolatedComponent(), MoveInterpolationTarget()
    - ``interp_rotation`` (bool):  [Read-Write] If true and there is an interpolated component set, rotation interpolation is enabled which allows the interpolated object to smooth uneven updates
      of the UpdatedComponent's rotation (usually to smooth network updates).
      Rotation interpolation is *only* applied if bInterpMovement is also enabled.
      see: SetInterpolatedComponent(), MoveInterpolationTarget()
    - ``interp_rotation_time`` (float):  [Read-Write] "Time" over which most of the rotation interpolation occurs, when the UpdatedComponent (target) moves ahead of the interpolated component.
      Since the implementation uses exponential lagged smoothing, this is a rough time value and experimentation should inform a final result.
      A value of zero is effectively instantaneous interpolation.
    - ``interpolation_use_scoped_movement`` (bool):  [Read-Write] If true, uses FScopedMovementUpdate to avoid moving the attached interpolated object's children more than once during a tick when it would both interpolate and move during projectile simulation.
      This also defers overlap updates for the interpolated object until after the simulation update completes.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_homing_projectile`` (bool):  [Read-Write] If true, we will accelerate toward our homing target. HomingTargetComponent must be set after the projectile is spawned.
      see: HomingTargetComponent, HomingAccelerationMagnitude
    - ``is_sliding`` (bool):  [Read-Only] If true, projectile is sliding / rolling along a surface.
    - ``max_simulation_iterations`` (int32):  [Read-Write] Max number of iterations used for each discrete simulation step.
      Increasing this value can address precision issues with fast-moving objects or complex collision scenarios, at the cost of performance.
      
      WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
      see: MaxSimulationTimeStep, bForceSubStepping
    - ``max_simulation_time_step`` (float):  [Read-Write] Max time delta for each discrete simulation step.
      Lowering this value can address precision issues with fast-moving objects or complex collision scenarios, at the cost of performance.
      
      WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
      see: MaxSimulationIterations, bForceSubStepping
    - ``max_speed`` (float):  [Read-Write] Limit on speed of projectile (0 means no limit).
    - ``min_friction_fraction`` (float):  [Read-Write] When bounce angle affects friction, apply at least this fraction of normal friction.
      Helps consistently slow objects sliding or rolling along surfaces or in valleys when the usual friction amount would take a very long time to settle.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_projectile_bounce`` (OnProjectileBounceDelegate):  [Read-Write] Called when projectile impacts something and bounces are enabled.
    - ``on_projectile_stop`` (OnProjectileStopDelegate):  [Read-Write] Called when projectile has come to a stop (velocity is below simulation threshold, bounces are disabled, or it is forcibly stopped).
    - ``plane_constraint_axis_setting`` (PlaneConstraintAxisSetting):  [Read-Write] Setting that controls behavior when movement is restricted to a 2D plane defined by a specific axis/normal,
      so that movement along the locked axis is not be possible.
      see: SetPlaneConstraintAxisSetting
    - ``plane_constraint_normal`` (Vector):  [Read-Write] The normal or axis of the plane that constrains movement, if bConstrainToPlane is enabled.
      If for example you wanted to constrain movement to the X-Z plane (so that Y cannot change), the normal would be set to X=0 Y=1 Z=0.
      This is recalculated whenever PlaneConstraintAxisSetting changes. It is normalized once the component is registered with the game world.
      see: bConstrainToPlane, SetPlaneConstraintNormal(), SetPlaneConstraintFromVectors()
    - ``plane_constraint_origin`` (Vector):  [Read-Write] The origin of the plane that constrains movement, if plane constraint is enabled.
      This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
      see: bConstrainToPlane, SetPlaneConstraintOrigin().
    - ``previous_hit_normal`` (Vector):  [Read-Only] Saved HitResult Normal from previous simulation step that resulted in an impact. If PreviousHitTime is 1.0, then the hit was not in the last step.
    - ``previous_hit_time`` (float):  [Read-Only] Saved HitResult Time (0 to 1) from previous simulation step. Equal to 1.0 when there was no impact.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``projectile_gravity_scale`` (float):  [Read-Write] Custom gravity scale for this projectile. Set to 0 for no gravity.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``rotation_follows_velocity`` (bool):  [Read-Write] If true, this projectile will have its rotation updated each frame to match the direction of its velocity.
    - ``rotation_remains_vertical`` (bool):  [Read-Write] If true, this projectile will have its rotation updated each frame to maintain the rotations Yaw only. (bRotationFollowsVelocity is required to be true)
    - ``should_bounce`` (bool):  [Read-Write] If true, simple bounces will be simulated. Set this to false to stop simulating on contact.
    - ``simulation_enabled`` (bool):  [Read-Write] If true, does normal simulation ticking and update. If false, simulation is halted, but component will still tick (allowing interpolation to run).
    - ``simulation_use_scoped_movement`` (bool):  [Read-Write] If true, uses FScopedMovementUpdate to avoid moving the UpdatedComponent more than once during a tick during simulation.
      This also defers overlap updates and some impact events until after the simulation update completes, so it may delay important events and continue deflection, so use with caution.
    - ``snap_to_plane_at_start`` (bool):  [Read-Write] If true and plane constraints are enabled, then the updated component will be snapped to the plane when first attached.
    - ``sweep_collision`` (bool):  [Read-Write] If true, movement uses swept collision checks.
      If false, collision effectively teleports to the destination. Note that when this is disabled, movement will never generate blocking collision hits (though overlaps will be updated).
    - ``throttle_interpolation`` (bool):  [Read-Write] If true, throttle interpolation when not relevant.
      see: ThrottleInterpolationSkipFramesNotRecent, ThrottleInterpolationSkipFramesRecent, ThrottleInterpolationThresholdNotRenderedShortTime, ThrottleInterpolationThresholdNotRenderedLongTime
    - ``throttle_interpolation_skip_frames_not_recent`` (int32):  [Read-Write] When not recently relevant, skip this many frames of interpolation if throttling is enabled.
    - ``throttle_interpolation_skip_frames_recent`` (int32):  [Read-Write] When recently relevant, skip this many frames of interpolation if throttling is enabled.
    - ``throttle_interpolation_threshold_not_rendered_long_time`` (float):  [Read-Write] Time after not rendered for a long time when we consider throttling interpolation.
    - ``throttle_interpolation_threshold_not_rendered_short_time`` (float):  [Read-Write] Time after not rendered recently when we consider throttling interpolation.
    - ``tick_before_owner`` (bool):  [Read-Write] If true, after registration we will add a tick dependency to tick before our owner (if we can both tick).
      This is important when our tick causes an update in the owner's position, so that when the owner ticks it uses the most recent position without lag.
      Disabling this can improve performance if both objects tick but the order of ticks doesn't matter.
    - ``update_only_if_rendered`` (bool):  [Read-Write] If true, skips TickComponent() if UpdatedComponent was not recently rendered.
    - ``updated_component`` (SceneComponent):  [Read-Write] The component we move and update.
      If this is null at startup and bAutoRegisterUpdatedComponent is true, the owning Actor's root component will automatically be set as our UpdatedComponent at startup.
      see: bAutoRegisterUpdatedComponent, SetUpdatedComponent(), UpdatedPrimitive
    - ``updated_primitive`` (PrimitiveComponent):  [Read-Write] UpdatedComponent, cast as a UPrimitiveComponent. May be invalid if UpdatedComponent was null or not a UPrimitiveComponent.
    - ``velocity`` (Vector):  [Read-Write] Current velocity of updated component.
    """
    @property
    def initial_speed(self) -> float:
        r"""
        (float):  [Read-Write] Initial speed of projectile. If greater than zero, this will override the initial Velocity value and instead treat Velocity as a direction.
        """
        ...
    @initial_speed.setter
    def initial_speed(self, value: float) -> None:
        ...
    @property
    def speed(self) -> float:
        r"""
        deprecated: 'speed' was renamed to 'initial_speed'.
        """
        ...
    @speed.setter
    def speed(self, value: float) -> None:
        ...
    @property
    def max_speed(self) -> float:
        r"""
        (float):  [Read-Write] Limit on speed of projectile (0 means no limit).
        """
        ...
    @max_speed.setter
    def max_speed(self, value: float) -> None:
        ...
    @property
    def rotation_follows_velocity(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this projectile will have its rotation updated each frame to match the direction of its velocity.
        """
        ...
    @rotation_follows_velocity.setter
    def rotation_follows_velocity(self, value: bool) -> None:
        ...
    @property
    def rotation_remains_vertical(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this projectile will have its rotation updated each frame to maintain the rotations Yaw only. (bRotationFollowsVelocity is required to be true)
        """
        ...
    @rotation_remains_vertical.setter
    def rotation_remains_vertical(self, value: bool) -> None:
        ...
    @property
    def should_bounce(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, simple bounces will be simulated. Set this to false to stop simulating on contact.
        """
        ...
    @should_bounce.setter
    def should_bounce(self, value: bool) -> None:
        ...
    @property
    def initial_velocity_in_local_space(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the initial Velocity is interpreted as being in local space upon startup.
        see: SetVelocityInLocalSpace()
        """
        ...
    @initial_velocity_in_local_space.setter
    def initial_velocity_in_local_space(self, value: bool) -> None:
        ...
    @property
    def force_sub_stepping(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, forces sub-stepping to break up movement into discrete smaller steps to improve accuracy of the trajectory.
        Objects that move in a straight line typically do *not* need to set this, as movement always uses continuous collision detection (sweeps) so collision is not missed.
        Sub-stepping is automatically enabled when under the effects of gravity or when homing towards a target.
        see: MaxSimulationTimeStep, MaxSimulationIterations
        """
        ...
    @force_sub_stepping.setter
    def force_sub_stepping(self, value: bool) -> None:
        ...
    @property
    def simulation_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, does normal simulation ticking and update. If false, simulation is halted, but component will still tick (allowing interpolation to run).
        """
        ...
    @simulation_enabled.setter
    def simulation_enabled(self, value: bool) -> None:
        ...
    @property
    def sweep_collision(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, movement uses swept collision checks.
        If false, collision effectively teleports to the destination. Note that when this is disabled, movement will never generate blocking collision hits (though overlaps will be updated).
        """
        ...
    @sweep_collision.setter
    def sweep_collision(self, value: bool) -> None:
        ...
    @property
    def is_homing_projectile(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, we will accelerate toward our homing target. HomingTargetComponent must be set after the projectile is spawned.
        see: HomingTargetComponent, HomingAccelerationMagnitude
        """
        ...
    @is_homing_projectile.setter
    def is_homing_projectile(self, value: bool) -> None:
        ...
    @property
    def bounce_angle_affects_friction(self) -> bool:
        r"""
        (bool):  [Read-Write] Controls the effects of friction on velocity parallel to the impact surface when bouncing.
        If true, friction will be modified based on the angle of impact, making friction higher for perpendicular impacts and lower for glancing impacts.
        If false, a bounce will retain a proportion of tangential velocity equal to (1.0 - Friction), acting as a "horizontal restitution".
        """
        ...
    @bounce_angle_affects_friction.setter
    def bounce_angle_affects_friction(self, value: bool) -> None:
        ...
    @property
    def is_sliding(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, projectile is sliding / rolling along a surface.
        """
        ...
    @property
    def interp_movement(self) -> bool:
        r"""
        (bool):  [Read-Write] If true and there is an interpolated component set, location (and optionally rotation) interpolation is enabled which allows the interpolated object to smooth uneven updates
        of the UpdatedComponent's location (usually to smooth network updates). This requires using SetInterpolatedComponent() to indicate the visual component that lags behind the collision,
        and using MoveInterpolationTarget() when the new target location/rotation is received (usually on a net update).
        see: SetInterpolatedComponent(), MoveInterpolationTarget()
        """
        ...
    @interp_movement.setter
    def interp_movement(self, value: bool) -> None:
        ...
    @property
    def interp_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] If true and there is an interpolated component set, rotation interpolation is enabled which allows the interpolated object to smooth uneven updates
        of the UpdatedComponent's rotation (usually to smooth network updates).
        Rotation interpolation is *only* applied if bInterpMovement is also enabled.
        see: SetInterpolatedComponent(), MoveInterpolationTarget()
        """
        ...
    @interp_rotation.setter
    def interp_rotation(self, value: bool) -> None:
        ...
    @property
    def throttle_interpolation(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, throttle interpolation when not relevant.
        see: ThrottleInterpolationSkipFramesNotRecent, ThrottleInterpolationSkipFramesRecent, ThrottleInterpolationThresholdNotRenderedShortTime, ThrottleInterpolationThresholdNotRenderedLongTime
        """
        ...
    @throttle_interpolation.setter
    def throttle_interpolation(self, value: bool) -> None:
        ...
    @property
    def simulation_use_scoped_movement(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, uses FScopedMovementUpdate to avoid moving the UpdatedComponent more than once during a tick during simulation.
        This also defers overlap updates and some impact events until after the simulation update completes, so it may delay important events and continue deflection, so use with caution.
        """
        ...
    @simulation_use_scoped_movement.setter
    def simulation_use_scoped_movement(self, value: bool) -> None:
        ...
    @property
    def interpolation_use_scoped_movement(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, uses FScopedMovementUpdate to avoid moving the attached interpolated object's children more than once during a tick when it would both interpolate and move during projectile simulation.
        This also defers overlap updates for the interpolated object until after the simulation update completes.
        """
        ...
    @interpolation_use_scoped_movement.setter
    def interpolation_use_scoped_movement(self, value: bool) -> None:
        ...
    @property
    def previous_hit_time(self) -> float:
        r"""
        (float):  [Read-Only] Saved HitResult Time (0 to 1) from previous simulation step. Equal to 1.0 when there was no impact.
        """
        ...
    @property
    def previous_hit_normal(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Saved HitResult Normal from previous simulation step that resulted in an impact. If PreviousHitTime is 1.0, then the hit was not in the last step.
        """
        ...
    @property
    def projectile_gravity_scale(self) -> float:
        r"""
        (float):  [Read-Write] Custom gravity scale for this projectile. Set to 0 for no gravity.
        """
        ...
    @projectile_gravity_scale.setter
    def projectile_gravity_scale(self, value: float) -> None:
        ...
    @property
    def bounciness(self) -> float:
        r"""
        (float):  [Read-Write] Percentage of velocity maintained after the bounce in the direction of the normal of impact (coefficient of restitution).
        1.0 = no velocity lost, 0.0 = no bounce. Ignored if bShouldBounce is false.
        """
        ...
    @bounciness.setter
    def bounciness(self, value: float) -> None:
        ...
    @property
    def friction(self) -> float:
        r"""
        (float):  [Read-Write] Coefficient of friction, affecting the resistance to sliding along a surface.
        Normal range is [0,1] : 0.0 = no friction, 1.0+ = very high friction.
        Also affects the percentage of velocity maintained after the bounce in the direction tangent to the normal of impact.
        Ignored if bShouldBounce is false.
        see: bBounceAngleAffectsFriction
        """
        ...
    @friction.setter
    def friction(self, value: float) -> None:
        ...
    @property
    def bounce_velocity_stop_simulating_threshold(self) -> float:
        r"""
        (float):  [Read-Write] If velocity is below this threshold after a bounce, stops simulating and triggers the OnProjectileStop event.
        Ignored if bShouldBounce is false, in which case the projectile stops simulating on the first impact.
        see: StopSimulating(), OnProjectileStop
        """
        ...
    @bounce_velocity_stop_simulating_threshold.setter
    def bounce_velocity_stop_simulating_threshold(self, value: float) -> None:
        ...
    @property
    def min_friction_fraction(self) -> float:
        r"""
        (float):  [Read-Write] When bounce angle affects friction, apply at least this fraction of normal friction.
        Helps consistently slow objects sliding or rolling along surfaces or in valleys when the usual friction amount would take a very long time to settle.
        """
        ...
    @min_friction_fraction.setter
    def min_friction_fraction(self, value: float) -> None:
        ...
    @property
    def on_projectile_bounce(self) -> OnProjectileBounceDelegate:
        r"""
        (OnProjectileBounceDelegate):  [Read-Write] Called when projectile impacts something and bounces are enabled.
        """
        ...
    @on_projectile_bounce.setter
    def on_projectile_bounce(self, value: OnProjectileBounceDelegate) -> None:
        ...
    @property
    def on_projectile_stop(self) -> OnProjectileStopDelegate:
        r"""
        (OnProjectileStopDelegate):  [Read-Write] Called when projectile has come to a stop (velocity is below simulation threshold, bounces are disabled, or it is forcibly stopped).
        """
        ...
    @on_projectile_stop.setter
    def on_projectile_stop(self, value: OnProjectileStopDelegate) -> None:
        ...
    @property
    def homing_acceleration_magnitude(self) -> float:
        r"""
        (float):  [Read-Write] The magnitude of our acceleration towards the homing target. Overall velocity magnitude will still be limited by MaxSpeed.
        """
        ...
    @homing_acceleration_magnitude.setter
    def homing_acceleration_magnitude(self, value: float) -> None:
        ...
    @property
    def homing_target_component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Only] The current target we are homing towards. Can only be set at runtime (when projectile is spawned or updating).
        see: bIsHomingProjectile
        """
        ...
    @property
    def max_simulation_time_step(self) -> float:
        r"""
        (float):  [Read-Write] Max time delta for each discrete simulation step.
        Lowering this value can address precision issues with fast-moving objects or complex collision scenarios, at the cost of performance.
        
        WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
        see: MaxSimulationIterations, bForceSubStepping
        """
        ...
    @max_simulation_time_step.setter
    def max_simulation_time_step(self, value: float) -> None:
        ...
    @property
    def max_simulation_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] Max number of iterations used for each discrete simulation step.
        Increasing this value can address precision issues with fast-moving objects or complex collision scenarios, at the cost of performance.
        
        WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
        see: MaxSimulationTimeStep, bForceSubStepping
        """
        ...
    @max_simulation_iterations.setter
    def max_simulation_iterations(self, value: int) -> None:
        ...
    @property
    def bounce_additional_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] On the first few bounces (up to this amount), allow extra iterations over MaxSimulationIterations if necessary.
        """
        ...
    @bounce_additional_iterations.setter
    def bounce_additional_iterations(self, value: int) -> None:
        ...
    @property
    def interp_location_time(self) -> float:
        r"""
        (float):  [Read-Write] "Time" over which most of the location interpolation occurs, when the UpdatedComponent (target) moves ahead of the interpolated component.
        Since the implementation uses exponential lagged smoothing, this is a rough time value and experimentation should inform a final result.
        A value of zero is effectively instantaneous interpolation.
        """
        ...
    @interp_location_time.setter
    def interp_location_time(self, value: float) -> None:
        ...
    @property
    def interp_rotation_time(self) -> float:
        r"""
        (float):  [Read-Write] "Time" over which most of the rotation interpolation occurs, when the UpdatedComponent (target) moves ahead of the interpolated component.
        Since the implementation uses exponential lagged smoothing, this is a rough time value and experimentation should inform a final result.
        A value of zero is effectively instantaneous interpolation.
        """
        ...
    @interp_rotation_time.setter
    def interp_rotation_time(self, value: float) -> None:
        ...
    @property
    def interp_location_max_lag_distance(self) -> float:
        r"""
        (float):  [Read-Write] Max distance behind UpdatedComponent which the interpolated component is allowed to lag.
        """
        ...
    @interp_location_max_lag_distance.setter
    def interp_location_max_lag_distance(self, value: float) -> None:
        ...
    @property
    def interp_location_snap_to_target_distance(self) -> float:
        r"""
        (float):  [Read-Write] Max distance behind UpdatedComponent beyond which the interpolated component is snapped to the target location instead.
        For instance if the target teleports this far beyond the interpolated component, the interpolation is snapped to match the target.
        """
        ...
    @interp_location_snap_to_target_distance.setter
    def interp_location_snap_to_target_distance(self, value: float) -> None:
        ...
    @property
    def throttle_interpolation_threshold_not_rendered_short_time(self) -> float:
        r"""
        (float):  [Read-Write] Time after not rendered recently when we consider throttling interpolation.
        """
        ...
    @throttle_interpolation_threshold_not_rendered_short_time.setter
    def throttle_interpolation_threshold_not_rendered_short_time(self, value: float) -> None:
        ...
    @property
    def throttle_interpolation_threshold_not_rendered_long_time(self) -> float:
        r"""
        (float):  [Read-Write] Time after not rendered for a long time when we consider throttling interpolation.
        """
        ...
    @throttle_interpolation_threshold_not_rendered_long_time.setter
    def throttle_interpolation_threshold_not_rendered_long_time(self, value: float) -> None:
        ...
    @property
    def throttle_interpolation_skip_frames_recent(self) -> int:
        r"""
        (int32):  [Read-Write] When recently relevant, skip this many frames of interpolation if throttling is enabled.
        """
        ...
    @throttle_interpolation_skip_frames_recent.setter
    def throttle_interpolation_skip_frames_recent(self, value: int) -> None:
        ...
    @property
    def throttle_interpolation_skip_frames_not_recent(self) -> int:
        r"""
        (int32):  [Read-Write] When not recently relevant, skip this many frames of interpolation if throttling is enabled.
        """
        ...
    @throttle_interpolation_skip_frames_not_recent.setter
    def throttle_interpolation_skip_frames_not_recent(self, value: int) -> None:
        ...
    def stop_simulating(self, hit_result: HitResult) -> None:
        r"""
        x.stop_simulating(hit_result) -> None
        Clears the reference to UpdatedComponent, fires stop event (OnProjectileStop), and stops ticking (if bAutoUpdateTickRegistration is true).
        
        Args:
            hit_result (HitResult):
        """
        ...
    def stop_movement(self, hit_result: HitResult) -> None:
        r"""
        deprecated: 'stop_movement' was renamed to 'stop_simulating'.
        """
        ...
    def set_velocity_in_local_space(self, new_velocity: Vector) -> None:
        r"""
        x.set_velocity_in_local_space(new_velocity) -> None
        Sets the velocity to the new value, rotated into Actor space.
        
        Args:
            new_velocity (Vector):
        """
        ...
    def set_interpolated_component(self, component: SceneComponent) -> None:
        r"""
        x.set_interpolated_component(component) -> None
        Assigns the component that will be used for network interpolation/smoothing. It is expected that this is a component attached somewhere below the UpdatedComponent.
        When network updates use MoveInterpolationTarget() to move the UpdatedComponent, the interpolated component's relative offset will be maintained and smoothed over
        the course of future component ticks. The current relative location and rotation of the component is saved as the target offset for future interpolation.
        see: MoveInterpolationTarget(), bInterpMovement, bInterpRotation
        
        Args:
            component (SceneComponent):
        """
        ...
    def reset_interpolation(self) -> None:
        r"""
        x.reset_interpolation() -> None
        Resets interpolation so that interpolated component snaps back to the initial location/rotation without any additional offsets.
        """
        ...
    def move_interpolation_target(self, new_location: Vector, new_rotation: Rotator) -> None:
        r"""
        x.move_interpolation_target(new_location, new_rotation) -> None
        Moves the UpdatedComponent, which is also the interpolation target for the interpolated component. If there is not interpolated component, this simply moves UpdatedComponent.
        Use this typically from PostNetReceiveLocationAndRotation() or similar from an Actor.
        
        Args:
            new_location (Vector): 
            new_rotation (Rotator):
        """
        ...
    def limit_velocity(self, new_velocity: Vector) -> Vector:
        r"""
        x.limit_velocity(new_velocity) -> Vector
        Don't allow velocity magnitude to exceed MaxSpeed, if MaxSpeed is non-zero.
        
        Args:
            new_velocity (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def is_velocity_under_simulation_threshold(self) -> bool:
        r"""
        x.is_velocity_under_simulation_threshold() -> bool
        Returns true if velocity magnitude is less than BounceVelocityStopSimulatingThreshold.
        
        Returns:
            bool:
        """
        ...
    def is_interpolation_complete(self) -> bool:
        r"""
        x.is_interpolation_complete() -> bool
        Returns whether interpolation is complete because the target has been reached. True when interpolation is disabled.
        
        Returns:
            bool:
        """
        ...

class MovementComp_Projectile(ProjectileMovementComponent):
    r"""
    deprecated: 'MovementComp_Projectile' was renamed to 'ProjectileMovementComponent'.
    """
    ...

class RectLightComponent(LocalLightComponent):
    r"""
    A light component which emits light from a rectangle.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RectLightComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_global_illumination`` (bool):  [Read-Write] Whether the light affects global illumination, when ray-traced global illumination is enabled.
    - ``affect_reflection`` (bool):  [Read-Write] Whether the light affects objects in reflections, when ray-traced reflection is enabled.
    - ``affect_translucent_lighting`` (bool):  [Read-Write] Whether the light affects translucency or not.  Disabling this can save GPU time when there are many small lights.
    - ``affects_world`` (bool):  [Read-Write] Whether the light can affect the world, or whether it is disabled.
      A disabled light will not contribute to the scene in any way.  This setting cannot be changed at runtime and unbuilds lighting when changed.
      Setting this to false has the same effect as deleting the light, so it is useful for non-destructive experiments.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_radius`` (float):  [Read-Write] Bounds the light's visible influence.
      This clamping of the light's influence is not physically correct but very important for performance, larger lights cost more.
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``barn_door_angle`` (float):  [Read-Write] Angle of barn door attached to the light source rect.
    - ``barn_door_length`` (float):  [Read-Write] Length of barn door attached to the light source rect.
    - ``bloom_max_brightness`` (float):  [Read-Write] After exposure is applied, scene color brightness larger than BloomMaxBrightness will be rescaled down to BloomMaxBrightness.
    - ``bloom_scale`` (float):  [Read-Write] Scales the additive color.
    - ``bloom_threshold`` (float):  [Read-Write] Scene color must be larger than this to create bloom in the light shafts.
    - ``bloom_tint`` (Color):  [Read-Write] Multiplies against scene color to create the bloom color.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_deep_shadow`` (bool):  [Read-Write] Whether the light should cast high quality hair-strands self-shadowing. When this option is enabled, an extra GPU cost for this light.
    - ``cast_dynamic_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from dynamic objects.  Also requires Cast Shadows to be set to True.
    - ``cast_raytraced_shadow`` (CastRayTracedShadow):  [Read-Write]
    - ``cast_shadows`` (bool):  [Read-Write] Whether the light should cast any shadows.
    - ``cast_shadows_from_cinematic_objects_only`` (bool):  [Read-Write] Whether the light should only cast shadows from components marked as bCastCinematicShadows.
      This is useful for setting up cinematic Movable spotlights aimed at characters and avoiding the shadow depth rendering costs of the background.
      Note: this only works with dynamic shadow maps, not with static shadowing or Ray Traced Distance Field shadows.
    - ``cast_static_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from static objects.  Also requires Cast Shadows to be set to True.
    - ``cast_translucent_shadows`` (bool):  [Read-Write] Whether the light is allowed to cast dynamic shadows from translucency.
    - ``cast_volumetric_shadow`` (bool):  [Read-Write] Whether the light shadows volumetric fog.  Disabling this can save GPU time.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``contact_shadow_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" enabled. 0 = no shadow, 1 (default) = fully shadowed.
    - ``contact_shadow_length`` (float):  [Read-Write] Length of screen space ray trace for sharp contact shadows. Zero is disabled.
    - ``contact_shadow_length_in_ws`` (bool):  [Read-Write] Where Length of screen space ray trace for sharp contact shadows is in world space units or in screen space units.
    - ``contact_shadow_non_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" disabled. 0 (default) = no shadow, 1 = fully shadowed.
    - ``deep_shadow_layer_distribution`` (float):  [Read-Write] Change the deep shadow layers distribution 0:linear distribution (uniform layer distribution), 1:exponential (more details on near small details).
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disabled_brightness`` (float):  [Read-Write] Brightness factor applied to the light when the light function is specified but disabled, for example in scene captures that use SceneCapView_LitNoShadows.
      This should be set to the average brightness of the light function material's emissive input, which should be between 0 and 1.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_light_shaft_bloom`` (bool):  [Read-Write] Whether to render light shaft bloom from this light.
      For directional lights, the color around the light direction will be blurred radially and added back to the scene.
      for point lights, the color on pixels closer than the light's SourceRadius will be blurred radially and added back to the scene.
    - ``force_cached_shadows_for_movable_primitives`` (bool):  [Read-Write] Enables cached shadows for movable primitives for this light even if r.shadow.cachedshadowscastfrommovableprimitives is 0
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``ies_brightness_scale`` (float):  [Read-Write] Global scale for IES brightness contribution. Only available when "Use IES Brightness" is selected, and a valid IES profile texture is set
    - ``ies_texture`` (TextureLightProfile):  [Read-Write] IES texture (light profiles from real world measured data)
    - ``indirect_lighting_intensity`` (float):  [Read-Write] Scales the indirect lighting contribution from this light.
      A value of 0 disables any GI from this light. Default is 1.
    - ``intensity`` (float):  [Read-Write] Total energy that the light emits.
    - ``intensity_units`` (LightUnits):  [Read-Write] Units used for the intensity.
      The peak luminous intensity is measured in candelas,
      while the luminous power is measured in lumens.
    - ``inverse_exposure_blend`` (float):  [Read-Write] Blend Factor used to blend between Intensity and Intensity/Exposure.
      This is useful for gameplay lights that should have constant brighness on screen independent of current exposure.
      This feature can cause issues with exposure particularly when used on the primary light on a scene, as such it's usage should be limited.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``light_color`` (Color):  [Read-Write] Filter color of the light.
      Note that this can change the light's effective intensity.
    - ``light_function_fade_distance`` (float):  [Read-Write] Distance at which the light function should be completely faded to DisabledBrightness.
      This is useful for hiding aliasing from light functions applied in the distance.
    - ``light_function_material`` (MaterialInterface):  [Read-Write] The light function material to be applied to this light.
      Note that only non-lightmapped lights (UseDirectLightMap=False) can have a light function.
      Light functions are supported within VolumetricFog, but only for Directional, Point and Spot lights. Rect lights are not supported.
    - ``light_function_scale`` (Vector):  [Read-Write] Scales the light function projection.  X and Y scale in the directions perpendicular to the light's direction, Z scales along the light direction.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this light should affect.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmass_settings`` (LightmassPointLightSettings):  [Read-Write] The Lightmass settings for this object.
    - ``max_distance_fade_range`` (float):  [Read-Write]
    - ``max_draw_distance`` (float):  [Read-Write]
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_start_offset_depth_scale`` (float):  [Read-Write] Controls how large of an offset ray traced shadows have from the receiving surface as the camera gets further away.
      This can be useful to hide self-shadowing artifacts from low resolution distance fields on huge static meshes.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``samples_per_pixel`` (int32):  [Read-Write] Samples per pixel for ray tracing
    - ``shadow_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``shadow_resolution_scale`` (float):  [Read-Write] Scales the resolution of shadowmaps used to shadow this light.  By default shadowmap resolution is chosen based on screen size of the caster.
      Setting the scale to zero disables shadow maps, but does not disable, e.g., contact shadows.
      Note: shadowmap resolution is still clamped by 'r.Shadow.MaxResolution'
    - ``shadow_sharpen`` (float):  [Read-Write] Amount to sharpen shadow filtering
    - ``shadow_slope_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are. This works in addition to shadow bias, by increasing the
      amount of bias depending on the slope of a surface.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``source_height`` (float):  [Read-Write] Height of light source rect.
      Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
    - ``source_texture`` (Texture):  [Read-Write] Texture mapped to the light source rectangle
    - ``source_width`` (float):  [Read-Write] Width of light source rect.
      Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
    - ``specular_scale`` (float):  [Read-Write] Multiplier on specular highlights. Use only with great care! Any value besides 1 is not physical!
      Can be used to artistically remove highlights mimicking polarizing filters or photo touch up.
    - ``temperature`` (float):  [Read-Write] Color temperature in Kelvin of the blackbody illuminant.
      White (D65) is 6500K.
    - ``transmission`` (bool):  [Read-Write] Whether light from this light transmits through surfaces with subsurface scattering profiles. Requires light to be movable.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_ies_brightness`` (bool):  [Read-Write] true: take light brightness from IES profile, false: use the light brightness - the maximum light in one direction is used to define no masking. Use with InverseSquareFalloff. Will be disabled if a valid IES profile texture is not supplied.
    - ``use_ray_traced_distance_field_shadows`` (bool):  [Read-Write] Whether to use ray traced distance field area shadows.  The project setting bGenerateMeshDistanceFields must be enabled for this to have effect.
      Distance field shadows support area lights so they create soft shadows with sharp contacts.
      They have less aliasing artifacts than standard shadowmaps, but inherit all the limitations of distance field representations (only uniform scale, no deformation).
      These shadows have a low per-object cost (and don't depend on triangle count) so they are effective for distant shadows from a dynamic sun.
    - ``use_temperature`` (bool):  [Read-Write] false: use white (D65) as illuminant.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volumetric_scattering_intensity`` (float):  [Read-Write] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
    """
    @property
    def source_width(self) -> float:
        r"""
        (float):  [Read-Only] Width of light source rect.
        Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
        """
        ...
    @property
    def source_height(self) -> float:
        r"""
        (float):  [Read-Only] Height of light source rect.
        Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
        """
        ...
    @property
    def barn_door_angle(self) -> float:
        r"""
        (float):  [Read-Only] Angle of barn door attached to the light source rect.
        """
        ...
    @property
    def barn_door_length(self) -> float:
        r"""
        (float):  [Read-Only] Length of barn door attached to the light source rect.
        """
        ...
    @property
    def source_texture(self) -> Texture:
        r"""
        (Texture):  [Read-Only] Texture mapped to the light source rectangle
        """
        ...
    def set_source_width(self, new_value: float) -> None:
        r"""
        x.set_source_width(new_value) -> None
        Set Source Width
        
        Args:
            new_value (float):
        """
        ...
    def set_source_texture(self, new_value: Texture) -> None:
        r"""
        x.set_source_texture(new_value) -> None
        Set Source Texture
        
        Args:
            new_value (Texture):
        """
        ...
    def set_source_height(self, new_value: float) -> None:
        r"""
        x.set_source_height(new_value) -> None
        Set Source Height
        
        Args:
            new_value (float):
        """
        ...
    def set_barn_door_length(self, new_value: float) -> None:
        r"""
        x.set_barn_door_length(new_value) -> None
        Set Barn Door Length
        
        Args:
            new_value (float):
        """
        ...
    def set_barn_door_angle(self, new_value: float) -> None:
        r"""
        x.set_barn_door_angle(new_value) -> None
        Set Barn Door Angle
        
        Args:
            new_value (float):
        """
        ...

class RotatingMovementComponent(MovementComponent):
    r"""
    Performs continuous rotation of a component at a specific rotation rate.
    Rotation can optionally be offset around a pivot point.
    Collision testing is not performed during movement.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RotatingMovementComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_register_physics_volume_updates`` (bool):  [Read-Write] If true, then applies the value of bComponentShouldUpdatePhysicsVolume to the UpdatedComponent. If false, will not change bShouldUpdatePhysicsVolume on the UpdatedComponent at all.
      see: bComponentShouldUpdatePhysicsVolume
    - ``auto_register_updated_component`` (bool):  [Read-Write] If true, registers the owner's Root component as the UpdatedComponent if there is not one currently assigned.
    - ``auto_update_tick_registration`` (bool):  [Read-Write] If true, whenever the updated component is changed, this component will enable or disable its tick dependent on whether it has something to update.
      This will NOT enable tick at startup if bAutoActivate is false, because presumably you have a good reason for not wanting it to start ticking initially.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_should_update_physics_volume`` (bool):  [Read-Write] If true, enables bShouldUpdatePhysicsVolume on the UpdatedComponent during initialization from SetUpdatedComponent(), otherwise disables such updates.
      Only enabled if bAutoRegisterPhysicsVolumeUpdates is true.
      WARNING: UpdatePhysicsVolume is potentially expensive if overlap events are also *disabled* because it requires a separate query against all physics volumes in the world.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_to_plane`` (bool):  [Read-Write] If true, movement will be constrained to a plane.
      see: PlaneConstraintNormal, PlaneConstraintOrigin, PlaneConstraintAxisSetting
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``pivot_translation`` (Vector):  [Read-Write] Translation of pivot point around which we rotate, relative to current rotation.
      For instance, with PivotTranslation set to (X=+100, Y=0, Z=0), rotation will occur
      around the point +100 units along the local X axis from the center of the object,
      rather than around the object's origin (the default).
    - ``plane_constraint_axis_setting`` (PlaneConstraintAxisSetting):  [Read-Write] Setting that controls behavior when movement is restricted to a 2D plane defined by a specific axis/normal,
      so that movement along the locked axis is not be possible.
      see: SetPlaneConstraintAxisSetting
    - ``plane_constraint_normal`` (Vector):  [Read-Write] The normal or axis of the plane that constrains movement, if bConstrainToPlane is enabled.
      If for example you wanted to constrain movement to the X-Z plane (so that Y cannot change), the normal would be set to X=0 Y=1 Z=0.
      This is recalculated whenever PlaneConstraintAxisSetting changes. It is normalized once the component is registered with the game world.
      see: bConstrainToPlane, SetPlaneConstraintNormal(), SetPlaneConstraintFromVectors()
    - ``plane_constraint_origin`` (Vector):  [Read-Write] The origin of the plane that constrains movement, if plane constraint is enabled.
      This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
      see: bConstrainToPlane, SetPlaneConstraintOrigin().
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``rotation_in_local_space`` (bool):  [Read-Write] Whether rotation is applied in local or world space.
    - ``rotation_rate`` (Rotator):  [Read-Write] How fast to update roll/pitch/yaw of the component we update.
    - ``snap_to_plane_at_start`` (bool):  [Read-Write] If true and plane constraints are enabled, then the updated component will be snapped to the plane when first attached.
    - ``tick_before_owner`` (bool):  [Read-Write] If true, after registration we will add a tick dependency to tick before our owner (if we can both tick).
      This is important when our tick causes an update in the owner's position, so that when the owner ticks it uses the most recent position without lag.
      Disabling this can improve performance if both objects tick but the order of ticks doesn't matter.
    - ``update_only_if_rendered`` (bool):  [Read-Write] If true, skips TickComponent() if UpdatedComponent was not recently rendered.
    - ``updated_component`` (SceneComponent):  [Read-Write] The component we move and update.
      If this is null at startup and bAutoRegisterUpdatedComponent is true, the owning Actor's root component will automatically be set as our UpdatedComponent at startup.
      see: bAutoRegisterUpdatedComponent, SetUpdatedComponent(), UpdatedPrimitive
    - ``updated_primitive`` (PrimitiveComponent):  [Read-Write] UpdatedComponent, cast as a UPrimitiveComponent. May be invalid if UpdatedComponent was null or not a UPrimitiveComponent.
    - ``velocity`` (Vector):  [Read-Write] Current velocity of updated component.
    """
    @property
    def rotation_rate(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] How fast to update roll/pitch/yaw of the component we update.
        """
        ...
    @rotation_rate.setter
    def rotation_rate(self, value: Rotator) -> None:
        ...
    @property
    def pivot_translation(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Translation of pivot point around which we rotate, relative to current rotation.
        For instance, with PivotTranslation set to (X=+100, Y=0, Z=0), rotation will occur
        around the point +100 units along the local X axis from the center of the object,
        rather than around the object's origin (the default).
        """
        ...
    @pivot_translation.setter
    def pivot_translation(self, value: Vector) -> None:
        ...
    @property
    def rotation_in_local_space(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether rotation is applied in local or world space.
        """
        ...
    @rotation_in_local_space.setter
    def rotation_in_local_space(self, value: bool) -> None:
        ...

class MovementComp_Rotating(RotatingMovementComponent):
    r"""
    deprecated: 'MovementComp_Rotating' was renamed to 'RotatingMovementComponent'.
    """
    ...

class RuntimeVirtualTextureComponent(SceneComponent):
    r"""
    Component used to place a URuntimeVirtualTexture in the world.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RuntimeVirtualTextureComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bounds_align_actor`` (Actor):  [Read-Write] Actor to align rotation to. If set this actor is always included in the bounds calculation.
    - ``build_streaming_mips_button`` (bool):  [Read-Only] Placeholder for details customization button.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_for_nanite_only`` (bool):  [Read-Write] Enable the virtual texture only when Nanite is enabled. Can be used for a Displacement virtual texture with Nanite tessellation.
    - ``enable_in_game_per_platform`` (PerPlatformBool):  [Read-Write] Per platform overrides for enabling the virtual texture. Only affects In-Game and PIE.
    - ``enable_scalability`` (bool):  [Read-Write] Set to true to enable scalability settings for the virtual texture.
    - ``expand_bounds`` (float):  [Read-Write] Amount to expand the Bounds during calculation.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hide_primitives`` (bool):  [Read-Write] Hide primitives in the main pass. Hidden primitives will be those that draw to this virtual texture with 'Draw in Main Pass' set to 'From Virtual Texture'.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied.
      For compressors that support EncodeSpeed (i.e. Oodle), this is only applied if enabled (see Project Settings -> Texture Encoding).
      Note that this is in addition to any unavoidable loss due to the target format. Selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``scalability_group`` (uint32):  [Read-Write] Group index of the scalability settings to use for the virtual texture.
    - ``set_bounds_button`` (bool):  [Read-Only] Placeholder for details customization button.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``snap_bounds_to_landscape`` (bool):  [Read-Write] If the Bounds Align Actor is a Landscape then this will snap the bounds so that virtual texture texels align with landscape vertex positions.
    - ``stream_low_mips`` (int32):  [Read-Write] Number of streaming low mips to build for the virtual texture.
    - ``streaming_mips_fixed_color`` (LinearColor):  [Read-Write] Fixed color to use when building the streaming low mips. This only affects BaseColor and Displacement attributes. The Red channel is used for fixed Displacement.
    - ``streaming_texture`` (VirtualTextureBuilder):  [Read-Write] Texture object containing streamed low mips. This can reduce rendering update cost.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_streaming_low_mips_in_editor`` (bool):  [Read-Write] Use streaming low mips when rendering in editor. Set true to view and debug the baked streaming low mips.
    - ``use_streaming_mips_fixed_color`` (bool):  [Read-Write] Build the streaming low mips using a fixed color.
    - ``virtual_texture`` (RuntimeVirtualTexture):  [Read-Write] The virtual texture object to use.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def virtual_texture(self) -> RuntimeVirtualTexture:
        r"""
        (RuntimeVirtualTexture):  [Read-Only] The virtual texture object to use.
        """
        ...
    @property
    def streaming_texture(self) -> VirtualTextureBuilder:
        r"""
        (VirtualTextureBuilder):  [Read-Only] Texture object containing streamed low mips. This can reduce rendering update cost.
        """
        ...
    @property
    def lossy_compression_amount(self) -> TextureLossyCompressionAmount:
        r"""
        (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied.
        For compressors that support EncodeSpeed (i.e. Oodle), this is only applied if enabled (see Project Settings -> Texture Encoding).
        Note that this is in addition to any unavoidable loss due to the target format. Selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
        """
        ...
    @lossy_compression_amount.setter
    def lossy_compression_amount(self, value: TextureLossyCompressionAmount) -> None:
        ...
    @property
    def use_streaming_mips_fixed_color(self) -> bool:
        r"""
        (bool):  [Read-Only] Build the streaming low mips using a fixed color.
        """
        ...
    @property
    def streaming_mips_fixed_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Fixed color to use when building the streaming low mips. This only affects BaseColor and Displacement attributes. The Red channel is used for fixed Displacement.
        """
        ...
    def invalidate(self, world_bounds: BoxSphereBounds) -> None:
        r"""
        x.invalidate(world_bounds) -> None
        This function marks an area of the runtime virtual texture as dirty.
        
        Args:
            world_bounds (BoxSphereBounds): : The world space bounds of the pages to invalidate.
        """
        ...

class SkyAtmosphere(Info):
    r"""
    A placeable actor that represents a planet atmosphere material and simulates sky and light scattering within it.
    see: https://docs.unrealengine.com/en-US/Engine/Actors/FogEffects/SkyAtmosphere/index.html
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkyAtmosphereComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``sky_atmosphere_component`` (SkyAtmosphereComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def sky_atmosphere_component(self) -> SkyAtmosphereComponent:
        r"""
        (SkyAtmosphereComponent):  [Read-Only]
        """
        ...

class SplineComponent(PrimitiveComponent):
    r"""
    A spline component is a spline shape which can be used for other purposes (e.g. animating objects). It contains debug rendering capabilities.
    see: https://docs.unrealengine.com/latest/INT/Resources/ContentExamples/Blueprint_Splines
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SplineComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``adjust_tangents_on_snap`` (bool):  [Read-Write] Adjust tangents after snapping.
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``allow_discontinuous_spline`` (bool):  [Read-Write] Whether the spline's leave and arrive tangents can be different
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``closed_loop`` (bool):  [Read-Write] Whether the spline is to be considered as a closed loop.
      Use SetClosedLoop() to set this property, and IsClosedLoop() to read it.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``default_up_vector`` (Vector):  [Read-Write] Default up vector in local space to be used when calculating transforms along the spline
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``draw_debug`` (bool):  [Read-Write] If true, the spline will be rendered if the Splines showflag is set.
    - ``duration`` (float):  [Read-Write] Specifies the duration of the spline in seconds
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``editor_selected_spline_segment_color`` (LinearColor):  [Read-Write] Color of selected spline component parts in the editor
    - ``editor_tangent_color`` (LinearColor):  [Read-Write] Color of spline point tangents in the editor
    - ``editor_unselected_spline_segment_color`` (LinearColor):  [Read-Write] Color of unselected spline component parts in the editor
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``input_spline_points_to_construction_script`` (bool):  [Read-Write] Whether the spline points should be passed to the User Construction Script so they can be further manipulated by it.
      If false, they will not be visible to it, and it will not be able to influence the per-instance positions set in the editor.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``loop_position`` (float):  [Read-Write]
    - ``loop_position_override`` (bool):  [Read-Write]
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``reparam_steps_per_segment`` (int32):  [Read-Write] Number of steps per spline segment to place in the reparameterization table
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``scale_visualization_width`` (float):  [Read-Write] Width of spline in editor for use with scale visualization
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``should_visualize_scale`` (bool):  [Read-Write] Whether scale visualization should be displayed
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``spline_curves`` (SplineCurves):  [Read-Write]
    - ``spline_has_been_edited`` (bool):  [Read-Write] Whether the spline has been edited from its default by the spline component visualizer
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``stationary_endpoints`` (bool):  [Read-Write] Whether the endpoints of the spline are considered stationary when traversing the spline at non-constant velocity.  Essentially this sets the endpoints' tangents to zero vectors.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def duration(self) -> float:
        r"""
        (float):  [Read-Write] Specifies the duration of the spline in seconds
        """
        ...
    @duration.setter
    def duration(self, value: float) -> None:
        ...
    @property
    def stationary_endpoints(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the endpoints of the spline are considered stationary when traversing the spline at non-constant velocity.  Essentially this sets the endpoints' tangents to zero vectors.
        """
        ...
    @stationary_endpoints.setter
    def stationary_endpoints(self, value: bool) -> None:
        ...
    @property
    def input_spline_points_to_construction_script(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the spline points should be passed to the User Construction Script so they can be further manipulated by it.
        If false, they will not be visible to it, and it will not be able to influence the per-instance positions set in the editor.
        """
        ...
    @input_spline_points_to_construction_script.setter
    def input_spline_points_to_construction_script(self, value: bool) -> None:
        ...
    @property
    def draw_debug(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the spline will be rendered if the Splines showflag is set.
        """
        ...
    @draw_debug.setter
    def draw_debug(self, value: bool) -> None:
        ...
    @property
    def b_always_render_in_editor(self) -> bool:
        r"""
        deprecated: 'b_always_render_in_editor' was renamed to 'draw_debug'.
        """
        ...
    @b_always_render_in_editor.setter
    def b_always_render_in_editor(self, value: bool) -> None:
        ...
    @property
    def default_up_vector(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Default up vector in local space to be used when calculating transforms along the spline
        """
        ...
    @default_up_vector.setter
    def default_up_vector(self, value: Vector) -> None:
        ...
    def update_spline(self) -> None:
        r"""
        x.update_spline() -> None
        Update the spline tangents and SplineReparamTable
        """
        ...
    def set_world_location_at_spline_point(self, point_index: int, location: Vector) -> None:
        r"""
        x.set_world_location_at_spline_point(point_index, location) -> None
        Move an existing point to a new world location
        deprecated: Please use SetLocationAtSplinePoint, specifying SplineCoordinateSpace::World
        
        Args:
            point_index (int32): 
            location (Vector):
        """
        ...
    def set_up_vector_at_spline_point(self, point_index: int, up_vector: Vector, coordinate_space: SplineCoordinateSpace, update_spline: bool = True) -> None:
        r"""
        x.set_up_vector_at_spline_point(point_index, up_vector, coordinate_space, update_spline=True) -> None
        Specify the up vector at a given spline point
        
        Args:
            point_index (int32): 
            up_vector (Vector): 
            coordinate_space (SplineCoordinateSpace): 
            update_spline (bool):
        """
        ...
    def set_unselected_spline_segment_color(self, segment_color: LinearColor) -> None:
        r"""
        x.set_unselected_spline_segment_color(segment_color) -> None
        Specify unselected spline component segment color in the editor
        
        Args:
            segment_color (LinearColor):
        """
        ...
    def set_tangents_at_spline_point(self, point_index: int, arrive_tangent: Vector, leave_tangent: Vector, coordinate_space: SplineCoordinateSpace, update_spline: bool = True) -> None:
        r"""
        x.set_tangents_at_spline_point(point_index, arrive_tangent, leave_tangent, coordinate_space, update_spline=True) -> None
        Specify the tangents at a given spline point
        
        Args:
            point_index (int32): 
            arrive_tangent (Vector): 
            leave_tangent (Vector): 
            coordinate_space (SplineCoordinateSpace): 
            update_spline (bool):
        """
        ...
    def set_tangent_color(self, tangent_color: LinearColor) -> None:
        r"""
        x.set_tangent_color(tangent_color) -> None
        Specify selected spline component segment color in the editor
        
        Args:
            tangent_color (LinearColor):
        """
        ...
    def set_tangent_at_spline_point(self, point_index: int, tangent: Vector, coordinate_space: SplineCoordinateSpace, update_spline: bool = True) -> None:
        r"""
        x.set_tangent_at_spline_point(point_index, tangent, coordinate_space, update_spline=True) -> None
        Specify the tangent at a given spline point
        
        Args:
            point_index (int32): 
            tangent (Vector): 
            coordinate_space (SplineCoordinateSpace): 
            update_spline (bool):
        """
        ...
    def set_spline_world_points(self, points: Array[Vector]) -> None:
        r"""
        x.set_spline_world_points(points) -> None
        Sets the spline to an array of world space points
        deprecated: Please use SetSplinePoints, specifying SplineCoordinateSpace::World
        
        Args:
            points (Array[Vector]):
        """
        ...
    def set_spline_point_type(self, point_index: int, type: SplinePointType, update_spline: bool = True) -> None:
        r"""
        x.set_spline_point_type(point_index, type, update_spline=True) -> None
        Specify the type of a spline point
        
        Args:
            point_index (int32): 
            type (SplinePointType): 
            update_spline (bool):
        """
        ...
    def set_spline_points(self, points: Array[Vector], coordinate_space: SplineCoordinateSpace, update_spline: bool = True) -> None:
        r"""
        x.set_spline_points(points, coordinate_space, update_spline=True) -> None
        Sets the spline to an array of points
        
        Args:
            points (Array[Vector]): 
            coordinate_space (SplineCoordinateSpace): 
            update_spline (bool):
        """
        ...
    def set_spline_local_points(self, points: Array[Vector]) -> None:
        r"""
        x.set_spline_local_points(points) -> None
        Sets the spline to an array of local space points
        deprecated: Please use SetSplinePoints, specifying SplineCoordinateSpace::Local
        
        Args:
            points (Array[Vector]):
        """
        ...
    def set_selected_spline_segment_color(self, segment_color: LinearColor) -> None:
        r"""
        x.set_selected_spline_segment_color(segment_color) -> None
        Specify selected spline component segment color in the editor
        
        Args:
            segment_color (LinearColor):
        """
        ...
    def set_scale_at_spline_point(self, point_index: int, scale_vector: Vector, update_spline: bool = True) -> None:
        r"""
        x.set_scale_at_spline_point(point_index, scale_vector, update_spline=True) -> None
        Set the scale at a given spline point
        
        Args:
            point_index (int32): 
            scale_vector (Vector): 
            update_spline (bool):
        """
        ...
    def set_rotation_at_spline_point(self, point_index: int, rotation: Rotator, coordinate_space: SplineCoordinateSpace, update_spline: bool = True) -> None:
        r"""
        x.set_rotation_at_spline_point(point_index, rotation, coordinate_space, update_spline=True) -> None
        Set the rotation of an existing spline point
        
        Args:
            point_index (int32): 
            rotation (Rotator): 
            coordinate_space (SplineCoordinateSpace): 
            update_spline (bool):
        """
        ...
    def set_location_at_spline_point(self, point_index: int, location: Vector, coordinate_space: SplineCoordinateSpace, update_spline: bool = True) -> None:
        r"""
        x.set_location_at_spline_point(point_index, location, coordinate_space, update_spline=True) -> None
        Move an existing point to a new location
        
        Args:
            point_index (int32): 
            location (Vector): 
            coordinate_space (SplineCoordinateSpace): 
            update_spline (bool):
        """
        ...
    def set_draw_debug(self, show: bool) -> None:
        r"""
        x.set_draw_debug(show) -> None
        Specify whether this spline should be rendered when the Editor/Game spline show flag is set
        
        Args:
            show (bool):
        """
        ...
    def set_default_up_vector(self, up_vector: Vector, coordinate_space: SplineCoordinateSpace) -> None:
        r"""
        x.set_default_up_vector(up_vector, coordinate_space) -> None
        Sets the default up vector used by this spline
        
        Args:
            up_vector (Vector): 
            coordinate_space (SplineCoordinateSpace):
        """
        ...
    def set_closed_loop_at_position(self, closed_loop: bool, key: float, update_spline: bool = True) -> None:
        r"""
        x.set_closed_loop_at_position(closed_loop, key, update_spline=True) -> None
        Specify whether the spline is a closed loop or not, and if so, the input key corresponding to the loop point
        
        Args:
            closed_loop (bool): 
            key (float): 
            update_spline (bool):
        """
        ...
    def set_closed_loop(self, closed_loop: bool, update_spline: bool = True) -> None:
        r"""
        x.set_closed_loop(closed_loop, update_spline=True) -> None
        Specify whether the spline is a closed loop or not. The loop position will be at 1.0 after the last point's input key
        
        Args:
            closed_loop (bool): 
            update_spline (bool):
        """
        ...
    def remove_spline_point(self, index: int, update_spline: bool = True) -> None:
        r"""
        x.remove_spline_point(index, update_spline=True) -> None
        Removes point at specified index from the spline
        
        Args:
            index (int32): 
            update_spline (bool):
        """
        ...
    def is_closed_loop(self) -> bool:
        r"""
        x.is_closed_loop() -> bool
        Check whether the spline is a closed loop or not
        
        Returns:
            bool:
        """
        ...
    def get_world_tangent_at_distance_along_spline(self, distance: float) -> Vector:
        r"""
        x.get_world_tangent_at_distance_along_spline(distance) -> Vector
        Given a distance along the length of this spline, return the tangent vector of the spline there, in world space.
        deprecated: Please use GetTangentAtDistanceAlongSpline, specifying SplineCoordinateSpace::World
        
        Args:
            distance (float): 
        
        Returns:
            Vector:
        """
        ...
    def get_world_rotation_at_time(self, time: float, use_constant_velocity: bool = False) -> Rotator:
        r"""
        x.get_world_rotation_at_time(time, use_constant_velocity=False) -> Rotator
        Given a time from 0 to the spline duration, return a rotation corresponding to the spline's position and direction there, in world space.
        deprecated: Please use GetRotationAtTime, specifying SplineCoordinateSpace::World
        
        Args:
            time (float): 
            use_constant_velocity (bool): 
        
        Returns:
            Rotator:
        """
        ...
    def get_world_rotation_at_distance_along_spline(self, distance: float) -> Rotator:
        r"""
        x.get_world_rotation_at_distance_along_spline(distance) -> Rotator
        Given a distance along the length of this spline, return a rotation corresponding to the spline's rotation there, in world space.
        deprecated: Please use GetRotationAtDistanceAlongSpline, specifying SplineCoordinateSpace::World
        
        Args:
            distance (float): 
        
        Returns:
            Rotator:
        """
        ...
    def get_world_location_at_time(self, time: float, use_constant_velocity: bool = False) -> Vector:
        r"""
        x.get_world_location_at_time(time, use_constant_velocity=False) -> Vector
        Given a time from 0 to the spline duration, return the point in space where this puts you
        deprecated: Please use GetLocationAtTime, specifying SplineCoordinateSpace::World
        
        Args:
            time (float): 
            use_constant_velocity (bool): 
        
        Returns:
            Vector:
        """
        ...
    def get_world_location_at_spline_point(self, point_index: int) -> Vector:
        r"""
        x.get_world_location_at_spline_point(point_index) -> Vector
        Get the world location at spline point
        deprecated: Please use GetLocationAtSplinePoint, specifying SplineCoordinateSpace::World
        
        Args:
            point_index (int32): 
        
        Returns:
            Vector:
        """
        ...
    def get_world_location_at_distance_along_spline(self, distance: float) -> Vector:
        r"""
        x.get_world_location_at_distance_along_spline(distance) -> Vector
        Given a distance along the length of this spline, return the point in world space where this puts you
        deprecated: Please use GetLocationAtDistanceAlongSpline, specifying SplineCoordinateSpace::World
        
        Args:
            distance (float): 
        
        Returns:
            Vector:
        """
        ...
    def get_world_direction_at_time(self, time: float, use_constant_velocity: bool = False) -> Vector:
        r"""
        x.get_world_direction_at_time(time, use_constant_velocity=False) -> Vector
        Given a time from 0 to the spline duration, return a unit direction vector of the spline tangent there.
        deprecated: Please use GetDirectionAtTime, specifying SplineCoordinateSpace::World
        
        Args:
            time (float): 
            use_constant_velocity (bool): 
        
        Returns:
            Vector:
        """
        ...
    def get_world_direction_at_distance_along_spline(self, distance: float) -> Vector:
        r"""
        x.get_world_direction_at_distance_along_spline(distance) -> Vector
        Given a distance along the length of this spline, return a unit direction vector of the spline tangent there, in world space.
        deprecated: Please use GetDirectionAtDistanceAlongSpline, specifying SplineCoordinateSpace::World
        
        Args:
            distance (float): 
        
        Returns:
            Vector:
        """
        ...
    def get_vector_property_at_spline_point(self, index: int, property_name: Name) -> Vector:
        r"""
        x.get_vector_property_at_spline_point(index, property_name) -> Vector
        Get a metadata property vector value along the spline at spline point
        
        Args:
            index (int32): 
            property_name (Name): 
        
        Returns:
            Vector:
        """
        ...
    def get_vector_property_at_spline_input_key(self, key: float, property_name: Name) -> Vector:
        r"""
        x.get_vector_property_at_spline_input_key(key, property_name) -> Vector
        Get a metadata property vector value along the spline at spline input key
        
        Args:
            key (float): 
            property_name (Name): 
        
        Returns:
            Vector:
        """
        ...
    def get_up_vector_at_time(self, time: float, coordinate_space: SplineCoordinateSpace, use_constant_velocity: bool = False) -> Vector:
        r"""
        x.get_up_vector_at_time(time, coordinate_space, use_constant_velocity=False) -> Vector
        Given a time from 0 to the spline duration, return the spline's up vector there.
        
        Args:
            time (float): 
            coordinate_space (SplineCoordinateSpace): 
            use_constant_velocity (bool): 
        
        Returns:
            Vector:
        """
        ...
    def get_up_vector_at_spline_point(self, point_index: int, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_up_vector_at_spline_point(point_index, coordinate_space) -> Vector
        Get the up vector at spline point
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_up_vector_at_spline_input_key(self, key: float, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_up_vector_at_spline_input_key(key, coordinate_space) -> Vector
        Get up vector at the provided input key value
        
        Args:
            key (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_up_vector_at_distance_along_spline(self, distance: float, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_up_vector_at_distance_along_spline(distance, coordinate_space) -> Vector
        Given a distance along the length of this spline, return a unit direction vector corresponding to the spline's up vector there.
        
        Args:
            distance (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_transform_at_time(self, time: float, coordinate_space: SplineCoordinateSpace, use_constant_velocity: bool = False, use_scale: bool = False) -> Transform:
        r"""
        x.get_transform_at_time(time, coordinate_space, use_constant_velocity=False, use_scale=False) -> Transform
        Given a time from 0 to the spline duration, return the spline's transform at the corresponding position.
        
        Args:
            time (float): 
            coordinate_space (SplineCoordinateSpace): 
            use_constant_velocity (bool): 
            use_scale (bool): 
        
        Returns:
            Transform:
        """
        ...
    def get_transform_at_spline_point(self, point_index: int, coordinate_space: SplineCoordinateSpace, use_scale: bool = False) -> Transform:
        r"""
        x.get_transform_at_spline_point(point_index, coordinate_space, use_scale=False) -> Transform
        Get the transform at spline point
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
            use_scale (bool): 
        
        Returns:
            Transform:
        """
        ...
    def get_transform_at_spline_input_key(self, key: float, coordinate_space: SplineCoordinateSpace, use_scale: bool = False) -> Transform:
        r"""
        x.get_transform_at_spline_input_key(key, coordinate_space, use_scale=False) -> Transform
        Get transform at the provided input key value
        
        Args:
            key (float): 
            coordinate_space (SplineCoordinateSpace): 
            use_scale (bool): 
        
        Returns:
            Transform:
        """
        ...
    def get_transform_at_distance_along_spline(self, distance: float, coordinate_space: SplineCoordinateSpace, use_scale: bool = False) -> Transform:
        r"""
        x.get_transform_at_distance_along_spline(distance, coordinate_space, use_scale=False) -> Transform
        Given a distance along the length of this spline, return an FTransform corresponding to that point on the spline.
        
        Args:
            distance (float): 
            coordinate_space (SplineCoordinateSpace): 
            use_scale (bool): 
        
        Returns:
            Transform:
        """
        ...
    def get_time_at_distance_along_spline(self, distance: float) -> float:
        r"""
        x.get_time_at_distance_along_spline(distance) -> float
        Given a distance along the length of this spline, return the corresponding time at that point
        
        Args:
            distance (float): 
        
        Returns:
            float:
        """
        ...
    def get_tangent_at_time(self, time: float, coordinate_space: SplineCoordinateSpace, use_constant_velocity: bool = False) -> Vector:
        r"""
        x.get_tangent_at_time(time, coordinate_space, use_constant_velocity=False) -> Vector
        Given a time from 0 to the spline duration, return the spline's tangent there.
        
        Args:
            time (float): 
            coordinate_space (SplineCoordinateSpace): 
            use_constant_velocity (bool): 
        
        Returns:
            Vector:
        """
        ...
    def get_tangent_at_spline_point(self, point_index: int, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_tangent_at_spline_point(point_index, coordinate_space) -> Vector
        Get the tangent at spline point. This fetches the Leave tangent of the point.
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_tangent_at_spline_input_key(self, key: float, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_tangent_at_spline_input_key(key, coordinate_space) -> Vector
        Get tangent along spline at the provided input key value
        
        Args:
            key (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_tangent_at_distance_along_spline(self, distance: float, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_tangent_at_distance_along_spline(distance, coordinate_space) -> Vector
        Given a distance along the length of this spline, return the tangent vector of the spline there.
        
        Args:
            distance (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_spline_point_type(self, point_index: int) -> SplinePointType:
        r"""
        x.get_spline_point_type(point_index) -> SplinePointType
        Get the type of a spline point
        
        Args:
            point_index (int32): 
        
        Returns:
            SplinePointType:
        """
        ...
    def get_spline_point_at(self, point_index: int, coordinate_space: SplineCoordinateSpace) -> SplinePoint:
        r"""
        x.get_spline_point_at(point_index, coordinate_space) -> SplinePoint
        Gets the spline point of the spline at the specified index
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            SplinePoint:
        """
        ...
    def get_spline_length(self) -> float:
        r"""
        x.get_spline_length() -> float
        Returns total length along this spline
        
        Returns:
            float:
        """
        ...
    def get_scale_at_time(self, time: float, use_constant_velocity: bool = False) -> Vector:
        r"""
        x.get_scale_at_time(time, use_constant_velocity=False) -> Vector
        Given a time from 0 to the spline duration, return the spline's scale there.
        
        Args:
            time (float): 
            use_constant_velocity (bool): 
        
        Returns:
            Vector:
        """
        ...
    def get_scale_at_spline_point(self, point_index: int) -> Vector:
        r"""
        x.get_scale_at_spline_point(point_index) -> Vector
        Get the scale at spline point
        
        Args:
            point_index (int32): 
        
        Returns:
            Vector:
        """
        ...
    def get_scale_at_spline_input_key(self, key: float) -> Vector:
        r"""
        x.get_scale_at_spline_input_key(key) -> Vector
        Get scale at the provided input key value
        
        Args:
            key (float): 
        
        Returns:
            Vector:
        """
        ...
    def get_scale_at_distance_along_spline(self, distance: float) -> Vector:
        r"""
        x.get_scale_at_distance_along_spline(distance) -> Vector
        Given a distance along the length of this spline, return the spline's scale there.
        
        Args:
            distance (float): 
        
        Returns:
            Vector:
        """
        ...
    def get_rotation_at_time(self, time: float, coordinate_space: SplineCoordinateSpace, use_constant_velocity: bool = False) -> Rotator:
        r"""
        x.get_rotation_at_time(time, coordinate_space, use_constant_velocity=False) -> Rotator
        Given a time from 0 to the spline duration, return a rotation corresponding to the spline's position and direction there.
        
        Args:
            time (float): 
            coordinate_space (SplineCoordinateSpace): 
            use_constant_velocity (bool): 
        
        Returns:
            Rotator:
        """
        ...
    def get_rotation_at_spline_point(self, point_index: int, coordinate_space: SplineCoordinateSpace) -> Rotator:
        r"""
        x.get_rotation_at_spline_point(point_index, coordinate_space) -> Rotator
        Get the rotation at spline point as a rotator
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Rotator:
        """
        ...
    def get_rotation_at_spline_input_key(self, key: float, coordinate_space: SplineCoordinateSpace) -> Rotator:
        r"""
        x.get_rotation_at_spline_input_key(key, coordinate_space) -> Rotator
        Get rotator corresponding to rotation along spline at the provided input key value
        
        Args:
            key (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Rotator:
        """
        ...
    def get_rotation_at_distance_along_spline(self, distance: float, coordinate_space: SplineCoordinateSpace) -> Rotator:
        r"""
        x.get_rotation_at_distance_along_spline(distance, coordinate_space) -> Rotator
        Given a distance along the length of this spline, return a rotation corresponding to the spline's rotation there.
        
        Args:
            distance (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Rotator:
        """
        ...
    def get_roll_at_time(self, time: float, coordinate_space: SplineCoordinateSpace, use_constant_velocity: bool = False) -> float:
        r"""
        x.get_roll_at_time(time, coordinate_space, use_constant_velocity=False) -> float
        Given a time from 0 to the spline duration, return the spline's roll there, in degrees.
        
        Args:
            time (float): 
            coordinate_space (SplineCoordinateSpace): 
            use_constant_velocity (bool): 
        
        Returns:
            float:
        """
        ...
    def get_roll_at_spline_point(self, point_index: int, coordinate_space: SplineCoordinateSpace) -> float:
        r"""
        x.get_roll_at_spline_point(point_index, coordinate_space) -> float
        Get the amount of roll at spline point, in degrees
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            float:
        """
        ...
    def get_roll_at_spline_input_key(self, key: float, coordinate_space: SplineCoordinateSpace) -> float:
        r"""
        x.get_roll_at_spline_input_key(key, coordinate_space) -> float
        Get roll in degrees at the provided input key value
        
        Args:
            key (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            float:
        """
        ...
    def get_roll_at_distance_along_spline(self, distance: float, coordinate_space: SplineCoordinateSpace) -> float:
        r"""
        x.get_roll_at_distance_along_spline(distance, coordinate_space) -> float
        Given a distance along the length of this spline, return the spline's roll there, in degrees.
        
        Args:
            distance (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            float:
        """
        ...
    def get_right_vector_at_time(self, time: float, coordinate_space: SplineCoordinateSpace, use_constant_velocity: bool = False) -> Vector:
        r"""
        x.get_right_vector_at_time(time, coordinate_space, use_constant_velocity=False) -> Vector
        Given a time from 0 to the spline duration, return the spline's right vector there.
        
        Args:
            time (float): 
            coordinate_space (SplineCoordinateSpace): 
            use_constant_velocity (bool): 
        
        Returns:
            Vector:
        """
        ...
    def get_right_vector_at_spline_point(self, point_index: int, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_right_vector_at_spline_point(point_index, coordinate_space) -> Vector
        Get the right vector at spline point
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_right_vector_at_spline_input_key(self, key: float, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_right_vector_at_spline_input_key(key, coordinate_space) -> Vector
        Get right vector at the provided input key value
        
        Args:
            key (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_right_vector_at_distance_along_spline(self, distance: float, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_right_vector_at_distance_along_spline(distance, coordinate_space) -> Vector
        Given a distance along the length of this spline, return a unit direction vector corresponding to the spline's right vector there.
        
        Args:
            distance (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_number_of_spline_segments(self) -> int:
        r"""
        x.get_number_of_spline_segments() -> int32
        Get the number of segments that make up this spline
        
        Returns:
            int32:
        """
        ...
    def get_number_of_spline_points(self) -> int:
        r"""
        x.get_number_of_spline_points() -> int32
        Get the number of points that make up this spline
        
        Returns:
            int32:
        """
        ...
    def get_num_spline_points(self) -> int:
        r"""
        deprecated: 'get_num_spline_points' was renamed to 'get_number_of_spline_points'.
        """
        ...
    def get_location_at_time(self, time: float, coordinate_space: SplineCoordinateSpace, use_constant_velocity: bool = False) -> Vector:
        r"""
        x.get_location_at_time(time, coordinate_space, use_constant_velocity=False) -> Vector
        Given a time from 0 to the spline duration, return the point in space where this puts you
        
        Args:
            time (float): 
            coordinate_space (SplineCoordinateSpace): 
            use_constant_velocity (bool): 
        
        Returns:
            Vector:
        """
        ...
    def get_location_at_spline_point(self, point_index: int, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_location_at_spline_point(point_index, coordinate_space) -> Vector
        Get the location at spline point
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_location_at_spline_input_key(self, key: float, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_location_at_spline_input_key(key, coordinate_space) -> Vector
        Get location along spline at the provided input key value
        
        Args:
            key (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_location_at_distance_along_spline(self, distance: float, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_location_at_distance_along_spline(distance, coordinate_space) -> Vector
        Given a distance along the length of this spline, return the point in space where this puts you
        
        Args:
            distance (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_location_and_tangent_at_spline_point(self, point_index: int, coordinate_space: SplineCoordinateSpace) -> Tuple[Vector, Vector]:
        r"""
        x.get_location_and_tangent_at_spline_point(point_index, coordinate_space) -> (location=Vector, tangent=Vector)
        Get location and tangent at a spline point
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            tuple: 
        
            location (Vector): 
        
            tangent (Vector):
        """
        ...
    def get_local_location_and_tangent_at_spline_point(self, point_index: int) -> Tuple[Vector, Vector]:
        r"""
        x.get_local_location_and_tangent_at_spline_point(point_index) -> (local_location=Vector, local_tangent=Vector)
        Get local location and tangent at a spline point
        deprecated: Please use GetLocationAndTangentAtSplinePoint, specifying SplineCoordinateSpace::Local
        
        Args:
            point_index (int32): 
        
        Returns:
            tuple: 
        
            local_location (Vector): 
        
            local_tangent (Vector):
        """
        ...
    def get_leave_tangent_at_spline_point(self, point_index: int, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_leave_tangent_at_spline_point(point_index, coordinate_space) -> Vector
        Get the leave tangent at spline point
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_input_key_value_at_spline_point(self, point_index: int) -> float:
        r"""
        x.get_input_key_value_at_spline_point(point_index) -> float
        Get the input key (e.g. the time) of the control point of the spline at the specified index.
        
        Args:
            point_index (int32): 
        
        Returns:
            float:
        """
        ...
    def get_input_key_value_at_distance_along_spline(self, distance: float) -> float:
        r"""
        x.get_input_key_value_at_distance_along_spline(distance) -> float
        Given a distance along the length of this spline, return the corresponding input key at that point
        with a fractional component between the current input key and the next as a percentage.
        
        Args:
            distance (float): 
        
        Returns:
            float:
        """
        ...
    def get_input_key_at_distance_along_spline(self, distance: float) -> float:
        r"""
        x.get_input_key_at_distance_along_spline(distance) -> float
        This method has been deprecated because it was incorrectly returning the input key at time. To maintain the same behavior,
        replace it with GetTimeAtDistanceAlongSpline. To actually get the input key, instead call GetInputKeyValueAtDistanceAlongSpline.
        deprecated: Please use GetInputKeyValueAtDistanceAlongSpline to get input key at distance or GetTimeAtDistanceAlongSpline to get time value (normalized to duration) at distance (same logic as deprecated function).
        
        Args:
            distance (float): 
        
        Returns:
            float:
        """
        ...
    def get_float_property_at_spline_point(self, index: int, property_name: Name) -> float:
        r"""
        x.get_float_property_at_spline_point(index, property_name) -> float
        Get a metadata property float value along the spline at spline point
        
        Args:
            index (int32): 
            property_name (Name): 
        
        Returns:
            float:
        """
        ...
    def get_float_property_at_spline_input_key(self, key: float, property_name: Name) -> float:
        r"""
        x.get_float_property_at_spline_input_key(key, property_name) -> float
        Get a metadata property float value along the spline at spline input key
        
        Args:
            key (float): 
            property_name (Name): 
        
        Returns:
            float:
        """
        ...
    def get_distance_along_spline_at_spline_point(self, point_index: int) -> float:
        r"""
        x.get_distance_along_spline_at_spline_point(point_index) -> float
        Get the distance along the spline at the spline point
        
        Args:
            point_index (int32): 
        
        Returns:
            float:
        """
        ...
    def get_distance_along_spline_at_spline_input_key(self, key: float) -> float:
        r"""
        x.get_distance_along_spline_at_spline_input_key(key) -> float
        Get distance along the spline at the provided input key value
        
        Args:
            key (float): 
        
        Returns:
            float:
        """
        ...
    def get_distance_along_spline_at_location(self, location: Vector, coordinate_space: SplineCoordinateSpace) -> float:
        r"""
        x.get_distance_along_spline_at_location(location, coordinate_space) -> float
        Get distance along the spline at closest point of the provided input location
        
        Args:
            location (Vector): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            float:
        """
        ...
    def get_direction_at_time(self, time: float, coordinate_space: SplineCoordinateSpace, use_constant_velocity: bool = False) -> Vector:
        r"""
        x.get_direction_at_time(time, coordinate_space, use_constant_velocity=False) -> Vector
        Given a time from 0 to the spline duration, return a unit direction vector of the spline tangent there.
        
        Args:
            time (float): 
            coordinate_space (SplineCoordinateSpace): 
            use_constant_velocity (bool): 
        
        Returns:
            Vector:
        """
        ...
    def get_direction_at_spline_point(self, point_index: int, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_direction_at_spline_point(point_index, coordinate_space) -> Vector
        Get the direction at spline point
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_direction_at_spline_input_key(self, key: float, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_direction_at_spline_input_key(key, coordinate_space) -> Vector
        Get unit direction along spline at the provided input key value
        
        Args:
            key (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_direction_at_distance_along_spline(self, distance: float, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_direction_at_distance_along_spline(distance, coordinate_space) -> Vector
        Given a distance along the length of this spline, return a unit direction vector of the spline tangent there.
        
        Args:
            distance (float): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_default_up_vector(self, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_default_up_vector(coordinate_space) -> Vector
        Gets the default up vector used by this spline
        
        Args:
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def get_arrive_tangent_at_spline_point(self, point_index: int, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.get_arrive_tangent_at_spline_point(point_index, coordinate_space) -> Vector
        Get the arrive tangent at spline point
        
        Args:
            point_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def find_up_vector_closest_to_world_location(self, world_location: Vector, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.find_up_vector_closest_to_world_location(world_location, coordinate_space) -> Vector
        Given a location, in world space, return a unit direction vector corresponding to the spline's up vector closest to the location.
        
        Args:
            world_location (Vector): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def find_transform_closest_to_world_location(self, world_location: Vector, coordinate_space: SplineCoordinateSpace, use_scale: bool = False) -> Transform:
        r"""
        x.find_transform_closest_to_world_location(world_location, coordinate_space, use_scale=False) -> Transform
        Given a location, in world space, return an FTransform closest to that location.
        
        Args:
            world_location (Vector): 
            coordinate_space (SplineCoordinateSpace): 
            use_scale (bool): 
        
        Returns:
            Transform:
        """
        ...
    def find_tangent_closest_to_world_location(self, world_location: Vector, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.find_tangent_closest_to_world_location(world_location, coordinate_space) -> Vector
        Given a location, in world space, return the tangent vector of the spline closest to the location.
        
        Args:
            world_location (Vector): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def find_scale_closest_to_world_location(self, world_location: Vector) -> Vector:
        r"""
        x.find_scale_closest_to_world_location(world_location) -> Vector
        Given a location, in world space, return the spline's scale closest to the location.
        
        Args:
            world_location (Vector): 
        
        Returns:
            Vector:
        """
        ...
    def find_rotation_closest_to_world_location(self, world_location: Vector, coordinate_space: SplineCoordinateSpace) -> Rotator:
        r"""
        x.find_rotation_closest_to_world_location(world_location, coordinate_space) -> Rotator
        Given a location, in world space, return rotation corresponding to the spline's rotation closest to the location.
        
        Args:
            world_location (Vector): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Rotator:
        """
        ...
    def find_roll_closest_to_world_location(self, world_location: Vector, coordinate_space: SplineCoordinateSpace) -> float:
        r"""
        x.find_roll_closest_to_world_location(world_location, coordinate_space) -> float
        Given a location, in world space, return the spline's roll closest to the location, in degrees.
        
        Args:
            world_location (Vector): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            float:
        """
        ...
    def find_right_vector_closest_to_world_location(self, world_location: Vector, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.find_right_vector_closest_to_world_location(world_location, coordinate_space) -> Vector
        Given a location, in world space, return a unit direction vector corresponding to the spline's right vector closest to the location.
        
        Args:
            world_location (Vector): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def find_location_closest_to_world_location(self, world_location: Vector, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.find_location_closest_to_world_location(world_location, coordinate_space) -> Vector
        Given a location, in world space, return the point on the curve that is closest to the location.
        
        Args:
            world_location (Vector): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def find_input_key_closest_to_world_location(self, world_location: Vector) -> float:
        r"""
        x.find_input_key_closest_to_world_location(world_location) -> float
        Given a location, in world space, return the input key closest to that location.
        
        Args:
            world_location (Vector): 
        
        Returns:
            float:
        """
        ...
    def find_direction_closest_to_world_location(self, world_location: Vector, coordinate_space: SplineCoordinateSpace) -> Vector:
        r"""
        x.find_direction_closest_to_world_location(world_location, coordinate_space) -> Vector
        Given a location, in world space, return a unit direction vector of the spline tangent closest to the location.
        
        Args:
            world_location (Vector): 
            coordinate_space (SplineCoordinateSpace): 
        
        Returns:
            Vector:
        """
        ...
    def divide_spline_into_polyline_recursive_with_distances(self, start_distance_along_spline: float, end_distance_along_spline: float, coordinate_space: SplineCoordinateSpace, max_square_distance_from_spline: float) -> Optional[Tuple[Array[Vector], Array[float]]]:
        r"""
        x.divide_spline_into_polyline_recursive_with_distances(start_distance_along_spline, end_distance_along_spline, coordinate_space, max_square_distance_from_spline) -> (out_points=Array[Vector], out_distances_along_spline=Array[double]) or None
        Given a threshold, recursively sub-divides the spline section until the list of segments (polyline) matches the spline shape. Note: Prefer ConvertSplineToPolyline_InDistanceRange
        
        Args:
            start_distance_along_spline (float): 
            end_distance_along_spline (float): 
            coordinate_space (SplineCoordinateSpace): 
            max_square_distance_from_spline (float): 
        
        Returns:
            tuple or None: 
        
            out_points (Array[Vector]): 
        
            out_distances_along_spline (Array[double]):
        """
        ...
    def divide_spline_into_polyline_recursive(self, start_distance_along_spline: float, end_distance_along_spline: float, coordinate_space: SplineCoordinateSpace, max_square_distance_from_spline: float) -> Optional[Array[Vector]]:
        r"""
        x.divide_spline_into_polyline_recursive(start_distance_along_spline, end_distance_along_spline, coordinate_space, max_square_distance_from_spline) -> Array[Vector] or None
        Given a threshold, recursively sub-divides the spline section until the list of segments (polyline) matches the spline shape. Note: Prefer ConvertSplineToPolyline_InDistanceRange
        
        Args:
            start_distance_along_spline (float): 
            end_distance_along_spline (float): 
            coordinate_space (SplineCoordinateSpace): 
            max_square_distance_from_spline (float): 
        
        Returns:
            Array[Vector] or None: 
        
            out_points (Array[Vector]):
        """
        ...
    def convert_spline_to_poly_line_with_distances(self, coordinate_space: SplineCoordinateSpace, max_square_distance_from_spline: float) -> Optional[Tuple[Array[Vector], Array[float]]]:
        r"""
        x.convert_spline_to_poly_line_with_distances(coordinate_space, max_square_distance_from_spline) -> (out_points=Array[Vector], out_distances_along_spline=Array[double]) or None
        Given a threshold, returns a list of vertices along the spline that, treated as a list of segments (polyline), matches the spline shape. Also fills a list of corresponding distances along the spline for each point.
        
        Args:
            coordinate_space (SplineCoordinateSpace): 
            max_square_distance_from_spline (float): 
        
        Returns:
            tuple or None: 
        
            out_points (Array[Vector]): 
        
            out_distances_along_spline (Array[double]):
        """
        ...
    def convert_spline_to_polyline_in_time_range(self, coordinate_space: SplineCoordinateSpace, max_square_distance_from_spline: float, start_time_along_spline: float, end_time_along_spline: float, use_constant_velocity: bool, allow_wrapping_if_closed: bool = True) -> Optional[Tuple[Array[Vector], Array[float]]]:
        r"""
        x.convert_spline_to_polyline_in_time_range(coordinate_space, max_square_distance_from_spline, start_time_along_spline, end_time_along_spline, use_constant_velocity, allow_wrapping_if_closed=True) -> (out_points=Array[Vector], out_distances_along_spline=Array[double]) or None
        Given a threshold and start and end time range, returns a list of vertices along the spline that, treated as a list of segments (polyline), matches the spline shape in that range. Also fills a list of corresponding distances along the spline for each point.
        
        Args:
            coordinate_space (SplineCoordinateSpace): 
            max_square_distance_from_spline (float): 
            start_time_along_spline (float): 
            end_time_along_spline (float): 
            use_constant_velocity (bool): 
            allow_wrapping_if_closed (bool): 
        
        Returns:
            tuple or None: 
        
            out_points (Array[Vector]): 
        
            out_distances_along_spline (Array[double]):
        """
        ...
    def convert_spline_to_polyline_in_distance_range(self, coordinate_space: SplineCoordinateSpace, max_square_distance_from_spline: float, start_dist_along_spline: float, end_dist_along_spline: float, allow_wrapping_if_closed: bool = True) -> Optional[Tuple[Array[Vector], Array[float]]]:
        r"""
        x.convert_spline_to_polyline_in_distance_range(coordinate_space, max_square_distance_from_spline, start_dist_along_spline, end_dist_along_spline, allow_wrapping_if_closed=True) -> (out_points=Array[Vector], out_distances_along_spline=Array[double]) or None
        Given a threshold and a start and end distance range, returns a list of vertices along the spline that, treated as a list of segments (polyline), matches the spline shape in that range. Also fills a list of corresponding distances along the spline for each point.
        
        Args:
            coordinate_space (SplineCoordinateSpace): 
            max_square_distance_from_spline (float): 
            start_dist_along_spline (float): 
            end_dist_along_spline (float): 
            allow_wrapping_if_closed (bool): 
        
        Returns:
            tuple or None: 
        
            out_points (Array[Vector]): 
        
            out_distances_along_spline (Array[double]):
        """
        ...
    def convert_spline_to_poly_line(self, coordinate_space: SplineCoordinateSpace, max_square_distance_from_spline: float) -> Optional[Array[Vector]]:
        r"""
        x.convert_spline_to_poly_line(coordinate_space, max_square_distance_from_spline) -> Array[Vector] or None
        Given a threshold, returns a list of vertices along the spline that, treated as a list of segments (polyline), matches the spline shape.
        
        Args:
            coordinate_space (SplineCoordinateSpace): 
            max_square_distance_from_spline (float): 
        
        Returns:
            Array[Vector] or None: 
        
            out_points (Array[Vector]):
        """
        ...
    def convert_spline_segment_to_poly_line(self, spline_point_start_index: int, coordinate_space: SplineCoordinateSpace, max_square_distance_from_spline: float) -> Optional[Array[Vector]]:
        r"""
        x.convert_spline_segment_to_poly_line(spline_point_start_index, coordinate_space, max_square_distance_from_spline) -> Array[Vector] or None
        Given a threshold, returns a list of vertices along the spline segment that, treated as a list of segments (polyline), matches the spline shape.
        
        Args:
            spline_point_start_index (int32): 
            coordinate_space (SplineCoordinateSpace): 
            max_square_distance_from_spline (float): 
        
        Returns:
            Array[Vector] or None: 
        
            out_points (Array[Vector]):
        """
        ...
    def clear_spline_points(self, update_spline: bool = True) -> None:
        r"""
        x.clear_spline_points(update_spline=True) -> None
        Clears all the points in the spline
        
        Args:
            update_spline (bool):
        """
        ...
    def add_spline_world_point(self, position: Vector) -> None:
        r"""
        x.add_spline_world_point(position) -> None
        Adds a world space point to the spline
        deprecated: Please use AddSplinePoint, specifying SplineCoordinateSpace::World
        
        Args:
            position (Vector):
        """
        ...
    def add_spline_point_at_index(self, position: Vector, index: int, coordinate_space: SplineCoordinateSpace, update_spline: bool = True) -> None:
        r"""
        x.add_spline_point_at_index(position, index, coordinate_space, update_spline=True) -> None
        Adds a point to the spline at the specified index
        
        Args:
            position (Vector): 
            index (int32): 
            coordinate_space (SplineCoordinateSpace): 
            update_spline (bool):
        """
        ...
    def add_spline_point(self, position: Vector, coordinate_space: SplineCoordinateSpace, update_spline: bool = True) -> None:
        r"""
        x.add_spline_point(position, coordinate_space, update_spline=True) -> None
        Adds a point to the spline
        
        Args:
            position (Vector): 
            coordinate_space (SplineCoordinateSpace): 
            update_spline (bool):
        """
        ...
    def add_spline_local_point(self, position: Vector) -> None:
        r"""
        x.add_spline_local_point(position) -> None
        Adds a local space point to the spline
        deprecated: Please use AddSplinePoint, specifying SplineCoordinateSpace::Local
        
        Args:
            position (Vector):
        """
        ...
    def add_points(self, points: Array[SplinePoint], update_spline: bool = True) -> None:
        r"""
        x.add_points(points, update_spline=True) -> None
        Adds an array of FSplinePoints to the spline.
        
        Args:
            points (Array[SplinePoint]): 
            update_spline (bool):
        """
        ...
    def add_point(self, point: SplinePoint, update_spline: bool = True) -> None:
        r"""
        x.add_point(point, update_spline=True) -> None
        Adds an FSplinePoint to the spline. This contains its input key, position, tangent, rotation and scale.
        
        Args:
            point (SplinePoint): 
            update_spline (bool):
        """
        ...

class SplineMeshComponent(StaticMeshComponent):
    r"""
    A Spline Mesh Component is a derivation of a Static Mesh Component which can be deformed using a spline. Only a start and end position (and tangent) can be specified.
    see: https://docs.unrealengine.com/latest/INT/Resources/ContentExamples/Blueprint_Splines
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SplineMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``allow_spline_editing_per_instance`` (bool):  [Read-Write] If true, spline mesh properties - StartPos, EndPos, StartTangent and EndTangent- may be edited per instance in the level viewport. Otherwise, the spline mesh should be initialized in the construction script.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``forward_axis`` (SplineMeshAxis):  [Read-Write] Chooses the forward axis for the spline mesh orientation
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``never_needs_cooked_collision_data`` (bool):  [Read-Write] TODO Chaos this is to opt out of CreatePhysicsMeshes for certain meshes
      Better long term mesh is to not call CreatePhysicsMeshes until it is known there is a mesh instance that needs it.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``smooth_interp_roll_scale`` (bool):  [Read-Write] If true, will use smooth interpolation (ease in/out) for Scale, Roll, and Offset along this section of spline. If false, uses linear
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``spline_boundary_max`` (float):  [Read-Write] Maximum coordinate along the spline forward axis which corresponds to end of spline. If set to 0.0, will use bounding box to determine bounds
    - ``spline_boundary_min`` (float):  [Read-Write] Minimum coordinate along the spline forward axis which corresponds to start of spline. If set to 0.0, will use bounding box to determine bounds
    - ``spline_params`` (SplineMeshParams):  [Read-Write] Spline that is used to deform mesh
    - ``spline_up_dir`` (Vector):  [Read-Write] Axis (in component space) that is used to determine X axis for co-ordinates along spline
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    def update_mesh(self) -> None:
        r"""
        x.update_mesh() -> None
        Update the collision and render state on the spline mesh following changes to its geometry
        """
        ...
    def set_start_tangent(self, start_tangent: Vector, update_mesh: bool = True) -> None:
        r"""
        x.set_start_tangent(start_tangent, update_mesh=True) -> None
        Set the start tangent vector of spline in local space
        
        Args:
            start_tangent (Vector): 
            update_mesh (bool):
        """
        ...
    def set_start_scale(self, start_scale: Vector2D = [1.000000, 1.000000], update_mesh: bool = True) -> None:
        r"""
        x.set_start_scale(start_scale=[1.000000, 1.000000], update_mesh=True) -> None
        Set the start scaling
        
        Args:
            start_scale (Vector2D): 
            update_mesh (bool):
        """
        ...
    def set_start_roll_degrees(self, start_roll_degrees: float, update_mesh: bool = True) -> None:
        r"""
        x.set_start_roll_degrees(start_roll_degrees, update_mesh=True) -> None
        Set the start roll in degrees
        
        Args:
            start_roll_degrees (float): 
            update_mesh (bool):
        """
        ...
    def set_start_roll(self, start_roll: float, update_mesh: bool = True) -> None:
        r"""
        x.set_start_roll(start_roll, update_mesh=True) -> None
        Set the start roll, in radians
        
        Args:
            start_roll (float): 
            update_mesh (bool):
        """
        ...
    def set_start_position(self, start_pos: Vector, update_mesh: bool = True) -> None:
        r"""
        x.set_start_position(start_pos, update_mesh=True) -> None
        Set the start position of spline in local space
        
        Args:
            start_pos (Vector): 
            update_mesh (bool):
        """
        ...
    def set_start_offset(self, start_offset: Vector2D, update_mesh: bool = True) -> None:
        r"""
        x.set_start_offset(start_offset, update_mesh=True) -> None
        Set the start offset
        
        Args:
            start_offset (Vector2D): 
            update_mesh (bool):
        """
        ...
    def set_start_and_end(self, start_pos: Vector, start_tangent: Vector, end_pos: Vector, end_tangent: Vector, update_mesh: bool = True) -> None:
        r"""
        x.set_start_and_end(start_pos, start_tangent, end_pos, end_tangent, update_mesh=True) -> None
        Set the start and end, position and tangent, all in local space
        
        Args:
            start_pos (Vector): 
            start_tangent (Vector): 
            end_pos (Vector): 
            end_tangent (Vector): 
            update_mesh (bool):
        """
        ...
    def set_spline_up_dir(self, spline_up_dir: Vector, update_mesh: bool = True) -> None:
        r"""
        x.set_spline_up_dir(spline_up_dir, update_mesh=True) -> None
        Set the spline up direction
        
        Args:
            spline_up_dir (Vector): 
            update_mesh (bool):
        """
        ...
    def set_forward_axis(self, forward_axis: SplineMeshAxis, update_mesh: bool = True) -> None:
        r"""
        x.set_forward_axis(forward_axis, update_mesh=True) -> None
        Set the forward axis
        
        Args:
            forward_axis (SplineMeshAxis): 
            update_mesh (bool):
        """
        ...
    def set_end_tangent(self, end_tangent: Vector, update_mesh: bool = True) -> None:
        r"""
        x.set_end_tangent(end_tangent, update_mesh=True) -> None
        Set the end tangent vector of spline in local space
        
        Args:
            end_tangent (Vector): 
            update_mesh (bool):
        """
        ...
    def set_end_scale(self, end_scale: Vector2D = [1.000000, 1.000000], update_mesh: bool = True) -> None:
        r"""
        x.set_end_scale(end_scale=[1.000000, 1.000000], update_mesh=True) -> None
        Set the end scaling
        
        Args:
            end_scale (Vector2D): 
            update_mesh (bool):
        """
        ...
    def set_end_roll_degrees(self, end_roll_degrees: float, update_mesh: bool = True) -> None:
        r"""
        x.set_end_roll_degrees(end_roll_degrees, update_mesh=True) -> None
        Set the end roll in degrees
        
        Args:
            end_roll_degrees (float): 
            update_mesh (bool):
        """
        ...
    def set_end_roll(self, end_roll: float, update_mesh: bool = True) -> None:
        r"""
        x.set_end_roll(end_roll, update_mesh=True) -> None
        Set the end roll, in radians
        
        Args:
            end_roll (float): 
            update_mesh (bool):
        """
        ...
    def set_end_position(self, end_pos: Vector, update_mesh: bool = True) -> None:
        r"""
        x.set_end_position(end_pos, update_mesh=True) -> None
        Set the end position of spline in local space
        
        Args:
            end_pos (Vector): 
            update_mesh (bool):
        """
        ...
    def set_end_offset(self, end_offset: Vector2D, update_mesh: bool = True) -> None:
        r"""
        x.set_end_offset(end_offset, update_mesh=True) -> None
        Set the end offset
        
        Args:
            end_offset (Vector2D): 
            update_mesh (bool):
        """
        ...
    def set_boundary_min(self, boundary_min: float, update_mesh: bool = True) -> None:
        r"""
        x.set_boundary_min(boundary_min, update_mesh=True) -> None
        Set the boundary min
        
        Args:
            boundary_min (float): 
            update_mesh (bool):
        """
        ...
    def set_boundary_max(self, boundary_max: float, update_mesh: bool = True) -> None:
        r"""
        x.set_boundary_max(boundary_max, update_mesh=True) -> None
        Set the boundary max
        
        Args:
            boundary_max (float): 
            update_mesh (bool):
        """
        ...
    def get_start_tangent(self) -> Vector:
        r"""
        x.get_start_tangent() -> Vector
        Get the start tangent vector of spline in local space
        
        Returns:
            Vector:
        """
        ...
    def get_start_scale(self) -> Vector2D:
        r"""
        x.get_start_scale() -> Vector2D
        Get the start scaling
        
        Returns:
            Vector2D:
        """
        ...
    def get_start_roll(self) -> float:
        r"""
        x.get_start_roll() -> float
        Get the start roll, in radians
        
        Returns:
            float:
        """
        ...
    def get_start_position(self) -> Vector:
        r"""
        x.get_start_position() -> Vector
        Get the start position of spline in local space
        
        Returns:
            Vector:
        """
        ...
    def get_start_offset(self) -> Vector2D:
        r"""
        x.get_start_offset() -> Vector2D
        Get the start offset
        
        Returns:
            Vector2D:
        """
        ...
    def get_spline_up_dir(self) -> Vector:
        r"""
        x.get_spline_up_dir() -> Vector
        Get the spline up direction
        
        Returns:
            Vector:
        """
        ...
    def get_forward_axis(self) -> SplineMeshAxis:
        r"""
        x.get_forward_axis() -> SplineMeshAxis
        Get the forward axis
        
        Returns:
            SplineMeshAxis:
        """
        ...
    def get_end_tangent(self) -> Vector:
        r"""
        x.get_end_tangent() -> Vector
        Get the end tangent vector of spline in local space
        
        Returns:
            Vector:
        """
        ...
    def get_end_scale(self) -> Vector2D:
        r"""
        x.get_end_scale() -> Vector2D
        Get the end scaling
        
        Returns:
            Vector2D:
        """
        ...
    def get_end_roll(self) -> float:
        r"""
        x.get_end_roll() -> float
        Get the end roll, in radians
        
        Returns:
            float:
        """
        ...
    def get_end_position(self) -> Vector:
        r"""
        x.get_end_position() -> Vector
        Get the end position of spline in local space
        
        Returns:
            Vector:
        """
        ...
    def get_end_offset(self) -> Vector2D:
        r"""
        x.get_end_offset() -> Vector2D
        Get the end offset
        
        Returns:
            Vector2D:
        """
        ...
    def get_boundary_min(self) -> float:
        r"""
        x.get_boundary_min() -> float
        Get the boundary min
        
        Returns:
            float:
        """
        ...
    def get_boundary_max(self) -> float:
        r"""
        x.get_boundary_max() -> float
        Get the boundary max
        
        Returns:
            float:
        """
        ...

class SpotLightComponent(PointLightComponent):
    r"""
    A spot light component emits a directional cone shaped light (Eg a Torch).
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SpotLightComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_global_illumination`` (bool):  [Read-Write] Whether the light affects global illumination, when ray-traced global illumination is enabled.
    - ``affect_reflection`` (bool):  [Read-Write] Whether the light affects objects in reflections, when ray-traced reflection is enabled.
    - ``affect_translucent_lighting`` (bool):  [Read-Write] Whether the light affects translucency or not.  Disabling this can save GPU time when there are many small lights.
    - ``affects_world`` (bool):  [Read-Write] Whether the light can affect the world, or whether it is disabled.
      A disabled light will not contribute to the scene in any way.  This setting cannot be changed at runtime and unbuilds lighting when changed.
      Setting this to false has the same effect as deleting the light, so it is useful for non-destructive experiments.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_radius`` (float):  [Read-Write] Bounds the light's visible influence.
      This clamping of the light's influence is not physically correct but very important for performance, larger lights cost more.
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bloom_max_brightness`` (float):  [Read-Write] After exposure is applied, scene color brightness larger than BloomMaxBrightness will be rescaled down to BloomMaxBrightness.
    - ``bloom_scale`` (float):  [Read-Write] Scales the additive color.
    - ``bloom_threshold`` (float):  [Read-Write] Scene color must be larger than this to create bloom in the light shafts.
    - ``bloom_tint`` (Color):  [Read-Write] Multiplies against scene color to create the bloom color.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_deep_shadow`` (bool):  [Read-Write] Whether the light should cast high quality hair-strands self-shadowing. When this option is enabled, an extra GPU cost for this light.
    - ``cast_dynamic_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from dynamic objects.  Also requires Cast Shadows to be set to True.
    - ``cast_raytraced_shadow`` (CastRayTracedShadow):  [Read-Write]
    - ``cast_shadows`` (bool):  [Read-Write] Whether the light should cast any shadows.
    - ``cast_shadows_from_cinematic_objects_only`` (bool):  [Read-Write] Whether the light should only cast shadows from components marked as bCastCinematicShadows.
      This is useful for setting up cinematic Movable spotlights aimed at characters and avoiding the shadow depth rendering costs of the background.
      Note: this only works with dynamic shadow maps, not with static shadowing or Ray Traced Distance Field shadows.
    - ``cast_static_shadows`` (bool):  [Read-Write] Whether the light should cast shadows from static objects.  Also requires Cast Shadows to be set to True.
    - ``cast_translucent_shadows`` (bool):  [Read-Write] Whether the light is allowed to cast dynamic shadows from translucency.
    - ``cast_volumetric_shadow`` (bool):  [Read-Write] Whether the light shadows volumetric fog.  Disabling this can save GPU time.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``contact_shadow_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" enabled. 0 = no shadow, 1 (default) = fully shadowed.
    - ``contact_shadow_length`` (float):  [Read-Write] Length of screen space ray trace for sharp contact shadows. Zero is disabled.
    - ``contact_shadow_length_in_ws`` (bool):  [Read-Write] Where Length of screen space ray trace for sharp contact shadows is in world space units or in screen space units.
    - ``contact_shadow_non_casting_intensity`` (float):  [Read-Write] Intensity of the shadows cast by primitives with "cast contact shadow" disabled. 0 (default) = no shadow, 1 = fully shadowed.
    - ``deep_shadow_layer_distribution`` (float):  [Read-Write] Change the deep shadow layers distribution 0:linear distribution (uniform layer distribution), 1:exponential (more details on near small details).
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disabled_brightness`` (float):  [Read-Write] Brightness factor applied to the light when the light function is specified but disabled, for example in scene captures that use SceneCapView_LitNoShadows.
      This should be set to the average brightness of the light function material's emissive input, which should be between 0 and 1.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_light_shaft_bloom`` (bool):  [Read-Write] Whether to render light shaft bloom from this light.
      For directional lights, the color around the light direction will be blurred radially and added back to the scene.
      for point lights, the color on pixels closer than the light's SourceRadius will be blurred radially and added back to the scene.
    - ``force_cached_shadows_for_movable_primitives`` (bool):  [Read-Write] Enables cached shadows for movable primitives for this light even if r.shadow.cachedshadowscastfrommovableprimitives is 0
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``ies_brightness_scale`` (float):  [Read-Write] Global scale for IES brightness contribution. Only available when "Use IES Brightness" is selected, and a valid IES profile texture is set
    - ``ies_texture`` (TextureLightProfile):  [Read-Write] IES texture (light profiles from real world measured data)
    - ``indirect_lighting_intensity`` (float):  [Read-Write] Scales the indirect lighting contribution from this light.
      A value of 0 disables any GI from this light. Default is 1.
    - ``inner_cone_angle`` (float):  [Read-Write] Degrees.
    - ``intensity`` (float):  [Read-Write] Total energy that the light emits.
    - ``intensity_units`` (LightUnits):  [Read-Write] Units used for the intensity.
      The peak luminous intensity is measured in candelas,
      while the luminous power is measured in lumens.
    - ``inverse_exposure_blend`` (float):  [Read-Write] Blend Factor used to blend between Intensity and Intensity/Exposure.
      This is useful for gameplay lights that should have constant brighness on screen independent of current exposure.
      This feature can cause issues with exposure particularly when used on the primary light on a scene, as such it's usage should be limited.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``light_color`` (Color):  [Read-Write] Filter color of the light.
      Note that this can change the light's effective intensity.
    - ``light_falloff_exponent`` (float):  [Read-Write] Controls the radial falloff of the light when UseInverseSquaredFalloff is disabled.
      2 is almost linear and very unrealistic and around 8 it looks reasonable.
      With large exponents, the light has contribution to only a small area of its influence radius but still costs the same as low exponents.
    - ``light_function_fade_distance`` (float):  [Read-Write] Distance at which the light function should be completely faded to DisabledBrightness.
      This is useful for hiding aliasing from light functions applied in the distance.
    - ``light_function_material`` (MaterialInterface):  [Read-Write] The light function material to be applied to this light.
      Note that only non-lightmapped lights (UseDirectLightMap=False) can have a light function.
      Light functions are supported within VolumetricFog, but only for Directional, Point and Spot lights. Rect lights are not supported.
    - ``light_function_scale`` (Vector):  [Read-Write] Scales the light function projection.  X and Y scale in the directions perpendicular to the light's direction, Z scales along the light direction.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this light should affect.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmass_settings`` (LightmassPointLightSettings):  [Read-Write] The Lightmass settings for this object.
    - ``max_distance_fade_range`` (float):  [Read-Write]
    - ``max_draw_distance`` (float):  [Read-Write]
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``outer_cone_angle`` (float):  [Read-Write] Degrees.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_start_offset_depth_scale`` (float):  [Read-Write] Controls how large of an offset ray traced shadows have from the receiving surface as the camera gets further away.
      This can be useful to hide self-shadowing artifacts from low resolution distance fields on huge static meshes.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``samples_per_pixel`` (int32):  [Read-Write] Samples per pixel for ray tracing
    - ``shadow_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``shadow_resolution_scale`` (float):  [Read-Write] Scales the resolution of shadowmaps used to shadow this light.  By default shadowmap resolution is chosen based on screen size of the caster.
      Setting the scale to zero disables shadow maps, but does not disable, e.g., contact shadows.
      Note: shadowmap resolution is still clamped by 'r.Shadow.MaxResolution'
    - ``shadow_sharpen`` (float):  [Read-Write] Amount to sharpen shadow filtering
    - ``shadow_slope_bias`` (float):  [Read-Write] Controls how accurate self shadowing of whole scene shadows from this light are. This works in addition to shadow bias, by increasing the
      amount of bias depending on the slope of a surface.
      At 0, shadows will start at the their caster surface, but there will be many self shadowing artifacts.
      larger values, shadows will start further from their caster, and there won't be self shadowing artifacts but object might appear to fly.
      around 0.5 seems to be a good tradeoff. This also affects the soft transition of shadows
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``soft_source_radius`` (float):  [Read-Write] Soft radius of light source shape.
      Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
    - ``source_length`` (float):  [Read-Write] Length of light source shape.
      Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
    - ``source_radius`` (float):  [Read-Write] Radius of light source shape.
      Note that light sources shapes which intersect shadow casting geometry can cause shadowing artifacts.
    - ``specular_scale`` (float):  [Read-Write] Multiplier on specular highlights. Use only with great care! Any value besides 1 is not physical!
      Can be used to artistically remove highlights mimicking polarizing filters or photo touch up.
    - ``temperature`` (float):  [Read-Write] Color temperature in Kelvin of the blackbody illuminant.
      White (D65) is 6500K.
    - ``transmission`` (bool):  [Read-Write] Whether light from this light transmits through surfaces with subsurface scattering profiles. Requires light to be movable.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_ies_brightness`` (bool):  [Read-Write] true: take light brightness from IES profile, false: use the light brightness - the maximum light in one direction is used to define no masking. Use with InverseSquareFalloff. Will be disabled if a valid IES profile texture is not supplied.
    - ``use_inverse_squared_falloff`` (bool):  [Read-Write] Whether to use physically based inverse squared distance falloff, where AttenuationRadius is only clamping the light's contribution.
      Disabling inverse squared falloff can be useful when placing fill lights (don't want a super bright spot near the light).
      When enabled, the light's Intensity is in units of lumens, where 1700 lumens is a 100W lightbulb.
      When disabled, the light's Intensity is a brightness scale.
    - ``use_ray_traced_distance_field_shadows`` (bool):  [Read-Write] Whether to use ray traced distance field area shadows.  The project setting bGenerateMeshDistanceFields must be enabled for this to have effect.
      Distance field shadows support area lights so they create soft shadows with sharp contacts.
      They have less aliasing artifacts than standard shadowmaps, but inherit all the limitations of distance field representations (only uniform scale, no deformation).
      These shadows have a low per-object cost (and don't depend on triangle count) so they are effective for distant shadows from a dynamic sun.
    - ``use_temperature`` (bool):  [Read-Write] false: use white (D65) as illuminant.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volumetric_scattering_intensity`` (float):  [Read-Write] Intensity of the volumetric scattering from this light.  This scales Intensity and LightColor.
    """
    @property
    def inner_cone_angle(self) -> float:
        r"""
        (float):  [Read-Only] Degrees.
        """
        ...
    @property
    def outer_cone_angle(self) -> float:
        r"""
        (float):  [Read-Only] Degrees.
        """
        ...
    def set_outer_cone_angle(self, new_outer_cone_angle: float) -> None:
        r"""
        x.set_outer_cone_angle(new_outer_cone_angle) -> None
        Set Outer Cone Angle
        
        Args:
            new_outer_cone_angle (float):
        """
        ...
    def set_inner_cone_angle(self, new_inner_cone_angle: float) -> None:
        r"""
        x.set_inner_cone_angle(new_inner_cone_angle) -> None
        Set Inner Cone Angle
        
        Args:
            new_inner_cone_angle (float):
        """
        ...

class VolumetricCloudComponent(SceneComponent):
    r"""
    A component that represents a participating media material around a planet, e.g. clouds.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VolumetricCloudComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``aerial_pespective_mie_scattering_fade_distance`` (float):  [Read-Write] Specify the distance over which the Rayleigh scattering will linearly ramp up to full effect. (kilometers)
    - ``aerial_pespective_mie_scattering_start_distance`` (float):  [Read-Write] Specify the aerial perspective start distance on cloud for Mie scattering only. (kilometers)
    - ``aerial_pespective_rayleigh_scattering_fade_distance`` (float):  [Read-Write] Specify the distance over which the Rayleigh scattering will linearly ramp up to full effect. (kilometers)
    - ``aerial_pespective_rayleigh_scattering_start_distance`` (float):  [Read-Write] Specify the aerial perspective start distance on cloud for Rayleigh scattering only. (kilometers)
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``ground_albedo`` (Color):  [Read-Write] The ground albedo used to light the cloud from below with respect to the sun light and sky atmosphere.
      This is only used by the cloud material when the 'Volumetric Advanced' node have GroundContribution enabled.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``layer_bottom_altitude`` (float):  [Read-Write] The altitude at which the cloud layer starts. (kilometers above the ground)
    - ``layer_height`` (float):  [Read-Write] The height of the the cloud layer. (kilometers above the layer bottom altitude)
    - ``material`` (MaterialInterface):  [Read-Write] The material describing the cloud volume. It must be a Volume domain material.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``planet_radius`` (float):  [Read-Write] The planet radius used when there is not SkyAtmosphere component present in the scene.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``reflection_view_sample_count_scale_value`` (float):  [Read-Write] Scale the tracing sample count in reflection views. Quality level scalability CVARs affect the maximum range.
      The sample count resolution is still clamped according to scalability setting to 'r.VolumetricCloud.ReflectionRaySampleMaxCount'.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (basepass, transparency)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``shadow_reflection_view_sample_count_scale_value`` (float):  [Read-Write] Scale the shadow tracing sample count in reflection views, only used with Advanced Output ray marched shadows. Quality level scalability CVARs affect the maximum range.
      The sample count resolution is still clamped according to scalability setting to 'r.VolumetricCloud.Shadow.ReflectionRaySampleMaxCount'.
    - ``shadow_tracing_distance`` (float):  [Read-Write] The shadow tracing distance in kilometers, only used with Advanced Output ray marched shadows.
    - ``shadow_view_sample_count_scale`` (float):  [Read-Write] Scale the shadow tracing sample count in primary views, only used with Advanced Output ray marched shadows. Quality level scalability CVARs affect the maximum range.
      The sample count resolution is still clamped according to scalability setting to 'r.VolumetricCloud.Shadow.ViewRaySampleMaxCount'.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sky_light_cloud_bottom_occlusion`` (float):  [Read-Write] Occlude the sky light contribution at the bottom of the cloud layer. This is a fast approximation to sky lighting being occluded by cloud without having to trace rays or sample AO texture. Ignored if the cloud material explicitely sets the ambient occlusion value.
    - ``stop_tracing_transmittance_threshold`` (float):  [Read-Write] When the mean transmittance is below this threshold, we stop tracing. This is a good way to reduce the ray marched sample count, and thus to increase performance.
    - ``tracing_max_distance`` (float):  [Read-Write] The maximum distance that will be traced inside the cloud layer. (kilometers)
    - ``tracing_max_distance_mode`` (VolumetricCloudTracingMaxDistanceMode):  [Read-Write] Mode to select how the tracing max distance should be interpreted. DistanceFromPointOfView is useful to avoid the top of the cloud layer to be clipped when TracingMaxDistance is shorten for performance.
    - ``tracing_start_distance_from_camera`` (float):  [Read-Write] The distance from which the tracing will start. This is useful when the camera for instance is inside the layer of cloud. (kilometers)
    - ``tracing_start_max_distance`` (float):  [Read-Write] The maximum distance of the volumetric surface, i.e. cloud layer upper and lower bound, before which we will accept to start tracing. (kilometers)
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_per_sample_atmospheric_light_transmittance`` (bool):  [Read-Write] Whether to apply atmosphere transmittance per sample, instead of using the light global transmittance.
    - ``view_sample_count_scale`` (float):  [Read-Write] Scale the tracing sample count in primary views. Quality level scalability CVARs affect the maximum range.
      The sample count resolution is still clamped according to scalability setting to 'r.VolumetricCloud.ViewRaySampleCountMax'.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def layer_bottom_altitude(self) -> float:
        r"""
        (float):  [Read-Only] The altitude at which the cloud layer starts. (kilometers above the ground)
        """
        ...
    @property
    def layer_height(self) -> float:
        r"""
        (float):  [Read-Only] The height of the the cloud layer. (kilometers above the layer bottom altitude)
        """
        ...
    @property
    def tracing_start_max_distance(self) -> float:
        r"""
        (float):  [Read-Only] The maximum distance of the volumetric surface, i.e. cloud layer upper and lower bound, before which we will accept to start tracing. (kilometers)
        """
        ...
    @property
    def tracing_start_distance_from_camera(self) -> float:
        r"""
        (float):  [Read-Only] The distance from which the tracing will start. This is useful when the camera for instance is inside the layer of cloud. (kilometers)
        """
        ...
    @property
    def tracing_max_distance_mode(self) -> VolumetricCloudTracingMaxDistanceMode:
        r"""
        (VolumetricCloudTracingMaxDistanceMode):  [Read-Only] Mode to select how the tracing max distance should be interpreted. DistanceFromPointOfView is useful to avoid the top of the cloud layer to be clipped when TracingMaxDistance is shorten for performance.
        """
        ...
    @property
    def tracing_max_distance(self) -> float:
        r"""
        (float):  [Read-Only] The maximum distance that will be traced inside the cloud layer. (kilometers)
        """
        ...
    @property
    def planet_radius(self) -> float:
        r"""
        (float):  [Read-Only] The planet radius used when there is not SkyAtmosphere component present in the scene.
        """
        ...
    @property
    def ground_albedo(self) -> Color:
        r"""
        (Color):  [Read-Only] The ground albedo used to light the cloud from below with respect to the sun light and sky atmosphere.
        This is only used by the cloud material when the 'Volumetric Advanced' node have GroundContribution enabled.
        """
        ...
    @property
    def material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Only] The material describing the cloud volume. It must be a Volume domain material.
        """
        ...
    @property
    def use_per_sample_atmospheric_light_transmittance(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to apply atmosphere transmittance per sample, instead of using the light global transmittance.
        """
        ...
    @property
    def sky_light_cloud_bottom_occlusion(self) -> float:
        r"""
        (float):  [Read-Only] Occlude the sky light contribution at the bottom of the cloud layer. This is a fast approximation to sky lighting being occluded by cloud without having to trace rays or sample AO texture. Ignored if the cloud material explicitely sets the ambient occlusion value.
        """
        ...
    @property
    def view_sample_count_scale(self) -> float:
        r"""
        (float):  [Read-Only] Scale the tracing sample count in primary views. Quality level scalability CVARs affect the maximum range.
        The sample count resolution is still clamped according to scalability setting to 'r.VolumetricCloud.ViewRaySampleCountMax'.
        """
        ...
    @property
    def reflection_view_sample_count_scale_value(self) -> float:
        r"""
        (float):  [Read-Only] Scale the tracing sample count in reflection views. Quality level scalability CVARs affect the maximum range.
        The sample count resolution is still clamped according to scalability setting to 'r.VolumetricCloud.ReflectionRaySampleMaxCount'.
        """
        ...
    @property
    def shadow_view_sample_count_scale(self) -> float:
        r"""
        (float):  [Read-Only] Scale the shadow tracing sample count in primary views, only used with Advanced Output ray marched shadows. Quality level scalability CVARs affect the maximum range.
        The sample count resolution is still clamped according to scalability setting to 'r.VolumetricCloud.Shadow.ViewRaySampleMaxCount'.
        """
        ...
    @property
    def shadow_reflection_view_sample_count_scale_value(self) -> float:
        r"""
        (float):  [Read-Only] Scale the shadow tracing sample count in reflection views, only used with Advanced Output ray marched shadows. Quality level scalability CVARs affect the maximum range.
        The sample count resolution is still clamped according to scalability setting to 'r.VolumetricCloud.Shadow.ReflectionRaySampleMaxCount'.
        """
        ...
    @property
    def shadow_tracing_distance(self) -> float:
        r"""
        (float):  [Read-Only] The shadow tracing distance in kilometers, only used with Advanced Output ray marched shadows.
        """
        ...
    @property
    def stop_tracing_transmittance_threshold(self) -> float:
        r"""
        (float):  [Read-Only] When the mean transmittance is below this threshold, we stop tracing. This is a good way to reduce the ray marched sample count, and thus to increase performance.
        """
        ...
    @property
    def aerial_pespective_rayleigh_scattering_start_distance(self) -> float:
        r"""
        (float):  [Read-Only] Specify the aerial perspective start distance on cloud for Rayleigh scattering only. (kilometers)
        """
        ...
    @property
    def aerial_pespective_rayleigh_scattering_fade_distance(self) -> float:
        r"""
        (float):  [Read-Only] Specify the distance over which the Rayleigh scattering will linearly ramp up to full effect. (kilometers)
        """
        ...
    @property
    def aerial_pespective_mie_scattering_start_distance(self) -> float:
        r"""
        (float):  [Read-Only] Specify the aerial perspective start distance on cloud for Mie scattering only. (kilometers)
        """
        ...
    @property
    def aerial_pespective_mie_scattering_fade_distance(self) -> float:
        r"""
        (float):  [Read-Only] Specify the distance over which the Rayleigh scattering will linearly ramp up to full effect. (kilometers)
        """
        ...
    @property
    def holdout(self) -> bool:
        r"""
        (bool):  [Read-Only] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
        """
        ...
    @property
    def render_in_main_pass(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, this component will be rendered in the main pass (basepass, transparency)
        """
        ...
    def set_view_sample_count_scale(self, new_value: float) -> None:
        r"""
        x.set_view_sample_count_scale(new_value) -> None
        Set View Sample Count Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_tracing_start_max_distance(self, new_value: float) -> None:
        r"""
        x.set_tracing_start_max_distance(new_value) -> None
        Set Tracing Start Max Distance
        
        Args:
            new_value (float):
        """
        ...
    def set_tracing_start_distance_from_camera(self, new_value: float) -> None:
        r"""
        x.set_tracing_start_distance_from_camera(new_value) -> None
        Set Tracing Start Distance from Camera
        
        Args:
            new_value (float):
        """
        ...
    def set_tracing_max_distance(self, new_value: float) -> None:
        r"""
        x.set_tracing_max_distance(new_value) -> None
        Set Tracing Max Distance
        
        Args:
            new_value (float):
        """
        ...
    def set_stop_tracing_transmittance_threshold(self, new_value: float) -> None:
        r"""
        x.set_stop_tracing_transmittance_threshold(new_value) -> None
        Set Stop Tracing Transmittance Threshold
        
        Args:
            new_value (float):
        """
        ...
    def set_sky_light_cloud_bottom_occlusion(self, new_value: float) -> None:
        r"""
        x.set_sky_light_cloud_bottom_occlusion(new_value) -> None
        Set Sky Light Cloud Bottom Occlusion
        
        Args:
            new_value (float):
        """
        ...
    def set_shadow_view_sample_count_scale(self, new_value: float) -> None:
        r"""
        x.set_shadow_view_sample_count_scale(new_value) -> None
        Set Shadow View Sample Count Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_shadow_tracing_distance(self, new_value: float) -> None:
        r"""
        x.set_shadow_tracing_distance(new_value) -> None
        Set Shadow Tracing Distance
        
        Args:
            new_value (float):
        """
        ...
    def set_shadow_reflection_view_sample_count_scale(self, new_value: float) -> None:
        r"""
        x.set_shadow_reflection_view_sample_count_scale(new_value) -> None
        Set Shadow Reflection View Sample Count Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_shadow_reflection_sample_count_scale(self, new_value: float) -> None:
        r"""
        x.set_shadow_reflection_sample_count_scale(new_value) -> None
        Set Shadow Reflection Sample Count Scale
        deprecated: This function has been replaced by SetShadowReflectionViewSampleCountScale.
        
        Args:
            new_value (float):
        """
        ...
    def set_render_in_main_pass(self, value: bool) -> None:
        r"""
        x.set_render_in_main_pass(value) -> None
        Set Render in Main Pass
        
        Args:
            value (bool):
        """
        ...
    def set_reflection_view_sample_count_scale(self, new_value: float) -> None:
        r"""
        x.set_reflection_view_sample_count_scale(new_value) -> None
        Set Reflection View Sample Count Scale
        
        Args:
            new_value (float):
        """
        ...
    def set_reflection_sample_count_scale(self, new_value: float) -> None:
        r"""
        x.set_reflection_sample_count_scale(new_value) -> None
        Set Reflection Sample Count Scale
        deprecated: This function has been replaced by SetReflectionViewSampleCountScale.
        
        Args:
            new_value (float):
        """
        ...
    def set_planet_radius(self, new_value: float) -> None:
        r"""
        x.set_planet_radius(new_value) -> None
        Set Planet Radius
        
        Args:
            new_value (float):
        """
        ...
    def set_material(self, new_value: MaterialInterface) -> None:
        r"""
        x.set_material(new_value) -> None
        Set Material
        
        Args:
            new_value (MaterialInterface):
        """
        ...
    def set_layer_height(self, new_value: float) -> None:
        r"""
        x.set_layer_height(new_value) -> None
        Set Layer Height
        
        Args:
            new_value (float):
        """
        ...
    def set_layer_bottom_altitude(self, new_value: float) -> None:
        r"""
        x.set_layer_bottom_altitude(new_value) -> None
        Set Layer Bottom Altitude
        
        Args:
            new_value (float):
        """
        ...
    def set_holdout(self, new_holdout: bool) -> None:
        r"""
        x.set_holdout(new_holdout) -> None
        Set Holdout
        
        Args:
            new_holdout (bool):
        """
        ...
    def set_ground_albedo(self, new_value: Color) -> None:
        r"""
        x.set_ground_albedo(new_value) -> None
        Set Ground Albedo
        
        Args:
            new_value (Color):
        """
        ...
    def setb_use_per_sample_atmospheric_light_transmittance(self, new_value: bool) -> None:
        r"""
        x.setb_use_per_sample_atmospheric_light_transmittance(new_value) -> None
        Setb Use Per Sample Atmospheric Light Transmittance
        
        Args:
            new_value (bool):
        """
        ...

class VolumetricCloud(Info):
    r"""
    A placeable actor that represents a participating media material around a planet, e.g. clouds.
    see: TODO address to the documentation.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VolumetricCloudComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``volumetric_cloud_component`` (VolumetricCloudComponent):  [Read-Only]
    """
    @property
    def volumetric_cloud_component(self) -> VolumetricCloudComponent:
        r"""
        (VolumetricCloudComponent):  [Read-Only]
        """
        ...

class WorldPartitionStreamingSourceComponent(ActorComponent):
    r"""
    World Partition Streaming Source Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionStreamingSourceComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``debug_color`` (Color):  [Read-Write] Color used for debugging.
    - ``default_visualizer_loading_range`` (float):  [Read-Write] Value used by debug visualizer when grid loading range is chosen.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``priority`` (StreamingSourcePriority):  [Read-Write]
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``shapes`` (Array[StreamingSourceShape]):  [Read-Write] Optional aggregated shape list used to build a custom shape for the streaming source. When empty, fallbacks sphere shape with a radius equal to grid's loading range.
    - ``streaming_source_enabled`` (bool):  [Read-Write] Whether this component is enabled or not
    - ``target_behavior`` (StreamingSourceTargetBehavior):  [Read-Write] When TargetGrids or TargetHLODLayers are specified, this indicates the behavior.
    - ``target_grid`` (Name):  [Read-Write]
      deprecated: Use TargetGrids instead.
    - ``target_grids`` (Array[Name]):  [Read-Write] Optional target grids affected by streaming source.
    - ``target_hlod_layer`` (HLODLayer):  [Read-Write]
      deprecated: Use TargetHLODLayers instead.
    - ``target_hlod_layers`` (Array[HLODLayer]):  [Read-Write] Optional target HLODLayers affected by the streaming source.
      deprecated: Use TargetGrids instead.
    - ``target_state`` (StreamingSourceTargetState):  [Read-Write]
    """
    @property
    def target_behavior(self) -> StreamingSourceTargetBehavior:
        r"""
        (StreamingSourceTargetBehavior):  [Read-Write] When TargetGrids or TargetHLODLayers are specified, this indicates the behavior.
        """
        ...
    @target_behavior.setter
    def target_behavior(self, value: StreamingSourceTargetBehavior) -> None:
        ...
    @property
    def target_grids(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Optional target grids affected by streaming source.
        """
        ...
    @target_grids.setter
    def target_grids(self, value: Array[Name]) -> None:
        ...
    @property
    def target_grid(self) -> Name:
        r"""
        (Name):  [Read-Write]
        deprecated: Use TargetGrids instead.
        """
        ...
    @target_grid.setter
    def target_grid(self, value: Name) -> None:
        ...
    @property
    def target_hlod_layers(self) -> Array[HLODLayer]:
        r"""
        (Array[HLODLayer]):  [Read-Write] Optional target HLODLayers affected by the streaming source.
        deprecated: Use TargetGrids instead.
        """
        ...
    @target_hlod_layers.setter
    def target_hlod_layers(self, value: Array[HLODLayer]) -> None:
        ...
    @property
    def target_hlod_layer(self) -> HLODLayer:
        r"""
        (HLODLayer):  [Read-Write]
        deprecated: Use TargetHLODLayers instead.
        """
        ...
    @target_hlod_layer.setter
    def target_hlod_layer(self, value: HLODLayer) -> None:
        ...
    @property
    def shapes(self) -> Array[StreamingSourceShape]:
        r"""
        (Array[StreamingSourceShape]):  [Read-Write] Optional aggregated shape list used to build a custom shape for the streaming source. When empty, fallbacks sphere shape with a radius equal to grid's loading range.
        """
        ...
    @shapes.setter
    def shapes(self, value: Array[StreamingSourceShape]) -> None:
        ...
    @property
    def priority(self) -> StreamingSourcePriority:
        r"""
        (StreamingSourcePriority):  [Read-Write]
        """
        ...
    @priority.setter
    def priority(self, value: StreamingSourcePriority) -> None:
        ...
    @property
    def streaming_source_enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this component is enabled or not
        """
        ...
    @streaming_source_enabled.setter
    def streaming_source_enabled(self, value: bool) -> None:
        ...
    def is_streaming_source_enabled(self) -> bool:
        r"""
        x.is_streaming_source_enabled() -> bool
        Returns true if the component is active.
        
        Returns:
            bool:
        """
        ...
    def is_streaming_completed(self) -> bool:
        r"""
        x.is_streaming_completed() -> bool
        Returns true if streaming is completed for this streaming source component.
        
        Returns:
            bool:
        """
        ...
    def enable_streaming_source(self) -> None:
        r"""
        x.enable_streaming_source() -> None
        Enable the component
        """
        ...
    def disable_streaming_source(self) -> None:
        r"""
        x.disable_streaming_source() -> None
        Disable the component
        """
        ...

class CurveTable(Object):
    r"""
    Imported spreadsheet table as curves.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    """
    ...

class CompositeCurveTable(CurveTable):
    r"""
    Curve table composed of a stack of other curve tables.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CompositeCurveTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``parent_tables`` (Array[CurveTable]):  [Read-Write] Parent tables
      Tables with higher indices override data in tables with lower indices
    """
    @property
    def parent_tables(self) -> Array[CurveTable]:
        r"""
        (Array[CurveTable]):  [Read-Only] Parent tables
        Tables with higher indices override data in tables with lower indices
        """
        ...

class CompositeDataTable(DataTable):
    r"""
    Data table composed of a stack of other data tables.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CompositeDataTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only] The file this data table was imported from, may be empty
    - ``ignore_extra_fields`` (bool):  [Read-Write] Set to true to ignore extra fields in the import data, if false it will warn about them
    - ``ignore_missing_fields`` (bool):  [Read-Write] Set to true to ignore any fields that are expected but missing, if false it will warn about them
    - ``import_key_field`` (str):  [Read-Write] Explicit field in import data to use as key. If this is empty it uses Name for JSON and the first field found for CSV
    - ``parent_tables`` (Array[DataTable]):  [Read-Write] Parent tables
      Tables with higher indices override data in tables with lower indices
    - ``row_struct`` (ScriptStruct):  [Read-Only] Structure to use for each row of the table, must inherit from FTableRowBase
    - ``strip_from_client_builds`` (bool):  [Read-Write] Set to true to not cook this data table into client builds. Useful for sensitive tables that only servers should know about.
    """
    @property
    def parent_tables(self) -> Array[DataTable]:
        r"""
        (Array[DataTable]):  [Read-Only] Parent tables
        Tables with higher indices override data in tables with lower indices
        """
        ...

class CullDistanceVolume(Volume):
    r"""
    Cull Distance Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CullDistanceVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``cull_distances`` (Array[CullDistanceSizePair]):  [Read-Write] Array of size and cull distance pairs. The code will calculate the sphere diameter of a primitive's BB and look for a best
      fit in this array to determine which cull distance to use.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enabled`` (bool):  [Read-Write] Whether the volume is currently enabled or not.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def cull_distances(self) -> Array[CullDistanceSizePair]:
        r"""
        (Array[CullDistanceSizePair]):  [Read-Only] Array of size and cull distance pairs. The code will calculate the sphere diameter of a primitive's BB and look for a best
        fit in this array to determine which cull distance to use.
        """
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the volume is currently enabled or not.
        """
        ...

class CurveBase(Object):
    r"""
    Defines a curve of interpolated points to evaluate over a given range
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    """
    def get_value_range(self) -> Tuple[float, float]:
        r"""
        x.get_value_range() -> (min_value=float, max_value=float)
        Get the value range across all curves
        
        Returns:
            tuple: 
        
            min_value (float): 
        
            max_value (float):
        """
        ...
    def get_time_range(self) -> Tuple[float, float]:
        r"""
        x.get_time_range() -> (min_time=float, max_time=float)
        Get the time range across all curves
        
        Returns:
            tuple: 
        
            min_time (float): 
        
            max_time (float):
        """
        ...

class CurveFloat(CurveBase):
    r"""
    Curve Float
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    """
    def get_float_value(self, time: float) -> float:
        r"""
        x.get_float_value(time) -> float
        Evaluate this float curve at the specified time
        
        Args:
            time (float): 
        
        Returns:
            float:
        """
        ...

class CurveLinearColor(CurveBase):
    r"""
    Curve Linear Color
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveLinearColor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adjust_brightness`` (float):  [Read-Write]
    - ``adjust_brightness_curve`` (float):  [Read-Write]
    - ``adjust_hue`` (float):  [Read-Write] Properties for adjusting the color of the gradient
    - ``adjust_max_alpha`` (float):  [Read-Write]
    - ``adjust_min_alpha`` (float):  [Read-Write]
    - ``adjust_saturation`` (float):  [Read-Write]
    - ``adjust_vibrance`` (float):  [Read-Write]
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    """
    def get_unadjusted_linear_color_value(self, time: float) -> LinearColor:
        r"""
        x.get_unadjusted_linear_color_value(time) -> LinearColor
        Get Unadjusted Linear Color Value
        
        Args:
            time (float): 
        
        Returns:
            LinearColor:
        """
        ...
    def get_linear_color_value(self, time: float) -> LinearColor:
        r"""
        x.get_linear_color_value(time) -> LinearColor
        Get Linear Color Value
        
        Args:
            time (float): 
        
        Returns:
            LinearColor:
        """
        ...
    def get_clamped_linear_color_value(self, time: float) -> LinearColor:
        r"""
        x.get_clamped_linear_color_value(time) -> LinearColor
        Get Clamped Linear Color Value
        
        Args:
            time (float): 
        
        Returns:
            LinearColor:
        """
        ...

class CurveLinearColorAtlas(Texture2D):
    r"""
    Manages gradient LUT textures for registered actors and assigns them to the corresponding materials on the actor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveLinearColorAtlas.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``disable_all_adjustments`` (bool):  [Read-Write] Disable all color adjustments to preserve negative values in curves. Color adjustments clamp to 0 when enabled.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``gradient_curves`` (Array[CurveLinearColor]):  [Read-Write] Height of the lookup textures
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``square_resolution`` (bool):  [Read-Write] Set texture height equal to texture width.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``texture_height`` (uint32):  [Read-Write]
    - ``texture_size`` (uint32):  [Read-Write]
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    def get_curve_position(self, curve: CurveLinearColor) -> Optional[float]:
        r"""
        x.get_curve_position(curve) -> float or None
        Get Curve Position
        
        Args:
            curve (CurveLinearColor): 
        
        Returns:
            float or None: 
        
            position (float):
        """
        ...

class CurveVector(CurveBase):
    r"""
    Curve Vector
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CurveVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    """
    def get_vector_value(self, time: float) -> Vector:
        r"""
        x.get_vector_value(time) -> Vector
        Evaluate this float curve at the specified time
        
        Args:
            time (float): 
        
        Returns:
            Vector:
        """
        ...

class DamageType(Object):
    r"""
    A DamageType is intended to define and describe a particular form of damage and to provide an avenue
    for customizing responses to damage from various sources.
    
    For example, a game could make a DamageType_Fire set it up to ignite the damaged actor.
    
    DamageTypes are never instanced and should be treated as immutable data holders with static code
    functionality.  They should never be stateful.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DamageType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``caused_by_world`` (bool):  [Read-Write] True if this damagetype is caused by the world (falling off level, into lava, etc).
    - ``damage_falloff`` (float):  [Read-Write] Damage fall-off for radius damage (exponent).  Default 1.0=linear, 2.0=square of distance, etc.
    - ``damage_impulse`` (float):  [Read-Write] The magnitude of impulse to apply to the Actors damaged by this type.
    - ``destructible_damage_spread_scale`` (float):  [Read-Write] How much the damage spreads on a destructible mesh
    - ``destructible_impulse`` (float):  [Read-Write] How large the impulse should be applied to destructible meshes
    - ``radial_damage_vel_change`` (bool):  [Read-Write] When applying radial impulses, whether to treat as impulse or velocity change.
    - ``scale_momentum_by_mass`` (bool):  [Read-Write] True to scale imparted momentum by the receiving pawn's mass for pawns using character movement
    """
    @property
    def caused_by_world(self) -> bool:
        r"""
        (bool):  [Read-Only] True if this damagetype is caused by the world (falling off level, into lava, etc).
        """
        ...
    @property
    def scale_momentum_by_mass(self) -> bool:
        r"""
        (bool):  [Read-Only] True to scale imparted momentum by the receiving pawn's mass for pawns using character movement
        """
        ...
    @property
    def radial_damage_vel_change(self) -> bool:
        r"""
        (bool):  [Read-Only] When applying radial impulses, whether to treat as impulse or velocity change.
        """
        ...
    @property
    def damage_impulse(self) -> float:
        r"""
        (float):  [Read-Only] The magnitude of impulse to apply to the Actors damaged by this type.
        """
        ...
    @property
    def destructible_impulse(self) -> float:
        r"""
        (float):  [Read-Only] How large the impulse should be applied to destructible meshes
        """
        ...
    @property
    def destructible_damage_spread_scale(self) -> float:
        r"""
        (float):  [Read-Only] How much the damage spreads on a destructible mesh
        """
        ...
    @property
    def damage_falloff(self) -> float:
        r"""
        (float):  [Read-Only] Damage fall-off for radius damage (exponent).  Default 1.0=linear, 2.0=square of distance, etc.
        """
        ...

class PrimaryDataAsset(DataAsset):
    r"""
    A DataAsset that implements GetPrimaryAssetId and has asset bundle support, which allows it to be manually loaded/unloaded from the AssetManager.
    Instances of native subclasses can be created directly as Data Assets in the editor and will use the name of the native class as the PrimaryAssetType.
    Or, blueprint subclasses can be created to add variables and then subclassed again by Data Only Blueprints that set those variables.
    With blueprint subclasses, use Data Only Blueprints (and not Data Asset instances) to properly handle data inheritance and updating the parent class.
    
    The PrimaryAssetType will be equal to the name of the first native class going up the hierarchy, or the highest level blueprint class.
    IE, if you have UPrimaryDataAsset -> UParentNativeClass -> UChildNativeClass -> DataOnlyBlueprintClass the type will be ChildNativeClass.
    Whereas if you have UPrimaryDataAsset -> ParentBlueprintClass -> DataOnlyBlueprintClass the type will be ParentBlueprintClass.
    To change this behavior, override GetPrimaryAssetId in your native class or copy those functions into a different native base class.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataAsset.h
    
    """
    ...

class DataDrivenCVarEngineSubsystem(EngineSubsystem):
    r"""
    Data Driven CVar Engine Subsystem
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataDrivenCVars.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_data_driven_c_var_delegate`` (OnDataDrivenCVarChanged):  [Read-Write]
    """
    @property
    def on_data_driven_c_var_delegate(self) -> OnDataDrivenCVarChanged:
        r"""
        (OnDataDrivenCVarChanged):  [Read-Write]
        """
        ...
    @on_data_driven_c_var_delegate.setter
    def on_data_driven_c_var_delegate(self, value: OnDataDrivenCVarChanged) -> None:
        ...

class DataTableFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    Data Table Function Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataTableFunctionLibrary.h
    
    """
    @classmethod
    def get_data_table_row_struct(cls, table: DataTable) -> ScriptStruct:
        r"""
        X.get_data_table_row_struct(table) -> ScriptStruct
        Get the row struct used by the given Data Table, if any
        
        Args:
            table (DataTable): 
        
        Returns:
            ScriptStruct:
        """
        ...
    @classmethod
    def get_data_table_row_names(cls, table: DataTable) -> Array[Name]:
        r"""
        X.get_data_table_row_names(table) -> Array[Name]
        Get Data Table Row Names
        
        Args:
            table (DataTable): 
        
        Returns:
            Array[Name]: 
        
            out_row_names (Array[Name]):
        """
        ...
    @classmethod
    def get_data_table_column_names(cls, table: DataTable) -> Array[Name]:
        r"""
        X.get_data_table_column_names(table) -> Array[Name]
        Get the name of each column in this Data Table.
        note: These are always the raw property names (
        see: GetDataTableColumnAsString) rather than the friendly export name that would be used in a CSV/JSON export (
        see: GetDataTableColumnNameFromExportName).
        
        Args:
            table (DataTable): 
        
        Returns:
            Array[Name]: 
        
            out_column_names (Array[Name]):
        """
        ...
    @classmethod
    def get_data_table_column_name_from_export_name(cls, table: DataTable, column_export_name: str) -> Optional[Name]:
        r"""
        X.get_data_table_column_name_from_export_name(table, column_export_name) -> Name or None
        Get the raw property name of a data table column from its friendly export name.
        
        Args:
            table (DataTable): 
            column_export_name (str): 
        
        Returns:
            Name or None: True if a column was found for the friendly name, false otherwise.
        
            out_column_name (Name):
        """
        ...
    @classmethod
    def get_data_table_column_export_names(cls, table: DataTable) -> Array[str]:
        r"""
        X.get_data_table_column_export_names(table) -> Array[str]
        Get the friendly export name of each column in this Data Table.
        see: GetDataTableColumnNameFromExportName.
        
        Args:
            table (DataTable): 
        
        Returns:
            Array[str]: 
        
            out_export_column_names (Array[str]):
        """
        ...
    @classmethod
    def get_data_table_column_as_string(cls, data_table: DataTable, property_name: Name) -> Array[str]:
        r"""
        X.get_data_table_column_as_string(data_table, property_name) -> Array[str]
        Export from the DataTable all the row for one column. Export it as string. The row name is not included.
        see: GetDataTableColumnNames.
        see: GetDataTableColumnNameFromExportName.
        
        Args:
            data_table (DataTable): 
            property_name (Name): 
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def fill_data_table_from_json_string(cls, data_table: DataTable, json_string: str, import_row_struct: ScriptStruct = None) -> bool:
        r"""
        X.fill_data_table_from_json_string(data_table, json_string, import_row_struct=None) -> bool
        Empty and fill a Data Table from JSON string.
        
        Args:
            data_table (DataTable): 
            json_string (str): The Data that representing the contents of a JSON file.
            import_row_struct (ScriptStruct): Optional row struct to apply on import. If set will also force the import to run automated (no questions or dialogs).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    @classmethod
    def fill_data_table_from_json_file(cls, data_table: DataTable, json_file_path: str, import_row_struct: ScriptStruct = None) -> bool:
        r"""
        X.fill_data_table_from_json_file(data_table, json_file_path, import_row_struct=None) -> bool
        Empty and fill a Data Table from JSON file.
        
        Args:
            data_table (DataTable): 
            json_file_path (str): The file path of the JSON file.
            import_row_struct (ScriptStruct): Optional row struct to apply on import. If set will also force the import to run automated (no questions or dialogs).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    @classmethod
    def fill_data_table_from_csv_string(cls, data_table: DataTable, csv_string: str, import_row_struct: ScriptStruct = None) -> bool:
        r"""
        X.fill_data_table_from_csv_string(data_table, csv_string, import_row_struct=None) -> bool
        Empty and fill a Data Table from CSV string.
        
        Args:
            data_table (DataTable): 
            csv_string (str): The Data that representing the contents of a CSV file.
            import_row_struct (ScriptStruct): Optional row struct to apply on import. If set will also force the import to run automated (no questions or dialogs).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    @classmethod
    def fill_data_table_from_csv_file(cls, data_table: DataTable, csv_file_path: str, import_row_struct: ScriptStruct = None) -> bool:
        r"""
        X.fill_data_table_from_csv_file(data_table, csv_file_path, import_row_struct=None) -> bool
        Empty and fill a Data Table from CSV file.
        
        Args:
            data_table (DataTable): 
            csv_file_path (str): The file path of the CSV file.
            import_row_struct (ScriptStruct): Optional row struct to apply on import. If set will also force the import to run automated (no questions or dialogs).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    @classmethod
    def export_data_table_to_json_string(cls, data_table: DataTable) -> Optional[str]:
        r"""
        X.export_data_table_to_json_string(data_table) -> str or None
        Export a Data Table to JSON string.
        
        Args:
            data_table (DataTable): 
        
        Returns:
            str or None: True if the operation succeeds, check the log for errors if it didn't succeed.
        
            out_json_string (str): Output representing the contents of a JSON file.
        """
        ...
    @classmethod
    def export_data_table_to_json_file(cls, data_table: DataTable, json_file_path: str) -> bool:
        r"""
        X.export_data_table_to_json_file(data_table, json_file_path) -> bool
        Export a Data Table to JSON file.
        
        Args:
            data_table (DataTable): 
            json_file_path (str): The file path of the JSON file to write (output file is UTF-8).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    @classmethod
    def export_data_table_to_csv_string(cls, data_table: DataTable) -> Optional[str]:
        r"""
        X.export_data_table_to_csv_string(data_table) -> str or None
        Export a Data Table to CSV string.
        
        Args:
            data_table (DataTable): 
        
        Returns:
            str or None: True if the operation succeeds, check the log for errors if it didn't succeed.
        
            out_csv_string (str): Output representing the contents of a CSV file.
        """
        ...
    @classmethod
    def export_data_table_to_csv_file(cls, data_table: DataTable, csv_file_path: str) -> bool:
        r"""
        X.export_data_table_to_csv_file(data_table, csv_file_path) -> bool
        Export a Data Table to CSV file.
        
        Args:
            data_table (DataTable): 
            csv_file_path (str): The file path of the CSV file to write (output file is UTF-8).
        
        Returns:
            bool: True if the operation succeeds, check the log for errors if it didn't succeed.
        """
        ...
    @classmethod
    def evaluate_curve_table_row(cls, curve_table: CurveTable, row_name: Name, xy: float, context_string: str) -> Tuple[EvaluateCurveTableResult, float]:
        r"""
        X.evaluate_curve_table_row(curve_table, row_name, xy, context_string) -> (out_result=EvaluateCurveTableResult, out_xy=float)
        Evaluate Curve Table Row
        
        Args:
            curve_table (CurveTable): 
            row_name (Name): 
            xy (float): 
            context_string (str): 
        
        Returns:
            tuple: 
        
            out_result (EvaluateCurveTableResult): 
        
            out_xy (float):
        """
        ...
    @classmethod
    def does_data_table_row_exist(cls, table: DataTable, row_name: Name) -> bool:
        r"""
        X.does_data_table_row_exist(table, row_name) -> bool
        Returns whether or not Table contains a row named RowName
        
        Args:
            table (DataTable): 
            row_name (Name): 
        
        Returns:
            bool:
        """
        ...

class DebugCameraController(PlayerController):
    r"""
    Camera controller that allows you to fly around a level mostly unrestricted by normal movement rules.
    
    To turn it on, please press Alt+C or both (left and right) analogs on XBox pad,
    or use the "ToggleDebugCamera" console command. Check the debug camera bindings
    in DefaultPawn.cpp for the camera controls.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DebugCameraController.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_data_class`` (type(Class)):  [Read-Write] The type of async physics data object to use
      deprecated: AsyncPhysicsDataClass is deprecated. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``async_physics_data_component_deprecared`` (AsyncPhysicsInputComponent):  [Read-Write]
      deprecated: AsyncPhysicsDataComponent is deprecated. please see the new C++ NetworkPhysicsComponent
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``attach_to_pawn`` (bool):  [Read-Write] If true, the controller location will match the possessed Pawn's location. If false, it will not be updated. Rotation will match ControlRotation in either case.
      Since a Controller's location is normally inaccessible, this is intended mainly for purposes of being able to attach
      an Actor that follows the possessed Pawn location, but that still has the full aim rotation (since a Pawn might
      update only some components of the rotation).
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_manage_active_camera_target`` (bool):  [Read-Write] True to allow this player controller to manage the camera target for you,
      typically by using the possessed pawn as the camera target. Set to false
      if you want to manually control the camera target.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``cheat_class`` (type(Class)):  [Read-Write] Class of my CheatManager.
      see: CheatManager for more information about when it will be instantiated.
    - ``cheat_manager`` (CheatManager):  [Read-Write] Object that manages "cheat" commands.
      
      By default:
            - In Shipping configurations, the manager is always disabled because UE_WITH_CHEAT_MANAGER is 0
        - When playing in the editor, cheats are always enabled
        - In other cases, cheats are enabled by default in single player games but can be forced on with the EnableCheats console command
      
      This behavior can be changed either by overriding APlayerController::EnableCheats or AGameModeBase::AllowCheats.
    - ``click_event_keys`` (Array[Key]):  [Read-Write] List of keys that will cause click events to be forwarded, default to left click
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``current_click_trace_channel`` (CollisionChannel):  [Read-Write] Trace channel currently being used for determining what world object was clicked on.
    - ``current_mouse_cursor`` (MouseCursor):  [Read-Write] Currently visible mouse cursor
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_click_trace_channel`` (CollisionChannel):  [Read-Write] Default trace channel used for determining what world object was clicked on.
    - ``default_mouse_cursor`` (MouseCursor):  [Read-Write] Type of mouse cursor to show by default
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_click_events`` (bool):  [Read-Write] Whether actor/component click events should be generated.
    - ``enable_motion_controls`` (bool):  [Read-Write] Whether or not to consider input from motion sources (tilt, acceleration, etc)
    - ``enable_mouse_over_events`` (bool):  [Read-Write] Whether actor/component mouse over events should be generated.
    - ``enable_streaming_source`` (bool):  [Read-Write] Whether the PlayerController should be used as a World Partiton streaming source.
    - ``enable_touch_events`` (bool):  [Read-Write] Whether actor/component touch events should be generated.
    - ``enable_touch_over_events`` (bool):  [Read-Write] Whether actor/component touch over events should be generated.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``force_feedback_enabled`` (bool):  [Read-Write]
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hit_result_trace_distance`` (float):  [Read-Write] Distance to trace when computing click events
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_accel`` (float):  [Read-Write] Initial acceleration of the spectator pawn when we start possession.
    - ``initial_decel`` (float):  [Read-Write] Initial deceleration of the spectator pawn when we start possession.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``initial_max_speed`` (float):  [Read-Write] Initial max speed of the spectator pawn when we start possession.
    - ``input_pitch_scale`` (float):  [Read-Write] Pitch input speed scaling
      deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``input_roll_scale`` (float):  [Read-Write] Roll input speed scaling
      deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``input_yaw_scale`` (float):  [Read-Write] Yaw input speed scaling
      deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_instigated_any_damage`` (InstigatedAnyDamageSignature):  [Read-Write] Called when the controller has instigated damage in any way
    - ``on_possessed_pawn_changed`` (OnPossessedPawnChanged):  [Read-Write] Called on both authorities and clients when the possessed pawn changes (either OldPawn or NewPawn might be nullptr)
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_player_input_class`` (type(Class)):  [Read-Write] If set, then this UPlayerInput class will be used instead of the Input Settings' DefaultPlayerInputClass
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_camera_manager`` (PlayerCameraManager):  [Read-Write] Camera manager associated with this Player Controller.
    - ``player_camera_manager_class`` (type(Class)):  [Read-Write] PlayerCamera class should be set for each game, otherwise Engine.PlayerCameraManager is used
    - ``player_is_waiting`` (bool):  [Read-Only] True if PlayerController is currently waiting for the match to start or to respawn. Only valid in Spectating state.
    - ``player_state`` (PlayerState):  [Read-Write] PlayerState containing replicated information about the player using this controller (only exists for players, not NPCs).
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``should_perform_full_tick_when_paused`` (bool):  [Read-Write] Whether we fully tick when the game is paused, if our tick function is allowed to do so. If false, we do a minimal update during the tick.
    - ``show_mouse_cursor`` (bool):  [Read-Write] Whether the mouse cursor should be displayed.
    - ``smooth_target_view_rotation_speed`` (float):  [Read-Write] Interp speed for blending remote view rotation for smoother client updates
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``speed_scale`` (float):  [Read-Write] Allows control over the speed of the spectator pawn. This scales the speed based on the InitialMaxSpeed. Use Set Pawn Movement Speed Scale during runtime
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``streaming_source_debug_color`` (Color):  [Read-Write] Color used for debugging.
    - ``streaming_source_priority`` (StreamingSourcePriority):  [Read-Write] PlayerController streaming source priority.
    - ``streaming_source_shapes`` (Array[StreamingSourceShape]):  [Read-Write] Optional aggregated shape list used to build a custom shape for the streaming source. When empty, fallbacks sphere shape with a radius equal to grid's loading range.
    - ``streaming_source_should_activate`` (bool):  [Read-Write] Whether the PlayerController streaming source should activate cells after loading.
    - ``streaming_source_should_block_on_slow_streaming`` (bool):  [Read-Write] Whether the PlayerController streaming source should block on slow streaming.
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def speed_scale(self) -> float:
        r"""
        (float):  [Read-Only] Allows control over the speed of the spectator pawn. This scales the speed based on the InitialMaxSpeed. Use Set Pawn Movement Speed Scale during runtime
        """
        ...
    @property
    def initial_max_speed(self) -> float:
        r"""
        (float):  [Read-Only] Initial max speed of the spectator pawn when we start possession.
        """
        ...
    @property
    def initial_accel(self) -> float:
        r"""
        (float):  [Read-Only] Initial acceleration of the spectator pawn when we start possession.
        """
        ...
    @property
    def initial_decel(self) -> float:
        r"""
        (float):  [Read-Only] Initial deceleration of the spectator pawn when we start possession.
        """
        ...
    def toggle_display(self) -> None:
        r"""
        x.toggle_display() -> None
        Toggles the display of debug info and input commands for the Debug Camera.
        """
        ...
    def set_pawn_movement_speed_scale(self, new_speed_scale: float) -> None:
        r"""
        x.set_pawn_movement_speed_scale(new_speed_scale) -> None
        Sets the pawn movement speed scale.
        
        Args:
            new_speed_scale (float):
        """
        ...
    def receive_on_deactivate(self, restored_pc: PlayerController) -> None:
        r"""
        x.receive_on_deactivate(restored_pc) -> None
        Function called on deactivation of debug camera controller.
        
        Args:
            restored_pc (PlayerController): The Player Controller that the player input is being returned to.
        """
        ...
    def receive_on_actor_selected(self, new_selected_actor: Actor, select_hit_location: Vector, select_hit_normal: Vector, hit: HitResult) -> None:
        r"""
        x.receive_on_actor_selected(new_selected_actor, select_hit_location, select_hit_normal, hit) -> None
        Called when an actor has been selected with the primary key (e.g. left mouse button).
        
        The selection trace starts from the center of the debug camera's view.
        
        Args:
            new_selected_actor (Actor): 
            select_hit_location (Vector): The exact world-space location where the selection trace hit the New Selected Actor.
            select_hit_normal (Vector): The world-space surface normal of the New Selected Actor at the hit location.
            hit (HitResult):
        """
        ...
    def receive_on_activate(self, original_pc: PlayerController) -> None:
        r"""
        x.receive_on_activate(original_pc) -> None
        Function called on activation of debug camera controller.
        
        Args:
            original_pc (PlayerController): The active player controller before this debug camera controller was possessed by the player.
        """
        ...
    def get_selected_actor(self) -> Actor:
        r"""
        x.get_selected_actor() -> Actor
        Returns the currently selected actor, or null if it is invalid or not set
        
        Returns:
            Actor:
        """
        ...

class HUD(Actor):
    r"""
    Base class of the heads-up display. This has a canvas and a debug canvas on which primitives can be drawn.
    It also contains a list of simple hit boxes that can be used for simple item click detection.
    A method of rendering debug text is also included.
    Provides some simple methods for rendering text, textures, rectangles and materials which can also be accessed from blueprints.
    see: UCanvas
    see: FHUDHitBox
    see: FDebugTextInfo
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HUD.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_debug_text_shadow`` (bool):  [Read-Write] Put shadow on debug strings
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``lost_focus_paused`` (bool):  [Read-Write] Tells whether the game was paused due to lost focus
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_owner`` (PlayerController):  [Read-Write] PlayerController which owns this HUD.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``show_debug_info`` (bool):  [Read-Write] If true, current ViewTarget shows debug information using its DisplayDebug().
    - ``show_hit_box_debug_info`` (bool):  [Read-Write] If true, show hitbox debugging info.
    - ``show_hud`` (bool):  [Read-Write] Whether or not the HUD should be drawn.
    - ``show_overlays`` (bool):  [Read-Write] If true, render actor overlays.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def player_owner(self) -> PlayerController:
        r"""
        (PlayerController):  [Read-Only] PlayerController which owns this HUD.
        """
        ...
    @property
    def lost_focus_paused(self) -> bool:
        r"""
        (bool):  [Read-Only] Tells whether the game was paused due to lost focus
        """
        ...
    @property
    def show_hud(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not the HUD should be drawn.
        """
        ...
    @show_hud.setter
    def show_hud(self, value: bool) -> None:
        ...
    @property
    def show_debug_info(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, current ViewTarget shows debug information using its DisplayDebug().
        """
        ...
    @show_debug_info.setter
    def show_debug_info(self, value: bool) -> None:
        ...
    @property
    def show_hit_box_debug_info(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, show hitbox debugging info.
        """
        ...
    @show_hit_box_debug_info.setter
    def show_hit_box_debug_info(self, value: bool) -> None:
        ...
    @property
    def show_overlays(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, render actor overlays.
        """
        ...
    @show_overlays.setter
    def show_overlays(self, value: bool) -> None:
        ...
    @property
    def enable_debug_text_shadow(self) -> bool:
        r"""
        (bool):  [Read-Write] Put shadow on debug strings
        """
        ...
    @enable_debug_text_shadow.setter
    def enable_debug_text_shadow(self, value: bool) -> None:
        ...
    def receive_hit_box_release(self, box_name: Name) -> None:
        r"""
        x.receive_hit_box_release(box_name) -> None
        Called when a hit box is unclicked. Provides the name associated with that box.
        
        Args:
            box_name (Name):
        """
        ...
    def receive_hit_box_end_cursor_over(self, box_name: Name) -> None:
        r"""
        x.receive_hit_box_end_cursor_over(box_name) -> None
        Called when a hit box no longer has the mouse over it.
        
        Args:
            box_name (Name):
        """
        ...
    def receive_hit_box_click(self, box_name: Name) -> None:
        r"""
        x.receive_hit_box_click(box_name) -> None
        Called when a hit box is clicked on. Provides the name associated with that box.
        
        Args:
            box_name (Name):
        """
        ...
    def receive_hit_box_begin_cursor_over(self, box_name: Name) -> None:
        r"""
        x.receive_hit_box_begin_cursor_over(box_name) -> None
        Called when a hit box is moused over.
        
        Args:
            box_name (Name):
        """
        ...
    def receive_draw_hud(self, size_x: int, size_y: int) -> None:
        r"""
        x.receive_draw_hud(size_x, size_y) -> None
        Hook to allow blueprints to do custom HUD drawing.
        see: bSuppressNativeHUD to control HUD drawing in base class. Note:  the canvas resource used for drawing is only valid during this event, it will not be valid if drawing functions are called later (e.g. after a Delay node).
        
        Args:
            size_x (int32): 
            size_y (int32):
        """
        ...
    def project(self, location: Vector, clamp_to_zero_plane: bool = True) -> Vector:
        r"""
        x.project(location, clamp_to_zero_plane=True) -> Vector
        Transforms a 3D world-space vector into 2D screen coordinates
        
        Args:
            location (Vector): The world-space position to transform
            clamp_to_zero_plane (bool): If true, 2D screen coordinates behind the viewing plane (-Z) will have Z set to 0 (leaving X and Y alone)
        
        Returns:
            Vector: The transformed vector
        """
        ...
    def get_text_size(self, text: str, font: Font = None, scale: float = 1.000000) -> Tuple[float, float]:
        r"""
        x.get_text_size(text, font=None, scale=1.000000) -> (out_width=float, out_height=float)
        Returns the width and height of a string.
        
        Args:
            text (str): String to draw
            font (Font): Font to draw text.  If NULL, default font is chosen.
            scale (float): Scale multiplier to control size of the text.
        
        Returns:
            tuple: 
        
            out_width (float): Returns the width in pixels of the string.
        
            out_height (float): Returns the height in pixels of the string.
        """
        ...
    def get_owning_player_controller(self) -> PlayerController:
        r"""
        x.get_owning_player_controller() -> PlayerController
        Returns the PlayerController for this HUD's player.
        
        Returns:
            PlayerController:
        """
        ...
    def get_owning_pawn(self) -> Pawn:
        r"""
        x.get_owning_pawn() -> Pawn
        Returns the Pawn for this HUD's player.
        
        Returns:
            Pawn:
        """
        ...
    def get_actors_in_selection_rectangle(self, class_filter: Class, first_point: Vector2D, second_point: Vector2D, include_non_colliding_components: bool = True, actor_must_be_fully_enclosed: bool = False) -> Array[Actor]:
        r"""
        x.get_actors_in_selection_rectangle(class_filter, first_point, second_point, include_non_colliding_components=True, actor_must_be_fully_enclosed=False) -> Array[Actor]
        Returns the array of actors inside a selection rectangle, with a class filter.
        
        Sample usage:
        
              TArray<AStaticMeshActor*> ActorsInSelectionRect;
                     Canvas->GetActorsInSelectionRectangle<AStaticMeshActor>(FirstPoint,SecondPoint,ActorsInSelectionRect);
        
        Args:
            class_filter (type(Class)): 
            first_point (Vector2D): The first point, or anchor of the marquee box. Where the dragging of the marquee started in screen space.
            second_point (Vector2D): The second point, where the mouse cursor currently is / the other point of the box selection, in screen space.
            include_non_colliding_components (bool): Whether to include even non-colliding components of the actor when determining its bounds
            actor_must_be_fully_enclosed (bool): The Selection rule: whether the selection box can partially intersect Actor, or must fully enclose the Actor.
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]):
        """
        ...
    def draw_texture_simple(self, texture: Texture, screen_x: float, screen_y: float, scale: float = 1.000000, scale_position: bool = False) -> None:
        r"""
        x.draw_texture_simple(texture, screen_x, screen_y, scale=1.000000, scale_position=False) -> None
        Draws a textured quad on the HUD. Assumes 1:1 texel density.
        
        Args:
            texture (Texture): Texture to draw.
            screen_x (float): Screen-space X coordinate of upper left corner of the quad.
            screen_y (float): Screen-space Y coordinate of upper left corner of the quad.
            scale (float): Scale multiplier to control size of the text.
            scale_position (bool): Whether the "Scale" parameter should also scale the position of this draw call.
        """
        ...
    def draw_texture(self, texture: Texture, screen_x: float, screen_y: float, screen_w: float, screen_h: float, texture_u: float, texture_v: float, texture_u_width: float, texture_v_height: float, tint_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], blend_mode: BlendMode = BlendMode.BLEND_TRANSLUCENT, scale: float = 1.000000, scale_position: bool = False, rotation: float = 0.000000, rot_pivot: Vector2D = [0.000000, 0.000000]) -> None:
        r"""
        x.draw_texture(texture, screen_x, screen_y, screen_w, screen_h, texture_u, texture_v, texture_u_width, texture_v_height, tint_color=[1.000000, 1.000000, 1.000000, 1.000000], blend_mode=BlendMode.BLEND_TRANSLUCENT, scale=1.000000, scale_position=False, rotation=0.000000, rot_pivot=[0.000000, 0.000000]) -> None
        Draws a textured quad on the HUD.
        
        Args:
            texture (Texture): Texture to draw.
            screen_x (float): Screen-space X coordinate of upper left corner of the quad.
            screen_y (float): Screen-space Y coordinate of upper left corner of the quad.
            screen_w (float): Screen-space width of the quad (in pixels).
            screen_h (float): Screen-space height of the quad (in pixels).
            texture_u (float): Texture-space U coordinate of upper left corner of the quad
            texture_v (float): Texture-space V coordinate of upper left corner of the quad.
            texture_u_width (float): Texture-space width of the quad (in normalized UV distance).
            texture_v_height (float): Texture-space height of the quad (in normalized UV distance).
            tint_color (LinearColor): Vertex color for the quad.
            blend_mode (BlendMode): Controls how to blend this quad with the scene. Translucent by default.
            scale (float): Amount to scale the entire texture (horizontally and vertically)
            scale_position (bool): Whether the "Scale" parameter should also scale the position of this draw call.
            rotation (float): Amount to rotate this quad
            rot_pivot (Vector2D): Location (as proportion of quad, 0-1) to rotate about
        """
        ...
    def draw_text(self, text: str, text_color: LinearColor = [0.000000, 0.000000, 0.000000, 1.000000], screen_x: float = ..., screen_y: float = ..., font: Font = None, scale: float = 1.000000, scale_position: bool = False) -> None:
        r"""
        x.draw_text(text, text_color=[0.000000, 0.000000, 0.000000, 1.000000], screen_x, screen_y, font=None, scale=1.000000, scale_position=False) -> None
        Draws a string on the HUD.
        
        Args:
            text (str): String to draw
            text_color (LinearColor): Color to draw string
            screen_x (float): Screen-space X coordinate of upper left corner of the string.
            screen_y (float): Screen-space Y coordinate of upper left corner of the string.
            font (Font): Font to draw text.  If NULL, default font is chosen.
            scale (float): Scale multiplier to control size of the text.
            scale_position (bool): Whether the "Scale" parameter should also scale the position of this draw call.
        """
        ...
    def draw_rect(self, rect_color: LinearColor = [0.000000, 0.000000, 0.000000, 1.000000], screen_x: float = ..., screen_y: float = ..., screen_w: float = ..., screen_h: float = ...) -> None:
        r"""
        x.draw_rect(rect_color=[0.000000, 0.000000, 0.000000, 1.000000], screen_x, screen_y, screen_w, screen_h) -> None
        Draws a colored untextured quad on the HUD.
        
        Args:
            rect_color (LinearColor): Color of the rect. Can be translucent.
            screen_x (float): Screen-space X coordinate of upper left corner of the quad.
            screen_y (float): Screen-space Y coordinate of upper left corner of the quad.
            screen_w (float): Screen-space width of the quad (in pixels).
            screen_h (float): Screen-space height of the quad (in pixels).
        """
        ...
    def draw_material_triangle(self, material: MaterialInterface, v0_pos: Vector2D, v1_pos: Vector2D, v2_pos: Vector2D, v0_uv: Vector2D, v1_uv: Vector2D, v2_uv: Vector2D, v0_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], v1_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], v2_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000]) -> None:
        r"""
        x.draw_material_triangle(material, v0_pos, v1_pos, v2_pos, v0_uv, v1_uv, v2_uv, v0_color=[1.000000, 1.000000, 1.000000, 1.000000], v1_color=[1.000000, 1.000000, 1.000000, 1.000000], v2_color=[1.000000, 1.000000, 1.000000, 1.000000]) -> None
        Draw Material Triangle
        
        Args:
            material (MaterialInterface): 
            v0_pos (Vector2D): 
            v1_pos (Vector2D): 
            v2_pos (Vector2D): 
            v0_uv (Vector2D): 
            v1_uv (Vector2D): 
            v2_uv (Vector2D): 
            v0_color (LinearColor): 
            v1_color (LinearColor): 
            v2_color (LinearColor):
        """
        ...
    def draw_material_simple(self, material: MaterialInterface, screen_x: float, screen_y: float, screen_w: float, screen_h: float, scale: float = 1.000000, scale_position: bool = False) -> None:
        r"""
        x.draw_material_simple(material, screen_x, screen_y, screen_w, screen_h, scale=1.000000, scale_position=False) -> None
        Draws a material-textured quad on the HUD.  Assumes UVs such that the entire material is shown.
        
        Args:
            material (MaterialInterface): Material to use
            screen_x (float): Screen-space X coordinate of upper left corner of the quad.
            screen_y (float): Screen-space Y coordinate of upper left corner of the quad.
            screen_w (float): Screen-space width of the quad (in pixels).
            screen_h (float): Screen-space height of the quad (in pixels).
            scale (float): Amount to scale the entire texture (horizontally and vertically)
            scale_position (bool): Whether the "Scale" parameter should also scale the position of this draw call.
        """
        ...
    def draw_material(self, material: MaterialInterface, screen_x: float, screen_y: float, screen_w: float, screen_h: float, material_u: float, material_v: float, material_u_width: float, material_v_height: float, scale: float = 1.000000, scale_position: bool = False, rotation: float = 0.000000, rot_pivot: Vector2D = [0.000000, 0.000000]) -> None:
        r"""
        x.draw_material(material, screen_x, screen_y, screen_w, screen_h, material_u, material_v, material_u_width, material_v_height, scale=1.000000, scale_position=False, rotation=0.000000, rot_pivot=[0.000000, 0.000000]) -> None
        Draws a material-textured quad on the HUD.
        
        Args:
            material (MaterialInterface): Material to use
            screen_x (float): Screen-space X coordinate of upper left corner of the quad.
            screen_y (float): Screen-space Y coordinate of upper left corner of the quad.
            screen_w (float): Screen-space width of the quad (in pixels).
            screen_h (float): Screen-space height of the quad (in pixels).
            material_u (float): Texture-space U coordinate of upper left corner of the quad
            material_v (float): Texture-space V coordinate of upper left corner of the quad.
            material_u_width (float): Texture-space width of the quad (in normalized UV distance).
            material_v_height (float): Texture-space height of the quad (in normalized UV distance).
            scale (float): Amount to scale the entire texture (horizontally and vertically)
            scale_position (bool): Whether the "Scale" parameter should also scale the position of this draw call.
            rotation (float): Amount to rotate this quad
            rot_pivot (Vector2D): Location (as proportion of quad, 0-1) to rotate about
        """
        ...
    def draw_line(self, start_screen_x: float, start_screen_y: float, end_screen_x: float, end_screen_y: float, line_color: LinearColor = [0.000000, 0.000000, 0.000000, 1.000000], line_thickness: float = 0.000000) -> None:
        r"""
        x.draw_line(start_screen_x, start_screen_y, end_screen_x, end_screen_y, line_color=[0.000000, 0.000000, 0.000000, 1.000000], line_thickness=0.000000) -> None
        Draws a 2D line on the HUD.
        
        Args:
            start_screen_x (float): Screen-space X coordinate of start of the line.
            start_screen_y (float): Screen-space Y coordinate of start of the line.
            end_screen_x (float): Screen-space X coordinate of end of the line.
            end_screen_y (float): Screen-space Y coordinate of end of the line.
            line_color (LinearColor): Color to draw line
            line_thickness (float): Thickness of the line to draw
        """
        ...
    def deproject(self, screen_x: float, screen_y: float) -> Tuple[Vector, Vector]:
        r"""
        x.deproject(screen_x, screen_y) -> (world_position=Vector, world_direction=Vector)
        Transforms a 2D screen location into a 3D location and direction
        
        Args:
            screen_x (float): 
            screen_y (float): 
        
        Returns:
            tuple: 
        
            world_position (Vector): 
        
            world_direction (Vector):
        """
        ...
    def add_hit_box(self, position: Vector2D, size: Vector2D, name: Name, consumes_input: bool, priority: int = 0) -> None:
        r"""
        x.add_hit_box(position, size, name, consumes_input, priority=0) -> None
        Add a hitbox to the hud
        
        Args:
            position (Vector2D): Coordinates of the top left of the hit box.
            size (Vector2D): Size of the hit box.
            name (Name): 
            consumes_input (bool): Whether click processing should continue if this hit box is clicked.
            priority (int32): The priority of the box used for layering. Larger values are considered first.  Equal values are considered in the order they were added.
        """
        ...

class DebugCameraHUD(HUD):
    r"""
    HUD that displays info for the DebugCameraController view.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DebugCameraHUD.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_debug_text_shadow`` (bool):  [Read-Write] Put shadow on debug strings
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``lost_focus_paused`` (bool):  [Read-Write] Tells whether the game was paused due to lost focus
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_owner`` (PlayerController):  [Read-Write] PlayerController which owns this HUD.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``show_debug_info`` (bool):  [Read-Write] If true, current ViewTarget shows debug information using its DisplayDebug().
    - ``show_hit_box_debug_info`` (bool):  [Read-Write] If true, show hitbox debugging info.
    - ``show_hud`` (bool):  [Read-Write] Whether or not the HUD should be drawn.
    - ``show_overlays`` (bool):  [Read-Write] If true, render actor overlays.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class DecalActor(Actor):
    r"""
    DecalActor contains a DecalComponent which can be used to render material modifications on top of existing geometry.
    see: https://docs.unrealengine.com/latest/INT/Engine/Actors/DecalActor
    see: UDecalComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DecalActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``decal`` (DecalComponent):  [Read-Only] The decal component for this decal actor
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def decal(self) -> DecalComponent:
        r"""
        (DecalComponent):  [Read-Only] The decal component for this decal actor
        """
        ...
    def set_decal_material(self, new_decal_material: MaterialInterface) -> None:
        r"""
        x.set_decal_material(new_decal_material) -> None
        BEGIN DEPRECATED (use component functions now in level script)
        deprecated: Function 'SetDecalMaterial' is deprecated.
        
        Args:
            new_decal_material (MaterialInterface):
        """
        ...
    def get_decal_material(self) -> MaterialInterface:
        r"""
        x.get_decal_material() -> MaterialInterface
        Get Decal Material
        deprecated: Function 'GetDecalMaterial' is deprecated.
        
        Returns:
            MaterialInterface:
        """
        ...
    def create_dynamic_material_instance(self) -> MaterialInstanceDynamic:
        r"""
        x.create_dynamic_material_instance() -> MaterialInstanceDynamic
        Create Dynamic Material Instance
        deprecated: Function 'CreateDynamicMaterialInstance' is deprecated.
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...
    def create_mid_for_decal(self) -> MaterialInstanceDynamic:
        r"""
        deprecated: 'create_mid_for_decal' was renamed to 'create_dynamic_material_instance'.
        """
        ...

class DefaultPawn(Pawn):
    r"""
    DefaultPawn implements a simple Pawn with spherical collision and built-in flying movement.
    see: UFloatingPawnMovement
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DefaultPawn.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``add_default_movement_bindings`` (bool):  [Read-Write] If true, adds default input bindings for movement and camera look.
    - ``ai_controller_class`` (type(Class)):  [Read-Write] Default class to use when pawn is controlled by AI.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_possess_ai`` (AutoPossessAI):  [Read-Write] Determines when the Pawn creates and is possessed by an AI Controller (on level start, when spawned, etc).
      Only possible if AIControllerClassRef is set, and ignored if AutoPossessPlayer is enabled.
      see: AutoPossessPlayer
    - ``auto_possess_player`` (AutoReceiveInput):  [Read-Write] Determines which PlayerController, if any, should automatically possess the pawn when the level starts or when the pawn is spawned.
      see: AutoPossessAI
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``base_eye_height`` (float):  [Read-Write] Base eye height above collision center.
    - ``base_look_up_rate`` (float):  [Read-Only] Base lookup rate, in deg/sec. Other scaling may affect final lookup rate.
    - ``base_turn_rate`` (float):  [Read-Only] Base turn rate, in deg/sec. Other scaling may affect final turn rate.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_affect_navigation_generation`` (bool):  [Read-Write] If set to false (default) given pawn instance will never affect navigation generation (but components could).
      Setting it to true will result in using regular AActor's navigation relevancy
      calculation to check if this pawn instance should affect navigation generation.
      note: Use SetCanAffectNavigationGeneration() to change this value at runtime.
      note: Modifying this value at runtime will result in any navigation change only if runtime navigation generation is enabled.
      note: Override UpdateNavigationRelevance() to propagate the flag to the desired components.
      see: SetCanAffectNavigationGeneration(), UpdateNavigationRelevance()
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``collision_component`` (SphereComponent):  [Read-Only] DefaultPawn collision component
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``last_hit_by`` (Controller):  [Read-Write] Controller of the last Actor that caused us damage.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``mesh_component`` (StaticMeshComponent):  [Read-Only] The mesh associated with this Pawn.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``movement_component`` (PawnMovementComponent):  [Read-Only] DefaultPawn movement component
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_input_component_class`` (type(Class)):  [Read-Write] If set, then this InputComponent class will be used instead of the Input Settings' DefaultInputComponentClass
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_state`` (PlayerState):  [Read-Write] If Pawn is possessed by a player, points to its Player State.  Needed for network play as controllers are not replicated to clients.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``receive_controller_changed_delegate`` (PawnControllerChangedSignature):  [Read-Write] Event called after a pawn's controller has changed, on the server and owning client. This will happen at the same time as the delegate on GameInstance
    - ``receive_restarted_delegate`` (PawnRestartedSignature):  [Read-Write] Event called after a pawn has been restarted, usually by a possession change. This is called on the server for all pawns and the owning client for player pawns
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_controller_rotation_pitch`` (bool):  [Read-Write] If true, this Pawn's pitch will be updated to match the Controller's ControlRotation pitch, if controlled by a PlayerController.
    - ``use_controller_rotation_roll`` (bool):  [Read-Write] If true, this Pawn's roll will be updated to match the Controller's ControlRotation roll, if controlled by a PlayerController.
    - ``use_controller_rotation_yaw`` (bool):  [Read-Write] If true, this Pawn's yaw will be updated to match the Controller's ControlRotation yaw, if controlled by a PlayerController.
    """
    @property
    def base_turn_rate(self) -> float:
        r"""
        (float):  [Read-Only] Base turn rate, in deg/sec. Other scaling may affect final turn rate.
        """
        ...
    @property
    def base_look_up_rate(self) -> float:
        r"""
        (float):  [Read-Only] Base lookup rate, in deg/sec. Other scaling may affect final lookup rate.
        """
        ...
    @property
    def movement_component(self) -> PawnMovementComponent:
        r"""
        (PawnMovementComponent):  [Read-Only] DefaultPawn movement component
        """
        ...
    @property
    def default_pawn_movement(self) -> PawnMovementComponent:
        r"""
        deprecated: 'default_pawn_movement' was renamed to 'movement_component'.
        """
        ...
    @property
    def collision_component(self) -> SphereComponent:
        r"""
        (SphereComponent):  [Read-Only] DefaultPawn collision component
        """
        ...
    @property
    def mesh_component(self) -> StaticMeshComponent:
        r"""
        (StaticMeshComponent):  [Read-Only] The mesh associated with this Pawn.
        """
        ...
    @property
    def add_default_movement_bindings(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, adds default input bindings for movement and camera look.
        """
        ...
    def turn_at_rate(self, rate: float) -> None:
        r"""
        x.turn_at_rate(rate) -> None
        Called via input to turn at a given rate.
        
        Args:
            rate (float): This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
        """
        ...
    def move_up_world(self, val: float) -> None:
        r"""
        x.move_up_world(val) -> None
        Input callback to move up in world space (or down if Val is negative).
        see: APawn::AddMovementInput()
        
        Args:
            val (float): Amount of movement in the world up direction (or down if negative).
        """
        ...
    def move_right(self, val: float) -> None:
        r"""
        x.move_right(val) -> None
        Input callback to strafe right in local space (or left if Val is negative).
        see: APawn::AddMovementInput()
        
        Args:
            val (float): Amount of movement in the right direction (or left if negative).
        """
        ...
    def move_forward(self, val: float) -> None:
        r"""
        x.move_forward(val) -> None
        Input callback to move forward in local space (or backward if Val is negative).
        see: APawn::AddMovementInput()
        
        Args:
            val (float): Amount of movement in the forward direction (or backward if negative).
        """
        ...
    def look_up_at_rate(self, rate: float) -> None:
        r"""
        x.look_up_at_rate(rate) -> None
        Called via input to look up at a given rate (or down if Rate is negative).
        
        Args:
            rate (float): This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
        """
        ...

class PhysicsVolume(Volume):
    r"""
    PhysicsVolume: A bounding volume which affects actor physics.
    Each AActor is affected at any time by one PhysicsVolume.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``fluid_friction`` (float):  [Read-Write] This property controls the amount of friction applied by the volume as pawns using CharacterMovement move through it. The higher this value, the harder it will feel to move through
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_on_contact`` (bool):  [Read-Write] By default, the origin of an AActor must be inside a PhysicsVolume for it to affect the actor. However if this flag is true, the other actor only has to touch the volume to be affected by it.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``priority`` (int32):  [Read-Write] Determines which PhysicsVolume takes precedence if they overlap (higher number = higher priority).
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``terminal_velocity`` (float):  [Read-Write] Terminal velocity of pawns using CharacterMovement when falling.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``water_volume`` (bool):  [Read-Write] True if this volume contains a fluid like water
    """
    @property
    def terminal_velocity(self) -> float:
        r"""
        (float):  [Read-Write] Terminal velocity of pawns using CharacterMovement when falling.
        """
        ...
    @terminal_velocity.setter
    def terminal_velocity(self, value: float) -> None:
        ...
    @property
    def priority(self) -> int:
        r"""
        (int32):  [Read-Write] Determines which PhysicsVolume takes precedence if they overlap (higher number = higher priority).
        """
        ...
    @priority.setter
    def priority(self, value: int) -> None:
        ...
    @property
    def fluid_friction(self) -> float:
        r"""
        (float):  [Read-Write] This property controls the amount of friction applied by the volume as pawns using CharacterMovement move through it. The higher this value, the harder it will feel to move through
        """
        ...
    @fluid_friction.setter
    def fluid_friction(self, value: float) -> None:
        ...
    @property
    def water_volume(self) -> bool:
        r"""
        (bool):  [Read-Write] True if this volume contains a fluid like water
        """
        ...
    @water_volume.setter
    def water_volume(self, value: bool) -> None:
        ...
    @property
    def physics_on_contact(self) -> bool:
        r"""
        (bool):  [Read-Write] By default, the origin of an AActor must be inside a PhysicsVolume for it to affect the actor. However if this flag is true, the other actor only has to touch the volume to be affected by it.
        """
        ...
    @physics_on_contact.setter
    def physics_on_contact(self, value: bool) -> None:
        ...

class DynamicPhysicsVolume(PhysicsVolume):
    r"""
    deprecated: 'DynamicPhysicsVolume' was renamed to 'PhysicsVolume'.
    """
    ...

class DefaultPhysicsVolume(PhysicsVolume):
    r"""
    DefaultPhysicsVolume determines the physical effects an actor will experience if they are not inside any user specified PhysicsVolume
    see: APhysicsVolume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DefaultPhysicsVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``fluid_friction`` (float):  [Read-Write] This property controls the amount of friction applied by the volume as pawns using CharacterMovement move through it. The higher this value, the harder it will feel to move through
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_on_contact`` (bool):  [Read-Write] By default, the origin of an AActor must be inside a PhysicsVolume for it to affect the actor. However if this flag is true, the other actor only has to touch the volume to be affected by it.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``priority`` (int32):  [Read-Write] Determines which PhysicsVolume takes precedence if they overlap (higher number = higher priority).
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``terminal_velocity`` (float):  [Read-Write] Terminal velocity of pawns using CharacterMovement when falling.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``water_volume`` (bool):  [Read-Write] True if this volume contains a fluid like water
    """
    ...

class DialogueVoice(Object):
    r"""
    Dialogue Voice
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DialogueVoice.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``gender`` (GrammaticalGender):  [Read-Write]
    - ``plurality`` (GrammaticalNumber):  [Read-Write]
    """
    ...

class DialogueWave(Object):
    r"""
    Dialogue Wave
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DialogueWave.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``context_mappings`` (Array[DialogueContextMapping]):  [Read-Write] Mappings between dialogue contexts and associated soundwaves.
    - ``mature`` (bool):  [Read-Write] true if this dialogue is considered to contain mature/adult content.
    - ``override_subtitle_override`` (bool):  [Read-Write]
    - ``spoken_text`` (str):  [Read-Write] A localized version of the text that is actually spoken phonetically in the audio.
    - ``subtitle_override`` (str):  [Read-Write] A localized version of the subtitle text that should be displayed for this audio. By default this will be the same as the Spoken Text.
    - ``voice_actor_direction`` (str):  [Read-Write] Provides general notes to the voice actor intended to direct their performance, as well as contextual information to the translator.
    """
    @property
    def mature(self) -> bool:
        r"""
        (bool):  [Read-Only] true if this dialogue is considered to contain mature/adult content.
        """
        ...
    @property
    def override_subtitle_override(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def spoken_text(self) -> str:
        r"""
        (str):  [Read-Only] A localized version of the text that is actually spoken phonetically in the audio.
        """
        ...
    @property
    def subtitle_override(self) -> str:
        r"""
        (str):  [Read-Only] A localized version of the subtitle text that should be displayed for this audio. By default this will be the same as the Spoken Text.
        """
        ...

class DocumentationActor(Actor):
    r"""
    Documentation Actor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DocumentationActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``billboard`` (MaterialBillboardComponent):  [Read-Only]
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``document_link`` (str):  [Read-Write] Link to a help document.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def document_link(self) -> str:
        r"""
        (str):  [Read-Write] Link to a help document.
        """
        ...
    @document_link.setter
    def document_link(self, value: str) -> None:
        ...
    @property
    def billboard(self) -> MaterialBillboardComponent:
        r"""
        (MaterialBillboardComponent):  [Read-Only]
        """
        ...

class EngineElementsLibrary(BlueprintFunctionLibrary):
    r"""
    Engine Elements Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: EngineElementsLibrary.h
    
    """
    @classmethod
    def k2_acquire_editor_sm_instance_element_handle(cls, ism_component: InstancedStaticMeshComponent, instance_index: int, allow_create: bool = True) -> ScriptTypedElementHandle:
        r"""
        X.k2_acquire_editor_sm_instance_element_handle(ism_component, instance_index, allow_create=True) -> ScriptTypedElementHandle
        K2 Acquire Editor SMInstance Element Handle
        
        Args:
            ism_component (InstancedStaticMeshComponent): 
            instance_index (int32): 
            allow_create (bool): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...
    @classmethod
    def k2_acquire_editor_object_element_handle(cls, object: Object, allow_create: bool = True) -> ScriptTypedElementHandle:
        r"""
        X.k2_acquire_editor_object_element_handle(object, allow_create=True) -> ScriptTypedElementHandle
        K2 Acquire Editor Object Element Handle
        
        Args:
            object (Object): 
            allow_create (bool): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...
    @classmethod
    def k2_acquire_editor_component_element_handle(cls, component: ActorComponent, allow_create: bool = True) -> ScriptTypedElementHandle:
        r"""
        X.k2_acquire_editor_component_element_handle(component, allow_create=True) -> ScriptTypedElementHandle
        K2 Acquire Editor Component Element Handle
        
        Args:
            component (ActorComponent): 
            allow_create (bool): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...
    @classmethod
    def k2_acquire_editor_actor_element_handle(cls, actor: Actor, allow_create: bool = True) -> ScriptTypedElementHandle:
        r"""
        X.k2_acquire_editor_actor_element_handle(actor, allow_create=True) -> ScriptTypedElementHandle
        K2 Acquire Editor Actor Element Handle
        
        Args:
            actor (Actor): 
            allow_create (bool): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...

class TypedElementCommonActions(Object):
    r"""
    A utility to handle higher-level common actions, but default via UTypedElementWorldInterface,
    but asset editors can customize this behavior via FTypedElementCommonActionsCustomization.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TypedElementCommonActions.h
    
    """
    def paste_normalized_elements_from_string(self, element_list: TypedElementList, world: World, paste_option: TypedElementPasteOptions, input_string: str) -> Array[ScriptTypedElementHandle]:
        r"""
        x.paste_normalized_elements_from_string(element_list, world, paste_option, input_string) -> Array[ScriptTypedElementHandle]
        Paste any elements from the given string
        note: This list should have been pre-normalized via UTypedElementSelectionSet::GetNormalizedSelection or UTypedElementSelectionSet::GetNormalizedElementList.
        
        Args:
            element_list (TypedElementList): 
            world (World): 
            paste_option (TypedElementPasteOptions): 
            input_string (str): 
        
        Returns:
            Array[ScriptTypedElementHandle]:
        """
        ...
    def paste_elements_from_string(self, selection_set: TypedElementSelectionSet, world: World, paste_option: TypedElementPasteOptions, input_string: str) -> Array[ScriptTypedElementHandle]:
        r"""
        x.paste_elements_from_string(selection_set, world, paste_option, input_string) -> Array[ScriptTypedElementHandle]
        Paste any elements from the given string
        note: Internally this just calls PasteNormalizedElements on the result of UTypedElementSelectionSet::GetNormalizedSelection.
        
        Args:
            selection_set (TypedElementSelectionSet): 
            world (World): 
            paste_option (TypedElementPasteOptions): 
            input_string (str): 
        
        Returns:
            Array[ScriptTypedElementHandle]:
        """
        ...
    def paste_normalized_elements(self, element_list: TypedElementList, world: World, paste_option: TypedElementPasteOptions) -> Array[ScriptTypedElementHandle]:
        r"""
        x.paste_normalized_elements(element_list, world, paste_option) -> Array[ScriptTypedElementHandle]
        Paste any elements from the clipboard
        note: This list should have been pre-normalized via UTypedElementSelectionSet::GetNormalizedSelection or UTypedElementSelectionSet::GetNormalizedElementList.
        
        Args:
            element_list (TypedElementList): 
            world (World): 
            paste_option (TypedElementPasteOptions): 
        
        Returns:
            Array[ScriptTypedElementHandle]:
        """
        ...
    def paste_elements(self, selection_set: TypedElementSelectionSet, world: World, paste_option: TypedElementPasteOptions) -> Array[ScriptTypedElementHandle]:
        r"""
        x.paste_elements(selection_set, world, paste_option) -> Array[ScriptTypedElementHandle]
        Paste any elements from the clipboard
        note: Internally this just calls PasteNormalizedElements on the result of UTypedElementSelectionSet::GetNormalizedSelection.
        
        Args:
            selection_set (TypedElementSelectionSet): 
            world (World): 
            paste_option (TypedElementPasteOptions): 
        
        Returns:
            Array[ScriptTypedElementHandle]:
        """
        ...
    def duplicate_selected_elements(self, selection_set: TypedElementSelectionSet, world: World, location_offset: Vector) -> Array[ScriptTypedElementHandle]:
        r"""
        x.duplicate_selected_elements(selection_set, world, location_offset) -> Array[ScriptTypedElementHandle]
        Duplicate any elements from the given selection set that can be duplicated.
        note: Internally this just calls DuplicateNormalizedElements on the result of UTypedElementSelectionSet::GetNormalizedSelection.
        
        Args:
            selection_set (TypedElementSelectionSet): 
            world (World): 
            location_offset (Vector): 
        
        Returns:
            Array[ScriptTypedElementHandle]:
        """
        ...
    def duplicate_normalized_elements(self, element_list: TypedElementList, world: World, location_offset: Vector) -> Array[ScriptTypedElementHandle]:
        r"""
        x.duplicate_normalized_elements(element_list, world, location_offset) -> Array[ScriptTypedElementHandle]
        Duplicate any elements from the given list that can be duplicated.
        note: This list should have been pre-normalized via UTypedElementSelectionSet::GetNormalizedSelection or UTypedElementSelectionSet::GetNormalizedElementList.
        
        Args:
            element_list (TypedElementList): 
            world (World): 
            location_offset (Vector): 
        
        Returns:
            Array[ScriptTypedElementHandle]:
        """
        ...
    def delete_selected_elements(self, selection_set: TypedElementSelectionSet, world: World, deletion_options: TypedElementDeletionOptions) -> bool:
        r"""
        x.delete_selected_elements(selection_set, world, deletion_options) -> bool
        Delete any elements from the given selection set that can be deleted.
        note: Internally this just calls DeleteNormalizedElements on the result of UTypedElementSelectionSet::GetNormalizedSelection.
        
        Args:
            selection_set (TypedElementSelectionSet): 
            world (World): 
            deletion_options (TypedElementDeletionOptions): 
        
        Returns:
            bool:
        """
        ...
    def delete_normalized_elements(self, element_list: TypedElementList, world: World, selection_set: TypedElementSelectionSet, deletion_options: TypedElementDeletionOptions) -> bool:
        r"""
        x.delete_normalized_elements(element_list, world, selection_set, deletion_options) -> bool
        Delete any elements from the given list that can be deleted.
        note: This list should have been pre-normalized via UTypedElementSelectionSet::GetNormalizedSelection or UTypedElementSelectionSet::GetNormalizedElementList.
        
        Args:
            element_list (TypedElementList): 
            world (World): 
            selection_set (TypedElementSelectionSet): 
            deletion_options (TypedElementDeletionOptions): 
        
        Returns:
            bool:
        """
        ...
    def copy_selected_elements_to_string(self, selection_set: TypedElementSelectionSet) -> Optional[str]:
        r"""
        x.copy_selected_elements_to_string(selection_set) -> str or None
        Copy any elements from the given selection set that can be copied into the string
        note: Internally this just calls CopyNormalizedElements on the result of UTypedElementSelectionSet::GetNormalizedSelection.
        
        Args:
            selection_set (TypedElementSelectionSet): 
        
        Returns:
            str or None: 
        
            output_string (str):
        """
        ...
    def copy_selected_elements(self, selection_set: TypedElementSelectionSet) -> bool:
        r"""
        x.copy_selected_elements(selection_set) -> bool
        Copy any elements from the given selection set that can be copied into the clipboard
        note: Internally this just calls CopyNormalizedElements on the result of UTypedElementSelectionSet::GetNormalizedSelection.
        
        Args:
            selection_set (TypedElementSelectionSet): 
        
        Returns:
            bool:
        """
        ...
    def copy_normalized_elements_to_string(self, element_list: TypedElementList) -> Optional[str]:
        r"""
        x.copy_normalized_elements_to_string(element_list) -> str or None
        * Copy any elements from the given selection set that can be copied into the clipboard.
        *
        note: This list should have been pre-normalized via UTypedElementSelectionSet::GetNormalizedSelection or UTypedElementSelectionSet::GetNormalizedElementList.
        
        Args:
            element_list (TypedElementList): 
        
        Returns:
            str or None: 
        
            output_string (str):
        """
        ...
    def copy_normalized_elements(self, element_list: TypedElementList) -> bool:
        r"""
        x.copy_normalized_elements(element_list) -> bool
        * Copy any elements from the given selection set that can be copied into the clipboard.
        *
        note: This list should have been pre-normalized via UTypedElementSelectionSet::GetNormalizedSelection or UTypedElementSelectionSet::GetNormalizedElementList.
        
        Args:
            element_list (TypedElementList): 
        
        Returns:
            bool:
        """
        ...

class TypedElementWorldInterface(Interface):
    r"""
    Typed Element World Interface
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TypedElementWorldInterface.h
    
    """
    def set_world_transform(self, element_handle: ScriptTypedElementHandle, transform: Transform) -> bool:
        r"""
        x.set_world_transform(element_handle, transform) -> bool
        Attempt to set the transform of this element within its owner world.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            transform (Transform): 
        
        Returns:
            bool:
        """
        ...
    def set_relative_transform(self, element_handle: ScriptTypedElementHandle, transform: Transform) -> bool:
        r"""
        x.set_relative_transform(element_handle, transform) -> bool
        Attempt to set the transform of this element relative to its parent.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            transform (Transform): 
        
        Returns:
            bool:
        """
        ...
    def set_pivot_offset(self, element_handle: ScriptTypedElementHandle, pivot_offset: Vector) -> bool:
        r"""
        x.set_pivot_offset(element_handle, pivot_offset) -> bool
        Attempt to set the local space offset of this element that should be added to its pivot location.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            pivot_offset (Vector): 
        
        Returns:
            bool:
        """
        ...
    def promote_element(self, element_handle: ScriptTypedElementHandle, override_world: World = None) -> ScriptTypedElementHandle:
        r"""
        x.promote_element(element_handle, override_world=None) -> ScriptTypedElementHandle
        Promote an element when possible
        Generally available when the element is a lighter representation of another element.
        Like an instance for example.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            override_world (World): Override the world in which the promotion might create new elements. Leave it to null to use the world from the handle.
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...
    def notify_movement_started(self, element_handle: ScriptTypedElementHandle) -> None:
        r"""
        x.notify_movement_started(element_handle) -> None
        Notify that this element is about to be moved.
        
        Args:
            element_handle (ScriptTypedElementHandle):
        """
        ...
    def notify_movement_ongoing(self, element_handle: ScriptTypedElementHandle) -> None:
        r"""
        x.notify_movement_ongoing(element_handle) -> None
        Notify that this element is currently being moved.
        
        Args:
            element_handle (ScriptTypedElementHandle):
        """
        ...
    def notify_movement_ended(self, element_handle: ScriptTypedElementHandle) -> None:
        r"""
        x.notify_movement_ended(element_handle) -> None
        Notify that this element is done being moved.
        
        Args:
            element_handle (ScriptTypedElementHandle):
        """
        ...
    def is_template_element(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.is_template_element(element_handle) -> bool
        Is this element considered a template within its world (eg, a CDO or archetype).
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    def get_world_transform(self, element_handle: ScriptTypedElementHandle) -> Optional[Transform]:
        r"""
        x.get_world_transform(element_handle) -> Transform or None
        Get the transform of this element within its owner world, if any.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            Transform or None: 
        
            out_transform (Transform):
        """
        ...
    def get_relative_transform(self, element_handle: ScriptTypedElementHandle) -> Optional[Transform]:
        r"""
        x.get_relative_transform(element_handle) -> Transform or None
        Get the transform of this element relative to its parent, if any.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            Transform or None: 
        
            out_transform (Transform):
        """
        ...
    def get_pivot_offset(self, element_handle: ScriptTypedElementHandle) -> Optional[Vector]:
        r"""
        x.get_pivot_offset(element_handle) -> Vector or None
        Get the local space offset of this element that should be added to its pivot location, if any.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            Vector or None: 
        
            out_pivot_offset (Vector):
        """
        ...
    def get_owner_world(self, element_handle: ScriptTypedElementHandle) -> World:
        r"""
        x.get_owner_world(element_handle) -> World
        Get the owner world associated with this element, if any.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            World:
        """
        ...
    def get_owner_level(self, element_handle: ScriptTypedElementHandle) -> Level:
        r"""
        x.get_owner_level(element_handle) -> Level
        Get the owner level associated with this element, if any.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            Level:
        """
        ...
    def get_bounds(self, element_handle: ScriptTypedElementHandle) -> Optional[BoxSphereBounds]:
        r"""
        x.get_bounds(element_handle) -> BoxSphereBounds or None
        Get the bounds of this element, if any.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            BoxSphereBounds or None: 
        
            out_bounds (BoxSphereBounds):
        """
        ...
    def duplicate_element(self, element_handle: ScriptTypedElementHandle, world: World, location_offset: Vector) -> ScriptTypedElementHandle:
        r"""
        x.duplicate_element(element_handle, world, location_offset) -> ScriptTypedElementHandle
        Duplicate the given element.
        note: Default version calls DuplicateElements with a single element.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            world (World): 
            location_offset (Vector): 
        
        Returns:
            ScriptTypedElementHandle:
        """
        ...
    def delete_element(self, element_handle: ScriptTypedElementHandle, world: World, selection_set: TypedElementSelectionSet, deletion_options: TypedElementDeletionOptions) -> bool:
        r"""
        x.delete_element(element_handle, world, selection_set, deletion_options) -> bool
        Delete the given element.
        note: Default version calls DeleteElements with a single element.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            world (World): 
            selection_set (TypedElementSelectionSet): 
            deletion_options (TypedElementDeletionOptions): 
        
        Returns:
            bool:
        """
        ...
    def can_scale_element(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.can_scale_element(element_handle) -> bool
        Can the given element be scaled?
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    def can_promote_element(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.can_promote_element(element_handle) -> bool
        Can the element be promoted
        Generally available when the element is a lighter representation of another element.
        Like an instance for example.
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    def can_move_element(self, element_handle: ScriptTypedElementHandle, world_type: TypedElementWorldType) -> bool:
        r"""
        x.can_move_element(element_handle, world_type) -> bool
        Can the given element be moved within the world?
        
        Args:
            element_handle (ScriptTypedElementHandle): 
            world_type (TypedElementWorldType): 
        
        Returns:
            bool:
        """
        ...
    def can_edit_element(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.can_edit_element(element_handle) -> bool
        Can this element actually be edited in the world?
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    def can_duplicate_element(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.can_duplicate_element(element_handle) -> bool
        Can the given element be duplicated?
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...
    def can_delete_element(self, element_handle: ScriptTypedElementHandle) -> bool:
        r"""
        x.can_delete_element(element_handle) -> bool
        Can the given element be deleted?
        
        Args:
            element_handle (ScriptTypedElementHandle): 
        
        Returns:
            bool:
        """
        ...

class CancellableAsyncAction(BlueprintAsyncActionBase):
    r"""
    base class for asynchronous actions that can be spawned from UK2Node_AsyncAction or C++ code.
    These actions register themselves with the game instance and need to be explicitly canceled or ended normally to go away.
    The ExposedAsyncProxy metadata specifies the blueprint node will return this object for later canceling.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CancellableAsyncAction.h
    
    """
    def is_active(self) -> bool:
        r"""
        x.is_active() -> bool
        Returns true if this action is still active and has not completed or been cancelled
        
        Returns:
            bool:
        """
        ...
    def cancel(self) -> None:
        r"""
        x.cancel() -> None
        Cancel an asynchronous action, this attempts to cancel any lower level processes and also prevents delegates from being fired
        """
        ...

class ServerStatReplicator(Info):
    r"""
    Class used to replicate server "stat net" data over. For server only values, the client data is
    is overwritten when bUpdateStatNet == true. For data that both the client and server set, the server
    data will only overwrite if bUpdateStatNet == true && bOverwriteClientStats == true.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ServerStatReplicator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``overwrite_client_stats`` (bool):  [Read-Write] Whether to overwrite client data stat net with data from the server or not
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``update_stat_net`` (bool):  [Read-Write] Whether to update stat net with data from the server or not
    """
    ...

class SystemTimeTimecodeProvider(TimecodeProvider):
    r"""
    Converts the current system time to timecode, relative to a provided frame rate.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SystemTimeTimecodeProvider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_delay`` (float):  [Read-Write] Number of frames to subtract from the qualified frame time when GetDelayedQualifiedFrameTime or GetDelayedTimecode is called.
      see: GetDelayedQualifiedFrameTime, GetDelayedTimecode
    - ``frame_rate`` (FrameRate):  [Read-Write] The frame rate at which the timecode value will be generated.
    - ``generate_full_frame`` (bool):  [Read-Write] When generating frame time, should we generate full frame without subframe value.
    - ``use_high_performance_clock`` (bool):  [Read-Write] Use the high performance clock instead of the system time to generate the timecode value.
      Using the high performance clock is faster but will make the value drift over time.
    """
    ...

class ViewportStatsSubsystem(WorldSubsystem):
    r"""
    The Viewport Stats Subsystem offers the ability to add messages to the current
    viewport such as "LIGHTING NEEDS TO BE REBUILT" and "BLUEPRINT COMPILE ERROR".
    
    Example usage:
    
         if (UViewportStatsSubsystem* ViewportSubsystem = GetWorld()->GetSubsystem<UViewportStatsSubsystem>())
         {
                 // Bind a member function delegate to the subsystem...
                 FViewportDisplayCallback Callback;
                 Callback.BindDynamic(this, &UCustomClass::DisplayViewportMessage);
                 ViewportSubsystem->AddDisplayDelegate(Callback);
    
                 // ... or use inline lambda functions
                 ViewportSubsystem->AddDisplayDelegate([](FText& OutText, FLinearColor& OutColor)
                 {
                         // Some kind of state management
                         OutText = NSLOCTEXT("FooNamespace", "Blarg", "Display message here");
                         OutColor = FLinearColor::Red;
                         return bShouldDisplay;
                 });
         }
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ViewportStatsSubsystem.h
    
    """
    def remove_display_delegate(self, index_to_remove: int) -> None:
        r"""
        x.remove_display_delegate(index_to_remove) -> None
        Remove a callback function from the display subsystem
        
        Args:
            index_to_remove (int32): The index in the DisplayDelegates array to remove. This is the value returned from AddDisplayDelegate.
        """
        ...
    def add_timed_display(self, text: Text, color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000, display_offset: Vector2D = [0.000000, 0.000000]) -> None:
        r"""
        x.add_timed_display(text, color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000, display_offset=[0.000000, 0.000000]) -> None
        Add a message to be displayed on the viewport of this world
        
        Args:
            text (Text): The text to be displayed
            color (LinearColor): Color of the text to be displayed
            duration (float): How long the text will be on screen, if 0 then it will stay indefinitely
            display_offset (Vector2D): A position offset that the message should use when displayed.
        """
        ...
    def add_display_delegate(self, delegate: ViewportDisplayCallback) -> int:
        r"""
        x.add_display_delegate(delegate) -> int32
        Add a dynamic delegate to the display subsystem.
        
        Args:
            delegate (ViewportDisplayCallback): 
        
        Returns:
            int32:
        """
        ...

class FloatingPawnMovement(PawnMovementComponent):
    r"""
    FloatingPawnMovement is a movement component that provides simple movement for any Pawn class.
    Limits on speed and acceleration are provided, while gravity is not implemented.
    
    Normally the root component of the owning actor is moved, however another component may be selected (see SetUpdatedComponent()).
    During swept (non-teleporting) movement only collision of UpdatedComponent is considered, attached components will teleport to the end location ignoring collision.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: FloatingPawnMovement.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``acceleration`` (float):  [Read-Write] Acceleration applied by input (rate of change of velocity)
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_register_physics_volume_updates`` (bool):  [Read-Write] If true, then applies the value of bComponentShouldUpdatePhysicsVolume to the UpdatedComponent. If false, will not change bShouldUpdatePhysicsVolume on the UpdatedComponent at all.
      see: bComponentShouldUpdatePhysicsVolume
    - ``auto_register_updated_component`` (bool):  [Read-Write] If true, registers the owner's Root component as the UpdatedComponent if there is not one currently assigned.
    - ``auto_update_tick_registration`` (bool):  [Read-Write] If true, whenever the updated component is changed, this component will enable or disable its tick dependent on whether it has something to update.
      This will NOT enable tick at startup if bAutoActivate is false, because presumably you have a good reason for not wanting it to start ticking initially.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_should_update_physics_volume`` (bool):  [Read-Write] If true, enables bShouldUpdatePhysicsVolume on the UpdatedComponent during initialization from SetUpdatedComponent(), otherwise disables such updates.
      Only enabled if bAutoRegisterPhysicsVolumeUpdates is true.
      WARNING: UpdatePhysicsVolume is potentially expensive if overlap events are also *disabled* because it requires a separate query against all physics volumes in the world.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_to_plane`` (bool):  [Read-Write] If true, movement will be constrained to a plane.
      see: PlaneConstraintNormal, PlaneConstraintOrigin, PlaneConstraintAxisSetting
    - ``deceleration`` (float):  [Read-Write] Deceleration applied when there is no input (rate of change of velocity)
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``fixed_path_braking_distance`` (float):  [Read-Write] Braking distance override used with acceleration driven path following (bUseAccelerationForPaths)
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``max_speed`` (float):  [Read-Write] Maximum velocity magnitude allowed for the controlled Pawn.
    - ``nav_agent_props`` (NavAgentProperties):  [Read-Write] Properties that define how the component can move.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``plane_constraint_axis_setting`` (PlaneConstraintAxisSetting):  [Read-Write] Setting that controls behavior when movement is restricted to a 2D plane defined by a specific axis/normal,
      so that movement along the locked axis is not be possible.
      see: SetPlaneConstraintAxisSetting
    - ``plane_constraint_normal`` (Vector):  [Read-Write] The normal or axis of the plane that constrains movement, if bConstrainToPlane is enabled.
      If for example you wanted to constrain movement to the X-Z plane (so that Y cannot change), the normal would be set to X=0 Y=1 Z=0.
      This is recalculated whenever PlaneConstraintAxisSetting changes. It is normalized once the component is registered with the game world.
      see: bConstrainToPlane, SetPlaneConstraintNormal(), SetPlaneConstraintFromVectors()
    - ``plane_constraint_origin`` (Vector):  [Read-Write] The origin of the plane that constrains movement, if plane constraint is enabled.
      This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
      see: bConstrainToPlane, SetPlaneConstraintOrigin().
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``snap_to_plane_at_start`` (bool):  [Read-Write] If true and plane constraints are enabled, then the updated component will be snapped to the plane when first attached.
    - ``tick_before_owner`` (bool):  [Read-Write] If true, after registration we will add a tick dependency to tick before our owner (if we can both tick).
      This is important when our tick causes an update in the owner's position, so that when the owner ticks it uses the most recent position without lag.
      Disabling this can improve performance if both objects tick but the order of ticks doesn't matter.
    - ``turning_boost`` (float):  [Read-Write] Setting affecting extra force applied when changing direction, making turns have less drift and become more responsive.
      Velocity magnitude is not allowed to increase, that only happens due to normal acceleration. It may decrease with large direction changes.
      Larger values apply extra force to reach the target direction more quickly, while a zero value disables any extra turn force.
    - ``update_nav_agent_with_owners_collision`` (bool):  [Read-Write] If set to true NavAgentProps' radius and height will be updated with Owner's collision capsule size
    - ``update_only_if_rendered`` (bool):  [Read-Write] If true, skips TickComponent() if UpdatedComponent was not recently rendered.
    - ``updated_component`` (SceneComponent):  [Read-Write] The component we move and update.
      If this is null at startup and bAutoRegisterUpdatedComponent is true, the owning Actor's root component will automatically be set as our UpdatedComponent at startup.
      see: bAutoRegisterUpdatedComponent, SetUpdatedComponent(), UpdatedPrimitive
    - ``updated_primitive`` (PrimitiveComponent):  [Read-Write] UpdatedComponent, cast as a UPrimitiveComponent. May be invalid if UpdatedComponent was null or not a UPrimitiveComponent.
    - ``use_acceleration_for_paths`` (bool):  [Read-Write] If set, pathfollowing will control character movement via acceleration values. If false, it will set velocities directly.
    - ``use_fixed_braking_distance_for_paths`` (bool):  [Read-Write] If set, FixedPathBrakingDistance will be used for path following deceleration
    - ``velocity`` (Vector):  [Read-Write] Current velocity of updated component.
    """
    @property
    def max_speed(self) -> float:
        r"""
        (float):  [Read-Write] Maximum velocity magnitude allowed for the controlled Pawn.
        """
        ...
    @max_speed.setter
    def max_speed(self, value: float) -> None:
        ...
    @property
    def acceleration(self) -> float:
        r"""
        (float):  [Read-Write] Acceleration applied by input (rate of change of velocity)
        """
        ...
    @acceleration.setter
    def acceleration(self, value: float) -> None:
        ...
    @property
    def accel_rate(self) -> float:
        r"""
        deprecated: 'accel_rate' was renamed to 'acceleration'.
        """
        ...
    @accel_rate.setter
    def accel_rate(self, value: float) -> None:
        ...
    @property
    def deceleration(self) -> float:
        r"""
        (float):  [Read-Write] Deceleration applied when there is no input (rate of change of velocity)
        """
        ...
    @deceleration.setter
    def deceleration(self, value: float) -> None:
        ...
    @property
    def decel_rate(self) -> float:
        r"""
        deprecated: 'decel_rate' was renamed to 'deceleration'.
        """
        ...
    @decel_rate.setter
    def decel_rate(self, value: float) -> None:
        ...
    @property
    def turning_boost(self) -> float:
        r"""
        (float):  [Read-Write] Setting affecting extra force applied when changing direction, making turns have less drift and become more responsive.
        Velocity magnitude is not allowed to increase, that only happens due to normal acceleration. It may decrease with large direction changes.
        Larger values apply extra force to reach the target direction more quickly, while a zero value disables any extra turn force.
        """
        ...
    @turning_boost.setter
    def turning_boost(self, value: float) -> None:
        ...

class DefaultPawnMovement(FloatingPawnMovement):
    r"""
    deprecated: 'DefaultPawnMovement' was renamed to 'FloatingPawnMovement'.
    """
    ...

class Font(Object):
    r"""
    A font object, for use by Slate, UMG, and Canvas.
    
    A font can either be:
      * Runtime cached - The font contains a series of TTF files that combine to form a composite font. The glyphs are cached on demand when required at runtime.
      * Offline cached - The font contains a series of textures containing pre-baked cached glyphs and their associated texture coordinates.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Font.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ascent`` (float):  [Read-Write]
      todo: document
    - ``characters`` (Array[FontCharacter]):  [Read-Write] List of characters in the font.  For a MultiFont, this will include all characters in all sub-fonts!  Thus,
                    the number of characters in this array isn't necessary the number of characters available in the font
    - ``composite_font`` (CompositeFont):  [Read-Write] Embedded composite font data
    - ``descent`` (float):  [Read-Write]
      todo: document
    - ``em_scale`` (float):  [Read-Write] Font metrics.
    - ``font_cache_type`` (FontCacheType):  [Read-Write] What kind of font caching should we use? This controls which options we see
    - ``font_rasterization_mode`` (FontRasterizationMode):  [Read-Write] The preferred rasterization method for this font (enable / disable MSDF)
    - ``import_options`` (FontImportOptionsData):  [Read-Write] Options used when importing this font
    - ``kerning`` (int32):  [Read-Write] Default horizontal spacing between characters when rendering text with this font
    - ``leading`` (float):  [Read-Write]
      todo: document
    - ``legacy_font_name`` (Name):  [Read-Write] The default font name to use for legacy Canvas APIs that don't specify a font name
    - ``legacy_font_size`` (int32):  [Read-Write] The default size of the font used for legacy Canvas APIs that don't specify a font size
    - ``scaling_factor`` (float):  [Read-Write] Scale to apply to the font.
    - ``sdf_settings`` (FontSdfSettings):  [Read-Write] Settings for rendering this font using the sdf pipeline
    """
    ...

class FontFace(Object):
    r"""
    A font face asset contains the raw payload data for a source TTF/OTF file as used by FreeType.
    During cook this asset type generates a ".ufont" file containing the raw payload data (unless loaded "Inline").
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: FontFace.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ascend_overridden_value`` (int32):  [Read-Write] The typographic ascender of the face, expressed in font units.
    - ``descend_overridden_value`` (int32):  [Read-Write] The typographic ascender of the face, expressed in font units.
    - ``hinting`` (FontHinting):  [Read-Write] The hinting algorithm to use with the font face.
    - ``is_ascend_overridden`` (bool):  [Read-Write] Activate this option to use the specified ascend value instead of the value from the font.
    - ``is_descend_overridden`` (bool):  [Read-Write] Activate this option to use the specified descend value instead of the value from the font.
    - ``layout_method`` (FontLayoutMethod):  [Read-Write] Which method should we use when laying out the font? Try changing this if you notice clipping or height issues with your font.
    - ``loading_policy`` (FontLoadingPolicy):  [Read-Write] Enum controlling how this font face should be loaded at runtime. See the enum for more explanations of the options.
    - ``source_filename`` (str):  [Read-Write] The filename of the font face we were created from. This may not always exist on disk, as we may have previously loaded and cached the font data inside this asset.
    - ``sub_faces`` (Array[str]):  [Read-Only] Transient cache of the sub-faces available within this face
    """
    @property
    def source_filename(self) -> str:
        r"""
        (str):  [Read-Only] The filename of the font face we were created from. This may not always exist on disk, as we may have previously loaded and cached the font data inside this asset.
        """
        ...
    @property
    def hinting(self) -> FontHinting:
        r"""
        (FontHinting):  [Read-Write] The hinting algorithm to use with the font face.
        """
        ...
    @hinting.setter
    def hinting(self, value: FontHinting) -> None:
        ...
    @property
    def loading_policy(self) -> FontLoadingPolicy:
        r"""
        (FontLoadingPolicy):  [Read-Write] Enum controlling how this font face should be loaded at runtime. See the enum for more explanations of the options.
        """
        ...
    @loading_policy.setter
    def loading_policy(self, value: FontLoadingPolicy) -> None:
        ...
    @property
    def layout_method(self) -> FontLayoutMethod:
        r"""
        (FontLayoutMethod):  [Read-Write] Which method should we use when laying out the font? Try changing this if you notice clipping or height issues with your font.
        """
        ...
    @layout_method.setter
    def layout_method(self, value: FontLayoutMethod) -> None:
        ...

class AsyncActionHandleSaveGame(BlueprintAsyncActionBase):
    r"""
    Async action to handle async load/save of a USaveGame. This can be subclassed by a specific game
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncActionHandleSaveGame.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``completed`` (OnAsyncHandleSaveGame):  [Read-Write] Delegate called when the save/load completes
    """
    @property
    def completed(self) -> OnAsyncHandleSaveGame:
        r"""
        (OnAsyncHandleSaveGame):  [Read-Write] Delegate called when the save/load completes
        """
        ...
    @completed.setter
    def completed(self, value: OnAsyncHandleSaveGame) -> None:
        ...

class ForceFeedbackEffect(Object):
    r"""
    A predefined force-feedback effect to be played on a controller
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ForceFeedbackEffect.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_details`` (Array[ForceFeedbackChannelDetails]):  [Read-Write]
    - ``device_properties`` (Array[InputDeviceProperty]):  [Read-Write] A map of input device properties that we want to set while this effect is playing
    - ``duration`` (float):  [Read-Only] Duration of force feedback pattern in seconds.
    - ``per_device_overrides`` (Map[Name, ForceFeedbackEffectOverridenChannelDetails]):  [Read-Write] A map of platform name -> ForceFeedback channel details
    """
    @property
    def duration(self) -> float:
        r"""
        (float):  [Read-Only] Duration of force feedback pattern in seconds.
        """
        ...

class InputDeviceProperty(Object):
    r"""
    Base class that represents a single Input Device Property. An Input Device Property
    represents a feature that can be set on an input device. Things like what color a
    light is, advanced rumble patterns, or trigger haptics.
    
    This top level object can then be evaluated at a specific time to create a lower level
    FInputDeviceProperty, which the IInputInterface implementation can interpret however it desires.
    
    The behavior of device properties can vary depending on the current platform. Some platforms may not
    support certain device properties. An older gamepad may not have any advanced trigger haptics for
    example.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``property_duration`` (float):  [Read-Only] The duration that this device property should last. Override this if your property has any dynamic curves
      to be the max time range.
      
      A duration of 0 means that the device property will be treated as a "One Shot" effect, being applied once
      before being removed by the Input Device Subsystem.
    """
    @property
    def property_duration(self) -> float:
        r"""
        (float):  [Read-Only] The duration that this device property should last. Override this if your property has any dynamic curves
        to be the max time range.
        
        A duration of 0 means that the device property will be treated as a "One Shot" effect, being applied once
        before being removed by the Input Device Subsystem.
        """
        ...
    def reset_device_property(self, platform_user: PlatformUserId, device_id: InputDeviceId, force_reset: bool) -> None:
        r"""
        x.reset_device_property(platform_user, device_id, force_reset) -> None
        Reset the current device property. Provides an opportunity to reset device state after evaluation is complete.
        If overriding in Blueprints, make sure to call the parent function!
        
        Args:
            platform_user (PlatformUserId): The platform user that should receive this device property change
            device_id (InputDeviceId): 
            force_reset (bool):
        """
        ...
    def evaluate_device_property(self, platform_user: PlatformUserId, device_id: InputDeviceId, delta_time: float, duration: float) -> None:
        r"""
        x.evaluate_device_property(platform_user, device_id, delta_time, duration) -> None
        Evaluate this device property for a given duration.
        If overriding in Blueprints, make sure to call the parent function!
        
        Args:
            platform_user (PlatformUserId): The platform user that should receive this device property change
            device_id (InputDeviceId): 
            delta_time (float): Delta time
            duration (float): The number of seconds that this property has been active. Use this to get things like curve data over time.
        """
        ...

class ColorInputDeviceProperty(InputDeviceProperty):
    r"""
    Set the color of an Input Device to a static color. This will NOT reset the device color when the property
    is done evaluating. You can think of this as a "One Shot" effect, where you set the device property color.
    
    NOTE: This property has platform specific implementations and may behave differently per platform.
    See the docs for more details on each platform.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_data`` (DeviceColorData):  [Read-Write] Default color data that will be used by default. Device Specific overrides will be used when the current input device matches
    - ``device_override_data`` (Map[Name, DeviceColorData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
    - ``property_duration`` (float):  [Read-Only] The duration that this device property should last. Override this if your property has any dynamic curves
      to be the max time range.
      
      A duration of 0 means that the device property will be treated as a "One Shot" effect, being applied once
      before being removed by the Input Device Subsystem.
    """
    @property
    def color_data(self) -> DeviceColorData:
        r"""
        (DeviceColorData):  [Read-Write] Default color data that will be used by default. Device Specific overrides will be used when the current input device matches
        """
        ...
    @color_data.setter
    def color_data(self, value: DeviceColorData) -> None:
        ...
    @property
    def device_override_data(self) -> Map[Name, DeviceColorData]:
        r"""
        (Map[Name, DeviceColorData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
        """
        ...
    @device_override_data.setter
    def device_override_data(self, value: Map[Name, DeviceColorData]) -> None:
        ...

class ColorInputDeviceCurveProperty(InputDeviceProperty):
    r"""
    A property that can be used to change the color of an input device's light over time with a curve
    
    NOTE: This property has platform specific implementations and may behave differently per platform.
    See the docs for more details on each platform.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_data`` (DeviceColorCurveData):  [Read-Write] Default color data that will be used by default. Device Specific overrides will be used when the current input device matches
    - ``device_override_data`` (Map[Name, DeviceColorCurveData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
    - ``property_duration`` (float):  [Read-Only] The duration that this device property should last. Override this if your property has any dynamic curves
      to be the max time range.
      
      A duration of 0 means that the device property will be treated as a "One Shot" effect, being applied once
      before being removed by the Input Device Subsystem.
    """
    @property
    def color_data(self) -> DeviceColorCurveData:
        r"""
        (DeviceColorCurveData):  [Read-Write] Default color data that will be used by default. Device Specific overrides will be used when the current input device matches
        """
        ...
    @color_data.setter
    def color_data(self, value: DeviceColorCurveData) -> None:
        ...
    @property
    def device_override_data(self) -> Map[Name, DeviceColorCurveData]:
        r"""
        (Map[Name, DeviceColorCurveData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
        """
        ...
    @device_override_data.setter
    def device_override_data(self, value: Map[Name, DeviceColorCurveData]) -> None:
        ...

class InputDeviceTriggerEffect(InputDeviceProperty):
    r"""
    A property that effect the triggers on a gamepad
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_trigger_data`` (DeviceTriggerBaseData):  [Read-Write]
    - ``property_duration`` (float):  [Read-Only] The duration that this device property should last. Override this if your property has any dynamic curves
      to be the max time range.
      
      A duration of 0 means that the device property will be treated as a "One Shot" effect, being applied once
      before being removed by the Input Device Subsystem.
    """
    @property
    def base_trigger_data(self) -> DeviceTriggerBaseData:
        r"""
        (DeviceTriggerBaseData):  [Read-Write]
        """
        ...
    @base_trigger_data.setter
    def base_trigger_data(self, value: DeviceTriggerBaseData) -> None:
        ...

class InputDeviceTriggerFeedbackProperty(InputDeviceTriggerEffect):
    r"""
    Sets simple trigger feedback
    
    NOTE: This property has platform specific implementations and may behave differently per platform.
    See the docs for more details on each platform.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_trigger_data`` (DeviceTriggerBaseData):  [Read-Write]
    - ``device_override_data`` (Map[Name, DeviceTriggerFeedbackData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
    - ``property_duration`` (float):  [Read-Only] The duration that this device property should last. Override this if your property has any dynamic curves
      to be the max time range.
      
      A duration of 0 means that the device property will be treated as a "One Shot" effect, being applied once
      before being removed by the Input Device Subsystem.
    - ``trigger_data`` (DeviceTriggerFeedbackData):  [Read-Write] What position on the trigger that the feedback should be applied to over time (1-9)
    """
    @property
    def trigger_data(self) -> DeviceTriggerFeedbackData:
        r"""
        (DeviceTriggerFeedbackData):  [Read-Write] What position on the trigger that the feedback should be applied to over time (1-9)
        """
        ...
    @trigger_data.setter
    def trigger_data(self, value: DeviceTriggerFeedbackData) -> None:
        ...
    @property
    def device_override_data(self) -> Map[Name, DeviceTriggerFeedbackData]:
        r"""
        (Map[Name, DeviceTriggerFeedbackData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
        """
        ...
    @device_override_data.setter
    def device_override_data(self, value: Map[Name, DeviceTriggerFeedbackData]) -> None:
        ...

class InputDeviceTriggerResistanceProperty(InputDeviceTriggerEffect):
    r"""
    Provides linear resistance to a trigger while it is being pressed between a start and end value
    
    NOTE: This property has platform specific implementations and may behave differently per platform.
    See the docs for more details on each platform.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_trigger_data`` (DeviceTriggerBaseData):  [Read-Write]
    - ``device_override_data`` (Map[Name, DeviceTriggerTriggerResistanceData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
    - ``property_duration`` (float):  [Read-Only] The duration that this device property should last. Override this if your property has any dynamic curves
      to be the max time range.
      
      A duration of 0 means that the device property will be treated as a "One Shot" effect, being applied once
      before being removed by the Input Device Subsystem.
    - ``trigger_data`` (DeviceTriggerTriggerResistanceData):  [Read-Write]
    """
    @property
    def trigger_data(self) -> DeviceTriggerTriggerResistanceData:
        r"""
        (DeviceTriggerTriggerResistanceData):  [Read-Write]
        """
        ...
    @trigger_data.setter
    def trigger_data(self, value: DeviceTriggerTriggerResistanceData) -> None:
        ...
    @property
    def device_override_data(self) -> Map[Name, DeviceTriggerTriggerResistanceData]:
        r"""
        (Map[Name, DeviceTriggerTriggerResistanceData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
        """
        ...
    @device_override_data.setter
    def device_override_data(self, value: Map[Name, DeviceTriggerTriggerResistanceData]) -> None:
        ...

class InputDeviceTriggerVibrationProperty(InputDeviceTriggerEffect):
    r"""
    Sets trigger vibration
    
    NOTE: This property has platform specific implementations and may behave differently per platform.
    See the docs for more details on each platform.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_trigger_data`` (DeviceTriggerBaseData):  [Read-Write]
    - ``device_override_data`` (Map[Name, DeviceTriggerTriggerVibrationData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
    - ``property_duration`` (float):  [Read-Only] The duration that this device property should last. Override this if your property has any dynamic curves
      to be the max time range.
      
      A duration of 0 means that the device property will be treated as a "One Shot" effect, being applied once
      before being removed by the Input Device Subsystem.
    - ``trigger_data`` (DeviceTriggerTriggerVibrationData):  [Read-Write]
    """
    @property
    def trigger_data(self) -> DeviceTriggerTriggerVibrationData:
        r"""
        (DeviceTriggerTriggerVibrationData):  [Read-Write]
        """
        ...
    @trigger_data.setter
    def trigger_data(self, value: DeviceTriggerTriggerVibrationData) -> None:
        ...
    @property
    def device_override_data(self) -> Map[Name, DeviceTriggerTriggerVibrationData]:
        r"""
        (Map[Name, DeviceTriggerTriggerVibrationData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
        """
        ...
    @device_override_data.setter
    def device_override_data(self, value: Map[Name, DeviceTriggerTriggerVibrationData]) -> None:
        ...

class InputDeviceAudioBasedVibrationProperty(InputDeviceProperty):
    r"""
    Plays a sound to an input device's speaker. On platforms that support it, this sound will be played
    in the form of a vibration where the left and right audio channels represent the left and right side
    of the controller.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data`` (AudioBasedVibrationData):  [Read-Write]
    - ``device_override_data`` (Map[Name, AudioBasedVibrationData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
    - ``property_duration`` (float):  [Read-Only] The duration that this device property should last. Override this if your property has any dynamic curves
      to be the max time range.
      
      A duration of 0 means that the device property will be treated as a "One Shot" effect, being applied once
      before being removed by the Input Device Subsystem.
    """
    @property
    def data(self) -> AudioBasedVibrationData:
        r"""
        (AudioBasedVibrationData):  [Read-Write]
        """
        ...
    @data.setter
    def data(self, value: AudioBasedVibrationData) -> None:
        ...
    @property
    def device_override_data(self) -> Map[Name, AudioBasedVibrationData]:
        r"""
        (Map[Name, AudioBasedVibrationData]):  [Read-Write] A map of device specific color data. If no overrides are specified, the Default hardware data will be used
        """
        ...
    @device_override_data.setter
    def device_override_data(self, value: Map[Name, AudioBasedVibrationData]) -> None:
        ...

class InputDeviceSubsystem(EngineSubsystem):
    r"""
    The input device subsystem provides an interface to allow users to set Input Device Properties
    on any Platform User.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_input_hardware_device_changed`` (HardwareInputDeviceChanged):  [Read-Write] A delegate that is fired when a platform user changes what Hardware Input device they are using
    """
    @property
    def on_input_hardware_device_changed(self) -> HardwareInputDeviceChanged:
        r"""
        (HardwareInputDeviceChanged):  [Read-Write] A delegate that is fired when a platform user changes what Hardware Input device they are using
        """
        ...
    @on_input_hardware_device_changed.setter
    def on_input_hardware_device_changed(self, value: HardwareInputDeviceChanged) -> None:
        ...
    def remove_device_property_handles(self, handles_to_remove: Set[InputDevicePropertyHandle]) -> None:
        r"""
        x.remove_device_property_handles(handles_to_remove) -> None
        Remove a set of device properties based on their handles.
        
        Args:
            handles_to_remove (Set[InputDevicePropertyHandle]): The set of device property handles to remove
        """
        ...
    def remove_device_property_by_handle(self, handle_to_remove: InputDevicePropertyHandle) -> None:
        r"""
        x.remove_device_property_by_handle(handle_to_remove) -> None
        Remove a single device property based on it's handle
        
        Args:
            handle_to_remove (InputDevicePropertyHandle):
        """
        ...
    def remove_all_device_properties(self) -> None:
        r"""
        x.remove_all_device_properties() -> None
        Removes all the current Input Device Properties that are active, regardless of the Platform User
        """
        ...
    def is_property_active(self, handle: InputDevicePropertyHandle) -> bool:
        r"""
        x.is_property_active(handle) -> bool
        Returns true if the property associated with the given handle is currently active, and it is not pending removal
        
        Args:
            handle (InputDevicePropertyHandle): 
        
        Returns:
            bool:
        """
        ...
    def get_most_recently_used_hardware_device(self, user_id: PlatformUserId) -> HardwareDeviceIdentifier:
        r"""
        x.get_most_recently_used_hardware_device(user_id) -> HardwareDeviceIdentifier
        Gets the most recently used hardware input device for the given platform user
        
        Args:
            user_id (PlatformUserId): 
        
        Returns:
            HardwareDeviceIdentifier:
        """
        ...
    def get_input_device_hardware_identifier(self, input_device: InputDeviceId) -> HardwareDeviceIdentifier:
        r"""
        x.get_input_device_hardware_identifier(input_device) -> HardwareDeviceIdentifier
        Get Input Device Hardware Identifier
        
        Args:
            input_device (InputDeviceId): 
        
        Returns:
            HardwareDeviceIdentifier:
        """
        ...
    def get_active_device_property(self, handle: InputDevicePropertyHandle) -> InputDeviceProperty:
        r"""
        x.get_active_device_property(handle) -> InputDeviceProperty
        Returns a pointer to the active input device property with the given handle. Returns null if the property doesn't exist
        
        Args:
            handle (InputDevicePropertyHandle): 
        
        Returns:
            InputDeviceProperty:
        """
        ...
    def activate_device_property_of_class(self, property_class: Class, params: ActivateDevicePropertyParams) -> InputDevicePropertyHandle:
        r"""
        x.activate_device_property_of_class(property_class, params) -> InputDevicePropertyHandle
        Spawn a new instance of the given device property class and activate it.
        
        Args:
            property_class (type(Class)): 
            params (ActivateDevicePropertyParams): 
        
        Returns:
            InputDevicePropertyHandle:
        """
        ...

class SaveGame(Object):
    r"""
    This class acts as a base class for a save game object that can be used to save state about the game.
    When you create your own save game subclass, you would add member variables for the information that you want to save.
    Then when you want to save a game, create an instance of this object using CreateSaveGameObject, fill in the data, and use SaveGameToSlot, providing a slot name.
    To load the game you then just use LoadGameFromSlot, and read the data from the resulting object.
    see: https://docs.unrealengine.com/latest/INT/Gameplay/SaveGame
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SaveGame.h
    
    """
    ...

class LocalPlayerSaveGame(SaveGame):
    r"""
    Abstract subclass of USaveGame that provides utility functions that let you associate a Save Game object with a specific local player.
    These objects can also be loaded using the functions on GameplayStatics, but you would need to call functions like InitializeSaveGame manually.
    For simple games, it is fine to blueprint this class directly and add parameters and override functions in blueprint,
    but for complicated games you will want to subclass this in native code and set up proper versioning.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SaveGame.h
    
    """
    def was_save_requested(self) -> bool:
        r"""
        x.was_save_requested() -> bool
        Returns true if a save was ever requested, may still be in progress
        
        Returns:
            bool:
        """
        ...
    def was_loaded(self) -> bool:
        r"""
        x.was_loaded() -> bool
        Returns true if this was loaded from an existing save
        
        Returns:
            bool:
        """
        ...
    def was_last_save_successful(self) -> bool:
        r"""
        x.was_last_save_successful() -> bool
        Returns true if it has been saved at least once and the last save was successful
        
        Returns:
            bool:
        """
        ...
    def save_game_to_slot_for_local_player(self) -> bool:
        r"""
        x.save_game_to_slot_for_local_player() -> bool
        Synchronously save using the slot and user index, stalling the main thread until it completes.
        This will return true if the save was requested, and errors should be handled by the HandlePostSave function that will be called immediately.
        
        Returns:
            bool:
        """
        ...
    def reset_to_default(self) -> None:
        r"""
        x.reset_to_default() -> None
        Resets all saved data to default values, called when the load fails or manually
        """
        ...
    def on_reset_to_default(self) -> None:
        r"""
        x.on_reset_to_default() -> None
        Blueprint event called to reset all saved data to default, called when the load fails or manually
        """
        ...
    def on_pre_save(self) -> None:
        r"""
        x.on_pre_save() -> None
        Blueprint event called before saving, do any game-specific fixup here
        """
        ...
    def on_post_save(self, success: bool) -> None:
        r"""
        x.on_post_save(success) -> None
        Blueprint event called after saving finishes with success/failure result
        
        Args:
            success (bool):
        """
        ...
    def on_post_load(self) -> None:
        r"""
        x.on_post_load() -> None
        Blueprint event called after loading, is not called for newly created saves
        """
        ...
    @classmethod
    def load_or_create_save_game_for_local_player(cls, save_game_class: Class, local_player_controller: PlayerController, slot_name: str) -> LocalPlayerSaveGame:
        r"""
        X.load_or_create_save_game_for_local_player(save_game_class, local_player_controller, slot_name) -> LocalPlayerSaveGame
        Synchronously loads a save game object in the specified slot for the local player, stalling the main thread until it completes.
        This will return null for invalid parameters, but will create a new instance if the parameters are valid but loading fails.
        
        Args:
            save_game_class (type(Class)): 
            local_player_controller (PlayerController): 
            slot_name (str): 
        
        Returns:
            LocalPlayerSaveGame:
        """
        ...
    def is_save_in_progress(self) -> bool:
        r"""
        x.is_save_in_progress() -> bool
        Returns true if a save is in progress
        
        Returns:
            bool:
        """
        ...
    def get_save_slot_name(self) -> str:
        r"""
        x.get_save_slot_name() -> str
        Returns the save slot name to use
        
        Returns:
            str:
        """
        ...
    def get_saved_data_version(self) -> int:
        r"""
        x.get_saved_data_version() -> int32
        Returns the game-specific version number this was last saved/loaded as
        
        Returns:
            int32:
        """
        ...
    def get_platform_user_index(self) -> int:
        r"""
        x.get_platform_user_index() -> int32
        Returns the user index to save to, based on Local Player by default
        
        Returns:
            int32:
        """
        ...
    def get_platform_user_id(self) -> PlatformUserId:
        r"""
        x.get_platform_user_id() -> PlatformUserId
        Returns the platform user to save to, based on Local Player by default
        
        Returns:
            PlatformUserId:
        """
        ...
    def get_local_player_controller(self) -> PlayerController:
        r"""
        x.get_local_player_controller() -> PlayerController
        Returns the local player controller this is associated with, this will be valid if it is ready to save
        
        Returns:
            PlayerController:
        """
        ...
    def get_latest_data_version(self) -> int:
        r"""
        x.get_latest_data_version() -> int32
        Returns the latest save data version, this is used when the new data is saved
        
        Returns:
            int32:
        """
        ...
    def get_invalid_data_version(self) -> int:
        r"""
        x.get_invalid_data_version() -> int32
        Returns the invalid save data version, which means it has never been saved/loaded
        
        Returns:
            int32:
        """
        ...
    def async_save_game_to_slot_for_local_player(self) -> bool:
        r"""
        x.async_save_game_to_slot_for_local_player() -> bool
        Asynchronously save to the slot and user index.
        This will return true if the save was requested, and errors should be handled by the HandlePostSave function after the save succeeds or fails
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def async_load_or_create_save_game_for_local_player(cls, save_game_class: Class, local_player_controller: PlayerController, slot_name: str, delegate: OnLocalPlayerSaveGameLoaded) -> bool:
        r"""
        X.async_load_or_create_save_game_for_local_player(save_game_class, local_player_controller, slot_name, delegate) -> bool
        Asynchronously loads a save game object in the specified slot for the local player, if this returns true the delegate will get called later.
        False means the load was never scheduled, otherwise it will create and initialize a new instance before calling the delegate if loading failed.
        
        Args:
            save_game_class (type(Class)): 
            local_player_controller (PlayerController): 
            slot_name (str): 
            delegate (OnLocalPlayerSaveGameLoaded): 
        
        Returns:
            bool:
        """
        ...

class SpringArmComponent(SceneComponent):
    r"""
    This component tries to maintain its children at a fixed distance from the parent,
    but will retract the children if there is a collision, and spring back when there is no collision.
    
    Example: Use as a 'camera boom' or 'selfie stick' to keep the follow camera for a player from colliding into the world.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SpringArmComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``camera_lag_max_distance`` (float):  [Read-Write] Max distance the camera target may lag behind the current location. If set to zero, no max distance is enforced.
    - ``camera_lag_max_time_step`` (float):  [Read-Write] Max time step used when sub-stepping camera lag.
    - ``camera_lag_speed`` (float):  [Read-Write] If bEnableCameraLag is true, controls how quickly camera reaches target position. Low values are slower (more lag), high values are faster (less lag), while zero is instant (no lag).
    - ``camera_rotation_lag_speed`` (float):  [Read-Write] If bEnableCameraRotationLag is true, controls how quickly camera reaches target position. Low values are slower (more lag), high values are faster (less lag), while zero is instant (no lag).
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``clamp_to_max_physics_delta_time`` (bool):  [Read-Write] If true AND the view target is simulating using physics then use the same max timestep cap as the physics system. Prevents camera jitter when delta time is clamped within Chaos Physics.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``do_collision_test`` (bool):  [Read-Write] If true, do a collision test using ProbeChannel and ProbeSize to prevent camera clipping into level.
    - ``draw_debug_lag_markers`` (bool):  [Read-Write] If true and camera location lag is enabled, draws markers at the camera target (in green) and the lagged position (in yellow).
      A line is drawn between the two locations, in green normally but in red if the distance to the lag target has been clamped (by CameraLagMaxDistance).
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_camera_lag`` (bool):  [Read-Write] If true, camera lags behind target position to smooth its movement.
      see: CameraLagSpeed
    - ``enable_camera_rotation_lag`` (bool):  [Read-Write] If true, camera lags behind target rotation to smooth its movement.
      see: CameraRotationLagSpeed
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``inherit_pitch`` (bool):  [Read-Write] Should we inherit pitch from parent component. Does nothing if using Absolute Rotation.
    - ``inherit_roll`` (bool):  [Read-Write] Should we inherit roll from parent component. Does nothing if using Absolute Rotation.
    - ``inherit_yaw`` (bool):  [Read-Write] Should we inherit yaw from parent component. Does nothing if using Absolute Rotation.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``probe_channel`` (CollisionChannel):  [Read-Write] Collision channel of the query probe (defaults to ECC_Camera)
    - ``probe_size`` (float):  [Read-Write] How big should the query probe sphere be (in unreal units)
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``socket_offset`` (Vector):  [Read-Write] offset at end of spring arm; use this instead of the relative offset of the attached component to ensure the line trace works as desired
    - ``target_arm_length`` (float):  [Read-Write] Natural length of the spring arm when there are no collisions
    - ``target_offset`` (Vector):  [Read-Write] Offset at start of spring, applied in world space. Use this if you want a world-space offset from the parent component instead of the usual relative-space offset.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_camera_lag_substepping`` (bool):  [Read-Write] If bUseCameraLagSubstepping is true, sub-step camera damping so that it handles fluctuating frame rates well (though this comes at a cost).
      see: CameraLagMaxTimeStep
    - ``use_pawn_control_rotation`` (bool):  [Read-Write] If this component is placed on a pawn, should it use the view/control rotation of the pawn where possible?
      When disabled, the component will revert to using the stored RelativeRotation of the component.
      Note that this component itself does not rotate, but instead maintains its relative rotation to its parent as normal,
      and just repositions and rotates its children as desired by the inherited rotation settings. Use GetTargetRotation()
      if you want the rotation target based on all the settings (UsePawnControlRotation, InheritPitch, etc).
      see: GetTargetRotation(), APawn::GetViewRotation()
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def target_arm_length(self) -> float:
        r"""
        (float):  [Read-Write] Natural length of the spring arm when there are no collisions
        """
        ...
    @target_arm_length.setter
    def target_arm_length(self, value: float) -> None:
        ...
    @property
    def socket_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] offset at end of spring arm; use this instead of the relative offset of the attached component to ensure the line trace works as desired
        """
        ...
    @socket_offset.setter
    def socket_offset(self, value: Vector) -> None:
        ...
    @property
    def target_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Offset at start of spring, applied in world space. Use this if you want a world-space offset from the parent component instead of the usual relative-space offset.
        """
        ...
    @target_offset.setter
    def target_offset(self, value: Vector) -> None:
        ...
    @property
    def probe_size(self) -> float:
        r"""
        (float):  [Read-Write] How big should the query probe sphere be (in unreal units)
        """
        ...
    @probe_size.setter
    def probe_size(self, value: float) -> None:
        ...
    @property
    def probe_channel(self) -> CollisionChannel:
        r"""
        (CollisionChannel):  [Read-Write] Collision channel of the query probe (defaults to ECC_Camera)
        """
        ...
    @probe_channel.setter
    def probe_channel(self, value: CollisionChannel) -> None:
        ...
    @property
    def do_collision_test(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, do a collision test using ProbeChannel and ProbeSize to prevent camera clipping into level.
        """
        ...
    @do_collision_test.setter
    def do_collision_test(self, value: bool) -> None:
        ...
    @property
    def use_pawn_control_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] If this component is placed on a pawn, should it use the view/control rotation of the pawn where possible?
        When disabled, the component will revert to using the stored RelativeRotation of the component.
        Note that this component itself does not rotate, but instead maintains its relative rotation to its parent as normal,
        and just repositions and rotates its children as desired by the inherited rotation settings. Use GetTargetRotation()
        if you want the rotation target based on all the settings (UsePawnControlRotation, InheritPitch, etc).
        see: GetTargetRotation(), APawn::GetViewRotation()
        """
        ...
    @use_pawn_control_rotation.setter
    def use_pawn_control_rotation(self, value: bool) -> None:
        ...
    @property
    def b_use_controller_view_rotation(self) -> bool:
        r"""
        deprecated: 'b_use_controller_view_rotation' was renamed to 'use_pawn_control_rotation'.
        """
        ...
    @b_use_controller_view_rotation.setter
    def b_use_controller_view_rotation(self, value: bool) -> None:
        ...
    @property
    def b_use_pawn_view_rotation(self) -> bool:
        r"""
        deprecated: 'b_use_pawn_view_rotation' was renamed to 'use_pawn_control_rotation'.
        """
        ...
    @b_use_pawn_view_rotation.setter
    def b_use_pawn_view_rotation(self, value: bool) -> None:
        ...
    @property
    def inherit_pitch(self) -> bool:
        r"""
        (bool):  [Read-Write] Should we inherit pitch from parent component. Does nothing if using Absolute Rotation.
        """
        ...
    @inherit_pitch.setter
    def inherit_pitch(self, value: bool) -> None:
        ...
    @property
    def inherit_yaw(self) -> bool:
        r"""
        (bool):  [Read-Write] Should we inherit yaw from parent component. Does nothing if using Absolute Rotation.
        """
        ...
    @inherit_yaw.setter
    def inherit_yaw(self, value: bool) -> None:
        ...
    @property
    def inherit_roll(self) -> bool:
        r"""
        (bool):  [Read-Write] Should we inherit roll from parent component. Does nothing if using Absolute Rotation.
        """
        ...
    @inherit_roll.setter
    def inherit_roll(self, value: bool) -> None:
        ...
    @property
    def enable_camera_lag(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, camera lags behind target position to smooth its movement.
        see: CameraLagSpeed
        """
        ...
    @enable_camera_lag.setter
    def enable_camera_lag(self, value: bool) -> None:
        ...
    @property
    def enable_camera_rotation_lag(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, camera lags behind target rotation to smooth its movement.
        see: CameraRotationLagSpeed
        """
        ...
    @enable_camera_rotation_lag.setter
    def enable_camera_rotation_lag(self, value: bool) -> None:
        ...
    @property
    def use_camera_lag_substepping(self) -> bool:
        r"""
        (bool):  [Read-Write] If bUseCameraLagSubstepping is true, sub-step camera damping so that it handles fluctuating frame rates well (though this comes at a cost).
        see: CameraLagMaxTimeStep
        """
        ...
    @use_camera_lag_substepping.setter
    def use_camera_lag_substepping(self, value: bool) -> None:
        ...
    @property
    def draw_debug_lag_markers(self) -> bool:
        r"""
        (bool):  [Read-Write] If true and camera location lag is enabled, draws markers at the camera target (in green) and the lagged position (in yellow).
        A line is drawn between the two locations, in green normally but in red if the distance to the lag target has been clamped (by CameraLagMaxDistance).
        """
        ...
    @draw_debug_lag_markers.setter
    def draw_debug_lag_markers(self, value: bool) -> None:
        ...
    @property
    def camera_lag_speed(self) -> float:
        r"""
        (float):  [Read-Write] If bEnableCameraLag is true, controls how quickly camera reaches target position. Low values are slower (more lag), high values are faster (less lag), while zero is instant (no lag).
        """
        ...
    @camera_lag_speed.setter
    def camera_lag_speed(self, value: float) -> None:
        ...
    @property
    def camera_rotation_lag_speed(self) -> float:
        r"""
        (float):  [Read-Write] If bEnableCameraRotationLag is true, controls how quickly camera reaches target position. Low values are slower (more lag), high values are faster (less lag), while zero is instant (no lag).
        """
        ...
    @camera_rotation_lag_speed.setter
    def camera_rotation_lag_speed(self, value: float) -> None:
        ...
    @property
    def camera_lag_max_time_step(self) -> float:
        r"""
        (float):  [Read-Write] Max time step used when sub-stepping camera lag.
        """
        ...
    @camera_lag_max_time_step.setter
    def camera_lag_max_time_step(self, value: float) -> None:
        ...
    @property
    def camera_lag_max_distance(self) -> float:
        r"""
        (float):  [Read-Write] Max distance the camera target may lag behind the current location. If set to zero, no max distance is enforced.
        """
        ...
    @camera_lag_max_distance.setter
    def camera_lag_max_distance(self, value: float) -> None:
        ...
    @property
    def clamp_to_max_physics_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write] If true AND the view target is simulating using physics then use the same max timestep cap as the physics system. Prevents camera jitter when delta time is clamped within Chaos Physics.
        """
        ...
    @clamp_to_max_physics_delta_time.setter
    def clamp_to_max_physics_delta_time(self, value: bool) -> None:
        ...
    def is_collision_fix_applied(self) -> bool:
        r"""
        x.is_collision_fix_applied() -> bool
        Is the Collision Test displacement being applied?
        
        Returns:
            bool:
        """
        ...
    def get_unfixed_camera_position(self) -> Vector:
        r"""
        x.get_unfixed_camera_position() -> Vector
        Get the position where the camera should be without applying the Collision Test displacement
        
        Returns:
            Vector:
        """
        ...
    def get_target_rotation(self) -> Rotator:
        r"""
        x.get_target_rotation() -> Rotator
        Get the target rotation we inherit, used as the base target for the boom rotation.
        This is derived from attachment to our parent and considering the UsePawnControlRotation and absolute rotation flags.
        
        Returns:
            Rotator:
        """
        ...

class TouchInterface(Object):
    r"""
    Defines an interface by which touch input can be controlled using any number of buttons and virtual joysticks
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TouchInterface.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``activation_delay`` (float):  [Read-Write] How long after joystick enabled for touch (0.0 will disable this feature)
    - ``active_opacity`` (float):  [Read-Write] Opacity (0.0 - 1.0) of all controls while any control is active
    - ``controls`` (Array[TouchInputControl]):  [Read-Write]
    - ``inactive_opacity`` (float):  [Read-Write] Opacity (0.0 - 1.0) of all controls while no controls are active
    - ``prevent_recenter`` (bool):  [Read-Write] Prevent joystick re-centering and moving from Center through user taps
    - ``startup_delay`` (float):  [Read-Write] Delay at startup before virtual joystick is drawn
    - ``time_until_deactive`` (float):  [Read-Write] How long after user interaction will all controls fade out to Inactive Opacity
    - ``time_until_reset`` (float):  [Read-Write] How long after going inactive will controls reset/recenter themselves (0.0 will disable this feature)
    """
    ...

class GameInstance(Object):
    r"""
    GameInstance: high-level manager object for an instance of the running game.
    Spawned at game creation and not destroyed until game instance is shut down.
    Running as a standalone game, there will be one of these.
    Running in PIE (play-in-editor) will generate one of these per PIE instance.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_input_device_connection_change`` (OnUserInputDeviceConnectionChange):  [Read-Write] Callback for when an input device connection state has changed (a new gamepad was connected or disconnected)
    - ``on_pawn_controller_changed_delegates`` (OnPawnControllerChanged):  [Read-Write] gets triggered shortly after a pawn's controller is set. Most of the time
          it signals that the Controller has changed but in edge cases (like during
          replication) it might end up broadcasting the same pawn-controller pair
          more than once
    - ``on_user_input_device_pairing_change`` (OnUserInputDevicePairingChange):  [Read-Write] Callback when an input device has changed pairings (the owning platform user has changed for that device)
    """
    @property
    def on_pawn_controller_changed_delegates(self) -> OnPawnControllerChanged:
        r"""
        (OnPawnControllerChanged):  [Read-Write] gets triggered shortly after a pawn's controller is set. Most of the time
            it signals that the Controller has changed but in edge cases (like during
            replication) it might end up broadcasting the same pawn-controller pair
            more than once
        """
        ...
    @on_pawn_controller_changed_delegates.setter
    def on_pawn_controller_changed_delegates(self, value: OnPawnControllerChanged) -> None:
        ...
    @property
    def on_input_device_connection_change(self) -> OnUserInputDeviceConnectionChange:
        r"""
        (OnUserInputDeviceConnectionChange):  [Read-Write] Callback for when an input device connection state has changed (a new gamepad was connected or disconnected)
        """
        ...
    @on_input_device_connection_change.setter
    def on_input_device_connection_change(self, value: OnUserInputDeviceConnectionChange) -> None:
        ...
    @property
    def on_user_input_device_pairing_change(self) -> OnUserInputDevicePairingChange:
        r"""
        (OnUserInputDevicePairingChange):  [Read-Write] Callback when an input device has changed pairings (the owning platform user has changed for that device)
        """
        ...
    @on_user_input_device_pairing_change.setter
    def on_user_input_device_pairing_change(self, value: OnUserInputDevicePairingChange) -> None:
        ...
    def receive_shutdown(self) -> None:
        r"""
        x.receive_shutdown() -> None
        Opportunity for blueprints to handle the game instance being shutdown.
        """
        ...
    def receive_init(self) -> None:
        r"""
        x.receive_init() -> None
        Opportunity for blueprints to handle the game instance being initialized.
        """
        ...
    def handle_travel_error(self, failure_type: TravelFailure) -> None:
        r"""
        x.handle_travel_error(failure_type) -> None
        Opportunity for blueprints to handle travel errors.
        
        Args:
            failure_type (TravelFailure):
        """
        ...
    def handle_network_error(self, failure_type: NetworkFailure, is_server: bool) -> None:
        r"""
        x.handle_network_error(failure_type, is_server) -> None
        Opportunity for blueprints to handle network errors.
        
        Args:
            failure_type (NetworkFailure): 
            is_server (bool):
        """
        ...

class GameModeBase(Info):
    r"""
    The GameModeBase defines the game being played. It governs the game rules, scoring, what actors
    are allowed to exist in this game type, and who may enter the game.
    
    It is only instanced on the server and will never exist on the client.
    
    A GameModeBase actor is instantiated when the level is initialized for gameplay in
    C++ UGameEngine::LoadMap().
    
    The class of this GameMode actor is determined by (in order) either the URL ?game=xxx,
    the GameMode Override value set in the World Settings, or the DefaultGameMode entry set
    in the game's Project Settings.
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Framework/GameMode/index.html
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameModeBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_pawn_class`` (type(Class)):  [Read-Write] The default pawn class used by players.
    - ``default_player_name`` (Text):  [Read-Write] The default player name assigned to players that join with no name specified.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``game_net_driver_replication_system`` (ReplicationSystem):  [Read-Write] Can be used to request a specific replication system for a GameNetDriver that will replicate this game mode.
      Leave to Default to use the game engine's preferred system.
      Useful when migrating from one repsystem to another and a game mode does not fully support both repsystem yet.
    - ``game_session_class`` (type(Class)):  [Read-Write] Class of GameSession, which handles login approval and online game interface
    - ``game_state_class`` (type(Class)):  [Read-Write] Class of GameState associated with this GameMode.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``hud_class`` (type(Class)):  [Read-Write] HUD class this game uses.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``options_string`` (str):  [Read-Write] Save options string and parse it when needed
    - ``pauseable`` (bool):  [Read-Write] Whether the game is pauseable.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_controller_class`` (type(Class)):  [Read-Write] The class of PlayerController to spawn for players logging in.
    - ``player_state_class`` (type(Class)):  [Read-Write] A PlayerState of this class will be associated with every player to replicate relevant player information to all clients.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replay_spectator_player_controller_class`` (type(Class)):  [Read-Write] The PlayerController class used when spectating a network replay.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``server_stat_replicator_class`` (type(Class)):  [Read-Write]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``spectator_class`` (type(Class)):  [Read-Write] The pawn class used by the PlayerController for players when spectating.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``start_players_as_spectators`` (bool):  [Read-Write] Whether players should immediately spawn when logging in, or stay as spectators until they manually spawn
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_seamless_travel`` (bool):  [Read-Write] Whether the game perform map travels using SeamlessTravel() which loads in the background and doesn't disconnect clients
    """
    @property
    def options_string(self) -> str:
        r"""
        (str):  [Read-Only] Save options string and parse it when needed
        """
        ...
    @property
    def game_session_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Class of GameSession, which handles login approval and online game interface
        """
        ...
    @game_session_class.setter
    def game_session_class(self, value: Class) -> None:
        ...
    @property
    def game_state_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] Class of GameState associated with this GameMode.
        """
        ...
    @property
    def player_controller_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] The class of PlayerController to spawn for players logging in.
        """
        ...
    @property
    def player_state_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] A PlayerState of this class will be associated with every player to replicate relevant player information to all clients.
        """
        ...
    @property
    def hud_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] HUD class this game uses.
        """
        ...
    @hud_class.setter
    def hud_class(self, value: Class) -> None:
        ...
    @property
    def default_pawn_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] The default pawn class used by players.
        """
        ...
    @default_pawn_class.setter
    def default_pawn_class(self, value: Class) -> None:
        ...
    @property
    def spectator_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] The pawn class used by the PlayerController for players when spectating.
        """
        ...
    @property
    def replay_spectator_player_controller_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] The PlayerController class used when spectating a network replay.
        """
        ...
    @property
    def server_stat_replicator_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only]
        """
        ...
    @property
    def use_seamless_travel(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the game perform map travels using SeamlessTravel() which loads in the background and doesn't disconnect clients
        """
        ...
    @use_seamless_travel.setter
    def use_seamless_travel(self, value: bool) -> None:
        ...
    @property
    def start_players_as_spectators(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether players should immediately spawn when logging in, or stay as spectators until they manually spawn
        """
        ...
    @property
    def pauseable(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the game is pauseable.
        """
        ...
    @pauseable.setter
    def pauseable(self, value: bool) -> None:
        ...
    @property
    def game_net_driver_replication_system(self) -> ReplicationSystem:
        r"""
        (ReplicationSystem):  [Read-Write] Can be used to request a specific replication system for a GameNetDriver that will replicate this game mode.
        Leave to Default to use the game engine's preferred system.
        Useful when migrating from one repsystem to another and a game mode does not fully support both repsystem yet.
        """
        ...
    @game_net_driver_replication_system.setter
    def game_net_driver_replication_system(self, value: ReplicationSystem) -> None:
        ...
    def start_play(self) -> None:
        r"""
        x.start_play() -> None
        Transitions to calls BeginPlay on actors.
        """
        ...
    def spawn_default_pawn_for(self, new_player: Controller, start_spot: Actor) -> Pawn:
        r"""
        x.spawn_default_pawn_for(new_player, start_spot) -> Pawn
        Called during RestartPlayer to actually spawn the player's pawn, when using a start spot
        
        Args:
            new_player (Controller): Controller for whom this pawn is spawned
            start_spot (Actor): Actor at which to spawn pawn
        
        Returns:
            Pawn: a pawn of the default pawn class
        """
        ...
    def spawn_default_pawn_at_transform(self, new_player: Controller, spawn_transform: Transform) -> Pawn:
        r"""
        x.spawn_default_pawn_at_transform(new_player, spawn_transform) -> Pawn
        Called during RestartPlayer to actually spawn the player's pawn, when using a transform
        
        Args:
            new_player (Controller): Controller for whom this pawn is spawned
            spawn_transform (Transform): Transform at which to spawn pawn
        
        Returns:
            Pawn: a pawn of the default pawn class
        """
        ...
    def should_reset(self, actor_to_reset: Actor) -> bool:
        r"""
        x.should_reset(actor_to_reset) -> bool
        Overridable function to determine whether an Actor should have Reset called when the game has Reset called on it.
        Default implementation returns true
        
        Args:
            actor_to_reset (Actor): The actor to make a determination for
        
        Returns:
            bool: true if ActorToReset should have Reset() called on it while restarting the game, false if the GameMode will manually reset it or if the actor does not need to be reset
        """
        ...
    def return_to_main_menu_host(self) -> None:
        r"""
        x.return_to_main_menu_host() -> None
        Return to main menu, and disconnect any players
        """
        ...
    def restart_player_at_transform(self, new_player: Controller, spawn_transform: Transform) -> None:
        r"""
        x.restart_player_at_transform(new_player, spawn_transform) -> None
        Tries to spawn the player's pawn at a specific location
        
        Args:
            new_player (Controller): 
            spawn_transform (Transform):
        """
        ...
    def restart_player_at_player_start(self, new_player: Controller, start_spot: Actor) -> None:
        r"""
        x.restart_player_at_player_start(new_player, start_spot) -> None
        Tries to spawn the player's pawn at the specified actor's location
        
        Args:
            new_player (Controller): 
            start_spot (Actor):
        """
        ...
    def restart_player(self, new_player: Controller) -> None:
        r"""
        x.restart_player(new_player) -> None
        Tries to spawn the player's pawn, at the location returned by FindPlayerStart
        
        Args:
            new_player (Controller):
        """
        ...
    def reset_level(self) -> None:
        r"""
        x.reset_level() -> None
        Overridable function called when resetting level. This is used to reset the game state while staying in the same map
        Default implementation calls Reset() on all actors except GameMode and Controllers
        """
        ...
    def player_can_restart(self, player: PlayerController) -> bool:
        r"""
        x.player_can_restart(player) -> bool
        Returns true if it's valid to call RestartPlayer. By default will call Player->CanRestartPlayer
        
        Args:
            player (PlayerController): 
        
        Returns:
            bool:
        """
        ...
    def must_spectate(self, new_player_controller: PlayerController) -> bool:
        r"""
        x.must_spectate(new_player_controller) -> bool
        Returns true if NewPlayerController may only join the server as a spectator.
        
        Args:
            new_player_controller (PlayerController): 
        
        Returns:
            bool:
        """
        ...
    def on_post_login(self, new_player: PlayerController) -> None:
        r"""
        x.on_post_login(new_player) -> None
        Notification that a player has successfully logged in, and has been given a player controller
        
        Args:
            new_player (PlayerController):
        """
        ...
    def on_swap_player_controllers(self, old_pc: PlayerController, new_pc: PlayerController) -> None:
        r"""
        x.on_swap_player_controllers(old_pc, new_pc) -> None
        Called when a PlayerController is swapped to a new one during seamless travel
        
        Args:
            old_pc (PlayerController): 
            new_pc (PlayerController):
        """
        ...
    def on_restart_player(self, new_player: Controller) -> None:
        r"""
        x.on_restart_player(new_player) -> None
        Implementable event called at the end of RestartPlayer
        
        Args:
            new_player (Controller):
        """
        ...
    def on_logout(self, exiting_controller: Controller) -> None:
        r"""
        x.on_logout(exiting_controller) -> None
        Implementable event when a Controller with a PlayerState leaves the game.
        
        Args:
            exiting_controller (Controller):
        """
        ...
    def on_change_name(self, other: Controller, new_name: str, name_change: bool) -> None:
        r"""
        x.on_change_name(other, new_name, name_change) -> None
        Overridable event for GameMode blueprint to respond to a change name call
        
        Args:
            other (Controller): 
            new_name (str): The name to set the player to
            name_change (bool): Whether the name is changing or if this is the first time it has been set
        """
        ...
    def k2_find_player_start(self, player: Controller, incoming_name: str = "") -> Actor:
        r"""
        x.k2_find_player_start(player, incoming_name="") -> Actor
        Return the specific player start actor that should be used for the next spawn
        This will either use a previously saved startactor, or calls ChoosePlayerStart
        
        Args:
            player (Controller): The AController for whom we are choosing a Player Start
            incoming_name (str): Specifies the tag of a Player Start to use
        
        Returns:
            Actor: Actor chosen as player start (usually a PlayerStart)
        """
        ...
    def init_start_spot(self, start_spot: Actor, new_player: Controller) -> None:
        r"""
        x.init_start_spot(start_spot, new_player) -> None
        Called from RestartPlayerAtPlayerStart, can be used to initialize the start spawn actor
        
        Args:
            start_spot (Actor): 
            new_player (Controller):
        """
        ...
    def initialize_hud_for_player(self, new_player: PlayerController) -> None:
        r"""
        x.initialize_hud_for_player(new_player) -> None
        Initialize the AHUD object for a player. Games can override this to do something different
        
        Args:
            new_player (PlayerController):
        """
        ...
    def has_match_started(self) -> bool:
        r"""
        x.has_match_started() -> bool
        Returns true if the match start callbacks have been called
        
        Returns:
            bool:
        """
        ...
    def has_match_ended(self) -> bool:
        r"""
        x.has_match_ended() -> bool
        Returns true if the match can be considered ended
        
        Returns:
            bool:
        """
        ...
    def handle_starting_new_player(self, new_player: PlayerController) -> None:
        r"""
        x.handle_starting_new_player(new_player) -> None
        Signals that a player is ready to enter the game, which may start it up
        
        Args:
            new_player (PlayerController):
        """
        ...
    def get_num_spectators(self) -> int:
        r"""
        x.get_num_spectators() -> int32
        Returns number of human players currently spectating
        
        Returns:
            int32:
        """
        ...
    def get_num_players(self) -> int:
        r"""
        x.get_num_players() -> int32
        Returns number of active human players, excluding spectators
        
        Returns:
            int32:
        """
        ...
    def get_default_pawn_class_for_controller(self, controller: Controller) -> Class:
        r"""
        x.get_default_pawn_class_for_controller(controller) -> type(Class)
        Returns default pawn class for given controller
        
        Args:
            controller (Controller): 
        
        Returns:
            type(Class):
        """
        ...
    def find_player_start(self, player: Controller, incoming_name: str) -> Actor:
        r"""
        x.find_player_start(player, incoming_name) -> Actor
        Return the specific player start actor that should be used for the next spawn
        This will either use a previously saved startactor, or calls ChoosePlayerStart
        
        Args:
            player (Controller): The AController for whom we are choosing a Player Start
            incoming_name (str): Specifies the tag of a Player Start to use
        
        Returns:
            Actor: Actor chosen as player start (usually a PlayerStart)
        """
        ...
    def choose_player_start(self, player: Controller) -> Actor:
        r"""
        x.choose_player_start(player) -> Actor
        Return the 'best' player start for this player to spawn from
        Default implementation looks for a random unoccupied spot
        
        Args:
            player (Controller): is the controller for whom we are choosing a playerstart
        
        Returns:
            Actor: AActor chosen as player start (usually a PlayerStart)
        """
        ...
    def change_name(self, controller: Controller, new_name: str, name_change: bool) -> None:
        r"""
        x.change_name(controller, new_name, name_change) -> None
        Sets the name for a controller
        
        Args:
            controller (Controller): The controller of the player to change the name of
            new_name (str): The name to set the player to
            name_change (bool): Whether the name is changing or if this is the first time it has been set
        """
        ...
    def can_spectate(self, viewer: PlayerController, view_target: PlayerState) -> bool:
        r"""
        x.can_spectate(viewer, view_target) -> bool
        Return whether Viewer is allowed to spectate from the point of view of ViewTarget.
        
        Args:
            viewer (PlayerController): 
            view_target (PlayerState): 
        
        Returns:
            bool:
        """
        ...

class GameMode(GameModeBase):
    r"""
    GameMode is a subclass of GameModeBase that behaves like a multiplayer match-based game.
    It has default behavior for picking spawn points and match state.
    If you want a simpler base, inherit from GameModeBase instead.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameMode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_pawn_class`` (type(Class)):  [Read-Write] The default pawn class used by players.
    - ``default_player_name`` (Text):  [Read-Write] The default player name assigned to players that join with no name specified.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``delayed_start`` (bool):  [Read-Write] Whether the game should immediately start when the first player logs in. Affects the default behavior of ReadyToStartMatch
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``game_net_driver_replication_system`` (ReplicationSystem):  [Read-Write] Can be used to request a specific replication system for a GameNetDriver that will replicate this game mode.
      Leave to Default to use the game engine's preferred system.
      Useful when migrating from one repsystem to another and a game mode does not fully support both repsystem yet.
    - ``game_session_class`` (type(Class)):  [Read-Write] Class of GameSession, which handles login approval and online game interface
    - ``game_state_class`` (type(Class)):  [Read-Write] Class of GameState associated with this GameMode.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``hud_class`` (type(Class)):  [Read-Write] HUD class this game uses.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``inactive_player_state_life_span`` (float):  [Read-Write] Time a playerstate will stick around in an inactive state after a player logout
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``max_inactive_players`` (int32):  [Read-Write] The maximum number of inactive players before we kick the oldest ones out
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``min_respawn_delay`` (float):  [Read-Write] Minimum time before player can respawn after dying.
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``num_bots`` (int32):  [Read-Write] number of non-human players (AI controlled but participating as a player).
    - ``num_players`` (int32):  [Read-Write] Current number of human players.
    - ``num_spectators`` (int32):  [Read-Write] Current number of spectators.
    - ``num_travelling_players`` (int32):  [Read-Write] Number of players that are still traveling from a previous map
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``options_string`` (str):  [Read-Write] Save options string and parse it when needed
    - ``pauseable`` (bool):  [Read-Write] Whether the game is pauseable.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_controller_class`` (type(Class)):  [Read-Write] The class of PlayerController to spawn for players logging in.
    - ``player_state_class`` (type(Class)):  [Read-Write] A PlayerState of this class will be associated with every player to replicate relevant player information to all clients.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replay_spectator_player_controller_class`` (type(Class)):  [Read-Write] The PlayerController class used when spectating a network replay.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``server_stat_replicator_class`` (type(Class)):  [Read-Write]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``spectator_class`` (type(Class)):  [Read-Write] The pawn class used by the PlayerController for players when spectating.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``start_players_as_spectators`` (bool):  [Read-Write] Whether players should immediately spawn when logging in, or stay as spectators until they manually spawn
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_seamless_travel`` (bool):  [Read-Write] Whether the game perform map travels using SeamlessTravel() which loads in the background and doesn't disconnect clients
    """
    @property
    def delayed_start(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the game should immediately start when the first player logs in. Affects the default behavior of ReadyToStartMatch
        """
        ...
    @property
    def num_spectators(self) -> int:
        r"""
        (int32):  [Read-Only] Current number of spectators.
        """
        ...
    @property
    def num_players(self) -> int:
        r"""
        (int32):  [Read-Only] Current number of human players.
        """
        ...
    @property
    def num_bots(self) -> int:
        r"""
        (int32):  [Read-Only] number of non-human players (AI controlled but participating as a player).
        """
        ...
    @property
    def min_respawn_delay(self) -> float:
        r"""
        (float):  [Read-Only] Minimum time before player can respawn after dying.
        """
        ...
    @property
    def num_travelling_players(self) -> int:
        r"""
        (int32):  [Read-Only] Number of players that are still traveling from a previous map
        """
        ...
    def start_match(self) -> None:
        r"""
        x.start_match() -> None
        Transition from WaitingToStart to InProgress. You can call this manually, will also get called if ReadyToStartMatch returns true
        """
        ...
    def say(self, msg: str) -> None:
        r"""
        x.say(msg) -> None
        Exec command to broadcast a string to all players
        
        Args:
            msg (str):
        """
        ...
    def restart_game(self) -> None:
        r"""
        x.restart_game() -> None
        Restart the game, by default travel to the current map
        """
        ...
    def ready_to_start_match(self) -> bool:
        r"""
        x.ready_to_start_match() -> bool
        Returns true if ready to Start Match. Games should override this
        
        Returns:
            bool:
        """
        ...
    def ready_to_end_match(self) -> bool:
        r"""
        x.ready_to_end_match() -> bool
        Returns true if ready to End Match. Games should override this
        
        Returns:
            bool:
        """
        ...
    def on_set_match_state(self, new_state: Name) -> None:
        r"""
        x.on_set_match_state(new_state) -> None
        Implementable event to respond to match state changes
        
        Args:
            new_state (Name):
        """
        ...
    def is_match_in_progress(self) -> bool:
        r"""
        x.is_match_in_progress() -> bool
        Returns true if the match state is InProgress or other gameplay state
        
        Returns:
            bool:
        """
        ...
    def get_match_state(self) -> Name:
        r"""
        x.get_match_state() -> Name
        Returns the current match state, this is an accessor to protect the state machine flow
        
        Returns:
            Name:
        """
        ...
    def end_match(self) -> None:
        r"""
        x.end_match() -> None
        Transition from InProgress to WaitingPostMatch. You can call this manually, will also get called if ReadyToEndMatch returns true
        """
        ...
    def abort_match(self) -> None:
        r"""
        x.abort_match() -> None
        Report that a match has failed due to unrecoverable error
        """
        ...

class GameplayStatics(BlueprintFunctionLibrary):
    r"""
    Static class with useful gameplay utility functions that can be called from both Blueprint and C++
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameplayStatics.h
    
    """
    @classmethod
    def un_retain_all_sounds_in_sound_class(cls, sound_class: SoundClass) -> None:
        r"""
        X.un_retain_all_sounds_in_sound_class(sound_class) -> None
        Iterate through all sound waves and releases handles to retained chunks. (If the chunk is not being played it will be up for eviction)
        
        Args:
            sound_class (SoundClass):
        """
        ...
    @classmethod
    def unload_stream_level_by_soft_object_ptr(cls, world_context_object: Object, level: World, latent_info: LatentActionInfo, should_block_on_unload: bool) -> None:
        r"""
        X.unload_stream_level_by_soft_object_ptr(world_context_object, level, latent_info, should_block_on_unload) -> None
        Unload a streamed in level (by Object Reference)
        
        Args:
            world_context_object (Object): 
            level (World): 
            latent_info (LatentActionInfo): 
            should_block_on_unload (bool):
        """
        ...
    @classmethod
    def unload_stream_level(cls, world_context_object: Object, level_name: Name, latent_info: LatentActionInfo, should_block_on_unload: bool) -> None:
        r"""
        X.unload_stream_level(world_context_object, level_name, latent_info, should_block_on_unload) -> None
        Unload a streamed in level (by Name)
        
        Args:
            world_context_object (Object): 
            level_name (Name): 
            latent_info (LatentActionInfo): 
            should_block_on_unload (bool):
        """
        ...
    @classmethod
    def suggest_projectile_velocity_moving_target(cls, world_context_object: Object, projectile_start_location: Vector, target_actor: Actor, target_location_offset: Vector = [0.000000, 0.000000, 0.000000], gravity_z_override: float = 0.000000, time_to_target: float = 1.000000, draw_debug_type: DrawDebugTrace = DrawDebugTrace.NONE, draw_debug_time: float = 3.000000, draw_debug_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000]) -> Optional[Vector]:
        r"""
        X.suggest_projectile_velocity_moving_target(world_context_object, projectile_start_location, target_actor, target_location_offset=[0.000000, 0.000000, 0.000000], gravity_z_override=0.000000, time_to_target=1.000000, draw_debug_type=DrawDebugTrace.NONE, draw_debug_time=3.000000, draw_debug_color=[1.000000, 0.000000, 0.000000, 1.000000]) -> Vector or None
        Returns a launch velocity need for a projectile to hit the TargetActor in TimeToTarget seconds based on the TargetActor's current velocity.
        This assumes the projectile is only accelerated by gravity (i.e. no outside forces), and that the TargetActor is moving at a constant velocity.
        
        Args:
            world_context_object (Object): 
            projectile_start_location (Vector): Location the projectile is launched from
            target_actor (Actor): Actor that the projectile should hit in TimeToTarget seconds
            target_location_offset (Vector): Offset to apply to the location the projectile is aiming for
            gravity_z_override (double): Optional override of WorldGravityZ
            time_to_target (double): Time (in seconds) between the projectile being launched and the projectile hitting the TargetActor - clamped to be at least 0.1
            draw_debug_type (DrawDebugTrace): 
            draw_debug_time (float): 
            draw_debug_color (LinearColor): 
        
        Returns:
            Vector or None: 
        
            out_launch_velocity (Vector): The launch velocity returned from this calculation
        """
        ...
    @classmethod
    def suggest_projectile_velocity_custom_arc(cls, world_context_object: Object, start_pos: Vector, end_pos: Vector, override_gravity_z: float = 0.000000, arc_param: float = 0.500000) -> Optional[Vector]:
        r"""
        X.suggest_projectile_velocity_custom_arc(world_context_object, start_pos, end_pos, override_gravity_z=0.000000, arc_param=0.500000) -> Vector or None
        Returns the launch velocity needed for a projectile at rest at StartPos to land on EndPos.
        Assumes a medium arc (e.g. 45 deg on level ground). Projectile velocity is variable and unconstrained.
        Does no tracing.
        
        Args:
            world_context_object (Object): 
            start_pos (Vector): Start position of the simulation
            end_pos (Vector): Desired end location for the simulation
            override_gravity_z (float): Optional override of WorldGravityZ
            arc_param (float): Change height of arc between 0.0-1.0 where 0.5 is the default medium arc, 0 is up, and 1 is directly toward EndPos.
        
        Returns:
            Vector or None: 
        
            out_launch_velocity (Vector): Returns the launch velocity required to reach the EndPos
        """
        ...
    @classmethod
    def spawn_sound_attached(cls, sound: SoundBase, attach_to_component: SceneComponent, attach_point_name: Name = "None", location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], location_type: AttachLocation = AttachLocation.KEEP_RELATIVE_OFFSET, stop_when_attached_to_destroyed: bool = False, volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, attenuation_settings: SoundAttenuation = None, concurrency_settings: SoundConcurrency = None, auto_destroy: bool = True) -> AudioComponent:
        r"""
        X.spawn_sound_attached(sound, attach_to_component, attach_point_name="None", location=[0.000000, 0.000000, 0.000000], rotation=[0.000000, 0.000000, 0.000000], location_type=AttachLocation.KEEP_RELATIVE_OFFSET, stop_when_attached_to_destroyed=False, volume_multiplier=1.000000, pitch_multiplier=1.000000, start_time=0.000000, attenuation_settings=None, concurrency_settings=None, auto_destroy=True) -> AudioComponent
        This function allows users to create and play Audio Components attached to a specific Scene Component.
        Useful for spatialized and/or distance-attenuated sounds that need to follow another object in space.
        
        Args:
            sound (SoundBase): sound to play
            attach_to_component (SceneComponent): 
            attach_point_name (Name): Optional named point within the AttachComponent to play the sound at
            location (Vector): Depending on the value of Location Type this is either a relative offset from the attach component/point or an absolute world position that will be translated to a relative offset
            rotation (Rotator): Depending on the value of Location Type this is either a relative offset from the attach component/point or an absolute world rotation that will be translated to a relative offset
            location_type (AttachLocation): Specifies whether Location is a relative offset or an absolute world position
            stop_when_attached_to_destroyed (bool): Specifies whether the sound should stop playing when the owner of the attach to component is destroyed.
            volume_multiplier (float): A linear scalar multiplied with the volume, in order to make the sound louder or softer.
            pitch_multiplier (float): A linear scalar multiplied with the pitch.
            start_time (float): How far in to the sound to begin playback at
            attenuation_settings (SoundAttenuation): Override attenuation settings package to play sound with
            concurrency_settings (SoundConcurrency): Override concurrency settings package to play sound with
            auto_destroy (bool): Whether the returned audio component will be automatically cleaned up when the sound finishes (by completing or stopping) or whether it can be reactivated
        
        Returns:
            AudioComponent: An audio component to manipulate the spawned sound
        """
        ...
    @classmethod
    def play_sound_attached(cls, sound: SoundBase, attach_to_component: SceneComponent, attach_point_name: Name = "None", location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], location_type: AttachLocation = AttachLocation.KEEP_RELATIVE_OFFSET, stop_when_attached_to_destroyed: bool = False, volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, attenuation_settings: SoundAttenuation = None, concurrency_settings: SoundConcurrency = None, auto_destroy: bool = True) -> AudioComponent:
        r"""
        deprecated: 'play_sound_attached' was renamed to 'spawn_sound_attached'.
        """
        ...
    @classmethod
    def spawn_sound_at_location(cls, world_context_object: Object, sound: SoundBase, location: Vector, rotation: Rotator = [0.000000, 0.000000, 0.000000], volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, attenuation_settings: SoundAttenuation = None, concurrency_settings: SoundConcurrency = None, auto_destroy: bool = True) -> AudioComponent:
        r"""
        X.spawn_sound_at_location(world_context_object, sound, location, rotation=[0.000000, 0.000000, 0.000000], volume_multiplier=1.000000, pitch_multiplier=1.000000, start_time=0.000000, attenuation_settings=None, concurrency_settings=None, auto_destroy=True) -> AudioComponent
        Spawns a sound at the given location. This does not travel with any actor. Replication is also not handled at this point.
        
        Args:
            world_context_object (Object): 
            sound (SoundBase): sound to play
            location (Vector): World position to play sound at
            rotation (Rotator): World rotation to play sound at
            volume_multiplier (float): A linear scalar multiplied with the volume, in order to make the sound louder or softer.
            pitch_multiplier (float): A linear scalar multiplied with the pitch.
            start_time (float): How far in to the sound to begin playback at
            attenuation_settings (SoundAttenuation): Override attenuation settings package to play sound with
            concurrency_settings (SoundConcurrency): Override concurrency settings package to play sound with
            auto_destroy (bool): Whether the returned audio component will be automatically cleaned up when the sound finishes (by completing or stopping) or whether it can be reactivated
        
        Returns:
            AudioComponent: An audio component to manipulate the spawned sound
        """
        ...
    @classmethod
    def spawn_sound2d(cls, world_context_object: Object, sound: SoundBase, volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, concurrency_settings: SoundConcurrency = None, persist_across_level_transition: bool = False, auto_destroy: bool = True) -> AudioComponent:
        r"""
        X.spawn_sound2d(world_context_object, sound, volume_multiplier=1.000000, pitch_multiplier=1.000000, start_time=0.000000, concurrency_settings=None, persist_across_level_transition=False, auto_destroy=True) -> AudioComponent
        This function allows users to create Audio Components with settings specifically for non-spatialized,
        non-distance-attenuated sounds. Audio Components created using this function by default will not have
        Spatialization applied. Sound instances will begin playing upon spawning this Audio Component.
        
        * Not Replicated.
        
        Args:
            world_context_object (Object): 
            sound (SoundBase): Sound to play.
            volume_multiplier (float): A linear scalar multiplied with the volume, in order to make the sound louder or softer.
            pitch_multiplier (float): A linear scalar multiplied with the pitch.
            start_time (float): How far in to the sound to begin playback at
            concurrency_settings (SoundConcurrency): Override concurrency settings package to play sound with
            persist_across_level_transition (bool): 
            auto_destroy (bool): Whether the returned audio component will be automatically cleaned up when the sound finishes (by completing or stopping) or whether it can be reactivated
        
        Returns:
            AudioComponent: An audio component to manipulate the spawned sound
        """
        ...
    @classmethod
    def spawn_force_feedback_attached(cls, force_feedback_effect: ForceFeedbackEffect, attach_to_component: SceneComponent, attach_point_name: Name = "None", location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], location_type: AttachLocation = AttachLocation.KEEP_RELATIVE_OFFSET, stop_when_attached_to_destroyed: bool = False, looping: bool = False, intensity_multiplier: float = 1.000000, start_time: float = 0.000000, attenuation_settings: ForceFeedbackAttenuation = None, auto_destroy: bool = True) -> ForceFeedbackComponent:
        r"""
        X.spawn_force_feedback_attached(force_feedback_effect, attach_to_component, attach_point_name="None", location=[0.000000, 0.000000, 0.000000], rotation=[0.000000, 0.000000, 0.000000], location_type=AttachLocation.KEEP_RELATIVE_OFFSET, stop_when_attached_to_destroyed=False, looping=False, intensity_multiplier=1.000000, start_time=0.000000, attenuation_settings=None, auto_destroy=True) -> ForceFeedbackComponent
        Plays a force feedback effect attached to and following the specified component. This is a fire and forget effect. Replication is also not handled at this point.
        
        Args:
            force_feedback_effect (ForceFeedbackEffect): effect to play
            attach_to_component (SceneComponent): 
            attach_point_name (Name): Optional named point within the AttachComponent to attach to
            location (Vector): Depending on the value of Location Type this is either a relative offset from the attach component/point or an absolute world position that will be translated to a relative offset
            rotation (Rotator): Depending on the value of Location Type this is either a relative offset from the attach component/point or an absolute world rotation that will be translated to a relative offset
            location_type (AttachLocation): Specifies whether Location is a relative offset or an absolute world position
            stop_when_attached_to_destroyed (bool): Specifies whether the feedback effect should stop playing when the owner of the attach to component is destroyed.
            looping (bool): 
            intensity_multiplier (float): Intensity multiplier
            start_time (float): How far in to the feedback effect to begin playback at
            attenuation_settings (ForceFeedbackAttenuation): Override attenuation settings package to play effect with
            auto_destroy (bool): Whether the returned force feedback component will be automatically cleaned up when the feedback patern finishes (by completing or stopping) or whether it can be reactivated
        
        Returns:
            ForceFeedbackComponent: Force Feedback Component to manipulate the playing feedback effect with
        """
        ...
    @classmethod
    def spawn_force_feedback_at_location(cls, world_context_object: Object, force_feedback_effect: ForceFeedbackEffect, location: Vector, rotation: Rotator = [0.000000, 0.000000, 0.000000], looping: bool = False, intensity_multiplier: float = 1.000000, start_time: float = 0.000000, attenuation_settings: ForceFeedbackAttenuation = None, auto_destroy: bool = True) -> ForceFeedbackComponent:
        r"""
        X.spawn_force_feedback_at_location(world_context_object, force_feedback_effect, location, rotation=[0.000000, 0.000000, 0.000000], looping=False, intensity_multiplier=1.000000, start_time=0.000000, attenuation_settings=None, auto_destroy=True) -> ForceFeedbackComponent
        Plays a force feedback effect at the given location. This is a fire and forget effect and does not travel with any actor. Replication is also not handled at this point.
        
        Args:
            world_context_object (Object): 
            force_feedback_effect (ForceFeedbackEffect): effect to play
            location (Vector): World position to center the effect at
            rotation (Rotator): World rotation to center the effect at
            looping (bool): 
            intensity_multiplier (float): Intensity multiplier
            start_time (float): How far in to the feedback effect to begin playback at
            attenuation_settings (ForceFeedbackAttenuation): Override attenuation settings package to play effect with
            auto_destroy (bool): Whether the returned force feedback component will be automatically cleaned up when the feedback pattern finishes (by completing or stopping) or whether it can be reactivated
        
        Returns:
            ForceFeedbackComponent: Force Feedback Component to manipulate the playing feedback effect with
        """
        ...
    @classmethod
    def spawn_emitter_attached(cls, emitter_template: ParticleSystem, attach_to_component: SceneComponent, attach_point_name: Name = "None", location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], scale: Vector = [1.000000, 1.000000, 1.000000], location_type: AttachLocation = AttachLocation.KEEP_RELATIVE_OFFSET, auto_destroy: bool = True, pooling_method: PSCPoolMethod = PSCPoolMethod.NONE, auto_activate: bool = True) -> ParticleSystemComponent:
        r"""
        X.spawn_emitter_attached(emitter_template, attach_to_component, attach_point_name="None", location=[0.000000, 0.000000, 0.000000], rotation=[0.000000, 0.000000, 0.000000], scale=[1.000000, 1.000000, 1.000000], location_type=AttachLocation.KEEP_RELATIVE_OFFSET, auto_destroy=True, pooling_method=PSCPoolMethod.NONE, auto_activate=True) -> ParticleSystemComponent
        Plays the specified effect attached to and following the specified component. The system will go away when the effect is complete. Does not replicate.
        
        Args:
            emitter_template (ParticleSystem): particle system to create
            attach_to_component (SceneComponent): 
            attach_point_name (Name): Optional named point within the AttachComponent to spawn the emitter at
            location (Vector): Depending on the value of LocationType this is either a relative offset from the attach component/point or an absolute world location that will be translated to a relative offset (if LocationType is KeepWorldPosition).
            rotation (Rotator): Depending on the value of LocationType this is either a relative offset from the attach component/point or an absolute world rotation that will be translated to a relative offset (if LocationType is KeepWorldPosition).
            scale (Vector): Depending on the value of LocationType this is either a relative scale from the attach component or an absolute world scale that will be translated to a relative scale (if LocationType is KeepWorldPosition).
            location_type (AttachLocation): Specifies whether Location is a relative offset or an absolute world position
            auto_destroy (bool): Whether the component will automatically be destroyed when the particle system completes playing or whether it can be reactivated
            pooling_method (PSCPoolMethod): Method used for pooling this component. Defaults to none.
            auto_activate (bool): Whether the component will be automatically activated on creation.
        
        Returns:
            ParticleSystemComponent:
        """
        ...
    @classmethod
    def spawn_emitter_at_location(cls, world_context_object: Object, emitter_template: ParticleSystem, location: Vector, rotation: Rotator = [0.000000, 0.000000, 0.000000], scale: Vector = [1.000000, 1.000000, 1.000000], auto_destroy: bool = True, pooling_method: PSCPoolMethod = PSCPoolMethod.NONE, auto_activate_system: bool = True) -> ParticleSystemComponent:
        r"""
        X.spawn_emitter_at_location(world_context_object, emitter_template, location, rotation=[0.000000, 0.000000, 0.000000], scale=[1.000000, 1.000000, 1.000000], auto_destroy=True, pooling_method=PSCPoolMethod.NONE, auto_activate_system=True) -> ParticleSystemComponent
        Plays the specified effect at the given location and rotation, fire and forget. The system will go away when the effect is complete. Does not replicate.
        
        Args:
            world_context_object (Object): Object that we can obtain a world context from
            emitter_template (ParticleSystem): particle system to create
            location (Vector): location to place the effect in world space
            rotation (Rotator): rotation to place the effect in world space
            scale (Vector): scale to create the effect at
            auto_destroy (bool): Whether the component will automatically be destroyed when the particle system completes playing or whether it can be reactivated
            pooling_method (PSCPoolMethod): Method used for pooling this component. Defaults to none.
            auto_activate_system (bool): 
        
        Returns:
            ParticleSystemComponent:
        """
        ...
    @classmethod
    def spawn_dialogue_attached(cls, dialogue: DialogueWave, context: DialogueContext, attach_to_component: SceneComponent, attach_point_name: Name = "None", location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], location_type: AttachLocation = AttachLocation.KEEP_RELATIVE_OFFSET, stop_when_attached_to_destroyed: bool = False, volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, attenuation_settings: SoundAttenuation = None, auto_destroy: bool = True) -> AudioComponent:
        r"""
        X.spawn_dialogue_attached(dialogue, context, attach_to_component, attach_point_name="None", location=[0.000000, 0.000000, 0.000000], rotation=[0.000000, 0.000000, 0.000000], location_type=AttachLocation.KEEP_RELATIVE_OFFSET, stop_when_attached_to_destroyed=False, volume_multiplier=1.000000, pitch_multiplier=1.000000, start_time=0.000000, attenuation_settings=None, auto_destroy=True) -> AudioComponent
        Spawns a DialogueWave, a special type of Asset that requires Context data in order to resolve a specific SoundBase,
            which is then passed on to the new Audio Component. This function allows users to create and play Audio Components
            attached to a specific Scene Component. Useful for spatialized and/or distance-attenuated dialogue that needs to
            follow another object in space.
        
        Args:
            dialogue (DialogueWave): dialogue to play
            context (DialogueContext): context the dialogue is to play in
            attach_to_component (SceneComponent): 
            attach_point_name (Name): Optional named point within the AttachComponent to play the sound at
            location (Vector): Depending on the value of Location Type this is either a relative offset from the attach component/point or an absolute world position that will be translated to a relative offset
            rotation (Rotator): Depending on the value of Location Type this is either a relative offset from the attach component/point or an absolute world rotation that will be translated to a relative offset
            location_type (AttachLocation): Specifies whether Location is a relative offset or an absolute world position
            stop_when_attached_to_destroyed (bool): Specifies whether the sound should stop playing when the owner its attached to is destroyed.
            volume_multiplier (float): A linear scalar multiplied with the volume, in order to make the sound louder or softer.
            pitch_multiplier (float): A linear scalar multiplied with the pitch.
            start_time (float): How far in to the dialogue to begin playback at
            attenuation_settings (SoundAttenuation): Override attenuation settings package to play sound with
            auto_destroy (bool): Whether the returned audio component will be automatically cleaned up when the sound finishes (by completing or stopping) or whether it can be reactivated
        
        Returns:
            AudioComponent: Audio Component to manipulate the playing dialogue with
        """
        ...
    @classmethod
    def play_dialogue_attached(cls, dialogue: DialogueWave, context: DialogueContext, attach_to_component: SceneComponent, attach_point_name: Name = "None", location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], location_type: AttachLocation = AttachLocation.KEEP_RELATIVE_OFFSET, stop_when_attached_to_destroyed: bool = False, volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, attenuation_settings: SoundAttenuation = None, auto_destroy: bool = True) -> AudioComponent:
        r"""
        deprecated: 'play_dialogue_attached' was renamed to 'spawn_dialogue_attached'.
        """
        ...
    @classmethod
    def spawn_dialogue_at_location(cls, world_context_object: Object, dialogue: DialogueWave, context: DialogueContext, location: Vector, rotation: Rotator = [0.000000, 0.000000, 0.000000], volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, attenuation_settings: SoundAttenuation = None, auto_destroy: bool = True) -> AudioComponent:
        r"""
        X.spawn_dialogue_at_location(world_context_object, dialogue, context, location, rotation=[0.000000, 0.000000, 0.000000], volume_multiplier=1.000000, pitch_multiplier=1.000000, start_time=0.000000, attenuation_settings=None, auto_destroy=True) -> AudioComponent
        Spawns a DialogueWave, a special type of Asset that requires Context data in order to resolve a specific SoundBase,
        which is then passed on to the new Audio Component. This function allows users to create and play Audio Components at a
        specific World Location and Rotation. Useful for spatialized and/or distance-attenuated dialogue.
        
        Args:
            world_context_object (Object): 
            dialogue (DialogueWave): Dialogue to play
            context (DialogueContext): Context the dialogue is to play in
            location (Vector): World position to play dialogue at
            rotation (Rotator): World rotation to play dialogue at
            volume_multiplier (float): A linear scalar multiplied with the volume, in order to make the sound louder or softer.
            pitch_multiplier (float): A linear scalar multiplied with the pitch.
            start_time (float): How far into the dialogue to begin playback at
            attenuation_settings (SoundAttenuation): Override attenuation settings package to play sound with
            auto_destroy (bool): Whether the returned audio component will be automatically cleaned up when the sound finishes (by completing or stopping) or whether it can be reactivated
        
        Returns:
            AudioComponent: Audio Component to manipulate the playing dialogue with
        """
        ...
    @classmethod
    def spawn_dialogue2d(cls, world_context_object: Object, dialogue: DialogueWave, context: DialogueContext, volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, auto_destroy: bool = True) -> AudioComponent:
        r"""
        X.spawn_dialogue2d(world_context_object, dialogue, context, volume_multiplier=1.000000, pitch_multiplier=1.000000, start_time=0.000000, auto_destroy=True) -> AudioComponent
        Spawns a DialogueWave, a special type of Asset that requires Context data in order to resolve a specific SoundBase,
        which is then passed on to the new Audio Component. Audio Components created using this function by default will not
        have Spatialization applied. Sound instances will begin playing upon spawning this Audio Component.
        
        * Not Replicated.
        
        Args:
            world_context_object (Object): 
            dialogue (DialogueWave): dialogue to play
            context (DialogueContext): context the dialogue is to play in
            volume_multiplier (float): A linear scalar multiplied with the volume, in order to make the sound louder or softer.
            pitch_multiplier (float): A linear scalar multiplied with the pitch.
            start_time (float): How far in to the dialogue to begin playback at
            auto_destroy (bool): Whether the returned audio component will be automatically cleaned up when the sound finishes (by completing or stopping) or whether it can be reactivated
        
        Returns:
            AudioComponent: An audio component to manipulate the spawned sound
        """
        ...
    @classmethod
    def spawn_decal_attached(cls, decal_material: MaterialInterface, decal_size: Vector, attach_to_component: SceneComponent, attach_point_name: Name = "None", location: Vector = [0.000000, 0.000000, 0.000000], rotation: Rotator = [0.000000, 0.000000, 0.000000], location_type: AttachLocation = AttachLocation.KEEP_RELATIVE_OFFSET, life_span: float = 0.000000) -> DecalComponent:
        r"""
        X.spawn_decal_attached(decal_material, decal_size, attach_to_component, attach_point_name="None", location=[0.000000, 0.000000, 0.000000], rotation=[0.000000, 0.000000, 0.000000], location_type=AttachLocation.KEEP_RELATIVE_OFFSET, life_span=0.000000) -> DecalComponent
        Spawns a decal attached to and following the specified component. Does not replicate.
        
        Args:
            decal_material (MaterialInterface): decal's material
            decal_size (Vector): size of decal
            attach_to_component (SceneComponent): 
            attach_point_name (Name): Optional named point within the AttachComponent to spawn the emitter at
            location (Vector): Depending on the value of Location Type this is either a relative offset from the attach component/point or an absolute world position that will be translated to a relative offset
            rotation (Rotator): Depending on the value of LocationType this is either a relative offset from the attach component/point or an absolute world rotation that will be translated to a realative offset
            location_type (AttachLocation): Specifies whether Location is a relative offset or an absolute world position
            life_span (float): destroy decal component after time runs out (0 = infinite)
        
        Returns:
            DecalComponent:
        """
        ...
    @classmethod
    def spawn_decal_at_location(cls, world_context_object: Object, decal_material: MaterialInterface, decal_size: Vector, location: Vector, rotation: Rotator = [0.000000, -90.000000, 0.000000], life_span: float = 0.000000) -> DecalComponent:
        r"""
        X.spawn_decal_at_location(world_context_object, decal_material, decal_size, location, rotation=[0.000000, -90.000000, 0.000000], life_span=0.000000) -> DecalComponent
        Spawns a decal at the given location and rotation, fire and forget. Does not replicate.
        
        Args:
            world_context_object (Object): 
            decal_material (MaterialInterface): decal's material
            decal_size (Vector): size of decal
            location (Vector): location to place the decal in world space
            rotation (Rotator): rotation to place the decal in world space
            life_span (float): destroy decal component after time runs out (0 = infinite)
        
        Returns:
            DecalComponent:
        """
        ...
    @classmethod
    def set_world_origin_location(cls, world_context_object: Object, new_location: IntVector) -> None:
        r"""
        X.set_world_origin_location(world_context_object, new_location) -> None
        Requests a new location for a world origin.
        
        Args:
            world_context_object (Object): 
            new_location (IntVector):
        """
        ...
    @classmethod
    def set_viewport_mouse_capture_mode(cls, world_context_object: Object, mouse_capture_mode: MouseCaptureMode) -> None:
        r"""
        X.set_viewport_mouse_capture_mode(world_context_object, mouse_capture_mode) -> None
        Sets the current viewport mouse capture mode
        
        Args:
            world_context_object (Object): 
            mouse_capture_mode (MouseCaptureMode):
        """
        ...
    @classmethod
    def set_subtitles_enabled(cls, enabled: bool) -> None:
        r"""
        X.set_subtitles_enabled(enabled) -> None
        Will set subtitles to be enabled or disabled.
        
        Args:
            enabled (bool): will enable subtitle drawing if true, disable if false.
        """
        ...
    @classmethod
    def set_sound_mix_class_override(cls, world_context_object: Object, sound_mix_modifier: SoundMix, sound_class: SoundClass, volume: float = 1.000000, pitch: float = 1.000000, fade_in_time: float = 1.000000, apply_to_children: bool = True) -> None:
        r"""
        X.set_sound_mix_class_override(world_context_object, sound_mix_modifier, sound_class, volume=1.000000, pitch=1.000000, fade_in_time=1.000000, apply_to_children=True) -> None
        Overrides the sound class adjuster in the given sound mix. If the sound class does not exist in the input sound mix,
            the sound class adjuster will be added to the list of active sound mix modifiers.
        
        Args:
            world_context_object (Object): 
            sound_mix_modifier (SoundMix): The sound mix to modify.
            sound_class (SoundClass): The sound class to override (or add) in the sound mix.
            volume (float): The volume scale to set the sound class adjuster to.
            pitch (float): The pitch scale to set the sound class adjuster to.
            fade_in_time (float): The interpolation time to use to go from the current sound class adjuster values to the new values.
            apply_to_children (bool): Whether or not to apply this override to the sound class' children or to just the specified sound class.
        """
        ...
    @classmethod
    def set_sound_class_distance_scale(cls, world_context_object: Object, sound_class: SoundClass, distance_attenuation_scale: float, time_sec: float = 0.000000) -> None:
        r"""
        X.set_sound_class_distance_scale(world_context_object, sound_class, distance_attenuation_scale, time_sec=0.000000) -> None
        Linearly interpolates the attenuation distance scale value from it's current attenuation distance override value
        (1.0f it not overridden) to its new attenuation distance override, over the given amount of time
        
        * Fire and Forget.
        * Not Replicated.
        
        Args:
            world_context_object (Object): 
            sound_class (SoundClass): Sound class to to use to set the attenuation distance scale on.
            distance_attenuation_scale (float): A scalar for the attenuation distance used for computing distance attenuation.
            time_sec (float): A time value to linearly interpolate from the current distance attenuation scale value to the new value.
        """
        ...
    @classmethod
    def set_player_platform_user_id(cls, player_controller: PlayerController, user_id: PlatformUserId) -> None:
        r"""
        X.set_player_platform_user_id(player_controller, user_id) -> None
        Sets what platform user id a player should be using. This only works for local player controllers.
        
        Args:
            player_controller (PlayerController): 
            user_id (PlatformUserId):
        """
        ...
    @classmethod
    def set_player_controller_id(cls, player: PlayerController, controller_id: int) -> None:
        r"""
        X.set_player_controller_id(player, controller_id) -> None
        Sets what physical controller ID a player should be using. This only works for local player controllers.
        
        Args:
            player (PlayerController): The player controller of the player to change the controller ID of
            controller_id (int32): The controller ID to assign to this player
        """
        ...
    @classmethod
    def set_max_audio_channels_scaled(cls, world_context_object: Object, max_channel_count_scale: float) -> None:
        r"""
        X.set_max_audio_channels_scaled(world_context_object, max_channel_count_scale) -> None
        Sets the max number of voices (also known as "channels") dynamically by percentage. E.g. if you want to temporarily
        reduce voice count by 50%, use 0.50. Later, you can return to the original max voice count by using 1.0.
        
        Args:
            world_context_object (Object): 
            max_channel_count_scale (float): The percentage of the original voice count to set the max number of voices to
        """
        ...
    @classmethod
    def set_global_time_dilation(cls, world_context_object: Object, time_dilation: float) -> None:
        r"""
        X.set_global_time_dilation(world_context_object, time_dilation) -> None
        Sets the global time dilation.
        
        Args:
            world_context_object (Object): 
            time_dilation (float): value to set the global time dilation to
        """
        ...
    @classmethod
    def set_time_dilation(cls, world_context_object: Object, time_dilation: float) -> None:
        r"""
        deprecated: 'set_time_dilation' was renamed to 'set_global_time_dilation'.
        """
        ...
    @classmethod
    def set_global_pitch_modulation(cls, world_context_object: Object, pitch_modulation: float, time_sec: float) -> None:
        r"""
        X.set_global_pitch_modulation(world_context_object, pitch_modulation, time_sec) -> None
        Sets a global pitch modulation scalar that will apply to all non-UI sounds
        
        * Fire and Forget.
        * Not Replicated.
        
        Args:
            world_context_object (Object): 
            pitch_modulation (float): A pitch modulation value to globally set.
            time_sec (float): A time value to linearly interpolate the global modulation pitch over from it's current value.
        """
        ...
    @classmethod
    def set_global_listener_focus_parameters(cls, world_context_object: Object, focus_azimuth_scale: float = 1.000000, non_focus_azimuth_scale: float = 1.000000, focus_distance_scale: float = 1.000000, non_focus_distance_scale: float = 1.000000, focus_volume_scale: float = 1.000000, non_focus_volume_scale: float = 1.000000, focus_priority_scale: float = 1.000000, non_focus_priority_scale: float = 1.000000) -> None:
        r"""
        X.set_global_listener_focus_parameters(world_context_object, focus_azimuth_scale=1.000000, non_focus_azimuth_scale=1.000000, focus_distance_scale=1.000000, non_focus_distance_scale=1.000000, focus_volume_scale=1.000000, non_focus_volume_scale=1.000000, focus_priority_scale=1.000000, non_focus_priority_scale=1.000000) -> None
        Sets the global listener focus parameters, which will scale focus behavior of sounds based on their focus azimuth
        settings in their attenuation settings.
        
        * Fire and Forget.
        * Not Replicated.
        
        Args:
            world_context_object (Object): 
            focus_azimuth_scale (float): An angle scale value used to scale the azimuth angle that defines where sounds are in-focus.
            non_focus_azimuth_scale (float): 
            focus_distance_scale (float): A distance scale value to use for sounds which are in-focus. Values < 1.0 will reduce perceived distance to sounds, values > 1.0 will increase perceived distance to in-focus sounds.
            non_focus_distance_scale (float): A distance scale value to use for sounds which are out-of-focus. Values < 1.0 will reduce perceived distance to sounds, values > 1.0 will increase perceived distance to in-focus sounds.
            focus_volume_scale (float): 
            non_focus_volume_scale (float): 
            focus_priority_scale (float): A priority scale value (> 0.0) to use for sounds which are in-focus. Values < 1.0 will reduce the priority of in-focus sounds, values > 1.0 will increase the priority of in-focus sounds.
            non_focus_priority_scale (float): A priority scale value (> 0.0) to use for sounds which are out-of-focus. Values < 1.0 will reduce the priority of sounds out-of-focus sounds, values > 1.0 will increase the priority of out-of-focus sounds.
        """
        ...
    @classmethod
    def set_game_paused(cls, world_context_object: Object, paused: bool) -> bool:
        r"""
        X.set_game_paused(world_context_object, paused) -> bool
        Sets the game's paused state
        
        Args:
            world_context_object (Object): 
            paused (bool): Whether the game should be paused or not
        
        Returns:
            bool: Whether the game was successfully paused/unpaused
        """
        ...
    @classmethod
    def set_force_disable_splitscreen(cls, world_context_object: Object, disable: bool) -> None:
        r"""
        X.set_force_disable_splitscreen(world_context_object, disable) -> None
        Enables split screen
        
        Args:
            world_context_object (Object): 
            disable (bool): Whether the viewport should split screen between local players or not
        """
        ...
    @classmethod
    def set_enable_world_rendering(cls, world_context_object: Object, enable: bool) -> None:
        r"""
        X.set_enable_world_rendering(world_context_object, enable) -> None
        Enabled rendering of the world
        
        Args:
            world_context_object (Object): 
            enable (bool): Whether the world should be rendered or not
        """
        ...
    @classmethod
    def set_base_sound_mix(cls, world_context_object: Object, sound_mix: SoundMix) -> None:
        r"""
        X.set_base_sound_mix(world_context_object, sound_mix) -> None
        Set the sound mix of the audio system for special EQing
        
        Args:
            world_context_object (Object): 
            sound_mix (SoundMix):
        """
        ...
    @classmethod
    def k2_set_sound_mode(cls, world_context_object: Object, sound_mix: SoundMix) -> None:
        r"""
        deprecated: 'k2_set_sound_mode' was renamed to 'set_base_sound_mix'.
        """
        ...
    @classmethod
    def set_active_spatial_plugin_by_name(cls, world_context_object: Object, plugin_name: Name) -> bool:
        r"""
        X.set_active_spatial_plugin_by_name(world_context_object, plugin_name) -> bool
        Get list of available Audio Spatialization Plugins
        
        Args:
            world_context_object (Object): 
            plugin_name (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def save_game_to_slot(cls, save_game_object: SaveGame, slot_name: str, user_index: int) -> bool:
        r"""
        X.save_game_to_slot(save_game_object, slot_name, user_index) -> bool
        Save the contents of the SaveGameObject to a platform-specific save slot/file.
        note: This will write out all non-transient properties, the SaveGame property flag is not checked
        
        Args:
            save_game_object (SaveGame): Object that contains data about the save game that we want to write out
            slot_name (str): Name of save game slot to save to.
            user_index (int32): The platform user index that identifies the user doing the saving, ignored on some platforms.
        
        Returns:
            bool: Whether we successfully saved this information
        """
        ...
    @classmethod
    def remove_player(cls, player: PlayerController, destroy_pawn: bool) -> None:
        r"""
        X.remove_player(player, destroy_pawn) -> None
        Removes a local player from this game.
        
        Args:
            player (PlayerController): The player controller of the player to be removed
            destroy_pawn (bool): Whether the controlled pawn should be deleted as well
        """
        ...
    @classmethod
    def rebase_zero_origin_onto_local(cls, world_context_object: Object, world_location: Vector) -> Vector:
        r"""
        X.rebase_zero_origin_onto_local(world_context_object, world_location) -> Vector
        Returns local location for origin based position.
        
        Args:
            world_context_object (Object): 
            world_location (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def rebase_local_origin_onto_zero(cls, world_context_object: Object, world_location: Vector) -> Vector:
        r"""
        X.rebase_local_origin_onto_zero(world_context_object, world_location) -> Vector
        Returns origin based position for local world location.
        
        Args:
            world_context_object (Object): 
            world_location (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def push_sound_mix_modifier(cls, world_context_object: Object, sound_mix_modifier: SoundMix) -> None:
        r"""
        X.push_sound_mix_modifier(world_context_object, sound_mix_modifier) -> None
        Push a sound mix modifier onto the audio system
        
        Args:
            world_context_object (Object): 
            sound_mix_modifier (SoundMix): The Sound Mix Modifier to add to the system
        """
        ...
    @classmethod
    def push_sound_mode(cls, world_context_object: Object, sound_mix_modifier: SoundMix) -> None:
        r"""
        deprecated: 'push_sound_mode' was renamed to 'push_sound_mix_modifier'.
        """
        ...
    @classmethod
    def project_world_to_screen(cls, player: PlayerController, world_position: Vector, player_viewport_relative: bool = False) -> Optional[Vector2D]:
        r"""
        X.project_world_to_screen(player, world_position, player_viewport_relative=False) -> Vector2D or None
        Transforms the given 3D world-space point into a its 2D screen space coordinate.
        
        Args:
            player (PlayerController): Project using this player's view.
            world_position (Vector): World position to project.
            player_viewport_relative (bool): Should this be relative to the player viewport subregion (useful when using player attached widgets in split screen)
        
        Returns:
            Vector2D or None: 
        
            screen_position (Vector2D): (out) Corresponding 2D position in screen space
        """
        ...
    @classmethod
    def prime_sound(cls, sound: SoundBase) -> None:
        r"""
        X.prime_sound(sound) -> None
        Primes the sound, caching the first chunk of streamed audio.
        
        Args:
            sound (SoundBase):
        """
        ...
    @classmethod
    def prime_all_sounds_in_sound_class(cls, sound_class: SoundClass) -> None:
        r"""
        X.prime_all_sounds_in_sound_class(sound_class) -> None
        Primes the sound waves in the given USoundClass, caching the first chunk of streamed audio.
        
        Args:
            sound_class (SoundClass):
        """
        ...
    @classmethod
    def pop_sound_mix_modifier(cls, world_context_object: Object, sound_mix_modifier: SoundMix) -> None:
        r"""
        X.pop_sound_mix_modifier(world_context_object, sound_mix_modifier) -> None
        Pop a sound mix modifier from the audio system
        
        Args:
            world_context_object (Object): 
            sound_mix_modifier (SoundMix): The Sound Mix Modifier to remove from the system
        """
        ...
    @classmethod
    def pop_sound_mode(cls, world_context_object: Object, sound_mix_modifier: SoundMix) -> None:
        r"""
        deprecated: 'pop_sound_mode' was renamed to 'pop_sound_mix_modifier'.
        """
        ...
    @classmethod
    def play_world_camera_shake(cls, world_context_object: Object, shake: Class, epicenter: Vector, inner_radius: float, outer_radius: float, falloff: float = 1.000000, orient_shake_towards_epicenter: bool = False) -> None:
        r"""
        X.play_world_camera_shake(world_context_object, shake, epicenter, inner_radius, outer_radius, falloff=1.000000, orient_shake_towards_epicenter=False) -> None
        Plays an in-world camera shake that affects all nearby local players, with distance-based attenuation. Does not replicate.
        
        Args:
            world_context_object (Object): Object that we can obtain a world context from
            shake (type(Class)): Camera shake asset to use
            epicenter (Vector): location to place the effect in world space
            inner_radius (float): Cameras inside this radius are ignored
            outer_radius (float): Cameras outside of InnerRadius and inside this are effected
            falloff (float): Affects falloff of effect as it nears OuterRadius
            orient_shake_towards_epicenter (bool): Changes the rotation of shake to point towards epicenter instead of forward
        """
        ...
    @classmethod
    def play_sound_at_location(cls, world_context_object: Object, sound: SoundBase, location: Vector, rotation: Rotator, volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, attenuation_settings: SoundAttenuation = None, concurrency_settings: SoundConcurrency = None, owning_actor: Actor = None, initial_params: InitialActiveSoundParams = None) -> None:
        r"""
        X.play_sound_at_location(world_context_object, sound, location, rotation, volume_multiplier=1.000000, pitch_multiplier=1.000000, start_time=0.000000, attenuation_settings=None, concurrency_settings=None, owning_actor=None, initial_params=None) -> None
        Plays a sound at the given location. This is a fire and forget sound and does not travel with any actor.
        Replication is also not handled at this point.
        
        Args:
            world_context_object (Object): 
            sound (SoundBase): sound to play
            location (Vector): World position to play sound at
            rotation (Rotator): World rotation to play sound at
            volume_multiplier (float): A linear scalar multiplied with the volume, in order to make the sound louder or softer.
            pitch_multiplier (float): A linear scalar multiplied with the pitch.
            start_time (float): How far in to the sound to begin playback at
            attenuation_settings (SoundAttenuation): Override attenuation settings package to play sound with
            concurrency_settings (SoundConcurrency): Override concurrency settings package to play sound with
            owning_actor (Actor): The actor to use as the "owner" for concurrency settings purposes. Allows PlaySound calls to do a concurrency limit per owner.
            initial_params (InitialActiveSoundParams):
        """
        ...
    @classmethod
    def play_sound2d(cls, world_context_object: Object, sound: SoundBase, volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, concurrency_settings: SoundConcurrency = None, owning_actor: Actor = None, is_ui_sound: bool = True) -> None:
        r"""
        X.play_sound2d(world_context_object, sound, volume_multiplier=1.000000, pitch_multiplier=1.000000, start_time=0.000000, concurrency_settings=None, owning_actor=None, is_ui_sound=True) -> None
        Plays a sound directly with no attenuation, perfect for UI sounds.
        
        * Fire and Forget.
        * Not Replicated.
        
        Args:
            world_context_object (Object): 
            sound (SoundBase): Sound to play.
            volume_multiplier (float): A linear scalar multiplied with the volume, in order to make the sound louder or softer.
            pitch_multiplier (float): A linear scalar multiplied with the pitch.
            start_time (float): How far in to the sound to begin playback at
            concurrency_settings (SoundConcurrency): Override concurrency settings package to play sound with
            owning_actor (Actor): The actor to use as the "owner" for concurrency settings purposes. Allows PlaySound calls to do a concurrency limit per owner.
            is_ui_sound (bool): True if sound is UI related, else false
        """
        ...
    @classmethod
    def play_dialogue_at_location(cls, world_context_object: Object, dialogue: DialogueWave, context: DialogueContext, location: Vector, rotation: Rotator, volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, attenuation_settings: SoundAttenuation = None) -> None:
        r"""
        X.play_dialogue_at_location(world_context_object, dialogue, context, location, rotation, volume_multiplier=1.000000, pitch_multiplier=1.000000, start_time=0.000000, attenuation_settings=None) -> None
        Plays a dialogue at the given location. This is a fire and forget sound and does not travel with any actor.
            Replication is also not handled at this point.
        
        Args:
            world_context_object (Object): 
            dialogue (DialogueWave): dialogue to play
            context (DialogueContext): context the dialogue is to play in
            location (Vector): World position to play dialogue at
            rotation (Rotator): World rotation to play dialogue at
            volume_multiplier (float): A linear scalar multiplied with the volume, in order to make the sound louder or softer.
            pitch_multiplier (float): A linear scalar multiplied with the pitch.
            start_time (float): How far in to the dialogue to begin playback at
            attenuation_settings (SoundAttenuation): Override attenuation settings package to play sound with
        """
        ...
    @classmethod
    def play_dialogue2d(cls, world_context_object: Object, dialogue: DialogueWave, context: DialogueContext, volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000) -> None:
        r"""
        X.play_dialogue2d(world_context_object, dialogue, context, volume_multiplier=1.000000, pitch_multiplier=1.000000, start_time=0.000000) -> None
        Plays a dialogue directly with no attenuation, perfect for UI.
        
        * Fire and Forget.
        * Not Replicated.
        
        Args:
            world_context_object (Object): 
            dialogue (DialogueWave): dialogue to play
            context (DialogueContext): context the dialogue is to play in
            volume_multiplier (float): A linear scalar multiplied with the volume, in order to make the sound louder or softer.
            pitch_multiplier (float): A linear scalar multiplied with the pitch.
            start_time (float): How far in to the dialogue to begin playback at
        """
        ...
    @classmethod
    def parse_option(cls, options: str, key: str) -> str:
        r"""
        X.parse_option(options, key) -> str
        Find an option in the options string and return it.
        
        Args:
            options (str): The string containing the options.
            key (str): The key to find the value of in Options.
        
        Returns:
            str: The value associated with Key if Key found in Options string.
        """
        ...
    @classmethod
    def open_level_by_soft_object_ptr(cls, world_context_object: Object, level: World, absolute: bool = True, options: str = "") -> None:
        r"""
        X.open_level_by_soft_object_ptr(world_context_object, level, absolute=True, options="") -> None
        Travel to another level
        
        Args:
            world_context_object (Object): 
            level (World): the level to open
            absolute (bool): if true options are reset, if false options are carried over from current level
            options (str): a string of options to use for the travel URL
        """
        ...
    @classmethod
    def open_level(cls, world_context_object: Object, level_name: Name, absolute: bool = True, options: str = "") -> None:
        r"""
        X.open_level(world_context_object, level_name, absolute=True, options="") -> None
        Travel to another level
        
        Args:
            world_context_object (Object): 
            level_name (Name): the level to open
            absolute (bool): if true options are reset, if false options are carried over from current level
            options (str): a string of options to use for the travel URL
        """
        ...
    @classmethod
    def object_is_a(cls, object: Object, object_class: Class) -> bool:
        r"""
        X.object_is_a(object, object_class) -> bool
        Returns whether or not the object passed in is of (or inherits from) the class type.
        
        Args:
            object (Object): 
            object_class (type(Class)): 
        
        Returns:
            bool: True if the object is of (or inherits from) the class type.
        """
        ...
    @classmethod
    def load_stream_level_by_soft_object_ptr(cls, world_context_object: Object, level: World, make_visible_after_load: bool, should_block_on_load: bool, latent_info: LatentActionInfo) -> None:
        r"""
        X.load_stream_level_by_soft_object_ptr(world_context_object, level, make_visible_after_load, should_block_on_load, latent_info) -> None
        Stream the level (by Object Reference); Calling again before it finishes has no effect
        
        Args:
            world_context_object (Object): 
            level (World): 
            make_visible_after_load (bool): 
            should_block_on_load (bool): 
            latent_info (LatentActionInfo):
        """
        ...
    @classmethod
    def load_stream_level(cls, world_context_object: Object, level_name: Name, make_visible_after_load: bool, should_block_on_load: bool, latent_info: LatentActionInfo) -> None:
        r"""
        X.load_stream_level(world_context_object, level_name, make_visible_after_load, should_block_on_load, latent_info) -> None
        Stream the level (by Name); Calling again before it finishes has no effect
        
        Args:
            world_context_object (Object): 
            level_name (Name): 
            make_visible_after_load (bool): 
            should_block_on_load (bool): 
            latent_info (LatentActionInfo):
        """
        ...
    @classmethod
    def load_game_from_slot(cls, slot_name: str, user_index: int) -> SaveGame:
        r"""
        X.load_game_from_slot(slot_name, user_index) -> SaveGame
        Load the contents from a given slot.
        
        Args:
            slot_name (str): Name of the save game slot to load from.
            user_index (int32): The platform user index that identifies the user doing the saving, ignored on some platforms.
        
        Returns:
            SaveGame: Object containing loaded game state (nullptr if load fails)
        """
        ...
    @classmethod
    def is_splitscreen_force_disabled(cls, world_context_object: Object) -> bool:
        r"""
        X.is_splitscreen_force_disabled(world_context_object) -> bool
        Returns the split screen state
        
        Args:
            world_context_object (Object): 
        
        Returns:
            bool: Whether the game viewport is split screen or not
        """
        ...
    @classmethod
    def is_game_paused(cls, world_context_object: Object) -> bool:
        r"""
        X.is_game_paused(world_context_object) -> bool
        Returns the game's paused state
        
        Args:
            world_context_object (Object): 
        
        Returns:
            bool: Whether the game is currently paused or not
        """
        ...
    @classmethod
    def is_any_local_player_camera_within_range(cls, world_context_object: Object, location: Vector, maximum_range: float) -> bool:
        r"""
        X.is_any_local_player_camera_within_range(world_context_object, location, maximum_range) -> bool
        Determines if any local player controller's camera is within range of the specified location.
        note: This will always return false on dedicated servers.
        
        Args:
            world_context_object (Object): 
            location (Vector): The location from which test range
            maximum_range (float): The distance away from Location to test range
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def has_option(cls, options: str, key: str) -> bool:
        r"""
        X.has_option(options, key) -> bool
        Returns whether a key exists in an options string.
        
        Args:
            options (str): The string containing the options.
            key (str): 
        
        Returns:
            bool: Whether Key was found in Options.
        """
        ...
    @classmethod
    def has_launch_option(cls, option_to_check: str) -> bool:
        r"""
        X.has_launch_option(option_to_check) -> bool
        Checks the commandline to see if the desired option was specified on the commandline (e.g. -demobuild)
        
        Args:
            option_to_check (str): 
        
        Returns:
            bool: True if the launch option was specified on the commandline, false otherwise
        """
        ...
    @classmethod
    def grass_overlapping_sphere_count(cls, world_context_object: Object, static_mesh: StaticMesh, center_position: Vector, radius: float) -> int:
        r"""
        X.grass_overlapping_sphere_count(world_context_object, static_mesh, center_position, radius) -> int32
        Counts how many grass foliage instances overlap a given sphere.
        
        Args:
            world_context_object (Object): 
            static_mesh (StaticMesh): 
            center_position (Vector): The center position of the sphere.
            radius (float): The radius of the sphere.
        
        Returns:
            int32: Number of foliage instances with their mesh set to Mesh that overlap the sphere.
        """
        ...
    @classmethod
    def get_world_origin_location(cls, world_context_object: Object) -> IntVector:
        r"""
        X.get_world_origin_location(world_context_object) -> IntVector
        Returns world origin current location.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            IntVector:
        """
        ...
    @classmethod
    def get_world_delta_seconds(cls, world_context_object: Object) -> float:
        r"""
        X.get_world_delta_seconds(world_context_object) -> double
        Returns the frame delta time in seconds, adjusted by time dilation.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def get_view_projection_matrix(cls, desired_view: MinimalViewInfo) -> Tuple[Matrix, Matrix, Matrix]:
        r"""
        X.get_view_projection_matrix(desired_view) -> (view_matrix=Matrix, projection_matrix=Matrix, view_projection_matrix=Matrix)
        Returns the View Matrix, Projection Matrix and the View x Projection Matrix for a given view
        
        Args:
            desired_view (MinimalViewInfo): FMinimalViewInfo struct for a camera.
        
        Returns:
            tuple: 
        
            view_matrix (Matrix): (out) Corresponding View Matrix
        
            projection_matrix (Matrix): (out) Corresponding Projection Matrix
        
            view_projection_matrix (Matrix): (out) Corresponding View x Projection Matrix
        """
        ...
    @classmethod
    def get_viewport_mouse_capture_mode(cls, world_context_object: Object) -> MouseCaptureMode:
        r"""
        X.get_viewport_mouse_capture_mode(world_context_object) -> MouseCaptureMode
        Returns the current viewport mouse capture mode
        
        Args:
            world_context_object (Object): 
        
        Returns:
            MouseCaptureMode:
        """
        ...
    @classmethod
    def get_unpaused_time_seconds(cls, world_context_object: Object) -> float:
        r"""
        X.get_unpaused_time_seconds(world_context_object) -> double
        Returns time in seconds since world was brought up for play, adjusted by time dilation and IS NOT stopped when game pauses
        
        Args:
            world_context_object (Object): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def get_time_seconds(cls, world_context_object: Object) -> float:
        r"""
        X.get_time_seconds(world_context_object) -> double
        Returns time in seconds since world was brought up for play, adjusted by time dilation and IS stopped when game pauses
        
        Args:
            world_context_object (Object): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def get_surface_type(cls, hit: HitResult) -> PhysicalSurface:
        r"""
        X.get_surface_type(hit) -> PhysicalSurface
        Returns the EPhysicalSurface type of the given Hit.
        To edit surface type for your project, use ProjectSettings/Physics/PhysicalSurface section
        
        Args:
            hit (HitResult): 
        
        Returns:
            PhysicalSurface:
        """
        ...
    @classmethod
    def get_streaming_level(cls, world_context_object: Object, package_name: Name) -> LevelStreaming:
        r"""
        X.get_streaming_level(world_context_object, package_name) -> LevelStreaming
        Returns level streaming object with specified level package name
        
        Args:
            world_context_object (Object): 
            package_name (Name): 
        
        Returns:
            LevelStreaming:
        """
        ...
    @classmethod
    def get_real_time_seconds(cls, world_context_object: Object) -> float:
        r"""
        X.get_real_time_seconds(world_context_object) -> double
        Returns time in seconds since world was brought up for play, does NOT stop when game pauses, NOT dilated/clamped
        
        Args:
            world_context_object (Object): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def get_player_state_from_unique_net_id(cls, world_context_object: Object, unique_id: UniqueNetIdRepl) -> PlayerState:
        r"""
        X.get_player_state_from_unique_net_id(world_context_object, unique_id) -> PlayerState
        Returns the player state that matches the passed in online id, or null for an invalid one.
        This will work on both the client and server for local and remote players.
        
        Args:
            world_context_object (Object): 
            unique_id (UniqueNetIdRepl): The player's unique net/online id
        
        Returns:
            PlayerState:
        """
        ...
    @classmethod
    def get_player_state(cls, world_context_object: Object, player_state_index: int) -> PlayerState:
        r"""
        X.get_player_state(world_context_object, player_state_index) -> PlayerState
        Returns the player state at the given index in the game state's PlayerArray.
        This will work on both the client and server and the index will be consistent.
        After initial replication, all clients and the server will have access to PlayerStates for all connected players.
        
        Args:
            world_context_object (Object): 
            player_state_index (int32): Index into the game state's PlayerArray
        
        Returns:
            PlayerState:
        """
        ...
    @classmethod
    def get_player_pawn(cls, world_context_object: Object, player_index: int) -> Pawn:
        r"""
        X.get_player_pawn(world_context_object, player_index) -> Pawn
        Returns the pawn for the player controller at the specified player index.
        This will not include pawns of remote clients with no available player controller, you can use the player states list for that.
        
        Args:
            world_context_object (Object): 
            player_index (int32): Index in the player controller list, starting first with local players and then available remote ones
        
        Returns:
            Pawn:
        """
        ...
    @classmethod
    def get_player_controller_id(cls, player: PlayerController) -> int:
        r"""
        X.get_player_controller_id(player) -> int32
        Gets what physical controller ID a player is using. This only works for local player controllers.
        
        Args:
            player (PlayerController): The player controller of the player to get the ID of
        
        Returns:
            int32: The ID of the passed in player. -1 if there is no physical controller assigned to the passed in player
        """
        ...
    @classmethod
    def get_player_controller_from_platform_user(cls, world_context_object: Object, user_id: PlatformUserId) -> PlayerController:
        r"""
        X.get_player_controller_from_platform_user(world_context_object, user_id) -> PlayerController
        Returns the player controller with the specified physical controller ID. This only works for local players.
        
        Args:
            world_context_object (Object): 
            user_id (PlatformUserId): 
        
        Returns:
            PlayerController:
        """
        ...
    @classmethod
    def get_player_controller_from_id(cls, world_context_object: Object, controller_id: int) -> PlayerController:
        r"""
        X.get_player_controller_from_id(world_context_object, controller_id) -> PlayerController
        Returns the player controller with the specified physical controller ID. This only works for local players.
        
        Args:
            world_context_object (Object): 
            controller_id (int32): Physical controller ID, the same value returned from Get Player Controller ID
        
        Returns:
            PlayerController:
        """
        ...
    @classmethod
    def get_player_controller(cls, world_context_object: Object, player_index: int) -> PlayerController:
        r"""
        X.get_player_controller(world_context_object, player_index) -> PlayerController
        Returns the player controller found while iterating through the local and available remote player controllers.
        On a network client, this will only include local players as remote player controllers are not available.
        The index will be consistent as long as no new players join or leave, but it will not be the same across different clients and servers.
        
        Args:
            world_context_object (Object): 
            player_index (int32): Index in the player controller list, starting first with local players and then available remote ones
        
        Returns:
            PlayerController:
        """
        ...
    @classmethod
    def get_player_character(cls, world_context_object: Object, player_index: int) -> Character:
        r"""
        X.get_player_character(world_context_object, player_index) -> Character
        Returns the pawn for the player controller at the specified player index, will return null if the pawn is not a character.
        This will not include characters of remote clients with no available player controller, you can iterate the PlayerStates list for that.
        
        Args:
            world_context_object (Object): 
            player_index (int32): Index in the player controller list, starting first with local players and then available remote ones
        
        Returns:
            Character:
        """
        ...
    @classmethod
    def get_player_camera_manager(cls, world_context_object: Object, player_index: int) -> PlayerCameraManager:
        r"""
        X.get_player_camera_manager(world_context_object, player_index) -> PlayerCameraManager
        Returns the camera manager for the Player Controller at the specified player index.
        This will not include remote clients with no player controller.
        
        Args:
            world_context_object (Object): 
            player_index (int32): Index in the player controller list, starting first with local players and then available remote ones
        
        Returns:
            PlayerCameraManager:
        """
        ...
    @classmethod
    def get_player_camera(cls, world_context_object: Object, player_index: int) -> PlayerCameraManager:
        r"""
        deprecated: 'get_player_camera' was renamed to 'get_player_camera_manager'.
        """
        ...
    @classmethod
    def get_platform_name(cls) -> str:
        r"""
        X.get_platform_name() -> str
        Returns the string name of the current platform, to perform different behavior based on platform.
        (Platform names include Windows, Mac, Linux, IOS, Android, consoles, etc.).
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_object_class(cls, object: Object) -> Class:
        r"""
        X.get_object_class(object) -> type(Class)
        Returns the class of a passed in Object, will always be valid if Object is not NULL
        
        Args:
            object (Object): 
        
        Returns:
            type(Class):
        """
        ...
    @classmethod
    def get_num_player_states(cls, world_context_object: Object) -> int:
        r"""
        X.get_num_player_states(world_context_object) -> int32
        Returns the number of active player states, there is one player state for every connected player even if they are a remote client.
        Indexes up to this can be use as PlayerStateIndex parameters for other functions.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_num_player_controllers(cls, world_context_object: Object) -> int:
        r"""
        X.get_num_player_controllers(world_context_object) -> int32
        Returns the total number of available player controllers, including remote players when called on a server.
        Indexes up to this can be used as PlayerIndex parameters for the following functions.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_num_local_player_controllers(cls, world_context_object: Object) -> int:
        r"""
        X.get_num_local_player_controllers(world_context_object) -> int32
        Returns the number of fully initialized local players, this will be 0 on dedicated servers.
        Indexes up to this can be used as PlayerIndex parameters for the following functions, and you are guaranteed to get a local player controller.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_max_audio_channel_count(cls, world_context_object: Object) -> int:
        r"""
        X.get_max_audio_channel_count(world_context_object) -> int32
        Retrieves the max voice count currently used by the audio engine.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_key_value(cls, pair: str) -> Tuple[str, str]:
        r"""
        X.get_key_value(pair) -> (key=str, value=str)
        Break up a key=value pair into its key and value.
        
        Args:
            pair (str): The string containing a pair to split apart.
        
        Returns:
            tuple: 
        
            key (str): (out) Key portion of Pair. If no = in string will be the same as Pair.
        
            value (str): (out) Value portion of Pair. If no = in string will be empty.
        """
        ...
    @classmethod
    def get_int_option(cls, options: str, key: str, default_value: int) -> int:
        r"""
        X.get_int_option(options, key, default_value) -> int32
        Find an option in the options string and return it as an integer.
        
        Args:
            options (str): The string containing the options.
            key (str): The key to find the value of in Options.
            default_value (int32): 
        
        Returns:
            int32: The value associated with Key as an integer if Key found in Options string, otherwise DefaultValue.
        """
        ...
    @classmethod
    def get_global_time_dilation(cls, world_context_object: Object) -> float:
        r"""
        X.get_global_time_dilation(world_context_object) -> float
        Gets the current global time dilation.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            float: Current time dilation.
        """
        ...
    @classmethod
    def get_game_state(cls, world_context_object: Object) -> GameStateBase:
        r"""
        X.get_game_state(world_context_object) -> GameStateBase
        Returns the current GameStateBase or Null if it can't be retrieved
        
        Args:
            world_context_object (Object): 
        
        Returns:
            GameStateBase:
        """
        ...
    @classmethod
    def get_game_replication_info(cls, world_context_object: Object) -> GameStateBase:
        r"""
        deprecated: 'get_game_replication_info' was renamed to 'get_game_state'.
        """
        ...
    @classmethod
    def get_game_mode(cls, world_context_object: Object) -> GameModeBase:
        r"""
        X.get_game_mode(world_context_object) -> GameModeBase
        Returns the current GameModeBase or Null if it can't be retrieved, such as on the client
        
        Args:
            world_context_object (Object): 
        
        Returns:
            GameModeBase:
        """
        ...
    @classmethod
    def get_game_info(cls, world_context_object: Object) -> GameModeBase:
        r"""
        deprecated: 'get_game_info' was renamed to 'get_game_mode'.
        """
        ...
    @classmethod
    def get_game_instance(cls, world_context_object: Object) -> GameInstance:
        r"""
        X.get_game_instance(world_context_object) -> GameInstance
        Returns the game instance object
        
        Args:
            world_context_object (Object): 
        
        Returns:
            GameInstance:
        """
        ...
    @classmethod
    def get_enable_world_rendering(cls, world_context_object: Object) -> bool:
        r"""
        X.get_enable_world_rendering(world_context_object) -> bool
        Returns the world rendering state
        
        Args:
            world_context_object (Object): 
        
        Returns:
            bool: Whether the world should be rendered or not
        """
        ...
    @classmethod
    def get_current_reverb_effect(cls, world_context_object: Object) -> ReverbEffect:
        r"""
        X.get_current_reverb_effect(world_context_object) -> ReverbEffect
        Returns the highest priority reverb settings currently active from any source (Audio Volumes or manual settings).
        
        Args:
            world_context_object (Object): 
        
        Returns:
            ReverbEffect:
        """
        ...
    @classmethod
    def get_current_level_name(cls, world_context_object: Object, remove_prefix_string: bool = True) -> str:
        r"""
        X.get_current_level_name(world_context_object, remove_prefix_string=True) -> str
        Get the name of the currently-open level.
        
        Args:
            world_context_object (Object): 
            remove_prefix_string (bool): remove any streaming- or editor- added prefixes from the level name.
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_closest_listener_location(cls, world_context_object: Object, location: Vector, maximum_range: float, allow_attenuation_override: bool) -> Optional[Vector]:
        r"""
        X.get_closest_listener_location(world_context_object, location, maximum_range, allow_attenuation_override) -> Vector or None
        Finds and returns the position of the closest listener to the specified location
        note: This will always return false if there is no audio device, or the audio device is disabled.
        
        Args:
            world_context_object (Object): 
            location (Vector): The location from which we'd like to find the closest listener, in world space.
            maximum_range (float): The maximum distance away from Location that a listener can be.
            allow_attenuation_override (bool): True for the adjusted listener position (if attenuation override is set), false for the raw listener position (for panning)
        
        Returns:
            Vector or None: true if we've successfully found a listener within MaximumRange of Location, otherwise false.
        
            listener_position (Vector): [Out] The position of the closest listener in world space, if found.
        """
        ...
    @classmethod
    def get_available_spatial_plugin_names(cls, world_context_object: Object) -> Array[Name]:
        r"""
        X.get_available_spatial_plugin_names(world_context_object) -> Array[Name]
        Get list of available Audio Spatialization Plugin names
        
        Args:
            world_context_object (Object): 
        
        Returns:
            Array[Name]:
        """
        ...
    @classmethod
    def get_audio_time_seconds(cls, world_context_object: Object) -> float:
        r"""
        X.get_audio_time_seconds(world_context_object) -> double
        Returns time in seconds since world was brought up for play, IS stopped when game pauses, NOT dilated/clamped.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def get_all_actors_with_tag(cls, world_context_object: Object, tag: Name) -> Array[Actor]:
        r"""
        X.get_all_actors_with_tag(world_context_object, tag) -> Array[Actor]
        Find all Actors in the world with the specified tag.
        This is a slow operation, use with caution e.g. do not use every frame.
        
        Args:
            world_context_object (Object): 
            tag (Name): Tag to find. Must be specified or result array will be empty.
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]): Output array of Actors of the specified tag.
        """
        ...
    @classmethod
    def get_all_actors_with_interface(cls, world_context_object: Object, interface: Class) -> Array[Actor]:
        r"""
        X.get_all_actors_with_interface(world_context_object, interface) -> Array[Actor]
        Find all Actors in the world with the specified interface.
        This is a slow operation, use with caution e.g. do not use every frame.
        
        Args:
            world_context_object (Object): 
            interface (type(Class)): Interface to find. Must be specified or result array will be empty.
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]): Output array of Actors of the specified interface.
        """
        ...
    @classmethod
    def get_all_actors_of_class_with_tag(cls, world_context_object: Object, actor_class: Class, tag: Name) -> Array[Actor]:
        r"""
        X.get_all_actors_of_class_with_tag(world_context_object, actor_class, tag) -> Array[Actor]
        Find all Actors in the world of the specified class with the specified tag.
        This is a slow operation, use with caution e.g. do not use every frame.
        
        Args:
            world_context_object (Object): 
            actor_class (type(Class)): Class of Actor to find. Must be specified or result array will be empty.
            tag (Name): Tag to find. Must be specified or result array will be empty.
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]): Output array of Actors of the specified tag.
        """
        ...
    @classmethod
    def get_all_actors_of_class(cls, world_context_object: Object, actor_class: Class) -> Array[Actor]:
        r"""
        X.get_all_actors_of_class(world_context_object, actor_class) -> Array[Actor]
        Find all Actors in the world of the specified class.
        This is a slow operation, use with caution e.g. do not use every frame.
        
        Args:
            world_context_object (Object): 
            actor_class (type(Class)): Class of Actor to find. Must be specified or result array will be empty.
        
        Returns:
            Array[Actor]: 
        
            out_actors (Array[Actor]): Output array of Actors of the specified class.
        """
        ...
    @classmethod
    def get_actor_of_class(cls, world_context_object: Object, actor_class: Class) -> Actor:
        r"""
        X.get_actor_of_class(world_context_object, actor_class) -> Actor
        Find the first Actor in the world of the specified class.
        This is a slow operation, use with caution e.g. do not use every frame.
        
        Args:
            world_context_object (Object): 
            actor_class (type(Class)): Class of Actor to find. Must be specified or result will be empty.
        
        Returns:
            Actor: Actor of the specified class.
        """
        ...
    @classmethod
    def get_actor_array_bounds(cls, actors: Array[Actor], only_colliding_components: bool) -> Tuple[Vector, Vector]:
        r"""
        X.get_actor_array_bounds(actors, only_colliding_components) -> (center=Vector, box_extent=Vector)
        Bind the bounds of an array of Actors
        
        Args:
            actors (Array[Actor]): 
            only_colliding_components (bool): 
        
        Returns:
            tuple: 
        
            center (Vector): 
        
            box_extent (Vector):
        """
        ...
    @classmethod
    def get_actor_array_average_location(cls, actors: Array[Actor]) -> Vector:
        r"""
        X.get_actor_array_average_location(actors) -> Vector
        Find the average location (centroid) of an array of Actors
        
        Args:
            actors (Array[Actor]): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_active_spatial_plugin_name(cls, world_context_object: Object) -> Name:
        r"""
        X.get_active_spatial_plugin_name(world_context_object) -> Name
        Get currently active Audio Spatialization Plugin name
        
        Args:
            world_context_object (Object): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def get_accurate_real_time(cls) -> Tuple[int, float]:
        r"""
        X.get_accurate_real_time() -> (seconds=int32, partial_seconds=double)
        Returns time in seconds since the application was started. Unlike the other time functions this is accurate to the exact time this function is called instead of set once per frame.
        
        Returns:
            tuple: 
        
            seconds (int32): 
        
            partial_seconds (double):
        """
        ...
    @classmethod
    def flush_level_streaming(cls, world_context_object: Object) -> None:
        r"""
        X.flush_level_streaming(world_context_object) -> None
        Flushes level streaming in blocking fashion and returns when all sub-levels are loaded / visible / hidden
        
        Args:
            world_context_object (Object):
        """
        ...
    @classmethod
    def find_nearest_actor(cls, origin: Vector, actors_to_check: Array[Actor]) -> Tuple[Actor, float]:
        r"""
        X.find_nearest_actor(origin, actors_to_check) -> (Actor, distance=float)
        Returns an Actor nearest to Origin from ActorsToCheck array.
        
        Args:
            origin (Vector): World Location from which the distance is measured.
            actors_to_check (Array[Actor]): Array of Actors to examine and return Actor nearest to Origin.
        
        Returns:
            float: Nearest Actor.
        
            distance (float): Distance from Origin to the returned Actor.
        """
        ...
    @classmethod
    def find_collision_uv(cls, hit: HitResult, uv_channel: int) -> Optional[Vector2D]:
        r"""
        X.find_collision_uv(hit, uv_channel) -> Vector2D or None
        Try and find the UV for a collision impact. Note this ONLY works if 'Support UV From Hit Results' is enabled in Physics Settings.
        
        Args:
            hit (HitResult): 
            uv_channel (int32): 
        
        Returns:
            Vector2D or None: 
        
            uv (Vector2D):
        """
        ...
    @classmethod
    def enable_live_streaming(cls, enable: bool = True) -> None:
        r"""
        X.enable_live_streaming(enable=True) -> None
        Toggle live DVR streaming.
        
        Args:
            enable (bool): If true enable streaming, otherwise disable.
        """
        ...
    @classmethod
    def does_save_game_exist(cls, slot_name: str, user_index: int) -> bool:
        r"""
        X.does_save_game_exist(slot_name, user_index) -> bool
        See if a save game exists with the specified name.
        
        Args:
            slot_name (str): Name of save game slot.
            user_index (int32): The platform user index that identifies the user doing the saving, ignored on some platforms.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def deproject_screen_to_world(cls, player: PlayerController, screen_position: Vector2D) -> Optional[Tuple[Vector, Vector]]:
        r"""
        X.deproject_screen_to_world(player, screen_position) -> (world_position=Vector, world_direction=Vector) or None
        Transforms the given 2D screen space coordinate into a 3D world-space point and direction.
        
        Args:
            player (PlayerController): Deproject using this player's view.
            screen_position (Vector2D): 2D screen space to deproject.
        
        Returns:
            tuple or None: 
        
            world_position (Vector): (out) Corresponding 3D position in world space.
        
            world_direction (Vector): (out) World space direction vector away from the camera at the given 2d point.
        """
        ...
    @classmethod
    def deproject_scene_capture_to_world(cls, scene_capture2d: SceneCapture2D, target_uv: Vector2D) -> Optional[Tuple[Vector, Vector]]:
        r"""
        X.deproject_scene_capture_to_world(scene_capture2d, target_uv) -> (world_position=Vector, world_direction=Vector) or None
        Transforms the given 2D UV coordinate into a 3D world-space point and direction.
        
        Args:
            scene_capture2d (SceneCapture2D): Deproject using this scene capture's view.
            target_uv (Vector2D): 
        
        Returns:
            tuple or None: 
        
            world_position (Vector): (out) Corresponding 3D position on camera near plane, in world space.
        
            world_direction (Vector): (out) World space direction vector away from the camera at the given 2d point.
        """
        ...
    @classmethod
    def delete_game_in_slot(cls, slot_name: str, user_index: int) -> bool:
        r"""
        X.delete_game_in_slot(slot_name, user_index) -> bool
        Delete a save game in a particular slot.
        
        Args:
            slot_name (str): Name of save game slot to delete.
            user_index (int32): The platform user index that identifies the user doing the saving, ignored on some platforms.
        
        Returns:
            bool: True if a file was actually able to be deleted. use DoesSaveGameExist to distinguish between delete failures and failure due to file not existing.
        """
        ...
    @classmethod
    def deactivate_reverb_effect(cls, world_context_object: Object, tag_name: Name) -> None:
        r"""
        X.deactivate_reverb_effect(world_context_object, tag_name) -> None
        Deactivates a Reverb Effect that was applied outside of an Audio Volume
        
        Args:
            world_context_object (Object): 
            tag_name (Name): Tag associated with Reverb Effect to remove
        """
        ...
    @classmethod
    def create_sound2d(cls, world_context_object: Object, sound: SoundBase, volume_multiplier: float = 1.000000, pitch_multiplier: float = 1.000000, start_time: float = 0.000000, concurrency_settings: SoundConcurrency = None, persist_across_level_transition: bool = False, auto_destroy: bool = True) -> AudioComponent:
        r"""
        X.create_sound2d(world_context_object, sound, volume_multiplier=1.000000, pitch_multiplier=1.000000, start_time=0.000000, concurrency_settings=None, persist_across_level_transition=False, auto_destroy=True) -> AudioComponent
        This function allows users to create Audio Components in advance of playback with settings specifically for non-spatialized,
        non-distance-attenuated sounds. Audio Components created using this function by default will not have Spatialization applied.
        
        Args:
            world_context_object (Object): 
            sound (SoundBase): Sound to create.
            volume_multiplier (float): A linear scalar multiplied with the volume, in order to make the sound louder or softer.
            pitch_multiplier (float): A linear scalar multiplied with the pitch.
            start_time (float): How far into the sound to begin playback at
            concurrency_settings (SoundConcurrency): Override concurrency settings package to play sound with
            persist_across_level_transition (bool): 
            auto_destroy (bool): Whether the returned audio component will be automatically cleaned up when the sound finishes (by completing or stopping), or whether it can be reactivated
        
        Returns:
            AudioComponent: An audio component to manipulate the created sound
        """
        ...
    @classmethod
    def create_save_game_object(cls, save_game_class: Class) -> SaveGame:
        r"""
        X.create_save_game_object(save_game_class) -> SaveGame
        Create a new, empty SaveGame object to set data on and then pass to SaveGameToSlot.
        
        Args:
            save_game_class (type(Class)): Class of SaveGame to create
        
        Returns:
            SaveGame: New SaveGame object to write data to
        """
        ...
    @classmethod
    def create_player_from_platform_user(cls, world_context_object: Object, user_id: PlatformUserId, spawn_player_controller: bool = True) -> PlayerController:
        r"""
        X.create_player_from_platform_user(world_context_object, user_id, spawn_player_controller=True) -> PlayerController
        Create a new local player for this game, for cases like local multiplayer.
        
        Args:
            world_context_object (Object): 
            user_id (PlatformUserId): The platform user id that should control the newly created player. A valude of PLATFRMUSERID_NONE specifies to use the next available ID
            spawn_player_controller (bool): Whether a player controller should be spawned immediately for this player. If false a player controller will not be created automatically until transition to the next map.
        
        Returns:
            PlayerController: The created player controller if one is created.
        """
        ...
    @classmethod
    def create_player(cls, world_context_object: Object, controller_id: int = -1, spawn_player_controller: bool = True) -> PlayerController:
        r"""
        X.create_player(world_context_object, controller_id=-1, spawn_player_controller=True) -> PlayerController
        Create a new local player for this game, for cases like local multiplayer.
        
        Args:
            world_context_object (Object): 
            controller_id (int32): The ID of the physical controller that the should control the newly created player. A value of -1 specifies to use the next available ID
            spawn_player_controller (bool): Whether a player controller should be spawned immediately for this player. If false a player controller will not be created automatically until transition to the next map.
        
        Returns:
            PlayerController: The created player controller if one is created.
        """
        ...
    @classmethod
    def clear_sound_mix_modifiers(cls, world_context_object: Object) -> None:
        r"""
        X.clear_sound_mix_modifiers(world_context_object) -> None
        Clear all sound mix modifiers from the audio system
        
        Args:
            world_context_object (Object):
        """
        ...
    @classmethod
    def clear_sound_mode(cls, world_context_object: Object) -> None:
        r"""
        deprecated: 'clear_sound_mode' was renamed to 'clear_sound_mix_modifiers'.
        """
        ...
    @classmethod
    def clear_sound_mix_class_override(cls, world_context_object: Object, sound_mix_modifier: SoundMix, sound_class: SoundClass, fade_out_time: float = 1.000000) -> None:
        r"""
        X.clear_sound_mix_class_override(world_context_object, sound_mix_modifier, sound_class, fade_out_time=1.000000) -> None
        Clears any existing override of the Sound Class Adjuster in the given Sound Mix
        
        Args:
            world_context_object (Object): 
            sound_mix_modifier (SoundMix): The sound mix to modify.
            sound_class (SoundClass): The sound class in the sound mix to clear overrides from.
            fade_out_time (float): The interpolation time to use to go from the current sound class adjuster override values to the non-override values.
        """
        ...
    @classmethod
    def cancel_async_loading(cls) -> None:
        r"""
        X.cancel_async_loading() -> None
        Cancels all currently queued streaming packages
        """
        ...
    @classmethod
    def blueprint_suggest_projectile_velocity(cls, world_context_object: Object, start_location: Vector, end_location: Vector, launch_speed: float, override_gravity_z: float, trace_option: SuggestProjVelocityTraceOption, collision_radius: float, favor_high_arc: bool, draw_debug: bool, accept_closest_on_no_solutions: bool = False) -> Optional[Vector]:
        r"""
        X.blueprint_suggest_projectile_velocity(world_context_object, start_location, end_location, launch_speed, override_gravity_z, trace_option, collision_radius, favor_high_arc, draw_debug, accept_closest_on_no_solutions=False) -> Vector or None
        Calculates an launch velocity for a projectile to hit a specified point.
        
        Args:
            world_context_object (Object): 
            start_location (Vector): Intended launch location
            end_location (Vector): Desired landing location
            launch_speed (float): Desired launch speed
            override_gravity_z (float): Optional gravity override.  0 means "do not override".
            trace_option (SuggestProjVelocityTraceOption): Controls whether or not to validate a clear path by tracing along the calculated arc
            collision_radius (float): Radius of the projectile (assumed spherical), used when tracing
            favor_high_arc (bool): If true and there are 2 valid solutions, will return the higher arc.  If false, will favor the lower arc.
            draw_debug (bool): When true, a debug arc is drawn (red for an invalid arc, green for a valid arc)
            accept_closest_on_no_solutions (bool): If target is unreachable and no solutions are possible, provide a velocity that gets as close to the target as possible given this launch speed
        
        Returns:
            Vector or None: Returns false if there is no valid solution or the valid solutions are blocked.  Returns true otherwise.
        
            toss_velocity (Vector): (output) Result launch velocity.
        """
        ...
    @classmethod
    def blueprint_predict_projectile_path_by_trace_channel(cls, world_context_object: Object, start_pos: Vector, launch_velocity: Vector, trace_path: bool = True, projectile_radius: float = ..., trace_channel: CollisionChannel = CollisionChannel.ECC_WORLD_DYNAMIC, trace_complex: bool = ..., actors_to_ignore: Array[Actor] = ..., draw_debug_type: DrawDebugTrace = ..., draw_debug_time: float = ..., sim_frequency: float = 15.000000, max_sim_time: float = 2.000000, override_gravity_z: float = 0.000000) -> Optional[Tuple[HitResult, Array[Vector], Vector]]:
        r"""
        X.blueprint_predict_projectile_path_by_trace_channel(world_context_object, start_pos, launch_velocity, trace_path=True, projectile_radius, trace_channel=CollisionChannel.ECC_WORLD_DYNAMIC, trace_complex, actors_to_ignore, draw_debug_type, draw_debug_time, sim_frequency=15.000000, max_sim_time=2.000000, override_gravity_z=0.000000) -> (out_hit=HitResult, out_path_positions=Array[Vector], out_last_trace_destination=Vector) or None
        Predict the arc of a virtual projectile affected by gravity with collision checks along the arc. Returns a list of positions of the simulated arc and the destination reached by the simulation.
        Returns true if it hit something (if tracing with collision).
        
        Args:
            world_context_object (Object): 
            start_pos (Vector): First start trace location
            launch_velocity (Vector): Velocity the "virtual projectile" is launched at
            trace_path (bool): Trace along the entire path to look for blocking hits
            projectile_radius (float): Radius of the virtual projectile to sweep against the environment
            trace_channel (CollisionChannel): TraceChannel to trace against, if bTracePath is true.
            trace_complex (bool): Use TraceComplex (trace against triangles not primitives)
            actors_to_ignore (Array[Actor]): Actors to exclude from the traces
            draw_debug_type (DrawDebugTrace): Debug type (one-frame, duration, persistent)
            draw_debug_time (float): Duration of debug lines (only relevant for DrawDebugType::Duration)
            sim_frequency (float): Determines size of each sub-step in the simulation (chopping up MaxSimTime)
            max_sim_time (float): Maximum simulation time for the virtual projectile.
            override_gravity_z (float): Optional override of Gravity (if 0, uses WorldGravityZ)
        
        Returns:
            tuple or None: True if hit something along the path (if tracing with collision).
        
            out_hit (HitResult): Predicted hit result, if the projectile will hit something
        
            out_path_positions (Array[Vector]): Predicted projectile path. Ordered series of positions from StartPos to the end. Includes location at point of impact if it hit something.
        
            out_last_trace_destination (Vector): Goal position of the final trace it did. Will not be in the path if there is a hit.
        """
        ...
    @classmethod
    def blueprint_predict_projectile_path_by_object_type(cls, world_context_object: Object, start_pos: Vector, launch_velocity: Vector, trace_path: bool = True, projectile_radius: float = ..., object_types: Array[ObjectTypeQuery] = ..., trace_complex: bool = ..., actors_to_ignore: Array[Actor] = ..., draw_debug_type: DrawDebugTrace = ..., draw_debug_time: float = ..., sim_frequency: float = 15.000000, max_sim_time: float = 2.000000, override_gravity_z: float = 0.000000) -> Optional[Tuple[HitResult, Array[Vector], Vector]]:
        r"""
        X.blueprint_predict_projectile_path_by_object_type(world_context_object, start_pos, launch_velocity, trace_path=True, projectile_radius, object_types, trace_complex, actors_to_ignore, draw_debug_type, draw_debug_time, sim_frequency=15.000000, max_sim_time=2.000000, override_gravity_z=0.000000) -> (out_hit=HitResult, out_path_positions=Array[Vector], out_last_trace_destination=Vector) or None
        Predict the arc of a virtual projectile affected by gravity with collision checks along the arc. Returns a list of positions of the simulated arc and the destination reached by the simulation.
        Returns true if it hit something.
        
        Args:
            world_context_object (Object): 
            start_pos (Vector): First start trace location
            launch_velocity (Vector): Velocity the "virtual projectile" is launched at
            trace_path (bool): Trace along the entire path to look for blocking hits
            projectile_radius (float): Radius of the virtual projectile to sweep against the environment
            object_types (Array[ObjectTypeQuery]): ObjectTypes to trace against, if bTracePath is true.
            trace_complex (bool): Use TraceComplex (trace against triangles not primitives)
            actors_to_ignore (Array[Actor]): Actors to exclude from the traces
            draw_debug_type (DrawDebugTrace): Debug type (one-frame, duration, persistent)
            draw_debug_time (float): Duration of debug lines (only relevant for DrawDebugType::Duration)
            sim_frequency (float): Determines size of each sub-step in the simulation (chopping up MaxSimTime)
            max_sim_time (float): Maximum simulation time for the virtual projectile.
            override_gravity_z (float): Optional override of Gravity (if 0, uses WorldGravityZ)
        
        Returns:
            tuple or None: True if hit something along the path if tracing for collision.
        
            out_hit (HitResult): Predicted hit result, if the projectile will hit something
        
            out_path_positions (Array[Vector]): Predicted projectile path. Ordered series of positions from StartPos to the end. Includes location at point of impact if it hit something.
        
            out_last_trace_destination (Vector): Goal position of the final trace it did. Will not be in the path if there is a hit.
        """
        ...
    @classmethod
    def predict_projectile_path(cls, world_context_object: Object, start_pos: Vector, launch_velocity: Vector, trace_path: bool = True, projectile_radius: float = ..., object_types: Array[ObjectTypeQuery] = ..., trace_complex: bool = ..., actors_to_ignore: Array[Actor] = ..., draw_debug_type: DrawDebugTrace = ..., draw_debug_time: float = ..., sim_frequency: float = 15.000000, max_sim_time: float = 2.000000, override_gravity_z: float = 0.000000) -> Optional[Tuple[HitResult, Array[Vector], Vector]]:
        r"""
        deprecated: 'predict_projectile_path' was renamed to 'blueprint_predict_projectile_path_by_object_type'.
        """
        ...
    @classmethod
    def blueprint_predict_projectile_path_advanced(cls, world_context_object: Object, predict_params: PredictProjectilePathParams) -> Optional[PredictProjectilePathResult]:
        r"""
        X.blueprint_predict_projectile_path_advanced(world_context_object, predict_params) -> PredictProjectilePathResult or None
        Predict the arc of a virtual projectile affected by gravity with collision checks along the arc.
        Returns true if it hit something.
        
        Args:
            world_context_object (Object): 
            predict_params (PredictProjectilePathParams): Input params to the trace (start location, velocity, time to simulate, etc).
        
        Returns:
            PredictProjectilePathResult or None: True if hit something along the path (if tracing with collision).
        
            predict_result (PredictProjectilePathResult): Output result of the trace (Hit result, array of location/velocity/times for each trace step, etc).
        """
        ...
    @classmethod
    def are_subtitles_enabled(cls) -> bool:
        r"""
        X.are_subtitles_enabled() -> bool
        Returns whether or not subtitles are currently enabled.
        
        Returns:
            bool: true if subtitles are enabled.
        """
        ...
    @classmethod
    def are_any_listeners_within_range(cls, world_context_object: Object, location: Vector, maximum_range: float) -> bool:
        r"""
        X.are_any_listeners_within_range(world_context_object, location, maximum_range) -> bool
        Determines if any audio listeners are within range of the specified location
        note: This will always return false if there is no audio device, or the audio device is disabled.
        
        Args:
            world_context_object (Object): 
            location (Vector): The location from which test if a listener is in range
            maximum_range (float): The distance away from Location to test if any listener is within
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def apply_radial_damage_with_falloff(cls, world_context_object: Object, base_damage: float, minimum_damage: float, origin: Vector, damage_inner_radius: float, damage_outer_radius: float, damage_falloff: float, damage_type_class: Class, ignore_actors: Array[Actor], damage_causer: Actor = None, instigated_by_controller: Controller = None, damage_prevention_channel: CollisionChannel = CollisionChannel.ECC_VISIBILITY) -> bool:
        r"""
        X.apply_radial_damage_with_falloff(world_context_object, base_damage, minimum_damage, origin, damage_inner_radius, damage_outer_radius, damage_falloff, damage_type_class, ignore_actors, damage_causer=None, instigated_by_controller=None, damage_prevention_channel=CollisionChannel.ECC_VISIBILITY) -> bool
        Hurt locally authoritative actors within the radius. Will only hit components that block the Visibility channel.
        
        Args:
            world_context_object (Object): 
            base_damage (float): The base damage to apply, i.e. the damage at the origin.
            minimum_damage (float): 
            origin (Vector): Epicenter of the damage area.
            damage_inner_radius (float): Radius of the full damage area, from Origin
            damage_outer_radius (float): Radius of the minimum damage area, from Origin
            damage_falloff (float): Falloff exponent of damage from DamageInnerRadius to DamageOuterRadius
            damage_type_class (type(Class)): Class that describes the damage that was done.
            ignore_actors (Array[Actor]): List of Actors to ignore
            damage_causer (Actor): Actor that actually caused the damage (e.g. the grenade that exploded)
            instigated_by_controller (Controller): Controller that was responsible for causing this damage (e.g. player who threw the grenade)
            damage_prevention_channel (CollisionChannel): Damage will not be applied to victim if there is something between the origin and the victim which blocks traces on this channel
        
        Returns:
            bool: true if damage was applied to at least one actor.
        """
        ...
    @classmethod
    def apply_radial_damage(cls, world_context_object: Object, base_damage: float, origin: Vector, damage_radius: float, damage_type_class: Class, ignore_actors: Array[Actor], damage_causer: Actor = None, instigated_by_controller: Controller = None, do_full_damage: bool = False, damage_prevention_channel: CollisionChannel = CollisionChannel.ECC_VISIBILITY) -> bool:
        r"""
        X.apply_radial_damage(world_context_object, base_damage, origin, damage_radius, damage_type_class, ignore_actors, damage_causer=None, instigated_by_controller=None, do_full_damage=False, damage_prevention_channel=CollisionChannel.ECC_VISIBILITY) -> bool
        Hurt locally authoritative actors within the radius. Will only hit components that block the Visibility channel.
        
        Args:
            world_context_object (Object): 
            base_damage (float): The base damage to apply, i.e. the damage at the origin.
            origin (Vector): Epicenter of the damage area.
            damage_radius (float): Radius of the damage area, from Origin
            damage_type_class (type(Class)): Class that describes the damage that was done.
            ignore_actors (Array[Actor]): List of Actors to ignore
            damage_causer (Actor): Actor that actually caused the damage (e.g. the grenade that exploded).  This actor will not be damaged and it will not block damage.
            instigated_by_controller (Controller): Controller that was responsible for causing this damage (e.g. player who threw the grenade)
            do_full_damage (bool): 
            damage_prevention_channel (CollisionChannel): Damage will not be applied to victim if there is something between the origin and the victim which blocks traces on this channel
        
        Returns:
            bool: true if damage was applied to at least one actor.
        """
        ...
    @classmethod
    def apply_point_damage(cls, damaged_actor: Actor, base_damage: float, hit_from_direction: Vector, hit_info: HitResult, event_instigator: Controller, damage_causer: Actor, damage_type_class: Class) -> float:
        r"""
        X.apply_point_damage(damaged_actor, base_damage, hit_from_direction, hit_info, event_instigator, damage_causer, damage_type_class) -> float
        Hurts the specified actor with the specified impact.
        
        Args:
            damaged_actor (Actor): Actor that will be damaged.
            base_damage (float): The base damage to apply.
            hit_from_direction (Vector): Direction the hit came FROM
            hit_info (HitResult): Collision or trace result that describes the hit
            event_instigator (Controller): Controller that was responsible for causing this damage (e.g. player who shot the weapon)
            damage_causer (Actor): Actor that actually caused the damage (e.g. the grenade that exploded)
            damage_type_class (type(Class)): Class that describes the damage that was done.
        
        Returns:
            float: Actual damage the ended up being applied to the actor.
        """
        ...
    @classmethod
    def apply_damage(cls, damaged_actor: Actor, base_damage: float, event_instigator: Controller, damage_causer: Actor, damage_type_class: Class) -> float:
        r"""
        X.apply_damage(damaged_actor, base_damage, event_instigator, damage_causer, damage_type_class) -> float
        Hurts the specified actor with generic damage.
        
        Args:
            damaged_actor (Actor): Actor that will be damaged.
            base_damage (float): The base damage to apply.
            event_instigator (Controller): Controller that was responsible for causing this damage (e.g. player who shot the weapon)
            damage_causer (Actor): Actor that actually caused the damage (e.g. the grenade that exploded)
            damage_type_class (type(Class)): Class that describes the damage that was done.
        
        Returns:
            float: Actual damage the ended up being applied to the actor.
        """
        ...
    @classmethod
    def announce_accessible_string(cls, announcement_string: str) -> None:
        r"""
        X.announce_accessible_string(announcement_string) -> None
        If accessibility is enabled, have the platform announce a string to the player.
        These announcements can be interrupted by system accessibiliity announcements or other accessibility announcement requests.
        This should be used judiciously as flooding a player with announcements can be overrwhelming and confusing.
        Try to make announcements concise and clear.
        NOTE: Currently only supported on Win10, Mac, iOS
        
        Args:
            announcement_string (str):
        """
        ...
    @classmethod
    def activate_reverb_effect(cls, world_context_object: Object, reverb_effect: ReverbEffect, tag_name: Name, priority: float = 0.000000, volume: float = 0.500000, fade_time: float = 2.000000) -> None:
        r"""
        X.activate_reverb_effect(world_context_object, reverb_effect, tag_name, priority=0.000000, volume=0.500000, fade_time=2.000000) -> None
        Activates a Reverb Effect without the need for an Audio Volume
        
        Args:
            world_context_object (Object): 
            reverb_effect (ReverbEffect): Reverb Effect to use
            tag_name (Name): Tag to associate with Reverb Effect
            priority (float): Priority of the Reverb Effect
            volume (float): Volume level of Reverb Effect
            fade_time (float): Time before Reverb Effect is fully active
        """
        ...

class GameSession(Info):
    r"""
    Acts as a game-specific wrapper around the session interface. The game code makes calls to this when it needs to interact with the session interface.
    A game session exists only the server, while running an online game.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameSession.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class GameStateBase(Info):
    r"""
    GameStateBase is a class that manages the game's global state, and is spawned by GameModeBase.
    It exists on both the client and the server and is fully replicated.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameStateBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``authority_game_mode`` (GameModeBase):  [Read-Write] Instance of the current game mode, exists only on the server. For non-authority clients, this will be NULL.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``game_mode_class`` (type(Class)):  [Read-Write] Class of the server's game mode, assigned by GameModeBase.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_array`` (Array[PlayerState]):  [Read-Write] Array of all PlayerStates, maintained on both server and clients (PlayerStates are always relevant)
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``server_world_time_seconds_update_frequency`` (float):  [Read-Write] Frequency that the server updates the replicated TimeSeconds from the world. Set to zero to disable periodic updates.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``spectator_class`` (type(Class)):  [Read-Write] Class used by spectators, assigned by GameModeBase.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def game_mode_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] Class of the server's game mode, assigned by GameModeBase.
        """
        ...
    @property
    def authority_game_mode(self) -> GameModeBase:
        r"""
        (GameModeBase):  [Read-Only] Instance of the current game mode, exists only on the server. For non-authority clients, this will be NULL.
        """
        ...
    @property
    def spectator_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] Class used by spectators, assigned by GameModeBase.
        """
        ...
    @property
    def player_array(self) -> Array[PlayerState]:
        r"""
        (Array[PlayerState]):  [Read-Only] Array of all PlayerStates, maintained on both server and clients (PlayerStates are always relevant)
        """
        ...
    def has_match_started(self) -> bool:
        r"""
        x.has_match_started() -> bool
        Returns true if the world has started match (called MatchStarted callbacks)
        
        Returns:
            bool:
        """
        ...
    def has_match_ended(self) -> bool:
        r"""
        x.has_match_ended() -> bool
        Returns true if the match can be considered ended. Defaults to false.
        
        Returns:
            bool:
        """
        ...
    def has_begun_play(self) -> bool:
        r"""
        x.has_begun_play() -> bool
        Returns true if the world has started play (called BeginPlay on actors)
        
        Returns:
            bool:
        """
        ...
    def get_server_world_time_seconds(self) -> float:
        r"""
        x.get_server_world_time_seconds() -> double
        Returns the simulated TimeSeconds on the server, will be synchronized on client and server
        
        Returns:
            double:
        """
        ...
    def get_player_start_time(self, controller: Controller) -> float:
        r"""
        x.get_player_start_time(controller) -> float
        Returns the time that should be used as when a player started
        
        Args:
            controller (Controller): 
        
        Returns:
            float:
        """
        ...
    def get_player_respawn_delay(self, controller: Controller) -> float:
        r"""
        x.get_player_respawn_delay(controller) -> float
        Returns how much time needs to be spent before a player can respawn
        
        Args:
            controller (Controller): 
        
        Returns:
            float:
        """
        ...

class GameState(GameStateBase):
    r"""
    GameState is a subclass of GameStateBase that behaves like a multiplayer match-based game.
    It is tied to functionality in GameMode.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameState.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``authority_game_mode`` (GameModeBase):  [Read-Write] Instance of the current game mode, exists only on the server. For non-authority clients, this will be NULL.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``elapsed_time`` (int32):  [Read-Write] Elapsed game time since match has started.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``game_mode_class`` (type(Class)):  [Read-Write] Class of the server's game mode, assigned by GameModeBase.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``match_state`` (Name):  [Read-Only] What match state we are currently in
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_array`` (Array[PlayerState]):  [Read-Write] Array of all PlayerStates, maintained on both server and clients (PlayerStates are always relevant)
    - ``previous_match_state`` (Name):  [Read-Only] Previous map state, used to handle if multiple transitions happen per frame
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``server_world_time_seconds_update_frequency`` (float):  [Read-Write] Frequency that the server updates the replicated TimeSeconds from the world. Set to zero to disable periodic updates.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``spectator_class`` (type(Class)):  [Read-Write] Class used by spectators, assigned by GameModeBase.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def match_state(self) -> Name:
        r"""
        (Name):  [Read-Only] What match state we are currently in
        """
        ...
    @property
    def previous_match_state(self) -> Name:
        r"""
        (Name):  [Read-Only] Previous map state, used to handle if multiple transitions happen per frame
        """
        ...
    @property
    def elapsed_time(self) -> int:
        r"""
        (int32):  [Read-Only] Elapsed game time since match has started.
        """
        ...

class GameUserSettings(Object):
    r"""
    Stores user settings for a game (for example graphics and sound settings), with the ability to save and load to and from a file.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_game_user_settings_ui_needs_update`` (OnGameUserSettingsUINeedsUpdate):  [Read-Write]
    """
    @property
    def on_game_user_settings_ui_needs_update(self) -> OnGameUserSettingsUINeedsUpdate:
        r"""
        (OnGameUserSettingsUINeedsUpdate):  [Read-Write]
        """
        ...
    @on_game_user_settings_ui_needs_update.setter
    def on_game_user_settings_ui_needs_update(self, value: OnGameUserSettingsUINeedsUpdate) -> None:
        ...
    def validate_settings(self) -> None:
        r"""
        x.validate_settings() -> None
        Validates and resets bad user settings to default. Deletes stale user settings file if necessary.
        """
        ...
    def supports_hdr_display_output(self) -> bool:
        r"""
        x.supports_hdr_display_output() -> bool
        Whether the curently running system supports HDR display output
        
        Returns:
            bool:
        """
        ...
    def set_v_sync_enabled(self, enable: bool) -> None:
        r"""
        x.set_v_sync_enabled(enable) -> None
        Sets the user setting for vsync. See UGameUserSettings::bUseVSync.
        
        Args:
            enable (bool):
        """
        ...
    def set_visual_effect_quality(self, value: int) -> None:
        r"""
        x.set_visual_effect_quality(value) -> None
        Sets the visual effects quality (0..4, higher is better)
        
        Args:
            value (int32): 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        """
        ...
    def set_view_distance_quality(self, value: int) -> None:
        r"""
        x.set_view_distance_quality(value) -> None
        Sets the view distance quality (0..4, higher is better)
        
        Args:
            value (int32): 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        """
        ...
    def set_to_defaults(self) -> None:
        r"""
        x.set_to_defaults() -> None
        Set to Defaults
        """
        ...
    def set_texture_quality(self, value: int) -> None:
        r"""
        x.set_texture_quality(value) -> None
        Sets the texture quality (0..4, higher is better)
        
        Args:
            value (int32): 0:low, 1:medium, 2:high, 3:epic, 4:cinematic  (gets clamped if needed)
        """
        ...
    def set_shadow_quality(self, value: int) -> None:
        r"""
        x.set_shadow_quality(value) -> None
        Sets the shadow quality (0..4, higher is better)
        
        Args:
            value (int32): 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        """
        ...
    def set_shading_quality(self, value: int) -> None:
        r"""
        x.set_shading_quality(value) -> None
        Sets the shading quality (0..4, higher is better)
        
        Args:
            value (int32): 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        """
        ...
    def set_screen_resolution(self, resolution: IntPoint) -> None:
        r"""
        x.set_screen_resolution(resolution) -> None
        Sets the user setting for game screen resolution, in pixels.
        
        Args:
            resolution (IntPoint):
        """
        ...
    def set_resolution_scale_value_ex(self, new_scale_value: float) -> None:
        r"""
        x.set_resolution_scale_value_ex(new_scale_value) -> None
        Sets the current resolution scale
        
        Args:
            new_scale_value (float):
        """
        ...
    def set_resolution_scale_normalized(self, new_scale_normalized: float) -> None:
        r"""
        x.set_resolution_scale_normalized(new_scale_normalized) -> None
        Sets the current resolution scale as a normalized 0..1 value between MinScaleValue and MaxScaleValue
        
        Args:
            new_scale_normalized (float):
        """
        ...
    def set_reflection_quality(self, value: int) -> None:
        r"""
        x.set_reflection_quality(value) -> None
        Sets the reflection quality (0..4, higher is better)
        
        Args:
            value (int32): 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        """
        ...
    def set_post_processing_quality(self, value: int) -> None:
        r"""
        x.set_post_processing_quality(value) -> None
        Sets the post-processing quality (0..4, higher is better)
        
        Args:
            value (int32): 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        """
        ...
    def set_overall_scalability_level(self, value: int) -> None:
        r"""
        x.set_overall_scalability_level(value) -> None
        Changes all scalability settings at once based on a single overall quality level
        
        Args:
            value (int32): 0:low, 1:medium, 2:high, 3:epic, 4:cinematic
        """
        ...
    def set_global_illumination_quality(self, value: int) -> None:
        r"""
        x.set_global_illumination_quality(value) -> None
        Sets the global illumination quality (0..4, higher is better)
        
        Args:
            value (int32): 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        """
        ...
    def set_fullscreen_mode(self, fullscreen_mode: WindowMode) -> None:
        r"""
        x.set_fullscreen_mode(fullscreen_mode) -> None
        Sets the user setting for the game window fullscreen mode. See UGameUserSettings::FullscreenMode.
        
        Args:
            fullscreen_mode (WindowMode):
        """
        ...
    def set_frame_rate_limit(self, new_limit: float) -> None:
        r"""
        x.set_frame_rate_limit(new_limit) -> None
        Sets the user's frame rate limit (0 will disable frame rate limiting)
        
        Args:
            new_limit (float):
        """
        ...
    def set_foliage_quality(self, value: int) -> None:
        r"""
        x.set_foliage_quality(value) -> None
        Sets the foliage quality (0..4, higher is better)
        
        Args:
            value (int32): 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        """
        ...
    def set_dynamic_resolution_enabled(self, enable: bool) -> None:
        r"""
        x.set_dynamic_resolution_enabled(enable) -> None
        Sets the user setting for dynamic resolution. See UGameUserSettings::bUseDynamicResolution.
        
        Args:
            enable (bool):
        """
        ...
    def set_benchmark_fallback_values(self) -> None:
        r"""
        x.set_benchmark_fallback_values() -> None
        Set scalability settings to sensible fallback values, for use when the benchmark fails or potentially causes a crash
        """
        ...
    def set_audio_quality_level(self, quality_level: int) -> None:
        r"""
        x.set_audio_quality_level(quality_level) -> None
        Sets the user's audio quality level setting
        
        Args:
            quality_level (int32):
        """
        ...
    def set_anti_aliasing_quality(self, value: int) -> None:
        r"""
        x.set_anti_aliasing_quality(value) -> None
        Sets the anti-aliasing quality (0..4, higher is better)
        
        Args:
            value (int32): 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        """
        ...
    def save_settings(self) -> None:
        r"""
        x.save_settings() -> None
        Save the user settings to persistent storage (automatically happens as part of ApplySettings)
        """
        ...
    def run_hardware_benchmark(self, work_scale: int = 10, cpu_multiplier: float = 1.000000, gpu_multiplier: float = 1.000000) -> None:
        r"""
        x.run_hardware_benchmark(work_scale=10, cpu_multiplier=1.000000, gpu_multiplier=1.000000) -> None
        Runs the hardware benchmark and populates ScalabilityQuality as well as the last benchmark results config members, but does not apply the settings it determines. Designed to be called in conjunction with ApplyHardwareBenchmarkResults
        
        Args:
            work_scale (int32): 
            cpu_multiplier (float): 
            gpu_multiplier (float):
        """
        ...
    def revert_video_mode(self) -> None:
        r"""
        x.revert_video_mode() -> None
        Revert video mode (fullscreenmode/resolution) back to the last user confirmed values
        """
        ...
    def reset_to_current_settings(self) -> None:
        r"""
        x.reset_to_current_settings() -> None
        This function resets all settings to the current system settings
        """
        ...
    def load_settings(self, force_reload: bool = False) -> None:
        r"""
        x.load_settings(force_reload=False) -> None
        Loads the user settings from persistent storage
        
        Args:
            force_reload (bool):
        """
        ...
    def is_v_sync_enabled(self) -> bool:
        r"""
        x.is_v_sync_enabled() -> bool
        Returns the user setting for vsync.
        
        Returns:
            bool:
        """
        ...
    def is_v_sync_dirty(self) -> bool:
        r"""
        x.is_v_sync_dirty() -> bool
        Checks if the vsync user setting is different from current system setting
        
        Returns:
            bool:
        """
        ...
    def is_screen_resolution_dirty(self) -> bool:
        r"""
        x.is_screen_resolution_dirty() -> bool
        Checks if the Screen Resolution user setting is different from current
        
        Returns:
            bool:
        """
        ...
    def is_hdr_enabled(self) -> bool:
        r"""
        x.is_hdr_enabled() -> bool
        Is HDREnabled
        
        Returns:
            bool:
        """
        ...
    def is_fullscreen_mode_dirty(self) -> bool:
        r"""
        x.is_fullscreen_mode_dirty() -> bool
        Checks if the FullscreenMode user setting is different from current
        
        Returns:
            bool:
        """
        ...
    def is_dynamic_resolution_enabled(self) -> bool:
        r"""
        x.is_dynamic_resolution_enabled() -> bool
        Returns the user setting for dynamic resolution.
        
        Returns:
            bool:
        """
        ...
    def is_dynamic_resolution_dirty(self) -> bool:
        r"""
        x.is_dynamic_resolution_dirty() -> bool
        Checks if the dynamic resolution user setting is different from current system setting
        
        Returns:
            bool:
        """
        ...
    def is_dirty(self) -> bool:
        r"""
        x.is_dirty() -> bool
        Checks if any user settings is different from current
        
        Returns:
            bool:
        """
        ...
    def get_visual_effect_quality(self) -> int:
        r"""
        x.get_visual_effect_quality() -> int32
        Returns the visual effects quality (0..4, higher is better)
        
        Returns:
            int32:
        """
        ...
    def get_view_distance_quality(self) -> int:
        r"""
        x.get_view_distance_quality() -> int32
        Returns the view distance quality (0..4, higher is better)
        
        Returns:
            int32:
        """
        ...
    def get_texture_quality(self) -> int:
        r"""
        x.get_texture_quality() -> int32
        Returns the texture quality (0..4, higher is better)
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_sync_interval(cls) -> int:
        r"""
        X.get_sync_interval() -> int32
        Get Sync Interval
        
        Returns:
            int32:
        """
        ...
    def get_shadow_quality(self) -> int:
        r"""
        x.get_shadow_quality() -> int32
        Returns the shadow quality (0..4, higher is better)
        
        Returns:
            int32:
        """
        ...
    def get_shading_quality(self) -> int:
        r"""
        x.get_shading_quality() -> int32
        Returns the shading quality (0..4, higher is better)
        
        Returns:
            int32:
        """
        ...
    def get_screen_resolution(self) -> IntPoint:
        r"""
        x.get_screen_resolution() -> IntPoint
        Returns the user setting for game screen resolution, in pixels.
        
        Returns:
            IntPoint:
        """
        ...
    def get_resolution_scale_normalized(self) -> float:
        r"""
        x.get_resolution_scale_normalized() -> float
        Gets the current resolution scale as a normalized 0..1 value between MinScaleValue and MaxScaleValue
        
        Returns:
            float:
        """
        ...
    def get_resolution_scale_information_ex(self) -> Tuple[float, float, float, float]:
        r"""
        x.get_resolution_scale_information_ex() -> (current_scale_normalized=float, current_scale_value=float, min_scale_value=float, max_scale_value=float)
        Returns the current resolution scale and the range
        
        Returns:
            tuple: 
        
            current_scale_normalized (float): 
        
            current_scale_value (float): 
        
            min_scale_value (float): 
        
            max_scale_value (float):
        """
        ...
    def get_reflection_quality(self) -> int:
        r"""
        x.get_reflection_quality() -> int32
        Returns the reflection quality (0..4, higher is better)
        
        Returns:
            int32:
        """
        ...
    def get_recommended_resolution_scale(self) -> float:
        r"""
        x.get_recommended_resolution_scale() -> float
        Gets the recommended resolution quality based on LastRecommendedScreenWidth/Height and the current screen resolution
        
        Returns:
            float:
        """
        ...
    def get_preferred_fullscreen_mode(self) -> WindowMode:
        r"""
        x.get_preferred_fullscreen_mode() -> WindowMode
        Returns the user setting for game window fullscreen mode.
        
        Returns:
            WindowMode:
        """
        ...
    def get_post_processing_quality(self) -> int:
        r"""
        x.get_post_processing_quality() -> int32
        Returns the post-processing quality (0..4, higher is better)
        
        Returns:
            int32:
        """
        ...
    def get_overall_scalability_level(self) -> int:
        r"""
        x.get_overall_scalability_level() -> int32
        Returns the overall scalability level (can return -1 if the settings are custom)
        
        Returns:
            int32:
        """
        ...
    def get_last_confirmed_screen_resolution(self) -> IntPoint:
        r"""
        x.get_last_confirmed_screen_resolution() -> IntPoint
        Returns the last confirmed user setting for game screen resolution, in pixels.
        
        Returns:
            IntPoint:
        """
        ...
    def get_last_confirmed_fullscreen_mode(self) -> WindowMode:
        r"""
        x.get_last_confirmed_fullscreen_mode() -> WindowMode
        Returns the last confirmed user setting for game window fullscreen mode.
        
        Returns:
            WindowMode:
        """
        ...
    def get_global_illumination_quality(self) -> int:
        r"""
        x.get_global_illumination_quality() -> int32
        Returns the global illumination quality (0..4, higher is better)
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_game_user_settings(cls) -> GameUserSettings:
        r"""
        X.get_game_user_settings() -> GameUserSettings
        Returns the game local machine settings (resolution, windowing mode, scalability settings, etc...)
        
        Returns:
            GameUserSettings:
        """
        ...
    def get_fullscreen_mode(self) -> WindowMode:
        r"""
        x.get_fullscreen_mode() -> WindowMode
        Returns the user setting for game window fullscreen mode.
        
        Returns:
            WindowMode:
        """
        ...
    def get_frame_rate_limit(self) -> float:
        r"""
        x.get_frame_rate_limit() -> float
        Gets the user's frame rate limit (0 indiciates the frame rate limit is disabled)
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_frame_pace(cls) -> int:
        r"""
        X.get_frame_pace() -> int32
        Gets the current frame pacing frame rate in fps, or 0 if none
        
        Returns:
            int32:
        """
        ...
    def get_foliage_quality(self) -> int:
        r"""
        x.get_foliage_quality() -> int32
        Returns the foliage quality (0..4, higher is better)
        
        Returns:
            int32:
        """
        ...
    def get_desktop_resolution(self) -> IntPoint:
        r"""
        x.get_desktop_resolution() -> IntPoint
        Returns user's desktop resolution, in pixels.
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def get_default_window_position(cls) -> IntPoint:
        r"""
        X.get_default_window_position() -> IntPoint
        Returns the default window position when no position is set
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def get_default_window_mode(cls) -> WindowMode:
        r"""
        X.get_default_window_mode() -> WindowMode
        Returns the default window mode when no mode is set
        
        Returns:
            WindowMode:
        """
        ...
    def get_default_resolution_scale(self) -> float:
        r"""
        x.get_default_resolution_scale() -> float
        Gets the desired resolution quality based on DesiredScreenWidth/Height and the current screen resolution
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_default_resolution(cls) -> IntPoint:
        r"""
        X.get_default_resolution() -> IntPoint
        Returns the default resolution when no resolution is set
        
        Returns:
            IntPoint:
        """
        ...
    def get_current_hdr_display_nits(self) -> int:
        r"""
        x.get_current_hdr_display_nits() -> int32
        Returns 0 if HDR isn't supported or is turned off
        
        Returns:
            int32:
        """
        ...
    def get_audio_quality_level(self) -> int:
        r"""
        x.get_audio_quality_level() -> int32
        Returns the user's audio quality level setting
        
        Returns:
            int32:
        """
        ...
    def get_anti_aliasing_quality(self) -> int:
        r"""
        x.get_anti_aliasing_quality() -> int32
        Returns the anti-aliasing quality (0..4, higher is better)
        
        Returns:
            int32:
        """
        ...
    def enable_hdr_display_output(self, enable: bool, display_nits: int = 1000) -> None:
        r"""
        x.enable_hdr_display_output(enable, display_nits=1000) -> None
        Enables or disables HDR display output. Can be called again to change the desired nit level
        
        Args:
            enable (bool): 
            display_nits (int32):
        """
        ...
    def confirm_video_mode(self) -> None:
        r"""
        x.confirm_video_mode() -> None
        Mark current video mode settings (fullscreenmode/resolution) as being confirmed by the user
        """
        ...
    def apply_settings(self, check_for_command_line_overrides: bool = True) -> None:
        r"""
        x.apply_settings(check_for_command_line_overrides=True) -> None
        Applies all current user settings to the game and saves to permanent storage (e.g. file), optionally checking for command line overrides.
        
        Args:
            check_for_command_line_overrides (bool):
        """
        ...
    def apply_resolution_settings(self, check_for_command_line_overrides: bool) -> None:
        r"""
        x.apply_resolution_settings(check_for_command_line_overrides) -> None
        Apply Resolution Settings
        
        Args:
            check_for_command_line_overrides (bool):
        """
        ...
    def apply_non_resolution_settings(self) -> None:
        r"""
        x.apply_non_resolution_settings() -> None
        Apply Non Resolution Settings
        """
        ...
    def apply_hardware_benchmark_results(self) -> None:
        r"""
        x.apply_hardware_benchmark_results() -> None
        Applies the settings stored in ScalabilityQuality and saves settings
        """
        ...

class InputDeviceLibrary(BlueprintFunctionLibrary):
    r"""
    A static BP library that exposes Input Device data to blueprints
    see: IPlatformInputDeviceMapper
    note: Keep any function comments up to date with those in GenericPlatformInputDeviceMapper.h!
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputDeviceLibrary.h
    
    """
    @classmethod
    def not_equal_platform_user_id(cls, a: PlatformUserId, b: PlatformUserId) -> bool:
        r"""
        X.not_equal_platform_user_id(a, b) -> bool
        Returns true if PlatformUserId A is not equal to PlatformUserId B (A != B)
        
        Args:
            a (PlatformUserId): 
            b (PlatformUserId): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_input_device_id(cls, a: InputDeviceId, b: InputDeviceId) -> bool:
        r"""
        X.not_equal_input_device_id(a, b) -> bool
        Returns true if InputDeviceId A is not equal to InputDeviceId B (A != B)
        
        Args:
            a (InputDeviceId): 
            b (InputDeviceId): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_platform_id(cls, user_id: PlatformUserId) -> bool:
        r"""
        X.is_valid_platform_id(user_id) -> bool
        Check if the given platform ID is valid
        
        Args:
            user_id (PlatformUserId): 
        
        Returns:
            bool: True if the platform ID is valid (it has been assigned by the PlatformInputDeviceMapper)
        """
        ...
    @classmethod
    def is_valid_input_device(cls, device_id: InputDeviceId) -> bool:
        r"""
        X.is_valid_input_device(device_id) -> bool
        Check if the given input device is valid
        
        Args:
            device_id (InputDeviceId): 
        
        Returns:
            bool: True if the given input device is valid (it has been assigned an ID by the PlatformInputDeviceMapper)
        """
        ...
    @classmethod
    def is_unpaired_user_id(cls, platform_id: PlatformUserId) -> bool:
        r"""
        X.is_unpaired_user_id(platform_id) -> bool
        Returns true if the given Platform User Id is the user for unpaired input devices on this platform.
        
        Args:
            platform_id (PlatformUserId): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_input_device_mapped_to_unpaired_user(cls, input_device: InputDeviceId) -> bool:
        r"""
        X.is_input_device_mapped_to_unpaired_user(input_device) -> bool
        Returns true if the given input device is mapped to the unpaired platform user id.
        
        Args:
            input_device (InputDeviceId): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_device_property_handle_valid(cls, handle: InputDevicePropertyHandle) -> bool:
        r"""
        X.is_device_property_handle_valid(handle) -> bool
        Returns true if the given handle is valid
        
        Args:
            handle (InputDevicePropertyHandle): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_user_for_unpaired_input_devices(cls) -> PlatformUserId:
        r"""
        X.get_user_for_unpaired_input_devices() -> PlatformUserId
        Returns the platform user id that is being used for unmapped input devices.
        Will be PLATFORMUSERID_NONE if platform does not support this (this is the default behavior)
        
        Returns:
            PlatformUserId:
        """
        ...
    @classmethod
    def get_user_for_input_device(cls, device_id: InputDeviceId) -> PlatformUserId:
        r"""
        X.get_user_for_input_device(device_id) -> PlatformUserId
        Returns the platform user attached to this input device, or PLATFORMUSERID_NONE if invalid
        
        Args:
            device_id (InputDeviceId): 
        
        Returns:
            PlatformUserId:
        """
        ...
    @classmethod
    def get_primary_platform_user(cls) -> PlatformUserId:
        r"""
        X.get_primary_platform_user() -> PlatformUserId
        Returns the 'Primary' Platform user for this platform.
        This typically has an internal ID of '0' and is used as the default platform user to
        map devices such as the keyboard and mouse that don't get assigned unique ID's from their
        owning platform code.
        
        Returns:
            PlatformUserId:
        """
        ...
    @classmethod
    def get_primary_input_device_for_user(cls, user_id: PlatformUserId) -> InputDeviceId:
        r"""
        X.get_primary_input_device_for_user(user_id) -> InputDeviceId
        Returns the primary input device used by a specific player, or INPUTDEVICEID_NONE if invalid
        
        Args:
            user_id (PlatformUserId): 
        
        Returns:
            InputDeviceId:
        """
        ...
    @classmethod
    def get_player_controller_from_platform_user(cls, user_id: PlatformUserId) -> PlayerController:
        r"""
        X.get_player_controller_from_platform_user(user_id) -> PlayerController
        Get the player controller who has the given Platform User ID.
        
        Args:
            user_id (PlatformUserId): 
        
        Returns:
            PlayerController:
        """
        ...
    @classmethod
    def get_player_controller_from_input_device(cls, device_id: InputDeviceId) -> PlayerController:
        r"""
        X.get_player_controller_from_input_device(device_id) -> PlayerController
        Get the player controller who owns the given input device id
        
        Args:
            device_id (InputDeviceId): 
        
        Returns:
            PlayerController:
        """
        ...
    @classmethod
    def get_input_device_connection_state(cls, device_id: InputDeviceId) -> InputDeviceConnectionState:
        r"""
        X.get_input_device_connection_state(device_id) -> InputDeviceConnectionState
        Gets the connection state of the given input device.
        
        Args:
            device_id (InputDeviceId): The device to get the connection state of
        
        Returns:
            InputDeviceConnectionState: The connection state of the given device. EInputDeviceConnectionState::Unknown if the device is not mapped
        """
        ...
    @classmethod
    def get_default_input_device(cls) -> InputDeviceId:
        r"""
        X.get_default_input_device() -> InputDeviceId
        Returns the default device id used for things like keyboard/mouse input
        
        Returns:
            InputDeviceId:
        """
        ...
    @classmethod
    def get_all_input_devices_for_user(cls, user_id: PlatformUserId) -> Tuple[int, Array[InputDeviceId]]:
        r"""
        X.get_all_input_devices_for_user(user_id) -> (int32, out_input_devices=Array[InputDeviceId])
        Populates the OutInputDevices array with any InputDeviceID's that are mapped to the given platform user
        
        Args:
            user_id (PlatformUserId): The Platform User to gather the input devices of.
        
        Returns:
            Array[InputDeviceId]: The number of mapped devices, INDEX_NONE if the user was not found.
        
            out_input_devices (Array[InputDeviceId]): Array of input device ID's that will be populated with the mapped devices.
        """
        ...
    @classmethod
    def get_all_input_devices(cls) -> Tuple[int, Array[InputDeviceId]]:
        r"""
        X.get_all_input_devices() -> (int32, out_input_devices=Array[InputDeviceId])
        Get all mapped input devices on this platform regardless of their connection state.
        
        Returns:
            Array[InputDeviceId]: The number of connected input devices
        
            out_input_devices (Array[InputDeviceId]): Array of input devices to populate
        """
        ...
    @classmethod
    def get_all_connected_input_devices(cls) -> Tuple[int, Array[InputDeviceId]]:
        r"""
        X.get_all_connected_input_devices() -> (int32, out_input_devices=Array[InputDeviceId])
        Gather all currently connected input devices
        
        Returns:
            Array[InputDeviceId]: The number of connected input devices
        
            out_input_devices (Array[InputDeviceId]): Array of input devices to populate
        """
        ...
    @classmethod
    def get_all_active_users(cls) -> Tuple[int, Array[PlatformUserId]]:
        r"""
        X.get_all_active_users() -> (int32, out_users=Array[PlatformUserId])
        Get all currently active platform ids, anyone who has a mapped input device
        
        Returns:
            Array[PlatformUserId]: The number of active platform users
        
            out_users (Array[PlatformUserId]): Array that will be populated with the platform users.
        """
        ...
    @classmethod
    def equal_equal_platform_user_id(cls, a: PlatformUserId, b: PlatformUserId) -> bool:
        r"""
        X.equal_equal_platform_user_id(a, b) -> bool
        Returns true if PlatformUserId A is equal to PlatformUserId B (A == B)
        
        Args:
            a (PlatformUserId): 
            b (PlatformUserId): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_input_device_id(cls, a: InputDeviceId, b: InputDeviceId) -> bool:
        r"""
        X.equal_equal_input_device_id(a, b) -> bool
        Returns true if InputDeviceId A is equal to InputDeviceId B (A == B)
        
        Args:
            a (InputDeviceId): 
            b (InputDeviceId): 
        
        Returns:
            bool:
        """
        ...

class PlatformInputDeviceMapperLibrary(InputDeviceLibrary):
    r"""
    deprecated: 'PlatformInputDeviceMapperLibrary' was renamed to 'InputDeviceLibrary'.
    """
    ...

class InstancedPlacementPartitionActor(ISMPartitionActor):
    r"""
    The base class used by any editor placement of instanced objects, which holds any relevant runtime data for the placed instances.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InstancedPlacementPartitionActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class KillZVolume(PhysicsVolume):
    r"""
    KillZVolume is a volume used to determine when actors should be killed. Killing logic is overridden in FellOutOfWorld
    see: FellOutOfWorld
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KillZVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``fluid_friction`` (float):  [Read-Write] This property controls the amount of friction applied by the volume as pawns using CharacterMovement move through it. The higher this value, the harder it will feel to move through
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_on_contact`` (bool):  [Read-Write] By default, the origin of an AActor must be inside a PhysicsVolume for it to affect the actor. However if this flag is true, the other actor only has to touch the volume to be affected by it.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``priority`` (int32):  [Read-Write] Determines which PhysicsVolume takes precedence if they overlap (higher number = higher priority).
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``terminal_velocity`` (float):  [Read-Write] Terminal velocity of pawns using CharacterMovement when falling.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``water_volume`` (bool):  [Read-Write] True if this volume contains a fluid like water
    """
    ...

class KismetArrayLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet Array Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetArrayLibrary.h
    
    """
    @classmethod
    def sort_string_array(cls, target_array: Array[str], stable_sort: bool = False, sort_order: ArraySortOrder = ArraySortOrder.ASCENDING) -> Array[str]:
        r"""
        X.sort_string_array(target_array, stable_sort=False, sort_order=ArraySortOrder.ASCENDING) -> Array[str]
        Sorts an array of strings alphabetically.
        
        Args:
            target_array (Array[str]): The array to sort.
            stable_sort (bool): If a stable sort should be used. This preserves the order of identical elements, but is slower.
            sort_order (ArraySortOrder): If the array should be sorted in ascending or descending order.
        
        Returns:
            Array[str]: 
        
            target_array (Array[str]): The array to sort.
        """
        ...
    @classmethod
    def sort_name_array(cls, target_array: Array[Name], stable_sort: bool = False, lexical_sort: bool = True, sort_order: ArraySortOrder = ArraySortOrder.ASCENDING) -> Array[Name]:
        r"""
        X.sort_name_array(target_array, stable_sort=False, lexical_sort=True, sort_order=ArraySortOrder.ASCENDING) -> Array[Name]
        Sorts an array of FNames.
        
        Args:
            target_array (Array[Name]): The array to sort.
            stable_sort (bool): If a stable sort should be used. This preserves the order of identical elements, but is slower.
            lexical_sort (bool): If the names should be sorted based on the string value of the name rather than the comparison index. This is slower when enabled.
            sort_order (ArraySortOrder): If the array should be sorted in ascending or descending order.
        
        Returns:
            Array[Name]: 
        
            target_array (Array[Name]): The array to sort.
        """
        ...
    @classmethod
    def sort_int_array(cls, target_array: Array[int], stable_sort: bool = False, sort_order: ArraySortOrder = ArraySortOrder.ASCENDING) -> Array[int]:
        r"""
        X.sort_int_array(target_array, stable_sort=False, sort_order=ArraySortOrder.ASCENDING) -> Array[int32]
        Sorts an array of integers.
        
        Args:
            target_array (Array[int32]): The array to sort.
            stable_sort (bool): If a stable sort should be used. This preserves the order of identical elements, but is slower.
            sort_order (ArraySortOrder): If the array should be sorted in ascending or descending order.
        
        Returns:
            Array[int32]: 
        
            target_array (Array[int32]): The array to sort.
        """
        ...
    @classmethod
    def sort_int64_array(cls, target_array: Array[int], stable_sort: bool = False, sort_order: ArraySortOrder = ArraySortOrder.ASCENDING) -> Array[int]:
        r"""
        X.sort_int64_array(target_array, stable_sort=False, sort_order=ArraySortOrder.ASCENDING) -> Array[int64]
        Sorts an array of 64-bit integers.
        
        Args:
            target_array (Array[int64]): The array to sort.
            stable_sort (bool): If a stable sort should be used. This preserves the order of identical elements, but is slower.
            sort_order (ArraySortOrder): If the array should be sorted in ascending or descending order.
        
        Returns:
            Array[int64]: 
        
            target_array (Array[int64]): The array to sort.
        """
        ...
    @classmethod
    def sort_float_array(cls, target_array: Array[float], stable_sort: bool = False, sort_order: ArraySortOrder = ArraySortOrder.ASCENDING) -> Array[float]:
        r"""
        X.sort_float_array(target_array, stable_sort=False, sort_order=ArraySortOrder.ASCENDING) -> Array[double]
        Sorts an array of doubles.
        
        Args:
            target_array (Array[double]): The array to sort.
            stable_sort (bool): If a stable sort should be used. This preserves the order of identical elements, but is slower.
            sort_order (ArraySortOrder): If the array should be sorted in ascending or descending order.
        
        Returns:
            Array[double]: 
        
            target_array (Array[double]): The array to sort.
        """
        ...
    @classmethod
    def sort_byte_array(cls, target_array: Array[int], stable_sort: bool = False, sort_order: ArraySortOrder = ArraySortOrder.ASCENDING) -> Array[int]:
        r"""
        X.sort_byte_array(target_array, stable_sort=False, sort_order=ArraySortOrder.ASCENDING) -> Array[uint8]
        Sorts an array of bytes.
        
        Args:
            target_array (Array[uint8]): The array to sort.
            stable_sort (bool): If a stable sort should be used. This preserves the order of identical elements, but is slower.
            sort_order (ArraySortOrder): If the array should be sorted in ascending or descending order.
        
        Returns:
            Array[uint8]: 
        
            target_array (Array[uint8]): The array to sort.
        """
        ...
    @classmethod
    def filter_array(cls, target_array: Array[Actor], filter_class: Class) -> Array[Actor]:
        r"""
        X.filter_array(target_array, filter_class) -> Array[Actor]
        *Filter an array based on a Class derived from Actor.
        *
        *
        
        Args:
            target_array (Array[Actor]): The array to filter from *
            filter_class (type(Class)): The Actor sub-class type that acts as the filter, only objects derived from it will be returned. *
        
        Returns:
            Array[Actor]: 
        
            filtered_array (Array[Actor]):
        """
        ...

class GuidLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet Guid Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetGuidLibrary.h
    
    """
    @classmethod
    def parse_string_to_guid(cls, guid_string: str) -> Tuple[Guid, bool]:
        r"""
        X.parse_string_to_guid(guid_string) -> (out_guid=Guid, success=bool)
        Converts a String of format EGuidFormats to a Guid. Returns Guid OutGuid, Returns bool Success
        
        Args:
            guid_string (str): 
        
        Returns:
            tuple: 
        
            out_guid (Guid): 
        
            success (bool):
        """
        ...
    @classmethod
    def not_equal_guid_guid(cls, a: Guid, b: Guid) -> bool:
        r"""
        X.not_equal_guid_guid(a, b) -> bool
        Returns true if the values are not equal (A != B)
        
        Args:
            a (Guid): 
            b (Guid): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def new_guid(cls) -> Guid:
        r"""
        X.new_guid() -> Guid
        Returns a new unique GUID
        
        Returns:
            Guid:
        """
        ...
    @classmethod
    def is_valid_guid(cls, guid: Guid) -> bool:
        r"""
        X.is_valid_guid(guid) -> bool
        Checks whether the given GUID is valid
        
        Args:
            guid (Guid): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def invalidate_guid(cls, guid: Guid) -> Guid:
        r"""
        X.invalidate_guid(guid) -> Guid
        Invalidates the given GUID
        
        Args:
            guid (Guid): 
        
        Returns:
            Guid: 
        
            guid (Guid):
        """
        ...
    @classmethod
    def equal_equal_guid_guid(cls, a: Guid, b: Guid) -> bool:
        r"""
        X.equal_equal_guid_guid(a, b) -> bool
        Returns true if the values are equal (A == B)
        
        Args:
            a (Guid): 
            b (Guid): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def conv_guid_to_string(cls, guid: Guid) -> str:
        r"""
        X.conv_guid_to_string(guid) -> str
        Converts a GUID value to a string, in the form 'A-B-C-D'
        
        Args:
            guid (Guid): 
        
        Returns:
            str:
        """
        ...

class InputLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet Input Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetInputLibrary.h
    
    """
    @classmethod
    def pointer_event_is_touch_event(cls, input: PointerEvent) -> bool:
        r"""
        X.pointer_event_is_touch_event(input) -> bool
        Returns true if this event a result from a touch (as opposed to a mouse)
        
        Args:
            input (PointerEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def pointer_event_is_mouse_button_down(cls, input: PointerEvent, mouse_button: Key) -> bool:
        r"""
        X.pointer_event_is_mouse_button_down(input, mouse_button) -> bool
        Mouse buttons that are currently pressed
        
        Args:
            input (PointerEvent): 
            mouse_button (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def pointer_event_get_wheel_delta(cls, input: PointerEvent) -> float:
        r"""
        X.pointer_event_get_wheel_delta(input) -> float
        How much did the mouse wheel turn since the last mouse event
        
        Args:
            input (PointerEvent): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def pointer_event_get_user_index(cls, input: PointerEvent) -> int:
        r"""
        X.pointer_event_get_user_index(input) -> int32
        Returns the index of the user that caused the event
        
        Args:
            input (PointerEvent): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def pointer_event_get_touchpad_index(cls, input: PointerEvent) -> int:
        r"""
        X.pointer_event_get_touchpad_index(input) -> int32
        Returns the index of the touch pad that generated this event (for platforms with multiple touch pads per user)
        
        Args:
            input (PointerEvent): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def pointer_event_get_screen_space_position(cls, input: PointerEvent) -> Vector2D:
        r"""
        X.pointer_event_get_screen_space_position(input) -> Vector2D
        Returns The position of the cursor in screen space
        
        Args:
            input (PointerEvent): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def pointer_event_get_pointer_index(cls, input: PointerEvent) -> int:
        r"""
        X.pointer_event_get_pointer_index(input) -> int32
        Returns the unique identifier of the pointer (e.g., finger index)
        
        Args:
            input (PointerEvent): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def pointer_event_get_last_screen_space_position(cls, input: PointerEvent) -> Vector2D:
        r"""
        X.pointer_event_get_last_screen_space_position(input) -> Vector2D
        Returns the position of the cursor in screen space last time we handled an input event
        
        Args:
            input (PointerEvent): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def pointer_event_get_gesture_type(cls, input: PointerEvent) -> SlateGesture:
        r"""
        X.pointer_event_get_gesture_type(input) -> SlateGesture
        Returns the type of touch gesture
        
        Args:
            input (PointerEvent): 
        
        Returns:
            SlateGesture:
        """
        ...
    @classmethod
    def pointer_event_get_gesture_delta(cls, input: PointerEvent) -> Vector2D:
        r"""
        X.pointer_event_get_gesture_delta(input) -> Vector2D
        Returns the change in gesture value since the last gesture event of the same type.
        
        Args:
            input (PointerEvent): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def pointer_event_get_effecting_button(cls, input: PointerEvent) -> Key:
        r"""
        X.pointer_event_get_effecting_button(input) -> Key
        Mouse button that caused this event to be raised (possibly FKey::Invalid)
        
        Args:
            input (PointerEvent): 
        
        Returns:
            Key:
        """
        ...
    @classmethod
    def pointer_event_get_cursor_delta(cls, input: PointerEvent) -> Vector2D:
        r"""
        X.pointer_event_get_cursor_delta(input) -> Vector2D
        Returns the distance the mouse traveled since the last event was handled.
        
        Args:
            input (PointerEvent): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def modifier_keys_state_is_shift_down(cls, keys_state: SlateModifierKeysState) -> bool:
        r"""
        X.modifier_keys_state_is_shift_down(keys_state) -> bool
        Returns true if either shift key was down when the key state was captured
        
        Args:
            keys_state (SlateModifierKeysState): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def modifier_keys_state_is_control_down(cls, keys_state: SlateModifierKeysState) -> bool:
        r"""
        X.modifier_keys_state_is_control_down(keys_state) -> bool
        Returns true if either control key was down when the key state was captured
        
        Args:
            keys_state (SlateModifierKeysState): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def modifier_keys_state_is_command_down(cls, keys_state: SlateModifierKeysState) -> bool:
        r"""
        X.modifier_keys_state_is_command_down(keys_state) -> bool
        Returns true if either command key was down when the key state was captured
        
        Args:
            keys_state (SlateModifierKeysState): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def modifier_keys_state_is_alt_down(cls, keys_state: SlateModifierKeysState) -> bool:
        r"""
        X.modifier_keys_state_is_alt_down(keys_state) -> bool
        Returns true if either alt key was down when the key state was captured
        
        Args:
            keys_state (SlateModifierKeysState): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_vector_axis(cls, key: Key) -> bool:
        r"""
        X.key_is_vector_axis(key) -> bool
        Returns true if the key is a vector axis
        deprecated: Use Is Axis 2D/3D instead.
        note: Deprecated. Use Is Axis 2D/3D instead.
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_valid(cls, key: Key) -> bool:
        r"""
        X.key_is_valid(key) -> bool
        Returns true if this is a valid key.
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_mouse_button(cls, key: Key) -> bool:
        r"""
        X.key_is_mouse_button(key) -> bool
        Returns true if the key is a mouse button
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_modifier_key(cls, key: Key) -> bool:
        r"""
        X.key_is_modifier_key(key) -> bool
        Returns true if the key is a modifier key: Ctrl, Command, Alt, Shift
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_keyboard_key(cls, key: Key) -> bool:
        r"""
        X.key_is_keyboard_key(key) -> bool
        Returns true if the key is a keyboard button
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_gamepad_key(cls, key: Key) -> bool:
        r"""
        X.key_is_gamepad_key(key) -> bool
        Returns true if the key is a gamepad button
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_digital(cls, key: Key) -> bool:
        r"""
        X.key_is_digital(key) -> bool
        Returns true if the key is a digital button press
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_button_axis(cls, key: Key) -> bool:
        r"""
        X.key_is_button_axis(key) -> bool
        Returns true if the key is a 1D axis emulating a digital button press.
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_axis3d(cls, key: Key) -> bool:
        r"""
        X.key_is_axis3d(key) -> bool
        Returns true if the key is a 3D (vector) axis
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_axis2d(cls, key: Key) -> bool:
        r"""
        X.key_is_axis2d(key) -> bool
        Returns true if the key is a 2D (vector) axis
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_axis1d(cls, key: Key) -> bool:
        r"""
        X.key_is_axis1d(key) -> bool
        Returns true if the key is a 1D (float) axis
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_is_float_axis(cls, key: Key) -> bool:
        r"""
        deprecated: 'key_is_float_axis' was renamed to 'key_is_axis1d'.
        """
        ...
    @classmethod
    def key_is_analog(cls, key: Key) -> bool:
        r"""
        X.key_is_analog(key) -> bool
        Returns true if the key is an analog axis
        
        Args:
            key (Key): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def key_get_navigation_direction_from_key(cls, key_event: KeyEvent) -> UINavigation:
        r"""
        X.key_get_navigation_direction_from_key(key_event) -> UINavigation
        Returns the navigation action corresponding to this key, or Invalid if not found
        
        Args:
            key_event (KeyEvent): 
        
        Returns:
            UINavigation:
        """
        ...
    @classmethod
    def key_get_navigation_direction_from_analog(cls, analog_event: AnalogInputEvent) -> UINavigation:
        r"""
        X.key_get_navigation_direction_from_analog(analog_event) -> UINavigation
        Returns the navigation action corresponding to this key, or Invalid if not found
        
        Args:
            analog_event (AnalogInputEvent): 
        
        Returns:
            UINavigation:
        """
        ...
    @classmethod
    def key_get_navigation_action_from_key(cls, key_event: KeyEvent) -> UINavigationAction:
        r"""
        X.key_get_navigation_action_from_key(key_event) -> UINavigationAction
        Returns the navigation action corresponding to this key, or Invalid if not found
        
        Args:
            key_event (KeyEvent): 
        
        Returns:
            UINavigationAction:
        """
        ...
    @classmethod
    def key_get_navigation_action(cls, key: Key) -> UINavigationAction:
        r"""
        X.key_get_navigation_action(key) -> UINavigationAction
        Key Get Navigation Action
        deprecated: Use Get Key Event Navigation Action instead
        
        Args:
            key (Key): 
        
        Returns:
            UINavigationAction:
        """
        ...
    @classmethod
    def key_get_display_name(cls, key: Key, long_display_name: bool = True) -> Text:
        r"""
        X.key_get_display_name(key, long_display_name=True) -> Text
        Returns the display name of the key.
        
        Args:
            key (Key): 
            long_display_name (bool): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def input_event_is_shift_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_shift_down(input) -> bool
        Returns true if either shift key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_right_shift_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_right_shift_down(input) -> bool
        Returns true if right shift key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_right_control_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_right_control_down(input) -> bool
        Returns true if left control key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_right_command_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_right_command_down(input) -> bool
        Returns true if right command key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_right_alt_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_right_alt_down(input) -> bool
        Returns true if right alt key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_repeat(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_repeat(input) -> bool
        Returns whether or not this character is an auto-repeated keystroke
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_left_shift_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_left_shift_down(input) -> bool
        Returns true if left shift key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_left_control_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_left_control_down(input) -> bool
        Returns true if left control key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_left_command_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_left_command_down(input) -> bool
        Returns true if left command key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_left_alt_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_left_alt_down(input) -> bool
        Returns true if left alt key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_control_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_control_down(input) -> bool
        Returns true if either control key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_command_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_command_down(input) -> bool
        Returns true if either command key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_event_is_alt_down(cls, input: InputEvent) -> bool:
        r"""
        X.input_event_is_alt_down(input) -> bool
        Returns true if either alt key was down when this event occurred
        
        Args:
            input (InputEvent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def input_chord_get_display_name(cls, key: InputChord) -> Text:
        r"""
        X.input_chord_get_display_name(key) -> Text
        
        
        Args:
            key (InputChord): 
        
        Returns:
            Text: The display name of the input chord
        """
        ...
    @classmethod
    def get_user_index(cls, input: KeyEvent) -> int:
        r"""
        X.get_user_index(input) -> int32
        Get User Index
        
        Args:
            input (KeyEvent): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_modifier_keys_state(cls) -> SlateModifierKeysState:
        r"""
        X.get_modifier_keys_state() -> SlateModifierKeysState
        Returns a snapshot of the cached modifier-keys state for the application.
        
        Returns:
            SlateModifierKeysState:
        """
        ...
    @classmethod
    def get_key(cls, input: KeyEvent) -> Key:
        r"""
        X.get_key(input) -> Key
        Returns the key for this event.
        
        Args:
            input (KeyEvent): 
        
        Returns:
            Key: Key name
        """
        ...
    @classmethod
    def get_analog_value(cls, input: AnalogInputEvent) -> float:
        r"""
        X.get_analog_value(input) -> float
        Get Analog Value
        
        Args:
            input (AnalogInputEvent): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def equal_equal_key_key(cls, a: Key, b: Key) -> bool:
        r"""
        X.equal_equal_key_key(a, b) -> bool
        Test if the input key are equal (A == B)
        
        Args:
            a (Key): The key to compare against
            b (Key): The key to compare Returns true if the key are equal, false otherwise
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_input_chord_input_chord(cls, a: InputChord, b: InputChord) -> bool:
        r"""
        X.equal_equal_input_chord_input_chord(a, b) -> bool
        Test if the input chords are equal (A == B)
        
        Args:
            a (InputChord): The chord to compare against
            b (InputChord): The chord to compare Returns true if the chords are equal, false otherwise
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def calibrate_tilt(cls) -> None:
        r"""
        X.calibrate_tilt() -> None
        Calibrate the tilt for the input device
        """
        ...

class InternationalizationLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet Internationalization Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetInternationalizationLibrary.h
    
    """
    @classmethod
    def set_current_locale(cls, culture: str, save_to_config: bool = False) -> bool:
        r"""
        X.set_current_locale(culture, save_to_config=False) -> bool
        Set *only* the current locale (for internationalization).
        note: Unless you're doing something advanced, you likely want SetCurrentLanguageAndLocale or SetCurrentCulture instead.
        
        Args:
            culture (str): The locale to set, as an IETF language tag (eg, "zh-Hans-CN").
            save_to_config (bool): If true, save the new setting to the users' "GameUserSettings" config so that it persists after a reload.
        
        Returns:
            bool: True if the locale was set, false otherwise.
        """
        ...
    @classmethod
    def set_current_language_and_locale(cls, culture: str, save_to_config: bool = False) -> bool:
        r"""
        X.set_current_language_and_locale(culture, save_to_config=False) -> bool
        Set the current language (for localization) and locale (for internationalization).
        
        Args:
            culture (str): The language and locale to set, as an IETF language tag (eg, "zh-Hans-CN").
            save_to_config (bool): If true, save the new setting to the users' "GameUserSettings" config so that it persists after a reload.
        
        Returns:
            bool: True if the language and locale were set, false otherwise.
        """
        ...
    @classmethod
    def set_current_language(cls, culture: str, save_to_config: bool = False) -> bool:
        r"""
        X.set_current_language(culture, save_to_config=False) -> bool
        Set *only* the current language (for localization).
        note: Unless you're doing something advanced, you likely want SetCurrentLanguageAndLocale or SetCurrentCulture instead.
        
        Args:
            culture (str): The language to set, as an IETF language tag (eg, "zh-Hans-CN").
            save_to_config (bool): If true, save the new setting to the users' "GameUserSettings" config so that it persists after a reload.
        
        Returns:
            bool: True if the language was set, false otherwise.
        """
        ...
    @classmethod
    def set_current_culture(cls, culture: str, save_to_config: bool = False) -> bool:
        r"""
        X.set_current_culture(culture, save_to_config=False) -> bool
        Set the current culture.
        note: This function is a sledgehammer, and will set both the language and locale, as well as clear out any asset group cultures that may be set.
        
        Args:
            culture (str): The culture to set, as an IETF language tag (eg, "zh-Hans-CN").
            save_to_config (bool): If true, save the new setting to the users' "GameUserSettings" config so that it persists after a reload.
        
        Returns:
            bool: True if the culture was set, false otherwise.
        """
        ...
    @classmethod
    def set_current_asset_group_culture(cls, asset_group: Name, culture: str, save_to_config: bool = False) -> bool:
        r"""
        X.set_current_asset_group_culture(asset_group, culture, save_to_config=False) -> bool
        Set the given asset group category culture from an IETF language tag (eg, "zh-Hans-CN").
        
        Args:
            asset_group (Name): The asset group to set the culture for.
            culture (str): The culture to set, as an IETF language tag (eg, "zh-Hans-CN").
            save_to_config (bool): If true, save the new setting to the users' "GameUserSettings" config so that it persists after a reload.
        
        Returns:
            bool: True if the culture was set, false otherwise.
        """
        ...
    @classmethod
    def get_suitable_culture(cls, available_cultures: Array[str], culture_to_match: str, fallback_culture: str = "en") -> str:
        r"""
        X.get_suitable_culture(available_cultures, culture_to_match, fallback_culture="en") -> str
        Given a list of available cultures, try and find the most suitable culture from the list based on culture prioritization.
          eg) If your list was [en, fr, de] and the given culture was "en-US", this function would return "en".
          eg) If your list was [zh, ar, pl] and the given culture was "en-US", this function would return the fallback culture.
        
        Args:
            available_cultures (Array[str]): List of available cultures to filter against (see GetLocalizedCultures).
            culture_to_match (str): Culture to try and match (see GetCurrentLanguage).
            fallback_culture (str): The culture to return if there is no suitable match in the list (typically your native culture, see GetNativeCulture).
        
        Returns:
            str: The culture as an IETF language tag (eg, "zh-Hans-CN").
        """
        ...
    @classmethod
    def get_native_culture(cls, text_category: LocalizedTextSourceCategory) -> str:
        r"""
        X.get_native_culture(text_category) -> str
        Get the native culture for the given localization category.
        
        Args:
            text_category (LocalizedTextSourceCategory): 
        
        Returns:
            str: The culture as an IETF language tag (eg, "zh-Hans-CN").
        """
        ...
    @classmethod
    def get_localized_cultures(cls, include_game: bool = True, include_engine: bool = False, include_editor: bool = False, include_additional: bool = False) -> Array[str]:
        r"""
        X.get_localized_cultures(include_game=True, include_engine=False, include_editor=False, include_additional=False) -> Array[str]
        Get the list of cultures that have localization data available for them.
        
        Args:
            include_game (bool): Check for localized game resources.
            include_engine (bool): Check for localized engine resources.
            include_editor (bool): Check for localized editor resources.
            include_additional (bool): Check for localized additional (eg, plugin) resources.
        
        Returns:
            Array[str]: The list of cultures as IETF language tags (eg, "zh-Hans-CN").
        """
        ...
    @classmethod
    def get_current_locale(cls) -> str:
        r"""
        X.get_current_locale() -> str
        Get the current locale (for internationalization) as an IETF language tag:
         - A two-letter ISO 639-1 language code (eg, "zh").
         - An optional four-letter ISO 15924 script code (eg, "Hans").
         - An optional two-letter ISO 3166-1 country code (eg, "CN").
        
        Returns:
            str: The locale as an IETF language tag (eg, "zh-Hans-CN").
        """
        ...
    @classmethod
    def get_current_language(cls) -> str:
        r"""
        X.get_current_language() -> str
        Get the current language (for localization) as an IETF language tag:
         - A two-letter ISO 639-1 language code (eg, "zh").
         - An optional four-letter ISO 15924 script code (eg, "Hans").
         - An optional two-letter ISO 3166-1 country code (eg, "CN").
        
        Returns:
            str: The language as an IETF language tag (eg, "zh-Hans-CN").
        """
        ...
    @classmethod
    def get_current_culture(cls) -> str:
        r"""
        X.get_current_culture() -> str
        Get the current culture as an IETF language tag:
         - A two-letter ISO 639-1 language code (eg, "zh").
         - An optional four-letter ISO 15924 script code (eg, "Hans").
         - An optional two-letter ISO 3166-1 country code (eg, "CN").
        note: This function exists for legacy API parity with SetCurrentCulture and is equivalent to GetCurrentLanguage.
        
        Returns:
            str: The culture as an IETF language tag (eg, "zh-Hans-CN").
        """
        ...
    @classmethod
    def get_current_asset_group_culture(cls, asset_group: Name) -> str:
        r"""
        X.get_current_asset_group_culture(asset_group) -> str
        Get the given asset group category culture.
        note: Returns the current language if the group category doesn't have a culture override.
        
        Args:
            asset_group (Name): The asset group to get the culture for.
        
        Returns:
            str: The culture as an IETF language tag (eg, "zh-Hans-CN").
        """
        ...
    @classmethod
    def get_culture_display_name(cls, culture: str, localized: bool = True) -> str:
        r"""
        X.get_culture_display_name(culture, localized=True) -> str
        Get the display name of the given culture.
        
        Args:
            culture (str): The culture to get the display name of, as an IETF language tag (eg, "zh-Hans-CN")
            localized (bool): True to get the localized display name (the name of the culture in its own language), or False to get the display name in the current language.
        
        Returns:
            str: The display name of the culture, or the given culture code on failure.
        """
        ...
    @classmethod
    def clear_current_asset_group_culture(cls, asset_group: Name, save_to_config: bool = False) -> None:
        r"""
        X.clear_current_asset_group_culture(asset_group, save_to_config=False) -> None
        Clear the given asset group category culture.
        
        Args:
            asset_group (Name): The asset group to clear the culture for.
            save_to_config (bool): If true, save the new setting to the users' "GameUserSettings" config so that it persists after a reload.
        """
        ...

class MaterialLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet Material Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetMaterialLibrary.h
    
    """
    @classmethod
    def set_vector_parameter_value(cls, world_context_object: Object, collection: MaterialParameterCollection, parameter_name: Name, parameter_value: LinearColor) -> None:
        r"""
        X.set_vector_parameter_value(world_context_object, collection, parameter_name, parameter_value) -> None
        Sets a vector parameter value on the material collection instance. Logs if ParameterName is invalid.
        
        Args:
            world_context_object (Object): 
            collection (MaterialParameterCollection): 
            parameter_name (Name): 
            parameter_value (LinearColor):
        """
        ...
    @classmethod
    def set_scalar_parameter_value(cls, world_context_object: Object, collection: MaterialParameterCollection, parameter_name: Name, parameter_value: float) -> None:
        r"""
        X.set_scalar_parameter_value(world_context_object, collection, parameter_name, parameter_value) -> None
        Sets a scalar parameter value on the material collection instance. Logs if ParameterName is invalid.
        
        Args:
            world_context_object (Object): 
            collection (MaterialParameterCollection): 
            parameter_name (Name): 
            parameter_value (float):
        """
        ...
    @classmethod
    def get_vector_parameter_value(cls, world_context_object: Object, collection: MaterialParameterCollection, parameter_name: Name) -> LinearColor:
        r"""
        X.get_vector_parameter_value(world_context_object, collection, parameter_name) -> LinearColor
        Gets a vector parameter value from the material collection instance. Logs if ParameterName is invalid.
        
        Args:
            world_context_object (Object): 
            collection (MaterialParameterCollection): 
            parameter_name (Name): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def get_scalar_parameter_value(cls, world_context_object: Object, collection: MaterialParameterCollection, parameter_name: Name) -> float:
        r"""
        X.get_scalar_parameter_value(world_context_object, collection, parameter_name) -> float
        Gets a scalar parameter value from the material collection instance. Logs if ParameterName is invalid.
        
        Args:
            world_context_object (Object): 
            collection (MaterialParameterCollection): 
            parameter_name (Name): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def create_dynamic_material_instance(cls, world_context_object: Object, parent: MaterialInterface, optional_name: Name = "None", creation_flags: MIDCreationFlags = MIDCreationFlags.NONE) -> MaterialInstanceDynamic:
        r"""
        X.create_dynamic_material_instance(world_context_object, parent, optional_name="None", creation_flags=MIDCreationFlags.NONE) -> MaterialInstanceDynamic
        Creates a Dynamic Material Instance which you can modify during gameplay.
        
        Args:
            world_context_object (Object): 
            parent (MaterialInterface): 
            optional_name (Name): 
            creation_flags (MIDCreationFlags): 
        
        Returns:
            MaterialInstanceDynamic:
        """
        ...
    @classmethod
    def create_material_instance_dynamic(cls, world_context_object: Object, parent: MaterialInterface, optional_name: Name = "None", creation_flags: MIDCreationFlags = MIDCreationFlags.NONE) -> MaterialInstanceDynamic:
        r"""
        deprecated: 'create_material_instance_dynamic' was renamed to 'create_dynamic_material_instance'.
        """
        ...

class MathLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet Math Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetMathLibrary.h
    
    """
    @classmethod
    def xor_int_int(cls, a: int, b: int) -> int:
        r"""
        X.xor_int_int(a, b) -> int32
        Bitwise XOR (A ^ B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def xor_int64_int64(cls, a: int, b: int) -> int:
        r"""
        X.xor_int64_int64(a, b) -> int64
        Bitwise XOR (A ^ B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def wrap(cls, value: int, min: int = 0, max: int = 100) -> int:
        r"""
        X.wrap(value, min=0, max=100) -> int32
        Returns Value between A and B (inclusive) that wraps around
        
        Args:
            value (int32): 
            min (int32): 
            max (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def weighted_moving_average_f_vector(cls, current_sample: Vector, previous_sample: Vector, weight: float) -> Vector:
        r"""
        X.weighted_moving_average_f_vector(current_sample, previous_sample, weight) -> Vector
        Calculates the new value in a weighted moving average series using the previous value and the weight
        
        Args:
            current_sample (Vector): The value to blend with the previous sample to get a new weighted value
            previous_sample (Vector): The last value from the series
            weight (float): The weight to blend with
        
        Returns:
            Vector: the next value in the series
        """
        ...
    @classmethod
    def weighted_moving_average_f_rotator(cls, current_sample: Rotator, previous_sample: Rotator, weight: float) -> Rotator:
        r"""
        X.weighted_moving_average_f_rotator(current_sample, previous_sample, weight) -> Rotator
        Calculates the new value in a weighted moving average series using the previous value and the weight
        
        Args:
            current_sample (Rotator): The value to blend with the previous sample to get a new weighted value
            previous_sample (Rotator): The last value from the series
            weight (float): The weight to blend with
        
        Returns:
            Rotator: the next value in the series
        """
        ...
    @classmethod
    def weighted_moving_average_float(cls, current_sample: float, previous_sample: float, weight: float) -> float:
        r"""
        X.weighted_moving_average_float(current_sample, previous_sample, weight) -> float
        Calculates the new value in a weighted moving average series using the previous value and the weight
        
        Args:
            current_sample (float): The value to blend with the previous sample to get a new weighted value
            previous_sample (float): The last value from the series
            weight (float): The weight to blend with
        
        Returns:
            float: the next value in the series
        """
        ...
    @classmethod
    def v_size_xy_squared(cls, a: Vector) -> float:
        r"""
        X.v_size_xy_squared(a) -> double
        Returns the squared length of the vector's XY components.
        
        Args:
            a (Vector): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def v_size_xy(cls, a: Vector) -> float:
        r"""
        X.v_size_xy(a) -> double
        Returns the length of the vector's XY components.
        
        Args:
            a (Vector): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def v_size_squared(cls, a: Vector) -> float:
        r"""
        X.v_size_squared(a) -> double
        Returns the squared length of the vector
        
        Args:
            a (Vector): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def v_size2d_squared(cls, a: Vector2D) -> float:
        r"""
        X.v_size2d_squared(a) -> double
        Returns the squared length of a 2D Vector.
        
        Args:
            a (Vector2D): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def v_size2d(cls, a: Vector2D) -> float:
        r"""
        X.v_size2d(a) -> double
        Returns the length of a 2D Vector.
        
        Args:
            a (Vector2D): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def v_size(cls, a: Vector) -> float:
        r"""
        X.v_size(a) -> double
        Returns the length of the vector
        
        Args:
            a (Vector): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def v_lerp(cls, a: Vector, b: Vector, alpha: float) -> Vector:
        r"""
        X.v_lerp(a, b, alpha) -> Vector
        Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)
        
        Args:
            a (Vector): 
            b (Vector): 
            alpha (float): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def v_interp_to_constant(cls, current: Vector, target: Vector, delta_time: float, interp_speed: float) -> Vector:
        r"""
        X.v_interp_to_constant(current, target, delta_time, interp_speed) -> Vector
        Tries to reach Target at a constant rate.
        
        Args:
            current (Vector): Actual position
            target (Vector): Target position
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed
        
        Returns:
            Vector: New interpolated position
        """
        ...
    @classmethod
    def v_interp_to(cls, current: Vector, target: Vector, delta_time: float, interp_speed: float) -> Vector:
        r"""
        X.v_interp_to(current, target, delta_time, interp_speed) -> Vector
        Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position.
        
        Args:
            current (Vector): Actual position
            target (Vector): Target position
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed, if the speed given is 0, then jump to the target.
        
        Returns:
            Vector: New interpolated position
        """
        ...
    @classmethod
    def vector_spring_interp(cls, current: Vector, target: Vector, spring_state: VectorSpringState, stiffness: float, critical_damping_factor: float, delta_time: float, mass: float = 1.000000, target_velocity_amount: float = 1.000000, clamp: bool = False, min_value: Vector = [-1.000000, -1.000000, -1.000000], max_value: Vector = [1.000000, 1.000000, 1.000000], initialize_from_target: bool = False) -> Tuple[Vector, VectorSpringState]:
        r"""
        X.vector_spring_interp(current, target, spring_state, stiffness, critical_damping_factor, delta_time, mass=1.000000, target_velocity_amount=1.000000, clamp=False, min_value=[-1.000000, -1.000000, -1.000000], max_value=[1.000000, 1.000000, 1.000000], initialize_from_target=False) -> (Vector, spring_state=VectorSpringState)
        Uses a simple spring model to interpolate a vector from Current to Target.
        
        Args:
            current (Vector): Current value
            target (Vector): Target value
            spring_state (VectorSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
            stiffness (float): How stiff the spring model is (more stiffness means more oscillation around the target value)
            critical_damping_factor (float): How much damping to apply to the spring (0 means no damping, 1 means critically damped which means no oscillation)
            delta_time (float): Time difference since the last update
            mass (float): Multiplier that acts like mass on a spring
            target_velocity_amount (float): If 1 then the target velocity will be calculated and used, which results following the target more closely/without lag. Values down to zero (recommended when using this to smooth data) will progressively disable this effect.
            clamp (bool): Whether to use the Min/Max values to clamp the motion
            min_value (Vector): Clamps the minimum output value and cancels the velocity if it reaches this limit
            max_value (Vector): Clamps the maximum output value and cancels the velocity if it reaches this limit
            initialize_from_target (bool): If set then the current value will be set from the target on the first update
        
        Returns:
            VectorSpringState: 
        
            spring_state (VectorSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
        """
        ...
    @classmethod
    def vector_unwind_euler(cls, a: Vector) -> Vector:
        r"""
        X.vector_unwind_euler(a) -> Vector
        When this vector contains Euler angles (degrees), ensure that angles are between +/-180
        
        Args:
            a (Vector): 
        
        Returns:
            Vector: 
        
            a (Vector):
        """
        ...
    @classmethod
    def vector_unit_cartesian_to_spherical(cls, a: Vector) -> Vector2D:
        r"""
        X.vector_unit_cartesian_to_spherical(a) -> Vector2D
        Converts a Cartesian unit vector into spherical coordinates on the unit sphere.
        
        Args:
            a (Vector): 
        
        Returns:
            Vector2D: Output Theta will be in the range [0, PI], and output Phi will be in the range [-PI, PI].
        """
        ...
    @classmethod
    def vector_to_radians(cls, a: Vector) -> Vector:
        r"""
        X.vector_to_radians(a) -> Vector
        Converts a vector containing degree values to a vector containing radian values.
        
        Args:
            a (Vector): 
        
        Returns:
            Vector: Vector containing radian values
        """
        ...
    @classmethod
    def vector_to_degrees(cls, a: Vector) -> Vector:
        r"""
        X.vector_to_degrees(a) -> Vector
        Converts a vector containing radian values to a vector containing degree values.
        
        Args:
            a (Vector): 
        
        Returns:
            Vector: Vector  containing degree values
        """
        ...
    @classmethod
    def vector_snapped_to_grid(cls, vect: Vector, grid_size: float) -> Vector:
        r"""
        X.vector_snapped_to_grid(vect, grid_size) -> Vector
        Gets a copy of this vector snapped to a grid.
        
        Args:
            vect (Vector): 
            grid_size (float): Grid dimension / step.
        
        Returns:
            Vector: A copy of this vector snapped to a grid.
        """
        ...
    @classmethod
    def vector_slerp_vector_to_direction(cls, vector: Vector, direction: Vector, alpha: float) -> Vector:
        r"""
        X.vector_slerp_vector_to_direction(vector, direction, alpha) -> Vector
        Interpolate from a vector to the direction of another vector along a spherical path.
        
        Args:
            vector (Vector): Vector we interpolate from
            direction (Vector): Target direction we interpolate to
            alpha (double): interpolation amount, usually between 0-1
        
        Returns:
            Vector: Vector after interpolating between Vector and Direction along a spherical path. The magnitude will remain the length of the starting vector.
        """
        ...
    @classmethod
    def vector_slerp_normals(cls, normal_a: Vector, normal_b: Vector, alpha: float) -> Vector:
        r"""
        X.vector_slerp_normals(normal_a, normal_b, alpha) -> Vector
        Interpolate from normalized vector A to normalized vector B along a spherical path.
        
        Args:
            normal_a (Vector): Start direction of interpolation, must be normalized.
            normal_b (Vector): End target direction of interpolation, must be normalized.
            alpha (double): interpolation amount, usually between 0-1
        
        Returns:
            Vector: Vector after interpolating between A and B along a spherical path.
        """
        ...
    @classmethod
    def vector_set(cls, a: Vector, x: float, y: float, z: float) -> Vector:
        r"""
        X.vector_set(a, x, y, z) -> Vector
        Set the values of the vector directly.
        
        Args:
            a (Vector): 
            x (double): 
            y (double): 
            z (double): 
        
        Returns:
            Vector: 
        
            a (Vector):
        """
        ...
    @classmethod
    def vector_reciprocal(cls, a: Vector) -> Vector:
        r"""
        X.vector_reciprocal(a) -> Vector
        Gets the reciprocal of this vector, avoiding division by zero.
        Zero components are set to BIG_NUMBER.
        
        Args:
            a (Vector): 
        
        Returns:
            Vector: Reciprocal of this vector.
        """
        ...
    @classmethod
    def vector_project_on_to_normal(cls, v: Vector, normal: Vector) -> Vector:
        r"""
        X.vector_project_on_to_normal(v, normal) -> Vector
        Gets a copy of this vector projected onto the input vector, which is assumed to be unit length.
        
        Args:
            v (Vector): 
            normal (Vector): Vector to project onto (assumed to be unit length).
        
        Returns:
            Vector: Projected vector.
        """
        ...
    @classmethod
    def vector_normal_unsafe(cls, a: Vector) -> Vector:
        r"""
        X.vector_normal_unsafe(a) -> Vector
        Calculates normalized unit version of vector without checking for zero length.
        
        Args:
            a (Vector): 
        
        Returns:
            Vector: Normalized version of vector.
        """
        ...
    @classmethod
    def vector_normalize(cls, a: Vector, tolerance: float = 0.000000) -> Vector:
        r"""
        X.vector_normalize(a, tolerance=0.000000) -> Vector
        Normalize this vector in-place if it is large enough or set it to (0,0,0) otherwise.
        
        Args:
            a (Vector): 
            tolerance (float): Minimum squared length of vector for normalization.
        
        Returns:
            Vector: 
        
            a (Vector):
        """
        ...
    @classmethod
    def vector_normal2d(cls, a: Vector, tolerance: float = 0.000100) -> Vector:
        r"""
        X.vector_normal2d(a, tolerance=0.000100) -> Vector
        Gets a normalized unit copy of the 2D components of the vector, ensuring it is safe to do so. Z is set to zero.
        Returns zero vector if vector length is too small to normalize.
        
        Args:
            a (Vector): 
            tolerance (float): Minimum squared vector length.
        
        Returns:
            Vector: Normalized copy if safe, (0,0,0) otherwise.
        """
        ...
    @classmethod
    def vector_mirror_by_plane(cls, a: Vector, plane: Plane) -> Vector:
        r"""
        X.vector_mirror_by_plane(a, plane) -> Vector
        Mirrors a vector about a plane.
        
        Args:
            a (Vector): 
            plane (Plane): 
        
        Returns:
            Vector: Mirrored vector.
        """
        ...
    @classmethod
    def vector_is_zero(cls, a: Vector) -> bool:
        r"""
        X.vector_is_zero(a) -> bool
        Checks whether all components of the vector are exactly zero.
        
        Args:
            a (Vector): 
        
        Returns:
            bool: true if vector is exactly zero, otherwise false.
        """
        ...
    @classmethod
    def vector_is_unit(cls, a: Vector, squared_lenth_tolerance: float = 0.000100) -> bool:
        r"""
        X.vector_is_unit(a, squared_lenth_tolerance=0.000100) -> bool
        Determines if vector is normalized / unit (length 1) within specified squared tolerance.
        
        Args:
            a (Vector): 
            squared_lenth_tolerance (float): 
        
        Returns:
            bool: true if unit, false otherwise.
        """
        ...
    @classmethod
    def vector_is_uniform(cls, a: Vector, tolerance: float = 0.000100) -> bool:
        r"""
        X.vector_is_uniform(a, tolerance=0.000100) -> bool
        Checks whether all components of this vector are the same, within a tolerance.
        
        Args:
            a (Vector): 
            tolerance (float): Error tolerance.
        
        Returns:
            bool: true if the vectors are equal within tolerance limits, false otherwise.
        """
        ...
    @classmethod
    def vector_is_normal(cls, a: Vector) -> bool:
        r"""
        X.vector_is_normal(a) -> bool
        Determines if vector is normalized / unit (length 1).
        
        Args:
            a (Vector): 
        
        Returns:
            bool: true if normalized, false otherwise.
        """
        ...
    @classmethod
    def vector_is_nearly_zero(cls, a: Vector, tolerance: float = 0.000100) -> bool:
        r"""
        X.vector_is_nearly_zero(a, tolerance=0.000100) -> bool
        Checks whether vector is near to zero within a specified tolerance.
        
        Args:
            a (Vector): 
            tolerance (float): Error tolerance.
        
        Returns:
            bool: true if vector is in tolerance to zero, otherwise false.
        """
        ...
    @classmethod
    def vector_is_nan(cls, a: Vector) -> bool:
        r"""
        X.vector_is_nan(a) -> bool
        Determines if any component is not a number (NAN)
        
        Args:
            a (Vector): 
        
        Returns:
            bool: true if one or more components is NAN, otherwise false.
        """
        ...
    @classmethod
    def vector_heading_angle(cls, a: Vector) -> float:
        r"""
        X.vector_heading_angle(a) -> double
        Convert a direction vector into a 'heading' angle.
        
        Args:
            a (Vector): 
        
        Returns:
            double: 'Heading' angle between +/-PI radians. 0 is pointing down +X.
        """
        ...
    @classmethod
    def vector_get_sign_vector(cls, a: Vector) -> Vector:
        r"""
        X.vector_get_sign_vector(a) -> Vector
        Get a copy of the vector as sign only.
        Each component is set to +1 or -1, with the sign of zero treated as +1.
        
        Args:
            a (Vector): copy of the vector with each component set to +1 or -1
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def vector_get_projection(cls, a: Vector) -> Vector:
        r"""
        X.vector_get_projection(a) -> Vector
        Projects 2D components of vector based on Z.
        
        Args:
            a (Vector): 
        
        Returns:
            Vector: Projected version of vector based on Z.
        """
        ...
    @classmethod
    def vector_get_abs_min(cls, a: Vector) -> float:
        r"""
        X.vector_get_abs_min(a) -> double
        Find the minimum absolute element (abs(X), abs(Y) or abs(Z)) of a vector
        
        Args:
            a (Vector): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def vector_get_abs_max(cls, a: Vector) -> float:
        r"""
        X.vector_get_abs_max(a) -> double
        Find the maximum absolute element (abs(X), abs(Y) or abs(Z)) of a vector
        
        Args:
            a (Vector): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def vector_get_abs(cls, a: Vector) -> Vector:
        r"""
        X.vector_get_abs(a) -> Vector
        Get a copy of this vector with absolute value of each component.
        
        Args:
            a (Vector): 
        
        Returns:
            Vector: A copy of this vector with absolute value of each component.
        """
        ...
    @classmethod
    def vector_distance_squared(cls, v1: Vector, v2: Vector) -> float:
        r"""
        X.vector_distance_squared(v1, v2) -> double
        Squared distance between two points.
        
        Args:
            v1 (Vector): The first point.
            v2 (Vector): The second point.
        
        Returns:
            double: The squared distance between two points.
        """
        ...
    @classmethod
    def vector_distance2d_squared(cls, v1: Vector, v2: Vector) -> float:
        r"""
        X.vector_distance2d_squared(v1, v2) -> double
        Squared euclidean distance between two points in the XY plane (ignoring Z).
        
        Args:
            v1 (Vector): The first point.
            v2 (Vector): The second point.
        
        Returns:
            double: The distance between two points in the XY plane.
        """
        ...
    @classmethod
    def vector_distance2d(cls, v1: Vector, v2: Vector) -> float:
        r"""
        X.vector_distance2d(v1, v2) -> double
        Euclidean distance between two points in the XY plane (ignoring Z).
        
        Args:
            v1 (Vector): The first point.
            v2 (Vector): The second point.
        
        Returns:
            double: The distance between two points in the XY plane.
        """
        ...
    @classmethod
    def vector_distance(cls, v1: Vector, v2: Vector) -> float:
        r"""
        X.vector_distance(v1, v2) -> double
        Distance between two points.
        
        Args:
            v1 (Vector): The first point.
            v2 (Vector): The second point.
        
        Returns:
            double: The distance between two points.
        """
        ...
    @classmethod
    def vector_cosine_angle2d(cls, a: Vector, b: Vector) -> float:
        r"""
        X.vector_cosine_angle2d(a, b) -> double
        Returns the cosine of the angle between this vector and another projected onto the XY plane (no Z).
        
        Args:
            a (Vector): 
            b (Vector): the other vector to find the 2D cosine of the angle with.
        
        Returns:
            double: The cosine.
        """
        ...
    @classmethod
    def vector_component_min(cls, a: Vector, b: Vector) -> Vector:
        r"""
        X.vector_component_min(a, b) -> Vector
        Find the minimum elements (X, Y and Z) between the two vector's components
        
        Args:
            a (Vector): 
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def vector_component_max(cls, a: Vector, b: Vector) -> Vector:
        r"""
        X.vector_component_max(a, b) -> Vector
        Find the maximum elements (X, Y and Z) between the two vector's components
        
        Args:
            a (Vector): 
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def vector_clamp_size_max2d(cls, a: Vector, max: float) -> Vector:
        r"""
        X.vector_clamp_size_max2d(a, max) -> Vector
        Create a copy of this vector, with the maximum 2D magnitude/size/length clamped to MaxSize. Z is unchanged.
        
        Args:
            a (Vector): 
            max (double): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def vector_clamp_size_max(cls, a: Vector, max: float) -> Vector:
        r"""
        X.vector_clamp_size_max(a, max) -> Vector
        Create a copy of this vector, with its maximum magnitude/size/length clamped to MaxSize.
        
        Args:
            a (Vector): 
            max (double): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def vector_clamp_size2d(cls, a: Vector, min: float, max: float) -> Vector:
        r"""
        X.vector_clamp_size2d(a, min, max) -> Vector
        Create a copy of this vector, with the 2D magnitude/size/length clamped between Min and Max. Z is unchanged.
        
        Args:
            a (Vector): 
            min (double): 
            max (double): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def vector_bounded_to_cube(cls, vect: Vector, radius: float) -> Vector:
        r"""
        X.vector_bounded_to_cube(vect, radius) -> Vector
        Get a copy of this vector, clamped inside of an axis aligned cube centered at the origin.
        
        Args:
            vect (Vector): 
            radius (float): Half size of the cube (or radius of sphere circumscribed in the cube).
        
        Returns:
            Vector: A copy of this vector, bound by cube.
        """
        ...
    @classmethod
    def vector_bounded_to_box(cls, vect: Vector, box_min: Vector, box_max: Vector) -> Vector:
        r"""
        X.vector_bounded_to_box(vect, box_min, box_max) -> Vector
        Get a copy of this vector, clamped inside of the specified axis aligned cube.
        
        Args:
            vect (Vector): 
            box_min (Vector): 
            box_max (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def vector_assign(cls, a: Vector, vector: Vector) -> Vector:
        r"""
        X.vector_assign(a, vector) -> Vector
        Assign the values of the supplied vector.
        
        Args:
            a (Vector): 
            vector (Vector): Vector to copy values from.
        
        Returns:
            Vector: 
        
            a (Vector):
        """
        ...
    @classmethod
    def vector_add_bounded(cls, a: Vector, add_vect: Vector, radius: float) -> Vector:
        r"""
        X.vector_add_bounded(a, add_vect, radius) -> Vector
        Add a vector to this and clamp the result to an axis aligned cube centered at the origin.
        
        Args:
            a (Vector): 
            add_vect (Vector): Vector to add.
            radius (float): Half size of the cube.
        
        Returns:
            Vector: 
        
            a (Vector):
        """
        ...
    @classmethod
    def vector4_size_squared3(cls, a: Vector4) -> float:
        r"""
        X.vector4_size_squared3(a) -> double
        Returns the squared length of the vector. The W element is ignored.
        
        Args:
            a (Vector4): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def vector4_size_squared(cls, a: Vector4) -> float:
        r"""
        X.vector4_size_squared(a) -> double
        Returns the squared length of the vector.
        
        Args:
            a (Vector4): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def vector4_size3(cls, a: Vector4) -> float:
        r"""
        X.vector4_size3(a) -> double
        Returns the length of the vector. The W element is ignored.
        
        Args:
            a (Vector4): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def vector4_size(cls, a: Vector4) -> float:
        r"""
        X.vector4_size(a) -> double
        Returns the length of the vector.
        
        Args:
            a (Vector4): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def vector4_set(cls, a: Vector4, x: float, y: float, z: float, w: float) -> Vector4:
        r"""
        X.vector4_set(a, x, y, z, w) -> Vector4
        Set the values of the vector directly.
        
        Args:
            a (Vector4): 
            x (double): 
            y (double): 
            z (double): 
            w (double): 
        
        Returns:
            Vector4: 
        
            a (Vector4):
        """
        ...
    @classmethod
    def vector4_normal_unsafe3(cls, a: Vector4) -> Vector4:
        r"""
        X.vector4_normal_unsafe3(a) -> Vector4
        Calculates normalized unit version of vector without checking for zero length. The W element is ignored and the returned vector has W=0.
        
        Args:
            a (Vector4): 
        
        Returns:
            Vector4: Normalized version of vector.
        """
        ...
    @classmethod
    def vector4_normalize3(cls, a: Vector4, tolerance: float = 0.000000) -> Vector4:
        r"""
        X.vector4_normalize3(a, tolerance=0.000000) -> Vector4
        Normalize this vector in-place if it is large enough or set it to (0,0,0,0) otherwise. The W element is ignored and the returned vector has W=0.
        
        Args:
            a (Vector4): 
            tolerance (float): Minimum squared length of vector for normalization.
        
        Returns:
            Vector4: 
        
            a (Vector4):
        """
        ...
    @classmethod
    def vector4_normal3(cls, a: Vector4, tolerance: float = 0.000100) -> Vector4:
        r"""
        X.vector4_normal3(a, tolerance=0.000100) -> Vector4
        Gets a normalized unit copy of the vector, ensuring it is safe to do so based on the length. The W element is ignored and the returned vector has W=0.
        Returns zero vector if vector length is too small to safely normalize.
        
        Args:
            a (Vector4): 
            tolerance (float): Minimum squared vector length.
        
        Returns:
            Vector4: A normalized copy if safe, (0,0,0) otherwise.
        """
        ...
    @classmethod
    def vector4_negated(cls, a: Vector4) -> Vector4:
        r"""
        X.vector4_negated(a) -> Vector4
        Gets a negated copy of the vector. Equivalent to -Vector for scripts.
        
        Args:
            a (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    @classmethod
    def vector4_mirror_by_vector3(cls, direction: Vector4, surface_normal: Vector4) -> Vector4:
        r"""
        X.vector4_mirror_by_vector3(direction, surface_normal) -> Vector4
        Given a direction vector and a surface normal, returns the vector reflected across the surface normal.
        Produces a result like shining a laser at a mirror!
        The W element is ignored.
        
        Args:
            direction (Vector4): Direction vector the ray is coming from.
            surface_normal (Vector4): A normal of the surface the ray should be reflected on.
        
        Returns:
            Vector4: Reflected vector.
        """
        ...
    @classmethod
    def vector4_is_zero(cls, a: Vector4) -> bool:
        r"""
        X.vector4_is_zero(a) -> bool
        Checks whether all components of the vector are exactly zero.
        
        Args:
            a (Vector4): 
        
        Returns:
            bool: true if vector is exactly zero, otherwise false.
        """
        ...
    @classmethod
    def vector4_is_unit3(cls, a: Vector4, squared_lenth_tolerance: float = 0.000100) -> bool:
        r"""
        X.vector4_is_unit3(a, squared_lenth_tolerance=0.000100) -> bool
        Determines if vector is normalized / unit (length 1) within specified squared tolerance. The W element is ignored.
        
        Args:
            a (Vector4): 
            squared_lenth_tolerance (float): 
        
        Returns:
            bool: true if unit, false otherwise.
        """
        ...
    @classmethod
    def vector4_is_normal3(cls, a: Vector4) -> bool:
        r"""
        X.vector4_is_normal3(a) -> bool
        Determines if vector is normalized / unit (length 1). The W element is ignored.
        
        Args:
            a (Vector4): 
        
        Returns:
            bool: true if normalized, false otherwise.
        """
        ...
    @classmethod
    def vector4_is_nearly_zero3(cls, a: Vector4, tolerance: float = 0.000100) -> bool:
        r"""
        X.vector4_is_nearly_zero3(a, tolerance=0.000100) -> bool
        Checks whether vector is near to zero within a specified tolerance. The W element is ignored.
        
        Args:
            a (Vector4): 
            tolerance (float): Error tolerance.
        
        Returns:
            bool: true if vector is in tolerance to zero, otherwise false.
        """
        ...
    @classmethod
    def vector4_is_nan(cls, a: Vector4) -> bool:
        r"""
        X.vector4_is_nan(a) -> bool
        Determines if any component is not a number (NAN)
        
        Args:
            a (Vector4): 
        
        Returns:
            bool: true if one or more components is NAN, otherwise false.
        """
        ...
    @classmethod
    def vector4_dot_product3(cls, a: Vector4, b: Vector4) -> float:
        r"""
        X.vector4_dot_product3(a, b) -> double
        Returns the dot product of two vectors - see http://mathworld.wolfram.com/DotProduct.html The W element is ignored.
        
        Args:
            a (Vector4): 
            b (Vector4): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def vector4_dot_product(cls, a: Vector4, b: Vector4) -> float:
        r"""
        X.vector4_dot_product(a, b) -> double
        Returns the dot product of two vectors - see http://mathworld.wolfram.com/DotProduct.html
        
        Args:
            a (Vector4): 
            b (Vector4): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def vector4_cross_product3(cls, a: Vector4, b: Vector4) -> Vector4:
        r"""
        X.vector4_cross_product3(a, b) -> Vector4
        Returns the cross product of two vectors - see  http://mathworld.wolfram.com/CrossProduct.html
        
        Args:
            a (Vector4): 
            b (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    @classmethod
    def vector4_assign(cls, a: Vector4, vector: Vector4) -> Vector4:
        r"""
        X.vector4_assign(a, vector) -> Vector4
        Assign the values of the supplied vector.
        
        Args:
            a (Vector4): 
            vector (Vector4): Vector to copy values from.
        
        Returns:
            Vector4: 
        
            a (Vector4):
        """
        ...
    @classmethod
    def vector2d_interp_to_constant(cls, current: Vector2D, target: Vector2D, delta_time: float, interp_speed: float) -> Vector2D:
        r"""
        X.vector2d_interp_to_constant(current, target, delta_time, interp_speed) -> Vector2D
        Tries to reach Target at a constant rate.
        
        Args:
            current (Vector2D): Actual position
            target (Vector2D): Target position
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed
        
        Returns:
            Vector2D: New interpolated position
        """
        ...
    @classmethod
    def vector2d_interp_to(cls, current: Vector2D, target: Vector2D, delta_time: float, interp_speed: float) -> Vector2D:
        r"""
        X.vector2d_interp_to(current, target, delta_time, interp_speed) -> Vector2D
        Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position.
        
        Args:
            current (Vector2D): Actual position
            target (Vector2D): Target position
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed, if the speed given is 0, then jump to the target.
        
        Returns:
            Vector2D: New interpolated position
        """
        ...
    @classmethod
    def utc_now(cls) -> DateTime:
        r"""
        X.utc_now() -> DateTime
        Returns the UTC date and time on this computer
        
        Returns:
            DateTime:
        """
        ...
    @classmethod
    def transform_vector4(cls, matrix: Matrix, vec4: Vector4) -> Vector4:
        r"""
        X.transform_vector4(matrix, vec4) -> Vector4
        Transform the input vector4 by a provided matrix4x4 and returns the resulting vector4.
        
        Args:
            matrix (Matrix): 
            vec4 (Vector4): 
        
        Returns:
            Vector4: Transformed vector4.
        """
        ...
    @classmethod
    def transform_rotation(cls, t: Transform, rotation: Rotator) -> Rotator:
        r"""
        X.transform_rotation(t, rotation) -> Rotator
        Transform a rotator by the supplied transform.
        For example, if T was an object's transform, this would transform a rotation from local space to world space.
        
        Args:
            t (Transform): 
            rotation (Rotator): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def transform_location(cls, t: Transform, location: Vector) -> Vector:
        r"""
        X.transform_location(t, location) -> Vector
        Transform a position by the supplied transform.
        For example, if T was an object's transform, this would transform a position from local space to world space.
        
        Args:
            t (Transform): 
            location (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def transform_position(cls, t: Transform, location: Vector) -> Vector:
        r"""
        deprecated: 'transform_position' was renamed to 'transform_location'.
        """
        ...
    @classmethod
    def transform_direction(cls, t: Transform, direction: Vector) -> Vector:
        r"""
        X.transform_direction(t, direction) -> Vector
        Transform a direction vector by the supplied transform - will not change its length.
        For example, if T was an object's transform, this would transform a direction from local space to world space.
        
        Args:
            t (Transform): 
            direction (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def transform_determinant(cls, transform: Transform) -> float:
        r"""
        X.transform_determinant(transform) -> float
        Calculates the determinant of the transform (converts to FMatrix internally)
        
        Args:
            transform (Transform): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def to_unix_timestamp_double(cls, time: DateTime) -> float:
        r"""
        X.to_unix_timestamp_double(time) -> double
        Returns this date as the number of seconds since the Unix Epoch (January 1st of 1970).
        see: FromUnixTimestamp
        
        Args:
            time (DateTime): 
        
        Returns:
            double: Time of day.
        """
        ...
    @classmethod
    def to_unix_timestamp(cls, time: DateTime) -> int:
        r"""
        X.to_unix_timestamp(time) -> int64
        Returns this date as the number of seconds since the Unix Epoch (January 1st of 1970).
        see: FromUnixTimestamp
        
        Args:
            time (DateTime): 
        
        Returns:
            int64: Time of day.
        """
        ...
    @classmethod
    def to_sign2d(cls, a: Vector2D) -> Vector2D:
        r"""
        X.to_sign2d(a) -> Vector2D
        Get a copy of the vector as sign only.
        Each component is set to +1 or -1, with the sign of zero treated as +1.
        
        Args:
            a (Vector2D): 
        
        Returns:
            Vector2D: A copy of the vector with each component set to +1 or -1
        """
        ...
    @classmethod
    def to_rounded2d(cls, a: Vector2D) -> Vector2D:
        r"""
        X.to_rounded2d(a) -> Vector2D
        Get this vector as a vector where each component has been rounded to the nearest int.
        
        Args:
            a (Vector2D): 
        
        Returns:
            Vector2D: New FVector2D from this vector that is rounded.
        """
        ...
    @classmethod
    def to_hex_linear_color(cls, color: LinearColor) -> str:
        r"""
        X.to_hex_linear_color(color) -> str
        Converts this color value to a hexadecimal string. The format of the string is RRGGBBAA.
        
        Args:
            color (LinearColor): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def to_direction_and_length2d(cls, a: Vector2D) -> Tuple[Vector2D, float]:
        r"""
        X.to_direction_and_length2d(a) -> (out_dir=Vector2D, out_length=double)
        Util to convert this vector into a unit direction vector and its original length.
        
        Args:
            a (Vector2D): 
        
        Returns:
            tuple: 
        
            out_dir (Vector2D): Reference passed in to store unit direction vector.
        
            out_length (double): Reference passed in to store length of the vector.
        """
        ...
    @classmethod
    def today(cls) -> DateTime:
        r"""
        X.today() -> DateTime
        Returns the local date on this computer
        
        Returns:
            DateTime:
        """
        ...
    @classmethod
    def t_lerp(cls, a: Transform, b: Transform, alpha: float, interp_mode: LerpInterpolationMode = LerpInterpolationMode.QUAT_INTERP) -> Transform:
        r"""
        X.t_lerp(a, b, alpha, interp_mode=LerpInterpolationMode.QUAT_INTERP) -> Transform
        Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1).
        
        Args:
            a (Transform): 
            b (Transform): 
            alpha (float): 
            interp_mode (LerpInterpolationMode): 
        
        Returns:
            Transform:
        """
        ...
    @classmethod
    def t_interp_to(cls, current: Transform, target: Transform, delta_time: float, interp_speed: float) -> Transform:
        r"""
        X.t_interp_to(current, target, delta_time, interp_speed) -> Transform
        Tries to reach Target transform based on distance from Current position, giving a nice smooth feeling when tracking a position.
        
        Args:
            current (Transform): Actual transform
            target (Transform): Target transform
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed, if the speed given is 0, then jump to the target.
        
        Returns:
            Transform: New interpolated transform
        """
        ...
    @classmethod
    def timespan_ratio(cls, a: Timespan, b: Timespan) -> float:
        r"""
        X.timespan_ratio(a, b) -> float
        Returns the ratio between two time spans (A / B), handles zero values
        
        Args:
            a (Timespan): 
            b (Timespan): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def timespan_from_string(cls, timespan_string: str) -> Optional[Timespan]:
        r"""
        X.timespan_from_string(timespan_string) -> Timespan or None
        Converts a time span string to a Timespan object
        
        Args:
            timespan_string (str): 
        
        Returns:
            Timespan or None: 
        
            result (Timespan):
        """
        ...
    @classmethod
    def tan(cls, a: float) -> float:
        r"""
        X.tan(a) -> double
        Returns the tan of A (expects Radians)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def subtract_vector_vector(cls, a: Vector, b: Vector) -> Vector:
        r"""
        X.subtract_vector_vector(a, b) -> Vector
        Vector subtraction
        
        Args:
            a (Vector): 
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def subtract_vector_int(cls, a: Vector, b: int) -> Vector:
        r"""
        X.subtract_vector_int(a, b) -> Vector
        Subtracts an integer from each component of a vector
        
        Args:
            a (Vector): 
            b (int32): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def subtract_vector_float(cls, a: Vector, b: float) -> Vector:
        r"""
        X.subtract_vector_float(a, b) -> Vector
        Subtracts a float from each component of a vector
        
        Args:
            a (Vector): 
            b (double): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def subtract_vector4_vector4(cls, a: Vector4, b: Vector4) -> Vector4:
        r"""
        X.subtract_vector4_vector4(a, b) -> Vector4
        Returns subtraction of Vector B from Vector A (A - B)
        
        Args:
            a (Vector4): 
            b (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    @classmethod
    def subtract_vector2d_vector2d(cls, a: Vector2D, b: Vector2D) -> Vector2D:
        r"""
        X.subtract_vector2d_vector2d(a, b) -> Vector2D
        Returns subtraction of Vector B from Vector A (A - B)
        
        Args:
            a (Vector2D): 
            b (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def subtract_vector2d_float(cls, a: Vector2D, b: float) -> Vector2D:
        r"""
        X.subtract_vector2d_float(a, b) -> Vector2D
        Returns Vector A subtracted by B
        
        Args:
            a (Vector2D): 
            b (double): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def subtract_timespan_timespan(cls, a: Timespan, b: Timespan) -> Timespan:
        r"""
        X.subtract_timespan_timespan(a, b) -> Timespan
        Subtraction (A - B)
        
        Args:
            a (Timespan): 
            b (Timespan): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def subtract_quat_quat(cls, a: Quat, b: Quat) -> Quat:
        r"""
        X.subtract_quat_quat(a, b) -> Quat
        Returns subtraction of Vector B from Vector A (A - B)
        
        Args:
            a (Quat): 
            b (Quat): 
        
        Returns:
            Quat:
        """
        ...
    @classmethod
    def subtract_linear_color_linear_color(cls, a: LinearColor, b: LinearColor) -> LinearColor:
        r"""
        X.subtract_linear_color_linear_color(a, b) -> LinearColor
        Element-wise subtraction of two linear colors (R-R, G-G, B-B, A-A)
        
        Args:
            a (LinearColor): 
            b (LinearColor): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def subtract_int_point_int_point(cls, a: IntPoint, b: IntPoint) -> IntPoint:
        r"""
        X.subtract_int_point_int_point(a, b) -> IntPoint
        Returns IntPoint A subtracted by B
        
        Args:
            a (IntPoint): 
            b (IntPoint): 
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def subtract_int_point_int(cls, a: IntPoint, b: int) -> IntPoint:
        r"""
        X.subtract_int_point_int(a, b) -> IntPoint
        Subtraction (A - B)
        
        Args:
            a (IntPoint): 
            b (int32): 
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def subtract_int_int(cls, a: int, b: int = 1) -> int:
        r"""
        X.subtract_int_int(a, b=1) -> int32
        Subtraction (A - B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def subtract_int64_int64(cls, a: int, b: int = 1) -> int:
        r"""
        X.subtract_int64_int64(a, b=1) -> int64
        Subtraction (A - B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def subtract_double_double(cls, a: float, b: float = 1.000000) -> float:
        r"""
        X.subtract_double_double(a, b=1.000000) -> double
        Subtraction (A - B)
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def subtract_float_float(cls, a: float, b: float = 1.000000) -> float:
        r"""
        deprecated: 'subtract_float_float' was renamed to 'subtract_double_double'.
        """
        ...
    @classmethod
    def subtract_date_time_timespan(cls, a: DateTime, b: Timespan) -> DateTime:
        r"""
        X.subtract_date_time_timespan(a, b) -> DateTime
        Subtraction (A - B)
        
        Args:
            a (DateTime): 
            b (Timespan): 
        
        Returns:
            DateTime:
        """
        ...
    @classmethod
    def subtract_date_time_date_time(cls, a: DateTime, b: DateTime) -> Timespan:
        r"""
        X.subtract_date_time_date_time(a, b) -> Timespan
        Subtraction (A - B)
        
        Args:
            a (DateTime): 
            b (DateTime): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def subtract_byte_byte(cls, a: int, b: int = 1) -> int:
        r"""
        X.subtract_byte_byte(a, b=1) -> uint8
        Subtraction (A - B)
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            uint8:
        """
        ...
    @classmethod
    def square(cls, a: float) -> float:
        r"""
        X.square(a) -> double
        Returns square of A (A*A)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def sqrt(cls, a: float) -> float:
        r"""
        X.sqrt(a) -> double
        Returns square root of A
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def spherical2d_to_unit_cartesian(cls, a: Vector2D) -> Vector:
        r"""
        X.spherical2d_to_unit_cartesian(a) -> Vector
        Converts spherical coordinates on the unit sphere into a Cartesian unit length vector.
        
        Args:
            a (Vector2D): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def sin(cls, a: float) -> float:
        r"""
        X.sin(a) -> double
        Returns the sine of A (expects Radians)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def sign_of_integer64(cls, a: int) -> int:
        r"""
        X.sign_of_integer64(a) -> int64
        Sign (integer64, returns -1 if A < 0, 0 if A is zero, and +1 if A > 0)
        
        Args:
            a (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def sign_of_integer(cls, a: int) -> int:
        r"""
        X.sign_of_integer(a) -> int32
        Sign (integer, returns -1 if A < 0, 0 if A is zero, and +1 if A > 0)
        
        Args:
            a (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def sign_of_float(cls, a: float) -> float:
        r"""
        X.sign_of_float(a) -> double
        Sign (float, returns -1 if A < 0, 0 if A is zero, and +1 if A > 0)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def set_vector_spring_state_velocity(cls, spring_state: VectorSpringState, velocity: Vector) -> VectorSpringState:
        r"""
        X.set_vector_spring_state_velocity(spring_state, velocity) -> VectorSpringState
        Sets the state velocity of a vector spring
        
        Args:
            spring_state (VectorSpringState): 
            velocity (Vector): 
        
        Returns:
            VectorSpringState: 
        
            spring_state (VectorSpringState):
        """
        ...
    @classmethod
    def set_random_stream_seed(cls, stream: RandomStream, new_seed: int) -> RandomStream:
        r"""
        X.set_random_stream_seed(stream, new_seed) -> RandomStream
        Set the seed of a random stream to a specific number
        
        Args:
            stream (RandomStream): 
            new_seed (int32): 
        
        Returns:
            RandomStream: 
        
            stream (RandomStream):
        """
        ...
    @classmethod
    def set_quaternion_spring_state_angular_velocity(cls, spring_state: QuaternionSpringState, angular_velocity: Vector) -> QuaternionSpringState:
        r"""
        X.set_quaternion_spring_state_angular_velocity(spring_state, angular_velocity) -> QuaternionSpringState
        Sets the state angular velocity of a quaternion spring
        
        Args:
            spring_state (QuaternionSpringState): 
            angular_velocity (Vector): 
        
        Returns:
            QuaternionSpringState: 
        
            spring_state (QuaternionSpringState):
        """
        ...
    @classmethod
    def set_float_spring_state_velocity(cls, spring_state: FloatSpringState, velocity: float) -> FloatSpringState:
        r"""
        X.set_float_spring_state_velocity(spring_state, velocity) -> FloatSpringState
        Sets the state velocity of a float spring
        
        Args:
            spring_state (FloatSpringState): 
            velocity (float): 
        
        Returns:
            FloatSpringState: 
        
            spring_state (FloatSpringState):
        """
        ...
    @classmethod
    def set2d(cls, a: Vector2D, x: float, y: float) -> Vector2D:
        r"""
        X.set2d(a, x, y) -> Vector2D
        Set the values of the vector directly.
        
        Args:
            a (Vector2D): 
            x (double): 
            y (double): 
        
        Returns:
            Vector2D: 
        
            a (Vector2D):
        """
        ...
    @classmethod
    def select_vector(cls, a: Vector, b: Vector, pick_a: bool) -> Vector:
        r"""
        X.select_vector(a, b, pick_a) -> Vector
        If bPickA is true, A is returned, otherwise B is
        
        Args:
            a (Vector): 
            b (Vector): 
            pick_a (bool): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def select_transform(cls, a: Transform, b: Transform, pick_a: bool) -> Transform:
        r"""
        X.select_transform(a, b, pick_a) -> Transform
        If bPickA is true, A is returned, otherwise B is
        
        Args:
            a (Transform): 
            b (Transform): 
            pick_a (bool): 
        
        Returns:
            Transform:
        """
        ...
    @classmethod
    def select_text(cls, a: Text, b: Text, pick_a: bool) -> Text:
        r"""
        X.select_text(a, b, pick_a) -> Text
        If bPickA is true, A is returned, otherwise B is
        
        Args:
            a (Text): 
            b (Text): 
            pick_a (bool): 
        
        Returns:
            Text:
        """
        ...
    @classmethod
    def select_string(cls, a: str, b: str, pick_a: bool) -> str:
        r"""
        X.select_string(a, b, pick_a) -> str
        If bPickA is true, A is returned, otherwise B is
        
        Args:
            a (str): 
            b (str): 
            pick_a (bool): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def select_rotator(cls, a: Rotator, b: Rotator, pick_a: bool) -> Rotator:
        r"""
        X.select_rotator(a, b, pick_a) -> Rotator
        If bPickA is true, A is returned, otherwise B is
        
        Args:
            a (Rotator): 
            b (Rotator): 
            pick_a (bool): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def select_object(cls, a: Object, b: Object, select_a: bool) -> Object:
        r"""
        X.select_object(a, b, select_a) -> Object
        If bPickA is true, A is returned, otherwise B is
        
        Args:
            a (Object): 
            b (Object): 
            select_a (bool): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def select_name(cls, a: Name, b: Name, pick_a: bool) -> Name:
        r"""
        X.select_name(a, b, pick_a) -> Name
        If bPickA is true, A is returned, otherwise B is
        
        Args:
            a (Name): 
            b (Name): 
            pick_a (bool): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def select_int(cls, a: int, b: int, pick_a: bool) -> int:
        r"""
        X.select_int(a, b, pick_a) -> int32
        If bPickA is true, A is returned, otherwise B is
        
        Args:
            a (int32): 
            b (int32): 
            pick_a (bool): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def select_float(cls, a: float, b: float, pick_a: bool) -> float:
        r"""
        X.select_float(a, b, pick_a) -> double
        If bPickA is true, A is returned, otherwise B is
        
        Args:
            a (double): 
            b (double): 
            pick_a (bool): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def select_color(cls, a: LinearColor, b: LinearColor, pick_a: bool) -> LinearColor:
        r"""
        X.select_color(a, b, pick_a) -> LinearColor
        If bPickA is true, A is returned, otherwise B is
        
        Args:
            a (LinearColor): 
            b (LinearColor): 
            pick_a (bool): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def select_class(cls, a: Class, b: Class, select_a: bool) -> Class:
        r"""
        X.select_class(a, b, select_a) -> type(Class)
        If bPickA is true, A is returned, otherwise B is
        
        Args:
            a (type(Class)): 
            b (type(Class)): 
            select_a (bool): 
        
        Returns:
            type(Class):
        """
        ...
    @classmethod
    def seed_random_stream(cls, stream: RandomStream) -> RandomStream:
        r"""
        X.seed_random_stream(stream) -> RandomStream
        Create a new random seed for a random stream
        
        Args:
            stream (RandomStream): 
        
        Returns:
            RandomStream: 
        
            stream (RandomStream):
        """
        ...
    @classmethod
    def safe_divide(cls, a: float, b: float) -> float:
        r"""
        X.safe_divide(a, b) -> double
        This functions returns 0 if B (the denominator) is zero
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def round64(cls, a: float) -> int:
        r"""
        X.round64(a) -> int64
        Rounds A to the nearest integer (e.g., -1.6 becomes -2 and 1.6 becomes 2)
        
        Args:
            a (double): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def round(cls, a: float) -> int:
        r"""
        X.round(a) -> int32
        Rounds A to the nearest integer (e.g., -1.6 becomes -2 and 1.6 becomes 2)
        
        Args:
            a (double): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def rotator_from_axis_and_angle(cls, axis: Vector, angle: float) -> Rotator:
        r"""
        X.rotator_from_axis_and_angle(axis, angle) -> Rotator
        Create a rotation from an axis and supplied angle (in degrees)
        
        Args:
            axis (Vector): 
            angle (float): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def rotate_angle_axis(cls, vect: Vector, angle_deg: float, axis: Vector) -> Vector:
        r"""
        X.rotate_angle_axis(vect, angle_deg, axis) -> Vector
        Returns result of vector A rotated by AngleDeg around Axis
        
        Args:
            vect (Vector): 
            angle_deg (float): 
            axis (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def r_lerp(cls, a: Rotator, b: Rotator, alpha: float, shortest_path: bool) -> Rotator:
        r"""
        X.r_lerp(a, b, alpha, shortest_path) -> Rotator
        Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)
        
        Args:
            a (Rotator): 
            b (Rotator): 
            alpha (float): 
            shortest_path (bool): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def r_interp_to_constant(cls, current: Rotator, target: Rotator, delta_time: float, interp_speed: float) -> Rotator:
        r"""
        X.r_interp_to_constant(current, target, delta_time, interp_speed) -> Rotator
        Tries to reach Target rotation at a constant rate.
        
        Args:
            current (Rotator): Actual rotation
            target (Rotator): Target rotation
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed
        
        Returns:
            Rotator: New interpolated position
        """
        ...
    @classmethod
    def r_interp_to(cls, current: Rotator, target: Rotator, delta_time: float, interp_speed: float) -> Rotator:
        r"""
        X.r_interp_to(current, target, delta_time, interp_speed) -> Rotator
        Tries to reach Target rotation based on Current rotation, giving a nice smooth feeling when rotating to Target rotation.
        
        Args:
            current (Rotator): Actual rotation
            target (Rotator): Target rotation
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed, if the speed given is 0, then jump to the target.
        
        Returns:
            Rotator: New interpolated position
        """
        ...
    @classmethod
    def rgb_to_hsv_vector(cls, rgb: LinearColor) -> LinearColor:
        r"""
        X.rgb_to_hsv_vector(rgb) -> LinearColor
        Converts a RGB linear color to HSV (where H is in R (0..360), S is in G (0..1), and V is in B (0..1))
        
        Args:
            rgb (LinearColor): 
        
        Returns:
            LinearColor: 
        
            hsv (LinearColor):
        """
        ...
    @classmethod
    def rgb_to_hsv(cls, color: LinearColor) -> Tuple[float, float, float, float]:
        r"""
        X.rgb_to_hsv(color) -> (h=float, s=float, v=float, a=float)
        Breaks apart a color into individual HSV components (as well as alpha) (Hue is [0..360) while Saturation and Value are 0..1)
        
        Args:
            color (LinearColor): 
        
        Returns:
            tuple: 
        
            h (float): 
        
            s (float): 
        
            v (float): 
        
            a (float):
        """
        ...
    @classmethod
    def rgb_linear_to_hsv(cls, rgb: LinearColor) -> LinearColor:
        r"""
        X.rgb_linear_to_hsv(rgb) -> LinearColor
        Converts a RGB linear color to HSV (where H is in R, S is in G, and V is in B)
        
        Args:
            rgb (LinearColor): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def reset_vector_spring_state(cls, spring_state: VectorSpringState) -> VectorSpringState:
        r"""
        X.reset_vector_spring_state(spring_state) -> VectorSpringState
        Resets the state of a vector spring
        
        Args:
            spring_state (VectorSpringState): 
        
        Returns:
            VectorSpringState: 
        
            spring_state (VectorSpringState):
        """
        ...
    @classmethod
    def reset_random_stream(cls, stream: RandomStream) -> None:
        r"""
        X.reset_random_stream(stream) -> None
        Reset a random stream
        
        Args:
            stream (RandomStream):
        """
        ...
    @classmethod
    def reset_quaternion_spring_state(cls, spring_state: QuaternionSpringState) -> QuaternionSpringState:
        r"""
        X.reset_quaternion_spring_state(spring_state) -> QuaternionSpringState
        Resets the state of a quaternion spring
        
        Args:
            spring_state (QuaternionSpringState): 
        
        Returns:
            QuaternionSpringState: 
        
            spring_state (QuaternionSpringState):
        """
        ...
    @classmethod
    def reset_float_spring_state(cls, spring_state: FloatSpringState) -> FloatSpringState:
        r"""
        X.reset_float_spring_state(spring_state) -> FloatSpringState
        Resets the state of a float spring
        
        Args:
            spring_state (FloatSpringState): 
        
        Returns:
            FloatSpringState: 
        
            spring_state (FloatSpringState):
        """
        ...
    @classmethod
    def random_unit_vector_in_elliptical_cone_in_radians_from_stream(cls, stream: RandomStream, cone_dir: Vector, max_yaw_in_radians: float, max_pitch_in_radians: float) -> Vector:
        r"""
        X.random_unit_vector_in_elliptical_cone_in_radians_from_stream(stream, cone_dir, max_yaw_in_radians, max_pitch_in_radians) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        The shape of the cone can be modified according to the yaw and pitch angles.
        
        Args:
            stream (RandomStream): The random stream from which to obtain the vector.
            cone_dir (Vector): 
            max_yaw_in_radians (float): The yaw angle of the cone (from ConeDir to horizontal edge), in radians.
            max_pitch_in_radians (float): The pitch angle of the cone (from ConeDir to vertical edge), in radians.
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_unit_vector_in_elliptical_cone_in_radians(cls, cone_dir: Vector, max_yaw_in_radians: float, max_pitch_in_radians: float) -> Vector:
        r"""
        X.random_unit_vector_in_elliptical_cone_in_radians(cone_dir, max_yaw_in_radians, max_pitch_in_radians) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        The shape of the cone can be modified according to the yaw and pitch angles.
        
        Args:
            cone_dir (Vector): 
            max_yaw_in_radians (float): The yaw angle of the cone (from ConeDir to horizontal edge), in radians.
            max_pitch_in_radians (float): The pitch angle of the cone (from ConeDir to vertical edge), in radians.
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_unit_vector_in_elliptical_cone_in_degrees_from_stream(cls, stream: RandomStream, cone_dir: Vector, max_yaw_in_degrees: float, max_pitch_in_degrees: float) -> Vector:
        r"""
        X.random_unit_vector_in_elliptical_cone_in_degrees_from_stream(stream, cone_dir, max_yaw_in_degrees, max_pitch_in_degrees) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        The shape of the cone can be modified according to the yaw and pitch angles.
        
        Args:
            stream (RandomStream): The random stream from which to obtain the vector.
            cone_dir (Vector): 
            max_yaw_in_degrees (float): The yaw angle of the cone (from ConeDir to horizontal edge), in degrees.
            max_pitch_in_degrees (float): The pitch angle of the cone (from ConeDir to vertical edge), in degrees.
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_unit_vector_in_elliptical_cone_in_degrees(cls, cone_dir: Vector, max_yaw_in_degrees: float, max_pitch_in_degrees: float) -> Vector:
        r"""
        X.random_unit_vector_in_elliptical_cone_in_degrees(cone_dir, max_yaw_in_degrees, max_pitch_in_degrees) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        The shape of the cone can be modified according to the yaw and pitch angles.
        
        Args:
            cone_dir (Vector): 
            max_yaw_in_degrees (float): The yaw angle of the cone (from ConeDir to horizontal edge), in degrees.
            max_pitch_in_degrees (float): The pitch angle of the cone (from ConeDir to vertical edge), in degrees.
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_unit_vector_in_cone_with_yaw_and_pitch(cls, cone_dir: Vector, max_yaw_in_degrees: float, max_pitch_in_degrees: float) -> Vector:
        r"""
        deprecated: 'random_unit_vector_in_cone_with_yaw_and_pitch' was renamed to 'random_unit_vector_in_elliptical_cone_in_degrees'.
        """
        ...
    @classmethod
    def random_unit_vector_in_cone_in_radians_from_stream(cls, stream: RandomStream, cone_dir: Vector, cone_half_angle_in_radians: float) -> Vector:
        r"""
        X.random_unit_vector_in_cone_in_radians_from_stream(stream, cone_dir, cone_half_angle_in_radians) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        
        Args:
            stream (RandomStream): The random stream from which to obtain the vector.
            cone_dir (Vector): The base "center" direction of the cone.
            cone_half_angle_in_radians (float): The half-angle of the cone (from ConeDir to edge), in radians.
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_unit_vector_in_cone_in_radians(cls, cone_dir: Vector, cone_half_angle_in_radians: float) -> Vector:
        r"""
        X.random_unit_vector_in_cone_in_radians(cone_dir, cone_half_angle_in_radians) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        
        Args:
            cone_dir (Vector): The base "center" direction of the cone.
            cone_half_angle_in_radians (float): The half-angle of the cone (from ConeDir to edge), in radians.
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_unit_vector_in_cone(cls, cone_dir: Vector, cone_half_angle_in_radians: float) -> Vector:
        r"""
        deprecated: 'random_unit_vector_in_cone' was renamed to 'random_unit_vector_in_cone_in_radians'.
        """
        ...
    @classmethod
    def random_unit_vector_in_cone_in_degrees_from_stream(cls, stream: RandomStream, cone_dir: Vector, cone_half_angle_in_degrees: float) -> Vector:
        r"""
        X.random_unit_vector_in_cone_in_degrees_from_stream(stream, cone_dir, cone_half_angle_in_degrees) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        
        Args:
            stream (RandomStream): The random stream from which to obtain the vector.
            cone_dir (Vector): The base "center" direction of the cone.
            cone_half_angle_in_degrees (float): The half-angle of the cone (from ConeDir to edge), in degrees.
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_unit_vector_in_cone_in_degrees(cls, cone_dir: Vector, cone_half_angle_in_degrees: float) -> Vector:
        r"""
        X.random_unit_vector_in_cone_in_degrees(cone_dir, cone_half_angle_in_degrees) -> Vector
        Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
        
        Args:
            cone_dir (Vector): The base "center" direction of the cone.
            cone_half_angle_in_degrees (float): The half-angle of the cone (from ConeDir to edge), in degrees.
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_unit_vector_from_stream(cls, stream: RandomStream) -> Vector:
        r"""
        X.random_unit_vector_from_stream(stream) -> Vector
        Returns a random vector with length of 1.0
        
        Args:
            stream (RandomStream): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def v_rand_from_stream(cls, stream: RandomStream) -> Vector:
        r"""
        deprecated: 'v_rand_from_stream' was renamed to 'random_unit_vector_from_stream'.
        """
        ...
    @classmethod
    def random_unit_vector(cls) -> Vector:
        r"""
        X.random_unit_vector() -> Vector
        Returns a random vector with length of 1
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def v_rand(cls) -> Vector:
        r"""
        deprecated: 'v_rand' was renamed to 'random_unit_vector'.
        """
        ...
    @classmethod
    def random_rotator_from_stream(cls, stream: RandomStream, roll: bool) -> Rotator:
        r"""
        X.random_rotator_from_stream(stream, roll) -> Rotator
        Create a random rotation
        
        Args:
            stream (RandomStream): 
            roll (bool): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def rot_rand_from_stream(cls, stream: RandomStream, roll: bool) -> Rotator:
        r"""
        deprecated: 'rot_rand_from_stream' was renamed to 'random_rotator_from_stream'.
        """
        ...
    @classmethod
    def random_rotator(cls, roll: bool = False) -> Rotator:
        r"""
        X.random_rotator(roll=False) -> Rotator
        Generates a random rotation, with optional random roll.
        
        Args:
            roll (bool): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def rot_rand(cls, roll: bool = False) -> Rotator:
        r"""
        deprecated: 'rot_rand' was renamed to 'random_rotator'.
        """
        ...
    @classmethod
    def random_point_in_bounding_box_from_stream_box(cls, stream: RandomStream, box: Box) -> Vector:
        r"""
        X.random_point_in_bounding_box_from_stream_box(stream, box) -> Vector
        Returns a random point within the specified bounding box.
        
        Args:
            stream (RandomStream): 
            box (Box): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_point_in_bounding_box_from_stream(cls, stream: RandomStream, center: Vector, half_size: Vector) -> Vector:
        r"""
        X.random_point_in_bounding_box_from_stream(stream, center, half_size) -> Vector
        Returns a random point within the specified bounding box using the first vector as an origin and the second as the half size of the AABB.
        
        Args:
            stream (RandomStream): 
            center (Vector): 
            half_size (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_point_in_bounding_box_box(cls, box: Box) -> Vector:
        r"""
        X.random_point_in_bounding_box_box(box) -> Vector
        Returns a random point within the specified bounding box.
        
        Args:
            box (Box): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_point_in_bounding_box(cls, center: Vector, half_size: Vector) -> Vector:
        r"""
        X.random_point_in_bounding_box(center, half_size) -> Vector
        Returns a random point within the specified bounding box using the first vector as an origin and the second as the box extents.
        
        Args:
            center (Vector): 
            half_size (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def random_integer_in_range_from_stream(cls, stream: RandomStream, min: int, max: int) -> int:
        r"""
        X.random_integer_in_range_from_stream(stream, min, max) -> int32
        Return a random integer between Min and Max (>= Min and <= Max)
        
        Args:
            stream (RandomStream): 
            min (int32): 
            max (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def rand_range_from_stream(cls, stream: RandomStream, min: int, max: int) -> int:
        r"""
        deprecated: 'rand_range_from_stream' was renamed to 'random_integer_in_range_from_stream'.
        """
        ...
    @classmethod
    def random_integer_in_range(cls, min: int, max: int) -> int:
        r"""
        X.random_integer_in_range(min, max) -> int32
        Return a random integer between Min and Max (>= Min and <= Max)
        
        Args:
            min (int32): 
            max (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def rand_range(cls, min: int, max: int) -> int:
        r"""
        deprecated: 'rand_range' was renamed to 'random_integer_in_range'.
        """
        ...
    @classmethod
    def random_integer_from_stream(cls, stream: RandomStream, max: int) -> int:
        r"""
        X.random_integer_from_stream(stream, max) -> int32
        Returns a uniformly distributed random number between 0 and Max - 1
        
        Args:
            stream (RandomStream): 
            max (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def rand_from_stream(cls, stream: RandomStream, max: int) -> int:
        r"""
        deprecated: 'rand_from_stream' was renamed to 'random_integer_from_stream'.
        """
        ...
    @classmethod
    def random_integer64_in_range(cls, min: int, max: int) -> int:
        r"""
        X.random_integer64_in_range(min, max) -> int64
        Return a random integer64 between Min and Max (>= Min and <= Max)
        
        Args:
            min (int64): 
            max (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def random_integer64(cls, max: int) -> int:
        r"""
        X.random_integer64(max) -> int64
        Returns a uniformly distributed random number between 0 and Max - 1
        
        Args:
            max (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def random_integer(cls, max: int) -> int:
        r"""
        X.random_integer(max) -> int32
        Returns a uniformly distributed random number between 0 and Max - 1
        
        Args:
            max (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def rand(cls, max: int) -> int:
        r"""
        deprecated: 'rand' was renamed to 'random_integer'.
        """
        ...
    @classmethod
    def random_float_in_range_from_stream(cls, stream: RandomStream, min: float, max: float) -> float:
        r"""
        X.random_float_in_range_from_stream(stream, min, max) -> float
        Generate a random number between Min and Max
        
        Args:
            stream (RandomStream): 
            min (float): 
            max (float): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def f_rand_range_from_stream(cls, stream: RandomStream, min: float, max: float) -> float:
        r"""
        deprecated: 'f_rand_range_from_stream' was renamed to 'random_float_in_range_from_stream'.
        """
        ...
    @classmethod
    def random_float_in_range(cls, min: float, max: float) -> float:
        r"""
        X.random_float_in_range(min, max) -> double
        Generate a random number between Min and Max
        
        Args:
            min (double): 
            max (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def f_rand_range(cls, min: float, max: float) -> float:
        r"""
        deprecated: 'f_rand_range' was renamed to 'random_float_in_range'.
        """
        ...
    @classmethod
    def random_float_from_stream(cls, stream: RandomStream) -> float:
        r"""
        X.random_float_from_stream(stream) -> float
        Returns a random float between 0 and 1
        
        Args:
            stream (RandomStream): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def f_rand_from_stream(cls, stream: RandomStream) -> float:
        r"""
        deprecated: 'f_rand_from_stream' was renamed to 'random_float_from_stream'.
        """
        ...
    @classmethod
    def random_float(cls) -> float:
        r"""
        X.random_float() -> double
        Returns a random float between 0 and 1
        
        Returns:
            double:
        """
        ...
    @classmethod
    def f_rand(cls) -> float:
        r"""
        deprecated: 'f_rand' was renamed to 'random_float'.
        """
        ...
    @classmethod
    def random_bool_with_weight_from_stream(cls, random_stream: RandomStream, weight: float = 0.500000) -> bool:
        r"""
        X.random_bool_with_weight_from_stream(random_stream, weight=0.500000) -> bool
        Get a random chance with the specified weight. Range of weight is 0.0 - 1.0 E.g.,
                      Weight = .6 return value = True 60% of the time
        
        Args:
            random_stream (RandomStream): 
            weight (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def random_bool_with_weight(cls, weight: float = 0.500000) -> bool:
        r"""
        X.random_bool_with_weight(weight=0.500000) -> bool
        Get a random chance with the specified weight. Range of weight is 0.0 - 1.0 E.g.,
                     Weight = .6 return value = True 60% of the time
        
        Args:
            weight (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def random_bool_from_stream(cls, stream: RandomStream) -> bool:
        r"""
        X.random_bool_from_stream(stream) -> bool
        Returns a random bool
        
        Args:
            stream (RandomStream): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def rand_bool_from_stream(cls, stream: RandomStream) -> bool:
        r"""
        deprecated: 'rand_bool_from_stream' was renamed to 'random_bool_from_stream'.
        """
        ...
    @classmethod
    def random_bool(cls) -> bool:
        r"""
        X.random_bool() -> bool
        Returns a uniformly distributed random bool
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def rand_bool(cls) -> bool:
        r"""
        deprecated: 'rand_bool' was renamed to 'random_bool'.
        """
        ...
    @classmethod
    def radians_to_degrees(cls, a: float) -> float:
        r"""
        X.radians_to_degrees(a) -> double
        Returns degrees value based on the input radians
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def quaternion_spring_interp(cls, current: Quat, target: Quat, spring_state: QuaternionSpringState, stiffness: float, critical_damping_factor: float, delta_time: float, mass: float = 1.000000, target_velocity_amount: float = 1.000000, initialize_from_target: bool = False) -> Tuple[Quat, QuaternionSpringState]:
        r"""
        X.quaternion_spring_interp(current, target, spring_state, stiffness, critical_damping_factor, delta_time, mass=1.000000, target_velocity_amount=1.000000, initialize_from_target=False) -> (Quat, spring_state=QuaternionSpringState)
        Uses a simple spring model to interpolate a quaternion from Current to Target.
        
        Args:
            current (Quat): Current value
            target (Quat): Target value
            spring_state (QuaternionSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
            stiffness (float): How stiff the spring model is (more stiffness means more oscillation around the target value)
            critical_damping_factor (float): How much damping to apply to the spring (0 means no damping, 1 means critically damped which means no oscillation)
            delta_time (float): Time difference since the last update
            mass (float): Multiplier that acts like mass on a spring
            target_velocity_amount (float): If 1 then the target velocity will be calculated and used, which results following the target more closely/without lag. Values down to zero (recommended when using this to smooth data) will progressively disable this effect.
            initialize_from_target (bool): If set then the current value will be set from the target on the first update
        
        Returns:
            QuaternionSpringState: 
        
            spring_state (QuaternionSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
        """
        ...
    @classmethod
    def quat_vector_up(cls, q: Quat) -> Vector:
        r"""
        X.quat_vector_up(q) -> Vector
        Get the up direction (Z axis) after it has been rotated by this Quaternion.
        
        Args:
            q (Quat): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def quat_vector_right(cls, q: Quat) -> Vector:
        r"""
        X.quat_vector_right(q) -> Vector
        Get the right direction (Y axis) after it has been rotated by this Quaternion.
        
        Args:
            q (Quat): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def quat_vector_forward(cls, q: Quat) -> Vector:
        r"""
        X.quat_vector_forward(q) -> Vector
        Get the forward direction (X axis) after it has been rotated by this Quaternion.
        
        Args:
            q (Quat): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def quat_unrotate_vector(cls, q: Quat, v: Vector) -> Vector:
        r"""
        X.quat_unrotate_vector(q, v) -> Vector
        Rotate a vector by the inverse of this quaternion.
        
        Args:
            q (Quat): 
            v (Vector): the vector to be rotated
        
        Returns:
            Vector: vector after rotation by the inverse of this quaternion.
        """
        ...
    @classmethod
    def quat_slerp(cls, a: Quat, b: Quat, alpha: float) -> Quat:
        r"""
        X.quat_slerp(a, b, alpha) -> Quat
        Spherical interpolation between Quaternions. Result is normalized.
        
        Args:
            a (Quat): The starting quat we interp from
            b (Quat): The target quat we interp to
            alpha (double): The interpolation amount, usually 0 to 1.
        
        Returns:
            Quat: Quat after spherical interpolation
        """
        ...
    @classmethod
    def quat_size_squared(cls, q: Quat) -> float:
        r"""
        X.quat_size_squared(q) -> float
        Get the squared length of the quaternion.
        
        Args:
            q (Quat): 
        
        Returns:
            float: The squared length of the quaternion.
        """
        ...
    @classmethod
    def quat_size(cls, q: Quat) -> float:
        r"""
        X.quat_size(q) -> float
        Get the length of the quaternion.
        
        Args:
            q (Quat): 
        
        Returns:
            float: The length of the quaternion.
        """
        ...
    @classmethod
    def quat_set_from_euler(cls, q: Quat, euler: Vector) -> Quat:
        r"""
        X.quat_set_from_euler(q, euler) -> Quat
        Convert a vector of floating-point Euler angles (in degrees) into a Quaternion.
        
        Args:
            q (Quat): Quaternion to update
            euler (Vector): the Euler angles
        
        Returns:
            Quat: 
        
            q (Quat): Quaternion to update
        """
        ...
    @classmethod
    def quat_set_components(cls, q: Quat, x: float, y: float, z: float, w: float) -> Quat:
        r"""
        X.quat_set_components(q, x, y, z, w) -> Quat
        Set X, Y, Z, W components of Quaternion.
        
        Args:
            q (Quat): 
            x (float): 
            y (float): 
            z (float): 
            w (float): 
        
        Returns:
            Quat: 
        
            q (Quat):
        """
        ...
    @classmethod
    def quat_rotator(cls, q: Quat) -> Rotator:
        r"""
        X.quat_rotator(q) -> Rotator
        Converts to Rotator representation of this Quaternion.
        
        Args:
            q (Quat): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def quat_rotate_vector(cls, q: Quat, v: Vector) -> Vector:
        r"""
        X.quat_rotate_vector(q, v) -> Vector
        Rotate a vector by this quaternion.
        
        Args:
            q (Quat): 
            v (Vector): the vector to be rotated
        
        Returns:
            Vector: vector after rotation
        """
        ...
    @classmethod
    def quat_normalized(cls, q: Quat, tolerance: float = 0.000100) -> Quat:
        r"""
        X.quat_normalized(q, tolerance=0.000100) -> Quat
        Get a normalized copy of this quaternion.
        If it is too small, returns an identity quaternion.
        
        Args:
            q (Quat): 
            tolerance (float): Minimum squared length of quaternion for normalization.
        
        Returns:
            Quat:
        """
        ...
    @classmethod
    def quat_normalize(cls, q: Quat, tolerance: float = 0.000100) -> Quat:
        r"""
        X.quat_normalize(q, tolerance=0.000100) -> Quat
        Normalize this quaternion if it is large enough as compared to the supplied tolerance.
        If it is too small then set it to the identity quaternion.
        
        Args:
            q (Quat): 
            tolerance (float): Minimum squared length of quaternion for normalization.
        
        Returns:
            Quat: 
        
            q (Quat):
        """
        ...
    @classmethod
    def quat_make_from_euler(cls, euler: Vector) -> Quat:
        r"""
        X.quat_make_from_euler(euler) -> Quat
        Convert a vector of floating-point Euler angles (in degrees) into a Quaternion.
        
        Args:
            euler (Vector): the Euler angles
        
        Returns:
            Quat: constructed Quat
        """
        ...
    @classmethod
    def quat_log(cls, q: Quat) -> Quat:
        r"""
        X.quat_log(q) -> Quat
        Quaternion with W=0 and V=theta*v. Used in combination with Exp().
        
        Args:
            q (Quat): 
        
        Returns:
            Quat:
        """
        ...
    @classmethod
    def quat_is_normalized(cls, q: Quat) -> bool:
        r"""
        X.quat_is_normalized(q) -> bool
        Return true if this quaternion is normalized
        
        Args:
            q (Quat): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def quat_is_non_finite(cls, q: Quat) -> bool:
        r"""
        X.quat_is_non_finite(q) -> bool
        Determine if there are any non-finite values (NaN or Inf) in this Quat.
        
        Args:
            q (Quat): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def quat_is_identity(cls, q: Quat, tolerance: float = 0.000100) -> bool:
        r"""
        X.quat_is_identity(q, tolerance=0.000100) -> bool
        Checks whether this Quaternion is an Identity Quaternion.
        Assumes Quaternion tested is normalized.
        
        Args:
            q (Quat): 
            tolerance (float): Error tolerance for comparison with Identity Quaternion.
        
        Returns:
            bool: true if Quaternion is a normalized Identity Quaternion.
        """
        ...
    @classmethod
    def quat_is_finite(cls, q: Quat) -> bool:
        r"""
        X.quat_is_finite(q) -> bool
        Determine if all the values  are finite (not NaN nor Inf) in this Quat.
        
        Args:
            q (Quat): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def quat_inversed(cls, q: Quat) -> Quat:
        r"""
        X.quat_inversed(q) -> Quat
        Return an inversed copy of this quaternion.
        
        Args:
            q (Quat): 
        
        Returns:
            Quat:
        """
        ...
    @classmethod
    def quat_get_rotation_axis(cls, q: Quat) -> Vector:
        r"""
        X.quat_get_rotation_axis(q) -> Vector
        Get the axis of rotation of the Quaternion.
        This is the axis around which rotation occurs to transform the canonical coordinate system to the target orientation.
        For the identity Quaternion which has no such rotation, FVector(1,0,0) is returned.
        
        Args:
            q (Quat): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def quat_get_axis_z(cls, q: Quat) -> Vector:
        r"""
        X.quat_get_axis_z(q) -> Vector
        Get the up direction (Z axis) after it has been rotated by this Quaternion.
        
        Args:
            q (Quat): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def quat_get_axis_y(cls, q: Quat) -> Vector:
        r"""
        X.quat_get_axis_y(q) -> Vector
        Get the right direction (Y axis) after it has been rotated by this Quaternion.
        
        Args:
            q (Quat): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def quat_get_axis_x(cls, q: Quat) -> Vector:
        r"""
        X.quat_get_axis_x(q) -> Vector
        Get the forward direction (X axis) after it has been rotated by this Quaternion.
        
        Args:
            q (Quat): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def quat_get_angle(cls, q: Quat) -> float:
        r"""
        X.quat_get_angle(q) -> float
        Get the angle of this quaternion
        
        Args:
            q (Quat): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def quat_find_between_vectors(cls, start: Vector, end: Vector) -> Quat:
        r"""
        X.quat_find_between_vectors(start, end) -> Quat
        Generates the 'smallest' (geodesic) rotation around a sphere between two vectors of arbitrary length.
        
        Args:
            start (Vector): Vector the rotation starts from
            end (Vector): Vector the rotation ends at
        
        Returns:
            Quat: Quat that will rotate from Start to End
        """
        ...
    @classmethod
    def quat_find_between_normals(cls, start_normal: Vector, end_normal: Vector) -> Quat:
        r"""
        X.quat_find_between_normals(start_normal, end_normal) -> Quat
        Generates the 'smallest' (geodesic) rotation around a sphere between two normals (assumed to be unit length).
        
        Args:
            start_normal (Vector): 
            end_normal (Vector): 
        
        Returns:
            Quat: Quat that will rotate from Start to End
        """
        ...
    @classmethod
    def quat_exp(cls, q: Quat) -> Quat:
        r"""
        X.quat_exp(q) -> Quat
        Used in combination with Log().
        Assumes a quaternion with W=0 and V=theta*v (where |v| = 1).
        Exp(q) = (sin(theta)*v, cos(theta))
        
        Args:
            q (Quat): 
        
        Returns:
            Quat:
        """
        ...
    @classmethod
    def quat_euler(cls, q: Quat) -> Vector:
        r"""
        X.quat_euler(q) -> Vector
        Convert a Quaternion into floating-point Euler angles (in degrees).
        
        Args:
            q (Quat): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def quat_enforce_shortest_arc_with(cls, a: Quat, b: Quat) -> Quat:
        r"""
        X.quat_enforce_shortest_arc_with(a, b) -> Quat
        Modify the quaternion to ensure that the delta between it and B represents the shortest possible rotation angle.
        
        Args:
            a (Quat): 
            b (Quat): 
        
        Returns:
            Quat: 
        
            a (Quat):
        """
        ...
    @classmethod
    def quat_angular_distance(cls, a: Quat, b: Quat) -> float:
        r"""
        X.quat_angular_distance(a, b) -> float
        Find the angular distance/difference between two rotation quaternions.
        
        Args:
            a (Quat): 
            b (Quat): Quaternion to find angle distance to
        
        Returns:
            float: angular distance in radians
        """
        ...
    @classmethod
    def project_vector_on_to_vector(cls, v: Vector, target: Vector) -> Vector:
        r"""
        X.project_vector_on_to_vector(v, target) -> Vector
        Projects one vector (V) onto another (Target) and returns the projected vector.
        If Target is nearly zero in length, returns the zero vector.
        
        Args:
            v (Vector): Vector to project.
            target (Vector): Vector on which we are projecting.
        
        Returns:
            Vector: V projected on to Target.
        """
        ...
    @classmethod
    def project_on_to(cls, v: Vector, target: Vector) -> Vector:
        r"""
        deprecated: 'project_on_to' was renamed to 'project_vector_on_to_vector'.
        """
        ...
    @classmethod
    def project_vector_on_to_plane(cls, v: Vector, plane_normal: Vector) -> Vector:
        r"""
        X.project_vector_on_to_plane(v, plane_normal) -> Vector
        Projects a vector onto a plane defined by a normalized vector (PlaneNormal).
        
        Args:
            v (Vector): Vector to project onto the plane.
            plane_normal (Vector): Normal of the plane.
        
        Returns:
            Vector: Vector projected onto the plane.
        """
        ...
    @classmethod
    def project_point_on_to_plane(cls, point: Vector, plane_base: Vector, plane_normal: Vector) -> Vector:
        r"""
        X.project_point_on_to_plane(point, plane_base, plane_normal) -> Vector
        Projects/snaps a point onto a plane defined by a point on the plane and a plane normal.
        
        Args:
            point (Vector): Point to project onto the plane.
            plane_base (Vector): A point on the plane.
            plane_normal (Vector): Normal of the plane.
        
        Returns:
            Vector: Point projected onto the plane.
        """
        ...
    @classmethod
    def points_are_coplanar(cls, points: Array[Vector], tolerance: float = 0.100000) -> bool:
        r"""
        X.points_are_coplanar(points, tolerance=0.100000) -> bool
        Determines whether a given set of points are coplanar, with a tolerance. Any three points or less are always coplanar.
        
        Args:
            points (Array[Vector]): The set of points to determine coplanarity for.
            tolerance (float): Larger numbers means more variance is allowed.
        
        Returns:
            bool: Whether the points are relatively coplanar, based on the tolerance
        """
        ...
    @classmethod
    def perlin_noise1d(cls, value: float) -> float:
        r"""
        X.perlin_noise1d(value) -> float
        Generates a 1D Perlin noise from the given value.  Returns a continuous random value between -1.0 and 1.0.
        
        Args:
            value (float): The input value that Perlin noise will be generated from.  This is usually a steadily incrementing time value.
        
        Returns:
            float: Perlin noise in the range of -1.0 to 1.0
        """
        ...
    @classmethod
    def percent_int_int(cls, a: int, b: int = 1) -> int:
        r"""
        X.percent_int_int(a, b=1) -> int32
        Modulo (A % B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def percent_int64_int64(cls, a: int, b: int = 1) -> int:
        r"""
        X.percent_int64_int64(a, b=1) -> int64
        Modulo (A % B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def percent_byte_byte(cls, a: int, b: int = 1) -> int:
        r"""
        X.percent_byte_byte(a, b=1) -> uint8
        Modulo (A % B)
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            uint8:
        """
        ...
    @classmethod
    def or_int_int(cls, a: int, b: int) -> int:
        r"""
        X.or_int_int(a, b) -> int32
        Bitwise OR (A | B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def or_int64_int64(cls, a: int, b: int) -> int:
        r"""
        X.or_int64_int64(a, b) -> int64
        Bitwise OR (A | B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def now(cls) -> DateTime:
        r"""
        X.now() -> DateTime
        Returns the local date and time on this computer
        
        Returns:
            DateTime:
        """
        ...
    @classmethod
    def not_equal_exactly_vector_vector(cls, a: Vector, b: Vector) -> bool:
        r"""
        X.not_equal_exactly_vector_vector(a, b) -> bool
        Returns true if vector A is not equal to vector B (A != B)
        
        Args:
            a (Vector): 
            b (Vector): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_exactly_vector4_vector4(cls, a: Vector4, b: Vector4) -> bool:
        r"""
        X.not_equal_exactly_vector4_vector4(a, b) -> bool
        Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance
        
        Args:
            a (Vector4): 
            b (Vector4): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_exactly_vector2d_vector2d(cls, a: Vector2D, b: Vector2D) -> bool:
        r"""
        X.not_equal_exactly_vector2d_vector2d(a, b) -> bool
        Returns true if vector2D A is not equal to vector2D B (A != B) within a specified error tolerance
        
        Args:
            a (Vector2D): 
            b (Vector2D): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_vector_vector(cls, a: Vector, b: Vector, error_tolerance: float = 0.000100) -> bool:
        r"""
        X.not_equal_vector_vector(a, b, error_tolerance=0.000100) -> bool
        Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance
        
        Args:
            a (Vector): 
            b (Vector): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_vector4_vector4(cls, a: Vector4, b: Vector4, error_tolerance: float = 0.000100) -> bool:
        r"""
        X.not_equal_vector4_vector4(a, b, error_tolerance=0.000100) -> bool
        Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance
        
        Args:
            a (Vector4): 
            b (Vector4): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_vector2d_vector2d(cls, a: Vector2D, b: Vector2D, error_tolerance: float = 0.000100) -> bool:
        r"""
        X.not_equal_vector2d_vector2d(a, b, error_tolerance=0.000100) -> bool
        Returns true if vector2D A is not equal to vector2D B (A != B) within a specified error tolerance
        
        Args:
            a (Vector2D): 
            b (Vector2D): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_timespan_timespan(cls, a: Timespan, b: Timespan) -> bool:
        r"""
        X.not_equal_timespan_timespan(a, b) -> bool
        Returns true if the values are not equal (A != B)
        
        Args:
            a (Timespan): 
            b (Timespan): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_rotator_rotator(cls, a: Rotator, b: Rotator, error_tolerance: float = 0.000100) -> bool:
        r"""
        X.not_equal_rotator_rotator(a, b, error_tolerance=0.000100) -> bool
        Returns true if rotator A is not equal to rotator B (A != B) within a specified error tolerance
        
        Args:
            a (Rotator): 
            b (Rotator): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_quat_quat(cls, a: Quat, b: Quat, error_tolerance: float = 0.000100) -> bool:
        r"""
        X.not_equal_quat_quat(a, b, error_tolerance=0.000100) -> bool
        Returns true if Quat A is not equal to Quat B (A != B) within a specified error tolerance
        
        Args:
            a (Quat): 
            b (Quat): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_object_object(cls, a: Object, b: Object) -> bool:
        r"""
        X.not_equal_object_object(a, b) -> bool
        Returns true if A and B are not equal (A != B)
        
        Args:
            a (Object): 
            b (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_name_name(cls, a: Name, b: Name) -> bool:
        r"""
        X.not_equal_name_name(a, b) -> bool
        Returns true if A and B are not equal (A != B)
        
        Args:
            a (Name): 
            b (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_matrix_matrix(cls, a: Matrix, b: Matrix, tolerance: float = 0.000100) -> bool:
        r"""
        X.not_equal_matrix_matrix(a, b, tolerance=0.000100) -> bool
        Checks whether another Matrix is not equal to this, within specified tolerance.
        
        Args:
            a (Matrix): 
            b (Matrix): 
            tolerance (float): 
        
        Returns:
            bool: true if two Matrix are not equal, within specified tolerance, otherwise false.
        """
        ...
    @classmethod
    def not_equal_linear_color_linear_color(cls, a: LinearColor, b: LinearColor) -> bool:
        r"""
        X.not_equal_linear_color_linear_color(a, b) -> bool
        Returns true if linear color A is not equal to linear color B (A != B) within a specified error tolerance
        
        Args:
            a (LinearColor): 
            b (LinearColor): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_int_point_int_point(cls, a: IntPoint, b: IntPoint) -> bool:
        r"""
        X.not_equal_int_point_int_point(a, b) -> bool
        Returns true if IntPoint A is NOT equal to IntPoint B (A != B)
        
        Args:
            a (IntPoint): 
            b (IntPoint): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_int_int(cls, a: int, b: int) -> bool:
        r"""
        X.not_equal_int_int(a, b) -> bool
        Returns true if A is not equal to B (A != B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_int64_int64(cls, a: int, b: int) -> bool:
        r"""
        X.not_equal_int64_int64(a, b) -> bool
        Returns true if A is not equal to B (A != B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_double_double(cls, a: float, b: float) -> bool:
        r"""
        X.not_equal_double_double(a, b) -> bool
        Returns true if A does not equal B (A != B)
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_float_float(cls, a: float, b: float) -> bool:
        r"""
        deprecated: 'not_equal_float_float' was renamed to 'not_equal_double_double'.
        """
        ...
    @classmethod
    def not_equal_date_time_date_time(cls, a: DateTime, b: DateTime) -> bool:
        r"""
        X.not_equal_date_time_date_time(a, b) -> bool
        Returns true if the values are not equal (A != B)
        
        Args:
            a (DateTime): 
            b (DateTime): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_class_class(cls, a: Class, b: Class) -> bool:
        r"""
        X.not_equal_class_class(a, b) -> bool
        Returns true if A and B are not equal (A != B)
        
        Args:
            a (type(Class)): 
            b (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_byte_byte(cls, a: int, b: int) -> bool:
        r"""
        X.not_equal_byte_byte(a, b) -> bool
        Returns true if A is not equal to B (A != B)
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_bool_bool(cls, a: bool, b: bool) -> bool:
        r"""
        X.not_equal_bool_bool(a, b) -> bool
        Returns true if the values are not equal (A != B)
        
        Args:
            a (bool): 
            b (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_pre_bool(cls, a: bool) -> bool:
        r"""
        X.not_pre_bool(a) -> bool
        Returns the logical complement of the Boolean value (NOT A)
        
        Args:
            a (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_int64(cls, a: int) -> int:
        r"""
        X.not_int64(a) -> int64
        Bitwise NOT (~A)
        
        Args:
            a (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def not_int(cls, a: int) -> int:
        r"""
        X.not_int(a) -> int32
        Bitwise NOT (~A)
        
        Args:
            a (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def normal_safe2d(cls, a: Vector2D, tolerance: float = 0.000000) -> Vector2D:
        r"""
        X.normal_safe2d(a, tolerance=0.000000) -> Vector2D
        Gets a normalized copy of the vector, checking it is safe to do so based on the length.
        Returns zero vector if vector length is too small to safely normalize.
        
        Args:
            a (Vector2D): 
            tolerance (float): Minimum squared length of vector for normalization.
        
        Returns:
            Vector2D: A normalized copy of the vector if safe, (0,0) otherwise.
        """
        ...
    @classmethod
    def normalize_to_range(cls, value: float, range_min: float, range_max: float) -> float:
        r"""
        X.normalize_to_range(value, range_min, range_max) -> double
        Returns Value normalized to the given range.  (e.g. 20 normalized to the range 10->50 would result in 0.25)
        
        Args:
            value (double): 
            range_min (double): 
            range_max (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def inverse_lerp(cls, value: float, range_min: float, range_max: float) -> float:
        r"""
        deprecated: 'inverse_lerp' was renamed to 'normalize_to_range'.
        """
        ...
    @classmethod
    def normalized_delta_rotator(cls, a: Rotator, b: Rotator) -> Rotator:
        r"""
        X.normalized_delta_rotator(a, b) -> Rotator
        Normalized A-B
        
        Args:
            a (Rotator): 
            b (Rotator): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def normalize_axis(cls, angle: float) -> float:
        r"""
        X.normalize_axis(angle) -> float
        Clamps an angle to the range of [-180, 180].
        
        Args:
            angle (float): The Angle to clamp.
        
        Returns:
            float: The clamped angle.
        """
        ...
    @classmethod
    def normalize2d(cls, a: Vector2D, tolerance: float = 0.000000) -> Vector2D:
        r"""
        X.normalize2d(a, tolerance=0.000000) -> Vector2D
        Normalize this vector in-place if it is large enough, set it to (0,0) otherwise.
        see: NormalSafe2D()
        
        Args:
            a (Vector2D): 
            tolerance (float): Minimum squared length of vector for normalization.
        
        Returns:
            Vector2D: 
        
            a (Vector2D):
        """
        ...
    @classmethod
    def normal2d(cls, a: Vector2D) -> Vector2D:
        r"""
        X.normal2d(a) -> Vector2D
        Returns a unit normal version of the 2D vector
        
        Args:
            a (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def normal(cls, a: Vector, tolerance: float = 0.000100) -> Vector:
        r"""
        X.normal(a, tolerance=0.000100) -> Vector
        Gets a normalized unit copy of the vector, ensuring it is safe to do so based on the length.
        Returns zero vector if vector length is too small to safely normalize.
        
        Args:
            a (Vector): 
            tolerance (float): Minimum squared vector length.
        
        Returns:
            Vector: A normalized copy if safe, (0,0,0) otherwise.
        """
        ...
    @classmethod
    def negate_vector(cls, a: Vector) -> Vector:
        r"""
        X.negate_vector(a) -> Vector
        Negate a vector.
        
        Args:
            a (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def negate_rotator(cls, a: Rotator) -> Rotator:
        r"""
        X.negate_rotator(a) -> Rotator
        Negate a rotator
        
        Args:
            a (Rotator): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def negated2d(cls, a: Vector2D) -> Vector2D:
        r"""
        X.negated2d(a) -> Vector2D
        Gets a negated copy of the vector.
        
        Args:
            a (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def nearly_equal_transform_transform(cls, a: Transform, b: Transform, location_tolerance: float = 0.000100, rotation_tolerance: float = 0.000100, scale3d_tolerance: float = 0.000100) -> bool:
        r"""
        X.nearly_equal_transform_transform(a, b, location_tolerance=0.000100, rotation_tolerance=0.000100, scale3d_tolerance=0.000100) -> bool
        Returns true if transform A is nearly equal to B
        
        Args:
            a (Transform): 
            b (Transform): 
            location_tolerance (float): How close position of transforms need to be to be considered equal
            rotation_tolerance (float): How close rotations of transforms need to be to be considered equal
            scale3d_tolerance (float): How close scale of transforms need to be to be considered equal
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def nearly_equal_float_float(cls, a: float, b: float, error_tolerance: float = 0.000001) -> bool:
        r"""
        X.nearly_equal_float_float(a, b, error_tolerance=0.000001) -> bool
        Returns true if A is nearly equal to B (|A - B| < ErrorTolerance)
        
        Args:
            a (double): 
            b (double): 
            error_tolerance (double): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def multiply_multiply_float_float(cls, base: float, exp: float) -> float:
        r"""
        X.multiply_multiply_float_float(base, exp) -> double
        Power (Base to the Exp-th power)
        
        Args:
            base (double): 
            exp (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def multiply_by_pi(cls, value: float) -> float:
        r"""
        X.multiply_by_pi(value) -> double
        Multiplies the input value by pi.
        
        Args:
            value (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def multiply_vector_vector(cls, a: Vector, b: Vector) -> Vector:
        r"""
        X.multiply_vector_vector(a, b) -> Vector
        Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z})
        
        Args:
            a (Vector): 
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def multiply_vector_int(cls, a: Vector, b: int) -> Vector:
        r"""
        X.multiply_vector_int(a, b) -> Vector
        Scales Vector A by B
        
        Args:
            a (Vector): 
            b (int32): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def multiply_vector_float(cls, a: Vector, b: float) -> Vector:
        r"""
        X.multiply_vector_float(a, b) -> Vector
        Scales Vector A by B
        
        Args:
            a (Vector): 
            b (double): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def multiply_vector4_vector4(cls, a: Vector4, b: Vector4) -> Vector4:
        r"""
        X.multiply_vector4_vector4(a, b) -> Vector4
        Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z, A.w*B.w})
        
        Args:
            a (Vector4): 
            b (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    @classmethod
    def multiply_vector2d_vector2d(cls, a: Vector2D, b: Vector2D) -> Vector2D:
        r"""
        X.multiply_vector2d_vector2d(a, b) -> Vector2D
        Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y})
        
        Args:
            a (Vector2D): 
            b (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def multiply_vector2d_float(cls, a: Vector2D, b: float) -> Vector2D:
        r"""
        X.multiply_vector2d_float(a, b) -> Vector2D
        Returns Vector A scaled by B
        
        Args:
            a (Vector2D): 
            b (double): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def multiply_timespan_float(cls, a: Timespan, scalar: float) -> Timespan:
        r"""
        X.multiply_timespan_float(a, scalar) -> Timespan
        Scalar multiplication (A * s)
        
        Args:
            a (Timespan): 
            scalar (float): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def multiply_rotator_int(cls, a: Rotator, b: int) -> Rotator:
        r"""
        X.multiply_rotator_int(a, b) -> Rotator
        Returns rotator representing rotator A scaled by B
        
        Args:
            a (Rotator): 
            b (int32): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def multiply_rotator_float(cls, a: Rotator, b: float) -> Rotator:
        r"""
        X.multiply_rotator_float(a, b) -> Rotator
        Returns rotator representing rotator A scaled by B
        
        Args:
            a (Rotator): 
            b (float): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def multiply_quat_quat(cls, a: Quat, b: Quat) -> Quat:
        r"""
        X.multiply_quat_quat(a, b) -> Quat
        Gets the result of multiplying two quaternions (A * B).
        
        Order matters when composing quaternions: C = A * B will yield a quaternion C that logically
        first applies B then A to any subsequent transformation (right first, then left).
        
        Args:
            a (Quat): 
            b (Quat): The Quaternion to multiply by.
        
        Returns:
            Quat: The result of multiplication (A * B).
        """
        ...
    @classmethod
    def multiply_matrix_matrix(cls, a: Matrix, b: Matrix) -> Matrix:
        r"""
        X.multiply_matrix_matrix(a, b) -> Matrix
        Gets the result of multiplying a Matrix to this.
        
        Args:
            a (Matrix): 
            b (Matrix): 
        
        Returns:
            Matrix: The result of multiplication.
        """
        ...
    @classmethod
    def multiply_matrix_float(cls, a: Matrix, b: float) -> Matrix:
        r"""
        X.multiply_matrix_float(a, b) -> Matrix
        Multiplies all values of the matrix by a float.
        If your Matrix represents a Transform that you wish to scale you should use Apply Scale instead
        
        Args:
            a (Matrix): 
            b (double): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def multiply_linear_color_linear_color(cls, a: LinearColor, b: LinearColor) -> LinearColor:
        r"""
        X.multiply_linear_color_linear_color(a, b) -> LinearColor
        Element-wise multiplication of two linear colors (R*R, G*G, B*B, A*A)
        
        Args:
            a (LinearColor): 
            b (LinearColor): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def multiply_linear_color_float(cls, a: LinearColor, b: float) -> LinearColor:
        r"""
        X.multiply_linear_color_float(a, b) -> LinearColor
        Element-wise multiplication of a linear color by a float (F*R, F*G, F*B, F*A)
        
        Args:
            a (LinearColor): 
            b (float): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def multiply_int_point_int_point(cls, a: IntPoint, b: IntPoint) -> IntPoint:
        r"""
        X.multiply_int_point_int_point(a, b) -> IntPoint
        Returns IntPoint A multiplied by B
        
        Args:
            a (IntPoint): 
            b (IntPoint): 
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def multiply_int_point_int(cls, a: IntPoint, b: int) -> IntPoint:
        r"""
        X.multiply_int_point_int(a, b) -> IntPoint
        Multiplication (A * B)
        
        Args:
            a (IntPoint): 
            b (int32): 
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def multiply_int_int(cls, a: int, b: int) -> int:
        r"""
        X.multiply_int_int(a, b) -> int32
        Multiplication (A * B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def multiply_int_float(cls, a: int, b: float) -> float:
        r"""
        X.multiply_int_float(a, b) -> double
        Multiplication (A * B)
        
        Args:
            a (int32): 
            b (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def multiply_int64_int64(cls, a: int, b: int) -> int:
        r"""
        X.multiply_int64_int64(a, b) -> int64
        Multiplication (A * B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def multiply_double_double(cls, a: float, b: float) -> float:
        r"""
        X.multiply_double_double(a, b) -> double
        Multiplication (A * B)
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def multiply_float_float(cls, a: float, b: float) -> float:
        r"""
        deprecated: 'multiply_float_float' was renamed to 'multiply_double_double'.
        """
        ...
    @classmethod
    def multiply_byte_byte(cls, a: int, b: int) -> int:
        r"""
        X.multiply_byte_byte(a, b) -> uint8
        Multiplication (A * B)
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            uint8:
        """
        ...
    @classmethod
    def mirror_vector_by_normal(cls, vect: Vector, normal: Vector) -> Vector:
        r"""
        X.mirror_vector_by_normal(vect, normal) -> Vector
        Given a direction vector and a surface normal, returns the vector reflected across the surface normal.
        Produces a result like shining a laser at a mirror!
        
        Args:
            vect (Vector): Direction vector the ray is coming from.
            normal (Vector): A normal of the surface the ray should be reflected on.
        
        Returns:
            Vector: Reflected vector.
        """
        ...
    @classmethod
    def min_of_int_array(cls, int_array: Array[int]) -> Tuple[int, int]:
        r"""
        X.min_of_int_array(int_array) -> (index_of_min_value=int32, min_value=int32)
        Returns min of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.
        
        Args:
            int_array (Array[int32]): 
        
        Returns:
            tuple: 
        
            index_of_min_value (int32): 
        
            min_value (int32):
        """
        ...
    @classmethod
    def min_of_float_array(cls, float_array: Array[float]) -> Tuple[int, float]:
        r"""
        X.min_of_float_array(float_array) -> (index_of_min_value=int32, min_value=float)
        Returns min of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.
        
        Args:
            float_array (Array[float]): 
        
        Returns:
            tuple: 
        
            index_of_min_value (int32): 
        
            min_value (float):
        """
        ...
    @classmethod
    def min_of_byte_array(cls, byte_array: Array[int]) -> Tuple[int, int]:
        r"""
        X.min_of_byte_array(byte_array) -> (index_of_min_value=int32, min_value=uint8)
        Returns min of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.
        
        Args:
            byte_array (Array[uint8]): 
        
        Returns:
            tuple: 
        
            index_of_min_value (int32): 
        
            min_value (uint8):
        """
        ...
    @classmethod
    def min_int64(cls, a: int, b: int) -> int:
        r"""
        X.min_int64(a, b) -> int64
        Returns the minimum value of A and B
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def minimum_area_rectangle(cls, world_context_object: Object, verts: Array[Vector], sample_surface_normal: Vector, debug_draw: bool = False) -> Tuple[Vector, Rotator, float, float]:
        r"""
        X.minimum_area_rectangle(world_context_object, verts, sample_surface_normal, debug_draw=False) -> (out_rect_center=Vector, out_rect_rotation=Rotator, out_side_length_x=float, out_side_length_y=float)
        Minimum Area Rectangle
        deprecated: Use 'Min Area Rectangle' instead; this deprecated version incorrectly returns the average of all input points as the rectangle center.
        
        Args:
            world_context_object (Object): 
            verts (Array[Vector]): 
            sample_surface_normal (Vector): 
            debug_draw (bool): 
        
        Returns:
            tuple: 
        
            out_rect_center (Vector): 
        
            out_rect_rotation (Rotator): 
        
            out_side_length_x (float): 
        
            out_side_length_y (float):
        """
        ...
    @classmethod
    def min_area_rectangle(cls, world_context_object: Object, points: Array[Vector], sample_surface_normal: Vector, debug_draw: bool = False) -> Tuple[Vector, Rotator, float, float]:
        r"""
        X.min_area_rectangle(world_context_object, points, sample_surface_normal, debug_draw=False) -> (out_rect_center=Vector, out_rect_rotation=Rotator, out_rect_length_x=float, out_rect_length_y=float)
        Finds the minimum area rectangle that encloses a set of coplanar points.
        Uses the exhaustive search algorithm in http://www.geometrictools.com/Documentation/MinimumAreaRectangle.pdf
        
        Args:
            world_context_object (Object): Pointer to world context; only used when debug draw is enabled
            points (Array[Vector]): Points to enclose in the rectangle; need to be within the same plane for correct results
            sample_surface_normal (Vector): Normal indicating the surface direction for the points
            debug_draw (bool): Draws the output rectangle for debugging purposes provided the world context is set as well
        
        Returns:
            tuple: 
        
            out_rect_center (Vector): Translation for the output rectangle from the origin
        
            out_rect_rotation (Rotator): Rotation for the output rectangle from the XY plane
        
            out_rect_length_x (float): Length of the output rectangle along the X axis before rotation
        
            out_rect_length_y (float): Length of the output rectangle along the Y axis before rotation
        """
        ...
    @classmethod
    def min(cls, a: int, b: int) -> int:
        r"""
        X.min(a, b) -> int32
        Returns the minimum value of A and B
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def median_of_int_array(cls, int_array: Array[int]) -> float:
        r"""
        X.median_of_int_array(int_array) -> float
        Returns median of all array entries. Returns value of 0 if the supplied array is empty.
        
        Args:
            int_array (Array[int32]): 
        
        Returns:
            float: 
        
            median_value (float):
        """
        ...
    @classmethod
    def max_of_int_array(cls, int_array: Array[int]) -> Tuple[int, int]:
        r"""
        X.max_of_int_array(int_array) -> (index_of_max_value=int32, max_value=int32)
        Returns max of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.
        
        Args:
            int_array (Array[int32]): 
        
        Returns:
            tuple: 
        
            index_of_max_value (int32): 
        
            max_value (int32):
        """
        ...
    @classmethod
    def max_of_float_array(cls, float_array: Array[float]) -> Tuple[int, float]:
        r"""
        X.max_of_float_array(float_array) -> (index_of_max_value=int32, max_value=float)
        Returns max of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.
        
        Args:
            float_array (Array[float]): 
        
        Returns:
            tuple: 
        
            index_of_max_value (int32): 
        
            max_value (float):
        """
        ...
    @classmethod
    def max_of_byte_array(cls, byte_array: Array[int]) -> Tuple[int, int]:
        r"""
        X.max_of_byte_array(byte_array) -> (index_of_max_value=int32, max_value=uint8)
        Returns max of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.
        
        Args:
            byte_array (Array[uint8]): 
        
        Returns:
            tuple: 
        
            index_of_max_value (int32): 
        
            max_value (uint8):
        """
        ...
    @classmethod
    def max_int64(cls, a: int, b: int) -> int:
        r"""
        X.max_int64(a, b) -> int64
        Returns the maximum value of A and B
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def max(cls, a: int, b: int) -> int:
        r"""
        X.max(a, b) -> int32
        Returns the maximum value of A and B
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def matrix_transform_vector4(cls, m: Matrix, v: Vector4) -> Vector4:
        r"""
        X.matrix_transform_vector4(m, v) -> Vector4
        Transform a vector by the matrix.
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            v (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    @classmethod
    def matrix_transform_vector(cls, m: Matrix, v: Vector) -> Vector4:
        r"""
        X.matrix_transform_vector(m, v) -> Vector4
        Transform a direction vector - will not take into account translation part of the FMatrix.
        If you want to transform a surface normal (or plane) and correctly account for non-uniform scaling you should use TransformByUsingAdjointT.
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            v (Vector): 
        
        Returns:
            Vector4:
        """
        ...
    @classmethod
    def matrix_transform_position(cls, m: Matrix, v: Vector) -> Vector4:
        r"""
        X.matrix_transform_position(m, v) -> Vector4
        Transform a location - will take into account translation part of the FMatrix.
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            v (Vector): 
        
        Returns:
            Vector4:
        """
        ...
    @classmethod
    def matrix_to_quat(cls, m: Matrix) -> Quat:
        r"""
        X.matrix_to_quat(m) -> Quat
        Transform a rotation matrix into a quaternion.
        (Assumes Matrix represents a transform)
        warning: rotation part will need to be unit length for this to be right!
        
        Args:
            m (Matrix): 
        
        Returns:
            Quat:
        """
        ...
    @classmethod
    def matrix_set_origin(cls, m: Matrix, new_origin: Vector) -> Matrix:
        r"""
        X.matrix_set_origin(m, new_origin) -> Matrix
        Set the origin of the coordinate system to the given vector
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            new_origin (Vector): 
        
        Returns:
            Matrix: 
        
            m (Matrix):
        """
        ...
    @classmethod
    def matrix_set_column(cls, m: Matrix, column: MatrixColumns, value: Vector) -> Matrix:
        r"""
        X.matrix_set_column(m, column, value) -> Matrix
        Matrix Set Column
        
        Args:
            m (Matrix): 
            column (MatrixColumns): 
            value (Vector): 
        
        Returns:
            Matrix: 
        
            m (Matrix):
        """
        ...
    @classmethod
    def matrix_set_axis(cls, m: Matrix, axis: AxisType, axis_vector: Vector) -> Matrix:
        r"""
        X.matrix_set_axis(m, axis, axis_vector) -> Matrix
        set an axis of this matrix
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            axis (AxisType): vector of the axis
            axis_vector (Vector): 
        
        Returns:
            Matrix: 
        
            m (Matrix):
        """
        ...
    @classmethod
    def matrix_scale_translation(cls, m: Matrix, scale3d: Vector) -> Matrix:
        r"""
        X.matrix_scale_translation(m, scale3d) -> Matrix
        Scale the translation part of the matrix by the supplied vector.
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            scale3d (Vector): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def matrix_remove_translation(cls, m: Matrix) -> Matrix:
        r"""
        X.matrix_remove_translation(m) -> Matrix
        Remove any translation from this matrix
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def matrix_remove_scaling(cls, m: Matrix, tolerance: float = 0.000000) -> Matrix:
        r"""
        X.matrix_remove_scaling(m, tolerance=0.000000) -> Matrix
        Remove any scaling from this matrix (ie magnitude of each row is 1) with error Tolerance
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            tolerance (float): 
        
        Returns:
            Matrix: 
        
            m (Matrix):
        """
        ...
    @classmethod
    def matrix_mirror(cls, m: Matrix, mirror_axis: AxisType, flip_axis: AxisType) -> Matrix:
        r"""
        X.matrix_mirror(m, mirror_axis, flip_axis) -> Matrix
        Utility for mirroring this transform across a certain plane, and flipping one of the axis as well.
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            mirror_axis (AxisType): 
            flip_axis (AxisType): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def matrix_inverse_transform_vector(cls, m: Matrix, v: Vector) -> Vector:
        r"""
        X.matrix_inverse_transform_vector(m, v) -> Vector
        Transform a direction vector by the inverse of this matrix - will not take into account translation part.
        If you want to transform a surface normal (or plane) and correctly account for non-uniform scaling you should use TransformByUsingAdjointT with adjoint of matrix inverse.
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            v (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def matrix_inverse_transform_position(cls, m: Matrix, v: Vector) -> Vector:
        r"""
        X.matrix_inverse_transform_position(m, v) -> Vector
        Inverts the matrix and then transforms V - correctly handles scaling in this matrix.
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            v (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def matrix_get_unit_axis(cls, m: Matrix, axis: AxisType) -> Vector:
        r"""
        X.matrix_get_unit_axis(m, axis) -> Vector
        get unit length axis of this matrix
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            axis (AxisType): 
        
        Returns:
            Vector: vector of the axis
        """
        ...
    @classmethod
    def matrix_get_unit_axes(cls, m: Matrix) -> Tuple[Vector, Vector, Vector]:
        r"""
        X.matrix_get_unit_axes(m) -> (x=Vector, y=Vector, z=Vector)
        get unit length axes of this matrix
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
        
        Returns:
            tuple: 
        
            x (Vector): axes returned to this param
        
            y (Vector): axes returned to this param
        
            z (Vector): axes returned to this param
        """
        ...
    @classmethod
    def matrix_get_transposed(cls, m: Matrix) -> Matrix:
        r"""
        X.matrix_get_transposed(m) -> Matrix
        Transpose.
        
        Args:
            m (Matrix): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def matrix_get_transpose_adjoint(cls, m: Matrix) -> Matrix:
        r"""
        X.matrix_get_transpose_adjoint(m) -> Matrix
        Get the Transose Adjoint of the Matrix.
        
        Args:
            m (Matrix): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def matrix_get_scale_vector(cls, m: Matrix, tolerance: float = 0.000000) -> Vector:
        r"""
        X.matrix_get_scale_vector(m, tolerance=0.000000) -> Vector
        return a 3D scale vector calculated from this matrix (where each component is the magnitude of a row vector) with error Tolerance.
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            tolerance (float): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def matrix_get_scaled_axis(cls, m: Matrix, axis: AxisType) -> Vector:
        r"""
        X.matrix_get_scaled_axis(m, axis) -> Vector
        get axis of this matrix scaled by the scale of the matrix
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            axis (AxisType): 
        
        Returns:
            Vector: vector of the axis
        """
        ...
    @classmethod
    def matrix_get_scaled_axes(cls, m: Matrix) -> Tuple[Vector, Vector, Vector]:
        r"""
        X.matrix_get_scaled_axes(m) -> (x=Vector, y=Vector, z=Vector)
        get axes of this matrix scaled by the scale of the matrix
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
        
        Returns:
            tuple: 
        
            x (Vector): axes returned to this param
        
            y (Vector): axes returned to this param
        
            z (Vector): axes returned to this param
        """
        ...
    @classmethod
    def matrix_get_rot_determinant(cls, m: Matrix) -> float:
        r"""
        X.matrix_get_rot_determinant(m) -> float
        
        
        Args:
            m (Matrix): 
        
        Returns:
            float: the determinant of rotation 3x3 matrix (Assumes Top Left 3x3 Submatrix represents a Rotation)
        """
        ...
    @classmethod
    def matrix_get_rotator(cls, m: Matrix) -> Rotator:
        r"""
        X.matrix_get_rotator(m) -> Rotator
        Get the rotator representation of this matrix
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
        
        Returns:
            Rotator: rotator representation of this matrix
        """
        ...
    @classmethod
    def matrix_get_origin(cls, matrix: Matrix) -> Vector:
        r"""
        X.matrix_get_origin(matrix) -> Vector
        Get the origin of the co-ordinate system
        (Assumes Matrix represents a transform)
        
        Args:
            matrix (Matrix): 
        
        Returns:
            Vector: co-ordinate system origin
        """
        ...
    @classmethod
    def matrix_get_maximum_axis_scale(cls, m: Matrix) -> float:
        r"""
        X.matrix_get_maximum_axis_scale(m) -> float
        
        
        Args:
            m (Matrix): 
        
        Returns:
            float: the maximum magnitude of any row of the matrix. (Assumes Matrix represents a transform)
        """
        ...
    @classmethod
    def matrix_get_matrix_without_scale(cls, m: Matrix, tolerance: float = 0.000000) -> Matrix:
        r"""
        X.matrix_get_matrix_without_scale(m, tolerance=0.000000) -> Matrix
        Returns matrix after RemoveScaling with error Tolerance
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            tolerance (float): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def matrix_get_inverse(cls, m: Matrix) -> Matrix:
        r"""
        X.matrix_get_inverse(m) -> Matrix
        Get the inverse of the Matrix. Handles nil matrices.
        
        Args:
            m (Matrix): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def matrix_get_frustum_top_plane(cls, m: Matrix) -> Optional[Plane]:
        r"""
        X.matrix_get_frustum_top_plane(m) -> Plane or None
        Get the top plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Args:
            m (Matrix): 
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the top plane of the Frustum of this matrix
        """
        ...
    @classmethod
    def matrix_get_frustum_right_plane(cls, m: Matrix) -> Optional[Plane]:
        r"""
        X.matrix_get_frustum_right_plane(m) -> Plane or None
        Get the right plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Args:
            m (Matrix): 
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the right plane of the Frustum of this matrix
        """
        ...
    @classmethod
    def matrix_get_frustum_near_plane(cls, m: Matrix) -> Optional[Plane]:
        r"""
        X.matrix_get_frustum_near_plane(m) -> Plane or None
        Get the near plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Args:
            m (Matrix): 
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the near plane of the Frustum of this matrix
        """
        ...
    @classmethod
    def matrix_get_frustum_left_plane(cls, m: Matrix) -> Optional[Plane]:
        r"""
        X.matrix_get_frustum_left_plane(m) -> Plane or None
        Get the left plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Args:
            m (Matrix): 
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the left plane of the Frustum of this matrix
        """
        ...
    @classmethod
    def matrix_get_frustum_far_plane(cls, m: Matrix) -> Optional[Plane]:
        r"""
        X.matrix_get_frustum_far_plane(m) -> Plane or None
        Get the far plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Args:
            m (Matrix): 
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the far plane of the Frustum of this matrix
        """
        ...
    @classmethod
    def matrix_get_frustum_bottom_plane(cls, m: Matrix) -> Optional[Plane]:
        r"""
        X.matrix_get_frustum_bottom_plane(m) -> Plane or None
        Get the bottom plane of the Frustum of this matrix
        (Assumes Matrix represents a View Projection Matrix)
        
        Args:
            m (Matrix): 
        
        Returns:
            Plane or None: 
        
            out_plane (Plane): the bottom plane of the Frustum of this matrix
        """
        ...
    @classmethod
    def matrix_get_determinant(cls, m: Matrix) -> float:
        r"""
        X.matrix_get_determinant(m) -> float
        
        
        Args:
            m (Matrix): 
        
        Returns:
            float: determinant of this matrix.
        """
        ...
    @classmethod
    def matrix_get_column(cls, m: Matrix, column: MatrixColumns) -> Vector:
        r"""
        X.matrix_get_column(m, column) -> Vector
        get a column of this matrix
        
        Args:
            m (Matrix): 
            column (MatrixColumns): 
        
        Returns:
            Vector: vector of the column
        """
        ...
    @classmethod
    def matrix_contains_na_n(cls, m: Matrix) -> bool:
        r"""
        X.matrix_contains_na_n(m) -> bool
        Returns true if any element of this matrix is NaN
        
        Args:
            m (Matrix): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def matrix_concatenate_translation(cls, m: Matrix, translation: Vector) -> Matrix:
        r"""
        X.matrix_concatenate_translation(m, translation) -> Matrix
        Returns a matrix with an additional translation concatenated.
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            translation (Vector): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def matrix_apply_scale(cls, m: Matrix, scale: float) -> Matrix:
        r"""
        X.matrix_apply_scale(m, scale) -> Matrix
        Apply Scale to this matrix
        (Assumes Matrix represents a transform)
        
        Args:
            m (Matrix): 
            scale (float): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def map_range_unclamped(cls, value: float, range_a: float, range_b: float, out_range_a: float, out_range_b: float) -> float:
        r"""
        X.map_range_unclamped(value, range_a, range_b, out_range_a, out_range_b) -> double
        Returns Value mapped from one range into another.  (e.g. 20 normalized from the range 10->50 to 20->40 would result in 25)
        
        Args:
            value (double): 
            range_a (double): 
            range_b (double): 
            out_range_a (double): 
            out_range_b (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def map_range(cls, value: float, range_a: float, range_b: float, out_range_a: float, out_range_b: float) -> float:
        r"""
        deprecated: 'map_range' was renamed to 'map_range_unclamped'.
        """
        ...
    @classmethod
    def map_range_clamped(cls, value: float, range_a: float, range_b: float, out_range_a: float, out_range_b: float) -> float:
        r"""
        X.map_range_clamped(value, range_a, range_b, out_range_a, out_range_b) -> double
        Returns Value mapped from one range into another where the Value is clamped to the Input Range.  (e.g. 0.5 normalized from the range 0->1 to 0->50 would result in 25)
        
        Args:
            value (double): 
            range_a (double): 
            range_b (double): 
            out_range_a (double): 
            out_range_b (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def make_rot_from_zy(cls, z: Vector, y: Vector) -> Rotator:
        r"""
        X.make_rot_from_zy(z, y) -> Rotator
        Builds a matrix with given Z and Y axes. Z will remain fixed, Y may be changed minimally to enforce orthogonality. X will be computed. Inputs need not be normalized.
        
        Args:
            z (Vector): 
            y (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def make_rot_from_zx(cls, z: Vector, x: Vector) -> Rotator:
        r"""
        X.make_rot_from_zx(z, x) -> Rotator
        Builds a matrix with given Z and X axes. Z will remain fixed, X may be changed minimally to enforce orthogonality. Y will be computed. Inputs need not be normalized.
        
        Args:
            z (Vector): 
            x (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def make_rot_from_z(cls, z: Vector) -> Rotator:
        r"""
        X.make_rot_from_z(z) -> Rotator
        Builds a rotation matrix given only a ZAxis. X and Y are unspecified but will be orthonormal. ZAxis need not be normalized.
        
        Args:
            z (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def make_rot_from_yz(cls, y: Vector, z: Vector) -> Rotator:
        r"""
        X.make_rot_from_yz(y, z) -> Rotator
        Builds a matrix with given Y and Z axes. Y will remain fixed, Z may be changed minimally to enforce orthogonality. X will be computed. Inputs need not be normalized.
        
        Args:
            y (Vector): 
            z (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def make_rot_from_yx(cls, y: Vector, x: Vector) -> Rotator:
        r"""
        X.make_rot_from_yx(y, x) -> Rotator
        Builds a matrix with given Y and X axes. Y will remain fixed, X may be changed minimally to enforce orthogonality. Z will be computed. Inputs need not be normalized.
        
        Args:
            y (Vector): 
            x (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def make_rot_from_y(cls, y: Vector) -> Rotator:
        r"""
        X.make_rot_from_y(y) -> Rotator
        Builds a rotation matrix given only a YAxis. X and Z are unspecified but will be orthonormal. YAxis need not be normalized.
        
        Args:
            y (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def make_rot_from_xz(cls, x: Vector, z: Vector) -> Rotator:
        r"""
        X.make_rot_from_xz(x, z) -> Rotator
        Builds a matrix with given X and Z axes. X will remain fixed, Z may be changed minimally to enforce orthogonality. Y will be computed. Inputs need not be normalized.
        
        Args:
            x (Vector): 
            z (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def make_rot_from_xy(cls, x: Vector, y: Vector) -> Rotator:
        r"""
        X.make_rot_from_xy(x, y) -> Rotator
        Builds a matrix with given X and Y axes. X will remain fixed, Y may be changed minimally to enforce orthogonality. Z will be computed. Inputs need not be normalized.
        
        Args:
            x (Vector): 
            y (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def make_rot_from_x(cls, x: Vector) -> Rotator:
        r"""
        X.make_rot_from_x(x) -> Rotator
        Builds a rotator given only a XAxis. Y and Z are unspecified but will be orthonormal. XAxis need not be normalized.
        
        Args:
            x (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def make_rotation_from_axes(cls, forward: Vector, right: Vector, up: Vector) -> Rotator:
        r"""
        X.make_rotation_from_axes(forward, right, up) -> Rotator
        Build a reference frame from three axes
        
        Args:
            forward (Vector): 
            right (Vector): 
            up (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def make_relative_transform(cls, a: Transform, relative_to: Transform) -> Transform:
        r"""
        X.make_relative_transform(a, relative_to) -> Transform
        Computes a relative transform of one transform compared to another.
        
        Example: ChildOffset = MakeRelativeTransform(Child.GetActorTransform(), Parent.GetActorTransform())
        This computes the relative transform of the Child from the Parent.
        
        Args:
            a (Transform): The object's transform
            relative_to (Transform): The transform the result is relative to (in the same space as A)
        
        Returns:
            Transform: The new relative transform
        """
        ...
    @classmethod
    def convert_transform_to_relative(cls, a: Transform, relative_to: Transform) -> Transform:
        r"""
        deprecated: 'convert_transform_to_relative' was renamed to 'make_relative_transform'.
        """
        ...
    @classmethod
    def make_pulsating_value(cls, current_time: float, pulses_per_second: float = 1.000000, phase: float = 0.000000) -> float:
        r"""
        X.make_pulsating_value(current_time, pulses_per_second=1.000000, phase=0.000000) -> float
        Simple function to create a pulsating scalar value
        
        Args:
            current_time (float): Current absolute time
            pulses_per_second (float): How many full pulses per second?
            phase (float): Optional phase amount, between 0.0 and 1.0 (to synchronize pulses)
        
        Returns:
            float: Pulsating value (0.0-1.0)
        """
        ...
    @classmethod
    def make_plane_from_point_and_normal(cls, point: Vector, normal: Vector) -> Plane:
        r"""
        X.make_plane_from_point_and_normal(point, normal) -> Plane
        Creates a plane with a facing direction of Normal at the given Point
        
        Args:
            point (Vector): A point on the plane
            normal (Vector): The Normal of the plane at Point
        
        Returns:
            Plane: Plane instance
        """
        ...
    @classmethod
    def make_box_with_origin(cls, origin: Vector, extent: Vector) -> Box:
        r"""
        X.make_box_with_origin(origin, extent) -> Box
        Utility function to build an box from an Origin and Extent
        
        Args:
            origin (Vector): The location of the bounding box.
            extent (Vector): Half size of the bounding box.
        
        Returns:
            Box: A new axis-aligned bounding box.
        """
        ...
    @classmethod
    def loge(cls, a: float) -> float:
        r"""
        X.loge(a) -> double
        Returns natural log of A (if e^R == A, returns R)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def log(cls, a: float, base: float = 1.000000) -> float:
        r"""
        X.log(a, base=1.000000) -> double
        Returns log of A base B (if B^R == A, returns R)
        
        Args:
            a (double): 
            base (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def line_plane_intersection_origin_normal(cls, line_start: Vector, line_end: Vector, plane_origin: Vector, plane_normal: Vector) -> Optional[Tuple[float, Vector]]:
        r"""
        X.line_plane_intersection_origin_normal(line_start, line_end, plane_origin, plane_normal) -> (t=float, intersection=Vector) or None
        Computes the intersection point between a line and a plane.
        
        Args:
            line_start (Vector): 
            line_end (Vector): 
            plane_origin (Vector): 
            plane_normal (Vector): 
        
        Returns:
            tuple or None: True if the intersection test was successful.
        
            t (float): The t of the intersection between the line and the plane
        
            intersection (Vector): The point of intersection between the line and the plane
        """
        ...
    @classmethod
    def line_plane_intersection(cls, line_start: Vector, line_end: Vector, a_plane: Plane) -> Optional[Tuple[float, Vector]]:
        r"""
        X.line_plane_intersection(line_start, line_end, a_plane) -> (t=float, intersection=Vector) or None
        Computes the intersection point between a line and a plane.
        
        Args:
            line_start (Vector): 
            line_end (Vector): 
            a_plane (Plane): 
        
        Returns:
            tuple or None: True if the intersection test was successful.
        
            t (float): The t of the intersection between the line and the plane
        
            intersection (Vector): The point of intersection between the line and the plane
        """
        ...
    @classmethod
    def linear_color_lerp_using_hsv(cls, a: LinearColor, b: LinearColor, alpha: float) -> LinearColor:
        r"""
        X.linear_color_lerp_using_hsv(a, b, alpha) -> LinearColor
        Linearly interpolates between two colors by the specified Alpha amount (100% of A when Alpha=0 and 100% of B when Alpha=1).  The interpolation is performed in HSV color space taking the shortest path to the new color's hue.  This can give better results than a normal lerp, but is much more expensive.  The incoming colors are in RGB space, and the output color will be RGB.  The alpha value will also be interpolated.
        
        Args:
            a (LinearColor): The color and alpha to interpolate from as linear RGBA
            b (LinearColor): The color and alpha to interpolate to as linear RGBA
            alpha (float): Scalar interpolation amount (usually between 0.0 and 1.0 inclusive)
        
        Returns:
            LinearColor: The interpolated color in linear RGB space along with the interpolated alpha value
        """
        ...
    @classmethod
    def linear_color_lerp(cls, a: LinearColor, b: LinearColor, alpha: float) -> LinearColor:
        r"""
        X.linear_color_lerp(a, b, alpha) -> LinearColor
        Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)
        
        Args:
            a (LinearColor): 
            b (LinearColor): 
            alpha (float): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def linear_color_to_rgbe(cls, linear_color: LinearColor) -> Color:
        r"""
        X.linear_color_to_rgbe(linear_color) -> Color
        Converts from linear to 8-bit RGBE as outlined in Gregory Ward's Real Pixels article, Graphics Gems II, page 80.
        
        Args:
            linear_color (LinearColor): 
        
        Returns:
            Color:
        """
        ...
    @classmethod
    def linear_color_to_new_opacity(cls, color: LinearColor, opacity: float) -> LinearColor:
        r"""
        X.linear_color_to_new_opacity(color, opacity) -> LinearColor
        Returns a copy of this color using the specified opacity/alpha.
        
        Args:
            color (LinearColor): 
            opacity (float): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def linear_color_set_temperature(cls, out_color: LinearColor, temperature: float) -> LinearColor:
        r"""
        X.linear_color_set_temperature(out_color, temperature) -> LinearColor
        Converts temperature in Kelvins of a black body radiator to RGB chromaticity.
        
        Args:
            out_color (LinearColor): 
            temperature (float): 
        
        Returns:
            LinearColor: 
        
            out_color (LinearColor):
        """
        ...
    @classmethod
    def linear_color_set_rgba(cls, out_color: LinearColor, r: float, g: float, b: float, a: float = 1.000000) -> LinearColor:
        r"""
        X.linear_color_set_rgba(out_color, r, g, b, a=1.000000) -> LinearColor
        Assign individual linear RGBA components.
        
        Args:
            out_color (LinearColor): 
            r (float): 
            g (float): 
            b (float): 
            a (float): 
        
        Returns:
            LinearColor: 
        
            out_color (LinearColor):
        """
        ...
    @classmethod
    def linear_color_set_random_hue(cls, out_color: LinearColor) -> LinearColor:
        r"""
        X.linear_color_set_random_hue(out_color) -> LinearColor
        Sets to a random color. Choses a quite nice color based on a random hue.
        
        Args:
            out_color (LinearColor): 
        
        Returns:
            LinearColor: 
        
            out_color (LinearColor):
        """
        ...
    @classmethod
    def linear_color_set_from_srgb(cls, out_color: LinearColor, srgb: Color) -> LinearColor:
        r"""
        X.linear_color_set_from_srgb(out_color, srgb) -> LinearColor
        Assigns an FColor coming from an observed sRGB output, into a linear color.
        
        Args:
            out_color (LinearColor): 
            srgb (Color): The sRGB color that needs to be converted into linear space.
        
        Returns:
            LinearColor: 
        
            out_color (LinearColor):
        """
        ...
    @classmethod
    def linear_color_set_from_pow22(cls, out_color: LinearColor, color: Color) -> LinearColor:
        r"""
        X.linear_color_set_from_pow22(out_color, color) -> LinearColor
        Assigns an FColor coming from an observed Pow(1/2.2) output, into a linear color.
        
        Args:
            out_color (LinearColor): 
            color (Color): The Pow(1/2.2) color that needs to be converted into linear space.
        
        Returns:
            LinearColor: 
        
            out_color (LinearColor):
        """
        ...
    @classmethod
    def linear_color_set_from_hsv(cls, out_color: LinearColor, h: float, s: float, v: float, a: float = 1.000000) -> LinearColor:
        r"""
        X.linear_color_set_from_hsv(out_color, h, s, v, a=1.000000) -> LinearColor
        Assigns an HSV color to a linear space RGB color
        
        Args:
            out_color (LinearColor): 
            h (float): 
            s (float): 
            v (float): 
            a (float): 
        
        Returns:
            LinearColor: 
        
            out_color (LinearColor):
        """
        ...
    @classmethod
    def linear_color_set(cls, out_color: LinearColor, color: LinearColor) -> LinearColor:
        r"""
        X.linear_color_set(out_color, color) -> LinearColor
        Assign contents of InColor
        
        Args:
            out_color (LinearColor): 
            color (LinearColor): 
        
        Returns:
            LinearColor: 
        
            out_color (LinearColor):
        """
        ...
    @classmethod
    def linear_color_quantize_round(cls, color: LinearColor) -> Color:
        r"""
        X.linear_color_quantize_round(color) -> Color
        Quantizes the linear color with rounding and returns the result as an 8-bit color.  This bypasses the SRGB conversion.
        
        Args:
            color (LinearColor): 
        
        Returns:
            Color:
        """
        ...
    @classmethod
    def linear_color_quantize(cls, color: LinearColor) -> Color:
        r"""
        X.linear_color_quantize(color) -> Color
        Quantizes the linear color and returns the result as an 8-bit color.  This bypasses the SRGB conversion.
        deprecated: Use LinearColor_QuantizeRound instead for correct color conversion.
        
        Args:
            color (LinearColor): 
        
        Returns:
            Color:
        """
        ...
    @classmethod
    def linear_color_is_near_equal(cls, a: LinearColor, b: LinearColor, tolerance: float = 0.000100) -> bool:
        r"""
        X.linear_color_is_near_equal(a, b, tolerance=0.000100) -> bool
        Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance
        
        Args:
            a (LinearColor): 
            b (LinearColor): 
            tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def linear_color_get_min(cls, color: LinearColor) -> float:
        r"""
        X.linear_color_get_min(color) -> float
        Returns the minimum color channel value in this color structure
        
        Args:
            color (LinearColor): 
        
        Returns:
            float: The minimum color channel value
        """
        ...
    @classmethod
    def linear_color_get_max(cls, color: LinearColor) -> float:
        r"""
        X.linear_color_get_max(color) -> float
        Returns the maximum color channel value in this color structure
        
        Args:
            color (LinearColor): 
        
        Returns:
            float: The maximum color channel value
        """
        ...
    @classmethod
    def linear_color_get_luminance(cls, color: LinearColor) -> float:
        r"""
        X.linear_color_get_luminance(color) -> float
        Returns the perceived brightness of a color on a display taking into account the impact on the human eye per color channel: green > red > blue.
        
        Args:
            color (LinearColor): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def linear_color_distance(cls, c1: LinearColor, c2: LinearColor) -> float:
        r"""
        X.linear_color_distance(c1, c2) -> float
        Euclidean distance between two color points.
        
        Args:
            c1 (LinearColor): 
            c2 (LinearColor): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def linear_color_desaturated(cls, color: LinearColor, desaturation: float) -> LinearColor:
        r"""
        X.linear_color_desaturated(color, desaturation) -> LinearColor
        Returns a desaturated color, with 0 meaning no desaturation and 1 == full desaturation
        
        Args:
            color (LinearColor): 
            desaturation (float): 
        
        Returns:
            LinearColor: Desaturated color
        """
        ...
    @classmethod
    def less_less_vector_rotator(cls, a: Vector, b: Rotator) -> Vector:
        r"""
        X.less_less_vector_rotator(a, b) -> Vector
        Returns result of vector A rotated by the inverse of Rotator B
        
        Args:
            a (Vector): 
            b (Rotator): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def less_equal_timespan_timespan(cls, a: Timespan, b: Timespan) -> bool:
        r"""
        X.less_equal_timespan_timespan(a, b) -> bool
        Returns true if A is less than or equal to B (A <= B)
        
        Args:
            a (Timespan): 
            b (Timespan): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def less_equal_int_int(cls, a: int, b: int) -> bool:
        r"""
        X.less_equal_int_int(a, b) -> bool
        Returns true if A is less than or equal to B (A <= B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def less_equal_int64_int64(cls, a: int, b: int) -> bool:
        r"""
        X.less_equal_int64_int64(a, b) -> bool
        Returns true if A is less than or equal to B (A <= B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def less_equal_double_double(cls, a: float, b: float) -> bool:
        r"""
        X.less_equal_double_double(a, b) -> bool
        Returns true if A is Less than or equal to B (A <= B)
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def less_equal_float_float(cls, a: float, b: float) -> bool:
        r"""
        deprecated: 'less_equal_float_float' was renamed to 'less_equal_double_double'.
        """
        ...
    @classmethod
    def less_equal_date_time_date_time(cls, a: DateTime, b: DateTime) -> bool:
        r"""
        X.less_equal_date_time_date_time(a, b) -> bool
        Returns true if A is less than or equal to B (A <= B)
        
        Args:
            a (DateTime): 
            b (DateTime): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def less_equal_byte_byte(cls, a: int, b: int) -> bool:
        r"""
        X.less_equal_byte_byte(a, b) -> bool
        Returns true if A is less than or equal to B (A <= B)
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def less_timespan_timespan(cls, a: Timespan, b: Timespan) -> bool:
        r"""
        X.less_timespan_timespan(a, b) -> bool
        Returns true if A is less than B (A < B)
        
        Args:
            a (Timespan): 
            b (Timespan): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def less_int_int(cls, a: int, b: int) -> bool:
        r"""
        X.less_int_int(a, b) -> bool
        Returns true if A is less than B (A < B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def less_int64_int64(cls, a: int, b: int) -> bool:
        r"""
        X.less_int64_int64(a, b) -> bool
        Returns true if A is less than B (A < B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def less_double_double(cls, a: float, b: float) -> bool:
        r"""
        X.less_double_double(a, b) -> bool
        Returns true if A is Less than B (A < B)
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def less_float_float(cls, a: float, b: float) -> bool:
        r"""
        deprecated: 'less_float_float' was renamed to 'less_double_double'.
        """
        ...
    @classmethod
    def less_date_time_date_time(cls, a: DateTime, b: DateTime) -> bool:
        r"""
        X.less_date_time_date_time(a, b) -> bool
        Returns true if A is less than B (A < B)
        
        Args:
            a (DateTime): 
            b (DateTime): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def less_byte_byte(cls, a: int, b: int) -> bool:
        r"""
        X.less_byte_byte(a, b) -> bool
        Returns true if A is less than B (A < B)
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def lerp(cls, a: float, b: float, alpha: float) -> float:
        r"""
        X.lerp(a, b, alpha) -> double
        Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)
        
        Args:
            a (double): 
            b (double): 
            alpha (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def is_zero2d(cls, a: Vector2D) -> bool:
        r"""
        X.is_zero2d(a) -> bool
        Checks whether all components of the vector are exactly zero.
        
        Args:
            a (Vector2D): 
        
        Returns:
            bool: true if vector is exactly zero, otherwise false.
        """
        ...
    @classmethod
    def is_point_in_box_with_transform_box(cls, point: Vector, box_world_transform: Transform, box_extent: Box) -> bool:
        r"""
        X.is_point_in_box_with_transform_box(point, box_world_transform, box_extent) -> bool
        Determines whether a given point is in a box with a given transform. Includes points on the box.
        
        Args:
            point (Vector): Point to test
            box_world_transform (Transform): Component-to-World transform of the box.
            box_extent (Box): 
        
        Returns:
            bool: Whether the point is in the box.
        """
        ...
    @classmethod
    def is_point_in_box_with_transform(cls, point: Vector, box_world_transform: Transform, box_extent: Vector) -> bool:
        r"""
        X.is_point_in_box_with_transform(point, box_world_transform, box_extent) -> bool
        Determines whether a given point is in a box with a given transform. Includes points on the box.
        
        Args:
            point (Vector): Point to test
            box_world_transform (Transform): Component-to-World transform of the box.
            box_extent (Vector): Extents of the box (distance in each axis from origin), in component space.
        
        Returns:
            bool: Whether the point is in the box.
        """
        ...
    @classmethod
    def is_point_in_box_box(cls, point: Vector, box: Box) -> bool:
        r"""
        X.is_point_in_box_box(point, box) -> bool
        Determines whether the given point is in a box. Includes points on the box.
        
        Args:
            point (Vector): Point to test
            box (Box): Box to test against
        
        Returns:
            bool: Whether the point is in the box.
        """
        ...
    @classmethod
    def is_point_in_box(cls, point: Vector, box_origin: Vector, box_extent: Vector) -> bool:
        r"""
        X.is_point_in_box(point, box_origin, box_extent) -> bool
        Determines whether the given point is in a box. Includes points on the box.
        
        Args:
            point (Vector): Point to test
            box_origin (Vector): Origin of the box
            box_extent (Vector): Extents of the box (distance in each axis from origin)
        
        Returns:
            bool: Whether the point is in the box.
        """
        ...
    @classmethod
    def is_nearly_zero2d(cls, a: Vector2D, tolerance: float = 0.000100) -> bool:
        r"""
        X.is_nearly_zero2d(a, tolerance=0.000100) -> bool
        Checks whether vector is near to zero within a specified tolerance.
        
        Args:
            a (Vector2D): 
            tolerance (float): Error tolerance.
        
        Returns:
            bool: true if vector is in tolerance to zero, otherwise false.
        """
        ...
    @classmethod
    def is_morning(cls, a: DateTime) -> bool:
        r"""
        X.is_morning(a) -> bool
        Returns whether A's time is in the morning
        
        Args:
            a (DateTime): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_leap_year(cls, year: int) -> bool:
        r"""
        X.is_leap_year(year) -> bool
        Returns whether given year is a leap year
        
        Args:
            year (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_afternoon(cls, a: DateTime) -> bool:
        r"""
        X.is_afternoon(a) -> bool
        Returns whether A's time is in the afternoon
        
        Args:
            a (DateTime): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def invert_transform(cls, t: Transform) -> Transform:
        r"""
        X.invert_transform(t) -> Transform
        Returns the inverse of the given transform T.
        
        Example: Given a LocalToWorld transform, WorldToLocal will be returned.
        
        Args:
            t (Transform): The transform you wish to invert
        
        Returns:
            Transform: The inverse of T.
        """
        ...
    @classmethod
    def inverse_transform_rotation(cls, t: Transform, rotation: Rotator) -> Rotator:
        r"""
        X.inverse_transform_rotation(t, rotation) -> Rotator
        Transform a rotator by the inverse of the supplied transform.
        For example, if T was an object's transform, this would transform a rotation from world space to local space.
        
        Args:
            t (Transform): 
            rotation (Rotator): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def inverse_transform_location(cls, t: Transform, location: Vector) -> Vector:
        r"""
        X.inverse_transform_location(t, location) -> Vector
        Transform a position by the inverse of the supplied transform.
        For example, if T was an object's transform, this would transform a position from world space to local space.
        
        Args:
            t (Transform): 
            location (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def inverse_transform_position(cls, t: Transform, location: Vector) -> Vector:
        r"""
        deprecated: 'inverse_transform_position' was renamed to 'inverse_transform_location'.
        """
        ...
    @classmethod
    def inverse_transform_direction(cls, t: Transform, direction: Vector) -> Vector:
        r"""
        X.inverse_transform_direction(t, direction) -> Vector
        Transform a direction vector by the inverse of the supplied transform - will not change its length.
        For example, if T was an object's transform, this would transform a direction from world space to local space.
        
        Args:
            t (Transform): 
            direction (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def in_range_int_int(cls, value: int, min: int = 0, max: int = 10, inclusive_min: bool = True, inclusive_max: bool = True) -> bool:
        r"""
        X.in_range_int_int(value, min=0, max=10, inclusive_min=True, inclusive_max=True) -> bool
        Returns true if value is between Min and Max (V >= Min && V <= Max)
        If InclusiveMin is true, value needs to be equal or larger than Min, else it needs to be larger
        If InclusiveMax is true, value needs to be smaller or equal than Max, else it needs to be smaller
        
        Args:
            value (int32): 
            min (int32): 
            max (int32): 
            inclusive_min (bool): 
            inclusive_max (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def in_range_int64_int64(cls, value: int, min: int = 0, max: int = 10, inclusive_min: bool = True, inclusive_max: bool = True) -> bool:
        r"""
        X.in_range_int64_int64(value, min=0, max=10, inclusive_min=True, inclusive_max=True) -> bool
        Returns true if value is between Min and Max (V >= Min && V <= Max)
        If InclusiveMin is true, value needs to be equal or larger than Min, else it needs to be larger
        If InclusiveMax is true, value needs to be smaller or equal than Max, else it needs to be smaller
        
        Args:
            value (int64): 
            min (int64): 
            max (int64): 
            inclusive_min (bool): 
            inclusive_max (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def in_range_float_float(cls, value: float, min: float = 0.000000, max: float = 1.000000, inclusive_min: bool = True, inclusive_max: bool = True) -> bool:
        r"""
        X.in_range_float_float(value, min=0.000000, max=1.000000, inclusive_min=True, inclusive_max=True) -> bool
        Returns true if value is between Min and Max (V >= Min && V <= Max)
        If InclusiveMin is true, value needs to be equal or larger than Min, else it needs to be larger
        If InclusiveMax is true, value needs to be smaller or equal than Max, else it needs to be smaller
        
        Args:
            value (double): 
            min (double): 
            max (double): 
            inclusive_min (bool): 
            inclusive_max (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def hypotenuse(cls, width: float, height: float) -> float:
        r"""
        X.hypotenuse(width, height) -> double
        Returns the hypotenuse of a right-angled triangle given the width and height.
        
        Args:
            width (double): 
            height (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def hsv_to_rgb_linear(cls, hsv: LinearColor) -> LinearColor:
        r"""
        X.hsv_to_rgb_linear(hsv) -> LinearColor
        Converts a HSV linear color (where H is in R, S is in G, and V is in B) to linear RGB
        
        Args:
            hsv (LinearColor): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def hsv_to_rgb_vector(cls, hsv: LinearColor) -> LinearColor:
        r"""
        X.hsv_to_rgb_vector(hsv) -> LinearColor
        Converts a HSV linear color (where H is in R (0..360), S is in G (0..1), and V is in B (0..1)) to RGB
        
        Args:
            hsv (LinearColor): 
        
        Returns:
            LinearColor: 
        
            rgb (LinearColor):
        """
        ...
    @classmethod
    def hsv_to_rgb(cls, h: float, s: float, v: float, a: float = 1.000000) -> LinearColor:
        r"""
        X.hsv_to_rgb(h, s, v, a=1.000000) -> LinearColor
        Make a color from individual color components (HSV space; Hue is [0..360) while Saturation and Value are 0..1)
        
        Args:
            h (float): 
            s (float): 
            v (float): 
            a (float): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def grid_snap_float(cls, location: float, grid_size: float) -> float:
        r"""
        X.grid_snap_float(location, grid_size) -> double
        Snaps a value to the nearest grid multiple. E.g.,
                    Location = 5.1, GridSize = 10.0 : return value = 10.0
        If GridSize is 0 Location is returned
        if GridSize is very small precision issues may occur.
        
        Args:
            location (double): 
            grid_size (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def greater_greater_vector_rotator(cls, a: Vector, b: Rotator) -> Vector:
        r"""
        X.greater_greater_vector_rotator(a, b) -> Vector
        Returns result of vector A rotated by Rotator B
        
        Args:
            a (Vector): 
            b (Rotator): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def greater_equal_timespan_timespan(cls, a: Timespan, b: Timespan) -> bool:
        r"""
        X.greater_equal_timespan_timespan(a, b) -> bool
        Returns true if A is greater than or equal to B (A >= B)
        
        Args:
            a (Timespan): 
            b (Timespan): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def greater_equal_int_int(cls, a: int, b: int) -> bool:
        r"""
        X.greater_equal_int_int(a, b) -> bool
        Returns true if A is greater than or equal to B (A >= B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def greater_equal_int64_int64(cls, a: int, b: int) -> bool:
        r"""
        X.greater_equal_int64_int64(a, b) -> bool
        Returns true if A is greater than or equal to B (A >= B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def greater_equal_double_double(cls, a: float, b: float) -> bool:
        r"""
        X.greater_equal_double_double(a, b) -> bool
        Returns true if A is greater than or equal to B (A >= B)
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def greater_equal_float_float(cls, a: float, b: float) -> bool:
        r"""
        deprecated: 'greater_equal_float_float' was renamed to 'greater_equal_double_double'.
        """
        ...
    @classmethod
    def greater_equal_date_time_date_time(cls, a: DateTime, b: DateTime) -> bool:
        r"""
        X.greater_equal_date_time_date_time(a, b) -> bool
        Returns true if A is greater than or equal to B (A >= B)
        
        Args:
            a (DateTime): 
            b (DateTime): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def greater_equal_byte_byte(cls, a: int, b: int) -> bool:
        r"""
        X.greater_equal_byte_byte(a, b) -> bool
        Returns true if A is greater than or equal to B (A >= B)
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def greater_timespan_timespan(cls, a: Timespan, b: Timespan) -> bool:
        r"""
        X.greater_timespan_timespan(a, b) -> bool
        Returns true if A is greater than B (A > B)
        
        Args:
            a (Timespan): 
            b (Timespan): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def greater_int_int(cls, a: int, b: int) -> bool:
        r"""
        X.greater_int_int(a, b) -> bool
        Returns true if A is greater than B (A > B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def greater_int64_int64(cls, a: int, b: int) -> bool:
        r"""
        X.greater_int64_int64(a, b) -> bool
        Returns true if A is greater than B (A > B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def greater_double_double(cls, a: float, b: float) -> bool:
        r"""
        X.greater_double_double(a, b) -> bool
        Returns true if A is greater than B (A > B)
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def greater_float_float(cls, a: float, b: float) -> bool:
        r"""
        deprecated: 'greater_float_float' was renamed to 'greater_double_double'.
        """
        ...
    @classmethod
    def greater_date_time_date_time(cls, a: DateTime, b: DateTime) -> bool:
        r"""
        X.greater_date_time_date_time(a, b) -> bool
        Returns true if A is greater than B (A > B)
        
        Args:
            a (DateTime): 
            b (DateTime): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def greater_byte_byte(cls, a: int, b: int) -> bool:
        r"""
        X.greater_byte_byte(a, b) -> bool
        Returns true if A is greater than B (A > B)
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_year(cls, a: DateTime) -> int:
        r"""
        X.get_year(a) -> int32
        Returns the year component of A
        
        Args:
            a (DateTime): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_vector_array_average(cls, vectors: Array[Vector]) -> Vector:
        r"""
        X.get_vector_array_average(vectors) -> Vector
        Find the average of an array of vectors
        
        Args:
            vectors (Array[Vector]): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_up_vector(cls, rot: Rotator) -> Vector:
        r"""
        X.get_up_vector(rot) -> Vector
        Rotate the world up vector by the given rotation
        
        Args:
            rot (Rotator): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_total_seconds(cls, a: Timespan) -> float:
        r"""
        X.get_total_seconds(a) -> float
        Returns the total number of seconds in A
        
        Args:
            a (Timespan): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_total_minutes(cls, a: Timespan) -> float:
        r"""
        X.get_total_minutes(a) -> float
        Returns the total number of minutes in A
        
        Args:
            a (Timespan): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_total_milliseconds(cls, a: Timespan) -> float:
        r"""
        X.get_total_milliseconds(a) -> float
        Returns the total number of milliseconds in A
        
        Args:
            a (Timespan): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_total_hours(cls, a: Timespan) -> float:
        r"""
        X.get_total_hours(a) -> float
        Returns the total number of hours in A
        
        Args:
            a (Timespan): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_total_days(cls, a: Timespan) -> float:
        r"""
        X.get_total_days(a) -> float
        Returns the total number of days in A
        
        Args:
            a (Timespan): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_time_of_day(cls, a: DateTime) -> Timespan:
        r"""
        X.get_time_of_day(a) -> Timespan
        Returns the time elapsed since midnight of A
        
        Args:
            a (DateTime): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def get_tau(cls) -> float:
        r"""
        X.get_tau() -> double
        Returns the value of TAU (= 2 * PI)
        
        Returns:
            double:
        """
        ...
    @classmethod
    def get_slope_degree_angles(cls, my_right_y_axis: Vector, floor_normal: Vector, up_vector: Vector) -> Tuple[float, float]:
        r"""
        X.get_slope_degree_angles(my_right_y_axis, floor_normal, up_vector) -> (out_slope_pitch_degree_angle=float, out_slope_roll_degree_angle=float)
        Returns Slope Pitch and Roll angles in degrees based on the following information:
        outparam: OutSlopePitchDegreeAngle    Slope Pitch angle (degrees)
        outparam: OutSlopeRollDegreeAngle             Slope Roll angle (degrees)
        
        Args:
            my_right_y_axis (Vector): Right (Y) direction unit vector of Actor standing on Slope.
            floor_normal (Vector): Floor Normal (unit) vector.
            up_vector (Vector): UpVector of reference frame.
        
        Returns:
            tuple: 
        
            out_slope_pitch_degree_angle (float): 
        
            out_slope_roll_degree_angle (float):
        """
        ...
    @classmethod
    def get_seconds(cls, a: Timespan) -> int:
        r"""
        X.get_seconds(a) -> int32
        Returns the seconds component of A
        
        Args:
            a (Timespan): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_second(cls, a: DateTime) -> int:
        r"""
        X.get_second(a) -> int32
        Returns the second component of A
        
        Args:
            a (DateTime): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_runtime_float_curve_value(cls, curve: RuntimeFloatCurve, time: float, default_value: float = 0.000000) -> float:
        r"""
        X.get_runtime_float_curve_value(curve, time, default_value=0.000000) -> float
        Evaluate this runtime float curve at the specified time
        see: FRichCurve::Eval
        
        Args:
            curve (RuntimeFloatCurve): The runtime float curve to evaluate
            time (float): The time at which to evaluate the curve
            default_value (float): The default value which should be used if the curve cannot be evaluated at the given time.
        
        Returns:
            float: The curve's value at the given time.
        """
        ...
    @classmethod
    def get_rotated2d(cls, a: Vector2D, angle_deg: float) -> Vector2D:
        r"""
        X.get_rotated2d(a, angle_deg) -> Vector2D
        Rotates around axis (0,0,1)
        
        Args:
            a (Vector2D): 
            angle_deg (float): Angle to rotate (in degrees)
        
        Returns:
            Vector2D: Rotated Vector
        """
        ...
    @classmethod
    def get_right_vector(cls, rot: Rotator) -> Vector:
        r"""
        X.get_right_vector(rot) -> Vector
        Rotate the world right vector by the given rotation
        
        Args:
            rot (Rotator): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_reflection_vector(cls, direction: Vector, surface_normal: Vector) -> Vector:
        r"""
        X.get_reflection_vector(direction, surface_normal) -> Vector
        Given a direction vector and a surface normal, returns the vector reflected across the surface normal.
        Produces a result like shining a laser at a mirror!
        
        Args:
            direction (Vector): Direction vector the ray is coming from.
            surface_normal (Vector): A normal of the surface the ray should be reflected on.
        
        Returns:
            Vector: Reflected vector.
        """
        ...
    @classmethod
    def get_point_distance_to_segment(cls, point: Vector, segment_start: Vector, segment_end: Vector) -> float:
        r"""
        X.get_point_distance_to_segment(point, segment_start, segment_end) -> float
        Find the distance from a point to the closest point on a segment.
        
        Args:
            point (Vector): Point for which we find the distance to the closest point on the segment.
            segment_start (Vector): Start of the segment.
            segment_end (Vector): End of the segment.
        
        Returns:
            float: The distance from the given point to the closest point on the segment.
        """
        ...
    @classmethod
    def get_point_distance_to_line(cls, point: Vector, line_origin: Vector, line_direction: Vector) -> float:
        r"""
        X.get_point_distance_to_line(point, line_origin, line_direction) -> float
        Find the distance from a point to the closest point on an infinite line.
        
        Args:
            point (Vector): Point for which we find the distance to the closest point on the line.
            line_origin (Vector): Point of reference on the line.
            line_direction (Vector): Direction of the line. Not required to be normalized.
        
        Returns:
            float: The distance from the given point to the closest point on the line.
        """
        ...
    @classmethod
    def get_pi(cls) -> float:
        r"""
        X.get_pi() -> double
        Returns the value of PI
        
        Returns:
            double:
        """
        ...
    @classmethod
    def get_month(cls, a: DateTime) -> int:
        r"""
        X.get_month(a) -> int32
        Returns the month component of A
        
        Args:
            a (DateTime): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_minutes(cls, a: Timespan) -> int:
        r"""
        X.get_minutes(a) -> int32
        Returns the minutes component of A
        
        Args:
            a (Timespan): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_minute(cls, a: DateTime) -> int:
        r"""
        X.get_minute(a) -> int32
        Returns the minute component of A
        
        Args:
            a (DateTime): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_min_element(cls, a: Vector) -> float:
        r"""
        X.get_min_element(a) -> double
        Find the minimum element (X, Y or Z) of a vector
        
        Args:
            a (Vector): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def get_min2d(cls, a: Vector2D) -> float:
        r"""
        X.get_min2d(a) -> double
        Get the minimum value of the vector's components.
        
        Args:
            a (Vector2D): 
        
        Returns:
            double: The minimum value of the vector's components.
        """
        ...
    @classmethod
    def get_milliseconds(cls, a: Timespan) -> int:
        r"""
        X.get_milliseconds(a) -> int32
        Returns the milliseconds component of A
        
        Args:
            a (Timespan): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_millisecond(cls, a: DateTime) -> int:
        r"""
        X.get_millisecond(a) -> int32
        Returns the millisecond component of A
        
        Args:
            a (DateTime): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_max_element(cls, a: Vector) -> float:
        r"""
        X.get_max_element(a) -> double
        Find the maximum element (X, Y or Z) of a vector
        
        Args:
            a (Vector): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def get_max2d(cls, a: Vector2D) -> float:
        r"""
        X.get_max2d(a) -> double
        Get the maximum value of the vector's components.
        
        Args:
            a (Vector2D): 
        
        Returns:
            double: The maximum value of the vector's components.
        """
        ...
    @classmethod
    def get_hours(cls, a: Timespan) -> int:
        r"""
        X.get_hours(a) -> int32
        Returns the hours component of A
        
        Args:
            a (Timespan): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_hour12(cls, a: DateTime) -> int:
        r"""
        X.get_hour12(a) -> int32
        Returns the hour component of A (12h format)
        
        Args:
            a (DateTime): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_hour(cls, a: DateTime) -> int:
        r"""
        X.get_hour(a) -> int32
        Returns the hour component of A (24h format)
        
        Args:
            a (DateTime): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_forward_vector(cls, rot: Rotator) -> Vector:
        r"""
        X.get_forward_vector(rot) -> Vector
        Rotate the world forward vector by the given rotation
        
        Args:
            rot (Rotator): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_duration(cls, a: Timespan) -> Timespan:
        r"""
        X.get_duration(a) -> Timespan
        Returns the absolute value of A
        
        Args:
            a (Timespan): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def get_direction_unit_vector(cls, from_: Vector, to: Vector) -> Vector:
        r"""
        X.get_direction_unit_vector(from_, to) -> Vector
        Find the unit direction vector from one position to another or (0,0,0) if positions are the same.
        
        Args:
            from_ (Vector): 
            to (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_direction_vector(cls, from_: Vector, to: Vector) -> Vector:
        r"""
        deprecated: 'get_direction_vector' was renamed to 'get_direction_unit_vector'.
        """
        ...
    @classmethod
    def get_days(cls, a: Timespan) -> int:
        r"""
        X.get_days(a) -> int32
        Returns the days component of A
        
        Args:
            a (Timespan): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_day_of_year(cls, a: DateTime) -> int:
        r"""
        X.get_day_of_year(a) -> int32
        Returns the day of year of A
        
        Args:
            a (DateTime): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_day(cls, a: DateTime) -> int:
        r"""
        X.get_day(a) -> int32
        Returns the day component of A (1 to 31)
        
        Args:
            a (DateTime): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_date(cls, a: DateTime) -> DateTime:
        r"""
        X.get_date(a) -> DateTime
        Returns the date component of A
        
        Args:
            a (DateTime): 
        
        Returns:
            DateTime:
        """
        ...
    @classmethod
    def get_box_volume(cls, box: Box) -> float:
        r"""
        X.get_box_volume(box) -> double
        Gets the volume of this box.
        
        Args:
            box (Box): 
        
        Returns:
            double: The box volume.
        """
        ...
    @classmethod
    def get_box_size(cls, box: Box) -> Vector:
        r"""
        X.get_box_size(box) -> Vector
        Gets the size of this box.
        
        Args:
            box (Box): 
        
        Returns:
            Vector: The box size.
        """
        ...
    @classmethod
    def get_box_center(cls, box: Box) -> Vector:
        r"""
        X.get_box_center(box) -> Vector
        Gets the center point of this box.
        
        Args:
            box (Box): 
        
        Returns:
            Vector: The center point.
        """
        ...
    @classmethod
    def get_axes(cls, a: Rotator) -> Tuple[Vector, Vector, Vector]:
        r"""
        X.get_axes(a) -> (x=Vector, y=Vector, z=Vector)
        Get the reference frame direction vectors (axes) described by this rotation
        
        Args:
            a (Rotator): 
        
        Returns:
            tuple: 
        
            x (Vector): 
        
            y (Vector): 
        
            z (Vector):
        """
        ...
    @classmethod
    def get_abs_max2d(cls, a: Vector2D) -> float:
        r"""
        X.get_abs_max2d(a) -> double
        Get the maximum absolute value of the vector's components.
        
        Args:
            a (Vector2D): 
        
        Returns:
            double: The maximum absolute value of the vector's components.
        """
        ...
    @classmethod
    def get_abs2d(cls, a: Vector2D) -> Vector2D:
        r"""
        X.get_abs2d(a) -> Vector2D
        Get a copy of this vector with absolute value of each component.
        
        Args:
            a (Vector2D): 
        
        Returns:
            Vector2D: A copy of this vector with absolute value of each component.
        """
        ...
    @classmethod
    def f_wrap(cls, value: float, min: float = 0.000000, max: float = 1.000000) -> float:
        r"""
        X.f_wrap(value, min=0.000000, max=1.000000) -> double
        Returns Value wrapped from A and B (inclusive)
        
        Args:
            value (double): 
            min (double): 
            max (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def f_trunc_vector(cls, vector: Vector) -> IntVector:
        r"""
        X.f_trunc_vector(vector) -> IntVector
        Rounds A to an integer with truncation towards zero for each element in a vector.  (e.g. -1.7 truncated to -1, 2.8 truncated to 2)
        
        Args:
            vector (Vector): 
        
        Returns:
            IntVector:
        """
        ...
    @classmethod
    def f_trunc64(cls, a: float) -> int:
        r"""
        X.f_trunc64(a) -> int64
        Rounds A towards zero, truncating the fractional part (e.g., -1.6 becomes -1 and 1.6 becomes 1)
        
        Args:
            a (double): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def f_trunc(cls, a: float) -> int:
        r"""
        X.f_trunc(a) -> int32
        Rounds A towards zero, truncating the fractional part (e.g., -1.6 becomes -1 and 1.6 becomes 1)
        
        Args:
            a (double): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def from_unix_timestamp(cls, unix_time: int) -> DateTime:
        r"""
        X.from_unix_timestamp(unix_time) -> DateTime
        Returns the date from Unix time (seconds from midnight 1970-01-01)
        see: ToUnixTimestamp
        
        Args:
            unix_time (int64): Unix time (seconds from midnight 1970-01-01)
        
        Returns:
            DateTime: Gregorian date and time.
        """
        ...
    @classmethod
    def from_seconds(cls, seconds: float) -> Timespan:
        r"""
        X.from_seconds(seconds) -> Timespan
        Returns a time span that represents the specified number of seconds
        
        Args:
            seconds (float): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def from_minutes(cls, minutes: float) -> Timespan:
        r"""
        X.from_minutes(minutes) -> Timespan
        Returns a time span that represents the specified number of minutes
        
        Args:
            minutes (float): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def from_milliseconds(cls, milliseconds: float) -> Timespan:
        r"""
        X.from_milliseconds(milliseconds) -> Timespan
        Returns a time span that represents the specified number of milliseconds
        
        Args:
            milliseconds (float): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def from_hours(cls, hours: float) -> Timespan:
        r"""
        X.from_hours(hours) -> Timespan
        Returns a time span that represents the specified number of hours
        
        Args:
            hours (float): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def from_days(cls, days: float) -> Timespan:
        r"""
        X.from_days(days) -> Timespan
        Returns a time span that represents the specified number of days
        
        Args:
            days (float): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def fraction(cls, a: float) -> float:
        r"""
        X.fraction(a) -> double
        Returns the fractional part of a float.
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def f_mod64(cls, dividend: float, divisor: float) -> Tuple[int, float]:
        r"""
        X.f_mod64(dividend, divisor) -> (int64, remainder=double)
        Returns the number of times Divisor will go into Dividend (i.e., Dividend divided by Divisor), as well as the remainder
        
        Args:
            dividend (double): 
            divisor (double): 
        
        Returns:
            double: 
        
            remainder (double):
        """
        ...
    @classmethod
    def f_mod(cls, dividend: float, divisor: float) -> Tuple[int, float]:
        r"""
        X.f_mod(dividend, divisor) -> (int32, remainder=double)
        Returns the number of times Divisor will go into Dividend (i.e., Dividend divided by Divisor), as well as the remainder
        
        Args:
            dividend (double): 
            divisor (double): 
        
        Returns:
            double: 
        
            remainder (double):
        """
        ...
    @classmethod
    def f_min(cls, a: float, b: float) -> float:
        r"""
        X.f_min(a, b) -> double
        Returns the minimum value of A and B
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def f_max(cls, a: float, b: float) -> float:
        r"""
        X.f_max(a, b) -> double
        Returns the maximum value of A and B
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def float_spring_interp(cls, current: float, target: float, spring_state: FloatSpringState, stiffness: float, critical_damping_factor: float, delta_time: float, mass: float = 1.000000, target_velocity_amount: float = 1.000000, clamp: bool = False, min_value: float = -1.000000, max_value: float = 1.000000, initialize_from_target: bool = False) -> Tuple[float, FloatSpringState]:
        r"""
        X.float_spring_interp(current, target, spring_state, stiffness, critical_damping_factor, delta_time, mass=1.000000, target_velocity_amount=1.000000, clamp=False, min_value=-1.000000, max_value=1.000000, initialize_from_target=False) -> (float, spring_state=FloatSpringState)
        Uses a simple spring model to interpolate a float from Current to Target.
        
        Args:
            current (float): Current value
            target (float): Target value
            spring_state (FloatSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
            stiffness (float): How stiff the spring model is (more stiffness means more oscillation around the target value)
            critical_damping_factor (float): How much damping to apply to the spring (0 means no damping, 1 means critically damped which means no oscillation)
            delta_time (float): Time difference since the last update
            mass (float): Multiplier that acts like mass on a spring
            target_velocity_amount (float): If 1 then the target velocity will be calculated and used, which results following the target more closely/without lag. Values down to zero (recommended when using this to smooth data) will progressively disable this effect.
            clamp (bool): Whether to use the Min/Max values to clamp the motion
            min_value (float): Clamps the minimum output value and cancels the velocity if it reaches this limit
            max_value (float): Clamps the maximum output value and cancels the velocity if it reaches this limit
            initialize_from_target (bool): If set then the current value will be set from the target on the first update
        
        Returns:
            FloatSpringState: 
        
            spring_state (FloatSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
        """
        ...
    @classmethod
    def fixed_turn(cls, current: float, desired: float, delta_rate: float) -> float:
        r"""
        X.fixed_turn(current, desired, delta_rate) -> float
        Returns a new rotation component value
        
        Args:
            current (float): is the current rotation value
            desired (float): is the desired rotation value
            delta_rate (float): is the rotation amount to apply
        
        Returns:
            float: a new rotation component value clamped in the range (-360,360)
        """
        ...
    @classmethod
    def f_interp_to_constant(cls, current: float, target: float, delta_time: float, interp_speed: float) -> float:
        r"""
        X.f_interp_to_constant(current, target, delta_time, interp_speed) -> double
        Tries to reach Target at a constant rate.
        
        Args:
            current (double): Actual position
            target (double): Target position
            delta_time (double): Time since last tick
            interp_speed (double): Interpolation speed
        
        Returns:
            double: New interpolated position
        """
        ...
    @classmethod
    def f_interp_to(cls, current: float, target: float, delta_time: float, interp_speed: float) -> float:
        r"""
        X.f_interp_to(current, target, delta_time, interp_speed) -> double
        Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position.
        
        Args:
            current (double): Actual position
            target (double): Target position
            delta_time (double): Time since last tick
            interp_speed (double): Interpolation speed, if the speed given is 0, then jump to the target.
        
        Returns:
            double: New interpolated position
        """
        ...
    @classmethod
    def f_interp_ease_in_out(cls, a: float, b: float, alpha: float, exponent: float) -> float:
        r"""
        X.f_interp_ease_in_out(a, b, alpha, exponent) -> double
        Interpolate between A and B, applying an ease in/out function.  Exp controls the degree of the curve.
        
        Args:
            a (double): 
            b (double): 
            alpha (double): 
            exponent (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def find_relative_look_at_rotation(cls, start_transform: Transform, target_location: Vector) -> Rotator:
        r"""
        X.find_relative_look_at_rotation(start_transform, target_location) -> Rotator
        Find a local rotation (range of [-180, 180]) for an object with StartTransform to point at TargetLocation.
        Useful for getting LookAt Azimuth or Pawn Aim Offset.
        
        Args:
            start_transform (Transform): 
            target_location (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def find_nearest_points_on_line_segments(cls, segment1_start: Vector, segment1_end: Vector, segment2_start: Vector, segment2_end: Vector) -> Tuple[Vector, Vector]:
        r"""
        X.find_nearest_points_on_line_segments(segment1_start, segment1_end, segment2_start, segment2_end) -> (segment1_point=Vector, segment2_point=Vector)
        Find closest points between 2 segments.
        
        Args:
            segment1_start (Vector): Start of the 1st segment.
            segment1_end (Vector): End of the 1st segment.
            segment2_start (Vector): Start of the 2nd segment.
            segment2_end (Vector): End of the 2nd segment.
        
        Returns:
            tuple: 
        
            segment1_point (Vector): Closest point on segment 1 to segment 2.
        
            segment2_point (Vector): Closest point on segment 2 to segment 1.
        """
        ...
    @classmethod
    def find_look_at_rotation(cls, start: Vector, target: Vector) -> Rotator:
        r"""
        X.find_look_at_rotation(start, target) -> Rotator
        Find a rotation for an object at Start location to point at Target location.
        
        Args:
            start (Vector): 
            target (Vector): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def find_closest_point_on_segment(cls, point: Vector, segment_start: Vector, segment_end: Vector) -> Vector:
        r"""
        X.find_closest_point_on_segment(point, segment_start, segment_end) -> Vector
        Find the closest point on a segment to a given point.
        
        Args:
            point (Vector): Point for which we find the closest point on the segment.
            segment_start (Vector): Start of the segment.
            segment_end (Vector): End of the segment.
        
        Returns:
            Vector: The closest point on the segment to the given point.
        """
        ...
    @classmethod
    def find_closest_point_on_line(cls, point: Vector, line_origin: Vector, line_direction: Vector) -> Vector:
        r"""
        X.find_closest_point_on_line(point, line_origin, line_direction) -> Vector
        Find the closest point on an infinite line to a given point.
        
        Args:
            point (Vector): Point for which we find the closest point on the line.
            line_origin (Vector): Point of reference on the line.
            line_direction (Vector): Direction of the line. Not required to be normalized.
        
        Returns:
            Vector: The closest point on the line to the given point.
        """
        ...
    @classmethod
    def f_floor64(cls, a: float) -> int:
        r"""
        X.f_floor64(a) -> int64
        Rounds A down towards negative infinity / down to the previous integer (e.g., -1.6 becomes -2 and 1.6 becomes 1)
        
        Args:
            a (double): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def f_floor(cls, a: float) -> int:
        r"""
        X.f_floor(a) -> int32
        Rounds A down towards negative infinity / down to the previous integer (e.g., -1.6 becomes -2 and 1.6 becomes 1)
        
        Args:
            a (double): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def f_clamp(cls, value: float, min: float = 0.000000, max: float = 1.000000) -> float:
        r"""
        X.f_clamp(value, min=0.000000, max=1.000000) -> double
        Returns Value clamped between A and B (inclusive)
        
        Args:
            value (double): 
            min (double): 
            max (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def f_ceil64(cls, a: float) -> int:
        r"""
        X.f_ceil64(a) -> int64
        Rounds A up towards positive infinity / up to the next integer (e.g., -1.6 becomes -1 and 1.6 becomes 2)
        
        Args:
            a (double): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def f_ceil(cls, a: float) -> int:
        r"""
        X.f_ceil(a) -> int32
        Rounds A up towards positive infinity / up to the next integer (e.g., -1.6 becomes -1 and 1.6 becomes 2)
        
        Args:
            a (double): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def exp(cls, a: float) -> float:
        r"""
        X.exp(a) -> double
        Returns exponential(e) to the power A (e^A)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def equal_exactly_vector_vector(cls, a: Vector, b: Vector) -> bool:
        r"""
        X.equal_exactly_vector_vector(a, b) -> bool
        Returns true if vector A is equal to vector B (A == B)
        
        Args:
            a (Vector): 
            b (Vector): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_exactly_vector4_vector4(cls, a: Vector4, b: Vector4) -> bool:
        r"""
        X.equal_exactly_vector4_vector4(a, b) -> bool
        Returns true if vector A is equal to vector B (A == B)
        
        Args:
            a (Vector4): 
            b (Vector4): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_exactly_vector2d_vector2d(cls, a: Vector2D, b: Vector2D) -> bool:
        r"""
        X.equal_exactly_vector2d_vector2d(a, b) -> bool
        Returns true if vector A is equal to vector B (A == B)
        
        Args:
            a (Vector2D): 
            b (Vector2D): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_vector_vector(cls, a: Vector, b: Vector, error_tolerance: float = 0.000100) -> bool:
        r"""
        X.equal_equal_vector_vector(a, b, error_tolerance=0.000100) -> bool
        Returns true if vector A is equal to vector B (A == B) within a specified error tolerance
        
        Args:
            a (Vector): 
            b (Vector): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def nearly_equal_vector_vector(cls, a: Vector, b: Vector, error_tolerance: float = 0.000100) -> bool:
        r"""
        deprecated: 'nearly_equal_vector_vector' was renamed to 'equal_equal_vector_vector'.
        """
        ...
    @classmethod
    def equal_equal_vector4_vector4(cls, a: Vector4, b: Vector4, error_tolerance: float = 0.000100) -> bool:
        r"""
        X.equal_equal_vector4_vector4(a, b, error_tolerance=0.000100) -> bool
        Returns true if vector A is equal to vector B (A == B) within a specified error tolerance
        
        Args:
            a (Vector4): 
            b (Vector4): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_vector2d_vector2d(cls, a: Vector2D, b: Vector2D, error_tolerance: float = 0.000100) -> bool:
        r"""
        X.equal_equal_vector2d_vector2d(a, b, error_tolerance=0.000100) -> bool
        Returns true if vector2D A is equal to vector2D B (A == B) within a specified error tolerance
        
        Args:
            a (Vector2D): 
            b (Vector2D): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_transform_transform(cls, a: Transform, b: Transform) -> bool:
        r"""
        X.equal_equal_transform_transform(a, b) -> bool
        Returns true if transform A is equal to transform B
        
        Args:
            a (Transform): 
            b (Transform): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_timespan_timespan(cls, a: Timespan, b: Timespan) -> bool:
        r"""
        X.equal_equal_timespan_timespan(a, b) -> bool
        Returns true if the values are equal (A == B)
        
        Args:
            a (Timespan): 
            b (Timespan): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_rotator_rotator(cls, a: Rotator, b: Rotator, error_tolerance: float = 0.000100) -> bool:
        r"""
        X.equal_equal_rotator_rotator(a, b, error_tolerance=0.000100) -> bool
        Returns true if rotator A is equal to rotator B (A == B) within a specified error tolerance
        
        Args:
            a (Rotator): 
            b (Rotator): 
            error_tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def nearly_equal_rotator_rotator(cls, a: Rotator, b: Rotator, error_tolerance: float = 0.000100) -> bool:
        r"""
        deprecated: 'nearly_equal_rotator_rotator' was renamed to 'equal_equal_rotator_rotator'.
        """
        ...
    @classmethod
    def equal_equal_quat_quat(cls, a: Quat, b: Quat, tolerance: float = 0.000100) -> bool:
        r"""
        X.equal_equal_quat_quat(a, b, tolerance=0.000100) -> bool
        Returns true if Quaternion A is equal to Quaternion B (A == B) within a specified error tolerance
        
        Args:
            a (Quat): 
            b (Quat): 
            tolerance (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_object_object(cls, a: Object, b: Object) -> bool:
        r"""
        X.equal_equal_object_object(a, b) -> bool
        Returns true if A and B are equal (A == B)
        
        Args:
            a (Object): 
            b (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_name_name(cls, a: Name, b: Name) -> bool:
        r"""
        X.equal_equal_name_name(a, b) -> bool
        Returns true if A and B are equal (A == B)
        
        Args:
            a (Name): 
            b (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_matrix_matrix(cls, a: Matrix, b: Matrix, tolerance: float = 0.000100) -> bool:
        r"""
        X.equal_equal_matrix_matrix(a, b, tolerance=0.000100) -> bool
        Checks whether another Matrix is equal to this, within specified tolerance.
        
        Args:
            a (Matrix): 
            b (Matrix): 
            tolerance (float): Error Tolerance.
        
        Returns:
            bool: true if two Matrix are equal, within specified tolerance, otherwise false.
        """
        ...
    @classmethod
    def equal_equal_linear_color_linear_color(cls, a: LinearColor, b: LinearColor) -> bool:
        r"""
        X.equal_equal_linear_color_linear_color(a, b) -> bool
        Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance
        
        Args:
            a (LinearColor): 
            b (LinearColor): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_int_int(cls, a: int, b: int) -> bool:
        r"""
        X.equal_equal_int_int(a, b) -> bool
        Returns true if A is equal to B (A == B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_int64_int64(cls, a: int, b: int) -> bool:
        r"""
        X.equal_equal_int64_int64(a, b) -> bool
        Returns true if A is equal to B (A == B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_double_double(cls, a: float, b: float) -> bool:
        r"""
        X.equal_equal_double_double(a, b) -> bool
        Returns true if A is exactly equal to B (A == B)
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_float_float(cls, a: float, b: float) -> bool:
        r"""
        deprecated: 'equal_equal_float_float' was renamed to 'equal_equal_double_double'.
        """
        ...
    @classmethod
    def equal_equal_date_time_date_time(cls, a: DateTime, b: DateTime) -> bool:
        r"""
        X.equal_equal_date_time_date_time(a, b) -> bool
        Returns true if the values are equal (A == B)
        
        Args:
            a (DateTime): 
            b (DateTime): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_class_class(cls, a: Class, b: Class) -> bool:
        r"""
        X.equal_equal_class_class(a, b) -> bool
        Returns true if A and B are equal (A == B)
        
        Args:
            a (type(Class)): 
            b (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_byte_byte(cls, a: int, b: int) -> bool:
        r"""
        X.equal_equal_byte_byte(a, b) -> bool
        Returns true if A is equal to B (A == B)
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_bool_bool(cls, a: bool, b: bool) -> bool:
        r"""
        X.equal_equal_bool_bool(a, b) -> bool
        Returns true if the values are equal (A == B)
        
        Args:
            a (bool): 
            b (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_int_point_int_point(cls, a: IntPoint, b: IntPoint) -> bool:
        r"""
        X.equal_int_point_int_point(a, b) -> bool
        Returns true if IntPoint A is equal to IntPoint B (A == B)
        
        Args:
            a (IntPoint): 
            b (IntPoint): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def dynamic_weighted_moving_average_f_vector(cls, current_sample: Vector, previous_sample: Vector, max_distance: float, min_weight: float, max_weight: float) -> Vector:
        r"""
        X.dynamic_weighted_moving_average_f_vector(current_sample, previous_sample, max_distance, min_weight, max_weight) -> Vector
        Calculates the new value in a weighted moving average series using the previous value and a weight range.
        The weight range is used to dynamically adjust based upon distance between the samples
        This allows you to smooth a value more aggressively for small noise and let large movements be smoothed less (or vice versa)
        
        Args:
            current_sample (Vector): The value to blend with the previous sample to get a new weighted value
            previous_sample (Vector): The last value from the series
            max_distance (float): Distance to use as the blend between min weight or max weight
            min_weight (float): The weight use when the distance is small
            max_weight (float): The weight use when the distance is large
        
        Returns:
            Vector: the next value in the series
        """
        ...
    @classmethod
    def dynamic_weighted_moving_average_f_rotator(cls, current_sample: Rotator, previous_sample: Rotator, max_distance: float, min_weight: float, max_weight: float) -> Rotator:
        r"""
        X.dynamic_weighted_moving_average_f_rotator(current_sample, previous_sample, max_distance, min_weight, max_weight) -> Rotator
        Calculates the new value in a weighted moving average series using the previous value and a weight range.
        The weight range is used to dynamically adjust based upon distance between the samples
        This allows you to smooth a value more aggressively for small noise and let large movements be smoothed less (or vice versa)
        
        Args:
            current_sample (Rotator): The value to blend with the previous sample to get a new weighted value
            previous_sample (Rotator): The last value from the series
            max_distance (float): Distance to use as the blend between min weight or max weight
            min_weight (float): The weight use when the distance is small
            max_weight (float): The weight use when the distance is large
        
        Returns:
            Rotator: the next value in the series
        """
        ...
    @classmethod
    def dynamic_weighted_moving_average_float(cls, current_sample: float, previous_sample: float, max_distance: float, min_weight: float, max_weight: float) -> float:
        r"""
        X.dynamic_weighted_moving_average_float(current_sample, previous_sample, max_distance, min_weight, max_weight) -> float
        Calculates the new value in a weighted moving average series using the previous value and a weight range.
        The weight range is used to dynamically adjust based upon distance between the samples
        This allows you to smooth a value more aggressively for small noise and let large movements be smoothed less (or vice versa)
        
        Args:
            current_sample (float): The value to blend with the previous sample to get a new weighted value
            previous_sample (float): The last value from the series
            max_distance (float): Distance to use as the blend between min weight or max weight
            min_weight (float): The weight use when the distance is small
            max_weight (float): The weight use when the distance is large
        
        Returns:
            float: the next value in the series
        """
        ...
    @classmethod
    def dot_product2d(cls, a: Vector2D, b: Vector2D) -> float:
        r"""
        X.dot_product2d(a, b) -> double
        Returns the dot product of two 2d vectors - see http://mathworld.wolfram.com/DotProduct.html
        
        Args:
            a (Vector2D): 
            b (Vector2D): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def dot_vector_vector(cls, a: Vector, b: Vector) -> float:
        r"""
        X.dot_vector_vector(a, b) -> double
        Returns the dot product of two 3d vectors - see http://mathworld.wolfram.com/DotProduct.html
        
        Args:
            a (Vector): 
            b (Vector): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def divide_vector_vector(cls, a: Vector, b: Vector = [1.000000, 1.000000, 1.000000]) -> Vector:
        r"""
        X.divide_vector_vector(a, b=[1.000000, 1.000000, 1.000000]) -> Vector
        Element-wise Vector division (Result = {A.x/B.x, A.y/B.y, A.z/B.z})
        
        Args:
            a (Vector): 
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def divide_vector_int(cls, a: Vector, b: int = 1) -> Vector:
        r"""
        X.divide_vector_int(a, b=1) -> Vector
        Vector divide by an integer
        
        Args:
            a (Vector): 
            b (int32): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def divide_vector_float(cls, a: Vector, b: float = 1.000000) -> Vector:
        r"""
        X.divide_vector_float(a, b=1.000000) -> Vector
        Vector divide by a float
        
        Args:
            a (Vector): 
            b (double): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def divide_vector4_vector4(cls, a: Vector4, b: Vector4) -> Vector4:
        r"""
        X.divide_vector4_vector4(a, b) -> Vector4
        Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y, A.z/B.z, A.w/B.w})
        
        Args:
            a (Vector4): 
            b (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    @classmethod
    def divide_vector2d_vector2d(cls, a: Vector2D, b: Vector2D) -> Vector2D:
        r"""
        X.divide_vector2d_vector2d(a, b) -> Vector2D
        Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y})
        
        Args:
            a (Vector2D): 
            b (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def divide_vector2d_float(cls, a: Vector2D, b: float = 1.000000) -> Vector2D:
        r"""
        X.divide_vector2d_float(a, b=1.000000) -> Vector2D
        Returns Vector A divided by B
        
        Args:
            a (Vector2D): 
            b (double): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def divide_timespan_float(cls, a: Timespan, scalar: float) -> Timespan:
        r"""
        X.divide_timespan_float(a, scalar) -> Timespan
        Scalar division (A / s)
        
        Args:
            a (Timespan): 
            scalar (float): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def divide_linear_color_linear_color(cls, a: LinearColor, b: LinearColor) -> LinearColor:
        r"""
        X.divide_linear_color_linear_color(a, b) -> LinearColor
        Element-wise multiplication of two linear colors (R/R, G/G, B/B, A/A)
        
        Args:
            a (LinearColor): 
            b (LinearColor): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def divide_int_point_int_point(cls, a: IntPoint, b: IntPoint) -> IntPoint:
        r"""
        X.divide_int_point_int_point(a, b) -> IntPoint
        Returns IntPoint A divided by B
        
        Args:
            a (IntPoint): 
            b (IntPoint): 
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def divide_int_point_int(cls, a: IntPoint, b: int) -> IntPoint:
        r"""
        X.divide_int_point_int(a, b) -> IntPoint
        Division (A * B)
        
        Args:
            a (IntPoint): 
            b (int32): 
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def divide_int_int(cls, a: int, b: int = 1) -> int:
        r"""
        X.divide_int_int(a, b=1) -> int32
        Division (A / B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def divide_int64_int64(cls, a: int, b: int = 1) -> int:
        r"""
        X.divide_int64_int64(a, b=1) -> int64
        Division (A / B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def divide_double_double(cls, a: float, b: float = 1.000000) -> float:
        r"""
        X.divide_double_double(a, b=1.000000) -> double
        Division (A / B)
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def divide_float_float(cls, a: float, b: float = 1.000000) -> float:
        r"""
        deprecated: 'divide_float_float' was renamed to 'divide_double_double'.
        """
        ...
    @classmethod
    def divide_byte_byte(cls, a: int, b: int = 1) -> int:
        r"""
        X.divide_byte_byte(a, b=1) -> uint8
        Division (A / B)
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            uint8:
        """
        ...
    @classmethod
    def distance_squared2d(cls, v1: Vector2D, v2: Vector2D) -> float:
        r"""
        X.distance_squared2d(v1, v2) -> double
        Squared distance between two 2D points.
        
        Args:
            v1 (Vector2D): The first point.
            v2 (Vector2D): The second point.
        
        Returns:
            double: The squared distance between two 2D points.
        """
        ...
    @classmethod
    def distance2d(cls, v1: Vector2D, v2: Vector2D) -> float:
        r"""
        X.distance2d(v1, v2) -> double
        Distance between two 2D points.
        
        Args:
            v1 (Vector2D): The first point.
            v2 (Vector2D): The second point.
        
        Returns:
            double: The distance between two 2D points.
        """
        ...
    @classmethod
    def deg_tan(cls, a: float) -> float:
        r"""
        X.deg_tan(a) -> double
        Returns the tan of A (expects Degrees)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def deg_sin(cls, a: float) -> float:
        r"""
        X.deg_sin(a) -> double
        Returns the sin of A (expects Degrees)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def degrees_to_radians(cls, a: float) -> float:
        r"""
        X.degrees_to_radians(a) -> double
        Returns radians value based on the input degrees
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def deg_cos(cls, a: float) -> float:
        r"""
        X.deg_cos(a) -> double
        Returns the cos of A (expects Degrees)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def deg_atan2(cls, y: float, x: float) -> float:
        r"""
        X.deg_atan2(y, x) -> double
        Returns the inverse tan (atan2) of A/B (result is in Degrees)
        
        Args:
            y (double): 
            x (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def deg_atan(cls, a: float) -> float:
        r"""
        X.deg_atan(a) -> double
        Returns the inverse tan (atan) (result is in Degrees)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def deg_asin(cls, a: float) -> float:
        r"""
        X.deg_asin(a) -> double
        Returns the inverse sin (arcsin) of A (result is in Degrees)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def deg_acos(cls, a: float) -> float:
        r"""
        X.deg_acos(a) -> double
        Returns the inverse cos (arccos) of A (result is in Degrees)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def days_in_year(cls, year: int) -> int:
        r"""
        X.days_in_year(year) -> int32
        Returns the number of days in the given year
        
        Args:
            year (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def days_in_month(cls, year: int, month: int) -> int:
        r"""
        X.days_in_month(year, month) -> int32
        Returns the number of days in the given year and month
        
        Args:
            year (int32): 
            month (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def date_time_min_value(cls) -> DateTime:
        r"""
        X.date_time_min_value() -> DateTime
        Returns the minimum date and time value
        
        Returns:
            DateTime:
        """
        ...
    @classmethod
    def date_time_max_value(cls) -> DateTime:
        r"""
        X.date_time_max_value() -> DateTime
        Returns the maximum date and time value
        
        Returns:
            DateTime:
        """
        ...
    @classmethod
    def date_time_from_string(cls, date_time_string: str) -> Optional[DateTime]:
        r"""
        X.date_time_from_string(date_time_string) -> DateTime or None
        Converts a date string to a DateTime object
        
        Args:
            date_time_string (str): 
        
        Returns:
            DateTime or None: 
        
            result (DateTime):
        """
        ...
    @classmethod
    def date_time_from_iso_string(cls, iso_string: str) -> Optional[DateTime]:
        r"""
        X.date_time_from_iso_string(iso_string) -> DateTime or None
        Converts a date string in ISO-8601 format to a DateTime object
        
        Args:
            iso_string (str): 
        
        Returns:
            DateTime or None: 
        
            result (DateTime):
        """
        ...
    @classmethod
    def cross_product2d(cls, a: Vector2D, b: Vector2D) -> float:
        r"""
        X.cross_product2d(a, b) -> double
        Returns the cross product of two 2d vectors - see  http://mathworld.wolfram.com/CrossProduct.html
        
        Args:
            a (Vector2D): 
            b (Vector2D): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def cross_vector_vector(cls, a: Vector, b: Vector) -> Vector:
        r"""
        X.cross_vector_vector(a, b) -> Vector
        Returns the cross product of two 3d vectors - see http://mathworld.wolfram.com/CrossProduct.html
        
        Args:
            a (Vector): 
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def create_vector_from_yaw_pitch(cls, yaw: float, pitch: float, length: float = 1.000000) -> Vector:
        r"""
        X.create_vector_from_yaw_pitch(yaw, pitch, length=1.000000) -> Vector
        Creates a directional vector from rotation values {Pitch, Yaw} supplied in degrees with specified Length
        
        Args:
            yaw (float): 
            pitch (float): 
            length (float): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def cos(cls, a: float) -> float:
        r"""
        X.cos(a) -> double
        Returns the cosine of A (expects Radians)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def convert3d_to1d(cls, index3d: IntVector, x_size: int, y_size: int) -> int:
        r"""
        X.convert3d_to1d(index3d, x_size, y_size) -> int32
        Maps a 3D array index to a 1D array index.
        
        Args:
            index3d (IntVector): The 3D array index
            x_size (int32): X dimension of the 3D array
            y_size (int32): Y dimension of the 3D array
        
        Returns:
            int32: The equivalent 1D index of the array
        """
        ...
    @classmethod
    def convert2d_to1d(cls, index2d: IntPoint, x_size: int) -> int:
        r"""
        X.convert2d_to1d(index2d, x_size) -> int32
        Maps a 2D array index to a 1D array index.
        
        Args:
            index2d (IntPoint): The 2D array index
            x_size (int32): X dimension of the 2D array
        
        Returns:
            int32: The equivalent 1D index of the array
        """
        ...
    @classmethod
    def convert1d_to3d(cls, index1d: int, x_size: int, y_size: int) -> IntVector:
        r"""
        X.convert1d_to3d(index1d, x_size, y_size) -> IntVector
        Maps a 1D array index to a 3D array index.
        
        Args:
            index1d (int32): The 1D array index
            x_size (int32): X dimension of the 3D array
            y_size (int32): Y dimension of the 3D array
        
        Returns:
            IntVector: The equivalent 3D index of the array
        """
        ...
    @classmethod
    def convert1d_to2d(cls, index1d: int, x_size: int) -> IntPoint:
        r"""
        X.convert1d_to2d(index1d, x_size) -> IntPoint
        Maps a 1D array index to a 2D array index.
        
        Args:
            index1d (int32): The 1D array index
            x_size (int32): X dimension of the 2D array
        
        Returns:
            IntPoint: The equivalent 2D index of the array
        """
        ...
    @classmethod
    def conv_vector_to_vector2d(cls, vector: Vector) -> Vector2D:
        r"""
        X.conv_vector_to_vector2d(vector) -> Vector2D
        Converts a Vector to a Vector2D using the Vector's (X, Y) coordinates
        
        Args:
            vector (Vector): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def conv_vector_to_transform(cls, location: Vector) -> Transform:
        r"""
        X.conv_vector_to_transform(location) -> Transform
        Converts a vector to a transform. Uses vector as location
        
        Args:
            location (Vector): 
        
        Returns:
            Transform:
        """
        ...
    @classmethod
    def conv_vector_to_rotator(cls, vec: Vector) -> Rotator:
        r"""
        X.conv_vector_to_rotator(vec) -> Rotator
        Return the FRotator orientation corresponding to the direction in which the vector points.
        Sets Yaw and Pitch to the proper numbers, and sets Roll to zero because the roll can't be determined from a vector.
        
        Args:
            vec (Vector): 
        
        Returns:
            Rotator: FRotator from the Vector's direction, without any roll.
        """
        ...
    @classmethod
    def conv_vector_to_quaternion(cls, vec: Vector) -> Quat:
        r"""
        X.conv_vector_to_quaternion(vec) -> Quat
        Return the Quaternion orientation corresponding to the direction in which the vector points.
        Similar to the FRotator version, returns a result without roll such that it preserves the up vector.
        note: If you don't care about preserving the up vector and just want the most direct rotation, you can use the faster 'FindBetweenVectors(ForwardVector, YourVector)' or 'FindBetweenNormals(...)' if you know the vector is of unit length.
        
        Args:
            vec (Vector): 
        
        Returns:
            Quat: Quaternion from the Vector's direction, without any roll.
        """
        ...
    @classmethod
    def conv_vector_to_quaterion(cls, vec: Vector) -> Quat:
        r"""
        deprecated: 'conv_vector_to_quaterion' was renamed to 'conv_vector_to_quaternion'.
        """
        ...
    @classmethod
    def conv_vector_to_linear_color(cls, vec: Vector) -> LinearColor:
        r"""
        X.conv_vector_to_linear_color(vec) -> LinearColor
        Converts a vector to LinearColor
        
        Args:
            vec (Vector): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def conv_vector4_to_vector(cls, vector4: Vector4) -> Vector:
        r"""
        X.conv_vector4_to_vector(vector4) -> Vector
        Converts a Vector4 to a Vector (dropping the W element)
        
        Args:
            vector4 (Vector4): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def conv_vector4_to_rotator(cls, vec: Vector4) -> Rotator:
        r"""
        X.conv_vector4_to_rotator(vec) -> Rotator
        Return the FRotator orientation corresponding to the direction in which the vector points.
        Sets Yaw and Pitch to the proper numbers, and sets Roll to zero because the roll can't be determined from a vector.
        
        Args:
            vec (Vector4): 
        
        Returns:
            Rotator: FRotator from the Vector's direction, without any roll.
        """
        ...
    @classmethod
    def conv_vector4_to_quaternion(cls, vec: Vector4) -> Quat:
        r"""
        X.conv_vector4_to_quaternion(vec) -> Quat
        Return the Quaternion orientation corresponding to the direction in which the vector points.
        Similar to the FRotator version, returns a result without roll such that it preserves the up vector.
        note: If you don't care about preserving the up vector and just want the most direct rotation, you can use the faster 'FindBetweenVectors(ForwardVector, YourVector)' or 'FindBetweenNormals(...)' if you know the vector is of unit length.
        
        Args:
            vec (Vector4): 
        
        Returns:
            Quat: Quaternion from the Vector's direction, without any roll.
        """
        ...
    @classmethod
    def conv_vector4_to_quaterion(cls, vec: Vector4) -> Quat:
        r"""
        deprecated: 'conv_vector4_to_quaterion' was renamed to 'conv_vector4_to_quaternion'.
        """
        ...
    @classmethod
    def conv_vector2d_to_vector(cls, vector2d: Vector2D, z: float = 0.000000) -> Vector:
        r"""
        X.conv_vector2d_to_vector(vector2d, z=0.000000) -> Vector
        Converts a Vector2D to a Vector
        
        Args:
            vector2d (Vector2D): 
            z (float): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def conv_vector2d_to_int_point(cls, vector2d: Vector2D) -> IntPoint:
        r"""
        X.conv_vector2d_to_int_point(vector2d) -> IntPoint
        Converts a Vector2D to an IntPoint
        
        Args:
            vector2d (Vector2D): 
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def conv_transform_to_matrix(cls, transform: Transform) -> Matrix:
        r"""
        X.conv_transform_to_matrix(transform) -> Matrix
        Converts a Transform to a Matrix with scale
        
        Args:
            transform (Transform): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def conv_rotator_to_vector(cls, rot: Rotator) -> Vector:
        r"""
        X.conv_rotator_to_vector(rot) -> Vector
        Get the X direction vector after this rotation
        
        Args:
            rot (Rotator): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def conv_rotator_to_transform(cls, rotator: Rotator) -> Transform:
        r"""
        X.conv_rotator_to_transform(rotator) -> Transform
        Converts Rotator to Transform
        
        Args:
            rotator (Rotator): 
        
        Returns:
            Transform:
        """
        ...
    @classmethod
    def conv_rotator_to_quaternion(cls, rot: Rotator) -> Quat:
        r"""
        X.conv_rotator_to_quaternion(rot) -> Quat
        Converts to Quaternion representation of this Rotator.
        
        Args:
            rot (Rotator): 
        
        Returns:
            Quat:
        """
        ...
    @classmethod
    def conv_matrix_to_transform(cls, matrix: Matrix) -> Transform:
        r"""
        X.conv_matrix_to_transform(matrix) -> Transform
        Converts a Matrix to a Transform
        (Assumes Matrix represents a transform)
        
        Args:
            matrix (Matrix): 
        
        Returns:
            Transform:
        """
        ...
    @classmethod
    def conv_matrix_to_rotator(cls, matrix: Matrix) -> Rotator:
        r"""
        X.conv_matrix_to_rotator(matrix) -> Rotator
        Converts a Matrix to a Rotator
        (Assumes Matrix represents a transform)
        
        Args:
            matrix (Matrix): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def conv_linear_color_to_vector(cls, linear_color: LinearColor) -> Vector:
        r"""
        X.conv_linear_color_to_vector(linear_color) -> Vector
        Converts a LinearColor to a vector
        
        Args:
            linear_color (LinearColor): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def conv_linear_color_to_color(cls, linear_color: LinearColor, use_srgb: bool = True) -> Color:
        r"""
        X.conv_linear_color_to_color(linear_color, use_srgb=True) -> Color
        Quantizes the linear color and returns the result as a FColor with optional sRGB conversion and quality as goal.
        
        Args:
            linear_color (LinearColor): 
            use_srgb (bool): 
        
        Returns:
            Color:
        """
        ...
    @classmethod
    def conv_int_vector_to_vector(cls, int_vector: IntVector) -> Vector:
        r"""
        X.conv_int_vector_to_vector(int_vector) -> Vector
        Converts an IntVector to a vector
        
        Args:
            int_vector (IntVector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def conv_int_to_vector(cls, int: int) -> Vector:
        r"""
        X.conv_int_to_vector(int) -> Vector
        Converts an integer to a FVector
        
        Args:
            int (int32): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def conv_int_to_int_vector(cls, int: int) -> IntVector:
        r"""
        X.conv_int_to_int_vector(int) -> IntVector
        Converts an integer to an IntVector
        
        Args:
            int (int32): 
        
        Returns:
            IntVector:
        """
        ...
    @classmethod
    def conv_int_to_int64(cls, int: int) -> int:
        r"""
        X.conv_int_to_int64(int) -> int64
        Converts an integer to a 64 bit integer
        
        Args:
            int (int32): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def conv_int_to_double(cls, int: int) -> float:
        r"""
        X.conv_int_to_double(int) -> double
        Converts an integer to a float
        
        Args:
            int (int32): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def conv_int_to_float(cls, int: int) -> float:
        r"""
        deprecated: 'conv_int_to_float' was renamed to 'conv_int_to_double'.
        """
        ...
    @classmethod
    def conv_int_to_byte(cls, int: int) -> int:
        r"""
        X.conv_int_to_byte(int) -> uint8
        Converts an integer to a byte (if the integer is too large, returns the low 8 bits)
        
        Args:
            int (int32): 
        
        Returns:
            uint8:
        """
        ...
    @classmethod
    def conv_int_to_bool(cls, int: int) -> bool:
        r"""
        X.conv_int_to_bool(int) -> bool
        Converts a int to a bool
        
        Args:
            int (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def conv_int_point_to_vector2d(cls, int_point: IntPoint) -> Vector2D:
        r"""
        X.conv_int_point_to_vector2d(int_point) -> Vector2D
        Converts an IntPoint to a Vector2D
        
        Args:
            int_point (IntPoint): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def conv_int64_to_int(cls, int: int) -> int:
        r"""
        X.conv_int64_to_int(int) -> int32
        Converts a 64 bit integer to a 32 bit integer (if the integer is too large, returns the low 32 bits)
        
        Args:
            int (int64): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def conv_int64_to_double(cls, int: int) -> float:
        r"""
        X.conv_int64_to_double(int) -> double
        Converts a 64 bit integer to a float
        
        Args:
            int (int64): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def conv_int64_to_byte(cls, int: int) -> int:
        r"""
        X.conv_int64_to_byte(int) -> uint8
        Converts a 64 bit integer to a byte (if the integer is too large, returns the low 8 bits)
        
        Args:
            int (int64): 
        
        Returns:
            uint8:
        """
        ...
    @classmethod
    def conv_double_to_vector2d(cls, double: float) -> Vector2D:
        r"""
        X.conv_double_to_vector2d(double) -> Vector2D
        Convert a float into a vector, where each element is that float
        
        Args:
            double (double): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def conv_double_to_vector(cls, double: float) -> Vector:
        r"""
        X.conv_double_to_vector(double) -> Vector
        Converts a double into a vector, where each element is that float
        
        Args:
            double (double): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def conv_float_to_vector(cls, double: float) -> Vector:
        r"""
        deprecated: 'conv_float_to_vector' was renamed to 'conv_double_to_vector'.
        """
        ...
    @classmethod
    def conv_double_to_linear_color(cls, double: float) -> LinearColor:
        r"""
        X.conv_double_to_linear_color(double) -> LinearColor
        Converts a float into a LinearColor, where each RGB element is that float
        
        Args:
            double (double): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def conv_float_to_linear_color(cls, double: float) -> LinearColor:
        r"""
        deprecated: 'conv_float_to_linear_color' was renamed to 'conv_double_to_linear_color'.
        """
        ...
    @classmethod
    def conv_double_to_int64(cls, double: float) -> int:
        r"""
        X.conv_double_to_int64(double) -> int64
        Converts a float to a 64 bit integer
        
        Args:
            double (double): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def conv_color_to_linear_color(cls, color: Color) -> LinearColor:
        r"""
        X.conv_color_to_linear_color(color) -> LinearColor
        Converts a color to LinearColor
        
        Args:
            color (Color): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def conv_byte_to_int64(cls, byte: int) -> int:
        r"""
        X.conv_byte_to_int64(byte) -> int64
        Converts a byte to an integer
        
        Args:
            byte (uint8): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def conv_byte_to_int(cls, byte: int) -> int:
        r"""
        X.conv_byte_to_int(byte) -> int32
        Converts a byte to an integer
        
        Args:
            byte (uint8): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def conv_byte_to_double(cls, byte: int) -> float:
        r"""
        X.conv_byte_to_double(byte) -> double
        Converts a byte to a float
        
        Args:
            byte (uint8): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def conv_byte_to_float(cls, byte: int) -> float:
        r"""
        deprecated: 'conv_byte_to_float' was renamed to 'conv_byte_to_double'.
        """
        ...
    @classmethod
    def conv_bool_to_int(cls, bool: bool) -> int:
        r"""
        X.conv_bool_to_int(bool) -> int32
        Converts a bool to an int
        
        Args:
            bool (bool): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def conv_bool_to_double(cls, bool: bool) -> float:
        r"""
        X.conv_bool_to_double(bool) -> double
        Converts a bool to a float (0.0 or 1.0)
        
        Args:
            bool (bool): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def conv_bool_to_float(cls, bool: bool) -> float:
        r"""
        deprecated: 'conv_bool_to_float' was renamed to 'conv_bool_to_double'.
        """
        ...
    @classmethod
    def conv_bool_to_byte(cls, bool: bool) -> int:
        r"""
        X.conv_bool_to_byte(bool) -> uint8
        Converts a bool to a byte
        
        Args:
            bool (bool): 
        
        Returns:
            uint8:
        """
        ...
    @classmethod
    def compose_transforms(cls, a: Transform, b: Transform) -> Transform:
        r"""
        X.compose_transforms(a, b) -> Transform
        Compose two transforms in order: A * B.
        
        Order matters when composing transforms:
        A * B will yield a transform that logically first applies A then B to any subsequent transformation.
        
        Example: LocalToWorld = ComposeTransforms(DeltaRotation, LocalToWorld) will change rotation in local space by DeltaRotation.
        Example: LocalToWorld = ComposeTransforms(LocalToWorld, DeltaRotation) will change rotation in world space by DeltaRotation.
        
        Args:
            a (Transform): 
            b (Transform): 
        
        Returns:
            Transform: New transform: A * B
        """
        ...
    @classmethod
    def compose_rotators(cls, a: Rotator, b: Rotator) -> Rotator:
        r"""
        X.compose_rotators(a, b) -> Rotator
        Combine 2 rotations to give you the resulting rotation of first applying A, then B.
        
        Args:
            a (Rotator): 
            b (Rotator): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def class_is_child_of(cls, test_class: Class, parent_class: Class) -> bool:
        r"""
        X.class_is_child_of(test_class, parent_class) -> bool
        Determine if a class is a child of another class.
        
        Args:
            test_class (type(Class)): 
            parent_class (type(Class)): 
        
        Returns:
            bool: true if TestClass == ParentClass, or if TestClass is a child of ParentClass; false otherwise, or if either the value for either parameter is 'None'.
        """
        ...
    @classmethod
    def clamp_vector_size(cls, a: Vector, min: float, max: float) -> Vector:
        r"""
        X.clamp_vector_size(a, min, max) -> Vector
        Create a copy of this vector, with its magnitude/size/length clamped between Min and Max.
        
        Args:
            a (Vector): 
            min (double): 
            max (double): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def clamp_int64(cls, value: int, min: int, max: int) -> int:
        r"""
        X.clamp_int64(value, min, max) -> int64
        Returns Value clamped to be between A and B (inclusive)
        
        Args:
            value (int64): 
            min (int64): 
            max (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def clamp_axis(cls, angle: float) -> float:
        r"""
        X.clamp_axis(angle) -> float
        Clamps an angle to the range of [0, 360].
        
        Args:
            angle (float): The angle to clamp.
        
        Returns:
            float: The clamped angle.
        """
        ...
    @classmethod
    def clamp_axes2d(cls, a: Vector2D, min_axis_val: float, max_axis_val: float) -> Vector2D:
        r"""
        X.clamp_axes2d(a, min_axis_val, max_axis_val) -> Vector2D
        Creates a copy of this vector with both axes clamped to the given range.
        
        Args:
            a (Vector2D): 
            min_axis_val (double): 
            max_axis_val (double): 
        
        Returns:
            Vector2D: New vector with clamped axes.
        """
        ...
    @classmethod
    def clamp_angle(cls, angle_degrees: float, min_angle_degrees: float, max_angle_degrees: float) -> float:
        r"""
        X.clamp_angle(angle_degrees, min_angle_degrees, max_angle_degrees) -> double
        Clamps an arbitrary angle to be between the given angles.  Will clamp to nearest boundary.
        
        Args:
            angle_degrees (double): 
            min_angle_degrees (double): "from" angle that defines the beginning of the range of valid angles (sweeping clockwise)
            max_angle_degrees (double): "to" angle that defines the end of the range of valid angles
        
        Returns:
            double: Returns clamped angle in the range -180..180.
        """
        ...
    @classmethod
    def clamp(cls, value: int, min: int, max: int) -> int:
        r"""
        X.clamp(value, min, max) -> int32
        Returns Value clamped to be between A and B (inclusive)
        
        Args:
            value (int32): 
            min (int32): 
            max (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def c_interp_to(cls, current: LinearColor, target: LinearColor, delta_time: float, interp_speed: float) -> LinearColor:
        r"""
        X.c_interp_to(current, target, delta_time, interp_speed) -> LinearColor
        Interpolate Linear Color from Current to Target. Scaled by distance to Target, so it has a strong start speed and ease out.
        
        Args:
            current (LinearColor): Current Color
            target (LinearColor): Target Color
            delta_time (float): Time since last tick
            interp_speed (float): Interpolation speed, if the speed given is 0, then jump to the target.
        
        Returns:
            LinearColor: New interpolated Color
        """
        ...
    @classmethod
    def break_rot_into_axes(cls, rot: Rotator) -> Tuple[Vector, Vector, Vector]:
        r"""
        X.break_rot_into_axes(rot) -> (x=Vector, y=Vector, z=Vector)
        Breaks apart a rotator into its component axes
        
        Args:
            rot (Rotator): 
        
        Returns:
            tuple: 
        
            x (Vector): 
        
            y (Vector): 
        
            z (Vector):
        """
        ...
    @classmethod
    def break_color(cls, color: LinearColor) -> Tuple[float, float, float, float]:
        r"""
        X.break_color(color) -> (r=float, g=float, b=float, a=float)
        Breaks apart a color into individual RGB components (as well as alpha)
        
        Args:
            color (LinearColor): 
        
        Returns:
            tuple: 
        
            r (float): 
        
            g (float): 
        
            b (float): 
        
            a (float):
        """
        ...
    @classmethod
    def box_overlap(cls, a: Box, b: Box) -> Box:
        r"""
        X.box_overlap(a, b) -> Box
        Returns the overlap TBox<T> of two boxes
        
        Args:
            a (Box): The bounding box to test
            b (Box): The bounding box to test overlap against
        
        Returns:
            Box: the overlap box. It can be 0 if they don't overlap
        """
        ...
    @classmethod
    def box_is_point_inside(cls, box: Box, point: Vector) -> bool:
        r"""
        X.box_is_point_inside(box, point) -> bool
        Checks whether the given location is inside this box.
        note: This function assumes boxes have open bounds, i.e. points lying on the border of the box are not inside. Use IsPointInBox_Box to include borders in the test.
        
        Args:
            box (Box): The box to test
            point (Vector): The location to test for inside the bounding volume.
        
        Returns:
            bool: true if location is inside this volume.
        """
        ...
    @classmethod
    def box_is_inside_or_on(cls, inner_test: Box, outer_test: Box) -> bool:
        r"""
        X.box_is_inside_or_on(inner_test, outer_test) -> bool
        Returns true if the InnerTest Box is is completely inside or on OuterTest Box
        
        Args:
            inner_test (Box): The box to check if it is on the inside
            outer_test (Box): The box to check if InnerTest is within or on.
        
        Returns:
            bool: True if InnerTest Box is is completely inside of or on OuterTest Box
        """
        ...
    @classmethod
    def box_is_inside(cls, inner_test: Box, outer_test: Box) -> bool:
        r"""
        X.box_is_inside(inner_test, outer_test) -> bool
        Returns true if the InnerTest Box is is completely inside of the OuterTest Box
        
        Args:
            inner_test (Box): The box to check if it is on the inside
            outer_test (Box): The box to check if InnerTest is within.
        
        Returns:
            bool: True if InnerTest Box is is completely inside of OuterTest Box
        """
        ...
    @classmethod
    def box_intersects(cls, a: Box, b: Box) -> bool:
        r"""
        X.box_intersects(a, b) -> bool
        Checks whether the given bounding box A intersects this bounding box B.
        note: This function assumes boxes have closed bounds, i.e. boxes with coincident borders on any edge will overlap.
        
        Args:
            a (Box): The bounding box to check intersection against
            b (Box): The bounding box to intersect with.
        
        Returns:
            bool: true if the boxes intersect, false otherwise.
        """
        ...
    @classmethod
    def box_get_closest_point_to(cls, box: Box, point: Vector) -> Vector:
        r"""
        X.box_get_closest_point_to(box, point) -> Vector
        Calculates the closest point on or inside the box to a given point in space.
        
        Args:
            box (Box): The box to check if the point is inside of
            point (Vector): The point in space
        
        Returns:
            Vector: The closest point on or inside the box.
        """
        ...
    @classmethod
    def box_expand_by(cls, box: Box, negative: Vector, positive: Vector) -> Box:
        r"""
        X.box_expand_by(box, negative, positive) -> Box
        Returns a box of increased size.
        
        Args:
            box (Box): 
            negative (Vector): The size to increase the volume by in the negative direction (positive values move the bounds outwards)
            positive (Vector): The size to increase the volume by in the positive direction (positive values move the bounds outwards)
        
        Returns:
            Box: A new bounding box.
        """
        ...
    @classmethod
    def boolean_xor(cls, a: bool, b: bool) -> bool:
        r"""
        X.boolean_xor(a, b) -> bool
        Returns the logical eXclusive OR of two values (A XOR B)
        
        Args:
            a (bool): 
            b (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def boolean_or(cls, a: bool, b: bool) -> bool:
        r"""
        X.boolean_or(a, b) -> bool
        Returns the logical OR of two values (A OR B)
        
        Args:
            a (bool): 
            b (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def boolean_nor(cls, a: bool, b: bool) -> bool:
        r"""
        X.boolean_nor(a, b) -> bool
        Returns the logical Not OR of two values (A NOR B)
        
        Args:
            a (bool): 
            b (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def boolean_nand(cls, a: bool, b: bool) -> bool:
        r"""
        X.boolean_nand(a, b) -> bool
        Returns the logical NAND of two values (A AND B)
        
        Args:
            a (bool): 
            b (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def boolean_and(cls, a: bool, b: bool) -> bool:
        r"""
        X.boolean_and(a, b) -> bool
        Returns the logical AND of two values (A AND B)
        
        Args:
            a (bool): 
            b (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def b_min(cls, a: int, b: int) -> int:
        r"""
        X.b_min(a, b) -> uint8
        Returns the minimum value of A and B
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            uint8:
        """
        ...
    @classmethod
    def b_max(cls, a: int, b: int) -> int:
        r"""
        X.b_max(a, b) -> uint8
        Returns the maximum value of A and B
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            uint8:
        """
        ...
    @classmethod
    def average_of_int_array(cls, int_array: Array[int]) -> float:
        r"""
        X.average_of_int_array(int_array) -> float
        Returns average of all array entries. Returns value of 0 if the supplied array is empty.
        
        Args:
            int_array (Array[int32]): 
        
        Returns:
            float: 
        
            average_value (float):
        """
        ...
    @classmethod
    def atan2(cls, y: float, x: float) -> float:
        r"""
        X.atan2(y, x) -> double
        Returns the inverse tan (atan2) of A/B (result is in Radians)
        
        Args:
            y (double): 
            x (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def atan(cls, a: float) -> float:
        r"""
        X.atan(a) -> double
        Returns the inverse tan (atan) (result is in Radians)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def asin(cls, a: float) -> float:
        r"""
        X.asin(a) -> double
        Returns the inverse sine (arcsin) of A (result is in Radians)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def and_int_int(cls, a: int, b: int) -> int:
        r"""
        X.and_int_int(a, b) -> int32
        Bitwise AND (A & B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def and_int64_int64(cls, a: int, b: int) -> int:
        r"""
        X.and_int64_int64(a, b) -> int64
        Bitwise AND (A & B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def add_vector_vector(cls, a: Vector, b: Vector) -> Vector:
        r"""
        X.add_vector_vector(a, b) -> Vector
        Vector addition
        
        Args:
            a (Vector): 
            b (Vector): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def add_vector_int(cls, a: Vector, b: int) -> Vector:
        r"""
        X.add_vector_int(a, b) -> Vector
        Adds an integer to each component of a vector
        
        Args:
            a (Vector): 
            b (int32): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def add_vector_float(cls, a: Vector, b: float) -> Vector:
        r"""
        X.add_vector_float(a, b) -> Vector
        Adds a float to each component of a vector
        
        Args:
            a (Vector): 
            b (double): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def add_vector4_vector4(cls, a: Vector4, b: Vector4) -> Vector4:
        r"""
        X.add_vector4_vector4(a, b) -> Vector4
        Returns addition of Vector A and Vector B (A + B)
        
        Args:
            a (Vector4): 
            b (Vector4): 
        
        Returns:
            Vector4:
        """
        ...
    @classmethod
    def add_vector2d_vector2d(cls, a: Vector2D, b: Vector2D) -> Vector2D:
        r"""
        X.add_vector2d_vector2d(a, b) -> Vector2D
        Returns addition of Vector A and Vector B (A + B)
        
        Args:
            a (Vector2D): 
            b (Vector2D): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def add_vector2d_float(cls, a: Vector2D, b: float) -> Vector2D:
        r"""
        X.add_vector2d_float(a, b) -> Vector2D
        Returns Vector A added by B
        
        Args:
            a (Vector2D): 
            b (double): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def add_timespan_timespan(cls, a: Timespan, b: Timespan) -> Timespan:
        r"""
        X.add_timespan_timespan(a, b) -> Timespan
        Addition (A + B)
        
        Args:
            a (Timespan): 
            b (Timespan): 
        
        Returns:
            Timespan:
        """
        ...
    @classmethod
    def add_quat_quat(cls, a: Quat, b: Quat) -> Quat:
        r"""
        X.add_quat_quat(a, b) -> Quat
        Returns addition of Vector A and Vector B (A + B)
        
        Args:
            a (Quat): 
            b (Quat): 
        
        Returns:
            Quat:
        """
        ...
    @classmethod
    def add_matrix_matrix(cls, a: Matrix, b: Matrix) -> Matrix:
        r"""
        X.add_matrix_matrix(a, b) -> Matrix
        Gets the result of adding a matrix to this.
        
        Args:
            a (Matrix): 
            b (Matrix): 
        
        Returns:
            Matrix: The result of addition.
        """
        ...
    @classmethod
    def add_linear_color_linear_color(cls, a: LinearColor, b: LinearColor) -> LinearColor:
        r"""
        X.add_linear_color_linear_color(a, b) -> LinearColor
        Element-wise addition of two linear colors (R+R, G+G, B+B, A+A)
        
        Args:
            a (LinearColor): 
            b (LinearColor): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def add_int_point_int_point(cls, a: IntPoint, b: IntPoint) -> IntPoint:
        r"""
        X.add_int_point_int_point(a, b) -> IntPoint
        Returns IntPoint A added by B
        
        Args:
            a (IntPoint): 
            b (IntPoint): 
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def add_int_point_int(cls, a: IntPoint, b: int) -> IntPoint:
        r"""
        X.add_int_point_int(a, b) -> IntPoint
        Addition (A - B)
        
        Args:
            a (IntPoint): 
            b (int32): 
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def add_int_int(cls, a: int, b: int = 1) -> int:
        r"""
        X.add_int_int(a, b=1) -> int32
        Addition (A + B)
        
        Args:
            a (int32): 
            b (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def add_int64_int64(cls, a: int, b: int = 1) -> int:
        r"""
        X.add_int64_int64(a, b=1) -> int64
        Addition (A + B)
        
        Args:
            a (int64): 
            b (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def add_double_double(cls, a: float, b: float = 1.000000) -> float:
        r"""
        X.add_double_double(a, b=1.000000) -> double
        Addition (A + B)
        
        Args:
            a (double): 
            b (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def add_float_float(cls, a: float, b: float = 1.000000) -> float:
        r"""
        deprecated: 'add_float_float' was renamed to 'add_double_double'.
        """
        ...
    @classmethod
    def add_date_time_timespan(cls, a: DateTime, b: Timespan) -> DateTime:
        r"""
        X.add_date_time_timespan(a, b) -> DateTime
        Addition (A + B)
        
        Args:
            a (DateTime): 
            b (Timespan): 
        
        Returns:
            DateTime:
        """
        ...
    @classmethod
    def add_date_time_date_time(cls, a: DateTime, b: DateTime) -> DateTime:
        r"""
        X.add_date_time_date_time(a, b) -> DateTime
        Addition (A + B)
        
        Args:
            a (DateTime): 
            b (DateTime): 
        
        Returns:
            DateTime:
        """
        ...
    @classmethod
    def add_byte_byte(cls, a: int, b: int = 1) -> int:
        r"""
        X.add_byte_byte(a, b=1) -> uint8
        Addition (A + B)
        
        Args:
            a (uint8): 
            b (uint8): 
        
        Returns:
            uint8:
        """
        ...
    @classmethod
    def acos(cls, a: float) -> float:
        r"""
        X.acos(a) -> double
        Returns the inverse cosine (arccos) of A (result is in Radians)
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def abs_int64(cls, a: int) -> int:
        r"""
        X.abs_int64(a) -> int64
        Returns the absolute (positive) value of A
        
        Args:
            a (int64): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def abs_int(cls, a: int) -> int:
        r"""
        X.abs_int(a) -> int32
        Returns the absolute (positive) value of A
        
        Args:
            a (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def abs(cls, a: float) -> float:
        r"""
        X.abs(a) -> double
        Returns the absolute (positive) value of A
        
        Args:
            a (double): 
        
        Returns:
            double:
        """
        ...

class RenderingLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet Rendering Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetRenderingLibrary.h
    
    """
    @classmethod
    def set_cast_inset_shadow_for_all_attachments(cls, primitive_component: PrimitiveComponent, cast_inset_shadow: bool, light_attachments_as_group: bool) -> None:
        r"""
        X.set_cast_inset_shadow_for_all_attachments(primitive_component, cast_inset_shadow, light_attachments_as_group) -> None
        Set the inset shadow casting state of the given component and all its child attachments.
            Also choose if all attachments should be grouped for the inset shadow rendering. If enabled, one depth target will be shared for all attachments.
        
        Args:
            primitive_component (PrimitiveComponent): 
            cast_inset_shadow (bool): 
            light_attachments_as_group (bool):
        """
        ...
    @classmethod
    def resize_render_target2d(cls, texture_render_target: TextureRenderTarget2D, width: int = 256, height: int = 256) -> None:
        r"""
        X.resize_render_target2d(texture_render_target, width=256, height=256) -> None
        Changes the resolution of a render target. This is useful for when you need to resize the game viewport or change the in-game resolution during runtime
        and thus need to update the sizes of all the render targets in the game accordingly.
        
        Args:
            texture_render_target (TextureRenderTarget2D): 
            width (int32): 
            height (int32):
        """
        ...
    @classmethod
    def render_target_create_static_volume_texture_editor_only(cls, render_target: TextureRenderTargetVolume, name: str = "Texture", compression_settings: TextureCompressionSettings = TextureCompressionSettings.TC_DEFAULT, mip_settings: TextureMipGenSettings = TextureMipGenSettings.TMGS_FROM_TEXTURE_GROUP) -> VolumeTexture:
        r"""
        X.render_target_create_static_volume_texture_editor_only(render_target, name="Texture", compression_settings=TextureCompressionSettings.TC_DEFAULT, mip_settings=TextureMipGenSettings.TMGS_FROM_TEXTURE_GROUP) -> VolumeTexture
        Creates a new Static Volume Texture from a Render Target Volume.
        Only works in the editor
        
        Args:
            render_target (TextureRenderTargetVolume): 
            name (str): 
            compression_settings (TextureCompressionSettings): 
            mip_settings (TextureMipGenSettings): 
        
        Returns:
            VolumeTexture:
        """
        ...
    @classmethod
    def render_target_create_static_texture_cube_editor_only(cls, render_target: TextureRenderTargetCube, name: str = "Texture", compression_settings: TextureCompressionSettings = TextureCompressionSettings.TC_DEFAULT, mip_settings: TextureMipGenSettings = TextureMipGenSettings.TMGS_FROM_TEXTURE_GROUP) -> TextureCube:
        r"""
        X.render_target_create_static_texture_cube_editor_only(render_target, name="Texture", compression_settings=TextureCompressionSettings.TC_DEFAULT, mip_settings=TextureMipGenSettings.TMGS_FROM_TEXTURE_GROUP) -> TextureCube
        Creates a new Static Texture Cube from a Render Target Cube.
        Only works in the editor
        
        Args:
            render_target (TextureRenderTargetCube): 
            name (str): 
            compression_settings (TextureCompressionSettings): 
            mip_settings (TextureMipGenSettings): 
        
        Returns:
            TextureCube:
        """
        ...
    @classmethod
    def render_target_create_static_texture2d_editor_only(cls, render_target: TextureRenderTarget2D, name: str = "Texture", compression_settings: TextureCompressionSettings = TextureCompressionSettings.TC_DEFAULT, mip_settings: TextureMipGenSettings = TextureMipGenSettings.TMGS_FROM_TEXTURE_GROUP) -> Texture2D:
        r"""
        X.render_target_create_static_texture2d_editor_only(render_target, name="Texture", compression_settings=TextureCompressionSettings.TC_DEFAULT, mip_settings=TextureMipGenSettings.TMGS_FROM_TEXTURE_GROUP) -> Texture2D
        Creates a new Static Texture from a Render Target 2D.
        Only works in the editor
        
        Args:
            render_target (TextureRenderTarget2D): 
            name (str): 
            compression_settings (TextureCompressionSettings): 
            mip_settings (TextureMipGenSettings): 
        
        Returns:
            Texture2D:
        """
        ...
    @classmethod
    def render_target_create_static_texture2d_array_editor_only(cls, render_target: TextureRenderTarget2DArray, name: str = "Texture", compression_settings: TextureCompressionSettings = TextureCompressionSettings.TC_DEFAULT, mip_settings: TextureMipGenSettings = TextureMipGenSettings.TMGS_FROM_TEXTURE_GROUP) -> Texture2DArray:
        r"""
        X.render_target_create_static_texture2d_array_editor_only(render_target, name="Texture", compression_settings=TextureCompressionSettings.TC_DEFAULT, mip_settings=TextureMipGenSettings.TMGS_FROM_TEXTURE_GROUP) -> Texture2DArray
        Creates a new Static Texture 2D Array from a Render Target 2D Array.
        Only works in the editor
        
        Args:
            render_target (TextureRenderTarget2DArray): 
            name (str): 
            compression_settings (TextureCompressionSettings): 
            mip_settings (TextureMipGenSettings): 
        
        Returns:
            Texture2DArray:
        """
        ...
    @classmethod
    def release_render_target2d(cls, texture_render_target: TextureRenderTarget2D) -> None:
        r"""
        X.release_render_target2d(texture_render_target) -> None
        Manually releases GPU resources of a render target. This is useful for blueprint creating a lot of render target that would
        normally be released too late by the garbage collector that can be problematic on platforms that have tight GPU memory constrains.
        
        Args:
            texture_render_target (TextureRenderTarget2D):
        """
        ...
    @classmethod
    def refresh_path_tracing_output(cls) -> None:
        r"""
        X.refresh_path_tracing_output() -> None
        Forces the path tracer to restart sample accumulation.
        This can be used to force the path tracer to compute a new frame in situations where it can not detect a change in the scene automatically.
        """
        ...
    @classmethod
    def read_render_target_uv(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D, u: float, v: float) -> Color:
        r"""
        X.read_render_target_uv(world_context_object, texture_render_target, u, v) -> Color
        Incredibly inefficient and slow operation! Read a value as sRGB color from a render target using UV [0,1]x[0,1] coordinates.
        LDR render targets are assumed to be in sRGB space. HDR ones are assumed to be in linear space.
        Result is 8-bit per channel [0,255] BGRA in sRGB space.
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
            u (float): 
            v (float): 
        
        Returns:
            Color:
        """
        ...
    @classmethod
    def read_render_target_raw_uv_area(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D, area: Box2D, normalize: bool = True) -> Array[LinearColor]:
        r"""
        X.read_render_target_raw_uv_area(world_context_object, texture_render_target, area, normalize=True) -> Array[LinearColor]
        Incredibly inefficient and slow operation! Read an area of values as-is from a render target using a rectangle defined by UV [0,1]x[0,1] coordinates.
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
            area (Box2D): 
            normalize (bool): 
        
        Returns:
            Array[LinearColor]:
        """
        ...
    @classmethod
    def read_render_target_raw_uv(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D, u: float, v: float, normalize: bool = True) -> LinearColor:
        r"""
        X.read_render_target_raw_uv(world_context_object, texture_render_target, u, v, normalize=True) -> LinearColor
        Incredibly inefficient and slow operation! Read a value as-is from a render target using UV [0,1]x[0,1] coordinates.
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
            u (float): 
            v (float): 
            normalize (bool): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def read_render_target_raw_pixel_area(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D, min_x: int, min_y: int, max_x: int, max_y: int, normalize: bool = True) -> Array[LinearColor]:
        r"""
        X.read_render_target_raw_pixel_area(world_context_object, texture_render_target, min_x, min_y, max_x, max_y, normalize=True) -> Array[LinearColor]
        Incredibly inefficient and slow operation! Read an area of values as-is from a render target using a rectangle defined by integer pixel coordinates.
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
            min_x (int32): 
            min_y (int32): 
            max_x (int32): 
            max_y (int32): 
            normalize (bool): 
        
        Returns:
            Array[LinearColor]:
        """
        ...
    @classmethod
    def read_render_target_raw_pixel(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D, x: int, y: int, normalize: bool = True) -> LinearColor:
        r"""
        X.read_render_target_raw_pixel(world_context_object, texture_render_target, x, y, normalize=True) -> LinearColor
        Incredibly inefficient and slow operation! Read a value as-is from a render target using integer pixel coordinates.
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
            x (int32): 
            y (int32): 
            normalize (bool): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def read_render_target_raw(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D, normalize: bool = True) -> Optional[Array[LinearColor]]:
        r"""
        X.read_render_target_raw(world_context_object, texture_render_target, normalize=True) -> Array[LinearColor] or None
        Incredibly inefficient and slow operation! Read entire texture as-is from a render target.
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
            normalize (bool): 
        
        Returns:
            Array[LinearColor] or None: 
        
            out_linear_samples (Array[LinearColor]):
        """
        ...
    @classmethod
    def read_render_target_pixel(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D, x: int, y: int) -> Color:
        r"""
        X.read_render_target_pixel(world_context_object, texture_render_target, x, y) -> Color
        Incredibly inefficient and slow operation! Read a value as sRGB color from a render target using integer pixel coordinates.
        LDR render targets are assumed to be in sRGB space. HDR ones are assumed to be in linear space.
        Result is 8-bit per channel [0,255] BGRA in sRGB space.
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
            x (int32): 
            y (int32): 
        
        Returns:
            Color:
        """
        ...
    @classmethod
    def read_render_target(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D, normalize: bool = True) -> Optional[Array[Color]]:
        r"""
        X.read_render_target(world_context_object, texture_render_target, normalize=True) -> Array[Color] or None
        Incredibly inefficient and slow operation! Reads entire render target as sRGB color and returns a linear array of sRGB colors.
        LDR render targets are assumed to be in sRGB space. HDR ones are assumed to be in linear space.
        Result whether the operation succeeded.  If successful, OutSamples will an entry per pixel, where each is 8-bit per channel [0,255] BGRA in sRGB space.
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
            normalize (bool): 
        
        Returns:
            Array[Color] or None: 
        
            out_samples (Array[Color]):
        """
        ...
    @classmethod
    def import_file_as_texture2d(cls, world_context_object: Object, filename: str) -> Texture2D:
        r"""
        X.import_file_as_texture2d(world_context_object, filename) -> Texture2D
        Imports a texture file from disk and creates Texture2D from it.
        
        Args:
            world_context_object (Object): 
            filename (str): 
        
        Returns:
            Texture2D:
        """
        ...
    @classmethod
    def import_buffer_as_texture2d(cls, world_context_object: Object, buffer: Array[int]) -> Texture2D:
        r"""
        X.import_buffer_as_texture2d(world_context_object, buffer) -> Texture2D
        Imports a texture from a buffer and creates Texture2D from it.
        
        Args:
            world_context_object (Object): 
            buffer (Array[uint8]): 
        
        Returns:
            Texture2D:
        """
        ...
    @classmethod
    def export_texture2d(cls, world_context_object: Object, texture: Texture2D, file_path: str, file_name: str) -> None:
        r"""
        X.export_texture2d(world_context_object, texture, file_path, file_name) -> None
        Exports a Texture2D as a HDR image onto the disk.
        
        Args:
            world_context_object (Object): 
            texture (Texture2D): 
            file_path (str): 
            file_name (str):
        """
        ...
    @classmethod
    def export_render_target(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D, file_path: str, file_name: str) -> None:
        r"""
        X.export_render_target(world_context_object, texture_render_target, file_path, file_name) -> None
        Exports a render target as a HDR or PNG image onto the disk (depending on the format of the render target)
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
            file_path (str): 
            file_name (str):
        """
        ...
    @classmethod
    def end_draw_canvas_to_render_target(cls, world_context_object: Object, context: DrawToRenderTargetContext) -> None:
        r"""
        X.end_draw_canvas_to_render_target(world_context_object, context) -> None
        Must be paired with a BeginDrawCanvasToRenderTarget to complete rendering to a render target.
        
        Args:
            world_context_object (Object): 
            context (DrawToRenderTargetContext):
        """
        ...
    @classmethod
    def enable_path_tracing(cls, enable_path_tracer: bool) -> None:
        r"""
        X.enable_path_tracing(enable_path_tracer) -> None
        Enables or disables the path tracer for the current Game Viewport.
        This command is equivalent to setting ShowFlag.PathTracing, but is accessible even from shipping builds.
        
        Args:
            enable_path_tracer (bool):
        """
        ...
    @classmethod
    def draw_material_to_render_target(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D, material: MaterialInterface) -> None:
        r"""
        X.draw_material_to_render_target(world_context_object, texture_render_target, material) -> None
        Renders a quad with the material applied to the specified render target.
        This sets the render target even if it is already set, which is an expensive operation.
        Use BeginDrawCanvasToRenderTarget / EndDrawCanvasToRenderTarget instead if rendering multiple primitives to the same render target.
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
            material (MaterialInterface):
        """
        ...
    @classmethod
    def create_render_target_volume(cls, world_context_object: Object, width: int = 16, height: int = 16, depth: int = 16, format: TextureRenderTargetFormat = TextureRenderTargetFormat.RTF_RGBA16F, clear_color: LinearColor = [0.000000, 0.000000, 0.000000, 1.000000], auto_generate_mip_maps: bool = False, support_ua_vs: bool = False) -> TextureRenderTargetVolume:
        r"""
        X.create_render_target_volume(world_context_object, width=16, height=16, depth=16, format=TextureRenderTargetFormat.RTF_RGBA16F, clear_color=[0.000000, 0.000000, 0.000000, 1.000000], auto_generate_mip_maps=False, support_ua_vs=False) -> TextureRenderTargetVolume
        Creates a new volume render target and initializes it to the specified dimensions
        
        Args:
            world_context_object (Object): 
            width (int32): 
            height (int32): 
            depth (int32): 
            format (TextureRenderTargetFormat): 
            clear_color (LinearColor): 
            auto_generate_mip_maps (bool): 
            support_ua_vs (bool): 
        
        Returns:
            TextureRenderTargetVolume:
        """
        ...
    @classmethod
    def create_render_target2d_array(cls, world_context_object: Object, width: int = 256, height: int = 256, slices: int = 1, format: TextureRenderTargetFormat = TextureRenderTargetFormat.RTF_RGBA16F, clear_color: LinearColor = [0.000000, 0.000000, 0.000000, 1.000000], auto_generate_mip_maps: bool = False, support_ua_vs: bool = False) -> TextureRenderTarget2DArray:
        r"""
        X.create_render_target2d_array(world_context_object, width=256, height=256, slices=1, format=TextureRenderTargetFormat.RTF_RGBA16F, clear_color=[0.000000, 0.000000, 0.000000, 1.000000], auto_generate_mip_maps=False, support_ua_vs=False) -> TextureRenderTarget2DArray
        Creates a new render target array and initializes it to the specified dimensions
        
        Args:
            world_context_object (Object): 
            width (int32): 
            height (int32): 
            slices (int32): 
            format (TextureRenderTargetFormat): 
            clear_color (LinearColor): 
            auto_generate_mip_maps (bool): 
            support_ua_vs (bool): 
        
        Returns:
            TextureRenderTarget2DArray:
        """
        ...
    @classmethod
    def create_render_target2d(cls, world_context_object: Object, width: int = 256, height: int = 256, format: TextureRenderTargetFormat = TextureRenderTargetFormat.RTF_RGBA16F, clear_color: LinearColor = [0.000000, 0.000000, 0.000000, 1.000000], auto_generate_mip_maps: bool = False, support_ua_vs: bool = False) -> TextureRenderTarget2D:
        r"""
        X.create_render_target2d(world_context_object, width=256, height=256, format=TextureRenderTargetFormat.RTF_RGBA16F, clear_color=[0.000000, 0.000000, 0.000000, 1.000000], auto_generate_mip_maps=False, support_ua_vs=False) -> TextureRenderTarget2D
        Creates a new render target and initializes it to the specified dimensions
        
        Args:
            world_context_object (Object): 
            width (int32): 
            height (int32): 
            format (TextureRenderTargetFormat): 
            clear_color (LinearColor): 
            auto_generate_mip_maps (bool): 
            support_ua_vs (bool): 
        
        Returns:
            TextureRenderTarget2D:
        """
        ...
    @classmethod
    def convert_render_target_to_texture_volume_editor_only(cls, world_context_object: Object, render_target: TextureRenderTargetVolume, texture: VolumeTexture) -> None:
        r"""
        X.convert_render_target_to_texture_volume_editor_only(world_context_object, render_target, texture) -> None
        Copies the contents of a UTextureRenderTargetVolume to a UVolumeTexture
        Only works in the editor
        
        Args:
            world_context_object (Object): 
            render_target (TextureRenderTargetVolume): 
            texture (VolumeTexture):
        """
        ...
    @classmethod
    def convert_render_target_to_texture_cube_editor_only(cls, world_context_object: Object, render_target: TextureRenderTargetCube, texture: TextureCube) -> None:
        r"""
        X.convert_render_target_to_texture_cube_editor_only(world_context_object, render_target, texture) -> None
        Copies the contents of a UTextureRenderTargetCube to a UTextureCube
        Only works in the editor
        
        Args:
            world_context_object (Object): 
            render_target (TextureRenderTargetCube): 
            texture (TextureCube):
        """
        ...
    @classmethod
    def convert_render_target_to_texture2d_editor_only(cls, world_context_object: Object, render_target: TextureRenderTarget2D, texture: Texture2D) -> None:
        r"""
        X.convert_render_target_to_texture2d_editor_only(world_context_object, render_target, texture) -> None
        Copies the contents of a UTextureRenderTarget2D to a UTexture2D
        Only works in the editor
        
        Args:
            world_context_object (Object): 
            render_target (TextureRenderTarget2D): 
            texture (Texture2D):
        """
        ...
    @classmethod
    def convert_render_target_to_texture2d_array_editor_only(cls, world_context_object: Object, render_target: TextureRenderTarget2DArray, texture: Texture2DArray) -> None:
        r"""
        X.convert_render_target_to_texture2d_array_editor_only(world_context_object, render_target, texture) -> None
        Copies the contents of a UTextureRenderTarget2DArray to a UTexture2DArray
        Only works in the editor
        
        Args:
            world_context_object (Object): 
            render_target (TextureRenderTarget2DArray): 
            texture (Texture2DArray):
        """
        ...
    @classmethod
    def clear_render_target2d(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D, clear_color: LinearColor = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        r"""
        X.clear_render_target2d(world_context_object, texture_render_target, clear_color=[0.000000, 0.000000, 0.000000, 1.000000]) -> None
        Clears the specified render target with the given ClearColor.
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
            clear_color (LinearColor):
        """
        ...
    @classmethod
    def calculate_projection_matrix(cls, minimal_view_info: MinimalViewInfo) -> Matrix:
        r"""
        X.calculate_projection_matrix(minimal_view_info) -> Matrix
        Calculates the projection matrix using this view info's aspect ratio (regardless of bConstrainAspectRatio)
        
        Args:
            minimal_view_info (MinimalViewInfo): 
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def begin_draw_canvas_to_render_target(cls, world_context_object: Object, texture_render_target: TextureRenderTarget2D) -> Tuple[Canvas, Vector2D, DrawToRenderTargetContext]:
        r"""
        X.begin_draw_canvas_to_render_target(world_context_object, texture_render_target) -> (canvas=Canvas, size=Vector2D, context=DrawToRenderTargetContext)
        Returns a Canvas object that can be used to draw to the specified render target.
        Canvas has functions like DrawMaterial with size parameters that can be used to draw to a specific area of a render target.
        Be sure to call EndDrawCanvasToRenderTarget to complete the rendering!
        
        Args:
            world_context_object (Object): 
            texture_render_target (TextureRenderTarget2D): 
        
        Returns:
            tuple: 
        
            canvas (Canvas): 
        
            size (Vector2D): 
        
            context (DrawToRenderTargetContext):
        """
        ...

class StringLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet String Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetStringLibrary.h
    
    """
    @classmethod
    def trim_trailing(cls, source_string: str) -> str:
        r"""
        X.trim_trailing(source_string) -> str
        Removes trailing whitespace characters
        
        Args:
            source_string (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def trim(cls, source_string: str) -> str:
        r"""
        X.trim(source_string) -> str
        Removes whitespace characters from the front of this string.
        
        Args:
            source_string (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def to_upper(cls, source_string: str) -> str:
        r"""
        X.to_upper(source_string) -> str
        Returns a string converted to Upper case
        
        Args:
            source_string (str): The string to convert
        
        Returns:
            str: The string in upper case
        """
        ...
    @classmethod
    def to_lower(cls, source_string: str) -> str:
        r"""
        X.to_lower(source_string) -> str
        Returns a string converted to Lower case
        
        Args:
            source_string (str): The string to convert
        
        Returns:
            str: The string in lower case
        """
        ...
    @classmethod
    def time_seconds_to_string(cls, seconds: float) -> str:
        r"""
        X.time_seconds_to_string(seconds) -> str
        Convert a number of seconds into minutes:seconds.milliseconds format string (including leading zeroes)
        
        Args:
            seconds (float): 
        
        Returns:
            str: A new string built from the seconds parameter
        """
        ...
    @classmethod
    def starts_with(cls, source_string: str, prefix: str, search_case: SearchCase = SearchCase.IGNORE_CASE) -> bool:
        r"""
        X.starts_with(source_string, prefix, search_case=SearchCase.IGNORE_CASE) -> bool
        Test whether this string starts with given string.
        
        Args:
            source_string (str): 
            prefix (str): 
            search_case (SearchCase): Indicates whether the search is case sensitive or not ( defaults to ESearchCase::IgnoreCase )
        
        Returns:
            bool: true if this string begins with specified text, false otherwise
        """
        ...
    @classmethod
    def split(cls, source_string: str, str: str, search_case: SearchCase = SearchCase.IGNORE_CASE, search_dir: SearchDir = SearchDir.FROM_START) -> Optional[Tuple[str, str]]:
        r"""
        X.split(source_string, str, search_case=SearchCase.IGNORE_CASE, search_dir=SearchDir.FROM_START) -> (left_s=str, right_s=str) or None
        Splits this string at given string position case sensitive.
        
        Args:
            source_string (str): 
            str (str): The string to search and split at
            search_case (SearchCase): Indicates whether the search is case sensitive or not ( defaults to ESearchCase::IgnoreCase )
            search_dir (SearchDir): Indicates whether the search starts at the begining or at the end ( defaults to ESearchDir::FromStart )
        
        Returns:
            tuple or None: true if string is split, otherwise false
        
            left_s (str): out the string to the left of InStr, not updated if return is false
        
            right_s (str): out the string to the right of InStr, not updated if return is false
        """
        ...
    @classmethod
    def right_pad(cls, source_string: str, ch_count: int) -> str:
        r"""
        X.right_pad(source_string, ch_count) -> str
        * Pad the right of this string for a specified number of characters
        *
        
        Args:
            source_string (str): The string to pad *
            ch_count (int32): Amount of padding required *
        
        Returns:
            str: The padded string
        """
        ...
    @classmethod
    def right_chop(cls, source_string: str, count: int) -> str:
        r"""
        X.right_chop(source_string, count) -> str
        Returns the string to the right of the specified location, counting forward from the left (from the beginning of the word).
        
        Args:
            source_string (str): 
            count (int32): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def right(cls, source_string: str, count: int) -> str:
        r"""
        X.right(source_string, count) -> str
        Returns the string to the right of the specified location, counting back from the right (end of the word).
        
        Args:
            source_string (str): 
            count (int32): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def reverse(cls, source_string: str) -> str:
        r"""
        X.reverse(source_string) -> str
        Returns a copy of this string, with the characters in reverse order
        
        Args:
            source_string (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def replace_inline(cls, source_string: str, search_text: str, replacement_text: str, search_case: SearchCase = SearchCase.IGNORE_CASE) -> Tuple[int, str]:
        r"""
        X.replace_inline(source_string, search_text, replacement_text, search_case=SearchCase.IGNORE_CASE) -> (int32, source_string=str)
        Replace all occurrences of SearchText with ReplacementText in this string.
        
        Args:
            source_string (str): 
            search_text (str): the text that should be removed from this string
            replacement_text (str): the text to insert in its place
            search_case (SearchCase): Indicates whether the search is case sensitive or not ( defaults to ESearchCase::IgnoreCase )
        
        Returns:
            str: the number of occurrences of SearchText that were replaced.
        
            source_string (str):
        """
        ...
    @classmethod
    def replace(cls, source_string: str, from_: str, to: str, search_case: SearchCase = SearchCase.IGNORE_CASE) -> str:
        r"""
        X.replace(source_string, from_, to, search_case=SearchCase.IGNORE_CASE) -> str
        Replace all occurrences of a substring in this string
        
        Args:
            source_string (str): 
            from_ (str): substring to replace
            to (str): substring to replace From with
            search_case (SearchCase): Indicates whether the search is case sensitive or not ( defaults to ESearchCase::IgnoreCase )
        
        Returns:
            str: a copy of this string with the replacement made
        """
        ...
    @classmethod
    def parse_into_array(cls, source_string: str, delimiter: str = " ", cull_empty_strings: bool = True) -> Array[str]:
        r"""
        X.parse_into_array(source_string, delimiter=" ", cull_empty_strings=True) -> Array[str]
        Gets an array of strings from a source string divided up by a separator and empty strings can optionally be culled.
        
        Args:
            source_string (str): The string to chop up
            delimiter (str): The string to delimit on
            cull_empty_strings (bool): = true - Cull (true) empty strings or add them to the array (false)
        
        Returns:
            Array[str]: The array of string that have been separated
        """
        ...
    @classmethod
    def not_equal_str_str(cls, a: str, b: str) -> bool:
        r"""
        X.not_equal_str_str(a, b) -> bool
        Test if the input string are not equal (A != B)
        
        Args:
            a (str): The string to compare against
            b (str): The string to compare
        
        Returns:
            bool: Returns true if the input strings are not equal, false if they are equal
        """
        ...
    @classmethod
    def not_equal_stri_stri(cls, a: str, b: str) -> bool:
        r"""
        X.not_equal_stri_stri(a, b) -> bool
        Test if the input string are not equal (A != B), ignoring case differences
        
        Args:
            a (str): The string to compare against
            b (str): The string to compare
        
        Returns:
            bool: Returns true if the input strings are not equal, false if they are equal
        """
        ...
    @classmethod
    def mid(cls, source_string: str, start: int, count: int) -> str:
        r"""
        X.mid(source_string, start, count) -> str
        Returns the substring from Start position for Count characters.
        
        Args:
            source_string (str): 
            start (int32): 
            count (int32): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def matches_wildcard(cls, source_string: str, wildcard: str, search_case: SearchCase = SearchCase.IGNORE_CASE) -> bool:
        r"""
        X.matches_wildcard(source_string, wildcard, search_case=SearchCase.IGNORE_CASE) -> bool
        Searches this string for a given wild card
        warning: This is a simple, SLOW routine. Use with caution
        
        Args:
            source_string (str): 
            wildcard (str): *?-type wildcard
            search_case (SearchCase): Indicates whether the search is case sensitive or not ( defaults to ESearchCase::IgnoreCase )
        
        Returns:
            bool: true if this string matches the *?-type wildcard given.
        """
        ...
    @classmethod
    def len(cls, s: str) -> int:
        r"""
        X.len(s) -> int32
        Returns the number of characters in the string
        
        Args:
            s (str): 
        
        Returns:
            int32: The number of chars in the string
        """
        ...
    @classmethod
    def left_pad(cls, source_string: str, ch_count: int) -> str:
        r"""
        X.left_pad(source_string, ch_count) -> str
        * Pad the left of this string for a specified number of characters
        *
        
        Args:
            source_string (str): The string to pad *
            ch_count (int32): Amount of padding required *
        
        Returns:
            str: The padded string
        """
        ...
    @classmethod
    def left_chop(cls, source_string: str, count: int) -> str:
        r"""
        X.left_chop(source_string, count) -> str
        Returns the left most characters from the string chopping the given number of characters from the end
        
        Args:
            source_string (str): 
            count (int32): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def left(cls, source_string: str, count: int) -> str:
        r"""
        X.left(source_string, count) -> str
        Returns the left most given number of characters
        
        Args:
            source_string (str): 
            count (int32): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def join_string_array(cls, source_array: Array[str], separator: str = " ") -> str:
        r"""
        X.join_string_array(source_array, separator=" ") -> str
        Concatenates an array of strings into a single string.
        
        Args:
            source_array (Array[str]): The array of strings to concatenate.
            separator (str): The string used to separate each element.
        
        Returns:
            str: The final, joined, separated string.
        """
        ...
    @classmethod
    def is_numeric(cls, source_string: str) -> bool:
        r"""
        X.is_numeric(source_string) -> bool
        * Checks if a string contains only numeric characters
        *
        
        Args:
            source_string (str): The string to check *
        
        Returns:
            bool: true if the string only contains numeric characters
        """
        ...
    @classmethod
    def is_empty(cls, string: str) -> bool:
        r"""
        X.is_empty(string) -> bool
        Returns true if the string is empty
        
        Args:
            string (str): The string to check
        
        Returns:
            bool: Whether or not the string is empty
        """
        ...
    @classmethod
    def get_substring(cls, source_string: str, start_index: int = 0, length: int = 1) -> str:
        r"""
        X.get_substring(source_string, start_index=0, length=1) -> str
        Returns a substring from the string starting at the specified position
        
        Args:
            source_string (str): The string to get the substring from
            start_index (int32): The location in SourceString to use as the start of the substring
            length (int32): The length of the requested substring
        
        Returns:
            str: The requested substring
        """
        ...
    @classmethod
    def get_character_as_number(cls, source_string: str, index: int = 0) -> int:
        r"""
        X.get_character_as_number(source_string, index=0) -> int32
        Gets a single character from the string (as an integer)
        
        Args:
            source_string (str): The string to convert
            index (int32): Location of the character whose value is required
        
        Returns:
            int32: The integer value of the character or 0 if index is out of range
        """
        ...
    @classmethod
    def get_character_array_from_string(cls, source_string: str) -> Array[str]:
        r"""
        X.get_character_array_from_string(source_string) -> Array[str]
        Returns an array that contains one entry for each character in SourceString
        
        Args:
            source_string (str): The string to break apart into characters
        
        Returns:
            Array[str]: An array containing one entry for each character in SourceString
        """
        ...
    @classmethod
    def find_substring(cls, search_in: str, substring: str, use_case: bool = False, search_from_end: bool = False, start_position: int = -1) -> int:
        r"""
        X.find_substring(search_in, substring, use_case=False, search_from_end=False, start_position=-1) -> int32
        Finds the starting index of a substring in the a specified string
        
        Args:
            search_in (str): The string to search within
            substring (str): The string to look for in the SearchIn string
            use_case (bool): Whether or not to be case-sensitive
            search_from_end (bool): Whether or not to start the search from the end of the string instead of the beginning
            start_position (int32): The position to start the search from
        
        Returns:
            int32: The index (starting from 0 if bSearchFromEnd is false) of the first occurence of the substring
        """
        ...
    @classmethod
    def equal_equal_str_str(cls, a: str, b: str) -> bool:
        r"""
        X.equal_equal_str_str(a, b) -> bool
        Test if the input strings are equal (A == B)
        
        Args:
            a (str): The string to compare against
            b (str): The string to compare
        
        Returns:
            bool: True if the strings are equal, false otherwise
        """
        ...
    @classmethod
    def equal_equal_stri_stri(cls, a: str, b: str) -> bool:
        r"""
        X.equal_equal_stri_stri(a, b) -> bool
        Test if the input strings are equal (A == B), ignoring case
        
        Args:
            a (str): The string to compare against
            b (str): The string to compare
        
        Returns:
            bool: True if the strings are equal, false otherwise
        """
        ...
    @classmethod
    def ends_with(cls, source_string: str, suffix: str, search_case: SearchCase = SearchCase.IGNORE_CASE) -> bool:
        r"""
        X.ends_with(source_string, suffix, search_case=SearchCase.IGNORE_CASE) -> bool
        Test whether this string ends with given string.
        
        Args:
            source_string (str): 
            suffix (str): 
            search_case (SearchCase): Indicates whether the search is case sensitive or not ( defaults to ESearchCase::IgnoreCase )
        
        Returns:
            bool: true if this string ends with specified text, false otherwise
        """
        ...
    @classmethod
    def cull_array(cls, source_string: str) -> Tuple[int, Array[str]]:
        r"""
        X.cull_array(source_string) -> (int32, array=Array[str])
        Takes an array of strings and removes any zero length entries.
        
        Args:
            source_string (str): 
        
        Returns:
            Array[str]: The number of elements left in InArray
        
            array (Array[str]): The array to cull
        """
        ...
    @classmethod
    def conv_vector_to_string(cls, vec: Vector) -> str:
        r"""
        X.conv_vector_to_string(vec) -> str
        Converts a vector value to a string, in the form 'X= Y= Z='
        
        Args:
            vec (Vector): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_vector3f_to_string(cls, vec: Vector3f) -> str:
        r"""
        X.conv_vector3f_to_string(vec) -> str
        Converts a float vector value to a string, in the form 'X= Y= Z='
        
        Args:
            vec (Vector3f): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_vector2d_to_string(cls, vec: Vector2D) -> str:
        r"""
        X.conv_vector2d_to_string(vec) -> str
        Converts a vector2d value to a string, in the form 'X= Y='
        
        Args:
            vec (Vector2D): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_transform_to_string(cls, trans: Transform) -> str:
        r"""
        X.conv_transform_to_string(trans) -> str
        Converts a transform value to a string, in the form 'Translation: X= Y= Z= Rotation: P= Y= R= Scale: X= Y= Z='
        
        Args:
            trans (Transform): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_string_to_vector3f(cls, string: str) -> Tuple[Vector3f, bool]:
        r"""
        X.conv_string_to_vector3f(string) -> (out_converted_vector=Vector3f, out_is_valid=bool)
        Convert String Back To Float Vector. IsValid indicates whether or not the string could be successfully converted.
        
        Args:
            string (str): 
        
        Returns:
            tuple: 
        
            out_converted_vector (Vector3f): 
        
            out_is_valid (bool):
        """
        ...
    @classmethod
    def conv_string_to_vector2d(cls, string: str) -> Tuple[Vector2D, bool]:
        r"""
        X.conv_string_to_vector2d(string) -> (out_converted_vector2d=Vector2D, out_is_valid=bool)
        Convert String Back To Vector2D. IsValid indicates whether or not the string could be successfully converted.
        
        Args:
            string (str): 
        
        Returns:
            tuple: 
        
            out_converted_vector2d (Vector2D): 
        
            out_is_valid (bool):
        """
        ...
    @classmethod
    def conv_string_to_vector(cls, string: str) -> Tuple[Vector, bool]:
        r"""
        X.conv_string_to_vector(string) -> (out_converted_vector=Vector, out_is_valid=bool)
        Convert String Back To Vector. IsValid indicates whether or not the string could be successfully converted.
        
        Args:
            string (str): 
        
        Returns:
            tuple: 
        
            out_converted_vector (Vector): 
        
            out_is_valid (bool):
        """
        ...
    @classmethod
    def conv_string_to_rotator(cls, string: str) -> Tuple[Rotator, bool]:
        r"""
        X.conv_string_to_rotator(string) -> (out_converted_rotator=Rotator, out_is_valid=bool)
        Convert String Back To Rotator. IsValid indicates whether or not the string could be successfully converted.
        
        Args:
            string (str): 
        
        Returns:
            tuple: 
        
            out_converted_rotator (Rotator): 
        
            out_is_valid (bool):
        """
        ...
    @classmethod
    def conv_string_to_name(cls, string: str) -> Name:
        r"""
        X.conv_string_to_name(string) -> Name
        Converts a string to a name value
        
        Args:
            string (str): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def conv_string_to_int64(cls, string: str) -> int:
        r"""
        X.conv_string_to_int64(string) -> int64
        Converts a string to a int value
        
        Args:
            string (str): 
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def conv_string_to_int(cls, string: str) -> int:
        r"""
        X.conv_string_to_int(string) -> int32
        Converts a string to a int value
        
        Args:
            string (str): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def conv_string_to_double(cls, string: str) -> float:
        r"""
        X.conv_string_to_double(string) -> double
        Converts a string to a double value
        
        Args:
            string (str): 
        
        Returns:
            double:
        """
        ...
    @classmethod
    def conv_string_to_float(cls, string: str) -> float:
        r"""
        deprecated: 'conv_string_to_float' was renamed to 'conv_string_to_double'.
        """
        ...
    @classmethod
    def conv_string_to_color(cls, string: str) -> Tuple[LinearColor, bool]:
        r"""
        X.conv_string_to_color(string) -> (out_converted_color=LinearColor, out_is_valid=bool)
        Convert String Back To Color. IsValid indicates whether or not the string could be successfully converted.
        
        Args:
            string (str): 
        
        Returns:
            tuple: 
        
            out_converted_color (LinearColor): 
        
            out_is_valid (bool):
        """
        ...
    @classmethod
    def conv_rotator_to_string(cls, rot: Rotator) -> str:
        r"""
        X.conv_rotator_to_string(rot) -> str
        Converts a rotator value to a string, in the form 'P= Y= R='
        
        Args:
            rot (Rotator): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_platform_user_id_to_string(cls, platform_user_id: PlatformUserId) -> str:
        r"""
        X.conv_platform_user_id_to_string(platform_user_id) -> str
        Converts a PlatformUserId value to a string
        
        Args:
            platform_user_id (PlatformUserId): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_object_to_string(cls, obj: Object) -> str:
        r"""
        X.conv_object_to_string(obj) -> str
        Converts a UObject value to a string by calling the object's GetName method
        
        Args:
            obj (Object): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_name_to_string(cls, name: Name) -> str:
        r"""
        X.conv_name_to_string(name) -> str
        Converts a name value to a string
        
        Args:
            name (Name): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_matrix_to_string(cls, matrix: Matrix) -> str:
        r"""
        X.conv_matrix_to_string(matrix) -> str
        Converts a name value to a string
        
        Args:
            matrix (Matrix): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_int_vector_to_string(cls, int_vec: IntVector) -> str:
        r"""
        X.conv_int_vector_to_string(int_vec) -> str
        Converts an IntVector value to a string, in the form 'X= Y= Z='
        
        Args:
            int_vec (IntVector): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_int_to_string(cls, int: int) -> str:
        r"""
        X.conv_int_to_string(int) -> str
        Converts an integer value to a string
        
        Args:
            int (int32): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_int_point_to_string(cls, int_point: IntPoint) -> str:
        r"""
        X.conv_int_point_to_string(int_point) -> str
        Converts an IntPoint value to a string, in the form 'X= Y='
        
        Args:
            int_point (IntPoint): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_int64_to_string(cls, int: int) -> str:
        r"""
        X.conv_int64_to_string(int) -> str
        Converts an 64-bit integer value to a string
        
        Args:
            int (int64): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_input_device_id_to_string(cls, device_id: InputDeviceId) -> str:
        r"""
        X.conv_input_device_id_to_string(device_id) -> str
        Converts a InputDeviceId value to a string
        
        Args:
            device_id (InputDeviceId): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_double_to_string(cls, double: float) -> str:
        r"""
        X.conv_double_to_string(double) -> str
        Converts a double value to a string
        
        Args:
            double (double): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_float_to_string(cls, double: float) -> str:
        r"""
        deprecated: 'conv_float_to_string' was renamed to 'conv_double_to_string'.
        """
        ...
    @classmethod
    def conv_color_to_string(cls, color: LinearColor) -> str:
        r"""
        X.conv_color_to_string(color) -> str
        Converts a linear color value to a string, in the form '(R=,G=,B=,A=)'
        
        Args:
            color (LinearColor): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_byte_to_string(cls, byte: int) -> str:
        r"""
        X.conv_byte_to_string(byte) -> str
        Converts a byte value to a string
        
        Args:
            byte (uint8): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_box_to_string(cls, box: Box) -> str:
        r"""
        X.conv_box_to_string(box) -> str
        Converts a FBox value to a string
        
        Args:
            box (Box): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_box_center_and_extents_to_string(cls, box: Box) -> str:
        r"""
        X.conv_box_center_and_extents_to_string(box) -> str
        Converts a FBox value to a string of its Center and Extents values.
        
        Args:
            box (Box): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_bool_to_string(cls, bool: bool) -> str:
        r"""
        X.conv_bool_to_string(bool) -> str
        Converts a boolean value to a string, either 'true' or 'false'
        
        Args:
            bool (bool): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def contains(cls, search_in: str, substring: str, use_case: bool = False, search_from_end: bool = False) -> bool:
        r"""
        X.contains(search_in, substring, use_case=False, search_from_end=False) -> bool
        Returns whether this string contains the specified substring.
        
        Args:
            search_in (str): 
            substring (str): 
            use_case (bool): 
            search_from_end (bool): 
        
        Returns:
            bool: Returns whether the string contains the substring
        """
        ...
    @classmethod
    def concat_str_str(cls, a: str, b: str) -> str:
        r"""
        X.concat_str_str(a, b) -> str
        Concatenates two strings together to make a new string
        
        Args:
            a (str): The original string
            b (str): The string to append to A
        
        Returns:
            str: A new string which is the concatenation of A+B
        """
        ...
    @classmethod
    def build_string_vector2d(cls, append_to: str, prefix: str, vector2d: Vector2D, suffix: str) -> str:
        r"""
        X.build_string_vector2d(append_to, prefix, vector2d, suffix) -> str
        Converts a vector2d->string, creating a new string in the form AppendTo+Prefix+InVector2d+Suffix
        
        Args:
            append_to (str): An existing string to use as the start of the conversion string
            prefix (str): A string to use as a prefix, after the AppendTo string
            vector2d (Vector2D): The vector2d value to convert. Uses the standard FVector2D::ToString conversion
            suffix (str): A suffix to append to the end of the conversion string
        
        Returns:
            str: A new string built from the passed parameters
        """
        ...
    @classmethod
    def build_string_vector(cls, append_to: str, prefix: str, vector: Vector, suffix: str) -> str:
        r"""
        X.build_string_vector(append_to, prefix, vector, suffix) -> str
        Converts a vector->string, creating a new string in the form AppendTo+Prefix+InVector+Suffix
        
        Args:
            append_to (str): An existing string to use as the start of the conversion string
            prefix (str): A string to use as a prefix, after the AppendTo string
            vector (Vector): The vector value to convert. Uses the standard FVector::ToString conversion
            suffix (str): A suffix to append to the end of the conversion string
        
        Returns:
            str: A new string built from the passed parameters
        """
        ...
    @classmethod
    def build_string_rotator(cls, append_to: str, prefix: str, rot: Rotator, suffix: str) -> str:
        r"""
        X.build_string_rotator(append_to, prefix, rot, suffix) -> str
        Converts a rotator->string, creating a new string in the form AppendTo+Prefix+InRot+Suffix
        
        Args:
            append_to (str): An existing string to use as the start of the conversion string
            prefix (str): A string to use as a prefix, after the AppendTo string
            rot (Rotator): The rotator value to convert. Uses the standard ToString conversion
            suffix (str): A suffix to append to the end of the conversion string
        
        Returns:
            str: A new string built from the passed parameters
        """
        ...
    @classmethod
    def build_string_object(cls, append_to: str, prefix: str, obj: Object, suffix: str) -> str:
        r"""
        X.build_string_object(append_to, prefix, obj, suffix) -> str
        Converts a object->string, creating a new string in the form AppendTo+Prefix+object name+Suffix
        
        Args:
            append_to (str): An existing string to use as the start of the conversion string
            prefix (str): A string to use as a prefix, after the AppendTo string
            obj (Object): The object to convert. Will insert the name of the object into the conversion string
            suffix (str): A suffix to append to the end of the conversion string
        
        Returns:
            str: A new string built from the passed parameters
        """
        ...
    @classmethod
    def build_string_name(cls, append_to: str, prefix: str, name: Name, suffix: str) -> str:
        r"""
        X.build_string_name(append_to, prefix, name, suffix) -> str
        Converts a color->string, creating a new string in the form AppendTo+Prefix+InName+Suffix
        
        Args:
            append_to (str): An existing string to use as the start of the conversion string
            prefix (str): A string to use as a prefix, after the AppendTo string
            name (Name): The name value to convert
            suffix (str): A suffix to append to the end of the conversion string
        
        Returns:
            str: A new string built from the passed parameters
        """
        ...
    @classmethod
    def build_string_int_vector(cls, append_to: str, prefix: str, int_vector: IntVector, suffix: str) -> str:
        r"""
        X.build_string_int_vector(append_to, prefix, int_vector, suffix) -> str
        Converts an IntVector->string, creating a new string in the form AppendTo+Prefix+InIntVector+Suffix
        
        Args:
            append_to (str): An existing string to use as the start of the conversion string
            prefix (str): A string to use as a prefix, after the AppendTo string
            int_vector (IntVector): The intVector value to convert. Uses the standard FVector::ToString conversion
            suffix (str): A suffix to append to the end of the conversion string
        
        Returns:
            str: A new string built from the passed parameters
        """
        ...
    @classmethod
    def build_string_int(cls, append_to: str, prefix: str, int: int, suffix: str) -> str:
        r"""
        X.build_string_int(append_to, prefix, int, suffix) -> str
        Converts a int->string, creating a new string in the form AppendTo+Prefix+InInt+Suffix
        
        Args:
            append_to (str): An existing string to use as the start of the conversion string
            prefix (str): A string to use as a prefix, after the AppendTo string
            int (int32): The int value to convert
            suffix (str): A suffix to append to the end of the conversion string
        
        Returns:
            str: A new string built from the passed parameters
        """
        ...
    @classmethod
    def build_string_double(cls, append_to: str, prefix: str, double: float, suffix: str) -> str:
        r"""
        X.build_string_double(append_to, prefix, double, suffix) -> str
        Converts a double->string, create a new string in the form AppendTo+Prefix+InDouble+Suffix
        
        Args:
            append_to (str): An existing string to use as the start of the conversion string
            prefix (str): A string to use as a prefix, after the AppendTo string
            double (double): The double value to convert
            suffix (str): A suffix to append to the end of the conversion string
        
        Returns:
            str: A new string built from the passed parameters
        """
        ...
    @classmethod
    def build_string_float(cls, append_to: str, prefix: str, double: float, suffix: str) -> str:
        r"""
        deprecated: 'build_string_float' was renamed to 'build_string_double'.
        """
        ...
    @classmethod
    def build_string_color(cls, append_to: str, prefix: str, color: LinearColor, suffix: str) -> str:
        r"""
        X.build_string_color(append_to, prefix, color, suffix) -> str
        Converts a color->string, creating a new string in the form AppendTo+Prefix+InColor+Suffix
        
        Args:
            append_to (str): An existing string to use as the start of the conversion string
            prefix (str): A string to use as a prefix, after the AppendTo string
            color (LinearColor): The linear color value to convert. Uses the standard ToString conversion
            suffix (str): A suffix to append to the end of the conversion string
        
        Returns:
            str: A new string built from the passed parameters
        """
        ...
    @classmethod
    def build_string_bool(cls, append_to: str, prefix: str, bool: bool, suffix: str) -> str:
        r"""
        X.build_string_bool(append_to, prefix, bool, suffix) -> str
        Converts a boolean->string, creating a new string in the form AppendTo+Prefix+InBool+Suffix
        
        Args:
            append_to (str): An existing string to use as the start of the conversion string
            prefix (str): A string to use as a prefix, after the AppendTo string
            bool (bool): The bool value to convert. Will add "true" or "false" to the conversion string
            suffix (str): A suffix to append to the end of the conversion string
        
        Returns:
            str: A new string built from the passed parameters
        """
        ...

class StringTableLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet String Table Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetStringTableLibrary.h
    
    """
    @classmethod
    def is_registered_table_id(cls, table_id: Name) -> bool:
        r"""
        X.is_registered_table_id(table_id) -> bool
        Returns true if the given table ID corresponds to a registered string table.
        
        Args:
            table_id (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_registered_table_entry(cls, table_id: Name, key: str) -> bool:
        r"""
        X.is_registered_table_entry(table_id, key) -> bool
        Returns true if the given table ID corresponds to a registered string table, and that table has.
        
        Args:
            table_id (Name): 
            key (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_table_namespace(cls, table_id: Name) -> str:
        r"""
        X.get_table_namespace(table_id) -> str
        Returns the namespace of the given string table.
        
        Args:
            table_id (Name): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_table_entry_source_string(cls, table_id: Name, key: str) -> str:
        r"""
        X.get_table_entry_source_string(table_id, key) -> str
        Returns the source string of the given string table entry (or an empty string).
        
        Args:
            table_id (Name): 
            key (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_table_entry_meta_data(cls, table_id: Name, key: str, meta_data_id: Name) -> str:
        r"""
        X.get_table_entry_meta_data(table_id, key, meta_data_id) -> str
        Returns the specified meta-data of the given string table entry (or an empty string).
        
        Args:
            table_id (Name): 
            key (str): 
            meta_data_id (Name): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_registered_string_tables(cls) -> Array[Name]:
        r"""
        X.get_registered_string_tables() -> Array[Name]
        Returns an array of all registered string table IDs
        
        Returns:
            Array[Name]:
        """
        ...
    @classmethod
    def get_meta_data_ids_from_string_table_entry(cls, table_id: Name, key: str) -> Array[Name]:
        r"""
        X.get_meta_data_ids_from_string_table_entry(table_id, key) -> Array[Name]
        Returns an array of all meta-data IDs within the given string table entry
        
        Args:
            table_id (Name): 
            key (str): 
        
        Returns:
            Array[Name]:
        """
        ...
    @classmethod
    def get_keys_from_string_table(cls, table_id: Name) -> Array[str]:
        r"""
        X.get_keys_from_string_table(table_id) -> Array[str]
        Returns an array of all keys within the given string table
        
        Args:
            table_id (Name): 
        
        Returns:
            Array[str]:
        """
        ...

class Field(Object):
    r"""
    Field
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: 
    
    """
    ...

class Struct(Field):
    r"""
    Struct
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: 
    
    """
    ...

class ScriptStruct(Struct):
    r"""
    Script Struct
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: 
    
    """
    def get_struct_path_name(self) -> TopLevelAssetPath:
        r"""
        x.get_struct_path_name() -> TopLevelAssetPath
        Returns the full path to the specified struct as a Top Level Asset Path used by asset utilities
        
        Returns:
            TopLevelAssetPath:
        """
        ...

class Enum(Field):
    r"""
    Enum
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: 
    
    """
    def get_enum_path_name(self) -> TopLevelAssetPath:
        r"""
        x.get_enum_path_name() -> TopLevelAssetPath
        Returns the full path to the specified enum as a Top Level Asset Path used by asset utilities
        
        Returns:
            TopLevelAssetPath:
        """
        ...

class Class(Struct):
    r"""
    Class
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: 
    
    """
    def get_class_path_name(self) -> TopLevelAssetPath:
        r"""
        x.get_class_path_name() -> TopLevelAssetPath
        Returns the full path to the specified class as a Top Level Asset Path used by asset utilities
        
        Returns:
            TopLevelAssetPath:
        """
        ...

class SystemLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet System Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: KismetSystemLibrary.h
    
    """
    @classmethod
    def unregister_for_remote_notifications(cls) -> None:
        r"""
        X.unregister_for_remote_notifications() -> None
        Requests Requests unregistering from receiving remote notifications to the user's device.
        (Android only)
        """
        ...
    @classmethod
    def unload_primary_asset_list(cls, primary_asset_id_list: Array[PrimaryAssetId]) -> None:
        r"""
        X.unload_primary_asset_list(primary_asset_id_list) -> None
        Unloads a primary asset, which allows it to be garbage collected if nothing else is referencing it
        
        Args:
            primary_asset_id_list (Array[PrimaryAssetId]):
        """
        ...
    @classmethod
    def unload_primary_asset(cls, primary_asset_id: PrimaryAssetId) -> None:
        r"""
        X.unload_primary_asset(primary_asset_id) -> None
        Unloads a primary asset, which allows it to be garbage collected if nothing else is referencing it
        
        Args:
            primary_asset_id (PrimaryAssetId):
        """
        ...
    @classmethod
    def transact_object(cls, object: Object) -> None:
        r"""
        X.transact_object(object) -> None
        Notify the current transaction (if any) that this object is about to be modified and should be placed into the undo buffer.
        note: Internally this calls Modify on the given object, so will also mark the owner package dirty.
        note: Only available in the editor.
        
        Args:
            object (Object): The object that is about to be modified.
        """
        ...
    @classmethod
    def sphere_trace_single_for_objects(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, object_types: Array[ObjectTypeQuery], trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.sphere_trace_single_for_objects(world_context_object, start, end, radius, object_types, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Sweeps a sphere along the given line and returns the first hit encountered.
        This only finds objects that are of a type specified by ObjectTypes.
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the sphere to sweep
            object_types (Array[ObjectTypeQuery]): Array of Object Types to trace
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def sphere_trace_single_by_profile(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, profile_name: Name, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.sphere_trace_single_by_profile(world_context_object, start, end, radius, profile_name, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Sweep a sphere against the world and return the first blocking hit using a specific profile
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the sphere to sweep
            profile_name (Name): The 'profile' used to determine which components to hit
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def sphere_trace_single(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.sphere_trace_single(world_context_object, start, end, radius, trace_channel, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Sweeps a sphere along the given line and returns the first blocking hit encountered.
        This trace finds the objects that RESPONDS to the given TraceChannel
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the sphere to sweep
            trace_channel (TraceTypeQuery): 
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def sphere_trace_single_new(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        deprecated: 'sphere_trace_single_new' was renamed to 'sphere_trace_single'.
        """
        ...
    @classmethod
    def sphere_trace_multi_for_objects(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, object_types: Array[ObjectTypeQuery], trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.sphere_trace_multi_for_objects(world_context_object, start, end, radius, object_types, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Sweeps a sphere along the given line and returns all hits encountered.
        This only finds objects that are of a type specified by ObjectTypes.
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the sphere to sweep
            object_types (Array[ObjectTypeQuery]): Array of Object Types to trace
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a hit, false otherwise.
        
            out_hits (Array[HitResult]): A list of hits, sorted along the trace from start to finish.  The blocking hit will be the last hit, if there was one.
        """
        ...
    @classmethod
    def sphere_trace_multi_by_profile(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, profile_name: Name, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.sphere_trace_multi_by_profile(world_context_object, start, end, radius, profile_name, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Sweep a sphere against the world and return all initial overlaps using a specific profile, then overlapping hits and then first blocking hit
        Results are sorted, so a blocking hit (if found) will be the last element of the array
        Only the single closest blocking result will be generated, no tests will be done after that
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the sphere to sweep
            profile_name (Name): The 'profile' used to determine which components to hit
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a blocking hit, false otherwise.
        
            out_hits (Array[HitResult]): A list of hits, sorted along the trace from start to finish.  The blocking hit will be the last hit, if there was one.
        """
        ...
    @classmethod
    def sphere_trace_multi(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.sphere_trace_multi(world_context_object, start, end, radius, trace_channel, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Sweeps a sphere along the given line and returns all hits encountered up to and including the first blocking hit.
        This trace finds the objects that RESPOND to the given TraceChannel
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the sphere to sweep
            trace_channel (TraceTypeQuery): 
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a blocking hit, false otherwise.
        
            out_hits (Array[HitResult]): A list of hits, sorted along the trace from start to finish.  The blocking hit will be the last hit, if there was one.
        """
        ...
    @classmethod
    def sphere_trace_multi_new(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        deprecated: 'sphere_trace_multi_new' was renamed to 'sphere_trace_multi'.
        """
        ...
    @classmethod
    def sphere_overlap_components(cls, world_context_object: Object, sphere_pos: Vector, sphere_radius: float, object_types: Array[ObjectTypeQuery], component_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[PrimitiveComponent]]:
        r"""
        X.sphere_overlap_components(world_context_object, sphere_pos, sphere_radius, object_types, component_class_filter, actors_to_ignore) -> Array[PrimitiveComponent] or None
        Returns an array of components that overlap the given sphere.
        
        Args:
            world_context_object (Object): 
            sphere_pos (Vector): Center of sphere.
            sphere_radius (float): Size of sphere.
            object_types (Array[ObjectTypeQuery]): 
            component_class_filter (type(Class)): 
            actors_to_ignore (Array[Actor]): Ignore these actors in the list
        
        Returns:
            Array[PrimitiveComponent] or None: true if there was an overlap that passed the filters, false otherwise.
        
            out_components (Array[PrimitiveComponent]):
        """
        ...
    @classmethod
    def sphere_overlap_components_new(cls, world_context_object: Object, sphere_pos: Vector, sphere_radius: float, object_types: Array[ObjectTypeQuery], component_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[PrimitiveComponent]]:
        r"""
        deprecated: 'sphere_overlap_components_new' was renamed to 'sphere_overlap_components'.
        """
        ...
    @classmethod
    def sphere_overlap_actors(cls, world_context_object: Object, sphere_pos: Vector, sphere_radius: float, object_types: Array[ObjectTypeQuery], actor_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[Actor]]:
        r"""
        X.sphere_overlap_actors(world_context_object, sphere_pos, sphere_radius, object_types, actor_class_filter, actors_to_ignore) -> Array[Actor] or None
        Returns an array of actors that overlap the given sphere.
        
        Args:
            world_context_object (Object): 
            sphere_pos (Vector): Center of sphere.
            sphere_radius (float): Size of sphere.
            object_types (Array[ObjectTypeQuery]): 
            actor_class_filter (type(Class)): 
            actors_to_ignore (Array[Actor]): Ignore these actors in the list
        
        Returns:
            Array[Actor] or None: true if there was an overlap that passed the filters, false otherwise.
        
            out_actors (Array[Actor]): Returned array of actors. Unsorted.
        """
        ...
    @classmethod
    def sphere_overlap_actors_new(cls, world_context_object: Object, sphere_pos: Vector, sphere_radius: float, object_types: Array[ObjectTypeQuery], actor_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[Actor]]:
        r"""
        deprecated: 'sphere_overlap_actors_new' was renamed to 'sphere_overlap_actors'.
        """
        ...
    @classmethod
    def snapshot_object(cls, object: Object) -> None:
        r"""
        X.snapshot_object(object) -> None
        Notify the current transaction (if any) that this object is about to be modified and should be snapshot for intermediate update.
        note: Internally this calls SnapshotTransactionBuffer on the given object.
        note: Only available in the editor.
        
        Args:
            object (Object): The object that is about to be modified.
        """
        ...
    @classmethod
    def show_platform_specific_leaderboard_screen(cls, category_name: str) -> None:
        r"""
        X.show_platform_specific_leaderboard_screen(category_name) -> None
        Displays the built-in leaderboard GUI (iOS and Android only; this function may be renamed or moved in a future release)
        
        Args:
            category_name (str):
        """
        ...
    @classmethod
    def experimental_show_game_center_leaderboard(cls, category_name: str) -> None:
        r"""
        deprecated: 'experimental_show_game_center_leaderboard' was renamed to 'show_platform_specific_leaderboard_screen'.
        """
        ...
    @classmethod
    def show_platform_specific_achievements_screen(cls, specific_player: PlayerController) -> None:
        r"""
        X.show_platform_specific_achievements_screen(specific_player) -> None
        Displays the built-in achievements GUI (iOS and Android only; this function may be renamed or moved in a future release)
        
        Args:
            specific_player (PlayerController): Specific player's achievements to show. May not be supported on all platforms. If null, defaults to the player with ControllerId 0
        """
        ...
    @classmethod
    def show_interstitial_ad(cls) -> None:
        r"""
        X.show_interstitial_ad() -> None
        Shows the loaded interstitial ad (loaded with LoadInterstitialAd)
        (Android only)
        """
        ...
    @classmethod
    def show_ad_banner(cls, ad_id_index: int, show_on_bottom_of_screen: bool) -> None:
        r"""
        X.show_ad_banner(ad_id_index, show_on_bottom_of_screen) -> None
        Will show an ad banner (iAd on iOS, or AdMob on Android) on the top or bottom of screen, on top of the GL view (doesn't resize the view)
        (iOS and Android only)
        
        Args:
            ad_id_index (int32): The index of the ID to select for the ad to show
            show_on_bottom_of_screen (bool): If true, the iAd will be shown at the bottom of the screen, top otherwise
        """
        ...
    @classmethod
    def experimental_show_ad_banner(cls, ad_id_index: int, show_on_bottom_of_screen: bool) -> None:
        r"""
        deprecated: 'experimental_show_ad_banner' was renamed to 'show_ad_banner'.
        """
        ...
    @classmethod
    def set_window_title(cls, title: Text) -> None:
        r"""
        X.set_window_title(title) -> None
        Sets the game window title
        
        Args:
            title (Text):
        """
        ...
    @classmethod
    def set_volume_buttons_handled_by_system(cls, enabled: bool) -> None:
        r"""
        X.set_volume_buttons_handled_by_system(enabled) -> None
        Allows or inhibits system default handling of volume up and volume down buttons (Android only)
        
        Args:
            enabled (bool): If true, allow Android to handle volume up and down events
        """
        ...
    @classmethod
    def set_user_activity(cls, user_activity: UserActivity) -> None:
        r"""
        X.set_user_activity(user_activity) -> None
        Tells the engine what the user is doing for debug, analytics, etc.
        
        Args:
            user_activity (UserActivity):
        """
        ...
    @classmethod
    def set_suppress_viewport_transition_message(cls, world_context_object: Object, state: bool) -> None:
        r"""
        X.set_suppress_viewport_transition_message(world_context_object, state) -> None
        Sets the state of the transition message rendered by the viewport. (The blue text displayed when the game is paused and so forth.)
        
        Args:
            world_context_object (Object): World context
            state (bool):
        """
        ...
    @classmethod
    def set_supress_viewport_transition_message(cls, world_context_object: Object, state: bool) -> None:
        r"""
        deprecated: 'set_supress_viewport_transition_message' was renamed to 'set_suppress_viewport_transition_message'.
        """
        ...
    @classmethod
    def set_gamepads_block_device_feedback(cls, block: bool) -> None:
        r"""
        X.set_gamepads_block_device_feedback(block) -> None
        Sets whether attached gamepads will block feedback from the device itself (Mobile only).
        
        Args:
            block (bool):
        """
        ...
    @classmethod
    def retriggerable_delay(cls, world_context_object: Object, duration: float = 0.200000, latent_info: LatentActionInfo = ...) -> None:
        r"""
        X.retriggerable_delay(world_context_object, duration=0.200000, latent_info) -> None
        Perform a latent action with a retriggerable delay (specified in seconds).  Calling again while it is counting down will reset the countdown to Duration.
        
        Args:
            world_context_object (Object): 
            duration (float): length of delay (in seconds).
            latent_info (LatentActionInfo): The latent action.
        """
        ...
    @classmethod
    def reset_gamepad_assignment_to_controller(cls, controller_id: int) -> None:
        r"""
        X.reset_gamepad_assignment_to_controller(controller_id) -> None
        * Resets the gamepad assignment to player controller id (Android and iOS only)
        
        Args:
            controller_id (int32):
        """
        ...
    @classmethod
    def reset_gamepad_assignments(cls) -> None:
        r"""
        X.reset_gamepad_assignments() -> None
        Resets the gamepad to player controller id assignments (Android and iOS only)
        """
        ...
    @classmethod
    def reset_editor_property(cls, object: Object, property_name: Name, change_notify_mode: PropertyAccessChangeNotifyMode = PropertyAccessChangeNotifyMode.DEFAULT) -> bool:
        r"""
        X.reset_editor_property(object, property_name, change_notify_mode=PropertyAccessChangeNotifyMode.DEFAULT) -> bool
        Attempts to reset the value of a named property on the given object so that it matches the value of the archetype.
        
        Args:
            object (Object): The object you want to reset a property value on.
            property_name (Name): The name of the object property to reset the value of.
            change_notify_mode (PropertyAccessChangeNotifyMode): When to emit property change notifications.
        
        Returns:
            bool: Whether the property value was found and correctly reset.
        """
        ...
    @classmethod
    def register_for_remote_notifications(cls) -> None:
        r"""
        X.register_for_remote_notifications() -> None
        Requests permission to send remote notifications to the user's device.
        (Android and iOS only)
        """
        ...
    @classmethod
    def quit_game(cls, world_context_object: Object, specific_player: PlayerController, quit_preference: QuitPreference, ignore_platform_restrictions: bool) -> None:
        r"""
        X.quit_game(world_context_object, specific_player, quit_preference, ignore_platform_restrictions) -> None
        Exit the current game
        
        Args:
            world_context_object (Object): 
            specific_player (PlayerController): The specific player to quit the game. If not specified, player 0 will quit.
            quit_preference (QuitPreference): Form of quitting.
            ignore_platform_restrictions (bool): Ignores and best-practices based on platform (e.g on some consoles, games should never quit). Non-shipping only
        """
        ...
    @classmethod
    def quit_editor(cls) -> None:
        r"""
        X.quit_editor() -> None
        Exit the editor
        """
        ...
    @classmethod
    def print_text(cls, world_context_object: Object, text: Text = "Hello", print_to_screen: bool = True, print_to_log: bool = True, text_color: LinearColor = [0.000000, 0.660000, 1.000000, 1.000000], duration: float = 2.000000, key: Name = "None") -> None:
        r"""
        X.print_text(world_context_object, text="Hello", print_to_screen=True, print_to_log=True, text_color=[0.000000, 0.660000, 1.000000, 1.000000], duration=2.000000, key="None") -> None
        Prints text to the log, and optionally, to the screen
        If Print To Log is true, it will be visible in the Output Log window.  Otherwise it will be logged only as 'Verbose', so it generally won't show up.
        
        Args:
            world_context_object (Object): 
            text (Text): The text to log out
            print_to_screen (bool): Whether or not to print the output to the screen
            print_to_log (bool): Whether or not to print the output to the log
            text_color (LinearColor): The color of the text to display
            duration (float): The display duration (if Print to Screen is True). Using negative number will result in loading the duration time from the config.
            key (Name): If a non-empty key is provided, the message will replace any existing on-screen messages with the same key.
        """
        ...
    @classmethod
    def print_string(cls, world_context_object: Object, string: str = "Hello", print_to_screen: bool = True, print_to_log: bool = True, text_color: LinearColor = [0.000000, 0.660000, 1.000000, 1.000000], duration: float = 2.000000, key: Name = "None") -> None:
        r"""
        X.print_string(world_context_object, string="Hello", print_to_screen=True, print_to_log=True, text_color=[0.000000, 0.660000, 1.000000, 1.000000], duration=2.000000, key="None") -> None
        Prints a string to the log, and optionally, to the screen
        If Print To Log is true, it will be visible in the Output Log window.  Otherwise it will be logged only as 'Verbose', so it generally won't show up.
        
        Args:
            world_context_object (Object): 
            string (str): The string to log out
            print_to_screen (bool): Whether or not to print the output to the screen
            print_to_log (bool): Whether or not to print the output to the log
            text_color (LinearColor): The color of the text to display
            duration (float): The display duration (if Print to Screen is True). Using negative number will result in loading the duration time from the config.
            key (Name): If a non-empty key is provided, the message will replace any existing on-screen messages with the same key.
        """
        ...
    @classmethod
    def parse_param_value(cls, string: str, param: str) -> Optional[str]:
        r"""
        X.parse_param_value(string, param) -> str or None
        Returns 'value' if -option=value is in the string
        
        Args:
            string (str): 
            param (str): 
        
        Returns:
            str or None: 
        
            out_value (str):
        """
        ...
    @classmethod
    def parse_param(cls, string: str, param: str) -> bool:
        r"""
        X.parse_param(string, param) -> bool
        Returns true if the string has -param in it (do not specify the leading -)
        
        Args:
            string (str): 
            param (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def parse_command_line(cls, cmd_line: str) -> Tuple[Array[str], Array[str], Map[str, str]]:
        r"""
        X.parse_command_line(cmd_line) -> (out_tokens=Array[str], out_switches=Array[str], out_params=Map[str, str])
        * Parses the given string into loose tokens, switches (arguments that begin with - or /) and parameters (-mySwitch=myVar)
        *
        *
        
        Args:
            cmd_line (str): The the string to parse (ie '-foo -bar=/game/baz testtoken' ) *
        
        Returns:
            tuple: 
        
            out_tokens (Array[str]): 
        
            out_switches (Array[str]): 
        
            out_params (Map[str, str]):
        """
        ...
    @classmethod
    def not_equal_soft_object_reference(cls, a: Object, b: Object) -> bool:
        r"""
        X.not_equal_soft_object_reference(a, b) -> bool
        Returns true if the values are not equal (A != B)
        
        Args:
            a (Object): 
            b (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_soft_class_reference(cls, a: Class, b: Class) -> bool:
        r"""
        X.not_equal_soft_class_reference(a, b) -> bool
        Returns true if the values are not equal (A != B)
        
        Args:
            a (Class): 
            b (Class): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_primary_asset_type(cls, a: PrimaryAssetType, b: PrimaryAssetType) -> bool:
        r"""
        X.not_equal_primary_asset_type(a, b) -> bool
        Returns true if the values are not equal (A != B)
        
        Args:
            a (PrimaryAssetType): 
            b (PrimaryAssetType): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def not_equal_primary_asset_id(cls, a: PrimaryAssetId, b: PrimaryAssetId) -> bool:
        r"""
        X.not_equal_primary_asset_id(a, b) -> bool
        Returns true if the values are not equal (A != B)
        
        Args:
            a (PrimaryAssetId): 
            b (PrimaryAssetId): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def normalize_filename(cls, filename: str) -> str:
        r"""
        X.normalize_filename(filename) -> str
        Convert all / and \ to TEXT("/")
        
        Args:
            filename (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def move_component_to(cls, component: SceneComponent, target_relative_location: Vector, target_relative_rotation: Rotator, ease_out: bool, ease_in: bool, over_time: float = 0.200000, force_shortest_rotation_path: bool = ..., move_action: MoveComponentAction = ..., latent_info: LatentActionInfo = ...) -> None:
        r"""
        X.move_component_to(component, target_relative_location, target_relative_rotation, ease_out, ease_in, over_time=0.200000, force_shortest_rotation_path, move_action, latent_info) -> None
        * Interpolate a component to the specified relative location and rotation over the course of OverTime seconds.
        *
        see: EMoveComponentAction *
        
        Args:
            component (SceneComponent): Component to interpolate *
            target_relative_location (Vector): Relative target location *
            target_relative_rotation (Rotator): Relative target rotation *
            ease_out (bool): if true we will ease out (ie end slowly) during interpolation *
            ease_in (bool): if true we will ease in (ie start slowly) during interpolation *
            over_time (float): duration of interpolation *
            force_shortest_rotation_path (bool): if true we will always use the shortest path for rotation *
            move_action (MoveComponentAction): required movement behavior
            latent_info (LatentActionInfo): The latent action
        """
        ...
    @classmethod
    def make_literal_text(cls, value: Text) -> Text:
        r"""
        X.make_literal_text(value) -> Text
        Creates a literal FText
        
        Args:
            value (Text): value to set the FText to
        
        Returns:
            Text: The literal FText
        """
        ...
    @classmethod
    def make_literal_string(cls, value: str) -> str:
        r"""
        X.make_literal_string(value) -> str
        Creates a literal string
        
        Args:
            value (str): value to set the string to
        
        Returns:
            str: The literal string
        """
        ...
    @classmethod
    def make_literal_name(cls, value: Name) -> Name:
        r"""
        X.make_literal_name(value) -> Name
        Creates a literal name
        
        Args:
            value (Name): value to set the name to
        
        Returns:
            Name: The literal name
        """
        ...
    @classmethod
    def make_literal_int64(cls, value: int) -> int:
        r"""
        X.make_literal_int64(value) -> int64
        Creates a literal 64-bit integer
        
        Args:
            value (int64): value to set the 64-bit integer to
        
        Returns:
            int64: The literal 64-bit integer
        """
        ...
    @classmethod
    def make_literal_int(cls, value: int) -> int:
        r"""
        X.make_literal_int(value) -> int32
        Creates a literal integer
        
        Args:
            value (int32): value to set the integer to
        
        Returns:
            int32: The literal integer
        """
        ...
    @classmethod
    def make_literal_double(cls, value: float) -> float:
        r"""
        X.make_literal_double(value) -> double
        Creates a literal float (double-precision)
        
        Args:
            value (double): value to set the float (double-precision) to
        
        Returns:
            double: The literal float (double-precision)
        """
        ...
    @classmethod
    def make_literal_float(cls, value: float) -> float:
        r"""
        deprecated: 'make_literal_float' was renamed to 'make_literal_double'.
        """
        ...
    @classmethod
    def make_literal_byte(cls, value: int) -> int:
        r"""
        X.make_literal_byte(value) -> uint8
        Creates a literal byte
        
        Args:
            value (uint8): value to set the byte to
        
        Returns:
            uint8: The literal byte
        """
        ...
    @classmethod
    def make_literal_bool(cls, value: bool) -> bool:
        r"""
        X.make_literal_bool(value) -> bool
        Creates a literal bool
        
        Args:
            value (bool): value to set the bool to
        
        Returns:
            bool: The literal bool
        """
        ...
    @classmethod
    def log_string(cls, string: str = "Hello", print_to_log: bool = True) -> None:
        r"""
        X.log_string(string="Hello", print_to_log=True) -> None
        Prints a string to the log
        If Print To Log is true, it will be visible in the Output Log window.  Otherwise it will be logged only as 'Verbose', so it generally won't show up.
        
        Args:
            string (str): The string to log out
            print_to_log (bool): Whether or not to print the output to the log
        """
        ...
    @classmethod
    def load_interstitial_ad(cls, ad_id_index: int) -> None:
        r"""
        X.load_interstitial_ad(ad_id_index) -> None
        Will load a fullscreen interstitial AdMob ad. Call this before using ShowInterstitialAd
        (Android only)
        
        Args:
            ad_id_index (int32): The index of the ID to select for the ad to show
        """
        ...
    @classmethod
    def load_class_asset_blocking(cls, asset_class: Class) -> Class:
        r"""
        X.load_class_asset_blocking(asset_class) -> type(Class)
        Resolves or loads a Soft Class Reference immediately, this will cause hitches and Async Load Class Asset should be used if possible
        
        Args:
            asset_class (Class): 
        
        Returns:
            type(Class):
        """
        ...
    @classmethod
    def load_asset_blocking(cls, asset: Object) -> Object:
        r"""
        X.load_asset_blocking(asset) -> Object
        Resolves or loads a Soft Object Reference immediately, this will cause hitches and Async Load Asset should be used if possible
        
        Args:
            asset (Object): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def line_trace_single_for_objects(cls, world_context_object: Object, start: Vector, end: Vector, object_types: Array[ObjectTypeQuery], trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.line_trace_single_for_objects(world_context_object, start, end, object_types, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Does a collision trace along the given line and returns the first hit encountered.
        This only finds objects that are of a type specified by ObjectTypes.
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            object_types (Array[ObjectTypeQuery]): Array of Object Types to trace
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def line_trace_single_by_profile(cls, world_context_object: Object, start: Vector, end: Vector, profile_name: Name, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.line_trace_single_by_profile(world_context_object, start, end, profile_name, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Trace a ray against the world using a specific profile and return the first blocking hit
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            profile_name (Name): The 'profile' used to determine which components to hit
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def line_trace_single(cls, world_context_object: Object, start: Vector, end: Vector, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.line_trace_single(world_context_object, start, end, trace_channel, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Does a collision trace along the given line and returns the first blocking hit encountered.
        This trace finds the objects that RESPONDS to the given TraceChannel
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            trace_channel (TraceTypeQuery): 
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def line_trace_single_new(cls, world_context_object: Object, start: Vector, end: Vector, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        deprecated: 'line_trace_single_new' was renamed to 'line_trace_single'.
        """
        ...
    @classmethod
    def line_trace_multi_for_objects(cls, world_context_object: Object, start: Vector, end: Vector, object_types: Array[ObjectTypeQuery], trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.line_trace_multi_for_objects(world_context_object, start, end, object_types, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Does a collision trace along the given line and returns all hits encountered.
        This only finds objects that are of a type specified by ObjectTypes.
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            object_types (Array[ObjectTypeQuery]): Array of Object Types to trace
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a hit, false otherwise.
        
            out_hits (Array[HitResult]):
        """
        ...
    @classmethod
    def line_trace_multi_by_profile(cls, world_context_object: Object, start: Vector, end: Vector, profile_name: Name, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.line_trace_multi_by_profile(world_context_object, start, end, profile_name, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Trace a ray against the world using a specific profile and return overlapping hits and then first blocking hit
        Results are sorted, so a blocking hit (if found) will be the last element of the array
        Only the single closest blocking result will be generated, no tests will be done after that
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            profile_name (Name): The 'profile' used to determine which components to hit
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a blocking hit, false otherwise.
        
            out_hits (Array[HitResult]):
        """
        ...
    @classmethod
    def line_trace_multi(cls, world_context_object: Object, start: Vector, end: Vector, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.line_trace_multi(world_context_object, start, end, trace_channel, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Does a collision trace along the given line and returns all hits encountered up to and including the first blocking hit.
        This trace finds the objects that RESPOND to the given TraceChannel
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            trace_channel (TraceTypeQuery): The channel to trace
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a blocking hit, false otherwise.
        
            out_hits (Array[HitResult]):
        """
        ...
    @classmethod
    def line_trace_multi_new(cls, world_context_object: Object, start: Vector, end: Vector, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        deprecated: 'line_trace_multi_new' was renamed to 'line_trace_multi'.
        """
        ...
    @classmethod
    def launch_url(cls, url: str) -> None:
        r"""
        X.launch_url(url) -> None
        Opens the specified URL in the platform's web browser of choice
        
        Args:
            url (str):
        """
        ...
    @classmethod
    def un_pause_timer_handle(cls, world_context_object: Object, handle: TimerHandle) -> None:
        r"""
        X.un_pause_timer_handle(world_context_object, handle) -> None
        Resumes a paused timer from its current elapsed time.
        
        Args:
            world_context_object (Object): 
            handle (TimerHandle): The handle of the timer to unpause.
        """
        ...
    @classmethod
    def un_pause_timer_delegate(cls, delegate: TimerDynamicDelegate) -> None:
        r"""
        X.un_pause_timer_delegate(delegate) -> None
        Resumes a paused timer from its current elapsed time.
        deprecated: Use Unpause Timer by Handle
        
        Args:
            delegate (TimerDynamicDelegate):
        """
        ...
    @classmethod
    def un_pause_timer(cls, object: Object, function_name: str) -> None:
        r"""
        X.un_pause_timer(object, function_name) -> None
        Resumes a paused timer from its current elapsed time.
        
        Args:
            object (Object): Object that implements the delegate function. Defaults to self (this blueprint)
            function_name (str): Delegate function name. Can be a K2 function or a Custom Event.
        """
        ...
    @classmethod
    def timer_exists_handle(cls, world_context_object: Object, handle: TimerHandle) -> bool:
        r"""
        X.timer_exists_handle(world_context_object, handle) -> bool
        Returns true is a timer for the given handle exists, false otherwise.
        
        Args:
            world_context_object (Object): 
            handle (TimerHandle): The handle to check whether it exists.
        
        Returns:
            bool: True if the timer exists.
        """
        ...
    @classmethod
    def timer_exists_delegate(cls, delegate: TimerDynamicDelegate) -> bool:
        r"""
        X.timer_exists_delegate(delegate) -> bool
        Returns true is a timer for the given delegate exists, false otherwise.
        deprecated: Use Does Timer Exist by Handle
        
        Args:
            delegate (TimerDynamicDelegate): 
        
        Returns:
            bool: True if the timer exists.
        """
        ...
    @classmethod
    def timer_exists(cls, object: Object, function_name: str) -> bool:
        r"""
        X.timer_exists(object, function_name) -> bool
        Returns true is a timer for the given delegate exists, false otherwise.
        
        Args:
            object (Object): Object that implements the delegate function. Defaults to self (this blueprint)
            function_name (str): Delegate function name. Can be a K2 function or a Custom Event.
        
        Returns:
            bool: True if the timer exists.
        """
        ...
    @classmethod
    def set_timer_for_next_tick_delegate(cls, delegate: TimerDynamicDelegate) -> TimerHandle:
        r"""
        X.set_timer_for_next_tick_delegate(delegate) -> TimerHandle
        Set a timer to execute a delegate next tick.
        
        Args:
            delegate (TimerDynamicDelegate): 
        
        Returns:
            TimerHandle: The timer handle to pass to other timer functions to manipulate this timer.
        """
        ...
    @classmethod
    def set_timer_for_next_tick(cls, object: Object, function_name: str) -> TimerHandle:
        r"""
        X.set_timer_for_next_tick(object, function_name) -> TimerHandle
        Set a timer to execute a delegate on the next tick.
        
        Args:
            object (Object): Object that implements the delegate function. Defaults to self (this blueprint)
            function_name (str): Delegate function name. Can be a K2 function or a Custom Event.
        
        Returns:
            TimerHandle: The timer handle to pass to other timer functions to manipulate this timer.
        """
        ...
    @classmethod
    def set_timer_delegate(cls, delegate: TimerDynamicDelegate, time: float, looping: bool, max_once_per_frame: bool = False, initial_start_delay: float = 0.000000, initial_start_delay_variance: float = 0.000000) -> TimerHandle:
        r"""
        X.set_timer_delegate(delegate, time, looping, max_once_per_frame=False, initial_start_delay=0.000000, initial_start_delay_variance=0.000000) -> TimerHandle
        Set a timer to execute delegate. Setting an existing timer will reset that timer with updated parameters.
        
        Args:
            delegate (TimerDynamicDelegate): 
            time (float): How long to wait before executing the delegate, in seconds. Setting a timer to <= 0 seconds will clear it if it is set.
            looping (bool): True to keep executing the delegate every Time seconds, false to execute delegate only once.
            max_once_per_frame (bool): For looping timers, whether to execute only once when the timer would otherwise expires multiple times in the current frame.
            initial_start_delay (float): Initial delay passed to the timer manager, in seconds.
            initial_start_delay_variance (float): Use this to add some variance to when the timer starts in lieu of doing a random range on the InitialStartDelay input, in seconds.
        
        Returns:
            TimerHandle: The timer handle to pass to other timer functions to manipulate this timer.
        """
        ...
    @classmethod
    def set_timer(cls, object: Object, function_name: str, time: float, looping: bool, max_once_per_frame: bool = False, initial_start_delay: float = 0.000000, initial_start_delay_variance: float = 0.000000) -> TimerHandle:
        r"""
        X.set_timer(object, function_name, time, looping, max_once_per_frame=False, initial_start_delay=0.000000, initial_start_delay_variance=0.000000) -> TimerHandle
        Set a timer to execute delegate. Setting an existing timer will reset that timer with updated parameters.
        
        Args:
            object (Object): Object that implements the delegate function. Defaults to self (this blueprint)
            function_name (str): Delegate function name. Can be a K2 function or a Custom Event.
            time (float): How long to wait before executing the delegate, in seconds. Setting a timer to <= 0 seconds will clear it if it is set.
            looping (bool): True to keep executing the delegate every Time seconds, false to execute delegate only once.
            max_once_per_frame (bool): For looping timers, whether to execute only once when the timer would otherwise expires multiple times in the current frame.
            initial_start_delay (float): Initial delay passed to the timer manager to allow some variance in when the timer starts, in seconds.
            initial_start_delay_variance (float): Use this to add some variance to when the timer starts in lieu of doing a random range on the InitialStartDelay input, in seconds.
        
        Returns:
            TimerHandle: The timer handle to pass to other timer functions to manipulate this timer.
        """
        ...
    @classmethod
    def pause_timer_handle(cls, world_context_object: Object, handle: TimerHandle) -> None:
        r"""
        X.pause_timer_handle(world_context_object, handle) -> None
        Pauses a set timer at its current elapsed time.
        
        Args:
            world_context_object (Object): 
            handle (TimerHandle): The handle of the timer to pause.
        """
        ...
    @classmethod
    def pause_timer_delegate(cls, delegate: TimerDynamicDelegate) -> None:
        r"""
        X.pause_timer_delegate(delegate) -> None
        Pauses a set timer at its current elapsed time.
        deprecated: Use Pause Timer by Handle
        
        Args:
            delegate (TimerDynamicDelegate):
        """
        ...
    @classmethod
    def pause_timer(cls, object: Object, function_name: str) -> None:
        r"""
        X.pause_timer(object, function_name) -> None
        Pauses a set timer at its current elapsed time.
        
        Args:
            object (Object): Object that implements the delegate function. Defaults to self (this blueprint)
            function_name (str): Delegate function name. Can be a K2 function or a Custom Event.
        """
        ...
    @classmethod
    def is_valid_timer_handle(cls, handle: TimerHandle) -> bool:
        r"""
        X.is_valid_timer_handle(handle) -> bool
        Returns whether the timer handle is valid. This does not indicate that there is an active timer that this handle references, but rather that it once referenced a valid timer.
        
        Args:
            handle (TimerHandle): The handle of the timer to check validity of.
        
        Returns:
            bool: Whether the timer handle is valid.
        """
        ...
    @classmethod
    def is_timer_paused_handle(cls, world_context_object: Object, handle: TimerHandle) -> bool:
        r"""
        X.is_timer_paused_handle(world_context_object, handle) -> bool
        Returns true if a timer exists and is paused for the given handle, false otherwise.
        
        Args:
            world_context_object (Object): 
            handle (TimerHandle): The handle of the timer to check whether it is paused.
        
        Returns:
            bool: True if the timer exists and is paused.
        """
        ...
    @classmethod
    def is_timer_paused_delegate(cls, delegate: TimerDynamicDelegate) -> bool:
        r"""
        X.is_timer_paused_delegate(delegate) -> bool
        Returns true if a timer exists and is paused for the given delegate, false otherwise.
        deprecated: Use Is Timer Paused by Handle
        
        Args:
            delegate (TimerDynamicDelegate): 
        
        Returns:
            bool: True if the timer exists and is paused.
        """
        ...
    @classmethod
    def is_timer_paused(cls, object: Object, function_name: str) -> bool:
        r"""
        X.is_timer_paused(object, function_name) -> bool
        Returns true if a timer exists and is paused for the given delegate, false otherwise.
        
        Args:
            object (Object): Object that implements the delegate function. Defaults to self (this blueprint)
            function_name (str): Delegate function name. Can be a K2 function or a Custom Event.
        
        Returns:
            bool: True if the timer exists and is paused.
        """
        ...
    @classmethod
    def is_timer_active_handle(cls, world_context_object: Object, handle: TimerHandle) -> bool:
        r"""
        X.is_timer_active_handle(world_context_object, handle) -> bool
        Returns true if a timer exists and is active for the given handle, false otherwise.
        
        Args:
            world_context_object (Object): 
            handle (TimerHandle): The handle of the timer to check whether it is active.
        
        Returns:
            bool: True if the timer exists and is active.
        """
        ...
    @classmethod
    def is_timer_active_delegate(cls, delegate: TimerDynamicDelegate) -> bool:
        r"""
        X.is_timer_active_delegate(delegate) -> bool
        Returns true if a timer exists and is active for the given delegate, false otherwise.
        deprecated: Use Is Timer Active by Handle
        
        Args:
            delegate (TimerDynamicDelegate): 
        
        Returns:
            bool: True if the timer exists and is active.
        """
        ...
    @classmethod
    def is_timer_active(cls, object: Object, function_name: str) -> bool:
        r"""
        X.is_timer_active(object, function_name) -> bool
        Returns true if a timer exists and is active for the given delegate, false otherwise.
        
        Args:
            object (Object): Object that implements the delegate function. Defaults to self (this blueprint)
            function_name (str): Delegate function name. Can be a K2 function or a Custom Event.
        
        Returns:
            bool: True if the timer exists and is active.
        """
        ...
    @classmethod
    def invalidate_timer_handle(cls, handle: TimerHandle) -> Tuple[TimerHandle, TimerHandle]:
        r"""
        X.invalidate_timer_handle(handle) -> (TimerHandle, handle=TimerHandle)
        Invalidate the supplied TimerHandle and return it.
        
        Args:
            handle (TimerHandle): The handle of the timer to invalidate.
        
        Returns:
            TimerHandle: Return the invalidated timer handle for convenience.
        
            handle (TimerHandle): The handle of the timer to invalidate.
        """
        ...
    @classmethod
    def get_timer_remaining_time_handle(cls, world_context_object: Object, handle: TimerHandle) -> float:
        r"""
        X.get_timer_remaining_time_handle(world_context_object, handle) -> float
        Returns time until the timer will next execute its handle.
        
        Args:
            world_context_object (Object): 
            handle (TimerHandle): The handle of the timer to time remaining of.
        
        Returns:
            float: How long is remaining in the current iteration of the timer.
        """
        ...
    @classmethod
    def get_timer_remaining_time_delegate(cls, delegate: TimerDynamicDelegate) -> float:
        r"""
        X.get_timer_remaining_time_delegate(delegate) -> float
        Returns time until the timer will next execute its delegate.
        deprecated: Use Get Timer Remaining Time by Handle
        
        Args:
            delegate (TimerDynamicDelegate): 
        
        Returns:
            float: How long is remaining in the current iteration of the timer.
        """
        ...
    @classmethod
    def get_timer_remaining_time(cls, object: Object, function_name: str) -> float:
        r"""
        X.get_timer_remaining_time(object, function_name) -> float
        Returns time until the timer will next execute its delegate.
        
        Args:
            object (Object): Object that implements the delegate function. Defaults to self (this blueprint)
            function_name (str): Delegate function name. Can be a K2 function or a Custom Event.
        
        Returns:
            float: How long is remaining in the current iteration of the timer.
        """
        ...
    @classmethod
    def get_timer_elapsed_time_handle(cls, world_context_object: Object, handle: TimerHandle) -> float:
        r"""
        X.get_timer_elapsed_time_handle(world_context_object, handle) -> float
        Returns elapsed time for the given handle (time since current countdown iteration began).
        
        Args:
            world_context_object (Object): 
            handle (TimerHandle): The handle of the timer to get the elapsed time of.
        
        Returns:
            float: How long has elapsed since the current iteration of the timer began.
        """
        ...
    @classmethod
    def get_timer_elapsed_time_delegate(cls, delegate: TimerDynamicDelegate) -> float:
        r"""
        X.get_timer_elapsed_time_delegate(delegate) -> float
        Returns elapsed time for the given delegate (time since current countdown iteration began).
        deprecated: Use Get Timer Elapsed Time by Handle
        
        Args:
            delegate (TimerDynamicDelegate): 
        
        Returns:
            float: How long has elapsed since the current iteration of the timer began.
        """
        ...
    @classmethod
    def get_timer_elapsed_time(cls, object: Object, function_name: str) -> float:
        r"""
        X.get_timer_elapsed_time(object, function_name) -> float
        Returns elapsed time for the given delegate (time since current countdown iteration began).
        
        Args:
            object (Object): Object that implements the delegate function. Defaults to self (this blueprint)
            function_name (str): Delegate function name. Can be a K2 function or a Custom Event.
        
        Returns:
            float: How long has elapsed since the current iteration of the timer began.
        """
        ...
    @classmethod
    def clear_timer_handle(cls, world_context_object: Object, handle: TimerHandle) -> None:
        r"""
        X.clear_timer_handle(world_context_object, handle) -> None
        Clears a set timer.
        deprecated: Use Clear and Invalidate Timer by Handle. Note: you no longer need to reset your handle yourself after switching to the new function.
        
        Args:
            world_context_object (Object): 
            handle (TimerHandle): The handle of the timer to clear.
        """
        ...
    @classmethod
    def clear_timer_delegate(cls, delegate: TimerDynamicDelegate) -> None:
        r"""
        X.clear_timer_delegate(delegate) -> None
        Clears a set timer.
        deprecated: Use Clear Timer by Handle
        
        Args:
            delegate (TimerDynamicDelegate):
        """
        ...
    @classmethod
    def clear_timer(cls, object: Object, function_name: str) -> None:
        r"""
        X.clear_timer(object, function_name) -> None
        Clears a set timer.
        
        Args:
            object (Object): Object that implements the delegate function. Defaults to self (this blueprint)
            function_name (str): Delegate function name. Can be a K2 function or a Custom Event.
        """
        ...
    @classmethod
    def clear_and_invalidate_timer_handle(cls, world_context_object: Object, handle: TimerHandle) -> TimerHandle:
        r"""
        X.clear_and_invalidate_timer_handle(world_context_object, handle) -> TimerHandle
        Clears a set timer.
        
        Args:
            world_context_object (Object): 
            handle (TimerHandle): The handle of the timer to clear.
        
        Returns:
            TimerHandle: 
        
            handle (TimerHandle): The handle of the timer to clear.
        """
        ...
    @classmethod
    def is_valid_soft_object_reference(cls, soft_object_reference: Object) -> bool:
        r"""
        X.is_valid_soft_object_reference(soft_object_reference) -> bool
        Returns true if the Soft Object Reference is not null
        
        Args:
            soft_object_reference (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_soft_class_reference(cls, soft_class_reference: Class) -> bool:
        r"""
        X.is_valid_soft_class_reference(soft_class_reference) -> bool
        Returns true if the Soft Class Reference is not null
        
        Args:
            soft_class_reference (Class): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_primary_asset_type(cls, primary_asset_type: PrimaryAssetType) -> bool:
        r"""
        X.is_valid_primary_asset_type(primary_asset_type) -> bool
        Returns list of Primary Asset Ids for a PrimaryAssetType
        
        Args:
            primary_asset_type (PrimaryAssetType): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_primary_asset_id(cls, primary_asset_id: PrimaryAssetId) -> bool:
        r"""
        X.is_valid_primary_asset_id(primary_asset_id) -> bool
        Returns true if the Primary Asset Id is valid
        
        Args:
            primary_asset_id (PrimaryAssetId): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_interface(cls, interface: Interface) -> bool:
        r"""
        X.is_valid_interface(interface) -> bool
        Checks if the interface instance has a valid object for blueprint interface functions.
        This will return true for both natively implemented and blueprint implemented interfaces.
        
        Args:
            interface (Interface): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_class(cls, class_: Class) -> bool:
        r"""
        X.is_valid_class(class_) -> bool
        Return true if the class is usable : non-null and not pending kill
        
        Args:
            class_ (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid(cls, object: Object) -> bool:
        r"""
        X.is_valid(object) -> bool
        Return true if the object is usable : non-null and not pending kill
        
        Args:
            object (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_unattended(cls) -> bool:
        r"""
        X.is_unattended() -> bool
        Returns true if running unattended (-unattended is on the command line)
        
        Returns:
            bool: Unattended state
        """
        ...
    @classmethod
    def is_standalone(cls, world_context_object: Object) -> bool:
        r"""
        X.is_standalone(world_context_object) -> bool
        Returns whether this game instance is stand alone (no networking).
        
        Args:
            world_context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_split_screen(cls, world_context_object: Object) -> bool:
        r"""
        X.is_split_screen(world_context_object) -> bool
        Is Split Screen
        deprecated: Use HasMultipleLocalPlayers instead
        
        Args:
            world_context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_server(cls, world_context_object: Object) -> bool:
        r"""
        X.is_server(world_context_object) -> bool
        Returns whether the world this object is in is the host or not
        
        Args:
            world_context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_screensaver_enabled(cls) -> bool:
        r"""
        X.is_screensaver_enabled() -> bool
        Returns true if screen saver is enabled.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_packaged_for_distribution(cls) -> bool:
        r"""
        X.is_packaged_for_distribution() -> bool
        Returns whether this is a build that is packaged for distribution
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_logged_in(cls, specific_player: PlayerController) -> bool:
        r"""
        X.is_logged_in(specific_player) -> bool
        Returns whether the player is logged in to the currently active online subsystem.
        
        Args:
            specific_player (PlayerController): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_interstitial_ad_requested(cls) -> bool:
        r"""
        X.is_interstitial_ad_requested() -> bool
        Returns true if the requested interstitial ad has been successfully requested (false if load request fails)
        (Android only)
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_interstitial_ad_available(cls) -> bool:
        r"""
        X.is_interstitial_ad_available() -> bool
        Returns true if the requested interstitial ad is loaded and ready
        (Android only)
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_dedicated_server(cls, world_context_object: Object) -> bool:
        r"""
        X.is_dedicated_server(world_context_object) -> bool
        Returns whether this is running on a dedicated server
        
        Args:
            world_context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_controller_assigned_to_gamepad(cls, controller_id: int) -> bool:
        r"""
        X.is_controller_assigned_to_gamepad(controller_id) -> bool
        Returns true if controller id assigned to a gamepad (Android and iOS only)
        
        Args:
            controller_id (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def hide_ad_banner(cls) -> None:
        r"""
        X.hide_ad_banner() -> None
        Hides the ad banner (iAd on iOS, or AdMob on Android). Will force close the ad if it's open
        (iOS and Android only)
        """
        ...
    @classmethod
    def experimental_hide_ad_banner(cls) -> None:
        r"""
        deprecated: 'experimental_hide_ad_banner' was renamed to 'hide_ad_banner'.
        """
        ...
    @classmethod
    def has_multiple_local_players(cls, world_context_object: Object) -> bool:
        r"""
        X.has_multiple_local_players(world_context_object) -> bool
        Returns whether there are currently multiple local players in the given world
        
        Args:
            world_context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_volume_buttons_handled_by_system(cls) -> bool:
        r"""
        X.get_volume_buttons_handled_by_system() -> bool
        Returns true if system default handling of volume up and volume down buttons enabled (Android only)
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_unique_device_id(cls) -> str:
        r"""
        X.get_unique_device_id() -> str
        Returns the platform specific unique device id
        deprecated: Use GetDeviceId instead
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_system_path(cls, object: Object) -> str:
        r"""
        X.get_system_path(object) -> str
        Returns the full file system path to a UObject
        If given a non-asset UObject, it will return an empty string
        
        Args:
            object (Object): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_supported_fullscreen_resolutions(cls) -> Optional[Array[IntPoint]]:
        r"""
        X.get_supported_fullscreen_resolutions() -> Array[IntPoint] or None
        Gets the list of support fullscreen resolutions.
        
        Returns:
            Array[IntPoint] or None: true if successfully queried the device for available resolutions.
        
            resolutions (Array[IntPoint]):
        """
        ...
    @classmethod
    def get_struct_top_level_asset_path(cls, struct: ScriptStruct) -> TopLevelAssetPath:
        r"""
        X.get_struct_top_level_asset_path(struct) -> TopLevelAssetPath
        Returns the full path to the specified struct as a Top Level Asset Path used by asset utilities
        
        Args:
            struct (ScriptStruct): 
        
        Returns:
            TopLevelAssetPath:
        """
        ...
    @classmethod
    def get_soft_object_reference_from_primary_asset_id(cls, primary_asset_id: PrimaryAssetId) -> Object:
        r"""
        X.get_soft_object_reference_from_primary_asset_id(primary_asset_id) -> Object
        Returns the Object Id associated with a Primary Asset Id, this works even if the asset is not loaded
        
        Args:
            primary_asset_id (PrimaryAssetId): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def get_soft_object_path(cls, object: Object) -> SoftObjectPath:
        r"""
        X.get_soft_object_path(object) -> SoftObjectPath
        Returns the full path to the specified object as a Soft Object Path
        
        Args:
            object (Object): 
        
        Returns:
            SoftObjectPath:
        """
        ...
    @classmethod
    def get_soft_class_top_level_asset_path(cls, soft_class_reference: Class) -> TopLevelAssetPath:
        r"""
        X.get_soft_class_top_level_asset_path(soft_class_reference) -> TopLevelAssetPath
        Converts a Soft Class Reference to a Top Level Asset Path used by asset utilities
        
        Args:
            soft_class_reference (Class): 
        
        Returns:
            TopLevelAssetPath:
        """
        ...
    @classmethod
    def get_soft_class_reference_from_primary_asset_id(cls, primary_asset_id: PrimaryAssetId) -> Class:
        r"""
        X.get_soft_class_reference_from_primary_asset_id(primary_asset_id) -> Class
        Returns the Blueprint Class Id associated with a Primary Asset Id, this works even if the asset is not loaded
        
        Args:
            primary_asset_id (PrimaryAssetId): 
        
        Returns:
            Class:
        """
        ...
    @classmethod
    def get_soft_class_path(cls, class_: Class) -> SoftClassPath:
        r"""
        X.get_soft_class_path(class_) -> SoftClassPath
        Returns the full path to the specified class as a Soft Class Path (that can be used as a Soft Object Path)
        
        Args:
            class_ (type(Class)): 
        
        Returns:
            SoftClassPath:
        """
        ...
    @classmethod
    def get_rendering_material_quality_level(cls) -> int:
        r"""
        X.get_rendering_material_quality_level() -> int32
        Get the clamped state of r.MaterialQualityLevel, see console variable help (allows for scalability, cannot be used in construction scripts)
        0: low
        1: high
        2: medium
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_rendering_detail_mode(cls) -> int:
        r"""
        X.get_rendering_detail_mode() -> int32
        Get the clamped state of r.DetailMode, see console variable help (allows for scalability, cannot be used in construction scripts)
        0: low, show objects with DetailMode low
        1: medium, show objects with DetailMode medium or below
        2: high, show objects with DetailMode high or below
        3: epic, show all objects
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_project_saved_directory(cls) -> str:
        r"""
        X.get_project_saved_directory() -> str
        Get the saved directory of the current project
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_project_directory(cls) -> str:
        r"""
        X.get_project_directory() -> str
        Get the directory of the current project
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_project_content_directory(cls) -> str:
        r"""
        X.get_project_content_directory() -> str
        Get the content directory of the current project
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_primary_assets_with_bundle_state(cls, required_bundles: Array[Name], excluded_bundles: Array[Name], valid_types: Array[PrimaryAssetType], force_current_state: bool) -> Array[PrimaryAssetId]:
        r"""
        X.get_primary_assets_with_bundle_state(required_bundles, excluded_bundles, valid_types, force_current_state) -> Array[PrimaryAssetId]
        Returns the list of assets that are in a given bundle state. Required Bundles must be specified
        If ExcludedBundles is not empty, it will not return any assets in those bundle states
        If ValidTypes is not empty, it will only return assets of those types
        If ForceCurrentState is true it will use the current state even if a load is in process
        
        Args:
            required_bundles (Array[Name]): 
            excluded_bundles (Array[Name]): 
            valid_types (Array[PrimaryAssetType]): 
            force_current_state (bool): 
        
        Returns:
            Array[PrimaryAssetId]: 
        
            out_primary_asset_id_list (Array[PrimaryAssetId]):
        """
        ...
    @classmethod
    def get_primary_asset_id_list(cls, primary_asset_type: PrimaryAssetType) -> Array[PrimaryAssetId]:
        r"""
        X.get_primary_asset_id_list(primary_asset_type) -> Array[PrimaryAssetId]
        Returns list of PrimaryAssetIds for a PrimaryAssetType
        
        Args:
            primary_asset_type (PrimaryAssetType): 
        
        Returns:
            Array[PrimaryAssetId]: 
        
            out_primary_asset_id_list (Array[PrimaryAssetId]):
        """
        ...
    @classmethod
    def get_primary_asset_id_from_soft_object_reference(cls, soft_object_reference: Object) -> PrimaryAssetId:
        r"""
        X.get_primary_asset_id_from_soft_object_reference(soft_object_reference) -> PrimaryAssetId
        Returns the Primary Asset Id for a Soft Object Reference, this can return an invalid one if not registered
        
        Args:
            soft_object_reference (Object): 
        
        Returns:
            PrimaryAssetId:
        """
        ...
    @classmethod
    def get_primary_asset_id_from_soft_class_reference(cls, soft_class_reference: Class) -> PrimaryAssetId:
        r"""
        X.get_primary_asset_id_from_soft_class_reference(soft_class_reference) -> PrimaryAssetId
        Returns the Primary Asset Id for a Soft Class Reference, this can return an invalid one if not registered
        
        Args:
            soft_class_reference (Class): 
        
        Returns:
            PrimaryAssetId:
        """
        ...
    @classmethod
    def get_primary_asset_id_from_object(cls, object: Object) -> PrimaryAssetId:
        r"""
        X.get_primary_asset_id_from_object(object) -> PrimaryAssetId
        Returns the Primary Asset Id for an Object, this can return an invalid one if not registered
        
        Args:
            object (Object): 
        
        Returns:
            PrimaryAssetId:
        """
        ...
    @classmethod
    def get_primary_asset_id_from_class(cls, class_: Class) -> PrimaryAssetId:
        r"""
        X.get_primary_asset_id_from_class(class_) -> PrimaryAssetId
        Returns the Primary Asset Id for a Class, this can return an invalid one if not registered
        
        Args:
            class_ (type(Class)): 
        
        Returns:
            PrimaryAssetId:
        """
        ...
    @classmethod
    def get_preferred_languages(cls) -> Array[str]:
        r"""
        X.get_preferred_languages() -> Array[str]
        Returns an array of the user's preferred languages in order of preference
        
        Returns:
            Array[str]: An array of language IDs ordered from most preferred to least
        """
        ...
    @classmethod
    def get_platform_user_name(cls) -> str:
        r"""
        X.get_platform_user_name() -> str
        Get the current user name from the OS
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_platform_user_dir(cls) -> str:
        r"""
        X.get_platform_user_dir() -> str
        Get the current user dir from the OS
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_platform_time_seconds(cls) -> float:
        r"""
        X.get_platform_time_seconds() -> double
        Returns the current platform time in seconds. Not coupled to any gameplay or other containerization logic - this
        function is useful for timing execution time or timestamping data. Marked as callable rather than pure because
        implicit evaluation may be confusing, both for blueprint authors and blueprint readers. For implicit execution
        simply wrap it in a blueprint pure function.
        
        Returns:
            double:
        """
        ...
    @classmethod
    def get_path_name(cls, object: Object) -> str:
        r"""
        X.get_path_name(object) -> str
        Returns the full path to the specified object as a string
        
        Args:
            object (Object): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_outer_object(cls, object: Object) -> Object:
        r"""
        X.get_outer_object(object) -> Object
        Returns the outer object of an object.
        
        Args:
            object (Object): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def get_object_name(cls, object: Object) -> str:
        r"""
        X.get_object_name(object) -> str
        Returns the actual object name.
        
        Args:
            object (Object): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_object_from_primary_asset_id(cls, primary_asset_id: PrimaryAssetId) -> Object:
        r"""
        X.get_object_from_primary_asset_id(primary_asset_id) -> Object
        Returns the Object associated with a Primary Asset Id, this will only return a valid object if it is in memory, it will not load it
        
        Args:
            primary_asset_id (PrimaryAssetId): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def get_min_y_resolution_for_ui(cls) -> int:
        r"""
        X.get_min_y_resolution_for_ui() -> int32
        Gets the smallest Y resolution we want to support in the UI, clamped within reasons
        
        Returns:
            int32: value in pixels
        """
        ...
    @classmethod
    def get_min_y_resolution_for3d_view(cls) -> int:
        r"""
        X.get_min_y_resolution_for3d_view() -> int32
        Gets the smallest Y resolution we want to support in the 3D view, clamped within reasons
        
        Returns:
            int32: value in pixels
        """
        ...
    @classmethod
    def get_local_currency_symbol(cls) -> str:
        r"""
        X.get_local_currency_symbol() -> str
        Returns the currency symbol associated with the device's locale
        
        Returns:
            str: the currency symbol associated with the device's locale
        """
        ...
    @classmethod
    def get_local_currency_code(cls) -> str:
        r"""
        X.get_local_currency_code() -> str
        Returns the currency code associated with the device's locale
        
        Returns:
            str: the currency code associated with the device's locale
        """
        ...
    @classmethod
    def get_game_time_in_seconds(cls, world_context_object: Object) -> float:
        r"""
        X.get_game_time_in_seconds(world_context_object) -> double
        Get the current game time, in seconds. This stops when the game is paused and is affected by slomo.
        
        Args:
            world_context_object (Object): World context
        
        Returns:
            double:
        """
        ...
    @classmethod
    def get_gamepad_controller_name(cls, controller_id: int) -> str:
        r"""
        X.get_gamepad_controller_name(controller_id) -> str
        Returns name of controller if assigned to a gamepad (or None if not assigned) (Android and iOS only)
        
        Args:
            controller_id (int32): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_gamepad_button_glyph(cls, button_key: str, controller_index: int) -> Texture2D:
        r"""
        X.get_gamepad_button_glyph(button_key, controller_index) -> Texture2D
        Returns glyph assigned to a gamepad button (or a null ptr if not assigned) (iOS and tvOS only)
        
        Args:
            button_key (str): 
            controller_index (int32): 
        
        Returns:
            Texture2D:
        """
        ...
    @classmethod
    def get_game_name(cls) -> str:
        r"""
        X.get_game_name() -> str
        Get the name of the current game
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_game_bundle_id(cls) -> str:
        r"""
        X.get_game_bundle_id() -> str
        Retrieves the game's platform-specific bundle identifier or package name of the game
        
        Returns:
            str: The game's bundle identifier or package name.
        """
        ...
    @classmethod
    def get_frame_count(cls) -> int:
        r"""
        X.get_frame_count() -> int64
        Returns the value of GFrameCounter, a running count of the number of frames that have occurred.
        
        Returns:
            int64:
        """
        ...
    @classmethod
    def get_enum_top_level_asset_path(cls, enum: Enum) -> TopLevelAssetPath:
        r"""
        X.get_enum_top_level_asset_path(enum) -> TopLevelAssetPath
        Returns the full path to the specified enum as a Top Level Asset Path used by asset utilities
        
        Args:
            enum (Enum): 
        
        Returns:
            TopLevelAssetPath:
        """
        ...
    @classmethod
    def get_engine_version(cls) -> str:
        r"""
        X.get_engine_version() -> str
        Engine build number, for displaying to end users.
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_display_name(cls, object: Object) -> str:
        r"""
        X.get_display_name(object) -> str
        Returns the display name (or actor label), for displaying as a debugging aid.
        Note: In editor builds, this is the actor label.  In non-editor builds, this is the actual object name.  This function should not be used to uniquely identify actors!
        It is not localized and should not be used for display to an end user of a game.
        
        Args:
            object (Object): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_device_id(cls) -> str:
        r"""
        X.get_device_id() -> str
        Returns the platform specific unique device id
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_default_locale(cls) -> str:
        r"""
        X.get_default_locale() -> str
        Get the default locale (for internationalization) used by this platform
        note: This should be returned in IETF language tag form: - A two-letter ISO 639-1 language code (eg, "zh") - An optional four-letter ISO 15924 script code (eg, "Hans") - An optional two-letter ISO 3166-1 country code (eg, "CN")
        
        Returns:
            str: The locale as an IETF language tag (eg, "zh-Hans-CN")
        """
        ...
    @classmethod
    def get_default_language(cls) -> str:
        r"""
        X.get_default_language() -> str
        Get the default language (for localization) used by this platform
        note: This is typically the same as GetDefaultLocale unless the platform distinguishes between the two
        note: This should be returned in IETF language tag form: - A two-letter ISO 639-1 language code (eg, "zh") - An optional four-letter ISO 15924 script code (eg, "Hans") - An optional two-letter ISO 3166-1 country code (eg, "CN")
        
        Returns:
            str: The language as an IETF language tag (eg, "zh-Hans-CN")
        """
        ...
    @classmethod
    def get_current_bundle_state(cls, primary_asset_id: PrimaryAssetId, force_current_state: bool) -> Optional[Array[Name]]:
        r"""
        X.get_current_bundle_state(primary_asset_id, force_current_state) -> Array[Name] or None
        Returns the list of loaded bundles for a given Primary Asset. This will return false if the asset is not loaded at all.
        If ForceCurrentState is true it will return the current state even if a load is in process
        
        Args:
            primary_asset_id (PrimaryAssetId): 
            force_current_state (bool): 
        
        Returns:
            Array[Name] or None: 
        
            out_bundles (Array[Name]):
        """
        ...
    @classmethod
    def get_convenient_windowed_resolutions(cls) -> Optional[Array[IntPoint]]:
        r"""
        X.get_convenient_windowed_resolutions() -> Array[IntPoint] or None
        Gets the list of windowed resolutions which are convenient for the current primary display size.
        
        Returns:
            Array[IntPoint] or None: true if successfully queried the device for available resolutions.
        
            resolutions (Array[IntPoint]):
        """
        ...
    @classmethod
    def get_console_variable_string_value(cls, variable_name: str) -> str:
        r"""
        X.get_console_variable_string_value(variable_name) -> str
        Attempts to retrieve the value of the specified string console variable, if it exists.
        
        Args:
            variable_name (str): Name of the console variable to find.
        
        Returns:
            str: The value if found, empty string otherwise.
        """
        ...
    @classmethod
    def get_console_variable_int_value(cls, variable_name: str) -> int:
        r"""
        X.get_console_variable_int_value(variable_name) -> int32
        Attempts to retrieve the value of the specified integer console variable, if it exists.
        
        Args:
            variable_name (str): Name of the console variable to find.
        
        Returns:
            int32: The value if found, 0 otherwise.
        """
        ...
    @classmethod
    def get_console_variable_float_value(cls, variable_name: str) -> float:
        r"""
        X.get_console_variable_float_value(variable_name) -> float
        Attempts to retrieve the value of the specified float console variable, if it exists.
        
        Args:
            variable_name (str): Name of the console variable to find.
        
        Returns:
            float: The value if found, 0 otherwise.
        """
        ...
    @classmethod
    def get_console_variable_bool_value(cls, variable_name: str) -> bool:
        r"""
        X.get_console_variable_bool_value(variable_name) -> bool
        Evaluates, if it exists, whether the specified integer console variable has a non-zero value (true) or not (false).
        
        Args:
            variable_name (str): Name of the console variable to find.
        
        Returns:
            bool: True if found and has a non-zero value, false otherwise.
        """
        ...
    @classmethod
    def get_component_bounds(cls, component: SceneComponent) -> Tuple[Vector, Vector, float]:
        r"""
        X.get_component_bounds(component) -> (origin=Vector, box_extent=Vector, sphere_radius=float)
        Get bounds
        
        Args:
            component (SceneComponent): 
        
        Returns:
            tuple: 
        
            origin (Vector): 
        
            box_extent (Vector): 
        
            sphere_radius (float):
        """
        ...
    @classmethod
    def get_command_line(cls) -> str:
        r"""
        X.get_command_line() -> str
        Returns the command line that the process was launched with.
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_class_top_level_asset_path(cls, class_: Class) -> TopLevelAssetPath:
        r"""
        X.get_class_top_level_asset_path(class_) -> TopLevelAssetPath
        Returns the full path to the specified class as a Top Level Asset Path used by asset utilities
        
        Args:
            class_ (type(Class)): 
        
        Returns:
            TopLevelAssetPath:
        """
        ...
    @classmethod
    def get_class_from_primary_asset_id(cls, primary_asset_id: PrimaryAssetId) -> Class:
        r"""
        X.get_class_from_primary_asset_id(primary_asset_id) -> type(Class)
        Returns the Blueprint Class associated with a Primary Asset Id, this will only return a valid object if it is in memory, it will not load it
        
        Args:
            primary_asset_id (PrimaryAssetId): 
        
        Returns:
            type(Class):
        """
        ...
    @classmethod
    def get_class_display_name(cls, class_: Class) -> str:
        r"""
        X.get_class_display_name(class_) -> str
        Returns the display name of a class
        
        Args:
            class_ (type(Class)): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_build_version(cls) -> str:
        r"""
        X.get_build_version() -> str
        Build version, for displaying to end users in diagnostics.
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_build_configuration(cls) -> str:
        r"""
        X.get_build_configuration() -> str
        Build configuration, for displaying to end users in diagnostics.
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_ad_id_count(cls) -> int:
        r"""
        X.get_ad_id_count() -> int32
        Retrieves the total number of Ad IDs that can be selected between
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_actor_list_from_component_list(cls, component_list: Array[PrimitiveComponent], actor_class_filter: Class) -> Array[Actor]:
        r"""
        X.get_actor_list_from_component_list(component_list, actor_class_filter) -> Array[Actor]
        Returns an array of unique actors represented by the given list of components.
        
        Args:
            component_list (Array[PrimitiveComponent]): List of components.
            actor_class_filter (type(Class)): 
        
        Returns:
            Array[Actor]: 
        
            out_actor_list (Array[Actor]): Start of line segment.
        """
        ...
    @classmethod
    def get_actor_bounds(cls, actor: Actor) -> Tuple[Vector, Vector]:
        r"""
        X.get_actor_bounds(actor) -> (origin=Vector, box_extent=Vector)
        Get Actor Bounds
        deprecated: Function 'GetActorBounds' is deprecated.
        
        Args:
            actor (Actor): 
        
        Returns:
            tuple: 
        
            origin (Vector): 
        
            box_extent (Vector):
        """
        ...
    @classmethod
    def force_close_ad_banner(cls) -> None:
        r"""
        X.force_close_ad_banner() -> None
        Forces closed any displayed ad. Can lead to loss of revenue
        (iOS and Android only)
        """
        ...
    @classmethod
    def experimental_close_ad_banner(cls) -> None:
        r"""
        deprecated: 'experimental_close_ad_banner' was renamed to 'force_close_ad_banner'.
        """
        ...
    @classmethod
    def flush_persistent_debug_lines(cls, world_context_object: Object) -> None:
        r"""
        X.flush_persistent_debug_lines(world_context_object) -> None
        Flush all persistent debug lines and shapes.
        
        Args:
            world_context_object (Object):
        """
        ...
    @classmethod
    def flush_debug_strings(cls, world_context_object: Object) -> None:
        r"""
        X.flush_debug_strings(world_context_object) -> None
        Removes all debug strings.
        
        Args:
            world_context_object (Object):
        """
        ...
    @classmethod
    def execute_console_command(cls, world_context_object: Object, command: str, specific_player: PlayerController = None) -> None:
        r"""
        X.execute_console_command(world_context_object, command, specific_player=None) -> None
        Executes a console command, optionally on a specific controller
        
        Args:
            world_context_object (Object): 
            command (str): Command to send to the console
            specific_player (PlayerController): If specified, the console command will be routed through the specified player
        """
        ...
    @classmethod
    def equal_equal_soft_object_reference(cls, a: Object, b: Object) -> bool:
        r"""
        X.equal_equal_soft_object_reference(a, b) -> bool
        Returns true if the values are equal (A == B)
        
        Args:
            a (Object): 
            b (Object): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_soft_class_reference(cls, a: Class, b: Class) -> bool:
        r"""
        X.equal_equal_soft_class_reference(a, b) -> bool
        Returns true if the values are equal (A == B)
        
        Args:
            a (Class): 
            b (Class): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_primary_asset_type(cls, a: PrimaryAssetType, b: PrimaryAssetType) -> bool:
        r"""
        X.equal_equal_primary_asset_type(a, b) -> bool
        Returns true if the values are equal (A == B)
        
        Args:
            a (PrimaryAssetType): 
            b (PrimaryAssetType): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def equal_equal_primary_asset_id(cls, a: PrimaryAssetId, b: PrimaryAssetId) -> bool:
        r"""
        X.equal_equal_primary_asset_id(a, b) -> bool
        Returns true if the values are equal (A == B)
        
        Args:
            a (PrimaryAssetId): 
            b (PrimaryAssetId): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def end_transaction(cls) -> int:
        r"""
        X.end_transaction() -> int32
        Attempt to end the current undo transaction. Only successful if the transaction's action counter is 1.
        note: Only available in the editor.
        
        Returns:
            int32: The number of active actions when EndTransaction was called (a value of 1 indicates that the transaction was successfully closed), or -1 on failure.
        """
        ...
    @classmethod
    def draw_debug_string(cls, world_context_object: Object, text_location: Vector, text: str, test_base_actor: Actor = None, text_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000) -> None:
        r"""
        X.draw_debug_string(world_context_object, text_location, text, test_base_actor=None, text_color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000) -> None
        Draw a debug string at a 3d world location.
        
        Args:
            world_context_object (Object): 
            text_location (Vector): 
            text (str): 
            test_base_actor (Actor): 
            text_color (LinearColor): 
            duration (float):
        """
        ...
    @classmethod
    def draw_debug_sphere(cls, world_context_object: Object, center: Vector, radius: float = 100.000000, segments: int = 12, line_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000, thickness: float = 0.000000) -> None:
        r"""
        X.draw_debug_sphere(world_context_object, center, radius=100.000000, segments=12, line_color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000, thickness=0.000000) -> None
        Draw a debug sphere
        
        Args:
            world_context_object (Object): 
            center (Vector): 
            radius (float): 
            segments (int32): 
            line_color (LinearColor): 
            duration (float): 
            thickness (float):
        """
        ...
    @classmethod
    def draw_debug_point(cls, world_context_object: Object, position: Vector, size: float, point_color: LinearColor, duration: float = 0.000000) -> None:
        r"""
        X.draw_debug_point(world_context_object, position, size, point_color, duration=0.000000) -> None
        Draw a debug point
        
        Args:
            world_context_object (Object): 
            position (Vector): 
            size (float): 
            point_color (LinearColor): 
            duration (float):
        """
        ...
    @classmethod
    def draw_debug_plane(cls, world_context_object: Object, plane_coordinates: Plane, location: Vector, size: float, plane_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000) -> None:
        r"""
        X.draw_debug_plane(world_context_object, plane_coordinates, location, size, plane_color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000) -> None
        Draws a debug plane.
        
        Args:
            world_context_object (Object): 
            plane_coordinates (Plane): 
            location (Vector): 
            size (float): 
            plane_color (LinearColor): 
            duration (float):
        """
        ...
    @classmethod
    def draw_debug_line(cls, world_context_object: Object, line_start: Vector, line_end: Vector, line_color: LinearColor, duration: float = 0.000000, thickness: float = 0.000000) -> None:
        r"""
        X.draw_debug_line(world_context_object, line_start, line_end, line_color, duration=0.000000, thickness=0.000000) -> None
        Draw a debug line
        
        Args:
            world_context_object (Object): 
            line_start (Vector): 
            line_end (Vector): 
            line_color (LinearColor): 
            duration (float): 
            thickness (float):
        """
        ...
    @classmethod
    def draw_debug_frustum(cls, world_context_object: Object, frustum_transform: Transform, frustum_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000, thickness: float = 0.000000) -> None:
        r"""
        X.draw_debug_frustum(world_context_object, frustum_transform, frustum_color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000, thickness=0.000000) -> None
        Draws a debug frustum.
        
        Args:
            world_context_object (Object): 
            frustum_transform (Transform): 
            frustum_color (LinearColor): 
            duration (float): 
            thickness (float):
        """
        ...
    @classmethod
    def draw_debug_float_history_transform(cls, world_context_object: Object, float_history: DebugFloatHistory, draw_transform: Transform, draw_size: Vector2D, draw_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000) -> None:
        r"""
        X.draw_debug_float_history_transform(world_context_object, float_history, draw_transform, draw_size, draw_color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000) -> None
        Draws a 2D Histogram of size 'DrawSize' based FDebugFloatHistory struct, using DrawTransform for the position in the world.
        
        Args:
            world_context_object (Object): 
            float_history (DebugFloatHistory): 
            draw_transform (Transform): 
            draw_size (Vector2D): 
            draw_color (LinearColor): 
            duration (float):
        """
        ...
    @classmethod
    def draw_debug_float_history_location(cls, world_context_object: Object, float_history: DebugFloatHistory, draw_location: Vector, draw_size: Vector2D, draw_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000) -> None:
        r"""
        X.draw_debug_float_history_location(world_context_object, float_history, draw_location, draw_size, draw_color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000) -> None
        Draws a 2D Histogram of size 'DrawSize' based FDebugFloatHistory struct, using DrawLocation for the location in the world, rotation will face camera of first player.
        
        Args:
            world_context_object (Object): 
            float_history (DebugFloatHistory): 
            draw_location (Vector): 
            draw_size (Vector2D): 
            draw_color (LinearColor): 
            duration (float):
        """
        ...
    @classmethod
    def draw_debug_cylinder(cls, world_context_object: Object, start: Vector, end: Vector, radius: float = 100.000000, segments: int = 12, line_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000, thickness: float = 0.000000) -> None:
        r"""
        X.draw_debug_cylinder(world_context_object, start, end, radius=100.000000, segments=12, line_color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000, thickness=0.000000) -> None
        Draw a debug cylinder
        
        Args:
            world_context_object (Object): 
            start (Vector): 
            end (Vector): 
            radius (float): 
            segments (int32): 
            line_color (LinearColor): 
            duration (float): 
            thickness (float):
        """
        ...
    @classmethod
    def draw_debug_coordinate_system(cls, world_context_object: Object, axis_loc: Vector, axis_rot: Rotator, scale: float = 1.000000, duration: float = 0.000000, thickness: float = 0.000000) -> None:
        r"""
        X.draw_debug_coordinate_system(world_context_object, axis_loc, axis_rot, scale=1.000000, duration=0.000000, thickness=0.000000) -> None
        Draw a debug coordinate system.
        
        Args:
            world_context_object (Object): 
            axis_loc (Vector): 
            axis_rot (Rotator): 
            scale (float): 
            duration (float): 
            thickness (float):
        """
        ...
    @classmethod
    def draw_debug_cone_in_degrees(cls, world_context_object: Object, origin: Vector, direction: Vector, length: float = 100.000000, angle_width: float = 45.000000, angle_height: float = 45.000000, num_sides: int = 12, line_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000, thickness: float = 0.000000) -> None:
        r"""
        X.draw_debug_cone_in_degrees(world_context_object, origin, direction, length=100.000000, angle_width=45.000000, angle_height=45.000000, num_sides=12, line_color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000, thickness=0.000000) -> None
        Draw a debug cone
        Angles are specified in degrees
        
        Args:
            world_context_object (Object): 
            origin (Vector): 
            direction (Vector): 
            length (float): 
            angle_width (float): 
            angle_height (float): 
            num_sides (int32): 
            line_color (LinearColor): 
            duration (float): 
            thickness (float):
        """
        ...
    @classmethod
    def draw_debug_cone(cls, world_context_object: Object, origin: Vector, direction: Vector, length: float, angle_width: float, angle_height: float, num_sides: int, line_color: LinearColor, duration: float = 0.000000, thickness: float = 0.000000) -> None:
        r"""
        X.draw_debug_cone(world_context_object, origin, direction, length, angle_width, angle_height, num_sides, line_color, duration=0.000000, thickness=0.000000) -> None
        Draw a debug cone
        deprecated: DrawDebugCone has been changed to use degrees for angles instead of radians. Place a new DrawDebugCone node and pass your angles as degrees.
        
        Args:
            world_context_object (Object): 
            origin (Vector): 
            direction (Vector): 
            length (float): 
            angle_width (float): 
            angle_height (float): 
            num_sides (int32): 
            line_color (LinearColor): 
            duration (float): 
            thickness (float):
        """
        ...
    @classmethod
    def draw_debug_circle(cls, world_context_object: Object, center: Vector, radius: float, num_segments: int = 12, line_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000, thickness: float = 0.000000, y_axis: Vector = [0.000000, 1.000000, 0.000000], z_axis: Vector = [0.000000, 0.000000, 1.000000], draw_axis: bool = False) -> None:
        r"""
        X.draw_debug_circle(world_context_object, center, radius, num_segments=12, line_color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000, thickness=0.000000, y_axis=[0.000000, 1.000000, 0.000000], z_axis=[0.000000, 0.000000, 1.000000], draw_axis=False) -> None
        Draw a debug circle!
        
        Args:
            world_context_object (Object): 
            center (Vector): 
            radius (float): 
            num_segments (int32): 
            line_color (LinearColor): 
            duration (float): 
            thickness (float): 
            y_axis (Vector): 
            z_axis (Vector): 
            draw_axis (bool):
        """
        ...
    @classmethod
    def draw_debug_capsule(cls, world_context_object: Object, center: Vector, half_height: float, radius: float, rotation: Rotator, line_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000, thickness: float = 0.000000) -> None:
        r"""
        X.draw_debug_capsule(world_context_object, center, half_height, radius, rotation, line_color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000, thickness=0.000000) -> None
        Draw a debug capsule
        
        Args:
            world_context_object (Object): 
            center (Vector): 
            half_height (float): 
            radius (float): 
            rotation (Rotator): 
            line_color (LinearColor): 
            duration (float): 
            thickness (float):
        """
        ...
    @classmethod
    def draw_debug_camera(cls, camera_actor: CameraActor, camera_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], duration: float = 0.000000) -> None:
        r"""
        X.draw_debug_camera(camera_actor, camera_color=[1.000000, 1.000000, 1.000000, 1.000000], duration=0.000000) -> None
        Draw a debug camera shape.
        
        Args:
            camera_actor (CameraActor): 
            camera_color (LinearColor): 
            duration (float):
        """
        ...
    @classmethod
    def draw_debug_box(cls, world_context_object: Object, center: Vector, extent: Vector, line_color: LinearColor, rotation: Rotator = [0.000000, 0.000000, 0.000000], duration: float = 0.000000, thickness: float = 0.000000) -> None:
        r"""
        X.draw_debug_box(world_context_object, center, extent, line_color, rotation=[0.000000, 0.000000, 0.000000], duration=0.000000, thickness=0.000000) -> None
        Draw a debug box
        
        Args:
            world_context_object (Object): 
            center (Vector): 
            extent (Vector): 
            line_color (LinearColor): 
            rotation (Rotator): 
            duration (float): 
            thickness (float):
        """
        ...
    @classmethod
    def draw_debug_arrow(cls, world_context_object: Object, line_start: Vector, line_end: Vector, arrow_size: float, line_color: LinearColor, duration: float = 0.000000, thickness: float = 0.000000) -> None:
        r"""
        X.draw_debug_arrow(world_context_object, line_start, line_end, arrow_size, line_color, duration=0.000000, thickness=0.000000) -> None
        Draw directional arrow, pointing from LineStart to LineEnd.
        
        Args:
            world_context_object (Object): 
            line_start (Vector): 
            line_end (Vector): 
            arrow_size (float): 
            line_color (LinearColor): 
            duration (float): 
            thickness (float):
        """
        ...
    @classmethod
    def does_implement_interface(cls, test_object: Object, interface: Class) -> bool:
        r"""
        X.does_implement_interface(test_object, interface) -> bool
        Checks if the given object implements a specific interface, works for both native and blueprint interfacse
        
        Args:
            test_object (Object): 
            interface (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def does_class_implement_interface(cls, test_class: Class, interface: Class) -> bool:
        r"""
        X.does_class_implement_interface(test_class, interface) -> bool
        Checks if the given class implements a specific interface, works for both native and blueprint interfacse
        
        Args:
            test_class (type(Class)): 
            interface (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def delay_until_next_tick(cls, world_context_object: Object, latent_info: LatentActionInfo) -> None:
        r"""
        X.delay_until_next_tick(world_context_object, latent_info) -> None
        Perform a latent action with a delay of one tick.  Calling again while it is counting down will be ignored.
        
        Args:
            world_context_object (Object): 
            latent_info (LatentActionInfo): The latent action.
        """
        ...
    @classmethod
    def delay(cls, world_context_object: Object, duration: float = 0.200000, latent_info: LatentActionInfo = ...) -> None:
        r"""
        X.delay(world_context_object, duration=0.200000, latent_info) -> None
        Perform a latent action with a delay (specified in seconds).  Calling again while it is counting down will be ignored.
        
        Args:
            world_context_object (Object): 
            duration (float): length of delay (in seconds).
            latent_info (LatentActionInfo): The latent action.
        """
        ...
    @classmethod
    def create_copy_for_undo_buffer(cls, object_to_modify: Object) -> None:
        r"""
        X.create_copy_for_undo_buffer(object_to_modify) -> None
        Mark as modified.
        
        Args:
            object_to_modify (Object):
        """
        ...
    @classmethod
    def convert_to_relative_path(cls, filename: str) -> str:
        r"""
        X.convert_to_relative_path(filename) -> str
        Converts passed in filename to use a relative path
        
        Args:
            filename (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def convert_to_absolute_path(cls, filename: str) -> str:
        r"""
        X.convert_to_absolute_path(filename) -> str
        Converts passed in filename to use a absolute path
        
        Args:
            filename (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_soft_obj_ref_to_soft_obj_path(cls, soft_object_reference: Object) -> SoftObjectPath:
        r"""
        X.conv_soft_obj_ref_to_soft_obj_path(soft_object_reference) -> SoftObjectPath
        Converts a Soft Object Reference into a Soft Object Path
        
        Args:
            soft_object_reference (Object): 
        
        Returns:
            SoftObjectPath:
        """
        ...
    @classmethod
    def conv_soft_obj_ref_to_soft_class_path(cls, soft_class_reference: Class) -> SoftClassPath:
        r"""
        X.conv_soft_obj_ref_to_soft_class_path(soft_class_reference) -> SoftClassPath
        Converts a Soft Class Reference into a Soft Class Path (which can be used like a Soft Object Path)
        
        Args:
            soft_class_reference (Class): 
        
        Returns:
            SoftClassPath:
        """
        ...
    @classmethod
    def conv_soft_obj_path_to_soft_obj_ref(cls, soft_object_path: SoftObjectPath) -> Object:
        r"""
        X.conv_soft_obj_path_to_soft_obj_ref(soft_object_path) -> Object
        Converts a Soft Object Path into a base Soft Object Reference, this is not guaranteed to be resolvable
        
        Args:
            soft_object_path (SoftObjectPath): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def conv_soft_object_reference_to_string(cls, soft_object_reference: Object) -> str:
        r"""
        X.conv_soft_object_reference_to_string(soft_object_reference) -> str
        Converts a Soft Object Reference to a path string
        
        Args:
            soft_object_reference (Object): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_soft_class_reference_to_string(cls, soft_class_reference: Class) -> str:
        r"""
        X.conv_soft_class_reference_to_string(soft_class_reference) -> str
        Converts a Soft Class Reference to a path string
        
        Args:
            soft_class_reference (Class): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_soft_class_path_to_soft_class_ref(cls, soft_class_path: SoftClassPath) -> Class:
        r"""
        X.conv_soft_class_path_to_soft_class_ref(soft_class_path) -> Class
        Converts a Soft Class Path into a base Soft Class Reference, this is not guaranteed to be resolvable
        
        Args:
            soft_class_path (SoftClassPath): 
        
        Returns:
            Class:
        """
        ...
    @classmethod
    def conv_primary_asset_type_to_string(cls, primary_asset_type: PrimaryAssetType) -> str:
        r"""
        X.conv_primary_asset_type_to_string(primary_asset_type) -> str
        Converts a Primary Asset Type to a string. The other direction is not provided because it cannot be validated
        
        Args:
            primary_asset_type (PrimaryAssetType): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_primary_asset_id_to_string(cls, primary_asset_id: PrimaryAssetId) -> str:
        r"""
        X.conv_primary_asset_id_to_string(primary_asset_id) -> str
        Converts a Primary Asset Id to a string. The other direction is not provided because it cannot be validated
        
        Args:
            primary_asset_id (PrimaryAssetId): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def conv_object_to_class(cls, object: Object, class_: Class) -> Class:
        r"""
        X.conv_object_to_class(object, class_) -> type(Class)
        Casts from an object to a class, this will only work if the object is already a class
        
        Args:
            object (Object): 
            class_ (type(Class)): 
        
        Returns:
            type(Class):
        """
        ...
    @classmethod
    def conv_interface_to_object(cls, interface: Interface) -> Object:
        r"""
        X.conv_interface_to_object(interface) -> Object
        Converts an interface instance into an object
        
        Args:
            interface (Interface): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def conv_component_reference_to_soft_component_reference(cls, component_reference: ComponentReference) -> SoftComponentReference:
        r"""
        X.conv_component_reference_to_soft_component_reference(component_reference) -> SoftComponentReference
        Conv Component Reference to Soft Component Reference
        
        Args:
            component_reference (ComponentReference): 
        
        Returns:
            SoftComponentReference:
        """
        ...
    @classmethod
    def control_screensaver(cls, allow_screen_saver: bool) -> None:
        r"""
        X.control_screensaver(allow_screen_saver) -> None
        Allows or inhibits screensaver
        
        Args:
            allow_screen_saver (bool): If false, don't allow screensaver if possible, otherwise allow default behavior
        """
        ...
    @classmethod
    def component_overlap_components(cls, component: PrimitiveComponent, component_transform: Transform, object_types: Array[ObjectTypeQuery], component_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[PrimitiveComponent]]:
        r"""
        X.component_overlap_components(component, component_transform, object_types, component_class_filter, actors_to_ignore) -> Array[PrimitiveComponent] or None
        Returns an array of components that overlap the given component.
        
        Args:
            component (PrimitiveComponent): Component to test with.
            component_transform (Transform): Defines where to place the component for overlap testing.
            object_types (Array[ObjectTypeQuery]): 
            component_class_filter (type(Class)): 
            actors_to_ignore (Array[Actor]): Ignore these actors in the list
        
        Returns:
            Array[PrimitiveComponent] or None: true if there was an overlap that passed the filters, false otherwise.
        
            out_components (Array[PrimitiveComponent]):
        """
        ...
    @classmethod
    def component_overlap_components_new(cls, component: PrimitiveComponent, component_transform: Transform, object_types: Array[ObjectTypeQuery], component_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[PrimitiveComponent]]:
        r"""
        deprecated: 'component_overlap_components_new' was renamed to 'component_overlap_components'.
        """
        ...
    @classmethod
    def component_overlap_actors(cls, component: PrimitiveComponent, component_transform: Transform, object_types: Array[ObjectTypeQuery], actor_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[Actor]]:
        r"""
        X.component_overlap_actors(component, component_transform, object_types, actor_class_filter, actors_to_ignore) -> Array[Actor] or None
        Returns an array of actors that overlap the given component.
        
        Args:
            component (PrimitiveComponent): Component to test with.
            component_transform (Transform): Defines where to place the component for overlap testing.
            object_types (Array[ObjectTypeQuery]): 
            actor_class_filter (type(Class)): 
            actors_to_ignore (Array[Actor]): Ignore these actors in the list
        
        Returns:
            Array[Actor] or None: true if there was an overlap that passed the filters, false otherwise.
        
            out_actors (Array[Actor]): Returned array of actors. Unsorted.
        """
        ...
    @classmethod
    def component_overlap_actors_new(cls, component: PrimitiveComponent, component_transform: Transform, object_types: Array[ObjectTypeQuery], actor_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[Actor]]:
        r"""
        deprecated: 'component_overlap_actors_new' was renamed to 'component_overlap_actors'.
        """
        ...
    @classmethod
    def collect_garbage(cls) -> None:
        r"""
        X.collect_garbage() -> None
        Deletes all unreferenced objects, keeping only referenced objects (this command will be queued and happen at the end of the frame)
        Note: This can be a slow operation, and should only be performed where a hitch would be acceptable
        """
        ...
    @classmethod
    def capsule_trace_single_for_objects(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, half_height: float, object_types: Array[ObjectTypeQuery], trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.capsule_trace_single_for_objects(world_context_object, start, end, radius, half_height, object_types, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Sweeps a capsule along the given line and returns the first hit encountered.
        This only finds objects that are of a type specified by ObjectTypes.
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the capsule to sweep
            half_height (float): Distance from center of capsule to tip of hemisphere endcap.
            object_types (Array[ObjectTypeQuery]): Array of Object Types to trace
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def capsule_trace_single_by_profile(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, half_height: float, profile_name: Name, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.capsule_trace_single_by_profile(world_context_object, start, end, radius, half_height, profile_name, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Sweep a capsule against the world and return the first blocking hit using a specific profile
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the capsule to sweep
            half_height (float): Distance from center of capsule to tip of hemisphere endcap.
            profile_name (Name): The 'profile' used to determine which components to hit
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def capsule_trace_single(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, half_height: float, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.capsule_trace_single(world_context_object, start, end, radius, half_height, trace_channel, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Sweeps a capsule along the given line and returns the first blocking hit encountered.
        This trace finds the objects that RESPOND to the given TraceChannel
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the capsule to sweep
            half_height (float): Distance from center of capsule to tip of hemisphere endcap.
            trace_channel (TraceTypeQuery): 
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def capsule_trace_single_new(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, half_height: float, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        deprecated: 'capsule_trace_single_new' was renamed to 'capsule_trace_single'.
        """
        ...
    @classmethod
    def capsule_trace_multi_for_objects(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, half_height: float, object_types: Array[ObjectTypeQuery], trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.capsule_trace_multi_for_objects(world_context_object, start, end, radius, half_height, object_types, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Sweeps a capsule along the given line and returns all hits encountered.
        This only finds objects that are of a type specified by ObjectTypes.
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the capsule to sweep
            half_height (float): Distance from center of capsule to tip of hemisphere endcap.
            object_types (Array[ObjectTypeQuery]): Array of Object Types to trace
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a hit, false otherwise.
        
            out_hits (Array[HitResult]): A list of hits, sorted along the trace from start to finish.  The blocking hit will be the last hit, if there was one.
        """
        ...
    @classmethod
    def capsule_trace_multi_by_profile(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, half_height: float, profile_name: Name, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.capsule_trace_multi_by_profile(world_context_object, start, end, radius, half_height, profile_name, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Sweep a capsule against the world and return all initial overlaps using a specific profile, then overlapping hits and then first blocking hit
        Results are sorted, so a blocking hit (if found) will be the last element of the array
        Only the single closest blocking result will be generated, no tests will be done after that
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the capsule to sweep
            half_height (float): Distance from center of capsule to tip of hemisphere endcap.
            profile_name (Name): The 'profile' used to determine which components to hit
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a blocking hit, false otherwise.
        
            out_hits (Array[HitResult]): A list of hits, sorted along the trace from start to finish.  The blocking hit will be the last hit, if there was one.
        """
        ...
    @classmethod
    def capsule_trace_multi(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, half_height: float, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.capsule_trace_multi(world_context_object, start, end, radius, half_height, trace_channel, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Sweeps a capsule along the given line and returns all hits encountered up to and including the first blocking hit.
        This trace finds the objects that RESPOND to the given TraceChannel
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            radius (float): Radius of the capsule to sweep
            half_height (float): Distance from center of capsule to tip of hemisphere endcap.
            trace_channel (TraceTypeQuery): 
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a blocking hit, false otherwise.
        
            out_hits (Array[HitResult]): A list of hits, sorted along the trace from start to finish.  The blocking hit will be the last hit, if there was one.
        """
        ...
    @classmethod
    def capsule_trace_multi_new(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, half_height: float, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        deprecated: 'capsule_trace_multi_new' was renamed to 'capsule_trace_multi'.
        """
        ...
    @classmethod
    def capsule_overlap_components(cls, world_context_object: Object, capsule_pos: Vector, radius: float, half_height: float, object_types: Array[ObjectTypeQuery], component_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[PrimitiveComponent]]:
        r"""
        X.capsule_overlap_components(world_context_object, capsule_pos, radius, half_height, object_types, component_class_filter, actors_to_ignore) -> Array[PrimitiveComponent] or None
        Returns an array of components that overlap the given capsule.
        
        Args:
            world_context_object (Object): 
            capsule_pos (Vector): Center of the capsule.
            radius (float): Radius of capsule hemispheres and radius of center cylinder portion.
            half_height (float): Half-height of the capsule (from center of capsule to tip of hemisphere.
            object_types (Array[ObjectTypeQuery]): 
            component_class_filter (type(Class)): 
            actors_to_ignore (Array[Actor]): Ignore these actors in the list
        
        Returns:
            Array[PrimitiveComponent] or None: true if there was an overlap that passed the filters, false otherwise.
        
            out_components (Array[PrimitiveComponent]):
        """
        ...
    @classmethod
    def capsule_overlap_components_new(cls, world_context_object: Object, capsule_pos: Vector, radius: float, half_height: float, object_types: Array[ObjectTypeQuery], component_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[PrimitiveComponent]]:
        r"""
        deprecated: 'capsule_overlap_components_new' was renamed to 'capsule_overlap_components'.
        """
        ...
    @classmethod
    def capsule_overlap_actors(cls, world_context_object: Object, capsule_pos: Vector, radius: float, half_height: float, object_types: Array[ObjectTypeQuery], actor_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[Actor]]:
        r"""
        X.capsule_overlap_actors(world_context_object, capsule_pos, radius, half_height, object_types, actor_class_filter, actors_to_ignore) -> Array[Actor] or None
        Returns an array of actors that overlap the given capsule.
        
        Args:
            world_context_object (Object): 
            capsule_pos (Vector): Center of the capsule.
            radius (float): Radius of capsule hemispheres and radius of center cylinder portion.
            half_height (float): Half-height of the capsule (from center of capsule to tip of hemisphere.
            object_types (Array[ObjectTypeQuery]): 
            actor_class_filter (type(Class)): 
            actors_to_ignore (Array[Actor]): Ignore these actors in the list
        
        Returns:
            Array[Actor] or None: true if there was an overlap that passed the filters, false otherwise.
        
            out_actors (Array[Actor]): Returned array of actors. Unsorted.
        """
        ...
    @classmethod
    def capsule_overlap_actors_new(cls, world_context_object: Object, capsule_pos: Vector, radius: float, half_height: float, object_types: Array[ObjectTypeQuery], actor_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[Actor]]:
        r"""
        deprecated: 'capsule_overlap_actors_new' was renamed to 'capsule_overlap_actors'.
        """
        ...
    @classmethod
    def can_launch_url(cls, url: str) -> bool:
        r"""
        X.can_launch_url(url) -> bool
        Can Launch URL
        
        Args:
            url (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def cancel_transaction(cls, index: int) -> None:
        r"""
        X.cancel_transaction(index) -> None
        Cancel the current transaction, and no longer capture actions to be placed in the undo buffer.
        note: Only available in the editor.
        
        Args:
            index (int32): The action counter to cancel transactions from (as returned by a call to BeginTransaction).
        """
        ...
    @classmethod
    def box_trace_single_for_objects(cls, world_context_object: Object, start: Vector, end: Vector, half_size: Vector, orientation: Rotator, object_types: Array[ObjectTypeQuery], trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.box_trace_single_for_objects(world_context_object, start, end, half_size, orientation, object_types, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Sweeps a box along the given line and returns the first hit encountered.
        This only finds objects that are of a type specified by ObjectTypes.
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            half_size (Vector): Radius of the sphere to sweep
            orientation (Rotator): 
            object_types (Array[ObjectTypeQuery]): Array of Object Types to trace
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def box_trace_single_by_profile(cls, world_context_object: Object, start: Vector, end: Vector, half_size: Vector, orientation: Rotator, profile_name: Name, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.box_trace_single_by_profile(world_context_object, start, end, half_size, orientation, profile_name, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Sweep a box against the world and return the first blocking hit using a specific profile
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            half_size (Vector): Distance from the center of box along each axis
            orientation (Rotator): Orientation of the box
            profile_name (Name): The 'profile' used to determine which components to hit
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def box_trace_single(cls, world_context_object: Object, start: Vector, end: Vector, half_size: Vector, orientation: Rotator, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[HitResult]:
        r"""
        X.box_trace_single(world_context_object, start, end, half_size, orientation, trace_channel, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> HitResult or None
        Sweeps a box along the given line and returns the first blocking hit encountered.
        This trace finds the objects that RESPONDS to the given TraceChannel
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            half_size (Vector): Distance from the center of box along each axis
            orientation (Rotator): Orientation of the box
            trace_channel (TraceTypeQuery): 
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            HitResult or None: True if there was a hit, false otherwise.
        
            out_hit (HitResult): Properties of the trace hit.
        """
        ...
    @classmethod
    def box_trace_multi_for_objects(cls, world_context_object: Object, start: Vector, end: Vector, half_size: Vector, orientation: Rotator, object_types: Array[ObjectTypeQuery], trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.box_trace_multi_for_objects(world_context_object, start, end, half_size, orientation, object_types, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Sweeps a box along the given line and returns all hits encountered.
        This only finds objects that are of a type specified by ObjectTypes.
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            half_size (Vector): Radius of the sphere to sweep
            orientation (Rotator): 
            object_types (Array[ObjectTypeQuery]): Array of Object Types to trace
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a hit, false otherwise.
        
            out_hits (Array[HitResult]): A list of hits, sorted along the trace from start to finish.  The blocking hit will be the last hit, if there was one.
        """
        ...
    @classmethod
    def box_trace_multi_by_profile(cls, world_context_object: Object, start: Vector, end: Vector, half_size: Vector, orientation: Rotator, profile_name: Name, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.box_trace_multi_by_profile(world_context_object, start, end, half_size, orientation, profile_name, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Sweep a box against the world and return all initial overlaps using a specific profile, then overlapping hits and then first blocking hit
        Results are sorted, so a blocking hit (if found) will be the last element of the array
        Only the single closest blocking result will be generated, no tests will be done after that
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            half_size (Vector): Distance from the center of box along each axis
            orientation (Rotator): Orientation of the box
            profile_name (Name): The 'profile' used to determine which components to hit
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a blocking hit, false otherwise.
        
            out_hits (Array[HitResult]): A list of hits, sorted along the trace from start to finish. The blocking hit will be the last hit, if there was one.
        """
        ...
    @classmethod
    def box_trace_multi(cls, world_context_object: Object, start: Vector, end: Vector, half_size: Vector, orientation: Rotator, trace_channel: TraceTypeQuery, trace_complex: bool, actors_to_ignore: Array[Actor], draw_debug_type: DrawDebugTrace, ignore_self: bool = True, trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> Optional[Array[HitResult]]:
        r"""
        X.box_trace_multi(world_context_object, start, end, half_size, orientation, trace_channel, trace_complex, actors_to_ignore, draw_debug_type, ignore_self=True, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> Array[HitResult] or None
        Sweeps a box along the given line and returns all hits encountered.
        This trace finds the objects that RESPONDS to the given TraceChannel
        
        Args:
            world_context_object (Object): 
            start (Vector): Start of line segment.
            end (Vector): End of line segment.
            half_size (Vector): Distance from the center of box along each axis
            orientation (Rotator): Orientation of the box
            trace_channel (TraceTypeQuery): 
            trace_complex (bool): True to test against complex collision, false to test against simplified collision.
            actors_to_ignore (Array[Actor]): 
            draw_debug_type (DrawDebugTrace): 
            ignore_self (bool): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            Array[HitResult] or None: True if there was a blocking hit, false otherwise.
        
            out_hits (Array[HitResult]): A list of hits, sorted along the trace from start to finish. The blocking hit will be the last hit, if there was one.
        """
        ...
    @classmethod
    def box_overlap_components(cls, world_context_object: Object, box_pos: Vector, extent: Vector, object_types: Array[ObjectTypeQuery], component_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[PrimitiveComponent]]:
        r"""
        X.box_overlap_components(world_context_object, box_pos, extent, object_types, component_class_filter, actors_to_ignore) -> Array[PrimitiveComponent] or None
        Returns an array of components that overlap the given axis-aligned box.
        
        Args:
            world_context_object (Object): 
            box_pos (Vector): Center of box.
            extent (Vector): 
            object_types (Array[ObjectTypeQuery]): 
            component_class_filter (type(Class)): 
            actors_to_ignore (Array[Actor]): Ignore these actors in the list
        
        Returns:
            Array[PrimitiveComponent] or None: true if there was an overlap that passed the filters, false otherwise.
        
            out_components (Array[PrimitiveComponent]):
        """
        ...
    @classmethod
    def box_overlap_components_new(cls, world_context_object: Object, box_pos: Vector, extent: Vector, object_types: Array[ObjectTypeQuery], component_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[PrimitiveComponent]]:
        r"""
        deprecated: 'box_overlap_components_new' was renamed to 'box_overlap_components'.
        """
        ...
    @classmethod
    def box_overlap_actors(cls, world_context_object: Object, box_pos: Vector, box_extent: Vector, object_types: Array[ObjectTypeQuery], actor_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[Actor]]:
        r"""
        X.box_overlap_actors(world_context_object, box_pos, box_extent, object_types, actor_class_filter, actors_to_ignore) -> Array[Actor] or None
        Returns an array of actors that overlap the given axis-aligned box.
        
        Args:
            world_context_object (Object): 
            box_pos (Vector): Center of box.
            box_extent (Vector): Extents of box.
            object_types (Array[ObjectTypeQuery]): 
            actor_class_filter (type(Class)): 
            actors_to_ignore (Array[Actor]): Ignore these actors in the list
        
        Returns:
            Array[Actor] or None: true if there was an overlap that passed the filters, false otherwise.
        
            out_actors (Array[Actor]): Returned array of actors. Unsorted.
        """
        ...
    @classmethod
    def box_overlap_actors_new(cls, world_context_object: Object, box_pos: Vector, box_extent: Vector, object_types: Array[ObjectTypeQuery], actor_class_filter: Class, actors_to_ignore: Array[Actor]) -> Optional[Array[Actor]]:
        r"""
        deprecated: 'box_overlap_actors_new' was renamed to 'box_overlap_actors'.
        """
        ...
    @classmethod
    def begin_transaction(cls, context: str, description: Text, primary_object: Object) -> int:
        r"""
        X.begin_transaction(context, description, primary_object) -> int32
        Begin a new undo transaction. An undo transaction is defined as all actions which take place when the user selects "undo" a single time.
        note: If there is already an active transaction in progress, then this increments that transaction's action counter instead of beginning a new transaction.
        note: You must call TransactObject before modifying each object that should be included in this undo transaction.
        note: Only available in the editor.
        
        Args:
            context (str): The context for the undo session. Typically the tool/editor that caused the undo operation.
            description (Text): The description for the undo session. This is the text that will appear in the "Edit" menu next to the Undo item.
            primary_object (Object): The primary object that the undo session operators on (can be null, and mostly is).
        
        Returns:
            int32: The number of active actions when BeginTransaction was called (values greater than 0 indicate that there was already an existing undo transaction in progress), or -1 on failure.
        """
        ...
    @classmethod
    def add_float_history_sample(cls, value: float, float_history: DebugFloatHistory) -> DebugFloatHistory:
        r"""
        X.add_float_history_sample(value, float_history) -> DebugFloatHistory
        Add Float History Sample
        
        Args:
            value (float): 
            float_history (DebugFloatHistory): 
        
        Returns:
            DebugFloatHistory:
        """
        ...

class Paths(BlueprintFunctionLibrary):
    r"""
    Function library to expose FPaths to Blueprints and Python
    
    Function signatures are preserved for the most part with adjustments made to some
    signatures to better match Blueprints / Python workflow
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPathsLibrary.h
    
    """
    @classmethod
    def video_capture_dir(cls) -> str:
        r"""
        X.video_capture_dir() -> str
        Returns the directory the engine uses to output user requested video capture files.
        
        Returns:
            str: Video capture directory
        """
        ...
    @classmethod
    def validate_path(cls, path: str) -> Tuple[bool, Text]:
        r"""
        X.validate_path(path) -> (did_succeed=bool, out_reason=Text)
        Validates that the parts that make up the path contain no invalid characters as dictated by the operating system
        Note that this is a different set of restrictions to those imposed by FPackageName
        
        Args:
            path (str): path to validate
        
        Returns:
            tuple: 
        
            did_succeed (bool): Whether the path could be validated
        
            out_reason (Text): If validation fails, this is filled with the failure reason
        """
        ...
    @classmethod
    def split(cls, path: str) -> Tuple[str, str, str]:
        r"""
        X.split(path) -> (path_part=str, filename_part=str, extension_part=str)
        Parses a fully qualified or relative filename into its components (filename, path, extension).
        
        Args:
            path (str): 
        
        Returns:
            tuple: 
        
            path_part (str): 
        
            filename_part (str): 
        
            extension_part (str):
        """
        ...
    @classmethod
    def source_config_dir(cls) -> str:
        r"""
        X.source_config_dir() -> str
        Returns the directory the engine uses to look for the source leaf ini files. This
        can't be an .ini variable for obvious reasons.
        
        Returns:
            str: source config directory
        """
        ...
    @classmethod
    def should_save_to_user_dir(cls) -> bool:
        r"""
        X.should_save_to_user_dir() -> bool
        Should the "saved" directory structures be rooted in the user dir or relative to the "engine/game"
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def shader_working_dir(cls) -> str:
        r"""
        X.shader_working_dir() -> str
        Returns the Shader Working Directory
        
        Returns:
            str: shader working directory
        """
        ...
    @classmethod
    def set_project_file_path(cls, new_game_project_file_path: str) -> None:
        r"""
        X.set_project_file_path(new_game_project_file_path) -> None
        Sets the path to the project file.
        
        Args:
            new_game_project_file_path (str): The project file path to set.
        """
        ...
    @classmethod
    def set_extension(cls, path: str, new_extension: str) -> str:
        r"""
        X.set_extension(path, new_extension) -> str
        Sets the extension of the given filename (like ChangeExtension, but also applies the extension if the file doesn't have one)
        
        Args:
            path (str): 
            new_extension (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def screen_shot_dir(cls) -> str:
        r"""
        X.screen_shot_dir() -> str
        Returns the directory the engine uses to output screenshot files.
        
        Returns:
            str: screenshot directory
        """
        ...
    @classmethod
    def sandboxes_dir(cls) -> str:
        r"""
        X.sandboxes_dir() -> str
        Returns the directory the engine stores sandbox output
        
        Returns:
            str: sandbox directory
        """
        ...
    @classmethod
    def root_dir(cls) -> str:
        r"""
        X.root_dir() -> str
        Returns the root directory of the engine directory tree
        
        Returns:
            str: Root directory.
        """
        ...
    @classmethod
    def remove_duplicate_slashes(cls, path: str) -> str:
        r"""
        X.remove_duplicate_slashes(path) -> str
        Removes duplicate slashes in paths.
        Assumes all slashes have been converted to TEXT('/').
        For example, takes the string:
              BaseDirectory/SomeDirectory//SomeOtherDirectory////Filename.ext
        and converts it to:
              BaseDirectory/SomeDirectory/SomeOtherDirectory/Filename.ext
        
        Args:
            path (str): 
        
        Returns:
            str: 
        
            out_path (str):
        """
        ...
    @classmethod
    def project_user_dir(cls) -> str:
        r"""
        X.project_user_dir() -> str
        Returns the root directory for user-specific game files.
        
        Returns:
            str: game user directory
        """
        ...
    @classmethod
    def project_saved_dir(cls) -> str:
        r"""
        X.project_saved_dir() -> str
        Returns the saved directory of the current game by looking at FApp::GetProjectName().
        
        Returns:
            str: saved directory
        """
        ...
    @classmethod
    def project_plugins_dir(cls) -> str:
        r"""
        X.project_plugins_dir() -> str
        Returns the plugins directory of the current game by looking at FApp::GetProjectName().
        
        Returns:
            str: plugins directory
        """
        ...
    @classmethod
    def project_persistent_download_dir(cls) -> str:
        r"""
        X.project_persistent_download_dir() -> str
        * Returns the writable directory for downloaded data that persists across play sessions.
        
        Returns:
            str:
        """
        ...
    @classmethod
    def project_mods_dir(cls) -> str:
        r"""
        X.project_mods_dir() -> str
        Returns the mods directory of the current project by looking at FApp::GetProjectName().
        
        Returns:
            str: mods directory
        """
        ...
    @classmethod
    def project_log_dir(cls) -> str:
        r"""
        X.project_log_dir() -> str
        Returns the directory the engine uses to output logs. This currently can't
        be an .ini setting as the game starts logging before it can read from .ini
        files.
        
        Returns:
            str: log directory
        """
        ...
    @classmethod
    def project_intermediate_dir(cls) -> str:
        r"""
        X.project_intermediate_dir() -> str
        Returns the intermediate directory of the current game by looking at FApp::GetProjectName().
        
        Returns:
            str: intermediate directory
        """
        ...
    @classmethod
    def project_dir(cls) -> str:
        r"""
        X.project_dir() -> str
        Returns the base directory of the current project by looking at FApp::GetProjectName().
        This is usually a subdirectory of the installation
        root directory and can be overridden on the command line to allow self
        contained mod support.
        
        Returns:
            str: base directory
        """
        ...
    @classmethod
    def project_content_dir(cls) -> str:
        r"""
        X.project_content_dir() -> str
        Returns the content directory of the current game by looking at FApp::GetProjectName().
        
        Returns:
            str: content directory
        """
        ...
    @classmethod
    def project_config_dir(cls) -> str:
        r"""
        X.project_config_dir() -> str
        Returns the directory the root configuration files are located.
        
        Returns:
            str: root config directory
        """
        ...
    @classmethod
    def profiling_dir(cls) -> str:
        r"""
        X.profiling_dir() -> str
        Returns the directory the engine uses to output profiling files.
        
        Returns:
            str: log directory
        """
        ...
    @classmethod
    def normalize_filename(cls, path: str) -> str:
        r"""
        X.normalize_filename(path) -> str
        Convert all / and \ to TEXT("/")
        
        Args:
            path (str): 
        
        Returns:
            str: 
        
            out_path (str):
        """
        ...
    @classmethod
    def normalize_directory_name(cls, path: str) -> str:
        r"""
        X.normalize_directory_name(path) -> str
        Normalize all / and \ to TEXT("/") and remove any trailing TEXT("/") if the character before that is not a TEXT("/") or a colon
        
        Args:
            path (str): 
        
        Returns:
            str: 
        
            out_path (str):
        """
        ...
    @classmethod
    def make_valid_file_name(cls, string: str, replacement_char: str = "") -> str:
        r"""
        X.make_valid_file_name(string, replacement_char="") -> str
        Returns a string that is safe to use as a filename because all items in
        GetInvalidFileSystemChars() are removed
        
        Optionally specify the character to replace invalid characters with
        
        Args:
            string (str): 
            replacement_char (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def make_standard_filename(cls, path: str) -> str:
        r"""
        X.make_standard_filename(path) -> str
        Make fully standard "Unreal" pathname:
           - Normalizes path separators [NormalizeFilename]
           - Removes extraneous separators  [NormalizeDirectoryName, as well removing adjacent separators]
           - Collapses internal ..'s
           - Makes relative to Engine\Binaries\<Platform> (will ALWAYS start with ..\..\..)
        
        Args:
            path (str): 
        
        Returns:
            str: 
        
            out_path (str):
        """
        ...
    @classmethod
    def make_platform_filename(cls, path: str) -> str:
        r"""
        X.make_platform_filename(path) -> str
        Takes an "Unreal" pathname and converts it to a platform filename.
        
        Args:
            path (str): 
        
        Returns:
            str: 
        
            out_path (str):
        """
        ...
    @classmethod
    def make_path_relative_to(cls, path: str, relative_to: str) -> Optional[str]:
        r"""
        X.make_path_relative_to(path, relative_to) -> str or None
        Assuming both paths (or filenames) are relative to the same base dir, converts InPath to be relative to InRelativeTo
        
        Args:
            path (str): Path to change to be relative to InRelativeTo
            relative_to (str): Path to use as the new relative base
        
        Returns:
            str or None: true if OutPath was changed to be relative
        
            out_path (str):
        """
        ...
    @classmethod
    def launch_dir(cls) -> str:
        r"""
        X.launch_dir() -> str
        Returns the directory the application was launched from (useful for commandline utilities)
        
        Returns:
            str:
        """
        ...
    @classmethod
    def is_same_path(cls, path_a: str, path_b: str) -> bool:
        r"""
        X.is_same_path(path_a, path_b) -> bool
        Checks if two paths are the same.
        
        Args:
            path_a (str): First path to check.
            path_b (str): Second path to check.
        
        Returns:
            bool: True if both paths are the same. False otherwise.
        """
        ...
    @classmethod
    def is_restricted_path(cls, path: str) -> bool:
        r"""
        X.is_restricted_path(path) -> bool
        Determines if supplied path uses a restricted/internal subdirectory.  Note that slashes are normalized and character case is ignored for the comparison.
        
        Args:
            path (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_relative(cls, path: str) -> bool:
        r"""
        X.is_relative(path) -> bool
        Returns true if this path is relative to another path
        
        Args:
            path (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_project_file_path_set(cls) -> bool:
        r"""
        X.is_project_file_path_set() -> bool
        Checks whether the path to the project file, if any, is set.
        
        Returns:
            bool: true if the path is set, false otherwise.
        """
        ...
    @classmethod
    def is_drive(cls, path: str) -> bool:
        r"""
        X.is_drive(path) -> bool
        Returns true if this path represents a root drive or volume
        
        Args:
            path (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def has_project_persistent_download_dir(cls) -> bool:
        r"""
        X.has_project_persistent_download_dir() -> bool
        * Returns true if a writable directory for downloaded data that persists across play sessions is available
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_tool_tip_localization_paths(cls) -> Array[str]:
        r"""
        X.get_tool_tip_localization_paths() -> Array[str]
        Returns a list of tool tip localization paths
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def get_restricted_folder_names(cls) -> Array[str]:
        r"""
        X.get_restricted_folder_names() -> Array[str]
        Returns a list of restricted/internal folder names (without any slashes) which may be tested against full paths to determine if a path is restricted or not.
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def get_relative_path_to_root(cls) -> str:
        r"""
        X.get_relative_path_to_root() -> str
        Gets the relative path to get from BaseDir to RootDirectory
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_property_name_localization_paths(cls) -> Array[str]:
        r"""
        X.get_property_name_localization_paths() -> Array[str]
        Returns a list of property name localization paths
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def get_project_file_path(cls) -> str:
        r"""
        X.get_project_file_path() -> str
        Gets the path to the project file.
        
        Returns:
            str: Project file path.
        """
        ...
    @classmethod
    def get_path(cls, path: str) -> str:
        r"""
        X.get_path(path) -> str
        Returns the path in front of the filename
        
        Args:
            path (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_invalid_file_system_chars(cls) -> str:
        r"""
        X.get_invalid_file_system_chars() -> str
        Returns a string containing all invalid characters as dictated by the operating system
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_game_localization_paths(cls) -> Array[str]:
        r"""
        X.get_game_localization_paths() -> Array[str]
        Returns a list of game-specific localization paths
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def get_extension(cls, path: str, include_dot: bool = False) -> str:
        r"""
        X.get_extension(path, include_dot=False) -> str
        Gets the extension for this filename.
        
        Args:
            path (str): 
            include_dot (bool): if true, includes the leading dot in the result
        
        Returns:
            str: the extension of this filename, or an empty string if the filename doesn't have an extension.
        """
        ...
    @classmethod
    def get_engine_localization_paths(cls) -> Array[str]:
        r"""
        X.get_engine_localization_paths() -> Array[str]
        Returns a list of engine-specific localization paths
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def get_editor_localization_paths(cls) -> Array[str]:
        r"""
        X.get_editor_localization_paths() -> Array[str]
        Returns a list of editor-specific localization paths
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def get_clean_filename(cls, path: str) -> str:
        r"""
        X.get_clean_filename(path) -> str
        Returns the filename (with extension), minus any path information.
        
        Args:
            path (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_base_filename(cls, path: str, remove_path: bool = True) -> str:
        r"""
        X.get_base_filename(path, remove_path=True) -> str
        Returns the same thing as GetCleanFilename, but without the extension
        
        Args:
            path (str): 
            remove_path (bool): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def generated_config_dir(cls) -> str:
        r"""
        X.generated_config_dir() -> str
        Returns the directory the engine saves generated config files.
        
        Returns:
            str: config directory
        """
        ...
    @classmethod
    def game_user_developer_dir(cls) -> str:
        r"""
        X.game_user_developer_dir() -> str
        Returns the directory that contains developer-specific content for the current user
        
        Returns:
            str:
        """
        ...
    @classmethod
    def game_source_dir(cls) -> str:
        r"""
        X.game_source_dir() -> str
        Returns the directory where game source code files are kept
        
        Returns:
            str:
        """
        ...
    @classmethod
    def game_developers_dir(cls) -> str:
        r"""
        X.game_developers_dir() -> str
        Returns the directory that contains subfolders for developer-specific content
        
        Returns:
            str:
        """
        ...
    @classmethod
    def game_agnostic_saved_dir(cls) -> str:
        r"""
        X.game_agnostic_saved_dir() -> str
        Returns the saved directory that is not game specific. This is usually the same as
        EngineSavedDir().
        
        Returns:
            str: saved directory
        """
        ...
    @classmethod
    def file_exists(cls, path: str) -> bool:
        r"""
        X.file_exists(path) -> bool
        Returns true if this file was found, false otherwise
        
        Args:
            path (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def feature_pack_dir(cls) -> str:
        r"""
        X.feature_pack_dir() -> str
        Returns the directory where feature packs are kept
        
        Returns:
            str:
        """
        ...
    @classmethod
    def enterprise_plugins_dir(cls) -> str:
        r"""
        X.enterprise_plugins_dir() -> str
        Returns the enterprise plugins directory
        
        Returns:
            str: Plugins directory.
        """
        ...
    @classmethod
    def enterprise_feature_pack_dir(cls) -> str:
        r"""
        X.enterprise_feature_pack_dir() -> str
        Returns the enterprise FeaturePack directory
        
        Returns:
            str: FeaturePack directory.
        """
        ...
    @classmethod
    def enterprise_dir(cls) -> str:
        r"""
        X.enterprise_dir() -> str
        Returns the base directory enterprise directory.
        
        Returns:
            str: enterprise directory
        """
        ...
    @classmethod
    def engine_version_agnostic_user_dir(cls) -> str:
        r"""
        X.engine_version_agnostic_user_dir() -> str
        Returns the root directory for user-specific engine files which can be shared between versions. Always writable.
        
        Returns:
            str: root user directory
        """
        ...
    @classmethod
    def engine_user_dir(cls) -> str:
        r"""
        X.engine_user_dir() -> str
        Returns the root directory for user-specific engine files. Always writable.
        
        Returns:
            str: root user directory
        """
        ...
    @classmethod
    def engine_source_dir(cls) -> str:
        r"""
        X.engine_source_dir() -> str
        Returns the directory where engine source code files are kept
        
        Returns:
            str:
        """
        ...
    @classmethod
    def engine_saved_dir(cls) -> str:
        r"""
        X.engine_saved_dir() -> str
        Returns the saved directory of the engine
        
        Returns:
            str: Saved directory.
        """
        ...
    @classmethod
    def engine_plugins_dir(cls) -> str:
        r"""
        X.engine_plugins_dir() -> str
        Returns the plugins directory of the engine
        
        Returns:
            str: Plugins directory.
        """
        ...
    @classmethod
    def engine_intermediate_dir(cls) -> str:
        r"""
        X.engine_intermediate_dir() -> str
        Returns the intermediate directory of the engine
        
        Returns:
            str: content directory
        """
        ...
    @classmethod
    def engine_dir(cls) -> str:
        r"""
        X.engine_dir() -> str
        Returns the base directory of the "core" engine that can be shared across
        several games or across games & mods. Shaders and base localization files
        e.g. reside in the engine directory.
        
        Returns:
            str: engine directory
        """
        ...
    @classmethod
    def engine_content_dir(cls) -> str:
        r"""
        X.engine_content_dir() -> str
        Returns the content directory of the "core" engine that can be shared across
        several games or across games & mods.
        
        Returns:
            str: engine content directory
        """
        ...
    @classmethod
    def engine_config_dir(cls) -> str:
        r"""
        X.engine_config_dir() -> str
        Returns the directory the root configuration files are located.
        
        Returns:
            str: root config directory
        """
        ...
    @classmethod
    def directory_exists(cls, path: str) -> bool:
        r"""
        X.directory_exists(path) -> bool
        Returns true if this directory was found, false otherwise
        
        Args:
            path (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def diff_dir(cls) -> str:
        r"""
        X.diff_dir() -> str
        Returns the directory for temp files used for diffing
        
        Returns:
            str:
        """
        ...
    @classmethod
    def create_temp_filename(cls, path: str, prefix: str = "", extension: str = ".tmp") -> str:
        r"""
        X.create_temp_filename(path, prefix="", extension=".tmp") -> str
        Creates a temporary filename with the specified prefix.
        
        Args:
            path (str): The file pathname.
            prefix (str): The file prefix.
            extension (str): File extension ('.' required).
        
        Returns:
            str:
        """
        ...
    @classmethod
    def convert_to_sandbox_path(cls, path: str, sandbox_name: str) -> str:
        r"""
        X.convert_to_sandbox_path(path, sandbox_name) -> str
        Converts a normal path to a sandbox path (in Saved/Sandboxes).
        
        Args:
            path (str): 
            sandbox_name (str): The name of the sandbox.
        
        Returns:
            str:
        """
        ...
    @classmethod
    def convert_relative_path_to_full(cls, path: str, base_path: str = "") -> str:
        r"""
        X.convert_relative_path_to_full(path, base_path="") -> str
        Converts a relative path name to a fully qualified name relative to the specified BasePath.
        BasePath will be the process BaseDir() if not BasePath is given
        
        Args:
            path (str): 
            base_path (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def convert_from_sandbox_path(cls, path: str, sandbox_name: str) -> str:
        r"""
        X.convert_from_sandbox_path(path, sandbox_name) -> str
        Converts a sandbox (in Saved/Sandboxes) path to a normal path.
        
        Args:
            path (str): 
            sandbox_name (str): The name of the sandbox.
        
        Returns:
            str:
        """
        ...
    @classmethod
    def combine(cls, paths: Array[str]) -> str:
        r"""
        X.combine(paths) -> str
        Combine two or more Paths into one single Path
        
        Args:
            paths (Array[str]): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def collapse_relative_directories(cls, path: str) -> Optional[str]:
        r"""
        X.collapse_relative_directories(path) -> str or None
        Takes a fully pathed string and eliminates relative pathing (eg: annihilates ".." with the adjacent directory).
        Assumes all slashes have been converted to TEXT('/').
        For example, takes the string:
              BaseDirectory/SomeDirectory/../SomeOtherDirectory/Filename.ext
        and converts it to:
              BaseDirectory/SomeOtherDirectory/Filename.ext
        
        Args:
            path (str): 
        
        Returns:
            str or None: 
        
            out_path (str):
        """
        ...
    @classmethod
    def cloud_dir(cls) -> str:
        r"""
        X.cloud_dir() -> str
        Returns the directory for local files used in cloud emulation or support
        
        Returns:
            str:
        """
        ...
    @classmethod
    def change_extension(cls, path: str, new_extension: str) -> str:
        r"""
        X.change_extension(path, new_extension) -> str
        Changes the extension of the given filename (does nothing if the file has no extension)
        
        Args:
            path (str): 
            new_extension (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def bug_it_dir(cls) -> str:
        r"""
        X.bug_it_dir() -> str
        Returns the directory the engine uses to output BugIt files.
        
        Returns:
            str: screenshot directory
        """
        ...
    @classmethod
    def automation_transient_dir(cls) -> str:
        r"""
        X.automation_transient_dir() -> str
        Returns the directory for automation save files that are meant to be deleted every run
        
        Returns:
            str:
        """
        ...
    @classmethod
    def automation_log_dir(cls) -> str:
        r"""
        X.automation_log_dir() -> str
        Returns the directory for automation log files
        
        Returns:
            str:
        """
        ...
    @classmethod
    def automation_dir(cls) -> str:
        r"""
        X.automation_dir() -> str
        Returns the directory for automation save files
        
        Returns:
            str:
        """
        ...

class PlatformGameInstance(GameInstance):
    r"""
    UObject based class for handling mobile events. Having this object as an option gives the app lifetime access to these global delegates. The component UApplicationLifecycleComponent is destroyed at level loads
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``application_failed_to_register_for_remote_notifications_delegate`` (PlatformFailedToRegisterForRemoteNotificationsDelegate):  [Read-Write] called when the application fails to register for remote notifications
    - ``application_has_entered_foreground_delegate`` (PlatformDelegate):  [Read-Write] Called when the application is returning to the foreground (reverse any processing done in the EnterBackground delegate)
    - ``application_has_reactivated_delegate`` (PlatformDelegate):  [Read-Write] Called when the application has been reactivated (reverse any processing done in the Deactivate delegate)
    - ``application_received_local_notification_delegate`` (PlatformReceivedLocalNotificationDelegate):  [Read-Write] called when the application receives a local notification
    - ``application_received_remote_notification_delegate`` (PlatformReceivedRemoteNotificationDelegate):  [Read-Write] called when the application receives a remote notification
    - ``application_received_screen_orientation_changed_notification_delegate`` (PlatformScreenOrientationChangedDelegate):  [Read-Write] called when the application receives a screen orientation change notification
    - ``application_received_startup_arguments_delegate`` (PlatformStartupArgumentsDelegate):  [Read-Write] Called with arguments passed to the application on statup, perhaps meta data passed on by another application which launched this one.
    - ``application_registered_for_remote_notifications_delegate`` (PlatformRegisteredForRemoteNotificationsDelegate):  [Read-Write] called when the user grants permission to register for remote notifications
    - ``application_registered_for_user_notifications_delegate`` (PlatformRegisteredForUserNotificationsDelegate):  [Read-Write] called when the user grants permission to register for notifications
    - ``application_should_unload_resources_delegate`` (PlatformDelegate):  [Read-Write] Called when the OS is running low on resources and asks the application to free up any cached resources, drop graphics quality etc.
    - ``application_will_deactivate_delegate`` (PlatformDelegate):  [Read-Write] This is called when the application is about to be deactivated (e.g., due to a phone call or SMS or the sleep button).
      The game should be paused if possible, etc...
    - ``application_will_enter_background_delegate`` (PlatformDelegate):  [Read-Write] This is called when the application is being backgrounded (e.g., due to switching
      to another app or closing it via the home button)
      The game should release shared resources, save state, etc..., since it can be
      terminated from the background state without any further warning.
    - ``application_will_terminate_delegate`` (PlatformDelegate):  [Read-Write] This *may* be called when the application is getting terminated by the OS.
      There is no guarantee that this will ever be called on a mobile device,
      save state when ApplicationWillEnterBackgroundDelegate is called instead.
    - ``on_input_device_connection_change`` (OnUserInputDeviceConnectionChange):  [Read-Write] Callback for when an input device connection state has changed (a new gamepad was connected or disconnected)
    - ``on_pawn_controller_changed_delegates`` (OnPawnControllerChanged):  [Read-Write] gets triggered shortly after a pawn's controller is set. Most of the time
          it signals that the Controller has changed but in edge cases (like during
          replication) it might end up broadcasting the same pawn-controller pair
          more than once
    - ``on_user_input_device_pairing_change`` (OnUserInputDevicePairingChange):  [Read-Write] Callback when an input device has changed pairings (the owning platform user has changed for that device)
    """
    @property
    def application_will_deactivate_delegate(self) -> PlatformDelegate:
        r"""
        (PlatformDelegate):  [Read-Write] This is called when the application is about to be deactivated (e.g., due to a phone call or SMS or the sleep button).
        The game should be paused if possible, etc...
        """
        ...
    @application_will_deactivate_delegate.setter
    def application_will_deactivate_delegate(self, value: PlatformDelegate) -> None:
        ...
    @property
    def application_has_reactivated_delegate(self) -> PlatformDelegate:
        r"""
        (PlatformDelegate):  [Read-Write] Called when the application has been reactivated (reverse any processing done in the Deactivate delegate)
        """
        ...
    @application_has_reactivated_delegate.setter
    def application_has_reactivated_delegate(self, value: PlatformDelegate) -> None:
        ...
    @property
    def application_will_enter_background_delegate(self) -> PlatformDelegate:
        r"""
        (PlatformDelegate):  [Read-Write] This is called when the application is being backgrounded (e.g., due to switching
        to another app or closing it via the home button)
        The game should release shared resources, save state, etc..., since it can be
        terminated from the background state without any further warning.
        """
        ...
    @application_will_enter_background_delegate.setter
    def application_will_enter_background_delegate(self, value: PlatformDelegate) -> None:
        ...
    @property
    def application_has_entered_foreground_delegate(self) -> PlatformDelegate:
        r"""
        (PlatformDelegate):  [Read-Write] Called when the application is returning to the foreground (reverse any processing done in the EnterBackground delegate)
        """
        ...
    @application_has_entered_foreground_delegate.setter
    def application_has_entered_foreground_delegate(self, value: PlatformDelegate) -> None:
        ...
    @property
    def application_will_terminate_delegate(self) -> PlatformDelegate:
        r"""
        (PlatformDelegate):  [Read-Write] This *may* be called when the application is getting terminated by the OS.
        There is no guarantee that this will ever be called on a mobile device,
        save state when ApplicationWillEnterBackgroundDelegate is called instead.
        """
        ...
    @application_will_terminate_delegate.setter
    def application_will_terminate_delegate(self, value: PlatformDelegate) -> None:
        ...
    @property
    def application_should_unload_resources_delegate(self) -> PlatformDelegate:
        r"""
        (PlatformDelegate):  [Read-Write] Called when the OS is running low on resources and asks the application to free up any cached resources, drop graphics quality etc.
        """
        ...
    @application_should_unload_resources_delegate.setter
    def application_should_unload_resources_delegate(self, value: PlatformDelegate) -> None:
        ...
    @property
    def application_received_startup_arguments_delegate(self) -> PlatformStartupArgumentsDelegate:
        r"""
        (PlatformStartupArgumentsDelegate):  [Read-Write] Called with arguments passed to the application on statup, perhaps meta data passed on by another application which launched this one.
        """
        ...
    @application_received_startup_arguments_delegate.setter
    def application_received_startup_arguments_delegate(self, value: PlatformStartupArgumentsDelegate) -> None:
        ...
    @property
    def application_registered_for_remote_notifications_delegate(self) -> PlatformRegisteredForRemoteNotificationsDelegate:
        r"""
        (PlatformRegisteredForRemoteNotificationsDelegate):  [Read-Write] called when the user grants permission to register for remote notifications
        """
        ...
    @application_registered_for_remote_notifications_delegate.setter
    def application_registered_for_remote_notifications_delegate(self, value: PlatformRegisteredForRemoteNotificationsDelegate) -> None:
        ...
    @property
    def application_registered_for_user_notifications_delegate(self) -> PlatformRegisteredForUserNotificationsDelegate:
        r"""
        (PlatformRegisteredForUserNotificationsDelegate):  [Read-Write] called when the user grants permission to register for notifications
        """
        ...
    @application_registered_for_user_notifications_delegate.setter
    def application_registered_for_user_notifications_delegate(self, value: PlatformRegisteredForUserNotificationsDelegate) -> None:
        ...
    @property
    def application_failed_to_register_for_remote_notifications_delegate(self) -> PlatformFailedToRegisterForRemoteNotificationsDelegate:
        r"""
        (PlatformFailedToRegisterForRemoteNotificationsDelegate):  [Read-Write] called when the application fails to register for remote notifications
        """
        ...
    @application_failed_to_register_for_remote_notifications_delegate.setter
    def application_failed_to_register_for_remote_notifications_delegate(self, value: PlatformFailedToRegisterForRemoteNotificationsDelegate) -> None:
        ...
    @property
    def application_received_remote_notification_delegate(self) -> PlatformReceivedRemoteNotificationDelegate:
        r"""
        (PlatformReceivedRemoteNotificationDelegate):  [Read-Write] called when the application receives a remote notification
        """
        ...
    @application_received_remote_notification_delegate.setter
    def application_received_remote_notification_delegate(self, value: PlatformReceivedRemoteNotificationDelegate) -> None:
        ...
    @property
    def application_received_local_notification_delegate(self) -> PlatformReceivedLocalNotificationDelegate:
        r"""
        (PlatformReceivedLocalNotificationDelegate):  [Read-Write] called when the application receives a local notification
        """
        ...
    @application_received_local_notification_delegate.setter
    def application_received_local_notification_delegate(self, value: PlatformReceivedLocalNotificationDelegate) -> None:
        ...
    @property
    def application_received_screen_orientation_changed_notification_delegate(self) -> PlatformScreenOrientationChangedDelegate:
        r"""
        (PlatformScreenOrientationChangedDelegate):  [Read-Write] called when the application receives a screen orientation change notification
        """
        ...
    @application_received_screen_orientation_changed_notification_delegate.setter
    def application_received_screen_orientation_changed_notification_delegate(self, value: PlatformScreenOrientationChangedDelegate) -> None:
        ...

class PlatformLibrary(BlueprintFunctionLibrary):
    r"""
    Blueprint Platform Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintPlatformLibrary.h
    
    """
    @classmethod
    def set_allowed_device_orientation(cls, new_allowed_device_orientation: ScreenOrientation) -> None:
        r"""
        X.set_allowed_device_orientation(new_allowed_device_orientation) -> None
        Set the allowed orientation of the device.
        
        Args:
            new_allowed_device_orientation (ScreenOrientation):
        """
        ...
    @classmethod
    def schedule_local_notification_from_now(cls, in_seconds_from_now: int, title: Text, body: Text, action: Text, activation_event: str) -> int:
        r"""
        X.schedule_local_notification_from_now(in_seconds_from_now, title, body, action, activation_event) -> int32
        Schedule a local notification to fire inSecondsFromNow from now
        
        Args:
            in_seconds_from_now (int32): The seconds until the notification should fire
            title (Text): The title of the notification
            body (Text): The more detailed description of the notification
            action (Text): The text to be displayed on the slider controller
            activation_event (str): A string that is passed in the delegate callback when the app is brought into the foreground from the user activating the notification
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def schedule_local_notification_badge_from_now(cls, in_seconds_from_now: int, activation_event: str) -> None:
        r"""
        X.schedule_local_notification_badge_from_now(in_seconds_from_now, activation_event) -> None
        Schedule a local notification badge to fire inSecondsFromNow from now
        
        Args:
            in_seconds_from_now (int32): The seconds until the notification should fire
            activation_event (str): A string that is passed in the delegate callback when the app is brought into the foreground from the user activating the notification
        """
        ...
    @classmethod
    def schedule_local_notification_badge_at_time(cls, fire_date_time: DateTime, local_time: bool, activation_event: str) -> int:
        r"""
        X.schedule_local_notification_badge_at_time(fire_date_time, local_time, activation_event) -> int32
        Schedule a local notification badge at a specific time, inLocalTime specifies the current local time or if UTC time should be used
        
        Args:
            fire_date_time (DateTime): The time at which to fire the local notification
            local_time (bool): If true the provided time is in the local timezone, if false it is in UTC
            activation_event (str): A string that is passed in the delegate callback when the app is brought into the foreground from the user activating the notification
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def schedule_local_notification_at_time(cls, fire_date_time: DateTime, local_time: bool, title: Text, body: Text, action: Text, activation_event: str) -> int:
        r"""
        X.schedule_local_notification_at_time(fire_date_time, local_time, title, body, action, activation_event) -> int32
        Schedule a local notification at a specific time, inLocalTime specifies the current local time or if UTC time should be used
        
        Args:
            fire_date_time (DateTime): The time at which to fire the local notification
            local_time (bool): If true the provided time is in the local timezone, if false it is in UTC
            title (Text): The title of the notification
            body (Text): The more detailed description of the notification
            action (Text): The text to be displayed on the slider controller
            activation_event (str): A string that is passed in the delegate callback when the app is brought into the foreground from the user activating the notification
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_launch_notification(cls) -> Tuple[bool, str, int]:
        r"""
        X.get_launch_notification() -> (notification_launched_app=bool, activation_event=str, fire_date=int32)
        Get the local notification that was used to launch the app
        
        Returns:
            tuple: 
        
            notification_launched_app (bool): Return true if a notification was used to launch the app
        
            activation_event (str): Returns the name of the ActivationEvent if a notification was used to launch the app
        
            fire_date (int32): Returns the time the notification was activated
        """
        ...
    @classmethod
    def get_device_orientation(cls) -> ScreenOrientation:
        r"""
        X.get_device_orientation() -> ScreenOrientation
        Returns the current orientation of the device: will be either Portrait, LandscapeLeft, PortraitUpsideDown or LandscapeRight.
        
        Returns:
            ScreenOrientation: An EDeviceScreenOrientation value.
        """
        ...
    @classmethod
    def get_allowed_device_orientation(cls) -> ScreenOrientation:
        r"""
        X.get_allowed_device_orientation() -> ScreenOrientation
        Returns the allowed orientation of the device. This is NOT the same as GetDeviceOrientation, which only returns Portrait, LandscapeLeft,
        PortraitUpsideDown or LandscapeRight. The allowed orientation limits what orientation your device can have. So if you set the allowed orientation
        to LandscapeLeft, GetDeviceOrientation will only ever return LandscapeLeft. But if you set the allowed orientation to LandscapeSensor, you are actually
        restricting the allowed orientations to LandscapeLeft OR LandscapeRight (depending on the sensor), so GetDeviceOrientation might return LandscapeLeft OR LandscapeRight.
        
        Returns:
            ScreenOrientation: An EDeviceScreenOrientation value.
        """
        ...
    @classmethod
    def clear_all_local_notifications(cls) -> None:
        r"""
        X.clear_all_local_notifications() -> None
        Clear all pending local notifications. Typically this will be done before scheduling new notifications when going into the background
        """
        ...
    @classmethod
    def cancel_local_notification_by_id(cls, notification_id: int) -> None:
        r"""
        X.cancel_local_notification_by_id(notification_id) -> None
        Cancel a local notification given the ActivationEvent
        
        Args:
            notification_id (int32): The Id returned from one of the ScheduleLocalNotification* functions
        """
        ...
    @classmethod
    def cancel_local_notification(cls, activation_event: str) -> None:
        r"""
        X.cancel_local_notification(activation_event) -> None
        Cancel a local notification given the ActivationEvent
        
        Args:
            activation_event (str): The string passed into the Schedule call for the notification to be cancelled
        """
        ...

class ImportanceSamplingLibrary(BlueprintFunctionLibrary):
    r"""
    Importance Sampling Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ImportanceSamplingLibrary.h
    
    """
    @classmethod
    def random_sobol_float(cls, index: int, dimension: int, seed: float) -> float:
        r"""
        X.random_sobol_float(index, dimension, seed) -> float
        
        
        Args:
            index (int32): Which sequential point
            dimension (int32): Which Sobol dimension (0 to 15)
            seed (float): Random seed (in the range 0-1) to randomize across multiple sequences
        
        Returns:
            float: Sobol-distributed random number between 0 and 1
        """
        ...
    @classmethod
    def random_sobol_cell3d(cls, index: int, num_cells: int = 1, cell: Vector = [0.000000, 0.000000, 0.000000], seed: Vector = [0.000000, 0.000000, 0.000000]) -> Vector:
        r"""
        X.random_sobol_cell3d(index, num_cells=1, cell=[0.000000, 0.000000, 0.000000], seed=[0.000000, 0.000000, 0.000000]) -> Vector
        
        
        Args:
            index (int32): Which sequential point in the cell (starting at 0)
            num_cells (int32): Size of cell grid, 1 to 1024. Rounded up to the next power of two
            cell (Vector): Give a point from this integer grid cell
            seed (Vector): Random 3D seed (components in the range 0-1) to randomize across multiple sequences
        
        Returns:
            Vector: Sobol-distributed random 3D vector in the given grid cell
        """
        ...
    @classmethod
    def random_sobol_cell2d(cls, index: int, num_cells: int = 1, cell: Vector2D = [0.000000, 0.000000], seed: Vector2D = [0.000000, 0.000000]) -> Vector2D:
        r"""
        X.random_sobol_cell2d(index, num_cells=1, cell=[0.000000, 0.000000], seed=[0.000000, 0.000000]) -> Vector2D
        
        
        Args:
            index (int32): Which sequential point in the cell (starting at 0)
            num_cells (int32): Size of cell grid, 1 to 32768. Rounded up to the next power of two
            cell (Vector2D): Give a point from this integer grid cell
            seed (Vector2D): Random 2D seed (components in the range 0-1) to randomize across multiple sequences
        
        Returns:
            Vector2D: Sobol-distributed random 2D position in the given grid cell
        """
        ...
    @classmethod
    def next_sobol_float(cls, index: int, dimension: int, previous_value: float) -> float:
        r"""
        X.next_sobol_float(index, dimension, previous_value) -> float
        
        
        Args:
            index (int32): Which sequential point
            dimension (int32): Which Sobol dimension (0 to 15)
            previous_value (float): The Sobol value for Index-1
        
        Returns:
            float: Sobol-distributed random number between 0 and 1
        """
        ...
    @classmethod
    def next_sobol_cell3d(cls, index: int, num_cells: int = 1, previous_value: Vector = [0.000000, 0.000000, 0.000000]) -> Vector:
        r"""
        X.next_sobol_cell3d(index, num_cells=1, previous_value=[0.000000, 0.000000, 0.000000]) -> Vector
        
        
        Args:
            index (int32): Which sequential point
            num_cells (int32): Size of cell grid, 1 to 1024. Rounded up to the next power of two
            previous_value (Vector): The Sobol value for Index-1
        
        Returns:
            Vector: Sobol-distributed random 3D position in the same grid cell
        """
        ...
    @classmethod
    def next_sobol_cell2d(cls, index: int, num_cells: int = 1, previous_value: Vector2D = [0.000000, 0.000000]) -> Vector2D:
        r"""
        X.next_sobol_cell2d(index, num_cells=1, previous_value=[0.000000, 0.000000]) -> Vector2D
        
        
        Args:
            index (int32): Which sequential point
            num_cells (int32): Size of cell grid, 1 to 32768. Rounded up to the next power of two
            previous_value (Vector2D): The Sobol value for Index-1
        
        Returns:
            Vector2D: Sobol-distributed random 2D position in the same grid cell
        """
        ...
    @classmethod
    def importance_sample(cls, texture: ImportanceTexture, rand: Vector2D, samples: int, intensity: float) -> Tuple[Vector2D, LinearColor, float, float]:
        r"""
        X.importance_sample(texture, rand, samples, intensity) -> (sample_position=Vector2D, sample_color=LinearColor, sample_intensity=float, sample_size=float)
        Distribute sample points proportional to Texture2D luminance.
        outparam: SamplePosition - Importance sampled 2D output texture coordinate (0-1)
        outparam: SampleColor - Representative color near Position from MIP level for SampleSize
        outparam: SampleIntensity - Intensity of individual points, scaled by probability and number of samples
        outparam: SampleSize - Local density of points near Position (scaled for 1x1 texture space)
        
        Args:
            texture (ImportanceTexture): 
            rand (Vector2D): Random 2D point with components evenly distributed between 0 and 1
            samples (int32): Total number of samples that will be used
            intensity (float): Total intensity for light
        
        Returns:
            tuple: 
        
            sample_position (Vector2D): 
        
            sample_color (LinearColor): 
        
            sample_intensity (float): 
        
            sample_size (float):
        """
        ...

class LevelBounds(Actor):
    r"""
    Defines level bounds
    Updates bounding box automatically based on actors transformation changes or holds fixed user defined bounding box
    Uses only actors where AActor::IsLevelBoundsRelevant() == true
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelBounds.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``auto_update_bounds`` (bool):  [Read-Write] Whether to automatically update actor bounds based on all relevant actors bounds belonging to the same level
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``box_component`` (BoxComponent):  [Read-Write] Bounding box for the level bounds.
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class LevelInstance(Actor):
    r"""
    Level Instance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelInstanceActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``desired_runtime_behavior`` (LevelInstanceRuntimeBehavior):  [Read-Write]
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``level_instance_component`` (LevelInstanceComponent):  [Read-Only]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``world_asset`` (World):  [Read-Write] Level LevelInstance
    """
    def unload_level_instance(self) -> None:
        r"""
        x.unload_level_instance() -> None
        Unload Level Instance
        """
        ...
    def set_world_asset(self, world_asset: World) -> bool:
        r"""
        x.set_world_asset(world_asset) -> bool
        Sets the UWorld asset reference when loading a LevelInstance
        
        Args:
            world_asset (World): 
        
        Returns:
            bool:
        """
        ...
    def load_level_instance(self) -> None:
        r"""
        x.load_level_instance() -> None
        Load Level Instance
        """
        ...
    def is_loaded(self) -> bool:
        r"""
        x.is_loaded() -> bool
        Is Loaded
        
        Returns:
            bool:
        """
        ...
    def get_world_asset(self) -> World:
        r"""
        x.get_world_asset() -> World
        Get World Asset
        
        Returns:
            World:
        """
        ...
    def get_loaded_level(self) -> Level:
        r"""
        x.get_loaded_level() -> Level
        Get Loaded Level
        
        Returns:
            Level:
        """
        ...

class LevelInstanceComponent(SceneComponent):
    r"""
    ULevelInstanceComponent subclasses USceneComponent for Editing purposes so that we can have a proxy to the LevelInstanceActor's RootComponent transform without attaching to it.
    
    It is responsible for updating the transform of the ALevelInstanceEditorInstanceActor which is created when loading a LevelInstance Instance Level
    
    We use this method to avoid attaching the Instance Level Actors to the ILevelInstanceInterface. (Cross level attachment and undo/redo pain)
    
    The LevelInstance Level Actors are attached to this ALevelInstanceEditorInstanceActor keeping the attachment local to the Instance Level and shielded from the transaction buffer.
    
    Avoiding those Level Actors from being part of the Transaction system allows us to unload that level without clearing the transaction buffer. It also allows BP Reinstancing without having to update attachements.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelInstanceComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``edit_filter`` (WorldPartitionActorFilter):  [Read-Write]
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``filter`` (WorldPartitionActorFilter):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class LevelInstanceEditorInstanceActor(Actor):
    r"""
    Editor Only Actor that is spawned inside every LevelInstance Instance Level so that we can update its Actor Transforms through the ILevelInstanceInterface's (ULevelInstanceComponent)
    see: ULevelInstanceComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelInstanceEditorInstanceActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class LevelStreamingLevelInstanceEditor(LevelStreamingAlwaysLoaded):
    r"""
    Level Streaming Level Instance Editor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelInstanceEditorLevelStreaming.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disable_distance_streaming`` (bool):  [Read-Write] Whether this level streaming object should be ignored by world composition distance streaming,
      so streaming state can be controlled by other systems (ex: in blueprints)
    - ``draw_on_level_status_map`` (bool):  [Read-Write] If true, will be drawn on the 'level streaming status' map (STAT LEVELMAP console command)
    - ``editor_streaming_volumes`` (Array[LevelStreamingVolume]):  [Read-Write] The level streaming volumes bound to this level.
    - ``is_static`` (bool):  [Read-Write] Whether this level only contains static actors that aren't affected by gameplay or replication.
      If true, the engine can make certain optimizations and will add this level to the StaticLevels collection.
    - ``level_color`` (LinearColor):  [Read-Write] The level color used for visualization. (Show -> Advanced -> Level Coloration)
    - ``level_lod_index`` (int32):  [Read-Write] Requested LOD. Non LOD sub-levels have Index = -1
    - ``level_transform`` (Transform):  [Read-Write] Transform applied to actors after loading.
    - ``min_time_between_volume_unload_requests`` (float):  [Read-Write] Cooldown time in seconds between volume-based unload requests.  Used in preventing spurious unload requests.
    - ``on_level_hidden`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is no longer visible, may not be removed from world yet
    - ``on_level_loaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed in
    - ``on_level_shown`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is added to the world and is visible
    - ``on_level_unloaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed out
    - ``should_be_loaded`` (bool):  [Read-Write] Whether the level should be loaded
    - ``should_be_visible`` (bool):  [Read-Write] Whether the level should be visible if it is loaded
    - ``should_block_on_load`` (bool):  [Read-Write] Whether we want to force a blocking load
    - ``should_block_on_unload`` (bool):  [Read-Write] Whether we want to force a blocking unload
    - ``streaming_priority`` (int32):  [Read-Write] The relative priority of considering the streaming level. Changing the priority will not interrupt the currently considered level, but will affect the next time a level is being selected for evaluation.
    - ``world_asset`` (World):  [Read-Only] The reference to the world containing the level to load
    """
    ...

class LevelInstancePivot(Actor):
    r"""
    Level Instance Pivot
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelInstanceEditorPivotActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class LevelInstanceInterface(Interface):
    r"""
    Level Instance Interface
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelInstanceInterface.h
    
    """
    def unload_level_instance(self) -> None:
        r"""
        x.unload_level_instance() -> None
        Unload Level Instance
        """
        ...
    def set_world_asset(self, world_asset: World) -> bool:
        r"""
        x.set_world_asset(world_asset) -> bool
        Sets the UWorld asset reference when loading a LevelInstance
        
        Args:
            world_asset (World): 
        
        Returns:
            bool:
        """
        ...
    def load_level_instance(self) -> None:
        r"""
        x.load_level_instance() -> None
        Load Level Instance
        """
        ...
    def is_loaded(self) -> bool:
        r"""
        x.is_loaded() -> bool
        Is Loaded
        
        Returns:
            bool:
        """
        ...
    def get_world_asset(self) -> World:
        r"""
        x.get_world_asset() -> World
        Get World Asset
        
        Returns:
            World:
        """
        ...
    def get_loaded_level(self) -> Level:
        r"""
        x.get_loaded_level() -> Level
        Get Loaded Level
        
        Returns:
            Level:
        """
        ...

class LevelStreamingLevelInstance(LevelStreamingDynamic):
    r"""
    Level Streaming Level Instance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelInstanceLevelStreaming.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disable_distance_streaming`` (bool):  [Read-Write] Whether this level streaming object should be ignored by world composition distance streaming,
      so streaming state can be controlled by other systems (ex: in blueprints)
    - ``draw_on_level_status_map`` (bool):  [Read-Write] If true, will be drawn on the 'level streaming status' map (STAT LEVELMAP console command)
    - ``editor_streaming_volumes`` (Array[LevelStreamingVolume]):  [Read-Write] The level streaming volumes bound to this level.
    - ``initially_loaded`` (bool):  [Read-Write] Whether the level should be loaded at startup
    - ``initially_visible`` (bool):  [Read-Write] Whether the level should be visible at startup if it is loaded
    - ``is_static`` (bool):  [Read-Write] Whether this level only contains static actors that aren't affected by gameplay or replication.
      If true, the engine can make certain optimizations and will add this level to the StaticLevels collection.
    - ``level_color`` (LinearColor):  [Read-Write] The level color used for visualization. (Show -> Advanced -> Level Coloration)
    - ``level_lod_index`` (int32):  [Read-Write] Requested LOD. Non LOD sub-levels have Index = -1
    - ``level_transform`` (Transform):  [Read-Write] Transform applied to actors after loading.
    - ``min_time_between_volume_unload_requests`` (float):  [Read-Write] Cooldown time in seconds between volume-based unload requests.  Used in preventing spurious unload requests.
    - ``on_level_hidden`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is no longer visible, may not be removed from world yet
    - ``on_level_loaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed in
    - ``on_level_shown`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is added to the world and is visible
    - ``on_level_unloaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed out
    - ``should_be_loaded`` (bool):  [Read-Write] Whether the level should be loaded
    - ``should_be_visible`` (bool):  [Read-Write] Whether the level should be visible if it is loaded
    - ``should_block_on_load`` (bool):  [Read-Write] Whether we want to force a blocking load
    - ``should_block_on_unload`` (bool):  [Read-Write] Whether we want to force a blocking unload
    - ``streaming_priority`` (int32):  [Read-Write] The relative priority of considering the streaming level. Changing the priority will not interrupt the currently considered level, but will affect the next time a level is being selected for evaluation.
    - ``world_asset`` (World):  [Read-Only] The reference to the world containing the level to load
    """
    ...

class LevelScriptActor(Actor):
    r"""
    ALevelScriptActor is the base class for classes generated by
    ULevelScriptBlueprints. ALevelScriptActor instances are hidden actors that
    exist within a level, and can execute level-wide logic (operating on specific
    actor instances within the level). The level-script's functionality is defined
    inside the ULevelScriptBlueprint itself (using the blueprint's node-based
    interface).
    see: AActor
    see: https://docs.unrealengine.com/latest/INT/Engine/Blueprints/UserGuide/Types/LevelBlueprint/index.html
    see: ULevelScriptBlueprint
    see: https://docs.unrealengine.com/latest/INT/Engine/Blueprints/index.html
    see: UBlueprint
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LevelScriptActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    def world_origin_location_changed(self, old_origin_location: IntVector, new_origin_location: IntVector) -> None:
        r"""
        x.world_origin_location_changed(old_origin_location, new_origin_location) -> None
        Event called on world origin location changes
        
        Args:
            old_origin_location (IntVector): Previous world origin location
            new_origin_location (IntVector): New world origin location
        """
        ...
    def set_cinematic_mode(self, cinematic_mode: bool, hide_player: bool = True, affects_hud: bool = True, affects_movement: bool = False, affects_turning: bool = False) -> None:
        r"""
        x.set_cinematic_mode(cinematic_mode, hide_player=True, affects_hud=True, affects_movement=False, affects_turning=False) -> None
        Sets the cinematic mode on all PlayerControllers
        
        Args:
            cinematic_mode (bool): 
            hide_player (bool): specify true to hide the player's pawn (only relevant if bInCinematicMode is true)
            affects_hud (bool): specify true if we should show/hide the HUD to match the value of bCinematicMode
            affects_movement (bool): specify true to disable movement in cinematic mode, enable it when leaving
            affects_turning (bool): specify true to disable turning in cinematic mode or enable it when leaving
        """
        ...
    def remote_event(self, event_name: Name) -> bool:
        r"""
        x.remote_event(event_name) -> bool
        Tries to find an event named "EventName" on all other levels, and calls it
        
        Args:
            event_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def level_reset(self) -> None:
        r"""
        x.level_reset() -> None
        
        todo: document
        """
        ...

class LightmassCharacterIndirectDetailVolume(Volume):
    r"""
    Lightmass Character Indirect Detail Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightmassCharacterIndirectDetailVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class LightmassImportanceVolume(Volume):
    r"""
    Lightmass Importance Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightmassImportanceVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class LightWeightInstanceBlueprintFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    Light Weight Instance Blueprint Function Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightWeightInstanceBlueprintFunctionLibrary.h
    
    """
    @classmethod
    def create_new_light_weight_instance(cls, actor_class: Class, transform: Transform, layer: DataLayerInstance, world: World) -> ActorInstanceHandle:
        r"""
        X.create_new_light_weight_instance(actor_class, transform, layer, world) -> ActorInstanceHandle
        Returns a handle to a new light weight instance that represents an object of type ActorClass
        
        Args:
            actor_class (type(Class)): 
            transform (Transform): 
            layer (DataLayerInstance): 
            world (World): 
        
        Returns:
            ActorInstanceHandle:
        """
        ...
    @classmethod
    def convert_actor_to_light_weight_instance(cls, actor: Actor) -> ActorInstanceHandle:
        r"""
        X.convert_actor_to_light_weight_instance(actor) -> ActorInstanceHandle
        Returns a handle to the light weight representation and destroys Actor if successful; Returns a handle to Actor otherwise
        
        Args:
            actor (Actor): 
        
        Returns:
            ActorInstanceHandle:
        """
        ...

class LightWeightInstanceManager(Actor):
    r"""
    Light Weight Instance Manager
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightWeightInstanceManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instance_transforms`` (Array[Transform]):  [Read-Write] Current per instance transforms
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``represented_class`` (type(Class)):  [Read-Write]
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class LightWeightInstanceStaticMeshManager(LightWeightInstanceManager):
    r"""
    Light Weight Instance Static Mesh Manager
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightWeightInstanceStaticMeshManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instance_transforms`` (Array[Transform]):  [Read-Write] Current per instance transforms
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``ism_component`` (InstancedStaticMeshComponent):  [Read-Write]
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``represented_class`` (type(Class)):  [Read-Write]
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def static_mesh(self) -> StaticMesh:
        r"""
        (StaticMesh):  [Read-Only]
        """
        ...
    @property
    def ism_component(self) -> InstancedStaticMeshComponent:
        r"""
        (InstancedStaticMeshComponent):  [Read-Only]
        """
        ...

class LocationVolume(Volume):
    r"""
    A volume representing a location in the world. Used for World Partition loading regions.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LocationVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``debug_color`` (Color):  [Read-Write]
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    def unload(self) -> None:
        r"""
        x.unload() -> None
        Unload this location volume
        """
        ...
    def load(self) -> None:
        r"""
        x.load() -> None
        Load this location volume
        """
        ...
    def is_loaded(self) -> bool:
        r"""
        x.is_loaded() -> bool
        Return if this location volume is loaded
        
        Returns:
            bool:
        """
        ...

class LODActor(Actor):
    r"""
    LODActor is an instance of an autogenerated StaticMesh Actors by Hierarchical LOD System
    This is essentially just StaticMeshActor that you can't move or edit, but it contains multiple actors reference
    see: https://docs.unrealengine.com/BuildingWorlds/HLOD
    see: UStaticMesh
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LODActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``key`` (Name):  [Read-Only] The key used to validate this actor against the proxy
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``lod_draw_distance`` (float):  [Read-Only] what distance do you want this to show up instead of SubActors
    - ``lod_level`` (int32):  [Read-Only] The hierarchy level of this actor; the first tier of HLOD is level 1, the second tier is level 2 and so on.
    - ``material_settings`` (MaterialProxySettings):  [Read-Write] Override Material Settings, used when creating the proxy mesh
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_material_merge_settings`` (bool):  [Read-Write] Flag whether or not to use the override MaterialSettings when creating the proxy mesh
    - ``override_screen_size`` (bool):  [Read-Write] Flag whether or not to use the override ScreenSize when creating the proxy mesh
    - ``override_transition_screen_size`` (bool):  [Read-Write] Flag whether or not to use the override TransitionScreenSize for this proxy mesh
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``proxy`` (HLODProxy):  [Read-Only] The mesh proxy used to display this LOD
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``screen_size`` (int32):  [Read-Write] Override screen size value used in mesh reduction, when creating the proxy mesh
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``static_mesh_component`` (StaticMeshComponent):  [Read-Only] disable display of this component
    - ``sub_actors`` (Array[Actor]):  [Read-Only]
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``transition_screen_size`` (float):  [Read-Write] Override transition screen size value, determines the screen size at which the proxy is visible
      The screen size is based around the projected diameter of the bounding
      sphere of the model. i.e. 0.5 means half the screen's maximum dimension.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class MaterialInstanceActor(Actor):
    r"""
    Material Instance Actor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstanceActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``target_actors`` (Array[Actor]):  [Read-Write] Pointer to actors that we want to control paramters of using Matinee.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def target_actors(self) -> Array[Actor]:
        r"""
        (Array[Actor]):  [Read-Write] Pointer to actors that we want to control paramters of using Matinee.
        """
        ...
    @target_actors.setter
    def target_actors(self, value: Array[Actor]) -> None:
        ...

class MaterialInstanceDynamic(MaterialInstance):
    r"""
    Material Instance Dynamic
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialInstanceDynamic.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Write] Importing data and options used for this material
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``base_property_overrides`` (MaterialInstanceBasePropertyOverrides):  [Read-Write]
    - ``double_vector_parameter_values`` (Array[DoubleVectorParameterValue]):  [Read-Write] DoubleVector parameters.
    - ``font_parameter_values`` (Array[FontParameterValue]):  [Read-Write] Font parameters.
    - ``lightmass_settings`` (LightmassMaterialInterfaceSettings):  [Read-Write] The Lightmass settings for this object.
    - ``nanite_override_material`` (MaterialOverrideNanite):  [Read-Write] An override material which will be used instead of this one when rendering with Nanite.
    - ``neural_profile`` (NeuralProfile):  [Read-Write] Neural network profile. For internal usage, not editable/visible
    - ``override_subsurface_profile`` (bool):  [Read-Write] Defines if SubsurfaceProfile from this instance is used or it uses the parent one.
    - ``parent`` (MaterialInterface):  [Read-Write] Parent material.
    - ``phys_material`` (PhysicalMaterial):  [Read-Write] Physical material to use for this graphics material. Used for sounds, effects etc.
    - ``physical_material_map`` (PhysicalMaterial):  [Read-Write] Physical material map used with physical material mask, when it exists.
    - ``preview_mesh`` (SoftObjectPath):  [Read-Write] The mesh used by the material editor to preview the material.
    - ``runtime_virtual_texture_parameter_values`` (Array[RuntimeVirtualTextureParameterValue]):  [Read-Write] RuntimeVirtualTexture parameters.
    - ``scalar_parameter_values`` (Array[ScalarParameterValue]):  [Read-Write] Scalar parameters.
    - ``sparse_volume_texture_parameter_values`` (Array[SparseVolumeTextureParameterValue]):  [Read-Write] Sparse Volume Texture parameters.
    - ``subsurface_profile`` (SubsurfaceProfile):  [Read-Write] SubsurfaceProfile, for Screen Space Subsurface Scattering..
    - ``texture_parameter_values`` (Array[TextureParameterValue]):  [Read-Write] Texture parameters.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``vector_parameter_values`` (Array[VectorParameterValue]):  [Read-Write] Vector parameters.
    """
    def set_vector_parameter_value_by_info(self, parameter_info: MaterialParameterInfo, value: LinearColor) -> None:
        r"""
        x.set_vector_parameter_value_by_info(parameter_info, value) -> None
        Set an MID vector parameter value, using MPI (to allow access to layer parameters)
        
        Args:
            parameter_info (MaterialParameterInfo): 
            value (LinearColor):
        """
        ...
    def set_vector_parameter_value(self, parameter_name: Name, value: LinearColor) -> None:
        r"""
        x.set_vector_parameter_value(parameter_name, value) -> None
        Set an MID vector parameter value
        
        Args:
            parameter_name (Name): 
            value (LinearColor):
        """
        ...
    def set_texture_parameter_value_by_info(self, parameter_info: MaterialParameterInfo, value: Texture) -> None:
        r"""
        x.set_texture_parameter_value_by_info(parameter_info, value) -> None
        Set an MID texture parameter value using MPI (to allow access to layer parameters)
        
        Args:
            parameter_info (MaterialParameterInfo): 
            value (Texture):
        """
        ...
    def set_texture_parameter_value(self, parameter_name: Name, value: Texture) -> None:
        r"""
        x.set_texture_parameter_value(parameter_name, value) -> None
        Set an MID texture parameter value
        
        Args:
            parameter_name (Name): 
            value (Texture):
        """
        ...
    def set_sparse_volume_texture_parameter_value(self, parameter_name: Name, value: SparseVolumeTexture) -> None:
        r"""
        x.set_sparse_volume_texture_parameter_value(parameter_name, value) -> None
        Set an MID texture parameter value
        
        Args:
            parameter_name (Name): 
            value (SparseVolumeTexture):
        """
        ...
    def set_scalar_parameter_value_by_info(self, parameter_info: MaterialParameterInfo, value: float) -> None:
        r"""
        x.set_scalar_parameter_value_by_info(parameter_info, value) -> None
        Set a MID scalar (float) parameter value using MPI (to allow access to layer parameters)
        
        Args:
            parameter_info (MaterialParameterInfo): 
            value (float):
        """
        ...
    def set_scalar_parameter_value(self, parameter_name: Name, value: float) -> None:
        r"""
        x.set_scalar_parameter_value(parameter_name, value) -> None
        Set a MID scalar (float) parameter value
        
        Args:
            parameter_name (Name): 
            value (float):
        """
        ...
    def set_scalar_parameter_by_index(self, parameter_index: int, value: float) -> bool:
        r"""
        x.set_scalar_parameter_by_index(parameter_index, value) -> bool
        Use the cached value of OutParameterIndex from InitializeScalarParameterAndGetIndex to set the scalar parameter
        ONLY on the exact same MID.  Do NOT presume the index can be used from one instance on another.  Only use this
        pair of functions when optimization is critical; otherwise use either SetScalarParameterValueByInfo or
        SetScalarParameterValue.
        
        Args:
            parameter_index (int32): 
            value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_runtime_virtual_texture_parameter_value_by_info(self, parameter_info: MaterialParameterInfo, value: RuntimeVirtualTexture) -> None:
        r"""
        x.set_runtime_virtual_texture_parameter_value_by_info(parameter_info, value) -> None
        Set an MID texture parameter value using MPI (to allow access to layer parameters)
        
        Args:
            parameter_info (MaterialParameterInfo): 
            value (RuntimeVirtualTexture):
        """
        ...
    def set_runtime_virtual_texture_parameter_value(self, parameter_name: Name, value: RuntimeVirtualTexture) -> None:
        r"""
        x.set_runtime_virtual_texture_parameter_value(parameter_name, value) -> None
        Set an MID texture parameter value
        
        Args:
            parameter_name (Name): 
            value (RuntimeVirtualTexture):
        """
        ...
    def set_double_vector_parameter_value(self, parameter_name: Name, value: Vector4) -> None:
        r"""
        x.set_double_vector_parameter_value(parameter_name, value) -> None
        Set an MID vector parameter value
        
        Args:
            parameter_name (Name): 
            value (Vector4):
        """
        ...
    def interpolate_material_instance_parameters(self, source_a: MaterialInstance, source_b: MaterialInstance, alpha: float) -> None:
        r"""
        x.interpolate_material_instance_parameters(source_a, source_b, alpha) -> None
        Interpolates the scalar and vector parameters of this material instance based on two other material instances, and an alpha blending factor
        The output is the object itself (this).
        Supports the case SourceA==this || SourceB==this
        Both material have to be from the same base material
        
        Args:
            source_a (MaterialInstance): value that is used for Alpha=0, silently ignores the case if 0
            source_b (MaterialInstance): value that is used for Alpha=1, silently ignores the case if 0
            alpha (float): usually in the range 0..1, values outside the range extrapolate
        """
        ...
    def get_vector_parameter_value_by_info(self, parameter_info: MaterialParameterInfo) -> LinearColor:
        r"""
        x.get_vector_parameter_value_by_info(parameter_info) -> LinearColor
        Get the current MID vector parameter value, using MPI (to allow access to layer parameters)
        
        Args:
            parameter_info (MaterialParameterInfo): 
        
        Returns:
            LinearColor:
        """
        ...
    def get_vector_parameter_value(self, parameter_name: Name) -> LinearColor:
        r"""
        x.get_vector_parameter_value(parameter_name) -> LinearColor
        Get the current MID vector parameter value
        
        Args:
            parameter_name (Name): 
        
        Returns:
            LinearColor:
        """
        ...
    def get_texture_parameter_value_by_info(self, parameter_info: MaterialParameterInfo) -> Texture:
        r"""
        x.get_texture_parameter_value_by_info(parameter_info) -> Texture
        Get the current MID texture parameter value, using MPI (to allow access to layer parameters)
        
        Args:
            parameter_info (MaterialParameterInfo): 
        
        Returns:
            Texture:
        """
        ...
    def get_texture_parameter_value(self, parameter_name: Name) -> Texture:
        r"""
        x.get_texture_parameter_value(parameter_name) -> Texture
        Get the current MID texture parameter value
        
        Args:
            parameter_name (Name): 
        
        Returns:
            Texture:
        """
        ...
    def get_scalar_parameter_value_by_info(self, parameter_info: MaterialParameterInfo) -> float:
        r"""
        x.get_scalar_parameter_value_by_info(parameter_info) -> float
        Get the current scalar (float) parameter value from an MID, using MPI (to allow access to layer parameters)
        
        Args:
            parameter_info (MaterialParameterInfo): 
        
        Returns:
            float:
        """
        ...
    def get_scalar_parameter_value(self, parameter_name: Name) -> float:
        r"""
        x.get_scalar_parameter_value(parameter_name) -> float
        Get the current scalar (float) parameter value from an MID
        
        Args:
            parameter_name (Name): 
        
        Returns:
            float:
        """
        ...
    def copy_material_instance_parameters(self, source: MaterialInterface, quick_parameters_only: bool = False) -> None:
        r"""
        x.copy_material_instance_parameters(source, quick_parameters_only=False) -> None
        Copies over parameters given a material interface (copy each instance following the hierarchy)
        Very slow implementation, avoid using at runtime. Hopefully we can replace it later with something like CopyInterpParameters()
        The output is the object itself (this). Copying 'quick parameters only' will result in a much
        faster copy process but will only copy dynamic scalar, vector and texture parameters on clients.
        
        Args:
            source (MaterialInterface): 
            quick_parameters_only (bool): Copy scalar, vector and texture parameters only. Much faster but may not include required data
        """
        ...
    def initialize_scalar_parameter_and_get_index(self, parameter_name: Name, value: float) -> Optional[int]:
        r"""
        x.initialize_scalar_parameter_and_get_index(parameter_name, value) -> int32 or None
        Use this function to set an initial value and fetch the index for use in SetScalarParameterByIndex.  This
        function should only be called once for a particular name, and then use SetScalarParameterByIndex for subsequent
        calls.  However, beware using this except in cases where optimization is critical, which is generally only if
        you're using an unusually high number of parameters in a material and setting a large number of parameters in the
        same frame.  Also, if the material is changed in any way that can change the parameter list, the index can be
        invalidated.
        
        Args:
            parameter_name (Name): 
            value (float): 
        
        Returns:
            int32 or None: 
        
            out_parameter_index (int32):
        """
        ...
    def copy_parameter_overrides(self, material_instance: MaterialInstance) -> None:
        r"""
        x.copy_parameter_overrides(material_instance) -> None
        Copy parameter values from another material instance. This will copy only
        parameters explicitly overridden in that material instance!!
        
        Args:
            material_instance (MaterialInstance):
        """
        ...

class MaterialParameterCollection(Object):
    r"""
    Asset class that contains a list of parameter names and their default values.
    Any number of materials can reference these parameters and get new values when the parameter values are changed.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MaterialParameterCollection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``scalar_parameters`` (Array[CollectionScalarParameter]):  [Read-Write]
    - ``vector_parameters`` (Array[CollectionVectorParameter]):  [Read-Write]
    """
    def get_vector_parameter_names(self) -> Array[Name]:
        r"""
        x.get_vector_parameter_names() -> Array[Name]
        Returns an array of the names of all the vector parameters in this Material Parameter Collection *
        
        Returns:
            Array[Name]:
        """
        ...
    def get_vector_parameter_default_value(self, parameter_name: Name) -> Tuple[LinearColor, bool]:
        r"""
        x.get_vector_parameter_default_value(parameter_name) -> (LinearColor, parameter_found=bool)
        Gets the default value of a scalar parameter from a material collection.
        
        Args:
            parameter_name (Name): The name of the value to get the value of
        
        Returns:
            bool: the value of the parameter
        
            parameter_found (bool): if a parameter with the input name was found
        """
        ...
    def get_scalar_parameter_names(self) -> Array[Name]:
        r"""
        x.get_scalar_parameter_names() -> Array[Name]
        Returns an array of the names of all the scalar parameters in this Material Parameter Collection *
        
        Returns:
            Array[Name]:
        """
        ...
    def get_scalar_parameter_default_value(self, parameter_name: Name) -> Tuple[float, bool]:
        r"""
        x.get_scalar_parameter_default_value(parameter_name) -> (float, parameter_found=bool)
        Gets the default value of a scalar parameter from a material collection.
        
        Args:
            parameter_name (Name): The name of the value to get the value of
        
        Returns:
            bool: the value of the parameter
        
            parameter_found (bool): if a parameter with the input name was found
        """
        ...

class MeshMergeCullingVolume(Volume):
    r"""
    A volume that can be added a level in order to remove triangles from source meshes before generating HLOD or merged meshes
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshMergeCullingVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class MeshVertexPainterLibrary(BlueprintFunctionLibrary):
    r"""
    Mesh Vertex Painter Kismet Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshVertexPainterKismetLibrary.h
    
    """
    @classmethod
    def remove_painted_vertices(cls, static_mesh_component: StaticMeshComponent) -> None:
        r"""
        X.remove_painted_vertices(static_mesh_component) -> None
        Removes vertex colors on a mesh component
        
        Args:
            static_mesh_component (StaticMeshComponent):
        """
        ...
    @classmethod
    def paint_vertices_single_color(cls, static_mesh_component: StaticMeshComponent, fill_color: LinearColor, convert_to_srgb: bool = True) -> None:
        r"""
        X.paint_vertices_single_color(static_mesh_component, fill_color, convert_to_srgb=True) -> None
        Paints vertex colors on a mesh component in a specified color.
        
        Args:
            static_mesh_component (StaticMeshComponent): 
            fill_color (LinearColor): 
            convert_to_srgb (bool):
        """
        ...
    @classmethod
    def paint_vertices_lerp_along_axis(cls, static_mesh_component: StaticMeshComponent, start_color: LinearColor, end_color: LinearColor, axis: VertexPaintAxis, convert_to_srgb: bool = True) -> None:
        r"""
        X.paint_vertices_lerp_along_axis(static_mesh_component, start_color, end_color, axis, convert_to_srgb=True) -> None
        Paints vertex colors on a mesh component lerping from the start to the end color along the specified axis.
        
        Args:
            static_mesh_component (StaticMeshComponent): 
            start_color (LinearColor): 
            end_color (LinearColor): 
            axis (VertexPaintAxis): 
            convert_to_srgb (bool):
        """
        ...

class NavigationObjectBase(Actor):
    r"""
    Navigation Object Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationObjectBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class BandwidthTestActor(Actor):
    r"""
    This ABandwidthTestActor class is used to generate an easily controllable amount of bandwidth.
    It uses property replication to generate it's traffic via a NetDeltaSerializer struct
    Note that the property data is never stored in memory on the simulated clients
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BandwidthTestActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class NetPushModelHelpers(BlueprintFunctionLibrary):
    r"""
    Net Push Model Helpers
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NetPushModelHelpers.h
    
    """
    @classmethod
    def mark_property_dirty(cls, object: Object, property_name: Name) -> None:
        r"""
        X.mark_property_dirty(object, property_name) -> None
        Mark replicated property as dirty with the Push Model networking system
        
        Args:
            object (Object): 
            property_name (Name):
        """
        ...

class Note(Actor):
    r"""
    Note
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Note.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``text`` (str):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def text(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @text.setter
    def text(self, value: str) -> None:
        ...

class PackedLevelActor(LevelInstance):
    r"""
    APackedLevelActor is the result of packing the source level (WorldAsset base class property) into a single actor. See FPackedLevelActorBuilder.
    
    
    Other components are unsupported and will result in an incomplete APackedLevelActor. In this case using a regular ALevelInstance is recommended.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PackedLevelActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``desired_runtime_behavior`` (LevelInstanceRuntimeBehavior):  [Read-Write]
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``level_instance_component`` (LevelInstanceComponent):  [Read-Only]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``world_asset`` (World):  [Read-Write] Level LevelInstance
    """
    ...

class PackedLevelInstance(PackedLevelActor):
    r"""
    deprecated: 'PackedLevelInstance' was renamed to 'PackedLevelActor'.
    """
    ...

class PainCausingVolume(PhysicsVolume):
    r"""
    Volume that causes damage over time to any Actor that overlaps its collision.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PainCausingVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``damage_per_sec`` (float):  [Read-Write] Damage done per second to actors in this volume when bPainCausing=true
    - ``damage_type`` (type(Class)):  [Read-Write] Type of damage done
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``entry_pain`` (bool):  [Read-Write] if bPainCausing, cause pain when something enters the volume in addition to damage each second
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``fluid_friction`` (float):  [Read-Write] This property controls the amount of friction applied by the volume as pawns using CharacterMovement move through it. The higher this value, the harder it will feel to move through
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``pain_causing`` (bool):  [Read-Write] Whether volume currently causes damage.
    - ``pain_interval`` (float):  [Read-Write] If pain causing, time between damage applications.
    - ``physics_on_contact`` (bool):  [Read-Write] By default, the origin of an AActor must be inside a PhysicsVolume for it to affect the actor. However if this flag is true, the other actor only has to touch the volume to be affected by it.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``priority`` (int32):  [Read-Write] Determines which PhysicsVolume takes precedence if they overlap (higher number = higher priority).
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``terminal_velocity`` (float):  [Read-Write] Terminal velocity of pawns using CharacterMovement when falling.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``water_volume`` (bool):  [Read-Write] True if this volume contains a fluid like water
    """
    @property
    def pain_causing(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether volume currently causes damage.
        """
        ...
    @pain_causing.setter
    def pain_causing(self, value: bool) -> None:
        ...
    @property
    def damage_per_sec(self) -> float:
        r"""
        (float):  [Read-Write] Damage done per second to actors in this volume when bPainCausing=true
        """
        ...
    @damage_per_sec.setter
    def damage_per_sec(self, value: float) -> None:
        ...
    @property
    def damage_type(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Type of damage done
        """
        ...
    @damage_type.setter
    def damage_type(self, value: Class) -> None:
        ...
    @property
    def pain_interval(self) -> float:
        r"""
        (float):  [Read-Write] If pain causing, time between damage applications.
        """
        ...
    @pain_interval.setter
    def pain_interval(self, value: float) -> None:
        ...
    @property
    def entry_pain(self) -> bool:
        r"""
        (bool):  [Read-Write] if bPainCausing, cause pain when something enters the volume in addition to damage each second
        """
        ...
    @entry_pain.setter
    def entry_pain(self, value: bool) -> None:
        ...

class ParticleEventManager(Actor):
    r"""
    Particle Event Manager
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ParticleEventManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class AsyncPhysicsInputComponent(ActorComponent):
    r"""
    Async Physics Input Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AsyncPhysicsInputComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    def get_data_to_write(self) -> AsyncPhysicsData:
        r"""
        x.get_data_to_write() -> AsyncPhysicsData
        Get the async physics data to write to. This data will make its way to the async physics tick on client and server. Should not be called from async tick
        
        Returns:
            AsyncPhysicsData:
        """
        ...
    def get_data_to_consume(self) -> AsyncPhysicsData:
        r"""
        x.get_data_to_consume() -> AsyncPhysicsData
        Get the async physics data to execute logic off of. This data should not be modified and will NOT make its way back. Should be called from async tick
        
        Returns:
            AsyncPhysicsData:
        """
        ...

class ClusterUnionActor(Actor):
    r"""
    A lightweight actor that can be used to own a cluster union component.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ClusterUnionActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``cluster_union`` (ClusterUnionComponent):  [Read-Write] The pivot used while building.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def cluster_union(self) -> ClusterUnionComponent:
        r"""
        (ClusterUnionComponent):  [Read-Only] The pivot used while building.
        """
        ...

class ClusterUnionComponent(PrimitiveComponent):
    r"""
    This does the bulk of the work exposing a physics cluster union to the game thread.
    This component needs to be a primitive component primarily because of how physics
    proxies need to be registered with the solver with an association with a primitive component.
    This component can be used as part of AClusterUnionActor or on its own as its list of
    clustered components/actors can be specified dynamically at runtime and/or statically
    on asset creation.
    
    The cluster union component needs to not only maintain a game thread representation of what's happening on the
    physics thread but it also needs to make sure this data gets replicated to every client. A general model of how
    the data flow happens is as follows:
    
     [Server GT Command] -> [Server PT Command] -> [Server Modifies PT Data] -> [Server Sync PT Data back to GT Data].
    
    This enables GT control over what happens to the cluster union BUT ALSO maintains a physics-first approach
    to the cluster union where a physics event can possibly cause the cluster union to break.
    
    The GT data is replicated from the server to the clients either via the FClusterUnionReplicatedData on the cluster union component
    or per-child component data is replicated via the UClusterUnionReplicatedProxyComponent. Generally, the same flow is
    replicated on the client. The only exception is for replicating the X/R/V/W properties on the cluster union particle which does
    a GT -> PT data sync. There's no particula reason this happens...it just mirrors the single particle physics proxy here.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ClusterUnionComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``clustered_components_references`` (Array[ComponentReference]):  [Read-Write] These are the statically clustered components. These should
      be specified in the editor and never change.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_damage_from_collision`` (bool):  [Read-Write] Whether or not collisions against this geometry collection will apply strain which could cause the geometry collection to fracture.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``gravity_group_index_override`` (int32):  [Read-Write] If set to a value not equal to -1, will manually set the cluster union's gravity group
      instead of automatically inheriting it from its children particles.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_added_event`` (OnClusterUnionAddedComponent):  [Read-Write]
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_bounds_changed_event`` (OnClusterUnionBoundsChanged):  [Read-Write]
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_removed_event`` (OnClusterUnionRemovedComponent):  [Read-Write]
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def enable_damage_from_collision(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether or not collisions against this geometry collection will apply strain which could cause the geometry collection to fracture.
        """
        ...
    @enable_damage_from_collision.setter
    def enable_damage_from_collision(self, value: bool) -> None:
        ...
    @property
    def on_component_added_event(self) -> OnClusterUnionAddedComponent:
        r"""
        (OnClusterUnionAddedComponent):  [Read-Write]
        """
        ...
    @on_component_added_event.setter
    def on_component_added_event(self, value: OnClusterUnionAddedComponent) -> None:
        ...
    @property
    def on_component_removed_event(self) -> OnClusterUnionRemovedComponent:
        r"""
        (OnClusterUnionRemovedComponent):  [Read-Write]
        """
        ...
    @on_component_removed_event.setter
    def on_component_removed_event(self, value: OnClusterUnionRemovedComponent) -> None:
        ...
    @property
    def on_component_bounds_changed_event(self) -> OnClusterUnionBoundsChanged:
        r"""
        (OnClusterUnionBoundsChanged):  [Read-Write]
        """
        ...
    @on_component_bounds_changed_event.setter
    def on_component_bounds_changed_event(self, value: OnClusterUnionBoundsChanged) -> None:
        ...
    def set_is_anchored(self, is_anchored: bool) -> None:
        r"""
        x.set_is_anchored(is_anchored) -> None
        Set Is Anchored
        
        Args:
            is_anchored (bool):
        """
        ...
    def set_enable_damage_from_collision(self, value: bool) -> None:
        r"""
        x.set_enable_damage_from_collision(value) -> None
        Set Enable Damage from Collision
        
        Args:
            value (bool):
        """
        ...
    def remove_component_from_cluster(self, component: PrimitiveComponent) -> None:
        r"""
        x.remove_component_from_cluster(component) -> None
        Remove Component from Cluster
        
        Args:
            component (PrimitiveComponent):
        """
        ...
    def remove_component_bones_from_cluster(self, component: PrimitiveComponent, bone_ids: Array[int]) -> None:
        r"""
        x.remove_component_bones_from_cluster(component, bone_ids) -> None
        Remove Component Bones from Cluster
        
        Args:
            component (PrimitiveComponent): 
            bone_ids (Array[int32]):
        """
        ...
    def get_primitive_components(self) -> Array[PrimitiveComponent]:
        r"""
        x.get_primitive_components() -> Array[PrimitiveComponent]
        Get Primitive Components
        
        Returns:
            Array[PrimitiveComponent]:
        """
        ...
    def get_actors(self) -> Array[Actor]:
        r"""
        x.get_actors() -> Array[Actor]
        Get Actors
        
        Returns:
            Array[Actor]:
        """
        ...
    def add_component_to_cluster(self, component: PrimitiveComponent, bone_ids: Array[int], rebuild_geometry: bool = True) -> None:
        r"""
        x.add_component_to_cluster(component, bone_ids, rebuild_geometry=True) -> None
        Add Component to Cluster
        
        Args:
            component (PrimitiveComponent): 
            bone_ids (Array[int32]): 
            rebuild_geometry (bool):
        """
        ...

class ClusterUnionReplicatedProxyComponent(ActorComponent):
    r"""
    This component lets us store replicated information about how any particular UPrimitiveComponent
    should be attached to its parent cluster union. The benefits of using a separate components are:
    
        1) It lets us avoid adding any additional overhead into the UPrimitiveComponent.
     2) It lets the replicated information have the same net relevancy as the actor being added to the cluster union
        rather than having the same net relevancy as the cluster union (i.e. in the case of replicating this data in
        an array in the ClusterUnionComponent).
     3) It lets us pinpoint what exactly is being added/removed (vs if all this data was stored in an array) which lets
        us be a bit more efficient in terms of modifying the cluster union.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ClusterUnionReplicatedProxyComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class ConstraintInstanceBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Constraint Instance Blueprint Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ConstraintInstanceBlueprintLibrary.h
    
    """
    @classmethod
    def set_projection_params(cls, accessor: ConstraintInstanceAccessor, enable_projection: bool, projection_linear_alpha: float, projection_angular_alpha: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_projection_params(accessor, enable_projection, projection_linear_alpha, projection_angular_alpha) -> ConstraintInstanceAccessor
        Sets projection parameters of the constraint
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            enable_projection (bool): true to enable projection
            projection_linear_alpha (float): how much linear projection to apply in [0,1] range
            projection_angular_alpha (float): how much angular projection to apply in [0,1] range
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_parent_dominates(cls, accessor: ConstraintInstanceAccessor, parent_dominates: bool) -> ConstraintInstanceAccessor:
        r"""
        X.set_parent_dominates(accessor, parent_dominates) -> ConstraintInstanceAccessor
        Sets whether the parent body is not affected by it's child motion
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            parent_dominates (bool): true to avoid the parent being affected by its child motion
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_orientation_drive_twist_and_swing(cls, accessor: ConstraintInstanceAccessor, enable_twist_drive: bool, enable_swing_drive: bool) -> ConstraintInstanceAccessor:
        r"""
        X.set_orientation_drive_twist_and_swing(accessor, enable_twist_drive, enable_swing_drive) -> ConstraintInstanceAccessor
        Enables/Disables angular orientation drive. Only relevant if the AngularDriveMode is set to Twist and Swing
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            enable_twist_drive (bool): Indicates whether the drive for the twist axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
            enable_swing_drive (bool): Indicates whether the drive for the swing axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_orientation_drive_slerp(cls, accessor: ConstraintInstanceAccessor, enable_slerp: bool) -> ConstraintInstanceAccessor:
        r"""
        X.set_orientation_drive_slerp(accessor, enable_slerp) -> ConstraintInstanceAccessor
        Enables/Disables the angular orientation slerp drive. Only relevant if the AngularDriveMode is set to SLERP
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            enable_slerp (bool): Indicates whether the SLERP drive should be enabled. Only relevant if the AngularDriveMode is set to SLERP
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_mass_conditioning_enabled(cls, accessor: ConstraintInstanceAccessor, enable_mass_conditioning: bool) -> ConstraintInstanceAccessor:
        r"""
        X.set_mass_conditioning_enabled(accessor, enable_mass_conditioning) -> ConstraintInstanceAccessor
        
        brief: Enable or disable mass conditioning for the constraint.
        
        Args:
            accessor (ConstraintInstanceAccessor): 
            enable_mass_conditioning (bool): 
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor):
        """
        ...
    @classmethod
    def set_linear_velocity_target(cls, accessor: ConstraintInstanceAccessor, vel_target: Vector) -> ConstraintInstanceAccessor:
        r"""
        X.set_linear_velocity_target(accessor, vel_target) -> ConstraintInstanceAccessor
        Sets the target velocity for the linear drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            vel_target (Vector): Target velocity
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_linear_velocity_drive(cls, accessor: ConstraintInstanceAccessor, enable_drive_x: bool, enable_drive_y: bool, enable_drive_z: bool) -> ConstraintInstanceAccessor:
        r"""
        X.set_linear_velocity_drive(accessor, enable_drive_x, enable_drive_y, enable_drive_z) -> ConstraintInstanceAccessor
        Enables/Disables linear velocity drive
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            enable_drive_x (bool): Indicates whether the drive for the X-Axis should be enabled
            enable_drive_y (bool): Indicates whether the drive for the Y-Axis should be enabled
            enable_drive_z (bool): Indicates whether the drive for the Z-Axis should be enabled
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_linear_soft_limit_params(cls, accessor: ConstraintInstanceAccessor, soft_linear_limit: bool, linear_limit_stiffness: float, linear_limit_damping: float, linear_limit_restitution: float, linear_limit_contact_distance: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_linear_soft_limit_params(accessor, soft_linear_limit, linear_limit_stiffness, linear_limit_damping, linear_limit_restitution, linear_limit_contact_distance) -> ConstraintInstanceAccessor
        Sets Constraint Linear Soft Limit parameters
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change *
            soft_linear_limit (bool): True is the linear limit is soft
            linear_limit_stiffness (float): Stiffness of the soft linear limit. Only used when Soft limit is on ( positive value )
            linear_limit_damping (float): Damping of the soft linear limit. Only used when Soft limit is on ( positive value )
            linear_limit_restitution (float): Controls the amount of bounce when the constraint is violated. A restitution value of 1 will bounce back with the same velocity the limit was hit. A value of 0 will stop dead.
            linear_limit_contact_distance (float): Determines how close to the limit we have to get before turning the joint on. Larger value will be more expensive, but will do a better job not violating constraints. A smaller value will be more efficient, but easier to violate.
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change *
        """
        ...
    @classmethod
    def set_linear_position_target(cls, accessor: ConstraintInstanceAccessor, pos_target: Vector) -> ConstraintInstanceAccessor:
        r"""
        X.set_linear_position_target(accessor, pos_target) -> ConstraintInstanceAccessor
        Sets the target position for the linear drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            pos_target (Vector): Target position
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_linear_position_drive(cls, accessor: ConstraintInstanceAccessor, enable_drive_x: bool, enable_drive_y: bool, enable_drive_z: bool) -> ConstraintInstanceAccessor:
        r"""
        X.set_linear_position_drive(accessor, enable_drive_x, enable_drive_y, enable_drive_z) -> ConstraintInstanceAccessor
        Enables/Disables linear position drive
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            enable_drive_x (bool): Indicates whether the drive for the X-Axis should be enabled
            enable_drive_y (bool): Indicates whether the drive for the Y-Axis should be enabled
            enable_drive_z (bool): Indicates whether the drive for the Z-Axis should be enabled
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_linear_plasticity(cls, accessor: ConstraintInstanceAccessor, linear_plasticity: bool, linear_plasticity_threshold: float, plasticity_type: ConstraintPlasticityType) -> ConstraintInstanceAccessor:
        r"""
        X.set_linear_plasticity(accessor, linear_plasticity, linear_plasticity_threshold, plasticity_type) -> ConstraintInstanceAccessor
        Sets Constraint Linear Plasticity properties
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            linear_plasticity (bool): Whether it is possible to reset the target position from the linear displacement
            linear_plasticity_threshold (float): Delta from target needed to reset the target joint
            plasticity_type (ConstraintPlasticityType): 
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_linear_limits(cls, accessor: ConstraintInstanceAccessor, x_motion: LinearConstraintMotion, y_motion: LinearConstraintMotion, z_motion: LinearConstraintMotion, limit: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_linear_limits(accessor, x_motion, y_motion, z_motion, limit) -> ConstraintInstanceAccessor
        Sets Constraint Linear Motion Ranges
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            x_motion (LinearConstraintMotion): Type of motion along the X axis
            y_motion (LinearConstraintMotion): Type of motion along the Y axis
            z_motion (LinearConstraintMotion): Type of motion along the Z axis
            limit (float): linear limit to apply to all axis
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_linear_drive_params(cls, accessor: ConstraintInstanceAccessor, position_strength: float, velocity_strength: float, force_limit: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_linear_drive_params(accessor, position_strength, velocity_strength, force_limit) -> ConstraintInstanceAccessor
        Sets the drive params for the linear drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            position_strength (float): Positional strength for the drive (stiffness)
            velocity_strength (float): Velocity strength of the drive (damping)
            force_limit (float): Max force applied by the drive
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_linear_breakable(cls, accessor: ConstraintInstanceAccessor, linear_breakable: bool, linear_break_threshold: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_linear_breakable(accessor, linear_breakable, linear_break_threshold) -> ConstraintInstanceAccessor
        Sets the Linear Breakable properties
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            linear_breakable (bool): Whether it is possible to break the joint with linear force
            linear_break_threshold (float): Force needed to break the joint
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_disable_collision(cls, accessor: ConstraintInstanceAccessor, disable_collision: bool) -> ConstraintInstanceAccessor:
        r"""
        X.set_disable_collision(accessor, disable_collision) -> ConstraintInstanceAccessor
        Sets whether bodies attched to the constraint can collide or not
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            disable_collision (bool): true to disable collision between constrained bodies
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_contact_transfer_scale(cls, accessor: ConstraintInstanceAccessor, contact_transfer_scale: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_contact_transfer_scale(accessor, contact_transfer_scale) -> ConstraintInstanceAccessor
        Set Contact Transfer Scale
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            contact_transfer_scale (float): Set Contact Transfer Scale onto joints parent
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_angular_velocity_target(cls, accessor: ConstraintInstanceAccessor, vel_target: Vector) -> ConstraintInstanceAccessor:
        r"""
        X.set_angular_velocity_target(accessor, vel_target) -> ConstraintInstanceAccessor
        Sets the target velocity for the angular drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            vel_target (Vector): Target velocity
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_angular_velocity_drive_twist_and_swing(cls, accessor: ConstraintInstanceAccessor, enable_twist_drive: bool, enable_swing_drive: bool) -> ConstraintInstanceAccessor:
        r"""
        X.set_angular_velocity_drive_twist_and_swing(accessor, enable_twist_drive, enable_swing_drive) -> ConstraintInstanceAccessor
        Enables/Disables angular velocity twist and swing drive. Only relevant if the AngularDriveMode is set to Twist and Swing
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            enable_twist_drive (bool): Indicates whether the drive for the twist axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
            enable_swing_drive (bool): Indicates whether the drive for the swing axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_angular_velocity_drive_slerp(cls, accessor: ConstraintInstanceAccessor, enable_slerp: bool) -> ConstraintInstanceAccessor:
        r"""
        X.set_angular_velocity_drive_slerp(accessor, enable_slerp) -> ConstraintInstanceAccessor
        Enables/Disables the angular velocity slerp drive. Only relevant if the AngularDriveMode is set to SLERP
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            enable_slerp (bool): Indicates whether the SLERP drive should be enabled. Only relevant if the AngularDriveMode is set to SLERP
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_angular_soft_twist_limit_params(cls, accessor: ConstraintInstanceAccessor, soft_twist_limit: bool, twist_limit_stiffness: float, twist_limit_damping: float, twist_limit_restitution: float, twist_limit_contact_distance: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_angular_soft_twist_limit_params(accessor, soft_twist_limit, twist_limit_stiffness, twist_limit_damping, twist_limit_restitution, twist_limit_contact_distance) -> ConstraintInstanceAccessor
        Sets Constraint Angular Soft Twist Limit parameters
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change *
            soft_twist_limit (bool): True is the twist limit is soft
            twist_limit_stiffness (float): Stiffness of the soft Twist limit. Only used when Soft limit is on ( positive value )
            twist_limit_damping (float): Damping of the soft Twist limit. Only used when Soft limit is on ( positive value )
            twist_limit_restitution (float): Controls the amount of bounce when the constraint is violated. A restitution value of 1 will bounce back with the same velocity the limit was hit. A value of 0 will stop dead.
            twist_limit_contact_distance (float): Determines how close to the limit we have to get before turning the joint on. Larger value will be more expensive, but will do a better job not violating constraints. A smaller value will be more efficient, but easier to violate.
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change *
        """
        ...
    @classmethod
    def set_angular_soft_swing_limit_params(cls, accessor: ConstraintInstanceAccessor, soft_swing_limit: bool, swing_limit_stiffness: float, swing_limit_damping: float, swing_limit_restitution: float, swing_limit_contact_distance: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_angular_soft_swing_limit_params(accessor, soft_swing_limit, swing_limit_stiffness, swing_limit_damping, swing_limit_restitution, swing_limit_contact_distance) -> ConstraintInstanceAccessor
        Sets Constraint Angular Soft Swing Limit parameters
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change *
            soft_swing_limit (bool): True is the swing limit is soft
            swing_limit_stiffness (float): Stiffness of the soft swing limit. Only used when Soft limit is on ( positive value )
            swing_limit_damping (float): Damping of the soft swing limit. Only used when Soft limit is on ( positive value )
            swing_limit_restitution (float): Controls the amount of bounce when the constraint is violated. A restitution value of 1 will bounce back with the same velocity the limit was hit. A value of 0 will stop dead.
            swing_limit_contact_distance (float): Determines how close to the limit we have to get before turning the joint on. Larger value will be more expensive, but will do a better job not violating constraints. A smaller value will be more efficient, but easier to violate.
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change *
        """
        ...
    @classmethod
    def set_angular_plasticity(cls, accessor: ConstraintInstanceAccessor, angular_plasticity: bool, angular_plasticity_threshold: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_angular_plasticity(accessor, angular_plasticity, angular_plasticity_threshold) -> ConstraintInstanceAccessor
        Sets Constraint Angular Plasticity properties
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            angular_plasticity (bool): Whether it is possible to reset the target angle from the angular displacement
            angular_plasticity_threshold (float): Degrees needed to reset the rest state of the joint
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_angular_orientation_target(cls, accessor: ConstraintInstanceAccessor, pos_target: Rotator) -> ConstraintInstanceAccessor:
        r"""
        X.set_angular_orientation_target(accessor, pos_target) -> ConstraintInstanceAccessor
        Sets the target orientation for the angular drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            pos_target (Rotator): Target orientation
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_angular_limits(cls, accessor: ConstraintInstanceAccessor, swing1_motion_type: AngularConstraintMotion, swing1_limit_angle: float, swing2_motion_type: AngularConstraintMotion, swing2_limit_angle: float, twist_motion_type: AngularConstraintMotion, twist_limit_angle: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_angular_limits(accessor, swing1_motion_type, swing1_limit_angle, swing2_motion_type, swing2_limit_angle, twist_motion_type, twist_limit_angle) -> ConstraintInstanceAccessor
        Sets COnstraint Angular Motion Ranges
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            swing1_motion_type (AngularConstraintMotion): Type of swing motion ( first axis )
            swing1_limit_angle (float): Size of limit in degrees in [0, 180] range
            swing2_motion_type (AngularConstraintMotion): Type of swing motion ( second axis )
            swing2_limit_angle (float): Size of limit in degrees in [0, 180] range
            twist_motion_type (AngularConstraintMotion): Type of twist motion
            twist_limit_angle (float): Size of limit in degrees in [0, 180] range
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_angular_drive_params(cls, accessor: ConstraintInstanceAccessor, position_strength: float, velocity_strength: float, force_limit: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_angular_drive_params(accessor, position_strength, velocity_strength, force_limit) -> ConstraintInstanceAccessor
        Sets the drive params for the angular drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            position_strength (float): Positional strength for the drive (stiffness)
            velocity_strength (float): Velocity strength of the drive (damping)
            force_limit (float): Max force applied by the drive
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_angular_drive_mode(cls, accessor: ConstraintInstanceAccessor, drive_mode: AngularDriveMode) -> ConstraintInstanceAccessor:
        r"""
        X.set_angular_drive_mode(accessor, drive_mode) -> ConstraintInstanceAccessor
        Switches the angular drive mode between SLERP and Twist And Swing
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            drive_mode (AngularDriveMode): The angular drive mode to use. SLERP uses shortest spherical path, but will not work if any angular constraints are locked. Twist and Swing decomposes the path into the different angular degrees of freedom but may experience gimbal lock
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def set_angular_breakable(cls, accessor: ConstraintInstanceAccessor, angular_breakable: bool, angular_break_threshold: float) -> ConstraintInstanceAccessor:
        r"""
        X.set_angular_breakable(accessor, angular_breakable, angular_break_threshold) -> ConstraintInstanceAccessor
        Sets Constraint Angular Breakable properties
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
            angular_breakable (bool): Whether it is possible to break the joint with angular force
            angular_break_threshold (float): Torque needed to break the joint
        
        Returns:
            ConstraintInstanceAccessor: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to change
        """
        ...
    @classmethod
    def get_projection_params(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, float, float]:
        r"""
        X.get_projection_params(accessor) -> (accessor=ConstraintInstanceAccessor, enable_projection=bool, projection_linear_alpha=float, projection_angular_alpha=float)
        Gets projection parameters of the constraint
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            enable_projection (bool): true to enable projection
        
            projection_linear_alpha (float): how much linear projection to apply in [0,1] range
        
            projection_angular_alpha (float): how much angular projection to apply in [0,1] range
        """
        ...
    @classmethod
    def get_parent_dominates(cls, accessor: ConstraintInstanceAccessor) -> Optional[ConstraintInstanceAccessor]:
        r"""
        X.get_parent_dominates(accessor) -> ConstraintInstanceAccessor or None
        Gets whether the parent body is not affected by it's child motion
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            ConstraintInstanceAccessor or None: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        """
        ...
    @classmethod
    def get_orientation_drive_twist_and_swing(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, bool]:
        r"""
        X.get_orientation_drive_twist_and_swing(accessor) -> (accessor=ConstraintInstanceAccessor, out_enable_twist_drive=bool, out_enable_swing_drive=bool)
        Gets whether angular orientation drive are enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_enable_twist_drive (bool): Indicates whether the drive for the twist axis is enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
        
            out_enable_swing_drive (bool): Indicates whether the drive for the swing axis is enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
        """
        ...
    @classmethod
    def get_orientation_drive_slerp(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool]:
        r"""
        X.get_orientation_drive_slerp(accessor) -> (accessor=ConstraintInstanceAccessor, out_enable_slerp=bool)
        Gets whether the angular orientation slerp drive is enabled or not. Only relevant if the AngularDriveMode is set to SLERP
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_enable_slerp (bool): Indicates whether the SLERP drive should be enabled. Only relevant if the AngularDriveMode is set to SLERP
        """
        ...
    @classmethod
    def get_mass_conditioning_enabled(cls, accessor: ConstraintInstanceAccessor) -> Optional[ConstraintInstanceAccessor]:
        r"""
        X.get_mass_conditioning_enabled(accessor) -> ConstraintInstanceAccessor or None
        
        brief: Gets whether mass conditioning is enabled for the constraint.
        
        Args:
            accessor (ConstraintInstanceAccessor): 
        
        Returns:
            ConstraintInstanceAccessor or None: 
        
            accessor (ConstraintInstanceAccessor):
        """
        ...
    @classmethod
    def get_linear_velocity_target(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, Vector]:
        r"""
        X.get_linear_velocity_target(accessor) -> (accessor=ConstraintInstanceAccessor, out_vel_target=Vector)
        Gets the target velocity for the linear drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_vel_target (Vector): Target velocity
        """
        ...
    @classmethod
    def get_linear_velocity_drive(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, bool, bool]:
        r"""
        X.get_linear_velocity_drive(accessor) -> (accessor=ConstraintInstanceAccessor, out_enable_drive_x=bool, out_enable_drive_y=bool, out_enable_drive_z=bool)
        Gets whether linear velocity drive is enabled or not
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_enable_drive_x (bool): Indicates whether the drive for the X-Axis is enabled
        
            out_enable_drive_y (bool): Indicates whether the drive for the Y-Axis is enabled
        
            out_enable_drive_z (bool): Indicates whether the drive for the Z-Axis is enabled
        """
        ...
    @classmethod
    def get_linear_soft_limit_params(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, float, float, float, float]:
        r"""
        X.get_linear_soft_limit_params(accessor) -> (accessor=ConstraintInstanceAccessor, soft_linear_limit=bool, linear_limit_stiffness=float, linear_limit_damping=float, linear_limit_restitution=float, linear_limit_contact_distance=float)
        Gets Constraint Linear Soft Limit parameters
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query *
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query *
        
            soft_linear_limit (bool): True is the Linear limit is soft
        
            linear_limit_stiffness (float): Stiffness of the soft Linear limit. Only used when Soft limit is on ( positive value )
        
            linear_limit_damping (float): Damping of the soft Linear limit. Only used when Soft limit is on ( positive value )
        
            linear_limit_restitution (float): Controls the amount of bounce when the constraint is violated. A restitution value of 1 will bounce back with the same velocity the limit was hit. A value of 0 will stop dead.
        
            linear_limit_contact_distance (float): Determines how close to the limit we have to get before turning the joint on. Larger value will be more expensive, but will do a better job not violating constraints. A smaller value will be more efficient, but easier to violate.
        """
        ...
    @classmethod
    def get_linear_position_target(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, Vector]:
        r"""
        X.get_linear_position_target(accessor) -> (accessor=ConstraintInstanceAccessor, out_pos_target=Vector)
        Gets the target position for the linear drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_pos_target (Vector): Target position
        """
        ...
    @classmethod
    def get_linear_position_drive(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, bool, bool]:
        r"""
        X.get_linear_position_drive(accessor) -> (accessor=ConstraintInstanceAccessor, out_enable_drive_x=bool, out_enable_drive_y=bool, out_enable_drive_z=bool)
        Gets whether linear position drive is enabled or not
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_enable_drive_x (bool): Indicates whether the drive for the X-Axis is enabled
        
            out_enable_drive_y (bool): Indicates whether the drive for the Y-Axis is enabled
        
            out_enable_drive_z (bool): Indicates whether the drive for the Z-Axis is enabled
        """
        ...
    @classmethod
    def get_linear_plasticity(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, float, ConstraintPlasticityType]:
        r"""
        X.get_linear_plasticity(accessor) -> (accessor=ConstraintInstanceAccessor, linear_plasticity=bool, linear_plasticity_threshold=float, plasticity_type=ConstraintPlasticityType)
        Gets Constraint Linear Plasticity properties
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            linear_plasticity (bool): 
        
            linear_plasticity_threshold (float): 
        
            plasticity_type (ConstraintPlasticityType):
        """
        ...
    @classmethod
    def get_linear_limits(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, LinearConstraintMotion, LinearConstraintMotion, LinearConstraintMotion, float]:
        r"""
        X.get_linear_limits(accessor) -> (accessor=ConstraintInstanceAccessor, x_motion=LinearConstraintMotion, y_motion=LinearConstraintMotion, z_motion=LinearConstraintMotion, limit=float)
        Gets Constraint Linear Motion Ranges
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            x_motion (LinearConstraintMotion): Type of motion along the X axis
        
            y_motion (LinearConstraintMotion): Type of motion along the Y axis
        
            z_motion (LinearConstraintMotion): Type of motion along the Z axis
        
            limit (float): linear limit applied to all axis
        """
        ...
    @classmethod
    def get_linear_drive_params(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, float, float, float]:
        r"""
        X.get_linear_drive_params(accessor) -> (accessor=ConstraintInstanceAccessor, out_position_strength=float, out_velocity_strength=float, out_force_limit=float)
        Gets the drive params for the linear drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_position_strength (float): Positional strength for the drive (stiffness)
        
            out_velocity_strength (float): Velocity strength of the drive (damping)
        
            out_force_limit (float): Max force applied by the drive
        """
        ...
    @classmethod
    def get_linear_breakable(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, float]:
        r"""
        X.get_linear_breakable(accessor) -> (accessor=ConstraintInstanceAccessor, linear_breakable=bool, linear_break_threshold=float)
        Gets Constraint Linear Breakable properties
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            linear_breakable (bool): Whether it is possible to break the joint with linear force
        
            linear_break_threshold (float): Force needed to break the joint
        """
        ...
    @classmethod
    def get_disable_collsion(cls, accessor: ConstraintInstanceAccessor) -> Optional[ConstraintInstanceAccessor]:
        r"""
        X.get_disable_collsion(accessor) -> ConstraintInstanceAccessor or None
        Gets whether bodies attched to the constraint can collide or not
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            ConstraintInstanceAccessor or None: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        """
        ...
    @classmethod
    def get_contact_transfer_scale(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, float]:
        r"""
        X.get_contact_transfer_scale(accessor) -> (accessor=ConstraintInstanceAccessor, contact_transfer_scale=float)
        Gets Constraint Contact Transfer Scale properties
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            contact_transfer_scale (float): Scale for transfer of child energy to parent.
        """
        ...
    @classmethod
    def get_attached_body_names(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, Name, Name]:
        r"""
        X.get_attached_body_names(accessor) -> (accessor=ConstraintInstanceAccessor, parent_body=Name, child_body=Name)
        Gets Attached body names
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            parent_body (Name): Parent body name of the constraint
        
            child_body (Name): Child body name of the constraint
        """
        ...
    @classmethod
    def get_angular_velocity_target(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, Vector]:
        r"""
        X.get_angular_velocity_target(accessor) -> (accessor=ConstraintInstanceAccessor, out_vel_target=Vector)
        Gets the target velocity for the angular drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_vel_target (Vector): Target velocity
        """
        ...
    @classmethod
    def get_angular_velocity_drive_twist_and_swing(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, bool]:
        r"""
        X.get_angular_velocity_drive_twist_and_swing(accessor) -> (accessor=ConstraintInstanceAccessor, out_enable_twist_drive=bool, out_enable_swing_drive=bool)
        Gets whether angular velocity twist and swing drive is enabled or not. Only relevant if the AngularDriveMode is set to Twist and Swing
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_enable_twist_drive (bool): Indicates whether the drive for the twist axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
        
            out_enable_swing_drive (bool): Indicates whether the drive for the swing axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
        """
        ...
    @classmethod
    def get_angular_velocity_drive_slerp(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool]:
        r"""
        X.get_angular_velocity_drive_slerp(accessor) -> (accessor=ConstraintInstanceAccessor, out_enable_slerp=bool)
        Gets whether the angular velocity slerp drive is enabled or not. Only relevant if the AngularDriveMode is set to SLERP
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_enable_slerp (bool): Indicates whether the SLERP drive is enabled. Only relevant if the AngularDriveMode is set to SLERP
        """
        ...
    @classmethod
    def get_angular_soft_twist_limit_params(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, float, float, float, float]:
        r"""
        X.get_angular_soft_twist_limit_params(accessor) -> (accessor=ConstraintInstanceAccessor, soft_twist_limit=bool, twist_limit_stiffness=float, twist_limit_damping=float, twist_limit_restitution=float, twist_limit_contact_distance=float)
        Gets Constraint Angular Soft Twist Limit parameters
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query *
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query *
        
            soft_twist_limit (bool): True is the Twist limit is soft
        
            twist_limit_stiffness (float): Stiffness of the soft Twist limit. Only used when Soft limit is on ( positive value )
        
            twist_limit_damping (float): Damping of the soft Twist limit. Only used when Soft limit is on ( positive value )
        
            twist_limit_restitution (float): Controls the amount of bounce when the constraint is violated. A restitution value of 1 will bounce back with the same velocity the limit was hit. A value of 0 will stop dead.
        
            twist_limit_contact_distance (float): Determines how close to the limit we have to get before turning the joint on. Larger value will be more expensive, but will do a better job not violating constraints. A smaller value will be more efficient, but easier to violate.
        """
        ...
    @classmethod
    def get_angular_soft_swing_limit_params(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, float, float, float, float]:
        r"""
        X.get_angular_soft_swing_limit_params(accessor) -> (accessor=ConstraintInstanceAccessor, soft_swing_limit=bool, swing_limit_stiffness=float, swing_limit_damping=float, swing_limit_restitution=float, swing_limit_contact_distance=float)
        Gets Constraint Angular Soft Swing Limit parameters
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query *
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query *
        
            soft_swing_limit (bool): True is the swing limit is soft
        
            swing_limit_stiffness (float): Stiffness of the soft swing limit. Only used when Soft limit is on ( positive value )
        
            swing_limit_damping (float): Damping of the soft swing limit. Only used when Soft limit is on ( positive value )
        
            swing_limit_restitution (float): Controls the amount of bounce when the constraint is violated. A restitution value of 1 will bounce back with the same velocity the limit was hit. A value of 0 will stop dead.
        
            swing_limit_contact_distance (float): Determines how close to the limit we have to get before turning the joint on. Larger value will be more expensive, but will do a better job not violating constraints. A smaller value will be more efficient, but easier to violate.
        """
        ...
    @classmethod
    def get_angular_plasticity(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, float]:
        r"""
        X.get_angular_plasticity(accessor) -> (accessor=ConstraintInstanceAccessor, angular_plasticity=bool, angular_plasticity_threshold=float)
        Sets Constraint Angular Plasticity properties
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            angular_plasticity (bool): Whether it is possible to reset the target angle from the angular displacement
        
            angular_plasticity_threshold (float): Degrees needed to reset the rest state of the joint
        """
        ...
    @classmethod
    def get_angular_orientation_target(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, Rotator]:
        r"""
        X.get_angular_orientation_target(accessor) -> (accessor=ConstraintInstanceAccessor, out_pos_target=Rotator)
        Gets the target orientation for the angular drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_pos_target (Rotator): Target orientation
        """
        ...
    @classmethod
    def get_angular_limits(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, AngularConstraintMotion, float, AngularConstraintMotion, float, AngularConstraintMotion, float]:
        r"""
        X.get_angular_limits(accessor) -> (accessor=ConstraintInstanceAccessor, swing1_motion_type=AngularConstraintMotion, swing1_limit_angle=float, swing2_motion_type=AngularConstraintMotion, swing2_limit_angle=float, twist_motion_type=AngularConstraintMotion, twist_limit_angle=float)
        Gets Constraint Angular Motion Ranges
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            swing1_motion_type (AngularConstraintMotion): Type of swing motion ( first axis )
        
            swing1_limit_angle (float): Size of limit in degrees in [0, 180] range
        
            swing2_motion_type (AngularConstraintMotion): Type of swing motion ( second axis )
        
            swing2_limit_angle (float): Size of limit in degrees in [0, 180] range
        
            twist_motion_type (AngularConstraintMotion): Type of twist motion
        
            twist_limit_angle (float): Size of limit in degrees in [0, 180] range
        """
        ...
    @classmethod
    def get_angular_drive_params(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, float, float, float]:
        r"""
        X.get_angular_drive_params(accessor) -> (accessor=ConstraintInstanceAccessor, out_position_strength=float, out_velocity_strength=float, out_force_limit=float)
        Gets the drive params for the angular drive.
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_position_strength (float): Positional strength for the drive (stiffness)
        
            out_velocity_strength (float): Velocity strength of the drive (damping)
        
            out_force_limit (float): Max force applied by the drive
        """
        ...
    @classmethod
    def get_angular_drive_mode(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, AngularDriveMode]:
        r"""
        X.get_angular_drive_mode(accessor) -> (accessor=ConstraintInstanceAccessor, out_drive_mode=AngularDriveMode)
        Gets the angular drive mode ( SLERP or Twist And Swing)
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            out_drive_mode (AngularDriveMode): The angular drive mode to use. SLERP uses shortest spherical path, but will not work if any angular constraints are locked. Twist and Swing decomposes the path into the different angular degrees of freedom but may experience gimbal lock
        """
        ...
    @classmethod
    def get_angular_breakable(cls, accessor: ConstraintInstanceAccessor) -> Tuple[ConstraintInstanceAccessor, bool, float]:
        r"""
        X.get_angular_breakable(accessor) -> (accessor=ConstraintInstanceAccessor, angular_breakable=bool, angular_break_threshold=float)
        Gets Constraint Angular Breakable properties
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to query
        
            angular_breakable (bool): Whether it is possible to break the joint with angular force
        
            angular_break_threshold (float): Torque needed to break the joint
        """
        ...
    @classmethod
    def copy_params(cls, accessor: ConstraintInstanceAccessor, source_accessor: ConstraintInstanceAccessor, keep_position: bool = True, keep_rotation: bool = True) -> Tuple[ConstraintInstanceAccessor, ConstraintInstanceAccessor]:
        r"""
        X.copy_params(accessor, source_accessor, keep_position=True, keep_rotation=True) -> (accessor=ConstraintInstanceAccessor, source_accessor=ConstraintInstanceAccessor)
        Copies all properties from one constraint to another
        
        Args:
            accessor (ConstraintInstanceAccessor): Constraint accessor to write to
            source_accessor (ConstraintInstanceAccessor): Constraint accessor to read from
            keep_position (bool): Whether to keep original constraint positions
            keep_rotation (bool): Whether to keep original constraint rotations
        
        Returns:
            tuple: 
        
            accessor (ConstraintInstanceAccessor): Constraint accessor to write to
        
            source_accessor (ConstraintInstanceAccessor): Constraint accessor to read from
        """
        ...

class NetworkPhysicsComponent(ActorComponent):
    r"""
    Network physics component that will be attached to any player controller
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NetworkPhysicsComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class PhysicalAnimationComponent(ActorComponent):
    r"""
    Physical Animation Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicalAnimationComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``strength_multiplyer`` (float):  [Read-Write] Multiplies the strength of any active motors. (can blend from 0-1 for example)
    """
    @property
    def strength_multiplyer(self) -> float:
        r"""
        (float):  [Read-Only] Multiplies the strength of any active motors. (can blend from 0-1 for example)
        """
        ...
    def set_strength_multiplyer(self, strength_multiplyer: float) -> None:
        r"""
        x.set_strength_multiplyer(strength_multiplyer) -> None
        Updates strength multiplyer and any active motors
        
        Args:
            strength_multiplyer (float):
        """
        ...
    def set_skeletal_mesh_component(self, skeletal_mesh_component: SkeletalMeshComponent) -> None:
        r"""
        x.set_skeletal_mesh_component(skeletal_mesh_component) -> None
        Sets the skeletal mesh we are driving through physical animation. Will erase any existing physical animation data.
        
        Args:
            skeletal_mesh_component (SkeletalMeshComponent):
        """
        ...
    def get_body_target_transform(self, body_name: Name) -> Transform:
        r"""
        x.get_body_target_transform(body_name) -> Transform
        Returns the target transform for the given body. If physical animation component is not controlling this body, returns its current transform.
        
        Args:
            body_name (Name): 
        
        Returns:
            Transform:
        """
        ...
    def apply_physical_animation_settings_below(self, body_name: Name, physical_animation_data: PhysicalAnimationData, include_self: bool = True) -> None:
        r"""
        x.apply_physical_animation_settings_below(body_name, physical_animation_data, include_self=True) -> None
        Applies the physical animation settings to the body given and all bodies below.
        
        Args:
            body_name (Name): 
            physical_animation_data (PhysicalAnimationData): 
            include_self (bool):
        """
        ...
    def apply_physical_animation_settings(self, body_name: Name, physical_animation_data: PhysicalAnimationData) -> None:
        r"""
        x.apply_physical_animation_settings(body_name, physical_animation_data) -> None
        Applies the physical animation settings to the body given.
        
        Args:
            body_name (Name): 
            physical_animation_data (PhysicalAnimationData):
        """
        ...
    def apply_physical_animation_profile_below(self, body_name: Name, profile_name: Name, include_self: bool = True, clear_not_found: bool = False) -> None:
        r"""
        x.apply_physical_animation_profile_below(body_name, profile_name, include_self=True, clear_not_found=False) -> None
        Applies the physical animation profile to the body given and all bodies below.
        
        Args:
            body_name (Name): The body from which we'd like to start applying the physical animation profile. Finds all bodies below in the skeleton hierarchy. None implies all bodies
            profile_name (Name): The physical animation profile we'd like to apply. For each body in the physics asset we search for physical animation settings with this name.
            include_self (bool): Whether to include the provided body name in the list of bodies we act on (useful to ignore for cases where a root has multiple children)
            clear_not_found (bool): If true, bodies without the given profile name will have any existing physical animation settings cleared. If false, bodies without the given profile name are left untouched.
        """
        ...

class PhysicalMaterialMask(Object):
    r"""
    Physical material masks are used to map multiple physical materials to a single rendering material
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicalMaterialMask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``mask_texture`` (Texture):  [Read-Only] Mask input texture, square aspect ratio recommended. Recognized mask colors include: white, black, red, green, yellow, cyan, turquoise, and magenta.
    - ``uv_channel_index`` (int32):  [Read-Write] StaticMesh UV channel index to use when performing lookups with this mask.
    """
    @property
    def mask_texture(self) -> Texture:
        r"""
        (Texture):  [Read-Only] Mask input texture, square aspect ratio recommended. Recognized mask colors include: white, black, red, green, yellow, cyan, turquoise, and magenta.
        """
        ...
    @property
    def uv_channel_index(self) -> int:
        r"""
        (int32):  [Read-Write] StaticMesh UV channel index to use when performing lookups with this mask.
        """
        ...
    @uv_channel_index.setter
    def uv_channel_index(self, value: int) -> None:
        ...
    @property
    def address_x(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
        """
        ...
    @address_x.setter
    def address_x(self, value: TextureAddress) -> None:
        ...
    @property
    def address_y(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
        """
        ...
    @address_y.setter
    def address_y(self, value: TextureAddress) -> None:
        ...

class PhysicsAsset(Object):
    r"""
    PhysicsAsset contains a set of rigid bodies and constraints that make up a single ragdoll.
    The asset is not limited to human ragdolls, and can be used for any physical simulation using bodies and constraints.
    A SkeletalMesh has a single PhysicsAsset, which allows for easily turning ragdoll physics on or off for many SkeletalMeshComponents
    The asset can be configured inside the Physics Asset Editor.
    see: https://docs.unrealengine.com/InteractiveExperiences/Physics/PhysicsAssetEditor
    see: USkeletalMesh
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``constraint_profiles`` (Array[Name]):  [Read-Write]
    - ``not_for_dedicated_server`` (bool):  [Read-Write] If true, we skip instancing bodies for this PhysicsAsset on dedicated servers
    - ``physical_animation_profiles`` (Array[Name]):  [Read-Write]
    - ``solver_iterations`` (SolverIterations):  [Read-Only] Old solver settings shown for reference. These will be removed at some point.
      When you open an old asset you should see that the settings were transferred to "SolverSettings" above.
      You should usually see:
      SolverSettings.PositionIterations = OldSettings.SolverIterations * OldSetting.JointIterations;
      SolverSettings.VelocityIterations = 1;
      SolverSettings.ProjectionIterations = 1;
    - ``solver_settings`` (PhysicsAssetSolverSettings):  [Read-Write] Solver settings when the asset is used with a RigidBody Anim Node (RBAN).
    - ``solver_type`` (PhysicsAssetSolverType):  [Read-Write] Solver type used in physics asset editor. This can be used to make what you see in the asset editror more closely resembles what you
      see in game (though there will be differences owing to framerate variation etc). If your asset will primarily be used as a ragdoll
      select "World", but if it will be used in the AnimGraph select "RBAN".
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    def get_constraints(self, includes_terminated: bool) -> Array[ConstraintInstanceAccessor]:
        r"""
        x.get_constraints(includes_terminated) -> Array[ConstraintInstanceAccessor]
        Gets all constraints
        
        Args:
            includes_terminated (bool): 
        
        Returns:
            Array[ConstraintInstanceAccessor]: 
        
            out_constraints (Array[ConstraintInstanceAccessor]): returned list of constraints matching the parameters
        """
        ...
    def get_constraint_by_name(self, constraint_name: Name) -> ConstraintInstanceAccessor:
        r"""
        x.get_constraint_by_name(constraint_name) -> ConstraintInstanceAccessor
        Gets a constraint by its joint name
        
        Args:
            constraint_name (Name): name of the constraint
        
        Returns:
            ConstraintInstanceAccessor: ConstraintInstance accessor to the constraint data
        """
        ...
    def get_constraint_by_bone_names(self, bone1_name: Name, bone2_name: Name) -> ConstraintInstanceAccessor:
        r"""
        x.get_constraint_by_bone_names(bone1_name, bone2_name) -> ConstraintInstanceAccessor
        Gets a constraint by its joint name
        
        Args:
            bone1_name (Name): name of the first bone in the joint
            bone2_name (Name): name of the second bone in the joint
        
        Returns:
            ConstraintInstanceAccessor: ConstraintInstance accessor to the constraint data
        """
        ...

class PhysicsCollisionHandler(Object):
    r"""
    Physics Collision Handler
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsCollisionHandler.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_impact_sound`` (SoundBase):  [Read-Write] Sound to play
    - ``impact_re_fire_delay`` (float):  [Read-Write] Min time between effect/sound being triggered
    - ``impact_threshold`` (float):  [Read-Write] How hard an impact must be to trigger effect/sound
    """
    @property
    def impact_threshold(self) -> float:
        r"""
        (float):  [Read-Write] How hard an impact must be to trigger effect/sound
        """
        ...
    @impact_threshold.setter
    def impact_threshold(self, value: float) -> None:
        ...
    @property
    def impact_re_fire_delay(self) -> float:
        r"""
        (float):  [Read-Write] Min time between effect/sound being triggered
        """
        ...
    @impact_re_fire_delay.setter
    def impact_re_fire_delay(self, value: float) -> None:
        ...
    @property
    def default_impact_sound(self) -> SoundBase:
        r"""
        (SoundBase):  [Read-Write] Sound to play
        """
        ...
    @default_impact_sound.setter
    def default_impact_sound(self, value: SoundBase) -> None:
        ...

class PhysicsConstraintActor(RigidBodyBase):
    r"""
    Physics Constraint Actor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsConstraintActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``constraint_comp`` (PhysicsConstraintComponent):  [Read-Only]
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def constraint_comp(self) -> PhysicsConstraintComponent:
        r"""
        (PhysicsConstraintComponent):  [Read-Only]
        """
        ...

class PhysicsBSJointActor(PhysicsConstraintActor):
    r"""
    deprecated: 'PhysicsBSJointActor' was renamed to 'PhysicsConstraintActor'.
    """
    ...

class PhysicsHingeActor(PhysicsConstraintActor):
    r"""
    deprecated: 'PhysicsHingeActor' was renamed to 'PhysicsConstraintActor'.
    """
    ...

class PhysicsPrismaticActor(PhysicsConstraintActor):
    r"""
    deprecated: 'PhysicsPrismaticActor' was renamed to 'PhysicsConstraintActor'.
    """
    ...

class RB_ConstraintActor(PhysicsConstraintActor):
    r"""
    deprecated: 'RB_ConstraintActor' was renamed to 'PhysicsConstraintActor'.
    """
    ...

class PhysicsConstraintComponent(SceneComponent):
    r"""
    This is effectively a joint that allows you to connect 2 rigid bodies together. You can create different types of joints using the various parameters of this component.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsConstraintComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_name1`` (ConstrainComponentPropName):  [Read-Write] Name of first component property to constrain. If Actor1 is NULL, will look within Owner.
      If this is NULL, will use RootComponent of Actor1
    - ``component_name2`` (ConstrainComponentPropName):  [Read-Write] Name of second component property to constrain. If Actor2 is NULL, will look within Owner.
      If this is NULL, will use RootComponent of Actor2
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constraint_actor1`` (Actor):  [Read-Write] Pointer to first Actor to constrain.
    - ``constraint_actor2`` (Actor):  [Read-Write] Pointer to second Actor to constrain.
    - ``constraint_instance`` (ConstraintInstance):  [Read-Write] All constraint settings
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_constraint_broken`` (ConstraintBrokenSignature):  [Read-Write] Notification when constraint is broken.
    - ``on_plastic_deformation`` (PlasticDeformationEventSignature):  [Read-Write] Notification when constraint plasticity drive target changes.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def on_constraint_broken(self) -> ConstraintBrokenSignature:
        r"""
        (ConstraintBrokenSignature):  [Read-Write] Notification when constraint is broken.
        """
        ...
    @on_constraint_broken.setter
    def on_constraint_broken(self, value: ConstraintBrokenSignature) -> None:
        ...
    @property
    def on_plastic_deformation(self) -> PlasticDeformationEventSignature:
        r"""
        (PlasticDeformationEventSignature):  [Read-Write] Notification when constraint plasticity drive target changes.
        """
        ...
    @on_plastic_deformation.setter
    def on_plastic_deformation(self, value: PlasticDeformationEventSignature) -> None:
        ...
    def set_projection_params(self, projection_linear_alpha: float, projection_angular_alpha: float, projection_linear_tolerance: float, projection_angular_tolerance: float) -> None:
        r"""
        x.set_projection_params(projection_linear_alpha, projection_angular_alpha, projection_linear_tolerance, projection_angular_tolerance) -> None
        Set the projection settings for use when projection is enabled. See SetProjectionEnabled.
        For ragdolls you usually require that ProjectionLinearAlpha and ProjectionAngularAlpha be zero. They are most useful for cosmetic chains etc. ProjectionLinearTolerance and ProjectionAngularTolerance
        are emergency error recovery settings and should only rarely affect the simulation. If the simulation is significantly affected by the Tolerance settings, it likely indicates a setup stability issue.
        
        Args:
            projection_linear_alpha (float): Controls the semi-physical correction of linear error remaining after the joint solve. Will add energy into the system. Best for joint chains connected to a kinematic.
            projection_angular_alpha (float): Controls the semi-physical correction of angular error remaining after the joint solve. Will add energy into the system. Best for joint chains connected to a kinematic.
            projection_linear_tolerance (float): Linear errors above this will be corrected with a non-physical teleport.
            projection_angular_tolerance (float): Angular errors above this will be corrected with a non-physical teleport.
        """
        ...
    def set_projection_enabled(self, projection_enabled: bool) -> None:
        r"""
        x.set_projection_enabled(projection_enabled) -> None
        If true, joint projection is enabled. Projection is a semi-physics post-solve correction for fixing small errors, and a teleport for fixing larger errors. See SetProjectionParams
        
        Args:
            projection_enabled (bool):
        """
        ...
    def set_orientation_drive_twist_and_swing(self, enable_twist_drive: bool, enable_swing_drive: bool) -> None:
        r"""
        x.set_orientation_drive_twist_and_swing(enable_twist_drive, enable_swing_drive) -> None
        Enables/Disables angular orientation drive. Only relevant if the AngularDriveMode is set to Twist and Swing
        
        Args:
            enable_twist_drive (bool): Indicates whether the drive for the twist axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
            enable_swing_drive (bool): Indicates whether the drive for the swing axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
        """
        ...
    def set_orientation_drive_slerp(self, enable_slerp: bool) -> None:
        r"""
        x.set_orientation_drive_slerp(enable_slerp) -> None
        Enables/Disables the angular orientation slerp drive. Only relevant if the AngularDriveMode is set to SLERP
        
        Args:
            enable_slerp (bool): Indicates whether the SLERP drive should be enabled. Only relevant if the AngularDriveMode is set to SLERP
        """
        ...
    def set_linear_z_limit(self, constraint_type: LinearConstraintMotion, limit_size: float) -> None:
        r"""
        x.set_linear_z_limit(constraint_type, limit_size) -> None
        Sets the LinearZ Motion Type
        
        Args:
            constraint_type (LinearConstraintMotion): New Constraint Type
            limit_size (float): Size of limit
        """
        ...
    def set_linear_y_limit(self, constraint_type: LinearConstraintMotion, limit_size: float) -> None:
        r"""
        x.set_linear_y_limit(constraint_type, limit_size) -> None
        Sets the LinearY Motion Type
        
        Args:
            constraint_type (LinearConstraintMotion): New Constraint Type
            limit_size (float): Size of limit
        """
        ...
    def set_linear_x_limit(self, constraint_type: LinearConstraintMotion, limit_size: float) -> None:
        r"""
        x.set_linear_x_limit(constraint_type, limit_size) -> None
        Sets the LinearX Motion Type
        
        Args:
            constraint_type (LinearConstraintMotion): New Constraint Type
            limit_size (float): Size of limit
        """
        ...
    def set_linear_velocity_target(self, vel_target: Vector) -> None:
        r"""
        x.set_linear_velocity_target(vel_target) -> None
        Sets the target velocity for the linear drive.
        
        Args:
            vel_target (Vector): Target velocity
        """
        ...
    def set_linear_velocity_drive(self, enable_drive_x: bool, enable_drive_y: bool, enable_drive_z: bool) -> None:
        r"""
        x.set_linear_velocity_drive(enable_drive_x, enable_drive_y, enable_drive_z) -> None
        Enables/Disables linear position drive
        
        Args:
            enable_drive_x (bool): Indicates whether the drive for the X-Axis should be enabled
            enable_drive_y (bool): Indicates whether the drive for the Y-Axis should be enabled
            enable_drive_z (bool): Indicates whether the drive for the Z-Axis should be enabled
        """
        ...
    def set_linear_position_target(self, pos_target: Vector) -> None:
        r"""
        x.set_linear_position_target(pos_target) -> None
        Sets the target position for the linear drive.
        
        Args:
            pos_target (Vector): Target position
        """
        ...
    def set_linear_position_drive(self, enable_drive_x: bool, enable_drive_y: bool, enable_drive_z: bool) -> None:
        r"""
        x.set_linear_position_drive(enable_drive_x, enable_drive_y, enable_drive_z) -> None
        Enables/Disables linear position drive
        
        Args:
            enable_drive_x (bool): Indicates whether the drive for the X-Axis should be enabled
            enable_drive_y (bool): Indicates whether the drive for the Y-Axis should be enabled
            enable_drive_z (bool): Indicates whether the drive for the Z-Axis should be enabled
        """
        ...
    def set_linear_plasticity(self, linear_plasticity: bool, linear_plasticity_threshold: float, plasticity_type: ConstraintPlasticityType) -> None:
        r"""
        x.set_linear_plasticity(linear_plasticity, linear_plasticity_threshold, plasticity_type) -> None
        Sets the Linear Plasticity properties
        
        Args:
            linear_plasticity (bool): Whether it is possible to reset the target angle from the Linear displacement
            linear_plasticity_threshold (float): Percent deformation needed to reset the rest length of the joint
            plasticity_type (ConstraintPlasticityType):
        """
        ...
    def set_linear_drive_params(self, position_strength: float, velocity_strength: float, force_limit: float) -> None:
        r"""
        x.set_linear_drive_params(position_strength, velocity_strength, force_limit) -> None
        Sets the drive params for the linear drive.
        
        Args:
            position_strength (float): Positional strength for the drive (stiffness)
            velocity_strength (float): Velocity strength of the drive (damping)
            force_limit (float): Max force applied by the drive
        """
        ...
    def set_linear_breakable(self, linear_breakable: bool, linear_break_threshold: float) -> None:
        r"""
        x.set_linear_breakable(linear_breakable, linear_break_threshold) -> None
        Sets the Linear Breakable properties
        
        Args:
            linear_breakable (bool): Whether it is possible to break the joint with linear force
            linear_break_threshold (float): Force needed to break the joint
        """
        ...
    def set_disable_collision(self, disable_collision: bool) -> None:
        r"""
        x.set_disable_collision(disable_collision) -> None
        If true, the collision between the two rigid bodies of the constraint will be disabled.
        
        Args:
            disable_collision (bool):
        """
        ...
    def set_contact_transfer_scale(self, contact_transfer_scale: float) -> None:
        r"""
        x.set_contact_transfer_scale(contact_transfer_scale) -> None
        Sets the contact transfer scale properties
        
        Args:
            contact_transfer_scale (float): Set the contact transfer scale for the parent of the joint
        """
        ...
    def set_constraint_reference_position(self, frame: ConstraintFrame, ref_position: Vector) -> None:
        r"""
        x.set_constraint_reference_position(frame, ref_position) -> None
        Pass in reference position in (maintains reference orientation). If the constraint is currently active, this will set its active local pose. Otherwise the change will take affect in InitConstraint.
        
        Args:
            frame (ConstraintFrame): 
            ref_position (Vector):
        """
        ...
    def set_constraint_reference_orientation(self, frame: ConstraintFrame, pri_axis: Vector, sec_axis: Vector) -> None:
        r"""
        x.set_constraint_reference_orientation(frame, pri_axis, sec_axis) -> None
        Pass in reference orientation in (maintains reference position). If the constraint is currently active, this will set its active local pose. Otherwise the change will take affect in InitConstraint.
        
        Args:
            frame (ConstraintFrame): 
            pri_axis (Vector): 
            sec_axis (Vector):
        """
        ...
    def set_constraint_reference_frame(self, frame: ConstraintFrame, ref_frame: Transform) -> None:
        r"""
        x.set_constraint_reference_frame(frame, ref_frame) -> None
        Pass in reference frame in. If the constraint is currently active, this will set its active local pose. Otherwise the change will take affect in InitConstraint.
        
        Args:
            frame (ConstraintFrame): 
            ref_frame (Transform):
        """
        ...
    def set_constrained_components(self, component1: PrimitiveComponent, bone_name1: Name, component2: PrimitiveComponent, bone_name2: Name) -> None:
        r"""
        x.set_constrained_components(component1, bone_name1, component2, bone_name2) -> None
        Directly specify component to connect. Will update frames based on current position.
        
        Args:
            component1 (PrimitiveComponent): 
            bone_name1 (Name): 
            component2 (PrimitiveComponent): 
            bone_name2 (Name):
        """
        ...
    def set_angular_velocity_target(self, vel_target: Vector) -> None:
        r"""
        x.set_angular_velocity_target(vel_target) -> None
        Sets the target velocity for the angular drive.
        
        Args:
            vel_target (Vector): Target velocity
        """
        ...
    def set_angular_velocity_drive_twist_and_swing(self, enable_twist_drive: bool, enable_swing_drive: bool) -> None:
        r"""
        x.set_angular_velocity_drive_twist_and_swing(enable_twist_drive, enable_swing_drive) -> None
        Enables/Disables angular velocity twist and swing drive. Only relevant if the AngularDriveMode is set to Twist and Swing
        
        Args:
            enable_twist_drive (bool): Indicates whether the drive for the twist axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
            enable_swing_drive (bool): Indicates whether the drive for the swing axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
        """
        ...
    def set_angular_velocity_drive_slerp(self, enable_slerp: bool) -> None:
        r"""
        x.set_angular_velocity_drive_slerp(enable_slerp) -> None
        Enables/Disables the angular velocity slerp drive. Only relevant if the AngularDriveMode is set to SLERP
        
        Args:
            enable_slerp (bool): Indicates whether the SLERP drive should be enabled. Only relevant if the AngularDriveMode is set to SLERP
        """
        ...
    def set_angular_velocity_drive(self, enable_swing_drive: bool, enable_twist_drive: bool) -> None:
        r"""
        x.set_angular_velocity_drive(enable_swing_drive, enable_twist_drive) -> None
        Set Angular Velocity Drive
        deprecated: Use SetAngularVelocityDriveTwistAndSwing instead.
        
        Args:
            enable_swing_drive (bool): 
            enable_twist_drive (bool):
        """
        ...
    def set_angular_twist_limit(self, constraint_type: AngularConstraintMotion, twist_limit_angle: float) -> None:
        r"""
        x.set_angular_twist_limit(constraint_type, twist_limit_angle) -> None
        Sets the Angular Twist Motion Type
        
        Args:
            constraint_type (AngularConstraintMotion): New Constraint Type
            twist_limit_angle (float): Size of limit in degrees
        """
        ...
    def set_angular_swing2_limit(self, motion_type: AngularConstraintMotion, swing2_limit_angle: float) -> None:
        r"""
        x.set_angular_swing2_limit(motion_type, swing2_limit_angle) -> None
        Sets the Angular Swing2 Motion Type
        
        Args:
            motion_type (AngularConstraintMotion): 
            swing2_limit_angle (float): Size of limit in degrees
        """
        ...
    def set_angular_swing1_limit(self, motion_type: AngularConstraintMotion, swing1_limit_angle: float) -> None:
        r"""
        x.set_angular_swing1_limit(motion_type, swing1_limit_angle) -> None
        Sets the Angular Swing1 Motion Type
        
        Args:
            motion_type (AngularConstraintMotion): 
            swing1_limit_angle (float): Size of limit in degrees
        """
        ...
    def set_angular_plasticity(self, angular_plasticity: bool, angular_plasticity_threshold: float) -> None:
        r"""
        x.set_angular_plasticity(angular_plasticity, angular_plasticity_threshold) -> None
        Sets the Angular Plasticity properties
        
        Args:
            angular_plasticity (bool): Whether it is possible to reset the target angle from the angular displacement
            angular_plasticity_threshold (float): Degrees needed to reset the rest state of the joint
        """
        ...
    def set_angular_orientation_target(self, pos_target: Rotator) -> None:
        r"""
        x.set_angular_orientation_target(pos_target) -> None
        Sets the target orientation for the angular drive.
        
        Args:
            pos_target (Rotator): Target orientation
        """
        ...
    def set_angular_orientation_drive(self, enable_swing_drive: bool, enable_twist_drive: bool) -> None:
        r"""
        x.set_angular_orientation_drive(enable_swing_drive, enable_twist_drive) -> None
        Enables/Disables angular orientation drive. Only relevant if the AngularDriveMode is set to Twist and Swing
        deprecated: Use SetOrientationDriveTwistAndSwing instead.
        
        Args:
            enable_swing_drive (bool): Indicates whether the drive for the swing axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
            enable_twist_drive (bool): Indicates whether the drive for the twist axis should be enabled. Only relevant if the AngularDriveMode is set to Twist and Swing
        """
        ...
    def set_angular_drive_params(self, position_strength: float, velocity_strength: float, force_limit: float) -> None:
        r"""
        x.set_angular_drive_params(position_strength, velocity_strength, force_limit) -> None
        Sets the drive params for the angular drive.
        
        Args:
            position_strength (float): Positional strength for the drive (stiffness)
            velocity_strength (float): Velocity strength of the drive (damping)
            force_limit (float): Max force applied by the drive
        """
        ...
    def set_angular_drive_mode(self, drive_mode: AngularDriveMode) -> None:
        r"""
        x.set_angular_drive_mode(drive_mode) -> None
        Switches the angular drive mode between SLERP and Twist And Swing
        
        Args:
            drive_mode (AngularDriveMode): The angular drive mode to use. SLERP uses shortest spherical path, but will not work if any angular constraints are locked. Twist and Swing decomposes the path into the different angular degrees of freedom but may experience gimbal lock
        """
        ...
    def set_angular_breakable(self, angular_breakable: bool, angular_break_threshold: float) -> None:
        r"""
        x.set_angular_breakable(angular_breakable, angular_break_threshold) -> None
        Sets the Angular Breakable properties
        
        Args:
            angular_breakable (bool): Whether it is possible to break the joint with angular force
            angular_break_threshold (float): Torque needed to break the joint
        """
        ...
    def is_projection_enabled(self) -> bool:
        r"""
        x.is_projection_enabled() -> bool
        Is projection enabled. See SetProjectionEnabled
        
        Returns:
            bool:
        """
        ...
    def is_broken(self) -> bool:
        r"""
        x.is_broken() -> bool
        Retrieve the status of constraint being broken.
        
        Returns:
            bool:
        """
        ...
    def get_current_twist(self) -> float:
        r"""
        x.get_current_twist() -> float
        Gets the current Angular Twist of the constraint
        
        Returns:
            float:
        """
        ...
    def get_current_swing2(self) -> float:
        r"""
        x.get_current_swing2() -> float
        Gets the current Swing2 of the constraint
        
        Returns:
            float:
        """
        ...
    def get_current_swing1(self) -> float:
        r"""
        x.get_current_swing1() -> float
        Gets the current Swing1 of the constraint
        
        Returns:
            float:
        """
        ...
    def get_constraint_force(self) -> Tuple[Vector, Vector]:
        r"""
        x.get_constraint_force() -> (out_linear_force=Vector, out_angular_force=Vector)
        Retrieve the constraint force most recently applied to maintain this constraint. Returns 0 forces if the constraint is not initialized or broken.
        
        Returns:
            tuple: 
        
            out_linear_force (Vector): 
        
            out_angular_force (Vector):
        """
        ...
    def get_constraint(self) -> ConstraintInstanceAccessor:
        r"""
        x.get_constraint() -> ConstraintInstanceAccessor
        Gets the constraint object
        
        Returns:
            ConstraintInstanceAccessor:
        """
        ...
    def get_constrained_components(self) -> Tuple[PrimitiveComponent, Name, PrimitiveComponent, Name]:
        r"""
        x.get_constrained_components() -> (out_component1=PrimitiveComponent, out_bone_name1=Name, out_component2=PrimitiveComponent, out_bone_name2=Name)
        Get connected components and potential related attachement bones
        
        Returns:
            tuple: 
        
            out_component1 (PrimitiveComponent): 
        
            out_bone_name1 (Name): 
        
            out_component2 (PrimitiveComponent): 
        
            out_bone_name2 (Name):
        """
        ...
    def break_constraint(self) -> None:
        r"""
        x.break_constraint() -> None
        Break this constraint
        """
        ...

class RB_ConstraintComponent(PhysicsConstraintComponent):
    r"""
    deprecated: 'RB_ConstraintComponent' was renamed to 'PhysicsConstraintComponent'.
    """
    ...

class PhysicsHandleComponent(ActorComponent):
    r"""
    Utility object for moving physics objects around.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsHandleComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``angular_damping`` (float):  [Read-Write] Angular damping of the handle spring
    - ``angular_stiffness`` (float):  [Read-Write] Angular stiffness of the handle spring
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``interpolate_target`` (bool):  [Read-Write]
    - ``interpolation_speed`` (float):  [Read-Write] How quickly we interpolate the physics target transform
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``linear_damping`` (float):  [Read-Write] Linear damping of the handle spring.
    - ``linear_stiffness`` (float):  [Read-Write] Linear stiffness of the handle spring
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``soft_angular_constraint`` (bool):  [Read-Write]
    - ``soft_linear_constraint`` (bool):  [Read-Write]
    """
    @property
    def soft_angular_constraint(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def soft_linear_constraint(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def interpolate_target(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @interpolate_target.setter
    def interpolate_target(self, value: bool) -> None:
        ...
    @property
    def linear_damping(self) -> float:
        r"""
        (float):  [Read-Only] Linear damping of the handle spring.
        """
        ...
    @property
    def linear_stiffness(self) -> float:
        r"""
        (float):  [Read-Only] Linear stiffness of the handle spring
        """
        ...
    @property
    def angular_damping(self) -> float:
        r"""
        (float):  [Read-Only] Angular damping of the handle spring
        """
        ...
    @property
    def angular_stiffness(self) -> float:
        r"""
        (float):  [Read-Only] Angular stiffness of the handle spring
        """
        ...
    @property
    def interpolation_speed(self) -> float:
        r"""
        (float):  [Read-Only] How quickly we interpolate the physics target transform
        """
        ...
    def set_target_rotation(self, new_rotation: Rotator) -> None:
        r"""
        x.set_target_rotation(new_rotation) -> None
        Set the target rotation
        
        Args:
            new_rotation (Rotator):
        """
        ...
    def set_target_location_and_rotation(self, new_location: Vector, new_rotation: Rotator) -> None:
        r"""
        x.set_target_location_and_rotation(new_location, new_rotation) -> None
        Set target location and rotation
        
        Args:
            new_location (Vector): 
            new_rotation (Rotator):
        """
        ...
    def set_target_location(self, new_location: Vector) -> None:
        r"""
        x.set_target_location(new_location) -> None
        Set the target location
        
        Args:
            new_location (Vector):
        """
        ...
    def set_linear_stiffness(self, new_linear_stiffness: float) -> None:
        r"""
        x.set_linear_stiffness(new_linear_stiffness) -> None
        Set linear stiffness
        
        Args:
            new_linear_stiffness (float):
        """
        ...
    def set_linear_damping(self, new_linear_damping: float) -> None:
        r"""
        x.set_linear_damping(new_linear_damping) -> None
        Set linear damping
        
        Args:
            new_linear_damping (float):
        """
        ...
    def set_interpolation_speed(self, new_interpolation_speed: float) -> None:
        r"""
        x.set_interpolation_speed(new_interpolation_speed) -> None
        Set interpolation speed
        
        Args:
            new_interpolation_speed (float):
        """
        ...
    def set_angular_stiffness(self, new_angular_stiffness: float) -> None:
        r"""
        x.set_angular_stiffness(new_angular_stiffness) -> None
        Set angular stiffness
        
        Args:
            new_angular_stiffness (float):
        """
        ...
    def set_angular_damping(self, new_angular_damping: float) -> None:
        r"""
        x.set_angular_damping(new_angular_damping) -> None
        Set angular damping
        
        Args:
            new_angular_damping (float):
        """
        ...
    def release_component(self) -> None:
        r"""
        x.release_component() -> None
        Release the currently held component
        """
        ...
    def grab_component_at_location_with_rotation(self, component: PrimitiveComponent, bone_name: Name, location: Vector, rotation: Rotator) -> None:
        r"""
        x.grab_component_at_location_with_rotation(component, bone_name, location, rotation) -> None
        Grab the specified component at a given location and rotation. Constrains rotation.
        
        Args:
            component (PrimitiveComponent): 
            bone_name (Name): 
            location (Vector): 
            rotation (Rotator):
        """
        ...
    def grab_component_at_location(self, component: PrimitiveComponent, bone_name: Name, grab_location: Vector) -> None:
        r"""
        x.grab_component_at_location(component, bone_name, grab_location) -> None
        Grab the specified component at a given location. Does NOT constraint rotation which means the handle will pivot about GrabLocation.
        
        Args:
            component (PrimitiveComponent): 
            bone_name (Name): 
            grab_location (Vector):
        """
        ...
    def grab_component(self, component: PrimitiveComponent, bone_name: Name, grab_location: Vector, constrain_rotation: bool) -> None:
        r"""
        x.grab_component(component, bone_name, grab_location, constrain_rotation) -> None
        Grab Component
        deprecated: Please use GrabComponentAtLocation or GrabComponentAtLocationWithRotation
        
        Args:
            component (PrimitiveComponent): 
            bone_name (Name): 
            grab_location (Vector): 
            constrain_rotation (bool):
        """
        ...
    def get_target_location_and_rotation(self) -> Tuple[Vector, Rotator]:
        r"""
        x.get_target_location_and_rotation() -> (target_location=Vector, target_rotation=Rotator)
        Get the current location and rotation
        
        Returns:
            tuple: 
        
            target_location (Vector): 
        
            target_rotation (Rotator):
        """
        ...
    def get_grabbed_component(self) -> PrimitiveComponent:
        r"""
        x.get_grabbed_component() -> PrimitiveComponent
        Returns the currently grabbed component, or null if nothing is grabbed.
        
        Returns:
            PrimitiveComponent:
        """
        ...

class RB_Handle(PhysicsHandleComponent):
    r"""
    deprecated: 'RB_Handle' was renamed to 'PhysicsHandleComponent'.
    """
    ...

class PhysicsSettingsCore(DeveloperSettings):
    r"""
    Default physics settings.
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: PhysicsSettingsCore.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bounce_threshold_velocity`` (float):  [Read-Write] Minimum relative velocity required for an object to bounce. A typical value for simulation stability is about 0.2 * gravity
    - ``contact_offset_multiplier`` (float):  [Read-Write] Contact offset multiplier. When creating a physics shape we look at its bounding volume and multiply its minimum value by this multiplier. A bigger number will generate contact points earlier which results in higher stability at the cost of performance.
    - ``default_fluid_friction`` (float):  [Read-Write] Default fluid friction for Physics Volumes.
    - ``default_gravity_z`` (float):  [Read-Write] Default gravity.
    - ``default_shape_complexity`` (CollisionTraceFlag):  [Read-Write] Determines the default physics shape complexity.
    - ``default_terminal_velocity`` (float):  [Read-Write] Default terminal velocity for Physics Volumes.
    - ``enable2d_physics`` (bool):  [Read-Write] Can 2D physics be used (Box2D)?
    - ``enable_enhanced_determinism`` (bool):  [Read-Write] If set to true, the scene will use enhanced determinism at the cost of a bit more resources. See eENABLE_ENHANCED_DETERMINISM to learn about the specifics
    - ``enable_pcm`` (bool):  [Read-Write] Enables persistent contact manifolds. This will generate fewer contact points, but with more accuracy. Reduces stability of stacking, but can help energy conservation.
    - ``enable_shape_sharing`` (bool):  [Read-Write] Enables shape sharing between sync and async scene for static rigid actors
    - ``enable_stabilization`` (bool):  [Read-Write] Enables stabilization of contacts for slow moving bodies. This will help improve the stability of stacking.
    - ``friction_combine_mode`` (FrictionCombineMode):  [Read-Write] Friction combine mode, controls how friction is computed for multiple materials.
    - ``max_angular_velocity`` (float):  [Read-Write] Max angular velocity that a simulated object can achieve.
    - ``max_contact_offset`` (float):  [Read-Write] Max Contact offset.
    - ``max_depenetration_velocity`` (float):  [Read-Write] Max velocity which may be used to depenetrate simulated physics objects. 0 means no maximum.
    - ``min_contact_offset`` (float):  [Read-Write] Min Contact offset.
    - ``ragdoll_aggregate_threshold`` (int32):  [Read-Write] Threshold for ragdoll bodies above which they will be added to an aggregate before being added to the scene
    - ``restitution_combine_mode`` (FrictionCombineMode):  [Read-Write] Restitution combine mode, controls how restitution is computed for multiple materials.
    - ``simulate_scratch_memory_size`` (int32):  [Read-Write] Amount of memory to reserve for PhysX simulate(), this is per pxscene and will be rounded up to the next 16K boundary
    - ``simulate_skeletal_mesh_on_dedicated_server`` (bool):  [Read-Write] If true, simulate physics for this component on a dedicated server.
      This should be set if simulating physics and replicating with a dedicated server.
    - ``solver_options`` (ChaosSolverConfiguration):  [Read-Write] Options to apply to Chaos solvers on creation
    - ``triangle_mesh_triangle_min_area_threshold`` (float):  [Read-Write] Triangles from triangle meshes (BSP) with an area less than or equal to this value will be removed from physics collision data. Set to less than 0 to disable.
    - ``warn_missing_locks`` (bool):  [Read-Write] Whether to warn when physics locks are used incorrectly. Turning this off is not recommended and should only be used by very advanced users.
    """
    ...

class PhysicsSettings(PhysicsSettingsCore):
    r"""
    Default physics settings.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_physics_min_delta_time`` (float):  [Read-Write] Min Delta Time below which anim dynamics and rigidbody nodes will not simulate.
    - ``async_fixed_time_step_size`` (float):  [Read-Write] If using async, the time step size to tick at. This feature is still experimental. Certain functionality might not work correctly
    - ``bounce_threshold_velocity`` (float):  [Read-Write] Minimum relative velocity required for an object to bounce. A typical value for simulation stability is about 0.2 * gravity
    - ``chaos_settings`` (ChaosPhysicsSettings):  [Read-Write] Chaos physics engine settings
    - ``contact_offset_multiplier`` (float):  [Read-Write] Contact offset multiplier. When creating a physics shape we look at its bounding volume and multiply its minimum value by this multiplier. A bigger number will generate contact points earlier which results in higher stability at the cost of performance.
    - ``default_broadphase_settings`` (BroadphaseSettings):  [Read-Write] If we want to Enable MPB or not globally. This is then overridden by project settings if not enabled. *
    - ``default_degrees_of_freedom`` (SettingsDOF):  [Read-Write] Useful for constraining all objects in the world, for example if you are making a 2D game using 3D environments.
    - ``default_fluid_friction`` (float):  [Read-Write] Default fluid friction for Physics Volumes.
    - ``default_gravity_z`` (float):  [Read-Write] Default gravity.
    - ``default_shape_complexity`` (CollisionTraceFlag):  [Read-Write] Determines the default physics shape complexity.
    - ``default_terminal_velocity`` (float):  [Read-Write] Default terminal velocity for Physics Volumes.
    - ``disable_active_actors`` (bool):  [Read-Write] If true, physx will not update unreal with any bodies that have moved during the simulation. This should only be used if you have no physx simulation or you are manually updating the unreal data via polling physx.
    - ``disable_ccd`` (bool):  [Read-Write] If true CCD will be ignored. This is an optimization when CCD is never used which removes the need for physx to check it internally.
    - ``disable_kinematic_kinematic_pairs`` (bool):  [Read-Write] Whether to disable generating KK pairs, enabling this speeds up contact generation, however it is required when using APEX destruction.
    - ``disable_kinematic_static_pairs`` (bool):  [Read-Write] Whether to disable generating KS pairs, enabling this makes switching between dynamic and static slower for actors - but speeds up contact generation by early rejecting these pairs
    - ``enable2d_physics`` (bool):  [Read-Write] Can 2D physics be used (Box2D)?
    - ``enable_enhanced_determinism`` (bool):  [Read-Write] If set to true, the scene will use enhanced determinism at the cost of a bit more resources. See eENABLE_ENHANCED_DETERMINISM to learn about the specifics
    - ``enable_pcm`` (bool):  [Read-Write] Enables persistent contact manifolds. This will generate fewer contact points, but with more accuracy. Reduces stability of stacking, but can help energy conservation.
    - ``enable_shape_sharing`` (bool):  [Read-Write] Enables shape sharing between sync and async scene for static rigid actors
    - ``enable_stabilization`` (bool):  [Read-Write] Enables stabilization of contacts for slow moving bodies. This will help improve the stability of stacking.
    - ``friction_combine_mode`` (FrictionCombineMode):  [Read-Write] Friction combine mode, controls how friction is computed for multiple materials.
    - ``initial_average_frame_rate`` (float):  [Read-Write] Physics delta time initial average.
    - ``max_angular_velocity`` (float):  [Read-Write] Max angular velocity that a simulated object can achieve.
    - ``max_contact_offset`` (float):  [Read-Write] Max Contact offset.
    - ``max_depenetration_velocity`` (float):  [Read-Write] Max velocity which may be used to depenetrate simulated physics objects. 0 means no maximum.
    - ``max_physics_delta_time`` (float):  [Read-Write] Max Physics Delta Time to be clamped.
    - ``max_substep_delta_time`` (float):  [Read-Write] Max delta time (in seconds) for an individual simulation substep.
    - ``max_substeps`` (int32):  [Read-Write] Max number of substeps for physics simulation.
    - ``min_contact_offset`` (float):  [Read-Write] Min Contact offset.
    - ``min_delta_velocity_for_hit_events`` (float):  [Read-Write] Minimum velocity delta required on a collinding object for Chaos to send a hit event
    - ``min_physics_delta_time`` (float):  [Read-Write] Min Physics Delta Time; the simulation will not step if the delta time is below this value
    - ``phys_x_tree_rebuild_rate`` (int32):  [Read-Write] The number of frames it takes to rebuild the PhysX scene query AABB tree. The bigger the number, the smaller fetchResults takes per frame, but the more the tree deteriorates until a new tree is built
    - ``physic_error_correction`` (RigidBodyErrorCorrection):  [Read-Write] Error correction data for replicating simulated physics (rigid bodies)
    - ``physical_surfaces`` (Array[PhysicalSurfaceName]):  [Read-Write] PhysicalMaterial Surface Types
    - ``physics_prediction`` (PhysicsPredictionSettings):  [Read-Write] Settings for Networked Physics Prediction, experimental.
    - ``ragdoll_aggregate_threshold`` (int32):  [Read-Write] Threshold for ragdoll bodies above which they will be added to an aggregate before being added to the scene
    - ``restitution_combine_mode`` (FrictionCombineMode):  [Read-Write] Restitution combine mode, controls how restitution is computed for multiple materials.
    - ``simulate_anim_physics_after_reset`` (bool):  [Read-Write] Whether to simulate anim physics nodes in the tick where they're reset.
    - ``simulate_scratch_memory_size`` (int32):  [Read-Write] Amount of memory to reserve for PhysX simulate(), this is per pxscene and will be rounded up to the next 16K boundary
    - ``simulate_skeletal_mesh_on_dedicated_server`` (bool):  [Read-Write] If true, simulate physics for this component on a dedicated server.
      This should be set if simulating physics and replicating with a dedicated server.
    - ``solver_options`` (ChaosSolverConfiguration):  [Read-Write] Options to apply to Chaos solvers on creation
    - ``substepping`` (bool):  [Read-Write] Whether to substep the physics simulation. This feature is still experimental. Certain functionality might not work correctly
    - ``substepping_async`` (bool):  [Read-Write] Whether to substep the async physics simulation. This feature is still experimental. Certain functionality might not work correctly
    - ``support_uv_from_hit_results`` (bool):  [Read-Write] If true, store extra information to allow FindCollisionUV to derive UV info from a line trace hit result, using the FindCollisionUV utility
    - ``suppress_face_remap_table`` (bool):  [Read-Write] If true, the internal physx face to UE face mapping will not be generated. This is a memory optimization available if you do not rely on face indices returned by scene queries.
    - ``sync_scene_smoothing_factor`` (float):  [Read-Write] Physics delta time smoothing factor for sync scene.
    - ``tick_physics_async`` (bool):  [Read-Write] Whether to tick physics simulation on an async thread. This feature is still experimental. Certain functionality might not work correctly
    - ``triangle_mesh_triangle_min_area_threshold`` (float):  [Read-Write] Triangles from triangle meshes (BSP) with an area less than or equal to this value will be removed from physics collision data. Set to less than 0 to disable.
    - ``warn_missing_locks`` (bool):  [Read-Write] Whether to warn when physics locks are used incorrectly. Turning this off is not recommended and should only be used by very advanced users.
    """
    def get_physics_history_count(self) -> int:
        r"""
        x.get_physics_history_count() -> int32
        Get Physics History Count
        
        Returns:
            int32:
        """
        ...

class PhysicsThruster(RigidBodyBase):
    r"""
    Attach one of these on an object using physics simulation and it will apply a force down the negative-X direction
    ie. point X in the direction you want the thrust in.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsThruster.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``thruster_component`` (PhysicsThrusterComponent):  [Read-Only] Thruster component
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def thruster_component(self) -> PhysicsThrusterComponent:
        r"""
        (PhysicsThrusterComponent):  [Read-Only] Thruster component
        """
        ...

class RB_Thruster(PhysicsThruster):
    r"""
    deprecated: 'RB_Thruster' was renamed to 'PhysicsThruster'.
    """
    ...

class RadialForceComponent(SceneComponent):
    r"""
    Used to emit a radial force or impulse that can affect physics objects and or destructible objects.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RadialForceComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``destructible_damage`` (float):  [Read-Write] If > 0.f, will cause damage to destructible meshes as well
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``falloff`` (RadialImpulseFalloff):  [Read-Write] How the force or impulse should fall off as object are further away from the center
    - ``force_strength`` (float):  [Read-Write] How strong the force should be
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``ignore_owning_actor`` (bool):  [Read-Write] If true, do not apply force/impulse to any physics objects that are part of the Actor that owns this component.
    - ``impulse_strength`` (float):  [Read-Write] How strong the impulse should be
    - ``impulse_vel_change`` (bool):  [Read-Write] If true, the impulse will ignore mass of objects and will always result in a fixed velocity change
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``object_types_to_affect`` (Array[ObjectTypeQuery]):  [Read-Write] The object types that are affected by this radial force
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``radius`` (float):  [Read-Write] The radius to apply the force or impulse in
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def radius(self) -> float:
        r"""
        (float):  [Read-Write] The radius to apply the force or impulse in
        """
        ...
    @radius.setter
    def radius(self, value: float) -> None:
        ...
    @property
    def falloff(self) -> RadialImpulseFalloff:
        r"""
        (RadialImpulseFalloff):  [Read-Write] How the force or impulse should fall off as object are further away from the center
        """
        ...
    @falloff.setter
    def falloff(self, value: RadialImpulseFalloff) -> None:
        ...
    @property
    def impulse_strength(self) -> float:
        r"""
        (float):  [Read-Write] How strong the impulse should be
        """
        ...
    @impulse_strength.setter
    def impulse_strength(self, value: float) -> None:
        ...
    @property
    def impulse_vel_change(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the impulse will ignore mass of objects and will always result in a fixed velocity change
        """
        ...
    @impulse_vel_change.setter
    def impulse_vel_change(self, value: bool) -> None:
        ...
    @property
    def ignore_owning_actor(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, do not apply force/impulse to any physics objects that are part of the Actor that owns this component.
        """
        ...
    @ignore_owning_actor.setter
    def ignore_owning_actor(self, value: bool) -> None:
        ...
    @property
    def force_strength(self) -> float:
        r"""
        (float):  [Read-Write] How strong the force should be
        """
        ...
    @force_strength.setter
    def force_strength(self, value: float) -> None:
        ...
    @property
    def destructible_damage(self) -> float:
        r"""
        (float):  [Read-Write] If > 0.f, will cause damage to destructible meshes as well
        """
        ...
    @destructible_damage.setter
    def destructible_damage(self, value: float) -> None:
        ...
    def remove_object_type_to_affect(self, object_type: ObjectTypeQuery) -> None:
        r"""
        x.remove_object_type_to_affect(object_type) -> None
        Remove an object type that is affected by this radial force
        
        Args:
            object_type (ObjectTypeQuery):
        """
        ...
    def fire_impulse(self) -> None:
        r"""
        x.fire_impulse() -> None
        Fire a single impulse
        """
        ...
    def add_object_type_to_affect(self, object_type: ObjectTypeQuery) -> None:
        r"""
        x.add_object_type_to_affect(object_type) -> None
        Add an object type for this radial force to affect
        
        Args:
            object_type (ObjectTypeQuery):
        """
        ...

class RB_RadialForceComponent(RadialForceComponent):
    r"""
    deprecated: 'RB_RadialForceComponent' was renamed to 'RadialForceComponent'.
    """
    ...

class PhysicsFieldComponent(SceneComponent):
    r"""
    PhysicsFieldComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsFieldComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class PhysicsFieldStatics(BlueprintFunctionLibrary):
    r"""
    Static function with world field evaluation
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PhysicsFieldComponent.h
    
    """
    @classmethod
    def eval_physics_vector_field(cls, world_context_object: Object, world_position: Vector, vector_type: FieldVectorType) -> Vector:
        r"""
        X.eval_physics_vector_field(world_context_object, world_position, vector_type) -> Vector
        Evaluate the world physics vector field from BP
        
        Args:
            world_context_object (Object): 
            world_position (Vector): 
            vector_type (FieldVectorType): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def eval_physics_scalar_field(cls, world_context_object: Object, world_position: Vector, scalar_type: FieldScalarType) -> float:
        r"""
        X.eval_physics_scalar_field(world_context_object, world_position, scalar_type) -> float
        Evaluate the world physics scalar field from BP
        
        Args:
            world_context_object (Object): 
            world_position (Vector): 
            scalar_type (FieldScalarType): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def eval_physics_integer_field(cls, world_context_object: Object, world_position: Vector, integer_type: FieldIntegerType) -> int:
        r"""
        X.eval_physics_integer_field(world_context_object, world_position, integer_type) -> int32
        Evaluate the world physics integer field from BP
        
        Args:
            world_context_object (Object): 
            world_position (Vector): 
            integer_type (FieldIntegerType): 
        
        Returns:
            int32:
        """
        ...

class PlayerStart(NavigationObjectBase):
    r"""
    This class indicates a location where a player can spawn when the game begins.
    see: https://docs.unrealengine.com/latest/INT/Engine/Actors/PlayerStart/
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerStart.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_start_tag`` (Name):  [Read-Write] Used when searching for which playerstart to use.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def player_start_tag(self) -> Name:
        r"""
        (Name):  [Read-Write] Used when searching for which playerstart to use.
        """
        ...
    @player_start_tag.setter
    def player_start_tag(self, value: Name) -> None:
        ...

class PlayerStartPIE(PlayerStart):
    r"""
    Player Start PIE
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerStartPIE.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_start_tag`` (Name):  [Read-Write] Used when searching for which playerstart to use.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class PlayerState(Info):
    r"""
    A PlayerState is created for every player on a server (or in a standalone game).
    PlayerStates are replicated to all clients, and contain network game relevant information about the player, such as playername, score, etc.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerState.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``compressed_ping`` (uint8):  [Read-Write] Replicated compressed ping for this player (holds ping in msec divided by 4)
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_a_bot`` (bool):  [Read-Write]
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``is_spectator`` (bool):  [Read-Write]
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_pawn_set`` (OnPlayerStatePawnSet):  [Read-Write] Broadcast whenever this player's possessed pawn is set
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``pawn_private`` (Pawn):  [Read-Write] The pawn that is controlled by by this player state.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_id`` (int32):  [Read-Write]
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``score`` (float):  [Read-Write]
    - ``should_update_replicated_ping`` (bool):  [Read-Write] Whether or not this player's replicated CompressedPing value is updated automatically.
      Since player states are always relevant by default, in cases where there are many players replicating,
      replicating the ping value can cause additional unnecessary overhead on servers if the value isn't
      needed on clients.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def score(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def player_id(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def compressed_ping(self) -> int:
        r"""
        (uint8):  [Read-Only] Replicated compressed ping for this player (holds ping in msec divided by 4)
        """
        ...
    @property
    def ping(self) -> int:
        r"""
        deprecated: 'ping' was renamed to 'compressed_ping'.
        """
        ...
    @property
    def is_spectator(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def is_a_bot(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def on_pawn_set(self) -> OnPlayerStatePawnSet:
        r"""
        (OnPlayerStatePawnSet):  [Read-Write] Broadcast whenever this player's possessed pawn is set
        """
        ...
    @on_pawn_set.setter
    def on_pawn_set(self, value: OnPlayerStatePawnSet) -> None:
        ...
    @property
    def pawn_private(self) -> Pawn:
        r"""
        (Pawn):  [Read-Only] The pawn that is controlled by by this player state.
        """
        ...
    def receive_override_with(self, old_player_state: PlayerState) -> None:
        r"""
        x.receive_override_with(old_player_state) -> None
        * Can be implemented in Blueprint Child to move more properties from old to new PlayerState when reconnecting
        *
        *
        
        Args:
            old_player_state (PlayerState): Old PlayerState, which we use to fill the new one with
        """
        ...
    def receive_copy_properties(self, new_player_state: PlayerState) -> None:
        r"""
        x.receive_copy_properties(new_player_state) -> None
        * Can be implemented in Blueprint Child to move more properties from old to new PlayerState when traveling to a new level
        *
        *
        
        Args:
            new_player_state (PlayerState): New PlayerState, which we fill with the current properties
        """
        ...
    def is_only_a_spectator(self) -> bool:
        r"""
        x.is_only_a_spectator() -> bool
        Gets the literal value of bOnlySpectator.
        
        Returns:
            bool:
        """
        ...
    def get_player_name(self) -> str:
        r"""
        x.get_player_name() -> str
        returns current player name
        
        Returns:
            str:
        """
        ...
    def get_player_controller(self) -> PlayerController:
        r"""
        x.get_player_controller() -> PlayerController
        Return the player controller that created this player state, or null for remote clients
        
        Returns:
            PlayerController:
        """
        ...
    def get_ping_in_milliseconds(self) -> float:
        r"""
        x.get_ping_in_milliseconds() -> float
        Returns the ping (in milliseconds)
        
        Returns ExactPing if available (local players or when running on the server), and
        the replicated CompressedPing (converted back to milliseconds) otherwise.
        
        Note that replication of CompressedPing is controlled by bShouldUpdateReplicatedPing,
        and if disabled then this will return 0 or a stale value on clients for player states
        that aren't related to local players
        
        Returns:
            float:
        """
        ...
    def get_pawn(self) -> Pawn:
        r"""
        x.get_pawn() -> Pawn
        Return the pawn controlled by this Player State.
        
        Returns:
            Pawn:
        """
        ...
    def bp_get_unique_id(self) -> UniqueNetIdRepl:
        r"""
        x.bp_get_unique_id() -> UniqueNetIdRepl
        Gets the online unique id for a player. If a player is logged in this will be consistent across all clients and servers.
        
        Returns:
            UniqueNetIdRepl:
        """
        ...

class PostProcessVolume(Volume):
    r"""
    for FPostprocessSettings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PostProcessVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``blend_radius`` (float):  [Read-Write] World space radius around the volume that is used for blending (only if not unbound).
    - ``blend_weight`` (float):  [Read-Write] 0:no effect, 1:full effect
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enabled`` (bool):  [Read-Write] Whether this volume is enabled or not.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``priority`` (float):  [Read-Write] Priority of this volume. In the case of overlapping volumes the one with the highest priority
      overrides the lower priority ones. The order is undefined if two or more overlapping volumes have the same priority.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``settings`` (PostProcessSettings):  [Read-Write] Post process settings to use for this volume.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``unbound`` (bool):  [Read-Write] Whether this volume covers the whole world, or just the area inside its bounds.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def settings(self) -> PostProcessSettings:
        r"""
        (PostProcessSettings):  [Read-Write] Post process settings to use for this volume.
        """
        ...
    @settings.setter
    def settings(self, value: PostProcessSettings) -> None:
        ...
    @property
    def priority(self) -> float:
        r"""
        (float):  [Read-Write] Priority of this volume. In the case of overlapping volumes the one with the highest priority
        overrides the lower priority ones. The order is undefined if two or more overlapping volumes have the same priority.
        """
        ...
    @priority.setter
    def priority(self, value: float) -> None:
        ...
    @property
    def blend_radius(self) -> float:
        r"""
        (float):  [Read-Write] World space radius around the volume that is used for blending (only if not unbound).
        """
        ...
    @blend_radius.setter
    def blend_radius(self, value: float) -> None:
        ...
    @property
    def blend_weight(self) -> float:
        r"""
        (float):  [Read-Write] 0:no effect, 1:full effect
        """
        ...
    @blend_weight.setter
    def blend_weight(self, value: float) -> None:
        ...
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this volume is enabled or not.
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def unbound(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this volume covers the whole world, or just the area inside its bounds.
        """
        ...
    @unbound.setter
    def unbound(self, value: bool) -> None:
        ...
    def add_or_update_blendable(self, blendable_object: BlendableInterface, weight: float = 1.000000) -> None:
        r"""
        x.add_or_update_blendable(blendable_object, weight=1.000000) -> None
        Adds an Blendable (implements IBlendableInterface) to the array of Blendables (if it doesn't exist) and update the weight
        
        Args:
            blendable_object (BlendableInterface): 
            weight (float):
        """
        ...

class PrecomputedVisibilityVolume(Volume):
    r"""
    Precomputed Visibility Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrecomputedVisibilityVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class PrimaryAssetLabel(PrimaryDataAsset):
    r"""
    A seed file that is created to mark referenced assets as part of this primary asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PrimaryAssetLabel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_collection`` (CollectionReference):  [Read-Write] Collection to load asset references out of
    - ``explicit_assets`` (Array[Object]):  [Read-Write] List of manually specified assets to label
    - ``explicit_blueprints`` (Array[Class]):  [Read-Write] List of manually specified blueprint assets to label
    - ``include_redirectors`` (bool):  [Read-Write] If true, redirectors found by the AssetLabel's explicit assets or directory will be labeled. If false, redirectors will be skipped.
    - ``is_runtime_label`` (bool):  [Read-Write] Set to true if the label asset itself should be cooked and available at runtime. This does not affect the assets that are labeled, they are set with cook rule
    - ``label_assets_in_my_directory`` (bool):  [Read-Write] True to Label everything in this directory and sub directories
    - ``rules`` (PrimaryAssetRules):  [Read-Write] Management rules for this specific asset, if set it will override the type rules
    """
    ...

class HealthSnapshotBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Health Snapshot Blueprint Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HealthSnapshot.h
    
    """
    @classmethod
    def stop_performance_snapshots(cls) -> None:
        r"""
        X.stop_performance_snapshots() -> None
        Stops capturing FPS charts only if StartHealthSnapshotChart has first been called. Does nothing if FPS charts are not running. HealthSnapshots captured after this is called will not include performance stats.
        """
        ...
    @classmethod
    def start_performance_snapshots(cls) -> None:
        r"""
        X.start_performance_snapshots() -> None
        Begins capturing FPS charts that can be used to include performance data in a HealthSnapshot. If snapshots are already running clears all accumulated performance data
        """
        ...
    @classmethod
    def log_performance_snapshot(cls, snapshot_title: str, reset_stats: bool = True) -> None:
        r"""
        X.log_performance_snapshot(snapshot_title, reset_stats=True) -> None
        Writes a snapshot to the log. Captures memory stats by default. Also captures performance stats if called after StartHealthSnapshotChart and before SopHealthSnapshotChart.
        
        Args:
            snapshot_title (str): The name to be given to the new HealthSnapshot.
            reset_stats (bool):
        """
        ...

class RectLight(Light):
    r"""
    Rect Light
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RectLight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``light_component`` (LightComponent):  [Read-Write]
      todo: document
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``rect_light_component`` (RectLightComponent):  [Read-Only]
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def rect_light_component(self) -> RectLightComponent:
        r"""
        (RectLightComponent):  [Read-Only]
        """
        ...

class GameInstanceSubsystem(Subsystem):
    r"""
    UGameInstanceSubsystem
    Base class for auto instanced and initialized systems that share the lifetime of the game instance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: GameInstanceSubsystem.h
    
    """
    ...

class ReplaySubsystem(GameInstanceSubsystem):
    r"""
    Replay Subsystem
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ReplaySubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``load_default_map_on_stop`` (bool):  [Read-Write] Whether to reload the default map when StopReplay is called.
    """
    def request_checkpoint(self) -> None:
        r"""
        x.request_checkpoint() -> None
        Request a checkpoint write, if currently recording.
        """
        ...
    def is_recording(self) -> bool:
        r"""
        x.is_recording() -> bool
        Is Recording
        
        Returns:
            bool:
        """
        ...
    def is_playing(self) -> bool:
        r"""
        x.is_playing() -> bool
        Is Playing
        
        Returns:
            bool:
        """
        ...
    def get_replay_current_time(self) -> float:
        r"""
        x.get_replay_current_time() -> float
        Get current recording/playing replay time
        
        Returns:
            float: float Current recording/playback time in seconds
        """
        ...
    def get_active_replay_name(self) -> str:
        r"""
        x.get_active_replay_name() -> str
        Get current recording/playing replay name
        
        Returns:
            str: FString Name of relpay (session id, file name, etc)
        """
        ...

class ReverbEffect(Object):
    r"""
    Reverb Effect
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ReverbEffect.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``air_absorption_gain_hf`` (float):  [Read-Write] Air Absorption - 0.0 < 0.994 < 1.0 - lower value means more absorption
    - ``bypass_early_reflections`` (bool):  [Read-Write] Bypasses early reflections
    - ``bypass_late_reflections`` (bool):  [Read-Write] Bypasses late reflections.
    - ``decay_hf_ratio`` (float):  [Read-Write] Decay High Frequency Ratio - 0.1 < 0.83 < 2.0 - how much quicker or slower the high frequencies decay relative to the lower frequencies.
    - ``decay_time`` (float):  [Read-Write] Decay Time - 0.1 < 1.49 < 20.0 Seconds - larger is more reverb
    - ``density`` (float):  [Read-Write] Density - 0.0 < 1.0 < 1.0 - Coloration of the late reverb - lower value is more grainy
    - ``diffusion`` (float):  [Read-Write] Diffusion - 0.0 < 1.0 < 1.0 - Echo density in the reverberation decay - lower is more grainy
    - ``gain`` (float):  [Read-Write] Reverb Gain - 0.0 < 0.32 < 1.0 - overall reverb gain - master volume control
    - ``gain_hf`` (float):  [Read-Write] Reverb Gain High Frequency - 0.0 < 0.89 < 1.0 - attenuates the high frequency reflected sound
    - ``late_delay`` (float):  [Read-Write] Late Reverb Delay - 0.0 < 0.011 < 0.1 Seconds - time difference between late reverb and first reflections
    - ``late_gain`` (float):  [Read-Write] Late Reverb Gain - 0.0 < 1.26 < 10.0 - gain of the late reverb
    - ``reflections_delay`` (float):  [Read-Write] Reflections Delay - 0.0 < 0.007 < 0.3 Seconds - the time between the listener receiving the direct path sound and the first reflection
    - ``reflections_gain`` (float):  [Read-Write] Reflections Gain - 0.0 < 0.05 < 3.16 - controls the amount of initial reflections
    """
    @property
    def bypass_early_reflections(self) -> bool:
        r"""
        (bool):  [Read-Write] Bypasses early reflections
        """
        ...
    @bypass_early_reflections.setter
    def bypass_early_reflections(self, value: bool) -> None:
        ...
    @property
    def bypass_late_reflections(self) -> bool:
        r"""
        (bool):  [Read-Write] Bypasses late reflections.
        """
        ...
    @bypass_late_reflections.setter
    def bypass_late_reflections(self, value: bool) -> None:
        ...

class RuntimeOptionsBase(Object):
    r"""
    URuntimeOptionsBase: Base class designed to be subclassed in your game.
    
    Supports checking at runtime whether features are enabled/disabled, and changing
    configuration parameters via console cheats or startup commands.
    
    Add new config properties to your subclasses which default to the desired normal state
    This can be adjusted via the development-only tools (command line or cvar) or via an
    override in the config hierarchy to adjust it as needed (e.g., via a hotfix).
    
    In non-Shipping builds, each property will be exposed both as a console variable and as a
    command-line argument for easy testing during development.
    
    Debug console syntax (disabled in Shipping configurations):
      prefix.PropertyName Value
    Command line syntax (disabled in Shipping configurations):
      -prefix.PropertyName=Value
    DefaultRuntimeOptions.ini syntax (note that there is no prefix for these):
      [/Script/YourModule.YourRuntimeOptionsSubclass]
      PropertyName=Value
    
    Where the prefix is set by the value of OptionCommandPrefix (defaults to "ro" but can be overridden)
    
    You can also change the name of the ini file that settings are gathered from in your derived
    UCLASS() declaration
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RuntimeOptionsBase.h
    
    """
    ...

class SkinnedAsset(StreamableRenderAsset):
    r"""
    Skinned Asset
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkinnedAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``never_stream`` (bool):  [Read-Write]
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    """
    def find_socket_info(self, socket_name: Name) -> Tuple[SkeletalMeshSocket, Transform, int, int]:
        r"""
        x.find_socket_info(socket_name) -> (SkeletalMeshSocket, out_transform=Transform, out_bone_index=int32, out_index=int32)
        Find a socket object and associated info in this SkeletalMesh by name.
        Entering NAME_None will return NULL. If there are multiple sockets with the same name, will return the first one.
        Also returns the index for the socket allowing for future fast access via GetSocketByIndex()
        Also returns the socket transform and the bone index (if any)
        
        Args:
            socket_name (Name): 
        
        Returns:
            tuple: 
        
            out_transform (Transform): 
        
            out_bone_index (int32): 
        
            out_index (int32):
        """
        ...
    def find_socket(self, socket_name: Name) -> SkeletalMeshSocket:
        r"""
        x.find_socket(socket_name) -> SkeletalMeshSocket
        Find a socket object in this SkeletalMesh by name.
        Entering NAME_None will return NULL. If there are multiple sockets with the same name, will return the first one.
        
        Args:
            socket_name (Name): 
        
        Returns:
            SkeletalMeshSocket:
        """
        ...

class SkeletalMesh(SkinnedAsset):
    r"""
    SkeletalMesh is geometry bound to a hierarchical skeleton of bones which can be animated for the purpose of deforming the mesh.
    Skeletal Meshes are built up of two parts; a set of polygons composed to make up the surface of the mesh, and a hierarchical skeleton which can be used to animate the polygons.
    The 3D models, rigging, and animations are created in an external modeling and animation application (3DSMax, Maya, Softimage, etc).
    see: https://docs.unrealengine.com/latest/INT/Engine/Content/Types/SkeletalMeshes/
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Write]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``cloth_lod_bias_mode`` (ClothLODBiasMode):  [Read-Write]
    - ``default_animating_rig`` (Object):  [Read-Write]
    - ``default_mesh_deformer`` (MeshDeformer):  [Read-Write]
    - ``disable_below_min_lod_stripping`` (PerPlatformBool):  [Read-Write]
    - ``enable_per_poly_collision`` (bool):  [Read-Write]
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_info`` (Array[SkeletalMeshLODInfo]):  [Read-Write]
    - ``lod_settings`` (SkeletalMeshLODSettings):  [Read-Write]
    - ``materials`` (Array[SkeletalMaterial]):  [Read-Write]
    - ``max_num_optional_lo_ds`` (PerPlatformInt):  [Read-Write]
    - ``max_num_streamed_lo_ds`` (PerPlatformInt):  [Read-Write]
    - ``mesh_clothing_assets`` (Array[ClothingAssetBase]):  [Read-Write]
    - ``min_lod`` (PerPlatformInt):  [Read-Write]
    - ``min_quality_level_lod`` (PerQualityLevelInt):  [Read-Write]
    - ``morph_targets`` (Array[MorphTarget]):  [Read-Write]
    - ``negative_bounds_extension`` (Vector):  [Read-Write]
    - ``never_stream`` (bool):  [Read-Write]
    - ``node_mapping_data`` (Array[NodeMappingContainer]):  [Read-Write]
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``overlay_material`` (MaterialInterface):  [Read-Write]
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write]
    - ``override_lod_streaming_settings`` (bool):  [Read-Write]
    - ``physics_asset`` (PhysicsAsset):  [Read-Write]
    - ``positive_bounds_extension`` (Vector):  [Read-Write]
    - ``post_process_anim_blueprint`` (type(Class)):  [Read-Write]
    - ``post_process_anim_bplod_threshold`` (int32):  [Read-Write] * Max LOD level that post-process AnimBPs are evaluated.
      * For example if you have the threshold set to 2, it will evaluate until including LOD 2 (based on 0 index). In case the LOD level gets set to 3, it will stop evaluating the post-process AnimBP.
      * Setting it to -1 will always evaluate it and disable LODing.
    - ``ray_tracing_min_lod`` (int32):  [Read-Write]
    - ``sampling_info`` (SkeletalMeshSamplingInfo):  [Read-Write]
    - ``shadow_physics_asset`` (PhysicsAsset):  [Read-Write]
    - ``skel_mirror_axis`` (AxisType):  [Read-Write]
    - ``skel_mirror_flip_axis`` (AxisType):  [Read-Write]
    - ``skel_mirror_table`` (Array[BoneMirrorInfo]):  [Read-Write]
    - ``skeleton`` (Skeleton):  [Read-Only]
    - ``skin_weight_profiles`` (Array[SkinWeightProfileInfo]):  [Read-Write]
    - ``support_lod_streaming`` (PerPlatformBool):  [Read-Write]
    - ``support_ray_tracing`` (bool):  [Read-Write]
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only]
    """
    @property
    def skeleton(self) -> Skeleton:
        r"""
        (Skeleton):  [Read-Only]
        """
        ...
    @property
    def positive_bounds_extension(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def negative_bounds_extension(self) -> Vector:
        r"""
        (Vector):  [Read-Only]
        """
        ...
    @property
    def materials(self) -> Array[SkeletalMaterial]:
        r"""
        (Array[SkeletalMaterial]):  [Read-Write]
        """
        ...
    @materials.setter
    def materials(self, value: Array[SkeletalMaterial]) -> None:
        ...
    @property
    def lod_settings(self) -> SkeletalMeshLODSettings:
        r"""
        (SkeletalMeshLODSettings):  [Read-Write]
        """
        ...
    @lod_settings.setter
    def lod_settings(self, value: SkeletalMeshLODSettings) -> None:
        ...
    @property
    def default_animating_rig(self) -> Object:
        r"""
        (Object):  [Read-Write]
        """
        ...
    @default_animating_rig.setter
    def default_animating_rig(self, value: Object) -> None:
        ...
    @property
    def physics_asset(self) -> PhysicsAsset:
        r"""
        (PhysicsAsset):  [Read-Only]
        """
        ...
    @property
    def shadow_physics_asset(self) -> PhysicsAsset:
        r"""
        (PhysicsAsset):  [Read-Only]
        """
        ...
    @property
    def node_mapping_data(self) -> Array[NodeMappingContainer]:
        r"""
        (Array[NodeMappingContainer]):  [Read-Only]
        """
        ...
    @property
    def morph_targets(self) -> Array[MorphTarget]:
        r"""
        (Array[MorphTarget]):  [Read-Write]
        """
        ...
    @morph_targets.setter
    def morph_targets(self, value: Array[MorphTarget]) -> None:
        ...
    @property
    def post_process_anim_blueprint(self) -> Class:
        r"""
        (type(Class)):  [Read-Only]
        """
        ...
    @property
    def mesh_clothing_assets(self) -> Array[ClothingAssetBase]:
        r"""
        (Array[ClothingAssetBase]):  [Read-Write]
        """
        ...
    @mesh_clothing_assets.setter
    def mesh_clothing_assets(self, value: Array[ClothingAssetBase]) -> None:
        ...
    @property
    def default_mesh_deformer(self) -> MeshDeformer:
        r"""
        (MeshDeformer):  [Read-Only]
        """
        ...
    @property
    def overlay_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Only]
        """
        ...
    @property
    def overlay_material_max_draw_distance(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    def set_overlay_material_max_draw_distance(self, max_draw_distance: float) -> None:
        r"""
        x.set_overlay_material_max_draw_distance(max_draw_distance) -> None
        Change the default overlay material max draw distance used by this mesh
        
        Args:
            max_draw_distance (float):
        """
        ...
    def set_overlay_material(self, new_overlay_material: MaterialInterface) -> None:
        r"""
        x.set_overlay_material(new_overlay_material) -> None
        Change the default overlay material used by this mesh
        
        Args:
            new_overlay_material (MaterialInterface):
        """
        ...
    def set_min_lod_for_quality_levels(self, quality_level_minimum_lo_ds: Map[PerQualityLevels, int], default: int = -1) -> None:
        r"""
        x.set_min_lod_for_quality_levels(quality_level_minimum_lo_ds, default=-1) -> None
        Allow to override min lod quality levels on a skeletalMesh and it Default value (-1 value for Default dont override its value).
        
        Args:
            quality_level_minimum_lo_ds (Map[PerQualityLevels, int32]): 
            default (int32):
        """
        ...
    def num_sockets(self) -> int:
        r"""
        x.num_sockets() -> int32
        Returns the number of sockets available. Both on this mesh and it's skeleton.
        
        Returns:
            int32:
        """
        ...
    def get_all_morph_target_names(self) -> Array[str]:
        r"""
        x.get_all_morph_target_names() -> Array[str]
        Returns the list of all morph targets of this skeletal mesh
        
        Returns:
            Array[str]: The list of morph targets
        """
        ...
    def is_section_using_cloth(self, section_index: int, check_corresponding_sections: bool = True) -> bool:
        r"""
        x.is_section_using_cloth(section_index, check_corresponding_sections=True) -> bool
        Checks whether the provided section is using APEX cloth. if bCheckCorrespondingSections is true
        disabled sections will defer to correspond sections to see if they use cloth (non-cloth sections
        are disabled and another section added when cloth is enabled, using this flag allows for a check
        on the original section to succeed)
        
        Args:
            section_index (int32): Index to check
            check_corresponding_sections (bool): Whether to check corresponding sections for disabled sections
        
        Returns:
            bool:
        """
        ...
    def get_socket_by_index(self, index: int) -> SkeletalMeshSocket:
        r"""
        x.get_socket_by_index(index) -> SkeletalMeshSocket
        Returns a socket by index. Max index is NumSockets(). The meshes sockets are accessed first, then the skeletons.
        
        Args:
            index (int32): 
        
        Returns:
            SkeletalMeshSocket:
        """
        ...
    def get_overlay_material_max_draw_distance(self) -> float:
        r"""
        x.get_overlay_material_max_draw_distance() -> float
        Get the default overlay material max draw distance used by this mesh
        
        Returns:
            float:
        """
        ...
    def get_overlay_material(self) -> MaterialInterface:
        r"""
        x.get_overlay_material() -> MaterialInterface
        Get the default overlay material used by this mesh
        
        Returns:
            MaterialInterface:
        """
        ...
    def get_node_mapping_container(self, source_asset: Blueprint) -> NodeMappingContainer:
        r"""
        x.get_node_mapping_container(source_asset) -> NodeMappingContainer
        Get Node Mapping Container
        
        Args:
            source_asset (Blueprint): 
        
        Returns:
            NodeMappingContainer:
        """
        ...
    def get_min_lod_for_quality_levels(self) -> Tuple[Map[PerQualityLevels, int], int]:
        r"""
        x.get_min_lod_for_quality_levels() -> (quality_level_minimum_lo_ds=Map[PerQualityLevels, int32], default=int32)
        Get Min LODFor Quality Levels
        
        Returns:
            tuple: 
        
            quality_level_minimum_lo_ds (Map[PerQualityLevels, int32]): 
        
            default (int32):
        """
        ...
    def get_imported_bounds(self) -> BoxSphereBounds:
        r"""
        x.get_imported_bounds() -> BoxSphereBounds
        Get the original imported bounds of the skel mesh
        
        Returns:
            BoxSphereBounds:
        """
        ...
    def get_default_mesh_deformer(self) -> MeshDeformer:
        r"""
        x.get_default_mesh_deformer() -> MeshDeformer
        Get the default mesh deformer used by this mesh. A mesh deformer is used to deform the skeletal mesh at runtime
        
        Returns:
            MeshDeformer:
        """
        ...
    def get_bounds(self) -> BoxSphereBounds:
        r"""
        x.get_bounds() -> BoxSphereBounds
        Get the extended bounds of this mesh (imported bounds plus bounds extension). USkinnedAsset interface.
        
        Returns:
            BoxSphereBounds:
        """
        ...
    def find_socket_and_index(self, socket_name: Name) -> Tuple[SkeletalMeshSocket, int]:
        r"""
        x.find_socket_and_index(socket_name) -> (SkeletalMeshSocket, out_index=int32)
        Find a socket object in this SkeletalMesh by name.
        Entering NAME_None will return NULL. If there are multiple sockets with the same name, will return the first one.
        Also returns the index for the socket allowing for future fast access via GetSocketByIndex()
        
        Args:
            socket_name (Name): 
        
        Returns:
            int32: 
        
            out_index (int32):
        """
        ...
    def add_socket(self, socket: SkeletalMeshSocket, add_to_skeleton: bool = False) -> None:
        r"""
        x.add_socket(socket, add_to_skeleton=False) -> None
        Add a skeletal socket object to this SkeletalMesh, and optionally promotes it to USkeleton socket.
        
        Args:
            socket (SkeletalMeshSocket): 
            add_to_skeleton (bool):
        """
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...
    def strip_lod_geometry(self, lod_index: int, texture_mask: Texture2D, threshold: float) -> bool:
        r"""
        x.strip_lod_geometry(lod_index, texture_mask, threshold) -> bool
        This function will strip all triangle in the specified LOD that don't have any UV area pointing on a black pixel in the TextureMask.
        We use the UVChannel 0 to find the pixels in the texture.
        
        Args:
            lod_index (int32): 
            texture_mask (Texture2D): 
            threshold (float): 
        
        Returns:
            bool:
        """
        ...
    def remove_lo_ds(self, to_remove_lo_ds: Array[int]) -> bool:
        r"""
        x.remove_lo_ds(to_remove_lo_ds) -> bool
        Remove all the specified LODs. This function will remove all the valid LODs in the list.
        Valid LOD is any LOD greater then 0 that exist in the skeletalmesh. We cannot remove the base LOD 0.
        
        Args:
            to_remove_lo_ds (Array[int32]): The LODs we need to remove
        
        Returns:
            bool: true if the successfully remove all the LODs. False otherwise, but evedn if it return false it will have removed all valid LODs.
        """
        ...
    def rename_socket(self, old_name: Name, new_name: Name) -> bool:
        r"""
        x.rename_socket(old_name, new_name) -> bool
        Rename a socket within a skeleton
        
        Args:
            old_name (Name): The old name of the socket
            new_name (Name): The new name of the socket
        
        Returns:
            bool: true if the renaming succeeded.
        """
        ...
    def regenerate_lod(self, new_lod_count: int = 0, regenerate_even_if_imported: bool = False, generate_base_lod: bool = False) -> bool:
        r"""
        x.regenerate_lod(new_lod_count=0, regenerate_even_if_imported=False, generate_base_lod=False) -> bool
        Regenerate LODs of the mesh
        
        Args:
            new_lod_count (int32): Set valid value (>0) if you want to change LOD count. Otherwise, it will use the current LOD and regenerate
            regenerate_even_if_imported (bool): If this is true, it only regenerate even if this LOD was imported before If false, it will regenerate for only previously auto generated ones
            generate_base_lod (bool): If this is true and there is some reduction data, the base LOD will be reduce according to the settings
        
        Returns:
            bool: true if succeed. If mesh reduction is not available this will return false.
        """
        ...

class SkeletalMeshLODSettings(DataAsset):
    r"""
    Skeletal Mesh LODSettings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SkeletalMeshLODSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disable_below_min_lod_stripping`` (PerPlatformBool):  [Read-Write] When true LODs below MinLod will not be stripped during cook.
    - ``lod_groups`` (Array[SkeletalMeshLODGroupSettings]):  [Read-Write]
    - ``max_num_optional_lo_ds`` (PerPlatformInt):  [Read-Write] Default maximum number of optional LODs for meshes in this group (currently, need to be either 0 or > num of LODs below MinLod)
    - ``max_num_streamed_lo_ds`` (PerPlatformInt):  [Read-Write] Default maximum number of streamed LODs for meshes in this group
    - ``min_lod`` (PerPlatformInt):  [Read-Write] Minimum LOD to render. Can be overridden per mesh as well as set here for all mesh instances
    - ``min_quality_level_lod`` (PerQualityLevelInt):  [Read-Write] Minimum Quality Level LOD to render. Can be overridden per mesh as well as set here for all mesh instances
    - ``override_lod_streaming_settings`` (bool):  [Read-Write] Whether meshes in this group override default LOD streaming settings.
    - ``support_lod_streaming`` (PerPlatformBool):  [Read-Write] Whether meshes in this group stream LODs by default
    """
    ...

class USkeletalMeshReductionSettings(SkeletalMeshLODSettings):
    r"""
    deprecated: 'USkeletalMeshReductionSettings' was renamed to 'SkeletalMeshLODSettings'.
    """
    ...

class SlateBrushAsset(Object):
    r"""
    An asset describing how a texture can exist in slate's DPI-aware environment
    and how this texture responds to resizing. e.g. Scale9-stretching? Tiling?
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SlateBrushAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``brush`` (SlateBrush):  [Read-Write] The slate brush resource describing the texture's behavior.
    """
    ...

class SoundClass(Object):
    r"""
    Sound Class
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundClass.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_classes`` (Array[SoundClass]):  [Read-Write]
    - ``parent_class`` (SoundClass):  [Read-Write]
    - ``passive_sound_mix_modifiers`` (Array[PassiveSoundMixModifier]):  [Read-Write] SoundMix Modifiers to activate automatically when a sound of this class is playing.
    - ``properties`` (SoundClassProperties):  [Read-Write] Configurable properties like volume and priority.
    """
    @property
    def properties(self) -> SoundClassProperties:
        r"""
        (SoundClassProperties):  [Read-Only] Configurable properties like volume and priority.
        """
        ...
    @property
    def child_classes(self) -> Array[SoundClass]:
        r"""
        (Array[SoundClass]):  [Read-Only]
        """
        ...
    @property
    def passive_sound_mix_modifiers(self) -> Array[PassiveSoundMixModifier]:
        r"""
        (Array[PassiveSoundMixModifier]):  [Read-Only] SoundMix Modifiers to activate automatically when a sound of this class is playing.
        """
        ...
    @property
    def parent_class(self) -> SoundClass:
        r"""
        (SoundClass):  [Read-Only]
        """
        ...

class SoundConcurrency(Object):
    r"""
    Sound Concurrency
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundConcurrency.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``concurrency`` (SoundConcurrencySettings):  [Read-Write]
    """
    @property
    def concurrency(self) -> SoundConcurrencySettings:
        r"""
        (SoundConcurrencySettings):  [Read-Only]
        """
        ...

class SoundCue(SoundBase):
    r"""
    The behavior of audio playback is defined within Sound Cues.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundCue.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] Attenuation settings to use if Override Attenuation is set to true
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] Attenuation settings package for the sound
    - ``audio_properties_bindings`` (AudioPropertiesBindings):  [Read-Write]
    - ``audio_properties_sheet`` (AudioPropertiesSheetAssetBase):  [Read-Write]
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``bypass_volume_scale_for_priority`` (bool):  [Read-Write] Bypass volume weighting priority upon evaluating whether sound should remain active when max channel count is met (See platform Audio Settings).
    - ``concurrency_overrides`` (SoundConcurrencySettings):  [Read-Write] If Override Concurrency is true, concurrency settings to use.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] Set of concurrency settings to observe (if override is set to false).  Sound must pass all concurrency settings to play.
    - ``debug`` (bool):  [Read-Write] When "au.3dVisualize.Attenuation" has been specified, draw this sound's attenuation shape when the sound is audible. For debugging purposes only.
    - ``duration`` (float):  [Read-Only] Duration of sound in seconds.
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``exclude_from_random_node_branch_culling`` (bool):  [Read-Write] Ignore per-platform random node culling for memory purposes
    - ``first_node`` (SoundNode):  [Read-Write]
    - ``max_distance`` (float):  [Read-Only] The max distance of the asset, as determined by attenuation settings.
    - ``override_attenuation`` (bool):  [Read-Write] Indicates whether attenuation should use the Attenuation Overrides or the Attenuation Settings asset
    - ``override_concurrency`` (bool):  [Read-Write] Whether or not to override the sound concurrency object with local concurrency settings.
    - ``pitch_multiplier`` (float):  [Read-Write] Base pitch multiplier
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``prime_on_load`` (bool):  [Read-Write] Makes this sound cue automatically load any sound waves it can play into the cache when it is loaded.
    - ``priority`` (float):  [Read-Write] Used to determine whether sound can play or remain active if channel limit is met, where higher value is higher priority
      (see platform's Audio Settings 'Max Channels' property). Unless bypassed, value is weighted with the final volume of the
      sound to produce final runtime priority value.
    - ``sound_class_object`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix_object`` (SoundSubmixBase):  [Read-Write] Submix to route sound output to. If unset, falls back to referenced SoundClass submix.
      If SoundClass submix is unset, sends to the 'Master Submix' as set in the 'Audio' category of Project Settings'.
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] Array of submix sends to which a prescribed amount (see 'Send Level') of this sound is sent.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``subtitle_priority`` (float):  [Read-Write] The priority of the subtitle.  Defaults to 10000.  Higher values will play instead of lower values.
    - ``total_samples`` (float):  [Read-Only] Total number of samples (in the thousands). Useful as a metric to analyze the relative size of a given sound asset in content browser.
    - ``virtualization_mode`` (VirtualizationMode):  [Read-Write] Virtualization behavior, determining if a sound may revive and how it continues playing when culled or evicted (limited to looping sounds).
    - ``volume_multiplier`` (float):  [Read-Write] Base volume multiplier
    """
    @property
    def first_node(self) -> SoundNode:
        r"""
        (SoundNode):  [Read-Only]
        """
        ...
    @property
    def volume_multiplier(self) -> float:
        r"""
        (float):  [Read-Only] Base volume multiplier
        """
        ...
    @property
    def pitch_multiplier(self) -> float:
        r"""
        (float):  [Read-Only] Base pitch multiplier
        """
        ...

class SoundMix(Object):
    r"""
    Sound Mix
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundMix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_eq`` (bool):  [Read-Write] Whether to apply the EQ effect
    - ``duration`` (float):  [Read-Write] Duration of mix, negative means it will be applied until another mix is set.
    - ``eq_priority`` (float):  [Read-Write]
    - ``eq_settings`` (AudioEQEffect):  [Read-Write]
    - ``fade_in_time`` (float):  [Read-Write] Time taken in seconds for the mix to fade in.
    - ``fade_out_time`` (float):  [Read-Write] Time taken in seconds for the mix to fade out.
    - ``initial_delay`` (float):  [Read-Write] Initial delay in seconds before the mix is applied.
    - ``sound_class_effects`` (Array[SoundClassAdjuster]):  [Read-Write] Array of changes to be applied to groups.
    """
    @property
    def sound_class_effects(self) -> Array[SoundClassAdjuster]:
        r"""
        (Array[SoundClassAdjuster]):  [Read-Only] Array of changes to be applied to groups.
        """
        ...

class SoundMode(SoundMix):
    r"""
    deprecated: 'SoundMode' was renamed to 'SoundMix'.
    """
    ...

class SoundNodeAssetReferencer(SoundNode):
    r"""
    Sound node that contains a reference to the raw wave file to be played
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeAssetReferencer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    """
    ...

class SoundNodeAttenuation(SoundNode):
    r"""
    Defines how a sound's volume changes based on distance to the listener
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeAttenuation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write]
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write]
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``override_attenuation`` (bool):  [Read-Write]
    """
    ...

class SoundNodeBranch(SoundNode):
    r"""
    Selects a child node based on the value of a boolean parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeBranch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool_parameter_name`` (Name):  [Read-Write] The name of the boolean parameter to use to determine which branch we should take
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    """
    ...

class SoundNodeConcatenator(SoundNode):
    r"""
    Plays child nodes sequentially
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeConcatenator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``input_volume`` (Array[float]):  [Read-Write] Volume multiplier for each input.
    """
    ...

class SoundNodeDelay(SoundNode):
    r"""
    Defines a delay
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``delay_max`` (float):  [Read-Write] The upper bound of delay time in seconds.
    - ``delay_min`` (float):  [Read-Write] The lower bound of delay time in seconds.
    """
    ...

class SoundNodeDialoguePlayer(SoundNode):
    r"""
    Sound node that contains a reference to the dialogue table to pull from and be played
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeDialoguePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``dialogue_wave_parameter`` (DialogueWaveParameter):  [Read-Write]
    - ``looping`` (bool):  [Read-Write] Whether the dialogue line should be played looping
    """
    ...

class SoundNodeDistanceCrossFade(SoundNode):
    r"""
    SoundNodeDistanceCrossFade
    
    This node's purpose is to play different sounds based on the distance to the listener.
    The node mixes between the N different sounds which are valid for the distance.  One should
    think of a SoundNodeDistanceCrossFade as Mixer node which determines the set of nodes to
    "mix in" based on their distance to the sound.
    
    Example:
    You have a gun that plays a fire sound.  At long distances you want a different sound than
    if you were up close.   So you use a SoundNodeDistanceCrossFade which will calculate the distance
    a listener is from the sound and play either:  short distance, long distance, mix of short and long sounds.
    
    A SoundNodeDistanceCrossFade differs from an SoundNodeAttenuation in that any sound is only going
    be played if it is within the MinRadius and MaxRadius.  So if you want the short distance sound to be
    heard by people close to it, the MinRadius should probably be 0
    
    The volume curve for a SoundNodeDistanceCrossFade will look like this:
    
                             Volume (of the input)
       FadeInDistance.Max --> _________________ <-- FadeOutDistance.Min
                             /                 \
                            /                   \
                           /                     \
    FadeInDistance.Min -->/                       \ <-- FadeOutDistance.Max
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeDistanceCrossFade.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``cross_fade_input`` (Array[DistanceDatum]):  [Read-Write] Each input needs to have the correct data filled in so the SoundNodeDistanceCrossFade is able
      to determine which sounds to play
    """
    ...

class SoundNodeDoppler(SoundNode):
    r"""
    Computes doppler pitch shift
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeDoppler.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``doppler_intensity`` (float):  [Read-Write] How much to scale the doppler shift (1.0 is normal).
    - ``smoothing_interp_speed`` (float):  [Read-Write] Speed at which to interp pitch scale
    - ``use_smoothing`` (bool):  [Read-Write] Whether or not to do a smooth interp to our doppler
    """
    ...

class SoundNodeEnveloper(SoundNode):
    r"""
    Allows manipulation of volume and pitch over a set time period
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeEnveloper.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``duration_after_loop`` (float):  [Read-Write] The time in seconds it takes the evelope to fade out after the last loop is completed.
    - ``loop`` (bool):  [Read-Write] If enabled, the envelope will loop using the loop settings.
    - ``loop_count`` (int32):  [Read-Write] The number of times the envelope should loop if looping is enabled and the envelope is not set to loop indefinitely.
    - ``loop_end`` (float):  [Read-Write] The time in seconds where the envelope's loop ends.
    - ``loop_indefinitely`` (bool):  [Read-Write] If enabled, the envelope will continue to loop indefenitely regardless of the Loop Count value.
    - ``loop_start`` (float):  [Read-Write] The time in seconds where the envelope's loop begins.
    - ``pitch_curve`` (RuntimeFloatCurve):  [Read-Write] The distribution defining the pitch envelope.
    - ``pitch_max`` (float):  [Read-Write] The upper bound of pitch (1.0 is no change)
    - ``pitch_min`` (float):  [Read-Write] The lower bound of pitch (1.0 is no change)
    - ``volume_curve`` (RuntimeFloatCurve):  [Read-Write] The distribution defining the volume envelope.
    - ``volume_max`` (float):  [Read-Write] The upper bound of volume (1.0 is no change)
    - ``volume_min`` (float):  [Read-Write] The lower bound of volume (1.0 is no change)
    """
    ...

class SoundNodeGroupControl(SoundNode):
    r"""
    Plays different sounds depending on the number of active sounds
    Any time a new sound is played, the first group that has an available slot will be chosen
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeGroupControl.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``group_sizes`` (Array[int32]):  [Read-Write] How many active sounds are allowed for each group
    """
    ...

class SoundNodeLooping(SoundNode):
    r"""
    Defines how a sound loops; either indefinitely, or for a set number of times.
    Note: The Looping node should only be used for logical or procedural looping such as introducing a delay.
    These sounds will not be played seamlessly. If you want a sound to loop seamlessly and indefinitely,
    use the Looping flag on the Wave Player node for that sound.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeLooping.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``loop_count`` (int32):  [Read-Write] The amount of times to loop
    - ``loop_indefinitely`` (bool):  [Read-Write] If enabled, the node will continue to loop indefinitely regardless of the Loop Count value.
    """
    ...

class SoundNodeMature(SoundNode):
    r"""
    This SoundNode uses UEngine::bAllowMatureLanguage to determine whether child nodes
    that have USoundWave::bMature=true should be played.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeMature.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    """
    ...

class SoundNodeMixer(SoundNode):
    r"""
    Defines how concurrent sounds are mixed together
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeMixer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``input_volume`` (Array[float]):  [Read-Write] A volume for each input.  Automatically sized.
    """
    ...

class SoundNodeModulator(SoundNode):
    r"""
    Defines a random volume and pitch modification when a sound starts
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeModulator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``pitch_max`` (float):  [Read-Write] The upper bound of pitch (1.0 is no change).
    - ``pitch_min`` (float):  [Read-Write] The lower bound of pitch (1.0 is no change).
    - ``volume_max`` (float):  [Read-Write] The upper bound of volume (1.0 is no change).
    - ``volume_min`` (float):  [Read-Write] The lower bound of volume (1.0 is no change).
    """
    ...

class SoundNodeOscillator(SoundNode):
    r"""
    Defines how a sound oscillates
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeOscillator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``amplitude_max`` (float):  [Read-Write] An amplitude of 0.25 would oscillate between 0.75 and 1.25.
    - ``amplitude_min`` (float):  [Read-Write] An amplitude of 0.25 would oscillate between 0.75 and 1.25.
    - ``center_max`` (float):  [Read-Write] A center of 0.5 would oscillate around 0.5.
    - ``center_min`` (float):  [Read-Write] A center of 0.5 would oscillate around 0.5.
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``frequency_max`` (float):  [Read-Write] A frequency of 20 would oscillate at 10Hz.
    - ``frequency_min`` (float):  [Read-Write] A frequency of 20 would oscillate at 10Hz.
    - ``modulate_pitch`` (bool):  [Read-Write] Whether to oscillate pitch.
    - ``modulate_volume`` (bool):  [Read-Write] Whether to oscillate volume.
    - ``offset_max`` (float):  [Read-Write] Offset into the sine wave. Value modded by 2 * PI.
    - ``offset_min`` (float):  [Read-Write] Offset into the sine wave. Value modded by 2 * PI.
    """
    ...

class SoundNodeParamCrossFade(SoundNodeDistanceCrossFade):
    r"""
    Crossfades between different sounds based on a parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeParamCrossFade.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``cross_fade_input`` (Array[DistanceDatum]):  [Read-Write] Each input needs to have the correct data filled in so the SoundNodeDistanceCrossFade is able
      to determine which sounds to play
    - ``param_name`` (Name):  [Read-Write] Parameter controlling cross fades.
    """
    ...

class SoundNodeQualityLevel(SoundNode):
    r"""
    This SoundNode uses GameUserSettings AudioQualityLevel (or the editor override) to choose which branch to play
    and at runtime will only load in to memory sound waves connected to the branch that will be selected
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeQualityLevel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    """
    ...

class SoundNodeRandom(SoundNode):
    r"""
    Selects sounds from a random set
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeRandom.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``preselect_at_level_load`` (int32):  [Read-Write] If greater than 0, then upon each level load such a number of inputs will be randomly selected
      and the rest will be removed. This can be used to cut down the memory usage of large randomizing
      cues.
    - ``randomize_without_replacement`` (bool):  [Read-Write] Determines whether or not this SoundNodeRandom should randomize with or without
      replacement.
      
      WithoutReplacement means that only nodes left will be valid for
      selection.  So with that, you are guarenteed to have only one occurrence of the
      sound played until all of the other sounds in the set have all been played.
      
      WithReplacement means that a node will be chosen and then placed back into the set.
      So one could play the same sound over and over if the probabilities don't go your way :-)
    - ``should_exclude_from_branch_culling`` (bool):  [Read-Write] If set to true, this random node will not be culled on load for platforms with a maximum amount of preloaded random branches
       set in project settings
    - ``weights`` (Array[float]):  [Read-Write]
    """
    ...

class SoundNodeSoundClass(SoundNode):
    r"""
    Remaps the SoundClass of SoundWaves underneath this
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeSoundClass.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``sound_class_override`` (SoundClass):  [Read-Write]
    """
    ...

class SoundNodeSwitch(SoundNode):
    r"""
    Selects a child node based on the value of a integer parameter
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeSwitch.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``int_parameter_name`` (Name):  [Read-Write] The name of the integer parameter to use to determine which branch we should take
    """
    ...

class SoundNodeWaveParam(SoundNode):
    r"""
    Sound node that takes a runtime parameter for the wave to play
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeWaveParam.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``wave_parameter_name`` (Name):  [Read-Write] The name of the wave parameter to use to look up the SoundWave we should play
    """
    ...

class SoundNodeWavePlayer(SoundNodeAssetReferencer):
    r"""
    Sound node that contains a reference to the raw wave file to be played
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundNodeWavePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``child_nodes`` (Array[SoundNode]):  [Read-Write]
    - ``looping`` (bool):  [Read-Write]
    - ``sound_wave_asset_ptr`` (SoundWave):  [Read-Write]
    """
    ...

class SoundSourceBus(SoundWave):
    r"""
    A source bus is a type of USoundBase and can be "played" like any sound.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSourceBus.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] Attenuation settings package for the sound
    - ``audio_bus`` (AudioBus):  [Read-Write] Audio bus to use as audio for this source bus. This source bus will sonify the audio from the audio bus.
    - ``audio_properties_bindings`` (AudioPropertiesBindings):  [Read-Write]
    - ``audio_properties_sheet`` (AudioPropertiesSheetAssetBase):  [Read-Write]
    - ``auto_deactivate_when_silent`` (bool):  [Read-Write] Stop the source bus when the volume goes to zero.
      deprecated: Property 'bAutoDeactivateWhenSilent' is deprecated.
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``bypass_volume_scale_for_priority`` (bool):  [Read-Write] Bypass volume weighting priority upon evaluating whether sound should remain active when max channel count is met (See platform Audio Settings).
    - ``comment`` (str):  [Read-Write] Provides contextual information for the sound to the translator.
    - ``compression_quality`` (int32):  [Read-Write] Platform agnostic compression quality. 1..100 with 1 being best compression and 100 being best quality. ADPCM and PCM sound asset compression types ignore this parameter.
    - ``concurrency_overrides`` (SoundConcurrencySettings):  [Read-Write] If Override Concurrency is true, concurrency settings to use.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] Set of concurrency settings to observe (if override is set to false).  Sound must pass all concurrency settings to play.
    - ``cue_points`` (Array[SoundWaveCuePoint]):  [Read-Only] Cue point data parsed fro the .wav file. Contains "Loop Regions" as cue points as well!
    - ``curves`` (CurveTable):  [Read-Write] Curves associated with this sound wave
    - ``debug`` (bool):  [Read-Write] When "au.3dVisualize.Attenuation" has been specified, draw this sound's attenuation shape when the sound is audible. For debugging purposes only.
    - ``duration`` (float):  [Read-Only] Duration of sound in seconds.
    - ``enable_amplitude_envelope_analysis`` (bool):  [Read-Write] Whether or not to enable cook-time amplitude envelope analysis.
    - ``enable_baked_fft_analysis`` (bool):  [Read-Write] Whether or not to enable cook-time baked FFT analysis.
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_cloud_streaming`` (bool):  [Read-Write] If enabled, this wave may be streamed from the cloud using the Opus format. Loading behavior must NOT be `Force Inline`. Requires a suitable support plugin to be installed.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds. Describes how quickly the envelope analyzer responds to increasing amplitudes.
    - ``envelope_follower_frame_size`` (int32):  [Read-Write] How many audio frames to average a new envelope value. Larger values use less memory for audio envelope data but will result in lower envelope accuracy.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds. Describes how quickly the envelope analyzer responds to decreasing amplitudes.
    - ``fft_analysis_attack_time`` (int32):  [Read-Write] Attack time in milliseconds of the spectral envelope follower.
    - ``fft_analysis_frame_size`` (int32):  [Read-Write] How many audio frames analyze at a time.
    - ``fft_analysis_release_time`` (int32):  [Read-Write] Release time in milliseconds of the spectral envelope follower.
    - ``fft_size`` (SoundWaveFFTSize):  [Read-Write] The FFT window size to use for fft analysis.
    - ``frequencies_to_analyze`` (Array[float]):  [Read-Write] The frequencies (in hz) to analyze when doing baked FFT analysis.
    - ``imported_sample_rate`` (int32):  [Read-Only] Sample rate of the imported sound wave.
    - ``initial_chunk_size`` (int32):  [Read-Write] Please use size of First Chunk in Seconds.
      deprecated: Property 'InitialChunkSize' is deprecated.
    - ``is_ambisonics`` (bool):  [Read-Write] Whether or not this source is ambisonics file format. If set, sound always uses the
      'Master Ambisonics Submix' as set in the 'Audio' category of Project Settings'
      and ignores submix if provided locally or in the referenced SoundClass.
    - ``loading_behavior`` (SoundWaveLoadingBehavior):  [Read-Write] Specifies how and when compressed audio data is loaded for asset if stream caching is enabled.
    - ``looping`` (bool):  [Read-Write] If set, when played directly (not through a sound cue) the wave will be played looping.
    - ``manual_word_wrap`` (bool):  [Read-Write] If set to true will disable automatic generation of line breaks - use if the subtitles have been split manually.
    - ``mature`` (bool):  [Read-Write] If set to true if this sound is considered to contain mature/adult content.
    - ``max_distance`` (float):  [Read-Only] The max distance of the asset, as determined by attenuation settings.
    - ``modulation_settings`` (SoundModulationDefaultRoutingSettings):  [Read-Write] Modulation Settings
    - ``num_channels`` (int32):  [Read-Only] Number of channels of multichannel data; 1 or 2 for regular mono and stereo files
    - ``override_concurrency`` (bool):  [Read-Write] Whether or not to override the sound concurrency object with local concurrency settings.
    - ``override_sound_to_use_for_analysis`` (SoundWave):  [Read-Write] Specify a sound to use for the baked analysis. Will default to this USoundWave if not set.
    - ``pitch`` (float):  [Read-Write] Playback pitch for sound.
    - ``platform_settings`` (Map[Guid, SoundWaveCloudStreamingPlatformSettings]):  [Read-Write] Optionally disables cloud streaming per platform
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``priority`` (float):  [Read-Write] Used to determine whether sound can play or remain active if channel limit is met, where higher value is higher priority
      (see platform's Audio Settings 'Max Channels' property). Unless bypassed, value is weighted with the final volume of the
      sound to produce final runtime priority value.
    - ``sample_rate`` (int32):  [Read-Only] Cooked sample rate of the asset. Can be modified by sample rate override.
    - ``sample_rate_quality`` (SoundwaveSampleRateSettings):  [Read-Write] Determines the max sample rate to use if the platform enables "Resampling For Device" in project settings.
           For example, if the platform enables Resampling For Device and specifies 32000 for High, then setting High here will
           force the sound wave to be _at most_ 32000. Does nothing if Resampling For Device is disabled.
    - ``seekable_streaming`` (bool):  [Read-Write] Deprecated compression type properties
      deprecated: 5.0 - Property is deprecated. bSeekableStreaming now means ADPCM codec in SoundAssetCompressionType.
    - ``single_line`` (bool):  [Read-Write] If set to true the subtitles display as a sequence of single lines as opposed to multiline.
    - ``size_of_first_audio_chunk_in_seconds`` (PerPlatformFloat):  [Read-Write] How much audio to add to First Audio Chunk (in seconds)
    - ``sound_asset_compression_type`` (SoundAssetCompressionType):  [Read-Write] The compression type to use for the sound wave asset.
    - ``sound_class_object`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_group`` (SoundGroup):  [Read-Write]
    - ``sound_submix_object`` (SoundSubmixBase):  [Read-Write] Submix to route sound output to. If unset, falls back to referenced SoundClass submix.
      If SoundClass submix is unset, sends to the 'Master Submix' as set in the 'Audio' category of Project Settings'.
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] Array of submix sends to which a prescribed amount (see 'Send Level') of this sound is sent.
    - ``source_bus_channels`` (SourceBusChannels):  [Read-Write] How many channels to use for the source bus if the audio bus is not specified, otherwise it will use the audio bus object's channel count.
    - ``source_bus_duration`` (float):  [Read-Write] The duration (in seconds) to use for the source bus. A duration of 0.0 indicates to play the source bus indefinitely.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``spoken_text`` (str):  [Read-Write] A localized version of the text that is actually spoken phonetically in the audio.
      deprecated: Use Subtitles instead.
    - ``streaming_priority`` (int32):  [Read-Write]
      deprecated: 5.0 - Property is deprecated. Streaming priority has no effect with stream caching enabled.
    - ``subtitle_priority`` (float):  [Read-Write] The priority of the subtitle.
    - ``subtitles`` (Array[SubtitleCue]):  [Read-Write] Subtitle cues.
    - ``timecode_info`` (SoundWaveTimecodeInfo):  [Read-Only] Information about the time-code from import, if available.
    - ``total_samples`` (float):  [Read-Only] Total number of samples (in the thousands). Useful as a metric to analyze the relative size of a given sound asset in content browser.
    - ``transformations`` (Array[WaveformTransformationBase]):  [Read-Write] Waveform edits to be applied to this SoundWave on cook (editing transformations will trigger a cook)
    - ``treat_file_as_looping_for_analysis`` (bool):  [Read-Write] Whether or not we should treat the sound wave used for analysis (this or the override) as looping while performing analysis.
      A looping sound may include the end of the file for inclusion in analysis for envelope and FFT analysis.
    - ``use_bink_audio`` (bool):  [Read-Write]
      deprecated: 5.0 - Property is deprecated. bUseBinkAudio now means Bink codec in SoundAssetCompressionType.
    - ``virtualization_mode`` (VirtualizationMode):  [Read-Write] Virtualization behavior, determining if a sound may revive and how it continues playing when culled or evicted (limited to looping sounds).
    - ``volume`` (float):  [Read-Write] Playback volume of sound 0 to 1 - Default is 1.0.
    """
    @property
    def auto_deactivate_when_silent(self) -> bool:
        r"""
        (bool):  [Read-Write] Stop the source bus when the volume goes to zero.
        deprecated: Property 'bAutoDeactivateWhenSilent' is deprecated.
        """
        ...
    @auto_deactivate_when_silent.setter
    def auto_deactivate_when_silent(self, value: bool) -> None:
        ...

class SoundSubmixBase(Object):
    r"""
    Sound Submix Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_disable`` (bool):  [Read-Write] Auto-manage enabling and disabling the submix as a CPU optimization. It will be disabled if the submix and all child submixes are silent. It will re-enable if a sound is sent to the submix or a child submix is audible.
    - ``auto_disable_time`` (float):  [Read-Write] The minimum amount of time to wait before automatically disabling a submix if it is silent. Will immediately re-enable if source audio is sent to it.
    - ``child_submixes`` (Array[SoundSubmixBase]):  [Read-Only] Child submixes to this sound mix
    """
    @property
    def auto_disable(self) -> bool:
        r"""
        (bool):  [Read-Only] Auto-manage enabling and disabling the submix as a CPU optimization. It will be disabled if the submix and all child submixes are silent. It will re-enable if a sound is sent to the submix or a child submix is audible.
        """
        ...
    @property
    def auto_disable_time(self) -> float:
        r"""
        (float):  [Read-Write] The minimum amount of time to wait before automatically disabling a submix if it is silent. Will immediately re-enable if source audio is sent to it.
        """
        ...
    @auto_disable_time.setter
    def auto_disable_time(self, value: float) -> None:
        ...
    @property
    def child_submixes(self) -> Array[SoundSubmixBase]:
        r"""
        (Array[SoundSubmixBase]):  [Read-Only] Child submixes to this sound mix
        """
        ...
    def find_dynamic_ancestor(self) -> SoundSubmixBase:
        r"""
        x.find_dynamic_ancestor() -> SoundSubmixBase
        Searching upwards from this Submix to the root looking for the first Submix marked Dynamic
        If this Submix is Dynamic this will be returned.
        
        Returns:
            SoundSubmixBase:
        """
        ...
    def dynamic_disconnect(self, world_context_object: Object) -> bool:
        r"""
        x.dynamic_disconnect(world_context_object) -> bool
        Dynamically Disconnect from a parent.
        
        Args:
            world_context_object (Object): UObject that's used to GetWorld
        
        Returns:
            bool:
        """
        ...
    def dynamic_connect(self, world_context_object: Object, parent: SoundSubmixBase) -> bool:
        r"""
        x.dynamic_connect(world_context_object, parent) -> bool
        Dynamically Connects to a parent submix.
        
        Args:
            world_context_object (Object): UObject that's used to GetWorld
            parent (SoundSubmixBase): Parent Submix to connect to
        
        Returns:
            bool:
        """
        ...

class SoundSubmixWithParentBase(SoundSubmixBase):
    r"""
    This submix class can be derived from for submixes that output to a parent submix.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_disable`` (bool):  [Read-Write] Auto-manage enabling and disabling the submix as a CPU optimization. It will be disabled if the submix and all child submixes are silent. It will re-enable if a sound is sent to the submix or a child submix is audible.
    - ``auto_disable_time`` (float):  [Read-Write] The minimum amount of time to wait before automatically disabling a submix if it is silent. Will immediately re-enable if source audio is sent to it.
    - ``child_submixes`` (Array[SoundSubmixBase]):  [Read-Only] Child submixes to this sound mix
    - ``is_dynamic`` (bool):  [Read-Write] Is Submix Dynamic. (i.e. allows connect/disconnect at runtime.)  *
    - ``parent_submix`` (SoundSubmixBase):  [Read-Only]
    """
    @property
    def parent_submix(self) -> SoundSubmixBase:
        r"""
        (SoundSubmixBase):  [Read-Only]
        """
        ...
    @property
    def is_dynamic(self) -> bool:
        r"""
        (bool):  [Read-Only] Is Submix Dynamic. (i.e. allows connect/disconnect at runtime.)  *
        """
        ...

class SoundSubmix(SoundSubmixWithParentBase):
    r"""
    Sound Submix class meant for applying an effect to the downmixed sum of multiple audio sources.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ambisonics_plugin_settings`` (SoundfieldEncodingSettingsBase):  [Read-Write] Optional settings used by plugins which support ambisonics file playback.
    - ``audio_link_settings`` (AudioLinkSettingsAbstract):  [Read-Write] Optional Audio Link Settings Object
    - ``auto_disable`` (bool):  [Read-Write] Auto-manage enabling and disabling the submix as a CPU optimization. It will be disabled if the submix and all child submixes are silent. It will re-enable if a sound is sent to the submix or a child submix is audible.
    - ``auto_disable_time`` (float):  [Read-Write] The minimum amount of time to wait before automatically disabling a submix if it is silent. Will immediately re-enable if source audio is sent to it.
    - ``child_submixes`` (Array[SoundSubmixBase]):  [Read-Only] Child submixes to this sound mix
    - ``dry_level_modulation`` (SoundModulationDestinationSettings):  [Read-Write] The dry level of the submix in Decibels. Applied before submix effects and analysis are performed.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the envelope value of sounds played with this submix.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the envelope value of sounds played with this submix.
    - ``is_dynamic`` (bool):  [Read-Write] Is Submix Dynamic. (i.e. allows connect/disconnect at runtime.)  *
    - ``mute_when_backgrounded`` (bool):  [Read-Write] Mute this submix when the application is muted or in the background. Used to prevent submix effect tails from continuing when tabbing out of application or if application is muted.
    - ``on_submix_recorded_file_done`` (OnSubmixRecordedFileDone):  [Read-Write] Blueprint delegate for when a recorded file is finished exporting.
    - ``output_volume_modulation`` (SoundModulationDestinationSettings):  [Read-Write] The output volume of the submix in Decibels. Applied after submix effects and analysis are performed.
    - ``parent_submix`` (SoundSubmixBase):  [Read-Only]
    - ``send_to_audio_link`` (bool):  [Read-Write] Whether to send this Submix to AudioLink (when AudioLink is Enabled)
    - ``submix_effect_chain`` (Array[SoundEffectSubmixPreset]):  [Read-Write]
    - ``wet_level_modulation`` (SoundModulationDestinationSettings):  [Read-Write] The wet level of the submixin Decibels. Applied after submix effects and analysis are performed.
    """
    @property
    def mute_when_backgrounded(self) -> bool:
        r"""
        (bool):  [Read-Only] Mute this submix when the application is muted or in the background. Used to prevent submix effect tails from continuing when tabbing out of application or if application is muted.
        """
        ...
    @property
    def submix_effect_chain(self) -> Array[SoundEffectSubmixPreset]:
        r"""
        (Array[SoundEffectSubmixPreset]):  [Read-Only]
        """
        ...
    @property
    def ambisonics_plugin_settings(self) -> SoundfieldEncodingSettingsBase:
        r"""
        (SoundfieldEncodingSettingsBase):  [Read-Write] Optional settings used by plugins which support ambisonics file playback.
        """
        ...
    @ambisonics_plugin_settings.setter
    def ambisonics_plugin_settings(self, value: SoundfieldEncodingSettingsBase) -> None:
        ...
    @property
    def envelope_follower_attack_time(self) -> int:
        r"""
        (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the envelope value of sounds played with this submix.
        """
        ...
    @envelope_follower_attack_time.setter
    def envelope_follower_attack_time(self, value: int) -> None:
        ...
    @property
    def envelope_follower_release_time(self) -> int:
        r"""
        (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the envelope value of sounds played with this submix.
        """
        ...
    @envelope_follower_release_time.setter
    def envelope_follower_release_time(self, value: int) -> None:
        ...
    @property
    def output_volume_modulation(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] The output volume of the submix in Decibels. Applied after submix effects and analysis are performed.
        """
        ...
    @output_volume_modulation.setter
    def output_volume_modulation(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def wet_level_modulation(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] The wet level of the submixin Decibels. Applied after submix effects and analysis are performed.
        """
        ...
    @wet_level_modulation.setter
    def wet_level_modulation(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def dry_level_modulation(self) -> SoundModulationDestinationSettings:
        r"""
        (SoundModulationDestinationSettings):  [Read-Write] The dry level of the submix in Decibels. Applied before submix effects and analysis are performed.
        """
        ...
    @dry_level_modulation.setter
    def dry_level_modulation(self, value: SoundModulationDestinationSettings) -> None:
        ...
    @property
    def send_to_audio_link(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to send this Submix to AudioLink (when AudioLink is Enabled)
        """
        ...
    @send_to_audio_link.setter
    def send_to_audio_link(self, value: bool) -> None:
        ...
    @property
    def audio_link_settings(self) -> AudioLinkSettingsAbstract:
        r"""
        (AudioLinkSettingsAbstract):  [Read-Write] Optional Audio Link Settings Object
        """
        ...
    @audio_link_settings.setter
    def audio_link_settings(self, value: AudioLinkSettingsAbstract) -> None:
        ...
    @property
    def on_submix_recorded_file_done(self) -> OnSubmixRecordedFileDone:
        r"""
        (OnSubmixRecordedFileDone):  [Read-Write] Blueprint delegate for when a recorded file is finished exporting.
        """
        ...
    @on_submix_recorded_file_done.setter
    def on_submix_recorded_file_done(self, value: OnSubmixRecordedFileDone) -> None:
        ...
    def stop_spectral_analysis(self, world_context_object: Object) -> None:
        r"""
        x.stop_spectral_analysis(world_context_object) -> None
        Stop spectrum analysis of the audio output.
        
        Args:
            world_context_object (Object):
        """
        ...
    def stop_recording_output(self, world_context_object: Object, export_type: AudioRecordingExportType, name: str, path: str, existing_sound_wave_to_overwrite: SoundWave = None) -> None:
        r"""
        x.stop_recording_output(world_context_object, export_type, name, path, existing_sound_wave_to_overwrite=None) -> None
        Finish recording the audio from this submix and export it as a wav file or a USoundWave.
        
        Args:
            world_context_object (Object): 
            export_type (AudioRecordingExportType): 
            name (str): 
            path (str): 
            existing_sound_wave_to_overwrite (SoundWave):
        """
        ...
    def stop_envelope_following(self, world_context_object: Object) -> None:
        r"""
        x.stop_envelope_following(world_context_object) -> None
        Start envelope following the submix output. Register with OnSubmixEnvelope to receive envelope follower data in BP.
        
        Args:
            world_context_object (Object):
        """
        ...
    def start_spectral_analysis(self, world_context_object: Object, fft_size: FFTSize = FFTSize.DEFAULT_SIZE, interpolation_method: FFTPeakInterpolationMethod = FFTPeakInterpolationMethod.LINEAR, window_type: FFTWindowType = FFTWindowType.HANN, hop_size: float = 0.000000, spectrum_type: AudioSpectrumType = AudioSpectrumType.MAGNITUDE_SPECTRUM) -> None:
        r"""
        x.start_spectral_analysis(world_context_object, fft_size=FFTSize.DEFAULT_SIZE, interpolation_method=FFTPeakInterpolationMethod.LINEAR, window_type=FFTWindowType.HANN, hop_size=0.000000, spectrum_type=AudioSpectrumType.MAGNITUDE_SPECTRUM) -> None
        Start spectrum analysis of the audio output.
        
        Args:
            world_context_object (Object): 
            fft_size (FFTSize): 
            interpolation_method (FFTPeakInterpolationMethod): 
            window_type (FFTWindowType): 
            hop_size (float): 
            spectrum_type (AudioSpectrumType):
        """
        ...
    def start_recording_output(self, world_context_object: Object, expected_duration: float) -> None:
        r"""
        x.start_recording_output(world_context_object, expected_duration) -> None
        Start recording the audio from this submix.
        
        Args:
            world_context_object (Object): 
            expected_duration (float):
        """
        ...
    def start_envelope_following(self, world_context_object: Object) -> None:
        r"""
        x.start_envelope_following(world_context_object) -> None
        Start envelope following the submix output. Register with OnSubmixEnvelope to receive envelope follower data in BP.
        
        Args:
            world_context_object (Object):
        """
        ...
    def set_submix_wet_level(self, world_context_object: Object, wet_level: float) -> None:
        r"""
        x.set_submix_wet_level(world_context_object, wet_level) -> None
        Sets the output volume of the submix in linear gain. This dynamic level acts as a multiplier on the WetLevel property of this submix.
        
        Args:
            world_context_object (Object): 
            wet_level (float):
        """
        ...
    def set_submix_output_volume(self, world_context_object: Object, output_volume: float) -> None:
        r"""
        x.set_submix_output_volume(world_context_object, output_volume) -> None
        Sets the output volume of the submix in linear gain. This dynamic volume acts as a multiplier on the OutputVolume property of this submix.
        
        Args:
            world_context_object (Object): 
            output_volume (float):
        """
        ...
    def set_submix_dry_level(self, world_context_object: Object, dry_level: float) -> None:
        r"""
        x.set_submix_dry_level(world_context_object, dry_level) -> None
        Sets the output volume of the submix in linear gain. This dynamic level acts as a multiplier on the DryLevel property of this submix.
        
        Args:
            world_context_object (Object): 
            dry_level (float):
        """
        ...
    def remove_spectral_analysis_delegate(self, world_context_object: Object, on_submix_spectral_analysis_bp: OnSubmixSpectralAnalysisBP) -> None:
        r"""
        x.remove_spectral_analysis_delegate(world_context_object, on_submix_spectral_analysis_bp) -> None
        Remove a spectral analysis delegate.
        
        Args:
            world_context_object (Object): 
            on_submix_spectral_analysis_bp (OnSubmixSpectralAnalysisBP): The event delegate to remove.
        """
        ...
    def add_spectral_analysis_delegate(self, world_context_object: Object, band_settings: Array[SoundSubmixSpectralAnalysisBandSettings], on_submix_spectral_analysis_bp: OnSubmixSpectralAnalysisBP, update_rate: float = 10.000000, decibel_noise_floor: float = -40.000000, do_normalize: bool = True, do_auto_range: bool = False, auto_range_attack_time: float = 0.100000, auto_range_release_time: float = 60.000000) -> None:
        r"""
        x.add_spectral_analysis_delegate(world_context_object, band_settings, on_submix_spectral_analysis_bp, update_rate=10.000000, decibel_noise_floor=-40.000000, do_normalize=True, do_auto_range=False, auto_range_attack_time=0.100000, auto_range_release_time=60.000000) -> None
        Adds a spectral analysis delegate to receive notifications when this submix has spectrum analysis enabled.
        
        Args:
            world_context_object (Object): 
            band_settings (Array[SoundSubmixSpectralAnalysisBandSettings]): The frequency bands to analyze and their envelope-following settings.
            on_submix_spectral_analysis_bp (OnSubmixSpectralAnalysisBP): Event to fire when new spectral data is available.
            update_rate (float): How often to retrieve the data from the spectral analyzer and broadcast the event. Max is 30 times per second.
            decibel_noise_floor (float): Decibel Noise Floor to consider as silence when using a Decibel Spectrum Type.
            do_normalize (bool): If true, output band values will be normalized between zero and one.
            do_auto_range (bool): If true, output band values will have their ranges automatically adjusted to the minimum and maximum values in the audio. Output band values will be normalized between zero and one.
            auto_range_attack_time (float): The time (in seconds) it takes for the range to expand to 90% of a larger range.
            auto_range_release_time (float): The time (in seconds) it takes for the range to shrink to 90% of a smaller range.
        """
        ...
    def add_envelope_follower_delegate(self, world_context_object: Object, on_submix_envelope_bp: OnSubmixEnvelopeBP) -> None:
        r"""
        x.add_envelope_follower_delegate(world_context_object, on_submix_envelope_bp) -> None
        Adds an envelope follower delegate to the submix when envelope following is enabled on this submix.
        
        Args:
            world_context_object (Object): 
            on_submix_envelope_bp (OnSubmixEnvelopeBP): Event to fire when new envelope data is available.
        """
        ...

class SoundfieldSubmix(SoundSubmixWithParentBase):
    r"""
    Sound Submix class meant for use with soundfield formats, such as Ambisonics.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_disable`` (bool):  [Read-Write] Auto-manage enabling and disabling the submix as a CPU optimization. It will be disabled if the submix and all child submixes are silent. It will re-enable if a sound is sent to the submix or a child submix is audible.
    - ``auto_disable_time`` (float):  [Read-Write] The minimum amount of time to wait before automatically disabling a submix if it is silent. Will immediately re-enable if source audio is sent to it.
    - ``child_submixes`` (Array[SoundSubmixBase]):  [Read-Only] Child submixes to this sound mix
    - ``encoding_settings`` (SoundfieldEncodingSettingsBase):  [Read-Write] Which encoding settings to use the sound field.
    - ``is_dynamic`` (bool):  [Read-Write] Is Submix Dynamic. (i.e. allows connect/disconnect at runtime.)  *
    - ``parent_submix`` (SoundSubmixBase):  [Read-Only]
    - ``soundfield_effect_chain`` (Array[SoundfieldEffectBase]):  [Read-Write] Soundfield effect chain to use for the sound field.
    - ``soundfield_encoding_format`` (Name):  [Read-Write] Currently used format.
    """
    ...

class EndpointSubmix(SoundSubmixBase):
    r"""
    Sound Submix class meant for sending audio to an external endpoint, such as controller haptics or an additional audio device.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_disable`` (bool):  [Read-Write] Auto-manage enabling and disabling the submix as a CPU optimization. It will be disabled if the submix and all child submixes are silent. It will re-enable if a sound is sent to the submix or a child submix is audible.
    - ``auto_disable_time`` (float):  [Read-Write] The minimum amount of time to wait before automatically disabling a submix if it is silent. Will immediately re-enable if source audio is sent to it.
    - ``child_submixes`` (Array[SoundSubmixBase]):  [Read-Only] Child submixes to this sound mix
    - ``endpoint_settings`` (AudioEndpointSettingsBase):  [Read-Write]
    - ``endpoint_type`` (Name):  [Read-Write] Currently used format.
    """
    ...

class SoundfieldEndpointSubmix(SoundSubmixBase):
    r"""
    Sound Submix class meant for sending soundfield-encoded audio to an external endpoint, such as a hardware binaural renderer that supports ambisonics.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SoundSubmix.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_disable`` (bool):  [Read-Write] Auto-manage enabling and disabling the submix as a CPU optimization. It will be disabled if the submix and all child submixes are silent. It will re-enable if a sound is sent to the submix or a child submix is audible.
    - ``auto_disable_time`` (float):  [Read-Write] The minimum amount of time to wait before automatically disabling a submix if it is silent. Will immediately re-enable if source audio is sent to it.
    - ``child_submixes`` (Array[SoundSubmixBase]):  [Read-Only] Child submixes to this sound mix
    - ``encoding_settings`` (SoundfieldEncodingSettingsBase):  [Read-Write]
    - ``endpoint_settings`` (SoundfieldEndpointSettingsBase):  [Read-Write]
    - ``soundfield_effect_chain`` (Array[SoundfieldEffectBase]):  [Read-Write]
    - ``soundfield_endpoint_type`` (Name):  [Read-Write] Currently used format.
    """
    ...

class SpectatorPawn(DefaultPawn):
    r"""
    Spectator Pawn
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SpectatorPawn.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``add_default_movement_bindings`` (bool):  [Read-Write] If true, adds default input bindings for movement and camera look.
    - ``ai_controller_class`` (type(Class)):  [Read-Write] Default class to use when pawn is controlled by AI.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_possess_ai`` (AutoPossessAI):  [Read-Write] Determines when the Pawn creates and is possessed by an AI Controller (on level start, when spawned, etc).
      Only possible if AIControllerClassRef is set, and ignored if AutoPossessPlayer is enabled.
      see: AutoPossessPlayer
    - ``auto_possess_player`` (AutoReceiveInput):  [Read-Write] Determines which PlayerController, if any, should automatically possess the pawn when the level starts or when the pawn is spawned.
      see: AutoPossessAI
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``base_eye_height`` (float):  [Read-Write] Base eye height above collision center.
    - ``base_look_up_rate`` (float):  [Read-Only] Base lookup rate, in deg/sec. Other scaling may affect final lookup rate.
    - ``base_turn_rate`` (float):  [Read-Only] Base turn rate, in deg/sec. Other scaling may affect final turn rate.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_affect_navigation_generation`` (bool):  [Read-Write] If set to false (default) given pawn instance will never affect navigation generation (but components could).
      Setting it to true will result in using regular AActor's navigation relevancy
      calculation to check if this pawn instance should affect navigation generation.
      note: Use SetCanAffectNavigationGeneration() to change this value at runtime.
      note: Modifying this value at runtime will result in any navigation change only if runtime navigation generation is enabled.
      note: Override UpdateNavigationRelevance() to propagate the flag to the desired components.
      see: SetCanAffectNavigationGeneration(), UpdateNavigationRelevance()
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``collision_component`` (SphereComponent):  [Read-Only] DefaultPawn collision component
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``last_hit_by`` (Controller):  [Read-Write] Controller of the last Actor that caused us damage.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``mesh_component`` (StaticMeshComponent):  [Read-Only] The mesh associated with this Pawn.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``movement_component`` (PawnMovementComponent):  [Read-Only] DefaultPawn movement component
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_input_component_class`` (type(Class)):  [Read-Write] If set, then this InputComponent class will be used instead of the Input Settings' DefaultInputComponentClass
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_state`` (PlayerState):  [Read-Write] If Pawn is possessed by a player, points to its Player State.  Needed for network play as controllers are not replicated to clients.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``receive_controller_changed_delegate`` (PawnControllerChangedSignature):  [Read-Write] Event called after a pawn's controller has changed, on the server and owning client. This will happen at the same time as the delegate on GameInstance
    - ``receive_restarted_delegate`` (PawnRestartedSignature):  [Read-Write] Event called after a pawn has been restarted, usually by a possession change. This is called on the server for all pawns and the owning client for player pawns
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_controller_rotation_pitch`` (bool):  [Read-Write] If true, this Pawn's pitch will be updated to match the Controller's ControlRotation pitch, if controlled by a PlayerController.
    - ``use_controller_rotation_roll`` (bool):  [Read-Write] If true, this Pawn's roll will be updated to match the Controller's ControlRotation roll, if controlled by a PlayerController.
    - ``use_controller_rotation_yaw`` (bool):  [Read-Write] If true, this Pawn's yaw will be updated to match the Controller's ControlRotation yaw, if controlled by a PlayerController.
    """
    ...

class SpectatorPawnMovement(FloatingPawnMovement):
    r"""
    Spectator Pawn Movement
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SpectatorPawnMovement.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``acceleration`` (float):  [Read-Write] Acceleration applied by input (rate of change of velocity)
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_register_physics_volume_updates`` (bool):  [Read-Write] If true, then applies the value of bComponentShouldUpdatePhysicsVolume to the UpdatedComponent. If false, will not change bShouldUpdatePhysicsVolume on the UpdatedComponent at all.
      see: bComponentShouldUpdatePhysicsVolume
    - ``auto_register_updated_component`` (bool):  [Read-Write] If true, registers the owner's Root component as the UpdatedComponent if there is not one currently assigned.
    - ``auto_update_tick_registration`` (bool):  [Read-Write] If true, whenever the updated component is changed, this component will enable or disable its tick dependent on whether it has something to update.
      This will NOT enable tick at startup if bAutoActivate is false, because presumably you have a good reason for not wanting it to start ticking initially.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_should_update_physics_volume`` (bool):  [Read-Write] If true, enables bShouldUpdatePhysicsVolume on the UpdatedComponent during initialization from SetUpdatedComponent(), otherwise disables such updates.
      Only enabled if bAutoRegisterPhysicsVolumeUpdates is true.
      WARNING: UpdatePhysicsVolume is potentially expensive if overlap events are also *disabled* because it requires a separate query against all physics volumes in the world.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_to_plane`` (bool):  [Read-Write] If true, movement will be constrained to a plane.
      see: PlaneConstraintNormal, PlaneConstraintOrigin, PlaneConstraintAxisSetting
    - ``deceleration`` (float):  [Read-Write] Deceleration applied when there is no input (rate of change of velocity)
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``fixed_path_braking_distance`` (float):  [Read-Write] Braking distance override used with acceleration driven path following (bUseAccelerationForPaths)
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``max_speed`` (float):  [Read-Write] Maximum velocity magnitude allowed for the controlled Pawn.
    - ``nav_agent_props`` (NavAgentProperties):  [Read-Write] Properties that define how the component can move.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``plane_constraint_axis_setting`` (PlaneConstraintAxisSetting):  [Read-Write] Setting that controls behavior when movement is restricted to a 2D plane defined by a specific axis/normal,
      so that movement along the locked axis is not be possible.
      see: SetPlaneConstraintAxisSetting
    - ``plane_constraint_normal`` (Vector):  [Read-Write] The normal or axis of the plane that constrains movement, if bConstrainToPlane is enabled.
      If for example you wanted to constrain movement to the X-Z plane (so that Y cannot change), the normal would be set to X=0 Y=1 Z=0.
      This is recalculated whenever PlaneConstraintAxisSetting changes. It is normalized once the component is registered with the game world.
      see: bConstrainToPlane, SetPlaneConstraintNormal(), SetPlaneConstraintFromVectors()
    - ``plane_constraint_origin`` (Vector):  [Read-Write] The origin of the plane that constrains movement, if plane constraint is enabled.
      This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
      see: bConstrainToPlane, SetPlaneConstraintOrigin().
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``snap_to_plane_at_start`` (bool):  [Read-Write] If true and plane constraints are enabled, then the updated component will be snapped to the plane when first attached.
    - ``tick_before_owner`` (bool):  [Read-Write] If true, after registration we will add a tick dependency to tick before our owner (if we can both tick).
      This is important when our tick causes an update in the owner's position, so that when the owner ticks it uses the most recent position without lag.
      Disabling this can improve performance if both objects tick but the order of ticks doesn't matter.
    - ``turning_boost`` (float):  [Read-Write] Setting affecting extra force applied when changing direction, making turns have less drift and become more responsive.
      Velocity magnitude is not allowed to increase, that only happens due to normal acceleration. It may decrease with large direction changes.
      Larger values apply extra force to reach the target direction more quickly, while a zero value disables any extra turn force.
    - ``update_nav_agent_with_owners_collision`` (bool):  [Read-Write] If set to true NavAgentProps' radius and height will be updated with Owner's collision capsule size
    - ``update_only_if_rendered`` (bool):  [Read-Write] If true, skips TickComponent() if UpdatedComponent was not recently rendered.
    - ``updated_component`` (SceneComponent):  [Read-Write] The component we move and update.
      If this is null at startup and bAutoRegisterUpdatedComponent is true, the owning Actor's root component will automatically be set as our UpdatedComponent at startup.
      see: bAutoRegisterUpdatedComponent, SetUpdatedComponent(), UpdatedPrimitive
    - ``updated_primitive`` (PrimitiveComponent):  [Read-Write] UpdatedComponent, cast as a UPrimitiveComponent. May be invalid if UpdatedComponent was null or not a UPrimitiveComponent.
    - ``use_acceleration_for_paths`` (bool):  [Read-Write] If set, pathfollowing will control character movement via acceleration values. If false, it will set velocities directly.
    - ``use_fixed_braking_distance_for_paths`` (bool):  [Read-Write] If set, FixedPathBrakingDistance will be used for path following deceleration
    - ``velocity`` (Vector):  [Read-Write] Current velocity of updated component.
    """
    ...

class SplineMeshActor(Actor):
    r"""
    SplineMeshActor is an actor with a SplineMeshComponent.
    see: USplineMeshComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SplineMeshActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``spline_mesh_component`` (SplineMeshComponent):  [Read-Only]
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def spline_mesh_component(self) -> SplineMeshComponent:
        r"""
        (SplineMeshComponent):  [Read-Only]
        """
        ...

class StaticMesh(StreamableRenderAsset):
    r"""
    A StaticMesh is a piece of geometry that consists of a static set of polygons.
    Static Meshes can be translated, rotated, and scaled, but they cannot have their vertices animated in any way. As such, they are more efficient
    to render than other types of geometry such as USkeletalMesh, and they are often the basic building block of levels created in the engine.
    see: https://docs.unrealengine.com/latest/INT/Engine/Content/Types/StaticMeshes/
    see: AStaticMeshActor, UStaticMeshComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StaticMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_cpu_access`` (bool):  [Read-Write] If true, will keep geometry data CPU-accessible in cooked builds, rather than uploading to GPU memory and releasing it from CPU memory.
      This is required if you wish to access StaticMesh geometry data on the CPU at runtime in cooked builds (e.g. to convert StaticMesh to ProceduralMeshComponent)
    - ``asset_import_data`` (AssetImportData):  [Read-Write] Importing data and options used for this mesh
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``body_setup`` (BodySetup):  [Read-Write]
    - ``complex_collision_mesh`` (StaticMesh):  [Read-Write]
    - ``customized_collision`` (bool):  [Read-Write] If the user has modified collision in any way or has custom collision imported. Used for determining if to auto generate collision on import
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``generate_mesh_distance_field`` (bool):  [Read-Write] Whether to generate a distance field for this mesh, which can be used by DistanceField Indirect Shadows.
      This is ignored if the project's 'Generate Mesh Distance Fields' setting is enabled.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``has_navigation_data`` (bool):  [Read-Write] If true, mesh will have NavCollision property with additional data for navmesh generation and usage.
                Set to false for distant meshes (always outside navigation bounds) to save memory on collision data.
    - ``light_map_coordinate_index`` (int32):  [Read-Write] The light map coordinate index
    - ``light_map_resolution`` (int32):  [Read-Write] The light map resolution
    - ``lod_for_collision`` (int32):  [Read-Write] Specifies which mesh LOD to use for complex (per-poly) collision.
      Sometimes it can be desirable to use a lower poly representation for collision to reduce memory usage, improve performance and behaviour.
      Collision representation does not change based on distance to camera.
    - ``lod_group`` (Name):  [Read-Write] The LOD group to which this mesh belongs.
    - ``nanite_settings`` (MeshNaniteSettings):  [Read-Write] Settings related to building Nanite data.
    - ``nav_collision`` (NavCollisionBase):  [Read-Only]
    - ``negative_bounds_extension`` (Vector):  [Read-Write]
    - ``never_stream`` (bool):  [Read-Write]
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``positive_bounds_extension`` (Vector):  [Read-Write]
    - ``static_materials`` (Array[StaticMaterial]):  [Read-Write]
    - ``support_gpu_uniformly_distributed_sampling`` (bool):  [Read-Write] If true, a GPU buffer containing required data for uniform mesh surface sampling will be created at load time.
      It is created from the cpu data so bSupportUniformlyDistributedSampling is also required to be true.
    - ``support_physical_material_masks`` (bool):  [Read-Write] If true, complex collision data will store UVs and face remap table for use when performing
      PhysicalMaterialMask lookups in cooked builds. Note the increased memory cost for this
      functionality.
    - ``support_ray_tracing`` (bool):  [Read-Write] If true, a ray tracing acceleration structure will be built for this mesh and it may be used in ray tracing effects
    - ``support_uniformly_distributed_sampling`` (bool):  [Read-Write] Mesh supports uniformly distributed sampling in constant time.
      Memory cost is 8 bytes per triangle.
      Example usage is uniform spawning of particles.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``use_legacy_tangent_scaling`` (bool):  [Read-Write]
    """
    @property
    def static_materials(self) -> Array[StaticMaterial]:
        r"""
        (Array[StaticMaterial]):  [Read-Write]
        """
        ...
    @static_materials.setter
    def static_materials(self, value: Array[StaticMaterial]) -> None:
        ...
    @property
    def lod_for_collision(self) -> int:
        r"""
        (int32):  [Read-Write] Specifies which mesh LOD to use for complex (per-poly) collision.
        Sometimes it can be desirable to use a lower poly representation for collision to reduce memory usage, improve performance and behaviour.
        Collision representation does not change based on distance to camera.
        """
        ...
    @lod_for_collision.setter
    def lod_for_collision(self, value: int) -> None:
        ...
    def set_num_source_models(self, num: int) -> None:
        r"""
        x.set_num_source_models(num) -> None
        Set Num Source Models
        
        Args:
            num (int32):
        """
        ...
    def set_min_lod_for_quality_levels(self, quality_level_minimum_lo_ds: Map[PerQualityLevels, int], default: int = -1) -> None:
        r"""
        x.set_min_lod_for_quality_levels(quality_level_minimum_lo_ds, default=-1) -> None
        Allow to override min lod quality levels on a staticMesh and it Default value (-1 value for Default dont override its value).
        
        Args:
            quality_level_minimum_lo_ds (Map[PerQualityLevels, int32]): 
            default (int32):
        """
        ...
    def set_minimum_lod_for_platforms(self, platform_minimum_lo_ds: Map[Name, int]) -> None:
        r"""
        x.set_minimum_lod_for_platforms(platform_minimum_lo_ds) -> None
        Set Minimum LODFor Platforms
        
        Args:
            platform_minimum_lo_ds (Map[Name, int32]):
        """
        ...
    def set_minimum_lod_for_platform(self, platform_name: Name, min_lod: int) -> None:
        r"""
        x.set_minimum_lod_for_platform(platform_name, min_lod) -> None
        Set Minimum LODFor Platform
        
        Args:
            platform_name (Name): 
            min_lod (int32):
        """
        ...
    def set_material(self, material_index: int, new_material: MaterialInterface) -> None:
        r"""
        x.set_material(material_index, new_material) -> None
        Sets a Material given a Material Index
        
        Args:
            material_index (int32): 
            new_material (MaterialInterface):
        """
        ...
    def remove_socket(self, socket: StaticMeshSocket) -> None:
        r"""
        x.remove_socket(socket) -> None
        Remove a socket object in this StaticMesh by providing it's pointer. Use FindSocket() if needed.
        
        Args:
            socket (StaticMeshSocket):
        """
        ...
    def is_lod_screen_size_auto_computed(self) -> bool:
        r"""
        x.is_lod_screen_size_auto_computed() -> bool
        Is LODScreen Size Auto Computed
        
        Returns:
            bool:
        """
        ...
    def get_static_mesh_description(self, lod_index: int) -> StaticMeshDescription:
        r"""
        x.get_static_mesh_description(lod_index) -> StaticMeshDescription
        Return a new StaticMeshDescription referencing the MeshDescription of the given LOD
        
        Args:
            lod_index (int32): 
        
        Returns:
            StaticMeshDescription:
        """
        ...
    def get_sockets_by_tag(self, socket_tag: str) -> Array[StaticMeshSocket]:
        r"""
        x.get_sockets_by_tag(socket_tag) -> Array[StaticMeshSocket]
        Returns a list of sockets with the provided tag.
        
        Args:
            socket_tag (str): 
        
        Returns:
            Array[StaticMeshSocket]:
        """
        ...
    def get_num_triangles(self, lod_index: int) -> int:
        r"""
        x.get_num_triangles(lod_index) -> int32
        Returns the number of triangles in the render data for the specified LOD.
        
        Args:
            lod_index (int32): 
        
        Returns:
            int32:
        """
        ...
    def get_num_sections(self, lod: int) -> int:
        r"""
        x.get_num_sections(lod) -> int32
        Returns number of Sections that this StaticMesh has, in the supplied LOD (LOD 0 is the highest)
        
        Args:
            lod (int32): 
        
        Returns:
            int32:
        """
        ...
    def get_num_lods(self) -> int:
        r"""
        x.get_num_lods() -> int32
        Returns the number of LODs used by the mesh.
        
        Returns:
            int32:
        """
        ...
    def get_min_lod_for_quality_levels(self) -> Tuple[Map[PerQualityLevels, int], int]:
        r"""
        x.get_min_lod_for_quality_levels() -> (quality_level_minimum_lo_ds=Map[PerQualityLevels, int32], default=int32)
        Get Min LODFor Quality Levels
        
        Returns:
            tuple: 
        
            quality_level_minimum_lo_ds (Map[PerQualityLevels, int32]): 
        
            default (int32):
        """
        ...
    def get_minimum_lod_for_quality_levels(self) -> Map[Name, int]:
        r"""
        x.get_minimum_lod_for_quality_levels() -> Map[Name, int32]
        Get Minimum LODFor Quality Levels
        
        Returns:
            Map[Name, int32]: 
        
            quality_level_minimum_lo_ds (Map[Name, int32]):
        """
        ...
    def get_minimum_lod_for_quality_level(self, quality_level: Name) -> int:
        r"""
        x.get_minimum_lod_for_quality_level(quality_level) -> int32
        Get Minimum LODFor Quality Level
        
        Args:
            quality_level (Name): 
        
        Returns:
            int32:
        """
        ...
    def get_minimum_lod_for_platforms(self) -> Map[Name, int]:
        r"""
        x.get_minimum_lod_for_platforms() -> Map[Name, int32]
        Get Minimum LODFor Platforms
        
        Returns:
            Map[Name, int32]: 
        
            platform_minimum_lo_ds (Map[Name, int32]):
        """
        ...
    def get_minimum_lod_for_platform(self, platform_name: Name) -> int:
        r"""
        x.get_minimum_lod_for_platform(platform_name) -> int32
        Get Minimum LODFor Platform
        
        Args:
            platform_name (Name): 
        
        Returns:
            int32:
        """
        ...
    def get_material_index(self, material_slot_name: Name) -> int:
        r"""
        x.get_material_index(material_slot_name) -> int32
        Gets a Material index given a slot name
        
        Args:
            material_slot_name (Name): 
        
        Returns:
            int32: Requested material
        """
        ...
    def get_material(self, material_index: int) -> MaterialInterface:
        r"""
        x.get_material(material_index) -> MaterialInterface
        Gets a Material given a Material Index and an LOD number
        
        Args:
            material_index (int32): 
        
        Returns:
            MaterialInterface: Requested material
        """
        ...
    def get_bounds(self) -> BoxSphereBounds:
        r"""
        x.get_bounds() -> BoxSphereBounds
        Returns the number of bounds of the mesh.
        
        Returns:
            BoxSphereBounds: The bounding box represented as box origin with extents and also a sphere that encapsulates that box
        """
        ...
    def get_bounding_box(self) -> Box:
        r"""
        x.get_bounding_box() -> Box
        Returns the bounding box, in local space including bounds extension(s), of the StaticMesh asset
        
        Returns:
            Box:
        """
        ...
    def find_socket(self, socket_name: Name) -> StaticMeshSocket:
        r"""
        x.find_socket(socket_name) -> StaticMeshSocket
        Find a socket object in this StaticMesh by name.
        Entering NAME_None will return NULL. If there are multiple sockets with the same name, will return the first one.
        
        Args:
            socket_name (Name): 
        
        Returns:
            StaticMeshSocket:
        """
        ...
    @classmethod
    def create_static_mesh_description(cls, outer: Object = None) -> StaticMeshDescription:
        r"""
        X.create_static_mesh_description(outer=None) -> StaticMeshDescription
        Create an empty StaticMeshDescription object, to describe a static mesh at runtime
        
        Args:
            outer (Object): 
        
        Returns:
            StaticMeshDescription:
        """
        ...
    def build_from_static_mesh_descriptions(self, static_mesh_descriptions: Array[StaticMeshDescription], build_simple_collision: bool = False, fast_build: bool = True) -> None:
        r"""
        x.build_from_static_mesh_descriptions(static_mesh_descriptions, build_simple_collision=False, fast_build=True) -> None
        Builds static mesh LODs from the array of StaticMeshDescriptions passed in
        
        Args:
            static_mesh_descriptions (Array[StaticMeshDescription]): 
            build_simple_collision (bool): 
            fast_build (bool):
        """
        ...
    def add_socket(self, socket: StaticMeshSocket) -> None:
        r"""
        x.add_socket(socket) -> None
        Add a socket object in this StaticMesh.
        
        Args:
            socket (StaticMeshSocket):
        """
        ...
    def add_material(self, material: MaterialInterface) -> Name:
        r"""
        x.add_material(material) -> Name
        Adds a new material and return its slot name
        
        Args:
            material (MaterialInterface): 
        
        Returns:
            Name:
        """
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class StereoLayerFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    StereoLayer Extensions Function Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: StereoLayerFunctionLibrary.h
    
    """
    @classmethod
    def show_splash_screen(cls) -> None:
        r"""
        X.show_splash_screen() -> None
        Show the splash screen and override the VR display
        deprecated: Please use Show Loading Screen instead.
        """
        ...
    @classmethod
    def set_splash_screen(cls, texture: Texture, scale: Vector2D = [1.000000, 1.000000], offset: Vector = [0.000000, 0.000000, 0.000000], show_loading_movie: bool = False, show_on_set: bool = False) -> None:
        r"""
        X.set_splash_screen(texture, scale=[1.000000, 1.000000], offset=[0.000000, 0.000000, 0.000000], show_loading_movie=False, show_on_set=False) -> None
        Set splash screen attributes
        deprecated: Please use Add Loading Screen Splash instead.
        
        Args:
            texture (Texture): (in) A texture to be used for the splash. B8R8G8A8 format.
            scale (Vector2D): (in) Scale multiplier of the splash screen.
            offset (Vector): (in) Position in UE Units to offset the Splash Screen by
            show_loading_movie (bool): 
            show_on_set (bool):
        """
        ...
    @classmethod
    def hide_splash_screen(cls) -> None:
        r"""
        X.hide_splash_screen() -> None
        Hide the splash screen and return to normal display.
        deprecated: Please use Hide Loading Screen instead.
        """
        ...
    @classmethod
    def enable_auto_loading_splash_screen(cls, auto_show_enabled: bool) -> None:
        r"""
        X.enable_auto_loading_splash_screen(auto_show_enabled) -> None
        Enable Auto Loading Splash Screen
        deprecated: We don't recommend using Auto Show Loading Screen any longer, and it will be removed in a future update.
        
        Args:
            auto_show_enabled (bool):
        """
        ...

class ActorTextureStreamingBuildDataComponent(ActorComponent):
    r"""
    Actor Texture Streaming Build Data Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ActorTextureStreamingBuildDataComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class ServerStreamingLevelsVisibility(Actor):
    r"""
    Actor used to replicate server's visible level streaming
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ServerStreamingLevelsVisibility.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class TargetPoint(Actor):
    r"""
    Target Point
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TargetPoint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``arrow_component`` (ArrowComponent):  [Read-Only]
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_component`` (BillboardComponent):  [Read-Only]
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def sprite_component(self) -> BillboardComponent:
        r"""
        (BillboardComponent):  [Read-Only]
        """
        ...
    @property
    def arrow_component(self) -> ArrowComponent:
        r"""
        (ArrowComponent):  [Read-Only]
        """
        ...

class Texture2DDynamic(Texture):
    r"""
    note : UTexture2DDynamic derives directly from UTexture not from UTexture2D
    UTexture2DDynamic is a base for textures that don't have a TextureSource
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Texture2DDynamic.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    ...

class TextureCube(Texture):
    r"""
    Texture Cube
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureCube.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    ...

class TextureCubeArray(Texture):
    r"""
    Texture Cube Array
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureCubeArray.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``source_textures`` (Array[TextureCube]):  [Read-Write] Add Textures
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    ...

class TextureLightProfile(Texture2D):
    r"""
    Texture Light Profile
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureLightProfile.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``brightness`` (float):  [Read-Write] Light brightness in Candelas, imported from IES profile, <= 0 if the profile is used for masking only. Use with InverseSquareFalloff.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``texture_multiplier`` (float):  [Read-Only] Multiplier to map texture value to result to integrate over the sphere to 1.0f
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    ...

class TextureRenderTarget2DArray(TextureRenderTarget):
    r"""
    TextureRenderTarget2DArray
    
    2D Array render target texture resource. This can be used as a target
    for rendering as well as rendered as a regular 2DArray texture resource.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureRenderTarget2DArray.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``hdr`` (bool):  [Read-Write] Whether to support storing HDR values, which requires more memory.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``size_x`` (int32):  [Read-Write] The width of the texture.
    - ``size_y`` (int32):  [Read-Write] The height of the texture.
    - ``slices`` (int32):  [Read-Write] The slices of the texture.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``target_gamma`` (float):  [Read-Write] Will override FTextureRenderTarget2DResource::GetDisplayGamma if > 0.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    @property
    def size_x(self) -> int:
        r"""
        (int32):  [Read-Write] The width of the texture.
        """
        ...
    @size_x.setter
    def size_x(self, value: int) -> None:
        ...
    @property
    def size_y(self) -> int:
        r"""
        (int32):  [Read-Write] The height of the texture.
        """
        ...
    @size_y.setter
    def size_y(self, value: int) -> None:
        ...
    @property
    def slices(self) -> int:
        r"""
        (int32):  [Read-Write] The slices of the texture.
        """
        ...
    @slices.setter
    def slices(self, value: int) -> None:
        ...
    @property
    def hdr(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether to support storing HDR values, which requires more memory.
        """
        ...

class TextureRenderTargetCube(TextureRenderTarget):
    r"""
    TextureRenderTargetCube
    
    Cube render target texture resource. This can be used as a target
    for rendering as well as rendered as a regular cube texture resource.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureRenderTargetCube.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``hdr`` (bool):  [Read-Write] If OverrideFormat is not set, bHDR chooses the format of the RT.
            With bHDR on it is RGBA16F , off is BGRA8
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``size_x`` (int32):  [Read-Write] The width of the texture.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``target_gamma`` (float):  [Read-Write] Will override FTextureRenderTarget2DResource::GetDisplayGamma if > 0.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    @property
    def size_x(self) -> int:
        r"""
        (int32):  [Read-Write] The width of the texture.
        """
        ...
    @size_x.setter
    def size_x(self, value: int) -> None:
        ...
    @property
    def hdr(self) -> bool:
        r"""
        (bool):  [Read-Only] If OverrideFormat is not set, bHDR chooses the format of the RT.
              With bHDR on it is RGBA16F , off is BGRA8
        """
        ...

class TextureRenderTargetVolume(TextureRenderTarget):
    r"""
    TextureRenderTargetVolume
    
    Volume render target texture resource. This can be used as a target
    for rendering as well as rendered as a regular Volume texture resource.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TextureRenderTargetVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``hdr`` (bool):  [Read-Write] If OverrideFormat is not set, bHDR chooses the format of the RT.
            With bHDR on it is RGBA16F , off is BGRA8
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``size_x`` (int32):  [Read-Write] The width of the texture.
    - ``size_y`` (int32):  [Read-Write] The height of the texture.
    - ``size_z`` (int32):  [Read-Write] The depth of the texture.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``target_gamma`` (float):  [Read-Write] Will override FTextureRenderTarget2DResource::GetDisplayGamma if > 0.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    @property
    def size_x(self) -> int:
        r"""
        (int32):  [Read-Write] The width of the texture.
        """
        ...
    @size_x.setter
    def size_x(self, value: int) -> None:
        ...
    @property
    def size_y(self) -> int:
        r"""
        (int32):  [Read-Write] The height of the texture.
        """
        ...
    @size_y.setter
    def size_y(self, value: int) -> None:
        ...
    @property
    def size_z(self) -> int:
        r"""
        (int32):  [Read-Write] The depth of the texture.
        """
        ...
    @size_z.setter
    def size_z(self, value: int) -> None:
        ...
    @property
    def hdr(self) -> bool:
        r"""
        (bool):  [Read-Only] If OverrideFormat is not set, bHDR chooses the format of the RT.
              With bHDR on it is RGBA16F , off is BGRA8
        """
        ...

class TimelineTemplate(Object):
    r"""
    Timeline Template
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TimelineTemplate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_play`` (bool):  [Read-Write] If we want the timeline to auto-play
    - ``ignore_time_dilation`` (bool):  [Read-Write] If we want the timeline to ignore global time dilation
    - ``length_mode`` (TimelineLengthMode):  [Read-Write] How we want the timeline to determine its own length (e.g. specified length, last keyframe)
    - ``loop`` (bool):  [Read-Write] If we want the timeline to loop
    - ``meta_data_array`` (Array[BPVariableMetaDataEntry]):  [Read-Write] Metadata information for this timeline
    - ``replicated`` (bool):  [Read-Write] If we want the timeline to loop
    - ``timeline_length`` (float):  [Read-Write] Length of this timeline
    """
    @property
    def replicated(self) -> bool:
        r"""
        (bool):  [Read-Write] If we want the timeline to loop
        """
        ...
    @replicated.setter
    def replicated(self, value: bool) -> None:
        ...

class TriggerVolume(Volume):
    r"""
    Trigger Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: TriggerVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class DynamicTriggerVolume(TriggerVolume):
    r"""
    deprecated: 'DynamicTriggerVolume' was renamed to 'TriggerVolume'.
    """
    ...

class Canvas(Object):
    r"""
    A drawing canvas.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Canvas.h
    
    """
    def clipped_text_size(self, render_font: Font, render_text: str, scale: Vector2D = [1.000000, 1.000000]) -> Vector2D:
        r"""
        x.clipped_text_size(render_font, render_text, scale=[1.000000, 1.000000]) -> Vector2D
        Returns the clipped text size in screen space coordinates.
        
        Args:
            render_font (Font): Font to use when determining the size of the text. If this is null, then a default engine font is used.
            render_text (str): Text to determine the size of.
            scale (Vector2D): Scale of the font to use when determining the size of the text.
        
        Returns:
            Vector2D: Returns the screen space size of the text.
        """
        ...
    def wrapped_text_size(self, render_font: Font, render_text: str) -> Vector2D:
        r"""
        x.wrapped_text_size(render_font, render_text) -> Vector2D
        Returns the wrapped text size in screen space coordinates.
        
        Args:
            render_font (Font): Font to use when determining the size of the text. If this is null, then a default engine font is used.
            render_text (str): Text to determine the size of.
        
        Returns:
            Vector2D: Returns the screen space size of the text.
        """
        ...
    def project(self, world_location: Vector) -> Vector:
        r"""
        x.project(world_location) -> Vector
        Performs a projection of a world space coordinates using the projection matrix set up for the Canvas.
        
        Args:
            world_location (Vector): World space location to project onto the Canvas rendering plane.
        
        Returns:
            Vector: Returns a vector where X, Y defines a screen space position representing the world space location.
        """
        ...
    def draw_triangles(self, render_texture: Texture, triangles: Array[CanvasUVTri]) -> None:
        r"""
        x.draw_triangles(render_texture, triangles) -> None
        Draws a set of triangles on the Canvas.
        
        Args:
            render_texture (Texture): Texture to use when rendering the triangles. If no texture is set, then the default white texture is used.
            triangles (Array[CanvasUVTri]): Triangles to render.
        """
        ...
    def draw_texture(self, render_texture: Texture, screen_position: Vector2D, screen_size: Vector2D, coordinate_position: Vector2D, coordinate_size: Vector2D = [1.000000, 1.000000], render_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], blend_mode: BlendMode = BlendMode.BLEND_TRANSLUCENT, rotation: float = 0.000000, pivot_point: Vector2D = [0.500000, 0.500000]) -> None:
        r"""
        x.draw_texture(render_texture, screen_position, screen_size, coordinate_position, coordinate_size=[1.000000, 1.000000], render_color=[1.000000, 1.000000, 1.000000, 1.000000], blend_mode=BlendMode.BLEND_TRANSLUCENT, rotation=0.000000, pivot_point=[0.500000, 0.500000]) -> None
        Draws a texture on the Canvas.
        
        Args:
            render_texture (Texture): Texture to use when rendering. If no texture is set then this will use the default white texture.
            screen_position (Vector2D): Screen space position to render the texture.
            screen_size (Vector2D): Screen space size to render the texture.
            coordinate_position (Vector2D): Normalized UV starting coordinate to use when rendering the texture.
            coordinate_size (Vector2D): Normalized UV size coordinate to use when rendering the texture.
            render_color (LinearColor): Color to use when rendering the texture.
            blend_mode (BlendMode): Blending mode to use when rendering the texture.
            rotation (float): Rotation, in degrees, to render the texture.
            pivot_point (Vector2D): Normalized pivot point to use when rotating the texture.
        """
        ...
    def draw_text(self, render_font: Font, render_text: str, screen_position: Vector2D, scale: Vector2D = [1.000000, 1.000000], render_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], kerning: float = 0.000000, shadow_color: LinearColor = [0.000000, 0.000000, 0.000000, 1.000000], shadow_offset: Vector2D = [1.000000, 1.000000], centre_x: bool = False, centre_y: bool = False, outlined: bool = False, outline_color: LinearColor = [0.000000, 0.000000, 0.000000, 1.000000]) -> None:
        r"""
        x.draw_text(render_font, render_text, screen_position, scale=[1.000000, 1.000000], render_color=[1.000000, 1.000000, 1.000000, 1.000000], kerning=0.000000, shadow_color=[0.000000, 0.000000, 0.000000, 1.000000], shadow_offset=[1.000000, 1.000000], centre_x=False, centre_y=False, outlined=False, outline_color=[0.000000, 0.000000, 0.000000, 1.000000]) -> None
        Draws text on the Canvas.
        
        Args:
            render_font (Font): Font to use when rendering the text. If this is null, then a default engine font is used.
            render_text (str): Text to render on the Canvas.
            screen_position (Vector2D): Screen space position to render the text.
            scale (Vector2D): 
            render_color (LinearColor): Color to render the text.
            kerning (float): Horizontal spacing adjustment to modify the spacing between each letter.
            shadow_color (LinearColor): Color to render the shadow of the text.
            shadow_offset (Vector2D): Pixel offset relative to the screen space position to render the shadow of the text.
            centre_x (bool): If true, then interpret the screen space position X coordinate as the center of the rendered text.
            centre_y (bool): If true, then interpret the screen space position Y coordinate as the center of the rendered text.
            outlined (bool): If true, then the text should be rendered with an outline.
            outline_color (LinearColor): Color to render the outline for the text.
        """
        ...
    def draw_polygon(self, render_texture: Texture, screen_position: Vector2D, radius: Vector2D = [1.000000, 1.000000], number_of_sides: int = 3, render_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000]) -> None:
        r"""
        x.draw_polygon(render_texture, screen_position, radius=[1.000000, 1.000000], number_of_sides=3, render_color=[1.000000, 1.000000, 1.000000, 1.000000]) -> None
        Draws a polygon on the Canvas.
        
        Args:
            render_texture (Texture): Texture to use when rendering the triangles. If no texture is set, then the default white texture is used.
            screen_position (Vector2D): Screen space position to render the text.
            radius (Vector2D): How large in pixels this polygon should be.
            number_of_sides (int32): How many sides this polygon should have. This should be above or equal to three.
            render_color (LinearColor): Color to tint the polygon.
        """
        ...
    def draw_material_triangles(self, render_material: MaterialInterface, triangles: Array[CanvasUVTri]) -> None:
        r"""
        x.draw_material_triangles(render_material, triangles) -> None
        Draws a set of triangles on the Canvas.
        
        Args:
            render_material (MaterialInterface): Material to use when rendering. Remember that only the emissive channel is able to be rendered as no lighting is performed when rendering to the Canvas.
            triangles (Array[CanvasUVTri]): Triangles to render.
        """
        ...
    def draw_material(self, render_material: MaterialInterface, screen_position: Vector2D, screen_size: Vector2D, coordinate_position: Vector2D, coordinate_size: Vector2D = [1.000000, 1.000000], rotation: float = 0.000000, pivot_point: Vector2D = [0.500000, 0.500000]) -> None:
        r"""
        x.draw_material(render_material, screen_position, screen_size, coordinate_position, coordinate_size=[1.000000, 1.000000], rotation=0.000000, pivot_point=[0.500000, 0.500000]) -> None
        Draws a material on the Canvas.
        
        Args:
            render_material (MaterialInterface): Material to use when rendering. Remember that only the emissive channel is able to be rendered as no lighting is performed when rendering to the Canvas.
            screen_position (Vector2D): Screen space position to render the texture.
            screen_size (Vector2D): Screen space size to render the texture.
            coordinate_position (Vector2D): Normalized UV starting coordinate to use when rendering the texture.
            coordinate_size (Vector2D): Normalized UV size coordinate to use when rendering the texture.
            rotation (float): Rotation, in degrees, to render the texture.
            pivot_point (Vector2D): Normalized pivot point to use when rotating the texture.
        """
        ...
    def draw_line(self, screen_position_a: Vector2D = [0.000000, 0.000000], screen_position_b: Vector2D = [0.000000, 0.000000], thickness: float = 1.000000, render_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000]) -> None:
        r"""
        x.draw_line(screen_position_a=[0.000000, 0.000000], screen_position_b=[0.000000, 0.000000], thickness=1.000000, render_color=[1.000000, 1.000000, 1.000000, 1.000000]) -> None
        Draws a line on the Canvas.
        
        Args:
            screen_position_a (Vector2D): Starting position of the line in screen space.
            screen_position_b (Vector2D): Ending position of the line in screen space.
            thickness (float): How many pixels thick this line should be.
            render_color (LinearColor): Color to render the line.
        """
        ...
    def draw_box(self, screen_position: Vector2D, screen_size: Vector2D, thickness: float = 1.000000, render_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000]) -> None:
        r"""
        x.draw_box(screen_position, screen_size, thickness=1.000000, render_color=[1.000000, 1.000000, 1.000000, 1.000000]) -> None
        Draws an unfilled box on the Canvas.
        
        Args:
            screen_position (Vector2D): Screen space position to render the text.
            screen_size (Vector2D): Screen space size to render the texture.
            thickness (float): How many pixels thick the box lines should be.
            render_color (LinearColor):
        """
        ...
    def draw_border(self, border_texture: Texture, background_texture: Texture, left_border_texture: Texture, right_border_texture: Texture, top_border_texture: Texture, bottom_border_texture: Texture, screen_position: Vector2D, screen_size: Vector2D, coordinate_position: Vector2D, coordinate_size: Vector2D = [1.000000, 1.000000], render_color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], border_scale: Vector2D = [0.100000, 0.100000], background_scale: Vector2D = [0.100000, 0.100000], rotation: float = 0.000000, pivot_point: Vector2D = [0.500000, 0.500000], corner_size: Vector2D = [0.000000, 0.000000]) -> None:
        r"""
        x.draw_border(border_texture, background_texture, left_border_texture, right_border_texture, top_border_texture, bottom_border_texture, screen_position, screen_size, coordinate_position, coordinate_size=[1.000000, 1.000000], render_color=[1.000000, 1.000000, 1.000000, 1.000000], border_scale=[0.100000, 0.100000], background_scale=[0.100000, 0.100000], rotation=0.000000, pivot_point=[0.500000, 0.500000], corner_size=[0.000000, 0.000000]) -> None
        Draws a 3x3 grid border with tiled frame and tiled interior on the Canvas.
        
        Args:
            border_texture (Texture): Texture to use for border.
            background_texture (Texture): Texture to use for border background.
            left_border_texture (Texture): Texture to use for the tiling left border.
            right_border_texture (Texture): Texture to use for the tiling right border.
            top_border_texture (Texture): Texture to use for the tiling top border.
            bottom_border_texture (Texture): Texture to use for the tiling bottom border.
            screen_position (Vector2D): Screen space position to render the texture.
            screen_size (Vector2D): Screen space size to render the texture.
            coordinate_position (Vector2D): Normalized UV starting coordinate to use when rendering the border texture.
            coordinate_size (Vector2D): Normalized UV size coordinate to use when rendering the border texture.
            render_color (LinearColor): Color to tint the border.
            border_scale (Vector2D): Scale of the border.
            background_scale (Vector2D): Scale of the background.
            rotation (float): Rotation, in degrees, to render the texture.
            pivot_point (Vector2D): Normalized pivot point to use when rotating the texture.
            corner_size (Vector2D): Frame corner size in percent of frame texture (should be < 0.5f).
        """
        ...
    def deproject(self, screen_position: Vector2D) -> Tuple[Vector, Vector]:
        r"""
        x.deproject(screen_position) -> (world_origin=Vector, world_direction=Vector)
        Performs a deprojection of a screen space coordinate using the projection matrix set up for the Canvas.
        
        Args:
            screen_position (Vector2D): Screen space position to deproject to the World.
        
        Returns:
            tuple: 
        
            world_origin (Vector): Vector which is the world position of the screen space position.
        
            world_direction (Vector): Vector which can be used in a trace to determine what is "behind" the screen space position. Useful for object picking.
        """
        ...

class InputSettings(Object):
    r"""
    Project wide settings for input handling
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Input/index.html
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: InputSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``action_mappings`` (Array[InputActionKeyMapping]):  [Read-Write] List of Action Mappings
    - ``alt_enter_toggles_fullscreen`` (bool):  [Read-Write]
    - ``always_show_touch_interface`` (bool):  [Read-Write] Should the touch input interface be shown always, or only when the platform has a touch screen?
    - ``axis_config`` (Array[InputAxisConfigEntry]):  [Read-Write] List of Axis Properties
    - ``axis_mappings`` (Array[InputAxisKeyMapping]):  [Read-Write] List of Axis Mappings
    - ``capture_mouse_on_launch`` (bool):  [Read-Write] Controls if the viewport will capture the mouse on Launch of the application
    - ``console_keys`` (Array[Key]):  [Read-Write] The keys which open the console.
    - ``default_input_component_class`` (Class):  [Read-Write] Default class type for pawn input components.
    - ``default_player_input_class`` (Class):  [Read-Write] Default class type for player input object. May be overridden by player controller.
    - ``default_touch_interface`` (SoftObjectPath):  [Read-Write] The default on-screen touch input interface for the game (can be null to disable the onscreen interface)
    - ``default_viewport_mouse_capture_mode`` (MouseCaptureMode):  [Read-Write] The default mouse capture mode for the game viewport
    - ``default_viewport_mouse_lock_mode`` (MouseLockMode):  [Read-Write] The default mouse lock state behavior when the viewport acquires capture
    - ``double_click_time`` (float):  [Read-Write] If a key is pressed twice in this amount of time it is considered a "double click"
    - ``enable_dynamic_component_input_binding`` (bool):  [Read-Write] Should components that are dynamically added via the 'AddComponent' function at runtime have input delegates bound to them?
      see: AActor::FinishAddComponent
    - ``enable_fov_scaling`` (bool):  [Read-Write] Scale the mouse based on the player camera manager's field of view
    - ``enable_gesture_recognizer`` (bool):  [Read-Write] Whether or not to use the gesture recognition system to convert touches in to gestures that can be bound and queried
    - ``enable_input_device_subsystem`` (bool):  [Read-Write] If true, then the input device subsystem will be allowed to Initalize when the engine boots.
      NOTE: For this setting to take effect, and editor restart is required.
      see: UInputDeviceSubsystem
    - ``enable_legacy_input_scales`` (bool):  [Read-Write] Enable the use of legacy input scales on the player controller (InputYawScale, InputPitchScale, and InputRollScale)
    - ``enable_motion_controls`` (bool):  [Read-Write] If set to false, then the player controller's InputMotion function will never be called.
      This will effectively disable any motion input (tilt, rotation, acceleration, etc) on
      the GameViewportClient.
      see: GameViewportClient::InputMotion
    - ``enable_mouse_smoothing`` (bool):  [Read-Write] Mouse smoothing control
    - ``excluded_autocorrect_cultures`` (Array[str]):  [Read-Write] Disables autocorrect for these cultures, even if autocorrect is turned on. These should be ISO-compliant language and country codes, such as "en" or "en-US".
    - ``excluded_autocorrect_device_models`` (Array[str]):  [Read-Write] Disables autocorrect for these device models, even if autocorrect is turned in. Model IDs listed here will match against the start of the device's
      model (e.g., "SM-" will match all device model IDs that start with "SM-"). This is currently only supported on Android devices.
    - ``excluded_autocorrect_os`` (Array[str]):  [Read-Write] Disables autocorrect for these operating systems, even if autocorrect is enabled. Use the format "[platform] [osversion]"
      (e.g., "iOS 11.2" or "Android 6"). More specific versions will disable autocorrect for fewer devices ("iOS 11" will disable
      autocorrect for all devices running iOS 11, but "iOS 11.2.2" will not disable autocorrect for devices running 11.2.1).
    - ``f11_toggles_fullscreen`` (bool):  [Read-Write]
    - ``filter_input_by_platform_user`` (bool):  [Read-Write] If true, then the PlayerController::InputKey function will only process an input event if it
      came from an input device that is owned by the PlayerController's Platform User.
    - ``fov_scale`` (float):  [Read-Write] The scaling value to multiply the field of view by
    - ``platform_settings`` (PerPlatformSettings):  [Read-Write] Platform specific settings for Input.
      see: UInputPlatformSettings
    - ``should_flush_pressed_keys_on_viewport_focus_lost`` (bool):  [Read-Write] If true, then the Player Controller will have it's Pressed Keys flushed when the input mode is changed
      to Game and UI mode or the game viewport loses focus. The default behavior is true.
      see: UGameViewportClient::LostFocus
      see: APlayerController::ShouldFlushKeysWhenViewportFocusChanges
    - ``show_console_on_four_finger_tap`` (bool):  [Read-Write] Whether or not to show the console on 4 finger tap, on mobile platforms
    - ``speech_mappings`` (Array[InputActionSpeechMapping]):  [Read-Write] List of Speech Mappings
    - ``use_autocorrect`` (bool):  [Read-Write] If enabled, virtual keyboards will have autocorrect enabled. Currently only supported on mobile devices.
    - ``use_mouse_for_touch`` (bool):  [Read-Write] Allow mouse to be used for touch
    """
    def save_key_mappings(self) -> None:
        r"""
        x.save_key_mappings() -> None
        Flush the current mapping values to the config file
        """
        ...
    def remove_axis_mapping(self, key_mapping: InputAxisKeyMapping, force_rebuild_keymaps: bool = True) -> None:
        r"""
        x.remove_axis_mapping(key_mapping, force_rebuild_keymaps=True) -> None
        Programmatically remove an axis mapping to the project defaults
        
        Args:
            key_mapping (InputAxisKeyMapping): 
            force_rebuild_keymaps (bool):
        """
        ...
    def remove_action_mapping(self, key_mapping: InputActionKeyMapping, force_rebuild_keymaps: bool = True) -> None:
        r"""
        x.remove_action_mapping(key_mapping, force_rebuild_keymaps=True) -> None
        Programmatically remove an action mapping to the project defaults
        
        Args:
            key_mapping (InputActionKeyMapping): 
            force_rebuild_keymaps (bool):
        """
        ...
    @classmethod
    def get_input_settings(cls) -> InputSettings:
        r"""
        X.get_input_settings() -> InputSettings
        Returns the game local input settings (action mappings, axis mappings, etc...)
        
        Returns:
            InputSettings:
        """
        ...
    def get_axis_names(self) -> Array[Name]:
        r"""
        x.get_axis_names() -> Array[Name]
        Populate a list of all defined axis names
        
        Returns:
            Array[Name]: 
        
            axis_names (Array[Name]):
        """
        ...
    def get_axis_mapping_by_name(self, axis_name: Name) -> Array[InputAxisKeyMapping]:
        r"""
        x.get_axis_mapping_by_name(axis_name) -> Array[InputAxisKeyMapping]
        Retrieve all axis mappings by a certain name.
        
        Args:
            axis_name (Name): 
        
        Returns:
            Array[InputAxisKeyMapping]: 
        
            out_mappings (Array[InputAxisKeyMapping]):
        """
        ...
    def get_action_names(self) -> Array[Name]:
        r"""
        x.get_action_names() -> Array[Name]
        Populate a list of all defined action names
        
        Returns:
            Array[Name]: 
        
            action_names (Array[Name]):
        """
        ...
    def get_action_mapping_by_name(self, action_name: Name) -> Array[InputActionKeyMapping]:
        r"""
        x.get_action_mapping_by_name(action_name) -> Array[InputActionKeyMapping]
        Get Action Mapping by Name
        
        Args:
            action_name (Name): 
        
        Returns:
            Array[InputActionKeyMapping]: 
        
            out_mappings (Array[InputActionKeyMapping]):
        """
        ...
    def force_rebuild_keymaps(self) -> None:
        r"""
        x.force_rebuild_keymaps() -> None
        When changes are made to the default mappings, push those changes out to PlayerInput key maps
        """
        ...
    def add_axis_mapping(self, key_mapping: InputAxisKeyMapping, force_rebuild_keymaps: bool = True) -> None:
        r"""
        x.add_axis_mapping(key_mapping, force_rebuild_keymaps=True) -> None
        Programmatically add an axis mapping to the project defaults
        
        Args:
            key_mapping (InputAxisKeyMapping): 
            force_rebuild_keymaps (bool):
        """
        ...
    def add_action_mapping(self, key_mapping: InputActionKeyMapping, force_rebuild_keymaps: bool = True) -> None:
        r"""
        x.add_action_mapping(key_mapping, force_rebuild_keymaps=True) -> None
        Programmatically add an action mapping to the project defaults
        
        Args:
            key_mapping (InputActionKeyMapping): 
            force_rebuild_keymaps (bool):
        """
        ...

class PlayerInput(Object):
    r"""
    Object within PlayerController that processes player input.
    Only exists on the client in network games.
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Input/index.html
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: PlayerInput.h
    
    """
    def get_outer_a_player_controller(self) -> PlayerController:
        r"""
        x.get_outer_a_player_controller() -> PlayerController
        Return's this object casted to a player controller. This can be null if there is no player controller.
        
        Returns:
            PlayerController:
        """
        ...

class VectorFieldVolume(Actor):
    r"""
    Vector Field Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VectorFieldVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``vector_field_component`` (VectorFieldComponent):  [Read-Only]
    """
    @property
    def vector_field_component(self) -> VectorFieldComponent:
        r"""
        (VectorFieldComponent):  [Read-Only]
        """
        ...

class VisualLoggerFilterVolume(Volume):
    r"""
    A volume to be placed in the level while browsing visual logger output.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VisualLoggerFilterVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class VisualLoggerLibrary(BlueprintFunctionLibrary):
    r"""
    Visual Logger Kismet Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VisualLoggerKismetLibrary.h
    
    """
    @classmethod
    def redirect_vislog(cls, source_owner: Object, destination_owner: Object) -> None:
        r"""
        X.redirect_vislog(source_owner, destination_owner) -> None
        Makes SourceOwner log to DestinationOwner's vislog
        
        Args:
            source_owner (Object): 
            destination_owner (Object):
        """
        ...
    @classmethod
    def log_text(cls, world_context_object: Object, text: str, log_category: Name = "VisLogBP", add_to_message_log: bool = False) -> None:
        r"""
        X.log_text(world_context_object, text, log_category="VisLogBP", add_to_message_log=False) -> None
        Logs simple text string with Visual Logger - recording for Visual Logs has to be enabled to record this data
        
        Args:
            world_context_object (Object): 
            text (str): 
            log_category (Name): 
            add_to_message_log (bool):
        """
        ...
    @classmethod
    def log_sphere(cls, world_context_object: Object, center: Vector, radius: float, text: str, object_color: LinearColor = [0.000000, 0.000000, 1.000000, 1.000000], log_category: Name = "VisLogBP", add_to_message_log: bool = False, wireframe: bool = False) -> None:
        r"""
        X.log_sphere(world_context_object, center, radius, text, object_color=[0.000000, 0.000000, 1.000000, 1.000000], log_category="VisLogBP", add_to_message_log=False, wireframe=False) -> None
        Logs sphere shape - recording for Visual Logs has to be enabled to record this data
        
        Args:
            world_context_object (Object): 
            center (Vector): 
            radius (float): 
            text (str): 
            object_color (LinearColor): 
            log_category (Name): 
            add_to_message_log (bool): 
            wireframe (bool):
        """
        ...
    @classmethod
    def log_segment(cls, world_context_object: Object, segment_start: Vector, segment_end: Vector, text: str, object_color: LinearColor = [0.000000, 0.000000, 1.000000, 1.000000], thickness: float = 0.000000, category_name: Name = "VisLogBP", add_to_message_log: bool = False) -> None:
        r"""
        X.log_segment(world_context_object, segment_start, segment_end, text, object_color=[0.000000, 0.000000, 1.000000, 1.000000], thickness=0.000000, category_name="VisLogBP", add_to_message_log=False) -> None
        Logs segment - recording for Visual Logs has to be enabled to record this data
        
        Args:
            world_context_object (Object): 
            segment_start (Vector): 
            segment_end (Vector): 
            text (str): 
            object_color (LinearColor): 
            thickness (float): 
            category_name (Name): 
            add_to_message_log (bool):
        """
        ...
    @classmethod
    def log_oriented_box(cls, world_context_object: Object, box_shape: Box, transform: Transform, text: str, object_color: LinearColor = [0.000000, 0.000000, 1.000000, 1.000000], log_category: Name = "VisLogBP", add_to_message_log: bool = False, wireframe: bool = False) -> None:
        r"""
        X.log_oriented_box(world_context_object, box_shape, transform, text, object_color=[0.000000, 0.000000, 1.000000, 1.000000], log_category="VisLogBP", add_to_message_log=False, wireframe=False) -> None
        Logs oriented box shape - recording for Visual Logs has to be enabled to record this data
        
        Args:
            world_context_object (Object): 
            box_shape (Box): 
            transform (Transform): 
            text (str): 
            object_color (LinearColor): 
            log_category (Name): 
            add_to_message_log (bool): 
            wireframe (bool):
        """
        ...
    @classmethod
    def log_location(cls, world_context_object: Object, location: Vector, text: str, object_color: LinearColor = [0.000000, 0.000000, 1.000000, 1.000000], radius: float = 10.000000, log_category: Name = "VisLogBP", add_to_message_log: bool = False) -> None:
        r"""
        X.log_location(world_context_object, location, text, object_color=[0.000000, 0.000000, 1.000000, 1.000000], radius=10.000000, log_category="VisLogBP", add_to_message_log=False) -> None
        Logs location as sphere with given radius - recording for Visual Logs has to be enabled to record this data
        
        Args:
            world_context_object (Object): 
            location (Vector): 
            text (str): 
            object_color (LinearColor): 
            radius (float): 
            log_category (Name): 
            add_to_message_log (bool):
        """
        ...
    @classmethod
    def log_cylinder(cls, world_context_object: Object, start: Vector, end: Vector, radius: float, text: str, object_color: LinearColor = [0.000000, 0.000000, 1.000000, 1.000000], log_category: Name = "VisLogBP", add_to_message_log: bool = False, wireframe: bool = False) -> None:
        r"""
        X.log_cylinder(world_context_object, start, end, radius, text, object_color=[0.000000, 0.000000, 1.000000, 1.000000], log_category="VisLogBP", add_to_message_log=False, wireframe=False) -> None
        Logs cylinder shape - recording for Visual Logs has to be enabled to record this data
        
        Args:
            world_context_object (Object): 
            start (Vector): 
            end (Vector): 
            radius (float): 
            text (str): 
            object_color (LinearColor): 
            log_category (Name): 
            add_to_message_log (bool): 
            wireframe (bool):
        """
        ...
    @classmethod
    def log_cone(cls, world_context_object: Object, origin: Vector, direction: Vector, length: float, angle: float, text: str, object_color: LinearColor = [0.000000, 0.000000, 1.000000, 1.000000], log_category: Name = "VisLogBP", add_to_message_log: bool = False, wireframe: bool = False) -> None:
        r"""
        X.log_cone(world_context_object, origin, direction, length, angle, text, object_color=[0.000000, 0.000000, 1.000000, 1.000000], log_category="VisLogBP", add_to_message_log=False, wireframe=False) -> None
        Logs cone shape - recording for Visual Logs has to be enabled to record this data
        
        Args:
            world_context_object (Object): 
            origin (Vector): 
            direction (Vector): 
            length (float): 
            angle (float): 
            text (str): 
            object_color (LinearColor): 
            log_category (Name): 
            add_to_message_log (bool): 
            wireframe (bool):
        """
        ...
    @classmethod
    def log_circle(cls, world_context_object: Object, center: Vector, up_axis: Vector, radius: float, text: str, object_color: LinearColor = [0.000000, 0.000000, 1.000000, 1.000000], thickness: float = 0.000000, category_name: Name = "VisLogBP", add_to_message_log: bool = False) -> None:
        r"""
        X.log_circle(world_context_object, center, up_axis, radius, text, object_color=[0.000000, 0.000000, 1.000000, 1.000000], thickness=0.000000, category_name="VisLogBP", add_to_message_log=False) -> None
        Logs circle - recording for Visual Logs has to be enabled to record this data
        
        Args:
            world_context_object (Object): 
            center (Vector): 
            up_axis (Vector): 
            radius (float): 
            text (str): 
            object_color (LinearColor): 
            thickness (float): 
            category_name (Name): 
            add_to_message_log (bool):
        """
        ...
    @classmethod
    def log_capsule(cls, world_context_object: Object, base: Vector, half_height: float, radius: float, rotation: Quat, text: str, object_color: LinearColor = [0.000000, 0.000000, 1.000000, 1.000000], log_category: Name = "VisLogBP", add_to_message_log: bool = False, wireframe: bool = False) -> None:
        r"""
        X.log_capsule(world_context_object, base, half_height, radius, rotation, text, object_color=[0.000000, 0.000000, 1.000000, 1.000000], log_category="VisLogBP", add_to_message_log=False, wireframe=False) -> None
        Logs capsule shape - recording for Visual Logs has to be enabled to record this data
        
        Args:
            world_context_object (Object): 
            base (Vector): 
            half_height (float): 
            radius (float): 
            rotation (Quat): 
            text (str): 
            object_color (LinearColor): 
            log_category (Name): 
            add_to_message_log (bool): 
            wireframe (bool):
        """
        ...
    @classmethod
    def log_box(cls, world_context_object: Object, box_shape: Box, text: str, object_color: LinearColor = [0.000000, 0.000000, 1.000000, 1.000000], log_category: Name = "VisLogBP", add_to_message_log: bool = False, wireframe: bool = False) -> None:
        r"""
        X.log_box(world_context_object, box_shape, text, object_color=[0.000000, 0.000000, 1.000000, 1.000000], log_category="VisLogBP", add_to_message_log=False, wireframe=False) -> None
        Logs box shape - recording for Visual Logs has to be enabled to record this data
        
        Args:
            world_context_object (Object): 
            box_shape (Box): 
            text (str): 
            object_color (LinearColor): 
            log_category (Name): 
            add_to_message_log (bool): 
            wireframe (bool):
        """
        ...
    @classmethod
    def log_arrow(cls, world_context_object: Object, segment_start: Vector, segment_end: Vector, text: str, object_color: LinearColor = [0.000000, 0.000000, 1.000000, 1.000000], category_name: Name = "VisLogBP", add_to_message_log: bool = False) -> None:
        r"""
        X.log_arrow(world_context_object, segment_start, segment_end, text, object_color=[0.000000, 0.000000, 1.000000, 1.000000], category_name="VisLogBP", add_to_message_log=False) -> None
        Logs arrow - recording for Visual Logs has to be enabled to record this data
        
        Args:
            world_context_object (Object): 
            segment_start (Vector): 
            segment_end (Vector): 
            text (str): 
            object_color (LinearColor): 
            category_name (Name): 
            add_to_message_log (bool):
        """
        ...
    @classmethod
    def enable_recording(cls, enabled: bool) -> None:
        r"""
        X.enable_recording(enabled) -> None
        Enable Recording
        
        Args:
            enabled (bool):
        """
        ...

class VOIPTalker(ActorComponent):
    r"""
    VOIPTalker
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VoiceConfig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``settings`` (VoiceSettings):  [Read-Write] Configurable settings for this player's voice. When set, this will update the next time the player speaks.
    """
    @property
    def settings(self) -> VoiceSettings:
        r"""
        (VoiceSettings):  [Read-Write] Configurable settings for this player's voice. When set, this will update the next time the player speaks.
        """
        ...
    @settings.setter
    def settings(self, value: VoiceSettings) -> None:
        ...
    def register_with_player_state(self, owning_state: PlayerState) -> None:
        r"""
        x.register_with_player_state(owning_state) -> None
        This function sets up this talker with a specific player.
        It is necessary to use this to properly control a specific player's voice
        and receive events.
        
        Args:
            owning_state (PlayerState):
        """
        ...
    def get_voice_level(self) -> float:
        r"""
        x.get_voice_level() -> float
        Get the current level of how loud this player is speaking. Will return 0.0
        if player is not talking.
        
        Returns:
            float:
        """
        ...
    @classmethod
    def create_talker_for_player(cls, owning_state: PlayerState) -> VOIPTalker:
        r"""
        X.create_talker_for_player(owning_state) -> VOIPTalker
        function for creating and registering a UVOIPTalker.
        
        Args:
            owning_state (PlayerState): 
        
        Returns:
            VOIPTalker:
        """
        ...
    def bp_on_talking_end(self) -> None:
        r"""
        x.bp_on_talking_end() -> None
        Blueprint native event for when this player stops speaking.
        """
        ...
    def bp_on_talking_begin(self, audio_component: AudioComponent) -> None:
        r"""
        x.bp_on_talking_begin(audio_component) -> None
        Blueprint native event for when this player starts speaking.
        
        Args:
            audio_component (AudioComponent):
        """
        ...

class VOIPStatics(BlueprintFunctionLibrary):
    r"""
    VOIPStatics
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VoiceConfig.h
    
    """
    @classmethod
    def set_mic_threshold(cls, threshold: float) -> None:
        r"""
        X.set_mic_threshold(threshold) -> None
        This function sets the Mic threshold for VOIP chat.
        
        Args:
            threshold (float):
        """
        ...

class VolumeTexture(Texture):
    r"""
    Volume Texture
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VolumeTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_mode`` (TextureAddress):  [Read-Write] The addressing mode to use for the X, Y and Z axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source2d_texture`` (Texture2D):  [Read-Write] A (optional) reference texture from which the volume texture was built
    - ``source2d_tile_size_x`` (int32):  [Read-Write] The reference texture tile size X
    - ``source2d_tile_size_y`` (int32):  [Read-Write] The reference texture tile size Y
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    @property
    def address_mode(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] The addressing mode to use for the X, Y and Z axis.
        """
        ...
    @address_mode.setter
    def address_mode(self, value: TextureAddress) -> None:
        ...

class VolumetricLightmapDensityVolume(Volume):
    r"""
    Provides local control over volumetric lightmap density.  Only convex shapes supported.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VolumetricLightmapDensityVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``allowed_mip_level_range`` (Int32Interval):  [Read-Write] The Volumetric Lightmap has 3 mipmaps, where the highest density mipmap (mip0) corresponds to VolumetricLightmapDetailCellSize.
      mip0: DetailCellSize
      mip1: DetailCellSize * 4
      mip2: DetailCellSize * 16
      
      By default, highest density will be placed around static geometry and static lights, but AllowedMipLevelRange can be used to override this behavior.
      Examples:
      [0, 3] = Volume does nothing
      [1, 3] = Volume removes highest density mip, even near static geometry, which can be useful to save memory ('stat MapBuildData')
      [0, 0] = Volume forces highest density.  Warning: using this on a large area can greatly increase memory and build times!
      When multiple volumes overlap, the smallest (highest density) values will be used.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class LightMapVirtualTexture2D(Texture2D):
    r"""
    Light Map Virtual Texture 2D
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LightmapVirtualTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``type_to_layer`` (Array[int8]):  [Read-Write]
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    ...

class RuntimeVirtualTexture(Object):
    r"""
    Runtime virtual texture UObject
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RuntimeVirtualTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adaptive`` (bool):  [Read-Write] Enable sparse adaptive page tables. This supports larger tile counts but adds an indirection cost when sampling the virtual texture. It is recommended only when very large virtual resolutions are necessary.
    - ``clear_textures`` (bool):  [Read-Write] Enable clear before rendering a page of the virtual texture. Disabling this can be an optimization if you know that the texture will always be fully covered by rendering.
    - ``compress_textures`` (bool):  [Read-Write] Enable storing the virtual texture in GPU supported compression formats. Using uncompressed is only recommended for debugging and quality comparisons.
    - ``continuous_update`` (bool):  [Read-Write] Enable continuous update of the virtual texture pages. This round-robin updates already mapped pages and can help fix pages that are mapped before dependent textures are fully streamed in.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``material_type`` (RuntimeVirtualTextureMaterialType):  [Read-Write] Contents of virtual texture.
    - ``private_space`` (bool):  [Read-Write] Enable private page table allocation. This can reduce total page table memory allocation but can also reduce the total number of virtual textures supported.
    - ``remove_low_mips`` (int32):  [Read-Write] Number of low mips to cut from the virtual texture. This can reduce peak virtual texture update cost but will also increase the probability of mip shimmering.
    - ``single_physical_space`` (bool):  [Read-Write] Enable page table channel packing. This reduces page table memory and update cost but can reduce the ability to share physical memory with other virtual textures.
    - ``tile_border_size`` (int32):  [Read-Write] Page tile border size divided by 2 (Actual values increase in multiples of 2). Higher values trigger a higher anisotropic sampling level.
    - ``tile_count`` (int32):  [Read-Write] Size of virtual texture in tiles. (Actual values increase in powers of 2).
      This is applied to the largest axis in world space and the size for any shorter axis is chosen to maintain aspect ratio.
    - ``tile_size`` (int32):  [Read-Write] Page tile size. (Actual values increase in powers of 2)
    - ``use_low_quality_compression`` (bool):  [Read-Write] Use low quality textures (RGB565/RGB555A1) to replace runtime compression
    """
    @property
    def tile_count(self) -> int:
        r"""
        (int32):  [Read-Only] Size of virtual texture in tiles. (Actual values increase in powers of 2).
        This is applied to the largest axis in world space and the size for any shorter axis is chosen to maintain aspect ratio.
        """
        ...
    @property
    def tile_size(self) -> int:
        r"""
        (int32):  [Read-Only] Page tile size. (Actual values increase in powers of 2)
        """
        ...
    @property
    def tile_border_size(self) -> int:
        r"""
        (int32):  [Read-Only] Page tile border size divided by 2 (Actual values increase in multiples of 2). Higher values trigger a higher anisotropic sampling level.
        """
        ...
    @property
    def material_type(self) -> RuntimeVirtualTextureMaterialType:
        r"""
        (RuntimeVirtualTextureMaterialType):  [Read-Only] Contents of virtual texture.
        """
        ...
    @property
    def compress_textures(self) -> bool:
        r"""
        (bool):  [Read-Only] Enable storing the virtual texture in GPU supported compression formats. Using uncompressed is only recommended for debugging and quality comparisons.
        """
        ...
    @property
    def use_low_quality_compression(self) -> bool:
        r"""
        (bool):  [Read-Only] Use low quality textures (RGB565/RGB555A1) to replace runtime compression
        """
        ...
    @property
    def lod_group(self) -> TextureGroup:
        r"""
        (TextureGroup):  [Read-Write] Texture group this texture belongs to
        """
        ...
    @lod_group.setter
    def lod_group(self, value: TextureGroup) -> None:
        ...
    def get_size(self) -> int:
        r"""
        x.get_size() -> int32
        Public getter for virtual texture size. This is derived from the TileCount and TileSize.
        
        Returns:
            int32:
        """
        ...
    def get_page_table_size(self) -> int:
        r"""
        x.get_page_table_size() -> int32
        Public getter for virtual texture page table size. This is only different from GetTileCount() when using an adaptive page table.
        
        Returns:
            int32:
        """
        ...

class RuntimeVirtualTextureVolume(Actor):
    r"""
    Actor used to place a URuntimeVirtualTexture in the world.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: RuntimeVirtualTextureVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``virtual_texture_component`` (RuntimeVirtualTextureComponent):  [Read-Only] Component that owns the runtime virtual texture.
    """
    @property
    def virtual_texture_component(self) -> RuntimeVirtualTextureComponent:
        r"""
        (RuntimeVirtualTextureComponent):  [Read-Only] Component that owns the runtime virtual texture.
        """
        ...

class RuntimeVirtualTextureStreamingProxy(Texture2D):
    r"""
    Deprecated class.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VirtualTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    ...

class VirtualTexture2D(Texture2D):
    r"""
    Virtual Texture with locally configurable build settings.
    A raw UTexture2D can also represent a Virtual Texture but uses the one and only per-project build settings.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VirtualTexture.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``address_x`` (TextureAddress):  [Read-Write] The addressing mode to use for the X axis.
    - ``address_y`` (TextureAddress):  [Read-Write] The addressing mode to use for the Y axis.
    - ``adjust_brightness`` (float):  [Read-Write] Static texture brightness adjustment (scales HSV value.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_brightness_curve`` (float):  [Read-Write] Static texture curve adjustment (raises HSV value to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_hue`` (float):  [Read-Write] Static texture hue adjustment (0 - 360) (offsets HSV hue by value in degrees.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_max_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 1 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_min_alpha`` (float):  [Read-Write] Remaps the alpha to the specified min/max range, defines the new value of 0 (Non-destructive; Requires texture source art to be available.)
    - ``adjust_rgb_curve`` (float):  [Read-Write] Static texture RGB curve adjustment (raises linear-space RGB color to the specified power.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_saturation`` (float):  [Read-Write] Static texture saturation adjustment (scales HSV saturation.)  (Non-destructive; Requires texture source art to be available.)
    - ``adjust_vibrance`` (float):  [Read-Write] Static texture "vibrance" adjustment (0 - 1) (HSV saturation algorithm adjustment.)  (Non-destructive; Requires texture source art to be available.)
    - ``alpha_coverage_thresholds`` (Vector4):  [Read-Write] Alpha values per channel to compare to when preserving alpha coverage. 0 means disable channel.  Typical good values in 0.5 - 0.9, not 1.0
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``availability`` (TextureAvailability):  [Read-Write] Whether the texture will be encoded to a gpu format and uploaded to the graphics card, or kept on the CPU for access by gamecode / blueprint.
      For CPU availability, the texture will still upload a tiny black texture as a placeholder. Only applies to 2d textures.
    - ``chroma_key_color`` (Color):  [Read-Write] The color that will be replaced with transparent black if chroma keying is enabled
    - ``chroma_key_texture`` (bool):  [Read-Write] Whether to chroma key the image, replacing any pixels that match ChromaKeyColor with transparent black
    - ``chroma_key_threshold`` (float):  [Read-Write] The threshold that components have to match for the texel to be considered equal to the ChromaKeyColor when chroma keying (<=, set to 0 to require a perfect exact match)
    - ``composite_power`` (float):  [Read-Write] default 1, high values result in a stronger effect e.g 1, 2, 4, 8
      this is not a slider because the texture update would not be fast enough
    - ``composite_texture`` (Texture):  [Read-Write]
    - ``composite_texture_mode`` (CompositeTextureMode):  [Read-Write] defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha
    - ``compress_final`` (bool):  [Read-Write] If enabled, compress with Final quality during this Editor session.
    - ``compression_cache_id`` (Guid):  [Read-Write] Change this optional ID to force the texture to be recompressed by changing its cache key.
    - ``compression_no_alpha`` (bool):  [Read-Write] If enabled, the texture's alpha channel will be forced to opaque for any compressed texture output format.  Does not apply if output format is uncompressed RGBA.
    - ``compression_quality`` (TextureCompressionQuality):  [Read-Write] The compression quality for generated ASTC textures (i.e. mobile platform textures).
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use when building the texture.
    - ``cook_platform_tiling_settings`` (TextureCookPlatformTilingSettings):  [Read-Write] If the platform supports it, tile the texture when cooking, or keep it linear and tile it when it's actually submitted to the GPU.
    - ``defer_compression`` (bool):  [Read-Write] If enabled, defer compression of the texture until save or manually compressed in the texture editor.
    - ``do_scale_mips_for_alpha_coverage`` (bool):  [Read-Write] Whether mip RGBA should be scaled to preserve the number of pixels with Value >= AlphaCoverageThresholds.  AlphaCoverageThresholds are ignored if this is off.
    - ``downscale`` (PerPlatformFloat):  [Read-Write] Downscale source texture, applied only to 2d textures without mips
      < 1.0 - use scale value from texture group
      1.0 - do not scale texture
      > 1.0 - scale texure
    - ``downscale_options`` (TextureDownscaleOptions):  [Read-Write] Texture downscaling options
    - ``filter`` (TextureFilter):  [Read-Write] The texture filtering mode to use when sampling this texture.
    - ``flip_green_channel`` (bool):  [Read-Write] When true the texture's green channel will be inverted. This is useful for some normal maps.
    - ``global_force_mip_levels_to_be_resident`` (bool):  [Read-Write] Global and serialized version of ForceMiplevelsToBeResident.
    - ``lod_bias`` (int32):  [Read-Write] A bias to the index of the top mip level to use.  That is, number of mip levels to drop when cooking.
    - ``lod_group`` (TextureGroup):  [Read-Write] Texture group this texture belongs to
    - ``lossy_compression_amount`` (TextureLossyCompressionAmount):  [Read-Write] How aggressively should any relevant lossy compression be applied. For compressors that support EncodeSpeed (i.e. Oodle), this is only
           applied if enabled (see Project Settings -> Texture Encoding). Note that this is *in addition* to any
           unavoidable loss due to the target format - selecting "No Lossy Compression" will not result in zero distortion for BCn formats.
    - ``max_texture_size`` (int32):  [Read-Write] The maximum resolution for generated textures. A value of 0 means the maximum size for the format on each platform.
    - ``mip_gen_settings`` (TextureMipGenSettings):  [Read-Write] Per asset specific setting to define the mip-map generation properties like sharpening and kernel size.
    - ``mip_load_options`` (TextureMipLoadOptions):  [Read-Write] The texture mip load options.
    - ``never_stream`` (bool):  [Read-Write]
    - ``normalize_normals`` (bool):  [Read-Write] Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior.
    - ``num_cinematic_mip_levels`` (int32):  [Read-Write] Number of mip-levels to use for cinematic quality.
    - ``oodle_preserve_extremes`` (bool):  [Read-Write] If set to true, then Oodle encoder preserves 0 and 255 (0.0 and 1.0) values exactly in alpha channel for BC3/BC7 and in all channels for BC4/BC5.
    - ``oodle_texture_sdk_version`` (Name):  [Read-Write] Oodle Texture SDK Version to encode with.  Enter 'latest' to update; 'None' preserves legacy encoding to avoid patches.
    - ``pad_with_border_color`` (bool):  [Read-Write] If set to true, texture padding will be performed using colors of the border pixels. This can be used to improve quality of the generated mipmaps for padded textures.
    - ``padding_color`` (Color):  [Read-Write] The color used to pad the texture out if it is padded due to PowerOfTwoMode
    - ``power_of_two_mode`` (TexturePowerOfTwoSetting):  [Read-Write] How to pad the texture to a power of 2 size (if necessary)
    - ``preserve_border`` (bool):  [Read-Write] When true the texture's border will be preserved during mipmap generation.
    - ``resize_during_build_x`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original width will be used.
    - ``resize_during_build_y`` (int32):  [Read-Write] Width of the resized texture when using "Resize To Specific Resolution" padding and resizing option. If set to zero, original height will be used.
    - ``source_color_settings`` (TextureSourceColorSettings):  [Read-Write] Texture color management settings: source encoding and color space.
    - ``srgb`` (bool):  [Read-Write] Whether Texture and its source are in SRGB Gamma color space.  Can only be used with 8-bit and compressed formats.  This should be unchecked if using alpha channels individually as masks.
    - ``use_legacy_gamma`` (bool):  [Read-Write] A flag for using the simplified legacy gamma space e.g pow(color,1/2.2) for converting from FColor to FLinearColor, if we're doing sRGB.
    - ``use_new_mip_filter`` (bool):  [Read-Write] Use faster mip generation filter, usually the same result but occasionally causes color shift in high contrast areas.
    - ``virtual_texture_streaming`` (bool):  [Read-Write] Is this texture streamed in using VT
    """
    ...

class VirtualTextureBuilder(Object):
    r"""
    Container for a UVirtualTexture2D that can be built from a FVirtualTextureBuildDesc description.
    This has a simple BuildTexture() interface but we may want to extend in the future to support partial builds
    or other more blueprint driven approaches for data generation.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VirtualTextureBuilder.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_cook_per_platform`` (PerPlatformBool):  [Read-Write] Per platform overrides for cooking the virtual texture.
    - ``separate_texture_for_mobile`` (bool):  [Read-Write] Whether to use a separate texture for Mobile rendering. A separate texure will be built using mobile preview editor mode
    - ``texture`` (VirtualTexture2D):  [Read-Only] The UTexture object.
    - ``texture_mobile`` (VirtualTexture2D):  [Read-Only] The UTexture object for Mobile rendering.
    """
    @property
    def texture(self) -> VirtualTexture2D:
        r"""
        (VirtualTexture2D):  [Read-Only] The UTexture object.
        """
        ...
    @property
    def texture_mobile(self) -> VirtualTexture2D:
        r"""
        (VirtualTexture2D):  [Read-Only] The UTexture object for Mobile rendering.
        """
        ...

class WindDirectionalSource(Info):
    r"""
    Actor that provides a directional wind source. Only affects SpeedTree assets.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WindDirectionalSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``component`` (WindDirectionalSourceComponent):  [Read-Only]
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def component(self) -> WindDirectionalSourceComponent:
        r"""
        (WindDirectionalSourceComponent):  [Read-Only]
        """
        ...

class WorldPartitionBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    World Partition Blueprint Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionBlueprintLibrary.h
    
    """
    @classmethod
    def unpin_actors(cls, actors_to_unpin: Array[Guid]) -> None:
        r"""
        X.unpin_actors(actors_to_unpin) -> None
        Unpin actors
        
        Args:
            actors_to_unpin (Array[Guid]):
        """
        ...
    @classmethod
    def unload_actors(cls, actors_to_unload: Array[Guid]) -> None:
        r"""
        X.unload_actors(actors_to_unload) -> None
        Unload actors
        
        Args:
            actors_to_unload (Array[Guid]):
        """
        ...
    @classmethod
    def pin_actors(cls, actors_to_pin: Array[Guid]) -> None:
        r"""
        X.pin_actors(actors_to_pin) -> None
        Pin actors
        
        Args:
            actors_to_pin (Array[Guid]):
        """
        ...
    @classmethod
    def load_actors(cls, actors_to_load: Array[Guid]) -> None:
        r"""
        X.load_actors(actors_to_load) -> None
        Load actors
        
        Args:
            actors_to_load (Array[Guid]):
        """
        ...
    @classmethod
    def get_runtime_world_bounds(cls) -> Box:
        r"""
        X.get_runtime_world_bounds() -> Box
        Gets the runtime world bounds, which only includes actor descriptors that aren't editor only.
        
        Returns:
            Box: The runtime world bounds.
        """
        ...
    @classmethod
    def get_intersecting_actor_descs(cls, box: Box) -> Optional[Array[ActorDesc]]:
        r"""
        X.get_intersecting_actor_descs(box) -> Array[ActorDesc] or None
        Gets all the actor descriptors intersecting the provided box into the provided array, recursing into actor containers.
        
        Args:
            box (Box): 
        
        Returns:
            Array[ActorDesc] or None: True if the operation was successful.
        
            out_actor_descs (Array[ActorDesc]):
        """
        ...
    @classmethod
    def get_editor_world_bounds(cls) -> Box:
        r"""
        X.get_editor_world_bounds() -> Box
        Gets the editor world bounds, which includes all actor descriptors.
        
        Returns:
            Box: The editor world bounds.
        """
        ...
    @classmethod
    def get_data_layer_manager(cls, world_context_object: Object) -> DataLayerManager:
        r"""
        X.get_data_layer_manager(world_context_object) -> DataLayerManager
        Returns the Data Layer Manager for this object.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            DataLayerManager:
        """
        ...
    @classmethod
    def get_actor_descs_for_actors(cls, actors: Array[Actor]) -> Optional[Array[ActorDesc]]:
        r"""
        X.get_actor_descs_for_actors(actors) -> Array[ActorDesc] or None
        Gets all the actor descriptors from the provided actor pointers, which represents descriptors on disk, e.g. will not
        reflect properties of unsaved actors.
        
        Args:
            actors (Array[Actor]): 
        
        Returns:
            Array[ActorDesc] or None: True if the operation was successful.
        
            out_actor_descs (Array[ActorDesc]):
        """
        ...
    @classmethod
    def get_actor_descs(cls) -> Optional[Array[ActorDesc]]:
        r"""
        X.get_actor_descs() -> Array[ActorDesc] or None
        Gets all the actor descriptors into the provided array, recursing into actor containers.
        
        Returns:
            Array[ActorDesc] or None: True if the operation was successful.
        
            out_actor_descs (Array[ActorDesc]):
        """
        ...

class WorldDataLayers(Info):
    r"""
    Actor containing data layers instances within a world.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldDataLayers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``world_data_layers`` (Set[DataLayer]):  [Read-Write]
      deprecated: Convert Data layers to DataLayerInstances and DataLayerAssets using DataLayerToAsset CommandLet and use DataLayerInstances instead.
    """
    @property
    def world_data_layers(self) -> Set[DataLayer]:
        r"""
        (Set[DataLayer]):  [Read-Write]
        deprecated: Convert Data layers to DataLayerInstances and DataLayerAssets using DataLayerToAsset CommandLet and use DataLayerInstances instead.
        """
        ...
    @world_data_layers.setter
    def world_data_layers(self, value: Set[DataLayer]) -> None:
        ...

class DataLayer(Object):
    r"""
    Data Layer
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_color`` (Color):  [Read-Write]
    - ``initial_runtime_state`` (DataLayerRuntimeState):  [Read-Write]
    - ``is_initially_loaded_in_editor`` (bool):  [Read-Write] Determines the default value of the data layer's loaded state in editor if it hasn't been changed in data layer outliner by the user
    - ``is_initially_visible`` (bool):  [Read-Write] Whether actors associated with the Data Layer should be initially visible in the viewport when loading the map
    - ``is_runtime`` (bool):  [Read-Write] Whether the Data Layer affects actor runtime loading
    """
    def is_visible(self) -> bool:
        r"""
        x.is_visible() -> bool
        Is Visible
        
        Returns:
            bool:
        """
        ...
    def is_runtime(self) -> bool:
        r"""
        x.is_runtime() -> bool
        Is Runtime
        
        Returns:
            bool:
        """
        ...
    def is_initially_visible(self) -> bool:
        r"""
        x.is_initially_visible() -> bool
        Is Initially Visible
        
        Returns:
            bool:
        """
        ...
    def is_initially_active(self) -> bool:
        r"""
        x.is_initially_active() -> bool
        Is Initially Active
        deprecated: Use GetInitialRuntimeState instead
        
        Returns:
            bool:
        """
        ...
    def is_effective_visible(self) -> bool:
        r"""
        x.is_effective_visible() -> bool
        Is Effective Visible
        
        Returns:
            bool:
        """
        ...
    def is_dynamically_loaded(self) -> bool:
        r"""
        x.is_dynamically_loaded() -> bool
        Is Dynamically Loaded
        deprecated: Use IsRuntime instead
        
        Returns:
            bool:
        """
        ...
    def get_initial_state(self) -> DataLayerStateType:
        r"""
        x.get_initial_state() -> DataLayerStateType
        Get Initial State
        deprecated: Use GetInitialRuntimeState instead
        
        Returns:
            DataLayerStateType:
        """
        ...
    def get_initial_runtime_state(self) -> DataLayerRuntimeState:
        r"""
        x.get_initial_runtime_state() -> DataLayerRuntimeState
        Get Initial Runtime State
        
        Returns:
            DataLayerRuntimeState:
        """
        ...
    def get_debug_color(self) -> Color:
        r"""
        x.get_debug_color() -> Color
        Get Debug Color
        
        Returns:
            Color:
        """
        ...
    def get_data_layer_label(self) -> Name:
        r"""
        x.get_data_layer_label() -> Name
        Get Data Layer Label
        
        Returns:
            Name:
        """
        ...
    def equals(self, actor_data_layer: ActorDataLayer) -> bool:
        r"""
        x.equals(actor_data_layer) -> bool
        Equals
        
        Args:
            actor_data_layer (ActorDataLayer): 
        
        Returns:
            bool:
        """
        ...

class DataLayerInstancePrivate(DataLayerInstance):
    r"""
    Data Layer Instance Private
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayerInstancePrivate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_layer_asset`` (DataLayerAsset):  [Read-Only]
    - ``initial_runtime_state`` (DataLayerRuntimeState):  [Read-Write] Initial runtime state of this data layer instance. Only supported if it's runtime and not client/server only.
    - ``is_included_in_actor_filter_default`` (bool):  [Read-Write] Whether actors assigned to this DataLayer are included by default when used in a filter
    - ``is_initially_loaded_in_editor`` (bool):  [Read-Write] Determines the default value of the data layer's loaded state in editor if it hasn't been changed in data layer outliner by the user
    - ``is_initially_visible`` (bool):  [Read-Write] Whether actors associated with the Data Layer should be initially visible in the viewport when loading the map
    """
    ...

class DataLayerSubsystem(WorldSubsystem):
    r"""
    This class is deprecated, it has been replaced by DataLayerManager.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DataLayerSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_data_layer_runtime_state_changed`` (OnDataLayerRuntimeStateChanged):  [Read-Write]
    """
    @property
    def on_data_layer_runtime_state_changed(self) -> OnDataLayerRuntimeStateChanged:
        r"""
        (OnDataLayerRuntimeStateChanged):  [Read-Write]
        """
        ...
    @on_data_layer_runtime_state_changed.setter
    def on_data_layer_runtime_state_changed(self, value: OnDataLayerRuntimeStateChanged) -> None:
        ...
    @property
    def on_data_layer_state_changed(self) -> OnDataLayerRuntimeStateChanged:
        r"""
        deprecated: 'on_data_layer_state_changed' was renamed to 'on_data_layer_runtime_state_changed'.
        """
        ...
    @on_data_layer_state_changed.setter
    def on_data_layer_state_changed(self, value: OnDataLayerRuntimeStateChanged) -> None:
        ...
    def set_data_layer_state_by_label(self, data_layer_label: Name, state: DataLayerStateType) -> None:
        r"""
        x.set_data_layer_state_by_label(data_layer_label, state) -> None
        Set Data Layer State by Label
        deprecated: DataLayerSubsystem is deprecated, use the equivalent function in DataLayerManager
        
        Args:
            data_layer_label (Name): 
            state (DataLayerStateType):
        """
        ...
    def set_data_layer_state(self, data_layer: ActorDataLayer, state: DataLayerStateType) -> None:
        r"""
        x.set_data_layer_state(data_layer, state) -> None
        Set Data Layer State
        deprecated: DataLayerSubsystem is deprecated, use the equivalent function in DataLayerManager
        
        Args:
            data_layer (ActorDataLayer): 
            state (DataLayerStateType):
        """
        ...
    def set_data_layer_runtime_state_by_label(self, data_layer_label: Name, state: DataLayerRuntimeState, is_recursive: bool = False) -> None:
        r"""
        x.set_data_layer_runtime_state_by_label(data_layer_label, state, is_recursive=False) -> None
        Set Data Layer Runtime State by Label
        
        Args:
            data_layer_label (Name): 
            state (DataLayerRuntimeState): 
            is_recursive (bool):
        """
        ...
    def set_data_layer_runtime_state(self, data_layer: ActorDataLayer, state: DataLayerRuntimeState, is_recursive: bool = False) -> None:
        r"""
        x.set_data_layer_runtime_state(data_layer, state, is_recursive=False) -> None
        Set Data Layer Runtime State
        
        Args:
            data_layer (ActorDataLayer): 
            state (DataLayerRuntimeState): 
            is_recursive (bool):
        """
        ...
    def set_data_layer_instance_runtime_state(self, data_layer_asset: DataLayerAsset, state: DataLayerRuntimeState, is_recursive: bool = False) -> None:
        r"""
        x.set_data_layer_instance_runtime_state(data_layer_asset, state, is_recursive=False) -> None
        Set Data Layer Instance Runtime State
        deprecated: DataLayerSubsystem is deprecated, use the equivalent function in DataLayerManager
        
        Args:
            data_layer_asset (DataLayerAsset): 
            state (DataLayerRuntimeState): 
            is_recursive (bool):
        """
        ...
    def get_loaded_data_layer_names(self) -> Set[Name]:
        r"""
        x.get_loaded_data_layer_names() -> Set[Name]
        Get Loaded Data Layer Names
        deprecated: GetLoadedDataLayerNames will be removed.
        
        Returns:
            Set[Name]:
        """
        ...
    def get_data_layer_state_by_label(self, data_layer_label: Name) -> DataLayerStateType:
        r"""
        x.get_data_layer_state_by_label(data_layer_label) -> DataLayerStateType
        Get Data Layer State by Label
        deprecated: DataLayerSubsystem is deprecated, use the equivalent function in DataLayerManager
        
        Args:
            data_layer_label (Name): 
        
        Returns:
            DataLayerStateType:
        """
        ...
    def get_data_layer_state(self, data_layer: ActorDataLayer) -> DataLayerStateType:
        r"""
        x.get_data_layer_state(data_layer) -> DataLayerStateType
        Get Data Layer State
        deprecated: DataLayerSubsystem is deprecated, use the equivalent function in DataLayerManager
        
        Args:
            data_layer (ActorDataLayer): 
        
        Returns:
            DataLayerStateType:
        """
        ...
    def get_data_layer_runtime_state_by_label(self, data_layer_label: Name) -> DataLayerRuntimeState:
        r"""
        x.get_data_layer_runtime_state_by_label(data_layer_label) -> DataLayerRuntimeState
        Get Data Layer Runtime State by Label
        deprecated: DataLayerSubsystem is deprecated, use GetDataLayerInstanceRuntimeState in DataLayerManager
        
        Args:
            data_layer_label (Name): 
        
        Returns:
            DataLayerRuntimeState:
        """
        ...
    def get_data_layer_runtime_state(self, data_layer: ActorDataLayer) -> DataLayerRuntimeState:
        r"""
        x.get_data_layer_runtime_state(data_layer) -> DataLayerRuntimeState
        Get Data Layer Runtime State
        deprecated: DataLayerSubsystem is deprecated, use GetDataLayerInstanceRuntimeState in DataLayerManager
        
        Args:
            data_layer (ActorDataLayer): 
        
        Returns:
            DataLayerRuntimeState:
        """
        ...
    def get_data_layer_instance_runtime_state(self, data_layer_asset: DataLayerAsset) -> DataLayerRuntimeState:
        r"""
        x.get_data_layer_instance_runtime_state(data_layer_asset) -> DataLayerRuntimeState
        Get Data Layer Instance Runtime State
        deprecated: DataLayerSubsystem is deprecated, use the equivalent function in DataLayerManager
        
        Args:
            data_layer_asset (DataLayerAsset): 
        
        Returns:
            DataLayerRuntimeState:
        """
        ...
    def get_data_layer_instance_from_asset(self, data_layer_asset: DataLayerAsset) -> DataLayerInstance:
        r"""
        x.get_data_layer_instance_from_asset(data_layer_asset) -> DataLayerInstance
        Get Data Layer Instance from Asset
        deprecated: DataLayerSubsystem is deprecated, use the equivalent function in DataLayerManager
        
        Args:
            data_layer_asset (DataLayerAsset): 
        
        Returns:
            DataLayerInstance:
        """
        ...
    def get_data_layer_instance_effective_runtime_state(self, data_layer_asset: DataLayerAsset) -> DataLayerRuntimeState:
        r"""
        x.get_data_layer_instance_effective_runtime_state(data_layer_asset) -> DataLayerRuntimeState
        Get Data Layer Instance Effective Runtime State
        deprecated: DataLayerSubsystem is deprecated, use the equivalent function in DataLayerManager
        
        Args:
            data_layer_asset (DataLayerAsset): 
        
        Returns:
            DataLayerRuntimeState:
        """
        ...
    def get_data_layer_from_name(self, data_layer_name: Name) -> DataLayerInstance:
        r"""
        x.get_data_layer_from_name(data_layer_name) -> DataLayerInstance
        Get Data Layer from Name
        deprecated: DataLayerSubsystem is deprecated, use GetDataLayerInstanceFromAsset in DataLayerManager
        
        Args:
            data_layer_name (Name): 
        
        Returns:
            DataLayerInstance:
        """
        ...
    def get_data_layer_from_label(self, data_layer_label: Name) -> DataLayerInstance:
        r"""
        x.get_data_layer_from_label(data_layer_label) -> DataLayerInstance
        Get Data Layer from Label
        deprecated: DataLayerSubsystem is deprecated, use GetDataLayerInstanceFromAsset in DataLayerManager
        
        Args:
            data_layer_label (Name): 
        
        Returns:
            DataLayerInstance:
        """
        ...
    def get_data_layer_effective_runtime_state_by_label(self, data_layer_label: Name) -> DataLayerRuntimeState:
        r"""
        x.get_data_layer_effective_runtime_state_by_label(data_layer_label) -> DataLayerRuntimeState
        Get Data Layer Effective Runtime State by Label
        deprecated: DataLayerSubsystem is deprecated, use GetDataLayerInstanceEffectiveRuntimeState in DataLayerManager
        
        Args:
            data_layer_label (Name): 
        
        Returns:
            DataLayerRuntimeState:
        """
        ...
    def get_data_layer_effective_runtime_state(self, data_layer: ActorDataLayer) -> DataLayerRuntimeState:
        r"""
        x.get_data_layer_effective_runtime_state(data_layer) -> DataLayerRuntimeState
        Get Data Layer Effective Runtime State
        deprecated: DataLayerSubsystem is deprecated, use GetDataLayerInstanceEffectiveRuntimeState in DataLayerManager
        
        Args:
            data_layer (ActorDataLayer): 
        
        Returns:
            DataLayerRuntimeState:
        """
        ...
    def get_data_layer(self, data_layer: ActorDataLayer) -> DataLayerInstance:
        r"""
        x.get_data_layer(data_layer) -> DataLayerInstance
        Get Data Layer
        deprecated: DataLayerSubsystem is deprecated, use GetDataLayerInstanceFromAsset in DataLayerManager
        
        Args:
            data_layer (ActorDataLayer): 
        
        Returns:
            DataLayerInstance:
        """
        ...
    def get_active_data_layer_names(self) -> Set[Name]:
        r"""
        x.get_active_data_layer_names() -> Set[Name]
        Get Active Data Layer Names
        deprecated: GetActiveDataLayerNames will be removed.
        
        Returns:
            Set[Name]:
        """
        ...

class DeprecatedDataLayerInstance(DataLayerInstance):
    r"""
    Class used for Runtime Conversion of the Deprecated UDataLayer Class to UDataLayerInstance + UDataLayerAsset.
    This class is not to be inherited. It is solely used by AWorldDatalayers to convert UDataLayers to UDataLayerInstances on Level Boot.
    You will need to run the DataLayerToAsset CommandLet to convert the deprecated datalayers to UDataLayerAssets and UDataLayerInstanceWithAsset.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DeprecatedDataLayerInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_layer_type`` (DataLayerType):  [Read-Write]
    - ``debug_color`` (Color):  [Read-Write]
    - ``initial_runtime_state`` (DataLayerRuntimeState):  [Read-Write] Initial runtime state of this data layer instance. Only supported if it's runtime and not client/server only.
    - ``is_initially_loaded_in_editor`` (bool):  [Read-Write] Determines the default value of the data layer's loaded state in editor if it hasn't been changed in data layer outliner by the user
    - ``is_initially_visible`` (bool):  [Read-Write] Whether actors associated with the Data Layer should be initially visible in the viewport when loading the map
    """
    ...

class WorldPartitionDestructibleHLODComponent(SceneComponent):
    r"""
    World Partition Destructible HLODComponent
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DestructibleHLODComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class WorldPartitionDestructibleHLODMeshComponent(WorldPartitionDestructibleHLODComponent):
    r"""
    World Partition Destructible HLODMesh Component
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DestructibleHLODComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class WorldPartitionHLOD(Actor):
    r"""
    World Partition HLOD
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class WorldPartitionDestructibleInHLODSupportLibrary(BlueprintFunctionLibrary):
    r"""
    World Partition Destructible in HLODSupport Library
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODDestruction.h
    
    """
    @classmethod
    def destroy_in_hlod(cls, destructible_in_hlod: WorldPartitionDestructibleInHLODInterface) -> None:
        r"""
        X.destroy_in_hlod(destructible_in_hlod) -> None
        Destroy in HLOD
        
        Args:
            destructible_in_hlod (WorldPartitionDestructibleInHLODInterface):
        """
        ...
    @classmethod
    def damage_in_hlod(cls, destructible_in_hlod: WorldPartitionDestructibleInHLODInterface, damage_percent: float) -> None:
        r"""
        X.damage_in_hlod(destructible_in_hlod, damage_percent) -> None
        Damage in HLOD
        
        Args:
            destructible_in_hlod (WorldPartitionDestructibleInHLODInterface): 
            damage_percent (float):
        """
        ...

class HLODLayer(Object):
    r"""
    HLODLayer
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cell_size`` (int32):  [Read-Write] Cell size of the runtime grid created to encompass HLOD actors generated for this HLOD Layer
    - ``hlod_actor_class`` (type(Class)):  [Read-Write] Specify a custom HLOD Actor class, the default is AWorldPartitionHLOD
    - ``hlod_builder_class`` (type(Class)):  [Read-Write] HLOD Builder class
    - ``hlod_builder_settings`` (HLODBuilderSettings):  [Read-Only]
    - ``hlod_modifier_class`` (type(Class)):  [Read-Write] HLOD Modifier class, to allow changes to the HLOD at runtime
    - ``is_spatially_loaded`` (bool):  [Read-Write] Whether HLOD actors generated for this layer will be spatially loaded
    - ``layer_type`` (HLODLayerType):  [Read-Write] Type of HLOD generation to use
    - ``loading_range`` (double):  [Read-Write] Loading range of the runtime grid created to encompass HLOD actors generated for this HLOD Layer
    - ``parent_layer`` (HLODLayer):  [Read-Write] HLOD Layer to assign to the generated HLOD actors
    """
    ...

class NavigationDataChunkActor(PartitionActor):
    r"""
    Navigation Data Chunk Actor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationDataChunkActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class WorldPartitionLevelStreamingDynamic(LevelStreamingDynamic):
    r"""
    World Partition Level Streaming Dynamic
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionLevelStreamingDynamic.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disable_distance_streaming`` (bool):  [Read-Write] Whether this level streaming object should be ignored by world composition distance streaming,
      so streaming state can be controlled by other systems (ex: in blueprints)
    - ``draw_on_level_status_map`` (bool):  [Read-Write] If true, will be drawn on the 'level streaming status' map (STAT LEVELMAP console command)
    - ``editor_streaming_volumes`` (Array[LevelStreamingVolume]):  [Read-Write] The level streaming volumes bound to this level.
    - ``initially_loaded`` (bool):  [Read-Write] Whether the level should be loaded at startup
    - ``initially_visible`` (bool):  [Read-Write] Whether the level should be visible at startup if it is loaded
    - ``is_static`` (bool):  [Read-Write] Whether this level only contains static actors that aren't affected by gameplay or replication.
      If true, the engine can make certain optimizations and will add this level to the StaticLevels collection.
    - ``level_color`` (LinearColor):  [Read-Write] The level color used for visualization. (Show -> Advanced -> Level Coloration)
    - ``level_lod_index`` (int32):  [Read-Write] Requested LOD. Non LOD sub-levels have Index = -1
    - ``level_transform`` (Transform):  [Read-Write] Transform applied to actors after loading.
    - ``min_time_between_volume_unload_requests`` (float):  [Read-Write] Cooldown time in seconds between volume-based unload requests.  Used in preventing spurious unload requests.
    - ``on_level_hidden`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is no longer visible, may not be removed from world yet
    - ``on_level_loaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed in
    - ``on_level_shown`` (LevelStreamingVisibilityStatus):  [Read-Write] Called when level is added to the world and is visible
    - ``on_level_unloaded`` (LevelStreamingLoadedStatus):  [Read-Write] Called when level is streamed out
    - ``should_be_loaded`` (bool):  [Read-Write] Whether the level should be loaded
    - ``should_be_visible`` (bool):  [Read-Write] Whether the level should be visible if it is loaded
    - ``should_block_on_load`` (bool):  [Read-Write] Whether we want to force a blocking load
    - ``should_block_on_unload`` (bool):  [Read-Write] Whether we want to force a blocking unload
    - ``streaming_priority`` (int32):  [Read-Write] The relative priority of considering the streaming level. Changing the priority will not interrupt the currently considered level, but will affect the next time a level is being selected for evaluation.
    - ``world_asset`` (World):  [Read-Only] The reference to the world containing the level to load
    """
    ...

class WorldPartitionMiniMap(Info):
    r"""
    A mini map to preview the world in world partition window. (editor-only)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionMiniMap.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``builder_cell_size`` (int32):  [Read-Write] Size of the loading region that will be used when iterating over the whole map during the minimap build process.
      A smaller size may help reduce blurriness as it will put less pressure on various graphics pools, at the expanse of an increase in processing time.
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``capture_source`` (SceneCaptureSource):  [Read-Write] Specifies which component of the scene rendering should be output to the minimap texture.
    - ``capture_warmup_frames`` (uint32):  [Read-Write] Number of frames to render before each capture in order to warmup various rendering systems (VT/Nanite/etc).
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``excluded_data_layers`` (Set[ActorDataLayer]):  [Read-Write] Datalayers excluded from MiniMap rendering
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``mini_map_texture`` (Texture2D):  [Read-Only] MiniMap Texture for displaying on world partition window
    - ``mini_map_world_bounds`` (Box):  [Read-Only] WorldBounds for MinMapTexture
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``uv_offset`` (Box2D):  [Read-Only] UVOffset used to setup Virtual Texture
    - ``world_units_per_pixel`` (int32):  [Read-Write] Target world units per pixel for the minimap texture.
      May not end up being the final minimap accuracy if the resulting texture resolution is unsupported.
    """
    ...

class WorldPartitionMiniMapVolume(Volume):
    r"""
    World Partition Mini Map Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionMiniMapVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class WorldPartitionReplay(Actor):
    r"""
    Actor used to record world partition replay data (streaming sources for now)
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionReplay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class SpatialHashRuntimeGridInfo(Info):
    r"""
    Actor keeping information regarding a runtime grid
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionRuntimeSpatialHash.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class WorldPartitionSubsystem(TickableWorldSubsystem):
    r"""
    UWorldPartitionSubsystem
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionSubsystem.h
    
    """
    def is_streaming_completed(self, query_state: WorldPartitionRuntimeCellState, query_sources: Array[WorldPartitionStreamingQuerySource], exact_state: bool) -> bool:
        r"""
        x.is_streaming_completed(query_state, query_sources, exact_state) -> bool
        Is Streaming Completed
        
        Args:
            query_state (WorldPartitionRuntimeCellState): 
            query_sources (Array[WorldPartitionStreamingQuerySource]): 
            exact_state (bool): 
        
        Returns:
            bool:
        """
        ...
    def is_all_streaming_completed(self) -> bool:
        r"""
        x.is_all_streaming_completed() -> bool
        Returns true if world partition is done streaming levels, adding them to the world or removing them from the world.
        
        Returns:
            bool:
        """
        ...

class WorldPartitionVolume(Volume):
    r"""
    World Partition Volume
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartitionVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``brush_builder`` (BrushBuilder):  [Read-Only]
    - ``brush_component`` (BrushComponent):  [Read-Only]
    - ``brush_type`` (BrushType):  [Read-Write] Type of brush
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``display_shaded_volume`` (bool):  [Read-Write] If true, display the brush with a shaded volume
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``shaded_volume_opacity_value`` (float):  [Read-Write] Value used to set the opacity for the shaded volume, between 0-1
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class SoundFactory(Factory):
    r"""
    Sound Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``auto_create_cue`` (bool):  [Read-Write] If enabled, a sound cue will automatically be created for the sound
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``cue_package_suffix`` (str):  [Read-Write] If not empty, generated SoundCues will be placed in PackageCuePackageSuffix, but only if bAutoCreateCue is true
    - ``cue_volume`` (float):  [Read-Write] The volume of the created sound cue
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``include_attenuation_node`` (bool):  [Read-Write] If enabled, the created sound cue will include a attenuation node
    - ``include_looping_node`` (bool):  [Read-Write] If enabled, the created sound cue will include a looping node
    - ``include_modulator_node`` (bool):  [Read-Write] If enabled, the created sound cue will include a modulator node
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ReimportSoundFactory(SoundFactory):
    r"""
    Reimport Sound Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: ReimportSoundFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``auto_create_cue`` (bool):  [Read-Write] If enabled, a sound cue will automatically be created for the sound
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``cue_package_suffix`` (str):  [Read-Write] If not empty, generated SoundCues will be placed in PackageCuePackageSuffix, but only if bAutoCreateCue is true
    - ``cue_volume`` (float):  [Read-Write] The volume of the created sound cue
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``include_attenuation_node`` (bool):  [Read-Write] If enabled, the created sound cue will include a attenuation node
    - ``include_looping_node`` (bool):  [Read-Write] If enabled, the created sound cue will include a looping node
    - ``include_modulator_node`` (bool):  [Read-Write] If enabled, the created sound cue will include a modulator node
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AudioBusFactory(Factory):
    r"""
    Audio Bus Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: AudioBusFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class DialogueVoiceFactory(Factory):
    r"""
    Dialogue Voice Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: DialogueVoiceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class DialogueWaveFactory(Factory):
    r"""
    Dialogue Wave Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: DialogueWaveFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ReverbEffectFactory(Factory):
    r"""
    Reverb Effect Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: ReverbEffectFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundAttenuationFactory(Factory):
    r"""
    Sound Attenuation Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundAttenuationFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundClassFactory(Factory):
    r"""
    Sound Class Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundClassFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundConcurrencyFactory(Factory):
    r"""
    Sound Concurrency Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundConcurrencyFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundCueFactoryNew(Factory):
    r"""
    Sound Cue Factory New
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundCueFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``initial_dialogue_wave`` (DialogueWave):  [Read-Write] An initial dialogue wave to place in the newly created cue
      deprecated: Use Array InitialDialogueWaves instead.
    - ``initial_dialogue_waves`` (Array[DialogueWave]):  [Read-Write] Initial dialogue wave(s) to place in the newly created cue(s)
    - ``initial_sound_wave`` (SoundWave):  [Read-Write] Initial sound wave to place in the newly created cue
      deprecated: Use Array InitialSoundWaves instead.
    - ``initial_sound_waves`` (Array[SoundWave]):  [Read-Write] Initial sound wave(s) to place in the newly created cue(s)
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    @property
    def initial_sound_wave(self) -> SoundWave:
        r"""
        (SoundWave):  [Read-Write] Initial sound wave to place in the newly created cue
        deprecated: Use Array InitialSoundWaves instead.
        """
        ...
    @initial_sound_wave.setter
    def initial_sound_wave(self, value: SoundWave) -> None:
        ...
    @property
    def initial_dialogue_wave(self) -> DialogueWave:
        r"""
        (DialogueWave):  [Read-Write] An initial dialogue wave to place in the newly created cue
        deprecated: Use Array InitialDialogueWaves instead.
        """
        ...
    @initial_dialogue_wave.setter
    def initial_dialogue_wave(self, value: DialogueWave) -> None:
        ...

class SoundMixFactory(Factory):
    r"""
    Sound Mix Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundMixFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundSourceBusFactory(Factory):
    r"""
    Sound Source Bus Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundSourceBusFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundSourceEffectFactory(Factory):
    r"""
    Sound Source Effect Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundSourceEffectFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``sound_effect_sourcepreset_class`` (type(Class)):  [Read-Write] The type of sound source effect preset that will be created
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundSourceEffectChainFactory(Factory):
    r"""
    Sound Source Effect Chain Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundSourceEffectFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundSubmixEffectFactory(Factory):
    r"""
    Sound Submix Effect Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundSubmixEffectFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``sound_effect_submix_preset_class`` (type(Class)):  [Read-Write] The type of sound source effect preset that will be created
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundSubmixFactory(Factory):
    r"""
    Sound Submix Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundSubmixFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundfieldSubmixFactory(Factory):
    r"""
    Soundfield Submix Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundSubmixFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class EndpointSubmixFactory(Factory):
    r"""
    Endpoint Submix Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundSubmixFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SoundfieldEndpointSubmixFactory(Factory):
    r"""
    Soundfield Endpoint Submix Factory
    
    **C++ Source:**
    
    - **Module**: AudioEditor
    - **File**: SoundSubmixFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AnimationModifier(Object):
    r"""
    Animation Modifier
    
    **C++ Source:**
    
    - **Module**: AnimationModifiers
    - **File**: AnimationModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``reapply_post_owner_change`` (bool):  [Read-Write] If this is set to true then the animation modifier will call it's reapply function after any change made to the owning asset.
    """
    def on_revert(self, animation_sequence: AnimSequence) -> None:
        r"""
        x.on_revert(animation_sequence) -> None
        On Revert
        
        Args:
            animation_sequence (AnimSequence):
        """
        ...
    def on_apply(self, animation_sequence: AnimSequence) -> None:
        r"""
        x.on_apply(animation_sequence) -> None
        Executed when the Animation is initialized (native event for debugging / testing purposes)
        
        Args:
            animation_sequence (AnimSequence):
        """
        ...

class ChaosCacheCollection(Object):
    r"""
    Chaos Cache Collection
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCaching
    - **File**: CacheCollection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``caches`` (Array[ChaosCache]):  [Read-Write]
    """
    ...

class ChaosCacheManager(Actor):
    r"""
    Chaos Cache Manager
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCaching
    - **File**: CacheManagerActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``cache_collection`` (ChaosCacheCollection):  [Read-Write] The Cache Collection asset to use for this observer. This can be used for playback and record simultaneously
      across multiple components depending on the settings for that component.
    - ``cache_mode`` (CacheMode):  [Read-Write] How to use the cache - playback or record
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``observed_components`` (Array[ObservedComponent]):  [Read-Write] List of observed objects and their caches
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``start_mode`` (StartMode):  [Read-Write] How to trigger the cache record or playback, timed will start counting at BeginPlay, Triggered will begin
      counting from when the owning cache manager is requested to trigger the cache action
      see: AChaosCacheManager::TriggerObservedComponent
    - ``start_time`` (float):  [Read-Write] Defines the (random access) time that represents the rest pose of the components managed by this cache.
      When in Play mode, the components are set to the state provided by the caches at this evaluated time.
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def start_time(self) -> float:
        r"""
        (float):  [Read-Write] Defines the (random access) time that represents the rest pose of the components managed by this cache.
        When in Play mode, the components are set to the state provided by the caches at this evaluated time.
        """
        ...
    @start_time.setter
    def start_time(self, value: float) -> None:
        ...
    def trigger_component_by_cache(self, cache_name: Name) -> None:
        r"""
        x.trigger_component_by_cache(cache_name) -> None
        Triggers a component to play or record.
        Searches the observed component list for an entry matching InCacheName and triggers the
        playback or recording of the linked observed component
        
        Args:
            cache_name (Name): Cache name to trigger
        """
        ...
    def trigger_component(self, component: PrimitiveComponent) -> None:
        r"""
        x.trigger_component(component) -> None
        Triggers a component to play or record.
        If the cache manager has an observed component entry for InComponent and it is a triggered entry
        this will begin the playback or record for that component, otherwise no action is taken.
        
        Args:
            component (PrimitiveComponent): Component to trigger
        """
        ...
    def trigger_all(self) -> None:
        r"""
        x.trigger_all() -> None
        Triggers the recording or playback of all observed components
        """
        ...
    def set_current_time(self, current_time: float) -> None:
        r"""
        x.set_current_time(current_time) -> None
        Set Current Time
        
        Args:
            current_time (float):
        """
        ...
    def set_cache_collection(self, cache_collection: ChaosCacheCollection) -> None:
        r"""
        x.set_cache_collection(cache_collection) -> None
        change the cache collection for this player
        if the cache is playing or recording this will have no effect
        
        Args:
            cache_collection (ChaosCacheCollection):
        """
        ...
    def reset_single_transform(self, index: int) -> None:
        r"""
        x.reset_single_transform(index) -> None
        Resets the component at the specified index in the observed list back to the world space transform it had when the
        cache for it was originally recorded if one is available
        
        Args:
            index (int32): Index of the component to reset
        """
        ...
    def reset_all_component_transforms(self) -> None:
        r"""
        x.reset_all_component_transforms() -> None
        Resets all components back to the world space transform they had when the cache for them was originally recorded
        if one is available
        """
        ...
    def enable_playback_by_cache(self, cache_name: Name, enable: bool) -> None:
        r"""
        x.enable_playback_by_cache(cache_name, enable) -> None
        Enable playback for a specific component using its cache name
        
        Args:
            cache_name (Name): 
            enable (bool):
        """
        ...
    def enable_playback(self, index: int, enable: bool) -> None:
        r"""
        x.enable_playback(index, enable) -> None
        Enable playback for a specific component using its index in the list of observed component
        
        Args:
            index (int32): 
            enable (bool):
        """
        ...

class ChaosCachePlayer(ChaosCacheManager):
    r"""
    Chaos Cache Player
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCaching
    - **File**: CacheManagerActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``cache_collection`` (ChaosCacheCollection):  [Read-Write] The Cache Collection asset to use for this observer. This can be used for playback and record simultaneously
      across multiple components depending on the settings for that component.
    - ``cache_mode`` (CacheMode):  [Read-Write] How to use the cache - playback or record
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``observed_components`` (Array[ObservedComponent]):  [Read-Write] List of observed objects and their caches
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``start_mode`` (StartMode):  [Read-Write] How to trigger the cache record or playback, timed will start counting at BeginPlay, Triggered will begin
      counting from when the owning cache manager is requested to trigger the cache action
      see: AChaosCacheManager::TriggerObservedComponent
    - ``start_time`` (float):  [Read-Write] Defines the (random access) time that represents the rest pose of the components managed by this cache.
      When in Play mode, the components are set to the state provided by the caches at this evaluated time.
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class MovieSceneChaosCacheSection(MovieSceneBaseCacheSection):
    r"""
    Movie scene section that control ChaosCache playback
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCaching
    - **File**: MovieSceneChaosCacheSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``params`` (MovieSceneChaosCacheParams):  [Read-Write]
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneChaosCacheTrack(MovieSceneNameableTrack):
    r"""
    Handles animation of ChaosCache
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCaching
    - **File**: MovieSceneChaosCacheTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class ChaosClothingInteractor(ClothingInteractor):
    r"""
    Chaos Clothing Interactor
    
    **C++ Source:**
    
    - **Plugin**: ChaosCloth
    - **Module**: ChaosCloth
    - **File**: ChaosClothingSimulationInteractor.h
    
    """
    def set_wind(self, drag: Vector2D = [0.070000, 0.500000], lift: Vector2D = [0.070000, 0.500000], air_density: float = 0.000001, wind_velocity: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        r"""
        x.set_wind(drag=[0.070000, 0.500000], lift=[0.070000, 0.500000], air_density=0.000001, wind_velocity=[0.000000, 0.000000, 0.000000]) -> None
        Set Wind
        
        Args:
            drag (Vector2D): 
            lift (Vector2D): 
            air_density (float): 
            wind_velocity (Vector):
        """
        ...
    def set_velocity_scale(self, linear_velocity_scale: Vector = [0.750000, 0.750000, 0.750000], angular_velocity_scale: float = 0.750000, fictitious_angular_scale: float = 1.000000) -> None:
        r"""
        x.set_velocity_scale(linear_velocity_scale=[0.750000, 0.750000, 0.750000], angular_velocity_scale=0.750000, fictitious_angular_scale=1.000000) -> None
        Set Velocity Scale
        
        Args:
            linear_velocity_scale (Vector): 
            angular_velocity_scale (float): 
            fictitious_angular_scale (float):
        """
        ...
    def set_pressure(self, pressure: Vector2D = [0.000000, 1.000000]) -> None:
        r"""
        x.set_pressure(pressure=[0.000000, 1.000000]) -> None
        Set Pressure
        
        Args:
            pressure (Vector2D):
        """
        ...
    def set_material_linear(self, edge_stiffness: float = 1.000000, bending_stiffness: float = 1.000000, area_stiffness: float = 1.000000) -> None:
        r"""
        x.set_material_linear(edge_stiffness=1.000000, bending_stiffness=1.000000, area_stiffness=1.000000) -> None
        Set Material Linear
        
        Args:
            edge_stiffness (float): 
            bending_stiffness (float): 
            area_stiffness (float):
        """
        ...
    def set_material(self, edge_stiffness: Vector2D = [1.000000, 1.000000], bending_stiffness: Vector2D = [1.000000, 1.000000], area_stiffness: Vector2D = [1.000000, 1.000000]) -> None:
        r"""
        x.set_material(edge_stiffness=[1.000000, 1.000000], bending_stiffness=[1.000000, 1.000000], area_stiffness=[1.000000, 1.000000]) -> None
        Set Material
        
        Args:
            edge_stiffness (Vector2D): 
            bending_stiffness (Vector2D): 
            area_stiffness (Vector2D):
        """
        ...
    def set_long_range_attachment_linear(self, tether_stiffness: float = 1.000000, tether_scale: float = 1.000000) -> None:
        r"""
        x.set_long_range_attachment_linear(tether_stiffness=1.000000, tether_scale=1.000000) -> None
        Set Long Range Attachment Linear
        
        Args:
            tether_stiffness (float): 
            tether_scale (float):
        """
        ...
    def set_long_range_attachment(self, tether_stiffness: Vector2D = [1.000000, 1.000000], tether_scale: Vector2D = [1.000000, 1.000000]) -> None:
        r"""
        x.set_long_range_attachment(tether_stiffness=[1.000000, 1.000000], tether_scale=[1.000000, 1.000000]) -> None
        Set Long Range Attachment
        
        Args:
            tether_stiffness (Vector2D): 
            tether_scale (Vector2D):
        """
        ...
    def set_gravity(self, gravity_scale: float = 1.000000, is_gravity_overridden: bool = False, gravity_override: Vector = [0.000000, 0.000000, -981.000000]) -> None:
        r"""
        x.set_gravity(gravity_scale=1.000000, is_gravity_overridden=False, gravity_override=[0.000000, 0.000000, -981.000000]) -> None
        Set Gravity
        
        Args:
            gravity_scale (float): 
            is_gravity_overridden (bool): 
            gravity_override (Vector):
        """
        ...
    def set_damping(self, damping_coefficient: float = 0.010000, local_damping_coefficient: float = 0.000000) -> None:
        r"""
        x.set_damping(damping_coefficient=0.010000, local_damping_coefficient=0.000000) -> None
        Set Damping
        
        Args:
            damping_coefficient (float): 
            local_damping_coefficient (float):
        """
        ...
    def set_collision(self, collision_thickness: float = 1.000000, friction_coefficient: float = 0.800000, use_ccd: bool = False, self_collision_thickness: float = 2.000000) -> None:
        r"""
        x.set_collision(collision_thickness=1.000000, friction_coefficient=0.800000, use_ccd=False, self_collision_thickness=2.000000) -> None
        Set Collision
        
        Args:
            collision_thickness (float): 
            friction_coefficient (float): 
            use_ccd (bool): 
            self_collision_thickness (float):
        """
        ...
    def set_backstop(self, enabled: bool = True) -> None:
        r"""
        x.set_backstop(enabled=True) -> None
        Set Backstop
        
        Args:
            enabled (bool):
        """
        ...
    def set_anim_drive_linear(self, anim_drive_stiffness: float = 0.000000) -> None:
        r"""
        x.set_anim_drive_linear(anim_drive_stiffness=0.000000) -> None
        Set Anim Drive Linear
        
        Args:
            anim_drive_stiffness (float):
        """
        ...
    def set_anim_drive(self, anim_drive_stiffness: Vector2D = [0.000000, 1.000000], anim_drive_damping: Vector2D = [0.000000, 1.000000]) -> None:
        r"""
        x.set_anim_drive(anim_drive_stiffness=[0.000000, 1.000000], anim_drive_damping=[0.000000, 1.000000]) -> None
        Set Anim Drive
        
        Args:
            anim_drive_stiffness (Vector2D): 
            anim_drive_damping (Vector2D):
        """
        ...
    def set_aerodynamics(self, drag_coefficient: float = 0.070000, lift_coefficient: float = 0.035000, wind_velocity: Vector = [0.000000, 0.000000, 0.000000]) -> None:
        r"""
        x.set_aerodynamics(drag_coefficient=0.070000, lift_coefficient=0.035000, wind_velocity=[0.000000, 0.000000, 0.000000]) -> None
        Deprecated. This function cannot set different Low and High values for the Drag and Lift weight maps. Use SetWind instead.
        
        Args:
            drag_coefficient (float): 
            lift_coefficient (float): 
            wind_velocity (Vector):
        """
        ...
    def reset_and_teleport(self, reset: bool = False, teleport: bool = False) -> None:
        r"""
        x.reset_and_teleport(reset=False, teleport=False) -> None
        Reset and Teleport
        
        Args:
            reset (bool): 
            teleport (bool):
        """
        ...

class ChaosClothingSimulationInteractor(ClothingSimulationInteractor):
    r"""
    Chaos Clothing Simulation Interactor
    
    **C++ Source:**
    
    - **Plugin**: ChaosCloth
    - **Module**: ChaosCloth
    - **File**: ChaosClothingSimulationInteractor.h
    
    """
    ...

class TurnBasedMatchInterface(Interface):
    r"""
    Turn Based Match Interface
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystem
    - **Module**: OnlineSubsystem
    - **File**: TurnBasedMatchInterface.h
    
    """
    def on_match_received_turn(self, match: str, did_become_active: bool) -> None:
        r"""
        x.on_match_received_turn(match, did_become_active) -> None
        On Match Received Turn
        
        Args:
            match (str): 
            did_become_active (bool):
        """
        ...
    def on_match_ended(self, match: str) -> None:
        r"""
        x.on_match_ended(match) -> None
        On Match Ended
        
        Args:
            match (str):
        """
        ...

class AchievementLibrary(BlueprintFunctionLibrary):
    r"""
    Library of synchronous achievement calls
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: AchievementBlueprintLibrary.h
    
    """
    @classmethod
    def get_cached_achievement_progress(cls, world_context_object: Object, player_controller: PlayerController, achievement_id: Name) -> Tuple[bool, float]:
        r"""
        X.get_cached_achievement_progress(world_context_object, player_controller, achievement_id) -> (found_id=bool, progress=float)
        out
        
        Args:
            world_context_object (Object): 
            player_controller (PlayerController): 
            achievement_id (Name): 
        
        Returns:
            tuple: 
        
            found_id (bool): 
        
            progress (float):
        """
        ...
    @classmethod
    def get_cached_achievement_description(cls, world_context_object: Object, player_controller: PlayerController, achievement_id: Name) -> Tuple[bool, Text, Text, Text, bool]:
        r"""
        X.get_cached_achievement_description(world_context_object, player_controller, achievement_id) -> (found_id=bool, title=Text, locked_description=Text, unlocked_description=Text, hidden=bool)
        out
        
        Args:
            world_context_object (Object): 
            player_controller (PlayerController): 
            achievement_id (Name): 
        
        Returns:
            tuple: 
        
            found_id (bool): 
        
            title (Text): 
        
            locked_description (Text): 
        
            unlocked_description (Text): 
        
            hidden (bool):
        """
        ...

class OnlineBlueprintCallProxyBase(BlueprintAsyncActionBase):
    r"""
    Online Blueprint Call Proxy Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: OnlineBlueprintCallProxyBase.h
    
    """
    ...

class AchievementQueryCallbackProxy(OnlineBlueprintCallProxyBase):
    r"""
    Achievement Query Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: AchievementQueryCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (EmptyOnlineDelegate):  [Read-Write] Called when there is an unsuccessful query
    - ``on_success`` (EmptyOnlineDelegate):  [Read-Write] Called when there is a successful query
    """
    @property
    def on_success(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when there is a successful query
        """
        ...
    @on_success.setter
    def on_success(self, value: EmptyOnlineDelegate) -> None:
        ...
    @property
    def on_failure(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when there is an unsuccessful query
        """
        ...
    @on_failure.setter
    def on_failure(self, value: EmptyOnlineDelegate) -> None:
        ...

class AchievementWriteCallbackProxy(OnlineBlueprintCallProxyBase):
    r"""
    Achievement Write Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: AchievementWriteCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (AchievementWriteDelegate):  [Read-Write] Called when there is an unsuccessful achievement write
    - ``on_success`` (AchievementWriteDelegate):  [Read-Write] Called when there is a successful achievement write
    """
    @property
    def on_success(self) -> AchievementWriteDelegate:
        r"""
        (AchievementWriteDelegate):  [Read-Write] Called when there is a successful achievement write
        """
        ...
    @on_success.setter
    def on_success(self, value: AchievementWriteDelegate) -> None:
        ...
    @property
    def on_failure(self) -> AchievementWriteDelegate:
        r"""
        (AchievementWriteDelegate):  [Read-Write] Called when there is an unsuccessful achievement write
        """
        ...
    @on_failure.setter
    def on_failure(self, value: AchievementWriteDelegate) -> None:
        ...

class ConnectionCallbackProxy(OnlineBlueprintCallProxyBase):
    r"""
    Connection Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: ConnectionCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (OnlineConnectionResult):  [Read-Write] Called when there is an unsuccessful query
    - ``on_success`` (OnlineConnectionResult):  [Read-Write] Called when there is a successful query
    """
    @property
    def on_success(self) -> OnlineConnectionResult:
        r"""
        (OnlineConnectionResult):  [Read-Write] Called when there is a successful query
        """
        ...
    @on_success.setter
    def on_success(self, value: OnlineConnectionResult) -> None:
        ...
    @property
    def on_failure(self) -> OnlineConnectionResult:
        r"""
        (OnlineConnectionResult):  [Read-Write] Called when there is an unsuccessful query
        """
        ...
    @on_failure.setter
    def on_failure(self, value: OnlineConnectionResult) -> None:
        ...

class CreateSessionCallbackProxy(OnlineBlueprintCallProxyBase):
    r"""
    Create Session Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: CreateSessionCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (EmptyOnlineDelegate):  [Read-Write] Called when there was an error creating the session
    - ``on_success`` (EmptyOnlineDelegate):  [Read-Write] Called when the session was created successfully
    """
    @property
    def on_success(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when the session was created successfully
        """
        ...
    @on_success.setter
    def on_success(self, value: EmptyOnlineDelegate) -> None:
        ...
    @property
    def on_failure(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when there was an error creating the session
        """
        ...
    @on_failure.setter
    def on_failure(self, value: EmptyOnlineDelegate) -> None:
        ...

class DestroySessionCallbackProxy(OnlineBlueprintCallProxyBase):
    r"""
    Destroy Session Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: DestroySessionCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (EmptyOnlineDelegate):  [Read-Write] Called when there is an unsuccessful destroy
    - ``on_success`` (EmptyOnlineDelegate):  [Read-Write] Called when there is a successful destroy
    """
    @property
    def on_success(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when there is a successful destroy
        """
        ...
    @on_success.setter
    def on_success(self, value: EmptyOnlineDelegate) -> None:
        ...
    @property
    def on_failure(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when there is an unsuccessful destroy
        """
        ...
    @on_failure.setter
    def on_failure(self, value: EmptyOnlineDelegate) -> None:
        ...

class EndMatchCallbackProxy(OnlineBlueprintCallProxyBase):
    r"""
    End Match Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: EndMatchCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (EmptyOnlineDelegate):  [Read-Write] Called when ending the match fails
    - ``on_success`` (EmptyOnlineDelegate):  [Read-Write] Called when the match ends successfully
    """
    @property
    def on_success(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when the match ends successfully
        """
        ...
    @on_success.setter
    def on_success(self, value: EmptyOnlineDelegate) -> None:
        ...
    @property
    def on_failure(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when ending the match fails
        """
        ...
    @on_failure.setter
    def on_failure(self, value: EmptyOnlineDelegate) -> None:
        ...

class EndTurnCallbackProxy(OnlineBlueprintCallProxyBase):
    r"""
    End Turn Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: EndTurnCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (EmptyOnlineDelegate):  [Read-Write] Called when there is an unsuccessful query
    - ``on_success`` (EmptyOnlineDelegate):  [Read-Write] Called when there is a successful query
    """
    @property
    def on_success(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when there is a successful query
        """
        ...
    @on_success.setter
    def on_success(self, value: EmptyOnlineDelegate) -> None:
        ...
    @property
    def on_failure(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when there is an unsuccessful query
        """
        ...
    @on_failure.setter
    def on_failure(self, value: EmptyOnlineDelegate) -> None:
        ...

class FindSessionsCallbackProxy(OnlineBlueprintCallProxyBase):
    r"""
    Find Sessions Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: FindSessionsCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (BlueprintFindSessionsResultDelegate):  [Read-Write] Called when there is an unsuccessful query
    - ``on_success`` (BlueprintFindSessionsResultDelegate):  [Read-Write] Called when there is a successful query
    """
    @property
    def on_success(self) -> BlueprintFindSessionsResultDelegate:
        r"""
        (BlueprintFindSessionsResultDelegate):  [Read-Write] Called when there is a successful query
        """
        ...
    @on_success.setter
    def on_success(self, value: BlueprintFindSessionsResultDelegate) -> None:
        ...
    @property
    def on_failure(self) -> BlueprintFindSessionsResultDelegate:
        r"""
        (BlueprintFindSessionsResultDelegate):  [Read-Write] Called when there is an unsuccessful query
        """
        ...
    @on_failure.setter
    def on_failure(self, value: BlueprintFindSessionsResultDelegate) -> None:
        ...
    @classmethod
    def get_server_name(cls, result: BlueprintSessionResult) -> str:
        r"""
        X.get_server_name(result) -> str
        Get Server Name
        
        Args:
            result (BlueprintSessionResult): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_ping_in_ms(cls, result: BlueprintSessionResult) -> int:
        r"""
        X.get_ping_in_ms(result) -> int32
        Get Ping in Ms
        
        Args:
            result (BlueprintSessionResult): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_max_players(cls, result: BlueprintSessionResult) -> int:
        r"""
        X.get_max_players(result) -> int32
        Get Max Players
        
        Args:
            result (BlueprintSessionResult): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_current_players(cls, result: BlueprintSessionResult) -> int:
        r"""
        X.get_current_players(result) -> int32
        Get Current Players
        
        Args:
            result (BlueprintSessionResult): 
        
        Returns:
            int32:
        """
        ...

class FindTurnBasedMatchCallbackProxy(OnlineBlueprintCallProxyBase):
    r"""
    Find Turn Based Match Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: FindTurnBasedMatchCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (OnlineTurnBasedMatchResult):  [Read-Write] Called when matchmaking failed
    - ``on_success`` (OnlineTurnBasedMatchResult):  [Read-Write] Called when matchmaking succeeded.
    """
    @property
    def on_success(self) -> OnlineTurnBasedMatchResult:
        r"""
        (OnlineTurnBasedMatchResult):  [Read-Write] Called when matchmaking succeeded.
        """
        ...
    @on_success.setter
    def on_success(self, value: OnlineTurnBasedMatchResult) -> None:
        ...
    @property
    def on_failure(self) -> OnlineTurnBasedMatchResult:
        r"""
        (OnlineTurnBasedMatchResult):  [Read-Write] Called when matchmaking failed
        """
        ...
    @on_failure.setter
    def on_failure(self, value: OnlineTurnBasedMatchResult) -> None:
        ...

class InAppPurchaseCallbackProxy2(Object):
    r"""
    In App Purchase Callback Proxy 2
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseCallbackProxy2.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (InAppPurchaseResult2):  [Read-Write] Called when there is an unsuccessful In-App Purchase transaction
    - ``on_success`` (InAppPurchaseResult2):  [Read-Write] Called when there is a successful In-App Purchase transaction
    """
    @property
    def on_success(self) -> InAppPurchaseResult2:
        r"""
        (InAppPurchaseResult2):  [Read-Write] Called when there is a successful In-App Purchase transaction
        """
        ...
    @on_success.setter
    def on_success(self, value: InAppPurchaseResult2) -> None:
        ...
    @property
    def on_failure(self) -> InAppPurchaseResult2:
        r"""
        (InAppPurchaseResult2):  [Read-Write] Called when there is an unsuccessful In-App Purchase transaction
        """
        ...
    @on_failure.setter
    def on_failure(self, value: InAppPurchaseResult2) -> None:
        ...
    @classmethod
    def create_proxy_object_for_in_app_purchase_unprocessed_purchases(cls, player_controller: PlayerController) -> InAppPurchaseCallbackProxy2:
        r"""
        X.create_proxy_object_for_in_app_purchase_unprocessed_purchases(player_controller) -> InAppPurchaseCallbackProxy2
        Create Proxy Object for in App Purchase Unprocessed Purchases
        deprecated: Please use 'Get known In-App Receipts' and remember to pass the output receipts to 'Finalize In-App Purchase Transaction' after being validated and processed
        
        Args:
            player_controller (PlayerController): 
        
        Returns:
            InAppPurchaseCallbackProxy2:
        """
        ...
    @classmethod
    def create_proxy_object_for_in_app_purchase_query_owned(cls, player_controller: PlayerController) -> InAppPurchaseCallbackProxy2:
        r"""
        X.create_proxy_object_for_in_app_purchase_query_owned(player_controller) -> InAppPurchaseCallbackProxy2
        Create Proxy Object for in App Purchase Query Owned
        deprecated: Please use 'Query for Owned In-App Products' and remember to pass the output receipts to 'Finalize In-App Purchase Transaction' after being validated and processed
        
        Args:
            player_controller (PlayerController): 
        
        Returns:
            InAppPurchaseCallbackProxy2:
        """
        ...
    @classmethod
    def create_proxy_object_for_in_app_purchase(cls, player_controller: PlayerController, product_request: InAppPurchaseProductRequest2) -> InAppPurchaseCallbackProxy2:
        r"""
        X.create_proxy_object_for_in_app_purchase(player_controller, product_request) -> InAppPurchaseCallbackProxy2
        Kicks off a transaction for the provided product identifier
        deprecated: Please use 'Start an In-App Purchase' and remember to pass the output receipts to 'Finalize In-App Purchase Transaction' after being validated and processed
        
        Args:
            player_controller (PlayerController): 
            product_request (InAppPurchaseProductRequest2): 
        
        Returns:
            InAppPurchaseCallbackProxy2:
        """
        ...

class InAppPurchaseCheckoutCallbackProxy(Object):
    r"""
    In App Purchase Checkout Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseCheckoutCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (OnlineProxyInAppCheckoutResult):  [Read-Write] Called when there is an unsuccessful In-App Purchase transaction
    - ``on_success`` (OnlineProxyInAppCheckoutResult):  [Read-Write] Called when there is a successful In-App Purchase transaction
    """
    @property
    def on_success(self) -> OnlineProxyInAppCheckoutResult:
        r"""
        (OnlineProxyInAppCheckoutResult):  [Read-Write] Called when there is a successful In-App Purchase transaction
        """
        ...
    @on_success.setter
    def on_success(self, value: OnlineProxyInAppCheckoutResult) -> None:
        ...
    @property
    def on_failure(self) -> OnlineProxyInAppCheckoutResult:
        r"""
        (OnlineProxyInAppCheckoutResult):  [Read-Write] Called when there is an unsuccessful In-App Purchase transaction
        """
        ...
    @on_failure.setter
    def on_failure(self, value: OnlineProxyInAppCheckoutResult) -> None:
        ...
    @classmethod
    def create_proxy_object_for_in_app_purchase_checkout(cls, player_controller: PlayerController, product_request: InAppPurchaseProductRequest2) -> InAppPurchaseCheckoutCallbackProxy:
        r"""
        X.create_proxy_object_for_in_app_purchase_checkout(player_controller, product_request) -> InAppPurchaseCheckoutCallbackProxy
        Kicks off a transaction for the provided product identifier
        
        Args:
            player_controller (PlayerController): 
            product_request (InAppPurchaseProductRequest2): 
        
        Returns:
            InAppPurchaseCheckoutCallbackProxy:
        """
        ...

class InAppPurchaseFinalizeProxy(Object):
    r"""
    In App Purchase Finalize Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseFinalizeProxy.h
    
    """
    @classmethod
    def create_proxy_object_for_in_app_purchase_finalize(cls, app_purchase_receipt: InAppPurchaseReceiptInfo2, player_controller: PlayerController) -> InAppPurchaseFinalizeProxy:
        r"""
        X.create_proxy_object_for_in_app_purchase_finalize(app_purchase_receipt, player_controller) -> InAppPurchaseFinalizeProxy
        Finalizes a transaction for the provided transaction identifier
        
        Args:
            app_purchase_receipt (InAppPurchaseReceiptInfo2): 
            player_controller (PlayerController): 
        
        Returns:
            InAppPurchaseFinalizeProxy:
        """
        ...

class InAppPurchaseQueryCallbackProxy2(Object):
    r"""
    In App Purchase Query Callback Proxy 2
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseQueryCallbackProxy2.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (InAppPurchaseQuery2Result):  [Read-Write] Called when there is an unsuccessful InAppPurchase query
    - ``on_success`` (InAppPurchaseQuery2Result):  [Read-Write] Called when there is a successful InAppPurchase query
    """
    @property
    def on_success(self) -> InAppPurchaseQuery2Result:
        r"""
        (InAppPurchaseQuery2Result):  [Read-Write] Called when there is a successful InAppPurchase query
        """
        ...
    @on_success.setter
    def on_success(self, value: InAppPurchaseQuery2Result) -> None:
        ...
    @property
    def on_failure(self) -> InAppPurchaseQuery2Result:
        r"""
        (InAppPurchaseQuery2Result):  [Read-Write] Called when there is an unsuccessful InAppPurchase query
        """
        ...
    @on_failure.setter
    def on_failure(self, value: InAppPurchaseQuery2Result) -> None:
        ...
    @classmethod
    def create_proxy_object_for_in_app_purchase_query(cls, player_controller: PlayerController, product_identifiers: Array[str]) -> InAppPurchaseQueryCallbackProxy2:
        r"""
        X.create_proxy_object_for_in_app_purchase_query(player_controller, product_identifiers) -> InAppPurchaseQueryCallbackProxy2
        Queries a InAppPurchase for an integer value
        
        Args:
            player_controller (PlayerController): 
            product_identifiers (Array[str]): 
        
        Returns:
            InAppPurchaseQueryCallbackProxy2:
        """
        ...

class InAppPurchaseReceiptsCallbackProxy(Object):
    r"""
    In App Purchase Receipts Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseReceiptsCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (OnlineProxyInAppReceiptsResult):  [Read-Write] Called when there is an unsuccessful In-App Purchase transaction
    - ``on_success`` (OnlineProxyInAppReceiptsResult):  [Read-Write] Called when there is a successful In-App Purchase transaction
    """
    @property
    def on_success(self) -> OnlineProxyInAppReceiptsResult:
        r"""
        (OnlineProxyInAppReceiptsResult):  [Read-Write] Called when there is a successful In-App Purchase transaction
        """
        ...
    @on_success.setter
    def on_success(self, value: OnlineProxyInAppReceiptsResult) -> None:
        ...
    @property
    def on_failure(self) -> OnlineProxyInAppReceiptsResult:
        r"""
        (OnlineProxyInAppReceiptsResult):  [Read-Write] Called when there is an unsuccessful In-App Purchase transaction
        """
        ...
    @on_failure.setter
    def on_failure(self, value: OnlineProxyInAppReceiptsResult) -> None:
        ...
    @classmethod
    def create_proxy_object_for_in_app_purchase_restore_owned_products(cls, player_controller: PlayerController) -> InAppPurchaseReceiptsCallbackProxy:
        r"""
        X.create_proxy_object_for_in_app_purchase_restore_owned_products(player_controller) -> InAppPurchaseReceiptsCallbackProxy
        Create Proxy Object for in App Purchase Restore Owned Products
        
        Args:
            player_controller (PlayerController): 
        
        Returns:
            InAppPurchaseReceiptsCallbackProxy:
        """
        ...
    @classmethod
    def create_proxy_object_for_in_app_purchase_query_owned_products(cls, player_controller: PlayerController) -> InAppPurchaseReceiptsCallbackProxy:
        r"""
        X.create_proxy_object_for_in_app_purchase_query_owned_products(player_controller) -> InAppPurchaseReceiptsCallbackProxy
        Create Proxy Object for in App Purchase Query Owned Products
        
        Args:
            player_controller (PlayerController): 
        
        Returns:
            InAppPurchaseReceiptsCallbackProxy:
        """
        ...
    @classmethod
    def create_proxy_object_for_in_app_purchase_get_known_receipts(cls, player_controller: PlayerController) -> InAppPurchaseReceiptsCallbackProxy:
        r"""
        X.create_proxy_object_for_in_app_purchase_get_known_receipts(player_controller) -> InAppPurchaseReceiptsCallbackProxy
        Create Proxy Object for in App Purchase Get Known Receipts
        
        Args:
            player_controller (PlayerController): 
        
        Returns:
            InAppPurchaseReceiptsCallbackProxy:
        """
        ...

class InAppPurchaseRestoreCallbackProxy2(Object):
    r"""
    In App Purchase Restore Callback Proxy 2
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: InAppPurchaseRestoreCallbackProxy2.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (InAppPurchaseRestoreResult2):  [Read-Write] Called when there is an unsuccessful In-App Purchase transaction
    - ``on_success`` (InAppPurchaseRestoreResult2):  [Read-Write] Called when there is a successful In-App Purchase transaction
    """
    @property
    def on_success(self) -> InAppPurchaseRestoreResult2:
        r"""
        (InAppPurchaseRestoreResult2):  [Read-Write] Called when there is a successful In-App Purchase transaction
        """
        ...
    @on_success.setter
    def on_success(self, value: InAppPurchaseRestoreResult2) -> None:
        ...
    @property
    def on_failure(self) -> InAppPurchaseRestoreResult2:
        r"""
        (InAppPurchaseRestoreResult2):  [Read-Write] Called when there is an unsuccessful In-App Purchase transaction
        """
        ...
    @on_failure.setter
    def on_failure(self, value: InAppPurchaseRestoreResult2) -> None:
        ...
    @classmethod
    def create_proxy_object_for_in_app_purchase_restore(cls, consumable_product_flags: Array[InAppPurchaseProductRequest2], player_controller: PlayerController) -> InAppPurchaseRestoreCallbackProxy2:
        r"""
        X.create_proxy_object_for_in_app_purchase_restore(consumable_product_flags, player_controller) -> InAppPurchaseRestoreCallbackProxy2
        Kicks off a transaction for the provided product identifier
        deprecated: Please use 'Restore Owned In-App Products' and remember to pass the output receipts to 'Finalize In-App Purchase Transaction' after being validated and processed
        
        Args:
            consumable_product_flags (Array[InAppPurchaseProductRequest2]): 
            player_controller (PlayerController): 
        
        Returns:
            InAppPurchaseRestoreCallbackProxy2:
        """
        ...

class JoinSessionCallbackProxy(OnlineBlueprintCallProxyBase):
    r"""
    Join Session Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: JoinSessionCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (EmptyOnlineDelegate):  [Read-Write] Called when there is an unsuccessful join
    - ``on_success`` (EmptyOnlineDelegate):  [Read-Write] Called when there is a successful join
    """
    @property
    def on_success(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when there is a successful join
        """
        ...
    @on_success.setter
    def on_success(self, value: EmptyOnlineDelegate) -> None:
        ...
    @property
    def on_failure(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when there is an unsuccessful join
        """
        ...
    @on_failure.setter
    def on_failure(self, value: EmptyOnlineDelegate) -> None:
        ...

class LeaderboardLibrary(BlueprintFunctionLibrary):
    r"""
    A beacon host used for taking reservations for an existing game session
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: LeaderboardBlueprintLibrary.h
    
    """
    @classmethod
    def write_leaderboard_integer(cls, player_controller: PlayerController, stat_name: Name, stat_value: int) -> bool:
        r"""
        X.write_leaderboard_integer(player_controller, stat_name, stat_value) -> bool
        Writes an integer value to the specified leaderboard
        
        Args:
            player_controller (PlayerController): 
            stat_name (Name): 
            stat_value (int32): 
        
        Returns:
            bool:
        """
        ...

class LeaderboardFlushCallbackProxy(Object):
    r"""
    Leaderboard Flush Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: LeaderboardFlushCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (OnLeaderboardFlushed):  [Read-Write] Called when there is an unsuccessful leaderboard flush
    - ``on_success`` (OnLeaderboardFlushed):  [Read-Write] Called when there is a successful leaderboard flush
    """
    @property
    def on_success(self) -> OnLeaderboardFlushed:
        r"""
        (OnLeaderboardFlushed):  [Read-Write] Called when there is a successful leaderboard flush
        """
        ...
    @on_success.setter
    def on_success(self, value: OnLeaderboardFlushed) -> None:
        ...
    @property
    def on_failure(self) -> OnLeaderboardFlushed:
        r"""
        (OnLeaderboardFlushed):  [Read-Write] Called when there is an unsuccessful leaderboard flush
        """
        ...
    @on_failure.setter
    def on_failure(self, value: OnLeaderboardFlushed) -> None:
        ...

class LeaderboardQueryCallbackProxy(Object):
    r"""
    Leaderboard Query Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: LeaderboardQueryCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (LeaderboardQueryResult):  [Read-Write] Called when there is an unsuccessful leaderboard query
    - ``on_success`` (LeaderboardQueryResult):  [Read-Write] Called when there is a successful leaderboard query
    """
    @property
    def on_success(self) -> LeaderboardQueryResult:
        r"""
        (LeaderboardQueryResult):  [Read-Write] Called when there is a successful leaderboard query
        """
        ...
    @on_success.setter
    def on_success(self, value: LeaderboardQueryResult) -> None:
        ...
    @property
    def on_failure(self) -> LeaderboardQueryResult:
        r"""
        (LeaderboardQueryResult):  [Read-Write] Called when there is an unsuccessful leaderboard query
        """
        ...
    @on_failure.setter
    def on_failure(self, value: LeaderboardQueryResult) -> None:
        ...

class LogoutCallbackProxy(BlueprintAsyncActionBase):
    r"""
    Logout Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: LogoutCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (OnlineLogoutResult):  [Read-Write] Called when the logout completed unsuccessfully
    - ``on_success`` (OnlineLogoutResult):  [Read-Write] Called when the logout completed successfully
    """
    @property
    def on_success(self) -> OnlineLogoutResult:
        r"""
        (OnlineLogoutResult):  [Read-Write] Called when the logout completed successfully
        """
        ...
    @on_success.setter
    def on_success(self, value: OnlineLogoutResult) -> None:
        ...
    @property
    def on_failure(self) -> OnlineLogoutResult:
        r"""
        (OnlineLogoutResult):  [Read-Write] Called when the logout completed unsuccessfully
        """
        ...
    @on_failure.setter
    def on_failure(self, value: OnlineLogoutResult) -> None:
        ...

class OnlineBeacon(Actor):
    r"""
    Base class for beacon communication (Unreal Networking, but outside normal gameplay traffic)
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: OnlineBeacon.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class OnlineBeaconClient(OnlineBeacon):
    r"""
    Base class for any unique beacon connectivity, paired with an AOnlineBeaconHostObject implementation
    
    This is the actual actor that replicates across client/server and where all RPCs occur
    On the host, the life cycle is managed by an AOnlineBeaconHostObject
    On the client, the life cycle is managed by the game
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: OnlineBeaconClient.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class OnlineBeaconHost(OnlineBeacon):
    r"""
    Main actor that listens for side channel communication from another Unreal Engine application
    
    The AOnlineBeaconHost listens for connections to route to a registered AOnlineBeaconHostObject
    The AOnlineBeaconHostObject is responsible for spawning the server version of the AOnlineBeaconClient
    The AOnlineBeaconHost pairs the two client actors, verifies the validity of the exchange, and accepts/continues the connection
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: OnlineBeaconHost.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class OnlineBeaconHostObject(Actor):
    r"""
    Base class for any unique beacon connectivity, paired with an AOnlineBeaconClient implementation
    
    By defining a beacon type and implementing the ability to spawn unique AOnlineBeaconClients, any two instances of the engine
    can communicate with each other without officially connecting through normal Unreal networking
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: OnlineBeaconHostObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class PartyBeaconClient(OnlineBeaconClient):
    r"""
    A beacon client used for making reservations with an existing game session
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: PartyBeaconClient.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class PartyBeaconHost(OnlineBeaconHostObject):
    r"""
    A beacon host used for taking reservations for an existing game session
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: PartyBeaconHost.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class QuitMatchCallbackProxy(OnlineBlueprintCallProxyBase):
    r"""
    Quit Match Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: QuitMatchCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (EmptyOnlineDelegate):  [Read-Write] Called when there is an unsuccessful query
    - ``on_success`` (EmptyOnlineDelegate):  [Read-Write] Called when there is a successful query
    """
    @property
    def on_success(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when there is a successful query
        """
        ...
    @on_success.setter
    def on_success(self, value: EmptyOnlineDelegate) -> None:
        ...
    @property
    def on_failure(self) -> EmptyOnlineDelegate:
        r"""
        (EmptyOnlineDelegate):  [Read-Write] Called when there is an unsuccessful query
        """
        ...
    @on_failure.setter
    def on_failure(self, value: EmptyOnlineDelegate) -> None:
        ...

class ShowLoginUICallbackProxy(BlueprintAsyncActionBase):
    r"""
    Show Login UICallback Proxy
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: ShowLoginUICallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_failure`` (OnlineShowLoginUIResult):  [Read-Write] Called when there is an unsuccessful query
    - ``on_success`` (OnlineShowLoginUIResult):  [Read-Write] Called when there is a successful query
    """
    @property
    def on_success(self) -> OnlineShowLoginUIResult:
        r"""
        (OnlineShowLoginUIResult):  [Read-Write] Called when there is a successful query
        """
        ...
    @on_success.setter
    def on_success(self, value: OnlineShowLoginUIResult) -> None:
        ...
    @property
    def on_failure(self) -> OnlineShowLoginUIResult:
        r"""
        (OnlineShowLoginUIResult):  [Read-Write] Called when there is an unsuccessful query
        """
        ...
    @on_failure.setter
    def on_failure(self, value: OnlineShowLoginUIResult) -> None:
        ...

class SpectatorBeaconClient(OnlineBeaconClient):
    r"""
    A beacon client used for making reservations with an existing game session
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: SpectatorBeaconClient.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class SpectatorBeaconHost(OnlineBeaconHostObject):
    r"""
    A beacon host used for taking reservations for an existing game session
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: SpectatorBeaconHost.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class TestBeaconClient(OnlineBeaconClient):
    r"""
    A beacon client used for making reservations with an existing game session
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: TestBeaconClient.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class TestBeaconHost(OnlineBeaconHostObject):
    r"""
    A beacon host used for taking reservations for an existing game session
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: TestBeaconHost.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class TurnBasedLibrary(BlueprintFunctionLibrary):
    r"""
    Library of synchronous achievement calls
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: TurnBasedBlueprintLibrary.h
    
    """
    @classmethod
    def register_turn_based_match_interface_object(cls, world_context_object: Object, player_controller: PlayerController, object: Object) -> None:
        r"""
        X.register_turn_based_match_interface_object(world_context_object, player_controller, object) -> None
        Register Turn Based Match Interface Object
        
        Args:
            world_context_object (Object): 
            player_controller (PlayerController): 
            object (Object):
        """
        ...
    @classmethod
    def get_player_display_name(cls, world_context_object: Object, player_controller: PlayerController, match_id: str, player_index: int) -> str:
        r"""
        X.get_player_display_name(world_context_object, player_controller, match_id, player_index) -> str
        out
        
        Args:
            world_context_object (Object): 
            player_controller (PlayerController): 
            match_id (str): 
            player_index (int32): 
        
        Returns:
            str: 
        
            player_display_name (str):
        """
        ...
    @classmethod
    def get_my_player_index(cls, world_context_object: Object, player_controller: PlayerController, match_id: str) -> int:
        r"""
        X.get_my_player_index(world_context_object, player_controller, match_id) -> int32
        out
        
        Args:
            world_context_object (Object): 
            player_controller (PlayerController): 
            match_id (str): 
        
        Returns:
            int32: 
        
            player_index (int32):
        """
        ...
    @classmethod
    def get_is_my_turn(cls, world_context_object: Object, player_controller: PlayerController, match_id: str) -> bool:
        r"""
        X.get_is_my_turn(world_context_object, player_controller, match_id) -> bool
        out
        
        Args:
            world_context_object (Object): 
            player_controller (PlayerController): 
            match_id (str): 
        
        Returns:
            bool: 
        
            is_my_turn (bool):
        """
        ...

class VoipListenerSynthComponent(SynthComponent):
    r"""
    Voip Listener Synth Component
    
    **C++ Source:**
    
    - **Plugin**: OnlineSubsystemUtils
    - **Module**: OnlineSubsystemUtils
    - **File**: VoipListenerSynthComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``allow_spatialization`` (bool):  [Read-Write] Is this audio component allowed to be spatialized?
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] What sound concurrency to use for sounds generated by this audio component
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulation_routing`` (SoundModulationDefaultRoutingSettings):  [Read-Write]
    - ``on_audio_envelope_value`` (OnSynthEnvelopeValue):  [Read-Write]
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``override_attenuation`` (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sound_class`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] Submix this sound belongs to
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] An array of submix sends. Audio from this sound will send a portion of its audio to these effects.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    def is_idling(self) -> bool:
        r"""
        x.is_idling() -> bool
        * Thread safe way to get whether this synth component still has buffered packets of audio to play back.
        * This function is used by the Voice Engine to clean up voice sounds when they are not playing back audio
        * to make space for other sounds to be rendered.
        
        *
        
        Returns:
            bool: true if this synth component is out of audio to play.
        """
        ...

class LevelVariantSets(Object):
    r"""
    Level Variant Sets
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: LevelVariantSets.h
    
    """
    def get_variant_set_by_name(self, variant_set_name: str) -> VariantSet:
        r"""
        x.get_variant_set_by_name(variant_set_name) -> VariantSet
        Get Variant Set by Name
        
        Args:
            variant_set_name (str): 
        
        Returns:
            VariantSet:
        """
        ...
    def get_variant_set(self, variant_set_index: int) -> VariantSet:
        r"""
        x.get_variant_set(variant_set_index) -> VariantSet
        Get Variant Set
        
        Args:
            variant_set_index (int32): 
        
        Returns:
            VariantSet:
        """
        ...
    def get_num_variant_sets(self) -> int:
        r"""
        x.get_num_variant_sets() -> int32
        Get Num Variant Sets
        
        Returns:
            int32:
        """
        ...
    def remove_variant_set_by_name(self, variant_set_name: str) -> None:
        r"""
        x.remove_variant_set_by_name(variant_set_name) -> None
        Looks for a variant set with VariantSetName within LevelVariantSets and removes it, if it exists
        
        Args:
            variant_set_name (str):
        """
        ...
    def remove_variant_set(self, variant_set: VariantSet) -> None:
        r"""
        x.remove_variant_set(variant_set) -> None
        Removes VariantSet from LevelVariantSets, if that is its parent
        
        Args:
            variant_set (VariantSet):
        """
        ...
    def add_variant_set(self, variant_set: VariantSet) -> None:
        r"""
        x.add_variant_set(variant_set) -> None
        Adds VariantSet to the LevelVariantSets' list of VariantSets
        
        Args:
            variant_set (VariantSet):
        """
        ...

class LevelVariantSetsActor(Actor):
    r"""
    Level Variant Sets Actor
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: LevelVariantSetsActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``level_variant_sets`` (SoftObjectPath):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def level_variant_sets(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Only]
        """
        ...
    def switch_on_variant_by_name(self, variant_set_name: str, variant_name: str) -> bool:
        r"""
        x.switch_on_variant_by_name(variant_set_name, variant_name) -> bool
        Switch on Variant by Name
        
        Args:
            variant_set_name (str): 
            variant_name (str): 
        
        Returns:
            bool:
        """
        ...
    def switch_on_variant_by_index(self, variant_set_index: int, variant_index: int) -> bool:
        r"""
        x.switch_on_variant_by_index(variant_set_index, variant_index) -> bool
        Switch on Variant by Index
        
        Args:
            variant_set_index (int32): 
            variant_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_level_variant_sets(self, variant_sets: LevelVariantSets) -> None:
        r"""
        x.set_level_variant_sets(variant_sets) -> None
        Set Level Variant Sets
        
        Args:
            variant_sets (LevelVariantSets):
        """
        ...
    def get_level_variant_sets(self, load: bool = False) -> LevelVariantSets:
        r"""
        x.get_level_variant_sets(load=False) -> LevelVariantSets
        Returns the LevelVariantSets asset, optionally loading it if necessary
        
        Args:
            load (bool): 
        
        Returns:
            LevelVariantSets:
        """
        ...

class LevelVariantSetsFunctionDirector(Object):
    r"""
    Level Variant Sets Function Director
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: LevelVariantSetsFunctionDirector.h
    
    """
    ...

class PropertyValue(Object):
    r"""
    Property Value
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: PropertyValue.h
    
    """
    def has_recorded_data(self) -> bool:
        r"""
        x.has_recorded_data() -> bool
        Has Recorded Data
        
        Returns:
            bool:
        """
        ...
    def get_property_tooltip(self) -> Text:
        r"""
        x.get_property_tooltip() -> Text
        Get Property Tooltip
        
        Returns:
            Text:
        """
        ...
    def get_full_display_string(self) -> str:
        r"""
        x.get_full_display_string() -> str
        Get Full Display String
        
        Returns:
            str:
        """
        ...
    def set_value_vector4(self, value: Vector4) -> None:
        r"""
        x.set_value_vector4(value) -> None
        Set Value Vector 4
        
        Args:
            value (Vector4):
        """
        ...
    def set_value_vector2d(self, value: Vector2D) -> None:
        r"""
        x.set_value_vector2d(value) -> None
        Set Value Vector 2D
        
        Args:
            value (Vector2D):
        """
        ...
    def set_value_vector(self, value: Vector) -> None:
        r"""
        x.set_value_vector(value) -> None
        Set Value Vector
        
        Args:
            value (Vector):
        """
        ...
    def set_value_string(self, value: str) -> None:
        r"""
        x.set_value_string(value) -> None
        Set Value String
        
        Args:
            value (str):
        """
        ...
    def set_value_rotator(self, value: Rotator) -> None:
        r"""
        x.set_value_rotator(value) -> None
        Set Value Rotator
        
        Args:
            value (Rotator):
        """
        ...
    def set_value_quat(self, value: Quat) -> None:
        r"""
        x.set_value_quat(value) -> None
        Set Value Quat
        
        Args:
            value (Quat):
        """
        ...
    def set_value_object(self, value: Object) -> None:
        r"""
        x.set_value_object(value) -> None
        Set Value Object
        
        Args:
            value (Object):
        """
        ...
    def set_value_linear_color(self, value: LinearColor) -> None:
        r"""
        x.set_value_linear_color(value) -> None
        Set Value Linear Color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_value_int_point(self, value: IntPoint) -> None:
        r"""
        x.set_value_int_point(value) -> None
        Set Value Int Point
        
        Args:
            value (IntPoint):
        """
        ...
    def set_value_int(self, value: int) -> None:
        r"""
        x.set_value_int(value) -> None
        Set Value Int
        
        Args:
            value (int32):
        """
        ...
    def set_value_float(self, value: float) -> None:
        r"""
        x.set_value_float(value) -> None
        Set Value Float
        
        Args:
            value (float):
        """
        ...
    def set_value_color(self, value: Color) -> None:
        r"""
        x.set_value_color(value) -> None
        Set Value Color
        
        Args:
            value (Color):
        """
        ...
    def set_value_bool(self, value: bool) -> None:
        r"""
        x.set_value_bool(value) -> None
        Set Value Bool
        
        Args:
            value (bool):
        """
        ...
    def record(self) -> None:
        r"""
        x.record() -> None
        Records new data for PropVal from the actor from which it was captured
        """
        ...
    def get_value_vector4(self) -> Vector4:
        r"""
        x.get_value_vector4() -> Vector4
        Get Value Vector 4
        
        Returns:
            Vector4:
        """
        ...
    def get_value_vector2d(self) -> Vector2D:
        r"""
        x.get_value_vector2d() -> Vector2D
        Get Value Vector 2D
        
        Returns:
            Vector2D:
        """
        ...
    def get_value_vector(self) -> Vector:
        r"""
        x.get_value_vector() -> Vector
        Get Value Vector
        
        Returns:
            Vector:
        """
        ...
    def get_value_string(self) -> str:
        r"""
        x.get_value_string() -> str
        Get Value String
        
        Returns:
            str:
        """
        ...
    def get_value_rotator(self) -> Rotator:
        r"""
        x.get_value_rotator() -> Rotator
        Get Value Rotator
        
        Returns:
            Rotator:
        """
        ...
    def get_value_quat(self) -> Quat:
        r"""
        x.get_value_quat() -> Quat
        Get Value Quat
        
        Returns:
            Quat:
        """
        ...
    def get_value_object(self) -> Object:
        r"""
        x.get_value_object() -> Object
        Get Value Object
        
        Returns:
            Object:
        """
        ...
    def get_value_linear_color(self) -> LinearColor:
        r"""
        x.get_value_linear_color() -> LinearColor
        Get Value Linear Color
        
        Returns:
            LinearColor:
        """
        ...
    def get_value_int_point(self) -> IntPoint:
        r"""
        x.get_value_int_point() -> IntPoint
        Get Value Int Point
        
        Returns:
            IntPoint:
        """
        ...
    def get_value_int(self) -> int:
        r"""
        x.get_value_int() -> int32
        Get Value Int
        
        Returns:
            int32:
        """
        ...
    def get_value_float(self) -> float:
        r"""
        x.get_value_float() -> float
        Get Value Float
        
        Returns:
            float:
        """
        ...
    def get_value_color(self) -> Color:
        r"""
        x.get_value_color() -> Color
        Get Value Color
        
        Returns:
            Color:
        """
        ...
    def get_value_bool(self) -> bool:
        r"""
        x.get_value_bool() -> bool
        Get Value Bool
        
        Returns:
            bool:
        """
        ...
    def get_property_type_string(self) -> str:
        r"""
        x.get_property_type_string() -> str
        This allows the scripting language to get the type of the C++ property its dealing with
        
        Returns:
            str:
        """
        ...
    def apply(self) -> None:
        r"""
        x.apply() -> None
        Applies the recorded data from PropVal to the actor from which it was captured
        """
        ...

class PropertyValueTransform(PropertyValue):
    r"""
    Deprecated: Only here for backwards compatibility with 4.21
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: PropertyValue.h
    
    """
    ...

class PropertyValueVisibility(PropertyValue):
    r"""
    Deprecated: Only here for backwards compatibility
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: PropertyValue.h
    
    """
    ...

class PropertyValueColor(PropertyValue):
    r"""
    Keeps an FLinearColor interface by using the property setter/getter functions,
    even though the property itself is of FColor type
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: PropertyValueColor.h
    
    """
    ...

class PropertyValueMaterial(PropertyValue):
    r"""
    Property Value Material
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: PropertyValueMaterial.h
    
    """
    ...

class PropertyValueOption(PropertyValue):
    r"""
    PropertyValue that can only be captured from ASwitchActors
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: PropertyValueOption.h
    
    """
    ...

class PropertyValueSoftObject(PropertyValue):
    r"""
    Stores data from a USoftObjectProperty.
    It will store it's recorded data as a raw UObject*, and use the usual UPropertyValue
    facilities for serializing it as a Soft object ptr. This derived class handles converting
    to and from the property's underlying FSoftObjectPtr to our UObject*.
    We can't keep a FSoftObjectPtr ourselves, neither as a temp member nor as raw bytes, as it has
    internal heap-allocated data members like FName and FString.
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: PropertyValueSoftObject.h
    
    """
    ...

class SwitchActor(Actor):
    r"""
    Switch Actor allows quickly toggling the visibility of its child actors so that
    only one is visible at a time. It can also be captured with the Variant Manager
    to expose this capability as a property capture
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: SwitchActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``scene_component`` (SceneComponent):  [Read-Only] Exposing our root component like this allows manual Mobility control on the details panel
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    def select_option(self, option_index: int) -> None:
        r"""
        x.select_option(option_index) -> None
        Select one of the available options by index
        
        Args:
            option_index (int32):
        """
        ...
    def get_selected_option(self) -> int:
        r"""
        x.get_selected_option() -> int32
        If we have exactly one child actor visible, it will return a pointer to it. Returns nullptr otherwise
        
        Returns:
            int32:
        """
        ...
    def get_options(self) -> Array[Actor]:
        r"""
        x.get_options() -> Array[Actor]
        Returns the child actors that are available options, in a fixed order that may differ from the one displayed in the world outliner
        
        Returns:
            Array[Actor]:
        """
        ...

class Variant(Object):
    r"""
    Variant
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: Variant.h
    
    """
    def switch_on(self) -> None:
        r"""
        x.switch_on() -> None
        Switch On
        """
        ...
    def set_thumbnail_from_texture(self, new_thumbnail: Texture2D) -> None:
        r"""
        x.set_thumbnail_from_texture(new_thumbnail) -> None
        Sets the thumbnail to use for this variant. Can receive nullptr to clear it
        
        Args:
            new_thumbnail (Texture2D):
        """
        ...
    def set_thumbnail_from_file(self, file_path: str) -> None:
        r"""
        x.set_thumbnail_from_file(file_path) -> None
        Set Thumbnail from File
        
        Args:
            file_path (str):
        """
        ...
    def set_thumbnail_from_editor_viewport(self) -> None:
        r"""
        x.set_thumbnail_from_editor_viewport() -> None
        Sets the thumbnail from the active editor viewport. Doesn't do anything if the Editor is not available
        """
        ...
    def set_thumbnail_from_camera(self, world_context_object: Object, camera_transform: Transform, fov_degrees: float = 50.000000, min_z: float = 50.000000, gamma: float = 2.200000) -> None:
        r"""
        x.set_thumbnail_from_camera(world_context_object, camera_transform, fov_degrees=50.000000, min_z=50.000000, gamma=2.200000) -> None
        Set Thumbnail from Camera
        
        Args:
            world_context_object (Object): 
            camera_transform (Transform): 
            fov_degrees (float): 
            min_z (float): 
            gamma (float):
        """
        ...
    def set_display_text(self, new_display_text: Text) -> None:
        r"""
        x.set_display_text(new_display_text) -> None
        Set Display Text
        
        Args:
            new_display_text (Text):
        """
        ...
    def is_active(self) -> bool:
        r"""
        x.is_active() -> bool
        Returns true if none of our properties are dirty
        
        Returns:
            bool:
        """
        ...
    def get_thumbnail(self) -> Texture2D:
        r"""
        x.get_thumbnail() -> Texture2D
        Gets the thumbnail currently used for this variant
        
        Returns:
            Texture2D:
        """
        ...
    def get_parent(self) -> VariantSet:
        r"""
        x.get_parent() -> VariantSet
        Get Parent
        
        Returns:
            VariantSet:
        """
        ...
    def get_num_dependencies(self) -> int:
        r"""
        x.get_num_dependencies() -> int32
        Get Num Dependencies
        
        Returns:
            int32:
        """
        ...
    def get_num_actors(self) -> int:
        r"""
        x.get_num_actors() -> int32
        Get Num Actors
        
        Returns:
            int32:
        """
        ...
    def get_display_text(self) -> Text:
        r"""
        x.get_display_text() -> Text
        Get Display Text
        
        Returns:
            Text:
        """
        ...
    def get_dependents(self, level_variant_sets: LevelVariantSets, only_enabled_dependencies: bool) -> Array[Variant]:
        r"""
        x.get_dependents(level_variant_sets, only_enabled_dependencies) -> Array[Variant]
        Returns all the variants that have this variant as a dependency
        
        Args:
            level_variant_sets (LevelVariantSets): 
            only_enabled_dependencies (bool): 
        
        Returns:
            Array[Variant]:
        """
        ...
    def get_dependency(self, index: int) -> VariantDependency:
        r"""
        x.get_dependency(index) -> VariantDependency
        Get the dependency at index 'Index' by value. Will crash if index is invalid
        
        Args:
            index (int32): 
        
        Returns:
            VariantDependency:
        """
        ...
    def get_actor(self, actor_index: int) -> Actor:
        r"""
        x.get_actor(actor_index) -> Actor
        Get Actor
        
        Args:
            actor_index (int32): 
        
        Returns:
            Actor:
        """
        ...
    def set_dependency(self, index: int, dependency: VariantDependency) -> VariantDependency:
        r"""
        x.set_dependency(index, dependency) -> VariantDependency
        Set Dependency
        
        Args:
            index (int32): 
            dependency (VariantDependency): 
        
        Returns:
            VariantDependency: 
        
            dependency (VariantDependency):
        """
        ...
    def remove_captured_property_by_name(self, actor: Actor, property_path: str) -> None:
        r"""
        x.remove_captured_property_by_name(actor, property_path) -> None
        Removes property capture with PropertyPath from Actor's binding within Variant, if it exists
        
        Args:
            actor (Actor): 
            property_path (str):
        """
        ...
    def remove_captured_property(self, actor: Actor, property_: PropertyValue) -> None:
        r"""
        x.remove_captured_property(actor, property_) -> None
        Removes a property capture from an actor binding within Variant, if it exists
        
        Args:
            actor (Actor): 
            property_ (PropertyValue):
        """
        ...
    def remove_actor_binding_by_name(self, actor_name: str) -> None:
        r"""
        x.remove_actor_binding_by_name(actor_name) -> None
        Looks for an actor binding to an actor with ActorLabel within Variant and removes it, if it exists
        
        Args:
            actor_name (str):
        """
        ...
    def remove_actor_binding(self, actor: Actor) -> None:
        r"""
        x.remove_actor_binding(actor) -> None
        Removes an actor binding to Actor from Variant, if it exists
        
        Args:
            actor (Actor):
        """
        ...
    def get_captured_properties(self, actor: Actor) -> Array[PropertyValue]:
        r"""
        x.get_captured_properties(actor) -> Array[PropertyValue]
        Returns which properties have been captured for this actor in Variant
        
        Args:
            actor (Actor): 
        
        Returns:
            Array[PropertyValue]:
        """
        ...
    def delete_dependency(self, index: int) -> None:
        r"""
        x.delete_dependency(index) -> None
        Delete Dependency
        
        Args:
            index (int32):
        """
        ...
    def capture_property(self, actor: Actor, property_path: str) -> PropertyValue:
        r"""
        x.capture_property(actor, property_path) -> PropertyValue
        Finds the actor binding to Actor within Variant and tries capturing a property with PropertyPath
        Returns the captured UPropertyValue if succeeded or nullptr if it failed.
        
        Args:
            actor (Actor): 
            property_path (str): 
        
        Returns:
            PropertyValue:
        """
        ...
    def add_dependency(self, dependency: VariantDependency) -> Tuple[int, VariantDependency]:
        r"""
        x.add_dependency(dependency) -> (int32, dependency=VariantDependency)
        Add Dependency
        
        Args:
            dependency (VariantDependency): 
        
        Returns:
            VariantDependency: 
        
            dependency (VariantDependency):
        """
        ...
    def add_actor_binding(self, actor: Actor) -> None:
        r"""
        x.add_actor_binding(actor) -> None
        Binds the Actor to the Variant, internally creating a VariantObjectBinding
        
        Args:
            actor (Actor):
        """
        ...

class VariantSet(Object):
    r"""
    Variant Set
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContent
    - **File**: VariantSet.h
    
    """
    def set_thumbnail_from_texture(self, new_thumbnail: Texture2D) -> None:
        r"""
        x.set_thumbnail_from_texture(new_thumbnail) -> None
        Sets the thumbnail to use for this variant set. Can receive nullptr to clear it
        
        Args:
            new_thumbnail (Texture2D):
        """
        ...
    def set_thumbnail_from_file(self, file_path: str) -> None:
        r"""
        x.set_thumbnail_from_file(file_path) -> None
        Set Thumbnail from File
        
        Args:
            file_path (str):
        """
        ...
    def set_thumbnail_from_editor_viewport(self) -> None:
        r"""
        x.set_thumbnail_from_editor_viewport() -> None
        Sets the thumbnail from the active editor viewport. Doesn't do anything if the Editor is not available
        """
        ...
    def set_thumbnail_from_camera(self, world_context_object: Object, camera_transform: Transform, fov_degrees: float = 50.000000, min_z: float = 50.000000, gamma: float = 2.200000) -> None:
        r"""
        x.set_thumbnail_from_camera(world_context_object, camera_transform, fov_degrees=50.000000, min_z=50.000000, gamma=2.200000) -> None
        Set Thumbnail from Camera
        
        Args:
            world_context_object (Object): 
            camera_transform (Transform): 
            fov_degrees (float): 
            min_z (float): 
            gamma (float):
        """
        ...
    def set_display_text(self, new_display_text: Text) -> None:
        r"""
        x.set_display_text(new_display_text) -> None
        Set Display Text
        
        Args:
            new_display_text (Text):
        """
        ...
    def get_variant_by_name(self, variant_name: str) -> Variant:
        r"""
        x.get_variant_by_name(variant_name) -> Variant
        Get Variant by Name
        
        Args:
            variant_name (str): 
        
        Returns:
            Variant:
        """
        ...
    def get_variant(self, variant_index: int) -> Variant:
        r"""
        x.get_variant(variant_index) -> Variant
        Get Variant
        
        Args:
            variant_index (int32): 
        
        Returns:
            Variant:
        """
        ...
    def get_thumbnail(self) -> Texture2D:
        r"""
        x.get_thumbnail() -> Texture2D
        Gets the thumbnail currently used for this variant set
        
        Returns:
            Texture2D:
        """
        ...
    def get_parent(self) -> LevelVariantSets:
        r"""
        x.get_parent() -> LevelVariantSets
        Get Parent
        
        Returns:
            LevelVariantSets:
        """
        ...
    def get_num_variants(self) -> int:
        r"""
        x.get_num_variants() -> int32
        Get Num Variants
        
        Returns:
            int32:
        """
        ...
    def get_display_text(self) -> Text:
        r"""
        x.get_display_text() -> Text
        Get Display Text
        
        Returns:
            Text:
        """
        ...
    def remove_variant_by_name(self, variant_name: str) -> None:
        r"""
        x.remove_variant_by_name(variant_name) -> None
        Looks for a variant with VariantName within VariantSet and removes it, if it exists
        
        Args:
            variant_name (str):
        """
        ...
    def remove_variant(self, variant: Variant) -> None:
        r"""
        x.remove_variant(variant) -> None
        Removes Variant from VariantSet, if that is its parent
        
        Args:
            variant (Variant):
        """
        ...
    def add_variant(self, variant: Variant) -> None:
        r"""
        x.add_variant(variant) -> None
        Adds Variant to the VariantSet's list of Variants
        
        Args:
            variant (Variant):
        """
        ...

class GLTFExportOptions(Object):
    r"""
    GLTFExport Options
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFExportOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adjust_normalmaps`` (bool):  [Read-Write] If enabled, exported normalmaps will be adjusted from Unreal to glTF convention (i.e. the green channel is flipped).
    - ``bake_material_inputs`` (GLTFMaterialBakeMode):  [Read-Write] Bake mode determining if and how a material input is baked out to a texture. Baking is only used for non-trivial material inputs (i.e. not simple texture or constant expressions).
    - ``default_input_bake_settings`` (Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]):  [Read-Write] Input-specific default bake settings that override the general defaults above.
    - ``default_level_of_detail`` (int32):  [Read-Write] Default LOD level used for exporting a mesh. Can be overridden by component or asset settings (e.g. minimum or forced LOD level).
    - ``default_material_bake_filter`` (TextureFilter):  [Read-Write] Default filtering mode used when sampling the baked out texture. Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
    - ``default_material_bake_size`` (GLTFMaterialBakeSize):  [Read-Write] Default size of the baked out texture (containing the material input). Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
    - ``default_material_bake_tiling`` (TextureAddress):  [Read-Write] Default addressing mode used when sampling the baked out texture. Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
    - ``export_animation_sequences`` (bool):  [Read-Write] If enabled, export single animation asset used by a skeletal mesh component. Export of vertex skin weights must be enabled.
    - ``export_cameras`` (bool):  [Read-Write] If enabled, export camera components.
    - ``export_clear_coat_materials`` (bool):  [Read-Write] If enabled, materials with shading model clear coat will be properly exported. Uses extension KHR_materials_clearcoat.
    - ``export_cloth_materials`` (bool):  [Read-Write] If enabled, materials with shading model cloth will be properly exported. Uses extension KHR_materials_sheen.
    - ``export_emissive_strength`` (bool):  [Read-Write] If enabled, allows materials to have an emissive factor that exceeds the standard range [0.0, 1.0]. Uses extension KHR_materials_emissive_strength.
    - ``export_hidden_in_game`` (bool):  [Read-Write] If enabled, export actors and components that are flagged as hidden in-game.
    - ``export_level_sequences`` (bool):  [Read-Write] If enabled, export level sequences. Only transform tracks are currently supported. The level sequence will be played at the assigned display rate.
    - ``export_lights`` (bool):  [Read-Write] If enabled, export directional, point, and spot light components. Uses extension KHR_lights_punctual.
    - ``export_material_variants`` (GLTFMaterialVariantMode):  [Read-Write] Mode determining if and how to export material variants that change the materials property on a static or skeletal mesh component.
    - ``export_preview_mesh`` (bool):  [Read-Write] If enabled, the preview mesh for a standalone animation or material asset will also be exported.
    - ``export_proxy_materials`` (bool):  [Read-Write] If enabled, materials that have a proxy defined in their user data, will be exported using that proxy instead. This setting won't affect proxy materials exported or referenced directly.
    - ``export_specular_glossiness_materials`` (bool):  [Read-Write] If enabled, materials using the Importer's SpecularGlossiness material function will be exported. Uses extension KHR_materials_pbrSpecularGlossiness.
    - ``export_texture_transforms`` (bool):  [Read-Write] If enabled, export UV offset and scale/tiling used in materials. Uses extension KHR_texture_transform.
    - ``export_thin_translucent_materials`` (bool):  [Read-Write] If enabled, materials with shading model thin translucency will be exported. Export is only partial. Uses extension KHR_materials_transmission.
    - ``export_uniform_scale`` (float):  [Read-Write] Scale factor used for exporting all assets (0.01 by default) for conversion from centimeters (Unreal default) to meters (glTF).
    - ``export_unlit_materials`` (bool):  [Read-Write] If enabled, materials with shading model unlit will be properly exported. Uses extension KHR_materials_unlit.
    - ``export_vertex_colors`` (bool):  [Read-Write] If enabled, export vertex color. Not recommended due to vertex colors always being used as a base color multiplier in glTF, regardless of material. Often producing undesirable results.
    - ``export_vertex_skin_weights`` (bool):  [Read-Write] If enabled, export vertex bone weights and indices in skeletal meshes. Necessary for animation sequences.
    - ``include_copyright_notice`` (bool):  [Read-Write] If enabled, the copyright notice from project settings will be included as metadata in the glTF asset.
    - ``make_skinned_meshes_root`` (bool):  [Read-Write] If enabled, make skeletal meshes into root nodes to strictly comply with the glTF specification. Final bone transforms remain the same and visual results are unaffected.
    - ``skip_near_default_values`` (bool):  [Read-Write] If enabled, floating-point-based JSON properties that are nearly equal to their default value will not be exported and thus regarded as exactly default, reducing JSON size.
    - ``texture_image_format`` (GLTFTextureImageFormat):  [Read-Write] Desired image format used for exported textures.
    - ``texture_image_quality`` (int32):  [Read-Write] Level of compression used for textures exported with lossy image formats, 0 (default) or value between 1 (worst quality, best compression) and 100 (best quality, worst compression).
    - ``use_importer_material_mapping`` (bool):  [Read-Write] If enabled, materials imported with the Interchange-glTF importer will be directly mapped for the Exporter. bExport material options below will be ignored.
    - ``use_mesh_quantization`` (bool):  [Read-Write] If enabled, use quantization for vertex tangents and normals, reducing size. Requires extension KHR_mesh_quantization, which may result in the mesh not loading in some glTF viewers.
    """
    @property
    def export_uniform_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scale factor used for exporting all assets (0.01 by default) for conversion from centimeters (Unreal default) to meters (glTF).
        """
        ...
    @export_uniform_scale.setter
    def export_uniform_scale(self, value: float) -> None:
        ...
    @property
    def export_preview_mesh(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the preview mesh for a standalone animation or material asset will also be exported.
        """
        ...
    @export_preview_mesh.setter
    def export_preview_mesh(self, value: bool) -> None:
        ...
    @property
    def skip_near_default_values(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, floating-point-based JSON properties that are nearly equal to their default value will not be exported and thus regarded as exactly default, reducing JSON size.
        """
        ...
    @skip_near_default_values.setter
    def skip_near_default_values(self, value: bool) -> None:
        ...
    @property
    def include_copyright_notice(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the copyright notice from project settings will be included as metadata in the glTF asset.
        """
        ...
    @include_copyright_notice.setter
    def include_copyright_notice(self, value: bool) -> None:
        ...
    @property
    def export_proxy_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, materials that have a proxy defined in their user data, will be exported using that proxy instead. This setting won't affect proxy materials exported or referenced directly.
        """
        ...
    @export_proxy_materials.setter
    def export_proxy_materials(self, value: bool) -> None:
        ...
    @property
    def use_importer_material_mapping(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, materials imported with the Interchange-glTF importer will be directly mapped for the Exporter. bExport material options below will be ignored.
        """
        ...
    @use_importer_material_mapping.setter
    def use_importer_material_mapping(self, value: bool) -> None:
        ...
    @property
    def export_unlit_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, materials with shading model unlit will be properly exported. Uses extension KHR_materials_unlit.
        """
        ...
    @export_unlit_materials.setter
    def export_unlit_materials(self, value: bool) -> None:
        ...
    @property
    def export_clear_coat_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, materials with shading model clear coat will be properly exported. Uses extension KHR_materials_clearcoat.
        """
        ...
    @export_clear_coat_materials.setter
    def export_clear_coat_materials(self, value: bool) -> None:
        ...
    @property
    def export_cloth_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, materials with shading model cloth will be properly exported. Uses extension KHR_materials_sheen.
        """
        ...
    @export_cloth_materials.setter
    def export_cloth_materials(self, value: bool) -> None:
        ...
    @property
    def export_thin_translucent_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, materials with shading model thin translucency will be exported. Export is only partial. Uses extension KHR_materials_transmission.
        """
        ...
    @export_thin_translucent_materials.setter
    def export_thin_translucent_materials(self, value: bool) -> None:
        ...
    @property
    def export_specular_glossiness_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, materials using the Importer's SpecularGlossiness material function will be exported. Uses extension KHR_materials_pbrSpecularGlossiness.
        """
        ...
    @export_specular_glossiness_materials.setter
    def export_specular_glossiness_materials(self, value: bool) -> None:
        ...
    @property
    def export_emissive_strength(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, allows materials to have an emissive factor that exceeds the standard range [0.0, 1.0]. Uses extension KHR_materials_emissive_strength.
        """
        ...
    @export_emissive_strength.setter
    def export_emissive_strength(self, value: bool) -> None:
        ...
    @property
    def bake_material_inputs(self) -> GLTFMaterialBakeMode:
        r"""
        (GLTFMaterialBakeMode):  [Read-Write] Bake mode determining if and how a material input is baked out to a texture. Baking is only used for non-trivial material inputs (i.e. not simple texture or constant expressions).
        """
        ...
    @bake_material_inputs.setter
    def bake_material_inputs(self, value: GLTFMaterialBakeMode) -> None:
        ...
    @property
    def default_material_bake_size(self) -> GLTFMaterialBakeSize:
        r"""
        (GLTFMaterialBakeSize):  [Read-Write] Default size of the baked out texture (containing the material input). Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
        """
        ...
    @default_material_bake_size.setter
    def default_material_bake_size(self, value: GLTFMaterialBakeSize) -> None:
        ...
    @property
    def default_material_bake_filter(self) -> TextureFilter:
        r"""
        (TextureFilter):  [Read-Write] Default filtering mode used when sampling the baked out texture. Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
        """
        ...
    @default_material_bake_filter.setter
    def default_material_bake_filter(self, value: TextureFilter) -> None:
        ...
    @property
    def default_material_bake_tiling(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] Default addressing mode used when sampling the baked out texture. Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
        """
        ...
    @default_material_bake_tiling.setter
    def default_material_bake_tiling(self, value: TextureAddress) -> None:
        ...
    @property
    def default_input_bake_settings(self) -> Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]:
        r"""
        (Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]):  [Read-Write] Input-specific default bake settings that override the general defaults above.
        """
        ...
    @default_input_bake_settings.setter
    def default_input_bake_settings(self, value: Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]) -> None:
        ...
    @property
    def default_level_of_detail(self) -> int:
        r"""
        (int32):  [Read-Write] Default LOD level used for exporting a mesh. Can be overridden by component or asset settings (e.g. minimum or forced LOD level).
        """
        ...
    @default_level_of_detail.setter
    def default_level_of_detail(self, value: int) -> None:
        ...
    @property
    def export_vertex_colors(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export vertex color. Not recommended due to vertex colors always being used as a base color multiplier in glTF, regardless of material. Often producing undesirable results.
        """
        ...
    @export_vertex_colors.setter
    def export_vertex_colors(self, value: bool) -> None:
        ...
    @property
    def export_vertex_skin_weights(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export vertex bone weights and indices in skeletal meshes. Necessary for animation sequences.
        """
        ...
    @export_vertex_skin_weights.setter
    def export_vertex_skin_weights(self, value: bool) -> None:
        ...
    @property
    def make_skinned_meshes_root(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, make skeletal meshes into root nodes to strictly comply with the glTF specification. Final bone transforms remain the same and visual results are unaffected.
        """
        ...
    @make_skinned_meshes_root.setter
    def make_skinned_meshes_root(self, value: bool) -> None:
        ...
    @property
    def use_mesh_quantization(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, use quantization for vertex tangents and normals, reducing size. Requires extension KHR_mesh_quantization, which may result in the mesh not loading in some glTF viewers.
        """
        ...
    @use_mesh_quantization.setter
    def use_mesh_quantization(self, value: bool) -> None:
        ...
    @property
    def export_level_sequences(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export level sequences. Only transform tracks are currently supported. The level sequence will be played at the assigned display rate.
        """
        ...
    @export_level_sequences.setter
    def export_level_sequences(self, value: bool) -> None:
        ...
    @property
    def export_animation_sequences(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export single animation asset used by a skeletal mesh component. Export of vertex skin weights must be enabled.
        """
        ...
    @export_animation_sequences.setter
    def export_animation_sequences(self, value: bool) -> None:
        ...
    @property
    def texture_image_format(self) -> GLTFTextureImageFormat:
        r"""
        (GLTFTextureImageFormat):  [Read-Write] Desired image format used for exported textures.
        """
        ...
    @texture_image_format.setter
    def texture_image_format(self, value: GLTFTextureImageFormat) -> None:
        ...
    @property
    def texture_image_quality(self) -> int:
        r"""
        (int32):  [Read-Write] Level of compression used for textures exported with lossy image formats, 0 (default) or value between 1 (worst quality, best compression) and 100 (best quality, worst compression).
        """
        ...
    @texture_image_quality.setter
    def texture_image_quality(self, value: int) -> None:
        ...
    @property
    def export_texture_transforms(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export UV offset and scale/tiling used in materials. Uses extension KHR_texture_transform.
        """
        ...
    @export_texture_transforms.setter
    def export_texture_transforms(self, value: bool) -> None:
        ...
    @property
    def adjust_normalmaps(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, exported normalmaps will be adjusted from Unreal to glTF convention (i.e. the green channel is flipped).
        """
        ...
    @adjust_normalmaps.setter
    def adjust_normalmaps(self, value: bool) -> None:
        ...
    @property
    def export_hidden_in_game(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export actors and components that are flagged as hidden in-game.
        """
        ...
    @export_hidden_in_game.setter
    def export_hidden_in_game(self, value: bool) -> None:
        ...
    @property
    def export_lights(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export directional, point, and spot light components. Uses extension KHR_lights_punctual.
        """
        ...
    @export_lights.setter
    def export_lights(self, value: bool) -> None:
        ...
    @property
    def export_cameras(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, export camera components.
        """
        ...
    @export_cameras.setter
    def export_cameras(self, value: bool) -> None:
        ...
    @property
    def export_material_variants(self) -> GLTFMaterialVariantMode:
        r"""
        (GLTFMaterialVariantMode):  [Read-Write] Mode determining if and how to export material variants that change the materials property on a static or skeletal mesh component.
        """
        ...
    @export_material_variants.setter
    def export_material_variants(self, value: GLTFMaterialVariantMode) -> None:
        ...
    def reset_to_default(self) -> None:
        r"""
        x.reset_to_default() -> None
        Reset to Default
        """
        ...

class GLTFExporter(Exporter):
    r"""
    GLTFExporter
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFExporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    @classmethod
    def export_to_gltf(cls, object: Object, file_path: str, options: GLTFExportOptions, selected_actors: Set[Actor]) -> Optional[GLTFExportMessages]:
        r"""
        X.export_to_gltf(object, file_path, options, selected_actors) -> GLTFExportMessages or None
        Export the specified object to a glTF file (.gltf or .glb)
        
        Args:
            object (Object): The object to export (supported types are UMaterialInterface, UStaticMesh, USkeletalMesh, UWorld, UAnimSequence, ULevelSequence, ULevelVariantSets). Will default to the currently active world if null.
            file_path (str): The filename on disk to save as. Associated textures and binary files will be saved in the same folder, unless file extension is .glb - which results in a self-contained binary file.
            options (GLTFExportOptions): The various options to use during export. Will default to the project's user-specific editor settings if null.
            selected_actors (Set[Actor]): The set of actors to export, only applicable if the object to export is a UWorld. An empty set results in the export of all actors.
        
        Returns:
            GLTFExportMessages or None: true if the object was successfully exported
        
            out_messages (GLTFExportMessages): The resulting log messages from the export.
        """
        ...

class GLTFAnimSequenceExporter(GLTFExporter):
    r"""
    GLTFAnim Sequence Exporter
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFAnimSequenceExporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class GLTFLevelExporter(GLTFExporter):
    r"""
    GLTFLevel Exporter
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFLevelExporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class GLTFLevelSequenceExporter(GLTFExporter):
    r"""
    GLTFLevel Sequence Exporter
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFLevelSequenceExporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class GLTFLevelVariantSetsExporter(GLTFExporter):
    r"""
    GLTFLevel Variant Sets Exporter
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFLevelVariantSetsExporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class GLTFMaterialExporter(GLTFExporter):
    r"""
    GLTFMaterial Exporter
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFMaterialExporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class GLTFSkeletalMeshExporter(GLTFExporter):
    r"""
    GLTFSkeletal Mesh Exporter
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFSkeletalMeshExporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class GLTFStaticMeshExporter(GLTFExporter):
    r"""
    GLTFStatic Mesh Exporter
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFStaticMeshExporter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``export_task`` (AssetExportTask):  [Read-Write]
    - ``format_description`` (Array[str]):  [Read-Write] Descriptiong of the export format
    - ``format_extension`` (Array[str]):  [Read-Write] File extension to use for this exporter
    - ``supported_class`` (type(Class)):  [Read-Write] Supported class of this exporter
    - ``text`` (bool):  [Read-Write] If true, this will export the data as text
    """
    ...

class GLTFProxyOptions(Object):
    r"""
    GLTFProxy Options
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFProxyOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bake_material_inputs`` (bool):  [Read-Write] If enabled, a material input may be baked out to a texture (using a simple quad). Baking is only used for non-trivial material inputs (i.e. not simple texture or constant expressions).
    - ``default_input_bake_settings`` (Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]):  [Read-Write] Input-specific default bake settings that override the general defaults above.
    - ``default_material_bake_filter`` (TextureFilter):  [Read-Write] Default filtering mode used when sampling the baked out texture. Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
    - ``default_material_bake_size`` (GLTFMaterialBakeSize):  [Read-Write] Default size of the baked out texture (containing the material input). Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
    - ``default_material_bake_tiling`` (TextureAddress):  [Read-Write] Default addressing mode used when sampling the baked out texture. Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
    - ``use_thin_translucent_shading_model`` (bool):  [Read-Write] If enabled, materials with shading model thin translucency will be used. Conversion is only partial.
    """
    @property
    def bake_material_inputs(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, a material input may be baked out to a texture (using a simple quad). Baking is only used for non-trivial material inputs (i.e. not simple texture or constant expressions).
        """
        ...
    @bake_material_inputs.setter
    def bake_material_inputs(self, value: bool) -> None:
        ...
    @property
    def use_thin_translucent_shading_model(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, materials with shading model thin translucency will be used. Conversion is only partial.
        """
        ...
    @use_thin_translucent_shading_model.setter
    def use_thin_translucent_shading_model(self, value: bool) -> None:
        ...
    @property
    def default_material_bake_size(self) -> GLTFMaterialBakeSize:
        r"""
        (GLTFMaterialBakeSize):  [Read-Write] Default size of the baked out texture (containing the material input). Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
        """
        ...
    @default_material_bake_size.setter
    def default_material_bake_size(self, value: GLTFMaterialBakeSize) -> None:
        ...
    @property
    def default_material_bake_filter(self) -> TextureFilter:
        r"""
        (TextureFilter):  [Read-Write] Default filtering mode used when sampling the baked out texture. Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
        """
        ...
    @default_material_bake_filter.setter
    def default_material_bake_filter(self, value: TextureFilter) -> None:
        ...
    @property
    def default_material_bake_tiling(self) -> TextureAddress:
        r"""
        (TextureAddress):  [Read-Write] Default addressing mode used when sampling the baked out texture. Can be overridden by material- and input-specific bake settings, see GLTFMaterialExportOptions.
        """
        ...
    @default_material_bake_tiling.setter
    def default_material_bake_tiling(self, value: TextureAddress) -> None:
        ...
    @property
    def default_input_bake_settings(self) -> Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]:
        r"""
        (Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]):  [Read-Write] Input-specific default bake settings that override the general defaults above.
        """
        ...
    @default_input_bake_settings.setter
    def default_input_bake_settings(self, value: Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]) -> None:
        ...
    def reset_to_default(self) -> None:
        r"""
        x.reset_to_default() -> None
        Reset to Default
        """
        ...

class GLTFMaterialExportOptions(AssetUserData):
    r"""
    glTF-specific user data that can be added to material assets to override export options
    
    **C++ Source:**
    
    - **Plugin**: GLTFExporter
    - **Module**: GLTFExporter
    - **File**: GLTFMaterialUserData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default`` (GLTFOverrideMaterialBakeSettings):  [Read-Write] Default bake settings for this material in general.
    - ``inputs`` (Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]):  [Read-Write] Input-specific bake settings that override the defaults above.
    - ``proxy`` (MaterialInterface):  [Read-Write] If assigned, export will use the proxy instead of the original material.
    """
    @property
    def proxy(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Write] If assigned, export will use the proxy instead of the original material.
        """
        ...
    @proxy.setter
    def proxy(self, value: MaterialInterface) -> None:
        ...
    @property
    def default(self) -> GLTFOverrideMaterialBakeSettings:
        r"""
        (GLTFOverrideMaterialBakeSettings):  [Read-Write] Default bake settings for this material in general.
        """
        ...
    @default.setter
    def default(self, value: GLTFOverrideMaterialBakeSettings) -> None:
        ...
    @property
    def inputs(self) -> Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]:
        r"""
        (Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]):  [Read-Write] Input-specific bake settings that override the defaults above.
        """
        ...
    @inputs.setter
    def inputs(self, value: Map[GLTFMaterialPropertyGroup, GLTFOverrideMaterialBakeSettings]) -> None:
        ...

class DatasmithAreaLightActor(Actor):
    r"""
    Datasmith Area Light Actor
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAreaLightActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``attenuation_radius`` (float):  [Read-Write]
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``color`` (LinearColor):  [Read-Write]
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``dimensions`` (Vector2D):  [Read-Write]
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ies_brightness_scale`` (float):  [Read-Write]
    - ``ies_texture`` (TextureLightProfile):  [Read-Write]
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``intensity`` (float):  [Read-Write]
    - ``intensity_units`` (LightUnits):  [Read-Write]
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``light_shape`` (DatasmithAreaLightActorShape):  [Read-Write]
    - ``light_type`` (DatasmithAreaLightActorType):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``mobility`` (ComponentMobility):  [Read-Write]
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``rotation`` (Rotator):  [Read-Write]
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``source_length`` (float):  [Read-Write]
    - ``source_radius`` (float):  [Read-Write]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``spotlight_inner_angle`` (float):  [Read-Write]
    - ``spotlight_outer_angle`` (float):  [Read-Write]
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``temperature`` (float):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_ies_brightness`` (bool):  [Read-Write]
    """
    @property
    def mobility(self) -> ComponentMobility:
        r"""
        (ComponentMobility):  [Read-Only]
        """
        ...
    @property
    def light_type(self) -> DatasmithAreaLightActorType:
        r"""
        (DatasmithAreaLightActorType):  [Read-Write]
        """
        ...
    @light_type.setter
    def light_type(self, value: DatasmithAreaLightActorType) -> None:
        ...
    @property
    def light_shape(self) -> DatasmithAreaLightActorShape:
        r"""
        (DatasmithAreaLightActorShape):  [Read-Write]
        """
        ...
    @light_shape.setter
    def light_shape(self, value: DatasmithAreaLightActorShape) -> None:
        ...
    @property
    def dimensions(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write]
        """
        ...
    @dimensions.setter
    def dimensions(self, value: Vector2D) -> None:
        ...
    @property
    def intensity(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @intensity.setter
    def intensity(self, value: float) -> None:
        ...
    @property
    def intensity_units(self) -> LightUnits:
        r"""
        (LightUnits):  [Read-Write]
        """
        ...
    @intensity_units.setter
    def intensity_units(self, value: LightUnits) -> None:
        ...
    @property
    def color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write]
        """
        ...
    @color.setter
    def color(self, value: LinearColor) -> None:
        ...
    @property
    def temperature(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @temperature.setter
    def temperature(self, value: float) -> None:
        ...
    @property
    def ies_texture(self) -> TextureLightProfile:
        r"""
        (TextureLightProfile):  [Read-Write]
        """
        ...
    @ies_texture.setter
    def ies_texture(self, value: TextureLightProfile) -> None:
        ...
    @property
    def use_ies_brightness(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @use_ies_brightness.setter
    def use_ies_brightness(self, value: bool) -> None:
        ...
    @property
    def ies_brightness_scale(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @ies_brightness_scale.setter
    def ies_brightness_scale(self, value: float) -> None:
        ...
    @property
    def rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write]
        """
        ...
    @rotation.setter
    def rotation(self, value: Rotator) -> None:
        ...
    @property
    def source_radius(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @source_radius.setter
    def source_radius(self, value: float) -> None:
        ...
    @property
    def source_length(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @source_length.setter
    def source_length(self, value: float) -> None:
        ...
    @property
    def attenuation_radius(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @attenuation_radius.setter
    def attenuation_radius(self, value: float) -> None:
        ...
    @property
    def spotlight_inner_angle(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @spotlight_inner_angle.setter
    def spotlight_inner_angle(self, value: float) -> None:
        ...
    @property
    def spotlight_outer_angle(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @spotlight_outer_angle.setter
    def spotlight_outer_angle(self, value: float) -> None:
        ...

class DatasmithAssetImportData(AssetImportData):
    r"""
    Datasmith Asset Import Data
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_data`` (Array[DatasmithAdditionalData]):  [Read-Write]
    - ``asset_import_options`` (DatasmithAssetImportOptions):  [Read-Write]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    @property
    def asset_import_options(self) -> DatasmithAssetImportOptions:
        r"""
        (DatasmithAssetImportOptions):  [Read-Write]
        """
        ...
    @asset_import_options.setter
    def asset_import_options(self, value: DatasmithAssetImportOptions) -> None:
        ...

class DatasmithStaticMeshImportData(DatasmithAssetImportData):
    r"""
    Datasmith Static Mesh Import Data
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_data`` (Array[DatasmithAdditionalData]):  [Read-Write]
    - ``asset_import_options`` (DatasmithAssetImportOptions):  [Read-Write]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``import_options`` (DatasmithStaticMeshImportOptions):  [Read-Write]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    ...

class DatasmithStaticMeshCADImportData(DatasmithStaticMeshImportData):
    r"""
    Datasmith Static Mesh CADImport Data
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_data`` (Array[DatasmithAdditionalData]):  [Read-Write]
    - ``asset_import_options`` (DatasmithAssetImportOptions):  [Read-Write]
    - ``auxiliary_filenames`` (Array[str]):  [Read-Only]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``import_options`` (DatasmithStaticMeshImportOptions):  [Read-Write]
    - ``model_tolerance`` (double):  [Read-Only]
    - ``model_unit`` (double):  [Read-Only]
    - ``resource_filename`` (str):  [Read-Only]
    - ``resource_path`` (str):  [Read-Only]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``tessellation_options`` (DatasmithTessellationOptions):  [Read-Write]
    """
    ...

class DatasmithSceneImportData(AssetImportData):
    r"""
    Base class for import data and options used when importing any asset from Datasmith
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_options`` (DatasmithImportBaseOptions):  [Read-Write]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    ...

class DatasmithTranslatedSceneImportData(DatasmithSceneImportData):
    r"""
    Import data and options specific to Datasmith scenes imported through the translator system
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_options`` (Array[DatasmithOptionsBase]):  [Read-Write]
    - ``base_options`` (DatasmithImportBaseOptions):  [Read-Write]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    ...

class DatasmithCADImportSceneData(DatasmithSceneImportData):
    r"""
    Import data and options specific to tessellated Datasmith scenes
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_options`` (DatasmithImportBaseOptions):  [Read-Write]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``tessellation_options`` (DatasmithTessellationOptions):  [Read-Write]
    """
    ...

class DatasmithMDLSceneImportData(DatasmithSceneImportData):
    r"""
    Datasmith MDLScene Import Data
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_options`` (DatasmithImportBaseOptions):  [Read-Write]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    ...

class DatasmithGLTFSceneImportData(DatasmithSceneImportData):
    r"""
    Datasmith GLTFScene Import Data
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``author`` (str):  [Read-Only]
    - ``base_options`` (DatasmithImportBaseOptions):  [Read-Write]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``generator`` (str):  [Read-Only]
    - ``license`` (str):  [Read-Only]
    - ``source`` (str):  [Read-Only]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``version`` (float):  [Read-Only]
    """
    ...

class DatasmithStaticMeshGLTFImportData(DatasmithStaticMeshImportData):
    r"""
    Datasmith Static Mesh GLTFImport Data
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_data`` (Array[DatasmithAdditionalData]):  [Read-Write]
    - ``asset_import_options`` (DatasmithAssetImportOptions):  [Read-Write]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``import_options`` (DatasmithStaticMeshImportOptions):  [Read-Write]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``source_mesh_name`` (str):  [Read-Only]
    """
    ...

class DatasmithFBXSceneImportData(DatasmithSceneImportData):
    r"""
    Datasmith FBXScene Import Data
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_options`` (DatasmithImportBaseOptions):  [Read-Write]
    - ``colorize_materials`` (bool):  [Read-Only]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``generate_lightmap_u_vs`` (bool):  [Read-Only]
    - ``intermediate_serialization`` (uint8):  [Read-Only] Corresponds to a EDatasmithFBXIntermediateSerializationType
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``textures_dir`` (str):  [Read-Only]
    """
    ...

class DatasmithDeltaGenAssetImportData(DatasmithAssetImportData):
    r"""
    Datasmith Delta Gen Asset Import Data
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_data`` (Array[DatasmithAdditionalData]):  [Read-Write]
    - ``asset_import_options`` (DatasmithAssetImportOptions):  [Read-Write]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    ...

class DatasmithDeltaGenSceneImportData(DatasmithFBXSceneImportData):
    r"""
    Datasmith Delta Gen Scene Import Data
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_options`` (DatasmithImportBaseOptions):  [Read-Write]
    - ``colorize_materials`` (bool):  [Read-Only]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``generate_lightmap_u_vs`` (bool):  [Read-Only]
    - ``import_pos`` (bool):  [Read-Only]
    - ``import_tml`` (bool):  [Read-Only]
    - ``import_var`` (bool):  [Read-Only]
    - ``intermediate_serialization`` (uint8):  [Read-Only] Corresponds to a EDatasmithFBXIntermediateSerializationType
    - ``merge_nodes`` (bool):  [Read-Only]
    - ``optimize_duplicated_nodes`` (bool):  [Read-Only]
    - ``pos_path`` (str):  [Read-Only]
    - ``remove_invisible_nodes`` (bool):  [Read-Only]
    - ``simplify_node_hierarchy`` (bool):  [Read-Only]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``textures_dir`` (str):  [Read-Only]
    - ``tml_path`` (str):  [Read-Only]
    - ``var_path`` (str):  [Read-Only]
    """
    ...

class DatasmithVREDAssetImportData(DatasmithAssetImportData):
    r"""
    Datasmith VREDAsset Import Data
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_data`` (Array[DatasmithAdditionalData]):  [Read-Write]
    - ``asset_import_options`` (DatasmithAssetImportOptions):  [Read-Write]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    ...

class DatasmithVREDSceneImportData(DatasmithFBXSceneImportData):
    r"""
    Datasmith VREDScene Import Data
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_options`` (DatasmithImportBaseOptions):  [Read-Write]
    - ``clean_var`` (bool):  [Read-Only]
    - ``clip_info_path`` (str):  [Read-Only]
    - ``colorize_materials`` (bool):  [Read-Only]
    - ``datasmith_import_info`` (DatasmithImportInfo):  [Read-Write]
    - ``generate_lightmap_u_vs`` (bool):  [Read-Only]
    - ``import_clip_info`` (bool):  [Read-Only]
    - ``import_light_info`` (bool):  [Read-Only]
    - ``import_mats`` (bool):  [Read-Only]
    - ``import_var`` (bool):  [Read-Only]
    - ``intermediate_serialization`` (uint8):  [Read-Only] Corresponds to a EDatasmithFBXIntermediateSerializationType
    - ``light_info_path`` (str):  [Read-Only]
    - ``mats_path`` (str):  [Read-Only]
    - ``merge_nodes`` (bool):  [Read-Only]
    - ``optimize_duplicated_nodes`` (bool):  [Read-Only]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``textures_dir`` (str):  [Read-Only]
    - ``var_path`` (str):  [Read-Only]
    """
    ...

class DatasmithUserData(AssetUserData):
    r"""
    Asset user data that can be used with Datasmith on Actors and other objects
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAssetUserData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``metadata`` (Map[Name, str]):  [Read-Only]
    """
    @property
    def metadata(self) -> Map[Name, str]:
        r"""
        (Map[Name, str]):  [Read-Only]
        """
        ...

class DatasmithContentLibrary(BlueprintFunctionLibrary):
    r"""
    Datasmith Content Blueprint Library
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithContentBlueprintLibrary.h
    
    """
    @classmethod
    def get_datasmith_user_data_values_for_key(cls, object: Object, key: Name, partial_match_key: bool = False) -> Array[str]:
        r"""
        X.get_datasmith_user_data_values_for_key(object, key, partial_match_key=False) -> Array[str]
        Get the values of the given key for the Datasmith User Data of the given object.
        
        Args:
            object (Object): The Object from which to retrieve the Datasmith User Data.
            key (Name): The key to find in the Datasmith User Data.
            partial_match_key (bool): If true, check for contains, rather than exact match.
        
        Returns:
            Array[str]: The string value associated with the given key
        """
        ...
    @classmethod
    def get_datasmith_user_data_value_for_key(cls, object: Object, key: Name, partial_match_key: bool = False) -> str:
        r"""
        X.get_datasmith_user_data_value_for_key(object, key, partial_match_key=False) -> str
        Get the value of the given key for the Datasmith User Data of the given object.
        
        Args:
            object (Object): The Object from which to retrieve the Datasmith User Data.
            key (Name): The key to find in the Datasmith User Data.
            partial_match_key (bool): 
        
        Returns:
            str: The string value associated with the given key
        """
        ...
    @classmethod
    def get_datasmith_user_data_keys_and_values_for_value(cls, object: Object, string_to_match: str) -> Tuple[Array[Name], Array[str]]:
        r"""
        X.get_datasmith_user_data_keys_and_values_for_value(object, string_to_match) -> (out_keys=Array[Name], out_values=Array[str])
        Get the keys and values for which the associated value contains the string to match for the Datasmith User Data of the given object.
        
        Args:
            object (Object): The Object from which to retrieve the Datasmith User Data.
            string_to_match (str): The string to match in the values.
        
        Returns:
            tuple: 
        
            out_keys (Array[Name]): Output array of keys for which the associated values contain the string to match.
        
            out_values (Array[str]): Output array of values associated to the keys.
        """
        ...
    @classmethod
    def get_datasmith_user_data(cls, object: Object) -> DatasmithUserData:
        r"""
        X.get_datasmith_user_data(object) -> DatasmithUserData
        Get the Datasmith User Data of a given object
        
        Args:
            object (Object): The Object from which to retrieve the Datasmith User Data.
        
        Returns:
            DatasmithUserData: The Datasmith User Data if it exists; nullptr, otherwise
        """
        ...
    @classmethod
    def get_all_objects_and_values_for_key(cls, key: Name, object_class: Class) -> Tuple[Array[Object], Array[str]]:
        r"""
        X.get_all_objects_and_values_for_key(key, object_class) -> (out_objects=Array[Object], out_values=Array[str])
        Find all loaded objects of the given type that have a Datasmith User Data that contains the given key and their associated values.
        This is a slow operation, so editor only.
        
        Args:
            key (Name): The key to find in the Datasmith User Data.
            object_class (type(Class)): Class of the object on which to filter, if specificed; otherwise there's no filtering
        
        Returns:
            tuple: 
        
            out_objects (Array[Object]): Output array of objects for which the Datasmith User Data match the given key.
        
            out_values (Array[str]): Output array of values associated with each object in OutObjects.
        """
        ...
    @classmethod
    def get_all_datasmith_user_data(cls, object_class: Class) -> Array[DatasmithUserData]:
        r"""
        X.get_all_datasmith_user_data(object_class) -> Array[DatasmithUserData]
        Find all Datasmith User Data of loaded objects of the given type.
        This is a slow operation, so editor only.
        
        Args:
            object_class (type(Class)): Class of the object on which to filter, if specificed; otherwise there's no filtering
        
        Returns:
            Array[DatasmithUserData]: 
        
            out_user_data (Array[DatasmithUserData]): Output array of Datasmith User Data.
        """
        ...

class DatasmithImportedSequencesActor(Actor):
    r"""
    Datasmith Imported Sequences Actor
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportedSequencesActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``imported_sequences`` (Array[LevelSequence]):  [Read-Write]
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def imported_sequences(self) -> Array[LevelSequence]:
        r"""
        (Array[LevelSequence]):  [Read-Write]
        """
        ...
    @imported_sequences.setter
    def imported_sequences(self, value: Array[LevelSequence]) -> None:
        ...
    def play_level_sequence(self, sequence_to_play: LevelSequence) -> None:
        r"""
        x.play_level_sequence(sequence_to_play) -> None
        Play Level Sequence
        
        Args:
            sequence_to_play (LevelSequence):
        """
        ...

class DatasmithOptionsBase(Object):
    r"""
    Base class for all import options in datasmith.
    
    Notable feature: forces a full serialization of its properties (by opposition
    to the standard delta serialization which stores only the diff wrt the CDO)
    The intent is to store the exact options used in a previous import.
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    """
    ...

class DatasmithCommonTessellationOptions(DatasmithOptionsBase):
    r"""
    Datasmith Common Tessellation Options
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``options`` (DatasmithTessellationOptions):  [Read-Write]
    """
    @property
    def options(self) -> DatasmithTessellationOptions:
        r"""
        (DatasmithTessellationOptions):  [Read-Write]
        """
        ...
    @options.setter
    def options(self, value: DatasmithTessellationOptions) -> None:
        ...

class DatasmithImportOptions(DatasmithOptionsBase):
    r"""
    Datasmith Import Options
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithImportOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_options`` (DatasmithImportBaseOptions):  [Read-Write] Not displayed. Kept for future use
    - ``file_name`` (str):  [Read-Write] Name of the imported file without its path
    - ``file_path`` (str):  [Read-Write] Full path of the imported file
    - ``reimport_options`` (DatasmithReimportOptions):  [Read-Write] Options specific to the reimport process
    - ``source_uri`` (str):  [Read-Write]
    """
    @property
    def base_options(self) -> DatasmithImportBaseOptions:
        r"""
        (DatasmithImportBaseOptions):  [Read-Write] Not displayed. Kept for future use
        """
        ...
    @base_options.setter
    def base_options(self, value: DatasmithImportBaseOptions) -> None:
        ...
    @property
    def reimport_options(self) -> DatasmithReimportOptions:
        r"""
        (DatasmithReimportOptions):  [Read-Write] Options specific to the reimport process
        """
        ...
    @reimport_options.setter
    def reimport_options(self, value: DatasmithReimportOptions) -> None:
        ...
    @property
    def file_name(self) -> str:
        r"""
        (str):  [Read-Write] Name of the imported file without its path
        """
        ...
    @file_name.setter
    def file_name(self, value: str) -> None:
        ...
    @property
    def file_path(self) -> str:
        r"""
        (str):  [Read-Write] Full path of the imported file
        """
        ...
    @file_path.setter
    def file_path(self, value: str) -> None:
        ...
    @property
    def source_uri(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @source_uri.setter
    def source_uri(self, value: str) -> None:
        ...

class DatasmithSceneActor(Actor):
    r"""
    Datasmith Scene Actor
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithSceneActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``related_actors`` (Map[Name, Actor]):  [Read-Only] Map of all the actors related to this Datasmith Scene
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``scene`` (DatasmithScene):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class AnimationCompressionLibraryDatabase(Object):
    r"""
    An ACL database object references several UAnimSequence instances that it contains.
    
    **C++ Source:**
    
    - **Plugin**: ACLPlugin
    - **Module**: ACLPlugin
    - **File**: AnimationCompressionLibraryDatabase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_sequences`` (Array[AnimSequence]):  [Read-Only] The anim sequences contained within the database. Built manually from the asset UI, content browser, or with a commandlet.
    - ``highest_importance_proportion`` (float):  [Read-Only] What percentage of the key frames should remain in the anim sequences.
    - ``lowest_importance_proportion`` (float):  [Read-Write] What percentage of the key frames should be moved to the database. Least important key frames are moved first.
    - ``max_stream_request_size_kb`` (uint32):  [Read-Write] The maximum size in KiloBytes of streaming requests. Setting this to 0 will force tiers to load in a single request regardless of their size.
    - ``medium_importance_proportion`` (float):  [Read-Write] What percentage of the key frames should be moved to the database. Medium importance key frames are moved second.
    - ``preview_visual_fidelity`` (ACLVisualFidelity):  [Read-Write] The level of quality to preview with the database when decompressing in the editor.
    - ``strip_lowest_importance_tier`` (PerPlatformBool):  [Read-Write] Whether or not to strip the lowest importance tier entirely from disk. Stripping the lowest tier means that the visual fidelity of Highest and Medium are equivalent.
    """
    @classmethod
    def set_visual_fidelity(cls, world_context_object: Object, latent_info: LatentActionInfo, database_asset: AnimationCompressionLibraryDatabase, visual_fidelity: ACLVisualFidelity = ACLVisualFidelity.HIGHEST) -> ACLVisualFidelityChangeResult:
        r"""
        X.set_visual_fidelity(world_context_object, latent_info, database_asset, visual_fidelity=ACLVisualFidelity.HIGHEST) -> ACLVisualFidelityChangeResult
        Initiate a latent database change in quality by streaming in/out as necessary.
        
        Args:
            world_context_object (Object): 
            latent_info (LatentActionInfo): 
            database_asset (AnimationCompressionLibraryDatabase): 
            visual_fidelity (ACLVisualFidelity): 
        
        Returns:
            ACLVisualFidelityChangeResult: 
        
            result (ACLVisualFidelityChangeResult):
        """
        ...
    @classmethod
    def get_visual_fidelity(cls, database_asset: AnimationCompressionLibraryDatabase) -> ACLVisualFidelity:
        r"""
        X.get_visual_fidelity(database_asset) -> ACLVisualFidelity
        Get Visual Fidelity
        
        Args:
            database_asset (AnimationCompressionLibraryDatabase): 
        
        Returns:
            ACLVisualFidelity:
        """
        ...

class AnimationEditorPreviewActor(Actor):
    r"""
    Animation Editor Preview Actor
    
    **C++ Source:**
    
    - **Module**: Persona
    - **File**: AnimationEditorPreviewActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class AnimationSequenceBrowserContextMenuContext(Object):
    r"""
    Animation Sequence Browser Context Menu Context
    
    **C++ Source:**
    
    - **Module**: Persona
    - **File**: AnimationSequenceBrowserMenuContexts.h
    
    """
    def get_selected_objects(self) -> Array[Object]:
        r"""
        x.get_selected_objects() -> Array[Object]
        Get Selected Objects
        
        Returns:
            Array[Object]:
        """
        ...

class PersonaPreviewSceneDescription(Object):
    r"""
    Persona Preview Scene Description
    
    **C++ Source:**
    
    - **Module**: Persona
    - **File**: PersonaPreviewSceneDescription.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_meshes`` (DataAsset):  [Read-Write]
    - ``application_method`` (PreviewAnimationBlueprintApplicationMethod):  [Read-Write] The method by which a preview animation blueprint is applied, either as an overlay layer, or as a linked instance
    - ``linked_anim_graph_tag`` (Name):  [Read-Write] The tag to use when applying a preview animation blueprint via LinkAnimGraphByTag
    - ``preview_animation_blueprint`` (AnimBlueprint):  [Read-Write] The preview anim blueprint to use
    - ``preview_controller`` (type(Class)):  [Read-Write] The method by which the preview is animated
    - ``preview_mesh`` (SkeletalMesh):  [Read-Write] The preview mesh to use
    """
    @property
    def preview_controller(self) -> Class:
        r"""
        (type(Class)):  [Read-Only] The method by which the preview is animated
        """
        ...

class PersonaToolMenuContext(Object):
    r"""
    Persona Tool Menu Context
    
    **C++ Source:**
    
    - **Module**: Persona
    - **File**: PersonaToolMenuContext.h
    
    """
    def get_skeleton(self) -> Skeleton:
        r"""
        x.get_skeleton() -> Skeleton
        Get the skeleton that we are editing
        
        Returns:
            Skeleton:
        """
        ...
    def get_preview_mesh_component(self) -> DebugSkelMeshComponent:
        r"""
        x.get_preview_mesh_component() -> DebugSkelMeshComponent
        Get the preview component that we are using
        
        Returns:
            DebugSkelMeshComponent:
        """
        ...
    def get_mesh(self) -> SkeletalMesh:
        r"""
        x.get_mesh() -> SkeletalMesh
        Get the skeletal mesh that we are editing
        
        Returns:
            SkeletalMesh:
        """
        ...
    def get_anim_blueprint(self) -> AnimBlueprint:
        r"""
        x.get_anim_blueprint() -> AnimBlueprint
        Get the anim blueprint that we are editing
        
        Returns:
            AnimBlueprint:
        """
        ...
    def get_animation_asset(self) -> AnimationAsset:
        r"""
        x.get_animation_asset() -> AnimationAsset
        Get the animation asset that we are editing
        
        Returns:
            AnimationAsset:
        """
        ...

class MockDataMeshTrackerComponent(SceneComponent):
    r"""
    The MeshTrackerComponent class manages requests for environmental mesh data, processes the results and provides
    them to the calling system. The calling system is able request environmental mesh data within a specified area.
    Various other search criteria can be set via this class's public properties.  Mesh data requests are processed
    on a separate thread.  Once a mesh data request has been processed the calling system will be notified via an
    FOnMeshTrackerUpdated broadcast.
    
    **C++ Source:**
    
    - **Module**: MRMesh
    - **File**: MockDataMeshTrackerComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``block_vertex_colors`` (Array[Color]):  [Read-Write] Colors through which we cycle when setting vertex color by block.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_mesh_tracker_updated`` (OnMockDataMeshTrackerUpdated):  [Read-Write] Activated whenever new information about this mesh tracker is detected.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``request_normals`` (bool):  [Read-Write] If true, the system will generate normals for the triangle vertices.
    - ``request_vertex_confidence`` (bool):  [Read-Write] If true, the system will generate the mesh confidence values for the triangle vertices.
      These confidence values can be used to determine if the user needs to scan more.
    - ``scan_world`` (bool):  [Read-Write] Set to true to start scanning the world for meshes.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``update_interval`` (float):  [Read-Write] Update Interval in Seconds.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``vertex_color_from_confidence_one`` (LinearColor):  [Read-Write] Color mapped to confidence value of one.
    - ``vertex_color_from_confidence_zero`` (LinearColor):  [Read-Write] Color mapped to confidence value of zero.
    - ``vertex_color_mode`` (MeshTrackerVertexColorMode):  [Read-Write] Vertex Colors can be unused, or filled with several types of information.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def on_mesh_tracker_updated(self) -> OnMockDataMeshTrackerUpdated:
        r"""
        (OnMockDataMeshTrackerUpdated):  [Read-Write] Activated whenever new information about this mesh tracker is detected.
        """
        ...
    @on_mesh_tracker_updated.setter
    def on_mesh_tracker_updated(self, value: OnMockDataMeshTrackerUpdated) -> None:
        ...
    @property
    def scan_world(self) -> bool:
        r"""
        (bool):  [Read-Write] Set to true to start scanning the world for meshes.
        """
        ...
    @scan_world.setter
    def scan_world(self, value: bool) -> None:
        ...
    @property
    def request_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the system will generate normals for the triangle vertices.
        """
        ...
    @request_normals.setter
    def request_normals(self, value: bool) -> None:
        ...
    @property
    def request_vertex_confidence(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, the system will generate the mesh confidence values for the triangle vertices.
        These confidence values can be used to determine if the user needs to scan more.
        """
        ...
    @request_vertex_confidence.setter
    def request_vertex_confidence(self, value: bool) -> None:
        ...
    @property
    def vertex_color_mode(self) -> MeshTrackerVertexColorMode:
        r"""
        (MeshTrackerVertexColorMode):  [Read-Write] Vertex Colors can be unused, or filled with several types of information.
        """
        ...
    @vertex_color_mode.setter
    def vertex_color_mode(self, value: MeshTrackerVertexColorMode) -> None:
        ...
    @property
    def block_vertex_colors(self) -> Array[Color]:
        r"""
        (Array[Color]):  [Read-Write] Colors through which we cycle when setting vertex color by block.
        """
        ...
    @block_vertex_colors.setter
    def block_vertex_colors(self, value: Array[Color]) -> None:
        ...
    @property
    def vertex_color_from_confidence_zero(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Color mapped to confidence value of zero.
        """
        ...
    @vertex_color_from_confidence_zero.setter
    def vertex_color_from_confidence_zero(self, value: LinearColor) -> None:
        ...
    @property
    def vertex_color_from_confidence_one(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Color mapped to confidence value of one.
        """
        ...
    @vertex_color_from_confidence_one.setter
    def vertex_color_from_confidence_one(self, value: LinearColor) -> None:
        ...
    @property
    def update_interval(self) -> float:
        r"""
        (float):  [Read-Write] Update Interval in Seconds.
        """
        ...
    @update_interval.setter
    def update_interval(self, value: float) -> None:
        ...
    def disconnect_mr_mesh(self, mr_mesh_ptr: MRMeshComponent) -> None:
        r"""
        x.disconnect_mr_mesh(mr_mesh_ptr) -> None
        Unlinks the current procedural mesh component from the mesh tracking system.
        
        Args:
            mr_mesh_ptr (MRMeshComponent): The procedural mesh component to unlink from the mesh tracking system.
        """
        ...
    def connect_mr_mesh(self, mr_mesh_ptr: MRMeshComponent) -> None:
        r"""
        x.connect_mr_mesh(mr_mesh_ptr) -> None
        Sets the procedural mesh component that will store and display the environmental mesh results.
        
        Args:
            mr_mesh_ptr (MRMeshComponent): The procedural mesh component to store the query result in.
        """
        ...

class MRMeshComponent(PrimitiveComponent):
    r"""
    MRMesh Component
    
    **C++ Source:**
    
    - **Module**: MRMesh
    - **File**: MRMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``create_mesh_proxy_sections`` (bool):  [Read-Write] If true, MRMesh will create a renderable mesh proxy.  If false it will not, but could still provide collision.
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``material`` (MaterialInterface):  [Read-Write]
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_create_collision_mesh`` (bool):  [Read-Write] If true, MRMesh will not create a collidable ridgid body for each mesh section and can therefore never have collision.  Avoids the cost of generating collision.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``update_nav_mesh_on_mesh_update`` (bool):  [Read-Write] If true, MRMesh will automatically update its navmesh whenever any Mesh section is updated. This may be expensive. If this is disabled use ForceNavMeshUpdate to trigger a navmesh update when necessary.  Moving the component will also trigger a navmesh update.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_material`` (MaterialInterface):  [Read-Write]
    """
    def set_wireframe_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_wireframe_material(material) -> None
        Set the wireframe material.
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_wireframe_color(self, color: LinearColor) -> None:
        r"""
        x.set_wireframe_color(color) -> None
        Set Wireframe Color
        
        Args:
            color (LinearColor):
        """
        ...
    def set_use_wireframe(self, use_wireframe: bool) -> None:
        r"""
        x.set_use_wireframe(use_wireframe) -> None
        Set Use Wireframe
        
        Args:
            use_wireframe (bool):
        """
        ...
    def set_enable_mesh_occlusion(self, enable: bool) -> None:
        r"""
        x.set_enable_mesh_occlusion(enable) -> None
        Set Enable Mesh Occlusion
        
        Args:
            enable (bool):
        """
        ...
    def request_nav_mesh_update(self) -> None:
        r"""
        x.request_nav_mesh_update() -> None
        Generate nav mesh if collision data has changed since the last nav mesh generation.
        """
        ...
    def is_connected(self) -> bool:
        r"""
        x.is_connected() -> bool
        Is Connected
        
        Returns:
            bool:
        """
        ...
    def get_wireframe_color(self) -> LinearColor:
        r"""
        x.get_wireframe_color() -> LinearColor
        Get Wireframe Color
        
        Returns:
            LinearColor:
        """
        ...
    def get_use_wireframe(self) -> bool:
        r"""
        x.get_use_wireframe() -> bool
        Get Use Wireframe
        
        Returns:
            bool:
        """
        ...
    def get_enable_mesh_occlusion(self) -> bool:
        r"""
        x.get_enable_mesh_occlusion() -> bool
        Get Enable Mesh Occlusion
        
        Returns:
            bool:
        """
        ...
    def force_nav_mesh_update(self) -> None:
        r"""
        x.force_nav_mesh_update() -> None
        Force navmesh generation to run using the current collision data.  This will run even if the collision data has not been udpated! Unless you are changing navmesh settings or similar RequestNavMeshUpdate is reccomended.
        """
        ...
    def clear(self) -> None:
        r"""
        x.clear() -> None
        Clear
        """
        ...

class MeshReconstructorBase(Object):
    r"""
    Mesh Reconstructor Base
    
    **C++ Source:**
    
    - **Module**: MRMesh
    - **File**: MeshReconstructorBase.h
    
    """
    def stop_reconstruction(self) -> None:
        r"""
        x.stop_reconstruction() -> None
        Stop Reconstruction
        """
        ...
    def start_reconstruction(self) -> None:
        r"""
        x.start_reconstruction() -> None
        Start Reconstruction
        """
        ...
    def pause_reconstruction(self) -> None:
        r"""
        x.pause_reconstruction() -> None
        Pause Reconstruction
        """
        ...
    def is_reconstruction_started(self) -> bool:
        r"""
        x.is_reconstruction_started() -> bool
        Is Reconstruction Started
        
        Returns:
            bool:
        """
        ...
    def is_reconstruction_paused(self) -> bool:
        r"""
        x.is_reconstruction_paused() -> bool
        Is Reconstruction Paused
        
        Returns:
            bool:
        """
        ...

class LandscapeBlueprintBrush(LandscapeBlueprintBrushBase):
    r"""
    Landscape Blueprint Brush
    
    **C++ Source:**
    
    - **Module**: LandscapeEditorUtilities
    - **File**: LandscapeBlueprintBrush.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``affect_heightmap`` (bool):  [Read-Write]
    - ``affect_visibility_layer`` (bool):  [Read-Write]
    - ``affect_weightmap`` (bool):  [Read-Write]
    - ``affected_weightmap_layers`` (Array[Name]):  [Read-Write]
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_on_property_change`` (bool):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class LandscapeBlueprintCustomBrush(LandscapeBlueprintBrush):
    r"""
    deprecated: 'LandscapeBlueprintCustomBrush' was renamed to 'LandscapeBlueprintBrush'.
    """
    ...

class AssetThumbnailWidget(Widget):
    r"""
    This widget can be given an asset and it will render its thumbnail. Editor-only.
    
    **C++ Source:**
    
    - **Module**: UMGEditor
    - **File**: AssetThumbnailWidget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``asset_to_show`` (AssetData):  [Read-Write] The asset of which to show the thumbnail.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``resolution`` (IntPoint):  [Read-Write] Desired size of the thumbnail
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``thumbnail_settings`` (AssetThumbnailWidgetSettings):  [Read-Write] Behaviour and style of the widget
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def resolution(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Desired size of the thumbnail
        """
        ...
    @resolution.setter
    def resolution(self, value: IntPoint) -> None:
        ...
    @property
    def thumbnail_settings(self) -> AssetThumbnailWidgetSettings:
        r"""
        (AssetThumbnailWidgetSettings):  [Read-Write] Behaviour and style of the widget
        """
        ...
    @thumbnail_settings.setter
    def thumbnail_settings(self, value: AssetThumbnailWidgetSettings) -> None:
        ...
    def set_thumbnail_settings(self, thumbnail_settings: AssetThumbnailWidgetSettings) -> None:
        r"""
        x.set_thumbnail_settings(thumbnail_settings) -> None
        Set Thumbnail Settings
        
        Args:
            thumbnail_settings (AssetThumbnailWidgetSettings):
        """
        ...
    def set_resolution(self, resolution: IntPoint) -> None:
        r"""
        x.set_resolution(resolution) -> None
        Sets the resolution for the rendered thumbnail.
        
        Args:
            resolution (IntPoint):
        """
        ...
    def set_asset_by_object(self, object: Object) -> None:
        r"""
        x.set_asset_by_object(object) -> None
        Set Asset by Object
        
        Args:
            object (Object):
        """
        ...
    def set_asset(self, asset_data: AssetData) -> None:
        r"""
        x.set_asset(asset_data) -> None
        Set Asset
        
        Args:
            asset_data (AssetData):
        """
        ...
    def get_resolution(self) -> IntPoint:
        r"""
        x.get_resolution() -> IntPoint
        Gets the resolution of the rendered thumbnail.
        
        Returns:
            IntPoint:
        """
        ...

class SlateVectorArtDataFactory(Factory):
    r"""
    Slate Vector Art Data Factory
    
    **C++ Source:**
    
    - **Module**: UMGEditor
    - **File**: SlateVectorArtDataFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class UserWidgetBlueprint(Blueprint):
    r"""
    User Widget Blueprint
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UserWidgetBlueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blueprint_category`` (str):  [Read-Write] The category of the Blueprint, used to organize this Blueprint class when displayed in palette windows
    - ``blueprint_description`` (str):  [Read-Write] Shows up in the content browser tooltip when the blueprint is hovered
    - ``blueprint_display_name`` (str):  [Read-Write] Overrides the BP's display name in the editor UI
    - ``blueprint_namespace`` (str):  [Read-Write] The namespace of this blueprint (if set, the Blueprint will be treated differently for the context menu)
    - ``compile_mode`` (BlueprintCompileMode):  [Read-Write] The mode that will be used when compiling this class.
    - ``deprecate`` (bool):  [Read-Write] Deprecates the Blueprint, marking the generated class with the CLASS_Deprecated flag
    - ``generate_abstract_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a abstract class or not.  Should set CLASS_Abstract in the KismetCompiler.
    - ``generate_const_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a const class or not.  Should set CLASS_Const in the KismetCompiler.
    - ``hide_categories`` (Array[str]):  [Read-Write] Additional HideCategories. These are added to HideCategories from parent.
    - ``run_construction_script_in_sequencer`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor in sequencer
    - ``run_construction_script_on_drag`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor as you drag it in the editor, or only when the drag operation is complete
    - ``should_cook_property_guids_value`` (ShouldCookBlueprintPropertyGuids):  [Read-Write] Whether to include the property GUIDs for the generated class in a cooked build.
      note: This option may slightly increase memory usage in a cooked build, but can avoid needing to add CoreRedirect data for Blueprint classes stored within SaveGame archives.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    ...

class BaseWidgetBlueprint(UserWidgetBlueprint):
    r"""
    Base Widget Blueprint
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: BaseWidgetBlueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blueprint_category`` (str):  [Read-Write] The category of the Blueprint, used to organize this Blueprint class when displayed in palette windows
    - ``blueprint_description`` (str):  [Read-Write] Shows up in the content browser tooltip when the blueprint is hovered
    - ``blueprint_display_name`` (str):  [Read-Write] Overrides the BP's display name in the editor UI
    - ``blueprint_namespace`` (str):  [Read-Write] The namespace of this blueprint (if set, the Blueprint will be treated differently for the context menu)
    - ``compile_mode`` (BlueprintCompileMode):  [Read-Write] The mode that will be used when compiling this class.
    - ``deprecate`` (bool):  [Read-Write] Deprecates the Blueprint, marking the generated class with the CLASS_Deprecated flag
    - ``generate_abstract_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a abstract class or not.  Should set CLASS_Abstract in the KismetCompiler.
    - ``generate_const_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a const class or not.  Should set CLASS_Const in the KismetCompiler.
    - ``hide_categories`` (Array[str]):  [Read-Write] Additional HideCategories. These are added to HideCategories from parent.
    - ``run_construction_script_in_sequencer`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor in sequencer
    - ``run_construction_script_on_drag`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor as you drag it in the editor, or only when the drag operation is complete
    - ``should_cook_property_guids_value`` (ShouldCookBlueprintPropertyGuids):  [Read-Write] Whether to include the property GUIDs for the generated class in a cooked build.
      note: This option may slightly increase memory usage in a cooked build, but can avoid needing to add CoreRedirect data for Blueprint classes stored within SaveGame archives.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    """
    ...

class WidgetBlueprint(BaseWidgetBlueprint):
    r"""
    The widget blueprint enables extending UUserWidget the user extensible UWidget.
    
    **C++ Source:**
    
    - **Module**: UMGEditor
    - **File**: WidgetBlueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blueprint_category`` (str):  [Read-Write] The category of the Blueprint, used to organize this Blueprint class when displayed in palette windows
    - ``blueprint_description`` (str):  [Read-Write] Shows up in the content browser tooltip when the blueprint is hovered
    - ``blueprint_display_name`` (str):  [Read-Write] Overrides the BP's display name in the editor UI
    - ``blueprint_namespace`` (str):  [Read-Write] The namespace of this blueprint (if set, the Blueprint will be treated differently for the context menu)
    - ``can_call_initialized_without_player_context`` (bool):  [Read-Write] Run the initialize event on widget that doesn't have a player context.
    - ``compile_mode`` (BlueprintCompileMode):  [Read-Write] The mode that will be used when compiling this class.
    - ``deprecate`` (bool):  [Read-Write] Deprecates the Blueprint, marking the generated class with the CLASS_Deprecated flag
    - ``generate_abstract_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a abstract class or not.  Should set CLASS_Abstract in the KismetCompiler.
    - ``generate_const_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a const class or not.  Should set CLASS_Const in the KismetCompiler.
    - ``hide_categories`` (Array[str]):  [Read-Write] Additional HideCategories. These are added to HideCategories from parent.
    - ``run_construction_script_in_sequencer`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor in sequencer
    - ``run_construction_script_on_drag`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor as you drag it in the editor, or only when the drag operation is complete
    - ``should_cook_property_guids_value`` (ShouldCookBlueprintPropertyGuids):  [Read-Write] Whether to include the property GUIDs for the generated class in a cooked build.
      note: This option may slightly increase memory usage in a cooked build, but can avoid needing to add CoreRedirect data for Blueprint classes stored within SaveGame archives.
    - ``thumbnail_custom_size`` (Vector2D):  [Read-Write]
    - ``thumbnail_image`` (Texture2D):  [Read-Write]
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``thumbnail_size_mode`` (ThumbnailPreviewSizeMode):  [Read-Write]
    """
    ...

class WidgetBlueprintFactory(Factory):
    r"""
    Widget Blueprint Factory
    
    **C++ Source:**
    
    - **Module**: UMGEditor
    - **File**: WidgetBlueprintFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``blueprint_type`` (BlueprintType):  [Read-Write] The type of blueprint that will be created
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Write] The parent class of the created blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PropertyViewBase(Widget):
    r"""
    Base of property view allows you to display the value of an object properties.
    
    **C++ Source:**
    
    - **Module**: ScriptableEditorWidgets
    - **File**: PropertyViewBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``auto_load_asset`` (bool):  [Read-Write] Load the object (if it's an asset) when the widget is created.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_property_changed`` (OnPropertyValueChanged):  [Read-Write] Sets a delegate called when the property value changes
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def on_property_changed(self) -> OnPropertyValueChanged:
        r"""
        (OnPropertyValueChanged):  [Read-Write] Sets a delegate called when the property value changes
        """
        ...
    @on_property_changed.setter
    def on_property_changed(self, value: OnPropertyValueChanged) -> None:
        ...
    def set_object(self, new_object: Object) -> None:
        r"""
        x.set_object(new_object) -> None
        Set Object
        
        Args:
            new_object (Object):
        """
        ...
    def get_object(self) -> Object:
        r"""
        x.get_object() -> Object
        Get Object
        
        Returns:
            Object:
        """
        ...

class DetailsView(PropertyViewBase):
    r"""
    The details view allows you to display the value of an object properties.
    
    **C++ Source:**
    
    - **Module**: ScriptableEditorWidgets
    - **File**: DetailsView.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_favorite_system`` (bool):  [Read-Write] If false, the current properties editor will never display the favorite system
    - ``allow_filtering`` (bool):  [Read-Write] True if we allow filtering through search and the filter dropdown menu.
    - ``auto_load_asset`` (bool):  [Read-Write] Load the object (if it's an asset) when the widget is created.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``categories_to_show`` (Array[Name]):  [Read-Write] Which categories to show in the details panel. If both this and the Properties To Show lists are empty, all properties will show.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``column_width`` (float):  [Read-Write] The default column width
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``force_hidden_property_visibility`` (bool):  [Read-Write] If true, all properties will be visible, not just those with CPF_Edit
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_property_changed`` (OnPropertyValueChanged):  [Read-Write] Sets a delegate called when the property value changes
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``properties_to_show`` (Array[Name]):  [Read-Write] Which properties to show in the details panel. If both this and the Categories To Show lists are empty, all properties will show.
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``show_animated_properties_option`` (bool):  [Read-Write] True if you want to show the 'Show Only Animated Properties'. Only valid in conjunction with bAllowFiltering
    - ``show_keyable_properties_option`` (bool):  [Read-Write] True if you want to show the 'Show Only Keyable Properties'. Only valid in conjunction with bAllowFiltering
    - ``show_modified_properties_option`` (bool):  [Read-Write] True if you want to show the 'Show Only Modified Properties'. Only valid in conjunction with bAllowFiltering
    - ``show_scroll_bar`` (bool):  [Read-Write] If false, the details panel's scrollbar will always be hidden. Useful when embedding details panels in widgets that either grow to accommodate them, or with scrollbars of their own.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``view_identifier`` (Name):  [Read-Write] Identifier for this details view; NAME_None if this view is anonymous
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    ...

class SinglePropertyView(PropertyViewBase):
    r"""
    The single property view allows you to display the value of an object's property.
    
    **C++ Source:**
    
    - **Module**: ScriptableEditorWidgets
    - **File**: SinglePropertyView.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``auto_load_asset`` (bool):  [Read-Write] Load the object (if it's an asset) when the widget is created.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``name_override`` (Text):  [Read-Write] Override for the property name that will be displayed instead of the property name.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_property_changed`` (OnPropertyValueChanged):  [Read-Write] Sets a delegate called when the property value changes
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``property_name`` (Name):  [Read-Write] The name of the property to display.
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    def set_property_name(self, new_property_name: Name) -> None:
        r"""
        x.set_property_name(new_property_name) -> None
        Set Property Name
        
        Args:
            new_property_name (Name):
        """
        ...
    def set_name_override(self, new_property_name: Text) -> None:
        r"""
        x.set_name_override(new_property_name) -> None
        Set Name Override
        
        Args:
            new_property_name (Text):
        """
        ...
    def get_property_name(self) -> Name:
        r"""
        x.get_property_name() -> Name
        Get Property Name
        
        Returns:
            Name:
        """
        ...
    def get_name_override(self) -> Text:
        r"""
        x.get_name_override() -> Text
        Get Name Override
        
        Returns:
            Text:
        """
        ...

class AutomationViewSettings(DataAsset):
    r"""
    Automation View Settings
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: AutomationViewSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anti_aliasing`` (bool):  [Read-Write]
    - ``bloom`` (bool):  [Read-Write]
    - ``contact_shadows`` (bool):  [Read-Write]
    - ``distance_field_ao`` (bool):  [Read-Write]
    - ``eye_adaptation`` (bool):  [Read-Write]
    - ``motion_blur`` (bool):  [Read-Write]
    - ``screen_space_ao`` (bool):  [Read-Write]
    - ``screen_space_reflections`` (bool):  [Read-Write]
    - ``temporal_aa`` (bool):  [Read-Write]
    """
    ...

class AutomationEditorTask(Object):
    r"""
    UAutomationEditorTask
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: AutomationBlueprintFunctionLibrary.h
    
    """
    def is_valid_task(self) -> bool:
        r"""
        x.is_valid_task() -> bool
        Query if a task was setup
        
        Returns:
            bool:
        """
        ...
    def is_task_done(self) -> bool:
        r"""
        x.is_task_done() -> bool
        Query if the Editor task is done
        
        Returns:
            bool:
        """
        ...

class AutomationLibrary(BlueprintFunctionLibrary):
    r"""
    Automation Blueprint Function Library
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: AutomationBlueprintFunctionLibrary.h
    
    """
    @classmethod
    def take_high_res_screenshot(cls, res_x: int, res_y: int, filename: str, camera: CameraActor = None, mask_enabled: bool = False, capture_hdr: bool = False, comparison_tolerance: ComparisonTolerance = ComparisonTolerance.LOW, comparison_notes: str = "", delay: float = 0.000000, force_game_view: bool = True) -> AutomationEditorTask:
        r"""
        X.take_high_res_screenshot(res_x, res_y, filename, camera=None, mask_enabled=False, capture_hdr=False, comparison_tolerance=ComparisonTolerance.LOW, comparison_notes="", delay=0.000000, force_game_view=True) -> AutomationEditorTask
        take high res screenshot in editor.
        
        Args:
            res_x (int32): 
            res_y (int32): 
            filename (str): 
            camera (CameraActor): 
            mask_enabled (bool): 
            capture_hdr (bool): 
            comparison_tolerance (ComparisonTolerance): 
            comparison_notes (str): 
            delay (float): 
            force_game_view (bool): 
        
        Returns:
            AutomationEditorTask:
        """
        ...
    @classmethod
    def take_automation_screenshot_of_ui(cls, world_context_object: Object, latent_info: LatentActionInfo, name: str, options: AutomationScreenshotOptions) -> None:
        r"""
        X.take_automation_screenshot_of_ui(world_context_object, latent_info, name, options) -> None
        Take Automation Screenshot Of UI
        
        Args:
            world_context_object (Object): 
            latent_info (LatentActionInfo): 
            name (str): 
            options (AutomationScreenshotOptions):
        """
        ...
    @classmethod
    def take_automation_screenshot_at_camera(cls, world_context_object: Object, latent_info: LatentActionInfo, camera: CameraActor, name_override: str = "", notes: str = ..., options: AutomationScreenshotOptions = ...) -> None:
        r"""
        X.take_automation_screenshot_at_camera(world_context_object, latent_info, camera, name_override="", notes, options) -> None
        Takes a screenshot of the game's viewport, from a particular camera actors POV.  Does not capture any UI.
        
        Args:
            world_context_object (Object): 
            latent_info (LatentActionInfo): 
            camera (CameraActor): 
            name_override (str): 
            notes (str): 
            options (AutomationScreenshotOptions):
        """
        ...
    @classmethod
    def take_automation_screenshot(cls, world_context_object: Object, latent_info: LatentActionInfo, name: str = "", notes: str = ..., options: AutomationScreenshotOptions = ...) -> None:
        r"""
        X.take_automation_screenshot(world_context_object, latent_info, name="", notes, options) -> None
        Takes a screenshot of the game's viewport.  Does not capture any UI.
        
        Args:
            world_context_object (Object): 
            latent_info (LatentActionInfo): 
            name (str): 
            notes (str): 
            options (AutomationScreenshotOptions):
        """
        ...
    @classmethod
    def set_test_telemetry_storage(cls, storage_name: str) -> None:
        r"""
        X.set_test_telemetry_storage(storage_name) -> None
        Set Telemetry data storage name of currently running automated test.
        
        Args:
            storage_name (str):
        """
        ...
    @classmethod
    def set_scalability_quality_to_low(cls, world_context_object: Object) -> None:
        r"""
        X.set_scalability_quality_to_low(world_context_object) -> None
        Set Scalability Quality to Low
        
        Args:
            world_context_object (Object):
        """
        ...
    @classmethod
    def set_scalability_quality_to_epic(cls, world_context_object: Object) -> None:
        r"""
        X.set_scalability_quality_to_epic(world_context_object) -> None
        Set Scalability Quality to Epic
        
        Args:
            world_context_object (Object):
        """
        ...
    @classmethod
    def set_scalability_quality_level_relative_to_max(cls, world_context_object: Object, value: int = 1) -> None:
        r"""
        X.set_scalability_quality_level_relative_to_max(world_context_object, value=1) -> None
        Sets all other settings based on an overall value
        
        Args:
            world_context_object (Object): 
            value (int32): 0:Cinematic, 1:Epic...etc.
        """
        ...
    @classmethod
    def set_editor_viewport_visualize_buffer(cls, buffer_name: Name) -> None:
        r"""
        X.set_editor_viewport_visualize_buffer(buffer_name) -> None
        Sets all viewports of the first found level editor to have the VisualizeBuffer ViewMode and also display a given buffer (BaseColor/Metallic/Roughness/etc.) *
        
        Args:
            buffer_name (Name):
        """
        ...
    @classmethod
    def set_editor_viewport_view_mode(cls, index: ViewModeIndex) -> None:
        r"""
        X.set_editor_viewport_view_mode(index) -> None
        Sets all viewports of the first found level editor to have the given ViewMode (Lit/Unlit/etc.) *
        
        Args:
            index (ViewModeIndex):
        """
        ...
    @classmethod
    def get_stat_inc_max(cls, stat_name: Name) -> float:
        r"""
        X.get_stat_inc_max(stat_name) -> float
        Get Stat Inc Max
        
        Args:
            stat_name (Name): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_stat_inc_average(cls, stat_name: Name) -> float:
        r"""
        X.get_stat_inc_average(stat_name) -> float
        Get Stat Inc Average
        
        Args:
            stat_name (Name): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_stat_exc_max(cls, stat_name: Name) -> float:
        r"""
        X.get_stat_exc_max(stat_name) -> float
        Get Stat Exc Max
        
        Args:
            stat_name (Name): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_stat_exc_average(cls, stat_name: Name) -> float:
        r"""
        X.get_stat_exc_average(stat_name) -> float
        Get Stat Exc Average
        
        Args:
            stat_name (Name): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_stat_call_count(cls, stat_name: Name) -> float:
        r"""
        X.get_stat_call_count(stat_name) -> float
        Get Stat Call Count
        
        Args:
            stat_name (Name): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_default_screenshot_options_for_rendering(cls, tolerance: ComparisonTolerance = ComparisonTolerance.LOW, delay: float = 0.200000) -> AutomationScreenshotOptions:
        r"""
        X.get_default_screenshot_options_for_rendering(tolerance=ComparisonTolerance.LOW, delay=0.200000) -> AutomationScreenshotOptions
        Get Default Screenshot Options for Rendering
        
        Args:
            tolerance (ComparisonTolerance): 
            delay (float): 
        
        Returns:
            AutomationScreenshotOptions:
        """
        ...
    @classmethod
    def get_default_screenshot_options_for_gameplay(cls, tolerance: ComparisonTolerance = ComparisonTolerance.LOW, delay: float = 0.200000) -> AutomationScreenshotOptions:
        r"""
        X.get_default_screenshot_options_for_gameplay(tolerance=ComparisonTolerance.LOW, delay=0.200000) -> AutomationScreenshotOptions
        Get Default Screenshot Options for Gameplay
        
        Args:
            tolerance (ComparisonTolerance): 
            delay (float): 
        
        Returns:
            AutomationScreenshotOptions:
        """
        ...
    @classmethod
    def finish_loading_before_screenshot(cls) -> None:
        r"""
        X.finish_loading_before_screenshot() -> None
        Finish Loading Before Screenshot
        """
        ...
    @classmethod
    def enable_stat_group(cls, world_context_object: Object, group_name: Name) -> None:
        r"""
        X.enable_stat_group(world_context_object, group_name) -> None
        Enable Stat Group
        
        Args:
            world_context_object (Object): 
            group_name (Name):
        """
        ...
    @classmethod
    def disable_stat_group(cls, world_context_object: Object, group_name: Name) -> None:
        r"""
        X.disable_stat_group(world_context_object, group_name) -> None
        Disable Stat Group
        
        Args:
            world_context_object (Object): 
            group_name (Name):
        """
        ...
    @classmethod
    def compare_image_against_reference(cls, image_file_path: str, comparison_name: str = "", comparison_tolerance: ComparisonTolerance = ComparisonTolerance.LOW, comparison_notes: str = "", world_context_object: Object = None) -> bool:
        r"""
        X.compare_image_against_reference(image_file_path, comparison_name="", comparison_tolerance=ComparisonTolerance.LOW, comparison_notes="", world_context_object=None) -> bool
        request image comparison.
        
        Args:
            image_file_path (str): Absolute path to the image location. All 8bit RGBA channels supported formats by the engine are accepted.
            comparison_name (str): Optional name for the comparison, by default the basename of ImageFilePath is used
            comparison_tolerance (ComparisonTolerance): 
            comparison_notes (str): 
            world_context_object (Object): 
        
        Returns:
            bool: True if comparison was successfully enqueued
        """
        ...
    @classmethod
    def automation_wait_for_loading(cls, world_context_object: Object, latent_info: LatentActionInfo, options: AutomationWaitForLoadingOptions) -> None:
        r"""
        X.automation_wait_for_loading(world_context_object, latent_info, options) -> None
        Automation Wait for Loading
        
        Args:
            world_context_object (Object): 
            latent_info (LatentActionInfo): 
            options (AutomationWaitForLoadingOptions):
        """
        ...
    @classmethod
    def are_automated_tests_running(cls) -> bool:
        r"""
        X.are_automated_tests_running() -> bool
        Lets you know if any automated tests are running, or are about to run and the automation system is spinning up tests.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def add_test_warning(cls, log_item: str) -> None:
        r"""
        X.add_test_warning(log_item) -> None
        Add warning to currently running automated test.
        
        Args:
            log_item (str):
        """
        ...
    @classmethod
    def add_test_telemetry_data(cls, data_point: str, measurement: float, context: str = "") -> None:
        r"""
        X.add_test_telemetry_data(data_point, measurement, context="") -> None
        Add Telemetry data to currently running automated test.
        
        Args:
            data_point (str): 
            measurement (float): 
            context (str):
        """
        ...
    @classmethod
    def add_test_info(cls, log_item: str) -> None:
        r"""
        X.add_test_info(log_item) -> None
        Add info to currently running automated test.
        
        Args:
            log_item (str):
        """
        ...
    @classmethod
    def add_test_error(cls, log_item: str) -> None:
        r"""
        X.add_test_error(log_item) -> None
        Add error to currently running automated test.
        
        Args:
            log_item (str):
        """
        ...
    @classmethod
    def add_expected_plain_log_message(cls, expected_string: str, occurrences: int = 1, exact_match: bool = False) -> None:
        r"""
        X.add_expected_plain_log_message(expected_string, occurrences=1, exact_match=False) -> None
        Expect a specific log message to match a plain string during an automated test regardless of its verbosity
        
        Args:
            expected_string (str): 
            occurrences (int32): 
            exact_match (bool):
        """
        ...
    @classmethod
    def add_expected_plain_log_error(cls, expected_string: str, occurrences: int = 1, exact_match: bool = False) -> None:
        r"""
        X.add_expected_plain_log_error(expected_string, occurrences=1, exact_match=False) -> None
        Mute the report of log error and warning matching a plain string during an automated test
        
        Args:
            expected_string (str): 
            occurrences (int32): 
            exact_match (bool):
        """
        ...
    @classmethod
    def add_expected_log_message(cls, expected_pattern_string: str, occurrences: int = 1, exact_match: bool = False, is_regex: bool = True) -> None:
        r"""
        X.add_expected_log_message(expected_pattern_string, occurrences=1, exact_match=False, is_regex=True) -> None
        Expect a specific log message to match a pattern during an automated test regardless of its verbosity. Treat the pattern as regex by default.
        
        Args:
            expected_pattern_string (str): 
            occurrences (int32): 
            exact_match (bool): 
            is_regex (bool):
        """
        ...
    @classmethod
    def add_expected_log_error(cls, expected_pattern_string: str, occurrences: int = 1, exact_match: bool = False, is_regex: bool = True) -> None:
        r"""
        X.add_expected_log_error(expected_pattern_string, occurrences=1, exact_match=False, is_regex=True) -> None
        Mute the report of log error and warning matching a pattern during an automated test. Treat the pattern as regex by default.
        
        Args:
            expected_pattern_string (str): Expects a Regex pattern.
            occurrences (int32): 
            exact_match (bool): 
            is_regex (bool):
        """
        ...

class FuncTestRenderingComponent(PrimitiveComponent):
    r"""
    Func Test Rendering Component
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FuncTestRenderingComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class FunctionalTest(Actor):
    r"""
    Functional Test
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``author`` (str):  [Read-Write] The owner is the group or person responsible for the test. Generally you should use a group name
      like 'Editor' or 'Rendering'. When a test fails it may not be obvious who should investigate
      so this provides a associate responsible groups with tests.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``description`` (str):  [Read-Write] A description of the test, like what is this test trying to determine.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_enabled_value`` (bool):  [Read-Write] Allows a test to be disabled.  If a test is disabled, it will not appear in the set of
      runnable tests (after saving the map).
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``log_error_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogErrors are handled during this test.
    - ``log_warning_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogWarnings are handled during this test.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``observation_point`` (Actor):  [Read-Write] Allows you to specify another actor to view the test from.  Usually this is a camera you place
      in the map to observe the test.  Not useful when running on a build farm, but provides a handy
      way to observe the test from a different location than you place the functional test actor.
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``on_test_finished`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is finished. Use it to clean up
    - ``on_test_prepare`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is ready to prepare
    - ``on_test_start`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is started
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``preparation_time_limit`` (float):  [Read-Write] The Test's time limit for preparation, this is the time it has to return true when checking IsReady(). '0' means no limit.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``random_numbers_stream`` (RandomStream):  [Read-Write] A random number stream that you can use during testing.  This number stream will be consistent
      every time the test is run.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``result`` (FunctionalTestResult):  [Read-Write]
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``should_delay_garbage_collection`` (bool):  [Read-Write] Allows for garbage collection to be delayed. If delayed, garbage collection will be triggered at the end of a test run
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``test_label`` (str):  [Read-Write]
    - ``time_limit`` (float):  [Read-Write] Test's time limit. '0' means no limit
    - ``times_up_message`` (Text):  [Read-Write]
    - ``times_up_result`` (FunctionalTestResult):  [Read-Write] If test is limited by time this is the result that will be returned when time runs out
    - ``total_time`` (float):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def test_label(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def author(self) -> str:
        r"""
        (str):  [Read-Only] The owner is the group or person responsible for the test. Generally you should use a group name
        like 'Editor' or 'Rendering'. When a test fails it may not be obvious who should investigate
        so this provides a associate responsible groups with tests.
        """
        ...
    @property
    def description(self) -> str:
        r"""
        (str):  [Read-Only] A description of the test, like what is this test trying to determine.
        """
        ...
    @property
    def is_enabled_value(self) -> bool:
        r"""
        (bool):  [Read-Only] Allows a test to be disabled.  If a test is disabled, it will not appear in the set of
        runnable tests (after saving the map).
        """
        ...
    @property
    def log_error_handling(self) -> FunctionalTestLogHandling:
        r"""
        (FunctionalTestLogHandling):  [Read-Only] Determines how LogErrors are handled during this test.
        """
        ...
    @property
    def log_warning_handling(self) -> FunctionalTestLogHandling:
        r"""
        (FunctionalTestLogHandling):  [Read-Only] Determines how LogWarnings are handled during this test.
        """
        ...
    @property
    def observation_point(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Allows you to specify another actor to view the test from.  Usually this is a camera you place
        in the map to observe the test.  Not useful when running on a build farm, but provides a handy
        way to observe the test from a different location than you place the functional test actor.
        """
        ...
    @observation_point.setter
    def observation_point(self, value: Actor) -> None:
        ...
    @property
    def should_delay_garbage_collection(self) -> bool:
        r"""
        (bool):  [Read-Only] Allows for garbage collection to be delayed. If delayed, garbage collection will be triggered at the end of a test run
        """
        ...
    @property
    def random_numbers_stream(self) -> RandomStream:
        r"""
        (RandomStream):  [Read-Write] A random number stream that you can use during testing.  This number stream will be consistent
        every time the test is run.
        """
        ...
    @random_numbers_stream.setter
    def random_numbers_stream(self, value: RandomStream) -> None:
        ...
    @property
    def result(self) -> FunctionalTestResult:
        r"""
        (FunctionalTestResult):  [Read-Write]
        """
        ...
    @result.setter
    def result(self, value: FunctionalTestResult) -> None:
        ...
    @property
    def preparation_time_limit(self) -> float:
        r"""
        (float):  [Read-Only] The Test's time limit for preparation, this is the time it has to return true when checking IsReady(). '0' means no limit.
        """
        ...
    @property
    def time_limit(self) -> float:
        r"""
        (float):  [Read-Only] Test's time limit. '0' means no limit
        """
        ...
    @property
    def times_up_message(self) -> Text:
        r"""
        (Text):  [Read-Write]
        """
        ...
    @times_up_message.setter
    def times_up_message(self, value: Text) -> None:
        ...
    @property
    def on_test_prepare(self) -> FunctionalTestEventSignature:
        r"""
        (FunctionalTestEventSignature):  [Read-Write] Called when the test is ready to prepare
        """
        ...
    @on_test_prepare.setter
    def on_test_prepare(self, value: FunctionalTestEventSignature) -> None:
        ...
    @property
    def on_test_start(self) -> FunctionalTestEventSignature:
        r"""
        (FunctionalTestEventSignature):  [Read-Write] Called when the test is started
        """
        ...
    @on_test_start.setter
    def on_test_start(self, value: FunctionalTestEventSignature) -> None:
        ...
    @property
    def on_test_finished(self) -> FunctionalTestEventSignature:
        r"""
        (FunctionalTestEventSignature):  [Read-Write] Called when the test is finished. Use it to clean up
        """
        ...
    @on_test_finished.setter
    def on_test_finished(self, value: FunctionalTestEventSignature) -> None:
        ...
    @property
    def total_time(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    def set_time_limit(self, new_time_limit: float, result_when_time_runs_out: FunctionalTestResult) -> None:
        r"""
        x.set_time_limit(new_time_limit, result_when_time_runs_out) -> None
        Set Time Limit
        
        Args:
            new_time_limit (float): 
            result_when_time_runs_out (FunctionalTestResult):
        """
        ...
    def set_console_variable_from_integer(self, name: str, value: int) -> None:
        r"""
        x.set_console_variable_from_integer(name, value) -> None
        Sets the CVar from the given input. Variable gets reset after the test.
        
        Args:
            name (str): 
            value (int32):
        """
        ...
    def set_console_variable_from_float(self, name: str, value: float) -> None:
        r"""
        x.set_console_variable_from_float(name, value) -> None
        Sets the CVar from the given input. Variable gets reset after the test.
        
        Args:
            name (str): 
            value (float):
        """
        ...
    def set_console_variable_from_boolean(self, name: str, value: bool) -> None:
        r"""
        x.set_console_variable_from_boolean(name, value) -> None
        Sets the CVar from the given input. Variable gets reset after the test.
        
        Args:
            name (str): 
            value (bool):
        """
        ...
    def set_console_variable(self, name: str, value: str) -> None:
        r"""
        x.set_console_variable(name, value) -> None
        Sets the CVar from the given input. Variable gets reset after the test.
        
        Args:
            name (str): 
            value (str):
        """
        ...
    def register_auto_destroy_actor(self, actor_to_auto_destroy: Actor) -> None:
        r"""
        x.register_auto_destroy_actor(actor_to_auto_destroy) -> None
        Actors registered this way will be automatically destroyed (by limiting their lifespan)
            on test finish
        
        Args:
            actor_to_auto_destroy (Actor):
        """
        ...
    def receive_start_test(self) -> None:
        r"""
        x.receive_start_test() -> None
        Called once the IsReady() check for the test returns true.  After that happens the test has Officially started,
        and it will begin receiving Ticks in the blueprint.
        """
        ...
    def receive_prepare_test(self) -> None:
        r"""
        x.receive_prepare_test() -> None
        Prepare Test is fired once the test starts up, before the test IsReady() and thus before Start Test is called.
        So if there's some initial conditions or setup that you might need for your IsReady() check, you might want
        to do that here.
        """
        ...
    def on_wants_re_run_check(self) -> bool:
        r"""
        x.on_wants_re_run_check() -> bool
        retrieves information whether test wants to have another run just after finishing
        
        Returns:
            bool:
        """
        ...
    def on_additional_test_finished_message_request(self, test_result: FunctionalTestResult) -> str:
        r"""
        x.on_additional_test_finished_message_request(test_result) -> str
        On Additional Test Finished Message Request
        
        Args:
            test_result (FunctionalTestResult): 
        
        Returns:
            str:
        """
        ...
    def log_message(self, message: str) -> None:
        r"""
        x.log_message(message) -> None
        Log Message
        
        Args:
            message (str):
        """
        ...
    def is_running(self) -> bool:
        r"""
        x.is_running() -> bool
        AActor interface end
        
        Returns:
            bool:
        """
        ...
    def is_ready(self) -> bool:
        r"""
        x.is_ready() -> bool
        IsReady() is called once per frame after a test is run, until it returns true.  You should use this function to
        delay Start being called on the test until preconditions are met.
        
        Returns:
            bool:
        """
        ...
    def is_enabled(self) -> bool:
        r"""
        x.is_enabled() -> bool
        Is Enabled
        
        Returns:
            bool:
        """
        ...
    def get_current_rerun_reason(self) -> Name:
        r"""
        x.get_current_rerun_reason() -> Name
        Returns the current re-run reason if we're in a named re-run.
        
        Returns:
            Name:
        """
        ...
    def finish_test(self, test_result: FunctionalTestResult, message: str) -> None:
        r"""
        x.finish_test(test_result, message) -> None
        Finish Test
        
        Args:
            test_result (FunctionalTestResult): 
            message (str):
        """
        ...
    def debug_gather_relevant_actors(self) -> Array[Actor]:
        r"""
        x.debug_gather_relevant_actors() -> Array[Actor]
        Used by debug drawing to gather actors this test is using and point at them on the level to better understand test's setup
        
        Returns:
            Array[Actor]:
        """
        ...
    def assert_value_int(self, actual: int, should_be: ComparisonMethod, expected: int, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_value_int(actual, should_be, expected, what, context_object=None) -> bool
        Assert on a relationship between two integers.
        
        Args:
            actual (int32): 
            should_be (ComparisonMethod): 
            expected (int32): 
            what (str): A name to use in the message if the assert fails (What: expected {Actual} to be <ShouldBe> {Expected} for context '')
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_value_float(self, actual: float, should_be: ComparisonMethod, expected: float, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_value_float(actual, should_be, expected, what, context_object=None) -> bool
        Assert on a relationship between two floats.
        
        Args:
            actual (float): 
            should_be (ComparisonMethod): 
            expected (float): 
            what (str): A name to use in the message if the assert fails (What: expected {Actual} to be <ShouldBe> {Expected} for context '')
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_value_double(self, actual: float, should_be: ComparisonMethod, expected: float, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_value_double(actual, should_be, expected, what, context_object=None) -> bool
        Assert on a relationship between two doubles.
        
        Args:
            actual (double): 
            should_be (ComparisonMethod): 
            expected (double): 
            what (str): A name to use in the message if the assert fails (What: expected {Actual} to be <ShouldBe> {Expected} for context '')
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_value_date_time(self, actual: DateTime, should_be: ComparisonMethod, expected: DateTime, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_value_date_time(actual, should_be, expected, what, context_object=None) -> bool
        Assert on a relationship between two DateTimes.
        
        Args:
            actual (DateTime): 
            should_be (ComparisonMethod): 
            expected (DateTime): 
            what (str): A name to use in the message if the assert fails (What: expected {Actual} to be <ShouldBe> {Expected} for context '')
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_true(self, condition: bool, message: str, context_object: Object = None) -> bool:
        r"""
        x.assert_true(condition, message, context_object=None) -> bool
        Assert that a boolean value is true.
        
        Args:
            condition (bool): 
            message (str): The message to display if the assert fails ("Assertion Failed: 'Message' for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_not_equal_vector4(self, actual: Vector4, not_expected: Vector4, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_not_equal_vector4(actual, not_expected, what, context_object=None) -> bool
        Assert that two four-component vectors are (memberwise) not equal within a small tolerance.
        
        Args:
            actual (Vector4): 
            not_expected (Vector4): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' not to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_not_equal_vector2d(self, actual: Vector2D, not_expected: Vector2D, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_not_equal_vector2d(actual, not_expected, what, context_object=None) -> bool
        Assert that two two-component vectors are (memberwise) not equal within a small tolerance.
        
        Args:
            actual (Vector2D): 
            not_expected (Vector2D): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' not to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_not_equal_vector(self, actual: Vector, not_expected: Vector, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_not_equal_vector(actual, not_expected, what, context_object=None) -> bool
        Assert that two vectors are (memberwise) not equal within a small tolerance.
        
        Args:
            actual (Vector): 
            not_expected (Vector): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' not to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_not_equal_transform(self, actual: Transform, not_expected: Transform, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_not_equal_transform(actual, not_expected, what, context_object=None) -> bool
        Assert that two transforms are (components memberwise - translation, rotation, scale) not equal within a small tolerance.
        
        Args:
            actual (Transform): 
            not_expected (Transform): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' not to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_not_equal_string(self, actual: str, not_expected: str, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_not_equal_string(actual, not_expected, what, context_object=None) -> bool
        Assert that two Strings are not equal.
        
        Args:
            actual (str): 
            not_expected (str): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' not to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_not_equal_rotator(self, actual: Rotator, not_expected: Rotator, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_not_equal_rotator(actual, not_expected, what, context_object=None) -> bool
        Assert that the component angles of two rotators are all not equal within a small tolerance.
        
        Args:
            actual (Rotator): 
            not_expected (Rotator): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' not to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_not_equal_quat(self, actual: Quat, not_expected: Quat, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_not_equal_quat(actual, not_expected, what, context_object=None) -> bool
        Assert that two quats are (memberwise) not equal within a small tolerance.
        
        Args:
            actual (Quat): 
            not_expected (Quat): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' not to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_not_equal_plane(self, actual: Plane, not_expected: Plane, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_not_equal_plane(actual, not_expected, what, context_object=None) -> bool
        Assert that two planes are (memberwise) not equal within a small tolerance.
        
        Args:
            actual (Plane): 
            not_expected (Plane): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' not to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_not_equal_matrix(self, actual: Matrix, not_expected: Matrix, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_not_equal_matrix(actual, not_expected, what, context_object=None) -> bool
        Assert that two 4x4 matrices are (memberwise) not equal within a small tolerance.
        
        Args:
            actual (Matrix): 
            not_expected (Matrix): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' not to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_not_equal_box2d(self, actual: Box2D, not_expected: Box2D, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_not_equal_box2d(actual, not_expected, what, context_object=None) -> bool
        Assert that two two-component boxes are (memberwise) not equal within a small tolerance.
        
        Args:
            actual (Box2D): 
            not_expected (Box2D): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' not to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_is_valid(self, object: Object, message: str, context_object: Object = None) -> bool:
        r"""
        x.assert_is_valid(object, message, context_object=None) -> bool
        Assert that a UObject is valid
        
        Args:
            object (Object): 
            message (str): The message to display if the object is invalid ("Invalid object: 'Message' for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_false(self, condition: bool, message: str, context_object: Object = None) -> bool:
        r"""
        x.assert_false(condition, message, context_object=None) -> bool
        Assert that a boolean value is false.
        
        Args:
            condition (bool): 
            message (str): The message to display if the assert fails ("Assertion Failed: 'Message' for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_vector4(self, actual: Vector4, expected: Vector4, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_vector4(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that two four-component vectors are (memberwise) equal within a small tolerance.
        
        Args:
            actual (Vector4): 
            expected (Vector4): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' to be {Expected} but it was {Actual} for context ''")
            tolerance (float): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_vector2d(self, actual: Vector2D, expected: Vector2D, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_vector2d(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that two two-component vectors are (memberwise) equal within a small tolerance.
        
        Args:
            actual (Vector2D): 
            expected (Vector2D): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' to be {Expected} but it was {Actual} for context ''")
            tolerance (float): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_vector(self, actual: Vector, expected: Vector, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_vector(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that two vectors are (memberwise) equal within a small tolerance.
        
        Args:
            actual (Vector): 
            expected (Vector): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' to be {Expected} but it was {Actual} for context ''")
            tolerance (float): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_transform(self, actual: Transform, expected: Transform, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_transform(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that two transforms are (components memberwise - translation, rotation, scale) equal within a small tolerance.
        
        Args:
            actual (Transform): 
            expected (Transform): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' to be {Expected} but it was {Actual} for context ''")
            tolerance (float): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_trace_query_results(self, actual: TraceQueryTestResults, expected: TraceQueryTestResults, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_trace_query_results(actual, expected, what, context_object=None) -> bool
        Assert that two TraceQueryResults are equal.
        
        Args:
            actual (TraceQueryTestResults): 
            expected (TraceQueryTestResults): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' not to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_string(self, actual: str, expected: str, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_string(actual, expected, what, context_object=None) -> bool
        Assert that two Strings are equal.
        
        Args:
            actual (str): 
            expected (str): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' to be {Expected} but it was {Actual} for context ''")
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_rotator_orientation(self, actual: Rotator, expected: Rotator, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_rotator_orientation(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that the orientation of two rotators is the same within a small tolerance. Robust to quaternion singularities where angles can differ despite having an identical orientation.
        
        Args:
            actual (Rotator): 
            expected (Rotator): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' to be {Expected} but it was {Actual} for context ''")
            tolerance (float): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_rotator(self, actual: Rotator, expected: Rotator, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_rotator(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that the component angles of two rotators are all equal within a small tolerance.
        
        Args:
            actual (Rotator): 
            expected (Rotator): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' to be {Expected} but it was {Actual} for context ''")
            tolerance (float): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_quat(self, actual: Quat, expected: Quat, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_quat(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that two quats are (memberwise) equal within a small tolerance.
        
        Args:
            actual (Quat): 
            expected (Quat): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' to be {Expected} but it was {Actual} for context ''")
            tolerance (float): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_plane(self, actual: Plane, expected: Plane, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_plane(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that two planes are (memberwise) equal within a small tolerance.
        
        Args:
            actual (Plane): 
            expected (Plane): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' to be {Expected} but it was {Actual} for context ''")
            tolerance (float): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_object(self, actual: Object, expected: Object, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_object(actual, expected, what, context_object=None) -> bool
        Assert that two Objects are equal
        
        Args:
            actual (Object): 
            expected (Object): 
            what (str): A name to use in the message if the assert fails (What: expected {Actual} to be Equal To {Expected} for context '')
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_name(self, actual: Name, expected: Name, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_name(actual, expected, what, context_object=None) -> bool
        Assert that two FNames are equal
        
        Args:
            actual (Name): 
            expected (Name): 
            what (str): A name to use in the message if the assert fails (What: expected {Actual} to be Equal To {Expected} for context '')
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_matrix(self, actual: Matrix, expected: Matrix, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_matrix(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that two 4x4 matrices are (memberwise) equal within a small tolerance.
        
        Args:
            actual (Matrix): 
            expected (Matrix): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' to be {Expected} but it was {Actual} for context ''")
            tolerance (float): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_int(self, actual: int, expected: int, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_int(actual, expected, what, context_object=None) -> bool
        Assert that two ints are equal
        
        Args:
            actual (int32): 
            expected (int32): 
            what (str): A name to use in the message if the assert fails (What: expected {Actual} to be Equal To {Expected} for context '')
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_float(self, actual: float, expected: float, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_float(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that two floats are equal within tolerance between two floats.
        
        Args:
            actual (float): 
            expected (float): 
            what (str): A name to use in the message if the assert fails (What: expected {Actual} to be Equal To {Expected} within Tolerance for context '')
            tolerance (float): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_double(self, actual: float, expected: float, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_double(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that two double are equal within tolerance between two doubles.
        
        Args:
            actual (double): 
            expected (double): 
            what (str): A name to use in the message if the assert fails (What: expected {Actual} to be Equal To {Expected} within Tolerance for context '')
            tolerance (double): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_box2d(self, actual: Box2D, expected: Box2D, what: str, tolerance: float = 0.000100, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_box2d(actual, expected, what, tolerance=0.000100, context_object=None) -> bool
        Assert that two two-component boxes are (memberwise) equal within a small tolerance.
        
        Args:
            actual (Box2D): 
            expected (Box2D): 
            what (str): A name to use in the message if the assert fails ("Expected 'What' to be {Expected} but it was {Actual} for context ''")
            tolerance (float): 
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def assert_equal_bool(self, actual: bool, expected: bool, what: str, context_object: Object = None) -> bool:
        r"""
        x.assert_equal_bool(actual, expected, what, context_object=None) -> bool
        Assert that two bools are equal
        
        Args:
            actual (bool): 
            expected (bool): 
            what (str): A name to use in the message if the assert fails (What: expected {Actual} to be Equal To {Expected} for context '')
            context_object (Object): 
        
        Returns:
            bool:
        """
        ...
    def add_warning(self, message: str) -> None:
        r"""
        x.add_warning(message) -> None
        Add Warning
        
        Args:
            message (str):
        """
        ...
    def add_rerun(self, reason: Name) -> None:
        r"""
        x.add_rerun(reason) -> None
        Causes the test to be rerun for a specific named reason.
        
        Args:
            reason (Name):
        """
        ...
    def add_info(self, message: str) -> None:
        r"""
        x.add_info(message) -> None
        Add Info
        
        Args:
            message (str):
        """
        ...
    def add_error(self, message: str) -> None:
        r"""
        x.add_error(message) -> None
        Add Error
        
        Args:
            message (str):
        """
        ...

class FunctionalAITestBase(FunctionalTest):
    r"""
    AFunctionalAITestBase
    
    Base abstract class defining a Functional AI Test.
    You can derive from this base class to create a test with a different type of SpawnSets.
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalAITest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``author`` (str):  [Read-Write] The owner is the group or person responsible for the test. Generally you should use a group name
      like 'Editor' or 'Rendering'. When a test fails it may not be obvious who should investigate
      so this provides a associate responsible groups with tests.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``current_spawn_set_index`` (int32):  [Read-Write]
    - ``current_spawn_set_name`` (str):  [Read-Write]
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``debug_nav_mesh_on_timeout`` (bool):  [Read-Write] if set, ftest will postpone start until navmesh is fully generated
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``description`` (str):  [Read-Write] A description of the test, like what is this test trying to determine.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_enabled_value`` (bool):  [Read-Write] Allows a test to be disabled.  If a test is disabled, it will not appear in the set of
      runnable tests (after saving the map).
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``log_error_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogErrors are handled during this test.
    - ``log_warning_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogWarnings are handled during this test.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``nav_mesh_debug_extent`` (Vector):  [Read-Write] navmesh debug: extent around NavMeshDebugOrigin
    - ``nav_mesh_debug_origin`` (Vector):  [Read-Write] navmesh debug: log navoctree modifiers around this point
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``observation_point`` (Actor):  [Read-Write] Allows you to specify another actor to view the test from.  Usually this is a camera you place
      in the map to observe the test.  Not useful when running on a build farm, but provides a handy
      way to observe the test from a different location than you place the functional test actor.
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_ai_spawned`` (FunctionalTestAISpawned):  [Read-Write] Called when a single AI finished spawning
    - ``on_all_ais_pawned`` (FunctionalTestEventSignature):  [Read-Write] Called when a all AI finished spawning
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``on_test_finished`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is finished. Use it to clean up
    - ``on_test_prepare`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is ready to prepare
    - ``on_test_start`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is started
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``pending_delayed_spawns`` (Array[PendingDelayedSpawn]):  [Read-Write]
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``preparation_time_limit`` (float):  [Read-Write] The Test's time limit for preparation, this is the time it has to return true when checking IsReady(). '0' means no limit.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``random_numbers_stream`` (RandomStream):  [Read-Write] A random number stream that you can use during testing.  This number stream will be consistent
      every time the test is run.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``result`` (FunctionalTestResult):  [Read-Write]
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``should_delay_garbage_collection`` (bool):  [Read-Write] Allows for garbage collection to be delayed. If delayed, garbage collection will be triggered at the end of a test run
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``spawn_location_randomization_range`` (float):  [Read-Write]
    - ``spawned_pawns`` (Array[Pawn]):  [Read-Write]
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``test_label`` (str):  [Read-Write]
    - ``time_limit`` (float):  [Read-Write] Test's time limit. '0' means no limit
    - ``times_up_message`` (Text):  [Read-Write]
    - ``times_up_result`` (FunctionalTestResult):  [Read-Write] If test is limited by time this is the result that will be returned when time runs out
    - ``total_time`` (float):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``wait_for_nav_mesh`` (bool):  [Read-Write] if set, ftest will postpone start until navmesh is fully generated
    """
    @property
    def spawn_location_randomization_range(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def spawned_pawns(self) -> Array[Pawn]:
        r"""
        (Array[Pawn]):  [Read-Only]
        """
        ...
    @property
    def pending_delayed_spawns(self) -> Array[PendingDelayedSpawn]:
        r"""
        (Array[PendingDelayedSpawn]):  [Read-Only]
        """
        ...
    @property
    def current_spawn_set_index(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def current_spawn_set_name(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def on_ai_spawned(self) -> FunctionalTestAISpawned:
        r"""
        (FunctionalTestAISpawned):  [Read-Write] Called when a single AI finished spawning
        """
        ...
    @on_ai_spawned.setter
    def on_ai_spawned(self, value: FunctionalTestAISpawned) -> None:
        ...
    @property
    def on_all_ais_pawned(self) -> FunctionalTestEventSignature:
        r"""
        (FunctionalTestEventSignature):  [Read-Write] Called when a all AI finished spawning
        """
        ...
    @on_all_ais_pawned.setter
    def on_all_ais_pawned(self, value: FunctionalTestEventSignature) -> None:
        ...
    @property
    def wait_for_nav_mesh(self) -> bool:
        r"""
        (bool):  [Read-Only] if set, ftest will postpone start until navmesh is fully generated
        """
        ...
    def is_one_of_spawned_pawns(self, actor: Actor) -> bool:
        r"""
        x.is_one_of_spawned_pawns(actor) -> bool
        Is One Of Spawned Pawns
        
        Args:
            actor (Actor): 
        
        Returns:
            bool:
        """
        ...

class FunctionalAITest(FunctionalAITestBase):
    r"""
    FuntionalAITest
    
    Functional AI Test using a regular FAITestSpawnSet as a default SpawnSet class type.
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalAITest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``author`` (str):  [Read-Write] The owner is the group or person responsible for the test. Generally you should use a group name
      like 'Editor' or 'Rendering'. When a test fails it may not be obvious who should investigate
      so this provides a associate responsible groups with tests.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``current_spawn_set_index`` (int32):  [Read-Write]
    - ``current_spawn_set_name`` (str):  [Read-Write]
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``debug_nav_mesh_on_timeout`` (bool):  [Read-Write] if set, ftest will postpone start until navmesh is fully generated
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``description`` (str):  [Read-Write] A description of the test, like what is this test trying to determine.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_enabled_value`` (bool):  [Read-Write] Allows a test to be disabled.  If a test is disabled, it will not appear in the set of
      runnable tests (after saving the map).
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``log_error_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogErrors are handled during this test.
    - ``log_warning_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogWarnings are handled during this test.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``nav_mesh_debug_extent`` (Vector):  [Read-Write] navmesh debug: extent around NavMeshDebugOrigin
    - ``nav_mesh_debug_origin`` (Vector):  [Read-Write] navmesh debug: log navoctree modifiers around this point
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``observation_point`` (Actor):  [Read-Write] Allows you to specify another actor to view the test from.  Usually this is a camera you place
      in the map to observe the test.  Not useful when running on a build farm, but provides a handy
      way to observe the test from a different location than you place the functional test actor.
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_ai_spawned`` (FunctionalTestAISpawned):  [Read-Write] Called when a single AI finished spawning
    - ``on_all_ais_pawned`` (FunctionalTestEventSignature):  [Read-Write] Called when a all AI finished spawning
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``on_test_finished`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is finished. Use it to clean up
    - ``on_test_prepare`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is ready to prepare
    - ``on_test_start`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is started
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``pending_delayed_spawns`` (Array[PendingDelayedSpawn]):  [Read-Write]
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``preparation_time_limit`` (float):  [Read-Write] The Test's time limit for preparation, this is the time it has to return true when checking IsReady(). '0' means no limit.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``random_numbers_stream`` (RandomStream):  [Read-Write] A random number stream that you can use during testing.  This number stream will be consistent
      every time the test is run.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``result`` (FunctionalTestResult):  [Read-Write]
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``should_delay_garbage_collection`` (bool):  [Read-Write] Allows for garbage collection to be delayed. If delayed, garbage collection will be triggered at the end of a test run
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``spawn_location_randomization_range`` (float):  [Read-Write]
    - ``spawn_sets`` (Array[AITestSpawnSet]):  [Read-Write]
    - ``spawned_pawns`` (Array[Pawn]):  [Read-Write]
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``test_label`` (str):  [Read-Write]
    - ``time_limit`` (float):  [Read-Write] Test's time limit. '0' means no limit
    - ``times_up_message`` (Text):  [Read-Write]
    - ``times_up_result`` (FunctionalTestResult):  [Read-Write] If test is limited by time this is the result that will be returned when time runs out
    - ``total_time`` (float):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``wait_for_nav_mesh`` (bool):  [Read-Write] if set, ftest will postpone start until navmesh is fully generated
    """
    @property
    def spawn_sets(self) -> Array[AITestSpawnSet]:
        r"""
        (Array[AITestSpawnSet]):  [Read-Only]
        """
        ...

class AutomationPerformaceHelper(Object):
    r"""
    Class for use with functional tests which provides various performance measuring features.
    Recording of basic, unintrusive performance stats.
    Automatic captures using external CPU and GPU profilers.
    Triggering and ending of writing full stats to a file.
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalTest.h
    
    """
    def write_log_file(self, capture_dir: str, capture_extension: str) -> None:
        r"""
        x.write_log_file(capture_dir, capture_extension) -> None
        Writes the current set of performance stats records to a csv file in the profiling directory. An additional directory and an extension override can also be used.
        
        Args:
            capture_dir (str): 
            capture_extension (str):
        """
        ...
    def trigger_gpu_trace_if_record_falls_below_budget(self) -> None:
        r"""
        x.trigger_gpu_trace_if_record_falls_below_budget() -> None
        Will trigger a GPU trace next time the current test falls below GPU budget.
        """
        ...
    def tick(self, delta_seconds: float) -> None:
        r"""
        x.tick(delta_seconds) -> None
        Begin basic stat recording
        
        Args:
            delta_seconds (float):
        """
        ...
    def stop_cpu_profiling(self) -> None:
        r"""
        x.stop_cpu_profiling() -> None
        Communicates with external profiler to end a CPU capture.
        """
        ...
    def start_cpu_profiling(self) -> None:
        r"""
        x.start_cpu_profiling() -> None
        Communicates with external profiler to being a CPU capture.
        """
        ...
    def sample(self, delta_seconds: float) -> None:
        r"""
        x.sample(delta_seconds) -> None
        Adds a sample to the stats counters for the current performance stats record.
        
        Args:
            delta_seconds (float):
        """
        ...
    def on_begin_tests(self) -> None:
        r"""
        x.on_begin_tests() -> None
        Does any init work across all tests..
        """
        ...
    def on_all_tests_complete(self) -> None:
        r"""
        x.on_all_tests_complete() -> None
        Does any final work needed as all tests are complete.
        """
        ...
    def is_recording(self) -> bool:
        r"""
        x.is_recording() -> bool
        Returns true if this stats tracker is currently recording performance stats.
        
        Returns:
            bool:
        """
        ...
    def is_current_record_within_render_thread_budget(self) -> bool:
        r"""
        x.is_current_record_within_render_thread_budget() -> bool
        Is Current Record Within Render Thread Budget
        
        Returns:
            bool:
        """
        ...
    def is_current_record_within_gpu_budget(self) -> bool:
        r"""
        x.is_current_record_within_gpu_budget() -> bool
        Is Current Record Within GPUBudget
        
        Returns:
            bool:
        """
        ...
    def is_current_record_within_game_thread_budget(self) -> bool:
        r"""
        x.is_current_record_within_game_thread_budget() -> bool
        Is Current Record Within Game Thread Budget
        
        Returns:
            bool:
        """
        ...
    def end_stats_file(self) -> None:
        r"""
        x.end_stats_file() -> None
        Ends recording stats to a file.
        """
        ...
    def end_recording_baseline(self) -> None:
        r"""
        x.end_recording_baseline() -> None
        Stops recording the baseline and moves to the main record.
        """
        ...
    def end_recording(self) -> None:
        r"""
        x.end_recording() -> None
        Stops recording performance stats.
        """
        ...
    def begin_stats_file(self, record_name: str) -> None:
        r"""
        x.begin_stats_file(record_name) -> None
        Begins recording stats to a file.
        
        Args:
            record_name (str):
        """
        ...
    def begin_recording_baseline(self, record_name: str) -> None:
        r"""
        x.begin_recording_baseline(record_name) -> None
        Begins recording a new named performance stats record. We start by recording the baseline
        
        Args:
            record_name (str):
        """
        ...
    def begin_recording(self, record_name: str, gpu_budget: float, render_thread_budget: float, game_thread_budget: float) -> None:
        r"""
        x.begin_recording(record_name, gpu_budget, render_thread_budget, game_thread_budget) -> None
        Begins recording a new named performance stats record. We start by recording the baseline.
        
        Args:
            record_name (str): 
            gpu_budget (float): 
            render_thread_budget (float): 
            game_thread_budget (float):
        """
        ...

class FunctionalTestGameMode(GameModeBase):
    r"""
    Functional Test Game Mode
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalTestGameMode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_pawn_class`` (type(Class)):  [Read-Write] The default pawn class used by players.
    - ``default_player_name`` (Text):  [Read-Write] The default player name assigned to players that join with no name specified.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``game_net_driver_replication_system`` (ReplicationSystem):  [Read-Write] Can be used to request a specific replication system for a GameNetDriver that will replicate this game mode.
      Leave to Default to use the game engine's preferred system.
      Useful when migrating from one repsystem to another and a game mode does not fully support both repsystem yet.
    - ``game_session_class`` (type(Class)):  [Read-Write] Class of GameSession, which handles login approval and online game interface
    - ``game_state_class`` (type(Class)):  [Read-Write] Class of GameState associated with this GameMode.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``hud_class`` (type(Class)):  [Read-Write] HUD class this game uses.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``options_string`` (str):  [Read-Write] Save options string and parse it when needed
    - ``pauseable`` (bool):  [Read-Write] Whether the game is pauseable.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_controller_class`` (type(Class)):  [Read-Write] The class of PlayerController to spawn for players logging in.
    - ``player_state_class`` (type(Class)):  [Read-Write] A PlayerState of this class will be associated with every player to replicate relevant player information to all clients.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replay_spectator_player_controller_class`` (type(Class)):  [Read-Write] The PlayerController class used when spectating a network replay.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``server_stat_replicator_class`` (type(Class)):  [Read-Write]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``spectator_class`` (type(Class)):  [Read-Write] The pawn class used by the PlayerController for players when spectating.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``start_players_as_spectators`` (bool):  [Read-Write] Whether players should immediately spawn when logging in, or stay as spectators until they manually spawn
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_seamless_travel`` (bool):  [Read-Write] Whether the game perform map travels using SeamlessTravel() which loads in the background and doesn't disconnect clients
    """
    ...

class FunctionalTestingManager(BlueprintFunctionLibrary):
    r"""
    Functional Testing Manager
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalTestingManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_setup_tests`` (FunctionalTestEventSignature):  [Read-Write]
    - ``on_tests_begin`` (FunctionalTestEventSignature):  [Read-Write]
    - ``on_tests_complete`` (FunctionalTestEventSignature):  [Read-Write]
    """
    @property
    def on_setup_tests(self) -> FunctionalTestEventSignature:
        r"""
        (FunctionalTestEventSignature):  [Read-Write]
        """
        ...
    @on_setup_tests.setter
    def on_setup_tests(self, value: FunctionalTestEventSignature) -> None:
        ...
    @property
    def on_tests_complete(self) -> FunctionalTestEventSignature:
        r"""
        (FunctionalTestEventSignature):  [Read-Write]
        """
        ...
    @on_tests_complete.setter
    def on_tests_complete(self, value: FunctionalTestEventSignature) -> None:
        ...
    @property
    def on_tests_begin(self) -> FunctionalTestEventSignature:
        r"""
        (FunctionalTestEventSignature):  [Read-Write]
        """
        ...
    @on_tests_begin.setter
    def on_tests_begin(self, value: FunctionalTestEventSignature) -> None:
        ...
    @classmethod
    def run_all_functional_tests(cls, world_context_object: Object, new_log: bool = True, run_looped: bool = False, failed_tests_repro_string: str = "") -> bool:
        r"""
        X.run_all_functional_tests(world_context_object, new_log=True, run_looped=False, failed_tests_repro_string="") -> bool
        Triggers in sequence all functional tests found on the level.
        
        Args:
            world_context_object (Object): 
            new_log (bool): 
            run_looped (bool): 
            failed_tests_repro_string (str): 
        
        Returns:
            bool: true if any tests have been triggered
        """
        ...

class PhasedAutomationActorBase(Actor):
    r"""
    Phased Automation Actor Base
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalTestingManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    def on_functional_testing_complete(self) -> None:
        r"""
        x.on_functional_testing_complete() -> None
        On Functional Testing Complete
        """
        ...
    def on_functional_testing_begin(self) -> None:
        r"""
        x.on_functional_testing_begin() -> None
        On Functional Testing Begin
        """
        ...

class FunctionalTestLevelScript(LevelScriptActor):
    r"""
    Functional Test Level Script
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalTestLevelScript.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class FunctionalTestUtilityLibrary(BlueprintFunctionLibrary):
    r"""
    Used to expose C++ functions to tests that we don't want to make BP accessible
    in the engine itself.
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalTestUtilityLibrary.h
    
    """
    @classmethod
    def trace_channel_test_util(cls, world_context_object: Object, batch_options: TraceChannelTestBatchOptions, start: Vector, end: Vector, sphere_capsule_radius: float, capsule_half_height: float, box_half_size: Vector, orientation: Rotator, trace_channel: TraceTypeQuery, object_types: Array[ObjectTypeQuery], profile_name: Name, trace_complex: bool, actors_to_ignore: Array[Actor], ignore_self: bool = True, draw_debug_type: DrawDebugTrace = ..., trace_color: LinearColor = [1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color: LinearColor = [0.000000, 1.000000, 0.000000, 1.000000], draw_time: float = 5.000000) -> TraceQueryTestResults:
        r"""
        X.trace_channel_test_util(world_context_object, batch_options, start, end, sphere_capsule_radius, capsule_half_height, box_half_size, orientation, trace_channel, object_types, profile_name, trace_complex, actors_to_ignore, ignore_self=True, draw_debug_type, trace_color=[1.000000, 0.000000, 0.000000, 1.000000], trace_hit_color=[0.000000, 1.000000, 0.000000, 1.000000], draw_time=5.000000) -> TraceQueryTestResults
        Helper function to trace and permute many options at once
        
        Args:
            world_context_object (Object): 
            batch_options (TraceChannelTestBatchOptions): 
            start (Vector): 
            end (Vector): 
            sphere_capsule_radius (float): 
            capsule_half_height (float): 
            box_half_size (Vector): 
            orientation (Rotator): 
            trace_channel (TraceTypeQuery): 
            object_types (Array[ObjectTypeQuery]): 
            profile_name (Name): 
            trace_complex (bool): 
            actors_to_ignore (Array[Actor]): 
            ignore_self (bool): 
            draw_debug_type (DrawDebugTrace): 
            trace_color (LinearColor): 
            trace_hit_color (LinearColor): 
            draw_time (float): 
        
        Returns:
            TraceQueryTestResults:
        """
        ...

class ScreenshotFunctionalTestBase(FunctionalTest):
    r"""
    Base class for screenshot functional test
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: ScreenshotFunctionalTestBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``author`` (str):  [Read-Write] The owner is the group or person responsible for the test. Generally you should use a group name
      like 'Editor' or 'Rendering'. When a test fails it may not be obvious who should investigate
      so this provides a associate responsible groups with tests.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``description`` (str):  [Read-Write] A description of the test, like what is this test trying to determine.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_enabled_value`` (bool):  [Read-Write] Allows a test to be disabled.  If a test is disabled, it will not appear in the set of
      runnable tests (after saving the map).
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``log_error_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogErrors are handled during this test.
    - ``log_warning_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogWarnings are handled during this test.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``notes`` (str):  [Read-Write]
    - ``observation_point`` (Actor):  [Read-Write] Allows you to specify another actor to view the test from.  Usually this is a camera you place
      in the map to observe the test.  Not useful when running on a build farm, but provides a handy
      way to observe the test from a different location than you place the functional test actor.
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``on_test_finished`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is finished. Use it to clean up
    - ``on_test_prepare`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is ready to prepare
    - ``on_test_start`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is started
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``preparation_time_limit`` (float):  [Read-Write] The Test's time limit for preparation, this is the time it has to return true when checking IsReady(). '0' means no limit.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``random_numbers_stream`` (RandomStream):  [Read-Write] A random number stream that you can use during testing.  This number stream will be consistent
      every time the test is run.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``result`` (FunctionalTestResult):  [Read-Write]
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``screenshot_camera`` (CameraComponent):  [Read-Write]
    - ``screenshot_options`` (AutomationScreenshotOptions):  [Read-Write]
    - ``should_delay_garbage_collection`` (bool):  [Read-Write] Allows for garbage collection to be delayed. If delayed, garbage collection will be triggered at the end of a test run
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``test_label`` (str):  [Read-Write]
    - ``time_limit`` (float):  [Read-Write] Test's time limit. '0' means no limit
    - ``times_up_message`` (Text):  [Read-Write]
    - ``times_up_result`` (FunctionalTestResult):  [Read-Write] If test is limited by time this is the result that will be returned when time runs out
    - ``total_time`` (float):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def notes(self) -> str:
        r"""
        (str):  [Read-Only]
        """
        ...
    @property
    def screenshot_camera(self) -> CameraComponent:
        r"""
        (CameraComponent):  [Read-Only]
        """
        ...
    @property
    def screenshot_options(self) -> AutomationScreenshotOptions:
        r"""
        (AutomationScreenshotOptions):  [Read-Only]
        """
        ...

class FunctionalUIScreenshotTest(ScreenshotFunctionalTestBase):
    r"""
    Functional UIScreenshot Test
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: FunctionalUIScreenshotTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``author`` (str):  [Read-Write] The owner is the group or person responsible for the test. Generally you should use a group name
      like 'Editor' or 'Rendering'. When a test fails it may not be obvious who should investigate
      so this provides a associate responsible groups with tests.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``description`` (str):  [Read-Write] A description of the test, like what is this test trying to determine.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hide_debug_canvas`` (bool):  [Read-Write]
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_enabled_value`` (bool):  [Read-Write] Allows a test to be disabled.  If a test is disabled, it will not appear in the set of
      runnable tests (after saving the map).
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``log_error_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogErrors are handled during this test.
    - ``log_warning_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogWarnings are handled during this test.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``notes`` (str):  [Read-Write]
    - ``observation_point`` (Actor):  [Read-Write] Allows you to specify another actor to view the test from.  Usually this is a camera you place
      in the map to observe the test.  Not useful when running on a build farm, but provides a handy
      way to observe the test from a different location than you place the functional test actor.
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``on_test_finished`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is finished. Use it to clean up
    - ``on_test_prepare`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is ready to prepare
    - ``on_test_start`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is started
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``preparation_time_limit`` (float):  [Read-Write] The Test's time limit for preparation, this is the time it has to return true when checking IsReady(). '0' means no limit.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``random_numbers_stream`` (RandomStream):  [Read-Write] A random number stream that you can use during testing.  This number stream will be consistent
      every time the test is run.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``result`` (FunctionalTestResult):  [Read-Write]
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``screenshot_camera`` (CameraComponent):  [Read-Write]
    - ``screenshot_options`` (AutomationScreenshotOptions):  [Read-Write]
    - ``should_delay_garbage_collection`` (bool):  [Read-Write] Allows for garbage collection to be delayed. If delayed, garbage collection will be triggered at the end of a test run
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``test_label`` (str):  [Read-Write]
    - ``time_limit`` (float):  [Read-Write] Test's time limit. '0' means no limit
    - ``times_up_message`` (Text):  [Read-Write]
    - ``times_up_result`` (FunctionalTestResult):  [Read-Write] If test is limited by time this is the result that will be returned when time runs out
    - ``total_time`` (float):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``widget_class`` (type(Class)):  [Read-Write]
    - ``widget_location`` (WidgetTestAppearLocation):  [Read-Write]
    """
    ...

class GroundTruthData(Object):
    r"""
    Ground Truth Data
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: GroundTruthData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``object_data`` (Object):  [Read-Only]
    - ``reset_ground_truth`` (bool):  [Read-Write]
    """
    def save_object(self, ground_truth: Object) -> None:
        r"""
        x.save_object(ground_truth) -> None
        Save Object
        
        Args:
            ground_truth (Object):
        """
        ...
    def reset_object(self) -> None:
        r"""
        x.reset_object() -> None
        Reset Object
        """
        ...
    def load_object(self) -> Object:
        r"""
        x.load_object() -> Object
        Load Object
        
        Returns:
            Object:
        """
        ...
    def can_modify(self) -> bool:
        r"""
        x.can_modify() -> bool
        Can Modify
        
        Returns:
            bool:
        """
        ...

class ScreenshotFunctionalTest(ScreenshotFunctionalTestBase):
    r"""
    No UI
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: ScreenshotFunctionalTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``author`` (str):  [Read-Write] The owner is the group or person responsible for the test. Generally you should use a group name
      like 'Editor' or 'Rendering'. When a test fails it may not be obvious who should investigate
      so this provides a associate responsible groups with tests.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``camera_cut_on_screenshot_prep`` (bool):  [Read-Write] Tests not relying on temporal effects can force a camera cut to flush stale data
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``description`` (str):  [Read-Write] A description of the test, like what is this test trying to determine.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_enabled_value`` (bool):  [Read-Write] Allows a test to be disabled.  If a test is disabled, it will not appear in the set of
      runnable tests (after saving the map).
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``log_error_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogErrors are handled during this test.
    - ``log_warning_handling`` (FunctionalTestLogHandling):  [Read-Write] Determines how LogWarnings are handled during this test.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``notes`` (str):  [Read-Write]
    - ``observation_point`` (Actor):  [Read-Write] Allows you to specify another actor to view the test from.  Usually this is a camera you place
      in the map to observe the test.  Not useful when running on a build farm, but provides a handy
      way to observe the test from a different location than you place the functional test actor.
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``on_test_finished`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is finished. Use it to clean up
    - ``on_test_prepare`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is ready to prepare
    - ``on_test_start`` (FunctionalTestEventSignature):  [Read-Write] Called when the test is started
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``preparation_time_limit`` (float):  [Read-Write] The Test's time limit for preparation, this is the time it has to return true when checking IsReady(). '0' means no limit.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``random_numbers_stream`` (RandomStream):  [Read-Write] A random number stream that you can use during testing.  This number stream will be consistent
      every time the test is run.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``result`` (FunctionalTestResult):  [Read-Write]
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``screenshot_camera`` (CameraComponent):  [Read-Write]
    - ``screenshot_options`` (AutomationScreenshotOptions):  [Read-Write]
    - ``should_delay_garbage_collection`` (bool):  [Read-Write] Allows for garbage collection to be delayed. If delayed, garbage collection will be triggered at the end of a test run
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``test_label`` (str):  [Read-Write]
    - ``time_limit`` (float):  [Read-Write] Test's time limit. '0' means no limit
    - ``times_up_message`` (Text):  [Read-Write]
    - ``times_up_result`` (FunctionalTestResult):  [Read-Write] If test is limited by time this is the result that will be returned when time runs out
    - ``total_time`` (float):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def camera_cut_on_screenshot_prep(self) -> bool:
        r"""
        (bool):  [Read-Write] Tests not relying on temporal effects can force a camera cut to flush stale data
        """
        ...
    @camera_cut_on_screenshot_prep.setter
    def camera_cut_on_screenshot_prep(self, value: bool) -> None:
        ...

class TestPhaseComponent(SceneComponent):
    r"""
    Test Phase Component
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: TestPhaseComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class TraceQueryTestResults(Object):
    r"""
    Trace Query Test Results
    
    **C++ Source:**
    
    - **Module**: FunctionalTesting
    - **File**: TraceQueryTestResults.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``batch_options`` (TraceChannelTestBatchOptions):  [Read-Write]
    - ``channel_results`` (TraceQueryTestResultsInner):  [Read-Write] Results for channel trace
    - ``object_results`` (TraceQueryTestResultsInner):  [Read-Write] Results for object trace
    - ``profile_results`` (TraceQueryTestResultsInner):  [Read-Write] Results for profile trace
    """
    @property
    def channel_results(self) -> TraceQueryTestResultsInner:
        r"""
        (TraceQueryTestResultsInner):  [Read-Write] Results for channel trace
        """
        ...
    @channel_results.setter
    def channel_results(self, value: TraceQueryTestResultsInner) -> None:
        ...
    @property
    def object_results(self) -> TraceQueryTestResultsInner:
        r"""
        (TraceQueryTestResultsInner):  [Read-Write] Results for object trace
        """
        ...
    @object_results.setter
    def object_results(self, value: TraceQueryTestResultsInner) -> None:
        ...
    @property
    def profile_results(self) -> TraceQueryTestResultsInner:
        r"""
        (TraceQueryTestResultsInner):  [Read-Write] Results for profile trace
        """
        ...
    @profile_results.setter
    def profile_results(self, value: TraceQueryTestResultsInner) -> None:
        ...
    @property
    def batch_options(self) -> TraceChannelTestBatchOptions:
        r"""
        (TraceChannelTestBatchOptions):  [Read-Write]
        """
        ...
    @batch_options.setter
    def batch_options(self, value: TraceChannelTestBatchOptions) -> None:
        ...
    def to_string(self) -> str:
        r"""
        x.to_string() -> str
        Output string value
        
        Returns:
            str:
        """
        ...

class BehaviorTreeFactory(Factory):
    r"""
    Behavior Tree Factory
    
    **C++ Source:**
    
    - **Module**: BehaviorTreeEditor
    - **File**: BehaviorTreeFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class BlackboardDataFactory(Factory):
    r"""
    Blackboard Data Factory
    
    **C++ Source:**
    
    - **Module**: BehaviorTreeEditor
    - **File**: BlackboardDataFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class Overlays(Object):
    r"""
    An interface class for creating overlay data assets
    
    **C++ Source:**
    
    - **Module**: Overlay
    - **File**: Overlays.h
    
    """
    ...

class BasicOverlays(Overlays):
    r"""
    Implements an asset that contains a set of overlay data (which includes timing, text, and position) to be displayed for any
    given source (including, but not limited to, audio, dialog, and movies)
    
    **C++ Source:**
    
    - **Module**: Overlay
    - **File**: BasicOverlays.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only] The import data used to make this overlays asset
    - ``overlays`` (Array[OverlayItem]):  [Read-Write] The overlay data held by this asset. Contains info on timing, position, and the subtitle to display
    """
    ...

class LocalizedOverlays(Overlays):
    r"""
    Implements an asset that contains a set of Basic Overlays that will be displayed in accordance with
    the current locale, or a default set if an appropriate locale is not found
    
    **C++ Source:**
    
    - **Module**: Overlay
    - **File**: LocalizedOverlays.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only] The import data used to make this overlays asset
    - ``default_overlays`` (BasicOverlays):  [Read-Write] The overlays to use if no overlays are found for the current culture
    - ``locale_to_overlays_map`` (Map[str, BasicOverlays]):  [Read-Write] Maps a set of cultures to specific BasicOverlays assets.
      Cultures are comprised of three hyphen-separated parts:
                   A two-letter ISO 639-1 language code (e.g., "zh")
                   An optional four-letter ISO 15924 script code (e.g., "Hans")
                   An optional two-letter ISO 3166-1 country code  (e.g., "CN")
    """
    ...

class BasicOverlaysFactory(Factory):
    r"""
    Implements a factory for UBasicOverlays objects.
    
    **C++ Source:**
    
    - **Module**: OverlayEditor
    - **File**: BasicOverlaysFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class BasicOverlaysFactoryNew(Factory):
    r"""
    Implements a factory for new UBasicOverlays objects.
    
    **C++ Source:**
    
    - **Module**: OverlayEditor
    - **File**: BasicOverlaysFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class LocalizedOverlaysFactoryNew(Factory):
    r"""
    Implements a factory for new ULocalizedOverlays objects.
    
    **C++ Source:**
    
    - **Module**: OverlayEditor
    - **File**: LocalizedOverlaysFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ReimportBasicOverlaysFactory(BasicOverlaysFactory):
    r"""
    A factory for reimporting basic overlays
    
    **C++ Source:**
    
    - **Module**: OverlayEditor
    - **File**: ReimportBasicOverlaysFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ClothingSimulationInteractorNv(ClothingSimulationInteractor):
    r"""
    Clothing Simulation Interactor Nv
    
    **C++ Source:**
    
    - **Module**: ClothingSystemRuntimeNv
    - **File**: ClothingSimulationInteractorNv.h
    
    """
    def set_anim_drive_damper_stiffness(self, stiffness: float) -> None:
        r"""
        x.set_anim_drive_damper_stiffness(stiffness) -> None
        Set the stiffness of the resistive damping force for anim drive
        
        Args:
            stiffness (float):
        """
        ...

class AnimDataController(Object):
    r"""
    Anim Data Controller
    
    **C++ Source:**
    
    - **Module**: AnimationDataController
    - **File**: AnimDataController.h
    
    """
    def update_curve_names_from_skeleton(self, skeleton: Skeleton, supported_curve_type: RawCurveTrackTypes, should_transact: bool = True) -> None:
        r"""
        x.update_curve_names_from_skeleton(skeleton, supported_curve_type, should_transact=True) -> None
        Update Curve Names from Skeleton
        deprecated: This function is no longer used.
        
        Args:
            skeleton (Skeleton): 
            supported_curve_type (RawCurveTrackTypes): 
            should_transact (bool):
        """
        ...
    def set_transform_curve_keys(self, curve_id: AnimationCurveIdentifier, transform_values: Array[Transform], time_keys: Array[float], should_transact: bool = True) -> bool:
        r"""
        x.set_transform_curve_keys(curve_id, transform_values, time_keys, should_transact=True) -> bool
        Replace the keys for the transform curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the transform curve for which the keys are to be set
            transform_values (Array[Transform]): Transform Values with which the existing values are to be replaced
            time_keys (Array[float]): Time Keys with which the existing keys are to be replaced
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the transform curve keys were successfully set
        """
        ...
    def set_transform_curve_key(self, curve_id: AnimationCurveIdentifier, time: float, value: Transform, should_transact: bool = True) -> bool:
        r"""
        x.set_transform_curve_key(curve_id, time, value, should_transact=True) -> bool
        Sets a single key for the transform curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        In case a key for any of the individual transform channel curves already exists the value is replaced.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the transform curve for which the key is to be set
            time (float): Time of the key to be set
            value (Transform): Value of the key to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the transform curve key was successfully set
        """
        ...
    def set_play_length(self, length: float, should_transact: bool = True) -> None:
        r"""
        x.set_play_length(length, should_transact=True) -> None
        Set Play Length
        deprecated: SetPlayLength is deprecated use SetNumberOfFrames instead.
        
        Args:
            length (float): 
            should_transact (bool):
        """
        ...
    def set_number_of_frames(self, new_length_in_frames: FrameNumber, should_transact: bool = True) -> None:
        r"""
        x.set_number_of_frames(new_length_in_frames, should_transact=True) -> None
        Sets the total play-able length in seconds. Broadcasts a EAnimDataModelNotifyType::SequenceLengthChanged notify if successful.
        The number of frames and keys for the provided length is recalculated according to the current value of UAnimDataModel::FrameRate.
        
        Args:
            new_length_in_frames (FrameNumber): Total new play-able number of frames value (according to frame rate), has to be positive and non-zero
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def set_model(self, model: AnimationDataModel) -> None:
        r"""
        x.set_model(model) -> None
        Sets the AnimDataModel instance this controller is supposed to be targeting
        
        Args:
            model (AnimationDataModel): IAnimationDataModel instance to target
        """
        ...
    def set_frame_rate(self, frame_rate: FrameRate, should_transact: bool = True) -> None:
        r"""
        x.set_frame_rate(frame_rate, should_transact=True) -> None
        Sets the frame rate according to which the bone animation is expected to be sampled. Broadcasts a EAnimDataModelNotifyType::FrameRateChanged notify if successful.
        The number of frames and keys for the provided frame rate is recalculated according to the current value of UAnimDataModel::PlayLength.
        
        Args:
            frame_rate (FrameRate): The new sampling frame rate, has to be positive and non-zero
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def set_curve_keys(self, curve_id: AnimationCurveIdentifier, curve_keys: Array[RichCurveKey], should_transact: bool = True) -> bool:
        r"""
        x.set_curve_keys(curve_id, curve_keys, should_transact=True) -> bool
        Replace the keys for the curve with provided identifier and name. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the keys are to be replaced
            curve_keys (Array[RichCurveKey]): Keys with which the existing keys are to be replaced
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not replacing curve keys was successful
        """
        ...
    def set_curve_key(self, curve_id: AnimationCurveIdentifier, key: RichCurveKey, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_key(curve_id, key, should_transact=True) -> bool
        Sets a single key for the curve with provided identifier and name. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        In case a key for the provided key time already exists the key is replaced.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the key is to be set
            key (RichCurveKey): Key to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve key was successfully set
        """
        ...
    def set_curve_flags(self, curve_id: AnimationCurveIdentifier, flags: int, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_flags(curve_id, flags, should_transact=True) -> bool
        Replace the flags for the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveFlagsChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the flag state is to be set
            flags (int32): Flag mask with which the existing flags are to be replaced
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the flag mask was successfully set
        """
        ...
    def set_curve_flag(self, curve_id: AnimationCurveIdentifier, flag: AnimAssetCurveFlags, state: bool = True, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_flag(curve_id, flag, state=True, should_transact=True) -> bool
        Set an individual flag for the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveFlagsChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the flag state is to be set
            flag (AnimAssetCurveFlags): Flag for which the state is supposed to be set
            state (bool): State of the flag to be, true=set/false=not set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the flag state was successfully set
        """
        ...
    def set_curve_comment(self, curve_id: AnimationCurveIdentifier, comment: str = "/**\n\t* Changes the comment of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveCommentChanged notify if successful.\n\t* Currently changing curve comments is only supported for float curves.\n\t*\n\t* @param\tCurveId\t\t\t\tIdentifier of the curve to change the comment for\n\t* @param\tComment\t\t\t\tComment to which the curve is to be set\n\t* @param\tbShouldTransact\t\tWhether or not any undo-redo changes should be generated\n\t*\n\t* @return\tWhether or not the curve comment was successfully changed\n\t*/", should_transact: bool = True) -> bool:
        r"""
        x.set_curve_comment(curve_id, comment="/**\n\t* Changes the comment of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveCommentChanged notify if successful.\n\t* Currently changing curve comments is only supported for float curves.\n\t*\n\t* @param\tCurveId\t\t\t\tIdentifier of the curve to change the comment for\n\t* @param\tComment\t\t\t\tComment to which the curve is to be set\n\t* @param\tbShouldTransact\t\tWhether or not any undo-redo changes should be generated\n\t*\n\t* @return\tWhether or not the curve comment was successfully changed\n\t*/", should_transact=True) -> bool
        Changes the comment of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveCommentChanged notify if successful.
        Currently changing curve comments is only supported for float curves.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier of the curve to change the comment for
            comment (str): Comment to which the curve is to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve comment was successfully changed
        """
        ...
    def set_curve_color(self, curve_id: AnimationCurveIdentifier, color: LinearColor, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_color(curve_id, color, should_transact=True) -> bool
        Changes the color of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveColorChanged notify if successful.
        Currently changing curve colors is only supported for float curves.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier of the curve to change the color for
            color (LinearColor): Color to which the curve is to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve color was successfully changed
        """
        ...
    def set_bone_track_keys(self, bone_name: Name, positional_keys: Array[Vector], rotational_keys: Array[Quat], scaling_keys: Array[Vector], should_transact: bool = True) -> bool:
        r"""
        x.set_bone_track_keys(bone_name, positional_keys, rotational_keys, scaling_keys, should_transact=True) -> bool
        Removes an existing bone animation track with the provided name. Broadcasts a EAnimDataModelNotifyType::TrackChanged notify if successful.
        The provided number of keys provided is expected to match for each component, and be non-zero.
        
        Args:
            bone_name (Name): Bone name of the track for which the keys should be set
            positional_keys (Array[Vector]): Array of keys for the translation component
            rotational_keys (Array[Quat]): Array of keys for the rotation component
            scaling_keys (Array[Vector]): Array of keys for the scale component
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the keys were successfully set
        """
        ...
    def scale_curve(self, curve_id: AnimationCurveIdentifier, origin: float, factor: float, should_transact: bool = True) -> bool:
        r"""
        x.scale_curve(curve_id, origin, factor, should_transact=True) -> bool
        Scales the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveScaled notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier of the curve to scale
            origin (float): Time to use as the origin when scaling the curve
            factor (float): Factor with which the curve is supposed to be scaled
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not scaling the curve was successful
        """
        ...
    def resize_play_length(self, new_length: float, t0: float, t1: float, should_transact: bool = True) -> None:
        r"""
        x.resize_play_length(new_length, t0, t1, should_transact=True) -> None
        Resize Play Length
        deprecated: ResizePlayLength is deprecated use ResizeNumberOfFrames instead.
        
        Args:
            new_length (float): 
            t0 (float): 
            t1 (float): 
            should_transact (bool):
        """
        ...
    def resize_number_of_frames(self, new_length_in_frames: FrameNumber, t0: FrameNumber, t1: FrameNumber, should_transact: bool = True) -> None:
        r"""
        x.resize_number_of_frames(new_length_in_frames, t0, t1, should_transact=True) -> None
        Sets the total play-able length in seconds. Broadcasts a EAnimDataModelNotifyType::SequenceLengthChanged notify if successful.
        T0 and T1 are expected to represent the window of time that was either added or removed. E.g. for insertion T0 indicates the time
        at which additional time starts and T1 were it ends. For removal T0 indicates the time at which time should be started to remove, and T1 indicates the end. Giving a total of T1 - T0 added or removed length.
        The number of frames and keys for the provided length is recalculated according to the current value of UAnimDataModel::FrameRate.
        
        Args:
            new_length_in_frames (FrameNumber): Total new play-able number of frames value (according to frame rate), has to be positive and non-zero
            t0 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length starts
            t1 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length ends
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def resize_in_frames(self, new_length_in_frames: FrameNumber, t0: FrameNumber, t1: FrameNumber, should_transact: bool = True) -> None:
        r"""
        x.resize_in_frames(new_length_in_frames, t0, t1, should_transact=True) -> None
        Sets the total play-able length in seconds and resizes curves. Broadcasts EAnimDataModelNotifyType::SequenceLengthChanged
        and EAnimDataModelNotifyType::CurveChanged notifies if successful.
        T0 and T1 are expected to represent the window of time that was either added or removed. E.g. for insertion T0 indicates the time
        at which additional time starts and T1 were it ends. For removal T0 indicates the time at which time should be started to remove, and T1 indicates the end. Giving a total of T1 - T0 added or removed length.
        The number of frames and keys for the provided length is recalculated according to the current value of UAnimDataModel::FrameRate.
        
        Args:
            new_length_in_frames (FrameNumber): Total new play-able number of frames value (according to frame rate), has to be positive and non-zero
            t0 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length starts
            t1 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length ends
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def resize(self, length: float, t0: float, t1: float, should_transact: bool = True) -> None:
        r"""
        x.resize(length, t0, t1, should_transact=True) -> None
        Resize
        deprecated: Resize is deprecated use ResizeInFrames instead.
        
        Args:
            length (float): 
            t0 (float): 
            t1 (float): 
            should_transact (bool):
        """
        ...
    def rename_curve(self, curve_to_rename_id: AnimationCurveIdentifier, new_curve_id: AnimationCurveIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.rename_curve(curve_to_rename_id, new_curve_id, should_transact=True) -> bool
        Renames the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveRenamed notify if successful.
        
        Args:
            curve_to_rename_id (AnimationCurveIdentifier): Identifier for the curve to be renamed
            new_curve_id (AnimationCurveIdentifier): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully renamed
        """
        ...
    def remove_transform_curve_key(self, curve_id: AnimationCurveIdentifier, time: float, should_transact: bool = True) -> bool:
        r"""
        x.remove_transform_curve_key(curve_id, time, should_transact=True) -> bool
        Removes a single key for the transform curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the transform curve for which the key is to be removed
            time (float): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the transform curve key was successfully removed
        """
        ...
    def remove_curve_key(self, curve_id: AnimationCurveIdentifier, time: float, should_transact: bool = True) -> bool:
        r"""
        x.remove_curve_key(curve_id, time, should_transact=True) -> bool
        Remove a single key from the curve with provided identifier and name. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the key is to be removed
            time (float): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve key was successfully removed
        """
        ...
    def remove_curve(self, curve_id: AnimationCurveIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.remove_curve(curve_id, should_transact=True) -> bool
        Remove the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveRemoved notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the to-be-removed curve
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully removed
        """
        ...
    def remove_bone_track(self, bone_name: Name, should_transact: bool = True) -> bool:
        r"""
        x.remove_bone_track(bone_name, should_transact=True) -> bool
        Removes an existing bone animation track with the provided name. Broadcasts a EAnimDataModelNotifyType::TrackRemoved notify if successful.
        
        Args:
            bone_name (Name): Bone name of the track which should be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the removal was successful
        """
        ...
    def remove_attribute_key(self, attribute_identifier: AnimationAttributeIdentifier, time: float, should_transact: bool = True) -> bool:
        r"""
        x.remove_attribute_key(attribute_identifier, time, should_transact=True) -> bool
        Remove a single key from the attribute with provided identifier. Broadcasts a EAnimDataModelNotifyType::AttributeChanged notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the attribute from which the key is to be removed
            time (float): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute key was successfully removed
        """
        ...
    def remove_attribute(self, attribute_identifier: AnimationAttributeIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.remove_attribute(attribute_identifier, should_transact=True) -> bool
        Removes an attribute, if found, with the provided information. Broadcasts a EAnimDataModelNotifyType::AttributeRemoved notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-removed attribute
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute was successfully removed
        """
        ...
    def remove_all_curves_of_type(self, supported_curve_type: RawCurveTrackTypes, should_transact: bool = True) -> None:
        r"""
        x.remove_all_curves_of_type(supported_curve_type, should_transact=True) -> None
        Removes all the curves of the provided type. Broadcasts a EAnimDataModelNotifyType::CurveRemoved for each removed curve, wrapped within BracketOpened/BracketClosed notifies.
        
        Args:
            supported_curve_type (RawCurveTrackTypes): Type for which all curves are to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def remove_all_bone_tracks(self, should_transact: bool = True) -> None:
        r"""
        x.remove_all_bone_tracks(should_transact=True) -> None
        Removes all existing Bone Animation tracks. Broadcasts a EAnimDataModelNotifyType::TrackRemoved for each removed track, wrapped within BracketOpened/BracketClosed notifies.
        
        Args:
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def remove_all_attributes_for_bone(self, bone_name: Name, should_transact: bool = True) -> int:
        r"""
        x.remove_all_attributes_for_bone(bone_name, should_transact=True) -> int32
        Removes all attributes for the specified bone name, if any. Broadcasts a EAnimDataModelNotifyType::AttributeRemoved notify for each removed attribute.
        
        Args:
            bone_name (Name): Name of the bone to remove attributes for
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            int32: Total number of removes attributes
        """
        ...
    def remove_all_attributes(self, should_transact: bool = True) -> int:
        r"""
        x.remove_all_attributes(should_transact=True) -> int32
        Removes all stored attributes. Broadcasts a EAnimDataModelNotifyType::AttributeRemoved notify for each removed attribute.
        
        Args:
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            int32: Total number of removes attributes
        """
        ...
    def open_bracket(self, title: Text, should_transact: bool = True) -> None:
        r"""
        x.open_bracket(title, should_transact=True) -> None
        Opens an interaction bracket, used for combining a set of controller actions. Broadcasts a EAnimDataModelNotifyType::BracketOpened notify,
        this can be used by any Views or dependent systems to halt any unnecessary or invalid operations until the (last) bracket is closed.
        
        Args:
            title (Text): Description of the bracket, e.g. "Generating Curve Data"
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def insert_bone_track(self, bone_name: Name, desired_index: int, should_transact: bool = True) -> int:
        r"""
        x.insert_bone_track(bone_name, desired_index, should_transact=True) -> int32
        Insert Bone Track
        deprecated: InsertBoneTrack is deprecated use AddBoneTrack instead.
        
        Args:
            bone_name (Name): 
            desired_index (int32): 
            should_transact (bool): 
        
        Returns:
            int32:
        """
        ...
    def get_model_interface(self) -> AnimationDataModel:
        r"""
        x.get_model_interface() -> AnimationDataModel
        
        
        Returns:
            AnimationDataModel: The IAnimationDataModel instance this controller is currently targeting
        """
        ...
    def find_or_add_curve_names_on_skeleton(self, skeleton: Skeleton, supported_curve_type: RawCurveTrackTypes, should_transact: bool = True) -> None:
        r"""
        x.find_or_add_curve_names_on_skeleton(skeleton, supported_curve_type, should_transact=True) -> None
        Find or Add Curve Names on Skeleton
        deprecated: This function is no longer used.
        
        Args:
            skeleton (Skeleton): 
            supported_curve_type (RawCurveTrackTypes): 
            should_transact (bool):
        """
        ...
    def duplicate_curve(self, copy_curve_id: AnimationCurveIdentifier, new_curve_id: AnimationCurveIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.duplicate_curve(copy_curve_id, new_curve_id, should_transact=True) -> bool
        Duplicated the curve with the identifier. Broadcasts a EAnimDataModelNotifyType::CurveAdded notify if successful.
        
        Args:
            copy_curve_id (AnimationCurveIdentifier): Identifier for the to-be-duplicated curve
            new_curve_id (AnimationCurveIdentifier): Identifier for the to-be-added curve
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully duplicated
        """
        ...
    def duplicate_attribute(self, attribute_identifier: AnimationAttributeIdentifier, new_attribute_identifier: AnimationAttributeIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.duplicate_attribute(attribute_identifier, new_attribute_identifier, should_transact=True) -> bool
        Duplicated the attribute (curve) with the identifier. Broadcasts a EAnimDataModelNotifyType::AttributeAdded notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-duplicated attribute
            new_attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-added attribute
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute was successfully duplicated
        """
        ...
    def close_bracket(self, should_transact: bool = True) -> None:
        r"""
        x.close_bracket(should_transact=True) -> None
        Closes a previously opened interaction bracket, used for combining a set of controller actions. Broadcasts a EAnimDataModelNotifyType::BracketClosed notify.
        
        Args:
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def add_curve(self, curve_id: AnimationCurveIdentifier, curve_flags: int = 4, should_transact: bool = True) -> bool:
        r"""
        x.add_curve(curve_id, curve_flags=4, should_transact=True) -> bool
        Adds a new curve with the provided information. Broadcasts a EAnimDataModelNotifyType::CurveAdded notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the to-be-added curve
            curve_flags (int32): Flags to be set for the curve
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully added
        """
        ...
    def add_bone_track(self, bone_name: Name, should_transact: bool = True) -> int:
        r"""
        x.add_bone_track(bone_name, should_transact=True) -> int32
        Add Bone Track
        deprecated: AddBoneTrack returning index is deprecated use AddBoneCurve returning bool instead.
        
        Args:
            bone_name (Name): 
            should_transact (bool): 
        
        Returns:
            int32:
        """
        ...
    def add_bone_curve(self, bone_name: Name, should_transact: bool = True) -> bool:
        r"""
        x.add_bone_curve(bone_name, should_transact=True) -> bool
        Add Bone Curve
        
        Args:
            bone_name (Name): 
            should_transact (bool): 
        
        Returns:
            bool:
        """
        ...
    def add_attribute(self, attribute_identifier: AnimationAttributeIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.add_attribute(attribute_identifier, should_transact=True) -> bool
        Adds a new attribute with the provided information. Broadcasts a EAnimDataModelNotifyType::AttributeAdded notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-added attribute
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute was successfully added
        """
        ...

class HLODLayerFactory(Factory):
    r"""
    HLODLayer Factory
    
    **C++ Source:**
    
    - **Module**: WorldPartitionEditor
    - **File**: HLODLayerFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AndroidFileServerBPLibrary(BlueprintFunctionLibrary):
    r"""
    Android File Server BPLibrary
    
    **C++ Source:**
    
    - **Plugin**: AndroidFileServer
    - **Module**: AndroidFileServer
    - **File**: AndroidFileServerBPLibrary.h
    
    """
    @classmethod
    def stop_file_server(cls, usb: bool = True, network: bool = True) -> bool:
        r"""
        X.stop_file_server(usb=True, network=True) -> bool
        Request termination of Android FileServer
        
        Args:
            usb (bool): 
            network (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def start_file_server(cls, usb: bool = True, network: bool = False, port: int = 57099) -> bool:
        r"""
        X.start_file_server(usb=True, network=False, port=57099) -> bool
        Request startup of Android FileServer
        
        Args:
            usb (bool): 
            network (bool): 
            port (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_file_server_running(cls) -> AFSActiveType:
        r"""
        X.is_file_server_running() -> AFSActiveType
        Check if Android FileServer is running
        
        Returns:
            AFSActiveType:
        """
        ...

class EnhancedPlayerMappableKeyProfile(Object):
    r"""
    Represents one "Profile" that a user can have for their player mappable keys
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The localized display name of this profile
    - ``owning_user_id`` (PlatformUserId):  [Read-Only] The platform user id of the owning Local Player of this profile.
    - ``player_mapped_keys`` (Map[Name, KeyMappingRow]):  [Read-Write] A map of "Mapping Row Name" to all key mappings associated with it.
      Note: Dirty mappings will be serialized from UEnhancedInputUserSettings::Serialize
    - ``profile_identifier`` (GameplayTag):  [Read-Write] The ID of this profile. This can be used by each Key Mapping to filter down which profile is required for it be equipped.
    """
    @property
    def profile_identifier(self) -> GameplayTag:
        r"""
        (GameplayTag):  [Read-Only] The ID of this profile. This can be used by each Key Mapping to filter down which profile is required for it be equipped.
        """
        ...
    @property
    def owning_user_id(self) -> PlatformUserId:
        r"""
        (PlatformUserId):  [Read-Only] The platform user id of the owning Local Player of this profile.
        """
        ...
    @property
    def display_name(self) -> Text:
        r"""
        (Text):  [Read-Write] The localized display name of this profile
        """
        ...
    @display_name.setter
    def display_name(self, value: Text) -> None:
        ...
    @property
    def player_mapped_keys(self) -> Map[Name, KeyMappingRow]:
        r"""
        (Map[Name, KeyMappingRow]):  [Read-Only] A map of "Mapping Row Name" to all key mappings associated with it.
        Note: Dirty mappings will be serialized from UEnhancedInputUserSettings::Serialize
        """
        ...
    def to_string(self) -> str:
        r"""
        x.to_string() -> str
        Returns a string that can be used to debug the current key mappings.
        
        Returns:
            str:
        """
        ...
    def set_display_name(self, new_display_name: Text) -> None:
        r"""
        x.set_display_name(new_display_name) -> None
        Set Display Name
        
        Args:
            new_display_name (Text):
        """
        ...
    def reset_to_default(self) -> None:
        r"""
        x.reset_to_default() -> None
        Resets all the key mappings in this profile to their default value from their Input Mapping Context.
        """
        ...
    def reset_mapping_to_default(self, mapping_name: Name) -> None:
        r"""
        x.reset_mapping_to_default(mapping_name) -> None
        Resets every player key mapping to this mapping back to it's default value
        
        Args:
            mapping_name (Name):
        """
        ...
    def query_player_mapped_keys(self, options: PlayerMappableKeyQueryOptions) -> Tuple[int, Array[Key]]:
        r"""
        x.query_player_mapped_keys(options) -> (int32, out_keys=Array[Key])
        OUT
        
        Args:
            options (PlayerMappableKeyQueryOptions): 
        
        Returns:
            Array[Key]: 
        
            out_keys (Array[Key]):
        """
        ...
    def k2_find_key_mapping(self, args: MapPlayerKeyArgs) -> PlayerKeyMapping:
        r"""
        x.k2_find_key_mapping(args) -> PlayerKeyMapping
        K2 Find Key Mapping
        
        Args:
            args (MapPlayerKeyArgs): 
        
        Returns:
            PlayerKeyMapping: 
        
            out_key_mapping (PlayerKeyMapping):
        """
        ...
    def get_profile_identifer(self) -> GameplayTag:
        r"""
        x.get_profile_identifer() -> GameplayTag
        Get Profile Identifer
        
        Returns:
            GameplayTag:
        """
        ...
    def get_profile_display_name(self) -> Text:
        r"""
        x.get_profile_display_name() -> Text
        Get the localized display name for this profile
        
        Returns:
            Text:
        """
        ...
    def get_player_mapping_rows(self) -> Map[Name, KeyMappingRow]:
        r"""
        x.get_player_mapping_rows() -> Map[Name, KeyMappingRow]
        Get all known key mappings for this profile.
        
        This returns a map of "Mapping Name" -> Player Mappings to that name
        
        Returns:
            Map[Name, KeyMappingRow]:
        """
        ...
    def get_mapping_names_for_key(self, key: Key) -> Tuple[int, Array[Name]]:
        r"""
        x.get_mapping_names_for_key(key) -> (int32, out_mapping_names=Array[Name])
        OUT
        
        Args:
            key (Key): 
        
        Returns:
            Array[Name]: 
        
            out_mapping_names (Array[Name]):
        """
        ...
    def get_mapped_keys_in_row(self, mapping_name: Name) -> Tuple[int, Array[Key]]:
        r"""
        x.get_mapped_keys_in_row(mapping_name) -> (int32, out_keys=Array[Key])
        OUT
        
        Args:
            mapping_name (Name): 
        
        Returns:
            Array[Key]: 
        
            out_keys (Array[Key]):
        """
        ...
    def dump_profile_to_log(self) -> None:
        r"""
        x.dump_profile_to_log() -> None
        A helper function to print out all the current profile settings to the log.
        """
        ...
    def does_mapping_pass_query_options(self, player_mapping: PlayerKeyMapping, options: PlayerMappableKeyQueryOptions) -> bool:
        r"""
        x.does_mapping_pass_query_options(player_mapping, options) -> bool
        Returns true if the given player key mapping passes the query filter provided.
        
        Args:
            player_mapping (PlayerKeyMapping): 
            options (PlayerMappableKeyQueryOptions): 
        
        Returns:
            bool:
        """
        ...

class EnhancedInputUserSettings(SaveGame):
    r"""
    The Enhanced Input User Settings class is a place where you can put all of your Input Related settings
    that you want your user to be able to change. Things like their key mappings, aim sensitivity, accessibility
    settings, etc. This also provides a Registration point for Input Mappings Contexts (IMC) from possibly unloaded
    plugins (i.e. Game Feature Plugins). You can register your IMC from a Game Feature Action plugin here, and then
    have access to all the key mappings available. This is very useful for building settings screens because you can
    now access all the mappings in your game, even if the entire plugin isn't loaded yet.
    
    The user settings are stored on each UEnhancedPlayerInput object, so each instance of the settings can represent
    a single User or Local Player.
    
    To customize this for your game, you can create a subclass of it and change the "UserSettingsClass" in the
    Enhanced Input Project Settings.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_settings_applied`` (EnhancedInputUserSettingsApplied):  [Read-Write]
    - ``on_settings_changed`` (EnhancedInputUserSettingsChanged):  [Read-Write]
    """
    @property
    def on_settings_changed(self) -> EnhancedInputUserSettingsChanged:
        r"""
        (EnhancedInputUserSettingsChanged):  [Read-Write]
        """
        ...
    @on_settings_changed.setter
    def on_settings_changed(self, value: EnhancedInputUserSettingsChanged) -> None:
        ...
    @property
    def on_settings_applied(self) -> EnhancedInputUserSettingsApplied:
        r"""
        (EnhancedInputUserSettingsApplied):  [Read-Write]
        """
        ...
    @on_settings_applied.setter
    def on_settings_applied(self, value: EnhancedInputUserSettingsApplied) -> None:
        ...
    def unregister_input_mapping_contexts(self, mapping_contexts: Set[InputMappingContext]) -> bool:
        r"""
        x.unregister_input_mapping_contexts(mapping_contexts) -> bool
        Removes multiple mapping contexts from the registered mapping contexts
        
        Args:
            mapping_contexts (Set[InputMappingContext]): 
        
        Returns:
            bool:
        """
        ...
    def unregister_input_mapping_context(self, imc: InputMappingContext) -> bool:
        r"""
        x.unregister_input_mapping_context(imc) -> bool
        Removes this mapping context from the registered mapping contexts
        
        Args:
            imc (InputMappingContext): 
        
        Returns:
            bool:
        """
        ...
    def un_map_player_key(self, args: MapPlayerKeyArgs) -> GameplayTagContainer:
        r"""
        x.un_map_player_key(args) -> GameplayTagContainer
        Unmaps a single player mapping that matches the given Mapping name, slot, and hardware device.
        
        Args:
            args (MapPlayerKeyArgs): 
        
        Returns:
            GameplayTagContainer: 
        
            failure_reason (GameplayTagContainer):
        """
        ...
    def set_key_profile(self, profile_id: GameplayTag) -> bool:
        r"""
        x.set_key_profile(profile_id) -> bool
        Changes the currently active key profile to the one with the given name. Returns true if the operation was successful.
        
        Args:
            profile_id (GameplayTag): 
        
        Returns:
            bool:
        """
        ...
    def save_settings(self) -> None:
        r"""
        x.save_settings() -> None
        Synchronously save the settings to a hardcoded save game slot. This will work for simple games,
        but if you need to integrate it into an advanced save system you should Serialize this object out with the rest of your save data.
        """
        ...
    def reset_key_profile_to_default(self, profile_id: GameplayTag) -> GameplayTagContainer:
        r"""
        x.reset_key_profile_to_default(profile_id) -> GameplayTagContainer
        Resets the given key profile to default key mappings
        
        Args:
            profile_id (GameplayTag): The ID of the key profile to reset
        
        Returns:
            GameplayTagContainer: 
        
            failure_reason (GameplayTagContainer): Populated with failure reasons if the operation fails.
        """
        ...
    def reset_all_player_keys_in_row(self, args: MapPlayerKeyArgs) -> GameplayTagContainer:
        r"""
        x.reset_all_player_keys_in_row(args) -> GameplayTagContainer
        Resets each player mapped key to it's default value from the Input Mapping Context that it was registered from.
        If a key did not come from an IMC (i.e. it was added additionally by the player) then it will be reset to EKeys::Invalid.
        
        Args:
            args (MapPlayerKeyArgs): Arguments that contain the mapping name and profile ID to find the mapping to reset.
        
        Returns:
            GameplayTagContainer: 
        
            failure_reason (GameplayTagContainer): Populated with failure reasons if the operation fails.
        """
        ...
    def register_input_mapping_contexts(self, mapping_contexts: Set[InputMappingContext]) -> bool:
        r"""
        x.register_input_mapping_contexts(mapping_contexts) -> bool
        Registers multiple mapping contexts with the settings
        
        Args:
            mapping_contexts (Set[InputMappingContext]): 
        
        Returns:
            bool:
        """
        ...
    def register_input_mapping_context(self, imc: InputMappingContext) -> bool:
        r"""
        x.register_input_mapping_context(imc) -> bool
        Registers this mapping context with the user settings. This will iterate all the key mappings
        in the context and create an initial Player Mappable Key for every mapping that is marked as mappable.
        
        Args:
            imc (InputMappingContext): 
        
        Returns:
            bool:
        """
        ...
    def map_player_key(self, args: MapPlayerKeyArgs) -> GameplayTagContainer:
        r"""
        x.map_player_key(args) -> GameplayTagContainer
        Sets the player mapped key on the current key profile.
        
        Args:
            args (MapPlayerKeyArgs): 
        
        Returns:
            GameplayTagContainer: 
        
            failure_reason (GameplayTagContainer):
        """
        ...
    def is_mapping_context_registered(self, imc: InputMappingContext) -> bool:
        r"""
        x.is_mapping_context_registered(imc) -> bool
        Returns true if this mapping context is currently registered with the settings
        
        Args:
            imc (InputMappingContext): 
        
        Returns:
            bool:
        """
        ...
    def get_key_profile_with_identifier(self, profile_id: GameplayTag) -> EnhancedPlayerMappableKeyProfile:
        r"""
        x.get_key_profile_with_identifier(profile_id) -> EnhancedPlayerMappableKeyProfile
        Returns the key profile with the given name if one exists. Null if one doesn't exist
        
        Args:
            profile_id (GameplayTag): 
        
        Returns:
            EnhancedPlayerMappableKeyProfile:
        """
        ...
    def get_current_key_profile_identifier(self) -> GameplayTag:
        r"""
        x.get_current_key_profile_identifier() -> GameplayTag
        Gets the currently selected key profile
        
        Returns:
            GameplayTag:
        """
        ...
    def get_current_key_profile(self) -> EnhancedPlayerMappableKeyProfile:
        r"""
        x.get_current_key_profile() -> EnhancedPlayerMappableKeyProfile
        Get the current key profile that the user has set
        
        Returns:
            EnhancedPlayerMappableKeyProfile:
        """
        ...
    def find_mappings_in_row(self, mapping_name: Name) -> Set[PlayerKeyMapping]:
        r"""
        x.find_mappings_in_row(mapping_name) -> Set[PlayerKeyMapping]
        Returns a set of all player key mappings for the given mapping name.
        
        Args:
            mapping_name (Name): 
        
        Returns:
            Set[PlayerKeyMapping]:
        """
        ...
    def create_new_key_profile(self, args: PlayerMappableKeyProfileCreationArgs) -> EnhancedPlayerMappableKeyProfile:
        r"""
        x.create_new_key_profile(args) -> EnhancedPlayerMappableKeyProfile
        Creates a new profile with this name and type.
        
        Args:
            args (PlayerMappableKeyProfileCreationArgs): 
        
        Returns:
            EnhancedPlayerMappableKeyProfile:
        """
        ...
    def async_save_settings(self) -> None:
        r"""
        x.async_save_settings() -> None
        Asynchronously save the settings to a hardcoded save game slot. This will work for simple games,
        but if you need to integrate it into an advanced save system you should Serialize this object out with the rest of your save data.
        
        OnAsyncSaveComplete will be called upon save completion.
        """
        ...
    def apply_settings(self) -> None:
        r"""
        x.apply_settings() -> None
        Apply any custom input settings to your user. By default, this will just broadcast the OnSettingsApplied delegate
        which is a useful hook to maybe rebuild some UI or do other user facing updates.
        """
        ...

class EnhancedInputComponent(InputComponent):
    r"""
    Implement an Actor component for input bindings.
    
    An Enhanced Input Component is a transient component that enables an Actor to bind enhanced actions to delegate functions, or monitor those actions.
    Input components are processed from a stack managed by the PlayerController and processed by the PlayerInput.
    These bindings will not consume input events, but this behaviour can be replicated using UInputMappingContext::Priority.
    see: https://docs.unrealengine.com/latest/INT/Gameplay/Input/index.html
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class EnhancedInputLibrary(BlueprintFunctionLibrary):
    r"""
    Enhanced Input Library
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputLibrary.h
    
    """
    @classmethod
    def request_rebuild_control_mappings_using_context(cls, context: InputMappingContext, force_immediately: bool = False) -> None:
        r"""
        X.request_rebuild_control_mappings_using_context(context, force_immediately=False) -> None
        Flag all enhanced input subsystems making use of the mapping context for reapplication of all control mappings at the end of this frame.
        
        Args:
            context (InputMappingContext): Mappings will be rebuilt for all subsystems utilizing this context.
            force_immediately (bool): The mapping changes will be applied synchronously, rather than at the end of the frame, making them available to the input system on the same frame.
        """
        ...
    @classmethod
    def is_action_key_mapping_player_mappable(cls, action_key_mapping: EnhancedActionKeyMapping) -> bool:
        r"""
        X.is_action_key_mapping_player_mappable(action_key_mapping) -> bool
        Returns true if this Action Key Mapping either holds a Player Mappable Key Settings or is set bIsPlayerMappable.
        
        Args:
            action_key_mapping (EnhancedActionKeyMapping): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_third_player_mappable_key_slot(cls) -> PlayerMappableKeySlotData:
        r"""
        X.get_third_player_mappable_key_slot() -> PlayerMappableKeySlotData
        Get Third Player Mappable Key Slot
        deprecated: FPlayerMappableKeyOptions has been deprecated. Please use UPlayerMappableKeySettings instead.
        
        Returns:
            PlayerMappableKeySlotData:
        """
        ...
    @classmethod
    def get_second_player_mappable_key_slot(cls) -> PlayerMappableKeySlotData:
        r"""
        X.get_second_player_mappable_key_slot() -> PlayerMappableKeySlotData
        Get Second Player Mappable Key Slot
        deprecated: FPlayerMappableKeyOptions has been deprecated. Please use UPlayerMappableKeySettings instead.
        
        Returns:
            PlayerMappableKeySlotData:
        """
        ...
    @classmethod
    def get_player_mappable_key_settings(cls, action_key_mapping: EnhancedActionKeyMapping) -> PlayerMappableKeySettings:
        r"""
        X.get_player_mappable_key_settings(action_key_mapping) -> PlayerMappableKeySettings
        Returns the Player Mappable Key Settings owned by the Action Key Mapping or by the referenced Input Action, or nothing based of the Setting Behavior.
        
        Args:
            action_key_mapping (EnhancedActionKeyMapping): 
        
        Returns:
            PlayerMappableKeySettings:
        """
        ...
    @classmethod
    def get_mapping_name(cls, action_key_mapping: EnhancedActionKeyMapping) -> Name:
        r"""
        X.get_mapping_name(action_key_mapping) -> Name
        Returns the name of the mapping based on setting behavior used. If no name is found in the Mappable Key Settings it will return the name set in Player Mappable Options if bIsPlayerMappable is true.
        
        Args:
            action_key_mapping (EnhancedActionKeyMapping): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def get_fourth_player_mappable_key_slot(cls) -> PlayerMappableKeySlotData:
        r"""
        X.get_fourth_player_mappable_key_slot() -> PlayerMappableKeySlotData
        Get Fourth Player Mappable Key Slot
        deprecated: FPlayerMappableKeyOptions has been deprecated. Please use UPlayerMappableKeySettings instead.
        
        Returns:
            PlayerMappableKeySlotData:
        """
        ...
    @classmethod
    def get_first_player_mappable_key_slot(cls) -> PlayerMappableKeySlotData:
        r"""
        X.get_first_player_mappable_key_slot() -> PlayerMappableKeySlotData
        Get First Player Mappable Key Slot
        deprecated: FPlayerMappableKeyOptions has been deprecated. Please use UPlayerMappableKeySettings instead.
        
        Returns:
            PlayerMappableKeySlotData:
        """
        ...
    @classmethod
    def conv_input_action_value_to_string(cls, action_value: InputActionValue) -> str:
        r"""
        X.conv_input_action_value_to_string(action_value) -> str
        Converts a FInputActionValue to a string
        
        Args:
            action_value (InputActionValue): 
        
        Returns:
            str:
        """
        ...

class EnhancedInputPlatformData(Object):
    r"""
    A base class that can be used to store platform specific data for Enhanced Input.
    
    Make a subclass of this to add some additional options for per-platform settings
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputPlatformSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``mapping_context_redirects`` (Map[InputMappingContext, InputMappingContext]):  [Read-Write] Maps one Input Mapping Context to another. This can be used to replace
      specific Input Mapping Contexts with another on a per-platform basis.
    """
    @property
    def mapping_context_redirects(self) -> Map[InputMappingContext, InputMappingContext]:
        r"""
        (Map[InputMappingContext, InputMappingContext]):  [Read-Only] Maps one Input Mapping Context to another. This can be used to replace
        specific Input Mapping Contexts with another on a per-platform basis.
        """
        ...
    def get_context_redirect(self, context: InputMappingContext) -> InputMappingContext:
        r"""
        x.get_context_redirect(context) -> InputMappingContext
        Returns a pointer to the desired redirect mapping context. If there isn't one, then this returns InContext.
        
        Args:
            context (InputMappingContext): 
        
        Returns:
            InputMappingContext:
        """
        ...

class EnhancedInputSubsystemInterface(Interface):
    r"""
    Enhanced Input Subsystem Interface
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputSubsystemInterface.h
    
    """
    def update_value_of_continuous_input_injection_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue) -> None:
        r"""
        x.update_value_of_continuous_input_injection_for_player_mapping(mapping_name, raw_value) -> None
        Update the value of a continuous input injection for the given player mapping name, preserving the state of triggers and modifiers.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
        """
        ...
    def update_value_of_continuous_input_injection_for_action(self, action: InputAction, raw_value: InputActionValue) -> None:
        r"""
        x.update_value_of_continuous_input_injection_for_action(action, raw_value) -> None
        Update the value of a continuous input injection, preserving the state of triggers and modifiers.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
        """
        ...
    def stop_continuous_input_injection_for_player_mapping(self, mapping_name: Name) -> None:
        r"""
        x.stop_continuous_input_injection_for_player_mapping(mapping_name) -> None
        Stops continuous input injection for the given player mapping name.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
        """
        ...
    def stop_continuous_input_injection_for_action(self, action: InputAction) -> None:
        r"""
        x.stop_continuous_input_injection_for_action(action) -> None
        Stops continuous input injection for the given action.
        
        Args:
            action (InputAction): The action to stop injecting input for
        """
        ...
    def start_continuous_input_injection_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.start_continuous_input_injection_for_player_mapping(mapping_name, raw_value, modifiers, triggers) -> None
        Starts simulation of input via injection. This injects the given input every tick until it is stopped with StopContinuousInputInjectionForAction.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def start_continuous_input_injection_for_action(self, action: InputAction, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.start_continuous_input_injection_for_action(action, raw_value, modifiers, triggers) -> None
        Starts simulation of input via injection. This injects the given input every tick until it is stopped with StopContinuousInputInjectionForAction.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def request_rebuild_control_mappings(self, options: ModifyContextOptions = [True, False, False], rebuild_type: InputMappingRebuildType = InputMappingRebuildType.REBUILD) -> None:
        r"""
        x.request_rebuild_control_mappings(options=[True, False, False], rebuild_type=InputMappingRebuildType.REBUILD) -> None
        Flag player for reapplication of all mapping contexts at the end of this frame.
        This is called automatically when adding or removing mappings contexts.
        
        Args:
            options (ModifyContextOptions): Options to consider when removing this input mapping context
            rebuild_type (InputMappingRebuildType):
        """
        ...
    def remove_player_mappable_config(self, config: PlayerMappableInputConfig, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_player_mappable_config(config, options=[True, False, False]) -> None
        Remove Player Mappable Config
        deprecated: RemovePlayerMappableConfig has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            config (PlayerMappableInputConfig): 
            options (ModifyContextOptions):
        """
        ...
    def remove_mapping_context(self, mapping_context: InputMappingContext, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_mapping_context(mapping_context, options=[True, False, False]) -> None
        Remove a specific control context.
        This is safe to call even if the context is not applied.
        
        Args:
            mapping_context (InputMappingContext): Context to remove from the player
            options (ModifyContextOptions): Options to consider when removing this input mapping context
        """
        ...
    def remove_all_player_mapped_keys_for_mapping(self, mapping_name: Name, options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.remove_all_player_mapped_keys_for_mapping(mapping_name, options=[True, False, False]) -> int32
        Remove All Player Mapped Keys for Mapping
        deprecated: RemoveAllPlayerMappedKeysForMapping has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            options (ModifyContextOptions): 
        
        Returns:
            int32:
        """
        ...
    def remove_all_player_mapped_keys(self, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_all_player_mapped_keys(options=[True, False, False]) -> None
        Remove All Player Mapped Keys
        deprecated: RemoveAllPlayerMappedKeys has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            options (ModifyContextOptions):
        """
        ...
    def query_map_key_in_context_set(self, prioritized_active_contexts: Array[InputMappingContext], input_context: InputMappingContext, action: InputAction, key: Key, blocking_issues: MappingQueryIssueFlag) -> Tuple[MappingQueryResult, Array[MappingQueryIssue]]:
        r"""
        x.query_map_key_in_context_set(prioritized_active_contexts, input_context, action, key, blocking_issues) -> (MappingQueryResult, out_issues=Array[MappingQueryIssue])
        = DefaultMappingIssues::StandardFatal
        
        Args:
            prioritized_active_contexts (Array[InputMappingContext]): 
            input_context (InputMappingContext): 
            action (InputAction): 
            key (Key): 
            blocking_issues (MappingQueryIssueFlag): 
        
        Returns:
            Array[MappingQueryIssue]: 
        
            out_issues (Array[MappingQueryIssue]):
        """
        ...
    def query_map_key_in_active_context_set(self, input_context: InputMappingContext, action: InputAction, key: Key, blocking_issues: MappingQueryIssueFlag) -> Tuple[MappingQueryResult, Array[MappingQueryIssue]]:
        r"""
        x.query_map_key_in_active_context_set(input_context, action, key, blocking_issues) -> (MappingQueryResult, out_issues=Array[MappingQueryIssue])
        = DefaultMappingIssues::StandardFatal
        
        Args:
            input_context (InputMappingContext): 
            action (InputAction): 
            key (Key): 
            blocking_issues (MappingQueryIssueFlag): 
        
        Returns:
            Array[MappingQueryIssue]: 
        
            out_issues (Array[MappingQueryIssue]):
        """
        ...
    def query_keys_mapped_to_action(self, action: InputAction) -> Array[Key]:
        r"""
        x.query_keys_mapped_to_action(action) -> Array[Key]
        Returns the keys mapped to the given action in the active input mapping contexts.
        
        Args:
            action (InputAction): 
        
        Returns:
            Array[Key]:
        """
        ...
    def k2_remove_player_mapped_key_in_slot(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.k2_remove_player_mapped_key_in_slot(mapping_name, key_slot=[0], options=[True, False, False]) -> int32
        Removes player mapped key in the KeySlot for mapping of MappingName.
        Requests a rebuild of the player mappings.
        deprecated: K2_RemovePlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            key_slot (PlayerMappableKeySlotData): 
            options (ModifyContextOptions): 
        
        Returns:
            int32: The number of mappings that have been removed
        """
        ...
    def remove_player_mapped_key(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        deprecated: 'remove_player_mapped_key' was renamed to 'k2_remove_player_mapped_key_in_slot'.
        """
        ...
    def k2_get_player_mapped_key_in_slot(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0]) -> Key:
        r"""
        x.k2_get_player_mapped_key_in_slot(mapping_name, key_slot=[0]) -> Key
        K2 Get Player Mapped Key in Slot
        deprecated: K2_GetPlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            key_slot (PlayerMappableKeySlotData): 
        
        Returns:
            Key:
        """
        ...
    def get_player_mapped_key(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0]) -> Key:
        r"""
        deprecated: 'get_player_mapped_key' was renamed to 'k2_get_player_mapped_key_in_slot'.
        """
        ...
    def k2_add_player_mapped_key_in_slot(self, mapping_name: Name, new_key: Key, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.k2_add_player_mapped_key_in_slot(mapping_name, new_key, key_slot=[0], options=[True, False, False]) -> int32
        K2 Add Player Mapped Key in Slot
        deprecated: AddPlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            new_key (Key): 
            key_slot (PlayerMappableKeySlotData): 
            options (ModifyContextOptions): 
        
        Returns:
            int32:
        """
        ...
    def add_player_mapped_key(self, mapping_name: Name, new_key: Key, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        deprecated: 'add_player_mapped_key' was renamed to 'k2_add_player_mapped_key_in_slot'.
        """
        ...
    def inject_input_vector_for_player_mapping(self, mapping_name: Name, value: Vector, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_vector_for_player_mapping(mapping_name, value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            value (Vector): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_vector_for_action(self, action: InputAction, value: Vector, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_vector_for_action(action, value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            value (Vector): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_for_player_mapping(mapping_name, raw_value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_for_action(self, action: InputAction, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_for_action(action, raw_value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def has_mapping_context(self, mapping_context: InputMappingContext) -> Optional[int]:
        r"""
        x.has_mapping_context(mapping_context) -> int32 or None
        Check if a mapping context is applied to this subsystem's owner.
        
        Args:
            mapping_context (InputMappingContext): The mapping context to search for on the subsystem's owner.
        
        Returns:
            int32 or None: True if the mapping context is applied
        
            out_found_priority (int32): The priority of the mapping context if it is applied. -1 if the context is not applied
        """
        ...
    def get_user_settings(self) -> EnhancedInputUserSettings:
        r"""
        x.get_user_settings() -> EnhancedInputUserSettings
        Get User Settings
        
        Returns:
            EnhancedInputUserSettings:
        """
        ...
    def get_all_player_mapped_keys(self, mapping_name: Name) -> Array[Key]:
        r"""
        x.get_all_player_mapped_keys(mapping_name) -> Array[Key]
        Get All Player Mapped Keys
        deprecated: GetAllPlayerMappedKeys has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
        
        Returns:
            Array[Key]:
        """
        ...
    def get_all_player_mappable_action_key_mappings(self) -> Array[EnhancedActionKeyMapping]:
        r"""
        x.get_all_player_mappable_action_key_mappings() -> Array[EnhancedActionKeyMapping]
        Get an array of the currently applied key mappings that are marked as Player Mappable.
        
        Returns:
            Array[EnhancedActionKeyMapping]:
        """
        ...
    def clear_all_mappings(self) -> None:
        r"""
        x.clear_all_mappings() -> None
        Remove all applied mapping contexts.
        """
        ...
    def add_player_mappable_config(self, config: PlayerMappableInputConfig, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.add_player_mappable_config(config, options=[True, False, False]) -> None
        Add Player Mappable Config
        deprecated: AddPlayerMappableConfig has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            config (PlayerMappableInputConfig): 
            options (ModifyContextOptions):
        """
        ...
    def add_mapping_context(self, mapping_context: InputMappingContext, priority: int, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.add_mapping_context(mapping_context, priority, options=[True, False, False]) -> None
        Add a control mapping context.
        
        Args:
            mapping_context (InputMappingContext): A set of key to action mappings to apply to this player
            priority (int32): Higher priority mappings will be applied first and, if they consume input, will block lower priority mappings.
            options (ModifyContextOptions): Options to consider when adding this mapping context.
        """
        ...

class LocalPlayerSubsystem(Subsystem):
    r"""
    ULocalPlayerSubsystem
    Base class for auto instanced and initialized subsystem that share the lifetime of local players
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LocalPlayerSubsystem.h
    
    """
    ...

class EnhancedInputLocalPlayerSubsystem(LocalPlayerSubsystem):
    r"""
    Per local player input subsystem
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputSubsystems.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control_mappings_rebuilt_delegate`` (OnControlMappingsRebuilt):  [Read-Write] Blueprint Event that is called at the end of any frame that Control Mappings have been rebuilt.
    """
    @property
    def control_mappings_rebuilt_delegate(self) -> OnControlMappingsRebuilt:
        r"""
        (OnControlMappingsRebuilt):  [Read-Write] Blueprint Event that is called at the end of any frame that Control Mappings have been rebuilt.
        """
        ...
    @control_mappings_rebuilt_delegate.setter
    def control_mappings_rebuilt_delegate(self, value: OnControlMappingsRebuilt) -> None:
        ...
    def update_value_of_continuous_input_injection_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue) -> None:
        r"""
        x.update_value_of_continuous_input_injection_for_player_mapping(mapping_name, raw_value) -> None
        Update the value of a continuous input injection for the given player mapping name, preserving the state of triggers and modifiers.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
        """
        ...
    def update_value_of_continuous_input_injection_for_action(self, action: InputAction, raw_value: InputActionValue) -> None:
        r"""
        x.update_value_of_continuous_input_injection_for_action(action, raw_value) -> None
        Update the value of a continuous input injection, preserving the state of triggers and modifiers.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
        """
        ...
    def stop_continuous_input_injection_for_player_mapping(self, mapping_name: Name) -> None:
        r"""
        x.stop_continuous_input_injection_for_player_mapping(mapping_name) -> None
        Stops continuous input injection for the given player mapping name.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
        """
        ...
    def stop_continuous_input_injection_for_action(self, action: InputAction) -> None:
        r"""
        x.stop_continuous_input_injection_for_action(action) -> None
        Stops continuous input injection for the given action.
        
        Args:
            action (InputAction): The action to stop injecting input for
        """
        ...
    def start_continuous_input_injection_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.start_continuous_input_injection_for_player_mapping(mapping_name, raw_value, modifiers, triggers) -> None
        Starts simulation of input via injection. This injects the given input every tick until it is stopped with StopContinuousInputInjectionForAction.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def start_continuous_input_injection_for_action(self, action: InputAction, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.start_continuous_input_injection_for_action(action, raw_value, modifiers, triggers) -> None
        Starts simulation of input via injection. This injects the given input every tick until it is stopped with StopContinuousInputInjectionForAction.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def request_rebuild_control_mappings(self, options: ModifyContextOptions = [True, False, False], rebuild_type: InputMappingRebuildType = InputMappingRebuildType.REBUILD) -> None:
        r"""
        x.request_rebuild_control_mappings(options=[True, False, False], rebuild_type=InputMappingRebuildType.REBUILD) -> None
        Flag player for reapplication of all mapping contexts at the end of this frame.
        This is called automatically when adding or removing mappings contexts.
        
        Args:
            options (ModifyContextOptions): Options to consider when removing this input mapping context
            rebuild_type (InputMappingRebuildType):
        """
        ...
    def remove_player_mappable_config(self, config: PlayerMappableInputConfig, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_player_mappable_config(config, options=[True, False, False]) -> None
        Remove Player Mappable Config
        deprecated: RemovePlayerMappableConfig has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            config (PlayerMappableInputConfig): 
            options (ModifyContextOptions):
        """
        ...
    def remove_mapping_context(self, mapping_context: InputMappingContext, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_mapping_context(mapping_context, options=[True, False, False]) -> None
        Remove a specific control context.
        This is safe to call even if the context is not applied.
        
        Args:
            mapping_context (InputMappingContext): Context to remove from the player
            options (ModifyContextOptions): Options to consider when removing this input mapping context
        """
        ...
    def remove_all_player_mapped_keys_for_mapping(self, mapping_name: Name, options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.remove_all_player_mapped_keys_for_mapping(mapping_name, options=[True, False, False]) -> int32
        Remove All Player Mapped Keys for Mapping
        deprecated: RemoveAllPlayerMappedKeysForMapping has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            options (ModifyContextOptions): 
        
        Returns:
            int32:
        """
        ...
    def remove_all_player_mapped_keys(self, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_all_player_mapped_keys(options=[True, False, False]) -> None
        Remove All Player Mapped Keys
        deprecated: RemoveAllPlayerMappedKeys has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            options (ModifyContextOptions):
        """
        ...
    def query_map_key_in_context_set(self, prioritized_active_contexts: Array[InputMappingContext], input_context: InputMappingContext, action: InputAction, key: Key, blocking_issues: MappingQueryIssueFlag) -> Tuple[MappingQueryResult, Array[MappingQueryIssue]]:
        r"""
        x.query_map_key_in_context_set(prioritized_active_contexts, input_context, action, key, blocking_issues) -> (MappingQueryResult, out_issues=Array[MappingQueryIssue])
        = DefaultMappingIssues::StandardFatal
        
        Args:
            prioritized_active_contexts (Array[InputMappingContext]): 
            input_context (InputMappingContext): 
            action (InputAction): 
            key (Key): 
            blocking_issues (MappingQueryIssueFlag): 
        
        Returns:
            Array[MappingQueryIssue]: 
        
            out_issues (Array[MappingQueryIssue]):
        """
        ...
    def query_map_key_in_active_context_set(self, input_context: InputMappingContext, action: InputAction, key: Key, blocking_issues: MappingQueryIssueFlag) -> Tuple[MappingQueryResult, Array[MappingQueryIssue]]:
        r"""
        x.query_map_key_in_active_context_set(input_context, action, key, blocking_issues) -> (MappingQueryResult, out_issues=Array[MappingQueryIssue])
        = DefaultMappingIssues::StandardFatal
        
        Args:
            input_context (InputMappingContext): 
            action (InputAction): 
            key (Key): 
            blocking_issues (MappingQueryIssueFlag): 
        
        Returns:
            Array[MappingQueryIssue]: 
        
            out_issues (Array[MappingQueryIssue]):
        """
        ...
    def query_keys_mapped_to_action(self, action: InputAction) -> Array[Key]:
        r"""
        x.query_keys_mapped_to_action(action) -> Array[Key]
        Returns the keys mapped to the given action in the active input mapping contexts.
        
        Args:
            action (InputAction): 
        
        Returns:
            Array[Key]:
        """
        ...
    def k2_remove_player_mapped_key_in_slot(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.k2_remove_player_mapped_key_in_slot(mapping_name, key_slot=[0], options=[True, False, False]) -> int32
        Removes player mapped key in the KeySlot for mapping of MappingName.
        Requests a rebuild of the player mappings.
        deprecated: K2_RemovePlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            key_slot (PlayerMappableKeySlotData): 
            options (ModifyContextOptions): 
        
        Returns:
            int32: The number of mappings that have been removed
        """
        ...
    def remove_player_mapped_key(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        deprecated: 'remove_player_mapped_key' was renamed to 'k2_remove_player_mapped_key_in_slot'.
        """
        ...
    def k2_get_player_mapped_key_in_slot(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0]) -> Key:
        r"""
        x.k2_get_player_mapped_key_in_slot(mapping_name, key_slot=[0]) -> Key
        K2 Get Player Mapped Key in Slot
        deprecated: K2_GetPlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            key_slot (PlayerMappableKeySlotData): 
        
        Returns:
            Key:
        """
        ...
    def get_player_mapped_key(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0]) -> Key:
        r"""
        deprecated: 'get_player_mapped_key' was renamed to 'k2_get_player_mapped_key_in_slot'.
        """
        ...
    def k2_add_player_mapped_key_in_slot(self, mapping_name: Name, new_key: Key, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.k2_add_player_mapped_key_in_slot(mapping_name, new_key, key_slot=[0], options=[True, False, False]) -> int32
        K2 Add Player Mapped Key in Slot
        deprecated: AddPlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            new_key (Key): 
            key_slot (PlayerMappableKeySlotData): 
            options (ModifyContextOptions): 
        
        Returns:
            int32:
        """
        ...
    def add_player_mapped_key(self, mapping_name: Name, new_key: Key, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        deprecated: 'add_player_mapped_key' was renamed to 'k2_add_player_mapped_key_in_slot'.
        """
        ...
    def inject_input_vector_for_player_mapping(self, mapping_name: Name, value: Vector, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_vector_for_player_mapping(mapping_name, value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            value (Vector): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_vector_for_action(self, action: InputAction, value: Vector, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_vector_for_action(action, value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            value (Vector): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_for_player_mapping(mapping_name, raw_value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_for_action(self, action: InputAction, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_for_action(action, raw_value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def has_mapping_context(self, mapping_context: InputMappingContext) -> Optional[int]:
        r"""
        x.has_mapping_context(mapping_context) -> int32 or None
        Check if a mapping context is applied to this subsystem's owner.
        
        Args:
            mapping_context (InputMappingContext): The mapping context to search for on the subsystem's owner.
        
        Returns:
            int32 or None: True if the mapping context is applied
        
            out_found_priority (int32): The priority of the mapping context if it is applied. -1 if the context is not applied
        """
        ...
    def get_user_settings(self) -> EnhancedInputUserSettings:
        r"""
        x.get_user_settings() -> EnhancedInputUserSettings
        Get User Settings
        
        Returns:
            EnhancedInputUserSettings:
        """
        ...
    def get_all_player_mapped_keys(self, mapping_name: Name) -> Array[Key]:
        r"""
        x.get_all_player_mapped_keys(mapping_name) -> Array[Key]
        Get All Player Mapped Keys
        deprecated: GetAllPlayerMappedKeys has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
        
        Returns:
            Array[Key]:
        """
        ...
    def get_all_player_mappable_action_key_mappings(self) -> Array[EnhancedActionKeyMapping]:
        r"""
        x.get_all_player_mappable_action_key_mappings() -> Array[EnhancedActionKeyMapping]
        Get an array of the currently applied key mappings that are marked as Player Mappable.
        
        Returns:
            Array[EnhancedActionKeyMapping]:
        """
        ...
    def clear_all_mappings(self) -> None:
        r"""
        x.clear_all_mappings() -> None
        Remove all applied mapping contexts.
        """
        ...
    def add_player_mappable_config(self, config: PlayerMappableInputConfig, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.add_player_mappable_config(config, options=[True, False, False]) -> None
        Add Player Mappable Config
        deprecated: AddPlayerMappableConfig has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            config (PlayerMappableInputConfig): 
            options (ModifyContextOptions):
        """
        ...
    def add_mapping_context(self, mapping_context: InputMappingContext, priority: int, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.add_mapping_context(mapping_context, priority, options=[True, False, False]) -> None
        Add a control mapping context.
        
        Args:
            mapping_context (InputMappingContext): A set of key to action mappings to apply to this player
            priority (int32): Higher priority mappings will be applied first and, if they consume input, will block lower priority mappings.
            options (ModifyContextOptions): Options to consider when adding this mapping context.
        """
        ...

class EnhancedInputWorldSubsystem(WorldSubsystem):
    r"""
    Per world input subsystem that allows you to bind input delegates to actors without an owning Player Controller.
    This should be used when an actor needs to receive input delegates but will never have an owning Player Controller.
    For example, you can add input delegates to unlock a door when the user has a certain set of keys pressed.
    Be sure to enable input on the actor, or else the input delegates won't fire!
    
    Note: if you do have an actor with an owning Player Controller use the local player input subsystem instead.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedInputSubsystems.h
    
    """
    def remove_actor_input_component(self, actor: Actor) -> bool:
        r"""
        x.remove_actor_input_component(actor) -> bool
        Removes this Actor's input component from the stack to be processed by this subsystem's tick function
        
        Args:
            actor (Actor): 
        
        Returns:
            bool:
        """
        ...
    def add_actor_input_component(self, actor: Actor) -> None:
        r"""
        x.add_actor_input_component(actor) -> None
        Adds this Actor's input component onto the stack to be processed by this subsystem's tick function
        
        Args:
            actor (Actor):
        """
        ...
    def update_value_of_continuous_input_injection_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue) -> None:
        r"""
        x.update_value_of_continuous_input_injection_for_player_mapping(mapping_name, raw_value) -> None
        Update the value of a continuous input injection for the given player mapping name, preserving the state of triggers and modifiers.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
        """
        ...
    def update_value_of_continuous_input_injection_for_action(self, action: InputAction, raw_value: InputActionValue) -> None:
        r"""
        x.update_value_of_continuous_input_injection_for_action(action, raw_value) -> None
        Update the value of a continuous input injection, preserving the state of triggers and modifiers.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
        """
        ...
    def stop_continuous_input_injection_for_player_mapping(self, mapping_name: Name) -> None:
        r"""
        x.stop_continuous_input_injection_for_player_mapping(mapping_name) -> None
        Stops continuous input injection for the given player mapping name.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
        """
        ...
    def stop_continuous_input_injection_for_action(self, action: InputAction) -> None:
        r"""
        x.stop_continuous_input_injection_for_action(action) -> None
        Stops continuous input injection for the given action.
        
        Args:
            action (InputAction): The action to stop injecting input for
        """
        ...
    def start_continuous_input_injection_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.start_continuous_input_injection_for_player_mapping(mapping_name, raw_value, modifiers, triggers) -> None
        Starts simulation of input via injection. This injects the given input every tick until it is stopped with StopContinuousInputInjectionForAction.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def start_continuous_input_injection_for_action(self, action: InputAction, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.start_continuous_input_injection_for_action(action, raw_value, modifiers, triggers) -> None
        Starts simulation of input via injection. This injects the given input every tick until it is stopped with StopContinuousInputInjectionForAction.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def request_rebuild_control_mappings(self, options: ModifyContextOptions = [True, False, False], rebuild_type: InputMappingRebuildType = InputMappingRebuildType.REBUILD) -> None:
        r"""
        x.request_rebuild_control_mappings(options=[True, False, False], rebuild_type=InputMappingRebuildType.REBUILD) -> None
        Flag player for reapplication of all mapping contexts at the end of this frame.
        This is called automatically when adding or removing mappings contexts.
        
        Args:
            options (ModifyContextOptions): Options to consider when removing this input mapping context
            rebuild_type (InputMappingRebuildType):
        """
        ...
    def remove_player_mappable_config(self, config: PlayerMappableInputConfig, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_player_mappable_config(config, options=[True, False, False]) -> None
        Remove Player Mappable Config
        deprecated: RemovePlayerMappableConfig has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            config (PlayerMappableInputConfig): 
            options (ModifyContextOptions):
        """
        ...
    def remove_mapping_context(self, mapping_context: InputMappingContext, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_mapping_context(mapping_context, options=[True, False, False]) -> None
        Remove a specific control context.
        This is safe to call even if the context is not applied.
        
        Args:
            mapping_context (InputMappingContext): Context to remove from the player
            options (ModifyContextOptions): Options to consider when removing this input mapping context
        """
        ...
    def remove_all_player_mapped_keys_for_mapping(self, mapping_name: Name, options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.remove_all_player_mapped_keys_for_mapping(mapping_name, options=[True, False, False]) -> int32
        Remove All Player Mapped Keys for Mapping
        deprecated: RemoveAllPlayerMappedKeysForMapping has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            options (ModifyContextOptions): 
        
        Returns:
            int32:
        """
        ...
    def remove_all_player_mapped_keys(self, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_all_player_mapped_keys(options=[True, False, False]) -> None
        Remove All Player Mapped Keys
        deprecated: RemoveAllPlayerMappedKeys has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            options (ModifyContextOptions):
        """
        ...
    def query_map_key_in_context_set(self, prioritized_active_contexts: Array[InputMappingContext], input_context: InputMappingContext, action: InputAction, key: Key, blocking_issues: MappingQueryIssueFlag) -> Tuple[MappingQueryResult, Array[MappingQueryIssue]]:
        r"""
        x.query_map_key_in_context_set(prioritized_active_contexts, input_context, action, key, blocking_issues) -> (MappingQueryResult, out_issues=Array[MappingQueryIssue])
        = DefaultMappingIssues::StandardFatal
        
        Args:
            prioritized_active_contexts (Array[InputMappingContext]): 
            input_context (InputMappingContext): 
            action (InputAction): 
            key (Key): 
            blocking_issues (MappingQueryIssueFlag): 
        
        Returns:
            Array[MappingQueryIssue]: 
        
            out_issues (Array[MappingQueryIssue]):
        """
        ...
    def query_map_key_in_active_context_set(self, input_context: InputMappingContext, action: InputAction, key: Key, blocking_issues: MappingQueryIssueFlag) -> Tuple[MappingQueryResult, Array[MappingQueryIssue]]:
        r"""
        x.query_map_key_in_active_context_set(input_context, action, key, blocking_issues) -> (MappingQueryResult, out_issues=Array[MappingQueryIssue])
        = DefaultMappingIssues::StandardFatal
        
        Args:
            input_context (InputMappingContext): 
            action (InputAction): 
            key (Key): 
            blocking_issues (MappingQueryIssueFlag): 
        
        Returns:
            Array[MappingQueryIssue]: 
        
            out_issues (Array[MappingQueryIssue]):
        """
        ...
    def query_keys_mapped_to_action(self, action: InputAction) -> Array[Key]:
        r"""
        x.query_keys_mapped_to_action(action) -> Array[Key]
        Returns the keys mapped to the given action in the active input mapping contexts.
        
        Args:
            action (InputAction): 
        
        Returns:
            Array[Key]:
        """
        ...
    def k2_remove_player_mapped_key_in_slot(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.k2_remove_player_mapped_key_in_slot(mapping_name, key_slot=[0], options=[True, False, False]) -> int32
        Removes player mapped key in the KeySlot for mapping of MappingName.
        Requests a rebuild of the player mappings.
        deprecated: K2_RemovePlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            key_slot (PlayerMappableKeySlotData): 
            options (ModifyContextOptions): 
        
        Returns:
            int32: The number of mappings that have been removed
        """
        ...
    def remove_player_mapped_key(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        deprecated: 'remove_player_mapped_key' was renamed to 'k2_remove_player_mapped_key_in_slot'.
        """
        ...
    def k2_get_player_mapped_key_in_slot(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0]) -> Key:
        r"""
        x.k2_get_player_mapped_key_in_slot(mapping_name, key_slot=[0]) -> Key
        K2 Get Player Mapped Key in Slot
        deprecated: K2_GetPlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            key_slot (PlayerMappableKeySlotData): 
        
        Returns:
            Key:
        """
        ...
    def get_player_mapped_key(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0]) -> Key:
        r"""
        deprecated: 'get_player_mapped_key' was renamed to 'k2_get_player_mapped_key_in_slot'.
        """
        ...
    def k2_add_player_mapped_key_in_slot(self, mapping_name: Name, new_key: Key, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.k2_add_player_mapped_key_in_slot(mapping_name, new_key, key_slot=[0], options=[True, False, False]) -> int32
        K2 Add Player Mapped Key in Slot
        deprecated: AddPlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            new_key (Key): 
            key_slot (PlayerMappableKeySlotData): 
            options (ModifyContextOptions): 
        
        Returns:
            int32:
        """
        ...
    def add_player_mapped_key(self, mapping_name: Name, new_key: Key, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        deprecated: 'add_player_mapped_key' was renamed to 'k2_add_player_mapped_key_in_slot'.
        """
        ...
    def inject_input_vector_for_player_mapping(self, mapping_name: Name, value: Vector, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_vector_for_player_mapping(mapping_name, value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            value (Vector): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_vector_for_action(self, action: InputAction, value: Vector, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_vector_for_action(action, value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            value (Vector): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_for_player_mapping(mapping_name, raw_value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_for_action(self, action: InputAction, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_for_action(action, raw_value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def has_mapping_context(self, mapping_context: InputMappingContext) -> Optional[int]:
        r"""
        x.has_mapping_context(mapping_context) -> int32 or None
        Check if a mapping context is applied to this subsystem's owner.
        
        Args:
            mapping_context (InputMappingContext): The mapping context to search for on the subsystem's owner.
        
        Returns:
            int32 or None: True if the mapping context is applied
        
            out_found_priority (int32): The priority of the mapping context if it is applied. -1 if the context is not applied
        """
        ...
    def get_user_settings(self) -> EnhancedInputUserSettings:
        r"""
        x.get_user_settings() -> EnhancedInputUserSettings
        Get User Settings
        
        Returns:
            EnhancedInputUserSettings:
        """
        ...
    def get_all_player_mapped_keys(self, mapping_name: Name) -> Array[Key]:
        r"""
        x.get_all_player_mapped_keys(mapping_name) -> Array[Key]
        Get All Player Mapped Keys
        deprecated: GetAllPlayerMappedKeys has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
        
        Returns:
            Array[Key]:
        """
        ...
    def get_all_player_mappable_action_key_mappings(self) -> Array[EnhancedActionKeyMapping]:
        r"""
        x.get_all_player_mappable_action_key_mappings() -> Array[EnhancedActionKeyMapping]
        Get an array of the currently applied key mappings that are marked as Player Mappable.
        
        Returns:
            Array[EnhancedActionKeyMapping]:
        """
        ...
    def clear_all_mappings(self) -> None:
        r"""
        x.clear_all_mappings() -> None
        Remove all applied mapping contexts.
        """
        ...
    def add_player_mappable_config(self, config: PlayerMappableInputConfig, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.add_player_mappable_config(config, options=[True, False, False]) -> None
        Add Player Mappable Config
        deprecated: AddPlayerMappableConfig has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            config (PlayerMappableInputConfig): 
            options (ModifyContextOptions):
        """
        ...
    def add_mapping_context(self, mapping_context: InputMappingContext, priority: int, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.add_mapping_context(mapping_context, priority, options=[True, False, False]) -> None
        Add a control mapping context.
        
        Args:
            mapping_context (InputMappingContext): A set of key to action mappings to apply to this player
            priority (int32): Higher priority mappings will be applied first and, if they consume input, will block lower priority mappings.
            options (ModifyContextOptions): Options to consider when adding this mapping context.
        """
        ...

class EnhancedPlayerInput(PlayerInput):
    r"""
    UEnhancedPlayerInput : UPlayerInput extensions for enhanced player input system
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: EnhancedPlayerInput.h
    
    """
    ...

class InputAction(DataAsset):
    r"""
    An Input Action is a logical representation of something the user can do, such as "Jump" or "Crouch".
    These are what your gameplay code binds to in order to listen for input state changes. For most scenarios
    your gameplay code should be listening for the "Triggered" event on an input action. This will allow
    for the most scalable and customizable input configuration because you can add different triggers
    for each key mapping in the Input Mapping Context.
    
    They are the conceptual equivalent to "Action" and "Axis" mapping names from the Legacy Input System.
    
    Note: These are instanced per player (via FInputActionInstance)
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputAction.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accumulation_behavior`` (InputActionAccumulationBehavior):  [Read-Write] This defines how the value of this input action will be calcuated in the case that there are multiple key mappings to the same input action.
      
      When TakeHighestAbsoluteValue is selected, then the key mapping with the highest absolutle value will be utilized. (Default)
      When Cumulative is selected, then each key mapping will be added together to get the key value.
      see: UEnhancedPlayerInput::ProcessActionMappingEvent, where this property is read from.
    - ``action_description`` (Text):  [Read-Write] A localized descriptor of this input action
    - ``consume_input`` (bool):  [Read-Write] Should this action swallow any inputs bound to it or allow them to pass through to affect lower priority bound actions?
    - ``consumes_action_and_axis_mappings`` (bool):  [Read-Write] Should this Input Action consume any legacy Action and Axis key mappings?
      If true, then any key mapping to this input action will consume(aka block) the legacy key
      mapping from firing delegates.
    - ``modifiers`` (Array[InputModifier]):  [Read-Write] Modifiers are applied to the final action value.
      These are applied sequentially in array order.
      They are applied on top of any FEnhancedActionKeyMapping modifiers that drove the initial input
      
      Note: Modifiers defined in the Input Action asset will be applied AFTER any modifiers defined in individual key mappings in the Input Mapping Context asset.
    - ``player_mappable_key_settings`` (PlayerMappableKeySettings):  [Read-Write] Holds setting information about this Action Input for setting screen and save purposes.
    - ``reserve_all_mappings`` (bool):  [Read-Write] This action's mappings are not intended to be automatically overridden by higher priority context mappings. Users must explicitly remove the mapping first. NOTE: It is the responsibility of the author of the mapping code to enforce this!
    - ``trigger_events_that_consume_legacy_keys`` (int32):  [Read-Write] A bitmask of trigger events that, when reached, will consume any FKeys mapped to this input action.
    - ``trigger_when_paused`` (bool):  [Read-Write] Should this action be able to trigger whilst the game is paused - Replaces bExecuteWhenPaused
    - ``triggers`` (Array[InputTrigger]):  [Read-Write] Trigger qualifiers. If any trigger qualifiers exist the action will not trigger unless:
      At least one Explicit trigger in this list has been met.
      All Implicit triggers in this list are met.
    - ``value_type`` (InputActionValueType):  [Read-Write] The type that this action returns from a GetActionValue query or action event
    """
    @property
    def action_description(self) -> Text:
        r"""
        (Text):  [Read-Only] A localized descriptor of this input action
        """
        ...
    @property
    def trigger_when_paused(self) -> bool:
        r"""
        (bool):  [Read-Only] Should this action be able to trigger whilst the game is paused - Replaces bExecuteWhenPaused
        """
        ...
    @property
    def consume_input(self) -> bool:
        r"""
        (bool):  [Read-Write] Should this action swallow any inputs bound to it or allow them to pass through to affect lower priority bound actions?
        """
        ...
    @consume_input.setter
    def consume_input(self, value: bool) -> None:
        ...
    @property
    def consumes_action_and_axis_mappings(self) -> bool:
        r"""
        (bool):  [Read-Write] Should this Input Action consume any legacy Action and Axis key mappings?
        If true, then any key mapping to this input action will consume(aka block) the legacy key
        mapping from firing delegates.
        """
        ...
    @consumes_action_and_axis_mappings.setter
    def consumes_action_and_axis_mappings(self, value: bool) -> None:
        ...
    @property
    def reserve_all_mappings(self) -> bool:
        r"""
        (bool):  [Read-Only] This action's mappings are not intended to be automatically overridden by higher priority context mappings. Users must explicitly remove the mapping first. NOTE: It is the responsibility of the author of the mapping code to enforce this!
        """
        ...
    @property
    def trigger_events_that_consume_legacy_keys(self) -> int:
        r"""
        (int32):  [Read-Write] A bitmask of trigger events that, when reached, will consume any FKeys mapped to this input action.
        """
        ...
    @trigger_events_that_consume_legacy_keys.setter
    def trigger_events_that_consume_legacy_keys(self, value: int) -> None:
        ...
    @property
    def value_type(self) -> InputActionValueType:
        r"""
        (InputActionValueType):  [Read-Only] The type that this action returns from a GetActionValue query or action event
        """
        ...
    @property
    def accumulation_behavior(self) -> InputActionAccumulationBehavior:
        r"""
        (InputActionAccumulationBehavior):  [Read-Only] This defines how the value of this input action will be calcuated in the case that there are multiple key mappings to the same input action.
        
        When TakeHighestAbsoluteValue is selected, then the key mapping with the highest absolutle value will be utilized. (Default)
        When Cumulative is selected, then each key mapping will be added together to get the key value.
        see: UEnhancedPlayerInput::ProcessActionMappingEvent, where this property is read from.
        """
        ...
    @property
    def triggers(self) -> Array[InputTrigger]:
        r"""
        (Array[InputTrigger]):  [Read-Write] Trigger qualifiers. If any trigger qualifiers exist the action will not trigger unless:
        At least one Explicit trigger in this list has been met.
        All Implicit triggers in this list are met.
        """
        ...
    @triggers.setter
    def triggers(self, value: Array[InputTrigger]) -> None:
        ...
    @property
    def modifiers(self) -> Array[InputModifier]:
        r"""
        (Array[InputModifier]):  [Read-Write] Modifiers are applied to the final action value.
        These are applied sequentially in array order.
        They are applied on top of any FEnhancedActionKeyMapping modifiers that drove the initial input
        
        Note: Modifiers defined in the Input Action asset will be applied AFTER any modifiers defined in individual key mappings in the Input Mapping Context asset.
        """
        ...
    @modifiers.setter
    def modifiers(self, value: Array[InputModifier]) -> None:
        ...
    @property
    def player_mappable_key_settings(self) -> PlayerMappableKeySettings:
        r"""
        (PlayerMappableKeySettings):  [Read-Write] Holds setting information about this Action Input for setting screen and save purposes.
        """
        ...
    @player_mappable_key_settings.setter
    def player_mappable_key_settings(self, value: PlayerMappableKeySettings) -> None:
        ...

class InputMappingContext(DataAsset):
    r"""
    UInputMappingContext : A collection of key to action mappings for a specific input context
    Could be used to:
         Store predefined controller mappings (allow switching between controller config variants). TODO: Build a system allowing redirects of UInputMappingContexts to handle this.
         Define per-vehicle control mappings
         Define context specific mappings (e.g. I switch from a gun (shoot action) to a grappling hook (reel in, reel out, disconnect actions).
         Define overlay mappings to be applied on top of existing control mappings (e.g. Hero specific action mappings in a MOBA)
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputMappingContext.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``context_description`` (Text):  [Read-Write] Localized context descriptor
    - ``mappings`` (Array[EnhancedActionKeyMapping]):  [Read-Write] List of key to action mappings.
    """
    @property
    def mappings(self) -> Array[EnhancedActionKeyMapping]:
        r"""
        (Array[EnhancedActionKeyMapping]):  [Read-Only] List of key to action mappings.
        """
        ...
    @property
    def context_description(self) -> Text:
        r"""
        (Text):  [Read-Only] Localized context descriptor
        """
        ...
    def unmap_key(self, action: InputAction, key: Key) -> None:
        r"""
        x.unmap_key(action, key) -> None
        Unmap a key from an action within the mapping context.
        
        Args:
            action (InputAction): 
            key (Key):
        """
        ...
    def unmap_all_keys_from_action(self, action: InputAction) -> None:
        r"""
        x.unmap_all_keys_from_action(action) -> None
        Unmap all key maps to an action within the mapping context.
        
        Args:
            action (InputAction):
        """
        ...
    def unmap_all(self) -> None:
        r"""
        x.unmap_all() -> None
        Unmap everything within the mapping context.
        """
        ...
    def unmap_action(self, action: InputAction) -> None:
        r"""
        x.unmap_action(action) -> None
        Unmap Action
        deprecated: Function 'UnmapAction' is deprecated.
        
        Args:
            action (InputAction):
        """
        ...
    def map_key(self, action: InputAction, to_key: Key) -> EnhancedActionKeyMapping:
        r"""
        x.map_key(action, to_key) -> EnhancedActionKeyMapping
        Map a key to an action within the mapping context.
        
        Args:
            action (InputAction): 
            to_key (Key): 
        
        Returns:
            EnhancedActionKeyMapping:
        """
        ...

class InputModifier(Object):
    r"""
    Base class for building modifiers.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    """
    def modify_raw(self, player_input: EnhancedPlayerInput, current_value: InputActionValue, delta_time: float) -> InputActionValue:
        r"""
        x.modify_raw(player_input, current_value, delta_time) -> InputActionValue
        ModifyRaw
        Will be called by each modifier in the modifier chain
        
        Args:
            player_input (EnhancedPlayerInput): 
            current_value (InputActionValue): The modified value returned by the previous modifier in the chain, or the base raw value if this is the first modifier in the chain.
            delta_time (float): 
        
        Returns:
            InputActionValue:
        """
        ...
    def get_visualization_color(self, sample_value: InputActionValue, final_value: InputActionValue) -> LinearColor:
        r"""
        x.get_visualization_color(sample_value, final_value) -> LinearColor
        Helper to allow debug visualization of the modifier.
        
        Args:
            sample_value (InputActionValue): The base input action value pre-modification (ranging -1 -> 1 across all applicable axes).
            final_value (InputActionValue): The post-modification input action value for the provided SampleValue.
        
        Returns:
            LinearColor:
        """
        ...

class InputModifierSmoothDelta(InputModifier):
    r"""
    Normalized Smooth Delta
    
    Produces a smoothed normalized delta of the current(new) and last(old) input value.
    Boolean input values will be returned as is.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``easing_exponent`` (float):  [Read-Write] For ease functions, this controls the degree of the curve.
      
      This only affects the Interp_Ease_In, Interp_Ease_Out, and Interp_Ease_In_Out smoothing methods
    - ``smoothing_method`` (NormalizeInputSmoothingType):  [Read-Write]
    - ``speed`` (float):  [Read-Write] Speed, or Alpha. If the speed given is 0, then jump to the target.
    """
    @property
    def smoothing_method(self) -> NormalizeInputSmoothingType:
        r"""
        (NormalizeInputSmoothingType):  [Read-Write]
        """
        ...
    @smoothing_method.setter
    def smoothing_method(self, value: NormalizeInputSmoothingType) -> None:
        ...
    @property
    def speed(self) -> float:
        r"""
        (float):  [Read-Write] Speed, or Alpha. If the speed given is 0, then jump to the target.
        """
        ...
    @speed.setter
    def speed(self, value: float) -> None:
        ...
    @property
    def easing_exponent(self) -> float:
        r"""
        (float):  [Read-Write] For ease functions, this controls the degree of the curve.
        
        This only affects the Interp_Ease_In, Interp_Ease_Out, and Interp_Ease_In_Out smoothing methods
        """
        ...
    @easing_exponent.setter
    def easing_exponent(self, value: float) -> None:
        ...

class InputModifierDeadZone(InputModifier):
    r"""
    Dead Zone
    Input values within the range LowerThreshold -> UpperThreshold will be remapped from 0 -> 1.
    Values outside this range will be clamped.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``lower_threshold`` (float):  [Read-Write] Threshold below which input is ignored
    - ``type`` (DeadZoneType):  [Read-Write]
    - ``upper_threshold`` (float):  [Read-Write] Threshold above which input is clamped to 1
    """
    @property
    def lower_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Threshold below which input is ignored
        """
        ...
    @lower_threshold.setter
    def lower_threshold(self, value: float) -> None:
        ...
    @property
    def upper_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Threshold above which input is clamped to 1
        """
        ...
    @upper_threshold.setter
    def upper_threshold(self, value: float) -> None:
        ...
    @property
    def type(self) -> DeadZoneType:
        r"""
        (DeadZoneType):  [Read-Write]
        """
        ...
    @type.setter
    def type(self, value: DeadZoneType) -> None:
        ...

class InputModifierScalar(InputModifier):
    r"""
    Scalar
    Scales input by a set factor per axis
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``scalar`` (Vector):  [Read-Write] The scalar that will be applied to the input value.
      
      For example, if you have a scalar of (2.0, 2.0, 2.0), each input axis will be multiplied by 2.0.
      
      Note: This will do nothing on boolean input action types, as they can only be true or false.
    """
    @property
    def scalar(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The scalar that will be applied to the input value.
        
        For example, if you have a scalar of (2.0, 2.0, 2.0), each input axis will be multiplied by 2.0.
        
        Note: This will do nothing on boolean input action types, as they can only be true or false.
        """
        ...
    @scalar.setter
    def scalar(self, value: Vector) -> None:
        ...

class InputModifierScaleByDeltaTime(InputModifier):
    r"""
    Scalar
    Multiplies the input value by Delta Time this frame
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    """
    ...

class InputModifierNegate(InputModifier):
    r"""
    Negate
    Inverts input per axis
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``x`` (bool):  [Read-Write]
    - ``y`` (bool):  [Read-Write]
    - ``z`` (bool):  [Read-Write]
    """
    @property
    def x(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @x.setter
    def x(self, value: bool) -> None:
        ...
    @property
    def y(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @y.setter
    def y(self, value: bool) -> None:
        ...
    @property
    def z(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @z.setter
    def z(self, value: bool) -> None:
        ...

class InputModifierSmooth(InputModifier):
    r"""
    Smooth
    Smooth inputs out over multiple frames
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    """
    ...

class InputModifierResponseCurveExponential(InputModifier):
    r"""
    Response Curve Exponential
    Apply a simple exponential response curve to input values, per axis
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``curve_exponent`` (Vector):  [Read-Write]
    """
    @property
    def curve_exponent(self) -> Vector:
        r"""
        (Vector):  [Read-Write]
        """
        ...
    @curve_exponent.setter
    def curve_exponent(self, value: Vector) -> None:
        ...

class InputModifierResponseCurveUser(InputModifier):
    r"""
    Response Curve User Defined
    Apply a custom response curve to input values, per axis
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``response_x`` (CurveFloat):  [Read-Write]
    - ``response_y`` (CurveFloat):  [Read-Write]
    - ``response_z`` (CurveFloat):  [Read-Write]
    """
    @property
    def response_x(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write]
        """
        ...
    @response_x.setter
    def response_x(self, value: CurveFloat) -> None:
        ...
    @property
    def response_y(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write]
        """
        ...
    @response_y.setter
    def response_y(self, value: CurveFloat) -> None:
        ...
    @property
    def response_z(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write]
        """
        ...
    @response_z.setter
    def response_z(self, value: CurveFloat) -> None:
        ...

class InputModifierFOVScaling(InputModifier):
    r"""
    FOV Scaling
    Apply FOV dependent scaling to input values, per axis
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``fov_scale`` (float):  [Read-Write] Extra scalar applied on top of basic FOV scaling.
    - ``fov_scaling_type`` (FOVScalingType):  [Read-Write]
    """
    @property
    def fov_scale(self) -> float:
        r"""
        (float):  [Read-Write] Extra scalar applied on top of basic FOV scaling.
        """
        ...
    @fov_scale.setter
    def fov_scale(self, value: float) -> None:
        ...
    @property
    def fov_scaling_type(self) -> FOVScalingType:
        r"""
        (FOVScalingType):  [Read-Write]
        """
        ...
    @fov_scaling_type.setter
    def fov_scaling_type(self, value: FOVScalingType) -> None:
        ...

class InputModifierToWorldSpace(InputModifier):
    r"""
    Input space to World space conversion
    Auto-converts axes within the Input Action Value into world space     allowing the result to be directly plugged into functions that take world space values.
    E.g. For a 2D input axis up/down is mapped to world X (forward), whilst axis left/right is mapped to world Y (right).
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    """
    ...

class InputModifierSwizzleAxis(InputModifier):
    r"""
    Swizzle axis components of an input value.
    Useful to map a 1D input onto the Y axis of a 2D action.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputModifiers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``order`` (InputAxisSwizzle):  [Read-Write] Default to XY swap, useful for binding 1D inputs to the Y axis.
    """
    @property
    def order(self) -> InputAxisSwizzle:
        r"""
        (InputAxisSwizzle):  [Read-Write] Default to XY swap, useful for binding 1D inputs to the Y axis.
        """
        ...
    @order.setter
    def order(self, value: InputAxisSwizzle) -> None:
        ...

class InputTrigger(Object):
    r"""
    Base class for building triggers.
    Transitions to Triggered state once the input meets or exceeds the actuation threshold.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    """
    @property
    def actuation_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Point at which this trigger fires
        """
        ...
    @actuation_threshold.setter
    def actuation_threshold(self, value: float) -> None:
        ...
    @property
    def should_always_tick(self) -> bool:
        r"""
        (bool):  [Read-Only] Decides whether this trigger ticks every frame or not.
               * This WILL affect performance and should only be used in specific custom triggers.
        """
        ...
    @property
    def last_value(self) -> InputActionValue:
        r"""
        (InputActionValue):  [Read-Only] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
        """
        ...
    def update_state(self, player_input: EnhancedPlayerInput, modified_value: InputActionValue, delta_time: float) -> TriggerState:
        r"""
        x.update_state(player_input, modified_value, delta_time) -> TriggerState
        This function checks if the requisite conditions have been met for the trigger to fire.
         Returns Trigger State None              - No trigger conditions have been met. Trigger is inactive.
                         Trigger State Ongoing   - Some trigger conditions have been met. Trigger is processing but not yet active.
                         Trigger State Triggered - All trigger conditions have been met to fire. Trigger is active.
        
        Args:
            player_input (EnhancedPlayerInput): 
            modified_value (InputActionValue): 
            delta_time (float): 
        
        Returns:
            TriggerState:
        """
        ...
    def is_actuated(self, for_value: InputActionValue) -> bool:
        r"""
        x.is_actuated(for_value) -> bool
        * Is the value passed in sufficiently large to be of interest to the trigger.
        * This is a helper function that implements the most obvious (>=) interpretation of the actuation threshold.
        
        Args:
            for_value (InputActionValue): 
        
        Returns:
            bool:
        """
        ...
    def get_trigger_type(self) -> TriggerType:
        r"""
        x.get_trigger_type() -> TriggerType
        Changes the way this trigger affects an action with multiple triggers:
                All implicit triggers must be triggering to trigger the action.
                If there are any explicit triggers at least one must be triggering to trigger the action.
        
        Returns:
            TriggerType:
        """
        ...

class InputTriggerTimedBase(InputTrigger):
    r"""
    Base class for building triggers that have firing conditions governed by elapsed time.
    This class transitions state to Ongoing once input is actuated, and will track Ongoing input time until input is released.
    Inheriting classes should provide the logic for Triggered transitions.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``affected_by_time_dilation`` (bool):  [Read-Write] Should global time dilation be applied to the held duration?
      Default is set to false.
      
      If this is set to true, then the owning Player Controller's actor time dilation
      will be used when calculating the HeldDuration.
      see: UInputTriggerTimedBase::CalculateHeldDuration
      see: AWorldSettings::GetEffectiveTimeDilation
    - ``held_duration`` (float):  [Read-Write] How long have we been actuating this trigger?
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    """
    @property
    def held_duration(self) -> float:
        r"""
        (float):  [Read-Write] How long have we been actuating this trigger?
        """
        ...
    @held_duration.setter
    def held_duration(self, value: float) -> None:
        ...
    @property
    def affected_by_time_dilation(self) -> bool:
        r"""
        (bool):  [Read-Write] Should global time dilation be applied to the held duration?
        Default is set to false.
        
        If this is set to true, then the owning Player Controller's actor time dilation
        will be used when calculating the HeldDuration.
        see: UInputTriggerTimedBase::CalculateHeldDuration
        see: AWorldSettings::GetEffectiveTimeDilation
        """
        ...
    @affected_by_time_dilation.setter
    def affected_by_time_dilation(self, value: bool) -> None:
        ...

class InputTriggerDown(InputTrigger):
    r"""
    UInputTriggerDown
          Trigger fires when the input exceeds the actuation threshold.
          Note: When no triggers are bound Down (with an actuation threshold of > 0) is the default behavior.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    """
    ...

class InputTriggerPressed(InputTrigger):
    r"""
    UInputTriggerPressed
          Trigger fires once only when input exceeds the actuation threshold.
          Holding the input will not cause further triggers.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    """
    ...

class InputTriggerReleased(InputTrigger):
    r"""
    UInputTriggerReleased
          Trigger returns Ongoing whilst input exceeds the actuation threshold.
          Trigger fires once only when input drops back below actuation threshold.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    """
    ...

class InputTriggerHold(InputTriggerTimedBase):
    r"""
    UInputTriggerHold
          Trigger fires once input has remained actuated for HoldTimeThreshold seconds.
          Trigger may optionally fire once, or repeatedly fire.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``affected_by_time_dilation`` (bool):  [Read-Write] Should global time dilation be applied to the held duration?
      Default is set to false.
      
      If this is set to true, then the owning Player Controller's actor time dilation
      will be used when calculating the HeldDuration.
      see: UInputTriggerTimedBase::CalculateHeldDuration
      see: AWorldSettings::GetEffectiveTimeDilation
    - ``held_duration`` (float):  [Read-Write] How long have we been actuating this trigger?
    - ``hold_time_threshold`` (float):  [Read-Write] How long does the input have to be held to cause trigger?
    - ``is_one_shot`` (bool):  [Read-Write] Should this trigger fire only once, or fire every frame once the hold time threshold is met?
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    """
    @property
    def hold_time_threshold(self) -> float:
        r"""
        (float):  [Read-Write] How long does the input have to be held to cause trigger?
        """
        ...
    @hold_time_threshold.setter
    def hold_time_threshold(self, value: float) -> None:
        ...
    @property
    def is_one_shot(self) -> bool:
        r"""
        (bool):  [Read-Write] Should this trigger fire only once, or fire every frame once the hold time threshold is met?
        """
        ...
    @is_one_shot.setter
    def is_one_shot(self, value: bool) -> None:
        ...

class InputTriggerHoldAndRelease(InputTriggerTimedBase):
    r"""
    UInputTriggerHoldAndRelease
          Trigger fires when input is released after having been actuated for at least HoldTimeThreshold seconds.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``affected_by_time_dilation`` (bool):  [Read-Write] Should global time dilation be applied to the held duration?
      Default is set to false.
      
      If this is set to true, then the owning Player Controller's actor time dilation
      will be used when calculating the HeldDuration.
      see: UInputTriggerTimedBase::CalculateHeldDuration
      see: AWorldSettings::GetEffectiveTimeDilation
    - ``held_duration`` (float):  [Read-Write] How long have we been actuating this trigger?
    - ``hold_time_threshold`` (float):  [Read-Write] How long does the input have to be held to cause trigger?
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    """
    @property
    def hold_time_threshold(self) -> float:
        r"""
        (float):  [Read-Write] How long does the input have to be held to cause trigger?
        """
        ...
    @hold_time_threshold.setter
    def hold_time_threshold(self, value: float) -> None:
        ...

class InputTriggerTap(InputTriggerTimedBase):
    r"""
    UInputTriggerTap
          Input must be actuated then released within TapReleaseTimeThreshold seconds to trigger.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``affected_by_time_dilation`` (bool):  [Read-Write] Should global time dilation be applied to the held duration?
      Default is set to false.
      
      If this is set to true, then the owning Player Controller's actor time dilation
      will be used when calculating the HeldDuration.
      see: UInputTriggerTimedBase::CalculateHeldDuration
      see: AWorldSettings::GetEffectiveTimeDilation
    - ``held_duration`` (float):  [Read-Write] How long have we been actuating this trigger?
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    - ``tap_release_time_threshold`` (float):  [Read-Write] Release within this time-frame to trigger a tap
    """
    @property
    def tap_release_time_threshold(self) -> float:
        r"""
        (float):  [Read-Write] Release within this time-frame to trigger a tap
        """
        ...
    @tap_release_time_threshold.setter
    def tap_release_time_threshold(self, value: float) -> None:
        ...

class InputTriggerPulse(InputTriggerTimedBase):
    r"""
    UInputTriggerPulse
          Trigger that fires at an Interval, in seconds, while input is actuated.
          Note:   Completed only fires when the repeat limit is reached or when input is released immediately after being triggered.
                          Otherwise, Canceled is fired when input is released.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``affected_by_time_dilation`` (bool):  [Read-Write] Should global time dilation be applied to the held duration?
      Default is set to false.
      
      If this is set to true, then the owning Player Controller's actor time dilation
      will be used when calculating the HeldDuration.
      see: UInputTriggerTimedBase::CalculateHeldDuration
      see: AWorldSettings::GetEffectiveTimeDilation
    - ``held_duration`` (float):  [Read-Write] How long have we been actuating this trigger?
    - ``interval`` (float):  [Read-Write] How long between each trigger fire while input is held, in seconds?
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    - ``trigger_limit`` (int32):  [Read-Write] How many times can the trigger fire while input is held? (0 = no limit)
    - ``trigger_on_start`` (bool):  [Read-Write] Whether to trigger when the input first exceeds the actuation threshold or wait for the first interval?
    """
    @property
    def trigger_on_start(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to trigger when the input first exceeds the actuation threshold or wait for the first interval?
        """
        ...
    @trigger_on_start.setter
    def trigger_on_start(self, value: bool) -> None:
        ...
    @property
    def interval(self) -> float:
        r"""
        (float):  [Read-Write] How long between each trigger fire while input is held, in seconds?
        """
        ...
    @interval.setter
    def interval(self, value: float) -> None:
        ...
    @property
    def trigger_limit(self) -> int:
        r"""
        (int32):  [Read-Write] How many times can the trigger fire while input is held? (0 = no limit)
        """
        ...
    @trigger_limit.setter
    def trigger_limit(self, value: int) -> None:
        ...

class InputTriggerChordAction(InputTrigger):
    r"""
    UInputTriggerChordAction
    Applies a chord action that must be triggering for this trigger's action to trigger
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``chord_action`` (InputAction):  [Read-Write] The action that must be triggering for this trigger's action to trigger
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    """
    @property
    def chord_action(self) -> InputAction:
        r"""
        (InputAction):  [Read-Write] The action that must be triggering for this trigger's action to trigger
        """
        ...
    @chord_action.setter
    def chord_action(self, value: InputAction) -> None:
        ...

class InputTriggerChordBlocker(InputTriggerChordAction):
    r"""
    UInputTriggerChordBlocker
          Automatically instantiated  to block mappings that are masked by a UInputTriggerChordAction chord from firing whilst the chording key is active.
          NOTE: Do not attempt to add these manually.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``chord_action`` (InputAction):  [Read-Write] The action that must be triggering for this trigger's action to trigger
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    """
    ...

class InputTriggerCombo(InputTrigger):
    r"""
    UInputTriggerCombo
    All actions in the combo array must be completed (based on combo completion event specified - triggered, completed, etc.) to trigger the action this trigger is on.
    Actions must also be completed in the order specified by the combo actions array (starting at index 0).
    Note: This will only trigger for one frame before resetting the combo trigger's progress
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: InputTriggers.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actuation_threshold`` (float):  [Read-Write] Point at which this trigger fires
    - ``combo_actions`` (Array[InputComboStepData]):  [Read-Write] List of input actions that need to be completed (according to Combo Step Completion States) to trigger this action.
      Input actions must be triggered in order (starting at index 0) to count towards the triggering of the combo.
    - ``current_combo_step_index`` (int32):  [Read-Write] Keeps track of what action we're currently at in the combo
    - ``current_time_between_combo_steps`` (float):  [Read-Write] Time elapsed between last combo InputAction trigger and current time
    - ``input_cancel_actions`` (Array[InputCancelAction]):  [Read-Write] Actions that will cancel the combo if they are completed (according to Cancellation States)
    - ``last_value`` (InputActionValue):  [Read-Write] Value passed to UpdateState on the previous tick. This will be updated automatically after the trigger is updated.
    - ``should_always_tick`` (bool):  [Read-Write] Decides whether this trigger ticks every frame or not.
             * This WILL affect performance and should only be used in specific custom triggers.
    """
    @property
    def current_combo_step_index(self) -> int:
        r"""
        (int32):  [Read-Only] Keeps track of what action we're currently at in the combo
        """
        ...
    @property
    def current_time_between_combo_steps(self) -> float:
        r"""
        (float):  [Read-Only] Time elapsed between last combo InputAction trigger and current time
        """
        ...
    @property
    def combo_actions(self) -> Array[InputComboStepData]:
        r"""
        (Array[InputComboStepData]):  [Read-Write] List of input actions that need to be completed (according to Combo Step Completion States) to trigger this action.
        Input actions must be triggered in order (starting at index 0) to count towards the triggering of the combo.
        """
        ...
    @combo_actions.setter
    def combo_actions(self, value: Array[InputComboStepData]) -> None:
        ...
    @property
    def input_cancel_actions(self) -> Array[InputCancelAction]:
        r"""
        (Array[InputCancelAction]):  [Read-Write] Actions that will cancel the combo if they are completed (according to Cancellation States)
        """
        ...
    @input_cancel_actions.setter
    def input_cancel_actions(self, value: Array[InputCancelAction]) -> None:
        ...

class PlayerMappableInputConfig(PrimaryDataAsset):
    r"""
    UPlayerMappableInputConfig
    
    This represents one set of Player Mappable controller/keymappings. You can use this input config to create
    the default mappings for your player to start with in your game. It provides an easy way to get only the player
    mappable key actions, and it can be used to add multiple UInputMappingContext's at once to the player.
    
    Populate this data asset with Input Mapping Contexts that have player mappable actions in them.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: PlayerMappableInputConfig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``config_display_name`` (Text):  [Read-Write] The display name that can be used
    - ``config_name`` (Name):  [Read-Write] The unique name of this config that can be used when saving it
    - ``contexts`` (Map[InputMappingContext, int32]):  [Read-Write] Mapping contexts that make up this Input Config with their associated priority.
    - ``is_deprecated`` (bool):  [Read-Write] A flag that can be used to mark this Input Config as deprecated to your player/designers.
    - ``metadata`` (Object):  [Read-Write] Metadata that can used to store any other related items to your key mapping such as icons, ability assets, etc.
    """
    @property
    def config_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The unique name of this config that can be used when saving it
        """
        ...
    @property
    def config_display_name(self) -> Text:
        r"""
        (Text):  [Read-Only] The display name that can be used
        """
        ...
    @property
    def is_deprecated(self) -> bool:
        r"""
        (bool):  [Read-Only] A flag that can be used to mark this Input Config as deprecated to your player/designers.
        """
        ...
    @property
    def metadata(self) -> Object:
        r"""
        (Object):  [Read-Only] Metadata that can used to store any other related items to your key mapping such as icons, ability assets, etc.
        """
        ...
    @property
    def contexts(self) -> Map[InputMappingContext, int]:
        r"""
        (Map[InputMappingContext, int32]):  [Read-Only] Mapping contexts that make up this Input Config with their associated priority.
        """
        ...
    def reset_to_default(self) -> None:
        r"""
        x.reset_to_default() -> None
        Resets this mappable config to use the keys
        """
        ...
    def is_deprecated(self) -> bool:
        r"""
        x.is_deprecated() -> bool
        Is Deprecated
        
        Returns:
            bool:
        """
        ...
    def get_player_mappable_keys(self) -> Array[EnhancedActionKeyMapping]:
        r"""
        x.get_player_mappable_keys() -> Array[EnhancedActionKeyMapping]
        Get all the player mappable keys in this config.
        
        Returns:
            Array[EnhancedActionKeyMapping]:
        """
        ...
    def get_metadata(self) -> Object:
        r"""
        x.get_metadata() -> Object
        Get all the player mappable keys in this config.
        
        Returns:
            Object:
        """
        ...
    def get_mapping_contexts(self) -> Map[InputMappingContext, int]:
        r"""
        x.get_mapping_contexts() -> Map[InputMappingContext, int32]
        Return all the Input Mapping contexts that
        
        Returns:
            Map[InputMappingContext, int32]:
        """
        ...
    def get_mapping_by_name(self, mapping_name: Name) -> EnhancedActionKeyMapping:
        r"""
        x.get_mapping_by_name(mapping_name) -> EnhancedActionKeyMapping
        Returns the action key mapping for the mapping that matches the given name
        
        Args:
            mapping_name (Name): 
        
        Returns:
            EnhancedActionKeyMapping:
        """
        ...
    def get_keys_bound_to_action(self, action: InputAction) -> Array[EnhancedActionKeyMapping]:
        r"""
        x.get_keys_bound_to_action(action) -> Array[EnhancedActionKeyMapping]
        Returns all the keys mapped to a specific Input Action in this mapping config.
        
        Args:
            action (InputAction): 
        
        Returns:
            Array[EnhancedActionKeyMapping]:
        """
        ...
    def get_display_name(self) -> Text:
        r"""
        x.get_display_name() -> Text
        Get Display Name
        
        Returns:
            Text:
        """
        ...
    def get_config_name(self) -> Name:
        r"""
        x.get_config_name() -> Name
        Get Config Name
        
        Returns:
            Name:
        """
        ...

class PlayerMappableKeySettings(Object):
    r"""
    Hold setting information of an Action Input or a Action Key Mapping for setting screen and save purposes.
    Experimental: Do not count on long term support for this structure.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: EnhancedInput
    - **File**: PlayerMappableKeySettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_category`` (Text):  [Read-Write] The category that this player mapping is in
    - ``display_name`` (Text):  [Read-Write] The localized display name of this key mapping. Use this when displaying the mappings to a user.
    - ``metadata`` (Object):  [Read-Write] Metadata that can used to store any other related items to this key mapping such as icons, ability assets, etc.
    - ``name`` (Name):  [Read-Write] A unique name for this player mapping to be saved with.
    - ``supported_key_profiles`` (GameplayTagContainer):  [Read-Write] If this key mapping should only be added when a specific key profile is equipped, then set those here.
      
      If this is empty, then the key mapping will not be filtered out based on the current profile.
    """
    @property
    def metadata(self) -> Object:
        r"""
        (Object):  [Read-Only] Metadata that can used to store any other related items to this key mapping such as icons, ability assets, etc.
        """
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Only] A unique name for this player mapping to be saved with.
        """
        ...
    @property
    def display_name(self) -> Text:
        r"""
        (Text):  [Read-Only] The localized display name of this key mapping. Use this when displaying the mappings to a user.
        """
        ...
    @property
    def display_category(self) -> Text:
        r"""
        (Text):  [Read-Only] The category that this player mapping is in
        """
        ...
    @property
    def supported_key_profiles(self) -> GameplayTagContainer:
        r"""
        (GameplayTagContainer):  [Read-Only] If this key mapping should only be added when a specific key profile is equipped, then set those here.
        
        If this is empty, then the key mapping will not be filtered out based on the current profile.
        """
        ...

class EnhancedInputEditorSubsystem(EditorSubsystem):
    r"""
    The Enhanced Input Editor Subsystem can be used to process input outside of PIE within the editor.
    Calling StartConsumingInput will allow the input preprocessor to drive Input Action delegates
    to be fired in the editor.
    
    This allows you to hook up Input Action delegates in Editor Utilities to make editor tools driven by
    input.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: InputEditor
    - **File**: EnhancedInputEditorSubsystem.h
    
    """
    def stop_consuming_input(self) -> None:
        r"""
        x.stop_consuming_input() -> None
        Tells this subsystem to stop ticking and consuming any input. This will stop any Input Action Delegates from being called.
        """
        ...
    def start_consuming_input(self) -> None:
        r"""
        x.start_consuming_input() -> None
        Start the consumption of input messages in this subsystem. This is required to have any Input Action delegates be fired.
        """
        ...
    def push_input_component(self, input_component: InputComponent) -> None:
        r"""
        x.push_input_component(input_component) -> None
        Pushes this input component onto the stack to be processed by this subsystem's tick function
        
        Args:
            input_component (InputComponent):
        """
        ...
    def pop_input_component(self, input_component: InputComponent) -> bool:
        r"""
        x.pop_input_component(input_component) -> bool
        Removes this input component onto the stack to be processed by this subsystem's tick function
        
        Args:
            input_component (InputComponent): 
        
        Returns:
            bool:
        """
        ...
    def is_consuming_input(self) -> bool:
        r"""
        x.is_consuming_input() -> bool
        Returns true if this subsystem is currently consuming input
        
        Returns:
            bool:
        """
        ...
    def update_value_of_continuous_input_injection_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue) -> None:
        r"""
        x.update_value_of_continuous_input_injection_for_player_mapping(mapping_name, raw_value) -> None
        Update the value of a continuous input injection for the given player mapping name, preserving the state of triggers and modifiers.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
        """
        ...
    def update_value_of_continuous_input_injection_for_action(self, action: InputAction, raw_value: InputActionValue) -> None:
        r"""
        x.update_value_of_continuous_input_injection_for_action(action, raw_value) -> None
        Update the value of a continuous input injection, preserving the state of triggers and modifiers.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
        """
        ...
    def stop_continuous_input_injection_for_player_mapping(self, mapping_name: Name) -> None:
        r"""
        x.stop_continuous_input_injection_for_player_mapping(mapping_name) -> None
        Stops continuous input injection for the given player mapping name.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
        """
        ...
    def stop_continuous_input_injection_for_action(self, action: InputAction) -> None:
        r"""
        x.stop_continuous_input_injection_for_action(action) -> None
        Stops continuous input injection for the given action.
        
        Args:
            action (InputAction): The action to stop injecting input for
        """
        ...
    def start_continuous_input_injection_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.start_continuous_input_injection_for_player_mapping(mapping_name, raw_value, modifiers, triggers) -> None
        Starts simulation of input via injection. This injects the given input every tick until it is stopped with StopContinuousInputInjectionForAction.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def start_continuous_input_injection_for_action(self, action: InputAction, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.start_continuous_input_injection_for_action(action, raw_value, modifiers, triggers) -> None
        Starts simulation of input via injection. This injects the given input every tick until it is stopped with StopContinuousInputInjectionForAction.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def request_rebuild_control_mappings(self, options: ModifyContextOptions = [True, False, False], rebuild_type: InputMappingRebuildType = InputMappingRebuildType.REBUILD) -> None:
        r"""
        x.request_rebuild_control_mappings(options=[True, False, False], rebuild_type=InputMappingRebuildType.REBUILD) -> None
        Flag player for reapplication of all mapping contexts at the end of this frame.
        This is called automatically when adding or removing mappings contexts.
        
        Args:
            options (ModifyContextOptions): Options to consider when removing this input mapping context
            rebuild_type (InputMappingRebuildType):
        """
        ...
    def remove_player_mappable_config(self, config: PlayerMappableInputConfig, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_player_mappable_config(config, options=[True, False, False]) -> None
        Remove Player Mappable Config
        deprecated: RemovePlayerMappableConfig has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            config (PlayerMappableInputConfig): 
            options (ModifyContextOptions):
        """
        ...
    def remove_mapping_context(self, mapping_context: InputMappingContext, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_mapping_context(mapping_context, options=[True, False, False]) -> None
        Remove a specific control context.
        This is safe to call even if the context is not applied.
        
        Args:
            mapping_context (InputMappingContext): Context to remove from the player
            options (ModifyContextOptions): Options to consider when removing this input mapping context
        """
        ...
    def remove_all_player_mapped_keys_for_mapping(self, mapping_name: Name, options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.remove_all_player_mapped_keys_for_mapping(mapping_name, options=[True, False, False]) -> int32
        Remove All Player Mapped Keys for Mapping
        deprecated: RemoveAllPlayerMappedKeysForMapping has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            options (ModifyContextOptions): 
        
        Returns:
            int32:
        """
        ...
    def remove_all_player_mapped_keys(self, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.remove_all_player_mapped_keys(options=[True, False, False]) -> None
        Remove All Player Mapped Keys
        deprecated: RemoveAllPlayerMappedKeys has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            options (ModifyContextOptions):
        """
        ...
    def query_map_key_in_context_set(self, prioritized_active_contexts: Array[InputMappingContext], input_context: InputMappingContext, action: InputAction, key: Key, blocking_issues: MappingQueryIssueFlag) -> Tuple[MappingQueryResult, Array[MappingQueryIssue]]:
        r"""
        x.query_map_key_in_context_set(prioritized_active_contexts, input_context, action, key, blocking_issues) -> (MappingQueryResult, out_issues=Array[MappingQueryIssue])
        = DefaultMappingIssues::StandardFatal
        
        Args:
            prioritized_active_contexts (Array[InputMappingContext]): 
            input_context (InputMappingContext): 
            action (InputAction): 
            key (Key): 
            blocking_issues (MappingQueryIssueFlag): 
        
        Returns:
            Array[MappingQueryIssue]: 
        
            out_issues (Array[MappingQueryIssue]):
        """
        ...
    def query_map_key_in_active_context_set(self, input_context: InputMappingContext, action: InputAction, key: Key, blocking_issues: MappingQueryIssueFlag) -> Tuple[MappingQueryResult, Array[MappingQueryIssue]]:
        r"""
        x.query_map_key_in_active_context_set(input_context, action, key, blocking_issues) -> (MappingQueryResult, out_issues=Array[MappingQueryIssue])
        = DefaultMappingIssues::StandardFatal
        
        Args:
            input_context (InputMappingContext): 
            action (InputAction): 
            key (Key): 
            blocking_issues (MappingQueryIssueFlag): 
        
        Returns:
            Array[MappingQueryIssue]: 
        
            out_issues (Array[MappingQueryIssue]):
        """
        ...
    def query_keys_mapped_to_action(self, action: InputAction) -> Array[Key]:
        r"""
        x.query_keys_mapped_to_action(action) -> Array[Key]
        Returns the keys mapped to the given action in the active input mapping contexts.
        
        Args:
            action (InputAction): 
        
        Returns:
            Array[Key]:
        """
        ...
    def k2_remove_player_mapped_key_in_slot(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.k2_remove_player_mapped_key_in_slot(mapping_name, key_slot=[0], options=[True, False, False]) -> int32
        Removes player mapped key in the KeySlot for mapping of MappingName.
        Requests a rebuild of the player mappings.
        deprecated: K2_RemovePlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            key_slot (PlayerMappableKeySlotData): 
            options (ModifyContextOptions): 
        
        Returns:
            int32: The number of mappings that have been removed
        """
        ...
    def remove_player_mapped_key(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        deprecated: 'remove_player_mapped_key' was renamed to 'k2_remove_player_mapped_key_in_slot'.
        """
        ...
    def k2_get_player_mapped_key_in_slot(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0]) -> Key:
        r"""
        x.k2_get_player_mapped_key_in_slot(mapping_name, key_slot=[0]) -> Key
        K2 Get Player Mapped Key in Slot
        deprecated: K2_GetPlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            key_slot (PlayerMappableKeySlotData): 
        
        Returns:
            Key:
        """
        ...
    def get_player_mapped_key(self, mapping_name: Name, key_slot: PlayerMappableKeySlotData = [0]) -> Key:
        r"""
        deprecated: 'get_player_mapped_key' was renamed to 'k2_get_player_mapped_key_in_slot'.
        """
        ...
    def k2_add_player_mapped_key_in_slot(self, mapping_name: Name, new_key: Key, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        x.k2_add_player_mapped_key_in_slot(mapping_name, new_key, key_slot=[0], options=[True, False, False]) -> int32
        K2 Add Player Mapped Key in Slot
        deprecated: AddPlayerMappedKeyInSlot has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
            new_key (Key): 
            key_slot (PlayerMappableKeySlotData): 
            options (ModifyContextOptions): 
        
        Returns:
            int32:
        """
        ...
    def add_player_mapped_key(self, mapping_name: Name, new_key: Key, key_slot: PlayerMappableKeySlotData = [0], options: ModifyContextOptions = [True, False, False]) -> int:
        r"""
        deprecated: 'add_player_mapped_key' was renamed to 'k2_add_player_mapped_key_in_slot'.
        """
        ...
    def inject_input_vector_for_player_mapping(self, mapping_name: Name, value: Vector, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_vector_for_player_mapping(mapping_name, value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            value (Vector): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_vector_for_action(self, action: InputAction, value: Vector, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_vector_for_action(action, value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            value (Vector): The value to set the action to (the type will be controlled by the Action)
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_for_player_mapping(self, mapping_name: Name, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_for_player_mapping(mapping_name, raw_value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            mapping_name (Name): The name of the player mapping that can be used for look up an associated UInputAction object.
            raw_value (InputActionValue): The value to set the action to
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def inject_input_for_action(self, action: InputAction, raw_value: InputActionValue, modifiers: Array[InputModifier], triggers: Array[InputTrigger]) -> None:
        r"""
        x.inject_input_for_action(action, raw_value, modifiers, triggers) -> None
        Input simulation via injection. Runs modifiers and triggers delegates as if the input had come through the underlying input system as FKeys.
        Applies action modifiers and triggers on top.
        
        Args:
            action (InputAction): The Input Action to set inject input for
            raw_value (InputActionValue): The value to set the action to
            modifiers (Array[InputModifier]): The modifiers to apply to the injected input.
            triggers (Array[InputTrigger]): The triggers to apply to the injected input.
        """
        ...
    def has_mapping_context(self, mapping_context: InputMappingContext) -> Optional[int]:
        r"""
        x.has_mapping_context(mapping_context) -> int32 or None
        Check if a mapping context is applied to this subsystem's owner.
        
        Args:
            mapping_context (InputMappingContext): The mapping context to search for on the subsystem's owner.
        
        Returns:
            int32 or None: True if the mapping context is applied
        
            out_found_priority (int32): The priority of the mapping context if it is applied. -1 if the context is not applied
        """
        ...
    def get_user_settings(self) -> EnhancedInputUserSettings:
        r"""
        x.get_user_settings() -> EnhancedInputUserSettings
        Get User Settings
        
        Returns:
            EnhancedInputUserSettings:
        """
        ...
    def get_all_player_mapped_keys(self, mapping_name: Name) -> Array[Key]:
        r"""
        x.get_all_player_mapped_keys(mapping_name) -> Array[Key]
        Get All Player Mapped Keys
        deprecated: GetAllPlayerMappedKeys has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            mapping_name (Name): 
        
        Returns:
            Array[Key]:
        """
        ...
    def get_all_player_mappable_action_key_mappings(self) -> Array[EnhancedActionKeyMapping]:
        r"""
        x.get_all_player_mappable_action_key_mappings() -> Array[EnhancedActionKeyMapping]
        Get an array of the currently applied key mappings that are marked as Player Mappable.
        
        Returns:
            Array[EnhancedActionKeyMapping]:
        """
        ...
    def clear_all_mappings(self) -> None:
        r"""
        x.clear_all_mappings() -> None
        Remove all applied mapping contexts.
        """
        ...
    def add_player_mappable_config(self, config: PlayerMappableInputConfig, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.add_player_mappable_config(config, options=[True, False, False]) -> None
        Add Player Mappable Config
        deprecated: AddPlayerMappableConfig has been deprecated, please use UEnhancedInputUserSettings instead.
        
        Args:
            config (PlayerMappableInputConfig): 
            options (ModifyContextOptions):
        """
        ...
    def add_mapping_context(self, mapping_context: InputMappingContext, priority: int, options: ModifyContextOptions = [True, False, False]) -> None:
        r"""
        x.add_mapping_context(mapping_context, priority, options=[True, False, False]) -> None
        Add a control mapping context.
        
        Args:
            mapping_context (InputMappingContext): A set of key to action mappings to apply to this player
            priority (int32): Higher priority mappings will be applied first and, if they consume input, will block lower priority mappings.
            options (ModifyContextOptions): Options to consider when adding this mapping context.
        """
        ...

class InputMappingContext_Factory(Factory):
    r"""
    Asset factories
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: InputEditor
    - **File**: InputEditorModule.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``input_mapping_context_class`` (type(Class)):  [Read-Write]
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class InputAction_Factory(Factory):
    r"""
    Input Action Factory
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: InputEditor
    - **File**: InputEditorModule.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``input_action_class`` (type(Class)):  [Read-Write]
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PlayerMappableInputConfig_Factory(Factory):
    r"""
    Player Mappable Input Config Factory
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: InputEditor
    - **File**: InputEditorModule.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MockInputUserSettings(EnhancedInputUserSettings):
    r"""
    Mock Input User Settings
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: InputEditor
    - **File**: InputTestFramework.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_settings_applied`` (EnhancedInputUserSettingsApplied):  [Read-Write]
    - ``on_settings_changed`` (EnhancedInputUserSettingsChanged):  [Read-Write]
    """
    ...

class TestMappableKeysAction(InputAction):
    r"""
    A subclass of UInputAction that will have it's player mappable key settings object set automatically so
    we can test re-mappable keys.
    
    **C++ Source:**
    
    - **Plugin**: EnhancedInput
    - **Module**: InputEditor
    - **File**: InputTestFramework.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accumulation_behavior`` (InputActionAccumulationBehavior):  [Read-Write] This defines how the value of this input action will be calcuated in the case that there are multiple key mappings to the same input action.
      
      When TakeHighestAbsoluteValue is selected, then the key mapping with the highest absolutle value will be utilized. (Default)
      When Cumulative is selected, then each key mapping will be added together to get the key value.
      see: UEnhancedPlayerInput::ProcessActionMappingEvent, where this property is read from.
    - ``action_description`` (Text):  [Read-Write] A localized descriptor of this input action
    - ``consume_input`` (bool):  [Read-Write] Should this action swallow any inputs bound to it or allow them to pass through to affect lower priority bound actions?
    - ``consumes_action_and_axis_mappings`` (bool):  [Read-Write] Should this Input Action consume any legacy Action and Axis key mappings?
      If true, then any key mapping to this input action will consume(aka block) the legacy key
      mapping from firing delegates.
    - ``modifiers`` (Array[InputModifier]):  [Read-Write] Modifiers are applied to the final action value.
      These are applied sequentially in array order.
      They are applied on top of any FEnhancedActionKeyMapping modifiers that drove the initial input
      
      Note: Modifiers defined in the Input Action asset will be applied AFTER any modifiers defined in individual key mappings in the Input Mapping Context asset.
    - ``player_mappable_key_settings`` (PlayerMappableKeySettings):  [Read-Write] Holds setting information about this Action Input for setting screen and save purposes.
    - ``reserve_all_mappings`` (bool):  [Read-Write] This action's mappings are not intended to be automatically overridden by higher priority context mappings. Users must explicitly remove the mapping first. NOTE: It is the responsibility of the author of the mapping code to enforce this!
    - ``trigger_events_that_consume_legacy_keys`` (int32):  [Read-Write] A bitmask of trigger events that, when reached, will consume any FKeys mapped to this input action.
    - ``trigger_when_paused`` (bool):  [Read-Write] Should this action be able to trigger whilst the game is paused - Replaces bExecuteWhenPaused
    - ``triggers`` (Array[InputTrigger]):  [Read-Write] Trigger qualifiers. If any trigger qualifiers exist the action will not trigger unless:
      At least one Explicit trigger in this list has been met.
      All Implicit triggers in this list are met.
    - ``value_type`` (InputActionValueType):  [Read-Write] The type that this action returns from a GetActionValue query or action event
    """
    ...

class EnvironmentQueryFactory(Factory):
    r"""
    Environment Query Factory
    
    **C++ Source:**
    
    - **Plugin**: EnvironmentQueryEditor
    - **Module**: EnvironmentQueryEditor
    - **File**: EnvironmentQueryFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TakeMetaData(Object):
    r"""
    Take meta-data that is stored on ULevelSequence assets that are recorded through the Take Recorder.
    Meta-data is retrieved through ULevelSequence::FindMetaData<UTakeMetaData>()
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakeMetaData.h
    
    """
    def unlock(self) -> None:
        r"""
        x.unlock() -> None
        Unlock this take if it is read-only, allowing it to be modified once again
        """
        ...
    def set_timestamp(self, timestamp: DateTime) -> None:
        r"""
        x.set_timestamp(timestamp) -> None
        Set this take's timestamp
        note:: Only valid for takes that have not been locked
        
        Args:
            timestamp (DateTime):
        """
        ...
    def set_timecode_out(self, timecode_out: Timecode) -> None:
        r"""
        x.set_timecode_out(timecode_out) -> None
        Set this take's timecode out
        note:: Only valid for takes that have not been locked
        
        Args:
            timecode_out (Timecode):
        """
        ...
    def set_timecode_in(self, timecode_in: Timecode) -> None:
        r"""
        x.set_timecode_in(timecode_in) -> None
        Set this take's timecode in
        note:: Only valid for takes that have not been locked
        
        Args:
            timecode_in (Timecode):
        """
        ...
    def set_take_number(self, take_number: int, emit_changed: bool = True) -> None:
        r"""
        x.set_take_number(take_number, emit_changed=True) -> None
        Set this take's take number. Take numbers are always clamped to be >= 1.
        note:: Only valid for takes that have not been locked
        
        Args:
            take_number (int32): 
            emit_changed (bool): Whether or not to send a take number changed event
        """
        ...
    def set_slate(self, slate: str, emit_changed: bool = True) -> None:
        r"""
        x.set_slate(slate, emit_changed=True) -> None
        Set the slate for this take and reset its take number to 1
        note:: Only valid for takes that have not been locked
        
        Args:
            slate (str): 
            emit_changed (bool): Whether or not to send a slate changed event
        """
        ...
    def set_preset_origin(self, preset_origin: TakePreset) -> None:
        r"""
        x.set_preset_origin(preset_origin) -> None
        Set the preset on which the take is based
        note:: Only valid for takes that have not been locked
        
        Args:
            preset_origin (TakePreset):
        """
        ...
    def set_level_origin(self, level_origin: Level) -> None:
        r"""
        x.set_level_origin(level_origin) -> None
        Set the map used to create this recording
        
        Args:
            level_origin (Level):
        """
        ...
    def set_frame_rate_from_timecode(self, from_timecode: bool) -> None:
        r"""
        x.set_frame_rate_from_timecode(from_timecode) -> None
        Set if we get frame rate from time code
        
        Args:
            from_timecode (bool):
        """
        ...
    def set_frame_rate(self, frame_rate: FrameRate) -> None:
        r"""
        x.set_frame_rate(frame_rate) -> None
        Set this take's frame-rate
        note:: Only valid for takes that have not been locked
        
        Args:
            frame_rate (FrameRate):
        """
        ...
    def set_duration(self, duration: FrameTime) -> None:
        r"""
        x.set_duration(duration) -> None
        Set this take's duration
        note:: Only valid for takes that have not been locked
        
        Args:
            duration (FrameTime):
        """
        ...
    def set_description(self, description: str) -> None:
        r"""
        x.set_description(description) -> None
        Set this take's user-provided description
        note:: Only valid for takes that have not been locked
        
        Args:
            description (str):
        """
        ...
    def recorded(self) -> bool:
        r"""
        x.recorded() -> bool
        Check if this take was recorded (as opposed
        to being setup for recording)
        
        Returns:
            bool:
        """
        ...
    def lock(self) -> None:
        r"""
        x.lock() -> None
        Lock this take, causing it to become read-only
        """
        ...
    def is_locked(self) -> bool:
        r"""
        x.is_locked() -> bool
        Check whether this take is locked
        
        Returns:
            bool:
        """
        ...
    def get_timestamp(self) -> DateTime:
        r"""
        x.get_timestamp() -> DateTime
        
        
        Returns:
            DateTime: The timestamp for this take
        """
        ...
    def get_timecode_out(self) -> Timecode:
        r"""
        x.get_timecode_out() -> Timecode
        
        
        Returns:
            Timecode: The timecode out for this take
        """
        ...
    def get_timecode_in(self) -> Timecode:
        r"""
        x.get_timecode_in() -> Timecode
        
        
        Returns:
            Timecode: The timecode in for this take
        """
        ...
    def get_take_number(self) -> int:
        r"""
        x.get_take_number() -> int32
        
        
        Returns:
            int32: The take number for this take
        """
        ...
    def get_slate(self) -> str:
        r"""
        x.get_slate() -> str
        
        
        Returns:
            str: The slate for this take
        """
        ...
    def get_preset_origin(self) -> TakePreset:
        r"""
        x.get_preset_origin() -> TakePreset
        
        
        Returns:
            TakePreset: The preset on which the take was originally based
        """
        ...
    def get_level_path(self) -> str:
        r"""
        x.get_level_path() -> str
        
        
        Returns:
            str: The AssetPath of the Level used to create a Recorded Level Sequence
        """
        ...
    def get_level_origin(self) -> Level:
        r"""
        x.get_level_origin() -> Level
        
        
        Returns:
            Level: The Map used to create this recording
        """
        ...
    def get_frame_rate_from_timecode(self) -> bool:
        r"""
        x.get_frame_rate_from_timecode() -> bool
        
        
        Returns:
            bool: Get if we get frame rate from time code
        """
        ...
    def get_frame_rate(self) -> FrameRate:
        r"""
        x.get_frame_rate() -> FrameRate
        
        
        Returns:
            FrameRate: The frame-rate for this take
        """
        ...
    def get_duration(self) -> FrameTime:
        r"""
        x.get_duration() -> FrameTime
        
        
        Returns:
            FrameTime: The duration for this take
        """
        ...
    def get_description(self) -> str:
        r"""
        x.get_description() -> str
        
        
        Returns:
            str: The user-provided description for this take
        """
        ...
    def generate_asset_path(self, path_format_string: str) -> str:
        r"""
        x.generate_asset_path(path_format_string) -> str
        Generate the desired asset path for this take meta-data
        
        Args:
            path_format_string (str): 
        
        Returns:
            str:
        """
        ...

class TakePreset(Object):
    r"""
    Take preset that is stored as an asset comprising a ULevelSequence, and a set of actor recording sources
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakePreset.h
    
    """
    ...

class TakeRecorderSource(Object):
    r"""
    Base class for all sources that can be recorded with the Take Recorder. Custom recording sources can
    be created by inheriting from this class and implementing the Start/Tick/Stop recording functions.
    The level sequence that the recording is being placed into is provided so that the take can decide
    to store the data directly in the resulting level sequence, but sources are not limited to generating
    data in the specified Level Sequence. The source should be registered with the ITakeRecorderModule for
    it to show up in the Take Recorder UI. If creating a recording setup via code you can just add instances
    of your Source to the UTakeRecorderSources instance you're using to record and skip registering them with
    the module.
    
    Sources should reset their state before recording as there is not a guarantee that the object will be newly
    created for each recording.
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakeRecorderSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    @property
    def enabled(self) -> bool:
        r"""
        (bool):  [Read-Write] True if this source is cued for recording or not
        """
        ...
    @enabled.setter
    def enabled(self, value: bool) -> None:
        ...
    @property
    def take_number(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @take_number.setter
    def take_number(self, value: int) -> None:
        ...
    @property
    def track_tint(self) -> Color:
        r"""
        (Color):  [Read-Write]
        """
        ...
    @track_tint.setter
    def track_tint(self, value: Color) -> None:
        ...

class ActorRecorderPropertyMap(Object):
    r"""
    This represents a list of all possible properties and components on an actor
    which can be recorded by the Actor Recorder and whether or not the user wishes
    to record them. If you wish to expose a property to be recorded it needs to be marked
    as "Interp" (C++) or "Expose to Cinematics" in Blueprints.
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakeRecorderSourceProperty.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``children`` (Array[ActorRecorderPropertyMap]):  [Read-Write]
    - ``properties`` (Array[ActorRecordedProperty]):  [Read-Write] Represents properties exposed to Cinematics that can possibly be recorded.
    - ``recorded_object`` (Object):  [Read-Only]
    """
    @property
    def properties(self) -> Array[ActorRecordedProperty]:
        r"""
        (Array[ActorRecordedProperty]):  [Read-Write] Represents properties exposed to Cinematics that can possibly be recorded.
        """
        ...
    @properties.setter
    def properties(self, value: Array[ActorRecordedProperty]) -> None:
        ...
    @property
    def children(self) -> Array[ActorRecorderPropertyMap]:
        r"""
        (Array[ActorRecorderPropertyMap]):  [Read-Write]
        """
        ...
    @children.setter
    def children(self, value: Array[ActorRecorderPropertyMap]) -> None:
        ...

class TakeRecorderAudioInputSettings(Object):
    r"""
    Provides access to the UI code for registering OnAudioInputDeviceChanged delegates.
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakeRecorderSourceProperty.h
    
    """
    ...

class TakeRecorderSources(Object):
    r"""
    A list of sources to record for any given take. Stored as meta-data on ULevelSequence through ULevelSequence::FindMetaData<UTakeRecorderSources>
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakeRecorderSources.h
    
    """
    def start_recording_source(self, sources: Array[TakeRecorderSource], current_frame_time: QualifiedTime) -> None:
        r"""
        x.start_recording_source(sources, current_frame_time) -> None
        Calls the recording initialization flows on each of the specified sources.
        
        Args:
            sources (Array[TakeRecorderSource]): 
            current_frame_time (QualifiedTime):
        """
        ...
    def remove_source(self, source: TakeRecorderSource) -> None:
        r"""
        x.remove_source(source) -> None
        Remove the specified source from this list
        
        Args:
            source (TakeRecorderSource): The source to remove
        """
        ...
    def get_sources_copy(self) -> Array[TakeRecorderSource]:
        r"""
        x.get_sources_copy() -> Array[TakeRecorderSource]
        Retrieves a copy of the list of sources that are being recorded. This is intended for Blueprint usages which cannot
        use TArrayView.
        DO NOT MODIFY THIS ARRAY, modifications will be lost.
        
        Returns:
            Array[TakeRecorderSource]:
        """
        ...
    def add_source(self, source_type: Class) -> TakeRecorderSource:
        r"""
        x.add_source(source_type) -> TakeRecorderSource
        Add a new source to this source list of the templated type
        
        Args:
            source_type (type(Class)): The class type of the source to add
        
        Returns:
            TakeRecorderSource: An instance of the specified source type
        """
        ...

class TakesCoreBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Takes Core Blueprint Library
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakesCore
    - **File**: TakesCoreBlueprintLibrary.h
    
    """
    @classmethod
    def set_on_take_recorder_take_number_changed(cls, on_take_recorder_take_number_changed: OnTakeRecorderTakeNumberChanged) -> None:
        r"""
        X.set_on_take_recorder_take_number_changed(on_take_recorder_take_number_changed) -> None
        Called when the take number is changed.
        
        Args:
            on_take_recorder_take_number_changed (OnTakeRecorderTakeNumberChanged):
        """
        ...
    @classmethod
    def set_on_take_recorder_slate_changed(cls, on_take_recorder_slate_changed: OnTakeRecorderSlateChanged) -> None:
        r"""
        X.set_on_take_recorder_slate_changed(on_take_recorder_slate_changed) -> None
        Called when the slate is changed.
        
        Args:
            on_take_recorder_slate_changed (OnTakeRecorderSlateChanged):
        """
        ...
    @classmethod
    def find_takes(cls, slate: str, take_number: int = 0) -> Array[AssetData]:
        r"""
        X.find_takes(slate, take_number=0) -> Array[AssetData]
        Find all the existing takes that were recorded with the specified slate
        
        Args:
            slate (str): The slate to filter by
            take_number (int32): The take number to filter by. <=0 denotes all takes
        
        Returns:
            Array[AssetData]:
        """
        ...
    @classmethod
    def compute_next_take_number(cls, slate: str) -> int:
        r"""
        X.compute_next_take_number(slate) -> int32
        Compute the next unused sequential take number for the specified slate
        
        Args:
            slate (str): 
        
        Returns:
            int32:
        """
        ...

class MovieSceneTakeSection(MovieSceneSection):
    r"""
    A section in a Take track
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeMovieScene
    - **File**: MovieSceneTakeSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneTakeSettings(Object):
    r"""
    Universal take recorder settings that apply to a whole take
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeMovieScene
    - **File**: MovieSceneTakeSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frames_name`` (str):  [Read-Write] Frames Name
    - ``hours_name`` (str):  [Read-Write] Hours Name
    - ``minutes_name`` (str):  [Read-Write] Minutes Name
    - ``seconds_name`` (str):  [Read-Write] Seconds Name
    - ``slate_name`` (str):  [Read-Write] Slate Name
    - ``sub_frames_name`` (str):  [Read-Write] SubFrames Name
    """
    @property
    def hours_name(self) -> str:
        r"""
        (str):  [Read-Write] Hours Name
        """
        ...
    @hours_name.setter
    def hours_name(self, value: str) -> None:
        ...
    @property
    def minutes_name(self) -> str:
        r"""
        (str):  [Read-Write] Minutes Name
        """
        ...
    @minutes_name.setter
    def minutes_name(self, value: str) -> None:
        ...
    @property
    def seconds_name(self) -> str:
        r"""
        (str):  [Read-Write] Seconds Name
        """
        ...
    @seconds_name.setter
    def seconds_name(self, value: str) -> None:
        ...
    @property
    def frames_name(self) -> str:
        r"""
        (str):  [Read-Write] Frames Name
        """
        ...
    @frames_name.setter
    def frames_name(self, value: str) -> None:
        ...
    @property
    def sub_frames_name(self) -> str:
        r"""
        (str):  [Read-Write] SubFrames Name
        """
        ...
    @sub_frames_name.setter
    def sub_frames_name(self, value: str) -> None:
        ...
    @property
    def slate_name(self) -> str:
        r"""
        (str):  [Read-Write] Slate Name
        """
        ...
    @slate_name.setter
    def slate_name(self, value: str) -> None:
        ...

class MovieSceneTakeTrack(MovieSceneNameableTrack):
    r"""
    Handles manipulation of takes in a movie scene
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeMovieScene
    - **File**: MovieSceneTakeTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneTrackRecorder(Object):
    r"""
    Movie Scene Track Recorder
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: MovieSceneTrackRecorder.h
    
    """
    ...

class MovieSceneTrackRecorderSettings(Object):
    r"""
    Movie Scene Track Recorder Settings
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: MovieSceneTrackRecorderSettings.h
    
    """
    ...

class MovieScene3DAttachTrackRecorder(MovieSceneTrackRecorder):
    r"""
    Movie Scene 3DAttach Track Recorder
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: MovieScene3DAttachTrackRecorder.h
    
    """
    ...

class MovieScene3DTransformTrackRecorder(MovieSceneTrackRecorder):
    r"""
    Movie Scene 3DTransform Track Recorder
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: MovieScene3DTransformTrackRecorder.h
    
    """
    ...

class MovieSceneAnimationTrackRecorder(MovieSceneTrackRecorder):
    r"""
    Movie Scene Animation Track Recorder
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: MovieSceneAnimationTrackRecorder.h
    
    """
    ...

class MovieSceneAnimationTrackRecorderEditorSettings(MovieSceneTrackRecorderSettings):
    r"""
    Movie Scene Animation Track Recorder Editor Settings
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: MovieSceneAnimationTrackRecorderSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animation_asset_name`` (str):  [Read-Write] The name of the animation asset.
      Supports any of the following format specifiers that will be substituted when a take is recorded:
      {day}       - The day of the timestamp for the start of the recording.
      {month}     - The month of the timestamp for the start of the recording.
      {year}      - The year of the timestamp for the start of the recording.
      {hour}      - The hour of the timestamp for the start of the recording.
      {minute}    - The minute of the timestamp for the start of the recording.
      {second}    - The second of the timestamp for the start of the recording.
      {take}      - The take number.
      {slate}     - The slate string.
      {actor}     - The name of the actor being recorded.
    - ``animation_sub_directory`` (str):  [Read-Write] The name of the subdirectory animations will be placed in. Leave this empty to place into the same directory as the sequence base path.
      Supports any of the following format specifiers that will be substituted when a take is recorded:
      {day}       - The day of the timestamp for the start of the recording.
      {month}     - The month of the timestamp for the start of the recording.
      {year}      - The year of the timestamp for the start of the recording.
      {hour}      - The hour of the timestamp for the start of the recording.
      {minute}    - The minute of the timestamp for the start of the recording.
      {second}    - The second of the timestamp for the start of the recording.
      {take}      - The take number.
      {slate}     - The slate string.
      {actor}     - The name of the actor being recorded.
    - ``animation_track_name`` (Text):  [Read-Write] Name of the recorded animation track.
    - ``interp_mode`` (RichCurveInterpMode):  [Read-Write] Interpolation mode for the recorded keys.
    - ``remove_root_animation`` (bool):  [Read-Write] If true we remove the root animation and move it to a transform track, if false we leave it on the root bone in the anim sequence
    - ``tangent_mode`` (RichCurveTangentMode):  [Read-Write] Tangent mode for the recorded keys.
    - ``timecode_bone_method`` (TimecodeBoneMethod):  [Read-Write] The method to record timecode values onto bones
    """
    @property
    def animation_track_name(self) -> Text:
        r"""
        (Text):  [Read-Write] Name of the recorded animation track.
        """
        ...
    @animation_track_name.setter
    def animation_track_name(self, value: Text) -> None:
        ...
    @property
    def animation_asset_name(self) -> str:
        r"""
        (str):  [Read-Write] The name of the animation asset.
        Supports any of the following format specifiers that will be substituted when a take is recorded:
        {day}       - The day of the timestamp for the start of the recording.
        {month}     - The month of the timestamp for the start of the recording.
        {year}      - The year of the timestamp for the start of the recording.
        {hour}      - The hour of the timestamp for the start of the recording.
        {minute}    - The minute of the timestamp for the start of the recording.
        {second}    - The second of the timestamp for the start of the recording.
        {take}      - The take number.
        {slate}     - The slate string.
        {actor}     - The name of the actor being recorded.
        """
        ...
    @animation_asset_name.setter
    def animation_asset_name(self, value: str) -> None:
        ...
    @property
    def animation_sub_directory(self) -> str:
        r"""
        (str):  [Read-Write] The name of the subdirectory animations will be placed in. Leave this empty to place into the same directory as the sequence base path.
        Supports any of the following format specifiers that will be substituted when a take is recorded:
        {day}       - The day of the timestamp for the start of the recording.
        {month}     - The month of the timestamp for the start of the recording.
        {year}      - The year of the timestamp for the start of the recording.
        {hour}      - The hour of the timestamp for the start of the recording.
        {minute}    - The minute of the timestamp for the start of the recording.
        {second}    - The second of the timestamp for the start of the recording.
        {take}      - The take number.
        {slate}     - The slate string.
        {actor}     - The name of the actor being recorded.
        """
        ...
    @animation_sub_directory.setter
    def animation_sub_directory(self, value: str) -> None:
        ...
    @property
    def remove_root_animation(self) -> bool:
        r"""
        (bool):  [Read-Write] If true we remove the root animation and move it to a transform track, if false we leave it on the root bone in the anim sequence
        """
        ...
    @remove_root_animation.setter
    def remove_root_animation(self, value: bool) -> None:
        ...
    @property
    def timecode_bone_method(self) -> TimecodeBoneMethod:
        r"""
        (TimecodeBoneMethod):  [Read-Write] The method to record timecode values onto bones
        """
        ...
    @timecode_bone_method.setter
    def timecode_bone_method(self, value: TimecodeBoneMethod) -> None:
        ...

class MovieSceneAnimationTrackRecorderSettings(MovieSceneAnimationTrackRecorderEditorSettings):
    r"""
    Movie Scene Animation Track Recorder Settings
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: MovieSceneAnimationTrackRecorderSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animation_asset_name`` (str):  [Read-Write] The name of the animation asset.
      Supports any of the following format specifiers that will be substituted when a take is recorded:
      {day}       - The day of the timestamp for the start of the recording.
      {month}     - The month of the timestamp for the start of the recording.
      {year}      - The year of the timestamp for the start of the recording.
      {hour}      - The hour of the timestamp for the start of the recording.
      {minute}    - The minute of the timestamp for the start of the recording.
      {second}    - The second of the timestamp for the start of the recording.
      {take}      - The take number.
      {slate}     - The slate string.
      {actor}     - The name of the actor being recorded.
    - ``animation_sub_directory`` (str):  [Read-Write] The name of the subdirectory animations will be placed in. Leave this empty to place into the same directory as the sequence base path.
      Supports any of the following format specifiers that will be substituted when a take is recorded:
      {day}       - The day of the timestamp for the start of the recording.
      {month}     - The month of the timestamp for the start of the recording.
      {year}      - The year of the timestamp for the start of the recording.
      {hour}      - The hour of the timestamp for the start of the recording.
      {minute}    - The minute of the timestamp for the start of the recording.
      {second}    - The second of the timestamp for the start of the recording.
      {take}      - The take number.
      {slate}     - The slate string.
      {actor}     - The name of the actor being recorded.
    - ``animation_track_name`` (Text):  [Read-Write] Name of the recorded animation track.
    - ``interp_mode`` (RichCurveInterpMode):  [Read-Write] Interpolation mode for the recorded keys.
    - ``remove_root_animation`` (bool):  [Read-Write] If true we remove the root animation and move it to a transform track, if false we leave it on the root bone in the anim sequence
    - ``tangent_mode`` (RichCurveTangentMode):  [Read-Write] Tangent mode for the recorded keys.
    - ``timecode_bone_method`` (TimecodeBoneMethod):  [Read-Write] The method to record timecode values onto bones
    """
    ...

class MovieSceneParticleTrackRecorder(MovieSceneTrackRecorder):
    r"""
    Movie Scene Particle Track Recorder
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: MovieSceneParticleTrackRecorder.h
    
    """
    ...

class MovieScenePropertyTrackRecorder(MovieSceneTrackRecorder):
    r"""
    Movie Scene Property Track Recorder
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: MovieScenePropertyTrackRecorder.h
    
    """
    ...

class MovieSceneSpawnTrackRecorder(MovieSceneTrackRecorder):
    r"""
    Movie Scene Spawn Track Recorder
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: MovieSceneSpawnTrackRecorder.h
    
    """
    ...

class MovieSceneVisibilityTrackRecorder(MovieSceneTrackRecorder):
    r"""
    Movie Scene Visibility Track Recorder
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeTrackRecorders
    - **File**: MovieSceneVisibilityTrackRecorder.h
    
    """
    ...

class TakeRecorderSubsystem(EngineSubsystem):
    r"""
    UTakeRecorderSubsystem
    Subsystem for Take Recorder
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``take_recorder_cancelled`` (TakeRecorderCancelled):  [Read-Write] Called when take recorder is cancelled
    - ``take_recorder_finished`` (TakeRecorderFinished):  [Read-Write] Called when take recorder has finished
    - ``take_recorder_marked_frame_added`` (TakeRecorderMarkedFrameAdded):  [Read-Write] Called when a marked frame is added to take recorder
    - ``take_recorder_pre_initialize`` (TakeRecorderPreInitialize):  [Read-Write] Called before initialization occurs (ie. when the recording button is pressed and before the countdown starts)
    - ``take_recorder_started`` (TakeRecorderStarted):  [Read-Write] Called when take recorder is started
    - ``take_recorder_stopped`` (TakeRecorderStopped):  [Read-Write] Called when take recorder is stopped
    """
    @property
    def take_recorder_pre_initialize(self) -> TakeRecorderPreInitialize:
        r"""
        (TakeRecorderPreInitialize):  [Read-Write] Called before initialization occurs (ie. when the recording button is pressed and before the countdown starts)
        """
        ...
    @take_recorder_pre_initialize.setter
    def take_recorder_pre_initialize(self, value: TakeRecorderPreInitialize) -> None:
        ...
    @property
    def take_recorder_started(self) -> TakeRecorderStarted:
        r"""
        (TakeRecorderStarted):  [Read-Write] Called when take recorder is started
        """
        ...
    @take_recorder_started.setter
    def take_recorder_started(self, value: TakeRecorderStarted) -> None:
        ...
    @property
    def take_recorder_stopped(self) -> TakeRecorderStopped:
        r"""
        (TakeRecorderStopped):  [Read-Write] Called when take recorder is stopped
        """
        ...
    @take_recorder_stopped.setter
    def take_recorder_stopped(self, value: TakeRecorderStopped) -> None:
        ...
    @property
    def take_recorder_finished(self) -> TakeRecorderFinished:
        r"""
        (TakeRecorderFinished):  [Read-Write] Called when take recorder has finished
        """
        ...
    @take_recorder_finished.setter
    def take_recorder_finished(self, value: TakeRecorderFinished) -> None:
        ...
    @property
    def take_recorder_cancelled(self) -> TakeRecorderCancelled:
        r"""
        (TakeRecorderCancelled):  [Read-Write] Called when take recorder is cancelled
        """
        ...
    @take_recorder_cancelled.setter
    def take_recorder_cancelled(self, value: TakeRecorderCancelled) -> None:
        ...
    @property
    def take_recorder_marked_frame_added(self) -> TakeRecorderMarkedFrameAdded:
        r"""
        (TakeRecorderMarkedFrameAdded):  [Read-Write] Called when a marked frame is added to take recorder
        """
        ...
    @take_recorder_marked_frame_added.setter
    def take_recorder_marked_frame_added(self, value: TakeRecorderMarkedFrameAdded) -> None:
        ...

class TakeRecorder(Object):
    r"""
    Take Recorder
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorder.h
    
    """
    def get_state(self) -> TakeRecorderState:
        r"""
        x.get_state() -> TakeRecorderState
        Get the current state of this recorder
        
        Returns:
            TakeRecorderState:
        """
        ...
    def get_sequence(self) -> LevelSequence:
        r"""
        x.get_sequence() -> LevelSequence
        Access the sequence asset that this recorder is recording into
        
        Returns:
            LevelSequence:
        """
        ...
    def get_countdown_seconds(self) -> float:
        r"""
        x.get_countdown_seconds() -> float
        Access the number of seconds remaining before this recording will start
        
        Returns:
            float:
        """
        ...

class TakeRecorderBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Take Recorder Blueprint Library
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderBlueprintLibrary.h
    
    """
    @classmethod
    def stop_recording(cls) -> None:
        r"""
        X.stop_recording() -> None
        Stop recording if there is a recorder currently active
        """
        ...
    @classmethod
    def start_recording(cls, level_sequence: LevelSequence, sources: TakeRecorderSources, meta_data: TakeMetaData, parameters: TakeRecorderParameters) -> TakeRecorder:
        r"""
        X.start_recording(level_sequence, sources, meta_data, parameters) -> TakeRecorder
        Start a new recording using the specified parameters. Will fail if a recording is currently in progress
        
        Args:
            level_sequence (LevelSequence): The base level sequence to use for the recording. Will be played back during the recording and duplicated to create the starting point for the resulting asset.
            sources (TakeRecorderSources): The sources to use for the recording
            meta_data (TakeMetaData): Meta-data pertaining to this recording, duplicated into the resulting recorded sequence
            parameters (TakeRecorderParameters): Configurable parameters for this recorder instance
        
        Returns:
            TakeRecorder: The recorder responsible for the recording, or None if a a recording could not be started
        """
        ...
    @classmethod
    def set_on_take_recorder_stopped(cls, on_take_recorder_stopped: OnTakeRecorderStopped) -> None:
        r"""
        X.set_on_take_recorder_stopped(on_take_recorder_stopped) -> None
        Set on Take Recorder Stopped
        deprecated: Please use TakeRecorderSubsystem::TakeRecorderStopped
        
        Args:
            on_take_recorder_stopped (OnTakeRecorderStopped):
        """
        ...
    @classmethod
    def set_on_take_recorder_started(cls, on_take_recorder_started: OnTakeRecorderStarted) -> None:
        r"""
        X.set_on_take_recorder_started(on_take_recorder_started) -> None
        Set on Take Recorder Started
        deprecated: Please use TakeRecorderSubsystem::TakeRecorderStarted
        
        Args:
            on_take_recorder_started (OnTakeRecorderStarted):
        """
        ...
    @classmethod
    def set_on_take_recorder_pre_initialize(cls, on_take_recorder_pre_initialize: OnTakeRecorderPreInitialize) -> None:
        r"""
        X.set_on_take_recorder_pre_initialize(on_take_recorder_pre_initialize) -> None
        Set on Take Recorder Pre Initialize
        deprecated: Please use TakeRecorderSubsystem::TakeRecorderPreInitialize
        
        Args:
            on_take_recorder_pre_initialize (OnTakeRecorderPreInitialize):
        """
        ...
    @classmethod
    def set_on_take_recorder_panel_changed(cls, on_take_recorder_panel_changed: OnTakeRecorderPanelChanged) -> None:
        r"""
        X.set_on_take_recorder_panel_changed(on_take_recorder_panel_changed) -> None
        Called when a Take Panel is constructed or destroyed.
        
        Args:
            on_take_recorder_panel_changed (OnTakeRecorderPanelChanged):
        """
        ...
    @classmethod
    def set_on_take_recorder_marked_frame_added(cls, on_take_recorder_marked_frame_added: OnTakeRecorderMarkedFrameAdded) -> None:
        r"""
        X.set_on_take_recorder_marked_frame_added(on_take_recorder_marked_frame_added) -> None
        Set on Take Recorder Marked Frame Added
        deprecated: Please use TakeRecorderSubsystem::TakeRecorderMarkedFrameAdded
        
        Args:
            on_take_recorder_marked_frame_added (OnTakeRecorderMarkedFrameAdded):
        """
        ...
    @classmethod
    def set_on_take_recorder_finished(cls, on_take_recorder_finished: OnTakeRecorderFinished) -> None:
        r"""
        X.set_on_take_recorder_finished(on_take_recorder_finished) -> None
        Set on Take Recorder Finished
        deprecated: Please use TakeRecorderSubsystem::TakeRecorderFinished
        
        Args:
            on_take_recorder_finished (OnTakeRecorderFinished):
        """
        ...
    @classmethod
    def set_on_take_recorder_cancelled(cls, on_take_recorder_cancelled: OnTakeRecorderCancelled) -> None:
        r"""
        X.set_on_take_recorder_cancelled(on_take_recorder_cancelled) -> None
        Set on Take Recorder Cancelled
        deprecated: Please use TakeRecorderSubsystem::TakeRecorderCancelled
        
        Args:
            on_take_recorder_cancelled (OnTakeRecorderCancelled):
        """
        ...
    @classmethod
    def set_default_parameters(cls, default_parameters: TakeRecorderParameters) -> None:
        r"""
        X.set_default_parameters(default_parameters) -> None
        Set the default recorder parameters
        
        Args:
            default_parameters (TakeRecorderParameters):
        """
        ...
    @classmethod
    def open_take_recorder_panel(cls) -> TakeRecorderPanel:
        r"""
        X.open_take_recorder_panel() -> TakeRecorderPanel
        Get the currently open take recorder panel, if one is open, opening a new one if not
        
        Returns:
            TakeRecorderPanel:
        """
        ...
    @classmethod
    def is_take_recorder_enabled(cls) -> bool:
        r"""
        X.is_take_recorder_enabled() -> bool
        Is the Take Recorder enabled in the build
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_recording(cls) -> bool:
        r"""
        X.is_recording() -> bool
        Check whether a recording is currently active
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_take_recorder_panel(cls) -> TakeRecorderPanel:
        r"""
        X.get_take_recorder_panel() -> TakeRecorderPanel
        Get the currently open take recorder panel, if one is open
        
        Returns:
            TakeRecorderPanel:
        """
        ...
    @classmethod
    def get_default_parameters(cls) -> TakeRecorderParameters:
        r"""
        X.get_default_parameters() -> TakeRecorderParameters
        Get the default recorder parameters according to the project and user settings
        
        Returns:
            TakeRecorderParameters:
        """
        ...
    @classmethod
    def get_active_recorder(cls) -> TakeRecorder:
        r"""
        X.get_active_recorder() -> TakeRecorder
        Retrieve the currently active recorder, or None if there none are active
        
        Returns:
            TakeRecorder:
        """
        ...
    @classmethod
    def cancel_recording(cls) -> None:
        r"""
        X.cancel_recording() -> None
        Cancel recording if there is a recorder currently active
        """
        ...

class TakeRecorderPanel(Object):
    r"""
    Take recorder UI panel interop object
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderPanel.h
    
    """
    def stop_recording(self) -> None:
        r"""
        x.stop_recording() -> None
        Stop recording with the current take
        """
        ...
    def start_recording(self) -> None:
        r"""
        x.start_recording() -> None
        Start recording with the current take
        """
        ...
    def setup_for_viewing(self, level_sequence_asset: LevelSequence) -> None:
        r"""
        x.setup_for_viewing(level_sequence_asset) -> None
        Setup this panel as a viewer for a previously recorded take.
        
        Args:
            level_sequence_asset (LevelSequence):
        """
        ...
    def setup_for_recording_into_level_sequence(self, level_sequence_asset: LevelSequence) -> None:
        r"""
        x.setup_for_recording_into_level_sequence(level_sequence_asset) -> None
        Setup this panel such that it is ready to start recording using the specified
        level sequence asset to record into.
        
        Args:
            level_sequence_asset (LevelSequence):
        """
        ...
    def setup_for_recording_take_preset(self, take_preset_asset: TakePreset) -> None:
        r"""
        x.setup_for_recording_take_preset(take_preset_asset) -> None
        Setup this panel such that it is ready to start recording using the specified
        take preset as a template for the recording.
        
        Args:
            take_preset_asset (TakePreset):
        """
        ...
    def setup_for_recording_level_sequence(self, level_sequence_asset: LevelSequence) -> None:
        r"""
        x.setup_for_recording_level_sequence(level_sequence_asset) -> None
        Setup this panel such that it is ready to start recording using the specified
        level sequence asset as a template for the recording.
        
        Args:
            level_sequence_asset (LevelSequence):
        """
        ...
    def setup_for_editing(self, take_preset: TakePreset) -> None:
        r"""
        x.setup_for_editing(take_preset) -> None
        Setup this panel as an editor for the specified take preset asset.
        
        Args:
            take_preset (TakePreset):
        """
        ...
    def set_frame_rate_from_timecode(self, from_timecode: bool) -> None:
        r"""
        x.set_frame_rate_from_timecode(from_timecode) -> None
        Set if the frame rate is set from the Timecode frame rate
        
        Args:
            from_timecode (bool):
        """
        ...
    def set_frame_rate(self, frame_rate: FrameRate) -> None:
        r"""
        x.set_frame_rate(frame_rate) -> None
        Set the frame rate for this take
        
        Args:
            frame_rate (FrameRate):
        """
        ...
    def new_take(self) -> None:
        r"""
        x.new_take() -> None
        New Take
        deprecated: Please use ClearPendingTake instead
        """
        ...
    def get_take_meta_data(self) -> TakeMetaData:
        r"""
        x.get_take_meta_data() -> TakeMetaData
        Access take meta data for this take
        
        Returns:
            TakeMetaData:
        """
        ...
    def get_sources(self) -> TakeRecorderSources:
        r"""
        x.get_sources() -> TakeRecorderSources
        Access the sources that are to be (or were) used for recording this take
        
        Returns:
            TakeRecorderSources:
        """
        ...
    def get_mode(self) -> TakeRecorderPanelMode:
        r"""
        x.get_mode() -> TakeRecorderPanelMode
        Get the mode that the panel is currently in
        
        Returns:
            TakeRecorderPanelMode:
        """
        ...
    def get_level_sequence(self) -> LevelSequence:
        r"""
        x.get_level_sequence() -> LevelSequence
        Access the level sequence for this take
        
        Returns:
            LevelSequence:
        """
        ...
    def get_last_recorded_level_sequence(self) -> LevelSequence:
        r"""
        x.get_last_recorded_level_sequence() -> LevelSequence
        Access the last level sequence that was recorded
        
        Returns:
            LevelSequence:
        """
        ...
    def get_frame_rate(self) -> FrameRate:
        r"""
        x.get_frame_rate() -> FrameRate
        Access the frame rate for this take
        
        Returns:
            FrameRate:
        """
        ...
    def clear_pending_take(self) -> None:
        r"""
        x.clear_pending_take() -> None
        * Clear the pending take level sequence
        """
        ...
    def can_start_recording(self) -> Optional[Text]:
        r"""
        x.can_start_recording() -> Text or None
        Whether the panel is ready to start recording
        
        Returns:
            Text or None: 
        
            out_error_text (Text):
        """
        ...

class TakeRecorderOverlayWidget(UserWidget):
    r"""
    Take Recorder Overlay Widget
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderOverlayWidget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``color_and_opacity`` (LinearColor):  [Read-Write] The color and opacity of this widget.  Tints all child widgets.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``desired_focus_widget`` (WidgetChild):  [Read-Write]
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``foreground_color`` (SlateColor):  [Read-Write] The foreground color of the widget, this is inherited by sub widgets.  Any color property
      that is marked as inherit will use this color.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Setting this flag to true, allows this widget to accept focus when clicked, or when navigated to.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_visibility_changed`` (OnVisibilityChangedEvent):  [Read-Write] Called when the visibility has changed
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``padding`` (Margin):  [Read-Write] The padding area around the content.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``preview_background`` (Texture2D):  [Read-Write] A preview background that you can use when designing the UI to get a sense of scale on the screen.  Use
      a texture with a screenshot of your game in it, for example if you were designing a HUD.
    - ``priority`` (int32):  [Read-Write]
    - ``recorder`` (TakeRecorder):  [Read-Write] The recorder that this overlay is reflecting
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``stop_action`` (bool):  [Read-Write]
    - ``tick_frequency`` (WidgetTickFrequency):  [Read-Write] This widget is allowed to tick. If this is unchecked tick will never be called, animations will not play correctly, and latent actions will not execute.
      Uncheck this for performance reasons only
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def recorder(self) -> TakeRecorder:
        r"""
        (TakeRecorder):  [Read-Only] The recorder that this overlay is reflecting
        """
        ...

class TakeRecorderUserSettings(Object):
    r"""
    Universal take recorder settings that apply to a whole take
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``preset_save_dir`` (DirectoryPath):  [Read-Write] The default location in which to save take presets
    - ``settings`` (TakeRecorderUserParameters):  [Read-Write] User settings that should be passed to a recorder instance
    """
    @property
    def settings(self) -> TakeRecorderUserParameters:
        r"""
        (TakeRecorderUserParameters):  [Read-Only] User settings that should be passed to a recorder instance
        """
        ...

class TakeRecorderProjectSettings(Object):
    r"""
    Universal take recorder settings that apply to a whole take
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorder
    - **File**: TakeRecorderSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (TakeRecorderProjectParameters):  [Read-Write]
    """
    @property
    def settings(self) -> TakeRecorderProjectParameters:
        r"""
        (TakeRecorderProjectParameters):  [Read-Only]
        """
        ...

class CacheCollectionFactory(Factory):
    r"""
    Cache Collection Factory
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCachingEditor
    - **File**: CacheCollectionFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MovieSceneChaosCacheTrackRecorder(MovieSceneTrackRecorder):
    r"""
    Track recorder implementation for the chaos cache
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCachingEditor
    - **File**: MovieSceneChaosCacheTrackRecorder.h
    
    """
    ...

class TakeRecorderChaosCacheSource(TakeRecorderSource):
    r"""
    A recording source selector for the chaos integration into take recorder
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCachingEditor
    - **File**: TakeRecorderChaosCacheSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``chaos_cache_manager`` (ChaosCacheManager):  [Read-Write] Chaos Cache manager to be used as take recorder source
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    @property
    def chaos_cache_manager(self) -> ChaosCacheManager:
        r"""
        (ChaosCacheManager):  [Read-Write] Chaos Cache manager to be used as take recorder source
        """
        ...
    @chaos_cache_manager.setter
    def chaos_cache_manager(self, value: ChaosCacheManager) -> None:
        ...

class StructUtilsFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    Struct Utils Function Library
    
    **C++ Source:**
    
    - **Plugin**: StructUtils
    - **Module**: StructUtilsEngine
    - **File**: StructUtilsFunctionLibrary.h
    
    """
    @classmethod
    def reset(cls, instanced_struct: InstancedStruct, struct_type: ScriptStruct = None) -> InstancedStruct:
        r"""
        X.reset(instanced_struct, struct_type=None) -> InstancedStruct
        Resets an InstancedStruct.
        
        Args:
            instanced_struct (InstancedStruct): 
            struct_type (ScriptStruct): 
        
        Returns:
            InstancedStruct: 
        
            instanced_struct (InstancedStruct):
        """
        ...
    @classmethod
    def not_equal_instanced_struct(cls, a: InstancedStruct, b: InstancedStruct) -> bool:
        r"""
        X.not_equal_instanced_struct(a, b) -> bool
        Checks whether two InstancedStructs are not equal.
        
        Args:
            a (InstancedStruct): 
            b (InstancedStruct): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_valid_instanced_struct(cls, instanced_struct: InstancedStruct) -> bool:
        r"""
        X.is_valid_instanced_struct(instanced_struct) -> bool
        Checks whether the InstancedStruct contains value.
        
        Args:
            instanced_struct (InstancedStruct): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_instanced_struct_valid(cls, instanced_struct: InstancedStruct) -> StructUtilsResult:
        r"""
        X.is_instanced_struct_valid(instanced_struct) -> StructUtilsResult
        Checks whether an InstancedStruct contains value.
        
        Args:
            instanced_struct (InstancedStruct): 
        
        Returns:
            StructUtilsResult:
        """
        ...
    @classmethod
    def equal_equal_instanced_struct(cls, a: InstancedStruct, b: InstancedStruct) -> bool:
        r"""
        X.equal_equal_instanced_struct(a, b) -> bool
        Checks whether two InstancedStructs (and the values contained within) are equal.
        
        Args:
            a (InstancedStruct): 
            b (InstancedStruct): 
        
        Returns:
            bool:
        """
        ...

class RigVM(Object):
    r"""
    The RigVM is the main object for evaluating FRigVMByteCode instructions.
    It combines the byte code, a list of required function pointers for
    execute instructions and required memory in one class.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVM.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_memory_storage_object`` (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4,
      deprecated: Please use DefaultDebugMemoryStorage for compiling and DebugMemoryStorage in the ExtendedExecuteContext for intance execution
    - ``literal_memory_storage_object`` (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4
      deprecated: Please, use LiteralMemoryStorage
    - ``work_memory_storage_object`` (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4
      deprecated: Please, use DefaultWorkMemoryStorage for compiling and WorkMemoryStorage in the ExtendedExecuteContext for intance execution
    """
    @property
    def work_memory_storage_object(self) -> RigVMMemoryStorage:
        r"""
        (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4
        deprecated: Please, use DefaultWorkMemoryStorage for compiling and WorkMemoryStorage in the ExtendedExecuteContext for intance execution
        """
        ...
    @work_memory_storage_object.setter
    def work_memory_storage_object(self, value: RigVMMemoryStorage) -> None:
        ...
    @property
    def literal_memory_storage_object(self) -> RigVMMemoryStorage:
        r"""
        (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4
        deprecated: Please, use LiteralMemoryStorage
        """
        ...
    @literal_memory_storage_object.setter
    def literal_memory_storage_object(self, value: RigVMMemoryStorage) -> None:
        ...
    @property
    def debug_memory_storage_object(self) -> RigVMMemoryStorage:
        r"""
        (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4,
        deprecated: Please use DefaultDebugMemoryStorage for compiling and DebugMemoryStorage in the ExtendedExecuteContext for intance execution
        """
        ...
    @debug_memory_storage_object.setter
    def debug_memory_storage_object(self, value: RigVMMemoryStorage) -> None:
        ...
    def set_parameter_value_vector2d(self, parameter_name: Name, value: Vector2D, array_index: int = 0) -> None:
        r"""
        x.set_parameter_value_vector2d(parameter_name, value, array_index=0) -> None
        Set Parameter Value Vector 2D
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            value (Vector2D): 
            array_index (int32):
        """
        ...
    def set_parameter_value_vector(self, parameter_name: Name, value: Vector, array_index: int = 0) -> None:
        r"""
        x.set_parameter_value_vector(parameter_name, value, array_index=0) -> None
        Set Parameter Value Vector
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            value (Vector): 
            array_index (int32):
        """
        ...
    def set_parameter_value_transform(self, parameter_name: Name, value: Transform, array_index: int = 0) -> None:
        r"""
        x.set_parameter_value_transform(parameter_name, value, array_index=0) -> None
        Set Parameter Value Transform
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            value (Transform): 
            array_index (int32):
        """
        ...
    def set_parameter_value_string(self, parameter_name: Name, value: str, array_index: int = 0) -> None:
        r"""
        x.set_parameter_value_string(parameter_name, value, array_index=0) -> None
        Set Parameter Value String
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            value (str): 
            array_index (int32):
        """
        ...
    def set_parameter_value_quat(self, parameter_name: Name, value: Quat, array_index: int = 0) -> None:
        r"""
        x.set_parameter_value_quat(parameter_name, value, array_index=0) -> None
        Set Parameter Value Quat
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            value (Quat): 
            array_index (int32):
        """
        ...
    def set_parameter_value_name(self, parameter_name: Name, value: Name, array_index: int = 0) -> None:
        r"""
        x.set_parameter_value_name(parameter_name, value, array_index=0) -> None
        Set Parameter Value Name
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            value (Name): 
            array_index (int32):
        """
        ...
    def set_parameter_value_int(self, parameter_name: Name, value: int, array_index: int = 0) -> None:
        r"""
        x.set_parameter_value_int(parameter_name, value, array_index=0) -> None
        Set Parameter Value Int
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            value (int32): 
            array_index (int32):
        """
        ...
    def set_parameter_value_float(self, parameter_name: Name, value: float, array_index: int = 0) -> None:
        r"""
        x.set_parameter_value_float(parameter_name, value, array_index=0) -> None
        Set Parameter Value Float
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            value (float): 
            array_index (int32):
        """
        ...
    def set_parameter_value_double(self, parameter_name: Name, value: float, array_index: int = 0) -> None:
        r"""
        x.set_parameter_value_double(parameter_name, value, array_index=0) -> None
        Set Parameter Value Double
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            value (double): 
            array_index (int32):
        """
        ...
    def set_parameter_value_bool(self, parameter_name: Name, value: bool, array_index: int = 0) -> None:
        r"""
        x.set_parameter_value_bool(parameter_name, value, array_index=0) -> None
        Set Parameter Value Bool
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            value (bool): 
            array_index (int32):
        """
        ...
    def get_statistics(self) -> RigVMStatistics:
        r"""
        x.get_statistics() -> RigVMStatistics
        returns the statistics information
        deprecated: Function 'GetStatistics' is deprecated.
        
        Returns:
            RigVMStatistics:
        """
        ...
    def get_parameter_value_vector2d(self, parameter_name: Name, array_index: int = 0) -> Vector2D:
        r"""
        x.get_parameter_value_vector2d(parameter_name, array_index=0) -> Vector2D
        Get Parameter Value Vector 2D
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            array_index (int32): 
        
        Returns:
            Vector2D:
        """
        ...
    def get_parameter_value_vector(self, parameter_name: Name, array_index: int = 0) -> Vector:
        r"""
        x.get_parameter_value_vector(parameter_name, array_index=0) -> Vector
        Get Parameter Value Vector
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            array_index (int32): 
        
        Returns:
            Vector:
        """
        ...
    def get_parameter_value_transform(self, parameter_name: Name, array_index: int = 0) -> Transform:
        r"""
        x.get_parameter_value_transform(parameter_name, array_index=0) -> Transform
        Get Parameter Value Transform
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            array_index (int32): 
        
        Returns:
            Transform:
        """
        ...
    def get_parameter_value_string(self, parameter_name: Name, array_index: int = 0) -> str:
        r"""
        x.get_parameter_value_string(parameter_name, array_index=0) -> str
        Get Parameter Value String
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            array_index (int32): 
        
        Returns:
            str:
        """
        ...
    def get_parameter_value_quat(self, parameter_name: Name, array_index: int = 0) -> Quat:
        r"""
        x.get_parameter_value_quat(parameter_name, array_index=0) -> Quat
        Get Parameter Value Quat
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            array_index (int32): 
        
        Returns:
            Quat:
        """
        ...
    def get_parameter_value_name(self, parameter_name: Name, array_index: int = 0) -> Name:
        r"""
        x.get_parameter_value_name(parameter_name, array_index=0) -> Name
        Get Parameter Value Name
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            array_index (int32): 
        
        Returns:
            Name:
        """
        ...
    def get_parameter_value_int(self, parameter_name: Name, array_index: int = 0) -> int:
        r"""
        x.get_parameter_value_int(parameter_name, array_index=0) -> int32
        Get Parameter Value Int
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            array_index (int32): 
        
        Returns:
            int32:
        """
        ...
    def get_parameter_value_float(self, parameter_name: Name, array_index: int = 0) -> float:
        r"""
        x.get_parameter_value_float(parameter_name, array_index=0) -> float
        Get Parameter Value Float
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            array_index (int32): 
        
        Returns:
            float:
        """
        ...
    def get_parameter_value_double(self, parameter_name: Name, array_index: int = 0) -> float:
        r"""
        x.get_parameter_value_double(parameter_name, array_index=0) -> double
        Get Parameter Value Double
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            array_index (int32): 
        
        Returns:
            double:
        """
        ...
    def get_parameter_value_bool(self, parameter_name: Name, array_index: int = 0) -> bool:
        r"""
        x.get_parameter_value_bool(parameter_name, array_index=0) -> bool
        Get Parameter Value Bool
        deprecated: This function has been deprecated and it is no longer supported, please, update your code.
        
        Args:
            parameter_name (Name): 
            array_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def execute(self, entry_name: Name = "None") -> Optional[RigVMExtendedExecuteContext]:
        r"""
        x.execute(entry_name="None") -> RigVMExtendedExecuteContext or None
        Execute
        deprecated: This function has been deprecated and it is no longer supported.
        
        Args:
            entry_name (Name): 
        
        Returns:
            RigVMExtendedExecuteContext or None: 
        
            context (RigVMExtendedExecuteContext):
        """
        ...

class NameSpacedUserData(AssetUserData):
    r"""
    User data that can be attached to assets to provide namespaced data access.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMAssetUserData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name_space`` (str):  [Read-Write] The namespace to use when looking up values inside of the user data.
    """
    ...

class DataAssetLink(NameSpacedUserData):
    r"""
    Namespaced user data which provides access to a linked data asset
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMAssetUserData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_asset`` (DataAsset):  [Read-Write] If assigned, the data asset link will provide access to the data asset's content.
    - ``name_space`` (str):  [Read-Write] The namespace to use when looking up values inside of the user data.
    """
    @property
    def data_asset(self) -> DataAsset:
        r"""
        (DataAsset):  [Read-Write] If assigned, the data asset link will provide access to the data asset's content.
        """
        ...
    @data_asset.setter
    def data_asset(self, value: DataAsset) -> None:
        ...

class RigVMNativized(RigVM):
    r"""
    Rig VMNativized
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMNativized.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``debug_memory_storage_object`` (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4,
      deprecated: Please use DefaultDebugMemoryStorage for compiling and DebugMemoryStorage in the ExtendedExecuteContext for intance execution
    - ``literal_memory_storage_object`` (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4
      deprecated: Please, use LiteralMemoryStorage
    - ``work_memory_storage_object`` (RigVMMemoryStorage):  [Read-Write] Deprecated 5.4
      deprecated: Please, use DefaultWorkMemoryStorage for compiling and WorkMemoryStorage in the ExtendedExecuteContext for intance execution
    """
    ...

class RigVMUserWorkflowOptions(Object):
    r"""
    Rig VMUser Workflow Options
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMUserWorkflow.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``subject`` (Object):  [Read-Write]
    - ``workflow`` (RigVMUserWorkflow):  [Read-Write]
    """
    @property
    def subject(self) -> Object:
        r"""
        (Object):  [Read-Only]
        """
        ...
    @property
    def workflow(self) -> RigVMUserWorkflow:
        r"""
        (RigVMUserWorkflow):  [Read-Only]
        """
        ...
    def requires_dialog(self) -> bool:
        r"""
        x.requires_dialog() -> bool
        Requires Dialog
        
        Returns:
            bool:
        """
        ...
    def report_warning(self, message: str) -> None:
        r"""
        x.report_warning(message) -> None
        Report Warning
        
        Args:
            message (str):
        """
        ...
    def report_info(self, message: str) -> None:
        r"""
        x.report_info(message) -> None
        Report Info
        
        Args:
            message (str):
        """
        ...
    def report_error(self, message: str) -> None:
        r"""
        x.report_error(message) -> None
        Report Error
        
        Args:
            message (str):
        """
        ...
    def is_valid(self) -> bool:
        r"""
        x.is_valid() -> bool
        Is Valid
        
        Returns:
            bool:
        """
        ...

class RigVMHost(Object):
    r"""
    set this to something larger than 0 to profile N runs
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMHost.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    """
    def supports_event(self, event_name: Name) -> bool:
        r"""
        x.supports_event(event_name) -> bool
        Supports Event
        
        Args:
            event_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def set_variable_from_string(self, variable_name: Name, value: str) -> bool:
        r"""
        x.set_variable_from_string(variable_name, value) -> bool
        Returns the value of a given variable as a string
        
        Args:
            variable_name (Name): 
            value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_frames_per_second(self, frames_per_second: float) -> None:
        r"""
        x.set_frames_per_second(frames_per_second) -> None
        Set the current fps
        
        Args:
            frames_per_second (float):
        """
        ...
    def set_delta_time(self, delta_time: float) -> None:
        r"""
        x.set_delta_time(delta_time) -> None
        Set the current delta time
        
        Args:
            delta_time (float):
        """
        ...
    def set_absolute_time(self, absolute_time: float, set_delta_time_zero: bool = False) -> None:
        r"""
        x.set_absolute_time(absolute_time, set_delta_time_zero=False) -> None
        Set the current absolute time
        
        Args:
            absolute_time (float): 
            set_delta_time_zero (bool):
        """
        ...
    def set_absolute_and_delta_time(self, absolute_time: float, delta_time: float) -> None:
        r"""
        x.set_absolute_and_delta_time(absolute_time, delta_time) -> None
        Set the current absolute and delta times
        
        Args:
            absolute_time (float): 
            delta_time (float):
        """
        ...
    def request_run_once_event(self, event_name: Name, event_index: int = -1) -> None:
        r"""
        x.request_run_once_event(event_name, event_index=-1) -> None
        Requests to run an event once
        
        Args:
            event_name (Name): 
            event_index (int32):
        """
        ...
    def request_init(self) -> None:
        r"""
        x.request_init() -> None
        Requests to perform an init during the next execution
        """
        ...
    def remove_run_once_event(self, event_name: Name) -> bool:
        r"""
        x.remove_run_once_event(event_name) -> bool
        Removes an event running once
        
        Args:
            event_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_init_required(self) -> bool:
        r"""
        x.is_init_required() -> bool
        Returns true if this host requires the VM memory to be initialized
        
        Returns:
            bool:
        """
        ...
    def get_vm(self) -> RigVM:
        r"""
        x.get_vm() -> RigVM
        Get VM
        
        Returns:
            RigVM:
        """
        ...
    def get_variable_type(self, variable_name: Name) -> Name:
        r"""
        x.get_variable_type(variable_name) -> Name
        Returns the type of a given variable
        
        Args:
            variable_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def get_variable_as_string(self, variable_name: Name) -> str:
        r"""
        x.get_variable_as_string(variable_name) -> str
        Returns the value of a given variable as a string
        
        Args:
            variable_name (Name): 
        
        Returns:
            str:
        """
        ...
    def get_supported_events(self) -> Array[Name]:
        r"""
        x.get_supported_events() -> Array[Name]
        Get Supported Events
        
        Returns:
            Array[Name]:
        """
        ...
    def get_script_accessible_variables(self) -> Array[Name]:
        r"""
        x.get_script_accessible_variables() -> Array[Name]
        Returns the names of variables accessible in scripting
        
        Returns:
            Array[Name]:
        """
        ...
    def get_extended_execute_context(self) -> RigVMExtendedExecuteContext:
        r"""
        x.get_extended_execute_context() -> RigVMExtendedExecuteContext
        Get Extended Execute Context
        deprecated: This function has been deprecated and it is no longer supported.
        
        Returns:
            RigVMExtendedExecuteContext:
        """
        ...
    def get_delta_time(self) -> float:
        r"""
        x.get_delta_time() -> float
        Gets the current delta time
        
        Returns:
            float:
        """
        ...
    def get_current_frames_per_second(self) -> float:
        r"""
        x.get_current_frames_per_second() -> float
        Returns the current frames per second (this may change over time)
        
        Returns:
            float:
        """
        ...
    def get_absolute_time(self) -> float:
        r"""
        x.get_absolute_time() -> float
        Gets the current absolute time
        
        Returns:
            float:
        """
        ...
    @classmethod
    def find_rig_vm_hosts(cls, outer: Object, optional_class: Class) -> Array[RigVMHost]:
        r"""
        X.find_rig_vm_hosts(outer, optional_class) -> Array[RigVMHost]
        Find Rig VMHosts
        
        Args:
            outer (Object): 
            optional_class (type(Class)): 
        
        Returns:
            Array[RigVMHost]:
        """
        ...
    def execute_event(self, event_name: Name) -> bool:
        r"""
        x.execute_event(event_name) -> bool
        Execute a user defined event
        
        Args:
            event_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def execute(self, event_name: Name) -> bool:
        r"""
        x.execute(event_name) -> bool
        Execute
        
        Args:
            event_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def can_execute(self) -> bool:
        r"""
        x.can_execute() -> bool
        Is valid for execution
        
        Returns:
            bool:
        """
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class RigVMBlueprint(Blueprint):
    r"""
    Rig VMBlueprint
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMBlueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blueprint_category`` (str):  [Read-Write] The category of the Blueprint, used to organize this Blueprint class when displayed in palette windows
    - ``blueprint_description`` (str):  [Read-Write] Shows up in the content browser tooltip when the blueprint is hovered
    - ``blueprint_display_name`` (str):  [Read-Write] Overrides the BP's display name in the editor UI
    - ``blueprint_namespace`` (str):  [Read-Write] The namespace of this blueprint (if set, the Blueprint will be treated differently for the context menu)
    - ``compile_mode`` (BlueprintCompileMode):  [Read-Write] The mode that will be used when compiling this class.
    - ``deprecate`` (bool):  [Read-Write] Deprecates the Blueprint, marking the generated class with the CLASS_Deprecated flag
    - ``generate_abstract_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a abstract class or not.  Should set CLASS_Abstract in the KismetCompiler.
    - ``generate_const_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a const class or not.  Should set CLASS_Const in the KismetCompiler.
    - ``hide_categories`` (Array[str]):  [Read-Write] Additional HideCategories. These are added to HideCategories from parent.
    - ``python_log_settings`` (RigVMPythonSettings):  [Read-Write]
    - ``rig_graph_display_settings`` (RigVMEdGraphDisplaySettings):  [Read-Write]
    - ``run_construction_script_in_sequencer`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor in sequencer
    - ``run_construction_script_on_drag`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor as you drag it in the editor, or only when the drag operation is complete
    - ``should_cook_property_guids_value`` (ShouldCookBlueprintPropertyGuids):  [Read-Write] Whether to include the property GUIDs for the generated class in a cooked build.
      note: This option may slightly increase memory usage in a cooked build, but can avoid needing to add CoreRedirect data for Blueprint classes stored within SaveGame archives.
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``vm_compile_settings`` (RigVMCompileSettings):  [Read-Write]
    - ``vm_runtime_settings`` (RigVMRuntimeSettings):  [Read-Write]
    """
    @property
    def vm_compile_settings(self) -> RigVMCompileSettings:
        r"""
        (RigVMCompileSettings):  [Read-Write]
        """
        ...
    @vm_compile_settings.setter
    def vm_compile_settings(self, value: RigVMCompileSettings) -> None:
        ...
    def suspend_notifications(self, suspend_notifs: bool) -> None:
        r"""
        x.suspend_notifications(suspend_notifs) -> None
        Suspend Notifications
        
        Args:
            suspend_notifs (bool):
        """
        ...
    def set_auto_vm_recompile(self, auto_recompile: bool) -> None:
        r"""
        x.set_auto_vm_recompile(auto_recompile) -> None
        Set Auto VMRecompile
        
        Args:
            auto_recompile (bool):
        """
        ...
    def request_rig_vm_init(self) -> None:
        r"""
        x.request_rig_vm_init() -> None
        Request Rig VMInit
        """
        ...
    def request_auto_vm_recompilation(self) -> None:
        r"""
        x.request_auto_vm_recompilation() -> None
        Request Auto VMRecompilation
        """
        ...
    def rename_member_variable(self, old_name: Name, new_name: Name) -> bool:
        r"""
        x.rename_member_variable(old_name, new_name) -> bool
        Rename Member Variable
        
        Args:
            old_name (Name): 
            new_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def remove_model(self, name: str = "Rig Graph", setup_undo_redo: bool = True, print_python_command: bool = True) -> bool:
        r"""
        x.remove_model(name="Rig Graph", setup_undo_redo=True, print_python_command=True) -> bool
        Remove Model
        
        Args:
            name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_member_variable(self, name: Name) -> bool:
        r"""
        x.remove_member_variable(name) -> bool
        Remove Member Variable
        
        Args:
            name (Name): 
        
        Returns:
            bool:
        """
        ...
    def recompile_vm_if_required(self) -> None:
        r"""
        x.recompile_vm_if_required() -> None
        Recompile VMIf Required
        """
        ...
    def recompile_vm(self) -> None:
        r"""
        x.recompile_vm() -> None
        Recompile VM
        """
        ...
    def get_rig_vm_host_class(self) -> Class:
        r"""
        x.get_rig_vm_host_class() -> type(Class)
        Get Rig VMHost Class
        
        Returns:
            type(Class):
        """
        ...
    def get_or_create_controller(self, graph: RigVMGraph = None) -> RigVMController:
        r"""
        x.get_or_create_controller(graph=None) -> RigVMController
        Get or Create Controller
        
        Args:
            graph (RigVMGraph): 
        
        Returns:
            RigVMController:
        """
        ...
    def get_model(self, ed_graph: EdGraph = None) -> RigVMGraph:
        r"""
        x.get_model(ed_graph=None) -> RigVMGraph
        Get Model
        
        Args:
            ed_graph (EdGraph): 
        
        Returns:
            RigVMGraph:
        """
        ...
    def get_member_variables(self) -> Array[RigVMGraphVariableDescription]:
        r"""
        x.get_member_variables() -> Array[RigVMGraphVariableDescription]
        Get Member Variables
        
        Returns:
            Array[RigVMGraphVariableDescription]:
        """
        ...
    def get_local_function_library(self) -> RigVMFunctionLibrary:
        r"""
        x.get_local_function_library() -> RigVMFunctionLibrary
        Get Local Function Library
        
        Returns:
            RigVMFunctionLibrary:
        """
        ...
    def get_focused_model(self) -> RigVMGraph:
        r"""
        x.get_focused_model() -> RigVMGraph
        Get Focused Model
        
        Returns:
            RigVMGraph:
        """
        ...
    def get_default_model(self) -> RigVMGraph:
        r"""
        x.get_default_model() -> RigVMGraph
        Get Default Model
        
        Returns:
            RigVMGraph:
        """
        ...
    def get_debugged_rig_vm_host(self) -> RigVMHost:
        r"""
        x.get_debugged_rig_vm_host() -> RigVMHost
        Get Debugged Rig VMHost
        
        Returns:
            RigVMHost:
        """
        ...
    def get_controller_by_name(self, graph_name: str = "") -> RigVMController:
        r"""
        x.get_controller_by_name(graph_name="") -> RigVMController
        Get Controller by Name
        
        Args:
            graph_name (str): 
        
        Returns:
            RigVMController:
        """
        ...
    def get_controller(self, graph: RigVMGraph = None) -> RigVMController:
        r"""
        x.get_controller(graph=None) -> RigVMController
        Get Controller
        
        Args:
            graph (RigVMGraph): 
        
        Returns:
            RigVMController:
        """
        ...
    def get_available_rig_vm_structs(self) -> Array[Struct]:
        r"""
        x.get_available_rig_vm_structs() -> Array[Struct]
        Get Available Rig VMStructs
        
        Returns:
            Array[Struct]:
        """
        ...
    def get_auto_vm_recompile(self) -> bool:
        r"""
        x.get_auto_vm_recompile() -> bool
        Get Auto VMRecompile
        
        Returns:
            bool:
        """
        ...
    def get_all_models(self) -> Array[RigVMGraph]:
        r"""
        x.get_all_models() -> Array[RigVMGraph]
        Get All Models
        
        Returns:
            Array[RigVMGraph]:
        """
        ...
    def generate_python_commands(self, new_blueprint_name: str) -> Array[str]:
        r"""
        x.generate_python_commands(new_blueprint_name) -> Array[str]
        Generate Python Commands
        
        Args:
            new_blueprint_name (str): 
        
        Returns:
            Array[str]:
        """
        ...
    def create_rig_vm_host(self) -> RigVMHost:
        r"""
        x.create_rig_vm_host() -> RigVMHost
        Create Rig VMHost
        
        Returns:
            RigVMHost:
        """
        ...
    def change_member_variable_type(self, name: Name, cpp_type: str, is_public: bool = False, is_read_only: bool = False, default_value: str = "") -> bool:
        r"""
        x.change_member_variable_type(name, cpp_type, is_public=False, is_read_only=False, default_value="") -> bool
        Change Member Variable Type
        
        Args:
            name (Name): 
            cpp_type (str): 
            is_public (bool): 
            is_read_only (bool): 
            default_value (str): 
        
        Returns:
            bool:
        """
        ...
    def add_model(self, name: str = "Rig Graph", setup_undo_redo: bool = True, print_python_command: bool = True) -> RigVMGraph:
        r"""
        x.add_model(name="Rig Graph", setup_undo_redo=True, print_python_command=True) -> RigVMGraph
        Add Model
        
        Args:
            name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMGraph:
        """
        ...
    def add_member_variable(self, name: Name, cpp_type: str, is_public: bool = False, is_read_only: bool = False, default_value: str = "") -> Name:
        r"""
        x.add_member_variable(name, cpp_type, is_public=False, is_read_only=False, default_value="") -> Name
        Add Member Variable
        
        Args:
            name (Name): 
            cpp_type (str): 
            is_public (bool): 
            is_read_only (bool): 
            default_value (str): 
        
        Returns:
            Name:
        """
        ...

class RigVMCompiler(Object):
    r"""
    Rig VMCompiler
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMCompiler.h
    
    """
    def compile_vm(self, graphs: Array[RigVMGraph], controller: RigVMController, out_vm: RigVM) -> Optional[RigVMExtendedExecuteContext]:
        r"""
        x.compile_vm(graphs, controller, out_vm) -> RigVMExtendedExecuteContext or None
        Compile VM
        
        Args:
            graphs (Array[RigVMGraph]): 
            controller (RigVMController): 
            out_vm (RigVM): 
        
        Returns:
            RigVMExtendedExecuteContext or None: 
        
            context (RigVMExtendedExecuteContext):
        """
        ...
    def compile(self, graphs: Array[RigVMGraph], controller: RigVMController, out_vm: RigVM) -> bool:
        r"""
        x.compile(graphs, controller, out_vm) -> bool
        Compile
        deprecated: Compile is deprecated, use CompileVM with Context parameter.
        
        Args:
            graphs (Array[RigVMGraph]): 
            controller (RigVMController): 
            out_vm (RigVM): 
        
        Returns:
            bool:
        """
        ...

class RigVMNode(Object):
    r"""
    The Node represents a single statement within a Graph.
    Nodes can represent values such as Variables / Parameters,
    they can represent Function Invocations or Control Flow
    logic statements (such as If conditions of For loops).
    Additionally Nodes are used to represent Comment statements.
    Nodes contain Pins to represent parameters for Function
    Invocations or Value access on Variables / Parameters.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMNode.h
    
    """
    def set_has_breakpoint(self, value: bool) -> None:
        r"""
        x.set_has_breakpoint(value) -> None
        Set Has Breakpoint
        
        Args:
            value (bool):
        """
        ...
    def set_execution_is_halted_at_this_node(self, value: bool) -> None:
        r"""
        x.set_execution_is_halted_at_this_node(value) -> None
        Set Execution Is Halted at This Node
        
        Args:
            value (bool):
        """
        ...
    def is_visible_in_ui(self) -> bool:
        r"""
        x.is_visible_in_ui() -> bool
        Returns true if this should be visible in the UI
        
        Returns:
            bool:
        """
        ...
    def is_selected(self) -> bool:
        r"""
        x.is_selected() -> bool
        Returns true if this Node is currently selected.
        
        Returns:
            bool:
        """
        ...
    def is_pure(self) -> bool:
        r"""
        x.is_pure() -> bool
        Returns true if this Node has no side-effects
        and no internal state.
        
        Returns:
            bool:
        """
        ...
    def is_mutable(self) -> bool:
        r"""
        x.is_mutable() -> bool
        Returns true if this Node has side effects or
        internal state.
        
        Returns:
            bool:
        """
        ...
    def is_loop_node(self) -> bool:
        r"""
        x.is_loop_node() -> bool
        return true if this node is a loop node
        
        Returns:
            bool:
        """
        ...
    def is_linked_to(self, node: RigVMNode) -> bool:
        r"""
        x.is_linked_to(node) -> bool
        Returns true if this Node is linked to another
        given node through any of the Nodes' Pins.
        
        Args:
            node (RigVMNode): 
        
        Returns:
            bool:
        """
        ...
    def is_input_aggregate(self) -> bool:
        r"""
        x.is_input_aggregate() -> bool
        Is Input Aggregate
        
        Returns:
            bool:
        """
        ...
    def is_injected(self) -> bool:
        r"""
        x.is_injected() -> bool
        Returns true if this is an injected node.
        Injected nodes are managed by pins are are not visible to the user.
        
        Returns:
            bool:
        """
        ...
    def is_event(self) -> bool:
        r"""
        x.is_event() -> bool
        Returns true if this Node is the beginning of a scope
        
        Returns:
            bool:
        """
        ...
    def is_defined_as_varying(self) -> bool:
        r"""
        x.is_defined_as_varying() -> bool
        Returns true if the node is defined as non-varying
        
        Returns:
            bool:
        """
        ...
    def is_defined_as_constant(self) -> bool:
        r"""
        x.is_defined_as_constant() -> bool
        Returns true if the node is defined as non-varying
        
        Returns:
            bool:
        """
        ...
    def is_decorator_pin(self, name: Name) -> bool:
        r"""
        x.is_decorator_pin(name) -> bool
        Is Decorator Pin
        
        Args:
            name (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_control_flow_node(self) -> bool:
        r"""
        x.is_control_flow_node() -> bool
        return true if this node is a control flow node
        
        Returns:
            bool:
        """
        ...
    def is_aggregate(self) -> bool:
        r"""
        x.is_aggregate() -> bool
        Is Aggregate
        
        Returns:
            bool:
        """
        ...
    def has_pin_of_direction(self, direction: RigVMPinDirection) -> bool:
        r"""
        x.has_pin_of_direction(direction) -> bool
        Returns true if the node has any pins of the provided direction
        
        Args:
            direction (RigVMPinDirection): 
        
        Returns:
            bool:
        """
        ...
    def has_output_pin(self, include_io: bool = True) -> bool:
        r"""
        x.has_output_pin(include_io=True) -> bool
        Returns true if the node has any output pins
        
        Args:
            include_io (bool): 
        
        Returns:
            bool:
        """
        ...
    def has_orphaned_pins(self) -> bool:
        r"""
        x.has_orphaned_pins() -> bool
        Returns true if the node has orphaned pins - which leads to a compiler error
        
        Returns:
            bool:
        """
        ...
    def has_lazy_pin(self, only_consider_pins_with_links: bool = False) -> bool:
        r"""
        x.has_lazy_pin(only_consider_pins_with_links=False) -> bool
        Returns true if the node has any lazily evaluating pins
        
        Args:
            only_consider_pins_with_links (bool): 
        
        Returns:
            bool:
        """
        ...
    def has_io_pin(self) -> bool:
        r"""
        x.has_io_pin() -> bool
        Returns true if the node has any io pins
        
        Returns:
            bool:
        """
        ...
    def has_input_pin(self, include_io: bool = True) -> bool:
        r"""
        x.has_input_pin(include_io=True) -> bool
        Returns true if the node has any input pins
        
        Args:
            include_io (bool): 
        
        Returns:
            bool:
        """
        ...
    def has_breakpoint(self) -> bool:
        r"""
        x.has_breakpoint() -> bool
        Has Breakpoint
        
        Returns:
            bool:
        """
        ...
    def get_tool_tip_text(self) -> Text:
        r"""
        x.get_tool_tip_text() -> Text
        Returns the tooltip of this node
        
        Returns:
            Text:
        """
        ...
    def get_supported_workflows(self, type: RigVMUserWorkflowType, subject: Object) -> Array[RigVMUserWorkflow]:
        r"""
        x.get_supported_workflows(type, subject) -> Array[RigVMUserWorkflow]
        returns all supported workflows of the node
        
        Args:
            type (RigVMUserWorkflowType): 
            subject (Object): 
        
        Returns:
            Array[RigVMUserWorkflow]:
        """
        ...
    def get_size(self) -> Vector2D:
        r"""
        x.get_size() -> Vector2D
        Returns the 2d size of this node - used for UI.
        
        Returns:
            Vector2D:
        """
        ...
    def get_second_aggregate_pin(self) -> RigVMPin:
        r"""
        x.get_second_aggregate_pin() -> RigVMPin
        Get Second Aggregate Pin
        
        Returns:
            RigVMPin:
        """
        ...
    def get_root_graph(self) -> RigVMGraph:
        r"""
        x.get_root_graph() -> RigVMGraph
        Returns the top level / root Graph of this Node
        
        Returns:
            RigVMGraph:
        """
        ...
    def get_previous_f_name(self) -> Name:
        r"""
        x.get_previous_f_name() -> Name
        Returns the name of the node prior to the renaming
        
        Returns:
            Name:
        """
        ...
    def get_position(self) -> Vector2D:
        r"""
        x.get_position() -> Vector2D
        Returns the 2d position of this node - used for UI.
        
        Returns:
            Vector2D:
        """
        ...
    def get_pins(self) -> Array[RigVMPin]:
        r"""
        x.get_pins() -> Array[RigVMPin]
        Returns all of the top-level Pins of this Node.
        
        Returns:
            Array[RigVMPin]:
        """
        ...
    def get_orphaned_pins(self) -> Array[RigVMPin]:
        r"""
        x.get_orphaned_pins() -> Array[RigVMPin]
        Returns all of the top-level orphaned Pins of this Node.
        
        Returns:
            Array[RigVMPin]:
        """
        ...
    def get_opposite_aggregate_pin(self) -> RigVMPin:
        r"""
        x.get_opposite_aggregate_pin() -> RigVMPin
        Get Opposite Aggregate Pin
        
        Returns:
            RigVMPin:
        """
        ...
    def get_node_title(self) -> str:
        r"""
        x.get_node_title() -> str
        Returns the title of this Node - used for UI.
        
        Returns:
            str:
        """
        ...
    def get_node_path(self, recursive: bool = False) -> str:
        r"""
        x.get_node_path(recursive=False) -> str
        Returns the a . separated string containing all of the
        names used to reach this Node within the Graph.
        (for now this is the same as the Node's name)
        
        Args:
            recursive (bool): 
        
        Returns:
            str:
        """
        ...
    def get_node_index(self) -> int:
        r"""
        x.get_node_index() -> int32
        Returns the current index of the Node within the Graph.
        
        Returns:
            int32:
        """
        ...
    def get_node_color(self) -> LinearColor:
        r"""
        x.get_node_color() -> LinearColor
        Returns the color of this node - used for UI.
        
        Returns:
            LinearColor:
        """
        ...
    def get_next_aggregate_name(self, last_aggregate_pin_name: Name) -> Name:
        r"""
        x.get_next_aggregate_name(last_aggregate_pin_name) -> Name
        Get Next Aggregate Name
        
        Args:
            last_aggregate_pin_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def get_links(self) -> Array[RigVMLink]:
        r"""
        x.get_links() -> Array[RigVMLink]
        Returns all links to any pin on this node
        
        Returns:
            Array[RigVMLink]:
        """
        ...
    def get_linked_target_nodes(self) -> Array[RigVMNode]:
        r"""
        x.get_linked_target_nodes() -> Array[RigVMNode]
        Returns a list of Nodes connected as targets to
        this Node as the source.
        
        Returns:
            Array[RigVMNode]:
        """
        ...
    def get_linked_source_nodes(self) -> Array[RigVMNode]:
        r"""
        x.get_linked_source_nodes() -> Array[RigVMNode]
        Returns a list of Nodes connected as sources to
        this Node as the target.
        
        Returns:
            Array[RigVMNode]:
        """
        ...
    def get_injection_info(self) -> RigVMInjectionInfo:
        r"""
        x.get_injection_info() -> RigVMInjectionInfo
        Returns the injection info of this Node (or nullptr)
        
        Returns:
            RigVMInjectionInfo:
        """
        ...
    def get_graph_depth(self) -> int:
        r"""
        x.get_graph_depth() -> int32
        Returns the graph nesting depth of this node
        
        Returns:
            int32:
        """
        ...
    def get_graph(self) -> RigVMGraph:
        r"""
        x.get_graph() -> RigVMGraph
        Returns the Graph of this Node
        
        Returns:
            RigVMGraph:
        """
        ...
    def get_first_aggregate_pin(self) -> RigVMPin:
        r"""
        x.get_first_aggregate_pin() -> RigVMPin
        Get First Aggregate Pin
        
        Returns:
            RigVMPin:
        """
        ...
    def get_event_name(self) -> Name:
        r"""
        x.get_event_name() -> Name
        Returns the name of the event
        
        Returns:
            Name:
        """
        ...
    def get_decorator_pins(self) -> Array[RigVMPin]:
        r"""
        x.get_decorator_pins() -> Array[RigVMPin]
        Get Decorator Pins
        
        Returns:
            Array[RigVMPin]:
        """
        ...
    def get_all_pins_recursively(self) -> Array[RigVMPin]:
        r"""
        x.get_all_pins_recursively() -> Array[RigVMPin]
        Returns all of the Pins of this Node (including SubPins).
        
        Returns:
            Array[RigVMPin]:
        """
        ...
    def get_aggregate_outputs(self) -> Array[RigVMPin]:
        r"""
        x.get_aggregate_outputs() -> Array[RigVMPin]
        Get Aggregate Outputs
        
        Returns:
            Array[RigVMPin]:
        """
        ...
    def get_aggregate_inputs(self) -> Array[RigVMPin]:
        r"""
        x.get_aggregate_inputs() -> Array[RigVMPin]
        Get Aggregate Inputs
        
        Returns:
            Array[RigVMPin]:
        """
        ...
    def find_pin(self, pin_path: str) -> RigVMPin:
        r"""
        x.find_pin(pin_path) -> RigVMPin
        Returns a Pin given it's partial pin path below
        this node (for example: "Color.R")
        
        Args:
            pin_path (str): 
        
        Returns:
            RigVMPin:
        """
        ...
    def find_function_for_node(self) -> RigVMLibraryNode:
        r"""
        x.find_function_for_node() -> RigVMLibraryNode
        Find Function for Node
        
        Returns:
            RigVMLibraryNode:
        """
        ...
    def execution_is_halted_at_this_node(self) -> bool:
        r"""
        x.execution_is_halted_at_this_node() -> bool
        Execution Is Halted at This Node
        
        Returns:
            bool:
        """
        ...
    def can_only_exist_once(self) -> bool:
        r"""
        x.can_only_exist_once() -> bool
        Returns true if this node can only exist once in a graph
        
        Returns:
            bool:
        """
        ...
    def can_be_upgraded(self) -> bool:
        r"""
        x.can_be_upgraded() -> bool
        returns true if the node can be upgraded
        
        Returns:
            bool:
        """
        ...

class RigVMTemplateNode(RigVMNode):
    r"""
    The Template Node represents an unresolved function.
    Template nodes can morph into all functions implementing
    the template's template.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMTemplateNode.h
    
    """
    def is_singleton(self) -> bool:
        r"""
        x.is_singleton() -> bool
        Is Singleton
        
        Returns:
            bool:
        """
        ...
    def is_resolved(self) -> bool:
        r"""
        x.is_resolved() -> bool
        returns true if the template node is resolved
        
        Returns:
            bool:
        """
        ...
    def is_fully_unresolved(self) -> bool:
        r"""
        x.is_fully_unresolved() -> bool
        returns true if the template is fully unresolved
        
        Returns:
            bool:
        """
        ...
    def get_script_struct(self) -> ScriptStruct:
        r"""
        x.get_script_struct() -> ScriptStruct
        Returns the UStruct for this unit node
        (the struct declaring the RIGVM_METHOD)
        
        Returns:
            ScriptStruct:
        """
        ...
    def get_notation(self) -> Name:
        r"""
        x.get_notation() -> Name
        Returns the notation of the node
        
        Returns:
            Name:
        """
        ...

class RigVMLibraryNode(RigVMTemplateNode):
    r"""
    The Library Node represents a function invocation of a
    function specified somewhere else. The function can be
    expressed as a sub-graph (RigVMGroupNode) or as a
    referenced function (RigVMFunctionNode).
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMLibraryNode.h
    
    """
    def get_library(self) -> RigVMFunctionLibrary:
        r"""
        x.get_library() -> RigVMFunctionLibrary
        Get Library
        
        Returns:
            RigVMFunctionLibrary:
        """
        ...
    def get_contained_graph(self) -> RigVMGraph:
        r"""
        x.get_contained_graph() -> RigVMGraph
        Get Contained Graph
        
        Returns:
            RigVMGraph:
        """
        ...

class RigVMCollapseNode(RigVMLibraryNode):
    r"""
    The Collapse Node is a library node which stores the
    function and its nodes directly within the node itself.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMCollapseNode.h
    
    """
    ...

class RigVMAggregateNode(RigVMCollapseNode):
    r"""
    The Aggregate Node contains a subgraph of nodes with aggregate pins (2in+1out or 1out+2in) connected
    to each other. For example, a unit node IntAdd which adds 2 integers and provides Result=A+B could have
    A, B and Result as aggregates in order to add additional input pins to construct an Aggregate Node that computes
    Result=A+B+C.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMAggregateNode.h
    
    """
    ...

class RigVMArrayNode(RigVMTemplateNode):
    r"""
    The Array Node represents one of a series available
    array operations such as SetNum, GetAtIndex etc.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMArrayNode.h
    
    """
    def get_op_code(self) -> RigVMOpCode:
        r"""
        x.get_op_code() -> RigVMOpCode
        Returns the op code of this node
        
        Returns:
            RigVMOpCode:
        """
        ...
    def get_cpp_type_object(self) -> Object:
        r"""
        x.get_cpp_type_object() -> Object
        Returns the C++ data type struct of the array (or nullptr)
        
        Returns:
            Object:
        """
        ...
    def get_cpp_type(self) -> str:
        r"""
        x.get_cpp_type() -> str
        Returns the C++ data type of the element
        
        Returns:
            str:
        """
        ...

class RigVMBranchNode(RigVMNode):
    r"""
    A branch node is used to branch between two blocks of execution
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMBranchNode.h
    
    """
    ...

class RigVMCommentNode(RigVMNode):
    r"""
    Comment Nodes can be used to annotate a Graph by adding
    colored grouping as well as user provided text.
    Comment Nodes are purely cosmetic and don't contribute
    to the runtime result of the Graph / Function.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMCommentNode.h
    
    """
    def get_comment_text(self) -> str:
        r"""
        x.get_comment_text() -> str
        Returns the current user provided text of this comment.
        
        Returns:
            str:
        """
        ...
    def get_comment_font_size(self) -> int:
        r"""
        x.get_comment_font_size() -> int32
        Returns the current user provided font size of this comment.
        
        Returns:
            int32:
        """
        ...
    def get_comment_color_bubble(self) -> bool:
        r"""
        x.get_comment_color_bubble() -> bool
        Returns the current user provided bubble color inheritance of this comment.
        
        Returns:
            bool:
        """
        ...
    def get_comment_bubble_visible(self) -> bool:
        r"""
        x.get_comment_bubble_visible() -> bool
        Returns the current user provided bubble visibility of this comment.
        
        Returns:
            bool:
        """
        ...

class RigVMDispatchNode(RigVMTemplateNode):
    r"""
    The Struct Node represents a Function Invocation of a RIGVM_METHOD
    declared on a USTRUCT. Struct Nodes have input / output pins for all
    struct UPROPERTY members.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMDispatchNode.h
    
    """
    ...

class RigVMEnumNode(RigVMNode):
    r"""
    The Enum Node represents a constant enum value for use within the graph.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMEnumNode.h
    
    """
    def get_enum(self) -> Enum:
        r"""
        x.get_enum() -> Enum
        Returns the enum itself
        
        Returns:
            Enum:
        """
        ...
    def get_cpp_type_object(self) -> Object:
        r"""
        x.get_cpp_type_object() -> Object
        Returns the C++ data type struct of the parameter (or nullptr)
        
        Returns:
            Object:
        """
        ...
    def get_cpp_type(self) -> str:
        r"""
        x.get_cpp_type() -> str
        Returns the C++ data type of the parameter
        
        Returns:
            str:
        """
        ...

class RigVMFunctionEntryNode(RigVMTemplateNode):
    r"""
    The Function Entry node is used to provide access to the
    input pins of the library node for links within.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMFunctionEntryNode.h
    
    """
    ...

class RigVMFunctionReferenceNode(RigVMLibraryNode):
    r"""
    The Function Reference Node is a library node which references
    a library node from a separate function library graph.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMFunctionReferenceNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``referenced_node_ptr`` (RigVMLibraryNode):  [Read-Write]
      deprecated: Property 'ReferencedNodePtr' is deprecated.
    """
    @property
    def referenced_node_ptr(self) -> RigVMLibraryNode:
        r"""
        (RigVMLibraryNode):  [Read-Write]
        deprecated: Property 'ReferencedNodePtr' is deprecated.
        """
        ...
    @referenced_node_ptr.setter
    def referenced_node_ptr(self, value: RigVMLibraryNode) -> None:
        ...
    def get_referenced_function_header(self) -> RigVMGraphFunctionHeader:
        r"""
        x.get_referenced_function_header() -> RigVMGraphFunctionHeader
        Get Referenced Function Header for Blueprint
        
        Returns:
            RigVMGraphFunctionHeader:
        """
        ...

class RigVMFunctionReturnNode(RigVMTemplateNode):
    r"""
    The Function Return node is used to provide access to the
    output pins of the library node for links within.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMFunctionReturnNode.h
    
    """
    ...

class RigVMIfNode(RigVMTemplateNode):
    r"""
    A if node is used to pick between two values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMIfNode.h
    
    """
    ...

class RigVMInvokeEntryNode(RigVMNode):
    r"""
    The Invoke Entry Node is used to invoke another entry from the
    the currently running entry.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMInvokeEntryNode.h
    
    """
    def get_entry_name(self) -> Name:
        r"""
        x.get_entry_name() -> Name
        Returns the name of the entry to run
        
        Returns:
            Name:
        """
        ...

class RigVMParameterNode(RigVMNode):
    r"""
    The Parameter Node represents an input or output argument / parameter
    of the Function / Graph. Parameter Node have only a single value pin.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMParameterNode.h
    
    """
    def is_input(self) -> bool:
        r"""
        x.is_input() -> bool
        Returns true if this node is an input
        
        Returns:
            bool:
        """
        ...
    def get_parameter_name(self) -> Name:
        r"""
        x.get_parameter_name() -> Name
        Returns the name of the parameter
        
        Returns:
            Name:
        """
        ...
    def get_parameter_description(self) -> RigVMGraphParameterDescription:
        r"""
        x.get_parameter_description() -> RigVMGraphParameterDescription
        Returns this parameter node's parameter description
        
        Returns:
            RigVMGraphParameterDescription:
        """
        ...
    def get_default_value(self) -> str:
        r"""
        x.get_default_value() -> str
        Returns the default value of the parameter as a string
        
        Returns:
            str:
        """
        ...
    def get_cpp_type_object(self) -> Object:
        r"""
        x.get_cpp_type_object() -> Object
        Returns the C++ data type struct of the parameter (or nullptr)
        
        Returns:
            Object:
        """
        ...
    def get_cpp_type(self) -> str:
        r"""
        x.get_cpp_type() -> str
        Returns the C++ data type of the parameter
        
        Returns:
            str:
        """
        ...

class RigVMRerouteNode(RigVMNode):
    r"""
    A reroute node is used to visually improve the
    data flow within a Graph. Reroutes are purely
    cosmetic and have no impact on the resulting
    VM whatsoever. Reroutes can furthermore be
    displayed as full nodes or as small circles.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMRerouteNode.h
    
    """
    ...

class RigVMSelectNode(RigVMTemplateNode):
    r"""
    A select node is used to select between multiple values
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMSelectNode.h
    
    """
    ...

class RigVMUnitNode(RigVMTemplateNode):
    r"""
    The Struct Node represents a Function Invocation of a RIGVM_METHOD
    declared on a USTRUCT. Struct Nodes have input / output pins for all
    struct UPROPERTY members.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMUnitNode.h
    
    """
    def get_struct_default_value(self) -> str:
        r"""
        x.get_struct_default_value() -> str
        Returns the default value for the struct as text
        
        Returns:
            str:
        """
        ...
    def get_method_name(self) -> Name:
        r"""
        x.get_method_name() -> Name
        Returns the name of the declared RIGVM_METHOD
        
        Returns:
            Name:
        """
        ...

class RigVMStructNode(RigVMUnitNode):
    r"""
    deprecated: 'RigVMStructNode' was renamed to 'RigVMUnitNode'.
    """
    ...

class RigVMVariableNode(RigVMNode):
    r"""
    The Variable Node represents a mutable value / local state within the
    the Function / Graph. Variable Node's can be a getter or a setter.
    Getters are pure nodes with just an output value pin, while setters
    are mutable nodes with an execute and input value pin.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMVariableNode.h
    
    """
    def is_local_variable(self) -> bool:
        r"""
        x.is_local_variable() -> bool
        Returns true if this variable is a local variable
        
        Returns:
            bool:
        """
        ...
    def is_input_argument(self) -> bool:
        r"""
        x.is_input_argument() -> bool
        Returns true if this variable is an input argument
        
        Returns:
            bool:
        """
        ...
    def is_getter(self) -> bool:
        r"""
        x.is_getter() -> bool
        Returns true if this node is a variable getter
        
        Returns:
            bool:
        """
        ...
    def is_external_variable(self) -> bool:
        r"""
        x.is_external_variable() -> bool
        Returns true if this variable is an external variable
        
        Returns:
            bool:
        """
        ...
    def get_variable_name(self) -> Name:
        r"""
        x.get_variable_name() -> Name
        Returns the name of the variable
        
        Returns:
            Name:
        """
        ...
    def get_variable_description(self) -> RigVMGraphVariableDescription:
        r"""
        x.get_variable_description() -> RigVMGraphVariableDescription
        Returns this variable node's variable description
        
        Returns:
            RigVMGraphVariableDescription:
        """
        ...
    def get_default_value(self) -> str:
        r"""
        x.get_default_value() -> str
        Returns the default value of the variable as a string
        
        Returns:
            str:
        """
        ...
    def get_cpp_type_object(self) -> Object:
        r"""
        x.get_cpp_type_object() -> Object
        Returns the C++ data type struct of the variable (or nullptr)
        
        Returns:
            Object:
        """
        ...
    def get_cpp_type(self) -> str:
        r"""
        x.get_cpp_type() -> str
        Returns the C++ data type of the variable
        
        Returns:
            str:
        """
        ...

class RigVMController(Object):
    r"""
    The Controller is the sole authority to perform changes
    on the Graph. The Controller itself is stateless.
    The Controller offers a Modified event to subscribe to
    for user interface views - so they can be informed about
    any change that's happening within the Graph.
    The Controller routes all changes through the Graph itself,
    so you can have N Controllers performing edits on 1 Graph,
    and N Views subscribing to 1 Controller.
    In Python you can also subscribe to this event to be
    able to react to topological changes of the Graph there.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMController.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``modified_event`` (RigVMGraphModifiedDynamicEvent):  [Read-Write]
    """
    @property
    def modified_event(self) -> RigVMGraphModifiedDynamicEvent:
        r"""
        (RigVMGraphModifiedDynamicEvent):  [Read-Only]
        """
        ...
    def upgrade_nodes(self, node_names: Array[Name], recursive: bool = True, setup_undo_redo: bool = True, print_python_command: bool = False) -> Array[RigVMNode]:
        r"""
        x.upgrade_nodes(node_names, recursive=True, setup_undo_redo=True, print_python_command=False) -> Array[RigVMNode]
        Upgrades a set of nodes with each corresponding next known version
        
        Args:
            node_names (Array[Name]): 
            recursive (bool): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            Array[RigVMNode]:
        """
        ...
    def unresolve_template_nodes(self, node_names: Array[Name], setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.unresolve_template_nodes(node_names, setup_undo_redo=True, print_python_command=False) -> bool
        Turns a resolved templated node(s) back into its template.
        
        Args:
            node_names (Array[Name]): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def undo(self) -> bool:
        r"""
        x.undo() -> bool
        Un-does the last action on the stack.
        Note: This should really only be used for unit tests,
        use the GEditor's main Undo method instead.
        
        Returns:
            bool:
        """
        ...
    def unbind_pin_from_variable(self, pin_path: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.unbind_pin_from_variable(pin_path, setup_undo_redo=True, print_python_command=False) -> bool
        Removes the binging of a pin to a variable
        This causes a PinBoundVariableChanged modified event.
        
        Args:
            pin_path (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_unit_node_defaults(self, node: RigVMUnitNode, defaults: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.set_unit_node_defaults(node, defaults, setup_undo_redo=True, print_python_command=False) -> bool
        Adds a Function / Struct Node to the edited Graph.
        UnitNode represent a RIGVM_METHOD declaration on a USTRUCT.
        This causes a NodeAdded modified event.
        
        Args:
            node (RigVMUnitNode): 
            defaults (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_schema(self, schema: RigVMSchema) -> None:
        r"""
        x.set_schema(schema) -> None
        Sets the schema on the controller
        
        Args:
            schema (RigVMSchema):
        """
        ...
    def set_remapped_variable(self, function_ref_node: RigVMFunctionReferenceNode, inner_variable_name: Name, outer_variable_name: Name, setup_undo_redo: bool = True) -> bool:
        r"""
        x.set_remapped_variable(function_ref_node, inner_variable_name, outer_variable_name, setup_undo_redo=True) -> bool
        Sets the remapped variable on a function reference node
        
        Args:
            function_ref_node (RigVMFunctionReferenceNode): 
            inner_variable_name (Name): 
            outer_variable_name (Name): 
            setup_undo_redo (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_pin_is_watched(self, pin_path: str, is_watched: bool, setup_undo_redo: bool = True) -> bool:
        r"""
        x.set_pin_is_watched(pin_path, is_watched, setup_undo_redo=True) -> bool
        Sets the pin to be watched (or not)
        This causes a PinWatchedChanged modified event.
        
        Args:
            pin_path (str): 
            is_watched (bool): 
            setup_undo_redo (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_pin_expansion(self, pin_path: str, is_expanded: bool, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.set_pin_expansion(pin_path, is_expanded, setup_undo_redo=True, print_python_command=False) -> bool
        Sets the pin to be expanded or not
        This causes a PinExpansionChanged modified event.
        
        Args:
            pin_path (str): 
            is_expanded (bool): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_pin_default_value(self, pin_path: str, default_value: str, resize_arrays: bool = True, setup_undo_redo: bool = True, merge_undo_action: bool = False, print_python_command: bool = False, set_value_on_linked_pins: bool = True) -> bool:
        r"""
        x.set_pin_default_value(pin_path, default_value, resize_arrays=True, setup_undo_redo=True, merge_undo_action=False, print_python_command=False, set_value_on_linked_pins=True) -> bool
        Sets the default value of a pin given its pinpath.
        This causes a PinDefaultValueChanged modified event.
        
        Args:
            pin_path (str): 
            default_value (str): 
            resize_arrays (bool): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
            print_python_command (bool): 
            set_value_on_linked_pins (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_size_by_name(self, node_name: Name, size: Vector2D, setup_undo_redo: bool = True, merge_undo_action: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.set_node_size_by_name(node_name, size, setup_undo_redo=True, merge_undo_action=False, print_python_command=False) -> bool
        Sets the size of a node in the graph by name.
        This causes a NodeSizeChanged modified event.
        
        Args:
            node_name (Name): 
            size (Vector2D): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_size(self, node: RigVMNode, size: Vector2D, setup_undo_redo: bool = True, merge_undo_action: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.set_node_size(node, size, setup_undo_redo=True, merge_undo_action=False, print_python_command=False) -> bool
        Sets the size of a node in the graph.
        This causes a NodeSizeChanged modified event.
        
        Args:
            node (RigVMNode): 
            size (Vector2D): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_selection(self, node_names: Array[Name], setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.set_node_selection(node_names, setup_undo_redo=True, print_python_command=False) -> bool
        Selects the nodes given the selection
        This might cause several NodeDeselected modified event.
        
        Args:
            node_names (Array[Name]): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_position_by_name(self, node_name: Name, position: Vector2D, setup_undo_redo: bool = True, merge_undo_action: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.set_node_position_by_name(node_name, position, setup_undo_redo=True, merge_undo_action=False, print_python_command=False) -> bool
        Sets the position of a node in the graph by name.
        This causes a NodePositionChanged modified event.
        
        Args:
            node_name (Name): 
            position (Vector2D): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_position(self, node: RigVMNode, position: Vector2D, setup_undo_redo: bool = True, merge_undo_action: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.set_node_position(node, position, setup_undo_redo=True, merge_undo_action=False, print_python_command=False) -> bool
        Sets the position of a node in the graph.
        This causes a NodePositionChanged modified event.
        
        Args:
            node (RigVMNode): 
            position (Vector2D): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_keywords_by_name(self, node_name: Name, keywords: str, setup_undo_redo: bool = True, merge_undo_action: bool = False) -> bool:
        r"""
        x.set_node_keywords_by_name(node_name, keywords, setup_undo_redo=True, merge_undo_action=False) -> bool
        Sets the keywords of a node in the graph.
        This causes a NodeKeywordsChanged modified event.
        
        Args:
            node_name (Name): 
            keywords (str): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_keywords(self, node: RigVMCollapseNode, keywords: str, setup_undo_redo: bool = True, merge_undo_action: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.set_node_keywords(node, keywords, setup_undo_redo=True, merge_undo_action=False, print_python_command=False) -> bool
        Sets the keywords of a node in the graph.
        This causes a NodeKeywordsChanged modified event.
        
        Args:
            node (RigVMCollapseNode): 
            keywords (str): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_description_by_name(self, node_name: Name, description: str, setup_undo_redo: bool = True, merge_undo_action: bool = False) -> bool:
        r"""
        x.set_node_description_by_name(node_name, description, setup_undo_redo=True, merge_undo_action=False) -> bool
        Sets the keywords of a node in the graph.
        This causes a NodeDescriptionChanged modified event.
        
        Args:
            node_name (Name): 
            description (str): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_description(self, node: RigVMCollapseNode, description: str, setup_undo_redo: bool = True, merge_undo_action: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.set_node_description(node, description, setup_undo_redo=True, merge_undo_action=False, print_python_command=False) -> bool
        Sets the function description of a node in the graph.
        This causes a NodeDescriptionChanged modified event.
        
        Args:
            node (RigVMCollapseNode): 
            description (str): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_color_by_name(self, node_name: Name, color: LinearColor, setup_undo_redo: bool = True, merge_undo_action: bool = False) -> bool:
        r"""
        x.set_node_color_by_name(node_name, color, setup_undo_redo=True, merge_undo_action=False) -> bool
        Sets the color of a node in the graph by name.
        This causes a NodeColorChanged modified event.
        
        Args:
            node_name (Name): 
            color (LinearColor): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_color(self, node: RigVMNode, color: LinearColor, setup_undo_redo: bool = True, merge_undo_action: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.set_node_color(node, color, setup_undo_redo=True, merge_undo_action=False, print_python_command=False) -> bool
        Sets the color of a node in the graph.
        This causes a NodeColorChanged modified event.
        
        Args:
            node (RigVMNode): 
            color (LinearColor): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_category_by_name(self, node_name: Name, category: str, setup_undo_redo: bool = True, merge_undo_action: bool = False) -> bool:
        r"""
        x.set_node_category_by_name(node_name, category, setup_undo_redo=True, merge_undo_action=False) -> bool
        Sets the category of a node in the graph.
        This causes a NodeCategoryChanged modified event.
        
        Args:
            node_name (Name): 
            category (str): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_node_category(self, node: RigVMCollapseNode, category: str, setup_undo_redo: bool = True, merge_undo_action: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.set_node_category(node, category, setup_undo_redo=True, merge_undo_action=False, print_python_command=False) -> bool
        Sets the category of a node in the graph.
        This causes a NodeCategoryChanged modified event.
        
        Args:
            node (RigVMCollapseNode): 
            category (str): 
            setup_undo_redo (bool): 
            merge_undo_action (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_local_variable_type_from_object_path(self, variable_name: Name, cpp_type: str, cpp_type_object_path: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.set_local_variable_type_from_object_path(variable_name, cpp_type, cpp_type_object_path, setup_undo_redo=True, print_python_command=False) -> bool
        Set Local Variable Type from Object Path
        
        Args:
            variable_name (Name): 
            cpp_type (str): 
            cpp_type_object_path (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_local_variable_type(self, variable_name: Name, cpp_type: str, cpp_type_object: Object, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.set_local_variable_type(variable_name, cpp_type, cpp_type_object, setup_undo_redo=True, print_python_command=False) -> bool
        Sets the type of the local variable
        
        Args:
            variable_name (Name): 
            cpp_type (str): 
            cpp_type_object (Object): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_local_variable_default_value(self, variable_name: Name, default_value: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.set_local_variable_default_value(variable_name, default_value, setup_undo_redo=True, print_python_command=False) -> bool
        Set Local Variable Default Value
        
        Args:
            variable_name (Name): 
            default_value (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_is_running_unit_test(self, is_running: bool) -> None:
        r"""
        x.set_is_running_unit_test(is_running) -> None
        Helper function to disable a series of checks that can be ignored during a unit test
        
        Args:
            is_running (bool):
        """
        ...
    def set_graph(self, graph: RigVMGraph) -> None:
        r"""
        x.set_graph(graph) -> None
        Sets the currently edited Graph of this controller.
        This causes a GraphChanged modified event.
        deprecated: Function has been deprecated, please rely on GetControllerForGraph instead.
        
        Args:
            graph (RigVMGraph):
        """
        ...
    def set_exposed_pin_index(self, pin_name: Name, new_index: int, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.set_exposed_pin_index(pin_name, new_index, setup_undo_redo=True, print_python_command=False) -> bool
        Sets the index for an exposed pin. This can be used to move the pin up and down on the node.
        
        Args:
            pin_name (Name): 
            new_index (int32): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_comment_text_by_name(self, node_name: Name, comment_text: str, comment_font_size: int, comment_bubble_visible: bool, comment_color_bubble: bool, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.set_comment_text_by_name(node_name, comment_text, comment_font_size, comment_bubble_visible, comment_color_bubble, setup_undo_redo=True, print_python_command=False) -> bool
        Sets the comment text and properties of a comment node in the graph by name.
        This causes a CommentTextChanged modified event.
        
        Args:
            node_name (Name): 
            comment_text (str): 
            comment_font_size (int32): 
            comment_bubble_visible (bool): 
            comment_color_bubble (bool): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_comment_text(self, node: RigVMNode, comment_text: str, comment_font_size: int, comment_bubble_visible: bool, comment_color_bubble: bool, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.set_comment_text(node, comment_text, comment_font_size, comment_bubble_visible, comment_color_bubble, setup_undo_redo=True, print_python_command=False) -> bool
        Sets the comment text and properties of a comment node in the graph.
        This causes a CommentTextChanged modified event.
        
        Args:
            node (RigVMNode): 
            comment_text (str): 
            comment_font_size (int32): 
            comment_bubble_visible (bool): 
            comment_color_bubble (bool): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_array_pin_size(self, array_pin_path: str, size: int, default_value: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.set_array_pin_size(array_pin_path, size, default_value="", setup_undo_redo=True, print_python_command=False) -> bool
        Sets the size of the array pin
        This causes a PinArraySizeChanged modified event.
        
        Args:
            array_pin_path (str): 
            size (int32): 
            default_value (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def select_node_by_name(self, node_name: Name, select: bool = True, setup_undo_redo: bool = True) -> bool:
        r"""
        x.select_node_by_name(node_name, select=True, setup_undo_redo=True) -> bool
        Selects a single node in the graph by name.
        This causes a NodeSelected / NodeDeselected modified event.
        
        Args:
            node_name (Name): 
            select (bool): 
            setup_undo_redo (bool): 
        
        Returns:
            bool:
        """
        ...
    def select_node(self, node: RigVMNode, select: bool = True, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.select_node(node, select=True, setup_undo_redo=True, print_python_command=False) -> bool
        Selects a single node in the graph.
        This causes a NodeSelected / NodeDeselected modified event.
        
        Args:
            node (RigVMNode): 
            select (bool): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def resolve_wild_card_pin(self, pin_path: str, cpp_type: str, cpp_type_object_path: Name, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.resolve_wild_card_pin(pin_path, cpp_type, cpp_type_object_path, setup_undo_redo=True, print_python_command=False) -> bool
        Resolves a wildcard pin on any node
        
        Args:
            pin_path (str): 
            cpp_type (str): 
            cpp_type_object_path (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def reset_pin_default_value(self, pin_path: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.reset_pin_default_value(pin_path, setup_undo_redo=True, print_python_command=False) -> bool
        Resets the default value of a pin given its pinpath.
        This causes a PinDefaultValueChanged modified event.
        
        Args:
            pin_path (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def replace_parameter_node_with_variable(self, node_name: Name, variable_name: Name, cpp_type: str, cpp_type_object: Object, setup_undo_redo: bool) -> RigVMVariableNode:
        r"""
        x.replace_parameter_node_with_variable(node_name, variable_name, cpp_type, cpp_type_object, setup_undo_redo) -> RigVMVariableNode
        Refreshes the variable node with the new data
        
        Args:
            node_name (Name): 
            variable_name (Name): 
            cpp_type (str): 
            cpp_type_object (Object): 
            setup_undo_redo (bool): 
        
        Returns:
            RigVMVariableNode:
        """
        ...
    def rename_variable(self, old_name: Name, new_name: Name, setup_undo_redo: bool = True) -> bool:
        r"""
        x.rename_variable(old_name, new_name, setup_undo_redo=True) -> bool
        Renames a variable in the graph.
        This causes a VariableRenamed modified event.
        deprecated: Function 'RenameVariable' is deprecated.
        
        Args:
            old_name (Name): 
            new_name (Name): 
            setup_undo_redo (bool): 
        
        Returns:
            bool:
        """
        ...
    def rename_parameter(self, old_name: Name, new_name: Name, setup_undo_redo: bool = True) -> bool:
        r"""
        x.rename_parameter(old_name, new_name, setup_undo_redo=True) -> bool
        Renames a parameter in the graph.
        This causes a ParameterRenamed modified event.
        deprecated: Function 'RenameParameter' is deprecated.
        
        Args:
            old_name (Name): 
            new_name (Name): 
            setup_undo_redo (bool): 
        
        Returns:
            bool:
        """
        ...
    def rename_node(self, node: RigVMNode, new_name: Name, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.rename_node(node, new_name, setup_undo_redo=True, print_python_command=False) -> bool
        Renames a node in the graph
        This causes a NodeRenamed modified event.
        
        Args:
            node (RigVMNode): 
            new_name (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def rename_local_variable(self, variable_name: Name, new_variable_name: Name, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.rename_local_variable(variable_name, new_variable_name, setup_undo_redo=True, print_python_command=False) -> bool
        Rename a local variable from the graph
        
        Args:
            variable_name (Name): 
            new_variable_name (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def rename_function(self, old_function_name: Name, new_function_name: Name, setup_undo_redo: bool = True) -> bool:
        r"""
        x.rename_function(old_function_name, new_function_name, setup_undo_redo=True) -> bool
        Renames a function in the function library
        
        Args:
            old_function_name (Name): 
            new_function_name (Name): 
            setup_undo_redo (bool): 
        
        Returns:
            bool:
        """
        ...
    def rename_exposed_pin(self, old_pin_name: Name, new_pin_name: Name, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.rename_exposed_pin(old_pin_name, new_pin_name, setup_undo_redo=True, print_python_command=False) -> bool
        Renames an exposed pin in the graph controlled by this
        
        Args:
            old_pin_name (Name): 
            new_pin_name (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_nodes_by_name(self, node_names: Array[Name], setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.remove_nodes_by_name(node_names, setup_undo_redo=True, print_python_command=False) -> bool
        Removes a list of nodes from the graph given the names
        This causes a NodeRemoved modified event.
        
        Args:
            node_names (Array[Name]): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_nodes(self, nodes: Array[RigVMNode], setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.remove_nodes(nodes, setup_undo_redo=True, print_python_command=False) -> bool
        Removes a list of nodes from the graph
        This causes a NodeRemoved modified event.
        
        Args:
            nodes (Array[RigVMNode]): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_node_by_name(self, node_name: Name, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.remove_node_by_name(node_name, setup_undo_redo=True, print_python_command=False) -> bool
        Removes a node from the graph given the node's name.
        This causes a NodeRemoved modified event.
        
        Args:
            node_name (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_node(self, node: RigVMNode, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.remove_node(node, setup_undo_redo=True, print_python_command=False) -> bool
        Removes a node from the graph
        This causes a NodeRemoved modified event.
        
        Args:
            node (RigVMNode): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_local_variable(self, variable_name: Name, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.remove_local_variable(variable_name, setup_undo_redo=True, print_python_command=False) -> bool
        Remove a local variable from the graph
        
        Args:
            variable_name (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_injected_node(self, pin_path: str, as_input: bool, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.remove_injected_node(pin_path, as_input, setup_undo_redo=True, print_python_command=False) -> bool
        Removes an injected node
        This causes a NodeRemoved modified event.
        
        Args:
            pin_path (str): 
            as_input (bool): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_function_from_library(self, function_name: Name, setup_undo_redo: bool = True) -> bool:
        r"""
        x.remove_function_from_library(function_name, setup_undo_redo=True) -> bool
        Removes a function from a function library graph
        
        Args:
            function_name (Name): 
            setup_undo_redo (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_exposed_pin(self, pin_name: Name, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.remove_exposed_pin(pin_name, setup_undo_redo=True, print_python_command=False) -> bool
        Removes an exposed pin from the graph controlled by this
        
        Args:
            pin_name (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_decorator(self, node_name: Name, decorator_name: Name, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.remove_decorator(node_name, decorator_name, setup_undo_redo=True, print_python_command=False) -> bool
        Removes a decorator from a node
        
        Args:
            node_name (Name): 
            decorator_name (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_array_pin(self, array_element_pin_path: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.remove_array_pin(array_element_pin_path, setup_undo_redo=True, print_python_command=False) -> bool
        Removes an array element pin from an array pin.
        This causes a PinArraySizeChanged modified event.
        
        Args:
            array_element_pin_path (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_aggregate_pin(self, pin_path: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.remove_aggregate_pin(pin_path, setup_undo_redo=True, print_python_command=False) -> bool
        Remove Aggregate Pin
        
        Args:
            pin_path (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def refresh_variable_node(self, node_name: Name, variable_name: Name, cpp_type: str, cpp_type_object: Object, setup_undo_redo: bool, setup_orphan_pins: bool = True) -> None:
        r"""
        x.refresh_variable_node(node_name, variable_name, cpp_type, cpp_type_object, setup_undo_redo, setup_orphan_pins=True) -> None
        Refreshes the variable node with the new data
        
        Args:
            node_name (Name): 
            variable_name (Name): 
            cpp_type (str): 
            cpp_type_object (Object): 
            setup_undo_redo (bool): 
            setup_orphan_pins (bool):
        """
        ...
    def redo(self) -> bool:
        r"""
        x.redo() -> bool
        Re-does the last action on the stack.
        Note: This should really only be used for unit tests,
        use the GEditor's main Undo method instead.
        
        Returns:
            bool:
        """
        ...
    def push_graph(self, graph: RigVMGraph, setup_undo_redo: bool = True) -> bool:
        r"""
        x.push_graph(graph, setup_undo_redo=True) -> bool
        Pushes a new graph to the stack
        This causes a GraphChanged modified event.
        deprecated: Function has been deprecated, please rely on GetControllerForGraph instead.
        
        Args:
            graph (RigVMGraph): 
            setup_undo_redo (bool): 
        
        Returns:
            bool:
        """
        ...
    def promote_pin_to_variable(self, pin_path: str, create_variable_node: bool, node_position: Vector2D = [0.000000, 0.000000], setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.promote_pin_to_variable(pin_path, create_variable_node, node_position=[0.000000, 0.000000], setup_undo_redo=True, print_python_command=False) -> bool
        Promotes a pin to a variable
        
        Args:
            pin_path (str): 
            create_variable_node (bool): 
            node_position (Vector2D): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def promote_function_reference_node_to_collapse_node(self, node_name: Name, setup_undo_redo: bool = True, print_python_command: bool = False, remove_function_definition: bool = False) -> Name:
        r"""
        x.promote_function_reference_node_to_collapse_node(node_name, setup_undo_redo=True, print_python_command=False, remove_function_definition=False) -> Name
        Turns a collapse node into a function node
        
        Args:
            node_name (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
            remove_function_definition (bool): 
        
        Returns:
            Name:
        """
        ...
    def promote_collapse_node_to_function_reference_node(self, node_name: Name, setup_undo_redo: bool = True, print_python_command: bool = False, existing_function_definition_path: str = "") -> Name:
        r"""
        x.promote_collapse_node_to_function_reference_node(node_name, setup_undo_redo=True, print_python_command=False, existing_function_definition_path="") -> Name
        Turns a collapse node into a function node
        
        Args:
            node_name (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
            existing_function_definition_path (str): 
        
        Returns:
            Name:
        """
        ...
    def pop_graph(self, setup_undo_redo: bool = True) -> RigVMGraph:
        r"""
        x.pop_graph(setup_undo_redo=True) -> RigVMGraph
        Pops the last graph off the stack
        This causes a GraphChanged modified event.
        deprecated: Function has been deprecated, please rely on GetControllerForGraph instead.
        
        Args:
            setup_undo_redo (bool): 
        
        Returns:
            RigVMGraph:
        """
        ...
    def perform_user_workflow(self, workflow: RigVMUserWorkflow, options: RigVMUserWorkflowOptions, setup_undo_redo: bool = True) -> bool:
        r"""
        x.perform_user_workflow(workflow, options, setup_undo_redo=True) -> bool
        performs all actions representing the workflow
        
        Args:
            workflow (RigVMUserWorkflow): 
            options (RigVMUserWorkflowOptions): 
            setup_undo_redo (bool): 
        
        Returns:
            bool:
        """
        ...
    def open_undo_bracket(self, title: str) -> bool:
        r"""
        x.open_undo_bracket(title) -> bool
        Opens an undo bracket / scoped transaction for
        a series of actions to be performed as one step on the
        Undo stack. This is primarily useful for Python.
        This causes a UndoBracketOpened modified event.
        
        Args:
            title (str): 
        
        Returns:
            bool:
        """
        ...
    def mark_function_as_public(self, function_name: Name, is_public: bool, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.mark_function_as_public(function_name, is_public, setup_undo_redo=True, print_python_command=False) -> bool
        Mark a function as public/private in the function library
        
        Args:
            function_name (Name): 
            is_public (bool): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def make_variable_node_from_binding(self, pin_path: str, node_position: Vector2D = [0.000000, 0.000000], setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.make_variable_node_from_binding(pin_path, node_position=[0.000000, 0.000000], setup_undo_redo=True, print_python_command=False) -> bool
        Turns a binding to a variable node
        
        Args:
            pin_path (str): 
            node_position (Vector2D): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def make_options_for_workflow(self, subject: Object, workflow: RigVMUserWorkflow) -> RigVMUserWorkflowOptions:
        r"""
        x.make_options_for_workflow(subject, workflow) -> RigVMUserWorkflowOptions
        creates the options struct for a given workflow
        
        Args:
            subject (Object): 
            workflow (RigVMUserWorkflow): 
        
        Returns:
            RigVMUserWorkflowOptions:
        """
        ...
    def make_bindings_from_variable_node(self, node_name: Name, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.make_bindings_from_variable_node(node_name, setup_undo_redo=True, print_python_command=False) -> bool
        Turns a variable node into one or more bindings
        
        Args:
            node_name (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def localize_functions(self, function_definitions: Array[RigVMGraphFunctionIdentifier], localize_dependent_private_functions: bool = True, setup_undo_redo: bool = True, print_python_command: bool = False) -> Map[RigVMGraphFunctionIdentifier, RigVMLibraryNode]:
        r"""
        x.localize_functions(function_definitions, localize_dependent_private_functions=True, setup_undo_redo=True, print_python_command=False) -> Map[RigVMGraphFunctionIdentifier, RigVMLibraryNode]
        Copies a series of function declaratioms into this graph's local function library
        
        Args:
            function_definitions (Array[RigVMGraphFunctionIdentifier]): 
            localize_dependent_private_functions (bool): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            Map[RigVMGraphFunctionIdentifier, RigVMLibraryNode]:
        """
        ...
    def localize_function_from_path(self, host_path: str, function_name: Name, localize_dependent_private_functions: bool = True, setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMLibraryNode:
        r"""
        x.localize_function_from_path(host_path, function_name, localize_dependent_private_functions=True, setup_undo_redo=True, print_python_command=False) -> RigVMLibraryNode
        Copies a function declaration into this graph's local function library
        
        Args:
            host_path (str): 
            function_name (Name): 
            localize_dependent_private_functions (bool): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMLibraryNode:
        """
        ...
    def localize_function(self, function_definition: RigVMGraphFunctionIdentifier, localize_dependent_private_functions: bool = True, setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMLibraryNode:
        r"""
        x.localize_function(function_definition, localize_dependent_private_functions=True, setup_undo_redo=True, print_python_command=False) -> RigVMLibraryNode
        Localize Function
        
        Args:
            function_definition (RigVMGraphFunctionIdentifier): 
            localize_dependent_private_functions (bool): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMLibraryNode:
        """
        ...
    def is_transacting(self) -> bool:
        r"""
        x.is_transacting() -> bool
        Returns true if the controller is currently transacting
        
        Returns:
            bool:
        """
        ...
    def is_reporting_enabled(self) -> bool:
        r"""
        x.is_reporting_enabled() -> bool
        Returns true if reporting is enabled
        
        Returns:
            bool:
        """
        ...
    def is_function_public(self, function_name: Name) -> bool:
        r"""
        x.is_function_public(function_name) -> bool
        Returns true if a function is marked as public in the function library
        
        Args:
            function_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def insert_array_pin(self, array_pin_path: str, index: int = -1, default_value: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> str:
        r"""
        x.insert_array_pin(array_pin_path, index=-1, default_value="", setup_undo_redo=True, print_python_command=False) -> str
        Inserts an array element pin into an array pin.
        This causes a PinArraySizeChanged modified event.
        
        Args:
            array_pin_path (str): 
            index (int32): 
            default_value (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            str:
        """
        ...
    def import_nodes_from_text(self, text: str, setup_undo_redo: bool = True, print_python_commands: bool = False) -> Array[Name]:
        r"""
        x.import_nodes_from_text(text, setup_undo_redo=True, print_python_commands=False) -> Array[Name]
        Exports the given nodes as text
        
        Args:
            text (str): 
            setup_undo_redo (bool): 
            print_python_commands (bool): 
        
        Returns:
            Array[Name]:
        """
        ...
    @classmethod
    def get_unit_structs_for_template(cls, notation: Name) -> Array[ScriptStruct]:
        r"""
        X.get_unit_structs_for_template(notation) -> Array[ScriptStruct]
        Returns all supported unit structs for a given template notation
        
        Args:
            notation (Name): 
        
        Returns:
            Array[ScriptStruct]:
        """
        ...
    def get_top_level_graph(self) -> RigVMGraph:
        r"""
        x.get_top_level_graph() -> RigVMGraph
        Returns the top level graph
        
        Returns:
            RigVMGraph:
        """
        ...
    @classmethod
    def get_template_for_unit_struct(cls, function: ScriptStruct, method_name: str = "Execute") -> str:
        r"""
        X.get_template_for_unit_struct(function, method_name="Execute") -> str
        Returns the template for a given function (or an empty string)
        
        Args:
            function (ScriptStruct): 
            method_name (str): 
        
        Returns:
            str:
        """
        ...
    def get_schema(self) -> RigVMSchema:
        r"""
        x.get_schema() -> RigVMSchema
        Returns the schema used by this controller
        
        Returns:
            RigVMSchema:
        """
        ...
    @classmethod
    def get_registered_unit_structs(cls) -> Array[ScriptStruct]:
        r"""
        X.get_registered_unit_structs() -> Array[ScriptStruct]
        Returns all registered unit structs
        
        Returns:
            Array[ScriptStruct]:
        """
        ...
    @classmethod
    def get_registered_templates(cls) -> Array[str]:
        r"""
        X.get_registered_templates() -> Array[str]
        Returns all registered template notations
        
        Returns:
            Array[str]:
        """
        ...
    def get_pin_default_value(self, pin_path: str) -> str:
        r"""
        x.get_pin_default_value(pin_path) -> str
        Returns the default value of a pin given its pinpath.
        
        Args:
            pin_path (str): 
        
        Returns:
            str:
        """
        ...
    def get_graph(self) -> RigVMGraph:
        r"""
        x.get_graph() -> RigVMGraph
        Returns the currently edited Graph of this controller.
        
        Returns:
            RigVMGraph:
        """
        ...
    def get_controller_for_graph(self, graph: RigVMGraph) -> RigVMController:
        r"""
        x.get_controller_for_graph(graph) -> RigVMController
        Returns another controller for a given graph
        
        Args:
            graph (RigVMGraph): 
        
        Returns:
            RigVMController:
        """
        ...
    def generate_python_commands(self) -> Array[str]:
        r"""
        x.generate_python_commands() -> Array[str]
        Generate Python Commands
        
        Returns:
            Array[str]:
        """
        ...
    def export_selected_nodes_to_text(self, include_exterior_links: bool = False) -> str:
        r"""
        x.export_selected_nodes_to_text(include_exterior_links=False) -> str
        Exports the selected nodes as text
        
        Args:
            include_exterior_links (bool): 
        
        Returns:
            str:
        """
        ...
    def export_nodes_to_text(self, node_names: Array[Name], include_exterior_links: bool = False) -> str:
        r"""
        x.export_nodes_to_text(node_names, include_exterior_links=False) -> str
        Exports the given nodes as text
        
        Args:
            node_names (Array[Name]): 
            include_exterior_links (bool): 
        
        Returns:
            str:
        """
        ...
    def expand_library_node(self, node_name: Name, setup_undo_redo: bool = True, print_python_command: bool = False) -> Array[RigVMNode]:
        r"""
        x.expand_library_node(node_name, setup_undo_redo=True, print_python_command=False) -> Array[RigVMNode]
        Turns a library node into its contained nodes
        
        Args:
            node_name (Name): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            Array[RigVMNode]:
        """
        ...
    def enable_reporting(self, enabled: bool = True) -> None:
        r"""
        x.enable_reporting(enabled=True) -> None
        Enables or disables the error reporting of this Controller.
        
        Args:
            enabled (bool):
        """
        ...
    def eject_node_from_pin(self, pin_path: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMNode:
        r"""
        x.eject_node_from_pin(pin_path, setup_undo_redo=True, print_python_command=False) -> RigVMNode
        Ejects the last injected node on a pin
        
        Args:
            pin_path (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMNode:
        """
        ...
    def duplicate_array_pin(self, array_element_pin_path: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> str:
        r"""
        x.duplicate_array_pin(array_element_pin_path, setup_undo_redo=True, print_python_command=False) -> str
        Duplicates an array element pin.
        This causes a PinArraySizeChanged modified event.
        
        Args:
            array_element_pin_path (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            str:
        """
        ...
    def collapse_nodes(self, node_names: Array[Name], collapse_node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False, is_aggregate: bool = False) -> RigVMCollapseNode:
        r"""
        x.collapse_nodes(node_names, collapse_node_name="", setup_undo_redo=True, print_python_command=False, is_aggregate=False) -> RigVMCollapseNode
        Turns a series of nodes into a Collapse node
        
        Args:
            node_names (Array[Name]): 
            collapse_node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
            is_aggregate (bool): 
        
        Returns:
            RigVMCollapseNode:
        """
        ...
    def close_undo_bracket(self) -> bool:
        r"""
        x.close_undo_bracket() -> bool
        Closes an undo bracket / scoped transaction.
        This is primarily useful for Python.
        This causes a UndoBracketClosed modified event.
        
        Returns:
            bool:
        """
        ...
    def clear_node_selection(self, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.clear_node_selection(setup_undo_redo=True, print_python_command=False) -> bool
        Deselects all currently selected nodes in the graph.
        This might cause several NodeDeselected modified event.
        
        Args:
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def clear_array_pin(self, array_pin_path: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.clear_array_pin(array_pin_path, setup_undo_redo=True, print_python_command=False) -> bool
        Removes all (but one) array element pin from an array pin.
        This causes a PinArraySizeChanged modified event.
        
        Args:
            array_pin_path (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def change_exposed_pin_type(self, pin_name: Name, cpp_type: str, cpp_type_object_path: Name, setup_undo_redo: bool, setup_orphan_pins: bool = True, print_python_command: bool = False) -> Optional[bool]:
        r"""
        x.change_exposed_pin_type(pin_name, cpp_type, cpp_type_object_path, setup_undo_redo, setup_orphan_pins=True, print_python_command=False) -> bool or None
        Changes the type of an exposed pin in the graph controlled by this
        
        Args:
            pin_name (Name): 
            cpp_type (str): 
            cpp_type_object_path (Name): 
            setup_undo_redo (bool): 
            setup_orphan_pins (bool): 
            print_python_command (bool): 
        
        Returns:
            bool or None: 
        
            setup_undo_redo (bool):
        """
        ...
    def can_import_nodes_from_text(self, text: str) -> bool:
        r"""
        x.can_import_nodes_from_text(text) -> bool
        Exports the given nodes as text
        
        Args:
            text (str): 
        
        Returns:
            bool:
        """
        ...
    def cancel_undo_bracket(self) -> bool:
        r"""
        x.cancel_undo_bracket() -> bool
        Cancels an undo bracket / scoped transaction.
        This is primarily useful for Python.
        This causes a UndoBracketCanceled modified event.
        
        Returns:
            bool:
        """
        ...
    def break_link(self, output_pin_path: str, input_pin_path: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.break_link(output_pin_path, input_pin_path, setup_undo_redo=True, print_python_command=False) -> bool
        Removes a link from the graph.
        This causes a LinkRemoved modified event.
        
        Args:
            output_pin_path (str): 
            input_pin_path (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def break_all_links(self, pin_path: str, as_input: bool = True, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.break_all_links(pin_path, as_input=True, setup_undo_redo=True, print_python_command=False) -> bool
        Removes all links on a given pin from the graph.
        This might cause multiple LinkRemoved modified event.
        
        Args:
            pin_path (str): 
            as_input (bool): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def bind_pin_to_variable(self, pin_path: str, new_bound_variable_path: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> bool:
        r"""
        x.bind_pin_to_variable(pin_path, new_bound_variable_path, setup_undo_redo=True, print_python_command=False) -> bool
        Binds a pin to a variable (or removes the binding given NAME_None)
        This causes a PinBoundVariableChanged modified event.
        
        Args:
            pin_path (str): 
            new_bound_variable_path (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            bool:
        """
        ...
    def add_variable_node_from_object_path(self, variable_name: Name, cpp_type: str, cpp_type_object_path: str, is_getter: bool, default_value: str, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMVariableNode:
        r"""
        x.add_variable_node_from_object_path(variable_name, cpp_type, cpp_type_object_path, is_getter, default_value, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMVariableNode
        Adds a Variable Node to the edited Graph given a struct object path name.
        Variables represent local work state for the function and
        can be read from (bIsGetter == true) or written to (bIsGetter == false).
        This causes a NodeAdded modified event.
        
        Args:
            variable_name (Name): 
            cpp_type (str): 
            cpp_type_object_path (str): 
            is_getter (bool): 
            default_value (str): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMVariableNode:
        """
        ...
    def add_variable_node(self, variable_name: Name, cpp_type: str, cpp_type_object: Object, is_getter: bool, default_value: str, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMVariableNode:
        r"""
        x.add_variable_node(variable_name, cpp_type, cpp_type_object, is_getter, default_value, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMVariableNode
        Adds a Variable Node to the edited Graph.
        Variables represent local work state for the function and
        can be read from and written to.
        This causes a NodeAdded modified event.
        
        Args:
            variable_name (Name): 
            cpp_type (str): 
            cpp_type_object (Object): 
            is_getter (bool): 
            default_value (str): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMVariableNode:
        """
        ...
    def add_unit_node_with_defaults(self, script_struct: ScriptStruct, defaults: str, method_name: Name = "Execute", position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMUnitNode:
        r"""
        x.add_unit_node_with_defaults(script_struct, defaults, method_name="Execute", position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMUnitNode
        Adds a Function / Struct Node to the edited Graph.
        UnitNode represent a RIGVM_METHOD declaration on a USTRUCT.
        This causes a NodeAdded modified event.
        
        Args:
            script_struct (ScriptStruct): 
            defaults (str): 
            method_name (Name): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMUnitNode:
        """
        ...
    def add_unit_node_from_struct_path(self, script_struct_path: str, method_name: Name = "Execute", position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMUnitNode:
        r"""
        x.add_unit_node_from_struct_path(script_struct_path, method_name="Execute", position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMUnitNode
        Adds a Function / Struct Node to the edited Graph given its struct object path name.
        UnitNode represent a RIGVM_METHOD declaration on a USTRUCT.
        This causes a NodeAdded modified event.
        
        Args:
            script_struct_path (str): 
            method_name (Name): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMUnitNode:
        """
        ...
    def add_unit_node(self, script_struct: ScriptStruct, method_name: Name = "Execute", position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMUnitNode:
        r"""
        x.add_unit_node(script_struct, method_name="Execute", position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMUnitNode
        Adds a Function / Struct Node to the edited Graph.
        UnitNode represent a RIGVM_METHOD declaration on a USTRUCT.
        This causes a NodeAdded modified event.
        
        Args:
            script_struct (ScriptStruct): 
            method_name (Name): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMUnitNode:
        """
        ...
    def add_template_node(self, notation: Name, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMTemplateNode:
        r"""
        x.add_template_node(notation, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMTemplateNode
        Adds a template node to the graph.
        
        Args:
            notation (Name): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMTemplateNode:
        """
        ...
    def add_select_node_from_struct(self, script_struct: ScriptStruct, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True) -> RigVMNode:
        r"""
        x.add_select_node_from_struct(script_struct, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True) -> RigVMNode
        Add Select Node from Struct
        
        Args:
            script_struct (ScriptStruct): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
        
        Returns:
            RigVMNode:
        """
        ...
    def add_select_node(self, cpp_type: str, cpp_type_object_path: Name, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMNode:
        r"""
        x.add_select_node(cpp_type, cpp_type_object_path, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMNode
        Adds a select node to the graph.
        Select nodes can be used to pick between multiple values based on an index.
        
        Args:
            cpp_type (str): 
            cpp_type_object_path (Name): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMNode:
        """
        ...
    def add_reroute_node_on_pin(self, pin_path: str, as_input: bool, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMRerouteNode:
        r"""
        x.add_reroute_node_on_pin(pin_path, as_input, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMRerouteNode
        Adds a Reroute Node on an existing Pin to the editor Graph.
        Reroute Nodes can be used to visually improve the data flow,
        they don't require any additional memory though and are purely
        cosmetic. This causes a NodeAdded modified event.
        
        Args:
            pin_path (str): 
            as_input (bool): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMRerouteNode:
        """
        ...
    def add_reroute_node_on_link_path(self, link_pin_path_representation: str, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMRerouteNode:
        r"""
        x.add_reroute_node_on_link_path(link_pin_path_representation, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMRerouteNode
        Adds a Reroute Node on an existing Link to the edited Graph given the Link's string representation.
        Reroute Nodes can be used to visually improve the data flow,
        they don't require any additional memory though and are purely
        cosmetic. This causes a NodeAdded modified event.
        
        Args:
            link_pin_path_representation (str): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMRerouteNode:
        """
        ...
    def add_reroute_node_on_link(self, link: RigVMLink, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMRerouteNode:
        r"""
        x.add_reroute_node_on_link(link, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMRerouteNode
        Adds a Reroute Node on an existing Link to the edited Graph.
        Reroute Nodes can be used to visually improve the data flow,
        they don't require any additional memory though and are purely
        cosmetic. This causes a NodeAdded modified event.
        
        Args:
            link (RigVMLink): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMRerouteNode:
        """
        ...
    def add_parameter_node_from_object_path(self, parameter_name: Name, cpp_type: str, cpp_type_object_path: str, is_input: bool, default_value: str, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMParameterNode:
        r"""
        x.add_parameter_node_from_object_path(parameter_name, cpp_type, cpp_type_object_path, is_input, default_value, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMParameterNode
        Adds a Parameter Node to the edited Graph given a struct object path name.
        Parameters represent input or output arguments to the Graph / Function.
        Input Parameters are constant values / literals.
        This causes a NodeAdded modified event.
        deprecated: Function 'AddParameterNodeFromObjectPath' is deprecated.
        
        Args:
            parameter_name (Name): 
            cpp_type (str): 
            cpp_type_object_path (str): 
            is_input (bool): 
            default_value (str): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMParameterNode:
        """
        ...
    def add_parameter_node(self, parameter_name: Name, cpp_type: str, cpp_type_object: Object, is_input: bool, default_value: str, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMParameterNode:
        r"""
        x.add_parameter_node(parameter_name, cpp_type, cpp_type_object, is_input, default_value, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMParameterNode
        Adds a Parameter Node to the edited Graph.
        Parameters represent input or output arguments to the Graph / Function.
        Input Parameters are constant values / literals.
        This causes a NodeAdded modified event.
        deprecated: Function 'AddParameterNode' is deprecated.
        
        Args:
            parameter_name (Name): 
            cpp_type (str): 
            cpp_type_object (Object): 
            is_input (bool): 
            default_value (str): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMParameterNode:
        """
        ...
    def add_local_variable_from_object_path(self, variable_name: Name, cpp_type: str, cpp_type_object_path: str, default_value: str, setup_undo_redo: bool = True) -> RigVMGraphVariableDescription:
        r"""
        x.add_local_variable_from_object_path(variable_name, cpp_type, cpp_type_object_path, default_value, setup_undo_redo=True) -> RigVMGraphVariableDescription
        Add a local variable to the graph given a struct object path name.
        
        Args:
            variable_name (Name): 
            cpp_type (str): 
            cpp_type_object_path (str): 
            default_value (str): 
            setup_undo_redo (bool): 
        
        Returns:
            RigVMGraphVariableDescription:
        """
        ...
    def add_local_variable(self, variable_name: Name, cpp_type: str, cpp_type_object: Object, default_value: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMGraphVariableDescription:
        r"""
        x.add_local_variable(variable_name, cpp_type, cpp_type_object, default_value, setup_undo_redo=True, print_python_command=False) -> RigVMGraphVariableDescription
        Add a local variable to the graph
        
        Args:
            variable_name (Name): 
            cpp_type (str): 
            cpp_type_object (Object): 
            default_value (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMGraphVariableDescription:
        """
        ...
    def add_link(self, output_pin_path: str, input_pin_path: str, setup_undo_redo: bool = True, print_python_command: bool = False, user_direction: RigVMPinDirection = RigVMPinDirection.OUTPUT, create_cast_node: bool = False) -> bool:
        r"""
        x.add_link(output_pin_path, input_pin_path, setup_undo_redo=True, print_python_command=False, user_direction=RigVMPinDirection.OUTPUT, create_cast_node=False) -> bool
        Adds a link to the graph.
        This causes a LinkAdded modified event.
        
        Args:
            output_pin_path (str): 
            input_pin_path (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
            user_direction (RigVMPinDirection): 
            create_cast_node (bool): 
        
        Returns:
            bool:
        """
        ...
    def add_invoke_entry_node(self, entry_name: Name, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMInvokeEntryNode:
        r"""
        x.add_invoke_entry_node(entry_name, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMInvokeEntryNode
        Adds an entry invocation node
        This causes a NodeAdded modified event.
        
        Args:
            entry_name (Name): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMInvokeEntryNode:
        """
        ...
    def add_injected_node_from_struct_path(self, pin_path: str, as_input: bool, script_struct_path: str, method_name: Name, input_pin_name: Name, output_pin_name: Name, node_name: str = "", setup_undo_redo: bool = True) -> RigVMInjectionInfo:
        r"""
        x.add_injected_node_from_struct_path(pin_path, as_input, script_struct_path, method_name, input_pin_name, output_pin_name, node_name="", setup_undo_redo=True) -> RigVMInjectionInfo
        Adds a Function / Struct Node to the edited Graph as an injected node
        UnitNode represent a RIGVM_METHOD declaration on a USTRUCT.
        This causes a NodeAdded modified event.
        
        Args:
            pin_path (str): 
            as_input (bool): 
            script_struct_path (str): 
            method_name (Name): 
            input_pin_name (Name): 
            output_pin_name (Name): 
            node_name (str): 
            setup_undo_redo (bool): 
        
        Returns:
            RigVMInjectionInfo:
        """
        ...
    def add_injected_node(self, pin_path: str, as_input: bool, script_struct: ScriptStruct, method_name: Name, input_pin_name: Name, output_pin_name: Name, node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMInjectionInfo:
        r"""
        x.add_injected_node(pin_path, as_input, script_struct, method_name, input_pin_name, output_pin_name, node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMInjectionInfo
        Adds a Function / Struct Node to the edited Graph as an injected node
        UnitNode represent a RIGVM_METHOD declaration on a USTRUCT.
        This causes a NodeAdded modified event.
        
        Args:
            pin_path (str): 
            as_input (bool): 
            script_struct (ScriptStruct): 
            method_name (Name): 
            input_pin_name (Name): 
            output_pin_name (Name): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMInjectionInfo:
        """
        ...
    def add_if_node_from_struct(self, script_struct: ScriptStruct, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True) -> RigVMNode:
        r"""
        x.add_if_node_from_struct(script_struct, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True) -> RigVMNode
        Add if Node from Struct
        
        Args:
            script_struct (ScriptStruct): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
        
        Returns:
            RigVMNode:
        """
        ...
    def add_if_node(self, cpp_type: str, cpp_type_object_path: Name, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMNode:
        r"""
        x.add_if_node(cpp_type, cpp_type_object_path, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMNode
        Adds an if node to the graph.
        If nodes can be used to pick between two values based on a condition.
        
        Args:
            cpp_type (str): 
            cpp_type_object_path (Name): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMNode:
        """
        ...
    def add_function_to_library(self, function_name: Name, mutable: bool, node_position: Vector2D = [0.000000, 0.000000], setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMLibraryNode:
        r"""
        x.add_function_to_library(function_name, mutable, node_position=[0.000000, 0.000000], setup_undo_redo=True, print_python_command=False) -> RigVMLibraryNode
        Adds a function definition to a function library graph
        
        Args:
            function_name (Name): 
            mutable (bool): 
            node_position (Vector2D): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMLibraryNode:
        """
        ...
    def add_function_reference_node_from_description(self, function_definition: RigVMGraphFunctionHeader, node_position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMFunctionReferenceNode:
        r"""
        x.add_function_reference_node_from_description(function_definition, node_position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMFunctionReferenceNode
        Adds a function reference / invocation to the graph
        
        Args:
            function_definition (RigVMGraphFunctionHeader): 
            node_position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMFunctionReferenceNode:
        """
        ...
    def add_function_reference_node(self, function_definition: RigVMLibraryNode, node_position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMFunctionReferenceNode:
        r"""
        x.add_function_reference_node(function_definition, node_position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMFunctionReferenceNode
        Add Function Reference Node
        
        Args:
            function_definition (RigVMLibraryNode): 
            node_position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMFunctionReferenceNode:
        """
        ...
    def add_free_reroute_node(self, cpp_type: str, cpp_type_object_path: Name, is_constant: bool, custom_widget_name: Name, default_value: str, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True) -> RigVMRerouteNode:
        r"""
        x.add_free_reroute_node(cpp_type, cpp_type_object_path, is_constant, custom_widget_name, default_value, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True) -> RigVMRerouteNode
        Adds a free Reroute Node
        
        Args:
            cpp_type (str): 
            cpp_type_object_path (Name): 
            is_constant (bool): 
            custom_widget_name (Name): 
            default_value (str): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
        
        Returns:
            RigVMRerouteNode:
        """
        ...
    def add_external_function_reference_node(self, host_path: str, function_name: Name, node_position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMFunctionReferenceNode:
        r"""
        x.add_external_function_reference_node(host_path, function_name, node_position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMFunctionReferenceNode
        Add External Function Reference Node
        
        Args:
            host_path (str): 
            function_name (Name): 
            node_position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMFunctionReferenceNode:
        """
        ...
    def add_exposed_pin(self, pin_name: Name, direction: RigVMPinDirection, cpp_type: str, cpp_type_object_path: Name, default_value: str, setup_undo_redo: bool = True, print_python_command: bool = False) -> Name:
        r"""
        x.add_exposed_pin(pin_name, direction, cpp_type, cpp_type_object_path, default_value, setup_undo_redo=True, print_python_command=False) -> Name
        Adds an exposed pin to the graph controlled by this
        
        Args:
            pin_name (Name): 
            direction (RigVMPinDirection): 
            cpp_type (str): 
            cpp_type_object_path (Name): 
            default_value (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            Name:
        """
        ...
    def add_enum_node(self, cpp_type_object_path: Name, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMEnumNode:
        r"""
        x.add_enum_node(cpp_type_object_path, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMEnumNode
        Adds an enum node to the graph
        Enum nodes can be used to represent constant enum values within the graph
        
        Args:
            cpp_type_object_path (Name): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMEnumNode:
        """
        ...
    def add_decorator(self, node_name: Name, decorator_type_object_path: Name, decorator_name: Name = "None", default_value: str = "", pin_index: int = -1, setup_undo_redo: bool = True, print_python_command: bool = False) -> Name:
        r"""
        x.add_decorator(node_name, decorator_type_object_path, decorator_name="None", default_value="", pin_index=-1, setup_undo_redo=True, print_python_command=False) -> Name
        Adds a decorator to a node
        
        Args:
            node_name (Name): 
            decorator_type_object_path (Name): 
            decorator_name (Name): 
            default_value (str): 
            pin_index (int32): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            Name:
        """
        ...
    def add_comment_node(self, comment_text: str, position: Vector2D = [0.000000, 0.000000], size: Vector2D = [400.000000, 300.000000], color: LinearColor = [0.000000, 0.000000, 0.000000, 1.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMCommentNode:
        r"""
        x.add_comment_node(comment_text, position=[0.000000, 0.000000], size=[400.000000, 300.000000], color=[0.000000, 0.000000, 0.000000, 1.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMCommentNode
        Adds a Comment Node to the edited Graph.
        Comments can be used to annotate the Graph.
        This causes a NodeAdded modified event.
        
        Args:
            comment_text (str): 
            position (Vector2D): 
            size (Vector2D): 
            color (LinearColor): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMCommentNode:
        """
        ...
    def add_branch_node(self, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> RigVMNode:
        r"""
        x.add_branch_node(position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False) -> RigVMNode
        Adds a branch node to the graph.
        Branch nodes can be used to split the execution of into multiple branches,
        allowing to drive behavior by logic.
        
        Args:
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            RigVMNode:
        """
        ...
    def add_array_pin(self, array_pin_path: str, default_value: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> str:
        r"""
        x.add_array_pin(array_pin_path, default_value="", setup_undo_redo=True, print_python_command=False) -> str
        Adds an array element pin to the end of an array pin.
        This causes a PinArraySizeChanged modified event.
        
        Args:
            array_pin_path (str): 
            default_value (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            str:
        """
        ...
    def add_array_node_from_object_path(self, op_code: RigVMOpCode, cpp_type: str, cpp_type_object_path: str, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False, is_patching: bool = False) -> RigVMNode:
        r"""
        x.add_array_node_from_object_path(op_code, cpp_type, cpp_type_object_path, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False, is_patching=False) -> RigVMNode
        Adds a Array Node to the edited Graph given a struct object path name.
        This causes a NodeAdded modified event.
        
        Args:
            op_code (RigVMOpCode): 
            cpp_type (str): 
            cpp_type_object_path (str): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
            is_patching (bool): 
        
        Returns:
            RigVMNode:
        """
        ...
    def add_array_node(self, op_code: RigVMOpCode, cpp_type: str, cpp_type_object: Object, position: Vector2D = [0.000000, 0.000000], node_name: str = "", setup_undo_redo: bool = True, print_python_command: bool = False, is_patching: bool = False) -> RigVMNode:
        r"""
        x.add_array_node(op_code, cpp_type, cpp_type_object, position=[0.000000, 0.000000], node_name="", setup_undo_redo=True, print_python_command=False, is_patching=False) -> RigVMNode
        Adds a Array Node to the edited Graph.
        This causes a NodeAdded modified event.
        
        Args:
            op_code (RigVMOpCode): 
            cpp_type (str): 
            cpp_type_object (Object): 
            position (Vector2D): 
            node_name (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
            is_patching (bool): 
        
        Returns:
            RigVMNode:
        """
        ...
    def add_aggregate_pin(self, node_name: str, pin_name: str, default_value: str = "", setup_undo_redo: bool = True, print_python_command: bool = False) -> str:
        r"""
        x.add_aggregate_pin(node_name, pin_name, default_value="", setup_undo_redo=True, print_python_command=False) -> str
        Add Aggregate Pin
        
        Args:
            node_name (str): 
            pin_name (str): 
            default_value (str): 
            setup_undo_redo (bool): 
            print_python_command (bool): 
        
        Returns:
            str:
        """
        ...

class RigVMGraph(Object):
    r"""
    The Graph represents a Function definition
    using Nodes as statements.
    Graphs can be compiled into a URigVM using the
    FRigVMCompiler.
    Graphs provide access to its Nodes, Pins and
    Links.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMGraph.h
    
    """
    def set_default_function_library(self, function_library: RigVMFunctionLibrary) -> None:
        r"""
        x.set_default_function_library(function_library) -> None
        Set Default Function Library
        
        Args:
            function_library (RigVMFunctionLibrary):
        """
        ...
    def is_top_level_graph(self) -> bool:
        r"""
        x.is_top_level_graph() -> bool
        Returns true if this graph is the top level graph
        
        Returns:
            bool:
        """
        ...
    def is_root_graph(self) -> bool:
        r"""
        x.is_root_graph() -> bool
        Returns true if this graph is a root / top level graph
        
        Returns:
            bool:
        """
        ...
    def is_node_selected(self, node_name: Name) -> bool:
        r"""
        x.is_node_selected(node_name) -> bool
        Returns true if a Node with a given name is selected.
        
        Args:
            node_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def get_variable_descriptions(self) -> Array[RigVMGraphVariableDescription]:
        r"""
        x.get_variable_descriptions() -> Array[RigVMGraphVariableDescription]
        Returns a list of unique Variable descriptions within this Graph.
        Multiple Variable Nodes can share the same description.
        
        Returns:
            Array[RigVMGraphVariableDescription]:
        """
        ...
    def get_select_nodes(self) -> Array[Name]:
        r"""
        x.get_select_nodes() -> Array[Name]
        Returns the names of all currently selected Nodes.
        
        Returns:
            Array[Name]:
        """
        ...
    def get_root_graph(self) -> RigVMGraph:
        r"""
        x.get_root_graph() -> RigVMGraph
        Returns the root / top level parent graph of this graph (or this if it is the root graph)
        
        Returns:
            RigVMGraph:
        """
        ...
    def get_return_node(self) -> RigVMFunctionReturnNode:
        r"""
        x.get_return_node() -> RigVMFunctionReturnNode
        Returns the return node of this graph
        
        Returns:
            RigVMFunctionReturnNode:
        """
        ...
    def get_parent_graph(self) -> RigVMGraph:
        r"""
        x.get_parent_graph() -> RigVMGraph
        Returns the parent graph of this graph
        
        Returns:
            RigVMGraph:
        """
        ...
    def get_output_arguments(self) -> Array[RigVMGraphVariableDescription]:
        r"""
        x.get_output_arguments() -> Array[RigVMGraphVariableDescription]
        Returns the output arguments of this graph
        
        Returns:
            Array[RigVMGraphVariableDescription]:
        """
        ...
    def get_nodes(self) -> Array[RigVMNode]:
        r"""
        x.get_nodes() -> Array[RigVMNode]
        Returns all of the Nodes within this Graph.
        
        Returns:
            Array[RigVMNode]:
        """
        ...
    def get_node_path(self) -> str:
        r"""
        x.get_node_path() -> str
        Returns the path of this graph as defined by its invoking nodes
        
        Returns:
            str:
        """
        ...
    def get_local_variables(self, include_input_arguments: bool = False) -> Array[RigVMGraphVariableDescription]:
        r"""
        x.get_local_variables(include_input_arguments=False) -> Array[RigVMGraphVariableDescription]
        Returns the local variables of this function
        
        Args:
            include_input_arguments (bool): 
        
        Returns:
            Array[RigVMGraphVariableDescription]:
        """
        ...
    def get_links(self) -> Array[RigVMLink]:
        r"""
        x.get_links() -> Array[RigVMLink]
        Returns all of the Links within this Graph.
        
        Returns:
            Array[RigVMLink]:
        """
        ...
    def get_input_arguments(self) -> Array[RigVMGraphVariableDescription]:
        r"""
        x.get_input_arguments() -> Array[RigVMGraphVariableDescription]
        Returns the input arguments of this graph
        
        Returns:
            Array[RigVMGraphVariableDescription]:
        """
        ...
    def get_graph_name(self) -> str:
        r"""
        x.get_graph_name() -> str
        Returns the name of this graph (as defined by the node path)
        
        Returns:
            str:
        """
        ...
    def get_graph_depth(self) -> int:
        r"""
        x.get_graph_depth() -> int32
        Returns the root / top level parent graph of this graph (or this if it is the root graph)
        
        Returns:
            int32:
        """
        ...
    def get_event_names(self) -> Array[Name]:
        r"""
        x.get_event_names() -> Array[Name]
        Returns array of event names
        
        Returns:
            Array[Name]:
        """
        ...
    def get_entry_node(self) -> RigVMFunctionEntryNode:
        r"""
        x.get_entry_node() -> RigVMFunctionEntryNode
        Returns the entry node of this graph
        
        Returns:
            RigVMFunctionEntryNode:
        """
        ...
    def get_default_function_library(self) -> RigVMFunctionLibrary:
        r"""
        x.get_default_function_library() -> RigVMFunctionLibrary
        Returns the locally available function library
        
        Returns:
            RigVMFunctionLibrary:
        """
        ...
    def get_contained_graphs(self, recursive: bool = False) -> Array[RigVMGraph]:
        r"""
        x.get_contained_graphs(recursive=False) -> Array[RigVMGraph]
        Returns all of the contained graphs
        
        Args:
            recursive (bool): 
        
        Returns:
            Array[RigVMGraph]:
        """
        ...
    def find_pin(self, pin_path: str) -> RigVMPin:
        r"""
        x.find_pin(pin_path) -> RigVMPin
        Returns a Pin given its path, for example "Node.Color.R".
        
        Args:
            pin_path (str): 
        
        Returns:
            RigVMPin:
        """
        ...
    def find_node_by_name(self, node_name: Name) -> RigVMNode:
        r"""
        x.find_node_by_name(node_name) -> RigVMNode
        Returns a Node given its name (or nullptr).
        
        Args:
            node_name (Name): 
        
        Returns:
            RigVMNode:
        """
        ...
    def find_node(self, node_path: str) -> RigVMNode:
        r"""
        x.find_node(node_path) -> RigVMNode
        Returns a Node given its path (or nullptr).
        (for now this is the same as finding a node by its name.)
        
        Args:
            node_path (str): 
        
        Returns:
            RigVMNode:
        """
        ...
    def find_link(self, link_pin_path_representation: str) -> RigVMLink:
        r"""
        x.find_link(link_pin_path_representation) -> RigVMLink
        Returns a link given its string representation,
        for example "NodeA.Color.R -> NodeB.Translation.X"
        
        Args:
            link_pin_path_representation (str): 
        
        Returns:
            RigVMLink:
        """
        ...
    def contains_link(self, pin_path_representation: str) -> bool:
        r"""
        x.contains_link(pin_path_representation) -> bool
        Returns true if the graph contains a link given its string representation
        
        Args:
            pin_path_representation (str): 
        
        Returns:
            bool:
        """
        ...

class RigVMFunctionLibrary(RigVMGraph):
    r"""
    The Function Library is a graph used only to store
    the sub graphs used for functions.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMFunctionLibrary.h
    
    """
    def get_references_for_function(self, function_name: Name) -> Array[RigVMFunctionReferenceNode]:
        r"""
        x.get_references_for_function(function_name) -> Array[RigVMFunctionReferenceNode]
        Returns all references for a given function name
        
        Args:
            function_name (Name): 
        
        Returns:
            Array[RigVMFunctionReferenceNode]:
        """
        ...
    def get_reference_paths_for_function(self, function_name: Name) -> Array[str]:
        r"""
        x.get_reference_paths_for_function(function_name) -> Array[str]
        Returns all references for a given function name
        
        Args:
            function_name (Name): 
        
        Returns:
            Array[str]:
        """
        ...
    def get_functions(self) -> Array[RigVMLibraryNode]:
        r"""
        x.get_functions() -> Array[RigVMLibraryNode]
        Returns all of the stored functions
        
        Returns:
            Array[RigVMLibraryNode]:
        """
        ...
    def find_function_for_node(self, node: RigVMNode) -> RigVMLibraryNode:
        r"""
        x.find_function_for_node(node) -> RigVMLibraryNode
        Finds a function by a node within a function (or a sub graph of that)
        
        Args:
            node (RigVMNode): 
        
        Returns:
            RigVMLibraryNode:
        """
        ...
    def find_function(self, function_name: Name) -> RigVMLibraryNode:
        r"""
        x.find_function(function_name) -> RigVMLibraryNode
        Finds a function by name
        
        Args:
            function_name (Name): 
        
        Returns:
            RigVMLibraryNode:
        """
        ...

class RigVMLink(Object):
    r"""
    The Link represents a connection between two Pins
    within a Graph. The Link can be accessed on the
    Graph itself - or through the URigVMPin::GetLinks()
    method.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMLink.h
    
    """
    def get_target_pin(self) -> RigVMPin:
        r"""
        x.get_target_pin() -> RigVMPin
        Returns the target Pin of this Link (or nullptr)
        
        Returns:
            RigVMPin:
        """
        ...
    def get_target_node(self) -> RigVMNode:
        r"""
        x.get_target_node() -> RigVMNode
        Returns the target Node of this Link (or nullptr)
        
        Returns:
            RigVMNode:
        """
        ...
    def get_source_pin(self) -> RigVMPin:
        r"""
        x.get_source_pin() -> RigVMPin
        Returns the source Pin of this Link (or nullptr)
        
        Returns:
            RigVMPin:
        """
        ...
    def get_source_node(self) -> RigVMNode:
        r"""
        x.get_source_node() -> RigVMNode
        Returns the source Node of this Link (or nullptr)
        
        Returns:
            RigVMNode:
        """
        ...
    def get_pin_path_representation(self) -> str:
        r"""
        x.get_pin_path_representation() -> str
        Returns a string representation of the Link,
        for example: "NodeA.Color.R -> NodeB.Translation.X"
        note: can be split again using SplitPinPathRepresentation
        
        Returns:
            str:
        """
        ...
    def get_opposite_pin(self, pin: RigVMPin) -> RigVMPin:
        r"""
        x.get_opposite_pin(pin) -> RigVMPin
        Returns the opposite Pin of this Link given one of its edges (or nullptr)
        
        Args:
            pin (RigVMPin): 
        
        Returns:
            RigVMPin:
        """
        ...
    def get_link_index(self) -> int:
        r"""
        x.get_link_index() -> int32
        Returns the current index of this Link within its owning Graph.
        
        Returns:
            int32:
        """
        ...
    def get_graph_depth(self) -> int:
        r"""
        x.get_graph_depth() -> int32
        Returns the graph nesting depth of this link
        
        Returns:
            int32:
        """
        ...
    def get_graph(self) -> RigVMGraph:
        r"""
        x.get_graph() -> RigVMGraph
        Returns the Link's owning Graph/
        
        Returns:
            RigVMGraph:
        """
        ...

class RigVMInjectionInfo(Object):
    r"""
    The Injected Info is used for injecting a node on a pin.
    Injected nodes are not visible to the user, but they are normal
    nodes on the graph.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMPin.h
    
    """
    def get_pin(self) -> RigVMPin:
        r"""
        x.get_pin() -> RigVMPin
        Returns the pin of this injected node.
        
        Returns:
            RigVMPin:
        """
        ...
    def get_graph(self) -> RigVMGraph:
        r"""
        x.get_graph() -> RigVMGraph
        Returns the graph of this injected node.
        
        Returns:
            RigVMGraph:
        """
        ...

class RigVMPin(Object):
    r"""
    The Pin represents a single connector / pin on a node in the RigVM model.
    Pins can be connected based on rules. Pins also provide access to a 'PinPath',
    which essentially represents . separated list of names to reach the pin within
    the owning graph. PinPaths are unique.
    In comparison to the EdGraph Pin the URigVMPin supports the concept of 'SubPins',
    so child / parent relationships between pins. A FVector Pin for example might
    have its X, Y and Z components as SubPins. Array Pins will have its elements as
    SubPins, and so on.
    A URigVMPin is owned solely by a URigVMNode.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMPin.h
    
    """
    def should_only_show_sub_pins(self) -> bool:
        r"""
        x.should_only_show_sub_pins() -> bool
        Returns true if this pin is an array that should be displayed as elements only
        
        Returns:
            bool:
        """
        ...
    def should_hide_sub_pins(self) -> bool:
        r"""
        x.should_hide_sub_pins() -> bool
        Returns true if this pin's subpins should be hidden in the UI
        
        Returns:
            bool:
        """
        ...
    def requires_watch(self, check_exposed_pin_chain: bool = False) -> bool:
        r"""
        x.requires_watch(check_exposed_pin_chain=False) -> bool
        Returns true if the pin should be watched
        
        Args:
            check_exposed_pin_chain (bool): 
        
        Returns:
            bool:
        """
        ...
    def is_wild_card(self) -> bool:
        r"""
        x.is_wild_card() -> bool
        Returns true if the C++ data type is unknown
        
        Returns:
            bool:
        """
        ...
    def is_u_object(self) -> bool:
        r"""
        x.is_u_object() -> bool
        Returns true if the data type of the Pin is a uobject
        
        Returns:
            bool:
        """
        ...
    def is_struct_member(self) -> bool:
        r"""
        x.is_struct_member() -> bool
        Returns true if the Pin is a SubPin within a struct
        
        Returns:
            bool:
        """
        ...
    def is_struct(self) -> bool:
        r"""
        x.is_struct() -> bool
        Returns true if the data type of the Pin is a struct
        
        Returns:
            bool:
        """
        ...
    def is_string_type(self) -> bool:
        r"""
        x.is_string_type() -> bool
        Returns true if the C++ data type is FString or FName
        
        Returns:
            bool:
        """
        ...
    def is_root_pin(self) -> bool:
        r"""
        x.is_root_pin() -> bool
        Returns true if this pin is a root pin
        
        Returns:
            bool:
        """
        ...
    def is_reference_counted_container(self) -> bool:
        r"""
        x.is_reference_counted_container() -> bool
        Returns true if this data type is referenced counted
        
        Returns:
            bool:
        """
        ...
    def is_linked_to(self, pin: RigVMPin) -> bool:
        r"""
        x.is_linked_to(pin) -> bool
        Returns true if this Pin is linked to another Pin
        
        Args:
            pin (RigVMPin): 
        
        Returns:
            bool:
        """
        ...
    def is_lazy(self) -> bool:
        r"""
        x.is_lazy() -> bool
        Returns true if this pin's value may be executed lazily
        
        Returns:
            bool:
        """
        ...
    def is_interface(self) -> bool:
        r"""
        x.is_interface() -> bool
        Returns true if the data type of the Pin is a interface
        
        Returns:
            bool:
        """
        ...
    def is_fixed_size_array(self) -> bool:
        r"""
        x.is_fixed_size_array() -> bool
        Returns true if this pin is an array that should be displayed as elements only
        
        Returns:
            bool:
        """
        ...
    def is_expanded(self) -> bool:
        r"""
        x.is_expanded() -> bool
        Returns true if the pin is currently expanded
        
        Returns:
            bool:
        """
        ...
    def is_execute_context(self) -> bool:
        r"""
        x.is_execute_context() -> bool
        Returns true if the C++ data type is an execute context
        
        Returns:
            bool:
        """
        ...
    def is_enum(self) -> bool:
        r"""
        x.is_enum() -> bool
        Returns true if the data type of the Pin is a enum
        
        Returns:
            bool:
        """
        ...
    def is_dynamic_array(self) -> bool:
        r"""
        x.is_dynamic_array() -> bool
        Returns true if this pin represents a dynamic array
        
        Returns:
            bool:
        """
        ...
    def is_defined_as_constant(self) -> bool:
        r"""
        x.is_defined_as_constant() -> bool
        Returns true if the pin is defined as a constant value / literal
        
        Returns:
            bool:
        """
        ...
    def is_decorator_pin(self) -> bool:
        r"""
        x.is_decorator_pin() -> bool
        Returns true if this pin represents a decorator
        
        Returns:
            bool:
        """
        ...
    def is_array_element(self) -> bool:
        r"""
        x.is_array_element() -> bool
        Returns true if the Pin is a SubPin within an array
        
        Returns:
            bool:
        """
        ...
    def is_array(self) -> bool:
        r"""
        x.is_array() -> bool
        Returns true if the data type of the Pin is an array
        
        Returns:
            bool:
        """
        ...
    def get_tool_tip_text(self) -> Text:
        r"""
        x.get_tool_tip_text() -> Text
        Returns the tooltip of this pin
        
        Returns:
            Text:
        """
        ...
    def get_target_links(self, recursive: bool = False) -> Array[RigVMLink]:
        r"""
        x.get_target_links(recursive=False) -> Array[RigVMLink]
        Returns all of the target links,
        using this Pin as the source.
        
        Args:
            recursive (bool): 
        
        Returns:
            Array[RigVMLink]:
        """
        ...
    def get_sub_pins(self) -> Array[RigVMPin]:
        r"""
        x.get_sub_pins() -> Array[RigVMPin]
        Returns all of the SubPins of this one.
        
        Returns:
            Array[RigVMPin]:
        """
        ...
    def get_sub_pin_path(self, parent_pin: RigVMPin, include_parent_pin_name: bool = False) -> str:
        r"""
        x.get_sub_pin_path(parent_pin, include_parent_pin_name=False) -> str
        Returns a . separated path containing all names of the pin and its owners
        until we hit the provided parent pin.
        
        Args:
            parent_pin (RigVMPin): 
            include_parent_pin_name (bool): 
        
        Returns:
            str:
        """
        ...
    def get_source_links(self, recursive: bool = False) -> Array[RigVMLink]:
        r"""
        x.get_source_links(recursive=False) -> Array[RigVMLink]
        Returns all of the source pins
        using this Pin as the target.
        
        Args:
            recursive (bool): 
        
        Returns:
            Array[RigVMLink]:
        """
        ...
    def get_segment_path(self, include_root_pin: bool = False) -> str:
        r"""
        x.get_segment_path(include_root_pin=False) -> str
        Returns a . separated path containing all names of the pin within its main
        memory owner / storage. This is typically used to create an offset pointer
        within memory (FRigVMRegisterOffset).
        So for example for a PinPath such as "Node.Transform.Translation.X" the
        corresponding SegmentPath is "Translation.X", since the transform is the
        storage / memory.
        
        Args:
            include_root_pin (bool): 
        
        Returns:
            str:
        """
        ...
    def get_script_struct(self) -> ScriptStruct:
        r"""
        x.get_script_struct() -> ScriptStruct
        Returns the struct of the data type of the Pin,
        or nullptr otherwise.
        
        Returns:
            ScriptStruct:
        """
        ...
    def get_root_pin(self) -> RigVMPin:
        r"""
        x.get_root_pin() -> RigVMPin
        Returns the top-most parent Pin, so for example
        for "Node.Transform.Translation.X" this returns
        the Pin for "Node.Transform".
        
        Returns:
            RigVMPin:
        """
        ...
    def get_pin_path(self, use_node_path: bool = False) -> str:
        r"""
        x.get_pin_path(use_node_path=False) -> str
        Returns a . separated path containing all names of the pin and its owners,
        this includes the node name, for example "Node.Color.R"
        
        Args:
            use_node_path (bool): 
        
        Returns:
            str:
        """
        ...
    def get_pin_index(self) -> int:
        r"""
        x.get_pin_index() -> int32
        Returns the index of the Pin within the node / parent Pin
        
        Returns:
            int32:
        """
        ...
    def get_pin_for_link(self) -> RigVMPin:
        r"""
        x.get_pin_for_link() -> RigVMPin
        Returns the pin to be used for a link.
        This might differ from this actual pin, since
        the pin might contain injected nodes.
        
        Returns:
            RigVMPin:
        """
        ...
    def get_parent_pin(self) -> RigVMPin:
        r"""
        x.get_parent_pin() -> RigVMPin
        Returns the parent Pin - or nullptr if the Pin
        is nested directly below a node.
        
        Returns:
            RigVMPin:
        """
        ...
    def get_original_pin_from_injected_node(self) -> RigVMPin:
        r"""
        x.get_original_pin_from_injected_node() -> RigVMPin
        Returns the original pin for a pin on an injected
        node. This can be used to determine where a link
        should go in the user interface
        
        Returns:
            RigVMPin:
        """
        ...
    def get_node(self) -> RigVMNode:
        r"""
        x.get_node() -> RigVMNode
        Returns the node of this Pin.
        
        Returns:
            RigVMNode:
        """
        ...
    def get_meta_data(self, key: Name) -> str:
        r"""
        x.get_meta_data(key) -> str
        Returns the keyed metadata associated with this pin, if any
        
        Args:
            key (Name): 
        
        Returns:
            str:
        """
        ...
    def get_links(self) -> Array[RigVMLink]:
        r"""
        x.get_links() -> Array[RigVMLink]
        Returns all of the links linked to this Pin.
        
        Returns:
            Array[RigVMLink]:
        """
        ...
    def get_linked_target_pins(self, recursive: bool = False) -> Array[RigVMPin]:
        r"""
        x.get_linked_target_pins(recursive=False) -> Array[RigVMPin]
        Returns all of the linked target Pins,
        using this Pin as the source.
        
        Args:
            recursive (bool): 
        
        Returns:
            Array[RigVMPin]:
        """
        ...
    def get_linked_source_pins(self, recursive: bool = False) -> Array[RigVMPin]:
        r"""
        x.get_linked_source_pins(recursive=False) -> Array[RigVMPin]
        Returns all of the linked source Pins,
        using this Pin as the target.
        
        Args:
            recursive (bool): 
        
        Returns:
            Array[RigVMPin]:
        """
        ...
    def get_graph(self) -> RigVMGraph:
        r"""
        x.get_graph() -> RigVMGraph
        Returns the graph of this Pin.
        
        Returns:
            RigVMGraph:
        """
        ...
    def get_enum(self) -> Enum:
        r"""
        x.get_enum() -> Enum
        Returns the enum of the data type of the Pin,
        or nullptr otherwise.
        
        Returns:
            Enum:
        """
        ...
    def get_display_name(self) -> Name:
        r"""
        x.get_display_name() -> Name
        Returns the display label of the pin
        
        Returns:
            Name:
        """
        ...
    def get_direction(self) -> RigVMPinDirection:
        r"""
        x.get_direction() -> RigVMPinDirection
        Returns the direction of the pin
        
        Returns:
            RigVMPinDirection:
        """
        ...
    def get_default_value(self) -> str:
        r"""
        x.get_default_value() -> str
        Returns the default value of the Pin as a string.
        Note that this value is computed based on the Pin's
        SubPins - so for example for a FVector typed Pin
        the default value is actually composed out of the
        default values of the X, Y and Z SubPins.
        
        Returns:
            str:
        """
        ...
    def get_custom_widget_name(self) -> Name:
        r"""
        x.get_custom_widget_name() -> Name
        Returns the name of a custom widget to be used
        for editing the Pin.
        
        Returns:
            Name:
        """
        ...
    def get_cpp_type_object(self) -> Object:
        r"""
        x.get_cpp_type_object() -> Object
        Returns the struct of the data type of the Pin,
        or nullptr otherwise.
        
        Returns:
            Object:
        """
        ...
    def get_cpp_type(self) -> str:
        r"""
        x.get_cpp_type() -> str
        Returns the C++ data type of the pin
        
        Returns:
            str:
        """
        ...
    def get_array_size(self) -> int:
        r"""
        x.get_array_size() -> int32
        Returns the number of elements within an array Pin
        
        Returns:
            int32:
        """
        ...
    def get_array_element_cpp_type(self) -> str:
        r"""
        x.get_array_element_cpp_type() -> str
        Returns the C++ data type of an element of the Pin array
        
        Returns:
            str:
        """
        ...
    def get_absolute_pin_index(self) -> int:
        r"""
        x.get_absolute_pin_index() -> int32
        Returns the absolute index of the Pin within the node / parent Pin
        
        Returns:
            int32:
        """
        ...
    def find_sub_pin(self, pin_path: str) -> RigVMPin:
        r"""
        x.find_sub_pin(pin_path) -> RigVMPin
        Returns a SubPin given a name / path or nullptr.
        
        Args:
            pin_path (str): 
        
        Returns:
            RigVMPin:
        """
        ...
    def find_link_for_pin(self, other_pin: RigVMPin) -> RigVMLink:
        r"""
        x.find_link_for_pin(other_pin) -> RigVMLink
        Returns the link that represents the connection
        between this pin and InOtherPin. nullptr is returned
        if the pins are not connected.
        
        Args:
            other_pin (RigVMPin): 
        
        Returns:
            RigVMLink:
        """
        ...
    def contains_wild_card_sub_pin(self) -> bool:
        r"""
        x.contains_wild_card_sub_pin() -> bool
        Returns true if any of the subpins is a wildcard
        
        Returns:
            bool:
        """
        ...

class RigVMUserWorkflowRegistry(Object):
    r"""
    Rig VMUser Workflow Registry
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMUserWorkflowRegistry.h
    
    """
    def unregister_provider(self, handle: int) -> None:
        r"""
        x.unregister_provider(handle) -> None
        Unregister Provider
        
        Args:
            handle (int32):
        """
        ...
    def register_provider(self, struct: ScriptStruct, provider: RigVMUserWorkflowProvider) -> int:
        r"""
        x.register_provider(struct, provider) -> int32
        Register Provider
        
        Args:
            struct (ScriptStruct): 
            provider (RigVMUserWorkflowProvider): 
        
        Returns:
            int32:
        """
        ...
    def get_workflows(self, type: RigVMUserWorkflowType, struct: ScriptStruct, subject: Object) -> Array[RigVMUserWorkflow]:
        r"""
        x.get_workflows(type, struct, subject) -> Array[RigVMUserWorkflow]
        Get Workflows
        
        Args:
            type (RigVMUserWorkflowType): 
            struct (ScriptStruct): 
            subject (Object): 
        
        Returns:
            Array[RigVMUserWorkflow]:
        """
        ...
    @classmethod
    def get(cls) -> RigVMUserWorkflowRegistry:
        r"""
        X.get() -> RigVMUserWorkflowRegistry
        Get
        
        Returns:
            RigVMUserWorkflowRegistry:
        """
        ...

class ControlRigShapeLibraryLink(NameSpacedUserData):
    r"""
    Namespaced user data which provides access to a linked shape library
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigAssetUserData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name_space`` (str):  [Read-Write] The namespace to use when looking up values inside of the user data.
    - ``shape_library`` (ControlRigShapeLibrary):  [Read-Write] If assigned, the data asset link will provide access to the data asset's content.
    """
    @property
    def shape_library(self) -> ControlRigShapeLibrary:
        r"""
        (ControlRigShapeLibrary):  [Read-Write] If assigned, the data asset link will provide access to the data asset's content.
        """
        ...
    @shape_library.setter
    def shape_library(self, value: ControlRigShapeLibrary) -> None:
        ...

class ControlRig(RigVMHost):
    r"""
    Runs logic for mapping input data to transforms (the "Rig")
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``on_control_selected_bp`` (OnControlSelectedBP):  [Read-Write]
    """
    @property
    def on_control_selected_bp(self) -> OnControlSelectedBP:
        r"""
        (OnControlSelectedBP):  [Read-Write]
        """
        ...
    @on_control_selected_bp.setter
    def on_control_selected_bp(self, value: OnControlSelectedBP) -> None:
        ...
    def supports_backwards_solve(self) -> bool:
        r"""
        x.supports_backwards_solve() -> bool
        Contains a backwards solve event
        
        Returns:
            bool:
        """
        ...
    def select_control(self, control_name: Name, select: bool = True) -> None:
        r"""
        x.select_control(control_name, select=True) -> None
        Select Control
        
        Args:
            control_name (Name): 
            select (bool):
        """
        ...
    def request_construction(self) -> None:
        r"""
        x.request_construction() -> None
        Requests to perform construction during the next execution
        """
        ...
    def is_control_selected(self, control_name: Name) -> bool:
        r"""
        x.is_control_selected(control_name) -> bool
        Is Control Selected
        
        Args:
            control_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def get_hosting_actor(self) -> Actor:
        r"""
        x.get_hosting_actor() -> Actor
        Find the actor the rig is bound to, if any
        
        Returns:
            Actor:
        """
        ...
    def get_hierarchy(self) -> RigHierarchy:
        r"""
        x.get_hierarchy() -> RigHierarchy
        Get Hierarchy
        
        Returns:
            RigHierarchy:
        """
        ...
    @classmethod
    def find_control_rigs(cls, outer: Object, optional_class: Class) -> Array[ControlRig]:
        r"""
        X.find_control_rigs(outer, optional_class) -> Array[ControlRig]
        Find Control Rigs
        
        Args:
            outer (Object): 
            optional_class (type(Class)): 
        
        Returns:
            Array[ControlRig]:
        """
        ...
    def current_control_selection(self) -> Array[Name]:
        r"""
        x.current_control_selection() -> Array[Name]
        Current Control Selection
        
        Returns:
            Array[Name]:
        """
        ...
    def create_transformable_control_handle(self, control_name: Name) -> TransformableControlHandle:
        r"""
        x.create_transformable_control_handle(control_name) -> TransformableControlHandle
        Creates a transformable control handle for the specified control to be used by the constraints system. Should use the UObject from
              ConstraintsScriptingLibrary::GetManager(UWorld* InWorld)
        
        Args:
            control_name (Name): 
        
        Returns:
            TransformableControlHandle:
        """
        ...
    def clear_control_selection(self) -> bool:
        r"""
        x.clear_control_selection() -> bool
        Clear Control Selection
        
        Returns:
            bool:
        """
        ...

class ModularRig(ControlRig):
    r"""
    Runs logic for mapping input data to transforms (the "Rig")
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ModularRig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``on_control_selected_bp`` (OnControlSelectedBP):  [Read-Write]
    """
    ...

class RigHierarchy(Object):
    r"""
    Rig Hierarchy
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``modified_event`` (RigHierarchyModifiedDynamicEvent):  [Read-Write]
    """
    @property
    def modified_event(self) -> RigHierarchyModifiedDynamicEvent:
        r"""
        (RigHierarchyModifiedDynamicEvent):  [Read-Only]
        """
        ...
    def unset_curve_value_by_index(self, element_index: int, setup_undo: bool = False) -> None:
        r"""
        x.unset_curve_value_by_index(element_index, setup_undo=False) -> None
        Sets a curve's value given its index
        
        Args:
            element_index (int32): The index of the element to set the value for
            setup_undo (bool): If true the transform stack will be setup for undo / redo
        """
        ...
    def unset_curve_value(self, key: RigElementKey, setup_undo: bool = False) -> None:
        r"""
        x.unset_curve_value(key, setup_undo=False) -> None
        Sets a curve's value given its key
        
        Args:
            key (RigElementKey): The key of the element to set the value for
            setup_undo (bool): If true the transform stack will be setup for undo / redo
        """
        ...
    def switch_to_world_space(self, child: RigElementKey, initial: bool = False, affect_children: bool = True) -> bool:
        r"""
        x.switch_to_world_space(child, initial=False, affect_children=True) -> bool
        Switches a multi parent element to world space.
        This injects a world space reference.
        
        Args:
            child (RigElementKey): The key of the multi parented element
            initial (bool): If true the initial weights will be used
            affect_children (bool): If set to false children will not move (maintain global).
        
        Returns:
            bool: Returns true if changing the weight was successful
        """
        ...
    def switch_to_parent(self, child: RigElementKey, parent: RigElementKey, initial: bool = False, affect_children: bool = True) -> bool:
        r"""
        x.switch_to_parent(child, parent, initial=False, affect_children=True) -> bool
        Switches a multi parent element to a single parent.
        This sets the new parent's weight to 1.0 and disables
        weights for all other potential parents.
        
        Args:
            child (RigElementKey): The key of the multi parented element
            parent (RigElementKey): The key of the parent to look up the weight for
            initial (bool): If true the initial weights will be used
            affect_children (bool): If set to false children will not move (maintain global).
        
        Returns:
            bool: Returns true if changing the weight was successful
        """
        ...
    def switch_to_default_parent(self, child: RigElementKey, initial: bool = False, affect_children: bool = True) -> bool:
        r"""
        x.switch_to_default_parent(child, initial=False, affect_children=True) -> bool
        Switches a multi parent element to its first parent
        
        Args:
            child (RigElementKey): The key of the multi parented element
            initial (bool): If true the initial weights will be used
            affect_children (bool): If set to false children will not move (maintain global).
        
        Returns:
            bool: Returns true if changing the weight was successful
        """
        ...
    def sort_keys(self, keys: Array[RigElementKey]) -> Array[RigElementKey]:
        r"""
        x.sort_keys(keys) -> Array[RigElementKey]
        Sorts the input key list by traversing the hierarchy
        
        Args:
            keys (Array[RigElementKey]): The keys to sort
        
        Returns:
            Array[RigElementKey]: The sorted keys
        """
        ...
    def set_vector_metadata(self, item: RigElementKey, metadata_name: Name, value: Vector) -> bool:
        r"""
        x.set_vector_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FVector value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Vector): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_vector_array_metadata(self, item: RigElementKey, metadata_name: Name, value: Array[Vector]) -> bool:
        r"""
        x.set_vector_array_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FVector array value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Array[Vector]): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_transform_metadata(self, item: RigElementKey, metadata_name: Name, value: Transform) -> bool:
        r"""
        x.set_transform_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FTransform value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Transform): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_transform_array_metadata(self, item: RigElementKey, metadata_name: Name, value: Array[Transform]) -> bool:
        r"""
        x.set_transform_array_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FTransform array value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Array[Transform]): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_tag(self, item: RigElementKey, tag: Name) -> bool:
        r"""
        x.set_tag(item, tag) -> bool
        * Sets a tag on an element in the hierarchy
        *
        
        Args:
            item (RigElementKey): The item to set the tag for *
            tag (Name): The tag to set
        
        Returns:
            bool:
        """
        ...
    def set_rotator_metadata(self, item: RigElementKey, metadata_name: Name, value: Rotator) -> bool:
        r"""
        x.set_rotator_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FRotator value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Rotator): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_rotator_array_metadata(self, item: RigElementKey, metadata_name: Name, value: Array[Rotator]) -> bool:
        r"""
        x.set_rotator_array_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FRotator array value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Array[Rotator]): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_rig_element_key_metadata(self, item: RigElementKey, metadata_name: Name, value: RigElementKey) -> bool:
        r"""
        x.set_rig_element_key_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FRigElementKey value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (RigElementKey): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_rig_element_key_array_metadata(self, item: RigElementKey, metadata_name: Name, value: Array[RigElementKey]) -> bool:
        r"""
        x.set_rig_element_key_array_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FRigElementKey array value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Array[RigElementKey]): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_quat_metadata(self, item: RigElementKey, metadata_name: Name, value: Quat) -> bool:
        r"""
        x.set_quat_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FQuat value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Quat): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_quat_array_metadata(self, item: RigElementKey, metadata_name: Name, value: Array[Quat]) -> bool:
        r"""
        x.set_quat_array_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FQuat array value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Array[Quat]): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_pose(self, pose: RigPose) -> None:
        r"""
        x.set_pose(pose) -> None
        Sets the current / initial pose of the hierarchy
        
        Args:
            pose (RigPose): The pose to set on the hierarchy
        """
        ...
    def set_parent_weight_array(self, child: RigElementKey, weights: Array[RigElementWeight], initial: bool = False, affect_children: bool = True) -> bool:
        r"""
        x.set_parent_weight_array(child, weights, initial=False, affect_children=True) -> bool
        Sets the all of the weights of the parents of a multi parent element
        
        Args:
            child (RigElementKey): The key of the multi parented element
            weights (Array[RigElementWeight]): The new weights to set for the parents
            initial (bool): If true the initial weights will be used
            affect_children (bool): If set to false children will not move (maintain global).
        
        Returns:
            bool: Returns true if changing the weight was successful
        """
        ...
    def set_parent_weight(self, child: RigElementKey, parent: RigElementKey, weight: RigElementWeight, initial: bool = False, affect_children: bool = True) -> bool:
        r"""
        x.set_parent_weight(child, parent, weight, initial=False, affect_children=True) -> bool
        Sets the weight of a parent below a multi parent element
        
        Args:
            child (RigElementKey): The key of the multi parented element
            parent (RigElementKey): The key of the parent to look up the weight for
            weight (RigElementWeight): The new weight to set for the parent
            initial (bool): If true the initial weights will be used
            affect_children (bool): If set to false children will not move (maintain global).
        
        Returns:
            bool: Returns true if changing the weight was successful
        """
        ...
    def set_name_metadata(self, item: RigElementKey, metadata_name: Name, value: Name) -> bool:
        r"""
        x.set_name_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FName value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Name): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_name_array_metadata(self, item: RigElementKey, metadata_name: Name, value: Array[Name]) -> bool:
        r"""
        x.set_name_array_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FName array value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Array[Name]): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_local_transform_by_index(self, element_index: int, transform: Transform, initial: bool = False, affect_children: bool = True, setup_undo: bool = False, print_python_commands: bool = False) -> None:
        r"""
        x.set_local_transform_by_index(element_index, transform, initial=False, affect_children=True, setup_undo=False, print_python_commands=False) -> None
        Sets the local current or initial transform for a given element index.
        
        Args:
            element_index (int32): The index of the element to set the transform for
            transform (Transform): The new transform value to set
            initial (bool): If true the initial transform will be used
            affect_children (bool): If set to false children will not move (maintain global).
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            print_python_commands (bool):
        """
        ...
    def set_local_transform(self, key: RigElementKey, transform: Transform, initial: bool = False, affect_children: bool = True, setup_undo: bool = False, print_python_commands: bool = False) -> None:
        r"""
        x.set_local_transform(key, transform, initial=False, affect_children=True, setup_undo=False, print_python_commands=False) -> None
        Sets the local current or initial transform for a given key.
        
        Args:
            key (RigElementKey): The key to set the transform for
            transform (Transform): The new transform value to set
            initial (bool): If true the initial transform will be used
            affect_children (bool): If set to false children will not move (maintain global).
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            print_python_commands (bool):
        """
        ...
    def set_linear_color_metadata(self, item: RigElementKey, metadata_name: Name, value: LinearColor) -> bool:
        r"""
        x.set_linear_color_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FLinearColor value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (LinearColor): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_linear_color_array_metadata(self, item: RigElementKey, metadata_name: Name, value: Array[LinearColor]) -> bool:
        r"""
        x.set_linear_color_array_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a FLinearColor array value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Array[LinearColor]): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_int32_metadata(self, item: RigElementKey, metadata_name: Name, value: int) -> bool:
        r"""
        x.set_int32_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a int32 value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (int32): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_int32_array_metadata(self, item: RigElementKey, metadata_name: Name, value: Array[int]) -> bool:
        r"""
        x.set_int32_array_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a int32 array value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Array[int32]): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_global_transform_by_index(self, element_index: int, transform: Transform, initial: bool = False, affect_children: bool = True, setup_undo: bool = False, print_python_command: bool = False) -> None:
        r"""
        x.set_global_transform_by_index(element_index, transform, initial=False, affect_children=True, setup_undo=False, print_python_command=False) -> None
        Sets the global current or initial transform for a given element index.
        
        Args:
            element_index (int32): The index of the element to set the transform for
            transform (Transform): The new transform value to set
            initial (bool): If true the initial transform will be used
            affect_children (bool): If set to false children will not move (maintain global).
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            print_python_command (bool):
        """
        ...
    def set_global_transform(self, key: RigElementKey, transform: Transform, initial: bool = False, affect_children: bool = True, setup_undo: bool = False, print_python_command: bool = False) -> None:
        r"""
        x.set_global_transform(key, transform, initial=False, affect_children=True, setup_undo=False, print_python_command=False) -> None
        Sets the global current or initial transform for a given key.
        
        Args:
            key (RigElementKey): The key to set the transform for
            transform (Transform): The new transform value to set
            initial (bool): If true the initial transform will be used
            affect_children (bool): If set to false children will not move (maintain global).
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            print_python_command (bool):
        """
        ...
    def set_float_metadata(self, item: RigElementKey, metadata_name: Name, value: float) -> bool:
        r"""
        x.set_float_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a float value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (float): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_float_array_metadata(self, item: RigElementKey, metadata_name: Name, value: Array[float]) -> bool:
        r"""
        x.set_float_array_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a float array value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Array[float]): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_curve_value_by_index(self, element_index: int, value: float, setup_undo: bool = False) -> None:
        r"""
        x.set_curve_value_by_index(element_index, value, setup_undo=False) -> None
        Sets a curve's value given its index
        
        Args:
            element_index (int32): The index of the element to set the value for
            value (float): The value to set on the curve
            setup_undo (bool): If true the transform stack will be setup for undo / redo
        """
        ...
    def set_curve_value(self, key: RigElementKey, value: float, setup_undo: bool = False) -> None:
        r"""
        x.set_curve_value(key, value, setup_undo=False) -> None
        Sets a curve's value given its key
        
        Args:
            key (RigElementKey): The key of the element to set the value for
            value (float): The value to set on the curve
            setup_undo (bool): If true the transform stack will be setup for undo / redo
        """
        ...
    def set_control_visibility_by_index(self, element_index: int, visibility: bool) -> None:
        r"""
        x.set_control_visibility_by_index(element_index, visibility) -> None
        Sets a control's current visibility based on a key
        
        Args:
            element_index (int32): The index of the element to set the visibility for
            visibility (bool): The visibility to set on the control
        """
        ...
    def set_control_visibility(self, key: RigElementKey, visibility: bool) -> None:
        r"""
        x.set_control_visibility(key, visibility) -> None
        Sets a control's current visibility based on a key
        
        Args:
            key (RigElementKey): The key of the element to set the visibility for
            visibility (bool): The visibility to set on the control
        """
        ...
    def set_control_value_by_index(self, element_index: int, value: RigControlValue, value_type: RigControlValueType = RigControlValueType.CURRENT, setup_undo: bool = False, print_python_commands: bool = False) -> None:
        r"""
        x.set_control_value_by_index(element_index, value, value_type=RigControlValueType.CURRENT, setup_undo=False, print_python_commands=False) -> None
        Sets a control's current value given its index
        
        Args:
            element_index (int32): The index of the element to set the current value for
            value (RigControlValue): The value to set on the control
            value_type (RigControlValueType): The type of value to set
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            print_python_commands (bool):
        """
        ...
    def set_control_value(self, key: RigElementKey, value: RigControlValue, value_type: RigControlValueType = RigControlValueType.CURRENT, setup_undo: bool = False, print_python_commands: bool = False) -> None:
        r"""
        x.set_control_value(key, value, value_type=RigControlValueType.CURRENT, setup_undo=False, print_python_commands=False) -> None
        Sets a control's current value given its key
        
        Args:
            key (RigElementKey): The key of the element to set the current value for
            value (RigControlValue): The value to set on the control
            value_type (RigControlValueType): The type of value to set
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            print_python_commands (bool):
        """
        ...
    def set_control_shape_transform_by_index(self, element_index: int, transform: Transform, initial: bool = False, setup_undo: bool = False) -> None:
        r"""
        x.set_control_shape_transform_by_index(element_index, transform, initial=False, setup_undo=False) -> None
        Sets the local shape transform for a given control element by index
        
        Args:
            element_index (int32): The index of the control element to set the shape transform for
            transform (Transform): The new local shape transform value to set
            initial (bool): If true the initial value will be used
            setup_undo (bool): If true the transform stack will be setup for undo / redo
        """
        ...
    def set_control_shape_transform(self, key: RigElementKey, transform: Transform, initial: bool = False, setup_undo: bool = False) -> None:
        r"""
        x.set_control_shape_transform(key, transform, initial=False, setup_undo=False) -> None
        Sets the shape transform for a given control element by key
        
        Args:
            key (RigElementKey): The key of the control element to set the shape transform for
            transform (Transform): The new shape transform value to set
            initial (bool): If true the initial value will be used
            setup_undo (bool): If true the transform stack will be setup for undo / redo
        """
        ...
    def set_control_settings_by_index(self, element_index: int, settings: RigControlSettings, setup_undo: bool = False, force: bool = False, print_python_commands: bool = False) -> None:
        r"""
        x.set_control_settings_by_index(element_index, settings, setup_undo=False, force=False, print_python_commands=False) -> None
        Sets the control settings for a given control element by index
        
        Args:
            element_index (int32): The index of the control element to set the settings for
            settings (RigControlSettings): The new control settings value to set
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            force (bool): 
            print_python_commands (bool):
        """
        ...
    def set_control_settings(self, key: RigElementKey, settings: RigControlSettings, setup_undo: bool = False, force: bool = False, print_python_commands: bool = False) -> None:
        r"""
        x.set_control_settings(key, settings, setup_undo=False, force=False, print_python_commands=False) -> None
        Sets the control settings for a given control element by key
        
        Args:
            key (RigElementKey): The key of the control element to set the settings for
            settings (RigControlSettings): The new control settings value to set
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            force (bool): 
            print_python_commands (bool):
        """
        ...
    def set_control_preferred_rotator_by_index(self, element_index: int, rotator: Rotator, initial: bool = False, fix_euler_flips: bool = False) -> None:
        r"""
        x.set_control_preferred_rotator_by_index(element_index, rotator, initial=False, fix_euler_flips=False) -> None
        Sets a control's preferred rotator (local transform rotation)
        
        Args:
            element_index (int32): The element index to look up
            rotator (Rotator): The new preferred rotator to set
            initial (bool): If true we'll return the preferred rotator for the initial - otherwise current transform
            fix_euler_flips (bool): If true the new rotator value will use the shortest path
        """
        ...
    def set_control_preferred_rotator(self, key: RigElementKey, rotator: Rotator, initial: bool = False, fix_euler_flips: bool = False) -> None:
        r"""
        x.set_control_preferred_rotator(key, rotator, initial=False, fix_euler_flips=False) -> None
        Sets a control's preferred rotator (local transform rotation)
        
        Args:
            key (RigElementKey): The key of the element to retrieve the current value for
            rotator (Rotator): The new preferred rotator to set
            initial (bool): If true we'll return the preferred rotator for the initial - otherwise current transform
            fix_euler_flips (bool): If true the new rotator value will use the shortest path
        """
        ...
    def set_control_preferred_rotation_order_by_index(self, element_index: int, rotation_order: EulerRotationOrder) -> None:
        r"""
        x.set_control_preferred_rotation_order_by_index(element_index, rotation_order) -> None
        Sets a control's preferred euler rotation order
        
        Args:
            element_index (int32): The element index to look up
            rotation_order (EulerRotationOrder): The rotation order to use when setting the euler angles
        """
        ...
    def set_control_preferred_rotation_order(self, key: RigElementKey, rotation_order: EulerRotationOrder) -> None:
        r"""
        x.set_control_preferred_rotation_order(key, rotation_order) -> None
        Sets a control's preferred euler rotation order
        
        Args:
            key (RigElementKey): The key of the element to retrieve the current value for
            rotation_order (EulerRotationOrder): The rotation order to use when setting the euler angles
        """
        ...
    def set_control_preferred_euler_angles_by_index(self, element_index: int, euler_angles: Vector, rotation_order: EulerRotationOrder, initial: bool = False, fix_euler_flips: bool = False) -> None:
        r"""
        x.set_control_preferred_euler_angles_by_index(element_index, euler_angles, rotation_order, initial=False, fix_euler_flips=False) -> None
        Sets a control's preferred euler angles (local transform rotation)
        
        Args:
            element_index (int32): The element index to look up
            euler_angles (Vector): The new preferred euler angles to set
            rotation_order (EulerRotationOrder): The rotation order to use when setting the euler angles
            initial (bool): If true we'll return the preferred euler angles for the initial - otherwise current transform
            fix_euler_flips (bool): If true the new euler angles value will use the shortest path
        """
        ...
    def set_control_preferred_euler_angles(self, key: RigElementKey, euler_angles: Vector, rotation_order: EulerRotationOrder, initial: bool = False, fix_euler_flips: bool = False) -> None:
        r"""
        x.set_control_preferred_euler_angles(key, euler_angles, rotation_order, initial=False, fix_euler_flips=False) -> None
        Sets a control's preferred euler angles (local transform rotation)
        
        Args:
            key (RigElementKey): The key of the element to retrieve the current value for
            euler_angles (Vector): The new preferred euler angles to set
            rotation_order (EulerRotationOrder): The rotation order to use when setting the euler angles
            initial (bool): If true we'll return the preferred euler angles for the initial - otherwise current transform
            fix_euler_flips (bool): If true the new euler angles value will use the shortest path
        """
        ...
    def set_control_offset_transform_by_index(self, element_index: int, transform: Transform, initial: bool = False, affect_children: bool = True, setup_undo: bool = False, print_python_commands: bool = False) -> None:
        r"""
        x.set_control_offset_transform_by_index(element_index, transform, initial=False, affect_children=True, setup_undo=False, print_python_commands=False) -> None
        Sets the local offset transform for a given control element by index
        
        Args:
            element_index (int32): The index of the control element to set the offset transform for
            transform (Transform): The new local offset transform value to set
            initial (bool): If true the initial value will be used
            affect_children (bool): If set to false children will not move (maintain global).
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            print_python_commands (bool):
        """
        ...
    def set_control_offset_transform(self, key: RigElementKey, transform: Transform, initial: bool = False, affect_children: bool = True, setup_undo: bool = False, print_python_commands: bool = False) -> None:
        r"""
        x.set_control_offset_transform(key, transform, initial=False, affect_children=True, setup_undo=False, print_python_commands=False) -> None
        Sets the offset transform for a given control element by key
        
        Args:
            key (RigElementKey): The key of the control element to set the offset transform for
            transform (Transform): The new offset transform value to set
            initial (bool): If true the initial value will be used
            affect_children (bool): If set to false children will not move (maintain global).
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            print_python_commands (bool):
        """
        ...
    def set_connector_settings_by_index(self, element_index: int, settings: RigConnectorSettings, setup_undo: bool = False, force: bool = False, print_python_commands: bool = False) -> None:
        r"""
        x.set_connector_settings_by_index(element_index, settings, setup_undo=False, force=False, print_python_commands=False) -> None
        Sets the connector settings for a given connector element by index
        
        Args:
            element_index (int32): The index of the connector element to set the settings for
            settings (RigConnectorSettings): The new connector settings value to set
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            force (bool): 
            print_python_commands (bool):
        """
        ...
    def set_connector_settings(self, key: RigElementKey, settings: RigConnectorSettings, setup_undo: bool = False, force: bool = False, print_python_commands: bool = False) -> None:
        r"""
        x.set_connector_settings(key, settings, setup_undo=False, force=False, print_python_commands=False) -> None
        Sets the connector settings for a given connector element by key
        
        Args:
            key (RigElementKey): The key of the connector element to set the settings for
            settings (RigConnectorSettings): The new connector settings value to set
            setup_undo (bool): If true the transform stack will be setup for undo / redo
            force (bool): 
            print_python_commands (bool):
        """
        ...
    def set_bool_metadata(self, item: RigElementKey, metadata_name: Name, value: bool) -> bool:
        r"""
        x.set_bool_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a bool value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (bool): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def set_bool_array_metadata(self, item: RigElementKey, metadata_name: Name, value: Array[bool]) -> bool:
        r"""
        x.set_bool_array_metadata(item, metadata_name, value) -> bool
        Sets the metadata to a bool array value
        
        Args:
            item (RigElementKey): The element key to set the metadata for
            metadata_name (Name): The name of the metadata to set
            value (Array[bool]): The value to set
        
        Returns:
            bool: Returns true if setting the metadata was successful
        """
        ...
    def send_auto_key_event(self, element: RigElementKey, offset_in_seconds: float = 0.000000, asynchronous: bool = True) -> None:
        r"""
        x.send_auto_key_event(element, offset_in_seconds=0.000000, asynchronous=True) -> None
        Sends an autokey event from the hierarchy to the world
        
        Args:
            element (RigElementKey): The element to send the autokey for
            offset_in_seconds (float): The time offset in seconds
            asynchronous (bool): If set to true the event will go on a thread safe queue
        """
        ...
    def restore_sockets_from_states(self, states: Array[RigSocketState], setup_undo_redo: bool = False) -> Array[RigElementKey]:
        r"""
        x.restore_sockets_from_states(states, setup_undo_redo=False) -> Array[RigElementKey]
        Try to restore the sockets from the state structs
        
        Args:
            states (Array[RigSocketState]): 
            setup_undo_redo (bool): 
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def restore_connectors_from_states(self, states: Array[RigConnectorState], setup_undo_redo: bool = False) -> Array[RigElementKey]:
        r"""
        x.restore_connectors_from_states(states, setup_undo_redo=False) -> Array[RigElementKey]
        Try to restore the connectors from the state structs
        
        Args:
            states (Array[RigConnectorState]): 
            setup_undo_redo (bool): 
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def reset_to_default(self) -> None:
        r"""
        x.reset_to_default() -> None
        Resets the hierarchy to the state of its default. This refers to the
        hierarchy on the default object.
        """
        ...
    def reset_pose_to_initial(self, type_filter: RigElementType) -> None:
        r"""
        x.reset_pose_to_initial(type_filter) -> None
        Resets the current pose of a filtered list of elements to the initial / ref pose.
        
        Args:
            type_filter (RigElementType):
        """
        ...
    def reset_curve_values(self) -> None:
        r"""
        x.reset_curve_values() -> None
        Resets all curves to 0.0
        """
        ...
    def reset(self) -> None:
        r"""
        x.reset() -> None
        Clears the whole hierarchy and removes all elements.
        """
        ...
    def remove_metadata(self, item: RigElementKey, metadata_name: Name) -> bool:
        r"""
        x.remove_metadata(item, metadata_name) -> bool
        Removes the metadata under a given element
        
        Args:
            item (RigElementKey): The element key to search under
            metadata_name (Name): The name of the metadata to remove
        
        Returns:
            bool:
        """
        ...
    def remove_all_metadata(self, item: RigElementKey) -> bool:
        r"""
        x.remove_all_metadata(item) -> bool
        Removes all of the metadata under a given item
        
        Args:
            item (RigElementKey): The element key to search under
        
        Returns:
            bool:
        """
        ...
    def num(self) -> int:
        r"""
        x.num() -> int32
        Returns the number of elements in the Hierarchy.
        
        Returns:
            int32: The number of elements in the Hierarchy
        """
        ...
    @classmethod
    def make_control_value_from_vector2d(cls, value: Vector2D) -> RigControlValue:
        r"""
        X.make_control_value_from_vector2d(value) -> RigControlValue
        Creates a rig control value from a FVector2D value
        
        Args:
            value (Vector2D): The value to create the rig control value from
        
        Returns:
            RigControlValue: The converted control rig val ue
        """
        ...
    @classmethod
    def make_control_value_from_vector(cls, value: Vector) -> RigControlValue:
        r"""
        X.make_control_value_from_vector(value) -> RigControlValue
        Creates a rig control value from a FVector value
        
        Args:
            value (Vector): The value to create the rig control value from
        
        Returns:
            RigControlValue: The converted control rig val ue
        """
        ...
    @classmethod
    def make_control_value_from_transform_no_scale(cls, value: TransformNoScale) -> RigControlValue:
        r"""
        X.make_control_value_from_transform_no_scale(value) -> RigControlValue
        Creates a rig control value from a FTransformNoScale value
        
        Args:
            value (TransformNoScale): The value to create the rig control value from
        
        Returns:
            RigControlValue: The converted control rig val ue
        """
        ...
    @classmethod
    def make_control_value_from_transform(cls, value: Transform) -> RigControlValue:
        r"""
        X.make_control_value_from_transform(value) -> RigControlValue
        Creates a rig control value from a FTransform value
        
        Args:
            value (Transform): The value to create the rig control value from
        
        Returns:
            RigControlValue: The converted control rig val ue
        """
        ...
    @classmethod
    def make_control_value_from_rotator(cls, value: Rotator) -> RigControlValue:
        r"""
        X.make_control_value_from_rotator(value) -> RigControlValue
        Creates a rig control value from a FRotator value
        
        Args:
            value (Rotator): The value to create the rig control value from
        
        Returns:
            RigControlValue: The converted control rig val ue
        """
        ...
    @classmethod
    def make_control_value_from_int(cls, value: int) -> RigControlValue:
        r"""
        X.make_control_value_from_int(value) -> RigControlValue
        Creates a rig control value from a int32 value
        
        Args:
            value (int32): The value to create the rig control value from
        
        Returns:
            RigControlValue: The converted control rig val ue
        """
        ...
    @classmethod
    def make_control_value_from_float(cls, value: float) -> RigControlValue:
        r"""
        X.make_control_value_from_float(value) -> RigControlValue
        Creates a rig control value from a float value
        
        Args:
            value (float): The value to create the rig control value from
        
        Returns:
            RigControlValue: The converted control rig val ue
        """
        ...
    @classmethod
    def make_control_value_from_euler_transform(cls, value: EulerTransform) -> RigControlValue:
        r"""
        X.make_control_value_from_euler_transform(value) -> RigControlValue
        Creates a rig control value from a FEulerTransform value
        
        Args:
            value (EulerTransform): The value to create the rig control value from
        
        Returns:
            RigControlValue: The converted control rig val ue
        """
        ...
    @classmethod
    def make_control_value_from_bool(cls, value: bool) -> RigControlValue:
        r"""
        X.make_control_value_from_bool(value) -> RigControlValue
        Creates a rig control value from a bool value
        
        Args:
            value (bool): The value to create the rig control value from
        
        Returns:
            RigControlValue: The converted control rig val ue
        """
        ...
    def is_valid_index(self, element_index: int) -> bool:
        r"""
        x.is_valid_index(element_index) -> bool
        Returns true if the provided element index is valid
        
        Args:
            element_index (int32): The index to validate
        
        Returns:
            bool: Returns true if the provided element index is valid
        """
        ...
    def is_selected_by_index(self, index: int) -> bool:
        r"""
        x.is_selected_by_index(index) -> bool
        Returns true if a given element is selected
        
        Args:
            index (int32): The index to check
        
        Returns:
            bool: true if a given element is selected
        """
        ...
    def is_selected(self, key: RigElementKey) -> bool:
        r"""
        x.is_selected(key) -> bool
        Returns true if a given element is selected
        
        Args:
            key (RigElementKey): The key to check
        
        Returns:
            bool: true if a given element is selected
        """
        ...
    def is_procedural(self, key: RigElementKey) -> bool:
        r"""
        x.is_procedural(key) -> bool
        Returns true if the provided element is procedural.
        
        Args:
            key (RigElementKey): The key to validate
        
        Returns:
            bool: Returns true if the element is procedural
        """
        ...
    def is_parented_to(self, child: RigElementKey, parent: RigElementKey) -> bool:
        r"""
        x.is_parented_to(child, parent) -> bool
        Returns true if an element is parented to another element
        
        Args:
            child (RigElementKey): The key of the child element to check for a parent
            parent (RigElementKey): The key of the parent element to check for
        
        Returns:
            bool: True if the given parent and given child have a parent-child relationship
        """
        ...
    def is_curve_value_set_by_index(self, element_index: int) -> bool:
        r"""
        x.is_curve_value_set_by_index(element_index) -> bool
        Returns a curve's value given its index
        
        Args:
            element_index (int32): The index of the element to retrieve the value for
        
        Returns:
            bool: Returns true if the value is set, false otherwise.
        """
        ...
    def is_curve_value_set(self, key: RigElementKey) -> bool:
        r"""
        x.is_curve_value_set(key) -> bool
        Returns whether a curve's value is set, given its key
        
        Args:
            key (RigElementKey): The key of the element to retrieve the value for
        
        Returns:
            bool: Returns true if the value is set, false otherwise.
        """
        ...
    def is_controller_available(self) -> bool:
        r"""
        x.is_controller_available() -> bool
        Returns true if the hierarchy controller is currently available
        The controller may not be available during certain events.
        If the controller is not available then GetController() will return nullptr.
        
        Returns:
            bool:
        """
        ...
    def has_tag(self, item: RigElementKey, tag: Name) -> bool:
        r"""
        x.has_tag(item, tag) -> bool
        * Returns true if a given item has a certain tag
        *
        
        Args:
            item (RigElementKey): The item to return the tags for *
            tag (Name): The tag to check
        
        Returns:
            bool:
        """
        ...
    def get_vector_metadata(self, item: RigElementKey, metadata_name: Name, default_value: Vector) -> Vector:
        r"""
        x.get_vector_metadata(item, metadata_name, default_value) -> Vector
        Queries and returns the value of FVector metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
            default_value (Vector): The default value to fall back on
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_vector_from_control_value(cls, value: RigControlValue) -> Vector:
        r"""
        X.get_vector_from_control_value(value) -> Vector
        Returns the contained FVector value from a a Rig Control Value
        
        Args:
            value (RigControlValue): The Rig Control value to convert from
        
        Returns:
            Vector: The converted FVector value
        """
        ...
    def get_vector_array_metadata(self, item: RigElementKey, metadata_name: Name) -> Array[Vector]:
        r"""
        x.get_vector_array_metadata(item, metadata_name) -> Array[Vector]
        Queries and returns the value of FVector array metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
        
        Returns:
            Array[Vector]:
        """
        ...
    @classmethod
    def get_vector2d_from_control_value(cls, value: RigControlValue) -> Vector2D:
        r"""
        X.get_vector2d_from_control_value(value) -> Vector2D
        Returns the contained FVector2D value from a a Rig Control Value
        
        Args:
            value (RigControlValue): The Rig Control value to convert from
        
        Returns:
            Vector2D: The converted FVector2D value
        """
        ...
    @classmethod
    def get_transform_no_scale_from_control_value(cls, value: RigControlValue) -> TransformNoScale:
        r"""
        X.get_transform_no_scale_from_control_value(value) -> TransformNoScale
        Returns the contained FTransformNoScale value from a a Rig Control Value
        
        Args:
            value (RigControlValue): The Rig Control value to convert from
        
        Returns:
            TransformNoScale: The converted FTransformNoScale value
        """
        ...
    def get_transform_metadata(self, item: RigElementKey, metadata_name: Name, default_value: Transform) -> Transform:
        r"""
        x.get_transform_metadata(item, metadata_name, default_value) -> Transform
        Queries and returns the value of FTransform metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
            default_value (Transform): The default value to fall back on
        
        Returns:
            Transform:
        """
        ...
    @classmethod
    def get_transform_from_control_value(cls, value: RigControlValue) -> Transform:
        r"""
        X.get_transform_from_control_value(value) -> Transform
        Returns the contained FTransform value from a a Rig Control Value
        
        Args:
            value (RigControlValue): The Rig Control value to convert from
        
        Returns:
            Transform: The converted FTransform value
        """
        ...
    def get_transform_array_metadata(self, item: RigElementKey, metadata_name: Name) -> Array[Transform]:
        r"""
        x.get_transform_array_metadata(item, metadata_name) -> Array[Transform]
        Queries and returns the value of FTransform array metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
        
        Returns:
            Array[Transform]:
        """
        ...
    def get_tags(self, item: RigElementKey) -> Array[Name]:
        r"""
        x.get_tags(item) -> Array[Name]
        * Returns the tags for a given item
        *
        
        Args:
            item (RigElementKey): The item to return the tags for
        
        Returns:
            Array[Name]:
        """
        ...
    def get_socket_states(self) -> Array[RigSocketState]:
        r"""
        x.get_socket_states() -> Array[RigSocketState]
        Returns all of the sockets' state
        
        Returns:
            Array[RigSocketState]:
        """
        ...
    def get_sockets(self, traverse: bool = True) -> Array[RigElementKey]:
        r"""
        x.get_sockets(traverse=True) -> Array[RigElementKey]
        Returns all Socket elements
        
        Args:
            traverse (bool): Returns the elements in order of a depth first traversal
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def get_selected_keys(self, type_filter: RigElementType = RigElementType.ALL) -> Array[RigElementKey]:
        r"""
        x.get_selected_keys(type_filter=RigElementType.ALL) -> Array[RigElementKey]
        Returns the keys of selected elements
        InTypeFilter: The types to retrieve the selection for
        
        Args:
            type_filter (RigElementType): 
        
        Returns:
            Array[RigElementKey]: An array of the currently selected elements
        """
        ...
    def get_rule_manager(self, create_if_needed: bool = True) -> ModularRigRuleManager:
        r"""
        x.get_rule_manager(create_if_needed=True) -> ModularRigRuleManager
        Returns a rule manager for this hierarchy
        Note: If the manager is not available this will return nullptr
        even if the bCreateIfNeeded flag is set to true.
        
        Args:
            create_if_needed (bool): Creates a controller if needed
        
        Returns:
            ModularRigRuleManager: The Controller for this hierarchy
        """
        ...
    def get_rotator_metadata(self, item: RigElementKey, metadata_name: Name, default_value: Rotator) -> Rotator:
        r"""
        x.get_rotator_metadata(item, metadata_name, default_value) -> Rotator
        Queries and returns the value of FRotator metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
            default_value (Rotator): The default value to fall back on
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def get_rotator_from_control_value(cls, value: RigControlValue) -> Rotator:
        r"""
        X.get_rotator_from_control_value(value) -> Rotator
        Returns the contained FRotator value from a a Rig Control Value
        
        Args:
            value (RigControlValue): The Rig Control value to convert from
        
        Returns:
            Rotator: The converted FRotator value
        """
        ...
    def get_rotator_array_metadata(self, item: RigElementKey, metadata_name: Name) -> Array[Rotator]:
        r"""
        x.get_rotator_array_metadata(item, metadata_name) -> Array[Rotator]
        Queries and returns the value of FRotator array metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
        
        Returns:
            Array[Rotator]:
        """
        ...
    def get_root_elements(self) -> Array[RigElementKey]:
        r"""
        x.get_root_elements() -> Array[RigElementKey]
        Returns all root element keys
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def get_rigid_bodies(self, traverse: bool = True) -> Array[RigElementKey]:
        r"""
        x.get_rigid_bodies(traverse=True) -> Array[RigElementKey]
        Returns all RigidBody elements
        
        Args:
            traverse (bool): Returns the elements in order of a depth first traversal
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def get_rig_element_key_metadata(self, item: RigElementKey, metadata_name: Name, default_value: RigElementKey) -> RigElementKey:
        r"""
        x.get_rig_element_key_metadata(item, metadata_name, default_value) -> RigElementKey
        Queries and returns the value of FRigElementKey metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
            default_value (RigElementKey): The default value to fall back on
        
        Returns:
            RigElementKey:
        """
        ...
    def get_rig_element_key_array_metadata(self, item: RigElementKey, metadata_name: Name) -> Array[RigElementKey]:
        r"""
        x.get_rig_element_key_array_metadata(item, metadata_name) -> Array[RigElementKey]
        Queries and returns the value of FRigElementKey array metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def get_references(self, traverse: bool = True) -> Array[RigElementKey]:
        r"""
        x.get_references(traverse=True) -> Array[RigElementKey]
        Returns all references
        
        Args:
            traverse (bool): Returns the elements in order of a depth first traversal
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def get_quat_metadata(self, item: RigElementKey, metadata_name: Name, default_value: Quat) -> Quat:
        r"""
        x.get_quat_metadata(item, metadata_name, default_value) -> Quat
        Queries and returns the value of FQuat metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
            default_value (Quat): The default value to fall back on
        
        Returns:
            Quat:
        """
        ...
    def get_quat_array_metadata(self, item: RigElementKey, metadata_name: Name) -> Array[Quat]:
        r"""
        x.get_quat_array_metadata(item, metadata_name) -> Array[Quat]
        Queries and returns the value of FQuat array metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
        
        Returns:
            Array[Quat]:
        """
        ...
    def get_previous_parent(self, key: RigElementKey) -> RigElementKey:
        r"""
        x.get_previous_parent(key) -> RigElementKey
        Returns the previous parent of an element prior to a reparent operation
        
        Args:
            key (RigElementKey): The key of the element to request the old parent  for
        
        Returns:
            RigElementKey:
        """
        ...
    def get_previous_name(self, key: RigElementKey) -> Name:
        r"""
        x.get_previous_name(key) -> Name
        Returns the previous name of an element prior to a rename operation
        
        Args:
            key (RigElementKey): The key of the element to request the old name for
        
        Returns:
            Name:
        """
        ...
    def get_pose(self, initial: bool = False, include_transient_controls: bool = True) -> RigPose:
        r"""
        x.get_pose(initial=False, include_transient_controls=True) -> RigPose
        Returns the current / initial pose of the hierarchy
        
        Args:
            initial (bool): If set to true the initial pose will be returned
            include_transient_controls (bool): If true the transient controls will be included in the pose
        
        Returns:
            RigPose: The pose of the hierarchy
        """
        ...
    def get_parent_weight_array(self, child: RigElementKey, initial: bool = False) -> Array[RigElementWeight]:
        r"""
        x.get_parent_weight_array(child, initial=False) -> Array[RigElementWeight]
        Returns the weights of all parents below a multi parent element
        
        Args:
            child (RigElementKey): The key of the multi parented element
            initial (bool): If true the initial weights will be used
        
        Returns:
            Array[RigElementWeight]: Returns the weight of a parent below a multi parent element, or FLT_MAX if the parent is invalid
        """
        ...
    def get_parent_weight(self, child: RigElementKey, parent: RigElementKey, initial: bool = False) -> RigElementWeight:
        r"""
        x.get_parent_weight(child, parent, initial=False) -> RigElementWeight
        Returns the weight of a parent below a multi parent element
        
        Args:
            child (RigElementKey): The key of the multi parented element
            parent (RigElementKey): The key of the parent to look up the weight for
            initial (bool): If true the initial weights will be used
        
        Returns:
            RigElementWeight: Returns the weight of a parent below a multi parent element, or FLT_MAX if the parent is invalid
        """
        ...
    def get_parent_transform_by_index(self, element_index: int, initial: bool = False) -> Transform:
        r"""
        x.get_parent_transform_by_index(element_index, initial=False) -> Transform
        Returns the global current or initial value for a given element index.
        If the element does not have a parent FTransform::Identity will be returned.
        
        Args:
            element_index (int32): The index of the element to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The element's parent's global current or initial transform's value.
        """
        ...
    def get_parent_transform(self, key: RigElementKey, initial: bool = False) -> Transform:
        r"""
        x.get_parent_transform(key, initial=False) -> Transform
        Returns the global current or initial value for a given key.
        If the element does not have a parent FTransform::Identity will be returned.
        
        Args:
            key (RigElementKey): The key of the element to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The element's parent's global current or initial transform's value.
        """
        ...
    def get_parents(self, key: RigElementKey, recursive: bool = False) -> Array[RigElementKey]:
        r"""
        x.get_parents(key, recursive=False) -> Array[RigElementKey]
        Returns the parent elements of a given element key
        
        Args:
            key (RigElementKey): The key of the element to retrieve the parents for
            recursive (bool): If set to true parents of parents will also be returned
        
        Returns:
            Array[RigElementKey]: Returns the parent elements
        """
        ...
    def get_number_of_parents(self, key: RigElementKey) -> int:
        r"""
        x.get_number_of_parents(key) -> int32
        Returns the number of parents of an element
        
        Args:
            key (RigElementKey): The key of the element to retrieve the number of parents for
        
        Returns:
            int32: Returns the number of parents of an element
        """
        ...
    def get_nulls(self, traverse: bool = True) -> Array[RigElementKey]:
        r"""
        x.get_nulls(traverse=True) -> Array[RigElementKey]
        Returns all Null elements
        
        Args:
            traverse (bool): Returns the elements in order of a depth first traversal
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def get_name_space_f_name(self, item: RigElementKey) -> Name:
        r"""
        x.get_name_space_f_name(item) -> Name
        Returns the namespace of an element belong to (or NAME_None in case the element doesn't belong to a module / namespace)
        
        Args:
            item (RigElementKey): 
        
        Returns:
            Name: The namespace the element belongs to (or NAME_None)
        """
        ...
    def get_name_space(self, item: RigElementKey) -> str:
        r"""
        x.get_name_space(item) -> str
        Returns the namespace of an element belong to (or an empty string in case the element doesn't belong to a module / namespace)
        
        Args:
            item (RigElementKey): 
        
        Returns:
            str: The namespace the element belongs to (or empty string)
        """
        ...
    def get_name_metadata(self, item: RigElementKey, metadata_name: Name, default_value: Name) -> Name:
        r"""
        x.get_name_metadata(item, metadata_name, default_value) -> Name
        Queries and returns the value of FName metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
            default_value (Name): The default value to fall back on
        
        Returns:
            Name:
        """
        ...
    def get_name_array_metadata(self, item: RigElementKey, metadata_name: Name) -> Array[Name]:
        r"""
        x.get_name_array_metadata(item, metadata_name) -> Array[Name]
        Queries and returns the value of FName array metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
        
        Returns:
            Array[Name]:
        """
        ...
    def get_module_path_f_name(self, item: RigElementKey) -> Name:
        r"""
        x.get_module_path_f_name(item) -> Name
        Returns the path of the module an element belong to (or NAME_None in case the element doesn't belong to a module)
        
        Args:
            item (RigElementKey): 
        
        Returns:
            Name: The path the element belongs to (or NAME_None)
        """
        ...
    def get_module_path(self, item: RigElementKey) -> str:
        r"""
        x.get_module_path(item) -> str
        Returns the path of the module an element belong to (or an empty string in case the element doesn't belong to a module)
        
        Args:
            item (RigElementKey): 
        
        Returns:
            str: The path the element belongs to (or empty string)
        """
        ...
    def get_metadata_type(self, item: RigElementKey, metadata_name: Name) -> RigMetadataType:
        r"""
        x.get_metadata_type(item, metadata_name) -> RigMetadataType
        Returns the type of metadata given its name the item it is stored under
        
        Args:
            item (RigElementKey): The element key to return the metadata type for
            metadata_name (Name): The name of the metadata to return the type for
        
        Returns:
            RigMetadataType:
        """
        ...
    def get_metadata_names(self, item: RigElementKey) -> Array[Name]:
        r"""
        x.get_metadata_names(item) -> Array[Name]
        Returns the name of metadata for a given element
        
        Args:
            item (RigElementKey): The element key to return the metadata keys for
        
        Returns:
            Array[Name]:
        """
        ...
    def get_local_transform_by_index(self, element_index: int, initial: bool = False) -> Transform:
        r"""
        x.get_local_transform_by_index(element_index, initial=False) -> Transform
        Returns the local current or initial value for a element index.
        If the index is invalid FTransform::Identity will be returned.
        
        Args:
            element_index (int32): The index to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The local current or initial transform's value.
        """
        ...
    def get_local_transform(self, key: RigElementKey, initial: bool = False) -> Transform:
        r"""
        x.get_local_transform(key, initial=False) -> Transform
        Returns the local current or initial value for a given key.
        If the key is invalid FTransform::Identity will be returned.
        
        Args:
            key (RigElementKey): The key to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The local current or initial transform's value.
        """
        ...
    def get_local_index(self, key: RigElementKey) -> int:
        r"""
        x.get_local_index(key) -> int32
        Returns the index of an element given its key within its default parent (or root)
        
        Args:
            key (RigElementKey): The key of the element to retrieve the index for
        
        Returns:
            int32: The index of the element or INDEX_NONE
        """
        ...
    def get_local_control_shape_transform_by_index(self, element_index: int, initial: bool = False) -> Transform:
        r"""
        x.get_local_control_shape_transform_by_index(element_index, initial=False) -> Transform
        Returns the local shape transform for a given control element.
        
        Args:
            element_index (int32): The index of the control to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The local shape transform
        """
        ...
    def get_local_control_shape_transform(self, key: RigElementKey, initial: bool = False) -> Transform:
        r"""
        x.get_local_control_shape_transform(key, initial=False) -> Transform
        Returns the local shape transform for a given control element.
        
        Args:
            key (RigElementKey): The key of the control to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The local shape transform
        """
        ...
    def get_linear_color_metadata(self, item: RigElementKey, metadata_name: Name, default_value: LinearColor) -> LinearColor:
        r"""
        x.get_linear_color_metadata(item, metadata_name, default_value) -> LinearColor
        Queries and returns the value of FLinearColor metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
            default_value (LinearColor): The default value to fall back on
        
        Returns:
            LinearColor:
        """
        ...
    def get_linear_color_array_metadata(self, item: RigElementKey, metadata_name: Name) -> Array[LinearColor]:
        r"""
        x.get_linear_color_array_metadata(item, metadata_name) -> Array[LinearColor]
        Queries and returns the value of FLinearColor array metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
        
        Returns:
            Array[LinearColor]:
        """
        ...
    def get_keys(self, element_indices: Array[int]) -> Array[RigElementKey]:
        r"""
        x.get_keys(element_indices) -> Array[RigElementKey]
        Returns the keys of an array of indices
        
        Args:
            element_indices (Array[int32]): The indices to retrieve the keys for
        
        Returns:
            Array[RigElementKey]: The keys of the elements given the indices
        """
        ...
    def get_key(self, element_index: int) -> RigElementKey:
        r"""
        x.get_key(element_index) -> RigElementKey
        Returns the key of an element given its index
        
        Args:
            element_index (int32): The index of the element to retrieve the key for
        
        Returns:
            RigElementKey: The key of an element given its index
        """
        ...
    @classmethod
    def get_int_from_control_value(cls, value: RigControlValue) -> int:
        r"""
        X.get_int_from_control_value(value) -> int32
        Returns the contained int32 value from a a Rig Control Value
        
        Args:
            value (RigControlValue): The Rig Control value to convert from
        
        Returns:
            int32: The converted int32 value
        """
        ...
    def get_int32_metadata(self, item: RigElementKey, metadata_name: Name, default_value: int) -> int:
        r"""
        x.get_int32_metadata(item, metadata_name, default_value) -> int32
        Queries and returns the value of int32 metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
            default_value (int32): The default value to fall back on
        
        Returns:
            int32:
        """
        ...
    def get_int32_array_metadata(self, item: RigElementKey, metadata_name: Name) -> Array[int]:
        r"""
        x.get_int32_array_metadata(item, metadata_name) -> Array[int32]
        Queries and returns the value of int32 array metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
        
        Returns:
            Array[int32]:
        """
        ...
    def get_index(self, key: RigElementKey) -> int:
        r"""
        x.get_index(key) -> int32
        Returns the index of an element given its key
        
        Args:
            key (RigElementKey): The key of the element to retrieve the index for
        
        Returns:
            int32: The index of the element or INDEX_NONE
        """
        ...
    def get_global_transform_by_index(self, element_index: int, initial: bool = False) -> Transform:
        r"""
        x.get_global_transform_by_index(element_index, initial=False) -> Transform
        Returns the global current or initial value for a element index.
        If the index is invalid FTransform::Identity will be returned.
        
        Args:
            element_index (int32): The index to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The global current or initial transform's value.
        """
        ...
    def get_global_transform(self, key: RigElementKey, initial: bool = False) -> Transform:
        r"""
        x.get_global_transform(key, initial=False) -> Transform
        Returns the global current or initial value for a given key.
        If the key is invalid FTransform::Identity will be returned.
        
        Args:
            key (RigElementKey): The key to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The global current or initial transform's value.
        """
        ...
    def get_global_control_shape_transform_by_index(self, element_index: int, initial: bool = False) -> Transform:
        r"""
        x.get_global_control_shape_transform_by_index(element_index, initial=False) -> Transform
        Returns the global shape transform for a given control element.
        
        Args:
            element_index (int32): The index of the control to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The global shape transform
        """
        ...
    def get_global_control_shape_transform(self, key: RigElementKey, initial: bool = False) -> Transform:
        r"""
        x.get_global_control_shape_transform(key, initial=False) -> Transform
        Returns the global shape transform for a given control element.
        
        Args:
            key (RigElementKey): The key of the control to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The global shape transform
        """
        ...
    def get_global_control_offset_transform_by_index(self, element_index: int, initial: bool = False) -> Transform:
        r"""
        x.get_global_control_offset_transform_by_index(element_index, initial=False) -> Transform
        Returns the global offset transform for a given control element.
        
        Args:
            element_index (int32): The index of the control to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The global offset transform
        """
        ...
    def get_global_control_offset_transform(self, key: RigElementKey, initial: bool = False) -> Transform:
        r"""
        x.get_global_control_offset_transform(key, initial=False) -> Transform
        Returns the global offset transform for a given control element.
        
        Args:
            key (RigElementKey): The key of the control to retrieve the transform for
            initial (bool): If true the initial transform will be used
        
        Returns:
            Transform: The global offset transform
        """
        ...
    def get_float_metadata(self, item: RigElementKey, metadata_name: Name, default_value: float) -> float:
        r"""
        x.get_float_metadata(item, metadata_name, default_value) -> float
        Queries and returns the value of float metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
            default_value (float): The default value to fall back on
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_float_from_control_value(cls, value: RigControlValue) -> float:
        r"""
        X.get_float_from_control_value(value) -> float
        Returns the contained float value from a a Rig Control Value
        
        Args:
            value (RigControlValue): The Rig Control value to convert from
        
        Returns:
            float: The converted float value
        """
        ...
    def get_float_array_metadata(self, item: RigElementKey, metadata_name: Name) -> Array[float]:
        r"""
        x.get_float_array_metadata(item, metadata_name) -> Array[float]
        Queries and returns the value of float array metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
        
        Returns:
            Array[float]:
        """
        ...
    def get_first_parent(self, key: RigElementKey) -> RigElementKey:
        r"""
        x.get_first_parent(key) -> RigElementKey
        Returns the first parent element of a given element key
        
        Args:
            key (RigElementKey): The key of the element to retrieve the parents for
        
        Returns:
            RigElementKey: Returns the first parent element
        """
        ...
    @classmethod
    def get_euler_transform_from_control_value(cls, value: RigControlValue) -> EulerTransform:
        r"""
        X.get_euler_transform_from_control_value(value) -> EulerTransform
        Returns the contained FEulerTransform value from a a Rig Control Value
        
        Args:
            value (RigControlValue): The Rig Control value to convert from
        
        Returns:
            EulerTransform: The converted FEulerTransform value
        """
        ...
    def get_default_parent(self, key: RigElementKey) -> RigElementKey:
        r"""
        x.get_default_parent(key) -> RigElementKey
        Returns the default parent element's key of a given child key
        
        Args:
            key (RigElementKey): The key of the element to retrieve the parent for
        
        Returns:
            RigElementKey: Returns the default parent element key
        """
        ...
    def get_curve_value_by_index(self, element_index: int) -> float:
        r"""
        x.get_curve_value_by_index(element_index) -> float
        Returns a curve's value given its index
        
        Args:
            element_index (int32): The index of the element to retrieve the value for
        
        Returns:
            float: Returns the value of the curve
        """
        ...
    def get_curve_value(self, key: RigElementKey) -> float:
        r"""
        x.get_curve_value(key) -> float
        Returns a curve's value given its key
        
        Args:
            key (RigElementKey): The key of the element to retrieve the value for
        
        Returns:
            float: Returns the value of the curve
        """
        ...
    def get_curves(self) -> Array[RigElementKey]:
        r"""
        x.get_curves() -> Array[RigElementKey]
        Returns all Curve elements
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def get_control_value_by_index(self, element_index: int, value_type: RigControlValueType = RigControlValueType.CURRENT) -> RigControlValue:
        r"""
        x.get_control_value_by_index(element_index, value_type=RigControlValueType.CURRENT) -> RigControlValue
        Returns a control's current value given its index
        
        Args:
            element_index (int32): The index of the element to retrieve the current value for
            value_type (RigControlValueType): The type of value to return
        
        Returns:
            RigControlValue: Returns the current value of the control
        """
        ...
    def get_control_value(self, key: RigElementKey, value_type: RigControlValueType = RigControlValueType.CURRENT) -> RigControlValue:
        r"""
        x.get_control_value(key, value_type=RigControlValueType.CURRENT) -> RigControlValue
        Returns a control's current value given its key
        
        Args:
            key (RigElementKey): The key of the element to retrieve the current value for
            value_type (RigControlValueType): The type of value to return
        
        Returns:
            RigControlValue: Returns the current value of the control
        """
        ...
    def get_control_preferred_rotator_by_index(self, element_index: int, initial: bool = False) -> Rotator:
        r"""
        x.get_control_preferred_rotator_by_index(element_index, initial=False) -> Rotator
        Returns a control's preferred rotator (local transform rotation)
        
        Args:
            element_index (int32): The element index to look up
            initial (bool): If true we'll return the preferred rotator for the initial - otherwise current transform
        
        Returns:
            Rotator: Returns the current preferred rotator
        """
        ...
    def get_control_preferred_rotator(self, key: RigElementKey, initial: bool = False) -> Rotator:
        r"""
        x.get_control_preferred_rotator(key, initial=False) -> Rotator
        Returns a control's preferred rotator (local transform rotation)
        
        Args:
            key (RigElementKey): The key of the element to retrieve the current value for
            initial (bool): If true we'll return the preferred rotator for the initial - otherwise current transform
        
        Returns:
            Rotator: Returns the current preferred rotator
        """
        ...
    def get_control_preferred_euler_rotation_order_by_index(self, element_index: int, from_settings: bool = True) -> EulerRotationOrder:
        r"""
        x.get_control_preferred_euler_rotation_order_by_index(element_index, from_settings=True) -> EulerRotationOrder
        Returns a control's preferred euler rotation order
        
        Args:
            element_index (int32): The element index to look up
            from_settings (bool): If true the rotation order will be looked up from the control's settings, otherwise from the currently set animation value
        
        Returns:
            EulerRotationOrder: Returns the current preferred euler rotation order
        """
        ...
    def get_control_preferred_euler_rotation_order(self, key: RigElementKey, from_settings: bool = True) -> EulerRotationOrder:
        r"""
        x.get_control_preferred_euler_rotation_order(key, from_settings=True) -> EulerRotationOrder
        Returns a control's preferred euler rotation order
        
        Args:
            key (RigElementKey): The key of the element to retrieve the current value for
            from_settings (bool): If true the rotation order will be looked up from the control's settings, otherwise from the currently set animation value
        
        Returns:
            EulerRotationOrder: Returns the current preferred euler rotation order
        """
        ...
    def get_control_preferred_euler_angles_by_index(self, element_index: int, rotation_order: EulerRotationOrder, initial: bool = False) -> Vector:
        r"""
        x.get_control_preferred_euler_angles_by_index(element_index, rotation_order, initial=False) -> Vector
        Returns a control's preferred euler angles (local transform rotation)
        
        Args:
            element_index (int32): The element index to look up
            rotation_order (EulerRotationOrder): The rotation order to use when retrieving the euler angles
            initial (bool): If true we'll return the preferred euler angles for the initial - otherwise current transform
        
        Returns:
            Vector: Returns the current preferred euler angles
        """
        ...
    def get_control_preferred_euler_angles(self, key: RigElementKey, rotation_order: EulerRotationOrder, initial: bool = False) -> Vector:
        r"""
        x.get_control_preferred_euler_angles(key, rotation_order, initial=False) -> Vector
        Returns a control's preferred euler angles (local transform rotation)
        
        Args:
            key (RigElementKey): The key of the element to retrieve the current value for
            rotation_order (EulerRotationOrder): The rotation order to use when retrieving the euler angles
            initial (bool): If true we'll return the preferred euler angles for the initial - otherwise current transform
        
        Returns:
            Vector: Returns the current preferred euler angles
        """
        ...
    def get_controller(self, create_if_needed: bool = True) -> RigHierarchyController:
        r"""
        x.get_controller(create_if_needed=True) -> RigHierarchyController
        Returns a controller for this hierarchy.
        Note: If the controller is not available this will return nullptr
        even if the bCreateIfNeeded flag is set to true. You can check the
        controller's availability with IsControllerAvailable().
        
        Args:
            create_if_needed (bool): Creates a controller if needed
        
        Returns:
            RigHierarchyController: The Controller for this hierarchy
        """
        ...
    def get_controls(self, traverse: bool = True) -> Array[RigElementKey]:
        r"""
        x.get_controls(traverse=True) -> Array[RigElementKey]
        Returns all Control elements
        
        Args:
            traverse (bool): Returns the elements in order of a depth first traversal
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def get_connector_states(self) -> Array[RigConnectorState]:
        r"""
        x.get_connector_states() -> Array[RigConnectorState]
        Returns all of the connectors' state
        
        Returns:
            Array[RigConnectorState]:
        """
        ...
    def get_connectors(self, traverse: bool = True) -> Array[RigElementKey]:
        r"""
        x.get_connectors(traverse=True) -> Array[RigElementKey]
        Returns all Connector elements
        
        Args:
            traverse (bool): Returns the elements in order of a depth first traversal
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def get_children(self, key: RigElementKey, recursive: bool = False) -> Array[RigElementKey]:
        r"""
        x.get_children(key, recursive=False) -> Array[RigElementKey]
        Returns the child elements of a given element key
        
        Args:
            key (RigElementKey): The key of the element to retrieve the children for
            recursive (bool): If set to true grand-children will also be returned etc
        
        Returns:
            Array[RigElementKey]: Returns the child elements
        """
        ...
    def get_bool_metadata(self, item: RigElementKey, metadata_name: Name, default_value: bool) -> bool:
        r"""
        x.get_bool_metadata(item, metadata_name, default_value) -> bool
        Queries and returns the value of bool metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
            default_value (bool): The default value to fall back on
        
        Returns:
            bool:
        """
        ...
    def get_bool_array_metadata(self, item: RigElementKey, metadata_name: Name) -> Array[bool]:
        r"""
        x.get_bool_array_metadata(item, metadata_name) -> Array[bool]
        Queries and returns the value of bool array metadata
        
        Args:
            item (RigElementKey): The element key to return the metadata for
            metadata_name (Name): The name of the metadata to query
        
        Returns:
            Array[bool]:
        """
        ...
    def get_bones(self, traverse: bool = True) -> Array[RigElementKey]:
        r"""
        x.get_bones(traverse=True) -> Array[RigElementKey]
        Returns all Bone elements
        
        Args:
            traverse (bool): Returns the elements in order of a depth first traversal
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def get_all_keys(self, traverse: bool = True) -> Array[RigElementKey]:
        r"""
        x.get_all_keys(traverse=True) -> Array[RigElementKey]
        Returns all element keys of this hierarchy
        
        Args:
            traverse (bool): If set to true the keys will be returned by depth first traversal
        
        Returns:
            Array[RigElementKey]: The keys of all elements
        """
        ...
    def find_null(self, key: RigElementKey) -> RigNullElement:
        r"""
        x.find_null(key) -> RigNullElement
        Returns null element for a given key, for scripting purpose only, for cpp usage, use Find<FRigControlElement>()
        
        Args:
            key (RigElementKey): The key of the null element to retrieve.
        
        Returns:
            RigNullElement:
        """
        ...
    def find_control(self, key: RigElementKey) -> RigControlElement:
        r"""
        x.find_control(key) -> RigControlElement
        Returns control element for a given key, for scripting purpose only, for cpp usage, use Find<FRigControlElement>()
        
        Args:
            key (RigElementKey): The key of the control element to retrieve.
        
        Returns:
            RigControlElement:
        """
        ...
    def find_bone(self, key: RigElementKey) -> RigBoneElement:
        r"""
        x.find_bone(key) -> RigBoneElement
        Returns bone element for a given key, for scripting purpose only, for cpp usage, use Find<FRigBoneElement>()
        
        Args:
            key (RigElementKey): The key of the bone element to retrieve.
        
        Returns:
            RigBoneElement:
        """
        ...
    def copy_pose(self, hierarchy: RigHierarchy, current: bool, initial: bool, weights: bool, match_pose_in_global_if_needed: bool = False) -> None:
        r"""
        x.copy_pose(hierarchy, current, initial, weights, match_pose_in_global_if_needed=False) -> None
        Copies the contents of a hierarchy onto this one
        
        Args:
            hierarchy (RigHierarchy): 
            current (bool): 
            initial (bool): 
            weights (bool): 
            match_pose_in_global_if_needed (bool):
        """
        ...
    def copy_hierarchy(self, hierarchy: RigHierarchy) -> None:
        r"""
        x.copy_hierarchy(hierarchy) -> None
        Copies the contents of a hierarchy onto this one
        
        Args:
            hierarchy (RigHierarchy):
        """
        ...
    def contains(self, key: RigElementKey) -> bool:
        r"""
        x.contains(key) -> bool
        Returns true if the provided element key is valid
        
        Args:
            key (RigElementKey): The key to validate
        
        Returns:
            bool: Returns true if the provided element key is valid
        """
        ...

class AnimNodeControlRigLibrary(BlueprintFunctionLibrary):
    r"""
    Exposes operations to be performed on a control rig anim node
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: AnimNode_ControlRig_Library.h
    
    """
    @classmethod
    def set_control_rig_class(cls, node: ControlRigReference, control_rig_class: Class) -> ControlRigReference:
        r"""
        X.set_control_rig_class(node, control_rig_class) -> ControlRigReference
        Set the control rig class on the node
        
        Args:
            node (ControlRigReference): 
            control_rig_class (type(Class)): 
        
        Returns:
            ControlRigReference:
        """
        ...
    @classmethod
    def convert_to_control_rig_pure(cls, node: AnimNodeReference) -> Tuple[ControlRigReference, bool]:
        r"""
        X.convert_to_control_rig_pure(node) -> (control_rig=ControlRigReference, result=bool)
        Get a control rig context from an anim node context (pure)
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            tuple: 
        
            control_rig (ControlRigReference): 
        
            result (bool):
        """
        ...
    @classmethod
    def convert_to_control_rig(cls, node: AnimNodeReference) -> Tuple[ControlRigReference, AnimNodeReferenceConversionResult]:
        r"""
        X.convert_to_control_rig(node) -> (ControlRigReference, result=AnimNodeReferenceConversionResult)
        Get a control rig context from an anim node context
        
        Args:
            node (AnimNodeReference): 
        
        Returns:
            AnimNodeReferenceConversionResult: 
        
            result (AnimNodeReferenceConversionResult):
        """
        ...

class TransformableControlHandle(TransformableHandle):
    r"""
    UTransformableControlHandle
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigTransformableHandle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``constraint_binding_id`` (MovieSceneObjectBindingID):  [Read-Write] possible bindingID
    - ``control_name`` (Name):  [Read-Write] The ControlName of the control that this handle is pointing at.
    - ``control_rig`` (ControlRig):  [Read-Write] The ControlRig that this handle is pointing at.
    """
    @property
    def control_rig(self) -> ControlRig:
        r"""
        (ControlRig):  [Read-Only] The ControlRig that this handle is pointing at.
        """
        ...
    @property
    def control_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The ControlName of the control that this handle is pointing at.
        """
        ...

class ControlRigAnimInstance(AnimInstance):
    r"""
    Control Rig Anim Instance
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigAnimInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    ...

class ControlRigComponent(PrimitiveComponent):
    r"""
    A component that hosts an animation ControlRig, manages control components and marshals data between the two
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``control_rig_class`` (type(Class)):  [Read-Write] The class of control rig to instantiate
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``draw_bones`` (bool):  [Read-Write] When checked the rig's bones are drawn using debug drawing similar to the animation editor viewport
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_lazy_evaluation`` (bool):  [Read-Write] When checked the rig will only run if any of the mapped inputs has changed
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``lazy_evaluation_position_threshold`` (float):  [Read-Write] The delta threshold for a translation / position difference. 0.0 disables position differences.
    - ``lazy_evaluation_rotation_threshold`` (float):  [Read-Write] The delta threshold for a rotation difference (in degrees). 0.0 disables rotation differences.
    - ``lazy_evaluation_scale_threshold`` (float):  [Read-Write] The delta threshold for a scale difference. 0.0 disables scale differences.
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``mapped_elements`` (Array[ControlRigComponentMappedElement]):  [Read-Only]
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_post_construction_delegate`` (ControlRigComponentDelegate):  [Read-Write] Event fired after this component's ControlRig is setup
    - ``on_post_forwards_solve_delegate`` (ControlRigComponentDelegate):  [Read-Write] Event fired after this component's ControlRig's forwards solve
    - ``on_post_initialize_delegate`` (ControlRigComponentDelegate):  [Read-Write] Event fired after this component's ControlRig is initialized
    - ``on_pre_construction_delegate`` (ControlRigComponentDelegate):  [Read-Write] Event fired before this component's ControlRig is setup
    - ``on_pre_forwards_solve_delegate`` (ControlRigComponentDelegate):  [Read-Write] Event fired before this component's ControlRig's forwards solve
    - ``on_pre_initialize_delegate`` (ControlRigComponentDelegate):  [Read-Write] Event fired just before this component's ControlRig is initialized
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``reset_initials_before_construction`` (bool):  [Read-Write] When checked the initial transforms on bones, nulls and controls are reset prior to a construction event
    - ``reset_transform_before_tick`` (bool):  [Read-Write] When checked the transforms are reset before a tick / update of the rig
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``show_debug_drawing`` (bool):  [Read-Write] When checked the rig's debug drawing instructions are drawn in the viewport
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``update_in_editor`` (bool):  [Read-Write] When checked the rig is run in the editor viewport without running / simulation the game
    - ``update_rig_on_tick`` (bool):  [Read-Write] When checked this ensures to run the rig's update on the component's tick automatically
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``user_defined_elements`` (Array[ControlRigComponentMappedElement]):  [Read-Write]
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def control_rig_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] The class of control rig to instantiate
        """
        ...
    @control_rig_class.setter
    def control_rig_class(self, value: Class) -> None:
        ...
    @property
    def on_pre_initialize_delegate(self) -> ControlRigComponentDelegate:
        r"""
        (ControlRigComponentDelegate):  [Read-Write] Event fired just before this component's ControlRig is initialized
        """
        ...
    @on_pre_initialize_delegate.setter
    def on_pre_initialize_delegate(self, value: ControlRigComponentDelegate) -> None:
        ...
    @property
    def on_post_initialize_delegate(self) -> ControlRigComponentDelegate:
        r"""
        (ControlRigComponentDelegate):  [Read-Write] Event fired after this component's ControlRig is initialized
        """
        ...
    @on_post_initialize_delegate.setter
    def on_post_initialize_delegate(self, value: ControlRigComponentDelegate) -> None:
        ...
    @property
    def on_pre_construction_delegate(self) -> ControlRigComponentDelegate:
        r"""
        (ControlRigComponentDelegate):  [Read-Write] Event fired before this component's ControlRig is setup
        """
        ...
    @on_pre_construction_delegate.setter
    def on_pre_construction_delegate(self, value: ControlRigComponentDelegate) -> None:
        ...
    @property
    def on_pre_setup_delegate(self) -> ControlRigComponentDelegate:
        r"""
        deprecated: 'on_pre_setup_delegate' was renamed to 'on_pre_construction_delegate'.
        """
        ...
    @on_pre_setup_delegate.setter
    def on_pre_setup_delegate(self, value: ControlRigComponentDelegate) -> None:
        ...
    @property
    def on_post_construction_delegate(self) -> ControlRigComponentDelegate:
        r"""
        (ControlRigComponentDelegate):  [Read-Write] Event fired after this component's ControlRig is setup
        """
        ...
    @on_post_construction_delegate.setter
    def on_post_construction_delegate(self, value: ControlRigComponentDelegate) -> None:
        ...
    @property
    def on_post_setup_delegate(self) -> ControlRigComponentDelegate:
        r"""
        deprecated: 'on_post_setup_delegate' was renamed to 'on_post_construction_delegate'.
        """
        ...
    @on_post_setup_delegate.setter
    def on_post_setup_delegate(self, value: ControlRigComponentDelegate) -> None:
        ...
    @property
    def on_pre_forwards_solve_delegate(self) -> ControlRigComponentDelegate:
        r"""
        (ControlRigComponentDelegate):  [Read-Write] Event fired before this component's ControlRig's forwards solve
        """
        ...
    @on_pre_forwards_solve_delegate.setter
    def on_pre_forwards_solve_delegate(self, value: ControlRigComponentDelegate) -> None:
        ...
    @property
    def on_pre_update_delegate(self) -> ControlRigComponentDelegate:
        r"""
        deprecated: 'on_pre_update_delegate' was renamed to 'on_pre_forwards_solve_delegate'.
        """
        ...
    @on_pre_update_delegate.setter
    def on_pre_update_delegate(self, value: ControlRigComponentDelegate) -> None:
        ...
    @property
    def on_post_forwards_solve_delegate(self) -> ControlRigComponentDelegate:
        r"""
        (ControlRigComponentDelegate):  [Read-Write] Event fired after this component's ControlRig's forwards solve
        """
        ...
    @on_post_forwards_solve_delegate.setter
    def on_post_forwards_solve_delegate(self, value: ControlRigComponentDelegate) -> None:
        ...
    @property
    def on_post_update_delegate(self) -> ControlRigComponentDelegate:
        r"""
        deprecated: 'on_post_update_delegate' was renamed to 'on_post_forwards_solve_delegate'.
        """
        ...
    @on_post_update_delegate.setter
    def on_post_update_delegate(self, value: ControlRigComponentDelegate) -> None:
        ...
    def update(self, delta_time: float = 0.000000) -> None:
        r"""
        x.update(delta_time=0.000000) -> None
        Updates and ticks the rig.
        
        Args:
            delta_time (float):
        """
        ...
    def set_object_binding(self, object_to_bind: Object) -> None:
        r"""
        x.set_object_binding(object_to_bind) -> None
        Set Object Binding
        
        Args:
            object_to_bind (Object):
        """
        ...
    def set_mapped_elements(self, new_mapped_elements: Array[ControlRigComponentMappedElement]) -> None:
        r"""
        x.set_mapped_elements(new_mapped_elements) -> None
        Replaces the mapped elements on the component with the provided array, should not be used before OnPreInitialize Event
        
        Args:
            new_mapped_elements (Array[ControlRigComponentMappedElement]):
        """
        ...
    def set_initial_space_transform(self, space_name: Name, initial_transform: Transform, space: ControlRigComponentSpace = ControlRigComponentSpace.RIG_SPACE) -> None:
        r"""
        x.set_initial_space_transform(space_name, initial_transform, space=ControlRigComponentSpace.RIG_SPACE) -> None
        Sets the transform of the space in the requested space
        
        Args:
            space_name (Name): The name of the space to set the transform for
            initial_transform (Transform): 
            space (ControlRigComponentSpace): The space to set the transform in
        """
        ...
    def set_initial_bone_transform(self, bone_name: Name, initial_transform: Transform, space: ControlRigComponentSpace = ControlRigComponentSpace.RIG_SPACE, propagate_to_children: bool = False) -> None:
        r"""
        x.set_initial_bone_transform(bone_name, initial_transform, space=ControlRigComponentSpace.RIG_SPACE, propagate_to_children=False) -> None
        Sets the initial transform of the bone in the requested space
        
        Args:
            bone_name (Name): The name of the bone to set the transform for
            initial_transform (Transform): The initial transform to set for the bone
            space (ControlRigComponentSpace): The space to set the transform in
            propagate_to_children (bool): If true the child bones will be moved together with the affected bone
        """
        ...
    def set_control_vector2d(self, control_name: Name, value: Vector2D) -> None:
        r"""
        x.set_control_vector2d(control_name, value) -> None
        Sets the value of a vector2D control
        
        Args:
            control_name (Name): The name of the control to set
            value (Vector2D): The new value for the control
        """
        ...
    def set_control_transform(self, control_name: Name, value: Transform, space: ControlRigComponentSpace = ControlRigComponentSpace.RIG_SPACE) -> None:
        r"""
        x.set_control_transform(control_name, value, space=ControlRigComponentSpace.RIG_SPACE) -> None
        Sets the value of a transform control
        
        Args:
            control_name (Name): The name of the control to set
            value (Transform): The new value for the control
            space (ControlRigComponentSpace): The space to set the value in
        """
        ...
    def set_control_scale(self, control_name: Name, value: Vector, space: ControlRigComponentSpace = ControlRigComponentSpace.LOCAL_SPACE) -> None:
        r"""
        x.set_control_scale(control_name, value, space=ControlRigComponentSpace.LOCAL_SPACE) -> None
        Sets the value of a scale control
        
        Args:
            control_name (Name): The name of the control to set
            value (Vector): The new value for the control
            space (ControlRigComponentSpace): The space to set the value in
        """
        ...
    def set_control_rotator(self, control_name: Name, value: Rotator, space: ControlRigComponentSpace = ControlRigComponentSpace.LOCAL_SPACE) -> None:
        r"""
        x.set_control_rotator(control_name, value, space=ControlRigComponentSpace.LOCAL_SPACE) -> None
        Sets the value of a rotator control
        
        Args:
            control_name (Name): The name of the control to set
            value (Rotator): The new value for the control
            space (ControlRigComponentSpace): The space to set the value in
        """
        ...
    def set_control_rig_class(self, control_rig_class: Class) -> None:
        r"""
        x.set_control_rig_class(control_rig_class) -> None
        Set Control Rig Class
        
        Args:
            control_rig_class (type(Class)):
        """
        ...
    def set_control_position(self, control_name: Name, value: Vector, space: ControlRigComponentSpace = ControlRigComponentSpace.LOCAL_SPACE) -> None:
        r"""
        x.set_control_position(control_name, value, space=ControlRigComponentSpace.LOCAL_SPACE) -> None
        Sets the value of a position control
        
        Args:
            control_name (Name): The name of the control to set
            value (Vector): The new value for the control
            space (ControlRigComponentSpace): The space to set the value in
        """
        ...
    def set_control_offset(self, control_name: Name, offset_transform: Transform, space: ControlRigComponentSpace = ControlRigComponentSpace.RIG_SPACE) -> None:
        r"""
        x.set_control_offset(control_name, offset_transform, space=ControlRigComponentSpace.RIG_SPACE) -> None
        Sets the offset transform of a control
        
        Args:
            control_name (Name): The name of the control to set
            offset_transform (Transform): The new offset trasnform for the control
            space (ControlRigComponentSpace): The space to set the offset transform in
        """
        ...
    def set_control_int(self, control_name: Name, value: int) -> None:
        r"""
        x.set_control_int(control_name, value) -> None
        Sets the value of an integer control
        
        Args:
            control_name (Name): The name of the control to set
            value (int32): The new value for the control
        """
        ...
    def set_control_float(self, control_name: Name, value: float) -> None:
        r"""
        x.set_control_float(control_name, value) -> None
        Sets the value of a float control
        
        Args:
            control_name (Name): The name of the control to set
            value (float): The new value for the control
        """
        ...
    def set_control_bool(self, control_name: Name, value: bool) -> None:
        r"""
        x.set_control_bool(control_name, value) -> None
        Sets the value of a bool control
        
        Args:
            control_name (Name): The name of the control to set
            value (bool): The new value for the control
        """
        ...
    def set_bone_transform(self, bone_name: Name, transform: Transform, space: ControlRigComponentSpace = ControlRigComponentSpace.RIG_SPACE, weight: float = 1.000000, propagate_to_children: bool = True) -> None:
        r"""
        x.set_bone_transform(bone_name, transform, space=ControlRigComponentSpace.RIG_SPACE, weight=1.000000, propagate_to_children=True) -> None
        Sets the transform of the bone in the requested space
        
        Args:
            bone_name (Name): The name of the bone to set the transform for
            transform (Transform): 
            space (ControlRigComponentSpace): The space to set the transform in
            weight (float): The weight of how much the change should be applied (0.0 to 1.0)
            propagate_to_children (bool): If true the child bones will be moved together with the affected bone
        """
        ...
    def set_bone_initial_transforms_from_skeletal_mesh(self, skeletal_mesh: SkeletalMesh) -> None:
        r"""
        x.set_bone_initial_transforms_from_skeletal_mesh(skeletal_mesh) -> None
        Setup the initial transforms / ref pose of the bones based on a skeletal mesh
        
        Args:
            skeletal_mesh (SkeletalMesh):
        """
        ...
    def on_pre_initialize(self, component: ControlRigComponent) -> None:
        r"""
        x.on_pre_initialize(component) -> None
        On Pre Initialize
        
        Args:
            component (ControlRigComponent):
        """
        ...
    def on_pre_forwards_solve(self, component: ControlRigComponent) -> None:
        r"""
        x.on_pre_forwards_solve(component) -> None
        On Pre Forwards Solve
        
        Args:
            component (ControlRigComponent):
        """
        ...
    def on_pre_construction(self, component: ControlRigComponent) -> None:
        r"""
        x.on_pre_construction(component) -> None
        On Pre Construction
        
        Args:
            component (ControlRigComponent):
        """
        ...
    def on_post_initialize(self, component: ControlRigComponent) -> None:
        r"""
        x.on_post_initialize(component) -> None
        On Post Initialize
        
        Args:
            component (ControlRigComponent):
        """
        ...
    def on_post_forwards_solve(self, component: ControlRigComponent) -> None:
        r"""
        x.on_post_forwards_solve(component) -> None
        On Post Forwards Solve
        
        Args:
            component (ControlRigComponent):
        """
        ...
    def on_post_construction(self, component: ControlRigComponent) -> None:
        r"""
        x.on_post_construction(component) -> None
        On Post Construction
        
        Args:
            component (ControlRigComponent):
        """
        ...
    def initialize(self) -> None:
        r"""
        x.initialize() -> None
        Initializes the rig's memory and calls the construction event
        """
        ...
    def get_space_transform(self, space_name: Name, space: ControlRigComponentSpace = ControlRigComponentSpace.RIG_SPACE) -> Transform:
        r"""
        x.get_space_transform(space_name, space=ControlRigComponentSpace.RIG_SPACE) -> Transform
        Returns the transform of the space in the requested space
        
        Args:
            space_name (Name): The name of the space to retrieve the transform for
            space (ControlRigComponentSpace): The space to retrieve the transform in
        
        Returns:
            Transform: the transform of the space in the requested space
        """
        ...
    def get_initial_space_transform(self, space_name: Name, space: ControlRigComponentSpace = ControlRigComponentSpace.RIG_SPACE) -> Transform:
        r"""
        x.get_initial_space_transform(space_name, space=ControlRigComponentSpace.RIG_SPACE) -> Transform
        Returns the initial transform of the space in the requested space
        
        Args:
            space_name (Name): The name of the space to retrieve the transform for
            space (ControlRigComponentSpace): The space to retrieve the transform in
        
        Returns:
            Transform: the initial transform of the space in the requested space
        """
        ...
    def get_initial_bone_transform(self, bone_name: Name, space: ControlRigComponentSpace = ControlRigComponentSpace.RIG_SPACE) -> Transform:
        r"""
        x.get_initial_bone_transform(bone_name, space=ControlRigComponentSpace.RIG_SPACE) -> Transform
        Returns the initial transform of the bone in the requested space
        
        Args:
            bone_name (Name): The name of the bone to retrieve the transform for
            space (ControlRigComponentSpace): The space to retrieve the transform in
        
        Returns:
            Transform: the initial transform of the bone in the requested space
        """
        ...
    def get_element_names(self, element_type: RigElementType = RigElementType.BONE) -> Array[Name]:
        r"""
        x.get_element_names(element_type=RigElementType.BONE) -> Array[Name]
        Returns all of the names for a given element type (Bone, Control, etc)
        
        Args:
            element_type (RigElementType): The type of elements to return the names for
        
        Returns:
            Array[Name]: all of the names for a given element type (Bone, Control, etc)
        """
        ...
    def get_control_vector2d(self, control_name: Name) -> Vector2D:
        r"""
        x.get_control_vector2d(control_name) -> Vector2D
        Returns the value of a Vector3D control
        
        Args:
            control_name (Name): The name of the control to retrieve the value for
        
        Returns:
            Vector2D: The Vector3D value of the control
        """
        ...
    def get_control_transform(self, control_name: Name, space: ControlRigComponentSpace = ControlRigComponentSpace.RIG_SPACE) -> Transform:
        r"""
        x.get_control_transform(control_name, space=ControlRigComponentSpace.RIG_SPACE) -> Transform
        Returns the value of a transform control
        
        Args:
            control_name (Name): The name of the control to retrieve the value for
            space (ControlRigComponentSpace): The space to retrieve the control's value in
        
        Returns:
            Transform: The transform value of the control
        """
        ...
    def get_control_scale(self, control_name: Name, space: ControlRigComponentSpace = ControlRigComponentSpace.LOCAL_SPACE) -> Vector:
        r"""
        x.get_control_scale(control_name, space=ControlRigComponentSpace.LOCAL_SPACE) -> Vector
        Returns the value of a scale control
        
        Args:
            control_name (Name): The name of the control to retrieve the value for
            space (ControlRigComponentSpace): The space to retrieve the control's value in
        
        Returns:
            Vector: The scale value of the control
        """
        ...
    def get_control_rotator(self, control_name: Name, space: ControlRigComponentSpace = ControlRigComponentSpace.LOCAL_SPACE) -> Rotator:
        r"""
        x.get_control_rotator(control_name, space=ControlRigComponentSpace.LOCAL_SPACE) -> Rotator
        Returns the value of a rotator control
        
        Args:
            control_name (Name): The name of the control to retrieve the value for
            space (ControlRigComponentSpace): The space to retrieve the control's value in
        
        Returns:
            Rotator: The rotator value of the control
        """
        ...
    def get_control_rig(self) -> ControlRig:
        r"""
        x.get_control_rig() -> ControlRig
        Get the ControlRig hosted by this component
        
        Returns:
            ControlRig:
        """
        ...
    def get_control_position(self, control_name: Name, space: ControlRigComponentSpace = ControlRigComponentSpace.LOCAL_SPACE) -> Vector:
        r"""
        x.get_control_position(control_name, space=ControlRigComponentSpace.LOCAL_SPACE) -> Vector
        Returns the value of a position control
        
        Args:
            control_name (Name): The name of the control to retrieve the value for
            space (ControlRigComponentSpace): The space to retrieve the control's value in
        
        Returns:
            Vector: The position value of the control
        """
        ...
    def get_control_offset(self, control_name: Name, space: ControlRigComponentSpace = ControlRigComponentSpace.RIG_SPACE) -> Transform:
        r"""
        x.get_control_offset(control_name, space=ControlRigComponentSpace.RIG_SPACE) -> Transform
        Returns the offset transform of a control
        
        Args:
            control_name (Name): The name of the control to retrieve the offset transform for
            space (ControlRigComponentSpace): The space to retrieve the offset transform in
        
        Returns:
            Transform: The offset transform of a control
        """
        ...
    def get_control_int(self, control_name: Name) -> int:
        r"""
        x.get_control_int(control_name) -> int32
        Returns the value of an integer control
        
        Args:
            control_name (Name): The name of the control to retrieve the value for
        
        Returns:
            int32: The int32 value of the control
        """
        ...
    def get_control_float(self, control_name: Name) -> float:
        r"""
        x.get_control_float(control_name) -> float
        Returns the value of a float control
        
        Args:
            control_name (Name): The name of the control to retrieve the value for
        
        Returns:
            float: The float value of the control
        """
        ...
    def get_control_bool(self, control_name: Name) -> bool:
        r"""
        x.get_control_bool(control_name) -> bool
        Returns the value of a bool control
        
        Args:
            control_name (Name): The name of the control to retrieve the value for
        
        Returns:
            bool: The bool value of the control
        """
        ...
    def get_bone_transform(self, bone_name: Name, space: ControlRigComponentSpace = ControlRigComponentSpace.RIG_SPACE) -> Transform:
        r"""
        x.get_bone_transform(bone_name, space=ControlRigComponentSpace.RIG_SPACE) -> Transform
        Returns the transform of the bone in the requested space
        
        Args:
            bone_name (Name): The name of the bone to retrieve the transform for
            space (ControlRigComponentSpace): The space to retrieve the transform in
        
        Returns:
            Transform: the transform of the bone in the requested space
        """
        ...
    def get_absolute_time(self) -> float:
        r"""
        x.get_absolute_time() -> float
        Get the ControlRig's local time in seconds since its last initialize
        
        Returns:
            float:
        """
        ...
    def does_element_exist(self, name: Name, element_type: RigElementType = RigElementType.BONE) -> bool:
        r"""
        x.does_element_exist(name, element_type=RigElementType.BONE) -> bool
        Returns true if an element given a type and name exists in the rig
        
        Args:
            name (Name): The name for the element to look up
            element_type (RigElementType): The type of element to look up
        
        Returns:
            bool: true if the element exists
        """
        ...
    def clear_mapped_elements(self) -> None:
        r"""
        x.clear_mapped_elements() -> None
        Removes all mapped elements from the component
        """
        ...
    def can_execute(self) -> bool:
        r"""
        x.can_execute() -> bool
        Returns true if the Component can execute its Control Rig
        
        Returns:
            bool:
        """
        ...
    def add_mapped_skeletal_mesh(self, skeletal_mesh_component: SkeletalMeshComponent, bones: Array[ControlRigComponentMappedBone], curves: Array[ControlRigComponentMappedCurve], direction: ControlRigComponentMapDirection = ControlRigComponentMapDirection.OUTPUT) -> None:
        r"""
        x.add_mapped_skeletal_mesh(skeletal_mesh_component, bones, curves, direction=ControlRigComponentMapDirection.OUTPUT) -> None
        Adds a series of mapped bones to the rig, should not be used before OnPreInitialize Event
        
        Args:
            skeletal_mesh_component (SkeletalMeshComponent): 
            bones (Array[ControlRigComponentMappedBone]): 
            curves (Array[ControlRigComponentMappedCurve]): 
            direction (ControlRigComponentMapDirection):
        """
        ...
    def add_mapped_elements(self, new_mapped_elements: Array[ControlRigComponentMappedElement]) -> None:
        r"""
        x.add_mapped_elements(new_mapped_elements) -> None
        Adds the provided mapped elements to the component, should not be used before OnPreInitialize Event
        
        Args:
            new_mapped_elements (Array[ControlRigComponentMappedElement]):
        """
        ...
    def add_mapped_components(self, components: Array[ControlRigComponentMappedComponent]) -> None:
        r"""
        x.add_mapped_components(components) -> None
        Adds a series of mapped bones to the rig, should not be used before OnPreInitialize Event
        
        Args:
            components (Array[ControlRigComponentMappedComponent]):
        """
        ...
    def add_mapped_complete_skeletal_mesh(self, skeletal_mesh_component: SkeletalMeshComponent, direction: ControlRigComponentMapDirection = ControlRigComponentMapDirection.OUTPUT) -> None:
        r"""
        x.add_mapped_complete_skeletal_mesh(skeletal_mesh_component, direction=ControlRigComponentMapDirection.OUTPUT) -> None
        Adds all matching bones to the rig, should not be used before OnPreInitialize Event
        
        Args:
            skeletal_mesh_component (SkeletalMeshComponent): 
            direction (ControlRigComponentMapDirection):
        """
        ...

class ControlRigControlActor(Actor):
    r"""
    Control Rig Control Actor
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigControlActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``actor_to_track`` (Actor):  [Read-Write]
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``cast_shadows`` (bool):  [Read-Write]
    - ``color_parameter`` (str):  [Read-Write]
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``control_rig_class`` (type(Class)):  [Read-Write]
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_selectable`` (bool):  [Read-Write]
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``material_override`` (MaterialInterface):  [Read-Write]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``refresh_on_tick`` (bool):  [Read-Write]
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def actor_to_track(self) -> Actor:
        r"""
        (Actor):  [Read-Write]
        """
        ...
    @actor_to_track.setter
    def actor_to_track(self, value: Actor) -> None:
        ...
    @property
    def control_rig_class(self) -> Class:
        r"""
        (type(Class)):  [Read-Write]
        """
        ...
    @control_rig_class.setter
    def control_rig_class(self, value: Class) -> None:
        ...
    @property
    def refresh_on_tick(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @refresh_on_tick.setter
    def refresh_on_tick(self, value: bool) -> None:
        ...
    @property
    def is_selectable(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @is_selectable.setter
    def is_selectable(self, value: bool) -> None:
        ...
    @property
    def material_override(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Write]
        """
        ...
    @material_override.setter
    def material_override(self, value: MaterialInterface) -> None:
        ...
    @property
    def color_parameter(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @color_parameter.setter
    def color_parameter(self, value: str) -> None:
        ...
    @property
    def cast_shadows(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @cast_shadows.setter
    def cast_shadows(self, value: bool) -> None:
        ...
    def reset_control_actor(self) -> None:
        r"""
        x.reset_control_actor() -> None
        Reset Control Actor
        """
        ...
    def refresh(self) -> None:
        r"""
        x.refresh() -> None
        Refresh
        """
        ...
    def clear(self) -> None:
        r"""
        x.clear() -> None
        Clear
        """
        ...

class ControlRigShapeActor(Actor):
    r"""
    An actor used to represent a rig control
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigGizmoActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``hovered`` (bool):  [Read-Write] Whether this control is hovered
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``selected`` (bool):  [Read-Write] Whether this control is selected
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``static_mesh_component`` (StaticMeshComponent):  [Read-Only] this is visual representation of the transform
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def static_mesh_component(self) -> StaticMeshComponent:
        r"""
        (StaticMeshComponent):  [Read-Only] this is visual representation of the transform
        """
        ...
    @property
    def selected(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this control is selected
        """
        ...
    @selected.setter
    def selected(self, value: bool) -> None:
        ...
    @property
    def hovered(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether this control is hovered
        """
        ...
    @hovered.setter
    def hovered(self, value: bool) -> None:
        ...
    def set_global_transform(self, transform: Transform) -> None:
        r"""
        x.set_global_transform(transform) -> None
        this returns root component transform based on attach
        when there is no attach, it is based on 0
        
        Args:
            transform (Transform):
        """
        ...
    def on_transform_changed(self, new_transform: Transform) -> None:
        r"""
        x.on_transform_changed(new_transform) -> None
        Event called when the transform of this control has changed
        
        Args:
            new_transform (Transform):
        """
        ...
    def on_selection_changed(self, is_selected: bool) -> None:
        r"""
        x.on_selection_changed(is_selected) -> None
        Event called when the selection state of this control has changed
        
        Args:
            is_selected (bool):
        """
        ...
    def on_manipulating_changed(self, is_manipulating: bool) -> None:
        r"""
        x.on_manipulating_changed(is_manipulating) -> None
        Event called when the manipulating state of this control has changed
        
        Args:
            is_manipulating (bool):
        """
        ...
    def on_hovered_changed(self, is_selected: bool) -> None:
        r"""
        x.on_hovered_changed(is_selected) -> None
        Event called when the hovered state of this control has changed
        
        Args:
            is_selected (bool):
        """
        ...
    def on_enabled_changed(self, is_enabled: bool) -> None:
        r"""
        x.on_enabled_changed(is_enabled) -> None
        Event called when the enabled state of this control has changed
        
        Args:
            is_enabled (bool):
        """
        ...
    def get_global_transform(self) -> Transform:
        r"""
        x.get_global_transform() -> Transform
        Get Global Transform
        
        Returns:
            Transform:
        """
        ...

class ControlRigGizmoActor(ControlRigShapeActor):
    r"""
    deprecated: 'ControlRigGizmoActor' was renamed to 'ControlRigShapeActor'.
    """
    ...

class ControlRigShapeLibrary(Object):
    r"""
    Control Rig Shape Library
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigGizmoLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_material`` (Material):  [Read-Write]
    - ``default_shape`` (ControlRigShapeDefinition):  [Read-Write]
    - ``material_color_parameter`` (Name):  [Read-Write]
    - ``shapes`` (Array[ControlRigShapeDefinition]):  [Read-Write]
    - ``x_ray_material`` (Material):  [Read-Write]
    """
    ...

class ControlRigGizmoLibrary(ControlRigShapeLibrary):
    r"""
    deprecated: 'ControlRigGizmoLibrary' was renamed to 'ControlRigShapeLibrary'.
    """
    ...

class ControlRigTestData(Object):
    r"""
    Control Rig Test Data
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigTestData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``control_rig_object_path`` (SoftObjectPath):  [Read-Only]
    - ``frames_to_skip`` (Array[int32]):  [Read-Write]
    - ``initial`` (ControlRigTestDataFrame):  [Read-Only]
    - ``input_frames`` (Array[ControlRigTestDataFrame]):  [Read-Only]
    - ``output_frames`` (Array[ControlRigTestDataFrame]):  [Read-Only]
    - ``tolerance`` (double):  [Read-Write]
    """
    @property
    def control_rig_object_path(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Only]
        """
        ...
    @property
    def initial(self) -> ControlRigTestDataFrame:
        r"""
        (ControlRigTestDataFrame):  [Read-Only]
        """
        ...
    @property
    def input_frames(self) -> Array[ControlRigTestDataFrame]:
        r"""
        (Array[ControlRigTestDataFrame]):  [Read-Only]
        """
        ...
    @property
    def output_frames(self) -> Array[ControlRigTestDataFrame]:
        r"""
        (Array[ControlRigTestDataFrame]):  [Read-Only]
        """
        ...
    @property
    def frames_to_skip(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Only]
        """
        ...
    @property
    def tolerance(self) -> float:
        r"""
        (double):  [Read-Only]
        """
        ...
    def setup_replay(self, control_rig: ControlRig, ground_truth: bool = True) -> bool:
        r"""
        x.setup_replay(control_rig, ground_truth=True) -> bool
        Setup Replay
        
        Args:
            control_rig (ControlRig): 
            ground_truth (bool): 
        
        Returns:
            bool:
        """
        ...
    def release_replay(self) -> None:
        r"""
        x.release_replay() -> None
        Release Replay
        """
        ...
    def record(self, control_rig: ControlRig, recording_duration: float = 0.000000) -> bool:
        r"""
        x.record(control_rig, recording_duration=0.000000) -> bool
        Record
        
        Args:
            control_rig (ControlRig): 
            recording_duration (double): 
        
        Returns:
            bool:
        """
        ...
    def is_replaying(self) -> bool:
        r"""
        x.is_replaying() -> bool
        Is Replaying
        
        Returns:
            bool:
        """
        ...
    def is_recording(self) -> bool:
        r"""
        x.is_recording() -> bool
        Is Recording
        
        Returns:
            bool:
        """
        ...
    def get_time_range(self, input: bool = False) -> Vector2D:
        r"""
        x.get_time_range(input=False) -> Vector2D
        Get Time Range
        
        Args:
            input (bool): 
        
        Returns:
            Vector2D:
        """
        ...
    def get_playback_mode(self) -> ControlRigTestDataPlaybackMode:
        r"""
        x.get_playback_mode() -> ControlRigTestDataPlaybackMode
        Get Playback Mode
        
        Returns:
            ControlRigTestDataPlaybackMode:
        """
        ...
    def get_frame_index_for_time(self, seconds: float, input: bool = False) -> int:
        r"""
        x.get_frame_index_for_time(seconds, input=False) -> int32
        Get Frame Index for Time
        
        Args:
            seconds (double): 
            input (bool): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def create_new_asset(cls, desired_package_path: str, blueprint_path_name: str) -> ControlRigTestData:
        r"""
        X.create_new_asset(desired_package_path, blueprint_path_name) -> ControlRigTestData
        Create New Asset
        
        Args:
            desired_package_path (str): 
            blueprint_path_name (str): 
        
        Returns:
            ControlRigTestData:
        """
        ...

class ModularRigController(Object):
    r"""
    Modular Rig Controller
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ModularRigController.h
    
    """
    def un_bind_module_variable(self, module_path: str, variable_name: Name, setup_undo: bool = True) -> bool:
        r"""
        x.un_bind_module_variable(module_path, variable_name, setup_undo=True) -> bool
        Un Bind Module Variable
        
        Args:
            module_path (str): 
            variable_name (Name): 
            setup_undo (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_module_short_name(self, module_path: str, new_short_name: str, setup_undo: bool = True) -> bool:
        r"""
        x.set_module_short_name(module_path, new_short_name, setup_undo=True) -> bool
        Set Module Short Name
        
        Args:
            module_path (str): 
            new_short_name (str): 
            setup_undo (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_config_value_in_module(self, module_path: str, variable_name: Name, value: str, setup_undo: bool = True) -> bool:
        r"""
        x.set_config_value_in_module(module_path, variable_name, value, setup_undo=True) -> bool
        Set Config Value in Module
        
        Args:
            module_path (str): 
            variable_name (Name): 
            value (str): 
            setup_undo (bool): 
        
        Returns:
            bool:
        """
        ...
    def reparent_module(self, module_path: str, new_parent_module_path: str, setup_undo: bool = True) -> str:
        r"""
        x.reparent_module(module_path, new_parent_module_path, setup_undo=True) -> str
        Reparent Module
        
        Args:
            module_path (str): 
            new_parent_module_path (str): 
            setup_undo (bool): 
        
        Returns:
            str:
        """
        ...
    def rename_module(self, module_path: str, new_name: Name, setup_undo: bool = True) -> str:
        r"""
        x.rename_module(module_path, new_name, setup_undo=True) -> str
        Rename Module
        
        Args:
            module_path (str): 
            new_name (Name): 
            setup_undo (bool): 
        
        Returns:
            str:
        """
        ...
    def mirror_module(self, module_path: str, settings: RigVMMirrorSettings, setup_undo: bool = True) -> str:
        r"""
        x.mirror_module(module_path, settings, setup_undo=True) -> str
        Mirror Module
        
        Args:
            module_path (str): 
            settings (RigVMMirrorSettings): 
            setup_undo (bool): 
        
        Returns:
            str:
        """
        ...
    def disconnect_cyclic_connectors(self, setup_undo: bool = True) -> Array[RigElementKey]:
        r"""
        x.disconnect_cyclic_connectors(setup_undo=True) -> Array[RigElementKey]
        Disconnect Cyclic Connectors
        
        Args:
            setup_undo (bool): 
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def disconnect_connector(self, connector_key: RigElementKey, disconnect_sub_modules: bool = False, setup_undo: bool = True) -> bool:
        r"""
        x.disconnect_connector(connector_key, disconnect_sub_modules=False, setup_undo=True) -> bool
        Disconnect Connector
        
        Args:
            connector_key (RigElementKey): 
            disconnect_sub_modules (bool): 
            setup_undo (bool): 
        
        Returns:
            bool:
        """
        ...
    def delete_module(self, module_path: str, setup_undo: bool = True) -> bool:
        r"""
        x.delete_module(module_path, setup_undo=True) -> bool
        Delete Module
        
        Args:
            module_path (str): 
            setup_undo (bool): 
        
        Returns:
            bool:
        """
        ...
    def connect_connector_to_element(self, connector_key: RigElementKey, target_key: RigElementKey, setup_undo: bool = True, auto_resolve_other_connectors: bool = True, check_valid_connection: bool = True) -> bool:
        r"""
        x.connect_connector_to_element(connector_key, target_key, setup_undo=True, auto_resolve_other_connectors=True, check_valid_connection=True) -> bool
        Connect Connector to Element
        
        Args:
            connector_key (RigElementKey): 
            target_key (RigElementKey): 
            setup_undo (bool): 
            auto_resolve_other_connectors (bool): 
            check_valid_connection (bool): 
        
        Returns:
            bool:
        """
        ...
    def can_connect_connector_to_element(self, connector_key: RigElementKey, target_key: RigElementKey) -> Optional[Text]:
        r"""
        x.can_connect_connector_to_element(connector_key, target_key) -> Text or None
        Can Connect Connector to Element
        
        Args:
            connector_key (RigElementKey): 
            target_key (RigElementKey): 
        
        Returns:
            Text or None: 
        
            out_error_message (Text):
        """
        ...
    def bind_module_variable(self, module_path: str, variable_name: Name, source_path: str, setup_undo: bool = True) -> bool:
        r"""
        x.bind_module_variable(module_path, variable_name, source_path, setup_undo=True) -> bool
        Bind Module Variable
        
        Args:
            module_path (str): 
            variable_name (Name): 
            source_path (str): 
            setup_undo (bool): 
        
        Returns:
            bool:
        """
        ...
    def auto_connect_secondary_connectors(self, connector_keys: Array[RigElementKey], replace_existing_connections: bool, setup_undo: bool = True) -> bool:
        r"""
        x.auto_connect_secondary_connectors(connector_keys, replace_existing_connections, setup_undo=True) -> bool
        Auto Connect Secondary Connectors
        
        Args:
            connector_keys (Array[RigElementKey]): 
            replace_existing_connections (bool): 
            setup_undo (bool): 
        
        Returns:
            bool:
        """
        ...
    def auto_connect_modules(self, module_paths: Array[str], replace_existing_connections: bool, setup_undo: bool = True) -> bool:
        r"""
        x.auto_connect_modules(module_paths, replace_existing_connections, setup_undo=True) -> bool
        Auto Connect Modules
        
        Args:
            module_paths (Array[str]): 
            replace_existing_connections (bool): 
            setup_undo (bool): 
        
        Returns:
            bool:
        """
        ...
    def add_module(self, module_name: Name, class_: Class, parent_module_path: str, setup_undo: bool = True) -> str:
        r"""
        x.add_module(module_name, class_, parent_module_path, setup_undo=True) -> str
        Add Module
        
        Args:
            module_name (Name): 
            class_ (type(Class)): 
            parent_module_path (str): 
            setup_undo (bool): 
        
        Returns:
            str:
        """
        ...

class ModularRigRuleManager(Object):
    r"""
    A management class to validate rules and pattern match
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ModularRigRuleManager.h
    
    """
    ...

class AdditiveControlRig(ControlRig):
    r"""
    Rig that allows additive layer editing per joint
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: AdditiveControlRig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``on_control_selected_bp`` (OnControlSelectedBP):  [Read-Write]
    """
    ...

class FKControlRig(ControlRig):
    r"""
    Rig that allows override editing per joint
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: FKControlRig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``on_control_selected_bp`` (OnControlSelectedBP):  [Read-Write]
    """
    ...

class RigHierarchyController(Object):
    r"""
    Rig Hierarchy Controller
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: RigHierarchyController.h
    
    """
    def set_selection(self, keys: Array[RigElementKey], print_python_command: bool = False) -> bool:
        r"""
        x.set_selection(keys, print_python_command=False) -> bool
        Sets the selection based on a list of keys
        
        Args:
            keys (Array[RigElementKey]): The array of keys of the elements to select
            print_python_command (bool): 
        
        Returns:
            bool: Returns true if the selection was applied
        """
        ...
    def set_parent(self, child: RigElementKey, parent: RigElementKey, maintain_global_transform: bool = True, setup_undo: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.set_parent(child, parent, maintain_global_transform=True, setup_undo=False, print_python_command=False) -> bool
        Sets a new parent to an element. For elements that allow more than one parent the parent list will be replaced.
        
        Args:
            child (RigElementKey): The key of the element to set the parent for
            parent (RigElementKey): The key of the new parent to set
            maintain_global_transform (bool): If set to true the child will stay in the same place spatially, otherwise it will maintain it's local transform (and potential move).
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            bool: Returns true if successful.
        """
        ...
    def set_hierarchy(self, hierarchy: RigHierarchy) -> None:
        r"""
        x.set_hierarchy(hierarchy) -> None
        Sets the hierarchy currently linked to this controller
        
        Args:
            hierarchy (RigHierarchy):
        """
        ...
    def set_display_name(self, control: RigElementKey, display_name: Name, rename_element: bool = False, setup_undo: bool = False, print_python_command: bool = False) -> Name:
        r"""
        x.set_display_name(control, display_name, rename_element=False, setup_undo=False, print_python_command=False) -> Name
        Sets the display name on a control
        
        Args:
            control (RigElementKey): The key of the control to change the display name for
            display_name (Name): The new display name to set for the control
            rename_element (bool): True if the control should also be renamed
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            Name: Returns the new display name used for the control
        """
        ...
    def set_control_settings(self, key: RigElementKey, settings: RigControlSettings, setup_undo: bool = False) -> bool:
        r"""
        x.set_control_settings(key, settings, setup_undo=False) -> bool
        Sets a control's settings given a control key
        
        Args:
            key (RigElementKey): The key of the control to set the settings for
            settings (RigControlSettings): 
            setup_undo (bool): 
        
        Returns:
            bool: Returns true if the settings have been set correctly
        """
        ...
    def select_element(self, key: RigElementKey, select: bool = True, clear_selection: bool = False) -> bool:
        r"""
        x.select_element(key, select=True, clear_selection=False) -> bool
        Selects or deselects an element in the hierarchy
        
        Args:
            key (RigElementKey): The key of the element to select
            select (bool): If set to false the element will be deselected
            clear_selection (bool): 
        
        Returns:
            bool: Returns true if the selection was applied
        """
        ...
    def reorder_element(self, element: RigElementKey, index: int, setup_undo: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.reorder_element(element, index, setup_undo=False, print_python_command=False) -> bool
        Changes the element's index within its default parent (or the top level)
        
        Args:
            element (RigElementKey): The key of the element to rename
            index (int32): The new index of the element to take within its default parent (or the top level)
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            bool: Returns true if the element has been reordered accordingly
        """
        ...
    def rename_element(self, element: RigElementKey, name: Name, setup_undo: bool = False, print_python_command: bool = False, clear_selection: bool = True) -> RigElementKey:
        r"""
        x.rename_element(element, name, setup_undo=False, print_python_command=False, clear_selection=True) -> RigElementKey
        Renames an existing element in the hierarchy
        
        Args:
            element (RigElementKey): The key of the element to rename
            name (Name): The new name to set for the element
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
            clear_selection (bool): True if the selection should be cleared after a rename
        
        Returns:
            RigElementKey: Returns the new element key used for the element
        """
        ...
    def remove_parent(self, child: RigElementKey, parent: RigElementKey, maintain_global_transform: bool = True, setup_undo: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.remove_parent(child, parent, maintain_global_transform=True, setup_undo=False, print_python_command=False) -> bool
        Removes an existing parent from an element in the hierarchy. For elements that allow only one parent the element will be unparented (same as ::RemoveAllParents)
        
        Args:
            child (RigElementKey): The key of the element to remove the parent for
            parent (RigElementKey): The key of the parent to remove
            maintain_global_transform (bool): If set to true the child will stay in the same place spatially, otherwise it will maintain it's local transform (and potential move).
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            bool: Returns true if successful.
        """
        ...
    def remove_element(self, element: RigElementKey, setup_undo: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.remove_element(element, setup_undo=False, print_python_command=False) -> bool
        Removes an existing element from the hierarchy
        
        Args:
            element (RigElementKey): The key of the element to remove
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            bool: Returns true if successful.
        """
        ...
    def remove_all_parents(self, child: RigElementKey, maintain_global_transform: bool = True, setup_undo: bool = False, print_python_command: bool = False) -> bool:
        r"""
        x.remove_all_parents(child, maintain_global_transform=True, setup_undo=False, print_python_command=False) -> bool
        Removes all parents from an element in the hierarchy.
        
        Args:
            child (RigElementKey): The key of the element to remove all parents for
            maintain_global_transform (bool): If set to true the child will stay in the same place spatially, otherwise it will maintain it's local transform (and potential move).
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            bool: Returns true if successful.
        """
        ...
    def mirror_elements(self, keys: Array[RigElementKey], settings: RigVMMirrorSettings, select_new_elements: bool = True, setup_undo: bool = False, print_python_commands: bool = False) -> Array[RigElementKey]:
        r"""
        x.mirror_elements(keys, settings, select_new_elements=True, setup_undo=False, print_python_commands=False) -> Array[RigElementKey]
        Mirrors the given elements
        
        Args:
            keys (Array[RigElementKey]): The keys of the elements to mirror
            settings (RigVMMirrorSettings): The settings to use for the mirror operation
            select_new_elements (bool): If set to true the new elements will be selected
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_commands (bool): 
        
        Returns:
            Array[RigElementKey]: The keys of the mirrored items
        """
        ...
    def import_from_text(self, content: str, replace_existing_elements: bool = False, select_new_elements: bool = True, setup_undo: bool = False, print_python_commands: bool = False) -> Array[RigElementKey]:
        r"""
        x.import_from_text(content, replace_existing_elements=False, select_new_elements=True, setup_undo=False, print_python_commands=False) -> Array[RigElementKey]
        Imports the content of a text buffer to the hierarchy
        
        Args:
            content (str): The string buffer representing the content to import
            replace_existing_elements (bool): If set to true existing items will be replaced / updated with the content in the buffer
            select_new_elements (bool): If set to true the new elements will be selected
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_commands (bool): 
        
        Returns:
            Array[RigElementKey]:
        """
        ...
    def import_curves_from_asset(self, asset_path: str, name_space: Name = "None", select_curves: bool = False, setup_undo: bool = False) -> Array[RigElementKey]:
        r"""
        x.import_curves_from_asset(asset_path, name_space="None", select_curves=False, setup_undo=False) -> Array[RigElementKey]
        Imports all curves from a skeleton to the hierarchy
        
        Args:
            asset_path (str): The path to the uasset to import from
            name_space (Name): The namespace to prefix the bone names with
            select_curves (bool): If true the curves will be selected upon import
            setup_undo (bool): If set to true the stack will record the change for undo / redo
        
        Returns:
            Array[RigElementKey]: The keys of the imported elements
        """
        ...
    def import_curves(self, skeleton: Skeleton, name_space: Name = "None", select_curves: bool = False, setup_undo: bool = False, print_python_command: bool = False) -> Array[RigElementKey]:
        r"""
        x.import_curves(skeleton, name_space="None", select_curves=False, setup_undo=False, print_python_command=False) -> Array[RigElementKey]
        Imports all curves from a skeleton to the hierarchy
        
        Args:
            skeleton (Skeleton): The skeleton to import the curves from
            name_space (Name): The namespace to prefix the bone names with
            select_curves (bool): If true the curves will be selected upon import
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): 
        
        Returns:
            Array[RigElementKey]: The keys of the imported elements
        """
        ...
    def import_bones_from_asset(self, asset_path: str, name_space: Name = "None", replace_existing_bones: bool = True, remove_obsolete_bones: bool = True, select_bones: bool = False, setup_undo: bool = False) -> Array[RigElementKey]:
        r"""
        x.import_bones_from_asset(asset_path, name_space="None", replace_existing_bones=True, remove_obsolete_bones=True, select_bones=False, setup_undo=False) -> Array[RigElementKey]
        Imports an existing skeleton to the hierarchy
        
        Args:
            asset_path (str): The path to the uasset to import from
            name_space (Name): The namespace to prefix the bone names with
            replace_existing_bones (bool): If true existing bones will be removed
            remove_obsolete_bones (bool): If true bones non-existent in the skeleton will be removed from the hierarchy
            select_bones (bool): If true the bones will be selected upon import
            setup_undo (bool): If set to true the stack will record the change for undo / redo
        
        Returns:
            Array[RigElementKey]: The keys of the imported elements
        """
        ...
    def import_bones(self, skeleton: Skeleton, name_space: Name = "None", replace_existing_bones: bool = True, remove_obsolete_bones: bool = True, select_bones: bool = False, setup_undo: bool = False, print_python_command: bool = False) -> Array[RigElementKey]:
        r"""
        x.import_bones(skeleton, name_space="None", replace_existing_bones=True, remove_obsolete_bones=True, select_bones=False, setup_undo=False, print_python_command=False) -> Array[RigElementKey]
        Imports an existing skeleton to the hierarchy
        
        Args:
            skeleton (Skeleton): The skeleton to import
            name_space (Name): The namespace to prefix the bone names with
            replace_existing_bones (bool): If true existing bones will be removed
            remove_obsolete_bones (bool): If true bones non-existent in the skeleton will be removed from the hierarchy
            select_bones (bool): If true the bones will be selected upon import
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            Array[RigElementKey]: The keys of the imported elements
        """
        ...
    def get_hierarchy(self) -> RigHierarchy:
        r"""
        x.get_hierarchy() -> RigHierarchy
        Returns the hierarchy currently linked to this controller
        
        Returns:
            RigHierarchy:
        """
        ...
    def get_control_settings(self, key: RigElementKey) -> RigControlSettings:
        r"""
        x.get_control_settings(key) -> RigControlSettings
        Returns the control settings of a given control
        
        Args:
            key (RigElementKey): The key of the control to receive the settings for
        
        Returns:
            RigControlSettings: The settings of the given control
        """
        ...
    def generate_python_commands(self) -> Array[str]:
        r"""
        x.generate_python_commands() -> Array[str]
        Generate Python Commands
        
        Returns:
            Array[str]:
        """
        ...
    def export_to_text(self, keys: Array[RigElementKey]) -> str:
        r"""
        x.export_to_text(keys) -> str
        Exports a list of items to text
        
        Args:
            keys (Array[RigElementKey]): The keys to export to text
        
        Returns:
            str: The text representation of the requested elements
        """
        ...
    def export_selection_to_text(self) -> str:
        r"""
        x.export_selection_to_text() -> str
        Exports the selected items to text
        
        Returns:
            str: The text representation of the selected items
        """
        ...
    def duplicate_elements(self, keys: Array[RigElementKey], select_new_elements: bool = True, setup_undo: bool = False, print_python_commands: bool = False) -> Array[RigElementKey]:
        r"""
        x.duplicate_elements(keys, select_new_elements=True, setup_undo=False, print_python_commands=False) -> Array[RigElementKey]
        Duplicate the given elements
        
        Args:
            keys (Array[RigElementKey]): The keys of the elements to duplicate
            select_new_elements (bool): If set to true the new elements will be selected
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_commands (bool): 
        
        Returns:
            Array[RigElementKey]: The keys of the 4d items
        """
        ...
    def deselect_element(self, key: RigElementKey) -> bool:
        r"""
        x.deselect_element(key) -> bool
        Deselects or deselects an element in the hierarchy
        
        Args:
            key (RigElementKey): The key of the element to deselect
        
        Returns:
            bool: Returns true if the selection was applied
        """
        ...
    def clear_selection(self) -> bool:
        r"""
        x.clear_selection() -> bool
        Clears the selection
        
        Returns:
            bool: Returns true if the selection was applied
        """
        ...
    def add_socket(self, name: Name, parent: RigElementKey, transform: Transform, transform_in_global: bool = True, color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000], description: str = "", setup_undo: bool = False, print_python_command: bool = False) -> RigElementKey:
        r"""
        x.add_socket(name, parent, transform, transform_in_global=True, color=[1.000000, 1.000000, 1.000000, 1.000000], description="", setup_undo=False, print_python_command=False) -> RigElementKey
        Adds a socket to the hierarchy
        
        Args:
            name (Name): The suggested name of the new socket - will eventually be corrected by the namespace
            parent (RigElementKey): The (optional) parent of the new null. If you don't need a parent, pass FRigElementKey()
            transform (Transform): The transform for the new socket - either in local or global space, based on bTransformInGlobal
            transform_in_global (bool): Set this to true if the Transform passed is expressed in global space, false for local space.
            color (LinearColor): The color of the socket
            description (str): The description of the socket
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            RigElementKey: The key for the newly created bone.
        """
        ...
    def add_rigid_body(self, name: Name, parent: RigElementKey, settings: RigRigidBodySettings, local_transform: Transform, setup_undo: bool = False, print_python_command: bool = False) -> RigElementKey:
        r"""
        x.add_rigid_body(name, parent, settings, local_transform, setup_undo=False, print_python_command=False) -> RigElementKey
        Adds a rigidbody to the hierarchy
        
        Args:
            name (Name): The suggested name of the new rigidbody - will eventually be corrected by the namespace
            parent (RigElementKey): The (optional) parent of the new rigidbody. If you don't need a parent, pass FRigElementKey()
            settings (RigRigidBodySettings): All of the rigidbody's settings
            local_transform (Transform): The transform for the new rigidbody - in the space of the provided parent
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            RigElementKey: The key for the newly created rigidbody.
        """
        ...
    def add_parent(self, child: RigElementKey, parent: RigElementKey, weight: float = 0.000000, maintain_global_transform: bool = True, setup_undo: bool = False) -> bool:
        r"""
        x.add_parent(child, parent, weight=0.000000, maintain_global_transform=True, setup_undo=False) -> bool
        Adds a new parent to an element. For elements that allow only one parent the parent will be replaced (Same as ::SetParent).
        
        Args:
            child (RigElementKey): The key of the element to add the parent for
            parent (RigElementKey): The key of the new parent to add
            weight (float): The initial weight to give to the parent
            maintain_global_transform (bool): If set to true the child will stay in the same place spatially, otherwise it will maintain it's local transform (and potential move).
            setup_undo (bool): If set to true the stack will record the change for undo / redo
        
        Returns:
            bool: Returns true if successful.
        """
        ...
    def add_null(self, name: Name, parent: RigElementKey, transform: Transform, transform_in_global: bool = True, setup_undo: bool = False, print_python_command: bool = False) -> RigElementKey:
        r"""
        x.add_null(name, parent, transform, transform_in_global=True, setup_undo=False, print_python_command=False) -> RigElementKey
        Adds a null to the hierarchy
        
        Args:
            name (Name): The suggested name of the new null - will eventually be corrected by the namespace
            parent (RigElementKey): The (optional) parent of the new null. If you don't need a parent, pass FRigElementKey()
            transform (Transform): The transform for the new null - either in local or global null, based on bTransformInGlobal
            transform_in_global (bool): Set this to true if the Transform passed is expressed in global null, false for local null.
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            RigElementKey: The key for the newly created null.
        """
        ...
    def add_curve(self, name: Name, value: float = 0.000000, setup_undo: bool = True, print_python_command: bool = False) -> RigElementKey:
        r"""
        x.add_curve(name, value=0.000000, setup_undo=True, print_python_command=False) -> RigElementKey
        Adds a curve to the hierarchy
        
        Args:
            name (Name): The suggested name of the new curve - will eventually be corrected by the namespace
            value (float): The value to use for the curve
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            RigElementKey: The key for the newly created curve.
        """
        ...
    def add_control(self, name: Name, parent: RigElementKey, settings: RigControlSettings, value: RigControlValue, setup_undo: bool = True, print_python_command: bool = False) -> RigElementKey:
        r"""
        x.add_control(name, parent, settings, value, setup_undo=True, print_python_command=False) -> RigElementKey
        Adds a control to the hierarchy
        
        Args:
            name (Name): The suggested name of the new control - will eventually be corrected by the namespace
            parent (RigElementKey): The (optional) parent of the new control. If you don't need a parent, pass FRigElementKey()
            settings (RigControlSettings): All of the control's settings
            value (RigControlValue): The value to use for the control
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): 
        
        Returns:
            RigElementKey: The key for the newly created control.
        """
        ...
    def add_connector(self, name: Name, settings: RigConnectorSettings = ["", ConnectorType.PRIMARY, False, []], setup_undo: bool = False, print_python_command: bool = False) -> RigElementKey:
        r"""
        x.add_connector(name, settings=["", ConnectorType.PRIMARY, False, []], setup_undo=False, print_python_command=False) -> RigElementKey
        Adds a connector to the hierarchy
        
        Args:
            name (Name): The suggested name of the new connector - will eventually be corrected by the namespace
            settings (RigConnectorSettings): All of the connector's settings
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            RigElementKey: The key for the newly created bone.
        """
        ...
    def add_bone(self, name: Name, parent: RigElementKey, transform: Transform, transform_in_global: bool = True, bone_type: RigBoneType = RigBoneType.USER, setup_undo: bool = False, print_python_command: bool = False) -> RigElementKey:
        r"""
        x.add_bone(name, parent, transform, transform_in_global=True, bone_type=RigBoneType.USER, setup_undo=False, print_python_command=False) -> RigElementKey
        Adds a bone to the hierarchy
        
        Args:
            name (Name): The suggested name of the new bone - will eventually be corrected by the namespace
            parent (RigElementKey): The (optional) parent of the new bone. If you don't need a parent, pass FRigElementKey()
            transform (Transform): The transform for the new bone - either in local or global space, based on bTransformInGlobal
            transform_in_global (bool): Set this to true if the Transform passed is expressed in global space, false for local space.
            bone_type (RigBoneType): The type of bone to add. This can be used to differentiate between imported bones and user defined bones.
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): If set to true a python command equivalent to this call will be printed out
        
        Returns:
            RigElementKey: The key for the newly created bone.
        """
        ...
    def add_animation_channel(self, name: Name, parent_control: RigElementKey, settings: RigControlSettings, setup_undo: bool = True, print_python_command: bool = False) -> RigElementKey:
        r"""
        x.add_animation_channel(name, parent_control, settings, setup_undo=True, print_python_command=False) -> RigElementKey
        Adds a control to the hierarchy
        
        Args:
            name (Name): The suggested name of the new animation channel - will eventually be corrected by the namespace
            parent_control (RigElementKey): The parent of the new animation channel.
            settings (RigControlSettings): All of the animation channel's settings
            setup_undo (bool): If set to true the stack will record the change for undo / redo
            print_python_command (bool): 
        
        Returns:
            RigElementKey: The key for the newly created animation channel.
        """
        ...

class ControlRigLayerInstance(AnimInstance):
    r"""
    Control Rig Layer Instance
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigLayerInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    ...

class MovieSceneControlRigParameterSection(MovieSceneParameterSection):
    r"""
    Movie scene section that controls animation controller animation
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: MovieSceneControlRigParameterSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``control_rig_class`` (type(Class)):  [Read-Write] The class of control rig to instantiate
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneControlRigParameterTrack(MovieSceneNameableTrack):
    r"""
    Handles animation of skeletal mesh actors using animation ControlRigs
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: MovieSceneControlRigParameterTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class ControlRigPoseAsset(Object):
    r"""
    An individual Pose made of Control Rig Controls
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigPose.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``pose`` (ControlRigControlPose):  [Read-Write]
    """
    @property
    def pose(self) -> ControlRigControlPose:
        r"""
        (ControlRigControlPose):  [Read-Write]
        """
        ...
    @pose.setter
    def pose(self, value: ControlRigControlPose) -> None:
        ...
    def select_controls(self, control_rig: ControlRig, do_mirror: bool = False) -> None:
        r"""
        x.select_controls(control_rig, do_mirror=False) -> None
        Select Controls
        
        Args:
            control_rig (ControlRig): 
            do_mirror (bool):
        """
        ...
    def save_pose(self, control_rig: ControlRig, use_all: bool) -> None:
        r"""
        x.save_pose(control_rig, use_all) -> None
        Save Pose
        
        Args:
            control_rig (ControlRig): 
            use_all (bool):
        """
        ...
    def replace_control_name(self, current_name: Name, new_name: Name) -> None:
        r"""
        x.replace_control_name(current_name, new_name) -> None
        Replace Control Name
        
        Args:
            current_name (Name): 
            new_name (Name):
        """
        ...
    def paste_pose(self, control_rig: ControlRig, do_key: bool = False, do_mirror: bool = False) -> None:
        r"""
        x.paste_pose(control_rig, do_key=False, do_mirror=False) -> None
        Paste Pose
        
        Args:
            control_rig (ControlRig): 
            do_key (bool): 
            do_mirror (bool):
        """
        ...
    def get_current_pose(self, control_rig: ControlRig) -> ControlRigControlPose:
        r"""
        x.get_current_pose(control_rig) -> ControlRigControlPose
        Get Current Pose
        
        Args:
            control_rig (ControlRig): 
        
        Returns:
            ControlRigControlPose: 
        
            out_pose (ControlRigControlPose):
        """
        ...
    def get_control_names(self) -> Array[Name]:
        r"""
        x.get_control_names() -> Array[Name]
        Get Control Names
        
        Returns:
            Array[Name]:
        """
        ...
    def does_mirror_match(self, control_rig: ControlRig, control_name: Name) -> bool:
        r"""
        x.does_mirror_match(control_rig, control_name) -> bool
        Does Mirror Match
        
        Args:
            control_rig (ControlRig): 
            control_name (Name): 
        
        Returns:
            bool:
        """
        ...

class ControlRigPoseMirrorSettings(Object):
    r"""
    Control Rig Pose Mirror Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigPoseMirrorSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``axis_to_flip`` (AxisType):  [Read-Write] Axis to Flip for Rotations
    - ``left_side`` (str):  [Read-Write] String To Denote Left Side
    - ``mirror_axis`` (AxisType):  [Read-Write] Axis to Mirror Translations
    - ``right_side`` (str):  [Read-Write] String To Denote Right Side
    """
    @property
    def right_side(self) -> str:
        r"""
        (str):  [Read-Write] String To Denote Right Side
        """
        ...
    @right_side.setter
    def right_side(self, value: str) -> None:
        ...
    @property
    def left_side(self) -> str:
        r"""
        (str):  [Read-Write] String To Denote Left Side
        """
        ...
    @left_side.setter
    def left_side(self, value: str) -> None:
        ...
    @property
    def mirror_axis(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] Axis to Mirror Translations
        """
        ...
    @mirror_axis.setter
    def mirror_axis(self, value: AxisType) -> None:
        ...
    @property
    def axis_to_flip(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] Axis to Flip for Rotations
        """
        ...
    @axis_to_flip.setter
    def axis_to_flip(self, value: AxisType) -> None:
        ...

class ControlRigPoseProjectSettings(Object):
    r"""
    Control Rig Pose Project Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigPoseProjectSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``root_save_dirs`` (Array[DirectoryPath]):  [Read-Write] The root of the directory in which to save poses
    """
    @property
    def root_save_dirs(self) -> Array[DirectoryPath]:
        r"""
        (Array[DirectoryPath]):  [Read-Write] The root of the directory in which to save poses
        """
        ...
    @root_save_dirs.setter
    def root_save_dirs(self, value: Array[DirectoryPath]) -> None:
        ...

class ControlRigWorkflowOptions(RigVMUserWorkflowOptions):
    r"""
    Control Rig Workflow Options
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigNodeWorkflow.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``hierarchy`` (RigHierarchy):  [Read-Write]
    - ``selection`` (Array[RigElementKey]):  [Read-Write]
    - ``subject`` (Object):  [Read-Write]
    - ``workflow`` (RigVMUserWorkflow):  [Read-Write]
    """
    @property
    def hierarchy(self) -> RigHierarchy:
        r"""
        (RigHierarchy):  [Read-Write]
        """
        ...
    @hierarchy.setter
    def hierarchy(self, value: RigHierarchy) -> None:
        ...
    @property
    def selection(self) -> Array[RigElementKey]:
        r"""
        (Array[RigElementKey]):  [Read-Write]
        """
        ...
    @selection.setter
    def selection(self, value: Array[RigElementKey]) -> None:
        ...
    def ensure_at_least_one_rig_element_selected(self) -> bool:
        r"""
        x.ensure_at_least_one_rig_element_selected() -> bool
        Ensure at Least One Rig Element Selected
        
        Returns:
            bool:
        """
        ...

class ControlRigTransformWorkflowOptions(ControlRigWorkflowOptions):
    r"""
    Control Rig Transform Workflow Options
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRig
    - **File**: ControlRigNodeWorkflow.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``hierarchy`` (RigHierarchy):  [Read-Write]
    - ``selection`` (Array[RigElementKey]):  [Read-Write]
    - ``subject`` (Object):  [Read-Write]
    - ``transform_type`` (RigTransformType):  [Read-Write] The type of transform to retrieve from the hierarchy
    - ``workflow`` (RigVMUserWorkflow):  [Read-Write]
    """
    @property
    def transform_type(self) -> RigTransformType:
        r"""
        (RigTransformType):  [Read-Write] The type of transform to retrieve from the hierarchy
        """
        ...
    @transform_type.setter
    def transform_type(self, value: RigTransformType) -> None:
        ...

class PyTestInterface(Interface):
    r"""
    Py Test Interface
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTestInterface.h
    
    """
    def func_interface(self, value: int) -> int:
        r"""
        x.func_interface(value) -> int32
        Func Interface
        
        Args:
            value (int32): 
        
        Returns:
            int32:
        """
        ...

class PyTestChildInterface(PyTestInterface):
    r"""
    Py Test Child Interface
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTestInterface.h
    
    """
    def func_interface_child(self, value: int) -> int:
        r"""
        x.func_interface_child(value) -> int32
        Func Interface Child
        
        Args:
            value (int32): 
        
        Returns:
            int32:
        """
        ...

class PyTestOtherInterface(Interface):
    r"""
    Py Test Other Interface
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTestInterface.h
    
    """
    def func_interface_other(self, value: int) -> int:
        r"""
        x.func_interface_other(value) -> int32
        Func Interface Other
        
        Args:
            value (int32): 
        
        Returns:
            int32:
        """
        ...

class PyTestStructLibrary(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto the test struct in Python.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    """
    @classmethod
    def set_bool_mutable_via_ref(cls, struct: PyTestStruct) -> PyTestStruct:
        r"""
        X.set_bool_mutable_via_ref(struct) -> PyTestStruct
        Set Bool Mutable Via Ref
        
        Args:
            struct (PyTestStruct): 
        
        Returns:
            PyTestStruct: 
        
            struct (PyTestStruct):
        """
        ...
    @classmethod
    def set_bool_mutable(cls, struct: PyTestStruct) -> None:
        r"""
        X.set_bool_mutable(struct) -> None
        Set Bool Mutable
        
        Args:
            struct (PyTestStruct):
        """
        ...
    @classmethod
    def legacy_is_bool_set(cls, struct: PyTestStruct) -> bool:
        r"""
        X.legacy_is_bool_set(struct) -> bool
        Legacy Is Bool Set
        deprecated: LegacyIsBoolSet is deprecated. Please use IsBoolSet instead.
        
        Args:
            struct (PyTestStruct): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_bool_set(cls, struct: PyTestStruct) -> bool:
        r"""
        X.is_bool_set(struct) -> bool
        Is Bool Set
        
        Args:
            struct (PyTestStruct): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def clear_bool_mutable_via_ref(cls, struct: PyTestStruct) -> PyTestStruct:
        r"""
        X.clear_bool_mutable_via_ref(struct) -> PyTestStruct
        Clear Bool Mutable Via Ref
        
        Args:
            struct (PyTestStruct): 
        
        Returns:
            PyTestStruct: 
        
            struct (PyTestStruct):
        """
        ...
    @classmethod
    def clear_bool_mutable(cls, struct: PyTestStruct) -> None:
        r"""
        X.clear_bool_mutable(struct) -> None
        Clear Bool Mutable
        
        Args:
            struct (PyTestStruct):
        """
        ...
    @classmethod
    def add_str(cls, struct: PyTestStruct, value: str) -> PyTestStruct:
        r"""
        X.add_str(struct, value) -> PyTestStruct
        Add Str
        
        Args:
            struct (PyTestStruct): 
            value (str): 
        
        Returns:
            PyTestStruct:
        """
        ...
    @classmethod
    def add_int(cls, struct: PyTestStruct, value: int) -> PyTestStruct:
        r"""
        X.add_int(struct, value) -> PyTestStruct
        Add Int
        
        Args:
            struct (PyTestStruct): 
            value (int32): 
        
        Returns:
            PyTestStruct:
        """
        ...
    @classmethod
    def add_float(cls, struct: PyTestStruct, value: float) -> PyTestStruct:
        r"""
        X.add_float(struct, value) -> PyTestStruct
        Add Float
        
        Args:
            struct (PyTestStruct): 
            value (float): 
        
        Returns:
            PyTestStruct:
        """
        ...

class PyTestObject(Object):
    r"""
    Object to allow testing of the various UObject features that are exposed to Python wrapped types.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool`` (bool):  [Read-Write]
    - ``bool_defaults_only`` (bool):  [Read-Write]
    - ``bool_instance_only`` (bool):  [Read-Write]
    - ``child_struct`` (PyTestChildStruct):  [Read-Write]
    - ``delegate`` (PyTestDelegate):  [Read-Write]
    - ``enum`` (PyTestEnum):  [Read-Write]
    - ``field_path`` (FieldPath):  [Read-Write]
    - ``float`` (float):  [Read-Write]
    - ``int`` (int32):  [Read-Write]
    - ``multicast_delegate`` (PyTestMulticastDelegate):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``string`` (str):  [Read-Write]
    - ``string_array`` (Array[str]):  [Read-Write]
    - ``string_int_map`` (Map[str, int32]):  [Read-Write]
    - ``string_set`` (Set[str]):  [Read-Write]
    - ``struct`` (PyTestStruct):  [Read-Write]
    - ``struct_array`` (Array[PyTestStruct]):  [Read-Write]
    - ``struct_field_path`` (FieldPath):  [Read-Write]
    - ``text`` (Text):  [Read-Write]
    """
    @property
    def bool(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @bool.setter
    def bool(self, value: bool) -> None:
        ...
    @property
    def int(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @int.setter
    def int(self, value: int) -> None:
        ...
    @property
    def float(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @float.setter
    def float(self, value: float) -> None:
        ...
    @property
    def enum(self) -> PyTestEnum:
        r"""
        (PyTestEnum):  [Read-Write]
        """
        ...
    @enum.setter
    def enum(self, value: PyTestEnum) -> None:
        ...
    @property
    def string(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @string.setter
    def string(self, value: str) -> None:
        ...
    @property
    def name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name.setter
    def name(self, value: Name) -> None:
        ...
    @property
    def text(self) -> Text:
        r"""
        (Text):  [Read-Write]
        """
        ...
    @text.setter
    def text(self, value: Text) -> None:
        ...
    @property
    def field_path(self) -> FieldPath:
        r"""
        (FieldPath):  [Read-Write]
        """
        ...
    @field_path.setter
    def field_path(self, value: FieldPath) -> None:
        ...
    @property
    def struct_field_path(self) -> FieldPath:
        r"""
        (FieldPath):  [Read-Write]
        """
        ...
    @struct_field_path.setter
    def struct_field_path(self, value: FieldPath) -> None:
        ...
    @property
    def string_array(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write]
        """
        ...
    @string_array.setter
    def string_array(self, value: Array[str]) -> None:
        ...
    @property
    def string_set(self) -> Set[str]:
        r"""
        (Set[str]):  [Read-Write]
        """
        ...
    @string_set.setter
    def string_set(self, value: Set[str]) -> None:
        ...
    @property
    def string_int_map(self) -> Map[str, int]:
        r"""
        (Map[str, int32]):  [Read-Write]
        """
        ...
    @string_int_map.setter
    def string_int_map(self, value: Map[str, int]) -> None:
        ...
    @property
    def delegate(self) -> PyTestDelegate:
        r"""
        (PyTestDelegate):  [Read-Write]
        """
        ...
    @delegate.setter
    def delegate(self, value: PyTestDelegate) -> None:
        ...
    @property
    def multicast_delegate(self) -> PyTestMulticastDelegate:
        r"""
        (PyTestMulticastDelegate):  [Read-Write]
        """
        ...
    @multicast_delegate.setter
    def multicast_delegate(self, value: PyTestMulticastDelegate) -> None:
        ...
    @property
    def struct(self) -> PyTestStruct:
        r"""
        (PyTestStruct):  [Read-Write]
        """
        ...
    @struct.setter
    def struct(self, value: PyTestStruct) -> None:
        ...
    @property
    def struct_array(self) -> Array[PyTestStruct]:
        r"""
        (Array[PyTestStruct]):  [Read-Write]
        """
        ...
    @struct_array.setter
    def struct_array(self, value: Array[PyTestStruct]) -> None:
        ...
    @property
    def child_struct(self) -> PyTestChildStruct:
        r"""
        (PyTestChildStruct):  [Read-Write]
        """
        ...
    @child_struct.setter
    def child_struct(self, value: PyTestChildStruct) -> None:
        ...
    @classmethod
    def return_set(cls) -> Set[int]:
        r"""
        X.return_set() -> Set[int32]
        Return Set
        
        Returns:
            Set[int32]:
        """
        ...
    @classmethod
    def return_map(cls) -> Map[int, bool]:
        r"""
        X.return_map() -> Map[int32, bool]
        Return Map
        
        Returns:
            Map[int32, bool]:
        """
        ...
    @classmethod
    def return_field_path(cls) -> FieldPath:
        r"""
        X.return_field_path() -> FieldPath
        Return Field Path
        
        Returns:
            FieldPath:
        """
        ...
    @classmethod
    def return_array(cls) -> Array[int]:
        r"""
        X.return_array() -> Array[int32]
        Return Array
        
        Returns:
            Array[int32]:
        """
        ...
    def multicast_delegate_property_callback(self, str: str) -> None:
        r"""
        x.multicast_delegate_property_callback(str) -> None
        Multicast Delegate Property Callback
        
        Args:
            str (str):
        """
        ...
    def legacy_func_taking_py_test_struct(self, struct: PyTestStruct) -> None:
        r"""
        x.legacy_func_taking_py_test_struct(struct) -> None
        Legacy Func Taking Py Test Struct
        deprecated: LegacyFuncTakingPyTestStruct is deprecated. Please use FuncTakingPyTestStruct instead.
        
        Args:
            struct (PyTestStruct):
        """
        ...
    def func_taking_py_test_struct_default(self, struct: PyTestStruct = [False, 0, 0.000000, PyTestEnum.ONE, "", "None", "", FieldPath(), FieldPath(), [], [], {}, False]) -> None:
        r"""
        x.func_taking_py_test_struct_default(struct=[False, 0, 0.000000, PyTestEnum.ONE, "", "None", "", FieldPath(), FieldPath(), [], [], {}, False]) -> None
        Func Taking Py Test Struct Default
        
        Args:
            struct (PyTestStruct):
        """
        ...
    def func_taking_py_test_struct(self, struct: PyTestStruct) -> None:
        r"""
        x.func_taking_py_test_struct(struct) -> None
        Func Taking Py Test Struct
        
        Args:
            struct (PyTestStruct):
        """
        ...
    def func_taking_py_test_delegate(self, delegate: PyTestDelegate, value: int) -> int:
        r"""
        x.func_taking_py_test_delegate(delegate, value) -> int32
        Func Taking Py Test Delegate
        
        Args:
            delegate (PyTestDelegate): 
            value (int32): 
        
        Returns:
            int32:
        """
        ...
    def func_taking_py_test_child_struct(self, struct: PyTestChildStruct) -> None:
        r"""
        x.func_taking_py_test_child_struct(struct) -> None
        Func Taking Py Test Child Struct
        
        Args:
            struct (PyTestChildStruct):
        """
        ...
    def func_taking_field_path(self, field_path: FieldPath) -> None:
        r"""
        x.func_taking_field_path(field_path) -> None
        Func Taking Field Path
        
        Args:
            field_path (FieldPath):
        """
        ...
    def func_blueprint_native_ref(self, out_struct: PyTestStruct) -> PyTestStruct:
        r"""
        x.func_blueprint_native_ref(out_struct) -> PyTestStruct
        Func Blueprint Native Ref
        
        Args:
            out_struct (PyTestStruct): 
        
        Returns:
            PyTestStruct: 
        
            out_struct (PyTestStruct):
        """
        ...
    def func_blueprint_native(self, value: int) -> int:
        r"""
        x.func_blueprint_native(value) -> int32
        Func Blueprint Native
        
        Args:
            value (int32): 
        
        Returns:
            int32:
        """
        ...
    def func_blueprint_implementable_packed_getter(self) -> Optional[int]:
        r"""
        x.func_blueprint_implementable_packed_getter() -> int32 or None
        Func Blueprint Implementable Packed Getter
        
        Returns:
            int32 or None: 
        
            out_value (int32):
        """
        ...
    def func_blueprint_implementable(self, value: int) -> int:
        r"""
        x.func_blueprint_implementable(value) -> int32
        Func Blueprint Implementable
        
        Args:
            value (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def emit_script_warning(cls) -> None:
        r"""
        X.emit_script_warning() -> None
        Emit Script Warning
        """
        ...
    @classmethod
    def emit_script_error(cls) -> None:
        r"""
        X.emit_script_error() -> None
        Emit Script Error
        """
        ...
    def delegate_property_callback(self, value: int) -> int:
        r"""
        x.delegate_property_callback(value) -> int32
        UHT couldn't parse any default value for the FieldPath.
        
        Args:
            value (int32): 
        
        Returns:
            int32:
        """
        ...
    def call_func_blueprint_native_ref(self, out_struct: PyTestStruct) -> PyTestStruct:
        r"""
        x.call_func_blueprint_native_ref(out_struct) -> PyTestStruct
        Call Func Blueprint Native Ref
        
        Args:
            out_struct (PyTestStruct): 
        
        Returns:
            PyTestStruct: 
        
            out_struct (PyTestStruct):
        """
        ...
    def call_func_blueprint_native(self, value: int) -> int:
        r"""
        x.call_func_blueprint_native(value) -> int32
        Call Func Blueprint Native
        
        Args:
            value (int32): 
        
        Returns:
            int32:
        """
        ...
    def call_func_blueprint_implementable_packed_getter(self) -> Optional[int]:
        r"""
        x.call_func_blueprint_implementable_packed_getter() -> int32 or None
        Call Func Blueprint Implementable Packed Getter
        
        Returns:
            int32 or None: 
        
            out_value (int32):
        """
        ...
    def call_func_blueprint_implementable(self, value: int) -> int:
        r"""
        x.call_func_blueprint_implementable(value) -> int32
        Call Func Blueprint Implementable
        
        Args:
            value (int32): 
        
        Returns:
            int32:
        """
        ...
    def func_interface_child(self, value: int) -> int:
        r"""
        x.func_interface_child(value) -> int32
        Func Interface Child
        
        Args:
            value (int32): 
        
        Returns:
            int32:
        """
        ...
    def func_interface(self, value: int) -> int:
        r"""
        x.func_interface(value) -> int32
        Func Interface
        
        Args:
            value (int32): 
        
        Returns:
            int32:
        """
        ...
    def func_interface_other(self, value: int) -> int:
        r"""
        x.func_interface_other(value) -> int32
        Func Interface Other
        
        Args:
            value (int32): 
        
        Returns:
            int32:
        """
        ...
    def is_bool_set(self) -> bool:
        r"""
        x.is_bool_set() -> bool
        Is Bool Set
        
        Returns:
            bool:
        """
        ...
    CONSTANT_VALUE: int #: (int32): Get Constant Value
    OTHER_CONSTANT_VALUE: int #: (int32): Get Other Constant Value

class PyTestChildObject(PyTestObject):
    r"""
    Object to allow testing of inheritance on Python wrapped types.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool`` (bool):  [Read-Write]
    - ``bool_defaults_only`` (bool):  [Read-Write]
    - ``bool_instance_only`` (bool):  [Read-Write]
    - ``child_struct`` (PyTestChildStruct):  [Read-Write]
    - ``delegate`` (PyTestDelegate):  [Read-Write]
    - ``enum`` (PyTestEnum):  [Read-Write]
    - ``field_path`` (FieldPath):  [Read-Write]
    - ``float`` (float):  [Read-Write]
    - ``int`` (int32):  [Read-Write]
    - ``multicast_delegate`` (PyTestMulticastDelegate):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``string`` (str):  [Read-Write]
    - ``string_array`` (Array[str]):  [Read-Write]
    - ``string_int_map`` (Map[str, int32]):  [Read-Write]
    - ``string_set`` (Set[str]):  [Read-Write]
    - ``struct`` (PyTestStruct):  [Read-Write]
    - ``struct_array`` (Array[PyTestStruct]):  [Read-Write]
    - ``struct_field_path`` (FieldPath):  [Read-Write]
    - ``text`` (Text):  [Read-Write]
    """
    ...

class LegacyPyTestObject(PyTestObject):
    r"""
    Object to test deprecation of Python wrapped types.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool`` (bool):  [Read-Write]
    - ``bool_defaults_only`` (bool):  [Read-Write]
    - ``bool_instance_only`` (bool):  [Read-Write]
    - ``child_struct`` (PyTestChildStruct):  [Read-Write]
    - ``delegate`` (PyTestDelegate):  [Read-Write]
    - ``enum`` (PyTestEnum):  [Read-Write]
    - ``field_path`` (FieldPath):  [Read-Write]
    - ``float`` (float):  [Read-Write]
    - ``int`` (int32):  [Read-Write]
    - ``multicast_delegate`` (PyTestMulticastDelegate):  [Read-Write]
    - ``name`` (Name):  [Read-Write]
    - ``string`` (str):  [Read-Write]
    - ``string_array`` (Array[str]):  [Read-Write]
    - ``string_int_map`` (Map[str, int32]):  [Read-Write]
    - ``string_set`` (Set[str]):  [Read-Write]
    - ``struct`` (PyTestStruct):  [Read-Write]
    - ``struct_array`` (Array[PyTestStruct]):  [Read-Write]
    - ``struct_field_path`` (FieldPath):  [Read-Write]
    - ``text`` (Text):  [Read-Write]
    """
    ...

class PyTestObjectLibrary(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto the test object in Python.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    """
    @classmethod
    def is_bool_set(cls, obj: PyTestObject) -> bool:
        r"""
        X.is_bool_set(obj) -> bool
        Is Bool Set
        
        Args:
            obj (PyTestObject): 
        
        Returns:
            bool:
        """
        ...

class PyTestStructDelegate(Object):
    r"""
    This class along with UPyTestVectorDelegate verify that 2 UObjects with the same delegate name/type, do not collide.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_name_collision_test_delegate`` (OnNameCollisionDelegate):  [Read-Write] Called when a new item is selected in the combobox.
    """
    @property
    def on_name_collision_test_delegate(self) -> OnNameCollisionDelegate:
        r"""
        (OnNameCollisionDelegate):  [Read-Write] Called when a new item is selected in the combobox.
        """
        ...
    @on_name_collision_test_delegate.setter
    def on_name_collision_test_delegate(self, value: OnNameCollisionDelegate) -> None:
        ...

class PyTestVectorDelegate(Object):
    r"""
    This class along with UPyTestStructDelegate verify that 2 UObjects with the same delegate name/type, do not collide.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_name_collision_test_delegate`` (OnNameCollisionDelegate):  [Read-Write] Called when a new item is selected in the combobox.
    """
    @property
    def on_name_collision_test_delegate(self) -> OnNameCollisionDelegate:
        r"""
        (OnNameCollisionDelegate):  [Read-Write] Called when a new item is selected in the combobox.
        """
        ...
    @on_name_collision_test_delegate.setter
    def on_name_collision_test_delegate(self, value: OnNameCollisionDelegate) -> None:
        ...

class PyTestTypeHint(Object):
    r"""
    Used to verify if the generated Python stub is correctly type-hinted (if type hint is enabled). The stub is generated
    * in the project intermediate folder when the Python developer mode is enabled (Editor preferences). The type hints can
    * be checked in the stub itself or PythonScriptPlugin/Content/Python/test_type_hints.py can be loaded in a Python IDE that
    * supports type checking and look at the code to verify that there is not problems with the types.
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyTest.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool_prop`` (bool):  [Read-Write] Check type hinted properties (setter/getter)
    - ``delegate_prop`` (PyTestDelegate):  [Read-Write]
    - ``enum_prop`` (PyTestEnum):  [Read-Write]
    - ``field_path_prop`` (FieldPath):  [Read-Write]
    - ``float_prop`` (float):  [Read-Write]
    - ``int_prop`` (int32):  [Read-Write]
    - ``map_prop`` (Map[int32, str]):  [Read-Write]
    - ``multicast_delegate_prop`` (PyTestMulticastDelegate):  [Read-Write]
    - ``name_array_prop`` (Array[Name]):  [Read-Write]
    - ``name_prop`` (Name):  [Read-Write]
    - ``object_array_prop`` (Array[Object]):  [Read-Write]
    - ``object_prop`` (PyTestObject):  [Read-Write]
    - ``set_prop`` (Set[str]):  [Read-Write]
    - ``slate_tick_delegate`` (PyTestSlateTickDelegate):  [Read-Write] Members to facilitate testing particular Python API.
    - ``str_array_prop`` (Array[str]):  [Read-Write]
    - ``string_prop`` (str):  [Read-Write]
    - ``struct_prop`` (PyTestStruct):  [Read-Write]
    - ``text_array_prop`` (Array[Text]):  [Read-Write]
    - ``text_prop`` (Text):  [Read-Write]
    """
    @property
    def bool_prop(self) -> bool:
        r"""
        (bool):  [Read-Write] Check type hinted properties (setter/getter)
        """
        ...
    @bool_prop.setter
    def bool_prop(self, value: bool) -> None:
        ...
    @property
    def int_prop(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @int_prop.setter
    def int_prop(self, value: int) -> None:
        ...
    @property
    def float_prop(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @float_prop.setter
    def float_prop(self, value: float) -> None:
        ...
    @property
    def enum_prop(self) -> PyTestEnum:
        r"""
        (PyTestEnum):  [Read-Write]
        """
        ...
    @enum_prop.setter
    def enum_prop(self, value: PyTestEnum) -> None:
        ...
    @property
    def string_prop(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @string_prop.setter
    def string_prop(self, value: str) -> None:
        ...
    @property
    def name_prop(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @name_prop.setter
    def name_prop(self, value: Name) -> None:
        ...
    @property
    def text_prop(self) -> Text:
        r"""
        (Text):  [Read-Write]
        """
        ...
    @text_prop.setter
    def text_prop(self, value: Text) -> None:
        ...
    @property
    def field_path_prop(self) -> FieldPath:
        r"""
        (FieldPath):  [Read-Write]
        """
        ...
    @field_path_prop.setter
    def field_path_prop(self, value: FieldPath) -> None:
        ...
    @property
    def struct_prop(self) -> PyTestStruct:
        r"""
        (PyTestStruct):  [Read-Write]
        """
        ...
    @struct_prop.setter
    def struct_prop(self, value: PyTestStruct) -> None:
        ...
    @property
    def object_prop(self) -> PyTestObject:
        r"""
        (PyTestObject):  [Read-Write]
        """
        ...
    @object_prop.setter
    def object_prop(self, value: PyTestObject) -> None:
        ...
    @property
    def str_array_prop(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write]
        """
        ...
    @str_array_prop.setter
    def str_array_prop(self, value: Array[str]) -> None:
        ...
    @property
    def name_array_prop(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write]
        """
        ...
    @name_array_prop.setter
    def name_array_prop(self, value: Array[Name]) -> None:
        ...
    @property
    def text_array_prop(self) -> Array[Text]:
        r"""
        (Array[Text]):  [Read-Write]
        """
        ...
    @text_array_prop.setter
    def text_array_prop(self, value: Array[Text]) -> None:
        ...
    @property
    def object_array_prop(self) -> Array[Object]:
        r"""
        (Array[Object]):  [Read-Write]
        """
        ...
    @object_array_prop.setter
    def object_array_prop(self, value: Array[Object]) -> None:
        ...
    @property
    def set_prop(self) -> Set[str]:
        r"""
        (Set[str]):  [Read-Write]
        """
        ...
    @set_prop.setter
    def set_prop(self, value: Set[str]) -> None:
        ...
    @property
    def map_prop(self) -> Map[int, str]:
        r"""
        (Map[int32, str]):  [Read-Write]
        """
        ...
    @map_prop.setter
    def map_prop(self, value: Map[int, str]) -> None:
        ...
    @property
    def delegate_prop(self) -> PyTestDelegate:
        r"""
        (PyTestDelegate):  [Read-Write]
        """
        ...
    @delegate_prop.setter
    def delegate_prop(self, value: PyTestDelegate) -> None:
        ...
    @property
    def multicast_delegate_prop(self) -> PyTestMulticastDelegate:
        r"""
        (PyTestMulticastDelegate):  [Read-Write]
        """
        ...
    @multicast_delegate_prop.setter
    def multicast_delegate_prop(self, value: PyTestMulticastDelegate) -> None:
        ...
    @property
    def slate_tick_delegate(self) -> PyTestSlateTickDelegate:
        r"""
        (PyTestSlateTickDelegate):  [Read-Write] Members to facilitate testing particular Python API.
        """
        ...
    @slate_tick_delegate.setter
    def slate_tick_delegate(self, value: PyTestSlateTickDelegate) -> None:
        ...
    @classmethod
    def check_tuple_return_type(cls, out_string: str) -> Tuple[int, str]:
        r"""
        X.check_tuple_return_type(out_string) -> (int32, out_string=str)
        Check Tuple Return Type
        
        Args:
            out_string (str): 
        
        Returns:
            str: 
        
            out_string (str):
        """
        ...
    def check_text_type_hints(self, param1: Text, param2: Text = "Hi") -> Text:
        r"""
        x.check_text_type_hints(param1, param2="Hi") -> Text
        Check Text Type Hints
        
        Args:
            param1 (Text): 
            param2 (Text): 
        
        Returns:
            Text:
        """
        ...
    def check_struct_type_hints(self, param1: PyTestStruct, param2: PyTestStruct = [False, 0, 0.000000, PyTestEnum.ONE, "", "None", "", FieldPath(), FieldPath(), [], [], {}, False]) -> PyTestStruct:
        r"""
        x.check_struct_type_hints(param1, param2=[False, 0, 0.000000, PyTestEnum.ONE, "", "None", "", FieldPath(), FieldPath(), [], [], {}, False]) -> PyTestStruct
        Check Struct Type Hints
        
        Args:
            param1 (PyTestStruct): 
            param2 (PyTestStruct): 
        
        Returns:
            PyTestStruct:
        """
        ...
    def check_string_type_hints(self, param1: str, param2: str = "Hi") -> str:
        r"""
        x.check_string_type_hints(param1, param2="Hi") -> str
        Check String Type Hints
        
        Args:
            param1 (str): 
            param2 (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def check_static_function(cls, param1: bool, param2: int, param3: float, param4: str) -> bool:
        r"""
        X.check_static_function(param1, param2, param3, param4) -> bool
        Check Static Function
        
        Args:
            param1 (bool): 
            param2 (int32): 
            param3 (double): 
            param4 (str): 
        
        Returns:
            bool:
        """
        ...
    def check_set_type_hints(self, param1: Set[str], param2: Set[Name], param3: Set[Object]) -> Set[Name]:
        r"""
        x.check_set_type_hints(param1, param2, param3) -> Set[Name]
        Check Set Type Hints
        
        Args:
            param1 (Set[str]): 
            param2 (Set[Name]): 
            param3 (Set[Object]): 
        
        Returns:
            Set[Name]:
        """
        ...
    def check_object_type_hints(self, param1: PyTestObject, param4: PyTestObject = None) -> PyTestObject:
        r"""
        x.check_object_type_hints(param1, param4=None) -> PyTestObject
        Check Object Type Hints
        
        Args:
            param1 (PyTestObject): 
            param4 (PyTestObject): 
        
        Returns:
            PyTestObject:
        """
        ...
    def check_name_type_hints(self, param1: Name, param2: Name = "Hi") -> Name:
        r"""
        x.check_name_type_hints(param1, param2="Hi") -> Name
        Check Name Type Hints
        
        Args:
            param1 (Name): 
            param2 (Name): 
        
        Returns:
            Name:
        """
        ...
    def check_map_type_hints(self, param1: Map[int, str], param2: Map[int, Name], param3: Map[int, Text], param4: Map[int, Object]) -> Map[str, Object]:
        r"""
        x.check_map_type_hints(param1, param2, param3, param4) -> Map[str, Object]
        Check Map Type Hints
        
        Args:
            param1 (Map[int32, str]): 
            param2 (Map[int32, Name]): 
            param3 (Map[int32, Text]): 
            param4 (Map[int32, Object]): 
        
        Returns:
            Map[str, Object]:
        """
        ...
    def check_integer_type_hints(self, param1: int, param2: int = 4, param3: int = 5) -> int:
        r"""
        x.check_integer_type_hints(param1, param2=4, param3=5) -> int32
        Check Integer Type Hints
        
        Args:
            param1 (uint8): 
            param2 (int32): 
            param3 (int64): 
        
        Returns:
            int32:
        """
        ...
    def check_float_type_hints(self, param1: float, param2: float, param3: float = -3.300000, param4: float = 4.400000) -> float:
        r"""
        x.check_float_type_hints(param1, param2, param3=-3.300000, param4=4.400000) -> double
        Check Float Type Hints
        
        Args:
            param1 (float): 
            param2 (double): 
            param3 (float): 
            param4 (double): 
        
        Returns:
            double:
        """
        ...
    def check_field_path_type_hints(self, param1: FieldPath) -> FieldPath:
        r"""
        x.check_field_path_type_hints(param1) -> FieldPath
        Check Field Path Type Hints
        
        Args:
            param1 (FieldPath): 
        
        Returns:
            FieldPath:
        """
        ...
    def check_enum_type_hints(self, param1: PyTestEnum, param2: PyTestEnum = PyTestEnum.ONE) -> PyTestEnum:
        r"""
        x.check_enum_type_hints(param1, param2=PyTestEnum.ONE) -> PyTestEnum
        Check Enum Type Hints
        
        Args:
            param1 (PyTestEnum): 
            param2 (PyTestEnum): 
        
        Returns:
            PyTestEnum:
        """
        ...
    def check_delegate_type_hints(self, param1: PyTestDelegate) -> PyTestDelegate:
        r"""
        x.check_delegate_type_hints(param1) -> PyTestDelegate
        Check Delegate Type Hints
        
        Args:
            param1 (PyTestDelegate): 
        
        Returns:
            PyTestDelegate:
        """
        ...
    def check_bool_type_hints(self, param1: bool, param2: bool = True, param3: bool = False) -> bool:
        r"""
        x.check_bool_type_hints(param1, param2=True, param3=False) -> bool
        Check type hinted methods.
        
        Args:
            param1 (bool): 
            param2 (bool): 
            param3 (bool): 
        
        Returns:
            bool:
        """
        ...
    def check_array_type_hints(self, param1: Array[str], param2: Array[Name], param3: Array[Text], param4: Array[Object]) -> Array[Text]:
        r"""
        x.check_array_type_hints(param1, param2, param3, param4) -> Array[Text]
        Check Array Type Hints
        
        Args:
            param1 (Array[str]): 
            param2 (Array[Name]): 
            param3 (Array[Text]): 
            param4 (Array[Object]): 
        
        Returns:
            Array[Text]:
        """
        ...
    STR_CONST: str #: (str): Check type hinted constants
    INT_CONST: int #: (int32): Get Int Const

class PythonScriptLibrary(BlueprintFunctionLibrary):
    r"""
    Python Script Library
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PythonScriptLibrary.h
    
    """
    @classmethod
    def is_python_available(cls) -> bool:
        r"""
        X.is_python_available() -> bool
        Check to see whether Python support is available in the current build.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def execute_python_command_ex(cls, python_command: str, execution_mode: PythonCommandExecutionMode = PythonCommandExecutionMode.EXECUTE_FILE, file_execution_scope: PythonFileExecutionScope = PythonFileExecutionScope.PRIVATE) -> Optional[Tuple[str, Array[PythonLogOutputEntry]]]:
        r"""
        X.execute_python_command_ex(python_command, execution_mode=PythonCommandExecutionMode.EXECUTE_FILE, file_execution_scope=PythonFileExecutionScope.PRIVATE) -> (command_result=str, log_output=Array[PythonLogOutputEntry]) or None
        Execute the given Python command.
        
        Args:
            python_command (str): The command to run. This may be literal Python code, or a file (with optional arguments) that you want to run.
            execution_mode (PythonCommandExecutionMode): Controls the mode used to execute the command.
            file_execution_scope (PythonFileExecutionScope): Controls the scope used when executing Python files.
        
        Returns:
            tuple or None: true if the command ran successfully, false if there were errors.
        
            command_result (str): The result of running the command. On success, for EvaluateStatement mode this will be the actual result of running the command, and will be None in all other cases. On failure, this will be the error information (typically a Python exception trace).
        
            log_output (Array[PythonLogOutputEntry]): The log output captured while running the command.
        """
        ...
    @classmethod
    def execute_python_command(cls, python_command: str) -> bool:
        r"""
        X.execute_python_command(python_command) -> bool
        Execute the given Python command.
        
        Args:
            python_command (str): The command to run. This may be literal Python code, or a file (with optional arguments) that you want to run.
        
        Returns:
            bool: true if the command ran successfully, false if there were errors (the output log will show the errors).
        """
        ...

class PythonObjectHandle(Object):
    r"""
    Handle object to wrap a Python object for use as a UPROPERTY on a UCLASS or USTRUCT.
    This allows Python generated types to store arbitrary Python objects as native properties,
    rather than rely on the lifetime of the Python wrapper object to keep a non-property object reference alive.
    
    The following functions are available in Python script to interact with these handles:
      - unreal.create_python_object_handle(obj) -> handle  - Creates an unreal.PythonObjectHandle from a given PyObject.
      - unreal.resolve_python_object_handle(handle) -> obj - Resolves an unreal.PythonObjectHandle to its PyObject, or None.
      - unreal.destroy_python_object_handle(handle)        - Destroys an unreal.PythonObjectHandle (clearing its PyObject reference).
    
    Manually calling destroy is optional, but can be useful when you need to *immediately* clean-up a reference to the wrapped
    Python object, rather than wait for UE GC to clean it up at an arbitrary point in the future.
    
    This can be used to create a property on Python generated types via the standard unreal.uproperty syntax, eg):
      MyObjectHandleProperty = unreal.uproperty(unreal.PythonObjectHandle)
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyWrapperBase.h
    
    """
    ...

class PythonGeneratedClass(Class):
    r"""
    An Unreal class that was generated from a Python type
    
    **C++ Source:**
    
    - **Plugin**: PythonScriptPlugin
    - **Module**: PythonScriptPlugin
    - **File**: PyWrapperObject.h
    
    """
    ...

class BlackboardKeyType(Object):
    r"""
    Blackboard Key Type
    
    **C++ Source:**
    
    - **Module**: AIModule
    - **File**: BlackboardKeyType.h
    
    """
    ...

class Level(Object):
    r"""
    A Level is a collection of Actors (lights, volumes, mesh instances etc.).
    Multiple Levels can be loaded and unloaded into the World to create a streaming experience.
    see: https://docs.unrealengine.com/latest/INT/Engine/Levels
    see: UActor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Level.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``lightmap_total_size`` (float):  [Read-Only] Total number of KB used for lightmap textures in the level.
    - ``shadowmap_total_size`` (float):  [Read-Only] Total number of KB used for shadowmap textures in the level.
    - ``use_actor_folders`` (bool):  [Read-Write] Use actor folder objects, actor folders of this level will be persistent in their own object.
    - ``use_external_actors`` (bool):  [Read-Write] Use external actors, new actor spawned in this level will be external and existing external actors will be loaded on load.
    """
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class RigVMMemoryStorage(Object):
    r"""
    The URigVMMemoryStorage represents an instance of heterogeneous memory.
    The memory layout is defined by the URigVMMemoryStorageGeneratorClass.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVM
    - **File**: RigVMMemoryStorage.h
    
    """
    ...

class Player(Object):
    r"""
    Player
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Player.h
    
    """
    ...

class LocalPlayer(Player):
    r"""
    Each player that is active on the current client/listen server has a LocalPlayer.
    It stays active across maps, and there may be several spawned in the case of splitscreen/coop.
    There will be 0 spawned on dedicated servers.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: LocalPlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``sent_split_join`` (bool):  [Read-Only] set when we've sent a split join request
    """
    ...

class UserWidgetExtension(Object):
    r"""
    UserWidgetExtension is the base class for components that define reusable behavior that can be added to different types of Widgets.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: UserWidgetExtension.h
    
    """
    ...

class FieldSystem(Object):
    r"""
    Field System
    
    **C++ Source:**
    
    - **Module**: FieldSystemEngine
    - **File**: FieldSystemAsset.h
    
    """
    ...

class ThumbnailInfo(Object):
    r"""
    Thumbnail Info
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: ThumbnailInfo.h
    
    """
    ...

class BrushBuilder(Object):
    r"""
    Base class of UnrealEd brush builders.
    
    
    Tips for writing brush builders:
    
    - Always validate the user-specified and call BadParameters function
      if anything is wrong, instead of actually building geometry.
      If you build an invalid brush due to bad user parameters, you'll
      cause an extraordinary amount of pain for the poor user.
    
    - When generating polygons with more than 3 vertices, BE SURE all the
      polygon's vertices are coplanar!  Out-of-plane polygons will cause
      geometry to be corrupted.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BrushBuilder.h
    
    """
    ...

class NavigationSystemConfig(Object):
    r"""
    Navigation System Config
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavigationSystemConfig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``default_agent_name`` (Name):  [Read-Write] If not None indicates which of navigation datas and supported agents are
      going to be used as the default ones. If navigation agent of this type does
      not exist or is not enabled then the first available nav data will be used
      as the default one
    - ``is_overriden`` (bool):  [Read-Only] If true it means the navigation system settings are overridden from another source (like a NavConfigOverrideActor)
    - ``navigation_system_class`` (SoftClassPath):  [Read-Write]
    - ``supported_agents_mask`` (NavAgentSelector):  [Read-Write] NavigationSystem's properties in Project Settings define all possible supported agents,
          but a specific navigation system can choose to support only a subset of agents.
    """
    ...

class ClothConfigBase(Object):
    r"""
    Base class for simulator specific simulation controls.
    Each cloth instance on a skeletal mesh can have a unique cloth config
    
    **C++ Source:**
    
    - **Module**: ClothingSystemRuntimeInterface
    - **File**: ClothConfigBase.h
    
    """
    ...

class Package(Object):
    r"""
    Package
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: 
    
    """
    ...

class AnimGraphNodeBinding(Object):
    r"""
    Anim Graph Node Binding
    
    **C++ Source:**
    
    - **Module**: AnimGraph
    - **File**: AnimGraphNodeBinding.h
    
    """
    ...

class MeshDeformer(Object):
    r"""
    Base class for mesh deformer assets.
    Mesh deformers can be added to mesh components to implement flexible deformation systems.
    A UMeshDeformer needs to implement creation of a UMeshDeformerInstance which will apply deformer actions and store deformer state.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshDeformer.h
    
    """
    ...

class MeshDeformerInstanceSettings(Object):
    r"""
    Base class for mesh deformers instance settings.
    This contains the serialized user settings to apply to the UMeshDeformer.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshDeformerInstance.h
    
    """
    ...

class MeshDeformerInstance(Object):
    r"""
    Base class for mesh deformers instances.
    This contains the transient per instance state for a UMeshDeformer.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MeshDeformerInstance.h
    
    """
    ...

class BlueprintGeneratedClass(Class):
    r"""
    Blueprint Generated Class
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlueprintGeneratedClass.h
    
    """
    ...

class LevelSequenceDirectorGeneratedClass(BlueprintGeneratedClass):
    r"""
    deprecated: 'LevelSequenceDirectorGeneratedClass' was renamed to 'BlueprintGeneratedClass'.
    """
    ...

class AnimBlueprintGeneratedClass(BlueprintGeneratedClass):
    r"""
    Anim Blueprint Generated Class
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimBlueprintGeneratedClass.h
    
    """
    ...

class VimGeneratedClass(AnimBlueprintGeneratedClass):
    r"""
    deprecated: 'VimGeneratedClass' was renamed to 'AnimBlueprintGeneratedClass'.
    """
    ...

class VariableFrameStrippingSettings(Object):
    r"""
    * This is a wrapper for the Variable frame stripping Codec.
    * It allows for the mass changing of settings on animation sequences in an editor accessible way.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VariableFrameStrippingSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``frame_stripping_rate`` (PerPlatformInt):  [Read-Write] The number of Frames that are stripped down to one.
      Allows for overrides of that multiplier.
      FrameStrippingRate == 1 would strip no frames, Therefore this is clamped to 2.
    - ``use_variable_frame_stripping`` (PerPlatformBool):  [Read-Write] Enables the change from standard 1/2 frame stripping to stripping a higher amount of frames per frame kept
    """
    ...

class AnimCurveCompressionSettings(Object):
    r"""
    * This object is used to wrap a curve compression codec. It allows a clean integration in the editor by avoiding the need
    * to create asset types and factory wrappers for every codec.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCurveCompressionSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``codec`` (AnimCurveCompressionCodec):  [Read-Write] An animation curve compression codec.
    """
    ...

class AnimBoneCompressionSettings(Object):
    r"""
    * This object is used to wrap a bone compression codec. It allows a clean integration in the editor by avoiding the need
    * to create asset types and factory wrappers for every codec.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimBoneCompressionSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``codecs`` (Array[AnimBoneCompressionCodec]):  [Read-Write] A list of animation bone compression codecs to try. Empty entries are ignored but the array cannot be empty.
    - ``error_threshold`` (float):  [Read-Write] When compressing, the best codec below this error threshold will be used.
    - ``force_below_threshold`` (bool):  [Read-Write] Any codec (even one that increases the size) with a lower error will be used until it falls below the threshold.
    """
    ...

class AssetMappingTable(Object):
    r"""
    UAssetMappingTable : that has AssetMappingTableging data
            - used for retargeting
            - support to share different animations
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AssetMappingTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``mapped_assets`` (Array[AssetMapping]):  [Read-Only] Mappin of asset between source and target *
    """
    ...

class AudioPropertiesSheetAssetBase(Object):
    r"""
    Audio Properties Sheet Asset Base
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: AudioPropertiesSheetAssetBase.h
    
    """
    ...

class AudioPropertiesBindings(Object):
    r"""
    Audio Properties Bindings
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: AudioPropertiesBindings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``object_property_to_sheet_property_map`` (Map[Name, Name]):  [Read-Write]
    """
    ...

class WaveformTransformationBase(Object):
    r"""
    Base class to hold editor configurable properties for an arbitrary transformation of audio waveform data
    
    **C++ Source:**
    
    - **Module**: AudioExtensions
    - **File**: IWaveformTransformation.h
    
    """
    ...

class MovieSceneBindingOverrides(Object):
    r"""
    A one-to-many definition of movie scene object binding IDs to overridden objects that should be bound to that binding.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieSceneBindingOverrides.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``binding_data`` (Array[MovieSceneBindingOverrideData]):  [Read-Write] The actual binding data
    """
    ...

class Layer(Object):
    r"""
    Layer
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Layer.h
    
    """
    ...

class SubsurfaceProfile(Object):
    r"""
    Subsurface Scattering profile asset, can be specified at the material. Only for "Subsurface Profile" materials, is use during Screenspace Subsurface Scattering
    Don't change at runtime. All properties in here are per material - texture like variations need to come from properties that are in the GBuffer.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SubsurfaceProfile.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SubsurfaceProfileStruct):  [Read-Write]
    """
    ...

class NeuralProfile(Object):
    r"""
    This class represents assets that stores the neural network model data and the conversion from/to the model.
    
    Neural network model profile typically consist of a neural network model data and the config of preprocessing/post-processing
    of applying this neural network model.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NeuralProfile.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (NeuralProfileStruct):  [Read-Write]
    """
    ...

class PropertyEditorTestInstancedObject(Object):
    r"""
    Property Editor Test Instanced Object
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: PropertyEditorTestObject.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``number`` (int32):  [Read-Write]
    """
    ...

class FontImportOptions(Object):
    r"""
    Holds options for importing fonts.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: FontImportOptions.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data`` (FontImportOptionsData):  [Read-Write] The actual data for this object.  We wrap it in a struct so that we can copy it around between objects.
    """
    ...

class LandscapeInfo(Object):
    r"""
    Landscape Info
    
    **C++ Source:**
    
    - **Module**: Landscape
    - **File**: LandscapeInfo.h
    
    """
    ...

class AnalysisProperties(Object):
    r"""
    The base class for properties to be used in analysis. Engine will inherit from this to define structures used for
    the functions it supports. User-defined functions will likely need their own analysis structures inheriting from
    this too.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BlendSpace.h
    
    """
    ...

class SpecularProfile(Object):
    r"""
    Specular profile asset, can be specified at a material.
    Don't change at runtime. All properties in here are per material.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: SpecularProfile.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SpecularProfileStruct):  [Read-Write]
    """
    ...

class VectorField(Object):
    r"""
    Vector Field
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: VectorField.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bounds`` (Box):  [Read-Write] Bounds of the volume in local space.
    - ``intensity`` (float):  [Read-Write] The intensity with which to multiplie vectors in this field.
    """
    ...

class WorldPartition(Object):
    r"""
    World Partition
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: WorldPartition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_showing_hlo_ds_in_editor`` (bool):  [Read-Write] Whether HLODs should be allowed to be displayed in the editor for this map
    - ``data_layers_logic_operator`` (WorldPartitionDataLayersLogicOperator):  [Read-Write]
    - ``default_hlod_layer`` (HLODLayer):  [Read-Write] Default HLOD layer
    - ``server_streaming_mode`` (WorldPartitionServerStreamingMode):  [Read-Write]
    - ``server_streaming_out_mode`` (WorldPartitionServerStreamingOutMode):  [Read-Write]
    """
    ...

class CameraShakePattern(Object):
    r"""
    A shake "pattern" defines how a camera should be effectively shaken. Examples of shake patterns
    are sinewave oscillation, perlin noise, or FBX animation.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: CameraShakeBase.h
    
    """
    ...

class HLODProxy(Object):
    r"""
    This asset acts as a proxy to a static mesh for ALODActors to display
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``hlod_actors`` (Map[HLODProxyDesc, HLODProxyMesh]):  [Read-Only]
    - ``owning_map`` (World):  [Read-Only] Keep hold of the level in the editor to allow for package cleaning etc.
    - ``proxy_meshes`` (Array[HLODProxyMesh]):  [Read-Only] All the mesh proxies we contain
    """
    ...

class MorphTarget(Object):
    r"""
    Morph Target
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: MorphTarget.h
    
    """
    ...

class BodySetupCore(Object):
    r"""
    Body Setup Core
    
    **C++ Source:**
    
    - **Module**: PhysicsCore
    - **File**: BodySetupCore.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_name`` (Name):  [Read-Only] Used in the PhysicsAsset case. Associates this Body with Bone in a skeletal mesh.
    - ``collision_reponse`` (BodyCollisionResponse):  [Read-Write] Collision Type for this body. This eventually changes response to collision to others *
    - ``collision_trace_flag`` (CollisionTraceFlag):  [Read-Write] Collision Trace behavior - by default, it will keep simple(convex)/complex(per-poly) separate *
    - ``physics_type`` (PhysicsType):  [Read-Write] If simulated it will use physics, if kinematic it will not be affected by physics, but can interact with physically simulated bodies. Default will inherit from OwnerComponent's behavior.
    """
    ...

class BodySetup(BodySetupCore):
    r"""
    BodySetup contains all collision information that is associated with a single asset.
    A single BodySetup instance is shared among many BodyInstances so that geometry data is not duplicated.
    Assets typically implement a GetBodySetup function that is used during physics state creation.
    see: GetBodySetup
    see: FBodyInstance
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: BodySetup.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``agg_geom`` (KAggregateGeom):  [Read-Write] Simplified collision representation of this
    - ``bone_name`` (Name):  [Read-Only] Used in the PhysicsAsset case. Associates this Body with Bone in a skeletal mesh.
    - ``collision_reponse`` (BodyCollisionResponse):  [Read-Write] Collision Type for this body. This eventually changes response to collision to others *
    - ``collision_trace_flag`` (CollisionTraceFlag):  [Read-Write] Collision Trace behavior - by default, it will keep simple(convex)/complex(per-poly) separate *
    - ``consider_for_bounds`` (bool):  [Read-Write] Should this BodySetup be considered for the bounding box of the PhysicsAsset (and hence SkeletalMeshComponent).
      There is a speed improvement from having less BodySetups processed each frame when updating the bounds.
    - ``default_instance`` (BodyInstance):  [Read-Write] Default properties of the body instance, copied into objects on instantiation, was URB_BodyInstance
    - ``double_sided_geometry`` (bool):  [Read-Write] If true, the physics triangle mesh will use double sided faces when doing scene queries.
      This is useful for planes and single sided meshes that need traces to work on both sides.
    - ``never_needs_cooked_collision_data`` (bool):  [Read-Write] TODO Chaos this is to opt out of CreatePhysicsMeshes for certain meshes
      Better long term mesh is to not call CreatePhysicsMeshes until it is known there is a mesh instance that needs it.
    - ``phys_material`` (PhysicalMaterial):  [Read-Write] Physical material to use for simple collision on this body. Encodes information about density, friction etc.
    - ``physics_type`` (PhysicsType):  [Read-Write] If simulated it will use physics, if kinematic it will not be affected by physics, but can interact with physically simulated bodies. Default will inherit from OwnerComponent's behavior.
    - ``walkable_slope_override`` (WalkableSlopeOverride):  [Read-Write] Custom walkable slope setting for this body.
    """
    ...

class RB_BodySetup(BodySetup):
    r"""
    deprecated: 'RB_BodySetup' was renamed to 'BodySetup'.
    """
    ...

class NavCollisionBase(Object):
    r"""
    Nav Collision Base
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: NavCollisionBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_dynamic_obstacle`` (bool):  [Read-Write] If set, mesh will be used as dynamic obstacle (don't create navmesh on top, much faster adding/removing)
    """
    ...

class HLODBuilderSettings(Object):
    r"""
    Base class for all HLOD Builder settings
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODBuilder.h
    
    """
    ...

class ChaosCache(Object):
    r"""
    Chaos Cache
    
    **C++ Source:**
    
    - **Plugin**: ChaosCaching
    - **Module**: ChaosCaching
    - **File**: ChaosCache.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``num_recorded_frames`` (uint32):  [Read-Only]
    - ``recorded_duration`` (float):  [Read-Only]
    - ``spawnable`` (CacheSpawnableTemplate):  [Read-Only] Spawn template for an actor that can play this cache
    """
    ...

class DatasmithAdditionalData(Object):
    r"""
    Base class for all additional data storable on datasmith assets.
    usage:: Translator can push custom data on assets in order to exploit that data latter (
    see: UDatasmithCustomActionBase)
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithAdditionalData.h
    
    """
    ...

class DatasmithScene(Object):
    r"""
    Datasmith Scene
    
    **C++ Source:**
    
    - **Plugin**: DatasmithContent
    - **Module**: DatasmithContent
    - **File**: DatasmithScene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (DatasmithSceneImportData):  [Read-Write] Importing data and options used for this Datasmith scene
    - ``clothes`` (Map[Name, Object]):  [Read-Only] Map of all the cloth related to this Datasmith Scene
    - ``level_sequences`` (Map[Name, LevelSequence]):  [Read-Only] Map of all the level sequences related to this Datasmith Scene
    - ``level_variant_sets`` (Map[Name, LevelVariantSets]):  [Read-Only] Map of all the level variant sets related to this Datasmith Scene
    - ``material_functions`` (Map[Name, MaterialFunction]):  [Read-Only] Map of all the material functions related to this Datasmith Scene
    - ``materials`` (Map[Name, MaterialInterface]):  [Read-Only] Map of all the materials related to this Datasmith Scene
    - ``static_meshes`` (Map[Name, StaticMesh]):  [Read-Only] Map of all the static meshes related to this Datasmith Scene
    - ``textures`` (Map[Name, Texture]):  [Read-Only] Map of all the textures related to this Datasmith Scene
    """
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class RigVMSchema(Object):
    r"""
    The Schema is used to determine which actions are allowed
    on a graph. This includes any topological change.
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMDeveloper
    - **File**: RigVMSchema.h
    
    """
    ...

class AnimCurveCompressionCodec(Object):
    r"""
    * Base class for all curve compression codecs.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimCurveCompressionCodec.h
    
    """
    ...

class AnimBoneCompressionCodec(Object):
    r"""
    * Base class for all bone compression codecs.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AnimBoneCompressionCodec.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``description`` (str):  [Read-Write] Description for this codec.
    """
    ...

class HLODProxyDesc(Object):
    r"""
    Describe a LODActor
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: HLODProxyDesc.h
    
    """
    ...

class DEditorParameterValue(Object):
    r"""
    DEditor Parameter Value
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: DEditorParameterValue.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``override`` (bool):  [Read-Write]
    - ``parameter_info`` (MaterialParameterInfo):  [Read-Write]
    """
    ...

class Distribution(Object):
    r"""
    Distribution
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: Distribution.h
    
    """
    ...

class DistributionVector(Distribution):
    r"""
    Distribution Vector
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DistributionVector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_be_baked`` (bool):  [Read-Write] Can this variable be baked out to a FRawDistribution? Should be true 99% of the time
    """
    ...

class DistributionFloat(Distribution):
    r"""
    Distribution Float
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: DistributionFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``can_be_baked`` (bool):  [Read-Write] Can this variable be baked out to a FRawDistribution? Should be true 99% of the time
    """
    ...

class PlatformSettings(Object):
    r"""
    The base class of any per platform settings.  The pattern for using these is as follows.
    
    Step 1) Subclass UPlatformSettings, UMyPerPlatformSettings : public UPlatformSettings.
    
    Step 2) For your system should already have a UDeveloperSettings that you created so that
            users can customize other properties for your system in the project.  On that class
            you need to create a property of type FPerPlatformSettings, e.g.
            UPROPERTY(EditAnywhere, Category=Platform)
            FPerPlatformSettings PlatformOptions
    
    Step 3) In your UDeveloperSettings subclasses construct, there should be a line like this,
            PlatformOptions.Settings.Initialize(UMyPerPlatformSettings::StaticClass());
            This will actually ensure that you initialize the settings exposed in the editor to whatever
            the current platform configuration is for them.
    
    Step 4) Nothing else needed.  In your system code, you will just call
            UMyPerPlatformSettings* MySettings = UPlatformSettingsManager::Get().GetSettingsForPlatform<UMyPerPlatformSettings>()
            that will get you the current settings for the active platform, or the simulated platform in the editor.
    
    **C++ Source:**
    
    - **Module**: DeveloperSettings
    - **File**: PlatformSettings.h
    
    """
    ...

class AnimationSharingStateProcessor(Object):
    r"""
    Animation Sharing State Processor
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharing
    - **File**: AnimationSharingTypes.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animation_state_enum`` (Enum):  [Read-Write]
    """
    def process_actor_state(self, actor: Actor, current_state: int, on_demand_state: int) -> Tuple[int, bool]:
        r"""
        x.process_actor_state(actor, current_state, on_demand_state) -> (out_state=int32, should_process=bool)
        Process Actor State
        
        Args:
            actor (Actor): 
            current_state (uint8): 
            on_demand_state (uint8): 
        
        Returns:
            tuple: 
        
            out_state (int32): 
        
            should_process (bool):
        """
        ...
    def get_animation_state_enum(self) -> Enum:
        r"""
        x.get_animation_state_enum() -> Enum
        Get Animation State Enum
        
        Returns:
            Enum:
        """
        ...

class AnimSharingStateInstance(AnimInstance):
    r"""
    Anim Sharing State Instance
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharing
    - **File**: AnimationSharingInstances.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animation_to_play`` (AnimSequence):  [Read-Write]
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``permutation_time_offset`` (float):  [Read-Write]
    - ``play_rate`` (float):  [Read-Write]
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``state_bool`` (bool):  [Read-Write]
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    @property
    def animation_to_play(self) -> AnimSequence:
        r"""
        (AnimSequence):  [Read-Only]
        """
        ...
    @property
    def permutation_time_offset(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def play_rate(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def state_bool(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    def get_instanced_actors(self) -> Array[Actor]:
        r"""
        x.get_instanced_actors() -> Array[Actor]
        Get Instanced Actors
        
        Returns:
            Array[Actor]: 
        
            actors (Array[Actor]):
        """
        ...

class AnimSharingTransitionInstance(AnimInstance):
    r"""
    Anim Sharing Transition Instance
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharing
    - **File**: AnimationSharingInstances.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_bool`` (bool):  [Read-Write]
    - ``blend_time`` (float):  [Read-Write]
    - ``from_component`` (SkeletalMeshComponent):  [Read-Write]
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``to_component`` (SkeletalMeshComponent):  [Read-Write]
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    @property
    def from_component(self) -> SkeletalMeshComponent:
        r"""
        (SkeletalMeshComponent):  [Read-Only]
        """
        ...
    @property
    def to_component(self) -> SkeletalMeshComponent:
        r"""
        (SkeletalMeshComponent):  [Read-Only]
        """
        ...
    @property
    def blend_time(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def blend_bool(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class AnimSharingAdditiveInstance(AnimInstance):
    r"""
    Anim Sharing Additive Instance
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharing
    - **File**: AnimationSharingInstances.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additive_animation`` (AnimSequence):  [Read-Write]
    - ``alpha`` (float):  [Read-Write]
    - ``base_component`` (SkeletalMeshComponent):  [Read-Write]
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``state_bool`` (bool):  [Read-Write]
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    @property
    def base_component(self) -> SkeletalMeshComponent:
        r"""
        (SkeletalMeshComponent):  [Read-Only]
        """
        ...
    @property
    def additive_animation(self) -> AnimSequence:
        r"""
        (AnimSequence):  [Read-Only]
        """
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Only]
        """
        ...
    @property
    def state_bool(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...

class AnimationSharingManager(Object):
    r"""
    Animation Sharing Manager
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharing
    - **File**: AnimationSharingManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``per_skeleton_data`` (Array[AnimSharingInstance]):  [Read-Only] Sharing data required for the unique Skeleton setups
    """
    def register_actor_with_skeleton_bp(self, actor: Actor, sharing_skeleton: Skeleton) -> None:
        r"""
        x.register_actor_with_skeleton_bp(actor, sharing_skeleton) -> None
        Register an Actor with this Animation Sharing manager, according to the SharingSkeleton
        
        Args:
            actor (Actor): 
            sharing_skeleton (Skeleton):
        """
        ...
    @classmethod
    def get_animation_sharing_manager(cls, world_context_object: Object) -> AnimationSharingManager:
        r"""
        X.get_animation_sharing_manager(world_context_object) -> AnimationSharingManager
        Returns the AnimationSharing Manager, nullptr if none was set up
        
        Args:
            world_context_object (Object): 
        
        Returns:
            AnimationSharingManager:
        """
        ...
    @classmethod
    def create_animation_sharing_manager(cls, world_context_object: Object, setup: AnimationSharingSetup) -> bool:
        r"""
        X.create_animation_sharing_manager(world_context_object, setup) -> bool
        Create an Animation Sharing Manager using the provided Setup
        
        Args:
            world_context_object (Object): 
            setup (AnimationSharingSetup): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def animation_sharing_enabled(cls) -> bool:
        r"""
        X.animation_sharing_enabled() -> bool
        Returns whether or not the animation sharing is enabled
        
        Returns:
            bool:
        """
        ...

class AnimationSharingSetup(Object):
    r"""
    The Animation Sharing Setup asset contains all the information that will be shared across the specified Actors
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharing
    - **File**: AnimationSharingSetup.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``scalability_settings`` (AnimationSharingScalability):  [Read-Write]
    - ``skeleton_setups`` (Array[PerSkeletonAnimationSharingSetup]):  [Read-Write]
    """
    ...

class AnimSharingInstance(Object):
    r"""
    Anim Sharing Instance
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharing
    - **File**: AnimationSharingManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``registered_actors`` (Array[Actor]):  [Read-Only] Actors currently registered to be animation driven by the AnimManager using this setup
    - ``sharing_actor`` (Actor):  [Read-Only] Actor to which all the running SkeletalMeshComponents used for the sharing are attached to
    - ``state_enum`` (Enum):  [Read-Only] Enum class set up by the user to 'describe' the animation states
    - ``state_processor`` (AnimationSharingStateProcessor):  [Read-Write] (Blueprint)class instance used for determining the state enum value for each registered actor
    - ``used_animation_sequences`` (Array[AnimSequence]):  [Read-Only]
    """
    ...

class CableActor(Actor):
    r"""
    An actor that renders a simulated cable
    
    **C++ Source:**
    
    - **Plugin**: CableComponent
    - **Module**: CableComponent
    - **File**: CableActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``cable_component`` (CableComponent):  [Read-Only] Cable component that performs simulation and rendering
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def cable_component(self) -> CableComponent:
        r"""
        (CableComponent):  [Read-Only] Cable component that performs simulation and rendering
        """
        ...

class CableComponent(MeshComponent):
    r"""
    Component that allows you to specify custom triangle mesh geometry
    
    **C++ Source:**
    
    - **Plugin**: CableComponent
    - **Module**: CableComponent
    - **File**: CableComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attach_end`` (bool):  [Read-Write] Should we fix the end to something (using AttachEndTo and EndLocation), or leave it free.
      If false, AttachEndTo and EndLocation are just used for initial location of end of cable
    - ``attach_end_to`` (ComponentReference):  [Read-Write] Actor or Component that the defines the end position of the cable
    - ``attach_end_to_socket_name`` (Name):  [Read-Write] Socket name on the AttachEndTo component to attach to
    - ``attach_start`` (bool):  [Read-Write] Should we fix the start to something, or leave it free.
      If false, component transform is just used for initial location of start of cable
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cable_force`` (Vector):  [Read-Write] Force vector (world space) applied to all particles in cable.
    - ``cable_gravity_scale`` (float):  [Read-Write] Scaling applied to world gravity affecting this cable.
    - ``cable_length`` (float):  [Read-Write] Rest length of the cable
    - ``cable_width`` (float):  [Read-Write] How wide the cable geometry is
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``collision_friction`` (float):  [Read-Write] If collision is enabled, control how much sliding friction is applied when cable is in contact.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_collision`` (bool):  [Read-Write] EXPERIMENTAL. Perform sweeps for each cable particle, each substep, to avoid collisions with the world.
      Uses the Collision Preset on the component to determine what is collided with.
      This greatly increases the cost of the cable simulation.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``enable_stiffness`` (bool):  [Read-Write] Add stiffness constraints to cable.
    - ``end_location`` (Vector):  [Read-Write] End location of cable, relative to AttachEndTo (or AttachEndToSocketName) if specified, otherwise relative to cable component.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``num_segments`` (int32):  [Read-Write] How many segments the cable has
    - ``num_sides`` (int32):  [Read-Write] Number of sides of the cable geometry
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``skip_cable_update_when_not_owner_recently_rendered`` (bool):  [Read-Write]
    - ``skip_cable_update_when_not_visible`` (bool):  [Read-Write]
    - ``solver_iterations`` (int32):  [Read-Write] The number of solver iterations controls how 'stiff' the cable is
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``substep_time`` (float):  [Read-Write] Controls the simulation substep time for the cable
    - ``tile_material`` (float):  [Read-Write] How many times to repeat the material along the length of the cable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_substepping`` (bool):  [Read-Write] When false, will still wait for SubstepTime to elapse before updating, but will only run the cable simulation once using all of accumulated simulation time
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def attach_start(self) -> bool:
        r"""
        (bool):  [Read-Write] Should we fix the start to something, or leave it free.
        If false, component transform is just used for initial location of start of cable
        """
        ...
    @attach_start.setter
    def attach_start(self, value: bool) -> None:
        ...
    @property
    def attach_end(self) -> bool:
        r"""
        (bool):  [Read-Write] Should we fix the end to something (using AttachEndTo and EndLocation), or leave it free.
        If false, AttachEndTo and EndLocation are just used for initial location of end of cable
        """
        ...
    @attach_end.setter
    def attach_end(self, value: bool) -> None:
        ...
    @property
    def end_location(self) -> Vector:
        r"""
        (Vector):  [Read-Write] End location of cable, relative to AttachEndTo (or AttachEndToSocketName) if specified, otherwise relative to cable component.
        """
        ...
    @end_location.setter
    def end_location(self, value: Vector) -> None:
        ...
    @property
    def cable_length(self) -> float:
        r"""
        (float):  [Read-Write] Rest length of the cable
        """
        ...
    @cable_length.setter
    def cable_length(self, value: float) -> None:
        ...
    @property
    def num_segments(self) -> int:
        r"""
        (int32):  [Read-Only] How many segments the cable has
        """
        ...
    @property
    def substep_time(self) -> float:
        r"""
        (float):  [Read-Only] Controls the simulation substep time for the cable
        """
        ...
    @property
    def solver_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] The number of solver iterations controls how 'stiff' the cable is
        """
        ...
    @solver_iterations.setter
    def solver_iterations(self, value: int) -> None:
        ...
    @property
    def enable_stiffness(self) -> bool:
        r"""
        (bool):  [Read-Write] Add stiffness constraints to cable.
        """
        ...
    @enable_stiffness.setter
    def enable_stiffness(self, value: bool) -> None:
        ...
    @property
    def use_substepping(self) -> bool:
        r"""
        (bool):  [Read-Write] When false, will still wait for SubstepTime to elapse before updating, but will only run the cable simulation once using all of accumulated simulation time
        """
        ...
    @use_substepping.setter
    def use_substepping(self, value: bool) -> None:
        ...
    @property
    def skip_cable_update_when_not_visible(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @skip_cable_update_when_not_visible.setter
    def skip_cable_update_when_not_visible(self, value: bool) -> None:
        ...
    @property
    def skip_cable_update_when_not_owner_recently_rendered(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @skip_cable_update_when_not_owner_recently_rendered.setter
    def skip_cable_update_when_not_owner_recently_rendered(self, value: bool) -> None:
        ...
    @property
    def enable_collision(self) -> bool:
        r"""
        (bool):  [Read-Write] EXPERIMENTAL. Perform sweeps for each cable particle, each substep, to avoid collisions with the world.
        Uses the Collision Preset on the component to determine what is collided with.
        This greatly increases the cost of the cable simulation.
        """
        ...
    @enable_collision.setter
    def enable_collision(self, value: bool) -> None:
        ...
    @property
    def collision_friction(self) -> float:
        r"""
        (float):  [Read-Write] If collision is enabled, control how much sliding friction is applied when cable is in contact.
        """
        ...
    @collision_friction.setter
    def collision_friction(self, value: float) -> None:
        ...
    @property
    def cable_force(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Force vector (world space) applied to all particles in cable.
        """
        ...
    @cable_force.setter
    def cable_force(self, value: Vector) -> None:
        ...
    @property
    def cable_gravity_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scaling applied to world gravity affecting this cable.
        """
        ...
    @cable_gravity_scale.setter
    def cable_gravity_scale(self, value: float) -> None:
        ...
    @property
    def cable_width(self) -> float:
        r"""
        (float):  [Read-Write] How wide the cable geometry is
        """
        ...
    @cable_width.setter
    def cable_width(self, value: float) -> None:
        ...
    @property
    def num_sides(self) -> int:
        r"""
        (int32):  [Read-Only] Number of sides of the cable geometry
        """
        ...
    @property
    def tile_material(self) -> float:
        r"""
        (float):  [Read-Write] How many times to repeat the material along the length of the cable
        """
        ...
    @tile_material.setter
    def tile_material(self, value: float) -> None:
        ...
    def set_attach_end_to_component(self, component: SceneComponent, socket_name: Name = "None") -> None:
        r"""
        x.set_attach_end_to_component(component, socket_name="None") -> None
        Attaches the end of the cable to a specific Component *
        
        Args:
            component (SceneComponent): 
            socket_name (Name):
        """
        ...
    def set_attach_end_to(self, actor: Actor, component_property: Name, socket_name: Name = "None") -> None:
        r"""
        x.set_attach_end_to(actor, component_property, socket_name="None") -> None
        Attaches the end of the cable to a specific Component within an Actor *
        
        Args:
            actor (Actor): 
            component_property (Name): 
            socket_name (Name):
        """
        ...
    def get_cable_particle_locations(self) -> Array[Vector]:
        r"""
        x.get_cable_particle_locations() -> Array[Vector]
        Get array of locations of particles (in world space) making up the cable simulation.
        
        Returns:
            Array[Vector]: 
        
            locations (Array[Vector]):
        """
        ...
    def get_attached_component(self) -> SceneComponent:
        r"""
        x.get_attached_component() -> SceneComponent
        Gets the specific USceneComponent that the cable is attached to *
        
        Returns:
            SceneComponent:
        """
        ...
    def get_attached_actor(self) -> Actor:
        r"""
        x.get_attached_actor() -> Actor
        Gets the Actor that the cable is attached to *
        
        Returns:
            Actor:
        """
        ...

class CustomMeshComponent(MeshComponent):
    r"""
    Component that allows you to specify custom triangle mesh geometry
    
    **C++ Source:**
    
    - **Plugin**: CustomMeshComponent
    - **Module**: CustomMeshComponent
    - **File**: CustomMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    def set_custom_mesh_triangles(self, triangles: Array[CustomMeshTriangle]) -> bool:
        r"""
        x.set_custom_mesh_triangles(triangles) -> bool
        Set the geometry to use on this triangle mesh
        
        Args:
            triangles (Array[CustomMeshTriangle]): 
        
        Returns:
            bool:
        """
        ...
    def clear_custom_mesh_triangles(self) -> None:
        r"""
        x.clear_custom_mesh_triangles() -> None
        Removes all geometry from this triangle mesh.  Does not deallocate memory, allowing new geometry to reuse the existing allocation.
        """
        ...
    def add_custom_mesh_triangles(self, triangles: Array[CustomMeshTriangle]) -> None:
        r"""
        x.add_custom_mesh_triangles(triangles) -> None
        Add to the geometry to use on this triangle mesh.  This may cause an allocation.  Use SetCustomMeshTriangles() instead when possible to reduce allocations.
        
        Args:
            triangles (Array[CustomMeshTriangle]):
        """
        ...

class AudioAnalyzerAssetBase(Object):
    r"""
    UAudioAnalyzerAssetBase
    
    UAudioAnalyzerAssetBase provides the base interface for controlling asset actions within the editor.
    
    **C++ Source:**
    
    - **Module**: AudioAnalyzer
    - **File**: AudioAnalyzerAsset.h
    
    """
    ...

class AudioAnalyzerSettings(AudioAnalyzerAssetBase):
    r"""
    UAudioAnalyzerSettings
    
    UAudioAnalyzerSettings provides a way to store and reuse existing analyzer settings
    across multiple analyzers.
    
    **C++ Source:**
    
    - **Module**: AudioAnalyzer
    - **File**: AudioAnalyzer.h
    
    """
    ...

class AudioAnalyzer(Object):
    r"""
    UAudioAnalyzer
    
    UAudioAnalyzer performs analysis on an audio bus using specific settings and exposes the results via blueprints.
    
    Subclasses of UAudioAnalyzer must implement GetAnalyzerFactoryName() to associate
    the UAudioAnalyzer asset with an IAudioAnalyzerFactory implementation.
    
    To support blueprint access, subclasses can implement UFUNCTIONs to expose the data
    returned by GetResult().
    
    **C++ Source:**
    
    - **Module**: AudioAnalyzer
    - **File**: AudioAnalyzer.h
    
    """
    def stop_analyzing(self, world_context_object: Object = None) -> None:
        r"""
        x.stop_analyzing(world_context_object=None) -> None
        Stops analyzing audio.
        
        Args:
            world_context_object (Object):
        """
        ...
    def start_analyzing(self, world_context_object: Object, audio_bus_to_analyze: AudioBus) -> None:
        r"""
        x.start_analyzing(world_context_object, audio_bus_to_analyze) -> None
        Starts analyzing audio from the given audio bus. Optionally override the audio bus desired to analyze.
        
        Args:
            world_context_object (Object): 
            audio_bus_to_analyze (AudioBus):
        """
        ...

class AudioAnalyzerNRTSettings(AudioAnalyzerAssetBase):
    r"""
    UAudioAnalyzerNRTSettings
    
    UAudioAnalyzerNRTSettings provides a way to store and reuse existing analyzer settings
    across multiple analyzers. This class provides the interface and functionality to
    automatically trigger reanalysis of audio across all analyzers associated with this
    setting when when a UPROPERTY in this setting object is edited.
    
    **C++ Source:**
    
    - **Module**: AudioAnalyzer
    - **File**: AudioAnalyzerNRT.h
    
    """
    ...

class AudioAnalyzerNRT(AudioAnalyzerAssetBase):
    r"""
    UAudioAnalyzerNRT
    
    UAudioAnalyzerNRT applies an analyzer to a sound using specific settings, stores the
    results and exposes them via blueprints.
    
    Subclasses of UAudioAnalyzerNRT must implement GetAnalyzerNRTFactoryName() to associate
    the UAudioAnalyzerNRT with an IAudioAnalyzerNRTFactory implementation.
    
    To support blueprint access, subclasses can implement UFUNCTIONs to expose the data
    returned by GetResult().
    
    **C++ Source:**
    
    - **Module**: AudioAnalyzer
    - **File**: AudioAnalyzerNRT.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration_in_seconds`` (float):  [Read-Write] The duration of the analyzed audio in seconds.
    - ``sound`` (SoundWave):  [Read-Write] The USoundWave which is analyzed.
    """
    @property
    def sound(self) -> SoundWave:
        r"""
        (SoundWave):  [Read-Only] The USoundWave which is analyzed.
        """
        ...
    @property
    def duration_in_seconds(self) -> float:
        r"""
        (float):  [Read-Only] The duration of the analyzed audio in seconds.
        """
        ...

class AudioSynesthesiaSettings(AudioAnalyzerSettings):
    r"""
    UAudioSynesthesiaSettings
    
    Defines asset actions for derived UAudioSynthesiaSettings subclasses.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: AudioSynesthesia.h
    
    """
    ...

class AudioSynesthesiaNRTSettings(AudioAnalyzerNRTSettings):
    r"""
    UAudioSynesthesiaNRTSettings
    
    Defines asset actions for derived UAudioSynthesiaNRTSettings subclasses.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: AudioSynesthesiaNRT.h
    
    """
    ...

class AudioSynesthesiaNRT(AudioAnalyzerNRT):
    r"""
    UAudioSynesthesiaNRT
    
    Defines asset actions for derived UAudioSynthesiaNRT subclasses.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: AudioSynesthesiaNRT.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration_in_seconds`` (float):  [Read-Write] The duration of the analyzed audio in seconds.
    - ``sound`` (SoundWave):  [Read-Write] The USoundWave which is analyzed.
    """
    ...

class ConstantQSettings(AudioSynesthesiaSettings):
    r"""
    UConstantQSettings
    
    Settings for a UConstantQ analyzer.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: ConstantQ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``analysis_period_in_seconds`` (float):  [Read-Write] Number of seconds between cqt measurements
    - ``band_width_stretch`` (float):  [Read-Write] Stretching factor to control overlap of adjacent bands.
    - ``cqt_normalization`` (ConstantQNormalizationEnum):  [Read-Write] Normalization scheme used to generate band windows.
    - ``downmix_to_mono`` (bool):  [Read-Write] If true, multichannel audio is downmixed to mono with equal amplitude scaling. If false, each channel gets it's own CQT result.
    - ``fft_size`` (ConstantQFFTSizeEnum):  [Read-Write] Size of FFT.
    - ``noise_floor_db`` (float):  [Read-Write] Noise floor to use when normalizing CQT
    - ``num_bands`` (int32):  [Read-Write] Total number of resulting constant Q bands.
    - ``num_bands_per_octave`` (float):  [Read-Write] Number of bands within an octave.
    - ``spectrum_type`` (AudioSpectrumType):  [Read-Write] Type of spectrum to use.
    - ``starting_frequency_hz`` (float):  [Read-Write] Starting frequency for first bin of CQT
    - ``window_type`` (FFTWindowType):  [Read-Write] Type of window to be applied to input audio
    """
    @property
    def starting_frequency_hz(self) -> float:
        r"""
        (float):  [Read-Only] Starting frequency for first bin of CQT
        """
        ...
    @property
    def num_bands(self) -> int:
        r"""
        (int32):  [Read-Only] Total number of resulting constant Q bands.
        """
        ...
    @property
    def num_bands_per_octave(self) -> float:
        r"""
        (float):  [Read-Only] Number of bands within an octave.
        """
        ...
    @property
    def analysis_period_in_seconds(self) -> float:
        r"""
        (float):  [Read-Only] Number of seconds between cqt measurements
        """
        ...
    @property
    def downmix_to_mono(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, multichannel audio is downmixed to mono with equal amplitude scaling. If false, each channel gets it's own CQT result.
        """
        ...
    @property
    def fft_size(self) -> ConstantQFFTSizeEnum:
        r"""
        (ConstantQFFTSizeEnum):  [Read-Only] Size of FFT.
        """
        ...
    @property
    def window_type(self) -> FFTWindowType:
        r"""
        (FFTWindowType):  [Read-Only] Type of window to be applied to input audio
        """
        ...
    @property
    def spectrum_type(self) -> AudioSpectrumType:
        r"""
        (AudioSpectrumType):  [Read-Only] Type of spectrum to use.
        """
        ...
    @property
    def band_width_stretch(self) -> float:
        r"""
        (float):  [Read-Only] Stretching factor to control overlap of adjacent bands.
        """
        ...
    @property
    def cqt_normalization(self) -> ConstantQNormalizationEnum:
        r"""
        (ConstantQNormalizationEnum):  [Read-Only] Normalization scheme used to generate band windows.
        """
        ...
    @property
    def noise_floor_db(self) -> float:
        r"""
        (float):  [Read-Only] Noise floor to use when normalizing CQT
        """
        ...

class ConstantQAnalyzer(AudioAnalyzer):
    r"""
    UConstantQAnalyzer
    
    UConstantQAnalyzer calculates the temporal evolution of constant q transform for a given
    audio bus in real-time. ConstantQ is available for individual channels or the overall audio bus.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: ConstantQ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_constant_q_results`` (OnConstantQResults):  [Read-Write] Delegate to receive all Spectrum results, per-channel, since last delegate call. If bDownmixToMono setting is true, results will be in channel index 0.
    - ``on_latest_constant_q_results`` (OnLatestConstantQResults):  [Read-Write] Delegate to receive the latest per-channel Spectrum results. If bDownmixToMono setting is true, results will be in channel index 0.
    - ``settings`` (ConstantQSettings):  [Read-Write] The settings for the audio analyzer.
    """
    @property
    def settings(self) -> ConstantQSettings:
        r"""
        (ConstantQSettings):  [Read-Write] The settings for the audio analyzer.
        """
        ...
    @settings.setter
    def settings(self, value: ConstantQSettings) -> None:
        ...
    @property
    def on_constant_q_results(self) -> OnConstantQResults:
        r"""
        (OnConstantQResults):  [Read-Write] Delegate to receive all Spectrum results, per-channel, since last delegate call. If bDownmixToMono setting is true, results will be in channel index 0.
        """
        ...
    @on_constant_q_results.setter
    def on_constant_q_results(self, value: OnConstantQResults) -> None:
        ...
    @property
    def on_latest_constant_q_results(self) -> OnLatestConstantQResults:
        r"""
        (OnLatestConstantQResults):  [Read-Write] Delegate to receive the latest per-channel Spectrum results. If bDownmixToMono setting is true, results will be in channel index 0.
        """
        ...
    @on_latest_constant_q_results.setter
    def on_latest_constant_q_results(self, value: OnLatestConstantQResults) -> None:
        ...
    def get_num_center_frequencies(self) -> int:
        r"""
        x.get_num_center_frequencies() -> int32
        Get Num Center Frequencies
        
        Returns:
            int32:
        """
        ...
    def get_center_frequencies(self) -> Array[float]:
        r"""
        x.get_center_frequencies() -> Array[float]
        Get Center Frequencies
        
        Returns:
            Array[float]: 
        
            out_center_frequencies (Array[float]):
        """
        ...

class ConstantQNRTSettings(AudioSynesthesiaNRTSettings):
    r"""
    UConstantQNRTSettings
    
    Settings for a UConstantQNRT analyzer.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: ConstantQNRT.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``analysis_period`` (float):  [Read-Write] Number of seconds between cqt measurements
    - ``band_width_stretch`` (float):  [Read-Write] Stretching factor to control overlap of adjacent bands.
    - ``cqt_normalization`` (ConstantQNormalizationEnum):  [Read-Write] Normalization scheme used to generate band windows.
    - ``downmix_to_mono`` (bool):  [Read-Write] If true, multichannel audio is downmixed to mono with equal amplitude scaling. If false, each channel gets it's own CQT result.
    - ``fft_size`` (ConstantQFFTSizeEnum):  [Read-Write] Size of FFT.
    - ``noise_floor_db`` (float):  [Read-Write] Noise floor to use when normalizing CQT
    - ``num_bands`` (int32):  [Read-Write] Total number of resulting constant Q bands.
    - ``num_bands_per_octave`` (float):  [Read-Write] Number of bands within an octave.
    - ``spectrum_type`` (AudioSpectrumType):  [Read-Write] Type of spectrum to use.
    - ``starting_frequency`` (float):  [Read-Write] Starting frequency for first bin of CQT
    - ``window_type`` (FFTWindowType):  [Read-Write] Type of window to be applied to input audio
    """
    @property
    def starting_frequency(self) -> float:
        r"""
        (float):  [Read-Only] Starting frequency for first bin of CQT
        """
        ...
    @property
    def num_bands(self) -> int:
        r"""
        (int32):  [Read-Only] Total number of resulting constant Q bands.
        """
        ...
    @property
    def num_bands_per_octave(self) -> float:
        r"""
        (float):  [Read-Only] Number of bands within an octave.
        """
        ...
    @property
    def analysis_period(self) -> float:
        r"""
        (float):  [Read-Only] Number of seconds between cqt measurements
        """
        ...
    @property
    def downmix_to_mono(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, multichannel audio is downmixed to mono with equal amplitude scaling. If false, each channel gets it's own CQT result.
        """
        ...
    @property
    def fft_size(self) -> ConstantQFFTSizeEnum:
        r"""
        (ConstantQFFTSizeEnum):  [Read-Only] Size of FFT.
        """
        ...
    @property
    def window_type(self) -> FFTWindowType:
        r"""
        (FFTWindowType):  [Read-Only] Type of window to be applied to input audio
        """
        ...
    @property
    def spectrum_type(self) -> AudioSpectrumType:
        r"""
        (AudioSpectrumType):  [Read-Only] Type of spectrum to use.
        """
        ...
    @property
    def band_width_stretch(self) -> float:
        r"""
        (float):  [Read-Only] Stretching factor to control overlap of adjacent bands.
        """
        ...
    @property
    def cqt_normalization(self) -> ConstantQNormalizationEnum:
        r"""
        (ConstantQNormalizationEnum):  [Read-Only] Normalization scheme used to generate band windows.
        """
        ...
    @property
    def noise_floor_db(self) -> float:
        r"""
        (float):  [Read-Only] Noise floor to use when normalizing CQT
        """
        ...

class ConstantQNRT(AudioSynesthesiaNRT):
    r"""
    UConstantQNRT
    
    UConstantQNRT calculates the temporal evolution of constant q transform for a given
    sound. ConstantQ is available for individual channels or the overall sound asset.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: ConstantQNRT.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration_in_seconds`` (float):  [Read-Write] The duration of the analyzed audio in seconds.
    - ``settings`` (ConstantQNRTSettings):  [Read-Write] The settings for the audio analyzer.
    - ``sound`` (SoundWave):  [Read-Write] The USoundWave which is analyzed.
    """
    @property
    def settings(self) -> ConstantQNRTSettings:
        r"""
        (ConstantQNRTSettings):  [Read-Only] The settings for the audio analyzer.
        """
        ...
    def get_normalized_channel_constant_q_at_time(self, seconds: float, channel: int) -> Array[float]:
        r"""
        x.get_normalized_channel_constant_q_at_time(seconds, channel) -> Array[float]
        Get a specific channel cqt of the analyzed sound at a given time.
        
        Args:
            seconds (float): 
            channel (int32): 
        
        Returns:
            Array[float]: 
        
            out_constant_q (Array[float]):
        """
        ...
    def get_channel_constant_q_at_time(self, seconds: float, channel: int) -> Array[float]:
        r"""
        x.get_channel_constant_q_at_time(seconds, channel) -> Array[float]
        Get a specific channel cqt of the analyzed sound at a given time.
        
        Args:
            seconds (float): 
            channel (int32): 
        
        Returns:
            Array[float]: 
        
            out_constant_q (Array[float]):
        """
        ...

class LoudnessSettings(AudioSynesthesiaSettings):
    r"""
    ULoudnessSettings
    
    Settings for a ULoudness analyzer.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Loudness.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``analysis_period`` (float):  [Read-Write] Number of seconds between loudness measurements
    - ``curve_type`` (LoudnessCurveTypeEnum):  [Read-Write] Type of equal loudness curve used in calculations
    - ``expected_max_loudness`` (float):  [Read-Write] dB level to denote silence.  Used when calculating normalized loudness.
    - ``maximum_frequency`` (float):  [Read-Write] Maximum analysis frequency for calculating loudness.
    - ``minimum_frequency`` (float):  [Read-Write] Minimum analysis frequency for calculating loudness.
    - ``noise_floor_db`` (float):  [Read-Write] dB level to denote silence.  Used when calculating normalized loudness.
    """
    @property
    def analysis_period(self) -> float:
        r"""
        (float):  [Read-Only] Number of seconds between loudness measurements
        """
        ...
    @property
    def minimum_frequency(self) -> float:
        r"""
        (float):  [Read-Only] Minimum analysis frequency for calculating loudness.
        """
        ...
    @property
    def maximum_frequency(self) -> float:
        r"""
        (float):  [Read-Only] Maximum analysis frequency for calculating loudness.
        """
        ...
    @property
    def curve_type(self) -> LoudnessCurveTypeEnum:
        r"""
        (LoudnessCurveTypeEnum):  [Read-Only] Type of equal loudness curve used in calculations
        """
        ...
    @property
    def noise_floor_db(self) -> float:
        r"""
        (float):  [Read-Only] dB level to denote silence.  Used when calculating normalized loudness.
        """
        ...
    @property
    def expected_max_loudness(self) -> float:
        r"""
        (float):  [Read-Only] dB level to denote silence.  Used when calculating normalized loudness.
        """
        ...

class LoudnessAnalyzer(AudioAnalyzer):
    r"""
    ULoudnessAnalyzer
    
    ULoudnessAnalyzer calculates the temporal evolution of perceptual loudness for a given
    audio bus in real-time. Loudness is available for individual channels or the overall audio bus. Normalized
    loudness values convert the range to 0.0 to 1.0 where 0.0 is the noise floor and 1.0 is the
    maximum loudness of the particular sound.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Loudness.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_latest_overall_loudness_results`` (OnLatestOverallLoudnessResults):  [Read-Write] Delegate to receive the latest overall loudness results.
    - ``on_latest_per_channel_loudness_results`` (OnLatestPerChannelLoudnessResults):  [Read-Write] Delegate to receive the latest per-channel loudness results.
    - ``on_overall_loudness_results`` (OnOverallLoudnessResults):  [Read-Write] Delegate to receive all overall loudness results since last delegate call.
    - ``on_per_channel_loudness_results`` (OnPerChannelLoudnessResults):  [Read-Write] Delegate to receive all loudness results, per-channel, since last delegate call.
    - ``settings`` (LoudnessSettings):  [Read-Write] The settings for the audio analyzer.
    """
    @property
    def settings(self) -> LoudnessSettings:
        r"""
        (LoudnessSettings):  [Read-Write] The settings for the audio analyzer.
        """
        ...
    @settings.setter
    def settings(self, value: LoudnessSettings) -> None:
        ...
    @property
    def on_overall_loudness_results(self) -> OnOverallLoudnessResults:
        r"""
        (OnOverallLoudnessResults):  [Read-Write] Delegate to receive all overall loudness results since last delegate call.
        """
        ...
    @on_overall_loudness_results.setter
    def on_overall_loudness_results(self, value: OnOverallLoudnessResults) -> None:
        ...
    @property
    def on_per_channel_loudness_results(self) -> OnPerChannelLoudnessResults:
        r"""
        (OnPerChannelLoudnessResults):  [Read-Write] Delegate to receive all loudness results, per-channel, since last delegate call.
        """
        ...
    @on_per_channel_loudness_results.setter
    def on_per_channel_loudness_results(self, value: OnPerChannelLoudnessResults) -> None:
        ...
    @property
    def on_latest_overall_loudness_results(self) -> OnLatestOverallLoudnessResults:
        r"""
        (OnLatestOverallLoudnessResults):  [Read-Write] Delegate to receive the latest overall loudness results.
        """
        ...
    @on_latest_overall_loudness_results.setter
    def on_latest_overall_loudness_results(self, value: OnLatestOverallLoudnessResults) -> None:
        ...
    @property
    def on_latest_per_channel_loudness_results(self) -> OnLatestPerChannelLoudnessResults:
        r"""
        (OnLatestPerChannelLoudnessResults):  [Read-Write] Delegate to receive the latest per-channel loudness results.
        """
        ...
    @on_latest_per_channel_loudness_results.setter
    def on_latest_per_channel_loudness_results(self, value: OnLatestPerChannelLoudnessResults) -> None:
        ...

class LoudnessNRTSettings(AudioSynesthesiaNRTSettings):
    r"""
    ULoudnessNRTSettings
    
    Settings for a ULoudnessNRT analyzer.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: LoudnessNRT.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``analysis_period`` (float):  [Read-Write] Number of seconds between loudness measurements
    - ``curve_type`` (LoudnessNRTCurveTypeEnum):  [Read-Write] Type of equal loudness curve used in calculations
    - ``maximum_frequency`` (float):  [Read-Write] Maximum analysis frequency for calculating loudness.
    - ``minimum_frequency`` (float):  [Read-Write] Minimum analysis frequency for calculating loudness.
    - ``noise_floor_db`` (float):  [Read-Write] dB level to denote silence.  Used when calculating normalized loudness.
    """
    @property
    def analysis_period(self) -> float:
        r"""
        (float):  [Read-Only] Number of seconds between loudness measurements
        """
        ...
    @property
    def minimum_frequency(self) -> float:
        r"""
        (float):  [Read-Only] Minimum analysis frequency for calculating loudness.
        """
        ...
    @property
    def maximum_frequency(self) -> float:
        r"""
        (float):  [Read-Only] Maximum analysis frequency for calculating loudness.
        """
        ...
    @property
    def curve_type(self) -> LoudnessNRTCurveTypeEnum:
        r"""
        (LoudnessNRTCurveTypeEnum):  [Read-Only] Type of equal loudness curve used in calculations
        """
        ...
    @property
    def noise_floor_db(self) -> float:
        r"""
        (float):  [Read-Only] dB level to denote silence.  Used when calculating normalized loudness.
        """
        ...

class LoudnessNRT(AudioSynesthesiaNRT):
    r"""
    ULoudnessNRT
    
    ULoudnessNRT calculates the temporal evolution of perceptual loudness for a given
    sound. Loudness is available for individual channels or the overall sound asset. Normalized
    loudness values convert the range to 0.0 to 1.0 where 0.0 is the noise floor and 1.0 is the
    maximum loudness of the particular sound.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: LoudnessNRT.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration_in_seconds`` (float):  [Read-Write] The duration of the analyzed audio in seconds.
    - ``settings`` (LoudnessNRTSettings):  [Read-Write] The settings for the audio analyzer.
    - ``sound`` (SoundWave):  [Read-Write] The USoundWave which is analyzed.
    """
    @property
    def settings(self) -> LoudnessNRTSettings:
        r"""
        (LoudnessNRTSettings):  [Read-Only] The settings for the audio analyzer.
        """
        ...
    def get_normalized_loudness_at_time(self, seconds: float) -> float:
        r"""
        x.get_normalized_loudness_at_time(seconds) -> float
        Get the normalized overall loudness of the analyzed sound at a given time. Normalized loudness
        is always between 0.0 to 1.0. 0.0 refers to the noise floor while 1.0 refers to the maximum
        loudness in the sound.
        
        Args:
            seconds (float): 
        
        Returns:
            float: 
        
            out_loudness (float):
        """
        ...
    def get_normalized_channel_loudness_at_time(self, seconds: float, channel: int) -> float:
        r"""
        x.get_normalized_channel_loudness_at_time(seconds, channel) -> float
        Get a specific channel normalized loudness of the analyzed sound at a given time. Normalized
        loudness is always between 0.0 to 1.0. 0.0 refers to the noise floor while 1.0 refers to the
        maximum loudness in the sound.
        
        Args:
            seconds (float): 
            channel (int32): 
        
        Returns:
            float: 
        
            out_loudness (float):
        """
        ...
    def get_loudness_at_time(self, seconds: float) -> float:
        r"""
        x.get_loudness_at_time(seconds) -> float
        Get the overall loudness of the analyzed sound at a given time.
        
        Args:
            seconds (float): 
        
        Returns:
            float: 
        
            out_loudness (float):
        """
        ...
    def get_channel_loudness_at_time(self, seconds: float, channel: int) -> float:
        r"""
        x.get_channel_loudness_at_time(seconds, channel) -> float
        Get a specific channel loudness of the analyzed sound at a given time.
        
        Args:
            seconds (float): 
            channel (int32): 
        
        Returns:
            float: 
        
            out_loudness (float):
        """
        ...

class MeterSettings(AudioSynesthesiaSettings):
    r"""
    UMeterSettings
    
    Settings for a UMeterAnalyzer.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Meter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``analysis_period`` (float):  [Read-Write] Number of seconds between meter measurements
    - ``clipping_threshold`` (float):  [Read-Write] What volume threshold to throw clipping detection notifications.
    - ``meter_attack_time`` (int32):  [Read-Write] Meter attack time, in milliseconds
    - ``meter_release_time`` (int32):  [Read-Write] Meter release time, in milliseconds.
    - ``peak_hold_time`` (int32):  [Read-Write] Peak hold time, in milliseconds
    - ``peak_mode`` (MeterPeakType):  [Read-Write] Meter envelope type type
    """
    @property
    def analysis_period(self) -> float:
        r"""
        (float):  [Read-Only] Number of seconds between meter measurements
        """
        ...
    @property
    def peak_mode(self) -> MeterPeakType:
        r"""
        (MeterPeakType):  [Read-Only] Meter envelope type type
        """
        ...
    @property
    def meter_attack_time(self) -> int:
        r"""
        (int32):  [Read-Only] Meter attack time, in milliseconds
        """
        ...
    @property
    def meter_release_time(self) -> int:
        r"""
        (int32):  [Read-Only] Meter release time, in milliseconds.
        """
        ...
    @property
    def peak_hold_time(self) -> int:
        r"""
        (int32):  [Read-Only] Peak hold time, in milliseconds
        """
        ...
    @property
    def clipping_threshold(self) -> float:
        r"""
        (float):  [Read-Only] What volume threshold to throw clipping detection notifications.
        """
        ...

class MeterAnalyzer(AudioAnalyzer):
    r"""
    UMeterAnalyzer
    
    UMeterAnalyzer calculates the current amplitude of an
    audio bus in real-time.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: Meter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_latest_overall_meter_results`` (OnLatestOverallMeterResults):  [Read-Write] Delegate to receive the latest overall meter results.
    - ``on_latest_per_channel_meter_results`` (OnLatestPerChannelMeterResults):  [Read-Write] Delegate to receive the latest per-channel meter results.
    - ``on_overall_meter_results`` (OnOverallMeterResults):  [Read-Write] Delegate to receive all overall meter results since last delegate call.
    - ``on_per_channel_meter_results`` (OnPerChannelMeterResults):  [Read-Write] Delegate to receive all meter results, per-channel, since last delegate call.
    - ``settings`` (MeterSettings):  [Read-Write] The settings for the meter audio analyzer.
    """
    @property
    def settings(self) -> MeterSettings:
        r"""
        (MeterSettings):  [Read-Write] The settings for the meter audio analyzer.
        """
        ...
    @settings.setter
    def settings(self, value: MeterSettings) -> None:
        ...
    @property
    def on_overall_meter_results(self) -> OnOverallMeterResults:
        r"""
        (OnOverallMeterResults):  [Read-Write] Delegate to receive all overall meter results since last delegate call.
        """
        ...
    @on_overall_meter_results.setter
    def on_overall_meter_results(self, value: OnOverallMeterResults) -> None:
        ...
    @property
    def on_per_channel_meter_results(self) -> OnPerChannelMeterResults:
        r"""
        (OnPerChannelMeterResults):  [Read-Write] Delegate to receive all meter results, per-channel, since last delegate call.
        """
        ...
    @on_per_channel_meter_results.setter
    def on_per_channel_meter_results(self, value: OnPerChannelMeterResults) -> None:
        ...
    @property
    def on_latest_overall_meter_results(self) -> OnLatestOverallMeterResults:
        r"""
        (OnLatestOverallMeterResults):  [Read-Write] Delegate to receive the latest overall meter results.
        """
        ...
    @on_latest_overall_meter_results.setter
    def on_latest_overall_meter_results(self, value: OnLatestOverallMeterResults) -> None:
        ...
    @property
    def on_latest_per_channel_meter_results(self) -> OnLatestPerChannelMeterResults:
        r"""
        (OnLatestPerChannelMeterResults):  [Read-Write] Delegate to receive the latest per-channel meter results.
        """
        ...
    @on_latest_per_channel_meter_results.setter
    def on_latest_per_channel_meter_results(self, value: OnLatestPerChannelMeterResults) -> None:
        ...

class OnsetNRTSettings(AudioSynesthesiaNRTSettings):
    r"""
    UOnsetNRTSettings
    
    Settings for a UOnsetNRT analyzer.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: OnsetNRT.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``downmix_to_mono`` (bool):  [Read-Write] If true, multichannel audio is downmixed to mono with equal amplitude scaling. If false, each channel gets it's own onset result.
    - ``granularity_in_seconds`` (float):  [Read-Write] Onset timestamp granularity onsets. Lower granularity takes longer to compute.
    - ``maximum_frequency`` (float):  [Read-Write] Starting frequency for onset anlaysis.
    - ``minimum_frequency`` (float):  [Read-Write] Starting frequency for onset anlaysis.
    - ``sensitivity`` (float):  [Read-Write] Sensitivity of onset detector. Higher sensitivity will find more onsets.
    """
    @property
    def downmix_to_mono(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, multichannel audio is downmixed to mono with equal amplitude scaling. If false, each channel gets it's own onset result.
        """
        ...
    @property
    def granularity_in_seconds(self) -> float:
        r"""
        (float):  [Read-Only] Onset timestamp granularity onsets. Lower granularity takes longer to compute.
        """
        ...
    @property
    def sensitivity(self) -> float:
        r"""
        (float):  [Read-Only] Sensitivity of onset detector. Higher sensitivity will find more onsets.
        """
        ...
    @property
    def minimum_frequency(self) -> float:
        r"""
        (float):  [Read-Only] Starting frequency for onset anlaysis.
        """
        ...
    @property
    def maximum_frequency(self) -> float:
        r"""
        (float):  [Read-Only] Starting frequency for onset anlaysis.
        """
        ...

class OnsetNRT(AudioSynesthesiaNRT):
    r"""
    UOnsetNRT
    
    UOnsetNRT calculates the temporal evolution of constant q transform for a given
    sound. Onset is available for individual channels or the overall sound asset.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: OnsetNRT.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration_in_seconds`` (float):  [Read-Write] The duration of the analyzed audio in seconds.
    - ``settings`` (OnsetNRTSettings):  [Read-Write] The settings for the audio analyzer.
    - ``sound`` (SoundWave):  [Read-Write] The USoundWave which is analyzed.
    """
    @property
    def settings(self) -> OnsetNRTSettings:
        r"""
        (OnsetNRTSettings):  [Read-Only] The settings for the audio analyzer.
        """
        ...
    def get_normalized_channel_onsets_between_times(self, start_seconds: float, end_seconds: float, channel: int) -> Tuple[Array[float], Array[float]]:
        r"""
        x.get_normalized_channel_onsets_between_times(start_seconds, end_seconds, channel) -> (out_onset_timestamps=Array[float], out_onset_strengths=Array[float])
        Get a specific channel cqt of the analyzed sound at a given time.
        
        Args:
            start_seconds (float): 
            end_seconds (float): 
            channel (int32): 
        
        Returns:
            tuple: 
        
            out_onset_timestamps (Array[float]): 
        
            out_onset_strengths (Array[float]):
        """
        ...
    def get_channel_onsets_between_times(self, start_seconds: float, end_seconds: float, channel: int) -> Tuple[Array[float], Array[float]]:
        r"""
        x.get_channel_onsets_between_times(start_seconds, end_seconds, channel) -> (out_onset_timestamps=Array[float], out_onset_strengths=Array[float])
        Returns onsets which occured between start and end timestamps.
        
        Args:
            start_seconds (float): 
            end_seconds (float): 
            channel (int32): 
        
        Returns:
            tuple: 
        
            out_onset_timestamps (Array[float]): 
        
            out_onset_strengths (Array[float]):
        """
        ...

class SynesthesiaSpectrumAnalysisSettings(AudioSynesthesiaSettings):
    r"""
    USynesthesiaSpectrumAnalysisSettings
    
    Settings for a USynesthesiaSpectrumAnalysisAnalyzer.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: SynesthesiaSpectrumAnalysis.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``analysis_period`` (float):  [Read-Write] Number of seconds between SynesthesiaSpectrumAnalysis measurements
    - ``downmix_to_mono`` (bool):  [Read-Write] If true, multichannel audio is downmixed to mono with equal amplitude scaling. If false, each channel gets its own FFT result.
    - ``fft_size`` (FFTSize):  [Read-Write] Size of FFT.
    - ``spectrum_type`` (AudioSpectrumType):  [Read-Write] Type of spectrum to use.
    - ``window_type`` (FFTWindowType):  [Read-Write] Type of window to use.
    """
    @property
    def analysis_period(self) -> float:
        r"""
        (float):  [Read-Only] Number of seconds between SynesthesiaSpectrumAnalysis measurements
        """
        ...
    @property
    def fft_size(self) -> FFTSize:
        r"""
        (FFTSize):  [Read-Only] Size of FFT.
        """
        ...
    @property
    def spectrum_type(self) -> AudioSpectrumType:
        r"""
        (AudioSpectrumType):  [Read-Only] Type of spectrum to use.
        """
        ...
    @property
    def window_type(self) -> FFTWindowType:
        r"""
        (FFTWindowType):  [Read-Only] Type of window to use.
        """
        ...
    @property
    def downmix_to_mono(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, multichannel audio is downmixed to mono with equal amplitude scaling. If false, each channel gets its own FFT result.
        """
        ...

class SynesthesiaSpectrumAnalyzer(AudioAnalyzer):
    r"""
    USynesthesiaSpectrumAnalysisAnalyzer
    
    USynesthesiaSpectrumAnalysisAnalyzer calculates the current amplitude of an
    audio bus in real-time.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesia
    - **File**: SynesthesiaSpectrumAnalysis.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_latest_spectrum_results`` (OnLatestSpectrumResults):  [Read-Write] Delegate to receive the latest per-channel Spectrum results. If bDownmixToMono setting is true, results will be in channel index 0.
    - ``on_spectrum_results`` (OnSpectrumResults):  [Read-Write] Delegate to receive all Spectrum results, per-channel, since last delegate call. If bDownmixToMono setting is true, results will be in channel index 0.
    - ``settings`` (SynesthesiaSpectrumAnalysisSettings):  [Read-Write] The settings for the SynesthesiaSpectrumAnalysis audio analyzer.
    """
    @property
    def settings(self) -> SynesthesiaSpectrumAnalysisSettings:
        r"""
        (SynesthesiaSpectrumAnalysisSettings):  [Read-Write] The settings for the SynesthesiaSpectrumAnalysis audio analyzer.
        """
        ...
    @settings.setter
    def settings(self, value: SynesthesiaSpectrumAnalysisSettings) -> None:
        ...
    @property
    def on_spectrum_results(self) -> OnSpectrumResults:
        r"""
        (OnSpectrumResults):  [Read-Write] Delegate to receive all Spectrum results, per-channel, since last delegate call. If bDownmixToMono setting is true, results will be in channel index 0.
        """
        ...
    @on_spectrum_results.setter
    def on_spectrum_results(self, value: OnSpectrumResults) -> None:
        ...
    @property
    def on_latest_spectrum_results(self) -> OnLatestSpectrumResults:
        r"""
        (OnLatestSpectrumResults):  [Read-Write] Delegate to receive the latest per-channel Spectrum results. If bDownmixToMono setting is true, results will be in channel index 0.
        """
        ...
    @on_latest_spectrum_results.setter
    def on_latest_spectrum_results(self, value: OnLatestSpectrumResults) -> None:
        ...
    def get_num_center_frequencies(self) -> int:
        r"""
        x.get_num_center_frequencies() -> int32
        Get Num Center Frequencies
        
        Returns:
            int32:
        """
        ...
    def get_center_frequencies(self, sample_rate: float) -> Array[float]:
        r"""
        x.get_center_frequencies(sample_rate) -> Array[float]
        Get Center Frequencies
        
        Args:
            sample_rate (float): 
        
        Returns:
            Array[float]: 
        
            out_center_frequencies (Array[float]):
        """
        ...

class MetaSoundDocumentInterface(Interface):
    r"""
    Meta Sound Document Interface
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundDocumentInterface.h
    
    """
    ...

class MetasoundParameterPack(Object):
    r"""
    Here is the UObject BlueprintType that can be used in c++ and blueprint code. It holds a FMetasoundParamStorage
    instance and can pass it along to the audio system's SetObjectParameter function via an AudioProxy.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundFrontend
    - **File**: MetasoundParameterPack.h
    
    """
    def set_trigger(self, parameter_name: Name, only_if_exists: bool = True) -> SetParamResult:
        r"""
        x.set_trigger(parameter_name, only_if_exists=True) -> SetParamResult
        Set Trigger
        
        Args:
            parameter_name (Name): 
            only_if_exists (bool): 
        
        Returns:
            SetParamResult:
        """
        ...
    def set_string(self, parameter_name: Name, value: str, only_if_exists: bool = True) -> SetParamResult:
        r"""
        x.set_string(parameter_name, value, only_if_exists=True) -> SetParamResult
        Set String
        
        Args:
            parameter_name (Name): 
            value (str): 
            only_if_exists (bool): 
        
        Returns:
            SetParamResult:
        """
        ...
    def set_int(self, parameter_name: Name, value: int, only_if_exists: bool = True) -> SetParamResult:
        r"""
        x.set_int(parameter_name, value, only_if_exists=True) -> SetParamResult
        Set Int
        
        Args:
            parameter_name (Name): 
            value (int32): 
            only_if_exists (bool): 
        
        Returns:
            SetParamResult:
        """
        ...
    def set_float(self, parameter_name: Name, value: float, only_if_exists: bool = True) -> SetParamResult:
        r"""
        x.set_float(parameter_name, value, only_if_exists=True) -> SetParamResult
        Set Float
        
        Args:
            parameter_name (Name): 
            value (float): 
            only_if_exists (bool): 
        
        Returns:
            SetParamResult:
        """
        ...
    def set_bool(self, parameter_name: Name, value: bool, only_if_exists: bool = True) -> SetParamResult:
        r"""
        x.set_bool(parameter_name, value, only_if_exists=True) -> SetParamResult
        Set Bool
        
        Args:
            parameter_name (Name): 
            value (bool): 
            only_if_exists (bool): 
        
        Returns:
            SetParamResult:
        """
        ...
    @classmethod
    def make_metasound_parameter_pack(cls) -> MetasoundParameterPack:
        r"""
        X.make_metasound_parameter_pack() -> MetasoundParameterPack
        Make Metasound Parameter Pack
        
        Returns:
            MetasoundParameterPack:
        """
        ...
    def has_trigger(self, parameter_name: Name) -> bool:
        r"""
        x.has_trigger(parameter_name) -> bool
        Has Trigger
        
        Args:
            parameter_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def has_string(self, parameter_name: Name) -> bool:
        r"""
        x.has_string(parameter_name) -> bool
        Has String
        
        Args:
            parameter_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def has_int(self, parameter_name: Name) -> bool:
        r"""
        x.has_int(parameter_name) -> bool
        Has Int
        
        Args:
            parameter_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def has_float(self, parameter_name: Name) -> bool:
        r"""
        x.has_float(parameter_name) -> bool
        Has Float
        
        Args:
            parameter_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def has_bool(self, parameter_name: Name) -> bool:
        r"""
        x.has_bool(parameter_name) -> bool
        Has Bool
        
        Args:
            parameter_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def get_trigger(self, parameter_name: Name) -> Optional[SetParamResult]:
        r"""
        x.get_trigger(parameter_name) -> SetParamResult or None
        Get Trigger
        
        Args:
            parameter_name (Name): 
        
        Returns:
            SetParamResult or None: 
        
            result (SetParamResult):
        """
        ...
    def get_string(self, parameter_name: Name) -> Tuple[str, SetParamResult]:
        r"""
        x.get_string(parameter_name) -> (str, result=SetParamResult)
        Get String
        
        Args:
            parameter_name (Name): 
        
        Returns:
            SetParamResult: 
        
            result (SetParamResult):
        """
        ...
    def get_int(self, parameter_name: Name) -> Tuple[int, SetParamResult]:
        r"""
        x.get_int(parameter_name) -> (int32, result=SetParamResult)
        Get Int
        
        Args:
            parameter_name (Name): 
        
        Returns:
            SetParamResult: 
        
            result (SetParamResult):
        """
        ...
    def get_float(self, parameter_name: Name) -> Tuple[float, SetParamResult]:
        r"""
        x.get_float(parameter_name) -> (float, result=SetParamResult)
        Get Float
        
        Args:
            parameter_name (Name): 
        
        Returns:
            SetParamResult: 
        
            result (SetParamResult):
        """
        ...
    def get_bool(self, parameter_name: Name) -> Optional[SetParamResult]:
        r"""
        x.get_bool(parameter_name) -> SetParamResult or None
        Get Bool
        
        Args:
            parameter_name (Name): 
        
        Returns:
            SetParamResult or None: 
        
            result (SetParamResult):
        """
        ...

class WaveTableBank(Object):
    r"""
    Wave Table Bank
    
    **C++ Source:**
    
    - **Plugin**: WaveTable
    - **Module**: WaveTable
    - **File**: WaveTableBank.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bipolar`` (bool):  [Read-Write] Determines if output from curve/wavetable are to be clamped between
      [-1.0f, 1.0f] (i.e. for waveform generation, oscillation, etc.)
      or [0.0f, 1.0f] (i.e. for enveloping) when sampling curve/wavetable
    - ``entries`` (Array[WaveTableBankEntry]):  [Read-Write]
    - ``resolution`` (WaveTableResolution):  [Read-Write] Number of samples cached for each entry in the given bank.
    - ``sample_mode`` (WaveTableSamplingMode):  [Read-Write] Sampling mode used for the bank.
    - ``sample_rate`` (int32):  [Read-Write] Number of samples cached for each entry in the given bank.
    - ``wave_table_size_mb`` (float):  [Read-Only] Sum total size of all WaveTable data within the given bank
    """
    ...

class MetasoundFrontendLiteralBlueprintAccess(BlueprintFunctionLibrary):
    r"""
    Blueprint support for FMetasoundFrontendLiteral
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundFrontendLiteralBlueprintAccess.h
    
    """
    @classmethod
    def create_string_meta_sound_literal(cls, value: str) -> MetasoundFrontendLiteral:
        r"""
        X.create_string_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create String Meta Sound Literal
        
        Args:
            value (str): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    @classmethod
    def create_string_array_meta_sound_literal(cls, value: Array[str]) -> MetasoundFrontendLiteral:
        r"""
        X.create_string_array_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create String Array Meta Sound Literal
        
        Args:
            value (Array[str]): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    @classmethod
    def create_object_meta_sound_literal(cls, value: Object) -> MetasoundFrontendLiteral:
        r"""
        X.create_object_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create Object Meta Sound Literal
        
        Args:
            value (Object): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    @classmethod
    def create_object_array_meta_sound_literal(cls, value: Array[Object]) -> MetasoundFrontendLiteral:
        r"""
        X.create_object_array_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create Object Array Meta Sound Literal
        
        Args:
            value (Array[Object]): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    @classmethod
    def create_meta_sound_literal_from_param(cls, param: AudioParameter) -> MetasoundFrontendLiteral:
        r"""
        X.create_meta_sound_literal_from_param(param) -> MetasoundFrontendLiteral
        Create Meta Sound Literal from Param
        
        Args:
            param (AudioParameter): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    @classmethod
    def create_int_meta_sound_literal(cls, value: int) -> MetasoundFrontendLiteral:
        r"""
        X.create_int_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create Int Meta Sound Literal
        
        Args:
            value (int32): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    @classmethod
    def create_int_array_meta_sound_literal(cls, value: Array[int]) -> MetasoundFrontendLiteral:
        r"""
        X.create_int_array_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create Int Array Meta Sound Literal
        
        Args:
            value (Array[int32]): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    @classmethod
    def create_float_meta_sound_literal(cls, value: float) -> MetasoundFrontendLiteral:
        r"""
        X.create_float_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create Float Meta Sound Literal
        
        Args:
            value (float): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    @classmethod
    def create_float_array_meta_sound_literal(cls, value: Array[float]) -> MetasoundFrontendLiteral:
        r"""
        X.create_float_array_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create Float Array Meta Sound Literal
        
        Args:
            value (Array[float]): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    @classmethod
    def create_bool_meta_sound_literal(cls, value: bool) -> MetasoundFrontendLiteral:
        r"""
        X.create_bool_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create Bool Meta Sound Literal
        
        Args:
            value (bool): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    @classmethod
    def create_bool_array_meta_sound_literal(cls, value: Array[bool]) -> MetasoundFrontendLiteral:
        r"""
        X.create_bool_array_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create Bool Array Meta Sound Literal
        
        Args:
            value (Array[bool]): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...

class MetasoundGeneratorHandle(Object):
    r"""
    Blueprint-facing interface to a FMetasoundGenerator on a UAudioComponent.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundGeneratorHandle.h
    
    """
    def watch_output(self, output_name: Name, on_output_value_changed: OnMetasoundOutputValueChanged, analyzer_name: Name = "None", analyzer_output_name: Name = "None") -> bool:
        r"""
        x.watch_output(output_name, on_output_value_changed, analyzer_name="None", analyzer_output_name="None") -> bool
        Watch an output value.
        
        Args:
            output_name (Name): The user-specified name of the output in the Metasound
            on_output_value_changed (OnMetasoundOutputValueChanged): The event to fire when the output's value changes
            analyzer_name (Name): (optional) The name of the analyzer to use on the output, defaults to a passthrough
            analyzer_output_name (Name): (optional) The name of the output on the analyzer to watch, defaults to the passthrough output
        
        Returns:
            bool: true if the watch setup succeeded, false otherwise
        """
        ...
    def update_watchers(self) -> None:
        r"""
        x.update_watchers() -> None
        Update any watched outputs
        """
        ...
    def get_cpu_core_utilization(self) -> float:
        r"""
        x.get_cpu_core_utilization() -> double
        Get the CPU usage as "fraction of real time" used to render this metasound.
        NOTE: The MetasoundSource asset MUST have had its EnableRenderTiming function called
        before the metasound is started!
        
        Returns:
            double:
        """
        ...
    def enable_runtime_render_timing(self, enable: bool) -> None:
        r"""
        x.enable_runtime_render_timing(enable) -> None
        Enable the profiling of the MetaSound render for this playing instance. You
        must call this before calling "GetRuntimeCPUCoreUtilization" (below) or you will just
        get 0.0 back for core utilization.
        
        Args:
            enable (bool):
        """
        ...
    @classmethod
    def create_meta_sound_generator_handle(cls, on_component: AudioComponent) -> MetasoundGeneratorHandle:
        r"""
        X.create_meta_sound_generator_handle(on_component) -> MetasoundGeneratorHandle
        Create Meta Sound Generator Handle
        
        Args:
            on_component (AudioComponent): 
        
        Returns:
            MetasoundGeneratorHandle:
        """
        ...
    def apply_parameter_pack(self, pack: MetasoundParameterPack) -> bool:
        r"""
        x.apply_parameter_pack(pack) -> bool
        Makes a copy of the supplied parameter pack and passes it to the MetaSoundGenerator
        for asynchronous processing. IT ALSO caches this copy so that if the AudioComponent
        is virtualized the parameter pack will be sent again when/if the AudioComponent is
        "unvirtualized".
        
        Args:
            pack (MetasoundParameterPack): 
        
        Returns:
            bool:
        """
        ...

class AudioEngineSubsystem(DynamicSubsystem):
    r"""
    UAudioEngineSubsystem
    Base class for auto instanced and initialized systems that share the lifetime of the audio device
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: AudioEngineSubsystem.h
    
    """
    ...

class MetaSoundCacheSubsystem(AudioEngineSubsystem):
    r"""
    UMetaSoundCacheSubsystem
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundOperatorCacheSubsystem.h
    
    """
    def touch_or_precache_meta_sound(self, meta_sound: MetaSoundSource, num_instances: int = 1) -> None:
        r"""
        x.touch_or_precache_meta_sound(meta_sound, num_instances=1) -> None
        same as PrecacheMetaSound except cached operator that already exists in the cache will be moved to the top instead of building,
              any operators that we couldn't move to the top, will be built.
              (i.e. if 2 operators are already cached and Num Instances is 4, it will construct 2 and move the existing 2 to the top of the cache)
        
        Args:
            meta_sound (MetaSoundSource): 
            num_instances (int32):
        """
        ...
    def remove_cached_operators_for_meta_sound(self, meta_sound: MetaSoundSource) -> None:
        r"""
        x.remove_cached_operators_for_meta_sound(meta_sound) -> None
        Clear the operator pool of any operators associated with the given MetaSound
        
        Args:
            meta_sound (MetaSoundSource):
        """
        ...
    def precache_meta_sound(self, meta_sound: MetaSoundSource, num_instances: int = 1) -> None:
        r"""
        x.precache_meta_sound(meta_sound, num_instances=1) -> None
        Builds the requested number of MetaSound operators (asynchronously) and puts them in the pool for playback.
              (If these operators are not yet available when the MetaSound attempts to play, one will be created Independent of this request.)
        
        Args:
            meta_sound (MetaSoundSource): 
            num_instances (int32):
        """
        ...

class MetasoundOutputBlueprintAccess(BlueprintFunctionLibrary):
    r"""
    Blueprint support for core types. If you want to support more core types, add them here.
    If you want to support types introduced in other plugins, create a blueprint library in that plugin.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundOutput.h
    
    """
    @classmethod
    def is_time(cls, output: MetaSoundOutput) -> bool:
        r"""
        X.is_time(output) -> bool
        Is Time
        
        Args:
            output (MetaSoundOutput): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_string(cls, output: MetaSoundOutput) -> bool:
        r"""
        X.is_string(output) -> bool
        Is String
        
        Args:
            output (MetaSoundOutput): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_int32(cls, output: MetaSoundOutput) -> bool:
        r"""
        X.is_int32(output) -> bool
        Is Int 32
        
        Args:
            output (MetaSoundOutput): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_float(cls, output: MetaSoundOutput) -> bool:
        r"""
        X.is_float(output) -> bool
        Is Float
        
        Args:
            output (MetaSoundOutput): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_bool(cls, output: MetaSoundOutput) -> bool:
        r"""
        X.is_bool(output) -> bool
        Is Bool
        
        Args:
            output (MetaSoundOutput): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_time_seconds(cls, output: MetaSoundOutput) -> Tuple[float, bool]:
        r"""
        X.get_time_seconds(output) -> (double, success=bool)
        Get Time Seconds
        
        Args:
            output (MetaSoundOutput): 
        
        Returns:
            bool: 
        
            success (bool):
        """
        ...
    @classmethod
    def get_string(cls, output: MetaSoundOutput) -> Tuple[str, bool]:
        r"""
        X.get_string(output) -> (str, success=bool)
        Get String
        
        Args:
            output (MetaSoundOutput): 
        
        Returns:
            bool: 
        
            success (bool):
        """
        ...
    @classmethod
    def get_int32(cls, output: MetaSoundOutput) -> Tuple[int, bool]:
        r"""
        X.get_int32(output) -> (int32, success=bool)
        Get Int 32
        
        Args:
            output (MetaSoundOutput): 
        
        Returns:
            bool: 
        
            success (bool):
        """
        ...
    @classmethod
    def get_float(cls, output: MetaSoundOutput) -> Tuple[float, bool]:
        r"""
        X.get_float(output) -> (float, success=bool)
        Get Float
        
        Args:
            output (MetaSoundOutput): 
        
        Returns:
            bool: 
        
            success (bool):
        """
        ...
    @classmethod
    def get_bool(cls, output: MetaSoundOutput) -> Optional[bool]:
        r"""
        X.get_bool(output) -> bool or None
        Get Bool
        
        Args:
            output (MetaSoundOutput): 
        
        Returns:
            bool or None: 
        
            success (bool):
        """
        ...

class MetaSoundOutputSubsystem(TickableWorldSubsystem):
    r"""
    Provides access to a playing Metasound generator's outputs
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundOutputSubsystem.h
    
    """
    def watch_output(self, audio_component: AudioComponent, output_name: Name, on_output_value_changed: OnMetasoundOutputValueChanged, analyzer_name: Name = "None", analyzer_output_name: Name = "None") -> bool:
        r"""
        x.watch_output(audio_component, output_name, on_output_value_changed, analyzer_name="None", analyzer_output_name="None") -> bool
        Watch an output on a Metasound playing on a given audio component.
        
        Args:
            audio_component (AudioComponent): The audio component
            output_name (Name): The user-specified name of the output in the Metasound
            on_output_value_changed (OnMetasoundOutputValueChanged): The event to fire when the output's value changes
            analyzer_name (Name): (optional) The name of the analyzer to use on the output, defaults to a passthrough
            analyzer_output_name (Name): (optional) The name of the output on the analyzer to watch, defaults to the passthrough output
        
        Returns:
            bool: true if the watch setup succeeded, false otherwise
        """
        ...

class MetaSoundPatch(Object):
    r"""
    This asset type is used for Metasound assets that can only be used as nodes in other Metasound graphs.
    Because of this, they contain no required inputs or outputs.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: Metasound.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``root_meta_sound_document`` (MetasoundFrontendDocument):  [Read-Write]
    """
    ...

class MetaSound(MetaSoundPatch):
    r"""
    deprecated: 'MetaSound' was renamed to 'MetaSoundPatch'.
    """
    ...

class MetaSoundAssetSubsystem(EngineSubsystem):
    r"""
    The subsystem in charge of the MetaSound asset registry
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundAssetSubsystem.h
    
    """
    def unregister_asset_classes_in_directories(self, directories: Array[MetaSoundAssetDirectory]) -> None:
        r"""
        x.unregister_asset_classes_in_directories(directories) -> None
        Unregister Asset Classes in Directories
        
        Args:
            directories (Array[MetaSoundAssetDirectory]):
        """
        ...
    def register_asset_classes_in_directories(self, directories: Array[MetaSoundAssetDirectory]) -> None:
        r"""
        x.register_asset_classes_in_directories(directories) -> None
        Register Asset Classes in Directories
        
        Args:
            directories (Array[MetaSoundAssetDirectory]):
        """
        ...

class MetaSoundBuilderBase(Object):
    r"""
    Base implementation of MetaSound builder
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundBuilderSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_attached`` (bool):  [Read-Write]
      deprecated: 5.4 - All source builders now operate on an underlying document source document that is also used to audition.
    """
    @property
    def is_attached(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: 5.4 - All source builders now operate on an underlying document source document that is also used to audition.
        """
        ...
    @is_attached.setter
    def is_attached(self, value: bool) -> None:
        ...
    def set_node_input_default(self, node_input_handle: MetaSoundBuilderNodeInputHandle, literal: MetasoundFrontendLiteral) -> MetaSoundBuilderResult:
        r"""
        x.set_node_input_default(node_input_handle, literal) -> MetaSoundBuilderResult
        Sets the node's input default value (used if no connection to the given node input is present)
        
        Args:
            node_input_handle (MetaSoundBuilderNodeInputHandle): 
            literal (MetasoundFrontendLiteral): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def set_graph_input_default(self, input_name: Name, literal: MetasoundFrontendLiteral) -> MetaSoundBuilderResult:
        r"""
        x.set_graph_input_default(input_name, literal) -> MetaSoundBuilderResult
        Sets the input node's default value, overriding the default provided by the referenced graph if the graph is a preset.
        
        Args:
            input_name (Name): 
            literal (MetasoundFrontendLiteral): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def remove_node_input_default(self, input_handle: MetaSoundBuilderNodeInputHandle) -> MetaSoundBuilderResult:
        r"""
        x.remove_node_input_default(input_handle) -> MetaSoundBuilderResult
        Removes node input literal default if set, reverting the value to be whatever the node class defaults the value to.
        Returns success if value was removed, false if not removed (i.e. wasn't set to begin with).
        
        Args:
            input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def remove_node(self, node_handle: MetaSoundNodeHandle) -> MetaSoundBuilderResult:
        r"""
        x.remove_node(node_handle) -> MetaSoundBuilderResult
        Removes node and any associated connections from the builder's MetaSound.
        
        Args:
            node_handle (MetaSoundNodeHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def remove_interface(self, interface_name: Name) -> MetaSoundBuilderResult:
        r"""
        x.remove_interface(interface_name) -> MetaSoundBuilderResult
        Removes the interface with the given name from the builder's MetaSound. Removes any graph inputs
        and outputs associated with the given interface and their respective connections (if any).
        
        Args:
            interface_name (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def remove_graph_output(self, name: Name) -> MetaSoundBuilderResult:
        r"""
        x.remove_graph_output(name) -> MetaSoundBuilderResult
        Removes graph output if it exists; sets result to succeeded if it was removed and failed if it was not.
        
        Args:
            name (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def remove_graph_input(self, name: Name) -> MetaSoundBuilderResult:
        r"""
        x.remove_graph_input(name) -> MetaSoundBuilderResult
        Removes graph input if it exists; sets result to succeeded if it was removed and failed if it was not.
        
        Args:
            name (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def nodes_are_connected(self, output_handle: MetaSoundBuilderNodeOutputHandle, input_handle: MetaSoundBuilderNodeInputHandle) -> bool:
        r"""
        x.nodes_are_connected(output_handle, input_handle) -> bool
        Returns if a given node output and node input are connected.
        
        Args:
            output_handle (MetaSoundBuilderNodeOutputHandle): 
            input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            bool:
        """
        ...
    def node_output_is_connected(self, output_handle: MetaSoundBuilderNodeOutputHandle) -> bool:
        r"""
        x.node_output_is_connected(output_handle) -> bool
        Returns if a given node output is connected.
        
        Args:
            output_handle (MetaSoundBuilderNodeOutputHandle): 
        
        Returns:
            bool:
        """
        ...
    def node_input_is_connected(self, input_handle: MetaSoundBuilderNodeInputHandle) -> bool:
        r"""
        x.node_input_is_connected(input_handle) -> bool
        Returns if a given node input has connections.
        
        Args:
            input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            bool:
        """
        ...
    def is_preset(self) -> bool:
        r"""
        x.is_preset() -> bool
        Returns whether this is a preset.
        
        Returns:
            bool:
        """
        ...
    def interface_is_declared(self, interface_name: Name) -> bool:
        r"""
        x.interface_is_declared(interface_name) -> bool
        Returns if a given interface is declared.
        
        Args:
            interface_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def get_referenced_preset_asset(self) -> Object:
        r"""
        x.get_referenced_preset_asset() -> Object
        Return the asset referenced by this preset builder. Returns nullptr if the builder is not a preset.
        
        Returns:
            Object:
        """
        ...
    def get_node_output_is_constructor_pin(self, output_handle: MetaSoundBuilderNodeOutputHandle) -> bool:
        r"""
        x.get_node_output_is_constructor_pin(output_handle) -> bool
        Returns whether the given node output is a constructor pin
        
        Args:
            output_handle (MetaSoundBuilderNodeOutputHandle): 
        
        Returns:
            bool:
        """
        ...
    def get_node_output_data(self, output_handle: MetaSoundBuilderNodeOutputHandle) -> Tuple[Name, Name, MetaSoundBuilderResult]:
        r"""
        x.get_node_output_data(output_handle) -> (name=Name, data_type=Name, out_result=MetaSoundBuilderResult)
        Returns node output's data if valid (including things like name and datatype).
        
        Args:
            output_handle (MetaSoundBuilderNodeOutputHandle): 
        
        Returns:
            tuple: 
        
            name (Name): 
        
            data_type (Name): 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def get_node_input_is_constructor_pin(self, input_handle: MetaSoundBuilderNodeInputHandle) -> bool:
        r"""
        x.get_node_input_is_constructor_pin(input_handle) -> bool
        Returns whether the given node input is a constructor pin
        
        Args:
            input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            bool:
        """
        ...
    def get_node_input_default(self, input_handle: MetaSoundBuilderNodeInputHandle) -> Tuple[MetasoundFrontendLiteral, MetaSoundBuilderResult]:
        r"""
        x.get_node_input_default(input_handle) -> (MetasoundFrontendLiteral, out_result=MetaSoundBuilderResult)
        Returns node input's literal value if set on graph, otherwise fails and returns default literal.
        
        Args:
            input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def get_node_input_data(self, input_handle: MetaSoundBuilderNodeInputHandle) -> Tuple[Name, Name, MetaSoundBuilderResult]:
        r"""
        x.get_node_input_data(input_handle) -> (name=Name, data_type=Name, out_result=MetaSoundBuilderResult)
        Returns node input's data if valid (including things like name and datatype).
        
        Args:
            input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            tuple: 
        
            name (Name): 
        
            data_type (Name): 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def get_node_input_class_default(self, input_handle: MetaSoundBuilderNodeInputHandle) -> Tuple[MetasoundFrontendLiteral, MetaSoundBuilderResult]:
        r"""
        x.get_node_input_class_default(input_handle) -> (MetasoundFrontendLiteral, out_result=MetaSoundBuilderResult)
        Returns node input's class literal value if set, otherwise fails and returns default literal.
        
        Args:
            input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_node_outputs_by_data_type(self, node_handle: MetaSoundNodeHandle, data_type: Name) -> Tuple[Array[MetaSoundBuilderNodeOutputHandle], MetaSoundBuilderResult]:
        r"""
        x.find_node_outputs_by_data_type(node_handle, data_type) -> (Array[MetaSoundBuilderNodeOutputHandle], out_result=MetaSoundBuilderResult)
        Returns node outputs by the given DataType (ex. "Audio", "Trigger", "String", "Bool", "Float", "Int32", etc.).
        
        Args:
            node_handle (MetaSoundNodeHandle): 
            data_type (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_node_outputs(self, node_handle: MetaSoundNodeHandle) -> Tuple[Array[MetaSoundBuilderNodeOutputHandle], MetaSoundBuilderResult]:
        r"""
        x.find_node_outputs(node_handle) -> (Array[MetaSoundBuilderNodeOutputHandle], out_result=MetaSoundBuilderResult)
        Returns all node outputs.
        
        Args:
            node_handle (MetaSoundNodeHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_node_output_parent(self, output_handle: MetaSoundBuilderNodeOutputHandle) -> Tuple[MetaSoundNodeHandle, MetaSoundBuilderResult]:
        r"""
        x.find_node_output_parent(output_handle) -> (MetaSoundNodeHandle, out_result=MetaSoundBuilderResult)
        Returns output's parent node if the input is valid, otherwise returns invalid node handle.
        
        Args:
            output_handle (MetaSoundBuilderNodeOutputHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_node_output_by_name(self, node_handle: MetaSoundNodeHandle, output_name: Name) -> Tuple[MetaSoundBuilderNodeOutputHandle, MetaSoundBuilderResult]:
        r"""
        x.find_node_output_by_name(node_handle, output_name) -> (MetaSoundBuilderNodeOutputHandle, out_result=MetaSoundBuilderResult)
        Returns node output by the given name.
        
        Args:
            node_handle (MetaSoundNodeHandle): 
            output_name (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_node_inputs_by_data_type(self, node_handle: MetaSoundNodeHandle, data_type: Name) -> Tuple[Array[MetaSoundBuilderNodeInputHandle], MetaSoundBuilderResult]:
        r"""
        x.find_node_inputs_by_data_type(node_handle, data_type) -> (Array[MetaSoundBuilderNodeInputHandle], out_result=MetaSoundBuilderResult)
        Returns node inputs by the given DataType (ex. "Audio", "Trigger", "String", "Bool", "Float", "Int32", etc.).
        
        Args:
            node_handle (MetaSoundNodeHandle): 
            data_type (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_node_inputs(self, node_handle: MetaSoundNodeHandle) -> Tuple[Array[MetaSoundBuilderNodeInputHandle], MetaSoundBuilderResult]:
        r"""
        x.find_node_inputs(node_handle) -> (Array[MetaSoundBuilderNodeInputHandle], out_result=MetaSoundBuilderResult)
        Returns all node inputs.
        
        Args:
            node_handle (MetaSoundNodeHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_node_input_parent(self, input_handle: MetaSoundBuilderNodeInputHandle) -> Tuple[MetaSoundNodeHandle, MetaSoundBuilderResult]:
        r"""
        x.find_node_input_parent(input_handle) -> (MetaSoundNodeHandle, out_result=MetaSoundBuilderResult)
        Returns input's parent node if the input is valid, otherwise returns invalid node handle.
        
        Args:
            input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_node_input_by_name(self, node_handle: MetaSoundNodeHandle, input_name: Name) -> Tuple[MetaSoundBuilderNodeInputHandle, MetaSoundBuilderResult]:
        r"""
        x.find_node_input_by_name(node_handle, input_name) -> (MetaSoundBuilderNodeInputHandle, out_result=MetaSoundBuilderResult)
        Returns node input by the given name if it exists, or an invalid handle if not found.
        
        Args:
            node_handle (MetaSoundNodeHandle): 
            input_name (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_node_class_version(self, node_handle: MetaSoundNodeHandle) -> Tuple[MetasoundFrontendVersion, MetaSoundBuilderResult]:
        r"""
        x.find_node_class_version(node_handle) -> (MetasoundFrontendVersion, out_result=MetaSoundBuilderResult)
        Returns output's parent node if the input is valid, otherwise returns invalid node handle.
        
        Args:
            node_handle (MetaSoundNodeHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_interface_output_nodes(self, interface_name: Name) -> Tuple[Array[MetaSoundNodeHandle], MetaSoundBuilderResult]:
        r"""
        x.find_interface_output_nodes(interface_name) -> (Array[MetaSoundNodeHandle], out_result=MetaSoundBuilderResult)
        Returns output nodes associated with a given interface.
        
        Args:
            interface_name (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_interface_input_nodes(self, interface_name: Name) -> Tuple[Array[MetaSoundNodeHandle], MetaSoundBuilderResult]:
        r"""
        x.find_interface_input_nodes(interface_name) -> (Array[MetaSoundNodeHandle], out_result=MetaSoundBuilderResult)
        Returns input nodes associated with a given interface.
        
        Args:
            interface_name (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_graph_output_node(self, output_name: Name) -> Tuple[MetaSoundNodeHandle, MetaSoundBuilderResult]:
        r"""
        x.find_graph_output_node(output_name) -> (MetaSoundNodeHandle, out_result=MetaSoundBuilderResult)
        Returns graph output node by the given name if it exists, or an invalid handle if not found.
        
        Args:
            output_name (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def find_graph_input_node(self, input_name: Name) -> Tuple[MetaSoundNodeHandle, MetaSoundBuilderResult]:
        r"""
        x.find_graph_input_node(input_name) -> (MetaSoundNodeHandle, out_result=MetaSoundBuilderResult)
        Returns graph input node by the given name if it exists, or an invalid handle if not found.
        
        Args:
            input_name (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def disconnect_nodes_by_interface_bindings(self, from_node_handle: MetaSoundNodeHandle, to_node_handle: MetaSoundNodeHandle) -> MetaSoundBuilderResult:
        r"""
        x.disconnect_nodes_by_interface_bindings(from_node_handle, to_node_handle) -> MetaSoundBuilderResult
        Disconnects two nodes using defined MetaSound Interface Bindings registered with the MetaSound Interface registry. Returns success if
        all connections were found and removed, failed if any connections were not.
        
        Args:
            from_node_handle (MetaSoundNodeHandle): 
            to_node_handle (MetaSoundNodeHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def disconnect_nodes(self, node_output_handle: MetaSoundBuilderNodeOutputHandle, node_input_handle: MetaSoundBuilderNodeInputHandle) -> MetaSoundBuilderResult:
        r"""
        x.disconnect_nodes(node_output_handle, node_input_handle) -> MetaSoundBuilderResult
        Disconnects node output to a node input. Returns success if connection was removed, failed if not.
        
        Args:
            node_output_handle (MetaSoundBuilderNodeOutputHandle): 
            node_input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def disconnect_node_output(self, node_output_handle: MetaSoundBuilderNodeOutputHandle) -> MetaSoundBuilderResult:
        r"""
        x.disconnect_node_output(node_output_handle) -> MetaSoundBuilderResult
        Removes all connections from a given node output. Returns success if all connections were removed, failed if not.
        
        Args:
            node_output_handle (MetaSoundBuilderNodeOutputHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def disconnect_node_input(self, node_input_handle: MetaSoundBuilderNodeInputHandle) -> MetaSoundBuilderResult:
        r"""
        x.disconnect_node_input(node_input_handle) -> MetaSoundBuilderResult
        Removes connection to a given node input. Returns success if connection was removed, failed if not.
        
        Args:
            node_input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def convert_to_preset(self, referenced_node_class: MetaSoundDocumentInterface) -> MetaSoundBuilderResult:
        r"""
        x.convert_to_preset(referenced_node_class) -> MetaSoundBuilderResult
        Convert this builder to a MetaSound source preset with the given referenced source builder
        
        Args:
            referenced_node_class (MetaSoundDocumentInterface): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def convert_from_preset(self) -> MetaSoundBuilderResult:
        r"""
        x.convert_from_preset() -> MetaSoundBuilderResult
        Converts this preset to a fully accessible MetaSound; sets result to succeeded if it was converted successfully and failed if it was not.
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def contains_node_output(self, output: MetaSoundBuilderNodeOutputHandle) -> bool:
        r"""
        x.contains_node_output(output) -> bool
        Returns whether node output exists.
        
        Args:
            output (MetaSoundBuilderNodeOutputHandle): 
        
        Returns:
            bool:
        """
        ...
    def contains_node_input(self, input: MetaSoundBuilderNodeInputHandle) -> bool:
        r"""
        x.contains_node_input(input) -> bool
        Returns whether node input exists.
        
        Args:
            input (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            bool:
        """
        ...
    def contains_node(self, node: MetaSoundNodeHandle) -> bool:
        r"""
        x.contains_node(node) -> bool
        Returns whether node exists.
        
        Args:
            node (MetaSoundNodeHandle): 
        
        Returns:
            bool:
        """
        ...
    def connect_nodes_by_interface_bindings(self, from_node_handle: MetaSoundNodeHandle, to_node_handle: MetaSoundNodeHandle) -> MetaSoundBuilderResult:
        r"""
        x.connect_nodes_by_interface_bindings(from_node_handle, to_node_handle) -> MetaSoundBuilderResult
        Connects two nodes using defined MetaSound Interface Bindings registered with the MetaSound Interface registry.
        
        Args:
            from_node_handle (MetaSoundNodeHandle): 
            to_node_handle (MetaSoundNodeHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def connect_nodes(self, node_output_handle: MetaSoundBuilderNodeOutputHandle, node_input_handle: MetaSoundBuilderNodeInputHandle) -> MetaSoundBuilderResult:
        r"""
        x.connect_nodes(node_output_handle, node_input_handle) -> MetaSoundBuilderResult
        Connects node output to a node input. Does *NOT* provide loop detection for performance reasons.  Loop detection is checked on class registration when built or played.
        Returns succeeded if connection made, failed if connection already exists with input, the data types do not match, or the connection is not supported due to access type
        incompatibility (ex. constructor input to non-constructor input).
        
        Args:
            node_output_handle (MetaSoundBuilderNodeOutputHandle): 
            node_input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def connect_node_output_to_graph_output(self, graph_output_name: Name, node_output_handle: MetaSoundBuilderNodeOutputHandle) -> MetaSoundBuilderResult:
        r"""
        x.connect_node_output_to_graph_output(graph_output_name, node_output_handle) -> MetaSoundBuilderResult
        Connects a given node output to the graph output with the given name.
        
        Args:
            graph_output_name (Name): 
            node_output_handle (MetaSoundBuilderNodeOutputHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def connect_node_outputs_to_matching_graph_interface_outputs(self, node_handle: MetaSoundNodeHandle) -> Tuple[Array[MetaSoundBuilderNodeInputHandle], MetaSoundBuilderResult]:
        r"""
        x.connect_node_outputs_to_matching_graph_interface_outputs(node_handle) -> (Array[MetaSoundBuilderNodeInputHandle], out_result=MetaSoundBuilderResult)
        Connects a given node's outputs to all graph outputs for shared interfaces implemented on both the node's referenced class and the builder's MetaSound graph. Returns inputs of connected output nodes.
        
        Args:
            node_handle (MetaSoundNodeHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def connect_node_input_to_graph_input(self, graph_input_name: Name, node_input_handle: MetaSoundBuilderNodeInputHandle) -> MetaSoundBuilderResult:
        r"""
        x.connect_node_input_to_graph_input(graph_input_name, node_input_handle) -> MetaSoundBuilderResult
        Connects a given node input to the graph input with the given name.
        
        Args:
            graph_input_name (Name): 
            node_input_handle (MetaSoundBuilderNodeInputHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def connect_node_inputs_to_matching_graph_interface_inputs(self, node_handle: MetaSoundNodeHandle) -> Tuple[Array[MetaSoundBuilderNodeOutputHandle], MetaSoundBuilderResult]:
        r"""
        x.connect_node_inputs_to_matching_graph_interface_inputs(node_handle) -> (Array[MetaSoundBuilderNodeOutputHandle], out_result=MetaSoundBuilderResult)
        Connects a given node's inputs to all graph inputs for shared interfaces implemented on both the node's referenced class and the builder's MetaSound graph. Returns outputs of connected input nodes.
        
        Args:
            node_handle (MetaSoundNodeHandle): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def add_node_by_class_name(self, class_name: MetasoundFrontendClassName, major_version: int = 1) -> Tuple[MetaSoundNodeHandle, MetaSoundBuilderResult]:
        r"""
        x.add_node_by_class_name(class_name, major_version=1) -> (MetaSoundNodeHandle, out_result=MetaSoundBuilderResult)
        Adds node referencing the highest native class version of the given class name to the document.
        Returns a node handle to the created node if successful, or an invalid handle if it failed.
        
        Args:
            class_name (MetasoundFrontendClassName): 
            major_version (int32): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def add_node(self, node_class: MetaSoundDocumentInterface) -> Tuple[MetaSoundNodeHandle, MetaSoundBuilderResult]:
        r"""
        x.add_node(node_class) -> (MetaSoundNodeHandle, out_result=MetaSoundBuilderResult)
        Adds a node to the graph using the provided MetaSound asset as its defining NodeClass.
        Returns a node handle to the created node if successful, or an invalid handle if it failed.
        
        Args:
            node_class (MetaSoundDocumentInterface): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def add_interface(self, interface_name: Name) -> MetaSoundBuilderResult:
        r"""
        x.add_interface(interface_name) -> MetaSoundBuilderResult
        Adds an interface registered with the given name to the graph, adding associated input and output nodes.
        
        Args:
            interface_name (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def add_graph_output_node(self, name: Name, data_type: Name, default_value: MetasoundFrontendLiteral, is_constructor_output: bool = False) -> Tuple[MetaSoundBuilderNodeInputHandle, MetaSoundBuilderResult]:
        r"""
        x.add_graph_output_node(name, data_type, default_value, is_constructor_output=False) -> (MetaSoundBuilderNodeInputHandle, out_result=MetaSoundBuilderResult)
        Adds a graph output node with the given name, DataType, and sets output node's input to default value.
        Returns the new output node's input handle if it was successfully created, or an invalid handle if it failed.
        
        Args:
            name (Name): 
            data_type (Name): 
            default_value (MetasoundFrontendLiteral): 
            is_constructor_output (bool): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def add_graph_input_node(self, name: Name, data_type: Name, default_value: MetasoundFrontendLiteral, is_constructor_input: bool = False) -> Tuple[MetaSoundBuilderNodeOutputHandle, MetaSoundBuilderResult]:
        r"""
        x.add_graph_input_node(name, data_type, default_value, is_constructor_input=False) -> (MetaSoundBuilderNodeOutputHandle, out_result=MetaSoundBuilderResult)
        Adds a graph input node with the given name, DataType, and sets the graph input to default value.
        Returns the new input node's output handle if it was successfully created, or an invalid handle if it failed.
        
        Args:
            name (Name): 
            data_type (Name): 
            default_value (MetasoundFrontendLiteral): 
            is_constructor_input (bool): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...

class MetaSoundPatchBuilder(MetaSoundBuilderBase):
    r"""
    Builder in charge of building a MetaSound Patch
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundBuilderSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_attached`` (bool):  [Read-Write]
      deprecated: 5.4 - All source builders now operate on an underlying document source document that is also used to audition.
    """
    def build(self, parent: Object, options: MetaSoundBuilderOptions) -> MetaSoundDocumentInterface:
        r"""
        x.build(parent, options) -> MetaSoundDocumentInterface
        Build
        
        Args:
            parent (Object): 
            options (MetaSoundBuilderOptions): 
        
        Returns:
            MetaSoundDocumentInterface:
        """
        ...

class MetaSoundSourceBuilder(MetaSoundBuilderBase):
    r"""
    Builder in charge of building a MetaSound Source
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundBuilderSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_attached`` (bool):  [Read-Write]
      deprecated: 5.4 - All source builders now operate on an underlying document source document that is also used to audition.
    """
    def set_sample_rate_override(self, sample_rate: int) -> None:
        r"""
        x.set_sample_rate_override(sample_rate) -> None
        Sets the MetaSound's SampleRate override
        
        Args:
            sample_rate (int32):
        """
        ...
    def set_quality(self, quality: Name) -> None:
        r"""
        x.set_quality(quality) -> None
        Sets the MetaSound's Quality level
        
        Args:
            quality (Name):
        """
        ...
    def set_format(self, output_format: MetaSoundOutputAudioFormat) -> MetaSoundBuilderResult:
        r"""
        x.set_format(output_format) -> MetaSoundBuilderResult
        Sets the output audio format of the source
        
        Args:
            output_format (MetaSoundOutputAudioFormat): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def set_block_rate_override(self, block_rate: float) -> None:
        r"""
        x.set_block_rate_override(block_rate) -> None
        Sets the MetaSound's BlockRate override
        
        Args:
            block_rate (float):
        """
        ...
    def get_live_updates_enabled(self) -> bool:
        r"""
        x.get_live_updates_enabled() -> bool
        Returns whether or not live updates are both globally enabled (via cvar) and are enabled on this builder's last built sound, which may or may not still be playing.
        
        Returns:
            bool:
        """
        ...
    def build(self, parent: Object, options: MetaSoundBuilderOptions) -> MetaSoundDocumentInterface:
        r"""
        x.build(parent, options) -> MetaSoundDocumentInterface
        Build
        
        Args:
            parent (Object): 
            options (MetaSoundBuilderOptions): 
        
        Returns:
            MetaSoundDocumentInterface:
        """
        ...
    def audition(self, parent: Object, audio_component: AudioComponent, on_create_generator: OnCreateAuditionGeneratorHandleDelegate, live_updates_enabled: bool = False) -> None:
        r"""
        x.audition(parent, audio_component, on_create_generator, live_updates_enabled=False) -> None
        Audition
        
        Args:
            parent (Object): 
            audio_component (AudioComponent): 
            on_create_generator (OnCreateAuditionGeneratorHandleDelegate): 
            live_updates_enabled (bool):
        """
        ...

class MetaSoundBuilderSubsystem(EngineSubsystem):
    r"""
    The subsystem in charge of tracking MetaSound builders
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundBuilderSubsystem.h
    
    """
    def unregister_source_builder(self, builder_name: Name) -> bool:
        r"""
        x.unregister_source_builder(builder_name) -> bool
        Unregister Source Builder
        
        Args:
            builder_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def unregister_patch_builder(self, builder_name: Name) -> bool:
        r"""
        x.unregister_patch_builder(builder_name) -> bool
        Unregister Patch Builder
        
        Args:
            builder_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def unregister_builder(self, builder_name: Name) -> bool:
        r"""
        x.unregister_builder(builder_name) -> bool
        Unregister Builder
        
        Args:
            builder_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def register_source_builder(self, builder_name: Name, builder: MetaSoundSourceBuilder) -> None:
        r"""
        x.register_source_builder(builder_name, builder) -> None
        Adds builder to subsystem's registry to make it persistent and easily accessible by multiple systems or Blueprints
        
        Args:
            builder_name (Name): 
            builder (MetaSoundSourceBuilder):
        """
        ...
    def register_patch_builder(self, builder_name: Name, builder: MetaSoundPatchBuilder) -> None:
        r"""
        x.register_patch_builder(builder_name, builder) -> None
        Adds builder to subsystem's registry to make it persistent and easily accessible by multiple systems or Blueprints
        
        Args:
            builder_name (Name): 
            builder (MetaSoundPatchBuilder):
        """
        ...
    def register_builder(self, builder_name: Name, builder: MetaSoundBuilderBase) -> None:
        r"""
        x.register_builder(builder_name, builder) -> None
        Adds builder to subsystem's registry to make it persistent and easily accessible by multiple systems or Blueprints
        
        Args:
            builder_name (Name): 
            builder (MetaSoundBuilderBase):
        """
        ...
    def is_interface_registered(self, interface_name: Name) -> bool:
        r"""
        x.is_interface_registered(interface_name) -> bool
        Is Interface Registered
        
        Args:
            interface_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def find_source_builder(self, builder_name: Name) -> MetaSoundSourceBuilder:
        r"""
        x.find_source_builder(builder_name) -> MetaSoundSourceBuilder
        Returns the source builder manually registered with the MetaSound Builder Subsystem with the provided custom name (if previously registered)
        
        Args:
            builder_name (Name): 
        
        Returns:
            MetaSoundSourceBuilder:
        """
        ...
    def find_patch_builder(self, builder_name: Name) -> MetaSoundPatchBuilder:
        r"""
        x.find_patch_builder(builder_name) -> MetaSoundPatchBuilder
        Returns the patch builder manually registered with the MetaSound Builder Subsystem with the provided custom name (if previously registered)
        
        Args:
            builder_name (Name): 
        
        Returns:
            MetaSoundPatchBuilder:
        """
        ...
    def find_builder_of_document(self, meta_sound: MetaSoundDocumentInterface) -> MetaSoundBuilderBase:
        r"""
        x.find_builder_of_document(meta_sound) -> MetaSoundBuilderBase
        Returns the builder associated with the given MetaSound (if one exists, transient or asset).
        
        Args:
            meta_sound (MetaSoundDocumentInterface): 
        
        Returns:
            MetaSoundBuilderBase:
        """
        ...
    def find_builder(self, builder_name: Name) -> MetaSoundBuilderBase:
        r"""
        x.find_builder(builder_name) -> MetaSoundBuilderBase
        Returns the builder manually registered with the MetaSound Builder Subsystem with the provided custom name (if previously registered)
        
        Args:
            builder_name (Name): 
        
        Returns:
            MetaSoundBuilderBase:
        """
        ...
    def create_string_meta_sound_literal(self, value: str) -> Tuple[MetasoundFrontendLiteral, Name]:
        r"""
        x.create_string_meta_sound_literal(value) -> (MetasoundFrontendLiteral, data_type=Name)
        Create String Meta Sound Literal
        
        Args:
            value (str): 
        
        Returns:
            Name: 
        
            data_type (Name):
        """
        ...
    def create_string_array_meta_sound_literal(self, value: Array[str]) -> Tuple[MetasoundFrontendLiteral, Name]:
        r"""
        x.create_string_array_meta_sound_literal(value) -> (MetasoundFrontendLiteral, data_type=Name)
        Create String Array Meta Sound Literal
        
        Args:
            value (Array[str]): 
        
        Returns:
            Name: 
        
            data_type (Name):
        """
        ...
    def create_source_preset_builder(self, builder_name: Name, referenced_source_class: MetaSoundDocumentInterface) -> Tuple[MetaSoundSourceBuilder, MetaSoundBuilderResult]:
        r"""
        x.create_source_preset_builder(builder_name, referenced_source_class) -> (MetaSoundSourceBuilder, out_result=MetaSoundBuilderResult)
        Create Source Preset Builder
        
        Args:
            builder_name (Name): 
            referenced_source_class (MetaSoundDocumentInterface): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def create_source_builder(self, builder_name: Name, output_format: MetaSoundOutputAudioFormat = MetaSoundOutputAudioFormat.MONO, is_one_shot: bool = True) -> Tuple[MetaSoundSourceBuilder, MetaSoundBuilderNodeOutputHandle, MetaSoundBuilderNodeInputHandle, Array[MetaSoundBuilderNodeInputHandle], MetaSoundBuilderResult]:
        r"""
        x.create_source_builder(builder_name, output_format=MetaSoundOutputAudioFormat.MONO, is_one_shot=True) -> (MetaSoundSourceBuilder, on_play_node_output=MetaSoundBuilderNodeOutputHandle, on_finished_node_input=MetaSoundBuilderNodeInputHandle, audio_out_node_inputs=Array[MetaSoundBuilderNodeInputHandle], out_result=MetaSoundBuilderResult)
        Create Source Builder
        
        Args:
            builder_name (Name): 
            output_format (MetaSoundOutputAudioFormat): 
            is_one_shot (bool): 
        
        Returns:
            tuple: 
        
            on_play_node_output (MetaSoundBuilderNodeOutputHandle): 
        
            on_finished_node_input (MetaSoundBuilderNodeInputHandle): 
        
            audio_out_node_inputs (Array[MetaSoundBuilderNodeInputHandle]): 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def create_patch_preset_builder(self, builder_name: Name, referenced_patch_class: MetaSoundDocumentInterface) -> Tuple[MetaSoundPatchBuilder, MetaSoundBuilderResult]:
        r"""
        x.create_patch_preset_builder(builder_name, referenced_patch_class) -> (MetaSoundPatchBuilder, out_result=MetaSoundBuilderResult)
        Create Patch Preset Builder
        
        Args:
            builder_name (Name): 
            referenced_patch_class (MetaSoundDocumentInterface): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def create_patch_builder(self, builder_name: Name) -> Tuple[MetaSoundPatchBuilder, MetaSoundBuilderResult]:
        r"""
        x.create_patch_builder(builder_name) -> (MetaSoundPatchBuilder, out_result=MetaSoundBuilderResult)
        Create Patch Builder
        
        Args:
            builder_name (Name): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def create_object_meta_sound_literal(self, value: Object) -> MetasoundFrontendLiteral:
        r"""
        x.create_object_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create Object Meta Sound Literal
        
        Args:
            value (Object): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    def create_object_array_meta_sound_literal(self, value: Array[Object]) -> MetasoundFrontendLiteral:
        r"""
        x.create_object_array_meta_sound_literal(value) -> MetasoundFrontendLiteral
        Create Object Array Meta Sound Literal
        
        Args:
            value (Array[Object]): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    def create_meta_sound_literal_from_param(self, param: AudioParameter) -> MetasoundFrontendLiteral:
        r"""
        x.create_meta_sound_literal_from_param(param) -> MetasoundFrontendLiteral
        Create Meta Sound Literal from Param
        
        Args:
            param (AudioParameter): 
        
        Returns:
            MetasoundFrontendLiteral:
        """
        ...
    def create_int_meta_sound_literal(self, value: int) -> Tuple[MetasoundFrontendLiteral, Name]:
        r"""
        x.create_int_meta_sound_literal(value) -> (MetasoundFrontendLiteral, data_type=Name)
        Create Int Meta Sound Literal
        
        Args:
            value (int32): 
        
        Returns:
            Name: 
        
            data_type (Name):
        """
        ...
    def create_int_array_meta_sound_literal(self, value: Array[int]) -> Tuple[MetasoundFrontendLiteral, Name]:
        r"""
        x.create_int_array_meta_sound_literal(value) -> (MetasoundFrontendLiteral, data_type=Name)
        Create Int Array Meta Sound Literal
        
        Args:
            value (Array[int32]): 
        
        Returns:
            Name: 
        
            data_type (Name):
        """
        ...
    def create_float_meta_sound_literal(self, value: float) -> Tuple[MetasoundFrontendLiteral, Name]:
        r"""
        x.create_float_meta_sound_literal(value) -> (MetasoundFrontendLiteral, data_type=Name)
        Create Float Meta Sound Literal
        
        Args:
            value (float): 
        
        Returns:
            Name: 
        
            data_type (Name):
        """
        ...
    def create_float_array_meta_sound_literal(self, value: Array[float]) -> Tuple[MetasoundFrontendLiteral, Name]:
        r"""
        x.create_float_array_meta_sound_literal(value) -> (MetasoundFrontendLiteral, data_type=Name)
        Create Float Array Meta Sound Literal
        
        Args:
            value (Array[float]): 
        
        Returns:
            Name: 
        
            data_type (Name):
        """
        ...
    def create_bool_meta_sound_literal(self, value: bool) -> Tuple[MetasoundFrontendLiteral, Name]:
        r"""
        x.create_bool_meta_sound_literal(value) -> (MetasoundFrontendLiteral, data_type=Name)
        Create Bool Meta Sound Literal
        
        Args:
            value (bool): 
        
        Returns:
            Name: 
        
            data_type (Name):
        """
        ...
    def create_bool_array_meta_sound_literal(self, value: Array[bool]) -> Tuple[MetasoundFrontendLiteral, Name]:
        r"""
        x.create_bool_array_meta_sound_literal(value) -> (MetasoundFrontendLiteral, data_type=Name)
        Create Bool Array Meta Sound Literal
        
        Args:
            value (Array[bool]): 
        
        Returns:
            Name: 
        
            data_type (Name):
        """
        ...

class MetaSoundSource(SoundWaveProcedural):
    r"""
    This Metasound type can be played as an audio source.
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEngine
    - **File**: MetasoundSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] Attenuation settings package for the sound
    - ``audio_properties_bindings`` (AudioPropertiesBindings):  [Read-Write]
    - ``audio_properties_sheet`` (AudioPropertiesSheetAssetBase):  [Read-Write]
    - ``block_rate_override`` (PerPlatformFloat):  [Read-Write] Override the BlockRate for this Sound (overrides Quality). NOTE: A Zero value will have no effect and use either the Quality setting (if set), or the defaults.
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``bypass_volume_scale_for_priority`` (bool):  [Read-Write] Bypass volume weighting priority upon evaluating whether sound should remain active when max channel count is met (See platform Audio Settings).
    - ``comment`` (str):  [Read-Write] Provides contextual information for the sound to the translator.
    - ``compression_quality`` (int32):  [Read-Write] Platform agnostic compression quality. 1..100 with 1 being best compression and 100 being best quality. ADPCM and PCM sound asset compression types ignore this parameter.
    - ``concurrency_overrides`` (SoundConcurrencySettings):  [Read-Write] If Override Concurrency is true, concurrency settings to use.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] Set of concurrency settings to observe (if override is set to false).  Sound must pass all concurrency settings to play.
    - ``cue_points`` (Array[SoundWaveCuePoint]):  [Read-Only] Cue point data parsed fro the .wav file. Contains "Loop Regions" as cue points as well!
    - ``curves`` (CurveTable):  [Read-Write] Curves associated with this sound wave
    - ``debug`` (bool):  [Read-Write] When "au.3dVisualize.Attenuation" has been specified, draw this sound's attenuation shape when the sound is audible. For debugging purposes only.
    - ``duration`` (float):  [Read-Only] Duration of sound in seconds.
    - ``enable_amplitude_envelope_analysis`` (bool):  [Read-Write] Whether or not to enable cook-time amplitude envelope analysis.
    - ``enable_baked_fft_analysis`` (bool):  [Read-Write] Whether or not to enable cook-time baked FFT analysis.
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_cloud_streaming`` (bool):  [Read-Write] If enabled, this wave may be streamed from the cloud using the Opus format. Loading behavior must NOT be `Force Inline`. Requires a suitable support plugin to be installed.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds. Describes how quickly the envelope analyzer responds to increasing amplitudes.
    - ``envelope_follower_frame_size`` (int32):  [Read-Write] How many audio frames to average a new envelope value. Larger values use less memory for audio envelope data but will result in lower envelope accuracy.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds. Describes how quickly the envelope analyzer responds to decreasing amplitudes.
    - ``fft_analysis_attack_time`` (int32):  [Read-Write] Attack time in milliseconds of the spectral envelope follower.
    - ``fft_analysis_frame_size`` (int32):  [Read-Write] How many audio frames analyze at a time.
    - ``fft_analysis_release_time`` (int32):  [Read-Write] Release time in milliseconds of the spectral envelope follower.
    - ``fft_size`` (SoundWaveFFTSize):  [Read-Write] The FFT window size to use for fft analysis.
    - ``frequencies_to_analyze`` (Array[float]):  [Read-Write] The frequencies (in hz) to analyze when doing baked FFT analysis.
    - ``imported_sample_rate`` (int32):  [Read-Only] Sample rate of the imported sound wave.
    - ``initial_chunk_size`` (int32):  [Read-Write] Please use size of First Chunk in Seconds.
      deprecated: Property 'InitialChunkSize' is deprecated.
    - ``is_ambisonics`` (bool):  [Read-Write] Whether or not this source is ambisonics file format. If set, sound always uses the
      'Master Ambisonics Submix' as set in the 'Audio' category of Project Settings'
      and ignores submix if provided locally or in the referenced SoundClass.
    - ``loading_behavior`` (SoundWaveLoadingBehavior):  [Read-Write] Specifies how and when compressed audio data is loaded for asset if stream caching is enabled.
    - ``looping`` (bool):  [Read-Write] If set, when played directly (not through a sound cue) the wave will be played looping.
    - ``manual_word_wrap`` (bool):  [Read-Write] If set to true will disable automatic generation of line breaks - use if the subtitles have been split manually.
    - ``mature`` (bool):  [Read-Write] If set to true if this sound is considered to contain mature/adult content.
    - ``max_distance`` (float):  [Read-Only] The max distance of the asset, as determined by attenuation settings.
    - ``modulation_settings`` (SoundModulationDefaultRoutingSettings):  [Read-Write] Modulation Settings
    - ``num_channels`` (int32):  [Read-Only] Number of channels of multichannel data; 1 or 2 for regular mono and stereo files
    - ``output_format`` (MetaSoundOutputAudioFormat):  [Read-Write] The output audio format of the metasound source.
    - ``override_concurrency`` (bool):  [Read-Write] Whether or not to override the sound concurrency object with local concurrency settings.
    - ``override_sound_to_use_for_analysis`` (SoundWave):  [Read-Write] Specify a sound to use for the baked analysis. Will default to this USoundWave if not set.
    - ``pitch`` (float):  [Read-Write] Playback pitch for sound.
    - ``platform_settings`` (Map[Guid, SoundWaveCloudStreamingPlatformSettings]):  [Read-Write] Optionally disables cloud streaming per platform
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``priority`` (float):  [Read-Write] Used to determine whether sound can play or remain active if channel limit is met, where higher value is higher priority
      (see platform's Audio Settings 'Max Channels' property). Unless bypassed, value is weighted with the final volume of the
      sound to produce final runtime priority value.
    - ``quality_setting`` (Name):  [Read-Write] The Quality this Metasound will use. These are defined in the MetaSounds project settings.
    - ``root_metasound_document`` (MetasoundFrontendDocument):  [Read-Write]
    - ``sample_rate`` (int32):  [Read-Only] Cooked sample rate of the asset. Can be modified by sample rate override.
    - ``sample_rate_override`` (PerPlatformInt):  [Read-Write] Override the SampleRate for this Sound (overrides Quality). NOTE: A Zero value will have no effect and use either the Quality setting (if set), or the Device Rate
    - ``sample_rate_quality`` (SoundwaveSampleRateSettings):  [Read-Write] Determines the max sample rate to use if the platform enables "Resampling For Device" in project settings.
           For example, if the platform enables Resampling For Device and specifies 32000 for High, then setting High here will
           force the sound wave to be _at most_ 32000. Does nothing if Resampling For Device is disabled.
    - ``seekable_streaming`` (bool):  [Read-Write] Deprecated compression type properties
      deprecated: 5.0 - Property is deprecated. bSeekableStreaming now means ADPCM codec in SoundAssetCompressionType.
    - ``single_line`` (bool):  [Read-Write] If set to true the subtitles display as a sequence of single lines as opposed to multiline.
    - ``size_of_first_audio_chunk_in_seconds`` (PerPlatformFloat):  [Read-Write] How much audio to add to First Audio Chunk (in seconds)
    - ``sound_asset_compression_type`` (SoundAssetCompressionType):  [Read-Write] The compression type to use for the sound wave asset.
    - ``sound_class_object`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_group`` (SoundGroup):  [Read-Write]
    - ``sound_submix_object`` (SoundSubmixBase):  [Read-Write] Submix to route sound output to. If unset, falls back to referenced SoundClass submix.
      If SoundClass submix is unset, sends to the 'Master Submix' as set in the 'Audio' category of Project Settings'.
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] Array of submix sends to which a prescribed amount (see 'Send Level') of this sound is sent.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``spoken_text`` (str):  [Read-Write] A localized version of the text that is actually spoken phonetically in the audio.
      deprecated: Use Subtitles instead.
    - ``streaming_priority`` (int32):  [Read-Write]
      deprecated: 5.0 - Property is deprecated. Streaming priority has no effect with stream caching enabled.
    - ``subtitle_priority`` (float):  [Read-Write] The priority of the subtitle.
    - ``subtitles`` (Array[SubtitleCue]):  [Read-Write] Subtitle cues.
    - ``timecode_info`` (SoundWaveTimecodeInfo):  [Read-Only] Information about the time-code from import, if available.
    - ``total_samples`` (float):  [Read-Only] Total number of samples (in the thousands). Useful as a metric to analyze the relative size of a given sound asset in content browser.
    - ``transformations`` (Array[WaveformTransformationBase]):  [Read-Write] Waveform edits to be applied to this SoundWave on cook (editing transformations will trigger a cook)
    - ``treat_file_as_looping_for_analysis`` (bool):  [Read-Write] Whether or not we should treat the sound wave used for analysis (this or the override) as looping while performing analysis.
      A looping sound may include the end of the file for inclusion in analysis for envelope and FFT analysis.
    - ``use_bink_audio`` (bool):  [Read-Write]
      deprecated: 5.0 - Property is deprecated. bUseBinkAudio now means Bink codec in SoundAssetCompressionType.
    - ``virtualization_mode`` (VirtualizationMode):  [Read-Write] Virtualization behavior, determining if a sound may revive and how it continues playing when culled or evicted (limited to looping sounds).
    - ``volume`` (float):  [Read-Write] Playback volume of sound 0 to 1 - Default is 1.0.
    """
    @property
    def output_format(self) -> MetaSoundOutputAudioFormat:
        r"""
        (MetaSoundOutputAudioFormat):  [Read-Only] The output audio format of the metasound source.
        """
        ...
    @property
    def quality_setting(self) -> Name:
        r"""
        (Name):  [Read-Write] The Quality this Metasound will use. These are defined in the MetaSounds project settings.
        """
        ...
    @quality_setting.setter
    def quality_setting(self, value: Name) -> None:
        ...
    @property
    def block_rate_override(self) -> PerPlatformFloat:
        r"""
        (PerPlatformFloat):  [Read-Only] Override the BlockRate for this Sound (overrides Quality). NOTE: A Zero value will have no effect and use either the Quality setting (if set), or the defaults.
        """
        ...
    @property
    def sample_rate_override(self) -> PerPlatformInt:
        r"""
        (PerPlatformInt):  [Read-Only] Override the SampleRate for this Sound (overrides Quality). NOTE: A Zero value will have no effect and use either the Quality setting (if set), or the Device Rate
        """
        ...

class RadialSlider(Widget):
    r"""
    A simple widget that shows a sliding bar with a handle that allows you to control the value between 0..1.
    
    * No Children
    
    **C++ Source:**
    
    - **Module**: AdvancedWidgets
    - **File**: RadialSlider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``angular_offset`` (float):  [Read-Write] Rotates radial slider by arbitrary offset to support full gamut of configurations.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``center_background_color`` (LinearColor):  [Read-Write] The color to draw the center background in.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``custom_default_value`` (float):  [Read-Write] The value where the slider should draw it's progress bar from, independent of direction
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hand_start_end_ratio`` (Vector2D):  [Read-Write] Start and end of the hand as a ratio to the slider radius (so 0.0 to 1.0 is from the slider center to the handle).
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Should the slider be focusable?
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``locked`` (bool):  [Read-Write] Whether the handle is interactive or fixed.
    - ``mouse_uses_step`` (bool):  [Read-Write] Sets new value if mouse position is greater/less than half the step size.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_controller_capture_begin`` (OnControllerCaptureBeginEvent):  [Read-Write] Invoked when the controller capture begins.
    - ``on_controller_capture_end`` (OnControllerCaptureEndEvent):  [Read-Write] Invoked when the controller capture ends.
    - ``on_mouse_capture_begin`` (OnMouseCaptureBeginEvent):  [Read-Write] Invoked when the mouse is pressed and a capture begins.
    - ``on_mouse_capture_end`` (OnMouseCaptureEndEvent):  [Read-Write] Invoked when the mouse is released and a capture ends.
    - ``on_value_changed`` (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``requires_controller_lock`` (bool):  [Read-Write] Sets whether we have to lock input to change the slider value.
    - ``show_slider_hand`` (bool):  [Read-Write] Whether to show the slider hand.
    - ``show_slider_handle`` (bool):  [Read-Write] Whether to show the slider handle (thumb).
    - ``slider_bar_color`` (LinearColor):  [Read-Write] The color to draw the slider bar in.
    - ``slider_handle_color`` (LinearColor):  [Read-Write] The color to draw the slider handle in.
    - ``slider_handle_end_angle`` (float):  [Read-Write] The angle at which the Slider Handle will end.
    - ``slider_handle_start_angle`` (float):  [Read-Write] The angle at which the Slider Handle will start.
    - ``slider_progress_color`` (LinearColor):  [Read-Write] The color to draw the completed progress of the slider bar in.
    - ``slider_range`` (RuntimeFloatCurve):  [Read-Write] A curve that defines how the slider should be sampled. Default is linear.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``step_size`` (float):  [Read-Write] The amount to adjust the value by, when using a controller or keyboard
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``use_custom_default_value`` (bool):  [Read-Write] Whether the slider should draw it's progress bar from a custom value on the slider
    - ``use_vertical_drag`` (bool):  [Read-Write] Whether the value is changed when dragging vertically as opposed to along the radial curve.
    - ``value`` (float):  [Read-Write] The slider value to display.
    - ``value_tags`` (Array[float]):  [Read-Write] Adds text tags to the radial slider at the value's position.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (SliderStyle):  [Read-Write] The progress bar style
    """
    @property
    def value(self) -> float:
        r"""
        (float):  [Read-Write] The slider value to display.
        """
        ...
    @value.setter
    def value(self, value: float) -> None:
        ...
    @property
    def slider_range(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Only] A curve that defines how the slider should be sampled. Default is linear.
        """
        ...
    @property
    def value_tags(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Only] Adds text tags to the radial slider at the value's position.
        """
        ...
    @property
    def slider_handle_start_angle(self) -> float:
        r"""
        (float):  [Read-Only] The angle at which the Slider Handle will start.
        """
        ...
    @property
    def slider_handle_end_angle(self) -> float:
        r"""
        (float):  [Read-Only] The angle at which the Slider Handle will end.
        """
        ...
    @property
    def angular_offset(self) -> float:
        r"""
        (float):  [Read-Only] Rotates radial slider by arbitrary offset to support full gamut of configurations.
        """
        ...
    @property
    def hand_start_end_ratio(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Only] Start and end of the hand as a ratio to the slider radius (so 0.0 to 1.0 is from the slider center to the handle).
        """
        ...
    @property
    def widget_style(self) -> SliderStyle:
        r"""
        (SliderStyle):  [Read-Write] The progress bar style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: SliderStyle) -> None:
        ...
    @property
    def slider_bar_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the slider bar in.
        """
        ...
    @property
    def slider_progress_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the completed progress of the slider bar in.
        """
        ...
    @property
    def slider_handle_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the slider handle in.
        """
        ...
    @property
    def center_background_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the center background in.
        """
        ...
    @property
    def locked(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the handle is interactive or fixed.
        """
        ...
    @property
    def mouse_uses_step(self) -> bool:
        r"""
        (bool):  [Read-Only] Sets new value if mouse position is greater/less than half the step size.
        """
        ...
    @property
    def requires_controller_lock(self) -> bool:
        r"""
        (bool):  [Read-Only] Sets whether we have to lock input to change the slider value.
        """
        ...
    @property
    def step_size(self) -> float:
        r"""
        (float):  [Read-Only] The amount to adjust the value by, when using a controller or keyboard
        """
        ...
    @property
    def is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Only] Should the slider be focusable?
        """
        ...
    @property
    def use_vertical_drag(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the value is changed when dragging vertically as opposed to along the radial curve.
        """
        ...
    @use_vertical_drag.setter
    def use_vertical_drag(self, value: bool) -> None:
        ...
    @property
    def show_slider_handle(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to show the slider handle (thumb).
        """
        ...
    @show_slider_handle.setter
    def show_slider_handle(self, value: bool) -> None:
        ...
    @property
    def show_slider_hand(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to show the slider hand.
        """
        ...
    @show_slider_hand.setter
    def show_slider_hand(self, value: bool) -> None:
        ...
    @property
    def on_mouse_capture_begin(self) -> OnMouseCaptureBeginEvent:
        r"""
        (OnMouseCaptureBeginEvent):  [Read-Write] Invoked when the mouse is pressed and a capture begins.
        """
        ...
    @on_mouse_capture_begin.setter
    def on_mouse_capture_begin(self, value: OnMouseCaptureBeginEvent) -> None:
        ...
    @property
    def on_mouse_capture_end(self) -> OnMouseCaptureEndEvent:
        r"""
        (OnMouseCaptureEndEvent):  [Read-Write] Invoked when the mouse is released and a capture ends.
        """
        ...
    @on_mouse_capture_end.setter
    def on_mouse_capture_end(self, value: OnMouseCaptureEndEvent) -> None:
        ...
    @property
    def on_controller_capture_begin(self) -> OnControllerCaptureBeginEvent:
        r"""
        (OnControllerCaptureBeginEvent):  [Read-Write] Invoked when the controller capture begins.
        """
        ...
    @on_controller_capture_begin.setter
    def on_controller_capture_begin(self, value: OnControllerCaptureBeginEvent) -> None:
        ...
    @property
    def on_controller_capture_end(self) -> OnControllerCaptureEndEvent:
        r"""
        (OnControllerCaptureEndEvent):  [Read-Write] Invoked when the controller capture ends.
        """
        ...
    @on_controller_capture_end.setter
    def on_controller_capture_end(self, value: OnControllerCaptureEndEvent) -> None:
        ...
    @property
    def on_value_changed(self) -> OnFloatValueChangedEvent:
        r"""
        (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
        """
        ...
    @on_value_changed.setter
    def on_value_changed(self, value: OnFloatValueChangedEvent) -> None:
        ...
    def set_value_tags(self, value_tags: Array[float]) -> None:
        r"""
        x.set_value_tags(value_tags) -> None
        Adds value tags to the slider.
        
        Args:
            value_tags (Array[float]):
        """
        ...
    def set_value(self, value: float) -> None:
        r"""
        x.set_value(value) -> None
        Sets the current value of the slider.
        
        Args:
            value (float):
        """
        ...
    def set_use_vertical_drag(self, use_vertical_drag: bool) -> None:
        r"""
        x.set_use_vertical_drag(use_vertical_drag) -> None
        Set whether the value is changed when dragging vertically as opposed to along the radial curve.
        
        Args:
            use_vertical_drag (bool):
        """
        ...
    def set_step_size(self, value: float) -> None:
        r"""
        x.set_step_size(value) -> None
        Sets the amount to adjust the value by, when using a controller or keyboard
        
        Args:
            value (float):
        """
        ...
    def set_slider_range(self, slider_range: RuntimeFloatCurve) -> None:
        r"""
        x.set_slider_range(slider_range) -> None
        Sets the curve for the slider range
        
        Args:
            slider_range (RuntimeFloatCurve):
        """
        ...
    def set_slider_progress_color(self, value: LinearColor) -> None:
        r"""
        x.set_slider_progress_color(value) -> None
        Sets the progress color of the slider bar
        
        Args:
            value (LinearColor):
        """
        ...
    def set_slider_handle_start_angle(self, value: float) -> None:
        r"""
        x.set_slider_handle_start_angle(value) -> None
        Sets the minimum angle of the slider.
        
        Args:
            value (float):
        """
        ...
    def set_slider_handle_end_angle(self, value: float) -> None:
        r"""
        x.set_slider_handle_end_angle(value) -> None
        Sets the maximum angle of the slider.
        
        Args:
            value (float):
        """
        ...
    def set_slider_handle_color(self, value: LinearColor) -> None:
        r"""
        x.set_slider_handle_color(value) -> None
        Sets the color of the handle bar
        
        Args:
            value (LinearColor):
        """
        ...
    def set_slider_bar_color(self, value: LinearColor) -> None:
        r"""
        x.set_slider_bar_color(value) -> None
        Sets the color of the slider bar
        
        Args:
            value (LinearColor):
        """
        ...
    def set_show_slider_handle(self, show_slider_handle: bool) -> None:
        r"""
        x.set_show_slider_handle(show_slider_handle) -> None
        Whether to show the slider handle (thumb).
        
        Args:
            show_slider_handle (bool):
        """
        ...
    def set_show_slider_hand(self, show_slider_hand: bool) -> None:
        r"""
        x.set_show_slider_hand(show_slider_hand) -> None
        Whether to show the slider hand.
        
        Args:
            show_slider_hand (bool):
        """
        ...
    def set_locked(self, value: bool) -> None:
        r"""
        x.set_locked(value) -> None
        Sets the handle to be interactive or fixed
        
        Args:
            value (bool):
        """
        ...
    def set_hand_start_end_ratio(self, value: Vector2D) -> None:
        r"""
        x.set_hand_start_end_ratio(value) -> None
        Sets the start and end of the hand as a ratio to the slider radius (so 0.0 to 1.0 is from the slider center to the handle).
        
        Args:
            value (Vector2D):
        """
        ...
    def set_custom_default_value(self, value: float) -> None:
        r"""
        x.set_custom_default_value(value) -> None
        Sets the current custom default value of the slider.
        
        Args:
            value (float):
        """
        ...
    def set_center_background_color(self, value: LinearColor) -> None:
        r"""
        x.set_center_background_color(value) -> None
        Sets the color of the slider bar
        
        Args:
            value (LinearColor):
        """
        ...
    def set_angular_offset(self, value: float) -> None:
        r"""
        x.set_angular_offset(value) -> None
        Sets the Angular Offset for the slider.
        
        Args:
            value (float):
        """
        ...
    def get_value(self) -> float:
        r"""
        x.get_value() -> float
        Gets the current value of the slider.
        
        Returns:
            float:
        """
        ...
    def get_normalized_slider_handle_position(self) -> float:
        r"""
        x.get_normalized_slider_handle_position() -> float
        Get the current raw slider alpha from 0 to 1
        
        Returns:
            float:
        """
        ...
    def get_custom_default_value(self) -> float:
        r"""
        x.get_custom_default_value() -> float
        Gets the current custom default value of the slider.
        
        Returns:
            float:
        """
        ...

class AudioMeter(Widget):
    r"""
    An audio meter widget.
    
    Supports displaying a slower moving peak-hold value as well as the current meter value.
    
    A clipping value is also displayed which shows a customizable color to indicate clipping.
    
    Internal values are stored and interacted with as linear volume values.
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioMeter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``background_color`` (LinearColor):  [Read-Write] The color to draw the background.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``meter_background_color`` (LinearColor):  [Read-Write] The color to draw the meter background.
    - ``meter_channel_info`` (Array[MeterChannelInfo]):  [Read-Write] The current meter value to display.
    - ``meter_clipping_color`` (LinearColor):  [Read-Write] The color to draw the meter clipping value.
    - ``meter_peak_color`` (LinearColor):  [Read-Write] The color to draw the meter peak value.
    - ``meter_scale_color`` (LinearColor):  [Read-Write] The color to draw the meter scale hashes.
    - ``meter_scale_label_color`` (LinearColor):  [Read-Write] The color to draw the meter scale label.
    - ``meter_value_color`` (LinearColor):  [Read-Write] The color to draw the meter value.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``orientation`` (Orientation):  [Read-Write] The slider's orientation.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (AudioMeterStyle):  [Read-Write] The audio meter style
    """
    @property
    def widget_style(self) -> AudioMeterStyle:
        r"""
        (AudioMeterStyle):  [Read-Write] The audio meter style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: AudioMeterStyle) -> None:
        ...
    @property
    def orientation(self) -> Orientation:
        r"""
        (Orientation):  [Read-Only] The slider's orientation.
        """
        ...
    @property
    def background_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the background.
        """
        ...
    @property
    def meter_background_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the meter background.
        """
        ...
    @property
    def meter_value_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the meter value.
        """
        ...
    @property
    def meter_peak_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the meter peak value.
        """
        ...
    @property
    def meter_clipping_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the meter clipping value.
        """
        ...
    @property
    def meter_scale_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the meter scale hashes.
        """
        ...
    @property
    def meter_scale_label_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the meter scale label.
        """
        ...
    def set_meter_value_color(self, value: LinearColor) -> None:
        r"""
        x.set_meter_value_color(value) -> None
        Sets the meter value color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_meter_scale_label_color(self, value: LinearColor) -> None:
        r"""
        x.set_meter_scale_label_color(value) -> None
        Sets the meter scale color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_meter_scale_color(self, value: LinearColor) -> None:
        r"""
        x.set_meter_scale_color(value) -> None
        Sets the meter scale color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_meter_peak_color(self, value: LinearColor) -> None:
        r"""
        x.set_meter_peak_color(value) -> None
        Sets the meter peak color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_meter_clipping_color(self, value: LinearColor) -> None:
        r"""
        x.set_meter_clipping_color(value) -> None
        Sets the meter clipping color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_meter_channel_info(self, meter_channel_info: Array[MeterChannelInfo]) -> None:
        r"""
        x.set_meter_channel_info(meter_channel_info) -> None
        Sets the current meter values.
        
        Args:
            meter_channel_info (Array[MeterChannelInfo]):
        """
        ...
    def set_meter_background_color(self, value: LinearColor) -> None:
        r"""
        x.set_meter_background_color(value) -> None
        Sets the meter background color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_background_color(self, value: LinearColor) -> None:
        r"""
        x.set_background_color(value) -> None
        Sets the background color
        
        Args:
            value (LinearColor):
        """
        ...
    def get_meter_channel_info(self) -> Array[MeterChannelInfo]:
        r"""
        x.get_meter_channel_info() -> Array[MeterChannelInfo]
        Gets the current linear value of the meter.
        
        Returns:
            Array[MeterChannelInfo]:
        """
        ...

class AudioOscilloscope(Widget):
    r"""
    An oscilloscope UMG widget.
    
    Supports displaying waveforms from incoming audio samples.
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioOscilloscopeUMG.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``amplitude_grid_labels_unit`` (YAxisLabelsUnit):  [Read-Write] Define the amplitude grid labels unit.
    - ``analysis_period_ms`` (float):  [Read-Write] The analysis period in milliseconds.
    - ``audio_bus`` (AudioBus):  [Read-Write] The audio bus used to obtain audio samples for the oscilloscope
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``oscilloscope_style`` (AudioOscilloscopePanelStyle):  [Read-Write] The oscilloscope panel style
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``panel_layout_type`` (AudioPanelLayoutType):  [Read-Write] Show/Hide advanced panel layout.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``show_amplitude_grid`` (bool):  [Read-Write] Show/Hide the amplitude grid.
    - ``show_amplitude_labels`` (bool):  [Read-Write] Show/Hide the amplitude labels.
    - ``show_time_grid`` (bool):  [Read-Write] Show/Hide the time grid.
    - ``show_trigger_threshold_line`` (bool):  [Read-Write] Show/Hide the trigger threshold line.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``time_grid_labels_unit`` (XAxisLabelsUnit):  [Read-Write] Define the time grid labels unit.
    - ``time_window_ms`` (float):  [Read-Write] The time window in milliseconds.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``trigger_threshold`` (float):  [Read-Write] The trigger threshold position in the Y axis.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def oscilloscope_style(self) -> AudioOscilloscopePanelStyle:
        r"""
        (AudioOscilloscopePanelStyle):  [Read-Write] The oscilloscope panel style
        """
        ...
    @oscilloscope_style.setter
    def oscilloscope_style(self, value: AudioOscilloscopePanelStyle) -> None:
        ...
    @property
    def audio_bus(self) -> AudioBus:
        r"""
        (AudioBus):  [Read-Write] The audio bus used to obtain audio samples for the oscilloscope
        """
        ...
    @audio_bus.setter
    def audio_bus(self, value: AudioBus) -> None:
        ...
    @property
    def time_window_ms(self) -> float:
        r"""
        (float):  [Read-Write] The time window in milliseconds.
        """
        ...
    @time_window_ms.setter
    def time_window_ms(self, value: float) -> None:
        ...
    @property
    def analysis_period_ms(self) -> float:
        r"""
        (float):  [Read-Write] The analysis period in milliseconds.
        """
        ...
    @analysis_period_ms.setter
    def analysis_period_ms(self, value: float) -> None:
        ...
    @property
    def show_time_grid(self) -> bool:
        r"""
        (bool):  [Read-Write] Show/Hide the time grid.
        """
        ...
    @show_time_grid.setter
    def show_time_grid(self, value: bool) -> None:
        ...
    @property
    def time_grid_labels_unit(self) -> XAxisLabelsUnit:
        r"""
        (XAxisLabelsUnit):  [Read-Write] Define the time grid labels unit.
        """
        ...
    @time_grid_labels_unit.setter
    def time_grid_labels_unit(self, value: XAxisLabelsUnit) -> None:
        ...
    @property
    def show_amplitude_grid(self) -> bool:
        r"""
        (bool):  [Read-Write] Show/Hide the amplitude grid.
        """
        ...
    @show_amplitude_grid.setter
    def show_amplitude_grid(self, value: bool) -> None:
        ...
    @property
    def show_amplitude_labels(self) -> bool:
        r"""
        (bool):  [Read-Write] Show/Hide the amplitude labels.
        """
        ...
    @show_amplitude_labels.setter
    def show_amplitude_labels(self, value: bool) -> None:
        ...
    @property
    def amplitude_grid_labels_unit(self) -> YAxisLabelsUnit:
        r"""
        (YAxisLabelsUnit):  [Read-Write] Define the amplitude grid labels unit.
        """
        ...
    @amplitude_grid_labels_unit.setter
    def amplitude_grid_labels_unit(self, value: YAxisLabelsUnit) -> None:
        ...
    @property
    def show_trigger_threshold_line(self) -> bool:
        r"""
        (bool):  [Read-Write] Show/Hide the trigger threshold line.
        """
        ...
    @show_trigger_threshold_line.setter
    def show_trigger_threshold_line(self, value: bool) -> None:
        ...
    @property
    def trigger_threshold(self) -> float:
        r"""
        (float):  [Read-Write] The trigger threshold position in the Y axis.
        """
        ...
    @trigger_threshold.setter
    def trigger_threshold(self, value: float) -> None:
        ...
    @property
    def panel_layout_type(self) -> AudioPanelLayoutType:
        r"""
        (AudioPanelLayoutType):  [Read-Write] Show/Hide advanced panel layout.
        """
        ...
    @panel_layout_type.setter
    def panel_layout_type(self, value: AudioPanelLayoutType) -> None:
        ...
    def stop_processing(self) -> None:
        r"""
        x.stop_processing() -> None
        Stops the oscilloscope processing.
        """
        ...
    def start_processing(self) -> None:
        r"""
        x.start_processing() -> None
        Starts the oscilloscope processing.
        """
        ...

class AudioRadialSlider(Widget):
    r"""
    An audio radial slider widget.
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioRadialSlider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``center_background_color`` (LinearColor):  [Read-Write] The color to draw the widget background.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hand_start_end_ratio`` (Vector2D):  [Read-Write] Start and end of the hand as a ratio to the slider radius (so 0.0 to 1.0 is from the slider center to the handle).
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_units_text_read_only`` (bool):  [Read-Write] Whether to set the units part of the text label read only.
    - ``is_value_text_read_only`` (bool):  [Read-Write] Whether to set the value part of the text label read only.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_value_changed`` (OnAudioRadialSliderValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
    - ``output_range`` (Vector2D):  [Read-Write] Output range
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``show_label_only_on_hover`` (bool):  [Read-Write] If true, show text label only on hover; if false always show label.
    - ``show_units_text`` (bool):  [Read-Write] Whether to show the units part of the text label.
    - ``slider_bar_color`` (LinearColor):  [Read-Write] The color to draw the slider bar in.
    - ``slider_progress_color`` (LinearColor):  [Read-Write] The color to draw the slider progress bar in.
    - ``slider_thickness`` (float):  [Read-Write] The slider thickness.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text_label_background_color`` (LinearColor):  [Read-Write] The color to draw the text label background.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``units_text`` (Text):  [Read-Write] The text label units
    - ``value`` (float):  [Read-Write] The normalized linear (0 - 1) slider value position.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_layout`` (AudioRadialSliderLayout):  [Read-Write] The layout of the widget (position of text label).
    """
    @property
    def on_value_changed(self) -> OnAudioRadialSliderValueChangedEvent:
        r"""
        (OnAudioRadialSliderValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
        """
        ...
    @on_value_changed.setter
    def on_value_changed(self, value: OnAudioRadialSliderValueChangedEvent) -> None:
        ...
    def set_widget_layout(self, layout: AudioRadialSliderLayout) -> None:
        r"""
        x.set_widget_layout(layout) -> None
        Sets the widget layout
        
        Args:
            layout (AudioRadialSliderLayout):
        """
        ...
    def set_value_text_read_only(self, is_read_only: bool) -> None:
        r"""
        x.set_value_text_read_only(is_read_only) -> None
        Sets whether the value text is read only
        
        Args:
            is_read_only (bool):
        """
        ...
    def set_units_text_read_only(self, is_read_only: bool) -> None:
        r"""
        x.set_units_text_read_only(is_read_only) -> None
        Sets whether the units text is read only
        
        Args:
            is_read_only (bool):
        """
        ...
    def set_units_text(self, units: Text) -> None:
        r"""
        x.set_units_text(units) -> None
        Sets the units text
        
        Args:
            units (Text):
        """
        ...
    def set_text_label_background_color(self, color: SlateColor) -> None:
        r"""
        x.set_text_label_background_color(color) -> None
        Sets the label background color
        
        Args:
            color (SlateColor):
        """
        ...
    def set_slider_thickness(self, thickness: float) -> None:
        r"""
        x.set_slider_thickness(thickness) -> None
        Sets the slider thickness
        
        Args:
            thickness (float):
        """
        ...
    def set_slider_progress_color(self, value: LinearColor) -> None:
        r"""
        x.set_slider_progress_color(value) -> None
        Sets the slider progress color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_slider_bar_color(self, value: LinearColor) -> None:
        r"""
        x.set_slider_bar_color(value) -> None
        Sets the slider bar color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_show_units_text(self, show_units_text: bool) -> None:
        r"""
        x.set_show_units_text(show_units_text) -> None
        Sets whether to show the units text
        
        Args:
            show_units_text (bool):
        """
        ...
    def set_show_label_only_on_hover(self, show_label_only_on_hover: bool) -> None:
        r"""
        x.set_show_label_only_on_hover(show_label_only_on_hover) -> None
        If true, show text label only on hover; if false always show label.
        
        Args:
            show_label_only_on_hover (bool):
        """
        ...
    def set_output_range(self, output_range: Vector2D) -> None:
        r"""
        x.set_output_range(output_range) -> None
        Sets the output range
        
        Args:
            output_range (Vector2D):
        """
        ...
    def set_hand_start_end_ratio(self, hand_start_end_ratio: Vector2D) -> None:
        r"""
        x.set_hand_start_end_ratio(hand_start_end_ratio) -> None
        Sets the start and end of the hand as a ratio to the slider radius (so 0.0 to 1.0 is from the slider center to the handle).
        
        Args:
            hand_start_end_ratio (Vector2D):
        """
        ...
    def set_center_background_color(self, value: LinearColor) -> None:
        r"""
        x.set_center_background_color(value) -> None
        Sets the label background color
        
        Args:
            value (LinearColor):
        """
        ...
    def get_slider_value(self, output_value: float) -> float:
        r"""
        x.get_slider_value(output_value) -> float
        Get normalized linear (0 - 1) slider value from output based on internal lin to output mapping.
        
        Args:
            output_value (float): 
        
        Returns:
            float:
        """
        ...
    def get_output_value(self, slider_value: float) -> float:
        r"""
        x.get_output_value(slider_value) -> float
        Get output value from normalized linear (0 - 1) based on internal lin to output mapping.
        
        Args:
            slider_value (float): 
        
        Returns:
            float:
        """
        ...

class AudioVolumeRadialSlider(AudioRadialSlider):
    r"""
    An audio slider widget, for use with volume.
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioRadialSlider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``center_background_color`` (LinearColor):  [Read-Write] The color to draw the widget background.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hand_start_end_ratio`` (Vector2D):  [Read-Write] Start and end of the hand as a ratio to the slider radius (so 0.0 to 1.0 is from the slider center to the handle).
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_units_text_read_only`` (bool):  [Read-Write] Whether to set the units part of the text label read only.
    - ``is_value_text_read_only`` (bool):  [Read-Write] Whether to set the value part of the text label read only.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_value_changed`` (OnAudioRadialSliderValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
    - ``output_range`` (Vector2D):  [Read-Write] Output range
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``show_label_only_on_hover`` (bool):  [Read-Write] If true, show text label only on hover; if false always show label.
    - ``show_units_text`` (bool):  [Read-Write] Whether to show the units part of the text label.
    - ``slider_bar_color`` (LinearColor):  [Read-Write] The color to draw the slider bar in.
    - ``slider_progress_color`` (LinearColor):  [Read-Write] The color to draw the slider progress bar in.
    - ``slider_thickness`` (float):  [Read-Write] The slider thickness.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text_label_background_color`` (LinearColor):  [Read-Write] The color to draw the text label background.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``units_text`` (Text):  [Read-Write] The text label units
    - ``value`` (float):  [Read-Write] The normalized linear (0 - 1) slider value position.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_layout`` (AudioRadialSliderLayout):  [Read-Write] The layout of the widget (position of text label).
    """
    ...

class AudioFrequencyRadialSlider(AudioRadialSlider):
    r"""
    An audio slider widget, for use with frequency.
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioRadialSlider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``center_background_color`` (LinearColor):  [Read-Write] The color to draw the widget background.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hand_start_end_ratio`` (Vector2D):  [Read-Write] Start and end of the hand as a ratio to the slider radius (so 0.0 to 1.0 is from the slider center to the handle).
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_units_text_read_only`` (bool):  [Read-Write] Whether to set the units part of the text label read only.
    - ``is_value_text_read_only`` (bool):  [Read-Write] Whether to set the value part of the text label read only.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_value_changed`` (OnAudioRadialSliderValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
    - ``output_range`` (Vector2D):  [Read-Write] Output range
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``show_label_only_on_hover`` (bool):  [Read-Write] If true, show text label only on hover; if false always show label.
    - ``show_units_text`` (bool):  [Read-Write] Whether to show the units part of the text label.
    - ``slider_bar_color`` (LinearColor):  [Read-Write] The color to draw the slider bar in.
    - ``slider_progress_color`` (LinearColor):  [Read-Write] The color to draw the slider progress bar in.
    - ``slider_thickness`` (float):  [Read-Write] The slider thickness.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text_label_background_color`` (LinearColor):  [Read-Write] The color to draw the text label background.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``units_text`` (Text):  [Read-Write] The text label units
    - ``value`` (float):  [Read-Write] The normalized linear (0 - 1) slider value position.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_layout`` (AudioRadialSliderLayout):  [Read-Write] The layout of the widget (position of text label).
    """
    ...

class AudioSliderBase(Widget):
    r"""
    An audio slider widget.
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioSlider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_units_text_read_only`` (bool):  [Read-Write] Whether to set the units part of the text label read only.
    - ``is_value_text_read_only`` (bool):  [Read-Write] Whether to set the value part of the text label read only.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_value_changed`` (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
    - ``orientation`` (Orientation):  [Read-Write] The slider's orientation.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``show_label_only_on_hover`` (bool):  [Read-Write] If true, show text label only on hover; if false always show label.
    - ``show_units_text`` (bool):  [Read-Write] Whether to show the units part of the text label.
    - ``slider_background_color`` (LinearColor):  [Read-Write] The color to draw the slider background.
    - ``slider_bar_color`` (LinearColor):  [Read-Write] The color to draw the slider bar.
    - ``slider_thumb_color`` (LinearColor):  [Read-Write] The color to draw the slider thumb.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text_label_background_color`` (LinearColor):  [Read-Write] The color to draw the text label background.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``units_text`` (Text):  [Read-Write] The text label units
    - ``value`` (float):  [Read-Write] The normalized linear (0 - 1) slider value.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_background_color`` (LinearColor):  [Read-Write] The color to draw the widget background.
    """
    @property
    def orientation(self) -> Orientation:
        r"""
        (Orientation):  [Read-Only] The slider's orientation.
        """
        ...
    @property
    def on_value_changed(self) -> OnFloatValueChangedEvent:
        r"""
        (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
        """
        ...
    @on_value_changed.setter
    def on_value_changed(self, value: OnFloatValueChangedEvent) -> None:
        ...
    def set_widget_background_color(self, value: LinearColor) -> None:
        r"""
        x.set_widget_background_color(value) -> None
        Sets the widget background color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_value_text_read_only(self, is_read_only: bool) -> None:
        r"""
        x.set_value_text_read_only(is_read_only) -> None
        Sets whether the value text is read only
        
        Args:
            is_read_only (bool):
        """
        ...
    def set_units_text_read_only(self, is_read_only: bool) -> None:
        r"""
        x.set_units_text_read_only(is_read_only) -> None
        Sets whether the units text is read only
        
        Args:
            is_read_only (bool):
        """
        ...
    def set_units_text(self, units: Text) -> None:
        r"""
        x.set_units_text(units) -> None
        Sets the units text
        
        Args:
            units (Text):
        """
        ...
    def set_text_label_background_color(self, color: SlateColor) -> None:
        r"""
        x.set_text_label_background_color(color) -> None
        Sets the label background color
        
        Args:
            color (SlateColor):
        """
        ...
    def set_slider_thumb_color(self, value: LinearColor) -> None:
        r"""
        x.set_slider_thumb_color(value) -> None
        Sets the slider thumb color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_slider_bar_color(self, value: LinearColor) -> None:
        r"""
        x.set_slider_bar_color(value) -> None
        Sets the slider bar color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_slider_background_color(self, value: LinearColor) -> None:
        r"""
        x.set_slider_background_color(value) -> None
        Sets the slider background color
        
        Args:
            value (LinearColor):
        """
        ...
    def set_show_units_text(self, show_units_text: bool) -> None:
        r"""
        x.set_show_units_text(show_units_text) -> None
        Sets whether to show the units text
        
        Args:
            show_units_text (bool):
        """
        ...
    def set_show_label_only_on_hover(self, show_label_only_on_hover: bool) -> None:
        r"""
        x.set_show_label_only_on_hover(show_label_only_on_hover) -> None
        If true, show text label only on hover; if false always show label.
        
        Args:
            show_label_only_on_hover (bool):
        """
        ...
    def get_slider_value(self, output_value: float) -> float:
        r"""
        x.get_slider_value(output_value) -> float
        Get normalized linear (0 - 1) slider value from output based on internal lin to output mapping.
        
        Args:
            output_value (float): 
        
        Returns:
            float:
        """
        ...
    def get_output_value(self, slider_value: float) -> float:
        r"""
        x.get_output_value(slider_value) -> float
        Get output value from normalized linear (0 - 1) based on internal lin to output mapping.
        
        Args:
            slider_value (float): 
        
        Returns:
            float:
        """
        ...
    def get_lin_value(self, output_value: float) -> float:
        r"""
        x.get_lin_value(output_value) -> float
        Get normalized linear (0 - 1) value from output based on internal lin to output mapping.
        deprecated: 5.1 - GetLinValue is deprecated, please use GetSliderValue instead.
        
        Args:
            output_value (float): 
        
        Returns:
            float:
        """
        ...

class AudioSlider(AudioSliderBase):
    r"""
    An audio slider widget with customizable curves.
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioSlider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_units_text_read_only`` (bool):  [Read-Write] Whether to set the units part of the text label read only.
    - ``is_value_text_read_only`` (bool):  [Read-Write] Whether to set the value part of the text label read only.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``lin_to_output_curve`` (CurveFloat):  [Read-Write] Curves for mapping linear to output values.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_value_changed`` (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
    - ``orientation`` (Orientation):  [Read-Write] The slider's orientation.
    - ``output_to_lin_curve`` (CurveFloat):  [Read-Write]
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``show_label_only_on_hover`` (bool):  [Read-Write] If true, show text label only on hover; if false always show label.
    - ``show_units_text`` (bool):  [Read-Write] Whether to show the units part of the text label.
    - ``slider_background_color`` (LinearColor):  [Read-Write] The color to draw the slider background.
    - ``slider_bar_color`` (LinearColor):  [Read-Write] The color to draw the slider bar.
    - ``slider_thumb_color`` (LinearColor):  [Read-Write] The color to draw the slider thumb.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text_label_background_color`` (LinearColor):  [Read-Write] The color to draw the text label background.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``units_text`` (Text):  [Read-Write] The text label units
    - ``value`` (float):  [Read-Write] The normalized linear (0 - 1) slider value.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_background_color`` (LinearColor):  [Read-Write] The color to draw the widget background.
    """
    @property
    def lin_to_output_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write] Curves for mapping linear to output values.
        """
        ...
    @lin_to_output_curve.setter
    def lin_to_output_curve(self, value: CurveFloat) -> None:
        ...
    @property
    def output_to_lin_curve(self) -> CurveFloat:
        r"""
        (CurveFloat):  [Read-Write]
        """
        ...
    @output_to_lin_curve.setter
    def output_to_lin_curve(self, value: CurveFloat) -> None:
        ...

class AudioVolumeSlider(AudioSlider):
    r"""
    An audio slider widget with default customizable curves for volume (dB).
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioSlider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_units_text_read_only`` (bool):  [Read-Write] Whether to set the units part of the text label read only.
    - ``is_value_text_read_only`` (bool):  [Read-Write] Whether to set the value part of the text label read only.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``lin_to_output_curve`` (CurveFloat):  [Read-Write] Curves for mapping linear to output values.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_value_changed`` (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
    - ``orientation`` (Orientation):  [Read-Write] The slider's orientation.
    - ``output_to_lin_curve`` (CurveFloat):  [Read-Write]
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``show_label_only_on_hover`` (bool):  [Read-Write] If true, show text label only on hover; if false always show label.
    - ``show_units_text`` (bool):  [Read-Write] Whether to show the units part of the text label.
    - ``slider_background_color`` (LinearColor):  [Read-Write] The color to draw the slider background.
    - ``slider_bar_color`` (LinearColor):  [Read-Write] The color to draw the slider bar.
    - ``slider_thumb_color`` (LinearColor):  [Read-Write] The color to draw the slider thumb.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text_label_background_color`` (LinearColor):  [Read-Write] The color to draw the text label background.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``units_text`` (Text):  [Read-Write] The text label units
    - ``value`` (float):  [Read-Write] The normalized linear (0 - 1) slider value.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_background_color`` (LinearColor):  [Read-Write] The color to draw the widget background.
    """
    ...

class AudioFrequencySlider(AudioSliderBase):
    r"""
    An audio slider widget, for use with frequency.
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioSlider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_units_text_read_only`` (bool):  [Read-Write] Whether to set the units part of the text label read only.
    - ``is_value_text_read_only`` (bool):  [Read-Write] Whether to set the value part of the text label read only.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_value_changed`` (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
    - ``orientation`` (Orientation):  [Read-Write] The slider's orientation.
    - ``output_range`` (Vector2D):  [Read-Write] Frequency output range
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``show_label_only_on_hover`` (bool):  [Read-Write] If true, show text label only on hover; if false always show label.
    - ``show_units_text`` (bool):  [Read-Write] Whether to show the units part of the text label.
    - ``slider_background_color`` (LinearColor):  [Read-Write] The color to draw the slider background.
    - ``slider_bar_color`` (LinearColor):  [Read-Write] The color to draw the slider bar.
    - ``slider_thumb_color`` (LinearColor):  [Read-Write] The color to draw the slider thumb.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text_label_background_color`` (LinearColor):  [Read-Write] The color to draw the text label background.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``units_text`` (Text):  [Read-Write] The text label units
    - ``value`` (float):  [Read-Write] The normalized linear (0 - 1) slider value.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_background_color`` (LinearColor):  [Read-Write] The color to draw the widget background.
    """
    ...

class AudioVectorscope(Widget):
    r"""
    A vectorscope UMG widget.
    
    Supports displaying waveforms in 2D (Left channel X axis, Right channel Y axis) from incoming audio samples.
    
    **C++ Source:**
    
    - **Plugin**: AudioWidgets
    - **Module**: AudioWidgets
    - **File**: AudioVectorscopeUMG.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``audio_bus`` (AudioBus):  [Read-Write] The audio bus used to obtain audio samples for the vectorscope
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``display_persistence_ms`` (float):  [Read-Write] For how long the audio samples should persist in the screen (in milliseconds).
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``grid_divisions`` (int32):  [Read-Write] The number of grid divisions.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``panel_layout_type`` (AudioPanelLayoutType):  [Read-Write] Show/Hide advanced panel layout.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``scale`` (float):  [Read-Write] The scale for the displayed audio samples.
    - ``show_grid`` (bool):  [Read-Write] Show/Hide the vectorscope grid.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``vectorscope_style`` (AudioVectorscopePanelStyle):  [Read-Write] The vectorscope panel style
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def vectorscope_style(self) -> AudioVectorscopePanelStyle:
        r"""
        (AudioVectorscopePanelStyle):  [Read-Write] The vectorscope panel style
        """
        ...
    @vectorscope_style.setter
    def vectorscope_style(self, value: AudioVectorscopePanelStyle) -> None:
        ...
    @property
    def audio_bus(self) -> AudioBus:
        r"""
        (AudioBus):  [Read-Write] The audio bus used to obtain audio samples for the vectorscope
        """
        ...
    @audio_bus.setter
    def audio_bus(self, value: AudioBus) -> None:
        ...
    @property
    def show_grid(self) -> bool:
        r"""
        (bool):  [Read-Write] Show/Hide the vectorscope grid.
        """
        ...
    @show_grid.setter
    def show_grid(self, value: bool) -> None:
        ...
    @property
    def grid_divisions(self) -> int:
        r"""
        (int32):  [Read-Write] The number of grid divisions.
        """
        ...
    @grid_divisions.setter
    def grid_divisions(self, value: int) -> None:
        ...
    @property
    def display_persistence_ms(self) -> float:
        r"""
        (float):  [Read-Write] For how long the audio samples should persist in the screen (in milliseconds).
        """
        ...
    @display_persistence_ms.setter
    def display_persistence_ms(self, value: float) -> None:
        ...
    @property
    def scale(self) -> float:
        r"""
        (float):  [Read-Write] The scale for the displayed audio samples.
        """
        ...
    @scale.setter
    def scale(self, value: float) -> None:
        ...
    @property
    def panel_layout_type(self) -> AudioPanelLayoutType:
        r"""
        (AudioPanelLayoutType):  [Read-Write] Show/Hide advanced panel layout.
        """
        ...
    @panel_layout_type.setter
    def panel_layout_type(self, value: AudioPanelLayoutType) -> None:
        ...
    def stop_processing(self) -> None:
        r"""
        x.stop_processing() -> None
        Stops the vectorscope processing.
        """
        ...
    def start_processing(self) -> None:
        r"""
        x.start_processing() -> None
        Starts the vectorscope processing.
        """
        ...

class MetaSoundEditorSubsystem(EditorSubsystem):
    r"""
    The subsystem in charge of editor MetaSound functionality
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEditor
    - **File**: MetasoundEditorSubsystem.h
    
    """
    def set_node_location(self, builder: MetaSoundBuilderBase, node: MetaSoundNodeHandle, location: Vector2D) -> MetaSoundBuilderResult:
        r"""
        x.set_node_location(builder, node, location) -> MetaSoundBuilderResult
        Sets the visual location to InLocation of a given node InNode of a given builder's document.
        
        Args:
            builder (MetaSoundBuilderBase): 
            node (MetaSoundNodeHandle): 
            location (Vector2D): 
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...
    def build_to_asset(self, builder: MetaSoundBuilderBase, author: str, asset_name: str, package_path: str, template_sound_wave: SoundWave = None) -> Tuple[MetaSoundDocumentInterface, MetaSoundBuilderResult]:
        r"""
        x.build_to_asset(builder, author, asset_name, package_path, template_sound_wave=None) -> (MetaSoundDocumentInterface, out_result=MetaSoundBuilderResult)
        Build the given builder to a MetaSound asset
        
        Args:
            builder (MetaSoundBuilderBase): 
            author (str): Sets the author on the given builder's document.
            asset_name (str): Name of the asset to build.
            package_path (str): Path of package to build asset to.
            template_sound_wave (SoundWave): SoundWave settings such as attenuation, modulation, and sound class will be copied from the optional TemplateSoundWave. For preset builders, TemplateSoundWave will override the template values from the referenced asset.
        
        Returns:
            MetaSoundBuilderResult: 
        
            out_result (MetaSoundBuilderResult):
        """
        ...

class MetaSoundBaseFactory(Factory):
    r"""
    Meta Sound Base Factory
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEditor
    - **File**: MetasoundFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``referenced_meta_sound_object`` (Object):  [Read-Write] Set to initialize MetaSound type as Preset,
      using the provided MetaSound as a Reference
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MetaSoundFactory(MetaSoundBaseFactory):
    r"""
    Meta Sound Factory
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEditor
    - **File**: MetasoundFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``referenced_meta_sound_object`` (Object):  [Read-Write] Set to initialize MetaSound type as Preset,
      using the provided MetaSound as a Reference
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MetaSoundSourceFactory(MetaSoundBaseFactory):
    r"""
    Meta Sound Source Factory
    
    **C++ Source:**
    
    - **Plugin**: Metasound
    - **Module**: MetasoundEditor
    - **File**: MetasoundFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``referenced_meta_sound_object`` (Object):  [Read-Write] Set to initialize MetaSound type as Preset,
      using the provided MetaSound as a Reference
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ProceduralMeshLibrary(BlueprintFunctionLibrary):
    r"""
    Kismet Procedural Mesh Library
    
    **C++ Source:**
    
    - **Plugin**: ProceduralMeshComponent
    - **Module**: ProceduralMeshComponent
    - **File**: KismetProceduralMeshLibrary.h
    
    """
    @classmethod
    def slice_procedural_mesh(cls, proc_mesh: ProceduralMeshComponent, plane_position: Vector, plane_normal: Vector, create_other_half: bool, cap_option: ProcMeshSliceCapOption, cap_material: MaterialInterface) -> ProceduralMeshComponent:
        r"""
        X.slice_procedural_mesh(proc_mesh, plane_position, plane_normal, create_other_half, cap_option, cap_material) -> ProceduralMeshComponent
        Slice the ProceduralMeshComponent (including simple convex collision) using a plane. Optionally create 'cap' geometry.
        
        Args:
            proc_mesh (ProceduralMeshComponent): ProceduralMeshComponent to slice
            plane_position (Vector): Point on the plane to use for slicing, in world space
            plane_normal (Vector): Normal of plane used for slicing. Geometry on the positive side of the plane will be kept.
            create_other_half (bool): If true, an additional ProceduralMeshComponent (OutOtherHalfProcMesh) will be created using the other half of the sliced geometry
            cap_option (ProcMeshSliceCapOption): If and how to create 'cap' geometry on the slicing plane
            cap_material (MaterialInterface): If creating a new section for the cap, assign this material to that section
        
        Returns:
            ProceduralMeshComponent: 
        
            out_other_half_proc_mesh (ProceduralMeshComponent): If bCreateOtherHalf is set, this is the new component created. Its owner will be the same as the supplied InProcMesh.
        """
        ...
    @classmethod
    def get_section_from_static_mesh(cls, mesh: StaticMesh, lod_index: int, section_index: int) -> Tuple[Array[Vector], Array[int], Array[Vector], Array[Vector2D], Array[ProcMeshTangent]]:
        r"""
        X.get_section_from_static_mesh(mesh, lod_index, section_index) -> (vertices=Array[Vector], triangles=Array[int32], normals=Array[Vector], u_vs=Array[Vector2D], tangents=Array[ProcMeshTangent])
        Grab geometry data from a StaticMesh asset.
        
        Args:
            mesh (StaticMesh): 
            lod_index (int32): 
            section_index (int32): 
        
        Returns:
            tuple: 
        
            vertices (Array[Vector]): 
        
            triangles (Array[int32]): 
        
            normals (Array[Vector]): 
        
            u_vs (Array[Vector2D]): 
        
            tangents (Array[ProcMeshTangent]):
        """
        ...
    @classmethod
    def get_section_from_procedural_mesh(cls, proc_mesh: ProceduralMeshComponent, section_index: int) -> Tuple[Array[Vector], Array[int], Array[Vector], Array[Vector2D], Array[ProcMeshTangent]]:
        r"""
        X.get_section_from_procedural_mesh(proc_mesh, section_index) -> (vertices=Array[Vector], triangles=Array[int32], normals=Array[Vector], u_vs=Array[Vector2D], tangents=Array[ProcMeshTangent])
        Grab geometry data from a ProceduralMeshComponent.
        
        Args:
            proc_mesh (ProceduralMeshComponent): 
            section_index (int32): 
        
        Returns:
            tuple: 
        
            vertices (Array[Vector]): 
        
            triangles (Array[int32]): 
        
            normals (Array[Vector]): 
        
            u_vs (Array[Vector2D]): 
        
            tangents (Array[ProcMeshTangent]):
        """
        ...
    @classmethod
    def generate_box_mesh(cls, box_radius: Vector) -> Tuple[Array[Vector], Array[int], Array[Vector], Array[Vector2D], Array[ProcMeshTangent]]:
        r"""
        X.generate_box_mesh(box_radius) -> (vertices=Array[Vector], triangles=Array[int32], normals=Array[Vector], u_vs=Array[Vector2D], tangents=Array[ProcMeshTangent])
        Generate vertex and index buffer for a simple box, given the supplied dimensions. Normals, UVs and tangents are also generated for each vertex.
        
        Args:
            box_radius (Vector): 
        
        Returns:
            tuple: 
        
            vertices (Array[Vector]): 
        
            triangles (Array[int32]): 
        
            normals (Array[Vector]): 
        
            u_vs (Array[Vector2D]): 
        
            tangents (Array[ProcMeshTangent]):
        """
        ...
    @classmethod
    def create_grid_mesh_welded(cls, num_x: int, num_y: int, grid_spacing: float = 16.000000) -> Tuple[Array[int], Array[Vector], Array[Vector2D]]:
        r"""
        X.create_grid_mesh_welded(num_x, num_y, grid_spacing=16.000000) -> (triangles=Array[int32], vertices=Array[Vector], u_vs=Array[Vector2D])
        Generate a vertex buffer, index buffer and UVs for a tessellated grid mesh.
        out: Triangles               Output index buffer
        out: Vertices                Output vertex buffer
        out: UVs                             Out UVs
        
        Args:
            num_x (int32): Number of vertices in X direction (must be >= 2)
            num_y (int32): Number of vertices in y direction (must be >= 2)
            grid_spacing (float): Size of each quad in world units
        
        Returns:
            tuple: 
        
            triangles (Array[int32]): 
        
            vertices (Array[Vector]): 
        
            u_vs (Array[Vector2D]):
        """
        ...
    @classmethod
    def create_grid_mesh_triangles(cls, num_x: int, num_y: int, winding: bool) -> Array[int]:
        r"""
        X.create_grid_mesh_triangles(num_x, num_y, winding) -> Array[int32]
        Generate an index buffer for a grid of quads.
        out: Triangles               Output index buffer
        
        Args:
            num_x (int32): Number of vertices in X direction (must be >= 2)
            num_y (int32): Number of vertices in y direction (must be >= 2)
            winding (bool): Reverses winding of indices generated for each quad
        
        Returns:
            Array[int32]: 
        
            triangles (Array[int32]):
        """
        ...
    @classmethod
    def create_grid_mesh_split(cls, num_x: int, num_y: int, grid_spacing: float = 16.000000) -> Tuple[Array[int], Array[Vector], Array[Vector2D], Array[Vector2D]]:
        r"""
        X.create_grid_mesh_split(num_x, num_y, grid_spacing=16.000000) -> (triangles=Array[int32], vertices=Array[Vector], u_vs=Array[Vector2D], uv1s=Array[Vector2D])
        Generate a vertex buffer, index buffer and UVs for a grid mesh where each quad is split, with standard 0-1 UVs on UV0 and point sampled texel center UVs for UV1.
        out: Triangles               Output index buffer
        out: Vertices                Output vertex buffer
        out: UVs                             Out UVs
        out: UV1s                    Out UV1s
        
        Args:
            num_x (int32): Number of vertices in X direction (must be >= 2)
            num_y (int32): Number of vertices in y direction (must be >= 2)
            grid_spacing (float): Size of each quad in world units
        
        Returns:
            tuple: 
        
            triangles (Array[int32]): 
        
            vertices (Array[Vector]): 
        
            u_vs (Array[Vector2D]): 
        
            uv1s (Array[Vector2D]):
        """
        ...
    @classmethod
    def copy_procedural_mesh_from_static_mesh_component(cls, static_mesh_component: StaticMeshComponent, lod_index: int, proc_mesh_component: ProceduralMeshComponent, create_collision: bool) -> None:
        r"""
        X.copy_procedural_mesh_from_static_mesh_component(static_mesh_component, lod_index, proc_mesh_component, create_collision) -> None
        Copy materials from StaticMeshComponent to ProceduralMeshComponent.
        
        Args:
            static_mesh_component (StaticMeshComponent): 
            lod_index (int32): 
            proc_mesh_component (ProceduralMeshComponent): 
            create_collision (bool):
        """
        ...
    @classmethod
    def convert_quad_to_triangles(cls, triangles: Array[int], vert0: int, vert1: int, vert2: int, vert3: int) -> Array[int]:
        r"""
        X.convert_quad_to_triangles(triangles, vert0, vert1, vert2, vert3) -> Array[int32]
        Add a quad, specified by four indices, to a triangle index buffer as two triangles.
        
        Args:
            triangles (Array[int32]): 
            vert0 (int32): 
            vert1 (int32): 
            vert2 (int32): 
            vert3 (int32): 
        
        Returns:
            Array[int32]: 
        
            triangles (Array[int32]):
        """
        ...
    @classmethod
    def calculate_tangents_for_mesh(cls, vertices: Array[Vector], triangles: Array[int], u_vs: Array[Vector2D]) -> Tuple[Array[Vector], Array[ProcMeshTangent]]:
        r"""
        X.calculate_tangents_for_mesh(vertices, triangles, u_vs) -> (normals=Array[Vector], tangents=Array[ProcMeshTangent])
        Automatically generate normals and tangent vectors for a mesh
        UVs are required for correct tangent generation.
        
        Args:
            vertices (Array[Vector]): 
            triangles (Array[int32]): 
            u_vs (Array[Vector2D]): 
        
        Returns:
            tuple: 
        
            normals (Array[Vector]): 
        
            tangents (Array[ProcMeshTangent]):
        """
        ...

class ProceduralMeshComponent(MeshComponent):
    r"""
    Component that allows you to specify custom triangle mesh geometry
    Beware! This feature is experimental and may be substantially changed in future releases.
    
    **C++ Source:**
    
    - **Plugin**: ProceduralMeshComponent
    - **Module**: ProceduralMeshComponent
    - **File**: ProceduralMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_async_cooking`` (bool):  [Read-Write] Controls whether the physics cooking should be done off the game thread. This should be used when collision geometry doesn't have to be immediately up to date (For example streaming in far away objects)
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_complex_as_simple_collision`` (bool):  [Read-Write] Controls whether the complex (Per poly) geometry should be treated as 'simple' collision.
      Should be set to false if this component is going to be given simple collision and simulated.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def use_complex_as_simple_collision(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the complex (Per poly) geometry should be treated as 'simple' collision.
        Should be set to false if this component is going to be given simple collision and simulated.
        """
        ...
    @property
    def use_async_cooking(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the physics cooking should be done off the game thread. This should be used when collision geometry doesn't have to be immediately up to date (For example streaming in far away objects)
        """
        ...
    def update_mesh_section_linear_color(self, section_index: int, vertices: Array[Vector], normals: Array[Vector], uv0: Array[Vector2D], uv1: Array[Vector2D], uv2: Array[Vector2D], uv3: Array[Vector2D], vertex_colors: Array[LinearColor], tangents: Array[ProcMeshTangent], srgb_conversion: bool = True) -> None:
        r"""
        x.update_mesh_section_linear_color(section_index, vertices, normals, uv0, uv1, uv2, uv3, vertex_colors, tangents, srgb_conversion=True) -> None
        Updates a section of this procedural mesh component. This is faster than CreateMeshSection, but does not let you change topology. Collision info is also updated.
        
        Args:
            section_index (int32): 
            vertices (Array[Vector]): Vertex buffer of all vertex positions to use for this mesh section.
            normals (Array[Vector]): Optional array of normal vectors for each vertex. If supplied, must be same length as Vertices array.
            uv0 (Array[Vector2D]): Optional array of texture co-ordinates for each vertex. If supplied, must be same length as Vertices array.
            uv1 (Array[Vector2D]): 
            uv2 (Array[Vector2D]): 
            uv3 (Array[Vector2D]): 
            vertex_colors (Array[LinearColor]): Optional array of colors for each vertex. If supplied, must be same length as Vertices array.
            tangents (Array[ProcMeshTangent]): Optional array of tangent vector for each vertex. If supplied, must be same length as Vertices array.
            srgb_conversion (bool): Whether to do sRGB conversion when converting FLinearColor to FColor
        """
        ...
    def update_mesh_section(self, section_index: int, vertices: Array[Vector], normals: Array[Vector], uv0: Array[Vector2D], vertex_colors: Array[Color], tangents: Array[ProcMeshTangent]) -> None:
        r"""
        x.update_mesh_section(section_index, vertices, normals, uv0, vertex_colors, tangents) -> None
        Updates a section of this procedural mesh component. This is faster than CreateMeshSection, but does not let you change topology. Collision info is also updated.
        This function is deprecated for Blueprints because it uses the unsupported 'Color' type. Use new 'Create Mesh Section' function which uses LinearColor instead.
        deprecated: This function is deprecated for Blueprints because it uses the unsupported 'Color' type. Use new 'Update Mesh Section' function which uses LinearColor instead.
        
        Args:
            section_index (int32): 
            vertices (Array[Vector]): Vertex buffer of all vertex positions to use for this mesh section.
            normals (Array[Vector]): Optional array of normal vectors for each vertex. If supplied, must be same length as Vertices array.
            uv0 (Array[Vector2D]): Optional array of texture co-ordinates for each vertex. If supplied, must be same length as Vertices array.
            vertex_colors (Array[Color]): Optional array of colors for each vertex. If supplied, must be same length as Vertices array.
            tangents (Array[ProcMeshTangent]): Optional array of tangent vector for each vertex. If supplied, must be same length as Vertices array.
        """
        ...
    def set_mesh_section_visible(self, section_index: int, new_visibility: bool) -> None:
        r"""
        x.set_mesh_section_visible(section_index, new_visibility) -> None
        Control visibility of a particular section
        
        Args:
            section_index (int32): 
            new_visibility (bool):
        """
        ...
    def is_mesh_section_visible(self, section_index: int) -> bool:
        r"""
        x.is_mesh_section_visible(section_index) -> bool
        Returns whether a particular section is currently visible
        
        Args:
            section_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_num_sections(self) -> int:
        r"""
        x.get_num_sections() -> int32
        Returns number of sections currently created for this component
        
        Returns:
            int32:
        """
        ...
    def create_mesh_section_linear_color(self, section_index: int, vertices: Array[Vector], triangles: Array[int], normals: Array[Vector], uv0: Array[Vector2D], uv1: Array[Vector2D], uv2: Array[Vector2D], uv3: Array[Vector2D], vertex_colors: Array[LinearColor], tangents: Array[ProcMeshTangent], create_collision: bool, srgb_conversion: bool = False) -> None:
        r"""
        x.create_mesh_section_linear_color(section_index, vertices, triangles, normals, uv0, uv1, uv2, uv3, vertex_colors, tangents, create_collision, srgb_conversion=False) -> None
        Create/replace a section for this procedural mesh component.
        
        Args:
            section_index (int32): Index of the section to create or replace.
            vertices (Array[Vector]): Vertex buffer of all vertex positions to use for this mesh section.
            triangles (Array[int32]): Index buffer indicating which vertices make up each triangle. Length must be a multiple of 3.
            normals (Array[Vector]): Optional array of normal vectors for each vertex. If supplied, must be same length as Vertices array.
            uv0 (Array[Vector2D]): Optional array of texture co-ordinates for each vertex. If supplied, must be same length as Vertices array.
            uv1 (Array[Vector2D]): 
            uv2 (Array[Vector2D]): 
            uv3 (Array[Vector2D]): 
            vertex_colors (Array[LinearColor]): Optional array of colors for each vertex. If supplied, must be same length as Vertices array.
            tangents (Array[ProcMeshTangent]): Optional array of tangent vector for each vertex. If supplied, must be same length as Vertices array.
            create_collision (bool): Indicates whether collision should be created for this section. This adds significant cost.
            srgb_conversion (bool): Whether to do sRGB conversion when converting FLinearColor to FColor
        """
        ...
    def create_mesh_section(self, section_index: int, vertices: Array[Vector], triangles: Array[int], normals: Array[Vector], uv0: Array[Vector2D], vertex_colors: Array[Color], tangents: Array[ProcMeshTangent], create_collision: bool) -> None:
        r"""
        x.create_mesh_section(section_index, vertices, triangles, normals, uv0, vertex_colors, tangents, create_collision) -> None
        Create/replace a section for this procedural mesh component.
        This function is deprecated for Blueprints because it uses the unsupported 'Color' type. Use new 'Create Mesh Section' function which uses LinearColor instead.
        deprecated: This function is deprecated for Blueprints because it uses the unsupported 'Color' type. Use new 'Create Mesh Section' function which uses LinearColor instead.
        
        Args:
            section_index (int32): Index of the section to create or replace.
            vertices (Array[Vector]): Vertex buffer of all vertex positions to use for this mesh section.
            triangles (Array[int32]): Index buffer indicating which vertices make up each triangle. Length must be a multiple of 3.
            normals (Array[Vector]): Optional array of normal vectors for each vertex. If supplied, must be same length as Vertices array.
            uv0 (Array[Vector2D]): Optional array of texture co-ordinates for each vertex. If supplied, must be same length as Vertices array.
            vertex_colors (Array[Color]): Optional array of colors for each vertex. If supplied, must be same length as Vertices array.
            tangents (Array[ProcMeshTangent]): Optional array of tangent vector for each vertex. If supplied, must be same length as Vertices array.
            create_collision (bool): Indicates whether collision should be created for this section. This adds significant cost.
        """
        ...
    def clear_mesh_section(self, section_index: int) -> None:
        r"""
        x.clear_mesh_section(section_index) -> None
        Clear a section of the procedural mesh. Other sections do not change index.
        
        Args:
            section_index (int32):
        """
        ...
    def clear_collision_convex_meshes(self) -> None:
        r"""
        x.clear_collision_convex_meshes() -> None
        Remove collision meshes from this component
        """
        ...
    def clear_all_mesh_sections(self) -> None:
        r"""
        x.clear_all_mesh_sections() -> None
        Clear all mesh sections and reset to empty state
        """
        ...
    def add_collision_convex_mesh(self, convex_verts: Array[Vector]) -> None:
        r"""
        x.add_collision_convex_mesh(convex_verts) -> None
        Add simple collision convex to this component
        
        Args:
            convex_verts (Array[Vector]):
        """
        ...

class LocationServices(BlueprintFunctionLibrary):
    r"""
    Location Services
    
    **C++ Source:**
    
    - **Plugin**: LocationServicesBPLibrary
    - **Module**: LocationServicesBPLibrary
    - **File**: LocationServicesBPLibrary.h
    
    """
    @classmethod
    def stop_location_services(cls) -> bool:
        r"""
        X.stop_location_services() -> bool
        Stops the updates of location from the Location Service that was started with StartLocationService
        
        Returns:
            bool: true if stop is successful
        """
        ...
    @classmethod
    def start_location_services(cls) -> bool:
        r"""
        X.start_location_services() -> bool
        Starts requesting location updates from the appropriate Location Service
        
        Returns:
            bool: true if startup successful
        """
        ...
    @classmethod
    def is_location_accuracy_available(cls, accuracy: LocationAccuracy) -> bool:
        r"""
        X.is_location_accuracy_available(accuracy) -> bool
        Checks if the supplied Accuracy is available on the current device.
        
        Args:
            accuracy (LocationAccuracy): the accuracy to check
        
        Returns:
            bool: true if the mobile device can support the Accuracy, false if it will use a different accuracy
        """
        ...
    @classmethod
    def init_location_services(cls, accuracy: LocationAccuracy, update_frequency: float, min_distance_filter: float) -> bool:
        r"""
        X.init_location_services(accuracy, update_frequency, min_distance_filter) -> bool
        Called to set up the Location Service before use
        
        Args:
            accuracy (LocationAccuracy): as seen in the enum above
            update_frequency (float): in milliseconds. (Android only)
            min_distance_filter (float): 
        
        Returns:
            bool: true if Initialization was succesful
        """
        ...
    @classmethod
    def get_location_services_impl(cls) -> LocationServicesImpl:
        r"""
        X.get_location_services_impl() -> LocationServicesImpl
        * Returns the Location Services implementation object. Intended to be used to set up the FLocationServicesData_OnLocationChanged
        * delegate in Blueprints.
        *
        
        Returns:
            LocationServicesImpl: the Android or IOS impl object
        """
        ...
    @classmethod
    def get_last_known_location(cls) -> LocationServicesData:
        r"""
        X.get_last_known_location() -> LocationServicesData
        Returns the last location information returned by the location service. If no location update has been made, will return
        a default-value-filled struct.
        
        Returns:
            LocationServicesData: the last known location from updates
        """
        ...
    @classmethod
    def are_location_services_enabled(cls) -> bool:
        r"""
        X.are_location_services_enabled() -> bool
        Checks if the Location Services on the mobile device are enabled for this application
        
        Returns:
            bool: true if the mobile device has enabled the appropriate service for the app
        """
        ...

class LocationServicesImpl(Object):
    r"""
    Location Services Impl
    
    **C++ Source:**
    
    - **Plugin**: LocationServicesBPLibrary
    - **Module**: LocationServicesBPLibrary
    - **File**: LocationServicesImpl.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_location_changed`` (LocationServicesData_OnLocationChanged):  [Read-Write]
    """
    @property
    def on_location_changed(self) -> LocationServicesData_OnLocationChanged:
        r"""
        (LocationServicesData_OnLocationChanged):  [Read-Write]
        """
        ...
    @on_location_changed.setter
    def on_location_changed(self, value: LocationServicesData_OnLocationChanged) -> None:
        ...

class ResonanceAudioSoundfieldSettings(SoundfieldEncodingSettingsBase):
    r"""
    Resonance Audio Soundfield Settings
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudio
    - **File**: ResonanceAudioAmbisonicsSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``render_mode`` (ResonanceRenderMode):  [Read-Write] Which order of ambisonics to use for this submix.
    """
    @property
    def render_mode(self) -> ResonanceRenderMode:
        r"""
        (ResonanceRenderMode):  [Read-Only] Which order of ambisonics to use for this submix.
        """
        ...

class ResonanceAudioBlueprintFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    Resonance Audio Blueprint Function Library
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudio
    - **File**: ResonanceAudioBlueprintFunctionLibrary.h
    
    """
    @classmethod
    def set_global_reverb_preset(cls, preset: ResonanceAudioReverbPluginPreset) -> None:
        r"""
        X.set_global_reverb_preset(preset) -> None
        This function overrides the Global Reverb Preset for Resonance Audio
        
        Args:
            preset (ResonanceAudioReverbPluginPreset):
        """
        ...
    @classmethod
    def get_global_reverb_preset(cls) -> ResonanceAudioReverbPluginPreset:
        r"""
        X.get_global_reverb_preset() -> ResonanceAudioReverbPluginPreset
        This function retrieves the Global Reverb Preset for Resonance Audio
        
        Returns:
            ResonanceAudioReverbPluginPreset:
        """
        ...

class ResonanceAudioDirectivityVisualizer(Actor):
    r"""
    Resonance Audio Directivity Visualizer
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudio
    - **File**: ResonanceAudioDirectivityVisualizer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class ResonanceAudioReverbPluginPreset(SoundEffectSubmixPreset):
    r"""
    Resonance Audio Reverb Plugin Preset
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudio
    - **File**: ResonanceAudioReverb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (ResonanceAudioReverbPluginSettings):  [Read-Write]
    """
    def set_room_rotation(self, rotation: Quat) -> None:
        r"""
        x.set_room_rotation(rotation) -> None
        Sets room rotation in 3D space
        
        Args:
            rotation (Quat):
        """
        ...
    def set_room_position(self, position: Vector) -> None:
        r"""
        x.set_room_position(position) -> None
        Sets room position in 3D space
        
        Args:
            position (Vector):
        """
        ...
    def set_room_materials(self, materials: Array[RaMaterialName]) -> None:
        r"""
        x.set_room_materials(materials) -> None
        Sets Resonance Audio room's acoustic materials
        
        Args:
            materials (Array[RaMaterialName]):
        """
        ...
    def set_room_dimensions(self, dimensions: Vector) -> None:
        r"""
        x.set_room_dimensions(dimensions) -> None
        Sets room dimensions in 3D space
        
        Args:
            dimensions (Vector):
        """
        ...
    def set_reverb_time_modifier(self, reverb_time_modifier: float) -> None:
        r"""
        x.set_reverb_time_modifier(reverb_time_modifier) -> None
        Adjusts the reverberation time across all frequency bands by multiplying the computed values by this factor.
        Has no effect when set to 1.0
        
        Args:
            reverb_time_modifier (float):
        """
        ...
    def set_reverb_gain(self, reverb_gain: float) -> None:
        r"""
        x.set_reverb_gain(reverb_gain) -> None
        Sets reverb gain multiplier
        
        Args:
            reverb_gain (float):
        """
        ...
    def set_reverb_brightness(self, reverb_brightness: float) -> None:
        r"""
        x.set_reverb_brightness(reverb_brightness) -> None
        Increases high frequency reverberation times when positive, decreases when negative.
        Has no effect when set to 0.0
        
        Args:
            reverb_brightness (float):
        """
        ...
    def set_reflection_scalar(self, reflection_scalar: float) -> None:
        r"""
        x.set_reflection_scalar(reflection_scalar) -> None
        Sets early reflections gain multiplier
        
        Args:
            reflection_scalar (float):
        """
        ...
    def set_enable_room_effects(self, enable_room_effects: bool) -> None:
        r"""
        x.set_enable_room_effects(enable_room_effects) -> None
        Enables/disables Resonance Audio room effects
        
        Args:
            enable_room_effects (bool):
        """
        ...

class ResonanceAudioSpatializationSourceSettings(SpatializationPluginSourceSettingsBase):
    r"""
    Resonance Audio Spatialization Source Settings
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudio
    - **File**: ResonanceAudioSpatializationSourceSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``max_distance`` (float):  [Read-Write] Maximum distance to apply the chosen attenuation method ((default = 50000.0 cm)
    - ``min_distance`` (float):  [Read-Write] Minimum distance to apply the chosen attenuation method (default = 100.0 cm)
    - ``pattern`` (float):  [Read-Write] Directivity pattern: 0.0 (omnidirectional), 0.5 (cardioid), 1.0 (figure-of-8)
    - ``rolloff`` (RaDistanceRolloffModel):  [Read-Write] Roll-off model to use for sound source distance attenuation. Select 'None' (default) to use Unreal attenuation settings
    - ``scale`` (float):  [Read-Write] Scale (for directivity pattern visualization only).
    - ``sharpness`` (float):  [Read-Write] Sharpness of the directivity pattern. Higher values result in a narrower sound emission beam
    - ``spatialization_method`` (RaSpatializationMethod):  [Read-Write] Spatialization method to use for sound object(s). NOTE: Has no effect if 'Stereo Panning' global quality mode is selected for the project
    - ``spread`` (float):  [Read-Write] Spread (width) of the sound source (in degrees). Note: spread control is not available if 'Stereo Panning' global quality mode is enabled for the project and / or 'Stereo Panning' spatialization mode is enabled for the sound source
    - ``toggle_visualization`` (bool):  [Read-Write] Whether to visualize directivity pattern in the viewport.
    """
    def set_sound_source_spread(self, spread: float) -> None:
        r"""
        x.set_sound_source_spread(spread) -> None
        Sets the sound source spread (width), applies, and updates
        
        Args:
            spread (float):
        """
        ...
    def set_sound_source_directivity(self, pattern: float, sharpness: float) -> None:
        r"""
        x.set_sound_source_directivity(pattern, sharpness) -> None
        Sets the sound source directivity, applies, and updates
        
        Args:
            pattern (float): 
            sharpness (float):
        """
        ...

class AmbisonicsEncodingSettings(SoundfieldEncodingSettingsBase):
    r"""
    Ambisonics Encoding Settings
    
    **C++ Source:**
    
    - **Plugin**: SoundFields
    - **Module**: SoundFields
    - **File**: SoundFields.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ambisonics_order`` (int32):  [Read-Write]
    """
    ...

class AudioImpulseResponse(Object):
    r"""
    UAudioImpulseResponse
    UAsset used to represent Imported Impulse Responses
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EffectConvolutionReverb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``ir_data`` (Array[float]):  [Read-Write]
      deprecated: Property 'IRData' is deprecated.
    - ``normalization_volume_db`` (float):  [Read-Write] Used to account for energy added by convolution with "loud" Impulse Responses.
    - ``true_stereo`` (bool):  [Read-Write] If true, impulse response channels are interpreted as true stereo which allows channel crosstalk. If false, impulse response channels are interpreted as independent channel impulses.
    """
    @property
    def normalization_volume_db(self) -> float:
        r"""
        (float):  [Read-Only] Used to account for energy added by convolution with "loud" Impulse Responses.
        """
        ...
    @property
    def true_stereo(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, impulse response channels are interpreted as true stereo which allows channel crosstalk. If false, impulse response channels are interpreted as independent channel impulses.
        """
        ...
    @property
    def ir_data(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Write]
        deprecated: Property 'IRData' is deprecated.
        """
        ...
    @ir_data.setter
    def ir_data(self, value: Array[float]) -> None:
        ...

class ImpulseResponse(AudioImpulseResponse):
    r"""
    deprecated: 'ImpulseResponse' was renamed to 'AudioImpulseResponse'.
    """
    ...

class ModularSynthPresetBank(Object):
    r"""
    Modular Synth Preset Bank
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Component.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``presets`` (Array[ModularSynthPresetBankEntry]):  [Read-Write]
    """
    @property
    def presets(self) -> Array[ModularSynthPresetBankEntry]:
        r"""
        (Array[ModularSynthPresetBankEntry]):  [Read-Write]
        """
        ...
    @presets.setter
    def presets(self, value: Array[ModularSynthPresetBankEntry]) -> None:
        ...

class ModularSynthLibrary(BlueprintFunctionLibrary):
    r"""
    Modular Synth Library
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Component.h
    
    """
    @classmethod
    def add_modular_synth_preset_to_bank_asset(cls, bank: ModularSynthPresetBank, preset: ModularSynthPreset, preset_name: str) -> None:
        r"""
        X.add_modular_synth_preset_to_bank_asset(bank, preset, preset_name) -> None
        Adds the modular synth preset to the bank asset in the content browser. Only call during editor.
        
        Args:
            bank (ModularSynthPresetBank): 
            preset (ModularSynthPreset): 
            preset_name (str):
        """
        ...

class ModularSynthComponent(SynthComponent):
    r"""
    UModularSynthComponent
    Implementation of a USynthComponent.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: EpicSynth1Component.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``allow_spatialization`` (bool):  [Read-Write] Is this audio component allowed to be spatialized?
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] What sound concurrency to use for sounds generated by this audio component
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulation_routing`` (SoundModulationDefaultRoutingSettings):  [Read-Write]
    - ``on_audio_envelope_value`` (OnSynthEnvelopeValue):  [Read-Write]
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``override_attenuation`` (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sound_class`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] Submix this sound belongs to
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] An array of submix sends. Audio from this sound will send a portion of its audio to these effects.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``voice_count`` (int32):  [Read-Write] The voice count to use for the synthesizer. Cannot be changed
    """
    @property
    def voice_count(self) -> int:
        r"""
        (int32):  [Read-Only] The voice count to use for the synthesizer. Cannot be changed
        """
        ...
    def set_synth_preset(self, synth_preset: ModularSynthPreset) -> None:
        r"""
        x.set_synth_preset(synth_preset) -> None
        Sets the preset struct for the synth
        
        Args:
            synth_preset (ModularSynthPreset):
        """
        ...
    def set_sustain_gain(self, sustain_gain: float) -> None:
        r"""
        x.set_sustain_gain(sustain_gain) -> None
        Sets the envelope sustain gain value.
        
        Args:
            sustain_gain (float):
        """
        ...
    def set_stereo_delay_wetlevel(self, delay_wetlevel: float) -> None:
        r"""
        x.set_stereo_delay_wetlevel(delay_wetlevel) -> None
        Sets the amount of stereo delay wetlevel [0.0, 1.0]
        
        Args:
            delay_wetlevel (float):
        """
        ...
    def set_stereo_delay_time(self, delay_time_msec: float) -> None:
        r"""
        x.set_stereo_delay_time(delay_time_msec) -> None
        Sets the amount of stereo delay time in msec.
        
        Args:
            delay_time_msec (float):
        """
        ...
    def set_stereo_delay_ratio(self, delay_ratio: float) -> None:
        r"""
        x.set_stereo_delay_ratio(delay_ratio) -> None
        Sets the amount of stereo delay ratio between left and right delay lines [0.0, 1.0]
        
        Args:
            delay_ratio (float):
        """
        ...
    def set_stereo_delay_mode(self, stereo_delay_mode: SynthStereoDelayMode) -> None:
        r"""
        x.set_stereo_delay_mode(stereo_delay_mode) -> None
        Sets whether not stereo delay is enabled.
        
        Args:
            stereo_delay_mode (SynthStereoDelayMode):
        """
        ...
    def set_stereo_delay_is_enabled(self, stereo_delay_enabled: bool) -> None:
        r"""
        x.set_stereo_delay_is_enabled(stereo_delay_enabled) -> None
        Sets whether not stereo delay is enabled.
        
        Args:
            stereo_delay_enabled (bool):
        """
        ...
    def set_stereo_delay_feedback(self, delay_feedback: float) -> None:
        r"""
        x.set_stereo_delay_feedback(delay_feedback) -> None
        Sets the amount of stereo delay feedback [0.0, 1.0]
        
        Args:
            delay_feedback (float):
        """
        ...
    def set_spread(self, spread: float) -> None:
        r"""
        x.set_spread(spread) -> None
        Sets the amount of spread of the oscillators. [0.0, 1.0]
        
        Args:
            spread (float):
        """
        ...
    def set_release_time(self, release_time_msec: float) -> None:
        r"""
        x.set_release_time(release_time_msec) -> None
        Sets the envelope release time in msec.
        
        Args:
            release_time_msec (float):
        """
        ...
    def set_portamento(self, portamento: float) -> None:
        r"""
        x.set_portamento(portamento) -> None
        Sets the synth portamento [0.0, 1.0]
        
        Args:
            portamento (float):
        """
        ...
    def set_pitch_bend(self, pitch_bend: float) -> None:
        r"""
        x.set_pitch_bend(pitch_bend) -> None
        Sets the synth pitch bend amount.
        
        Args:
            pitch_bend (float):
        """
        ...
    def set_pan(self, pan: float) -> None:
        r"""
        x.set_pan(pan) -> None
        Sets the pan of the synth [-1.0, 1.0].
        
        Args:
            pan (float):
        """
        ...
    def set_osc_type(self, osc_index: int, osc_type: Synth1OscType) -> None:
        r"""
        x.set_osc_type(osc_index, osc_type) -> None
        Set the oscillator type.
        
        Args:
            osc_index (int32): Which oscillator to set the type for.
            osc_type (Synth1OscType): The oscillator type to set.
        """
        ...
    def set_osc_sync(self, is_synced: bool) -> None:
        r"""
        x.set_osc_sync(is_synced) -> None
        Set whether or not to follow the phase of osc2 to osc1
        
        Args:
            is_synced (bool):
        """
        ...
    def set_osc_semitones(self, osc_index: int, semitones: float) -> None:
        r"""
        x.set_osc_semitones(osc_index, semitones) -> None
        Sets the oscillator semitones.
        
        Args:
            osc_index (int32): Which oscillator to set the type for.
            semitones (float): The amount of semitones to set the oscillator to (relative to base frequency/pitch).
        """
        ...
    def set_osc_pulsewidth(self, osc_index: int, pulsewidth: float) -> None:
        r"""
        x.set_osc_pulsewidth(osc_index, pulsewidth) -> None
        Sets the square wave pulsewidth [0.0, 1.0]
        
        Args:
            osc_index (int32): 
            pulsewidth (float):
        """
        ...
    def set_osc_octave(self, osc_index: int, octave: float) -> None:
        r"""
        x.set_osc_octave(osc_index, octave) -> None
        Sets the oscillator octaves
        
        Args:
            osc_index (int32): Which oscillator to set the type for.
            octave (float): Which octave to set the oscillator to (relative to base frequency/pitch).
        """
        ...
    def set_osc_gain_mod(self, osc_index: int, osc_gain_mod: float) -> None:
        r"""
        x.set_osc_gain_mod(osc_index, osc_gain_mod) -> None
        Set the oscillator gain modulation.
        
        Args:
            osc_index (int32): Which oscillator to set the type for.
            osc_gain_mod (float): The oscillator gain modulation to use.
        """
        ...
    def set_osc_gain(self, osc_index: int, osc_gain: float) -> None:
        r"""
        x.set_osc_gain(osc_index, osc_gain) -> None
        Set the oscillator gain.
        
        Args:
            osc_index (int32): Which oscillator to set the type for.
            osc_gain (float): The oscillator gain.
        """
        ...
    def set_osc_frequency_mod(self, osc_index: int, osc_freq_mod: float) -> None:
        r"""
        x.set_osc_frequency_mod(osc_index, osc_freq_mod) -> None
        Set the oscillator frequency modulation
        
        Args:
            osc_index (int32): Which oscillator to set the type for.
            osc_freq_mod (float): The oscillator frequency modulation to use.
        """
        ...
    def set_osc_cents(self, osc_index: int, cents: float) -> None:
        r"""
        x.set_osc_cents(osc_index, cents) -> None
        Sets the oscillator cents.
        
        Args:
            osc_index (int32): Which oscillator to set the type for.
            cents (float): The amount of cents to set the oscillator to (relative to base frequency/pitch)..
        """
        ...
    def set_mod_env_sustain_gain(self, sustain_gain: float) -> None:
        r"""
        x.set_mod_env_sustain_gain(sustain_gain) -> None
        Sets the envelope modulator sustain gain
        
        Args:
            sustain_gain (float):
        """
        ...
    def set_mod_env_release_time(self, release: float) -> None:
        r"""
        x.set_mod_env_release_time(release) -> None
        Sets the envelope modulator release
        
        Args:
            release (float):
        """
        ...
    def set_mod_env_patch(self, patch_type: SynthModEnvPatch) -> None:
        r"""
        x.set_mod_env_patch(patch_type) -> None
        Sets whether or not to modulate a param based on the envelope. Uses bias envelope output (offset from sustain gain).
        
        Args:
            patch_type (SynthModEnvPatch):
        """
        ...
    def set_mod_env_invert(self, invert: bool) -> None:
        r"""
        x.set_mod_env_invert(invert) -> None
        Sets whether or not to invert the envelope modulator.
        
        Args:
            invert (bool):
        """
        ...
    def set_mod_env_depth(self, depth: float) -> None:
        r"""
        x.set_mod_env_depth(depth) -> None
        Sets the envelope modulator depth (amount to apply the output modulation)
        
        Args:
            depth (float):
        """
        ...
    def set_mod_env_decay_time(self, decay_time_msec: float) -> None:
        r"""
        x.set_mod_env_decay_time(decay_time_msec) -> None
        Sets the envelope modulator attack time in msec
        
        Args:
            decay_time_msec (float):
        """
        ...
    def set_mod_env_bias_patch(self, patch_type: SynthModEnvBiasPatch) -> None:
        r"""
        x.set_mod_env_bias_patch(patch_type) -> None
        Sets whether or not to modulate a param based on the envelope. Uses bias envelope output (offset from sustain gain).
        
        Args:
            patch_type (SynthModEnvBiasPatch):
        """
        ...
    def set_mod_env_bias_invert(self, invert: bool) -> None:
        r"""
        x.set_mod_env_bias_invert(invert) -> None
        Sets whether or not to invert the bias output of the envelope modulator.
        
        Args:
            invert (bool):
        """
        ...
    def set_mod_env_attack_time(self, attack_time_msec: float) -> None:
        r"""
        x.set_mod_env_attack_time(attack_time_msec) -> None
        Sets the envelope modulator attack time in msec
        
        Args:
            attack_time_msec (float):
        """
        ...
    def set_lfo_type(self, lfo_index: int, lfo_type: SynthLFOType) -> None:
        r"""
        x.set_lfo_type(lfo_index, lfo_type) -> None
        Sets the LFO type
        
        Args:
            lfo_index (int32): Which LFO to set the frequency for.
            lfo_type (SynthLFOType): The LFO type to use.
        """
        ...
    def set_lfo_patch(self, lfo_index: int, lfo_patch_type: SynthLFOPatchType) -> None:
        r"""
        x.set_lfo_patch(lfo_index, lfo_patch_type) -> None
        Sets the LFO patch type. LFO patch determines what parameter is modulated by the LFO.
        
        Args:
            lfo_index (int32): Which LFO to set the frequency for.
            lfo_patch_type (SynthLFOPatchType): The LFO patch type to use.
        """
        ...
    def set_lfo_mode(self, lfo_index: int, lfo_mode: SynthLFOMode) -> None:
        r"""
        x.set_lfo_mode(lfo_index, lfo_mode) -> None
        Sets the LFO type
        
        Args:
            lfo_index (int32): Which LFO to set the frequency for.
            lfo_mode (SynthLFOMode): The LFO mode to use.
        """
        ...
    def set_lfo_gain_mod(self, lfo_index: int, gain_mod: float) -> None:
        r"""
        x.set_lfo_gain_mod(lfo_index, gain_mod) -> None
        Sets the LFO gain mod factor (external modulation)
        
        Args:
            lfo_index (int32): Which LFO to set the frequency for.
            gain_mod (float):
        """
        ...
    def set_lfo_gain(self, lfo_index: int, gain: float) -> None:
        r"""
        x.set_lfo_gain(lfo_index, gain) -> None
        Sets the LFO gain factor
        
        Args:
            lfo_index (int32): Which LFO to set the frequency for.
            gain (float): The gain factor to use for the LFO.
        """
        ...
    def set_lfo_frequency_mod(self, lfo_index: int, frequency_mod_hz: float) -> None:
        r"""
        x.set_lfo_frequency_mod(lfo_index, frequency_mod_hz) -> None
        Sets the LFO frequency modulation in hz
        
        Args:
            lfo_index (int32): Which LFO to set the frequency for.
            frequency_mod_hz (float): The LFO frequency to use.
        """
        ...
    def set_lfo_frequency(self, lfo_index: int, frequency_hz: float) -> None:
        r"""
        x.set_lfo_frequency(lfo_index, frequency_hz) -> None
        Sets the LFO frequency in hz
        
        Args:
            lfo_index (int32): Which LFO to set the frequency for.
            frequency_hz (float): The LFO frequency to use.
        """
        ...
    def set_gain_db(self, gain_db: float) -> None:
        r"""
        x.set_gain_db(gain_db) -> None
        Sets the synth gain in decibels.
        
        Args:
            gain_db (float):
        """
        ...
    def set_filter_type(self, filter_type: SynthFilterType) -> None:
        r"""
        x.set_filter_type(filter_type) -> None
        Sets the filter type.
        
        Args:
            filter_type (SynthFilterType):
        """
        ...
    def set_filter_q_mod(self, filter_q: float) -> None:
        r"""
        x.set_filter_q_mod(filter_q) -> None
        Sets a modulated filter Q (resonance)
        
        Args:
            filter_q (float):
        """
        ...
    def set_filter_q(self, filter_q: float) -> None:
        r"""
        x.set_filter_q(filter_q) -> None
        Sets the filter Q (resonance)
        
        Args:
            filter_q (float):
        """
        ...
    def set_filter_frequency_mod(self, filter_frequency_hz: float) -> None:
        r"""
        x.set_filter_frequency_mod(filter_frequency_hz) -> None
        Sets the filter cutoff frequency in hz.
        
        Args:
            filter_frequency_hz (float):
        """
        ...
    def set_filter_frequency(self, filter_frequency_hz: float) -> None:
        r"""
        x.set_filter_frequency(filter_frequency_hz) -> None
        Sets the filter cutoff frequency in hz.
        
        Args:
            filter_frequency_hz (float):
        """
        ...
    def set_filter_algorithm(self, filter_algorithm: SynthFilterAlgorithm) -> None:
        r"""
        x.set_filter_algorithm(filter_algorithm) -> None
        Sets the filter algorithm.
        
        Args:
            filter_algorithm (SynthFilterAlgorithm):
        """
        ...
    def set_enable_unison(self, enable_unison: bool) -> None:
        r"""
        x.set_enable_unison(enable_unison) -> None
        Sets whether or not the synth is in unison mode (i.e. no spread)
        
        Args:
            enable_unison (bool):
        """
        ...
    def set_enable_retrigger(self, retrigger_enabled: bool) -> None:
        r"""
        x.set_enable_retrigger(retrigger_enabled) -> None
        Sets whether or not to retrigger envelope per note on.
        
        Args:
            retrigger_enabled (bool):
        """
        ...
    def set_enable_polyphony(self, enable_polyphony: bool) -> None:
        r"""
        x.set_enable_polyphony(enable_polyphony) -> None
        Sets whether or not to use polyphony for the synthesizer.
        
        Args:
            enable_polyphony (bool): Whether or not to enable polyphony for the synth.
        """
        ...
    def set_enable_patch(self, patch_id: PatchId, is_enabled: bool) -> bool:
        r"""
        x.set_enable_patch(patch_id, is_enabled) -> bool
        Set Enable Patch
        
        Args:
            patch_id (PatchId): 
            is_enabled (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_enable_legato(self, legato_enabled: bool) -> None:
        r"""
        x.set_enable_legato(legato_enabled) -> None
        Sets whether or not to use legato for the synthesizer.
        
        Args:
            legato_enabled (bool):
        """
        ...
    def set_decay_time(self, decay_time_msec: float) -> None:
        r"""
        x.set_decay_time(decay_time_msec) -> None
        Sets the envelope decay time in msec.
        
        Args:
            decay_time_msec (float):
        """
        ...
    def set_chorus_frequency(self, frequency: float) -> None:
        r"""
        x.set_chorus_frequency(frequency) -> None
        Sets the chorus frequency
        
        Args:
            frequency (float):
        """
        ...
    def set_chorus_feedback(self, feedback: float) -> None:
        r"""
        x.set_chorus_feedback(feedback) -> None
        Sets the chorus feedback
        
        Args:
            feedback (float):
        """
        ...
    def set_chorus_enabled(self, enable_chorus: bool) -> None:
        r"""
        x.set_chorus_enabled(enable_chorus) -> None
        Sets whether or not chorus is enabled.
        
        Args:
            enable_chorus (bool):
        """
        ...
    def set_chorus_depth(self, depth: float) -> None:
        r"""
        x.set_chorus_depth(depth) -> None
        Sets the chorus depth
        
        Args:
            depth (float):
        """
        ...
    def set_attack_time(self, attack_time_msec: float) -> None:
        r"""
        x.set_attack_time(attack_time_msec) -> None
        Sets the envelope attack time in msec.
        
        Args:
            attack_time_msec (float):
        """
        ...
    def note_on(self, note: float, velocity: int, duration: float = -1.000000) -> None:
        r"""
        x.note_on(note, velocity, duration=-1.000000) -> None
        Play a new note. Optionally pass in a duration to automatically turn off the note.
        
        Args:
            note (float): 
            velocity (int32): 
            duration (float):
        """
        ...
    def note_off(self, note: float, all_notes_off: bool = False, kill_all_notes: bool = False) -> None:
        r"""
        x.note_off(note, all_notes_off=False, kill_all_notes=False) -> None
        Stop the note (will only do anything if a voice is playing with that note)
        
        Args:
            note (float): 
            all_notes_off (bool): 
            kill_all_notes (bool):
        """
        ...
    def create_patch(self, patch_source: Synth1PatchSource, patch_cables: Array[Synth1PatchCable], enable_by_default: bool) -> PatchId:
        r"""
        x.create_patch(patch_source, patch_cables, enable_by_default) -> PatchId
        Creates a new modular synth patch between a modulation source and a set of modulation destinations
        
        Args:
            patch_source (Synth1PatchSource): 
            patch_cables (Array[Synth1PatchCable]): 
            enable_by_default (bool): 
        
        Returns:
            PatchId:
        """
        ...

class SourceEffectBitCrusherPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Bit Crusher Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectBitCrusher.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectBitCrusherSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectBitCrusherSettings:
        r"""
        (SourceEffectBitCrusherSettings):  [Read-Only]
        """
        ...
    def set_settings(self, settings: SourceEffectBitCrusherBaseSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Sets just base (i.e. carrier) setting values without modifying modulation source references
        
        Args:
            settings (SourceEffectBitCrusherBaseSettings):
        """
        ...
    def set_sample_rate_modulators(self, modulators: Set[SoundModulatorBase]) -> None:
        r"""
        x.set_sample_rate_modulators(modulators) -> None
        Set Sample Rate Modulators
        
        Args:
            modulators (Set[SoundModulatorBase]):
        """
        ...
    def set_sample_rate_modulator(self, modulator: SoundModulatorBase) -> None:
        r"""
        x.set_sample_rate_modulator(modulator) -> None
        Set Sample Rate Modulator
        
        Args:
            modulator (SoundModulatorBase):
        """
        ...
    def set_sample_rate(self, sample_rate: float) -> None:
        r"""
        x.set_sample_rate(sample_rate) -> None
        Set Sample Rate
        
        Args:
            sample_rate (float):
        """
        ...
    def set_modulation_settings(self, modulation_settings: SourceEffectBitCrusherSettings) -> None:
        r"""
        x.set_modulation_settings(modulation_settings) -> None
        Set Modulation Settings
        
        Args:
            modulation_settings (SourceEffectBitCrusherSettings):
        """
        ...
    def set_bits(self, bits: float) -> None:
        r"""
        x.set_bits(bits) -> None
        Set Bits
        
        Args:
            bits (float):
        """
        ...
    def set_bit_modulators(self, modulators: Set[SoundModulatorBase]) -> None:
        r"""
        x.set_bit_modulators(modulators) -> None
        Set Bit Modulators
        
        Args:
            modulators (Set[SoundModulatorBase]):
        """
        ...
    def set_bit_modulator(self, modulator: SoundModulatorBase) -> None:
        r"""
        x.set_bit_modulator(modulator) -> None
        Set Bit Modulator
        
        Args:
            modulator (SoundModulatorBase):
        """
        ...

class SourceEffectChorusPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Chorus Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectChorus.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectChorusSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectChorusSettings:
        r"""
        (SourceEffectChorusSettings):  [Read-Only]
        """
        ...
    def set_wet_modulators(self, modulators: Set[SoundModulatorBase]) -> None:
        r"""
        x.set_wet_modulators(modulators) -> None
        Set Wet Modulators
        
        Args:
            modulators (Set[SoundModulatorBase]):
        """
        ...
    def set_wet_modulator(self, modulator: SoundModulatorBase) -> None:
        r"""
        x.set_wet_modulator(modulator) -> None
        Set Wet Modulator
        
        Args:
            modulator (SoundModulatorBase):
        """
        ...
    def set_wet(self, wet_amount: float) -> None:
        r"""
        x.set_wet(wet_amount) -> None
        Set Wet
        
        Args:
            wet_amount (float):
        """
        ...
    def set_spread_modulators(self, modulators: Set[SoundModulatorBase]) -> None:
        r"""
        x.set_spread_modulators(modulators) -> None
        Set Spread Modulators
        
        Args:
            modulators (Set[SoundModulatorBase]):
        """
        ...
    def set_spread_modulator(self, modulator: SoundModulatorBase) -> None:
        r"""
        x.set_spread_modulator(modulator) -> None
        Set Spread Modulator
        
        Args:
            modulator (SoundModulatorBase):
        """
        ...
    def set_spread(self, spread: float) -> None:
        r"""
        x.set_spread(spread) -> None
        Set Spread
        
        Args:
            spread (float):
        """
        ...
    def set_settings(self, settings: SourceEffectChorusBaseSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Sets just base (i.e. carrier) setting values without modifying modulation source references
        
        Args:
            settings (SourceEffectChorusBaseSettings):
        """
        ...
    def set_modulation_settings(self, modulation_settings: SourceEffectChorusSettings) -> None:
        r"""
        x.set_modulation_settings(modulation_settings) -> None
        Set Modulation Settings
        
        Args:
            modulation_settings (SourceEffectChorusSettings):
        """
        ...
    def set_frequency_modulators(self, modulators: Set[SoundModulatorBase]) -> None:
        r"""
        x.set_frequency_modulators(modulators) -> None
        Set Frequency Modulators
        
        Args:
            modulators (Set[SoundModulatorBase]):
        """
        ...
    def set_frequency_modulator(self, modulator: SoundModulatorBase) -> None:
        r"""
        x.set_frequency_modulator(modulator) -> None
        Set Frequency Modulator
        
        Args:
            modulator (SoundModulatorBase):
        """
        ...
    def set_frequency(self, frequency: float) -> None:
        r"""
        x.set_frequency(frequency) -> None
        Set Frequency
        
        Args:
            frequency (float):
        """
        ...
    def set_feedback_modulators(self, modulators: Set[SoundModulatorBase]) -> None:
        r"""
        x.set_feedback_modulators(modulators) -> None
        Set Feedback Modulators
        
        Args:
            modulators (Set[SoundModulatorBase]):
        """
        ...
    def set_feedback_modulator(self, modulator: SoundModulatorBase) -> None:
        r"""
        x.set_feedback_modulator(modulator) -> None
        Set Feedback Modulator
        
        Args:
            modulator (SoundModulatorBase):
        """
        ...
    def set_feedback(self, feedback: float) -> None:
        r"""
        x.set_feedback(feedback) -> None
        Set Feedback
        
        Args:
            feedback (float):
        """
        ...
    def set_dry_modulators(self, modulators: Set[SoundModulatorBase]) -> None:
        r"""
        x.set_dry_modulators(modulators) -> None
        Set Dry Modulators
        
        Args:
            modulators (Set[SoundModulatorBase]):
        """
        ...
    def set_dry_modulator(self, modulator: SoundModulatorBase) -> None:
        r"""
        x.set_dry_modulator(modulator) -> None
        Set Dry Modulator
        
        Args:
            modulator (SoundModulatorBase):
        """
        ...
    def set_dry(self, dry_amount: float) -> None:
        r"""
        x.set_dry(dry_amount) -> None
        Set Dry
        
        Args:
            dry_amount (float):
        """
        ...
    def set_depth_modulators(self, modulators: Set[SoundModulatorBase]) -> None:
        r"""
        x.set_depth_modulators(modulators) -> None
        Set Depth Modulators
        
        Args:
            modulators (Set[SoundModulatorBase]):
        """
        ...
    def set_depth_modulator(self, modulator: SoundModulatorBase) -> None:
        r"""
        x.set_depth_modulator(modulator) -> None
        Set Depth Modulator
        
        Args:
            modulator (SoundModulatorBase):
        """
        ...
    def set_depth(self, depth: float) -> None:
        r"""
        x.set_depth(depth) -> None
        Set Depth
        
        Args:
            depth (float):
        """
        ...

class SourceEffectConvolutionReverbPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Convolution Reverb Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectConvolutionReverb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``block_size`` (SubmixEffectConvolutionReverbBlockSize):  [Read-Write] Set the internal block size. This can effect latency and performance. Higher values will result in
      lower CPU costs while lower values will result higher CPU costs. Latency may be affected depending
      on the interplay between audio engines buffer sizes and this effects block size. Generally, higher
      values result in higher latency, and lower values result in lower latency.
    - ``enable_hardware_acceleration`` (bool):  [Read-Write] Opt into hardware acceleration of the convolution reverb (if available)
    - ``impulse_response`` (AudioImpulseResponse):  [Read-Write] The impulse response used for convolution.
    - ``settings`` (SourceEffectConvolutionReverbSettings):  [Read-Write] ConvolutionReverbPreset Preset Settings.
    """
    @property
    def impulse_response(self) -> AudioImpulseResponse:
        r"""
        (AudioImpulseResponse):  [Read-Write] The impulse response used for convolution.
        """
        ...
    @impulse_response.setter
    def impulse_response(self, value: AudioImpulseResponse) -> None:
        ...
    @property
    def settings(self) -> SourceEffectConvolutionReverbSettings:
        r"""
        (SourceEffectConvolutionReverbSettings):  [Read-Write] ConvolutionReverbPreset Preset Settings.
        """
        ...
    @settings.setter
    def settings(self, value: SourceEffectConvolutionReverbSettings) -> None:
        ...
    @property
    def block_size(self) -> SubmixEffectConvolutionReverbBlockSize:
        r"""
        (SubmixEffectConvolutionReverbBlockSize):  [Read-Only] Set the internal block size. This can effect latency and performance. Higher values will result in
        lower CPU costs while lower values will result higher CPU costs. Latency may be affected depending
        on the interplay between audio engines buffer sizes and this effects block size. Generally, higher
        values result in higher latency, and lower values result in lower latency.
        """
        ...
    @property
    def enable_hardware_acceleration(self) -> bool:
        r"""
        (bool):  [Read-Only] Opt into hardware acceleration of the convolution reverb (if available)
        """
        ...
    def set_settings(self, settings: SourceEffectConvolutionReverbSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set the convolution reverb settings
        
        Args:
            settings (SourceEffectConvolutionReverbSettings):
        """
        ...

class SourceEffectDynamicsProcessorPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Dynamics Processor Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectDynamicsProcessor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectDynamicsProcessorSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectDynamicsProcessorSettings:
        r"""
        (SourceEffectDynamicsProcessorSettings):  [Read-Only]
        """
        ...
    def set_settings(self, settings: SourceEffectDynamicsProcessorSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SourceEffectDynamicsProcessorSettings):
        """
        ...

class EnvelopeFollowerListener(ActorComponent):
    r"""
    Envelope Follower Listener
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectEnvelopeFollower.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_envelope_follower_update`` (OnEnvelopeFollowerUpdate):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    @property
    def on_envelope_follower_update(self) -> OnEnvelopeFollowerUpdate:
        r"""
        (OnEnvelopeFollowerUpdate):  [Read-Write]
        """
        ...
    @on_envelope_follower_update.setter
    def on_envelope_follower_update(self, value: OnEnvelopeFollowerUpdate) -> None:
        ...

class SourceEffectEnvelopeFollowerPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Envelope Follower Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectEnvelopeFollower.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectEnvelopeFollowerSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectEnvelopeFollowerSettings:
        r"""
        (SourceEffectEnvelopeFollowerSettings):  [Read-Only]
        """
        ...
    def unregister_envelope_follower_listener(self, envelope_follower_listener: EnvelopeFollowerListener) -> None:
        r"""
        x.unregister_envelope_follower_listener(envelope_follower_listener) -> None
        Unregisters an envelope follower listener with the effect.
        
        Args:
            envelope_follower_listener (EnvelopeFollowerListener):
        """
        ...
    def set_settings(self, settings: SourceEffectEnvelopeFollowerSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SourceEffectEnvelopeFollowerSettings):
        """
        ...
    def register_envelope_follower_listener(self, envelope_follower_listener: EnvelopeFollowerListener) -> None:
        r"""
        x.register_envelope_follower_listener(envelope_follower_listener) -> None
        Registers an envelope follower listener with the effect.
        
        Args:
            envelope_follower_listener (EnvelopeFollowerListener):
        """
        ...

class SourceEffectEQPreset(SoundEffectSourcePreset):
    r"""
    Source Effect EQPreset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectEQ.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectEQSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectEQSettings:
        r"""
        (SourceEffectEQSettings):  [Read-Only]
        """
        ...
    def set_settings(self, settings: SourceEffectEQSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SourceEffectEQSettings):
        """
        ...

class SourceEffectFilterPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Filter Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectFilterSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectFilterSettings:
        r"""
        (SourceEffectFilterSettings):  [Read-Only]
        """
        ...
    def set_settings(self, settings: SourceEffectFilterSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SourceEffectFilterSettings):
        """
        ...

class SourceEffectFoldbackDistortionPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Foldback Distortion Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectFoldbackDistortion.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectFoldbackDistortionSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectFoldbackDistortionSettings:
        r"""
        (SourceEffectFoldbackDistortionSettings):  [Read-Only]
        """
        ...
    def set_settings(self, settings: SourceEffectFoldbackDistortionSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SourceEffectFoldbackDistortionSettings):
        """
        ...

class SourceEffectMidSideSpreaderPreset(SoundEffectSourcePreset):
    r"""
    USourceEffectMidSideSpreaderPreset
    This code exposes your preset settings and effect class to the editor.
    And allows for a handle to setting/updating effect settings dynamically.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMidSideSpreader.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectMidSideSpreaderSettings):  [Read-Write] The copy of the settings struct. Can't be written to in BP, but can be read.
      Note that the value read in BP is the serialized settings, will not reflect dynamic changes made in BP.
    """
    @property
    def settings(self) -> SourceEffectMidSideSpreaderSettings:
        r"""
        (SourceEffectMidSideSpreaderSettings):  [Read-Only] The copy of the settings struct. Can't be written to in BP, but can be read.
        Note that the value read in BP is the serialized settings, will not reflect dynamic changes made in BP.
        """
        ...
    def set_settings(self, settings: SourceEffectMidSideSpreaderSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Change settings of your effect from blueprints. Will broadcast changes to active instances.
        
        Args:
            settings (SourceEffectMidSideSpreaderSettings):
        """
        ...

class SourceEffectMotionFilterPreset(SoundEffectSourcePreset):
    r"""
    USourceEffectMotionFilterPreset
    This code exposes your preset settings and effect class to the editor.
    And allows for a handle to setting/updating effect settings dynamically.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectMotionFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectMotionFilterSettings):  [Read-Write] The copy of the settings struct. Can't be written to in BP, but can be read.
      Note that the value read in BP is the serialized settings, will not reflect dynamic changes made in BP.
    """
    @property
    def settings(self) -> SourceEffectMotionFilterSettings:
        r"""
        (SourceEffectMotionFilterSettings):  [Read-Only] The copy of the settings struct. Can't be written to in BP, but can be read.
        Note that the value read in BP is the serialized settings, will not reflect dynamic changes made in BP.
        """
        ...
    def set_settings(self, settings: SourceEffectMotionFilterSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Change settings of your effect from blueprints. Will broadcast changes to active instances.
        
        Args:
            settings (SourceEffectMotionFilterSettings):
        """
        ...

class SourceEffectPannerPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Panner Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectPanner.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectPannerSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectPannerSettings:
        r"""
        (SourceEffectPannerSettings):  [Read-Only]
        """
        ...
    def set_settings(self, settings: SourceEffectPannerSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SourceEffectPannerSettings):
        """
        ...

class SourceEffectPhaserPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Phaser Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectPhaser.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectPhaserSettings):  [Read-Write] The depth of the chorus effect
    """
    @property
    def settings(self) -> SourceEffectPhaserSettings:
        r"""
        (SourceEffectPhaserSettings):  [Read-Write] The depth of the chorus effect
        """
        ...
    @settings.setter
    def settings(self, value: SourceEffectPhaserSettings) -> None:
        ...
    def set_settings(self, settings: SourceEffectPhaserSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SourceEffectPhaserSettings):
        """
        ...

class SourceEffectRingModulationPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Ring Modulation Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectRingModulation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectRingModulationSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectRingModulationSettings:
        r"""
        (SourceEffectRingModulationSettings):  [Read-Only]
        """
        ...
    def set_settings(self, settings: SourceEffectRingModulationSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SourceEffectRingModulationSettings):
        """
        ...

class SourceEffectSimpleDelayPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Simple Delay Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectSimpleDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectSimpleDelaySettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectSimpleDelaySettings:
        r"""
        (SourceEffectSimpleDelaySettings):  [Read-Only]
        """
        ...
    def set_settings(self, settings: SourceEffectSimpleDelaySettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SourceEffectSimpleDelaySettings):
        """
        ...

class SourceEffectStereoDelayPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Stereo Delay Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectStereoDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectStereoDelaySettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectStereoDelaySettings:
        r"""
        (SourceEffectStereoDelaySettings):  [Read-Only]
        """
        ...
    def set_settings(self, settings: SourceEffectStereoDelaySettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SourceEffectStereoDelaySettings):
        """
        ...

class SourceEffectWaveShaperPreset(SoundEffectSourcePreset):
    r"""
    Source Effect Wave Shaper Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SourceEffectWaveShaper.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SourceEffectWaveShaperSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SourceEffectWaveShaperSettings:
        r"""
        (SourceEffectWaveShaperSettings):  [Read-Only]
        """
        ...
    def set_settings(self, settings: SourceEffectWaveShaperSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SourceEffectWaveShaperSettings):
        """
        ...

class SubmixEffectConvolutionReverbPreset(SoundEffectSubmixPreset):
    r"""
    Submix Effect Convolution Reverb Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectConvolutionReverb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``block_size`` (SubmixEffectConvolutionReverbBlockSize):  [Read-Write] Set the internal block size. This can effect latency and performance. Higher values will result in
      lower CPU costs while lower values will result higher CPU costs. Latency may be affected depending
      on the interplay between audio engines buffer sizes and this effects block size. Generally, higher
      values result in higher latency, and lower values result in lower latency.
    - ``enable_hardware_acceleration`` (bool):  [Read-Write] Opt into hardware acceleration of the convolution reverb (if available)
    - ``impulse_response`` (AudioImpulseResponse):  [Read-Write] The impulse response used for convolution.
    - ``settings`` (SubmixEffectConvolutionReverbSettings):  [Read-Write] ConvolutionReverbPreset Preset Settings.
    """
    @property
    def impulse_response(self) -> AudioImpulseResponse:
        r"""
        (AudioImpulseResponse):  [Read-Write] The impulse response used for convolution.
        """
        ...
    @impulse_response.setter
    def impulse_response(self, value: AudioImpulseResponse) -> None:
        ...
    @property
    def settings(self) -> SubmixEffectConvolutionReverbSettings:
        r"""
        (SubmixEffectConvolutionReverbSettings):  [Read-Write] ConvolutionReverbPreset Preset Settings.
        """
        ...
    @settings.setter
    def settings(self, value: SubmixEffectConvolutionReverbSettings) -> None:
        ...
    @property
    def block_size(self) -> SubmixEffectConvolutionReverbBlockSize:
        r"""
        (SubmixEffectConvolutionReverbBlockSize):  [Read-Only] Set the internal block size. This can effect latency and performance. Higher values will result in
        lower CPU costs while lower values will result higher CPU costs. Latency may be affected depending
        on the interplay between audio engines buffer sizes and this effects block size. Generally, higher
        values result in higher latency, and lower values result in lower latency.
        """
        ...
    @property
    def enable_hardware_acceleration(self) -> bool:
        r"""
        (bool):  [Read-Only] Opt into hardware acceleration of the convolution reverb (if available)
        """
        ...
    def set_settings(self, settings: SubmixEffectConvolutionReverbSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set the convolution reverb settings
        
        Args:
            settings (SubmixEffectConvolutionReverbSettings):
        """
        ...

class ConvolutionReverbPreset(SubmixEffectConvolutionReverbPreset):
    r"""
    deprecated: 'ConvolutionReverbPreset' was renamed to 'SubmixEffectConvolutionReverbPreset'.
    """
    ...

class SubmixEffectDelayStatics(BlueprintFunctionLibrary):
    r"""
    Submix Effect Delay Statics
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectDelay.h
    
    """
    @classmethod
    def set_maximum_delay_length(cls, delay_settings: SubmixEffectDelaySettings, maximum_delay_length: float) -> Tuple[SubmixEffectDelaySettings, SubmixEffectDelaySettings]:
        r"""
        X.set_maximum_delay_length(delay_settings, maximum_delay_length) -> (SubmixEffectDelaySettings, delay_settings=SubmixEffectDelaySettings)
        Set Maximum Delay Length
        
        Args:
            delay_settings (SubmixEffectDelaySettings): 
            maximum_delay_length (float): 
        
        Returns:
            SubmixEffectDelaySettings: 
        
            delay_settings (SubmixEffectDelaySettings):
        """
        ...
    @classmethod
    def set_interpolation_time(cls, delay_settings: SubmixEffectDelaySettings, interpolation_time: float) -> Tuple[SubmixEffectDelaySettings, SubmixEffectDelaySettings]:
        r"""
        X.set_interpolation_time(delay_settings, interpolation_time) -> (SubmixEffectDelaySettings, delay_settings=SubmixEffectDelaySettings)
        Set Interpolation Time
        
        Args:
            delay_settings (SubmixEffectDelaySettings): 
            interpolation_time (float): 
        
        Returns:
            SubmixEffectDelaySettings: 
        
            delay_settings (SubmixEffectDelaySettings):
        """
        ...
    @classmethod
    def set_delay_length(cls, delay_settings: SubmixEffectDelaySettings, delay_length: float) -> Tuple[SubmixEffectDelaySettings, SubmixEffectDelaySettings]:
        r"""
        X.set_delay_length(delay_settings, delay_length) -> (SubmixEffectDelaySettings, delay_settings=SubmixEffectDelaySettings)
        Set Delay Length
        
        Args:
            delay_settings (SubmixEffectDelaySettings): 
            delay_length (float): 
        
        Returns:
            SubmixEffectDelaySettings: 
        
            delay_settings (SubmixEffectDelaySettings):
        """
        ...

class SubmixEffectDelayPreset(SoundEffectSubmixPreset):
    r"""
    USubmixEffectDelayPreset
    Class which processes audio streams and uses parameters defined in the preset class.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SubmixEffectDelaySettings):  [Read-Write]
    """
    @property
    def settings(self) -> SubmixEffectDelaySettings:
        r"""
        (SubmixEffectDelaySettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: SubmixEffectDelaySettings) -> None:
        ...
    def set_settings(self, settings: SubmixEffectDelaySettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Sets runtime delay settings. This will replace any dynamically added or modified settings without modifying
        the original UObject.
        
        Args:
            settings (SubmixEffectDelaySettings):
        """
        ...
    def set_interpolation_time(self, time: float) -> None:
        r"""
        x.set_interpolation_time(time) -> None
        Set the time it takes to interpolate between parameters, in milliseconds.
        
        Args:
            time (float):
        """
        ...
    def set_delay(self, length: float) -> None:
        r"""
        x.set_delay(length) -> None
        Set how long the delay actually is, in milliseconds.
        
        Args:
            length (float):
        """
        ...
    def set_default_settings(self, settings: SubmixEffectDelaySettings) -> None:
        r"""
        x.set_default_settings(settings) -> None
        Sets object's default settings. This will update both the default UObject settings (and mark it as dirty),
        as well as any dynamically set settings.
        
        Args:
            settings (SubmixEffectDelaySettings):
        """
        ...
    def get_max_delay_in_milliseconds(self) -> float:
        r"""
        x.get_max_delay_in_milliseconds() -> float
        Get the maximum delay possible.
        
        Returns:
            float:
        """
        ...

class SubmixEffectFilterPreset(SoundEffectSubmixPreset):
    r"""
    USubmixEffectFilterPreset
    Class which processes audio streams and uses parameters defined in the preset class.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SubmixEffectFilterSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SubmixEffectFilterSettings:
        r"""
        (SubmixEffectFilterSettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: SubmixEffectFilterSettings) -> None:
        ...
    def set_settings(self, settings: SubmixEffectFilterSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set all filter effect settings
        
        Args:
            settings (SubmixEffectFilterSettings):
        """
        ...
    def set_filter_type(self, type: SubmixFilterType) -> None:
        r"""
        x.set_filter_type(type) -> None
        Sets the filter type
        
        Args:
            type (SubmixFilterType):
        """
        ...
    def set_filter_q_mod(self, q: float) -> None:
        r"""
        x.set_filter_q_mod(q) -> None
        Sets the filter Q
        
        Args:
            q (float):
        """
        ...
    def set_filter_q(self, q: float) -> None:
        r"""
        x.set_filter_q(q) -> None
        Sets the filter Q
        
        Args:
            q (float):
        """
        ...
    def set_filter_cutoff_frequency_mod(self, frequency: float) -> None:
        r"""
        x.set_filter_cutoff_frequency_mod(frequency) -> None
        Sets the mod filter cutoff frequency
        
        Args:
            frequency (float):
        """
        ...
    def set_filter_cutoff_frequency(self, frequency: float) -> None:
        r"""
        x.set_filter_cutoff_frequency(frequency) -> None
        Sets the base filter cutoff frequency
        
        Args:
            frequency (float):
        """
        ...
    def set_filter_algorithm(self, algorithm: SubmixFilterAlgorithm) -> None:
        r"""
        x.set_filter_algorithm(algorithm) -> None
        Sets the filter algorithm
        
        Args:
            algorithm (SubmixFilterAlgorithm):
        """
        ...

class SubmixEffectFlexiverbPreset(SoundEffectSubmixPreset):
    r"""
    Submix Effect Flexiverb Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectFlexiverb.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SubmixEffectFlexiverbSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SubmixEffectFlexiverbSettings:
        r"""
        (SubmixEffectFlexiverbSettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: SubmixEffectFlexiverbSettings) -> None:
        ...
    def set_settings(self, settings: SubmixEffectFlexiverbSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SubmixEffectFlexiverbSettings):
        """
        ...

class SubmixEffectMultibandCompressorPreset(SoundEffectSubmixPreset):
    r"""
    Submix Effect Multiband Compressor Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectMultiBandCompressor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SubmixEffectMultibandCompressorSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SubmixEffectMultibandCompressorSettings:
        r"""
        (SubmixEffectMultibandCompressorSettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: SubmixEffectMultibandCompressorSettings) -> None:
        ...
    def set_settings(self, settings: SubmixEffectMultibandCompressorSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set Settings
        
        Args:
            settings (SubmixEffectMultibandCompressorSettings):
        """
        ...
    def set_external_submix(self, submix: SoundSubmix) -> None:
        r"""
        x.set_external_submix(submix) -> None
        Sets the source key input as the provided Submix's output.  If no object is provided, key is set
        to effect's input.
        
        Args:
            submix (SoundSubmix):
        """
        ...
    def set_audio_bus(self, audio_bus: AudioBus) -> None:
        r"""
        x.set_audio_bus(audio_bus) -> None
        Sets the source key input as the provided AudioBus' output.  If no object is provided, key is set
        to effect's input.
        
        Args:
            audio_bus (AudioBus):
        """
        ...
    def reset_key(self) -> None:
        r"""
        x.reset_key() -> None
        Reset Key
        """
        ...

class SubmixEffectStereoDelayPreset(SoundEffectSubmixPreset):
    r"""
    USubmixEffectDelayPreset
    Class which processes audio streams and uses parameters defined in the preset class.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectStereoDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SubmixEffectStereoDelaySettings):  [Read-Write]
    """
    @property
    def settings(self) -> SubmixEffectStereoDelaySettings:
        r"""
        (SubmixEffectStereoDelaySettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: SubmixEffectStereoDelaySettings) -> None:
        ...
    def set_settings(self, settings: SubmixEffectStereoDelaySettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set all tap delay settings. This will replace any dynamically added or modified taps.
        
        Args:
            settings (SubmixEffectStereoDelaySettings):
        """
        ...

class SubmixEffectStereoToQuadPreset(SoundEffectSubmixPreset):
    r"""
    Submix effect which sends stereo audio to quad (left surround and right surround) if the channel count is greater than 2.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectStereoToQuad.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SubmixEffectStereoToQuadSettings):  [Read-Write]
    """
    @property
    def settings(self) -> SubmixEffectStereoToQuadSettings:
        r"""
        (SubmixEffectStereoToQuadSettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: SubmixEffectStereoToQuadSettings) -> None:
        ...
    def set_settings(self, settings: SubmixEffectStereoToQuadSettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set all tap delay settings. This will replace any dynamically added or modified taps.
        
        Args:
            settings (SubmixEffectStereoToQuadSettings):
        """
        ...

class SubmixEffectTapDelayPreset(SoundEffectSubmixPreset):
    r"""
    UTapDelaySubmixPreset
    Class which processes audio streams and uses parameters defined in the preset class.
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SubmixEffectTapDelay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (SubmixEffectTapDelaySettings):  [Read-Write]
    """
    @property
    def settings(self) -> SubmixEffectTapDelaySettings:
        r"""
        (SubmixEffectTapDelaySettings):  [Read-Write]
        """
        ...
    @settings.setter
    def settings(self, value: SubmixEffectTapDelaySettings) -> None:
        ...
    def set_tap(self, tap_id: int, tap_info: TapDelayInfo) -> None:
        r"""
        x.set_tap(tap_id, tap_info) -> None
        Modify a specific tap.
        
        Args:
            tap_id (int32): 
            tap_info (TapDelayInfo):
        """
        ...
    def set_settings(self, settings: SubmixEffectTapDelaySettings) -> None:
        r"""
        x.set_settings(settings) -> None
        Set all tap delay setting. This will replace any dynamically added or modified taps.
        
        Args:
            settings (SubmixEffectTapDelaySettings):
        """
        ...
    def set_interpolation_time(self, time: float) -> None:
        r"""
        x.set_interpolation_time(time) -> None
        Set the time it takes to interpolate between parameters, in milliseconds.
        
        Args:
            time (float):
        """
        ...
    def remove_tap(self, tap_id: int) -> None:
        r"""
        x.remove_tap(tap_id) -> None
        Remove the tap from the preset.
        
        Args:
            tap_id (int32):
        """
        ...
    def get_tap_ids(self) -> Array[int]:
        r"""
        x.get_tap_ids() -> Array[int32]
        Retrieve an array of all tap ids for the submix effect.
        
        Returns:
            Array[int32]: 
        
            tap_ids (Array[int32]):
        """
        ...
    def get_tap(self, tap_id: int) -> TapDelayInfo:
        r"""
        x.get_tap(tap_id) -> TapDelayInfo
        Get the current info about a specific tap.
        
        Args:
            tap_id (int32): 
        
        Returns:
            TapDelayInfo: 
        
            tap_info (TapDelayInfo):
        """
        ...
    def get_max_delay_in_milliseconds(self) -> float:
        r"""
        x.get_max_delay_in_milliseconds() -> float
        Get the maximum delay possible.
        
        Returns:
            float:
        """
        ...
    def add_tap(self) -> int:
        r"""
        x.add_tap() -> int32
        Adds a dynamic tap delay with the given settings. Returns the tap id.
        
        Returns:
            int32: 
        
            tap_id (int32):
        """
        ...

class GranularSynth(SynthComponent):
    r"""
    Granular Synth
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentGranulator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``allow_spatialization`` (bool):  [Read-Write] Is this audio component allowed to be spatialized?
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] What sound concurrency to use for sounds generated by this audio component
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulation_routing`` (SoundModulationDefaultRoutingSettings):  [Read-Write]
    - ``on_audio_envelope_value`` (OnSynthEnvelopeValue):  [Read-Write]
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``override_attenuation`` (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sound_class`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] Submix this sound belongs to
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] An array of submix sends. Audio from this sound will send a portion of its audio to these effects.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    def set_sustain_gain(self, sustain_gain: float) -> None:
        r"""
        x.set_sustain_gain(sustain_gain) -> None
        Set Sustain Gain
        
        Args:
            sustain_gain (float):
        """
        ...
    def set_sound_wave(self, sound_wave: SoundWave) -> None:
        r"""
        x.set_sound_wave(sound_wave) -> None
        This will override the current sound wave if one is set, stop audio, and reload the new sound wave
        
        Args:
            sound_wave (SoundWave):
        """
        ...
    def set_scrub_mode(self, scrub_mode: bool) -> None:
        r"""
        x.set_scrub_mode(scrub_mode) -> None
        Set Scrub Mode
        
        Args:
            scrub_mode (bool):
        """
        ...
    def set_release_time_msec(self, release_time_msec: float) -> None:
        r"""
        x.set_release_time_msec(release_time_msec) -> None
        Set Release Time Msec
        
        Args:
            release_time_msec (float):
        """
        ...
    def set_playhead_time(self, position_sec: float, lerp_time_sec: float = 0.000000, seek_type: GranularSynthSeekType = GranularSynthSeekType.FROM_BEGINNING) -> None:
        r"""
        x.set_playhead_time(position_sec, lerp_time_sec=0.000000, seek_type=GranularSynthSeekType.FROM_BEGINNING) -> None
        Set Playhead Time
        
        Args:
            position_sec (float): 
            lerp_time_sec (float): 
            seek_type (GranularSynthSeekType):
        """
        ...
    def set_playback_speed(self, playhead_rate: float) -> None:
        r"""
        x.set_playback_speed(playhead_rate) -> None
        Set Playback Speed
        
        Args:
            playhead_rate (float):
        """
        ...
    def set_grain_volume(self, base_volume: float, volume_range: Vector2D = [0.000000, 0.000000]) -> None:
        r"""
        x.set_grain_volume(base_volume, volume_range=[0.000000, 0.000000]) -> None
        Set Grain Volume
        
        Args:
            base_volume (float): 
            volume_range (Vector2D):
        """
        ...
    def set_grains_per_second(self, grains_per_second: float) -> None:
        r"""
        x.set_grains_per_second(grains_per_second) -> None
        Set Grains Per Second
        
        Args:
            grains_per_second (float):
        """
        ...
    def set_grain_probability(self, grain_probability: float) -> None:
        r"""
        x.set_grain_probability(grain_probability) -> None
        Set Grain Probability
        
        Args:
            grain_probability (float):
        """
        ...
    def set_grain_pitch(self, base_pitch: float, pitch_range: Vector2D = [0.000000, 0.000000]) -> None:
        r"""
        x.set_grain_pitch(base_pitch, pitch_range=[0.000000, 0.000000]) -> None
        Set Grain Pitch
        
        Args:
            base_pitch (float): 
            pitch_range (Vector2D):
        """
        ...
    def set_grain_pan(self, base_pan: float, pan_range: Vector2D = [0.000000, 0.000000]) -> None:
        r"""
        x.set_grain_pan(base_pan, pan_range=[0.000000, 0.000000]) -> None
        Set Grain Pan
        
        Args:
            base_pan (float): 
            pan_range (Vector2D):
        """
        ...
    def set_grain_envelope_type(self, envelope_type: GranularSynthEnvelopeType) -> None:
        r"""
        x.set_grain_envelope_type(envelope_type) -> None
        Set Grain Envelope Type
        
        Args:
            envelope_type (GranularSynthEnvelopeType):
        """
        ...
    def set_grain_duration(self, base_duration_msec: float, duration_range: Vector2D = [0.000000, 0.000000]) -> None:
        r"""
        x.set_grain_duration(base_duration_msec, duration_range=[0.000000, 0.000000]) -> None
        Set Grain Duration
        
        Args:
            base_duration_msec (float): 
            duration_range (Vector2D):
        """
        ...
    def set_decay_time(self, decay_time_msec: float) -> None:
        r"""
        x.set_decay_time(decay_time_msec) -> None
        Set Decay Time
        
        Args:
            decay_time_msec (float):
        """
        ...
    def set_attack_time(self, attack_time_msec: float) -> None:
        r"""
        x.set_attack_time(attack_time_msec) -> None
        Set Attack Time
        
        Args:
            attack_time_msec (float):
        """
        ...
    def note_on(self, note: float, velocity: int, duration: float = -1.000000) -> None:
        r"""
        x.note_on(note, velocity, duration=-1.000000) -> None
        Note On
        
        Args:
            note (float): 
            velocity (int32): 
            duration (float):
        """
        ...
    def note_off(self, note: float, kill: bool = False) -> None:
        r"""
        x.note_off(note, kill=False) -> None
        Note Off
        
        Args:
            note (float): 
            kill (bool):
        """
        ...
    def is_loaded(self) -> bool:
        r"""
        x.is_loaded() -> bool
        Is Loaded
        
        Returns:
            bool:
        """
        ...
    def get_sample_duration(self) -> float:
        r"""
        x.get_sample_duration() -> float
        Get Sample Duration
        
        Returns:
            float:
        """
        ...
    def get_current_playhead_time(self) -> float:
        r"""
        x.get_current_playhead_time() -> float
        Get Current Playhead Time
        
        Returns:
            float:
        """
        ...

class MonoWaveTableSynthPreset(Object):
    r"""
    UStruct Mono Wave Table Synth Preset
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentMonoWaveTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``lock_keyframes_to_grid`` (int32):  [Read-Write] How many evenly-spaced keyframes to use when LockKeyframesToGrid is true
    - ``lock_keyframes_to_grid_bool`` (bool):  [Read-Write] Lock wavetables to evenly spaced keyframes that can be edited vertically only (will re-sample)
    - ``normalize_wave_tables`` (bool):  [Read-Write] Normalize the WaveTable data? False will allow clipping, True will normalize the tables when sent to the synth for rendering
    - ``preset_name`` (str):  [Read-Write] Name the preset
    - ``wave_table`` (Array[RuntimeFloatCurve]):  [Read-Write] Wave Table Editor
    - ``wave_table_resolution`` (int32):  [Read-Write] How many samples will be taken of the curve from time = [0.0, 1.0]
    """
    @property
    def preset_name(self) -> str:
        r"""
        (str):  [Read-Write] Name the preset
        """
        ...
    @preset_name.setter
    def preset_name(self, value: str) -> None:
        ...
    @property
    def lock_keyframes_to_grid_bool(self) -> bool:
        r"""
        (bool):  [Read-Only] Lock wavetables to evenly spaced keyframes that can be edited vertically only (will re-sample)
        """
        ...
    @property
    def lock_keyframes_to_grid(self) -> int:
        r"""
        (int32):  [Read-Only] How many evenly-spaced keyframes to use when LockKeyframesToGrid is true
        """
        ...
    @property
    def wave_table_resolution(self) -> int:
        r"""
        (int32):  [Read-Only] How many samples will be taken of the curve from time = [0.0, 1.0]
        """
        ...
    @property
    def wave_table(self) -> Array[RuntimeFloatCurve]:
        r"""
        (Array[RuntimeFloatCurve]):  [Read-Only] Wave Table Editor
        """
        ...
    @property
    def normalize_wave_tables(self) -> bool:
        r"""
        (bool):  [Read-Write] Normalize the WaveTable data? False will allow clipping, True will normalize the tables when sent to the synth for rendering
        """
        ...
    @normalize_wave_tables.setter
    def normalize_wave_tables(self, value: bool) -> None:
        ...

class SynthComponentMonoWaveTable(SynthComponent):
    r"""
    Synth Component Mono Wave Table
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentMonoWaveTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``allow_spatialization`` (bool):  [Read-Write] Is this audio component allowed to be spatialized?
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] What sound concurrency to use for sounds generated by this audio component
    - ``current_preset`` (MonoWaveTableSynthPreset):  [Read-Write] The settings asset to use for this synth
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulation_routing`` (SoundModulationDefaultRoutingSettings):  [Read-Write]
    - ``on_audio_envelope_value`` (OnSynthEnvelopeValue):  [Read-Write]
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_num_tables_changed`` (NumTablesChanged):  [Read-Write] Curve array altered
    - ``on_table_altered`` (OnTableAltered):  [Read-Write] Wave Table curve was edited
    - ``override_attenuation`` (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sound_class`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] Submix this sound belongs to
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] An array of submix sends. Audio from this sound will send a portion of its audio to these effects.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def on_table_altered(self) -> OnTableAltered:
        r"""
        (OnTableAltered):  [Read-Write] Wave Table curve was edited
        """
        ...
    @on_table_altered.setter
    def on_table_altered(self, value: OnTableAltered) -> None:
        ...
    @property
    def on_num_tables_changed(self) -> NumTablesChanged:
        r"""
        (NumTablesChanged):  [Read-Write] Curve array altered
        """
        ...
    @on_num_tables_changed.setter
    def on_num_tables_changed(self, value: NumTablesChanged) -> None:
        ...
    def set_wave_table_position(self, position: float) -> None:
        r"""
        x.set_wave_table_position(position) -> None
        Sets the wavetable position. Expects a percentage between 0.0 and 1.0
        
        Args:
            position (float):
        """
        ...
    def set_sustain_pedal_state(self, sustain_pedal_state: bool) -> None:
        r"""
        x.set_sustain_pedal_state(sustain_pedal_state) -> None
        Inform the synth if the sustain pedal is pressed or not
        
        Args:
            sustain_pedal_state (bool):
        """
        ...
    def set_pos_lfo_type(self, lfo_type: SynthLFOType) -> None:
        r"""
        x.set_pos_lfo_type(lfo_type) -> None
        Set the shape of the Lfo controlling the position
        
        Args:
            lfo_type (SynthLFOType):
        """
        ...
    def set_pos_lfo_frequency(self, lfo_frequency: float) -> None:
        r"""
        x.set_pos_lfo_frequency(lfo_frequency) -> None
        Set frequency of LFO controlling Table Position (in Hz)
        
        Args:
            lfo_frequency (float):
        """
        ...
    def set_pos_lfo_depth(self, lfo_depth: float) -> None:
        r"""
        x.set_pos_lfo_depth(lfo_depth) -> None
        Set the Modulation depth of the Lfo controlling the Table Position around the current position value
                 0.0 = no modulation, 1.0 = current position +/- 0.5 (Lfo + Position result will clamp [0.0, 1.0])
        
        Args:
            lfo_depth (float):
        """
        ...
    def set_position_envelope_sustain_gain(self, sustain_gain: float) -> None:
        r"""
        x.set_position_envelope_sustain_gain(sustain_gain) -> None
        Set Position envelope sustain gain
        
        Args:
            sustain_gain (float):
        """
        ...
    def set_position_envelope_release_time(self, release_time_msec: float) -> None:
        r"""
        x.set_position_envelope_release_time(release_time_msec) -> None
        Set Position envelope release time (msec)
        
        Args:
            release_time_msec (float):
        """
        ...
    def set_position_envelope_invert(self, invert: bool) -> None:
        r"""
        x.set_position_envelope_invert(invert) -> None
        Set Position envelope envelope inversion
        
        Args:
            invert (bool):
        """
        ...
    def set_position_envelope_depth(self, depth: float) -> None:
        r"""
        x.set_position_envelope_depth(depth) -> None
        Set Position envelope envelope depth
        
        Args:
            depth (float):
        """
        ...
    def set_position_envelope_decay_time(self, decay_time_msec: float) -> None:
        r"""
        x.set_position_envelope_decay_time(decay_time_msec) -> None
        Set Position envelope decay time (msec)
        
        Args:
            decay_time_msec (float):
        """
        ...
    def set_position_envelope_bias_invert(self, bias_invert: bool) -> None:
        r"""
        x.set_position_envelope_bias_invert(bias_invert) -> None
        Set Position envelope bias inversion
        
        Args:
            bias_invert (bool):
        """
        ...
    def set_position_envelope_bias_depth(self, depth: float) -> None:
        r"""
        x.set_position_envelope_bias_depth(depth) -> None
        Set Position envelope bias depth
        
        Args:
            depth (float):
        """
        ...
    def set_position_envelope_attack_time(self, attack_time_msec: float) -> None:
        r"""
        x.set_position_envelope_attack_time(attack_time_msec) -> None
        Set Position envelope attack time (msec)
        
        Args:
            attack_time_msec (float):
        """
        ...
    def set_low_pass_filter_resonance(self, new_q: float) -> None:
        r"""
        x.set_low_pass_filter_resonance(new_q) -> None
        Set the Cut-off frequency of the low-pass filter
        
        Args:
            new_q (float):
        """
        ...
    def set_frequency_with_midi_note(self, midi_note: float) -> None:
        r"""
        x.set_frequency_with_midi_note(midi_note) -> None
        Set the oscillator's frequency via midi note number
        
        Args:
            midi_note (float):
        """
        ...
    def set_frequency_pitch_bend(self, frequency_offset_cents: float) -> None:
        r"""
        x.set_frequency_pitch_bend(frequency_offset_cents) -> None
        Set a frequency offset in cents (for pitch modulation such as the Pitch Bend Wheel)
        
        Args:
            frequency_offset_cents (float):
        """
        ...
    def set_frequency(self, frequency_hz: float) -> None:
        r"""
        x.set_frequency(frequency_hz) -> None
        Sets the oscillator's frequency
        
        Args:
            frequency_hz (float):
        """
        ...
    def set_filter_envelope_sustain_gain(self, sustain_gain: float) -> None:
        r"""
        x.set_filter_envelope_sustain_gain(sustain_gain) -> None
        Set Low-Pass Filter envelope sustain gain
        
        Args:
            sustain_gain (float):
        """
        ...
    def set_filter_envelope_release_time(self, release_time_msec: float) -> None:
        r"""
        x.set_filter_envelope_release_time(release_time_msec) -> None
        Set Low-Pass Filter envelope release time (msec)
        
        Args:
            release_time_msec (float):
        """
        ...
    def set_filter_envelopen_decay_time(self, decay_time_msec: float) -> None:
        r"""
        x.set_filter_envelopen_decay_time(decay_time_msec) -> None
        Set Low-Pass Filter envelope decay time (msec)
        
        Args:
            decay_time_msec (float):
        """
        ...
    def set_filter_envelope_invert(self, invert: bool) -> None:
        r"""
        x.set_filter_envelope_invert(invert) -> None
        Set Low-Pass Filter envelope inversion
        
        Args:
            invert (bool):
        """
        ...
    def set_filter_envelope_depth(self, depth: float) -> None:
        r"""
        x.set_filter_envelope_depth(depth) -> None
        Set Low-Pass Filter envelope depth
        
        Args:
            depth (float):
        """
        ...
    def set_filter_envelope_bias_invert(self, bias_invert: bool) -> None:
        r"""
        x.set_filter_envelope_bias_invert(bias_invert) -> None
        Set Low-Pass Filter envelope bias inversion
        
        Args:
            bias_invert (bool):
        """
        ...
    def set_filter_envelope_bias_depth(self, depth: float) -> None:
        r"""
        x.set_filter_envelope_bias_depth(depth) -> None
        Set Low-Pass Filter envelope bias depth
        
        Args:
            depth (float):
        """
        ...
    def set_filter_envelope_attack_time(self, attack_time_msec: float) -> None:
        r"""
        x.set_filter_envelope_attack_time(attack_time_msec) -> None
        Set Low-Pass Filter envelope attack time (msec)
        
        Args:
            attack_time_msec (float):
        """
        ...
    def set_curve_value(self, table_index: int, keyframe_index: int, new_value: float) -> bool:
        r"""
        x.set_curve_value(table_index, keyframe_index, new_value) -> bool
        Set a Keyframe value given a Table number and Keyframe number.
                 Returns false if the request was invalid.
                 NewValue will be clamped from +/- 1.0
        
        Args:
            table_index (int32): 
            keyframe_index (int32): 
            new_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_curve_tangent(self, table_index: int, new_tangent: float) -> bool:
        r"""
        x.set_curve_tangent(table_index, new_tangent) -> bool
        Set the curve tangent ("Curve depth" between keyframes)
        This should only be used for live-editing features! (changing the curves at runtime is expensive)
        
        Args:
            table_index (int32): 
            new_tangent (float): 
        
        Returns:
            bool:
        """
        ...
    def set_curve_interpolation_type(self, interpolation_type: CurveInterpolationType, table_index: int) -> bool:
        r"""
        x.set_curve_interpolation_type(interpolation_type, table_index) -> bool
        Set the curve interpolation type (What the curve is doing between keyframes)
        This should only be used for live-editing features! (changing the curves at runtime is expensive)
        
        Args:
            interpolation_type (CurveInterpolationType): 
            table_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_amp_envelope_sustain_gain(self, sustain_gain: float) -> None:
        r"""
        x.set_amp_envelope_sustain_gain(sustain_gain) -> None
        Set Amp envelope sustain gain [0.0, 1.0]
        
        Args:
            sustain_gain (float):
        """
        ...
    def set_amp_envelope_release_time(self, release_time_msec: float) -> None:
        r"""
        x.set_amp_envelope_release_time(release_time_msec) -> None
        Set Amp envelope release time (msec)
        
        Args:
            release_time_msec (float):
        """
        ...
    def set_amp_envelope_invert(self, invert: bool) -> None:
        r"""
        x.set_amp_envelope_invert(invert) -> None
        Set whether or not the Amp envelope is inverted
        
        Args:
            invert (bool):
        """
        ...
    def set_amp_envelope_depth(self, depth: float) -> None:
        r"""
        x.set_amp_envelope_depth(depth) -> None
        Set the overall depth of the Amp envelope
        
        Args:
            depth (float):
        """
        ...
    def set_amp_envelope_decay_time(self, decay_time_msec: float) -> None:
        r"""
        x.set_amp_envelope_decay_time(decay_time_msec) -> None
        Set Amp envelope decay time (msec)
        
        Args:
            decay_time_msec (float):
        """
        ...
    def set_amp_envelope_bias_invert(self, bias_invert: bool) -> None:
        r"""
        x.set_amp_envelope_bias_invert(bias_invert) -> None
        Set whether or not the Amp envelope's bias is inverted
        
        Args:
            bias_invert (bool):
        """
        ...
    def set_amp_envelope_bias_depth(self, depth: float) -> None:
        r"""
        x.set_amp_envelope_bias_depth(depth) -> None
        Set the bias depth of the the Amp envelope
        
        Args:
            depth (float):
        """
        ...
    def set_amp_envelope_attack_time(self, attack_time_msec: float) -> None:
        r"""
        x.set_amp_envelope_attack_time(attack_time_msec) -> None
        Set Amp envelope attack time (msec)
        
        Args:
            attack_time_msec (float):
        """
        ...
    def refresh_wave_table(self, index: int) -> None:
        r"""
        x.refresh_wave_table(index) -> None
        Refresh a particular wavetable (from Game Thread data)
        
        Args:
            index (int32):
        """
        ...
    def refresh_all_wave_tables(self) -> None:
        r"""
        x.refresh_all_wave_tables() -> None
        Refresh all wavetables (from Game Thread data)
        """
        ...
    def note_on(self, midi_note: float, velocity: float) -> None:
        r"""
        x.note_on(midi_note, velocity) -> None
        Starts a new note (retrigs modulators, etc.)
        
        Args:
            midi_note (float): 
            velocity (float):
        """
        ...
    def note_off(self, midi_note: float) -> None:
        r"""
        x.note_off(midi_note) -> None
        Starts a new note (retrigs modulators, etc.)
        
        Args:
            midi_note (float):
        """
        ...
    def get_num_table_entries(self) -> int:
        r"""
        x.get_num_table_entries() -> int32
        Start BP functionality // Get the number of table elements from Blueprint
        
        Returns:
            int32:
        """
        ...
    def get_max_table_index(self) -> int:
        r"""
        x.get_max_table_index() -> int32
        Get the number of curves in the wave table. (returns -1 if there is no asset)
        
        Returns:
            int32:
        """
        ...
    def get_key_frame_values_for_table(self, table_index: float) -> Array[float]:
        r"""
        x.get_key_frame_values_for_table(table_index) -> Array[float]
        Get an array of floats that represent the key frames in the requested curve
        
        Args:
            table_index (float): 
        
        Returns:
            Array[float]:
        """
        ...
    def get_curve_tangent(self, table_index: int) -> float:
        r"""
        x.get_curve_tangent(table_index) -> float
        Get the curve interpolation type (What the curve is doing between keyframes)
        
        Args:
            table_index (int32): 
        
        Returns:
            float:
        """
        ...

class SynthComponentToneGenerator(SynthComponent):
    r"""
    Synth Component Tone Generator
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentToneGenerator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``allow_spatialization`` (bool):  [Read-Write] Is this audio component allowed to be spatialized?
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_db_at_max_range`` (float):  [Read-Write] An attenuation, in decibels, to apply to the sound at max range.
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] What sound concurrency to use for sounds generated by this audio component
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``distance_attenuation_curve`` (RuntimeFloatCurve):  [Read-Write] A distance attenuation curve to use to attenuate the audio.
    - ``distance_range`` (Vector2D):  [Read-Write] A distance range over which to apply distance attenuation using the supplied curve.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``frequency`` (float):  [Read-Write] The frequency (in hz) of the tone generator.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulation_routing`` (SoundModulationDefaultRoutingSettings):  [Read-Write]
    - ``on_audio_envelope_value`` (OnSynthEnvelopeValue):  [Read-Write]
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``override_attenuation`` (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sound_class`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] Submix this sound belongs to
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] An array of submix sends. Audio from this sound will send a portion of its audio to these effects.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volume`` (float):  [Read-Write] The linear volume of the tone generator.
    """
    @property
    def frequency(self) -> float:
        r"""
        (float):  [Read-Only] The frequency (in hz) of the tone generator.
        """
        ...
    @property
    def volume(self) -> float:
        r"""
        (float):  [Read-Only] The linear volume of the tone generator.
        """
        ...
    @property
    def distance_attenuation_curve(self) -> RuntimeFloatCurve:
        r"""
        (RuntimeFloatCurve):  [Read-Write] A distance attenuation curve to use to attenuate the audio.
        """
        ...
    @distance_attenuation_curve.setter
    def distance_attenuation_curve(self, value: RuntimeFloatCurve) -> None:
        ...
    @property
    def distance_range(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] A distance range over which to apply distance attenuation using the supplied curve.
        """
        ...
    @distance_range.setter
    def distance_range(self, value: Vector2D) -> None:
        ...
    @property
    def attenuation_db_at_max_range(self) -> float:
        r"""
        (float):  [Read-Write] An attenuation, in decibels, to apply to the sound at max range.
        """
        ...
    @attenuation_db_at_max_range.setter
    def attenuation_db_at_max_range(self, value: float) -> None:
        ...
    def set_volume(self, volume: float) -> None:
        r"""
        x.set_volume(volume) -> None
        Sets the volume of the tone generator
        
        Args:
            volume (float):
        """
        ...
    def set_frequency(self, frequency: float) -> None:
        r"""
        x.set_frequency(frequency) -> None
        Sets the frequency of the tone generator
        
        Args:
            frequency (float):
        """
        ...

class SynthSamplePlayer(SynthComponent):
    r"""
    Synth Sample Player
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthComponentWaveTable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``allow_spatialization`` (bool):  [Read-Write] Is this audio component allowed to be spatialized?
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] What sound concurrency to use for sounds generated by this audio component
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulation_routing`` (SoundModulationDefaultRoutingSettings):  [Read-Write]
    - ``on_audio_envelope_value`` (OnSynthEnvelopeValue):  [Read-Write]
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_sample_loaded`` (OnSampleLoaded):  [Read-Write]
    - ``on_sample_playback_progress`` (OnSamplePlaybackProgress):  [Read-Write]
    - ``override_attenuation`` (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sound_class`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] Submix this sound belongs to
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] An array of submix sends. Audio from this sound will send a portion of its audio to these effects.
    - ``sound_wave`` (SoundWave):  [Read-Write]
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def sound_wave(self) -> SoundWave:
        r"""
        (SoundWave):  [Read-Write]
        """
        ...
    @sound_wave.setter
    def sound_wave(self, value: SoundWave) -> None:
        ...
    @property
    def on_sample_loaded(self) -> OnSampleLoaded:
        r"""
        (OnSampleLoaded):  [Read-Write]
        """
        ...
    @on_sample_loaded.setter
    def on_sample_loaded(self, value: OnSampleLoaded) -> None:
        ...
    @property
    def on_sample_playback_progress(self) -> OnSamplePlaybackProgress:
        r"""
        (OnSamplePlaybackProgress):  [Read-Write]
        """
        ...
    @on_sample_playback_progress.setter
    def on_sample_playback_progress(self, value: OnSamplePlaybackProgress) -> None:
        ...
    def set_sound_wave(self, sound_wave: SoundWave) -> None:
        r"""
        x.set_sound_wave(sound_wave) -> None
        This will override the current sound wave if one is set, stop audio, and reload the new sound wave
        
        Args:
            sound_wave (SoundWave):
        """
        ...
    def set_scrub_time_width(self, scrub_time_width_sec: float) -> None:
        r"""
        x.set_scrub_time_width(scrub_time_width_sec) -> None
        Set Scrub Time Width
        
        Args:
            scrub_time_width_sec (float):
        """
        ...
    def set_scrub_mode(self, scrub_mode: bool) -> None:
        r"""
        x.set_scrub_mode(scrub_mode) -> None
        Set Scrub Mode
        
        Args:
            scrub_mode (bool):
        """
        ...
    def set_pitch(self, pitch: float, time_sec: float) -> None:
        r"""
        x.set_pitch(pitch, time_sec) -> None
        Set Pitch
        
        Args:
            pitch (float): 
            time_sec (float):
        """
        ...
    def seek_to_time(self, time_sec: float, seek_type: SamplePlayerSeekType, wrap: bool = True) -> None:
        r"""
        x.seek_to_time(time_sec, seek_type, wrap=True) -> None
        Seek to Time
        
        Args:
            time_sec (float): 
            seek_type (SamplePlayerSeekType): 
            wrap (bool):
        """
        ...
    def is_loaded(self) -> bool:
        r"""
        x.is_loaded() -> bool
        Is Loaded
        
        Returns:
            bool:
        """
        ...
    def get_sample_duration(self) -> float:
        r"""
        x.get_sample_duration() -> float
        Get Sample Duration
        
        Returns:
            float:
        """
        ...
    def get_current_playback_progress_time(self) -> float:
        r"""
        x.get_current_playback_progress_time() -> float
        Get Current Playback Progress Time
        
        Returns:
            float:
        """
        ...
    def get_current_playback_progress_percent(self) -> float:
        r"""
        x.get_current_playback_progress_percent() -> float
        Get Current Playback Progress Percent
        
        Returns:
            float:
        """
        ...

class SynthesisUtilitiesBlueprintFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    Synthesis Utilities Blueprint Function Library
    A library of synthesis related functions for use in Blueprints
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthesisBlueprintUtilities.h
    
    """
    @classmethod
    def get_log_frequency(cls, linear_value: float, domain_min: float, domain_max: float, range_min: float, range_max: float) -> float:
        r"""
        X.get_log_frequency(linear_value, domain_min, domain_max, range_min, range_max) -> float
        Returns the log frequency of the input value. Maps linear domain and range values to log output (good for linear slider controlling frequency)
        
        Args:
            linear_value (float): 
            domain_min (float): 
            domain_max (float): 
            range_min (float): 
            range_max (float): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_linear_frequency(cls, log_frequency_value: float, domain_min: float, domain_max: float, range_min: float, range_max: float) -> float:
        r"""
        X.get_linear_frequency(log_frequency_value, domain_min, domain_max, range_min, range_max) -> float
        Returns the log frequency of the input value. Maps linear domain and range values to log output (good for linear slider controlling frequency)
        
        Args:
            log_frequency_value (float): 
            domain_min (float): 
            domain_max (float): 
            range_min (float): 
            range_max (float): 
        
        Returns:
            float:
        """
        ...

class Synth2DSlider(Widget):
    r"""
    A simple widget that shows a sliding bar with a handle that allows you to control the value between 0..1.
    
    * No Children
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: Synth2DSlider.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``indent_handle`` (bool):  [Read-Write] Whether the slidable area should be indented to fit the handle.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Should the slider be focusable?
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``locked`` (bool):  [Read-Write] Whether the handle is interactive or fixed.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_controller_capture_begin`` (OnControllerCaptureBeginEventSynth2D):  [Read-Write] Invoked when the controller capture begins.
    - ``on_controller_capture_end`` (OnControllerCaptureEndEventSynth2D):  [Read-Write] Invoked when the controller capture ends.
    - ``on_mouse_capture_begin`` (OnMouseCaptureBeginEventSynth2D):  [Read-Write] Invoked when the mouse is pressed and a capture begins.
    - ``on_mouse_capture_end`` (OnMouseCaptureEndEventSynth2D):  [Read-Write] Invoked when the mouse is released and a capture ends.
    - ``on_value_changed_x`` (OnFloatValueChangedEventSynth2D):  [Read-Write] Called when the value is changed by slider or typing.
    - ``on_value_changed_y`` (OnFloatValueChangedEventSynth2D):  [Read-Write] Called when the value is changed by slider or typing.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slider_handle_color`` (LinearColor):  [Read-Write] The color to draw the slider handle in.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``step_size`` (float):  [Read-Write] The amount to adjust the value by, when using a controller or keyboard
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``value_x`` (float):  [Read-Write]
    - ``value_y`` (float):  [Read-Write]
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (Synth2DSliderStyle):  [Read-Write] The progress bar style
    """
    @property
    def widget_style(self) -> Synth2DSliderStyle:
        r"""
        (Synth2DSliderStyle):  [Read-Write] The progress bar style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: Synth2DSliderStyle) -> None:
        ...
    @property
    def slider_handle_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color to draw the slider handle in.
        """
        ...
    @property
    def indent_handle(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the slidable area should be indented to fit the handle.
        """
        ...
    @property
    def locked(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the handle is interactive or fixed.
        """
        ...
    @property
    def step_size(self) -> float:
        r"""
        (float):  [Read-Only] The amount to adjust the value by, when using a controller or keyboard
        """
        ...
    @property
    def is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Only] Should the slider be focusable?
        """
        ...
    @property
    def on_mouse_capture_begin(self) -> OnMouseCaptureBeginEventSynth2D:
        r"""
        (OnMouseCaptureBeginEventSynth2D):  [Read-Write] Invoked when the mouse is pressed and a capture begins.
        """
        ...
    @on_mouse_capture_begin.setter
    def on_mouse_capture_begin(self, value: OnMouseCaptureBeginEventSynth2D) -> None:
        ...
    @property
    def on_mouse_capture_end(self) -> OnMouseCaptureEndEventSynth2D:
        r"""
        (OnMouseCaptureEndEventSynth2D):  [Read-Write] Invoked when the mouse is released and a capture ends.
        """
        ...
    @on_mouse_capture_end.setter
    def on_mouse_capture_end(self, value: OnMouseCaptureEndEventSynth2D) -> None:
        ...
    @property
    def on_controller_capture_begin(self) -> OnControllerCaptureBeginEventSynth2D:
        r"""
        (OnControllerCaptureBeginEventSynth2D):  [Read-Write] Invoked when the controller capture begins.
        """
        ...
    @on_controller_capture_begin.setter
    def on_controller_capture_begin(self, value: OnControllerCaptureBeginEventSynth2D) -> None:
        ...
    @property
    def on_controller_capture_end(self) -> OnControllerCaptureEndEventSynth2D:
        r"""
        (OnControllerCaptureEndEventSynth2D):  [Read-Write] Invoked when the controller capture ends.
        """
        ...
    @on_controller_capture_end.setter
    def on_controller_capture_end(self, value: OnControllerCaptureEndEventSynth2D) -> None:
        ...
    @property
    def on_value_changed_x(self) -> OnFloatValueChangedEventSynth2D:
        r"""
        (OnFloatValueChangedEventSynth2D):  [Read-Write] Called when the value is changed by slider or typing.
        """
        ...
    @on_value_changed_x.setter
    def on_value_changed_x(self, value: OnFloatValueChangedEventSynth2D) -> None:
        ...
    @property
    def on_value_changed_y(self) -> OnFloatValueChangedEventSynth2D:
        r"""
        (OnFloatValueChangedEventSynth2D):  [Read-Write] Called when the value is changed by slider or typing.
        """
        ...
    @on_value_changed_y.setter
    def on_value_changed_y(self, value: OnFloatValueChangedEventSynth2D) -> None:
        ...
    def set_value(self, value: Vector2D) -> None:
        r"""
        x.set_value(value) -> None
        Sets the current value of the slider.
        
        Args:
            value (Vector2D):
        """
        ...
    def set_step_size(self, value: float) -> None:
        r"""
        x.set_step_size(value) -> None
        Sets the amount to adjust the value by, when using a controller or keyboard
        
        Args:
            value (float):
        """
        ...
    def set_slider_handle_color(self, value: LinearColor) -> None:
        r"""
        x.set_slider_handle_color(value) -> None
        Sets the color of the handle bar
        
        Args:
            value (LinearColor):
        """
        ...
    def set_locked(self, value: bool) -> None:
        r"""
        x.set_locked(value) -> None
        Sets the handle to be interactive or fixed
        
        Args:
            value (bool):
        """
        ...
    def set_indent_handle(self, value: bool) -> None:
        r"""
        x.set_indent_handle(value) -> None
        Sets if the slidable area should be indented to fit the handle
        
        Args:
            value (bool):
        """
        ...
    def get_value(self) -> Vector2D:
        r"""
        x.get_value() -> Vector2D
        Gets the current value of the slider.
        
        Returns:
            Vector2D:
        """
        ...

class SynthKnob(Widget):
    r"""
    A simple widget that shows a sliding bar with a handle that allows you to control the value between 0..1.
    
    * No Children
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: Synthesis
    - **File**: SynthKnob.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Should the slider be focusable?
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``locked`` (bool):  [Read-Write] Whether the handle is interactive or fixed.
    - ``mouse_fine_tune_speed`` (float):  [Read-Write] The speed of the mouse knob control when fine-tuning the knob
    - ``mouse_speed`` (float):  [Read-Write] The speed of the mouse knob control
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_controller_capture_begin`` (OnControllerCaptureBeginEvent):  [Read-Write] Invoked when the controller capture begins.
    - ``on_controller_capture_end`` (OnControllerCaptureEndEvent):  [Read-Write] Invoked when the controller capture ends.
    - ``on_mouse_capture_begin`` (OnMouseCaptureBeginEvent):  [Read-Write] Invoked when the mouse is pressed and a capture begins.
    - ``on_mouse_capture_end`` (OnMouseCaptureEndEvent):  [Read-Write] Invoked when the mouse is released and a capture ends.
    - ``on_value_changed`` (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``parameter_name`` (Text):  [Read-Write] The name of the pararameter. Will show when knob turns.
    - ``parameter_units`` (Text):  [Read-Write] The parameter units (e.g. hz). Will append to synth tooltip info.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``show_tooltip_info`` (bool):  [Read-Write] Enable tool tip window to show parameter information while knob turns
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``step_size`` (float):  [Read-Write] The amount to adjust the value by, when using a controller or keyboard
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``value`` (float):  [Read-Write] The volume value to display.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (SynthKnobStyle):  [Read-Write] The synth knob style
    """
    @property
    def step_size(self) -> float:
        r"""
        (float):  [Read-Only] The amount to adjust the value by, when using a controller or keyboard
        """
        ...
    @property
    def mouse_speed(self) -> float:
        r"""
        (float):  [Read-Only] The speed of the mouse knob control
        """
        ...
    @property
    def mouse_fine_tune_speed(self) -> float:
        r"""
        (float):  [Read-Only] The speed of the mouse knob control when fine-tuning the knob
        """
        ...
    @property
    def show_tooltip_info(self) -> bool:
        r"""
        (bool):  [Read-Only] Enable tool tip window to show parameter information while knob turns
        """
        ...
    @property
    def parameter_name(self) -> Text:
        r"""
        (Text):  [Read-Only] The name of the pararameter. Will show when knob turns.
        """
        ...
    @property
    def parameter_units(self) -> Text:
        r"""
        (Text):  [Read-Only] The parameter units (e.g. hz). Will append to synth tooltip info.
        """
        ...
    @property
    def widget_style(self) -> SynthKnobStyle:
        r"""
        (SynthKnobStyle):  [Read-Write] The synth knob style
        """
        ...
    @widget_style.setter
    def widget_style(self, value: SynthKnobStyle) -> None:
        ...
    @property
    def locked(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the handle is interactive or fixed.
        """
        ...
    @property
    def is_focusable(self) -> bool:
        r"""
        (bool):  [Read-Only] Should the slider be focusable?
        """
        ...
    @property
    def on_mouse_capture_begin(self) -> OnMouseCaptureBeginEvent:
        r"""
        (OnMouseCaptureBeginEvent):  [Read-Write] Invoked when the mouse is pressed and a capture begins.
        """
        ...
    @on_mouse_capture_begin.setter
    def on_mouse_capture_begin(self, value: OnMouseCaptureBeginEvent) -> None:
        ...
    @property
    def on_mouse_capture_end(self) -> OnMouseCaptureEndEvent:
        r"""
        (OnMouseCaptureEndEvent):  [Read-Write] Invoked when the mouse is released and a capture ends.
        """
        ...
    @on_mouse_capture_end.setter
    def on_mouse_capture_end(self, value: OnMouseCaptureEndEvent) -> None:
        ...
    @property
    def on_controller_capture_begin(self) -> OnControllerCaptureBeginEvent:
        r"""
        (OnControllerCaptureBeginEvent):  [Read-Write] Invoked when the controller capture begins.
        """
        ...
    @on_controller_capture_begin.setter
    def on_controller_capture_begin(self, value: OnControllerCaptureBeginEvent) -> None:
        ...
    @property
    def on_controller_capture_end(self) -> OnControllerCaptureEndEvent:
        r"""
        (OnControllerCaptureEndEvent):  [Read-Write] Invoked when the controller capture ends.
        """
        ...
    @on_controller_capture_end.setter
    def on_controller_capture_end(self, value: OnControllerCaptureEndEvent) -> None:
        ...
    @property
    def on_value_changed(self) -> OnFloatValueChangedEvent:
        r"""
        (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
        """
        ...
    @on_value_changed.setter
    def on_value_changed(self, value: OnFloatValueChangedEvent) -> None:
        ...
    def set_value(self, value: float) -> None:
        r"""
        x.set_value(value) -> None
        Sets the current value of the slider.
        
        Args:
            value (float):
        """
        ...
    def set_step_size(self, value: float) -> None:
        r"""
        x.set_step_size(value) -> None
        Sets the amount to adjust the value by, when using a controller or keyboard
        
        Args:
            value (float):
        """
        ...
    def set_locked(self, value: bool) -> None:
        r"""
        x.set_locked(value) -> None
        Sets the handle to be interactive or fixed
        
        Args:
            value (bool):
        """
        ...
    def get_value(self) -> float:
        r"""
        x.get_value() -> float
        Gets the current value of the slider.
        
        Returns:
            float:
        """
        ...

class NiagaraAssetTagDefinitionsFactory(Factory):
    r"""
    Niagara Asset Tag Definitions Factory
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraAssetTagDefinitionsFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraDataChannelAssetFactoryNew(Factory):
    r"""
    Niagara Data Channel Asset Factory New
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraDataChannelAssetFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraHierarchyMenuContext(Object):
    r"""
    Niagara Hierarchy Menu Context
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraHierarchyViewModelBase.h
    
    """
    ...

class NiagaraScriptFactoryNew(Factory):
    r"""
    Niagara Script Factory New
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraScriptFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraModuleScriptFactory(NiagaraScriptFactoryNew):
    r"""
    Niagara module script factory.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraScriptFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraFunctionScriptFactory(NiagaraScriptFactoryNew):
    r"""
    Niagara function factory.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraScriptFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraDynamicInputScriptFactory(NiagaraScriptFactoryNew):
    r"""
    Niagara dynamic input script factory.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraScriptFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraClipboardEditorScriptingUtilities(Object):
    r"""
    Niagara Clipboard Editor Scripting Utilities
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraClipboard.h
    
    """
    @classmethod
    def try_set_local_value_as_int(cls, input: NiagaraClipboardFunctionInput, value: int, loose_typing: bool = True) -> bool:
        r"""
        X.try_set_local_value_as_int(input, value, loose_typing=True) -> bool
        Try Set Local Value as Int
        
        Args:
            input (NiagaraClipboardFunctionInput): 
            value (int32): 
            loose_typing (bool): 
        
        Returns:
            bool: 
        
            out_succeeded (bool):
        """
        ...
    @classmethod
    def try_get_local_value_as_int(cls, input: NiagaraClipboardFunctionInput) -> Tuple[bool, int]:
        r"""
        X.try_get_local_value_as_int(input) -> (out_succeeded=bool, out_value=int32)
        Try Get Local Value as Int
        
        Args:
            input (NiagaraClipboardFunctionInput): 
        
        Returns:
            tuple: 
        
            out_succeeded (bool): 
        
            out_value (int32):
        """
        ...
    @classmethod
    def try_get_local_value_as_float(cls, input: NiagaraClipboardFunctionInput) -> Tuple[bool, float]:
        r"""
        X.try_get_local_value_as_float(input) -> (out_succeeded=bool, out_value=float)
        Try Get Local Value as Float
        
        Args:
            input (NiagaraClipboardFunctionInput): 
        
        Returns:
            tuple: 
        
            out_succeeded (bool): 
        
            out_value (float):
        """
        ...
    @classmethod
    def try_get_input_by_name(cls, inputs: Array[NiagaraClipboardFunctionInput], input_name: Name) -> Tuple[bool, NiagaraClipboardFunctionInput]:
        r"""
        X.try_get_input_by_name(inputs, input_name) -> (out_succeeded=bool, out_input=NiagaraClipboardFunctionInput)
        Try Get Input by Name
        
        Args:
            inputs (Array[NiagaraClipboardFunctionInput]): 
            input_name (Name): 
        
        Returns:
            tuple: 
        
            out_succeeded (bool): 
        
            out_input (NiagaraClipboardFunctionInput):
        """
        ...
    @classmethod
    def get_type_name(cls, input: NiagaraClipboardFunctionInput) -> Name:
        r"""
        X.get_type_name(input) -> Name
        Get Type Name
        
        Args:
            input (NiagaraClipboardFunctionInput): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def create_vec3_local_value_input(cls, outer: Object, input_name: Name, has_edit_condition: bool, edit_condition_value: bool, vec3_value: Vector) -> NiagaraClipboardFunctionInput:
        r"""
        X.create_vec3_local_value_input(outer, input_name, has_edit_condition, edit_condition_value, vec3_value) -> NiagaraClipboardFunctionInput
        Create Vec 3Local Value Input
        
        Args:
            outer (Object): 
            input_name (Name): 
            has_edit_condition (bool): 
            edit_condition_value (bool): 
            vec3_value (Vector): 
        
        Returns:
            NiagaraClipboardFunctionInput:
        """
        ...
    @classmethod
    def create_vec2_local_value_input(cls, outer: Object, input_name: Name, has_edit_condition: bool, edit_condition_value: bool, vec2_value: Vector2D) -> NiagaraClipboardFunctionInput:
        r"""
        X.create_vec2_local_value_input(outer, input_name, has_edit_condition, edit_condition_value, vec2_value) -> NiagaraClipboardFunctionInput
        Create Vec 2Local Value Input
        
        Args:
            outer (Object): 
            input_name (Name): 
            has_edit_condition (bool): 
            edit_condition_value (bool): 
            vec2_value (Vector2D): 
        
        Returns:
            NiagaraClipboardFunctionInput:
        """
        ...
    @classmethod
    def create_struct_local_value_input(cls, outer: Object, input_name: Name, has_edit_condition: bool, edit_condition_value: bool, struct_value: UserDefinedStruct) -> NiagaraClipboardFunctionInput:
        r"""
        X.create_struct_local_value_input(outer, input_name, has_edit_condition, edit_condition_value, struct_value) -> NiagaraClipboardFunctionInput
        Create Struct Local Value Input
        
        Args:
            outer (Object): 
            input_name (Name): 
            has_edit_condition (bool): 
            edit_condition_value (bool): 
            struct_value (UserDefinedStruct): 
        
        Returns:
            NiagaraClipboardFunctionInput:
        """
        ...
    @classmethod
    def create_linked_value_input(cls, outer: Object, input_name: Name, input_type_name: Name, has_edit_condition: bool, edit_condition_value: bool, linked_value: Name) -> NiagaraClipboardFunctionInput:
        r"""
        X.create_linked_value_input(outer, input_name, input_type_name, has_edit_condition, edit_condition_value, linked_value) -> NiagaraClipboardFunctionInput
        Create Linked Value Input
        
        Args:
            outer (Object): 
            input_name (Name): 
            input_type_name (Name): 
            has_edit_condition (bool): 
            edit_condition_value (bool): 
            linked_value (Name): 
        
        Returns:
            NiagaraClipboardFunctionInput:
        """
        ...
    @classmethod
    def create_int_local_value_input(cls, outer: Object, input_name: Name, has_edit_condition: bool, edit_condition_value: bool, local_value: int) -> NiagaraClipboardFunctionInput:
        r"""
        X.create_int_local_value_input(outer, input_name, has_edit_condition, edit_condition_value, local_value) -> NiagaraClipboardFunctionInput
        Create Int Local Value Input
        
        Args:
            outer (Object): 
            input_name (Name): 
            has_edit_condition (bool): 
            edit_condition_value (bool): 
            local_value (int32): 
        
        Returns:
            NiagaraClipboardFunctionInput:
        """
        ...
    @classmethod
    def create_float_local_value_input(cls, outer: Object, input_name: Name, has_edit_condition: bool, edit_condition_value: bool, local_value: float) -> NiagaraClipboardFunctionInput:
        r"""
        X.create_float_local_value_input(outer, input_name, has_edit_condition, edit_condition_value, local_value) -> NiagaraClipboardFunctionInput
        Create Float Local Value Input
        
        Args:
            outer (Object): 
            input_name (Name): 
            has_edit_condition (bool): 
            edit_condition_value (bool): 
            local_value (float): 
        
        Returns:
            NiagaraClipboardFunctionInput:
        """
        ...
    @classmethod
    def create_expression_value_input(cls, outer: Object, input_name: Name, input_type_name: Name, has_edit_condition: bool, edit_condition_value: bool, expression_value: str) -> NiagaraClipboardFunctionInput:
        r"""
        X.create_expression_value_input(outer, input_name, input_type_name, has_edit_condition, edit_condition_value, expression_value) -> NiagaraClipboardFunctionInput
        Create Expression Value Input
        
        Args:
            outer (Object): 
            input_name (Name): 
            input_type_name (Name): 
            has_edit_condition (bool): 
            edit_condition_value (bool): 
            expression_value (str): 
        
        Returns:
            NiagaraClipboardFunctionInput:
        """
        ...
    @classmethod
    def create_enum_local_value_input(cls, outer: Object, input_name: Name, has_edit_condition: bool, edit_codition_value: bool, enum_type: UserDefinedEnum, enum_value: int) -> NiagaraClipboardFunctionInput:
        r"""
        X.create_enum_local_value_input(outer, input_name, has_edit_condition, edit_codition_value, enum_type, enum_value) -> NiagaraClipboardFunctionInput
        Create Enum Local Value Input
        
        Args:
            outer (Object): 
            input_name (Name): 
            has_edit_condition (bool): 
            edit_codition_value (bool): 
            enum_type (UserDefinedEnum): 
            enum_value (int32): 
        
        Returns:
            NiagaraClipboardFunctionInput:
        """
        ...
    @classmethod
    def create_dynamic_value_input(cls, outer: Object, input_name: Name, input_type_name: Name, has_edit_condition: bool, edit_condition_value: bool, dynamic_value_name: str, dynamic_value: NiagaraScript) -> NiagaraClipboardFunctionInput:
        r"""
        X.create_dynamic_value_input(outer, input_name, input_type_name, has_edit_condition, edit_condition_value, dynamic_value_name, dynamic_value) -> NiagaraClipboardFunctionInput
        Create Dynamic Value Input
        
        Args:
            outer (Object): 
            input_name (Name): 
            input_type_name (Name): 
            has_edit_condition (bool): 
            edit_condition_value (bool): 
            dynamic_value_name (str): 
            dynamic_value (NiagaraScript): 
        
        Returns:
            NiagaraClipboardFunctionInput:
        """
        ...
    @classmethod
    def create_data_value_input(cls, outer: Object, input_name: Name, has_edit_condition: bool, edit_condition_value: bool, data_value: NiagaraDataInterface) -> NiagaraClipboardFunctionInput:
        r"""
        X.create_data_value_input(outer, input_name, has_edit_condition, edit_condition_value, data_value) -> NiagaraClipboardFunctionInput
        Create Data Value Input
        
        Args:
            outer (Object): 
            input_name (Name): 
            has_edit_condition (bool): 
            edit_condition_value (bool): 
            data_value (NiagaraDataInterface): 
        
        Returns:
            NiagaraClipboardFunctionInput:
        """
        ...
    @classmethod
    def create_bool_local_value_input(cls, outer: Object, input_name: Name, has_edit_condition: bool, edit_condition_value: bool, bool_value: bool) -> NiagaraClipboardFunctionInput:
        r"""
        X.create_bool_local_value_input(outer, input_name, has_edit_condition, edit_condition_value, bool_value) -> NiagaraClipboardFunctionInput
        Create Bool Local Value Input
        
        Args:
            outer (Object): 
            input_name (Name): 
            has_edit_condition (bool): 
            edit_condition_value (bool): 
            bool_value (bool): 
        
        Returns:
            NiagaraClipboardFunctionInput:
        """
        ...

class NiagaraEffectTypeFactoryNew(Factory):
    r"""
    Niagara Effect Type Factory New
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraEffectTypeFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraEmitterFactoryNew(Factory):
    r"""
    A factory for niagara emitter assets.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraEmitterFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraParameterCollectionFactoryNew(Factory):
    r"""
    Niagara Parameter Collection Factory New
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraParameterCollectionFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraParameterCollectionInstanceFactoryNew(Factory):
    r"""
    Niagara Parameter Collection Instance Factory New
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraParameterCollectionFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraParameterDefinitionsFactory(Factory):
    r"""
    Niagara Parameter Definitions Factory
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraParameterDefinitionsFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraSimCacheFactoryNew(Factory):
    r"""
    Niagara Sim Cache Factory New
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraSimCacheFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraSystemFactoryNew(Factory):
    r"""
    Niagara System Factory New
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraSystemFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraValidationRuleSetFactoryNew(Factory):
    r"""
    Niagara Validation Rule Set Factory New
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraValidationRuleSetFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MovieSceneNiagaraEmitterSectionBase(MovieSceneSection):
    r"""
    Movie Scene Niagara Emitter Section Base
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: MovieSceneNiagaraEmitterTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneNiagaraEmitterTrack(MovieSceneNameableTrack):
    r"""
    A track representing an emitter in the niagara effect editor timeline.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: MovieSceneNiagaraEmitterTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class NiagaraSequence(MovieSceneSequence):
    r"""
    Movie scene sequence used by Niagara.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraSequence.h
    
    """
    ...

class MovieSceneNiagaraEmitterSection(MovieSceneNiagaraEmitterSectionBase):
    r"""
    Niagara editor movie scene section; represents one emitter in the timeline
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: MovieSceneNiagaraEmitterSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``num_loops`` (int32):  [Read-Write]
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``start_time_included_in_first_loop_only`` (bool):  [Read-Write]
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class NiagaraPythonScriptModuleInput(Object):
    r"""
    Wrapper for setting the value on a parameter of a UNiagaraScript, applied through a UUpgradeNiagaraScriptResults.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: UpgradeNiagaraScriptResults.h
    
    """
    def is_set(self) -> bool:
        r"""
        x.is_set() -> bool
        Is Set
        
        Returns:
            bool:
        """
        ...
    def is_local_value(self) -> bool:
        r"""
        x.is_local_value() -> bool
        Is Local Value
        
        Returns:
            bool:
        """
        ...
    def is_linked_value(self) -> bool:
        r"""
        x.is_linked_value() -> bool
        Is Linked Value
        
        Returns:
            bool:
        """
        ...
    def as_vec4(self) -> Vector4:
        r"""
        x.as_vec4() -> Vector4
        As Vec 4
        
        Returns:
            Vector4:
        """
        ...
    def as_vec3(self) -> Vector:
        r"""
        x.as_vec3() -> Vector
        As Vec 3
        
        Returns:
            Vector:
        """
        ...
    def as_vec2(self) -> Vector2D:
        r"""
        x.as_vec2() -> Vector2D
        As Vec 2
        
        Returns:
            Vector2D:
        """
        ...
    def as_quat(self) -> Quat:
        r"""
        x.as_quat() -> Quat
        As Quat
        
        Returns:
            Quat:
        """
        ...
    def as_linked_value(self) -> str:
        r"""
        x.as_linked_value() -> str
        As Linked Value
        
        Returns:
            str:
        """
        ...
    def as_int(self) -> int:
        r"""
        x.as_int() -> int32
        As Int
        
        Returns:
            int32:
        """
        ...
    def as_float(self) -> float:
        r"""
        x.as_float() -> float
        As Float
        
        Returns:
            float:
        """
        ...
    def as_enum(self) -> str:
        r"""
        x.as_enum() -> str
        As Enum
        
        Returns:
            str:
        """
        ...
    def as_color(self) -> LinearColor:
        r"""
        x.as_color() -> LinearColor
        As Color
        
        Returns:
            LinearColor:
        """
        ...
    def as_bool(self) -> bool:
        r"""
        x.as_bool() -> bool
        As Bool
        
        Returns:
            bool:
        """
        ...

class UpgradeNiagaraScriptResults(Object):
    r"""
    Wrapper class for passing results back from the version upgrade python script.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: UpgradeNiagaraScriptResults.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cancelled_by_python_error`` (bool):  [Read-Write] Whether the converter process was cancelled due to an unrecoverable error in the python script process.
    - ``new_inputs`` (Array[NiagaraPythonScriptModuleInput]):  [Read-Write]
    - ``old_inputs`` (Array[NiagaraPythonScriptModuleInput]):  [Read-Write]
    """
    @property
    def cancelled_by_python_error(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the converter process was cancelled due to an unrecoverable error in the python script process.
        """
        ...
    @cancelled_by_python_error.setter
    def cancelled_by_python_error(self, value: bool) -> None:
        ...
    @property
    def old_inputs(self) -> Array[NiagaraPythonScriptModuleInput]:
        r"""
        (Array[NiagaraPythonScriptModuleInput]):  [Read-Write]
        """
        ...
    @old_inputs.setter
    def old_inputs(self, value: Array[NiagaraPythonScriptModuleInput]) -> None:
        ...
    @property
    def new_inputs(self) -> Array[NiagaraPythonScriptModuleInput]:
        r"""
        (Array[NiagaraPythonScriptModuleInput]):  [Read-Write]
        """
        ...
    @new_inputs.setter
    def new_inputs(self, value: Array[NiagaraPythonScriptModuleInput]) -> None:
        ...
    def set_vec4_input(self, input_name: str, value: Vector4) -> None:
        r"""
        x.set_vec4_input(input_name, value) -> None
        Set Vec 4Input
        
        Args:
            input_name (str): 
            value (Vector4):
        """
        ...
    def set_vec3_input(self, input_name: str, value: Vector) -> None:
        r"""
        x.set_vec3_input(input_name, value) -> None
        Set Vec 3Input
        
        Args:
            input_name (str): 
            value (Vector):
        """
        ...
    def set_vec2_input(self, input_name: str, value: Vector2D) -> None:
        r"""
        x.set_vec2_input(input_name, value) -> None
        Set Vec 2Input
        
        Args:
            input_name (str): 
            value (Vector2D):
        """
        ...
    def set_quat_input(self, input_name: str, value: Quat) -> None:
        r"""
        x.set_quat_input(input_name, value) -> None
        Set Quat Input
        
        Args:
            input_name (str): 
            value (Quat):
        """
        ...
    def set_new_input(self, input_name: str, value: NiagaraPythonScriptModuleInput) -> None:
        r"""
        x.set_new_input(input_name, value) -> None
        Set New Input
        
        Args:
            input_name (str): 
            value (NiagaraPythonScriptModuleInput):
        """
        ...
    def set_linked_input(self, input_name: str, value: str) -> None:
        r"""
        x.set_linked_input(input_name, value) -> None
        Set Linked Input
        
        Args:
            input_name (str): 
            value (str):
        """
        ...
    def set_int_input(self, input_name: str, value: int) -> None:
        r"""
        x.set_int_input(input_name, value) -> None
        Set Int Input
        
        Args:
            input_name (str): 
            value (int32):
        """
        ...
    def set_float_input(self, input_name: str, value: float) -> None:
        r"""
        x.set_float_input(input_name, value) -> None
        Set Float Input
        
        Args:
            input_name (str): 
            value (float):
        """
        ...
    def set_enum_input(self, input_name: str, value: str) -> None:
        r"""
        x.set_enum_input(input_name, value) -> None
        Set Enum Input
        
        Args:
            input_name (str): 
            value (str):
        """
        ...
    def set_color_input(self, input_name: str, value: LinearColor) -> None:
        r"""
        x.set_color_input(input_name, value) -> None
        Set Color Input
        
        Args:
            input_name (str): 
            value (LinearColor):
        """
        ...
    def set_bool_input(self, input_name: str, value: bool) -> None:
        r"""
        x.set_bool_input(input_name, value) -> None
        Set Bool Input
        
        Args:
            input_name (str): 
            value (bool):
        """
        ...
    def reset_to_default(self, input_name: str) -> None:
        r"""
        x.reset_to_default(input_name) -> None
        Reset to Default
        
        Args:
            input_name (str):
        """
        ...
    def get_old_input(self, input_name: str) -> NiagaraPythonScriptModuleInput:
        r"""
        x.get_old_input(input_name) -> NiagaraPythonScriptModuleInput
        Get Old Input
        
        Args:
            input_name (str): 
        
        Returns:
            NiagaraPythonScriptModuleInput:
        """
        ...

class NiagaraPythonModule(Object):
    r"""
    Wrapper for a module from the emitter stack.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: UpgradeNiagaraScriptResults.h
    
    """
    def get_object(self) -> NiagaraStackModuleItem:
        r"""
        x.get_object() -> NiagaraStackModuleItem
        Returns the raw underlying object
        
        Returns:
            NiagaraStackModuleItem:
        """
        ...

class NiagaraPythonEmitter(Object):
    r"""
    Wrapper for an emitter stack.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: UpgradeNiagaraScriptResults.h
    
    """
    def set_properties(self, data: VersionedNiagaraEmitterData) -> None:
        r"""
        x.set_properties(data) -> None
        sets the new emitter properties
        
        Args:
            data (VersionedNiagaraEmitterData):
        """
        ...
    def has_module(self, module_name: str) -> bool:
        r"""
        x.has_module(module_name) -> bool
        returns true if the emitter contains a certain module
        
        Args:
            module_name (str): 
        
        Returns:
            bool:
        """
        ...
    def get_properties(self) -> VersionedNiagaraEmitterData:
        r"""
        x.get_properties() -> VersionedNiagaraEmitterData
        returns the emitter properties, such as determinism or interpolated spawning
        
        Returns:
            VersionedNiagaraEmitterData:
        """
        ...
    def get_object(self) -> NiagaraEmitter:
        r"""
        x.get_object() -> NiagaraEmitter
        Returns the raw underlying object
        
        Returns:
            NiagaraEmitter:
        """
        ...
    def get_modules(self) -> Array[NiagaraPythonModule]:
        r"""
        x.get_modules() -> Array[NiagaraPythonModule]
        returns a list of all modules contained in this emitter
        
        Returns:
            Array[NiagaraPythonModule]:
        """
        ...
    def get_module(self, module_name: str) -> NiagaraPythonModule:
        r"""
        x.get_module(module_name) -> NiagaraPythonModule
        returns a module by name
        
        Args:
            module_name (str): 
        
        Returns:
            NiagaraPythonModule:
        """
        ...

class UpgradeNiagaraEmitterContext(Object):
    r"""
    Wrapper class for passing results back from the version upgrade python script.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: UpgradeNiagaraScriptResults.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cancelled_by_python_error`` (bool):  [Read-Write] Whether the converter process was cancelled due to an unrecoverable error in the python script process.
    - ``new_emitter`` (NiagaraPythonEmitter):  [Read-Write]
    - ``old_emitter`` (NiagaraPythonEmitter):  [Read-Write]
    """
    @property
    def cancelled_by_python_error(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether the converter process was cancelled due to an unrecoverable error in the python script process.
        """
        ...
    @cancelled_by_python_error.setter
    def cancelled_by_python_error(self, value: bool) -> None:
        ...
    @property
    def old_emitter(self) -> NiagaraPythonEmitter:
        r"""
        (NiagaraPythonEmitter):  [Read-Write]
        """
        ...
    @old_emitter.setter
    def old_emitter(self, value: NiagaraPythonEmitter) -> None:
        ...
    @property
    def new_emitter(self) -> NiagaraPythonEmitter:
        r"""
        (NiagaraPythonEmitter):  [Read-Write]
        """
        ...
    @new_emitter.setter
    def new_emitter(self, value: NiagaraPythonEmitter) -> None:
        ...

class VolumeCacheFactory(Factory):
    r"""
    Volume Cache Factory
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: VolumeCacheFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class NiagaraClipboardFunctionInput(Object):
    r"""
    Niagara Clipboard Function Input
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraClipboard.h
    
    """
    ...

class UserDefinedStruct(ScriptStruct):
    r"""
    User Defined Struct
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: UserDefinedStruct.h
    
    """
    ...

class UserDefinedEnum(Enum):
    r"""
    An Enumeration is a list of named values.
    
    **C++ Source:**
    
    - **Module**: Engine
    - **File**: UserDefinedEnum.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enum_description`` (Text):  [Read-Write] Shows up in the content browser when the enum asset is hovered
    """
    ...

class NiagaraScriptBase(Object):
    r"""
    Niagara Script Base
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraShader
    - **File**: NiagaraScriptBase.h
    
    """
    ...

class NiagaraScript(NiagaraScriptBase):
    r"""
    Runtime script for a Niagara system
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraScript.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``category`` (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'Category' is deprecated.
    - ``collapsed_view_format`` (Text):  [Read-Write] Deprecated, use LibraryVisibility instead.
      deprecated: Property 'CollapsedViewFormat' is deprecated.
    - ``conversion_utility`` (type(Class)):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'ConversionUtility' is deprecated.
    - ``deprecated`` (bool):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'bDeprecated' is deprecated.
    - ``deprecation_message`` (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'DeprecationMessage' is deprecated.
    - ``deprecation_recommendation`` (NiagaraScript):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'DeprecationRecommendation' is deprecated.
    - ``description`` (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'Description' is deprecated.
    - ``experimental`` (bool):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'bExperimental' is deprecated.
    - ``experimental_message`` (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'ExperimentalMessage' is deprecated.
    - ``expose_to_library`` (bool):  [Read-Write] Deprecated, use LibraryVisibility instead.
      deprecated: Property 'bExposeToLibrary' is deprecated.
    - ``keywords`` (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'Keywords' is deprecated.
    - ``library_visibility`` (NiagaraScriptLibraryVisibility):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'LibraryVisibility' is deprecated.
    - ``module_usage_bitmask`` (int32):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'ModuleUsageBitmask' is deprecated.
    - ``note_message`` (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'NoteMessage' is deprecated.
    - ``numeric_output_type_selection_mode`` (NiagaraNumericOutputTypeSelectionMode):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'NumericOutputTypeSelectionMode' is deprecated.
    - ``provided_dependencies`` (Array[Name]):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'ProvidedDependencies' is deprecated.
    - ``required_dependencies`` (Array[NiagaraModuleDependency]):  [Read-Write] Use property in struct returned from GetScriptData() instead
      deprecated: Property 'RequiredDependencies' is deprecated.
    - ``script_meta_data`` (Map[Name, str]):  [Read-Write] Deprecated, use LibraryVisibility instead.
      deprecated: Property 'ScriptMetaData' is deprecated.
    - ``source`` (NiagaraScriptSourceBase):  [Read-Write] 'Source' data/graphs for this script
      deprecated: Property 'Source' is deprecated.
    - ``validation_rules`` (Array[NiagaraValidationRule]):  [Read-Write] A set of rules to apply when this script is used in the stack. To create your own rules, write a custom class that extends UNiagaraValidationRule.
    """
    @property
    def module_usage_bitmask(self) -> int:
        r"""
        (int32):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'ModuleUsageBitmask' is deprecated.
        """
        ...
    @module_usage_bitmask.setter
    def module_usage_bitmask(self, value: int) -> None:
        ...
    @property
    def category(self) -> Text:
        r"""
        (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'Category' is deprecated.
        """
        ...
    @category.setter
    def category(self, value: Text) -> None:
        ...
    @property
    def provided_dependencies(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'ProvidedDependencies' is deprecated.
        """
        ...
    @provided_dependencies.setter
    def provided_dependencies(self, value: Array[Name]) -> None:
        ...
    @property
    def required_dependencies(self) -> Array[NiagaraModuleDependency]:
        r"""
        (Array[NiagaraModuleDependency]):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'RequiredDependencies' is deprecated.
        """
        ...
    @required_dependencies.setter
    def required_dependencies(self, value: Array[NiagaraModuleDependency]) -> None:
        ...
    @property
    def deprecated(self) -> bool:
        r"""
        (bool):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'bDeprecated' is deprecated.
        """
        ...
    @deprecated.setter
    def deprecated(self, value: bool) -> None:
        ...
    @property
    def deprecation_message(self) -> Text:
        r"""
        (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'DeprecationMessage' is deprecated.
        """
        ...
    @deprecation_message.setter
    def deprecation_message(self, value: Text) -> None:
        ...
    @property
    def deprecation_recommendation(self) -> NiagaraScript:
        r"""
        (NiagaraScript):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'DeprecationRecommendation' is deprecated.
        """
        ...
    @deprecation_recommendation.setter
    def deprecation_recommendation(self, value: NiagaraScript) -> None:
        ...
    @property
    def conversion_utility(self) -> Class:
        r"""
        (type(Class)):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'ConversionUtility' is deprecated.
        """
        ...
    @conversion_utility.setter
    def conversion_utility(self, value: Class) -> None:
        ...
    @property
    def experimental(self) -> bool:
        r"""
        (bool):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'bExperimental' is deprecated.
        """
        ...
    @experimental.setter
    def experimental(self, value: bool) -> None:
        ...
    @property
    def experimental_message(self) -> Text:
        r"""
        (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'ExperimentalMessage' is deprecated.
        """
        ...
    @experimental_message.setter
    def experimental_message(self, value: Text) -> None:
        ...
    @property
    def note_message(self) -> Text:
        r"""
        (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'NoteMessage' is deprecated.
        """
        ...
    @note_message.setter
    def note_message(self, value: Text) -> None:
        ...
    @property
    def expose_to_library(self) -> bool:
        r"""
        (bool):  [Read-Write] Deprecated, use LibraryVisibility instead.
        deprecated: Property 'bExposeToLibrary' is deprecated.
        """
        ...
    @expose_to_library.setter
    def expose_to_library(self, value: bool) -> None:
        ...
    @property
    def library_visibility(self) -> NiagaraScriptLibraryVisibility:
        r"""
        (NiagaraScriptLibraryVisibility):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'LibraryVisibility' is deprecated.
        """
        ...
    @library_visibility.setter
    def library_visibility(self, value: NiagaraScriptLibraryVisibility) -> None:
        ...
    @property
    def numeric_output_type_selection_mode(self) -> NiagaraNumericOutputTypeSelectionMode:
        r"""
        (NiagaraNumericOutputTypeSelectionMode):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'NumericOutputTypeSelectionMode' is deprecated.
        """
        ...
    @numeric_output_type_selection_mode.setter
    def numeric_output_type_selection_mode(self, value: NiagaraNumericOutputTypeSelectionMode) -> None:
        ...
    @property
    def description(self) -> Text:
        r"""
        (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'Description' is deprecated.
        """
        ...
    @description.setter
    def description(self, value: Text) -> None:
        ...
    @property
    def keywords(self) -> Text:
        r"""
        (Text):  [Read-Write] Use property in struct returned from GetScriptData() instead
        deprecated: Property 'Keywords' is deprecated.
        """
        ...
    @keywords.setter
    def keywords(self, value: Text) -> None:
        ...
    @property
    def collapsed_view_format(self) -> Text:
        r"""
        (Text):  [Read-Write] Deprecated, use LibraryVisibility instead.
        deprecated: Property 'CollapsedViewFormat' is deprecated.
        """
        ...
    @collapsed_view_format.setter
    def collapsed_view_format(self, value: Text) -> None:
        ...
    @property
    def script_meta_data(self) -> Map[Name, str]:
        r"""
        (Map[Name, str]):  [Read-Write] Deprecated, use LibraryVisibility instead.
        deprecated: Property 'ScriptMetaData' is deprecated.
        """
        ...
    @script_meta_data.setter
    def script_meta_data(self, value: Map[Name, str]) -> None:
        ...
    @property
    def source(self) -> NiagaraScriptSourceBase:
        r"""
        (NiagaraScriptSourceBase):  [Read-Write] 'Source' data/graphs for this script
        deprecated: Property 'Source' is deprecated.
        """
        ...
    @source.setter
    def source(self, value: NiagaraScriptSourceBase) -> None:
        ...

class NiagaraMergeable(Object):
    r"""
    Niagara Mergeable
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraCore
    - **File**: NiagaraMergeable.h
    
    """
    ...

class NiagaraDataInterfaceBase(NiagaraMergeable):
    r"""
    Base class for all Niagara data interfaces.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraCore
    - **File**: NiagaraDataInterfaceBase.h
    
    """
    ...

class NiagaraDataInterface(NiagaraDataInterfaceBase):
    r"""
    Base class for all Niagara data interfaces.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterface.h
    
    """
    ...

class NiagaraStackEntry(Object):
    r"""
    Niagara Stack Entry
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraStackEntry.h
    
    """
    ...

class NiagaraStackItem(NiagaraStackEntry):
    r"""
    Niagara Stack Item
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraStackItem.h
    
    """
    ...

class NiagaraStackModuleItem(NiagaraStackItem):
    r"""
    Niagara Stack Module Item
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraStackModuleItem.h
    
    """
    ...

class NiagaraEmitter(Object):
    r"""
    Niagara Emitters are particle spawners that can be reused for different effects by putting them into Niagara Systems.
    Emitters render their particles using different renderers, such as Sprite Renderers or Mesh Renderers to produce different effects.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEmitter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allocation_mode`` (ParticleAllocationMode):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'AllocationMode' is deprecated.
    - ``attributes_to_preserve`` (Array[str]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'AttributesToPreserve' is deprecated.
    - ``determinism`` (bool):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'bDeterminism' is deprecated.
    - ``editor_data`` (NiagaraEditorDataBase):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'EditorData' is deprecated.
    - ``editor_parameters`` (NiagaraEditorParametersAdapterBase):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'EditorParameters' is deprecated.
    - ``emitter_spawn_script_props`` (NiagaraEmitterScriptProperties):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'EmitterSpawnScriptProps' is deprecated.
    - ``emitter_update_script_props`` (NiagaraEmitterScriptProperties):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'EmitterUpdateScriptProps' is deprecated.
    - ``event_handler_script_props`` (Array[NiagaraEventScriptProperties]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'EventHandlerScriptProps' is deprecated.
    - ``gpu_compute_script`` (NiagaraScript):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'GPUComputeScript' is deprecated.
    - ``graph_source`` (NiagaraScriptSourceBase):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'GraphSource' is deprecated.
    - ``interpolated_spawning`` (bool):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'bInterpolatedSpawning' is deprecated.
    - ``is_inheritable`` (bool):  [Read-Write] If an emitter is inheritable, new emitters based on an inheritable emitter, or Niagara Systems using an inheritable emitter, will automatically inherit changes made to the original emitter.
    - ``local_space`` (bool):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'bLocalSpace' is deprecated.
    - ``max_gpu_particles_spawn_per_frame`` (uint32):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'MaxGPUParticlesSpawnPerFrame' is deprecated.
    - ``parent`` (NiagaraEmitter):  [Read-Write]
      deprecated: Property 'Parent' is deprecated.
    - ``parent_at_last_merge`` (NiagaraEmitter):  [Read-Write]
      deprecated: Property 'ParentAtLastMerge' is deprecated.
    - ``parent_scratch_pad_scripts`` (Array[NiagaraScript]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'ParentScratchPadScripts' is deprecated.
    - ``platforms`` (NiagaraPlatformSet):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'Platforms' is deprecated.
    - ``pre_allocation_count`` (int32):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'PreAllocationCount' is deprecated.
    - ``random_seed`` (int32):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'RandomSeed' is deprecated.
    - ``renderer_bindings`` (NiagaraParameterStore):  [Read-Write]
      deprecated: Property 'RendererBindings' is deprecated.
    - ``renderer_properties`` (Array[NiagaraRendererProperties]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'RendererProperties' is deprecated.
    - ``requires_persistent_i_ds`` (bool):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'bRequiresPersistentIDs' is deprecated.
    - ``scalability_overrides`` (NiagaraEmitterScalabilityOverrides):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'ScalabilityOverrides' is deprecated.
    - ``scratch_pad_scripts`` (Array[NiagaraScript]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'ScratchPadScripts' is deprecated.
    - ``shared_event_generator_ids`` (Array[Name]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'SharedEventGeneratorIds' is deprecated.
    - ``sim_target`` (NiagaraSimTarget):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'SimTarget' is deprecated.
    - ``simulation_stages`` (Array[NiagaraSimulationStageBase]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'SimulationStages' is deprecated.
    - ``spawn_script_props`` (NiagaraEmitterScriptProperties):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'SpawnScriptProps' is deprecated.
    - ``template_asset_description`` (Text):  [Read-Write]
    - ``template_specification`` (NiagaraScriptTemplateSpecification):  [Read-Write]
      deprecated: Property 'TemplateSpecification' is deprecated.
    - ``update_script_props`` (NiagaraEmitterScriptProperties):  [Read-Write] Use property in struct returned from GetEmitterData() instead
      deprecated: Property 'UpdateScriptProps' is deprecated.
    """
    @property
    def local_space(self) -> bool:
        r"""
        (bool):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'bLocalSpace' is deprecated.
        """
        ...
    @local_space.setter
    def local_space(self, value: bool) -> None:
        ...
    @property
    def determinism(self) -> bool:
        r"""
        (bool):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'bDeterminism' is deprecated.
        """
        ...
    @determinism.setter
    def determinism(self, value: bool) -> None:
        ...
    @property
    def random_seed(self) -> int:
        r"""
        (int32):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'RandomSeed' is deprecated.
        """
        ...
    @random_seed.setter
    def random_seed(self, value: int) -> None:
        ...
    @property
    def allocation_mode(self) -> ParticleAllocationMode:
        r"""
        (ParticleAllocationMode):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'AllocationMode' is deprecated.
        """
        ...
    @allocation_mode.setter
    def allocation_mode(self, value: ParticleAllocationMode) -> None:
        ...
    @property
    def pre_allocation_count(self) -> int:
        r"""
        (int32):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'PreAllocationCount' is deprecated.
        """
        ...
    @pre_allocation_count.setter
    def pre_allocation_count(self, value: int) -> None:
        ...
    @property
    def update_script_props(self) -> NiagaraEmitterScriptProperties:
        r"""
        (NiagaraEmitterScriptProperties):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'UpdateScriptProps' is deprecated.
        """
        ...
    @update_script_props.setter
    def update_script_props(self, value: NiagaraEmitterScriptProperties) -> None:
        ...
    @property
    def spawn_script_props(self) -> NiagaraEmitterScriptProperties:
        r"""
        (NiagaraEmitterScriptProperties):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'SpawnScriptProps' is deprecated.
        """
        ...
    @spawn_script_props.setter
    def spawn_script_props(self, value: NiagaraEmitterScriptProperties) -> None:
        ...
    @property
    def template_specification(self) -> NiagaraScriptTemplateSpecification:
        r"""
        (NiagaraScriptTemplateSpecification):  [Read-Write]
        deprecated: Property 'TemplateSpecification' is deprecated.
        """
        ...
    @template_specification.setter
    def template_specification(self, value: NiagaraScriptTemplateSpecification) -> None:
        ...
    @property
    def emitter_spawn_script_props(self) -> NiagaraEmitterScriptProperties:
        r"""
        (NiagaraEmitterScriptProperties):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'EmitterSpawnScriptProps' is deprecated.
        """
        ...
    @emitter_spawn_script_props.setter
    def emitter_spawn_script_props(self, value: NiagaraEmitterScriptProperties) -> None:
        ...
    @property
    def emitter_update_script_props(self) -> NiagaraEmitterScriptProperties:
        r"""
        (NiagaraEmitterScriptProperties):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'EmitterUpdateScriptProps' is deprecated.
        """
        ...
    @emitter_update_script_props.setter
    def emitter_update_script_props(self, value: NiagaraEmitterScriptProperties) -> None:
        ...
    @property
    def attributes_to_preserve(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'AttributesToPreserve' is deprecated.
        """
        ...
    @attributes_to_preserve.setter
    def attributes_to_preserve(self, value: Array[str]) -> None:
        ...
    @property
    def parent_scratch_pad_scripts(self) -> Array[NiagaraScript]:
        r"""
        (Array[NiagaraScript]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'ParentScratchPadScripts' is deprecated.
        """
        ...
    @parent_scratch_pad_scripts.setter
    def parent_scratch_pad_scripts(self, value: Array[NiagaraScript]) -> None:
        ...
    @property
    def sim_target(self) -> NiagaraSimTarget:
        r"""
        (NiagaraSimTarget):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'SimTarget' is deprecated.
        """
        ...
    @sim_target.setter
    def sim_target(self, value: NiagaraSimTarget) -> None:
        ...
    @property
    def platforms(self) -> NiagaraPlatformSet:
        r"""
        (NiagaraPlatformSet):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'Platforms' is deprecated.
        """
        ...
    @platforms.setter
    def platforms(self, value: NiagaraPlatformSet) -> None:
        ...
    @property
    def scalability_overrides(self) -> NiagaraEmitterScalabilityOverrides:
        r"""
        (NiagaraEmitterScalabilityOverrides):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'ScalabilityOverrides' is deprecated.
        """
        ...
    @scalability_overrides.setter
    def scalability_overrides(self, value: NiagaraEmitterScalabilityOverrides) -> None:
        ...
    @property
    def interpolated_spawning(self) -> bool:
        r"""
        (bool):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'bInterpolatedSpawning' is deprecated.
        """
        ...
    @interpolated_spawning.setter
    def interpolated_spawning(self, value: bool) -> None:
        ...
    @property
    def renderer_bindings(self) -> NiagaraParameterStore:
        r"""
        (NiagaraParameterStore):  [Read-Write]
        deprecated: Property 'RendererBindings' is deprecated.
        """
        ...
    @renderer_bindings.setter
    def renderer_bindings(self, value: NiagaraParameterStore) -> None:
        ...
    @property
    def requires_persistent_i_ds(self) -> bool:
        r"""
        (bool):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'bRequiresPersistentIDs' is deprecated.
        """
        ...
    @requires_persistent_i_ds.setter
    def requires_persistent_i_ds(self, value: bool) -> None:
        ...
    @property
    def max_gpu_particles_spawn_per_frame(self) -> int:
        r"""
        (uint32):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'MaxGPUParticlesSpawnPerFrame' is deprecated.
        """
        ...
    @max_gpu_particles_spawn_per_frame.setter
    def max_gpu_particles_spawn_per_frame(self, value: int) -> None:
        ...
    @property
    def graph_source(self) -> NiagaraScriptSourceBase:
        r"""
        (NiagaraScriptSourceBase):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'GraphSource' is deprecated.
        """
        ...
    @graph_source.setter
    def graph_source(self, value: NiagaraScriptSourceBase) -> None:
        ...
    @property
    def scratch_pad_scripts(self) -> Array[NiagaraScript]:
        r"""
        (Array[NiagaraScript]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'ScratchPadScripts' is deprecated.
        """
        ...
    @scratch_pad_scripts.setter
    def scratch_pad_scripts(self, value: Array[NiagaraScript]) -> None:
        ...
    @property
    def editor_data(self) -> NiagaraEditorDataBase:
        r"""
        (NiagaraEditorDataBase):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'EditorData' is deprecated.
        """
        ...
    @editor_data.setter
    def editor_data(self, value: NiagaraEditorDataBase) -> None:
        ...
    @property
    def editor_parameters(self) -> NiagaraEditorParametersAdapterBase:
        r"""
        (NiagaraEditorParametersAdapterBase):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'EditorParameters' is deprecated.
        """
        ...
    @editor_parameters.setter
    def editor_parameters(self, value: NiagaraEditorParametersAdapterBase) -> None:
        ...
    @property
    def renderer_properties(self) -> Array[NiagaraRendererProperties]:
        r"""
        (Array[NiagaraRendererProperties]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'RendererProperties' is deprecated.
        """
        ...
    @renderer_properties.setter
    def renderer_properties(self, value: Array[NiagaraRendererProperties]) -> None:
        ...
    @property
    def event_handler_script_props(self) -> Array[NiagaraEventScriptProperties]:
        r"""
        (Array[NiagaraEventScriptProperties]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'EventHandlerScriptProps' is deprecated.
        """
        ...
    @event_handler_script_props.setter
    def event_handler_script_props(self, value: Array[NiagaraEventScriptProperties]) -> None:
        ...
    @property
    def simulation_stages(self) -> Array[NiagaraSimulationStageBase]:
        r"""
        (Array[NiagaraSimulationStageBase]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'SimulationStages' is deprecated.
        """
        ...
    @simulation_stages.setter
    def simulation_stages(self, value: Array[NiagaraSimulationStageBase]) -> None:
        ...
    @property
    def gpu_compute_script(self) -> NiagaraScript:
        r"""
        (NiagaraScript):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'GPUComputeScript' is deprecated.
        """
        ...
    @gpu_compute_script.setter
    def gpu_compute_script(self, value: NiagaraScript) -> None:
        ...
    @property
    def shared_event_generator_ids(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Use property in struct returned from GetEmitterData() instead
        deprecated: Property 'SharedEventGeneratorIds' is deprecated.
        """
        ...
    @shared_event_generator_ids.setter
    def shared_event_generator_ids(self, value: Array[Name]) -> None:
        ...
    @property
    def parent(self) -> NiagaraEmitter:
        r"""
        (NiagaraEmitter):  [Read-Write]
        deprecated: Property 'Parent' is deprecated.
        """
        ...
    @parent.setter
    def parent(self, value: NiagaraEmitter) -> None:
        ...
    @property
    def parent_at_last_merge(self) -> NiagaraEmitter:
        r"""
        (NiagaraEmitter):  [Read-Write]
        deprecated: Property 'ParentAtLastMerge' is deprecated.
        """
        ...
    @parent_at_last_merge.setter
    def parent_at_last_merge(self, value: NiagaraEmitter) -> None:
        ...

class NiagaraEmitterProperties(NiagaraEmitter):
    r"""
    deprecated: 'NiagaraEmitterProperties' was renamed to 'NiagaraEmitter'.
    """
    ...

class NiagaraNode(EdGraphNode):
    r"""
    Niagara Node
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraNode.h
    
    """
    ...

class NiagaraNodeWithDynamicPins(NiagaraNode):
    r"""
    A base node for niagara nodes with pins which can be dynamically added and removed by the user.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraNodeWithDynamicPins.h
    
    """
    ...

class NiagaraNodeFunctionCall(NiagaraNodeWithDynamicPins):
    r"""
    Niagara Node Function Call
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraEditor
    - **File**: NiagaraNodeFunctionCall.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``function_script`` (NiagaraScript):  [Read-Write]
    - ``function_specifiers`` (Map[Name, Name]):  [Read-Only]
    - ``inherit_debug_status`` (bool):  [Read-Write] Controls whether the debug state of the current function gets propagated into this function call.
    - ``selected_script_version`` (Guid):  [Read-Only]
    """
    ...

class NiagaraValidationRule(Object):
    r"""
    Base class for system validation logic.
    These allow Niagara systems to be inspected for content validation either at save time or from a commandlet.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraValidationRule.h
    
    """
    ...

class NiagaraScriptSourceBase(Object):
    r"""
    Runtime data for a Niagara system
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraScriptSourceBase.h
    
    """
    ...

class NiagaraEditorDataBase(Object):
    r"""
    A base class for editor only data which supports post loading from the runtime owner object.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEditorDataBase.h
    
    """
    ...

class NiagaraEditorParametersAdapterBase(Object):
    r"""
    A base class for editor only data which owns UNiagaraScriptVariables and supports synchronizing them with definitions.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEditorDataBase.h
    
    """
    ...

class NiagaraRendererProperties(NiagaraMergeable):
    r"""
    Emitter properties base class
    Each EmitterRenderer derives from this with its own class, and returns it in GetProperties; a copy
    of those specific properties is stored on UNiagaraEmitter (on the System) for serialization
    and handed back to the System renderer on load.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraRendererProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_in_cull_proxies`` (bool):  [Read-Write]
    - ``motion_vector_setting`` (NiagaraRendererMotionVectorSetting):  [Read-Write] Hint about how to generate motion (velocity) vectors for this renderer.
    - ``platforms`` (NiagaraPlatformSet):  [Read-Write] Platforms on which this renderer is enabled.
    - ``renderer_enabled_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Binding to control if the renderer is enabled or disabled.
      When disabled the renderer does not generate or render any particle data.
      When disabled via a static bool the renderer will be removed in cooked content.
    - ``sort_order_hint`` (int32):  [Read-Write] By default, emitters are drawn in the order that they are added to the system. This value will allow you to control the order in a more fine-grained manner.
            Materials of the same type (i.e. Transparent) will draw in order from lowest to highest within the system. The default value is 0.
    """
    ...

class NiagaraEffectRendererProperties(NiagaraRendererProperties):
    r"""
    deprecated: 'NiagaraEffectRendererProperties' was renamed to 'NiagaraRendererProperties'.
    """
    ...

class NiagaraSimulationStageBase(NiagaraMergeable):
    r"""
    A base class for niagara simulation stages.  This class should be derived to add stage specific information.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSimulationStageBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``simulation_stage_name`` (Name):  [Read-Write]
    """
    ...

class NiagaraDataChannelReader(Object):
    r"""
    Initial simple API for reading and writing data in a data channel from game code / BP.
    Likely to be replaced in the near future with a custom BP node and a helper struct.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataChannelAccessor.h
    
    """
    def read_vector4(self, var_name: Name, index: int) -> Tuple[Vector4, bool]:
        r"""
        x.read_vector4(var_name, index) -> (Vector4, is_valid=bool)
        Read Vector 4
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    def read_vector2d(self, var_name: Name, index: int) -> Tuple[Vector2D, bool]:
        r"""
        x.read_vector2d(var_name, index) -> (Vector2D, is_valid=bool)
        Read Vector 2D
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    def read_vector(self, var_name: Name, index: int) -> Tuple[Vector, bool]:
        r"""
        x.read_vector(var_name, index) -> (Vector, is_valid=bool)
        Read Vector
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    def read_spawn_info(self, var_name: Name, index: int) -> Tuple[NiagaraSpawnInfo, bool]:
        r"""
        x.read_spawn_info(var_name, index) -> (NiagaraSpawnInfo, is_valid=bool)
        Read Spawn Info
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    def read_quat(self, var_name: Name, index: int) -> Tuple[Quat, bool]:
        r"""
        x.read_quat(var_name, index) -> (Quat, is_valid=bool)
        Read Quat
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    def read_position(self, var_name: Name, index: int) -> Tuple[Vector, bool]:
        r"""
        x.read_position(var_name, index) -> (Vector, is_valid=bool)
        Read Position
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    def read_linear_color(self, var_name: Name, index: int) -> Tuple[LinearColor, bool]:
        r"""
        x.read_linear_color(var_name, index) -> (LinearColor, is_valid=bool)
        Read Linear Color
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    def read_int(self, var_name: Name, index: int) -> Tuple[int, bool]:
        r"""
        x.read_int(var_name, index) -> (int32, is_valid=bool)
        Read Int
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    def read_id(self, var_name: Name, index: int) -> Tuple[NiagaraID, bool]:
        r"""
        x.read_id(var_name, index) -> (NiagaraID, is_valid=bool)
        Read ID
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    def read_float(self, var_name: Name, index: int) -> Tuple[float, bool]:
        r"""
        x.read_float(var_name, index) -> (double, is_valid=bool)
        Read Float
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    def read_enum(self, var_name: Name, index: int) -> Tuple[int, bool]:
        r"""
        x.read_enum(var_name, index) -> (uint8, is_valid=bool)
        Read Enum
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool: 
        
            is_valid (bool):
        """
        ...
    def read_bool(self, var_name: Name, index: int) -> Optional[bool]:
        r"""
        x.read_bool(var_name, index) -> bool or None
        Read Bool
        
        Args:
            var_name (Name): 
            index (int32): 
        
        Returns:
            bool or None: 
        
            is_valid (bool):
        """
        ...
    def num(self) -> int:
        r"""
        x.num() -> int32
        Num
        
        Returns:
            int32:
        """
        ...
    def init_access(self, search_params: NiagaraDataChannelSearchParameters, read_prev_frame_data: bool) -> bool:
        r"""
        x.init_access(search_params, read_prev_frame_data) -> bool
        Call before each access to the data channel to grab the correct data to read.
        
        Args:
            search_params (NiagaraDataChannelSearchParameters): 
            read_prev_frame_data (bool): 
        
        Returns:
            bool:
        """
        ...

class NiagaraDataChannelWriter(Object):
    r"""
    Niagara Data Channel Writer
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataChannelAccessor.h
    
    """
    def write_vector4(self, var_name: Name, index: int, data: Vector4) -> None:
        r"""
        x.write_vector4(var_name, index, data) -> None
        Write Vector 4
        
        Args:
            var_name (Name): 
            index (int32): 
            data (Vector4):
        """
        ...
    def write_vector2d(self, var_name: Name, index: int, data: Vector2D) -> None:
        r"""
        x.write_vector2d(var_name, index, data) -> None
        Write Vector 2D
        
        Args:
            var_name (Name): 
            index (int32): 
            data (Vector2D):
        """
        ...
    def write_vector(self, var_name: Name, index: int, data: Vector) -> None:
        r"""
        x.write_vector(var_name, index, data) -> None
        Write Vector
        
        Args:
            var_name (Name): 
            index (int32): 
            data (Vector):
        """
        ...
    def write_spawn_info(self, var_name: Name, index: int, data: NiagaraSpawnInfo) -> None:
        r"""
        x.write_spawn_info(var_name, index, data) -> None
        Write Spawn Info
        
        Args:
            var_name (Name): 
            index (int32): 
            data (NiagaraSpawnInfo):
        """
        ...
    def write_quat(self, var_name: Name, index: int, data: Quat) -> None:
        r"""
        x.write_quat(var_name, index, data) -> None
        Write Quat
        
        Args:
            var_name (Name): 
            index (int32): 
            data (Quat):
        """
        ...
    def write_position(self, var_name: Name, index: int, data: Vector) -> None:
        r"""
        x.write_position(var_name, index, data) -> None
        Write Position
        
        Args:
            var_name (Name): 
            index (int32): 
            data (Vector):
        """
        ...
    def write_linear_color(self, var_name: Name, index: int, data: LinearColor) -> None:
        r"""
        x.write_linear_color(var_name, index, data) -> None
        Write Linear Color
        
        Args:
            var_name (Name): 
            index (int32): 
            data (LinearColor):
        """
        ...
    def write_int(self, var_name: Name, index: int, data: int) -> None:
        r"""
        x.write_int(var_name, index, data) -> None
        Write Int
        
        Args:
            var_name (Name): 
            index (int32): 
            data (int32):
        """
        ...
    def write_id(self, var_name: Name, index: int, data: NiagaraID) -> None:
        r"""
        x.write_id(var_name, index, data) -> None
        Write ID
        
        Args:
            var_name (Name): 
            index (int32): 
            data (NiagaraID):
        """
        ...
    def write_float(self, var_name: Name, index: int, data: float) -> None:
        r"""
        x.write_float(var_name, index, data) -> None
        Write Float
        
        Args:
            var_name (Name): 
            index (int32): 
            data (double):
        """
        ...
    def write_enum(self, var_name: Name, index: int, data: int) -> None:
        r"""
        x.write_enum(var_name, index, data) -> None
        Write Enum
        
        Args:
            var_name (Name): 
            index (int32): 
            data (uint8):
        """
        ...
    def write_bool(self, var_name: Name, index: int, data: bool) -> None:
        r"""
        x.write_bool(var_name, index, data) -> None
        Write Bool
        
        Args:
            var_name (Name): 
            index (int32): 
            data (bool):
        """
        ...
    def num(self) -> int:
        r"""
        x.num() -> int32
        Num
        
        Returns:
            int32:
        """
        ...
    def init_write(self, search_params: NiagaraDataChannelSearchParameters, count: int, visible_to_game: bool = True, visible_to_cpu: bool = True, visible_to_gpu: bool = True, debug_source: str = ...) -> bool:
        r"""
        x.init_write(search_params, count, visible_to_game=True, visible_to_cpu=True, visible_to_gpu=True, debug_source) -> bool
        Call before each batch of writes to allocate the data we'll be writing to.
        
        Args:
            search_params (NiagaraDataChannelSearchParameters): 
            count (int32): 
            visible_to_game (bool): 
            visible_to_cpu (bool): 
            visible_to_gpu (bool): 
            debug_source (str): 
        
        Returns:
            bool:
        """
        ...

class NiagaraDataChannelHandler(Object):
    r"""
    Niagara Data Channel Handler
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataChannelHandler.h
    
    """
    def get_data_channel_writer(self) -> NiagaraDataChannelWriter:
        r"""
        x.get_data_channel_writer() -> NiagaraDataChannelWriter
        Get Data Channel Writer
        
        Returns:
            NiagaraDataChannelWriter:
        """
        ...
    def get_data_channel_reader(self) -> NiagaraDataChannelReader:
        r"""
        x.get_data_channel_reader() -> NiagaraDataChannelReader
        Get Data Channel Reader
        
        Returns:
            NiagaraDataChannelReader:
        """
        ...

class NiagaraDataChannelAsset(Object):
    r"""
    Niagara Data Channels are a system for communication between Niagara Systems and with game code/Blueprint.
    
    Data channel assets define the payload as well as some transfer settings.
    Niagara Systems can read from and write to data channels via data interfaces.
    Blueprint and C++ code can also read from and write to data channels using its API functions.
    
    EXPERIMENTAL:
    Data Channels are currently experimental and undergoing heavy development.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataChannelPublic.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data_channel`` (NiagaraDataChannel):  [Read-Write]
    """
    ...

class NiagaraDataChannelHandler_Global(NiagaraDataChannelHandler):
    r"""
    Basic DataChannel handler that makes all data visible globally.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataChannel_Global.h
    
    """
    ...

class NiagaraDataChannelHandler_Islands(NiagaraDataChannelHandler):
    r"""
    Niagara Data Channel Handler Islands
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataChannel_Islands.h
    
    """
    ...

class NiagaraSettings(DeveloperSettings):
    r"""
    Niagara Settings
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accurate_quat_interpolation`` (bool):  [Read-Write] If set to true, quaternion attributes will be interpolated via slerp instead of lerp in interpolated spawn scripts.
    - ``additional_parameter_enums`` (Array[SoftObjectPath]):  [Read-Write]
    - ``additional_parameter_types`` (Array[SoftObjectPath]):  [Read-Write]
    - ``additional_payload_types`` (Array[SoftObjectPath]):  [Read-Write]
    - ``allow_create_actor_from_system_with_no_effect_type`` (bool):  [Read-Write] Should we allow placing a Niagara System in the editor into a level which has no effect type assigned?
    - ``byte_code_strip_option`` (NiagaraStripScriptByteCodeOption):  [Read-Write] Controls how byte code will be stripped when loading assets that have multiple sets of bytecode (i.e. optimized).
    - ``compilation_mode`` (NiagaraCompilationMode):  [Read-Write]
    - ``component_renderer_warnings_per_class`` (Map[str, Text]):  [Read-Write] Info texts that the component renderer shows the user depending on the selected component class.
    - ``default_effect_type`` (SoftObjectPath):  [Read-Write] Default effect type to use for effects that don't define their own. Can be null.
    - ``default_gpu_translucent_latency`` (NiagaraDefaultGpuTranslucentLatency):  [Read-Write] The default setting for Gpu simulation translucent draw latency.
    - ``default_grid_format`` (NiagaraGpuBufferFormat):  [Read-Write] The default buffer format used by all Niagara Grid Data Interfaces unless overridden.
    - ``default_light_inverse_exposure_blend`` (float):  [Read-Write] The default InverseExposureBlend used for the light renderer.
    - ``default_pixel_coverage_mode`` (NiagaraDefaultRendererPixelCoverageMode):  [Read-Write] The default setting for pixel coverage mode when automatic is set on the Niagara Renderer.
    - ``default_render_target_format`` (TextureRenderTargetFormat):  [Read-Write] The default render target format used by all Niagara Render Target Data Interfaces unless overridden.
    - ``default_renderer_motion_vector_setting`` (NiagaraDefaultRendererMotionVectorSetting):  [Read-Write] The default setting for motion vectors in Niagara renderers
    - ``default_sort_precision`` (NiagaraDefaultSortPrecision):  [Read-Write] The default setting for sorting precision when automatic is set on the Niagara Renderer.
    - ``enforce_strict_stack_types`` (bool):  [Read-Write] If set to true, types like positions and vectors cannot be assigned to each other without an explicit conversion step.
      If false, type checks are loosened and some types can be implicitly converted into each other.
      It is recommended to not disable this when working with large world coordinates.
    - ``experimental_vm_enabled`` (bool):  [Read-Write] True indicates that we will generate byte code for the new optimized VM.  Control over whether the new VM will
      be used when executing NiagaraScripts will also take into account the overrides on the system (bDisableExperimentalVM) and
      the cvars fx.NiagaraScript.StripByteCodeOnLoad and fx.ForceExecVMPath.
    - ``invalid_namespace_write_severity`` (NiagaraCompileErrorSeverity):  [Read-Write] If the Niagara compiler sees that a script writes to a namespace that is read only (e.g. a particle script writing to a system attribute), what should it do.
    - ``limit_delta_time`` (bool):  [Read-Write] Whether to limit the max tick delta time or not.
    - ``max_delta_time_per_tick`` (float):  [Read-Write] Limits the delta time per tick for emitters to prevent simulation spikes due to frame lags.
    - ``ndi_collision_query_async_gpu_trace_provider_order`` (Array[NDICollisionQuery_AsyncGpuTraceProvider]):  [Read-Write] Defines how traces tagged as 'Project Default' will be interpreted when using the AsyncGpuTrace data interface.
      The system will go through (starting at element 0) to find the first provider that is available.
    - ``ndi_skel_mesh_adjacency_triangle_index_format`` (NDISkelMesh_AdjacencyTriangleIndexFormat):  [Read-Write] Controls the format used for specifying triangle indexes in adjacency buffers.  Changing this setting requires restarting the editor.
    - ``ndi_skel_mesh_gpu_max_influences`` (NDISkelMesh_GpuMaxInfluences):  [Read-Write] Controls the maximum number of influences we allow the Skeletal Mesh Data Interface to use on the GPU.  Changing this setting requires restarting the editor.
    - ``ndi_skel_mesh_gpu_uniform_sampling_format`` (NDISkelMesh_GpuUniformSamplingFormat):  [Read-Write] Controls the format used for uniform sampling on the GPU.  Changing this setting requires restarting the editor.
    - ``ndi_skel_mesh_support16_bit_index_weight`` (bool):  [Read-Write] Enabled support for 16 bit bone index & bone weight, optional to reduce shader complexity.  Changing this setting requires restarting the editor.
    - ``ndi_skel_mesh_support_reading_deformed_geometry`` (bool):  [Read-Write] When enabled we will read deformed geometry if available, i.e. data from the deformed graph / skin cache
      When disable we will only read from the default vertex data which does not include morph targets, skin, etc.
      Changing this setting requires restarting the editor.
      Note: Enabling this does add additional branches to the skel mesh data reading.
    - ``ndi_static_mesh_allow_distance_fields`` (bool):  [Read-Write] When enabled the static mesh data interface is allowed to sample from the distance field data (if present) on the GPU.
      Enabling this feature will move all systems that contain static mesh samples into PostRenderOpaque tick group regardless of the features used.
      Changing this setting requires restarting the editor.
    - ``platform_set_redirects`` (Array[NiagaraPlatformSetRedirect]):  [Read-Write]
    - ``position_pin_type_color`` (LinearColor):  [Read-Write] Position pin type color. The other pin colors are defined in the general editor settings.
    - ``quality_levels`` (Array[Text]):  [Read-Write] The quality levels Niagara uses.
    - ``quick_sim_cache_capture_frame_count`` (int32):  [Read-Write] The number of frames to capture when capturing a Sim Cache from the Niagara Component Details Panel. *
    - ``required_effect_type`` (SoftObjectPath):  [Read-Write] Specifies a required effect type which must be used for effects in the project.
    - ``show_convertible_inputs_in_stack`` (bool):  [Read-Write] If true then the "link input" menu will also show variables of different types, as long as there is a conversion script for them.
    - ``sim_cache_auxiliary_file_base_path`` (str):  [Read-Write] Base path for auxiliary files written out during the generation of a Niagara Sim Cache (ie: volume files).
    - ``sim_cache_max_cpu_memory_volumetrics`` (int64):  [Read-Write] Max memory in megabytes for total CPU memory for cached volumetric data
    - ``stateless_emitters_enabled`` (bool):  [Read-Write] Enables Lightweight Emitters experimental feature.
      Statless emitters are lightweight fixed function emitters, they are not fully programmable like regular emitters and do not run scripts on the CPU.
      Particle data is extrapolated per frame for the current particle age.  This means we never store particle data, we only generate it on demand.
      Systems that contain only lightweight emitters and no system script modules can take advantage of a much faster path to execute.
      * There is no guarantee on backwards compatability for this feature currently.  Do not ship lightweight content. **
    - ``system_viewport_in_orbit_mode`` (bool):  [Read-Write] Sets the default navigation behavior for the system preview viewport.
    - ``systems_support_large_world_coordinates`` (bool):  [Read-Write] If true then active effects rebase the simulation positions to not lose precision. Can be turned off if not needed to skip unnecessary rebasing calculations.
    """
    @property
    def limit_delta_time(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to limit the max tick delta time or not.
        """
        ...
    @limit_delta_time.setter
    def limit_delta_time(self, value: bool) -> None:
        ...
    @property
    def max_delta_time_per_tick(self) -> float:
        r"""
        (float):  [Read-Write] Limits the delta time per tick for emitters to prevent simulation spikes due to frame lags.
        """
        ...
    @max_delta_time_per_tick.setter
    def max_delta_time_per_tick(self, value: float) -> None:
        ...

class NiagaraValidationRuleSet(Object):
    r"""
    A set of reusable validation rules.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraValidationRuleSet.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``validation_rules`` (Array[NiagaraValidationRule]):  [Read-Write]
    """
    ...

class NiagaraDataInterfaceSceneCapture2D(NiagaraDataInterface):
    r"""
    Data Interface which can control or read from a scene capture component.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceSceneCapture2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_move_offset_location`` (Vector):  [Read-Write] Location offset when applying auto movement.
    - ``auto_move_offset_location_mode`` (NDISceneCapture2DOffsetMode):  [Read-Write] Should we apply the auto move offset in local or world space?
    - ``auto_move_offset_rotation`` (Rotator):  [Read-Write] Rotation offset when applying auto movement.
    - ``auto_move_offset_rotation_mode`` (NDISceneCapture2DOffsetMode):  [Read-Write] How we should apply the rotation
    - ``auto_move_with_component`` (bool):  [Read-Write] When enabled the scene capture component will be automatically moved to the location of the NiagaraComponent with an optional offset.
    - ``managed_capture_every_frame`` (bool):  [Read-Write]
    - ``managed_capture_on_movement`` (bool):  [Read-Write]
    - ``managed_capture_source`` (SceneCaptureSource):  [Read-Write]
    - ``managed_fov_angle`` (float):  [Read-Write]
    - ``managed_ortho_width`` (float):  [Read-Write]
    - ``managed_projection_type`` (CameraProjectionMode):  [Read-Write]
    - ``managed_show_only_actors`` (Array[Actor]):  [Read-Write]
    - ``managed_texture_format`` (TextureRenderTargetFormat):  [Read-Write]
    - ``managed_texture_size`` (IntPoint):  [Read-Write]
    - ``scene_capture_user_parameter`` (NiagaraUserParameterBinding):  [Read-Write] When valid should point to either a Scene Capture 2D Component or a Scene Capture 2D Actor.
    - ``source_mode`` (NDISceneCapture2DSourceMode):  [Read-Write] How should we find the scene capture component to use?
    """
    @classmethod
    def set_scene_capture2d_managed_show_only_actors(cls, niagara_system: NiagaraComponent, parameter_name: Name, show_only_actors: Array[Actor]) -> None:
        r"""
        X.set_scene_capture2d_managed_show_only_actors(niagara_system, parameter_name, show_only_actors) -> None
        Allows you to set the show only actors when Niagara manages the component.  If Niagara does not manage the component use the regular BP methods.
        
        Args:
            niagara_system (NiagaraComponent): 
            parameter_name (Name): 
            show_only_actors (Array[Actor]):
        """
        ...

class NiagaraDataInterfaceStaticMesh(NiagaraDataInterface):
    r"""
    Data Interface allowing sampling of static meshes.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceStaticMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_sampling_from_streaming_lo_ds`` (bool):  [Read-Write] When true, we allow this DI to sample from streaming LODs. Selectively overriding the CVar fx.Niagara.NDIStaticMesh.UseInlineLODsOnly.
    - ``capture_transforms_per_frame`` (bool):  [Read-Write] If true we capture the transforms from the mesh component each frame.
    - ``default_mesh`` (StaticMesh):  [Read-Write] Mesh used to sample from when not overridden by a source actor from the scene. This mesh is NOT removed from cooked builds.
    - ``filtered_sockets`` (Array[Name]):  [Read-Write] List of filtered sockets to use.
    - ``instance_index`` (int32):  [Read-Write] When attached to an Instanced Static Mesh, which instance should be read from.
    - ``lod_index`` (int32):  [Read-Write] Static Mesh LOD to sample.
      When the desired LOD is not available, the next available LOD is used.
      When LOD Index is negative, Desired LOD = Num LODs - LOD Index.
    - ``lod_index_user_parameter`` (NiagaraUserParameterBinding):  [Read-Write] Reference to a user parameter if we're reading one.
    - ``mesh_parameter_binding`` (NiagaraUserParameterBinding):  [Read-Write] Mesh parameter binding can be either an Actor (in which case we find the component), static mesh component or a static mesh.
    - ``preview_mesh`` (StaticMesh):  [Read-Write] Mesh used to sample from when not overridden by a source actor from the scene. Only available in editor for previewing. This is removed in cooked builds.
    - ``section_filter`` (NDIStaticMeshSectionFilter):  [Read-Write] Array of filters the can be used to limit sampling to certain sections of the mesh.
    - ``soft_source_actor`` (Actor):  [Read-Write] The source actor from which to sample. Takes precedence over the direct mesh. Note that this can only be set when used as a user variable on a component in the world.
    - ``source_mode`` (NDIStaticMesh_SourceMode):  [Read-Write] Controls how to retrieve the Static Mesh Component to attach to.
    - ``use_physics_body_velocity`` (bool):  [Read-Write] If true then the mesh velocity is taken from the mesh component's physics data. Otherwise it will be calculated by diffing the component transforms between ticks, which is more reliable but won't work on the first frame.
    """
    @classmethod
    def set_niagara_static_mesh_di_instance_index(cls, niagara_system: NiagaraComponent, user_parameter_name: Name, new_instance_index: int) -> None:
        r"""
        X.set_niagara_static_mesh_di_instance_index(niagara_system, user_parameter_name, new_instance_index) -> None
        Set Niagara Static Mesh DIInstance Index
        
        Args:
            niagara_system (NiagaraComponent): 
            user_parameter_name (Name): 
            new_instance_index (int32):
        """
        ...

class NiagaraDataInterfaceUObjectPropertyReader(NiagaraDataInterface):
    r"""
    Data interface to read properties from UObjects.
    Rather than having BP tick functions that push data into Niagara this data interface will instead pull them.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceUObjectPropertyReader.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``property_remap`` (Array[NiagaraUObjectPropertyReaderRemap]):  [Read-Write]
    - ``source_actor`` (Actor):  [Read-Write] Optional source actor to use, if the user parameter binding is valid this will be ignored.
    - ``source_actor_component_class`` (type(Class)):  [Read-Write] When an actor is bound as the object we will also search for a component of this type to bind properties to.
      For example, setting this to a UPointLightComponent when binding properties we will first look at the actor
      then look for a component of UPointLightComponent and look at properties on that also.
      If no class is specified here we look at the RootComponent instead.
    - ``source_mode`` (NDIObjectPropertyReaderSourceMode):  [Read-Write] Determines how we should select the source object we read from.
    - ``u_object_parameter_binding`` (NiagaraUserParameterBinding):  [Read-Write] User parameter Object binding to read properties from.
    """
    @classmethod
    def set_u_object_reader_property_remap(cls, niagara_component: NiagaraComponent, user_parameter_name: Name, graph_name: Name, remap_name: Name) -> None:
        r"""
        X.set_u_object_reader_property_remap(niagara_component, user_parameter_name, graph_name, remap_name) -> None
        Remaps a property reader, where the
        
        Args:
            niagara_component (NiagaraComponent): 
            user_parameter_name (Name): 
            graph_name (Name): 
            remap_name (Name):
        """
        ...

class MovieSceneNiagaraSystemSpawnSection(MovieSceneSection):
    r"""
    Movie Scene Niagara System Spawn Section
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraSystemSpawnSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``age_update_mode`` (NiagaraAgeUpdateMode):  [Read-Write] Specifies how sequencer should update the age of the controlled niagara system.
    - ``allow_scalability`` (bool):  [Read-Write]
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_end_behavior`` (NiagaraSystemSpawnSectionEndBehavior):  [Read-Write] Specifies what should happen to the niagara system when section evaluation finishes.
    - ``section_evaluate_behavior`` (NiagaraSystemSpawnSectionEvaluateBehavior):  [Read-Write] Specifies what should happen to the niagara system when section is evaluating from the 2nd frame until the last frame.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``section_start_behavior`` (NiagaraSystemSpawnSectionStartBehavior):  [Read-Write] Specifies what should happen to the niagara system from before the section evaluates up until the first frame of the section.
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneNiagaraTrack(MovieSceneNameableTrack):
    r"""
    Movie Scene Niagara Track
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneNiagaraSystemTrack(MovieSceneNiagaraTrack):
    r"""
    Movie Scene Niagara System Track
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraSystemTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneNiagaraParameterTrack(MovieSceneNiagaraTrack):
    r"""
    A base class for tracks that animate niagara parameters.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraParameterTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneNiagaraBoolParameterTrack(MovieSceneNiagaraParameterTrack):
    r"""
    A track for animating boolean niagara parameters.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraBoolParameterTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneNiagaraColorParameterTrack(MovieSceneNiagaraParameterTrack):
    r"""
    A track for animating color niagara parameters.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraColorParameterTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneNiagaraFloatParameterTrack(MovieSceneNiagaraParameterTrack):
    r"""
    A track for animating float niagara parameters.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraFloatParameterTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneNiagaraIntegerParameterTrack(MovieSceneNiagaraParameterTrack):
    r"""
    A track for animating integer niagara parameters.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraIntegerParameterTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneNiagaraVectorParameterTrack(MovieSceneNiagaraParameterTrack):
    r"""
    A track for animating float niagara parameters.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: MovieSceneNiagaraVectorParameterTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class NiagaraActor(Actor):
    r"""
    Niagara Actor
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``niagara_component`` (NiagaraComponent):  [Read-Only] Pointer to System component
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def niagara_component(self) -> NiagaraComponent:
        r"""
        (NiagaraComponent):  [Read-Only] Pointer to System component
        """
        ...
    def set_destroy_on_system_finish(self, should_destroy_on_system_finish: bool) -> None:
        r"""
        x.set_destroy_on_system_finish(should_destroy_on_system_finish) -> None
        Set true for this actor to self-destruct when the Niagara system finishes, false otherwise
        
        Args:
            should_destroy_on_system_finish (bool):
        """
        ...
    def get_destroy_on_system_finish(self) -> bool:
        r"""
        x.get_destroy_on_system_finish() -> bool
        Returns true if the system will destroy on finish
        
        Returns:
            bool:
        """
        ...

class NiagaraComponent(FXSystemComponent):
    r"""
    UNiagaraComponent is the primitive component for a Niagara System.
    see: ANiagaraActor
    see: UNiagaraSystem
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``allow_scalability`` (bool):  [Read-Write] Controls whether we allow scalability culling for this component. If enabled, this component's FX may be culled due to things such as distance, visibility, instance counts and performance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset`` (NiagaraSystem):  [Read-Write]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_attach_location_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our location when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_parent`` (SceneComponent):  [Read-Only] Component we automatically attach to when activated, if bAutoManageAttachment is true.
      If null during registration, we assign the existing AttachParent and defer attachment until we activate.
      see: bAutoManageAttachment
    - ``auto_attach_rotation_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our rotation when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_scale_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our scale when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_socket_name`` (Name):  [Read-Write] Socket we automatically attach to on the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment
    - ``auto_attach_weld_simulated_bodies`` (bool):  [Read-Write] Option for how we handle bWeldSimulatedBodies when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment
    - ``auto_manage_attachment`` (bool):  [Read-Write] True if we should automatically attach to AutoAttachParent when activated, and detach from our parent when completed.
      This overrides any current attachment that may be present at the time of activation (deferring initial attachment until activation, if AutoAttachParent is null).
      When enabled, detachment occurs regardless of whether AutoAttachParent is assigned, and the relative transform from the time of activation is restored.
      This also disables attachment on dedicated servers, where we don't actually activate even if bAutoActivate is true.
      see: AutoAttachParent, AutoAttachSocketName, AutoAttachLocationType
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_gpu_compute_debug`` (bool):  [Read-Write] When true the GPU simulation debug display will enabled, allowing information used during simulation to be visualized.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_solo`` (bool):  [Read-Write] When true, this component's system will be force to update via a slower "solo" path rather than the more optimal batched path with other instances of the same system.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``instance_parameter_overrides`` (Map[NiagaraVariableBase, NiagaraVariant]):  [Read-Write]
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``occlusion_query_mode`` (NiagaraOcclusionQueryMode):  [Read-Write]
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``on_system_finished`` (OnNiagaraSystemFinished):  [Read-Write] Called when the particle system is done
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``override_warmup_settings`` (bool):  [Read-Write] When true then this instance will override the system's warmup settings.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``random_seed_offset`` (int32):  [Read-Write] Offsets the deterministic random seed of all emitters. Used to achieve variety between components, while still achieving determinism.
      WARNINGS:
      - If this value is set in a non-deterministic way, it has the potential to break determinism of the entire system.
      - This value is applied when emitters are activated/reset, and changing them while the emitter is active has no effect.
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``template_parameter_overrides`` (Map[NiagaraVariableBase, NiagaraVariant]):  [Read-Write]
    - ``tick_behavior`` (NiagaraTickBehavior):  [Read-Write] Allows you to control how Niagara selects the tick group, changing this while an instance is active will result in not change as it is cached.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wait_for_compilation_on_activate`` (bool):  [Read-Write]
    - ``warmup_tick_count`` (int32):  [Read-Write] Number of ticks to process for warmup of the system. Total warmup time is WarmupTickCount * WarmupTickDelta.
    - ``warmup_tick_delta`` (float):  [Read-Write] Delta time used when ticking the system in warmup mode.
    """
    @property
    def auto_manage_attachment(self) -> bool:
        r"""
        (bool):  [Read-Only] True if we should automatically attach to AutoAttachParent when activated, and detach from our parent when completed.
        This overrides any current attachment that may be present at the time of activation (deferring initial attachment until activation, if AutoAttachParent is null).
        When enabled, detachment occurs regardless of whether AutoAttachParent is assigned, and the relative transform from the time of activation is restored.
        This also disables attachment on dedicated servers, where we don't actually activate even if bAutoActivate is true.
        see: AutoAttachParent, AutoAttachSocketName, AutoAttachLocationType
        """
        ...
    @property
    def auto_attach_weld_simulated_bodies(self) -> bool:
        r"""
        (bool):  [Read-Write] Option for how we handle bWeldSimulatedBodies when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment
        """
        ...
    @auto_attach_weld_simulated_bodies.setter
    def auto_attach_weld_simulated_bodies(self, value: bool) -> None:
        ...
    @property
    def occlusion_query_mode(self) -> NiagaraOcclusionQueryMode:
        r"""
        (NiagaraOcclusionQueryMode):  [Read-Only]
        """
        ...
    @property
    def on_system_finished(self) -> OnNiagaraSystemFinished:
        r"""
        (OnNiagaraSystemFinished):  [Read-Write] Called when the particle system is done
        """
        ...
    @on_system_finished.setter
    def on_system_finished(self, value: OnNiagaraSystemFinished) -> None:
        ...
    @property
    def auto_attach_parent(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Only] Component we automatically attach to when activated, if bAutoManageAttachment is true.
        If null during registration, we assign the existing AttachParent and defer attachment until we activate.
        see: bAutoManageAttachment
        """
        ...
    @property
    def auto_attach_socket_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Socket we automatically attach to on the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment
        """
        ...
    @auto_attach_socket_name.setter
    def auto_attach_socket_name(self, value: Name) -> None:
        ...
    @property
    def auto_attach_location_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write] Options for how we handle our location when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment, EAttachmentRule
        """
        ...
    @auto_attach_location_rule.setter
    def auto_attach_location_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def auto_attach_rotation_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write] Options for how we handle our rotation when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment, EAttachmentRule
        """
        ...
    @auto_attach_rotation_rule.setter
    def auto_attach_rotation_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def auto_attach_scale_rule(self) -> AttachmentRule:
        r"""
        (AttachmentRule):  [Read-Write] Options for how we handle our scale when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
        see: bAutoManageAttachment, EAttachmentRule
        """
        ...
    @auto_attach_scale_rule.setter
    def auto_attach_scale_rule(self, value: AttachmentRule) -> None:
        ...
    @property
    def allow_scalability(self) -> bool:
        r"""
        (bool):  [Read-Write] Controls whether we allow scalability culling for this component. If enabled, this component's FX may be culled due to things such as distance, visibility, instance counts and performance.
        """
        ...
    @allow_scalability.setter
    def allow_scalability(self, value: bool) -> None:
        ...
    def set_variable_vec4(self, variable_name: Name, value: Vector4) -> None:
        r"""
        x.set_variable_vec4(variable_name, value) -> None
        Sets a Niagara Vector4 parameter by name, overriding locally if necessary.
        
        Args:
            variable_name (Name): 
            value (Vector4):
        """
        ...
    def set_variable_vec3(self, variable_name: Name, value: Vector) -> None:
        r"""
        x.set_variable_vec3(variable_name, value) -> None
        Sets a Niagara Vector3 parameter by name, overriding locally if necessary.
        
        Args:
            variable_name (Name): 
            value (Vector):
        """
        ...
    def set_variable_vec2(self, variable_name: Name, value: Vector2D) -> None:
        r"""
        x.set_variable_vec2(variable_name, value) -> None
        Sets a Niagara Vector2 parameter by name, overriding locally if necessary.
        
        Args:
            variable_name (Name): 
            value (Vector2D):
        """
        ...
    def set_variable_texture_render_target(self, variable_name: Name, texture_render_target: TextureRenderTarget) -> None:
        r"""
        x.set_variable_texture_render_target(variable_name, texture_render_target) -> None
        Set Variable Texture Render Target
        
        Args:
            variable_name (Name): 
            texture_render_target (TextureRenderTarget):
        """
        ...
    def set_variable_texture(self, variable_name: Name, texture: Texture) -> None:
        r"""
        x.set_variable_texture(variable_name, texture) -> None
        Set Variable Texture
        
        Args:
            variable_name (Name): 
            texture (Texture):
        """
        ...
    def set_variable_static_mesh(self, variable_name: Name, value: StaticMesh) -> None:
        r"""
        x.set_variable_static_mesh(variable_name, value) -> None
        Set Variable Static Mesh
        
        Args:
            variable_name (Name): 
            value (StaticMesh):
        """
        ...
    def set_variable_quat(self, variable_name: Name, value: Quat) -> None:
        r"""
        x.set_variable_quat(variable_name, value) -> None
        Sets a Niagara quaternion parameter by name, overriding locally if necessary.
        
        Args:
            variable_name (Name): 
            value (Quat):
        """
        ...
    def set_variable_position(self, variable_name: Name, value: Vector) -> None:
        r"""
        x.set_variable_position(variable_name, value) -> None
        Sets a Niagara Position parameter by name, overriding locally if necessary.
        
        Args:
            variable_name (Name): 
            value (Vector):
        """
        ...
    def set_variable_object(self, variable_name: Name, object: Object) -> None:
        r"""
        x.set_variable_object(variable_name, object) -> None
        Set Variable Object
        
        Args:
            variable_name (Name): 
            object (Object):
        """
        ...
    def set_variable_matrix(self, variable_name: Name, value: Matrix) -> None:
        r"""
        x.set_variable_matrix(variable_name, value) -> None
        Sets a Niagara matrix parameter by name, overriding locally if necessary.
        
        Args:
            variable_name (Name): 
            value (Matrix):
        """
        ...
    def set_variable_material(self, variable_name: Name, object: MaterialInterface) -> None:
        r"""
        x.set_variable_material(variable_name, object) -> None
        Set Variable Material
        
        Args:
            variable_name (Name): 
            object (MaterialInterface):
        """
        ...
    def set_variable_linear_color(self, variable_name: Name, value: LinearColor) -> None:
        r"""
        x.set_variable_linear_color(variable_name, value) -> None
        Sets a Niagara FLinearColor parameter by name, overriding locally if necessary.
        
        Args:
            variable_name (Name): 
            value (LinearColor):
        """
        ...
    def set_variable_int(self, variable_name: Name, value: int) -> None:
        r"""
        x.set_variable_int(variable_name, value) -> None
        Sets a Niagara int parameter by name, overriding locally if necessary.
        
        Args:
            variable_name (Name): 
            value (int32):
        """
        ...
    def set_variable_float(self, variable_name: Name, value: float) -> None:
        r"""
        x.set_variable_float(variable_name, value) -> None
        Sets a Niagara float parameter by name, overriding locally if necessary.
        
        Args:
            variable_name (Name): 
            value (float):
        """
        ...
    def set_variable_bool(self, variable_name: Name, value: bool) -> None:
        r"""
        x.set_variable_bool(variable_name, value) -> None
        Sets a Niagara bool parameter by name, overriding locally if necessary.
        
        Args:
            variable_name (Name): 
            value (bool):
        """
        ...
    def set_variable_actor(self, variable_name: Name, actor: Actor) -> None:
        r"""
        x.set_variable_actor(variable_name, actor) -> None
        Set Variable Actor
        
        Args:
            variable_name (Name): 
            actor (Actor):
        """
        ...
    def set_tick_behavior(self, new_tick_behavior: NiagaraTickBehavior) -> None:
        r"""
        x.set_tick_behavior(new_tick_behavior) -> None
        Set Tick Behavior
        
        Args:
            new_tick_behavior (NiagaraTickBehavior):
        """
        ...
    def set_system_fixed_bounds(self, local_bounds: Box) -> None:
        r"""
        x.set_system_fixed_bounds(local_bounds) -> None
        Sets the fixed bounds for the system instance, this overrides all other bounds.
        The box is expected to be in local space not world space.
        A default uninitialized box will clear the fixed bounds and revert back to system fixed / dynamic bounds.
        
        Args:
            local_bounds (Box):
        """
        ...
    def set_sim_cache(self, sim_cache: NiagaraSimCache, reset_system: bool = False) -> None:
        r"""
        x.set_sim_cache(sim_cache, reset_system=False) -> None
        Sets the simulation cache to use for the component.
        A null SimCache parameter will clear the active simulation cache.
        When clearing a simulation cache that has been running you may wish to reset or continue, this option is only
        valid when using a full simulation cache.  A renderer only cache will always reset as we can not continue the
        simulation due to missing simulation data.
        
        Args:
            sim_cache (NiagaraSimCache): 
            reset_system (bool):
        """
        ...
    def set_seek_delta(self, seek_delta: float) -> None:
        r"""
        x.set_seek_delta(seek_delta) -> None
        Sets the delta value which is used when seeking from the current age, to the desired age.  This is only relevant
              when using the DesiredAge age update mode.
        
        Args:
            seek_delta (float):
        """
        ...
    def set_rendering_enabled(self, rendering_enabled: bool) -> None:
        r"""
        x.set_rendering_enabled(rendering_enabled) -> None
        Sets whether or not rendering is enabled for this component.
        
        Args:
            rendering_enabled (bool):
        """
        ...
    def set_random_seed_offset(self, new_random_seed_offset: int) -> None:
        r"""
        x.set_random_seed_offset(new_random_seed_offset) -> None
        Set Random Seed Offset
        
        Args:
            new_random_seed_offset (int32):
        """
        ...
    def set_preview_lod_distance(self, enable_preview_lod_distance: bool, preview_lod_distance: float, preview_max_distance: float) -> None:
        r"""
        x.set_preview_lod_distance(enable_preview_lod_distance, preview_lod_distance, preview_max_distance) -> None
        Set Preview LODDistance
        
        Args:
            enable_preview_lod_distance (bool): 
            preview_lod_distance (float): 
            preview_max_distance (float):
        """
        ...
    def set_paused(self, paused: bool) -> None:
        r"""
        x.set_paused(paused) -> None
        Set Paused
        
        Args:
            paused (bool):
        """
        ...
    def set_occlusion_query_mode(self, mode: NiagaraOcclusionQueryMode) -> None:
        r"""
        x.set_occlusion_query_mode(mode) -> None
        Set Occlusion Query Mode
        
        Args:
            mode (NiagaraOcclusionQueryMode):
        """
        ...
    def set_niagara_variable_vec4(self, variable_name: str, value: Vector4) -> None:
        r"""
        x.set_niagara_variable_vec4(variable_name, value) -> None
        Set Niagara Variable Vec 4
        
        Args:
            variable_name (str): 
            value (Vector4):
        """
        ...
    def set_niagara_variable_vec3(self, variable_name: str, value: Vector) -> None:
        r"""
        x.set_niagara_variable_vec3(variable_name, value) -> None
        Set Niagara Variable Vec 3
        
        Args:
            variable_name (str): 
            value (Vector):
        """
        ...
    def set_niagara_variable_vec2(self, variable_name: str, value: Vector2D) -> None:
        r"""
        x.set_niagara_variable_vec2(variable_name, value) -> None
        Set Niagara Variable Vec 2
        
        Args:
            variable_name (str): 
            value (Vector2D):
        """
        ...
    def set_niagara_variable_quat(self, variable_name: str, value: Quat) -> None:
        r"""
        x.set_niagara_variable_quat(variable_name, value) -> None
        Set Niagara Variable Quat
        
        Args:
            variable_name (str): 
            value (Quat):
        """
        ...
    def set_niagara_variable_position(self, variable_name: str, value: Vector) -> None:
        r"""
        x.set_niagara_variable_position(variable_name, value) -> None
        Set Niagara Variable Position
        
        Args:
            variable_name (str): 
            value (Vector):
        """
        ...
    def set_niagara_variable_object(self, variable_name: str, object: Object) -> None:
        r"""
        x.set_niagara_variable_object(variable_name, object) -> None
        Set Niagara Variable Object
        
        Args:
            variable_name (str): 
            object (Object):
        """
        ...
    def set_niagara_variable_matrix(self, variable_name: str, value: Matrix) -> None:
        r"""
        x.set_niagara_variable_matrix(variable_name, value) -> None
        Set Niagara Variable Matrix
        
        Args:
            variable_name (str): 
            value (Matrix):
        """
        ...
    def set_niagara_variable_linear_color(self, variable_name: str, value: LinearColor) -> None:
        r"""
        x.set_niagara_variable_linear_color(variable_name, value) -> None
        Set Niagara Variable Linear Color
        
        Args:
            variable_name (str): 
            value (LinearColor):
        """
        ...
    def set_niagara_variable_int(self, variable_name: str, value: int) -> None:
        r"""
        x.set_niagara_variable_int(variable_name, value) -> None
        Set Niagara Variable Int
        
        Args:
            variable_name (str): 
            value (int32):
        """
        ...
    def set_niagara_variable_float(self, variable_name: str, value: float) -> None:
        r"""
        x.set_niagara_variable_float(variable_name, value) -> None
        Set Niagara Variable Float
        
        Args:
            variable_name (str): 
            value (float):
        """
        ...
    def set_niagara_variable_bool(self, variable_name: str, value: bool) -> None:
        r"""
        x.set_niagara_variable_bool(variable_name, value) -> None
        Set Niagara Variable Bool
        
        Args:
            variable_name (str): 
            value (bool):
        """
        ...
    def set_niagara_variable_actor(self, variable_name: str, actor: Actor) -> None:
        r"""
        x.set_niagara_variable_actor(variable_name, actor) -> None
        Set Niagara Variable Actor
        
        Args:
            variable_name (str): 
            actor (Actor):
        """
        ...
    def set_max_sim_time(self, max_time: float) -> None:
        r"""
        x.set_max_sim_time(max_time) -> None
        Sets the maximum CPU time in seconds we will simulate to the desired age, when we go beyond this limit ticks will be processed in the next frame.
        This is only relevant when using the DesiredAge age update mode.
        Note: The componet will not be visibile if we have ticks to process and SetCanRenderWhileSeeking is set to true
        
        Args:
            max_time (float):
        """
        ...
    def set_lock_desired_age_delta_time_to_seek_delta(self, lock: bool) -> None:
        r"""
        x.set_lock_desired_age_delta_time_to_seek_delta(lock) -> None
        Sets whether or not the delta time used to tick the system instance when using desired age is locked to the seek delta.  When true, the system instance
              will only be ticked when the desired age has changed by more than the seek delta.  When false the system instance will be ticked by the change in desired
              age when not seeking.
        
        Args:
            lock (bool):
        """
        ...
    def set_gpu_compute_debug(self, enable_debug: bool) -> None:
        r"""
        x.set_gpu_compute_debug(enable_debug) -> None
        Set Gpu Compute Debug
        
        Args:
            enable_debug (bool):
        """
        ...
    def set_force_solo(self, force_solo: bool) -> None:
        r"""
        x.set_force_solo(force_solo) -> None
        Set Force Solo
        
        Args:
            force_solo (bool):
        """
        ...
    def set_emitter_fixed_bounds(self, emitter_name: Name, local_bounds: Box) -> None:
        r"""
        x.set_emitter_fixed_bounds(emitter_name, local_bounds) -> None
        Sets the fixed bounds for an emitter instance, this overrides all other bounds.
        The box is expected to be in local space not world space.
        A default uninitialized box will clear the fixed bounds and revert back to emitter fixed / dynamic bounds.
        
        Args:
            emitter_name (Name): 
            local_bounds (Box):
        """
        ...
    def set_desired_age(self, desired_age: float) -> None:
        r"""
        x.set_desired_age(desired_age) -> None
        Sets the desired age of the System instance.  This is only relevant when using the DesiredAge age update mode.
        
        Args:
            desired_age (float):
        """
        ...
    def set_custom_time_dilation(self, dilation: float = 1.000000) -> None:
        r"""
        x.set_custom_time_dilation(dilation=1.000000) -> None
        Sets the custom time dilation value for the component.
        Note: This is only available on components that are in solo mode currently.
        
        Args:
            dilation (float):
        """
        ...
    def set_can_render_while_seeking(self, can_render_while_seeking: bool) -> None:
        r"""
        x.set_can_render_while_seeking(can_render_while_seeking) -> None
        Sets whether or not the system can render while seeking.
        
        Args:
            can_render_while_seeking (bool):
        """
        ...
    def set_auto_destroy(self, auto_destroy: bool) -> None:
        r"""
        x.set_auto_destroy(auto_destroy) -> None
        Set Auto Destroy
        
        Args:
            auto_destroy (bool):
        """
        ...
    def set_asset(self, asset: NiagaraSystem, reset_existing_override_parameters: bool = True) -> None:
        r"""
        x.set_asset(asset, reset_existing_override_parameters=True) -> None
        Switch which asset the component is using.
        This requires Niagara to wait for concurrent execution and the override parameter store to be synchronized with the new asset.
        By default existing parameters are reset when we call SetAsset, modify bResetExistingOverrideParameters to leave existing parameter data as is.
        
        Args:
            asset (NiagaraSystem): 
            reset_existing_override_parameters (bool):
        """
        ...
    def set_age_update_mode(self, age_update_mode: NiagaraAgeUpdateMode) -> None:
        r"""
        x.set_age_update_mode(age_update_mode) -> None
        Sets the age update mode for the System instance.
        
        Args:
            age_update_mode (NiagaraAgeUpdateMode):
        """
        ...
    def seek_to_desired_age(self, desired_age: float) -> None:
        r"""
        x.seek_to_desired_age(desired_age) -> None
        Sets the desired age of the System instance and designates that this change is a seek.  When seeking to a desired age the
                  The component can optionally prevent rendering.
        
        Args:
            desired_age (float):
        """
        ...
    def reset_system(self) -> None:
        r"""
        x.reset_system() -> None
        Resets the System to it's initial pre-simulated state.
        """
        ...
    def reinitialize_system(self) -> None:
        r"""
        x.reinitialize_system() -> None
        Called on when an external object wishes to force this System to reinitialize itself from the System data.
        """
        ...
    def is_paused(self) -> bool:
        r"""
        x.is_paused() -> bool
        Is Paused
        
        Returns:
            bool:
        """
        ...
    def init_for_performance_baseline(self) -> None:
        r"""
        x.init_for_performance_baseline() -> None
        Initializes this component for capturing a performance baseline.
        This will do things such as disabling distance culling and setting a LODDistance of 0 to ensure the effect is at it's maximum cost.
        """
        ...
    def get_tick_behavior(self) -> NiagaraTickBehavior:
        r"""
        x.get_tick_behavior() -> NiagaraTickBehavior
        Get Tick Behavior
        
        Returns:
            NiagaraTickBehavior:
        """
        ...
    def get_system_fixed_bounds(self) -> Box:
        r"""
        x.get_system_fixed_bounds() -> Box
        Gets the fixed bounds for the system instance.
        This will return the user set fixed bounds if set, or the systems fixed bounds if set.
        Note: The returned box may be invalid if no fixed bounds exist
        
        Returns:
            Box:
        """
        ...
    def get_sim_cache(self) -> NiagaraSimCache:
        r"""
        x.get_sim_cache() -> NiagaraSimCache
        Get the active simulation cache, will return null if we do not have an active one.
        
        Returns:
            NiagaraSimCache:
        """
        ...
    def get_seek_delta(self) -> float:
        r"""
        x.get_seek_delta() -> float
        Gets the delta value which is used when seeking from the current age, to the desired age.  This is only relevant
              when using the DesiredAge age update mode.
        
        Returns:
            float:
        """
        ...
    def get_random_seed_offset(self) -> int:
        r"""
        x.get_random_seed_offset() -> int32
        Get Random Seed Offset
        
        Returns:
            int32:
        """
        ...
    def get_preview_lod_distance_enabled(self) -> bool:
        r"""
        x.get_preview_lod_distance_enabled() -> bool
        Get Preview LODDistance Enabled
        
        Returns:
            bool:
        """
        ...
    def get_preview_lod_distance(self) -> float:
        r"""
        x.get_preview_lod_distance() -> float
        Get Preview LODDistance
        
        Returns:
            float:
        """
        ...
    def get_occlusion_query_mode(self) -> NiagaraOcclusionQueryMode:
        r"""
        x.get_occlusion_query_mode() -> NiagaraOcclusionQueryMode
        Get Occlusion Query Mode
        
        Returns:
            NiagaraOcclusionQueryMode:
        """
        ...
    def get_max_sim_time(self) -> float:
        r"""
        x.get_max_sim_time() -> float
        Get the maximum CPU time in seconds we will simulate to the desired age, when we go beyond this limit ticks will be processed in the next frame.
        This is only relevant when using the DesiredAge age update mode.
        Note: The componet will not be visibile if we have ticks to process and SetCanRenderWhileSeeking is set to true
        
        Returns:
            float:
        """
        ...
    def get_lock_desired_age_delta_time_to_seek_delta(self) -> bool:
        r"""
        x.get_lock_desired_age_delta_time_to_seek_delta() -> bool
        Gets whether or not the delta time used to tick the system instance when using desired age is locked to the seek delta.  When true, the system instance
              will only be ticked when the desired age has changed by more than the seek delta.  When false the system instance will be ticked by the change in desired
              age when not seeking.
        
        Returns:
            bool:
        """
        ...
    def get_force_solo(self) -> bool:
        r"""
        x.get_force_solo() -> bool
        Get Force Solo
        
        Returns:
            bool:
        """
        ...
    def get_emitter_fixed_bounds(self, emitter_name: Name) -> Box:
        r"""
        x.get_emitter_fixed_bounds(emitter_name) -> Box
        Gets the fixed bounds for an emitter instance.
        This will return the user set fixed bounds if set, or the emitters fixed bounds if set.
        Note: The returned box may be invalid if no fixed bounds exist
        
        Args:
            emitter_name (Name): 
        
        Returns:
            Box:
        """
        ...
    def get_desired_age(self) -> float:
        r"""
        x.get_desired_age() -> float
        Gets the desired age of the System instance.  This is only relevant when using the DesiredAge age update mode.
        
        Returns:
            float:
        """
        ...
    def get_data_interface(self, name: str) -> NiagaraDataInterface:
        r"""
        x.get_data_interface(name) -> NiagaraDataInterface
        Get Data Interface
        
        Args:
            name (str): 
        
        Returns:
            NiagaraDataInterface:
        """
        ...
    def get_custom_time_dilation(self) -> float:
        r"""
        x.get_custom_time_dilation() -> float
        Get Custom Time Dilation
        
        Returns:
            float:
        """
        ...
    def get_asset(self) -> NiagaraSystem:
        r"""
        x.get_asset() -> NiagaraSystem
        Get Asset
        
        Returns:
            NiagaraSystem:
        """
        ...
    def get_age_update_mode(self) -> NiagaraAgeUpdateMode:
        r"""
        x.get_age_update_mode() -> NiagaraAgeUpdateMode
        Get Age Update Mode
        
        Returns:
            NiagaraAgeUpdateMode:
        """
        ...
    def clear_system_fixed_bounds(self) -> None:
        r"""
        x.clear_system_fixed_bounds() -> None
        Clear any previously set fixed bounds for the system instance.
        """
        ...
    def clear_sim_cache(self, reset_system: bool = False) -> None:
        r"""
        x.clear_sim_cache(reset_system=False) -> None
        Clear any active simulation cache.
        When clearing a simulation cache that has been running you may wish to reset or continue, this option is only
        valid when using a full simulation cache.  A renderer only cache will always reset as we can not continue the
        simulation due to missing simulation data.
        
        Args:
            reset_system (bool):
        """
        ...
    def clear_emitter_fixed_bounds(self, emitter_name: Name) -> None:
        r"""
        x.clear_emitter_fixed_bounds(emitter_name) -> None
        Clear any previously set fixed bounds for the emitter instance.
        
        Args:
            emitter_name (Name):
        """
        ...
    def advance_simulation_by_time(self, simulate_time: float, tick_delta_seconds: float) -> None:
        r"""
        x.advance_simulation_by_time(simulate_time, tick_delta_seconds) -> None
        Advances this system's simulation by the specified time in seconds and delta time. Advancement is done in whole ticks of TickDeltaSeconds so actual simulated time will be the nearest lower multiple of TickDeltaSeconds.
        
        Args:
            simulate_time (float): 
            tick_delta_seconds (float):
        """
        ...
    def advance_simulation(self, tick_count: int, tick_delta_seconds: float) -> None:
        r"""
        x.advance_simulation(tick_count, tick_delta_seconds) -> None
        Advances this system's simulation by the specified number of ticks and delta time.
        
        Args:
            tick_count (int32): 
            tick_delta_seconds (float):
        """
        ...

class NiagaraCullProxyComponent(NiagaraComponent):
    r"""
    A specialization of UNiagaraComponent that can act as a proxy for many other NiagaraComponents that have been culled by scalability.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraCullProxyComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``allow_scalability`` (bool):  [Read-Write] Controls whether we allow scalability culling for this component. If enabled, this component's FX may be culled due to things such as distance, visibility, instance counts and performance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset`` (NiagaraSystem):  [Read-Write]
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_attach_location_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our location when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_parent`` (SceneComponent):  [Read-Only] Component we automatically attach to when activated, if bAutoManageAttachment is true.
      If null during registration, we assign the existing AttachParent and defer attachment until we activate.
      see: bAutoManageAttachment
    - ``auto_attach_rotation_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our rotation when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_scale_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our scale when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_socket_name`` (Name):  [Read-Write] Socket we automatically attach to on the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment
    - ``auto_attach_weld_simulated_bodies`` (bool):  [Read-Write] Option for how we handle bWeldSimulatedBodies when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment
    - ``auto_manage_attachment`` (bool):  [Read-Write] True if we should automatically attach to AutoAttachParent when activated, and detach from our parent when completed.
      This overrides any current attachment that may be present at the time of activation (deferring initial attachment until activation, if AutoAttachParent is null).
      When enabled, detachment occurs regardless of whether AutoAttachParent is assigned, and the relative transform from the time of activation is restored.
      This also disables attachment on dedicated servers, where we don't actually activate even if bAutoActivate is true.
      see: AutoAttachParent, AutoAttachSocketName, AutoAttachLocationType
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_gpu_compute_debug`` (bool):  [Read-Write] When true the GPU simulation debug display will enabled, allowing information used during simulation to be visualized.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_solo`` (bool):  [Read-Write] When true, this component's system will be force to update via a slower "solo" path rather than the more optimal batched path with other instances of the same system.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``instance_parameter_overrides`` (Map[NiagaraVariableBase, NiagaraVariant]):  [Read-Write]
    - ``instances`` (Array[NiagaraCulledComponentInfo]):  [Read-Write] Array of additional instance transforms. This component will be rendered at it's own transform and additionally at each of these transforms.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``occlusion_query_mode`` (NiagaraOcclusionQueryMode):  [Read-Write]
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``on_system_finished`` (OnNiagaraSystemFinished):  [Read-Write] Called when the particle system is done
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``override_warmup_settings`` (bool):  [Read-Write] When true then this instance will override the system's warmup settings.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``random_seed_offset`` (int32):  [Read-Write] Offsets the deterministic random seed of all emitters. Used to achieve variety between components, while still achieving determinism.
      WARNINGS:
      - If this value is set in a non-deterministic way, it has the potential to break determinism of the entire system.
      - This value is applied when emitters are activated/reset, and changing them while the emitter is active has no effect.
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``template_parameter_overrides`` (Map[NiagaraVariableBase, NiagaraVariant]):  [Read-Write]
    - ``tick_behavior`` (NiagaraTickBehavior):  [Read-Write] Allows you to control how Niagara selects the tick group, changing this while an instance is active will result in not change as it is cached.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wait_for_compilation_on_activate`` (bool):  [Read-Write]
    - ``warmup_tick_count`` (int32):  [Read-Write] Number of ticks to process for warmup of the system. Total warmup time is WarmupTickCount * WarmupTickDelta.
    - ``warmup_tick_delta`` (float):  [Read-Write] Delta time used when ticking the system in warmup mode.
    """
    ...

class NiagaraDataChannelLibrary(BlueprintFunctionLibrary):
    r"""
    A C++ and Blueprint accessible library of utility functions for accessing Niagara DataChannel
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataChannel.h
    
    """
    @classmethod
    def write_to_niagara_data_channel(cls, world_context_object: Object, channel: NiagaraDataChannelAsset, search_params: NiagaraDataChannelSearchParameters, count: int, visible_to_game: bool, visible_to_cpu: bool, visible_to_gpu: bool, debug_source: str) -> NiagaraDataChannelWriter:
        r"""
        X.write_to_niagara_data_channel(world_context_object, channel, search_params, count, visible_to_game, visible_to_cpu, visible_to_gpu, debug_source) -> NiagaraDataChannelWriter
        Initializes and returns the Niagara Data Channel writer to write N elements to the given data channel.
        
        Args:
            world_context_object (Object): World to execute in
            channel (NiagaraDataChannelAsset): The channel to write to
            search_params (NiagaraDataChannelSearchParameters): Parameters used when retrieving a specific set of Data Channel Data to read or write like the islands data channel type.
            count (int32): The number of elements to write
            visible_to_game (bool): If true, the data written to this data channel is visible to Blueprint and C++ logic reading from it
            visible_to_cpu (bool): If true, the data written to this data channel is visible to Niagara CPU emitters
            visible_to_gpu (bool): If true, the data written to this data channel is visible to Niagara GPU emitters
            debug_source (str): Instigator for this write, used in the debug hud to track writes to the data channel from different sources
        
        Returns:
            NiagaraDataChannelWriter:
        """
        ...
    @classmethod
    def read_from_niagara_data_channel(cls, world_context_object: Object, channel: NiagaraDataChannelAsset, search_params: NiagaraDataChannelSearchParameters, read_previous_frame: bool) -> NiagaraDataChannelReader:
        r"""
        X.read_from_niagara_data_channel(world_context_object, channel, search_params, read_previous_frame) -> NiagaraDataChannelReader
        Initializes and returns the Niagara Data Channel reader for the given data channel.
        
        Args:
            world_context_object (Object): World to execute in
            channel (NiagaraDataChannelAsset): The channel to read from
            search_params (NiagaraDataChannelSearchParameters): Parameters used when retrieving a specific set of Data Channel Data to read or write like the islands data channel type.
            read_previous_frame (bool): True if this reader will read the previous frame's data. If false, we read the current frame. Reading the current frame allows for zero latency reads, but any data elements that are generated after this reader is used are missed. Reading the previous frame's data introduces a frame of latency but ensures we never miss any data as we have access to the whole frame.
        
        Returns:
            NiagaraDataChannelReader:
        """
        ...
    @classmethod
    def get_data_channel_element_count(cls, world_context_object: Object, channel: NiagaraDataChannelAsset, search_params: NiagaraDataChannelSearchParameters, read_previous_frame: bool = True) -> int:
        r"""
        X.get_data_channel_element_count(world_context_object, channel, search_params, read_previous_frame=True) -> int32
        Returns the number of readable elements in the given data channel
        
        Args:
            world_context_object (Object): World to execute in
            channel (NiagaraDataChannelAsset): The channel to read from
            search_params (NiagaraDataChannelSearchParameters): Parameters used when retrieving a specific set of Data Channel Data to read or write like the islands data channel type.
            read_previous_frame (bool): True if this reader will read the previous frame's data. If false, we read the current frame. Reading the current frame allows for zero latency reads, but any data elements that are generated after this reader is used are missed. Reading the previous frame's data introduces a frame of latency but ensures we never miss any data as we have access to the whole frame.
        
        Returns:
            int32:
        """
        ...

class NiagaraDataInterfaceRWBase(NiagaraDataInterface):
    r"""
    Niagara Data Interface RWBase
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceRW.h
    
    """
    ...

class NiagaraDataInterfaceArray(NiagaraDataInterfaceRWBase):
    r"""
    Niagara Data Interface Array
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArray.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    """
    @property
    def gpu_sync_mode(self) -> NiagaraGpuSyncMode:
        r"""
        (NiagaraGpuSyncMode):  [Read-Only] How to do we want to synchronize modifications to the array data.
        """
        ...
    @property
    def max_elements(self) -> int:
        r"""
        (int32):  [Read-Only] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
        """
        ...

class NiagaraDataInterfaceArrayFloat(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array Float
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``float_data`` (Array[float]):  [Read-Write]
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    """
    @property
    def float_data(self) -> Array[float]:
        r"""
        (Array[float]):  [Read-Write]
        """
        ...
    @float_data.setter
    def float_data(self, value: Array[float]) -> None:
        ...

class NiagaraDataInterfaceArrayFloat2(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array Float 2
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``float_data`` (Array[Vector2D]):  [Read-Write]
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    """
    @property
    def float_data(self) -> Array[Vector2D]:
        r"""
        (Array[Vector2D]):  [Read-Write]
        """
        ...
    @float_data.setter
    def float_data(self, value: Array[Vector2D]) -> None:
        ...

class NiagaraDataInterfaceArrayFloat3(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array Float 3
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``float_data`` (Array[Vector]):  [Read-Write]
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    """
    @property
    def float_data(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Write]
        """
        ...
    @float_data.setter
    def float_data(self, value: Array[Vector]) -> None:
        ...

class NiagaraDataInterfaceArrayPosition(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array Position
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    - ``position_data`` (Array[NiagaraPosition]):  [Read-Write]
    """
    @property
    def position_data(self) -> Array[NiagaraPosition]:
        r"""
        (Array[NiagaraPosition]):  [Read-Write]
        """
        ...
    @position_data.setter
    def position_data(self, value: Array[NiagaraPosition]) -> None:
        ...

class NiagaraDataInterfaceArrayFloat4(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array Float 4
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``float_data`` (Array[Vector4]):  [Read-Write]
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    """
    @property
    def float_data(self) -> Array[Vector4]:
        r"""
        (Array[Vector4]):  [Read-Write]
        """
        ...
    @float_data.setter
    def float_data(self, value: Array[Vector4]) -> None:
        ...

class NiagaraDataInterfaceArrayColor(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array Color
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_data`` (Array[LinearColor]):  [Read-Write]
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    """
    @property
    def color_data(self) -> Array[LinearColor]:
        r"""
        (Array[LinearColor]):  [Read-Write]
        """
        ...
    @color_data.setter
    def color_data(self, value: Array[LinearColor]) -> None:
        ...

class NiagaraDataInterfaceArrayQuat(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array Quat
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    - ``quat_data`` (Array[Quat]):  [Read-Write]
    """
    @property
    def quat_data(self) -> Array[Quat]:
        r"""
        (Array[Quat]):  [Read-Write]
        """
        ...
    @quat_data.setter
    def quat_data(self, value: Array[Quat]) -> None:
        ...

class NiagaraDataInterfaceArrayMatrix(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array Matrix
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``matrix_data`` (Array[Matrix]):  [Read-Write]
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    """
    @property
    def matrix_data(self) -> Array[Matrix]:
        r"""
        (Array[Matrix]):  [Read-Write]
        """
        ...
    @matrix_data.setter
    def matrix_data(self, value: Array[Matrix]) -> None:
        ...

class NiagaraDataInterfaceArrayFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    C++ and Blueprint library for accessing array types
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayFunctionLibrary.h
    
    """
    @classmethod
    def set_niagara_array_vector_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, value: Vector, size_to_fit: bool) -> None:
        r"""
        X.set_niagara_array_vector_value(niagara_system, override_name, index, value, size_to_fit) -> None
        Sets a single value within a Niagara Array FVector.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            value (Vector): 
            size_to_fit (bool):
        """
        ...
    @classmethod
    def set_niagara_array_vector4_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, value: Vector4, size_to_fit: bool) -> None:
        r"""
        X.set_niagara_array_vector4_value(niagara_system, override_name, index, value, size_to_fit) -> None
        Sets a single value within a Niagara Array FVector4.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            value (Vector4): 
            size_to_fit (bool):
        """
        ...
    @classmethod
    def set_niagara_array_vector4(cls, niagara_system: NiagaraComponent, override_name: Name, array_data: Array[Vector4]) -> None:
        r"""
        X.set_niagara_array_vector4(niagara_system, override_name, array_data) -> None
        Sets Niagara Array FVector4 Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            array_data (Array[Vector4]):
        """
        ...
    @classmethod
    def set_niagara_array_vector2d_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, value: Vector2D, size_to_fit: bool) -> None:
        r"""
        X.set_niagara_array_vector2d_value(niagara_system, override_name, index, value, size_to_fit) -> None
        Sets a single value within a Niagara Array FVector2D.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            value (Vector2D): 
            size_to_fit (bool):
        """
        ...
    @classmethod
    def set_niagara_array_vector2d(cls, niagara_system: NiagaraComponent, override_name: Name, array_data: Array[Vector2D]) -> None:
        r"""
        X.set_niagara_array_vector2d(niagara_system, override_name, array_data) -> None
        Sets Niagara Array FVector2D Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            array_data (Array[Vector2D]):
        """
        ...
    @classmethod
    def set_niagara_array_vector(cls, niagara_system: NiagaraComponent, override_name: Name, array_data: Array[Vector]) -> None:
        r"""
        X.set_niagara_array_vector(niagara_system, override_name, array_data) -> None
        Sets Niagara Array FVector Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            array_data (Array[Vector]):
        """
        ...
    @classmethod
    def set_niagara_array_u_int8_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, value: int, size_to_fit: bool) -> None:
        r"""
        X.set_niagara_array_u_int8_value(niagara_system, override_name, index, value, size_to_fit) -> None
        Sets a single value within a Niagara Array UInt8.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            value (int32): 
            size_to_fit (bool):
        """
        ...
    @classmethod
    def set_niagara_array_u_int8(cls, niagara_system: NiagaraComponent, override_name: Name, array_data: Array[int]) -> None:
        r"""
        X.set_niagara_array_u_int8(niagara_system, override_name, array_data) -> None
        Sets Niagara Array UInt8 Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            array_data (Array[int32]):
        """
        ...
    @classmethod
    def set_niagara_array_quat_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, value: Quat, size_to_fit: bool) -> None:
        r"""
        X.set_niagara_array_quat_value(niagara_system, override_name, index, value, size_to_fit) -> None
        Sets a single value within a Niagara Array FQuat.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            value (Quat): 
            size_to_fit (bool):
        """
        ...
    @classmethod
    def set_niagara_array_quat(cls, niagara_system: NiagaraComponent, override_name: Name, array_data: Array[Quat]) -> None:
        r"""
        X.set_niagara_array_quat(niagara_system, override_name, array_data) -> None
        Sets Niagara Array FQuat Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            array_data (Array[Quat]):
        """
        ...
    @classmethod
    def set_niagara_array_position_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, value: Vector, size_to_fit: bool) -> None:
        r"""
        X.set_niagara_array_position_value(niagara_system, override_name, index, value, size_to_fit) -> None
        Set Niagara Array Position Value
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            value (Vector): 
            size_to_fit (bool):
        """
        ...
    @classmethod
    def set_niagara_array_position(cls, niagara_system: NiagaraComponent, override_name: Name, array_data: Array[Vector]) -> None:
        r"""
        X.set_niagara_array_position(niagara_system, override_name, array_data) -> None
        Sets Niagara Array FVector Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            array_data (Array[Vector]):
        """
        ...
    @classmethod
    def set_niagara_array_matrix_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, value: Matrix, size_to_fit: bool, apply_lwc_rebase: bool = True) -> None:
        r"""
        X.set_niagara_array_matrix_value(niagara_system, override_name, index, value, size_to_fit, apply_lwc_rebase=True) -> None
        Sets a single value within a Niagara Array FMatrix.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            value (Matrix): 
            size_to_fit (bool): 
            apply_lwc_rebase (bool): When enabled the matrix translation will have the simulation tile offset subtracted from it
        """
        ...
    @classmethod
    def set_niagara_array_matrix(cls, niagara_system: NiagaraComponent, override_name: Name, array_data: Array[Matrix], apply_lwc_rebase: bool = True) -> None:
        r"""
        X.set_niagara_array_matrix(niagara_system, override_name, array_data, apply_lwc_rebase=True) -> None
        Sets Niagara Array FMatrix Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            array_data (Array[Matrix]): 
            apply_lwc_rebase (bool): When enabled the matrix translation will have the simulation tile offset subtracted from it
        """
        ...
    @classmethod
    def set_niagara_array_int32_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, value: int, size_to_fit: bool) -> None:
        r"""
        X.set_niagara_array_int32_value(niagara_system, override_name, index, value, size_to_fit) -> None
        Sets a single value within a Niagara Array Int32.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            value (int32): 
            size_to_fit (bool):
        """
        ...
    @classmethod
    def set_niagara_array_int32(cls, niagara_system: NiagaraComponent, override_name: Name, array_data: Array[int]) -> None:
        r"""
        X.set_niagara_array_int32(niagara_system, override_name, array_data) -> None
        Sets Niagara Array Int32 Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            array_data (Array[int32]):
        """
        ...
    @classmethod
    def set_niagara_array_float_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, value: float, size_to_fit: bool) -> None:
        r"""
        X.set_niagara_array_float_value(niagara_system, override_name, index, value, size_to_fit) -> None
        Sets a single value within a Niagara Array Float.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            value (float): 
            size_to_fit (bool):
        """
        ...
    @classmethod
    def set_niagara_array_float(cls, niagara_system: NiagaraComponent, override_name: Name, array_data: Array[float]) -> None:
        r"""
        X.set_niagara_array_float(niagara_system, override_name, array_data) -> None
        Sets Niagara Array Float Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            array_data (Array[float]):
        """
        ...
    @classmethod
    def set_niagara_array_color_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, value: LinearColor, size_to_fit: bool) -> None:
        r"""
        X.set_niagara_array_color_value(niagara_system, override_name, index, value, size_to_fit) -> None
        Sets a single value within a Niagara Array FLinearColor.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            value (LinearColor): 
            size_to_fit (bool):
        """
        ...
    @classmethod
    def set_niagara_array_color(cls, niagara_system: NiagaraComponent, override_name: Name, array_data: Array[LinearColor]) -> None:
        r"""
        X.set_niagara_array_color(niagara_system, override_name, array_data) -> None
        Sets Niagara Array FLinearColor Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            array_data (Array[LinearColor]):
        """
        ...
    @classmethod
    def set_niagara_array_bool_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, value: bool, size_to_fit: bool) -> None:
        r"""
        X.set_niagara_array_bool_value(niagara_system, override_name, index, value, size_to_fit) -> None
        Sets a single value within a Niagara Array Bool.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            value (bool): 
            size_to_fit (bool):
        """
        ...
    @classmethod
    def set_niagara_array_bool(cls, niagara_system: NiagaraComponent, override_name: Name, array_data: Array[bool]) -> None:
        r"""
        X.set_niagara_array_bool(niagara_system, override_name, array_data) -> None
        Sets Niagara Array Bool Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            array_data (Array[bool]):
        """
        ...
    @classmethod
    def get_niagara_array_vector_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int) -> Vector:
        r"""
        X.get_niagara_array_vector_value(niagara_system, override_name, index) -> Vector
        Gets a single value within a Niagara Array FVector.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_niagara_array_vector4_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int) -> Vector4:
        r"""
        X.get_niagara_array_vector4_value(niagara_system, override_name, index) -> Vector4
        Gets a single value within a Niagara Array FVector4.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
        
        Returns:
            Vector4:
        """
        ...
    @classmethod
    def get_niagara_array_vector4(cls, niagara_system: NiagaraComponent, override_name: Name) -> Array[Vector4]:
        r"""
        X.get_niagara_array_vector4(niagara_system, override_name) -> Array[Vector4]
        Gets a copy of Niagara FVector4 Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
        
        Returns:
            Array[Vector4]:
        """
        ...
    @classmethod
    def get_niagara_array_vector2d_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int) -> Vector2D:
        r"""
        X.get_niagara_array_vector2d_value(niagara_system, override_name, index) -> Vector2D
        Gets a single value within a Niagara Array FVector2D.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def get_niagara_array_vector2d(cls, niagara_system: NiagaraComponent, override_name: Name) -> Array[Vector2D]:
        r"""
        X.get_niagara_array_vector2d(niagara_system, override_name) -> Array[Vector2D]
        Gets a copy of Niagara FVector2D Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
        
        Returns:
            Array[Vector2D]:
        """
        ...
    @classmethod
    def get_niagara_array_vector(cls, niagara_system: NiagaraComponent, override_name: Name) -> Array[Vector]:
        r"""
        X.get_niagara_array_vector(niagara_system, override_name) -> Array[Vector]
        Gets a copy of Niagara FVector Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
        
        Returns:
            Array[Vector]:
        """
        ...
    @classmethod
    def get_niagara_array_u_int8_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int) -> int:
        r"""
        X.get_niagara_array_u_int8_value(niagara_system, override_name, index) -> int32
        Gets a single value within a Niagara Array UInt8.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_niagara_array_u_int8(cls, niagara_system: NiagaraComponent, override_name: Name) -> Array[int]:
        r"""
        X.get_niagara_array_u_int8(niagara_system, override_name) -> Array[int32]
        Gets a copy of Niagara UInt8 Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
        
        Returns:
            Array[int32]:
        """
        ...
    @classmethod
    def get_niagara_array_quat_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int) -> Quat:
        r"""
        X.get_niagara_array_quat_value(niagara_system, override_name, index) -> Quat
        Gets a single value within a Niagara Array FQuat.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
        
        Returns:
            Quat:
        """
        ...
    @classmethod
    def get_niagara_array_quat(cls, niagara_system: NiagaraComponent, override_name: Name) -> Array[Quat]:
        r"""
        X.get_niagara_array_quat(niagara_system, override_name) -> Array[Quat]
        Gets a copy of Niagara FQuat Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
        
        Returns:
            Array[Quat]:
        """
        ...
    @classmethod
    def get_niagara_array_position_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int) -> Vector:
        r"""
        X.get_niagara_array_position_value(niagara_system, override_name, index) -> Vector
        Gets a single value within a Niagara Array Position.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_niagara_array_position(cls, niagara_system: NiagaraComponent, override_name: Name) -> Array[Vector]:
        r"""
        X.get_niagara_array_position(niagara_system, override_name) -> Array[Vector]
        Gets a copy of Niagara Position Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
        
        Returns:
            Array[Vector]:
        """
        ...
    @classmethod
    def get_niagara_array_matrix_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int, apply_lwc_rebase: bool = True) -> Matrix:
        r"""
        X.get_niagara_array_matrix_value(niagara_system, override_name, index, apply_lwc_rebase=True) -> Matrix
        Gets a single value within a Niagara Array FMatrix.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
            apply_lwc_rebase (bool): When enabled the matrix translation will have the simulation tile offset added to it
        
        Returns:
            Matrix:
        """
        ...
    @classmethod
    def get_niagara_array_matrix(cls, niagara_system: NiagaraComponent, override_name: Name, apply_lwc_rebase: bool = True) -> Array[Matrix]:
        r"""
        X.get_niagara_array_matrix(niagara_system, override_name, apply_lwc_rebase=True) -> Array[Matrix]
        Gets a copy of Niagara FMatrix Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            apply_lwc_rebase (bool): When enabled the matrix translation will have the simulation tile offset added to it
        
        Returns:
            Array[Matrix]:
        """
        ...
    @classmethod
    def get_niagara_array_int32_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int) -> int:
        r"""
        X.get_niagara_array_int32_value(niagara_system, override_name, index) -> int32
        Gets a single value within a Niagara Array Int32.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_niagara_array_int32(cls, niagara_system: NiagaraComponent, override_name: Name) -> Array[int]:
        r"""
        X.get_niagara_array_int32(niagara_system, override_name) -> Array[int32]
        Gets a copy of Niagara Int32 Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
        
        Returns:
            Array[int32]:
        """
        ...
    @classmethod
    def get_niagara_array_float_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int) -> float:
        r"""
        X.get_niagara_array_float_value(niagara_system, override_name, index) -> float
        Gets a single value within a Niagara Array Float.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_niagara_array_float(cls, niagara_system: NiagaraComponent, override_name: Name) -> Array[float]:
        r"""
        X.get_niagara_array_float(niagara_system, override_name) -> Array[float]
        Gets a copy of Niagara Float Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
        
        Returns:
            Array[float]:
        """
        ...
    @classmethod
    def get_niagara_array_color_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int) -> LinearColor:
        r"""
        X.get_niagara_array_color_value(niagara_system, override_name, index) -> LinearColor
        Gets a single value within a Niagara Array FLinearColor.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def get_niagara_array_color(cls, niagara_system: NiagaraComponent, override_name: Name) -> Array[LinearColor]:
        r"""
        X.get_niagara_array_color(niagara_system, override_name) -> Array[LinearColor]
        Gets a copy of Niagara FLinearColor Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
        
        Returns:
            Array[LinearColor]:
        """
        ...
    @classmethod
    def get_niagara_array_bool_value(cls, niagara_system: NiagaraComponent, override_name: Name, index: int) -> bool:
        r"""
        X.get_niagara_array_bool_value(niagara_system, override_name, index) -> bool
        Gets a single value within a Niagara Array Bool.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            index (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_niagara_array_bool(cls, niagara_system: NiagaraComponent, override_name: Name) -> Array[bool]:
        r"""
        X.get_niagara_array_bool(niagara_system, override_name) -> Array[bool]
        Gets a copy of Niagara Bool Data.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
        
        Returns:
            Array[bool]:
        """
        ...

class NiagaraDataInterfaceArrayInt32(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array Int 32
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``int_data`` (Array[int32]):  [Read-Write]
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    """
    @property
    def int_data(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write]
        """
        ...
    @int_data.setter
    def int_data(self, value: Array[int]) -> None:
        ...

class NiagaraDataInterfaceArrayUInt8(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array UInt 8
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``int_data`` (Array[int32]):  [Read-Write]
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    """
    @property
    def int_data(self) -> Array[int]:
        r"""
        (Array[int32]):  [Read-Write]
        """
        ...
    @int_data.setter
    def int_data(self, value: Array[int]) -> None:
        ...

class NiagaraDataInterfaceArrayBool(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array Bool
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayInt.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool_data`` (Array[bool]):  [Read-Write]
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    """
    @property
    def bool_data(self) -> Array[bool]:
        r"""
        (Array[bool]):  [Read-Write]
        """
        ...
    @bool_data.setter
    def bool_data(self, value: Array[bool]) -> None:
        ...

class NiagaraDataInterfaceArrayNiagaraID(NiagaraDataInterfaceArray):
    r"""
    Niagara Data Interface Array Niagara ID
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceArrayNiagaraID.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``gpu_sync_mode`` (NiagaraGpuSyncMode):  [Read-Write] How to do we want to synchronize modifications to the array data.
    - ``int_data`` (Array[NiagaraID]):  [Read-Write]
    - ``max_elements`` (int32):  [Read-Write] When greater than 0 sets the maximum number of elements the array can hold, only relevant when using operations that modify the array size.
    """
    @property
    def int_data(self) -> Array[NiagaraID]:
        r"""
        (Array[NiagaraID]):  [Read-Write]
        """
        ...
    @int_data.setter
    def int_data(self, value: Array[NiagaraID]) -> None:
        ...

class NiagaraDataInterfaceAudioPlayerSettings(Object):
    r"""
    Niagara Data Interface Audio Player Settings
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceAudioPlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``attenuation_settings`` (SoundAttenuationSettings):  [Read-Write]
    - ``concurrency`` (SoundConcurrency):  [Read-Write]
    - ``override_attenuation_settings`` (bool):  [Read-Write]
    - ``override_concurrency`` (bool):  [Read-Write]
    """
    @property
    def override_concurrency(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_concurrency.setter
    def override_concurrency(self, value: bool) -> None:
        ...
    @property
    def concurrency(self) -> SoundConcurrency:
        r"""
        (SoundConcurrency):  [Read-Write]
        """
        ...
    @concurrency.setter
    def concurrency(self, value: SoundConcurrency) -> None:
        ...
    @property
    def override_attenuation_settings(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @override_attenuation_settings.setter
    def override_attenuation_settings(self, value: bool) -> None:
        ...
    @property
    def attenuation_settings(self) -> SoundAttenuationSettings:
        r"""
        (SoundAttenuationSettings):  [Read-Write]
        """
        ...
    @attenuation_settings.setter
    def attenuation_settings(self, value: SoundAttenuationSettings) -> None:
        ...

class NiagaraParticleCallbackHandler(Interface):
    r"""
    Niagara Particle Callback Handler
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceExport.h
    
    """
    def receive_particle_data(self, data: Array[BasicParticleData], niagara_system: NiagaraSystem, simulation_position_offset: Vector) -> None:
        r"""
        x.receive_particle_data(data, niagara_system, simulation_position_offset) -> None
        This function is called once per tick with the gathered particle data. It will not be called if there is no particle data to call it with.
        
        Args:
            data (Array[BasicParticleData]): 
            niagara_system (NiagaraSystem): 
            simulation_position_offset (Vector):
        """
        ...

class NiagaraDataInterfaceGrid2D(NiagaraDataInterfaceRWBase):
    r"""
    Niagara Data Interface Grid 2D
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceRW.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clear_before_non_iteration_stage`` (bool):  [Read-Write] Option to clear the buffer prior to a stage where the iteration count does not match the grid resolution.  Useful for stages where one wants to do sparse writes
      and accumulate values.
    - ``num_attributes`` (int32):  [Read-Write] Number of Attributes
    - ``num_cells_max_axis`` (int32):  [Read-Write] Number of cells on the longest axis
    - ``num_cells_x`` (int32):  [Read-Write] Number of cells in X
    - ``num_cells_y`` (int32):  [Read-Write] Number of cells in Y
    - ``set_grid_from_max_axis`` (bool):  [Read-Write] Set grid resolution according to longest axis
    - ``world_b_box_size`` (Vector2D):  [Read-Write] World size of the grid
    """
    ...

class NiagaraDataInterfaceGrid2DCollection(NiagaraDataInterfaceGrid2D):
    r"""
    Niagara Data Interface Grid 2DCollection
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceGrid2DCollection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clear_before_non_iteration_stage`` (bool):  [Read-Write] Option to clear the buffer prior to a stage where the iteration count does not match the grid resolution.  Useful for stages where one wants to do sparse writes
      and accumulate values.
    - ``num_attributes`` (int32):  [Read-Write] Number of Attributes
    - ``num_cells_max_axis`` (int32):  [Read-Write] Number of cells on the longest axis
    - ``num_cells_x`` (int32):  [Read-Write] Number of cells in X
    - ``num_cells_y`` (int32):  [Read-Write] Number of cells in Y
    - ``override_buffer_format`` (NiagaraGpuBufferFormat):  [Read-Write] When enabled overrides the format used to store data inside the grid, otherwise uses the project default setting.  Lower bit depth formats will save memory and performance at the cost of precision.
    - ``override_format`` (bool):  [Read-Write]
    - ``preview_attribute`` (Name):  [Read-Write] When enabled allows you to preview the grid in a debug display
    - ``preview_grid`` (bool):  [Read-Write]
    - ``render_target_user_parameter`` (NiagaraUserParameterBinding):  [Read-Write] Reference to a user parameter if we're reading one.
    - ``set_grid_from_max_axis`` (bool):  [Read-Write] Set grid resolution according to longest axis
    - ``world_b_box_size`` (Vector2D):  [Read-Write] World size of the grid
    """
    def get_texture_size(self, component: NiagaraComponent) -> Tuple[int, int]:
        r"""
        x.get_texture_size(component) -> (size_x=int32, size_y=int32)
        Get Texture Size
        
        Args:
            component (NiagaraComponent): 
        
        Returns:
            tuple: 
        
            size_x (int32): 
        
            size_y (int32):
        """
        ...
    def get_raw_texture_size(self, component: NiagaraComponent) -> Tuple[int, int]:
        r"""
        x.get_raw_texture_size(component) -> (size_x=int32, size_y=int32)
        Get Raw Texture Size
        deprecated: This function has been replaced by object user variables on the emitter to specify render targets to fill with data.
        
        Args:
            component (NiagaraComponent): 
        
        Returns:
            tuple: 
        
            size_x (int32): 
        
            size_y (int32):
        """
        ...
    def fill_texture2d(self, component: NiagaraComponent, dest: TextureRenderTarget2D, attribute_index: int) -> bool:
        r"""
        x.fill_texture2d(component, dest, attribute_index) -> bool
        Fills a texture render target 2d with the current data from the simulation
        #todo(dmp): this will eventually go away when we formalize how data makes it out of Niagara
        deprecated: This function has been replaced by object user variables on the emitter to specify render targets to fill with data.
        
        Args:
            component (NiagaraComponent): 
            dest (TextureRenderTarget2D): 
            attribute_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def fill_raw_texture2d(self, component: NiagaraComponent, dest: TextureRenderTarget2D) -> Optional[Tuple[int, int]]:
        r"""
        x.fill_raw_texture2d(component, dest) -> (tiles_x=int32, tiles_y=int32) or None
        Fill Raw Texture 2D
        deprecated: This function has been replaced by object user variables on the emitter to specify render targets to fill with data.
        
        Args:
            component (NiagaraComponent): 
            dest (TextureRenderTarget2D): 
        
        Returns:
            tuple or None: 
        
            tiles_x (int32): 
        
            tiles_y (int32):
        """
        ...

class NiagaraDataInterfaceGrid2DCollectionReader(NiagaraDataInterfaceGrid2DCollection):
    r"""
    Niagara Data Interface Grid 2DCollection Reader
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceGrid2DCollectionReader.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clear_before_non_iteration_stage`` (bool):  [Read-Write] Option to clear the buffer prior to a stage where the iteration count does not match the grid resolution.  Useful for stages where one wants to do sparse writes
      and accumulate values.
    - ``di_name`` (str):  [Read-Write] Name of the Grid2DCollection Data Interface on the emitter
    - ``emitter_name`` (str):  [Read-Write] Name of the emitter to read from
    - ``num_attributes`` (int32):  [Read-Write] Number of Attributes
    - ``num_cells_max_axis`` (int32):  [Read-Write] Number of cells on the longest axis
    - ``num_cells_x`` (int32):  [Read-Write] Number of cells in X
    - ``num_cells_y`` (int32):  [Read-Write] Number of cells in Y
    - ``override_buffer_format`` (NiagaraGpuBufferFormat):  [Read-Write] When enabled overrides the format used to store data inside the grid, otherwise uses the project default setting.  Lower bit depth formats will save memory and performance at the cost of precision.
    - ``override_format`` (bool):  [Read-Write]
    - ``preview_attribute`` (Name):  [Read-Write] When enabled allows you to preview the grid in a debug display
    - ``preview_grid`` (bool):  [Read-Write]
    - ``render_target_user_parameter`` (NiagaraUserParameterBinding):  [Read-Write] Reference to a user parameter if we're reading one.
    - ``set_grid_from_max_axis`` (bool):  [Read-Write] Set grid resolution according to longest axis
    - ``world_b_box_size`` (Vector2D):  [Read-Write] World size of the grid
    """
    ...

class NiagaraDataInterfaceGrid3D(NiagaraDataInterfaceRWBase):
    r"""
    Niagara Data Interface Grid 3D
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceRW.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cell_size`` (float):  [Read-Write] World space size of a cell
    - ``clear_before_non_iteration_stage`` (bool):  [Read-Write] Option to clear the buffer prior to a stage where the iteration count does not match the grid resolution.  Useful for stages where one wants to do sparse writes
      and accumulate values.
    - ``num_cells`` (IntVector):  [Read-Write] Number of cells
    - ``num_cells_max_axis`` (int32):  [Read-Write] Number of cells on the longest axis
    - ``set_resolution_method`` (SetResolutionMethod):  [Read-Write] Method for setting the grid resolution
    - ``world_b_box_size`` (Vector):  [Read-Write] World size of the grid
    """
    ...

class NiagaraDataInterfaceGrid3DCollection(NiagaraDataInterfaceGrid3D):
    r"""
    Niagara Data Interface Grid 3DCollection
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceGrid3DCollection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cell_size`` (float):  [Read-Write] World space size of a cell
    - ``clear_before_non_iteration_stage`` (bool):  [Read-Write] Option to clear the buffer prior to a stage where the iteration count does not match the grid resolution.  Useful for stages where one wants to do sparse writes
      and accumulate values.
    - ``num_attributes`` (int32):  [Read-Write] Number of attributes stored on the grid
    - ``num_cells`` (IntVector):  [Read-Write] Number of cells
    - ``num_cells_max_axis`` (int32):  [Read-Write] Number of cells on the longest axis
    - ``override_buffer_format`` (NiagaraGpuBufferFormat):  [Read-Write] When enabled overrides the format used to store data inside the grid, otherwise uses the project default setting.  Lower bit depth formats will save memory and performance at the cost of precision.
    - ``override_format`` (bool):  [Read-Write]
    - ``preview_attribute`` (Name):  [Read-Write] When enabled allows you to preview the grid in a debug display
    - ``preview_grid`` (bool):  [Read-Write]
    - ``render_target_user_parameter`` (NiagaraUserParameterBinding):  [Read-Write] Reference to a user parameter if we're reading one.
    - ``set_resolution_method`` (SetResolutionMethod):  [Read-Write] Method for setting the grid resolution
    - ``world_b_box_size`` (Vector):  [Read-Write] World size of the grid
    """
    def get_texture_size(self, component: NiagaraComponent) -> Tuple[int, int, int]:
        r"""
        x.get_texture_size(component) -> (size_x=int32, size_y=int32, size_z=int32)
        Get Texture Size
        
        Args:
            component (NiagaraComponent): 
        
        Returns:
            tuple: 
        
            size_x (int32): 
        
            size_y (int32): 
        
            size_z (int32):
        """
        ...
    def get_raw_texture_size(self, component: NiagaraComponent) -> Tuple[int, int, int]:
        r"""
        x.get_raw_texture_size(component) -> (size_x=int32, size_y=int32, size_z=int32)
        Get Raw Texture Size
        
        Args:
            component (NiagaraComponent): 
        
        Returns:
            tuple: 
        
            size_x (int32): 
        
            size_y (int32): 
        
            size_z (int32):
        """
        ...
    def fill_volume_texture(self, component: NiagaraComponent, dest: VolumeTexture, attribute_index: int) -> bool:
        r"""
        x.fill_volume_texture(component, dest, attribute_index) -> bool
        Fills a texture render target 2d with the current data from the simulation
        #todo(dmp): this will eventually go away when we formalize how data makes it out of Niagara
        #todo(dmp): reimplement for 3d
        deprecated: This function has been replaced by object user variables on the emitter to specify render targets to fill with data.
        
        Args:
            component (NiagaraComponent): 
            dest (VolumeTexture): 
            attribute_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def fill_raw_volume_texture(self, component: NiagaraComponent, dest: VolumeTexture) -> Optional[Tuple[int, int, int]]:
        r"""
        x.fill_raw_volume_texture(component, dest) -> (tiles_x=int32, tiles_y=int32, tile_z=int32) or None
        Fill Raw Volume Texture
        deprecated: This function has been replaced by object user variables on the emitter to specify render targets to fill with data.
        
        Args:
            component (NiagaraComponent): 
            dest (VolumeTexture): 
        
        Returns:
            tuple or None: 
        
            tiles_x (int32): 
        
            tiles_y (int32): 
        
            tile_z (int32):
        """
        ...

class NiagaraDataInterfaceGrid3DCollectionReader(NiagaraDataInterfaceGrid3DCollection):
    r"""
    Niagara Data Interface Grid 3DCollection Reader
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceGrid3DCollectionReader.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cell_size`` (float):  [Read-Write] World space size of a cell
    - ``clear_before_non_iteration_stage`` (bool):  [Read-Write] Option to clear the buffer prior to a stage where the iteration count does not match the grid resolution.  Useful for stages where one wants to do sparse writes
      and accumulate values.
    - ``di_name`` (str):  [Read-Write] Name of the Grid2DCollection Data Interface on the emitter
    - ``emitter_name`` (str):  [Read-Write] Name of the emitter to read from
    - ``num_attributes`` (int32):  [Read-Write] Number of attributes stored on the grid
    - ``num_cells`` (IntVector):  [Read-Write] Number of cells
    - ``num_cells_max_axis`` (int32):  [Read-Write] Number of cells on the longest axis
    - ``override_buffer_format`` (NiagaraGpuBufferFormat):  [Read-Write] When enabled overrides the format used to store data inside the grid, otherwise uses the project default setting.  Lower bit depth formats will save memory and performance at the cost of precision.
    - ``override_format`` (bool):  [Read-Write]
    - ``preview_attribute`` (Name):  [Read-Write] When enabled allows you to preview the grid in a debug display
    - ``preview_grid`` (bool):  [Read-Write]
    - ``render_target_user_parameter`` (NiagaraUserParameterBinding):  [Read-Write] Reference to a user parameter if we're reading one.
    - ``set_resolution_method`` (SetResolutionMethod):  [Read-Write] Method for setting the grid resolution
    - ``world_b_box_size`` (Vector):  [Read-Write] World size of the grid
    """
    ...

class NiagaraDataInterfaceIntRenderTarget2D(NiagaraDataInterfaceRWBase):
    r"""
    Niagara Data Interface Int Render Target 2D
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceIntRenderTarget2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``preview_display_range`` (Vector2D):  [Read-Write] The range to normaliez the preview display to.
    - ``preview_render_target`` (bool):  [Read-Write]
    - ``render_target_user_parameter`` (NiagaraUserParameterBinding):  [Read-Write] When valid the user parameter is used as the render target rather than creating one internal, note that the input render target will be adjusted by the Niagara simulation
    - ``size`` (IntPoint):  [Read-Write]
    """
    ...

class NiagaraDataInterfaceRenderTarget2D(NiagaraDataInterfaceRWBase):
    r"""
    Niagara Data Interface Render Target 2D
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceRenderTarget2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``inherit_user_parameter_settings`` (bool):  [Read-Write] When enabled texture parameters (size / etc) are taken from the user provided render target.
      If no valid user parameter is set the system will be invalid.
      Note: The resource will be recreated if UAV access is not available, which will reset the contents.
    - ``mip_map_generation`` (NiagaraMipMapGeneration):  [Read-Write] Controls if and when we generate mips for the render target.
    - ``mip_map_generation_type`` (NiagaraMipMapGenerationType):  [Read-Write]
    - ``override_format`` (bool):  [Read-Write]
    - ``override_render_target_filter`` (TextureFilter):  [Read-Write] When enabled overrides the filter of the render target, otherwise uses the project default setting.
    - ``override_render_target_format`` (TextureRenderTargetFormat):  [Read-Write] When enabled overrides the format of the render target, otherwise uses the project default setting.
    - ``preview_render_target`` (bool):  [Read-Write]
    - ``render_target_user_parameter`` (NiagaraUserParameterBinding):  [Read-Write] When valid the user parameter is used as the render target rather than creating one internal, note that the input render target will be adjusted by the Niagara simulation
    - ``size`` (IntPoint):  [Read-Write]
    """
    ...

class NiagaraDataInterfaceRenderTarget2DArray(NiagaraDataInterfaceRWBase):
    r"""
    Niagara Data Interface Render Target 2DArray
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceRenderTarget2DArray.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``inherit_user_parameter_settings`` (bool):  [Read-Write] When enabled texture parameters (size / etc) are taken from the user provided render target.
      If no valid user parameter is set the system will be invalid.
      Note: The resource will be recreated if UAV access is not available, which will reset the contents.
    - ``override_format`` (bool):  [Read-Write]
    - ``override_render_target_filter`` (TextureFilter):  [Read-Write] When enabled overrides the filter of the render target, otherwise uses the project default setting.
    - ``override_render_target_format`` (TextureRenderTargetFormat):  [Read-Write] When enabled overrides the format of the render target, otherwise uses the project default setting.
    - ``preview_render_target`` (bool):  [Read-Write]
    - ``render_target_user_parameter`` (NiagaraUserParameterBinding):  [Read-Write] When valid the user parameter is used as the render target rather than creating one internal, note that the input render target will be adjusted by the Niagara simulation
    - ``size`` (IntVector):  [Read-Write]
    """
    ...

class NiagaraDataInterfaceRenderTargetCube(NiagaraDataInterfaceRWBase):
    r"""
    Niagara Data Interface Render Target Cube
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceRenderTargetCube.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``inherit_user_parameter_settings`` (bool):  [Read-Write] When enabled texture parameters (size / etc) are taken from the user provided render target.
      If no valid user parameter is set the system will be invalid.
      Note: The resource will be recreated if UAV access is not available, which will reset the contents.
    - ``override_format`` (bool):  [Read-Write]
    - ``override_render_target_filter`` (TextureFilter):  [Read-Write] When enabled overrides the filter of the render target, otherwise uses the project default setting.
    - ``override_render_target_format`` (TextureRenderTargetFormat):  [Read-Write] When enabled overrides the format of the render target, otherwise uses the project default setting.
    - ``preview_render_target`` (bool):  [Read-Write]
    - ``render_target_user_parameter`` (NiagaraUserParameterBinding):  [Read-Write] When valid the user parameter is used as the render target rather than creating one internal, note that the input render target will be adjusted by the Niagara simulation
    - ``size`` (int32):  [Read-Write]
    """
    ...

class NiagaraDataInterfaceRenderTargetVolume(NiagaraDataInterfaceRWBase):
    r"""
    Niagara Data Interface Render Target Volume
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceRenderTargetVolume.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``inherit_user_parameter_settings`` (bool):  [Read-Write] When enabled texture parameters (size / etc) are taken from the user provided render target.
      If no valid user parameter is set the system will be invalid.
      Note: The resource will be recreated if UAV access is not available, which will reset the contents.
    - ``override_format`` (bool):  [Read-Write]
    - ``override_render_target_filter`` (TextureFilter):  [Read-Write] When enabled overrides the filter of the render target, otherwise uses the project default setting.
    - ``override_render_target_format`` (TextureRenderTargetFormat):  [Read-Write] When enabled overrides the format of the render target, otherwise uses the project default setting.
    - ``preview_render_target`` (bool):  [Read-Write]
    - ``render_target_user_parameter`` (NiagaraUserParameterBinding):  [Read-Write] When valid the user parameter is used as the render target rather than creating one internal, note that the input render target will be adjusted by the Niagara simulation
    - ``size`` (IntVector):  [Read-Write]
    """
    ...

class NiagaraDIRigidMeshCollisionFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    C++ and Blueprint library for accessing array types
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataInterfaceRigidMeshCollisionQuery.h
    
    """
    @classmethod
    def set_source_actors(cls, niagara_system: NiagaraComponent, override_name: Name, source_actors: Array[Actor]) -> None:
        r"""
        X.set_source_actors(niagara_system, override_name, source_actors) -> None
        Set Source Actors
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (Name): 
            source_actors (Array[Actor]):
        """
        ...

class NiagaraFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    A C++ and Blueprint accessible library of utility functions for accessing Niagara simulations
    All positions & orientations are returned in Unreal reference frame & units, assuming the Leap device is located at the origin.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraFunctionLibrary.h
    
    """
    @classmethod
    def spawn_system_attached_with_params(cls, spawn_params: FXSystemSpawnParameters) -> NiagaraComponent:
        r"""
        X.spawn_system_attached_with_params(spawn_params) -> NiagaraComponent
        Spawn System Attached with Params
        
        Args:
            spawn_params (FXSystemSpawnParameters): 
        
        Returns:
            NiagaraComponent:
        """
        ...
    @classmethod
    def spawn_system_attached(cls, system_template: NiagaraSystem, attach_to_component: SceneComponent, attach_point_name: Name, location: Vector, rotation: Rotator, location_type: AttachLocation, auto_destroy: bool, auto_activate: bool = True, pooling_method: NCPoolMethod = NCPoolMethod.NONE, pre_cull_check: bool = True) -> NiagaraComponent:
        r"""
        X.spawn_system_attached(system_template, attach_to_component, attach_point_name, location, rotation, location_type, auto_destroy, auto_activate=True, pooling_method=NCPoolMethod.NONE, pre_cull_check=True) -> NiagaraComponent
        Spawn System Attached
        
        Args:
            system_template (NiagaraSystem): 
            attach_to_component (SceneComponent): 
            attach_point_name (Name): 
            location (Vector): 
            rotation (Rotator): 
            location_type (AttachLocation): 
            auto_destroy (bool): 
            auto_activate (bool): 
            pooling_method (NCPoolMethod): 
            pre_cull_check (bool): 
        
        Returns:
            NiagaraComponent:
        """
        ...
    @classmethod
    def spawn_system_at_location_with_params(cls, spawn_params: FXSystemSpawnParameters) -> NiagaraComponent:
        r"""
        X.spawn_system_at_location_with_params(spawn_params) -> NiagaraComponent
        Spawn System at Location with Params
        
        Args:
            spawn_params (FXSystemSpawnParameters): 
        
        Returns:
            NiagaraComponent:
        """
        ...
    @classmethod
    def spawn_system_at_location(cls, world_context_object: Object, system_template: NiagaraSystem, location: Vector, rotation: Rotator = [0.000000, 0.000000, 0.000000], scale: Vector = [1.000000, 1.000000, 1.000000], auto_destroy: bool = True, auto_activate: bool = True, pooling_method: NCPoolMethod = NCPoolMethod.NONE, pre_cull_check: bool = True) -> NiagaraComponent:
        r"""
        X.spawn_system_at_location(world_context_object, system_template, location, rotation=[0.000000, 0.000000, 0.000000], scale=[1.000000, 1.000000, 1.000000], auto_destroy=True, auto_activate=True, pooling_method=NCPoolMethod.NONE, pre_cull_check=True) -> NiagaraComponent
        Spawns a Niagara System at the specified world location/rotation
        
        Args:
            world_context_object (Object): 
            system_template (NiagaraSystem): 
            location (Vector): 
            rotation (Rotator): 
            scale (Vector): 
            auto_destroy (bool): 
            auto_activate (bool): 
            pooling_method (NCPoolMethod): 
            pre_cull_check (bool): 
        
        Returns:
            NiagaraComponent: The spawned UNiagaraComponent
        """
        ...
    @classmethod
    def set_volume_texture_object(cls, niagara_system: NiagaraComponent, override_name: str, texture: VolumeTexture) -> None:
        r"""
        X.set_volume_texture_object(niagara_system, override_name, texture) -> None
        Overrides the Volume Texture for a Niagara Volume Texture Data Interface User Parameter.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (str): 
            texture (VolumeTexture):
        """
        ...
    @classmethod
    def set_texture_object(cls, niagara_system: NiagaraComponent, override_name: str, texture: Texture) -> None:
        r"""
        X.set_texture_object(niagara_system, override_name, texture) -> None
        Overrides the Texture Object for a Niagara Texture Data Interface User Parameter.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (str): 
            texture (Texture):
        """
        ...
    @classmethod
    def set_texture2d_array_object(cls, niagara_system: NiagaraComponent, override_name: str, texture: Texture2DArray) -> None:
        r"""
        X.set_texture2d_array_object(niagara_system, override_name, texture) -> None
        Overrides the 2D Array Texture for a Niagara 2D Array Texture Data Interface User Parameter.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (str): 
            texture (Texture2DArray):
        """
        ...
    @classmethod
    def set_skeletal_mesh_data_interface_sampling_regions(cls, niagara_system: NiagaraComponent, override_name: str, sampling_regions: Array[Name]) -> None:
        r"""
        X.set_skeletal_mesh_data_interface_sampling_regions(niagara_system, override_name, sampling_regions) -> None
        Sets the SamplingRegion to use on the skeletal mesh data interface, this is destructive as it modifies the data interface.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (str): 
            sampling_regions (Array[Name]):
        """
        ...
    @classmethod
    def set_skeletal_mesh_data_interface_filtered_sockets(cls, niagara_system: NiagaraComponent, override_name: str, filtered_sockets: Array[Name]) -> None:
        r"""
        X.set_skeletal_mesh_data_interface_filtered_sockets(niagara_system, override_name, filtered_sockets) -> None
        Sets the Filtered Sockets to use on the skeletal mesh data interface, this is destructive as it modifies the data interface.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (str): 
            filtered_sockets (Array[Name]):
        """
        ...
    @classmethod
    def set_skeletal_mesh_data_interface_filtered_bones(cls, niagara_system: NiagaraComponent, override_name: str, filtered_bones: Array[Name]) -> None:
        r"""
        X.set_skeletal_mesh_data_interface_filtered_bones(niagara_system, override_name, filtered_bones) -> None
        Sets the Filtered Bones to use on the skeletal mesh data interface, this is destructive as it modifies the data interface.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (str): 
            filtered_bones (Array[Name]):
        """
        ...
    @classmethod
    def set_component_niagara_gpu_ray_traced_collision_group(cls, world_context_object: Object, primitive: PrimitiveComponent, collision_group: int) -> None:
        r"""
        X.set_component_niagara_gpu_ray_traced_collision_group(world_context_object, primitive, collision_group) -> None
        Sets the Niagara GPU ray traced collision group for the give primitive component.
        
        Args:
            world_context_object (Object): 
            primitive (PrimitiveComponent): 
            collision_group (int32):
        """
        ...
    @classmethod
    def set_actor_niagara_gpu_ray_traced_collision_group(cls, world_context_object: Object, actor: Actor, collision_group: int) -> None:
        r"""
        X.set_actor_niagara_gpu_ray_traced_collision_group(world_context_object, actor, collision_group) -> None
        Sets the Niagara GPU ray traced collision group for all primitive components on the given actor.
        
        Args:
            world_context_object (Object): 
            actor (Actor): 
            collision_group (int32):
        """
        ...
    @classmethod
    def release_niagara_gpu_ray_traced_collision_group(cls, world_context_object: Object, collision_group: int) -> None:
        r"""
        X.release_niagara_gpu_ray_traced_collision_group(world_context_object, collision_group) -> None
        Releases a collision group back to the system for use by ohers.
        
        Args:
            world_context_object (Object): 
            collision_group (int32):
        """
        ...
    @classmethod
    def override_system_user_variable_static_mesh_component(cls, niagara_system: NiagaraComponent, override_name: str, static_mesh_component: StaticMeshComponent) -> None:
        r"""
        X.override_system_user_variable_static_mesh_component(niagara_system, override_name, static_mesh_component) -> None
        Sets a Niagara StaticMesh parameter by name, overriding locally if necessary.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (str): 
            static_mesh_component (StaticMeshComponent):
        """
        ...
    @classmethod
    def override_system_user_variable_static_mesh(cls, niagara_system: NiagaraComponent, override_name: str, static_mesh: StaticMesh) -> None:
        r"""
        X.override_system_user_variable_static_mesh(niagara_system, override_name, static_mesh) -> None
        Override System User Variable Static Mesh
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (str): 
            static_mesh (StaticMesh):
        """
        ...
    @classmethod
    def override_system_user_variable_skeletal_mesh_component(cls, niagara_system: NiagaraComponent, override_name: str, skeletal_mesh_component: SkeletalMeshComponent) -> None:
        r"""
        X.override_system_user_variable_skeletal_mesh_component(niagara_system, override_name, skeletal_mesh_component) -> None
        Sets a Niagara StaticMesh parameter by name, overriding locally if necessary.
        
        Args:
            niagara_system (NiagaraComponent): 
            override_name (str): 
            skeletal_mesh_component (SkeletalMeshComponent):
        """
        ...
    @classmethod
    def get_niagara_parameter_collection(cls, world_context_object: Object, collection: NiagaraParameterCollection) -> NiagaraParameterCollectionInstance:
        r"""
        X.get_niagara_parameter_collection(world_context_object, collection) -> NiagaraParameterCollectionInstance
        This is gonna be totally reworked
               UFUNCTION(BlueprintCallable, Category = Niagara, meta = (Keywords = "niagara System", UnsafeDuringActorConstruction = "true"))
               static void SetUpdateScriptConstant(UNiagaraComponent* Component, FName EmitterName, FName ConstantName, FVector Value);
        
        Args:
            world_context_object (Object): 
            collection (NiagaraParameterCollection): 
        
        Returns:
            NiagaraParameterCollectionInstance:
        """
        ...
    @classmethod
    def acquire_niagara_gpu_ray_traced_collision_group(cls, world_context_object: Object) -> int:
        r"""
        X.acquire_niagara_gpu_ray_traced_collision_group(world_context_object) -> int32
        Returns a free collision group for use in HWRT collision group filtering. Returns -1 on failure.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            int32:
        """
        ...

class NiagaraLensEffectBase(NiagaraActor):
    r"""
    Niagara equivalent of AEmitterCameraLensEffectBase.
    This class is supported by APlayerCameraManager (via ICameraLensEffectInterface) as a camera lens effect.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraLensEffectBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_multiple_instances`` (bool):  [Read-Write] Are multiple instances of the effect allowed?
      When disabled, a single instance of the effect may be retriggered!
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``base_authored_fov`` (float):  [Read-Write] FOVs that differ from this may cause adjustments in positioning.
      This is the FOV which the effect was tested with.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``desired_relative_transform`` (Transform):  [Read-Write] Relative offset from the camera (where X is out from the camera)
      Might be changed slightly when the FOV is different than expected.
    - ``emitters_to_treat_as_same`` (Array[type(Class)]):  [Read-Write] If an effect class in this array is currently playing, do not play this effect.
      Useful for preventing multiple similar or expensive camera effects from playing simultaneously.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``niagara_component`` (NiagaraComponent):  [Read-Only] Pointer to System component
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``reset_when_retriggered`` (bool):  [Read-Write] When an instance of this effect is retriggered (because more than one instance is not allowed)
      should the particle system be explicitly reset? Activate(bReset = true);
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    def get_primary_particle_component(self) -> FXSystemComponent:
        r"""
        x.get_primary_particle_component() -> FXSystemComponent
        Get Primary Particle Component
        
        Returns:
            FXSystemComponent:
        """
        ...
    def get_particle_components(self) -> Array[FXSystemComponent]:
        r"""
        x.get_particle_components() -> Array[FXSystemComponent]
        Get Particle Components
        
        Returns:
            Array[FXSystemComponent]:
        """
        ...

class NiagaraLightRendererProperties(NiagaraRendererProperties):
    r"""
    Niagara Light Renderer Properties
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraLightRendererProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``affects_translucency`` (bool):  [Read-Write] Whether lights from this renderer should affect translucency.
      Use with caution - if enabled, create only a few particle lights at most, and the smaller they are, the less they will cost.
    - ``allow_in_cull_proxies`` (bool):  [Read-Write]
    - ``alpha_scales_brightness`` (bool):  [Read-Write] When checked, will treat the alpha value of the particle's color as a multiplier of the light's brightness.
    - ``color_add`` (Vector3f):  [Read-Write] A static color shift applied to each rendered light
    - ``color_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for light color when generating lights?
    - ``default_exponent`` (float):  [Read-Write] The exponent to use for all lights if no exponent binding was found
    - ``inverse_exposure_blend`` (float):  [Read-Write] Blend Factor used to blend between Intensity and Intensity/Exposure.
      This is useful for gameplay lights that should have constant brighness on screen independent of current exposure.
      This feature can cause issues with exposure particularly when used on the primary light on a scene, as such it's usage should be limited.
    - ``light_exponent_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for the light's exponent when inverse squared falloff is disabled?
    - ``light_rendering_enabled_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use to check if light rendering should be enabled for a particle? This can be used to control the spawn-rate on a per-particle basis.
    - ``motion_vector_setting`` (NiagaraRendererMotionVectorSetting):  [Read-Write] Hint about how to generate motion (velocity) vectors for this renderer.
    - ``override_inverse_exposure_blend`` (bool):  [Read-Write] When enabled we will override the project default setting with our local setting.
    - ``platforms`` (NiagaraPlatformSet):  [Read-Write] Platforms on which this renderer is enabled.
    - ``position_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for position when generating lights?
    - ``radius_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for light radius when generating lights?
    - ``radius_scale`` (float):  [Read-Write] A factor used to scale each particle light radius
    - ``renderer_enabled_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Binding to control if the renderer is enabled or disabled.
      When disabled the renderer does not generate or render any particle data.
      When disabled via a static bool the renderer will be removed in cooked content.
    - ``renderer_visibility`` (int32):  [Read-Write] If a render visibility tag is present, particles whose tag matches this value will be visible in this renderer.
    - ``renderer_visibility_tag_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for the renderer visibility tag?
    - ``sort_order_hint`` (int32):  [Read-Write] By default, emitters are drawn in the order that they are added to the system. This value will allow you to control the order in a more fine-grained manner.
            Materials of the same type (i.e. Transparent) will draw in order from lowest to highest within the system. The default value is 0.
    - ``source_mode`` (NiagaraRendererSourceDataMode):  [Read-Write] Whether or not to draw a single element for the Emitter or to draw the particles.
    - ``specular_scale`` (float):  [Read-Write] The specular scale to use for all lights if no binding was found
    - ``specular_scale_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for the specular scale when generating lights?
    - ``use_inverse_squared_falloff`` (bool):  [Read-Write] Whether to use physically based inverse squared falloff from the light.  If unchecked, the value from the LightExponent binding will be used instead.
    - ``volumetric_scattering_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for the intensity of the volumetric scattering from this light? This scales the light's intensity and color.
    """
    @property
    def inverse_exposure_blend(self) -> float:
        r"""
        (float):  [Read-Only] Blend Factor used to blend between Intensity and Intensity/Exposure.
        This is useful for gameplay lights that should have constant brighness on screen independent of current exposure.
        This feature can cause issues with exposure particularly when used on the primary light on a scene, as such it's usage should be limited.
        """
        ...

class NiagaraParameterCollectionInstance(Object):
    r"""
    Niagara Parameter Collection Instance
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraParameterCollection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection`` (NiagaraParameterCollection):  [Read-Write] TODO: Abstract to some interface to allow a hierarchy like UMaterialInstance?
    """
    def set_vector_parameter(self, variable_name: str, value: Vector) -> None:
        r"""
        x.set_vector_parameter(variable_name, value) -> None
        Set Vector Parameter
        
        Args:
            variable_name (str): 
            value (Vector):
        """
        ...
    def set_vector4_parameter(self, variable_name: str, value: Vector4) -> None:
        r"""
        x.set_vector4_parameter(variable_name, value) -> None
        TODO[mg]: add position setter for LWC
        
        Args:
            variable_name (str): 
            value (Vector4):
        """
        ...
    def set_vector2d_parameter(self, variable_name: str, value: Vector2D) -> None:
        r"""
        x.set_vector2d_parameter(variable_name, value) -> None
        Set Vector 2DParameter
        
        Args:
            variable_name (str): 
            value (Vector2D):
        """
        ...
    def set_quat_parameter(self, variable_name: str, value: Quat) -> None:
        r"""
        x.set_quat_parameter(variable_name, value) -> None
        Set Quat Parameter
        
        Args:
            variable_name (str): 
            value (Quat):
        """
        ...
    def set_int_parameter(self, variable_name: str, value: int) -> None:
        r"""
        x.set_int_parameter(variable_name, value) -> None
        Set Int Parameter
        
        Args:
            variable_name (str): 
            value (int32):
        """
        ...
    def set_float_parameter(self, variable_name: str, value: float) -> None:
        r"""
        x.set_float_parameter(variable_name, value) -> None
        Set Float Parameter
        
        Args:
            variable_name (str): 
            value (float):
        """
        ...
    def set_color_parameter(self, variable_name: str, value: LinearColor) -> None:
        r"""
        x.set_color_parameter(variable_name, value) -> None
        Set Color Parameter
        
        Args:
            variable_name (str): 
            value (LinearColor):
        """
        ...
    def set_bool_parameter(self, variable_name: str, value: bool) -> None:
        r"""
        x.set_bool_parameter(variable_name, value) -> None
        Set Bool Parameter
        
        Args:
            variable_name (str): 
            value (bool):
        """
        ...
    def get_vector_parameter(self, variable_name: str) -> Vector:
        r"""
        x.get_vector_parameter(variable_name) -> Vector
        Get Vector Parameter
        
        Args:
            variable_name (str): 
        
        Returns:
            Vector:
        """
        ...
    def get_vector4_parameter(self, variable_name: str) -> Vector4:
        r"""
        x.get_vector4_parameter(variable_name) -> Vector4
        Get Vector 4Parameter
        
        Args:
            variable_name (str): 
        
        Returns:
            Vector4:
        """
        ...
    def get_vector2d_parameter(self, variable_name: str) -> Vector2D:
        r"""
        x.get_vector2d_parameter(variable_name) -> Vector2D
        Get Vector 2DParameter
        
        Args:
            variable_name (str): 
        
        Returns:
            Vector2D:
        """
        ...
    def get_quat_parameter(self, variable_name: str) -> Quat:
        r"""
        x.get_quat_parameter(variable_name) -> Quat
        Get Quat Parameter
        
        Args:
            variable_name (str): 
        
        Returns:
            Quat:
        """
        ...
    def get_int_parameter(self, variable_name: str) -> int:
        r"""
        x.get_int_parameter(variable_name) -> int32
        Get Int Parameter
        
        Args:
            variable_name (str): 
        
        Returns:
            int32:
        """
        ...
    def get_float_parameter(self, variable_name: str) -> float:
        r"""
        x.get_float_parameter(variable_name) -> float
        Get Float Parameter
        
        Args:
            variable_name (str): 
        
        Returns:
            float:
        """
        ...
    def get_color_parameter(self, variable_name: str) -> LinearColor:
        r"""
        x.get_color_parameter(variable_name) -> LinearColor
        Get Color Parameter
        
        Args:
            variable_name (str): 
        
        Returns:
            LinearColor:
        """
        ...
    def get_bool_parameter(self, variable_name: str) -> bool:
        r"""
        x.get_bool_parameter(variable_name) -> bool
        Accessors from Blueprint. For now just exposing common types but ideally we can expose any somehow in future.
        
        Args:
            variable_name (str): 
        
        Returns:
            bool:
        """
        ...

class NiagaraBaselineController(Object):
    r"""
    Base class for baseline controllers. These can are responsible for spawning and manipulating the FX needed for the baseline perf tests.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPerfBaseline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``effect_type`` (NiagaraEffectType):  [Read-Write] The effect type this controller is in use by.
    - ``owner`` (NiagaraPerfBaselineActor):  [Read-Write] The owning actor for this baseline controller.
    - ``system`` (NiagaraSystem):  [Read-Write] The baseline system to spawn.
    - ``test_duration`` (float):  [Read-Write] Duration to gather performance stats for the given system.
    """
    @property
    def test_duration(self) -> float:
        r"""
        (float):  [Read-Write] Duration to gather performance stats for the given system.
        """
        ...
    @test_duration.setter
    def test_duration(self, value: float) -> None:
        ...
    @property
    def effect_type(self) -> NiagaraEffectType:
        r"""
        (NiagaraEffectType):  [Read-Only] The effect type this controller is in use by.
        """
        ...
    @property
    def owner(self) -> NiagaraPerfBaselineActor:
        r"""
        (NiagaraPerfBaselineActor):  [Read-Only] The owning actor for this baseline controller.
        """
        ...
    def on_tick_test(self) -> bool:
        r"""
        x.on_tick_test() -> bool
        Returns whether the baseline test is complete.
        
        Returns:
            bool:
        """
        ...
    def on_owner_tick(self, delta_time: float) -> None:
        r"""
        x.on_owner_tick(delta_time) -> None
        Called when the owning actor is ticked.
        
        Args:
            delta_time (float):
        """
        ...
    def on_end_test(self, stats: NiagaraPerfBaselineStats) -> None:
        r"""
        x.on_end_test(stats) -> None
        Called from the stats system on completion of the test with the final stats for the given system asset.
        
        Args:
            stats (NiagaraPerfBaselineStats):
        """
        ...
    def on_begin_test(self) -> None:
        r"""
        x.on_begin_test() -> None
        Called from the stats system when we begin gathering stats for the given System asset.
        """
        ...
    def get_system(self) -> NiagaraSystem:
        r"""
        x.get_system() -> NiagaraSystem
        Returns the System for this baseline. Will synchronously load the system if needed.
        
        Returns:
            NiagaraSystem:
        """
        ...

class NiagaraBaselineController_Basic(NiagaraBaselineController):
    r"""
    Simple controller that will just spawn the given system N times. If any instance completes, it will spawn a new one to replace it.
    Can handle simple burst or looping systems.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPerfBaseline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``effect_type`` (NiagaraEffectType):  [Read-Write] The effect type this controller is in use by.
    - ``num_instances`` (int32):  [Read-Write]
    - ``owner`` (NiagaraPerfBaselineActor):  [Read-Write] The owning actor for this baseline controller.
    - ``system`` (NiagaraSystem):  [Read-Write] The baseline system to spawn.
    - ``test_duration`` (float):  [Read-Write] Duration to gather performance stats for the given system.
    """
    ...

class NiagaraPerfBaselineActor(Actor):
    r"""
    Actor that controls how the baseline system behaves and also controls stats gathering for.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPerfBaseline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``controller`` (NiagaraBaselineController):  [Read-Write]
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``label`` (TextRenderComponent):  [Read-Write]
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class NiagaraPreviewBase(Actor):
    r"""
    Base actor for preview actors used in UNiagaraPreviewAxis.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPreviewGrid.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    def set_system(self, system: NiagaraSystem) -> None:
        r"""
        x.set_system(system) -> None
        AActor Interface End
        
        Args:
            system (NiagaraSystem):
        """
        ...
    def set_label_text(self, x_axis_text: Text, y_axis_text: Text) -> None:
        r"""
        x.set_label_text(x_axis_text, y_axis_text) -> None
        Set Label Text
        
        Args:
            x_axis_text (Text): 
            y_axis_text (Text):
        """
        ...

class NiagaraPreviewAxis(Object):
    r"""
    Base class for all preview axis types.
    NiagaraPreviewGrid uses these to control how many systems to spawn in each axis and how each system varies on that axis.
    C++ Examples are show below. You can also create these as Blueprint classes as show in the Plugin content folder.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPreviewGrid.h
    
    """
    def num(self) -> int:
        r"""
        x.num() -> int32
        Returns the number of previews for this axis.
        
        Returns:
            int32:
        """
        ...
    def apply_to_preview(self, preview_component: NiagaraComponent, preview_index: int, is_x_axis: bool) -> str:
        r"""
        x.apply_to_preview(preview_component, preview_index, is_x_axis) -> str
        Applies this axis for the preview at PreviewIndex on this axis.
        
        Args:
            preview_component (NiagaraComponent): 
            preview_index (int32): 
            is_x_axis (bool): 
        
        Returns:
            str: 
        
            out_label_text (str):
        """
        ...

class NiagaraPreviewAxis_InterpParamBase(NiagaraPreviewAxis):
    r"""
    Niagara Preview Axis Interp Param Base
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPreviewGrid.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``count`` (int32):  [Read-Write]
    - ``param`` (Name):  [Read-Write]
    """
    ...

class NiagaraPreviewAxis_InterpParamInt32(NiagaraPreviewAxis_InterpParamBase):
    r"""
    Niagara Preview Axis Interp Param Int 32
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPreviewGrid.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``count`` (int32):  [Read-Write]
    - ``max`` (int32):  [Read-Write]
    - ``min`` (int32):  [Read-Write]
    - ``param`` (Name):  [Read-Write]
    """
    ...

class NiagaraPreviewAxis_InterpParamFloat(NiagaraPreviewAxis_InterpParamBase):
    r"""
    Niagara Preview Axis Interp Param Float
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPreviewGrid.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``count`` (int32):  [Read-Write]
    - ``max`` (float):  [Read-Write]
    - ``min`` (float):  [Read-Write]
    - ``param`` (Name):  [Read-Write]
    """
    ...

class NiagaraPreviewAxis_InterpParamVector2D(NiagaraPreviewAxis_InterpParamBase):
    r"""
    Niagara Preview Axis Interp Param Vector 2D
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPreviewGrid.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``count`` (int32):  [Read-Write]
    - ``max`` (Vector2D):  [Read-Write]
    - ``min`` (Vector2D):  [Read-Write]
    - ``param`` (Name):  [Read-Write]
    """
    ...

class NiagaraPreviewAxis_InterpParamVector(NiagaraPreviewAxis_InterpParamBase):
    r"""
    Niagara Preview Axis Interp Param Vector
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPreviewGrid.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``count`` (int32):  [Read-Write]
    - ``max`` (Vector):  [Read-Write]
    - ``min`` (Vector):  [Read-Write]
    - ``param`` (Name):  [Read-Write]
    """
    ...

class NiagaraPreviewAxis_InterpParamVector4(NiagaraPreviewAxis_InterpParamBase):
    r"""
    Niagara Preview Axis Interp Param Vector 4
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPreviewGrid.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``count`` (int32):  [Read-Write]
    - ``max`` (Vector4):  [Read-Write]
    - ``min`` (Vector4):  [Read-Write]
    - ``param`` (Name):  [Read-Write]
    """
    ...

class NiagaraPreviewAxis_InterpParamLinearColor(NiagaraPreviewAxis_InterpParamBase):
    r"""
    Niagara Preview Axis Interp Param Linear Color
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPreviewGrid.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``count`` (int32):  [Read-Write]
    - ``max`` (LinearColor):  [Read-Write]
    - ``min`` (LinearColor):  [Read-Write]
    - ``param`` (Name):  [Read-Write]
    """
    ...

class NiagaraPreviewGrid(Actor):
    r"""
    Niagara Preview Grid
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraPreviewGrid.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``preview_axis_x`` (NiagaraPreviewAxis):  [Read-Write] Object controlling behavior varying on the X axis.
    - ``preview_axis_y`` (NiagaraPreviewAxis):  [Read-Write] Object controlling behavior varying on the Y axis.
    - ``preview_class`` (type(Class)):  [Read-Write] Class used to for previews in this grid.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``reset_mode`` (NiagaraPreviewGridResetMode):  [Read-Write]
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spacing_x`` (float):  [Read-Write] The default spacing between previews in X if the axis does not override it.
    - ``spacing_y`` (float):  [Read-Write] The default spacing between previews if the axis does not override it.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``system`` (NiagaraSystem):  [Read-Write]
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    def set_paused(self, paused: bool) -> None:
        r"""
        x.set_paused(paused) -> None
        Set Paused
        
        Args:
            paused (bool):
        """
        ...
    def get_previews(self) -> Array[NiagaraComponent]:
        r"""
        x.get_previews() -> Array[NiagaraComponent]
        Get Previews
        
        Returns:
            Array[NiagaraComponent]: 
        
            out_previews (Array[NiagaraComponent]):
        """
        ...
    def deactivate_previews(self) -> None:
        r"""
        x.deactivate_previews() -> None
        Deactivate Previews
        """
        ...
    def activate_previews(self, reset: bool) -> None:
        r"""
        x.activate_previews(reset) -> None
        AActor Interface End
        
        Args:
            reset (bool):
        """
        ...

class NiagaraSimCache(Object):
    r"""
    Niagara Sim Cache
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSimCache.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cache_guid`` (Guid):  [Read-Only]
    - ``duration_seconds`` (float):  [Read-Only]
    - ``soft_niagara_system`` (NiagaraSystem):  [Read-Only]
    - ``start_seconds`` (float):  [Read-Only]
    """
    def read_vector_attribute(self, attribute_name: Name, emitter_name: Name, frame_index: int = 0) -> Array[Vector]:
        r"""
        x.read_vector_attribute(attribute_name, emitter_name, frame_index=0) -> Array[Vector]
        Reads Niagara Vec3 attributes by name from the cache frame and appends them into the OutValues array.
        EmitterName - If left blank will return the system simulation attributes.
        
        Args:
            attribute_name (Name): 
            emitter_name (Name): 
            frame_index (int32): 
        
        Returns:
            Array[Vector]: 
        
            out_values (Array[Vector]):
        """
        ...
    def read_vector4_attribute(self, attribute_name: Name, emitter_name: Name, frame_index: int = 0) -> Array[Vector4]:
        r"""
        x.read_vector4_attribute(attribute_name, emitter_name, frame_index=0) -> Array[Vector4]
        Reads Niagara Vec4 attributes by name from the cache frame and appends them into the OutValues array.
        EmitterName - If left blank will return the system simulation attributes.
        
        Args:
            attribute_name (Name): 
            emitter_name (Name): 
            frame_index (int32): 
        
        Returns:
            Array[Vector4]: 
        
            out_values (Array[Vector4]):
        """
        ...
    def read_vector2_attribute(self, attribute_name: Name, emitter_name: Name, frame_index: int = 0) -> Array[Vector2D]:
        r"""
        x.read_vector2_attribute(attribute_name, emitter_name, frame_index=0) -> Array[Vector2D]
        Reads Niagara Vec2 attributes by name from the cache frame and appends them into the OutValues array.
        EmitterName - If left blank will return the system simulation attributes.
        
        Args:
            attribute_name (Name): 
            emitter_name (Name): 
            frame_index (int32): 
        
        Returns:
            Array[Vector2D]: 
        
            out_values (Array[Vector2D]):
        """
        ...
    def read_quat_attribute_with_rebase(self, quat: Quat, attribute_name: Name = "MeshOrientation", emitter_name: Name = "None", frame_index: int = 0) -> Array[Quat]:
        r"""
        x.read_quat_attribute_with_rebase(quat, attribute_name="MeshOrientation", emitter_name="None", frame_index=0) -> Array[Quat]
        Reads Niagara Quaternion attributes by name from the cache frame and appends them into the OutValues array.
        Only attributes that in the rebase list will be transform into the provided Quat space.  Therefore the cache
        must be captured with rebasing enabled to have any impact.
        EmitterName - If left blank will return the system simulation attributes.
        
        Args:
            quat (Quat): 
            attribute_name (Name): 
            emitter_name (Name): 
            frame_index (int32): 
        
        Returns:
            Array[Quat]: 
        
            out_values (Array[Quat]):
        """
        ...
    def read_quat_attribute(self, attribute_name: Name = "MeshOrientation", emitter_name: Name = "None", local_space_to_world: bool = True, frame_index: int = 0) -> Array[Quat]:
        r"""
        x.read_quat_attribute(attribute_name="MeshOrientation", emitter_name="None", local_space_to_world=True, frame_index=0) -> Array[Quat]
        Reads Niagara Quaternion attributes by name from the cache frame and appends them into the OutValues array.
        Local space emitters provide data at local rotation unless bLocalSpaceToWorld is true.
        EmitterName - If left blank will return the system simulation attributes.
        LocalSpaceToWorld - Caches are always stored in the emitters space, i.e. local or world space.  You can set this to false if you want the local Quat rather than the world Quat.
        
        Args:
            attribute_name (Name): 
            emitter_name (Name): 
            local_space_to_world (bool): 
            frame_index (int32): 
        
        Returns:
            Array[Quat]: 
        
            out_values (Array[Quat]):
        """
        ...
    def read_position_attribute_with_rebase(self, transform: Transform, attribute_name: Name = "Position", emitter_name: Name = "None", frame_index: int = 0) -> Array[Vector]:
        r"""
        x.read_position_attribute_with_rebase(transform, attribute_name="Position", emitter_name="None", frame_index=0) -> Array[Vector]
        Reads Niagara Position attributes by name from the cache frame and appends them into the OutValues array.
        All attributes read with this method will be re-based from the captured space into the provided transform space,
        this will occur even if the cache was not captured with re-basing enabled.
        EmitterName - If left blank will return the system simulation attributes.
        
        Args:
            transform (Transform): 
            attribute_name (Name): 
            emitter_name (Name): 
            frame_index (int32): 
        
        Returns:
            Array[Vector]: 
        
            out_values (Array[Vector]):
        """
        ...
    def read_position_attribute(self, attribute_name: Name = "Position", emitter_name: Name = "None", local_space_to_world: bool = True, frame_index: int = 0) -> Array[Vector]:
        r"""
        x.read_position_attribute(attribute_name="Position", emitter_name="None", local_space_to_world=True, frame_index=0) -> Array[Vector]
        Reads Niagara Position attributes by name from the cache frame and appends them into the OutValues array.
        Local space emitters provide data at local locations unless bLocalSpaceToWorld is true.
        EmitterName - If left blank will return the system simulation attributes.
        LocalSpaceToWorld - Caches are always stored in the emitters space, i.e. local or world space.  You can set this to false if you want the local position rather than the world position.
        
        Args:
            attribute_name (Name): 
            emitter_name (Name): 
            local_space_to_world (bool): 
            frame_index (int32): 
        
        Returns:
            Array[Vector]: 
        
            out_values (Array[Vector]):
        """
        ...
    def read_int_attribute(self, attribute_name: Name, emitter_name: Name, frame_index: int = 0) -> Array[int]:
        r"""
        x.read_int_attribute(attribute_name, emitter_name, frame_index=0) -> Array[int32]
        Reads Niagara int attributes by name from the cache frame and appends them into the OutValues array.
        EmitterName - If left blank will return the system simulation attributes.
        
        Args:
            attribute_name (Name): 
            emitter_name (Name): 
            frame_index (int32): 
        
        Returns:
            Array[int32]: 
        
            out_values (Array[int32]):
        """
        ...
    def read_id_attribute(self, attribute_name: Name, emitter_name: Name, frame_index: int = 0) -> Array[NiagaraID]:
        r"""
        x.read_id_attribute(attribute_name, emitter_name, frame_index=0) -> Array[NiagaraID]
        Reads Niagara ID attributes by name from the cache frame and appends them into the OutValues array.
        EmitterName - If left blank will return the system simulation attributes.
        
        Args:
            attribute_name (Name): 
            emitter_name (Name): 
            frame_index (int32): 
        
        Returns:
            Array[NiagaraID]: 
        
            out_values (Array[NiagaraID]):
        """
        ...
    def read_float_attribute(self, attribute_name: Name, emitter_name: Name, frame_index: int = 0) -> Array[float]:
        r"""
        x.read_float_attribute(attribute_name, emitter_name, frame_index=0) -> Array[float]
        Reads Niagara float attributes by name from the cache frame and appends them into the OutValues array.
        EmitterName - If left blank will return the system simulation attributes.
        
        Args:
            attribute_name (Name): 
            emitter_name (Name): 
            frame_index (int32): 
        
        Returns:
            Array[float]: 
        
            out_values (Array[float]):
        """
        ...
    def read_color_attribute(self, attribute_name: Name = "Color", emitter_name: Name = "None", frame_index: int = 0) -> Array[LinearColor]:
        r"""
        x.read_color_attribute(attribute_name="Color", emitter_name="None", frame_index=0) -> Array[LinearColor]
        Reads Niagara Color attributes by name from the cache frame and appends them into the OutValues array.
        EmitterName - If left blank will return the system simulation attributes.
        
        Args:
            attribute_name (Name): 
            emitter_name (Name): 
            frame_index (int32): 
        
        Returns:
            Array[LinearColor]: 
        
            out_values (Array[LinearColor]):
        """
        ...
    def is_empty(self) -> bool:
        r"""
        x.is_empty() -> bool
        An empty cache contains no frame data and can not be used
        
        Returns:
            bool:
        """
        ...
    def is_cache_valid(self) -> bool:
        r"""
        x.is_cache_valid() -> bool
        A valid cache is one that contains at least 1 frames worth of data.
        
        Returns:
            bool:
        """
        ...
    def get_start_seconds(self) -> float:
        r"""
        x.get_start_seconds() -> float
        Get the time the simulation was at when recorded.
        
        Returns:
            float:
        """
        ...
    def get_num_frames(self) -> int:
        r"""
        x.get_num_frames() -> int32
        Get number of frames stored in the cache.
        
        Returns:
            int32:
        """
        ...
    def get_num_emitters(self) -> int:
        r"""
        x.get_num_emitters() -> int32
        Get number of emitters stored inside the cache.
        
        Returns:
            int32:
        """
        ...
    def get_emitter_names(self) -> Array[Name]:
        r"""
        x.get_emitter_names() -> Array[Name]
        Returns a list of emitters we have captured in the SimCache.
        
        Returns:
            Array[Name]:
        """
        ...
    def get_emitter_name(self, emitter_index: int) -> Name:
        r"""
        x.get_emitter_name(emitter_index) -> Name
        Get the emitter name at the provided index.
        
        Args:
            emitter_index (int32): 
        
        Returns:
            Name:
        """
        ...
    def get_attribute_capture_mode(self) -> NiagaraSimCacheAttributeCaptureMode:
        r"""
        x.get_attribute_capture_mode() -> NiagaraSimCacheAttributeCaptureMode
        How were the attributes captured for this sim cache.
        
        Returns:
            NiagaraSimCacheAttributeCaptureMode:
        """
        ...

class AsyncNiagaraCaptureSimCache(CancellableAsyncAction):
    r"""
    Async Niagara Capture Sim Cache
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSimCacheFunctionLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``capture_complete`` (OnCaptureComplete):  [Read-Write]
    """
    @property
    def capture_complete(self) -> OnCaptureComplete:
        r"""
        (OnCaptureComplete):  [Read-Write]
        """
        ...
    @capture_complete.setter
    def capture_complete(self, value: OnCaptureComplete) -> None:
        ...

class NiagaraSimCacheFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    Niagara Sim Cache Function Library
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSimCacheFunctionLibrary.h
    
    """
    @classmethod
    def create_niagara_sim_cache(cls, world_context_object: Object) -> NiagaraSimCache:
        r"""
        X.create_niagara_sim_cache(world_context_object) -> NiagaraSimCache
        Captures the simulation cache object that can be captured into using the various API calls.
        
        Args:
            world_context_object (Object): 
        
        Returns:
            NiagaraSimCache:
        """
        ...
    @classmethod
    def capture_niagara_sim_cache_immediate(cls, sim_cache: NiagaraSimCache, create_parameters: NiagaraSimCacheCreateParameters, niagara_component: NiagaraComponent, advance_simulation: bool = False, advance_delta_time: float = 0.016660) -> Optional[NiagaraSimCache]:
        r"""
        X.capture_niagara_sim_cache_immediate(sim_cache, create_parameters, niagara_component, advance_simulation=False, advance_delta_time=0.016660) -> NiagaraSimCache or None
        Captures the simulations current frame data into the SimCache.
        This happens immediately so you may need to be careful with tick order of the component you are capturing from.
        The return can be invalid if the component can not be captured for some reason (i.e. not active).
        When AdvanceSimulation is true we will manually advance the simulation one frame using the provided AdvanceDeltaTime before capturing.
        
        Args:
            sim_cache (NiagaraSimCache): 
            create_parameters (NiagaraSimCacheCreateParameters): 
            niagara_component (NiagaraComponent): 
            advance_simulation (bool): 
            advance_delta_time (float): 
        
        Returns:
            NiagaraSimCache or None: 
        
            out_sim_cache (NiagaraSimCache):
        """
        ...

class NiagaraSpriteRendererProperties(NiagaraRendererProperties):
    r"""
    Niagara Sprite Renderer Properties
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSpriteRendererProperties.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alignment`` (NiagaraSpriteAlignment):  [Read-Write] Imagine the particle texture having an arrow pointing up, these modes define how the particle aligns that texture to other particle attributes.
    - ``allow_in_cull_proxies`` (bool):  [Read-Write]
    - ``alpha_threshold`` (float):  [Read-Write] Alpha channel values larger than the threshold are considered occupied and will be contained in the bounding geometry.
      Raising this threshold slightly can reduce overdraw in particles using this animation asset.
    - ``bounding_mode`` (SubUVBoundingVertexCount):  [Read-Write] More bounding vertices results in reduced overdraw, but adds more triangle overhead.
      The eight vertex mode is best used when the SubUV texture has a lot of space to cut out that is not captured by the four vertex version,
      and when the particles using the texture will be few and large.
    - ``camera_offset_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for camera offset when generating sprites?
    - ``cast_shadows`` (bool):  [Read-Write] When disabled the renderer will not cast shadows.
      The component controls if shadows are enabled, this flag allows you to disable the renderer casting shadows.
    - ``color_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for color when generating sprites?
    - ``custom_sorting_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for custom sorting? Defaults to Particles.NormalizedAge.
    - ``cutout_texture`` (Texture2D):  [Read-Write] Texture to generate bounding geometry from.
    - ``dynamic_material1_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for dynamic material parameters when generating sprites?
    - ``dynamic_material2_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for dynamic material parameters when generating sprites?
    - ``dynamic_material3_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for dynamic material parameters when generating sprites?
    - ``dynamic_material_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for dynamic material parameters when generating sprites?
    - ``enable_camera_distance_culling`` (bool):  [Read-Write] Enables frustum culling of individual sprites
    - ``facing_mode`` (NiagaraSpriteFacingMode):  [Read-Write] Determines how the particle billboard orients itself relative to the camera.
    - ``gpu_translucent_latency`` (NiagaraRendererGpuTranslucentLatency):  [Read-Write] Gpu simulations run at different points in the frame depending on what features are used, i.e. depth buffer, distance fields, etc.
      Opaque materials will run latent when these features are used.
      Translucent materials can choose if they want to use this frames or the previous frames data to match opaque draws.
    - ``macro_uv_radius`` (float):  [Read-Write] World space radius that UVs generated with the ParticleMacroUV material node will tile based on.
    - ``material`` (MaterialInterface):  [Read-Write] The material used to render the particle. Note that it must have the Use with Niagara Sprites flag checked.
    - ``material_parameters`` (NiagaraRendererMaterialParameters):  [Read-Write] If this array has entries, we will create a MaterialInstanceDynamic per Emitter instance from Material and set the Material parameters using the Niagara simulation variables listed.
    - ``material_random_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for material randoms when generating sprites?
    - ``material_user_param_binding`` (NiagaraUserParameterBinding):  [Read-Write] Use the UMaterialInterface bound to this user variable if it is set to a valid value. If this is bound to a valid value and Material is also set, UserParamBinding wins.
    - ``max_camera_distance`` (float):  [Read-Write]
    - ``max_facing_camera_blend_distance`` (float):  [Read-Write] When FacingMode is FacingCameraDistanceBlend, the distance at which the sprite is fully facing the camera position
    - ``min_camera_distance`` (float):  [Read-Write]
    - ``min_facing_camera_blend_distance`` (float):  [Read-Write] When FacingMode is FacingCameraDistanceBlend, the distance at which the sprite is fully facing the camera plane.
    - ``motion_vector_setting`` (NiagaraRendererMotionVectorSetting):  [Read-Write] Hint about how to generate motion (velocity) vectors for this renderer.
    - ``normalized_age_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for Normalized Age?
    - ``opacity_source_mode`` (OpacitySourceMode):  [Read-Write]
    - ``pivot_in_uv_space`` (Vector2D):  [Read-Write] Determines the location of the pivot point of this particle. It follows Unreal's UV space, which has the upper left of the image at 0,0 and bottom right at 1,1. The middle is at 0.5, 0.5.
      NOTE: This value is ignored if "Pivot Offset Binding" is bound to a valid attribute
    - ``pivot_offset_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for pivot offset? (NOTE: Values are expected to be in UV space).
    - ``pixel_coverage_blend`` (float):  [Read-Write] When pixel coverage is enabled this allows you to control the blend of the pixel coverage color adjustment.
      i.e. 1.0 = full, 0.5 = 50/50 blend, 0.0 = none
    - ``pixel_coverage_mode`` (NiagaraRendererPixelCoverageMode):  [Read-Write] This setting controls what happens when a sprite becomes less than a pixel in size.
      Disabling will apply nothing and can result in flickering issues, especially with Temporal Super Resolution.
      Automatic will enable the appropriate settings when the material blend mode is some form of translucency, project setting must also be enabled.
      When coverage is less than a pixel, we also calculate a percentage of coverage, and then darken or reduce opacity
      to visually compensate. The different enabled settings allow you to control how the coverage amount is applied to
      your particle color.  If particle color is not connected to your material the compensation will not be applied.
    - ``platforms`` (NiagaraPlatformSet):  [Read-Write] Platforms on which this renderer is enabled.
    - ``position_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for position when generating sprites?
    - ``remove_hmd_roll_in_vr`` (bool):  [Read-Write] If true, removes the HMD view roll (e.g. in VR)
    - ``renderer_enabled_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Binding to control if the renderer is enabled or disabled.
      When disabled the renderer does not generate or render any particle data.
      When disabled via a static bool the renderer will be removed in cooked content.
    - ``renderer_visibility`` (uint32):  [Read-Write] If a render visibility tag is present, particles whose tag matches this value will be visible in this renderer.
    - ``renderer_visibility_tag_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for RendererVisibilityTag?
    - ``sort_mode`` (NiagaraSortMode):  [Read-Write] Determines how we sort the particles prior to rendering.
    - ``sort_only_when_translucent`` (bool):  [Read-Write] If true, the particles are only sorted when using a translucent material.
    - ``sort_order_hint`` (int32):  [Read-Write] By default, emitters are drawn in the order that they are added to the system. This value will allow you to control the order in a more fine-grained manner.
            Materials of the same type (i.e. Transparent) will draw in order from lowest to highest within the system. The default value is 0.
    - ``sort_precision`` (NiagaraRendererSortPrecision):  [Read-Write] Sort precision to use when sorting is active.
    - ``source_mode`` (NiagaraRendererSourceDataMode):  [Read-Write] Whether or not to draw a single element for the Emitter or to draw the particles.
    - ``sprite_alignment_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for sprite alignment when generating sprites?
    - ``sprite_facing_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for sprite facing when generating sprites?
    - ``sprite_rotation_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for sprite rotation (in degrees) when generating sprites?
    - ``sprite_size_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for sprite size when generating sprites?
    - ``sub_image_blend`` (bool):  [Read-Write] If true, blends the sub-image UV lookup with its next adjacent member using the fractional part of the SubImageIndex float value as the linear interpolation factor.
    - ``sub_image_index_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for sprite sub-image indexing when generating sprites?
    - ``sub_image_size`` (Vector2D):  [Read-Write] When using SubImage lookups for particles, this variable contains the number of columns in X and the number of rows in Y.
    - ``use_material_cutout_texture`` (bool):  [Read-Write] Use the cutout texture from the material opacity mask, or if none exist, from the material opacity.
    - ``uv_scale_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for UV scale when generating sprites?
    - ``velocity_binding`` (NiagaraVariableAttributeBinding):  [Read-Write] Which attribute should we use for velocity when generating sprites?
    """
    @property
    def use_material_cutout_texture(self) -> bool:
        r"""
        (bool):  [Read-Only] Use the cutout texture from the material opacity mask, or if none exist, from the material opacity.
        """
        ...

class NiagaraSystem(FXSystemAsset):
    r"""
    A Niagara System contains multiple Niagara Emitters to create various effects.
    Niagara Systems can be placed in the world, unlike Emitters, and expose User Parameters to configure an effect at runtime.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraSystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_culling_for_local_players_override`` (bool):  [Read-Write] The override value for bAllowCullingForLocalPlayers from the Effect Type.
    - ``allow_system_state_fast_path`` (bool):  [Read-Write] When enabled if all emitters don't require script execution and the system script is empty / constant we can invoke a faster CPU path.
    - ``bake_out_rapid_iteration`` (bool):  [Read-Write] When enable constant values are baked into the scripts while editing the system, this will increase iteration times but improve performance.
    - ``bake_out_rapid_iteration_on_cook`` (bool):  [Read-Write] When enabled constant values are baked into scripts to improve performance.
    - ``cast_shadow`` (bool):  [Read-Write] When enabled this is the default value set on the component.
      Controls whether the primitive component should cast a shadow or not.
    - ``compress_attributes`` (bool):  [Read-Write] Toggles whether or not emitters within this system will try and compress their particle attributes.
            In some cases, this precision change can lead to perceivable differences, but memory costs and or performance (especially true for GPU emitters) can improve.
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] When enabled this is the default value set on the component.
      Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] When enabled this is the default value set on the component.
      Mask used for stencil buffer writes.
    - ``determinism`` (bool):  [Read-Write] When disabled we will generate a RandomSeed per instance on reset which is not deterministic.
      When enabled we will always use the RandomSeed from the system plus the components RandomSeedOffset, this allows for determinism but variance between components.
    - ``disable_debug_switches`` (bool):  [Read-Write] When enable debug switches are disabled while editing the system.
    - ``disable_debug_switches_on_cook`` (bool):  [Read-Write] When enabled debug switches are disabled when compiling the system.
    - ``disable_experimental_vm`` (bool):  [Read-Write] If true, disables optimized VM, if available
    - ``dump_debug_emitter_info`` (bool):  [Read-Write]
    - ``dump_debug_system_info`` (bool):  [Read-Write]
    - ``effect_type`` (NiagaraEffectType):  [Read-Write] An effect types defines settings shared between systems, for example scalability and validation rules.
      Things like environment fx usually have a different effect type than gameplay relevant fx such as weapon impacts.
      This way whole classes of effects can be adjusted at once.
    - ``fixed_bounds`` (bool):  [Read-Write] Whether or not fixed bounds are enabled.
    - ``fixed_bounds`` (Box):  [Read-Write] The fixed bounding box value for the whole system. When placed in the level and the bounding box is not visible to the camera, the effect is culled from rendering.
    - ``fixed_tick_delta`` (bool):  [Read-Write]
    - ``fixed_tick_delta_time`` (float):  [Read-Write] If activated, the system ticks with a fixed delta time instead of the varying game thread delta time. This leads to much more stable simulations.
      When the fixed tick delta is smaller than the game thread tick time the simulation is substepping by executing multiple ticks per frame.
      Note that activating this feature forces the system to tick on the game thread instead of an async task in parallel.
      
      The max number of substeps per frame can be set via fx.Niagara.SystemSimulation.MaxTickSubsteps
    - ``ignore_particle_reads_for_attribute_trim`` (bool):  [Read-Write] If true ParticleReads will not absolutely prevent attribute trimming - User must ensure that the appropriate attributes are preserved on the source emitter!
    - ``initial_owner_velocity_from_actor`` (bool):  [Read-Write] When enabled we use the owner actor's velocity for the first frame.
      If we do not have an owner actor, or this is disable then the first frame's velocity will be zero.
    - ``max_pool_size`` (uint32):  [Read-Write] Max number of components of this system to keep resident in the world component pool.
    - ``override_allow_culling_for_local_players`` (bool):  [Read-Write] Controls whether we should override the Effect Type value for bAllowCullingForLocalPlayers.
    - ``override_cast_shadow`` (bool):  [Read-Write] Various optional overrides for component properties when spawning a system
    - ``override_custom_depth_stencil_value`` (bool):  [Read-Write]
    - ``override_custom_depth_stencil_write_mask`` (bool):  [Read-Write]
    - ``override_receives_decals`` (bool):  [Read-Write]
    - ``override_render_custom_depth`` (bool):  [Read-Write]
    - ``override_scalability_settings`` (bool):  [Read-Write]
    - ``override_translucency_sort_distance_offset`` (bool):  [Read-Write]
    - ``override_translucency_sort_priority`` (bool):  [Read-Write]
    - ``parameter_collection_overrides`` (Array[NiagaraParameterCollectionInstance]):  [Read-Write]
    - ``platforms`` (NiagaraPlatformSet):  [Read-Write]
    - ``pool_prime_size`` (uint32):  [Read-Write] How many instances we should use to initially prime the pool.
      This can amortize runtime activation cost by moving it to load time.
      Use with care as this could cause large hitches for systems loaded/unloaded during play rather than at level load.
    - ``random_seed`` (int32):  [Read-Write] Seed used for system script random number generator.
    - ``receives_decals`` (bool):  [Read-Write] When enabled this is the default value set on the component.
      Whether the primitive receives decals.
    - ``render_custom_depth`` (bool):  [Read-Write] When enabled this is the default value set on the component.
      This primitive has bRenderCustomDepth enabled.
    - ``require_current_frame_data`` (bool):  [Read-Write] When enabled, we follow the settings on the UNiagaraComponent for tick order. When this option is disabled, we ignore any dependencies from data interfaces or other variables and instead fire off the simulation as early in the frame as possible. This greatly
            reduces overhead and allows the game thread to run faster, but comes at a tradeoff if the dependencies might leave gaps or other visual artifacts.
    - ``support_large_world_coordinates`` (bool):  [Read-Write] If true then position type values will be rebased on system activation to fit into a float precision vector. This needs to be turned off when using a custom data interface or renderer that does not support the rebasing.
    - ``system_scalability_overrides`` (NiagaraSystemScalabilityOverrides):  [Read-Write]
    - ``template_asset_description`` (Text):  [Read-Write]
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] When enabled this is the default value set on the component.
      Modifies the sort distance for translucent objects, see PrimitiveComponent description for more details.
    - ``translucency_sort_priority`` (int32):  [Read-Write] When enabled this is the default value set on the component.
      Adjusts the translucent object sorting priority, see PrimitiveComponent description for more details.
    - ``trim_attributes`` (bool):  [Read-Write] When enabled we trim particle attributes while editing the system.
    - ``trim_attributes_on_cook`` (bool):  [Read-Write] If true Particle attributes will be removed from the DataSet if they are unnecessary (are never read by ParameterMap)
    - ``warmup_tick_count`` (int32):  [Read-Write] Number of ticks to process for warmup. You can set by this or by time via WarmupTime.
    - ``warmup_tick_delta`` (float):  [Read-Write] Delta time to use for warmup ticks.
    - ``warmup_time`` (float):  [Read-Write] Warm up time in seconds. Used to calculate WarmupTickCount. Rounds down to the nearest multiple of WarmupTickDelta.
    """
    @property
    def cast_shadow(self) -> bool:
        r"""
        (bool):  [Read-Only] When enabled this is the default value set on the component.
        Controls whether the primitive component should cast a shadow or not.
        """
        ...
    @property
    def receives_decals(self) -> bool:
        r"""
        (bool):  [Read-Only] When enabled this is the default value set on the component.
        Whether the primitive receives decals.
        """
        ...
    @property
    def render_custom_depth(self) -> bool:
        r"""
        (bool):  [Read-Only] When enabled this is the default value set on the component.
        This primitive has bRenderCustomDepth enabled.
        """
        ...
    @property
    def custom_depth_stencil_write_mask(self) -> RendererStencilMask:
        r"""
        (RendererStencilMask):  [Read-Only] When enabled this is the default value set on the component.
        Mask used for stencil buffer writes.
        """
        ...
    @property
    def custom_depth_stencil_value(self) -> int:
        r"""
        (int32):  [Read-Only] When enabled this is the default value set on the component.
        Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
        """
        ...
    @property
    def translucency_sort_priority(self) -> int:
        r"""
        (int32):  [Read-Only] When enabled this is the default value set on the component.
        Adjusts the translucent object sorting priority, see PrimitiveComponent description for more details.
        """
        ...
    @property
    def translucency_sort_distance_offset(self) -> float:
        r"""
        (float):  [Read-Only] When enabled this is the default value set on the component.
        Modifies the sort distance for translucent objects, see PrimitiveComponent description for more details.
        """
        ...

class NiagaraEffect(NiagaraSystem):
    r"""
    deprecated: 'NiagaraEffect' was renamed to 'NiagaraSystem'.
    """
    ...

class NiagaraDataChannel(Object):
    r"""
    Niagara Data Channel
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraDataChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_variables`` (Array[NiagaraDataChannelVariable]):  [Read-Write] The variables that define the data contained in this Data Channel.
    - ``enforce_tick_group_read_write_order`` (bool):  [Read-Write] If true we ensure that all writes happen in or before the Tick Group specified in EndWriteTickGroup and that all reads happen in tick groups after this.
    - ``final_write_tick_group`` (TickingGroup):  [Read-Write] The final tick group that this data channel can be written to.
    - ``keep_previous_frame_data`` (bool):  [Read-Write] If true, we keep our previous frame's data. This comes at a memory and performance cost but allows users to avoid tick order dependency by reading last frame's data. Some users will prefer a frame of latency to tick order dependency.
    - ``variables`` (Array[NiagaraVariable]):  [Read-Write]
      deprecated: Property 'Variables' is deprecated.
    """
    @property
    def variables(self) -> Array[NiagaraVariable]:
        r"""
        (Array[NiagaraVariable]):  [Read-Write]
        deprecated: Property 'Variables' is deprecated.
        """
        ...
    @variables.setter
    def variables(self, value: Array[NiagaraVariable]) -> None:
        ...

class NiagaraParameterCollection(Object):
    r"""
    Asset containing a collection of global parameters usable by Niagara.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraParameterCollection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``namespace`` (Name):  [Read-Write] Namespace for this parameter collection. Is enforced to be unique across all parameter collections.
    - ``source_material_collection`` (MaterialParameterCollection):  [Read-Write] Optional set of MPC that can drive scalar and vector parameters
    """
    ...

class NiagaraEffectType(Object):
    r"""
    Contains settings and working data shared among many NiagaraSystems that share some commonality of type. For example ImpactFX vs EnvironmentalFX.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_culling_for_local_players`` (bool):  [Read-Write] Controls whether or not culling is allowed for FX that are owned by, attached to or instigated by a locally controlled pawn.
    - ``cull_reaction`` (NiagaraCullReaction):  [Read-Write] How effects of this type react when they fail the cull checks.
    - ``emitter_scalability_settings`` (NiagaraEmitterScalabilitySettingsArray):  [Read-Write]
    - ``performance_baseline_controller`` (NiagaraBaselineController):  [Read-Write] Controls generation of performance baseline data for this effect type.
    - ``significance_handler`` (NiagaraSignificanceHandler):  [Read-Write] Used to determine the relative significance of FX in the scene which is used in other scalability systems such as instance count culling.
    - ``system_scalability_settings`` (NiagaraSystemScalabilitySettingsArray):  [Read-Write]
    - ``update_frequency`` (NiagaraScalabilityUpdateFrequency):  [Read-Write] How regularly effects of this type are checked for scalability.
    - ``validation_rule_sets`` (Array[NiagaraValidationRuleSet]):  [Read-Write] Array of reusable rule sets to apply when checking content. To create your own rules, write a custom class that extends UNiagaraValidationRule.
    - ``validation_rules`` (Array[NiagaraValidationRule]):  [Read-Write] A set of rules to apply when checking content. To create your own rules, write a custom class that extends UNiagaraValidationRule.
    """
    ...

class NiagaraSignificanceHandler(Object):
    r"""
    Base class for significance handlers.
    These allow Niagara's scalability system to determine the relative significance of different FX in the scene.
    Some basic ones are provided but projects are free to implement their own more complex determinations of significance.
    For example, FX attached to the player character could be given higher priority.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: Niagara
    - **File**: NiagaraEffectType.h
    
    """
    ...

class AnimNotifyState_TimedNiagaraEffect(AnimNotifyState):
    r"""
    Timed Niagara Effect Notify
    Allows a looping Niagara effect to be played in an animation that will activate
    at the beginning of the notify and deactivate at the end.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraAnimNotifies
    - **File**: AnimNotifyState_TimedNiagaraEffect.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``apply_rate_scale_as_time_dilation`` (bool):  [Read-Write] Should we set the animation rate scale as time dilation on the spawn effect?
    - ``destroy_at_end`` (bool):  [Read-Write] Whether the Niagara system should be immediately destroyed at the end of the notify state or be allowed to finish
    - ``location_offset`` (Vector):  [Read-Write] Offset from the socket or bone to place the Niagara system
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``rotation_offset`` (Rotator):  [Read-Write] Rotation offset from the socket or bone for the Niagara system
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify state instance should fire in animation editors
    - ``socket_name`` (Name):  [Read-Write] The socket or bone to attach the system to
    - ``template`` (NiagaraSystem):  [Read-Write] The niagara system to spawn for the notify state
    """
    @property
    def template(self) -> NiagaraSystem:
        r"""
        (NiagaraSystem):  [Read-Only] The niagara system to spawn for the notify state
        """
        ...
    @property
    def socket_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The socket or bone to attach the system to
        """
        ...
    @property
    def location_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Offset from the socket or bone to place the Niagara system
        """
        ...
    @property
    def rotation_offset(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] Rotation offset from the socket or bone for the Niagara system
        """
        ...
    @property
    def apply_rate_scale_as_time_dilation(self) -> bool:
        r"""
        (bool):  [Read-Only] Should we set the animation rate scale as time dilation on the spawn effect?
        """
        ...
    @property
    def destroy_at_end(self) -> bool:
        r"""
        (bool):  [Read-Only] Whether the Niagara system should be immediately destroyed at the end of the notify state or be allowed to finish
        """
        ...
    def get_spawned_effect(self, mesh_comp: MeshComponent) -> FXSystemComponent:
        r"""
        x.get_spawned_effect(mesh_comp) -> FXSystemComponent
        Return FXSystemComponent created from SpawnEffect
        
        Args:
            mesh_comp (MeshComponent): 
        
        Returns:
            FXSystemComponent:
        """
        ...

class AnimNotifyState_TimedNiagaraEffectAdvanced(AnimNotifyState_TimedNiagaraEffect):
    r"""
    Same as Timed Niagara Effect but also provides some more advanced abilities at an additional cost.
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraAnimNotifies
    - **File**: AnimNotifyState_TimedNiagaraEffect.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_curves`` (Array[CurveParameterPair]):  [Read-Write] Array of fnames to map Anim Curve names to Niagara Parameters.
    - ``apply_rate_scale_as_time_dilation`` (bool):  [Read-Write] Should we set the animation rate scale as time dilation on the spawn effect?
    - ``apply_rate_scale_to_progress`` (bool):  [Read-Write] Should we apply the animation rate scale when calculating the elasped time.
    - ``destroy_at_end`` (bool):  [Read-Write] Whether the Niagara system should be immediately destroyed at the end of the notify state or be allowed to finish
    - ``enable_normalized_notify_progress`` (bool):  [Read-Write] This send a 0-1 value of the normalized progress to the FX Component to the float User Parameter.
    - ``location_offset`` (Vector):  [Read-Write] Offset from the socket or bone to place the Niagara system
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``notify_progress_user_parameter`` (Name):  [Read-Write] The name of your niagara user variable you would like to send the normalized notify progress to.
    - ``rotation_offset`` (Rotator):  [Read-Write] Rotation offset from the socket or bone for the Niagara system
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify state instance should fire in animation editors
    - ``socket_name`` (Name):  [Read-Write] The socket or bone to attach the system to
    - ``template`` (NiagaraSystem):  [Read-Write] The niagara system to spawn for the notify state
    """
    @property
    def apply_rate_scale_to_progress(self) -> bool:
        r"""
        (bool):  [Read-Only] Should we apply the animation rate scale when calculating the elasped time.
        """
        ...
    def get_notify_progress(self, mesh_comp: MeshComponent) -> float:
        r"""
        x.get_notify_progress(mesh_comp) -> float
        Returns a 0 to 1 value for the progress of this component along the notify.
        
        Args:
            mesh_comp (MeshComponent): 
        
        Returns:
            float:
        """
        ...

class AnimNotify_PlayNiagaraEffect(AnimNotify):
    r"""
    Anim Notify Play Niagara Effect
    
    **C++ Source:**
    
    - **Plugin**: Niagara
    - **Module**: NiagaraAnimNotifies
    - **File**: AnimNotify_PlayNiagaraEffect.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_scale`` (bool):  [Read-Write] Whether or not we are in absolute scale mode
    - ``attached`` (bool):  [Read-Write] Should attach to the bone/socket
    - ``location_offset`` (Vector):  [Read-Write] Location offset from the socket
    - ``notify_color`` (Color):  [Read-Write] Color of Notify in editor
    - ``rotation_offset`` (Rotator):  [Read-Write] Rotation offset from socket
    - ``scale`` (Vector):  [Read-Write] Scale to spawn the Niagara system at
    - ``should_fire_in_editor`` (bool):  [Read-Write] Whether this notify instance should fire in animation editors
    - ``socket_name`` (Name):  [Read-Write] SocketName to attach to
    - ``template`` (NiagaraSystem):  [Read-Write] Niagara System to Spawn
    """
    @property
    def template(self) -> NiagaraSystem:
        r"""
        (NiagaraSystem):  [Read-Only] Niagara System to Spawn
        """
        ...
    @property
    def location_offset(self) -> Vector:
        r"""
        (Vector):  [Read-Only] Location offset from the socket
        """
        ...
    @property
    def rotation_offset(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] Rotation offset from socket
        """
        ...
    @property
    def attached(self) -> bool:
        r"""
        (bool):  [Read-Only] Should attach to the bone/socket
        """
        ...
    @property
    def socket_name(self) -> Name:
        r"""
        (Name):  [Read-Only] SocketName to attach to
        """
        ...
    def get_spawned_effect(self) -> FXSystemComponent:
        r"""
        x.get_spawned_effect() -> FXSystemComponent
        Return FXSystemComponent created from SpawnEffect
        
        Returns:
            FXSystemComponent:
        """
        ...

class MovieSceneNiagaraCacheSection(MovieSceneBaseCacheSection):
    r"""
    Movie scene section that control NiagaraCache playback
    
    **C++ Source:**
    
    - **Plugin**: NiagaraSimCaching
    - **Module**: NiagaraSimCaching
    - **File**: MovieSceneNiagaraCacheSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``params`` (MovieSceneNiagaraCacheParams):  [Read-Write]
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneNiagaraCacheTrack(MovieSceneNameableTrack):
    r"""
    Handles animation of NiagaraCache
    
    **C++ Source:**
    
    - **Plugin**: NiagaraSimCaching
    - **Module**: NiagaraSimCaching
    - **File**: MovieSceneNiagaraCacheTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneNiagaraTrackRecorder(MovieSceneTrackRecorder):
    r"""
    Movie Scene Niagara Track Recorder
    
    **C++ Source:**
    
    - **Plugin**: NiagaraSimCaching
    - **Module**: NiagaraSimCachingEditor
    - **File**: MovieSceneNiagaraTrackRecorder.h
    
    """
    ...

class InterchangeAnimationTrackSetNode(InterchangeBaseNode):
    r"""
    Class to represent a set of animation track nodes that share the same frame rate.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeAnimationTrackSetNode.h
    
    """
    def set_custom_frame_rate(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_frame_rate(attribute_value) -> bool
        Set the frame rate for the animations in the level sequence.
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def remove_custom_animation_track_uid(self, animation_track_uid: str) -> bool:
        r"""
        x.remove_custom_animation_track_uid(animation_track_uid) -> bool
        Remove one track dependency from this object.
        
        Args:
            animation_track_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_frame_rate(self) -> Optional[float]:
        r"""
        x.get_custom_frame_rate() -> float or None
        Get the frame rate for the animations in the level sequence.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_animation_track_uids(self) -> Array[str]:
        r"""
        x.get_custom_animation_track_uids() -> Array[str]
        Retrieve the track dependency for this object.
        
        Returns:
            Array[str]: 
        
            out_animation_track_uids (Array[str]):
        """
        ...
    def get_custom_animation_track_uid_count(self) -> int:
        r"""
        x.get_custom_animation_track_uid_count() -> int32
        Retrieve the number of track dependencies for this object.
        
        Returns:
            int32:
        """
        ...
    def get_custom_animation_track_uid(self, index: int) -> str:
        r"""
        x.get_custom_animation_track_uid(index) -> str
        Retrieve one track dependency for this object.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_animation_track_uid (str):
        """
        ...
    def add_custom_animation_track_uid(self, animation_track_uid: str) -> bool:
        r"""
        x.add_custom_animation_track_uid(animation_track_uid) -> bool
        Add one track dependency to this object.
        
        Args:
            animation_track_uid (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeAnimationTrackBaseNode(InterchangeBaseNode):
    r"""
    Abstract class providing the minimal services required for an animation track node.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeAnimationTrackSetNode.h
    
    """
    def set_custom_completion_mode(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_completion_mode(attribute_value) -> bool
        Set how the actor's animated property should behave once its animation completes.
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_completion_mode(self) -> Optional[int]:
        r"""
        x.get_custom_completion_mode() -> int32 or None
        Get how the actor's animated property behaves once this animation is complete.
        The output value will be clamped to the range of values defined in EInterchangeAimationCompletionMode.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...

class InterchangeAnimationTrackSetInstanceNode(InterchangeAnimationTrackBaseNode):
    r"""
    Class to represent an animation that instances another animation track set node.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeAnimationTrackSetNode.h
    
    """
    def set_custom_track_set_dependency_uid(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_track_set_dependency_uid(attribute_value) -> bool
        Set the unique id of the level sequence this instance references.
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_time_scale(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_time_scale(attribute_value) -> bool
        Set the time scale used for the level sequence instance.
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_start_frame(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_start_frame(attribute_value) -> bool
        Set the frame where the level sequence instance starts.
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_duration(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_duration(attribute_value) -> bool
        Set the level sequence instance duration in number of frames.
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_track_set_dependency_uid(self) -> Optional[str]:
        r"""
        x.get_custom_track_set_dependency_uid() -> str or None
        Get the unique id of the level sequence this instance references.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_time_scale(self) -> Optional[float]:
        r"""
        x.get_custom_time_scale() -> float or None
        Get the time scale used for the level sequence instance.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_start_frame(self) -> Optional[int]:
        r"""
        x.get_custom_start_frame() -> int32 or None
        Get the frame where the level sequence instance starts.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_duration(self) -> Optional[int]:
        r"""
        x.get_custom_duration() -> int32 or None
        Get the level sequence instance duration in number of frames.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...

class InterchangeAnimationTrackNode(InterchangeAnimationTrackBaseNode):
    r"""
    Class to represent an animation on the property of a camera, light, or scene node
    The list of supported properties is enumerated in EInterchangeAnimatedProperty.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeAnimationTrackSetNode.h
    
    """
    def set_custom_targeted_property(self, targeted_property: int) -> bool:
        r"""
        x.set_custom_targeted_property(targeted_property) -> bool
        Set Custom Targeted Property
        
        Args:
            targeted_property (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_property_track(self, property_track: Name) -> bool:
        r"""
        x.set_custom_property_track(property_track) -> bool
        Set the property animated by this track. Usually the name of a UMovieSceneTrack, e.g for UMovieSceneColorTrack -> Color
        
        Args:
            property_track (Name): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_frame_count(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_frame_count(attribute_value) -> bool
        Set the number of frames for the animation of this track.
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_animation_payload_key(self, unique_id: str, type: InterchangeAnimationPayLoadType) -> bool:
        r"""
        x.set_custom_animation_payload_key(unique_id, type) -> bool
        Set the payload key needed to retrieve the animation for this track.
        
        Args:
            unique_id (str): 
            type (InterchangeAnimationPayLoadType): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_actor_dependency_uid(self, dependency_uid: str) -> bool:
        r"""
        x.set_custom_actor_dependency_uid(dependency_uid) -> bool
        Set the actor dependency to this object.
        
        Args:
            dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_targeted_property(self) -> Optional[int]:
        r"""
        x.get_custom_targeted_property() -> int32 or None
        Get Custom Targeted Property
        
        Returns:
            int32 or None: 
        
            targeted_property (int32):
        """
        ...
    def get_custom_property_track(self) -> Optional[Name]:
        r"""
        x.get_custom_property_track() -> Name or None
        Get Custom Property Track
        
        Returns:
            Name or None: 
        
            property_track (Name):
        """
        ...
    def get_custom_frame_count(self) -> Optional[int]:
        r"""
        x.get_custom_frame_count() -> int32 or None
        Get the number of frames for the animation of this track.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_animation_payload_key(self) -> Optional[InterchangeAnimationPayLoadKey]:
        r"""
        x.get_custom_animation_payload_key() -> InterchangeAnimationPayLoadKey or None
        Get the payload key needed to retrieve the animation for this track.
        
        Returns:
            InterchangeAnimationPayLoadKey or None: 
        
            animation_pay_load_key (InterchangeAnimationPayLoadKey):
        """
        ...
    def get_custom_actor_dependency_uid(self) -> Optional[str]:
        r"""
        x.get_custom_actor_dependency_uid() -> str or None
        Get the actor dependency to this object.
        
        Returns:
            str or None: 
        
            dependency_uid (str):
        """
        ...

class InterchangeTransformAnimationTrackNode(InterchangeAnimationTrackNode):
    r"""
    Class to represent an animation on the transform of a camera, light, or scene node.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeAnimationTrackSetNode.h
    
    """
    def set_custom_used_channels(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_used_channels(attribute_value) -> bool
        Set which channels of this animation should be used. This is a bitwise mask.
        Bits are interpreted as follow:
           None          = 0x000,
           TranslationX  = 0x001,
           TranslationY  = 0x002,
           TranslationZ  = 0x004,
           Translation   = TranslationX | TranslationY | TranslationZ,
           RotationX     = 0x008,
           RotationY     = 0x010,
           RotationZ     = 0x020,
           Rotation      = RotationX | RotationY | RotationZ,
           ScaleX        = 0x040,
           ScaleY        = 0x080,
           ScaleZ        = 0x100,
           Scale         = ScaleX | ScaleY | ScaleZ,
           AllTransform  = Translation | Rotation | Scale,
           Weight        = 0x200,
           All           = Translation | Rotation | Scale | Weight,
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_used_channels(self) -> Optional[int]:
        r"""
        x.get_custom_used_channels() -> int32 or None
        Get which channels of this animation should be used. This is a bitmask.
        See SetCustomUsedChannels for description of bitmask
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...

class InterchangeSkeletalAnimationTrackNode(InterchangeAnimationTrackBaseNode):
    r"""
    * Class to hold onto the relationships between a set of animation tracks and the bones, morph targets of a skeleton.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeAnimationTrackSetNode.h
    
    """
    def set_custom_skeleton_node_uid(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_skeleton_node_uid(attribute_value) -> bool
        Set the unique ID of the skeleton factory node. Return false if the attribute could not be set.
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_animation_stop_time(self, stop_time: float) -> bool:
        r"""
        x.set_custom_animation_stop_time(stop_time) -> bool
        Set the animation stop time. Return false if the attribute could not be set.
        
        Args:
            stop_time (double): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_animation_start_time(self, start_time: float) -> bool:
        r"""
        x.set_custom_animation_start_time(start_time) -> bool
        Set the animation start time. Return false if the attribute could not be set.
        
        Args:
            start_time (double): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_animation_sample_rate(self, sample_rate: float) -> bool:
        r"""
        x.set_custom_animation_sample_rate(sample_rate) -> bool
        Set the animation sample rate. Return false if the attribute could not be set.
        
        Args:
            sample_rate (double): 
        
        Returns:
            bool:
        """
        ...
    def set_animation_payload_key_for_scene_node_uid(self, scene_node_uid: str, unique_id: str, type: InterchangeAnimationPayLoadType) -> bool:
        r"""
        x.set_animation_payload_key_for_scene_node_uid(scene_node_uid, unique_id, type) -> bool
        Set Animation Payload Key for Scene Node Uid
        
        Args:
            scene_node_uid (str): 
            unique_id (str): 
            type (InterchangeAnimationPayLoadType): 
        
        Returns:
            bool:
        """
        ...
    def set_animation_payload_key_for_morph_target_node_uid(self, morph_target_node_uid: str, unique_id: str, type: InterchangeAnimationPayLoadType) -> bool:
        r"""
        x.set_animation_payload_key_for_morph_target_node_uid(morph_target_node_uid, unique_id, type) -> bool
        Set Animation Payload Key for Morph Target Node Uid
        
        Args:
            morph_target_node_uid (str): 
            unique_id (str): 
            type (InterchangeAnimationPayLoadType): 
        
        Returns:
            bool:
        """
        ...
    def get_scene_node_animation_payload_keys(self) -> Tuple[Map[str, str], Map[str, int]]:
        r"""
        x.get_scene_node_animation_payload_keys() -> (out_scene_node_animation_payload_key_uids=Map[str, str], out_scene_node_animation_payload_key_types=Map[str, uint8])
        Get Scene Node Animation Payload Keys
        
        Returns:
            tuple: 
        
            out_scene_node_animation_payload_key_uids (Map[str, str]): 
        
            out_scene_node_animation_payload_key_types (Map[str, uint8]):
        """
        ...
    def get_morph_target_node_animation_payload_keys(self) -> Tuple[Map[str, str], Map[str, int]]:
        r"""
        x.get_morph_target_node_animation_payload_keys() -> (out_morph_target_node_animation_payload_key_uids=Map[str, str], out_morph_target_node_animation_payload_key_types=Map[str, uint8])
        Get Morph Target Node Animation Payload Keys
        
        Returns:
            tuple: 
        
            out_morph_target_node_animation_payload_key_uids (Map[str, str]): 
        
            out_morph_target_node_animation_payload_key_types (Map[str, uint8]):
        """
        ...
    def get_custom_skeleton_node_uid(self) -> Optional[str]:
        r"""
        x.get_custom_skeleton_node_uid() -> str or None
        Get the unique ID of the skeleton factory node. Return false if the attribute is not set.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_animation_stop_time(self) -> Optional[float]:
        r"""
        x.get_custom_animation_stop_time() -> double or None
        Get the animation stop time. Return false if the attribute is not set.
        
        Returns:
            double or None: 
        
            stop_time (double):
        """
        ...
    def get_custom_animation_start_time(self) -> Optional[float]:
        r"""
        x.get_custom_animation_start_time() -> double or None
        Get the animation start time. Return false if the attribute is not set.
        
        Returns:
            double or None: 
        
            start_time (double):
        """
        ...
    def get_custom_animation_sample_rate(self) -> Optional[float]:
        r"""
        x.get_custom_animation_sample_rate() -> double or None
        Get the animation sample rate. Return false if the attribute is not set.
        
        Returns:
            double or None: 
        
            sample_rate (double):
        """
        ...

class InterchangePhysicalCameraNode(InterchangeBaseNode):
    r"""
    Interchange Physical Camera Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeCameraNode.h
    
    """
    def set_custom_sensor_width(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_sensor_width(attribute_value) -> bool
        Set Custom Sensor Width
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_sensor_height(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_sensor_height(attribute_value) -> bool
        Set Custom Sensor Height
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_focal_length(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_focal_length(attribute_value) -> bool
        Set Custom Focal Length
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_enable_depth_of_field(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_enable_depth_of_field(attribute_value) -> bool
        Set Custom Enable Depth Of Field
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_sensor_width(self) -> Optional[float]:
        r"""
        x.get_custom_sensor_width() -> float or None
        Get Custom Sensor Width
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_sensor_height(self) -> Optional[float]:
        r"""
        x.get_custom_sensor_height() -> float or None
        Get Custom Sensor Height
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_focal_length(self) -> Optional[float]:
        r"""
        x.get_custom_focal_length() -> float or None
        Get Custom Focal Length
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_enable_depth_of_field(self) -> Optional[bool]:
        r"""
        x.get_custom_enable_depth_of_field() -> bool or None
        Get Custom Enable Depth Of Field
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...

class InterchangeStandardCameraNode(InterchangeBaseNode):
    r"""
    Primarily used for Ortho Camera
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeCameraNode.h
    
    """
    def set_custom_width(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_width(attribute_value) -> bool
        Set Custom Width
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_projection_mode(self, attribute_value: InterchangeCameraProjectionType) -> bool:
        r"""
        x.set_custom_projection_mode(attribute_value) -> bool
        Set Custom Projection Mode
        
        Args:
            attribute_value (InterchangeCameraProjectionType): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_near_clip_plane(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_near_clip_plane(attribute_value) -> bool
        Set Custom Near Clip Plane
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_field_of_view(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_field_of_view(attribute_value) -> bool
        Field of View in Degrees.
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_far_clip_plane(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_far_clip_plane(attribute_value) -> bool
        Set Custom Far Clip Plane
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_aspect_ratio(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_aspect_ratio(attribute_value) -> bool
        Set Custom Aspect Ratio
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_width(self) -> Optional[float]:
        r"""
        x.get_custom_width() -> float or None
        Get Custom Width
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_projection_mode(self) -> Optional[InterchangeCameraProjectionType]:
        r"""
        x.get_custom_projection_mode() -> InterchangeCameraProjectionType or None
        Get Custom Projection Mode
        
        Returns:
            InterchangeCameraProjectionType or None: 
        
            attribute_value (InterchangeCameraProjectionType):
        """
        ...
    def get_custom_near_clip_plane(self) -> Optional[float]:
        r"""
        x.get_custom_near_clip_plane() -> float or None
        Get Custom Near Clip Plane
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_field_of_view(self) -> Optional[float]:
        r"""
        x.get_custom_field_of_view() -> float or None
        Field of View in Degrees.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_far_clip_plane(self) -> Optional[float]:
        r"""
        x.get_custom_far_clip_plane() -> float or None
        Get Custom Far Clip Plane
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_aspect_ratio(self) -> Optional[float]:
        r"""
        x.get_custom_aspect_ratio() -> float or None
        Get Custom Aspect Ratio
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeShaderNode(InterchangeBaseNode):
    r"""
    A shader node is a named set of inputs and outputs. It can be connected to other shader nodes and finally to a shader graph input.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeShaderGraphNode.h
    
    """
    def set_custom_shader_type(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_shader_type(attribute_value) -> bool
        Sets which type of shader this nodes represents. Can be arbitrary or one of the predefined shader types.
        The material pipeline handling the shader node should be aware of the shader type that is being set here.
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_shader_type(self) -> Optional[str]:
        r"""
        x.get_custom_shader_type() -> str or None
        Get Custom Shader Type
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def add_string_input(self, input_name: str, attribute_value: str, is_a_parameter: bool = False) -> bool:
        r"""
        x.add_string_input(input_name, attribute_value, is_a_parameter=False) -> bool
        Set the String Attribute on the Shader Node. If bIsAParameter is set to true, it would be treated as a overridable Texture
        or else it should be treated as a LUT Texture.
        Note: It is assumed that the input name would be the parameter name when bIsAParameter is true.
        
        Args:
            input_name (str): 
            attribute_value (str): 
            is_a_parameter (bool): 
        
        Returns:
            bool:
        """
        ...
    def add_linear_color_input(self, input_name: str, attribute_value: LinearColor, is_a_parameter: bool = False) -> bool:
        r"""
        x.add_linear_color_input(input_name, attribute_value, is_a_parameter=False) -> bool
        Set the Linear Color Attribute on the Shader Node. If bIsAParameter is set to true, it would be treated as a VectorParameter
        when the Material Pipeline creates the materials. Otherwise it would be a constant 3 vector expression in the shader graph.
        Note: It is assumed that the input name would be the parameter name when bIsAParameter is true.
        
        Args:
            input_name (str): 
            attribute_value (LinearColor): 
            is_a_parameter (bool): 
        
        Returns:
            bool:
        """
        ...
    def add_float_input(self, input_name: str, attribute_value: float, is_a_parameter: bool = False) -> bool:
        r"""
        x.add_float_input(input_name, attribute_value, is_a_parameter=False) -> bool
        Set the Float Attribute on the Shader Node. If bIsAParameter is set to true, it would be treated as a ScalarParameter
        when the Material Pipeline creates the materials. Otherwise it would be a constant expression in the shader graph.
        Note: It is assumed that the input name would be the parameter name when bIsAParameter is true.
        
        Args:
            input_name (str): 
            attribute_value (float): 
            is_a_parameter (bool): 
        
        Returns:
            bool:
        """
        ...

class InterchangeDecalMaterialNode(InterchangeShaderNode):
    r"""
    Interchange Decal Material Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeDecalMaterialNode.h
    
    """
    ...

class InterchangeDecalNode(InterchangeBaseNode):
    r"""
    Interchange Decal Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeDecalNode.h
    
    """
    def set_custom_sort_order(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_sort_order(attribute_value) -> bool
        Set Custom Sort Order
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_decal_size(self, attribute_value: Vector) -> bool:
        r"""
        x.set_custom_decal_size(attribute_value) -> bool
        Set Custom Decal Size
        
        Args:
            attribute_value (Vector): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_decal_material_path_name(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_decal_material_path_name(attribute_value) -> bool
        Set Custom Decal Material Path Name
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_sort_order(self) -> Optional[int]:
        r"""
        x.get_custom_sort_order() -> int32 or None
        Get Custom Sort Order
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_decal_size(self) -> Optional[Vector]:
        r"""
        x.get_custom_decal_size() -> Vector or None
        Get Custom Decal Size
        
        Returns:
            Vector or None: 
        
            attribute_value (Vector):
        """
        ...
    def get_custom_decal_material_path_name(self) -> Optional[str]:
        r"""
        x.get_custom_decal_material_path_name() -> str or None
        Get Custom Decal Material Path Name
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...

class InterchangeBaseLightNode(InterchangeBaseNode):
    r"""
    Interchange Base Light Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeLightNode.h
    
    """
    def set_custom_use_temperature(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_use_temperature(attribute_value) -> bool
        Set Custom Use Temperature
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_temperature(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_temperature(attribute_value) -> bool
        Set Custom Temperature
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_light_color(self, attribute_value: LinearColor) -> bool:
        r"""
        x.set_custom_light_color(attribute_value) -> bool
        Set Custom Light Color
        
        Args:
            attribute_value (LinearColor): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_intensity(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_intensity(attribute_value) -> bool
        Set Custom Intensity
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_use_temperature(self) -> Optional[bool]:
        r"""
        x.get_custom_use_temperature() -> bool or None
        Get Custom Use Temperature
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_temperature(self) -> Optional[float]:
        r"""
        x.get_custom_temperature() -> float or None
        Get Custom Temperature
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_light_color(self) -> Optional[LinearColor]:
        r"""
        x.get_custom_light_color() -> LinearColor or None
        Get Custom Light Color
        
        Returns:
            LinearColor or None: 
        
            attribute_value (LinearColor):
        """
        ...
    def get_custom_intensity(self) -> Optional[float]:
        r"""
        x.get_custom_intensity() -> float or None
        Get Custom Intensity
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeLightNode(InterchangeBaseLightNode):
    r"""
    Interchange Light Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeLightNode.h
    
    """
    def set_custom_use_ies_brightness(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_use_ies_brightness(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Use IESBrightness
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_rotation(self, attribute_value: Rotator, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_rotation(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Rotation
        
        Args:
            attribute_value (Rotator): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_intensity_units(self, attribute_value: InterchangeLightUnits) -> bool:
        r"""
        x.set_custom_intensity_units(attribute_value) -> bool
        Set Custom Intensity Units
        
        Args:
            attribute_value (InterchangeLightUnits): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_ies_texture(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_ies_texture(attribute_value) -> bool
        Set Custom IESTexture
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_ies_brightness_scale(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_ies_brightness_scale(attribute_value, add_apply_delegate=True) -> bool
        Set Custom IESBrightness Scale
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_attenuation_radius(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_attenuation_radius(attribute_value) -> bool
        Set Custom Attenuation Radius
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_use_ies_brightness(self) -> Optional[bool]:
        r"""
        x.get_custom_use_ies_brightness() -> bool or None
        Get Custom Use IESBrightness
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_rotation(self) -> Optional[Rotator]:
        r"""
        x.get_custom_rotation() -> Rotator or None
        Get Custom Rotation
        
        Returns:
            Rotator or None: 
        
            attribute_value (Rotator):
        """
        ...
    def get_custom_intensity_units(self) -> Optional[InterchangeLightUnits]:
        r"""
        x.get_custom_intensity_units() -> InterchangeLightUnits or None
        Get Custom Intensity Units
        
        Returns:
            InterchangeLightUnits or None: 
        
            attribute_value (InterchangeLightUnits):
        """
        ...
    def get_custom_ies_texture(self) -> Optional[str]:
        r"""
        x.get_custom_ies_texture() -> str or None
        Get Custom IESTexture
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_ies_brightness_scale(self) -> Optional[float]:
        r"""
        x.get_custom_ies_brightness_scale() -> float or None
        Get Custom IESBrightness Scale
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_attenuation_radius(self) -> Optional[float]:
        r"""
        x.get_custom_attenuation_radius() -> float or None
        Get Custom Attenuation Radius
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangePointLightNode(InterchangeLightNode):
    r"""
    Interchange Point Light Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeLightNode.h
    
    """
    def set_custom_use_inverse_squared_falloff(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_use_inverse_squared_falloff(attribute_value) -> bool
        Set Custom Use Inverse Squared Falloff
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_light_falloff_exponent(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_light_falloff_exponent(attribute_value) -> bool
        Set Custom Light Falloff Exponent
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_use_inverse_squared_falloff(self) -> Optional[bool]:
        r"""
        x.get_custom_use_inverse_squared_falloff() -> bool or None
        Get Custom Use Inverse Squared Falloff
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_light_falloff_exponent(self) -> Optional[float]:
        r"""
        x.get_custom_light_falloff_exponent() -> float or None
        Get Custom Light Falloff Exponent
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeSpotLightNode(InterchangePointLightNode):
    r"""
    Interchange Spot Light Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeLightNode.h
    
    """
    def set_custom_outer_cone_angle(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_outer_cone_angle(attribute_value) -> bool
        Set Custom Outer Cone Angle
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_inner_cone_angle(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_inner_cone_angle(attribute_value) -> bool
        Set Custom Inner Cone Angle
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_outer_cone_angle(self) -> Optional[float]:
        r"""
        x.get_custom_outer_cone_angle() -> float or None
        Get Custom Outer Cone Angle
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_inner_cone_angle(self) -> Optional[float]:
        r"""
        x.get_custom_inner_cone_angle() -> float or None
        Get Custom Inner Cone Angle
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeRectLightNode(InterchangeLightNode):
    r"""
    Interchange Rect Light Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeLightNode.h
    
    """
    def set_custom_source_width(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_source_width(attribute_value) -> bool
        Set Custom Source Width
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_source_height(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_source_height(attribute_value) -> bool
        Set Custom Source Height
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_source_width(self) -> Optional[float]:
        r"""
        x.get_custom_source_width() -> float or None
        Get Custom Source Width
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_source_height(self) -> Optional[float]:
        r"""
        x.get_custom_source_height() -> float or None
        Get Custom Source Height
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeDirectionalLightNode(InterchangeBaseLightNode):
    r"""
    Interchange Directional Light Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeLightNode.h
    
    """
    ...

class InterchangeTextureNode(InterchangeBaseNode):
    r"""
    Interchange Texture Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeTextureNode.h
    
    """
    def set_pay_load_key(self, payload_key: str) -> None:
        r"""
        x.set_pay_load_key(payload_key) -> None
        Set Pay Load Key
        
        Args:
            payload_key (str):
        """
        ...
    def set_custom_srgb(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_srgb(attribute_value) -> bool
        Set Custom SRGB
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_filter(self, attribute_value: InterchangeTextureFilterMode) -> bool:
        r"""
        x.set_custom_filter(attribute_value) -> bool
        Set Custom Filter
        
        Args:
            attribute_value (InterchangeTextureFilterMode): 
        
        Returns:
            bool:
        """
        ...
    def set_customb_flip_green_channel(self, attribute_value: bool) -> bool:
        r"""
        x.set_customb_flip_green_channel(attribute_value) -> bool
        Set Customb Flip Green Channel
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_srgb(self) -> Optional[bool]:
        r"""
        x.get_custom_srgb() -> bool or None
        Get Custom SRGB
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_filter(self) -> Optional[InterchangeTextureFilterMode]:
        r"""
        x.get_custom_filter() -> InterchangeTextureFilterMode or None
        Get Custom Filter
        
        Returns:
            InterchangeTextureFilterMode or None: 
        
            attribute_value (InterchangeTextureFilterMode):
        """
        ...
    def get_customb_flip_green_channel(self) -> Optional[bool]:
        r"""
        x.get_customb_flip_green_channel() -> bool or None
        Get Customb Flip Green Channel
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...

class InterchangeTexture2DArrayNode(InterchangeTextureNode):
    r"""
    Interchange Texture 2DArray Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeTexture2DArrayNode.h
    
    """
    ...

class InterchangeTextureCubeArrayNode(InterchangeTextureNode):
    r"""
    Interchange Texture Cube Array Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeTextureCubeArrayNode.h
    
    """
    ...

class InterchangeTextureCubeNode(InterchangeTextureNode):
    r"""
    Interchange Texture Cube Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeTextureCubeNode.h
    
    """
    ...

class InterchangeTextureLightProfileNode(InterchangeTextureNode):
    r"""
    Interchange Texture Light Profile Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeTextureLightProfileNode.h
    
    """
    ...

class InterchangeVariantSetNode(InterchangeBaseNode):
    r"""
    Class to represent a set of variants.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeVariantSetNode.h
    
    """
    def set_custom_variants_payload_key(self, payload_key: str) -> bool:
        r"""
        x.set_custom_variants_payload_key(payload_key) -> bool
        Set the payload key needed to retrieve the variants for this VariantSet.
        
        Args:
            payload_key (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_display_text(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_display_text(attribute_value) -> bool
        Set the text to be displayed in the UI for this VariantSet.
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_custom_dependency_uid(self, dependency_uid: str) -> bool:
        r"""
        x.remove_custom_dependency_uid(dependency_uid) -> bool
        Remove the specified translated node's unique ID from this VariantSet.
        
        Args:
            dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_variants_payload_key(self) -> Optional[str]:
        r"""
        x.get_custom_variants_payload_key() -> str or None
        Get the payload key needed to retrieve the variants for this VariantSet.
        
        Returns:
            str or None: 
        
            payload_key (str):
        """
        ...
    def get_custom_display_text(self) -> Optional[str]:
        r"""
        x.get_custom_display_text() -> str or None
        Retrieve the text that is displayed in the UI for this VariantSet.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_dependency_uids(self) -> Array[str]:
        r"""
        x.get_custom_dependency_uids() -> Array[str]
        Retrieve all the translated node's unique IDs for this VariantSet.
        
        Returns:
            Array[str]: 
        
            out_dependency_uids (Array[str]):
        """
        ...
    def get_custom_dependency_uid_count(self) -> int:
        r"""
        x.get_custom_dependency_uid_count() -> int32
        Retrieve the number of translated node's unique IDs for this VariantSet.
        
        Returns:
            int32:
        """
        ...
    def get_custom_dependency_uid(self, index: int) -> str:
        r"""
        x.get_custom_dependency_uid(index) -> str
        Retrieve the specified translated node's unique ID for this VariantSet.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_dependency_uid (str):
        """
        ...
    def add_custom_dependency_uid(self, dependency_uid: str) -> bool:
        r"""
        x.add_custom_dependency_uid(dependency_uid) -> bool
        Add the specified translated node's unique ID to this VariantSet.
        
        Args:
            dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeSceneVariantSetsNode(InterchangeBaseNode):
    r"""
    Class to represent a set of VariantSet nodes
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeVariantSetNode.h
    
    """
    def remove_custom_variant_set_uid(self, variant_uid: str) -> bool:
        r"""
        x.remove_custom_variant_set_uid(variant_uid) -> bool
        Remove the specified VariantSet's unique id from this object.
        
        Args:
            variant_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_variant_set_uids(self) -> Array[str]:
        r"""
        x.get_custom_variant_set_uids() -> Array[str]
        Retrieve all the VariantSets' unique ids for this object.
        
        Returns:
            Array[str]: 
        
            out_variant_uids (Array[str]):
        """
        ...
    def get_custom_variant_set_uid_count(self) -> int:
        r"""
        x.get_custom_variant_set_uid_count() -> int32
        Retrieve the number of VariantSets for this object.
        
        Returns:
            int32:
        """
        ...
    def get_custom_variant_set_uid(self, index: int) -> str:
        r"""
        x.get_custom_variant_set_uid(index) -> str
        Retrieve the specified VariantSet's unique id for this object.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_variant_uid (str):
        """
        ...
    def add_custom_variant_set_uid(self, variant_uid: str) -> bool:
        r"""
        x.add_custom_variant_set_uid(variant_uid) -> bool
        Add the specified VariantSet's unique id to this object.
        
        Args:
            variant_uid (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeVolumeTextureNode(InterchangeTextureNode):
    r"""
    Interchange Volume Texture Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeVolumeTextureNode.h
    
    """
    ...

class InterchangeMaterialInstanceNode(InterchangeBaseNode):
    r"""
    Interchange Material Instance Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeMaterialInstanceNode.h
    
    """
    def set_custom_parent(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_parent(attribute_value) -> bool
        Set Custom Parent
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def get_vector_parameter_value(self, parameter_name: str) -> Optional[LinearColor]:
        r"""
        x.get_vector_parameter_value(parameter_name) -> LinearColor or None
        Get Vector Parameter Value
        
        Args:
            parameter_name (str): 
        
        Returns:
            LinearColor or None: 
        
            attribute_value (LinearColor):
        """
        ...
    def get_texture_parameter_value(self, parameter_name: str) -> Optional[str]:
        r"""
        x.get_texture_parameter_value(parameter_name) -> str or None
        Get Texture Parameter Value
        
        Args:
            parameter_name (str): 
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_static_switch_parameter_value(self, parameter_name: str) -> Optional[bool]:
        r"""
        x.get_static_switch_parameter_value(parameter_name) -> bool or None
        Get Static Switch Parameter Value
        
        Args:
            parameter_name (str): 
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_scalar_parameter_value(self, parameter_name: str) -> Optional[float]:
        r"""
        x.get_scalar_parameter_value(parameter_name) -> float or None
        Get Scalar Parameter Value
        
        Args:
            parameter_name (str): 
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_parent(self) -> Optional[str]:
        r"""
        x.get_custom_parent() -> str or None
        Get Custom Parent
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def add_vector_parameter_value(self, parameter_name: str, attribute_value: LinearColor) -> bool:
        r"""
        x.add_vector_parameter_value(parameter_name, attribute_value) -> bool
        Add Vector Parameter Value
        
        Args:
            parameter_name (str): 
            attribute_value (LinearColor): 
        
        Returns:
            bool:
        """
        ...
    def add_texture_parameter_value(self, parameter_name: str, attribute_value: str) -> bool:
        r"""
        x.add_texture_parameter_value(parameter_name, attribute_value) -> bool
        Add Texture Parameter Value
        
        Args:
            parameter_name (str): 
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def add_static_switch_parameter_value(self, parameter_name: str, attribute_value: bool) -> bool:
        r"""
        x.add_static_switch_parameter_value(parameter_name, attribute_value) -> bool
        Add Static Switch Parameter Value
        
        Args:
            parameter_name (str): 
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def add_scalar_parameter_value(self, parameter_name: str, attribute_value: float) -> bool:
        r"""
        x.add_scalar_parameter_value(parameter_name, attribute_value) -> bool
        Add Scalar Parameter Value
        
        Args:
            parameter_name (str): 
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...

class InterchangeMeshNode(InterchangeBaseNode):
    r"""
    Interchange Mesh Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeMeshNode.h
    
    """
    def set_slot_material_dependency_uid(self, slot_name: str, material_dependency_uid: str) -> bool:
        r"""
        x.set_slot_material_dependency_uid(slot_name, material_dependency_uid) -> bool
        Add the specified Material dependency to a specific slot name of this object.
        
        Args:
            slot_name (str): 
            material_dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def set_skinned_mesh(self, is_skinned_mesh: bool) -> bool:
        r"""
        x.set_skinned_mesh(is_skinned_mesh) -> bool
        Set the IsSkinnedMesh attribute to determine whether this node represents a skinned mesh.
        
        Args:
            is_skinned_mesh (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_skeleton_dependency_uid(self, dependency_uid: str) -> bool:
        r"""
        x.set_skeleton_dependency_uid(dependency_uid) -> bool
        Add the specified skeleton dependency to this object.
        
        Args:
            dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def set_scene_instance_uid(self, dependency_uid: str) -> bool:
        r"""
        x.set_scene_instance_uid(dependency_uid) -> bool
        Add the specified asset instance this scene node refers to.
        
        Args:
            dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def set_pay_load_key(self, pay_load_key: str, pay_load_type: InterchangeMeshPayLoadType) -> None:
        r"""
        x.set_pay_load_key(pay_load_key, pay_load_type) -> None
        Set Pay Load Key
        
        Args:
            pay_load_key (str): 
            pay_load_type (InterchangeMeshPayLoadType):
        """
        ...
    def set_morph_target_name(self, morph_target_name: str) -> bool:
        r"""
        x.set_morph_target_name(morph_target_name) -> bool
        Set the MorphTargetName attribute to determine the name of the morph target.
        
        Args:
            morph_target_name (str): 
        
        Returns:
            bool:
        """
        ...
    def set_morph_target_dependency_uid(self, dependency_uid: str) -> bool:
        r"""
        x.set_morph_target_dependency_uid(dependency_uid) -> bool
        Add the specified morph target dependency to this object.
        
        Args:
            dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def set_morph_target(self, is_morph_target: bool) -> bool:
        r"""
        x.set_morph_target(is_morph_target) -> bool
        Set the IsMorphTarget attribute to determine whether this node represents a morph target.
        
        Args:
            is_morph_target (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_vertex_count(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_vertex_count(attribute_value) -> bool
        Set the vertex count of this mesh. Return false if the attribute could not be set.
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_uv_count(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_uv_count(attribute_value) -> bool
        Set the UV count attribute of this mesh. Return false if the attribute could not be set.
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_polygon_count(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_polygon_count(attribute_value) -> bool
        Set the polygon count of this mesh. Return false if the attribute could not be set.
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_has_vertex_tangent(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_has_vertex_tangent(attribute_value) -> bool
        Set the vertex tangent attribute of this mesh. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_has_vertex_normal(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_has_vertex_normal(attribute_value) -> bool
        Set the vertex normal attribute of this mesh. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_has_vertex_color(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_has_vertex_color(attribute_value) -> bool
        Set the vertex color attribute of this mesh. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_has_vertex_binormal(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_has_vertex_binormal(attribute_value) -> bool
        Set the vertex bi-normal attribute of this mesh. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_has_smooth_group(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_has_smooth_group(attribute_value) -> bool
        Set the smoothing group attribute of this mesh. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_bounding_box(self, attribute_value: Box) -> bool:
        r"""
        x.set_custom_bounding_box(attribute_value) -> bool
        Set the bounding box of this mesh. Return false if the attribute could not be set.
        
        Args:
            attribute_value (Box): 
        
        Returns:
            bool:
        """
        ...
    def remove_slot_material_dependency_uid(self, slot_name: str) -> bool:
        r"""
        x.remove_slot_material_dependency_uid(slot_name) -> bool
        Remove the Material dependency associated with the given slot name from this object.
        
        Args:
            slot_name (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_skeleton_dependency_uid(self, dependency_uid: str) -> bool:
        r"""
        x.remove_skeleton_dependency_uid(dependency_uid) -> bool
        Remove the specified skeleton dependency from this object.
        
        Args:
            dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_scene_instance_uid(self, dependency_uid: str) -> bool:
        r"""
        x.remove_scene_instance_uid(dependency_uid) -> bool
        Remove the specified asset instance this scene node refers to.
        
        Args:
            dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_morph_target_dependency_uid(self, dependency_uid: str) -> bool:
        r"""
        x.remove_morph_target_dependency_uid(dependency_uid) -> bool
        Remove the specified morph target dependency from this object.
        
        Args:
            dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def is_skinned_mesh(self) -> bool:
        r"""
        x.is_skinned_mesh() -> bool
        Return true if this node represents a skinned mesh.
        
        Returns:
            bool:
        """
        ...
    def is_morph_target(self) -> bool:
        r"""
        x.is_morph_target() -> bool
        Return true if this node represents a morph target.
        
        Returns:
            bool:
        """
        ...
    def get_slot_material_dependency_uid(self, slot_name: str) -> Optional[str]:
        r"""
        x.get_slot_material_dependency_uid(slot_name) -> str or None
        Retrieve the specified Material dependency for a given slot of this object.
        
        Args:
            slot_name (str): 
        
        Returns:
            str or None: 
        
            out_material_dependency (str):
        """
        ...
    def get_slot_material_dependencies(self) -> Map[str, str]:
        r"""
        x.get_slot_material_dependencies() -> Map[str, str]
        Retrieve the correspondence table between slot names and assigned materials for this object.
        
        Returns:
            Map[str, str]: 
        
            out_material_dependencies (Map[str, str]):
        """
        ...
    def get_skeleton_dependency(self, index: int) -> str:
        r"""
        x.get_skeleton_dependency(index) -> str
        Retrieve the specified skeleton dependency for this object.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_dependency (str):
        """
        ...
    def get_skeleton_dependencies(self) -> Array[str]:
        r"""
        x.get_skeleton_dependencies() -> Array[str]
        Retrieve the skeleton dependency for this object.
        
        Returns:
            Array[str]: 
        
            out_dependencies (Array[str]):
        """
        ...
    def get_skeleton_dependecies_count(self) -> int:
        r"""
        x.get_skeleton_dependecies_count() -> int32
        Retrieve the number of skeleton dependencies for this object.
        
        Returns:
            int32:
        """
        ...
    def get_scene_instance_uids_count(self) -> int:
        r"""
        x.get_scene_instance_uids_count() -> int32
        Retrieve the number of scene nodes instancing this mesh.
        
        Returns:
            int32:
        """
        ...
    def get_scene_instance_uids(self) -> Array[str]:
        r"""
        x.get_scene_instance_uids() -> Array[str]
        Retrieve the asset instances this scene node refers to.
        
        Returns:
            Array[str]: 
        
            out_dependencies (Array[str]):
        """
        ...
    def get_scene_instance_uid(self, index: int) -> str:
        r"""
        x.get_scene_instance_uid(index) -> str
        Retrieve the asset instance this scene node refers to.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_dependency (str):
        """
        ...
    def get_morph_target_name(self) -> Optional[str]:
        r"""
        x.get_morph_target_name() -> str or None
        Get the morph target name.
        Return true if we successfully retrieved the MorphTargetName attribute.
        
        Returns:
            str or None: 
        
            out_morph_target_name (str):
        """
        ...
    def get_morph_target_dependency(self, index: int) -> str:
        r"""
        x.get_morph_target_dependency(index) -> str
        Retrieve the specified morph target dependency for this object.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_dependency (str):
        """
        ...
    def get_morph_target_dependencies(self) -> Array[str]:
        r"""
        x.get_morph_target_dependencies() -> Array[str]
        Retrieve all morph target dependencies for this object.
        
        Returns:
            Array[str]: 
        
            out_dependencies (Array[str]):
        """
        ...
    def get_morph_target_dependecies_count(self) -> int:
        r"""
        x.get_morph_target_dependecies_count() -> int32
        Retrieve the number of morph target dependencies for this object.
        
        Returns:
            int32:
        """
        ...
    def get_custom_vertex_count(self) -> Optional[int]:
        r"""
        x.get_custom_vertex_count() -> int32 or None
        Query the vertex count of this mesh. Return false if the attribute was not set.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_uv_count(self) -> Optional[int]:
        r"""
        x.get_custom_uv_count() -> int32 or None
        Query the UV count of this mesh. Return false if the attribute was not set.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_polygon_count(self) -> Optional[int]:
        r"""
        x.get_custom_polygon_count() -> int32 or None
        Query the polygon count of this mesh. Return false if the attribute was not set.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_has_vertex_tangent(self) -> Optional[bool]:
        r"""
        x.get_custom_has_vertex_tangent() -> bool or None
        Query whether this mesh has vertex tangents. Return false if the attribute was not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_has_vertex_normal(self) -> Optional[bool]:
        r"""
        x.get_custom_has_vertex_normal() -> bool or None
        Query whether this mesh has vertex normals. Return false if the attribute was not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_has_vertex_color(self) -> Optional[bool]:
        r"""
        x.get_custom_has_vertex_color() -> bool or None
        Query whether this mesh has vertex colors. Return false if the attribute was not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_has_vertex_binormal(self) -> Optional[bool]:
        r"""
        x.get_custom_has_vertex_binormal() -> bool or None
        Query whether this mesh has vertex bi-normals. Return false if the attribute was not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_has_smooth_group(self) -> Optional[bool]:
        r"""
        x.get_custom_has_smooth_group() -> bool or None
        Query whether this mesh has smoothing groups. Return false if the attribute was not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_bounding_box(self) -> Optional[Box]:
        r"""
        x.get_custom_bounding_box() -> Box or None
        Query the bounding box of this mesh. Return false if the attribute was not set.
        
        Returns:
            Box or None: 
        
            attribute_value (Box):
        """
        ...

class InterchangeSceneNode(InterchangeBaseNode):
    r"""
    The scene node represents a transform node in the scene.
    Scene nodes can have user-defined attributes. Use UInterchangeUserDefinedAttributesAPI to get and set user-defined attribute data.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeSceneNode.h
    
    """
    def set_slot_material_dependency_uid(self, slot_name: str, material_dependency_uid: str) -> bool:
        r"""
        x.set_slot_material_dependency_uid(slot_name, material_dependency_uid) -> bool
        Add the specified Material dependency to a specific slot name of this object.
        
        Args:
            slot_name (str): 
            material_dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def set_morph_target_curve_weight(self, morph_target_name: str, weight: float) -> bool:
        r"""
        x.set_morph_target_curve_weight(morph_target_name, weight) -> bool
        Set MorphTarget with given weight.
        
        Args:
            morph_target_name (str): 
            weight (float): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_time_zero_local_transform(self, base_node_container: InterchangeBaseNodeContainer, attribute_value: Transform, reset_cache: bool = True) -> bool:
        r"""
        x.set_custom_time_zero_local_transform(base_node_container, attribute_value, reset_cache=True) -> bool
        Set the local transform of the time-zero scene node.
        
        Args:
            base_node_container (InterchangeBaseNodeContainer): 
            attribute_value (Transform): 
            reset_cache (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_local_transform(self, base_node_container: InterchangeBaseNodeContainer, attribute_value: Transform, reset_cache: bool = True) -> bool:
        r"""
        x.set_custom_local_transform(base_node_container, attribute_value, reset_cache=True) -> bool
        Set the default scene node local transform.
        The default transform is the local transform of the node (no bind pose, no time evaluation).
        
        Args:
            base_node_container (InterchangeBaseNodeContainer): 
            attribute_value (Transform): 
            reset_cache (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_geometric_transform(self, attribute_value: Transform) -> bool:
        r"""
        x.set_custom_geometric_transform(attribute_value) -> bool
        Set the geometric offset. Any mesh attached to this scene node will be offset using this transform.
        
        Args:
            attribute_value (Transform): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_bind_pose_local_transform(self, base_node_container: InterchangeBaseNodeContainer, attribute_value: Transform, reset_cache: bool = True) -> bool:
        r"""
        x.set_custom_bind_pose_local_transform(base_node_container, attribute_value, reset_cache=True) -> bool
        Set the local transform of the bind pose scene node.
        
        Args:
            base_node_container (InterchangeBaseNodeContainer): 
            attribute_value (Transform): 
            reset_cache (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_asset_instance_uid(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_asset_instance_uid(attribute_value) -> bool
        Add an asset for this scene node to instantiate.
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_animation_asset_uid_to_play(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_animation_asset_uid_to_play(attribute_value) -> bool
        Set the Animation Asset To Play by this Scene Node. Only relevant for SkeletalMeshActors (that is, SceneNodes that are instantiating Skeletal Meshes).
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_specialized_type(self, specialized_type: str) -> bool:
        r"""
        x.remove_specialized_type(specialized_type) -> bool
        Remove Specialized Type
        
        Args:
            specialized_type (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_slot_material_dependency_uid(self, slot_name: str) -> bool:
        r"""
        x.remove_slot_material_dependency_uid(slot_name) -> bool
        Remove the Material dependency associated with the given slot name from this object.
        
        Args:
            slot_name (str): 
        
        Returns:
            bool:
        """
        ...
    def is_specialized_type_contains(self, specialized_type: str) -> bool:
        r"""
        x.is_specialized_type_contains(specialized_type) -> bool
        Is Specialized Type Contains
        
        Args:
            specialized_type (str): 
        
        Returns:
            bool:
        """
        ...
    def get_specialized_types(self) -> Array[str]:
        r"""
        x.get_specialized_types() -> Array[str]
        Get Specialized Types
        
        Returns:
            Array[str]: 
        
            out_specialized_types (Array[str]):
        """
        ...
    def get_specialized_type_count(self) -> int:
        r"""
        x.get_specialized_type_count() -> int32
        Get the specialized type this scene node represents (for example, Joint or LODGroup).
        
        Returns:
            int32:
        """
        ...
    def get_specialized_type(self, index: int) -> str:
        r"""
        x.get_specialized_type(index) -> str
        Get Specialized Type
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_specialized_type (str):
        """
        ...
    def get_slot_material_dependency_uid(self, slot_name: str) -> Optional[str]:
        r"""
        x.get_slot_material_dependency_uid(slot_name) -> str or None
        Retrieve the Material dependency for a given slot of this object.
        
        Args:
            slot_name (str): 
        
        Returns:
            str or None: 
        
            out_material_dependency (str):
        """
        ...
    def get_slot_material_dependencies(self) -> Map[str, str]:
        r"""
        x.get_slot_material_dependencies() -> Map[str, str]
        Retrieve the correspondence table between slot names and assigned materials for this object.
        
        Returns:
            Map[str, str]: 
        
            out_material_dependencies (Map[str, str]):
        """
        ...
    def get_morph_target_curve_weights(self) -> Map[str, float]:
        r"""
        x.get_morph_target_curve_weights() -> Map[str, float]
        Get MorphTargets and their weights.
        
        Returns:
            Map[str, float]: 
        
            out_morph_target_curve_weights (Map[str, float]):
        """
        ...
    def get_custom_time_zero_local_transform(self) -> Optional[Transform]:
        r"""
        x.get_custom_time_zero_local_transform() -> Transform or None
        Get the local transform of the time-zero scene node.
        
        Returns:
            Transform or None: 
        
            attribute_value (Transform):
        """
        ...
    def get_custom_time_zero_global_transform(self, base_node_container: InterchangeBaseNodeContainer, global_offset_transform: Transform, force_recache: bool = False) -> Optional[Transform]:
        r"""
        x.get_custom_time_zero_global_transform(base_node_container, global_offset_transform, force_recache=False) -> Transform or None
        Get the global transform of the time-zero scene node. This value is computed from the local transforms of all parent time-zero scene nodes.
        
        Args:
            base_node_container (InterchangeBaseNodeContainer): 
            global_offset_transform (Transform): 
            force_recache (bool): 
        
        Returns:
            Transform or None: 
        
            attribute_value (Transform):
        """
        ...
    def get_custom_local_transform(self) -> Optional[Transform]:
        r"""
        x.get_custom_local_transform() -> Transform or None
        Get the default scene node local transform.
        The default transform is the local transform of the node (no bind pose, no time evaluation).
        
        Returns:
            Transform or None: 
        
            attribute_value (Transform):
        """
        ...
    def get_custom_global_transform(self, base_node_container: InterchangeBaseNodeContainer, global_offset_transform: Transform, force_recache: bool = False) -> Optional[Transform]:
        r"""
        x.get_custom_global_transform(base_node_container, global_offset_transform, force_recache=False) -> Transform or None
        Get the default scene node global transform. This value is computed from the local transforms of all parent scene nodes.
        
        Args:
            base_node_container (InterchangeBaseNodeContainer): 
            global_offset_transform (Transform): 
            force_recache (bool): 
        
        Returns:
            Transform or None: 
        
            attribute_value (Transform):
        """
        ...
    def get_custom_geometric_transform(self) -> Optional[Transform]:
        r"""
        x.get_custom_geometric_transform() -> Transform or None
        Get the geometric offset. Any mesh attached to this scene node will be offset using this transform.
        
        Returns:
            Transform or None: 
        
            attribute_value (Transform):
        """
        ...
    def get_custom_bind_pose_local_transform(self) -> Optional[Transform]:
        r"""
        x.get_custom_bind_pose_local_transform() -> Transform or None
        Get the local transform of the bind pose scene node.
        
        Returns:
            Transform or None: 
        
            attribute_value (Transform):
        """
        ...
    def get_custom_bind_pose_global_transform(self, base_node_container: InterchangeBaseNodeContainer, global_offset_transform: Transform, force_recache: bool = False) -> Optional[Transform]:
        r"""
        x.get_custom_bind_pose_global_transform(base_node_container, global_offset_transform, force_recache=False) -> Transform or None
        Get the global transform of the bind pose scene node. This value is computed from the local transforms of all parent bind poses.
        
        Args:
            base_node_container (InterchangeBaseNodeContainer): 
            global_offset_transform (Transform): 
            force_recache (bool): 
        
        Returns:
            Transform or None: 
        
            attribute_value (Transform):
        """
        ...
    def get_custom_asset_instance_uid(self) -> Optional[str]:
        r"""
        x.get_custom_asset_instance_uid() -> str or None
        Get which asset, if any, a scene node is instantiating. Return false if the Attribute was not set previously.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_animation_asset_uid_to_play(self) -> Optional[str]:
        r"""
        x.get_custom_animation_asset_uid_to_play() -> str or None
        Get the Animation Asset To Play by this Scene Node.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def add_specialized_type(self, specialized_type: str) -> bool:
        r"""
        x.add_specialized_type(specialized_type) -> bool
        Add Specialized Type
        
        Args:
            specialized_type (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeShaderPortsAPI(Object):
    r"""
    The Shader Ports API manages a set of inputs and outputs attributes.
    This API can be used over any InterchangeBaseNode that wants to support shader ports as attributes.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeShaderGraphNode.h
    
    """
    @classmethod
    def make_input_value_key(cls, input_name: str) -> str:
        r"""
        X.make_input_value_key(input_name) -> str
        Makes an attribute key to represent a value being given to an input (that is, Inputs:InputName:Value).
        
        Args:
            input_name (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def make_input_parameter_key(cls, input_name: str) -> str:
        r"""
        X.make_input_parameter_key(input_name) -> str
        Makes an attribute key to represent a parameter being given to an input (that is, Inputs:InputName:Parameter).
        This is more relevant to Materials, but could be used to differentiate between constant values and parameters.
        
        Args:
            input_name (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def make_input_name(cls, input_key: str) -> str:
        r"""
        X.make_input_name(input_key) -> str
        From an attribute key associated with an input (that is, Inputs:InputName:Value), retrieves the input name.
        
        Args:
            input_key (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def make_input_connection_key(cls, input_name: str) -> str:
        r"""
        X.make_input_connection_key(input_name) -> str
        Makes an attribute key to represent a node being connected to an input (that is, Inputs:InputName:Connect).
        
        Args:
            input_name (str): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def is_a_parameter(cls, attribute_key: str) -> bool:
        r"""
        X.is_a_parameter(attribute_key) -> bool
        Returns true if the attribute key is an input that represents parameters (ends with ":Parameter").
        
        Args:
            attribute_key (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_an_input(cls, attribute_key: str) -> bool:
        r"""
        X.is_an_input(attribute_key) -> bool
        Returns true if the attribute key is associated with an input (starts with "Inputs:").
        
        Args:
            attribute_key (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def has_parameter(cls, interchange_node: InterchangeBaseNode, input_name: Name) -> bool:
        r"""
        X.has_parameter(interchange_node, input_name) -> bool
        Checks whether a particular input exists as a parameter on a given node.
        
        Args:
            interchange_node (InterchangeBaseNode): 
            input_name (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def has_input(cls, interchange_node: InterchangeBaseNode, input_name: Name) -> bool:
        r"""
        X.has_input(interchange_node, input_name) -> bool
        Checks whether a particular input exists on a given node.
        
        Args:
            interchange_node (InterchangeBaseNode): 
            input_name (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_input_connection(cls, interchange_node: InterchangeBaseNode, input_name: str) -> Optional[Tuple[str, str]]:
        r"""
        X.get_input_connection(interchange_node, input_name) -> (out_expression_uid=str, output_name=str) or None
        Retrieves the node unique id and the output name connected to a given input, if any.
        
        Args:
            interchange_node (InterchangeBaseNode): 
            input_name (str): 
        
        Returns:
            tuple or None: 
        
            out_expression_uid (str): 
        
            output_name (str):
        """
        ...
    @classmethod
    def gather_inputs(cls, interchange_node: InterchangeBaseNode) -> Array[str]:
        r"""
        X.gather_inputs(interchange_node) -> Array[str]
        Retrieves the names of all the inputs for a given node.
        
        Args:
            interchange_node (InterchangeBaseNode): 
        
        Returns:
            Array[str]: 
        
            out_input_names (Array[str]):
        """
        ...
    @classmethod
    def connect_ouput_to_input_by_name(cls, interchange_node: InterchangeBaseNode, input_name: str, expression_uid: str, output_name: str) -> bool:
        r"""
        X.connect_ouput_to_input_by_name(interchange_node, input_name, expression_uid, output_name) -> bool
        Adds an input connection attribute.
        
        Args:
            interchange_node (InterchangeBaseNode): The node to create the input on.
            input_name (str): The name to give to the input.
            expression_uid (str): The unique ID of the node to connect to the input.
            output_name (str): The name of the output from ExpressionUid to connect to the input.
        
        Returns:
            bool: True if the input connection was successfully added to the node.
        """
        ...
    @classmethod
    def connect_ouput_to_input_by_index(cls, interchange_node: InterchangeBaseNode, input_name: str, expression_uid: str, output_index: int) -> bool:
        r"""
        X.connect_ouput_to_input_by_index(interchange_node, input_name, expression_uid, output_index) -> bool
        Adds an input connection attribute.
        
        Args:
            interchange_node (InterchangeBaseNode): The node to create the input on.
            input_name (str): The name to give to the input.
            expression_uid (str): The unique ID of the node to connect to the input.
            output_index (int32): The index of the output from ExpressionUid to connect to the input.
        
        Returns:
            bool: True if the input connection was successfully added to the node. OutputIndex is encoded in a string in the following pattern: ExpressionUid:OutputByIndex:FString::FromInt(OutputIndex) The index should be retrieved using UInterchangeShaderPortsAPI::GetOutputIndexFromName().
        """
        ...
    @classmethod
    def connect_default_ouput_to_input(cls, interchange_node: InterchangeBaseNode, input_name: str, expression_uid: str) -> bool:
        r"""
        X.connect_default_ouput_to_input(interchange_node, input_name, expression_uid) -> bool
        Adds an input connection attribute.
        
        Args:
            interchange_node (InterchangeBaseNode): The node to create the input on.
            input_name (str): The name to give to the input.
            expression_uid (str): The unique ID of the node to connect to the input.
        
        Returns:
            bool: True if the input connection was successfully added to the node.
        """
        ...

class InterchangeFunctionCallShaderNode(InterchangeShaderNode):
    r"""
    A function call shader node has a named set of inputs and outputs which corresponds to the inputs and outputs of the shader function it instances.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeShaderGraphNode.h
    
    """
    def set_custom_material_function(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_material_function(attribute_value) -> bool
        Set the unique id of the material function referenced by the function call expression.
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_material_function(self) -> Optional[str]:
        r"""
        x.get_custom_material_function() -> str or None
        Get Custom Material Function
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...

class InterchangeShaderGraphNode(InterchangeShaderNode):
    r"""
    A shader graph has its own set of inputs on which shader nodes can be connected to.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeShaderGraphNode.h
    
    """
    def set_custom_two_sided_transmission(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_two_sided_transmission(attribute_value) -> bool
        Set Custom Two Sided Transmission
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_two_sided(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_two_sided(attribute_value) -> bool
        Set if this shader graph should be rendered two-sided or not. Defaults to off.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_screen_space_reflections(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_screen_space_reflections(attribute_value) -> bool
        Set Custom Screen Space Reflections
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_opacity_mask_clip_value(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_opacity_mask_clip_value(attribute_value, add_apply_delegate=True) -> bool
        The shader is transparent if its alpha value is lower than the clip value, or opaque if it is higher.
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_is_a_shader_function(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_is_a_shader_function(attribute_value) -> bool
        Set whether this shader graph should be considered as a material (false), or a material function (true).
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_blend_mode(self, attribute_value: int) -> bool:
        r"""
        x.set_custom_blend_mode(attribute_value) -> bool
        Set Custom Blend Mode
        
        Args:
            attribute_value (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_two_sided_transmission(self) -> Optional[bool]:
        r"""
        x.get_custom_two_sided_transmission() -> bool or None
        Forces two-sided even for Transmission materials.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_two_sided(self) -> Optional[bool]:
        r"""
        x.get_custom_two_sided() -> bool or None
        Get Custom Two Sided
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_screen_space_reflections(self) -> Optional[bool]:
        r"""
        x.get_custom_screen_space_reflections() -> bool or None
        Get Custom Screen Space Reflections
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_opacity_mask_clip_value(self) -> Optional[float]:
        r"""
        x.get_custom_opacity_mask_clip_value() -> float or None
        Get Custom Opacity Mask Clip Value
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_is_a_shader_function(self) -> Optional[bool]:
        r"""
        x.get_custom_is_a_shader_function() -> bool or None
        Get Custom Is AShader Function
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_blend_mode(self) -> Optional[int]:
        r"""
        x.get_custom_blend_mode() -> int32 or None
        Set the Blend Mode using EBlendMode to avoid a dependency on the Engine.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...

class InterchangeTexture2DNode(InterchangeTextureNode):
    r"""
    ns UE::Interchange
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeTexture2DNode.h
    
    """
    def set_custom_wrap_v(self, attribute_value: InterchangeTextureWrapMode) -> bool:
        r"""
        x.set_custom_wrap_v(attribute_value) -> bool
        Set Custom Wrap V
        
        Args:
            attribute_value (InterchangeTextureWrapMode): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_wrap_u(self, attribute_value: InterchangeTextureWrapMode) -> bool:
        r"""
        x.set_custom_wrap_u(attribute_value) -> bool
        Set Custom Wrap U
        
        Args:
            attribute_value (InterchangeTextureWrapMode): 
        
        Returns:
            bool:
        """
        ...
    def get_source_blocks(self) -> Map[int, str]:
        r"""
        x.get_source_blocks() -> Map[int32, str]
        Get the source blocks for the texture.
        If the map is empty, the texture is imported as a normal texture using the payload key.
        
        Returns:
            Map[int32, str]:
        """
        ...
    def get_custom_wrap_v(self) -> Optional[InterchangeTextureWrapMode]:
        r"""
        x.get_custom_wrap_v() -> InterchangeTextureWrapMode or None
        Get Custom Wrap V
        
        Returns:
            InterchangeTextureWrapMode or None: 
        
            attribute_value (InterchangeTextureWrapMode):
        """
        ...
    def get_custom_wrap_u(self) -> Optional[InterchangeTextureWrapMode]:
        r"""
        x.get_custom_wrap_u() -> InterchangeTextureWrapMode or None
        Get Custom Wrap U
        
        Returns:
            InterchangeTextureWrapMode or None: 
        
            attribute_value (InterchangeTextureWrapMode):
        """
        ...

class InterchangeTextureBlurNode(InterchangeTexture2DNode):
    r"""
    Interchange Texture Blur Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeNodes
    - **File**: InterchangeTextureBlurNode.h
    
    """
    ...

class InterchangeActorFactoryNode(InterchangeFactoryBaseNode):
    r"""
    Interchange Actor Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeActorFactoryNode.h
    
    """
    def set_custom_mobility(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_mobility(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Mobility
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_local_transform(self, attribute_value: Transform, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_local_transform(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Local Transform
        
        Args:
            attribute_value (Transform): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_global_transform(self, attribute_value: Transform, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_global_transform(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Global Transform
        
        Args:
            attribute_value (Transform): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_actor_class_name(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_actor_class_name(attribute_value) -> bool
        Set Custom Actor Class Name
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_mobility(self) -> Optional[int]:
        r"""
        x.get_custom_mobility() -> uint8 or None
        Get Custom Mobility
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_local_transform(self) -> Optional[Transform]:
        r"""
        x.get_custom_local_transform() -> Transform or None
        Get Custom Local Transform
        
        Returns:
            Transform or None: 
        
            attribute_value (Transform):
        """
        ...
    def get_custom_global_transform(self) -> Optional[Transform]:
        r"""
        x.get_custom_global_transform() -> Transform or None
        Get Custom Global Transform
        
        Returns:
            Transform or None: 
        
            attribute_value (Transform):
        """
        ...
    def get_custom_actor_class_name(self) -> Optional[str]:
        r"""
        x.get_custom_actor_class_name() -> str or None
        Get Custom Actor Class Name
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...

class InterchangePhysicalCameraFactoryNode(InterchangeActorFactoryNode):
    r"""
    Interchange Physical Camera Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeCameraFactoryNode.h
    
    """
    def set_custom_sensor_width(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_sensor_width(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Sensor Width
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_sensor_height(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_sensor_height(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Sensor Height
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_focus_method(self, attribute_value: CameraFocusMethod, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_focus_method(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Focus Method
        
        Args:
            attribute_value (CameraFocusMethod): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_focal_length(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_focal_length(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Focal Length
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_sensor_width(self) -> Optional[float]:
        r"""
        x.get_custom_sensor_width() -> float or None
        Get Custom Sensor Width
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_sensor_height(self) -> Optional[float]:
        r"""
        x.get_custom_sensor_height() -> float or None
        Get Custom Sensor Height
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_focus_method(self) -> Optional[CameraFocusMethod]:
        r"""
        x.get_custom_focus_method() -> CameraFocusMethod or None
        Get Custom Focus Method
        
        Returns:
            CameraFocusMethod or None: 
        
            attribute_value (CameraFocusMethod):
        """
        ...
    def get_custom_focal_length(self) -> Optional[float]:
        r"""
        x.get_custom_focal_length() -> float or None
        Get Custom Focal Length
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeCineCameraFactoryNode(InterchangePhysicalCameraFactoryNode):
    r"""
    deprecated: 'InterchangeCineCameraFactoryNode' was renamed to 'InterchangePhysicalCameraFactoryNode'.
    """
    ...

class InterchangeStandardCameraFactoryNode(InterchangeActorFactoryNode):
    r"""
    * Used for common non-physical camera with orthographic or perspective projection.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeCameraFactoryNode.h
    
    """
    def set_custom_width(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_width(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Width
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_projection_mode(self, attribute_value: CameraProjectionMode, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_projection_mode(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Projection Mode
        
        Args:
            attribute_value (CameraProjectionMode): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_near_clip_plane(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_near_clip_plane(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Near Clip Plane
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_field_of_view(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_field_of_view(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Field Of View
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_far_clip_plane(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_far_clip_plane(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Far Clip Plane
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_aspect_ratio(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_aspect_ratio(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Aspect Ratio
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_width(self) -> Optional[float]:
        r"""
        x.get_custom_width() -> float or None
        Get Custom Width
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_projection_mode(self) -> Optional[CameraProjectionMode]:
        r"""
        x.get_custom_projection_mode() -> CameraProjectionMode or None
        Get Custom Projection Mode
        
        Returns:
            CameraProjectionMode or None: 
        
            attribute_value (CameraProjectionMode):
        """
        ...
    def get_custom_near_clip_plane(self) -> Optional[float]:
        r"""
        x.get_custom_near_clip_plane() -> float or None
        Get Custom Near Clip Plane
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_field_of_view(self) -> Optional[float]:
        r"""
        x.get_custom_field_of_view() -> float or None
        Get Custom Field Of View
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_far_clip_plane(self) -> Optional[float]:
        r"""
        x.get_custom_far_clip_plane() -> float or None
        Get Custom Far Clip Plane
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_aspect_ratio(self) -> Optional[float]:
        r"""
        x.get_custom_aspect_ratio() -> float or None
        Get Custom Aspect Ratio
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeDecalActorFactoryNode(InterchangeActorFactoryNode):
    r"""
    Interchange Decal Actor Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeDecalActorFactoryNode.h
    
    """
    def set_custom_sort_order(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_sort_order(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Sort Order
        
        Args:
            attribute_value (int32): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_decal_size(self, attribute_value: Vector, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_decal_size(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Decal Size
        
        Args:
            attribute_value (Vector): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_decal_material_path_name(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_decal_material_path_name(attribute_value) -> bool
        Set Custom Decal Material Path Name
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get Object Class
        
        Returns:
            type(Class):
        """
        ...
    def get_custom_sort_order(self) -> Optional[int]:
        r"""
        x.get_custom_sort_order() -> int32 or None
        Get Custom Sort Order
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_decal_size(self) -> Optional[Vector]:
        r"""
        x.get_custom_decal_size() -> Vector or None
        Get Custom Decal Size
        
        Returns:
            Vector or None: 
        
            attribute_value (Vector):
        """
        ...
    def get_custom_decal_material_path_name(self) -> Optional[str]:
        r"""
        x.get_custom_decal_material_path_name() -> str or None
        Get Custom Decal Material Path Name
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...

class InterchangeBaseMaterialFactoryNode(InterchangeFactoryBaseNode):
    r"""
    Interchange Base Material Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeMaterialFactoryNode.h
    
    """
    def set_custom_is_material_import_enabled(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_is_material_import_enabled(attribute_value) -> bool
        Sets if this shader graph should be rendered two sided or not. Defaults to off.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_is_material_import_enabled(self) -> Optional[bool]:
        r"""
        x.get_custom_is_material_import_enabled() -> bool or None
        Get Custom Is Material Import Enabled
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...

class InterchangeDecalMaterialFactoryNode(InterchangeBaseMaterialFactoryNode):
    r"""
    Interchange Decal Material Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeDecalMaterialFactoryNode.h
    
    """
    def set_custom_normal_texture_path(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_normal_texture_path(attribute_value) -> bool
        Set Custom Normal Texture Path
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_diffuse_texture_path(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_diffuse_texture_path(attribute_value) -> bool
        Set Custom Diffuse Texture Path
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get Object Class
        
        Returns:
            type(Class):
        """
        ...
    def get_custom_normal_texture_path(self) -> Optional[str]:
        r"""
        x.get_custom_normal_texture_path() -> str or None
        Get Custom Normal Texture Path
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_diffuse_texture_path(self) -> Optional[str]:
        r"""
        x.get_custom_diffuse_texture_path() -> str or None
        Get Custom Diffuse Texture Path
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...

class InterchangeLevelSequenceFactoryNode(InterchangeFactoryBaseNode):
    r"""
    Interchange Level Sequence Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeLevelSequenceFactoryNode.h
    
    """
    def set_custom_frame_rate(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_frame_rate(attribute_value) -> bool
        Set the frame rate for the animations in the level sequence.
        
        Args:
            attribute_value (float): 
        
        Returns:
            bool:
        """
        ...
    def remove_custom_animation_track_uid(self, animation_track_uid: str) -> bool:
        r"""
        x.remove_custom_animation_track_uid(animation_track_uid) -> bool
        Remove one track dependency from this object.
        
        Args:
            animation_track_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get the class this node want to create
        
        Returns:
            type(Class):
        """
        ...
    def get_custom_frame_rate(self) -> Optional[float]:
        r"""
        x.get_custom_frame_rate() -> float or None
        Get the frame rate for the animations in the level sequence.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_animation_track_uids(self) -> Array[str]:
        r"""
        x.get_custom_animation_track_uids() -> Array[str]
        This function allow to retrieve the track dependency for this object.
        
        Returns:
            Array[str]: 
        
            out_animation_track_uids (Array[str]):
        """
        ...
    def get_custom_animation_track_uid_count(self) -> int:
        r"""
        x.get_custom_animation_track_uid_count() -> int32
        This function allow to retrieve the number of track dependencies for this object.
        
        Returns:
            int32:
        """
        ...
    def get_custom_animation_track_uid(self, index: int) -> str:
        r"""
        x.get_custom_animation_track_uid(index) -> str
        This function allow to retrieve one track dependency for this object.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_animation_track_uid (str):
        """
        ...
    def add_custom_animation_track_uid(self, animation_track_uid: str) -> bool:
        r"""
        x.add_custom_animation_track_uid(animation_track_uid) -> bool
        Add one track dependency to this object.
        
        Args:
            animation_track_uid (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeAnimationTrackSetFactoryNode(InterchangeLevelSequenceFactoryNode):
    r"""
    deprecated: 'InterchangeAnimationTrackSetFactoryNode' was renamed to 'InterchangeLevelSequenceFactoryNode'.
    """
    ...

class InterchangeBaseLightFactoryNode(InterchangeActorFactoryNode):
    r"""
    Interchange Base Light Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeLightFactoryNode.h
    
    """
    def set_custom_use_temperature(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_use_temperature(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Use Temperature
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_temperature(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_temperature(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Temperature
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_light_color(self, attribute_value: Color, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_light_color(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Light Color
        
        Args:
            attribute_value (Color): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_intensity(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_intensity(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Intensity
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_use_temperature(self) -> Optional[bool]:
        r"""
        x.get_custom_use_temperature() -> bool or None
        Get Custom Use Temperature
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_temperature(self) -> Optional[float]:
        r"""
        x.get_custom_temperature() -> float or None
        Get Custom Temperature
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_light_color(self) -> Optional[Color]:
        r"""
        x.get_custom_light_color() -> Color or None
        Get Custom Light Color
        
        Returns:
            Color or None: 
        
            attribute_value (Color):
        """
        ...
    def get_custom_intensity(self) -> Optional[float]:
        r"""
        x.get_custom_intensity() -> float or None
        Get Custom Intensity
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeDirectionalLightFactoryNode(InterchangeBaseLightFactoryNode):
    r"""
    Interchange Directional Light Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeLightFactoryNode.h
    
    """
    ...

class InterchangeLightFactoryNode(InterchangeBaseLightFactoryNode):
    r"""
    Interchange Light Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeLightFactoryNode.h
    
    """
    def set_custom_use_ies_brightness(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_use_ies_brightness(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Use IESBrightness
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_rotation(self, attribute_value: Rotator, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_rotation(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Rotation
        
        Args:
            attribute_value (Rotator): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_intensity_units(self, attribute_value: LightUnits, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_intensity_units(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Intensity Units
        
        Args:
            attribute_value (LightUnits): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_ies_texture(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_ies_texture(attribute_value) -> bool
        Set Custom IESTexture
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_ies_brightness_scale(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_ies_brightness_scale(attribute_value, add_apply_delegate=True) -> bool
        Set Custom IESBrightness Scale
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_attenuation_radius(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_attenuation_radius(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Attenuation Radius
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_use_ies_brightness(self) -> Optional[bool]:
        r"""
        x.get_custom_use_ies_brightness() -> bool or None
        Get Custom Use IESBrightness
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_rotation(self) -> Optional[Rotator]:
        r"""
        x.get_custom_rotation() -> Rotator or None
        Get Custom Rotation
        
        Returns:
            Rotator or None: 
        
            attribute_value (Rotator):
        """
        ...
    def get_custom_intensity_units(self) -> Optional[LightUnits]:
        r"""
        x.get_custom_intensity_units() -> LightUnits or None
        Get Custom Intensity Units
        
        Returns:
            LightUnits or None: 
        
            attribute_value (LightUnits):
        """
        ...
    def get_custom_ies_texture(self) -> Optional[str]:
        r"""
        x.get_custom_ies_texture() -> str or None
        Get Custom IESTexture
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_ies_brightness_scale(self) -> Optional[float]:
        r"""
        x.get_custom_ies_brightness_scale() -> float or None
        Get Custom IESBrightness Scale
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_attenuation_radius(self) -> Optional[float]:
        r"""
        x.get_custom_attenuation_radius() -> float or None
        Get Custom Attenuation Radius
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeRectLightFactoryNode(InterchangeLightFactoryNode):
    r"""
    Interchange Rect Light Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeLightFactoryNode.h
    
    """
    def set_custom_source_width(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_source_width(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Source Width
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_source_height(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_source_height(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Source Height
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_source_width(self) -> Optional[float]:
        r"""
        x.get_custom_source_width() -> float or None
        Get Custom Source Width
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_source_height(self) -> Optional[float]:
        r"""
        x.get_custom_source_height() -> float or None
        Get Custom Source Height
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangePointLightFactoryNode(InterchangeLightFactoryNode):
    r"""
    Interchange Point Light Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeLightFactoryNode.h
    
    """
    def set_custom_use_inverse_squared_falloff(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_use_inverse_squared_falloff(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Use Inverse Squared Falloff
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_light_falloff_exponent(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_light_falloff_exponent(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Light Falloff Exponent
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_use_inverse_squared_falloff(self) -> Optional[bool]:
        r"""
        x.get_custom_use_inverse_squared_falloff() -> bool or None
        Get Custom Use Inverse Squared Falloff
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_light_falloff_exponent(self) -> Optional[float]:
        r"""
        x.get_custom_light_falloff_exponent() -> float or None
        Get Custom Light Falloff Exponent
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeSpotLightFactoryNode(InterchangePointLightFactoryNode):
    r"""
    Interchange Spot Light Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeLightFactoryNode.h
    
    """
    def set_custom_outer_cone_angle(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_outer_cone_angle(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Outer Cone Angle
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_inner_cone_angle(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_inner_cone_angle(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Inner Cone Angle
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_outer_cone_angle(self) -> Optional[float]:
        r"""
        x.get_custom_outer_cone_angle() -> float or None
        Get Custom Outer Cone Angle
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_inner_cone_angle(self) -> Optional[float]:
        r"""
        x.get_custom_inner_cone_angle() -> float or None
        Get Custom Inner Cone Angle
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangePhysicsAssetFactoryNode(InterchangeFactoryBaseNode):
    r"""
    Interchange Physics Asset Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangePhysicsAssetFactoryNode.h
    
    """
    def set_custom_skeletal_mesh_uid(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_skeletal_mesh_uid(attribute_value) -> bool
        Set the Skeletal Mesh asset UID used to create the data in the post-pipeline step.
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def initialize_physics_asset_node(self, unique_id: str, display_label: str, asset_class: str) -> None:
        r"""
        x.initialize_physics_asset_node(unique_id, display_label, asset_class) -> None
        Initialize node data.
        param:: UniqueID - The unique ID for this node.
        
        Args:
            unique_id (str): 
            display_label (str): The name of the node.
            asset_class (str): The class the Skeleton factory will create for this node.
        """
        ...
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get the class this node creates.
        
        Returns:
            type(Class):
        """
        ...
    def get_custom_skeletal_mesh_uid(self) -> Optional[str]:
        r"""
        x.get_custom_skeletal_mesh_uid() -> str or None
        Get the Skeletal Mesh asset UID used to create the data in the post-pipeline step.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...

class InterchangeSceneVariantSetsFactoryNode(InterchangeFactoryBaseNode):
    r"""
    Interchange Scene Variant Sets Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeSceneVariantSetsFactoryNode.h
    
    """
    def remove_custom_variant_set_uid(self, variant_uid: str) -> bool:
        r"""
        x.remove_custom_variant_set_uid(variant_uid) -> bool
        Remove the specified unique ID of a translated VariantSet from this object.
        
        Args:
            variant_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get the class this node creates.
        
        Returns:
            type(Class):
        """
        ...
    def get_custom_variant_set_uids(self) -> Array[str]:
        r"""
        x.get_custom_variant_set_uids() -> Array[str]
        Retrieve the unique IDs of all translated VariantSets for this object.
        
        Returns:
            Array[str]: 
        
            out_variant_uids (Array[str]):
        """
        ...
    def get_custom_variant_set_uid_count(self) -> int:
        r"""
        x.get_custom_variant_set_uid_count() -> int32
        Retrieve the number of unique IDs of all translated VariantSets for this object.
        
        Returns:
            int32:
        """
        ...
    def get_custom_variant_set_uid(self, index: int) -> str:
        r"""
        x.get_custom_variant_set_uid(index) -> str
        Retrieve the UID of the VariantSet with the specified index.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_variant_uid (str):
        """
        ...
    def add_custom_variant_set_uid(self, variant_uid: str) -> bool:
        r"""
        x.add_custom_variant_set_uid(variant_uid) -> bool
        Add a unique id of a translated VariantSet for this object.
        
        Args:
            variant_uid (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeSkeletonFactoryNode(InterchangeFactoryBaseNode):
    r"""
    Interchange Skeleton Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeSkeletonFactoryNode.h
    
    """
    def set_custom_use_time_zero_for_bind_pose(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_use_time_zero_for_bind_pose(attribute_value) -> bool
        If AttributeValue is true, force this skeleton to use time-zero evaluation instead of its bind pose.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_skeletal_mesh_factory_node_uid(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_skeletal_mesh_factory_node_uid(attribute_value) -> bool
        Set Custom Skeletal Mesh Factory Node Uid
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_root_joint_uid(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_root_joint_uid(attribute_value) -> bool
        Set Custom Root Joint Uid
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def initialize_skeleton_node(self, unique_id: str, display_label: str, asset_class: str) -> None:
        r"""
        x.initialize_skeleton_node(unique_id, display_label, asset_class) -> None
        Initialize node data.
        param:: UniqueID - The unique ID for this node.
        
        Args:
            unique_id (str): 
            display_label (str): The name of the node.
            asset_class (str): The class the Skeleton factory will create for this node.
        """
        ...
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get the class this node creates.
        
        Returns:
            type(Class):
        """
        ...
    def get_custom_use_time_zero_for_bind_pose(self) -> Optional[bool]:
        r"""
        x.get_custom_use_time_zero_for_bind_pose() -> bool or None
        Query whether this skeleton should replace joint transforms with time-zero evaluation instead of bind pose.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_skeletal_mesh_factory_node_uid(self) -> Optional[str]:
        r"""
        x.get_custom_skeletal_mesh_factory_node_uid() -> str or None
        Get Custom Skeletal Mesh Factory Node Uid
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_root_joint_uid(self) -> Optional[str]:
        r"""
        x.get_custom_root_joint_uid() -> str or None
        Return false if the attribute was not set previously.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...

class InterchangeTextureFactoryNode(InterchangeFactoryBaseNode):
    r"""
    Interchange Texture Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeTextureFactoryNode.h
    
    """
    def set_custom_virtual_texture_streaming(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_virtual_texture_streaming(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Virtual Texture Streaming
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_translated_texture_node_uid(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_translated_texture_node_uid(attribute_value) -> bool
        Set the unique ID of the translated texture node. This is a reference to the node that was created by the translator. It is needed to get the texture payload.
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_srgb(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_srgb(attribute_value, add_apply_delegate=True) -> bool
        Set Custom SRGB
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_prefer_compressed_source_data(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_prefer_compressed_source_data(attribute_value) -> bool
        * Determines whether the factory should tell the translator to provide a compressed source data payload when available.
        * This will generally result in smaller assets. However, some operations like the texture build might be slower, because the source data first needs to be decompressed.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_power_of_two_mode(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_power_of_two_mode(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Power Of Two Mode
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_padding_color(self, attribute_value: Color, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_padding_color(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Padding Color
        
        Args:
            attribute_value (Color): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_mip_load_options(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_mip_load_options(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Mip Load Options
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_mip_gen_settings(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_mip_gen_settings(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Mip Gen Settings
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_max_texture_size(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_max_texture_size(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Max Texture Size
        
        Args:
            attribute_value (int32): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_lossy_compression_amount(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_lossy_compression_amount(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Lossy Compression Amount
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_lod_group(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_lod_group(attribute_value, add_apply_delegate=True) -> bool
        Set Custom LODGroup
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_lod_bias(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_lod_bias(attribute_value, add_apply_delegate=True) -> bool
        Set Custom LODBias
        
        Args:
            attribute_value (int32): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_filter(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_filter(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Filter
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_downscale_options(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_downscale_options(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Downscale Options
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_downscale(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_downscale(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Downscale
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_defer_compression(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_defer_compression(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Defer Compression
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_compression_settings(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_compression_settings(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Compression Settings
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_compression_quality(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_compression_quality(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Compression Quality
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_compression_no_alpha(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_compression_no_alpha(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Compression No Alpha
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_composite_texture_mode(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_composite_texture_mode(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Composite Texture Mode
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_composite_power(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_composite_power(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Composite Power
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_chroma_key_threshold(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_chroma_key_threshold(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Chroma Key Threshold
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_chroma_key_color(self, attribute_value: Color, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_chroma_key_color(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Chroma Key Color
        
        Args:
            attribute_value (Color): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_customb_use_legacy_gamma(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_customb_use_legacy_gamma(attribute_value, add_apply_delegate=True) -> bool
        Set Customb Use Legacy Gamma
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_customb_preserve_border(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_customb_preserve_border(attribute_value, add_apply_delegate=True) -> bool
        Set Customb Preserve Border
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_customb_flip_green_channel(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_customb_flip_green_channel(attribute_value, add_apply_delegate=True) -> bool
        Set Customb Flip Green Channel
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_customb_do_scale_mips_for_alpha_coverage(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_customb_do_scale_mips_for_alpha_coverage(attribute_value, add_apply_delegate=True) -> bool
        Set Customb Do Scale Mips for Alpha Coverage
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_customb_chroma_key_texture(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_customb_chroma_key_texture(attribute_value, add_apply_delegate=True) -> bool
        Set Customb Chroma Key Texture
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_alpha_coverage_thresholds(self, attribute_value: Vector4, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_alpha_coverage_thresholds(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Alpha Coverage Thresholds
        
        Args:
            attribute_value (Vector4): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_allow_non_power_of_two(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_allow_non_power_of_two(attribute_value) -> bool
        * Should the factory allow the import of texture that would have a resolution that is not a power of two
        * By default this is not allowed
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_adjust_vibrance(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_adjust_vibrance(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Adjust Vibrance
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_adjust_saturation(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_adjust_saturation(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Adjust Saturation
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_adjust_rgb_curve(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_adjust_rgb_curve(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Adjust RGBCurve
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_adjust_min_alpha(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_adjust_min_alpha(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Adjust Min Alpha
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_adjust_max_alpha(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_adjust_max_alpha(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Adjust Max Alpha
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_adjust_hue(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_adjust_hue(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Adjust Hue
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_adjust_brightness_curve(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_adjust_brightness_curve(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Adjust Brightness Curve
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_adjust_brightness(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_adjust_brightness(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Adjust Brightness
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def initialize_texture_node(self, unique_id: str, display_label: str, asset_name: str) -> None:
        r"""
        x.initialize_texture_node(unique_id, display_label, asset_name) -> None
        Initialize node data.
        param:: UniqueID - The unique ID for this node.
        
        Args:
            unique_id (str): 
            display_label (str): The name of the node.
            asset_name (str):
        """
        ...
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get the class this node creates.
        
        Returns:
            type(Class):
        """
        ...
    def get_custom_virtual_texture_streaming(self) -> Optional[bool]:
        r"""
        x.get_custom_virtual_texture_streaming() -> bool or None
        Return false if the Attribute was not set previously.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_translated_texture_node_uid(self) -> Optional[str]:
        r"""
        x.get_custom_translated_texture_node_uid() -> str or None
        Get the unique ID of the translated texture node.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_srgb(self) -> Optional[bool]:
        r"""
        x.get_custom_srgb() -> bool or None
        Return false if the Attribute was not set previously.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_prefer_compressed_source_data(self) -> Optional[bool]:
        r"""
        x.get_custom_prefer_compressed_source_data() -> bool or None
        Return false if the Attribute was not set previously.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_power_of_two_mode(self) -> Optional[int]:
        r"""
        x.get_custom_power_of_two_mode() -> uint8 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_padding_color(self) -> Optional[Color]:
        r"""
        x.get_custom_padding_color() -> Color or None
        Return false if the Attribute was not set previously.
        
        Returns:
            Color or None: 
        
            attribute_value (Color):
        """
        ...
    def get_custom_mip_load_options(self) -> Optional[int]:
        r"""
        x.get_custom_mip_load_options() -> uint8 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_mip_gen_settings(self) -> Optional[int]:
        r"""
        x.get_custom_mip_gen_settings() -> uint8 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_max_texture_size(self) -> Optional[int]:
        r"""
        x.get_custom_max_texture_size() -> int32 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_lossy_compression_amount(self) -> Optional[int]:
        r"""
        x.get_custom_lossy_compression_amount() -> uint8 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_lod_group(self) -> Optional[int]:
        r"""
        x.get_custom_lod_group() -> uint8 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_lod_bias(self) -> Optional[int]:
        r"""
        x.get_custom_lod_bias() -> int32 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_filter(self) -> Optional[int]:
        r"""
        x.get_custom_filter() -> uint8 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_downscale_options(self) -> Optional[int]:
        r"""
        x.get_custom_downscale_options() -> uint8 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_downscale(self) -> Optional[float]:
        r"""
        x.get_custom_downscale() -> float or None
        Return false if the Attribute was not set previously.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_defer_compression(self) -> Optional[bool]:
        r"""
        x.get_custom_defer_compression() -> bool or None
        Return false if the Attribute was not set previously.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_compression_settings(self) -> Optional[int]:
        r"""
        x.get_custom_compression_settings() -> uint8 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_compression_quality(self) -> Optional[int]:
        r"""
        x.get_custom_compression_quality() -> uint8 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_compression_no_alpha(self) -> Optional[bool]:
        r"""
        x.get_custom_compression_no_alpha() -> bool or None
        Return false if the Attribute was not set previously.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_composite_texture_mode(self) -> Optional[int]:
        r"""
        x.get_custom_composite_texture_mode() -> uint8 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_composite_power(self) -> Optional[float]:
        r"""
        x.get_custom_composite_power() -> float or None
        Return false if the Attribute was not set previously.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_chroma_key_threshold(self) -> Optional[float]:
        r"""
        x.get_custom_chroma_key_threshold() -> float or None
        Return false if the Attribute was not set previously.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_chroma_key_color(self) -> Optional[Color]:
        r"""
        x.get_custom_chroma_key_color() -> Color or None
        Return false if the Attribute was not set previously.
        
        Returns:
            Color or None: 
        
            attribute_value (Color):
        """
        ...
    def get_customb_use_legacy_gamma(self) -> Optional[bool]:
        r"""
        x.get_customb_use_legacy_gamma() -> bool or None
        Return false if the Attribute was not set previously.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_customb_preserve_border(self) -> Optional[bool]:
        r"""
        x.get_customb_preserve_border() -> bool or None
        Return false if the Attribute was not set previously.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_customb_flip_green_channel(self) -> Optional[bool]:
        r"""
        x.get_customb_flip_green_channel() -> bool or None
        Return false if the Attribute was not set previously.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_customb_do_scale_mips_for_alpha_coverage(self) -> Optional[bool]:
        r"""
        x.get_customb_do_scale_mips_for_alpha_coverage() -> bool or None
        Return false if the Attribute was not set previously.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_customb_chroma_key_texture(self) -> Optional[bool]:
        r"""
        x.get_customb_chroma_key_texture() -> bool or None
        Return false if the Attribute was not set previously.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_alpha_coverage_thresholds(self) -> Optional[Vector4]:
        r"""
        x.get_custom_alpha_coverage_thresholds() -> Vector4 or None
        Return false if the Attribute was not set previously.
        
        Returns:
            Vector4 or None: 
        
            attribute_value (Vector4):
        """
        ...
    def get_custom_allow_non_power_of_two(self) -> Optional[bool]:
        r"""
        x.get_custom_allow_non_power_of_two() -> bool or None
        Return false if the Attribute was not set previously.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_adjust_vibrance(self) -> Optional[float]:
        r"""
        x.get_custom_adjust_vibrance() -> float or None
        Return false if the Attribute was not set previously.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_adjust_saturation(self) -> Optional[float]:
        r"""
        x.get_custom_adjust_saturation() -> float or None
        Return false if the Attribute was not set previously.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_adjust_rgb_curve(self) -> Optional[float]:
        r"""
        x.get_custom_adjust_rgb_curve() -> float or None
        Return false if the Attribute was not set previously.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_adjust_min_alpha(self) -> Optional[float]:
        r"""
        x.get_custom_adjust_min_alpha() -> float or None
        Return false if the Attribute was not set previously.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_adjust_max_alpha(self) -> Optional[float]:
        r"""
        x.get_custom_adjust_max_alpha() -> float or None
        Return false if the Attribute was not set previously.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_adjust_hue(self) -> Optional[float]:
        r"""
        x.get_custom_adjust_hue() -> float or None
        Return false if the Attribute was not set previously.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_adjust_brightness_curve(self) -> Optional[float]:
        r"""
        x.get_custom_adjust_brightness_curve() -> float or None
        Return false if the Attribute was not set previously.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_adjust_brightness(self) -> Optional[float]:
        r"""
        x.get_custom_adjust_brightness() -> float or None
        Return false if the Attribute was not set previously.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeTexture2DArrayFactoryNode(InterchangeTextureFactoryNode):
    r"""
    Interchange Texture 2DArray Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeTexture2DArrayFactoryNode.h
    
    """
    def set_custom_address_z(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_address_z(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Address Z
        
        Args:
            attribute_value (uint8): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_address_z(self) -> Optional[int]:
        r"""
        x.get_custom_address_z() -> uint8 or None
        Get Custom Address Z
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_address_y(self) -> Optional[int]:
        r"""
        x.get_custom_address_y() -> uint8 or None
        Get Custom Address Y
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...
    def get_custom_address_x(self) -> Optional[int]:
        r"""
        x.get_custom_address_x() -> uint8 or None
        Get Custom Address X
        
        Returns:
            uint8 or None: 
        
            attribute_value (uint8):
        """
        ...

class InterchangeTexture2DFactoryNode(InterchangeTextureFactoryNode):
    r"""
    ns UE::Interchange
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeTexture2DFactoryNode.h
    
    """
    def set_source_blocks(self, source_blocks: Map[int, str]) -> None:
        r"""
        x.set_source_blocks(source_blocks) -> None
        Set the source blocks for the texture.
        Using this suggests to the pipeline to consider this texture as a UDIM. The pipeline can choose whether to pass these blocks to the texture factory node.
        
        Args:
            source_blocks (Map[int32, str]): The blocks and their source image that compose the whole texture. The textures must be of the same format and use the same pixel format. The first block in the map is used to determine the accepted texture format and pixel format.
        """
        ...
    def set_source_block_by_coordinates(self, x: int, y: int, source_file: str) -> None:
        r"""
        x.set_source_block_by_coordinates(x, y, source_file) -> None
        Set a source block for the texture.
        
        Args:
            x (int32): The X coordinate of the block.
            y (int32): The Y coordinate of the block.
            source_file (str): The source file for that block. The textures must be of the same format and use the same pixel format. The first block in the map is used to determine the accepted texture format and pixel format.
        """
        ...
    def set_source_block(self, block_index: int, source_file: str) -> None:
        r"""
        x.set_source_block(block_index, source_file) -> None
        Set a source block for the texture.
        
        Args:
            block_index (int32): The UDIM index of the block.
            source_file (str): The source file for that block. The textures must be of the same format and use the same pixel format. The first block in the map is used to determine the accepted texture format and pixel format.
        """
        ...
    def set_custom_address_y(self, attribute_value: TextureAddress, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_address_y(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Address Y
        
        Args:
            attribute_value (TextureAddress): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_address_x(self, attribute_value: TextureAddress, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_address_x(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Address X
        
        Args:
            attribute_value (TextureAddress): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_source_blocks(self) -> Map[int, str]:
        r"""
        x.get_source_blocks() -> Map[int32, str]
        Get the source blocks for the texture.
        If the map is empty, the texture is imported as a normal texture using the payload key.
        
        Returns:
            Map[int32, str]:
        """
        ...
    def get_source_block_by_coordinates(self, x: int, y: int) -> Optional[str]:
        r"""
        x.get_source_block_by_coordinates(x, y) -> str or None
        Get a source block from the texture.
        
        Args:
            x (int32): The X coordinate of the block.
            y (int32): The Y coordinate of the block.
        
        Returns:
            str or None: True if the source file for the block was found.
        
            out_source_file (str): The source file for that block if found.
        """
        ...
    def get_source_block(self, block_index: int) -> Optional[str]:
        r"""
        x.get_source_block(block_index) -> str or None
        Get a source block from the texture.
        
        Args:
            block_index (int32): The UDIM Index of the block.
        
        Returns:
            str or None: True if the source file for the block was found.
        
            out_source_file (str): The source file for that block if found.
        """
        ...
    def get_custom_address_y(self) -> Optional[TextureAddress]:
        r"""
        x.get_custom_address_y() -> TextureAddress or None
        Return false if the Attribute was not set previously.
        
        Returns:
            TextureAddress or None: 
        
            attribute_value (TextureAddress):
        """
        ...
    def get_custom_address_x(self) -> Optional[TextureAddress]:
        r"""
        x.get_custom_address_x() -> TextureAddress or None
        Return false if the Attribute was not set previously.
        
        Returns:
            TextureAddress or None: 
        
            attribute_value (TextureAddress):
        """
        ...

class InterchangeTextureCubeArrayFactoryNode(InterchangeTextureFactoryNode):
    r"""
    Interchange Texture Cube Array Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeTextureCubeArrayFactoryNode.h
    
    """
    ...

class InterchangeTextureCubeFactoryNode(InterchangeTextureFactoryNode):
    r"""
    Interchange Texture Cube Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeTextureCubeFactoryNode.h
    
    """
    ...

class InterchangeTextureLightProfileFactoryNode(InterchangeTexture2DFactoryNode):
    r"""
    Interchange Texture Light Profile Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeTextureLightProfileFactoryNode.h
    
    """
    def set_custom_texture_multiplier(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_texture_multiplier(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Texture Multiplier
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_brightness(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_brightness(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Brightness
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_texture_multiplier(self) -> Optional[float]:
        r"""
        x.get_custom_texture_multiplier() -> float or None
        Get Custom Texture Multiplier
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_brightness(self) -> Optional[float]:
        r"""
        x.get_custom_brightness() -> float or None
        Get Custom Brightness
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...

class InterchangeVolumeTextureFactoryNode(InterchangeTextureFactoryNode):
    r"""
    Interchange Volume Texture Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeVolumeTextureFactoryNode.h
    
    """
    ...

class InterchangeAnimSequenceFactoryNode(InterchangeFactoryBaseNode):
    r"""
    Interchange Anim Sequence Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeAnimSequenceFactoryNode.h
    
    """
    def set_custom_skeleton_soft_object_path(self, attribute_value: SoftObjectPath) -> bool:
        r"""
        x.set_custom_skeleton_soft_object_path(attribute_value) -> bool
        Set the optional existing USkeleton this animation must use. If this attribute is set and the skeleton is valid,
        the AnimSequence factory uses this skeleton instead of the one imported from GetCustomSkeletonFactoryNodeUid.
        Pipelines set this attribute when the user wants to specify an existing skeleton.
        
        Args:
            attribute_value (SoftObjectPath): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_skeleton_factory_node_uid(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_skeleton_factory_node_uid(attribute_value) -> bool
        Set the unique ID of the skeleton factory node. Return false if the attribute cannot be set.
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_remove_curve_redundant_keys(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_remove_curve_redundant_keys(attribute_value) -> bool
        Set the custom attribute RemoveCurveRedundantKeys. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_material_drive_parameter_on_custom_attribute(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_material_drive_parameter_on_custom_attribute(attribute_value) -> bool
        Set the custom attribute MaterialDriveParameterOnCustomAttribute. Return false if the attribute could not be set.
        
        Note: If true, sets Material Curve Type for all custom attributes.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_import_bone_tracks_sample_rate(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_import_bone_tracks_sample_rate(attribute_value) -> bool
        Set the import bone tracks sample rate. Return false if the attribute could not be set.
        
        Args:
            attribute_value (double): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_import_bone_tracks_range_stop(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_import_bone_tracks_range_stop(attribute_value) -> bool
        Set the import bone tracks end time in seconds. Return false if the attribute could not be set.
        
        Args:
            attribute_value (double): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_import_bone_tracks_range_start(self, attribute_value: float) -> bool:
        r"""
        x.set_custom_import_bone_tracks_range_start(attribute_value) -> bool
        Set the import bone tracks start time in seconds. Return false if the attribute could not be set.
        
        Args:
            attribute_value (double): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_import_bone_tracks(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_import_bone_tracks(attribute_value) -> bool
        Set the import bone tracks state. Pass true to import bone tracks, or false to not import bone tracks.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_import_attribute_curves(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_import_attribute_curves(attribute_value) -> bool
        Set the import attribute curves state. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_do_not_import_curve_with_zero(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_do_not_import_curve_with_zero(attribute_value) -> bool
        Set the custom attribute DoNotImportCurveWithZero. Return false if the attribute could not be set.
        
        Note - If this attribute is enabled, only curves that have a value other than zero will be imported. This is to avoid adding extra curves to evaluate.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_delete_existing_non_curve_custom_attributes(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_delete_existing_non_curve_custom_attributes(attribute_value) -> bool
        Set the custom attribute DeleteExistingNonCurveCustomAttributes. Return false if the attribute could not be set.
        
        Note - If true, all previous non-curve custom attributes are deleted if you reimport.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_delete_existing_morph_target_curves(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_delete_existing_morph_target_curves(attribute_value) -> bool
        Set the custom attribute DeleteExistingMorphTargetCurves. Return false if the attribute could not be set.
        
        Note: If true, all previous morph target curves are deleted if you reimport.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_delete_existing_custom_attribute_curves(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_delete_existing_custom_attribute_curves(attribute_value) -> bool
        Set the custom attribute DeleteExistingCustomAttributeCurves. Return false if the attribute could not be set.
        
        Note - If true, all previous custom attribute curves are deleted if you reimport.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_add_curve_metadata_to_skeleton(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_add_curve_metadata_to_skeleton(attribute_value) -> bool
        Set the custom attribute AddCurveMetadataToSkeleton. Return false if the attribute could not be set.
        
        Note - If this setting is disabled, curve metadata will be added to skeletal meshes for morph targets, but no metadata entry will be created for general curves.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_animation_payload_keys_for_scene_node_uids(self, scene_node_animation_payload_key_uids: Map[str, str], scene_node_animation_payload_key_types: Map[str, int]) -> None:
        r"""
        x.set_animation_payload_keys_for_scene_node_uids(scene_node_animation_payload_key_uids, scene_node_animation_payload_key_types) -> None
        Set Animation Payload Keys for Scene Node Uids
        
        Args:
            scene_node_animation_payload_key_uids (Map[str, str]): 
            scene_node_animation_payload_key_types (Map[str, uint8]):
        """
        ...
    def set_animation_payload_keys_for_morph_target_node_uids(self, morph_target_animation_payload_key_uids: Map[str, str], morph_target_animation_payload_key_types: Map[str, int]) -> None:
        r"""
        x.set_animation_payload_keys_for_morph_target_node_uids(morph_target_animation_payload_key_uids, morph_target_animation_payload_key_types) -> None
        Set Animation Payload Keys for Morph Target Node Uids
        
        Args:
            morph_target_animation_payload_key_uids (Map[str, str]): 
            morph_target_animation_payload_key_types (Map[str, uint8]):
        """
        ...
    def set_animated_material_curve_suffixe(self, material_curve_suffixe: str) -> bool:
        r"""
        x.set_animated_material_curve_suffixe(material_curve_suffixe) -> bool
        Add an animated material curve suffix.
        
        Args:
            material_curve_suffixe (str): 
        
        Returns:
            bool:
        """
        ...
    def set_animated_attribute_step_curve_name(self, attribute_step_curve_name: str) -> bool:
        r"""
        x.set_animated_attribute_step_curve_name(attribute_step_curve_name) -> bool
        Add an animated attribute step curve name.
        
        Args:
            attribute_step_curve_name (str): 
        
        Returns:
            bool:
        """
        ...
    def set_animated_attribute_curve_name(self, attribute_curve_name: str) -> bool:
        r"""
        x.set_animated_attribute_curve_name(attribute_curve_name) -> bool
        Add an animated attribute curve name.
        
        Args:
            attribute_curve_name (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_animated_material_curve_suffixe(self, material_curve_suffixe: str) -> bool:
        r"""
        x.remove_animated_material_curve_suffixe(material_curve_suffixe) -> bool
        Remove the specified animated material curve suffix.
        
        Args:
            material_curve_suffixe (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_animated_attribute_step_curve_name(self, attribute_step_curve_name: str) -> bool:
        r"""
        x.remove_animated_attribute_step_curve_name(attribute_step_curve_name) -> bool
        Remove the specified animated attribute step curve name.
        
        Args:
            attribute_step_curve_name (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_animated_attribute_curve_name(self, attribute_curve_name: str) -> bool:
        r"""
        x.remove_animated_attribute_curve_name(attribute_curve_name) -> bool
        Remove the specified animated attribute curve name.
        
        Args:
            attribute_curve_name (str): 
        
        Returns:
            bool:
        """
        ...
    def initialize_anim_sequence_node(self, unique_id: str, display_label: str) -> None:
        r"""
        x.initialize_anim_sequence_node(unique_id, display_label) -> None
        Initialize node data.
        
        Args:
            unique_id (str): The unique ID for this node.
            display_label (str): The name of the node.
        """
        ...
    def get_scene_node_animation_payload_keys(self) -> Map[str, InterchangeAnimationPayLoadKey]:
        r"""
        x.get_scene_node_animation_payload_keys() -> Map[str, InterchangeAnimationPayLoadKey]
        Get Scene Node Animation Payload Keys
        
        Returns:
            Map[str, InterchangeAnimationPayLoadKey]: 
        
            out_scene_node_animation_payload_keys (Map[str, InterchangeAnimationPayLoadKey]):
        """
        ...
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get the class this node creates.
        
        Returns:
            type(Class):
        """
        ...
    def get_morph_target_node_animation_payload_keys(self) -> Map[str, InterchangeAnimationPayLoadKey]:
        r"""
        x.get_morph_target_node_animation_payload_keys() -> Map[str, InterchangeAnimationPayLoadKey]
        Get Morph Target Node Animation Payload Keys
        
        Returns:
            Map[str, InterchangeAnimationPayLoadKey]: 
        
            out_morph_target_node_animation_payloads (Map[str, InterchangeAnimationPayLoadKey]):
        """
        ...
    def get_custom_skeleton_soft_object_path(self) -> Optional[SoftObjectPath]:
        r"""
        x.get_custom_skeleton_soft_object_path() -> SoftObjectPath or None
        Query the optional existing USkeleton this animation must use. If this attribute is set and the skeleton is valid,
        the AnimSequence factory uses this skeleton instead of the one imported from GetCustomSkeletonFactoryNodeUid.
        Pipelines set this attribute when the user wants to specify an existing skeleton.
        Return false if the attribute was not set.
        
        Returns:
            SoftObjectPath or None: 
        
            attribute_value (SoftObjectPath):
        """
        ...
    def get_custom_skeleton_factory_node_uid(self) -> Optional[str]:
        r"""
        x.get_custom_skeleton_factory_node_uid() -> str or None
        Get the unique ID of the skeleton factory node. Return false if the attribute is not set.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_remove_curve_redundant_keys(self) -> Optional[bool]:
        r"""
        x.get_custom_remove_curve_redundant_keys() -> bool or None
        Get the custom attribute RemoveCurveRedundantKeys. Return false if the attribute is not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_material_drive_parameter_on_custom_attribute(self) -> Optional[bool]:
        r"""
        x.get_custom_material_drive_parameter_on_custom_attribute() -> bool or None
        Get the custom attribute MaterialDriveParameterOnCustomAttribute. Return false if the attribute is not set.
        
        Note: If true, sets Material Curve Type for all custom attributes.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_import_bone_tracks_sample_rate(self) -> Optional[float]:
        r"""
        x.get_custom_import_bone_tracks_sample_rate() -> double or None
        Get the import bone tracks sample rate. Return false if the attribute is not set.
        
        Returns:
            double or None: 
        
            attribute_value (double):
        """
        ...
    def get_custom_import_bone_tracks_range_stop(self) -> Optional[float]:
        r"""
        x.get_custom_import_bone_tracks_range_stop() -> double or None
        Get the import bone tracks end time in seconds. Return false if the attribute is not set.
        
        Returns:
            double or None: 
        
            attribute_value (double):
        """
        ...
    def get_custom_import_bone_tracks_range_start(self) -> Optional[float]:
        r"""
        x.get_custom_import_bone_tracks_range_start() -> double or None
        Get the import bone tracks start time in seconds. Return false if the attribute is not set.
        
        Returns:
            double or None: 
        
            attribute_value (double):
        """
        ...
    def get_custom_import_bone_tracks(self) -> Optional[bool]:
        r"""
        x.get_custom_import_bone_tracks() -> bool or None
        Get the import bone tracks state. If the attribute is true, bone tracks are imported. If the attribute
        is false, bone tracks are not imported.
        
        Return false if the attribute is not set. Return true if the attribute exists and can be queried.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_import_attribute_curves(self) -> Optional[bool]:
        r"""
        x.get_custom_import_attribute_curves() -> bool or None
        Get the import attribute curves state. If true, all user custom attributes on nodes are imported.
        
        Return false if the attribute is not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_do_not_import_curve_with_zero(self) -> Optional[bool]:
        r"""
        x.get_custom_do_not_import_curve_with_zero() -> bool or None
        Get the custom attribute DoNotImportCurveWithZero. Return false if the attribute is not set.
        
        Note - If this attribute is enabled, only curves that have a value other than zero will be imported. This is to avoid adding extra curves to evaluate.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_delete_existing_non_curve_custom_attributes(self) -> Optional[bool]:
        r"""
        x.get_custom_delete_existing_non_curve_custom_attributes() -> bool or None
        Get the custom attribute DeleteExistingNonCurveCustomAttributes. Return false if the attribute is not set.
        
        Note - If true, all previous non-curve custom attributes are deleted if you reimport.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_delete_existing_morph_target_curves(self) -> Optional[bool]:
        r"""
        x.get_custom_delete_existing_morph_target_curves() -> bool or None
        Get the custom attribute DeleteExistingMorphTargetCurves. Return false if the attribute is not set.
        
        Note: If true, all previous morph target curves are deleted if you reimport.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_delete_existing_custom_attribute_curves(self) -> Optional[bool]:
        r"""
        x.get_custom_delete_existing_custom_attribute_curves() -> bool or None
        Get the custom attribute DeleteExistingCustomAttributeCurves. Return false if the attribute is not set.
        
        Note - If true, all previous custom attribute curves are deleted if you reimport.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_add_curve_metadata_to_skeleton(self) -> Optional[bool]:
        r"""
        x.get_custom_add_curve_metadata_to_skeleton() -> bool or None
        Get the custom attribute AddCurveMetadataToSkeleton. Return false if the attribute is not set.
        
        Note - If this setting is disabled, curve metadata will be added to skeletal meshes for morph targets, but no metadata entry will be created for general curves.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_animated_material_curve_suffixes_count(self) -> int:
        r"""
        x.get_animated_material_curve_suffixes_count() -> int32
        Return the number of animated material curve suffixes this anim sequence drives. Curves are FRichCurve of type float.
        
        Returns:
            int32:
        """
        ...
    def get_animated_material_curve_suffixes(self) -> Array[str]:
        r"""
        x.get_animated_material_curve_suffixes() -> Array[str]
        Get all animated material curve suffixes.
        
        Returns:
            Array[str]: 
        
            out_material_curve_suffixes (Array[str]):
        """
        ...
    def get_animated_material_curve_suffixe(self, index: int) -> str:
        r"""
        x.get_animated_material_curve_suffixe(index) -> str
        Get the animated material curve suffix with the specified index.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_material_curve_suffixe (str):
        """
        ...
    def get_animated_attribute_step_curve_names_count(self) -> int:
        r"""
        x.get_animated_attribute_step_curve_names_count() -> int32
        Return the number of animated attribute step curve names this anim sequence drives.
        
        Returns:
            int32:
        """
        ...
    def get_animated_attribute_step_curve_names(self) -> Array[str]:
        r"""
        x.get_animated_attribute_step_curve_names() -> Array[str]
        Get all animated attribute step curve names.
        
        Returns:
            Array[str]: 
        
            out_attribute_step_curve_names (Array[str]):
        """
        ...
    def get_animated_attribute_step_curve_name(self, index: int) -> str:
        r"""
        x.get_animated_attribute_step_curve_name(index) -> str
        Get the animated attribute step curve name at the specified index.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_attribute_step_curve_name (str):
        """
        ...
    def get_animated_attribute_curve_names_count(self) -> int:
        r"""
        x.get_animated_attribute_curve_names_count() -> int32
        Return the number of animated attribute curve names this anim sequence drives. Curves are FRichCurve of type float.
        
        Returns:
            int32:
        """
        ...
    def get_animated_attribute_curve_names(self) -> Array[str]:
        r"""
        x.get_animated_attribute_curve_names() -> Array[str]
        Get all animated attribute curve names.
        
        Returns:
            Array[str]: 
        
            out_attribute_curve_names (Array[str]):
        """
        ...
    def get_animated_attribute_curve_name(self, index: int) -> str:
        r"""
        x.get_animated_attribute_curve_name(index) -> str
        Get the animated attribute curve name at the specified index.
        
        Args:
            index (int32): 
        
        Returns:
            str: 
        
            out_attribute_curve_name (str):
        """
        ...

class InterchangeCommonPipelineDataFactoryNode(InterchangeFactoryBaseNode):
    r"""
    This factory node is where pipelines can set global data that can be used by factories.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeCommonPipelineDataFactoryNode.h
    
    """
    def set_custom_global_offset_transform(self, node_container: InterchangeBaseNodeContainer, attribute_value: Transform) -> bool:
        r"""
        x.set_custom_global_offset_transform(node_container, attribute_value) -> bool
        Pipelines can set a global transform. Factories will use this global offset when importing assets.
        
        Args:
            node_container (InterchangeBaseNodeContainer): 
            attribute_value (Transform): 
        
        Returns:
            bool:
        """
        ...
    def set_bake_meshes(self, node_container: InterchangeBaseNodeContainer, attribute_value: bool) -> bool:
        r"""
        x.set_bake_meshes(node_container, attribute_value) -> bool
        Pipelines can set this Bake Meshes setting. Factories use this to identify whether they should apply global transforms to static meshes and skeletal meshes.
        
        Args:
            node_container (InterchangeBaseNodeContainer): 
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_global_offset_transform(self) -> Optional[Transform]:
        r"""
        x.get_custom_global_offset_transform() -> Transform or None
        Return the global offset transform set by the pipelines.
        
        Returns:
            Transform or None: 
        
            attribute_value (Transform):
        """
        ...
    def get_bake_meshes(self) -> Optional[bool]:
        r"""
        x.get_bake_meshes() -> bool or None
        Return the value of the Bake Meshes setting set by the pipelines.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...

class InterchangeMaterialFactoryNode(InterchangeBaseMaterialFactoryNode):
    r"""
    Interchange Material Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeMaterialFactoryNode.h
    
    """
    def set_custom_two_sided(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_two_sided(attribute_value, add_apply_delegate=True) -> bool
        Sets if this shader graph should be rendered two sided or not. Defaults to off.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_translucency_lighting_mode(self, attribute_value: TranslucencyLightingMode, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_translucency_lighting_mode(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Translucency Lighting Mode
        
        Args:
            attribute_value (TranslucencyLightingMode): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_shading_model(self, attribute_value: MaterialShadingModel, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_shading_model(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Shading Model
        
        Args:
            attribute_value (MaterialShadingModel): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_screen_space_reflections(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_screen_space_reflections(attribute_value) -> bool
        Set Custom Screen Space Reflections
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_refraction_method(self, attribute_value: RefractionMode, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_refraction_method(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Refraction Method
        
        Args:
            attribute_value (RefractionMode): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_opacity_mask_clip_value(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_opacity_mask_clip_value(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Opacity Mask Clip Value
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_blend_mode(self, attribute_value: BlendMode, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_blend_mode(attribute_value, add_apply_delegate=True) -> bool
        Set Custom Blend Mode
        
        Args:
            attribute_value (BlendMode): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def get_transmission_color_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_transmission_color_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Transmission Color Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_tangent_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_tangent_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Tangent Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_subsurface_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_subsurface_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Subsurface Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_specular_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_specular_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Specular Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_roughness_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_roughness_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Roughness Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_refraction_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_refraction_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Refraction Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_opacity_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_opacity_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Opacity Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_occlusion_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_occlusion_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Occlusion Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get Object Class
        
        Returns:
            type(Class):
        """
        ...
    def get_normal_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_normal_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Normal Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_metallic_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_metallic_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Metallic Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_fuzz_color_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_fuzz_color_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Fuzz Color Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_emissive_color_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_emissive_color_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Emissive Color Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_custom_two_sided(self) -> Optional[bool]:
        r"""
        x.get_custom_two_sided() -> bool or None
        Get Custom Two Sided
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_translucency_lighting_mode(self) -> Optional[TranslucencyLightingMode]:
        r"""
        x.get_custom_translucency_lighting_mode() -> TranslucencyLightingMode or None
        Get Custom Translucency Lighting Mode
        
        Returns:
            TranslucencyLightingMode or None: 
        
            attribute_value (TranslucencyLightingMode):
        """
        ...
    def get_custom_shading_model(self) -> Optional[MaterialShadingModel]:
        r"""
        x.get_custom_shading_model() -> MaterialShadingModel or None
        Get Custom Shading Model
        
        Returns:
            MaterialShadingModel or None: 
        
            attribute_value (MaterialShadingModel):
        """
        ...
    def get_custom_screen_space_reflections(self) -> Optional[bool]:
        r"""
        x.get_custom_screen_space_reflections() -> bool or None
        Get Custom Screen Space Reflections
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_refraction_method(self) -> Optional[RefractionMode]:
        r"""
        x.get_custom_refraction_method() -> RefractionMode or None
        Get Custom Refraction Method
        
        Returns:
            RefractionMode or None: 
        
            attribute_value (RefractionMode):
        """
        ...
    def get_custom_opacity_mask_clip_value(self) -> Optional[float]:
        r"""
        x.get_custom_opacity_mask_clip_value() -> float or None
        Get Custom Opacity Mask Clip Value
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_blend_mode(self) -> Optional[BlendMode]:
        r"""
        x.get_custom_blend_mode() -> BlendMode or None
        Get Custom Blend Mode
        
        Returns:
            BlendMode or None: 
        
            attribute_value (BlendMode):
        """
        ...
    def get_cloth_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_cloth_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Cloth Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_clear_coat_roughness_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_clear_coat_roughness_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Clear Coat Roughness Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_clear_coat_normal_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_clear_coat_normal_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Clear Coat Normal Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_clear_coat_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_clear_coat_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Clear Coat Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_base_color_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_base_color_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Base Color Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def get_anisotropy_connection(self) -> Optional[Tuple[str, str]]:
        r"""
        x.get_anisotropy_connection() -> (expression_node_uid=str, output_name=str) or None
        Get Anisotropy Connection
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...
    def connect_to_transmission_color(self, attribute_value: str) -> bool:
        r"""
        x.connect_to_transmission_color(attribute_value) -> bool
        Connect to Transmission Color
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_tangent(self, expression_node_uid: str) -> bool:
        r"""
        x.connect_to_tangent(expression_node_uid) -> bool
        Connect to Tangent
        
        Args:
            expression_node_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_subsurface(self, expression_node_uid: str) -> bool:
        r"""
        x.connect_to_subsurface(expression_node_uid) -> bool
        Connect to Subsurface
        
        Args:
            expression_node_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_specular(self, expression_node_uid: str) -> bool:
        r"""
        x.connect_to_specular(expression_node_uid) -> bool
        Connect to Specular
        
        Args:
            expression_node_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_roughness(self, expression_node_uid: str) -> bool:
        r"""
        x.connect_to_roughness(expression_node_uid) -> bool
        Connect to Roughness
        
        Args:
            expression_node_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_refraction(self, attribute_value: str) -> bool:
        r"""
        x.connect_to_refraction(attribute_value) -> bool
        Connect to Refraction
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_opacity(self, attribute_value: str) -> bool:
        r"""
        x.connect_to_opacity(attribute_value) -> bool
        Connect to Opacity
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_occlusion(self, attribute_value: str) -> bool:
        r"""
        x.connect_to_occlusion(attribute_value) -> bool
        Connect to Occlusion
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_normal(self, expression_node_uid: str) -> bool:
        r"""
        x.connect_to_normal(expression_node_uid) -> bool
        Connect to Normal
        
        Args:
            expression_node_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_metallic(self, attribute_value: str) -> bool:
        r"""
        x.connect_to_metallic(attribute_value) -> bool
        Connect to Metallic
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_fuzz_color(self, attribute_value: str) -> bool:
        r"""
        x.connect_to_fuzz_color(attribute_value) -> bool
        Connect to Fuzz Color
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_emissive_color(self, expression_node_uid: str) -> bool:
        r"""
        x.connect_to_emissive_color(expression_node_uid) -> bool
        Connect to Emissive Color
        
        Args:
            expression_node_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_cloth(self, attribute_value: str) -> bool:
        r"""
        x.connect_to_cloth(attribute_value) -> bool
        Connect to Cloth
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_clear_coat_roughness(self, attribute_value: str) -> bool:
        r"""
        x.connect_to_clear_coat_roughness(attribute_value) -> bool
        Connect to Clear Coat Roughness
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_clear_coat_normal(self, attribute_value: str) -> bool:
        r"""
        x.connect_to_clear_coat_normal(attribute_value) -> bool
        Connect to Clear Coat Normal
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_clear_coat(self, attribute_value: str) -> bool:
        r"""
        x.connect_to_clear_coat(attribute_value) -> bool
        Connect to Clear Coat
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_base_color(self, attribute_value: str) -> bool:
        r"""
        x.connect_to_base_color(attribute_value) -> bool
        Connect to Base Color
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_to_anisotropy(self, expression_node_uid: str) -> bool:
        r"""
        x.connect_to_anisotropy(expression_node_uid) -> bool
        Connect to Anisotropy
        
        Args:
            expression_node_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_transmission_color(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_transmission_color(expression_node_uid, output_name) -> bool
        Connect Output to Transmission Color
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_tangent(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_tangent(expression_node_uid, output_name) -> bool
        Connect Output to Tangent
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_subsurface(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_subsurface(expression_node_uid, output_name) -> bool
        Connect Output to Subsurface
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_specular(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_specular(expression_node_uid, output_name) -> bool
        Connect Output to Specular
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_roughness(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_roughness(expression_node_uid, output_name) -> bool
        Connect Output to Roughness
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_refraction(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_refraction(expression_node_uid, output_name) -> bool
        Connect Output to Refraction
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_opacity(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_opacity(expression_node_uid, output_name) -> bool
        Connect Output to Opacity
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_occlusion(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_occlusion(expression_node_uid, output_name) -> bool
        Connect Output to Occlusion
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_normal(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_normal(expression_node_uid, output_name) -> bool
        Connect Output to Normal
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_metallic(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_metallic(expression_node_uid, output_name) -> bool
        Connect Output to Metallic
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_fuzz_color(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_fuzz_color(expression_node_uid, output_name) -> bool
        Connect Output to Fuzz Color
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_emissive_color(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_emissive_color(expression_node_uid, output_name) -> bool
        Connect Output to Emissive Color
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_cloth(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_cloth(expression_node_uid, output_name) -> bool
        Connect Output to Cloth
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_clear_coat_roughness(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_clear_coat_roughness(expression_node_uid, output_name) -> bool
        Connect Output to Clear Coat Roughness
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_clear_coat_normal(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_clear_coat_normal(expression_node_uid, output_name) -> bool
        Connect Output to Clear Coat Normal
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_clear_coat(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_clear_coat(expression_node_uid, output_name) -> bool
        Connect Output to Clear Coat
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_base_color(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_base_color(expression_node_uid, output_name) -> bool
        Connect Output to Base Color
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...
    def connect_output_to_anisotropy(self, expression_node_uid: str, output_name: str) -> bool:
        r"""
        x.connect_output_to_anisotropy(expression_node_uid, output_name) -> bool
        Connect Output to Anisotropy
        
        Args:
            expression_node_uid (str): 
            output_name (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeMaterialExpressionFactoryNode(InterchangeFactoryBaseNode):
    r"""
    Interchange Material Expression Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeMaterialFactoryNode.h
    
    """
    def set_custom_expression_class_name(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_expression_class_name(attribute_value) -> bool
        Set Custom Expression Class Name
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_expression_class_name(self) -> Optional[str]:
        r"""
        x.get_custom_expression_class_name() -> str or None
        Get Custom Expression Class Name
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...

class InterchangeMaterialInstanceFactoryNode(InterchangeBaseMaterialFactoryNode):
    r"""
    Interchange Material Instance Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeMaterialFactoryNode.h
    
    """
    def set_custom_parent(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_parent(attribute_value) -> bool
        Set Custom Parent
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_instance_class_name(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_instance_class_name(attribute_value) -> bool
        Set Custom Instance Class Name
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_parent(self) -> Optional[str]:
        r"""
        x.get_custom_parent() -> str or None
        Get Custom Parent
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def get_custom_instance_class_name(self) -> Optional[str]:
        r"""
        x.get_custom_instance_class_name() -> str or None
        Get Custom Instance Class Name
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...

class InterchangeMaterialFunctionCallExpressionFactoryNode(InterchangeMaterialExpressionFactoryNode):
    r"""
    Interchange Material Function Call Expression Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeMaterialFactoryNode.h
    
    """
    def set_custom_material_function_dependency(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_material_function_dependency(attribute_value) -> bool
        Set the unique ID of the material function that the function call expression
        is referring to.
        Note that a call to AddFactoryDependencyUid is made to guarantee that
        the material function is created before the function call expression
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def get_custom_material_function_dependency(self) -> Optional[str]:
        r"""
        x.get_custom_material_function_dependency() -> str or None
        Get Custom Material Function Dependency
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...

class InterchangeMaterialFunctionFactoryNode(InterchangeBaseMaterialFactoryNode):
    r"""
    Interchange Material Function Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeMaterialFactoryNode.h
    
    """
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get Object Class
        
        Returns:
            type(Class):
        """
        ...
    def get_input_connection(self, input_name: str) -> Optional[Tuple[str, str]]:
        r"""
        x.get_input_connection(input_name) -> (expression_node_uid=str, output_name=str) or None
        Get Input Connection
        
        Args:
            input_name (str): 
        
        Returns:
            tuple or None: 
        
            expression_node_uid (str): 
        
            output_name (str):
        """
        ...

class InterchangeMeshActorFactoryNode(InterchangeActorFactoryNode):
    r"""
    Interchange Mesh Actor Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeMeshActorFactoryNode.h
    
    """
    def set_slot_material_dependency_uid(self, slot_name: str, material_dependency_uid: str) -> bool:
        r"""
        x.set_slot_material_dependency_uid(slot_name, material_dependency_uid) -> bool
        Add a Material dependency to the specified slot of this object.
        
        Args:
            slot_name (str): 
            material_dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_geometric_transform(self, attribute_value: Transform) -> bool:
        r"""
        x.set_custom_geometric_transform(attribute_value) -> bool
        Set the geometric offset. Any mesh attached to this scene node will be offset using this transform.
        
        Args:
            attribute_value (Transform): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_animation_asset_uid_to_play(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_animation_asset_uid_to_play(attribute_value) -> bool
        Set the animation asset for this scene node to play. (This is only relevant for SkeletalMeshActors: scene nodes that are instantiating skeletal meshes.)
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_slot_material_dependency_uid(self, slot_name: str) -> bool:
        r"""
        x.remove_slot_material_dependency_uid(slot_name) -> bool
        Remove the Material dependency associated with the specified slot name from this object.
        
        Args:
            slot_name (str): 
        
        Returns:
            bool:
        """
        ...
    def get_slot_material_dependency_uid(self, slot_name: str) -> Optional[str]:
        r"""
        x.get_slot_material_dependency_uid(slot_name) -> str or None
        Retrieve the Material dependency for the specified slot of this object.
        
        Args:
            slot_name (str): 
        
        Returns:
            str or None: 
        
            out_material_dependency (str):
        """
        ...
    def get_slot_material_dependencies(self) -> Map[str, str]:
        r"""
        x.get_slot_material_dependencies() -> Map[str, str]
        Retrieve the correspondence table between slot names and assigned materials for this object.
        
        Returns:
            Map[str, str]: 
        
            out_material_dependencies (Map[str, str]):
        """
        ...
    def get_custom_geometric_transform(self) -> Optional[Transform]:
        r"""
        x.get_custom_geometric_transform() -> Transform or None
        Get the geometric offset. Any mesh attached to this scene node will be offset using this transform.
        
        Returns:
            Transform or None: 
        
            attribute_value (Transform):
        """
        ...
    def get_custom_animation_asset_uid_to_play(self) -> Optional[str]:
        r"""
        x.get_custom_animation_asset_uid_to_play() -> str or None
        Get the animation asset set for this scene node to play.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...

class InterchangeMeshFactoryNode(InterchangeFactoryBaseNode):
    r"""
    namespace Interchange
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeMeshFactoryNode.h
    
    """
    def set_slot_material_dependency_uid(self, slot_name: str, material_dependency_uid: str) -> bool:
        r"""
        x.set_slot_material_dependency_uid(slot_name, material_dependency_uid) -> bool
        Add a Material dependency to the specified slot of this object.
        
        Args:
            slot_name (str): 
            material_dependency_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_vertex_color_replace(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_vertex_color_replace(attribute_value) -> bool
        Set whether the static mesh factory should replace the vertex color. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_vertex_color_override(self, attribute_value: Color) -> bool:
        r"""
        x.set_custom_vertex_color_override(attribute_value) -> bool
        Set whether the static mesh factory should override the vertex color. Return false if the attribute could not be set.
        
        Args:
            attribute_value (Color): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_vertex_color_ignore(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_vertex_color_ignore(attribute_value) -> bool
        Set whether the static mesh factory should ignore the vertex color. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_use_mikk_t_space(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_use_mikk_t_space(attribute_value, add_apply_delegate=True) -> bool
        Set whether tangents are recomputed using MikkTSpace when they need to be recomputed.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_use_high_precision_tangent_basis(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_use_high_precision_tangent_basis(attribute_value, add_apply_delegate=True) -> bool
        Set whether tangents are stored at 16-bit precision instead of the default 8-bit precision.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_use_full_precision_u_vs(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_use_full_precision_u_vs(attribute_value, add_apply_delegate=True) -> bool
        Set whether UVs are stored at full floating point precision.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_use_backwards_compatible_f16_trunc_u_vs(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_use_backwards_compatible_f16_trunc_u_vs(attribute_value, add_apply_delegate=True) -> bool
        Set whether UVs are converted to 16-bit by a legacy truncation process instead of the default rounding process. This may avoid differences when reimporting older content.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_remove_degenerates(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_remove_degenerates(attribute_value, add_apply_delegate=True) -> bool
        Set whether degenerate triangles are removed.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_recompute_tangents(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_recompute_tangents(attribute_value, add_apply_delegate=True) -> bool
        Set whether tangents in the imported mesh are ignored and recomputed.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_recompute_normals(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_recompute_normals(attribute_value, add_apply_delegate=True) -> bool
        Set whether normals in the imported mesh are ignored and recomputed. When normals are recomputed, the tangents are also recomputed.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_lod_group(self, attribute_value: Name, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_lod_group(attribute_value, add_apply_delegate=True) -> bool
        Set a custom LOD group for the mesh.
        
        Args:
            attribute_value (Name): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_keep_sections_separate(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_keep_sections_separate(attribute_value) -> bool
        Set whether sections with matching materials are kept separate and will not get combined.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_compute_weighted_normals(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_compute_weighted_normals(attribute_value, add_apply_delegate=True) -> bool
        Set whether normals are recomputed by weighting the surface area and the corner angle of the triangle as a ratio.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def reset_slot_material_dependencies(self) -> bool:
        r"""
        x.reset_slot_material_dependencies() -> bool
        Reset all the material dependencies.
        
        Returns:
            bool:
        """
        ...
    def remove_slot_material_dependency_uid(self, slot_name: str) -> bool:
        r"""
        x.remove_slot_material_dependency_uid(slot_name) -> bool
        Remove the Material dependency associated with the specfied slot name of this object.
        
        Args:
            slot_name (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_lod_data_unique_id(self, lod_data_unique_id: str) -> bool:
        r"""
        x.remove_lod_data_unique_id(lod_data_unique_id) -> bool
        Remove Lod Data Unique Id
        
        Args:
            lod_data_unique_id (str): 
        
        Returns:
            bool:
        """
        ...
    def get_slot_material_dependency_uid(self, slot_name: str) -> Optional[str]:
        r"""
        x.get_slot_material_dependency_uid(slot_name) -> str or None
        Retrieve the Material dependency for the specified slot of this object.
        
        Args:
            slot_name (str): 
        
        Returns:
            str or None: 
        
            out_material_dependency (str):
        """
        ...
    def get_slot_material_dependencies(self) -> Map[str, str]:
        r"""
        x.get_slot_material_dependencies() -> Map[str, str]
        Retrieve the correspondence table between slot names and assigned materials for this object.
        
        Returns:
            Map[str, str]: 
        
            out_material_dependencies (Map[str, str]):
        """
        ...
    def get_lod_data_unique_ids(self) -> Array[str]:
        r"""
        x.get_lod_data_unique_ids() -> Array[str]
        Get Lod Data Unique Ids
        
        Returns:
            Array[str]: 
        
            out_lod_data_unique_ids (Array[str]):
        """
        ...
    def get_lod_data_count(self) -> int:
        r"""
        x.get_lod_data_count() -> int32
        Return the number of LODs this static mesh has.
        
        Returns:
            int32:
        """
        ...
    def get_custom_vertex_color_replace(self) -> Optional[bool]:
        r"""
        x.get_custom_vertex_color_replace() -> bool or None
        Query whether the static mesh factory should replace the vertex color. Return false if the attribute was not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_vertex_color_override(self) -> Optional[Color]:
        r"""
        x.get_custom_vertex_color_override() -> Color or None
        Query whether the static mesh factory should override the vertex color. Return false if the attribute was not set.
        
        Returns:
            Color or None: 
        
            attribute_value (Color):
        """
        ...
    def get_custom_vertex_color_ignore(self) -> Optional[bool]:
        r"""
        x.get_custom_vertex_color_ignore() -> bool or None
        Query whether the static mesh factory should ignore the vertex color. Return false if the attribute was not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_use_mikk_t_space(self) -> Optional[bool]:
        r"""
        x.get_custom_use_mikk_t_space() -> bool or None
        Query whether tangents are recomputed using MikkTSpace when they need to be recomputed.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_use_high_precision_tangent_basis(self) -> Optional[bool]:
        r"""
        x.get_custom_use_high_precision_tangent_basis() -> bool or None
        Query whether tangents are stored at 16-bit precision instead of the default 8-bit precision.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_use_full_precision_u_vs(self) -> Optional[bool]:
        r"""
        x.get_custom_use_full_precision_u_vs() -> bool or None
        Query whether UVs are stored at full floating point precision.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_use_backwards_compatible_f16_trunc_u_vs(self) -> Optional[bool]:
        r"""
        x.get_custom_use_backwards_compatible_f16_trunc_u_vs() -> bool or None
        Query whether UVs are converted to 16-bit by a legacy truncation process instead of the default rounding process. This may avoid differences when reimporting older content.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_remove_degenerates(self) -> Optional[bool]:
        r"""
        x.get_custom_remove_degenerates() -> bool or None
        Query whether degenerate triangles are removed.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_recompute_tangents(self) -> Optional[bool]:
        r"""
        x.get_custom_recompute_tangents() -> bool or None
        Query whether tangents in the imported mesh are ignored and recomputed.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_recompute_normals(self) -> Optional[bool]:
        r"""
        x.get_custom_recompute_normals() -> bool or None
        Query whether normals in the imported mesh are ignored and recomputed. When normals are recomputed, the tangents are also recomputed.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_lod_group(self) -> Optional[Name]:
        r"""
        x.get_custom_lod_group() -> Name or None
        Query whether a custom LOD group is set for the mesh.
        
        Returns:
            Name or None: 
        
            attribute_value (Name):
        """
        ...
    def get_custom_keep_sections_separate(self) -> Optional[bool]:
        r"""
        x.get_custom_keep_sections_separate() -> bool or None
        Query whether sections with matching materials are kept separate and will not get combined.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_compute_weighted_normals(self) -> Optional[bool]:
        r"""
        x.get_custom_compute_weighted_normals() -> bool or None
        Query whether normals are recomputed by weighting the surface area and the corner angle of the triangle as a ratio.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def add_lod_data_unique_id(self, lod_data_unique_id: str) -> bool:
        r"""
        x.add_lod_data_unique_id(lod_data_unique_id) -> bool
        Add Lod Data Unique Id
        
        Args:
            lod_data_unique_id (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeSceneImportAssetFactoryNode(InterchangeFactoryBaseNode):
    r"""
    Interchange Scene Import Asset Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeSceneImportAssetFactoryNode.h
    
    """
    ...

class InterchangeSkeletalMeshFactoryNode(InterchangeMeshFactoryNode):
    r"""
    Interchange Skeletal Mesh Factory Node
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeSkeletalMeshFactoryNode.h
    
    """
    def set_custom_use_high_precision_skin_weights(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_use_high_precision_skin_weights(attribute_value, add_apply_delegate=True) -> bool
        Set the skeletal mesh UseHighPrecisionSkinWeights setting.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_threshold_uv(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_threshold_uv(attribute_value, add_apply_delegate=True) -> bool
        Set the skeletal mesh threshold value that is used to decide whether two UVs are equal.
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_threshold_tangent_normal(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_threshold_tangent_normal(attribute_value, add_apply_delegate=True) -> bool
        Set the skeletal mesh threshold value that is used to decide whether two normals, tangents, or bi-normals are equal.
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_threshold_position(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_threshold_position(attribute_value, add_apply_delegate=True) -> bool
        Set the skeletal mesh threshold value that is used to decide whether two vertex positions are equal.
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_skeleton_soft_object_path(self, attribute_value: SoftObjectPath) -> bool:
        r"""
        x.set_custom_skeleton_soft_object_path(attribute_value) -> bool
        Set the skeletal mesh factory skeleton UObject. Return false if the attribute could not be set.
        
        Args:
            attribute_value (SoftObjectPath): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_physic_asset_soft_object_path(self, attribute_value: SoftObjectPath) -> bool:
        r"""
        x.set_custom_physic_asset_soft_object_path(attribute_value) -> bool
        Set a physics asset the skeletal mesh factory should use. Return false if the attribute could not be set.
        
        Args:
            attribute_value (SoftObjectPath): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_morph_threshold_position(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_morph_threshold_position(attribute_value, add_apply_delegate=True) -> bool
        Set the skeletal mesh threshold value that is used to compare vertex position equality when computing morph target deltas.
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_import_vertex_attributes(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_import_vertex_attributes(attribute_value) -> bool
        Set whether the skeletal mesh factory should import vertex attributes. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_import_morph_target(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_import_morph_target(attribute_value) -> bool
        Set whether the skeletal mesh factory should create morph targets. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_import_content_type(self, attribute_value: InterchangeSkeletalMeshContentType) -> bool:
        r"""
        x.set_custom_import_content_type(attribute_value) -> bool
        Set the skeletal mesh import content type. This content type determines whether the factory imports partial or full translated content. Return false if the attribute could not be set.
        
        Args:
            attribute_value (InterchangeSkeletalMeshContentType): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_create_physics_asset(self, attribute_value: bool) -> bool:
        r"""
        x.set_custom_create_physics_asset(attribute_value) -> bool
        Set whether the skeletal mesh factory should create a physics asset. Return false if the attribute could not be set.
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_bone_influence_limit(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_bone_influence_limit(attribute_value, add_apply_delegate=True) -> bool
        Set the maximum number of bone influences to allow each vertex in this mesh to use.
        If set higher than the limit determined by the project settings, it has no effect.
        If set to 0, the value is taken from the DefaultBoneInfluenceLimit project setting.
        
        Args:
            attribute_value (int32): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def initialize_skeletal_mesh_node(self, unique_id: str, display_label: str, asset_class: str) -> None:
        r"""
        x.initialize_skeletal_mesh_node(unique_id, display_label, asset_class) -> None
        Initialize node data.
        param:: UniqueID - The unique ID for this node.
        
        Args:
            unique_id (str): 
            display_label (str): The name of the node.
            asset_class (str): The class the SkeletalMesh factory will create for this node.
        """
        ...
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get the class this node creates.
        
        Returns:
            type(Class):
        """
        ...
    def get_custom_use_high_precision_skin_weights(self) -> Optional[bool]:
        r"""
        x.get_custom_use_high_precision_skin_weights() -> bool or None
        Query the skeletal mesh UseHighPrecisionSkinWeights setting.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_threshold_uv(self) -> Optional[float]:
        r"""
        x.get_custom_threshold_uv() -> float or None
        Query the skeletal mesh threshold value that is used to decide whether two UVs are equal.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_threshold_tangent_normal(self) -> Optional[float]:
        r"""
        x.get_custom_threshold_tangent_normal() -> float or None
        Query the skeletal mesh threshold value that is used to decide whether two normals, tangents, or bi-normals are equal.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_threshold_position(self) -> Optional[float]:
        r"""
        x.get_custom_threshold_position() -> float or None
        Query the skeletal mesh threshold value that is used to decide whether two vertex positions are equal.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_skeleton_soft_object_path(self) -> Optional[SoftObjectPath]:
        r"""
        x.get_custom_skeleton_soft_object_path() -> SoftObjectPath or None
        Query the skeletal mesh factory skeleton UObject. Return false if the attribute was not set.
        
        Returns:
            SoftObjectPath or None: 
        
            attribute_value (SoftObjectPath):
        """
        ...
    def get_custom_physic_asset_soft_object_path(self) -> Optional[SoftObjectPath]:
        r"""
        x.get_custom_physic_asset_soft_object_path() -> SoftObjectPath or None
        Query a physics asset the skeletal mesh factory should use. Return false if the attribute was not set.
        
        Returns:
            SoftObjectPath or None: 
        
            attribute_value (SoftObjectPath):
        """
        ...
    def get_custom_morph_threshold_position(self) -> Optional[float]:
        r"""
        x.get_custom_morph_threshold_position() -> float or None
        Query the skeletal mesh threshold value that is used to compare vertex position equality when computing morph target deltas.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_import_vertex_attributes(self) -> Optional[bool]:
        r"""
        x.get_custom_import_vertex_attributes() -> bool or None
        Query whether the skeletal mesh factory should import vertex attributes. Return false if the attribute was not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_import_morph_target(self) -> Optional[bool]:
        r"""
        x.get_custom_import_morph_target() -> bool or None
        Query whether the skeletal mesh factory should create morph targets. Return false if the attribute was not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_import_content_type(self) -> Optional[InterchangeSkeletalMeshContentType]:
        r"""
        x.get_custom_import_content_type() -> InterchangeSkeletalMeshContentType or None
        Query the skeletal mesh import content type. This content type determines whether the factory imports partial or full translated content. Return false if the attribute was not set.
        
        Returns:
            InterchangeSkeletalMeshContentType or None: 
        
            attribute_value (InterchangeSkeletalMeshContentType):
        """
        ...
    def get_custom_create_physics_asset(self) -> Optional[bool]:
        r"""
        x.get_custom_create_physics_asset() -> bool or None
        Query whether the skeletal mesh factory should create a physics asset. Return false if the attribute was not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_bone_influence_limit(self) -> Optional[int]:
        r"""
        x.get_custom_bone_influence_limit() -> int32 or None
        Query the maximum number of bone influences to allow each vertex in this mesh to use.
        If set higher than the limit determined by the project settings, it has no effect.
        If set to 0, the value is taken from the DefaultBoneInfluenceLimit project setting.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...

class InterchangeSkeletalMeshLodDataNode(InterchangeFactoryBaseNode):
    r"""
    ns UE
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeSkeletalMeshLodDataNode.h
    
    """
    def set_custom_skeleton_uid(self, attribute_value: str) -> bool:
        r"""
        x.set_custom_skeleton_uid(attribute_value) -> bool
        Set the LOD skeletal mesh factory skeleton reference. Return false if the attribute could not be set.
        
        Args:
            attribute_value (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.remove_mesh_uid(mesh_name) -> bool
        Remove a mesh geometry used to create this LOD geometry. A mesh UID can represent either a scene node or a mesh node. If it is a scene node, the mesh factory bakes the geometry payload with the global transform of the scene node.
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_all_meshes(self) -> bool:
        r"""
        x.remove_all_meshes() -> bool
        Remove all mesh geometry used to create this LOD geometry. A mesh UID can represent either a scene node or a mesh node. If it is a scene node, the mesh factory bakes the geometry payload with the global transform of the scene node.
        
        Returns:
            bool:
        """
        ...
    def get_mesh_uids_count(self) -> int:
        r"""
        x.get_mesh_uids_count() -> int32
        Return the number of mesh geometries this LOD will be made from. A mesh UID can represent either a scene node or a mesh node. If it is a scene node, the mesh factory bakes the geometry payload with the global transform of the scene node.
        
        Returns:
            int32:
        """
        ...
    def get_mesh_uids(self) -> Array[str]:
        r"""
        x.get_mesh_uids() -> Array[str]
        Query all mesh geometry this LOD will be made from. A mesh UID can represent either a scene node or a mesh node. If it is a scene node, the mesh factory bakes the geometry payload with the global transform of the scene node.
        
        Returns:
            Array[str]: 
        
            out_mesh_names (Array[str]):
        """
        ...
    def get_custom_skeleton_uid(self) -> Optional[str]:
        r"""
        x.get_custom_skeleton_uid() -> str or None
        Query the LOD skeletal mesh factory skeleton reference. Return false if the attribute was not set.
        
        Returns:
            str or None: 
        
            attribute_value (str):
        """
        ...
    def add_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.add_mesh_uid(mesh_name) -> bool
        Add a mesh geometry used to create this LOD geometry. A mesh UID can represent either a scene node or a mesh node. If it is a scene node, the mesh factory bakes the geometry payload with the global transform of the scene node.
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeStaticMeshFactoryNode(InterchangeMeshFactoryNode):
    r"""
    namespace UE
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeStaticMeshFactoryNode.h
    
    """
    def set_custom_support_face_remap(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_support_face_remap(attribute_value, add_apply_delegate=True) -> bool
        Set whether the static mesh is set up for use with physical material masks.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_src_lightmap_index(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_src_lightmap_index(attribute_value, add_apply_delegate=True) -> bool
        Set the index of the UV that is used as the source for generating lightmaps for the static mesh.
        
        Args:
            attribute_value (int32): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_min_lightmap_resolution(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_min_lightmap_resolution(attribute_value, add_apply_delegate=True) -> bool
        Set the amount of padding used to pack UVs for the static mesh.
        
        Args:
            attribute_value (int32): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_max_lumen_mesh_cards(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_max_lumen_mesh_cards(attribute_value, add_apply_delegate=True) -> bool
        Set the maximum number of Lumen mesh cards to generate for this mesh.
        More cards means that the surface will have better coverage, but will result in increased runtime overhead.
        Set this to 0 to disable mesh card generation for this mesh.
        The default is 12.
        
        Args:
            attribute_value (int32): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_generate_lightmap_u_vs(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_generate_lightmap_u_vs(attribute_value, add_apply_delegate=True) -> bool
        Set whether the static mesh should generate lightmap UVs.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_generate_distance_field_as_if_two_sided(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_generate_distance_field_as_if_two_sided(attribute_value, add_apply_delegate=True) -> bool
        Set whether to generate the distance field by treating every triangle hit as a front face.
        This prevents the distance field from being discarded due to the mesh being open, but also lowers distance field ambient occlusion quality.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_dst_lightmap_index(self, attribute_value: int, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_dst_lightmap_index(attribute_value, add_apply_delegate=True) -> bool
        Set the index of the UV that is used to store generated lightmaps for the static mesh.
        
        Args:
            attribute_value (int32): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_distance_field_resolution_scale(self, attribute_value: float, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_distance_field_resolution_scale(attribute_value, add_apply_delegate=True) -> bool
        Set the scale to apply to the mesh when allocating the distance field volume texture.
        The default scale is 1, which assumes that the mesh will be placed unscaled in the world.
        
        Args:
            attribute_value (float): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_distance_field_replacement_mesh(self, attribute_value: SoftObjectPath, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_distance_field_replacement_mesh(attribute_value, add_apply_delegate=True) -> bool
        Set the static mesh asset whose distance field will be used as the distance field for the imported mesh.
        
        Args:
            attribute_value (SoftObjectPath): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_build_scale3d(self, attribute_value: Vector, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_build_scale3d(attribute_value, add_apply_delegate=True) -> bool
        Set the local scale that is applied when building the static mesh.
        
        Args:
            attribute_value (Vector): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_build_reversed_index_buffer(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_build_reversed_index_buffer(attribute_value, add_apply_delegate=True) -> bool
        Set whether the static mesh should build a reversed index buffer.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_custom_build_nanite(self, attribute_value: bool, add_apply_delegate: bool = True) -> bool:
        r"""
        x.set_custom_build_nanite(attribute_value, add_apply_delegate=True) -> bool
        Set whether the static mesh factory should set the Nanite build setting. Return false if the attribute was not set.
        
        Args:
            attribute_value (bool): 
            add_apply_delegate (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_socket_ud(self, socket_uid: str) -> bool:
        r"""
        x.remove_socket_ud(socket_uid) -> bool
        Remove Socket Ud
        
        Args:
            socket_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def initialize_static_mesh_node(self, unique_id: str, display_label: str, asset_class: str) -> None:
        r"""
        x.initialize_static_mesh_node(unique_id, display_label, asset_class) -> None
        Initialize node data.
        
        Args:
            unique_id (str): The unique ID for this node.
            display_label (str): The name of the node.
            asset_class (str): The class the StaticMesh factory will create for this node.
        """
        ...
    def get_socket_uids(self) -> Array[str]:
        r"""
        x.get_socket_uids() -> Array[str]
        Get Socket Uids
        
        Returns:
            Array[str]: 
        
            out_socket_uids (Array[str]):
        """
        ...
    def get_socket_uid_count(self) -> int:
        r"""
        x.get_socket_uid_count() -> int32
        Return the number of socket UIDs this static mesh has.
        
        Returns:
            int32:
        """
        ...
    def get_object_class(self) -> Class:
        r"""
        x.get_object_class() -> type(Class)
        Get the class this node creates.
        
        Returns:
            type(Class):
        """
        ...
    def get_custom_support_face_remap(self) -> Optional[bool]:
        r"""
        x.get_custom_support_face_remap() -> bool or None
        Get whether the static mesh is set up for use with physical material masks.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_src_lightmap_index(self) -> Optional[int]:
        r"""
        x.get_custom_src_lightmap_index() -> int32 or None
        Get the index of the UV that is used as the source for generating lightmaps for the static mesh.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_min_lightmap_resolution(self) -> Optional[int]:
        r"""
        x.get_custom_min_lightmap_resolution() -> int32 or None
        Get the amount of padding used to pack UVs for the static mesh.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_max_lumen_mesh_cards(self) -> Optional[int]:
        r"""
        x.get_custom_max_lumen_mesh_cards() -> int32 or None
        Get the maximum number of Lumen mesh cards to generate for this mesh.
        More cards means that the surface will have better coverage, but will result in increased runtime overhead.
        Set this to 0 to disable mesh card generation for this mesh.
        The default is 12.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_generate_lightmap_u_vs(self) -> Optional[bool]:
        r"""
        x.get_custom_generate_lightmap_u_vs() -> bool or None
        Get whether the static mesh should generate lightmap UVs.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_generate_distance_field_as_if_two_sided(self) -> Optional[bool]:
        r"""
        x.get_custom_generate_distance_field_as_if_two_sided() -> bool or None
        Get whether to generate the distance field by treating every triangle hit as a front face.
        This prevents the distance field from being discarded due to the mesh being open, but also lowers distance field ambient occlusion quality.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_dst_lightmap_index(self) -> Optional[int]:
        r"""
        x.get_custom_dst_lightmap_index() -> int32 or None
        Get the index of the UV that is used to store generated lightmaps for the static mesh.
        
        Returns:
            int32 or None: 
        
            attribute_value (int32):
        """
        ...
    def get_custom_distance_field_resolution_scale(self) -> Optional[float]:
        r"""
        x.get_custom_distance_field_resolution_scale() -> float or None
        Get the scale to apply to the mesh when allocating the distance field volume texture.
        The default scale is 1, which assumes that the mesh will be placed unscaled in the world.
        
        Returns:
            float or None: 
        
            attribute_value (float):
        """
        ...
    def get_custom_distance_field_replacement_mesh(self) -> Optional[SoftObjectPath]:
        r"""
        x.get_custom_distance_field_replacement_mesh() -> SoftObjectPath or None
        Get the static mesh asset whose distance field will be used as the distance field for the imported mesh.
        
        Returns:
            SoftObjectPath or None: 
        
            attribute_value (SoftObjectPath):
        """
        ...
    def get_custom_build_scale3d(self) -> Optional[Vector]:
        r"""
        x.get_custom_build_scale3d() -> Vector or None
        Get the local scale that is applied when building the static mesh.
        
        Returns:
            Vector or None: 
        
            attribute_value (Vector):
        """
        ...
    def get_custom_build_reversed_index_buffer(self) -> Optional[bool]:
        r"""
        x.get_custom_build_reversed_index_buffer() -> bool or None
        Get whether the static mesh should build a reversed index buffer.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_custom_build_nanite(self) -> Optional[bool]:
        r"""
        x.get_custom_build_nanite() -> bool or None
        Get whether the static mesh factory should set the Nanite build setting. Return false if the attribute was not set.
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def add_socket_uids(self, socket_uids: Array[str]) -> bool:
        r"""
        x.add_socket_uids(socket_uids) -> bool
        Add Socket Uids
        
        Args:
            socket_uids (Array[str]): 
        
        Returns:
            bool:
        """
        ...
    def add_socket_uid(self, socket_uid: str) -> bool:
        r"""
        x.add_socket_uid(socket_uid) -> bool
        Add Socket Uid
        
        Args:
            socket_uid (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeStaticMeshLodDataNode(InterchangeFactoryBaseNode):
    r"""
    namespace UE
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeFactoryNodes
    - **File**: InterchangeStaticMeshLodDataNode.h
    
    """
    def set_one_convex_hull_per_ucx(self, attribute_value: bool) -> bool:
        r"""
        x.set_one_convex_hull_per_ucx(attribute_value) -> bool
        Set One Convex Hull Per UCX
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_import_collision(self, attribute_value: bool) -> bool:
        r"""
        x.set_import_collision(attribute_value) -> bool
        Set Import Collision
        
        Args:
            attribute_value (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_sphere_collision_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.remove_sphere_collision_mesh_uid(mesh_name) -> bool
        Remove Sphere Collision Mesh Uid
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.remove_mesh_uid(mesh_name) -> bool
        Remove Mesh Uid
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_convex_collision_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.remove_convex_collision_mesh_uid(mesh_name) -> bool
        Remove Convex Collision Mesh Uid
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_capsule_collision_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.remove_capsule_collision_mesh_uid(mesh_name) -> bool
        Remove Capsule Collision Mesh Uid
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_box_collision_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.remove_box_collision_mesh_uid(mesh_name) -> bool
        Remove Box Collision Mesh Uid
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...
    def remove_all_sphere_collision_meshes(self) -> bool:
        r"""
        x.remove_all_sphere_collision_meshes() -> bool
        Remove All Sphere Collision Meshes
        
        Returns:
            bool:
        """
        ...
    def remove_all_meshes(self) -> bool:
        r"""
        x.remove_all_meshes() -> bool
        Remove All Meshes
        
        Returns:
            bool:
        """
        ...
    def remove_all_convex_collision_meshes(self) -> bool:
        r"""
        x.remove_all_convex_collision_meshes() -> bool
        Remove All Convex Collision Meshes
        
        Returns:
            bool:
        """
        ...
    def remove_all_capsule_collision_meshes(self) -> bool:
        r"""
        x.remove_all_capsule_collision_meshes() -> bool
        Remove All Capsule Collision Meshes
        
        Returns:
            bool:
        """
        ...
    def remove_all_box_collision_meshes(self) -> bool:
        r"""
        x.remove_all_box_collision_meshes() -> bool
        Remove All Box Collision Meshes
        
        Returns:
            bool:
        """
        ...
    def get_sphere_collision_mesh_uids_count(self) -> int:
        r"""
        x.get_sphere_collision_mesh_uids_count() -> int32
        Get Sphere Collision Mesh Uids Count
        
        Returns:
            int32:
        """
        ...
    def get_sphere_collision_mesh_uids(self) -> Array[str]:
        r"""
        x.get_sphere_collision_mesh_uids() -> Array[str]
        Get Sphere Collision Mesh Uids
        
        Returns:
            Array[str]: 
        
            out_mesh_names (Array[str]):
        """
        ...
    def get_one_convex_hull_per_ucx(self) -> Optional[bool]:
        r"""
        x.get_one_convex_hull_per_ucx() -> bool or None
        Get One Convex Hull Per UCX
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_mesh_uids_count(self) -> int:
        r"""
        x.get_mesh_uids_count() -> int32
        Mesh UIDs can be either a scene node or a mesh node UID. If it is a scene node, the mesh factory bakes the geometry payload with the global transform of the scene node.
        
        Returns:
            int32:
        """
        ...
    def get_mesh_uids(self) -> Array[str]:
        r"""
        x.get_mesh_uids() -> Array[str]
        Get Mesh Uids
        
        Returns:
            Array[str]: 
        
            out_mesh_names (Array[str]):
        """
        ...
    def get_import_collision(self) -> Optional[bool]:
        r"""
        x.get_import_collision() -> bool or None
        Get Import Collision
        
        Returns:
            bool or None: 
        
            attribute_value (bool):
        """
        ...
    def get_convex_collision_mesh_uids_count(self) -> int:
        r"""
        x.get_convex_collision_mesh_uids_count() -> int32
        Get Convex Collision Mesh Uids Count
        
        Returns:
            int32:
        """
        ...
    def get_convex_collision_mesh_uids(self) -> Array[str]:
        r"""
        x.get_convex_collision_mesh_uids() -> Array[str]
        Get Convex Collision Mesh Uids
        
        Returns:
            Array[str]: 
        
            out_mesh_names (Array[str]):
        """
        ...
    def get_capsule_collision_mesh_uids_count(self) -> int:
        r"""
        x.get_capsule_collision_mesh_uids_count() -> int32
        Get Capsule Collision Mesh Uids Count
        
        Returns:
            int32:
        """
        ...
    def get_capsule_collision_mesh_uids(self) -> Array[str]:
        r"""
        x.get_capsule_collision_mesh_uids() -> Array[str]
        Get Capsule Collision Mesh Uids
        
        Returns:
            Array[str]: 
        
            out_mesh_names (Array[str]):
        """
        ...
    def get_box_collision_mesh_uids_count(self) -> int:
        r"""
        x.get_box_collision_mesh_uids_count() -> int32
        Get Box Collision Mesh Uids Count
        
        Returns:
            int32:
        """
        ...
    def get_box_collision_mesh_uids(self) -> Array[str]:
        r"""
        x.get_box_collision_mesh_uids() -> Array[str]
        Get Box Collision Mesh Uids
        
        Returns:
            Array[str]: 
        
            out_mesh_names (Array[str]):
        """
        ...
    def add_sphere_collision_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.add_sphere_collision_mesh_uid(mesh_name) -> bool
        Add Sphere Collision Mesh Uid
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...
    def add_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.add_mesh_uid(mesh_name) -> bool
        Add Mesh Uid
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...
    def add_convex_collision_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.add_convex_collision_mesh_uid(mesh_name) -> bool
        Add Convex Collision Mesh Uid
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...
    def add_capsule_collision_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.add_capsule_collision_mesh_uid(mesh_name) -> bool
        Add Capsule Collision Mesh Uid
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...
    def add_box_collision_mesh_uid(self, mesh_name: str) -> bool:
        r"""
        x.add_box_collision_mesh_uid(mesh_name) -> bool
        Add Box Collision Mesh Uid
        
        Args:
            mesh_name (str): 
        
        Returns:
            bool:
        """
        ...

class InterchangeActorFactory(InterchangeFactoryBase):
    r"""
    Interchange Actor Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeActorFactory.h
    
    """
    ...

class InterchangeDecalActorFactory(InterchangeActorFactory):
    r"""
    Interchange Decal Actor Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeDecalActorFactory.h
    
    """
    ...

class InterchangeLevelSequenceFactory(InterchangeFactoryBase):
    r"""
    Interchange Level Sequence Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeLevelSequenceFactory.h
    
    """
    ...

class InterchangeAnimationTrackSetFactory(InterchangeLevelSequenceFactory):
    r"""
    deprecated: 'InterchangeAnimationTrackSetFactory' was renamed to 'InterchangeLevelSequenceFactory'.
    """
    ...

class InterchangeLightActorFactory(InterchangeActorFactory):
    r"""
    Interchange Light Actor Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeLightActorFactory.h
    
    """
    ...

class InterchangeSceneImportAssetFactory(InterchangeFactoryBase):
    r"""
    Interchange Scene Import Asset Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeSceneImportAssetFactory.h
    
    """
    ...

class InterchangeSceneVariantSetsFactory(InterchangeFactoryBase):
    r"""
    Interchange Scene Variant Sets Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeSceneVariantSetsFactory.h
    
    """
    ...

class MaterialExpressionMaterialXRamp4(MaterialExpression):
    r"""
    A material expression that computes a 4-corner bilinear value ramp..
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionRamp4.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionRamp4(MaterialExpressionMaterialXRamp4):
    r"""
    deprecated: 'MaterialExpressionRamp4' was renamed to 'MaterialExpressionMaterialXRamp4'.
    """
    ...

class InterchangeAnimSequenceFactory(InterchangeFactoryBase):
    r"""
    Interchange Anim Sequence Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeAnimSequenceFactory.h
    
    """
    ...

class InterchangeFbxTranslatorSettings(InterchangeTranslatorSettings):
    r"""
    Fbx translator class support import of texture, material, static mesh, skeletal mesh,
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeFbxTranslator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``convert_scene`` (bool):  [Read-Write] Whether to convert FBX scene axis system to Unreal axis system.
    - ``convert_scene_unit`` (bool):  [Read-Write] Whether to convert the scene from FBX unit to UE unit (centimeter).
    - ``force_front_x_axis`` (bool):  [Read-Write] Whether to force the front axis to be align with X instead of -Y default.
    """
    ...

class InterchangeFbxTranslator(InterchangeTranslatorBase):
    r"""
    Interchange Fbx Translator
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeFbxTranslator.h
    
    """
    ...

class InterchangeGLTFTranslator(InterchangeTranslatorBase):
    r"""
    glTF translator class support import of texture, material, static mesh, skeletal mesh,
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeGltfTranslator.h
    
    """
    ...

class InterchangeMaterialXTranslator(InterchangeTranslatorBase):
    r"""
    Interchange Material XTranslator
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeMaterialXTranslator.h
    
    """
    ...

class MaterialExpressionMaterialXAppend3Vector(MaterialExpression):
    r"""
    A material expression that allows combining 3 channels together to create a vector with more channel than the original
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionAppend3Vector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionAppend3Vector(MaterialExpressionMaterialXAppend3Vector):
    r"""
    deprecated: 'MaterialExpressionAppend3Vector' was renamed to 'MaterialExpressionMaterialXAppend3Vector'.
    """
    ...

class MaterialExpressionMaterialXAppend4Vector(MaterialExpression):
    r"""
    A material expression that allows combining 4 channels together to create a vector with more channel than the original
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionAppend4Vector.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionAppend4Vector(MaterialExpressionMaterialXAppend4Vector):
    r"""
    deprecated: 'MaterialExpressionAppend4Vector' was renamed to 'MaterialExpressionMaterialXAppend4Vector'.
    """
    ...

class MaterialExpressionMaterialXBurn(MaterialExpression):
    r"""
    Blend nodes take two 1-4 channel inputs and apply the same operator to all channels.
    Blend nodes support an optional float input mix , which can be used
    to mix the original B value with the result of the blend operation.
    Operation: 1-(1-B)/A
    Result: Lerp(B, 1-(1-B)/A, Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionBurn.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionBurn(MaterialExpressionMaterialXBurn):
    r"""
    deprecated: 'MaterialExpressionBurn' was renamed to 'MaterialExpressionMaterialXBurn'.
    """
    ...

class MaterialExpressionMaterialXDifference(MaterialExpression):
    r"""
    Blend nodes take two 1-4 channel inputs and apply the same operator to all channels.
    Blend nodes support an optional float input mix , which can be used
    to mix the original B value with the result of the blend operation.
    Operation: abs(A - B)
    Result: Lerp(B, abs(A - B), Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionDifference.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDifference(MaterialExpressionMaterialXDifference):
    r"""
    deprecated: 'MaterialExpressionDifference' was renamed to 'MaterialExpressionMaterialXDifference'.
    """
    ...

class MaterialExpressionMaterialXDisjointOver(MaterialExpression):
    r"""
    Merge nodes take two 4-channel (color4) inputs and use the built-in alpha channel(s) to control the
    compositing of the A and B inputs. "A" and "B" refer to the non-alpha channels of the A and B inputs respectively,
    and "a" and "b" refer to the alpha channels of the A and B inputs.
    Merge nodes are only defined for float4 inputs
    Merge nodes support an optional float input Alpha , which can be used to mix the
    original B value with the result of the blend operation.
    
    Operation: A + B        if a + b <= 1;
               A + B(1-a)/b if a + b > 1
    Result: Lerp(B, Op, Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionDisjointOver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDisjointOver(MaterialExpressionMaterialXDisjointOver):
    r"""
    deprecated: 'MaterialExpressionDisjointOver' was renamed to 'MaterialExpressionMaterialXDisjointOver'.
    """
    ...

class MaterialExpressionMaterialXDodge(MaterialExpression):
    r"""
    Blend nodes take two 1-4 channel inputs and apply the same operator to all channels.
    Blend nodes support an optional float input mix , which can be used
    to mix the original B value with the result of the blend operation.
    Operation: B/(1-A)
    Result: Lerp(B, B/(1-A), Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionDodge.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionDodge(MaterialExpressionMaterialXDodge):
    r"""
    deprecated: 'MaterialExpressionDodge' was renamed to 'MaterialExpressionMaterialXDodge'.
    """
    ...

class MaterialExpressionMaterialXFractal3D(MaterialExpression):
    r"""
    Zero-centered 3D Fractal noise in 1, 2, 3 or 4 channels, created by summing several
    octaves of 3D Perlin noise, increasing the frequency and decreasing the amplitude at each octave.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionFractal3D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_amplitude`` (float):  [Read-Write] only used if Amplitude is not hooked up
    - ``const_diminish`` (float):  [Read-Write] only used if Diminish is not hooked up
    - ``const_lacunarity`` (float):  [Read-Write] only used if Lacunarity is not hooked up
    - ``const_octaves`` (int32):  [Read-Write] only used if Octaves is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``levels`` (int32):  [Read-Write] 1 = fast but little detail, .. larger numbers cost more performance
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``output_max`` (float):  [Read-Write]
    - ``output_min`` (float):  [Read-Write]
    - ``scale`` (float):  [Read-Write] can also be done with a multiply on the Position
    - ``turbulence`` (bool):  [Read-Write] How multiple frequencies are getting combined
    """
    ...

class MaterialExpressionFractal3D(MaterialExpressionMaterialXFractal3D):
    r"""
    deprecated: 'MaterialExpressionFractal3D' was renamed to 'MaterialExpressionMaterialXFractal3D'.
    """
    ...

class MaterialExpressionMaterialXIn(MaterialExpression):
    r"""
    Merge nodes take two 4-channel (color4) inputs and use the built-in alpha channel(s) to control the
    compositing of the A and B inputs. "A" and "B" refer to the non-alpha channels of the A and B inputs respectively,
    and "a" and "b" refer to the alpha channels of the A and B inputs.
    Merge nodes are only defined for float4 inputs
    Merge nodes support an optional float input Alpha , which can be used to mix the
    original B value with the result of the blend operation.
    
    Operation: Ab
    Result: Lerp(B, Ab, Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionIn.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionIn(MaterialExpressionMaterialXIn):
    r"""
    deprecated: 'MaterialExpressionIn' was renamed to 'MaterialExpressionMaterialXIn'.
    """
    ...

class MaterialExpressionMaterialXLuminance(MaterialExpression):
    r"""
    Material Expression Material XLuminance
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionLuminance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``luminance_factors`` (LinearColor):  [Read-Write]
    - ``luminance_mode`` (MaterialXLuminanceMode):  [Read-Write] Color component factors for converting a color to greyscale.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionLuminance(MaterialExpressionMaterialXLuminance):
    r"""
    deprecated: 'MaterialExpressionLuminance' was renamed to 'MaterialExpressionMaterialXLuminance'.
    """
    ...

class MaterialExpressionMaterialXMask(MaterialExpression):
    r"""
    Merge nodes take two 4-channel (color4) inputs and use the built-in alpha channel(s) to control the
    compositing of the A and B inputs. "A" and "B" refer to the non-alpha channels of the A and B inputs respectively,
    and "a" and "b" refer to the alpha channels of the A and B inputs.
    Merge nodes are only defined for float4 inputs
    Merge nodes support an optional float input Alpha , which can be used to mix the
    original B value with the result of the blend operation.
    
    Operation: B*a
    Result: Lerp(B, B*a, Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionMask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMask(MaterialExpressionMaterialXMask):
    r"""
    deprecated: 'MaterialExpressionMask' was renamed to 'MaterialExpressionMaterialXMask'.
    """
    ...

class MaterialExpressionMaterialXMatte(MaterialExpression):
    r"""
    Merge nodes take two 4-channel (color4) inputs and use the built-in alpha channel(s) to control the
    compositing of the A and B inputs. "A" and "B" refer to the non-alpha channels of the A and B inputs respectively,
    and "a" and "b" refer to the alpha channels of the A and B inputs.
    Merge nodes are only defined for float4 inputs
    Merge nodes support an optional float input Alpha , which can be used to mix the
    original B value with the result of the blend operation.
    
    Operation: A*a + B*(1-a)
    Result: Lerp(B, A*a + B*(1-a), Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionMatte.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMatte(MaterialExpressionMaterialXMatte):
    r"""
    deprecated: 'MaterialExpressionMatte' was renamed to 'MaterialExpressionMaterialXMatte'.
    """
    ...

class MaterialExpressionMaterialXMinus(MaterialExpression):
    r"""
    Blend nodes take two 1-4 channel inputs and apply the same operator to all channels.
    Blend nodes support an optional float input mix , which can be used
    to mix the original B value with the result of the blend operation.
    Operation: A - B
    Result: Lerp(B, A - B, Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionMinus.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMinus(MaterialExpressionMaterialXMinus):
    r"""
    deprecated: 'MaterialExpressionMinus' was renamed to 'MaterialExpressionMaterialXMinus'.
    """
    ...

class MaterialExpressionMaterialXOut(MaterialExpression):
    r"""
    Merge nodes take two 4-channel (color4) inputs and use the built-in alpha channel(s) to control the
    compositing of the A and B inputs. "A" and "B" refer to the non-alpha channels of the A and B inputs respectively,
    and "a" and "b" refer to the alpha channels of the A and B inputs.
    Merge nodes are only defined for float4 inputs
    Merge nodes support an optional float input Alpha , which can be used to mix the
    original B value with the result of the blend operation.
    
    Operation: A(1-b)
    Result: Lerp(B, A(1-b), Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionOut.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionOut(MaterialExpressionMaterialXOut):
    r"""
    deprecated: 'MaterialExpressionOut' was renamed to 'MaterialExpressionMaterialXOut'.
    """
    ...

class MaterialExpressionMaterialXOver(MaterialExpression):
    r"""
    Merge nodes take two 4-channel (color4) inputs and use the built-in alpha channel(s) to control the
    compositing of the A and B inputs. "A" and "B" refer to the non-alpha channels of the A and B inputs respectively,
    and "a" and "b" refer to the alpha channels of the A and B inputs.
    Merge nodes are only defined for float4 inputs
    Merge nodes support an optional float input Alpha , which can be used to mix the
    original B value with the result of the blend operation.
    
    Operation: A + B(1-a)
    Result: Lerp(B, A + B(1-a), Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionOver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionOver(MaterialExpressionMaterialXOver):
    r"""
    deprecated: 'MaterialExpressionOver' was renamed to 'MaterialExpressionMaterialXOver'.
    """
    ...

class MaterialExpressionMaterialXOverlay(MaterialExpression):
    r"""
    Blend nodes take two 1-4 channel inputs and apply the same operator to all channels.
    Blend nodes support an optional float input mix , which can be used
    to mix the original B value with the result of the blend operation.
    Operation: 2*A*B          if A < 0.5;
               1-(1-A)(1-B) if A >= 0.5
    Result: Lerp(B, Op, Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionOverlay.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionOverlay(MaterialExpressionMaterialXOverlay):
    r"""
    deprecated: 'MaterialExpressionOverlay' was renamed to 'MaterialExpressionMaterialXOverlay'.
    """
    ...

class MaterialExpressionMaterialXPlace2D(MaterialExpression):
    r"""
    Transform incoming UV texture coordinates from one 2D frame of reference to another.
    operationorder (integer enum): the order in which to perform the transform operations.
    "0" or "SRT" performs -pivot, scale, rotate, translate, +pivot as per the original
    implementation matching the behavior of certain DCC packages, and "1" or "TRS" performs
    -pivot, translate, rotate, scale, +pivot which does not introduce texture shear.
    Default is 0 "SRT" for backward compatibility.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionPlace2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_rotation_angle`` (float):  [Read-Write] only used if RotationAngle is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPlace2D(MaterialExpressionMaterialXPlace2D):
    r"""
    deprecated: 'MaterialExpressionPlace2D' was renamed to 'MaterialExpressionMaterialXPlace2D'.
    """
    ...

class MaterialExpressionMaterialXPlus(MaterialExpression):
    r"""
    Blend nodes take two 1-4 channel inputs and apply the same operator to all channels.
    Blend nodes support an optional float input mix , which can be used
    to mix the original B value with the result of the blend operation.
    Operation: A + B
    Result: Lerp(B, A + B, Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionPlus.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPlus(MaterialExpressionMaterialXPlus):
    r"""
    deprecated: 'MaterialExpressionPlus' was renamed to 'MaterialExpressionMaterialXPlus'.
    """
    ...

class MaterialExpressionMaterialXPremult(MaterialExpression):
    r"""
    Multiply the RGB channels of the input by the Alpha channel of the input.
    Input must be of type float4
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionPremult.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionPremult(MaterialExpressionMaterialXPremult):
    r"""
    deprecated: 'MaterialExpressionPremult' was renamed to 'MaterialExpressionMaterialXPremult'.
    """
    ...

class MaterialExpressionMaterialXRampLeftRight(MaterialExpression):
    r"""
    A material expression that computes a left-to-right bilinear value ramp.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionRampLeftRight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionRampLeftRight(MaterialExpressionMaterialXRampLeftRight):
    r"""
    deprecated: 'MaterialExpressionRampLeftRight' was renamed to 'MaterialExpressionMaterialXRampLeftRight'.
    """
    ...

class MaterialExpressionMaterialXRampTopBottom(MaterialExpression):
    r"""
    A material expression that computes a top-to-bottom bilinear value ramp.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionRampTopBottom.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionRampTopBottom(MaterialExpressionMaterialXRampTopBottom):
    r"""
    deprecated: 'MaterialExpressionRampTopBottom' was renamed to 'MaterialExpressionMaterialXRampTopBottom'.
    """
    ...

class MaterialExpressionMaterialXRemap(MaterialExpression):
    r"""
    A material expression that Remap a value from one range to another.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionRemap.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``input_high_default`` (float):  [Read-Write]
    - ``input_low_default`` (float):  [Read-Write]
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``target_high_default`` (float):  [Read-Write]
    - ``target_low_default`` (float):  [Read-Write]
    """
    ...

class MaterialExpressionRemap(MaterialExpressionMaterialXRemap):
    r"""
    deprecated: 'MaterialExpressionRemap' was renamed to 'MaterialExpressionMaterialXRemap'.
    """
    ...

class MaterialExpressionMaterialXRotate2D(MaterialExpression):
    r"""
    A material expression that rotates a vector2 value about the origin in 2D.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionRotate2D.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_rotation_angle`` (float):  [Read-Write] only used if RotationAngle is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionRotate2D(MaterialExpressionMaterialXRotate2D):
    r"""
    deprecated: 'MaterialExpressionRotate2D' was renamed to 'MaterialExpressionMaterialXRotate2D'.
    """
    ...

class MaterialExpressionMaterialXScreen(MaterialExpression):
    r"""
    Blend nodes take two 1-4 channel inputs and apply the same operator to all channels.
    Blend nodes support an optional float input mix , which can be used
    to mix the original B value with the result of the blend operation.
    Operation: 1-(1-A)(1-B)
    Result: Lerp(B, 1-(1-F)(1-B), Alpha)
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionScreen.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_alpha`` (float):  [Read-Write] only used if Alpha is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionScreen(MaterialExpressionMaterialXScreen):
    r"""
    deprecated: 'MaterialExpressionScreen' was renamed to 'MaterialExpressionMaterialXScreen'.
    """
    ...

class MaterialExpressionMaterialXSplitLeftRight(MaterialExpression):
    r"""
    A material expression that computes a left-right split matte, split at a specified u value.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionSplitLeftRight.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_center`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSplitLeftRight(MaterialExpressionMaterialXSplitLeftRight):
    r"""
    deprecated: 'MaterialExpressionSplitLeftRight' was renamed to 'MaterialExpressionMaterialXSplitLeftRight'.
    """
    ...

class MaterialExpressionMaterialXSplitTopBottom(MaterialExpression):
    r"""
    A material expression that computes a top-bottom split matte, split at a specified v value.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionSplitTopBottom.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``const_center`` (float):  [Read-Write] only used if A is not hooked up
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionSplitTopBottom(MaterialExpressionMaterialXSplitTopBottom):
    r"""
    deprecated: 'MaterialExpressionSplitTopBottom' was renamed to 'MaterialExpressionMaterialXSplitTopBottom'.
    """
    ...

class MaterialExpressionMaterialXSwizzle(MaterialExpression):
    r"""
    Material Expression Material XSwizzle
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionSwizzle.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channels`` (str):  [Read-Write]
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionMaterialXTextureSampleParameterBlur(MaterialExpressionTextureSampleParameter2D):
    r"""
    Material Expression Material XTexture Sample Parameter Blur
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionTextureSampleParameterBlur.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``filter`` (MaterialXTextureSampleBlurFilter):  [Read-Write] Filter to use when we blur a Texture: Gaussian or Box Linear filter
    - ``filter_offset`` (float):  [Read-Write] Offset of the filter when we sample a texture coordinate
    - ``filter_size`` (float):  [Read-Write] Size of the filter when we sample a texture coordinate
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``kernel_size`` (MAterialXTextureSampleBlurKernel):  [Read-Write] The size of the blur kernel, relative to 0-1 UV space.
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``parameter_name`` (Name):  [Read-Write]
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class MaterialExpressionTextureSampleParameterBlur(MaterialExpressionMaterialXTextureSampleParameterBlur):
    r"""
    deprecated: 'MaterialExpressionTextureSampleParameterBlur' was renamed to 'MaterialExpressionMaterialXTextureSampleParameterBlur'.
    """
    ...

class MaterialExpressionMaterialXUnpremult(MaterialExpression):
    r"""
    Divide the RGB channels of the input by the Alpha channel of the input. If the
    Alpha value is zero, the original color4 input value is passed through unchanged.
    Input must be of type float4
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: MaterialExpressionUnpremult.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    """
    ...

class MaterialExpressionUnpremult(MaterialExpressionMaterialXUnpremult):
    r"""
    deprecated: 'MaterialExpressionUnpremult' was renamed to 'MaterialExpressionMaterialXUnpremult'.
    """
    ...

class InterchangeMaterialFactory(InterchangeFactoryBase):
    r"""
    Interchange Material Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeMaterialFactory.h
    
    """
    ...

class InterchangeMaterialFunctionFactory(InterchangeFactoryBase):
    r"""
    Interchange Material Function Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeMaterialFactory.h
    
    """
    ...

class InterchangeOBJTranslator(InterchangeTranslatorBase):
    r"""
    Interchange OBJTranslator
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeOBJTranslator.h
    
    """
    ...

class InterchangePhysicsAssetFactory(InterchangeFactoryBase):
    r"""
    Interchange Physics Asset Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangePhysicsAssetFactory.h
    
    """
    ...

class InterchangeSkeletalMeshFactory(InterchangeFactoryBase):
    r"""
    Interchange Skeletal Mesh Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeSkeletalMeshFactory.h
    
    """
    ...

class InterchangeSkeletonFactory(InterchangeFactoryBase):
    r"""
    Interchange Skeleton Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeSkeletonFactory.h
    
    """
    ...

class InterchangeStaticMeshFactory(InterchangeFactoryBase):
    r"""
    Interchange Static Mesh Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeStaticMeshFactory.h
    
    """
    ...

class InterchangeCineCameraActorFactory(InterchangeActorFactory):
    r"""
    Interchange Cine Camera Actor Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeCameraActorFactory.h
    
    """
    ...

class InterchangeCameraActorFactory(InterchangeActorFactory):
    r"""
    Interchange Camera Actor Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeCameraActorFactory.h
    
    """
    ...

class InterchangeSkeletalMeshActorFactory(InterchangeActorFactory):
    r"""
    Interchange Skeletal Mesh Actor Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeSkeletalMeshActorFactory.h
    
    """
    ...

class InterchangeStaticMeshActorFactory(InterchangeActorFactory):
    r"""
    Interchange Static Mesh Actor Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeStaticMeshActorFactory.h
    
    """
    ...

class InterchangeDDSTranslator(InterchangeTranslatorBase):
    r"""
    Interchange DDSTranslator
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeDDSTranslator.h
    
    """
    ...

class InterchangeIESTranslator(InterchangeTranslatorBase):
    r"""
    Interchange IESTranslator
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeIESTranslator.h
    
    """
    ...

class InterchangeImageWrapperTranslator(InterchangeTranslatorBase):
    r"""
    A translator for most of the image wrapper supported formats
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeImageWrapperTranslator.h
    
    """
    ...

class InterchangeJPGTranslator(InterchangeTranslatorBase):
    r"""
    Interchange JPGTranslator
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeJPGTranslator.h
    
    """
    ...

class InterchangePCXTranslator(InterchangeTranslatorBase):
    r"""
    Interchange PCXTranslator
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangePCXTranslator.h
    
    """
    ...

class InterchangePSDTranslator(InterchangeTranslatorBase):
    r"""
    Interchange PSDTranslator
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangePSDTranslator.h
    
    """
    ...

class InterchangeTextureFactory(InterchangeFactoryBase):
    r"""
    Interchange Texture Factory
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeTextureFactory.h
    
    """
    ...

class InterchangeUEJPEGTranslator(InterchangeTranslatorBase):
    r"""
    Interchange UEJPEGTranslator
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeImport
    - **File**: InterchangeUEJPEGTranslator.h
    
    """
    ...

class InterchangeGenericCommonMeshesProperties(InterchangePipelineBase):
    r"""
    Interchange Generic Common Meshes Properties
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericAssetsPipelineSharedSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_detect_mesh_type`` (bool):  [Read-Write] If enabled, and some static mesh transforms are animated, the pipeline will convert the static mesh into a rigid skeletal mesh.
      This setting is only used if the Force All Meshes As Type setting is set to "None".
    - ``bake_meshes`` (bool):  [Read-Write] If enabled, meshes are baked with the scene instance hierarchy transform.
    - ``compute_weighted_normals`` (bool):  [Read-Write] If enabled, normals are computed using the surface area and the corner angle of the triangle as a ratio.
    - ``force_all_mesh_as_type`` (InterchangeForceMeshType):  [Read-Write] If set, imports all meshes in the source as either static meshes or skeletal meshes.
    - ``import_lods`` (bool):  [Read-Write] If enabled, any existing LODs for meshes are imported. This setting is only used if the Bake Meshes setting is also enabled.
    - ``keep_sections_separate`` (bool):  [Read-Write] If checked, sections with matching materials are kept separate and will not get combined.
    - ``recompute_normals`` (bool):  [Read-Write] If enabled, normals in the imported mesh are ignored and recomputed.
    - ``recompute_tangents`` (bool):  [Read-Write] If enabled, tangents in the imported mesh are ignored and recomputed.
    - ``remove_degenerates`` (bool):  [Read-Write] If true, degenerate triangles are removed.
    - ``use_backwards_compatible_f16_trunc_u_vs`` (bool):  [Read-Write] If enabled, UVs are converted to 16-bit by a legacy truncation process instead of the default rounding process. This may avoid differences when reimporting older content.
    - ``use_full_precision_u_vs`` (bool):  [Read-Write] If true, UVs are stored at full floating-point precision.
    - ``use_high_precision_tangent_basis`` (bool):  [Read-Write] If true, tangents are stored at 16-bit vs 8-bit precision.
    - ``use_mikk_t_space`` (bool):  [Read-Write] If enabled, tangents are recomputed using MikkTSpace.
    - ``vertex_color_import_option`` (InterchangeVertexColorImportOption):  [Read-Write] Specify how vertex colors should be imported.
    - ``vertex_override_color`` (Color):  [Read-Write] Specify an override color for use when the Vertex Color Import Option setting is set to Override.
    """
    @property
    def force_all_mesh_as_type(self) -> InterchangeForceMeshType:
        r"""
        (InterchangeForceMeshType):  [Read-Write] If set, imports all meshes in the source as either static meshes or skeletal meshes.
        """
        ...
    @force_all_mesh_as_type.setter
    def force_all_mesh_as_type(self, value: InterchangeForceMeshType) -> None:
        ...
    @property
    def auto_detect_mesh_type(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, and some static mesh transforms are animated, the pipeline will convert the static mesh into a rigid skeletal mesh.
        This setting is only used if the Force All Meshes As Type setting is set to "None".
        """
        ...
    @auto_detect_mesh_type.setter
    def auto_detect_mesh_type(self, value: bool) -> None:
        ...
    @property
    def import_lods(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, any existing LODs for meshes are imported. This setting is only used if the Bake Meshes setting is also enabled.
        """
        ...
    @import_lods.setter
    def import_lods(self, value: bool) -> None:
        ...
    @property
    def bake_meshes(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, meshes are baked with the scene instance hierarchy transform.
        """
        ...
    @bake_meshes.setter
    def bake_meshes(self, value: bool) -> None:
        ...
    @property
    def keep_sections_separate(self) -> bool:
        r"""
        (bool):  [Read-Write] If checked, sections with matching materials are kept separate and will not get combined.
        """
        ...
    @keep_sections_separate.setter
    def keep_sections_separate(self, value: bool) -> None:
        ...
    @property
    def vertex_color_import_option(self) -> InterchangeVertexColorImportOption:
        r"""
        (InterchangeVertexColorImportOption):  [Read-Write] Specify how vertex colors should be imported.
        """
        ...
    @vertex_color_import_option.setter
    def vertex_color_import_option(self, value: InterchangeVertexColorImportOption) -> None:
        ...
    @property
    def vertex_override_color(self) -> Color:
        r"""
        (Color):  [Read-Write] Specify an override color for use when the Vertex Color Import Option setting is set to Override.
        """
        ...
    @vertex_override_color.setter
    def vertex_override_color(self, value: Color) -> None:
        ...
    @property
    def recompute_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, normals in the imported mesh are ignored and recomputed.
        """
        ...
    @recompute_normals.setter
    def recompute_normals(self, value: bool) -> None:
        ...
    @property
    def recompute_tangents(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, tangents in the imported mesh are ignored and recomputed.
        """
        ...
    @recompute_tangents.setter
    def recompute_tangents(self, value: bool) -> None:
        ...
    @property
    def use_mikk_t_space(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, tangents are recomputed using MikkTSpace.
        """
        ...
    @use_mikk_t_space.setter
    def use_mikk_t_space(self, value: bool) -> None:
        ...
    @property
    def compute_weighted_normals(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, normals are computed using the surface area and the corner angle of the triangle as a ratio.
        """
        ...
    @compute_weighted_normals.setter
    def compute_weighted_normals(self, value: bool) -> None:
        ...
    @property
    def use_high_precision_tangent_basis(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, tangents are stored at 16-bit vs 8-bit precision.
        """
        ...
    @use_high_precision_tangent_basis.setter
    def use_high_precision_tangent_basis(self, value: bool) -> None:
        ...
    @property
    def use_full_precision_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, UVs are stored at full floating-point precision.
        """
        ...
    @use_full_precision_u_vs.setter
    def use_full_precision_u_vs(self, value: bool) -> None:
        ...
    @property
    def use_backwards_compatible_f16_trunc_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, UVs are converted to 16-bit by a legacy truncation process instead of the default rounding process. This may avoid differences when reimporting older content.
        """
        ...
    @use_backwards_compatible_f16_trunc_u_vs.setter
    def use_backwards_compatible_f16_trunc_u_vs(self, value: bool) -> None:
        ...
    @property
    def remove_degenerates(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, degenerate triangles are removed.
        """
        ...
    @remove_degenerates.setter
    def remove_degenerates(self, value: bool) -> None:
        ...

class InterchangeGenericCommonSkeletalMeshesAndAnimationsProperties(InterchangePipelineBase):
    r"""
    Interchange Generic Common Skeletal Meshes and Animations Properties
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericAssetsPipelineSharedSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``convert_statics_with_morph_targets_to_skeletals`` (bool):  [Read-Write] If enabled, all static meshes that have morph targets will be imported as skeletal meshes instead.
    - ``import_meshes_in_bone_hierarchy`` (bool):  [Read-Write] If enabled, meshes nested in bone hierarchies will be imported as meshes instead of being converted to bones. If the meshes are not skinned, they are
      added to the skeletal mesh and removed from the list of static meshes.
    - ``import_only_animations`` (bool):  [Read-Write] If enabled, only animations are imported from the source. You must also set a valid skeleton.
    - ``skeleton`` (Skeleton):  [Read-Write] Skeleton to use for imported asset. When importing a skeletal mesh, leaving this as "None" will create a new skeleton. When importing an animation, this must be specified.
    - ``use_t0_as_ref_pose`` (bool):  [Read-Write] If enabled, frame 0 is used as the reference pose for skeletal meshes.
    """
    @property
    def import_only_animations(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, only animations are imported from the source. You must also set a valid skeleton.
        """
        ...
    @import_only_animations.setter
    def import_only_animations(self, value: bool) -> None:
        ...
    @property
    def skeleton(self) -> Skeleton:
        r"""
        (Skeleton):  [Read-Write] Skeleton to use for imported asset. When importing a skeletal mesh, leaving this as "None" will create a new skeleton. When importing an animation, this must be specified.
        """
        ...
    @skeleton.setter
    def skeleton(self, value: Skeleton) -> None:
        ...
    @property
    def import_meshes_in_bone_hierarchy(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, meshes nested in bone hierarchies will be imported as meshes instead of being converted to bones. If the meshes are not skinned, they are
        added to the skeletal mesh and removed from the list of static meshes.
        """
        ...
    @import_meshes_in_bone_hierarchy.setter
    def import_meshes_in_bone_hierarchy(self, value: bool) -> None:
        ...
    @property
    def use_t0_as_ref_pose(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, frame 0 is used as the reference pose for skeletal meshes.
        """
        ...
    @use_t0_as_ref_pose.setter
    def use_t0_as_ref_pose(self, value: bool) -> None:
        ...
    @property
    def convert_statics_with_morph_targets_to_skeletals(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, all static meshes that have morph targets will be imported as skeletal meshes instead.
        """
        ...
    @convert_statics_with_morph_targets_to_skeletals.setter
    def convert_statics_with_morph_targets_to_skeletals(self, value: bool) -> None:
        ...

class InterchangeGLTFPipeline(InterchangePipelineBase):
    r"""
    Interchange GLTFPipeline
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeglTFPipeline.h
    
    """
    ...

class InterchangeMaterialXPipeline(InterchangePipelineBase):
    r"""
    Interchange Material XPipeline
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeMaterialXPipeline.h
    
    """
    ...

class InterchangeGenericAnimationPipeline(InterchangePipelineBase):
    r"""
    Interchange Generic Animation Pipeline
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericAnimationPipeline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``add_curve_metadata_to_skeleton`` (bool):  [Read-Write] Determines whether to automatically add curve metadata to an animation's skeleton. If this setting is disabled, curve metadata will be added to skeletal meshes for morph targets, but no metadata entry will be created for general curves.
    - ``animation_range`` (InterchangeAnimationRange):  [Read-Write] Determines which animation range to import: the range defined at export, the range of frames with animation, or a manually defined range.
    - ``custom_bone_animation_sample_rate`` (int32):  [Read-Write] Sample fbx animation data at the specified sample rate, 0 find automaticaly the best sample rate
    - ``delete_existing_custom_attribute_curves`` (bool):  [Read-Write] If enabled, all previous node attributes imported as Animation Curves will be deleted when doing a reimport.
    - ``delete_existing_morph_target_curves`` (bool):  [Read-Write] If enabled, all previous morph target curves will be deleted when doing a reimport.
    - ``delete_existing_non_curve_custom_attributes`` (bool):  [Read-Write] If enabled, all previous node attributes imported as Animation Attributes will be deleted when doing a reimport.
    - ``do_not_import_curve_with_zero`` (bool):  [Read-Write] When importing a custom attribute or morph target as a curve, only import if it has a value other than zero. This avoids adding extra curves to evaluate.
    - ``frame_import_range`` (Int32Interval):  [Read-Write] The frame range used when the Animation Length setting is set to Set Range.
    - ``import_animations`` (bool):  [Read-Write] If enabled, import all animation assets found in the source.
    - ``import_bone_tracks`` (bool):  [Read-Write] Import bone transform tracks. If false, this will discard any bone transform tracks.
    - ``import_custom_attribute`` (bool):  [Read-Write] If enabled, import node attributes as either Animation Curves or Animation Attributes.
    - ``material_curve_suffixes`` (Array[str]):  [Read-Write] Set the Material Curve Type for custom attributes that have the specified suffixes. This setting is not used if the Set Material Curve Type setting is enabled.
    - ``remove_curve_redundant_keys`` (bool):  [Read-Write] When importing custom attributes as curves, remove redundant keys.
    - ``set_material_drive_parameter_on_custom_attribute`` (bool):  [Read-Write] Set the material curve type for all custom attributes.
    - ``snap_to_closest_frame_boundary`` (bool):  [Read-Write] If enabled, snaps the animation to the closest frame boundary using the import sampling rate.
    - ``use30_hz_to_bake_bone_animation`` (bool):  [Read-Write] If enabled, samples all animation curves to 30 FPS
    """
    @property
    def import_animations(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, import all animation assets found in the source.
        """
        ...
    @import_animations.setter
    def import_animations(self, value: bool) -> None:
        ...
    @property
    def import_bone_tracks(self) -> bool:
        r"""
        (bool):  [Read-Write] Import bone transform tracks. If false, this will discard any bone transform tracks.
        """
        ...
    @import_bone_tracks.setter
    def import_bone_tracks(self, value: bool) -> None:
        ...
    @property
    def animation_range(self) -> InterchangeAnimationRange:
        r"""
        (InterchangeAnimationRange):  [Read-Write] Determines which animation range to import: the range defined at export, the range of frames with animation, or a manually defined range.
        """
        ...
    @animation_range.setter
    def animation_range(self, value: InterchangeAnimationRange) -> None:
        ...
    @property
    def frame_import_range(self) -> Int32Interval:
        r"""
        (Int32Interval):  [Read-Write] The frame range used when the Animation Length setting is set to Set Range.
        """
        ...
    @frame_import_range.setter
    def frame_import_range(self, value: Int32Interval) -> None:
        ...
    @property
    def use30_hz_to_bake_bone_animation(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, samples all animation curves to 30 FPS
        """
        ...
    @use30_hz_to_bake_bone_animation.setter
    def use30_hz_to_bake_bone_animation(self, value: bool) -> None:
        ...
    @property
    def custom_bone_animation_sample_rate(self) -> int:
        r"""
        (int32):  [Read-Write] Sample fbx animation data at the specified sample rate, 0 find automaticaly the best sample rate
        """
        ...
    @custom_bone_animation_sample_rate.setter
    def custom_bone_animation_sample_rate(self, value: int) -> None:
        ...
    @property
    def snap_to_closest_frame_boundary(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, snaps the animation to the closest frame boundary using the import sampling rate.
        """
        ...
    @snap_to_closest_frame_boundary.setter
    def snap_to_closest_frame_boundary(self, value: bool) -> None:
        ...
    @property
    def import_custom_attribute(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, import node attributes as either Animation Curves or Animation Attributes.
        """
        ...
    @import_custom_attribute.setter
    def import_custom_attribute(self, value: bool) -> None:
        ...
    @property
    def add_curve_metadata_to_skeleton(self) -> bool:
        r"""
        (bool):  [Read-Write] Determines whether to automatically add curve metadata to an animation's skeleton. If this setting is disabled, curve metadata will be added to skeletal meshes for morph targets, but no metadata entry will be created for general curves.
        """
        ...
    @add_curve_metadata_to_skeleton.setter
    def add_curve_metadata_to_skeleton(self, value: bool) -> None:
        ...
    @property
    def set_material_drive_parameter_on_custom_attribute(self) -> bool:
        r"""
        (bool):  [Read-Write] Set the material curve type for all custom attributes.
        """
        ...
    @set_material_drive_parameter_on_custom_attribute.setter
    def set_material_drive_parameter_on_custom_attribute(self, value: bool) -> None:
        ...
    @property
    def material_curve_suffixes(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Set the Material Curve Type for custom attributes that have the specified suffixes. This setting is not used if the Set Material Curve Type setting is enabled.
        """
        ...
    @material_curve_suffixes.setter
    def material_curve_suffixes(self, value: Array[str]) -> None:
        ...
    @property
    def remove_curve_redundant_keys(self) -> bool:
        r"""
        (bool):  [Read-Write] When importing custom attributes as curves, remove redundant keys.
        """
        ...
    @remove_curve_redundant_keys.setter
    def remove_curve_redundant_keys(self, value: bool) -> None:
        ...
    @property
    def do_not_import_curve_with_zero(self) -> bool:
        r"""
        (bool):  [Read-Write] When importing a custom attribute or morph target as a curve, only import if it has a value other than zero. This avoids adding extra curves to evaluate.
        """
        ...
    @do_not_import_curve_with_zero.setter
    def do_not_import_curve_with_zero(self, value: bool) -> None:
        ...
    @property
    def delete_existing_non_curve_custom_attributes(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, all previous node attributes imported as Animation Attributes will be deleted when doing a reimport.
        """
        ...
    @delete_existing_non_curve_custom_attributes.setter
    def delete_existing_non_curve_custom_attributes(self, value: bool) -> None:
        ...
    @property
    def delete_existing_custom_attribute_curves(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, all previous node attributes imported as Animation Curves will be deleted when doing a reimport.
        """
        ...
    @delete_existing_custom_attribute_curves.setter
    def delete_existing_custom_attribute_curves(self, value: bool) -> None:
        ...
    @property
    def delete_existing_morph_target_curves(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, all previous morph target curves will be deleted when doing a reimport.
        """
        ...
    @delete_existing_morph_target_curves.setter
    def delete_existing_morph_target_curves(self, value: bool) -> None:
        ...

class InterchangeGenericAssetsPipeline(InterchangePipelineBase):
    r"""
    This pipeline is the generic option for all types of meshes. It should be called before specialized mesh pipelines like the generic static mesh or skeletal mesh pipelines.
    All import options that are shared between mesh types should be added here.
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericAssetsPipeline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animation_pipeline`` (InterchangeGenericAnimationPipeline):  [Read-Only] ANIMATIONS_CATEGORY Properties
    - ``asset_name`` (str):  [Read-Write] If set, and there is only one asset and one source, the imported asset is given this name.
    - ``common_meshes_properties`` (InterchangeGenericCommonMeshesProperties):  [Read-Only] COMMON_MESHES_CATEGORY Properties
    - ``common_skeletal_meshes_and_animations_properties`` (InterchangeGenericCommonSkeletalMeshesAndAnimationsProperties):  [Read-Only] COMMON_SKELETAL_ANIMATIONS_CATEGORY
    - ``import_offset_rotation`` (Rotator):  [Read-Write] Rotation offset applied to meshes and animations.
    - ``import_offset_translation`` (Vector):  [Read-Write] Translation offset applied to meshes and animations.
    - ``import_offset_uniform_scale`` (float):  [Read-Write] Uniform scale offset applied to meshes and animations.
    - ``material_pipeline`` (InterchangeGenericMaterialPipeline):  [Read-Only] MATERIALS_CATEGORY Properties
    - ``mesh_pipeline`` (InterchangeGenericMeshPipeline):  [Read-Only] MESHES_CATEGORY Properties
    - ``pipeline_display_name`` (str):  [Read-Write] The name of the pipeline that will be display in the import dialog.
    - ``reimport_strategy`` (ReimportStrategyFlags):  [Read-Write] Set the reimport strategy.
    - ``use_source_name_for_asset`` (bool):  [Read-Write] If enabled, and the Asset Name setting is empty, and there is only one asset and one source, the imported asset is given the same name as the source data.
    """
    @property
    def pipeline_display_name(self) -> str:
        r"""
        (str):  [Read-Write] The name of the pipeline that will be display in the import dialog.
        """
        ...
    @pipeline_display_name.setter
    def pipeline_display_name(self, value: str) -> None:
        ...
    @property
    def reimport_strategy(self) -> ReimportStrategyFlags:
        r"""
        (ReimportStrategyFlags):  [Read-Write] Set the reimport strategy.
        """
        ...
    @reimport_strategy.setter
    def reimport_strategy(self, value: ReimportStrategyFlags) -> None:
        ...
    @property
    def use_source_name_for_asset(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, and the Asset Name setting is empty, and there is only one asset and one source, the imported asset is given the same name as the source data.
        """
        ...
    @use_source_name_for_asset.setter
    def use_source_name_for_asset(self, value: bool) -> None:
        ...
    @property
    def asset_name(self) -> str:
        r"""
        (str):  [Read-Write] If set, and there is only one asset and one source, the imported asset is given this name.
        """
        ...
    @asset_name.setter
    def asset_name(self, value: str) -> None:
        ...
    @property
    def import_offset_translation(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Translation offset applied to meshes and animations.
        """
        ...
    @import_offset_translation.setter
    def import_offset_translation(self, value: Vector) -> None:
        ...
    @property
    def import_offset_rotation(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] Rotation offset applied to meshes and animations.
        """
        ...
    @import_offset_rotation.setter
    def import_offset_rotation(self, value: Rotator) -> None:
        ...
    @property
    def import_offset_uniform_scale(self) -> float:
        r"""
        (float):  [Read-Write] Uniform scale offset applied to meshes and animations.
        """
        ...
    @import_offset_uniform_scale.setter
    def import_offset_uniform_scale(self, value: float) -> None:
        ...
    @property
    def common_meshes_properties(self) -> InterchangeGenericCommonMeshesProperties:
        r"""
        (InterchangeGenericCommonMeshesProperties):  [Read-Only] COMMON_MESHES_CATEGORY Properties
        """
        ...
    @property
    def common_skeletal_meshes_and_animations_properties(self) -> InterchangeGenericCommonSkeletalMeshesAndAnimationsProperties:
        r"""
        (InterchangeGenericCommonSkeletalMeshesAndAnimationsProperties):  [Read-Only] COMMON_SKELETAL_ANIMATIONS_CATEGORY
        """
        ...
    @property
    def mesh_pipeline(self) -> InterchangeGenericMeshPipeline:
        r"""
        (InterchangeGenericMeshPipeline):  [Read-Only] MESHES_CATEGORY Properties
        """
        ...
    @property
    def animation_pipeline(self) -> InterchangeGenericAnimationPipeline:
        r"""
        (InterchangeGenericAnimationPipeline):  [Read-Only] ANIMATIONS_CATEGORY Properties
        """
        ...
    @property
    def material_pipeline(self) -> InterchangeGenericMaterialPipeline:
        r"""
        (InterchangeGenericMaterialPipeline):  [Read-Only] MATERIALS_CATEGORY Properties
        """
        ...

class InterchangeGenericMaterialPipeline(InterchangePipelineBase):
    r"""
    Interchange Generic Material Pipeline
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericMaterialPipeline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_name`` (str):  [Read-Write] If set, and there is only one asset and one source, the imported asset will be given this name.
    - ``create_material_instance_for_parent`` (bool):  [Read-Write] If set, additional material instances are created for reference/parent materials.
    - ``identify_duplicate_materials`` (bool):  [Read-Write] If set, reference materials along with respective material instances are created.
    - ``import_materials`` (bool):  [Read-Write] If enabled, imports the material assets found in the sources.
    - ``material_import`` (InterchangeMaterialImportOption):  [Read-Write] Determines what kind of material assets should be created for the imported materials.
    - ``parent_material`` (SoftObjectPath):  [Read-Write] Optional material used as the parent when importing materials as instances. If no parent material is specified, one will be automatically selected during the import process.
    - ``pipeline_display_name`` (str):  [Read-Write] The name of the pipeline that will be display in the import dialog.
    - ``search_location`` (InterchangeMaterialSearchLocation):  [Read-Write] Specify where we should search for existing materials when importing.
    - ``texture_pipeline`` (InterchangeGenericTexturePipeline):  [Read-Only]
    """
    @property
    def pipeline_display_name(self) -> str:
        r"""
        (str):  [Read-Write] The name of the pipeline that will be display in the import dialog.
        """
        ...
    @pipeline_display_name.setter
    def pipeline_display_name(self, value: str) -> None:
        ...
    @property
    def import_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, imports the material assets found in the sources.
        """
        ...
    @import_materials.setter
    def import_materials(self, value: bool) -> None:
        ...
    @property
    def search_location(self) -> InterchangeMaterialSearchLocation:
        r"""
        (InterchangeMaterialSearchLocation):  [Read-Write] Specify where we should search for existing materials when importing.
        """
        ...
    @search_location.setter
    def search_location(self, value: InterchangeMaterialSearchLocation) -> None:
        ...
    @property
    def asset_name(self) -> str:
        r"""
        (str):  [Read-Write] If set, and there is only one asset and one source, the imported asset will be given this name.
        """
        ...
    @asset_name.setter
    def asset_name(self, value: str) -> None:
        ...
    @property
    def material_import(self) -> InterchangeMaterialImportOption:
        r"""
        (InterchangeMaterialImportOption):  [Read-Write] Determines what kind of material assets should be created for the imported materials.
        """
        ...
    @material_import.setter
    def material_import(self, value: InterchangeMaterialImportOption) -> None:
        ...
    @property
    def identify_duplicate_materials(self) -> bool:
        r"""
        (bool):  [Read-Write] If set, reference materials along with respective material instances are created.
        """
        ...
    @identify_duplicate_materials.setter
    def identify_duplicate_materials(self, value: bool) -> None:
        ...
    @property
    def create_material_instance_for_parent(self) -> bool:
        r"""
        (bool):  [Read-Write] If set, additional material instances are created for reference/parent materials.
        """
        ...
    @create_material_instance_for_parent.setter
    def create_material_instance_for_parent(self, value: bool) -> None:
        ...
    @property
    def parent_material(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Write] Optional material used as the parent when importing materials as instances. If no parent material is specified, one will be automatically selected during the import process.
        """
        ...
    @parent_material.setter
    def parent_material(self, value: SoftObjectPath) -> None:
        ...
    @property
    def texture_pipeline(self) -> InterchangeGenericTexturePipeline:
        r"""
        (InterchangeGenericTexturePipeline):  [Read-Only]
        """
        ...

class InterchangeGenericMeshPipeline(InterchangePipelineBase):
    r"""
    Hide drop down will make sure the class is not showing in the class picker
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericMeshPipeline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_influence_limit`` (int32):  [Read-Write] The maximum number of bone influences to allow each vertex in this mesh to use.
      If set higher than the limit determined by the project settings, it has no effect.
      If set to 0, the value is taken from the DefaultBoneInfluenceLimit project setting.
    - ``build_nanite`` (bool):  [Read-Write] If enabled, imported meshes will be rendered by Nanite at runtime. Make sure your meshes and materials meet the requirements for Nanite.
    - ``build_reversed_index_buffer`` (bool):  [Read-Write] If enabled, builds a reversed index buffer for each static mesh.
    - ``build_scale3d`` (Vector):  [Read-Write] The local scale applied when building the mesh.
    - ``combine_skeletal_meshes`` (bool):  [Read-Write] If enabled, all skinned mesh nodes that belong to the same skeleton root joint are combined into a single skeletal mesh.
    - ``combine_static_meshes`` (bool):  [Read-Write] If enabled, all translated static mesh nodes will be imported as a single static mesh.
    - ``create_physics_asset`` (bool):  [Read-Write] If enabled, create new PhysicsAsset if one doesn't exist.
    - ``distance_field_replacement_mesh`` (StaticMesh):  [Read-Write] If set, replaces the distance field for all imported meshes with the distance field of the specified Static Mesh.
    - ``distance_field_resolution_scale`` (float):  [Read-Write] Scale to apply to the mesh when allocating the distance field volume texture.
      The default scale is 1, which assumes that the mesh will be placed unscaled in the world.
    - ``dst_lightmap_index`` (int32):  [Read-Write] Specifies the index of the UV channel that will store generated lightmap UVs.
    - ``generate_distance_field_as_if_two_sided`` (bool):  [Read-Write] Determines whether to generate the distance field treating every triangle hit as a front face.
      When enabled, prevents the distance field from being discarded due to the mesh being open, but also lowers distance field ambient occlusion quality.
    - ``generate_lightmap_u_vs`` (bool):  [Read-Write] If enabled, generates lightmap UVs for each static mesh.
    - ``import_collision`` (bool):  [Read-Write] If enabled, custom collision will be imported. If enabled and there is no custom collision, a generic collision will be automatically generated.
      If disabled, no collision will be created or imported.
    - ``import_collision_according_to_mesh_name`` (bool):  [Read-Write] If enabled, meshes with certain prefixes will be imported as collision primitives for the mesh with the corresponding unprefixed name.
      
      Supported prefixes are:
      UBX_ Box collision
      UCP_ Capsule collision
      USP_ Sphere collision
      UCX_ Convex collision
    - ``import_morph_targets`` (bool):  [Read-Write] If enabled, imports all morph target shapes found in the source.
    - ``import_skeletal_meshes`` (bool):  [Read-Write] If enabled, imports all skeletal mesh assets found in the sources.
    - ``import_static_meshes`` (bool):  [Read-Write] If enabled, imports all static mesh assets found in the sources.
    - ``import_vertex_attributes`` (bool):  [Read-Write] If enabled, creates named vertex attributes for secondary vertex color data.
    - ``lod_group`` (Name):  [Read-Write] The LOD group that will be assigned to this mesh.
    - ``max_lumen_mesh_cards`` (int32):  [Read-Write] The maximum number of Lumen mesh cards to generate for this mesh.
      More cards means that the surface will have better coverage, but will result in increased runtime overhead.
      Set this to 0 to disable mesh card generation for this mesh.
      The default is 12.
    - ``min_lightmap_resolution`` (int32):  [Read-Write] When generating lightmaps, determines the amount of padding used to pack UVs. Set this value to the lowest-resolution lightmap you expect to use with the imported meshes.
    - ``morph_threshold_position`` (float):  [Read-Write] Threshold to compare vertex position equality when computing morph target deltas.
    - ``one_convex_hull_per_ucx`` (bool):  [Read-Write] If enabled, each UCX collision mesh will be imported as a single convex hull. If disabled, a UCX mesh will be decomposed into its separate pieces and a convex hull generated for each.
    - ``physics_asset`` (PhysicsAsset):  [Read-Write] If set, use the specified PhysicsAsset. If not set and the Create Physics Asset setting is not enabled, the importer will not generate or set any physics asset.
    - ``skeletal_mesh_import_content_type`` (InterchangeSkeletalMeshContentType):  [Read-Write] Determines what types of information are imported for skeletal meshes.
    - ``src_lightmap_index`` (int32):  [Read-Write] Specifies the index of the UV channel that will be used as the source when generating lightmaps.
    - ``support_face_remap`` (bool):  [Read-Write] If enabled, imported static meshes are set up for use with physical material masks.
    - ``threshold_position`` (float):  [Read-Write] Threshold value that is used to decide whether two vertex positions are equal.
    - ``threshold_tangent_normal`` (float):  [Read-Write] Threshold value that is used to decide whether two normals, tangents, or bi-normals are equal.
    - ``threshold_uv`` (float):  [Read-Write] Threshold value that is used to decide whether two UVs are equal.
    - ``update_skeleton_reference_pose`` (bool):  [Read-Write] Enable this option to update the reference pose of the Skeleton (of the mesh). The reference pose of the mesh is always updated.
    - ``use_high_precision_skin_weights`` (bool):  [Read-Write] If enabled, imported skin weights use 16 bits instead of 8 bits.
    """
    @property
    def import_static_meshes(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, imports all static mesh assets found in the sources.
        """
        ...
    @import_static_meshes.setter
    def import_static_meshes(self, value: bool) -> None:
        ...
    @property
    def combine_static_meshes(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, all translated static mesh nodes will be imported as a single static mesh.
        """
        ...
    @combine_static_meshes.setter
    def combine_static_meshes(self, value: bool) -> None:
        ...
    @property
    def lod_group(self) -> Name:
        r"""
        (Name):  [Read-Write] The LOD group that will be assigned to this mesh.
        """
        ...
    @lod_group.setter
    def lod_group(self, value: Name) -> None:
        ...
    @property
    def import_collision(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, custom collision will be imported. If enabled and there is no custom collision, a generic collision will be automatically generated.
        If disabled, no collision will be created or imported.
        """
        ...
    @import_collision.setter
    def import_collision(self, value: bool) -> None:
        ...
    @property
    def import_collision_according_to_mesh_name(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, meshes with certain prefixes will be imported as collision primitives for the mesh with the corresponding unprefixed name.
        
        Supported prefixes are:
        UBX_ Box collision
        UCP_ Capsule collision
        USP_ Sphere collision
        UCX_ Convex collision
        """
        ...
    @import_collision_according_to_mesh_name.setter
    def import_collision_according_to_mesh_name(self, value: bool) -> None:
        ...
    @property
    def one_convex_hull_per_ucx(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, each UCX collision mesh will be imported as a single convex hull. If disabled, a UCX mesh will be decomposed into its separate pieces and a convex hull generated for each.
        """
        ...
    @one_convex_hull_per_ucx.setter
    def one_convex_hull_per_ucx(self, value: bool) -> None:
        ...
    @property
    def build_nanite(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, imported meshes will be rendered by Nanite at runtime. Make sure your meshes and materials meet the requirements for Nanite.
        """
        ...
    @build_nanite.setter
    def build_nanite(self, value: bool) -> None:
        ...
    @property
    def build_reversed_index_buffer(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, builds a reversed index buffer for each static mesh.
        """
        ...
    @build_reversed_index_buffer.setter
    def build_reversed_index_buffer(self, value: bool) -> None:
        ...
    @property
    def generate_lightmap_u_vs(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, generates lightmap UVs for each static mesh.
        """
        ...
    @generate_lightmap_u_vs.setter
    def generate_lightmap_u_vs(self, value: bool) -> None:
        ...
    @property
    def generate_distance_field_as_if_two_sided(self) -> bool:
        r"""
        (bool):  [Read-Write] Determines whether to generate the distance field treating every triangle hit as a front face.
        When enabled, prevents the distance field from being discarded due to the mesh being open, but also lowers distance field ambient occlusion quality.
        """
        ...
    @generate_distance_field_as_if_two_sided.setter
    def generate_distance_field_as_if_two_sided(self, value: bool) -> None:
        ...
    @property
    def support_face_remap(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, imported static meshes are set up for use with physical material masks.
        """
        ...
    @support_face_remap.setter
    def support_face_remap(self, value: bool) -> None:
        ...
    @property
    def min_lightmap_resolution(self) -> int:
        r"""
        (int32):  [Read-Write] When generating lightmaps, determines the amount of padding used to pack UVs. Set this value to the lowest-resolution lightmap you expect to use with the imported meshes.
        """
        ...
    @min_lightmap_resolution.setter
    def min_lightmap_resolution(self, value: int) -> None:
        ...
    @property
    def src_lightmap_index(self) -> int:
        r"""
        (int32):  [Read-Write] Specifies the index of the UV channel that will be used as the source when generating lightmaps.
        """
        ...
    @src_lightmap_index.setter
    def src_lightmap_index(self, value: int) -> None:
        ...
    @property
    def dst_lightmap_index(self) -> int:
        r"""
        (int32):  [Read-Write] Specifies the index of the UV channel that will store generated lightmap UVs.
        """
        ...
    @dst_lightmap_index.setter
    def dst_lightmap_index(self, value: int) -> None:
        ...
    @property
    def build_scale3d(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The local scale applied when building the mesh.
        """
        ...
    @build_scale3d.setter
    def build_scale3d(self, value: Vector) -> None:
        ...
    @property
    def distance_field_resolution_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scale to apply to the mesh when allocating the distance field volume texture.
        The default scale is 1, which assumes that the mesh will be placed unscaled in the world.
        """
        ...
    @distance_field_resolution_scale.setter
    def distance_field_resolution_scale(self, value: float) -> None:
        ...
    @property
    def distance_field_replacement_mesh(self) -> StaticMesh:
        r"""
        (StaticMesh):  [Read-Write] If set, replaces the distance field for all imported meshes with the distance field of the specified Static Mesh.
        """
        ...
    @distance_field_replacement_mesh.setter
    def distance_field_replacement_mesh(self, value: StaticMesh) -> None:
        ...
    @property
    def max_lumen_mesh_cards(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of Lumen mesh cards to generate for this mesh.
        More cards means that the surface will have better coverage, but will result in increased runtime overhead.
        Set this to 0 to disable mesh card generation for this mesh.
        The default is 12.
        """
        ...
    @max_lumen_mesh_cards.setter
    def max_lumen_mesh_cards(self, value: int) -> None:
        ...
    @property
    def import_skeletal_meshes(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, imports all skeletal mesh assets found in the sources.
        """
        ...
    @import_skeletal_meshes.setter
    def import_skeletal_meshes(self, value: bool) -> None:
        ...
    @property
    def skeletal_mesh_import_content_type(self) -> InterchangeSkeletalMeshContentType:
        r"""
        (InterchangeSkeletalMeshContentType):  [Read-Write] Determines what types of information are imported for skeletal meshes.
        """
        ...
    @skeletal_mesh_import_content_type.setter
    def skeletal_mesh_import_content_type(self, value: InterchangeSkeletalMeshContentType) -> None:
        ...
    @property
    def combine_skeletal_meshes(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, all skinned mesh nodes that belong to the same skeleton root joint are combined into a single skeletal mesh.
        """
        ...
    @combine_skeletal_meshes.setter
    def combine_skeletal_meshes(self, value: bool) -> None:
        ...
    @property
    def import_morph_targets(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, imports all morph target shapes found in the source.
        """
        ...
    @import_morph_targets.setter
    def import_morph_targets(self, value: bool) -> None:
        ...
    @property
    def import_vertex_attributes(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, creates named vertex attributes for secondary vertex color data.
        """
        ...
    @import_vertex_attributes.setter
    def import_vertex_attributes(self, value: bool) -> None:
        ...
    @property
    def update_skeleton_reference_pose(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable this option to update the reference pose of the Skeleton (of the mesh). The reference pose of the mesh is always updated.
        """
        ...
    @update_skeleton_reference_pose.setter
    def update_skeleton_reference_pose(self, value: bool) -> None:
        ...
    @property
    def create_physics_asset(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, create new PhysicsAsset if one doesn't exist.
        """
        ...
    @create_physics_asset.setter
    def create_physics_asset(self, value: bool) -> None:
        ...
    @property
    def physics_asset(self) -> PhysicsAsset:
        r"""
        (PhysicsAsset):  [Read-Write] If set, use the specified PhysicsAsset. If not set and the Create Physics Asset setting is not enabled, the importer will not generate or set any physics asset.
        """
        ...
    @physics_asset.setter
    def physics_asset(self, value: PhysicsAsset) -> None:
        ...
    @property
    def use_high_precision_skin_weights(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, imported skin weights use 16 bits instead of 8 bits.
        """
        ...
    @use_high_precision_skin_weights.setter
    def use_high_precision_skin_weights(self, value: bool) -> None:
        ...
    @property
    def threshold_position(self) -> float:
        r"""
        (float):  [Read-Write] Threshold value that is used to decide whether two vertex positions are equal.
        """
        ...
    @threshold_position.setter
    def threshold_position(self, value: float) -> None:
        ...
    @property
    def threshold_tangent_normal(self) -> float:
        r"""
        (float):  [Read-Write] Threshold value that is used to decide whether two normals, tangents, or bi-normals are equal.
        """
        ...
    @threshold_tangent_normal.setter
    def threshold_tangent_normal(self, value: float) -> None:
        ...
    @property
    def threshold_uv(self) -> float:
        r"""
        (float):  [Read-Write] Threshold value that is used to decide whether two UVs are equal.
        """
        ...
    @threshold_uv.setter
    def threshold_uv(self, value: float) -> None:
        ...
    @property
    def morph_threshold_position(self) -> float:
        r"""
        (float):  [Read-Write] Threshold to compare vertex position equality when computing morph target deltas.
        """
        ...
    @morph_threshold_position.setter
    def morph_threshold_position(self, value: float) -> None:
        ...
    @property
    def bone_influence_limit(self) -> int:
        r"""
        (int32):  [Read-Write] The maximum number of bone influences to allow each vertex in this mesh to use.
        If set higher than the limit determined by the project settings, it has no effect.
        If set to 0, the value is taken from the DefaultBoneInfluenceLimit project setting.
        """
        ...
    @bone_influence_limit.setter
    def bone_influence_limit(self, value: int) -> None:
        ...

class InterchangeGenericLevelPipeline(InterchangePipelineBase):
    r"""
    Interchange Generic Level Pipeline
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericScenesPipeline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``delete_missing_actors`` (bool):  [Read-Write] If enabled, deletes actors that were not part of the translation when reimporting into a level.
    - ``delete_missing_assets`` (bool):  [Read-Write] If enabled, deletes assets that were not part of the translation when reimporting into a level.
    - ``force_reimport_deleted_actors`` (bool):  [Read-Write] If enabled, respawns actors that were deleted in the editor prior to a reimport.
    - ``force_reimport_deleted_assets`` (bool):  [Read-Write] If enabled, recreates assets that were deleted in the editor prior to reimporting into a level.
    - ``pipeline_display_name`` (str):  [Read-Write] The name of the pipeline that will be display in the import dialog.
    - ``reimport_property_strategy`` (ReimportStrategyFlags):  [Read-Write] Set the reimport strategy when reimporting into the level.
    - ``use_physical_instead_of_standard_perspective_camera`` (bool):  [Read-Write] Disable this option to not convert Standard(Perspective) to Physical Cameras
    """
    @property
    def pipeline_display_name(self) -> str:
        r"""
        (str):  [Read-Write] The name of the pipeline that will be display in the import dialog.
        """
        ...
    @pipeline_display_name.setter
    def pipeline_display_name(self, value: str) -> None:
        ...
    @property
    def reimport_property_strategy(self) -> ReimportStrategyFlags:
        r"""
        (ReimportStrategyFlags):  [Read-Write] Set the reimport strategy when reimporting into the level.
        """
        ...
    @reimport_property_strategy.setter
    def reimport_property_strategy(self, value: ReimportStrategyFlags) -> None:
        ...
    @property
    def delete_missing_actors(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, deletes actors that were not part of the translation when reimporting into a level.
        """
        ...
    @delete_missing_actors.setter
    def delete_missing_actors(self, value: bool) -> None:
        ...
    @property
    def force_reimport_deleted_actors(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, respawns actors that were deleted in the editor prior to a reimport.
        """
        ...
    @force_reimport_deleted_actors.setter
    def force_reimport_deleted_actors(self, value: bool) -> None:
        ...
    @property
    def force_reimport_deleted_assets(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, recreates assets that were deleted in the editor prior to reimporting into a level.
        """
        ...
    @force_reimport_deleted_assets.setter
    def force_reimport_deleted_assets(self, value: bool) -> None:
        ...
    @property
    def delete_missing_assets(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, deletes assets that were not part of the translation when reimporting into a level.
        """
        ...
    @delete_missing_assets.setter
    def delete_missing_assets(self, value: bool) -> None:
        ...
    @property
    def use_physical_instead_of_standard_perspective_camera(self) -> bool:
        r"""
        (bool):  [Read-Write] Disable this option to not convert Standard(Perspective) to Physical Cameras
        """
        ...
    @use_physical_instead_of_standard_perspective_camera.setter
    def use_physical_instead_of_standard_perspective_camera(self, value: bool) -> None:
        ...

class InterchangeGenericTexturePipeline(InterchangePipelineBase):
    r"""
    Interchange Generic Texture Pipeline
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangeGenericTexturePipeline.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_non_power_of_two`` (bool):  [Read-Write] If enabled, textures that have a non-power-of-two resolution are imported.
    - ``asset_name`` (str):  [Read-Write] If set, and there is only one asset and one source, the imported asset will be given this name.
    - ``detect_normal_map_texture`` (bool):  [Read-Write] If enabled, tests each newly imported texture to see if it is a normal map.
      If it is, the SRGB, Compression Settings, and LOD Group properties of that texture will be adjusted.
    - ``file_extensions_to_import_as_long_lat_cubemap`` (Set[str]):  [Read-Write] Specify the file types that should be imported as long/lat cubemaps.
    - ``flip_normal_map_green_channel`` (bool):  [Read-Write] If enabled, the texture's green channel will be inverted for normal maps. This setting is only used if the Detect Normal Map Texture setting is also enabled.
    - ``import_textures`` (bool):  [Read-Write] If enabled, imports all texture assets found in the source.
    - ``import_udi_ms`` (bool):  [Read-Write] If enabled, imports textures as UDIMs if they are named using a UDIM naming pattern.
    - ``pipeline_display_name`` (str):  [Read-Write] The name of the pipeline that will be display in the import dialog.
    - ``prefer_compressed_source_data`` (bool):  [Read-Write] If enabled, the translator compresses the source data payload whenever possible. This generally results in smaller assets.
      However, some operations like the texture build might be slower, because the source data first needs to be decompressed.
      If disabled, the translator leaves the decision to the factory or the pipelines.
    """
    @property
    def pipeline_display_name(self) -> str:
        r"""
        (str):  [Read-Write] The name of the pipeline that will be display in the import dialog.
        """
        ...
    @pipeline_display_name.setter
    def pipeline_display_name(self, value: str) -> None:
        ...
    @property
    def import_textures(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, imports all texture assets found in the source.
        """
        ...
    @import_textures.setter
    def import_textures(self, value: bool) -> None:
        ...
    @property
    def asset_name(self) -> str:
        r"""
        (str):  [Read-Write] If set, and there is only one asset and one source, the imported asset will be given this name.
        """
        ...
    @asset_name.setter
    def asset_name(self, value: str) -> None:
        ...
    @property
    def detect_normal_map_texture(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, tests each newly imported texture to see if it is a normal map.
        If it is, the SRGB, Compression Settings, and LOD Group properties of that texture will be adjusted.
        """
        ...
    @detect_normal_map_texture.setter
    def detect_normal_map_texture(self, value: bool) -> None:
        ...
    @property
    def flip_normal_map_green_channel(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the texture's green channel will be inverted for normal maps. This setting is only used if the Detect Normal Map Texture setting is also enabled.
        """
        ...
    @flip_normal_map_green_channel.setter
    def flip_normal_map_green_channel(self, value: bool) -> None:
        ...
    @property
    def import_udi_ms(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, imports textures as UDIMs if they are named using a UDIM naming pattern.
        """
        ...
    @import_udi_ms.setter
    def import_udi_ms(self, value: bool) -> None:
        ...
    @property
    def file_extensions_to_import_as_long_lat_cubemap(self) -> Set[str]:
        r"""
        (Set[str]):  [Read-Write] Specify the file types that should be imported as long/lat cubemaps.
        """
        ...
    @file_extensions_to_import_as_long_lat_cubemap.setter
    def file_extensions_to_import_as_long_lat_cubemap(self, value: Set[str]) -> None:
        ...
    @property
    def prefer_compressed_source_data(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the translator compresses the source data payload whenever possible. This generally results in smaller assets.
        However, some operations like the texture build might be slower, because the source data first needs to be decompressed.
        If disabled, the translator leaves the decision to the factory or the pipelines.
        """
        ...
    @prefer_compressed_source_data.setter
    def prefer_compressed_source_data(self, value: bool) -> None:
        ...
    @property
    def allow_non_power_of_two(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, textures that have a non-power-of-two resolution are imported.
        """
        ...
    @allow_non_power_of_two.setter
    def allow_non_power_of_two(self, value: bool) -> None:
        ...

class InterchangePipelineMeshesUtilities(Object):
    r"""
    Interchange Pipeline Meshes Utilities
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangePipelines
    - **File**: InterchangePipelineMeshesUtilities.h
    
    """
    def set_context(self, context: InterchangePipelineMeshesUtilitiesContext) -> None:
        r"""
        x.set_context(context) -> None
        Set Context
        
        Args:
            context (InterchangePipelineMeshesUtilitiesContext):
        """
        ...
    def is_valid_mesh_instance_uid(self, mesh_instance_uid: str) -> bool:
        r"""
        x.is_valid_mesh_instance_uid(mesh_instance_uid) -> bool
        Return true if there is an existing FInterchangeMeshInstance that matches the MeshInstanceUid key.
        
        Args:
            mesh_instance_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def is_valid_mesh_geometry_uid(self, mesh_geometry_uid: str) -> bool:
        r"""
        x.is_valid_mesh_geometry_uid(mesh_geometry_uid) -> bool
        Return true if there is an existing FInterchangeMeshGeometry that matches the MeshInstanceUid key.
        
        Args:
            mesh_geometry_uid (str): 
        
        Returns:
            bool:
        """
        ...
    def get_mesh_instance_skeleton_root_uid(self, mesh_instance_uid: str) -> str:
        r"""
        x.get_mesh_instance_skeleton_root_uid(mesh_instance_uid) -> str
        Return the skeleton root node UID. This is the UID for a UInterchangeSceneNode that has a "Joint" specialized type.
        Return an empty string if the MeshInstanceUid parameter points to nothing.
        
        Args:
            mesh_instance_uid (str): 
        
        Returns:
            str:
        """
        ...
    def get_mesh_instance_by_uid(self, mesh_instance_uid: str) -> InterchangeMeshInstance:
        r"""
        x.get_mesh_instance_by_uid(mesh_instance_uid) -> InterchangeMeshInstance
        Get the instanced mesh from the unique ID.
        
        Args:
            mesh_instance_uid (str): 
        
        Returns:
            InterchangeMeshInstance:
        """
        ...
    def get_mesh_geometry_skeleton_root_uid(self, mesh_geometry_uid: str) -> str:
        r"""
        x.get_mesh_geometry_skeleton_root_uid(mesh_geometry_uid) -> str
        Return the skeleton root node UID. This is the UID for a UInterchangeSceneNode that has a "Joint" specialized type.
        Return an empty string if the MeshGeometryUid parameter points to nothing.
        
        Args:
            mesh_geometry_uid (str): 
        
        Returns:
            str:
        """
        ...
    def get_mesh_geometry_by_uid(self, mesh_geometry_uid: str) -> InterchangeMeshGeometry:
        r"""
        x.get_mesh_geometry_by_uid(mesh_geometry_uid) -> InterchangeMeshGeometry
        Get the geometry mesh from the unique ID.
        
        Args:
            mesh_geometry_uid (str): 
        
        Returns:
            InterchangeMeshGeometry:
        """
        ...
    def get_all_static_mesh_instance(self) -> Array[str]:
        r"""
        x.get_all_static_mesh_instance() -> Array[str]
        Get the unique IDs of all static mesh instances.
        
        Returns:
            Array[str]: 
        
            mesh_instance_uids (Array[str]):
        """
        ...
    def get_all_static_mesh_geometry(self) -> Array[str]:
        r"""
        x.get_all_static_mesh_geometry() -> Array[str]
        Get the unique IDs of all static mesh geometry.
        
        Returns:
            Array[str]: 
        
            mesh_geometry_uids (Array[str]):
        """
        ...
    def get_all_skinned_mesh_instance(self) -> Array[str]:
        r"""
        x.get_all_skinned_mesh_instance() -> Array[str]
        Get the unique IDs of all skinned mesh instances.
        
        Returns:
            Array[str]: 
        
            mesh_instance_uids (Array[str]):
        """
        ...
    def get_all_skinned_mesh_geometry(self) -> Array[str]:
        r"""
        x.get_all_skinned_mesh_geometry() -> Array[str]
        Get the unique IDs of all skinned mesh geometry.
        
        Returns:
            Array[str]: 
        
            mesh_geometry_uids (Array[str]):
        """
        ...
    def get_all_mesh_instance_uids_using_mesh_geometry_uid(self, mesh_geometry_uid: str) -> Array[str]:
        r"""
        x.get_all_mesh_instance_uids_using_mesh_geometry_uid(mesh_geometry_uid) -> Array[str]
        Get all instanced mesh UIDs that use the mesh geometry unique ID.
        
        Args:
            mesh_geometry_uid (str): 
        
        Returns:
            Array[str]: 
        
            mesh_instance_uids (Array[str]):
        """
        ...
    def get_all_mesh_instance_uids(self) -> Array[str]:
        r"""
        x.get_all_mesh_instance_uids() -> Array[str]
        Get the unique IDs of all mesh instances.
        
        Returns:
            Array[str]: 
        
            mesh_instance_uids (Array[str]):
        """
        ...
    def get_all_mesh_geometry_not_instanced(self) -> Array[str]:
        r"""
        x.get_all_mesh_geometry_not_instanced() -> Array[str]
        Get the unique IDs of all non-instanced mesh geometry.
        
        Returns:
            Array[str]: 
        
            mesh_geometry_uids (Array[str]):
        """
        ...
    def get_all_mesh_geometry(self) -> Array[str]:
        r"""
        x.get_all_mesh_geometry() -> Array[str]
        Get the unique IDs of all mesh geometry.
        
        Returns:
            Array[str]: 
        
            mesh_geometry_uids (Array[str]):
        """
        ...
    @classmethod
    def create_interchange_pipeline_meshes_utilities(cls, base_node_container: InterchangeBaseNodeContainer) -> InterchangePipelineMeshesUtilities:
        r"""
        X.create_interchange_pipeline_meshes_utilities(base_node_container) -> InterchangePipelineMeshesUtilities
        Create an instance of UInterchangePipelineMeshesUtilities.
        
        Args:
            base_node_container (InterchangeBaseNodeContainer): 
        
        Returns:
            InterchangePipelineMeshesUtilities:
        """
        ...

class ActorSequence(MovieSceneSequence):
    r"""
    Movie scene animation embedded within an actor.
    
    **C++ Source:**
    
    - **Plugin**: ActorSequence
    - **Module**: ActorSequence
    - **File**: ActorSequence.h
    
    """
    ...

class ActorSequenceComponent(ActorComponent):
    r"""
    Movie scene animation embedded within an actor.
    
    **C++ Source:**
    
    - **Plugin**: ActorSequence
    - **Module**: ActorSequence
    - **File**: ActorSequenceComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``playback_settings`` (MovieSceneSequencePlaybackSettings):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``sequence`` (ActorSequence):  [Read-Write] Embedded actor sequence data
    - ``sequence_player`` (ActorSequencePlayer):  [Read-Write]
    """
    @property
    def sequence_player(self) -> ActorSequencePlayer:
        r"""
        (ActorSequencePlayer):  [Read-Only]
        """
        ...
    def stop_sequence(self) -> None:
        r"""
        x.stop_sequence() -> None
        Calls the Stop function on the SequencePlayer if its valid.
        """
        ...
    def play_sequence(self) -> None:
        r"""
        x.play_sequence() -> None
        Calls the Play function on the SequencePlayer if its valid.
        """
        ...
    def pause_sequence(self) -> None:
        r"""
        x.pause_sequence() -> None
        Calls the Pause function on the SequencePlayer if its valid.
        """
        ...

class ActorSequencePlayer(MovieSceneSequencePlayer):
    r"""
    UActorSequencePlayer is used to actually "play" an actor sequence asset at runtime.
    
    **C++ Source:**
    
    - **Plugin**: ActorSequence
    - **Module**: ActorSequence
    - **File**: ActorSequencePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_finished`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player finishes naturally (without explicitly calling stop)
    - ``on_pause`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is paused
    - ``on_play`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is played
    - ``on_play_reverse`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is played in reverse
    - ``on_stop`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is stopped
    """
    ...

class ImgMediaPlaybackComponent(ActorComponent):
    r"""
    Component to help with ImgMedia playback.
    If desired, add this to an object that displays an ImgMedia sequence.
    Not necessary to do this, but if you do then you can get additional functionality
    such as selective mipmap loading.
    
    **C++ Source:**
    
    - **Plugin**: ImgMedia
    - **Module**: ImgMediaEngine
    - **File**: ImgMediaPlaybackComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``lod_bias`` (float):  [Read-Write] This will be added to the calculated mipmap level. E.g. if set to 2, and you would normally be at mipmap level 1, then you will actually be at level 3.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class AnimSequencerController(Object):
    r"""
    Anim Sequencer Controller
    
    **C++ Source:**
    
    - **Plugin**: AnimationData
    - **Module**: AnimationData
    - **File**: AnimSequencerController.h
    
    """
    def update_curve_names_from_skeleton(self, skeleton: Skeleton, supported_curve_type: RawCurveTrackTypes, should_transact: bool = True) -> None:
        r"""
        x.update_curve_names_from_skeleton(skeleton, supported_curve_type, should_transact=True) -> None
        Update Curve Names from Skeleton
        deprecated: This function is no longer used.
        
        Args:
            skeleton (Skeleton): 
            supported_curve_type (RawCurveTrackTypes): 
            should_transact (bool):
        """
        ...
    def set_transform_curve_keys(self, curve_id: AnimationCurveIdentifier, transform_values: Array[Transform], time_keys: Array[float], should_transact: bool = True) -> bool:
        r"""
        x.set_transform_curve_keys(curve_id, transform_values, time_keys, should_transact=True) -> bool
        Replace the keys for the transform curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the transform curve for which the keys are to be set
            transform_values (Array[Transform]): Transform Values with which the existing values are to be replaced
            time_keys (Array[float]): Time Keys with which the existing keys are to be replaced
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the transform curve keys were successfully set
        """
        ...
    def set_transform_curve_key(self, curve_id: AnimationCurveIdentifier, time: float, value: Transform, should_transact: bool = True) -> bool:
        r"""
        x.set_transform_curve_key(curve_id, time, value, should_transact=True) -> bool
        Sets a single key for the transform curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        In case a key for any of the individual transform channel curves already exists the value is replaced.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the transform curve for which the key is to be set
            time (float): Time of the key to be set
            value (Transform): Value of the key to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the transform curve key was successfully set
        """
        ...
    def set_play_length(self, length: float, should_transact: bool = True) -> None:
        r"""
        x.set_play_length(length, should_transact=True) -> None
        Set Play Length
        deprecated: SetPlayLength is deprecated use SetNumberOfFrames instead.
        
        Args:
            length (float): 
            should_transact (bool):
        """
        ...
    def set_number_of_frames(self, new_length_in_frames: FrameNumber, should_transact: bool = True) -> None:
        r"""
        x.set_number_of_frames(new_length_in_frames, should_transact=True) -> None
        Sets the total play-able length in seconds. Broadcasts a EAnimDataModelNotifyType::SequenceLengthChanged notify if successful.
        The number of frames and keys for the provided length is recalculated according to the current value of UAnimDataModel::FrameRate.
        
        Args:
            new_length_in_frames (FrameNumber): Total new play-able number of frames value (according to frame rate), has to be positive and non-zero
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def set_model(self, model: AnimationDataModel) -> None:
        r"""
        x.set_model(model) -> None
        Sets the AnimDataModel instance this controller is supposed to be targeting
        
        Args:
            model (AnimationDataModel): IAnimationDataModel instance to target
        """
        ...
    def set_frame_rate(self, frame_rate: FrameRate, should_transact: bool = True) -> None:
        r"""
        x.set_frame_rate(frame_rate, should_transact=True) -> None
        Sets the frame rate according to which the bone animation is expected to be sampled. Broadcasts a EAnimDataModelNotifyType::FrameRateChanged notify if successful.
        The number of frames and keys for the provided frame rate is recalculated according to the current value of UAnimDataModel::PlayLength.
        
        Args:
            frame_rate (FrameRate): The new sampling frame rate, has to be positive and non-zero
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def set_curve_keys(self, curve_id: AnimationCurveIdentifier, curve_keys: Array[RichCurveKey], should_transact: bool = True) -> bool:
        r"""
        x.set_curve_keys(curve_id, curve_keys, should_transact=True) -> bool
        Replace the keys for the curve with provided identifier and name. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the keys are to be replaced
            curve_keys (Array[RichCurveKey]): Keys with which the existing keys are to be replaced
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not replacing curve keys was successful
        """
        ...
    def set_curve_key(self, curve_id: AnimationCurveIdentifier, key: RichCurveKey, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_key(curve_id, key, should_transact=True) -> bool
        Sets a single key for the curve with provided identifier and name. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        In case a key for the provided key time already exists the key is replaced.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the key is to be set
            key (RichCurveKey): Key to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve key was successfully set
        """
        ...
    def set_curve_flags(self, curve_id: AnimationCurveIdentifier, flags: int, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_flags(curve_id, flags, should_transact=True) -> bool
        Replace the flags for the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveFlagsChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the flag state is to be set
            flags (int32): Flag mask with which the existing flags are to be replaced
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the flag mask was successfully set
        """
        ...
    def set_curve_flag(self, curve_id: AnimationCurveIdentifier, flag: AnimAssetCurveFlags, state: bool = True, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_flag(curve_id, flag, state=True, should_transact=True) -> bool
        Set an individual flag for the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveFlagsChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the flag state is to be set
            flag (AnimAssetCurveFlags): Flag for which the state is supposed to be set
            state (bool): State of the flag to be, true=set/false=not set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the flag state was successfully set
        """
        ...
    def set_curve_comment(self, curve_id: AnimationCurveIdentifier, comment: str = "/**\n\t* Changes the comment of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveCommentChanged notify if successful.\n\t* Currently changing curve comments is only supported for float curves.\n\t*\n\t* @param\tCurveId\t\t\t\tIdentifier of the curve to change the comment for\n\t* @param\tComment\t\t\t\tComment to which the curve is to be set\n\t* @param\tbShouldTransact\t\tWhether or not any undo-redo changes should be generated\n\t*\n\t* @return\tWhether or not the curve comment was successfully changed\n\t*/", should_transact: bool = True) -> bool:
        r"""
        x.set_curve_comment(curve_id, comment="/**\n\t* Changes the comment of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveCommentChanged notify if successful.\n\t* Currently changing curve comments is only supported for float curves.\n\t*\n\t* @param\tCurveId\t\t\t\tIdentifier of the curve to change the comment for\n\t* @param\tComment\t\t\t\tComment to which the curve is to be set\n\t* @param\tbShouldTransact\t\tWhether or not any undo-redo changes should be generated\n\t*\n\t* @return\tWhether or not the curve comment was successfully changed\n\t*/", should_transact=True) -> bool
        Changes the comment of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveCommentChanged notify if successful.
        Currently changing curve comments is only supported for float curves.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier of the curve to change the comment for
            comment (str): Comment to which the curve is to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve comment was successfully changed
        """
        ...
    def set_curve_color(self, curve_id: AnimationCurveIdentifier, color: LinearColor, should_transact: bool = True) -> bool:
        r"""
        x.set_curve_color(curve_id, color, should_transact=True) -> bool
        Changes the color of the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveColorChanged notify if successful.
        Currently changing curve colors is only supported for float curves.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier of the curve to change the color for
            color (LinearColor): Color to which the curve is to be set
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve color was successfully changed
        """
        ...
    def set_bone_track_keys(self, bone_name: Name, positional_keys: Array[Vector], rotational_keys: Array[Quat], scaling_keys: Array[Vector], should_transact: bool = True) -> bool:
        r"""
        x.set_bone_track_keys(bone_name, positional_keys, rotational_keys, scaling_keys, should_transact=True) -> bool
        Removes an existing bone animation track with the provided name. Broadcasts a EAnimDataModelNotifyType::TrackChanged notify if successful.
        The provided number of keys provided is expected to match for each component, and be non-zero.
        
        Args:
            bone_name (Name): Bone name of the track for which the keys should be set
            positional_keys (Array[Vector]): Array of keys for the translation component
            rotational_keys (Array[Quat]): Array of keys for the rotation component
            scaling_keys (Array[Vector]): Array of keys for the scale component
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the keys were successfully set
        """
        ...
    def scale_curve(self, curve_id: AnimationCurveIdentifier, origin: float, factor: float, should_transact: bool = True) -> bool:
        r"""
        x.scale_curve(curve_id, origin, factor, should_transact=True) -> bool
        Scales the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveScaled notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier of the curve to scale
            origin (float): Time to use as the origin when scaling the curve
            factor (float): Factor with which the curve is supposed to be scaled
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not scaling the curve was successful
        """
        ...
    def resize_play_length(self, new_length: float, t0: float, t1: float, should_transact: bool = True) -> None:
        r"""
        x.resize_play_length(new_length, t0, t1, should_transact=True) -> None
        Resize Play Length
        deprecated: ResizePlayLength is deprecated use ResizeNumberOfFrames instead.
        
        Args:
            new_length (float): 
            t0 (float): 
            t1 (float): 
            should_transact (bool):
        """
        ...
    def resize_number_of_frames(self, new_length_in_frames: FrameNumber, t0: FrameNumber, t1: FrameNumber, should_transact: bool = True) -> None:
        r"""
        x.resize_number_of_frames(new_length_in_frames, t0, t1, should_transact=True) -> None
        Sets the total play-able length in seconds. Broadcasts a EAnimDataModelNotifyType::SequenceLengthChanged notify if successful.
        T0 and T1 are expected to represent the window of time that was either added or removed. E.g. for insertion T0 indicates the time
        at which additional time starts and T1 were it ends. For removal T0 indicates the time at which time should be started to remove, and T1 indicates the end. Giving a total of T1 - T0 added or removed length.
        The number of frames and keys for the provided length is recalculated according to the current value of UAnimDataModel::FrameRate.
        
        Args:
            new_length_in_frames (FrameNumber): Total new play-able number of frames value (according to frame rate), has to be positive and non-zero
            t0 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length starts
            t1 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length ends
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def resize_in_frames(self, new_length_in_frames: FrameNumber, t0: FrameNumber, t1: FrameNumber, should_transact: bool = True) -> None:
        r"""
        x.resize_in_frames(new_length_in_frames, t0, t1, should_transact=True) -> None
        Sets the total play-able length in seconds and resizes curves. Broadcasts EAnimDataModelNotifyType::SequenceLengthChanged
        and EAnimDataModelNotifyType::CurveChanged notifies if successful.
        T0 and T1 are expected to represent the window of time that was either added or removed. E.g. for insertion T0 indicates the time
        at which additional time starts and T1 were it ends. For removal T0 indicates the time at which time should be started to remove, and T1 indicates the end. Giving a total of T1 - T0 added or removed length.
        The number of frames and keys for the provided length is recalculated according to the current value of UAnimDataModel::FrameRate.
        
        Args:
            new_length_in_frames (FrameNumber): Total new play-able number of frames value (according to frame rate), has to be positive and non-zero
            t0 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length starts
            t1 (FrameNumber): Point between 0 and NewLengthInFrames at which the change in length ends
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def resize(self, length: float, t0: float, t1: float, should_transact: bool = True) -> None:
        r"""
        x.resize(length, t0, t1, should_transact=True) -> None
        Resize
        deprecated: Resize is deprecated use ResizeInFrames instead.
        
        Args:
            length (float): 
            t0 (float): 
            t1 (float): 
            should_transact (bool):
        """
        ...
    def rename_curve(self, curve_to_rename_id: AnimationCurveIdentifier, new_curve_id: AnimationCurveIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.rename_curve(curve_to_rename_id, new_curve_id, should_transact=True) -> bool
        Renames the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveRenamed notify if successful.
        
        Args:
            curve_to_rename_id (AnimationCurveIdentifier): Identifier for the curve to be renamed
            new_curve_id (AnimationCurveIdentifier): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully renamed
        """
        ...
    def remove_transform_curve_key(self, curve_id: AnimationCurveIdentifier, time: float, should_transact: bool = True) -> bool:
        r"""
        x.remove_transform_curve_key(curve_id, time, should_transact=True) -> bool
        Removes a single key for the transform curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the transform curve for which the key is to be removed
            time (float): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the transform curve key was successfully removed
        """
        ...
    def remove_curve_key(self, curve_id: AnimationCurveIdentifier, time: float, should_transact: bool = True) -> bool:
        r"""
        x.remove_curve_key(curve_id, time, should_transact=True) -> bool
        Remove a single key from the curve with provided identifier and name. Broadcasts a EAnimDataModelNotifyType::CurveChanged notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the curve for which the key is to be removed
            time (float): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve key was successfully removed
        """
        ...
    def remove_curve(self, curve_id: AnimationCurveIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.remove_curve(curve_id, should_transact=True) -> bool
        Remove the curve with provided identifier. Broadcasts a EAnimDataModelNotifyType::CurveRemoved notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the to-be-removed curve
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully removed
        """
        ...
    def remove_bone_track(self, bone_name: Name, should_transact: bool = True) -> bool:
        r"""
        x.remove_bone_track(bone_name, should_transact=True) -> bool
        Removes an existing bone animation track with the provided name. Broadcasts a EAnimDataModelNotifyType::TrackRemoved notify if successful.
        
        Args:
            bone_name (Name): Bone name of the track which should be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the removal was successful
        """
        ...
    def remove_attribute_key(self, attribute_identifier: AnimationAttributeIdentifier, time: float, should_transact: bool = True) -> bool:
        r"""
        x.remove_attribute_key(attribute_identifier, time, should_transact=True) -> bool
        Remove a single key from the attribute with provided identifier. Broadcasts a EAnimDataModelNotifyType::AttributeChanged notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the attribute from which the key is to be removed
            time (float): Time of the key to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute key was successfully removed
        """
        ...
    def remove_attribute(self, attribute_identifier: AnimationAttributeIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.remove_attribute(attribute_identifier, should_transact=True) -> bool
        Removes an attribute, if found, with the provided information. Broadcasts a EAnimDataModelNotifyType::AttributeRemoved notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-removed attribute
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute was successfully removed
        """
        ...
    def remove_all_curves_of_type(self, supported_curve_type: RawCurveTrackTypes, should_transact: bool = True) -> None:
        r"""
        x.remove_all_curves_of_type(supported_curve_type, should_transact=True) -> None
        Removes all the curves of the provided type. Broadcasts a EAnimDataModelNotifyType::CurveRemoved for each removed curve, wrapped within BracketOpened/BracketClosed notifies.
        
        Args:
            supported_curve_type (RawCurveTrackTypes): Type for which all curves are to be removed
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def remove_all_bone_tracks(self, should_transact: bool = True) -> None:
        r"""
        x.remove_all_bone_tracks(should_transact=True) -> None
        Removes all existing Bone Animation tracks. Broadcasts a EAnimDataModelNotifyType::TrackRemoved for each removed track, wrapped within BracketOpened/BracketClosed notifies.
        
        Args:
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def remove_all_attributes_for_bone(self, bone_name: Name, should_transact: bool = True) -> int:
        r"""
        x.remove_all_attributes_for_bone(bone_name, should_transact=True) -> int32
        Removes all attributes for the specified bone name, if any. Broadcasts a EAnimDataModelNotifyType::AttributeRemoved notify for each removed attribute.
        
        Args:
            bone_name (Name): Name of the bone to remove attributes for
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            int32: Total number of removes attributes
        """
        ...
    def remove_all_attributes(self, should_transact: bool = True) -> int:
        r"""
        x.remove_all_attributes(should_transact=True) -> int32
        Removes all stored attributes. Broadcasts a EAnimDataModelNotifyType::AttributeRemoved notify for each removed attribute.
        
        Args:
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            int32: Total number of removes attributes
        """
        ...
    def open_bracket(self, title: Text, should_transact: bool = True) -> None:
        r"""
        x.open_bracket(title, should_transact=True) -> None
        Opens an interaction bracket, used for combining a set of controller actions. Broadcasts a EAnimDataModelNotifyType::BracketOpened notify,
        this can be used by any Views or dependent systems to halt any unnecessary or invalid operations until the (last) bracket is closed.
        
        Args:
            title (Text): Description of the bracket, e.g. "Generating Curve Data"
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def insert_bone_track(self, bone_name: Name, desired_index: int, should_transact: bool = True) -> int:
        r"""
        x.insert_bone_track(bone_name, desired_index, should_transact=True) -> int32
        Insert Bone Track
        deprecated: InsertBoneTrack is deprecated use AddBoneTrack instead.
        
        Args:
            bone_name (Name): 
            desired_index (int32): 
            should_transact (bool): 
        
        Returns:
            int32:
        """
        ...
    def get_model_interface(self) -> AnimationDataModel:
        r"""
        x.get_model_interface() -> AnimationDataModel
        
        
        Returns:
            AnimationDataModel: The IAnimationDataModel instance this controller is currently targeting
        """
        ...
    def find_or_add_curve_names_on_skeleton(self, skeleton: Skeleton, supported_curve_type: RawCurveTrackTypes, should_transact: bool = True) -> None:
        r"""
        x.find_or_add_curve_names_on_skeleton(skeleton, supported_curve_type, should_transact=True) -> None
        Find or Add Curve Names on Skeleton
        deprecated: This function is no longer used.
        
        Args:
            skeleton (Skeleton): 
            supported_curve_type (RawCurveTrackTypes): 
            should_transact (bool):
        """
        ...
    def duplicate_curve(self, copy_curve_id: AnimationCurveIdentifier, new_curve_id: AnimationCurveIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.duplicate_curve(copy_curve_id, new_curve_id, should_transact=True) -> bool
        Duplicated the curve with the identifier. Broadcasts a EAnimDataModelNotifyType::CurveAdded notify if successful.
        
        Args:
            copy_curve_id (AnimationCurveIdentifier): Identifier for the to-be-duplicated curve
            new_curve_id (AnimationCurveIdentifier): Identifier for the to-be-added curve
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully duplicated
        """
        ...
    def duplicate_attribute(self, attribute_identifier: AnimationAttributeIdentifier, new_attribute_identifier: AnimationAttributeIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.duplicate_attribute(attribute_identifier, new_attribute_identifier, should_transact=True) -> bool
        Duplicated the attribute (curve) with the identifier. Broadcasts a EAnimDataModelNotifyType::AttributeAdded notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-duplicated attribute
            new_attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-added attribute
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute was successfully duplicated
        """
        ...
    def close_bracket(self, should_transact: bool = True) -> None:
        r"""
        x.close_bracket(should_transact=True) -> None
        Closes a previously opened interaction bracket, used for combining a set of controller actions. Broadcasts a EAnimDataModelNotifyType::BracketClosed notify.
        
        Args:
            should_transact (bool): Whether or not any undo-redo changes should be generated
        """
        ...
    def add_curve(self, curve_id: AnimationCurveIdentifier, curve_flags: int = 4, should_transact: bool = True) -> bool:
        r"""
        x.add_curve(curve_id, curve_flags=4, should_transact=True) -> bool
        Adds a new curve with the provided information. Broadcasts a EAnimDataModelNotifyType::CurveAdded notify if successful.
        
        Args:
            curve_id (AnimationCurveIdentifier): Identifier for the to-be-added curve
            curve_flags (int32): Flags to be set for the curve
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the curve was successfully added
        """
        ...
    def add_bone_track(self, bone_name: Name, should_transact: bool = True) -> int:
        r"""
        x.add_bone_track(bone_name, should_transact=True) -> int32
        Add Bone Track
        deprecated: AddBoneTrack returning index is deprecated use AddBoneCurve returning bool instead.
        
        Args:
            bone_name (Name): 
            should_transact (bool): 
        
        Returns:
            int32:
        """
        ...
    def add_bone_curve(self, bone_name: Name, should_transact: bool = True) -> bool:
        r"""
        x.add_bone_curve(bone_name, should_transact=True) -> bool
        Add Bone Curve
        
        Args:
            bone_name (Name): 
            should_transact (bool): 
        
        Returns:
            bool:
        """
        ...
    def add_attribute(self, attribute_identifier: AnimationAttributeIdentifier, should_transact: bool = True) -> bool:
        r"""
        x.add_attribute(attribute_identifier, should_transact=True) -> bool
        Adds a new attribute with the provided information. Broadcasts a EAnimDataModelNotifyType::AttributeAdded notify if successful.
        
        Args:
            attribute_identifier (AnimationAttributeIdentifier): Identifier for the to-be-added attribute
            should_transact (bool): Whether or not any undo-redo changes should be generated
        
        Returns:
            bool: Whether or not the attribute was successfully added
        """
        ...

class AnimationSequencerDataModel(MovieSceneSequence):
    r"""
    Animation Sequencer Data Model
    
    **C++ Source:**
    
    - **Plugin**: AnimationData
    - **Module**: AnimationData
    - **File**: AnimSequencerDataModel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``animated_bone_attributes`` (Array[AnimatedBoneAttribute]):  [Read-Only]
    - ``cached_raw_data_guid`` (Guid):  [Read-Only] Raw data GUID taken from UAnimSequence when initially populating - this allows for retaining compressed data state initially
    - ``curve_identifier_to_meta_data`` (Map[AnimationCurveIdentifier, AnimationCurveMetaData]):  [Read-Only] Per-curve information holding flags/color, due to be deprecated in the future
    - ``legacy_curve_data`` (AnimationCurveData):  [Read-Only]
    - ``modified_event`` (AnimDataModelModifiedDynamicEvent):  [Read-Write] Dynamic delegate event allows scripting to register to any broadcast-ed notify.
    - ``movie_scene`` (MovieScene):  [Read-Only] Movie scene instance containing FK Control rig and section representing the animation data
    - ``populated`` (bool):  [Read-Only]
    """
    @property
    def modified_event(self) -> AnimDataModelModifiedDynamicEvent:
        r"""
        (AnimDataModelModifiedDynamicEvent):  [Read-Write] Dynamic delegate event allows scripting to register to any broadcast-ed notify.
        """
        ...
    @modified_event.setter
    def modified_event(self, value: AnimDataModelModifiedDynamicEvent) -> None:
        ...
    def is_valid_bone_track_name(self, track_name: Name) -> bool:
        r"""
        x.is_valid_bone_track_name(track_name) -> bool
        Is Valid Bone Track Name
        
        Args:
            track_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def is_valid_bone_track_index(self, track_index: int) -> bool:
        r"""
        x.is_valid_bone_track_index(track_index) -> bool
        Is Valid Bone Track Index
        
        Args:
            track_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_play_length(self) -> float:
        r"""
        x.get_play_length() -> double
        
        
        Returns:
            double: Total length of play-able animation data
        """
        ...
    def get_num_bone_tracks(self) -> int:
        r"""
        x.get_num_bone_tracks() -> int32
        
        
        Returns:
            int32: Total number of bone animation tracks
        """
        ...
    def get_number_of_transform_curves(self) -> int:
        r"""
        x.get_number_of_transform_curves() -> int32
        
        
        Returns:
            int32: Total number of stored FTransform curves
        """
        ...
    def get_number_of_keys(self) -> int:
        r"""
        x.get_number_of_keys() -> int32
        
        
        Returns:
            int32: Total number of animation data keys stored
        """
        ...
    def get_number_of_frames(self) -> int:
        r"""
        x.get_number_of_frames() -> int32
        
        
        Returns:
            int32: Total number of frames of animation data stored
        """
        ...
    def get_number_of_float_curves(self) -> int:
        r"""
        x.get_number_of_float_curves() -> int32
        
        
        Returns:
            int32: Total number of stored float curves
        """
        ...
    def get_frame_rate(self) -> FrameRate:
        r"""
        x.get_frame_rate() -> FrameRate
        
        
        Returns:
            FrameRate: Frame rate at which the animation data is key-ed
        """
        ...
    def get_bone_track_names(self) -> Array[Name]:
        r"""
        x.get_bone_track_names() -> Array[Name]
        Populates the provided array with all contained (bone) track names
        
        Returns:
            Array[Name]: 
        
            out_names (Array[Name]): [out] Array containing all bone track names
        """
        ...
    def get_bone_track_index_by_name(self, track_name: Name) -> int:
        r"""
        x.get_bone_track_index_by_name(track_name) -> int32
        Get Bone Track Index by Name
        
        Args:
            track_name (Name): 
        
        Returns:
            int32:
        """
        ...
    def get_bone_track_index(self, track: BoneAnimationTrack) -> int:
        r"""
        x.get_bone_track_index(track) -> int32
        Get Bone Track Index
        
        Args:
            track (BoneAnimationTrack): 
        
        Returns:
            int32:
        """
        ...
    def get_bone_track_by_name(self, track_name: Name) -> BoneAnimationTrack:
        r"""
        x.get_bone_track_by_name(track_name) -> BoneAnimationTrack
        Get Bone Track by Name
        
        Args:
            track_name (Name): 
        
        Returns:
            BoneAnimationTrack:
        """
        ...
    def get_bone_track_by_index(self, track_index: int) -> BoneAnimationTrack:
        r"""
        x.get_bone_track_by_index(track_index) -> BoneAnimationTrack
        Get Bone Track by Index
        
        Args:
            track_index (int32): 
        
        Returns:
            BoneAnimationTrack:
        """
        ...
    def get_bone_animation_tracks(self) -> Array[BoneAnimationTrack]:
        r"""
        x.get_bone_animation_tracks() -> Array[BoneAnimationTrack]
        Get Bone Animation Tracks
        
        Returns:
            Array[BoneAnimationTrack]:
        """
        ...
    def get_animation_sequence(self) -> AnimSequence:
        r"""
        x.get_animation_sequence() -> AnimSequence
        
        
        Returns:
            AnimSequence: The outer UAnimSequence object if found, otherwise returns a nullptr
        """
        ...

class MovieScene(MovieSceneSignedObject):
    r"""
    Implements a movie scene asset.
    
    **C++ Source:**
    
    - **Module**: MovieScene
    - **File**: MovieScene.h
    
    """
    ...

class ControlRigSchema(RigVMSchema):
    r"""
    Control Rig Schema
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigDeveloper
    - **File**: ControlRigSchema.h
    
    """
    ...

class AnimGraphNode_ControlRig(AnimGraphNode_CustomProperty):
    r"""
    Anim Graph Node Control Rig
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigDeveloper
    - **File**: AnimGraphNode_ControlRig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_ControlRig):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class ControlRigBlueprint(RigVMBlueprint):
    r"""
    Control Rig Blueprint
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigDeveloper
    - **File**: ControlRigBlueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blueprint_category`` (str):  [Read-Write] The category of the Blueprint, used to organize this Blueprint class when displayed in palette windows
    - ``blueprint_description`` (str):  [Read-Write] Shows up in the content browser tooltip when the blueprint is hovered
    - ``blueprint_display_name`` (str):  [Read-Write] Overrides the BP's display name in the editor UI
    - ``blueprint_namespace`` (str):  [Read-Write] The namespace of this blueprint (if set, the Blueprint will be treated differently for the context menu)
    - ``compile_mode`` (BlueprintCompileMode):  [Read-Write] The mode that will be used when compiling this class.
    - ``deprecate`` (bool):  [Read-Write] Deprecates the Blueprint, marking the generated class with the CLASS_Deprecated flag
    - ``draw_container`` (RigVMDrawContainer):  [Read-Write]
    - ``generate_abstract_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a abstract class or not.  Should set CLASS_Abstract in the KismetCompiler.
    - ``generate_const_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a const class or not.  Should set CLASS_Const in the KismetCompiler.
    - ``hide_categories`` (Array[str]):  [Read-Write] Additional HideCategories. These are added to HideCategories from parent.
    - ``hierarchy`` (RigHierarchy):  [Read-Write]
    - ``hierarchy_settings`` (RigHierarchySettings):  [Read-Write]
    - ``influences`` (RigInfluenceMapPerEvent):  [Read-Write]
    - ``modular_rig_model`` (ModularRigModel):  [Read-Write]
    - ``modular_rig_settings`` (ModularRigSettings):  [Read-Write]
    - ``python_log_settings`` (RigVMPythonSettings):  [Read-Write]
    - ``rig_graph_display_settings`` (RigVMEdGraphDisplaySettings):  [Read-Write]
    - ``rig_module_settings`` (RigModuleSettings):  [Read-Write]
    - ``run_construction_script_in_sequencer`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor in sequencer
    - ``run_construction_script_on_drag`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor as you drag it in the editor, or only when the drag operation is complete
    - ``shape_libraries`` (Array[ControlRigShapeLibrary]):  [Read-Write]
    - ``should_cook_property_guids_value`` (ShouldCookBlueprintPropertyGuids):  [Read-Write] Whether to include the property GUIDs for the generated class in a cooked build.
      note: This option may slightly increase memory usage in a cooked build, but can avoid needing to add CoreRedirect data for Blueprint classes stored within SaveGame archives.
    - ``source_curve_import`` (Object):  [Read-Write] The skeleton from import into a curve
    - ``source_hierarchy_import`` (Object):  [Read-Write] The skeleton from import into a hierarchy
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``vm_compile_settings`` (RigVMCompileSettings):  [Read-Write]
    - ``vm_runtime_settings`` (RigVMRuntimeSettings):  [Read-Write]
    """
    @property
    def hierarchy(self) -> RigHierarchy:
        r"""
        (RigHierarchy):  [Read-Only]
        """
        ...
    @property
    def modular_rig_model(self) -> ModularRigModel:
        r"""
        (ModularRigModel):  [Read-Only]
        """
        ...
    def turn_into_standalone_rig(self) -> bool:
        r"""
        x.turn_into_standalone_rig() -> bool
        Turn Into Standalone Rig Blueprint
        
        Returns:
            bool:
        """
        ...
    def turn_into_control_rig_module(self) -> bool:
        r"""
        x.turn_into_control_rig_module() -> bool
        Turn Into Control Rig Module Blueprint
        
        Returns:
            bool:
        """
        ...
    def set_preview_mesh(self, preview_mesh: SkeletalMesh, mark_as_dirty: bool = True) -> None:
        r"""
        x.set_preview_mesh(preview_mesh, mark_as_dirty=True) -> None
        IInterface_PreviewMeshProvider interface
        
        Args:
            preview_mesh (SkeletalMesh): 
            mark_as_dirty (bool):
        """
        ...
    def recompile_modular_rig(self) -> None:
        r"""
        x.recompile_modular_rig() -> None
        Recompile Modular Rig
        """
        ...
    def is_control_rig_module(self) -> bool:
        r"""
        x.is_control_rig_module() -> bool
        Is Control Rig Module
        
        Returns:
            bool:
        """
        ...
    def get_rig_module_icon(self) -> Texture2D:
        r"""
        x.get_rig_module_icon() -> Texture2D
        Get Rig Module Icon
        
        Returns:
            Texture2D:
        """
        ...
    def get_preview_mesh(self) -> SkeletalMesh:
        r"""
        x.get_preview_mesh() -> SkeletalMesh
        Get Preview Mesh
        
        Returns:
            SkeletalMesh:
        """
        ...
    def get_modular_rig_controller(self) -> ModularRigController:
        r"""
        x.get_modular_rig_controller() -> ModularRigController
        Get Modular Rig Controller
        
        Returns:
            ModularRigController:
        """
        ...
    def get_hierarchy_controller(self) -> RigHierarchyController:
        r"""
        x.get_hierarchy_controller() -> RigHierarchyController
        Get Hierarchy Controller
        
        Returns:
            RigHierarchyController:
        """
        ...
    def get_debugged_control_rig(self) -> ControlRig:
        r"""
        x.get_debugged_control_rig() -> ControlRig
        Get Debugged Control Rig
        
        Returns:
            ControlRig:
        """
        ...
    @classmethod
    def get_currently_open_rig_blueprints(cls) -> Array[ControlRigBlueprint]:
        r"""
        X.get_currently_open_rig_blueprints() -> Array[ControlRigBlueprint]
        Get Currently Open Rig Blueprints
        
        Returns:
            Array[ControlRigBlueprint]:
        """
        ...
    def get_control_rig_class(self) -> Class:
        r"""
        x.get_control_rig_class() -> type(Class)
        Get Control Rig Class
        
        Returns:
            type(Class):
        """
        ...
    def create_control_rig(self) -> ControlRig:
        r"""
        x.create_control_rig() -> ControlRig
        Create Control Rig
        
        Returns:
            ControlRig:
        """
        ...
    def convert_hierarchy_elements_to_spawner_nodes(self, hierarchy: RigHierarchy, keys: Array[RigElementKey], remove_elements: bool = True) -> Array[RigVMNode]:
        r"""
        x.convert_hierarchy_elements_to_spawner_nodes(hierarchy, keys, remove_elements=True) -> Array[RigVMNode]
        Convert Hierarchy Elements to Spawner Nodes
        
        Args:
            hierarchy (RigHierarchy): 
            keys (Array[RigElementKey]): 
            remove_elements (bool): 
        
        Returns:
            Array[RigVMNode]:
        """
        ...
    def can_turn_into_standalone_rig(self) -> bool:
        r"""
        x.can_turn_into_standalone_rig() -> bool
        Can Turn Into Standalone Rig Blueprint
        
        Returns:
            bool:
        """
        ...

class LegacyCameraShake(CameraShakeBase):
    r"""
    Legacy camera shake which can do either oscillation or run camera anims.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: LegacyCameraShake.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``anim_blend_in_time`` (float):  [Read-Write] Linear blend-in time.
    - ``anim_blend_out_time`` (float):  [Read-Write] Linear blend-out time.
    - ``anim_play_rate`` (float):  [Read-Write] Scalar defining how fast to play the anim.
    - ``anim_scale`` (float):  [Read-Write] Scalar defining how "intense" to play the anim.
    - ``anim_sequence`` (CameraAnimationSequence):  [Read-Write] Source camera animation sequence to play. Can be null.
    - ``fov_oscillation`` (FOscillator):  [Read-Write] FOV oscillation
    - ``loc_oscillation`` (VOscillator):  [Read-Write] Positional oscillation
    - ``oscillation_blend_in_time`` (float):  [Read-Write] Duration of the blend-in, where the oscillation scales from 0 to 1.
    - ``oscillation_blend_out_time`` (float):  [Read-Write] Duration of the blend-out, where the oscillation scales from 1 to 0.
    - ``oscillation_duration`` (float):  [Read-Write] Duration in seconds of current screen shake. Less than 0 means indefinite, 0 means no oscillation.
    - ``oscillator_time_remaining`` (float):  [Read-Write] Time remaining for oscillation shakes. Less than 0.f means shake infinitely.
    - ``random_anim_segment`` (bool):  [Read-Write] If true, play a random snippet of the animation of length Duration.  Implies bLoop and bRandomStartTime = true for the AnimSequence.
      If false, play the full anim once, non-looped. Useful for getting variety out of a single looped AnimSequence asset.
    - ``random_anim_segment_duration`` (float):  [Read-Write] When bRandomAnimSegment is true, this defines how long the anim should play.
    - ``root_shake_pattern`` (CameraShakePattern):  [Read-Write] The root pattern for this camera shake
    - ``rot_oscillation`` (ROscillator):  [Read-Write] Rotational oscillation
    - ``shake_scale`` (float):  [Read-Write] The overall scale to apply to the shake. Only valid when the shake is active.
    - ``single_instance`` (bool):  [Read-Write] If true to only allow a single instance of this shake class to play at any given time.
      Subsequent attempts to play this shake will simply restart the timer.
    """
    @property
    def rot_oscillation(self) -> ROscillator:
        r"""
        (ROscillator):  [Read-Write] Rotational oscillation
        """
        ...
    @rot_oscillation.setter
    def rot_oscillation(self, value: ROscillator) -> None:
        ...
    @property
    def loc_oscillation(self) -> VOscillator:
        r"""
        (VOscillator):  [Read-Write] Positional oscillation
        """
        ...
    @loc_oscillation.setter
    def loc_oscillation(self, value: VOscillator) -> None:
        ...
    @property
    def fov_oscillation(self) -> FOscillator:
        r"""
        (FOscillator):  [Read-Write] FOV oscillation
        """
        ...
    @fov_oscillation.setter
    def fov_oscillation(self, value: FOscillator) -> None:
        ...
    @property
    def oscillator_time_remaining(self) -> float:
        r"""
        (float):  [Read-Only] Time remaining for oscillation shakes. Less than 0.f means shake infinitely.
        """
        ...
    @classmethod
    def start_legacy_camera_shake_from_source(cls, player_camera_manager: PlayerCameraManager, shake_class: Class, source_component: CameraShakeSourceComponent, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> LegacyCameraShake:
        r"""
        X.start_legacy_camera_shake_from_source(player_camera_manager, shake_class, source_component, scale=1.000000, play_space=CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot=[0.000000, 0.000000, 0.000000]) -> LegacyCameraShake
        Backwards compatible method used by core BP redirectors. This is needed because the return value is specifically a legacy camera shake,
        which some BP logic often uses directly to set oscillator/anim properties.
        
        Args:
            player_camera_manager (PlayerCameraManager): 
            shake_class (type(Class)): 
            source_component (CameraShakeSourceComponent): 
            scale (float): 
            play_space (CameraShakePlaySpace): 
            user_play_space_rot (Rotator): 
        
        Returns:
            LegacyCameraShake:
        """
        ...
    @classmethod
    def start_matinee_camera_shake_from_source(cls, player_camera_manager: PlayerCameraManager, shake_class: Class, source_component: CameraShakeSourceComponent, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> LegacyCameraShake:
        r"""
        deprecated: 'start_matinee_camera_shake_from_source' was renamed to 'start_legacy_camera_shake_from_source'.
        """
        ...
    @classmethod
    def start_legacy_camera_shake(cls, player_camera_manager: PlayerCameraManager, shake_class: Class, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> LegacyCameraShake:
        r"""
        X.start_legacy_camera_shake(player_camera_manager, shake_class, scale=1.000000, play_space=CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot=[0.000000, 0.000000, 0.000000]) -> LegacyCameraShake
        Backwards compatible method used by core BP redirectors. This is needed because the return value is specifically a legacy camera shake,
        which some BP logic often uses directly to set oscillator/anim properties.
        
        Args:
            player_camera_manager (PlayerCameraManager): 
            shake_class (type(Class)): 
            scale (float): 
            play_space (CameraShakePlaySpace): 
            user_play_space_rot (Rotator): 
        
        Returns:
            LegacyCameraShake:
        """
        ...
    @classmethod
    def start_matinee_camera_shake(cls, player_camera_manager: PlayerCameraManager, shake_class: Class, scale: float = 1.000000, play_space: CameraShakePlaySpace = CameraShakePlaySpace.CAMERA_LOCAL, user_play_space_rot: Rotator = [0.000000, 0.000000, 0.000000]) -> LegacyCameraShake:
        r"""
        deprecated: 'start_matinee_camera_shake' was renamed to 'start_legacy_camera_shake'.
        """
        ...
    def receive_stop_shake(self, immediately: bool) -> None:
        r"""
        x.receive_stop_shake(immediately) -> None
        Called when the shake is explicitly stopped.
        
        Args:
            immediately (bool):
        """
        ...
    def receive_play_shake(self, scale: float) -> None:
        r"""
        x.receive_play_shake(scale) -> None
        Called when the shake starts playing
        
        Args:
            scale (float):
        """
        ...
    def receive_is_finished(self) -> bool:
        r"""
        x.receive_is_finished() -> bool
        Called to allow a shake to decide when it's finished playing.
        
        Returns:
            bool:
        """
        ...
    def blueprint_update_camera_shake(self, delta_time: float, alpha: float, pov: MinimalViewInfo) -> MinimalViewInfo:
        r"""
        x.blueprint_update_camera_shake(delta_time, alpha, pov) -> MinimalViewInfo
        Called every tick to let the shake modify the point of view
        
        Args:
            delta_time (float): 
            alpha (float): 
            pov (MinimalViewInfo): 
        
        Returns:
            MinimalViewInfo: 
        
            modified_pov (MinimalViewInfo):
        """
        ...

class CameraShake(LegacyCameraShake):
    r"""
    deprecated: 'CameraShake' was renamed to 'LegacyCameraShake'.
    """
    ...

class MatineeCameraShake(LegacyCameraShake):
    r"""
    deprecated: 'MatineeCameraShake' was renamed to 'LegacyCameraShake'.
    """
    ...

class LegacyCameraShakeFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    Blueprint function library for autocasting from a base camera shake to a legacy camera shake.
    This prevents breaking Blueprints now that APlayerCameraManager::StartCameraShake returns the base class.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: LegacyCameraShake.h
    
    """
    @classmethod
    def conv_legacy_camera_shake(cls, camera_shake: CameraShakeBase) -> LegacyCameraShake:
        r"""
        X.conv_legacy_camera_shake(camera_shake) -> LegacyCameraShake
        Conv Legacy Camera Shake
        
        Args:
            camera_shake (CameraShakeBase): 
        
        Returns:
            LegacyCameraShake:
        """
        ...
    @classmethod
    def conv_matinee_camera_shake(cls, camera_shake: CameraShakeBase) -> LegacyCameraShake:
        r"""
        deprecated: 'conv_matinee_camera_shake' was renamed to 'conv_legacy_camera_shake'.
        """
        ...

class MatineeCameraShakeFunctionLibrary(LegacyCameraShakeFunctionLibrary):
    r"""
    deprecated: 'MatineeCameraShakeFunctionLibrary' was renamed to 'LegacyCameraShakeFunctionLibrary'.
    """
    ...

class CameraAnimationCameraModifier(CameraModifier):
    r"""
    A camera modifier that plays camera animation sequences.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraAnimationCameraModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Current blend alpha.
    - ``alpha_in_time`` (float):  [Read-Write] When blending in, alpha proceeds from 0 to 1 over this time
    - ``alpha_out_time`` (float):  [Read-Write] When blending out, alpha proceeds from 1 to 0 over this time
    - ``camera_owner`` (PlayerCameraManager):  [Read-Write] Camera this object is associated with.
    - ``debug`` (bool):  [Read-Write] If true, enables certain debug visualization features.
    - ``exclusive`` (bool):  [Read-Write] If true, no other modifiers of same priority allowed.
    - ``priority`` (uint8):  [Read-Write] Priority value that determines the order in which modifiers are applied. 0 = highest priority, 255 = lowest.
    """
    def stop_camera_animation(self, handle: CameraAnimationHandle, immediate: bool = False) -> None:
        r"""
        x.stop_camera_animation(handle, immediate=False) -> None
        Stops the given camera animation instance.
        
        Args:
            handle (CameraAnimationHandle): 
            immediate (bool): True to stop it right now and ignore blend out, false to let it blend out as indicated.
        """
        ...
    def stop_all_camera_animations_of(self, sequence: CameraAnimationSequence, immediate: bool = False) -> None:
        r"""
        x.stop_all_camera_animations_of(sequence, immediate=False) -> None
        Stop playing all instances of the given camera animation sequence.
        
        Args:
            sequence (CameraAnimationSequence): The sequence of which to stop all instances.
            immediate (bool): True to stop it right now and ignore blend out, false to let it blend out as indicated.
        """
        ...
    def stop_all_camera_animations(self, immediate: bool = False) -> None:
        r"""
        x.stop_all_camera_animations(immediate=False) -> None
        Stop all camera animation instances.
        
        Args:
            immediate (bool): True to stop it right now and ignore blend out, false to let it blend out as indicated.
        """
        ...
    def play_camera_animation(self, sequence: CameraAnimationSequence, params: CameraAnimationParams) -> CameraAnimationHandle:
        r"""
        x.play_camera_animation(sequence, params) -> CameraAnimationHandle
        Play a new camera animation sequence.
        
        Args:
            sequence (CameraAnimationSequence): The sequence to use for the new camera animation.
            params (CameraAnimationParams): The parameters for the new camera animation instance.
        
        Returns:
            CameraAnimationHandle:
        """
        ...
    def is_camera_animation_active(self, handle: CameraAnimationHandle) -> bool:
        r"""
        x.is_camera_animation_active(handle) -> bool
        Returns whether the given camera animation is playing.
        
        Args:
            handle (CameraAnimationHandle): A handle to a previously started camera animation.
        
        Returns:
            bool: Whether the corresponding camera animation is playing or not.
        """
        ...
    @classmethod
    def get_camera_animation_camera_modifier_from_player_controller(cls, player_controller: PlayerController) -> CameraAnimationCameraModifier:
        r"""
        X.get_camera_animation_camera_modifier_from_player_controller(player_controller) -> CameraAnimationCameraModifier
        Get Camera Animation Camera Modifier from Player Controller
        
        Args:
            player_controller (PlayerController): 
        
        Returns:
            CameraAnimationCameraModifier:
        """
        ...
    @classmethod
    def get_camera_animation_camera_modifier_from_id(cls, world_context_object: Object, controller_id: int) -> CameraAnimationCameraModifier:
        r"""
        X.get_camera_animation_camera_modifier_from_id(world_context_object, controller_id) -> CameraAnimationCameraModifier
        Get Camera Animation Camera Modifier from ID
        
        Args:
            world_context_object (Object): 
            controller_id (int32): 
        
        Returns:
            CameraAnimationCameraModifier:
        """
        ...
    @classmethod
    def get_camera_animation_camera_modifier(cls, world_context_object: Object, player_index: int) -> CameraAnimationCameraModifier:
        r"""
        X.get_camera_animation_camera_modifier(world_context_object, player_index) -> CameraAnimationCameraModifier
        Get Camera Animation Camera Modifier
        
        Args:
            world_context_object (Object): 
            player_index (int32): 
        
        Returns:
            CameraAnimationCameraModifier:
        """
        ...

class GameplayCamerasFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    Blueprint function library for autocasting a player camera manager into the camera animation camera modifier.
    This prevents breaking Blueprints now that APlayerCameraManager::StartCameraShake returns the base class.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraAnimationCameraModifier.h
    
    """
    @classmethod
    def conv_camera_shake_play_space(cls, camera_animation_play_space: CameraAnimationPlaySpace) -> CameraShakePlaySpace:
        r"""
        X.conv_camera_shake_play_space(camera_animation_play_space) -> CameraShakePlaySpace
        Conv Camera Shake Play Space
        
        Args:
            camera_animation_play_space (CameraAnimationPlaySpace): 
        
        Returns:
            CameraShakePlaySpace:
        """
        ...
    @classmethod
    def conv_camera_animation_play_space(cls, camera_shake_play_space: CameraShakePlaySpace) -> CameraAnimationPlaySpace:
        r"""
        X.conv_camera_animation_play_space(camera_shake_play_space) -> CameraAnimationPlaySpace
        Conv Camera Animation Play Space
        
        Args:
            camera_shake_play_space (CameraShakePlaySpace): 
        
        Returns:
            CameraAnimationPlaySpace:
        """
        ...
    @classmethod
    def conv_camera_animation_camera_modifier(cls, player_camera_manager: PlayerCameraManager) -> CameraAnimationCameraModifier:
        r"""
        X.conv_camera_animation_camera_modifier(player_camera_manager) -> CameraAnimationCameraModifier
        Conv Camera Animation Camera Modifier
        
        Args:
            player_camera_manager (PlayerCameraManager): 
        
        Returns:
            CameraAnimationCameraModifier:
        """
        ...

class GameplayCameraActor(Actor):
    r"""
    An actor that can run a camera asset.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: GameplayCameraActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``camera_component`` (GameplayCameraComponent):  [Read-Only]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``scene_component`` (SceneComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def scene_component(self) -> SceneComponent:
        r"""
        (SceneComponent):  [Read-Only]
        """
        ...
    @property
    def camera_component(self) -> GameplayCameraComponent:
        r"""
        (GameplayCameraComponent):  [Read-Only]
        """
        ...

class GameplayCameraComponent(SceneComponent):
    r"""
    A component that can run a camera asset inside its own camera evaluation context.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: GameplayCameraComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``camera`` (CameraAsset):  [Read-Write]
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def camera(self) -> CameraAsset:
        r"""
        (CameraAsset):  [Read-Write]
        """
        ...
    @camera.setter
    def camera(self, value: CameraAsset) -> None:
        ...
    def activate_camera(self, player_index: int = 0) -> None:
        r"""
        x.activate_camera(player_index=0) -> None
        Activate Camera
        
        Args:
            player_index (int32):
        """
        ...

class GameplayCameraSystemActor(Actor):
    r"""
    An actor that hosts a camera system.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: GameplayCameraSystemActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_activate_for_player`` (AutoReceiveInput):  [Read-Write]
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``camera_system_component`` (GameplayCameraSystemComponent):  [Read-Only]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def camera_system_component(self) -> GameplayCameraSystemComponent:
        r"""
        (GameplayCameraSystemComponent):  [Read-Only]
        """
        ...
    def activate_for_player(self, player_index: int) -> None:
        r"""
        x.activate_for_player(player_index) -> None
        Activate for Player
        
        Args:
            player_index (int32):
        """
        ...

class GameplayCameraSystemComponent(SceneComponent):
    r"""
    A component that hosts a camera system.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: GameplayCameraSystemComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    ...

class GameplayCamerasSubsystem(WorldSubsystem):
    r"""
    World subsystem that holds global objects for handling camera animation sequences.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: GameplayCamerasSubsystem.h
    
    """
    def stop_camera_animation(self, player_controller: PlayerController, handle: CameraAnimationHandle, immediate: bool = False) -> None:
        r"""
        x.stop_camera_animation(player_controller, handle, immediate=False) -> None
        Stops the given camera animation instance.
        
        Args:
            player_controller (PlayerController): The player controller on which to play the animation.
            handle (CameraAnimationHandle): 
            immediate (bool): True to stop it right now and ignore blend out, false to let it blend out as indicated.
        """
        ...
    def stop_all_camera_animations_of(self, player_controller: PlayerController, sequence: CameraAnimationSequence, immediate: bool = False) -> None:
        r"""
        x.stop_all_camera_animations_of(player_controller, sequence, immediate=False) -> None
        Stop playing all instances of the given camera animation sequence.
        
        Args:
            player_controller (PlayerController): The player controller on which to play the animation.
            sequence (CameraAnimationSequence): The sequence of which to stop all instances.
            immediate (bool): True to stop it right now and ignore blend out, false to let it blend out as indicated.
        """
        ...
    def stop_all_camera_animations(self, player_controller: PlayerController, immediate: bool = False) -> None:
        r"""
        x.stop_all_camera_animations(player_controller, immediate=False) -> None
        Stop all camera animation instances.
        
        Args:
            player_controller (PlayerController): The player controller on which to play the animation.
            immediate (bool): True to stop it right now and ignore blend out, false to let it blend out as indicated.
        """
        ...
    def play_camera_animation(self, player_controller: PlayerController, sequence: CameraAnimationSequence, params: CameraAnimationParams) -> CameraAnimationHandle:
        r"""
        x.play_camera_animation(player_controller, sequence, params) -> CameraAnimationHandle
        Play a new camera animation sequence.
        
        Args:
            player_controller (PlayerController): The player controller on which to play the animation.
            sequence (CameraAnimationSequence): The sequence to use for the new camera animation.
            params (CameraAnimationParams): The parameters for the new camera animation instance.
        
        Returns:
            CameraAnimationHandle:
        """
        ...
    def is_camera_animation_active(self, player_controller: PlayerController, handle: CameraAnimationHandle) -> bool:
        r"""
        x.is_camera_animation_active(player_controller, handle) -> bool
        Returns whether the given camera animation is playing.
        
        Args:
            player_controller (PlayerController): The player controller on which to play the animation.
            handle (CameraAnimationHandle): A handle to a previously started camera animation.
        
        Returns:
            bool: Whether the corresponding camera animation is playing or not.
        """
        ...

class DefaultCameraShakeBase(CameraShakeBase):
    r"""
    Like UCameraShakeBase but with a perlin noise shake pattern by default, for convenience.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: DefaultCameraShakeBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``root_shake_pattern`` (CameraShakePattern):  [Read-Write] The root pattern for this camera shake
    - ``shake_scale`` (float):  [Read-Write] The overall scale to apply to the shake. Only valid when the shake is active.
    - ``single_instance`` (bool):  [Read-Write] If true to only allow a single instance of this shake class to play at any given time.
      Subsequent attempts to play this shake will simply restart the timer.
    """
    ...

class SimpleCameraShakePattern(CameraShakePattern):
    r"""
    A base class for a simple camera shake.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: SimpleCameraShakePattern.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_in_time`` (float):  [Read-Write] Blend-in time for this shake. Zero or less means no blend-in.
    - ``blend_out_time`` (float):  [Read-Write] Blend-out time for this shake. Zero or less means no blend-out.
    - ``duration`` (float):  [Read-Write] Duration in seconds of this shake. Zero or less means infinite.
    """
    ...

class PerlinNoiseCameraShakePattern(SimpleCameraShakePattern):
    r"""
    A camera shake that uses Perlin noise to shake the camera.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: PerlinNoiseCameraShakePattern.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_in_time`` (float):  [Read-Write] Blend-in time for this shake. Zero or less means no blend-in.
    - ``blend_out_time`` (float):  [Read-Write] Blend-out time for this shake. Zero or less means no blend-out.
    - ``duration`` (float):  [Read-Write] Duration in seconds of this shake. Zero or less means infinite.
    - ``fov`` (PerlinNoiseShaker):  [Read-Write] FOV shake.
    - ``location_amplitude_multiplier`` (float):  [Read-Write] Amplitude multiplier for all location shake
    - ``location_frequency_multiplier`` (float):  [Read-Write] Frequency multiplier for all location shake
    - ``pitch`` (PerlinNoiseShaker):  [Read-Write] Pitch shake.
    - ``roll`` (PerlinNoiseShaker):  [Read-Write] Roll shake.
    - ``rotation_amplitude_multiplier`` (float):  [Read-Write] Amplitude multiplier for all rotation shake
    - ``rotation_frequency_multiplier`` (float):  [Read-Write] Frequency multiplier for all rotation shake
    - ``x`` (PerlinNoiseShaker):  [Read-Write] Shake in the X axis.
    - ``y`` (PerlinNoiseShaker):  [Read-Write] Shake in the Y axis.
    - ``yaw`` (PerlinNoiseShaker):  [Read-Write] Yaw shake.
    - ``z`` (PerlinNoiseShaker):  [Read-Write] Shake in the Z axis.
    """
    @property
    def location_amplitude_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Amplitude multiplier for all location shake
        """
        ...
    @location_amplitude_multiplier.setter
    def location_amplitude_multiplier(self, value: float) -> None:
        ...
    @property
    def location_frequency_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Frequency multiplier for all location shake
        """
        ...
    @location_frequency_multiplier.setter
    def location_frequency_multiplier(self, value: float) -> None:
        ...
    @property
    def x(self) -> PerlinNoiseShaker:
        r"""
        (PerlinNoiseShaker):  [Read-Write] Shake in the X axis.
        """
        ...
    @x.setter
    def x(self, value: PerlinNoiseShaker) -> None:
        ...
    @property
    def y(self) -> PerlinNoiseShaker:
        r"""
        (PerlinNoiseShaker):  [Read-Write] Shake in the Y axis.
        """
        ...
    @y.setter
    def y(self, value: PerlinNoiseShaker) -> None:
        ...
    @property
    def z(self) -> PerlinNoiseShaker:
        r"""
        (PerlinNoiseShaker):  [Read-Write] Shake in the Z axis.
        """
        ...
    @z.setter
    def z(self, value: PerlinNoiseShaker) -> None:
        ...
    @property
    def rotation_amplitude_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Amplitude multiplier for all rotation shake
        """
        ...
    @rotation_amplitude_multiplier.setter
    def rotation_amplitude_multiplier(self, value: float) -> None:
        ...
    @property
    def rotation_frequency_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Frequency multiplier for all rotation shake
        """
        ...
    @rotation_frequency_multiplier.setter
    def rotation_frequency_multiplier(self, value: float) -> None:
        ...
    @property
    def pitch(self) -> PerlinNoiseShaker:
        r"""
        (PerlinNoiseShaker):  [Read-Write] Pitch shake.
        """
        ...
    @pitch.setter
    def pitch(self, value: PerlinNoiseShaker) -> None:
        ...
    @property
    def yaw(self) -> PerlinNoiseShaker:
        r"""
        (PerlinNoiseShaker):  [Read-Write] Yaw shake.
        """
        ...
    @yaw.setter
    def yaw(self, value: PerlinNoiseShaker) -> None:
        ...
    @property
    def roll(self) -> PerlinNoiseShaker:
        r"""
        (PerlinNoiseShaker):  [Read-Write] Roll shake.
        """
        ...
    @roll.setter
    def roll(self, value: PerlinNoiseShaker) -> None:
        ...
    @property
    def fov(self) -> PerlinNoiseShaker:
        r"""
        (PerlinNoiseShaker):  [Read-Write] FOV shake.
        """
        ...
    @fov.setter
    def fov(self, value: PerlinNoiseShaker) -> None:
        ...

class WaveOscillatorCameraShakePattern(SimpleCameraShakePattern):
    r"""
    A camera shake that uses oscillations to move the camera.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: WaveOscillatorCameraShakePattern.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blend_in_time`` (float):  [Read-Write] Blend-in time for this shake. Zero or less means no blend-in.
    - ``blend_out_time`` (float):  [Read-Write] Blend-out time for this shake. Zero or less means no blend-out.
    - ``duration`` (float):  [Read-Write] Duration in seconds of this shake. Zero or less means infinite.
    - ``fov`` (WaveOscillator):  [Read-Write] FOV oscillation.
    - ``location_amplitude_multiplier`` (float):  [Read-Write] Amplitude multiplier for all location oscillation
    - ``location_frequency_multiplier`` (float):  [Read-Write] Frequency multiplier for all location oscillation
    - ``pitch`` (WaveOscillator):  [Read-Write] Pitch oscillation.
    - ``roll`` (WaveOscillator):  [Read-Write] Roll oscillation.
    - ``rotation_amplitude_multiplier`` (float):  [Read-Write] Amplitude multiplier for all rotation oscillation
    - ``rotation_frequency_multiplier`` (float):  [Read-Write] Frequency multiplier for all rotation oscillation
    - ``x`` (WaveOscillator):  [Read-Write] Oscillation in the X axis.
    - ``y`` (WaveOscillator):  [Read-Write] Oscillation in the Y axis.
    - ``yaw`` (WaveOscillator):  [Read-Write] Yaw oscillation.
    - ``z`` (WaveOscillator):  [Read-Write] Oscillation in the Z axis.
    """
    @property
    def location_amplitude_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Amplitude multiplier for all location oscillation
        """
        ...
    @location_amplitude_multiplier.setter
    def location_amplitude_multiplier(self, value: float) -> None:
        ...
    @property
    def location_frequency_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Frequency multiplier for all location oscillation
        """
        ...
    @location_frequency_multiplier.setter
    def location_frequency_multiplier(self, value: float) -> None:
        ...
    @property
    def x(self) -> WaveOscillator:
        r"""
        (WaveOscillator):  [Read-Write] Oscillation in the X axis.
        """
        ...
    @x.setter
    def x(self, value: WaveOscillator) -> None:
        ...
    @property
    def y(self) -> WaveOscillator:
        r"""
        (WaveOscillator):  [Read-Write] Oscillation in the Y axis.
        """
        ...
    @y.setter
    def y(self, value: WaveOscillator) -> None:
        ...
    @property
    def z(self) -> WaveOscillator:
        r"""
        (WaveOscillator):  [Read-Write] Oscillation in the Z axis.
        """
        ...
    @z.setter
    def z(self, value: WaveOscillator) -> None:
        ...
    @property
    def rotation_amplitude_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Amplitude multiplier for all rotation oscillation
        """
        ...
    @rotation_amplitude_multiplier.setter
    def rotation_amplitude_multiplier(self, value: float) -> None:
        ...
    @property
    def rotation_frequency_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Frequency multiplier for all rotation oscillation
        """
        ...
    @rotation_frequency_multiplier.setter
    def rotation_frequency_multiplier(self, value: float) -> None:
        ...
    @property
    def pitch(self) -> WaveOscillator:
        r"""
        (WaveOscillator):  [Read-Write] Pitch oscillation.
        """
        ...
    @pitch.setter
    def pitch(self, value: WaveOscillator) -> None:
        ...
    @property
    def yaw(self) -> WaveOscillator:
        r"""
        (WaveOscillator):  [Read-Write] Yaw oscillation.
        """
        ...
    @yaw.setter
    def yaw(self, value: WaveOscillator) -> None:
        ...
    @property
    def roll(self) -> WaveOscillator:
        r"""
        (WaveOscillator):  [Read-Write] Roll oscillation.
        """
        ...
    @roll.setter
    def roll(self, value: WaveOscillator) -> None:
        ...
    @property
    def fov(self) -> WaveOscillator:
        r"""
        (WaveOscillator):  [Read-Write] FOV oscillation.
        """
        ...
    @fov.setter
    def fov(self, value: WaveOscillator) -> None:
        ...

class TestCameraShake(CameraShakeBase):
    r"""
    Test Camera Shake
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraShakeTestObjects.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``root_shake_pattern`` (CameraShakePattern):  [Read-Write] The root pattern for this camera shake
    - ``shake_scale`` (float):  [Read-Write] The overall scale to apply to the shake. Only valid when the shake is active.
    - ``single_instance`` (bool):  [Read-Write] If true to only allow a single instance of this shake class to play at any given time.
      Subsequent attempts to play this shake will simply restart the timer.
    """
    ...

class TemplateSequence(MovieSceneSequence):
    r"""
    * Movie scene animation that can be instanced multiple times inside a level sequence.
    
    **C++ Source:**
    
    - **Plugin**: TemplateSequence
    - **Module**: TemplateSequence
    - **File**: TemplateSequence.h
    
    """
    ...

class CameraAnimationSequence(TemplateSequence):
    r"""
    * A template sequence specifically designed for playing on cameras.
    
    **C++ Source:**
    
    - **Plugin**: TemplateSequence
    - **Module**: TemplateSequence
    - **File**: CameraAnimationSequence.h
    
    """
    ...

class CameraAsset(Object):
    r"""
    A complete camera asset.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``camera_director`` (CameraDirector):  [Read-Write] The camera director to use in this camera.
    - ``enter_transitions`` (Array[CameraModeTransition]):  [Read-Write] A list of default enter transitions for all the camera modes in this asset.
    - ``exit_transitions`` (Array[CameraModeTransition]):  [Read-Write] A list of default exit transitions for all the camera modes in this asset.
    """
    ...

class CameraDirector(Object):
    r"""
    Base class for a camera director.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraDirector.h
    
    """
    ...

class CameraModeTransitionCondition(Object):
    r"""
    Base class for a camera transition condition.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraModeTransition.h
    
    """
    ...

class CameraInstantiableObject(Object):
    r"""
    Camera Instantiable Object
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraInstantiableObject.h
    
    """
    ...

class CameraNode(CameraInstantiableObject):
    r"""
    The base class for a camera node.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: CameraNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_enabled`` (bool):  [Read-Write] Specifies whether this node is enabled.
    """
    ...

class BlendCameraNode(CameraNode):
    r"""
    Base class for blend camera nodes.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCameras
    - **File**: BlendCameraNode.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_enabled`` (bool):  [Read-Write] Specifies whether this node is enabled.
    """
    ...

class PaperCharacter(Character):
    r"""
    APaperCharacter behaves like ACharacter, but uses a UPaperFlipbookComponent instead of a USkeletalMeshComponent as a visual representation
    Note: The variable named Mesh will not be set up on this actor!
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperCharacter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``ai_controller_class`` (type(Class)):  [Read-Write] Default class to use when pawn is controlled by AI.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_possess_ai`` (AutoPossessAI):  [Read-Write] Determines when the Pawn creates and is possessed by an AI Controller (on level start, when spawned, etc).
      Only possible if AIControllerClassRef is set, and ignored if AutoPossessPlayer is enabled.
      see: AutoPossessPlayer
    - ``auto_possess_player`` (AutoReceiveInput):  [Read-Write] Determines which PlayerController, if any, should automatically possess the pawn when the level starts or when the pawn is spawned.
      see: AutoPossessAI
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``base_eye_height`` (float):  [Read-Write] Base eye height above collision center.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_affect_navigation_generation`` (bool):  [Read-Write] If set to false (default) given pawn instance will never affect navigation generation (but components could).
      Setting it to true will result in using regular AActor's navigation relevancy
      calculation to check if this pawn instance should affect navigation generation.
      note: Use SetCanAffectNavigationGeneration() to change this value at runtime.
      note: Modifying this value at runtime will result in any navigation change only if runtime navigation generation is enabled.
      note: Override UpdateNavigationRelevance() to propagate the flag to the desired components.
      see: SetCanAffectNavigationGeneration(), UpdateNavigationRelevance()
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``capsule_component`` (CapsuleComponent):  [Read-Only] The CapsuleComponent being used for movement collision (by CharacterMovement). Always treated as being vertically aligned in simple collision check functions.
    - ``character_movement`` (CharacterMovementComponent):  [Read-Only] Movement component used for movement logic in various movement modes (walking, falling, etc), containing relevant settings and functions to control movement.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``crouched_eye_height`` (float):  [Read-Write] Default crouched eye height
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_crouched`` (bool):  [Read-Write] Set by character movement to specify that this Character is currently crouched.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``jump_current_count`` (int32):  [Read-Only] Tracks the current number of jumps performed.
      This is incremented in CheckJumpInput, used in CanJump_Implementation, and reset in OnMovementModeChanged.
      When providing overrides for these methods, it's recommended to either manually
      increment / reset this value, or call the Super:: method.
    - ``jump_current_count_pre_jump`` (int32):  [Read-Only] Represents the current number of jumps performed before CheckJumpInput modifies JumpCurrentCount.
      This is set in CheckJumpInput and is used in SetMoveFor and PrepMoveFor instead of JumpCurrentCount
      since CheckJumpInput can modify JumpCurrentCount.
      When providing overrides for these methods, it's recommended to either manually
      set this value, or call the Super:: method.
    - ``jump_force_time_remaining`` (float):  [Read-Only] Amount of jump force time remaining, if JumpMaxHoldTime > 0.
    - ``jump_key_hold_time`` (float):  [Read-Only] Jump key Held Time.
      This is the time that the player has held the jump key, in seconds.
    - ``jump_max_count`` (int32):  [Read-Write] The max number of jumps the character can perform.
      Note that if JumpMaxHoldTime is non zero and StopJumping is not called, the player
      may be able to perform and unlimited number of jumps. Therefore it is usually
      best to call StopJumping() when jump input has ceased (such as a button up event).
    - ``jump_max_hold_time`` (float):  [Read-Write] The max time the jump key can be held.
      Note that if StopJumping() is not called before the max jump hold time is reached,
      then the character will carry on receiving vertical velocity. Therefore it is usually
      best to call StopJumping() when jump input has ceased (such as a button up event).
    - ``landed_delegate`` (LandedSignature):  [Read-Write] Called upon landing when falling, to perform actions based on the Hit result.
      Note that movement mode is still "Falling" during this event. Current Velocity value is the velocity at the time of landing.
      Consider OnMovementModeChanged() as well, as that can be used once the movement mode changes to the new mode (most likely Walking).
      see: OnMovementModeChanged()
    - ``last_hit_by`` (Controller):  [Read-Write] Controller of the last Actor that caused us damage.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``mesh`` (SkeletalMeshComponent):  [Read-Only] The main skeletal mesh associated with this Character (optional sub-object).
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``movement_mode_changed_delegate`` (MovementModeChangedSignature):  [Read-Write] Multicast delegate for MovementMode changing.
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_character_movement_updated`` (CharacterMovementUpdatedSignature):  [Read-Write] Event triggered at the end of a CharacterMovementComponent movement update.
      This is the preferred event to use rather than the Tick event when performing custom updates to CharacterMovement properties based on the current state.
      This is mainly due to the nature of network updates, where client corrections in position from the server can cause multiple iterations of a movement update,
      which allows this event to update as well, while a Tick event would not.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_reached_jump_apex`` (CharacterReachedApexSignature):  [Read-Write] Broadcast when Character's jump reaches its apex. Needs CharacterMovement->bNotifyApex = true
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_input_component_class`` (type(Class)):  [Read-Write] If set, then this InputComponent class will be used instead of the Input Settings' DefaultInputComponentClass
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_state`` (PlayerState):  [Read-Write] If Pawn is possessed by a player, points to its Player State.  Needed for network play as controllers are not replicated to clients.
    - ``pressed_jump`` (bool):  [Read-Write] When true, player wants to jump
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``proxy_jump_force_started_time`` (float):  [Read-Only] Track last time a jump force started for a proxy.
    - ``receive_controller_changed_delegate`` (PawnControllerChangedSignature):  [Read-Write] Event called after a pawn's controller has changed, on the server and owning client. This will happen at the same time as the delegate on GameInstance
    - ``receive_restarted_delegate`` (PawnRestartedSignature):  [Read-Write] Event called after a pawn has been restarted, usually by a possession change. This is called on the server for all pawns and the owning client for player pawns
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite`` (PaperFlipbookComponent):  [Read-Only] The main skeletal mesh associated with this Character (optional sub-object).
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_controller_rotation_pitch`` (bool):  [Read-Write] If true, this Pawn's pitch will be updated to match the Controller's ControlRotation pitch, if controlled by a PlayerController.
    - ``use_controller_rotation_roll`` (bool):  [Read-Write] If true, this Pawn's roll will be updated to match the Controller's ControlRotation roll, if controlled by a PlayerController.
    - ``use_controller_rotation_yaw`` (bool):  [Read-Write] If true, this Pawn's yaw will be updated to match the Controller's ControlRotation yaw, if controlled by a PlayerController.
    - ``was_jumping`` (bool):  [Read-Only] Tracks whether or not the character was already jumping last frame.
    """
    @property
    def sprite(self) -> PaperFlipbookComponent:
        r"""
        (PaperFlipbookComponent):  [Read-Only] The main skeletal mesh associated with this Character (optional sub-object).
        """
        ...

class PaperFlipbook(Object):
    r"""
    Contains an animation sequence of sprite frames
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperFlipbook.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_source`` (FlipbookCollisionMode):  [Read-Write] Collision source
    - ``default_material`` (MaterialInterface):  [Read-Write] The material to use on a flipbook player instance if not overridden
    - ``frames_per_second`` (float):  [Read-Write] The nominal frame rate to play this flipbook animation back at
    - ``key_frames`` (Array[PaperFlipbookKeyFrame]):  [Read-Write] The set of key frames for this flipbook animation (each one has a duration and a sprite to display)
    """
    @property
    def frames_per_second(self) -> float:
        r"""
        (float):  [Read-Only] The nominal frame rate to play this flipbook animation back at
        """
        ...
    @property
    def default_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Only] The material to use on a flipbook player instance if not overridden
        """
        ...
    @property
    def collision_source(self) -> FlipbookCollisionMode:
        r"""
        (FlipbookCollisionMode):  [Read-Only] Collision source
        """
        ...
    def is_valid_key_frame_index(self, index: int) -> bool:
        r"""
        x.is_valid_key_frame_index(index) -> bool
        Is the specified Index within the valid range of key frames?
        
        Args:
            index (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_total_duration(self) -> float:
        r"""
        x.get_total_duration() -> float
        Returns the total duration in seconds
        
        Returns:
            float:
        """
        ...
    def get_sprite_at_time(self, time: float, clamp_to_ends: bool = False) -> PaperSprite:
        r"""
        x.get_sprite_at_time(time, clamp_to_ends=False) -> PaperSprite
        Returns the sprite at the specified time (in seconds), or nullptr if none exists.
        When bClampToEnds is true, it will choose the first or last sprite if the time is out of range.
        
        Args:
            time (float): 
            clamp_to_ends (bool): 
        
        Returns:
            PaperSprite:
        """
        ...
    def get_sprite_at_frame(self, frame_index: int) -> PaperSprite:
        r"""
        x.get_sprite_at_frame(frame_index) -> PaperSprite
        Returns the sprite at the specified keyframe index, or nullptr if none exists
        
        Args:
            frame_index (int32): 
        
        Returns:
            PaperSprite:
        """
        ...
    def get_num_key_frames(self) -> int:
        r"""
        x.get_num_key_frames() -> int32
        Returns the number of key frames
        
        Returns:
            int32:
        """
        ...
    def get_num_frames(self) -> int:
        r"""
        x.get_num_frames() -> int32
        Returns the total number of frames
        
        Returns:
            int32:
        """
        ...
    def get_key_frame_index_at_time(self, time: float, clamp_to_ends: bool = False) -> int:
        r"""
        x.get_key_frame_index_at_time(time, clamp_to_ends=False) -> int32
        Returns the keyframe index that covers the specified time (in seconds), or INDEX_NONE if none exists.
        When bClampToEnds is true, it will choose the first or last keyframe if the time is out of range.
        
        Args:
            time (float): 
            clamp_to_ends (bool): 
        
        Returns:
            int32:
        """
        ...

class PaperFlipbookActor(Actor):
    r"""
    An instance of a UPaperFlipbook in a level.
    
    This actor is created when you drag a flipbook asset from the content browser into the level, and
    it is just a thin wrapper around a UPaperFlipbookComponent that actually references the asset.
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperFlipbookActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``render_component`` (PaperFlipbookComponent):  [Read-Only]
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def render_component(self) -> PaperFlipbookComponent:
        r"""
        (PaperFlipbookComponent):  [Read-Only]
        """
        ...

class PaperFlipbookComponent(MeshComponent):
    r"""
    Paper Flipbook Component
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperFlipbookComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_finished_playing`` (FlipbookFinishedPlaySignature):  [Read-Write] Event called whenever a non-looping flipbook finishes playing (either reaching the beginning or the end, depending on the play direction)
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``play_rate`` (float):  [Read-Write] Current play rate of the flipbook
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``source_flipbook`` (PaperFlipbook):  [Read-Write] Flipbook currently being played
    - ``sprite_color`` (LinearColor):  [Read-Write] Vertex color to apply to the frames
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def sprite_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] Vertex color to apply to the frames
        """
        ...
    @property
    def on_finished_playing(self) -> FlipbookFinishedPlaySignature:
        r"""
        (FlipbookFinishedPlaySignature):  [Read-Write] Event called whenever a non-looping flipbook finishes playing (either reaching the beginning or the end, depending on the play direction)
        """
        ...
    @on_finished_playing.setter
    def on_finished_playing(self, value: FlipbookFinishedPlaySignature) -> None:
        ...
    def stop(self) -> None:
        r"""
        x.stop() -> None
        Stop playback of flipbook
        """
        ...
    def set_sprite_color(self, new_color: LinearColor) -> None:
        r"""
        x.set_sprite_color(new_color) -> None
        Set color of the sprite
        
        Args:
            new_color (LinearColor):
        """
        ...
    def set_play_rate(self, new_rate: float) -> None:
        r"""
        x.set_play_rate(new_rate) -> None
        Sets the new play rate for this flipbook
        
        Args:
            new_rate (float):
        """
        ...
    def set_playback_position_in_frames(self, new_frame_position: int, fire_events: bool) -> None:
        r"""
        x.set_playback_position_in_frames(new_frame_position, fire_events) -> None
        Jump to a position in the flipbook (expressed in frames). If bFireEvents is true, event functions will fire, otherwise they will not.
        
        Args:
            new_frame_position (int32): 
            fire_events (bool):
        """
        ...
    def set_playback_position(self, new_position: float, fire_events: bool) -> None:
        r"""
        x.set_playback_position(new_position, fire_events) -> None
        Jump to a position in the flipbook (expressed in seconds). If bFireEvents is true, event functions will fire, otherwise they will not.
        
        Args:
            new_position (float): 
            fire_events (bool):
        """
        ...
    def set_new_time(self, new_time: float) -> None:
        r"""
        x.set_new_time(new_time) -> None
        Set the new playback position time to use
        
        Args:
            new_time (float):
        """
        ...
    def set_looping(self, new_looping: bool) -> None:
        r"""
        x.set_looping(new_looping) -> None
        true means we should loop, false means we should not.
        
        Args:
            new_looping (bool):
        """
        ...
    def set_flipbook(self, new_flipbook: PaperFlipbook) -> bool:
        r"""
        x.set_flipbook(new_flipbook) -> bool
        Change the flipbook used by this instance (will reset the play time to 0 if it is a new flipbook).
        
        Args:
            new_flipbook (PaperFlipbook): 
        
        Returns:
            bool:
        """
        ...
    def reverse_from_end(self) -> None:
        r"""
        x.reverse_from_end() -> None
        Start playback of flipbook in reverse from the end
        """
        ...
    def reverse(self) -> None:
        r"""
        x.reverse() -> None
        Start playback of flipbook in reverse
        """
        ...
    def play_from_start(self) -> None:
        r"""
        x.play_from_start() -> None
        Start playback of flipbook from the start
        """
        ...
    def play(self) -> None:
        r"""
        x.play() -> None
        Start playback of flipbook
        """
        ...
    def is_reversing(self) -> bool:
        r"""
        x.is_reversing() -> bool
        Get whether we are reversing or not
        
        Returns:
            bool:
        """
        ...
    def is_playing(self) -> bool:
        r"""
        x.is_playing() -> bool
        Get whether this flipbook is playing or not.
        
        Returns:
            bool:
        """
        ...
    def is_looping(self) -> bool:
        r"""
        x.is_looping() -> bool
        Get whether we are looping or not
        
        Returns:
            bool:
        """
        ...
    def get_sprite_color(self) -> LinearColor:
        r"""
        x.get_sprite_color() -> LinearColor
        Returns the current color of the sprite
        
        Returns:
            LinearColor:
        """
        ...
    def get_play_rate(self) -> float:
        r"""
        x.get_play_rate() -> float
        Get the current play rate for this flipbook
        
        Returns:
            float:
        """
        ...
    def get_playback_position_in_frames(self) -> int:
        r"""
        x.get_playback_position_in_frames() -> int32
        Get the current playback position (in frames) of the flipbook
        
        Returns:
            int32:
        """
        ...
    def get_playback_position(self) -> float:
        r"""
        x.get_playback_position() -> float
        Get the current playback position (in seconds) of the flipbook
        
        Returns:
            float:
        """
        ...
    def get_flipbook_length_in_frames(self) -> int:
        r"""
        x.get_flipbook_length_in_frames() -> int32
        Get length of the flipbook (in frames)
        
        Returns:
            int32:
        """
        ...
    def get_flipbook_length(self) -> float:
        r"""
        x.get_flipbook_length() -> float
        Get length of the flipbook (in seconds)
        
        Returns:
            float:
        """
        ...
    def get_flipbook_framerate(self) -> float:
        r"""
        x.get_flipbook_framerate() -> float
        Get the nominal framerate that the flipbook will be played back at (ignoring PlayRate), in frames per second
        
        Returns:
            float:
        """
        ...
    def get_flipbook(self) -> PaperFlipbook:
        r"""
        x.get_flipbook() -> PaperFlipbook
        Gets the flipbook used by this instance.
        
        Returns:
            PaperFlipbook:
        """
        ...

class PaperAnimatedRenderComponent(PaperFlipbookComponent):
    r"""
    deprecated: 'PaperAnimatedRenderComponent' was renamed to 'PaperFlipbookComponent'.
    """
    ...

class PaperGroupedSpriteActor(Actor):
    r"""
    A group of sprites that will be rendered and culled as a single unit
    
    This actor is created when you Merge several sprite components together.
    it is just a thin wrapper around a UPaperGroupedSpriteComponent.
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperGroupedSpriteActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``render_component`` (PaperGroupedSpriteComponent):  [Read-Only]
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def render_component(self) -> PaperGroupedSpriteComponent:
        r"""
        (PaperGroupedSpriteComponent):  [Read-Only]
        """
        ...

class PaperGroupedSpriteComponent(MeshComponent):
    r"""
    A component that handles rendering and collision for many instances of one or more UPaperSprite assets.
    see: UPrimitiveComponent, UPaperSprite
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperGroupedSpriteComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``per_instance_sprite_data`` (Array[SpriteInstanceData]):  [Read-Write] Array of instances
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    def update_instance_transform(self, instance_index: int, new_instance_transform: Transform, world_space: bool = False, mark_render_state_dirty: bool = True, teleport: bool = False) -> bool:
        r"""
        x.update_instance_transform(instance_index, new_instance_transform, world_space=False, mark_render_state_dirty=True, teleport=False) -> bool
        Update the transform for the instance specified. Instance is given in local space of this component unless bWorldSpace is set.  Returns True on success.
        
        Args:
            instance_index (int32): 
            new_instance_transform (Transform): 
            world_space (bool): 
            mark_render_state_dirty (bool): 
            teleport (bool): 
        
        Returns:
            bool:
        """
        ...
    def update_instance_color(self, instance_index: int, new_instance_color: LinearColor, mark_render_state_dirty: bool = True) -> bool:
        r"""
        x.update_instance_color(instance_index, new_instance_color, mark_render_state_dirty=True) -> bool
        Update the color for the instance specified. Returns True on success.
        
        Args:
            instance_index (int32): 
            new_instance_color (LinearColor): 
            mark_render_state_dirty (bool): 
        
        Returns:
            bool:
        """
        ...
    def sort_instances_along_axis(self, world_space_sort_axis: Vector) -> None:
        r"""
        x.sort_instances_along_axis(world_space_sort_axis) -> None
        Sort all instances by their world space position along the specified axis
        
        Args:
            world_space_sort_axis (Vector):
        """
        ...
    def remove_instance(self, instance_index: int) -> bool:
        r"""
        x.remove_instance(instance_index) -> bool
        Remove the instance specified. Returns True on success.
        
        Args:
            instance_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_instance_transform(self, instance_index: int, world_space: bool = False) -> Optional[Transform]:
        r"""
        x.get_instance_transform(instance_index, world_space=False) -> Transform or None
        Get the transform for the instance specified. Instance is returned in local space of this component unless bWorldSpace is set.  Returns True on success.
        
        Args:
            instance_index (int32): 
            world_space (bool): 
        
        Returns:
            Transform or None: 
        
            out_instance_transform (Transform):
        """
        ...
    def get_instance_count(self) -> int:
        r"""
        x.get_instance_count() -> int32
        Get the number of instances in this component
        
        Returns:
            int32:
        """
        ...
    def clear_instances(self) -> None:
        r"""
        x.clear_instances() -> None
        Clear all instances being rendered by this component
        """
        ...
    def add_instance(self, transform: Transform, sprite: PaperSprite, world_space: bool = False, color: LinearColor = [1.000000, 1.000000, 1.000000, 1.000000]) -> int:
        r"""
        x.add_instance(transform, sprite, world_space=False, color=[1.000000, 1.000000, 1.000000, 1.000000]) -> int32
        Add an instance to this component. Transform can be given either in the local space of this component or world space.
        
        Args:
            transform (Transform): 
            sprite (PaperSprite): 
            world_space (bool): 
            color (LinearColor): 
        
        Returns:
            int32:
        """
        ...

class PaperSprite(Object):
    r"""
    Sprite Asset
    
    Stores the data necessary to render a single 2D sprite (from a region of a texture)
    Can also contain collision shapes for the sprite.
    see: UPaperSpriteComponent
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperSprite.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_source_textures`` (Array[Texture]):  [Read-Write] Additional source textures for other slots
    - ``alternate_material`` (MaterialInterface):  [Read-Write] The alternate material to use on a sprite instance if not overridden (this is only used for Diced render geometry, and will be the opaque material in that case, slot 1)
    - ``atlas_group`` (PaperSpriteAtlas):  [Read-Write] Spritesheet group that this sprite belongs to
    - ``body_setup`` (BodySetup):  [Read-Write] Baked physics data.
    - ``collision_geometry`` (SpriteGeometryCollection):  [Read-Write] Custom collision geometry polygons (in texture space)
    - ``collision_thickness`` (float):  [Read-Write] The extrusion thickness of collision geometry when using a 3D collision domain
    - ``custom_pivot_point`` (Vector2D):  [Read-Write] Custom pivot point (relative to the sprite rectangle)
    - ``default_material`` (MaterialInterface):  [Read-Write] The material to use on a sprite instance if not overridden (this is the default material when only one is being used, and is the translucent/masked material for Diced render geometry, slot 0)
    - ``origin_in_source_image_before_trimming`` (Vector2D):  [Read-Write] Origin within SourceImage, prior to atlasing
    - ``pivot_mode`` (SpritePivotMode):  [Read-Write] Pivot mode
    - ``pixels_per_unreal_unit`` (float):  [Read-Write] The scaling factor between pixels and Unreal units (cm) (e.g., 0.64 would make a 64 pixel wide sprite take up 100 cm)
    - ``render_geometry`` (SpriteGeometryCollection):  [Read-Write] Custom render geometry polygons (in texture space)
    - ``rotated_in_source_image`` (bool):  [Read-Write] This texture is rotated in the atlas
    - ``snap_pivot_to_pixel_grid`` (bool):  [Read-Write] Should the pivot be snapped to a pixel boundary?
    - ``sockets`` (Array[PaperSpriteSocket]):  [Read-Write] List of sockets on this sprite
    - ``source_dimension`` (Vector2D):  [Read-Write] Dimensions within SourceTexture (in pixels)
    - ``source_image_dimension_before_trimming`` (Vector2D):  [Read-Write] Dimensions of SourceImage
    - ``source_texture`` (Texture2D):  [Read-Write] The source texture that the sprite comes from
    - ``source_texture_dimension`` (Vector2D):  [Read-Write] Dimension of the texture when this sprite was created
      Used when the sprite is resized at some point
    - ``source_uv`` (Vector2D):  [Read-Write] Position within SourceTexture (in pixels)
    - ``sprite_collision_domain`` (SpriteCollisionMode):  [Read-Write] Collision domain (no collision, 2D, or 3D)
    - ``trimmed_in_source_image`` (bool):  [Read-Write] This texture is trimmed, consider the values above
    """
    @property
    def default_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Only] The material to use on a sprite instance if not overridden (this is the default material when only one is being used, and is the translucent/masked material for Diced render geometry, slot 0)
        """
        ...
    @property
    def alternate_material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Only] The alternate material to use on a sprite instance if not overridden (this is only used for Diced render geometry, and will be the opaque material in that case, slot 1)
        """
        ...

class PaperSpriteActor(Actor):
    r"""
    An instance of a UPaperSprite in a level.
    
    This actor is created when you drag a sprite asset from the content browser into the level, and
    it is just a thin wrapper around a UPaperSpriteComponent that actually references the asset.
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperSpriteActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``render_component`` (PaperSpriteComponent):  [Read-Only]
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def render_component(self) -> PaperSpriteComponent:
        r"""
        (PaperSpriteComponent):  [Read-Only]
        """
        ...

class PaperRenderActor(PaperSpriteActor):
    r"""
    deprecated: 'PaperRenderActor' was renamed to 'PaperSpriteActor'.
    """
    ...

class PaperSpriteAtlas(Object):
    r"""
    Groups together a set of sprites that will try to share the same texture atlas (allowing them to be combined into a single draw call)
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperSpriteAtlas.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``atlas_description`` (str):  [Read-Write] Description of this atlas, which shows up in the content browser tooltip
    - ``atlas_guid`` (Guid):  [Read-Only] The GUID of the atlas group, used to match up sprites that belong to this group even thru atlas renames
    - ``compression_settings`` (TextureCompressionSettings):  [Read-Write] Compression settings to use on atlas texture
    - ``filter`` (TextureFilter):  [Read-Write] Texture filtering mode when sampling these textures
    - ``generated_textures`` (Array[Texture]):  [Read-Only] List of generated atlas textures
    - ``max_height`` (int32):  [Read-Write] Maximum atlas page height (single pages might be smaller)
    - ``max_width`` (int32):  [Read-Write] Maximum atlas page width (single pages might be smaller)
    - ``mip_count`` (int32):  [Read-Write] Maximum atlas page height (single pages might be smaller)
    - ``padding`` (int32):  [Read-Write] The number of pixels of padding
    - ``padding_type`` (PaperSpriteAtlasPadding):  [Read-Write] The type of padding performed on this atlas
    - ``rebuild_atlas`` (bool):  [Read-Write] Slots in the atlas
    """
    ...

class PaperSpriteLibrary(BlueprintFunctionLibrary):
    r"""
    Paper Sprite Blueprint Library
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperSpriteBlueprintLibrary.h
    
    """
    @classmethod
    def make_brush_from_sprite(cls, sprite: PaperSprite, width: int, height: int) -> SlateBrush:
        r"""
        X.make_brush_from_sprite(sprite, width, height) -> SlateBrush
        Make Brush from Sprite
        
        Args:
            sprite (PaperSprite): 
            width (int32): 
            height (int32): 
        
        Returns:
            SlateBrush:
        """
        ...

class PaperSpriteComponent(MeshComponent):
    r"""
    A component that handles rendering and collision for a single instance of a UPaperSprite asset.
    
    This component is created when you drag a sprite asset from the content browser into a Blueprint, or
    contained inside of the actor created when you drag one into the level.
    see: UPrimitiveComponent, UPaperSprite
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperSpriteComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``source_sprite`` (PaperSprite):  [Read-Write] The sprite asset used by this component
    - ``sprite_color`` (LinearColor):  [Read-Write] The color of the sprite (passed to the sprite material as a vertex color)
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def source_sprite(self) -> PaperSprite:
        r"""
        (PaperSprite):  [Read-Only] The sprite asset used by this component
        """
        ...
    @property
    def sprite_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color of the sprite (passed to the sprite material as a vertex color)
        """
        ...
    def set_sprite_color(self, new_color: LinearColor) -> None:
        r"""
        x.set_sprite_color(new_color) -> None
        Set color of the sprite
        
        Args:
            new_color (LinearColor):
        """
        ...
    def set_sprite(self, new_sprite: PaperSprite) -> bool:
        r"""
        x.set_sprite(new_sprite) -> bool
        Change the PaperSprite used by this instance.
        
        Args:
            new_sprite (PaperSprite): 
        
        Returns:
            bool:
        """
        ...
    def get_sprite(self) -> PaperSprite:
        r"""
        x.get_sprite() -> PaperSprite
        Gets the PaperSprite used by this instance.
        
        Returns:
            PaperSprite:
        """
        ...

class PaperRenderComponent(PaperSpriteComponent):
    r"""
    deprecated: 'PaperRenderComponent' was renamed to 'PaperSpriteComponent'.
    """
    ...

class PaperTileLayer(Object):
    r"""
    This class represents a single layer in a tile map.  All layers in the map must have the size dimensions.
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTileLayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collision_offset_override`` (float):  [Read-Write] The override offset of the collision for this layer (when bOverrideCollisionOffset is set)
      Note: This is measured in Unreal Units (cm) from the center of the tile map component, not from the previous layer.
    - ``collision_thickness_override`` (float):  [Read-Write] The override thickness of the collision for this layer (when bOverrideCollisionThickness is set)
    - ``hidden_in_editor`` (bool):  [Read-Write] Is this layer currently hidden in the editor?
    - ``hidden_in_game`` (bool):  [Read-Write] Should this layer be hidden in the game?
    - ``layer_collides`` (bool):  [Read-Write] Should this layer generate collision?
      Note: This only has an effect if the owning tile map has collision enabled
    - ``layer_color`` (LinearColor):  [Read-Write] The color of this layer (multiplied with the tile map color and passed to the material as a vertex color)
    - ``layer_height`` (int32):  [Read-Write] Height of the layer (in tiles)
    - ``layer_name`` (Text):  [Read-Write] Name of the layer
    - ``layer_width`` (int32):  [Read-Write] Width of the layer (in tiles)
    - ``override_collision_offset`` (bool):  [Read-Write] Should this layer use a custom offset for generated collision instead of the layer drawing offset?
    - ``override_collision_thickness`` (bool):  [Read-Write] Should this layer use a custom thickness for generated collision instead of the thickness setting in the tile map?
    """
    @property
    def layer_name(self) -> Text:
        r"""
        (Text):  [Read-Only] Name of the layer
        """
        ...
    @property
    def layer_width(self) -> int:
        r"""
        (int32):  [Read-Only] Width of the layer (in tiles)
        """
        ...
    @property
    def layer_height(self) -> int:
        r"""
        (int32):  [Read-Only] Height of the layer (in tiles)
        """
        ...
    @property
    def hidden_in_game(self) -> bool:
        r"""
        (bool):  [Read-Only] Should this layer be hidden in the game?
        """
        ...
    @property
    def layer_collides(self) -> bool:
        r"""
        (bool):  [Read-Only] Should this layer generate collision?
        Note: This only has an effect if the owning tile map has collision enabled
        """
        ...
    @property
    def override_collision_thickness(self) -> bool:
        r"""
        (bool):  [Read-Only] Should this layer use a custom thickness for generated collision instead of the thickness setting in the tile map?
        """
        ...
    @property
    def override_collision_offset(self) -> bool:
        r"""
        (bool):  [Read-Only] Should this layer use a custom offset for generated collision instead of the layer drawing offset?
        """
        ...
    @property
    def collision_thickness_override(self) -> float:
        r"""
        (float):  [Read-Only] The override thickness of the collision for this layer (when bOverrideCollisionThickness is set)
        """
        ...
    @property
    def collision_offset_override(self) -> float:
        r"""
        (float):  [Read-Only] The override offset of the collision for this layer (when bOverrideCollisionOffset is set)
        Note: This is measured in Unreal Units (cm) from the center of the tile map component, not from the previous layer.
        """
        ...
    @property
    def layer_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color of this layer (multiplied with the tile map color and passed to the material as a vertex color)
        """
        ...

class PaperTileMap(Object):
    r"""
    A tile map is a 2D grid with a defined width and height (in tiles).  There can be multiple layers, each of which can specify which tile should appear in each cell of the map for that layer.
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTileMap.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only] Importing data and options used for this tile map
    - ``background_color`` (LinearColor):  [Read-Write] The background color displayed in the tile map editor
    - ``collision_thickness`` (float):  [Read-Write] The extrusion thickness of collision geometry when using a 3D collision domain
    - ``hex_side_length`` (int32):  [Read-Write] The vertical height of the sides of the hex cell for a tile.
      Note: This value should already be included as part of the TileHeight, and is purely cosmetic; it only affects how the tile cursor preview is drawn.
    - ``layer_grid_color`` (LinearColor):  [Read-Write] The color of the layer grid
    - ``map_height`` (int32):  [Read-Write] Height of map (in tiles)
    - ``map_width`` (int32):  [Read-Write] Width of map (in tiles)
    - ``material`` (MaterialInterface):  [Read-Write] The material to use on a tile map instance if not overridden
    - ``multi_tile_grid_color`` (LinearColor):  [Read-Write] The color of the multi tile grid
    - ``multi_tile_grid_height`` (int32):  [Read-Write] Number of tiles the multi tile grid spans vertically. 0 removes horizontal lines
    - ``multi_tile_grid_offset_x`` (int32):  [Read-Write] Number of tiles the multi tile grid is shifted to the right
    - ``multi_tile_grid_offset_y`` (int32):  [Read-Write] Number of tiles the multi tile grid is shifted downwards
    - ``multi_tile_grid_width`` (int32):  [Read-Write] Number of tiles the multi tile grid spans horizontally. 0 removes vertical lines
    - ``pixels_per_unreal_unit`` (float):  [Read-Write] The scaling factor between pixels and Unreal units (cm) (e.g., 0.64 would make a 64 pixel wide tile take up 100 cm)
    - ``projection_mode`` (TileMapProjectionMode):  [Read-Write] Tile map type
    - ``separation_per_layer`` (float):  [Read-Write] The Z-separation between each layer of the tile map
    - ``separation_per_tile_x`` (float):  [Read-Write] The Z-separation incurred as you travel in X (not strictly applied, batched tiles will be put at the same Z level)
    - ``separation_per_tile_y`` (float):  [Read-Write] The Z-separation incurred as you travel in Y (not strictly applied, batched tiles will be put at the same Z level)
    - ``sprite_collision_domain`` (SpriteCollisionMode):  [Read-Write] Collision domain (no collision, 2D, or 3D)
    - ``tile_grid_color`` (LinearColor):  [Read-Write] The color of the tile grid
    - ``tile_height`` (int32):  [Read-Write] Height of one tile (in pixels)
    - ``tile_layers`` (Array[PaperTileLayer]):  [Read-Write] The list of layers
    - ``tile_width`` (int32):  [Read-Write] Width of one tile (in pixels)
    """
    @property
    def map_width(self) -> int:
        r"""
        (int32):  [Read-Only] Width of map (in tiles)
        """
        ...
    @property
    def map_height(self) -> int:
        r"""
        (int32):  [Read-Only] Height of map (in tiles)
        """
        ...
    @property
    def tile_width(self) -> int:
        r"""
        (int32):  [Read-Only] Width of one tile (in pixels)
        """
        ...
    @property
    def tile_height(self) -> int:
        r"""
        (int32):  [Read-Only] Height of one tile (in pixels)
        """
        ...
    @property
    def separation_per_layer(self) -> float:
        r"""
        (float):  [Read-Only] The Z-separation between each layer of the tile map
        """
        ...
    @property
    def material(self) -> MaterialInterface:
        r"""
        (MaterialInterface):  [Read-Only] The material to use on a tile map instance if not overridden
        """
        ...
    @property
    def tile_layers(self) -> Array[PaperTileLayer]:
        r"""
        (Array[PaperTileLayer]):  [Read-Only] The list of layers
        """
        ...
    @property
    def collision_thickness(self) -> float:
        r"""
        (float):  [Read-Only] The extrusion thickness of collision geometry when using a 3D collision domain
        """
        ...
    @property
    def sprite_collision_domain(self) -> SpriteCollisionMode:
        r"""
        (SpriteCollisionMode):  [Read-Only] Collision domain (no collision, 2D, or 3D)
        """
        ...
    @property
    def projection_mode(self) -> TileMapProjectionMode:
        r"""
        (TileMapProjectionMode):  [Read-Only] Tile map type
        """
        ...

class PaperTileMapActor(Actor):
    r"""
    An instance of a UPaperTileMap in a level.
    
    This actor is created when you drag a tile map asset from the content browser into the level, and
    it is just a thin wrapper around a UPaperTileMapComponent that actually references the asset.
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTileMapActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``render_component`` (PaperTileMapComponent):  [Read-Only]
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def render_component(self) -> PaperTileMapComponent:
        r"""
        (PaperTileMapComponent):  [Read-Only]
        """
        ...

class PaperTileMapComponent(MeshComponent):
    r"""
    A component that handles rendering and collision for a single instance of a UPaperTileMap asset.
    
    This component is created when you drag a tile map asset from the content browser into a Blueprint, or
    contained inside of the actor created when you drag one into the level.
    
    NOTE: This is an beta preview class.  While not considered production-ready, it is a step beyond
    'experimental' and is being provided as a preview of things to come:
     - We will try to provide forward-compatibility for content you create.
     - The classes may change significantly in the future.
     - The code is in an early state and may not meet the desired polish / quality bar.
     - There is probably no documentation or example content yet.
     - They will be promoted out of 'beta' when they are production ready.
    see: UPrimitiveComponent, UPaperTileMap
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTileMapComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``show_outline_when_unselected`` (bool):  [Read-Write] Should this component show an outline around the first layer when the component is not selected?
    - ``show_per_layer_grid_when_selected`` (bool):  [Read-Write] Should this component show an outline around each layer when the component is selected?
    - ``show_per_layer_grid_when_unselected`` (bool):  [Read-Write] Should this component show an outline around each layer when the component is not selected?
    - ``show_per_tile_grid_when_selected`` (bool):  [Read-Write] Should this component show a tile grid when the component is selected?
    - ``show_per_tile_grid_when_unselected`` (bool):  [Read-Write] Should this component show a tile grid when the component is not selected?
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``tile_map`` (PaperTileMap):  [Read-Write] The tile map used by this component
    - ``tile_map_color`` (LinearColor):  [Read-Write] The color of the tile map (multiplied with the per-layer color and passed to the material as a vertex color)
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_single_layer`` (bool):  [Read-Write] Should we draw a single layer?
    - ``use_single_layer_index`` (int32):  [Read-Write] The index of the single layer to use if enabled
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def tile_map(self) -> PaperTileMap:
        r"""
        (PaperTileMap):  [Read-Only] The tile map used by this component
        """
        ...
    def set_tile_map_color(self, new_color: LinearColor) -> None:
        r"""
        x.set_tile_map_color(new_color) -> None
        Sets the tile map global color multiplier (multiplied with the per-layer color and passed to the material as a vertex color)
        
        Args:
            new_color (LinearColor):
        """
        ...
    def set_tile_map(self, new_tile_map: PaperTileMap) -> bool:
        r"""
        x.set_tile_map(new_tile_map) -> bool
        Change the PaperTileMap used by this instance.
        
        Args:
            new_tile_map (PaperTileMap): 
        
        Returns:
            bool:
        """
        ...
    def set_tile(self, x: int, y: int, layer: int = 0, new_value: PaperTileInfo = ...) -> None:
        r"""
        x.set_tile(x, y, layer=0, new_value) -> None
        Modifies the contents of a specified tile cell (Note: This will only work on components that own their own tile map (OwnsTileMap returns true), you cannot modify standalone tile map assets)
        Note: Does not update collision by default, call RebuildCollision after all edits have been done in a frame if necessary
        
        Args:
            x (int32): 
            y (int32): 
            layer (int32): 
            new_value (PaperTileInfo):
        """
        ...
    def set_layer_color(self, new_color: LinearColor, layer: int = 0) -> None:
        r"""
        x.set_layer_color(new_color, layer=0) -> None
        Sets the per-layer color multiplier for a specific layer (multiplied with the tile map color and passed to the material as a vertex color)
        Note: This will only work on components that own their own tile map (OwnsTileMap returns true), you cannot modify standalone tile map assets
        
        Args:
            new_color (LinearColor): 
            layer (int32):
        """
        ...
    def set_layer_collision(self, layer: int = 0, has_collision: bool = True, override_thickness: bool = True, custom_thickness: float = 50.000000, override_offset: bool = False, custom_offset: float = 0.000000, rebuild_collision: bool = True) -> None:
        r"""
        x.set_layer_collision(layer=0, has_collision=True, override_thickness=True, custom_thickness=50.000000, override_offset=False, custom_offset=0.000000, rebuild_collision=True) -> None
        Sets the collision thickness for a specific layer
        Note: This will only work on components that own their own tile map (OwnsTileMap returns true), you cannot modify standalone tile map assets
        
        Args:
            layer (int32): 
            has_collision (bool): 
            override_thickness (bool): 
            custom_thickness (float): 
            override_offset (bool): 
            custom_offset (float): 
            rebuild_collision (bool):
        """
        ...
    def set_default_collision_thickness(self, thickness: float, rebuild_collision: bool = True) -> None:
        r"""
        x.set_default_collision_thickness(thickness, rebuild_collision=True) -> None
        Sets the default thickness for any layers that don't override the collision thickness
        Note: This will only work on components that own their own tile map (OwnsTileMap returns true), you cannot modify standalone tile map assets
        
        Args:
            thickness (float): 
            rebuild_collision (bool):
        """
        ...
    def resize_map(self, new_width_in_tiles: int, new_height_in_tiles: int) -> None:
        r"""
        x.resize_map(new_width_in_tiles, new_height_in_tiles) -> None
        Resizes the tile map (Note: This will only work on components that own their own tile map (OwnsTileMap returns true), you cannot modify standalone tile map assets)
        
        Args:
            new_width_in_tiles (int32): 
            new_height_in_tiles (int32):
        """
        ...
    def rebuild_collision(self) -> None:
        r"""
        x.rebuild_collision() -> None
        Rebuilds collision for the tile map
        """
        ...
    def owns_tile_map(self) -> bool:
        r"""
        x.owns_tile_map() -> bool
        Does this component own the tile map (is it instanced instead of being an asset reference)?
        
        Returns:
            bool:
        """
        ...
    def make_tile_map_editable(self) -> None:
        r"""
        x.make_tile_map_editable() -> None
        Makes the tile map asset pointed to by this component editable.  Nothing happens if it was already instanced, but
        if the tile map is an asset reference, it is cloned to make a unique instance.
        """
        ...
    def get_tile_polygon(self, tile_x: int, tile_y: int, layer_index: int = 0, world_space: bool = False) -> Array[Vector]:
        r"""
        x.get_tile_polygon(tile_x, tile_y, layer_index=0, world_space=False) -> Array[Vector]
        Returns the polygon for the specified tile (will be 4 or 6 vertices as a rectangle, diamond, or hexagon)
        
        Args:
            tile_x (int32): 
            tile_y (int32): 
            layer_index (int32): 
            world_space (bool): 
        
        Returns:
            Array[Vector]: 
        
            points (Array[Vector]):
        """
        ...
    def get_tile_map_color(self) -> LinearColor:
        r"""
        x.get_tile_map_color() -> LinearColor
        Gets the tile map global color multiplier (multiplied with the per-layer color and passed to the material as a vertex color)
        
        Returns:
            LinearColor:
        """
        ...
    def get_tile_corner_position(self, tile_x: int, tile_y: int, layer_index: int = 0, world_space: bool = False) -> Vector:
        r"""
        x.get_tile_corner_position(tile_x, tile_y, layer_index=0, world_space=False) -> Vector
        Returns the position of the top left corner of the specified tile
        
        Args:
            tile_x (int32): 
            tile_y (int32): 
            layer_index (int32): 
            world_space (bool): 
        
        Returns:
            Vector:
        """
        ...
    def get_tile_center_position(self, tile_x: int, tile_y: int, layer_index: int = 0, world_space: bool = False) -> Vector:
        r"""
        x.get_tile_center_position(tile_x, tile_y, layer_index=0, world_space=False) -> Vector
        Returns the position of the center of the specified tile
        
        Args:
            tile_x (int32): 
            tile_y (int32): 
            layer_index (int32): 
            world_space (bool): 
        
        Returns:
            Vector:
        """
        ...
    def get_tile(self, x: int, y: int, layer: int = 0) -> PaperTileInfo:
        r"""
        x.get_tile(x, y, layer=0) -> PaperTileInfo
        Returns the contents of a specified tile cell
        
        Args:
            x (int32): 
            y (int32): 
            layer (int32): 
        
        Returns:
            PaperTileInfo:
        """
        ...
    def get_map_size(self) -> Tuple[int, int, int]:
        r"""
        x.get_map_size() -> (map_width=int32, map_height=int32, num_layers=int32)
        Returns the size of the tile map
        
        Returns:
            tuple: 
        
            map_width (int32): 
        
            map_height (int32): 
        
            num_layers (int32):
        """
        ...
    def get_layer_color(self, layer: int = 0) -> LinearColor:
        r"""
        x.get_layer_color(layer=0) -> LinearColor
        Gets the per-layer color multiplier for a specific layer (multiplied with the tile map color and passed to the material as a vertex color)
        
        Args:
            layer (int32): 
        
        Returns:
            LinearColor:
        """
        ...
    def create_new_tile_map(self, map_width: int = 4, map_height: int = 4, tile_width: int = 32, tile_height: int = 32, pixels_per_unreal_unit: float = 1.000000, create_layer: bool = True) -> None:
        r"""
        x.create_new_tile_map(map_width=4, map_height=4, tile_width=32, tile_height=32, pixels_per_unreal_unit=1.000000, create_layer=True) -> None
        Creates a new tile map of the specified size, replacing the TileMap reference (or dropping the previous owned one)
        
        Args:
            map_width (int32): Width of the map (in tiles)
            map_height (int32): Height of the map (in tiles)
            tile_width (int32): Width of one tile (in pixels)
            tile_height (int32): Height of one tile (in pixels)
            pixels_per_unreal_unit (float): 
            create_layer (bool): Should an empty layer be created?
        """
        ...
    def add_new_layer(self) -> PaperTileLayer:
        r"""
        x.add_new_layer() -> PaperTileLayer
        Creates and adds a new layer to the tile map
        Note: This will only work on components that own their own tile map (OwnsTileMap returns true), you cannot modify standalone tile map assets
        
        Returns:
            PaperTileLayer:
        """
        ...

class PaperTileMapRenderComponent(PaperTileMapComponent):
    r"""
    deprecated: 'PaperTileMapRenderComponent' was renamed to 'PaperTileMapComponent'.
    """
    ...

class PaperTileSet(Object):
    r"""
    A tile set is a collection of tiles pulled from a texture that can be used to fill out a tile map.
    see: UPaperTileMap, UPaperTileMapComponent
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTileSet.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_source_textures`` (Array[Texture]):  [Read-Write] Additional source textures for other slots
    - ``background_color`` (LinearColor):  [Read-Write] The background color displayed in the tile set viewer
    - ``border_margin`` (IntMargin):  [Read-Write] The amount of padding around the border of the tile sheet (in pixels)
    - ``drawing_offset`` (IntPoint):  [Read-Write] The drawing offset for tiles from this set (in pixels)
    - ``per_tile_data`` (Array[PaperTileMetadata]):  [Read-Write] Per-tile information
    - ``per_tile_spacing`` (IntPoint):  [Read-Write] The amount of padding between tiles in the tile sheet (in pixels)
    - ``tile_sheet`` (Texture2D):  [Read-Write] The tile sheet texture associated with this tile set
    - ``tile_size`` (IntPoint):  [Read-Write] The width and height of a single tile (in pixels)
    """
    @property
    def tile_size(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Only] The width and height of a single tile (in pixels)
        """
        ...
    @property
    def tile_sheet(self) -> Texture2D:
        r"""
        (Texture2D):  [Read-Only] The tile sheet texture associated with this tile set
        """
        ...
    @property
    def border_margin(self) -> IntMargin:
        r"""
        (IntMargin):  [Read-Only] The amount of padding around the border of the tile sheet (in pixels)
        """
        ...
    @property
    def per_tile_spacing(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Only] The amount of padding between tiles in the tile sheet (in pixels)
        """
        ...
    @property
    def drawing_offset(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Only] The drawing offset for tiles from this set (in pixels)
        """
        ...

class MaterialExpressionSpriteTextureSampler(MaterialExpressionTextureSampleParameter2D):
    r"""
    This is a texture sampler 2D with a special automatically defined parameter name. The texture specified here will be replaced by the SourceTexture or an AdditionalSourceTextures entry of a Paper2D sprite if this material is used on a sprite.
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: MaterialExpressionSpriteTextureSampler.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``additional_slot_index`` (int32):  [Read-Write] This is the slot index into the AdditionalSourceTextures array
    - ``automatic_view_mip_bias`` (bool):  [Read-Write] Whether the texture should be sampled with per view mip biasing for sharper output with Temporal AA.
    - ``channel_names`` (ParameterChannelNames):  [Read-Write]
    - ``const_coordinate`` (uint8):  [Read-Write] only used if Coordinates is not hooked up
    - ``const_mip_value`` (int32):  [Read-Write] only used if MipValue is not hooked up
    - ``desc`` (str):  [Read-Write] A description that level designers can add (shows in the material editor UI).
    - ``group`` (Name):  [Read-Write] The name of the parameter Group to display in MaterialInstance Editor. Default is None group
    - ``is_default_meshpaint_texture`` (bool):  [Read-Write] Is default selected texture when using mesh paint mode texture painting
    - ``material_expression_editor_x`` (int32):  [Read-Write]
    - ``material_expression_editor_y`` (int32):  [Read-Write]
    - ``mip_value_mode`` (TextureMipValueMode):  [Read-Write] Defines how the MipValue property is applied to the texture lookup
    - ``parameter_name`` (Name):  [Read-Write]
    - ``sample_additional_textures`` (bool):  [Read-Write] Is this a sampler for the default SourceTexture or the AdditionalSourceTextures list?
    - ``sampler_source`` (SamplerSourceMode):  [Read-Write] Controls where the sampler for this texture lookup will come from.
      Choose 'from texture asset' to make use of the UTexture addressing settings,
      Otherwise use one of the global samplers, which will not consume a sampler slot.
      This allows materials to use more than 16 unique textures on SM5 platforms.
    - ``sampler_type`` (MaterialSamplerType):  [Read-Write]
    - ``slot_display_name`` (Text):  [Read-Write] Friendly label for the texture slot, displayed in the Sprite Editor if not empty
    - ``sort_priority`` (int32):  [Read-Write] Controls where the this parameter is displayed in a material instance parameter list.  The lower the number the higher up in the parameter list.
    - ``texture`` (Texture):  [Read-Write]
    """
    ...

class PaperTerrainActor(Actor):
    r"""
    An instance of a piece of 2D terrain in the level
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTerrainActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``render_component`` (PaperTerrainComponent):  [Read-Only]
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def render_component(self) -> PaperTerrainComponent:
        r"""
        (PaperTerrainComponent):  [Read-Only]
        """
        ...

class PaperTerrainComponent(PrimitiveComponent):
    r"""
    The terrain visualization component for an associated spline component.
    This takes a 2D terrain material and instances sprite geometry along the spline path.
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTerrainComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``closed_spline`` (bool):  [Read-Write]
    - ``collision_thickness`` (float):  [Read-Write] The extrusion thickness of collision geometry when using a 3D collision domain
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``filled_spline`` (bool):  [Read-Write]
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``random_seed`` (int32):  [Read-Write] Random seed used for choosing which spline meshes to use.
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``reparam_steps_per_segment`` (int32):  [Read-Write] Number of steps per spline segment to place in the reparameterization table
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``segment_overlap_amount`` (float):  [Read-Write] The overlap amount between segments
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sprite_collision_domain`` (SpriteCollisionMode):  [Read-Write] Collision domain (no collision, 2D (experimental), or 3D)
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``terrain_color`` (LinearColor):  [Read-Write] The color of the terrain (passed to the sprite material as a vertex color)
    - ``terrain_material`` (PaperTerrainMaterial):  [Read-Write] The terrain material to apply to this component (set of rules for which sprites are used on different surfaces or the interior)
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    @property
    def terrain_material(self) -> PaperTerrainMaterial:
        r"""
        (PaperTerrainMaterial):  [Read-Only] The terrain material to apply to this component (set of rules for which sprites are used on different surfaces or the interior)
        """
        ...
    @property
    def closed_spline(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def filled_spline(self) -> bool:
        r"""
        (bool):  [Read-Only]
        """
        ...
    @property
    def terrain_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Only] The color of the terrain (passed to the sprite material as a vertex color)
        """
        ...
    def set_terrain_color(self, new_color: LinearColor) -> None:
        r"""
        x.set_terrain_color(new_color) -> None
        Set color of the terrain
        
        Args:
            new_color (LinearColor):
        """
        ...

class PaperTerrainMaterial(DataAsset):
    r"""
    Paper Terrain Material
    
    'Material' setup for a 2D terrain spline (stores references to sprites that will be instanced along the spline path, not actually related to UMaterialInterface).
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTerrainMaterial.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``interior_fill`` (PaperSprite):  [Read-Write] The sprite to use for an interior region fill
    - ``rules`` (Array[PaperTerrainMaterialRule]):  [Read-Write]
    """
    ...

class PaperTerrainSplineComponent(SplineComponent):
    r"""
    
    TODO:: Document
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: PaperTerrainSplineComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``adjust_tangents_on_snap`` (bool):  [Read-Write] Adjust tangents after snapping.
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``allow_discontinuous_spline`` (bool):  [Read-Write] Whether the spline's leave and arrive tangents can be different
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``closed_loop`` (bool):  [Read-Write] Whether the spline is to be considered as a closed loop.
      Use SetClosedLoop() to set this property, and IsClosedLoop() to read it.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``default_up_vector`` (Vector):  [Read-Write] Default up vector in local space to be used when calculating transforms along the spline
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``draw_debug`` (bool):  [Read-Write] If true, the spline will be rendered if the Splines showflag is set.
    - ``duration`` (float):  [Read-Write] Specifies the duration of the spline in seconds
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``editor_selected_spline_segment_color`` (LinearColor):  [Read-Write] Color of selected spline component parts in the editor
    - ``editor_tangent_color`` (LinearColor):  [Read-Write] Color of spline point tangents in the editor
    - ``editor_unselected_spline_segment_color`` (LinearColor):  [Read-Write] Color of unselected spline component parts in the editor
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``input_spline_points_to_construction_script`` (bool):  [Read-Write] Whether the spline points should be passed to the User Construction Script so they can be further manipulated by it.
      If false, they will not be visible to it, and it will not be able to influence the per-instance positions set in the editor.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``loop_position`` (float):  [Read-Write]
    - ``loop_position_override`` (bool):  [Read-Write]
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``reparam_steps_per_segment`` (int32):  [Read-Write] Number of steps per spline segment to place in the reparameterization table
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``scale_visualization_width`` (float):  [Read-Write] Width of spline in editor for use with scale visualization
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``should_visualize_scale`` (bool):  [Read-Write] Whether scale visualization should be displayed
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``spline_curves`` (SplineCurves):  [Read-Write]
    - ``spline_has_been_edited`` (bool):  [Read-Write] Whether the spline has been edited from its default by the spline component visualizer
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``stationary_endpoints`` (bool):  [Read-Write] Whether the endpoints of the spline are considered stationary when traversing the spline at non-constant velocity.  Essentially this sets the endpoints' tangents to zero vectors.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class TileMapLibrary(BlueprintFunctionLibrary):
    r"""
    A collection of utility methods for working with tile map components
    see: UPaperTileMap, UPaperTileMapComponent
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2D
    - **File**: TileMapBlueprintLibrary.h
    
    """
    @classmethod
    def make_tile(cls, tile_index: int, tile_set: PaperTileSet, flip_h: bool, flip_v: bool, flip_d: bool) -> PaperTileInfo:
        r"""
        X.make_tile(tile_index, tile_set, flip_h, flip_v, flip_d) -> PaperTileInfo
        Creates a tile from the specified information
        
        Args:
            tile_index (int32): 
            tile_set (PaperTileSet): 
            flip_h (bool): 
            flip_v (bool): 
            flip_d (bool): 
        
        Returns:
            PaperTileInfo:
        """
        ...
    @classmethod
    def get_tile_user_data(cls, tile: PaperTileInfo) -> Name:
        r"""
        X.get_tile_user_data(tile) -> Name
        Returns the user data name for the specified tile, or NAME_None if there is no user-specified data
        
        Args:
            tile (PaperTileInfo): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def get_tile_transform(cls, tile: PaperTileInfo) -> Transform:
        r"""
        X.get_tile_transform(tile) -> Transform
        Returns the transform for a tile
        
        Args:
            tile (PaperTileInfo): 
        
        Returns:
            Transform:
        """
        ...
    @classmethod
    def break_tile(cls, tile: PaperTileInfo) -> Tuple[int, PaperTileSet, bool, bool, bool]:
        r"""
        X.break_tile(tile) -> (tile_index=int32, tile_set=PaperTileSet, flip_h=bool, flip_v=bool, flip_d=bool)
        Breaks out the information for a tile
        
        Args:
            tile (PaperTileInfo): 
        
        Returns:
            tuple: 
        
            tile_index (int32): 
        
            tile_set (PaperTileSet): 
        
            flip_h (bool): 
        
            flip_v (bool): 
        
            flip_d (bool):
        """
        ...

class AudioCurveSourceComponent(AudioComponent):
    r"""
    An audio component that also provides curves to drive animation
    
    **C++ Source:**
    
    - **Plugin**: FacialAnimation
    - **Module**: FacialAnimation
    - **File**: AudioCurveSourceComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``allow_spatialization`` (bool):  [Read-Write] Overrides spatialization enablement in either the attenuation asset or on this audio component's attenuation settings override.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_attach_location_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our location when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_parent`` (SceneComponent):  [Read-Only] Component we automatically attach to when activated, if bAutoManageAttachment is true.
      If null during registration, we assign the existing AttachParent and defer attachment until we activate.
      see: bAutoManageAttachment
    - ``auto_attach_rotation_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our rotation when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_scale_rule`` (AttachmentRule):  [Read-Write] Options for how we handle our scale when we attach to the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment, EAttachmentRule
    - ``auto_attach_socket_name`` (Name):  [Read-Write] Socket we automatically attach to on the AutoAttachParent, if bAutoManageAttachment is true.
      see: bAutoManageAttachment
    - ``auto_manage_attachment`` (bool):  [Read-Write] True if we should automatically attach to AutoAttachParent when Played, and detach from our parent when playback is completed.
      This overrides any current attachment that may be present at the time of activation (deferring initial attachment until activation, if AutoAttachParent is null).
      If enabled, this AudioComponent's WorldLocation will no longer be reliable when not currently playing audio, and any attach children will also be
      detached/attached along with it.
      When enabled, detachment occurs regardless of whether AutoAttachParent is assigned, and the relative transform from the time of activation is restored.
      This also disables attachment on dedicated servers, where we don't actually activate even if bAutoActivate is true.
      see: AutoAttachParent, AutoAttachSocketName, AutoAttachLocationType
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``can_play_multiple_instances`` (bool):  [Read-Write] If true, the Audio Component will play multiple sound instances at once. Switching sounds or calling play while already playing
      will not stop already active instances. Virtualization for all played sounds will be disabled. Disabling while sound(s) are playing
      will not take effect until the AudioComponent is stopped and restarted.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] What sound concurrency rules to use for sounds generated by this audio component
    - ``curve_source_binding_name`` (Name):  [Read-Write] Get the name that this curve source can be bound to by.
      Clients of this curve source will use this name to identify this source.
    - ``curve_sync_offset`` (float):  [Read-Write] Offset in time applied to audio position when evaluating curves
    - ``default_parameters`` (Array[AudioParameter]):  [Read-Write] Array of parameters for this AudioComponent. Changes to this array directly will
      not be forwarded to the sound if the component is actively playing, and will be superseded
      by parameters set via the actor interface if set, or the instance parameters.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disable_parameter_updates_while_playing`` (bool):  [Read-Write] If true, the Audio Component will ignore parameter updates for already-playing sound(s).
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_low_pass_filter`` (bool):  [Read-Write] Whether or not to apply a low-pass filter to the sound that plays in this audio component.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``low_pass_filter_frequency`` (float):  [Read-Write] If enabled, the frequency of the Lowpass Filter (in Hz) to apply to this voice. A frequency of 0.0 is the device sample rate and will bypass the filter.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulation_routing`` (SoundModulationDefaultRoutingSettings):  [Read-Write]
    - ``on_audio_finished`` (OnAudioFinished):  [Read-Write] Called when we finish playing audio, either because it played to completion or because a Stop() call turned it off early
    - ``on_audio_multi_envelope_value`` (OnAudioMultiEnvelopeValue):  [Read-Write]
    - ``on_audio_play_state_changed`` (OnAudioPlayStateChanged):  [Read-Write] This function returns the Targeted Audio Component's current Play State.
      Playing, if the sound is currently playing.
      Stopped, if the sound is stopped.
      Paused, if the sound is currently playing, but paused.
      Fading In, if the sound is in the process of Fading In.
      Fading Out, if the sound is in the process of Fading Out.
    - ``on_audio_playback_percent`` (OnAudioPlaybackPercent):  [Read-Write] Called as a sound plays on the audio component to allow BP to perform actions based on playback percentage.
      Computed as samples played divided by total samples, taking into account pitch.
      Not currently implemented on all platforms.
    - ``on_audio_single_envelope_value`` (OnAudioSingleEnvelopeValue):  [Read-Write]
    - ``on_audio_virtualization_changed`` (OnAudioVirtualizationChanged):  [Read-Write] Called when virtualization state changes
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``override_attenuation`` (bool):  [Read-Write] Allows defining attenuation settings directly on this audio component without using an attenuation settings asset.
    - ``override_priority`` (bool):  [Read-Write] Whether or not to override the priority of the given sound with the value provided.
    - ``override_subtitle_priority`` (bool):  [Read-Write] Whether or not to override the sound's subtitle priority.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pitch_modulation_max`` (float):  [Read-Write] The upper bound to use when randomly determining a pitch multiplier
    - ``pitch_modulation_min`` (float):  [Read-Write] The lower bound to use when randomly determining a pitch multiplier
    - ``pitch_multiplier`` (float):  [Read-Write] A pitch multiplier to apply to sounds generated by this component
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``priority`` (float):  [Read-Write] If enabled, overrides the priority of the selected sound with the value provided.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sound`` (SoundBase):  [Read-Write] The sound to be played
    - ``sound_class_override`` (SoundClass):  [Read-Write] SoundClass that overrides that set on the referenced SoundBase when component is played.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The chain of Source Effects to apply to the sounds playing on the Audio Component
    - ``subtitle_priority`` (float):  [Read-Write] Used by the subtitle manager to prioritize subtitles wave instances spawned by this component.
    - ``suppress_subtitles`` (bool):  [Read-Write] If true, subtitles in the sound data will be ignored.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``volume_modulation_max`` (float):  [Read-Write] The upper bound to use when randomly determining a volume multiplier
    - ``volume_modulation_min`` (float):  [Read-Write] The lower bound to use when randomly determining a volume multiplier
    - ``volume_multiplier`` (float):  [Read-Write] A volume multiplier to apply to sounds generated by this component
    """
    @property
    def curve_source_binding_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Get the name that this curve source can be bound to by.
        Clients of this curve source will use this name to identify this source.
        """
        ...
    @curve_source_binding_name.setter
    def curve_source_binding_name(self, value: Name) -> None:
        ...
    @property
    def curve_sync_offset(self) -> float:
        r"""
        (float):  [Read-Write] Offset in time applied to audio position when evaluating curves
        """
        ...
    @curve_sync_offset.setter
    def curve_sync_offset(self, value: float) -> None:
        ...
    def get_curve_value(self, curve_name: Name) -> float:
        r"""
        x.get_curve_value(curve_name) -> float
        Get the value for a specified curve
        
        Args:
            curve_name (Name): 
        
        Returns:
            float:
        """
        ...
    def get_curves(self) -> Array[NamedCurveValue]:
        r"""
        x.get_curves() -> Array[NamedCurveValue]
        Evaluate all curves that this source provides
        
        Returns:
            Array[NamedCurveValue]: 
        
            out_values (Array[NamedCurveValue]):
        """
        ...
    def get_binding_name(self) -> Name:
        r"""
        x.get_binding_name() -> Name
        Get the name that this curve source can be bound to by.
        Clients of this curve source will use this name to identify this source.
        
        Returns:
            Name:
        """
        ...

class EditorValidatorBase(Object):
    r"""
    * The EditorValidatorBase is a class which verifies that an asset meets a specific ruleset.
    * It should be used when checking engine-level classes, as UObject::IsDataValid requires
    * overriding the base class. You can create project-specific version of the validator base,
    * with custom logging and enabled logic.
    *
    * C++ and Blueprint validators will be gathered on editor start, while python validators need
    * to register themselves
    
    **C++ Source:**
    
    - **Plugin**: DataValidation
    - **Module**: DataValidation
    - **File**: EditorValidatorBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_enabled`` (bool):  [Read-Write]
    - ``only_print_custom_message`` (bool):  [Read-Write] Whether we should also print out the source validator when printing validation errors.
    """
    def k2_validate_loaded_asset(self, asset: Object) -> DataValidationResult:
        r"""
        x.k2_validate_loaded_asset(asset) -> DataValidationResult
        Override this in blueprint to validate assets
        
        Args:
            asset (Object): 
        
        Returns:
            DataValidationResult:
        """
        ...
    def validate_loaded_asset(self, asset: Object) -> DataValidationResult:
        r"""
        deprecated: 'validate_loaded_asset' was renamed to 'k2_validate_loaded_asset'.
        """
        ...
    def k2_can_validate_asset(self, asset: Object) -> bool:
        r"""
        x.k2_can_validate_asset(asset) -> bool
        Override this to determine whether or not you can validate a given asset with this validator
        
        Args:
            asset (Object): 
        
        Returns:
            bool:
        """
        ...
    def can_validate_asset(self, asset: Object) -> bool:
        r"""
        deprecated: 'can_validate_asset' was renamed to 'k2_can_validate_asset'.
        """
        ...
    def k2_can_validate(self, usecase: DataValidationUsecase) -> bool:
        r"""
        x.k2_can_validate(usecase) -> bool
        Override this to determine whether or not you can use this validator given this usecase
        
        Args:
            usecase (DataValidationUsecase): 
        
        Returns:
            bool:
        """
        ...
    def can_validate(self, usecase: DataValidationUsecase) -> bool:
        r"""
        deprecated: 'can_validate' was renamed to 'k2_can_validate'.
        """
        ...
    def get_validation_result(self) -> DataValidationResult:
        r"""
        x.get_validation_result() -> DataValidationResult
        Get Validation Result
        
        Returns:
            DataValidationResult:
        """
        ...
    def asset_warning(self, asset: Object, message: Text) -> None:
        r"""
        x.asset_warning(asset, message) -> None
        Adds a message to this validation but doesn't mark it as failed.
        
        Args:
            asset (Object): 
            message (Text):
        """
        ...
    def asset_passes(self, asset: Object) -> None:
        r"""
        x.asset_passes(asset) -> None
        Marks the validation as successful. Failure to call this will report the validator as not having checked the asset.
        
        Args:
            asset (Object):
        """
        ...
    def asset_fails(self, asset: Object, message: Text) -> None:
        r"""
        x.asset_fails(asset, message) -> None
        Marks the validation as failed and adds an error message.
        
        Args:
            asset (Object): 
            message (Text):
        """
        ...

class DirtyFilesChangelistValidator(EditorValidatorBase):
    r"""
    Validates there is no unsaved files in the changelist about to be submitted.
    
    **C++ Source:**
    
    - **Plugin**: DataValidation
    - **Module**: DataValidation
    - **File**: DirtyFilesChangelistValidator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_enabled`` (bool):  [Read-Write]
    - ``only_print_custom_message`` (bool):  [Read-Write] Whether we should also print out the source validator when printing validation errors.
    """
    ...

class EditorValidatorSubsystem(EditorSubsystem):
    r"""
    UEditorValidatorSubsystem manages all the asset validation in the engine.
    
    The first validation handled is UObject::IsDataValid and its overridden functions.
    Those validations require custom classes and are most suited to project-specific
    classes.
    
    The next validation set is of all registered UEditorValidationBases. These validators
    have a function to determine if they can validate a given asset, and if they are
    currently enabled. They are good candidates for validating engine classes or
    very specific project logic.
    
    Finally, this subsystem may be subclassed to change the overally behavior of
    validation in your project. If a subclass exist in your project module, it will
    supercede the engine validation subsystem.
    
    **C++ Source:**
    
    - **Plugin**: DataValidation
    - **Module**: DataValidation
    - **File**: EditorValidatorSubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``validate_on_save`` (bool):  [Read-Write] Whether it should validate assets on save inside the editor
      deprecated: Use bValidateOnSave on UDataValidationSettings instead.
    """
    @property
    def validate_on_save(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether it should validate assets on save inside the editor
        deprecated: Use bValidateOnSave on UDataValidationSettings instead.
        """
        ...
    @validate_on_save.setter
    def validate_on_save(self, value: bool) -> None:
        ...
    def validate_changelists(self, changelists: Array[DataValidationChangelist], settings: ValidateAssetsSettings) -> Tuple[DataValidationResult, ValidateAssetsResults]:
        r"""
        x.validate_changelists(changelists, settings) -> (DataValidationResult, out_results=ValidateAssetsResults)
        Validate Changelists
        
        Args:
            changelists (Array[DataValidationChangelist]): 
            settings (ValidateAssetsSettings): 
        
        Returns:
            ValidateAssetsResults: 
        
            out_results (ValidateAssetsResults):
        """
        ...
    def validate_changelist(self, changelist: DataValidationChangelist, settings: ValidateAssetsSettings) -> Tuple[DataValidationResult, ValidateAssetsResults]:
        r"""
        x.validate_changelist(changelist, settings) -> (DataValidationResult, out_results=ValidateAssetsResults)
        Called to validate assets from either the UI or a commandlet.
        Loads the specified assets and runs all registered validators on them.
        Populates the message log with errors and warnings with clickable links.
        
        Args:
            changelist (DataValidationChangelist): 
            settings (ValidateAssetsSettings): Structure passing context and settings for ValidateAssetsWithSettings
        
        Returns:
            ValidateAssetsResults: Validation results for the changelist object itself
        
            out_results (ValidateAssetsResults): More detailed information about the results of the validate assets command
        """
        ...
    def validate_assets_with_settings(self, asset_data_list: Array[AssetData]) -> Tuple[int, ValidateAssetsSettings, ValidateAssetsResults]:
        r"""
        x.validate_assets_with_settings(asset_data_list) -> (int32, settings=ValidateAssetsSettings, out_results=ValidateAssetsResults)
        Called to validate assets from either the UI or a commandlet.
        Loads the specified assets and runs all registered validators on them.
        Populates the message log with errors and warnings with clickable links.
        
        Args:
            asset_data_list (Array[AssetData]): 
        
        Returns:
            tuple: Number of assets with validation failures or warnings
        
            settings (ValidateAssetsSettings): Structure passing context and settings for ValidateAssetsWithSettings
        
            out_results (ValidateAssetsResults): More detailed information about the results of the validate assets command
        """
        ...
    def remove_validator(self, validator: EditorValidatorBase) -> None:
        r"""
        x.remove_validator(validator) -> None
        * Removes a validator
        * Should be called during module shutdown if a validator was added.
        
        Args:
            validator (EditorValidatorBase):
        """
        ...
    def is_object_valid(self, object: Object, validation_usecase: DataValidationUsecase) -> Tuple[DataValidationResult, Array[Text], Array[Text]]:
        r"""
        x.is_object_valid(object, validation_usecase) -> (DataValidationResult, validation_errors=Array[Text], validation_warnings=Array[Text])
        Runs registered validators on the provided object.
        Does not add anything to any FMessageLog tabs.
        
        Args:
            object (Object): 
            validation_usecase (DataValidationUsecase): 
        
        Returns:
            tuple: Returns Valid if the object contains valid data; returns Invalid if the object contains invalid data; returns NotValidated if no validations was performed on the object
        
            validation_errors (Array[Text]): 
        
            validation_warnings (Array[Text]):
        """
        ...
    def is_asset_valid(self, asset_data: AssetData, validation_usecase: DataValidationUsecase) -> Tuple[DataValidationResult, Array[Text], Array[Text]]:
        r"""
        x.is_asset_valid(asset_data, validation_usecase) -> (DataValidationResult, validation_errors=Array[Text], validation_warnings=Array[Text])
        Loads the object referred to by the provided AssetData and runs registered validators on it.
        Does not add anything to any FMessageLog tabs.
        
        Args:
            asset_data (AssetData): 
            validation_usecase (DataValidationUsecase): 
        
        Returns:
            tuple: Returns Valid if the object pointed to by AssetData contains valid data; returns Invalid if the object contains invalid data or does not exist; returns NotValidated if no validations was performed on the object
        
            validation_errors (Array[Text]): 
        
            validation_warnings (Array[Text]):
        """
        ...
    def add_validator(self, validator: EditorValidatorBase) -> None:
        r"""
        x.add_validator(validator) -> None
        * Adds a validator to the list, making sure it is a unique instance
        
        Args:
            validator (EditorValidatorBase):
        """
        ...

class EditorValidator_Localization(EditorValidatorBase):
    r"""
    * Validates that localized assets (within the L10N folder) conform to a corresponding source asset of the correct type.
    * Localized assets that fail this validation will never be loaded as localized variants at runtime.
    
    **C++ Source:**
    
    - **Plugin**: DataValidation
    - **Module**: DataValidation
    - **File**: EditorValidator_Localization.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_enabled`` (bool):  [Read-Write]
    - ``only_print_custom_message`` (bool):  [Read-Write] Whether we should also print out the source validator when printing validation errors.
    """
    ...

class WorldPartitionChangelistValidator(EditorValidatorBase):
    r"""
    World Partition Changelist Validator
    
    **C++ Source:**
    
    - **Plugin**: DataValidation
    - **Module**: DataValidation
    - **File**: WorldPartitionChangelistValidator.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_enabled`` (bool):  [Read-Write]
    - ``only_print_custom_message`` (bool):  [Read-Write] Whether we should also print out the source validator when printing validation errors.
    """
    ...

class DataValidationChangelist(Object):
    r"""
    Changelist abstraction to allow changelist-level data validation
    
    **C++ Source:**
    
    - **Plugin**: DataValidation
    - **Module**: DataValidation
    - **File**: DataValidationChangelist.h
    
    """
    ...

class RetargetOpBase(Object):
    r"""
    Retarget Op Base
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetOps.h
    
    """
    ...

class CurveRemapOp(RetargetOpBase):
    r"""
    Curve Remap Op
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: CurveRemapOp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``copy_all_source_curves`` (bool):  [Read-Write] This setting only applies to all curves when exporting retargeted animations.
      True: all source curves are copied to the target animation sequence asset.
      False: only remapped curves are left on the target animation sequence asset.
    - ``curves_to_remap`` (Array[CurveRemapPair]):  [Read-Write] Add pairs of Source/Target curve names to remap. While retargeting, the animation from the source curves
      will be redirected to the curves on the target skeletal meshes. Can be used to drive, blendshapes or other downstream systems.
      NOTE: By default the IK Retargeter will automatically copy all equivalently named curves from the source to the
      target. Remapping with this op is only necessary when the target curve name(s) are different.
    """
    ...

class RetargetOpStack(Object):
    r"""
    wrapper around a TArray of Retarget Ops for display in details panel
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargetOps.h
    
    """
    ...

class IKGoalCreatorInterface(Interface):
    r"""
    IKGoal Creator Interface
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRigInterface.h
    
    """
    def add_ik_goals(self) -> Map[Name, IKRigGoal]:
        r"""
        x.add_ik_goals() -> Map[Name, IKRigGoal]
        Add your own goals to the OutGoals map (careful not to remove existing goals in the map!)
        
        Returns:
            Map[Name, IKRigGoal]: 
        
            out_goals (Map[Name, IKRigGoal]):
        """
        ...

class PinBoneOp(RetargetOpBase):
    r"""
    Pin Bone Op
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: PinBoneOp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bones_to_pin`` (Array[PinBoneData]):  [Read-Write]
    - ``global_offset`` (Transform):  [Read-Write] A manual offset to apply in global space
    - ``local_offset`` (Transform):  [Read-Write] A manual offset to apply in local space
    - ``maintain_offset`` (bool):  [Read-Write] Maintain the original offset between the BoneToPin and BoneToPinTo
    - ``pin_to`` (RetargetSourceOrTarget):  [Read-Write] The bone, on the target skeleton to pin to.
    - ``pin_type`` (PinBoneType):  [Read-Write] Apply this pin to the full transform, or just translation or rotation only.
    """
    ...

class RootMotionGeneratorOp(RetargetOpBase):
    r"""
    Root Motion Generator Op
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: RootMotionGeneratorOp.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``global_offset`` (Transform):  [Read-Write] A manual offset to apply in global space to the root bone.
    - ``maintain_offset_from_pelvis`` (bool):  [Read-Write] Applies only when generating root motion from the Pelvis.
      Maintains the offset between the root and pelvis as recorded in the target retarget pose.
      If false, the root bone is placed directly under the Pelvis bone.
    - ``propagate_to_non_retargeted_children`` (bool):  [Read-Write] Will transform all children of the target root that are not themselves part of a retarget chain.
    - ``root_height_source`` (RootMotionHeightSource):  [Read-Write] How to set the height of the root bone.
      Copy Height From Source: copies the height of the root bone on the source skeleton's root bone.
      Snap To Ground: sets the root bone height to the ground plane (Z=0).
    - ``root_motion_source`` (RootMotionSource):  [Read-Write] Where to copy the root motion from.
      Copy From Source Root: copies the motion from the source root bone, but scales it according to relative height difference.
      Generate From Target Pelvis: uses the retargeted Pelvis motion to generate root motion.
      NOTE: Generating root motion from the Pelvis
    - ``rotate_with_pelvis`` (bool):  [Read-Write] Applies only when generating root motion from the Pelvis.
      When true, the applied offset will be rotated by the Pelvis.
      (NOTE: This may cause unwanted rotations, for example if Pelvis Yaw is animated.)
    - ``source_root_bone`` (Name):  [Read-Write] The root of the source skeleton.
    - ``target_pelvis_bone`` (Name):  [Read-Write] The pelvis of the target skeleton.
    - ``target_root_bone`` (Name):  [Read-Write] The root of the target skeleton.
    """
    ...

class IKRigComponent(ActorComponent):
    r"""
    IKRig Component
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRigComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    def set_ik_rig_goal_transform(self, goal_name: Name, transform: Transform, position_alpha: float, rotation_alpha: float) -> None:
        r"""
        x.set_ik_rig_goal_transform(goal_name, transform, position_alpha, rotation_alpha) -> None
        Set an IK Rig Goal transform (assumed in Component Space of Skeletal Mesh) with separate alpha values.
        
        Args:
            goal_name (Name): 
            transform (Transform): 
            position_alpha (float): 
            rotation_alpha (float):
        """
        ...
    def set_ik_rig_goal_position_and_rotation(self, goal_name: Name, position: Vector, rotation: Quat, position_alpha: float, rotation_alpha: float) -> None:
        r"""
        x.set_ik_rig_goal_position_and_rotation(goal_name, position, rotation, position_alpha, rotation_alpha) -> None
        Set an IK Rig Goal position and rotation (assumed in Component Space of Skeletal Mesh) with separate alpha values.
        
        Args:
            goal_name (Name): 
            position (Vector): 
            rotation (Quat): 
            position_alpha (float): 
            rotation_alpha (float):
        """
        ...
    def set_ik_rig_goal(self, goal: IKRigGoal) -> None:
        r"""
        x.set_ik_rig_goal(goal) -> None
        Apply a IKRigGoal and store it on this rig. Goal transform assumed in Component Space of Skeletal Mesh.
        
        Args:
            goal (IKRigGoal):
        """
        ...
    def clear_all_goals(self) -> None:
        r"""
        x.clear_all_goals() -> None
        Remove all stored goals in this component.
        """
        ...
    def add_ik_goals(self) -> Map[Name, IKRigGoal]:
        r"""
        x.add_ik_goals() -> Map[Name, IKRigGoal]
        Add your own goals to the OutGoals map (careful not to remove existing goals in the map!)
        
        Returns:
            Map[Name, IKRigGoal]: 
        
            out_goals (Map[Name, IKRigGoal]):
        """
        ...

class RetargetChainSettings(Object):
    r"""
    Retarget Chain Settings
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargeter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (TargetChainSettings):  [Read-Write] The settings used to control the motion on this target chain.
    - ``source_chain`` (Name):  [Read-Only] The chain on the Source IK Rig asset to copy animation FROM.
    - ``target_chain`` (Name):  [Read-Only] The chain on the Target IK Rig asset to copy animation TO.
    """
    @property
    def source_chain(self) -> Name:
        r"""
        (Name):  [Read-Only] The chain on the Source IK Rig asset to copy animation FROM.
        """
        ...
    @property
    def target_chain(self) -> Name:
        r"""
        (Name):  [Read-Only] The chain on the Target IK Rig asset to copy animation TO.
        """
        ...
    @property
    def settings(self) -> TargetChainSettings:
        r"""
        (TargetChainSettings):  [Read-Write] The settings used to control the motion on this target chain.
        """
        ...
    @settings.setter
    def settings(self, value: TargetChainSettings) -> None:
        ...

class RetargetRootSettings(Object):
    r"""
    Retarget Root Settings
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargeter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (TargetRootSettings):  [Read-Write] The settings used to control the motion of the target root bone.
    """
    ...

class IKRetargetGlobalSettings(Object):
    r"""
    IKRetarget Global Settings
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargeter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``settings`` (RetargetGlobalSettings):  [Read-Write] Global retargeter settings.
    """
    ...

class IKRetargeter(Object):
    r"""
    IKRetargeter
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRetargeter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``chain_draw_size`` (float):  [Read-Write] The visual size of the IK goals in the viewport.
    - ``chain_draw_thickness`` (float):  [Read-Write] The thickness of lines on the IK goals in the viewport.
    - ``debug_draw`` (bool):  [Read-Write] Toggle debug drawing for retargeting in the viewport.
    - ``draw_final_goals`` (bool):  [Read-Write] Draw final IK goal locations.
    - ``draw_source_locations`` (bool):  [Read-Write] Draw goal locations from source skeleton.
    - ``ignore_root_lock_in_preview`` (bool):  [Read-Write] When true, animation sequences with "Force Root Lock" turned On will act as though it is Off.
      This affects only the preview in the retarget editor. Use ExportRootLockMode to control exported animation behavior.
      This setting has no effect on runtime retargeting where root motion is copied from the source component.
    - ``source_ik_rig_asset`` (IKRigDefinition):  [Read-Write] The rig to copy animation FROM.
    - ``source_mesh_offset`` (Vector):  [Read-Write] The offset applied to the source mesh in the editor viewport.
    - ``source_preview_mesh`` (SkeletalMesh):  [Read-Write] Optional. Override the Skeletal Mesh to copy animation from. Uses the preview mesh from the Source IK Rig asset by default.
    - ``target_ik_rig_asset`` (IKRigDefinition):  [Read-Write] The rig to copy animation TO.
    - ``target_mesh_offset`` (Vector):  [Read-Write] The offset applied to the target mesh in the editor viewport.
    - ``target_mesh_scale`` (float):  [Read-Write] Scale the target mesh in the viewport for easier visualization next to the source.
    - ``target_preview_mesh`` (SkeletalMesh):  [Read-Write] Optional. Override the Skeletal Mesh to preview the retarget on. Uses the preview mesh from the Target IK Rig asset by default.
    """
    @classmethod
    def set_root_settings_in_retarget_profile(cls, retarget_profile: RetargetProfile, root_settings: TargetRootSettings) -> RetargetProfile:
        r"""
        X.set_root_settings_in_retarget_profile(retarget_profile, root_settings) -> RetargetProfile
        Set the root settings in a retarget profile (will set bApplyRootSettings to true).
        
        Args:
            retarget_profile (RetargetProfile): 
            root_settings (TargetRootSettings): 
        
        Returns:
            RetargetProfile: 
        
            retarget_profile (RetargetProfile):
        """
        ...
    @classmethod
    def set_global_settings_in_retarget_profile(cls, retarget_profile: RetargetProfile, global_settings: RetargetGlobalSettings) -> RetargetProfile:
        r"""
        X.set_global_settings_in_retarget_profile(retarget_profile, global_settings) -> RetargetProfile
        Set the global settings in a retarget profile (will set bApplyGlobalSettings to true).
        
        Args:
            retarget_profile (RetargetProfile): 
            global_settings (RetargetGlobalSettings): 
        
        Returns:
            RetargetProfile: 
        
            retarget_profile (RetargetProfile):
        """
        ...
    @classmethod
    def set_chain_speed_plant_settings_in_retarget_profile(cls, retarget_profile: RetargetProfile, speed_plant_settings: TargetChainSpeedPlantSettings, target_chain_name: Name) -> RetargetProfile:
        r"""
        X.set_chain_speed_plant_settings_in_retarget_profile(retarget_profile, speed_plant_settings, target_chain_name) -> RetargetProfile
        Set the chain Speed Plant settings in a retarget profile (will set bApplyChainSettings to true).
        
        Args:
            retarget_profile (RetargetProfile): 
            speed_plant_settings (TargetChainSpeedPlantSettings): 
            target_chain_name (Name): 
        
        Returns:
            RetargetProfile: 
        
            retarget_profile (RetargetProfile):
        """
        ...
    @classmethod
    def set_chain_settings_in_retarget_profile(cls, retarget_profile: RetargetProfile, chain_settings: TargetChainSettings, target_chain_name: Name) -> RetargetProfile:
        r"""
        X.set_chain_settings_in_retarget_profile(retarget_profile, chain_settings, target_chain_name) -> RetargetProfile
        Set the chain settings in a retarget profile (will set bApplyChainSettings to true).
        
        Args:
            retarget_profile (RetargetProfile): 
            chain_settings (TargetChainSettings): 
            target_chain_name (Name): 
        
        Returns:
            RetargetProfile: 
        
            retarget_profile (RetargetProfile):
        """
        ...
    @classmethod
    def set_chain_ik_settings_in_retarget_profile(cls, retarget_profile: RetargetProfile, ik_settings: TargetChainIKSettings, target_chain_name: Name) -> RetargetProfile:
        r"""
        X.set_chain_ik_settings_in_retarget_profile(retarget_profile, ik_settings, target_chain_name) -> RetargetProfile
        Set the chain IK settings in a retarget profile (will set bApplyChainSettings to true).
        
        Args:
            retarget_profile (RetargetProfile): 
            ik_settings (TargetChainIKSettings): 
            target_chain_name (Name): 
        
        Returns:
            RetargetProfile: 
        
            retarget_profile (RetargetProfile):
        """
        ...
    @classmethod
    def set_chain_fk_settings_in_retarget_profile(cls, retarget_profile: RetargetProfile, fk_settings: TargetChainFKSettings, target_chain_name: Name) -> RetargetProfile:
        r"""
        X.set_chain_fk_settings_in_retarget_profile(retarget_profile, fk_settings, target_chain_name) -> RetargetProfile
        Set the chain FK settings in a retarget profile (will set bApplyChainSettings to true).
        
        Args:
            retarget_profile (RetargetProfile): 
            fk_settings (TargetChainFKSettings): 
            target_chain_name (Name): 
        
        Returns:
            RetargetProfile: 
        
            retarget_profile (RetargetProfile):
        """
        ...
    def has_target_ik_rig(self) -> bool:
        r"""
        x.has_target_ik_rig() -> bool
        Returns true if the target IK Rig has been assigned
        
        Returns:
            bool:
        """
        ...
    def has_source_ik_rig(self) -> bool:
        r"""
        x.has_source_ik_rig() -> bool
        Returns true if the source IK Rig has been assigned
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_root_settings_from_retarget_profile(cls, retarget_profile: RetargetProfile) -> Tuple[TargetRootSettings, RetargetProfile]:
        r"""
        X.get_root_settings_from_retarget_profile(retarget_profile) -> (TargetRootSettings, retarget_profile=RetargetProfile)
        Returns the root settings in the supplied Retarget Profile.
        
        Args:
            retarget_profile (RetargetProfile): 
        
        Returns:
            RetargetProfile: 
        
            retarget_profile (RetargetProfile):
        """
        ...
    @classmethod
    def get_root_settings_from_retarget_asset(cls, retarget_asset: IKRetargeter, optional_profile_name: Name) -> TargetRootSettings:
        r"""
        X.get_root_settings_from_retarget_asset(retarget_asset, optional_profile_name) -> TargetRootSettings
        Returns the root settings in an IK Retargeter Asset using the given profile name (optional)
        
        Args:
            retarget_asset (IKRetargeter): 
            optional_profile_name (Name): 
        
        Returns:
            TargetRootSettings: 
        
            out_settings (TargetRootSettings):
        """
        ...
    @classmethod
    def get_global_settings_from_retarget_profile(cls, retarget_profile: RetargetProfile) -> Tuple[RetargetGlobalSettings, RetargetProfile]:
        r"""
        X.get_global_settings_from_retarget_profile(retarget_profile) -> (RetargetGlobalSettings, retarget_profile=RetargetProfile)
        Returns the global settings in the supplied Retarget Profile.
        
        Args:
            retarget_profile (RetargetProfile): 
        
        Returns:
            RetargetProfile: 
        
            retarget_profile (RetargetProfile):
        """
        ...
    @classmethod
    def get_global_settings_from_retarget_asset(cls, retarget_asset: IKRetargeter, optional_profile_name: Name) -> RetargetGlobalSettings:
        r"""
        X.get_global_settings_from_retarget_asset(retarget_asset, optional_profile_name) -> RetargetGlobalSettings
        Returns the global settings in an IK Retargeter Asset using the given profile name (optional)
        
        Args:
            retarget_asset (IKRetargeter): 
            optional_profile_name (Name): 
        
        Returns:
            RetargetGlobalSettings: 
        
            out_settings (RetargetGlobalSettings):
        """
        ...
    @classmethod
    def get_chain_using_goal_from_retarget_asset(cls, retarget_asset: IKRetargeter, ik_goal_name: Name) -> TargetChainSettings:
        r"""
        X.get_chain_using_goal_from_retarget_asset(retarget_asset, ik_goal_name) -> TargetChainSettings
        Returns the chain settings associated with a given Goal in an IK Retargeter Asset using the given profile name (optional)
        
        Args:
            retarget_asset (IKRetargeter): 
            ik_goal_name (Name): 
        
        Returns:
            TargetChainSettings:
        """
        ...
    @classmethod
    def get_chain_settings_from_retarget_profile(cls, retarget_profile: RetargetProfile, target_chain_name: Name) -> Tuple[TargetChainSettings, RetargetProfile]:
        r"""
        X.get_chain_settings_from_retarget_profile(retarget_profile, target_chain_name) -> (TargetChainSettings, retarget_profile=RetargetProfile)
        Returns the chain settings associated with a given target chain in the supplied Retarget Profile.
        
        Args:
            retarget_profile (RetargetProfile): 
            target_chain_name (Name): 
        
        Returns:
            RetargetProfile: 
        
            retarget_profile (RetargetProfile):
        """
        ...
    @classmethod
    def get_chain_settings_from_retarget_asset(cls, retarget_asset: IKRetargeter, target_chain_name: Name, optional_profile_name: Name) -> TargetChainSettings:
        r"""
        X.get_chain_settings_from_retarget_asset(retarget_asset, target_chain_name, optional_profile_name) -> TargetChainSettings
        Returns the chain settings associated with a given target chain in an IK Retargeter Asset using the given profile name (optional)
        
        Args:
            retarget_asset (IKRetargeter): 
            target_chain_name (Name): 
            optional_profile_name (Name): 
        
        Returns:
            TargetChainSettings:
        """
        ...

class IKRigEffectorGoal(Object):
    r"""
    IKRig Effector Goal
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRigDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_name`` (Name):  [Read-Only] The name of the bone that this Goal is located at.
    - ``current_transform`` (Transform):  [Read-Write] The current transform of this Goal, in the Global Space of the character.
    - ``expose_position`` (bool):  [Read-Write] Should position data be exposed in Blueprint
    - ``expose_rotation`` (bool):  [Read-Write] Should rotation data be exposed in Blueprint
    - ``goal_name`` (Name):  [Read-Only] The name used to refer to this goal from outside systems.
      This is the name to use when referring to this Goal from Blueprint, Anim Graph, Control Rig or IK Retargeter.
    - ``initial_transform`` (Transform):  [Read-Only] The initial transform of this Goal, as defined by the initial transform of the Goal's bone in the retarget pose.
    - ``position_alpha`` (float):  [Read-Write] Range 0-1, default is 1. Blend between the input bone position (0.0) and the current goal position (1.0).
    - ``preview_mode`` (IKRigGoalPreviewMode):  [Read-Write] Effects how this Goal transform is previewed in the IK Rig editor.
      "Additive" interprets the Goal transform as being relative to the input pose. Useful for previewing animations.
      "Absolute" pins the Goal transform to the Gizmo in the viewport.
    - ``rotation_alpha`` (float):  [Read-Write] Range 0-1, default is 1. Blend between the input bone rotation (0.0) and the current goal rotation (1.0).
    - ``size_multiplier`` (float):  [Read-Write] The size of the Goal gizmo drawing in the editor viewport.
    - ``thickness_multiplier`` (float):  [Read-Write] The thickness of the Goal gizmo drawing in the editor viewport.
    """
    @property
    def goal_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name used to refer to this goal from outside systems.
        This is the name to use when referring to this Goal from Blueprint, Anim Graph, Control Rig or IK Retargeter.
        """
        ...
    @property
    def bone_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The name of the bone that this Goal is located at.
        """
        ...
    @property
    def position_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 1. Blend between the input bone position (0.0) and the current goal position (1.0).
        """
        ...
    @position_alpha.setter
    def position_alpha(self, value: float) -> None:
        ...
    @property
    def rotation_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1, default is 1. Blend between the input bone rotation (0.0) and the current goal rotation (1.0).
        """
        ...
    @rotation_alpha.setter
    def rotation_alpha(self, value: float) -> None:
        ...
    @property
    def current_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Write] The current transform of this Goal, in the Global Space of the character.
        """
        ...
    @current_transform.setter
    def current_transform(self, value: Transform) -> None:
        ...
    @property
    def initial_transform(self) -> Transform:
        r"""
        (Transform):  [Read-Only] The initial transform of this Goal, as defined by the initial transform of the Goal's bone in the retarget pose.
        """
        ...
    @property
    def preview_mode(self) -> IKRigGoalPreviewMode:
        r"""
        (IKRigGoalPreviewMode):  [Read-Write] Effects how this Goal transform is previewed in the IK Rig editor.
        "Additive" interprets the Goal transform as being relative to the input pose. Useful for previewing animations.
        "Absolute" pins the Goal transform to the Gizmo in the viewport.
        """
        ...
    @preview_mode.setter
    def preview_mode(self, value: IKRigGoalPreviewMode) -> None:
        ...
    @property
    def size_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] The size of the Goal gizmo drawing in the editor viewport.
        """
        ...
    @size_multiplier.setter
    def size_multiplier(self, value: float) -> None:
        ...
    @property
    def thickness_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] The thickness of the Goal gizmo drawing in the editor viewport.
        """
        ...
    @thickness_multiplier.setter
    def thickness_multiplier(self, value: float) -> None:
        ...
    @property
    def expose_position(self) -> bool:
        r"""
        (bool):  [Read-Write] Should position data be exposed in Blueprint
        """
        ...
    @expose_position.setter
    def expose_position(self, value: bool) -> None:
        ...
    @property
    def expose_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] Should rotation data be exposed in Blueprint
        """
        ...
    @expose_rotation.setter
    def expose_rotation(self, value: bool) -> None:
        ...

class IKRigDefinition(Object):
    r"""
    IKRig Definition
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRigDefinition.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``draw_goals`` (bool):  [Read-Write] Draw bones in the viewport.
    - ``goal_size`` (float):  [Read-Write] The size of the Goals in the editor viewport.
    - ``goal_thickness`` (float):  [Read-Write] The thickness of the Goals in the editor viewport.
    - ``preview_skeletal_mesh`` (SkeletalMesh):  [Read-Write] The skeletal mesh to run the IK solve on (loaded into viewport).
      NOTE: you can assign ANY Skeletal Mesh to apply the IK Rig to. Compatibility is determined when a new mesh is assigned
      by comparing it's hierarchy with the goals, solvers and bone settings required by the rig. See output log for details.
    """
    ...

class IKRig_BodyMoverEffector(Object):
    r"""
    IKRig Body Mover Effector
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRig_BodyMover.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_name`` (Name):  [Read-Only]
    - ``goal_name`` (Name):  [Read-Only]
    - ``influence_multiplier`` (float):  [Read-Write] Scale the influence this effector has on the body. Range is 0-10. Default is 1.0.
    """
    @property
    def goal_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def bone_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def influence_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] Scale the influence this effector has on the body. Range is 0-10. Default is 1.0.
        """
        ...
    @influence_multiplier.setter
    def influence_multiplier(self, value: float) -> None:
        ...

class IKRigSolver(Object):
    r"""
    this is the base class for creating your own solver type that integrates into the IK Rig framework/editor.
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRigSolver.h
    
    """
    ...

class IKRig_BodyMover(IKRigSolver):
    r"""
    IKRig Body Mover
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRig_BodyMover.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``position_alpha`` (float):  [Read-Write] Blend the translational effect of this solver on/off. Range is 0-1. Default is 1.0.
    - ``position_negative_x`` (float):  [Read-Write] Multiply the NEGATIVE X translation. Range is 0-1. Default is 1.0.
    - ``position_negative_y`` (float):  [Read-Write] Multiply the NEGATIVE Y translation. Range is 0-1. Default is 1.0.
    - ``position_negative_z`` (float):  [Read-Write] Multiply the NEGATIVE Z translation. Range is 0-1. Default is 1.0.
    - ``position_positive_x`` (float):  [Read-Write] Multiply the POSITIVE X translation. Range is 0-1. Default is 1.0.
    - ``position_positive_y`` (float):  [Read-Write] Multiply the POSITIVE Y translation. Range is 0-1. Default is 1.0.
    - ``position_positive_z`` (float):  [Read-Write] Multiply the POSITIVE Z translation. Range is 0-1. Default is 1.0.
    - ``root_bone`` (Name):  [Read-Only] The target bone to move with the effectors.
    - ``rotate_x_alpha`` (float):  [Read-Write] Blend the X-axis rotational effect on/off. Range is 0-1. Default is 1.0.
    - ``rotate_y_alpha`` (float):  [Read-Write] Blend the Y-axis rotational effect on/off. Range is 0-1. Default is 1.0.
    - ``rotate_z_alpha`` (float):  [Read-Write] Blend the Z-axis rotational effect on/off. Range is 0-1. Default is 1.0.
    - ``rotation_alpha`` (float):  [Read-Write] Blend the total rotational effect on/off. Range is 0-1. Default is 1.0.
    """
    @property
    def position_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Blend the translational effect of this solver on/off. Range is 0-1. Default is 1.0.
        """
        ...
    @position_alpha.setter
    def position_alpha(self, value: float) -> None:
        ...
    @property
    def position_positive_x(self) -> float:
        r"""
        (float):  [Read-Write] Multiply the POSITIVE X translation. Range is 0-1. Default is 1.0.
        """
        ...
    @position_positive_x.setter
    def position_positive_x(self, value: float) -> None:
        ...
    @property
    def position_negative_x(self) -> float:
        r"""
        (float):  [Read-Write] Multiply the NEGATIVE X translation. Range is 0-1. Default is 1.0.
        """
        ...
    @position_negative_x.setter
    def position_negative_x(self, value: float) -> None:
        ...
    @property
    def position_positive_y(self) -> float:
        r"""
        (float):  [Read-Write] Multiply the POSITIVE Y translation. Range is 0-1. Default is 1.0.
        """
        ...
    @position_positive_y.setter
    def position_positive_y(self, value: float) -> None:
        ...
    @property
    def position_negative_y(self) -> float:
        r"""
        (float):  [Read-Write] Multiply the NEGATIVE Y translation. Range is 0-1. Default is 1.0.
        """
        ...
    @position_negative_y.setter
    def position_negative_y(self, value: float) -> None:
        ...
    @property
    def position_positive_z(self) -> float:
        r"""
        (float):  [Read-Write] Multiply the POSITIVE Z translation. Range is 0-1. Default is 1.0.
        """
        ...
    @position_positive_z.setter
    def position_positive_z(self, value: float) -> None:
        ...
    @property
    def position_negative_z(self) -> float:
        r"""
        (float):  [Read-Write] Multiply the NEGATIVE Z translation. Range is 0-1. Default is 1.0.
        """
        ...
    @position_negative_z.setter
    def position_negative_z(self, value: float) -> None:
        ...
    @property
    def rotation_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Blend the total rotational effect on/off. Range is 0-1. Default is 1.0.
        """
        ...
    @rotation_alpha.setter
    def rotation_alpha(self, value: float) -> None:
        ...
    @property
    def rotate_x_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Blend the X-axis rotational effect on/off. Range is 0-1. Default is 1.0.
        """
        ...
    @rotate_x_alpha.setter
    def rotate_x_alpha(self, value: float) -> None:
        ...
    @property
    def rotate_y_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Blend the Y-axis rotational effect on/off. Range is 0-1. Default is 1.0.
        """
        ...
    @rotate_y_alpha.setter
    def rotate_y_alpha(self, value: float) -> None:
        ...
    @property
    def rotate_z_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Blend the Z-axis rotational effect on/off. Range is 0-1. Default is 1.0.
        """
        ...
    @rotate_z_alpha.setter
    def rotate_z_alpha(self, value: float) -> None:
        ...

class IKRig_LimbEffector(Object):
    r"""
    IKRig Limb Effector
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRig_LimbSolver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_name`` (Name):  [Read-Only]
    - ``goal_name`` (Name):  [Read-Only]
    """
    @property
    def goal_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def bone_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...

class IKRig_LimbSolver(IKRigSolver):
    r"""
    IKRig Limb Solver
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRig_LimbSolver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``average_pull`` (bool):  [Read-Write] Pull averaging only has a visual impact when we have more than 2 bones (3 links).
    - ``enable_limit`` (bool):  [Read-Write] Enable/Disable rotational limits
    - ``enable_twist_correction`` (bool):  [Read-Write] Enable Knee Twist correction, by comparing Foot FK with Foot IK orientation.
    - ``end_bone_forward_axis`` (AxisType):  [Read-Write] Forward Axis for Foot bone.
    - ``hinge_rotation_axis`` (AxisType):  [Read-Write] Hinge Bones Rotation Axis. This is essentially the plane normal for (hip - knee - foot).
    - ``max_iterations`` (int32):  [Read-Write] Number of Max Iterations to reach the target
    - ``min_rotation_angle`` (float):  [Read-Write] Only used if bEnableRotationLimit is enabled. Prevents the leg from folding onto itself,
      and forces at least this angle between Parent and Child bone.
    - ``pull_distribution`` (float):  [Read-Write] Re-position limb to distribute pull: 0 = foot, 0.5 = balanced, 1.f = hip
    - ``reach_precision`` (float):  [Read-Write] Precision (distance to the target)
    - ``reach_step_alpha`` (float):  [Read-Write] Move end effector towards target. If we are compressing the chain, limit displacement.
    - ``root_name`` (Name):  [Read-Only]
    """
    @property
    def root_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def reach_precision(self) -> float:
        r"""
        (float):  [Read-Write] Precision (distance to the target)
        """
        ...
    @reach_precision.setter
    def reach_precision(self, value: float) -> None:
        ...
    @property
    def hinge_rotation_axis(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] Hinge Bones Rotation Axis. This is essentially the plane normal for (hip - knee - foot).
        """
        ...
    @hinge_rotation_axis.setter
    def hinge_rotation_axis(self, value: AxisType) -> None:
        ...
    @property
    def max_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] Number of Max Iterations to reach the target
        """
        ...
    @max_iterations.setter
    def max_iterations(self, value: int) -> None:
        ...
    @property
    def enable_limit(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable/Disable rotational limits
        """
        ...
    @enable_limit.setter
    def enable_limit(self, value: bool) -> None:
        ...
    @property
    def min_rotation_angle(self) -> float:
        r"""
        (float):  [Read-Write] Only used if bEnableRotationLimit is enabled. Prevents the leg from folding onto itself,
        and forces at least this angle between Parent and Child bone.
        """
        ...
    @min_rotation_angle.setter
    def min_rotation_angle(self, value: float) -> None:
        ...
    @property
    def average_pull(self) -> bool:
        r"""
        (bool):  [Read-Write] Pull averaging only has a visual impact when we have more than 2 bones (3 links).
        """
        ...
    @average_pull.setter
    def average_pull(self, value: bool) -> None:
        ...
    @property
    def pull_distribution(self) -> float:
        r"""
        (float):  [Read-Write] Re-position limb to distribute pull: 0 = foot, 0.5 = balanced, 1.f = hip
        """
        ...
    @pull_distribution.setter
    def pull_distribution(self, value: float) -> None:
        ...
    @property
    def reach_step_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Move end effector towards target. If we are compressing the chain, limit displacement.
        """
        ...
    @reach_step_alpha.setter
    def reach_step_alpha(self, value: float) -> None:
        ...
    @property
    def enable_twist_correction(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable Knee Twist correction, by comparing Foot FK with Foot IK orientation.
        """
        ...
    @enable_twist_correction.setter
    def enable_twist_correction(self, value: bool) -> None:
        ...
    @property
    def end_bone_forward_axis(self) -> AxisType:
        r"""
        (AxisType):  [Read-Write] Forward Axis for Foot bone.
        """
        ...
    @end_bone_forward_axis.setter
    def end_bone_forward_axis(self, value: AxisType) -> None:
        ...

class IKRig_FBIKEffector(Object):
    r"""
    IKRig FBIKEffector
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRig_FBIKSolver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_name`` (Name):  [Read-Only] The bone that this effector will pull on.
    - ``chain_depth`` (int32):  [Read-Write] Range 0-inf (default is 0). Explicitly set the number of bones up the hierarchy to consider part of this effector's 'chain'.
      The "chain" of bones is used to apply Preferred Angles, Pull Chain Alpha and Chain "Sub Solves".
      If left at 0, the solver will attempt to determine the root of the chain by searching up the hierarchy until it finds a branch or another effector, whichever it finds first.
    - ``goal_name`` (Name):  [Read-Only] The Goal that is driving this effector's transform.
    - ``pin_rotation`` (float):  [Read-Write] Range 0-1 (default is 1.0).
      Blends the effector bone rotation between the rotation of the effector transform (1.0) and the rotation of the input bone (0.0).
    - ``pull_chain_alpha`` (float):  [Read-Write] Range 0-1 (default is 1.0). When enabled (greater than 0.0), the solver internally partitions the skeleton into 'chains' which extend
      from the effector up the hierarchy by "Chain Depth". If Chain Depth is 0, the chain root is set to the nearest fork in the skeleton.
      These chains are pre-rotated and translated, as a whole, towards the effector targets.
      This can improve the results for sparse bone chains, and significantly improve convergence on dense bone chains.
      But it may cause undesirable results in highly constrained bone chains (like robot arms).
    - ``strength_alpha`` (float):  [Read-Write] Range 0-1 (default is 1.0). The strength of the effector when pulling the bone towards it's target location.
      At 0.0, the effector does not pull at all, but the bones between the effector and the root will still slightly resist motion from other effectors.
      This can thus act as a "stabilizer" for parts of the body that you do not want to behave in a pure FK fashion.
    """
    @property
    def goal_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The Goal that is driving this effector's transform.
        """
        ...
    @property
    def bone_name(self) -> Name:
        r"""
        (Name):  [Read-Only] The bone that this effector will pull on.
        """
        ...
    @property
    def chain_depth(self) -> int:
        r"""
        (int32):  [Read-Write] Range 0-inf (default is 0). Explicitly set the number of bones up the hierarchy to consider part of this effector's 'chain'.
        The "chain" of bones is used to apply Preferred Angles, Pull Chain Alpha and Chain "Sub Solves".
        If left at 0, the solver will attempt to determine the root of the chain by searching up the hierarchy until it finds a branch or another effector, whichever it finds first.
        """
        ...
    @chain_depth.setter
    def chain_depth(self, value: int) -> None:
        ...
    @property
    def strength_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1 (default is 1.0). The strength of the effector when pulling the bone towards it's target location.
        At 0.0, the effector does not pull at all, but the bones between the effector and the root will still slightly resist motion from other effectors.
        This can thus act as a "stabilizer" for parts of the body that you do not want to behave in a pure FK fashion.
        """
        ...
    @strength_alpha.setter
    def strength_alpha(self, value: float) -> None:
        ...
    @property
    def pull_chain_alpha(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1 (default is 1.0). When enabled (greater than 0.0), the solver internally partitions the skeleton into 'chains' which extend
        from the effector up the hierarchy by "Chain Depth". If Chain Depth is 0, the chain root is set to the nearest fork in the skeleton.
        These chains are pre-rotated and translated, as a whole, towards the effector targets.
        This can improve the results for sparse bone chains, and significantly improve convergence on dense bone chains.
        But it may cause undesirable results in highly constrained bone chains (like robot arms).
        """
        ...
    @pull_chain_alpha.setter
    def pull_chain_alpha(self, value: float) -> None:
        ...
    @property
    def pin_rotation(self) -> float:
        r"""
        (float):  [Read-Write] Range 0-1 (default is 1.0).
        Blends the effector bone rotation between the rotation of the effector transform (1.0) and the rotation of the input bone (0.0).
        """
        ...
    @pin_rotation.setter
    def pin_rotation(self, value: float) -> None:
        ...

class IKRig_FBIKBoneSettings(Object):
    r"""
    IKRig FBIKBone Settings
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRig_FBIKSolver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone`` (Name):  [Read-Only] The bone these settings are applied to.
    - ``max_x`` (float):  [Read-Write] Range is 0 to 180 (Default is 0). Degrees of rotation in the positive X direction to allow when joint is in "Limited" mode.
    - ``max_y`` (float):  [Read-Write] Range is 0 to 180 (Default is 0). Degrees of rotation in the positive Y direction to allow when joint is in "Limited" mode.
    - ``max_z`` (float):  [Read-Write] Range is 0 to 180 (Default is 0). Degrees of rotation in the positive Z direction to allow when joint is in "Limited" mode.
    - ``min_x`` (float):  [Read-Write] Range is -180 to 0 (Default is 0). Degrees of rotation in the negative X direction to allow when joint is in "Limited" mode.
    - ``min_y`` (float):  [Read-Write] Range is -180 to 0 (Default is 0). Degrees of rotation in the negative Y direction to allow when joint is in "Limited" mode.
    - ``min_z`` (float):  [Read-Write] Range is -180 to 0 (Default is 0). Degrees of rotation in the negative Z direction to allow when joint is in "Limited" mode.
    - ``position_stiffness`` (float):  [Read-Write] Range is 0 to 1 (Default is 0). At higher values, the bone will resist translational motion (forcing other bones to compensate).
    - ``preferred_angles`` (Vector):  [Read-Write] The local Euler angles (in degrees) used to rotate this bone when the chain it belongs to is squashed.
      This happens by moving the effector at the tip of the chain towards the root of the chain.
      This can be used to coerce knees and elbows to bend in the anatomically "correct" direction without resorting to limits (which may require more iterations to converge).
    - ``rotation_stiffness`` (float):  [Read-Write] Range is 0 to 1 (Default is 0). At higher values, the bone will resist rotating (forcing other bones to compensate).
    - ``use_preferred_angles`` (bool):  [Read-Write] When true, this bone will "prefer" to rotate in the direction specified by the Preferred Angles when the chain it belongs to is compressed.
      Preferred Angles should be the first method used to fix bones that bend in the wrong direction (rather than limits).
      The resulting angles can be visualized on their own by temporarily setting the Solver iterations to 0 and moving the effectors.
    - ``x`` (PBIKLimitType):  [Read-Write] Limit the rotation angle of the bone on the X axis.
      Free: can rotate freely in this axis.
      Limited: rotation is clamped between the min/max angles relative to the Skeletal Mesh reference pose.
      Locked: no rotation is allowed in this axis (will remain at reference pose angle).
    - ``y`` (PBIKLimitType):  [Read-Write] Limit the rotation angle of the bone on the Y axis.
      Free: can rotate freely in this axis.
      Limited: rotation is clamped between the min/max angles relative to the Skeletal Mesh reference pose.
      Locked: no rotation is allowed in this axis (will remain at input pose angle).
    - ``z`` (PBIKLimitType):  [Read-Write] Limit the rotation angle of the bone on the Z axis.
      Free: can rotate freely in this axis.
      Limited: rotation is clamped between the min/max angles relative to the Skeletal Mesh reference pose.
      Locked: no rotation is allowed in this axis (will remain at input pose angle).
    """
    @property
    def bone(self) -> Name:
        r"""
        (Name):  [Read-Only] The bone these settings are applied to.
        """
        ...
    @property
    def rotation_stiffness(self) -> float:
        r"""
        (float):  [Read-Write] Range is 0 to 1 (Default is 0). At higher values, the bone will resist rotating (forcing other bones to compensate).
        """
        ...
    @rotation_stiffness.setter
    def rotation_stiffness(self, value: float) -> None:
        ...
    @property
    def position_stiffness(self) -> float:
        r"""
        (float):  [Read-Write] Range is 0 to 1 (Default is 0). At higher values, the bone will resist translational motion (forcing other bones to compensate).
        """
        ...
    @position_stiffness.setter
    def position_stiffness(self, value: float) -> None:
        ...
    @property
    def x(self) -> PBIKLimitType:
        r"""
        (PBIKLimitType):  [Read-Write] Limit the rotation angle of the bone on the X axis.
        Free: can rotate freely in this axis.
        Limited: rotation is clamped between the min/max angles relative to the Skeletal Mesh reference pose.
        Locked: no rotation is allowed in this axis (will remain at reference pose angle).
        """
        ...
    @x.setter
    def x(self, value: PBIKLimitType) -> None:
        ...
    @property
    def min_x(self) -> float:
        r"""
        (float):  [Read-Write] Range is -180 to 0 (Default is 0). Degrees of rotation in the negative X direction to allow when joint is in "Limited" mode.
        """
        ...
    @min_x.setter
    def min_x(self, value: float) -> None:
        ...
    @property
    def max_x(self) -> float:
        r"""
        (float):  [Read-Write] Range is 0 to 180 (Default is 0). Degrees of rotation in the positive X direction to allow when joint is in "Limited" mode.
        """
        ...
    @max_x.setter
    def max_x(self, value: float) -> None:
        ...
    @property
    def y(self) -> PBIKLimitType:
        r"""
        (PBIKLimitType):  [Read-Write] Limit the rotation angle of the bone on the Y axis.
        Free: can rotate freely in this axis.
        Limited: rotation is clamped between the min/max angles relative to the Skeletal Mesh reference pose.
        Locked: no rotation is allowed in this axis (will remain at input pose angle).
        """
        ...
    @y.setter
    def y(self, value: PBIKLimitType) -> None:
        ...
    @property
    def min_y(self) -> float:
        r"""
        (float):  [Read-Write] Range is -180 to 0 (Default is 0). Degrees of rotation in the negative Y direction to allow when joint is in "Limited" mode.
        """
        ...
    @min_y.setter
    def min_y(self, value: float) -> None:
        ...
    @property
    def max_y(self) -> float:
        r"""
        (float):  [Read-Write] Range is 0 to 180 (Default is 0). Degrees of rotation in the positive Y direction to allow when joint is in "Limited" mode.
        """
        ...
    @max_y.setter
    def max_y(self, value: float) -> None:
        ...
    @property
    def z(self) -> PBIKLimitType:
        r"""
        (PBIKLimitType):  [Read-Write] Limit the rotation angle of the bone on the Z axis.
        Free: can rotate freely in this axis.
        Limited: rotation is clamped between the min/max angles relative to the Skeletal Mesh reference pose.
        Locked: no rotation is allowed in this axis (will remain at input pose angle).
        """
        ...
    @z.setter
    def z(self, value: PBIKLimitType) -> None:
        ...
    @property
    def min_z(self) -> float:
        r"""
        (float):  [Read-Write] Range is -180 to 0 (Default is 0). Degrees of rotation in the negative Z direction to allow when joint is in "Limited" mode.
        """
        ...
    @min_z.setter
    def min_z(self, value: float) -> None:
        ...
    @property
    def max_z(self) -> float:
        r"""
        (float):  [Read-Write] Range is 0 to 180 (Default is 0). Degrees of rotation in the positive Z direction to allow when joint is in "Limited" mode.
        """
        ...
    @max_z.setter
    def max_z(self, value: float) -> None:
        ...
    @property
    def use_preferred_angles(self) -> bool:
        r"""
        (bool):  [Read-Write] When true, this bone will "prefer" to rotate in the direction specified by the Preferred Angles when the chain it belongs to is compressed.
        Preferred Angles should be the first method used to fix bones that bend in the wrong direction (rather than limits).
        The resulting angles can be visualized on their own by temporarily setting the Solver iterations to 0 and moving the effectors.
        """
        ...
    @use_preferred_angles.setter
    def use_preferred_angles(self, value: bool) -> None:
        ...
    @property
    def preferred_angles(self) -> Vector:
        r"""
        (Vector):  [Read-Write] The local Euler angles (in degrees) used to rotate this bone when the chain it belongs to is squashed.
        This happens by moving the effector at the tip of the chain towards the root of the chain.
        This can be used to coerce knees and elbows to bend in the anatomically "correct" direction without resorting to limits (which may require more iterations to converge).
        """
        ...
    @preferred_angles.setter
    def preferred_angles(self, value: Vector) -> None:
        ...

class IKRig_PBIKBoneSettings(IKRig_FBIKBoneSettings):
    r"""
    deprecated: 'IKRig_PBIKBoneSettings' was renamed to 'IKRig_FBIKBoneSettings'.
    """
    ...

class IKRigFBIKSolver(IKRigSolver):
    r"""
    IKRig FBIKSolver
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRig_FBIKSolver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``allow_stretch`` (bool):  [Read-Write] If true, joints will translate to reach the effectors; causing bones to lengthen if necessary. Good for cartoon effects. Default is false.
    - ``iterations`` (int32):  [Read-Write] High iteration counts can help solve complex joint configurations with competing constraints, but will increase runtime cost. Default is 20.
    - ``mass_multiplier`` (float):  [Read-Write] A global mass multiplier; higher values will make the joints more stiff, but require more iterations. Typical range is 0.0 to 10.0.
    - ``max_angle`` (float):  [Read-Write] Maximum angle that a joint can be rotated per constraint iteration. Lower this value if the solve is diverging. Range is 0.0 to 180.0. Default is 30.
    - ``over_relaxation`` (float):  [Read-Write] Pushes constraints beyond their normal amount to speed up convergence. Increasing this may speed up convergence, but at the cost of stability. Range is 1.0 - 2.0. Default is 1.3.
    - ``pre_pull_root_settings`` (RootPrePullSettings):  [Read-Write] Settings only applicable when Root Behavior is set to "PrePull". Use these values to adjust the gross movement and orientation of the entire skeleton.
    - ``pull_chain_alpha`` (float):  [Read-Write] A global multiplier for all Pull Chain Alpha values on all effectors. Range is 0.0 to 1.0. Default is 1.0.
    - ``root_behavior`` (PBIKRootBehavior):  [Read-Write] (Default is PrePull) Set the behavior of the solver root.
      Pre Pull: translates and rotates the root (and all children) by the average motion of the stretched effectors to help achieve faster convergence when reaching far.
      Pin to Input: locks the translation and rotation of the root bone to the input pose. Overrides any bone settings applied to the root. Good for partial-body solves.
      Free: treats the root bone like any other and allows it to move freely or according to any bone settings applied to it.
    - ``root_bone`` (Name):  [Read-Only] All bones above this bone in the hierarchy will be completely ignored by the solver. Typically this is set to
      the top-most skinned bone in the Skeletal Mesh (ie Pelvis, Hips etc), NOT the actual root of the entire skeleton.
      
      If you want to use the solver on a single chain of bones, and NOT translate the chain, ensure that "PinRoot" is
      checked on to disable the root from translating to reach the effector goals.
    - ``sub_iterations`` (int32):  [Read-Write] Iterations used for sub-chains defined by the Chain Depth of the effectors. These are solved BEFORE the main iteration pass. Default is 0.
    """
    @property
    def root_bone(self) -> Name:
        r"""
        (Name):  [Read-Only] All bones above this bone in the hierarchy will be completely ignored by the solver. Typically this is set to
        the top-most skinned bone in the Skeletal Mesh (ie Pelvis, Hips etc), NOT the actual root of the entire skeleton.
        
        If you want to use the solver on a single chain of bones, and NOT translate the chain, ensure that "PinRoot" is
        checked on to disable the root from translating to reach the effector goals.
        """
        ...
    @property
    def iterations(self) -> int:
        r"""
        (int32):  [Read-Write] High iteration counts can help solve complex joint configurations with competing constraints, but will increase runtime cost. Default is 20.
        """
        ...
    @iterations.setter
    def iterations(self, value: int) -> None:
        ...
    @property
    def sub_iterations(self) -> int:
        r"""
        (int32):  [Read-Write] Iterations used for sub-chains defined by the Chain Depth of the effectors. These are solved BEFORE the main iteration pass. Default is 0.
        """
        ...
    @sub_iterations.setter
    def sub_iterations(self, value: int) -> None:
        ...
    @property
    def mass_multiplier(self) -> float:
        r"""
        (float):  [Read-Write] A global mass multiplier; higher values will make the joints more stiff, but require more iterations. Typical range is 0.0 to 10.0.
        """
        ...
    @mass_multiplier.setter
    def mass_multiplier(self, value: float) -> None:
        ...
    @property
    def allow_stretch(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, joints will translate to reach the effectors; causing bones to lengthen if necessary. Good for cartoon effects. Default is false.
        """
        ...
    @allow_stretch.setter
    def allow_stretch(self, value: bool) -> None:
        ...
    @property
    def root_behavior(self) -> PBIKRootBehavior:
        r"""
        (PBIKRootBehavior):  [Read-Write] (Default is PrePull) Set the behavior of the solver root.
        Pre Pull: translates and rotates the root (and all children) by the average motion of the stretched effectors to help achieve faster convergence when reaching far.
        Pin to Input: locks the translation and rotation of the root bone to the input pose. Overrides any bone settings applied to the root. Good for partial-body solves.
        Free: treats the root bone like any other and allows it to move freely or according to any bone settings applied to it.
        """
        ...
    @root_behavior.setter
    def root_behavior(self, value: PBIKRootBehavior) -> None:
        ...
    @property
    def pre_pull_root_settings(self) -> RootPrePullSettings:
        r"""
        (RootPrePullSettings):  [Read-Write] Settings only applicable when Root Behavior is set to "PrePull". Use these values to adjust the gross movement and orientation of the entire skeleton.
        """
        ...
    @pre_pull_root_settings.setter
    def pre_pull_root_settings(self, value: RootPrePullSettings) -> None:
        ...
    @property
    def pull_chain_alpha(self) -> float:
        r"""
        (float):  [Read-Write] A global multiplier for all Pull Chain Alpha values on all effectors. Range is 0.0 to 1.0. Default is 1.0.
        """
        ...
    @pull_chain_alpha.setter
    def pull_chain_alpha(self, value: float) -> None:
        ...
    @property
    def max_angle(self) -> float:
        r"""
        (float):  [Read-Write] Maximum angle that a joint can be rotated per constraint iteration. Lower this value if the solve is diverging. Range is 0.0 to 180.0. Default is 30.
        """
        ...
    @max_angle.setter
    def max_angle(self, value: float) -> None:
        ...
    @property
    def over_relaxation(self) -> float:
        r"""
        (float):  [Read-Write] Pushes constraints beyond their normal amount to speed up convergence. Increasing this may speed up convergence, but at the cost of stability. Range is 1.0 - 2.0. Default is 1.3.
        """
        ...
    @over_relaxation.setter
    def over_relaxation(self, value: float) -> None:
        ...

class IKRigPBIKSolver(IKRigFBIKSolver):
    r"""
    deprecated: 'IKRigPBIKSolver' was renamed to 'IKRigFBIKSolver'.
    """
    ...

class IKRig_PoleSolverEffector(Object):
    r"""
    IKRig Pole Solver Effector
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRig_PoleSolver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Blend the effector on/off. Range is 0-1. Default is 1.0.
    - ``bone_name`` (Name):  [Read-Only]
    - ``goal_name`` (Name):  [Read-Only]
    """
    @property
    def goal_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def bone_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write] Blend the effector on/off. Range is 0-1. Default is 1.0.
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...

class IKRig_PoleSolver(IKRigSolver):
    r"""
    IKRig Pole Solver
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRig_PoleSolver.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``end_name`` (Name):  [Read-Only]
    - ``root_name`` (Name):  [Read-Only]
    """
    ...

class IKRig_SetTransformEffector(Object):
    r"""
    IKRig Set Transform Effector
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRig_SetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``alpha`` (float):  [Read-Write] Blend the effector on/off. Range is 0-1. Default is 1.0.
    - ``enable_position`` (bool):  [Read-Write] If true, Goal will drive the translation of the target bone. Default is true.
    - ``enable_rotation`` (bool):  [Read-Write] If true, Goal will drive the rotation of the target bone. Default is true.
    """
    @property
    def enable_position(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, Goal will drive the translation of the target bone. Default is true.
        """
        ...
    @enable_position.setter
    def enable_position(self, value: bool) -> None:
        ...
    @property
    def enable_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, Goal will drive the rotation of the target bone. Default is true.
        """
        ...
    @enable_rotation.setter
    def enable_rotation(self, value: bool) -> None:
        ...
    @property
    def alpha(self) -> float:
        r"""
        (float):  [Read-Write] Blend the effector on/off. Range is 0-1. Default is 1.0.
        """
        ...
    @alpha.setter
    def alpha(self, value: float) -> None:
        ...

class IKRig_SetTransform(IKRigSolver):
    r"""
    IKRig Set Transform
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRig
    - **File**: IKRig_SetTransform.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``goal`` (Name):  [Read-Only]
    - ``root_bone`` (Name):  [Read-Only]
    """
    ...

class AnimGraphNode_IKRig(AnimGraphNode_CustomProperty):
    r"""
    Editor node for IKRig
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigDeveloper
    - **File**: AnimGraphNode_IKRig.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_IKRig):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class AnimGraphNode_RetargetPoseFromMesh(AnimGraphNode_Base):
    r"""
    Editor node for IKRig
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigDeveloper
    - **File**: AnimGraphNode_RetargetPoseFromMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``become_relevant_function`` (MemberReference):  [Read-Write] Function called when the node becomes relevant, meaning it goes from having no weight to any weight.
    - ``binding`` (AnimGraphNodeBinding):  [Read-Write] Bindings for pins that this node exposes
    - ``initial_update_function`` (MemberReference):  [Read-Write] Function called before the node is updated for the first time
    - ``node`` (AnimNode_RetargetPoseFromMesh):  [Read-Write]
    - ``show_pin_for_properties`` (Array[OptionalPinFromProperty]):  [Read-Write]
    - ``tag`` (Name):  [Read-Write] Optional reference tag name. If this is set then this node can be referenced from elsewhere in this animation blueprint using an anim node reference
    - ``update_function`` (MemberReference):  [Read-Write] Function called when the node is updated
    """
    ...

class ChaosVDInstancedStaticMeshComponent(InstancedStaticMeshComponent):
    r"""
    CVD version of a Instance Static Mesh Component that holds additional CVD data
    
    **C++ Source:**
    
    - **Plugin**: ChaosVD
    - **Module**: ChaosVD
    - **File**: ChaosVDInstancedStaticMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``instance_end_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance completely fades out.
    - ``instance_lod_distance_scale`` (float):  [Read-Write] Scale applied to change the computation of LOD distances when using the StaticMesh screen sizes.
      Smaller values make LODs transition earlier.
    - ``instance_start_cull_distance`` (int32):  [Read-Write] Distance from camera at which each instance begins to fade out.
    - ``instancing_random_seed`` (int32):  [Read-Write] Value used to seed the random number stream that generates random numbers for each of this mesh's instances.
            The random number is stored in a buffer accessible to materials through the PerInstanceRandom expression. If
            this is set to zero (default), it will be populated automatically by the editor.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``num_custom_data_floats`` (int32):  [Read-Write] Defines the number of floats that will be available per instance for custom data
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``per_instance_sm_custom_data`` (Array[float]):  [Read-Write] Array of custom data for instances. This will contains NumCustomDataFloats*InstanceCount entries. The entries are represented sequantially, in instance order. Can be read in a material and manipulated through Blueprints.
          Example: If NumCustomDataFloats is 1, then each entry will belong to an instance. Custom data 0 will belong to Instance 0. Custom data 1 will belong to Instance 1 etc.
          Example: If NumCustomDataFloats is 2, then each pair of sequential entries belong to an instance. Custom data 0 and 1 will belong to Instance 0. Custom data 2 and 3 will belong to Instance 2 etc.
    - ``per_instance_sm_data`` (Array[InstancedStaticMeshInstanceData]):  [Read-Write] Array of instances, bulk serialized.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``use_gpu_lod_selection`` (bool):  [Read-Write] If true, this component will use GPU LOD selection.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    ...

class ChaosVDParticleActor(Actor):
    r"""
    Actor used to represent a Chaos Particle in the Visual Debugger's world
    
    **C++ Source:**
    
    - **Plugin**: ChaosVD
    - **Module**: ChaosVD
    - **File**: ChaosVDParticleActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class ChaosVDParticleDataComponent(ActorComponent):
    r"""
    Component that will reference all particle data for a specific solver for the current frame.
    Currently it is empty and only used to interface with the component visualizer system for particle data,
    but when we eventually remove the dependency on actors to represent particles as planned, the particle data will be referenced in this component.\
    (similarly to how the Scene Query Data and Collision Data is referenced in their respective components)
    
    **C++ Source:**
    
    - **Plugin**: ChaosVD
    - **Module**: ChaosVD
    - **File**: ChaosVDParticleDataComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class ChaosVDSceneQueryDataComponent(ActorComponent):
    r"""
    Actor Component that contains all the scene queries recorded at the current loaded frame
    
    **C++ Source:**
    
    - **Plugin**: ChaosVD
    - **Module**: ChaosVD
    - **File**: ChaosVDSceneQueryDataComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class ChaosVDSceneQueryDataContainer(Actor):
    r"""
    Actor that contains Scene Queries components data and any related logic used to visualize recording scene queries
    
    **C++ Source:**
    
    - **Plugin**: ChaosVD
    - **Module**: ChaosVD
    - **File**: ChaosVDSceneQueryDataContainer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class ChaosVDSkySphereInterface(Interface):
    r"""
    Chaos VDSky Sphere Interface
    
    **C++ Source:**
    
    - **Plugin**: ChaosVD
    - **Module**: ChaosVD
    - **File**: ChaosVDSkySphereInterface.h
    
    """
    def set_directional_light_source(self, new_light_source: DirectionalLight) -> None:
        r"""
        x.set_directional_light_source(new_light_source) -> None
        Set Directional Light Source
        
        Args:
            new_light_source (DirectionalLight):
        """
        ...
    def refresh(self) -> None:
        r"""
        x.refresh() -> None
        Refresh
        """
        ...

class ChaosVDSolverCollisionDataComponent(ActorComponent):
    r"""
    Chaos VDSolver Collision Data Component
    
    **C++ Source:**
    
    - **Plugin**: ChaosVD
    - **Module**: ChaosVD
    - **File**: ChaosVDSolverCollisionDataComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class ChaosVDSolverInfoActor(Actor):
    r"""
    Chaos VDSolver Info Actor
    
    **C++ Source:**
    
    - **Plugin**: ChaosVD
    - **Module**: ChaosVD
    - **File**: ChaosVDSolverInfoActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``simulation_transform`` (Transform):  [Read-Only]
    - ``solver_id`` (int32):  [Read-Only]
    - ``solver_name`` (str):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class ChaosVDSolverJointConstraintDataComponent(ActorComponent):
    r"""
    Chaos VDSolver Joint Constraint Data Component
    
    **C++ Source:**
    
    - **Plugin**: ChaosVD
    - **Module**: ChaosVD
    - **File**: ChaosVDSolverJointConstraintDataComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class ChaosVDStaticMeshComponent(StaticMeshComponent):
    r"""
    CVD version of a Static Mesh Component that holds additional CVD data
    
    **C++ Source:**
    
    - **Plugin**: ChaosVD
    - **Module**: ChaosVD
    - **File**: ChaosVDStaticMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_distance_field_indirect_shadow`` (bool):  [Read-Write] Whether to use the mesh distance field representation (when present) for shadowing indirect lighting (from lightmaps or skylight) on Movable components.
      This works like capsule shadows on skeletal meshes, except using the mesh distance field so no physics asset is required.
      The StaticMesh must have 'Generate Mesh Distance Field' enabled, or the project must have 'Generate Mesh Distance Fields' enabled for this feature to work.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disallow_mesh_paint_per_instance`` (bool):  [Read-Write] If true, mesh painting is disallowed on this instance. Set if vertex colors are overridden in a construction script.
    - ``disallow_nanite`` (bool):  [Read-Write] Forces this component to use fallback mesh for rendering if Nanite is enabled on the mesh.
    - ``distance_field_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the dynamic indirect shadow can be.
    - ``distance_field_self_shadow_bias`` (float):  [Read-Write] Useful for reducing self shadowing from distance field methods when using world position offset to animate the mesh's vertices.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``evaluate_world_position_offset`` (bool):  [Read-Write] Whether to evaluate World Position Offset.
    - ``evaluate_world_position_offset_in_ray_tracing`` (bool):  [Read-Write] Whether to evaluate World Position Offset for ray tracing.
      This is only used when running with r.RayTracing.Geometry.StaticMeshes.WPO=1
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``force_nanite_for_masked`` (bool):  [Read-Write] Forces this component to always use Nanite for masked materials, even if FNaniteSettings::bAllowMaskedMaterials=false
    - ``forced_lod_model`` (int32):  [Read-Write] If 0, auto-select LOD level. if >0, force to (ForcedLodModel-1).
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_instance_for_texture_streaming`` (bool):  [Read-Write] Ignore this instance of this static mesh when calculating streaming information.
      This can be useful when doing things like applying character textures to static geometry,
      to avoid them using distance-based streaming.
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``lightmass_settings`` (LightmassPrimitiveSettings):  [Read-Write] The Lightmass settings for this object.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod`` (int32):  [Read-Write] Specifies the smallest LOD that will be used for this component.
      This is ignored if ForcedLodModel is enabled.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``overridden_light_map_res`` (int32):  [Read-Write] Light map resolution to use on this component, used if bOverrideLightMapRes is true and there is a valid StaticMesh.
    - ``override_distance_field_self_shadow_bias`` (bool):  [Read-Write] Whether to override the DistanceFieldSelfShadowBias setting of the static mesh asset with the DistanceFieldSelfShadowBias of this component.
    - ``override_light_map_res`` (bool):  [Read-Write] Whether to override the lightmap resolution defined in the static mesh.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether to override the MinLOD setting of the static mesh asset with the MinLOD of this component.
    - ``override_wireframe_color`` (bool):  [Read-Write] If true, WireframeColorOverride will be used. If false, color is determined based on mobility and physics simulation settings
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``previous_lod_level`` (int32):  [Read-Write] LOD that was desired for rendering this StaticMeshComponent last frame.
      deprecated: This property is deprecated and no longer supported.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``reverse_culling`` (bool):  [Read-Write] Controls whether the static mesh component's backface culling should be reversed
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``sort_triangles`` (bool):  [Read-Write] Enable dynamic sort mesh's triangles to remove ordering issue when rendered with a translucent material
    - ``static_mesh`` (StaticMesh):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_default_collision`` (bool):  [Read-Write] Use the collision profile specified in the StaticMesh asset.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color_override`` (Color):  [Read-Write] Wireframe color to use if bOverrideWireframeColor is true
    - ``world_position_offset_disable_distance`` (int32):  [Read-Write] Distance at which to disable World Position Offset for an entire instance (0 = Never disable WPO).
    - ``world_position_offset_writes_velocity`` (bool):  [Read-Write] Whether world position offset turns on velocity writes.
      If the WPO isn't static then setting false may give incorrect motion vectors.
      But if we know that the WPO is static then setting false may save performance.
    """
    ...

class TraceUtilLibrary(BlueprintFunctionLibrary):
    r"""
    Trace Util Library
    
    **C++ Source:**
    
    - **Plugin**: TraceUtilities
    - **Module**: TraceUtilities
    - **File**: TraceUtilLibrary.h
    
    """
    @classmethod
    def trace_mark_region_start(cls, name: str) -> None:
        r"""
        X.trace_mark_region_start(name) -> None
        Traces a begin event for a region with specified name.
        
        Args:
            name (str):
        """
        ...
    @classmethod
    def trace_mark_region_end(cls, name: str) -> None:
        r"""
        X.trace_mark_region_end(name) -> None
        Traces an end event for a region with specified name.
        
        Args:
            name (str):
        """
        ...
    @classmethod
    def trace_bookmark(cls, name: str) -> None:
        r"""
        X.trace_bookmark(name) -> None
        Traces a bookmark with specified name.
        
        Args:
            name (str):
        """
        ...
    @classmethod
    def toggle_channel(cls, channel_name: str, enabled: bool) -> bool:
        r"""
        X.toggle_channel(channel_name, enabled) -> bool
        Toggle Channel
        
        Args:
            channel_name (str): 
            enabled (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def stop_tracing(cls) -> bool:
        r"""
        X.stop_tracing() -> bool
        Stop Tracing
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def start_trace_to_file(cls, file_name: str, channels: Array[str]) -> bool:
        r"""
        X.start_trace_to_file(file_name, channels) -> bool
        Start Trace to File
        
        Args:
            file_name (str): 
            channels (Array[str]): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def start_trace_send_to(cls, target: str, channels: Array[str]) -> bool:
        r"""
        X.start_trace_send_to(target, channels) -> bool
        Start Trace Send To
        
        Args:
            target (str): 
            channels (Array[str]): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def resume_tracing(cls) -> bool:
        r"""
        X.resume_tracing() -> bool
        Resume Tracing
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def pause_tracing(cls) -> bool:
        r"""
        X.pause_tracing() -> bool
        Pause Tracing
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_tracing(cls) -> bool:
        r"""
        X.is_tracing() -> bool
        Is Tracing
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_channel_enabled(cls, channel_name: str) -> bool:
        r"""
        X.is_channel_enabled(channel_name) -> bool
        Is Channel Enabled
        
        Args:
            channel_name (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_enabled_channels(cls) -> Array[str]:
        r"""
        X.get_enabled_channels() -> Array[str]
        Get Enabled Channels
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def get_all_channels(cls) -> Array[str]:
        r"""
        X.get_all_channels() -> Array[str]
        Get All Channels
        
        Returns:
            Array[str]:
        """
        ...

class AutomationUtilsBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Automation Utils Blueprint Library
    
    **C++ Source:**
    
    - **Plugin**: AutomationUtils
    - **Module**: AutomationUtils
    - **File**: AutomationUtilsBlueprintLibrary.h
    
    """
    @classmethod
    def take_gameplay_automation_screenshot(cls, screenshot_name: str, max_global_error: float = 0.020000, max_local_error: float = 0.120000, map_name_override: str = "") -> None:
        r"""
        X.take_gameplay_automation_screenshot(screenshot_name, max_global_error=0.020000, max_local_error=0.120000, map_name_override="") -> None
        Take Gameplay Automation Screenshot
        
        Args:
            screenshot_name (str): 
            max_global_error (float): 
            max_local_error (float): 
            map_name_override (str):
        """
        ...

class GeometryCollectionCacheFactory(Factory):
    r"""
    Geometry Collection Cache Factory
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionEditor
    - **File**: GeometryCollectionCacheFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class GeometryCollectionFactory(Factory):
    r"""
    Factory for Simple Cube
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionEditor
    - **File**: GeometryCollectionFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MovieSceneGeometryCollectionSection(MovieSceneSection):
    r"""
    Movie scene section that control geometry cache playback
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionTracks
    - **File**: MovieSceneGeometryCollectionSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``params`` (MovieSceneGeometryCollectionParams):  [Read-Write]
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class MovieSceneGeometryCollectionTrack(MovieSceneNameableTrack):
    r"""
    Movie Scene Geometry Collection Track
    
    **C++ Source:**
    
    - **Plugin**: GeometryCollectionPlugin
    - **Module**: GeometryCollectionTracks
    - **File**: MovieSceneGeometryCollectionTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class DataflowAssetFactory(Factory):
    r"""
    Dataflow Asset Factory
    
    **C++ Source:**
    
    - **Plugin**: Dataflow
    - **Module**: DataflowEditor
    - **File**: DataflowAssetFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class DataflowActor(Actor):
    r"""
    Dataflow Actor
    
    **C++ Source:**
    
    - **Plugin**: Dataflow
    - **Module**: DataflowEnginePlugin
    - **File**: DataflowActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``dataflow_component`` (DataflowComponent):  [Read-Only] DataflowComponent
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def dataflow_component(self) -> DataflowComponent:
        r"""
        (DataflowComponent):  [Read-Only] DataflowComponent
        """
        ...

class DataflowComponent(PrimitiveComponent):
    r"""
    UDataflowComponent
    
    **C++ Source:**
    
    - **Plugin**: Dataflow
    - **Module**: DataflowEnginePlugin
    - **File**: DataflowComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class ChaosSolverFactory(Factory):
    r"""
    Factory for Simple Cube
    
    **C++ Source:**
    
    - **Plugin**: ChaosSolverPlugin
    - **Module**: ChaosSolverEditor
    - **File**: ChaosSolverFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class LocalizableMessageLibrary(BlueprintFunctionLibrary):
    r"""
    BlueprintFunctionLibrary for LocalizableMessage
    
    **C++ Source:**
    
    - **Plugin**: LocalizableMessage
    - **Module**: LocalizableMessageBlueprint
    - **File**: LocalizableMessageLibrary.h
    
    """
    @classmethod
    def reset_localizable_message(cls, message: LocalizableMessage) -> LocalizableMessage:
        r"""
        X.reset_localizable_message(message) -> LocalizableMessage
        Resets the Localizable Message
        
        Args:
            message (LocalizableMessage): 
        
        Returns:
            LocalizableMessage: 
        
            message (LocalizableMessage):
        """
        ...
    @classmethod
    def is_empty_localizable_message(cls, message: LocalizableMessage) -> bool:
        r"""
        X.is_empty_localizable_message(message) -> bool
        Returns true if the message is empty
        
        Args:
            message (LocalizableMessage): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def conv_localizable_message_to_text(cls, world_context_object: Object, message: LocalizableMessage) -> Text:
        r"""
        X.conv_localizable_message_to_text(world_context_object, message) -> Text
        Conversion function from LocalizableMessage to FText.
        
        Args:
            world_context_object (Object): 
            message (LocalizableMessage): 
        
        Returns:
            Text:
        """
        ...

class InteractiveToolPropertySet(Object):
    r"""
    A UInteractiveTool contains a set of UObjects that contain "properties" of the Tool, ie
    the configuration flags, parameters, etc that control the Tool. Currently any UObject
    can be added as a property set, however there is no automatic mechanism for those child
    UObjects to notify the Tool when a property changes.
    
    If you make your property set UObjects subclasses of UInteractiveToolPropertySet, then
    when the Tool Properties are changed *in the Editor*, the parent Tool will be automatically notified.
    You can override UInteractiveTool::OnPropertyModified() to act on these notifications
    
    **C++ Source:**
    
    - **Module**: InteractiveToolsFramework
    - **File**: InteractiveTool.h
    
    """
    ...

class BakeMultiTexture2DProperties(InteractiveToolPropertySet):
    r"""
    Bake Multi Texture 2DProperties
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolsetExp
    - **Module**: MeshModelingToolsExp
    - **File**: BakeMeshAttributeToolCommon.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``all_source_textures`` (Array[Texture2D]):  [Read-Only] The set of all source textures from all input materials
    - ``material_id_source_textures`` (Array[Texture2D]):  [Read-Write] For each material ID, the source texture that will be resampled in that material's region
    - ``uv_layer`` (str):  [Read-Write] UV channel to use for the source mesh texture
    """
    @property
    def all_source_textures(self) -> Array[Texture2D]:
        r"""
        (Array[Texture2D]):  [Read-Only] The set of all source textures from all input materials
        """
        ...

class SkeletonModifier(Object):
    r"""
    FSkeletalMeshSkeletonModifier
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolsetExp
    - **Module**: SkeletalMeshModifiers
    - **File**: SkeletonModifier.h
    
    """
    def set_skeletal_mesh(self, skeletal_mesh: SkeletalMesh) -> bool:
        r"""
        x.set_skeletal_mesh(skeletal_mesh) -> bool
        Set Skeletal Mesh
        
        Args:
            skeletal_mesh (SkeletalMesh): 
        
        Returns:
            bool:
        """
        ...
    def set_bone_transform(self, bone_name: Name, new_transform: Transform, move_children: bool) -> bool:
        r"""
        x.set_bone_transform(bone_name, new_transform, move_children) -> bool
        Sets the bone the desired local transform
        
        Args:
            bone_name (Name): The new bone's name that needs to be moved.
            new_transform (Transform): The new local transform in the bone's parent space.
            move_children (bool): Propagate new transform to children
        
        Returns:
            bool: \c true if the operation succeeded, false otherwise.
        """
        ...
    def set_bones_transforms(self, bone_names: Array[Name], new_transforms: Array[Transform], move_children: bool) -> bool:
        r"""
        x.set_bones_transforms(bone_names, new_transforms, move_children) -> bool
        Set Bones Transforms
        
        Args:
            bone_names (Array[Name]): 
            new_transforms (Array[Transform]): 
            move_children (bool): 
        
        Returns:
            bool:
        """
        ...
    def rename_bones(self, old_bone_names: Array[Name], new_bone_names: Array[Name]) -> bool:
        r"""
        x.rename_bones(old_bone_names, new_bone_names) -> bool
        Rename Bones
        
        Args:
            old_bone_names (Array[Name]): 
            new_bone_names (Array[Name]): 
        
        Returns:
            bool:
        """
        ...
    def rename_bone(self, old_bone_name: Name, new_bone_name: Name) -> bool:
        r"""
        x.rename_bone(old_bone_name, new_bone_name) -> bool
        Rename bones
        
        Args:
            old_bone_name (Name): The current bone's name.
            new_bone_name (Name): The new bone's name.
        
        Returns:
            bool: \c true if the operation succeeded, false otherwise.
        """
        ...
    def remove_bones(self, bone_names: Array[Name], remove_children: bool) -> bool:
        r"""
        x.remove_bones(bone_names, remove_children) -> bool
        Remove Bones
        
        Args:
            bone_names (Array[Name]): 
            remove_children (bool): 
        
        Returns:
            bool:
        """
        ...
    def remove_bone(self, bone_name: Name, remove_children: bool) -> bool:
        r"""
        x.remove_bone(bone_name, remove_children) -> bool
        Remove a bone in the skeleton hierarchy
        
        Args:
            bone_name (Name): The new bone's name.
            remove_children (bool): Remove children recursively.
        
        Returns:
            bool: \c true if the operation succeeded, false otherwise.
        """
        ...
    def parent_bones(self, bone_names: Array[Name], parent_names: Array[Name]) -> bool:
        r"""
        x.parent_bones(bone_names, parent_names) -> bool
        Parent Bones
        
        Args:
            bone_names (Array[Name]): 
            parent_names (Array[Name]): 
        
        Returns:
            bool:
        """
        ...
    def parent_bone(self, bone_name: Name, parent_name: Name) -> bool:
        r"""
        x.parent_bone(bone_name, parent_name) -> bool
        Parent bones
        
        Args:
            bone_name (Name): The current bone's name.
            parent_name (Name): The new parent's name (Name_NONE to unparent).
        
        Returns:
            bool: \c true if the operation succeeded, false otherwise.
        """
        ...
    def orient_bones(self, bone_names: Array[Name], options: OrientOptions = [OrientAxis.POSITIVE_X, OrientAxis.POSITIVE_Y, True, [0.000000, 1.000000, 0.000000], True]) -> bool:
        r"""
        x.orient_bones(bone_names, options=[OrientAxis.POSITIVE_X, OrientAxis.POSITIVE_Y, True, [0.000000, 1.000000, 0.000000], True]) -> bool
        Orient Bones
        
        Args:
            bone_names (Array[Name]): 
            options (OrientOptions): 
        
        Returns:
            bool:
        """
        ...
    def orient_bone(self, bone_name: Name, options: OrientOptions = [OrientAxis.POSITIVE_X, OrientAxis.POSITIVE_Y, True, [0.000000, 1.000000, 0.000000], True]) -> bool:
        r"""
        x.orient_bone(bone_name, options=[OrientAxis.POSITIVE_X, OrientAxis.POSITIVE_Y, True, [0.000000, 1.000000, 0.000000], True]) -> bool
        Align bones
        
        Args:
            bone_name (Name): The current bone's name.
            options (OrientOptions): The orienting options
        
        Returns:
            bool: \c true if the operation succeeded, false otherwise.
        """
        ...
    def mirror_bones(self, bones_name: Array[Name], options: MirrorOptions = [AxisType.X, True, "_l", "_r", True]) -> bool:
        r"""
        x.mirror_bones(bones_name, options=[AxisType.X, True, "_l", "_r", True]) -> bool
        Mirror Bones
        
        Args:
            bones_name (Array[Name]): 
            options (MirrorOptions): 
        
        Returns:
            bool:
        """
        ...
    def mirror_bone(self, bone_name: Name, options: MirrorOptions = [AxisType.X, True, "_l", "_r", True]) -> bool:
        r"""
        x.mirror_bone(bone_name, options=[AxisType.X, True, "_l", "_r", True]) -> bool
        Mirror bones
        
        Args:
            bone_name (Name): The new bone's name.
            options (MirrorOptions): The mirroring options
        
        Returns:
            bool: \c true if the operation succeeded, false otherwise.
        """
        ...
    def get_parent_name(self, bone_name: Name) -> Name:
        r"""
        x.get_parent_name(bone_name) -> Name
        Get Parent Name
        
        Args:
            bone_name (Name): The current bone's name.
        
        Returns:
            Name: \c The current bone's parent name
        """
        ...
    def get_children_names(self, bone_name: Name, recursive: bool = False) -> Array[Name]:
        r"""
        x.get_children_names(bone_name, recursive=False) -> Array[Name]
        Get Children Names
        
        Args:
            bone_name (Name): The parent's name.
            recursive (bool): If set to true grand-children will also be added recursively
        
        Returns:
            Array[Name]: \c The children names list
        """
        ...
    def get_bone_transform(self, bone_name: Name, global_: bool = False) -> Transform:
        r"""
        x.get_bone_transform(bone_name, global_=False) -> Transform
        Get Bone Transform
        
        Args:
            bone_name (Name): The current bone's name.
            global_ (bool): Whether it should return the parent space or global transform
        
        Returns:
            Transform: \c The current bone's transform
        """
        ...
    def get_all_bone_names(self) -> Array[Name]:
        r"""
        x.get_all_bone_names() -> Array[Name]
        Get All Bone Names
        
        Returns:
            Array[Name]: \c All bone names list
        """
        ...
    def commit_skeleton_to_skeletal_mesh(self) -> bool:
        r"""
        x.commit_skeleton_to_skeletal_mesh() -> bool
        Actually applies the skeleton modifications to the skeletal mesh.
        
        Returns:
            bool: true if commit succeeded.
        """
        ...
    def add_bones(self, bones_name: Array[Name], parents_name: Array[Name], transforms: Array[Transform]) -> bool:
        r"""
        x.add_bones(bones_name, parents_name, transforms) -> bool
        Add Bones
        
        Args:
            bones_name (Array[Name]): 
            parents_name (Array[Name]): 
            transforms (Array[Transform]): 
        
        Returns:
            bool:
        """
        ...
    def add_bone(self, bone_name: Name, parent_name: Name, transform: Transform) -> bool:
        r"""
        x.add_bone(bone_name, parent_name, transform) -> bool
        Creates a new bone in the skeleton hierarchy at desired transform
        
        Args:
            bone_name (Name): The new bone's name.
            parent_name (Name): The new bone parent's name.
            transform (Transform): The default local transform in the parent space.
        
        Returns:
            bool: \c true if the operation succeeded, false otherwise.
        """
        ...

class SkinWeightModifier(Object):
    r"""
    API used to modify skin weights on a Skeletal Mesh asset.
    
    To use:
    1. Instantiate an instance of USkinWeightModifier
    2. Call "SetSkeletalMesh(MyMeshAsset)", passing in the skeletal mesh you want to edit weights on
    3. Use Get/Set weights functions, and Normalize/Prune to edit the weights as desired
    4. When ready to commit to the asset, call CommitWeightsToSkeletalMesh() and save the asset if desired
    
    This API can be used from C++, Blueprint or Python. Here is a sample usage of the API in Python:
    
    import unreal
    
    # create a weight modifier for a given skeletal mesh
    skel_mesh = unreal.EditorAssetLibrary().load_asset("/Game/Characters/Wolf/Meshes/SK_Wolf")
    weight_modifier = unreal.SkinWeightModifier()
    weight_modifier.set_skeletal_mesh(skel_mesh)
    
    # get weight of vertex 1234
    vertex_weights = weight_modifier.get_vertex_weights(1234)
    print(vertex_weights)
    
    # remove neck2 as an influence on this vertex
    vertex_weights.pop("neck2")
    weight_modifier.set_vertex_weights(vertex_weights, True)
    print(vertex_weights)
    
    # commit change to the skeletal mesh
    weight_modifier.commit_weights_to_skeletal_mesh()
    
    OUTPUT:
    {"head": 0.6, "neck1": 0.3, "neck2": 0.1}
    {"head": 0.6, "neck1": 0.3}
    
    In Python, the per-vertex weights are stored as a dictionary mapping Bone Names to float weight values.
    
    The "SetVertexWeights()" function expects the same data structure. You can add/remove/edit influences as needed.
    The SetVertexWeights() function does not normalize the weights. So you can make multiple modifications
    and call NormalizeVertexWeights() or NormalizeAllWeights() as desired.
    
    The PruneVertexWeights() and EnforceMaxInfluences() functions can be used to trim small influences
    and clamp the total number of influences per vertex as needed.
    
    Note that it is not required to normalize the weights by calling any of the normalize functions. Or manually before
    calling SetVertexWeights(). Committing the weights to the skeletal mesh will always enforce normalization.
    
    Though it may be useful to normalize while editing.
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolsetExp
    - **Module**: SkeletalMeshModifiers
    - **File**: SkinWeightModifier.h
    
    """
    def set_vertex_weights(self, vertex_id: int, weights: Map[Name, float], replace_all: bool = False) -> bool:
        r"""
        x.set_vertex_weights(vertex_id, weights, replace_all=False) -> bool
        Set bone weights for a single vertex. The weights are stored as supplied and not normalized until
        either "CommitWeightsToSkeletalMesh()" or "NormalizeVertexWeights()" is called.
        
        Args:
            vertex_id (int32): the index of the vertex
            weights (Map[Name, float]): a map of Bone-Name to Weight for all bones that influence the specified vertex, ie {"Head": 0.6, "Neck": 0.4}
            replace_all (bool): if true, all weights on this vertex will be replaced with the input weights. Default is false.
        
        Returns:
            bool:
        """
        ...
    def set_skeletal_mesh(self, mesh: SkeletalMesh) -> bool:
        r"""
        x.set_skeletal_mesh(mesh) -> bool
        Call this first to load the weights for a skeletal mesh for fast editing.
        
        Args:
            mesh (SkeletalMesh): The skeletal mesh asset to load for weight editing
        
        Returns:
            bool: bool - true if the mesh weights were successfully loaded.
        """
        ...
    def prune_vertex_weights(self, vertex_id: int, weight_threshold: float) -> bool:
        r"""
        x.prune_vertex_weights(vertex_id, weight_threshold) -> bool
        Remove all weights below the given threshold value, on the given vertex.
        Influences that are pruned will no longer receive weight from normalization.
        
        Args:
            vertex_id (int32): the index of the vertex to prune weights on
            weight_threshold (float): vertex weights below this value will be removed.
        
        Returns:
            bool: true if influences were removed, false otherwise
        """
        ...
    def prune_all_weights(self, weight_threshold: float) -> bool:
        r"""
        x.prune_all_weights(weight_threshold) -> bool
        Remove all weights below the given threshold value, on all vertices.
        
        Args:
            weight_threshold (float): vertex weights below this value will be removed.
        
        Returns:
            bool: true if influences were removed, false otherwise
        """
        ...
    def normalize_vertex_weights(self, vertex_id: int) -> bool:
        r"""
        x.normalize_vertex_weights(vertex_id) -> bool
        Normalize weights on the specified vertex.
        
        Args:
            vertex_id (int32): the index of the vertex to normalize weights on
        
        Returns:
            bool: true if normalization was performed, false otherwise
        """
        ...
    def normalize_all_weights(self) -> bool:
        r"""
        x.normalize_all_weights() -> bool
        Normalize weights on all vertices in the mesh.
        
        Returns:
            bool: true if normalization was performed, false otherwise
        """
        ...
    def get_vertex_weights(self, vertex_id: int) -> Map[Name, float]:
        r"""
        x.get_vertex_weights(vertex_id) -> Map[Name, float]
        Get all bone weights for a single vertex.
        
        Args:
            vertex_id (int32): the index of the vertex
        
        Returns:
            Map[Name, float]: a map of Bone Name to weight values for all bones that influence the specified vertex.
        """
        ...
    def get_skeletal_mesh(self) -> SkeletalMesh:
        r"""
        x.get_skeletal_mesh() -> SkeletalMesh
        Get a reference to the skeletal mesh that was loaded
        
        Returns:
            SkeletalMesh: USkeletalMesh* - the mesh that was loaded, or null
        """
        ...
    def get_num_vertices(self) -> int:
        r"""
        x.get_num_vertices() -> int32
        Get the total number of vertices in the skeletal mesh.
        
        Returns:
            int32: int, number of vertices
        """
        ...
    def get_all_bone_names(self) -> Array[Name]:
        r"""
        x.get_all_bone_names() -> Array[Name]
        Get an array of all bone names in the skeletal mesh.
        
        Returns:
            Array[Name]: array of bone names
        """
        ...
    def enforce_max_influences(self, max_influences: int = -1) -> bool:
        r"""
        x.enforce_max_influences(max_influences=-1) -> bool
        Strips out smallest influences to ensure each vertex does not have weight on more influences than MaxInfluences.
        Influences with the smallest weight are culled first.
        
        Args:
            max_influences (int32): The maximum number of influences to allow for each vertex in the mesh. If -1 is passed, will use the project-wide MaxInfluences amount.
        
        Returns:
            bool: true if influences were removed, false otherwise
        """
        ...
    def commit_weights_to_skeletal_mesh(self) -> bool:
        r"""
        x.commit_weights_to_skeletal_mesh() -> bool
        Actually applies the weight modifications to the skeletal mesh. This action creates an undo transaction.
        The skeletal mesh asset will be dirtied, but it is up to the user to save the asset if required.
        
        Returns:
            bool: true if weights were applied to a skeletal mesh, false otherwise
        """
        ...

class EditorConfigBase(Object):
    r"""
    Inherit from this class to simplify saving and loading properties from editor configs.
    
    **C++ Source:**
    
    - **Module**: EditorConfig
    - **File**: EditorConfigBase.h
    
    """
    ...

class InteractiveToolsPresetCollectionAsset(EditorConfigBase):
    r"""
    Implements an asset that can be used to store tool settings as a named preset
    
    **C++ Source:**
    
    - **Plugin**: ToolPresets
    - **Module**: ToolPresetAsset
    - **File**: ToolPresetAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``collection_label`` (Text):  [Read-Write]
    - ``per_tool_presets`` (Map[str, InteractiveToolPresetStore]):  [Read-Only] TODO: Currently there are no helper methods within this class, simply providing
      raw access to the underlying arrays and maps. This is intentional.
      Until the design of the preset concept is more firmly decided, it seems like a waste to
      implement a bunch of methods that we don't know if we actually want/need at the end.
      Once we are satisifed with the data structure, planned accessors and mutators will include
      support for adding, removing, renaming, saving and retrieving presets.
    """
    ...

class InteractiveToolsPresetCollectionAssetFactory(Factory):
    r"""
    Interactive Tools Preset Collection Asset Factory
    
    **C++ Source:**
    
    - **Plugin**: ToolPresets
    - **Module**: ToolPresetAsset
    - **File**: ToolPresetAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class GeometryCache(Object):
    r"""
    A Geometry Cache is a piece/set of geometry that consists of individual Mesh/Transformation samples.
    In contrast with Static Meshes they can have their vertices animated in certain ways. *
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCache
    - **File**: GeometryCache.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only] Importing data and options used for this Geometry cache object
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the asset
    - ``end_frame`` (int32):  [Read-Write]
    - ``material_slot_names`` (Array[Name]):  [Read-Write]
    - ``materials`` (Array[MaterialInterface]):  [Read-Write]
    - ``start_frame`` (int32):  [Read-Write]
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``tracks`` (Array[GeometryCacheTrack]):  [Read-Only] GeometryCache track defining the samples/geometry data for this GeomCache instance
    """
    @property
    def materials(self) -> Array[MaterialInterface]:
        r"""
        (Array[MaterialInterface]):  [Read-Write]
        """
        ...
    @materials.setter
    def materials(self, value: Array[MaterialInterface]) -> None:
        ...
    @property
    def material_slot_names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write]
        """
        ...
    @material_slot_names.setter
    def material_slot_names(self, value: Array[Name]) -> None:
        ...
    @property
    def start_frame(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    @property
    def end_frame(self) -> int:
        r"""
        (int32):  [Read-Only]
        """
        ...
    def has_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.has_asset_user_data_of_class(user_data_class) -> bool
        Checks whether or not an instance of the provided AssetUserData class is contained.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to check for
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was found
        """
        ...
    def get_asset_user_data_of_class(self, user_data_class: Class) -> AssetUserData:
        r"""
        x.get_asset_user_data_of_class(user_data_class) -> AssetUserData
        Returns an instance of the provided AssetUserData class if it's contained in the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to get
        
        Returns:
            AssetUserData: The instance of the UAssetUserData class contained, or null if it doesn't exist
        """
        ...
    def add_asset_user_data_of_class(self, user_data_class: Class) -> bool:
        r"""
        x.add_asset_user_data_of_class(user_data_class) -> bool
        Creates and adds an instance of the provided AssetUserData class to the target asset.
        
        Args:
            user_data_class (type(Class)): UAssetUserData sub class to create
        
        Returns:
            bool: Whether or not an instance of InUserDataClass was succesfully added
        """
        ...

class GeometryCacheActor(Actor):
    r"""
    GeometryCache actor, serves as a place-able actor for GeometryCache objects
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCache
    - **File**: GeometryCacheActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``geometry_cache_component`` (GeometryCacheComponent):  [Read-Only]
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def geometry_cache_component(self) -> GeometryCacheComponent:
        r"""
        (GeometryCacheComponent):  [Read-Only]
        """
        ...
    def get_geometry_cache_component(self) -> GeometryCacheComponent:
        r"""
        x.get_geometry_cache_component() -> GeometryCacheComponent
        Returns GeometryCacheComponent subobject *
        
        Returns:
            GeometryCacheComponent:
        """
        ...

class GeometryCacheComponent(MeshComponent):
    r"""
    GeometryCacheComponent, encapsulates a GeometryCache asset instance and implements functionality for rendering/and playback of GeometryCaches
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCache
    - **File**: GeometryCacheComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``duration`` (float):  [Read-Write] Duration of the animation (maximum time)
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``elapsed_time`` (float):  [Read-Only]
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``extrapolate_frames`` (bool):  [Read-Write] Enable frame extrapolation for sub-frame sampling of non-constant topologies with imported motion vectors
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``geometry_cache`` (GeometryCache):  [Read-Write] Geometry Cache instance referenced by the component
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``looping`` (bool):  [Read-Write]
    - ``manual_tick`` (bool):  [Read-Write]
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``motion_vector_scale`` (float):  [Read-Write] Scale factor to apply to the imported motion vectors
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``num_tracks`` (int32):  [Read-Only]
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_wireframe_color`` (bool):  [Read-Write] Do we override the wireframe rendering color?
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``playback_speed`` (float):  [Read-Write]
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``running`` (bool):  [Read-Write]
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``start_time_offset`` (float):  [Read-Write]
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_override_color`` (LinearColor):  [Read-Write] The wireframe override color.
    """
    @property
    def geometry_cache(self) -> GeometryCache:
        r"""
        (GeometryCache):  [Read-Only] Geometry Cache instance referenced by the component
        """
        ...
    @property
    def running(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @running.setter
    def running(self, value: bool) -> None:
        ...
    @property
    def looping(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @looping.setter
    def looping(self, value: bool) -> None:
        ...
    @property
    def start_time_offset(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @start_time_offset.setter
    def start_time_offset(self, value: float) -> None:
        ...
    @property
    def playback_speed(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @playback_speed.setter
    def playback_speed(self, value: float) -> None:
        ...
    @property
    def motion_vector_scale(self) -> float:
        r"""
        (float):  [Read-Write] Scale factor to apply to the imported motion vectors
        """
        ...
    @motion_vector_scale.setter
    def motion_vector_scale(self, value: float) -> None:
        ...
    @property
    def duration(self) -> float:
        r"""
        (float):  [Read-Only] Duration of the animation (maximum time)
        """
        ...
    def tick_at_this_time(self, time: float, is_running: bool, backwards: bool, is_looping: bool) -> None:
        r"""
        x.tick_at_this_time(time, is_running, backwards, is_looping) -> None
        Tick at This Time
        
        Args:
            time (float): 
            is_running (bool): 
            backwards (bool): 
            is_looping (bool):
        """
        ...
    def stop(self) -> None:
        r"""
        x.stop() -> None
        Stop playback of GeometryCache
        """
        ...
    def set_wireframe_override_color(self, color: LinearColor) -> None:
        r"""
        x.set_wireframe_override_color(color) -> None
        Set the color, used when overriding the wireframe color is enabled.
        
        Args:
            color (LinearColor):
        """
        ...
    def set_start_time_offset(self, new_start_time_offset: float) -> None:
        r"""
        x.set_start_time_offset(new_start_time_offset) -> None
        Set current start time offset for GeometryCache.
        
        Args:
            new_start_time_offset (float):
        """
        ...
    def set_playback_speed(self, new_playback_speed: float) -> None:
        r"""
        x.set_playback_speed(new_playback_speed) -> None
        Set new playback speed for GeometryCache.
        
        Args:
            new_playback_speed (float):
        """
        ...
    def set_override_wireframe_color(self, override: bool) -> None:
        r"""
        x.set_override_wireframe_color(override) -> None
        Override wireframe color?
        
        Args:
            override (bool):
        """
        ...
    def set_motion_vector_scale(self, new_motion_vector_scale: float) -> None:
        r"""
        x.set_motion_vector_scale(new_motion_vector_scale) -> None
        Set new motion vector scale.
        
        Args:
            new_motion_vector_scale (float):
        """
        ...
    def set_looping(self, new_looping: bool) -> None:
        r"""
        x.set_looping(new_looping) -> None
        Set whether this GeometryCache is looping or not.
        
        Args:
            new_looping (bool):
        """
        ...
    def set_geometry_cache(self, new_geom_cache: GeometryCache) -> bool:
        r"""
        x.set_geometry_cache(new_geom_cache) -> bool
        Change the Geometry Cache used by this instance.
        
        Args:
            new_geom_cache (GeometryCache): 
        
        Returns:
            bool:
        """
        ...
    def set_extrapolate_frames(self, new_extrapolating: bool) -> None:
        r"""
        x.set_extrapolate_frames(new_extrapolating) -> None
        Set whether this GeometryCache is extrapolating frames.
        
        Args:
            new_extrapolating (bool):
        """
        ...
    def play_reversed_from_end(self) -> None:
        r"""
        x.play_reversed_from_end() -> None
        Start playback of GeometryCache from the end and play in reverse
        """
        ...
    def play_reversed(self) -> None:
        r"""
        x.play_reversed() -> None
        Start playback of GeometryCache in reverse
        """
        ...
    def play_from_start(self) -> None:
        r"""
        x.play_from_start() -> None
        Start playback of GeometryCache from the start
        """
        ...
    def play(self) -> None:
        r"""
        x.play() -> None
        Start playback of GeometryCache
        """
        ...
    def pause(self) -> None:
        r"""
        x.pause() -> None
        Pause playback of GeometryCache
        """
        ...
    def is_playing_reversed(self) -> bool:
        r"""
        x.is_playing_reversed() -> bool
        Get whether this GeometryCache is playing in reverse or not.
        
        Returns:
            bool:
        """
        ...
    def is_playing(self) -> bool:
        r"""
        x.is_playing() -> bool
        Get whether this GeometryCache is playing or not.
        
        Returns:
            bool:
        """
        ...
    def is_looping(self) -> bool:
        r"""
        x.is_looping() -> bool
        Get whether this GeometryCache is looping or not.
        
        Returns:
            bool:
        """
        ...
    def is_extrapolating_frames(self) -> bool:
        r"""
        x.is_extrapolating_frames() -> bool
        Get whether this GeometryCache is extrapolating frames.
        
        Returns:
            bool:
        """
        ...
    def get_wireframe_override_color(self) -> LinearColor:
        r"""
        x.get_wireframe_override_color() -> LinearColor
        Get the wireframe override color, used when overriding the wireframe color is enabled.
        
        Returns:
            LinearColor:
        """
        ...
    def get_start_time_offset(self) -> float:
        r"""
        x.get_start_time_offset() -> float
        Get current start time offset for GeometryCache.
        
        Returns:
            float:
        """
        ...
    def get_playback_speed(self) -> float:
        r"""
        x.get_playback_speed() -> float
        Get current playback speed for GeometryCache.
        
        Returns:
            float:
        """
        ...
    def get_playback_direction(self) -> float:
        r"""
        x.get_playback_direction() -> float
        Set the current animation time for GeometryCache. Includes the influence of elapsed time and SetStartTimeOffset
        
        Returns:
            float:
        """
        ...
    def get_override_wireframe_color(self) -> bool:
        r"""
        x.get_override_wireframe_color() -> bool
        Check whether we are overriding the wireframe color or not.
        
        Returns:
            bool:
        """
        ...
    def get_number_of_frames(self) -> int:
        r"""
        x.get_number_of_frames() -> int32
        Get the number of frames
        
        Returns:
            int32:
        """
        ...
    def get_motion_vector_scale(self) -> float:
        r"""
        x.get_motion_vector_scale() -> float
        Get the motion vector scale.
        
        Returns:
            float:
        """
        ...
    def get_duration(self) -> float:
        r"""
        x.get_duration() -> float
        Get the duration of the playback
        
        Returns:
            float:
        """
        ...
    def get_animation_time(self) -> float:
        r"""
        x.get_animation_time() -> float
        Set the current animation time for GeometryCache. Includes the influence of elapsed time and SetStartTimeOffset
        
        Returns:
            float:
        """
        ...

class GeometryCacheTrack(Object):
    r"""
    Base class for GeometryCache tracks, stores matrix animation data and implements functionality for it
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCache
    - **File**: GeometryCacheTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration`` (float):  [Read-Only] The duration of this track's animation. This is an open ended interval [0..Duration[.
      If the animation is looping this is also the length of the loop.
      
      Note: This is set by the importer possibly based on user preferences. There may be less actual frames available.
      E.g. the animation has data for the first 2 seconds, but duration is set to 5, so it will loop every 5 seconds
      with the last three seconds showing a static scene.
    """
    ...

class GeometryCacheTrack_FlipbookAnimation(GeometryCacheTrack):
    r"""
    Derived GeometryCacheTrack class, used for Transform animation.
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCache
    - **File**: GeometryCacheTrackFlipbookAnimation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration`` (float):  [Read-Only] The duration of this track's animation. This is an open ended interval [0..Duration[.
      If the animation is looping this is also the length of the loop.
      
      Note: This is set by the importer possibly based on user preferences. There may be less actual frames available.
      E.g. the animation has data for the first 2 seconds, but duration is set to 5, so it will loop every 5 seconds
      with the last three seconds showing a static scene.
    - ``num_mesh_samples`` (uint32):  [Read-Only] Number of Mesh Sample within this track
    """
    ...

class GeometryCacheTrackStreamable(GeometryCacheTrack):
    r"""
    Derived GeometryCacheTrack class, used for Transform animation.
    
    \note FGeometryCacheTrackStreamableRenderResource keeps a reference to the track.
    Be sure to keep the implementation of this class valid so it properly releases
    the render resoruce before making any changes to this object that may affect the render thread.
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCache
    - **File**: GeometryCacheTrackStreamable.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``codec`` (GeometryCacheCodecBase):  [Read-Only] Codec for this track
    - ``duration`` (float):  [Read-Only] The duration of this track's animation. This is an open ended interval [0..Duration[.
      If the animation is looping this is also the length of the loop.
      
      Note: This is set by the importer possibly based on user preferences. There may be less actual frames available.
      E.g. the animation has data for the first 2 seconds, but duration is set to 5, so it will loop every 5 seconds
      with the last three seconds showing a static scene.
    """
    ...

class GeometryCacheTrack_TransformAnimation(GeometryCacheTrack):
    r"""
    Derived GeometryCacheTrack class, used for Transform animation.
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCache
    - **File**: GeometryCacheTrackTransformAnimation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration`` (float):  [Read-Only] The duration of this track's animation. This is an open ended interval [0..Duration[.
      If the animation is looping this is also the length of the loop.
      
      Note: This is set by the importer possibly based on user preferences. There may be less actual frames available.
      E.g. the animation has data for the first 2 seconds, but duration is set to 5, so it will loop every 5 seconds
      with the last three seconds showing a static scene.
    """
    ...

class GeometryCacheTrack_TransformGroupAnimation(GeometryCacheTrack):
    r"""
    Derived GeometryCacheTrack class, used for Transform animation.
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCache
    - **File**: GeometryCacheTrackTransformGroupAnimation.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``duration`` (float):  [Read-Only] The duration of this track's animation. This is an open ended interval [0..Duration[.
      If the animation is looping this is also the length of the loop.
      
      Note: This is set by the importer possibly based on user preferences. There may be less actual frames available.
      E.g. the animation has data for the first 2 seconds, but duration is set to 5, so it will loop every 5 seconds
      with the last three seconds showing a static scene.
    """
    ...

class GeometryCacheCodecBase(Object):
    r"""
    Interface for assets/objects that can own UserData *
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCache
    - **File**: GeometryCacheCodecBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``topology_ranges`` (Array[int32]):  [Read-Only] Frames at which the topology of the decoded frames changes sorted in increasing order
      this allows fast topology queries between arbitrary frames.
      each codec has to fill this
    """
    ...

class AbcAssetImportData(AssetImportData):
    r"""
    Base class for import data and options used when importing any asset from Alembic
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    ...

class AbcImportSettings(Object):
    r"""
    Class that contains all options for importing an alembic file
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicLibrary
    - **File**: AbcImportSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``compression_settings`` (AbcCompressionSettings):  [Read-Write]
    - ``conversion_settings`` (AbcConversionSettings):  [Read-Write]
    - ``geometry_cache_settings`` (AbcGeometryCacheSettings):  [Read-Write]
    - ``import_type`` (AlembicImportType):  [Read-Write] Type of asset to import from Alembic file
    - ``material_settings`` (AbcMaterialSettings):  [Read-Write]
    - ``normal_generation_settings`` (AbcNormalGenerationSettings):  [Read-Write]
    - ``sampling_settings`` (AbcSamplingSettings):  [Read-Write]
    - ``static_mesh_settings`` (AbcStaticMeshSettings):  [Read-Write]
    """
    @property
    def import_type(self) -> AlembicImportType:
        r"""
        (AlembicImportType):  [Read-Write] Type of asset to import from Alembic file
        """
        ...
    @import_type.setter
    def import_type(self, value: AlembicImportType) -> None:
        ...
    @property
    def sampling_settings(self) -> AbcSamplingSettings:
        r"""
        (AbcSamplingSettings):  [Read-Write]
        """
        ...
    @sampling_settings.setter
    def sampling_settings(self, value: AbcSamplingSettings) -> None:
        ...
    @property
    def normal_generation_settings(self) -> AbcNormalGenerationSettings:
        r"""
        (AbcNormalGenerationSettings):  [Read-Write]
        """
        ...
    @normal_generation_settings.setter
    def normal_generation_settings(self, value: AbcNormalGenerationSettings) -> None:
        ...
    @property
    def material_settings(self) -> AbcMaterialSettings:
        r"""
        (AbcMaterialSettings):  [Read-Write]
        """
        ...
    @material_settings.setter
    def material_settings(self, value: AbcMaterialSettings) -> None:
        ...
    @property
    def compression_settings(self) -> AbcCompressionSettings:
        r"""
        (AbcCompressionSettings):  [Read-Write]
        """
        ...
    @compression_settings.setter
    def compression_settings(self, value: AbcCompressionSettings) -> None:
        ...
    @property
    def static_mesh_settings(self) -> AbcStaticMeshSettings:
        r"""
        (AbcStaticMeshSettings):  [Read-Write]
        """
        ...
    @static_mesh_settings.setter
    def static_mesh_settings(self, value: AbcStaticMeshSettings) -> None:
        ...
    @property
    def geometry_cache_settings(self) -> AbcGeometryCacheSettings:
        r"""
        (AbcGeometryCacheSettings):  [Read-Write]
        """
        ...
    @geometry_cache_settings.setter
    def geometry_cache_settings(self, value: AbcGeometryCacheSettings) -> None:
        ...
    @property
    def conversion_settings(self) -> AbcConversionSettings:
        r"""
        (AbcConversionSettings):  [Read-Write]
        """
        ...
    @conversion_settings.setter
    def conversion_settings(self, value: AbcConversionSettings) -> None:
        ...

class AlembicImportFactory(Factory):
    r"""
    Alembic Import Factory
    
    **C++ Source:**
    
    - **Plugin**: AlembicImporter
    - **Module**: AlembicImporter
    - **File**: AlembicImportFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AnimationSharingSetupFactory(Factory):
    r"""
    Animation Sharing Setup Factory
    
    **C++ Source:**
    
    - **Plugin**: AnimationSharing
    - **Module**: AnimationSharingEd
    - **File**: AnimationSharingSetupFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class LayersBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Function library containing methods for interacting with editor layers
    
    **C++ Source:**
    
    - **Plugin**: ActorLayerUtilities
    - **Module**: ActorLayerUtilities
    - **File**: ActorLayerUtilities.h
    
    """
    @classmethod
    def remove_actor_from_layer(cls, actor: Actor, layer: ActorLayer) -> None:
        r"""
        X.remove_actor_from_layer(actor, layer) -> None
        Removes the actor from the specified layer
        
        Args:
            actor (Actor): 
            layer (ActorLayer):
        """
        ...
    @classmethod
    def get_actors(cls, world_context_object: Object, actor_layer: ActorLayer) -> Array[Actor]:
        r"""
        X.get_actors(world_context_object, actor_layer) -> Array[Actor]
        Get all the actors in this layer
        
        Args:
            world_context_object (Object): 
            actor_layer (ActorLayer): 
        
        Returns:
            Array[Actor]:
        """
        ...
    @classmethod
    def add_actor_to_layer(cls, actor: Actor, layer: ActorLayer) -> None:
        r"""
        X.add_actor_to_layer(actor, layer) -> None
        Adds the actor to the specified layer
        
        Args:
            actor (Actor): 
            layer (ActorLayer):
        """
        ...

class ArchVisCharacter(Character):
    r"""
    Arch Vis Character
    
    **C++ Source:**
    
    - **Plugin**: ArchVisCharacter
    - **Module**: ArchVisCharacter
    - **File**: ArchVisCharacter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``ai_controller_class`` (type(Class)):  [Read-Write] Default class to use when pawn is controlled by AI.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_possess_ai`` (AutoPossessAI):  [Read-Write] Determines when the Pawn creates and is possessed by an AI Controller (on level start, when spawned, etc).
      Only possible if AIControllerClassRef is set, and ignored if AutoPossessPlayer is enabled.
      see: AutoPossessPlayer
    - ``auto_possess_player`` (AutoReceiveInput):  [Read-Write] Determines which PlayerController, if any, should automatically possess the pawn when the level starts or when the pawn is spawned.
      see: AutoPossessAI
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``base_eye_height`` (float):  [Read-Write] Base eye height above collision center.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_affect_navigation_generation`` (bool):  [Read-Write] If set to false (default) given pawn instance will never affect navigation generation (but components could).
      Setting it to true will result in using regular AActor's navigation relevancy
      calculation to check if this pawn instance should affect navigation generation.
      note: Use SetCanAffectNavigationGeneration() to change this value at runtime.
      note: Modifying this value at runtime will result in any navigation change only if runtime navigation generation is enabled.
      note: Override UpdateNavigationRelevance() to propagate the flag to the desired components.
      see: SetCanAffectNavigationGeneration(), UpdateNavigationRelevance()
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``capsule_component`` (CapsuleComponent):  [Read-Only] The CapsuleComponent being used for movement collision (by CharacterMovement). Always treated as being vertically aligned in simple collision check functions.
    - ``character_movement`` (CharacterMovementComponent):  [Read-Only] Movement component used for movement logic in various movement modes (walking, falling, etc), containing relevant settings and functions to control movement.
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``crouched_eye_height`` (float):  [Read-Write] Default crouched eye height
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_crouched`` (bool):  [Read-Write] Set by character movement to specify that this Character is currently crouched.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``jump_current_count`` (int32):  [Read-Only] Tracks the current number of jumps performed.
      This is incremented in CheckJumpInput, used in CanJump_Implementation, and reset in OnMovementModeChanged.
      When providing overrides for these methods, it's recommended to either manually
      increment / reset this value, or call the Super:: method.
    - ``jump_current_count_pre_jump`` (int32):  [Read-Only] Represents the current number of jumps performed before CheckJumpInput modifies JumpCurrentCount.
      This is set in CheckJumpInput and is used in SetMoveFor and PrepMoveFor instead of JumpCurrentCount
      since CheckJumpInput can modify JumpCurrentCount.
      When providing overrides for these methods, it's recommended to either manually
      set this value, or call the Super:: method.
    - ``jump_force_time_remaining`` (float):  [Read-Only] Amount of jump force time remaining, if JumpMaxHoldTime > 0.
    - ``jump_key_hold_time`` (float):  [Read-Only] Jump key Held Time.
      This is the time that the player has held the jump key, in seconds.
    - ``jump_max_count`` (int32):  [Read-Write] The max number of jumps the character can perform.
      Note that if JumpMaxHoldTime is non zero and StopJumping is not called, the player
      may be able to perform and unlimited number of jumps. Therefore it is usually
      best to call StopJumping() when jump input has ceased (such as a button up event).
    - ``jump_max_hold_time`` (float):  [Read-Write] The max time the jump key can be held.
      Note that if StopJumping() is not called before the max jump hold time is reached,
      then the character will carry on receiving vertical velocity. Therefore it is usually
      best to call StopJumping() when jump input has ceased (such as a button up event).
    - ``landed_delegate`` (LandedSignature):  [Read-Write] Called upon landing when falling, to perform actions based on the Hit result.
      Note that movement mode is still "Falling" during this event. Current Velocity value is the velocity at the time of landing.
      Consider OnMovementModeChanged() as well, as that can be used once the movement mode changes to the new mode (most likely Walking).
      see: OnMovementModeChanged()
    - ``last_hit_by`` (Controller):  [Read-Write] Controller of the last Actor that caused us damage.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``look_up_at_rate_axis_name`` (str):  [Read-Write] Axis name for rate-based look up/down inputs (e.g. joystick). This should match an Axis Binding in your input settings
    - ``look_up_axis_name`` (str):  [Read-Write] Axis name for direct look up/down inputs (e.g. mouse). This should match an Axis Binding in your input settings
    - ``mesh`` (SkeletalMeshComponent):  [Read-Only] The main skeletal mesh associated with this Character (optional sub-object).
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``mouse_sensitivity_scale_pitch`` (float):  [Read-Write] Controls how aggressively mouse motion translates to character rotation in the pitch axis.
    - ``mouse_sensitivity_scale_yaw`` (float):  [Read-Write] Controls how aggressively mouse motion translates to character rotation in the yaw axis.
    - ``move_forward_axis_name`` (str):  [Read-Write] Axis name for "move forward/back" control. This should match an Axis Binding in your input settings
    - ``move_right_axis_name`` (str):  [Read-Write] Axis name for "move left/right" control. This should match an Axis Binding in your input settings
    - ``movement_mode_changed_delegate`` (MovementModeChangedSignature):  [Read-Write] Multicast delegate for MovementMode changing.
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_character_movement_updated`` (CharacterMovementUpdatedSignature):  [Read-Write] Event triggered at the end of a CharacterMovementComponent movement update.
      This is the preferred event to use rather than the Tick event when performing custom updates to CharacterMovement properties based on the current state.
      This is mainly due to the nature of network updates, where client corrections in position from the server can cause multiple iterations of a movement update,
      which allows this event to update as well, while a Tick event would not.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_reached_jump_apex`` (CharacterReachedApexSignature):  [Read-Write] Broadcast when Character's jump reaches its apex. Needs CharacterMovement->bNotifyApex = true
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_input_component_class`` (type(Class)):  [Read-Write] If set, then this InputComponent class will be used instead of the Input Settings' DefaultInputComponentClass
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_state`` (PlayerState):  [Read-Write] If Pawn is possessed by a player, points to its Player State.  Needed for network play as controllers are not replicated to clients.
    - ``pressed_jump`` (bool):  [Read-Write] When true, player wants to jump
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``proxy_jump_force_started_time`` (float):  [Read-Only] Track last time a jump force started for a proxy.
    - ``receive_controller_changed_delegate`` (PawnControllerChangedSignature):  [Read-Write] Event called after a pawn's controller has changed, on the server and owning client. This will happen at the same time as the delegate on GameInstance
    - ``receive_restarted_delegate`` (PawnRestartedSignature):  [Read-Write] Event called after a pawn has been restarted, usually by a possession change. This is called on the server for all pawns and the owning client for player pawns
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``turn_at_rate_axis_name`` (str):  [Read-Write] Axis name for rate-based turn left/right inputs (e.g. joystick). This should match an Axis Binding in your input settings
    - ``turn_axis_name`` (str):  [Read-Write] Axis name for direct turn left/right inputs (e.g. mouse). This should match an Axis Binding in your input settings
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    - ``use_controller_rotation_pitch`` (bool):  [Read-Write] If true, this Pawn's pitch will be updated to match the Controller's ControlRotation pitch, if controlled by a PlayerController.
    - ``use_controller_rotation_roll`` (bool):  [Read-Write] If true, this Pawn's roll will be updated to match the Controller's ControlRotation roll, if controlled by a PlayerController.
    - ``use_controller_rotation_yaw`` (bool):  [Read-Write] If true, this Pawn's yaw will be updated to match the Controller's ControlRotation yaw, if controlled by a PlayerController.
    - ``was_jumping`` (bool):  [Read-Only] Tracks whether or not the character was already jumping last frame.
    """
    @property
    def look_up_axis_name(self) -> str:
        r"""
        (str):  [Read-Only] Axis name for direct look up/down inputs (e.g. mouse). This should match an Axis Binding in your input settings
        """
        ...
    @property
    def look_up_at_rate_axis_name(self) -> str:
        r"""
        (str):  [Read-Only] Axis name for rate-based look up/down inputs (e.g. joystick). This should match an Axis Binding in your input settings
        """
        ...
    @property
    def turn_axis_name(self) -> str:
        r"""
        (str):  [Read-Only] Axis name for direct turn left/right inputs (e.g. mouse). This should match an Axis Binding in your input settings
        """
        ...
    @property
    def turn_at_rate_axis_name(self) -> str:
        r"""
        (str):  [Read-Only] Axis name for rate-based turn left/right inputs (e.g. joystick). This should match an Axis Binding in your input settings
        """
        ...
    @property
    def move_forward_axis_name(self) -> str:
        r"""
        (str):  [Read-Only] Axis name for "move forward/back" control. This should match an Axis Binding in your input settings
        """
        ...
    @property
    def move_right_axis_name(self) -> str:
        r"""
        (str):  [Read-Only] Axis name for "move left/right" control. This should match an Axis Binding in your input settings
        """
        ...
    @property
    def mouse_sensitivity_scale_pitch(self) -> float:
        r"""
        (float):  [Read-Only] Controls how aggressively mouse motion translates to character rotation in the pitch axis.
        """
        ...
    @property
    def mouse_sensitivity_scale_yaw(self) -> float:
        r"""
        (float):  [Read-Only] Controls how aggressively mouse motion translates to character rotation in the yaw axis.
        """
        ...

class ArchVisCharMovementComponent(CharacterMovementComponent):
    r"""
    Arch Vis Char Movement Component
    
    **C++ Source:**
    
    - **Plugin**: ArchVisCharacter
    - **Module**: ArchVisCharacter
    - **File**: ArchVisCharMovementComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``air_control`` (float):  [Read-Write] When falling, amount of lateral movement control available to the character.
      0 = no control, 1 = full control at max speed of MaxWalkSpeed.
    - ``air_control_boost_multiplier`` (float):  [Read-Write] When falling, multiplier applied to AirControl when lateral velocity is less than AirControlBoostVelocityThreshold.
      Setting this to zero will disable air control boosting. Final result is clamped at 1.
    - ``air_control_boost_velocity_threshold`` (float):  [Read-Write] When falling, if lateral velocity magnitude is less than this value, AirControl is multiplied by AirControlBoostMultiplier.
      Setting this to zero will disable air control boosting.
    - ``allow_physics_rotation_during_anim_root_motion`` (bool):  [Read-Write]
    - ``always_check_floor`` (bool):  [Read-Write] Whether we always force floor checks for stationary Characters while walking.
      Normally floor checks are avoided if possible when not moving, but this can be used to force them if there are use-cases where they are being skipped erroneously
      (such as objects moving up into the character from below).
    - ``apply_gravity_while_jumping`` (bool):  [Read-Write] Apply gravity while the character is actively jumping (e.g. holding the jump key).
      Helps remove frame-rate dependent jump height, but may alter base jump height.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_register_physics_volume_updates`` (bool):  [Read-Write] If true, then applies the value of bComponentShouldUpdatePhysicsVolume to the UpdatedComponent. If false, will not change bShouldUpdatePhysicsVolume on the UpdatedComponent at all.
      see: bComponentShouldUpdatePhysicsVolume
    - ``auto_register_updated_component`` (bool):  [Read-Write] If true, registers the owner's Root component as the UpdatedComponent if there is not one currently assigned.
    - ``auto_update_tick_registration`` (bool):  [Read-Write] If true, whenever the updated component is changed, this component will enable or disable its tick dependent on whether it has something to update.
      This will NOT enable tick at startup if bAutoActivate is false, because presumably you have a good reason for not wanting it to start ticking initially.
    - ``avoidance_consideration_radius`` (float):  [Read-Write]
    - ``avoidance_group`` (NavAvoidanceMask):  [Read-Write] Moving actor's group mask
    - ``avoidance_uid`` (int32):  [Read-Only] No default value, for now it's assumed to be valid if GetAvoidanceManager() returns non-NULL.
    - ``avoidance_weight`` (float):  [Read-Write] De facto default value 0.5 (due to that being the default in the avoidance registration function), indicates RVO behavior.
    - ``based_movement_ignore_physics_base`` (bool):  [Read-Write] Property to set if UpdateBasedMovement should ignore collision with actors part of the current MovementBase, if the base is simulated by physics
    - ``braking_deceleration_falling`` (float):  [Read-Write] Lateral deceleration when falling and not applying acceleration.
      see: MaxAcceleration
    - ``braking_deceleration_flying`` (float):  [Read-Write] Deceleration when flying and not applying acceleration.
      see: MaxAcceleration
    - ``braking_deceleration_swimming`` (float):  [Read-Write] Deceleration when swimming and not applying acceleration.
      see: MaxAcceleration
    - ``braking_deceleration_walking`` (float):  [Read-Write] Deceleration when walking and not applying acceleration. This is a constant opposing force that directly lowers velocity by a constant value.
      see: GroundFriction, MaxAcceleration
    - ``braking_friction`` (float):  [Read-Write] Friction (drag) coefficient applied when braking (whenever Acceleration = 0, or if character is exceeding max speed); actual value used is this multiplied by BrakingFrictionFactor.
      When braking, this property allows you to control how much friction is applied when moving across the ground, applying an opposing force that scales with current velocity.
      Braking is composed of friction (velocity-dependent drag) and constant deceleration.
      This is the current value, used in all movement modes; if this is not desired, override it or bUseSeparateBrakingFriction when movement mode changes.
      note: Only used if bUseSeparateBrakingFriction setting is true, otherwise current friction such as GroundFriction is used.
      see: bUseSeparateBrakingFriction, BrakingFrictionFactor, GroundFriction, BrakingDecelerationWalking
    - ``braking_friction_factor`` (float):  [Read-Write] Factor used to multiply actual value of friction used when braking.
      This applies to any friction value that is currently used, which may depend on bUseSeparateBrakingFriction.
      note: This is 2 by default for historical reasons, a value of 1 gives the true drag equation.
      see: bUseSeparateBrakingFriction, GroundFriction, BrakingFriction
    - ``braking_sub_step_time`` (float):  [Read-Write] Time substepping when applying braking friction. Smaller time steps increase accuracy at the slight cost of performance, especially if there are large frame times.
    - ``buoyancy`` (float):  [Read-Write] Water buoyancy. A ratio (1.0 = neutral buoyancy, 0.0 = no buoyancy)
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``can_walk_off_ledges`` (bool):  [Read-Write] If true, Character can walk off a ledge.
    - ``can_walk_off_ledges_when_crouching`` (bool):  [Read-Write] If true, Character can walk off a ledge when crouching.
    - ``component_should_update_physics_volume`` (bool):  [Read-Write] If true, enables bShouldUpdatePhysicsVolume on the UpdatedComponent during initialization from SetUpdatedComponent(), otherwise disables such updates.
      Only enabled if bAutoRegisterPhysicsVolumeUpdates is true.
      WARNING: UpdatePhysicsVolume is potentially expensive if overlap events are also *disabled* because it requires a separate query against all physics volumes in the world.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``constrain_to_plane`` (bool):  [Read-Write] If true, movement will be constrained to a plane.
      see: PlaneConstraintNormal, PlaneConstraintOrigin, PlaneConstraintAxisSetting
    - ``crouch_maintains_base_location`` (bool):  [Read-Only] If true, crouching should keep the base of the capsule in place by lowering the center of the shrunken capsule. If false, the base of the capsule moves up and the center stays in place.
      The same behavior applies when the character uncrouches: if true, the base is kept in the same location and the center moves up. If false, the capsule grows and only moves up if the base impacts something.
      By default this variable is set when the movement mode changes: set to true when walking and false otherwise. Feel free to override the behavior when the movement mode changes.
    - ``crouched_half_height`` (float):  [Read-Write]
    - ``current_floor`` (FindFloorResult):  [Read-Only] Information about the floor the Character is standing on (updated only during walking movement).
    - ``custom_movement_mode`` (uint8):  [Read-Write] Current custom sub-mode if MovementMode is set to Custom.
      This is automatically replicated through the Character owner and for client-server movement functions.
      see: SetMovementMode()
    - ``default_land_movement_mode`` (MovementMode):  [Read-Write] Default movement mode when not in water. Used at player startup or when teleported.
      see: DefaultWaterMovementMode
      see: bRunPhysicsWithNoController
    - ``default_water_movement_mode`` (MovementMode):  [Read-Write] Default movement mode when in water. Used at player startup or when teleported.
      see: DefaultLandMovementMode
      see: bRunPhysicsWithNoController
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_physics_interaction`` (bool):  [Read-Write] If enabled, the player will interact with physics objects when walking into them.
    - ``enable_scoped_movement_updates`` (bool):  [Read-Write] If true, high-level movement updates will be wrapped in a movement scope that accumulates updates and defers a bulk of the work until the end.
      When enabled, touch and hit events will not be triggered until the end of multiple moves within an update, which can improve performance.
      see: FScopedMovementUpdate
    - ``enable_server_dual_move_scoped_movement_updates`` (bool):  [Read-Write] Optional scoped movement update to combine moves for cheaper performance on the server when the client sends two moves in one packet.
      Be warned that since this wraps a larger scope than is normally done with bEnableScopedMovementUpdates, this can result in subtle changes in behavior
      in regards to when overlap events are handled, when attached components are moved, etc.
      see: bEnableScopedMovementUpdates
    - ``falling_lateral_friction`` (float):  [Read-Write] Friction to apply to lateral air movement when falling.
      If bUseSeparateBrakingFriction is false, also affects the ability to stop more quickly when braking (whenever Acceleration is zero).
      see: BrakingFriction, bUseSeparateBrakingFriction
    - ``fixed_path_braking_distance`` (float):  [Read-Write] Braking distance override used with acceleration driven path following (bUseAccelerationForPaths)
    - ``force_next_floor_check`` (bool):  [Read-Only] Force the Character in MOVE_Walking to do a check for a valid floor even if it hasn't moved. Cleared after next floor check.
      Normally if bAlwaysCheckFloor is false we try to avoid the floor check unless some conditions are met, but this can be used to force the next check to always run.
    - ``former_base_velocity_decay_half_life`` (float):  [Read-Write] When applying a root motion override while falling off a moving object, this controls how long it takes to lose half the former base's velocity (in seconds).
      Set to 0 to ignore former bases (default).
      Set to -1 for no decay.
      Any other positive value sets the half-life for exponential decay.
    - ``gravity_direction`` (Vector):  [Read-Only] A normalized vector representing the direction of gravity for gravity relative movement modes: walking, falling,
      and custom movement modes. Gravity direction remaps player input as being within the plane defined by the gravity
      direction. Movement simulation values like velocity and acceleration are maintained in their existing world coordinate
      space but are transformed internally as gravity relative (for instance moving forward up a vertical wall that gravity is
      defined to be perpendicular to and jump "up" from that wall). If ShouldRemainVertical() is true the character's capsule
      will be oriented to align with the gravity direction.
    - ``gravity_scale`` (float):  [Read-Write] Custom gravity scale. Gravity is multiplied by this amount for the character.
    - ``gravity_to_world_transform`` (Quat):  [Read-Only] A cached quaternion representing the inverse rotation from world space to gravity relative space defined by GravityDirection.
    - ``ground_friction`` (float):  [Read-Write] Setting that affects movement control. Higher values allow faster changes in direction.
      If bUseSeparateBrakingFriction is false, also affects the ability to stop more quickly when braking (whenever Acceleration is zero), where it is multiplied by BrakingFrictionFactor.
      When braking, this property allows you to control how much friction is applied when moving across the ground, applying an opposing force that scales with current velocity.
      This can be used to simulate slippery surfaces such as ice or oil by changing the value (possibly based on the material pawn is standing on).
      see: BrakingDecelerationWalking, BrakingFriction, bUseSeparateBrakingFriction, BrakingFrictionFactor
    - ``groups_to_avoid`` (NavAvoidanceMask):  [Read-Write] Will avoid other agents if they are in one of specified groups
    - ``groups_to_ignore`` (NavAvoidanceMask):  [Read-Write] Will NOT avoid other agents if they are in one of specified groups, higher priority than GroupsToAvoid
    - ``ignore_base_rotation`` (bool):  [Read-Write] Whether the character ignores changes in rotation of the base it is standing on.
      If true, the character maintains current world rotation.
      If false, the character rotates with the moving base.
    - ``ignore_client_movement_error_checks_and_correction`` (bool):  [Read-Write] If true, we should ignore server location difference checks for client error on this movement component.
      This can be useful when character is moving at extreme speeds for a duration and you need it to look
      smooth on clients without the server correcting the client. Make sure to disable when done, as this would
      break this character's server-client movement correction.
      see: bServerAcceptClientAuthoritativePosition, ServerCheckClientError()
    - ``impart_base_angular_velocity`` (bool):  [Read-Write] If true, impart the base component's tangential components of angular velocity when jumping or falling off it.
      Only those components of the velocity allowed by the separate component settings (bImpartBaseVelocityX etc) will be applied.
      see: bImpartBaseVelocityX, bImpartBaseVelocityY, bImpartBaseVelocityZ
    - ``impart_base_velocity_x`` (bool):  [Read-Write] If true, impart the base actor's X velocity when falling off it (which includes jumping)
    - ``impart_base_velocity_y`` (bool):  [Read-Write] If true, impart the base actor's Y velocity when falling off it (which includes jumping)
    - ``impart_base_velocity_z`` (bool):  [Read-Write] If true, impart the base actor's Z velocity when falling off it (which includes jumping)
    - ``initial_push_force_factor`` (float):  [Read-Write] Initial impulse force to apply when the player bounces into a blocking physics object.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``jump_off_jump_z_factor`` (float):  [Read-Write] Fraction of JumpZVelocity to use when automatically "jumping off" of a base actor that's not allowed to be a base for a character. (For example, if you're not allowed to stand on other players.)
    - ``jump_out_of_water_pitch`` (float):  [Read-Write] When exiting water, jump if control pitch angle is this high or above.
    - ``jump_z_velocity`` (float):  [Read-Write] Initial velocity (instantaneous vertical acceleration) when jumping.
    - ``just_teleported`` (bool):  [Read-Only] Used by movement code to determine if a change in position is based on normal movement or a teleport. If not a teleport, velocity can be recomputed based on the change in position.
    - ``ledge_check_threshold`` (float):  [Read-Write] Used in determining if pawn is going off ledge.  If the ledge is "shorter" than this value then the pawn will be able to walk off it. *
    - ``listen_server_network_simulated_smooth_location_time`` (float):  [Read-Write] Similar setting as NetworkSimulatedSmoothLocationTime but only used on Listen servers.
    - ``listen_server_network_simulated_smooth_rotation_time`` (float):  [Read-Write] Similar setting as NetworkSimulatedSmoothRotationTime but only used on Listen servers.
    - ``maintain_horizontal_ground_velocity`` (bool):  [Read-Write] If true, walking movement always maintains horizontal velocity when moving up ramps, which causes movement up ramps to be faster parallel to the ramp surface.
      If false, then walking movement maintains velocity magnitude parallel to the ramp surface.
    - ``mass`` (float):  [Read-Write] Mass of pawn (for when momentum is imparted to it).
    - ``max_acceleration`` (float):  [Read-Write] Max Acceleration (rate of change of velocity)
    - ``max_custom_movement_speed`` (float):  [Read-Write] The maximum speed when using Custom movement mode.
    - ``max_depenetration_with_geometry`` (float):  [Read-Write] Max distance we allow simulated proxies to depenetrate when moving out of anything but Pawns.
      This is generally more tolerant than with Pawns, because other geometry is either not moving, or is moving predictably with a bit of delay compared to on the server.
      see: MaxDepenetrationWithGeometryAsProxy, MaxDepenetrationWithPawn, MaxDepenetrationWithPawnAsProxy
    - ``max_depenetration_with_geometry_as_proxy`` (float):  [Read-Write] Max distance we allow simulated proxies to depenetrate when moving out of anything but Pawns.
      This is generally more tolerant than with Pawns, because other geometry is either not moving, or is moving predictably with a bit of delay compared to on the server.
      see: MaxDepenetrationWithGeometry, MaxDepenetrationWithPawn, MaxDepenetrationWithPawnAsProxy
    - ``max_depenetration_with_pawn`` (float):  [Read-Write] Max distance we are allowed to depenetrate when moving out of other Pawns.
      see: MaxDepenetrationWithGeometry, MaxDepenetrationWithGeometryAsProxy, MaxDepenetrationWithPawnAsProxy
    - ``max_depenetration_with_pawn_as_proxy`` (float):  [Read-Write] Max distance we allow simulated proxies to depenetrate when moving out of other Pawns.
      Typically we don't want a large value, because we receive a server authoritative position that we should not then ignore by pushing them out of the local player.
      see: MaxDepenetrationWithGeometry, MaxDepenetrationWithGeometryAsProxy, MaxDepenetrationWithPawn
    - ``max_fly_speed`` (float):  [Read-Write] The maximum flying speed.
    - ``max_jump_apex_attempts_per_simulation`` (int32):  [Read-Write] Max number of attempts per simulation to attempt to exactly reach the jump apex when falling movement reaches the top of the arc.
      Limiting this prevents deep recursion when special cases cause collision or other conditions which reactivate the apex condition.
    - ``max_out_of_water_step_height`` (float):  [Read-Write] Maximum step height for getting out of water
    - ``max_pitch`` (float):  [Read-Write] Controls how far up you can look
    - ``max_rotational_velocity`` (Rotator):  [Read-Write] Fastest possible turn rate
    - ``max_simulation_iterations`` (int32):  [Read-Write] Max number of iterations used for each discrete simulation step.
      Used primarily in the the more advanced movement modes that break up larger time steps (usually those applying gravity such as falling and walking).
      Increasing this value can address issues with fast-moving objects or complex collision scenarios, at the cost of performance.
      
      WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
      see: MaxSimulationTimeStep
    - ``max_simulation_time_step`` (float):  [Read-Write] Max time delta for each discrete simulation step.
      Used primarily in the the more advanced movement modes that break up larger time steps (usually those applying gravity such as falling and walking).
      Lowering this value can address issues with fast-moving objects or complex collision scenarios, at the cost of performance.
      
      WARNING: if (MaxSimulationTimeStep * MaxSimulationIterations) is too low for the min framerate, the last simulation step may exceed MaxSimulationTimeStep to complete the simulation.
      see: MaxSimulationIterations
    - ``max_step_height`` (float):  [Read-Write] Maximum height character can step up
    - ``max_swim_speed`` (float):  [Read-Write] The maximum swimming speed.
    - ``max_touch_force`` (float):  [Read-Write] Maximum force applied to touched physics objects. If < 0.0f, there is no maximum.
    - ``max_walk_speed`` (float):  [Read-Write] The maximum ground speed when walking. Also determines maximum lateral speed when falling.
    - ``max_walk_speed_crouched`` (float):  [Read-Write] The maximum ground speed when walking and crouched.
    - ``min_analog_walk_speed`` (float):  [Read-Write] The ground speed that we should accelerate up to when walking at minimum analog stick tilt
    - ``min_pitch`` (float):  [Read-Write] Controls how far down you can look
    - ``min_touch_force`` (float):  [Read-Write] Minimum Force applied to touched physics objects. If < 0.0f, there is no minimum.
    - ``movement_mode`` (MovementMode):  [Read-Write] Actor's current movement mode (walking, falling, etc).
         - walking:  Walking on a surface, under the effects of friction, and able to "step up" barriers. Vertical velocity is zero.
         - falling:  Falling under the effects of gravity, after jumping or walking off the edge of a surface.
         - flying:   Flying, ignoring the effects of gravity.
         - swimming: Swimming through a fluid volume, under the effects of gravity and buoyancy.
         - custom:   User-defined custom movement mode, including many possible sub-modes.
      This is automatically replicated through the Character owner and for client-server movement functions.
      see: SetMovementMode(), CustomMovementMode
    - ``nav_agent_props`` (NavAgentProperties):  [Read-Write] Properties that define how the component can move.
    - ``nav_mesh_projection_height_scale_down`` (float):  [Read-Write] Scale of the total capsule height to use for projection from navmesh to underlying geometry in the downward direction.
      In other words, trace down to [CapsuleHeight * NavMeshProjectionHeightScaleDown] below nav mesh.
    - ``nav_mesh_projection_height_scale_up`` (float):  [Read-Write] Scale of the total capsule height to use for projection from navmesh to underlying geometry in the upward direction.
      In other words, start the trace at [CapsuleHeight * NavMeshProjectionHeightScaleUp] above nav mesh.
    - ``nav_mesh_projection_interp_speed`` (float):  [Read-Write] Speed at which to interpolate agent navmesh offset between traces. 0: Instant (no interp) > 0: Interp speed")
    - ``nav_mesh_projection_interval`` (float):  [Read-Write] How often we should raycast to project from navmesh to underlying geometry
    - ``nav_walking_floor_dist_tolerance`` (float):  [Read-Write] Ignore small differences in ground height between server and client data during NavWalking mode
    - ``net_proxy_shrink_half_height`` (float):  [Read-Write] Shrink simulated proxy capsule half height by this amount, to account for network rounding that may cause encroachment. Changing during gameplay is not supported.
      see: AdjustProxyCapsuleSize()
    - ``net_proxy_shrink_radius`` (float):  [Read-Write] Shrink simulated proxy capsule radius by this amount, to account for network rounding that may cause encroachment. Changing during gameplay is not supported.
      see: AdjustProxyCapsuleSize()
    - ``network_always_replicate_transform_update_timestamp`` (bool):  [Read-Write] Flag used on the server to determine whether to always replicate ReplicatedServerLastTransformUpdateTimeStamp to clients.
      Normally this is only sent when the network smoothing mode on character movement is set to Linear smoothing (on the server), to save bandwidth.
      Setting this to true will force the timestamp to replicate regardless, in case the server doesn't know about the smoothing mode, or if the timestamp is used for another purpose.
    - ``network_large_client_correction_distance`` (float):  [Read-Write] If client error is larger than this, sets bNetworkLargeClientCorrection to reduce delay between client adjustments.
      see: NetworkMinTimeBetweenClientAdjustments, NetworkMinTimeBetweenClientAdjustmentsLargeCorrection
    - ``network_max_smooth_update_distance`` (float):  [Read-Write] Maximum distance character is allowed to lag behind server location when interpolating between updates.
    - ``network_min_time_between_client_ack_good_moves`` (float):  [Read-Write] Minimum time on the server between acknowledging good client moves. This can save on bandwidth. Set to 0 to disable throttling.
    - ``network_min_time_between_client_adjustments`` (float):  [Read-Write] Minimum time on the server between sending client adjustments when client has exceeded allowable position error.
      Should be >= NetworkMinTimeBetweenClientAdjustmentsLargeCorrection (the larger value is used regardless).
      This can save on bandwidth. Set to 0 to disable throttling.
      see: ServerLastClientAdjustmentTime
    - ``network_min_time_between_client_adjustments_large_correction`` (float):  [Read-Write] Minimum time on the server between sending client adjustments when client has exceeded allowable position error by a large amount (NetworkLargeClientCorrectionDistance).
      Should be <= NetworkMinTimeBetweenClientAdjustments (the smaller value is used regardless).
      see: NetworkMinTimeBetweenClientAdjustments
    - ``network_no_smooth_update_distance`` (float):  [Read-Write] Maximum distance beyond which character is teleported to the new server location without any smoothing.
    - ``network_simulated_smooth_location_time`` (float):  [Read-Write] How long to take to smoothly interpolate from the old pawn position on the client to the corrected one sent by the server. Not used by Linear smoothing.
    - ``network_simulated_smooth_rotation_time`` (float):  [Read-Write] How long to take to smoothly interpolate from the old pawn rotation on the client to the corrected one sent by the server. Not used by Linear smoothing.
    - ``network_skip_proxy_prediction_on_net_update`` (bool):  [Read-Write] Whether we skip prediction on frames where a proxy receives a network update. This can avoid expensive prediction on those frames,
      with the side-effect of predicting with a frame of additional latency.
    - ``network_smoothing_mode`` (NetworkSmoothingMode):  [Read-Write] Smoothing mode for simulated proxies in network game.
    - ``notify_apex`` (bool):  [Read-Only] If true, event NotifyJumpApex() to CharacterOwner's controller when at apex of jump. Is cleared when event is triggered.
      By default this is off, and if you want the event to fire you typically set it to true when movement mode changes to "Falling" from another mode (see OnMovementModeChanged).
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``orient_rotation_to_movement`` (bool):  [Read-Write] If true, rotate the Character toward the direction of acceleration, using RotationRate as the rate of rotation change. Overrides UseControllerDesiredRotation.
      Normally you will want to make sure that other settings are cleared, such as bUseControllerRotationYaw on the Character.
    - ``outof_water_z`` (float):  [Read-Write] Z velocity applied when pawn tries to get out of water
    - ``perch_additional_height`` (float):  [Read-Write] When perching on a ledge, add this additional distance to MaxStepHeight when determining how high above a walkable floor we can perch.
      Note that we still enforce MaxStepHeight to start the step up; this just allows the character to hang off the edge or step slightly higher off the floor.
      (
      see: PerchRadiusThreshold)
    - ``perch_radius_threshold`` (float):  [Read-Write] Don't allow the character to perch on the edge of a surface if the contact is this close to the edge of the capsule.
      Note that characters will not fall off if they are within MaxStepHeight of a walkable surface below.
    - ``plane_constraint_axis_setting`` (PlaneConstraintAxisSetting):  [Read-Write] Setting that controls behavior when movement is restricted to a 2D plane defined by a specific axis/normal,
      so that movement along the locked axis is not be possible.
      see: SetPlaneConstraintAxisSetting
    - ``plane_constraint_normal`` (Vector):  [Read-Write] The normal or axis of the plane that constrains movement, if bConstrainToPlane is enabled.
      If for example you wanted to constrain movement to the X-Z plane (so that Y cannot change), the normal would be set to X=0 Y=1 Z=0.
      This is recalculated whenever PlaneConstraintAxisSetting changes. It is normalized once the component is registered with the game world.
      see: bConstrainToPlane, SetPlaneConstraintNormal(), SetPlaneConstraintFromVectors()
    - ``plane_constraint_origin`` (Vector):  [Read-Write] The origin of the plane that constrains movement, if plane constraint is enabled.
      This defines the behavior of snapping a position to the plane, such as by SnapUpdatedComponentToPlane().
      see: bConstrainToPlane, SetPlaneConstraintOrigin().
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``project_nav_mesh_on_both_world_channels`` (bool):  [Read-Write] Use both WorldStatic and WorldDynamic channels for NavWalking geometry conforming
    - ``project_nav_mesh_walking`` (bool):  [Read-Write] Whether to raycast to underlying geometry to better conform navmesh-walking characters
    - ``push_force_factor`` (float):  [Read-Write] Force to apply when the player collides with a blocking physics object.
    - ``push_force_point_z_offset_factor`` (float):  [Read-Write] Z-Offset for the position the force is applied to. 0.0f is the center of the physics object, 1.0f is the top and -1.0f is the bottom of the object.
    - ``push_force_scaled_to_mass`` (bool):  [Read-Write] If enabled, the PushForceFactor is applied per kg mass of the affected object.
    - ``push_force_using_z_offset`` (bool):  [Read-Write] If enabled, the PushForce location is moved using PushForcePointZOffsetFactor. Otherwise simply use the impact point.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``repulsion_force`` (float):  [Read-Write] Force per kg applied constantly to all overlapping components.
    - ``requested_move_use_acceleration`` (bool):  [Read-Write] Should use acceleration for path following?
      If true, acceleration is applied when path following to reach the target velocity.
      If false, path following velocity is set directly, disregarding acceleration.
    - ``rotation_rate`` (Rotator):  [Read-Write] Change in rotation per second, used when UseControllerDesiredRotation or OrientRotationToMovement are true. Set a negative value for infinite rotation rate and instant turns.
    - ``rotational_acceleration`` (Rotator):  [Read-Write] Controls how fast the character's turn rate accelerates when rotating and looking up/down
    - ``rotational_deceleration`` (Rotator):  [Read-Write] Controls how fast the character's turn rate decelerates to 0 when user stops turning
    - ``run_physics_with_no_controller`` (bool):  [Read-Write] If true, movement will be performed even if there is no Controller for the Character owner.
      Normally without a Controller, movement will be aborted and velocity and acceleration are zeroed if the character is walking.
      Characters that are spawned without a Controller but with this flag enabled will initialize the movement mode to DefaultLandMovementMode or DefaultWaterMovementMode appropriately.
      see: DefaultLandMovementMode, DefaultWaterMovementMode
    - ``scale_push_force_to_velocity`` (bool):  [Read-Write] If enabled, the applied push force will try to get the physics object to the same velocity than the player, not faster. This will only
                    scale the force down, it will never apply more force than defined by PushForceFactor.
    - ``server_accept_client_authoritative_position`` (bool):  [Read-Write] If true, and server does not detect client position error, server will copy the client movement location/velocity/etc after simulating the move.
      This can be useful for short bursts of movement that are difficult to sync over the network.
      Note that if bIgnoreClientMovementErrorChecksAndCorrection is used, this means the server will not detect an error.
      Also see GameNetworkManager->ClientAuthorativePosition which permanently enables this behavior.
      see: bIgnoreClientMovementErrorChecksAndCorrection, ServerShouldUseAuthoritativePosition()
    - ``snap_to_plane_at_start`` (bool):  [Read-Write] If true and plane constraints are enabled, then the updated component will be snapped to the plane when first attached.
    - ``standing_downward_force_scale`` (float):  [Read-Write] Force applied to objects we stand on (due to Mass and Gravity) is scaled by this amount.
    - ``stay_based_in_air`` (bool):  [Read-Write] Property to set if characters should stay based on objects while jumping
    - ``stay_based_in_air_height`` (float):  [Read-Write] Property used to set how high above base characters should stay based on objects while jumping if bStayBasedInAir is set
    - ``sweep_while_nav_walking`` (bool):  [Read-Write] Whether or not the character should sweep for collision geometry while walking.
      see: USceneComponent::MoveComponent.
    - ``tick_before_owner`` (bool):  [Read-Write] If true, after registration we will add a tick dependency to tick before our owner (if we can both tick).
      This is important when our tick causes an update in the owner's position, so that when the owner ticks it uses the most recent position without lag.
      Disabling this can improve performance if both objects tick but the order of ticks doesn't matter.
    - ``touch_force_factor`` (float):  [Read-Write] Force to apply to physics objects that are touched by the player.
    - ``touch_force_scaled_to_mass`` (bool):  [Read-Write] If enabled, the TouchForceFactor is applied per kg mass of the affected object.
    - ``update_nav_agent_with_owners_collision`` (bool):  [Read-Write] If set to true NavAgentProps' radius and height will be updated with Owner's collision capsule size
    - ``update_only_if_rendered`` (bool):  [Read-Write] If true, skips TickComponent() if UpdatedComponent was not recently rendered.
    - ``updated_component`` (SceneComponent):  [Read-Write] The component we move and update.
      If this is null at startup and bAutoRegisterUpdatedComponent is true, the owning Actor's root component will automatically be set as our UpdatedComponent at startup.
      see: bAutoRegisterUpdatedComponent, SetUpdatedComponent(), UpdatedPrimitive
    - ``updated_primitive`` (PrimitiveComponent):  [Read-Write] UpdatedComponent, cast as a UPrimitiveComponent. May be invalid if UpdatedComponent was null or not a UPrimitiveComponent.
    - ``use_acceleration_for_paths`` (bool):  [Read-Write] If set, pathfollowing will control character movement via acceleration values. If false, it will set velocities directly.
    - ``use_controller_desired_rotation`` (bool):  [Read-Write] If true, smoothly rotate the Character toward the Controller's desired rotation (typically Controller->ControlRotation), using RotationRate as the rate of rotation change. Overridden by OrientRotationToMovement.
      Normally you will want to make sure that other settings are cleared, such as bUseControllerRotationYaw on the Character.
    - ``use_fixed_braking_distance_for_paths`` (bool):  [Read-Write] If set, FixedPathBrakingDistance will be used for path following deceleration
    - ``use_flat_base_for_floor_checks`` (bool):  [Read-Write] Performs floor checks as if the character is using a shape with a flat base.
      This avoids the situation where characters slowly lower off the side of a ledge (as their capsule 'balances' on the edge).
    - ``use_rvo_avoidance`` (bool):  [Read-Write] If set, component will use RVO avoidance. This only runs on the server.
    - ``use_separate_braking_friction`` (bool):  [Read-Write] If true, BrakingFriction will be used to slow the character to a stop (when there is no Acceleration).
      If false, braking uses the same friction passed to CalcVelocity() (ie GroundFriction when walking), multiplied by BrakingFrictionFactor.
      This setting applies to all movement modes; if only desired in certain modes, consider toggling it when movement modes change.
      see: BrakingFriction
    - ``velocity`` (Vector):  [Read-Write] Current velocity of updated component.
    - ``walkable_floor_angle`` (float):  [Read-Write] Max angle in degrees of a walkable surface. Any greater than this and it is too steep to be walkable.
    - ``walkable_floor_z`` (float):  [Read-Only] Minimum Z value for floor normal. If less, not a walkable surface. Computed from WalkableFloorAngle.
    - ``walking_acceleration`` (float):  [Read-Write] How fast the character accelerates.
    - ``walking_friction`` (float):  [Read-Write] Controls walking deceleration.
    - ``walking_speed`` (float):  [Read-Write] How fast the character can walk.
    - ``wants_to_crouch`` (bool):  [Read-Only] If true, try to crouch (or keep crouching) on next update. If false, try to stop crouching on next update.
    - ``world_to_gravity_transform`` (Quat):  [Read-Only] A cached quaternion representing the rotation from world space to gravity relative space defined by GravityDirection.
    """
    @property
    def rotational_acceleration(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] Controls how fast the character's turn rate accelerates when rotating and looking up/down
        """
        ...
    @property
    def rotational_deceleration(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] Controls how fast the character's turn rate decelerates to 0 when user stops turning
        """
        ...
    @property
    def max_rotational_velocity(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] Fastest possible turn rate
        """
        ...
    @property
    def min_pitch(self) -> float:
        r"""
        (float):  [Read-Only] Controls how far down you can look
        """
        ...
    @property
    def max_pitch(self) -> float:
        r"""
        (float):  [Read-Only] Controls how far up you can look
        """
        ...
    @property
    def walking_friction(self) -> float:
        r"""
        (float):  [Read-Only] Controls walking deceleration.
        """
        ...
    @property
    def walking_speed(self) -> float:
        r"""
        (float):  [Read-Only] How fast the character can walk.
        """
        ...
    @property
    def walking_acceleration(self) -> float:
        r"""
        (float):  [Read-Only] How fast the character accelerates.
        """
        ...

class AudioCapture(AudioGenerator):
    r"""
    Class which opens up a handle to an audio capture device.
    Allows other objects to get audio buffers from the capture device.
    
    **C++ Source:**
    
    - **Plugin**: AudioCapture
    - **Module**: AudioCapture
    - **File**: AudioCapture.h
    
    """
    def stop_capturing_audio(self) -> None:
        r"""
        x.stop_capturing_audio() -> None
        Stops capturing audio
        """
        ...
    def start_capturing_audio(self) -> None:
        r"""
        x.start_capturing_audio() -> None
        Starts capturing audio
        """
        ...
    def is_capturing_audio(self) -> bool:
        r"""
        x.is_capturing_audio() -> bool
        Returns true if capturing audio
        
        Returns:
            bool:
        """
        ...
    def get_audio_capture_device_info(self) -> Optional[AudioCaptureDeviceInfo]:
        r"""
        x.get_audio_capture_device_info() -> AudioCaptureDeviceInfo or None
        Returns the audio capture device info
        
        Returns:
            AudioCaptureDeviceInfo or None: 
        
            out_info (AudioCaptureDeviceInfo):
        """
        ...

class AudioCaptureFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    Audio Capture Function Library
    
    **C++ Source:**
    
    - **Plugin**: AudioCapture
    - **Module**: AudioCapture
    - **File**: AudioCapture.h
    
    """
    @classmethod
    def create_audio_capture(cls) -> AudioCapture:
        r"""
        X.create_audio_capture() -> AudioCapture
        Create Audio Capture
        
        Returns:
            AudioCapture:
        """
        ...

class AudioCaptureLibrary(BlueprintFunctionLibrary):
    r"""
    Audio Capture Blueprint Library
    
    **C++ Source:**
    
    - **Plugin**: AudioCapture
    - **Module**: AudioCapture
    - **File**: AudioCaptureBlueprintLibrary.h
    
    """
    @classmethod
    def get_available_audio_input_devices(cls, world_context_object: Object, on_obtain_devices_event: OnAudioInputDevicesObtained) -> None:
        r"""
        X.get_available_audio_input_devices(world_context_object, on_obtain_devices_event) -> None
        Gets information about all audio output devices available in the system
        
        Args:
            world_context_object (Object): 
            on_obtain_devices_event (OnAudioInputDevicesObtained): the event to fire when the audio endpoint devices have been retrieved
        """
        ...
    @classmethod
    def conv_audio_input_device_info_to_string(cls, info: AudioInputDeviceInfo) -> str:
        r"""
        X.conv_audio_input_device_info_to_string(info) -> str
        Returns the device info in a human readable format
        
        Args:
            info (AudioInputDeviceInfo): The audio device data to print
        
        Returns:
            str: The data in a string format
        """
        ...

class AudioCaptureComponent(SynthComponent):
    r"""
    Audio Capture Component
    
    **C++ Source:**
    
    - **Plugin**: AudioCapture
    - **Module**: AudioCapture
    - **File**: AudioCaptureComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``allow_spatialization`` (bool):  [Read-Write] Is this audio component allowed to be spatialized?
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``attenuation_overrides`` (SoundAttenuationSettings):  [Read-Write] If bOverrideSettings is true, the attenuation properties to use for sounds generated by this component
    - ``attenuation_settings`` (SoundAttenuation):  [Read-Write] If bOverrideSettings is false, the asset to use to determine attenuation properties for sounds generated by this component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing after source effects are processed.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``concurrency_set`` (Set[SoundConcurrency]):  [Read-Write] What sound concurrency to use for sounds generated by this audio component
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_base_submix`` (bool):  [Read-Write] If enabled, sound will route to the Master Submix by default or to the Base Submix if defined. If disabled, sound will route ONLY to the Submix Sends and/or Bus Sends
    - ``enable_bus_sends`` (bool):  [Read-Write] Whether or not to enable sending this audio's output to buses.
    - ``enable_submix_sends`` (bool):  [Read-Write] Whether or not to enable Submix Sends other than the Base Submix.
    - ``envelope_follower_attack_time`` (int32):  [Read-Write] The attack time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``envelope_follower_release_time`` (int32):  [Read-Write] The release time in milliseconds for the envelope follower. Delegate callbacks can be registered to get the
      envelope value of sounds played with this audio component. Only used in audio mixer.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_ui_sound`` (bool):  [Read-Write] Whether or not this sound plays when the game is paused in the UI
    - ``jitter_latency_frames`` (int32):  [Read-Write] Induced latency in audio frames to use to account for jitter between mic capture hardware and audio render hardware.
         Increasing this number will increase latency but reduce potential for underruns.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``modulation_routing`` (SoundModulationDefaultRoutingSettings):  [Read-Write]
    - ``on_audio_envelope_value`` (OnSynthEnvelopeValue):  [Read-Write]
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``override_attenuation`` (bool):  [Read-Write] Should the Attenuation Settings asset be used (false) or should the properties set directly on the component be used for attenuation properties
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``pre_effect_bus_sends`` (Array[SoundSourceBusSendInfo]):  [Read-Write] This sound will send its audio output to this list of buses if there are bus instances playing before source effects are processed.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``sound_class`` (SoundClass):  [Read-Write] Sound class this sound belongs to
    - ``sound_submix`` (SoundSubmixBase):  [Read-Write] Submix this sound belongs to
    - ``sound_submix_sends`` (Array[SoundSubmixSendInfo]):  [Read-Write] An array of submix sends. Audio from this sound will send a portion of its audio to these effects.
    - ``source_effect_chain`` (SoundEffectSourcePresetChain):  [Read-Write] The source effect chain to use for this sound.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    """
    @property
    def jitter_latency_frames(self) -> int:
        r"""
        (int32):  [Read-Write] Induced latency in audio frames to use to account for jitter between mic capture hardware and audio render hardware.
           Increasing this number will increase latency but reduce potential for underruns.
        """
        ...
    @jitter_latency_frames.setter
    def jitter_latency_frames(self, value: int) -> None:
        ...

class AssetTagsSubsystem(EngineSubsystem):
    r"""
    Asset Tags Subsystem
    
    **C++ Source:**
    
    - **Plugin**: AssetTags
    - **Module**: AssetTags
    - **File**: AssetTagsSubsystem.h
    
    """
    def reparent_collection(self, name: Name, new_parent_name: Name) -> bool:
        r"""
        x.reparent_collection(name, new_parent_name) -> bool
        Re-parent the given collection.
        
        Args:
            name (Name): Name of the collection to re-parent.
            new_parent_name (Name): Name of the new parent collection, or None to have the collection become a root collection.
        
        Returns:
            bool: True if the collection was renamed, false otherwise (see the output log for details on error).
        """
        ...
    def rename_collection(self, name: Name, new_name: Name) -> bool:
        r"""
        x.rename_collection(name, new_name) -> bool
        Rename the given collection.
        
        Args:
            name (Name): Name of the collection to rename.
            new_name (Name): Name to give to the collection.
        
        Returns:
            bool: True if the collection was renamed, false otherwise (see the output log for details on error).
        """
        ...
    def remove_assets_from_collection(self, name: Name, asset_path_names: Array[Name]) -> bool:
        r"""
        x.remove_assets_from_collection(name, asset_path_names) -> bool
        Remove Assets from Collection
        
        Args:
            name (Name): 
            asset_path_names (Array[Name]): 
        
        Returns:
            bool:
        """
        ...
    def remove_asset_ptrs_from_collection(self, name: Name, asset_ptrs: Array[Object]) -> bool:
        r"""
        x.remove_asset_ptrs_from_collection(name, asset_ptrs) -> bool
        Remove the given assets from the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_ptrs (Array[Object]): Assets to remove.
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def remove_asset_ptr_from_collection(self, name: Name, asset_ptr: Object) -> bool:
        r"""
        x.remove_asset_ptr_from_collection(name, asset_ptr) -> bool
        Remove the given asset from the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_ptr (Object): Asset to remove.
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def remove_asset_from_collection(self, name: Name, asset_path_name: Name) -> bool:
        r"""
        x.remove_asset_from_collection(name, asset_path_name) -> bool
        Remove Asset from Collection
        
        Args:
            name (Name): 
            asset_path_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def remove_asset_datas_from_collection(self, name: Name, asset_datas: Array[AssetData]) -> bool:
        r"""
        x.remove_asset_datas_from_collection(name, asset_datas) -> bool
        Remove the given assets from the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_datas (Array[AssetData]): Assets to remove.
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def remove_asset_data_from_collection(self, name: Name, asset_data: AssetData) -> bool:
        r"""
        x.remove_asset_data_from_collection(name, asset_data) -> bool
        Remove the given asset from the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_data (AssetData): Asset to remove.
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def k2_remove_assets_from_collection(self, name: Name, asset_paths: Array[SoftObjectPath]) -> bool:
        r"""
        x.k2_remove_assets_from_collection(name, asset_paths) -> bool
        Remove the given assets from the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_paths (Array[SoftObjectPath]): 
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def k2_remove_asset_from_collection(self, name: Name, asset_path: SoftObjectPath) -> bool:
        r"""
        x.k2_remove_asset_from_collection(name, asset_path) -> bool
        Remove the given asset from the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_path (SoftObjectPath): Asset to remove (its path, eg) /Game/MyFolder/MyAsset.MyAsset).
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def k2_get_collections_containing_asset(self, asset_path: SoftObjectPath) -> Array[Name]:
        r"""
        x.k2_get_collections_containing_asset(asset_path) -> Array[Name]
        Get the names of the collections that contain the given asset.
        
        Args:
            asset_path (SoftObjectPath): 
        
        Returns:
            Array[Name]: Names of the collections that contain the asset.
        """
        ...
    def k2_add_asset_to_collection(self, name: Name, asset_path: SoftObjectPath) -> bool:
        r"""
        x.k2_add_asset_to_collection(name, asset_path) -> bool
        Add the given asset to the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_path (SoftObjectPath): 
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def k2_add_assets_to_collection(self, name: Name, asset_paths: Array[SoftObjectPath]) -> bool:
        r"""
        x.k2_add_assets_to_collection(name, asset_paths) -> bool
        Add the given assets to the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_paths (Array[SoftObjectPath]): 
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def get_collections_containing_asset_ptr(self, asset_ptr: Object) -> Array[Name]:
        r"""
        x.get_collections_containing_asset_ptr(asset_ptr) -> Array[Name]
        Get the names of the collections that contain the given asset.
        
        Args:
            asset_ptr (Object): Asset to test.
        
        Returns:
            Array[Name]: Names of the collections that contain the asset.
        """
        ...
    def get_collections_containing_asset_data(self, asset_data: AssetData) -> Array[Name]:
        r"""
        x.get_collections_containing_asset_data(asset_data) -> Array[Name]
        Get the names of the collections that contain the given asset.
        
        Args:
            asset_data (AssetData): Asset to test.
        
        Returns:
            Array[Name]: Names of the collections that contain the asset.
        """
        ...
    def get_collections_containing_asset(self, asset_path_name: Name) -> Array[Name]:
        r"""
        x.get_collections_containing_asset(asset_path_name) -> Array[Name]
        Get Collections Containing Asset
        
        Args:
            asset_path_name (Name): 
        
        Returns:
            Array[Name]:
        """
        ...
    def get_collections(self) -> Array[Name]:
        r"""
        x.get_collections() -> Array[Name]
        Get the names of all available collections.
        
        Returns:
            Array[Name]: Names of all available collections.
        """
        ...
    def get_assets_in_collection(self, name: Name) -> Array[AssetData]:
        r"""
        x.get_assets_in_collection(name) -> Array[AssetData]
        Get the assets in the given collection.
        
        Args:
            name (Name): Name of the collection to test.
        
        Returns:
            Array[AssetData]: Assets in the given collection.
        """
        ...
    def empty_collection(self, name: Name) -> bool:
        r"""
        x.empty_collection(name) -> bool
        Remove all assets from the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def destroy_collection(self, name: Name) -> bool:
        r"""
        x.destroy_collection(name) -> bool
        Destroy the given collection.
        
        Args:
            name (Name): Name of the collection to destroy.
        
        Returns:
            bool: True if the collection was destroyed, false otherwise (see the output log for details on error).
        """
        ...
    def create_collection(self, name: Name, share_type: CollectionShareType) -> bool:
        r"""
        x.create_collection(name, share_type) -> bool
        Create a new collection with the given name and share type.
        
        Args:
            name (Name): Name to give to the collection.
            share_type (CollectionShareType): Whether the collection should be local, private, or shared?
        
        Returns:
            bool: True if the collection was created, false otherwise (see the output log for details on error).
        """
        ...
    def collection_exists(self, name: Name) -> bool:
        r"""
        x.collection_exists(name) -> bool
        Check whether the given collection exists.
        
        Args:
            name (Name): Name of the collection to test.
        
        Returns:
            bool: True if the collection exists, false otherwise.
        """
        ...
    def add_asset_to_collection(self, name: Name, asset_path_name: Name) -> bool:
        r"""
        x.add_asset_to_collection(name, asset_path_name) -> bool
        Add Asset to Collection
        
        Args:
            name (Name): 
            asset_path_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def add_assets_to_collection(self, name: Name, asset_path_names: Array[Name]) -> bool:
        r"""
        x.add_assets_to_collection(name, asset_path_names) -> bool
        Add Assets to Collection
        
        Args:
            name (Name): 
            asset_path_names (Array[Name]): 
        
        Returns:
            bool:
        """
        ...
    def add_asset_ptr_to_collection(self, name: Name, asset_ptr: Object) -> bool:
        r"""
        x.add_asset_ptr_to_collection(name, asset_ptr) -> bool
        Add the given asset to the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_ptr (Object): Asset to add.
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def add_asset_ptrs_to_collection(self, name: Name, asset_ptrs: Array[Object]) -> bool:
        r"""
        x.add_asset_ptrs_to_collection(name, asset_ptrs) -> bool
        Add the given assets to the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_ptrs (Array[Object]): Assets to add.
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def add_asset_data_to_collection(self, name: Name, asset_data: AssetData) -> bool:
        r"""
        x.add_asset_data_to_collection(name, asset_data) -> bool
        Add the given asset to the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_data (AssetData): Asset to add.
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...
    def add_asset_datas_to_collection(self, name: Name, asset_datas: Array[AssetData]) -> bool:
        r"""
        x.add_asset_datas_to_collection(name, asset_datas) -> bool
        Add the given assets to the given collection.
        
        Args:
            name (Name): Name of the collection to modify.
            asset_datas (Array[AssetData]): Assets to add.
        
        Returns:
            bool: True if the collection was modified, false otherwise (see the output log for details on error).
        """
        ...

class AppleImageUtilsBaseAsyncTaskBlueprintProxy(Object):
    r"""
    Apple Image Utils Base Async Task Blueprint Proxy
    
    **C++ Source:**
    
    - **Plugin**: AppleImageUtils
    - **Module**: AppleImageUtils
    - **File**: AppleImageUtilsBlueprintProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``conversion_result`` (AppleImageUtilsImageConversionResult):  [Read-Write]
    - ``on_failure`` (AppleImageConversionDelegate):  [Read-Write]
    - ``on_success`` (AppleImageConversionDelegate):  [Read-Write]
    """
    @property
    def on_success(self) -> AppleImageConversionDelegate:
        r"""
        (AppleImageConversionDelegate):  [Read-Write]
        """
        ...
    @on_success.setter
    def on_success(self, value: AppleImageConversionDelegate) -> None:
        ...
    @property
    def on_failure(self) -> AppleImageConversionDelegate:
        r"""
        (AppleImageConversionDelegate):  [Read-Write]
        """
        ...
    @on_failure.setter
    def on_failure(self, value: AppleImageConversionDelegate) -> None:
        ...
    @property
    def conversion_result(self) -> AppleImageUtilsImageConversionResult:
        r"""
        (AppleImageUtilsImageConversionResult):  [Read-Only]
        """
        ...

class AndroidPermissionCallbackProxy(Object):
    r"""
    Android Permission Callback Proxy
    
    **C++ Source:**
    
    - **Plugin**: AndroidPermission
    - **Module**: AndroidPermission
    - **File**: AndroidPermissionCallbackProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_permissions_granted_dynamic_delegate`` (AndroidPermissionDynamicDelegate):  [Read-Write]
    """
    @property
    def on_permissions_granted_dynamic_delegate(self) -> AndroidPermissionDynamicDelegate:
        r"""
        (AndroidPermissionDynamicDelegate):  [Read-Write]
        """
        ...
    @on_permissions_granted_dynamic_delegate.setter
    def on_permissions_granted_dynamic_delegate(self, value: AndroidPermissionDynamicDelegate) -> None:
        ...

class AndroidPermissionFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    Android Permission Function Library
    
    **C++ Source:**
    
    - **Plugin**: AndroidPermission
    - **Module**: AndroidPermission
    - **File**: AndroidPermissionFunctionLibrary.h
    
    """
    @classmethod
    def check_permission(cls, permission: str) -> bool:
        r"""
        X.check_permission(permission) -> bool
        check if the permission is already granted
        
        Args:
            permission (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def acquire_permissions(cls, permissions: Array[str]) -> AndroidPermissionCallbackProxy:
        r"""
        X.acquire_permissions(permissions) -> AndroidPermissionCallbackProxy
        try to acquire permissions and return a singleton callback proxy object containing OnPermissionsGranted delegate
        
        Args:
            permissions (Array[str]): 
        
        Returns:
            AndroidPermissionCallbackProxy:
        """
        ...

class GeometryCacheStreamerSettings(DeveloperSettings):
    r"""
    Settings for the GeometryCache streamer
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCacheStreamer
    - **File**: GeometryCacheStreamerSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``look_ahead_buffer`` (float):  [Read-Write] The amount of animation (in seconds) to stream ahead of time (per stream)
    - ``max_memory_allowed`` (float):  [Read-Write] The maximum total amount of streamed data allowed in memory (for all streams)
    """
    @property
    def look_ahead_buffer(self) -> float:
        r"""
        (float):  [Read-Write] The amount of animation (in seconds) to stream ahead of time (per stream)
        """
        ...
    @look_ahead_buffer.setter
    def look_ahead_buffer(self, value: float) -> None:
        ...
    @property
    def max_memory_allowed(self) -> float:
        r"""
        (float):  [Read-Write] The maximum total amount of streamed data allowed in memory (for all streams)
        """
        ...
    @max_memory_allowed.setter
    def max_memory_allowed(self, value: float) -> None:
        ...

class MovieSceneGeometryCacheSection(MovieSceneSection):
    r"""
    Movie scene section that control geometry cache playback
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCacheTracks
    - **File**: MovieSceneGeometryCacheSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``params`` (MovieSceneGeometryCacheParams):  [Read-Write]
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    @property
    def params(self) -> MovieSceneGeometryCacheParams:
        r"""
        (MovieSceneGeometryCacheParams):  [Read-Write]
        """
        ...
    @params.setter
    def params(self, value: MovieSceneGeometryCacheParams) -> None:
        ...

class MovieSceneGeometryCacheTrack(MovieSceneNameableTrack):
    r"""
    Movie Scene Geometry Cache Track
    
    **C++ Source:**
    
    - **Plugin**: GeometryCache
    - **Module**: GeometryCacheTracks
    - **File**: MovieSceneGeometryCacheTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class BaseDynamicMeshComponent(MeshComponent):
    r"""
    UBaseDynamicMeshComponent is a base interface for a UMeshComponent based on a UDynamicMesh.
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: BaseDynamicMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``color_mode`` (DynamicMeshComponentColorOverrideMode):  [Read-Write]
    - ``color_space_mode`` (DynamicMeshVertexColorTransformMode):  [Read-Write] Color Space Transform that will be applied to the colors stored in the DynamicMesh Attribute Color Overlay when
      constructing render buffers.
      Default is "No Transform", ie color R/G/B/A will be independently converted from 32-bit float to 8-bit by direct mapping.
      LinearToSRGB mode will apply SRGB conversion, ie assumes colors in the Mesh are in Linear space. This will produce the same behavior as UStaticMesh.
      SRGBToLinear mode will invert SRGB conversion, ie assumes colors in the Mesh are in SRGB space.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``constant_color`` (Color):  [Read-Write] Constant Color used when Override Color Mode is set to Constant
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_flat_shading`` (bool):  [Read-Write] Enable use of per-triangle facet normals in place of mesh normals
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``enable_raytracing`` (bool):  [Read-Write] Enable/disable Raytracing support on this Mesh, if Raytracing is currently enabled in the Project Settings.
      Use SetEnableRaytracing() to configure this flag in Blueprints/C++.
    - ``enable_view_mode_overrides`` (bool):  [Read-Write] This flag controls whether Editor View Mode Overrides are enabled for this mesh. For example, this controls hidden-line removal on the wireframe
      in Wireframe View Mode, and whether the normal map will be disabled in Lighting-Only View Mode, as well as various other things.
      Use SetViewModeOverridesEnabled() to control this setting in Blueprints/C++.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``explicit_show_wireframe`` (bool):  [Read-Write] If true, render the Wireframe on top of the Shaded Mesh
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color`` (LinearColor):  [Read-Write] Constant Color used when Override Color Mode is set to Constant
    """
    @property
    def explicit_show_wireframe(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, render the Wireframe on top of the Shaded Mesh
        """
        ...
    @explicit_show_wireframe.setter
    def explicit_show_wireframe(self, value: bool) -> None:
        ...
    @property
    def wireframe_color(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Constant Color used when Override Color Mode is set to Constant
        """
        ...
    @wireframe_color.setter
    def wireframe_color(self, value: LinearColor) -> None:
        ...
    @property
    def color_mode(self) -> DynamicMeshComponentColorOverrideMode:
        r"""
        (DynamicMeshComponentColorOverrideMode):  [Read-Write]
        """
        ...
    @color_mode.setter
    def color_mode(self, value: DynamicMeshComponentColorOverrideMode) -> None:
        ...
    @property
    def constant_color(self) -> Color:
        r"""
        (Color):  [Read-Write] Constant Color used when Override Color Mode is set to Constant
        """
        ...
    @constant_color.setter
    def constant_color(self, value: Color) -> None:
        ...
    @property
    def color_space_mode(self) -> DynamicMeshVertexColorTransformMode:
        r"""
        (DynamicMeshVertexColorTransformMode):  [Read-Write] Color Space Transform that will be applied to the colors stored in the DynamicMesh Attribute Color Overlay when
        constructing render buffers.
        Default is "No Transform", ie color R/G/B/A will be independently converted from 32-bit float to 8-bit by direct mapping.
        LinearToSRGB mode will apply SRGB conversion, ie assumes colors in the Mesh are in Linear space. This will produce the same behavior as UStaticMesh.
        SRGBToLinear mode will invert SRGB conversion, ie assumes colors in the Mesh are in SRGB space.
        """
        ...
    @color_space_mode.setter
    def color_space_mode(self, value: DynamicMeshVertexColorTransformMode) -> None:
        ...
    @property
    def enable_flat_shading(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable use of per-triangle facet normals in place of mesh normals
        """
        ...
    @enable_flat_shading.setter
    def enable_flat_shading(self, value: bool) -> None:
        ...
    @property
    def enable_view_mode_overrides(self) -> bool:
        r"""
        (bool):  [Read-Write] This flag controls whether Editor View Mode Overrides are enabled for this mesh. For example, this controls hidden-line removal on the wireframe
        in Wireframe View Mode, and whether the normal map will be disabled in Lighting-Only View Mode, as well as various other things.
        Use SetViewModeOverridesEnabled() to control this setting in Blueprints/C++.
        """
        ...
    @enable_view_mode_overrides.setter
    def enable_view_mode_overrides(self, value: bool) -> None:
        ...
    @property
    def enable_raytracing(self) -> bool:
        r"""
        (bool):  [Read-Write] Enable/disable Raytracing support on this Mesh, if Raytracing is currently enabled in the Project Settings.
        Use SetEnableRaytracing() to configure this flag in Blueprints/C++.
        """
        ...
    @enable_raytracing.setter
    def enable_raytracing(self, value: bool) -> None:
        ...
    def set_view_mode_overrides_enabled(self, enabled: bool) -> None:
        r"""
        x.set_view_mode_overrides_enabled(enabled) -> None
        Set View Mode Overrides Enabled
        
        Args:
            enabled (bool):
        """
        ...
    def set_vertex_color_space_transform_mode(self, new_mode: DynamicMeshVertexColorTransformMode) -> None:
        r"""
        x.set_vertex_color_space_transform_mode(new_mode) -> None
        Configure the active Color Space Transform Mode
        
        Args:
            new_mode (DynamicMeshVertexColorTransformMode):
        """
        ...
    def set_shadows_enabled(self, enabled: bool) -> None:
        r"""
        x.set_shadows_enabled(enabled) -> None
        Set Shadows Enabled
        
        Args:
            enabled (bool):
        """
        ...
    def set_secondary_render_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_secondary_render_material(material) -> None
        Set an active secondary render material.
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_secondary_buffers_visibility(self, set_visible: bool) -> None:
        r"""
        x.set_secondary_buffers_visibility(set_visible) -> None
        Show/Hide the secondary triangle buffers. Does not invalidate SceneProxy.
        
        Args:
            set_visible (bool):
        """
        ...
    def set_override_render_material(self, material: MaterialInterface) -> None:
        r"""
        x.set_override_render_material(material) -> None
        Set an active override render material. This should replace all materials during rendering.
        
        Args:
            material (MaterialInterface):
        """
        ...
    def set_enable_wireframe_render_pass(self, enable: bool) -> None:
        r"""
        x.set_enable_wireframe_render_pass(enable) -> None
        Configure whether wireframe rendering is enabled or not
        
        Args:
            enable (bool):
        """
        ...
    def set_enable_raytracing(self, set_enabled: bool) -> None:
        r"""
        x.set_enable_raytracing(set_enabled) -> None
        Enable/Disable raytracing support. This is an expensive call as it flushes
        the rendering queue and forces an immediate rebuild of the SceneProxy.
        
        Args:
            set_enabled (bool):
        """
        ...
    def set_enable_flat_shading(self, enable: bool) -> None:
        r"""
        x.set_enable_flat_shading(enable) -> None
        Configure the Color used with Constant Color Override Mode
        
        Args:
            enable (bool):
        """
        ...
    def set_constant_override_color(self, new_color: Color) -> None:
        r"""
        x.set_constant_override_color(new_color) -> None
        Configure the Color used with Constant Color Override Mode
        
        Args:
            new_color (Color):
        """
        ...
    def set_color_override_mode(self, new_mode: DynamicMeshComponentColorOverrideMode) -> None:
        r"""
        x.set_color_override_mode(new_mode) -> None
        Configure the active Color Override
        
        Args:
            new_mode (DynamicMeshComponentColorOverrideMode):
        """
        ...
    def has_override_render_material(self, k: int) -> bool:
        r"""
        x.has_override_render_material(k) -> bool
        
        
        Args:
            k (int32): 
        
        Returns:
            bool: true if an override render material is currently enabled for the given MaterialIndex
        """
        ...
    def get_view_mode_overrides_enabled(self) -> bool:
        r"""
        x.get_view_mode_overrides_enabled() -> bool
        Get View Mode Overrides Enabled
        
        Returns:
            bool:
        """
        ...
    def get_vertex_color_space_transform_mode(self) -> DynamicMeshVertexColorTransformMode:
        r"""
        x.get_vertex_color_space_transform_mode() -> DynamicMeshVertexColorTransformMode
        
        
        Returns:
            DynamicMeshVertexColorTransformMode: active Color Override mode
        """
        ...
    def get_shadows_enabled(self) -> bool:
        r"""
        x.get_shadows_enabled() -> bool
        Get Shadows Enabled
        
        Returns:
            bool:
        """
        ...
    def get_secondary_render_material(self) -> MaterialInterface:
        r"""
        x.get_secondary_render_material() -> MaterialInterface
        
        
        Returns:
            MaterialInterface: active secondary render material
        """
        ...
    def get_secondary_buffers_visibility(self) -> bool:
        r"""
        x.get_secondary_buffers_visibility() -> bool
        
        
        Returns:
            bool: true if secondary buffers are currently set to be visible
        """
        ...
    def get_override_render_material(self, material_index: int) -> MaterialInterface:
        r"""
        x.get_override_render_material(material_index) -> MaterialInterface
        
        
        Args:
            material_index (int32): 
        
        Returns:
            MaterialInterface: active override render material for the given MaterialIndex
        """
        ...
    def get_flat_shading_enabled(self) -> bool:
        r"""
        x.get_flat_shading_enabled() -> bool
        
        
        Returns:
            bool: active Color used for Constant Color Override Mode
        """
        ...
    def get_enable_wireframe_render_pass(self) -> bool:
        r"""
        x.get_enable_wireframe_render_pass() -> bool
        
        
        Returns:
            bool: true if wireframe rendering pass is enabled
        """
        ...
    def get_enable_raytracing(self) -> bool:
        r"""
        x.get_enable_raytracing() -> bool
        
        
        Returns:
            bool: true if raytracing support is currently enabled
        """
        ...
    def get_dynamic_mesh(self) -> DynamicMesh:
        r"""
        x.get_dynamic_mesh() -> DynamicMesh
        
        
        Returns:
            DynamicMesh: the child UDynamicMesh
        """
        ...
    def get_constant_override_color(self) -> Color:
        r"""
        x.get_constant_override_color() -> Color
        
        
        Returns:
            Color: active Color used for Constant Color Override Mode
        """
        ...
    def get_color_override_mode(self) -> DynamicMeshComponentColorOverrideMode:
        r"""
        x.get_color_override_mode() -> DynamicMeshComponentColorOverrideMode
        
        
        Returns:
            DynamicMeshComponentColorOverrideMode: active Color Override mode
        """
        ...
    def clear_secondary_render_material(self) -> None:
        r"""
        x.clear_secondary_render_material() -> None
        Clear any active secondary render material
        """
        ...
    def clear_override_render_material(self) -> None:
        r"""
        x.clear_override_render_material() -> None
        Clear any active override render material
        """
        ...

class DynamicMeshComponent(BaseDynamicMeshComponent):
    r"""
    UDynamicMeshComponent is a mesh component similar to UProceduralMeshComponent,
    except it bases the renderable geometry off an internal UDynamicMesh instance (which
    encapsulates a FDynamicMesh3).
    
    There is extensive support for partial updates to render buffers, customizing colors,
    internally decomposing the mesh into separate chunks for more efficient render updates,
    and support for attaching a 'Postprocessor' to generate a render mesh on-the-fly
    See comment sections below for details.
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: DynamicMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``agg_geom`` (KAggregateGeom):  [Read-Write] Simplified collision representation for the mesh component
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``collision_type`` (CollisionTraceFlag):  [Read-Write] Type of Collision Geometry to use for this Mesh
    - ``color_mode`` (DynamicMeshComponentColorOverrideMode):  [Read-Write]
    - ``color_space_mode`` (DynamicMeshVertexColorTransformMode):  [Read-Write] Color Space Transform that will be applied to the colors stored in the DynamicMesh Attribute Color Overlay when
      constructing render buffers.
      Default is "No Transform", ie color R/G/B/A will be independently converted from 32-bit float to 8-bit by direct mapping.
      LinearToSRGB mode will apply SRGB conversion, ie assumes colors in the Mesh are in Linear space. This will produce the same behavior as UStaticMesh.
      SRGBToLinear mode will invert SRGB conversion, ie assumes colors in the Mesh are in SRGB space.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``constant_color`` (Color):  [Read-Write] Constant Color used when Override Color Mode is set to Constant
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``defer_collision_updates`` (bool):  [Read-Write] If true, updates to the mesh will not result in immediate collision regeneration. Useful when the mesh will be modified multiple times before collision is needed.
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_complex_collision`` (bool):  [Read-Write] If true, current mesh will be used as Complex Collision source mesh.
      This is independent of the CollisionType setting, ie, even if Complex collision is enabled, if this is false, then the Complex Collision mesh will be empty
    - ``enable_flat_shading`` (bool):  [Read-Write] Enable use of per-triangle facet normals in place of mesh normals
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``enable_raytracing`` (bool):  [Read-Write] Enable/disable Raytracing support on this Mesh, if Raytracing is currently enabled in the Project Settings.
      Use SetEnableRaytracing() to configure this flag in Blueprints/C++.
    - ``enable_view_mode_overrides`` (bool):  [Read-Write] This flag controls whether Editor View Mode Overrides are enabled for this mesh. For example, this controls hidden-line removal on the wireframe
      in Wireframe View Mode, and whether the normal map will be disabled in Lighting-Only View Mode, as well as various other things.
      Use SetViewModeOverridesEnabled() to control this setting in Blueprints/C++.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``explicit_show_wireframe`` (bool):  [Read-Write] If true, render the Wireframe on top of the Shaded Mesh
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``tangents_type`` (DynamicMeshComponentTangentsMode):  [Read-Write] Tangent source defines whether we use the provided tangents on the Dynamic Mesh, autogenerate tangents, or do not use tangents
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_async_cooking`` (bool):  [Read-Write] Controls whether the physics cooking should be done off the game thread.
      This should be used when collision geometry doesn't have to be immediately up to date (For example streaming in far away objects)
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color`` (LinearColor):  [Read-Write] Constant Color used when Override Color Mode is set to Constant
    """
    @property
    def tangents_type(self) -> DynamicMeshComponentTangentsMode:
        r"""
        (DynamicMeshComponentTangentsMode):  [Read-Write] Tangent source defines whether we use the provided tangents on the Dynamic Mesh, autogenerate tangents, or do not use tangents
        """
        ...
    @tangents_type.setter
    def tangents_type(self, value: DynamicMeshComponentTangentsMode) -> None:
        ...
    @property
    def collision_type(self) -> CollisionTraceFlag:
        r"""
        (CollisionTraceFlag):  [Read-Write] Type of Collision Geometry to use for this Mesh
        """
        ...
    @collision_type.setter
    def collision_type(self, value: CollisionTraceFlag) -> None:
        ...
    @property
    def use_async_cooking(self) -> bool:
        r"""
        (bool):  [Read-Only] Controls whether the physics cooking should be done off the game thread.
        This should be used when collision geometry doesn't have to be immediately up to date (For example streaming in far away objects)
        """
        ...
    @property
    def enable_complex_collision(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, current mesh will be used as Complex Collision source mesh.
        This is independent of the CollisionType setting, ie, even if Complex collision is enabled, if this is false, then the Complex Collision mesh will be empty
        """
        ...
    @enable_complex_collision.setter
    def enable_complex_collision(self, value: bool) -> None:
        ...
    @property
    def defer_collision_updates(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, updates to the mesh will not result in immediate collision regeneration. Useful when the mesh will be modified multiple times before collision is needed.
        """
        ...
    @defer_collision_updates.setter
    def defer_collision_updates(self, value: bool) -> None:
        ...
    def validate_material_slots(self, create_if_missing: bool = True, delete_extra_slots: bool = True) -> bool:
        r"""
        x.validate_material_slots(create_if_missing=True, delete_extra_slots=True) -> bool
        Compute the maximum MaterialID on the DynamicMesh, and ensure that Material Slots match.
        Pass both arguments as false to just do a check.
        
        Args:
            create_if_missing (bool): if true, add extra (empty) Material Slots to match max MaterialID
            delete_extra_slots (bool): if true, extra Material Slots beyond max MaterialID are removed
        
        Returns:
            bool: true if at the end of this function, Material Slot Count == Max MaterialID
        """
        ...
    def update_collision(self, only_if_pending: bool = True) -> None:
        r"""
        x.update_collision(only_if_pending=True) -> None
        Force an update of the Collision/Physics data for this Component.
        
        Args:
            only_if_pending (bool): only update if a collision update is pending, ie the underlying DynamicMesh changed and bDeferCollisionUpdates is enabled
        """
        ...
    def set_tangents_type(self, new_tangents_type: DynamicMeshComponentTangentsMode) -> None:
        r"""
        x.set_tangents_type(new_tangents_type) -> None
        Set Tangents Type
        
        Args:
            new_tangents_type (DynamicMeshComponentTangentsMode):
        """
        ...
    def set_dynamic_mesh(self, new_mesh: DynamicMesh) -> None:
        r"""
        x.set_dynamic_mesh(new_mesh) -> None
        Replace the current UDynamicMesh with a new one, and transfer ownership of NewMesh to this Component.
        This can be used to (eg) assign a UDynamicMesh created with NewObject in the Transient Package to this Component.
        warning: If NewMesh is owned/Outer'd to another DynamicMeshComponent, a GLEO error may occur if that Component is serialized.
        
        Args:
            new_mesh (DynamicMesh):
        """
        ...
    def set_deferred_collision_updates_enabled(self, enabled: bool, immediate_update: bool = True) -> None:
        r"""
        x.set_deferred_collision_updates_enabled(enabled, immediate_update=True) -> None
        Set value of bDeferCollisionUpdates, when enabled, collision is not automatically recomputed each time the mesh changes.
        
        Args:
            enabled (bool): 
            immediate_update (bool): if true, UpdateCollision(true) is called if bEnabled=false, ie to force a collision rebuild
        """
        ...
    def set_complex_as_simple_collision_enabled(self, enabled: bool, immediate_update: bool = True) -> None:
        r"""
        x.set_complex_as_simple_collision_enabled(enabled, immediate_update=True) -> None
        If bEnabled=true, sets bEnableComplexCollision=true and CollisionType=CTF_UseComplexAsSimple
        If bEnabled=true, sets bEnableComplexCollision=false and CollisionType=CTF_UseDefault
        
        Args:
            enabled (bool): 
            immediate_update (bool): if true, UpdateCollision(true) is called
        """
        ...
    def notify_mesh_vertex_attributes_modified(self, positions: bool = True, normals: bool = True, u_vs: bool = True, colors: bool = True) -> None:
        r"""
        x.notify_mesh_vertex_attributes_modified(positions=True, normals=True, u_vs=True, colors=True) -> None
        Notify the Component that vertex attribute values of it's DynamicMesh have been modified externally. This will result in
        Rendering vertex buffers being updated. This update path is more efficient than doing a full Notify Mesh Updated.
        warning: it is invalid to call this function if (1) the mesh triangulation has also been changed, (2) triangle MaterialIDs have been changed, or (3) any attribute overlay (normal, color, UV) topology has been modified, ie split-vertices have been added/removed. Behavior of this function is undefined in these cases and may crash. If you are unsure, use Notify Mesh Updated.
        
        Args:
            positions (bool): 
            normals (bool): 
            u_vs (bool): 
            colors (bool):
        """
        ...
    def notify_mesh_modified(self) -> None:
        r"""
        x.notify_mesh_modified() -> None
        Notify the Component that it's DynamicMesh has been modified externally. This will result in all Rendering Data
        for the Component being rebuilt on the next frame (internally the Scene Proxy is fully destroyed and rebuilt).
        
        You must use this function if the mesh triangulation has been modified, or if polygroups or material assignments
        have been changed, or if Normal/UV/Color topology has changed (ie new split-vertices have been introduced).
        If only vertex attribute values (position, normals, UVs, colors) have been modified, then
        Notify Vertex Attributes Updated can be used to do a faster update.
        """
        ...
    def get_tangents_type(self) -> DynamicMeshComponentTangentsMode:
        r"""
        x.get_tangents_type() -> DynamicMeshComponentTangentsMode
        Get Tangents Type
        
        Returns:
            DynamicMeshComponentTangentsMode:
        """
        ...
    def enable_complex_as_simple_collision(self) -> None:
        r"""
        x.enable_complex_as_simple_collision() -> None
        calls SetComplexAsSimpleCollisionEnabled(true, true)
        """
        ...
    def configure_material_set(self, new_material_set: Array[MaterialInterface]) -> None:
        r"""
        x.configure_material_set(new_material_set) -> None
        Set new list of Materials for the Mesh. Dynamic Mesh Component does not have
        Slot Names, so the size of the Material Set should be the same as the number of
        different Material IDs on the mesh MaterialID attribute
        
        Args:
            new_material_set (Array[MaterialInterface]):
        """
        ...

class DynamicMeshActor(Actor):
    r"""
    ADynamicMeshActor is an Actor that has a USimpleDynamicMeshComponent as it's RootObject.
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: DynamicMeshActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``dynamic_mesh_component`` (DynamicMeshComponent):  [Read-Only]
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_compute_mesh_pool`` (bool):  [Read-Write] Control whether the DynamicMeshPool will be created when requested via GetComputeMeshPool()
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def dynamic_mesh_component(self) -> DynamicMeshComponent:
        r"""
        (DynamicMeshComponent):  [Read-Only]
        """
        ...
    @property
    def enable_compute_mesh_pool(self) -> bool:
        r"""
        (bool):  [Read-Write] Control whether the DynamicMeshPool will be created when requested via GetComputeMeshPool()
        """
        ...
    @enable_compute_mesh_pool.setter
    def enable_compute_mesh_pool(self, value: bool) -> None:
        ...
    def release_compute_mesh(self, mesh: DynamicMesh) -> bool:
        r"""
        x.release_compute_mesh(mesh) -> bool
        Release a compute mesh back to the Pool
        
        Args:
            mesh (DynamicMesh): 
        
        Returns:
            bool:
        """
        ...
    def release_all_compute_meshes(self) -> None:
        r"""
        x.release_all_compute_meshes() -> None
        Release all compute meshes that the Pool has allocated
        """
        ...
    def get_dynamic_mesh_component(self) -> DynamicMeshComponent:
        r"""
        x.get_dynamic_mesh_component() -> DynamicMeshComponent
        Get Dynamic Mesh Component
        
        Returns:
            DynamicMeshComponent:
        """
        ...
    def get_compute_mesh_pool(self) -> DynamicMeshPool:
        r"""
        x.get_compute_mesh_pool() -> DynamicMeshPool
        Access the compute mesh pool
        
        Returns:
            DynamicMeshPool:
        """
        ...
    def free_all_compute_meshes(self) -> None:
        r"""
        x.free_all_compute_meshes() -> None
        Release all compute meshes that the Pool has allocated, and then release them from the Pool, so that they will be garbage-collected
        """
        ...
    def allocate_compute_mesh(self) -> DynamicMesh:
        r"""
        x.allocate_compute_mesh() -> DynamicMesh
        Request a compute mesh from the Pool, which will return a previously-allocated mesh or add and return a new one. If the Pool is disabled, a new UDynamicMesh will be allocated and returned.
        
        Returns:
            DynamicMesh:
        """
        ...

class DynamicMesh(Object):
    r"""
    UDynamicMesh is a UObject container for a FDynamicMesh3.
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: UDynamicMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enable_mesh_generator`` (bool):  [Read-Write] Controls whether the active Generator (if configured) will be applied when rebuilding the mesh
    - ``mesh_modified_bp_event`` (OnDynamicMeshModifiedBP):  [Read-Write] Blueprintable event called when mesh is modified, in the same cases as OnMeshChanged
    """
    @property
    def mesh_modified_bp_event(self) -> OnDynamicMeshModifiedBP:
        r"""
        (OnDynamicMeshModifiedBP):  [Read-Write] Blueprintable event called when mesh is modified, in the same cases as OnMeshChanged
        """
        ...
    @mesh_modified_bp_event.setter
    def mesh_modified_bp_event(self, value: OnDynamicMeshModifiedBP) -> None:
        ...
    def reset_to_cube(self) -> DynamicMesh:
        r"""
        x.reset_to_cube() -> DynamicMesh
        Clear the internal mesh to a 100x100x100 cube with base at the origin.
        This this instead of Reset() if an initially-empty mesh is undesirable (eg for a Component)
        
        Returns:
            DynamicMesh:
        """
        ...
    def reset(self) -> DynamicMesh:
        r"""
        x.reset() -> DynamicMesh
        Clear the internal mesh to an empty mesh.
        This *does not* allocate a new mesh, so any existing mesh pointers/refs are still valid
        
        Returns:
            DynamicMesh:
        """
        ...
    def is_empty(self) -> bool:
        r"""
        x.is_empty() -> bool
        
        
        Returns:
            bool: true if the mesh has no triangles
        """
        ...
    def get_triangle_count(self) -> int:
        r"""
        x.get_triangle_count() -> int32
        
        
        Returns:
            int32: number of triangles in the mesh
        """
        ...

class DynamicMeshPool(Object):
    r"""
    UDynamicMeshPool manages a Pool of UDynamicMesh objects. This allows
    the meshes to be re-used instead of being garbage-collected. This
    is intended to be used by Blueprints that need to do procedural geometry
    operations that generate temporary meshes, as these will commonly run their
    construction scripts many times as the user (eg) manipulates parameters,
    and constantly spawning new UDynamicMesh instances will result in enormous
    memory usage hanging around until GC runs.
    
    Usage is to call RequestMesh() to take ownership of an available UDynamicMesh (which
    will allocate a new one if the pool is empty) and ReturnMesh() to return it to the pool.
    
    ReturnAllMeshes() can be called to return all allocated meshes.
    
    In both cases, there is nothing preventing you from still holding on to the mesh.
    So, be careful.
    
    FreeAllMeshes() calls ReturnAllMeshes() and then releases the pool's references to
    the allocated meshes, so they can be Garbage Collected
    
    If you Request() more meshes than you Return(), the Pool will still be holding on to
    references to those meshes, and they will never be Garbage Collected (ie memory leak).
    As a failsafe, if the number of allocated meshes exceeds geometry.DynamicMesh.MaxPoolSize,
    the Pool will release all it's references and run garbage collection on the next call to RequestMesh().
    (Do not rely on this as a memory management strategy)
    
    An alternate strategy that could be employed here is for the Pool to not hold
    references to meshes it has provided, only those that have been explicitly returned.
    Then non-returned meshes would simply be garbage-collected, however it allows
    potentially a large amount of memory to be consumed until that occurs.
    
    UDynamicMesh::Reset() is called on the object returned to the Pool, which clears
    the internal FDynamicMesh3 (which uses normal C++ memory management, so no garbage collection involved)
    So the Pool does not re-use mesh memory, only the UObject containers.
    
    **C++ Source:**
    
    - **Module**: GeometryFramework
    - **File**: UDynamicMesh.h
    
    """
    def return_mesh(self, mesh: DynamicMesh) -> None:
        r"""
        x.return_mesh(mesh) -> None
        Release a UDynamicMesh returned by RequestMesh() back to the pool
        
        Args:
            mesh (DynamicMesh):
        """
        ...
    def return_all_meshes(self) -> None:
        r"""
        x.return_all_meshes() -> None
        Release all GeneratedMeshes back to the pool
        """
        ...
    def request_mesh(self) -> DynamicMesh:
        r"""
        x.request_mesh() -> DynamicMesh
        
        
        Returns:
            DynamicMesh: an available UDynamicMesh from the pool (possibly allocating a new mesh)
        """
        ...
    def free_all_meshes(self) -> None:
        r"""
        x.free_all_meshes() -> None
        Release all GeneratedMeshes back to the pool and allow them to be garbage collected
        """
        ...

class OctreeDynamicMeshComponent(BaseDynamicMeshComponent):
    r"""
    UOctreeDynamicMeshComponent is a mesh component similar to UProceduralMeshComponent,
    except it bases the renderable geometry off an internal FDynamicMesh3 instance.
    The class generally has the same capabilities as UDynamicMeshComponent.
    
    A FDynamicMeshOctree3 is available to dynamically track the triangles of the mesh
    (however the client is responsible for updating this octree).
    Based on the Octree, the mesh is partitioned into chunks that are stored in separate
    RenderBuffers in the FOctreeDynamicMeshSceneProxy.
    Calling NotifyMeshUpdated() will result in only the "dirty" chunks being updated,
    rather than the entire mesh.
    
    (So, if you don't need this capability, and don't want to update an Octree, use UDynamicMeshComponent!)
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: OctreeDynamicMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``color_mode`` (DynamicMeshComponentColorOverrideMode):  [Read-Write]
    - ``color_space_mode`` (DynamicMeshVertexColorTransformMode):  [Read-Write] Color Space Transform that will be applied to the colors stored in the DynamicMesh Attribute Color Overlay when
      constructing render buffers.
      Default is "No Transform", ie color R/G/B/A will be independently converted from 32-bit float to 8-bit by direct mapping.
      LinearToSRGB mode will apply SRGB conversion, ie assumes colors in the Mesh are in Linear space. This will produce the same behavior as UStaticMesh.
      SRGBToLinear mode will invert SRGB conversion, ie assumes colors in the Mesh are in SRGB space.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``constant_color`` (Color):  [Read-Write] Constant Color used when Override Color Mode is set to Constant
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_flat_shading`` (bool):  [Read-Write] Enable use of per-triangle facet normals in place of mesh normals
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``enable_raytracing`` (bool):  [Read-Write] Enable/disable Raytracing support on this Mesh, if Raytracing is currently enabled in the Project Settings.
      Use SetEnableRaytracing() to configure this flag in Blueprints/C++.
    - ``enable_view_mode_overrides`` (bool):  [Read-Write] This flag controls whether Editor View Mode Overrides are enabled for this mesh. For example, this controls hidden-line removal on the wireframe
      in Wireframe View Mode, and whether the normal map will be disabled in Lighting-Only View Mode, as well as various other things.
      Use SetViewModeOverridesEnabled() to control this setting in Blueprints/C++.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``explicit_show_wireframe`` (bool):  [Read-Write] If true, render the Wireframe on top of the Shaded Mesh
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color`` (LinearColor):  [Read-Write] Constant Color used when Override Color Mode is set to Constant
    """
    def set_dynamic_mesh(self, new_mesh: DynamicMesh) -> None:
        r"""
        x.set_dynamic_mesh(new_mesh) -> None
        Set Dynamic Mesh
        
        Args:
            new_mesh (DynamicMesh):
        """
        ...

class LineSetComponent(MeshComponent):
    r"""
    Line Set Component
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: LineSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class MeshWireframeComponent(MeshComponent):
    r"""
    UMeshWireframeComponent draws a mesh wireframe as lines, with line color/thickness
    varying depending on line type and the configuration settings.
    Currently can draw:
       - all mesh edges
       - boundary edges
       - UV seam edges
       - Normal seam edges
       - Color seam edges
    
    Client must provide a IMeshWireframeSourceProvider implementation that provides the
    edge set, vertices, and edge type
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: MeshWireframeComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``boundary_edge_color`` (Color):  [Read-Write]
    - ``boundary_edge_thickness`` (float):  [Read-Write]
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``color_seam_color`` (Color):  [Read-Write]
    - ``color_seam_thickness`` (float):  [Read-Write]
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_boundary_edges`` (bool):  [Read-Write] Boundary Edge properties
    - ``enable_color_seams`` (bool):  [Read-Write] color seam properties
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``enable_normal_seams`` (bool):  [Read-Write] normal seam properties
    - ``enable_tangent_seams`` (bool):  [Read-Write] tangent seam properties
    - ``enable_uv_seams`` (bool):  [Read-Write] UV seam properties
    - ``enable_wireframe`` (bool):  [Read-Write] Wireframe properties
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``line_depth_bias`` (float):  [Read-Write] Depth bias of the lines, used to offset in depth to avoid z-fighting
    - ``line_depth_bias_size_scale`` (float):  [Read-Write] Target-size depth bias scale. This is multiplied by LineDepthBias.
      Client of UMeshWireframeComponent can set this if desired, eg to fraction of target object bounding box size, etc.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``normal_seam_color`` (Color):  [Read-Write]
    - ``normal_seam_thickness`` (float):  [Read-Write]
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``tangent_seam_color`` (Color):  [Read-Write]
    - ``tangent_seam_thickness`` (float):  [Read-Write]
    - ``thickness_scale`` (float):  [Read-Write] Scaling factor applied to the per-edge-type thicknesses defined below
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``uv_seam_color`` (Color):  [Read-Write]
    - ``uv_seam_thickness`` (float):  [Read-Write]
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wireframe_color`` (Color):  [Read-Write]
    - ``wireframe_thickness`` (float):  [Read-Write]
    """
    ...

class PointSetComponent(MeshComponent):
    r"""
    UPointSetComponent is a Component that draws a set of points, as small squares.
    Per-point Color and (view-space) Size is supported. Normals are not supported.
    
    Points are inserted with an externally-defined ID, internally this is done via
    a TSparseArray. This class allocates a contiguous TArray large enugh to hold the
    largest ID. Using ReservePoints() may be beneficial for huge arrays.
    
    The points are drawn as two triangles (ie a square) orthogonal to the view direction.
    The actual point size is calculated in the shader, and so a custom material must be used.
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: PointSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class PreviewGeometryActor(InternalToolFrameworkActor):
    r"""
    An actor suitable for attaching components used to draw preview elements, such as LineSetComponent and TriangleSetComponent.
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: PreviewGeometryActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class TriangleSetComponent(MeshComponent):
    r"""
    A component for rendering an arbitrary assortment of triangles. Suitable, for instance, for rendering highlighted faces.
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: TriangleSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class ModelingObjectsCreationAPI(Object):
    r"""
    UModelingObjectsCreationAPI is a base interface for functions that can be used to
    create various types of objects from Modeling Tools, or other sources. The "type" is
    very generic here - "Mesh", "Texture", etc - because this API is meant to provide
    an abstraction for Tools to emit different types of objects in different situations.
    For example an Tool might emit StaticMesh Asset/Actors in-Editor, but ProceduralMeshComponents at Runtime.
    
    The creation inputs are specified via the structs above (eg FCreateMeshObjectParams, FCreateTextureObjectParams),
    which are very extensive, kitchen-sink sort of structs. Generally "New Mesh Object"
    creation behavior will be very complex and so this API is really just a way to route
    the data, and very few guarantees can be made about any specific implementation.
    
    The assumed (but not really required) usage of instances of this type are that they
    will be registered with an InteractiveToolsContext's ContextObjectStore, and then
    fetched from there by Tools/Algorithms/etc that need to use these capabilities can
    use the UE::Modeling::CreateXObject() helper functions below. However the interface
    does not have any dependencies on this usage model.
    
    See UEditorModelingObjectsCreationAPI for an example implementation suitable for in-Editor use.
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: ModelingObjectsCreationAPI.h
    
    """
    def create_texture_object(self, create_tex_params: CreateTextureObjectParams) -> CreateTextureObjectResult:
        r"""
        x.create_texture_object(create_tex_params) -> CreateTextureObjectResult
        Create a new texture object based on the data in CreateTexParams
        
        Args:
            create_tex_params (CreateTextureObjectParams): 
        
        Returns:
            CreateTextureObjectResult: a results data structure, containing a result code and information about any new objects created
        """
        ...
    def create_new_actor(self, create_actor_params: CreateActorParams) -> CreateActorResult:
        r"""
        x.create_new_actor(create_actor_params) -> CreateActorResult
        Create a new material object based on the data in CreateMaterialParams
        
        Args:
            create_actor_params (CreateActorParams): 
        
        Returns:
            CreateActorResult: a results data structure, containing a result code and information about any new objects created
        """
        ...
    def create_mesh_object(self, create_mesh_params: CreateMeshObjectParams) -> CreateMeshObjectResult:
        r"""
        x.create_mesh_object(create_mesh_params) -> CreateMeshObjectResult
        Create a new mesh object based on the data in CreateMeshParams
        
        Args:
            create_mesh_params (CreateMeshObjectParams): 
        
        Returns:
            CreateMeshObjectResult: a results data structure, containing a result code and information about any new objects created
        """
        ...
    def create_material_object(self, create_material_params: CreateMaterialObjectParams) -> CreateMaterialObjectResult:
        r"""
        x.create_material_object(create_material_params) -> CreateMaterialObjectResult
        Create a new material object based on the data in CreateMaterialParams
        
        Args:
            create_material_params (CreateMaterialObjectParams): 
        
        Returns:
            CreateMaterialObjectResult: a results data structure, containing a result code and information about any new objects created
        """
        ...

class PreviewMeshActor(InternalToolFrameworkActor):
    r"""
    UPreviewMesh internally spawns a APreviewMeshActor to hold the preview mesh object.
    We use this AInternalToolFrameworkActor subclass so that we can identify such objects
    at higher levels (for example to prevent them from being deleted in the Editor)
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponents
    - **File**: PreviewMesh.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class EditorModelingObjectsCreationAPI(ModelingObjectsCreationAPI):
    r"""
    Implementation of UModelingObjectsCreationAPI suitable for use in UE Editor.
    - CreateMeshObject() currently creates a StaticMesh Asset/Actor, a Volume Actor or a DynamicMesh Actor
    - CreateTextureObject() currently creates a UTexture2D Asset
    - CreateMaterialObject() currently creates a UMaterial Asset
    
    This is intended to be registered in the ToolsContext ContextObjectStore.
    Static utility functions ::Register() / ::Find() / ::Deregister() can be used to do this in a consistent way.
    
    Several client-provided callbacks can be used to customize functionality (eg in Modeling Mode)
     - GetNewAssetPathNameCallback is called to determine an asset path. This can be used to do
       things like pop up an interactive path-selection dialog, use project-defined paths, etc
     - OnModelingMeshCreated is broadcast for each new created mesh object
     - OnModelingTextureCreated is broadcast for each new created texture object
     - OnModelingMaterialCreated is broadcast for each new created material object
    
    **C++ Source:**
    
    - **Plugin**: MeshModelingToolset
    - **Module**: ModelingComponentsEditorOnly
    - **File**: EditorModelingObjectsCreationAPI.h
    
    """
    ...

class GooglePADFunctionLibrary(BlueprintFunctionLibrary):
    r"""
    Google PADFunction Library
    
    **C++ Source:**
    
    - **Plugin**: GooglePAD
    - **Module**: GooglePAD
    - **File**: GooglePADFunctionLibrary.h
    
    """
    @classmethod
    def show_cellular_data_confirmation(cls) -> GooglePADErrorCode:
        r"""
        X.show_cellular_data_confirmation() -> GooglePADErrorCode
        Show confirmation dialog requesting data download over cellular network
        
        Returns:
            GooglePADErrorCode:
        """
        ...
    @classmethod
    def request_removal(cls, name: str) -> GooglePADErrorCode:
        r"""
        X.request_removal(name) -> GooglePADErrorCode
        Request removal of an asset pack
        
        Args:
            name (str): 
        
        Returns:
            GooglePADErrorCode:
        """
        ...
    @classmethod
    def request_info(cls, asset_packs: Array[str]) -> GooglePADErrorCode:
        r"""
        X.request_info(asset_packs) -> GooglePADErrorCode
        Request information about a set of asset packs
        
        Args:
            asset_packs (Array[str]): 
        
        Returns:
            GooglePADErrorCode:
        """
        ...
    @classmethod
    def request_download(cls, asset_packs: Array[str]) -> GooglePADErrorCode:
        r"""
        X.request_download(asset_packs) -> GooglePADErrorCode
        Request download of a set of asset packs
        
        Args:
            asset_packs (Array[str]): 
        
        Returns:
            GooglePADErrorCode:
        """
        ...
    @classmethod
    def release_download_state(cls, state: int) -> None:
        r"""
        X.release_download_state(state) -> None
        Release download state resources
        
        Args:
            state (int32):
        """
        ...
    @classmethod
    def release_asset_pack_location(cls, location: int) -> None:
        r"""
        X.release_asset_pack_location(location) -> None
        Release location resources
        
        Args:
            location (int32):
        """
        ...
    @classmethod
    def get_total_bytes_to_download(cls, state: int) -> int:
        r"""
        X.get_total_bytes_to_download(state) -> int32
        Get the total number of bytes to download from a download state
        
        Args:
            state (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_storage_method(cls, location: int) -> GooglePADStorageMethod:
        r"""
        X.get_storage_method(location) -> GooglePADStorageMethod
        Get storage method from location
        
        Args:
            location (int32): 
        
        Returns:
            GooglePADStorageMethod:
        """
        ...
    @classmethod
    def get_show_cellular_data_confirmation_status(cls) -> Tuple[GooglePADErrorCode, GooglePADCellularDataConfirmStatus]:
        r"""
        X.get_show_cellular_data_confirmation_status() -> (GooglePADErrorCode, status=GooglePADCellularDataConfirmStatus)
        Get status of cellular confirmation dialog
        
        Returns:
            GooglePADCellularDataConfirmStatus: 
        
            status (GooglePADCellularDataConfirmStatus):
        """
        ...
    @classmethod
    def get_download_status(cls, state: int) -> GooglePADDownloadStatus:
        r"""
        X.get_download_status(state) -> GooglePADDownloadStatus
        Get download status from a download state
        
        Args:
            state (int32): 
        
        Returns:
            GooglePADDownloadStatus:
        """
        ...
    @classmethod
    def get_download_state(cls, name: str) -> Tuple[GooglePADErrorCode, int]:
        r"""
        X.get_download_state(name) -> (GooglePADErrorCode, state=int32)
        Get download state handle of an asset pack (release when done)
        
        Args:
            name (str): 
        
        Returns:
            int32: 
        
            state (int32):
        """
        ...
    @classmethod
    def get_bytes_downloaded(cls, state: int) -> int:
        r"""
        X.get_bytes_downloaded(state) -> int32
        Get the number of bytes downloaded from a download state
        
        Args:
            state (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_assets_path(cls, location: int) -> str:
        r"""
        X.get_assets_path(location) -> str
        Get asset path from from location
        
        Args:
            location (int32): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_asset_pack_location(cls, name: str) -> Tuple[GooglePADErrorCode, int]:
        r"""
        X.get_asset_pack_location(name) -> (GooglePADErrorCode, location=int32)
        Get location handle of requested asset pack (release when done)
        
        Args:
            name (str): 
        
        Returns:
            int32: 
        
            location (int32):
        """
        ...
    @classmethod
    def cancel_download(cls, asset_packs: Array[str]) -> GooglePADErrorCode:
        r"""
        X.cancel_download(asset_packs) -> GooglePADErrorCode
        Cancel download of a set of asset packs
        
        Args:
            asset_packs (Array[str]): 
        
        Returns:
            GooglePADErrorCode:
        """
        ...

class MobileInstalledContent(Object):
    r"""
    Mobile Installed Content
    
    **C++ Source:**
    
    - **Plugin**: MobilePatchingUtils
    - **Module**: MobilePatchingUtils
    - **File**: MobilePatchingLibrary.h
    
    """
    def mount(self, pak_order: int = 1, mount_point: str = ...) -> bool:
        r"""
        x.mount(pak_order=1, mount_point) -> bool
        Mount installed content
        
        Args:
            pak_order (int32): : Content pak priority
            mount_point (str): : Path to mount the pak at
        
        Returns:
            bool:
        """
        ...
    def get_installed_content_size(self) -> float:
        r"""
        x.get_installed_content_size() -> float
        Get the installed content size in megabytes
        
        Returns:
            float:
        """
        ...
    def get_disk_free_space(self) -> float:
        r"""
        x.get_disk_free_space() -> float
        Get the disk free space in megabytes where content is installed
        
        Returns:
            float:
        """
        ...

class MobilePendingContent(MobileInstalledContent):
    r"""
    Mobile Pending Content
    
    **C++ Source:**
    
    - **Plugin**: MobilePatchingUtils
    - **Module**: MobilePatchingUtils
    - **File**: MobilePatchingLibrary.h
    
    """
    def start_install(self, on_succeeded: OnContentInstallSucceeded, on_failed: OnContentInstallFailed) -> None:
        r"""
        x.start_install(on_succeeded, on_failed) -> None
        Attempt to download and install remote content.
        User can choose to mount installed content into the game.
        
        Args:
            on_succeeded (OnContentInstallSucceeded): 
            on_failed (OnContentInstallFailed):
        """
        ...
    def get_total_downloaded_size(self) -> float:
        r"""
        x.get_total_downloaded_size() -> float
        Get the total downloaded size in megabytes. Valid during installation
        
        Returns:
            float:
        """
        ...
    def get_required_disk_space(self) -> float:
        r"""
        x.get_required_disk_space() -> float
        Get the required disk space in megabytes for this content installation
        
        Returns:
            float:
        """
        ...
    def get_install_progress(self) -> float:
        r"""
        x.get_install_progress() -> float
        Get the current installation progress. Between 0 and 1 for known progress, or less than 0 for unknown progress
        
        Returns:
            float:
        """
        ...
    def get_download_status_text(self) -> Text:
        r"""
        x.get_download_status_text() -> Text
        Get Download Status Text
        
        Returns:
            Text:
        """
        ...
    def get_download_speed(self) -> float:
        r"""
        x.get_download_speed() -> float
        Get the current download speed in megabytes per second. Valid during installation
        
        Returns:
            float:
        """
        ...
    def get_download_size(self) -> float:
        r"""
        x.get_download_size() -> float
        Get the total download size for this content installation
        
        Returns:
            float:
        """
        ...

class MobilePatchingLibrary(BlueprintFunctionLibrary):
    r"""
    Mobile Patching Library
    
    **C++ Source:**
    
    - **Plugin**: MobilePatchingUtils
    - **Module**: MobilePatchingUtils
    - **File**: MobilePatchingLibrary.h
    
    """
    @classmethod
    def request_content(cls, remote_manifest_url: str, cloud_url: str, install_directory: str, on_succeeded: OnRequestContentSucceeded, on_failed: OnRequestContentFailed) -> None:
        r"""
        X.request_content(remote_manifest_url, cloud_url, install_directory, on_succeeded, on_failed) -> None
        Attempt to download manifest file using specified manifest URL.
        On success it will return an object that represents remote content. This object can be queried for additional information, like total content size, download size, etc.
        User can choose to download and install remote content.
        
        Args:
            remote_manifest_url (str): : URL from where manifest file can be downloaded. (http://my-server.com/awesomecontent.manifest)
            cloud_url (str): :  URL from where content chunk data can be downloaded. (http://my-server.com/awesomecontent/clouddir)
            install_directory (str): 
            on_succeeded (OnRequestContentSucceeded): 
            on_failed (OnRequestContentFailed):
        """
        ...
    @classmethod
    def has_active_wi_fi_connection(cls) -> bool:
        r"""
        X.has_active_wi_fi_connection() -> bool
        Whether WiFi connection is currently available
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_supported_platform_names(cls) -> Array[str]:
        r"""
        X.get_supported_platform_names() -> Array[str]
        Get the list of supported platform names on this device. Example: Android_ETC2, Android_ASTC
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def get_installed_content(cls, install_directory: str) -> MobileInstalledContent:
        r"""
        X.get_installed_content(install_directory) -> MobileInstalledContent
        Get the installed content. Will return non-null object if there is an installed content at specified directory
        User can choose to mount installed content into the game
        
        Args:
            install_directory (str): 
        
        Returns:
            MobileInstalledContent:
        """
        ...
    @classmethod
    def get_active_device_profile_name(cls) -> str:
        r"""
        X.get_active_device_profile_name() -> str
        Get the name of currently selected device profile name
        
        Returns:
            str:
        """
        ...

class AudioImpulseResponseFactory(Factory):
    r"""
    Audio Impulse Response Factory
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: SynthesisEditor
    - **File**: AudioImpulseResponseAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ModularSynthPresetBankFactory(Factory):
    r"""
    Modular Synth Preset Bank Factory
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: SynthesisEditor
    - **File**: EpicSynth1PresetBank.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MonoWaveTableSynthPresetFactory(Factory):
    r"""
    Mono Wave Table Synth Preset Factory
    
    **C++ Source:**
    
    - **Plugin**: Synthesis
    - **Module**: SynthesisEditor
    - **File**: MonoWaveTablePresetBank.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class VariantManagerFactoryNew(Factory):
    r"""
    Variant Manager Factory New
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContentEditor
    - **File**: VariantManagerFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class VariantManagerTestActor(Actor):
    r"""
    Variant Manager Test Actor
    
    **C++ Source:**
    
    - **Plugin**: VariantManagerContent
    - **Module**: VariantManagerContentEditor
    - **File**: VariantManagerTestActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``captured_bool_property`` (bool):  [Read-Write] Captured boolean property
    - ``captured_byte_property`` (uint8):  [Read-Write] Captured byte property
    - ``captured_color_property`` (Color):  [Read-Write] Captured FColor property
    - ``captured_float_property`` (float):  [Read-Write] Captured float property
    - ``captured_int_point_property`` (IntPoint):  [Read-Write] Captured FIntPoint property
    - ``captured_int_property`` (int32):  [Read-Write] Captured int32 property
    - ``captured_interface_property`` (Interface):  [Read-Write] Captured UInterface property
    - ``captured_linear_color_property`` (LinearColor):  [Read-Write] Captured FLinearColor property
    - ``captured_name_property`` (Name):  [Read-Write] Captured FName property
    - ``captured_object_property`` (Object):  [Read-Write] Captured UObject property
    - ``captured_quat_property`` (Quat):  [Read-Write] Captured FQuat property
    - ``captured_rotator_property`` (Rotator):  [Read-Write] Captured FRotator property
    - ``captured_str_property`` (str):  [Read-Write] Captured FString property
    - ``captured_text_property`` (Text):  [Read-Write] Captured FText property
    - ``captured_u_object_array_property`` (Array[Object]):  [Read-Write] Captured UObject array property
    - ``captured_vector2d_property`` (Vector2D):  [Read-Write] Captured FVector2D property
    - ``captured_vector4_property`` (Vector4):  [Read-Write] Captured FVector4 property
    - ``captured_vector_array_property`` (Array[Vector]):  [Read-Write] Captured FVector array property
    - ``captured_vector_property`` (Vector):  [Read-Write] Captured FVector property
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enum_with_no_default`` (VariantManagerTestEnum):  [Read-Write] Captured byte property
    - ``enum_with_second_default`` (VariantManagerTestEnum):  [Read-Write] Captured byte property
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def enum_with_no_default(self) -> VariantManagerTestEnum:
        r"""
        (VariantManagerTestEnum):  [Read-Write] Captured byte property
        """
        ...
    @enum_with_no_default.setter
    def enum_with_no_default(self, value: VariantManagerTestEnum) -> None:
        ...
    @property
    def enum_with_second_default(self) -> VariantManagerTestEnum:
        r"""
        (VariantManagerTestEnum):  [Read-Write] Captured byte property
        """
        ...
    @enum_with_second_default.setter
    def enum_with_second_default(self, value: VariantManagerTestEnum) -> None:
        ...
    @property
    def captured_byte_property(self) -> int:
        r"""
        (uint8):  [Read-Write] Captured byte property
        """
        ...
    @captured_byte_property.setter
    def captured_byte_property(self, value: int) -> None:
        ...
    @property
    def captured_int_property(self) -> int:
        r"""
        (int32):  [Read-Write] Captured int32 property
        """
        ...
    @captured_int_property.setter
    def captured_int_property(self, value: int) -> None:
        ...
    @property
    def captured_float_property(self) -> float:
        r"""
        (float):  [Read-Write] Captured float property
        """
        ...
    @captured_float_property.setter
    def captured_float_property(self, value: float) -> None:
        ...
    @property
    def captured_bool_property(self) -> bool:
        r"""
        (bool):  [Read-Write] Captured boolean property
        """
        ...
    @captured_bool_property.setter
    def captured_bool_property(self, value: bool) -> None:
        ...
    @property
    def captured_object_property(self) -> Object:
        r"""
        (Object):  [Read-Write] Captured UObject property
        """
        ...
    @captured_object_property.setter
    def captured_object_property(self, value: Object) -> None:
        ...
    @property
    def captured_interface_property(self) -> Interface:
        r"""
        (Interface):  [Read-Write] Captured UInterface property
        """
        ...
    @captured_interface_property.setter
    def captured_interface_property(self, value: Interface) -> None:
        ...
    @property
    def captured_name_property(self) -> Name:
        r"""
        (Name):  [Read-Write] Captured FName property
        """
        ...
    @captured_name_property.setter
    def captured_name_property(self, value: Name) -> None:
        ...
    @property
    def captured_str_property(self) -> str:
        r"""
        (str):  [Read-Write] Captured FString property
        """
        ...
    @captured_str_property.setter
    def captured_str_property(self, value: str) -> None:
        ...
    @property
    def captured_text_property(self) -> Text:
        r"""
        (Text):  [Read-Write] Captured FText property
        """
        ...
    @captured_text_property.setter
    def captured_text_property(self, value: Text) -> None:
        ...
    @property
    def captured_rotator_property(self) -> Rotator:
        r"""
        (Rotator):  [Read-Write] Captured FRotator property
        """
        ...
    @captured_rotator_property.setter
    def captured_rotator_property(self, value: Rotator) -> None:
        ...
    @property
    def captured_color_property(self) -> Color:
        r"""
        (Color):  [Read-Write] Captured FColor property
        """
        ...
    @captured_color_property.setter
    def captured_color_property(self, value: Color) -> None:
        ...
    @property
    def captured_linear_color_property(self) -> LinearColor:
        r"""
        (LinearColor):  [Read-Write] Captured FLinearColor property
        """
        ...
    @captured_linear_color_property.setter
    def captured_linear_color_property(self, value: LinearColor) -> None:
        ...
    @property
    def captured_vector_property(self) -> Vector:
        r"""
        (Vector):  [Read-Write] Captured FVector property
        """
        ...
    @captured_vector_property.setter
    def captured_vector_property(self, value: Vector) -> None:
        ...
    @property
    def captured_quat_property(self) -> Quat:
        r"""
        (Quat):  [Read-Write] Captured FQuat property
        """
        ...
    @captured_quat_property.setter
    def captured_quat_property(self, value: Quat) -> None:
        ...
    @property
    def captured_vector4_property(self) -> Vector4:
        r"""
        (Vector4):  [Read-Write] Captured FVector4 property
        """
        ...
    @captured_vector4_property.setter
    def captured_vector4_property(self, value: Vector4) -> None:
        ...
    @property
    def captured_vector2d_property(self) -> Vector2D:
        r"""
        (Vector2D):  [Read-Write] Captured FVector2D property
        """
        ...
    @captured_vector2d_property.setter
    def captured_vector2d_property(self, value: Vector2D) -> None:
        ...
    @property
    def captured_int_point_property(self) -> IntPoint:
        r"""
        (IntPoint):  [Read-Write] Captured FIntPoint property
        """
        ...
    @captured_int_point_property.setter
    def captured_int_point_property(self, value: IntPoint) -> None:
        ...
    @property
    def captured_u_object_array_property(self) -> Array[Object]:
        r"""
        (Array[Object]):  [Read-Write] Captured UObject array property
        """
        ...
    @captured_u_object_array_property.setter
    def captured_u_object_array_property(self, value: Array[Object]) -> None:
        ...
    @property
    def captured_vector_array_property(self) -> Array[Vector]:
        r"""
        (Array[Vector]):  [Read-Write] Captured FVector array property
        """
        ...
    @captured_vector_array_property.setter
    def captured_vector_array_property(self, value: Array[Vector]) -> None:
        ...

class VariantManagerLibrary(BlueprintFunctionLibrary):
    r"""
    Library of functions that can be used by the Python API to trigger VariantManager operations
    
    **C++ Source:**
    
    - **Plugin**: VariantManager
    - **Module**: VariantManager
    - **File**: VariantManagerBlueprintLibrary.h
    
    """
    @classmethod
    def set_value_vector4(cls, property_: PropertyValue, value: Vector4) -> None:
        r"""
        X.set_value_vector4(property_, value) -> None
        Set Value Vector 4
        
        Args:
            property_ (PropertyValue): 
            value (Vector4):
        """
        ...
    @classmethod
    def set_value_vector2d(cls, property_: PropertyValue, value: Vector2D) -> None:
        r"""
        X.set_value_vector2d(property_, value) -> None
        Set Value Vector 2D
        
        Args:
            property_ (PropertyValue): 
            value (Vector2D):
        """
        ...
    @classmethod
    def set_value_vector(cls, property_: PropertyValue, value: Vector) -> None:
        r"""
        X.set_value_vector(property_, value) -> None
        Set Value Vector
        
        Args:
            property_ (PropertyValue): 
            value (Vector):
        """
        ...
    @classmethod
    def set_value_string(cls, property_: PropertyValue, value: str) -> None:
        r"""
        X.set_value_string(property_, value) -> None
        Set Value String
        
        Args:
            property_ (PropertyValue): 
            value (str):
        """
        ...
    @classmethod
    def set_value_rotator(cls, property_: PropertyValue, value: Rotator) -> None:
        r"""
        X.set_value_rotator(property_, value) -> None
        Set Value Rotator
        
        Args:
            property_ (PropertyValue): 
            value (Rotator):
        """
        ...
    @classmethod
    def set_value_quat(cls, property_: PropertyValue, value: Quat) -> None:
        r"""
        X.set_value_quat(property_, value) -> None
        Set Value Quat
        
        Args:
            property_ (PropertyValue): 
            value (Quat):
        """
        ...
    @classmethod
    def set_value_object(cls, property_: PropertyValue, value: Object) -> None:
        r"""
        X.set_value_object(property_, value) -> None
        Set Value Object
        
        Args:
            property_ (PropertyValue): 
            value (Object):
        """
        ...
    @classmethod
    def set_value_linear_color(cls, property_: PropertyValue, value: LinearColor) -> None:
        r"""
        X.set_value_linear_color(property_, value) -> None
        Set Value Linear Color
        
        Args:
            property_ (PropertyValue): 
            value (LinearColor):
        """
        ...
    @classmethod
    def set_value_int_point(cls, property_: PropertyValue, value: IntPoint) -> None:
        r"""
        X.set_value_int_point(property_, value) -> None
        Set Value Int Point
        
        Args:
            property_ (PropertyValue): 
            value (IntPoint):
        """
        ...
    @classmethod
    def set_value_int(cls, property_: PropertyValue, value: int) -> None:
        r"""
        X.set_value_int(property_, value) -> None
        Set Value Int
        
        Args:
            property_ (PropertyValue): 
            value (int32):
        """
        ...
    @classmethod
    def set_value_float(cls, property_: PropertyValue, value: float) -> None:
        r"""
        X.set_value_float(property_, value) -> None
        Set Value Float
        
        Args:
            property_ (PropertyValue): 
            value (float):
        """
        ...
    @classmethod
    def set_value_color(cls, property_: PropertyValue, value: Color) -> None:
        r"""
        X.set_value_color(property_, value) -> None
        Set Value Color
        
        Args:
            property_ (PropertyValue): 
            value (Color):
        """
        ...
    @classmethod
    def set_value_bool(cls, property_: PropertyValue, value: bool) -> None:
        r"""
        X.set_value_bool(property_, value) -> None
        Set Value Bool
        
        Args:
            property_ (PropertyValue): 
            value (bool):
        """
        ...
    @classmethod
    def set_dependency(cls, variant: Variant, index: int, dependency: VariantDependency) -> VariantDependency:
        r"""
        X.set_dependency(variant, index, dependency) -> VariantDependency
        Set Dependency
        
        Args:
            variant (Variant): 
            index (int32): 
            dependency (VariantDependency): 
        
        Returns:
            VariantDependency: 
        
            dependency (VariantDependency):
        """
        ...
    @classmethod
    def remove_variant_set_by_name(cls, level_variant_sets: LevelVariantSets, variant_set_name: str) -> None:
        r"""
        X.remove_variant_set_by_name(level_variant_sets, variant_set_name) -> None
        Looks for a variant set with VariantSetName within LevelVariantSets and removes it, if it exists
        
        Args:
            level_variant_sets (LevelVariantSets): 
            variant_set_name (str):
        """
        ...
    @classmethod
    def remove_variant_set(cls, level_variant_sets: LevelVariantSets, variant_set: VariantSet) -> None:
        r"""
        X.remove_variant_set(level_variant_sets, variant_set) -> None
        Removes VariantSet from LevelVariantSets, if that is its parent
        
        Args:
            level_variant_sets (LevelVariantSets): 
            variant_set (VariantSet):
        """
        ...
    @classmethod
    def remove_variant_by_name(cls, variant_set: VariantSet, variant_name: str) -> None:
        r"""
        X.remove_variant_by_name(variant_set, variant_name) -> None
        Looks for a variant with VariantName within VariantSet and removes it, if it exists
        
        Args:
            variant_set (VariantSet): 
            variant_name (str):
        """
        ...
    @classmethod
    def remove_variant(cls, variant_set: VariantSet, variant: Variant) -> None:
        r"""
        X.remove_variant(variant_set, variant) -> None
        Removes Variant from VariantSet, if that is its parent
        
        Args:
            variant_set (VariantSet): 
            variant (Variant):
        """
        ...
    @classmethod
    def remove_captured_property_by_name(cls, variant: Variant, actor: Actor, property_path: str) -> None:
        r"""
        X.remove_captured_property_by_name(variant, actor, property_path) -> None
        Removes property capture with PropertyPath from Actor's binding within Variant, if it exists
        
        Args:
            variant (Variant): 
            actor (Actor): 
            property_path (str):
        """
        ...
    @classmethod
    def remove_captured_property(cls, variant: Variant, actor: Actor, property_: PropertyValue) -> None:
        r"""
        X.remove_captured_property(variant, actor, property_) -> None
        Removes a property capture from an actor binding within Variant, if it exists
        
        Args:
            variant (Variant): 
            actor (Actor): 
            property_ (PropertyValue):
        """
        ...
    @classmethod
    def remove_actor_binding_by_name(cls, variant: Variant, actor_name: str) -> None:
        r"""
        X.remove_actor_binding_by_name(variant, actor_name) -> None
        Looks for an actor binding to an actor with ActorLabel within Variant and removes it, if it exists
        
        Args:
            variant (Variant): 
            actor_name (str):
        """
        ...
    @classmethod
    def remove_actor_binding(cls, variant: Variant, actor: Actor) -> None:
        r"""
        X.remove_actor_binding(variant, actor) -> None
        Removes an actor binding to Actor from Variant, if it exists
        
        Args:
            variant (Variant): 
            actor (Actor):
        """
        ...
    @classmethod
    def record(cls, prop_val: PropertyValue) -> None:
        r"""
        X.record(prop_val) -> None
        Records new data for PropVal from the actor from which it was captured
        
        Args:
            prop_val (PropertyValue):
        """
        ...
    @classmethod
    def get_value_vector4(cls, property_: PropertyValue) -> Vector4:
        r"""
        X.get_value_vector4(property_) -> Vector4
        Get Value Vector 4
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            Vector4:
        """
        ...
    @classmethod
    def get_value_vector2d(cls, property_: PropertyValue) -> Vector2D:
        r"""
        X.get_value_vector2d(property_) -> Vector2D
        Get Value Vector 2D
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            Vector2D:
        """
        ...
    @classmethod
    def get_value_vector(cls, property_: PropertyValue) -> Vector:
        r"""
        X.get_value_vector(property_) -> Vector
        Get Value Vector
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            Vector:
        """
        ...
    @classmethod
    def get_value_string(cls, property_: PropertyValue) -> str:
        r"""
        X.get_value_string(property_) -> str
        Get Value String
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_value_rotator(cls, property_: PropertyValue) -> Rotator:
        r"""
        X.get_value_rotator(property_) -> Rotator
        Get Value Rotator
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            Rotator:
        """
        ...
    @classmethod
    def get_value_quat(cls, property_: PropertyValue) -> Quat:
        r"""
        X.get_value_quat(property_) -> Quat
        Get Value Quat
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            Quat:
        """
        ...
    @classmethod
    def get_value_object(cls, property_: PropertyValue) -> Object:
        r"""
        X.get_value_object(property_) -> Object
        Get Value Object
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            Object:
        """
        ...
    @classmethod
    def get_value_linear_color(cls, property_: PropertyValue) -> LinearColor:
        r"""
        X.get_value_linear_color(property_) -> LinearColor
        Get Value Linear Color
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def get_value_int_point(cls, property_: PropertyValue) -> IntPoint:
        r"""
        X.get_value_int_point(property_) -> IntPoint
        Get Value Int Point
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            IntPoint:
        """
        ...
    @classmethod
    def get_value_int(cls, property_: PropertyValue) -> int:
        r"""
        X.get_value_int(property_) -> int32
        Get Value Int
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_value_float(cls, property_: PropertyValue) -> float:
        r"""
        X.get_value_float(property_) -> float
        Get Value Float
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_value_color(cls, property_: PropertyValue) -> Color:
        r"""
        X.get_value_color(property_) -> Color
        Get Value Color
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            Color:
        """
        ...
    @classmethod
    def get_value_bool(cls, property_: PropertyValue) -> bool:
        r"""
        X.get_value_bool(property_) -> bool
        Get Value Bool
        
        Args:
            property_ (PropertyValue): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_property_type_string(cls, prop_val: PropertyValue) -> str:
        r"""
        X.get_property_type_string(prop_val) -> str
        This allows the scripting language to get the type of the C++ property its dealing with
        
        Args:
            prop_val (PropertyValue): 
        
        Returns:
            str:
        """
        ...
    @classmethod
    def get_captured_properties(cls, variant: Variant, actor: Actor) -> Array[PropertyValue]:
        r"""
        X.get_captured_properties(variant, actor) -> Array[PropertyValue]
        Returns which properties have been captured for this actor in Variant
        
        Args:
            variant (Variant): 
            actor (Actor): 
        
        Returns:
            Array[PropertyValue]:
        """
        ...
    @classmethod
    def get_capturable_properties(cls, actor_or_class: Object) -> Array[str]:
        r"""
        X.get_capturable_properties(actor_or_class) -> Array[str]
        Returns a property path for all the properties we can capture for an actor. Will also
        handle receiving the actor's class instead.
        
        Args:
            actor_or_class (Object): 
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def delete_dependency(cls, variant: Variant, index: int) -> None:
        r"""
        X.delete_dependency(variant, index) -> None
        Delete Dependency
        
        Args:
            variant (Variant): 
            index (int32):
        """
        ...
    @classmethod
    def create_level_variant_sets_asset(cls, asset_name: str, asset_path: str) -> LevelVariantSets:
        r"""
        X.create_level_variant_sets_asset(asset_name, asset_path) -> LevelVariantSets
        Creates a new LevelVariantSetsAsset named AssetName (e.g. 'MyLevelVariantSets') in the content path AssetPath (e.g. '/Game')
        
        Args:
            asset_name (str): 
            asset_path (str): 
        
        Returns:
            LevelVariantSets:
        """
        ...
    @classmethod
    def create_level_variant_sets_actor(cls, level_variant_sets_asset: LevelVariantSets) -> LevelVariantSetsActor:
        r"""
        X.create_level_variant_sets_actor(level_variant_sets_asset) -> LevelVariantSetsActor
        Creates a new ALevelVariantSetsActor in the current scene and assigns LevelVariantSetsAsset to it
        
        Args:
            level_variant_sets_asset (LevelVariantSets): 
        
        Returns:
            LevelVariantSetsActor:
        """
        ...
    @classmethod
    def capture_property(cls, variant: Variant, actor: Actor, property_path: str) -> PropertyValue:
        r"""
        X.capture_property(variant, actor, property_path) -> PropertyValue
        Finds the actor binding to Actor within Variant and tries capturing a property with PropertyPath
        Returns the captured UPropertyValue if succeeded or nullptr if it failed.
        
        Args:
            variant (Variant): 
            actor (Actor): 
            property_path (str): 
        
        Returns:
            PropertyValue:
        """
        ...
    @classmethod
    def apply(cls, prop_val: PropertyValue) -> None:
        r"""
        X.apply(prop_val) -> None
        Applies the recorded data from PropVal to the actor from which it was captured
        
        Args:
            prop_val (PropertyValue):
        """
        ...
    @classmethod
    def add_variant_set(cls, level_variant_sets: LevelVariantSets, variant_set: VariantSet) -> None:
        r"""
        X.add_variant_set(level_variant_sets, variant_set) -> None
        Adds VariantSet to the LevelVariantSets' list of VariantSets
        
        Args:
            level_variant_sets (LevelVariantSets): 
            variant_set (VariantSet):
        """
        ...
    @classmethod
    def add_variant(cls, variant_set: VariantSet, variant: Variant) -> None:
        r"""
        X.add_variant(variant_set, variant) -> None
        Adds Variant to the VariantSet's list of Variants
        
        Args:
            variant_set (VariantSet): 
            variant (Variant):
        """
        ...
    @classmethod
    def add_dependency(cls, variant: Variant, dependency: VariantDependency) -> Tuple[int, VariantDependency]:
        r"""
        X.add_dependency(variant, dependency) -> (int32, dependency=VariantDependency)
        Add Dependency
        
        Args:
            variant (Variant): 
            dependency (VariantDependency): 
        
        Returns:
            VariantDependency: 
        
            dependency (VariantDependency):
        """
        ...
    @classmethod
    def add_actor_binding(cls, variant: Variant, actor: Actor) -> None:
        r"""
        X.add_actor_binding(variant, actor) -> None
        Binds the Actor to the Variant, internally creating a VariantObjectBinding
        
        Args:
            variant (Variant): 
            actor (Actor):
        """
        ...

class InterchangeBlueprintPipelineBaseFactory(Factory):
    r"""
    Interchange Blueprint Pipeline Base Factory
    
    **C++ Source:**
    
    - **Plugin**: InterchangeEditor
    - **Module**: InterchangeEditorPipelines
    - **File**: InterchangePipelineFactories.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``blueprint_type`` (BlueprintType):  [Read-Write] The type of blueprint that will be created
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Write] The parent class of the created blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class InterchangePipelineBaseFactory(Factory):
    r"""
    Interchange Pipeline Base Factory
    
    **C++ Source:**
    
    - **Plugin**: InterchangeEditor
    - **Module**: InterchangeEditorPipelines
    - **File**: InterchangePipelineFactories.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class InterchangePythonPipelineAssetFactory(Factory):
    r"""
    Interchange Python Pipeline Asset Factory
    
    **C++ Source:**
    
    - **Plugin**: InterchangeEditor
    - **Module**: InterchangeEditorPipelines
    - **File**: InterchangePipelineFactories.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class InterchangeGraphInspectorPipeline(InterchangePipelineBase):
    r"""
    This pipeline is the generic pipeline option for all types of meshes. It should be called before specialized mesh pipelines like the generic static mesh or skeletal mesh pipelines.
    All import options that are shared between mesh types should be added here.
    
    UPROPERTY possible meta values:
    meta: ImportOnly - Boolean. The property is used only for import, not for reimport. Cannot be mixed with ReimportOnly.
    meta: ReimportOnly - Boolean. The property is used only for reimport, not for import. Cannot be mixed with ImportOnly.
    meta: MeshType - String. The property is for static mesh or skeletal mesh or both. If not specified, it will apply to all mesh types.
    
    **C++ Source:**
    
    - **Plugin**: InterchangeEditor
    - **Module**: InterchangeEditorPipelines
    - **File**: InterchangeGraphInspectorPipeline.h
    
    """
    ...

class InterchangePipelineConfigurationGeneric(InterchangePipelineConfigurationBase):
    r"""
    Interchange Pipeline Configuration Generic
    
    **C++ Source:**
    
    - **Plugin**: InterchangeEditor
    - **Module**: InterchangeEditorPipelines
    - **File**: InterchangePipelineConfigurationGeneric.h
    
    """
    ...

class InterchangeFilePickerGeneric(InterchangeFilePickerBase):
    r"""
    Interchange File Picker Generic
    
    **C++ Source:**
    
    - **Plugin**: InterchangeEditor
    - **Module**: InterchangeEditorUtilities
    - **File**: InterchangeOpenFileDialog.h
    
    """
    ...

class InterchangeTextureWriter(InterchangeWriterBase):
    r"""
    Interchange Texture Writer
    
    **C++ Source:**
    
    - **Plugin**: Interchange
    - **Module**: InterchangeExport
    - **File**: InterchangeTextureWriter.h
    
    """
    ...

class MovieSceneMediaPlayerPropertySection(MovieSceneSection):
    r"""
    Implements a movie scene section for media playback on a UMediaPlayer.
    
    **C++ Source:**
    
    - **Plugin**: MediaCompositing
    - **Module**: MediaCompositing
    - **File**: MovieSceneMediaPlayerPropertySection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``loop`` (bool):  [Read-Write] Whether to loop this video.
    - ``media_source`` (MediaSource):  [Read-Write] The source to play with this video track.
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    @property
    def media_source(self) -> MediaSource:
        r"""
        (MediaSource):  [Read-Write] The source to play with this video track.
        """
        ...
    @media_source.setter
    def media_source(self, value: MediaSource) -> None:
        ...
    @property
    def loop(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to loop this video.
        """
        ...
    @loop.setter
    def loop(self, value: bool) -> None:
        ...

class MovieSceneMediaPlayerPropertyTrack(MovieScenePropertyTrack):
    r"""
    Movie Scene Media Player Property Track
    
    **C++ Source:**
    
    - **Plugin**: MediaCompositing
    - **Module**: MediaCompositing
    - **File**: MovieSceneMediaPlayerPropertyTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MovieSceneMediaSection(MovieSceneSection):
    r"""
    Implements a movie scene section for media playback.
    
    **C++ Source:**
    
    - **Plugin**: MediaCompositing
    - **Module**: MediaCompositing
    - **File**: MovieSceneMediaSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cache_settings`` (MediaSourceCacheSettings):  [Read-Write] Override the default cache settings. Not used if we have a player proxy as the settings come from the proxy instead.
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``external_media_player`` (MediaPlayer):  [Read-Write] The external media player this track should control.
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``looping`` (bool):  [Read-Write] Should the media player be set to loop? This can be helpful for media formats that can use this information (such as exr sequences) to pre-cache the starting data when nearing the end of playback. Does not cause the media to continue playing after the end of the section is reached.
    - ``media_sound_component`` (MediaSoundComponent):  [Read-Write] The media sound component that receives the track's audio output.
    - ``media_source`` (MediaSource):  [Read-Write] The source to play with this video track if MediaSourceProxy is not available.
    - ``media_source_proxy_binding_id`` (MovieSceneObjectBindingID):  [Read-Write] The object to get the source to play from if you don't want to directly specify a media source.
    - ``media_source_proxy_index`` (int32):  [Read-Write] The index to pass to MediaSourceProxy to get the media source.
    - ``media_texture`` (MediaTexture):  [Read-Write] The media texture that receives the track's video output.
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``start_frame_offset`` (FrameNumber):  [Read-Write] Offset into the source media.
    - ``texture_index`` (int32):  [Read-Write] If using an object like a MediaPlate, then this determines which texture to use for crossfading purposes.
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    - ``use_external_media_player`` (bool):  [Read-Write] If true, this track will control a previously created media player instead of automatically creating one.
    """
    @property
    def media_source(self) -> MediaSource:
        r"""
        (MediaSource):  [Read-Write] The source to play with this video track if MediaSourceProxy is not available.
        """
        ...
    @media_source.setter
    def media_source(self, value: MediaSource) -> None:
        ...
    @property
    def media_source_proxy_index(self) -> int:
        r"""
        (int32):  [Read-Write] The index to pass to MediaSourceProxy to get the media source.
        """
        ...
    @media_source_proxy_index.setter
    def media_source_proxy_index(self, value: int) -> None:
        ...
    @property
    def looping(self) -> bool:
        r"""
        (bool):  [Read-Write] Should the media player be set to loop? This can be helpful for media formats that can use this information (such as exr sequences) to pre-cache the starting data when nearing the end of playback. Does not cause the media to continue playing after the end of the section is reached.
        """
        ...
    @looping.setter
    def looping(self, value: bool) -> None:
        ...
    @property
    def start_frame_offset(self) -> FrameNumber:
        r"""
        (FrameNumber):  [Read-Write] Offset into the source media.
        """
        ...
    @start_frame_offset.setter
    def start_frame_offset(self, value: FrameNumber) -> None:
        ...
    @property
    def media_texture(self) -> MediaTexture:
        r"""
        (MediaTexture):  [Read-Write] The media texture that receives the track's video output.
        """
        ...
    @media_texture.setter
    def media_texture(self, value: MediaTexture) -> None:
        ...
    @property
    def media_sound_component(self) -> MediaSoundComponent:
        r"""
        (MediaSoundComponent):  [Read-Write] The media sound component that receives the track's audio output.
        """
        ...
    @media_sound_component.setter
    def media_sound_component(self, value: MediaSoundComponent) -> None:
        ...
    @property
    def use_external_media_player(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, this track will control a previously created media player instead of automatically creating one.
        """
        ...
    @use_external_media_player.setter
    def use_external_media_player(self, value: bool) -> None:
        ...
    @property
    def external_media_player(self) -> MediaPlayer:
        r"""
        (MediaPlayer):  [Read-Write] The external media player this track should control.
        """
        ...
    @external_media_player.setter
    def external_media_player(self, value: MediaPlayer) -> None:
        ...
    @property
    def cache_settings(self) -> MediaSourceCacheSettings:
        r"""
        (MediaSourceCacheSettings):  [Read-Write] Override the default cache settings. Not used if we have a player proxy as the settings come from the proxy instead.
        """
        ...
    @cache_settings.setter
    def cache_settings(self, value: MediaSourceCacheSettings) -> None:
        ...
    @property
    def texture_index(self) -> int:
        r"""
        (int32):  [Read-Write] If using an object like a MediaPlate, then this determines which texture to use for crossfading purposes.
        """
        ...
    @texture_index.setter
    def texture_index(self, value: int) -> None:
        ...

class MovieSceneMediaTrack(MovieSceneNameableTrack):
    r"""
    Implements a movie scene track for media playback.
    
    **C++ Source:**
    
    - **Plugin**: MediaCompositing
    - **Module**: MediaCompositing
    - **File**: MovieSceneMediaTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class MediaPlate(Actor):
    r"""
    MediaPlate is an actor that can play and show media in the world.
    
    **C++ Source:**
    
    - **Plugin**: MediaPlate
    - **Module**: MediaPlate
    - **File**: MediaPlate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``media_plate_component`` (MediaPlateComponent):  [Read-Only]
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``static_mesh_component`` (StaticMeshComponent):  [Read-Only] Holds the mesh.
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def media_plate_component(self) -> MediaPlateComponent:
        r"""
        (MediaPlateComponent):  [Read-Only]
        """
        ...
    @property
    def static_mesh_component(self) -> StaticMeshComponent:
        r"""
        (StaticMeshComponent):  [Read-Only] Holds the mesh.
        """
        ...

class MediaPlateComponent(ActorComponent):
    r"""
    This is a component for AMediaPlate that can play and show media in the world.
    
    **C++ Source:**
    
    - **Plugin**: MediaPlate
    - **Module**: MediaPlate
    - **File**: MediaPlateComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``adaptive_pole_mip_upscaling`` (bool):  [Read-Write] If true then Media Plate will attempt to load and upscale lower quality mips and display those at the poles (Sphere object only).
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``auto_play`` (bool):  [Read-Write] If set then start playing when this object is active.
    - ``cache_settings`` (MediaSourceCacheSettings):  [Read-Write] Override the default cache settings.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``enable_audio`` (bool):  [Read-Write] If set then enable audio.
    - ``enable_mip_map_upscaling`` (bool):  [Read-Write] If true then enable the use of MipLevelToUpscale as defined below.
    - ``is_aspect_ratio_auto`` (bool):  [Read-Write] If true then set the aspect ratio automatically based on the media.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``is_media_plate_playing`` (bool):  [Read-Write] If true, then we want the media plate to play.
      Note that this could be true, but the player is not actually playing because
      bPlayOnlyWhenVisible = true and the plate is not visible.
    - ``letterboxes`` (Array[StaticMeshComponent]):  [Read-Write] Holds the component for the mesh.
    - ``loop`` (bool):  [Read-Write] If set then loop when we reach the end.
    - ``media_playlist`` (MediaPlaylist):  [Read-Write] What media playlist to play.
    - ``media_texture_settings`` (MediaTextureResourceSettings):  [Read-Write] Exposes Media Texture settings via Media Plate component.
    - ``mip_level_to_upscale`` (int32):  [Read-Write] With exr playback, upscale into lower quality mips from this specified level. All levels including and above the specified value will be fully read.
    - ``mip_map_bias`` (float):  [Read-Write] Media texture mip map bias shared between the (image sequence) loader and the media texture sampler.
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``play_on_open`` (bool):  [Read-Write] If set then play when opening the media.
    - ``play_only_when_visible`` (bool):  [Read-Write] If true then only allow playback when the media plate is visible.
    - ``playlist_index`` (int32):  [Read-Write] The current index of the source in the play list being played.
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``sound_component`` (MediaSoundComponent):  [Read-Write] Holds the component to play sound.
    - ``start_time`` (float):  [Read-Write] What time to start playing from (in seconds).
    - ``static_mesh_component`` (StaticMeshComponent):  [Read-Write] Holds the component for the mesh.
    - ``visible_mips_tiles_calculations`` (MediaTextureVisibleMipsTiles):  [Read-Write] Visible mips and tiles calculation mode for the supported mesh types in MediaPlate. (Player restart on change.)
    """
    @property
    def play_on_open(self) -> bool:
        r"""
        (bool):  [Read-Write] If set then play when opening the media.
        """
        ...
    @play_on_open.setter
    def play_on_open(self, value: bool) -> None:
        ...
    @property
    def start_time(self) -> float:
        r"""
        (float):  [Read-Write] What time to start playing from (in seconds).
        """
        ...
    @start_time.setter
    def start_time(self, value: float) -> None:
        ...
    @property
    def media_playlist(self) -> MediaPlaylist:
        r"""
        (MediaPlaylist):  [Read-Write] What media playlist to play.
        """
        ...
    @media_playlist.setter
    def media_playlist(self, value: MediaPlaylist) -> None:
        ...
    @property
    def playlist_index(self) -> int:
        r"""
        (int32):  [Read-Write] The current index of the source in the play list being played.
        """
        ...
    @playlist_index.setter
    def playlist_index(self, value: int) -> None:
        ...
    @property
    def is_media_plate_playing(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, then we want the media plate to play.
        Note that this could be true, but the player is not actually playing because
        bPlayOnlyWhenVisible = true and the plate is not visible.
        """
        ...
    @property
    def play_only_when_visible(self) -> bool:
        r"""
        (bool):  [Read-Only] If true then only allow playback when the media plate is visible.
        """
        ...
    @property
    def loop(self) -> bool:
        r"""
        (bool):  [Read-Write] If set then loop when we reach the end.
        """
        ...
    @loop.setter
    def loop(self, value: bool) -> None:
        ...
    @property
    def is_aspect_ratio_auto(self) -> bool:
        r"""
        (bool):  [Read-Write] If true then set the aspect ratio automatically based on the media.
        """
        ...
    @is_aspect_ratio_auto.setter
    def is_aspect_ratio_auto(self, value: bool) -> None:
        ...
    def set_play_only_when_visible(self, play_only_when_visible: bool) -> None:
        r"""
        x.set_play_only_when_visible(play_only_when_visible) -> None
        Call this to set bPlayOnlyWhenVisible.
        
        Args:
            play_only_when_visible (bool):
        """
        ...
    def set_mesh_range(self, mesh_range: Vector2D) -> None:
        r"""
        x.set_mesh_range(mesh_range) -> None
        Set the arc size in degrees used for visible mips and tiles calculations, specific to the sphere.
        
        Args:
            mesh_range (Vector2D):
        """
        ...
    def set_letterbox_aspect_ratio(self, aspect_ratio: float) -> None:
        r"""
        x.set_letterbox_aspect_ratio(aspect_ratio) -> None
        Call this to set the aspect ratio of the screen.
        
        Args:
            aspect_ratio (float):
        """
        ...
    def set_is_aspect_ratio_auto(self, is_aspect_ratio_auto: bool) -> None:
        r"""
        x.set_is_aspect_ratio_auto(is_aspect_ratio_auto) -> None
        Sets whether automatic aspect ratio is enabled.
        
        Args:
            is_aspect_ratio_auto (bool):
        """
        ...
    def seek(self, time: Timespan) -> bool:
        r"""
        x.seek(time) -> bool
        Call this to seek to the specified playback time.
        
        Args:
            time (Timespan): Time to seek to.
        
        Returns:
            bool: True on success, false otherwise.
        """
        ...
    def rewind(self) -> bool:
        r"""
        x.rewind() -> bool
        Rewinds the media to the beginning.
        
        This is the same as seeking to zero time.
        
        Returns:
            bool: True if rewinding, false otherwise.
        """
        ...
    def play(self) -> None:
        r"""
        x.play() -> None
        Call this to start playing.
        Open must be called before this.
        """
        ...
    def pause(self) -> None:
        r"""
        x.pause() -> None
        Call this to pause playback.
        Play can be called to resume playback.
        """
        ...
    def open(self) -> None:
        r"""
        x.open() -> None
        Call this to open the media.
        """
        ...
    def get_mesh_range(self) -> Vector2D:
        r"""
        x.get_mesh_range() -> Vector2D
        Return the arc size in degrees used for visible mips and tiles calculations, specific to the sphere.
        
        Returns:
            Vector2D:
        """
        ...
    def get_media_texture(self, index: int = 0) -> MediaTexture:
        r"""
        x.get_media_texture(index=0) -> MediaTexture
        Call this get our media texture.
        
        Args:
            index (int32): 
        
        Returns:
            MediaTexture:
        """
        ...
    def get_media_player(self) -> MediaPlayer:
        r"""
        x.get_media_player() -> MediaPlayer
        Call this get our media player.
        
        Returns:
            MediaPlayer:
        """
        ...
    def get_letterbox_aspect_ratio(self) -> float:
        r"""
        x.get_letterbox_aspect_ratio() -> float
        Call this to get the aspect ratio of the screen.
        
        Returns:
            float:
        """
        ...
    def get_is_aspect_ratio_auto(self) -> bool:
        r"""
        x.get_is_aspect_ratio_auto() -> bool
        Gets whether automatic aspect ratio is enabled.
        
        Returns:
            bool:
        """
        ...
    def close(self) -> None:
        r"""
        x.close() -> None
        Call this to close the media.
        """
        ...

class MovieSceneScriptingKey(Object):
    r"""
    Movie Scene Scripting Key
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingChannel.h
    
    """
    ...

class MovieSceneScriptingActorReferenceKey(MovieSceneScriptingKey):
    r"""
    Exposes a Sequencer Actor Reference type key to Python/Blueprints.
    Stores a reference to the data so changes to this class are forwarded onto the underlying data structures.
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingActorReference.h
    
    """
    def set_value(self, new_value: MovieSceneObjectBindingID) -> None:
        r"""
        x.set_value(new_value) -> None
        Sets the value for this key, reflecting it in the owning channel.
        
        Args:
            new_value (MovieSceneObjectBindingID): The new object binding for this key.
        """
        ...
    def set_time(self, new_frame_number: FrameNumber, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        x.set_time(new_frame_number, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Sets the time for this key in the owning channel. Will replace any key that already exists at that frame number in this channel.
        
        Args:
            new_frame_number (FrameNumber): What frame should this key be moved to? This should be in the time unit specified by TimeUnit.
            sub_frame (float): If using Display Rate time, what is the sub-frame this should go to? Clamped [0-1), and ignored with when TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Should the NewFrameNumber be interpreted as Display Rate frames or in Tick Resolution?
        """
        ...
    def get_value(self) -> MovieSceneObjectBindingID:
        r"""
        x.get_value() -> MovieSceneObjectBindingID
        Gets the value for this key from the owning channel.
        
        Returns:
            MovieSceneObjectBindingID: The object binding for this key.
        """
        ...
    def get_time(self, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime:
        r"""
        x.get_time(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime
        Gets the time for this key from the owning channel.
        
        Args:
            time_unit (MovieSceneTimeUnit): Should the time be returned in Display Rate frames (possibly with a sub-frame value) or in Tick Resolution with no sub-frame values?
        
        Returns:
            FrameTime: The time of this key which combines both the frame number and the sub-frame it is on. Sub-frame will be zero if you request Tick Resolution.
        """
        ...

class MovieSceneScriptingChannel(Object):
    r"""
    Movie Scene Scripting Channel
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingChannel.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_name`` (Name):  [Read-Write]
    """
    @property
    def channel_name(self) -> Name:
        r"""
        (Name):  [Read-Only]
        """
        ...

class MovieSceneScriptingActorReferenceChannel(MovieSceneScriptingChannel):
    r"""
    Movie Scene Scripting Actor Reference Channel
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingActorReference.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_name`` (Name):  [Read-Write]
    """
    def set_default(self, default_value: MovieSceneObjectBindingID) -> None:
        r"""
        x.set_default(default_value) -> None
        Set this channel's default value that should be used when no keys are present.
        Sets bHasDefaultValue to true automatically.
        
        Args:
            default_value (MovieSceneObjectBindingID):
        """
        ...
    def remove_key(self, key: MovieSceneScriptingKey) -> None:
        r"""
        x.remove_key(key) -> None
        Removes the specified key. Does nothing if the key is not specified or the key belongs to another channel.
        
        Args:
            key (MovieSceneScriptingKey):
        """
        ...
    def remove_default(self) -> None:
        r"""
        x.remove_default() -> None
        Remove this channel's default value causing the channel to have no effect where no keys are present
        """
        ...
    def has_default(self) -> bool:
        r"""
        x.has_default() -> bool
        
        
        Returns:
            bool: Does this channel have a default value set?
        """
        ...
    def get_keys_by_index(self, indices: Array[int]) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys_by_index(indices) -> Array[MovieSceneScriptingKey]
        Gets the keys in this channel specified by the specific index
        Indices: The indices from which to get the keys from
        
        Args:
            indices (Array[int32]): 
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingKey's contained by this channel. Returns all keys specified by the indices, even if out of range.
        """
        ...
    def get_keys(self) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys() -> Array[MovieSceneScriptingKey]
        Gets all of the keys in this channel.
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingActorReferenceKeys contained by this channel. Returns all keys even if clipped by the owning section's boundaries or outside of the current sequence play range.
        """
        ...
    def get_default(self) -> MovieSceneObjectBindingID:
        r"""
        x.get_default() -> MovieSceneObjectBindingID
        Get this channel's default value that will be used when no keys are present. Only a valid
        value when HasDefault() returns true.
        
        Returns:
            MovieSceneObjectBindingID:
        """
        ...
    def add_key(self, time: FrameNumber, new_value: MovieSceneObjectBindingID, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingActorReferenceKey:
        r"""
        x.add_key(time, new_value, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingActorReferenceKey
        Add a key to this channel. This initializes a new key and returns a reference to it.
        
        Args:
            time (FrameNumber): The frame this key should go on. Respects TimeUnit to determine if it is a display rate frame or a tick resolution frame.
            new_value (MovieSceneObjectBindingID): The value that this key should be created with.
            sub_frame (float): Optional [0-1) clamped sub-frame to put this key on. Ignored if TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Is the specified InTime in Display Rate frames or Tick Resolution.
        
        Returns:
            MovieSceneScriptingActorReferenceKey: The key that was created with the specified values at the specified time.
        """
        ...

class MovieSceneScriptingBoolKey(MovieSceneScriptingKey):
    r"""
    Exposes a Sequencer bool type key to Python/Blueprints.
    Stores a reference to the data so changes to this class are forwarded onto the underlying data structures.
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingBool.h
    
    """
    def set_value(self, new_value: bool) -> None:
        r"""
        x.set_value(new_value) -> None
        Sets the value for this key, reflecting it in the owning channel.
        
        Args:
            new_value (bool): The new value for this key.
        """
        ...
    def set_time(self, new_frame_number: FrameNumber, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        x.set_time(new_frame_number, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Sets the time for this key in the owning channel. Will replace any key that already exists at that frame number in this channel.
        
        Args:
            new_frame_number (FrameNumber): What frame should this key be moved to? This should be in the time unit specified by TimeUnit.
            sub_frame (float): If using Display Rate time, what is the sub-frame this should go to? Clamped [0-1), and ignored with when TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Should the NewFrameNumber be interpreted as Display Rate frames or in Tick Resolution?
        """
        ...
    def get_value(self) -> bool:
        r"""
        x.get_value() -> bool
        Gets the value for this key from the owning channel.
        
        Returns:
            bool: The value for this key.
        """
        ...
    def get_time(self, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime:
        r"""
        x.get_time(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime
        Gets the time for this key from the owning channel.
        
        Args:
            time_unit (MovieSceneTimeUnit): Should the time be returned in Display Rate frames (possibly with a sub-frame value) or in Tick Resolution with no sub-frame values?
        
        Returns:
            FrameTime: The time of this key which combines both the frame number and the sub-frame it is on. Sub-frame will be zero if you request Tick Resolution.
        """
        ...

class MovieSceneScriptingBoolChannel(MovieSceneScriptingChannel):
    r"""
    Movie Scene Scripting Bool Channel
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingBool.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_name`` (Name):  [Read-Write]
    """
    def set_default(self, default_value: bool) -> None:
        r"""
        x.set_default(default_value) -> None
        Set this channel's default value that should be used when no keys are present.
        Sets bHasDefaultValue to true automatically.
        
        Args:
            default_value (bool):
        """
        ...
    def remove_key(self, key: MovieSceneScriptingKey) -> None:
        r"""
        x.remove_key(key) -> None
        Removes the specified key. Does nothing if the key is not specified or the key belongs to another channel.
        
        Args:
            key (MovieSceneScriptingKey):
        """
        ...
    def remove_default(self) -> None:
        r"""
        x.remove_default() -> None
        Remove this channel's default value causing the channel to have no effect where no keys are present
        """
        ...
    def has_default(self) -> bool:
        r"""
        x.has_default() -> bool
        
        
        Returns:
            bool: Does this channel have a default value set?
        """
        ...
    def get_num_keys(self) -> int:
        r"""
        x.get_num_keys() -> int32
        Returns number of keys in this channel.
        
        Returns:
            int32:
        """
        ...
    def get_keys_by_index(self, indices: Array[int]) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys_by_index(indices) -> Array[MovieSceneScriptingKey]
        Gets the keys in this channel specified by the specific index
        Indices: The indices from which to get the keys from
        
        Args:
            indices (Array[int32]): 
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingKey's contained by this channel. Returns all keys specified by the indices, even if out of range.
        """
        ...
    def get_keys(self) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys() -> Array[MovieSceneScriptingKey]
        Gets all of the keys in this channel.
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingBoolKey's contained by this channel. Returns all keys even if clipped by the owning section's boundaries or outside of the current sequence play range.
        """
        ...
    def get_default(self) -> bool:
        r"""
        x.get_default() -> bool
        Get this channel's default value that will be used when no keys are present. Only a valid
        value when HasDefault() returns true.
        
        Returns:
            bool:
        """
        ...
    def evaluate_keys(self, range: SequencerScriptingRange, frame_rate: FrameRate) -> Array[bool]:
        r"""
        x.evaluate_keys(range, frame_rate) -> Array[bool]
        Gets baked keys in this channel.
        
        Args:
            range (SequencerScriptingRange): 
            frame_rate (FrameRate): 
        
        Returns:
            Array[bool]: An array of values contained by this channel. Returns baked keys in the specified range.
        """
        ...
    def compute_effective_range(self) -> SequencerScriptingRange:
        r"""
        x.compute_effective_range() -> SequencerScriptingRange
        Compute the effective range of this channel, for example, the extents of its key times
        
        Returns:
            SequencerScriptingRange: A range that represents the greatest range of times occupied by this channel, in the sequence's frame resolution
        """
        ...
    def add_key(self, time: FrameNumber, new_value: bool, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingBoolKey:
        r"""
        x.add_key(time, new_value, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingBoolKey
        Add a key to this channel. This initializes a new key and returns a reference to it.
        
        Args:
            time (FrameNumber): The frame this key should go on. Respects TimeUnit to determine if it is a display rate frame or a tick resolution frame.
            new_value (bool): The value that this key should be created with.
            sub_frame (float): Optional [0-1) clamped sub-frame to put this key on. Ignored if TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Is the specified InTime in Display Rate frames or Tick Resolution.
        
        Returns:
            MovieSceneScriptingBoolKey: The key that was created with the specified values at the specified time.
        """
        ...

class MovieSceneScriptingByteKey(MovieSceneScriptingKey):
    r"""
    Exposes a Sequencer byte/enum type key to Python/Blueprints.
    Stores a reference to the data so changes to this class are forwarded onto the underlying data structures.
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingByte.h
    
    """
    def set_value(self, new_value: int) -> None:
        r"""
        x.set_value(new_value) -> None
        Sets the value for this key, reflecting it in the owning channel.
        
        Args:
            new_value (uint8): The new value for this key.
        """
        ...
    def set_time(self, new_frame_number: FrameNumber, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        x.set_time(new_frame_number, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Sets the time for this key in the owning channel. Will replace any key that already exists at that frame number in this channel.
        
        Args:
            new_frame_number (FrameNumber): What frame should this key be moved to? This should be in the time unit specified by TimeUnit.
            sub_frame (float): If using Display Rate time, what is the sub-frame this should go to? Clamped [0-1), and ignored with when TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Should the NewFrameNumber be interpreted as Display Rate frames or in Tick Resolution?
        """
        ...
    def get_value(self) -> int:
        r"""
        x.get_value() -> uint8
        Gets the value for this key from the owning channel.
        
        Returns:
            uint8: The value for this key.
        """
        ...
    def get_time(self, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime:
        r"""
        x.get_time(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime
        Gets the time for this key from the owning channel.
        
        Args:
            time_unit (MovieSceneTimeUnit): Should the time be returned in Display Rate frames (possibly with a sub-frame value) or in Tick Resolution with no sub-frame values?
        
        Returns:
            FrameTime: The time of this key which combines both the frame number and the sub-frame it is on. Sub-frame will be zero if you request Tick Resolution.
        """
        ...

class MovieSceneScriptingByteChannel(MovieSceneScriptingChannel):
    r"""
    Movie Scene Scripting Byte Channel
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingByte.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_name`` (Name):  [Read-Write]
    """
    def set_default(self, default_value: int) -> None:
        r"""
        x.set_default(default_value) -> None
        Set this channel's default value that should be used when no keys are present.
        Sets bHasDefaultValue to true automatically.
        
        Args:
            default_value (uint8):
        """
        ...
    def remove_key(self, key: MovieSceneScriptingKey) -> None:
        r"""
        x.remove_key(key) -> None
        Removes the specified key. Does nothing if the key is not specified or the key belongs to another channel.
        
        Args:
            key (MovieSceneScriptingKey):
        """
        ...
    def remove_default(self) -> None:
        r"""
        x.remove_default() -> None
        Remove this channel's default value causing the channel to have no effect where no keys are present
        """
        ...
    def has_default(self) -> bool:
        r"""
        x.has_default() -> bool
        
        
        Returns:
            bool: Does this channel have a default value set?
        """
        ...
    def get_keys_by_index(self, indices: Array[int]) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys_by_index(indices) -> Array[MovieSceneScriptingKey]
        Gets the keys in this channel specified by the specific index
        Indices: The indices from which to get the keys from
        
        Args:
            indices (Array[int32]): 
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingKey's contained by this channel. Returns all keys specified by the indices, even if out of range.
        """
        ...
    def get_keys(self) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys() -> Array[MovieSceneScriptingKey]
        Gets all of the keys in this channel.
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingByteKey's contained by this channel. Returns all keys even if clipped by the owning section's boundaries or outside of the current sequence play range.
        """
        ...
    def get_default(self) -> int:
        r"""
        x.get_default() -> uint8
        Get this channel's default value that will be used when no keys are present. Only a valid
        value when HasDefault() returns true.
        
        Returns:
            uint8:
        """
        ...
    def add_key(self, time: FrameNumber, new_value: int, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, interpolation: MovieSceneKeyInterpolation = MovieSceneKeyInterpolation.AUTO) -> MovieSceneScriptingByteKey:
        r"""
        x.add_key(time, new_value, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, interpolation=MovieSceneKeyInterpolation.AUTO) -> MovieSceneScriptingByteKey
        Add a key to this channel. This initializes a new key and returns a reference to it.
        
        Args:
            time (FrameNumber): The frame this key should go on. Respects TimeUnit to determine if it is a display rate frame or a tick resolution frame.
            new_value (uint8): The value that this key should be created with.
            sub_frame (float): Optional [0-1) clamped sub-frame to put this key on. Ignored if TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Is the specified InTime in Display Rate frames or Tick Resolution.
            interpolation (MovieSceneKeyInterpolation): Interpolation method the key should use.
        
        Returns:
            MovieSceneScriptingByteKey: The key that was created with the specified values at the specified time.
        """
        ...

class MovieSceneScriptingDoubleKey(MovieSceneScriptingKey):
    r"""
    Exposes a Sequencer double type key to Python/Blueprints.
    Stores a reference to the data so changes to this class are forwarded onto the underlying data structures.
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingDouble.h
    
    """
    def set_value(self, new_value: float) -> None:
        r"""
        x.set_value(new_value) -> None
        Sets the value for this key, reflecting it in the owning channel.
        
        Args:
            new_value (double): The new double value for this key.
        """
        ...
    def set_time(self, new_frame_number: FrameNumber, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        x.set_time(new_frame_number, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Sets the time for this key in the owning channel. Will replace any key that already exists at that frame number in this channel.
        
        Args:
            new_frame_number (FrameNumber): What frame should this key be moved to? This should be in the time unit specified by TimeUnit.
            sub_frame (float): If using Display Rate time, what is the sub-frame this should go to? Clamped [0-1), and ignored with when TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Should the NewFrameNumber be interpreted as Display Rate frames or in Tick Resolution?
        """
        ...
    def set_tangent_weight_mode(self, new_value: RichCurveTangentWeightMode) -> None:
        r"""
        x.set_tangent_weight_mode(new_value) -> None
        If Interpolation Mode is RCIM_Cubic, the tangent weight mode at this key.
        
        Args:
            new_value (RichCurveTangentWeightMode): Specifies which tangent weights should be respected when evaluating the key.
        """
        ...
    def set_tangent_mode(self, new_value: RichCurveTangentMode) -> None:
        r"""
        x.set_tangent_mode(new_value) -> None
        Sets the tangent mode for this key, reflecting it in the owning channel.
        
        Args:
            new_value (RichCurveTangentMode): Tangent mode that this key should use to specify which tangent values are respected when evaluating. See ERichCurveTangentMode for more details.
        """
        ...
    def set_leave_tangent_weight(self, new_value: float) -> None:
        r"""
        x.set_leave_tangent_weight(new_value) -> None
        If Tangent Weight Mode is RCTWM_WeightedLeave or RCTWM_WeightedBoth, the weight of the leaving tangent on the right side.
        
        Args:
            new_value (float): Specifies the new leaving tangent weight. Represents the length of the hypotenuse in the form of "sqrt(x*x+y*y)" using the same definitions for x and y as tangents.
        """
        ...
    def set_leave_tangent(self, new_value: float) -> None:
        r"""
        x.set_leave_tangent(new_value) -> None
        If Interpolation Mode is RCIM_Cubic, the leaving tangent at this key.
        
        Args:
            new_value (float): Represents the geometric tangents in the form of "tan(y/x)" where y is the key's value and x is the seconds (both relative to key)
        """
        ...
    def set_interpolation_mode(self, new_value: RichCurveInterpMode) -> None:
        r"""
        x.set_interpolation_mode(new_value) -> None
        Sets the interpolation mode for this key, reflecting it in the owning channel.
        
        Args:
            new_value (RichCurveInterpMode): Interpolation mode this key should use to interpolate between this key and the next.
        """
        ...
    def set_arrive_tangent_weight(self, new_value: float) -> None:
        r"""
        x.set_arrive_tangent_weight(new_value) -> None
        If Tangent Weight Mode is RCTWM_WeightedArrive or RCTWM_WeightedBoth, the weight of the arriving tangent on the left side.
        
        Args:
            new_value (float): Specifies the new arriving tangent weight. Represents the length of the hypotenuse in the form of "sqrt(x*x+y*y)" using the same definitions for x and y as tangents.
        """
        ...
    def set_arrive_tangent(self, new_value: float) -> None:
        r"""
        x.set_arrive_tangent(new_value) -> None
        If Interpolation Mode is RCIM_Cubic, the arriving tangent at this key.
        
        Args:
            new_value (float): Represents the geometric tangents in the form of "tan(y/x)" where y is the key's value and x is the seconds (both relative to key)
        """
        ...
    def get_value(self) -> float:
        r"""
        x.get_value() -> double
        Gets the value for this key from the owning channel.
        
        Returns:
            double: The double value this key represents.
        """
        ...
    def get_time(self, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime:
        r"""
        x.get_time(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime
        Gets the time for this key from the owning channel.
        
        Args:
            time_unit (MovieSceneTimeUnit): Should the time be returned in Display Rate frames (possibly with a sub-frame value) or in Tick Resolution with no sub-frame values?
        
        Returns:
            FrameTime: The time of this key which combines both the frame number and the sub-frame it is on. Sub-frame will be zero if you request Tick Resolution.
        """
        ...
    def get_tangent_weight_mode(self) -> RichCurveTangentWeightMode:
        r"""
        x.get_tangent_weight_mode() -> RichCurveTangentWeightMode
        If Interpolation Mode is RCIM_Cubic, the tangent weight mode at this key
        
        Returns:
            RichCurveTangentWeightMode: Tangent Weight Mode. See ERichCurveTangentWeightMode for more detail on what each mode does.
        """
        ...
    def get_tangent_mode(self) -> RichCurveTangentMode:
        r"""
        x.get_tangent_mode() -> RichCurveTangentMode
        Gets the tangent mode for this key from the owning channel.
        
        Returns:
            RichCurveTangentMode: Tangent mode that this key is using specifying which tangent values are respected when evaluating.
        """
        ...
    def get_leave_tangent_weight(self) -> float:
        r"""
        x.get_leave_tangent_weight() -> float
        If Tangent Weight Mode is RCTWM_WeightedLeave or RCTWM_WeightedBoth, the weight of the leaving tangent on the right side.
        
        Returns:
            float: Tangent Weight. Represents the length of the hypotenuse in the form of "sqrt(x*x+y*y)" using the same definitions for x and y as tangents.
        """
        ...
    def get_leave_tangent(self) -> float:
        r"""
        x.get_leave_tangent() -> float
        If Interpolation Mode is RCIM_Cubic, the leaving tangent at this key
        
        Returns:
            float: Leaving Tangent value. Represents the geometric tangents in the form of "tan(y/x)" where y is the key's value and x is the seconds (both relative to key)
        """
        ...
    def get_interpolation_mode(self) -> RichCurveInterpMode:
        r"""
        x.get_interpolation_mode() -> RichCurveInterpMode
        Gets the interpolation mode for this key from the owning channel.
        
        Returns:
            RichCurveInterpMode: Interpolation mode this key uses to interpolate between this key and the next.
        """
        ...
    def get_arrive_tangent_weight(self) -> float:
        r"""
        x.get_arrive_tangent_weight() -> float
        If Tangent Weight Mode is RCTWM_WeightedArrive or RCTWM_WeightedBoth, the weight of the arriving tangent on the left side.
        
        Returns:
            float: Tangent Weight. Represents the length of the hypotenuse in the form of "sqrt(x*x+y*y)" using the same definitions for x and y as tangents.
        """
        ...
    def get_arrive_tangent(self) -> float:
        r"""
        x.get_arrive_tangent() -> float
        If Interpolation Mode is RCIM_Cubic, the arriving tangent at this key
        
        Returns:
            float: Arrival Tangent value. Represents the geometric tangents in the form of "tan(y/x)" where y is the key's value and x is the seconds (both relative to key)
        """
        ...

class MovieSceneScriptingDoubleChannel(MovieSceneScriptingChannel):
    r"""
    Movie Scene Scripting Double Channel
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingDouble.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_name`` (Name):  [Read-Write]
    """
    def set_pre_infinity_extrapolation(self, extrapolation: RichCurveExtrapolation) -> None:
        r"""
        x.set_pre_infinity_extrapolation(extrapolation) -> None
        Sets the Pre-infinity extrapolation state. See ERichCurveExtrapolation for more detail.
        
        Args:
            extrapolation (RichCurveExtrapolation): The new extrapolation mode this key should use for evaluating before this key.
        """
        ...
    def set_post_infinity_extrapolation(self, extrapolation: RichCurveExtrapolation) -> None:
        r"""
        x.set_post_infinity_extrapolation(extrapolation) -> None
        Sets the Post-infinity extrapolation state. See ERichCurveExtrapolation for more detail.
        
        Args:
            extrapolation (RichCurveExtrapolation): The new extrapolation mode this key should use for evaluating after this key.
        """
        ...
    def set_default(self, default_value: float) -> None:
        r"""
        x.set_default(default_value) -> None
        Set this channel's default value that should be used when no keys are present.
        Sets bHasDefaultValue to true automatically.
        
        Args:
            default_value (double):
        """
        ...
    def remove_key(self, key: MovieSceneScriptingKey) -> None:
        r"""
        x.remove_key(key) -> None
        Removes the specified key. Does nothing if the key is not specified or the key belongs to another channel.
        
        Args:
            key (MovieSceneScriptingKey):
        """
        ...
    def remove_default(self) -> None:
        r"""
        x.remove_default() -> None
        Remove this channel's default value causing the channel to have no effect where no keys are present
        """
        ...
    def has_default(self) -> bool:
        r"""
        x.has_default() -> bool
        
        
        Returns:
            bool: Does this channel have a default value set?
        """
        ...
    def get_pre_infinity_extrapolation(self) -> RichCurveExtrapolation:
        r"""
        x.get_pre_infinity_extrapolation() -> RichCurveExtrapolation
        
        
        Returns:
            RichCurveExtrapolation: Gets the Pre-infinity extrapolation state. See ERichCurveExtrapolation for more detail.
        """
        ...
    def get_post_infinity_extrapolation(self) -> RichCurveExtrapolation:
        r"""
        x.get_post_infinity_extrapolation() -> RichCurveExtrapolation
        
        
        Returns:
            RichCurveExtrapolation: Gets the Post-infinity extrapolation state. See ERichCurveExtrapolation for more detail.
        """
        ...
    def get_num_keys(self) -> int:
        r"""
        x.get_num_keys() -> int32
        Returns number of keys in this channel.
        
        Returns:
            int32:
        """
        ...
    def get_keys_by_index(self, indices: Array[int]) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys_by_index(indices) -> Array[MovieSceneScriptingKey]
        Gets the keys in this channel specified by the specific index
        Indices: The indices from which to get the keys from
        
        Args:
            indices (Array[int32]): 
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingKey's contained by this channel. Returns all keys specified by the indices, even if out of range.
        """
        ...
    def get_keys(self) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys() -> Array[MovieSceneScriptingKey]
        Gets all of the keys in this channel.
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingDoubleKey's contained by this channel. Returns all keys even if clipped by the owning section's boundaries or outside of the current sequence play range.
        """
        ...
    def get_default(self) -> float:
        r"""
        x.get_default() -> double
        Get this channel's default value that will be used when no keys are present. Only a valid
        value when HasDefault() returns true.
        
        Returns:
            double:
        """
        ...
    def evaluate_keys(self, range: SequencerScriptingRange, frame_rate: FrameRate) -> Array[float]:
        r"""
        x.evaluate_keys(range, frame_rate) -> Array[double]
        Gets baked keys in this channel.
        
        Args:
            range (SequencerScriptingRange): 
            frame_rate (FrameRate): 
        
        Returns:
            Array[double]: An array of double's contained by this channel. Returns baked keys in the specified range.
        """
        ...
    def compute_effective_range(self) -> SequencerScriptingRange:
        r"""
        x.compute_effective_range() -> SequencerScriptingRange
        Compute the effective range of this channel, for example, the extents of its key times
        
        Returns:
            SequencerScriptingRange: A range that represents the greatest range of times occupied by this channel, in the sequence's frame resolution
        """
        ...
    def add_key(self, time: FrameNumber, new_value: float, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, interpolation: MovieSceneKeyInterpolation = MovieSceneKeyInterpolation.AUTO) -> MovieSceneScriptingDoubleKey:
        r"""
        x.add_key(time, new_value, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, interpolation=MovieSceneKeyInterpolation.AUTO) -> MovieSceneScriptingDoubleKey
        Add a key to this channel. This initializes a new key and returns a reference to it.
        
        Args:
            time (FrameNumber): The frame this key should go on. Respects TimeUnit to determine if it is a display rate frame or a tick resolution frame.
            new_value (double): The value that this key should be created with.
            sub_frame (float): Optional [0-1) clamped sub-frame to put this key on. Ignored if TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Is the specified InTime in Display Rate frames or Tick Resolution.
            interpolation (MovieSceneKeyInterpolation): Interpolation method the key should use.
        
        Returns:
            MovieSceneScriptingDoubleKey: The key that was created with the specified values at the specified time.
        """
        ...

class MovieSceneScriptingEventKey(MovieSceneScriptingKey):
    r"""
    Exposes a Sequencer Event type key to Python/Blueprints.
    Stores a reference to the data so changes to this class are forwarded onto the underlying data structures.
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingEvent.h
    
    """
    def set_value(self, new_value: MovieSceneEvent) -> None:
        r"""
        x.set_value(new_value) -> None
        Sets the value for this key, reflecting it in the owning channel.
        
        Args:
            new_value (MovieSceneEvent): The new event payload for this key.
        """
        ...
    def set_time(self, new_frame_number: FrameNumber, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        x.set_time(new_frame_number, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Sets the time for this key in the owning channel. Will replace any key that already exists at that frame number in this channel.
        
        Args:
            new_frame_number (FrameNumber): What frame should this key be moved to? This should be in the time unit specified by TimeUnit.
            sub_frame (float): If using Display Rate time, what is the sub-frame this should go to? Clamped [0-1), and ignored with when TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Should the NewFrameNumber be interpreted as Display Rate frames or in Tick Resolution?
        """
        ...
    def get_value(self) -> MovieSceneEvent:
        r"""
        x.get_value() -> MovieSceneEvent
        Gets the value for this key from the owning channel.
        
        Returns:
            MovieSceneEvent: The event payload for this key which contains an event name and data.
        """
        ...
    def get_time(self, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime:
        r"""
        x.get_time(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime
        Gets the time for this key from the owning channel.
        
        Args:
            time_unit (MovieSceneTimeUnit): Should the time be returned in Display Rate frames (possibly with a sub-frame value) or in Tick Resolution with no sub-frame values?
        
        Returns:
            FrameTime: The time of this key which combines both the frame number and the sub-frame it is on. Sub-frame will be zero if you request Tick Resolution.
        """
        ...

class MovieSceneScriptingEventChannel(MovieSceneScriptingChannel):
    r"""
    Movie Scene Scripting Event Channel
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingEvent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_name`` (Name):  [Read-Write]
    """
    def remove_key(self, key: MovieSceneScriptingKey) -> None:
        r"""
        x.remove_key(key) -> None
        Removes the specified key. Does nothing if the key is not specified or the key belongs to another channel.
        
        Args:
            key (MovieSceneScriptingKey):
        """
        ...
    def get_keys_by_index(self, indices: Array[int]) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys_by_index(indices) -> Array[MovieSceneScriptingKey]
        Gets the keys in this channel specified by the specific index
        Indices: The indices from which to get the keys from
        
        Args:
            indices (Array[int32]): 
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingKey's contained by this channel. Returns all keys specified by the indices, even if out of range.
        """
        ...
    def get_keys(self) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys() -> Array[MovieSceneScriptingKey]
        Gets all of the keys in this channel.
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingEventKey's contained by this channel. Returns all keys even if clipped by the owning section's boundaries or outside of the current sequence play range.
        """
        ...
    def add_key(self, time: FrameNumber, new_value: MovieSceneEvent, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingEventKey:
        r"""
        x.add_key(time, new_value, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingEventKey
        Add a key to this channel. This initializes a new key and returns a reference to it.
        
        Args:
            time (FrameNumber): The frame this key should go on. Respects TimeUnit to determine if it is a display rate frame or a tick resolution frame.
            new_value (MovieSceneEvent): The value that this key should be created with.
            sub_frame (float): Optional [0-1) clamped sub-frame to put this key on. Ignored if TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Is the specified InTime in Display Rate frames or Tick Resolution.
        
        Returns:
            MovieSceneScriptingEventKey: The key that was created with the specified values at the specified time.
        """
        ...

class MovieSceneScriptingFloatKey(MovieSceneScriptingKey):
    r"""
    Exposes a Sequencer float type key to Python/Blueprints.
    Stores a reference to the data so changes to this class are forwarded onto the underlying data structures.
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingFloat.h
    
    """
    def set_value(self, new_value: float) -> None:
        r"""
        x.set_value(new_value) -> None
        Sets the value for this key, reflecting it in the owning channel.
        
        Args:
            new_value (float): The new float value for this key.
        """
        ...
    def set_time(self, new_frame_number: FrameNumber, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        x.set_time(new_frame_number, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Sets the time for this key in the owning channel. Will replace any key that already exists at that frame number in this channel.
        
        Args:
            new_frame_number (FrameNumber): What frame should this key be moved to? This should be in the time unit specified by TimeUnit.
            sub_frame (float): If using Display Rate time, what is the sub-frame this should go to? Clamped [0-1), and ignored with when TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Should the NewFrameNumber be interpreted as Display Rate frames or in Tick Resolution?
        """
        ...
    def set_tangent_weight_mode(self, new_value: RichCurveTangentWeightMode) -> None:
        r"""
        x.set_tangent_weight_mode(new_value) -> None
        If Interpolation Mode is RCIM_Cubic, the tangent weight mode at this key.
        
        Args:
            new_value (RichCurveTangentWeightMode): Specifies which tangent weights should be respected when evaluating the key.
        """
        ...
    def set_tangent_mode(self, new_value: RichCurveTangentMode) -> None:
        r"""
        x.set_tangent_mode(new_value) -> None
        Sets the tangent mode for this key, reflecting it in the owning channel.
        
        Args:
            new_value (RichCurveTangentMode): Tangent mode that this key should use to specify which tangent values are respected when evaluating. See ERichCurveTangentMode for more details.
        """
        ...
    def set_leave_tangent_weight(self, new_value: float) -> None:
        r"""
        x.set_leave_tangent_weight(new_value) -> None
        If Tangent Weight Mode is RCTWM_WeightedLeave or RCTWM_WeightedBoth, the weight of the leaving tangent on the right side.
        
        Args:
            new_value (float): Specifies the new leaving tangent weight. Represents the length of the hypotenuse in the form of "sqrt(x*x+y*y)" using the same definitions for x and y as tangents.
        """
        ...
    def set_leave_tangent(self, new_value: float) -> None:
        r"""
        x.set_leave_tangent(new_value) -> None
        If Interpolation Mode is RCIM_Cubic, the leaving tangent at this key.
        
        Args:
            new_value (float): Represents the geometric tangents in the form of "tan(y/x)" where y is the key's value and x is the seconds (both relative to key)
        """
        ...
    def set_interpolation_mode(self, new_value: RichCurveInterpMode) -> None:
        r"""
        x.set_interpolation_mode(new_value) -> None
        Sets the interpolation mode for this key, reflecting it in the owning channel.
        
        Args:
            new_value (RichCurveInterpMode): Interpolation mode this key should use to interpolate between this key and the next.
        """
        ...
    def set_arrive_tangent_weight(self, new_value: float) -> None:
        r"""
        x.set_arrive_tangent_weight(new_value) -> None
        If Tangent Weight Mode is RCTWM_WeightedArrive or RCTWM_WeightedBoth, the weight of the arriving tangent on the left side.
        
        Args:
            new_value (float): Specifies the new arriving tangent weight. Represents the length of the hypotenuse in the form of "sqrt(x*x+y*y)" using the same definitions for x and y as tangents.
        """
        ...
    def set_arrive_tangent(self, new_value: float) -> None:
        r"""
        x.set_arrive_tangent(new_value) -> None
        If Interpolation Mode is RCIM_Cubic, the arriving tangent at this key.
        
        Args:
            new_value (float): Represents the geometric tangents in the form of "tan(y/x)" where y is the key's value and x is the seconds (both relative to key)
        """
        ...
    def get_value(self) -> float:
        r"""
        x.get_value() -> float
        Gets the value for this key from the owning channel.
        
        Returns:
            float: The float value this key represents.
        """
        ...
    def get_time(self, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime:
        r"""
        x.get_time(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime
        Gets the time for this key from the owning channel.
        
        Args:
            time_unit (MovieSceneTimeUnit): Should the time be returned in Display Rate frames (possibly with a sub-frame value) or in Tick Resolution with no sub-frame values?
        
        Returns:
            FrameTime: The time of this key which combines both the frame number and the sub-frame it is on. Sub-frame will be zero if you request Tick Resolution.
        """
        ...
    def get_tangent_weight_mode(self) -> RichCurveTangentWeightMode:
        r"""
        x.get_tangent_weight_mode() -> RichCurveTangentWeightMode
        If Interpolation Mode is RCIM_Cubic, the tangent weight mode at this key
        
        Returns:
            RichCurveTangentWeightMode: Tangent Weight Mode. See ERichCurveTangentWeightMode for more detail on what each mode does.
        """
        ...
    def get_tangent_mode(self) -> RichCurveTangentMode:
        r"""
        x.get_tangent_mode() -> RichCurveTangentMode
        Gets the tangent mode for this key from the owning channel.
        
        Returns:
            RichCurveTangentMode: Tangent mode that this key is using specifying which tangent values are respected when evaluating.
        """
        ...
    def get_leave_tangent_weight(self) -> float:
        r"""
        x.get_leave_tangent_weight() -> float
        If Tangent Weight Mode is RCTWM_WeightedLeave or RCTWM_WeightedBoth, the weight of the leaving tangent on the right side.
        
        Returns:
            float: Tangent Weight. Represents the length of the hypotenuse in the form of "sqrt(x*x+y*y)" using the same definitions for x and y as tangents.
        """
        ...
    def get_leave_tangent(self) -> float:
        r"""
        x.get_leave_tangent() -> float
        If Interpolation Mode is RCIM_Cubic, the leaving tangent at this key
        
        Returns:
            float: Leaving Tangent value. Represents the geometric tangents in the form of "tan(y/x)" where y is the key's value and x is the seconds (both relative to key)
        """
        ...
    def get_interpolation_mode(self) -> RichCurveInterpMode:
        r"""
        x.get_interpolation_mode() -> RichCurveInterpMode
        Gets the interpolation mode for this key from the owning channel.
        
        Returns:
            RichCurveInterpMode: Interpolation mode this key uses to interpolate between this key and the next.
        """
        ...
    def get_arrive_tangent_weight(self) -> float:
        r"""
        x.get_arrive_tangent_weight() -> float
        If Tangent Weight Mode is RCTWM_WeightedArrive or RCTWM_WeightedBoth, the weight of the arriving tangent on the left side.
        
        Returns:
            float: Tangent Weight. Represents the length of the hypotenuse in the form of "sqrt(x*x+y*y)" using the same definitions for x and y as tangents.
        """
        ...
    def get_arrive_tangent(self) -> float:
        r"""
        x.get_arrive_tangent() -> float
        If Interpolation Mode is RCIM_Cubic, the arriving tangent at this key
        
        Returns:
            float: Arrival Tangent value. Represents the geometric tangents in the form of "tan(y/x)" where y is the key's value and x is the seconds (both relative to key)
        """
        ...

class MovieSceneScriptingActualFloatKey(MovieSceneScriptingFloatKey):
    r"""
    Movie Scene Scripting Actual Float Key
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingFloat.h
    
    """
    ...

class MovieSceneScriptingDoubleAsFloatKey(MovieSceneScriptingFloatKey):
    r"""
    Movie Scene Scripting Double as Float Key
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingFloat.h
    
    """
    ...

class MovieSceneScriptingFloatChannel(MovieSceneScriptingChannel):
    r"""
    Movie Scene Scripting Float Channel
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingFloat.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_name`` (Name):  [Read-Write]
    """
    def set_pre_infinity_extrapolation(self, extrapolation: RichCurveExtrapolation) -> None:
        r"""
        x.set_pre_infinity_extrapolation(extrapolation) -> None
        Sets the Pre-infinity extrapolation state. See ERichCurveExtrapolation for more detail.
        
        Args:
            extrapolation (RichCurveExtrapolation): The new extrapolation mode this key should use for evaluating before this key.
        """
        ...
    def set_post_infinity_extrapolation(self, extrapolation: RichCurveExtrapolation) -> None:
        r"""
        x.set_post_infinity_extrapolation(extrapolation) -> None
        Sets the Post-infinity extrapolation state. See ERichCurveExtrapolation for more detail.
        
        Args:
            extrapolation (RichCurveExtrapolation): The new extrapolation mode this key should use for evaluating after this key.
        """
        ...
    def set_default(self, default_value: float) -> None:
        r"""
        x.set_default(default_value) -> None
        Set this channel's default value that should be used when no keys are present.
        Sets bHasDefaultValue to true automatically.
        
        Args:
            default_value (float):
        """
        ...
    def remove_key(self, key: MovieSceneScriptingKey) -> None:
        r"""
        x.remove_key(key) -> None
        Removes the specified key. Does nothing if the key is not specified or the key belongs to another channel.
        
        Args:
            key (MovieSceneScriptingKey):
        """
        ...
    def remove_default(self) -> None:
        r"""
        x.remove_default() -> None
        Remove this channel's default value causing the channel to have no effect where no keys are present
        """
        ...
    def has_default(self) -> bool:
        r"""
        x.has_default() -> bool
        
        
        Returns:
            bool: Does this channel have a default value set?
        """
        ...
    def get_pre_infinity_extrapolation(self) -> RichCurveExtrapolation:
        r"""
        x.get_pre_infinity_extrapolation() -> RichCurveExtrapolation
        
        
        Returns:
            RichCurveExtrapolation: Gets the Pre-infinity extrapolation state. See ERichCurveExtrapolation for more detail.
        """
        ...
    def get_post_infinity_extrapolation(self) -> RichCurveExtrapolation:
        r"""
        x.get_post_infinity_extrapolation() -> RichCurveExtrapolation
        
        
        Returns:
            RichCurveExtrapolation: Gets the Post-infinity extrapolation state. See ERichCurveExtrapolation for more detail.
        """
        ...
    def get_num_keys(self) -> int:
        r"""
        x.get_num_keys() -> int32
        Returns number of keys in this channel.
        
        Returns:
            int32:
        """
        ...
    def get_keys_by_index(self, indices: Array[int]) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys_by_index(indices) -> Array[MovieSceneScriptingKey]
        Gets the keys in this channel specified by the specific index
        Indices: The indices from which to get the keys from
        
        Args:
            indices (Array[int32]): 
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingKey's contained by this channel. Returns all keys specified by the indices, even if out of range.
        """
        ...
    def get_keys(self) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys() -> Array[MovieSceneScriptingKey]
        Gets all of the keys in this channel.
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingFloatKey's contained by this channel. Returns all keys even if clipped by the owning section's boundaries or outside of the current sequence play range.
        """
        ...
    def get_default(self) -> float:
        r"""
        x.get_default() -> float
        Get this channel's default value that will be used when no keys are present. Only a valid
        value when HasDefault() returns true.
        
        Returns:
            float:
        """
        ...
    def evaluate_keys(self, range: SequencerScriptingRange, frame_rate: FrameRate) -> Array[float]:
        r"""
        x.evaluate_keys(range, frame_rate) -> Array[float]
        Gets baked keys in this channel.
        
        Args:
            range (SequencerScriptingRange): 
            frame_rate (FrameRate): 
        
        Returns:
            Array[float]: An array of float's contained by this channel. Returns baked keys in the specified range.
        """
        ...
    def compute_effective_range(self) -> SequencerScriptingRange:
        r"""
        x.compute_effective_range() -> SequencerScriptingRange
        Compute the effective range of this channel, for example, the extents of its key times
        
        Returns:
            SequencerScriptingRange: A range that represents the greatest range of times occupied by this channel, in the sequence's frame resolution
        """
        ...
    def add_key(self, time: FrameNumber, new_value: float, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, interpolation: MovieSceneKeyInterpolation = MovieSceneKeyInterpolation.AUTO) -> MovieSceneScriptingFloatKey:
        r"""
        x.add_key(time, new_value, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, interpolation=MovieSceneKeyInterpolation.AUTO) -> MovieSceneScriptingFloatKey
        Add a key to this channel. This initializes a new key and returns a reference to it.
        
        Args:
            time (FrameNumber): The frame this key should go on. Respects TimeUnit to determine if it is a display rate frame or a tick resolution frame.
            new_value (float): The value that this key should be created with.
            sub_frame (float): Optional [0-1) clamped sub-frame to put this key on. Ignored if TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Is the specified InTime in Display Rate frames or Tick Resolution.
            interpolation (MovieSceneKeyInterpolation): Interpolation method the key should use.
        
        Returns:
            MovieSceneScriptingFloatKey: The key that was created with the specified values at the specified time.
        """
        ...

class MovieSceneScriptingIntegerKey(MovieSceneScriptingKey):
    r"""
    Exposes a Sequencer integer type key to Python/Blueprints.
    Stores a reference to the data so changes to this class are forwarded onto the underlying data structures.
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingInteger.h
    
    """
    def set_value(self, new_value: int) -> None:
        r"""
        x.set_value(new_value) -> None
        Sets the value for this key, reflecting it in the owning channel.
        
        Args:
            new_value (int32): The new value for this key.
        """
        ...
    def set_time(self, new_frame_number: FrameNumber, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        x.set_time(new_frame_number, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Sets the time for this key in the owning channel. Will replace any key that already exists at that frame number in this channel.
        
        Args:
            new_frame_number (FrameNumber): What frame should this key be moved to? This should be in the time unit specified by TimeUnit.
            sub_frame (float): If using Display Rate time, what is the sub-frame this should go to? Clamped [0-1), and ignored with when TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Should the NewFrameNumber be interpreted as Display Rate frames or in Tick Resolution?
        """
        ...
    def get_value(self) -> int:
        r"""
        x.get_value() -> int32
        Gets the value for this key from the owning channel.
        
        Returns:
            int32: The value for this key.
        """
        ...
    def get_time(self, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime:
        r"""
        x.get_time(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime
        Gets the time for this key from the owning channel.
        
        Args:
            time_unit (MovieSceneTimeUnit): Should the time be returned in Display Rate frames (possibly with a sub-frame value) or in Tick Resolution with no sub-frame values?
        
        Returns:
            FrameTime: The time of this key which combines both the frame number and the sub-frame it is on. Sub-frame will be zero if you request Tick Resolution.
        """
        ...

class MovieSceneScriptingIntegerChannel(MovieSceneScriptingChannel):
    r"""
    Movie Scene Scripting Integer Channel
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingInteger.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_name`` (Name):  [Read-Write]
    """
    def set_default(self, default_value: int) -> None:
        r"""
        x.set_default(default_value) -> None
        Set this channel's default value that should be used when no keys are present.
        Sets bHasDefaultValue to true automatically.
        
        Args:
            default_value (int32):
        """
        ...
    def remove_key(self, key: MovieSceneScriptingKey) -> None:
        r"""
        x.remove_key(key) -> None
        Removes the specified key. Does nothing if the key is not specified or the key belongs to another channel.
        
        Args:
            key (MovieSceneScriptingKey):
        """
        ...
    def remove_default(self) -> None:
        r"""
        x.remove_default() -> None
        Remove this channel's default value causing the channel to have no effect where no keys are present
        """
        ...
    def has_default(self) -> bool:
        r"""
        x.has_default() -> bool
        
        
        Returns:
            bool: Does this channel have a default value set?
        """
        ...
    def get_num_keys(self) -> int:
        r"""
        x.get_num_keys() -> int32
        Returns number of keys in this channel.
        
        Returns:
            int32:
        """
        ...
    def get_keys_by_index(self, indices: Array[int]) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys_by_index(indices) -> Array[MovieSceneScriptingKey]
        Gets the keys in this channel specified by the specific index
        Indices: The indices from which to get the keys from
        
        Args:
            indices (Array[int32]): 
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingKey's contained by this channel. Returns all keys specified by the indices, even if out of range.
        """
        ...
    def get_keys(self) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys() -> Array[MovieSceneScriptingKey]
        Gets all of the keys in this channel.
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingIntegerKey's contained by this channel. Returns all keys even if clipped by the owning section's boundaries or outside of the current sequence play range.
        """
        ...
    def get_default(self) -> int:
        r"""
        x.get_default() -> int32
        Get this channel's default value that will be used when no keys are present. Only a valid
        value when HasDefault() returns true.
        
        Returns:
            int32:
        """
        ...
    def evaluate_keys(self, range: SequencerScriptingRange, frame_rate: FrameRate) -> Array[int]:
        r"""
        x.evaluate_keys(range, frame_rate) -> Array[int32]
        Gets baked keys in this channel.
        
        Args:
            range (SequencerScriptingRange): 
            frame_rate (FrameRate): 
        
        Returns:
            Array[int32]: An array of values contained by this channel. Returns baked keys in the specified range.
        """
        ...
    def add_key(self, time: FrameNumber, new_value: int, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingIntegerKey:
        r"""
        x.add_key(time, new_value, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingIntegerKey
        Add a key to this channel. This initializes a new key and returns a reference to it.
        
        Args:
            time (FrameNumber): The frame this key should go on. Respects TimeUnit to determine if it is a display rate frame or a tick resolution frame.
            new_value (int32): The value that this key should be created with.
            sub_frame (float): Optional [0-1) clamped sub-frame to put this key on. Ignored if TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Is the specified InTime in Display Rate frames or Tick Resolution.
        
        Returns:
            MovieSceneScriptingIntegerKey: The key that was created with the specified values at the specified time.
        """
        ...

class MovieSceneScriptingObjectPathKey(MovieSceneScriptingKey):
    r"""
    Exposes a Sequencer Object Path type key to Python/Blueprints.
    Stores a reference to the data so changes to this class are forwarded onto the underlying data structures.
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingObjectPath.h
    
    """
    def set_value(self, new_value: Object) -> None:
        r"""
        x.set_value(new_value) -> None
        Sets the value for this key, reflecting it in the owning channel.
        
        Args:
            new_value (Object): The new object for this key.
        """
        ...
    def set_time(self, new_frame_number: FrameNumber, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        x.set_time(new_frame_number, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Sets the time for this key in the owning channel. Will replace any key that already exists at that frame number in this channel.
        
        Args:
            new_frame_number (FrameNumber): What frame should this key be moved to? This should be in the time unit specified by TimeUnit.
            sub_frame (float): If using Display Rate time, what is the sub-frame this should go to? Clamped [0-1), and ignored with when TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Should the NewFrameNumber be interpreted as Display Rate frames or in Tick Resolution?
        """
        ...
    def get_value(self) -> Object:
        r"""
        x.get_value() -> Object
        Gets the value for this key from the owning channel.
        
        Returns:
            Object: The object for this key.
        """
        ...
    def get_time(self, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime:
        r"""
        x.get_time(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime
        Gets the time for this key from the owning channel.
        
        Args:
            time_unit (MovieSceneTimeUnit): Should the time be returned in Display Rate frames (possibly with a sub-frame value) or in Tick Resolution with no sub-frame values?
        
        Returns:
            FrameTime: The time of this key which combines both the frame number and the sub-frame it is on. Sub-frame will be zero if you request Tick Resolution.
        """
        ...

class MovieSceneScriptingObjectPathChannel(MovieSceneScriptingChannel):
    r"""
    Movie Scene Scripting Object Path Channel
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingObjectPath.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_name`` (Name):  [Read-Write]
    """
    def set_default(self, default_value: Object) -> None:
        r"""
        x.set_default(default_value) -> None
        Set this channel's default value that should be used when no keys are present.
        Sets bHasDefaultValue to true automatically.
        
        Args:
            default_value (Object):
        """
        ...
    def remove_key(self, key: MovieSceneScriptingKey) -> None:
        r"""
        x.remove_key(key) -> None
        Removes the specified key. Does nothing if the key is not specified or the key belongs to another channel.
        
        Args:
            key (MovieSceneScriptingKey):
        """
        ...
    def remove_default(self) -> None:
        r"""
        x.remove_default() -> None
        Remove this channel's default value causing the channel to have no effect where no keys are present
        """
        ...
    def has_default(self) -> bool:
        r"""
        x.has_default() -> bool
        
        
        Returns:
            bool: Does this channel have a default value set?
        """
        ...
    def get_keys_by_index(self, indices: Array[int]) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys_by_index(indices) -> Array[MovieSceneScriptingKey]
        Gets the keys in this channel specified by the specific index
        Indices: The indices from which to get the keys from
        
        Args:
            indices (Array[int32]): 
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingKey's contained by this channel. Returns all keys specified by the indices, even if out of range.
        """
        ...
    def get_keys(self) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys() -> Array[MovieSceneScriptingKey]
        Gets all of the keys in this channel.
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingObjectPathKey contained by this channel. Returns all keys even if clipped by the owning section's boundaries or outside of the current sequence play range.
        """
        ...
    def get_default(self) -> Object:
        r"""
        x.get_default() -> Object
        Get this channel's default value that will be used when no keys are present. Only a valid
        value when HasDefault() returns true.
        
        Returns:
            Object:
        """
        ...
    def add_key(self, time: FrameNumber, new_value: Object, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingObjectPathKey:
        r"""
        x.add_key(time, new_value, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingObjectPathKey
        Add a key to this channel. This initializes a new key and returns a reference to it.
        
        Args:
            time (FrameNumber): The frame this key should go on. Respects TimeUnit to determine if it is a display rate frame or a tick resolution frame.
            new_value (Object): The value that this key should be created with.
            sub_frame (float): Optional [0-1) clamped sub-frame to put this key on. Ignored if TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Is the specified InTime in Display Rate frames or Tick Resolution.
        
        Returns:
            MovieSceneScriptingObjectPathKey: The key that was created with the specified values at the specified time.
        """
        ...

class MovieSceneScriptingStringKey(MovieSceneScriptingKey):
    r"""
    Exposes a Sequencer string type key to Python/Blueprints.
    Stores a reference to the data so changes to this class are forwarded onto the underlying data structures.
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingString.h
    
    """
    def set_value(self, new_value: str) -> None:
        r"""
        x.set_value(new_value) -> None
        Sets the value for this key, reflecting it in the owning channel.
        
        Args:
            new_value (str): The new value for this key.
        """
        ...
    def set_time(self, new_frame_number: FrameNumber, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        x.set_time(new_frame_number, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Sets the time for this key in the owning channel. Will replace any key that already exists at that frame number in this channel.
        
        Args:
            new_frame_number (FrameNumber): What frame should this key be moved to? This should be in the time unit specified by TimeUnit.
            sub_frame (float): If using Display Rate time, what is the sub-frame this should go to? Clamped [0-1), and ignored with when TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Should the NewFrameNumber be interpreted as Display Rate frames or in Tick Resolution?
        """
        ...
    def get_value(self) -> str:
        r"""
        x.get_value() -> str
        Gets the value for this key from the owning channel.
        
        Returns:
            str: The value for this key.
        """
        ...
    def get_time(self, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime:
        r"""
        x.get_time(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> FrameTime
        Gets the time for this key from the owning channel.
        
        Args:
            time_unit (MovieSceneTimeUnit): Should the time be returned in Display Rate frames (possibly with a sub-frame value) or in Tick Resolution with no sub-frame values?
        
        Returns:
            FrameTime: The time of this key which combines both the frame number and the sub-frame it is on. Sub-frame will be zero if you request Tick Resolution.
        """
        ...

class MovieSceneScriptingStringChannel(MovieSceneScriptingChannel):
    r"""
    Movie Scene Scripting String Channel
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneScriptingString.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``channel_name`` (Name):  [Read-Write]
    """
    def set_default(self, default_value: str) -> None:
        r"""
        x.set_default(default_value) -> None
        Set this channel's default value that should be used when no keys are present.
        Sets bHasDefaultValue to true automatically.
        
        Args:
            default_value (str):
        """
        ...
    def remove_key(self, key: MovieSceneScriptingKey) -> None:
        r"""
        x.remove_key(key) -> None
        Removes the specified key. Does nothing if the key is not specified or the key belongs to another channel.
        
        Args:
            key (MovieSceneScriptingKey):
        """
        ...
    def remove_default(self) -> None:
        r"""
        x.remove_default() -> None
        Remove this channel's default value causing the channel to have no effect where no keys are present
        """
        ...
    def has_default(self) -> bool:
        r"""
        x.has_default() -> bool
        
        
        Returns:
            bool: Does this channel have a default value set?
        """
        ...
    def get_keys_by_index(self, indices: Array[int]) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys_by_index(indices) -> Array[MovieSceneScriptingKey]
        Gets the keys in this channel specified by the specific index
        Indices: The indices from which to get the keys from
        
        Args:
            indices (Array[int32]): 
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingKey's contained by this channel. Returns all keys specified by the indices, even if out of range.
        """
        ...
    def get_keys(self) -> Array[MovieSceneScriptingKey]:
        r"""
        x.get_keys() -> Array[MovieSceneScriptingKey]
        Gets all of the keys in this channel.
        
        Returns:
            Array[MovieSceneScriptingKey]: An array of UMovieSceneScriptingStringKey's contained by this channel. Returns all keys even if clipped by the owning section's boundaries or outside of the current sequence play range.
        """
        ...
    def get_default(self) -> str:
        r"""
        x.get_default() -> str
        Get this channel's default value that will be used when no keys are present. Only a valid
        value when HasDefault() returns true.
        
        Returns:
            str:
        """
        ...
    def add_key(self, time: FrameNumber, new_value: str, sub_frame: float = 0.000000, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingStringKey:
        r"""
        x.add_key(time, new_value, sub_frame=0.000000, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneScriptingStringKey
        Add a key to this channel. This initializes a new key and returns a reference to it.
        
        Args:
            time (FrameNumber): The frame this key should go on. Respects TimeUnit to determine if it is a display rate frame or a tick resolution frame.
            new_value (str): The value that this key should be created with.
            sub_frame (float): Optional [0-1) clamped sub-frame to put this key on. Ignored if TimeUnit is set to Tick Resolution.
            time_unit (MovieSceneTimeUnit): Is the specified InTime in Display Rate frames or Tick Resolution.
        
        Returns:
            MovieSceneScriptingStringKey: The key that was created with the specified values at the specified time.
        """
        ...

class MovieSceneBindingExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto FMovieSceneBindingProxies for scripting
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneBindingExtensions.h
    
    """
    @classmethod
    def set_spawnable_binding_id(cls, binding: MovieSceneBindingProxy, spawnable_binding_id: MovieSceneObjectBindingID) -> None:
        r"""
        X.set_spawnable_binding_id(binding, spawnable_binding_id) -> None
        Set the spawnable id that the possessable binding should possess
        
        Args:
            binding (MovieSceneBindingProxy): The binding to set
            spawnable_binding_id (MovieSceneObjectBindingID): The spawnable's binding id
        """
        ...
    @classmethod
    def set_sorting_order(cls, binding: MovieSceneBindingProxy, sorting_order: int) -> None:
        r"""
        X.set_sorting_order(binding, sorting_order) -> None
        Set the sorting order for this binding
        
        Args:
            binding (MovieSceneBindingProxy): The binding to get the sorting order from
            sorting_order (int32): The sorting order to set
        """
        ...
    @classmethod
    def set_parent(cls, binding: MovieSceneBindingProxy, parent_binding: MovieSceneBindingProxy) -> None:
        r"""
        X.set_parent(binding, parent_binding) -> None
        Set the parent to this binding
        
        Args:
            binding (MovieSceneBindingProxy): The binding to set
            parent_binding (MovieSceneBindingProxy): The parent to set the InBinding to
        """
        ...
    @classmethod
    def set_name(cls, binding: MovieSceneBindingProxy, name: str) -> None:
        r"""
        X.set_name(binding, name) -> None
        Set this binding's object non-display name
        
        Args:
            binding (MovieSceneBindingProxy): The binding to get the name of
            name (str): The name of the binding
        """
        ...
    @classmethod
    def set_display_name(cls, binding: MovieSceneBindingProxy, display_name: Text) -> None:
        r"""
        X.set_display_name(binding, display_name) -> None
        Set this binding's name
        
        Args:
            binding (MovieSceneBindingProxy): The binding to get the name of
            display_name (Text):
        """
        ...
    @classmethod
    def remove_track(cls, binding: MovieSceneBindingProxy, track_to_remove: MovieSceneTrack) -> None:
        r"""
        X.remove_track(binding, track_to_remove) -> None
        Remove the specified track from this binding
        
        Args:
            binding (MovieSceneBindingProxy): The binding to remove the track from
            track_to_remove (MovieSceneTrack): The track to remove
        """
        ...
    @classmethod
    def remove(cls, binding: MovieSceneBindingProxy) -> None:
        r"""
        X.remove(binding) -> None
        Remove the specified binding
        
        Args:
            binding (MovieSceneBindingProxy): The binding to remove the track from
        """
        ...
    @classmethod
    def move_binding_contents(cls, source_binding_id: MovieSceneBindingProxy, destination_binding_id: MovieSceneBindingProxy) -> None:
        r"""
        X.move_binding_contents(source_binding_id, destination_binding_id) -> None
        Move all the contents (tracks, child bindings) of the specified binding ID onto another
        
        Args:
            source_binding_id (MovieSceneBindingProxy): The identifier of the binding ID to move all tracks and children from
            destination_binding_id (MovieSceneBindingProxy): The identifier of the binding ID to move the contents to
        """
        ...
    @classmethod
    def is_valid(cls, binding: MovieSceneBindingProxy) -> bool:
        r"""
        X.is_valid(binding) -> bool
        Check whether the specified binding is valid
        
        Args:
            binding (MovieSceneBindingProxy): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_tracks(cls, binding: MovieSceneBindingProxy) -> Array[MovieSceneTrack]:
        r"""
        X.get_tracks(binding) -> Array[MovieSceneTrack]
        Get all the tracks stored within this binding
        
        Args:
            binding (MovieSceneBindingProxy): The binding to find tracks in
        
        Returns:
            Array[MovieSceneTrack]: An array containing all the binding's tracks
        """
        ...
    @classmethod
    def get_sorting_order(cls, binding: MovieSceneBindingProxy) -> int:
        r"""
        X.get_sorting_order(binding) -> int32
        Get the sorting order for this binding
        
        Args:
            binding (MovieSceneBindingProxy): The binding to get the sorting order from
        
        Returns:
            int32: The sorting order of the requested binding
        """
        ...
    @classmethod
    def get_possessed_object_class(cls, binding: MovieSceneBindingProxy) -> Class:
        r"""
        X.get_possessed_object_class(binding) -> type(Class)
        Get this binding's possessed object class
        
        Args:
            binding (MovieSceneBindingProxy): The binding to get the possessed object class of
        
        Returns:
            type(Class): The possessed object class of the binding
        """
        ...
    @classmethod
    def get_parent(cls, binding: MovieSceneBindingProxy) -> MovieSceneBindingProxy:
        r"""
        X.get_parent(binding) -> MovieSceneBindingProxy
        Get the parent of this binding
        
        Args:
            binding (MovieSceneBindingProxy): The binding to get the parent of
        
        Returns:
            MovieSceneBindingProxy: The binding's parent
        """
        ...
    @classmethod
    def get_object_template(cls, binding: MovieSceneBindingProxy) -> Object:
        r"""
        X.get_object_template(binding) -> Object
        Get this binding's object template
        
        Args:
            binding (MovieSceneBindingProxy): The binding to get the object template of
        
        Returns:
            Object: The object template of the binding
        """
        ...
    @classmethod
    def get_name(cls, binding: MovieSceneBindingProxy) -> str:
        r"""
        X.get_name(binding) -> str
        Get this binding's object non-display name
        
        Args:
            binding (MovieSceneBindingProxy): The binding to get the name of
        
        Returns:
            str: The name of the binding
        """
        ...
    @classmethod
    def get_id(cls, binding: MovieSceneBindingProxy) -> Guid:
        r"""
        X.get_id(binding) -> Guid
        Get this binding's ID
        
        Args:
            binding (MovieSceneBindingProxy): The binding to get the ID of
        
        Returns:
            Guid: The guid that uniquely represents this binding
        """
        ...
    @classmethod
    def get_display_name(cls, binding: MovieSceneBindingProxy) -> Text:
        r"""
        X.get_display_name(binding) -> Text
        Get this binding's name
        
        Args:
            binding (MovieSceneBindingProxy): The binding to get the name of
        
        Returns:
            Text: The display name of the binding
        """
        ...
    @classmethod
    def get_child_possessables(cls, binding: MovieSceneBindingProxy) -> Array[MovieSceneBindingProxy]:
        r"""
        X.get_child_possessables(binding) -> Array[MovieSceneBindingProxy]
        Get all the children of this binding
        
        Args:
            binding (MovieSceneBindingProxy): The binding to to get children of
        
        Returns:
            Array[MovieSceneBindingProxy]: An array containing all the binding's children
        """
        ...
    @classmethod
    def find_tracks_by_type(cls, binding: MovieSceneBindingProxy, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        X.find_tracks_by_type(binding, track_type) -> Array[MovieSceneTrack]
        Find all tracks within a given binding of the specified type
        
        Args:
            binding (MovieSceneBindingProxy): The binding to find tracks in
            track_type (type(Class)): A UMovieSceneTrack class type specifying which types of track to return
        
        Returns:
            Array[MovieSceneTrack]: An array containing any tracks that match the type specified
        """
        ...
    @classmethod
    def find_tracks_by_exact_type(cls, binding: MovieSceneBindingProxy, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        X.find_tracks_by_exact_type(binding, track_type) -> Array[MovieSceneTrack]
        Find all tracks within a given binding of the specified type, not allowing sub-classed types
        
        Args:
            binding (MovieSceneBindingProxy): The binding to find tracks in
            track_type (type(Class)): A UMovieSceneTrack class type specifying the exact types of track to return
        
        Returns:
            Array[MovieSceneTrack]: An array containing any tracks that are exactly the same as the type specified
        """
        ...
    @classmethod
    def add_track(cls, binding: MovieSceneBindingProxy, track_type: Class) -> MovieSceneTrack:
        r"""
        X.add_track(binding, track_type) -> MovieSceneTrack
        Add a new track to the specified binding
        
        Args:
            binding (MovieSceneBindingProxy): The binding to add tracks to
            track_type (type(Class)): A UMovieSceneTrack class type specifying the type of track to create
        
        Returns:
            MovieSceneTrack: The newly created track, if successful
        """
        ...

class MovieSceneEventTrackExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto UMovieSceneEventTrack for scripting
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneEventTrackExtensions.h
    
    """
    @classmethod
    def get_bound_object_property_class(cls, event_key: MovieSceneEvent) -> Class:
        r"""
        X.get_bound_object_property_class(event_key) -> type(Class)
        * Return the class of the bound object property
        *
        *
        
        Args:
            event_key (MovieSceneEvent): The event key to get the bound object property from *
        
        Returns:
            type(Class): The class of the bound object property
        """
        ...
    @classmethod
    def add_event_trigger_section(cls, track: MovieSceneEventTrack) -> MovieSceneEventTriggerSection:
        r"""
        X.add_event_trigger_section(track) -> MovieSceneEventTriggerSection
        Create a new event trigger section for the given track
        
        Args:
            track (MovieSceneEventTrack): 
        
        Returns:
            MovieSceneEventTriggerSection: The newly created event trigger section
        """
        ...
    @classmethod
    def add_event_repeater_section(cls, track: MovieSceneEventTrack) -> MovieSceneEventRepeaterSection:
        r"""
        X.add_event_repeater_section(track) -> MovieSceneEventRepeaterSection
        Create a new event repeater section for the given track
        
        Args:
            track (MovieSceneEventTrack): 
        
        Returns:
            MovieSceneEventRepeaterSection: The newly created event repeater section
        """
        ...

class MovieSceneFolderExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto UMovieSceneFolders for scripting
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneFolderExtensions.h
    
    """
    @classmethod
    def set_folder_name(cls, folder: MovieSceneFolder, folder_name: Name) -> bool:
        r"""
        X.set_folder_name(folder, folder_name) -> bool
        Set the name of the given folder
        
        Args:
            folder (MovieSceneFolder): The folder to set the name of
            folder_name (Name): The new name for the folder
        
        Returns:
            bool: True if the setting of the folder name succeeds
        """
        ...
    @classmethod
    def set_folder_color(cls, folder: MovieSceneFolder, folder_color: Color) -> bool:
        r"""
        X.set_folder_color(folder, folder_color) -> bool
        Set the display color of the given folder
        
        Args:
            folder (MovieSceneFolder): The folder to set the display color of
            folder_color (Color): The new display color for the folder
        
        Returns:
            bool: True if the folder's display color is set successfully
        """
        ...
    @classmethod
    def remove_child_track(cls, folder: MovieSceneFolder, track: MovieSceneTrack) -> bool:
        r"""
        X.remove_child_track(folder, track) -> bool
        Remove a track from the given folder
        
        Args:
            folder (MovieSceneFolder): The folder from which to remove a track
            track (MovieSceneTrack): The track to remove
        
        Returns:
            bool: True if the removal succeeds
        """
        ...
    @classmethod
    def remove_child_object_binding(cls, folder: MovieSceneFolder, object_binding: MovieSceneBindingProxy) -> bool:
        r"""
        X.remove_child_object_binding(folder, object_binding) -> bool
        Remove an object binding from the given folder
        
        Args:
            folder (MovieSceneFolder): The folder from which to remove an object binding
            object_binding (MovieSceneBindingProxy): The object binding to remove
        
        Returns:
            bool: True if the operation succeeds
        """
        ...
    @classmethod
    def remove_child_master_track(cls, folder: MovieSceneFolder, track: MovieSceneTrack) -> bool:
        r"""
        X.remove_child_master_track(folder, track) -> bool
        Remove Child Master Track
        deprecated: RemoveChildMasterTrack is deprecated. Please use RemoveChildTrack instead
        
        Args:
            folder (MovieSceneFolder): 
            track (MovieSceneTrack): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def remove_child_folder(cls, target_folder: MovieSceneFolder, folder_to_remove: MovieSceneFolder) -> bool:
        r"""
        X.remove_child_folder(target_folder, folder_to_remove) -> bool
        Remove a child folder from the given folder
        
        Args:
            target_folder (MovieSceneFolder): The folder from which to remove a child folder
            folder_to_remove (MovieSceneFolder): The child folder to be removed
        
        Returns:
            bool: True if the removal succeeds
        """
        ...
    @classmethod
    def get_folder_name(cls, folder: MovieSceneFolder) -> Name:
        r"""
        X.get_folder_name(folder) -> Name
        Get the given folder's display name
        
        Args:
            folder (MovieSceneFolder): The folder to use
        
        Returns:
            Name: The target folder's name
        """
        ...
    @classmethod
    def get_folder_color(cls, folder: MovieSceneFolder) -> Color:
        r"""
        X.get_folder_color(folder) -> Color
        Get the display color of the given folder
        
        Args:
            folder (MovieSceneFolder): The folder to get the display color of
        
        Returns:
            Color: The display color of the given folder
        """
        ...
    @classmethod
    def get_child_tracks(cls, folder: MovieSceneFolder) -> Array[MovieSceneTrack]:
        r"""
        X.get_child_tracks(folder) -> Array[MovieSceneTrack]
        Get the tracks contained by this folder
        
        Args:
            folder (MovieSceneFolder): The folder to get the tracks of
        
        Returns:
            Array[MovieSceneTrack]: The tracks under the given folder
        """
        ...
    @classmethod
    def get_child_object_bindings(cls, folder: MovieSceneFolder) -> Array[MovieSceneBindingProxy]:
        r"""
        X.get_child_object_bindings(folder) -> Array[MovieSceneBindingProxy]
        Get the object bindings contained by this folder
        
        Args:
            folder (MovieSceneFolder): The folder to get the bindings of
        
        Returns:
            Array[MovieSceneBindingProxy]: The object bindings under the given folder
        """
        ...
    @classmethod
    def get_child_master_tracks(cls, folder: MovieSceneFolder) -> Array[MovieSceneTrack]:
        r"""
        X.get_child_master_tracks(folder) -> Array[MovieSceneTrack]
        Get Child Master Tracks
        deprecated: GetChildMasterTracks is deprecated. Please use GetChildTracks instead
        
        Args:
            folder (MovieSceneFolder): 
        
        Returns:
            Array[MovieSceneTrack]:
        """
        ...
    @classmethod
    def get_child_folders(cls, folder: MovieSceneFolder) -> Array[MovieSceneFolder]:
        r"""
        X.get_child_folders(folder) -> Array[MovieSceneFolder]
        Get the child folders of a given folder
        
        Args:
            folder (MovieSceneFolder): The folder to get the child folders of
        
        Returns:
            Array[MovieSceneFolder]: The child folders associated with the given folder
        """
        ...
    @classmethod
    def add_child_track(cls, folder: MovieSceneFolder, track: MovieSceneTrack) -> bool:
        r"""
        X.add_child_track(folder, track) -> bool
        Add a track to this folder
        
        Args:
            folder (MovieSceneFolder): The folder to add a child track to
            track (MovieSceneTrack): The track to add to the folder
        
        Returns:
            bool: True if the addition is successful
        """
        ...
    @classmethod
    def add_child_object_binding(cls, folder: MovieSceneFolder, object_binding: MovieSceneBindingProxy) -> bool:
        r"""
        X.add_child_object_binding(folder, object_binding) -> bool
        Add a guid for an object binding to this folder
        
        Args:
            folder (MovieSceneFolder): The folder to add a child object to
            object_binding (MovieSceneBindingProxy): The binding to add to the folder
        
        Returns:
            bool: True if the addition is successful
        """
        ...
    @classmethod
    def add_child_master_track(cls, folder: MovieSceneFolder, track: MovieSceneTrack) -> bool:
        r"""
        X.add_child_master_track(folder, track) -> bool
        Add Child Master Track
        deprecated: AddChildMasterTrack is deprecated. Please use AddChildTrack instead
        
        Args:
            folder (MovieSceneFolder): 
            track (MovieSceneTrack): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def add_child_folder(cls, target_folder: MovieSceneFolder, folder_to_add: MovieSceneFolder) -> bool:
        r"""
        X.add_child_folder(target_folder, folder_to_add) -> bool
        Add a child folder to the target folder
        
        Args:
            target_folder (MovieSceneFolder): The folder to add a child folder to
            folder_to_add (MovieSceneFolder): The child folder to be added
        
        Returns:
            bool: True if the addition is successful
        """
        ...

class MovieSceneMaterialTrackExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto UMovieSceneMaterialTrack for scripting
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneMaterialTrackExtensions.h
    
    """
    @classmethod
    def set_material_info(cls, track: MovieSceneComponentMaterialTrack, material_info: ComponentMaterialInfo) -> None:
        r"""
        X.set_material_info(track, material_info) -> None
        Set material info of the component that is animated by the material track.
        
        Args:
            track (MovieSceneComponentMaterialTrack): The track to use
            material_info (ComponentMaterialInfo): The desired material info to animate.
        """
        ...
    @classmethod
    def set_material_index(cls, track: MovieSceneComponentMaterialTrack, material_index: int) -> None:
        r"""
        X.set_material_index(track, material_index) -> None
        Set Material Index
        deprecated: Use SetMaterialInfo instead
        
        Args:
            track (MovieSceneComponentMaterialTrack): 
            material_index (int32):
        """
        ...
    @classmethod
    def get_material_info(cls, track: MovieSceneComponentMaterialTrack) -> ComponentMaterialInfo:
        r"""
        X.get_material_info(track) -> ComponentMaterialInfo
        Get material info of the component that is animated by the material track.
        deprecated: Use SetMaterialInfo instead
        
        Args:
            track (MovieSceneComponentMaterialTrack): The track to use
        
        Returns:
            ComponentMaterialInfo: The material info.
        """
        ...
    @classmethod
    def get_material_index(cls, track: MovieSceneComponentMaterialTrack) -> int:
        r"""
        X.get_material_index(track) -> int32
        Get Material Index
        deprecated: Use SetMaterialInfo instead
        
        Args:
            track (MovieSceneComponentMaterialTrack): 
        
        Returns:
            int32:
        """
        ...

class MovieScenePrimitiveMaterialTrackExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto UMovieScenePrimitiveMaterialTrack for scripting
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieScenePrimitiveMaterialTrackExtensions.h
    
    """
    @classmethod
    def set_material_info(cls, track: MovieScenePrimitiveMaterialTrack, material_info: ComponentMaterialInfo) -> None:
        r"""
        X.set_material_info(track, material_info) -> None
        Set material info of the component that is animated by the material track.
        
        Args:
            track (MovieScenePrimitiveMaterialTrack): The track to use
            material_info (ComponentMaterialInfo): The desired material info to animate.
        """
        ...
    @classmethod
    def set_material_index(cls, track: MovieScenePrimitiveMaterialTrack, material_index: int) -> None:
        r"""
        X.set_material_index(track, material_index) -> None
        Set Material Index
        deprecated: Use SetMaterialInfo instead
        
        Args:
            track (MovieScenePrimitiveMaterialTrack): 
            material_index (int32):
        """
        ...
    @classmethod
    def get_material_info(cls, track: MovieScenePrimitiveMaterialTrack) -> ComponentMaterialInfo:
        r"""
        X.get_material_info(track) -> ComponentMaterialInfo
        Get material info of the component that is animated by the material track.
        deprecated: Use SetMaterialInfo instead
        
        Args:
            track (MovieScenePrimitiveMaterialTrack): The track to use
        
        Returns:
            ComponentMaterialInfo: The material info.
        """
        ...
    @classmethod
    def get_material_index(cls, track: MovieScenePrimitiveMaterialTrack) -> int:
        r"""
        X.get_material_index(track) -> int32
        Get Material Index
        deprecated: Use SetMaterialInfo instead
        
        Args:
            track (MovieScenePrimitiveMaterialTrack): 
        
        Returns:
            int32:
        """
        ...

class MovieScenePropertyTrackExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto UMovieScenePropertyTrack for scripting
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieScenePropertyTrackExtensions.h
    
    """
    @classmethod
    def set_property_name_and_path(cls, track: MovieScenePropertyTrack, property_name: Name, property_path: str) -> None:
        r"""
        X.set_property_name_and_path(track, property_name, property_path) -> None
        Set this track's property name and path
        
        Args:
            track (MovieScenePropertyTrack): The track to use
            property_name (Name): The property name
            property_path (str): The property path
        """
        ...
    @classmethod
    def set_object_property_class(cls, track: MovieSceneObjectPropertyTrack, property_class: Class) -> None:
        r"""
        X.set_object_property_class(track, property_class) -> None
        Set this object property track's property class
        
        Args:
            track (MovieSceneObjectPropertyTrack): The track to use
            property_class (type(Class)): The property class to set
        """
        ...
    @classmethod
    def set_byte_track_enum(cls, track: MovieSceneByteTrack, enum: Enum) -> None:
        r"""
        X.set_byte_track_enum(track, enum) -> None
        Set this byte track's enum
        
        Args:
            track (MovieSceneByteTrack): The track to use
            enum (Enum): The enum to set
        """
        ...
    @classmethod
    def get_unique_track_name(cls, track: MovieScenePropertyTrack) -> Name:
        r"""
        X.get_unique_track_name(track) -> Name
        Get this track's unique name
        
        Args:
            track (MovieScenePropertyTrack): The track to use
        
        Returns:
            Name: This track's unique name
        """
        ...
    @classmethod
    def get_property_path(cls, track: MovieScenePropertyTrack) -> str:
        r"""
        X.get_property_path(track) -> str
        Get this track's property path
        
        Args:
            track (MovieScenePropertyTrack): The track to use
        
        Returns:
            str: This track's property path
        """
        ...
    @classmethod
    def get_property_name(cls, track: MovieScenePropertyTrack) -> Name:
        r"""
        X.get_property_name(track) -> Name
        Get this track's property name
        
        Args:
            track (MovieScenePropertyTrack): The track to use
        
        Returns:
            Name: This track's property name
        """
        ...
    @classmethod
    def get_object_property_class(cls, track: MovieSceneObjectPropertyTrack) -> Class:
        r"""
        X.get_object_property_class(track) -> type(Class)
        Get this object property track's property class
        
        Args:
            track (MovieSceneObjectPropertyTrack): The track to use
        
        Returns:
            type(Class): The property class for this object property track
        """
        ...
    @classmethod
    def get_byte_track_enum(cls, track: MovieSceneByteTrack) -> Enum:
        r"""
        X.get_byte_track_enum(track) -> Enum
        Get this byte track's enum
        
        Args:
            track (MovieSceneByteTrack): The track to use
        
        Returns:
            Enum: The enum for this byte track
        """
        ...

class MovieSceneSectionExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto UMovieSceneSections for scripting
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneSectionExtensions.h
    
    """
    @classmethod
    def set_start_frame_seconds(cls, section: MovieSceneSection, start_time: float) -> None:
        r"""
        X.set_start_frame_seconds(section, start_time) -> None
        Set start time in seconds
        
        Args:
            section (MovieSceneSection): The section within which to set the start time
            start_time (float): The desired start time for this section
        """
        ...
    @classmethod
    def set_start_frame_bounded(cls, section: MovieSceneSection, is_bounded: bool) -> None:
        r"""
        X.set_start_frame_bounded(section, is_bounded) -> None
        Set start frame bounded
        
        Args:
            section (MovieSceneSection): The section to set whether the start frame is bounded or not
            is_bounded (bool):
        """
        ...
    @classmethod
    def set_start_frame(cls, section: MovieSceneSection, start_frame: int) -> None:
        r"""
        X.set_start_frame(section, start_frame) -> None
        Set start frame
        
        Args:
            section (MovieSceneSection): The section within which to set the start frame
            start_frame (int32): The desired start frame for this section
        """
        ...
    @classmethod
    def set_range_seconds(cls, section: MovieSceneSection, start_time: float, end_time: float) -> None:
        r"""
        X.set_range_seconds(section, start_time, end_time) -> None
        Set range in seconds
        
        Args:
            section (MovieSceneSection): The section within which to set the range
            start_time (float): The desired start frame for this section
            end_time (float): The desired end frame for this section
        """
        ...
    @classmethod
    def set_range(cls, section: MovieSceneSection, start_frame: int, end_frame: int) -> None:
        r"""
        X.set_range(section, start_frame, end_frame) -> None
        Set range
        
        Args:
            section (MovieSceneSection): The section within which to set the range
            start_frame (int32): The desired start frame for this section
            end_frame (int32): The desired end frame for this section
        """
        ...
    @classmethod
    def set_end_frame_seconds(cls, section: MovieSceneSection, end_time: float) -> None:
        r"""
        X.set_end_frame_seconds(section, end_time) -> None
        Set end time in seconds
        
        Args:
            section (MovieSceneSection): The section within which to set the end time
            end_time (float): The desired end time for this section
        """
        ...
    @classmethod
    def set_end_frame_bounded(cls, section: MovieSceneSection, is_bounded: bool) -> None:
        r"""
        X.set_end_frame_bounded(section, is_bounded) -> None
        Set end frame bounded
        
        Args:
            section (MovieSceneSection): The section to set whether the end frame is bounded or not
            is_bounded (bool):
        """
        ...
    @classmethod
    def set_end_frame(cls, section: MovieSceneSection, end_frame: int) -> None:
        r"""
        X.set_end_frame(section, end_frame) -> None
        Set end frame
        
        Args:
            section (MovieSceneSection): The section within which to set the end frame
            end_frame (int32): The desired start frame for this section
        """
        ...
    @classmethod
    def has_start_frame(cls, section: MovieSceneSection) -> bool:
        r"""
        X.has_start_frame(section) -> bool
        Has start frame
        
        Args:
            section (MovieSceneSection): The section being queried
        
        Returns:
            bool: Whether this section has a valid start frame (else infinite)
        """
        ...
    @classmethod
    def has_end_frame(cls, section: MovieSceneSection) -> bool:
        r"""
        X.has_end_frame(section) -> bool
        Has end frame
        
        Args:
            section (MovieSceneSection): The section being queried
        
        Returns:
            bool: Whether this section has a valid end frame (else infinite)
        """
        ...
    @classmethod
    def get_start_frame_seconds(cls, section: MovieSceneSection) -> float:
        r"""
        X.get_start_frame_seconds(section) -> float
        Get start time in seconds. Will throw an exception if section has no start frame, use HasStartFrame to check first.
        
        Args:
            section (MovieSceneSection): The section within which to get the start time
        
        Returns:
            float: Start time of this section
        """
        ...
    @classmethod
    def get_start_frame(cls, section: MovieSceneSection) -> int:
        r"""
        X.get_start_frame(section) -> int32
        Get start frame. Will throw an exception if section has no start frame, use HasStartFrame to check first.
        
        Args:
            section (MovieSceneSection): The section within which to get the start frame
        
        Returns:
            int32: Start frame of this section
        """
        ...
    @classmethod
    def get_parent_sequence_frame(cls, section: MovieSceneSubSection, frame: int, parent_sequence: MovieSceneSequence) -> int:
        r"""
        X.get_parent_sequence_frame(section, frame, parent_sequence) -> int32
        Get the frame in the space of its parent sequence
        
        Args:
            section (MovieSceneSubSection): The section that the InFrame is local to
            frame (int32): The desired local frame
            parent_sequence (MovieSceneSequence): The parent sequence to traverse from
        
        Returns:
            int32: The frame at the parent sequence
        """
        ...
    @classmethod
    def get_end_frame_seconds(cls, section: MovieSceneSection) -> float:
        r"""
        X.get_end_frame_seconds(section) -> float
        Get end time in seconds. Will throw an exception if section has no end frame, use HasEndFrame to check first.
        
        Args:
            section (MovieSceneSection): The section within which to get the end time
        
        Returns:
            float: End time of this section
        """
        ...
    @classmethod
    def get_end_frame(cls, section: MovieSceneSection) -> int:
        r"""
        X.get_end_frame(section) -> int32
        Get end frame. Will throw an exception if section has no end frame, use HasEndFrame to check first.
        
        Args:
            section (MovieSceneSection): The section within which to get the end frame
        
        Returns:
            int32: End frame of this section
        """
        ...
    @classmethod
    def get_channels_by_type(cls, section: MovieSceneSection, channel_type: Class) -> Array[MovieSceneScriptingChannel]:
        r"""
        X.get_channels_by_type(section, channel_type) -> Array[MovieSceneScriptingChannel]
        Find all channels that belong to the specified UMovieSceneSection that match the specific type. This will filter out any children who do not inherit
        from the specified type for you.
        
        Args:
            section (MovieSceneSection): The section to use.
            channel_type (type(Class)): The class type to look for.
        
        Returns:
            Array[MovieSceneScriptingChannel]: An array containing any key channels that match the type specified
        """
        ...
    @classmethod
    def get_channel(cls, section: MovieSceneSection, channel_name: Name) -> MovieSceneScriptingChannel:
        r"""
        X.get_channel(section, channel_name) -> MovieSceneScriptingChannel
        Get channel from specified section and channel name
        
        Args:
            section (MovieSceneSection): The section to use.
            channel_name (Name): The name of the channel.
        
        Returns:
            MovieSceneScriptingChannel: The channel if it exists
        """
        ...
    @classmethod
    def get_auto_size_start_frame_seconds(cls, section: MovieSceneSection) -> float:
        r"""
        X.get_auto_size_start_frame_seconds(section) -> float
        Get start time of the AutoSize in seconds. Will throw an exception if section has no start frame, use GetAutoSizeHasStartFrame to check first.
        
        Args:
            section (MovieSceneSection): The section being queried
        
        Returns:
            float: The start frame of the AutoSize data in seconds.
        """
        ...
    @classmethod
    def get_auto_size_start_frame(cls, section: MovieSceneSection) -> int:
        r"""
        X.get_auto_size_start_frame(section) -> int32
        Get start frame of the AutoSize. Will throw an exception if section has no start frame, use GetAutoSizeHasStartFrame to check first.
        
        Args:
            section (MovieSceneSection): The section being queried
        
        Returns:
            int32: The start frame of the AutoSize data.
        """
        ...
    @classmethod
    def get_auto_size_has_start_frame(cls, section: MovieSceneSection) -> bool:
        r"""
        X.get_auto_size_has_start_frame(section) -> bool
        Checks to see if this section has an AutoSize implementation, and if so, if that implementation has a start frame.
        
        Args:
            section (MovieSceneSection): The section being queried
        
        Returns:
            bool: Whether this section has a valid autosize range, and a valid start frame
        """
        ...
    @classmethod
    def get_auto_size_has_end_frame(cls, section: MovieSceneSection) -> bool:
        r"""
        X.get_auto_size_has_end_frame(section) -> bool
        Checks to see if this section has an AutoSize implementation, and if so, if that implementation has a end frame.
        
        Args:
            section (MovieSceneSection): The section being queried
        
        Returns:
            bool: Whether this section has a valid autosize range, and a valid end frame
        """
        ...
    @classmethod
    def get_auto_size_end_frame_seconds(cls, section: MovieSceneSection) -> float:
        r"""
        X.get_auto_size_end_frame_seconds(section) -> float
        Get end time of the AutoSize seconds. Will throw an exception if section has no end frame, use GetAutoSizeHasEndFrame to check first.
        
        Args:
            section (MovieSceneSection): The section being queried
        
        Returns:
            float: The end frame of the AutoSize data in seconds.
        """
        ...
    @classmethod
    def get_auto_size_end_frame(cls, section: MovieSceneSection) -> int:
        r"""
        X.get_auto_size_end_frame(section) -> int32
        Get end frame of the AutoSize. Will throw an exception if section has no end frame, use GetAutoSizeHasEndFrame to check first.
        
        Args:
            section (MovieSceneSection): The section being queried
        
        Returns:
            int32: The end frame of the AutoSize data.
        """
        ...
    @classmethod
    def get_all_channels(cls, section: MovieSceneSection) -> Array[MovieSceneScriptingChannel]:
        r"""
        X.get_all_channels(section) -> Array[MovieSceneScriptingChannel]
        Find all channels that belong to the specified UMovieSceneSection. Some sections have many channels (such as
        Transforms containing 9 double channels to represent Translation/Rotation/Scale), and a section may have mixed
        channel types.
        
        Args:
            section (MovieSceneSection): The section to use.
        
        Returns:
            Array[MovieSceneScriptingChannel]: An array containing any key channels that match the type specified
        """
        ...

class MovieSceneSequenceExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto UMovieSceneSequences for scripting purposes
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneSequenceExtensions.h
    
    """
    @classmethod
    def sort_marked_frames(cls, sequence: MovieSceneSequence) -> None:
        r"""
        X.sort_marked_frames(sequence) -> None
        * Sort the marked frames in chronological order
        
        Args:
            sequence (MovieSceneSequence):
        """
        ...
    @classmethod
    def set_work_range_start(cls, sequence: MovieSceneSequence, start_time_in_seconds: float) -> None:
        r"""
        X.set_work_range_start(sequence, start_time_in_seconds) -> None
        Set the sequence work range start in seconds
        
        Args:
            sequence (MovieSceneSequence): 
            start_time_in_seconds (double): The desired work range start time in seconds for this sequence
        """
        ...
    @classmethod
    def set_work_range_end(cls, sequence: MovieSceneSequence, end_time_in_seconds: float) -> None:
        r"""
        X.set_work_range_end(sequence, end_time_in_seconds) -> None
        Set the sequence work range end in seconds
        
        Args:
            sequence (MovieSceneSequence): 
            end_time_in_seconds (double):
        """
        ...
    @classmethod
    def set_view_range_start(cls, sequence: MovieSceneSequence, start_time_in_seconds: float) -> None:
        r"""
        X.set_view_range_start(sequence, start_time_in_seconds) -> None
        Set the sequence view range start in seconds
        
        Args:
            sequence (MovieSceneSequence): 
            start_time_in_seconds (double): The desired view range start time in seconds for this sequence
        """
        ...
    @classmethod
    def set_view_range_end(cls, sequence: MovieSceneSequence, end_time_in_seconds: float) -> None:
        r"""
        X.set_view_range_end(sequence, end_time_in_seconds) -> None
        Set the sequence view range end in seconds
        
        Args:
            sequence (MovieSceneSequence): 
            end_time_in_seconds (double):
        """
        ...
    @classmethod
    def set_tick_resolution_directly(cls, sequence: MovieSceneSequence, tick_resolution: FrameRate) -> None:
        r"""
        X.set_tick_resolution_directly(sequence, tick_resolution) -> None
        Sets this sequence's tick resolution directly without migrating frame times
        
        Args:
            sequence (MovieSceneSequence): The sequence to use
            tick_resolution (FrameRate): The tick resolution of the sequence, defining the smallest unit of time representable on this sequence
        """
        ...
    @classmethod
    def set_tick_resolution(cls, sequence: MovieSceneSequence, tick_resolution: FrameRate) -> None:
        r"""
        X.set_tick_resolution(sequence, tick_resolution) -> None
        Sets this sequence's tick resolution and migrates frame times
        
        Args:
            sequence (MovieSceneSequence): The sequence to use
            tick_resolution (FrameRate): The tick resolution of the sequence, defining the smallest unit of time representable on this sequence
        """
        ...
    @classmethod
    def set_read_only(cls, sequence: MovieSceneSequence, read_only: bool) -> None:
        r"""
        X.set_read_only(sequence, read_only) -> None
        * Set read only
        *
        *
        bInReadOnly: Whether the movie scene should be read only or not
        
        Args:
            sequence (MovieSceneSequence): 
            read_only (bool):
        """
        ...
    @classmethod
    def set_playback_start_seconds(cls, sequence: MovieSceneSequence, start_time: float) -> None:
        r"""
        X.set_playback_start_seconds(sequence, start_time) -> None
        Set playback start of this sequence in seconds
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to set the playback start
            start_time (float): The desired start time in seconds for this sequence
        """
        ...
    @classmethod
    def set_playback_start(cls, sequence: MovieSceneSequence, start_frame: int) -> None:
        r"""
        X.set_playback_start(sequence, start_frame) -> None
        Set playback start of this sequence
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to set the playback start
            start_frame (int32): The desired start frame for this sequence
        """
        ...
    @classmethod
    def set_playback_range_locked(cls, sequence: MovieSceneSequence, locked: bool) -> None:
        r"""
        X.set_playback_range_locked(sequence, locked) -> None
        * Set playback range locked
        *
        *
        bInLocked: Whether the movie scene playback range should be locked
        
        Args:
            sequence (MovieSceneSequence): 
            locked (bool):
        """
        ...
    @classmethod
    def set_playback_end_seconds(cls, sequence: MovieSceneSequence, end_time: float) -> None:
        r"""
        X.set_playback_end_seconds(sequence, end_time) -> None
        Set playback end of this sequence in seconds
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to set the playback end
            end_time (float): The desired end time in seconds for this sequence
        """
        ...
    @classmethod
    def set_playback_end(cls, sequence: MovieSceneSequence, end_frame: int) -> None:
        r"""
        X.set_playback_end(sequence, end_frame) -> None
        Set playback end of this sequence
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to set the playback end
            end_frame (int32): The desired end frame for this sequence
        """
        ...
    @classmethod
    def set_marked_frames_locked(cls, sequence: MovieSceneSequence, locked: bool) -> None:
        r"""
        X.set_marked_frames_locked(sequence, locked) -> None
        * Set marked frames locked
        *
        *
        bInLocked: Whether the movie scene marked frames should be locked
        
        Args:
            sequence (MovieSceneSequence): 
            locked (bool):
        """
        ...
    @classmethod
    def set_marked_frame_in_sequence(cls, sequence: MovieSceneSequence, mark_index: int, frame_number: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_marked_frame_in_sequence(sequence, mark_index, frame_number, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        * Sets the frame number for the given marked frame index. Does not maintain sort. Call SortMarkedFrames
        *
        *
        InMarkIndex: The given user marked frame index to edit *
        InFrameNumber: The frame number to set
        
        Args:
            sequence (MovieSceneSequence): 
            mark_index (int32): 
            frame_number (FrameNumber): 
            time_unit (MovieSceneTimeUnit):
        """
        ...
    @classmethod
    def set_marked_frame(cls, sequence: MovieSceneSequence, mark_index: int, frame_number: FrameNumber) -> None:
        r"""
        X.set_marked_frame(sequence, mark_index, frame_number) -> None
        Set Marked Frame
        deprecated: SetMarkedFrame is deprecated. Please use SetMarkedFrame that takes a time unit instead
        
        Args:
            sequence (MovieSceneSequence): 
            mark_index (int32): 
            frame_number (FrameNumber):
        """
        ...
    @classmethod
    def set_evaluation_type(cls, sequence: MovieSceneSequence, evaluation_type: MovieSceneEvaluationType) -> None:
        r"""
        X.set_evaluation_type(sequence, evaluation_type) -> None
        Set the evaluation type for this sequence
        
        Args:
            sequence (MovieSceneSequence): 
            evaluation_type (MovieSceneEvaluationType): The evaluation type to set for this sequence
        """
        ...
    @classmethod
    def set_display_rate(cls, sequence: MovieSceneSequence, display_rate: FrameRate) -> None:
        r"""
        X.set_display_rate(sequence, display_rate) -> None
        Sets this sequence's display rate
        
        Args:
            sequence (MovieSceneSequence): The sequence to use
            display_rate (FrameRate): The display rate that this sequence is displayed as
        """
        ...
    @classmethod
    def set_clock_source(cls, sequence: MovieSceneSequence, clock_source: UpdateClockSource) -> None:
        r"""
        X.set_clock_source(sequence, clock_source) -> None
        Set the clock source for this sequence
        
        Args:
            sequence (MovieSceneSequence): 
            clock_source (UpdateClockSource): The clock source to set for this sequence
        """
        ...
    @classmethod
    def resolve_binding_id(cls, root_sequence: MovieSceneSequence, object_binding_id: MovieSceneObjectBindingID) -> MovieSceneBindingProxy:
        r"""
        X.resolve_binding_id(root_sequence, object_binding_id) -> MovieSceneBindingProxy
        Make a binding for the given binding ID
        
        Args:
            root_sequence (MovieSceneSequence): The root sequence that contains the sequence
            object_binding_id (MovieSceneObjectBindingID): 
        
        Returns:
            MovieSceneBindingProxy: The new binding proxy
        """
        ...
    @classmethod
    def remove_track(cls, sequence: MovieSceneSequence, track: MovieSceneTrack) -> bool:
        r"""
        X.remove_track(sequence, track) -> bool
        Removes a track
        
        Args:
            sequence (MovieSceneSequence): The sequence to use
            track (MovieSceneTrack): The track to remove
        
        Returns:
            bool: Whether the track was successfully removed
        """
        ...
    @classmethod
    def remove_root_folder_from_sequence(cls, sequence: MovieSceneSequence, folder: MovieSceneFolder) -> None:
        r"""
        X.remove_root_folder_from_sequence(sequence, folder) -> None
        Remove a root folder from the given sequence. Will throw an exception if the specified folder is not valid or not a root folder.
        
        Args:
            sequence (MovieSceneSequence): The sequence That the folder belongs to
            folder (MovieSceneFolder): The folder to remove
        """
        ...
    @classmethod
    def remove_master_track(cls, sequence: MovieSceneSequence, track: MovieSceneTrack) -> bool:
        r"""
        X.remove_master_track(sequence, track) -> bool
        Remove Master Track
        deprecated: RemoveMasterTrack is deprecated. Please use RemoveTrack instead
        
        Args:
            sequence (MovieSceneSequence): 
            track (MovieSceneTrack): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def make_range_seconds(cls, sequence: MovieSceneSequence, start_time: float, duration: float) -> SequencerScriptingRange:
        r"""
        X.make_range_seconds(sequence, start_time, duration) -> SequencerScriptingRange
        Make a new range for this sequence in seconds
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to find the binding
            start_time (float): The time in seconds at which to start the range
            duration (float): The length of the range in seconds
        
        Returns:
            SequencerScriptingRange: Specified sequencer range
        """
        ...
    @classmethod
    def make_range(cls, sequence: MovieSceneSequence, start_frame: int, duration: int) -> SequencerScriptingRange:
        r"""
        X.make_range(sequence, start_frame, duration) -> SequencerScriptingRange
        Make a new range for this sequence in its display rate
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to find the binding
            start_frame (int32): The frame at which to start the range
            duration (int32): The length of the range
        
        Returns:
            SequencerScriptingRange: Specified sequencer range
        """
        ...
    @classmethod
    def locate_bound_objects(cls, sequence: MovieSceneSequence, binding: MovieSceneBindingProxy, context: Object) -> Array[Object]:
        r"""
        X.locate_bound_objects(sequence, binding, context) -> Array[Object]
        Locate all the objects that correspond to the specified object ID, using the specified context
        
        Args:
            sequence (MovieSceneSequence): The sequence to locate bound objects for
            binding (MovieSceneBindingProxy): The object binding
            context (Object): Optional context to use to find the required object
        
        Returns:
            Array[Object]: An array of all bound objects
        """
        ...
    @classmethod
    def is_read_only(cls, sequence: MovieSceneSequence) -> bool:
        r"""
        X.is_read_only(sequence) -> bool
        * Is read only
        *
        *
        
        Args:
            sequence (MovieSceneSequence): 
        
        Returns:
            bool: Whether the movie scene is read only or not
        """
        ...
    @classmethod
    def is_playback_range_locked(cls, sequence: MovieSceneSequence) -> bool:
        r"""
        X.is_playback_range_locked(sequence) -> bool
        * Is playback ranged locked
        *
        *
        
        Args:
            sequence (MovieSceneSequence): 
        
        Returns:
            bool: Whether the movie scene playback range is locked
        """
        ...
    @classmethod
    def get_work_range_start(cls, sequence: MovieSceneSequence) -> float:
        r"""
        X.get_work_range_start(sequence) -> double
        Get the sequence work range start in seconds
        
        Args:
            sequence (MovieSceneSequence): 
        
        Returns:
            double: The work range start time in seconds for this sequence
        """
        ...
    @classmethod
    def get_work_range_end(cls, sequence: MovieSceneSequence) -> float:
        r"""
        X.get_work_range_end(sequence) -> double
        Get the sequence work range end in seconds
        
        Args:
            sequence (MovieSceneSequence): 
        
        Returns:
            double: The work range end time in seconds for this sequence
        """
        ...
    @classmethod
    def get_view_range_start(cls, sequence: MovieSceneSequence) -> float:
        r"""
        X.get_view_range_start(sequence) -> double
        Get the sequence view range start in seconds
        
        Args:
            sequence (MovieSceneSequence): 
        
        Returns:
            double: The view range start time in seconds for this sequence
        """
        ...
    @classmethod
    def get_view_range_end(cls, sequence: MovieSceneSequence) -> float:
        r"""
        X.get_view_range_end(sequence) -> double
        Get the sequence view range end in seconds
        
        Args:
            sequence (MovieSceneSequence): 
        
        Returns:
            double: The view range end time in seconds for this sequence
        """
        ...
    @classmethod
    def get_tracks(cls, sequence: MovieSceneSequence) -> Array[MovieSceneTrack]:
        r"""
        X.get_tracks(sequence) -> Array[MovieSceneTrack]
        Get all tracks
        
        Args:
            sequence (MovieSceneSequence): The sequence to use
        
        Returns:
            Array[MovieSceneTrack]: An array containing all tracks in this sequence
        """
        ...
    @classmethod
    def get_tick_resolution(cls, sequence: MovieSceneSequence) -> FrameRate:
        r"""
        X.get_tick_resolution(sequence) -> FrameRate
        Gets this sequence's tick resolution
        
        Args:
            sequence (MovieSceneSequence): The sequence to use
        
        Returns:
            FrameRate: The tick resolution of the sequence, defining the smallest unit of time representable on this sequence
        """
        ...
    @classmethod
    def get_spawnables(cls, sequence: MovieSceneSequence) -> Array[MovieSceneBindingProxy]:
        r"""
        X.get_spawnables(sequence) -> Array[MovieSceneBindingProxy]
        Get all the spawnables in this sequence
        
        Args:
            sequence (MovieSceneSequence): The sequence to get spawnables for
        
        Returns:
            Array[MovieSceneBindingProxy]: Spawnables in this sequence
        """
        ...
    @classmethod
    def get_root_folders_in_sequence(cls, sequence: MovieSceneSequence) -> Array[MovieSceneFolder]:
        r"""
        X.get_root_folders_in_sequence(sequence) -> Array[MovieSceneFolder]
        Get the root folders in the provided sequence
        
        Args:
            sequence (MovieSceneSequence): The sequence to retrieve folders from
        
        Returns:
            Array[MovieSceneFolder]: The folders contained within the given sequence
        """
        ...
    @classmethod
    def get_possessables(cls, sequence: MovieSceneSequence) -> Array[MovieSceneBindingProxy]:
        r"""
        X.get_possessables(sequence) -> Array[MovieSceneBindingProxy]
        Get all the possessables in this sequence
        
        Args:
            sequence (MovieSceneSequence): The sequence to get possessables for
        
        Returns:
            Array[MovieSceneBindingProxy]: Possessables in this sequence
        """
        ...
    @classmethod
    def get_portable_binding_id(cls, root_sequence: MovieSceneSequence, destination_sequence: MovieSceneSequence, binding: MovieSceneBindingProxy) -> MovieSceneObjectBindingID:
        r"""
        X.get_portable_binding_id(root_sequence, destination_sequence, binding) -> MovieSceneObjectBindingID
        Get a portable binding ID for a binding that resides in a different sequence to the one where this binding will be resolved.
        note:: This function must be used over GetBindingID when the target binding resides in different shots or sub-sequences.
        note:: Only unique instances of sequences within a root sequences are supported
        
        Args:
            root_sequence (MovieSceneSequence): The root sequence that contains both the destination sequence (that will resolve the binding ID) and the target sequence that contains the actual binding
            destination_sequence (MovieSceneSequence): The sequence that will own or resolve the resulting binding ID. For example, if the binding ID will be applied to a camera cut section pass the sequence that contains the camera cut track to this parameter.
            binding (MovieSceneBindingProxy): 
        
        Returns:
            MovieSceneObjectBindingID: The binding's id
        """
        ...
    @classmethod
    def get_playback_start_seconds(cls, sequence: MovieSceneSequence) -> float:
        r"""
        X.get_playback_start_seconds(sequence) -> float
        Get playback start of this sequence in seconds
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to get the playback start
        
        Returns:
            float: Playback start of this sequence
        """
        ...
    @classmethod
    def get_playback_start(cls, sequence: MovieSceneSequence) -> int:
        r"""
        X.get_playback_start(sequence) -> int32
        Get playback start of this sequence in display rate resolution
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to get the playback start
        
        Returns:
            int32: Playback start of this sequence
        """
        ...
    @classmethod
    def get_playback_range(cls, sequence: MovieSceneSequence) -> SequencerScriptingRange:
        r"""
        X.get_playback_range(sequence) -> SequencerScriptingRange
        Get playback range of this sequence in display rate resolution
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to get the playback range
        
        Returns:
            SequencerScriptingRange: Playback range of this sequence
        """
        ...
    @classmethod
    def get_playback_end_seconds(cls, sequence: MovieSceneSequence) -> float:
        r"""
        X.get_playback_end_seconds(sequence) -> float
        Get playback end of this sequence in seconds
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to get the playback end
        
        Returns:
            float: Playback end of this sequence
        """
        ...
    @classmethod
    def get_playback_end(cls, sequence: MovieSceneSequence) -> int:
        r"""
        X.get_playback_end(sequence) -> int32
        Get playback end of this sequence in display rate resolution
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to get the playback end
        
        Returns:
            int32: Playback end of this sequence
        """
        ...
    @classmethod
    def get_movie_scene(cls, sequence: MovieSceneSequence) -> MovieScene:
        r"""
        X.get_movie_scene(sequence) -> MovieScene
        Get this sequence's movie scene data
        
        Args:
            sequence (MovieSceneSequence): The sequence to use
        
        Returns:
            MovieScene: This sequence's movie scene data object
        """
        ...
    @classmethod
    def get_master_tracks(cls, sequence: MovieSceneSequence) -> Array[MovieSceneTrack]:
        r"""
        X.get_master_tracks(sequence) -> Array[MovieSceneTrack]
        Get Master Tracks
        deprecated: GetMasterTracks is deprecated. Please use GetTracks instead
        
        Args:
            sequence (MovieSceneSequence): 
        
        Returns:
            Array[MovieSceneTrack]:
        """
        ...
    @classmethod
    def get_marked_frames_from_sequence(cls, sequence: MovieSceneSequence, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[MovieSceneMarkedFrame]:
        r"""
        X.get_marked_frames_from_sequence(sequence, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[MovieSceneMarkedFrame]
        * Get the marked frames for this sequence
        *
        *
        
        Args:
            sequence (MovieSceneSequence): 
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            Array[MovieSceneMarkedFrame]: Return the user marked frames
        """
        ...
    @classmethod
    def get_marked_frames(cls, sequence: MovieSceneSequence) -> Array[MovieSceneMarkedFrame]:
        r"""
        X.get_marked_frames(sequence) -> Array[MovieSceneMarkedFrame]
        Get Marked Frames
        deprecated: GetMarkedFrames is deprecated. Please use GetMarkedFrames that takes a time unit instead
        
        Args:
            sequence (MovieSceneSequence): 
        
        Returns:
            Array[MovieSceneMarkedFrame]:
        """
        ...
    @classmethod
    def get_evaluation_type(cls, sequence: MovieSceneSequence) -> MovieSceneEvaluationType:
        r"""
        X.get_evaluation_type(sequence) -> MovieSceneEvaluationType
        Get the evaluation type for this sequence
        
        Args:
            sequence (MovieSceneSequence): 
        
        Returns:
            MovieSceneEvaluationType: The evaluation type for this sequence
        """
        ...
    @classmethod
    def get_display_rate(cls, sequence: MovieSceneSequence) -> FrameRate:
        r"""
        X.get_display_rate(sequence) -> FrameRate
        Gets this sequence's display rate
        
        Args:
            sequence (MovieSceneSequence): The sequence to use
        
        Returns:
            FrameRate: The display rate that this sequence is displayed as
        """
        ...
    @classmethod
    def get_clock_source(cls, sequence: MovieSceneSequence) -> UpdateClockSource:
        r"""
        X.get_clock_source(sequence) -> UpdateClockSource
        Get the clock source for this sequence
        
        Args:
            sequence (MovieSceneSequence): 
        
        Returns:
            UpdateClockSource: The clock source for this sequence
        """
        ...
    @classmethod
    def get_bindings(cls, sequence: MovieSceneSequence) -> Array[MovieSceneBindingProxy]:
        r"""
        X.get_bindings(sequence) -> Array[MovieSceneBindingProxy]
        Get all the bindings in this sequence
        
        Args:
            sequence (MovieSceneSequence): The sequence to get bindings for
        
        Returns:
            Array[MovieSceneBindingProxy]: An array of unique identifiers for all the bindings in this sequence
        """
        ...
    @classmethod
    def get_binding_id(cls, sequence: MovieSceneSequence, binding: MovieSceneBindingProxy) -> MovieSceneObjectBindingID:
        r"""
        X.get_binding_id(sequence, binding) -> MovieSceneObjectBindingID
        Get the binding ID for a binding within a sequence.
        note:: The resulting binding is only valid when applied to properties within the same sequence as this binding. Use GetPortableBindingID for bindings which live in different sub-sequences.
        
        Args:
            sequence (MovieSceneSequence): 
            binding (MovieSceneBindingProxy): 
        
        Returns:
            MovieSceneObjectBindingID: The binding's id
        """
        ...
    @classmethod
    def find_tracks_by_type(cls, sequence: MovieSceneSequence, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        X.find_tracks_by_type(sequence, track_type) -> Array[MovieSceneTrack]
        Find all tracks of the specified type
        
        Args:
            sequence (MovieSceneSequence): The sequence to use
            track_type (type(Class)): A UMovieSceneTrack class type specifying which types of track to return
        
        Returns:
            Array[MovieSceneTrack]: An array containing any tracks that match the type specified
        """
        ...
    @classmethod
    def find_tracks_by_exact_type(cls, sequence: MovieSceneSequence, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        X.find_tracks_by_exact_type(sequence, track_type) -> Array[MovieSceneTrack]
        Find all tracks of the specified type, not allowing sub-classed types
        
        Args:
            sequence (MovieSceneSequence): The sequence to use
            track_type (type(Class)): A UMovieSceneTrack class type specifying the exact types of track to return
        
        Returns:
            Array[MovieSceneTrack]: An array containing any tracks that are exactly the same as the type specified
        """
        ...
    @classmethod
    def find_next_marked_frame_in_sequence(cls, sequence: MovieSceneSequence, frame_number: FrameNumber, forward: bool, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> int:
        r"""
        X.find_next_marked_frame_in_sequence(sequence, frame_number, forward, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> int32
        * Find the next/previous user marked frame from the given frame number
        *
        *
        InFrameNumber: The frame number to find the next/previous user marked frame from *
        bForward: Find forward from the given frame number.
        
        Args:
            sequence (MovieSceneSequence): 
            frame_number (FrameNumber): 
            forward (bool): 
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def find_next_marked_frame(cls, sequence: MovieSceneSequence, frame_number: FrameNumber, forward: bool) -> int:
        r"""
        X.find_next_marked_frame(sequence, frame_number, forward) -> int32
        Find Next Marked Frame
        deprecated: FindNextMarkedFrame is deprecated. Please use FindNextMarkedFrame that takes a time unit and defaults to display rate instead
        
        Args:
            sequence (MovieSceneSequence): 
            frame_number (FrameNumber): 
            forward (bool): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def find_master_tracks_by_type(cls, sequence: MovieSceneSequence, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        X.find_master_tracks_by_type(sequence, track_type) -> Array[MovieSceneTrack]
        Find Master Tracks by Type
        deprecated: FindMasterTracksByType is deprecated. Please use FindTracksByType instead
        
        Args:
            sequence (MovieSceneSequence): 
            track_type (type(Class)): 
        
        Returns:
            Array[MovieSceneTrack]:
        """
        ...
    @classmethod
    def find_master_tracks_by_exact_type(cls, sequence: MovieSceneSequence, track_type: Class) -> Array[MovieSceneTrack]:
        r"""
        X.find_master_tracks_by_exact_type(sequence, track_type) -> Array[MovieSceneTrack]
        Find Master Tracks by Exact Type
        deprecated: FindMasterTracksByExactType is deprecated. Please use FindTracksByExactType instead
        
        Args:
            sequence (MovieSceneSequence): 
            track_type (type(Class)): 
        
        Returns:
            Array[MovieSceneTrack]:
        """
        ...
    @classmethod
    def find_marked_frame_by_label(cls, sequence: MovieSceneSequence, label: str) -> int:
        r"""
        X.find_marked_frame_by_label(sequence, label) -> int32
        * Find the user marked frame by label
        *
        *
        InLabel: The label to the user marked frame to find
        
        Args:
            sequence (MovieSceneSequence): 
            label (str): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def find_marked_frame_by_frame_number_in_sequence(cls, sequence: MovieSceneSequence, frame_number: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> int:
        r"""
        X.find_marked_frame_by_frame_number_in_sequence(sequence, frame_number, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> int32
        * Find the user marked frame by frame number
        *
        *
        InFrameNumber: The frame number of the user marked frame to find
        
        Args:
            sequence (MovieSceneSequence): 
            frame_number (FrameNumber): 
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def find_marked_frame_by_frame_number(cls, sequence: MovieSceneSequence, frame_number: FrameNumber) -> int:
        r"""
        X.find_marked_frame_by_frame_number(sequence, frame_number) -> int32
        Find Marked Frame by Frame Number
        deprecated: FindMarkedFrameByFrameNumber is deprecated. Please use FindMarkedFrameByFrameNumber that takes a time unit instead
        
        Args:
            sequence (MovieSceneSequence): 
            frame_number (FrameNumber): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def find_binding_by_name(cls, sequence: MovieSceneSequence, name: str) -> MovieSceneBindingProxy:
        r"""
        X.find_binding_by_name(sequence, name) -> MovieSceneBindingProxy
        Attempt to locate a binding in this sequence by its name
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to find the binding
            name (str): The display name of the binding to look up
        
        Returns:
            MovieSceneBindingProxy: A unique identifier for the binding, or invalid
        """
        ...
    @classmethod
    def find_binding_by_id(cls, sequence: MovieSceneSequence, binding_id: Guid) -> MovieSceneBindingProxy:
        r"""
        X.find_binding_by_id(sequence, binding_id) -> MovieSceneBindingProxy
        Attempt to locate a binding in this sequence by its Id
        
        Args:
            sequence (MovieSceneSequence): The sequence within which to find the binding
            binding_id (Guid): The binding Id to look up
        
        Returns:
            MovieSceneBindingProxy: A unique identifier for the binding, or invalid
        """
        ...
    @classmethod
    def delete_marked_frames(cls, sequence: MovieSceneSequence) -> None:
        r"""
        X.delete_marked_frames(sequence) -> None
        * Delete all user marked frames
        
        Args:
            sequence (MovieSceneSequence):
        """
        ...
    @classmethod
    def delete_marked_frame(cls, sequence: MovieSceneSequence, delete_index: int) -> None:
        r"""
        X.delete_marked_frame(sequence, delete_index) -> None
        * Delete the user marked frame by index.
        *
        *
        DeleteIndex: The index to the user marked frame to delete
        
        Args:
            sequence (MovieSceneSequence): 
            delete_index (int32):
        """
        ...
    @classmethod
    def are_marked_frames_locked(cls, sequence: MovieSceneSequence) -> bool:
        r"""
        X.are_marked_frames_locked(sequence) -> bool
        * Are marked frames locked
        *
        *
        
        Args:
            sequence (MovieSceneSequence): 
        
        Returns:
            bool: Whether the movie scene marked frames are locked
        """
        ...
    @classmethod
    def add_track(cls, sequence: MovieSceneSequence, track_type: Class) -> MovieSceneTrack:
        r"""
        X.add_track(sequence, track_type) -> MovieSceneTrack
        Add a new track of the specified type
        
        Args:
            sequence (MovieSceneSequence): The sequence to use
            track_type (type(Class)): A UMovieSceneTrack class type to create
        
        Returns:
            MovieSceneTrack: The newly created track, if successful
        """
        ...
    @classmethod
    def add_spawnable_from_instance(cls, sequence: MovieSceneSequence, object_to_spawn: Object) -> MovieSceneBindingProxy:
        r"""
        X.add_spawnable_from_instance(sequence, object_to_spawn) -> MovieSceneBindingProxy
        Add a new binding to this sequence that will spawn the specified object
        
        Args:
            sequence (MovieSceneSequence): The sequence to add to
            object_to_spawn (Object): An object instance to use as a template for spawning
        
        Returns:
            MovieSceneBindingProxy: A unique identifier for the new binding
        """
        ...
    @classmethod
    def add_spawnable_from_class(cls, sequence: MovieSceneSequence, class_to_spawn: Class) -> MovieSceneBindingProxy:
        r"""
        X.add_spawnable_from_class(sequence, class_to_spawn) -> MovieSceneBindingProxy
        Add a new binding to this sequence that will spawn the specified object
        
        Args:
            sequence (MovieSceneSequence): The sequence to add to
            class_to_spawn (type(Class)): A class or blueprint type to spawn for this binding
        
        Returns:
            MovieSceneBindingProxy: A unique identifier for the new binding
        """
        ...
    @classmethod
    def add_root_folder_to_sequence(cls, sequence: MovieSceneSequence, new_folder_name: str) -> MovieSceneFolder:
        r"""
        X.add_root_folder_to_sequence(sequence, new_folder_name) -> MovieSceneFolder
        Add a root folder to the given sequence
        
        Args:
            sequence (MovieSceneSequence): The sequence to add a folder to
            new_folder_name (str): The name to give the added folder
        
        Returns:
            MovieSceneFolder: The newly created folder
        """
        ...
    @classmethod
    def add_possessable(cls, sequence: MovieSceneSequence, object_to_possess: Object) -> MovieSceneBindingProxy:
        r"""
        X.add_possessable(sequence, object_to_possess) -> MovieSceneBindingProxy
        Add a new binding to this sequence that will possess the specified object
        
        Args:
            sequence (MovieSceneSequence): The sequence to add a possessable to
            object_to_possess (Object): The object that this sequence should possess when evaluating
        
        Returns:
            MovieSceneBindingProxy: A unique identifier for the new binding
        """
        ...
    @classmethod
    def add_master_track(cls, sequence: MovieSceneSequence, track_type: Class) -> MovieSceneTrack:
        r"""
        X.add_master_track(sequence, track_type) -> MovieSceneTrack
        Add Master Track
        deprecated: AddMasterTrack is deprecated. Please use AddTrack instead
        
        Args:
            sequence (MovieSceneSequence): 
            track_type (type(Class)): 
        
        Returns:
            MovieSceneTrack:
        """
        ...
    @classmethod
    def add_marked_frame_to_sequence(cls, sequence: MovieSceneSequence, marked_frame: MovieSceneMarkedFrame, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> int:
        r"""
        X.add_marked_frame_to_sequence(sequence, marked_frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> int32
        * Add a given user marked frame.
        * A unique label will be generated if the marked frame label is empty
        *
        *
        InMarkedFrame: The given user marked frame to add *
        
        Args:
            sequence (MovieSceneSequence): 
            marked_frame (MovieSceneMarkedFrame): 
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            int32: The index to the newly added marked frame
        """
        ...
    @classmethod
    def add_marked_frame(cls, sequence: MovieSceneSequence, marked_frame: MovieSceneMarkedFrame) -> int:
        r"""
        X.add_marked_frame(sequence, marked_frame) -> int32
        Add Marked Frame
        deprecated: AddMarkedFrame is deprecated. Please use AddMarkedFrame that takes a time unit instead
        
        Args:
            sequence (MovieSceneSequence): 
            marked_frame (MovieSceneMarkedFrame): 
        
        Returns:
            int32:
        """
        ...

class MovieSceneTrackExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto UMovieSceneTracks for scripting
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneTrackExtensions.h
    
    """
    @classmethod
    def set_track_row_display_name(cls, track: MovieSceneTrack, name: Text, row_index: int) -> None:
        r"""
        X.set_track_row_display_name(track, name, row_index) -> None
        Set this track row's display name
        
        Args:
            track (MovieSceneTrack): The track to use
            name (Text): The name for this track
            row_index (int32): The row index for the track
        """
        ...
    @classmethod
    def set_sorting_order(cls, track: MovieSceneTrack, sorting_order: int) -> None:
        r"""
        X.set_sorting_order(track, sorting_order) -> None
        Set the sorting order for this track
        
        Args:
            track (MovieSceneTrack): The track to get the sorting order from
            sorting_order (int32): The sorting order to set
        """
        ...
    @classmethod
    def set_section_to_key(cls, track: MovieSceneTrack, section: MovieSceneSection) -> None:
        r"""
        X.set_section_to_key(track, section) -> None
        Set the section to key for this track. When properties for this section are modified externally,
        this section will receive those modifications and act accordingly (add/update keys). This is
        especially useful when there are multiple overlapping sections.
        
        Args:
            track (MovieSceneTrack): The track to set the section to key for
            section (MovieSceneSection): The section to key for this track
        """
        ...
    @classmethod
    def set_display_name(cls, track: MovieSceneTrack, name: Text) -> None:
        r"""
        X.set_display_name(track, name) -> None
        Set this track's display name
        
        Args:
            track (MovieSceneTrack): The track to use
            name (Text): The name for this track
        """
        ...
    @classmethod
    def set_color_tint(cls, track: MovieSceneTrack, color_tint: Color) -> None:
        r"""
        X.set_color_tint(track, color_tint) -> None
        Set the color tint for this track
        
        Args:
            track (MovieSceneTrack): The track to set the color tint for
            color_tint (Color): The color tint to set
        """
        ...
    @classmethod
    def remove_section(cls, track: MovieSceneTrack, section: MovieSceneSection) -> None:
        r"""
        X.remove_section(track, section) -> None
        Remove the specified section
        
        Args:
            track (MovieSceneTrack): The track to remove the section from, if present
            section (MovieSceneSection): The section to remove
        """
        ...
    @classmethod
    def get_track_row_display_name(cls, track: MovieSceneTrack, row_index: int) -> Text:
        r"""
        X.get_track_row_display_name(track, row_index) -> Text
        Get this track row's display name
        
        Args:
            track (MovieSceneTrack): The track to use
            row_index (int32): The row index for the track
        
        Returns:
            Text: This track's display name
        """
        ...
    @classmethod
    def get_sorting_order(cls, track: MovieSceneTrack) -> int:
        r"""
        X.get_sorting_order(track) -> int32
        Get the sorting order for this track
        
        Args:
            track (MovieSceneTrack): The track to get the sorting order from
        
        Returns:
            int32: The sorting order of the requested track
        """
        ...
    @classmethod
    def get_section_to_key(cls, track: MovieSceneTrack) -> MovieSceneSection:
        r"""
        X.get_section_to_key(track) -> MovieSceneSection
        Get the section to key for this track
        
        Args:
            track (MovieSceneTrack): The track to get the section to key for
        
        Returns:
            MovieSceneSection: The section to key for the requested track
        """
        ...
    @classmethod
    def get_sections(cls, track: MovieSceneTrack) -> Array[MovieSceneSection]:
        r"""
        X.get_sections(track) -> Array[MovieSceneSection]
        Access all this track's sections
        
        Args:
            track (MovieSceneTrack): The track to use
        
        Returns:
            Array[MovieSceneSection]: An array of this track's sections
        """
        ...
    @classmethod
    def get_display_name(cls, track: MovieSceneTrack) -> Text:
        r"""
        X.get_display_name(track) -> Text
        Get this track's display name
        
        Args:
            track (MovieSceneTrack): The track to use
        
        Returns:
            Text: This track's display name
        """
        ...
    @classmethod
    def get_color_tint(cls, track: MovieSceneTrack) -> Color:
        r"""
        X.get_color_tint(track) -> Color
        Get the color tint for this track
        
        Args:
            track (MovieSceneTrack): The track to get the color tint from
        
        Returns:
            Color: The color tint of the requested track
        """
        ...
    @classmethod
    def add_section(cls, track: MovieSceneTrack) -> MovieSceneSection:
        r"""
        X.add_section(track) -> MovieSceneSection
        Add a new section to this track
        
        Args:
            track (MovieSceneTrack): The track to use
        
        Returns:
            MovieSceneSection: The newly create section if successful
        """
        ...

class MovieSceneFloatVectorTrackExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto UMovieSceneFloatVectorTrack for scripting
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneVectorTrackExtensions.h
    
    """
    @classmethod
    def set_num_channels_used(cls, track: MovieSceneFloatVectorTrack, num_channels_used: int) -> None:
        r"""
        X.set_num_channels_used(track, num_channels_used) -> None
        Set the number of channels used for this track
        
        Args:
            track (MovieSceneFloatVectorTrack): The track to set
            num_channels_used (int32): The number of channels to use for this track
        """
        ...
    @classmethod
    def get_num_channels_used(cls, track: MovieSceneFloatVectorTrack) -> int:
        r"""
        X.get_num_channels_used(track) -> int32
        Get the number of channels used for this track
        
        Args:
            track (MovieSceneFloatVectorTrack): The track to query for the number of channels used
        
        Returns:
            int32: The number of channels used for this track
        """
        ...

class MovieSceneVectorTrackExtensions(MovieSceneFloatVectorTrackExtensions):
    r"""
    deprecated: 'MovieSceneVectorTrackExtensions' was renamed to 'MovieSceneFloatVectorTrackExtensions'.
    """
    ...

class MovieSceneDoubleVectorTrackExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto UMovieSceneDoubleVectorTrack for scripting
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: MovieSceneVectorTrackExtensions.h
    
    """
    @classmethod
    def set_num_channels_used(cls, track: MovieSceneDoubleVectorTrack, num_channels_used: int) -> None:
        r"""
        X.set_num_channels_used(track, num_channels_used) -> None
        Set the number of channels used for this track
        
        Args:
            track (MovieSceneDoubleVectorTrack): The track to set
            num_channels_used (int32): The number of channels to use for this track
        """
        ...
    @classmethod
    def get_num_channels_used(cls, track: MovieSceneDoubleVectorTrack) -> int:
        r"""
        X.get_num_channels_used(track) -> int32
        Get the number of channels used for this track
        
        Args:
            track (MovieSceneDoubleVectorTrack): The track to query for the number of channels used
        
        Returns:
            int32: The number of channels used for this track
        """
        ...

class SequencerScriptingRangeExtensions(BlueprintFunctionLibrary):
    r"""
    Function library containing methods that should be hoisted onto FSequencerScriptingRanges
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScripting
    - **File**: SequencerScriptingRangeExtensions.h
    
    """
    @classmethod
    def set_start_seconds(cls, range: SequencerScriptingRange, start: float) -> SequencerScriptingRange:
        r"""
        X.set_start_seconds(range, start) -> SequencerScriptingRange
        Set the starting time for the specified range in seconds. Interpreted as the first valid time that is inside the range.
        
        Args:
            range (SequencerScriptingRange): The range to set the start on
            start (float): 
        
        Returns:
            SequencerScriptingRange: 
        
            range (SequencerScriptingRange): The range to set the start on
        """
        ...
    @classmethod
    def set_start_frame(cls, range: SequencerScriptingRange, start: int) -> SequencerScriptingRange:
        r"""
        X.set_start_frame(range, start) -> SequencerScriptingRange
        Set the starting frame for the specified range. Interpreted as the first valid frame that is inside the range.
        
        Args:
            range (SequencerScriptingRange): The range to set the start on
            start (int32): 
        
        Returns:
            SequencerScriptingRange: 
        
            range (SequencerScriptingRange): The range to set the start on
        """
        ...
    @classmethod
    def set_end_seconds(cls, range: SequencerScriptingRange, end: float) -> SequencerScriptingRange:
        r"""
        X.set_end_seconds(range, end) -> SequencerScriptingRange
        Set the ending time for the specified range in seconds. Interpreted as the first time that is outside of the range.
        
        Args:
            range (SequencerScriptingRange): The range to set the end on
            end (float): 
        
        Returns:
            SequencerScriptingRange: 
        
            range (SequencerScriptingRange): The range to set the end on
        """
        ...
    @classmethod
    def set_end_frame(cls, range: SequencerScriptingRange, end: int) -> SequencerScriptingRange:
        r"""
        X.set_end_frame(range, end) -> SequencerScriptingRange
        Set the ending frame for the specified range. Interpreted as the first subsequent frame that is outside of the range.
        
        Args:
            range (SequencerScriptingRange): The range to set the end on
            end (int32): 
        
        Returns:
            SequencerScriptingRange: 
        
            range (SequencerScriptingRange): The range to set the end on
        """
        ...
    @classmethod
    def remove_start(cls, range: SequencerScriptingRange) -> SequencerScriptingRange:
        r"""
        X.remove_start(range) -> SequencerScriptingRange
        Remove the start from this range, making it infinite
        
        Args:
            range (SequencerScriptingRange): The range to remove the start from
        
        Returns:
            SequencerScriptingRange: 
        
            range (SequencerScriptingRange): The range to remove the start from
        """
        ...
    @classmethod
    def remove_end(cls, range: SequencerScriptingRange) -> SequencerScriptingRange:
        r"""
        X.remove_end(range) -> SequencerScriptingRange
        Remove the end from this range, making it infinite
        
        Args:
            range (SequencerScriptingRange): The range to remove the end from
        
        Returns:
            SequencerScriptingRange: 
        
            range (SequencerScriptingRange): The range to remove the end from
        """
        ...
    @classmethod
    def has_start(cls, range: SequencerScriptingRange) -> bool:
        r"""
        X.has_start(range) -> bool
        Check whether this range has a start
        
        Args:
            range (SequencerScriptingRange): The range to check
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def has_end(cls, range: SequencerScriptingRange) -> bool:
        r"""
        X.has_end(range) -> bool
        Check whether this range has an end
        
        Args:
            range (SequencerScriptingRange): The range to check
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_start_seconds(cls, range: SequencerScriptingRange) -> float:
        r"""
        X.get_start_seconds(range) -> float
        Get the starting time for the specified range in seconds, if it has one. Defined as the first valid time that is inside the range.
        
        Args:
            range (SequencerScriptingRange): The range to get the start from
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_start_frame(cls, range: SequencerScriptingRange) -> int:
        r"""
        X.get_start_frame(range) -> int32
        Get the starting frame for the specified range, if it has one. Defined as the first valid frame that is inside the range.
        
        Args:
            range (SequencerScriptingRange): The range to get the start from
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_end_seconds(cls, range: SequencerScriptingRange) -> float:
        r"""
        X.get_end_seconds(range) -> float
        Get the ending time for the specified range in seconds, if it has one. Defined as the first time that is outside of the range.
        
        Args:
            range (SequencerScriptingRange): The range to get the end from
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_end_frame(cls, range: SequencerScriptingRange) -> int:
        r"""
        X.get_end_frame(range) -> int32
        Get the ending frame for the specified range, if it has one. Defined as the first subsequent frame that is outside of the range.
        
        Args:
            range (SequencerScriptingRange): The range to get the end from
        
        Returns:
            int32:
        """
        ...

class SequencerCurveEditorObject(Object):
    r"""
    * Class to hold sequencer curve editor functions
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScriptingEditor
    - **File**: SequencerCurveEditorObject.h
    
    """
    def set_random_color_for_channels(self, class_: Class, identifiers: Array[str]) -> None:
        r"""
        x.set_random_color_for_channels(class_, identifiers) -> None
        Set Random Colors for specified channels idendified by it's class and identifiers. This will be stored in editor user preferences.
        
        Args:
            class_ (type(Class)): 
            identifiers (Array[str]):
        """
        ...
    def set_custom_color_for_channels(self, class_: Class, identifiers: Array[str], new_colors: Array[LinearColor]) -> None:
        r"""
        x.set_custom_color_for_channels(class_, identifiers, new_colors) -> None
        Set Custom Color for specified channels idendified by it's class and identifiers. This will be stored in editor user preferences.
        
        Args:
            class_ (type(Class)): 
            identifiers (Array[str]): 
            new_colors (Array[LinearColor]):
        """
        ...
    def set_custom_color_for_channel(self, class_: Class, identifier: str, new_color: LinearColor) -> None:
        r"""
        x.set_custom_color_for_channel(class_, identifier, new_color) -> None
        Set Custom Color for specified channel idendified by it's class and identifier. This will be stored in editor user preferences.
        
        Args:
            class_ (type(Class)): 
            identifier (str): 
            new_color (LinearColor):
        """
        ...
    def select_keys(self, channel: SequencerChannelProxy, indices: Array[int]) -> None:
        r"""
        x.select_keys(channel, indices) -> None
        Select keys
        
        Args:
            channel (SequencerChannelProxy): 
            indices (Array[int32]):
        """
        ...
    def open_curve_editor(self) -> None:
        r"""
        x.open_curve_editor() -> None
        Open curve editor
        """
        ...
    def is_curve_editor_open(self) -> bool:
        r"""
        x.is_curve_editor_open() -> bool
        Is curve editor open
        
        Returns:
            bool:
        """
        ...
    def has_custom_color_for_channel(self, class_: Class, identifier: str) -> bool:
        r"""
        x.has_custom_color_for_channel(class_, identifier) -> bool
        Get if a custom color for specified channel idendified by it's class and identifier exists
        
        Args:
            class_ (type(Class)): 
            identifier (str): 
        
        Returns:
            bool:
        """
        ...
    def get_selected_keys(self, channel_proxy: SequencerChannelProxy) -> Array[int]:
        r"""
        x.get_selected_keys(channel_proxy) -> Array[int32]
        Gets the selected keys with this channel
        
        Args:
            channel_proxy (SequencerChannelProxy): 
        
        Returns:
            Array[int32]:
        """
        ...
    def get_custom_color_for_channel(self, class_: Class, identifier: str) -> LinearColor:
        r"""
        x.get_custom_color_for_channel(class_, identifier) -> LinearColor
        Get custom color for specified channel idendified by it's class and identifier,if none exists will return white
        
        Args:
            class_ (type(Class)): 
            identifier (str): 
        
        Returns:
            LinearColor:
        """
        ...
    def get_channels_with_selected_keys(self) -> Array[SequencerChannelProxy]:
        r"""
        x.get_channels_with_selected_keys() -> Array[SequencerChannelProxy]
        Gets the channel with selected keys
        
        Returns:
            Array[SequencerChannelProxy]:
        """
        ...
    def empty_selection(self) -> None:
        r"""
        x.empty_selection() -> None
        Empties the current selection.
        """
        ...
    def delete_color_for_channels(self, class_: Class) -> str:
        r"""
        x.delete_color_for_channels(class_) -> str
        Delete for specified channel idendified by it's class and identifier.
        
        Args:
            class_ (type(Class)): 
        
        Returns:
            str: 
        
            identifier (str):
        """
        ...
    def close_curve_editor(self) -> None:
        r"""
        x.close_curve_editor() -> None
        Close curve editor
        """
        ...

class SequencerTools(BlueprintFunctionLibrary):
    r"""
    This is a set of helper functions to access various parts of the Sequencer API via Python. Because Sequencer itself is not suitable for exposing, most functionality
    gets wrapped by UObjects that have an easier API to work with. This UObject provides access to these wrapper UObjects where needed.
    
    **C++ Source:**
    
    - **Plugin**: SequencerScripting
    - **Module**: SequencerScriptingEditor
    - **File**: SequencerTools.h
    
    """
    @classmethod
    def render_movie(cls, capture_settings: MovieSceneCapture, on_finished_callback: OnRenderMovieStopped) -> bool:
        r"""
        X.render_movie(capture_settings, on_finished_callback) -> bool
        Render Movie
        deprecated: Function 'RenderMovie' is deprecated.
        
        Args:
            capture_settings (MovieSceneCapture): 
            on_finished_callback (OnRenderMovieStopped): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def link_anim_sequence(cls, sequence: LevelSequence, anim_sequence: AnimSequence, export_options: AnimSeqExportOption, binding: MovieSceneBindingProxy) -> bool:
        r"""
        X.link_anim_sequence(sequence, anim_sequence, export_options, binding) -> bool
        * Links a LevelSequence's SkeletalMesh binding to an existing anim sequence.
        *
        *
        InSequence: Sequence to link from *
        AnimSequence: The AnimSequence to link to. *
        ExportOption: The export options that should be used when baking the LevelSequence. *
        InBinding: Binding that has a skelmesh component on it
        
        Args:
            sequence (LevelSequence): 
            anim_sequence (AnimSequence): 
            export_options (AnimSeqExportOption): 
            binding (MovieSceneBindingProxy): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_rendering_movie(cls) -> bool:
        r"""
        X.is_rendering_movie() -> bool
        Is Rendering Movie
        deprecated: Function 'IsRenderingMovie' is deprecated.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_event_endpoint_valid(cls, endpoint: SequencerQuickBindingResult) -> bool:
        r"""
        X.is_event_endpoint_valid(endpoint) -> bool
        Check if an endpoint is valid and can be used to create movie scene event.
        
        Args:
            endpoint (SequencerQuickBindingResult): Endpoint to check.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def import_level_sequence_fbx(cls, world: World, sequence: LevelSequence, bindings: Array[MovieSceneBindingProxy], import_fbx_settings: MovieSceneUserImportFBXSettings, import_filename: str) -> bool:
        r"""
        X.import_level_sequence_fbx(world, sequence, bindings, import_fbx_settings, import_filename) -> bool
        * Import FBX onto Passed in Bindings
        *
        *
        InWorld: World to import to *
        InSequence: InSequence to import *
        InBindings: InBindings to import *
        InImportFBXSettings: Settings to control import. *
        InImportFileName: Path to fbx file to import from *
        InPlayer: Player to bind to
        
        Args:
            world (World): 
            sequence (LevelSequence): 
            bindings (Array[MovieSceneBindingProxy]): 
            import_fbx_settings (MovieSceneUserImportFBXSettings): 
            import_filename (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def import_fbx_to_control_rig(cls, world: World, sequence: LevelSequence, actor_with_control_rig_track: str, selected_control_rig_names: Array[str], import_fbx_control_rig_settings: MovieSceneUserImportFBXControlRigSettings, import_filename: str) -> bool:
        r"""
        X.import_fbx_to_control_rig(world, sequence, actor_with_control_rig_track, selected_control_rig_names, import_fbx_control_rig_settings, import_filename) -> bool
        * Import FBX onto a control rig with the specified track name
        *
        *
        InWorld: World to import to *
        InSequence: InSequence to import *
        ActorWithControlRigTrack: ActorWithControlRigTrack The name of the actor with the control rig track we are importing onto *
        SelectedControlRigNames: List of selected control rig names. Will use them if  ImportFBXControlRigSettings->bImportOntoSelectedControls is true *
        ImportFBXControlRigSettings: Settings to control import. *
        InImportFileName: Path to fbx file to create
        
        Args:
            world (World): 
            sequence (LevelSequence): 
            actor_with_control_rig_track (str): 
            selected_control_rig_names (Array[str]): 
            import_fbx_control_rig_settings (MovieSceneUserImportFBXControlRigSettings): 
            import_filename (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_object_bindings(cls, world: World, sequence: LevelSequence, object: Array[Object], range: SequencerScriptingRange) -> Array[SequencerBoundObjects]:
        r"""
        X.get_object_bindings(world, sequence, object, range) -> Array[SequencerBoundObjects]
        Get Object Bindings
        deprecated: Function 'GetObjectBindings' is deprecated.
        
        Args:
            world (World): 
            sequence (LevelSequence): 
            object (Array[Object]): 
            range (SequencerScriptingRange): 
        
        Returns:
            Array[SequencerBoundObjects]:
        """
        ...
    @classmethod
    def get_level_sequence_link_from_anim_sequence(cls, anim_sequence: AnimSequence) -> AnimSequenceLevelSequenceLink:
        r"""
        X.get_level_sequence_link_from_anim_sequence(anim_sequence) -> AnimSequenceLevelSequenceLink
        * Get the link to the level sequence if it exists on this anim sequence
        *
        *
        InAnimSequence: AnimSequence to get links from *
        
        Args:
            anim_sequence (AnimSequence): 
        
        Returns:
            AnimSequenceLevelSequenceLink: Returns the link object if it exists, nullptr if it doesn't
        """
        ...
    @classmethod
    def get_bound_objects(cls, world: World, sequence: LevelSequence, bindings: Array[MovieSceneBindingProxy], range: SequencerScriptingRange) -> Array[SequencerBoundObjects]:
        r"""
        X.get_bound_objects(world, sequence, bindings, range) -> Array[SequencerBoundObjects]
        Get Bound Objects
        deprecated: Function 'GetBoundObjects' is deprecated.
        
        Args:
            world (World): 
            sequence (LevelSequence): 
            bindings (Array[MovieSceneBindingProxy]): 
            range (SequencerScriptingRange): 
        
        Returns:
            Array[SequencerBoundObjects]:
        """
        ...
    @classmethod
    def get_anim_sequence_link_from_level_sequence(cls, level_sequence: LevelSequence) -> LevelSequenceAnimSequenceLink:
        r"""
        X.get_anim_sequence_link_from_level_sequence(level_sequence) -> LevelSequenceAnimSequenceLink
        * Get the links to the anim sequences if they exist on this level sequence
        *
        *
        InLevelSequence: LevelSequence to get links from *
        
        Args:
            level_sequence (LevelSequence): 
        
        Returns:
            LevelSequenceAnimSequenceLink: Returns the link object if it exists, nullptr if it doesn't
        """
        ...
    @classmethod
    def export_level_sequence_fbx(cls, params: SequencerExportFBXParams) -> bool:
        r"""
        X.export_level_sequence_fbx(params) -> bool
        * Export Passed in Bindings and Tracks to FBX
        
        Args:
            params (SequencerExportFBXParams): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def export_fbx_from_control_rig(cls, sequence: LevelSequence, actor_with_control_rig_track: str, export_fbx_control_rig_settings: MovieSceneUserExportFBXControlRigSettings) -> bool:
        r"""
        X.export_fbx_from_control_rig(sequence, actor_with_control_rig_track, export_fbx_control_rig_settings) -> bool
        Exports an FBX from the section to key of the control rig track of the actor with the given name.
        
        Args:
            sequence (LevelSequence): 
            actor_with_control_rig_track (str): 
            export_fbx_control_rig_settings (MovieSceneUserExportFBXControlRigSettings): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def export_anim_sequence(cls, world: World, sequence: LevelSequence, anim_sequence: AnimSequence, export_option: AnimSeqExportOption, binding: MovieSceneBindingProxy, create_link: bool) -> bool:
        r"""
        X.export_anim_sequence(world, sequence, anim_sequence, export_option, binding, create_link) -> bool
        * Export Passed in Binding as an Anim Seqquence.
        *
        *
        InWorld: World to export *
        InSequence: Sequence to export *
        AnimSequence: The AnimSequence to save into. *
        ExportOption: The export options for the sequence. *
        InBinding: Binding to export that has a skelmesh component on it *
        InAnimSequenceFilename: File to create *
        bCreateLink: If true will create a link between the animation sequence and the level sequence
        
        Args:
            world (World): 
            sequence (LevelSequence): 
            anim_sequence (AnimSequence): 
            export_option (AnimSeqExportOption): 
            binding (MovieSceneBindingProxy): 
            create_link (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def create_quick_binding(cls, sequence: MovieSceneSequence, object: Object, function_name: str, call_in_editor: bool) -> SequencerQuickBindingResult:
        r"""
        X.create_quick_binding(sequence, object, function_name, call_in_editor) -> SequencerQuickBindingResult
        Create a quick binding to an actor's member method to be used in an event sequence.
        
        Args:
            sequence (MovieSceneSequence): 
            object (Object): 
            function_name (str): Name of the method, as it is displayed in the Blueprint Editor. eg. "Set Actor Scale 3D"
            call_in_editor (bool): Should the event be callable in editor.
        
        Returns:
            SequencerQuickBindingResult: The created binding.
        """
        ...
    @classmethod
    def create_event(cls, sequence: MovieSceneSequence, section: MovieSceneEventSectionBase, endpoint: SequencerQuickBindingResult, payload: Array[str]) -> MovieSceneEvent:
        r"""
        X.create_event(sequence, section, endpoint, payload) -> MovieSceneEvent
        Create an event from a previously created blueprint endpoint and a payload. The resulting event should be added only
        to a channel of the section that was given as a parameter.
        InEndpoint.: 
        see: CreateQuickBinding
        
        Args:
            sequence (MovieSceneSequence): Main level sequence that holds the event track and to which the resulting event should be added.
            section (MovieSceneEventSectionBase): Section of the event track of the main sequence.
            endpoint (SequencerQuickBindingResult): Previously created endpoint.
            payload (Array[str]): Values passed as payload to event, count must match the numbers of payload variable names in
        
        Returns:
            MovieSceneEvent: The created movie event.
        """
        ...
    @classmethod
    def clear_linked_anim_sequences(cls, level_sequence: LevelSequence) -> None:
        r"""
        X.clear_linked_anim_sequences(level_sequence) -> None
        * Clear all linked anim sequences between this level sequence and any linked anim sequences
        *
        *
        InLevelSequence: LevelSequence to clean links for
        
        Args:
            level_sequence (LevelSequence):
        """
        ...
    @classmethod
    def cancel_movie_render(cls) -> None:
        r"""
        X.cancel_movie_render() -> None
        Cancel Movie Render
        deprecated: Function 'CancelMovieRender' is deprecated.
        """
        ...

class ImgMediaSource(BaseMediaSource):
    r"""
    Media source for EXR image sequences.
    
    Image sequence media sources point to a directory that contains a series of
    image files in which each image represents a single frame of the sequence.
    BMP, EXR, PNG and JPG images are currently supported. EXR image sequences
    are optimized for performance. The first frame of an image sequence is used
    to determine the image dimensions (all formats) and frame rate (EXR only).
    
    The image sequence directory may contain sub-directories, which are called
    'proxies'. Proxies can be used to provide alternative media for playback
    during development and testing of a game. One common scenario is the use
    of low resolution versions of image sequence media on computers that are
    too slow or don't have enough storage to play the original high-res media.
    
    **C++ Source:**
    
    - **Plugin**: ImgMedia
    - **Module**: ImgMedia
    - **File**: ImgMediaSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``fill_gaps_in_sequence`` (bool):  [Read-Write] If true, then any gaps in the sequence will be filled with blank frames.
    - ``frame_rate_override`` (FrameRate):  [Read-Write] Overrides the default frame rate stored in the image files (0/0 = do not override).
    - ``platform_player_names`` (Map[str, Name]):  [Read-Write] Override native media player plug-ins per platform (Empty = find one automatically).
    - ``proxy_override`` (str):  [Read-Write] Name of the proxy directory to use.
    - ``sequence_path`` (DirectoryPath):  [Read-Write] The directory that contains the image sequence files.
      
      - Relative paths will be with respect to the current Project directory.
      - You may use {engine_dir} or {project_dir} tokens.
    - ``sequence_proxy`` (ImgMediaSourceCustomizationSequenceProxy):  [Read-Write] This is only used so we can customize editing of SequencePath.
    """
    @property
    def frame_rate_override(self) -> FrameRate:
        r"""
        (FrameRate):  [Read-Write] Overrides the default frame rate stored in the image files (0/0 = do not override).
        """
        ...
    @frame_rate_override.setter
    def frame_rate_override(self, value: FrameRate) -> None:
        ...
    @property
    def proxy_override(self) -> str:
        r"""
        (str):  [Read-Write] Name of the proxy directory to use.
        """
        ...
    @proxy_override.setter
    def proxy_override(self, value: str) -> None:
        ...
    @property
    def fill_gaps_in_sequence(self) -> bool:
        r"""
        (bool):  [Read-Write] If true, then any gaps in the sequence will be filled with blank frames.
        """
        ...
    @fill_gaps_in_sequence.setter
    def fill_gaps_in_sequence(self, value: bool) -> None:
        ...
    @property
    def sequence_path(self) -> DirectoryPath:
        r"""
        (DirectoryPath):  [Read-Only] The directory that contains the image sequence files.
        
        - Relative paths will be with respect to the current Project directory.
        - You may use {engine_dir} or {project_dir} tokens.
        """
        ...
    def set_tokenized_sequence_path(self, path: str) -> None:
        r"""
        x.set_tokenized_sequence_path(path) -> None
        Set the path to the image sequence directory this source represents.
        see: GetSequencePath
        
        Args:
            path (str): The path to the desired image sequence directory. May contain supported tokens.
        """
        ...
    def set_sequence_path(self, path: str) -> None:
        r"""
        x.set_sequence_path(path) -> None
        Set the path to the image sequence directory this source represents.
        see: GetSequencePath
        
        Args:
            path (str): The path to an image file in the desired directory.
        """
        ...
    def remove_target_object(self, actor: Actor) -> None:
        r"""
        x.remove_target_object(actor) -> None
        This object is no longer using our img sequence.
        
        Args:
            actor (Actor): Object no longer using our img sequence.
        """
        ...
    def get_sequence_path(self) -> str:
        r"""
        x.get_sequence_path() -> str
        Get the path to the image sequence directory to be played. Supported tokens will be expanded.
        see: SetSequencePath
        
        Returns:
            str: The file path.
        """
        ...
    def get_proxies(self) -> Array[str]:
        r"""
        x.get_proxies() -> Array[str]
        Get the names of available proxy directories.
        see: GetSequencePath
        
        Returns:
            Array[str]: 
        
            out_proxies (Array[str]): Will contain the names of available proxy directories, if any.
        """
        ...
    def add_target_object(self, actor: Actor) -> None:
        r"""
        x.add_target_object(actor) -> None
        This object is using our img sequence.
        
        Args:
            actor (Actor): Object using our img sequence.
        """
        ...

class InterchangeImportTestPlan(Object):
    r"""
    Define a test plan
    
    **C++ Source:**
    
    - **Plugin**: InterchangeTests
    - **Module**: InterchangeTests
    - **File**: InterchangeImportTestPlan.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disabled_test_reason`` (str):  [Read-Write] Why is the test plan disabled.
    - ``is_enabled_in_automation_tests`` (bool):  [Read-Write] Whether or not this test plan is currently enabled
    - ``steps`` (Array[InterchangeImportTestStepBase]):  [Read-Write] Set of steps to perform to carry out this test plan
    """
    def run_this_test(self) -> None:
        r"""
        x.run_this_test() -> None
        Click here to immediately run this single test through the automation framework
        """
        ...

class InterchangeImportTestStepBase(Object):
    r"""
    Interchange Import Test Step Base
    
    **C++ Source:**
    
    - **Plugin**: InterchangeTests
    - **Module**: InterchangeTests
    - **File**: InterchangeImportTestStepBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``tests`` (Array[InterchangeTestFunction]):  [Read-Write] An array of results to check against
    """
    ...

class InterchangeImportTestStepImport(InterchangeImportTestStepBase):
    r"""
    Interchange Import Test Step Import
    
    **C++ Source:**
    
    - **Plugin**: InterchangeTests
    - **Module**: InterchangeTests
    - **File**: InterchangeImportTestStepImport.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``empty_destination_folder_prior_to_import`` (bool):  [Read-Write] Whether the destination folder should be emptied prior to import
    - ``import_into_level`` (bool):  [Read-Write] Whether we should use the import into level workflow
    - ``pipeline_stack`` (Array[InterchangePipelineBase]):  [Read-Write] The pipeline stack to use when importing (an empty array will use the defaults)
    - ``save_then_reload_imported_assets`` (bool):  [Read-Write] Whether imported assets should be saved and freshly reloaded after import
    - ``source_file`` (FilePath):  [Read-Write] The source file to import (path relative to the json script)
    - ``tests`` (Array[InterchangeTestFunction]):  [Read-Write] An array of results to check against
    """
    ...

class InterchangeImportTestStepReimport(InterchangeImportTestStepBase):
    r"""
    Interchange Import Test Step Reimport
    
    **C++ Source:**
    
    - **Plugin**: InterchangeTests
    - **Module**: InterchangeTests
    - **File**: InterchangeImportTestStepReimport.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_name_to_reimport`` (str):  [Read-Write] If there were multiple assets of the above type imported, specify the concrete name here.
    - ``asset_type_to_reimport`` (type(Class)):  [Read-Write] The type of the asset to reimport. If only one such asset was imported, this is unambiguous.
    - ``save_then_reload_imported_assets`` (bool):  [Read-Write] Determines whether imported assets should be saved and freshly reloaded after import.
    - ``source_file_to_reimport`` (FilePath):  [Read-Write] The source file to import (path relative to the json script).
    - ``tests`` (Array[InterchangeTestFunction]):  [Read-Write] An array of results to check against
    """
    ...

class Function(Struct):
    r"""
    Function
    
    **C++ Source:**
    
    - **Module**: CoreUObject
    - **File**: 
    
    """
    ...

class InterchangeImportTestPlanFactory(Factory):
    r"""
    Interchange Import Test Plan Factory
    
    **C++ Source:**
    
    - **Plugin**: InterchangeTests
    - **Module**: InterchangeTestEditor
    - **File**: InterchangeImportTestPlanFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AnimationCompressionLibraryDatabaseFactory(Factory):
    r"""
    Animation Compression Library Database Factory
    
    **C++ Source:**
    
    - **Plugin**: ACLPlugin
    - **Module**: ACLPluginEditor
    - **File**: AnimationCompressionLibraryDatabaseFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class CopyBonesModifier(AnimationModifier):
    r"""
    Animation Modifier to copy the transform of 'SourceBone(s)' to 'TargetBone(s)'
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: CopyBonesModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bone_pairs`` (Array[BoneReferencePair]):  [Read-Write] Source and Target bone pairs
    - ``bone_pose_space`` (AnimPoseSpaces):  [Read-Write] Space to convert SourceBone transforms into before copying them to TargetBone
    - ``reapply_post_owner_change`` (bool):  [Read-Write] If this is set to true then the animation modifier will call it's reapply function after any change made to the owning asset.
    """
    @property
    def bone_pairs(self) -> Array[BoneReferencePair]:
        r"""
        (Array[BoneReferencePair]):  [Read-Only] Source and Target bone pairs
        """
        ...
    @property
    def bone_pose_space(self) -> AnimPoseSpaces:
        r"""
        (AnimPoseSpaces):  [Read-Only] Space to convert SourceBone transforms into before copying them to TargetBone
        """
        ...

class EncodeRootBoneModifier(AnimationModifier):
    r"""
    Encode Root Bone Modifier
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: EncodeRootBoneModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``reapply_post_owner_change`` (bool):  [Read-Write] If this is set to true then the animation modifier will call it's reapply function after any change made to the owning asset.
    - ``weighted_bone_to_compute_root_orientation`` (Array[EncodeRootBoneWeightedBoneAxis]):  [Read-Write]
    - ``weighted_bone_to_compute_root_position`` (Array[EncodeRootBoneWeightedBone]):  [Read-Write]
    """
    ...

class FootstepAnimEventsModifier(AnimationModifier):
    r"""
    Generates animation notifies and/or sync markers for any specified bone(s)
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: FootstepAnimEventsModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``foot_definitions`` (Array[FootDefinition]):  [Read-Write] Foot bone(s) to be processed
    - ``generated_notify_tracks`` (Set[Name]):  [Read-Only] Keep track of to be generated tracks during modifier application
    - ``ground_threshold`` (float):  [Read-Write] Threshold for determining if a foot bone position can be considered to be on the ground level
    - ``processed_notify_tracks`` (Set[Name]):  [Read-Only] Keep track of tracks modified during modifier application
    - ``reapply_post_owner_change`` (bool):  [Read-Write] If this is set to true then the animation modifier will call it's reapply function after any change made to the owning asset.
    - ``sample_rate`` (int32):  [Read-Write] Rate used to sample the animation
    - ``should_remove_pre_existing_notifies_or_sync_markers`` (bool):  [Read-Write] If true, applying the anim modifier becomes a destructive action, meaning that any existing matched tracks will have their data overwritten by the modifier.
      Otherwise, no previous notifies or sync markers will removed when applying the anim modifier.
    - ``speed_threshold`` (float):  [Read-Write] Threshold to start finding the smallest foot bone translation speed.
      
      Note that the foot bone translation speed is normalize therefore when a footstep occurs
      the speed will be very close to zero, thus for most cases this value won't need to be changed.
    """
    @property
    def sample_rate(self) -> int:
        r"""
        (int32):  [Read-Only] Rate used to sample the animation
        """
        ...
    @property
    def ground_threshold(self) -> float:
        r"""
        (float):  [Read-Only] Threshold for determining if a foot bone position can be considered to be on the ground level
        """
        ...
    @property
    def speed_threshold(self) -> float:
        r"""
        (float):  [Read-Only] Threshold to start finding the smallest foot bone translation speed.
        
        Note that the foot bone translation speed is normalize therefore when a footstep occurs
        the speed will be very close to zero, thus for most cases this value won't need to be changed.
        """
        ...
    @property
    def foot_definitions(self) -> Array[FootDefinition]:
        r"""
        (Array[FootDefinition]):  [Read-Only] Foot bone(s) to be processed
        """
        ...
    @property
    def should_remove_pre_existing_notifies_or_sync_markers(self) -> bool:
        r"""
        (bool):  [Read-Only] If true, applying the anim modifier becomes a destructive action, meaning that any existing matched tracks will have their data overwritten by the modifier.
        Otherwise, no previous notifies or sync markers will removed when applying the anim modifier.
        """
        ...

class MotionExtractorUtilityLibrary(BlueprintFunctionLibrary):
    r"""
    Motion Extractor Utility Library
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: MotionExtractorUtilities.h
    
    """
    @classmethod
    def get_stopped_ranges_from_root_motion(cls, anim_sequence: AnimSequence, stop_speed_threshold: float = 10.000000, sample_rate: float = 120.000000) -> Array[Vector2D]:
        r"""
        X.get_stopped_ranges_from_root_motion(anim_sequence, stop_speed_threshold=10.000000, sample_rate=120.000000) -> Array[Vector2D]
        Returns the ranges (X/Start to Y/End) in the specified animation sequence where the animation is considered stopped.
        
        Args:
            anim_sequence (AnimSequence): Anim sequence to check
            stop_speed_threshold (float): Root motion speed under which the animation is considered stopped.
            sample_rate (float): Sample rate of the animation. It's recommended to use high values if the animation has very sudden direction changes.
        
        Returns:
            Array[Vector2D]:
        """
        ...
    @classmethod
    def get_moving_ranges_from_root_motion(cls, anim_sequence: AnimSequence, stop_speed_threshold: float = 10.000000, sample_rate: float = 120.000000) -> Array[Vector2D]:
        r"""
        X.get_moving_ranges_from_root_motion(anim_sequence, stop_speed_threshold=10.000000, sample_rate=120.000000) -> Array[Vector2D]
        Returns the ranges (X/Start to Y/End) in the specified animation sequence where the animation is considered moving.
        
        Args:
            anim_sequence (AnimSequence): Anim sequence to check
            stop_speed_threshold (float): Root motion speed over which the animation is considered moving.
            sample_rate (float): Sample rate of the animation. It's recommended to use high values if the animation has very sudden direction changes.
        
        Returns:
            Array[Vector2D]:
        """
        ...
    @classmethod
    def get_desired_value(cls, bone_transform: Transform, last_bone_transform: Transform, delta_time: float, motion_type: MotionExtractor_MotionType, axis: MotionExtractor_Axis) -> float:
        r"""
        X.get_desired_value(bone_transform, last_bone_transform, delta_time, motion_type, axis) -> float
        Returns the desired value from the extracted poses based on input settings.
        
        Args:
            bone_transform (Transform): Current frame's bone transform
            last_bone_transform (Transform): Last frame's bone transform. Unused when not calculating speeds.
            delta_time (float): Time step used between current and last bone transforms. Unused when not calculating speeds.
            motion_type (MotionExtractor_MotionType): What type of motion to extract (translation, rotation, speed, etc.)
            axis (MotionExtractor_Axis): Which axis/axes to extract motion from
        
        Returns:
            float:
        """
        ...
    @classmethod
    def generate_curve_name(cls, bone_name: Name, motion_type: MotionExtractor_MotionType, axis: MotionExtractor_Axis) -> Name:
        r"""
        X.generate_curve_name(bone_name, motion_type, axis) -> Name
        Generates a curve name based on input settings.
        
        Args:
            bone_name (Name): The name of the bone
            motion_type (MotionExtractor_MotionType): What type of motion this curve represents (translation, rotation, speed, etc.)
            axis (MotionExtractor_Axis): Which axis/axes the motion for this curve was extracted from
        
        Returns:
            Name:
        """
        ...

class ReOrientRootBoneModifier(AnimationModifier):
    r"""
    Reorient root bone in the animation while maintaining mesh position and rotation
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: ReOrientRootBoneModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``reapply_post_owner_change`` (bool):  [Read-Write] If this is set to true then the animation modifier will call it's reapply function after any change made to the owning asset.
    - ``rotator`` (Rotator):  [Read-Write] Rotation to apply to the root
    """
    @property
    def rotator(self) -> Rotator:
        r"""
        (Rotator):  [Read-Only] Rotation to apply to the root
        """
        ...

class ZeroOutRootBoneModifier(AnimationModifier):
    r"""
    Adjust root motion to be relative to the first frame. Optionally cut the start and end sections of the animation that don't have motion on the root.
          This was written to be used when capturing Character Movement motion via Take Recorder. Take Recorder outputs an animation captured from
          a character moving in game in world space, and this modifier zeroes out the root. The animation can then be exported to fbx to be animated against.
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: ZeroOutRootBoneModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``clip_end_frames_with_no_motion`` (bool):  [Read-Write] Clip frames at the end of the animation that have no root motion.
    - ``clip_start_frames_with_no_motion`` (bool):  [Read-Write] Clip frames at the start of the animation that have no root motion.
    - ``reapply_post_owner_change`` (bool):  [Read-Write] If this is set to true then the animation modifier will call it's reapply function after any change made to the owning asset.
    """
    @property
    def clip_start_frames_with_no_motion(self) -> bool:
        r"""
        (bool):  [Read-Only] Clip frames at the start of the animation that have no root motion.
        """
        ...
    @property
    def clip_end_frames_with_no_motion(self) -> bool:
        r"""
        (bool):  [Read-Only] Clip frames at the end of the animation that have no root motion.
        """
        ...

class MotionExtractorModifier(AnimationModifier):
    r"""
    Extracts motion from a bone in the animation and bakes it into a curve
    
    **C++ Source:**
    
    - **Plugin**: AnimationModifierLibrary
    - **Module**: AnimationModifierLibrary
    - **File**: MotionExtractorModifier.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_value`` (bool):  [Read-Write] Whether to convert the final value to absolute (positive)
    - ``axis`` (MotionExtractor_Axis):  [Read-Write] Axis to get the value from
    - ``bone_name`` (Name):  [Read-Write] Bone we are going to generate the curve from
    - ``custom_curve_name`` (Name):  [Read-Write] Custom name for the curve we are going to generate.
    - ``math_operation`` (MotionExtractor_MathOperation):  [Read-Write] Optional math operation to apply on the extracted value before add it to the generated curve
    - ``modifier`` (float):  [Read-Write] Right operand for the math operation selected
    - ``motion_type`` (MotionExtractor_MotionType):  [Read-Write] Type of motion to extract
    - ``normalize`` (bool):  [Read-Write] Whether we want a normalized value (0 - 1)
    - ``reapply_post_owner_change`` (bool):  [Read-Write] If this is set to true then the animation modifier will call it's reapply function after any change made to the owning asset.
    - ``relative_to_bone_name`` (Name):  [Read-Write] Bone which we'll use as the reference frame to generate this curve from. Space must be RelativeToBone to use this.
    - ``relative_to_first_frame`` (bool):  [Read-Write] Whether to extract the bone transforms relative to the first frame in the animation
    - ``remove_curve_on_revert`` (bool):  [Read-Write] Whether we want to remove the curve when we revert or re-apply modifier
                    Disabling this allows you to modify settings and create a new curve each time you re-apply the modifier
                    Enabling this is the preferred setting when using a modifier that's applied in bulk and you may want to remove/rename curves
    - ``sample_rate`` (int32):  [Read-Write] Rate used to sample the animation
    - ``space`` (MotionExtractor_Space):  [Read-Write] Reference frame/space to use when extracting the bone pose.
    - ``use_custom_curve_name`` (bool):  [Read-Write] Whether we want to specify a custom name for the curve. If false, the name of the curve will be auto generated based on the data we are going to extract
    """
    @property
    def bone_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Bone we are going to generate the curve from
        """
        ...
    @bone_name.setter
    def bone_name(self, value: Name) -> None:
        ...
    @property
    def relative_to_bone_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Bone which we'll use as the reference frame to generate this curve from. Space must be RelativeToBone to use this.
        """
        ...
    @relative_to_bone_name.setter
    def relative_to_bone_name(self, value: Name) -> None:
        ...
    @property
    def motion_type(self) -> MotionExtractor_MotionType:
        r"""
        (MotionExtractor_MotionType):  [Read-Write] Type of motion to extract
        """
        ...
    @motion_type.setter
    def motion_type(self, value: MotionExtractor_MotionType) -> None:
        ...
    @property
    def axis(self) -> MotionExtractor_Axis:
        r"""
        (MotionExtractor_Axis):  [Read-Write] Axis to get the value from
        """
        ...
    @axis.setter
    def axis(self, value: MotionExtractor_Axis) -> None:
        ...
    @property
    def remove_curve_on_revert(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we want to remove the curve when we revert or re-apply modifier
                      Disabling this allows you to modify settings and create a new curve each time you re-apply the modifier
                      Enabling this is the preferred setting when using a modifier that's applied in bulk and you may want to remove/rename curves
        """
        ...
    @remove_curve_on_revert.setter
    def remove_curve_on_revert(self, value: bool) -> None:
        ...
    @property
    def relative_to_first_frame(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to extract the bone transforms relative to the first frame in the animation
        """
        ...
    @relative_to_first_frame.setter
    def relative_to_first_frame(self, value: bool) -> None:
        ...
    @property
    def space(self) -> MotionExtractor_Space:
        r"""
        (MotionExtractor_Space):  [Read-Write] Reference frame/space to use when extracting the bone pose.
        """
        ...
    @space.setter
    def space(self, value: MotionExtractor_Space) -> None:
        ...
    @property
    def absolute_value(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to convert the final value to absolute (positive)
        """
        ...
    @absolute_value.setter
    def absolute_value(self, value: bool) -> None:
        ...
    @property
    def math_operation(self) -> MotionExtractor_MathOperation:
        r"""
        (MotionExtractor_MathOperation):  [Read-Write] Optional math operation to apply on the extracted value before add it to the generated curve
        """
        ...
    @math_operation.setter
    def math_operation(self, value: MotionExtractor_MathOperation) -> None:
        ...
    @property
    def modifier(self) -> float:
        r"""
        (float):  [Read-Write] Right operand for the math operation selected
        """
        ...
    @modifier.setter
    def modifier(self, value: float) -> None:
        ...
    @property
    def normalize(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we want a normalized value (0 - 1)
        """
        ...
    @normalize.setter
    def normalize(self, value: bool) -> None:
        ...
    @property
    def use_custom_curve_name(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether we want to specify a custom name for the curve. If false, the name of the curve will be auto generated based on the data we are going to extract
        """
        ...
    @use_custom_curve_name.setter
    def use_custom_curve_name(self, value: bool) -> None:
        ...
    @property
    def custom_curve_name(self) -> Name:
        r"""
        (Name):  [Read-Write] Custom name for the curve we are going to generate.
        """
        ...
    @custom_curve_name.setter
    def custom_curve_name(self, value: Name) -> None:
        ...

class TemplateSequenceSection(MovieSceneSubSection):
    r"""
    Defines the section for a template sequence track.
    
    **C++ Source:**
    
    - **Plugin**: TemplateSequence
    - **Module**: TemplateSequence
    - **File**: TemplateSequenceSection.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``color_tint`` (Color):  [Read-Write] The color tint for this section
    - ``easing`` (MovieSceneEasingSettings):  [Read-Write]
    - ``eval_options`` (MovieSceneSectionEvalOptions):  [Read-Write]
    - ``is_active`` (bool):  [Read-Write] Toggle whether this section is active/inactive
    - ``is_locked`` (bool):  [Read-Write] Toggle whether this section is locked/unlocked
    - ``network_mask`` (uint8):  [Read-Write]
    - ``parameters`` (MovieSceneSectionParameters):  [Read-Write]
    - ``post_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to continue 'postrolling' this section for after evaluation has ended.
    - ``pre_roll_frames`` (FrameNumber):  [Read-Write] The amount of time to prepare this section for evaluation before it actually starts.
    - ``section_range`` (MovieSceneFrameRange):  [Read-Write] The range in which this section is active
    - ``sub_sequence`` (MovieSceneSequence):  [Read-Write] Movie scene being played by this section
    - ``timecode_source`` (MovieSceneTimecodeSource):  [Read-Write] The timecode at which this movie scene section is based (ie. when it was recorded)
    """
    ...

class TemplateSequenceActor(Actor):
    r"""
    Actor responsible for controlling a specific template sequence in the world.
    
    **C++ Source:**
    
    - **Plugin**: TemplateSequence
    - **Module**: TemplateSequence
    - **File**: TemplateSequenceActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``binding_override`` (TemplateSequenceBindingOverrideData):  [Read-Write] The override for the template sequence's root object binding. See SetBinding.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``playback_settings`` (MovieSceneSequencePlaybackSettings):  [Read-Write]
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``sequence_player`` (TemplateSequencePlayer):  [Read-Write]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``template_sequence`` (SoftObjectPath):  [Read-Write]
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def playback_settings(self) -> MovieSceneSequencePlaybackSettings:
        r"""
        (MovieSceneSequencePlaybackSettings):  [Read-Only]
        """
        ...
    @property
    def sequence_player(self) -> TemplateSequencePlayer:
        r"""
        (TemplateSequencePlayer):  [Read-Only]
        """
        ...
    @property
    def template_sequence(self) -> SoftObjectPath:
        r"""
        (SoftObjectPath):  [Read-Only]
        """
        ...
    @property
    def binding_override(self) -> TemplateSequenceBindingOverrideData:
        r"""
        (TemplateSequenceBindingOverrideData):  [Read-Only] The override for the template sequence's root object binding. See SetBinding.
        """
        ...
    def set_sequence(self, sequence: TemplateSequence) -> None:
        r"""
        x.set_sequence(sequence) -> None
        Set the template sequence being played by this actor.
        
        Args:
            sequence (TemplateSequence):
        """
        ...
    def set_binding(self, actor: Actor, overrides_default: bool = True) -> None:
        r"""
        x.set_binding(actor, overrides_default=True) -> None
        Set the actor to play the template sequence onto, by setting up an override for the template
        sequence's root object binding.
        
        Args:
            actor (Actor): 
            overrides_default (bool):
        """
        ...
    def load_sequence(self) -> TemplateSequence:
        r"""
        x.load_sequence() -> TemplateSequence
        Get the template sequence being played by this actor.
        
        Returns:
            TemplateSequence: the template sequence, or nullptr if it is not assigned or cannot be loaded
        """
        ...
    def get_sequence(self) -> TemplateSequence:
        r"""
        x.get_sequence() -> TemplateSequence
        Get the template sequence being played by this actor.
        
        Returns:
            TemplateSequence: the template sequence, or nullptr if it is not assigned or cannot be loaded
        """
        ...

class TemplateSequencePlayer(MovieSceneSequencePlayer):
    r"""
    Template Sequence Player
    
    **C++ Source:**
    
    - **Plugin**: TemplateSequence
    - **Module**: TemplateSequence
    - **File**: TemplateSequencePlayer.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_finished`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player finishes naturally (without explicitly calling stop)
    - ``on_pause`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is paused
    - ``on_play`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is played
    - ``on_play_reverse`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is played in reverse
    - ``on_stop`` (OnMovieSceneSequencePlayerEvent):  [Read-Write] Event triggered when the level sequence player is stopped
    """
    @classmethod
    def create_template_sequence_player(cls, world_context_object: Object, template_sequence: TemplateSequence, settings: MovieSceneSequencePlaybackSettings) -> Tuple[TemplateSequencePlayer, TemplateSequenceActor]:
        r"""
        X.create_template_sequence_player(world_context_object, template_sequence, settings) -> (TemplateSequencePlayer, out_actor=TemplateSequenceActor)
        Create Template Sequence Player
        
        Args:
            world_context_object (Object): 
            template_sequence (TemplateSequence): 
            settings (MovieSceneSequencePlaybackSettings): 
        
        Returns:
            TemplateSequenceActor: 
        
            out_actor (TemplateSequenceActor):
        """
        ...

class SequenceCameraShakeTestUtil(BlueprintFunctionLibrary):
    r"""
    Sequence Camera Shake Test Util
    
    **C++ Source:**
    
    - **Plugin**: TemplateSequence
    - **Module**: TemplateSequence
    - **File**: SequenceCameraShakeTestUtil.h
    
    """
    @classmethod
    def get_post_process_blend_cache(cls, player_controller: PlayerController, pp_index: int) -> Optional[Tuple[PostProcessSettings, float]]:
        r"""
        X.get_post_process_blend_cache(player_controller, pp_index) -> (out_pp_settings=PostProcessSettings, out_pp_blend_weight=float) or None
        Get Post Process Blend Cache
        
        Args:
            player_controller (PlayerController): 
            pp_index (int32): 
        
        Returns:
            tuple or None: 
        
            out_pp_settings (PostProcessSettings): 
        
            out_pp_blend_weight (float):
        """
        ...
    @classmethod
    def get_last_frame_camera_cache_pov(cls, player_controller: PlayerController) -> MinimalViewInfo:
        r"""
        X.get_last_frame_camera_cache_pov(player_controller) -> MinimalViewInfo
        Get Last Frame Camera Cache POV
        
        Args:
            player_controller (PlayerController): 
        
        Returns:
            MinimalViewInfo:
        """
        ...
    @classmethod
    def get_camera_cache_pov(cls, player_controller: PlayerController) -> MinimalViewInfo:
        r"""
        X.get_camera_cache_pov(player_controller) -> MinimalViewInfo
        Get Camera Cache POV
        
        Args:
            player_controller (PlayerController): 
        
        Returns:
            MinimalViewInfo:
        """
        ...

class TemplateSequenceTrack(MovieSceneSubTrack):
    r"""
    Template Sequence Track
    
    **C++ Source:**
    
    - **Plugin**: TemplateSequence
    - **Module**: TemplateSequence
    - **File**: TemplateSequenceTrack.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``display_name`` (Text):  [Read-Write] The track's human readable display name.
    - ``display_options`` (MovieSceneTrackDisplayOptions):  [Read-Write] General display options for a given track
    - ``eval_options`` (MovieSceneTrackEvalOptions):  [Read-Write] General evaluation options for a given track
    - ``track_row_display_names`` (Array[Text]):  [Read-Write] The track display name per row.
    - ``track_tint`` (Color):  [Read-Write] This track's tint color
    """
    ...

class PaperSpriteAtlasFactory(Factory):
    r"""
    Paper Sprite Atlas Factory
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2DEditor
    - **File**: PaperSpriteAtlasFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PaperFlipbookFactory(Factory):
    r"""
    Factory for flipbooks
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2DEditor
    - **File**: PaperFlipbookFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PaperSpriteFactory(Factory):
    r"""
    Paper Sprite Factory
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2DEditor
    - **File**: PaperSpriteFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PaperTileMapFactory(Factory):
    r"""
    Paper Tile Map Factory
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2DEditor
    - **File**: PaperTileMapFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PaperTileMapPromotionFactory(Factory):
    r"""
    Paper Tile Map Promotion Factory
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2DEditor
    - **File**: PaperTileMapPromotionFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PaperTileSetFactory(Factory):
    r"""
    Paper Tile Set Factory
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2DEditor
    - **File**: PaperTileSetFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TileMapAssetImportData(AssetImportData):
    r"""
    Base class for import data and options used when importing a tile map
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2DEditor
    - **File**: TileMapAssetImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    """
    ...

class TileSheetPaddingFactory(Factory):
    r"""
    Factory used to pad out each individual tile in a tile sheet texture
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: Paper2DEditor
    - **File**: TileSheetPaddingFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``extrusion_amount`` (int32):  [Read-Write] The amount to extrude out from each tile (in pixels)
    - ``fill_with_transparent_black`` (bool):  [Read-Write] Should we use transparent black or white when filling the texture areas that aren't covered by tiles?
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``pad_to_power_of2`` (bool):  [Read-Write] Should we pad the texture to the next power of 2?
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PaperSpriteSheet(Object):
    r"""
    Paper Sprite Sheet
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: PaperSpriteSheetImporter
    - **File**: PaperSpriteSheet.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_data`` (AssetImportData):  [Read-Only] Import data for this
    - ``normal_map_texture`` (Texture2D):  [Read-Only] The asset that was created for NormalMapTextureName (if any)
    - ``normal_map_texture_name`` (str):  [Read-Only] The name of the normal map texture during import (if any)
    - ``sprite_names`` (Array[str]):  [Read-Only] The names of sprites during import
    - ``sprites`` (Array[PaperSprite]):  [Read-Only]
    - ``texture`` (Texture2D):  [Read-Only] The asset that was created for TextureName
    - ``texture_name`` (str):  [Read-Only] The name of the default or diffuse texture during import
    """
    ...

class PaperSpriteSheetImportFactory(Factory):
    r"""
    Imports a sprite sheet (and associated paper sprites and textures) from a JSON file exported from Adobe Flash CS6, Texture Packer, or other compatible tool
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: PaperSpriteSheetImporter
    - **File**: PaperSpriteSheetImportFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PaperSpriteSheetReimportFactory(PaperSpriteSheetImportFactory):
    r"""
    Reimports a UPaperSpriteSheet asset
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: PaperSpriteSheetImporter
    - **File**: PaperSpriteSheetReimportFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PaperTiledImporterFactory(Factory):
    r"""
    Imports a tile map (and associated textures & tile sets) exported from Tiled (http:www.mapeditor.org/)
    
    **C++ Source:**
    
    - **Plugin**: Paper2D
    - **Module**: PaperTiledImporter
    - **File**: PaperTiledImporterFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class EditorAssetLibrary(BlueprintFunctionLibrary):
    r"""
    Utility class to do most of the common functionalities with the ContentBrowser.
    The AssetRegistryHelpers class has more complex utilities. Use FindAssetData to get a FAssetData from an Asset Path.
    The Asset Path can be represented by
                ie. (Reference/Text Path)       StaticMesh'/Game/MyFolder/MyAsset.MyAsset'
                ie. (Full Name)                         StaticMesh /Game/MyFolder/MyAsset.MyAsset
                ie. (Path Name)                         /Game/MyFolder/MyAsset.MyAsset
                ie. (Package Name)                      /Game/MyFolder/MyAsset
    The Directory Path can be represented by
                ie. /Game/MyNewFolder/
                ie. /Game/MyNewFolder
    All operations can be slow. The editor should not be in play in editor mode. It will not work on assets of the type level.
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorAssetLibrary.h
    
    """
    @classmethod
    def sync_browser_to_objects(cls, asset_paths: Array[str]) -> None:
        r"""
        X.sync_browser_to_objects(asset_paths) -> None
        Sync the Content Browser to the given asset(s)
        
        Args:
            asset_paths (Array[str]): The list of asset paths to sync to in the Content Browser
        """
        ...
    @classmethod
    def set_metadata_tag(cls, object: Object, tag: Name, value: str) -> None:
        r"""
        X.set_metadata_tag(object, tag, value) -> None
        Set the value associated with a given tag of a loaded asset's metadata.
        
        Args:
            object (Object): The object from which to retrieve the metadata.
            tag (Name): The tag to set in the metadata.
            value (str): The string value to associate with the tag.
        """
        ...
    @classmethod
    def save_loaded_assets(cls, assets_to_save: Array[Object], only_if_is_dirty: bool = True) -> bool:
        r"""
        X.save_loaded_assets(assets_to_save, only_if_is_dirty=True) -> bool
        Save the packages the assets live in. All objects that live in the package will be saved. Will try to checkout the files.
        
        Args:
            assets_to_save (Array[Object]): 
            only_if_is_dirty (bool): Only checkout asset that are dirty.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def save_loaded_asset(cls, asset_to_save: Object, only_if_is_dirty: bool = True) -> bool:
        r"""
        X.save_loaded_asset(asset_to_save, only_if_is_dirty=True) -> bool
        Save the packages the assets live in. All objects that live in the package will be saved. Will try to checkout the file.
        
        Args:
            asset_to_save (Object): Asset that we want to save.
            only_if_is_dirty (bool): Only checkout asset that are dirty.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def save_directory(cls, directory_path: str, only_if_is_dirty: bool = True, recursive: bool = True) -> bool:
        r"""
        X.save_directory(directory_path, only_if_is_dirty=True, recursive=True) -> bool
        Save the packages the assets live in inside the directory. All objects that are in the directory will be saved.
        Will try to checkout the file first. Assets will be loaded before being saved.
        
        Args:
            directory_path (str): Directory that will be checked out and saved.
            only_if_is_dirty (bool): Only checkout asset that are dirty.
            recursive (bool): The search will be recursive and it will save the asset in the sub folders.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def save_asset(cls, asset_to_save: str, only_if_is_dirty: bool = True) -> bool:
        r"""
        X.save_asset(asset_to_save, only_if_is_dirty=True) -> bool
        Save the packages the assets live in. All objects that live in the package will be saved.
        Will try to checkout the file first. The Asset will be loaded before being saved.
        
        Args:
            asset_to_save (str): 
            only_if_is_dirty (bool): Only checkout/save the asset if it's dirty.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def rename_loaded_asset(cls, source_asset: Object, destination_asset_path: str) -> bool:
        r"""
        X.rename_loaded_asset(source_asset, destination_asset_path) -> bool
        Rename an asset from the Content Browser that is already loaded.
        Equivalent to a Move operation. Will try to checkout the files.
        
        Args:
            source_asset (Object): Asset that we want to copy from.
            destination_asset_path (str): Asset Path of the duplicated asset.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def rename_directory(cls, source_directory_path: str, destination_directory_path: str) -> bool:
        r"""
        X.rename_directory(source_directory_path, destination_directory_path) -> bool
        Rename assets from the Content Browser that are in the folder.
        Equivalent to a Move operation. Will try to checkout the files. The Assets will be loaded before being renamed.
        
        Args:
            source_directory_path (str): Directory of the assets that we want to rename from.
            destination_directory_path (str): Directory of the renamed asset.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def rename_asset(cls, source_asset_path: str, destination_asset_path: str) -> bool:
        r"""
        X.rename_asset(source_asset_path, destination_asset_path) -> bool
        Rename an asset from the Content Browser. Equivalent to a Move operation.
        Will try to checkout the file. The Asset will be loaded before being renamed.
        
        Args:
            source_asset_path (str): Asset Path of the asset that we want to copy from.
            destination_asset_path (str): Asset Path of the renamed asset.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def remove_metadata_tag(cls, object: Object, tag: Name) -> None:
        r"""
        X.remove_metadata_tag(object, tag) -> None
        Remove the given tag from a loaded asset's metadata.
        
        Args:
            object (Object): The object from which to retrieve the metadata.
            tag (Name): The tag to remove from the metadata.
        """
        ...
    @classmethod
    def make_directory(cls, directory_path: str) -> bool:
        r"""
        X.make_directory(directory_path) -> bool
        Create the directory on disk and in the Content Browser.
        
        Args:
            directory_path (str): Long Path Name of the directory.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def load_blueprint_class(cls, asset_path: str) -> Class:
        r"""
        X.load_blueprint_class(asset_path) -> type(Class)
        Load a Blueprint asset from the Content Browser and return its generated class. It will verify if the object is already loaded and only load it if it's necessary.
        
        Args:
            asset_path (str): Asset Path of the Blueprint asset.
        
        Returns:
            type(Class): Found or loaded class.
        """
        ...
    @classmethod
    def load_asset(cls, asset_path: str) -> Object:
        r"""
        X.load_asset(asset_path) -> Object
        Load an asset from the Content Browser. It will verify if the object is already loaded and only load it if it's necessary.
        
        Args:
            asset_path (str): Asset Path of the asset (that is not a level).
        
        Returns:
            Object: Found or loaded asset.
        """
        ...
    @classmethod
    def list_assets(cls, directory_path: str, recursive: bool = True, include_folder: bool = False) -> Array[str]:
        r"""
        X.list_assets(directory_path, recursive=True, include_folder=False) -> Array[str]
        Return the list of all the assets found in the DirectoryPath.
        
        Args:
            directory_path (str): Directory path of the asset we want the list from.
            recursive (bool): The search will be recursive and will look in sub folders.
            include_folder (bool): The result will include folders name.
        
        Returns:
            Array[str]: The list of asset found.
        """
        ...
    @classmethod
    def list_asset_by_tag_value(cls, tag_name: Name, tag_value: str) -> Array[str]:
        r"""
        X.list_asset_by_tag_value(tag_name, tag_value) -> Array[str]
        Return the list of all the assets that have the pair of Tag/Value.
        
        Args:
            tag_name (Name): The tag associated with the assets requested.
            tag_value (str): The value associated with the assets requested.
        
        Returns:
            Array[str]: The list of asset found.
        """
        ...
    @classmethod
    def get_tag_values(cls, asset_path: str) -> Map[Name, str]:
        r"""
        X.get_tag_values(asset_path) -> Map[Name, str]
        Gets all TagValues (from Asset Registry) associated with an (unloaded) asset as strings value.
        
        Args:
            asset_path (str): Asset Path we are trying to find.
        
        Returns:
            Map[Name, str]: The list of all TagName & TagValue.
        """
        ...
    @classmethod
    def get_project_root_asset_directory(cls) -> str:
        r"""
        X.get_project_root_asset_directory() -> str
        Historically, all project assets were stored in the logical "/Game/" directory
        when using plugins or UEFN projects, we want to ease asset reuse, and so the ambiguous
        "/Game/" directory is untenable. This function will return the useful project name.
        
        Returns:
            str: The current project name in UEFN, otherwise /Game/ for .uprojects
        """
        ...
    @classmethod
    def get_path_name_for_loaded_asset(cls, loaded_asset: Object) -> str:
        r"""
        X.get_path_name_for_loaded_asset(loaded_asset) -> str
        Return a valid AssetPath for a loaded asset. The asset need to be a valid asset in the Content Browser.
        Similar to GetPathName(). The format will be: /Game/MyFolder/MyAsset.MyAsset
        
        Args:
            loaded_asset (Object): Loaded Asset that exist in the Content Browser.
        
        Returns:
            str: If valid, the asset Path of the loaded asset.
        """
        ...
    @classmethod
    def get_metadata_tag_values(cls, object: Object) -> Map[Name, str]:
        r"""
        X.get_metadata_tag_values(object) -> Map[Name, str]
        Get all tags/values of a loaded asset's metadata.
        
        Args:
            object (Object): The object from which to retrieve the metadata.
        
        Returns:
            Map[Name, str]: The list of all Tags and Values.
        """
        ...
    @classmethod
    def get_metadata_tag(cls, object: Object, tag: Name) -> str:
        r"""
        X.get_metadata_tag(object, tag) -> str
        Get the value associated with the given tag of a loaded asset's metadata.
        
        Args:
            object (Object): The object from which to retrieve the metadata.
            tag (Name): The tag to find in the metadata.
        
        Returns:
            str: The string value associated with the tag.
        """
        ...
    @classmethod
    def find_package_referencers_for_asset(cls, asset_path: str, load_assets_to_confirm: bool = False) -> Array[str]:
        r"""
        X.find_package_referencers_for_asset(asset_path, load_assets_to_confirm=False) -> Array[str]
        Find Package Referencers for an asset. Only Soft and Hard dependencies would be looked for.
        Soft are dependencies which don't need to be loaded for the object to be used.
        Had are dependencies which are required for correct usage of the source asset and must be loaded at the same time.
        Other references may exist. The asset may be currently used in memory by another asset, by the editor or by code.
        Package dependencies are cached with the asset. False positive can happen until all the assets are loaded and re-saved.
        
        Args:
            asset_path (str): Asset Path of the asset that we are looking for (that is not a level).
            load_assets_to_confirm (bool): The asset and the referencers will be loaded (if not a level) to confirm the dependencies.
        
        Returns:
            Array[str]: The package path of the referencers.
        """
        ...
    @classmethod
    def find_asset_data(cls, asset_path: str) -> AssetData:
        r"""
        X.find_asset_data(asset_path) -> AssetData
        Return the AssetData for the Asset that can then be used with the more complex lib AssetRegistryHelpers.
        
        Args:
            asset_path (str): Asset Path we are trying to find.
        
        Returns:
            AssetData: The AssetData found.
        """
        ...
    @classmethod
    def duplicate_loaded_asset(cls, source_asset: Object, destination_asset_path: str) -> Object:
        r"""
        X.duplicate_loaded_asset(source_asset, destination_asset_path) -> Object
        Duplicate an asset from the Content Browser that is already loaded. Will try to checkout the file.
        
        Args:
            source_asset (Object): Asset that we want to copy from.
            destination_asset_path (str): Asset Path of the duplicated asset.
        
        Returns:
            Object: The duplicated object if the operation succeeds
        """
        ...
    @classmethod
    def duplicate_directory(cls, source_directory_path: str, destination_directory_path: str) -> bool:
        r"""
        X.duplicate_directory(source_directory_path, destination_directory_path) -> bool
        Duplicate asset from the Content Browser that are in the folder.
        Will try to checkout the files. The Assets will be loaded before being duplicated.
        
        Args:
            source_directory_path (str): Directory of the assets that we want to duplicate from.
            destination_directory_path (str): Directory of the duplicated asset.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def duplicate_asset(cls, source_asset_path: str, destination_asset_path: str) -> Object:
        r"""
        X.duplicate_asset(source_asset_path, destination_asset_path) -> Object
        Duplicate an asset from the Content Browser. Will try to checkout the file. The Asset will be loaded before being duplicated.
        
        Args:
            source_asset_path (str): Asset Path of the asset that we want to copy from.
            destination_asset_path (str): Asset Path of the duplicated asset.
        
        Returns:
            Object: The duplicated object if the operation succeeds.
        """
        ...
    @classmethod
    def does_directory_have_assets(cls, directory_path: str, recursive: bool = True) -> bool:
        r"""
        X.does_directory_have_assets(directory_path, recursive=True) -> bool
        Check if there any asset that exist in the directory.
        
        Args:
            directory_path (str): Long Path Name of the directory.
            recursive (bool): 
        
        Returns:
            bool: True if there is any assets.
        """
        ...
    @classmethod
    def does_directory_exist(cls, directory_path: str) -> bool:
        r"""
        X.does_directory_exist(directory_path) -> bool
        Check is the directory exist in the Content Browser.
        
        Args:
            directory_path (str): Long Path Name of the directory.
        
        Returns:
            bool: True if it does exist and it is valid.
        """
        ...
    @classmethod
    def does_asset_exist(cls, asset_path: str) -> bool:
        r"""
        X.does_asset_exist(asset_path) -> bool
        Check if the asset exists in the Content Browser.
        
        Args:
            asset_path (str): Asset Path of the asset (that is not a level).
        
        Returns:
            bool: True if it does exist and it is valid.
        """
        ...
    @classmethod
    def do_assets_exist(cls, asset_paths: Array[str]) -> bool:
        r"""
        X.do_assets_exist(asset_paths) -> bool
        Check if the assets exist in the Content Browser.
        
        Args:
            asset_paths (Array[str]): Asset Path of the assets (that are not a level).
        
        Returns:
            bool: True if they exist and it is valid.
        """
        ...
    @classmethod
    def delete_loaded_assets(cls, assets_to_delete: Array[Object]) -> bool:
        r"""
        X.delete_loaded_assets(assets_to_delete) -> bool
        Delete assets from the Content Browser that are already loaded.
        This is a Force Delete. It doesn't check if the assets have references in other Levels or by Actors.
        It will close all the asset editors and may clear the Transaction buffer (Undo History).
        Will try to mark the files as deleted.
        
        Args:
            assets_to_delete (Array[Object]): Assets that we want to delete.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def delete_loaded_asset(cls, asset_to_delete: Object) -> bool:
        r"""
        X.delete_loaded_asset(asset_to_delete) -> bool
        Delete an asset from the Content Browser that is already loaded.
        This is a Force Delete. It doesn't check if the asset has references in other Levels or by Actors.
        It will close all the asset editors and may clear the Transaction buffer (Undo History).
        Will try to mark the file as deleted.
        
        Args:
            asset_to_delete (Object): Asset that we want to delete.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def delete_directory(cls, directory_path: str) -> bool:
        r"""
        X.delete_directory(directory_path) -> bool
        Delete the packages inside a directory. If the directory is then empty, delete the directory.
        This is a Force Delete. It doesn't check if the assets have references in other Levels or by Actors.
        It will close all the asset editors and may clear the Transaction buffer (Undo History).
        Will try to mark the file as deleted. Assets will be loaded before being deleted.
        The search is always recursive. It will try to delete the sub folders.
        
        Args:
            directory_path (str): Directory that will be mark for delete and deleted.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def delete_asset(cls, asset_path_to_delete: str) -> bool:
        r"""
        X.delete_asset(asset_path_to_delete) -> bool
        Delete the package the assets live in. All objects that live in the package will be deleted.
        This is a Force Delete. It doesn't check if the asset has references in other Levels or by Actors.
        It will close all the asset editors and may clear the Transaction buffer (Undo History).
        Will try to mark the file as deleted. The Asset will be loaded before being deleted.
        
        Args:
            asset_path_to_delete (str): Asset Path of the asset that we want to delete.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def consolidate_assets(cls, asset_to_consolidate_to: Object, assets_to_consolidate: Array[Object]) -> bool:
        r"""
        X.consolidate_assets(asset_to_consolidate_to, assets_to_consolidate) -> bool
        Consolidates an asset by replacing all references/uses of the provided AssetsToConsolidate with references to AssetToConsolidateTo.
        This is useful when you want all references of assets to be replaced by a single asset.
        The function first attempts to directly replace all relevant references located within objects that are already loaded and in memory.
        Next, it deletes the AssetsToConsolidate, leaving behind object redirectors to AssetToConsolidateTo.
        note: The AssetsToConsolidate are DELETED by this function.
        note: Modified objects will be saved if the operation succeeds.
        
        Args:
            asset_to_consolidate_to (Object): Asset to which all references of the AssetsToConsolidate will instead refer to after this operation completes.
            assets_to_consolidate (Array[Object]): All references to these assets will be modified to reference AssetToConsolidateTo instead.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def checkout_loaded_assets(cls, assets_to_checkout: Array[Object]) -> bool:
        r"""
        X.checkout_loaded_assets(assets_to_checkout) -> bool
        Checkout the assets from the Content Browser.
        
        Args:
            assets_to_checkout (Array[Object]): 
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def checkout_loaded_asset(cls, asset_to_checkout: Object) -> bool:
        r"""
        X.checkout_loaded_asset(asset_to_checkout) -> bool
        Checkout the asset from the Content Browser.
        
        Args:
            asset_to_checkout (Object): Asset to checkout.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def checkout_directory(cls, directory_path: str, recursive: bool = True) -> bool:
        r"""
        X.checkout_directory(directory_path, recursive=True) -> bool
        Checkout assets from the Content Browser. It will load the assets if needed.
        All objects that are in the directory will be checkout. Assets will be loaded before being checkout.
        
        Args:
            directory_path (str): Directory of the assets that to checkout.
            recursive (bool): If the AssetPath is a folder, the search will be recursive and will checkout the asset in the sub folders.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...
    @classmethod
    def checkout_asset(cls, asset_to_checkout: str) -> bool:
        r"""
        X.checkout_asset(asset_to_checkout) -> bool
        Checkout the asset from the Content Browser.
        
        Args:
            asset_to_checkout (str): Asset Path of the asset that we want to checkout.
        
        Returns:
            bool: True if the operation succeeds.
        """
        ...

class EditorDialog(BlueprintFunctionLibrary):
    r"""
    Utility class to create simple pop-up dialogs to notify the user of task completion,
    or to ask them to make simple Yes/No/Retry/Cancel type decisions.
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorDialogLibrary.h
    
    """
    @classmethod
    def show_suppressable_warning_dialog(cls, title: Text, message: Text, ini_setting_name: str, ini_setting_file_name_override: str = "", default_value: bool = True) -> bool:
        r"""
        X.show_suppressable_warning_dialog(title, message, ini_setting_name, ini_setting_file_name_override="", default_value=True) -> bool
        Open a modal suppressable warning window, if suppressed will return the default value
        
        Args:
            title (Text): The title of the created dialog window
            message (Text): Text of the message to show
            ini_setting_name (str): The name of the entry in the INI where the state of the "Disable this warning" check box is stored
            ini_setting_file_name_override (str): The name of the INI where the state of the InIniSettingName flag is stored (defaults to GEditorPerProjectIni)
            default_value (bool): If the warning is suppressed, the function will log and return DefaultValue
        
        Returns:
            bool: The result of the users decision, or DefaultValue if suppressed.
        """
        ...
    @classmethod
    def show_objects_details_view(cls, title: Text, out_objects: Array[Object], options: EditorDialogLibraryObjectDetailsViewOptions = [True, True, False, 0, 0, 0.600000]) -> bool:
        r"""
        X.show_objects_details_view(title, out_objects, options=[True, True, False, 0, 0, 0.600000]) -> bool
        Open a modal message box dialog containing a details view for inspecting / modifying multiples UObjects.
        
        Args:
            title (Text): The title of the created dialog window
            out_objects (Array[Object]): Array of object instances which are supposed to be viewed
            options (EditorDialogLibraryObjectDetailsViewOptions): Optional settings to customize the look of the details view
        
        Returns:
            bool: The result of the users decision, true=Ok, false=Cancel, or false if running in unattended mode.
        """
        ...
    @classmethod
    def show_object_details_view(cls, title: Text, out_object: Object, options: EditorDialogLibraryObjectDetailsViewOptions = [True, True, False, 0, 0, 0.600000]) -> bool:
        r"""
        X.show_object_details_view(title, out_object, options=[True, True, False, 0, 0, 0.600000]) -> bool
        Open a modal message box dialog containing a details view for inspecting / modifying a UObject.
        
        Args:
            title (Text): The title of the created dialog window
            out_object (Object): Object instance of ClassOfObject which is supposed to be viewed
            options (EditorDialogLibraryObjectDetailsViewOptions): Optional settings to customize the look of the details view
        
        Returns:
            bool: The result of the users decision, true=Ok, false=Cancel, or false if running in unattended mode.
        """
        ...
    @classmethod
    def show_message(cls, title: Text, message: Text, message_type: AppMsgType, default_value: AppReturnType = AppReturnType.NO, message_category: AppMsgCategory = AppMsgCategory.WARNING) -> AppReturnType:
        r"""
        X.show_message(title, message, message_type, default_value=AppReturnType.NO, message_category=AppMsgCategory.WARNING) -> AppReturnType
        Open a modal message box dialog with the given message. If running in "-unattended" mode it will immediately
        return the value specified by DefaultValue. If not running in "-unattended" mode then it will block execution
        until the user makes a decision, at which point their decision will be returned.
        
        Args:
            title (Text): The title of the created dialog window
            message (Text): Text of the message to show
            message_type (AppMsgType): Specifies which buttons the dialog should have
            default_value (AppReturnType): If the application is Unattended, the function will log and return DefaultValue
            message_category (AppMsgCategory): The category of the message (affects the icon used)
        
        Returns:
            AppReturnType: The result of the users decision, or DefaultValue if running in unattended mode.
        """
        ...

class EditorFilterLibrary(BlueprintFunctionLibrary):
    r"""
    Utility class to filter a list of objects. Object should be in the World Editor.
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorFilterLibrary.h
    
    """
    @classmethod
    def by_selection(cls, target_array: Array[Actor], filter_type: EditorScriptingFilterType = EditorScriptingFilterType.INCLUDE) -> Array[Actor]:
        r"""
        X.by_selection(target_array, filter_type=EditorScriptingFilterType.INCLUDE) -> Array[Actor]
        Filter the array based on Object's selection.
        
        Args:
            target_array (Array[Actor]): Array of Object to filter. The array will not change.
            filter_type (EditorScriptingFilterType): Should include or not the array's item if it respects the condition.
        
        Returns:
            Array[Actor]: The filtered list.
        """
        ...
    @classmethod
    def by_level_name(cls, target_array: Array[Actor], level_name: Name, filter_type: EditorScriptingFilterType = EditorScriptingFilterType.INCLUDE) -> Array[Actor]:
        r"""
        X.by_level_name(target_array, level_name, filter_type=EditorScriptingFilterType.INCLUDE) -> Array[Actor]
        Filter the array by Level the Actor belongs to.
        
        Args:
            target_array (Array[Actor]): Array of Actor to filter. The array will not change.
            level_name (Name): The name of the Level the actor belongs to (same name as in the ContentBrowser).
            filter_type (EditorScriptingFilterType): Should include or not the array's item if it respects the condition.
        
        Returns:
            Array[Actor]: The filtered list.
        """
        ...
    @classmethod
    def by_layer(cls, target_array: Array[Actor], layer_name: Name, filter_type: EditorScriptingFilterType = EditorScriptingFilterType.INCLUDE) -> Array[Actor]:
        r"""
        X.by_layer(target_array, layer_name, filter_type=EditorScriptingFilterType.INCLUDE) -> Array[Actor]
        Filter the array by Layer the Actor belongs to.
        
        Args:
            target_array (Array[Actor]): Array of Actor to filter. The array will not change.
            layer_name (Name): The exact name of the Layer the actor belongs to.
            filter_type (EditorScriptingFilterType): Should include or not the array's item if it respects the condition.
        
        Returns:
            Array[Actor]: The filtered list.
        """
        ...
    @classmethod
    def by_id_name(cls, target_array: Array[Object], name_sub_string: str, string_match: EditorScriptingStringMatchType = EditorScriptingStringMatchType.CONTAINS, filter_type: EditorScriptingFilterType = EditorScriptingFilterType.INCLUDE) -> Array[Object]:
        r"""
        X.by_id_name(target_array, name_sub_string, string_match=EditorScriptingStringMatchType.CONTAINS, filter_type=EditorScriptingFilterType.INCLUDE) -> Array[Object]
        Filter the array based on the Object's ID name.
        
        Args:
            target_array (Array[Object]): Array of Object to filter. The array will not change.
            name_sub_string (str): The text the Object's ID name.
            string_match (EditorScriptingStringMatchType): Contains the NameSubString OR matches with the wildcard *? OR exactly the same value.
            filter_type (EditorScriptingFilterType): Should include or not the array's item if it respects the condition.
        
        Returns:
            Array[Object]: The filtered list.
        """
        ...
    @classmethod
    def by_class(cls, target_array: Array[Object], object_class: Class, filter_type: EditorScriptingFilterType = EditorScriptingFilterType.INCLUDE) -> Array[Object]:
        r"""
        X.by_class(target_array, object_class, filter_type=EditorScriptingFilterType.INCLUDE) -> Array[Object]
        Filter the array based on the Object's class.
        
        Args:
            target_array (Array[Object]): Array of Object to filter. The array will not change.
            object_class (type(Class)): The Class of the object.
            filter_type (EditorScriptingFilterType): Should include or not the array's item if it respects the condition.
        
        Returns:
            Array[Object]: The filtered list.
        """
        ...
    @classmethod
    def by_actor_tag(cls, target_array: Array[Actor], tag: Name, filter_type: EditorScriptingFilterType = EditorScriptingFilterType.INCLUDE) -> Array[Actor]:
        r"""
        X.by_actor_tag(target_array, tag, filter_type=EditorScriptingFilterType.INCLUDE) -> Array[Actor]
        Filter the array by Tag the Actor contains
        
        Args:
            target_array (Array[Actor]): Array of Actor to filter. The array will not change.
            tag (Name): The exact name of the Tag the actor contains.
            filter_type (EditorScriptingFilterType): Should include or not the array's item if it respects the condition.
        
        Returns:
            Array[Actor]: The filtered list.
        """
        ...
    @classmethod
    def by_actor_label(cls, target_array: Array[Actor], name_sub_string: str, string_match: EditorScriptingStringMatchType = EditorScriptingStringMatchType.CONTAINS, filter_type: EditorScriptingFilterType = EditorScriptingFilterType.INCLUDE, ignore_case: bool = True) -> Array[Actor]:
        r"""
        X.by_actor_label(target_array, name_sub_string, string_match=EditorScriptingStringMatchType.CONTAINS, filter_type=EditorScriptingFilterType.INCLUDE, ignore_case=True) -> Array[Actor]
        Filter the array based on the Actor's label (what we see in the editor)
        
        Args:
            target_array (Array[Actor]): Array of Actor to filter. The array will not change.
            name_sub_string (str): The text the Actor's Label.
            string_match (EditorScriptingStringMatchType): Contains the NameSubString OR matches with the wildcard *? OR exactly the same value.
            filter_type (EditorScriptingFilterType): Should include or not the array's item if it respects the condition.
            ignore_case (bool): Determines case sensitivity options for string comparisons.
        
        Returns:
            Array[Actor]: The filtered list.
        """
        ...

class EditorLevelLibrary(BlueprintFunctionLibrary):
    r"""
    Utility class to do most of the common functionalities in the World Editor.
    The editor should not be in play in editor mode.
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorLevelLibrary.h
    
    """
    @classmethod
    def spawn_actor_from_object(cls, object_to_use: Object, location: Vector, rotation: Rotator = [0.000000, 0.000000, 0.000000], transient: bool = False) -> Actor:
        r"""
        X.spawn_actor_from_object(object_to_use, location, rotation=[0.000000, 0.000000, 0.000000], transient=False) -> Actor
        Spawn Actor from Object
        
        Args:
            object_to_use (Object): 
            location (Vector): 
            rotation (Rotator): 
            transient (bool): 
        
        Returns:
            Actor:
        """
        ...
    @classmethod
    def spawn_actor_from_class(cls, actor_class: Class, location: Vector, rotation: Rotator = [0.000000, 0.000000, 0.000000], transient: bool = False) -> Actor:
        r"""
        X.spawn_actor_from_class(actor_class, location, rotation=[0.000000, 0.000000, 0.000000], transient=False) -> Actor
        Spawn Actor from Class
        
        Args:
            actor_class (type(Class)): 
            location (Vector): 
            rotation (Rotator): 
            transient (bool): 
        
        Returns:
            Actor:
        """
        ...
    @classmethod
    def set_selected_level_actors(cls, actors_to_select: Array[Actor]) -> None:
        r"""
        X.set_selected_level_actors(actors_to_select) -> None
        Set Selected Level Actors
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Editor Actor Utilities Subsystem
        
        Args:
            actors_to_select (Array[Actor]):
        """
        ...
    @classmethod
    def set_level_viewport_camera_info(cls, camera_location: Vector, camera_rotation: Rotator) -> None:
        r"""
        X.set_level_viewport_camera_info(camera_location, camera_rotation) -> None
        Set Level Viewport Camera Info
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Unreal Editor Subsystem
        
        Args:
            camera_location (Vector): 
            camera_rotation (Rotator):
        """
        ...
    @classmethod
    def set_current_level_by_name(cls, level_name: Name) -> bool:
        r"""
        X.set_current_level_by_name(level_name) -> bool
        Set Current Level by Name
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Level Editor Subsystem
        
        Args:
            level_name (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_actor_selection_state(cls, actor: Actor, should_be_selected: bool) -> None:
        r"""
        X.set_actor_selection_state(actor, should_be_selected) -> None
        Set Actor Selection State
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Editor Actor Utilities Subsystem
        
        Args:
            actor (Actor): 
            should_be_selected (bool):
        """
        ...
    @classmethod
    def select_nothing(cls) -> None:
        r"""
        X.select_nothing() -> None
        Select Nothing
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Editor Actor Utilities Subsystem
        """
        ...
    @classmethod
    def save_current_level(cls) -> bool:
        r"""
        X.save_current_level() -> bool
        Save Current Level
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Level Editor Subsystem
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def save_all_dirty_levels(cls) -> bool:
        r"""
        X.save_all_dirty_levels() -> bool
        Save All Dirty Levels
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Level Editor Subsystem
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def replace_selected_actors(cls, asset_path: str) -> None:
        r"""
        X.replace_selected_actors(asset_path) -> None
        Replaces the selected Actors with the same number of a different kind of Actor using the specified factory to spawn the new Actors
        note that only Location, Rotation, Drawscale, Drawscale3D, Tag, and Group are copied from the old Actors
        
        Args:
            asset_path (str):
        """
        ...
    @classmethod
    def replace_mesh_components_meshes_on_actors(cls, actors: Array[Actor], mesh_to_be_replaced: StaticMesh, new_mesh: StaticMesh) -> None:
        r"""
        X.replace_mesh_components_meshes_on_actors(actors, mesh_to_be_replaced, new_mesh) -> None
        Replace Mesh Components Meshes on Actors
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            actors (Array[Actor]): 
            mesh_to_be_replaced (StaticMesh): 
            new_mesh (StaticMesh):
        """
        ...
    @classmethod
    def replace_mesh_components_meshes(cls, mesh_components: Array[StaticMeshComponent], mesh_to_be_replaced: StaticMesh, new_mesh: StaticMesh) -> None:
        r"""
        X.replace_mesh_components_meshes(mesh_components, mesh_to_be_replaced, new_mesh) -> None
        Replace Mesh Components Meshes
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            mesh_components (Array[StaticMeshComponent]): 
            mesh_to_be_replaced (StaticMesh): 
            new_mesh (StaticMesh):
        """
        ...
    @classmethod
    def replace_mesh_components_materials_on_actors(cls, actors: Array[Actor], material_to_be_replaced: MaterialInterface, new_material: MaterialInterface) -> None:
        r"""
        X.replace_mesh_components_materials_on_actors(actors, material_to_be_replaced, new_material) -> None
        Replace Mesh Components Materials on Actors
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            actors (Array[Actor]): 
            material_to_be_replaced (MaterialInterface): 
            new_material (MaterialInterface):
        """
        ...
    @classmethod
    def replace_mesh_components_materials(cls, mesh_components: Array[MeshComponent], material_to_be_replaced: MaterialInterface, new_material: MaterialInterface) -> None:
        r"""
        X.replace_mesh_components_materials(mesh_components, material_to_be_replaced, new_material) -> None
        Replace Mesh Components Materials
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            mesh_components (Array[MeshComponent]): 
            material_to_be_replaced (MaterialInterface): 
            new_material (MaterialInterface):
        """
        ...
    @classmethod
    def pilot_level_actor(cls, actor_to_pilot: Actor) -> None:
        r"""
        X.pilot_level_actor(actor_to_pilot) -> None
        Pilot Level Actor
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Level Editor Subsystem
        
        Args:
            actor_to_pilot (Actor):
        """
        ...
    @classmethod
    def new_level_from_template(cls, asset_path: str, template_asset_path: str) -> bool:
        r"""
        X.new_level_from_template(asset_path, template_asset_path) -> bool
        New Level from Template
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Level Editor Subsystem
        
        Args:
            asset_path (str): 
            template_asset_path (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def new_level(cls, asset_path: str) -> bool:
        r"""
        X.new_level(asset_path) -> bool
        New Level
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Level Editor Subsystem
        
        Args:
            asset_path (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def merge_static_mesh_actors(cls, actors_to_merge: Array[StaticMeshActor], merge_options: MergeStaticMeshActorsOptions) -> Optional[StaticMeshActor]:
        r"""
        X.merge_static_mesh_actors(actors_to_merge, merge_options) -> StaticMeshActor or None
        Merge Static Mesh Actors
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            actors_to_merge (Array[StaticMeshActor]): 
            merge_options (MergeStaticMeshActorsOptions): 
        
        Returns:
            StaticMeshActor or None: 
        
            out_merged_actor (StaticMeshActor):
        """
        ...
    @classmethod
    def load_level(cls, asset_path: str) -> bool:
        r"""
        X.load_level(asset_path) -> bool
        Load Level
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Level Editor Subsystem
        
        Args:
            asset_path (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def join_static_mesh_actors(cls, actors_to_join: Array[StaticMeshActor], join_options: JoinStaticMeshActorsOptions) -> Actor:
        r"""
        X.join_static_mesh_actors(actors_to_join, join_options) -> Actor
        Join Static Mesh Actors
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            actors_to_join (Array[StaticMeshActor]): 
            join_options (JoinStaticMeshActorsOptions): 
        
        Returns:
            Actor:
        """
        ...
    @classmethod
    def get_selected_level_actors(cls) -> Array[Actor]:
        r"""
        X.get_selected_level_actors() -> Array[Actor]
        Get Selected Level Actors
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Editor Actor Utilities Subsystem
        
        Returns:
            Array[Actor]:
        """
        ...
    @classmethod
    def get_pie_worlds(cls, include_dedicated_server: bool) -> Array[World]:
        r"""
        X.get_pie_worlds(include_dedicated_server) -> Array[World]
        Get PIEWorlds
        
        Args:
            include_dedicated_server (bool): 
        
        Returns:
            Array[World]:
        """
        ...
    @classmethod
    def get_level_viewport_camera_info(cls) -> Optional[Tuple[Vector, Rotator]]:
        r"""
        X.get_level_viewport_camera_info() -> (camera_location=Vector, camera_rotation=Rotator) or None
        Get Level Viewport Camera Info
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Unreal Editor Subsystem
        
        Returns:
            tuple or None: 
        
            camera_location (Vector): 
        
            camera_rotation (Rotator):
        """
        ...
    @classmethod
    def get_game_world(cls) -> World:
        r"""
        X.get_game_world() -> World
        Get Game World
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Unreal Editor Subsystem
        
        Returns:
            World:
        """
        ...
    @classmethod
    def get_editor_world(cls) -> World:
        r"""
        X.get_editor_world() -> World
        Get Editor World
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Unreal Editor Subsystem
        
        Returns:
            World:
        """
        ...
    @classmethod
    def get_all_level_actors_components(cls) -> Array[ActorComponent]:
        r"""
        X.get_all_level_actors_components() -> Array[ActorComponent]
        Get All Level Actors Components
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Editor Actor Utilities Subsystem
        
        Returns:
            Array[ActorComponent]:
        """
        ...
    @classmethod
    def get_all_level_actors(cls) -> Array[Actor]:
        r"""
        X.get_all_level_actors() -> Array[Actor]
        Get All Level Actors
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Editor Actor Utilities Subsystem
        
        Returns:
            Array[Actor]:
        """
        ...
    @classmethod
    def get_actor_reference(cls, path_to_actor: str) -> Actor:
        r"""
        X.get_actor_reference(path_to_actor) -> Actor
        Get Actor Reference
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Editor Actor Utilities Subsystem
        
        Args:
            path_to_actor (str): 
        
        Returns:
            Actor:
        """
        ...
    @classmethod
    def eject_pilot_level_actor(cls) -> None:
        r"""
        X.eject_pilot_level_actor() -> None
        Eject Pilot Level Actor
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Level Editor Subsystem
        """
        ...
    @classmethod
    def editor_set_game_view(cls, game_view: bool) -> None:
        r"""
        X.editor_set_game_view(game_view) -> None
        Editor Set Game View
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Level Editor Subsystem
        
        Args:
            game_view (bool):
        """
        ...
    @classmethod
    def editor_play_simulate(cls) -> None:
        r"""
        X.editor_play_simulate() -> None
        Editor Play Simulate
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Level Editor Subsystem
        """
        ...
    @classmethod
    def editor_invalidate_viewports(cls) -> None:
        r"""
        X.editor_invalidate_viewports() -> None
        Editor Invalidate Viewports
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Level Editor Subsystem
        """
        ...
    @classmethod
    def editor_end_play(cls) -> None:
        r"""
        X.editor_end_play() -> None
        Editor End Play
        """
        ...
    @classmethod
    def destroy_actor(cls, actor_to_destroy: Actor) -> bool:
        r"""
        X.destroy_actor(actor_to_destroy) -> bool
        Destroy Actor
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Editor Actor Utilities Subsystem
        
        Args:
            actor_to_destroy (Actor): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def create_proxy_mesh_actor(cls, actors_to_merge: Array[StaticMeshActor], merge_options: CreateProxyMeshActorOptions) -> Optional[StaticMeshActor]:
        r"""
        X.create_proxy_mesh_actor(actors_to_merge, merge_options) -> StaticMeshActor or None
        Create Proxy Mesh Actor
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            actors_to_merge (Array[StaticMeshActor]): 
            merge_options (CreateProxyMeshActorOptions): 
        
        Returns:
            StaticMeshActor or None: 
        
            out_merged_actor (StaticMeshActor):
        """
        ...
    @classmethod
    def convert_actors(cls, actors: Array[Actor], actor_class: Class, static_mesh_package_path: str) -> Array[Actor]:
        r"""
        X.convert_actors(actors, actor_class, static_mesh_package_path) -> Array[Actor]
        Convert Actors
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Editor Actor Utilities Subsystem
        
        Args:
            actors (Array[Actor]): 
            actor_class (type(Class)): 
            static_mesh_package_path (str): 
        
        Returns:
            Array[Actor]:
        """
        ...
    @classmethod
    def clear_actor_selection_set(cls) -> None:
        r"""
        X.clear_actor_selection_set() -> None
        Clear Actor Selection Set
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Editor Actor Utilities Subsystem
        """
        ...

class EditorPythonScripting(BlueprintFunctionLibrary):
    r"""
    Utility class for Python scripting functionality.
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorPythonScriptingLibrary.h
    
    """
    @classmethod
    def set_keep_python_script_alive(cls, new_keep_alive: bool) -> None:
        r"""
        X.set_keep_python_script_alive(new_keep_alive) -> None
        Sets the bKeepPythonScriptAlive flag.
        
        If this is false (default), it will close the editor during the next tick (when executing a Python script in the editor-environment using the UnrealEditor-Cmd commandline tool).
        If this is true, it will not close the editor by itself, and you will have to close it manually, either by setting this value to false again, or by calling a function like unreal.SystemLibrary.quit_editor().
        
        Args:
            new_keep_alive (bool): The new value of the bKeepPythonScriptAlive flag.
        """
        ...
    @classmethod
    def get_keep_python_script_alive(cls) -> bool:
        r"""
        X.get_keep_python_script_alive() -> bool
        Returns the value of the bKeepPythonScriptAlive flag.
        
        If this is false (default), it will close the editor during the next tick (when executing a Python script in the editor-environment using the UnrealEditor-Cmd commandline tool).
        If this is true, it will not close the editor by itself, and you will have to close it manually, either by setting this value to false again, or by calling a function like unreal.SystemLibrary.quit_editor().
        
        Returns:
            bool: The current value of the bKeepPythonScriptAlive flag.
        """
        ...

class EditorSkeletalMeshLibrary(BlueprintFunctionLibrary):
    r"""
    Utility class to altering and analyzing a SkeletalMesh and use the common functionalities of the SkeletalMesh Editor.
    The editor should not be in play in editor mode.
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorSkeletalMeshLibrary.h
    
    """
    @classmethod
    def strip_lod_geometry(cls, skeletal_mesh: SkeletalMesh, lod_index: int, texture_mask: Texture2D, threshold: float) -> bool:
        r"""
        X.strip_lod_geometry(skeletal_mesh, lod_index, texture_mask, threshold) -> bool
        This function will strip all triangle in the specified LOD that don't have any UV area pointing on a black pixel in the TextureMask.
        We use the UVChannel 0 to find the pixels in the texture.
        
        Args:
            skeletal_mesh (SkeletalMesh): 
            lod_index (int32): 
            texture_mask (Texture2D): 
            threshold (float): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_lod_build_settings(cls, skeletal_mesh: SkeletalMesh, lod_index: int, build_options: SkeletalMeshBuildSettings) -> None:
        r"""
        X.set_lod_build_settings(skeletal_mesh, lod_index, build_options) -> None
        Set Lod Build Settings
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem
        
        Args:
            skeletal_mesh (SkeletalMesh): 
            lod_index (int32): 
            build_options (SkeletalMeshBuildSettings):
        """
        ...
    @classmethod
    def rename_socket(cls, skeletal_mesh: SkeletalMesh, old_name: Name, new_name: Name) -> bool:
        r"""
        X.rename_socket(skeletal_mesh, old_name, new_name) -> bool
        Rename Socket
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem
        
        Args:
            skeletal_mesh (SkeletalMesh): 
            old_name (Name): 
            new_name (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def remove_lo_ds(cls, skeletal_mesh: SkeletalMesh, to_remove_lo_ds: Array[int]) -> bool:
        r"""
        X.remove_lo_ds(skeletal_mesh, to_remove_lo_ds) -> bool
        Remove all the specified LODs. This function will remove all the valid LODs in the list.
        Valid LOD is any LOD greater then 0 that exist in the skeletalmesh. We cannot remove the base LOD 0.
        
        Args:
            skeletal_mesh (SkeletalMesh): The mesh inside which we are renaming a socket
            to_remove_lo_ds (Array[int32]): The LODs we need to remove
        
        Returns:
            bool: true if the successfully remove all the LODs. False otherwise, but evedn if it return false it will have removed all valid LODs.
        """
        ...
    @classmethod
    def reimport_all_custom_lo_ds(cls, skeletal_mesh: SkeletalMesh) -> bool:
        r"""
        X.reimport_all_custom_lo_ds(skeletal_mesh) -> bool
        Reimport All Custom LODs
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem
        
        Args:
            skeletal_mesh (SkeletalMesh): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def regenerate_lod(cls, skeletal_mesh: SkeletalMesh, new_lod_count: int = 0, regenerate_even_if_imported: bool = False, generate_base_lod: bool = False) -> bool:
        r"""
        X.regenerate_lod(skeletal_mesh, new_lod_count=0, regenerate_even_if_imported=False, generate_base_lod=False) -> bool
        Regenerate LOD
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem
        
        Args:
            skeletal_mesh (SkeletalMesh): 
            new_lod_count (int32): 
            regenerate_even_if_imported (bool): 
            generate_base_lod (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def import_lod(cls, base_mesh: SkeletalMesh, lod_index: int, source_filename: str) -> int:
        r"""
        X.import_lod(base_mesh, lod_index, source_filename) -> int32
        Import LOD
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem
        
        Args:
            base_mesh (SkeletalMesh): 
            lod_index (int32): 
            source_filename (str): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_num_verts(cls, skeletal_mesh: SkeletalMesh, lod_index: int) -> int:
        r"""
        X.get_num_verts(skeletal_mesh, lod_index) -> int32
        Get Num Verts
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem
        
        Args:
            skeletal_mesh (SkeletalMesh): 
            lod_index (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_lod_count(cls, skeletal_mesh: SkeletalMesh) -> int:
        r"""
        X.get_lod_count(skeletal_mesh) -> int32
        Get LODCount
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem
        
        Args:
            skeletal_mesh (SkeletalMesh): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_lod_build_settings(cls, skeletal_mesh: SkeletalMesh, lod_index: int) -> SkeletalMeshBuildSettings:
        r"""
        X.get_lod_build_settings(skeletal_mesh, lod_index) -> SkeletalMeshBuildSettings
        Get Lod Build Settings
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem
        
        Args:
            skeletal_mesh (SkeletalMesh): 
            lod_index (int32): 
        
        Returns:
            SkeletalMeshBuildSettings: 
        
            out_build_options (SkeletalMeshBuildSettings):
        """
        ...
    @classmethod
    def create_physics_asset(cls, skeletal_mesh: SkeletalMesh) -> PhysicsAsset:
        r"""
        X.create_physics_asset(skeletal_mesh) -> PhysicsAsset
        This function creates a PhysicsAsset for the given SkeletalMesh with the same settings as if it were created through FBX import
        
        Args:
            skeletal_mesh (SkeletalMesh): 
        
        Returns:
            PhysicsAsset:
        """
        ...

class SkeletalMeshUtilitiesLibrary(EditorSkeletalMeshLibrary):
    r"""
    deprecated: 'SkeletalMeshUtilitiesLibrary' was renamed to 'EditorSkeletalMeshLibrary'.
    """
    ...

class EditorStaticMeshLibrary(BlueprintFunctionLibrary):
    r"""
    Utility class to altering and analyzing a StaticMesh and use the common functionalities of the Mesh Editor.
    The editor should not be in play in editor mode.
    
    **C++ Source:**
    
    - **Plugin**: EditorScriptingUtilities
    - **Module**: EditorScriptingUtilities
    - **File**: EditorStaticMeshLibrary.h
    
    """
    @classmethod
    def set_lods_with_notification(cls, static_mesh: StaticMesh, reduction_options: StaticMeshReductionOptions, apply_changes: bool) -> int:
        r"""
        X.set_lods_with_notification(static_mesh, reduction_options, apply_changes) -> int32
        Set Lods with Notification
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            reduction_options (StaticMeshReductionOptions): 
            apply_changes (bool): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def set_lods(cls, static_mesh: StaticMesh, reduction_options: StaticMeshReductionOptions) -> int:
        r"""
        X.set_lods(static_mesh, reduction_options) -> int32
        Set Lods
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            reduction_options (StaticMeshReductionOptions): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def set_lod_reduction_settings(cls, static_mesh: StaticMesh, lod_index: int, reduction_options: MeshReductionSettings) -> None:
        r"""
        X.set_lod_reduction_settings(static_mesh, lod_index, reduction_options) -> None
        Set Lod Reduction Settings
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
            reduction_options (MeshReductionSettings):
        """
        ...
    @classmethod
    def set_lod_from_static_mesh(cls, destination_static_mesh: StaticMesh, destination_lod_index: int, source_static_mesh: StaticMesh, source_lod_index: int, reuse_existing_material_slots: bool) -> int:
        r"""
        X.set_lod_from_static_mesh(destination_static_mesh, destination_lod_index, source_static_mesh, source_lod_index, reuse_existing_material_slots) -> int32
        Set Lod from Static Mesh
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            destination_static_mesh (StaticMesh): 
            destination_lod_index (int32): 
            source_static_mesh (StaticMesh): 
            source_lod_index (int32): 
            reuse_existing_material_slots (bool): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def set_lod_build_settings(cls, static_mesh: StaticMesh, lod_index: int, build_options: MeshBuildSettings) -> None:
        r"""
        X.set_lod_build_settings(static_mesh, lod_index, build_options) -> None
        Set Lod Build Settings
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
            build_options (MeshBuildSettings):
        """
        ...
    @classmethod
    def set_generate_lightmap_uv(cls, static_mesh: StaticMesh, generate_lightmap_u_vs: bool) -> bool:
        r"""
        X.set_generate_lightmap_uv(static_mesh, generate_lightmap_u_vs) -> bool
        Set Generate Lightmap UVs
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            generate_lightmap_u_vs (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_convex_decomposition_collisions_with_notification(cls, static_mesh: StaticMesh, hull_count: int, max_hull_verts: int, hull_precision: int, apply_changes: bool) -> bool:
        r"""
        X.set_convex_decomposition_collisions_with_notification(static_mesh, hull_count, max_hull_verts, hull_precision, apply_changes) -> bool
        Set Convex Decomposition Collisions with Notification
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            hull_count (int32): 
            max_hull_verts (int32): 
            hull_precision (int32): 
            apply_changes (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_convex_decomposition_collisions(cls, static_mesh: StaticMesh, hull_count: int, max_hull_verts: int, hull_precision: int) -> bool:
        r"""
        X.set_convex_decomposition_collisions(static_mesh, hull_count, max_hull_verts, hull_precision) -> bool
        Set Convex Decomposition Collisions
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            hull_count (int32): 
            max_hull_verts (int32): 
            hull_precision (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_allow_cpu_access(cls, static_mesh: StaticMesh, allow_cpu_access: bool) -> None:
        r"""
        X.set_allow_cpu_access(static_mesh, allow_cpu_access) -> None
        Set Allow CPUAccess
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            allow_cpu_access (bool):
        """
        ...
    @classmethod
    def remove_uv_channel(cls, static_mesh: StaticMesh, lod_index: int, uv_channel_index: int) -> bool:
        r"""
        X.remove_uv_channel(static_mesh, lod_index, uv_channel_index) -> bool
        Remove UVChannel
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
            uv_channel_index (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def remove_lods(cls, static_mesh: StaticMesh) -> bool:
        r"""
        X.remove_lods(static_mesh) -> bool
        Remove Lods
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def remove_collisions_with_notification(cls, static_mesh: StaticMesh, apply_changes: bool) -> bool:
        r"""
        X.remove_collisions_with_notification(static_mesh, apply_changes) -> bool
        Remove Collisions with Notification
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            apply_changes (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def remove_collisions(cls, static_mesh: StaticMesh) -> bool:
        r"""
        X.remove_collisions(static_mesh) -> bool
        Remove Collisions
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def reimport_all_custom_lo_ds(cls, static_mesh: StaticMesh) -> bool:
        r"""
        X.reimport_all_custom_lo_ds(static_mesh) -> bool
        Reimport All Custom LODs
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_section_collision_enabled(cls, static_mesh: StaticMesh, lod_index: int, section_index: int) -> bool:
        r"""
        X.is_section_collision_enabled(static_mesh, lod_index, section_index) -> bool
        Is Section Collision Enabled
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
            section_index (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def insert_uv_channel(cls, static_mesh: StaticMesh, lod_index: int, uv_channel_index: int) -> bool:
        r"""
        X.insert_uv_channel(static_mesh, lod_index, uv_channel_index) -> bool
        Insert UVChannel
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
            uv_channel_index (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def import_lod(cls, base_static_mesh: StaticMesh, lod_index: int, source_filename: str) -> int:
        r"""
        X.import_lod(base_static_mesh, lod_index, source_filename) -> int32
        Import LOD
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            base_static_mesh (StaticMesh): 
            lod_index (int32): 
            source_filename (str): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def has_vertex_colors(cls, static_mesh: StaticMesh) -> bool:
        r"""
        X.has_vertex_colors(static_mesh) -> bool
        Has Vertex Colors
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def has_instance_vertex_colors(cls, static_mesh_component: StaticMeshComponent) -> bool:
        r"""
        X.has_instance_vertex_colors(static_mesh_component) -> bool
        Has Instance Vertex Colors
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh_component (StaticMeshComponent): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_simple_collision_count(cls, static_mesh: StaticMesh) -> int:
        r"""
        X.get_simple_collision_count(static_mesh) -> int32
        Get Simple Collision Count
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_num_uv_channels(cls, static_mesh: StaticMesh, lod_index: int) -> int:
        r"""
        X.get_num_uv_channels(static_mesh, lod_index) -> int32
        Get Num UVChannels
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_number_verts(cls, static_mesh: StaticMesh, lod_index: int) -> int:
        r"""
        X.get_number_verts(static_mesh, lod_index) -> int32
        Get Number Verts
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_number_materials(cls, static_mesh: StaticMesh) -> int:
        r"""
        X.get_number_materials(static_mesh) -> int32
        Get Number Materials
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_lod_screen_sizes(cls, static_mesh: StaticMesh) -> Array[float]:
        r"""
        X.get_lod_screen_sizes(static_mesh) -> Array[float]
        Get Lod Screen Sizes
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            Array[float]:
        """
        ...
    @classmethod
    def get_lod_reduction_settings(cls, static_mesh: StaticMesh, lod_index: int) -> MeshReductionSettings:
        r"""
        X.get_lod_reduction_settings(static_mesh, lod_index) -> MeshReductionSettings
        Get Lod Reduction Settings
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
        
        Returns:
            MeshReductionSettings: 
        
            out_reduction_options (MeshReductionSettings):
        """
        ...
    @classmethod
    def get_lod_count(cls, static_mesh: StaticMesh) -> int:
        r"""
        X.get_lod_count(static_mesh) -> int32
        Get Lod Count
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_lod_build_settings(cls, static_mesh: StaticMesh, lod_index: int) -> MeshBuildSettings:
        r"""
        X.get_lod_build_settings(static_mesh, lod_index) -> MeshBuildSettings
        Get Lod Build Settings
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
        
        Returns:
            MeshBuildSettings: 
        
            out_build_options (MeshBuildSettings):
        """
        ...
    @classmethod
    def get_convex_collision_count(cls, static_mesh: StaticMesh) -> int:
        r"""
        X.get_convex_collision_count(static_mesh) -> int32
        Get Convex Collision Count
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_collision_complexity(cls, static_mesh: StaticMesh) -> CollisionTraceFlag:
        r"""
        X.get_collision_complexity(static_mesh) -> CollisionTraceFlag
        Get Collision Complexity
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            CollisionTraceFlag:
        """
        ...
    @classmethod
    def generate_planar_uv_channel(cls, static_mesh: StaticMesh, lod_index: int, uv_channel_index: int, position: Vector, orientation: Rotator, tiling: Vector2D) -> bool:
        r"""
        X.generate_planar_uv_channel(static_mesh, lod_index, uv_channel_index, position, orientation, tiling) -> bool
        Generate Planar UVChannel
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
            uv_channel_index (int32): 
            position (Vector): 
            orientation (Rotator): 
            tiling (Vector2D): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def generate_cylindrical_uv_channel(cls, static_mesh: StaticMesh, lod_index: int, uv_channel_index: int, position: Vector, orientation: Rotator, tiling: Vector2D) -> bool:
        r"""
        X.generate_cylindrical_uv_channel(static_mesh, lod_index, uv_channel_index, position, orientation, tiling) -> bool
        Generate Cylindrical UVChannel
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
            uv_channel_index (int32): 
            position (Vector): 
            orientation (Rotator): 
            tiling (Vector2D): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def generate_box_uv_channel(cls, static_mesh: StaticMesh, lod_index: int, uv_channel_index: int, position: Vector, orientation: Rotator, size: Vector) -> bool:
        r"""
        X.generate_box_uv_channel(static_mesh, lod_index, uv_channel_index, position, orientation, size) -> bool
        Generate Box UVChannel
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
            uv_channel_index (int32): 
            position (Vector): 
            orientation (Rotator): 
            size (Vector): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def enable_section_collision(cls, static_mesh: StaticMesh, collision_enabled: bool, lod_index: int, section_index: int) -> None:
        r"""
        X.enable_section_collision(static_mesh, collision_enabled, lod_index, section_index) -> None
        Enable Section Collision
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            collision_enabled (bool): 
            lod_index (int32): 
            section_index (int32):
        """
        ...
    @classmethod
    def enable_section_cast_shadow(cls, static_mesh: StaticMesh, cast_shadow: bool, lod_index: int, section_index: int) -> None:
        r"""
        X.enable_section_cast_shadow(static_mesh, cast_shadow, lod_index, section_index) -> None
        Enable Section Cast Shadow
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            cast_shadow (bool): 
            lod_index (int32): 
            section_index (int32):
        """
        ...
    @classmethod
    def bulk_set_convex_decomposition_collisions_with_notification(cls, static_meshes: Array[StaticMesh], hull_count: int, max_hull_verts: int, hull_precision: int, apply_changes: bool) -> bool:
        r"""
        X.bulk_set_convex_decomposition_collisions_with_notification(static_meshes, hull_count, max_hull_verts, hull_precision, apply_changes) -> bool
        Bulk Set Convex Decomposition Collisions with Notification
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_meshes (Array[StaticMesh]): 
            hull_count (int32): 
            max_hull_verts (int32): 
            hull_precision (int32): 
            apply_changes (bool): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def bulk_set_convex_decomposition_collisions(cls, static_meshes: Array[StaticMesh], hull_count: int, max_hull_verts: int, hull_precision: int) -> bool:
        r"""
        X.bulk_set_convex_decomposition_collisions(static_meshes, hull_count, max_hull_verts, hull_precision) -> bool
        Bulk Set Convex Decomposition Collisions
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_meshes (Array[StaticMesh]): 
            hull_count (int32): 
            max_hull_verts (int32): 
            hull_precision (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def add_uv_channel(cls, static_mesh: StaticMesh, lod_index: int) -> bool:
        r"""
        X.add_uv_channel(static_mesh, lod_index) -> bool
        Add UVChannel
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def add_simple_collisions_with_notification(cls, static_mesh: StaticMesh, shape_type: ScriptCollisionShapeType, apply_changes: bool) -> int:
        r"""
        X.add_simple_collisions_with_notification(static_mesh, shape_type, apply_changes) -> int32
        Add Simple Collisions with Notification
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            shape_type (ScriptCollisionShapeType): 
            apply_changes (bool): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def add_simple_collisions(cls, static_mesh: StaticMesh, shape_type: ScriptCollisionShapeType) -> int:
        r"""
        X.add_simple_collisions(static_mesh, shape_type) -> int32
        Add Simple Collisions
        deprecated: The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem
        
        Args:
            static_mesh (StaticMesh): 
            shape_type (ScriptCollisionShapeType): 
        
        Returns:
            int32:
        """
        ...

class StaticMeshUtilitiesLibrary(EditorStaticMeshLibrary):
    r"""
    deprecated: 'StaticMeshUtilitiesLibrary' was renamed to 'EditorStaticMeshLibrary'.
    """
    ...

class CurveEditorFFTFilter(CurveEditorFilterBase):
    r"""
    Curve Editor FFTFilter
    
    **C++ Source:**
    
    - **Plugin**: CurveEditorTools
    - **Module**: CurveEditorTools
    - **File**: CurveEditorFFTFilter.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``cutoff_frequency`` (float):  [Read-Write] Normalized between 0-1. In a low pass filter, the lower the value is the smoother the output. In a high pass filter the higher the value the smoother the output.
    - ``order`` (int32):  [Read-Write] The number of samples used to filter in the time domain. It maps how steep the roll off is for the filter.
    - ``response`` (CurveEditorFFTFilterClass):  [Read-Write] Which FFT filter implementation to use.
    - ``type`` (CurveEditorFFTFilterType):  [Read-Write] Which frequencies are allowed through. For example, low-pass will let low frequency through and remove high frequency noise.
    """
    @property
    def cutoff_frequency(self) -> float:
        r"""
        (float):  [Read-Write] Normalized between 0-1. In a low pass filter, the lower the value is the smoother the output. In a high pass filter the higher the value the smoother the output.
        """
        ...
    @cutoff_frequency.setter
    def cutoff_frequency(self, value: float) -> None:
        ...
    @property
    def type(self) -> CurveEditorFFTFilterType:
        r"""
        (CurveEditorFFTFilterType):  [Read-Write] Which frequencies are allowed through. For example, low-pass will let low frequency through and remove high frequency noise.
        """
        ...
    @type.setter
    def type(self, value: CurveEditorFFTFilterType) -> None:
        ...
    @property
    def response(self) -> CurveEditorFFTFilterClass:
        r"""
        (CurveEditorFFTFilterClass):  [Read-Write] Which FFT filter implementation to use.
        """
        ...
    @response.setter
    def response(self, value: CurveEditorFFTFilterClass) -> None:
        ...
    @property
    def order(self) -> int:
        r"""
        (int32):  [Read-Write] The number of samples used to filter in the time domain. It maps how steep the roll off is for the filter.
        """
        ...
    @order.setter
    def order(self, value: int) -> None:
        ...

class SpeedTreeImportFactory(Factory):
    r"""
    Speed Tree Import Factory
    
    **C++ Source:**
    
    - **Plugin**: SpeedTreeImporter
    - **Module**: SpeedTreeImporter
    - **File**: SpeedTreeImportFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ReimportSpeedTreeFactory(SpeedTreeImportFactory):
    r"""
    Reimport Speed Tree Factory
    
    **C++ Source:**
    
    - **Plugin**: SpeedTreeImporter
    - **Module**: SpeedTreeImporter
    - **File**: ReimportSpeedTreeFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class SpeedTreeImportData(AssetImportData):
    r"""
    Speed Tree Import Data
    
    **C++ Source:**
    
    - **Plugin**: SpeedTreeImporter
    - **Module**: SpeedTreeImporter
    - **File**: SpeedTreeImportData.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``import_geometry_type`` (ImportGeometryType):  [Read-Write] Choose whether to import as a 3D asset, billboard or both
    - ``include_branch_seam_smoothing`` (bool):  [Read-Write]
    - ``include_collision`` (bool):  [Read-Write]
    - ``include_color_adjustment`` (bool):  [Read-Write]
    - ``include_detail_map_check`` (bool):  [Read-Write]
    - ``include_normal_map_check`` (bool):  [Read-Write]
    - ``include_smooth_lod_check`` (bool):  [Read-Write]
    - ``include_specular_map_check`` (bool):  [Read-Write]
    - ``include_speed_tree_ao`` (bool):  [Read-Write]
    - ``include_subsurface`` (bool):  [Read-Write]
    - ``include_vertex_processing_check`` (bool):  [Read-Write]
    - ``include_wind_check`` (bool):  [Read-Write]
    - ``lod_type`` (ImportLODType):  [Read-Write] Choose whether painted foliage or individual actor
    - ``make_materials_check`` (bool):  [Read-Write]
    - ``source_data`` (AssetImportInfo):  [Read-Only] Source file data describing the files that were used to import this asset.
    - ``tree_scale`` (float):  [Read-Write] Specify the tree scale
    """
    ...

class StaticMeshLODGenerationSettings(Object):
    r"""
    UStaticMeshLODGenerationSettings is intended to be a stored version of the settings used
    by UGenerateStaticMeshLODProcess (and the associated UGenerateStaticMeshLODAssetTool).
    This UObject is exposed as an Asset type in the Editor via UStaticMeshLODGenerationSettingsFactory.
    
    The Tool uses these serialized settings as a 'Preset', ie the user can save a set
    of configured settings, or load previously-saved settings.
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: LODGenerationSettingsAsset.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``mesh_generation`` (GenerateStaticMeshLODProcessSettings):  [Read-Write]
    - ``normals`` (GenerateStaticMeshLODProcess_NormalsSettings):  [Read-Write]
    - ``preprocessing`` (GenerateStaticMeshLODProcess_PreprocessSettings):  [Read-Write]
    - ``simple_collision`` (GenerateStaticMeshLODProcess_CollisionSettings):  [Read-Write]
    - ``simplification`` (GenerateStaticMeshLODProcess_SimplifySettings):  [Read-Write]
    - ``texture_baking`` (GenerateStaticMeshLODProcess_TextureSettings):  [Read-Write]
    - ``uv_generation`` (GenerateStaticMeshLODProcess_UVSettings):  [Read-Write]
    """
    ...

class StaticMeshLODGenerationSettingsFactory(Factory):
    r"""
    Asset Factory for UStaticMeshLODGenerationSettings, which is used to save settings for
    the AutoLOD Tool/Process as an Asset in the Editor
    
    **C++ Source:**
    
    - **Plugin**: MeshLODToolset
    - **Module**: MeshLODToolset
    - **File**: LODGenerationSettingsFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class BasicLineSetComponentBase(MeshComponent):
    r"""
    Base class for component specific functionality independent of the type of line stored in the component.
    
    **C++ Source:**
    
    - **Plugin**: UVEditor
    - **Module**: UVEditorTools
    - **File**: BasicLineSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class Basic2DLineSetComponent(BasicLineSetComponentBase):
    r"""
    Instantiation of a basic line set component in 2D using FVector2f for line positions.
    
    **C++ Source:**
    
    - **Plugin**: UVEditor
    - **Module**: UVEditorTools
    - **File**: BasicLineSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class Basic3DLineSetComponent(BasicLineSetComponentBase):
    r"""
    Instantiation of a basic line set component in 3D using FVector3f for line positions.
    
    **C++ Source:**
    
    - **Plugin**: UVEditor
    - **Module**: UVEditorTools
    - **File**: BasicLineSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class BasicPointSetComponentBase(MeshComponent):
    r"""
    Base class for component specific functionality independent of the type of point stored in the component.
    
    **C++ Source:**
    
    - **Plugin**: UVEditor
    - **Module**: UVEditorTools
    - **File**: BasicPointSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class Basic2DPointSetComponent(BasicPointSetComponentBase):
    r"""
    Instantiation of a basic point set component in 2D using FVector2f for point positions.
    
    **C++ Source:**
    
    - **Plugin**: UVEditor
    - **Module**: UVEditorTools
    - **File**: BasicPointSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class Basic3DPointSetComponent(BasicPointSetComponentBase):
    r"""
    Instantiation of a basic point set component in 3D using FVector3f for point positions.
    
    **C++ Source:**
    
    - **Plugin**: UVEditor
    - **Module**: UVEditorTools
    - **File**: BasicPointSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class BasicTriangleSetComponentBase(MeshComponent):
    r"""
    Base class for component specific functionality independent of the type of line stored in the component.
    
    **C++ Source:**
    
    - **Plugin**: UVEditor
    - **Module**: UVEditorTools
    - **File**: BasicTriangleSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class Basic2DTriangleSetComponent(BasicTriangleSetComponentBase):
    r"""
    Instantiation of a basic line set component in 2D using FVector2f for line positions.
    
    **C++ Source:**
    
    - **Plugin**: UVEditor
    - **Module**: UVEditorTools
    - **File**: BasicTriangleSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class Basic3DTriangleSetComponent(BasicTriangleSetComponentBase):
    r"""
    Instantiation of a basic line set component in 3D using FVector3f for line positions.
    
    **C++ Source:**
    
    - **Plugin**: UVEditor
    - **Module**: UVEditorTools
    - **File**: BasicTriangleSetComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class HLODBuilderInstancingSettings(HLODBuilderSettings):
    r"""
    HLODBuilder Instancing Settings
    
    **C++ Source:**
    
    - **Plugin**: WorldPartitionHLODUtilities
    - **Module**: WorldPartitionHLODUtilities
    - **File**: HLODBuilderInstancing.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``disallow_nanite`` (bool):  [Read-Write] If enabled, the components created for the HLODs will not use Nanite.
      Necessary if you want to use the last LOD & the mesh is Nanite enabled, as forced LODs are ignored by Nanite
    """
    @property
    def disallow_nanite(self) -> bool:
        r"""
        (bool):  [Read-Write] If enabled, the components created for the HLODs will not use Nanite.
        Necessary if you want to use the last LOD & the mesh is Nanite enabled, as forced LODs are ignored by Nanite
        """
        ...
    @disallow_nanite.setter
    def disallow_nanite(self, value: bool) -> None:
        ...

class HLODBuilderMeshApproximateSettings(HLODBuilderSettings):
    r"""
    HLODBuilder Mesh Approximate Settings
    
    **C++ Source:**
    
    - **Plugin**: WorldPartitionHLODUtilities
    - **Module**: WorldPartitionHLODUtilities
    - **File**: HLODBuilderMeshApproximate.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``hlod_material`` (MaterialInterface):  [Read-Write] Material that will be used by the generated HLOD static mesh
    - ``mesh_approximation_settings`` (MeshApproximationSettings):  [Read-Write] Mesh approximation settings
    """
    ...

class HLODBuilderMeshMergeSettings(HLODBuilderSettings):
    r"""
    HLODBuilder Mesh Merge Settings
    
    **C++ Source:**
    
    - **Plugin**: WorldPartitionHLODUtilities
    - **Module**: WorldPartitionHLODUtilities
    - **File**: HLODBuilderMeshMerge.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``hlod_material`` (MaterialInterface):  [Read-Write] Material that will be used by the generated HLOD static mesh
    - ``mesh_merge_settings`` (MeshMergingSettings):  [Read-Write] Merged mesh generation settings
    """
    ...

class HLODBuilderMeshSimplifySettings(HLODBuilderSettings):
    r"""
    HLODBuilder Mesh Simplify Settings
    
    **C++ Source:**
    
    - **Plugin**: WorldPartitionHLODUtilities
    - **Module**: WorldPartitionHLODUtilities
    - **File**: HLODBuilderMeshSimplify.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``hlod_material`` (MaterialInterface):  [Read-Write] Material that will be used by the generated HLOD static mesh
    - ``mesh_simplify_settings`` (MeshProxySettings):  [Read-Write] Simplified mesh generation settings
    """
    ...

class ObjectMixerObjectFilter(Object):
    r"""
    Native class for filtering object types to Object Mixer.
    Native C++ classes should inherit directly from this class.
    
    **C++ Source:**
    
    - **Plugin**: ObjectMixer
    - **Module**: ObjectMixerEditor
    - **File**: ObjectMixerEditorObjectFilter.h
    
    """
    ...

class LightMixerObjectFilter(ObjectMixerObjectFilter):
    r"""
    Light Mixer Object Filter
    
    **C++ Source:**
    
    - **Plugin**: LightMixer
    - **Module**: LightMixer
    - **File**: LightMixerObjectFilter.h
    
    """
    ...

class ObjectMixerBlueprintObjectFilter(ObjectMixerObjectFilter):
    r"""
    Script class for filtering object types to Object Mixer.
    Blueprint classes should inherit directly from this class.
    
    **C++ Source:**
    
    - **Plugin**: ObjectMixer
    - **Module**: ObjectMixerEditor
    - **File**: ObjectMixerEditorObjectFilter.h
    
    """
    def should_include_unsupported_properties(self) -> bool:
        r"""
        x.should_include_unsupported_properties() -> bool
        If true, properties that are not visible in the details panel and properties not supported by SSingleProperty will be selectable.
        Defaults to false.
        
        Returns:
            bool:
        """
        ...
    def get_show_transient_objects(self) -> bool:
        r"""
        x.get_show_transient_objects() -> bool
        Determines if transient objects (such as Sequencer Spawnables) should be shown in the list. False by default.
        
        Returns:
            bool:
        """
        ...
    def get_properties_that_require_list_refresh(self) -> Set[Name]:
        r"""
        x.get_properties_that_require_list_refresh() -> Set[Name]
        If a property is changed that has a name found in this set, the panel will be refreshed.
        Add a property name to this list if you expect the list to change in some way after changing that property.
        
        Returns:
            Set[Name]:
        """
        ...
    def get_object_mixer_property_inheritance_inclusion_options(self) -> ObjectMixerInheritanceInclusionOptions:
        r"""
        x.get_object_mixer_property_inheritance_inclusion_options() -> ObjectMixerInheritanceInclusionOptions
        Specify whether we should return only the properties of the specified classes or the properties of parent and child classes.
        Defaults to 'None' which only considers the properties of the specified classes.
        If you're not seeing all the properties you expected, try overloading this function.
        
        Returns:
            ObjectMixerInheritanceInclusionOptions:
        """
        ...
    def get_object_mixer_placement_class_inclusion_options(self) -> ObjectMixerInheritanceInclusionOptions:
        r"""
        x.get_object_mixer_placement_class_inclusion_options() -> ObjectMixerInheritanceInclusionOptions
        Specify whether we should return only the specified classes or the parent and child classes in placement mode.
        Defaults to 'None' which only considers the specified classes.
        
        Returns:
            ObjectMixerInheritanceInclusionOptions:
        """
        ...
    def get_object_classes_to_place(self) -> Set[Class]:
        r"""
        x.get_object_classes_to_place() -> Set[type(Class)]
        Return the basic actor types you want to be able to place using the Add button.
        Note that only subclasses of AActor are supported and only those which have a registered factory.
        This includes most engine actor types.
        
        Returns:
            Set[type(Class)]:
        """
        ...
    def get_object_classes_to_filter(self) -> Set[Class]:
        r"""
        x.get_object_classes_to_filter() -> Set[type(Class)]
        Return the basic object types you want to filter for in your level.
        For example, if you want to work with Lights, return ULightComponentBase.
        If you also want to see the properties for parent or child classes,
        override the GetObjectMixerPropertyInheritanceInclusionOptions and GetForceAddedColumns functions.
        
        Returns:
            Set[type(Class)]:
        """
        ...
    def get_force_added_columns(self) -> Set[Name]:
        r"""
        x.get_force_added_columns() -> Set[Name]
        Specify a list of property names found in parent classes you want to show that aren't in the specified classes.
        Note that properties specified here do not override the properties specified in GetColumnsToExclude().
        For example, a ULightComponent displays "LightColor" in the editor's details panel,
        but ULightComponent itself doesn't have a property named "LightColor". Instead it's in its parent class, ULightComponentBase.
        In this scenario, ULightComponent is specified and PropertyInheritanceInclusionOptions is None, so "LightColor" won't appear by default.
        Specify "LightColor" in this function to ensure that "LightColor" will appear as a column as long as
        the property is accessible to one of the specified classes regardless of which parent class it comes from.
        
        Returns:
            Set[Name]:
        """
        ...
    def get_columns_to_show_by_default(self) -> Set[Name]:
        r"""
        x.get_columns_to_show_by_default() -> Set[Name]
        Specify a list of property names corresponding to columns you want to show by default.
        For example, you can specify "Intensity" and "LightColor" to show only those property columns by default in the UI.
        Columns not specified will not be shown by default but can be enabled by the user in the UI.
        
        Returns:
            Set[Name]:
        """
        ...
    def get_columns_to_exclude(self) -> Set[Name]:
        r"""
        x.get_columns_to_exclude() -> Set[Name]
        Specify a list of property names corresponding to columns you don't want to ever show.
        For example, you can specify "Intensity" and "LightColor" to ensure that they can't be enabled or shown in the UI.
        Columns not specified can be enabled by the user in the UI.
        
        Returns:
            Set[Name]:
        """
        ...

class ObjectMixerEditorUWidget(Widget):
    r"""
    A UMG widget wrapper for the Object Mixer widget. Uses the same data as the Generic Object Mixer Instance.
    Only useful in the editor. It is not compatible at runtime.
    
    **C++ Source:**
    
    - **Plugin**: ObjectMixer
    - **Module**: ObjectMixerEditor
    - **File**: ObjectMixerEditorUWidget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``object_mixer_widget_user_config`` (ObjectMixerWidgetUserConfig):  [Read-Write] End of UWidget
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def object_mixer_widget_user_config(self) -> ObjectMixerWidgetUserConfig:
        r"""
        (ObjectMixerWidgetUserConfig):  [Read-Write] End of UWidget
        """
        ...
    @object_mixer_widget_user_config.setter
    def object_mixer_widget_user_config(self, value: ObjectMixerWidgetUserConfig) -> None:
        ...

class ObjectMixerBlueprintFilterFactory(Factory):
    r"""
    Object Mixer Blueprint Filter Factory
    
    **C++ Source:**
    
    - **Plugin**: ObjectMixer
    - **Module**: ObjectMixerEditor
    - **File**: ObjectMixerFilterFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Only] The parent class of the created blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class VersionInfoHandler(Object):
    r"""
    Version Info Handler
    
    **C++ Source:**
    
    - **Plugin**: Bridge
    - **Module**: MegascansPlugin
    - **File**: VersionInfoHandler.h
    
    """
    @classmethod
    def get(cls) -> VersionInfoHandler:
        r"""
        X.get() -> VersionInfoHandler
        Get
        
        Returns:
            VersionInfoHandler:
        """
        ...

class AudioSynesthesiaNRTFactory(Factory):
    r"""
    UAudioSynesthesiaNRTFactory
    
    UAudioSynesthesiaNRTFactory implements the factory for UAudioSynesthesiaNRT assets.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesiaEditor
    - **File**: AudioSynesthesiaNRTFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``audio_synesthesia_nrt_class`` (type(Class)):  [Read-Write] The type of audio analyzer settings that will be created
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AudioSynesthesiaNRTSettingsFactory(Factory):
    r"""
    UAudioSynesthesiaNRTSettingsFactory
    
    UAudioSynesthesiaNRTSettingsFactory implements the factory for UAudioSynesthesiaNRTSettings assets.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesiaEditor
    - **File**: AudioSynesthesiaNRTSettingsFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``audio_synesthesia_nrt_settings_class`` (type(Class)):  [Read-Write] The type of audio analyzer settings that will be created
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AudioSynesthesiaSettingsFactory(Factory):
    r"""
    UAudioSynesthesiaSettingsFactory
    
    UAudioSynesthesiaSettingsFactory implements the factory for UAudioSynesthesiaSettings assets.
    
    **C++ Source:**
    
    - **Plugin**: AudioSynesthesia
    - **Module**: AudioSynesthesiaEditor
    - **File**: AudioSynesthesiaSettingsFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``audio_synesthesia_settings_class`` (type(Class)):  [Read-Write] The type of audio analyzer settings that will be created
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TakeRecorderActorSource(TakeRecorderSource):
    r"""
    This Take Recorder Source can record an actor from the World's properties.
    Records the properties of the actor and the components on the actor and safely
    handles new components being spawned at runtime and the actor being destroyed.
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderActorSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``exclude_animation_names`` (Array[str]):  [Read-Write] Exclude all animation bones/curves that match this list
    - ``include_animation_names`` (Array[str]):  [Read-Write] Include only the animation bones/curves that match this list
    - ``record_parent_hierarchy`` (bool):  [Read-Write] Whether to ensure that the parent hierarchy is also recorded. If recording to possessable and the parent is not recorded,
      the recorded transforms will be in local space since the child will still be attached to the parent in the level after
      recording.  If recording to spawnable and the parent is not recorded, the recorded transforms will be in global space
      since the child will not be attached to the parent in the level.
    - ``record_type`` (TakeRecorderActorRecordType):  [Read-Write] Should this actor be recorded as a Possessable in Sequencer? If so the resulting Object Binding
      will not create a Spawnable copy of this object and instead will possess this object in the level.
    - ``recorded_properties`` (ActorRecorderPropertyMap):  [Read-Write] Lists the properties and components on the current actor and whether or not each property will be
      recorded into a track in the resulting Level Sequence.
    - ``reduce_keys`` (bool):  [Read-Write] Whether to perform key-reduction algorithms as part of the recording
    - ``take_number`` (int32):  [Read-Write]
    - ``target`` (Actor):  [Read-Write] Reference to the actor in the world that should have it's properties recorded.
    - ``track_tint`` (Color):  [Read-Write]
    """
    @property
    def target(self) -> Actor:
        r"""
        (Actor):  [Read-Write] Reference to the actor in the world that should have it's properties recorded.
        """
        ...
    @target.setter
    def target(self, value: Actor) -> None:
        ...
    @property
    def record_type(self) -> TakeRecorderActorRecordType:
        r"""
        (TakeRecorderActorRecordType):  [Read-Write] Should this actor be recorded as a Possessable in Sequencer? If so the resulting Object Binding
        will not create a Spawnable copy of this object and instead will possess this object in the level.
        """
        ...
    @record_type.setter
    def record_type(self, value: TakeRecorderActorRecordType) -> None:
        ...
    @property
    def record_parent_hierarchy(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to ensure that the parent hierarchy is also recorded. If recording to possessable and the parent is not recorded,
        the recorded transforms will be in local space since the child will still be attached to the parent in the level after
        recording.  If recording to spawnable and the parent is not recorded, the recorded transforms will be in global space
        since the child will not be attached to the parent in the level.
        """
        ...
    @record_parent_hierarchy.setter
    def record_parent_hierarchy(self, value: bool) -> None:
        ...
    @property
    def reduce_keys(self) -> bool:
        r"""
        (bool):  [Read-Write] Whether to perform key-reduction algorithms as part of the recording
        """
        ...
    @reduce_keys.setter
    def reduce_keys(self, value: bool) -> None:
        ...
    @property
    def recorded_properties(self) -> ActorRecorderPropertyMap:
        r"""
        (ActorRecorderPropertyMap):  [Read-Write] Lists the properties and components on the current actor and whether or not each property will be
        recorded into a track in the resulting Level Sequence.
        """
        ...
    @recorded_properties.setter
    def recorded_properties(self, value: ActorRecorderPropertyMap) -> None:
        ...
    @property
    def include_animation_names(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Include only the animation bones/curves that match this list
        """
        ...
    @include_animation_names.setter
    def include_animation_names(self, value: Array[str]) -> None:
        ...
    @property
    def exclude_animation_names(self) -> Array[str]:
        r"""
        (Array[str]):  [Read-Write] Exclude all animation bones/curves that match this list
        """
        ...
    @exclude_animation_names.setter
    def exclude_animation_names(self, value: Array[str]) -> None:
        ...
    def set_source_actor(self, target: Actor) -> None:
        r"""
        x.set_source_actor(target) -> None
        Set the Target actor that we are going to record. Will reset the Recorded Property Map to defaults.
        
        Args:
            target (Actor):
        """
        ...
    @classmethod
    def remove_actor_from_sources(cls, actor: Actor, sources: TakeRecorderSources) -> None:
        r"""
        X.remove_actor_from_sources(actor, sources) -> None
        * Remove the given actor from TakeRecorderSources.
        *
        *
        
        Args:
            actor (Actor): The actor to remove from the sources *
            sources (TakeRecorderSources): The sources from where to remove the actor
        """
        ...
    def get_source_actor(self) -> Actor:
        r"""
        x.get_source_actor() -> Actor
        Get Source Actor
        
        Returns:
            Actor:
        """
        ...
    @classmethod
    def add_source_for_actor(cls, actor: Actor, sources: TakeRecorderSources) -> TakeRecorderSource:
        r"""
        X.add_source_for_actor(actor, sources) -> TakeRecorderSource
        * Add a take recorder source for the given actor.
        *
        *
        
        Args:
            actor (Actor): The actor to add a source for *
            sources (TakeRecorderSources): The sources to add the actor to *
        
        Returns:
            TakeRecorderSource: The added source or the source already present with the same actor
        """
        ...

class TakeRecorderCameraCutSource(TakeRecorderSource):
    r"""
    A recording source that detects camera switching and creates a camera cut track
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderCameraCutSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    ...

class TakeRecorderLevelSequenceSource(TakeRecorderSource):
    r"""
    Plays level sequence actors when recording starts
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderLevelSequenceSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``level_sequences_to_trigger`` (Array[LevelSequence]):  [Read-Write]
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    @property
    def level_sequences_to_trigger(self) -> Array[LevelSequence]:
        r"""
        (Array[LevelSequence]):  [Read-Write]
        """
        ...
    @level_sequences_to_trigger.setter
    def level_sequences_to_trigger(self, value: Array[LevelSequence]) -> None:
        ...

class TakeRecorderLevelVisibilitySourceSettings(TakeRecorderSource):
    r"""
    A recording source that records level visibilitiy
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderLevelVisibilitySource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``level_visibility_track_name`` (Text):  [Read-Write] Name of the recorded level visibility track name
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    @property
    def level_visibility_track_name(self) -> Text:
        r"""
        (Text):  [Read-Write] Name of the recorded level visibility track name
        """
        ...
    @level_visibility_track_name.setter
    def level_visibility_track_name(self, value: Text) -> None:
        ...

class TakeRecorderLevelVisibilitySource(TakeRecorderLevelVisibilitySourceSettings):
    r"""
    A recording source that records level visibility state
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderLevelVisibilitySource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``level_visibility_track_name`` (Text):  [Read-Write] Name of the recorded level visibility track name
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    ...

class TakeRecorderMicrophoneAudioManager(TakeRecorderAudioInputSettings):
    r"""
    This class exposes the audio input device list via the project settings details. It does this in
     conjunction with FAudioInputDevicePropertyCustomization. It also manages the IAudioCaptureEditor
     object which handles the low level audio device recording.
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderMicrophoneAudioManager.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio_input_device`` (AudioInputDeviceProperty):  [Read-Write] The audio device to use for this microphone source
    """
    @property
    def audio_input_device(self) -> AudioInputDeviceProperty:
        r"""
        (AudioInputDeviceProperty):  [Read-Write] The audio device to use for this microphone source
        """
        ...
    @audio_input_device.setter
    def audio_input_device(self, value: AudioInputDeviceProperty) -> None:
        ...

class TakeRecorderMicrophoneAudioSourceSettings(TakeRecorderSource):
    r"""
    A recording source that records microphone audio
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderMicrophoneAudioSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio_asset_name`` (str):  [Read-Write] The name of the audio asset.
      Supports any of the following format specifiers that will be substituted when a take is recorded :
      {day} - The day of the timestamp for the start of the recording.
      {month} - The month of the timestamp for the start of the recording.
      {year} - The year of the timestamp for the start of the recording.
      {hour} - The hour of the timestamp for the start of the recording.
      {minute} - The minute of the timestamp for the start of the recording.
      {second} - The second of the timestamp for the start of the recording.
      {take} - The take number.
      {slate} - The slate string.
    - ``audio_source_name`` (Text):  [Read-Write] Name of the audio source
    - ``audio_sub_directory`` (str):  [Read-Write] The name of the subdirectory audio will be placed in. Leave this empty to place into the same directory as the sequence base path
      Supports any of the following format specifiers that will be substituted when a take is recorded :
      {day} - The day of the timestamp for the start of the recording.
      {month} - The month of the timestamp for the start of the recording.
      {year} - The year of the timestamp for the start of the recording.
      {hour} - The hour of the timestamp for the start of the recording.
      {minute} - The minute of the timestamp for the start of the recording.
      {second} - The second of the timestamp for the start of the recording.
      {take} - The take number.
      {slate} - The slate string.
    - ``audio_track_name`` (Text):  [Read-Write] Name of the recorded audio track
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    @property
    def audio_source_name(self) -> Text:
        r"""
        (Text):  [Read-Write] Name of the audio source
        """
        ...
    @audio_source_name.setter
    def audio_source_name(self, value: Text) -> None:
        ...
    @property
    def audio_track_name(self) -> Text:
        r"""
        (Text):  [Read-Write] Name of the recorded audio track
        """
        ...
    @audio_track_name.setter
    def audio_track_name(self, value: Text) -> None:
        ...
    @property
    def audio_asset_name(self) -> str:
        r"""
        (str):  [Read-Write] The name of the audio asset.
        Supports any of the following format specifiers that will be substituted when a take is recorded :
        {day} - The day of the timestamp for the start of the recording.
        {month} - The month of the timestamp for the start of the recording.
        {year} - The year of the timestamp for the start of the recording.
        {hour} - The hour of the timestamp for the start of the recording.
        {minute} - The minute of the timestamp for the start of the recording.
        {second} - The second of the timestamp for the start of the recording.
        {take} - The take number.
        {slate} - The slate string.
        """
        ...
    @audio_asset_name.setter
    def audio_asset_name(self, value: str) -> None:
        ...
    @property
    def audio_sub_directory(self) -> str:
        r"""
        (str):  [Read-Write] The name of the subdirectory audio will be placed in. Leave this empty to place into the same directory as the sequence base path
        Supports any of the following format specifiers that will be substituted when a take is recorded :
        {day} - The day of the timestamp for the start of the recording.
        {month} - The month of the timestamp for the start of the recording.
        {year} - The year of the timestamp for the start of the recording.
        {hour} - The hour of the timestamp for the start of the recording.
        {minute} - The minute of the timestamp for the start of the recording.
        {second} - The second of the timestamp for the start of the recording.
        {take} - The take number.
        {slate} - The slate string.
        """
        ...
    @audio_sub_directory.setter
    def audio_sub_directory(self, value: str) -> None:
        ...

class TakeRecorderMicrophoneAudioSource(TakeRecorderMicrophoneAudioSourceSettings):
    r"""
    A recording source that records microphone audio
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderMicrophoneAudioSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``audio_asset_name`` (str):  [Read-Write] The name of the audio asset.
      Supports any of the following format specifiers that will be substituted when a take is recorded :
      {day} - The day of the timestamp for the start of the recording.
      {month} - The month of the timestamp for the start of the recording.
      {year} - The year of the timestamp for the start of the recording.
      {hour} - The hour of the timestamp for the start of the recording.
      {minute} - The minute of the timestamp for the start of the recording.
      {second} - The second of the timestamp for the start of the recording.
      {take} - The take number.
      {slate} - The slate string.
    - ``audio_channel`` (AudioInputDeviceChannelProperty):  [Read-Write] The audio device to use for this microphone source
    - ``audio_gain`` (float):  [Read-Write] Gain in decibels to apply to recorded audio
    - ``audio_source_name`` (Text):  [Read-Write] Name of the audio source
    - ``audio_sub_directory`` (str):  [Read-Write] The name of the subdirectory audio will be placed in. Leave this empty to place into the same directory as the sequence base path
      Supports any of the following format specifiers that will be substituted when a take is recorded :
      {day} - The day of the timestamp for the start of the recording.
      {month} - The month of the timestamp for the start of the recording.
      {year} - The year of the timestamp for the start of the recording.
      {hour} - The hour of the timestamp for the start of the recording.
      {minute} - The minute of the timestamp for the start of the recording.
      {second} - The second of the timestamp for the start of the recording.
      {take} - The take number.
      {slate} - The slate string.
    - ``audio_track_name`` (Text):  [Read-Write] Name of the recorded audio track
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``replace_recorded_audio`` (bool):  [Read-Write] Replace existing recorded audio with any newly recorded audio
    - ``split_audio_channels_into_separate_tracks`` (bool):  [Read-Write]
      deprecated: SplitAudioChannelsIntoSeparateTracks is deprecated.
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    @property
    def audio_gain(self) -> float:
        r"""
        (float):  [Read-Write] Gain in decibels to apply to recorded audio
        """
        ...
    @audio_gain.setter
    def audio_gain(self, value: float) -> None:
        ...
    @property
    def split_audio_channels_into_separate_tracks(self) -> bool:
        r"""
        (bool):  [Read-Write]
        deprecated: SplitAudioChannelsIntoSeparateTracks is deprecated.
        """
        ...
    @split_audio_channels_into_separate_tracks.setter
    def split_audio_channels_into_separate_tracks(self, value: bool) -> None:
        ...
    @property
    def replace_recorded_audio(self) -> bool:
        r"""
        (bool):  [Read-Write] Replace existing recorded audio with any newly recorded audio
        """
        ...
    @replace_recorded_audio.setter
    def replace_recorded_audio(self, value: bool) -> None:
        ...
    @property
    def audio_channel(self) -> AudioInputDeviceChannelProperty:
        r"""
        (AudioInputDeviceChannelProperty):  [Read-Write] The audio device to use for this microphone source
        """
        ...
    @audio_channel.setter
    def audio_channel(self, value: AudioInputDeviceChannelProperty) -> None:
        ...

class TakeRecorderNearbySpawnedActorSource(TakeRecorderSource):
    r"""
    A recording source that detects actors spawned close to the current camera, and captures them as spawnables
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderNearbySpawnedActorSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``filter_spawned_actors`` (bool):  [Read-Write] Should we only record actors that pass the filter list?
    - ``filter_types`` (Array[type(Class)]):  [Read-Write] A type filter to apply to spawned objects
    - ``proximity`` (float):  [Read-Write] The proximity to the current camera that an actor must be spawned in order to be recorded as a spawnable. If 0, proximity is disregarded.
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    @property
    def proximity(self) -> float:
        r"""
        (float):  [Read-Write] The proximity to the current camera that an actor must be spawned in order to be recorded as a spawnable. If 0, proximity is disregarded.
        """
        ...
    @proximity.setter
    def proximity(self, value: float) -> None:
        ...
    @property
    def filter_spawned_actors(self) -> bool:
        r"""
        (bool):  [Read-Write] Should we only record actors that pass the filter list?
        """
        ...
    @filter_spawned_actors.setter
    def filter_spawned_actors(self, value: bool) -> None:
        ...
    @property
    def filter_types(self) -> Array[Class]:
        r"""
        (Array[type(Class)]):  [Read-Write] A type filter to apply to spawned objects
        """
        ...
    @filter_types.setter
    def filter_types(self, value: Array[Class]) -> None:
        ...

class TakeRecorderPlayerSource(TakeRecorderSource):
    r"""
    A recording source that records the current player
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderPlayerSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    ...

class TakeRecorderWorldSourceSettings(TakeRecorderSource):
    r"""
    A recording source that records world state
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderWorldSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``autotrack_actors`` (bool):  [Read-Write] Add a binding and track for all actors that aren't explicitly being recorded
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``record_world_settings`` (bool):  [Read-Write] Record world settings
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    @property
    def record_world_settings(self) -> bool:
        r"""
        (bool):  [Read-Write] Record world settings
        """
        ...
    @record_world_settings.setter
    def record_world_settings(self, value: bool) -> None:
        ...
    @property
    def autotrack_actors(self) -> bool:
        r"""
        (bool):  [Read-Write] Add a binding and track for all actors that aren't explicitly being recorded
        """
        ...
    @autotrack_actors.setter
    def autotrack_actors(self, value: bool) -> None:
        ...

class TakeRecorderWorldSource(TakeRecorderWorldSourceSettings):
    r"""
    A recording source that records world state
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: TakeRecorderSources
    - **File**: TakeRecorderWorldSource.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``autotrack_actors`` (bool):  [Read-Write] Add a binding and track for all actors that aren't explicitly being recorded
    - ``enabled`` (bool):  [Read-Write] True if this source is cued for recording or not
    - ``record_world_settings`` (bool):  [Read-Write] Record world settings
    - ``take_number`` (int32):  [Read-Write]
    - ``track_tint`` (Color):  [Read-Write]
    """
    ...

class CacheTrackRecorder(Object):
    r"""
    Cache Track Recorder
    
    **C++ Source:**
    
    - **Plugin**: Takes
    - **Module**: CacheTrackRecorder
    - **File**: CacheTrackRecorder.h
    
    """
    def get_state(self) -> CacheTrackRecorderState:
        r"""
        x.get_state() -> CacheTrackRecorderState
        Get the current state of this recorder
        
        Returns:
            CacheTrackRecorderState:
        """
        ...
    def get_sequence(self) -> LevelSequence:
        r"""
        x.get_sequence() -> LevelSequence
        Access the sequence asset that this recorder is recording into
        
        Returns:
            LevelSequence:
        """
        ...

class TestBTDecorator_Blueprint(BTDecorator_BlueprintBase):
    r"""
    Test BTDecorator Blueprint
    
    **C++ Source:**
    
    - **Module**: AITestSuite
    - **File**: TestBTDecorator_Blueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``check_condition_only_black_board_changes`` (bool):  [Read-Write] Applies only if Decorator has any FBlackboardKeySelector property and if decorator is
          set to abort BT flow. Is set to true ReceiveConditionCheck will be called only on changes
         to observed BB keys. If false or no BB keys observed ReceiveConditionCheck will be called every tick
    - ``custom_description`` (str):  [Read-Write]
    - ``flow_abort_mode`` (BTFlowAbortMode):  [Read-Write] flow controller settings
    - ``inverse_condition`` (bool):  [Read-Write] if set, condition check result will be inversed
    - ``node_name`` (str):  [Read-Write] node name
    - ``show_property_details`` (bool):  [Read-Write] show detailed information about properties
    """
    ...

class MockTask_Log(GameplayTask):
    r"""
    Mock Task Log
    
    **C++ Source:**
    
    - **Module**: AITestSuite
    - **File**: MockGameplayTasks.h
    
    """
    ...

class MockGameplayTasksComponent(GameplayTasksComponent):
    r"""
    a Testing-time component that is a way to access UGameplayTasksComponent's protected properties
    
    **C++ Source:**
    
    - **Module**: AITestSuite
    - **File**: MockGameplayTasks.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_claimed_resources_change`` (OnClaimedResourcesChangeSignature):  [Read-Write]
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class SparseVolumeTextureFactory(Factory):
    r"""
    Responsible for creating and importing Sparse Volume Texture objects
    
    **C++ Source:**
    
    - **Module**: SparseVolumeTexture
    - **File**: SparseVolumeTextureFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class EditorUtilityObject(Object):
    r"""
    Editor Utility Object
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityObject.h
    
    """
    def run(self) -> None:
        r"""
        x.run() -> None
        Standard function to execute
        """
        ...

class EditorAutomationObject(EditorUtilityObject):
    r"""
    deprecated: 'EditorAutomationObject' was renamed to 'EditorUtilityObject'.
    """
    ...

class ActorActionUtility(EditorUtilityObject):
    r"""
    Base class for all actor action-related utilities
    Any functions/events that are exposed on derived classes that have the correct signature will be
    included as menu options when right-clicking on a group of actors in the level editor.
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: ActorActionUtility.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``supported_classes`` (Array[Class]):  [Read-Write] For simple Asset Action's you should fill out the supported class here.
    """
    def get_supported_classes(self) -> Array[Class]:
        r"""
        x.get_supported_classes() -> Array[Class]
        Gets the statically determined supported classes, these classes are used as a first pass filter when determining
        if we can utilize this asset utility action on the asset.
        
        Returns:
            Array[Class]:
        """
        ...
    def get_supported_class(self) -> Class:
        r"""
        x.get_supported_class() -> type(Class)
        Get Supported Class
        deprecated: If you were just returning a single class add it to the SupportedClasses array (you can find it listed in the Class Defaults).  If you were doing complex logic to simulate having multiple classes act as filters, add them to the SupportedClasses array.  If you were doing 'other' logic, you'll need to do that upon action execution.
        
        Returns:
            type(Class):
        """
        ...

class AssetActionUtility(EditorUtilityObject):
    r"""
    Base class for all asset action-related utilities
    Any functions/events that are exposed on derived classes that have the correct signature will be
    included as menu options when right-clicking on a group of assets in the content browser.
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: AssetActionUtility.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``is_action_for_blueprints`` (bool):  [Read-Write] Is this action designed to work specifically on Blueprints (true) or on all assets (false).
      If true, SupportedClasses is treated as a filter against the Parent Class of selected Blueprint assets.
    - ``supported_classes`` (Array[Class]):  [Read-Write] The supported classes controls the list of classes that may be operated on by all of the asset functions in this
      utility class.
      note: When bIsActionForBlueprints is true, this will compare against the generated class of any Blueprint assets.
    - ``supported_conditions`` (Array[AssetActionSupportCondition]):  [Read-Write] The supported conditions for any asset to use these utility functions.  Note: all of these conditions must pass
      in sequence.  So if you have earlier failure conditions you want to be run first, put them first in the list,
      if those fail, their failure reason will be handled first.
    """
    def is_action_for_blueprints(self) -> bool:
        r"""
        x.is_action_for_blueprints() -> bool
        Returns whether or not this action is designed to work specifically on Blueprints (true) or on all assets (false).
        If true, GetSupportedClass() is treated as a filter against the Parent Class of selected Blueprint assets.
        note: Returns the value of bIsActionForBlueprints by default.
        
        Returns:
            bool:
        """
        ...
    def get_supported_classes(self) -> Array[Class]:
        r"""
        x.get_supported_classes() -> Array[Class]
        Gets the statically determined supported classes, these classes are used as a first pass filter when determining
        if we can utilize this asset utility action on the asset.
        
        Returns:
            Array[Class]:
        """
        ...
    def get_supported_class(self) -> Class:
        r"""
        x.get_supported_class() -> type(Class)
        Get Supported Class
        deprecated: If you were just returning a single class add it to the SupportedClasses array (you can find it listed in the Class Defaults).  If you were doing complex logic to simulate having multiple classes act as filters, add them to the SupportedClasses array.  If you were doing 'other' logic, you'll need to do that upon action execution.
        
        Returns:
            type(Class):
        """
        ...

class AsyncCaptureScene(BlueprintAsyncActionBase):
    r"""
    Async Capture Scene
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: AsyncCaptureScene.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``complete`` (OnAsyncCaptureSceneComplete):  [Read-Write]
    """
    @property
    def complete(self) -> OnAsyncCaptureSceneComplete:
        r"""
        (OnAsyncCaptureSceneComplete):  [Read-Write]
        """
        ...
    @complete.setter
    def complete(self, value: OnAsyncCaptureSceneComplete) -> None:
        ...

class AsyncImageExport(BlueprintAsyncActionBase):
    r"""
    Async Image Export
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: AsyncImageExport.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``complete`` (OnExportImageAsyncComplete):  [Read-Write]
    """
    @property
    def complete(self) -> OnExportImageAsyncComplete:
        r"""
        (OnExportImageAsyncComplete):  [Read-Write]
        """
        ...
    @complete.setter
    def complete(self, value: OnExportImageAsyncComplete) -> None:
        ...

class AsyncRegisterAndExecuteTask(BlueprintAsyncActionBase):
    r"""
    Async Register and Execute Task
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: AsyncRegisterAndExecuteTask.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_finished`` (OnEditorUtilityTaskDynamicDelegate):  [Read-Write]
    """
    @property
    def on_finished(self) -> OnEditorUtilityTaskDynamicDelegate:
        r"""
        (OnEditorUtilityTaskDynamicDelegate):  [Read-Write]
        """
        ...
    @on_finished.setter
    def on_finished(self, value: OnEditorUtilityTaskDynamicDelegate) -> None:
        ...

class EditorUtilityActor(Actor):
    r"""
    Editor Utility Actor
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``receives_editor_input`` (bool):  [Read-Write] If set to true, then this actor will be able to recieve input delegate callbacks when in the editor.
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def receives_editor_input(self) -> bool:
        r"""
        (bool):  [Read-Write] If set to true, then this actor will be able to recieve input delegate callbacks when in the editor.
        """
        ...
    @receives_editor_input.setter
    def receives_editor_input(self, value: bool) -> None:
        ...
    def run(self) -> None:
        r"""
        x.run() -> None
        Standard function to execute
        """
        ...
    def get_input_component(self) -> InputComponent:
        r"""
        x.get_input_component() -> InputComponent
        Returns the current InputComponent on this utility actor. This will be NULL unless bReceivesEditorInput is set to true.
        
        Returns:
            InputComponent:
        """
        ...

class EditorAutomationActor(EditorUtilityActor):
    r"""
    deprecated: 'EditorAutomationActor' was renamed to 'EditorUtilityActor'.
    """
    ...

class EditorUtilityActorComponent(ActorComponent):
    r"""
    Editor Utility Actor Component
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityActorComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    """
    ...

class EditorAutomationActorComponent(EditorUtilityActorComponent):
    r"""
    deprecated: 'EditorAutomationActorComponent' was renamed to 'EditorUtilityActorComponent'.
    """
    ...

class EditorUtilityBlueprintFactory(Factory):
    r"""
    Editor Utility Blueprint Factory
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityBlueprintFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Write] The parent class of the created blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class EditorUtilityCamera(CameraActor):
    r"""
    Editor Utility Camera
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityCamera.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_activate_for_player`` (AutoReceiveInput):  [Read-Write] Specifies which player controller, if any, should automatically use this Camera when the controller is active.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``camera_component`` (CameraComponent):  [Read-Only] The camera component for this camera
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``scene_component`` (SceneComponent):  [Read-Only]
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class EditorUtilityBlueprintAsyncActionBase(BlueprintAsyncActionBase):
    r"""
    Editor Utility Blueprint Async Action Base
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityLibrary.h
    
    """
    ...

class AsyncEditorDelay(EditorUtilityBlueprintAsyncActionBase):
    r"""
    Async Editor Delay
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``complete`` (AsyncDelayComplete):  [Read-Write]
    """
    @property
    def complete(self) -> AsyncDelayComplete:
        r"""
        (AsyncDelayComplete):  [Read-Write]
        """
        ...
    @complete.setter
    def complete(self, value: AsyncDelayComplete) -> None:
        ...

class AsyncEditorWaitForGameWorld(EditorUtilityBlueprintAsyncActionBase):
    r"""
    Async Editor Wait for Game World
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``complete`` (AsyncEditorWaitForGameWorldEvent):  [Read-Write]
    """
    @property
    def complete(self) -> AsyncEditorWaitForGameWorldEvent:
        r"""
        (AsyncEditorWaitForGameWorldEvent):  [Read-Write]
        """
        ...
    @complete.setter
    def complete(self, value: AsyncEditorWaitForGameWorldEvent) -> None:
        ...

class AsyncEditorOpenMapAndFocusActor(EditorUtilityBlueprintAsyncActionBase):
    r"""
    Async Editor Open Map and Focus Actor
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityLibrary.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``complete`` (AsyncDelayComplete):  [Read-Write]
    """
    @property
    def complete(self) -> AsyncDelayComplete:
        r"""
        (AsyncDelayComplete):  [Read-Write]
        """
        ...
    @complete.setter
    def complete(self, value: AsyncDelayComplete) -> None:
        ...

class EditorUtilityLibrary(BlueprintFunctionLibrary):
    r"""
    Expose editor utility functions to Blutilities
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityLibrary.h
    
    """
    @classmethod
    def sync_browser_to_folders(cls, folder_list: Array[str]) -> None:
        r"""
        X.sync_browser_to_folders(folder_list) -> None
        Sync the Content Browser to the given folder(s)
        
        Args:
            folder_list (Array[str]): The list of folders to sync to in the Content Browser
        """
        ...
    @classmethod
    def rename_asset(cls, asset: Object, new_name: str) -> None:
        r"""
        X.rename_asset(asset, new_name) -> None
        Renames an asset (cannot move folders)
        
        Args:
            asset (Object): 
            new_name (str):
        """
        ...
    @classmethod
    def get_selection_set(cls) -> Array[Actor]:
        r"""
        X.get_selection_set() -> Array[Actor]
        Get Selection Set
        
        Returns:
            Array[Actor]:
        """
        ...
    @classmethod
    def get_selection_bounds(cls) -> Tuple[Vector, Vector, float]:
        r"""
        X.get_selection_bounds() -> (origin=Vector, box_extent=Vector, sphere_radius=float)
        Get Selection Bounds
        
        Returns:
            tuple: 
        
            origin (Vector): 
        
            box_extent (Vector): 
        
            sphere_radius (float):
        """
        ...
    @classmethod
    def get_selected_path_view_folder_paths(cls) -> Array[str]:
        r"""
        X.get_selected_path_view_folder_paths() -> Array[str]
        Returns the folders that are selected in the path view for the content browser
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def get_selected_folder_paths(cls) -> Array[str]:
        r"""
        X.get_selected_folder_paths() -> Array[str]
        Gets the path to the currently selected folder in the content browser
        
        Returns:
            Array[str]:
        """
        ...
    @classmethod
    def get_selected_blueprint_classes(cls) -> Array[Class]:
        r"""
        X.get_selected_blueprint_classes() -> Array[type(Class)]
        Gets the set of currently selected classes
        
        Returns:
            Array[type(Class)]:
        """
        ...
    @classmethod
    def get_selected_assets_of_class(cls, asset_class: Class) -> Array[Object]:
        r"""
        X.get_selected_assets_of_class(asset_class) -> Array[Object]
        Get Selected Assets Of Class
        
        Args:
            asset_class (type(Class)): 
        
        Returns:
            Array[Object]:
        """
        ...
    @classmethod
    def get_selected_assets(cls) -> Array[Object]:
        r"""
        X.get_selected_assets() -> Array[Object]
        Gets the set of currently selected assets
        
        Returns:
            Array[Object]:
        """
        ...
    @classmethod
    def get_selected_asset_data(cls) -> Array[AssetData]:
        r"""
        X.get_selected_asset_data() -> Array[AssetData]
        Gets the set of currently selected asset data
        
        Returns:
            Array[AssetData]:
        """
        ...
    @classmethod
    def get_current_content_browser_path(cls) -> Optional[str]:
        r"""
        X.get_current_content_browser_path() -> str or None
        Attempts to get the path for the active content browser, returns false if there is no active content browser
        or if it was a virtual path
        
        Returns:
            str or None: Whether a path was successfully returned
        
            out_path (str): The returned path if successfully found
        """
        ...
    @classmethod
    def get_current_content_browser_item_path(cls) -> ContentBrowserItemPath:
        r"""
        X.get_current_content_browser_item_path() -> ContentBrowserItemPath
        Gets the current content browser path if one is open, whether it is internal or virtual.
        
        Returns:
            ContentBrowserItemPath:
        """
        ...
    def get_actor_reference(self, path_to_actor: str) -> Actor:
        r"""
        x.get_actor_reference(path_to_actor) -> Actor
        Attempts to find the actor specified by PathToActor in the current editor world
        
        Args:
            path_to_actor (str): The path to the actor (e.g. PersistentLevel.PlayerStart)
        
        Returns:
            Actor: A reference to the actor, or none if it wasn't found
        """
        ...
    @classmethod
    def convert_to_editor_utility_widget(cls, widget_bp: WidgetBlueprint) -> None:
        r"""
        X.convert_to_editor_utility_widget(widget_bp) -> None
        Convert to Editor Utility Widget
        
        Args:
            widget_bp (WidgetBlueprint):
        """
        ...

class EditorUtilitySubsystem(EditorSubsystem):
    r"""
    Editor Utility Subsystem
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilitySubsystem.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_begin_pie`` (OnEditorUtilityPIEEvent):  [Read-Write] Expose Begin PIE to blueprints.
    - ``on_end_pie`` (OnEditorUtilityPIEEvent):  [Read-Write] Expose End PIE to blueprints.
    """
    @property
    def on_begin_pie(self) -> OnEditorUtilityPIEEvent:
        r"""
        (OnEditorUtilityPIEEvent):  [Read-Write] Expose Begin PIE to blueprints.
        """
        ...
    @on_begin_pie.setter
    def on_begin_pie(self, value: OnEditorUtilityPIEEvent) -> None:
        ...
    @property
    def on_end_pie(self) -> OnEditorUtilityPIEEvent:
        r"""
        (OnEditorUtilityPIEEvent):  [Read-Write] Expose End PIE to blueprints.
        """
        ...
    @on_end_pie.setter
    def on_end_pie(self, value: OnEditorUtilityPIEEvent) -> None:
        ...
    def unregister_tab_by_id(self, tab_id: Name) -> bool:
        r"""
        x.unregister_tab_by_id(tab_id) -> bool
        Given an ID for a tab, try to close and unregister a tab that was registered through this subsystem
        
        Args:
            tab_id (Name): 
        
        Returns:
            bool:
        """
        ...
    def try_run_class(self, object_class: Class) -> bool:
        r"""
        x.try_run_class(object_class) -> bool
        Try Run Class
        
        Args:
            object_class (type(Class)): 
        
        Returns:
            bool:
        """
        ...
    def try_run(self, asset: Object) -> bool:
        r"""
        x.try_run(asset) -> bool
        Try Run
        
        Args:
            asset (Object): 
        
        Returns:
            bool:
        """
        ...
    def spawn_registered_tab_by_id(self, new_tab_id: Name) -> bool:
        r"""
        x.spawn_registered_tab_by_id(new_tab_id) -> bool
        Given an ID for a tab, try to find a tab spawner that matches, and then spawn a tab. Returns true if it was able to find a matching tab spawner
        
        Args:
            new_tab_id (Name): 
        
        Returns:
            bool:
        """
        ...
    def spawn_and_register_tab_with_id_generated_class(self, generated_widget_blueprint: WidgetBlueprintGeneratedClass, tab_id: Name) -> EditorUtilityWidget:
        r"""
        x.spawn_and_register_tab_with_id_generated_class(generated_widget_blueprint, tab_id) -> EditorUtilityWidget
        Unlike SpawnAndRegisterTabAndGetID allows spawn tab while providing TabID from Python scripts or BP
        
        Args:
            generated_widget_blueprint (type(WidgetBlueprintGeneratedClass)): 
            tab_id (Name): 
        
        Returns:
            EditorUtilityWidget:
        """
        ...
    def spawn_and_register_tab_with_id(self, blueprint: EditorUtilityWidgetBlueprint, tab_id: Name) -> EditorUtilityWidget:
        r"""
        x.spawn_and_register_tab_with_id(blueprint, tab_id) -> EditorUtilityWidget
        Unlike SpawnAndRegisterTabAndGetID allows spawn tab while providing TabID from Python scripts or BP
        
        Args:
            blueprint (EditorUtilityWidgetBlueprint): 
            tab_id (Name): 
        
        Returns:
            EditorUtilityWidget:
        """
        ...
    def spawn_and_register_tab_generated_class(self, generated_widget_blueprint: WidgetBlueprintGeneratedClass) -> EditorUtilityWidget:
        r"""
        x.spawn_and_register_tab_generated_class(generated_widget_blueprint) -> EditorUtilityWidget
        Spawn and Register Tab Generated Class
        
        Args:
            generated_widget_blueprint (type(WidgetBlueprintGeneratedClass)): 
        
        Returns:
            EditorUtilityWidget:
        """
        ...
    def spawn_and_register_tab_and_get_id_generated_class(self, generated_widget_blueprint: WidgetBlueprintGeneratedClass) -> Tuple[EditorUtilityWidget, Name]:
        r"""
        x.spawn_and_register_tab_and_get_id_generated_class(generated_widget_blueprint) -> (EditorUtilityWidget, new_tab_id=Name)
        Spawn and Register Tab and Get IDGenerated Class
        
        Args:
            generated_widget_blueprint (type(WidgetBlueprintGeneratedClass)): 
        
        Returns:
            Name: 
        
            new_tab_id (Name):
        """
        ...
    def spawn_and_register_tab_and_get_id(self, blueprint: EditorUtilityWidgetBlueprint) -> Tuple[EditorUtilityWidget, Name]:
        r"""
        x.spawn_and_register_tab_and_get_id(blueprint) -> (EditorUtilityWidget, new_tab_id=Name)
        Spawn and Register Tab and Get ID
        
        Args:
            blueprint (EditorUtilityWidgetBlueprint): 
        
        Returns:
            Name: 
        
            new_tab_id (Name):
        """
        ...
    def spawn_and_register_tab(self, blueprint: EditorUtilityWidgetBlueprint) -> EditorUtilityWidget:
        r"""
        x.spawn_and_register_tab(blueprint) -> EditorUtilityWidget
        Spawn and Register Tab
        
        Args:
            blueprint (EditorUtilityWidgetBlueprint): 
        
        Returns:
            EditorUtilityWidget:
        """
        ...
    def release_instance_of_asset(self, asset: Object) -> None:
        r"""
        x.release_instance_of_asset(asset) -> None
        Allow startup object to be garbage collected
        
        Args:
            asset (Object):
        """
        ...
    def register_tab_and_get_id_generated_class(self, generated_widget_blueprint: WidgetBlueprintGeneratedClass) -> Name:
        r"""
        x.register_tab_and_get_id_generated_class(generated_widget_blueprint) -> Name
        Register Tab and Get IDGenerated Class
        
        Args:
            generated_widget_blueprint (type(WidgetBlueprintGeneratedClass)): 
        
        Returns:
            Name: 
        
            new_tab_id (Name):
        """
        ...
    def register_tab_and_get_id(self, blueprint: EditorUtilityWidgetBlueprint) -> Name:
        r"""
        x.register_tab_and_get_id(blueprint) -> Name
        Register Tab and Get ID
        
        Args:
            blueprint (EditorUtilityWidgetBlueprint): 
        
        Returns:
            Name: 
        
            new_tab_id (Name):
        """
        ...
    def register_and_execute_task(self, new_task: EditorUtilityTask, optional_parent_task: EditorUtilityTask = None) -> None:
        r"""
        x.register_and_execute_task(new_task, optional_parent_task=None) -> None
        Register and Execute Task
        
        Args:
            new_task (EditorUtilityTask): 
            optional_parent_task (EditorUtilityTask):
        """
        ...
    def find_utility_widget_from_blueprint(self, blueprint: EditorUtilityWidgetBlueprint) -> EditorUtilityWidget:
        r"""
        x.find_utility_widget_from_blueprint(blueprint) -> EditorUtilityWidget
        Given an editor utility widget blueprint, get the widget it creates. This will return a null pointer if the widget is not currently in a tab.
        
        Args:
            blueprint (EditorUtilityWidgetBlueprint): 
        
        Returns:
            EditorUtilityWidget:
        """
        ...
    def does_tab_exist(self, new_tab_id: Name) -> bool:
        r"""
        x.does_tab_exist(new_tab_id) -> bool
        Given an ID for a tab, try to find an existing tab. Returns true if it found a tab.
        
        Args:
            new_tab_id (Name): 
        
        Returns:
            bool:
        """
        ...
    def close_tab_by_id(self, new_tab_id: Name) -> bool:
        r"""
        x.close_tab_by_id(new_tab_id) -> bool
        Given an ID for a tab, try to find and close an existing tab. Returns true if it found a tab to close.
        
        Args:
            new_tab_id (Name): 
        
        Returns:
            bool:
        """
        ...
    def can_run(self, asset: Object) -> bool:
        r"""
        x.can_run(asset) -> bool
        Can Run
        
        Args:
            asset (Object): 
        
        Returns:
            bool:
        """
        ...

class EditorUtilityTask(Object):
    r"""
    Editor Utility Task
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityTask.h
    
    """
    def was_cancel_requested(self) -> bool:
        r"""
        x.was_cancel_requested() -> bool
        Was Cancel Requested
        
        Returns:
            bool:
        """
        ...
    def set_task_notification_text(self, text: Text) -> None:
        r"""
        x.set_task_notification_text(text) -> None
        Set Task Notification Text
        
        Args:
            text (Text):
        """
        ...
    def receive_cancel_requested(self) -> None:
        r"""
        x.receive_cancel_requested() -> None
        Receive Cancel Requested
        """
        ...
    def receive_begin_execution(self) -> None:
        r"""
        x.receive_begin_execution() -> None
        Receive Begin Execution
        """
        ...
    def get_task_title_override(self) -> Text:
        r"""
        x.get_task_title_override() -> Text
        Get Task Title Override
        
        Returns:
            Text:
        """
        ...
    def finish_executing_task(self) -> None:
        r"""
        x.finish_executing_task() -> None
        Finish Executing Task
        """
        ...

class EditorUtilityToolMenuEntry(ToolMenuEntryScript):
    r"""
    Editor Utility Tool Menu Entry
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityToolMenu.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``data`` (ToolMenuEntryScriptData):  [Read-Write]
    """
    ...

class EditorUtilityToolMenuSection(ToolMenuSectionDynamic):
    r"""
    Editor Utility Tool Menu Section
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityToolMenu.h
    
    """
    ...

class EditorUtilityWidget(UserWidget):
    r"""
    Editor Utility Widget
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidget.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``always_reregister_with_windows_menu`` (bool):  [Read-Write] Should this widget always be re-added to the windows menu once it's opened
    - ``auto_run_default_action`` (bool):  [Read-Write] Should this blueprint automatically run OnDefaultActionClicked, or should it open up a details panel to edit properties and/or offer multiple buttons
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``color_and_opacity`` (LinearColor):  [Read-Write] The color and opacity of this widget.  Tints all child widgets.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``desired_focus_widget`` (WidgetChild):  [Read-Write]
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``foreground_color`` (SlateColor):  [Read-Write] The foreground color of the widget, this is inherited by sub widgets.  Any color property
      that is marked as inherit will use this color.
    - ``help_text`` (str):  [Read-Write]
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Setting this flag to true, allows this widget to accept focus when clicked, or when navigated to.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_visibility_changed`` (OnVisibilityChangedEvent):  [Read-Write] Called when the visibility has changed
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``padding`` (Margin):  [Read-Write] The padding area around the content.
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``preview_background`` (Texture2D):  [Read-Write] A preview background that you can use when designing the UI to get a sense of scale on the screen.  Use
      a texture with a screenshot of your game in it, for example if you were designing a HUD.
    - ``priority`` (int32):  [Read-Write]
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``stop_action`` (bool):  [Read-Write]
    - ``tab_display_name`` (Text):  [Read-Write] The display name for tabs spawned with this widget
    - ``tick_frequency`` (WidgetTickFrequency):  [Read-Write] This widget is allowed to tick. If this is unchecked tick will never be called, animations will not play correctly, and latent actions will not execute.
      Uncheck this for performance reasons only
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    @property
    def tab_display_name(self) -> Text:
        r"""
        (Text):  [Read-Write] The display name for tabs spawned with this widget
        """
        ...
    @tab_display_name.setter
    def tab_display_name(self, value: Text) -> None:
        ...
    @property
    def help_text(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @help_text.setter
    def help_text(self, value: str) -> None:
        ...
    @property
    def auto_run_default_action(self) -> bool:
        r"""
        (bool):  [Read-Only] Should this blueprint automatically run OnDefaultActionClicked, or should it open up a details panel to edit properties and/or offer multiple buttons
        """
        ...
    def run(self) -> None:
        r"""
        x.run() -> None
        The default action called when the widget is invoked if bAutoRunDefaultAction=true (it is never called otherwise)
        """
        ...
    def on_default_action_clicked(self) -> None:
        r"""
        deprecated: 'on_default_action_clicked' was renamed to 'run'.
        """
        ...

class EditorUtilityWidgetBlueprint(WidgetBlueprint):
    r"""
    Editor Utility Widget Blueprint
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetBlueprint.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``blueprint_category`` (str):  [Read-Write] The category of the Blueprint, used to organize this Blueprint class when displayed in palette windows
    - ``blueprint_description`` (str):  [Read-Write] Shows up in the content browser tooltip when the blueprint is hovered
    - ``blueprint_display_name`` (str):  [Read-Write] Overrides the BP's display name in the editor UI
    - ``blueprint_namespace`` (str):  [Read-Write] The namespace of this blueprint (if set, the Blueprint will be treated differently for the context menu)
    - ``can_call_initialized_without_player_context`` (bool):  [Read-Write] Run the initialize event on widget that doesn't have a player context.
    - ``compile_mode`` (BlueprintCompileMode):  [Read-Write] The mode that will be used when compiling this class.
    - ``deprecate`` (bool):  [Read-Write] Deprecates the Blueprint, marking the generated class with the CLASS_Deprecated flag
    - ``generate_abstract_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a abstract class or not.  Should set CLASS_Abstract in the KismetCompiler.
    - ``generate_const_class`` (bool):  [Read-Write] Whether or not this blueprint's class is a const class or not.  Should set CLASS_Const in the KismetCompiler.
    - ``hide_categories`` (Array[str]):  [Read-Write] Additional HideCategories. These are added to HideCategories from parent.
    - ``is_enabled_in_debugging`` (bool):  [Read-Write] Should the widget be enabled when debugging BP
    - ``is_enabled_in_pie`` (bool):  [Read-Write] Should the widget be enabled when running PIE
    - ``run_construction_script_in_sequencer`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor in sequencer
    - ``run_construction_script_on_drag`` (bool):  [Read-Write] whether or not you want to continuously rerun the construction script for an actor as you drag it in the editor, or only when the drag operation is complete
    - ``should_cook_property_guids_value`` (ShouldCookBlueprintPropertyGuids):  [Read-Write] Whether to include the property GUIDs for the generated class in a cooked build.
      note: This option may slightly increase memory usage in a cooked build, but can avoid needing to add CoreRedirect data for Blueprint classes stored within SaveGame archives.
    - ``thumbnail_custom_size`` (Vector2D):  [Read-Write]
    - ``thumbnail_image`` (Texture2D):  [Read-Write]
    - ``thumbnail_info`` (ThumbnailInfo):  [Read-Only] Information for thumbnail rendering
    - ``thumbnail_size_mode`` (ThumbnailPreviewSizeMode):  [Read-Write]
    """
    ...

class EditorUtilityWidgetBlueprintFactory(Factory):
    r"""
    Editor Utility Widget Blueprint Factory
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetBlueprintFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``blueprint_type`` (BlueprintType):  [Read-Write] The type of blueprint that will be created
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Write] The parent class of the created blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class EditorUtilityButton(Button):
    r"""
    Editor Utility Button
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``background_color`` (LinearColor):  [Read-Write] The color multiplier for the button background
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``click_method`` (ButtonClickMethod):  [Read-Write] The type of mouse action required by the user to trigger the buttons 'Click'
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``color_and_opacity`` (LinearColor):  [Read-Write] The color multiplier for the button content
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Sometimes a button should only be mouse-clickable and never keyboard focusable.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_clicked`` (OnButtonClickedEvent):  [Read-Write] Called when the button is clicked
    - ``on_hovered`` (OnButtonHoverEvent):  [Read-Write]
    - ``on_pressed`` (OnButtonPressedEvent):  [Read-Write] Called when the button is pressed
    - ``on_released`` (OnButtonReleasedEvent):  [Read-Write] Called when the button is released
    - ``on_unhovered`` (OnButtonHoverEvent):  [Read-Write]
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``press_method`` (ButtonPressMethod):  [Read-Write] The type of keyboard/gamepad button press action required by the user to trigger the buttons 'Click'
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``touch_method`` (ButtonTouchMethod):  [Read-Write] The type of touch action required by the user to trigger the buttons 'Click'
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ButtonStyle):  [Read-Write] The button style used at runtime
    """
    ...

class EditorUtilityCheckBox(CheckBox):
    r"""
    Editor Utility Check Box
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``checked_state`` (CheckBoxState):  [Read-Write] Whether the check box is currently in a checked state
    - ``click_method`` (ButtonClickMethod):  [Read-Write] The type of mouse action required by the user to trigger the buttons 'Click'
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``horizontal_alignment`` (HorizontalAlignment):  [Read-Write] How the content of the toggle button should align within the given space
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Sometimes a button should only be mouse-clickable and never keyboard focusable.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_check_state_changed`` (OnCheckBoxComponentStateChanged):  [Read-Write] Called when the checked state has changed
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``press_method`` (ButtonPressMethod):  [Read-Write] The type of keyboard/gamepad button press action required by the user to trigger the buttons 'Click'
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``touch_method`` (ButtonTouchMethod):  [Read-Write] The type of touch action required by the user to trigger the buttons 'Click'
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (CheckBoxStyle):  [Read-Write] The checkbox bar style
    """
    ...

class EditorUtilityCircularThrobber(CircularThrobber):
    r"""
    Editor Utility Circular Throbber
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``enable_radius`` (bool):  [Read-Write]
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``image`` (SlateBrush):  [Read-Write] The throbber image.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``number_of_pieces`` (int32):  [Read-Write] How many pieces there are
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``period`` (float):  [Read-Write] The amount of time for a full circle (in seconds)
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``radius`` (float):  [Read-Write] The radius of the circle. If the throbber is a child of Canvas Panel, the 'Size to Content' option must be enabled in order to set Radius.
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    ...

class EditorUtilityComboBoxKey(ComboBoxKey):
    r"""
    Editor Utility Combo Box Key
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``content_padding`` (Margin):  [Read-Write]
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``enable_gamepad_navigation_mode`` (bool):  [Read-Write] When false, directional keys will change the selection. When true, ComboBox
      must be activated and will only capture arrow input while activated.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``foreground_color`` (SlateColor):  [Read-Write] The foreground color to pass through the hierarchy.
    - ``has_down_arrow`` (bool):  [Read-Write] When false, the down arrow is not generated and it is up to the API consumer
      to make their own visual hint that this is a drop down.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] When true, allows the combo box to receive keyboard focus
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``item_style`` (TableRowStyle):  [Read-Write] The item row style.
    - ``max_list_height`` (float):  [Read-Write] The max height of the combobox list that opens
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_generate_content_widget`` (GenerateWidgetEvent):  [Read-Write] Called when the widget is needed for the content.
    - ``on_generate_item_widget`` (GenerateWidgetEvent):  [Read-Write] Called when the widget is needed for the item.
    - ``on_opening`` (OnOpeningEvent):  [Read-Write] Called when the combobox is opening
    - ``on_selection_changed`` (OnSelectionChangedEvent):  [Read-Write] Called when a new item is selected in the combobox.
    - ``options`` (Array[Name]):  [Read-Write]
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``scroll_bar_style`` (ScrollBarStyle):  [Read-Write] The scroll bar style.
    - ``selected_option`` (Name):  [Read-Write]
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ComboBoxStyle):  [Read-Write] The combobox style.
    """
    ...

class EditorUtilityComboBoxString(ComboBoxString):
    r"""
    Editor Utility Combo Box String
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``content_padding`` (Margin):  [Read-Write]
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``default_options`` (Array[str]):  [Read-Write] The default list of items to be displayed on the combobox.
    - ``enable_gamepad_navigation_mode`` (bool):  [Read-Write] When false, directional keys will change the selection. When true, ComboBox
      must be activated and will only capture arrow input while activated.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``font`` (SlateFontInfo):  [Read-Write] The default font to use in the combobox, only applies if you're not implementing OnGenerateWidgetEvent
      to factory each new entry.
    - ``foreground_color`` (SlateColor):  [Read-Write] The foreground color to pass through the hierarchy.
    - ``has_down_arrow`` (bool):  [Read-Write] When false, the down arrow is not generated and it is up to the API consumer
      to make their own visual hint that this is a drop down.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write]
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``item_style`` (TableRowStyle):  [Read-Write] The item row style.
    - ``max_list_height`` (float):  [Read-Write] The max height of the combobox list that opens
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_generate_widget_event`` (GenerateWidgetForString):  [Read-Write] Called when the widget is needed for the item.
    - ``on_opening`` (OnOpeningEvent):  [Read-Write] Called when the combobox is opening
    - ``on_selection_changed`` (OnSelectionChangedEvent):  [Read-Write] Called when a new item is selected in the combobox.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``scroll_bar_style`` (ScrollBarStyle):  [Read-Write] The scroll bar style.
    - ``selected_option`` (str):  [Read-Write] The item in the combobox to select by default
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ComboBoxStyle):  [Read-Write] The style.
    """
    ...

class EditorUtilityEditableText(EditableText):
    r"""
    Editor Utility Editable Text
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_context_menu`` (bool):  [Read-Write] Whether the context menu can be opened
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_keyboard_focus_on_commit`` (bool):  [Read-Write] Whether to clear keyboard focus when pressing enter to commit changes
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hint_text`` (Text):  [Read-Write] Hint text that appears when there is no text in the text box
    - ``is_caret_moved_when_gain_focus`` (bool):  [Read-Write] When set to true the caret is moved when gaining focus
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_password`` (bool):  [Read-Write] Sets whether this text box is for storing a password
    - ``is_read_only`` (bool):  [Read-Write] Sets whether this text box can actually be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] How the text should be aligned with the margin.
    - ``keyboard_type`` (VirtualKeyboardType):  [Read-Write] If we're on a platform that requires a virtual keyboard, what kind of keyboard should this widget use?
    - ``minimum_desired_width`` (float):  [Read-Write] The minimum desired Width for the text
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_text_changed`` (OnEditableTextChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
    - ``on_text_committed`` (OnEditableTextCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
    - ``overflow_policy`` (TextOverflowPolicy):  [Read-Write] Sets what happens to text that is clipped and doesn't fit within the clip rect for this widget
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``revert_text_on_escape`` (bool):  [Read-Write] Whether to allow the user to back out of changes when they press the escape key
    - ``select_all_text_on_commit`` (bool):  [Read-Write] Whether to select all text when pressing enter to commit changes
    - ``select_all_text_when_focused`` (bool):  [Read-Write] Whether to select all text when the user clicks to give focus on the widget
    - ``shaped_text_options`` (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text`` (Text):  [Read-Write] The text content for this editable text box widget
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``virtual_keyboard_dismiss_action`` (VirtualKeyboardDismissAction):  [Read-Write] What action should be taken when the virtual keyboard is dismissed?
    - ``virtual_keyboard_options`` (VirtualKeyboardOptions):  [Read-Write] Additional options for the virtual keyboard
    - ``virtual_keyboard_trigger`` (VirtualKeyboardTrigger):  [Read-Write]
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (EditableTextStyle):  [Read-Write] The style
    """
    ...

class EditorUtilityEditableTextBox(EditableTextBox):
    r"""
    Editor Utility Editable Text Box
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_context_menu`` (bool):  [Read-Write] Whether the context menu can be opened
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_keyboard_focus_on_commit`` (bool):  [Read-Write] Whether to clear keyboard focus when pressing enter to commit changes
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hint_text`` (Text):  [Read-Write] Hint text that appears when there is no text in the text box
    - ``is_caret_moved_when_gain_focus`` (bool):  [Read-Write] Workaround as we lose focus when the auto completion closes.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_password`` (bool):  [Read-Write] Sets whether this text box is for storing a password
    - ``is_read_only`` (bool):  [Read-Write] Sets the Text Box as Readonly to prevent it from being modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] How the text should be aligned with the margin.
    - ``keyboard_type`` (VirtualKeyboardType):  [Read-Write] If we're on a platform that requires a virtual keyboard, what kind of keyboard should this widget use?
    - ``minimum_desired_width`` (float):  [Read-Write] The minimum desired size for the text
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_text_changed`` (OnEditableTextBoxChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
    - ``on_text_committed`` (OnEditableTextBoxCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
    - ``overflow_policy`` (TextOverflowPolicy):  [Read-Write] Sets what happens to text that is clipped and doesn't fit within the clip rect for this widget
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``revert_text_on_escape`` (bool):  [Read-Write] Whether to allow the user to back out of changes when they press the escape key
    - ``select_all_text_on_commit`` (bool):  [Read-Write] Whether to select all text when pressing enter to commit changes
    - ``select_all_text_when_focused`` (bool):  [Read-Write] Whether to select all text when the user clicks to give focus on the widget
    - ``shaped_text_options`` (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text`` (Text):  [Read-Write] The text content for this editable text box widget
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``virtual_keyboard_dismiss_action`` (VirtualKeyboardDismissAction):  [Read-Write] What action should be taken when the virtual keyboard is dismissed?
    - ``virtual_keyboard_options`` (VirtualKeyboardOptions):  [Read-Write] Additional options to use for the virtual keyboard summoned by this widget
    - ``virtual_keyboard_trigger`` (VirtualKeyboardTrigger):  [Read-Write] The type of event that will trigger the display of the virtual keyboard
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (EditableTextBoxStyle):  [Read-Write] The style
    """
    ...

class EditorUtilityExpandableArea(ExpandableArea):
    r"""
    Editor Utility Expandable Area
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``area_padding`` (Margin):  [Read-Write]
    - ``border_brush`` (SlateBrush):  [Read-Write]
    - ``border_color`` (SlateColor):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``header_padding`` (Margin):  [Read-Write]
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_expanded`` (bool):  [Read-Write]
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``max_height`` (float):  [Read-Write] The maximum height of the area
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_expansion_changed`` (OnExpandableAreaExpansionChanged):  [Read-Write] A bindable delegate for the IsChecked.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``style`` (ExpandableAreaStyle):  [Read-Write]
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    ...

class EditorUtilityInputKeySelector(InputKeySelector):
    r"""
    Editor Utility Input Key Selector
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_gamepad_keys`` (bool):  [Read-Write] When true gamepad keys are allowed in the input chord representing the selected key, otherwise they are ignored.
    - ``allow_modifier_keys`` (bool):  [Read-Write] When true modifier keys such as control and alt are allowed in the
      input chord representing the selected key, if false modifier keys are ignored.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``escape_keys`` (Array[Key]):  [Read-Write] When true gamepad keys are allowed in the input chord representing the selected key, otherwise they are ignored.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``key_selection_text`` (Text):  [Read-Write] Sets the text which is displayed while selecting keys.
    - ``margin`` (Margin):  [Read-Write] The amount of blank space around the text used to display the currently selected key.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``no_key_specified_text`` (Text):  [Read-Write] Sets the text to display when no key text is available or not selecting a key.
    - ``on_is_selecting_key_changed`` (OnIsSelectingKeyChanged):  [Read-Write] Called whenever the key selection mode starts or stops.
    - ``on_key_selected`` (OnKeySelected):  [Read-Write] Called whenever a new key is selected by the user.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``selected_key`` (InputChord):  [Read-Write] The currently selected key chord.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text_style`` (TextBlockStyle):  [Read-Write] The button style used at runtime
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ButtonStyle):  [Read-Write] The button style used at runtime
    """
    ...

class EditorUtilityListView(ListView):
    r"""
    Editor Utility List View
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_dragging`` (bool):  [Read-Write] True to allow dragging of row widgets in the list
    - ``allow_overscroll`` (bool):  [Read-Write] Disable to stop scrollbars from activating inertial overscrolling
    - ``bp_on_entry_generated`` (OnListEntryGeneratedDynamic):  [Read-Write] Called when a row widget is generated for a list item
    - ``bp_on_entry_initialized`` (OnListEntryInitializedDynamic):  [Read-Write] Called when a row widget is generated for a list item
    - ``bp_on_entry_released`` (OnListEntryReleasedDynamic):  [Read-Write] Called when a row widget is released by the list (i.e. when it no longer represents a list item)
    - ``bp_on_item_clicked`` (SimpleListItemEventDynamic):  [Read-Write]
    - ``bp_on_item_double_clicked`` (SimpleListItemEventDynamic):  [Read-Write]
    - ``bp_on_item_is_hovered_changed`` (OnItemIsHoveredChangedDynamic):  [Read-Write]
    - ``bp_on_item_scrolled_into_view`` (OnListItemScrolledIntoViewDynamic):  [Read-Write]
    - ``bp_on_item_selection_changed`` (OnListItemSelectionChangedDynamic):  [Read-Write]
    - ``bp_on_list_view_scrolled`` (OnListViewScrolledDynamic):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_selection_on_click`` (bool):  [Read-Write]
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``consume_mouse_wheel`` (ConsumeMouseWheel):  [Read-Write]
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``enable_fixed_line_offset`` (bool):  [Read-Write]
    - ``enable_right_click_scrolling`` (bool):  [Read-Write] True to allow right click drag scrolling.
    - ``enable_scroll_animation`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list
    - ``enable_touch_animated_scrolling`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list with touch
    - ``enable_touch_scrolling`` (bool):  [Read-Write] True to allow scrolling using touch input.
    - ``entry_spacing`` (float):  [Read-Write] This deprecated property was originally BlueprintReadOnly. To satisfy the compiler requirment to have a BlueprintGetter for this property,
      it relies on the newly added UFunction GetHorizontalEntrySpacing() to act as its BlueprintGetter.
      deprecated: EntrySpacing has been deprecated. Please use HorizontalEntrySpacing and VerticalEntrySpacing.
    - ``entry_widget_class`` (type(Class)):  [Read-Write] The type of widget to create for each entry displayed in the list.
    - ``fixed_line_scroll_offset`` (float):  [Read-Write] Optional fixed offset (in lines) to always apply to the top/left (depending on orientation) of the list.
      If provided, all non-inertial means of scrolling will settle with exactly this offset of the topmost entry.
      Ex: A value of 0.25 would cause the topmost full entry to be offset down by a quarter length of the preceeding entry.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``horizontal_entry_spacing`` (float):  [Read-Write]
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write]
    - ``is_pointer_scrolling_enabled`` (bool):  [Read-Write] Enable/Disable scrolling using Touch or Mouse.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``num_designer_preview_entries`` (int32):  [Read-Write] The number of dummy item entry widgets to preview in the widget designer
    - ``orientation`` (Orientation):  [Read-Write] The scroll & layout orientation of the list. ListView and TileView only.
      Vertical will scroll vertically and arrange tiles into rows.
      Horizontal will scroll horizontally and arrange tiles into columns.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``return_focus_to_selection`` (bool):  [Read-Write]
    - ``scroll_bar_style`` (ScrollBarStyle):  [Read-Write]
    - ``selection_mode`` (SelectionMode):  [Read-Write]
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``vertical_entry_spacing`` (float):  [Read-Write]
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wheel_scroll_multiplier`` (float):  [Read-Write] The multiplier to apply when wheel scrolling
    - ``widget_style`` (TableViewStyle):  [Read-Write]
    """
    ...

class EditorUtilityMultiLineEditableText(MultiLineEditableText):
    r"""
    Editor Utility Multi Line Editable Text
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_context_menu`` (bool):  [Read-Write] Whether the context menu can be opened
    - ``apply_line_height_to_bottom_line`` (bool):  [Read-Write] Whether to leave extra space below the last line due to line height.
    - ``auto_wrap_text`` (bool):  [Read-Write] True if we're wrapping text automatically based on the computed horizontal space for this widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_keyboard_focus_on_commit`` (bool):  [Read-Write] Whether to clear keyboard focus when pressing enter to commit changes
    - ``clear_text_selection_on_focus_loss`` (bool):  [Read-Write] Whether to clear text selection when focus is lost
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hint_text`` (Text):  [Read-Write] Hint text that appears when there is no text in the text box
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_read_only`` (bool):  [Read-Write] Sets the Text as Readonly to prevent it from being modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] How the text should be aligned with the margin.
    - ``line_height_percentage`` (float):  [Read-Write] The amount to scale each lines height by.
    - ``margin`` (Margin):  [Read-Write] The amount of blank space left around the edges of text area.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_text_changed`` (OnMultiLineEditableTextChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
    - ``on_text_committed`` (OnMultiLineEditableTextCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``revert_text_on_escape`` (bool):  [Read-Write] Whether to allow the user to back out of changes when they press the escape key
    - ``select_all_text_when_focused`` (bool):  [Read-Write] Whether to select all text when the user clicks to give focus on the widget
    - ``shaped_text_options`` (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text`` (Text):  [Read-Write] The text content for this editable text box widget
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``virtual_keyboard_dismiss_action`` (VirtualKeyboardDismissAction):  [Read-Write] What action should be taken when the virtual keyboard is dismissed?
    - ``virtual_keyboard_options`` (VirtualKeyboardOptions):  [Read-Write] Additional options for the virtual keyboard
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (TextBlockStyle):  [Read-Write] The style
    - ``wrap_text_at`` (float):  [Read-Write] Whether text wraps onto a new line when it's length exceeds this width; if this value is zero or negative, no wrapping occurs.
    - ``wrapping_policy`` (TextWrappingPolicy):  [Read-Write] The wrapping policy to use.
    """
    ...

class EditorUtilityMultiLineEditableTextBox(MultiLineEditableTextBox):
    r"""
    Editor Utility Multi Line Editable Text Box
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_context_menu`` (bool):  [Read-Write] Whether the context menu can be opened
    - ``apply_line_height_to_bottom_line`` (bool):  [Read-Write] Whether to leave extra space below the last line due to line height.
    - ``auto_wrap_text`` (bool):  [Read-Write] True if we're wrapping text automatically based on the computed horizontal space for this widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``hint_text`` (Text):  [Read-Write] Hint text that appears when there is no text in the text box
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_read_only`` (bool):  [Read-Write] Sets the Text as Readonly to prevent it from being modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] How the text should be aligned with the margin.
    - ``line_height_percentage`` (float):  [Read-Write] The amount to scale each lines height by.
    - ``margin`` (Margin):  [Read-Write] The amount of blank space left around the edges of text area.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_text_changed`` (OnMultiLineEditableTextBoxChangedEvent):  [Read-Write] Called whenever the text is changed programmatically or interactively by the user
    - ``on_text_committed`` (OnMultiLineEditableTextBoxCommittedEvent):  [Read-Write] Called whenever the text is committed.  This happens when the user presses enter or the text box loses focus.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``shaped_text_options`` (ShapedTextOptions):  [Read-Write] Controls how the text within this widget should be shaped.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``text`` (Text):  [Read-Write] The text content for this editable text box widget
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``virtual_keyboard_dismiss_action`` (VirtualKeyboardDismissAction):  [Read-Write] What action should be taken when the virtual keyboard is dismissed?
    - ``virtual_keyboard_options`` (VirtualKeyboardOptions):  [Read-Write] Additional options to be used by the virtual keyboard summoned from this widget
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (EditableTextBoxStyle):  [Read-Write] The style
    - ``wrap_text_at`` (float):  [Read-Write] Whether text wraps onto a new line when it's length exceeds this width; if this value is zero or negative, no wrapping occurs.
    - ``wrapping_policy`` (TextWrappingPolicy):  [Read-Write] The wrapping policy to use.
    """
    ...

class EditorUtilityProgressBar(ProgressBar):
    r"""
    Editor Utility Progress Bar
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``bar_fill_style`` (ProgressBarFillStyle):  [Read-Write] Defines the visual style of the progress bar fill - scale or mask
    - ``bar_fill_type`` (ProgressBarFillType):  [Read-Write] Defines the direction in which the progress bar fills
    - ``border_padding`` (Vector2D):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``fill_color_and_opacity`` (LinearColor):  [Read-Write] Fill Color and Opacity
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_marquee`` (bool):  [Read-Write]
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``percent`` (float):  [Read-Write] Used to determine the fill position of the progress bar ranging 0..1
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ProgressBarStyle):  [Read-Write] The progress bar style
    """
    ...

class EditorUtilityScrollBar(ScrollBar):
    r"""
    Editor Utility Scroll Bar
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``always_show_scrollbar`` (bool):  [Read-Write]
    - ``always_show_scrollbar_track`` (bool):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``orientation`` (Orientation):  [Read-Write]
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``padding`` (Margin):  [Read-Write] The margin around the scrollbar
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``thickness`` (Vector2D):  [Read-Write] The thickness of the scrollbar thumb
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (ScrollBarStyle):  [Read-Write] Style of the scrollbar
    """
    ...

class EditorUtilityScrollBox(ScrollBox):
    r"""
    Editor Utility Scroll Box
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_overscroll`` (bool):  [Read-Write] Disable to stop scrollbars from activating inertial overscrolling
    - ``allow_right_click_drag_scrolling`` (bool):  [Read-Write] Option to disable right-click-drag scrolling
    - ``always_show_scrollbar`` (bool):  [Read-Write]
    - ``always_show_scrollbar_track`` (bool):  [Read-Write]
    - ``animate_wheel_scrolling`` (bool):  [Read-Write] True to lerp smoothly when wheel scrolling along the scroll box
    - ``back_pad_scrolling`` (bool):  [Read-Write] Whether to back pad this scroll box, allowing user to scroll backward until child contents are no longer visible
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``consume_mouse_wheel`` (ConsumeMouseWheel):  [Read-Write] When mouse wheel events should be consumed.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``front_pad_scrolling`` (bool):  [Read-Write] Whether to front pad this scroll box, allowing user to scroll forward until child contents are no longer visible
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``navigation_destination`` (DescendantScrollDestination):  [Read-Write] Sets where to scroll a widget to when using explicit navigation or if ScrollWhenFocusChanges is enabled
    - ``navigation_scroll_padding`` (float):  [Read-Write] The amount of padding to ensure exists between the item being navigated to, at the edge of the
      scrollbox.  Use this if you want to ensure there's a preview of the next item the user could scroll to.
    - ``on_scroll_bar_visibility_changed`` (OnScrollBarVisibilityChangedEvent):  [Read-Write] Called when the scrollbar visibility has changed
    - ``on_user_scrolled`` (OnUserScrolledEvent):  [Read-Write] Called when the scroll has changed
    - ``orientation`` (Orientation):  [Read-Write] The orientation of the scrolling and stacking in the box.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``scroll_bar_visibility`` (SlateVisibility):  [Read-Write] Visibility
    - ``scroll_when_focus_changes`` (ScrollWhenFocusChanges):  [Read-Write] Scroll behavior when user focus is given to a child widget
    - ``scrollbar_padding`` (Margin):  [Read-Write] The margin around the scrollbar
    - ``scrollbar_thickness`` (Vector2D):  [Read-Write] The thickness of the scrollbar thumb
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wheel_scroll_multiplier`` (float):  [Read-Write] The multiplier to apply when wheel scrolling
    - ``widget_bar_style`` (ScrollBarStyle):  [Read-Write] The bar style
    - ``widget_style`` (ScrollBoxStyle):  [Read-Write] The style
    """
    ...

class EditorUtilitySlider(Slider):
    r"""
    Editor Utility Slider
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``indent_handle`` (bool):  [Read-Write] Whether the slidable area should be indented to fit the handle.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write] Should the slider be focusable?
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``locked`` (bool):  [Read-Write] Whether the handle is interactive or fixed.
    - ``max_value`` (float):  [Read-Write] The maximum value the slider can be set to.
    - ``min_value`` (float):  [Read-Write] The minimum value the slider can be set to.
    - ``mouse_uses_step`` (bool):  [Read-Write] Sets new value if mouse position is greater/less than half the step size.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_controller_capture_begin`` (OnControllerCaptureBeginEvent):  [Read-Write] Invoked when the controller capture begins.
    - ``on_controller_capture_end`` (OnControllerCaptureEndEvent):  [Read-Write] Invoked when the controller capture ends.
    - ``on_mouse_capture_begin`` (OnMouseCaptureBeginEvent):  [Read-Write] Invoked when the mouse is pressed and a capture begins.
    - ``on_mouse_capture_end`` (OnMouseCaptureEndEvent):  [Read-Write] Invoked when the mouse is released and a capture ends.
    - ``on_value_changed`` (OnFloatValueChangedEvent):  [Read-Write] Called when the value is changed by slider or typing.
    - ``orientation`` (Orientation):  [Read-Write] The slider's orientation.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``requires_controller_lock`` (bool):  [Read-Write] Sets whether we have to lock input to change the slider value.
    - ``slider_bar_color`` (LinearColor):  [Read-Write] The color to draw the slider bar in.
    - ``slider_handle_color`` (LinearColor):  [Read-Write] The color to draw the slider handle in.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``step_size`` (float):  [Read-Write] The amount to adjust the value by, when using a controller or keyboard
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``value`` (float):  [Read-Write] The volume value to display.
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (SliderStyle):  [Read-Write] The progress bar style
    """
    ...

class EditorUtilitySpinBox(SpinBox):
    r"""
    Editor Utility Spin Box
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``always_uses_delta_snap`` (bool):  [Read-Write] Whether this spin box should use the delta snapping logic for typed values - default false
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_keyboard_focus_on_commit`` (bool):  [Read-Write] Whether to remove the keyboard focus from the spin box when the value is committed
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``delta`` (float):  [Read-Write] The amount by which to change the spin box value as the slider moves.
    - ``enable_slider`` (bool):  [Read-Write] Whether this spin box should have slider feature enabled
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``font`` (SlateFontInfo):  [Read-Write] Font color and opacity (overrides style)
    - ``foreground_color`` (SlateColor):  [Read-Write]
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``justification`` (TextJustify):  [Read-Write] The justification the value text should appear as.
    - ``keyboard_type`` (VirtualKeyboardType):  [Read-Write] If we're on a platform that requires a virtual keyboard, what kind of keyboard should this widget use?
    - ``max_fractional_digits`` (int32):  [Read-Write] The maximum required fractional digits - default 6
    - ``max_slider_value`` (float):  [Read-Write] The maximum allowable value that can be specified using the slider
    - ``max_value`` (float):  [Read-Write] The maximum allowable value that can be manually entered into the spin box
    - ``min_desired_width`` (float):  [Read-Write] The minimum width of the spin box
    - ``min_fractional_digits`` (int32):  [Read-Write] The minimum required fractional digits - default 1
    - ``min_slider_value`` (float):  [Read-Write] The minimum allowable value that can be specified using the slider
    - ``min_value`` (float):  [Read-Write] The minimum allowable value that can be manually entered into the spin box
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``on_begin_slider_movement`` (OnSpinBoxBeginSliderMovement):  [Read-Write] Called right before the slider begins to move
    - ``on_end_slider_movement`` (OnSpinBoxValueChangedEvent):  [Read-Write] Called right after the slider handle is released by the user
    - ``on_value_changed`` (OnSpinBoxValueChangedEvent):  [Read-Write] Called when the value is changed interactively by the user
    - ``on_value_committed`` (OnSpinBoxValueCommittedEvent):  [Read-Write] Called when the value is committed. Occurs when the user presses Enter or the text box loses focus.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``override_max_slider_value`` (bool):  [Read-Write] Whether the optional MaxSliderValue attribute of the widget is set
    - ``override_max_value`` (bool):  [Read-Write] Whether the optional MaxValue attribute of the widget is set
    - ``override_min_slider_value`` (bool):  [Read-Write] Whether the optional MinSliderValue attribute of the widget is set
    - ``override_min_value`` (bool):  [Read-Write] Whether the optional MinValue attribute of the widget is set
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``select_all_text_on_commit`` (bool):  [Read-Write] Whether to select the text in the spin box when the value is committed
    - ``slider_exponent`` (float):  [Read-Write] The exponent by which to increase the delta as the mouse moves. 1 is constant (never increases the delta).
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``value`` (float):  [Read-Write] Value stored in this spin box
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``widget_style`` (SpinBoxStyle):  [Read-Write] The Style
    """
    ...

class EditorUtilityThrobber(Throbber):
    r"""
    Editor Utility Throbber
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``animate_horizontally`` (bool):  [Read-Write] Should the pieces animate horizontally?
    - ``animate_opacity`` (bool):  [Read-Write] Should the pieces animate their opacity?
    - ``animate_vertically`` (bool):  [Read-Write] Should the pieces animate vertically?
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``image`` (SlateBrush):  [Read-Write] The animated pieces.
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``number_of_pieces`` (int32):  [Read-Write] How many pieces there are
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    """
    ...

class EditorUtilityTreeView(TreeView):
    r"""
    Editor Utility Tree View
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: EditorUtilityWidgetComponents.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``accessible_behavior`` (SlateAccessibleBehavior):  [Read-Write] Whether or not the widget is accessible, and how to describe it. If set to custom, additional customization options will appear.
    - ``accessible_summary_behavior`` (SlateAccessibleBehavior):  [Read-Write] How to describe this widget when it's being presented through a summary of a parent widget. If set to custom, additional customization options will appear.
    - ``accessible_summary_text`` (Text):  [Read-Write] When AccessibleSummaryBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``accessible_text`` (Text):  [Read-Write] When AccessibleBehavior is set to Custom, this is the text that will be used to describe the widget.
    - ``allow_dragging`` (bool):  [Read-Write] True to allow dragging of row widgets in the list
    - ``allow_overscroll`` (bool):  [Read-Write] Disable to stop scrollbars from activating inertial overscrolling
    - ``bp_on_entry_generated`` (OnListEntryGeneratedDynamic):  [Read-Write] Called when a row widget is generated for a list item
    - ``bp_on_entry_initialized`` (OnListEntryInitializedDynamic):  [Read-Write] Called when a row widget is generated for a list item
    - ``bp_on_entry_released`` (OnListEntryReleasedDynamic):  [Read-Write] Called when a row widget is released by the list (i.e. when it no longer represents a list item)
    - ``bp_on_get_item_children`` (OnGetItemChildrenDynamic):  [Read-Write] Called to get the list of children (if any) that correspond to the given item. Only called if the native C++ version of the event is not bound.
    - ``bp_on_item_clicked`` (SimpleListItemEventDynamic):  [Read-Write]
    - ``bp_on_item_double_clicked`` (SimpleListItemEventDynamic):  [Read-Write]
    - ``bp_on_item_expansion_changed`` (OnItemExpansionChangedDynamic):  [Read-Write]
    - ``bp_on_item_is_hovered_changed`` (OnItemIsHoveredChangedDynamic):  [Read-Write]
    - ``bp_on_item_scrolled_into_view`` (OnListItemScrolledIntoViewDynamic):  [Read-Write]
    - ``bp_on_item_selection_changed`` (OnListItemSelectionChangedDynamic):  [Read-Write]
    - ``bp_on_list_view_scrolled`` (OnListViewScrolledDynamic):  [Read-Write]
    - ``can_children_be_accessible`` (bool):  [Read-Write] Whether or not children of this widget can appear as distinct accessible widgets.
    - ``clear_selection_on_click`` (bool):  [Read-Write]
    - ``clipping`` (WidgetClipping):  [Read-Write] Controls how the clipping behavior of this widget.  Normally content that overflows the
      bounds of the widget continues rendering.  Enabling clipping prevents that overflowing content
      from being seen.
      
      NOTE: Elements in different clipping spaces can not be batched together, and so there is a
      performance cost to clipping.  Do not enable clipping unless a panel actually needs to prevent
      content from showing up outside its bounds.
    - ``consume_mouse_wheel`` (ConsumeMouseWheel):  [Read-Write]
    - ``cursor`` (MouseCursor):  [Read-Write] The cursor to show when the mouse is over the widget
    - ``enable_fixed_line_offset`` (bool):  [Read-Write]
    - ``enable_right_click_scrolling`` (bool):  [Read-Write] True to allow right click drag scrolling.
    - ``enable_scroll_animation`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list
    - ``enable_touch_animated_scrolling`` (bool):  [Read-Write] True to enable lerped animation when scrolling through the list with touch
    - ``enable_touch_scrolling`` (bool):  [Read-Write] True to allow scrolling using touch input.
    - ``entry_spacing`` (float):  [Read-Write] This deprecated property was originally BlueprintReadOnly. To satisfy the compiler requirment to have a BlueprintGetter for this property,
      it relies on the newly added UFunction GetHorizontalEntrySpacing() to act as its BlueprintGetter.
      deprecated: EntrySpacing has been deprecated. Please use HorizontalEntrySpacing and VerticalEntrySpacing.
    - ``entry_widget_class`` (type(Class)):  [Read-Write] The type of widget to create for each entry displayed in the list.
    - ``fixed_line_scroll_offset`` (float):  [Read-Write] Optional fixed offset (in lines) to always apply to the top/left (depending on orientation) of the list.
      If provided, all non-inertial means of scrolling will settle with exactly this offset of the topmost entry.
      Ex: A value of 0.25 would cause the topmost full entry to be offset down by a quarter length of the preceeding entry.
    - ``flow_direction_preference`` (FlowDirectionPreference):  [Read-Write] Allows you to set a new flow direction
    - ``horizontal_entry_spacing`` (float):  [Read-Write]
    - ``is_enabled`` (bool):  [Read-Write] Sets whether this widget can be modified interactively by the user
    - ``is_focusable`` (bool):  [Read-Write]
    - ``is_pointer_scrolling_enabled`` (bool):  [Read-Write] Enable/Disable scrolling using Touch or Mouse.
    - ``is_volatile`` (bool):  [Read-Write] If true prevents the widget or its child's geometry or layout information from being cached.  If this widget
      changes every frame, but you want it to still be in an invalidation panel you should make it as volatile
      instead of invalidating it every frame, which would prevent the invalidation panel from actually
      ever caching anything.
    - ``navigation`` (WidgetNavigation):  [Read-Write] The navigation object for this widget is optionally created if the user has configured custom
      navigation rules for this widget in the widget designer.  Those rules determine how navigation transitions
      can occur between widgets.
    - ``num_designer_preview_entries`` (int32):  [Read-Write] The number of dummy item entry widgets to preview in the widget designer
    - ``orientation`` (Orientation):  [Read-Write] The scroll & layout orientation of the list. ListView and TileView only.
      Vertical will scroll vertically and arrange tiles into rows.
      Horizontal will scroll horizontally and arrange tiles into columns.
    - ``override_accessible_defaults`` (bool):  [Read-Write] Override all of the default accessibility behavior and text for this widget.
    - ``override_cursor`` (bool):  [Read-Write]
    - ``pixel_snapping`` (WidgetPixelSnapping):  [Read-Write] If the widget will draw snapped to the nearest pixel.  Improves clarity but might cause visibile stepping in animation
    - ``render_opacity`` (float):  [Read-Write] The opacity of the widget
    - ``render_transform`` (WidgetTransform):  [Read-Write] The render transform of the widget allows for arbitrary 2D transforms to be applied to the widget.
    - ``render_transform_pivot`` (Vector2D):  [Read-Write] The render transform pivot controls the location about which transforms are applied.
      This value is a normalized coordinate about which things like rotations will occur.
    - ``return_focus_to_selection`` (bool):  [Read-Write]
    - ``scroll_bar_style`` (ScrollBarStyle):  [Read-Write]
    - ``selection_mode`` (SelectionMode):  [Read-Write]
    - ``slot`` (PanelSlot):  [Read-Write] The parent slot of the UWidget.  Allows us to easily inline edit the layout controlling this widget.
    - ``tool_tip_text`` (Text):  [Read-Write] Tooltip text to show when the user hovers over the widget with the mouse
    - ``tool_tip_widget`` (Widget):  [Read-Only] Tooltip widget to show when the user hovers over the widget with the mouse
    - ``vertical_entry_spacing`` (float):  [Read-Write]
    - ``visibility`` (SlateVisibility):  [Read-Write] The visibility of the widget
    - ``wheel_scroll_multiplier`` (float):  [Read-Write] The multiplier to apply when wheel scrolling
    - ``widget_style`` (TableViewStyle):  [Read-Write]
    """
    ...

class GlobalEditorUtilityBase(Object):
    r"""
    Global Editor Utility Base
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: GlobalEditorUtilityBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_run_default_action`` (bool):  [Read-Write] Should this blueprint automatically run OnDefaultActionClicked, or should it open up a details panel to edit properties and/or offer multiple buttons
    - ``help_text`` (str):  [Read-Write]
    - ``on_each_selected_actor`` (ForEachActorIteratorSignature):  [Read-Write] The method called for each selected actor when ForEachSelectedActor is called
    - ``on_each_selected_asset`` (ForEachAssetIteratorSignature):  [Read-Write] The method called for each selected asset when ForEachSelectedAsset is called
    """
    @property
    def help_text(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @help_text.setter
    def help_text(self, value: str) -> None:
        ...
    @property
    def auto_run_default_action(self) -> bool:
        r"""
        (bool):  [Read-Only] Should this blueprint automatically run OnDefaultActionClicked, or should it open up a details panel to edit properties and/or offer multiple buttons
        """
        ...
    @property
    def on_each_selected_actor(self) -> ForEachActorIteratorSignature:
        r"""
        (ForEachActorIteratorSignature):  [Read-Write] The method called for each selected actor when ForEachSelectedActor is called
        """
        ...
    @on_each_selected_actor.setter
    def on_each_selected_actor(self, value: ForEachActorIteratorSignature) -> None:
        ...
    @property
    def on_each_selected_asset(self) -> ForEachAssetIteratorSignature:
        r"""
        (ForEachAssetIteratorSignature):  [Read-Write] The method called for each selected asset when ForEachSelectedAsset is called
        """
        ...
    @on_each_selected_asset.setter
    def on_each_selected_asset(self, value: ForEachAssetIteratorSignature) -> None:
        ...
    def set_actor_selection_state(self, actor: Actor, should_be_selected: bool) -> None:
        r"""
        x.set_actor_selection_state(actor, should_be_selected) -> None
        Set the selection state for the selected actor
        
        Args:
            actor (Actor): 
            should_be_selected (bool):
        """
        ...
    def select_nothing(self) -> None:
        r"""
        x.select_nothing() -> None
        Selects nothing in the editor (another way to clear the selection)
        """
        ...
    def rename_asset(self, asset: Object, new_name: str) -> None:
        r"""
        x.rename_asset(asset, new_name) -> None
        Renames an asset (cannot move folders)
        
        Args:
            asset (Object): 
            new_name (str):
        """
        ...
    def on_default_action_clicked(self) -> None:
        r"""
        x.on_default_action_clicked() -> None
        The default action called when the blutility is invoked if bAutoRunDefaultAction=true (it is never called otherwise)
        """
        ...
    def get_selection_set(self) -> Array[Actor]:
        r"""
        x.get_selection_set() -> Array[Actor]
        Get Selection Set
        
        Returns:
            Array[Actor]:
        """
        ...
    def get_selection_bounds(self) -> Tuple[Vector, Vector, float]:
        r"""
        x.get_selection_bounds() -> (origin=Vector, box_extent=Vector, sphere_radius=float)
        Get Selection Bounds
        
        Returns:
            tuple: 
        
            origin (Vector): 
        
            box_extent (Vector): 
        
            sphere_radius (float):
        """
        ...
    def get_selected_assets(self) -> Array[Object]:
        r"""
        x.get_selected_assets() -> Array[Object]
        Gets the set of currently selected assets
        
        Returns:
            Array[Object]:
        """
        ...
    def get_editor_user_settings(self) -> EditorPerProjectUserSettings:
        r"""
        x.get_editor_user_settings() -> EditorPerProjectUserSettings
        Get Editor User Settings
        
        Returns:
            EditorPerProjectUserSettings:
        """
        ...
    def get_actor_reference(self, path_to_actor: str) -> Actor:
        r"""
        x.get_actor_reference(path_to_actor) -> Actor
        Attempts to find the actor specified by PathToActor in the current editor world
        
        Args:
            path_to_actor (str): The path to the actor (e.g. PersistentLevel.PlayerStart)
        
        Returns:
            Actor: A reference to the actor, or none if it wasn't found
        """
        ...
    def for_each_selected_asset(self) -> None:
        r"""
        x.for_each_selected_asset() -> None
        Calls OnEachSelectedAsset for each selected asset
        """
        ...
    def for_each_selected_actor(self) -> None:
        r"""
        x.for_each_selected_actor() -> None
        Calls OnEachSelectedActor for each selected actor
        """
        ...
    def clear_actor_selection_set(self) -> None:
        r"""
        x.clear_actor_selection_set() -> None
        Remove all actors from the selection set
        """
        ...

class EditorUtilityExtension(Interface):
    r"""
    Editor Utility Extension
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: IEditorUtilityExtension.h
    
    """
    ...

class PlacedEditorUtilityBase(Actor):
    r"""
    Placed Editor Utility Base
    
    **C++ Source:**
    
    - **Module**: Blutility
    - **File**: PlacedEditorUtilityBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``help_text`` (str):  [Read-Write]
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    @property
    def help_text(self) -> str:
        r"""
        (str):  [Read-Write]
        """
        ...
    @help_text.setter
    def help_text(self, value: str) -> None:
        ...
    def set_level_viewport_camera_info(self, camera_location: Vector, camera_rotation: Rotator) -> None:
        r"""
        x.set_level_viewport_camera_info(camera_location, camera_rotation) -> None
        Sets information about the camera position for the primary level editor viewport.
        
        Args:
            camera_location (Vector): Location the camera will be moved to.
            camera_rotation (Rotator): Rotation the camera will be set to.
        """
        ...
    def set_actor_selection_state(self, actor: Actor, should_be_selected: bool) -> None:
        r"""
        x.set_actor_selection_state(actor, should_be_selected) -> None
        Set the selection state for the selected actor
        
        Args:
            actor (Actor): 
            should_be_selected (bool):
        """
        ...
    def select_nothing(self) -> None:
        r"""
        x.select_nothing() -> None
        Selects nothing in the editor (another way to clear the selection)
        """
        ...
    def get_selection_set(self) -> Array[Actor]:
        r"""
        x.get_selection_set() -> Array[Actor]
        Returns the current selection set in the editor.  Note that for non-editor builds, this will return an empty array
        
        Returns:
            Array[Actor]:
        """
        ...
    def get_level_viewport_camera_info(self) -> Optional[Tuple[Vector, Rotator]]:
        r"""
        x.get_level_viewport_camera_info() -> (camera_location=Vector, camera_rotation=Rotator) or None
        Gets information about the camera position for the primary level editor viewport.  In non-editor builds, these will be zeroed
        
        Returns:
            tuple or None: Whether or not we were able to get a camera for a level editing viewport
        
            camera_location (Vector): (out) Current location of the level editing viewport camera, or zero if none found
        
            camera_rotation (Rotator): (out) Current rotation of the level editing viewport camera, or zero if none found
        """
        ...
    def get_actor_reference(self, path_to_actor: str) -> Actor:
        r"""
        x.get_actor_reference(path_to_actor) -> Actor
        Attempts to find the actor specified by PathToActor in the current editor world
        
        Args:
            path_to_actor (str): The path to the actor (e.g. PersistentLevel.PlayerStart)
        
        Returns:
            Actor: A reference to the actor, or none if it wasn't found
        """
        ...
    def clear_actor_selection_set(self) -> None:
        r"""
        x.clear_actor_selection_set() -> None
        Remove all actors from the selection set
        """
        ...

class BlutilityActor(PlacedEditorUtilityBase):
    r"""
    deprecated: 'BlutilityActor' was renamed to 'PlacedEditorUtilityBase'.
    """
    ...

class WidgetBlueprintGeneratedClass(BlueprintGeneratedClass):
    r"""
    The widget blueprint generated class allows us to create blueprint-able widgets for UMG at runtime.
    All WBPGC's are of UUserWidget classes, and they perform special post initialization using this class
    to give themselves many of the same capabilities as AActor blueprints, like dynamic delegate binding for
    widgets.
    
    **C++ Source:**
    
    - **Module**: UMG
    - **File**: WidgetBlueprintGeneratedClass.h
    
    """
    ...

class EditorPerProjectUserSettings(Object):
    r"""
    Editor Per Project User Settings
    
    **C++ Source:**
    
    - **Module**: UnrealEd
    - **File**: EditorPerProjectUserSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``always_build_uat`` (bool):  [Read-Write] Always build UAT\UBT before launching the game. It will decrease iteration times if disabled
    - ``always_gather_behavior_tree_debugger_data`` (bool):  [Read-Write] If enabled, behavior tree debugger will collect its data even when all behavior tree editor windows are closed
    - ``animation_reimport_warnings`` (bool):  [Read-Write] If enabled, will compare an animation's sequence length and curves against the old data and inform the user if something changed
    - ``automatically_hot_reload_new_classes`` (bool):  [Read-Write] If enabled, any newly added classes will be automatically compiled and trigger a hot-reload of the module they were added to
    - ``data_source_folder`` (DirectoryPath):  [Read-Write] Specify a project data source folder to store relative source file path to ease the re-import process
    - ``display_blackboard_keys_in_alphabetical_order`` (bool):  [Read-Write] If enabled, blackboard keys displayed in blackboard editor and key selector will be sorted in alphabetical order .
    - ``display_documentation_link`` (bool):  [Read-Write] If enabled, tooltips linked to documentation will show the developer the link bound to that UI item
    - ``display_engine_version_in_badge`` (bool):  [Read-Write] When enabled, Engine Version Number is displayed in the ProjectBadge
    - ``display_ui_extension_points`` (bool):  [Read-Write] If enabled, any newly opened UI menus, menu bars, and toolbars will show the developer hooks that would accept extensions
    - ``enable_swarm_debugging`` (bool):  [Read-Write] Enable swarm debugging features. Temp ssf files are not removed. Detailed message printing
    - ``get_attention_on_uat_completion`` (bool):  [Read-Write] If enabled, the Editor will attempt to get the users attention whenever a UAT task (such as cooking or packaging) is completed
    - ``keep_attach_hierarchy`` (bool):  [Read-Write] If enabled, export level with attachment hierarchy set
    - ``keep_fbx_namespace`` (bool):  [Read-Write] If enabled, the fbx parser will keep the fbx namespaces, otherwise the namespace will be append to fbx node.
    - ``show_compiler_log_on_compile_error`` (bool):  [Read-Write] If enabled, the compile message log window will open if there is a compiler error on Hot Reload
    - ``show_import_dialog_at_reimport`` (bool):  [Read-Write] If enabled, the fbx option dialog will show when user re-import a fbx
    - ``simplygon_server_ip`` (str):  [Read-Write] Server IP for the distributed Simplygon server
    - ``simplygon_swarm_delay`` (uint32):  [Read-Write] Time between JSON net requests for Simplygon Swarm
    - ``swarm_intermediate_folder`` (str):  [Read-Write] Folder in which Simplygon Swarm will store intermediate texture and mesh data that is uploaded to the Swarm
    - ``swarm_max_upload_chunk_size_in_mb`` (uint32):  [Read-Write]
    - ``swarm_num_of_concurrent_jobs`` (uint32):  [Read-Write] Number of concurrent swarm jobs to execute. This is independent of the main job queue.
    - ``use_simplygon_swarm`` (bool):  [Read-Write] When enabled, use SimplygonSwarm Module / server to create proxies
    """
    ...

class EditorUserSettings(EditorPerProjectUserSettings):
    r"""
    deprecated: 'EditorUserSettings' was renamed to 'EditorPerProjectUserSettings'.
    """
    ...

class StaticMeshEditorSubsystem(EditorSubsystem):
    r"""
    UStaticMeshEditorSubsystem
    Subsystem for exposing static mesh functionality to scripts
    
    **C++ Source:**
    
    - **Module**: StaticMeshEditor
    - **File**: StaticMeshEditorSubsystem.h
    
    """
    def set_nanite_settings(self, static_mesh: StaticMesh, nanite_settings: MeshNaniteSettings, apply_changes: bool = True) -> None:
        r"""
        x.set_nanite_settings(static_mesh, nanite_settings, apply_changes=True) -> None
        Get the Nanite Settings for the mesh
        
        Args:
            static_mesh (StaticMesh): Mesh to update nanite settings for
            nanite_settings (MeshNaniteSettings): Settings with which to update the mesh
            apply_changes (bool): Indicates if changes must be applied or not.
        """
        ...
    def set_lods_with_notification(self, static_mesh: StaticMesh, reduction_options: StaticMeshReductionOptions, apply_changes: bool) -> int:
        r"""
        x.set_lods_with_notification(static_mesh, reduction_options, apply_changes) -> int32
        Remove then add LODs on a static mesh.
        The static mesh must have at least LOD 0.
        The LOD 0 of the static mesh is kept after removal.
        The build settings of LOD 0 will be applied to all subsequent LODs.
        
        Args:
            static_mesh (StaticMesh): Mesh to process.
            reduction_options (StaticMeshReductionOptions): Options on how to generate LODs on the mesh.
            apply_changes (bool): Indicates if change must be notified.
        
        Returns:
            int32: the number of LODs generated on the input mesh. An negative value indicates that the reduction could not be performed. See log for explanation. No action will be performed if ReductionOptions.ReductionSettings is empty
        """
        ...
    def set_lod_screen_sizes(self, static_mesh: StaticMesh, screen_sizes: Array[float]) -> bool:
        r"""
        x.set_lod_screen_sizes(static_mesh, screen_sizes) -> bool
        Set LOD screen sizes.
        
        Args:
            static_mesh (StaticMesh): Mesh to process.
            screen_sizes (Array[float]): Array of LOD screen sizes to set.
        
        Returns:
            bool: A boolean indicating if setting the screen sizes was successful.
        """
        ...
    def set_lods(self, static_mesh: StaticMesh, reduction_options: StaticMeshReductionOptions) -> int:
        r"""
        x.set_lods(static_mesh, reduction_options) -> int32
        Same as SetLodsWithNotification but changes are applied.
        
        Args:
            static_mesh (StaticMesh): 
            reduction_options (StaticMeshReductionOptions): 
        
        Returns:
            int32:
        """
        ...
    def set_lod_reduction_settings(self, static_mesh: StaticMesh, lod_index: int, reduction_options: MeshReductionSettings) -> None:
        r"""
        x.set_lod_reduction_settings(static_mesh, lod_index, reduction_options) -> None
        Set the LOD reduction for the specified LOD index.
        
        Args:
            static_mesh (StaticMesh): Mesh to process.
            lod_index (int32): The LOD we will apply the reduction settings.
            reduction_options (MeshReductionSettings): The reduction settings we want to apply to the LOD.
        """
        ...
    def set_lod_material_slot(self, static_mesh: StaticMesh, material_slot_index: int, lod_index: int, section_index: int) -> None:
        r"""
        x.set_lod_material_slot(static_mesh, material_slot_index, lod_index, section_index) -> None
        Sets the material slot for a specific LOD.
        
        Args:
            static_mesh (StaticMesh): Static mesh to Enables/disables shadow casting from.
            material_slot_index (int32): Index of the material slot to use.
            lod_index (int32): Index of the StaticMesh LOD.
            section_index (int32): Index of the StaticMesh Section.
        """
        ...
    def set_lod_group(self, static_mesh: StaticMesh, lod_group: Name, rebuild_immediately: bool = True) -> bool:
        r"""
        x.set_lod_group(static_mesh, lod_group, rebuild_immediately=True) -> bool
        Set the LODGroup for the specified static mesh
        
        Args:
            static_mesh (StaticMesh): Mesh to process.
            lod_group (Name): Name of the LODGroup to apply
            rebuild_immediately (bool): If true, rebuild the static mesh immediately
        
        Returns:
            bool: Success
        """
        ...
    def set_lod_from_static_mesh(self, destination_static_mesh: StaticMesh, destination_lod_index: int, source_static_mesh: StaticMesh, source_lod_index: int, reuse_existing_material_slots: bool) -> int:
        r"""
        x.set_lod_from_static_mesh(destination_static_mesh, destination_lod_index, source_static_mesh, source_lod_index, reuse_existing_material_slots) -> int32
        Adds or create a LOD at DestinationLodIndex using the geometry from SourceStaticMesh SourceLodIndex
        
        Args:
            destination_static_mesh (StaticMesh): The static mesh to set the LOD in.
            destination_lod_index (int32): The index of the LOD to set.
            source_static_mesh (StaticMesh): The static mesh to get the LOD from.
            source_lod_index (int32): The index of the LOD to get.
            reuse_existing_material_slots (bool): If true, sections from SourceStaticMesh will be remapped to match the material slots of DestinationStaticMesh when they have the same material assigned. If false, all material slots of SourceStaticMesh will be appended in DestinationStaticMesh.
        
        Returns:
            int32: The index of the LOD that was set. It can be different than DestinationLodIndex if it wasn't a valid index. A negative value indicates that the LOD was not set. See log for explanation.
        """
        ...
    def set_lod_build_settings(self, static_mesh: StaticMesh, lod_index: int, build_options: MeshBuildSettings) -> None:
        r"""
        x.set_lod_build_settings(static_mesh, lod_index, build_options) -> None
        Set the LOD build options for the specified LOD index.
        
        Args:
            static_mesh (StaticMesh): Mesh to process.
            lod_index (int32): The LOD we will apply the build settings.
            build_options (MeshBuildSettings): The build settings we want to apply to the LOD.
        """
        ...
    def set_generate_lightmap_uv(self, static_mesh: StaticMesh, generate_lightmap_u_vs: bool) -> bool:
        r"""
        x.set_generate_lightmap_uv(static_mesh, generate_lightmap_u_vs) -> bool
        Set Generate Lightmap UVs for StaticMesh
        
        Args:
            static_mesh (StaticMesh): 
            generate_lightmap_u_vs (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_convex_decomposition_collisions_with_notification(self, static_mesh: StaticMesh, hull_count: int, max_hull_verts: int, hull_precision: int, apply_changes: bool) -> bool:
        r"""
        x.set_convex_decomposition_collisions_with_notification(static_mesh, hull_count, max_hull_verts, hull_precision, apply_changes) -> bool
        Add a convex collision to a static mesh.
        Any existing collisions will be removed from the static mesh.
        This method replicates what is done when invoking menu entry "Collision > Auto Convex Collision" in the Mesh Editor.
        
        Args:
            static_mesh (StaticMesh): Static mesh to add convex collision on.
            hull_count (int32): Maximum number of convex pieces that will be created. Must be positive.
            max_hull_verts (int32): Maximum number of vertices allowed for any generated convex hull.
            hull_precision (int32): Number of voxels to use when generating collision. Must be positive.
            apply_changes (bool): Indicates if changes must be apply or not.
        
        Returns:
            bool: A boolean indicating if the addition was successful or not.
        """
        ...
    def set_convex_decomposition_collisions(self, static_mesh: StaticMesh, hull_count: int, max_hull_verts: int, hull_precision: int) -> bool:
        r"""
        x.set_convex_decomposition_collisions(static_mesh, hull_count, max_hull_verts, hull_precision) -> bool
        Same as SetConvexDecompositionCollisionsWithNotification but changes are automatically applied.
        
        Args:
            static_mesh (StaticMesh): 
            hull_count (int32): 
            max_hull_verts (int32): 
            hull_precision (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_allow_cpu_access(self, static_mesh: StaticMesh, allow_cpu_access: bool) -> None:
        r"""
        x.set_allow_cpu_access(static_mesh, allow_cpu_access) -> None
        Sets StaticMeshFlag bAllowCPUAccess
        
        Args:
            static_mesh (StaticMesh): 
            allow_cpu_access (bool):
        """
        ...
    def replace_mesh_components_meshes_on_actors(self, actors: Array[Actor], mesh_to_be_replaced: StaticMesh, new_mesh: StaticMesh) -> None:
        r"""
        x.replace_mesh_components_meshes_on_actors(actors, mesh_to_be_replaced, new_mesh) -> None
        Find the references of the mesh MeshToBeReplaced on all the MeshComponents of all the Actors provided and replace it by NewMesh.
        
        Args:
            actors (Array[Actor]): List of Actors to search from.
            mesh_to_be_replaced (StaticMesh): Mesh we want to replace.
            new_mesh (StaticMesh): Mesh to replace MeshToBeReplaced by.
        """
        ...
    def replace_mesh_components_meshes(self, mesh_components: Array[StaticMeshComponent], mesh_to_be_replaced: StaticMesh, new_mesh: StaticMesh) -> None:
        r"""
        x.replace_mesh_components_meshes(mesh_components, mesh_to_be_replaced, new_mesh) -> None
        Find the references of the mesh MeshToBeReplaced on all the MeshComponents provided and replace it by NewMesh.
        The editor should not be in play in editor mode.
        
        Args:
            mesh_components (Array[StaticMeshComponent]): List of MeshComponent to search from.
            mesh_to_be_replaced (StaticMesh): Mesh we want to replace.
            new_mesh (StaticMesh): Mesh to replace MeshToBeReplaced by.
        """
        ...
    def replace_mesh_components_materials_on_actors(self, actors: Array[Actor], material_to_be_replaced: MaterialInterface, new_material: MaterialInterface) -> None:
        r"""
        x.replace_mesh_components_materials_on_actors(actors, material_to_be_replaced, new_material) -> None
        Find the references of the material MaterialToReplaced on all the MeshComponents of all the Actors provided and replace it by NewMaterial.
        
        Args:
            actors (Array[Actor]): List of Actors to search from.
            material_to_be_replaced (MaterialInterface): Material we want to replace.
            new_material (MaterialInterface): Material to replace MaterialToBeReplaced by.
        """
        ...
    def replace_mesh_components_materials(self, mesh_components: Array[MeshComponent], material_to_be_replaced: MaterialInterface, new_material: MaterialInterface) -> None:
        r"""
        x.replace_mesh_components_materials(mesh_components, material_to_be_replaced, new_material) -> None
        Find the references of the material MaterialToReplaced on all the MeshComponents provided and replace it by NewMaterial.
        
        Args:
            mesh_components (Array[MeshComponent]): List of MeshComponent to search from.
            material_to_be_replaced (MaterialInterface): Material we want to replace.
            new_material (MaterialInterface): Material to replace MaterialToBeReplaced by.
        """
        ...
    def remove_uv_channel(self, static_mesh: StaticMesh, lod_index: int, uv_channel_index: int) -> bool:
        r"""
        x.remove_uv_channel(static_mesh, lod_index, uv_channel_index) -> bool
        Removes the UV channel at the specified channel index on the given LOD of a StaticMesh.
        
        Args:
            static_mesh (StaticMesh): Static mesh on which to remove the UV channel.
            lod_index (int32): Index of the StaticMesh LOD.
            uv_channel_index (int32): Index where to remove the UV channel.
        
        Returns:
            bool: true if the UV channel was removed.
        """
        ...
    def remove_lods(self, static_mesh: StaticMesh) -> bool:
        r"""
        x.remove_lods(static_mesh) -> bool
        Remove LODs on a static mesh except LOD 0.
        
        Args:
            static_mesh (StaticMesh): Mesh to remove LOD from.
        
        Returns:
            bool: A boolean indicating if the removal was successful, true, or not.
        """
        ...
    def remove_collisions_with_notification(self, static_mesh: StaticMesh, apply_changes: bool) -> bool:
        r"""
        x.remove_collisions_with_notification(static_mesh, apply_changes) -> bool
        Remove collisions from a static mesh.
        This method replicates what is done when invoking menu entries "Collision > Remove Collision" in the Mesh Editor.
        
        Args:
            static_mesh (StaticMesh): Static mesh to remove collisions from.
            apply_changes (bool): Indicates if changes must be apply or not.
        
        Returns:
            bool: A boolean indicating if the removal was successful or not.
        """
        ...
    def remove_collisions(self, static_mesh: StaticMesh) -> bool:
        r"""
        x.remove_collisions(static_mesh) -> bool
        Same as RemoveCollisionsWithNotification but changes are applied.
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            bool:
        """
        ...
    def reimport_all_custom_lo_ds(self, static_mesh: StaticMesh) -> bool:
        r"""
        x.reimport_all_custom_lo_ds(static_mesh) -> bool
        Re-import all the custom LODs present in the specified static mesh.
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            bool: true if re-import all LODs works, false otherwise see log for explanation.
        """
        ...
    def merge_static_mesh_actors(self, actors_to_merge: Array[StaticMeshActor], merge_options: MergeStaticMeshActorsOptions) -> Optional[StaticMeshActor]:
        r"""
        x.merge_static_mesh_actors(actors_to_merge, merge_options) -> StaticMeshActor or None
        Merge the meshes into a unique mesh with the provided StaticMeshActors. There are multiple options on how to merge the meshes and their materials.
        The ActorsToMerge need to be in the same Level.
        This may have a high impact on performance depending of the MeshMergingSettings options.
        
        Args:
            actors_to_merge (Array[StaticMeshActor]): List of Actors to merge.
            merge_options (MergeStaticMeshActorsOptions): Options on how to merge the actors.
        
        Returns:
            StaticMeshActor or None: if the operation is successful.
        
            out_merged_actor (StaticMeshActor): The new created actor, if requested.
        """
        ...
    def join_static_mesh_actors(self, actors_to_join: Array[StaticMeshActor], join_options: JoinStaticMeshActorsOptions) -> Actor:
        r"""
        x.join_static_mesh_actors(actors_to_join, join_options) -> Actor
        Create a new Actor in the level that contains a duplicate of all the Actors Static Meshes Component.
        The ActorsToJoin need to be in the same Level.
        This will have a low impact on performance but may help the edition by grouping the meshes under a single Actor.
        
        Args:
            actors_to_join (Array[StaticMeshActor]): List of Actors to join.
            join_options (JoinStaticMeshActorsOptions): Options on how to join the actors.
        
        Returns:
            Actor: The new created actor.
        """
        ...
    def is_section_collision_enabled(self, static_mesh: StaticMesh, lod_index: int, section_index: int) -> bool:
        r"""
        x.is_section_collision_enabled(static_mesh, lod_index, section_index) -> bool
        Checks if a specific LOD mesh section has collision.
        
        Args:
            static_mesh (StaticMesh): Static mesh to remove collisions from.
            lod_index (int32): Index of the StaticMesh LOD.
            section_index (int32): Index of the StaticMesh Section.
        
        Returns:
            bool: True if the collision is enabled for the specified LOD of the StaticMesh section.
        """
        ...
    def insert_uv_channel(self, static_mesh: StaticMesh, lod_index: int, uv_channel_index: int) -> bool:
        r"""
        x.insert_uv_channel(static_mesh, lod_index, uv_channel_index) -> bool
        Inserts an empty UV channel at the specified channel index on the given LOD of a StaticMesh.
        
        Args:
            static_mesh (StaticMesh): Static mesh on which to insert a UV channel.
            lod_index (int32): Index of the StaticMesh LOD.
            uv_channel_index (int32): Index where to insert the UV channel.
        
        Returns:
            bool: true if a UV channel was added.
        """
        ...
    def import_lod(self, base_static_mesh: StaticMesh, lod_index: int, source_filename: str) -> int:
        r"""
        x.import_lod(base_static_mesh, lod_index, source_filename) -> int32
        Import or re-import a LOD into the specified base mesh. If the LOD do not exist it will import it and add it to the base static mesh. If the LOD already exist it will re-import the specified LOD.
        
        Args:
            base_static_mesh (StaticMesh): 
            lod_index (int32): 
            source_filename (str): 
        
        Returns:
            int32: the index of the LOD that was imported or re-imported. Will return INDEX_NONE if anything goes bad.
        """
        ...
    def has_vertex_colors(self, static_mesh: StaticMesh) -> bool:
        r"""
        x.has_vertex_colors(static_mesh) -> bool
        Check whether a static mesh has vertex colors
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            bool:
        """
        ...
    def has_instance_vertex_colors(self, static_mesh_component: StaticMeshComponent) -> bool:
        r"""
        x.has_instance_vertex_colors(static_mesh_component) -> bool
        Check whether a static mesh component has vertex colors
        
        Args:
            static_mesh_component (StaticMeshComponent): 
        
        Returns:
            bool:
        """
        ...
    def get_simple_collision_count(self, static_mesh: StaticMesh) -> int:
        r"""
        x.get_simple_collision_count(static_mesh) -> int32
        Get number of simple collisions present on a static mesh.
        
        Args:
            static_mesh (StaticMesh): Mesh to query on.
        
        Returns:
            int32: An integer representing the number of simple collisions on the input static mesh. An negative value indicates that the command could not be executed. See log for explanation.
        """
        ...
    def get_num_uv_channels(self, static_mesh: StaticMesh, lod_index: int) -> int:
        r"""
        x.get_num_uv_channels(static_mesh, lod_index) -> int32
        Returns the number of UV channels for the given LOD of a StaticMesh.
        
        Args:
            static_mesh (StaticMesh): Static mesh to query.
            lod_index (int32): Index of the StaticMesh LOD.
        
        Returns:
            int32: the number of UV channels.
        """
        ...
    def get_number_verts(self, static_mesh: StaticMesh, lod_index: int) -> int:
        r"""
        x.get_number_verts(static_mesh, lod_index) -> int32
        Get number of StaticMesh verts for an LOD
        
        Args:
            static_mesh (StaticMesh): 
            lod_index (int32): 
        
        Returns:
            int32:
        """
        ...
    def get_number_materials(self, static_mesh: StaticMesh) -> int:
        r"""
        x.get_number_materials(static_mesh) -> int32
        Get number of Materials for a StaticMesh
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            int32:
        """
        ...
    def get_nanite_settings(self, static_mesh: StaticMesh) -> MeshNaniteSettings:
        r"""
        x.get_nanite_settings(static_mesh) -> MeshNaniteSettings
        Get the Nanite Settings for the mesh
        
        Args:
            static_mesh (StaticMesh): Mesh to access
        
        Returns:
            MeshNaniteSettings: FMeshNaniteSettings struct for the given static mesh
        """
        ...
    def get_lod_screen_sizes(self, static_mesh: StaticMesh) -> Array[float]:
        r"""
        x.get_lod_screen_sizes(static_mesh) -> Array[float]
        Get an array of LOD screen sizes for evaluation.
        
        Args:
            static_mesh (StaticMesh): Mesh to process.
        
        Returns:
            Array[float]: array of LOD screen sizes.
        """
        ...
    def get_lod_reduction_settings(self, static_mesh: StaticMesh, lod_index: int) -> MeshReductionSettings:
        r"""
        x.get_lod_reduction_settings(static_mesh, lod_index) -> MeshReductionSettings
        Copy the reduction options with the specified LOD reduction settings.
        
        Args:
            static_mesh (StaticMesh): Mesh to process.
            lod_index (int32): The LOD we get the reduction settings.
        
        Returns:
            MeshReductionSettings: 
        
            out_reduction_options (MeshReductionSettings): The reduction settings where we copy the reduction options.
        """
        ...
    def get_lod_material_slot(self, static_mesh: StaticMesh, lod_index: int, section_index: int) -> int:
        r"""
        x.get_lod_material_slot(static_mesh, lod_index, section_index) -> int32
        Gets the material slot used for a specific LOD section.
        
        Args:
            static_mesh (StaticMesh): Static mesh to get the material index from.
            lod_index (int32): Index of the StaticMesh LOD.
            section_index (int32): Index of the StaticMesh Section.
        
        Returns:
            int32: MaterialSlotIndex   Index of the material slot used by the section or INDEX_NONE in case of error.
        """
        ...
    def get_lod_group(self, static_mesh: StaticMesh) -> Name:
        r"""
        x.get_lod_group(static_mesh) -> Name
        Get the LODGroup for the specified static mesh
        
        Args:
            static_mesh (StaticMesh): 
        
        Returns:
            Name: LODGroup
        """
        ...
    def get_lod_count(self, static_mesh: StaticMesh) -> int:
        r"""
        x.get_lod_count(static_mesh) -> int32
        Get number of LODs present on a static mesh.
        
        Args:
            static_mesh (StaticMesh): Mesh to process.
        
        Returns:
            int32: the number of LODs present on the input mesh. An negative value indicates that the command could not be executed. See log for explanation.
        """
        ...
    def get_lod_build_settings(self, static_mesh: StaticMesh, lod_index: int) -> MeshBuildSettings:
        r"""
        x.get_lod_build_settings(static_mesh, lod_index) -> MeshBuildSettings
        Copy the build options with the specified LOD build settings.
        
        Args:
            static_mesh (StaticMesh): Mesh to process.
            lod_index (int32): The LOD we get the reduction settings.
        
        Returns:
            MeshBuildSettings: 
        
            out_build_options (MeshBuildSettings): The build settings where we copy the build options.
        """
        ...
    def get_convex_collision_count(self, static_mesh: StaticMesh) -> int:
        r"""
        x.get_convex_collision_count(static_mesh) -> int32
        Get number of convex collisions present on a static mesh.
        
        Args:
            static_mesh (StaticMesh): Mesh to query on.
        
        Returns:
            int32: An integer representing the number of convex collisions on the input static mesh. An negative value indicates that the command could not be executed. See log for explanation.
        """
        ...
    def get_collision_complexity(self, static_mesh: StaticMesh) -> CollisionTraceFlag:
        r"""
        x.get_collision_complexity(static_mesh) -> CollisionTraceFlag
        Get the Collision Trace behavior of a static mesh
        
        Args:
            static_mesh (StaticMesh): Mesh to query on.
        
        Returns:
            CollisionTraceFlag: the Collision Trace behavior.
        """
        ...
    def generate_planar_uv_channel(self, static_mesh: StaticMesh, lod_index: int, uv_channel_index: int, position: Vector, orientation: Rotator, tiling: Vector2D) -> bool:
        r"""
        x.generate_planar_uv_channel(static_mesh, lod_index, uv_channel_index, position, orientation, tiling) -> bool
        Generates planar UV mapping in the specified UV channel on the given LOD of a StaticMesh.
        
        Args:
            static_mesh (StaticMesh): Static mesh on which to generate the UV mapping.
            lod_index (int32): Index of the StaticMesh LOD.
            uv_channel_index (int32): Channel where to save the UV mapping.
            position (Vector): Position of the center of the projection gizmo.
            orientation (Rotator): Rotation to apply to the projection gizmo.
            tiling (Vector2D): The UV tiling to use to generate the UV mapping.
        
        Returns:
            bool: true if the UV mapping was generated.
        """
        ...
    def generate_cylindrical_uv_channel(self, static_mesh: StaticMesh, lod_index: int, uv_channel_index: int, position: Vector, orientation: Rotator, tiling: Vector2D) -> bool:
        r"""
        x.generate_cylindrical_uv_channel(static_mesh, lod_index, uv_channel_index, position, orientation, tiling) -> bool
        Generates cylindrical UV mapping in the specified UV channel on the given LOD of a StaticMesh.
        
        Args:
            static_mesh (StaticMesh): Static mesh on which to generate the UV mapping.
            lod_index (int32): Index of the StaticMesh LOD.
            uv_channel_index (int32): Channel where to save the UV mapping.
            position (Vector): Position of the center of the projection gizmo.
            orientation (Rotator): Rotation to apply to the projection gizmo.
            tiling (Vector2D): The UV tiling to use to generate the UV mapping.
        
        Returns:
            bool: true if the UV mapping was generated.
        """
        ...
    def generate_box_uv_channel(self, static_mesh: StaticMesh, lod_index: int, uv_channel_index: int, position: Vector, orientation: Rotator, size: Vector) -> bool:
        r"""
        x.generate_box_uv_channel(static_mesh, lod_index, uv_channel_index, position, orientation, size) -> bool
        Generates box UV mapping in the specified UV channel on the given LOD of a StaticMesh.
        
        Args:
            static_mesh (StaticMesh): Static mesh on which to generate the UV mapping.
            lod_index (int32): Index of the StaticMesh LOD.
            uv_channel_index (int32): Channel where to save the UV mapping.
            position (Vector): Position of the center of the projection gizmo.
            orientation (Rotator): Rotation to apply to the projection gizmo.
            size (Vector): The size of the box projection gizmo.
        
        Returns:
            bool: true if the UV mapping was generated.
        """
        ...
    def enable_section_collision(self, static_mesh: StaticMesh, collision_enabled: bool, lod_index: int, section_index: int) -> None:
        r"""
        x.enable_section_collision(static_mesh, collision_enabled, lod_index, section_index) -> None
        Enables/disables mesh section collision for a specific LOD.
        
        Args:
            static_mesh (StaticMesh): Static mesh to Enables/disables collisions from.
            collision_enabled (bool): If the collision is enabled or not.
            lod_index (int32): Index of the StaticMesh LOD.
            section_index (int32): Index of the StaticMesh Section.
        """
        ...
    def enable_section_cast_shadow(self, static_mesh: StaticMesh, cast_shadow: bool, lod_index: int, section_index: int) -> None:
        r"""
        x.enable_section_cast_shadow(static_mesh, cast_shadow, lod_index, section_index) -> None
        Enables/disables mesh section shadow casting for a specific LOD.
        
        Args:
            static_mesh (StaticMesh): Static mesh to Enables/disables shadow casting from.
            cast_shadow (bool): If the section should cast shadow.
            lod_index (int32): Index of the StaticMesh LOD.
            section_index (int32): Index of the StaticMesh Section.
        """
        ...
    def create_proxy_mesh_actor(self, actors_to_merge: Array[StaticMeshActor], merge_options: CreateProxyMeshActorOptions) -> Optional[StaticMeshActor]:
        r"""
        x.create_proxy_mesh_actor(actors_to_merge, merge_options) -> StaticMeshActor or None
        Build a proxy mesh actor that can replace a set of mesh actors.
        
        Args:
            actors_to_merge (Array[StaticMeshActor]): List of actors to build a proxy for.
            merge_options (CreateProxyMeshActorOptions): 
        
        Returns:
            StaticMeshActor or None: Success of the proxy creation
        
            out_merged_actor (StaticMeshActor): generated actor if requested
        """
        ...
    def bulk_set_convex_decomposition_collisions_with_notification(self, static_meshes: Array[StaticMesh], hull_count: int, max_hull_verts: int, hull_precision: int, apply_changes: bool) -> bool:
        r"""
        x.bulk_set_convex_decomposition_collisions_with_notification(static_meshes, hull_count, max_hull_verts, hull_precision, apply_changes) -> bool
        Compute convex collisions for a set of static meshes.
        Any existing collisions will be removed from the static meshes.
        This method replicates what is done when invoking menu entry "Collision > Auto Convex Collision" in the Mesh Editor.
        
        Args:
            static_meshes (Array[StaticMesh]): Set of Static mesh to add convex collision on.
            hull_count (int32): Maximum number of convex pieces that will be created. Must be positive.
            max_hull_verts (int32): Maximum number of vertices allowed for any generated convex hull.
            hull_precision (int32): Number of voxels to use when generating collision. Must be positive.
            apply_changes (bool): Indicates if changes must be apply or not.
        
        Returns:
            bool: A boolean indicating if the addition was successful or not.
        """
        ...
    def bulk_set_convex_decomposition_collisions(self, static_meshes: Array[StaticMesh], hull_count: int, max_hull_verts: int, hull_precision: int) -> bool:
        r"""
        x.bulk_set_convex_decomposition_collisions(static_meshes, hull_count, max_hull_verts, hull_precision) -> bool
        Same as SetConvexDecompositionCollisionsWithNotification but changes are automatically applied.
        
        Args:
            static_meshes (Array[StaticMesh]): 
            hull_count (int32): 
            max_hull_verts (int32): 
            hull_precision (int32): 
        
        Returns:
            bool:
        """
        ...
    def add_uv_channel(self, static_mesh: StaticMesh, lod_index: int) -> bool:
        r"""
        x.add_uv_channel(static_mesh, lod_index) -> bool
        Adds an empty UV channel at the end of the existing channels on the given LOD of a StaticMesh.
        
        Args:
            static_mesh (StaticMesh): Static mesh on which to add a UV channel.
            lod_index (int32): Index of the StaticMesh LOD.
        
        Returns:
            bool: true if a UV channel was added.
        """
        ...
    def add_simple_collisions_with_notification(self, static_mesh: StaticMesh, shape_type: ScriptCollisionShapeType, apply_changes: bool) -> int:
        r"""
        x.add_simple_collisions_with_notification(static_mesh, shape_type, apply_changes) -> int32
        Add simple collisions to a static mesh.
        This method replicates what is done when invoking menu entries "Collision > Add [...] Simplified Collision" in the Mesh Editor.
        
        Args:
            static_mesh (StaticMesh): Mesh to generate simple collision for.
            shape_type (ScriptCollisionShapeType): Options on which simple collision to add to the mesh.
            apply_changes (bool): Indicates if changes must be apply or not.
        
        Returns:
            int32: An integer indicating the index of the collision newly created. A negative value indicates the addition failed.
        """
        ...
    def add_simple_collisions(self, static_mesh: StaticMesh, shape_type: ScriptCollisionShapeType) -> int:
        r"""
        x.add_simple_collisions(static_mesh, shape_type) -> int32
        Same as AddSimpleCollisionsWithNotification but changes are automatically applied.
        
        Args:
            static_mesh (StaticMesh): 
            shape_type (ScriptCollisionShapeType): 
        
        Returns:
            int32:
        """
        ...

class VisualLoggerRenderingComponent(DebugDrawComponent):
    r"""
    Primitive component used to draw visual logger data on level
    
    **C++ Source:**
    
    - **Module**: LogVisualizer
    - **File**: VisualLoggerRenderingComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    """
    ...

class VisualLoggerCameraController(DebugCameraController):
    r"""
    Visual Logger Camera Controller
    
    **C++ Source:**
    
    - **Module**: LogVisualizer
    - **File**: VisualLoggerCameraController.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_data_class`` (type(Class)):  [Read-Write] The type of async physics data object to use
      deprecated: AsyncPhysicsDataClass is deprecated. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``async_physics_data_component_deprecared`` (AsyncPhysicsInputComponent):  [Read-Write]
      deprecated: AsyncPhysicsDataComponent is deprecated. please see the new C++ NetworkPhysicsComponent
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``attach_to_pawn`` (bool):  [Read-Write] If true, the controller location will match the possessed Pawn's location. If false, it will not be updated. Rotation will match ControlRotation in either case.
      Since a Controller's location is normally inaccessible, this is intended mainly for purposes of being able to attach
      an Actor that follows the possessed Pawn location, but that still has the full aim rotation (since a Pawn might
      update only some components of the rotation).
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_manage_active_camera_target`` (bool):  [Read-Write] True to allow this player controller to manage the camera target for you,
      typically by using the possessed pawn as the camera target. Set to false
      if you want to manually control the camera target.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``cheat_class`` (type(Class)):  [Read-Write] Class of my CheatManager.
      see: CheatManager for more information about when it will be instantiated.
    - ``cheat_manager`` (CheatManager):  [Read-Write] Object that manages "cheat" commands.
      
      By default:
            - In Shipping configurations, the manager is always disabled because UE_WITH_CHEAT_MANAGER is 0
        - When playing in the editor, cheats are always enabled
        - In other cases, cheats are enabled by default in single player games but can be forced on with the EnableCheats console command
      
      This behavior can be changed either by overriding APlayerController::EnableCheats or AGameModeBase::AllowCheats.
    - ``click_event_keys`` (Array[Key]):  [Read-Write] List of keys that will cause click events to be forwarded, default to left click
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``current_click_trace_channel`` (CollisionChannel):  [Read-Write] Trace channel currently being used for determining what world object was clicked on.
    - ``current_mouse_cursor`` (MouseCursor):  [Read-Write] Currently visible mouse cursor
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_click_trace_channel`` (CollisionChannel):  [Read-Write] Default trace channel used for determining what world object was clicked on.
    - ``default_mouse_cursor`` (MouseCursor):  [Read-Write] Type of mouse cursor to show by default
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_click_events`` (bool):  [Read-Write] Whether actor/component click events should be generated.
    - ``enable_motion_controls`` (bool):  [Read-Write] Whether or not to consider input from motion sources (tilt, acceleration, etc)
    - ``enable_mouse_over_events`` (bool):  [Read-Write] Whether actor/component mouse over events should be generated.
    - ``enable_streaming_source`` (bool):  [Read-Write] Whether the PlayerController should be used as a World Partiton streaming source.
    - ``enable_touch_events`` (bool):  [Read-Write] Whether actor/component touch events should be generated.
    - ``enable_touch_over_events`` (bool):  [Read-Write] Whether actor/component touch over events should be generated.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``force_feedback_enabled`` (bool):  [Read-Write]
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hit_result_trace_distance`` (float):  [Read-Write] Distance to trace when computing click events
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_accel`` (float):  [Read-Write] Initial acceleration of the spectator pawn when we start possession.
    - ``initial_decel`` (float):  [Read-Write] Initial deceleration of the spectator pawn when we start possession.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``initial_max_speed`` (float):  [Read-Write] Initial max speed of the spectator pawn when we start possession.
    - ``input_pitch_scale`` (float):  [Read-Write] Pitch input speed scaling
      deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``input_roll_scale`` (float):  [Read-Write] Roll input speed scaling
      deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``input_yaw_scale`` (float):  [Read-Write] Yaw input speed scaling
      deprecated: Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_instigated_any_damage`` (InstigatedAnyDamageSignature):  [Read-Write] Called when the controller has instigated damage in any way
    - ``on_possessed_pawn_changed`` (OnPossessedPawnChanged):  [Read-Write] Called on both authorities and clients when the possessed pawn changes (either OldPawn or NewPawn might be nullptr)
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``override_player_input_class`` (type(Class)):  [Read-Write] If set, then this UPlayerInput class will be used instead of the Input Settings' DefaultPlayerInputClass
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_camera_manager`` (PlayerCameraManager):  [Read-Write] Camera manager associated with this Player Controller.
    - ``player_camera_manager_class`` (type(Class)):  [Read-Write] PlayerCamera class should be set for each game, otherwise Engine.PlayerCameraManager is used
    - ``player_is_waiting`` (bool):  [Read-Only] True if PlayerController is currently waiting for the match to start or to respawn. Only valid in Spectating state.
    - ``player_state`` (PlayerState):  [Read-Write] PlayerState containing replicated information about the player using this controller (only exists for players, not NPCs).
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``should_perform_full_tick_when_paused`` (bool):  [Read-Write] Whether we fully tick when the game is paused, if our tick function is allowed to do so. If false, we do a minimal update during the tick.
    - ``show_mouse_cursor`` (bool):  [Read-Write] Whether the mouse cursor should be displayed.
    - ``smooth_target_view_rotation_speed`` (float):  [Read-Write] Interp speed for blending remote view rotation for smoother client updates
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``speed_scale`` (float):  [Read-Write] Allows control over the speed of the spectator pawn. This scales the speed based on the InitialMaxSpeed. Use Set Pawn Movement Speed Scale during runtime
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``streaming_source_debug_color`` (Color):  [Read-Write] Color used for debugging.
    - ``streaming_source_priority`` (StreamingSourcePriority):  [Read-Write] PlayerController streaming source priority.
    - ``streaming_source_shapes`` (Array[StreamingSourceShape]):  [Read-Write] Optional aggregated shape list used to build a custom shape for the streaming source. When empty, fallbacks sphere shape with a radius equal to grid's loading range.
    - ``streaming_source_should_activate`` (bool):  [Read-Write] Whether the PlayerController streaming source should activate cells after loading.
    - ``streaming_source_should_block_on_slow_streaming`` (bool):  [Read-Write] Whether the PlayerController streaming source should block on slow streaming.
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class VisualLoggerHUD(DebugCameraHUD):
    r"""
    Visual Logger HUD
    
    **C++ Source:**
    
    - **Module**: LogVisualizer
    - **File**: VisualLoggerHUD.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``enable_debug_text_shadow`` (bool):  [Read-Write] Put shadow on debug strings
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``lost_focus_paused`` (bool):  [Read-Write] Tells whether the game was paused due to lost focus
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``player_owner`` (PlayerController):  [Read-Write] PlayerController which owns this HUD.
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``show_debug_info`` (bool):  [Read-Write] If true, current ViewTarget shows debug information using its DisplayDebug().
    - ``show_hit_box_debug_info`` (bool):  [Read-Write] If true, show hitbox debugging info.
    - ``show_hud`` (bool):  [Read-Write] Whether or not the HUD should be drawn.
    - ``show_overlays`` (bool):  [Read-Write] If true, render actor overlays.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class VisualLoggerRenderingActorBase(Actor):
    r"""
    Transient actor used to draw visual logger data on level
    Base class shared between RewindDebugger and Visual Logger implementations
    
    **C++ Source:**
    
    - **Module**: LogVisualizer
    - **File**: VisualLoggerRenderingActorBase.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class VisualLoggerRenderingActor(VisualLoggerRenderingActorBase):
    r"""
    Visual Logger Rendering Actor
    
    **C++ Source:**
    
    - **Module**: LogVisualizer
    - **File**: VisualLoggerRenderingActor.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class SkeletalMeshEditorSubsystem(EditorSubsystem):
    r"""
    USkeletalMeshEditorSubsystem
    Subsystem for exposing skeletal mesh functionality to scripts
    
    **C++ Source:**
    
    - **Module**: SkeletalMeshEditor
    - **File**: SkeletalMeshEditorSubsystem.h
    
    """
    def set_section_visible_in_ray_tracing(self, skeletal_mesh: SkeletalMesh, lod_index: int, section_index: int, visible_in_ray_tracing: bool) -> bool:
        r"""
        x.set_section_visible_in_ray_tracing(skeletal_mesh, lod_index, section_index, visible_in_ray_tracing) -> bool
        Set bVisibleInRayTracing for a section of a LOD of a Skeletal Mesh.
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to get number of vertices from.
            lod_index (int32): Index of the mesh LOD.
            section_index (int32): Index of the LOD section.
            visible_in_ray_tracing (bool): The function will set the bVisibleInRayTracing used by the section
        
        Returns:
            bool: false if invalid mesh or LOD index or section index.
        """
        ...
    def set_section_recompute_tangents_vertex_mask_channel(self, skeletal_mesh: SkeletalMesh, lod_index: int, section_index: int, recompute_tangents_vertex_mask_channel: int) -> bool:
        r"""
        x.set_section_recompute_tangents_vertex_mask_channel(skeletal_mesh, lod_index, section_index, recompute_tangents_vertex_mask_channel) -> bool
        Set RecomputeTangentsVertexMaskChannel for a section of a LOD of a Skeletal Mesh.
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to get number of vertices from.
            lod_index (int32): Index of the mesh LOD.
            section_index (int32): Index of the LOD section.
            recompute_tangents_vertex_mask_channel (uint8): The function will set the RecomputeTangentsVertexMaskChannel used by the section
        
        Returns:
            bool: false if invalid mesh or LOD index or section index.
        """
        ...
    def set_section_recompute_tangent(self, skeletal_mesh: SkeletalMesh, lod_index: int, section_index: int, recompute_tangent: bool) -> bool:
        r"""
        x.set_section_recompute_tangent(skeletal_mesh, lod_index, section_index, recompute_tangent) -> bool
        Set bRecomputeTangent for a section of a LOD of a Skeletal Mesh.
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to get number of vertices from.
            lod_index (int32): Index of the mesh LOD.
            section_index (int32): Index of the LOD section.
            recompute_tangent (bool): The function will set the bRecomputeTangent used by the section
        
        Returns:
            bool: false if invalid mesh or LOD index or section index.
        """
        ...
    def set_section_cast_shadow(self, skeletal_mesh: SkeletalMesh, lod_index: int, section_index: int, cast_shadow: bool) -> bool:
        r"""
        x.set_section_cast_shadow(skeletal_mesh, lod_index, section_index, cast_shadow) -> bool
        Set bCastShadow for a section of a LOD of a Skeletal Mesh.
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to get number of vertices from.
            lod_index (int32): Index of the mesh LOD.
            section_index (int32): Index of the LOD section.
            cast_shadow (bool): The function will set the bCastShadow used by the section
        
        Returns:
            bool: false if invalid mesh or LOD index or section index.
        """
        ...
    @classmethod
    def set_lod_build_settings(cls, skeletal_mesh: SkeletalMesh, lod_index: int, build_options: SkeletalMeshBuildSettings) -> None:
        r"""
        X.set_lod_build_settings(skeletal_mesh, lod_index, build_options) -> None
        Set the LOD build options for the specified LOD index.
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to process.
            lod_index (int32): The LOD we will apply the build settings.
            build_options (SkeletalMeshBuildSettings): The build settings we want to apply to the LOD.
        """
        ...
    @classmethod
    def rename_socket(cls, skeletal_mesh: SkeletalMesh, old_name: Name, new_name: Name) -> bool:
        r"""
        X.rename_socket(skeletal_mesh, old_name, new_name) -> bool
        Rename a socket within a skeleton
        
        Args:
            skeletal_mesh (SkeletalMesh): The mesh inside which we are renaming a socket
            old_name (Name): The old name of the socket
            new_name (Name): The new name of the socket
        
        Returns:
            bool: true if the renaming succeeded.
        """
        ...
    @classmethod
    def reimport_all_custom_lo_ds(cls, skeletal_mesh: SkeletalMesh) -> bool:
        r"""
        X.reimport_all_custom_lo_ds(skeletal_mesh) -> bool
        Re-import the specified skeletal mesh and all the custom LODs.
        
        Args:
            skeletal_mesh (SkeletalMesh): 
        
        Returns:
            bool: true if re-import works, false otherwise see log for explanation.
        """
        ...
    @classmethod
    def regenerate_lod(cls, skeletal_mesh: SkeletalMesh, new_lod_count: int = 0, regenerate_even_if_imported: bool = False, generate_base_lod: bool = False) -> bool:
        r"""
        X.regenerate_lod(skeletal_mesh, new_lod_count=0, regenerate_even_if_imported=False, generate_base_lod=False) -> bool
        Regenerate LODs of the mesh
        
        Args:
            skeletal_mesh (SkeletalMesh): The mesh that will regenerate LOD
            new_lod_count (int32): Set valid value (>0) if you want to change LOD count. Otherwise, it will use the current LOD and regenerate
            regenerate_even_if_imported (bool): If this is true, it only regenerate even if this LOD was imported before If false, it will regenerate for only previously auto generated ones
            generate_base_lod (bool): If this is true and there is some reduction data, the base LOD will be reduce according to the settings
        
        Returns:
            bool: true if succeed. If mesh reduction is not available this will return false.
        """
        ...
    @classmethod
    def is_physics_asset_compatible(cls, target_mesh: SkeletalMesh, physics_asset: PhysicsAsset) -> bool:
        r"""
        X.is_physics_asset_compatible(target_mesh, physics_asset) -> bool
        Checks whether a physics asset is compatible with the given SkeletalMesh
        
        Args:
            target_mesh (SkeletalMesh): The mesh to test for compatibility
            physics_asset (PhysicsAsset): The PhysicsAsset to test for compatibility
        
        Returns:
            bool: Whether the physics asset is compatible with the target SkeletalMesh
        """
        ...
    @classmethod
    def import_lod(cls, base_mesh: SkeletalMesh, lod_index: int, source_filename: str) -> int:
        r"""
        X.import_lod(base_mesh, lod_index, source_filename) -> int32
        Import or re-import a LOD into the specified base mesh. If the LOD do not exist it will import it and add it to the base static mesh. If the LOD already exist it will re-import the specified LOD.
        
        Args:
            base_mesh (SkeletalMesh): 
            lod_index (int32): 
            source_filename (str): 
        
        Returns:
            int32: The index of the LOD that was imported or re-imported. Will return INDEX_NONE if anything goes bad.
        """
        ...
    def get_section_visible_in_ray_tracing(self, skeletal_mesh: SkeletalMesh, lod_index: int, section_index: int) -> Optional[bool]:
        r"""
        x.get_section_visible_in_ray_tracing(skeletal_mesh, lod_index, section_index) -> bool or None
        Get bVisibleInRayTracing from a section of a LOD of a Skeletal Mesh
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to get number of vertices from.
            lod_index (int32): Index of the mesh LOD.
            section_index (int32): Index of the LOD section.
        
        Returns:
            bool or None: false if invalid mesh or LOD index or section index.
        
            out_visible_in_ray_tracing (bool): The function will set the bVisibleInRayTracing used by the section
        """
        ...
    def get_section_recompute_tangents_vertex_mask_channel(self, skeletal_mesh: SkeletalMesh, lod_index: int, section_index: int) -> Optional[int]:
        r"""
        x.get_section_recompute_tangents_vertex_mask_channel(skeletal_mesh, lod_index, section_index) -> uint8 or None
        Get RecomputeTangentsVertexMaskChannel from a section of a LOD of a Skeletal Mesh
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to get number of vertices from.
            lod_index (int32): Index of the mesh LOD.
            section_index (int32): Index of the LOD section.
        
        Returns:
            uint8 or None: false if invalid mesh or LOD index or section index.
        
            out_recompute_tangents_vertex_mask_channel (uint8): The function will set the RecomputeTangentsVertexMaskChannel used by the section
        """
        ...
    def get_section_recompute_tangent(self, skeletal_mesh: SkeletalMesh, lod_index: int, section_index: int) -> Optional[bool]:
        r"""
        x.get_section_recompute_tangent(skeletal_mesh, lod_index, section_index) -> bool or None
        Get bRecomputeTangent from a section of a LOD of a Skeletal Mesh
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to get number of vertices from.
            lod_index (int32): Index of the mesh LOD.
            section_index (int32): Index of the LOD section.
        
        Returns:
            bool or None: false if invalid mesh or LOD index or section index.
        
            out_recompute_tangent (bool): The function will set the bRecomputeTangent used by the section
        """
        ...
    def get_section_cast_shadow(self, skeletal_mesh: SkeletalMesh, lod_index: int, section_index: int) -> Optional[bool]:
        r"""
        x.get_section_cast_shadow(skeletal_mesh, lod_index, section_index) -> bool or None
        Get bCastShadow from a section of a LOD of a Skeletal Mesh
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to get number of vertices from.
            lod_index (int32): Index of the mesh LOD.
            section_index (int32): Index of the LOD section.
        
        Returns:
            bool or None: false if invalid mesh or LOD index or section index.
        
            out_cast_shadow (bool): The function will set the bCastShadow used by the section
        """
        ...
    def get_num_verts(self, skeletal_mesh: SkeletalMesh, lod_index: int) -> int:
        r"""
        x.get_num_verts(skeletal_mesh, lod_index) -> int32
        Get number of mesh vertices for an LOD of a Skeletal Mesh
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to get number of vertices from.
            lod_index (int32): Index of the mesh LOD.
        
        Returns:
            int32: Number of vertices. Returns 0 if invalid mesh or LOD index.
        """
        ...
    def get_num_sections(self, skeletal_mesh: SkeletalMesh, lod_index: int) -> int:
        r"""
        x.get_num_sections(skeletal_mesh, lod_index) -> int32
        Get number of sections for a LOD of a Skeletal Mesh
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to get number of vertices from.
            lod_index (int32): Index of the mesh LOD.
        
        Returns:
            int32: Number of sections. Returns INDEX_NONE if invalid mesh or LOD index.
        """
        ...
    def get_lod_material_slot(self, skeletal_mesh: SkeletalMesh, lod_index: int, section_index: int) -> int:
        r"""
        x.get_lod_material_slot(skeletal_mesh, lod_index, section_index) -> int32
        Gets the material slot used for a specific LOD section.
        
        Args:
            skeletal_mesh (SkeletalMesh): SkeletalMesh to get the material index from.
            lod_index (int32): Index of the StaticMesh LOD.
            section_index (int32): Index of the StaticMesh Section.
        
        Returns:
            int32: MaterialSlotIndex   Index of the material slot used by the section or INDEX_NONE in case of error.
        """
        ...
    @classmethod
    def get_lod_count(cls, skeletal_mesh: SkeletalMesh) -> int:
        r"""
        X.get_lod_count(skeletal_mesh) -> int32
        Retrieve the number of LOD contain in the specified skeletal mesh.
        
        Args:
            skeletal_mesh (SkeletalMesh): 
        
        Returns:
            int32: The LOD number.
        """
        ...
    @classmethod
    def get_lod_build_settings(cls, skeletal_mesh: SkeletalMesh, lod_index: int) -> SkeletalMeshBuildSettings:
        r"""
        X.get_lod_build_settings(skeletal_mesh, lod_index) -> SkeletalMeshBuildSettings
        Copy the build options with the specified LOD build settings.
        
        Args:
            skeletal_mesh (SkeletalMesh): Mesh to process.
            lod_index (int32): The LOD we get the reduction settings.
        
        Returns:
            SkeletalMeshBuildSettings: 
        
            out_build_options (SkeletalMeshBuildSettings): The build settings where we copy the build options.
        """
        ...
    @classmethod
    def create_physics_asset(cls, skeletal_mesh: SkeletalMesh) -> PhysicsAsset:
        r"""
        X.create_physics_asset(skeletal_mesh) -> PhysicsAsset
        This function creates a PhysicsAsset for the given SkeletalMesh with the same settings as if it were created through FBX import
        
        Args:
            skeletal_mesh (SkeletalMesh): 
        
        Returns:
            PhysicsAsset:
        """
        ...
    @classmethod
    def assign_physics_asset(cls, target_mesh: SkeletalMesh, physics_asset: PhysicsAsset) -> bool:
        r"""
        X.assign_physics_asset(target_mesh, physics_asset) -> bool
        Assigns a PhysicsAsset to the given SkeletalMesh if it is compatible. Passing
        nullptr / None as the physics asset will always succeed and will clear the
        physics asset assignment for the target SkeletalMesh
        
        Args:
            target_mesh (SkeletalMesh): The mesh to attempt to assign the PhysicsAsset to
            physics_asset (PhysicsAsset): The physics asset to assign to the provided mesh (or nullptr/None)
        
        Returns:
            bool: Whether the physics asset was successfully assigned to the mesh
        """
        ...

class ResonanceAudioReverbPluginPresetFactory(Factory):
    r"""
    Resonance Audio Reverb Plugin Preset Factory
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudioEditor
    - **File**: ResonanceAudioReverbPluginPresetFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ResonanceAudioSpatializationSourceSettingsFactory(Factory):
    r"""
    Resonance Audio Spatialization Source Settings Factory
    
    **C++ Source:**
    
    - **Plugin**: ResonanceAudio
    - **Module**: ResonanceAudioEditor
    - **File**: ResonanceAudioSpatializationSourceSettingsFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class RigVMEditorMenuContext(Object):
    r"""
    Rig VMEditor Menu Context
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMEditor
    - **File**: RigVMEditorMenuContext.h
    
    """
    def is_alt_down(self) -> bool:
        r"""
        x.is_alt_down() -> bool
        Returns true if either alt key is down
        
        Returns:
            bool:
        """
        ...
    def get_rig_vm_host(self) -> RigVMHost:
        r"""
        x.get_rig_vm_host() -> RigVMHost
        Get the active rigvm host instance in the viewport
        
        Returns:
            RigVMHost:
        """
        ...
    def get_rig_vm_blueprint(self) -> RigVMBlueprint:
        r"""
        x.get_rig_vm_blueprint() -> RigVMBlueprint
        Get the rigvm blueprint that we are editing
        
        Returns:
            RigVMBlueprint:
        """
        ...
    def get_graph_menu_context(self) -> RigVMEditorGraphMenuContext:
        r"""
        x.get_graph_menu_context() -> RigVMEditorGraphMenuContext
        Returns context for graph node context menu
        
        Returns:
            RigVMEditorGraphMenuContext:
        """
        ...

class RigVMBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Rig VMEditor Blueprint Library
    
    **C++ Source:**
    
    - **Plugin**: RigVM
    - **Module**: RigVMEditor
    - **File**: RigVMEditorBlueprintLibrary.h
    
    """
    @classmethod
    def request_auto_vm_recompilation(cls, blueprint: RigVMBlueprint) -> None:
        r"""
        X.request_auto_vm_recompilation(blueprint) -> None
        Request Auto VMRecompilation
        
        Args:
            blueprint (RigVMBlueprint):
        """
        ...
    @classmethod
    def recompile_vm_if_required(cls, blueprint: RigVMBlueprint) -> None:
        r"""
        X.recompile_vm_if_required(blueprint) -> None
        Recompile VMIf Required
        
        Args:
            blueprint (RigVMBlueprint):
        """
        ...
    @classmethod
    def recompile_vm(cls, blueprint: RigVMBlueprint) -> None:
        r"""
        X.recompile_vm(blueprint) -> None
        Recompile VM
        
        Args:
            blueprint (RigVMBlueprint):
        """
        ...
    @classmethod
    def load_assets_with_node_filter(cls, class_: Class, node_filter: RigVMNodeFilterDynamic) -> Array[RigVMBlueprint]:
        r"""
        X.load_assets_with_node_filter(class_, node_filter) -> Array[RigVMBlueprint]
        Load Assets with Node Filter for Blueprint
        
        Args:
            class_ (type(Class)): 
            node_filter (RigVMNodeFilterDynamic): 
        
        Returns:
            Array[RigVMBlueprint]:
        """
        ...
    @classmethod
    def load_assets_with_blueprint_filter(cls, class_: Class, blueprint_filter: RigVMBlueprintFilterDynamic) -> Array[RigVMBlueprint]:
        r"""
        X.load_assets_with_blueprint_filter(class_, blueprint_filter) -> Array[RigVMBlueprint]
        Load Assets with Blueprint Filter for Blueprint
        
        Args:
            class_ (type(Class)): 
            blueprint_filter (RigVMBlueprintFilterDynamic): 
        
        Returns:
            Array[RigVMBlueprint]:
        """
        ...
    @classmethod
    def load_assets_with_asset_data_filter(cls, class_: Class, asset_data_filter: RigVMAssetDataFilterDynamic) -> Array[RigVMBlueprint]:
        r"""
        X.load_assets_with_asset_data_filter(class_, asset_data_filter) -> Array[RigVMBlueprint]
        Load Assets with Asset Data Filter for Blueprint
        
        Args:
            class_ (type(Class)): 
            asset_data_filter (RigVMAssetDataFilterDynamic): 
        
        Returns:
            Array[RigVMBlueprint]:
        """
        ...
    @classmethod
    def load_assets_with_asset_data_and_node_filters(cls, class_: Class, asset_data_filter: RigVMAssetDataFilterDynamic, node_filter: RigVMNodeFilterDynamic) -> Array[RigVMBlueprint]:
        r"""
        X.load_assets_with_asset_data_and_node_filters(class_, asset_data_filter, node_filter) -> Array[RigVMBlueprint]
        Load Assets with Asset Data and Node Filters for Blueprint
        
        Args:
            class_ (type(Class)): 
            asset_data_filter (RigVMAssetDataFilterDynamic): 
            node_filter (RigVMNodeFilterDynamic): 
        
        Returns:
            Array[RigVMBlueprint]:
        """
        ...
    @classmethod
    def load_assets_with_asset_data_and_blueprint_filters(cls, class_: Class, asset_data_filter: RigVMAssetDataFilterDynamic, blueprint_filter: RigVMBlueprintFilterDynamic) -> Array[RigVMBlueprint]:
        r"""
        X.load_assets_with_asset_data_and_blueprint_filters(class_, asset_data_filter, blueprint_filter) -> Array[RigVMBlueprint]
        Load Assets with Asset Data and Blueprint Filters for Blueprint
        
        Args:
            class_ (type(Class)): 
            asset_data_filter (RigVMAssetDataFilterDynamic): 
            blueprint_filter (RigVMBlueprintFilterDynamic): 
        
        Returns:
            Array[RigVMBlueprint]:
        """
        ...
    @classmethod
    def load_assets_by_class(cls, class_: Class) -> Array[RigVMBlueprint]:
        r"""
        X.load_assets_by_class(class_) -> Array[RigVMBlueprint]
        Load Assets by Class
        
        Args:
            class_ (type(Class)): 
        
        Returns:
            Array[RigVMBlueprint]:
        """
        ...
    @classmethod
    def load_assets(cls) -> Array[RigVMBlueprint]:
        r"""
        X.load_assets() -> Array[RigVMBlueprint]
        Load Assets
        
        Returns:
            Array[RigVMBlueprint]:
        """
        ...
    @classmethod
    def get_model(cls, blueprint: RigVMBlueprint) -> RigVMGraph:
        r"""
        X.get_model(blueprint) -> RigVMGraph
        Get Model
        
        Args:
            blueprint (RigVMBlueprint): 
        
        Returns:
            RigVMGraph:
        """
        ...
    @classmethod
    def get_controller(cls, blueprint: RigVMBlueprint) -> RigVMController:
        r"""
        X.get_controller(blueprint) -> RigVMController
        Get Controller
        
        Args:
            blueprint (RigVMBlueprint): 
        
        Returns:
            RigVMController:
        """
        ...
    @classmethod
    def get_assets_with_filter(cls, class_: Class, asset_data_filter: RigVMAssetDataFilterDynamic) -> Array[AssetData]:
        r"""
        X.get_assets_with_filter(class_, asset_data_filter) -> Array[AssetData]
        Get Assets with Filter for Blueprint
        
        Args:
            class_ (type(Class)): 
            asset_data_filter (RigVMAssetDataFilterDynamic): 
        
        Returns:
            Array[AssetData]:
        """
        ...

class WaveTableBankFactory(Factory):
    r"""
    Wave Table Bank Factory
    
    **C++ Source:**
    
    - **Plugin**: WaveTable
    - **Module**: WaveTableEditor
    - **File**: WaveTableBankFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MediaPlayerEditorMediaContext(ToolMenuContextBase):
    r"""
    Media Player Editor Media Context
    
    **C++ Source:**
    
    - **Plugin**: MediaPlayerEditor
    - **Module**: MediaPlayerEditor
    - **File**: MediaPlayerEditorMediaContext.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``selected_asset`` (Object):  [Read-Write]
    - ``style_set_name`` (Name):  [Read-Write]
    """
    @property
    def selected_asset(self) -> Object:
        r"""
        (Object):  [Read-Write]
        """
        ...
    @selected_asset.setter
    def selected_asset(self, value: Object) -> None:
        ...
    @property
    def style_set_name(self) -> Name:
        r"""
        (Name):  [Read-Write]
        """
        ...
    @style_set_name.setter
    def style_set_name(self, value: Name) -> None:
        ...

class FileMediaSourceFactoryNew(Factory):
    r"""
    Implements a factory for UFileMediaSource objects.
    
    **C++ Source:**
    
    - **Plugin**: MediaPlayerEditor
    - **Module**: MediaPlayerEditor
    - **File**: FileMediaSourceFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MediaPlayerFactoryNew(Factory):
    r"""
    Implements a factory for UMediaPlayer objects.
    
    **C++ Source:**
    
    - **Plugin**: MediaPlayerEditor
    - **Module**: MediaPlayerEditor
    - **File**: MediaPlayerFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MediaPlaylistFactoryNew(Factory):
    r"""
    Implements a factory for UMediaPlaylist objects.
    
    **C++ Source:**
    
    - **Plugin**: MediaPlayerEditor
    - **Module**: MediaPlayerEditor
    - **File**: MediaPlaylistFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class MediaTextureFactoryNew(Factory):
    r"""
    Implements a factory for UMediaTexture objects.
    
    **C++ Source:**
    
    - **Plugin**: MediaPlayerEditor
    - **Module**: MediaPlayerEditor
    - **File**: MediaTextureFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class PlatformMediaSourceFactoryNew(Factory):
    r"""
    Implements a factory for UPlatformMediaSource objects.
    
    **C++ Source:**
    
    - **Plugin**: MediaPlayerEditor
    - **Module**: MediaPlayerEditor
    - **File**: PlatformMediaSourceFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class StreamMediaSourceFactoryNew(Factory):
    r"""
    Implements a factory for UStreamMediaSource objects.
    
    **C++ Source:**
    
    - **Plugin**: MediaPlayerEditor
    - **Module**: MediaPlayerEditor
    - **File**: StreamMediaSourceFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AndroidFileMediaSourceFactory(Factory):
    r"""
    Implements a factory for UFileMediaSource objects.
    
    **C++ Source:**
    
    - **Plugin**: AndroidMedia
    - **Module**: AndroidMediaEditor
    - **File**: AndroidFileMediaSourceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class WmfFileMediaSourceFactory(Factory):
    r"""
    Implements a factory for UFileMediaSource objects.
    
    **C++ Source:**
    
    - **Plugin**: WmfMedia
    - **Module**: WmfMediaEditor
    - **File**: WmfFileMediaSourceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class WebMPlatFileMediaSourceFactory(Factory):
    r"""
    Implements a factory for UFileMediaSource objects.
    
    **C++ Source:**
    
    - **Plugin**: WebMMedia
    - **Module**: WebMMediaEditor
    - **File**: WebMFileMediaSourceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AvfFileMediaSourceFactory(Factory):
    r"""
    Implements a factory for UFileMediaSource objects.
    
    **C++ Source:**
    
    - **Plugin**: AvfMedia
    - **Module**: AvfMediaEditor
    - **File**: AvfFileMediaSourceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ImgMediaSourceFactory(Factory):
    r"""
    Implements a factory for UImgMediaSource objects.
    
    **C++ Source:**
    
    - **Plugin**: ImgMedia
    - **Module**: ImgMediaEditor
    - **File**: ImgMediaSourceFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ImgMediaSourceFactoryNew(Factory):
    r"""
    Implements a factory for UImgMediaSource objects.
    
    **C++ Source:**
    
    - **Plugin**: ImgMedia
    - **Module**: ImgMediaEditor
    - **File**: ImgMediaSourceFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class CameraAnimationSequenceFactoryNew(Factory):
    r"""
    Implements a factory for UCameraAnimationSequence objects.
    
    **C++ Source:**
    
    - **Plugin**: TemplateSequence
    - **Module**: TemplateSequenceEditor
    - **File**: CameraAnimationSequenceFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class TemplateSequenceFactoryNew(Factory):
    r"""
    Implements a factory for UTemplateSequence objects.
    
    **C++ Source:**
    
    - **Plugin**: TemplateSequence
    - **Module**: TemplateSequenceEditor
    - **File**: TemplateSequenceFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``bound_actor_class`` (type(Class)):  [Read-Write] The root object binding class of the created template sequence.
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class AnimSequenceConverterFactory(AnimSequenceFactory):
    r"""
    Anim Sequence Converter Factory
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimSequenceConverterFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``preview_skeletal_mesh`` (SkeletalMesh):  [Read-Write] The preview mesh to use with this animation
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``target_skeleton`` (Skeleton):  [Read-Write]
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class BakeToControlRigSettings(Object):
    r"""
    Bake to Control Rig Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: BakeToControlRigSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``reduce_keys`` (bool):  [Read-Write] Reduce Keys
    - ``reset_controls`` (bool):  [Read-Write] Reset controls to initial value on every frame
    - ``tolerance`` (float):  [Read-Write] Reduce Keys Tolerance
    """
    ...

class ControlRigBlueprintLibrary(RigVMBlueprintLibrary):
    r"""
    Control Rig Blueprint Editor Library
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigBlueprintEditorLibrary.h
    
    """
    @classmethod
    def setup_all_editor_menus(cls) -> None:
        r"""
        X.setup_all_editor_menus() -> None
        Setup All Editor Menus
        """
        ...
    @classmethod
    def set_preview_mesh(cls, rig_blueprint: ControlRigBlueprint, preview_mesh: SkeletalMesh, mark_as_dirty: bool = True) -> None:
        r"""
        X.set_preview_mesh(rig_blueprint, preview_mesh, mark_as_dirty=True) -> None
        Set Preview Mesh
        
        Args:
            rig_blueprint (ControlRigBlueprint): 
            preview_mesh (SkeletalMesh): 
            mark_as_dirty (bool):
        """
        ...
    @classmethod
    def request_control_rig_init(cls, rig_blueprint: ControlRigBlueprint) -> None:
        r"""
        X.request_control_rig_init(rig_blueprint) -> None
        Request Control Rig Init
        
        Args:
            rig_blueprint (ControlRigBlueprint):
        """
        ...
    @classmethod
    def get_preview_mesh(cls, rig_blueprint: ControlRigBlueprint) -> SkeletalMesh:
        r"""
        X.get_preview_mesh(rig_blueprint) -> SkeletalMesh
        Get Preview Mesh
        
        Args:
            rig_blueprint (ControlRigBlueprint): 
        
        Returns:
            SkeletalMesh:
        """
        ...
    @classmethod
    def get_hierarchy_controller(cls, rig_blueprint: ControlRigBlueprint) -> RigHierarchyController:
        r"""
        X.get_hierarchy_controller(rig_blueprint) -> RigHierarchyController
        Get Hierarchy Controller
        
        Args:
            rig_blueprint (ControlRigBlueprint): 
        
        Returns:
            RigHierarchyController:
        """
        ...
    @classmethod
    def get_hierarchy(cls, rig_blueprint: ControlRigBlueprint) -> RigHierarchy:
        r"""
        X.get_hierarchy(rig_blueprint) -> RigHierarchy
        Get Hierarchy
        
        Args:
            rig_blueprint (ControlRigBlueprint): 
        
        Returns:
            RigHierarchy:
        """
        ...
    @classmethod
    def get_currently_open_rig_blueprints(cls) -> Array[ControlRigBlueprint]:
        r"""
        X.get_currently_open_rig_blueprints() -> Array[ControlRigBlueprint]
        Get Currently Open Rig Blueprints
        
        Returns:
            Array[ControlRigBlueprint]:
        """
        ...
    @classmethod
    def get_available_rig_units(cls) -> Array[Struct]:
        r"""
        X.get_available_rig_units() -> Array[Struct]
        Get Available Rig Units
        
        Returns:
            Array[Struct]:
        """
        ...
    @classmethod
    def get_available_rig_modules(cls) -> Array[RigModuleDescription]:
        r"""
        X.get_available_rig_modules() -> Array[RigModuleDescription]
        Get Available Rig Modules
        
        Returns:
            Array[RigModuleDescription]:
        """
        ...
    @classmethod
    def cast_to_control_rig_blueprint(cls, object: Object) -> Tuple[CastToControlRigBlueprintCases, ControlRigBlueprint]:
        r"""
        X.cast_to_control_rig_blueprint(object) -> (branches=CastToControlRigBlueprintCases, as_control_rig_blueprint=ControlRigBlueprint)
        Cast to Control Rig Blueprint
        
        Args:
            object (Object): 
        
        Returns:
            tuple: 
        
            branches (CastToControlRigBlueprintCases): 
        
            as_control_rig_blueprint (ControlRigBlueprint):
        """
        ...

class ControlRigBlueprintFactory(Factory):
    r"""
    Control Rig Blueprint Factory
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigBlueprintFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``parent_class`` (type(Class)):  [Read-Write] The parent class of the created blueprint
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    @classmethod
    def create_new_control_rig_asset(cls, desired_package_path: str, modular_rig: bool = False) -> ControlRigBlueprint:
        r"""
        X.create_new_control_rig_asset(desired_package_path, modular_rig=False) -> ControlRigBlueprint
        Create a new control rig asset within the contents space of the project.
        
        Args:
            desired_package_path (str): The package path to use for the control rig asset
            modular_rig (bool): If true the rig will be created as a modular rig
        
        Returns:
            ControlRigBlueprint:
        """
        ...
    @classmethod
    def create_control_rig_from_skeletal_mesh_or_skeleton(cls, selected_object: Object, modular_rig: bool = False) -> ControlRigBlueprint:
        r"""
        X.create_control_rig_from_skeletal_mesh_or_skeleton(selected_object, modular_rig=False) -> ControlRigBlueprint
        Create a new control rig asset within the contents space of the project
        based on a skeletal mesh or skeleton object.
        
        Args:
            selected_object (Object): The SkeletalMesh / Skeleton object to base the control rig asset on
            modular_rig (bool): If true the rig will be created as a modular rig
        
        Returns:
            ControlRigBlueprint:
        """
        ...

class ControlRigShapeLibraryFactory(Factory):
    r"""
    Control Rig Shape Library Factory
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigGizmoLibraryFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class ControlRigSequencerLibrary(BlueprintFunctionLibrary):
    r"""
    This is a set of helper functions to access various parts of the Sequencer and Control Rig API via Python and Blueprints.
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigSequencerEditorLibrary.h
    
    """
    @classmethod
    def tween_control_rig(cls, level_sequence: LevelSequence, control_rig: ControlRig, tween_value: float) -> bool:
        r"""
        X.tween_control_rig(level_sequence, control_rig, tween_value) -> bool
        Peform a Tween operation on the current active sequencer time(must be visible).
        
        Args:
            level_sequence (LevelSequence): The LevelSequence that's loaded in the editor
            control_rig (ControlRig): The Control Rig to tween.
            tween_value (float): The tween value to use, range from -1(blend to previous) to 1(blend to next)
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def snap_control_rig(cls, level_sequence: LevelSequence, start_frame: FrameNumber, end_frame: FrameNumber, children_to_snap: ControlRigSnapperSelection, parent_to_snap: ControlRigSnapperSelection, snap_settings: ControlRigSnapSettings, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> bool:
        r"""
        X.snap_control_rig(level_sequence, start_frame, end_frame, children_to_snap, parent_to_snap, snap_settings, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> bool
        Peform a Snap operation to snap the children to the parent.
        
        Args:
            level_sequence (LevelSequence): Active Sequence to snap
            start_frame (FrameNumber): Beginning of the snap
            end_frame (FrameNumber): End of the snap
            children_to_snap (ControlRigSnapperSelection): The children objects that snap and get keys set onto. They need to live in an active Sequencer in the level editor
            parent_to_snap (ControlRigSnapperSelection): The parent object to snap relative to. If animated, it needs to live in an active Sequencer in the level editor
            snap_settings (ControlRigSnapSettings): Settings to use
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def show_all_controls(cls, section: MovieSceneSection) -> None:
        r"""
        X.show_all_controls(section) -> None
        Shows all of the controls for the given section
        
        Args:
            section (MovieSceneSection):
        """
        ...
    @classmethod
    def set_local_control_rig_vector2_ds(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], values: Array[Vector2D], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_local_control_rig_vector2_ds(level_sequence, control_rig, control_name, frames, values, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set ControlRig Control's Vector2D values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Vector2D control
            frames (Array[FrameNumber]): Times to set the values
            values (Array[Vector2D]): The values to set at those times
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        """
        ...
    @classmethod
    def set_local_control_rig_vector2d(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, value: Vector2D, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, set_key: bool = True) -> None:
        r"""
        X.set_local_control_rig_vector2d(level_sequence, control_rig, control_name, frame, value, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, set_key=True) -> None
        Set ControlRig Control's Vector2D value at specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Vector2D control
            frame (FrameNumber): Time to set the value
            value (Vector2D): The value to set
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            set_key (bool): If True set a key, if not just set the value
        """
        ...
    @classmethod
    def set_local_control_rig_transforms(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], values: Array[Transform], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_local_control_rig_transforms(level_sequence, control_rig, control_name, frames, values, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set ControlRig Control's Transform values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Transform control
            frames (Array[FrameNumber]): Times to set the values
            values (Array[Transform]): The values to set at those times
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        """
        ...
    @classmethod
    def set_local_control_rig_transform_no_scales(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], values: Array[TransformNoScale], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_local_control_rig_transform_no_scales(level_sequence, control_rig, control_name, frames, values, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set ControlRig Control's TransformNoScale values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a TransformNoScale control
            frames (Array[FrameNumber]): Times to set the values
            values (Array[TransformNoScale]): The values to set at those times
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        """
        ...
    @classmethod
    def set_local_control_rig_transform_no_scale(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, value: TransformNoScale, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, set_key: bool = True) -> None:
        r"""
        X.set_local_control_rig_transform_no_scale(level_sequence, control_rig, control_name, frame, value, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, set_key=True) -> None
        Set ControlRig Control's TransformNoScale value at specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a TransformNoScale control
            frame (FrameNumber): Time to set the value
            value (TransformNoScale): The value to set
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            set_key (bool): If True set a key, if not just set the value
        """
        ...
    @classmethod
    def set_local_control_rig_transform(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, value: Transform, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, set_key: bool = True) -> None:
        r"""
        X.set_local_control_rig_transform(level_sequence, control_rig, control_name, frame, value, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, set_key=True) -> None
        Set ControlRig Control's Transform value at specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Transform control
            frame (FrameNumber): Time to set the value
            value (Transform): The value to set
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            set_key (bool): If True set a key, if not just set the value
        """
        ...
    @classmethod
    def set_local_control_rig_scales(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], values: Array[Vector], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_local_control_rig_scales(level_sequence, control_rig, control_name, frames, values, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set ControlRig Control's Scale values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Scale control
            frames (Array[FrameNumber]): Times to set the values
            values (Array[Vector]): The values to set at those times
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        """
        ...
    @classmethod
    def set_local_control_rig_scale(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, value: Vector, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, set_key: bool = True) -> None:
        r"""
        X.set_local_control_rig_scale(level_sequence, control_rig, control_name, frame, value, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, set_key=True) -> None
        Set ControlRig Control's Scale value at specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Scale control
            frame (FrameNumber): Time to set the value
            value (Vector): The value to set
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            set_key (bool): If True set a key, if not just set the value
        """
        ...
    @classmethod
    def set_local_control_rig_rotators(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], values: Array[Rotator], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_local_control_rig_rotators(level_sequence, control_rig, control_name, frames, values, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set ControlRig Control's Rotator values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Rotator control
            frames (Array[FrameNumber]): Times to set the values
            values (Array[Rotator]): The values to set at those times
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        """
        ...
    @classmethod
    def set_local_control_rig_rotator(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, value: Rotator, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, set_key: bool = True) -> None:
        r"""
        X.set_local_control_rig_rotator(level_sequence, control_rig, control_name, frame, value, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, set_key=True) -> None
        Set ControlRig Control's Rotator value at specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Rotator control
            frame (FrameNumber): Time to set the value
            value (Rotator): The value to set
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            set_key (bool): If True set a key, if not just set the value
        """
        ...
    @classmethod
    def set_local_control_rig_positions(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], values: Array[Vector], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_local_control_rig_positions(level_sequence, control_rig, control_name, frames, values, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set ControlRig Control's Position values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Position control
            frames (Array[FrameNumber]): Times to set the values
            values (Array[Vector]): The values to set at those times
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        """
        ...
    @classmethod
    def set_local_control_rig_position(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, value: Vector, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, set_key: bool = True) -> None:
        r"""
        X.set_local_control_rig_position(level_sequence, control_rig, control_name, frame, value, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, set_key=True) -> None
        Set ControlRig Control's Position value at specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Position control
            frame (FrameNumber): Time to set the value
            value (Vector): The value to set
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            set_key (bool): If True set a key, if not just set the value
        """
        ...
    @classmethod
    def set_local_control_rig_ints(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], values: Array[int], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_local_control_rig_ints(level_sequence, control_rig, control_name, frames, values, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set ControlRig Control's int values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a int control
            frames (Array[FrameNumber]): Times to set the values
            values (Array[int32]): The values to set at those times
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        """
        ...
    @classmethod
    def set_local_control_rig_int(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, value: int, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, set_key: bool = True) -> None:
        r"""
        X.set_local_control_rig_int(level_sequence, control_rig, control_name, frame, value, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, set_key=True) -> None
        Set ControlRig Control's int value at specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a int control
            frame (FrameNumber): Time to set the value
            value (int32): The value to set
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            set_key (bool): If True set a key, if not just set the value
        """
        ...
    @classmethod
    def set_local_control_rig_floats(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], values: Array[float], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_local_control_rig_floats(level_sequence, control_rig, control_name, frames, values, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set ControlRig Control's float values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a float control
            frames (Array[FrameNumber]): Times to set the values
            values (Array[float]): The values to set at those times
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        """
        ...
    @classmethod
    def set_local_control_rig_float(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, value: float, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, set_key: bool = True) -> None:
        r"""
        X.set_local_control_rig_float(level_sequence, control_rig, control_name, frame, value, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, set_key=True) -> None
        Set ControlRig Control's float value at specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a float control
            frame (FrameNumber): Time to set the value
            value (float): The value to set
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            set_key (bool): If True set a key, if not just set the value
        """
        ...
    @classmethod
    def set_local_control_rig_euler_transforms(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], values: Array[EulerTransform], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_local_control_rig_euler_transforms(level_sequence, control_rig, control_name, frames, values, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set ControlRig Control's EulerTransform values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a EulerTransform control
            frames (Array[FrameNumber]): Times to set the values
            values (Array[EulerTransform]): The values to set at those times
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        """
        ...
    @classmethod
    def set_local_control_rig_euler_transform(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, value: EulerTransform, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, set_key: bool = True) -> None:
        r"""
        X.set_local_control_rig_euler_transform(level_sequence, control_rig, control_name, frame, value, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, set_key=True) -> None
        Set ControlRig Control's EulerTransform value at specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a EulerTransform control
            frame (FrameNumber): Time to set the value
            value (EulerTransform): The value to set
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            set_key (bool): If True set a key, if not just set the value
        """
        ...
    @classmethod
    def set_local_control_rig_bools(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], values: Array[bool], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_local_control_rig_bools(level_sequence, control_rig, control_name, frames, values, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set ControlRig Control's bool values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a bool control
            frames (Array[FrameNumber]): Times to set the values
            values (Array[bool]): The values to set at those times
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        """
        ...
    @classmethod
    def set_local_control_rig_bool(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, value: bool, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, set_key: bool = True) -> None:
        r"""
        X.set_local_control_rig_bool(level_sequence, control_rig, control_name, frame, value, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, set_key=True) -> None
        Set ControlRig Control's bool value at specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set value on
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a bool control
            frame (FrameNumber): Time to set the value
            value (bool): The value to set
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            set_key (bool): If True set a key, if not just set the value
        """
        ...
    @classmethod
    def set_controls_mask(cls, section: MovieSceneSection, control_names: Array[Name], visible: bool) -> None:
        r"""
        X.set_controls_mask(section, control_names, visible) -> None
        Set the controls mask for the given ControlNames
        
        Args:
            section (MovieSceneSection): 
            control_names (Array[Name]): 
            visible (bool):
        """
        ...
    @classmethod
    def set_control_rig_world_transforms(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], world_transforms: Array[Transform], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_control_rig_world_transforms(level_sequence, control_rig, control_name, frames, world_transforms, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set ControlRig Control's World Transforms at a specific times.
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set transforms for. Must be loaded in Level Editor.
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control
            frames (Array[FrameNumber]): Times to set the transform
            world_transforms (Array[Transform]): 
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        """
        ...
    @classmethod
    def set_control_rig_world_transform(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, world_transform: Transform, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, set_key: bool = True) -> None:
        r"""
        X.set_control_rig_world_transform(level_sequence, control_rig, control_name, frame, world_transform, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, set_key=True) -> None
        Set ControlRig Control's World Transform at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to set transforms for. Must be loaded in Level Editor.
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control
            frame (FrameNumber): Time to set the transform
            world_transform (Transform): World Transform to set
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            set_key (bool): Whether or not to set a key.
        """
        ...
    @classmethod
    def set_control_rig_space(cls, sequence: LevelSequence, control_rig: ControlRig, control_name: Name, space_key: RigElementKey, time: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> bool:
        r"""
        X.set_control_rig_space(sequence, control_rig, control_name, space_key, time, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> bool
        * Set the a key for the Control Rig Space for the Control at the specified time. If space is the same as the current no key witll be set.
        *
        *
        
        Args:
            sequence (LevelSequence): Sequence to set the space *
            control_rig (ControlRig): ControlRig with the Control *
            control_name (Name): The name of the Control *
            space_key (RigElementKey): The new space for the Control *
            time (FrameNumber): Time to change the space. *
            time_unit (MovieSceneTimeUnit): Unit for the InTime, either in display rate or tick resolution
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_control_rig_priority_order(cls, section: MovieSceneTrack, priority_order: int) -> None:
        r"""
        X.set_control_rig_priority_order(section, priority_order) -> None
        Set Control Rig priority order
        
        Args:
            section (MovieSceneTrack): 
            priority_order (int32):
        """
        ...
    @classmethod
    def set_control_rig_layered_mode(cls, track: MovieSceneControlRigParameterTrack, set_is_layered: bool) -> bool:
        r"""
        X.set_control_rig_layered_mode(track, set_is_layered) -> bool
        * Convert the control rig track into absolute or layered rig
        *
        *
        
        Args:
            track (MovieSceneControlRigParameterTrack): Control rig track to convert *
            set_is_layered (bool): Convert to layered rig if true, or absolute if false
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def set_control_rig_apply_mode(cls, control_rig: ControlRig, apply_mode: ControlRigFKRigExecuteMode) -> bool:
        r"""
        X.set_control_rig_apply_mode(control_rig, apply_mode) -> bool
        Set the FK Control Rig to apply mode
        
        Args:
            control_rig (ControlRig): Rig to set
            apply_mode (ControlRigFKRigExecuteMode): Set the EControlRigFKRigExecuteMode mode (Replace,Addtiive or Direct)
        
        Returns:
            bool: returns True if the mode was set, may not be set if the Control Rig doesn't support these modes currently only FKControlRig's do.
        """
        ...
    @classmethod
    def set_constraint_active_key(cls, constraint: TickableConstraint, active: bool, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> bool:
        r"""
        X.set_constraint_active_key(constraint, active, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> bool
        Set the constraint active key in the current open Sequencer
        
        Args:
            constraint (TickableConstraint): The constraint to set the key
            active (bool): Whether or not it's active
            frame (FrameNumber): 
            time_unit (MovieSceneTimeUnit): Unit for the time params, either in display rate or tick resolution
        
        Returns:
            bool: Returns true if we set the constraint to be the passed in value, false if not. We may not do so if the value is the same.
        """
        ...
    @classmethod
    def rename_control_rig_control_channels(cls, sequence: LevelSequence, control_rig: ControlRig, old_control_names: Array[Name], new_control_names: Array[Name]) -> bool:
        r"""
        X.rename_control_rig_control_channels(sequence, control_rig, old_control_names, new_control_names) -> bool
        Rename the Control Rig Channels in Sequencer to the specified new control names, which should be present on the Control Rig
        
        Args:
            sequence (LevelSequence): Sequence to rename controls
            control_rig (ControlRig): ControlRig to rename controls
            old_control_names (Array[Name]): The name of the old Control Rig Control Channels to change. Will be replaced by the corresponding name in the InNewControlNames array
            new_control_names (Array[Name]): The name of the new Control Rig Channels
        
        Returns:
            bool: Return true if the function succeeds, false if it doesn't which can happen if the name arrays don't match in size or any of the new Control Names aren't valid
        """
        ...
    @classmethod
    def move_control_rig_space(cls, sequence: LevelSequence, control_rig: ControlRig, control_name: Name, time: FrameNumber, new_time: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> bool:
        r"""
        X.move_control_rig_space(sequence, control_rig, control_name, time, new_time, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> bool
        Move the Control Rig Space Key for the Control at the specified time to the new time. This will also move any Control Rig keys at this space switch boundary.
        
        Args:
            sequence (LevelSequence): Sequence to set the space
            control_rig (ControlRig): ControlRig with the Control
            control_name (Name): The name of the Control
            time (FrameNumber): Original time of the space key
            new_time (FrameNumber): New time for the space key
            time_unit (MovieSceneTimeUnit): Unit for the time params, either in display rate or tick resolution
        
        Returns:
            bool: Will return false if function fails, for example if there is no key at this time it will fail, or if the new time is invalid it could fail also
        """
        ...
    @classmethod
    def move_constraint_key(cls, constraint: TickableConstraint, constraint_section: MovieSceneSection, time: FrameNumber, new_time: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> bool:
        r"""
        X.move_constraint_key(constraint, constraint_section, time, new_time, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> bool
        Move the constraint active key in the current open Sequencer
        
        Args:
            constraint (TickableConstraint): 
            constraint_section (MovieSceneSection): Section containing Cosntraint Key
            time (FrameNumber): Original time of the constraint key
            new_time (FrameNumber): New time for the constraint key
            time_unit (MovieSceneTimeUnit): Unit for the time params, either in display rate or tick resolution
        
        Returns:
            bool: Will return false if function fails, for example if there is no key at this time it will fail, or if the new time is invalid it could fail also
        """
        ...
    @classmethod
    def load_anim_sequence_into_control_rig_section(cls, movie_scene_section: MovieSceneSection, anim_sequence: AnimSequence, skel_mesh_comp: SkeletalMeshComponent, start_frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, key_reduce: bool = False, tolerance: float = 0.001000, interpolation: MovieSceneKeyInterpolation = MovieSceneKeyInterpolation.SMART_AUTO, reset_controls: bool = True) -> bool:
        r"""
        X.load_anim_sequence_into_control_rig_section(movie_scene_section, anim_sequence, skel_mesh_comp, start_frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, key_reduce=False, tolerance=0.001000, interpolation=MovieSceneKeyInterpolation.SMART_AUTO, reset_controls=True) -> bool
        Load anim sequence into this control rig section
        
        Args:
            movie_scene_section (MovieSceneSection): The MovieSceneSectionto load into
            anim_sequence (AnimSequence): The Sequence to load
            skel_mesh_comp (SkeletalMeshComponent): 
            start_frame (FrameNumber): Frame to insert the animation
            time_unit (MovieSceneTimeUnit): Unit for all frame and time values, either in display rate or tick resolution
            key_reduce (bool): If true do key reduction based upon Tolerance, if false don't
            tolerance (float): If reducing keys, tolerance about which keys will be removed, smaller tolerance, more keys usually.
            interpolation (MovieSceneKeyInterpolation): The key interpolation type to set the keys, defaults to EMovieSceneKeyInterpolation::SmartAuto
            reset_controls (bool): If true will reset all controls to initial value on every frame
        
        Returns:
            bool: returns True if successful, False otherwise
        """
        ...
    @classmethod
    def is_layered_control_rig(cls, control_rig: ControlRig) -> bool:
        r"""
        X.is_layered_control_rig(control_rig) -> bool
        Whether or not the control rig is an Layered Control Rig.
        
        Args:
            control_rig (ControlRig): Rig to test to see if Layered Control Rig
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_fk_control_rig(cls, control_rig: ControlRig) -> bool:
        r"""
        X.is_fk_control_rig(control_rig) -> bool
        Whether or not the control rig is an FK Control Rig.
        
        Args:
            control_rig (ControlRig): Rig to test to see if FK Control Rig
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def import_fbx_to_control_rig_track(cls, world: World, sequence: LevelSequence, track: MovieSceneControlRigParameterTrack, section: MovieSceneControlRigParameterSection, selected_control_rig_names: Array[str], import_fbx_control_rig_settings: MovieSceneUserImportFBXControlRigSettings, import_filename: str) -> bool:
        r"""
        X.import_fbx_to_control_rig_track(world, sequence, track, section, selected_control_rig_names, import_fbx_control_rig_settings, import_filename) -> bool
        * Import FBX onto a control rig with the specified track and section
        *
        *
        
        Args:
            world (World): 
            sequence (LevelSequence): Sequence to import *
            track (MovieSceneControlRigParameterTrack): Track to import onto *
            section (MovieSceneControlRigParameterSection): Section to import onto, may be null in which case we use the track's section to key *
            selected_control_rig_names (Array[str]): List of selected control rig names. Will use them if  ImportFBXControlRigSettings->bImportOntoSelectedControls is true *
            import_fbx_control_rig_settings (MovieSceneUserImportFBXControlRigSettings): Settings to control import. *
            import_filename (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def hide_all_controls(cls, section: MovieSceneSection) -> None:
        r"""
        X.hide_all_controls(section) -> None
        Hides all of the controls for the given section
        
        Args:
            section (MovieSceneSection):
        """
        ...
    @classmethod
    def get_world_space_reference_key(cls) -> RigElementKey:
        r"""
        X.get_world_space_reference_key() -> RigElementKey
        * Get the default world space key, can be used a world space.
        
        Returns:
            RigElementKey:
        """
        ...
    @classmethod
    def get_visible_control_rigs(cls) -> Array[ControlRig]:
        r"""
        X.get_visible_control_rigs() -> Array[ControlRig]
        Get all of the visible control rigs in the level
        
        Returns:
            Array[ControlRig]: returns list of visible Control Rigs
        """
        ...
    @classmethod
    def get_skeletal_mesh_component_world_transforms(cls, level_sequence: LevelSequence, skeletal_mesh_component: SkeletalMeshComponent, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, reference_name: Name = "None") -> Array[Transform]:
        r"""
        X.get_skeletal_mesh_component_world_transforms(level_sequence, skeletal_mesh_component, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, reference_name="None") -> Array[Transform]
        Get SkeletalMeshComponents World Transforms at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get transform for
            skeletal_mesh_component (SkeletalMeshComponent): The SkeletalMeshComponent
            frames (Array[FrameNumber]): Times to get the transform
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            reference_name (Name): Optional name of the referencer
        
        Returns:
            Array[Transform]: Returns World Transforms
        """
        ...
    @classmethod
    def get_skeletal_mesh_component_world_transform(cls, level_sequence: LevelSequence, skeletal_mesh_component: SkeletalMeshComponent, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE, reference_name: Name = "None") -> Transform:
        r"""
        X.get_skeletal_mesh_component_world_transform(level_sequence, skeletal_mesh_component, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE, reference_name="None") -> Transform
        Get SkeletalMeshComponent World Transform at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get transform for
            skeletal_mesh_component (SkeletalMeshComponent): The SkeletalMeshComponent
            frame (FrameNumber): Time to get the transform
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
            reference_name (Name): Optional name of the referencer
        
        Returns:
            Transform: Returns World Transform
        """
        ...
    @classmethod
    def get_local_control_rig_vector2_ds(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Vector2D]:
        r"""
        X.get_local_control_rig_vector2_ds(level_sequence, control_rig, control_name, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Vector2D]
        Get ControlRig Control's Vector2D values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Vector2D control
            frames (Array[FrameNumber]): Times to get the values
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[Vector2D]: Returns Values at those times
        """
        ...
    @classmethod
    def get_local_control_rig_vector2d(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Vector2D:
        r"""
        X.get_local_control_rig_vector2d(level_sequence, control_rig, control_name, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Vector2D
        Get ControlRig Control's Vector2D value at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Vector2D control
            frame (FrameNumber): Time to get the value
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Vector2D: Returns Value at that time
        """
        ...
    @classmethod
    def get_local_control_rig_transforms(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Transform]:
        r"""
        X.get_local_control_rig_transforms(level_sequence, control_rig, control_name, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Transform]
        Get ControlRig Control's Transform values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Transform control
            frames (Array[FrameNumber]): Times to get the values
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[Transform]: Returns Values at those times
        """
        ...
    @classmethod
    def get_local_control_rig_transform_no_scales(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[TransformNoScale]:
        r"""
        X.get_local_control_rig_transform_no_scales(level_sequence, control_rig, control_name, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[TransformNoScale]
        Get ControlRig Control's TransformNoScale values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a TransformNoScale control
            frames (Array[FrameNumber]): Times to get the values
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[TransformNoScale]: Returns Values at those times
        """
        ...
    @classmethod
    def get_local_control_rig_transform_no_scale(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> TransformNoScale:
        r"""
        X.get_local_control_rig_transform_no_scale(level_sequence, control_rig, control_name, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> TransformNoScale
        Get ControlRig Control's TransformNoScale value at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a TransformNoScale control
            frame (FrameNumber): Time to get the value
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            TransformNoScale: Returns Value at that time
        """
        ...
    @classmethod
    def get_local_control_rig_transform(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Transform:
        r"""
        X.get_local_control_rig_transform(level_sequence, control_rig, control_name, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Transform
        Get ControlRig Control's Transform value at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Transform control
            frame (FrameNumber): Time to get the value
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Transform: Returns Value at that time
        """
        ...
    @classmethod
    def get_local_control_rig_scales(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Vector]:
        r"""
        X.get_local_control_rig_scales(level_sequence, control_rig, control_name, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Vector]
        Get ControlRig Control's Scale values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Scale control
            frames (Array[FrameNumber]): Times to get the values
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[Vector]: Returns Values at those times
        """
        ...
    @classmethod
    def get_local_control_rig_scale(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Vector:
        r"""
        X.get_local_control_rig_scale(level_sequence, control_rig, control_name, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Vector
        Get ControlRig Control's Scale value at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Scale control
            frame (FrameNumber): Time to get the value
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Vector: Returns Value at that time
        """
        ...
    @classmethod
    def get_local_control_rig_rotators(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Rotator]:
        r"""
        X.get_local_control_rig_rotators(level_sequence, control_rig, control_name, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Rotator]
        Get ControlRig Control's Rotator values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Rotator control
            frames (Array[FrameNumber]): Times to get the values
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[Rotator]: Returns Values at those times
        """
        ...
    @classmethod
    def get_local_control_rig_rotator(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Rotator:
        r"""
        X.get_local_control_rig_rotator(level_sequence, control_rig, control_name, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Rotator
        Get ControlRig Control's Rotator value at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Rotator control
            frame (FrameNumber): Time to get the value
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Rotator: Returns Value at that time
        """
        ...
    @classmethod
    def get_local_control_rig_positions(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Vector]:
        r"""
        X.get_local_control_rig_positions(level_sequence, control_rig, control_name, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Vector]
        Get ControlRig Control's Position values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Position control
            frames (Array[FrameNumber]): Times to get the values
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[Vector]: Returns Values at those times
        """
        ...
    @classmethod
    def get_local_control_rig_position(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Vector:
        r"""
        X.get_local_control_rig_position(level_sequence, control_rig, control_name, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Vector
        Get ControlRig Control's Position value at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a Position control
            frame (FrameNumber): Time to get the value
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Vector: Returns Value at that time
        """
        ...
    @classmethod
    def get_local_control_rig_ints(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[int]:
        r"""
        X.get_local_control_rig_ints(level_sequence, control_rig, control_name, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[int32]
        Get ControlRig Control's integer values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a intteger control
            frames (Array[FrameNumber]): Times to get the values
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[int32]: Returns Values at those times
        """
        ...
    @classmethod
    def get_local_control_rig_int(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> int:
        r"""
        X.get_local_control_rig_int(level_sequence, control_rig, control_name, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> int32
        Get ControlRig Control's integer value at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a integer control
            frame (FrameNumber): Time to get the value
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            int32: Returns Value at that time
        """
        ...
    @classmethod
    def get_local_control_rig_floats(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[float]:
        r"""
        X.get_local_control_rig_floats(level_sequence, control_rig, control_name, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[float]
        Get ControlRig Control's float values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a float control
            frames (Array[FrameNumber]): Times to get the values
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[float]: Returns Values at those times
        """
        ...
    @classmethod
    def get_local_control_rig_float(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> float:
        r"""
        X.get_local_control_rig_float(level_sequence, control_rig, control_name, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> float
        Get ControlRig Control's float value at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a float control
            frame (FrameNumber): Time to get the value
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            float: Returns Value at that time
        """
        ...
    @classmethod
    def get_local_control_rig_euler_transforms(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[EulerTransform]:
        r"""
        X.get_local_control_rig_euler_transforms(level_sequence, control_rig, control_name, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[EulerTransform]
        Get ControlRig Control's EulerTransform values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a EulerTransform control
            frames (Array[FrameNumber]): Times to get the values
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[EulerTransform]: Returns Values at those times
        """
        ...
    @classmethod
    def get_local_control_rig_euler_transform(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> EulerTransform:
        r"""
        X.get_local_control_rig_euler_transform(level_sequence, control_rig, control_name, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> EulerTransform
        Get ControlRig Control's EulerTransform value at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a EulerTransfom control
            frame (FrameNumber): Time to get the value
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            EulerTransform: Returns Value at that time
        """
        ...
    @classmethod
    def get_local_control_rig_bools(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[bool]:
        r"""
        X.get_local_control_rig_bools(level_sequence, control_rig, control_name, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[bool]
        Get ControlRig Control's bool values at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a bool control
            frames (Array[FrameNumber]): Times to get the values
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[bool]: Returns Values at those times
        """
        ...
    @classmethod
    def get_local_control_rig_bool(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> bool:
        r"""
        X.get_local_control_rig_bool(level_sequence, control_rig, control_name, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> bool
        Get ControlRig Control's bool value at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get value for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control, should be a bool control
            frame (FrameNumber): Time to get the value
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            bool: Returns Value at that time
        """
        ...
    @classmethod
    def get_fk_control_rig_apply_mode(cls, control_rig: ControlRig) -> ControlRigFKRigExecuteMode:
        r"""
        X.get_fk_control_rig_apply_mode(control_rig) -> ControlRigFKRigExecuteMode
        Get FKControlRig Apply Mode.
        
        Args:
            control_rig (ControlRig): Rig to test
        
        Returns:
            ControlRigFKRigExecuteMode: The EControlRigFKRigExecuteMode mode it is in, either Replace,Additive or Direct
        """
        ...
    @classmethod
    def get_default_parent_key(cls) -> RigElementKey:
        r"""
        X.get_default_parent_key() -> RigElementKey
        * Get the default parent key, can be used a parent space.
        
        Returns:
            RigElementKey:
        """
        ...
    @classmethod
    def get_controls_mask(cls, section: MovieSceneSection, control_name: Name) -> bool:
        r"""
        X.get_controls_mask(section, control_name) -> bool
        Get the controls mask for the given ControlName
        
        Args:
            section (MovieSceneSection): 
            control_name (Name): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_control_rig_world_transforms(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Transform]:
        r"""
        X.get_control_rig_world_transforms(level_sequence, control_rig, control_name, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Transform]
        Get ControlRig Control's World Transforms at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get transform for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control
            frames (Array[FrameNumber]): Times to get the transform
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[Transform]: Returns World Transforms
        """
        ...
    @classmethod
    def get_control_rig_world_transform(cls, level_sequence: LevelSequence, control_rig: ControlRig, control_name: Name, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Transform:
        r"""
        X.get_control_rig_world_transform(level_sequence, control_rig, control_name, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Transform
        Get ControlRig Control's World Transform at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get transform for
            control_rig (ControlRig): The ControlRig
            control_name (Name): Name of the Control
            frame (FrameNumber): Time to get the transform
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Transform: Returns World Transform
        """
        ...
    @classmethod
    def get_control_rigs(cls, level_sequence: LevelSequence) -> Array[ControlRigSequencerBindingProxy]:
        r"""
        X.get_control_rigs(level_sequence) -> Array[ControlRigSequencerBindingProxy]
        Get all of the control rigs and their bindings in the level sequence
        
        Args:
            level_sequence (LevelSequence): The movie scene sequence to look for Control Rigs
        
        Returns:
            Array[ControlRigSequencerBindingProxy]: returns list of Control Rigs in the level sequence.
        """
        ...
    @classmethod
    def get_control_rig_priority_order(cls, section: MovieSceneTrack) -> int:
        r"""
        X.get_control_rig_priority_order(section) -> int32
        Get Control Rig prirority order
        
        Args:
            section (MovieSceneTrack): 
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_constraints_for_handle(cls, world: World, child: TransformableHandle) -> Array[TickableConstraint]:
        r"""
        X.get_constraints_for_handle(world, child) -> Array[TickableConstraint]
        Get all constraints for this object, which is described by a transformable handle
        
        Args:
            world (World): 
            child (TransformableHandle): The handle to look for constraints controlling it
        
        Returns:
            Array[TickableConstraint]: Returns array of Constraints this handle is constrained to.
        """
        ...
    @classmethod
    def get_constraint_keys(cls, constraint: TickableConstraint, constraint_section: MovieSceneSection, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Optional[Tuple[Array[bool], Array[FrameNumber]]]:
        r"""
        X.get_constraint_keys(constraint, constraint_section, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> (out_bools=Array[bool], out_frames=Array[FrameNumber]) or None
        Get the constraint keys for the specified constraint
        
        Args:
            constraint (TickableConstraint): The constraint to get
            constraint_section (MovieSceneSection): Section containing Cosntraint Key
            time_unit (MovieSceneTimeUnit): Unit for the time params, either in display rate or tick resolution
        
        Returns:
            tuple or None: Returns true if we got the keys from this constraint
        
            out_bools (Array[bool]): Array of whether or not it's active at the specified times
        
            out_frames (Array[FrameNumber]): The Times for the keys
        """
        ...
    @classmethod
    def get_actor_world_transforms(cls, level_sequence: LevelSequence, actor: Actor, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Transform]:
        r"""
        X.get_actor_world_transforms(level_sequence, actor, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Array[Transform]
        Get Actors World Transforms at specific times
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get transform for
            actor (Actor): The actor
            frames (Array[FrameNumber]): Times to get the transform
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Array[Transform]: Returns World Transforms
        """
        ...
    @classmethod
    def get_actor_world_transform(cls, level_sequence: LevelSequence, actor: Actor, frame: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> Transform:
        r"""
        X.get_actor_world_transform(level_sequence, actor, frame, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> Transform
        Get Actors World Transform at a specific time
        
        Args:
            level_sequence (LevelSequence): Active Sequence to get transform for
            actor (Actor): The actor
            frame (FrameNumber): Time to get the transform
            time_unit (MovieSceneTimeUnit): Unit for frame values, either in display rate or tick resolution
        
        Returns:
            Transform: Returns World Transform
        """
        ...
    @classmethod
    def find_or_create_control_rig_track(cls, world: World, level_sequence: LevelSequence, control_rig_class: Class, binding: MovieSceneBindingProxy, is_layered_control_rig: bool = False) -> MovieSceneTrack:
        r"""
        X.find_or_create_control_rig_track(world, level_sequence, control_rig_class, binding, is_layered_control_rig=False) -> MovieSceneTrack
        Find or create a Control Rig track of a specific class based upon the binding
        
        Args:
            world (World): The world used to spawn into temporarily if binding is a spawnable
            level_sequence (LevelSequence): The LevelSequence to find or create
            control_rig_class (type(Class)): The class of the Control Rig
            binding (MovieSceneBindingProxy): The binding (actor or component binding) to find or create the Control Rig track
            is_layered_control_rig (bool): 
        
        Returns:
            MovieSceneTrack: returns Return the found or created track
        """
        ...
    @classmethod
    def find_or_create_control_rig_component_track(cls, world: World, level_sequence: LevelSequence, binding: MovieSceneBindingProxy) -> Array[MovieSceneTrack]:
        r"""
        X.find_or_create_control_rig_component_track(world, level_sequence, binding) -> Array[MovieSceneTrack]
        Find or create a Control Rig Component
        
        Args:
            world (World): The world used to spawn into temporarily if binding is a spawnable
            level_sequence (LevelSequence): The LevelSequence to find or create
            binding (MovieSceneBindingProxy): The binding (actor or component binding) to find or create the Control Rig tracks
        
        Returns:
            Array[MovieSceneTrack]: returns Find array of component Control Rigs that were found or created
        """
        ...
    @classmethod
    def export_fbx_from_control_rig_section(cls, sequence: LevelSequence, section: MovieSceneControlRigParameterSection, export_fbx_control_rig_settings: MovieSceneUserExportFBXControlRigSettings) -> bool:
        r"""
        X.export_fbx_from_control_rig_section(sequence, section, export_fbx_control_rig_settings) -> bool
        Exports an FBX from the given control rig section.
        
        Args:
            sequence (LevelSequence): 
            section (MovieSceneControlRigParameterSection): 
            export_fbx_control_rig_settings (MovieSceneUserExportFBXControlRigSettings): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def delete_control_rig_space(cls, sequence: LevelSequence, control_rig: ControlRig, control_name: Name, time: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> bool:
        r"""
        X.delete_control_rig_space(sequence, control_rig, control_name, time, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> bool
        Delete the Control Rig Space Key for the Control at the specified time. This will delete any attached Control Rig keys at this time and will perform any needed compensation to the new space.
        
        Args:
            sequence (LevelSequence): Sequence to set the space
            control_rig (ControlRig): ControlRig with the Control
            control_name (Name): The name of the Control
            time (FrameNumber): Time to delete the space.
            time_unit (MovieSceneTimeUnit): Unit for the InTime, either in display rate or tick resolution
        
        Returns:
            bool: Will return false if function fails,  for example if there is no key at this time it will fail.
        """
        ...
    @classmethod
    def delete_constraint_key(cls, constraint: TickableConstraint, constraint_section: MovieSceneSection, time: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> bool:
        r"""
        X.delete_constraint_key(constraint, constraint_section, time, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> bool
        Delete the Key for the Constraint at the specified time.
        
        Args:
            constraint (TickableConstraint): 
            constraint_section (MovieSceneSection): Section containing Cosntraint Key
            time (FrameNumber): Time to delete the constraint.
            time_unit (MovieSceneTimeUnit): Unit for the InTime, either in display rate or tick resolution
        
        Returns:
            bool: Will return false if function fails,  for example if there is no key at this time it will fail.
        """
        ...
    @classmethod
    def compensate_all(cls, constraint: TickableConstraint) -> bool:
        r"""
        X.compensate_all(constraint) -> bool
        Compensate constraint at all keys
        
        Args:
            constraint (TickableConstraint): The constraint to compensate
        
        Returns:
            bool: Returns true if it can compensate
        """
        ...
    @classmethod
    def compensate(cls, constraint: TickableConstraint, time: FrameNumber, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> bool:
        r"""
        X.compensate(constraint, time, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> bool
        Compensate constraint at the specfied time
        
        Args:
            constraint (TickableConstraint): The constraint to compensate
            time (FrameNumber): Time to compensate
            time_unit (MovieSceneTimeUnit): Unit for the InTime, either in display rate or tick resolution
        
        Returns:
            bool: Returns true if it can compensate
        """
        ...
    @classmethod
    def collapse_control_rig_anim_layers_with_settings(cls, sequence: LevelSequence, track: MovieSceneControlRigParameterTrack, settings: BakingAnimationKeySettings) -> bool:
        r"""
        X.collapse_control_rig_anim_layers_with_settings(sequence, track, settings) -> bool
        * Collapse and bake all sections and layers on a control rig track to just one section using passed in settings.
        *
        *
        
        Args:
            sequence (LevelSequence): Sequence that has track to collapse *
            track (MovieSceneControlRigParameterTrack): Track for layers to collapse *
            settings (BakingAnimationKeySettings): Settings that determine how to collapse
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def collapse_control_rig_anim_layers(cls, sequence: LevelSequence, track: MovieSceneControlRigParameterTrack, key_reduce: bool = False, tolerance: float = 0.001000) -> bool:
        r"""
        X.collapse_control_rig_anim_layers(sequence, track, key_reduce=False, tolerance=0.001000) -> bool
        * Collapse and bake all sections and layers on a control rig track to just one section.
        *
        *
        
        Args:
            sequence (LevelSequence): Sequence that has track to collapse *
            track (MovieSceneControlRigParameterTrack): Track for layers to collapse *
            key_reduce (bool): If true do key reduction based upon Tolerance, if false don't *
            tolerance (float): If reducing keys, tolerance about which keys will be removed, smaller tolerance, more keys usually.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def blend_values_on_selected(cls, level_sequence: LevelSequence, blend_operation: AnimToolBlendOperation, blend_value: float) -> bool:
        r"""
        X.blend_values_on_selected(level_sequence, blend_operation, blend_value) -> bool
        Peform specified blend operation based upon selected keys in the curve editor or selected control rig controls
        
        Args:
            level_sequence (LevelSequence): The LevelSequence that's loaded in the editor
            blend_operation (AnimToolBlendOperation): 
            blend_value (float): The blend value to use, range from -1(blend to previous) to 1(blend to next)
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def bake_to_control_rig(cls, world: World, level_sequence: LevelSequence, control_rig_class: Class, export_options: AnimSeqExportOption, reduce_keys: bool, tolerance: float, binding: MovieSceneBindingProxy, reset_controls: bool = True) -> bool:
        r"""
        X.bake_to_control_rig(world, level_sequence, control_rig_class, export_options, reduce_keys, tolerance, binding, reset_controls=True) -> bool
        Bake the current animation in the binding to a Control Rig track
        
        Args:
            world (World): The active world
            level_sequence (LevelSequence): The LevelSequence we are baking
            control_rig_class (type(Class)): The class of the Control Rig
            export_options (AnimSeqExportOption): Export options for creating an animation sequence
            reduce_keys (bool): 
            tolerance (float): If reducing keys, tolerance about which keys will be removed, smaller tolerance, more keys usually.
            binding (MovieSceneBindingProxy): The binding upon which to bake
            reset_controls (bool): If true will reset all controls to initial value on every frame
        
        Returns:
            bool: returns True if successful, False otherwise
        """
        ...
    @classmethod
    def bake_control_rig_space(cls, sequence: LevelSequence, control_rig: ControlRig, control_names: Array[Name], settings: RigSpacePickerBakeSettings, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> bool:
        r"""
        X.bake_control_rig_space(sequence, control_rig, control_names, settings, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> bool
        Bake specified Control Rig Controls to a specified Space based upon the current settings
        
        Args:
            sequence (LevelSequence): Sequence to bake
            control_rig (ControlRig): ControlRig to bake
            control_names (Array[Name]): The name of the Controls to bake
            settings (RigSpacePickerBakeSettings): The settings for the bake, e.g, how long to bake, to key reduce etc.
            time_unit (MovieSceneTimeUnit): Unit for the start and end times in the InSettings parameter.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def bake_constraints(cls, world: World, settings: BakingAnimationKeySettings) -> Optional[Array[TickableConstraint]]:
        r"""
        X.bake_constraints(world, settings) -> Array[TickableConstraint] or None
        Bake the constraint to keys based on the passed in settings. This will use the open sequencer to bake. See ConstraintsScriptingLibrary to get the list of available constraints
        
        Args:
            world (World): The active world
            settings (BakingAnimationKeySettings): Settings to use for baking
        
        Returns:
            Array[TickableConstraint] or None: Returns True if successful, False otherwise
        
            constraints (Array[TickableConstraint]): The Constraints tobake.  After baking they will be keyed to be inactive of the range of frames that are baked
        """
        ...
    @classmethod
    def bake_constraint(cls, world: World, constraint: TickableConstraint, frames: Array[FrameNumber], time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> bool:
        r"""
        X.bake_constraint(world, constraint, frames, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> bool
        Bake the constraint to keys based on the passed in frames. This will use the open sequencer to bake. See ConstraintsScriptingLibrary to get the list of available constraints
        
        Args:
            world (World): The active world
            constraint (TickableConstraint): The Constraint to bake. After baking it will be keyed to be inactive of the range of frames that are baked
            frames (Array[FrameNumber]): The frames to bake, if the array is empty it will use the active time ranges of the constraint to determine where it should bake
            time_unit (MovieSceneTimeUnit): Unit for all frame and time values, either in display rate or tick resolution
        
        Returns:
            bool: Returns True if successful, False otherwise
        """
        ...
    @classmethod
    def add_constraint(cls, world: World, type: TransformConstraintType, child: TransformableHandle, parent: TransformableHandle, maintain_offset: bool) -> TickableConstraint:
        r"""
        X.add_constraint(world, type, child, parent, maintain_offset) -> TickableConstraint
        Add a constraint possibly adding to sequencer also if one is open.
        
        Args:
            world (World): The active world
            type (TransformConstraintType): Type of constraint to create
            child (TransformableHandle): The handle to the transormable to be constrainted
            parent (TransformableHandle): The handle to the parent of the constraint
            maintain_offset (bool): Whether to maintain offset between child and parent when setting the constraint
        
        Returns:
            TickableConstraint: Returns the constraint if created all nullptr if not
        """
        ...

class ControlRigControlsProxy(Object):
    r"""
    Control Rig Controls Proxy
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigControlsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Only]
    """
    ...

class AnimDetailControlsKeyedProxy(ControlRigControlsProxy):
    r"""
    Anim Detail Controls Keyed Proxy
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Only]
    """
    ...

class AnimDetailControlsProxyFloat(AnimDetailControlsKeyedProxy):
    r"""
    Anim Detail Controls Proxy Float
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``float`` (AnimDetailProxyFloat):  [Read-Write]
    - ``name`` (Name):  [Read-Only]
    """
    @property
    def float(self) -> AnimDetailProxyFloat:
        r"""
        (AnimDetailProxyFloat):  [Read-Write]
        """
        ...
    @float.setter
    def float(self, value: AnimDetailProxyFloat) -> None:
        ...

class AnimDetailControlsProxyBool(AnimDetailControlsKeyedProxy):
    r"""
    Anim Detail Controls Proxy Bool
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``bool`` (AnimDetailProxyBool):  [Read-Write]
    - ``name`` (Name):  [Read-Only]
    """
    @property
    def bool(self) -> AnimDetailProxyBool:
        r"""
        (AnimDetailProxyBool):  [Read-Write]
        """
        ...
    @bool.setter
    def bool(self, value: AnimDetailProxyBool) -> None:
        ...

class AnimDetailControlsProxyInteger(AnimDetailControlsKeyedProxy):
    r"""
    Anim Detail Controls Proxy Integer
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``integer`` (AnimDetailProxyInteger):  [Read-Write]
    - ``name`` (Name):  [Read-Only]
    """
    @property
    def integer(self) -> AnimDetailProxyInteger:
        r"""
        (AnimDetailProxyInteger):  [Read-Write]
        """
        ...
    @integer.setter
    def integer(self, value: AnimDetailProxyInteger) -> None:
        ...

class AnimDetailControlsProxyEnum(AnimDetailControlsKeyedProxy):
    r"""
    Anim Detail Controls Proxy Enum
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``enum`` (ControlRigEnumControlProxyValue):  [Read-Write]
    - ``name`` (Name):  [Read-Only]
    """
    @property
    def enum(self) -> ControlRigEnumControlProxyValue:
        r"""
        (ControlRigEnumControlProxyValue):  [Read-Write]
        """
        ...
    @enum.setter
    def enum(self, value: ControlRigEnumControlProxyValue) -> None:
        ...

class AnimDetailControlsProxyTransform(AnimDetailControlsKeyedProxy):
    r"""
    Anim Detail Controls Proxy Transform
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``location`` (AnimDetailProxyLocation):  [Read-Write]
    - ``name`` (Name):  [Read-Only]
    - ``rotation`` (AnimDetailProxyRotation):  [Read-Write]
    - ``scale`` (AnimDetailProxyScale):  [Read-Write]
    """
    @property
    def location(self) -> AnimDetailProxyLocation:
        r"""
        (AnimDetailProxyLocation):  [Read-Write]
        """
        ...
    @location.setter
    def location(self, value: AnimDetailProxyLocation) -> None:
        ...
    @property
    def rotation(self) -> AnimDetailProxyRotation:
        r"""
        (AnimDetailProxyRotation):  [Read-Write]
        """
        ...
    @rotation.setter
    def rotation(self, value: AnimDetailProxyRotation) -> None:
        ...
    @property
    def scale(self) -> AnimDetailProxyScale:
        r"""
        (AnimDetailProxyScale):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: AnimDetailProxyScale) -> None:
        ...

class AnimDetailControlsProxyLocation(AnimDetailControlsKeyedProxy):
    r"""
    Anim Detail Controls Proxy Location
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``location`` (AnimDetailProxyLocation):  [Read-Write]
    - ``name`` (Name):  [Read-Only]
    """
    @property
    def location(self) -> AnimDetailProxyLocation:
        r"""
        (AnimDetailProxyLocation):  [Read-Write]
        """
        ...
    @location.setter
    def location(self, value: AnimDetailProxyLocation) -> None:
        ...

class AnimDetailControlsProxyRotation(AnimDetailControlsKeyedProxy):
    r"""
    Anim Detail Controls Proxy Rotation
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Only]
    - ``rotation`` (AnimDetailProxyRotation):  [Read-Write]
    """
    @property
    def rotation(self) -> AnimDetailProxyRotation:
        r"""
        (AnimDetailProxyRotation):  [Read-Write]
        """
        ...
    @rotation.setter
    def rotation(self, value: AnimDetailProxyRotation) -> None:
        ...

class AnimDetailControlsProxyScale(AnimDetailControlsKeyedProxy):
    r"""
    Anim Detail Controls Proxy Scale
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Only]
    - ``scale`` (AnimDetailProxyScale):  [Read-Write]
    """
    @property
    def scale(self) -> AnimDetailProxyScale:
        r"""
        (AnimDetailProxyScale):  [Read-Write]
        """
        ...
    @scale.setter
    def scale(self, value: AnimDetailProxyScale) -> None:
        ...

class AnimDetailControlsProxyVector2D(AnimDetailControlsKeyedProxy):
    r"""
    Anim Detail Controls Proxy Vector 2D
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: AnimDetailsProxy.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``name`` (Name):  [Read-Only]
    - ``vector2d`` (AnimDetailProxyVector2D):  [Read-Write]
    """
    @property
    def vector2d(self) -> AnimDetailProxyVector2D:
        r"""
        (AnimDetailProxyVector2D):  [Read-Write]
        """
        ...
    @vector2d.setter
    def vector2d(self, value: AnimDetailProxyVector2D) -> None:
        ...

class ControlRigContextMenuContext(Object):
    r"""
    Control Rig Context Menu Context
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigContextMenuContext.h
    
    """
    def is_alt_down(self) -> bool:
        r"""
        x.is_alt_down() -> bool
        Returns true if either alt key is down
        
        Returns:
            bool:
        """
        ...
    def get_rig_hierarchy_to_graph_drag_and_drop_context(self) -> ControlRigRigHierarchyToGraphDragAndDropContext:
        r"""
        x.get_rig_hierarchy_to_graph_drag_and_drop_context() -> ControlRigRigHierarchyToGraphDragAndDropContext
        Returns context for the menu that shows up when drag and drop from Rig Hierarchy to the Rig Graph
        
        Returns:
            ControlRigRigHierarchyToGraphDragAndDropContext:
        """
        ...
    def get_rig_hierarchy_drag_and_drop_context(self) -> ControlRigRigHierarchyDragAndDropContext:
        r"""
        x.get_rig_hierarchy_drag_and_drop_context() -> ControlRigRigHierarchyDragAndDropContext
        Returns context for a drag & drop action that contains source and target element keys
        
        Returns:
            ControlRigRigHierarchyDragAndDropContext:
        """
        ...
    def get_graph_node_context_menu_context(self) -> ControlRigGraphNodeContextMenuContext:
        r"""
        x.get_graph_node_context_menu_context() -> ControlRigGraphNodeContextMenuContext
        Returns context for graph node context menu
        
        Returns:
            ControlRigGraphNodeContextMenuContext:
        """
        ...
    def get_control_rig_blueprint(self) -> ControlRigBlueprint:
        r"""
        x.get_control_rig_blueprint() -> ControlRigBlueprint
        Get the control rig blueprint that we are editing
        
        Returns:
            ControlRigBlueprint:
        """
        ...
    def get_control_rig(self) -> ControlRig:
        r"""
        x.get_control_rig() -> ControlRig
        Get the active control rig instance in the viewport
        
        Returns:
            ControlRig:
        """
        ...

class ControlRigSkeletalMeshComponent(DebugSkelMeshComponent):
    r"""
    Control Rig Skeletal Mesh Component
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigSkeletalMeshComponent.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``absolute_location`` (bool):  [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent
    - ``absolute_rotation`` (bool):  [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent
    - ``absolute_scale`` (bool):  [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent
    - ``affect_distance_field_lighting`` (bool):  [Read-Write] Controls whether the primitive should affect dynamic distance field lighting methods.  This flag is only used if CastShadow is true. *
    - ``affect_dynamic_indirect_lighting`` (bool):  [Read-Write] Controls whether the primitive should influence indirect lighting.
    - ``affect_indirect_lighting_while_hidden`` (bool):  [Read-Write] Controls whether the primitive should affect indirect lighting when hidden. This flag is only used if bAffectDynamicIndirectLighting is true.
    - ``allow_anim_curve_evaluation`` (bool):  [Read-Write] Disable animation curves for this component. If this is set true, no curves will be processed
    - ``allow_cloth_actors`` (bool):  [Read-Write] Toggles creation of cloth simulation. Distinct from the simulation toggle below in that, if off, avoids allocating
      the actors entirely instead of just skipping the simulation step.
    - ``allow_cull_distance_volume`` (bool):  [Read-Write] Whether to accept cull distance volumes to modify cached cull distance.
    - ``always_create_physics_state`` (bool):  [Read-Write] Indicates if we'd like to create physics state all the time (for collision and simulation).
      If you set this to false, it still will create physics state if collision or simulation activated.
      This can help performance if you'd like to avoid overhead of creating physics state when triggers
    - ``anim_blueprint_generated_class`` (type(AnimBlueprintGeneratedClass)):  [Read-Write]
    - ``anim_class`` (type(Class)):  [Read-Write] The AnimBlueprint class to use. Use 'SetAnimInstanceClass' to change at runtime.
    - ``animation_data`` (SingleAnimationPlayData):  [Read-Write]
    - ``animation_mode`` (AnimationMode):  [Read-Write] Whether to use Animation Blueprint or play Single Animation Asset.
    - ``apply_impulse_on_damage`` (bool):  [Read-Write] True for damage to this component to apply physics impulse, false to opt out of these impulses.
    - ``asset_user_data`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``asset_user_data_editor_only`` (Array[AssetUserData]):  [Read-Write] Array of user data stored with the component
    - ``auto_activate`` (bool):  [Read-Write] Whether the component is activated at creation or must be explicitly activated.
    - ``body_instance`` (BodyInstance):  [Read-Write] Physics scene information for this component, holds a single rigid body with multiple shapes.
    - ``bounds_scale`` (float):  [Read-Write] Scales the bounds of the object.
      This is useful when using World Position Offset to animate the vertices of the object outside of its bounds.
      Warning: Increasing the bounds of an object will reduce performance and shadow quality!
      Currently only used by StaticMeshComponent and SkeletalMeshComponent.
    - ``cached_max_draw_distance`` (float):  [Read-Only] The distance to cull this primitive at.
      A CachedMaxDrawDistance of 0 indicates that the primitive should not be culled by distance.
    - ``can_character_step_up_on`` (CanBeCharacterBase):  [Read-Write] Determine whether a Character can step up onto this component.
      This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
      see: FWalkableSlopeOverride
    - ``can_ever_affect_navigation`` (bool):  [Read-Write] Whether this component can potentially influence navigation
    - ``capsule_indirect_shadow_min_visibility`` (float):  [Read-Write] Controls how dark the capsule indirect shadow can be.
    - ``cast_capsule_direct_shadow`` (bool):  [Read-Write] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for direct shadowing from lights.
      This type of shadowing is approximate but handles extremely wide area shadowing well.  The softness of the shadow depends on the light's LightSourceAngle / SourceRadius.
      This flag will force bCastInsetShadow to be enabled.
    - ``cast_capsule_indirect_shadow`` (bool):  [Read-Write] Whether to use the capsule representation (when present) from a skeletal mesh's ShadowPhysicsAsset for shadowing indirect lighting (from lightmaps or skylight).
    - ``cast_cinematic_shadow`` (bool):  [Read-Write] Whether this component should cast shadows from lights that have bCastShadowsFromCinematicObjectsOnly enabled.
      This is useful for characters in a cinematic with special cinematic lights, where the cost of shadowmap rendering of the environment is undesired.
    - ``cast_contact_shadow`` (bool):  [Read-Write] Whether the object should cast contact shadows.
      This flag is only used if CastShadow is true.
    - ``cast_dynamic_shadow`` (bool):  [Read-Write] Controls whether the primitive should cast shadows in the case of non precomputed shadowing.  This flag is only used if CastShadow is true. *
    - ``cast_far_shadow`` (bool):  [Read-Write] When enabled, the component will be rendering into the far shadow cascades (only for directional lights).
    - ``cast_hidden_shadow`` (bool):  [Read-Write] If true, the primitive will cast shadows even if bHidden is true.
      Controls whether the primitive should cast shadows when hidden.
      This flag is only used if CastShadow is true.
    - ``cast_inset_shadow`` (bool):  [Read-Write] Whether this component should create a per-object shadow that gives higher effective shadow resolution.
      Useful for cinematic character shadowing. Assumed to be enabled if bSelfShadowOnly is enabled.
    - ``cast_shadow`` (bool):  [Read-Write] Controls whether the primitive component should cast a shadow or not.
    - ``cast_shadow_as_two_sided`` (bool):  [Read-Write] Whether this primitive should cast dynamic shadows as if it were a two sided material.
    - ``cast_static_shadow`` (bool):  [Read-Write] Whether the object should cast a static shadow from shadow casting lights.  This flag is only used if CastShadow is true.
    - ``cast_volumetric_translucent_shadow`` (bool):  [Read-Write] Whether the object should cast a volumetric translucent shadow.
      Volumetric translucent shadows are useful for primitives with smoothly changing opacity like particles representing a volume,
      But have artifacts when used on highly opaque surfaces.
    - ``cloth_blend_weight`` (float):  [Read-Write] weight to blend between simulated results and key-framed positions
      if weight is 1.0, shows only cloth simulation results and 0.0 will show only skinned results
    - ``cloth_max_distance_scale`` (float):  [Read-Write]
    - ``cloth_velocity_scale`` (float):  [Read-Write] Scale applied to the component induced velocity of all cloth particles prior to stepping the cloth solver.
      Use 1.0 for fully induced velocity (default), or use 0.0 for no induced velocity, and any other values in between for a reduced induced velocity.
      When set to 0.0, it also provides a way to force the clothing to simulate in local space.
      This value multiplies to individual cloth's velocity scale settings, still allowing for differences in behavior between the various pieces of clothing within the same component.
    - ``clothing_simulation_factory`` (type(Class)):  [Read-Write] Class of the object responsible for
    - ``collide_with_attached_children`` (bool):  [Read-Write] can't collide with part of attached children if total collision volumes exceed 16 capsules or 32 planes per convex
    - ``collide_with_environment`` (bool):  [Read-Write] can't collide with part of environment if total collision volumes exceed 16 capsules or 32 planes per convex
    - ``component_tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.
    - ``component_use_fixed_skel_bounds`` (bool):  [Read-Write] When true, skip using the physics asset etc. and always use the fixed bounds defined in the SkeletalMesh.
    - ``consider_all_bodies_for_bounds`` (bool):  [Read-Write] If true, when updating bounds from a PhysicsAsset, consider _all_ BodySetups, not just those flagged with bConsiderForBounds.
    - ``consider_for_actor_placement_when_hidden`` (bool):  [Read-Write] If true, this component will be considered for placement when dragging and placing items in the editor even if it is not visible, such as in the case of hidden collision meshes
    - ``custom_depth_stencil_value`` (int32):  [Read-Write] Optionally write this 0-255 value to the stencil buffer in CustomDepth pass (Requires project setting or r.CustomDepth == 3)
    - ``custom_depth_stencil_write_mask`` (RendererStencilMask):  [Read-Write] Mask used for stencil buffer writes.
    - ``custom_primitive_data`` (CustomPrimitiveData):  [Read-Write] Optional user defined default values for the custom primitive data of this primitive
    - ``default_animating_rig_override`` (Object):  [Read-Write] Default Animating Rig to Use if bOverrideDefaultAnimatingRig is true
    - ``defer_kinematic_bone_update`` (bool):  [Read-Write] Whether animation and world transform updates are deferred. If this is on, the kinematic bodies (scene query data) will not update until the next time the physics simulation is run
    - ``detail_mode`` (DetailMode):  [Read-Write] If detail mode is >= system detail mode, primitive won't be rendered.
    - ``disable_cloth_simulation`` (bool):  [Read-Write] Disable cloth simulation and play original animation without simulation
    - ``disable_morph_target`` (bool):  [Read-Write] Disable Morphtarget for this component.
    - ``disable_post_process_blueprint`` (bool):  [Read-Write] Controls whether or not this component will evaluate its post process instance. The post-process
      Instance is dictated by the skeletal mesh so this is used for per-instance control.
    - ``disable_rigid_body_anim_node`` (bool):  [Read-Write] Disable rigid body animation nodes and play original animation without simulation
    - ``display_debug_update_rate_optimizations`` (bool):  [Read-Write] Enable on screen debugging of update rate optimization.
      Red = Skipping 0 frames, Green = skipping 1 frame, Blue = skipping 2 frames, black = skipping more than 2 frames.
      todo:: turn this into a console command.
    - ``editable_when_inherited`` (bool):  [Read-Write] True if this component can be modified when it was inherited from a parent actor class
    - ``emissive_light_source`` (bool):  [Read-Write] Whether the primitive will be used as an emissive light source.
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether to include this component in HLODs or not.
    - ``enable_material_parameter_caching`` (bool):  [Read-Write]
    - ``enable_per_poly_collision`` (bool):  [Read-Write] Uses skinned data for collision data.
    - ``enable_physics_on_dedicated_server`` (bool):  [Read-Write] If true, simulate physics for this component on a dedicated server.
      This should be set if simulating physics and replicating with a dedicated server.
          Note: This property cannot be changed at runtime.
    - ``enable_update_rate_optimizations`` (bool):  [Read-Write] if TRUE, Owner will determine how often animation will be updated and evaluated. See AnimUpdateRateTick()
      This allows to skip frames for performance. (For example based on visibility and size on screen).
    - ``exclude_for_specific_hlod_levels`` (Array[int32]):  [Read-Write]
      deprecated: WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead
    - ``exclude_from_hlod_levels`` (uint8):  [Read-Write] Which specific HLOD levels this component should be excluded from
    - ``exclude_from_light_attachment_group`` (bool):  [Read-Write] If set, then it overrides any bLightAttachmentsAsGroup set in a parent.
    - ``fill_collision_underneath_for_navmesh`` (bool):  [Read-Write] If set, navmesh will not be generated under the surface of the geometry
    - ``force_collision_update`` (bool):  [Read-Write] Forces the cloth simulation to constantly update its external collisions, at the expense of performance.
      This will help to prevent missed collisions if the cloth's skeletal mesh component isn't moving,
      and when instead, wind or other moving objects are causing new collision shapes to come into the cloth's vicinity.
    - ``force_mip_streaming`` (bool):  [Read-Write] If true, forces mips for textures used by this component to be resident when this component's level is loaded.
    - ``forced_lod_model`` (int32):  [Read-Write]
    - ``generate_overlap_events`` (bool):  [Read-Write]
    - ``global_anim_rate_scale`` (float):  [Read-Write] Used to scale speed of all animations on this skeletal mesh.
    - ``hidden_in_game`` (bool):  [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.
    - ``hidden_in_scene_capture`` (bool):  [Read-Write] When true, will not be captured by Scene Capture
    - ``hlod_batching_policy`` (HLODBatchingPolicy):  [Read-Write] Determines how the geometry of a component will be incorporated in proxy (simplified) HLODs.
    - ``holdout`` (bool):  [Read-Write] If this is True, this primitive will render black with an alpha of 0, but all secondary effects (shadows, reflections, indirect lighting) remain. This feature required the project setting "Enable alpha channel support in post processing".
    - ``ignore_leader_pose_component_lod`` (bool):  [Read-Write] Flag that when set will ensure UpdateLODStatus will not take the LeaderPoseComponent's current LOD in consideration when determining the correct LOD level (this requires LeaderPoseComponent's LOD to always be >= determined LOD otherwise bone transforms could be missing
    - ``ignore_radial_force`` (bool):  [Read-Write] Will ignore radial forces applied to this component.
    - ``ignore_radial_impulse`` (bool):  [Read-Write] Will ignore radial impulses applied to this component.
    - ``include_component_location_into_bounds`` (bool):  [Read-Write] If true, the Location of this Component will be included into its bounds calculation
      (this can be useful when using SMU_OnlyTickPoseWhenRendered on a character that moves away from the root and no bones are left near the origin of the component)
    - ``indirect_lighting_cache_quality`` (IndirectLightingCacheQuality):  [Read-Write] Quality of indirect lighting for Movable primitives.  This has a large effect on Indirect Lighting Cache update time.
    - ``is_editor_only`` (bool):  [Read-Write] If true, the component will be excluded from non-editor builds
    - ``kinematic_bones_update_type`` (KinematicBonesUpdateToPhysics):  [Read-Write] If we are running physics, should we update non-simulated bones based on the animation bone positions.
    - ``ld_max_draw_distance`` (float):  [Read-Write] Max draw distance exposed to LDs. The real max draw distance is the min (disregarding 0) of this and volumes affecting this object.
    - ``leader_pose_component`` (SkinnedMeshComponent):  [Read-Write] If set, this SkeletalMeshComponent will not use its SpaceBase for bone transform, but will
      use the component space transforms from the LeaderPoseComponent. This is used when constructing a character using multiple skeletal meshes sharing the same
      skeleton within the same Actor.
    - ``light_attachments_as_group`` (bool):  [Read-Write] Whether to light this component and any attachments as a group.  This only has effect on the root component of an attachment tree.
      When enabled, attached component shadowing settings like bCastInsetShadow, bCastVolumetricTranslucentShadow, etc, will be ignored.
      This is useful for improving performance when multiple movable components are attached together.
    - ``lighting_channels`` (LightingChannels):  [Read-Write] Channels that this component should be in.  Lights with matching channels will affect the component.
      These channels only apply to opaque materials, direct lighting, and dynamic lighting and shadowing.
    - ``lightmap_type`` (LightmapType):  [Read-Write] Controls the type of lightmap used for this component.
    - ``mesh_deformer`` (MeshDeformer):  [Read-Write] The mesh deformer to use. If no mesh deformer is set from here or the SkeletalMesh, then we fall back to the fixed function deformation.
    - ``mesh_deformer_instance`` (MeshDeformerInstance):  [Read-Write]
      deprecated: Use the GetMeshDeformerInstance function instead
    - ``mesh_deformer_instance_settings`` (MeshDeformerInstanceSettings):  [Read-Only] Object containing instance settings for the bound MeshDeformer.
    - ``min_draw_distance`` (float):  [Read-Write] The minimum distance at which the primitive should be rendered,
      measured in world space units from the center of the primitive's bounding sphere to the camera position.
    - ``min_lod_model`` (int32):  [Read-Write] This is the min LOD that this component will use.  (e.g. if set to 2 then only 2+ LOD Models will be used.) This is useful to set on
      meshes which are known to be a certain distance away and still want to have better LODs when zoomed in on them.
    - ``mobility`` (ComponentMobility):  [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.
    - ``multi_body_overlap`` (bool):  [Read-Write] If true, this component will generate individual overlaps for each overlapping physics body if it is a multi-body component. When false, this component will
      generate only one overlap, regardless of how many physics bodies it has and how many of them are overlapping another component/body. This flag has no
      influence on single body components.
    - ``never_distance_cull`` (bool):  [Read-Write] When enabled this object will not be culled by distance. This is ignored if a child of a HLOD.
    - ``no_skeleton_update`` (bool):  [Read-Write] Skips Ticking and Bone Refresh.
    - ``on_anim_initialized`` (OnAnimInitialized):  [Read-Write] Broadcast when the components anim instance is initialized
    - ``on_begin_cursor_over`` (ComponentBeginCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved over this component and mouse over events are enabled in the player controller
    - ``on_clicked`` (ComponentOnClickedSignature):  [Read-Write] Event called when the left mouse button is clicked while the mouse is over this component and click events are enabled in the player controller
    - ``on_component_activated`` (ActorComponentActivatedSignature):  [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset
    - ``on_component_begin_overlap`` (ComponentBeginOverlapSignature):  [Read-Write] Event called when something starts to overlaps this component, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
      note: When receiving an overlap from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
    - ``on_component_deactivated`` (ActorComponentDeactivateSignature):  [Read-Write] Called when the component has been deactivated
    - ``on_component_end_overlap`` (ComponentEndOverlapSignature):  [Read-Write] Event called when something stops overlapping this component
      note: Both this component and the other one must have GetGenerateOverlapEvents() set to true to generate overlap events.
    - ``on_component_hit`` (ComponentHitSignature):  [Read-Write] Event called when a component hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled for this component.
      note: When receiving a hit from another object's movement, the directions of 'Hit.Normal' and 'Hit.ImpactNormal' will be adjusted to indicate force from the other object against this object.
      note: NormalImpulse will be filled in for physics-simulating bodies, but will be zero for swept-component blocking collisions.
    - ``on_component_physics_state_changed`` (ComponentPhysicsStateChanged):  [Read-Write] Event called when physics state is created or destroyed for this component
    - ``on_component_sleep`` (ComponentSleepSignature):  [Read-Write] Event called when the underlying physics objects is put to sleep
    - ``on_component_wake`` (ComponentWakeSignature):  [Read-Write] Event called when the underlying physics objects is woken up
    - ``on_constraint_broken`` (ConstraintBrokenSignature):  [Read-Write] Notification when constraint is broken.
    - ``on_end_cursor_over`` (ComponentEndCursorOverSignature):  [Read-Write] Event called when the mouse cursor is moved off this component and mouse over events are enabled in the player controller
    - ``on_input_touch_begin`` (ComponentOnInputTouchBeginSignature):  [Read-Write] Event called when a touch input is received over this component when touch events are enabled in the player controller
    - ``on_input_touch_end`` (ComponentOnInputTouchEndSignature):  [Read-Write] Event called when a touch input is released over this component when touch events are enabled in the player controller
    - ``on_input_touch_enter`` (ComponentBeginTouchOverSignature):  [Read-Write] Event called when a finger is moved over this component when touch over events are enabled in the player controller
    - ``on_input_touch_leave`` (ComponentEndTouchOverSignature):  [Read-Write] Event called when a finger is moved off this component when touch over events are enabled in the player controller
    - ``on_plastic_deformation`` (PlasticDeformationEventSignature):  [Read-Write] Notification when constraint plasticity drive target changes.
    - ``on_released`` (ComponentOnReleasedSignature):  [Read-Write] Event called when the left mouse button is released while the mouse is over this component click events are enabled in the player controller
    - ``only_owner_see`` (bool):  [Read-Write] If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly.
    - ``overlay_material`` (MaterialInterface):  [Read-Write] Translucent material to blend on top of this mesh. Mesh will be rendered twice - once with a base material and once with overlay material
    - ``overlay_material_max_draw_distance`` (float):  [Read-Write] The max draw distance for overlay material. A distance of 0 indicates that overlay will be culled using primitive max distance.
    - ``override_default_animating_rig`` (bool):  [Read-Write] If true, DefaultAnimatingRigOverride will be used. If false, use the DefaultAnimatingRig in the SkeletalMesh
    - ``override_materials`` (Array[MaterialInterface]):  [Read-Write] Material overrides.
    - ``override_min_lod`` (bool):  [Read-Write] Whether we should use the min lod specified in MinLodModel for this component instead of the min lod in the mesh
    - ``owner_no_see`` (bool):  [Read-Write] If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly.
    - ``pause_anims`` (bool):  [Read-Write] pauses this component's animations (doesn't tick them, but still refreshes bones)
    - ``per_bone_motion_blur`` (bool):  [Read-Write] If true, use per-bone motion blur on this skeletal mesh (requires additional rendering, can be disabled to save performance).
    - ``physics_asset_override`` (PhysicsAsset):  [Read-Write] PhysicsAsset is set in SkeletalMesh by default, but you can override with this value
    - ``physics_transform_update_mode`` (PhysicsTransformUpdateMode):  [Read-Write] Whether physics simulation updates component transform.
    - ``physics_volume_changed_delegate`` (PhysicsVolumeChanged):  [Read-Write] Delegate that will be called when PhysicsVolume has been changed *
    - ``primary_component_tick`` (ActorComponentTickFunction):  [Read-Write] Main tick function for the Component
    - ``propagate_curves_to_followers`` (bool):  [Read-Write] If true, propagates calls to ApplyAnimationCurvesToComponent for follower components, only needed if follower components do not tick themselves
    - ``ray_tracing_group_culling_priority`` (RayTracingGroupCullingPriority):  [Read-Write] Defines how quickly it should be culled. For example buildings should have a low priority, but small dressing should have a high priority.
    - ``ray_tracing_group_id`` (int32):  [Read-Write] Defines run-time groups of components. For example allows to assemble multiple parts of a building at runtime.
      -1 means that component doesn't belong to any group.
    - ``receive_mobile_csm_shadows`` (bool):  [Read-Write] Mobile only:
      If disabled this component will not receive CSM shadows. (Components that do not receive CSM may have reduced shading cost)
    - ``receives_decals`` (bool):  [Read-Write] Whether the primitive receives decals.
    - ``relative_location`` (Vector):  [Read-Write] Location of the component relative to its parent
    - ``relative_rotation`` (Rotator):  [Read-Write] Rotation of the component relative to its parent
    - ``relative_scale3d`` (Vector):  [Read-Write] Non-uniform scaling of the component relative to its parent.
      Note that scaling is always applied in local space (no shearing etc)
    - ``render_custom_depth`` (bool):  [Read-Write] If true, this component will be rendered in the CustomDepth pass (usually used for outlines)
    - ``render_in_depth_pass`` (bool):  [Read-Write] If true, this component will be rendered in the depth pass even if it's not rendered in the main pass
    - ``render_in_main_pass`` (bool):  [Read-Write] If true, this component will be rendered in the main pass (z prepass, basepass, transparency)
    - ``render_static`` (bool):  [Read-Write] If true, render as static in reference pose.
    - ``replicate_physics_to_autonomous_proxy`` (bool):  [Read-Write] True if physics should be replicated to autonomous proxies. This should be true for
                    server-authoritative simulations, and false for client authoritative simulations.
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects list
      When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.
    - ``replicates`` (bool):  [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!
    - ``reset_after_teleport`` (bool):  [Read-Write] reset the clothing after moving the clothing position (called teleport)
    - ``return_material_on_move`` (bool):  [Read-Write] If true, component sweeps will return the material in their hit result.
      see: MoveComponent(), FHitResult
    - ``runtime_virtual_textures`` (Array[RuntimeVirtualTexture]):  [Read-Write] Array of runtime virtual textures into which we draw the mesh for this actor.
      The material also needs to be set up to output to a virtual texture.
    - ``self_shadow_only`` (bool):  [Read-Write] When enabled, the component will only cast a shadow on itself and not other components in the world.
      This is especially useful for first person weapons, and forces bCastInsetShadow to be enabled.
    - ``set_mesh_deformer`` (bool):  [Read-Write] If true, MeshDeformer will be used. If false, use the default mesh deformer on the SkeletalMesh.
    - ``shadow_cache_invalidation_behavior`` (ShadowCacheInvalidationBehavior):  [Read-Write] Control shadow invalidation behavior, in particular with respect to Virtual Shadow Maps and material effects like World Position Offset.
    - ``should_update_physics_volume`` (bool):  [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved.
      see: GetPhysicsVolume()
    - ``single_sample_shadow_from_stationary_lights`` (bool):  [Read-Write] Whether the whole component should be shadowed as one from stationary lights, which makes shadow receiving much cheaper.
      When enabled shadowing data comes from the volume lighting samples precomputed by Lightmass, which are very sparse.
      This is currently only used on stationary directional lights.
    - ``skeletal_mesh`` (SkeletalMesh):  [Read-Write]
      deprecated: Use USkeletalMeshComponent::GetSkeletalMeshAsset() or GetSkinnedAsset() instead.
    - ``skeletal_mesh_asset`` (SkeletalMesh):  [Read-Write]
    - ``skin_cache_usage`` (Array[SkinCacheUsage]):  [Read-Write] How this Component's LOD uses the skin cache feature. Auto will defer to the asset's (SkeletalMesh) option. If Ray Tracing is enabled, will imply Enabled
    - ``skinned_asset`` (SkinnedAsset):  [Read-Write]
    - ``skip_bounds_update_when_interpolating`` (bool):  [Read-Write] Whether to skip bounds update when interpolating. Bounds are updated to the target interpolation pose only on ticks when they are evaluated.
    - ``skip_kinematic_update_when_interpolating`` (bool):  [Read-Write] Whether to skip UpdateKinematicBonesToAnim() when interpolating. Kinematic bones are updated to the target interpolation pose only on ticks when they are evaluated.
    - ``static_when_not_moveable`` (bool):  [Read-Write] When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable
    - ``streaming_distance_multiplier`` (float):  [Read-Write] Allows adjusting the desired streaming distance of streaming textures that uses UV 0.
      1.0 is the default, whereas a higher value makes the textures stream in sooner from far away.
      A lower value (0.0-1.0) makes the textures stream in later (you have to be closer).
      Value can be < 0 (from legcay content, or code changes)
    - ``sync_attach_parent_lod`` (bool):  [Read-Write] If true, this component uses its parents LOD when attached if available
      ForcedLOD can override this change. By default, it will use parent LOD.
    - ``teleport_distance_threshold`` (float):  [Read-Write] Conduct teleportation if the character's movement is greater than this threshold in 1 frame.
      Zero or negative values will skip the check.
      You can also do force teleport manually using ForceNextUpdateTeleport() / ForceNextUpdateTeleportAndReset().
    - ``teleport_rotation_threshold`` (float):  [Read-Write] Rotation threshold in degrees, ranging from 0 to 180.
      Conduct teleportation if the character's rotation is greater than this threshold in 1 frame.
      Zero or negative values will skip the check.
    - ``trace_complex_on_move`` (bool):  [Read-Write] If true, component sweeps with this component should trace against complex collision during movement (for example, each triangle of a mesh).
      If false, collision will be resolved against simple collision bounds instead.
      see: MoveComponent()
    - ``translucency_sort_distance_offset`` (float):  [Read-Write] Modified sort distance offset for translucent objects in world units.
      A positive number will move the sort distance further and a negative number will move the distance closer.
      
      Ignored if the object is not translucent.
      Warning: Adjusting this value will prevent the renderer from correctly sorting based on distance.  Only modify this value if you are certain it will not cause visual artifacts.
    - ``translucency_sort_priority`` (int32):  [Read-Write] Translucent objects with a lower sort priority draw behind objects with a higher priority.
      Translucent objects with the same priority are rendered from back-to-front based on their bounds origin.
      This setting is also used to sort objects being drawn into a runtime virtual texture.
      
      Ignored if the object is not translucent.  The default priority is zero.
      Warning: This should never be set to a non-default value unless you know what you are doing, as it will prevent the renderer from sorting correctly.
      It is especially problematic on dynamic gameplay effects.
    - ``treat_as_background_for_occlusion`` (bool):  [Read-Write] Treat this primitive as part of the background for occlusion purposes. This can be used as an optimization to reduce the cost of rendering skyboxes, large ground planes that are part of the vista, etc.
    - ``update_animation_in_editor`` (bool):  [Read-Write] If true, this will Tick until disabled
    - ``update_cloth_in_editor`` (bool):  [Read-Write] If true, will play cloth in editor
    - ``update_joints_from_animation`` (bool):  [Read-Write] If we should pass joint position to joints each frame, so that they can be used by motorized joints to drive the
      ragdoll based on the animation.
    - ``update_mesh_when_kinematic`` (bool):  [Read-Write] If true, then the physics bodies will be used to drive the skeletal mesh even when they are
      kinematic (not simulating), otherwise the skeletal mesh will be driven by the animation input
      when the bodies are kinematic
    - ``update_overlaps_on_animation_finalize`` (bool):  [Read-Write] Controls whether blending in physics bones will refresh overlaps on this component, defaults to true but can be disabled in cases where we know anim->physics blending doesn't meaningfully change overlaps
    - ``use_as_occluder`` (bool):  [Read-Write] Whether to render the primitive in the depth only pass.
      This should generally be true for all objects, and let the renderer make decisions about whether to render objects in the depth only pass.
      todo: if any rendering features rely on a complete depth only pass, this variable needs to go away.
    - ``use_attach_parent_bound`` (bool):  [Read-Write] If true, this component uses its parents bounds when attached.
      This can be a significant optimization with many components attached together.
    - ``use_bounds_from_leader_pose_component`` (bool):  [Read-Write] When true, we will just using the bounds from our LeaderPoseComponent.  This is useful for when we have a Mesh Parented
      to the main SkelMesh (e.g. outline mesh or a full body overdraw effect that is toggled) that is always going to be the same
      bounds as parent.  We want to do no calculations in that case.
    - ``use_ref_pose_on_init_anim`` (bool):  [Read-Write] On InitAnim should we set to ref pose (if false use first tick of animation data). If enabled, takes precedence over UAnimationSettings::bTickAnimationOnSkeletalMeshInit
    - ``virtual_texture_cull_mips`` (int8):  [Read-Write] Number of lower mips in the runtime virtual texture to skip for rendering this primitive.
      Larger values reduce the effective draw distance in the runtime virtual texture.
      This culling method doesn't take into account primitive size or virtual texture size.
    - ``virtual_texture_lod_bias`` (int8):  [Read-Write] Bias to the LOD selected for rendering to runtime virtual textures.
    - ``virtual_texture_min_coverage`` (int8):  [Read-Write] Set the minimum pixel coverage before culling from the runtime virtual texture.
      Larger values reduce the effective draw distance in the runtime virtual texture.
    - ``virtual_texture_render_pass_type`` (RuntimeVirtualTextureMainPassType):  [Read-Write] Controls if this component draws in the main pass as well as in the virtual texture.
    - ``visibility_based_anim_tick_option`` (VisibilityBasedAnimTickOption):  [Read-Write] * This is tick animation frequency option based on this component rendered or not or using montage
      *  You can change this default value in the INI file
      * Mostly related with performance
    - ``visible`` (bool):  [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.
    - ``visible_in_ray_tracing`` (bool):  [Read-Write] If true, this component will be visible in ray tracing effects. Turning this off will remove it from ray traced reflections, shadows, etc.
    - ``visible_in_real_time_sky_captures`` (bool):  [Read-Write] If true, this component will be visible in real-time sky light reflection captures.
    - ``visible_in_reflection_captures`` (bool):  [Read-Write] If true, this component will be visible in reflection captures.
    - ``visible_in_scene_capture_only`` (bool):  [Read-Write] When true, will only be visible in Scene Capture
    - ``wait_for_parallel_cloth_task`` (bool):  [Read-Write] Whether we should stall the Cloth tick task until the cloth simulation is complete. This is required if we want up-to-date
      cloth data on the game thread, for example if we want to generate particles at cloth vertices.
    """
    ...

class ControlRigSnapSettings(Object):
    r"""
    Control Rig Snap Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: ControlRigSnapSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``baking_key_settings`` (BakingKeySettings):  [Read-Write]
    - ``frame_increment`` (int32):  [Read-Write]
    - ``keep_offset`` (bool):  [Read-Write] When snapping keep offset, if false snap completely
    - ``reduce_keys`` (bool):  [Read-Write]
    - ``snap_position`` (bool):  [Read-Write] When snapping, also snap position
    - ``snap_rotation`` (bool):  [Read-Write] When snapping, also snap rotation
    - ``snap_scale`` (bool):  [Read-Write] When snapping, also snap scale
    - ``tolerance`` (float):  [Read-Write]
    """
    @property
    def keep_offset(self) -> bool:
        r"""
        (bool):  [Read-Write] When snapping keep offset, if false snap completely
        """
        ...
    @keep_offset.setter
    def keep_offset(self, value: bool) -> None:
        ...
    @property
    def snap_position(self) -> bool:
        r"""
        (bool):  [Read-Write] When snapping, also snap position
        """
        ...
    @snap_position.setter
    def snap_position(self, value: bool) -> None:
        ...
    @property
    def snap_rotation(self) -> bool:
        r"""
        (bool):  [Read-Write] When snapping, also snap rotation
        """
        ...
    @snap_rotation.setter
    def snap_rotation(self, value: bool) -> None:
        ...
    @property
    def snap_scale(self) -> bool:
        r"""
        (bool):  [Read-Write] When snapping, also snap scale
        """
        ...
    @snap_scale.setter
    def snap_scale(self, value: bool) -> None:
        ...
    @property
    def baking_key_settings(self) -> BakingKeySettings:
        r"""
        (BakingKeySettings):  [Read-Write]
        """
        ...
    @baking_key_settings.setter
    def baking_key_settings(self, value: BakingKeySettings) -> None:
        ...
    @property
    def frame_increment(self) -> int:
        r"""
        (int32):  [Read-Write]
        """
        ...
    @frame_increment.setter
    def frame_increment(self, value: int) -> None:
        ...
    @property
    def reduce_keys(self) -> bool:
        r"""
        (bool):  [Read-Write]
        """
        ...
    @reduce_keys.setter
    def reduce_keys(self, value: bool) -> None:
        ...
    @property
    def tolerance(self) -> float:
        r"""
        (float):  [Read-Write]
        """
        ...
    @tolerance.setter
    def tolerance(self, value: float) -> None:
        ...

class CreateControlPoseAssetRigSettings(Object):
    r"""
    Create Control Pose Asset Rig Settings
    
    **C++ Source:**
    
    - **Plugin**: ControlRig
    - **Module**: ControlRigEditor
    - **File**: CreateControlAssetRigSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_name`` (str):  [Read-Write] Asset Name
    """
    ...

class CameraAssetFactory(Factory):
    r"""
    Implements a factory for UCameraAsset objects.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCamerasEditor
    - **File**: CameraAssetFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class CameraModeFactory(Factory):
    r"""
    Implements a factory for UCameraMode objects.
    
    **C++ Source:**
    
    - **Plugin**: GameplayCameras
    - **Module**: GameplayCamerasEditor
    - **File**: CameraModeFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class LevelSequenceFactoryNew(Factory):
    r"""
    Implements a factory for ULevelSequence objects.
    
    **C++ Source:**
    
    - **Plugin**: LevelSequenceEditor
    - **Module**: LevelSequenceEditor
    - **File**: LevelSequenceFactoryNew.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class LevelSequenceEditorBlueprintLibrary(BlueprintFunctionLibrary):
    r"""
    Level Sequence Editor Blueprint Library
    
    **C++ Source:**
    
    - **Plugin**: LevelSequenceEditor
    - **Module**: LevelSequenceEditor
    - **File**: LevelSequenceEditorBlueprintLibrary.h
    
    """
    @classmethod
    def set_track_filter_enabled(cls, track_filter_name: Text, enabled: bool) -> None:
        r"""
        X.set_track_filter_enabled(track_filter_name, enabled) -> None
        Sets the specified track filter to be on or off
        
        Args:
            track_filter_name (Text): 
            enabled (bool):
        """
        ...
    @classmethod
    def set_selection_range_start(cls, new_frame: int) -> None:
        r"""
        X.set_selection_range_start(new_frame) -> None
        Set the selection range start frame.
        
        Args:
            new_frame (int32):
        """
        ...
    @classmethod
    def set_selection_range_end(cls, new_frame: int) -> None:
        r"""
        X.set_selection_range_end(new_frame) -> None
        Set the selection range end frame.
        
        Args:
            new_frame (int32):
        """
        ...
    @classmethod
    def set_random_color_for_channels(cls, class_: Class, identifiers: Array[str]) -> None:
        r"""
        X.set_random_color_for_channels(class_, identifiers) -> None
        Set Random Color for Channels
        deprecated: Use USequencerCurveEditorObject::SetRandomColorForChannels
        
        Args:
            class_ (type(Class)): 
            identifiers (Array[str]):
        """
        ...
    @classmethod
    def set_playback_speed(cls, new_playback_speed: float) -> None:
        r"""
        X.set_playback_speed(new_playback_speed) -> None
        Set playback speed of the current level sequence
        
        Args:
            new_playback_speed (float):
        """
        ...
    @classmethod
    def set_loop_mode(cls, new_loop_mode: SequencerLoopMode) -> None:
        r"""
        X.set_loop_mode(new_loop_mode) -> None
        Set loop mode (note this is a per user preference)
        
        Args:
            new_loop_mode (SequencerLoopMode):
        """
        ...
    @classmethod
    def set_lock_level_sequence(cls, lock: bool) -> None:
        r"""
        X.set_lock_level_sequence(lock) -> None
        Sets the lock for the current level sequence and its descendants for editing.
        
        Args:
            lock (bool):
        """
        ...
    @classmethod
    def set_lock_camera_cut_to_viewport(cls, lock: bool) -> None:
        r"""
        X.set_lock_camera_cut_to_viewport(lock) -> None
        Sets the lock for the viewport to the camera cuts.
        
        Args:
            lock (bool):
        """
        ...
    @classmethod
    def set_local_position(cls, playback_params: MovieSceneSequencePlaybackParams, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_local_position(playback_params, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set local playhead position for the current level sequence. If the requested time is the same as the current time, an evaluation will be forced.
        
        Args:
            playback_params (MovieSceneSequencePlaybackParams): 
            time_unit (MovieSceneTimeUnit):
        """
        ...
    @classmethod
    def set_global_position(cls, playback_params: MovieSceneSequencePlaybackParams, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.set_global_position(playback_params, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Set global playhead position for the current level sequence. If the requested time is the same as the current time, an evaluation will be forced.
        
        Args:
            playback_params (MovieSceneSequencePlaybackParams): 
            time_unit (MovieSceneTimeUnit):
        """
        ...
    @classmethod
    def set_custom_color_for_channels(cls, class_: Class, identifiers: Array[str], new_colors: Array[LinearColor]) -> None:
        r"""
        X.set_custom_color_for_channels(class_, identifiers, new_colors) -> None
        Set Custom Color for Channels
        deprecated: Use USequencerCurveEditorObject::DeleteColorForChannels
        
        Args:
            class_ (type(Class)): 
            identifiers (Array[str]): 
            new_colors (Array[LinearColor]):
        """
        ...
    @classmethod
    def set_custom_color_for_channel(cls, class_: Class, identifier: str, new_color: LinearColor) -> None:
        r"""
        X.set_custom_color_for_channel(class_, identifier, new_color) -> None
        Set Custom Color for Channel
        deprecated: Use USequencerCurveEditorObject::SetCustomColorForChannel
        
        Args:
            class_ (type(Class)): 
            identifier (str): 
            new_color (LinearColor):
        """
        ...
    @classmethod
    def set_current_time(cls, new_frame: int) -> None:
        r"""
        X.set_current_time(new_frame) -> None
        Set Current Time
        deprecated: Use SetCurrentTime that takes a FMovieSceneSequencePlaybackParams
        
        Args:
            new_frame (int32):
        """
        ...
    @classmethod
    def set_current_local_time(cls, new_frame: int) -> None:
        r"""
        X.set_current_local_time(new_frame) -> None
        Set Current Local Time
        deprecated: Use SetCurrentLocalTime that takes a FMovieSceneSequencePlaybackParams
        
        Args:
            new_frame (int32):
        """
        ...
    @classmethod
    def select_tracks(cls, tracks: Array[MovieSceneTrack]) -> None:
        r"""
        X.select_tracks(tracks) -> None
        Select tracks
        
        Args:
            tracks (Array[MovieSceneTrack]):
        """
        ...
    @classmethod
    def select_sections(cls, sections: Array[MovieSceneSection]) -> None:
        r"""
        X.select_sections(sections) -> None
        Select sections
        
        Args:
            sections (Array[MovieSceneSection]):
        """
        ...
    @classmethod
    def select_keys(cls, channel: SequencerChannelProxy, indices: Array[int]) -> None:
        r"""
        X.select_keys(channel, indices) -> None
        Select keys from indices
        
        Args:
            channel (SequencerChannelProxy): 
            indices (Array[int32]):
        """
        ...
    @classmethod
    def select_folders(cls, folders: Array[MovieSceneFolder]) -> None:
        r"""
        X.select_folders(folders) -> None
        Select folders
        
        Args:
            folders (Array[MovieSceneFolder]):
        """
        ...
    @classmethod
    def select_channels(cls, channels: Array[SequencerChannelProxy]) -> None:
        r"""
        X.select_channels(channels) -> None
        Select channels
        
        Args:
            channels (Array[SequencerChannelProxy]):
        """
        ...
    @classmethod
    def select_bindings(cls, object_bindings: Array[MovieSceneBindingProxy]) -> None:
        r"""
        X.select_bindings(object_bindings) -> None
        Select bindings
        
        Args:
            object_bindings (Array[MovieSceneBindingProxy]):
        """
        ...
    @classmethod
    def refresh_current_level_sequence(cls) -> None:
        r"""
        X.refresh_current_level_sequence() -> None
        Refresh Sequencer UI.
        """
        ...
    @classmethod
    def play_to(cls, playback_params: MovieSceneSequencePlaybackParams, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> None:
        r"""
        X.play_to(playback_params, time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> None
        Play from the current time to the requested time in frames
        
        Args:
            playback_params (MovieSceneSequencePlaybackParams): 
            time_unit (MovieSceneTimeUnit):
        """
        ...
    @classmethod
    def play(cls) -> None:
        r"""
        X.play() -> None
        Play the current level sequence
        """
        ...
    @classmethod
    def pause(cls) -> None:
        r"""
        X.pause() -> None
        Pause the current level sequence
        """
        ...
    @classmethod
    def open_level_sequence(cls, level_sequence: LevelSequence) -> bool:
        r"""
        X.open_level_sequence(level_sequence) -> bool
        * Open a level sequence asset
        
        Args:
            level_sequence (LevelSequence): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_track_filter_enabled(cls, track_filter_name: Text) -> bool:
        r"""
        X.is_track_filter_enabled(track_filter_name) -> bool
        Gets whether the specified track filter is on/off
        
        Args:
            track_filter_name (Text): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_playing(cls) -> bool:
        r"""
        X.is_playing() -> bool
        Check whether the sequence is actively playing.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_level_sequence_locked(cls) -> bool:
        r"""
        X.is_level_sequence_locked() -> bool
        Check whether the current level sequence and its descendants are locked for editing.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def is_camera_cut_locked_to_viewport(cls) -> bool:
        r"""
        X.is_camera_cut_locked_to_viewport() -> bool
        Check whether the lock for the viewport to the camera cuts is enabled.
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def has_custom_color_for_channel(cls, class_: Class, identifier: str) -> bool:
        r"""
        X.has_custom_color_for_channel(class_, identifier) -> bool
        Has Custom Color for Channel
        deprecated: Use USequencerCurveEditorObject::HasCustomColorForChannel
        
        Args:
            class_ (type(Class)): 
            identifier (str): 
        
        Returns:
            bool:
        """
        ...
    @classmethod
    def get_track_filter_names(cls) -> Array[Text]:
        r"""
        X.get_track_filter_names() -> Array[Text]
        Gets all the available track filter names
        
        Returns:
            Array[Text]:
        """
        ...
    @classmethod
    def get_sub_sequence_hierarchy(cls) -> Array[MovieSceneSubSection]:
        r"""
        X.get_sub_sequence_hierarchy() -> Array[MovieSceneSubSection]
        * Get the current sub section hierarchy from the current sequence to the section associated with the focused sequence.
        
        Returns:
            Array[MovieSceneSubSection]:
        """
        ...
    @classmethod
    def get_selection_range_start(cls) -> int:
        r"""
        X.get_selection_range_start() -> int32
        Get the selection range start frame.
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_selection_range_end(cls) -> int:
        r"""
        X.get_selection_range_end() -> int32
        Get the selection range end frame.
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_selected_tracks(cls) -> Array[MovieSceneTrack]:
        r"""
        X.get_selected_tracks() -> Array[MovieSceneTrack]
        Gets the currently selected tracks.
        
        Returns:
            Array[MovieSceneTrack]:
        """
        ...
    @classmethod
    def get_selected_sections(cls) -> Array[MovieSceneSection]:
        r"""
        X.get_selected_sections() -> Array[MovieSceneSection]
        Gets the currently selected sections.
        
        Returns:
            Array[MovieSceneSection]:
        """
        ...
    @classmethod
    def get_selected_keys(cls, channel_proxy: SequencerChannelProxy) -> Array[int]:
        r"""
        X.get_selected_keys(channel_proxy) -> Array[int32]
        Gets the selected key indices with this channel
        
        Args:
            channel_proxy (SequencerChannelProxy): 
        
        Returns:
            Array[int32]:
        """
        ...
    @classmethod
    def get_selected_folders(cls) -> Array[MovieSceneFolder]:
        r"""
        X.get_selected_folders() -> Array[MovieSceneFolder]
        Gets the currently selected folders.
        
        Returns:
            Array[MovieSceneFolder]:
        """
        ...
    @classmethod
    def get_selected_channels(cls) -> Array[SequencerChannelProxy]:
        r"""
        X.get_selected_channels() -> Array[SequencerChannelProxy]
        Gets the currently selected channels.
        
        Returns:
            Array[SequencerChannelProxy]:
        """
        ...
    @classmethod
    def get_selected_bindings(cls) -> Array[MovieSceneBindingProxy]:
        r"""
        X.get_selected_bindings() -> Array[MovieSceneBindingProxy]
        Gets the currently selected object bindings
        
        Returns:
            Array[MovieSceneBindingProxy]:
        """
        ...
    @classmethod
    def get_playback_speed(cls) -> float:
        r"""
        X.get_playback_speed() -> float
        Get playback speed of the current level sequence
        
        Returns:
            float:
        """
        ...
    @classmethod
    def get_loop_mode(cls) -> SequencerLoopMode:
        r"""
        X.get_loop_mode() -> SequencerLoopMode
        Get loop mode (note this is a per user preference)
        
        Returns:
            SequencerLoopMode:
        """
        ...
    @classmethod
    def get_local_position(cls, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneSequencePlaybackParams:
        r"""
        X.get_local_position(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneSequencePlaybackParams
        Get the current local playhead position
        
        Args:
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            MovieSceneSequencePlaybackParams:
        """
        ...
    @classmethod
    def get_global_position(cls, time_unit: MovieSceneTimeUnit = MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneSequencePlaybackParams:
        r"""
        X.get_global_position(time_unit=MovieSceneTimeUnit.DISPLAY_RATE) -> MovieSceneSequencePlaybackParams
        Get the current global playhead position
        
        Args:
            time_unit (MovieSceneTimeUnit): 
        
        Returns:
            MovieSceneSequencePlaybackParams:
        """
        ...
    @classmethod
    def get_focused_level_sequence(cls) -> LevelSequence:
        r"""
        X.get_focused_level_sequence() -> LevelSequence
        * Get the currently focused/viewed level sequence asset if there is a hierarchy of sequences.
        
        Returns:
            LevelSequence:
        """
        ...
    @classmethod
    def get_custom_color_for_channel(cls, class_: Class, identifier: str) -> LinearColor:
        r"""
        X.get_custom_color_for_channel(class_, identifier) -> LinearColor
        Get Custom Color for Channel
        deprecated: Use USequencerCurveEditorObject::HasCustomColorForChannel
        
        Args:
            class_ (type(Class)): 
            identifier (str): 
        
        Returns:
            LinearColor:
        """
        ...
    @classmethod
    def get_current_time(cls) -> int:
        r"""
        X.get_current_time() -> int32
        Get Current Time
        deprecated: Use GetCurrentTime that returns a FMovieSceneSequencePlaybackParams
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_current_local_time(cls) -> int:
        r"""
        X.get_current_local_time() -> int32
        Get Current Local Time
        deprecated: Use GetCurrentLocalTime that returns a FMovieSceneSequencePlaybackParams
        
        Returns:
            int32:
        """
        ...
    @classmethod
    def get_current_level_sequence(cls) -> LevelSequence:
        r"""
        X.get_current_level_sequence() -> LevelSequence
        * Get the currently opened root level sequence asset
        
        Returns:
            LevelSequence:
        """
        ...
    @classmethod
    def get_channels_with_selected_keys(cls) -> Array[SequencerChannelProxy]:
        r"""
        X.get_channels_with_selected_keys() -> Array[SequencerChannelProxy]
        Gets the channel with selected keys.
        
        Returns:
            Array[SequencerChannelProxy]:
        """
        ...
    @classmethod
    def get_bound_objects(cls, object_binding: MovieSceneObjectBindingID) -> Array[Object]:
        r"""
        X.get_bound_objects(object_binding) -> Array[Object]
        Get the object bound to the given binding ID with the current level sequence editor
        
        Args:
            object_binding (MovieSceneObjectBindingID): 
        
        Returns:
            Array[Object]:
        """
        ...
    @classmethod
    def focus_parent_sequence(cls) -> None:
        r"""
        X.focus_parent_sequence() -> None
        * Focus/view the parent sequence, popping out of the current sub sequence section.
        """
        ...
    @classmethod
    def focus_level_sequence(cls, sub_section: MovieSceneSubSection) -> None:
        r"""
        X.focus_level_sequence(sub_section) -> None
        * Focus/view the sequence associated to the given sub sequence section.
        
        Args:
            sub_section (MovieSceneSubSection):
        """
        ...
    @classmethod
    def empty_selection(cls) -> None:
        r"""
        X.empty_selection() -> None
        Empties the current selection.
        """
        ...
    @classmethod
    def delete_color_for_channels(cls, class_: Class) -> str:
        r"""
        X.delete_color_for_channels(class_) -> str
        Delete Color for Channels
        deprecated: Use USequencerCurveEditorObject::DeleteColorForChannels
        
        Args:
            class_ (type(Class)): 
        
        Returns:
            str: 
        
            identifier (str):
        """
        ...
    @classmethod
    def close_level_sequence(cls) -> None:
        r"""
        X.close_level_sequence() -> None
        * Close
        """
        ...

class LevelSequenceEditorSubsystem(EditorSubsystem):
    r"""
    ULevelSequenceEditorSubsystem
    Subsystem for level sequence editor related utilities to scripts
    
    **C++ Source:**
    
    - **Plugin**: LevelSequenceEditor
    - **Module**: LevelSequenceEditor
    - **File**: LevelSequenceEditorSubsystem.h
    
    """
    def sync_sections_using_source_timecode(self, sections: Array[MovieSceneSection]) -> None:
        r"""
        x.sync_sections_using_source_timecode(sections) -> None
        Sync section using source timecode
        
        Args:
            sections (Array[MovieSceneSection]):
        """
        ...
    def snap_sections_to_timeline_using_source_timecode(self, sections: Array[MovieSceneSection]) -> None:
        r"""
        x.snap_sections_to_timeline_using_source_timecode(sections) -> None
        Snap sections to timeline using source timecode
        
        Args:
            sections (Array[MovieSceneSection]):
        """
        ...
    def replace_binding_with_actors(self, actors: Array[Actor], object_binding: MovieSceneBindingProxy) -> None:
        r"""
        x.replace_binding_with_actors(actors, object_binding) -> None
        Replaces the binding with the given actors
        
        Args:
            actors (Array[Actor]): 
            object_binding (MovieSceneBindingProxy):
        """
        ...
    def remove_invalid_bindings(self, object_binding: MovieSceneBindingProxy) -> None:
        r"""
        x.remove_invalid_bindings(object_binding) -> None
        Remove missing objects bound to this track
        
        Args:
            object_binding (MovieSceneBindingProxy):
        """
        ...
    def remove_all_bindings(self, object_binding: MovieSceneBindingProxy) -> None:
        r"""
        x.remove_all_bindings(object_binding) -> None
        Remove all bound actors from this track
        
        Args:
            object_binding (MovieSceneBindingProxy):
        """
        ...
    def remove_actors_from_binding(self, actors: Array[Actor], object_binding: MovieSceneBindingProxy) -> None:
        r"""
        x.remove_actors_from_binding(actors, object_binding) -> None
        Removes the given actors from the binding
        
        Args:
            actors (Array[Actor]): 
            object_binding (MovieSceneBindingProxy):
        """
        ...
    def rebind_component(self, component_bindings: Array[MovieSceneBindingProxy], component_name: Name) -> None:
        r"""
        x.rebind_component(component_bindings, component_name) -> None
        Rebind the component binding to the requested component
        
        Args:
            component_bindings (Array[MovieSceneBindingProxy]): 
            component_name (Name):
        """
        ...
    def paste_tracks(self, text_to_import: str, paste_tracks_params: MovieScenePasteTracksParams) -> Optional[Array[MovieSceneTrack]]:
        r"""
        x.paste_tracks(text_to_import, paste_tracks_params) -> Array[MovieSceneTrack] or None
        Paste tracks
        Paste tracks from the given TextToImport string (used in conjunction with CopyTracks).
        If TextToImport is empty, the contents of the clipboard will be used.
        
        Args:
            text_to_import (str): 
            paste_tracks_params (MovieScenePasteTracksParams): 
        
        Returns:
            Array[MovieSceneTrack] or None: 
        
            out_tracks (Array[MovieSceneTrack]):
        """
        ...
    def paste_sections(self, text_to_import: str, paste_sections_params: MovieScenePasteSectionsParams) -> Optional[Array[MovieSceneSection]]:
        r"""
        x.paste_sections(text_to_import, paste_sections_params) -> Array[MovieSceneSection] or None
        Paste sections
        Paste sections from the given TextToImport string (used in conjunction with CopySections).
        If TextToImport is empty, the contents of the clipboard will be used.
        
        Args:
            text_to_import (str): 
            paste_sections_params (MovieScenePasteSectionsParams): 
        
        Returns:
            Array[MovieSceneSection] or None: 
        
            out_sections (Array[MovieSceneSection]):
        """
        ...
    def paste_folders(self, text_to_import: str, paste_folders_params: MovieScenePasteFoldersParams) -> Optional[Array[MovieSceneFolder]]:
        r"""
        x.paste_folders(text_to_import, paste_folders_params) -> Array[MovieSceneFolder] or None
        Paste folders
        Paste folders from the given TextToImport string (used in conjunction with CopyFolders).
        If TextToImport is empty, the contents of the clipboard will be used.
        
        Args:
            text_to_import (str): 
            paste_folders_params (MovieScenePasteFoldersParams): 
        
        Returns:
            Array[MovieSceneFolder] or None: 
        
            out_folders (Array[MovieSceneFolder]):
        """
        ...
    def paste_bindings(self, text_to_import: str, paste_bindings_params: MovieScenePasteBindingsParams) -> Optional[Array[MovieSceneBindingProxy]]:
        r"""
        x.paste_bindings(text_to_import, paste_bindings_params) -> Array[MovieSceneBindingProxy] or None
        Paste bindings
        Paste bindings from the given TextToImport string (used in conjunction with CopyBindings).
        If TextToImport is empty, the contents of the clipboard will be used.
        
        Args:
            text_to_import (str): 
            paste_bindings_params (MovieScenePasteBindingsParams): 
        
        Returns:
            Array[MovieSceneBindingProxy] or None: 
        
            out_object_bindings (Array[MovieSceneBindingProxy]):
        """
        ...
    def get_scripting_layer(self) -> SequencerModuleScriptingLayer:
        r"""
        x.get_scripting_layer() -> SequencerModuleScriptingLayer
        Retrieve the scripting layer
        
        Returns:
            SequencerModuleScriptingLayer:
        """
        ...
    def get_curve_editor(self) -> SequencerCurveEditorObject:
        r"""
        x.get_curve_editor() -> SequencerCurveEditorObject
        Retrieve the curve editor
        
        Returns:
            SequencerCurveEditorObject:
        """
        ...
    def fix_actor_references(self) -> None:
        r"""
        x.fix_actor_references() -> None
        Attempts to automatically fix up broken actor references in the current scene
        """
        ...
    def create_camera(self, spawnable: bool) -> Tuple[MovieSceneBindingProxy, CineCameraActor]:
        r"""
        x.create_camera(spawnable) -> (MovieSceneBindingProxy, out_actor=CineCameraActor)
        Create a cine camera actor and add it to Sequencer
        
        Args:
            spawnable (bool): 
        
        Returns:
            CineCameraActor: 
        
            out_actor (CineCameraActor):
        """
        ...
    def copy_tracks(self, tracks: Array[MovieSceneTrack]) -> str:
        r"""
        x.copy_tracks(tracks) -> str
        Copy tracks
        The copied tracks will be saved to the clipboard as well as assigned to the ExportedText string.
        The ExportedTest string can be used in conjunction with PasteTracks if, for example, pasting copy/pasting multiple
        tracks without relying on a single clipboard.
        
        Args:
            tracks (Array[MovieSceneTrack]): 
        
        Returns:
            str: 
        
            exported_text (str):
        """
        ...
    def copy_sections(self, sections: Array[MovieSceneSection]) -> str:
        r"""
        x.copy_sections(sections) -> str
        Copy sections
        The copied sections will be saved to the clipboard as well as assigned to the ExportedText string.
        The ExportedTest string can be used in conjunction with PasteSections if, for example, pasting copy/pasting multiple
        sections without relying on a single clipboard.
        
        Args:
            sections (Array[MovieSceneSection]): 
        
        Returns:
            str: 
        
            exported_text (str):
        """
        ...
    def copy_folders(self, folders: Array[MovieSceneFolder]) -> str:
        r"""
        x.copy_folders(folders) -> str
        Copy folders
        The copied folders will be saved to the clipboard as well as assigned to the ExportedText string.
        The ExportedTest string can be used in conjunction with PasteFolders if, for example, pasting copy/pasting multiple
        folders without relying on a single clipboard.
        
        Args:
            folders (Array[MovieSceneFolder]): 
        
        Returns:
            str: 
        
            exported_text (str):
        """
        ...
    def copy_bindings(self, bindings: Array[MovieSceneBindingProxy]) -> str:
        r"""
        x.copy_bindings(bindings) -> str
        Copy bindings
        The copied bindings will be saved to the clipboard as well as assigned to the ExportedText string.
        The ExportedTest string can be used in conjunction with PasteBindings if, for example, pasting copy/pasting multiple
        bindings without relying on a single clipboard.
        
        Args:
            bindings (Array[MovieSceneBindingProxy]): 
        
        Returns:
            str: 
        
            exported_text (str):
        """
        ...
    def convert_to_spawnable(self, object_binding: MovieSceneBindingProxy) -> Array[MovieSceneBindingProxy]:
        r"""
        x.convert_to_spawnable(object_binding) -> Array[MovieSceneBindingProxy]
        Convert to spawnable. If there are multiple objects assigned to the possessable, multiple spawnables will be created.
        
        Args:
            object_binding (MovieSceneBindingProxy): 
        
        Returns:
            Array[MovieSceneBindingProxy]:
        """
        ...
    def convert_to_possessable(self, object_binding: MovieSceneBindingProxy) -> MovieSceneBindingProxy:
        r"""
        x.convert_to_possessable(object_binding) -> MovieSceneBindingProxy
        Convert to possessable
        
        Args:
            object_binding (MovieSceneBindingProxy): 
        
        Returns:
            MovieSceneBindingProxy:
        """
        ...
    def bake_transform_with_settings(self, object_bindings: Array[MovieSceneBindingProxy], settings: BakingAnimationKeySettings, params: MovieSceneScriptingParams = [MovieSceneTimeUnit.DISPLAY_RATE]) -> bool:
        r"""
        x.bake_transform_with_settings(object_bindings, settings, params=[MovieSceneTimeUnit.DISPLAY_RATE]) -> bool
        Bake Transform with Settings
        
        Args:
            object_bindings (Array[MovieSceneBindingProxy]): 
            settings (BakingAnimationKeySettings): 
            params (MovieSceneScriptingParams): 
        
        Returns:
            bool:
        """
        ...
    def bake_transform(self, object_bindings: Array[MovieSceneBindingProxy], bake_in_time: FrameTime, bake_out_time: FrameTime, bake_interval: FrameTime, params: MovieSceneScriptingParams = [MovieSceneTimeUnit.DISPLAY_RATE]) -> None:
        r"""
        x.bake_transform(object_bindings, bake_in_time, bake_out_time, bake_interval, params=[MovieSceneTimeUnit.DISPLAY_RATE]) -> None
        Bake Transform
        
        Args:
            object_bindings (Array[MovieSceneBindingProxy]): 
            bake_in_time (FrameTime): 
            bake_out_time (FrameTime): 
            bake_interval (FrameTime): 
            params (MovieSceneScriptingParams):
        """
        ...
    def add_actors_to_binding(self, actors: Array[Actor], object_binding: MovieSceneBindingProxy) -> None:
        r"""
        x.add_actors_to_binding(actors, object_binding) -> None
        Assigns the given actors to the binding
        
        Args:
            actors (Array[Actor]): 
            object_binding (MovieSceneBindingProxy):
        """
        ...
    def add_actors(self, actors: Array[Actor]) -> Array[MovieSceneBindingProxy]:
        r"""
        x.add_actors(actors) -> Array[MovieSceneBindingProxy]
        Add existing actors to Sequencer. Tracks will be automatically added based on default track settings.
        
        Args:
            actors (Array[Actor]): 
        
        Returns:
            Array[MovieSceneBindingProxy]:
        """
        ...

class LevelSequenceWithShotsSettings(Object):
    r"""
    Level Sequence With Shots Settings.
    
    **C++ Source:**
    
    - **Plugin**: LevelSequenceEditor
    - **Module**: LevelSequenceEditor
    - **File**: LevelSequenceEditorSettings.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``base_path`` (DirectoryPath):  [Read-Write] Sequence With Shots path.
    - ``instance_sub_sequences`` (bool):  [Read-Write] Whether to instance sub sequences based on the first created sub sequences.
    - ``name`` (str):  [Read-Write] Sequence With Shots name.
    - ``num_shots`` (uint32):  [Read-Write] Sequence With Shots number of shots.
    - ``sequence_to_duplicate`` (LevelSequence):  [Read-Write] Sequence With Shots level sequence to duplicate when creating shots.
    - ``sub_sequence_names`` (Array[Name]):  [Read-Write] Array of sub sequence names, each will result in a level sequence asset in the shot.
    - ``suffix`` (str):  [Read-Write] Sequence With Shots suffix.
    """
    @property
    def sub_sequence_names(self) -> Array[Name]:
        r"""
        (Array[Name]):  [Read-Write] Array of sub sequence names, each will result in a level sequence asset in the shot.
        """
        ...
    @sub_sequence_names.setter
    def sub_sequence_names(self, value: Array[Name]) -> None:
        ...

class IKRetargetBatchOperation(Object):
    r"""
    Encapsulate ability to batch duplicate and retarget a set of animation assets
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: IKRetargetBatchOperation.h
    
    """
    @classmethod
    def duplicate_and_retarget(cls, assets_to_retarget: Array[AssetData], source_mesh: SkeletalMesh, target_mesh: SkeletalMesh, ik_retarget_asset: IKRetargeter, search: str = "", replace: str = "", prefix: str = "", suffix: str = "", include_referenced_assets: bool = True) -> Array[AssetData]:
        r"""
        X.duplicate_and_retarget(assets_to_retarget, source_mesh, target_mesh, ik_retarget_asset, search="", replace="", prefix="", suffix="", include_referenced_assets=True) -> Array[AssetData]
        Convenience function to run a batch animation retarget from Blueprint / Python. This function will duplicate a list of
               * assets and use the supplied IK Retargeter to retarget the animation from the source to the target using the
               * settings in the provided IK Retargeter asset.
               *
               *
        
        Args:
            assets_to_retarget (Array[AssetData]): A list of animation assets to retarget (sequences, blendspaces or montages) *
            source_mesh (SkeletalMesh): The skeletal mesh with desired proportions to playback the assets to retarget *
            target_mesh (SkeletalMesh): The skeletal mesh to retarget the animation onto. *
            ik_retarget_asset (IKRetargeter): The IK Retargeter asset with IK Rigs appropriate for the source and target skeletal mesh *
            search (str): A string to search for in the file name (replaced with "Replace" string) *
            replace (str): A string to replace with in the file name *
            prefix (str): A string to add to the start of the new file name *
            suffix (str): A string to add at the end of the new file name *
            include_referenced_assets (bool): 
        
        Returns:
            Array[AssetData]:
        """
        ...

class BatchExportOptions(Object):
    r"""
    settings object used in details view of the batch retarget window
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: SRetargetAnimAssetsWindow.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``include_referenced_assets`` (bool):  [Read-Write] Duplicates and retargets any animation assets referenced by the input assets. For example, sequences in an animation blueprint or blendspace.
    - ``overwrite_existing_files`` (bool):  [Read-Write] Any files with the same name will be overwritten instead of creating a new file with a numeric suffix.
      This is useful when iterating on a batch process.
    """
    @property
    def include_referenced_assets(self) -> bool:
        r"""
        (bool):  [Read-Write] Duplicates and retargets any animation assets referenced by the input assets. For example, sequences in an animation blueprint or blendspace.
        """
        ...
    @include_referenced_assets.setter
    def include_referenced_assets(self, value: bool) -> None:
        ...

class BatchRetargetSettings(Object):
    r"""
    settings object used in details view of the batch retarget window
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: SRetargetAnimAssetsWindow.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``auto_generate_retargeter`` (bool):  [Read-Write] When true, the system will attempt to generate an IK Retargeter compatible with the supplied source and target skeletal meshes.
      If the skeletons are successfully characterized, it will align the retarget poses automatically.
      Automatic retargeting is currently limited to common, predefined skeleton types that Unreal knows about (see documentation for full list).
      If you attempt to use a skeletal mesh that is not compatible with a predefined template, warnings will be displayed in the output log and the
      export button will be disabled. In that case, you must supply a custom retargeter asset.
    - ``retarget_asset`` (IKRetargeter):  [Read-Write] You may also supply a custom IK Retargeter if needed.
    - ``source_skeletal_mesh`` (SkeletalMesh):  [Read-Write] The skeletal mesh with the proportions you want to copy animation FROM.
    - ``target_skeletal_mesh`` (SkeletalMesh):  [Read-Write] The skeletal mesh with the proportions you want to copy animation TO.
    """
    @property
    def source_skeletal_mesh(self) -> SkeletalMesh:
        r"""
        (SkeletalMesh):  [Read-Write] The skeletal mesh with the proportions you want to copy animation FROM.
        """
        ...
    @source_skeletal_mesh.setter
    def source_skeletal_mesh(self, value: SkeletalMesh) -> None:
        ...
    @property
    def target_skeletal_mesh(self) -> SkeletalMesh:
        r"""
        (SkeletalMesh):  [Read-Write] The skeletal mesh with the proportions you want to copy animation TO.
        """
        ...
    @target_skeletal_mesh.setter
    def target_skeletal_mesh(self, value: SkeletalMesh) -> None:
        ...
    @property
    def auto_generate_retargeter(self) -> bool:
        r"""
        (bool):  [Read-Write] When true, the system will attempt to generate an IK Retargeter compatible with the supplied source and target skeletal meshes.
        If the skeletons are successfully characterized, it will align the retarget poses automatically.
        Automatic retargeting is currently limited to common, predefined skeleton types that Unreal knows about (see documentation for full list).
        If you attempt to use a skeletal mesh that is not compatible with a predefined template, warnings will be displayed in the output log and the
        export button will be disabled. In that case, you must supply a custom retargeter asset.
        """
        ...
    @auto_generate_retargeter.setter
    def auto_generate_retargeter(self, value: bool) -> None:
        ...
    @property
    def retarget_asset(self) -> IKRetargeter:
        r"""
        (IKRetargeter):  [Read-Write] You may also supply a custom IK Retargeter if needed.
        """
        ...
    @retarget_asset.setter
    def retarget_asset(self, value: IKRetargeter) -> None:
        ...

class IKRetargetAnimInstance(AnimPreviewInstance):
    r"""
    IKRetarget Anim Instance
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: IKRetargetAnimInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    ...

class IKRetargeterController(Object):
    r"""
    A stateless singleton (1-per-asset) class used to make modifications to a UIKRetargeter asset.
    Use UIKRetargeter.GetController() to get the controller for the asset you want to modify.
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: IKRetargeterController.h
    
    """
    def snap_bone_to_ground(self, reference_bone: Name, source_or_target: RetargetSourceOrTarget) -> None:
        r"""
        x.snap_bone_to_ground(reference_bone, source_or_target) -> None
        Moves the entire skeleton vertically until the specified bone is the same height off the ground as in the reference pose.
        
        Args:
            reference_bone (Name): 
            source_or_target (RetargetSourceOrTarget):
        """
        ...
    def set_source_chain(self, source_chain_name: Name, target_chain_name: Name) -> bool:
        r"""
        x.set_source_chain(source_chain_name, target_chain_name) -> bool
        Assign a source chain to the given target chain. Animation will be copied from the source to the target.
        
        Args:
            source_chain_name (Name): 
            target_chain_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def set_rotation_offset_for_retarget_pose_bone(self, bone_name: Name, rotation_offset: Quat, skeleton_mode: RetargetSourceOrTarget) -> None:
        r"""
        x.set_rotation_offset_for_retarget_pose_bone(bone_name, rotation_offset, skeleton_mode) -> None
        Set a delta rotation for a given bone for the current retarget pose
        
        Args:
            bone_name (Name): 
            rotation_offset (Quat): 
            skeleton_mode (RetargetSourceOrTarget):
        """
        ...
    def set_root_settings(self, root_settings: TargetRootSettings) -> None:
        r"""
        x.set_root_settings(root_settings) -> None
        Set the retarget root settings for this asset.
        
        Args:
            root_settings (TargetRootSettings):
        """
        ...
    def set_root_offset_in_retarget_pose(self, translation_offset: Vector, source_or_target: RetargetSourceOrTarget) -> None:
        r"""
        x.set_root_offset_in_retarget_pose(translation_offset, source_or_target) -> None
        Set the translation offset on the retarget root bone for the current retarget pose
        
        Args:
            translation_offset (Vector): 
            source_or_target (RetargetSourceOrTarget):
        """
        ...
    def set_retarget_op_enabled(self, retarget_op_index: int, is_enabled: bool) -> bool:
        r"""
        x.set_retarget_op_enabled(retarget_op_index, is_enabled) -> bool
        Set enabled/disabled status of the given retarget operation.
        
        Args:
            retarget_op_index (int32): 
            is_enabled (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_retarget_chain_settings(self, target_chain_name: Name, settings: TargetChainSettings) -> bool:
        r"""
        x.set_retarget_chain_settings(target_chain_name, settings) -> bool
        Set the settings for the target chain by name. Returns true if the chain settings were applied, false otherwise.
        
        Args:
            target_chain_name (Name): 
            settings (TargetChainSettings): 
        
        Returns:
            bool:
        """
        ...
    def set_preview_mesh(self, source_or_target: RetargetSourceOrTarget, preview_mesh: SkeletalMesh) -> None:
        r"""
        x.set_preview_mesh(source_or_target, preview_mesh) -> None
        Set the preview skeletal mesh for either source or target
        
        Args:
            source_or_target (RetargetSourceOrTarget): 
            preview_mesh (SkeletalMesh):
        """
        ...
    def set_ik_rig(self, source_or_target: RetargetSourceOrTarget, ik_rig: IKRigDefinition) -> None:
        r"""
        x.set_ik_rig(source_or_target, ik_rig) -> None
        Set the IK Rig to use as the source or target (to copy animation FROM/TO)
        
        Args:
            source_or_target (RetargetSourceOrTarget): 
            ik_rig (IKRigDefinition):
        """
        ...
    def set_global_settings(self, global_settings: RetargetGlobalSettings) -> None:
        r"""
        x.set_global_settings(global_settings) -> None
        Get a copy of the global settings for this asset.
        
        Args:
            global_settings (RetargetGlobalSettings):
        """
        ...
    def set_current_retarget_pose(self, current_pose: Name, source_or_target: RetargetSourceOrTarget) -> bool:
        r"""
        x.set_current_retarget_pose(current_pose, source_or_target) -> bool
        Change which retarget pose is used by the retargeter at runtime
        
        Args:
            current_pose (Name): 
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            bool:
        """
        ...
    def reset_retarget_pose(self, pose_to_reset: Name, bones_to_reset: Array[Name], source_or_target: RetargetSourceOrTarget) -> None:
        r"""
        x.reset_retarget_pose(pose_to_reset, bones_to_reset, source_or_target) -> None
        Reset a retarget pose for the specified bones.
        If BonesToReset is Empty, will removes all stored deltas, returning pose to reference pose
        
        Args:
            pose_to_reset (Name): 
            bones_to_reset (Array[Name]): 
            source_or_target (RetargetSourceOrTarget):
        """
        ...
    def rename_retarget_pose(self, old_pose_name: Name, new_pose_name: Name, source_or_target: RetargetSourceOrTarget) -> bool:
        r"""
        x.rename_retarget_pose(old_pose_name, new_pose_name, source_or_target) -> bool
        Rename current retarget pose. Returns true if a pose was renamed.
        
        Args:
            old_pose_name (Name): 
            new_pose_name (Name): 
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            bool:
        """
        ...
    def remove_retarget_pose(self, pose_to_remove: Name, source_or_target: RetargetSourceOrTarget) -> bool:
        r"""
        x.remove_retarget_pose(pose_to_remove, source_or_target) -> bool
        Remove a retarget pose. Returns true if the pose was found and removed.
        
        Args:
            pose_to_remove (Name): 
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            bool:
        """
        ...
    def remove_retarget_op(self, op_index: int) -> bool:
        r"""
        x.remove_retarget_op(op_index) -> bool
        Remove the retarget op at the given stack index.
        
        Args:
            op_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def remove_all_ops(self) -> bool:
        r"""
        x.remove_all_ops() -> bool
        Remove all ops in the stack.
        
        Returns:
            bool:
        """
        ...
    def move_retarget_op_in_stack(self, op_to_move_index: int, target_index: int) -> bool:
        r"""
        x.move_retarget_op_in_stack(op_to_move_index, target_index) -> bool
        Move the retarget op at the given index to the target index.
        
        Args:
            op_to_move_index (int32): 
            target_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_source_chain(self, target_chain_name: Name) -> Name:
        r"""
        x.get_source_chain(target_chain_name) -> Name
        Get the name of the source chain mapped to a given target chain (the chain animation is copied FROM).
        
        Args:
            target_chain_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def get_rotation_offset_for_retarget_pose_bone(self, bone_name: Name, source_or_target: RetargetSourceOrTarget) -> Quat:
        r"""
        x.get_rotation_offset_for_retarget_pose_bone(bone_name, source_or_target) -> Quat
        Get a delta rotation for a given bone for the current retarget pose
        
        Args:
            bone_name (Name): 
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            Quat:
        """
        ...
    def get_root_settings(self) -> TargetRootSettings:
        r"""
        x.get_root_settings() -> TargetRootSettings
        Get a copy of the retarget root settings for this asset.
        
        Returns:
            TargetRootSettings:
        """
        ...
    def get_root_offset_in_retarget_pose(self, source_or_target: RetargetSourceOrTarget) -> Vector:
        r"""
        x.get_root_offset_in_retarget_pose(source_or_target) -> Vector
        Get the translation offset on the retarget root bone for the current retarget pose
        
        Args:
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            Vector:
        """
        ...
    def get_retarget_poses(self, source_or_target: RetargetSourceOrTarget) -> Map[Name, IKRetargetPose]:
        r"""
        x.get_retarget_poses(source_or_target) -> Map[Name, IKRetargetPose]
        Get access to array of retarget poses
        
        Args:
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            Map[Name, IKRetargetPose]:
        """
        ...
    def get_retarget_op_enabled(self, retarget_op_index: int) -> bool:
        r"""
        x.get_retarget_op_enabled(retarget_op_index) -> bool
        Get enabled status of the given Op.
        
        Args:
            retarget_op_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_retarget_op_at_index(self, index: int) -> RetargetOpBase:
        r"""
        x.get_retarget_op_at_index(index) -> RetargetOpBase
        Get access to the given retarget operation.
        
        Args:
            index (int32): 
        
        Returns:
            RetargetOpBase:
        """
        ...
    def get_retarget_chain_settings(self, target_chain_name: Name) -> TargetChainSettings:
        r"""
        x.get_retarget_chain_settings(target_chain_name) -> TargetChainSettings
        Get a copy of the settings for the target chain by name.
        
        Args:
            target_chain_name (Name): 
        
        Returns:
            TargetChainSettings:
        """
        ...
    def get_preview_mesh(self, source_or_target: RetargetSourceOrTarget) -> SkeletalMesh:
        r"""
        x.get_preview_mesh(source_or_target) -> SkeletalMesh
        Get the preview skeletal mesh
        
        Args:
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            SkeletalMesh:
        """
        ...
    def get_num_retarget_ops(self) -> int:
        r"""
        x.get_num_retarget_ops() -> int32
        Get the number of Ops in the stack.
        
        Returns:
            int32:
        """
        ...
    def get_index_of_retarget_op(self, retarget_op: RetargetOpBase) -> int:
        r"""
        x.get_index_of_retarget_op(retarget_op) -> int32
        Get access to the given retarget operation.
        
        Args:
            retarget_op (RetargetOpBase): 
        
        Returns:
            int32:
        """
        ...
    def get_ik_rig(self, source_or_target: RetargetSourceOrTarget) -> IKRigDefinition:
        r"""
        x.get_ik_rig(source_or_target) -> IKRigDefinition
        Get either source or target IK Rig
        
        Args:
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            IKRigDefinition:
        """
        ...
    def get_global_settings(self) -> RetargetGlobalSettings:
        r"""
        x.get_global_settings() -> RetargetGlobalSettings
        Get a copy of the global settings for this asset.
        
        Returns:
            RetargetGlobalSettings:
        """
        ...
    def get_current_retarget_pose_name(self, source_or_target: RetargetSourceOrTarget) -> Name:
        r"""
        x.get_current_retarget_pose_name(source_or_target) -> Name
        Get the current retarget pose
        
        Args:
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            Name:
        """
        ...
    def get_current_retarget_pose(self, source_or_target: RetargetSourceOrTarget) -> IKRetargetPose:
        r"""
        x.get_current_retarget_pose(source_or_target) -> IKRetargetPose
        Get the current retarget pose
        
        Args:
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            IKRetargetPose:
        """
        ...
    @classmethod
    def get_controller(cls, retargeter_asset: IKRetargeter) -> IKRetargeterController:
        r"""
        X.get_controller(retargeter_asset) -> IKRetargeterController
        Use this to get the controller for the given retargeter asset
        
        Args:
            retargeter_asset (IKRetargeter): 
        
        Returns:
            IKRetargeterController:
        """
        ...
    def get_all_chain_settings(self) -> Array[RetargetChainSettings]:
        r"""
        x.get_all_chain_settings() -> Array[RetargetChainSettings]
        Get read-only access to the list of settings for each target chain
        
        Returns:
            Array[RetargetChainSettings]:
        """
        ...
    def duplicate_retarget_pose(self, pose_to_duplicate: Name, new_name: Name, source_or_target: RetargetSourceOrTarget) -> Name:
        r"""
        x.duplicate_retarget_pose(pose_to_duplicate, new_name, source_or_target) -> Name
        Duplicate a retarget pose. Returns the name of the new, duplicate pose (or NAME_None if PoseToDuplicate is not found).
        
        Args:
            pose_to_duplicate (Name): 
            new_name (Name): 
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            Name:
        """
        ...
    def create_retarget_pose(self, new_pose_name: Name, source_or_target: RetargetSourceOrTarget) -> Name:
        r"""
        x.create_retarget_pose(new_pose_name, source_or_target) -> Name
        Add new retarget pose. Returns the name of the new retarget pose.
        
        Args:
            new_pose_name (Name): 
            source_or_target (RetargetSourceOrTarget): 
        
        Returns:
            Name:
        """
        ...
    def auto_map_chains(self, auto_map_type: AutoMapChainType, force_remap: bool) -> None:
        r"""
        x.auto_map_chains(auto_map_type, force_remap) -> None
        Use fuzzy string search to find "best" Source chain to map to each Target chain
        
        Args:
            auto_map_type (AutoMapChainType): 
            force_remap (bool):
        """
        ...
    def auto_align_bones(self, bones_to_align: Array[Name], method: RetargetAutoAlignMethod, source_or_target: RetargetSourceOrTarget) -> None:
        r"""
        x.auto_align_bones(bones_to_align, method, source_or_target) -> None
        Automatically align an array of bones and store in the current retarget pose. Bones not in a mapped chain will be ignored.
        
        Args:
            bones_to_align (Array[Name]): 
            method (RetargetAutoAlignMethod): 
            source_or_target (RetargetSourceOrTarget):
        """
        ...
    def auto_align_all_bones(self, source_or_target: RetargetSourceOrTarget) -> None:
        r"""
        x.auto_align_all_bones(source_or_target) -> None
        Automatically align all bones in mapped chains and store in the current retarget pose.
        
        Args:
            source_or_target (RetargetSourceOrTarget):
        """
        ...
    def add_retarget_op(self, op_class: Class) -> int:
        r"""
        x.add_retarget_op(op_class) -> int32
        Add a new retarget op of the given type to the bottom of the stack. Returns the stack index.
        
        Args:
            op_class (type(Class)): 
        
        Returns:
            int32:
        """
        ...

class IKRetargetFactory(Factory):
    r"""
    IKRetarget Factory
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: IKRetargetFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class IKRigAnimInstance(AnimPreviewInstance):
    r"""
    IKRig Anim Instance
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: IKRigAnimInstance.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``on_all_montage_instances_ended`` (OnAllMontageInstancesEndedMCDelegate):  [Read-Write] Called when all Montage instances have ended.
    - ``on_montage_blended_in`` (OnMontageBlendedInEndedMCDelegate):  [Read-Write] Called when a montage finishes blending in
    - ``on_montage_blending_out`` (OnMontageBlendingOutStartedMCDelegate):  [Read-Write] Called when a montage starts blending out, whether interrupted or finished
    - ``on_montage_ended`` (OnMontageEndedMCDelegate):  [Read-Write] Called when a montage has ended, whether interrupted or finished
    - ``on_montage_started`` (OnMontageStartedMCDelegate):  [Read-Write] Called when a montage has started
    - ``propagate_notifies_to_linked_instances`` (bool):  [Read-Write] Whether to propagate notifies to any linked anim instances
    - ``receive_notifies_from_linked_instances`` (bool):  [Read-Write] Whether to process notifies from any linked anim instances
    - ``root_motion_mode`` (RootMotionMode):  [Read-Write] Sets where this blueprint pulls Root Motion from
    - ``use_main_instance_montage_evaluation_data`` (bool):  [Read-Write] If true, linked instances will use the main instance's montage data. (i.e. playing a montage on a main instance will play it on the linked layer too.)
    """
    ...

class IKRigController(Object):
    r"""
    A singleton (per-asset) class used to make modifications to a UIKRigDefinition asset
    
    All modifications to an IKRigDefinition must go through this controller.
    
    Editors can subscribe to the callbacks on this controller to be notified of changes that require reinitialization
    of a running IK Rig processor instance.
    The API here is split into public/scripting sections which are accessible from Blueprint/Python and sections that
    are only relevant to editors in C++.
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: IKRigController.h
    
    """
    def set_solver_enabled(self, solver_index: int, is_enabled: bool) -> bool:
        r"""
        x.set_solver_enabled(solver_index, is_enabled) -> bool
        Set enabled/disabled status of the given solver.
        
        Args:
            solver_index (int32): 
            is_enabled (bool): 
        
        Returns:
            bool:
        """
        ...
    def set_skeletal_mesh(self, skeletal_mesh: SkeletalMesh) -> bool:
        r"""
        x.set_skeletal_mesh(skeletal_mesh) -> bool
        Sets the preview mesh to use. Loads the hierarchy into the asset's IKRigSkeleton.
        Returns true if the mesh was able to be set. False if it was incompatible for any reason.
        
        Args:
            skeletal_mesh (SkeletalMesh): 
        
        Returns:
            bool:
        """
        ...
    def set_root_bone(self, root_bone_name: Name, solver_index: int) -> bool:
        r"""
        x.set_root_bone(root_bone_name, solver_index) -> bool
        Set the root bone on a given solver. (not all solvers support root bones, checks CanSetRootBone() first)
        
        Args:
            root_bone_name (Name): 
            solver_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_retarget_root(self, root_bone_name: Name) -> bool:
        r"""
        x.set_retarget_root(root_bone_name) -> bool
        Set the Root Bone of the retargeting (can only be one).
        
        Args:
            root_bone_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def set_retarget_chain_start_bone(self, chain_name: Name, start_bone_name: Name) -> bool:
        r"""
        x.set_retarget_chain_start_bone(chain_name, start_bone_name) -> bool
        Set the Start Bone for the given Chain. Returns true if operation was successful.
        
        Args:
            chain_name (Name): 
            start_bone_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def set_retarget_chain_goal(self, chain_name: Name, goal_name: Name) -> bool:
        r"""
        x.set_retarget_chain_goal(chain_name, goal_name) -> bool
        Set the Goal for the given Chain. Returns true if operation was successful.
        
        Args:
            chain_name (Name): 
            goal_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def set_retarget_chain_end_bone(self, chain_name: Name, end_bone_name: Name) -> bool:
        r"""
        x.set_retarget_chain_end_bone(chain_name, end_bone_name) -> bool
        Set the End Bone for the given Chain. Returns true if operation was successful.
        
        Args:
            chain_name (Name): 
            end_bone_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def set_goal_bone(self, goal_name: Name, new_bone_name: Name) -> bool:
        r"""
        x.set_goal_bone(goal_name, new_bone_name) -> bool
        The the Bone that the given Goal should be parented to / associated with.
        
        Args:
            goal_name (Name): 
            new_bone_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def set_end_bone(self, end_bone_name: Name, solver_index: int) -> bool:
        r"""
        x.set_end_bone(end_bone_name, solver_index) -> bool
        Set the end bone on a given solver. (not all solvers require extra end bones, checks CanSetEndBone() first)
        
        Args:
            end_bone_name (Name): 
            solver_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def set_bone_excluded(self, bone_name: Name, exclude: bool) -> bool:
        r"""
        x.set_bone_excluded(bone_name, exclude) -> bool
        Include/exclude a bone from all the solvers. All bones are included by default.
        
        Args:
            bone_name (Name): 
            exclude (bool): 
        
        Returns:
            bool:
        """
        ...
    def rename_retarget_chain(self, chain_name: Name, new_chain_name: Name) -> Name:
        r"""
        x.rename_retarget_chain(chain_name, new_chain_name) -> Name
        Renamed the given Chain. Returns the new name (same as old if unsuccessful).
        
        Args:
            chain_name (Name): 
            new_chain_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def rename_goal(self, old_name: Name, potential_new_name: Name) -> Name:
        r"""
        x.rename_goal(old_name, potential_new_name) -> Name
        Rename a Goal. Returns new name, which may be different after being sanitized. Returns NAME_None if this fails.
        
        Args:
            old_name (Name): 
            potential_new_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def remove_solver(self, solver_index: int) -> bool:
        r"""
        x.remove_solver(solver_index) -> bool
        Remove the solver at the given stack index.
        
        Args:
            solver_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def remove_retarget_chain(self, chain_name: Name) -> bool:
        r"""
        x.remove_retarget_chain(chain_name) -> bool
        Remove a Chain with the given name. Returns true if a Chain was removed.
        
        Args:
            chain_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def remove_goal(self, goal_name: Name) -> bool:
        r"""
        x.remove_goal(goal_name) -> bool
        Remove the Goal by name.
        
        Args:
            goal_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def remove_bone_setting(self, bone_name: Name, solver_index: int) -> bool:
        r"""
        x.remove_bone_setting(bone_name, solver_index) -> bool
        Remove settings for the given Bone/Solver. Does nothing if Bone doesn't have setting in this Solver.
        
        Args:
            bone_name (Name): 
            solver_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def move_solver_in_stack(self, solver_to_move_index: int, target_solver_index: int) -> bool:
        r"""
        x.move_solver_in_stack(solver_to_move_index, target_solver_index) -> bool
        Move the solver at the given index to the target index.
        
        Args:
            solver_to_move_index (int32): 
            target_solver_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def is_skeletal_mesh_compatible(self, skeletal_mesh_to_check: SkeletalMesh) -> bool:
        r"""
        x.is_skeletal_mesh_compatible(skeletal_mesh_to_check) -> bool
        Returns true if the provided skeletal mesh could be used with this IK Rig.
        
        Args:
            skeletal_mesh_to_check (SkeletalMesh): 
        
        Returns:
            bool:
        """
        ...
    def is_goal_connected_to_solver(self, goal_name: Name, solver_index: int) -> bool:
        r"""
        x.is_goal_connected_to_solver(goal_name, solver_index) -> bool
        Returns true if the given Goal is connected to the given Solver. False otherwise.
        
        Args:
            goal_name (Name): 
            solver_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def is_goal_connected_to_any_solver(self, goal_name: Name) -> bool:
        r"""
        x.is_goal_connected_to_any_solver(goal_name) -> bool
        Returns true if the given Goal is connected to ANY solver. False otherwise.
        
        Args:
            goal_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def get_solver_enabled(self, solver_index: int) -> bool:
        r"""
        x.get_solver_enabled(solver_index) -> bool
        Get enabled status of the given solver.
        
        Args:
            solver_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def get_solver_at_index(self, index: int) -> IKRigSolver:
        r"""
        x.get_solver_at_index(index) -> IKRigSolver
        Get access to the given solver.
        
        Args:
            index (int32): 
        
        Returns:
            IKRigSolver:
        """
        ...
    def get_skeletal_mesh(self) -> SkeletalMesh:
        r"""
        x.get_skeletal_mesh() -> SkeletalMesh
        Get the skeletal mesh this asset is initialized with
        
        Returns:
            SkeletalMesh:
        """
        ...
    def get_root_bone(self, solver_index: int) -> Name:
        r"""
        x.get_root_bone(solver_index) -> Name
        Get the name of the root bone on a given solver. (not all solvers support root bones, checks CanSetRootBone() first)
        
        Args:
            solver_index (int32): 
        
        Returns:
            Name:
        """
        ...
    def get_retarget_root(self) -> Name:
        r"""
        x.get_retarget_root() -> Name
        Get the name of the Root Bone of the retargeting (can only be one).
        
        Returns:
            Name:
        """
        ...
    def get_retarget_chain_start_bone(self, chain_name: Name) -> Name:
        r"""
        x.get_retarget_chain_start_bone(chain_name) -> Name
        Get the End Bone name for the given Chain.
        
        Args:
            chain_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def get_retarget_chains(self) -> Array[BoneChain]:
        r"""
        x.get_retarget_chains() -> Array[BoneChain]
        Get read-only access to the list of Chains.
        
        Returns:
            Array[BoneChain]:
        """
        ...
    def get_retarget_chain_goal(self, chain_name: Name) -> Name:
        r"""
        x.get_retarget_chain_goal(chain_name) -> Name
        Get the Goal name for the given Chain.
        
        Args:
            chain_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def get_retarget_chain_end_bone(self, chain_name: Name) -> Name:
        r"""
        x.get_retarget_chain_end_bone(chain_name) -> Name
        Get the Start Bone name for the given Chain.
        
        Args:
            chain_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def get_ref_pose_transform_of_bone(self, bone_name: Name) -> Transform:
        r"""
        x.get_ref_pose_transform_of_bone(bone_name) -> Transform
        Get the global-space retarget pose transform of the given Bone.
        
        Args:
            bone_name (Name): 
        
        Returns:
            Transform:
        """
        ...
    def get_num_solvers(self) -> int:
        r"""
        x.get_num_solvers() -> int32
        Get the number of solvers in the stack.
        
        Returns:
            int32:
        """
        ...
    def get_index_of_solver(self, solver: IKRigSolver) -> int:
        r"""
        x.get_index_of_solver(solver) -> int32
        Get access to the given solver.
        
        Args:
            solver (IKRigSolver): 
        
        Returns:
            int32:
        """
        ...
    def get_goal_settings_for_solver(self, goal_name: Name, solver_index: int) -> Object:
        r"""
        x.get_goal_settings_for_solver(goal_name, solver_index) -> Object
        Get the UObject for the settings associated with the given Goal in the given Solver.
        Solvers can define their own per-Goal settings depending on their needs. These are termed "Effectors".
        
        Args:
            goal_name (Name): 
            solver_index (int32): 
        
        Returns:
            Object:
        """
        ...
    def get_goal_name_for_bone(self, bone_name: Name) -> Name:
        r"""
        x.get_goal_name_for_bone(bone_name) -> Name
        Get the Goal associated with the given Bone (may be NAME_None)
        
        Args:
            bone_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def get_goal(self, goal_name: Name) -> IKRigEffectorGoal:
        r"""
        x.get_goal(goal_name) -> IKRigEffectorGoal
        Get read-write access to the Goal with the given name.
        
        Args:
            goal_name (Name): 
        
        Returns:
            IKRigEffectorGoal:
        """
        ...
    def get_end_bone(self, solver_index: int) -> Name:
        r"""
        x.get_end_bone(solver_index) -> Name
        Get the name of the end bone on a given solver. (not all solvers require extra end bones, checks CanSetEndBone() first)
        
        Args:
            solver_index (int32): 
        
        Returns:
            Name:
        """
        ...
    @classmethod
    def get_controller(cls, ik_rig_definition: IKRigDefinition) -> IKRigController:
        r"""
        X.get_controller(ik_rig_definition) -> IKRigController
        Use this to get the controller for the given IKRig
        
        Args:
            ik_rig_definition (IKRigDefinition): 
        
        Returns:
            IKRigController:
        """
        ...
    def get_bone_settings(self, bone_name: Name, solver_index: int) -> Object:
        r"""
        x.get_bone_settings(bone_name, solver_index) -> Object
        Get the generic (Solver-specific) Bone settings UObject for this Bone in the given Solver.
        
        Args:
            bone_name (Name): 
            solver_index (int32): 
        
        Returns:
            Object:
        """
        ...
    def get_bone_for_goal(self, goal_name: Name) -> Name:
        r"""
        x.get_bone_for_goal(goal_name) -> Name
        The the Bone associated with the given Goal.
        
        Args:
            goal_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def get_bone_excluded(self, bone_name: Name) -> bool:
        r"""
        x.get_bone_excluded(bone_name) -> bool
        Returns true if the given Bone is excluded, false otherwise.
        
        Args:
            bone_name (Name): 
        
        Returns:
            bool:
        """
        ...
    def get_all_goals(self) -> Array[IKRigEffectorGoal]:
        r"""
        x.get_all_goals() -> Array[IKRigEffectorGoal]
        Get access to the list of Goals.
        
        Returns:
            Array[IKRigEffectorGoal]:
        """
        ...
    def disconnect_goal_from_solver(self, goal_to_remove: Name, solver_index: int) -> bool:
        r"""
        x.disconnect_goal_from_solver(goal_to_remove, solver_index) -> bool
        Disconnect the given Goal from the given Solver. This removes the Effector that associates the Goal with the Solver.
        
        Args:
            goal_to_remove (Name): 
            solver_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def connect_goal_to_solver(self, goal_name: Name, solver_index: int) -> bool:
        r"""
        x.connect_goal_to_solver(goal_name, solver_index) -> bool
        Connect the given Goal to the given Solver. This creates an "Effector" with settings specific to this Solver.
        
        Args:
            goal_name (Name): 
            solver_index (int32): 
        
        Returns:
            bool:
        """
        ...
    def apply_auto_generated_retarget_definition(self) -> bool:
        r"""
        x.apply_auto_generated_retarget_definition() -> bool
        Analyse the skeleton to see if it matches a known template and automatically generates all retarget chains and sets the retarget root
        Returns true if a matching skeletal template was found and the retarget definition for it was applied.
        
        Returns:
            bool:
        """
        ...
    def apply_auto_fbik(self) -> bool:
        r"""
        x.apply_auto_fbik() -> bool
        Analyse the skeleton to see if it matches a known template and automatically generates a full body IK setup
        Returns true if a matching skeletal template was found and the FBIK setup for it was applied.
        
        Returns:
            bool:
        """
        ...
    def add_solver(self, solver_class: Class) -> int:
        r"""
        x.add_solver(solver_class) -> int32
        Add a new solver of the given type to the bottom of the stack. Returns the stack index.
        
        Args:
            solver_class (type(Class)): 
        
        Returns:
            int32:
        """
        ...
    def add_retarget_chain(self, chain_name: Name, start_bone_name: Name, end_bone_name: Name, goal_name: Name) -> Name:
        r"""
        x.add_retarget_chain(chain_name, start_bone_name, end_bone_name, goal_name) -> Name
        Add a new chain with the given Chain and Bone names. Returns newly created chain name (uniquified).
        Note: only the ChainName is required here, all else can be set later.
        
        Args:
            chain_name (Name): 
            start_bone_name (Name): 
            end_bone_name (Name): 
            goal_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def add_new_goal(self, goal_name: Name, bone_name: Name) -> Name:
        r"""
        x.add_new_goal(goal_name, bone_name) -> Name
        Add a new Goal associated with the given Bone. GoalName must be unique. Bones can have multiple Goals (rare).
        
        Args:
            goal_name (Name): 
            bone_name (Name): 
        
        Returns:
            Name:
        """
        ...
    def add_bone_setting(self, bone_name: Name, solver_index: int) -> bool:
        r"""
        x.add_bone_setting(bone_name, solver_index) -> bool
        Add settings to the given Bone/Solver. Does nothing if Bone already has settings in this Solver.
        
        Args:
            bone_name (Name): 
            solver_index (int32): 
        
        Returns:
            bool:
        """
        ...

class IKRigDefinitionFactory(Factory):
    r"""
    IKRig Definition Factory
    
    **C++ Source:**
    
    - **Plugin**: IKRig
    - **Module**: IKRigEditor
    - **File**: IKRigDefinitionFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class LandscapeLayerInfoObjectFactory(Factory):
    r"""
    Landscape Layer Info Object Factory
    
    **C++ Source:**
    
    - **Module**: LandscapeEditor
    - **File**: LandscapeLayerInfoObjectFactory.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``asset_import_task`` (AssetImportTask):  [Read-Write] Task for importing file via script interfaces
    - ``automated_import_data`` (AutomatedAssetImportData):  [Read-Write] Data for how to import files via the automated command line importing interface
    - ``context_class`` (type(Class)):  [Read-Write] Class of the context object used to help create the object.
    - ``create_new`` (bool):  [Read-Write] The default value to return from CanCreateNew()
    - ``edit_after_new`` (bool):  [Read-Write] true if the associated editor should be opened after creating a new object.
    - ``editor_import`` (bool):  [Read-Write] true if the factory imports objects from files.
    - ``formats`` (Array[str]):  [Read-Write] List of formats supported by the factory. Each entry is of the form "ext;Description" where ext is the file extension.
    - ``supported_class`` (type(Class)):  [Read-Write] The class manufactured by this factory.
    - ``text`` (bool):  [Read-Write] true if the factory imports objects from text.
    """
    ...

class LandscapePlaceholder(Actor):
    r"""
    Landscape Placeholder
    
    **C++ Source:**
    
    - **Module**: LandscapeEditor
    - **File**: LandscapePlaceholder.h
    
    **Editor Properties:** (see get_editor_property/set_editor_property)
    
    - ``actor_guid`` (Guid):  [Read-Write] The GUID for this actor; this guid will be the same for actors from instanced streaming levels.
      see: ActorInstanceGuid, FActorInstanceGuidMapper
      note: Don't use VisibleAnywhere here to avoid getting the CPF_Edit flag and get this property reset when resetting to defaults. See FActorDetails::AddActorCategory and EditorUtilities::CopySingleProperty for details.
    - ``actor_instance_guid`` (Guid):  [Read-Write] The instance GUID for this actor; this guid will be unique for actors from instanced streaming levels.
      see: ActorGuid
      note: This is not guaranteed to be valid during PostLoad, but safe to access from RegisterAllComponents.
    - ``allow_tick_before_begin_play`` (bool):  [Read-Write] Whether we allow this Actor to tick before it receives the BeginPlay event.
      Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden.
      This Actor must be able to tick for this setting to be relevant.
    - ``always_relevant`` (bool):  [Read-Write] Always relevant for network (overrides bOnlyRelevantToOwner).
    - ``async_physics_tick_enabled`` (bool):  [Read-Write] Whether to use use the async physics tick with this actor.
    - ``auto_destroy_when_finished`` (bool):  [Read-Write] If true then destroy self when "finished", meaning all relevant components report that they are done and no timelines or timers are in flight.
    - ``auto_receive_input`` (AutoReceiveInput):  [Read-Write] Automatically registers this actor to receive input from a player.
    - ``block_input`` (bool):  [Read-Write] If true, all input on the stack below this actor will not be considered
    - ``call_pre_replication`` (bool):  [Read-Write]
    - ``call_pre_replication_for_replay`` (bool):  [Read-Write]
    - ``can_be_damaged`` (bool):  [Read-Write] Whether this actor can take damage. Must be true for damage events (e.g. ReceiveDamage()) to be called.
      see: https://www.unrealengine.com/blog/damage-in-ue4
      see: TakeDamage(), ReceiveDamage()
    - ``can_be_in_cluster`` (bool):  [Read-Write] If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
    - ``content_bundle_guid`` (Guid):  [Read-Write] The GUID for this actor's content bundle.
    - ``custom_time_dilation`` (float):  [Read-Write] Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
    - ``data_layer_assets`` (Array[DataLayerAsset]):  [Read-Write]
    - ``data_layers`` (Array[ActorDataLayer]):  [Read-Only] DataLayers the actor belongs to.
    - ``default_update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Only] Default value taken from config file for this class when 'UseConfigDefault' is chosen for
      'UpdateOverlapsMethodDuringLevelStreaming'. This allows a default to be chosen per class in the matching config.
      For example, for Actor it could be specified in DefaultEngine.ini as:
      
      [/Script/Engine.Actor]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = OnlyUpdateMovable
      
      Another subclass could set their default to something different, such as:
      
      [/Script/Engine.BlockingVolume]
      DefaultUpdateOverlapsMethodDuringLevelStreaming = NeverUpdate
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``enable_auto_lod_generation`` (bool):  [Read-Write] Whether this actor should be considered or not during HLOD generation.
    - ``external_data_layer_asset`` (ExternalDataLayerAsset):  [Read-Only]
    - ``find_camera_component_when_view_target`` (bool):  [Read-Write] If true, this actor should search for an owned camera component to view through when used as a view target.
    - ``generate_overlap_events_during_level_streaming`` (bool):  [Read-Write] If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load.
      You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
      see: UpdateOverlapsMethodDuringLevelStreaming
    - ``hidden`` (bool):  [Read-Write] Allows us to only see this Actor in the Editor, and not in the actual game.
      see: SetActorHiddenInGame()
    - ``hlod_layer`` (HLODLayer):  [Read-Write] The UHLODLayer in which this actor should be included.
    - ``ignores_origin_shifting`` (bool):  [Read-Write] Whether this actor should not be affected by world origin shifting.
    - ``initial_life_span`` (float):  [Read-Write] How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
    - ``input_priority`` (int32):  [Read-Write] The priority of this input component when pushed in to the stack.
    - ``instigator`` (Pawn):  [Read-Write] Pawn responsible for damage and other gameplay events caused by this actor.
    - ``is_editor_only_actor`` (bool):  [Read-Write] Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
    - ``is_main_world_only`` (bool):  [Read-Write] If checked, this Actor will only get loaded in a main world (persistent level), it will not be loaded through Level Instances.
    - ``is_spatially_loaded`` (bool):  [Read-Write] Determine if this actor is spatially loaded when placed in a partitioned world.
           If true, this actor will be loaded when in the range of any streaming sources and if (1) in no data layers, or (2) one or more of its data layers are enabled.
           If false, this actor will be loaded if (1) in no data layers, or (2) one or more of its data layers are enabled.
    - ``layers`` (Array[Name]):  [Read-Write] Layers the actor belongs to.  This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
    - ``min_net_update_frequency`` (float):  [Read-Write] Used to determine what rate to throttle down to when replicated properties are changing infrequently
    - ``net_cull_distance_squared`` (float):  [Read-Write] Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
    - ``net_dormancy`` (NetDormancy):  [Read-Write] Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
    - ``net_load_on_client`` (bool):  [Read-Write] This actor will be loaded on network clients during map load
    - ``net_priority`` (float):  [Read-Write] Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
    - ``net_update_frequency`` (float):  [Read-Write] How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
    - ``net_use_owner_relevancy`` (bool):  [Read-Write] If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
    - ``on_actor_begin_overlap`` (ActorBeginOverlapSignature):  [Read-Write] Called when another actor begins to overlap this actor, for example a player walking into a trigger.
      For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_end_overlap`` (ActorEndOverlapSignature):  [Read-Write] Called when another actor stops overlapping this actor.
      note: Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.
    - ``on_actor_hit`` (ActorHitSignature):  [Read-Write] Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation.
      For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
      note: For collisions during physics simulation to generate hit events, 'Simulation Generates Hit Events' must be enabled.
    - ``on_begin_cursor_over`` (ActorBeginCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
    - ``on_clicked`` (ActorOnClickedSignature):  [Read-Write] Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_destroyed`` (ActorDestroyedSignature):  [Read-Write] Event triggered when the actor has been explicitly destroyed.
    - ``on_end_cursor_over`` (ActorEndCursorOverSignature):  [Read-Write] Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
    - ``on_end_play`` (ActorEndPlaySignature):  [Read-Write] Event triggered when the actor is being deleted or removed from a level.
    - ``on_input_touch_begin`` (ActorOnInputTouchBeginSignature):  [Read-Write] Called when a touch input is received over this actor when touch events are enabled in the player controller.
    - ``on_input_touch_end`` (ActorOnInputTouchEndSignature):  [Read-Write] Called when a touch input is received over this component when touch events are enabled in the player controller.
    - ``on_input_touch_enter`` (ActorBeginTouchOverSignature):  [Read-Write] Called when a finger is moved over this actor when touch over events are enabled in the player controller.
    - ``on_input_touch_leave`` (ActorEndTouchOverSignature):  [Read-Write] Called when a finger is moved off this actor when touch over events are enabled in the player controller.
    - ``on_released`` (ActorOnReleasedSignature):  [Read-Write] Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
    - ``on_take_any_damage`` (TakeAnyDamageSignature):  [Read-Write] Called when the actor is damaged in any way.
    - ``on_take_point_damage`` (TakePointDamageSignature):  [Read-Write] Called when the actor is damaged by point damage.
    - ``on_take_radial_damage`` (TakeRadialDamageSignature):  [Read-Write] Called when the actor is damaged by radial damage.
    - ``only_relevant_to_owner`` (bool):  [Read-Write] If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
    - ``optimize_bp_component_data`` (bool):  [Read-Write] Whether to cook additional data to speed up spawn events at runtime for any Blueprint classes based on this Actor. This option may slightly increase memory usage in a cooked build.
    - ``physics_replication_mode`` (PhysicsReplicationMode):  [Read-Write] Which mode to replicate physics through for this actor. Only relevant if the actor replicates movement and has a component that simulate physics.
    - ``pivot_offset`` (Vector):  [Read-Write] Local space pivot offset for the actor, only used in the editor
    - ``primary_actor_tick`` (ActorTickFunction):  [Read-Write] Primary Actor tick function, which calls TickActor().
      Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
      see: https://docs.unrealengine.com/API/Runtime/Engine/Engine/FTickFunction
      see: AddTickPrerequisiteActor(), AddTickPrerequisiteComponent()
    - ``relevant_for_level_bounds`` (bool):  [Read-Write] If true, this actor's component's bounds will be included in the level's
      bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
    - ``remote_role`` (NetRole):  [Read-Only] Describes how much control the remote machine has over the actor.
    - ``replay_rewindable`` (bool):  [Read-Write] If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed.
      Otherwise, RewindForReplay will be called if we detect the actor needs to be reset.
      Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
    - ``replicate_movement`` (bool):  [Read-Write] If true, replicate movement/location related properties.
      Actor must also be set to replicate.
      see: SetReplicates()
      see: https://docs.unrealengine.com/InteractiveExperiences/Networking/Actors
    - ``replicate_using_registered_sub_object_list`` (bool):  [Read-Write] When true the replication system will only replicate the registered subobjects and the replicated actor components list
      When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
    - ``replicated_movement`` (RepMovement):  [Read-Write] Used for replication of our RootComponent's position and velocity
    - ``replicates`` (bool):  [Read-Write] If true, this actor will replicate to remote machines
      see: SetReplicates()
    - ``role`` (NetRole):  [Read-Only] Describes how much control the local machine has over the actor.
    - ``root_component`` (SceneComponent):  [Read-Write] The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
    - ``runtime_grid`` (Name):  [Read-Write] Determine in which partition grid this actor will be placed in the partition (if the world is partitioned).
      If None, the decision will be left to the partition.
    - ``spawn_collision_handling_method`` (SpawnActorCollisionHandlingMethod):  [Read-Write] Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
    - ``sprite_scale`` (float):  [Read-Write] The scale to apply to any billboard components in editor builds (happens in any WITH_EDITOR build, including non-cooked games).
    - ``tags`` (Array[Name]):  [Read-Write] Array of tags that can be used for grouping and categorizing.
    - ``update_overlaps_method_during_level_streaming`` (ActorUpdateOverlapsMethod):  [Read-Write] Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming.
      If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used.
      If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it,
      and overlap events may only come in once one of those objects update overlaps themselves (for example when moving).
      However if an object touching it *does* initialize state, both objects will know about their touching state with each other.
      This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially
      overlapping it do not need the overlap state because they will not trigger overlap notifications.
      
      Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag
      determines whether the Begin/End overlap events are triggered.
      see: bGenerateOverlapEventsDuringLevelStreaming, DefaultUpdateOverlapsMethodDuringLevelStreaming, GetUpdateOverlapsMethodDuringLevelStreaming()
    """
    ...

class add_controls_for_selected_options(Object):
    r"""
    Custom class for RigControlElement creation settings
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class add_controls_for_selected(ToolMenuEntryScript):
    r"""
    
        Custom Tool Menu Entry for RigControlElement creation
    
        Each override function will have a required context arg which will be used to find the
        specific ControlRigContextMenuContext, which will give the proper Control Rig in context.   
        
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class add_null_above_selected(ToolMenuEntryScript):
    r"""
    
        Custom Tool Menu Entry for RigNullElement creation
    
        Each override function will have a required context arg which will be used to find the
        specific ControlRigContextMenuContext, which will give the proper Control Rig in context.   
        
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class align_translation_rotation(ToolMenuEntryScript):
    r"""
    
        Custom Tool Menu Entry for RigControlElement Translation/Rotation alignment
    
        Each override function will have a required context arg which will be used to find the
        specific ControlRigContextMenuContext, which will give the proper Control Rig in context.   
        
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class align_translation_all(ToolMenuEntryScript):
    r"""
    
        Custom Tool Menu Entry for RigControlElement Translation alignment
    
        Each override function will have a required context arg which will be used to find the
        specific ControlRigContextMenuContext, which will give the proper Control Rig in context.   
        
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class align_translation_x(ToolMenuEntryScript):
    r"""
    
        Custom Tool Menu Entry for RigControlElement Translation X alignment
    
        Each override function will have a required context arg which will be used to find the
        specific ControlRigContextMenuContext, which will give the proper Control Rig in context.   
        
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class align_translation_y(ToolMenuEntryScript):
    r"""
    
        Custom Tool Menu Entry for RigControlElement Translation Y alignment
    
        Each override function will have a required context arg which will be used to find the
        specific ControlRigContextMenuContext, which will give the proper Control Rig in context.   
        
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class align_translation_z(ToolMenuEntryScript):
    r"""
    
        Custom Tool Menu Entry for RigControlElement Translation Z alignment
    
        Each override function will have a required context arg which will be used to find the
        specific ControlRigContextMenuContext, which will give the proper Control Rig in context.   
        
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class align_rotation(ToolMenuEntryScript):
    r"""
    
        Custom Tool Menu Entry for RigControlElement Rotation alignment
    
        Each override function will have a required context arg which will be used to find the
        specific ControlRigContextMenuContext, which will give the proper Control Rig in context.   
        
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class align_scale(ToolMenuEntryScript):
    r"""
    
        Custom Tool Menu Entry for RigControlElement Scale alignment
    
        Each override function will have a required context arg which will be used to find the
        specific ControlRigContextMenuContext, which will give the proper Control Rig in context.   
        
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class search_replace_name_dialog(Object):
    r"""
    Custom class for RigControlElement creation settings
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class search_replace_entry(ToolMenuEntryScript):
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class add_prefix_dialog(Object):
    r"""
    Custom class for RigControlElement creation settings
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class add_prefix_entry(ToolMenuEntryScript):
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class add_suffix_dialog(Object):
    r"""
    Custom class for RigControlElement creation settings
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class add_suffix_entry(ToolMenuEntryScript):
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class do_rename_dialog(Object):
    r"""
    Custom class for RigControlElement creation settings
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class do_rename_entry(ToolMenuEntryScript):
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class set_bone_reference_pose(ToolMenuEntryScript):
    r"""
    
        Custom Tool Menu Entry for RigControlElement creation
    
        Each override function will have a required context arg which will be used to find the
        specific ControlRigContextMenuContext, which will give the proper Control Rig in context.   
        
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

class import_ik_rig_options(Object):
    r"""
    Custom class for IK Rig import settings
    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        ...
    @property
    def __dict__(self):
        r"""
        dictionary for instance variables
        """
        ...
    @__dict__.setter
    def __dict__(self, value) -> None:
        ...
    @property
    def __weakref__(self):
        r"""
        list of weak references to the object
        """
        ...
    @__weakref__.setter
    def __weakref__(self, value) -> None:
        ...

##### Additional Code #####

# Copyright Epic Games, Inc. All Rights Reserved.


# Adapts the UE log system to be usable as a Python Buffered IO.
class _Logger(_io.BufferedIOBase):
    def __init__(self, encoding, log_func, flush_func):
        self.encoding = encoding
        self.log_func = log_func
        self.flush_func = flush_func
    def writable(self):
        return True
    def write(self, b):
        self.log_func(b.decode(self.encoding))
    def flush(self):
        self.flush_func()
    def detach(self):
        raise io.UnsupportedOperation("Not detachable")
    def close(self):
        raise io.UnsupportedOperation("Not closable")

# Some Python libraries assume 'incorrectly' that sys.stdout has a 'buffer' attribute because stdout commonly has one through the
# io.TextIOWrapper class. To make the integration of third party libraries with the engine as frictionless as possible, the UE log system
# is adapted to interface with the TextIOWrapper. If PYTHONUNBUFFERED is set, the payload of any call to sys.stdout/sys.stderr is immediately
# sent to UE log system. In general though, the payload is buffered, up to an end line. Note that print(), unless specified, adds an end line
# and the payload is directly sent to UE log system. Some libraries might call sys.stdout.write() several times without adding a new line to
# accumulate in the stdout buffer and then call stdout.flush() later on.
_unbuffered_stdout = _os.environ.get('PYTHONUNBUFFERED') != None and _os.environ.get('PYTHONUNBUFFERED') != ''
_sys.stdout = _io.TextIOWrapper(_Logger('utf-8', log, log_flush), encoding='utf-8', line_buffering=True, write_through=_unbuffered_stdout)
_sys.stderr = _io.TextIOWrapper(_Logger('utf-8', log_error, log_flush), encoding='utf-8', line_buffering=True, write_through=_unbuffered_stdout)

def _redirect_warning(message, category, filename, lineno, file=None, line=None):
    log_warning(_warnings.formatwarning(message, category, filename, lineno))
_warnings.showwarning = _redirect_warning

# On Mac/Linux, the Python and SSL libraries are built by Epic. Normally, when we run 'make install' for the SSL
# library, the installer copies the default certificates (.pem file) in the install folder where SSL expects them. But
# in UE, we copy the SSL lib and the certificates are not 'installed' where SSL expects them. If the user doesn't configure
# where to find the SSL certificates, Python will try to find the SSL default location and will likely fail. Python can use
# the SSL certificates from the 'certifi' package, which are from Mozilla. It turns out that UE also ships the '.pem' coming
# from Mozilla in Engine\Content\Certificates\ThirdParty\cacert.pem. As a convenience for users, we set up Python to use the
# certificates distributed with the Engine. Note that if the default certificates UE provides are not adequate, the user can
# set SSL_CERT_FILE enviroment variable or directly set the ones to use when calling 'ssl.create_default_context(...)'
if _os.name == 'posix': # os.name is faster than platform.system() saving about ~100 ms at boot time.
    # If the default path to the certificates doesn't exist and user didn't configure the corresponding environment variable.
    cert_file_env = 'SSL_CERT_FILE'
    if not _os.path.exists(_ssl.get_default_verify_paths().openssl_cafile) and cert_file_env not in _os.environ:
        script_dir = _os.path.dirname(_os.path.abspath(__file__))
        rel_path = _os.path.join(script_dir, '..', '..', '..', '..', '..', 'Content', 'Certificates', 'ThirdParty', 'cacert.pem')
        _os.environ[cert_file_env] = _os.path.normpath(rel_path)

def uclass():
    '''decorator used to define UClass types from Python'''
    def _uclass(type):
        generate_class(type)
        return type
    return _uclass
    
def ustruct():
    '''decorator used to define UStruct types from Python'''
    def _ustruct(type):
        generate_struct(type)
        return type
    return _ustruct
    
def uenum():
    '''decorator used to define UEnum types from Python'''
    def _uenum(type):
        generate_enum(type)
        return type
    return _uenum

def uvalue(val, meta=None):
    '''function used to define constant values from Python'''
    return ValueDef(val, meta)
    
def uproperty(type, meta=None, getter=None, setter=None):
    '''function used to define UProperty fields from Python'''
    return PropertyDef(type, meta, getter, setter)

def ufunction(meta=None, ret=None, params=None, override=None, static=None, pure=None, getter=None, setter=None):
    '''decorator used to define UFunction fields from Python'''
    def _ufunction(func):
        return FunctionDef(func, meta, ret, params, override, static, pure, getter, setter)
    return _ufunction


